@NathanMerrill I think that I will need to implement a custom map, or maybe use the GraphMap. Maybe use MultiTournament for player selection and IteratedGame as the base impl. Do you think these choices would be correct?

@JAtkin woah, you are understanding stuff way more than I expected :P

I guess that is a yes :) But really those are just guesses. I really don't understand them :) I was looking for the example project you mentioned on the meta post, but it seems to be removed.

yeah, sorry, its out of date, and I've improved the process since then, so you don't really need an example project to get started

you actually want an AdjacencyBoundedMap

You don't want a MultiTournment

multi tournaments combine multiple tournaments into a single tournament

So the AdjacencyBoundedMap has two primary features: It accepts a Neighborhood, which basically says "Which points are next to what points". In your example, you are using the VonNeumann neighborhood

(Aka, a square is adjacent to the 4 squares next to it)

The other part is the bounds, which defines the map limits

which is a square bounds, of whatever size you'll set it too

@JAtkin is that making any sense?

Yeah, it is (sorry about the wait, I was called away from the computer for a bit). What do you think the performance hit will be vs a 2d array of pixel objects?

Sorry, got to go again. I'll be back in about 45 minutes if you are still available. Thanks for the help!

@JAtkin First off, if you are making this a multi-language thing, then don't worry about performance: the communication will be the slowest part of your controller

that said, my AdjacencyBoundedMap does have a slight performance hit because I make out of bounds checks, but I use a collections library called Eclipse Collections which is really efficient

you will save on memory (as I only save locations when you need them), but I don't think that matters that much either

As far as the tournament is concerned: I'd either recommend putting a fixed number of players (like 10 or so), or putting all players on the map

I don't think it really matters which one you choose, but maybe it will

anyways, either way, you want the Sampling tournament

it selects the players randomly

I'm thinking that I'll make it multi-language, but only as a last resort if the user doesn't know java. Hopefully the posts will be primarily in java.

BTW I've put up a bare project up on github

github.com/JJ-Atkinson/splix-controller-ppcg

awesome

so, a couple of other questions: Are you going to be running a fixed number of iterations? Until all other players die? (with a potential maximum?)

I think that I will run a bunch of rounds and sum the score of each round (or maybe average, whichever works best) (average may be better if players are chosen randomly). The round will have a set number of moves (200+) and after those moves are completed the game is frozen and the points are tallied. I think that each bot will appear on a board multiple times, instead of giving them multiple lives. Is that possible?

so, terminology: a round is a Game in KoTHComm

yes, you can have multiple Submissions in a single game (each instance is called a Player)

so, you'd instantiate however many Players you want, and put them all in a game

Ok, I think I understand now.

as far as score aggregation is concerened, both Sum and Average are easy (and equivalent). I actually support more than those, and it can have a lot of effect on the outcomes, so its something worth thinking about

is there any reason you want to have multiple instances of the same bot in a single game?

I may have misunderstood the Sampling tournament, you said random. Does that mean that each player appears in the same number of games and which game they run in is random, or that everything is random?

it'll be roughly the same number of games

Ok

basically, what I do, is I randomly order the players, then pass them to you

then, when you need more players, I reorder them randomly again, and pass them again

so, each player will play once before another player gets a second game

The reasoning behind multiple instances is that you will have a second chance if one of your players dies. Maybe it should be multiple lives though. I still don't know if I would allow players to id instances of themselves if they appear multiple times on the board though.

but if you have tons of games, everybody will have second chances

True, I had forgot about that. Hmmm... The only other reason would be to fill the board with more players while only a few submissions are around.

Right. If you want a certain density of players, then either scale the size of the board with the number of players, or put a fixed number of players in the game, and allow repeats

Ah, good idea. I hadn't thought of scaling the board to the number of players present.

The biggest problem with scaling the board size is scoring

like, if you have a massive board, you may end up with a situation where the last player has a huge amount of squares, and the score is completely imbalanced towards him

but maybe not, not quite sure

Trial and error :)

anyways, scoring always works much better if you are able to order the players, or give reasonable partial scores

the obvious ordering is survival time

but that doesn't emphasize land ownership

you could do max-land-owned

or, land-owned-on-death

If the ordering is by survival time, everyone will play it safe. That will make everyone win...

they'll play safer

Land owned on death sounds promising. BTW why are partial scores important?

a bot that never attacks will eventually lose, as you still have to attack your opponent to win

the biggest enemy in nearly every KoTH is randomness

you want to keep variability as low as possible

if we crown 1 player the winner, and the rest as losers, then we got very little information from that game; namely that a particular player is better than the others

but when comparing the losers, we have no idea

and so, to rank the games, we have to say "who won the most"

but if one or two players always wins, then spots 3 to N are basically random

the opposite can be true: lets say its always a different player who wins

we'd basically end up with a random scoreboard

but if you could order the players, and find that a couple of the players consistently get 2nd or 3rd (but not 1st that often), then you know to rank them higher

Oh, ok. I thought you meant something like "after they die, they should still have a partial score"

well, the idea of keeping a score as you go is just going to waste cycles

unless you are going to feed that information to the players

(which could be interesting)

but you do need to return a score for each player at the end of the game

Got to go for the night. Thanks for your help! I'll probably be back tomorrow afternoon.

@NathanMerrill I just started on the board code, and am a bit confused. You suggested AdjacencyGraphMap as my base key. From my understanding, each item of U when using VonNeumannNeighborhood must be a Point2d, and can't be extended (getAdjacencies doesn't work for sub classes). How do I attach data to each point?

@JAtkin its like a Map with a key and a value. The key is the point2d, the value can be anything

AdjacencyGraphMap<U extends MapPoint, T>

Ah, silly me. I forgot to look at the T part...

the reason you don't want to extend Point2D is because it allows you to create Point2Ds on the fly and not worry about the data attached to them

like, you can simply create a Point2D(3,3), and it'll just work