Tell us your secrets, unleash your bot's code!

[bocsimacko]

git: http://quotenil.com/git/planet-wars.git

gitweb: http://quotenil.com/git/?p=planet-wars.git

I'll explain it in a blog entry, but the impatient can wade in. It's commented pretty well.

[iouri_]

[Torquemada2]

iouri_ thank's a lot for detail description. bocsimacko, I'll be waiting for your blog entry too. And your bot is a good reason to start studying Lisp to understand how it works.)

[wagstaff]

[DaTwinkDaddy]

My bot has been available since I started on it. It's not fancy, and hovering somewhere around rank 400 right now. My initial thoughts were to built something based on pressure/potential like smloh1, but it never got all the way there. The "best" thing about it (that broke me into the Top 100 a couple of times) was the planet valuation, which is based on simplistic game state prediction.

Name: DaTwinkDaddy
Profile:
Current Rank: ~400
Language: Haskell
Source:

Hrm, just noticed that I haven't pushed my last submission. It'll be up shortly.

[Zannick]

Name: Zannick
Profile:
Rank: 800-1000
Language: C

I basically stopped working on my bot as soon as it was finished due to other work. Looks like it's managing to stay in the top 1000, at least.

Mercurial:

This repository also contains some of the utility scripts I used to test my bots, and my implementation of CopyBot, a bot I wrote way back in September when the contest began to test submissions and such.

[Neverstu]

Name: Neverstu
Profile: http://ai-contest.com/profile.php?user_id=11516
Rank: 29
Language: C++

Source walkthrough, with pictures! http://reactorsoftware.com/blog/?p=24

As you will see my strategy is fairly basic. I'm happy that the handling of all moves/turns was relatively homogeneous. However now looking at the rankings I wonder if I should have accepted more special cases!

[Xrillo]

Name: Xrillo
Profile: http://ai-contest.com/profile.php?user_id=10212
Current Rank: 38
Language: C++

Bad and buggy implementation of a good algorithm - UCT.

[fglider]

Name: fglider
Profile: http://ai-contest.com/profile.php?user_id=8490
Current Rank: 52
Language: C++

Not very much different, as it looks from submissions from all my like long known enemies
The same:
Simulate and get metrics
Defend
Fear of them (check how many ships should remain on planet for it not to be taken)
Counter-snipe
Attack
Move remains to frontline
procedure. As for not mentioned here - when conquering neutrals - usual return on investment algorithm + some heuristic of conquering good planet with many defenders. When this is the case, send ships even if it is not enough to get the planet. That will next turn make planet oh so much better target. Of course this can only be used when planet is deep in my territory.

As for bugs - was not quite able to prevent my bot overcommiting when it conquers planet - it usualy sent 5-10 ships more than needed in complex cases, when attack was planned from many planets, and also target was defended or had ships in travel to it. Most probably some ugly > or >= signs misplasements in simulation routines

[synesso]

Bot name:
Unoficial rank: 500-600
Language:
Source:

Whilst my bot is not a top performer, I thought it may be interesting to some to see idiomatic Scala with higher-order functions, method lifting, immutable types and specification tests (most of my bot was written using BDD).

I completely re-wrote the app entry-point from the Java starter pack and it is much more succinct. (I made this pack via the forums).

The . Here's a of one. It deals with the behaviour of planets to project their future state given the incoming fleets.

The . Distinct operations were separated into different methods. These were lifted to functions and tested as closures in the specs.

Not having done any AI or game logic before I took a naive approach. I aimed for simplicity and treated each move independently. I did not differentiate between enemy targets and neutral targets. If it is a good deal (distance, regen and population wise) I take it. I sought to expand my collection of planets as a group rather than jumping to make distant colonies.

I would have loved to work with someone else during this project. Next year my will submit a collective bot. I can't wait.

I spent a long time trying to implement the same type of bot in Java, rewriting it maybe 5 times. It just got too messy for my liking. As soon as I could no longer make changes without side-effects I had to start again with a slightly revised algorithm. Using Scala made the task far simpler.