anuragjainsagar / ai-contest Goto Github PK

Purpose of code changes on this branch:

To fix issues http://code.google.com/p/ai-contest/issues/detail?id=38 and 
http://code.google.com/p/ai-contest/issues/detail?id=46. These two issues 
describe off-by-one errors in the battle resolution code in the client- and 
server-side engine, respectively. These two patches were submitted by 
jokeserver.

After the review, I'll merge this branch into:
/trunk

Common Lisp is popular. Let's make a starter package. The compile logic is 
already in place.

Right now the client-side engine works only in text mode. There is another 
issue about giving it a GUI. This issue is about improving the quality of 
the engine itself, not the GUI.
  * The command-line syntax of the client-side engine sucks. It should be 
made nicer and more intuitive. Something like java -jar Engine --
first_program ./my_bot --second_program example_bots/random_bot --map 
maps/map1.txt
  * The engine doesn't really give any helpful error messages when shit 
goes wrong. Whenever something goes wrong, the engine should print a 
message on stderr. Perhaps on a fatal error, a textbox with a helpful error 
message should show up to explain what went wrong, and what can be done to 
fix it.
  * The engine needs to do asynchronous I/O instead of blocking while it 
waits to read output from the individual programs.
  * Enforce a time limit. Currently the engine enforces no time limit. This 
is so confusing for the users, because their program will work on their own 
machine, but get disqualified for timing out when they submit it to the 
website. The correct time limit should be used by default, and they should 
be able to specify different time limits on the command line, by saying --
max_turn_time 3000 for 3 seconds, for example.

Perl is popular. Let's make a starter package. The compile logic is already in 
place.

What steps will reproduce the problem?
1. Visit http://csclub.uwaterloo.ca/~j3camero/ai-
contest/planet_wars/www/index.php
2. There is a white strip about 10 pixels high along the top of the title 
header. There are also thinner vertical white stripes on either side of the 
webpage, but these may be intentional.
3. The issue has been observed using Chrome and Firefox on Ubuntu Linux and 
with Safari on an iPod Touch and may exist on other browsers and platforms 
as well.

Wall Time is strongly affected by other process in the same machine and bots 
which use a lot of time might have a problem with that.
CPU Time should be slightly better.

http://nadeausoftware.com/articles/2008/03/java_tip_how_get_cpu_and_user_time_be
nchmarking#TimingasinglethreadedtaskusingCPUsystemandusertime

Please find attached a patch.

People don't know which API functions they can use.

Gotta get the forums set up and linked from the site so that the forum admin 
(amstan) can do his work.

Purpose of code changes on this branch:

The purpose of these changes is to develop a simple engine to serve as an 
example to implementers of other engines. The hope is that the Tic-Tac-Toe 
engine will serve as a nice starting point for building other engines.

Also, this change introduces a rudimentary Sandbox class which can be used 
to invoke a program and communicate with it.

When reviewing my code changes, please focus on:

After the review, I'll merge this branch into:
/trunk

This bot works :

std::vector<Planet> mine = pw.MyPlanets();
std::vector<Planet> neutral = pw.NeutralPlanets();

pw.IssueOrder(mine[0].PlanetID(), neutral[0].PlanetID(), -100);

Each turn, I have more 100 ships. :)

Somebody should start a strategy guide page for the website. It should 
outline some simple strategies that people can use.
  * Ideally, the strategies would start out very simple, and build in 
complexity. It would be super-ideal if the strategies all built on one 
another, so that people could start at the top of the guide and read through 
it, improving their programs incrementally.
  * Including pseudocode or even straight-up working code would be great. 
That way people could get some satisfaction by climbing the rankings really 
quickly. We would get more power users and fewer people who just submit the 
starter package then never come back.

The sadbox is a program that can be used to safely invoke untrusted code. 
The engine uses it to launch the programs submitted by the users. The plan 
right now is to have this work as follows:
  * Start a VM using Qemu, from a saved state
  * scp the files needed to run the program into the VM
  * Use ssh to exec the program inside the VM

The end result is a script that works like happyrun, except more secure. It 
would work something like this:
  * python sadbox.py --directory_to_transfer ../entries/2098/ --
command_to_run "java MyBot"

Purpose of code changes on this branch:

To repair the off-by-one bug in the client-side engine reported in this issue: 
http://code.google.com/p/ai-contest/issues/detail?id=38

After the review, I'll merge this branch into:
/trunk

There are already a few strategy guides and tutorials posted on the website. 
However, the advanced strategy guide does not have anything in it. Want to 
write it? Grab this issue and away you go.

Here are some ideas:
  1. A bunch of orders can be represented by a sparse matrix. This representation allows the creation of meta-strategies. Suppose you have a few different strategies, each of which produces a sparse matrix as its output. Meta-strategies can be created by taking a linear combination of the sparse matrices.
  2. Adaptive meta-strategies. In point (1) we saw how a meta-strategy can be encoded as a fixed vector of real numbers. What if this strategy vector could change as a function of the game state? Think about a neural net that has inputs like "safety", "% of ships that are mine", "% of production that is mine", "travel time to the closest weak planet", and a bunch of other stuff. The outputs of the neural network would be how much weight to attach to each of the various strategies.
  3. A discussion of control. How does your strategy know which planets it controls, and how solid their control of certain planets really is? If there were some way to measure what % control you have over each planet, then you could retreat from planets where you've lost control, or attack planets that you don't yet own, but which you solidly control.
  4. Market-based strategy. The game of Galcon is a lot like building an optimal investment portfolio. Picture the objective of Galcon as achieving the maximum ship count. Ships can be "invested" into a number of different planets. Each planet has an estimated % return, a "risk of default", a volatility. Furthermore the fate of nearby planets may be correlated. Think about Galcon as a Quadratic Programming problem, just like finding an optimal portfolio.
  5. Other ideas. There are tons.

We need to get some kind of basic tournament manager up and running before 
we can launch 

It's not clear where the "thinking code" should go. People have expressed 
general confusion as to how to use the C++ starter package. This should be 
cleaned up so it's crystal clear to a beginner programmer.

Do it.

The readme file should contain some information about where the package came 
from (Google AI Challenge), and where to get more information. It should have a 
link to the tutorials and Getting Started Guide. The readme file should also 
explain briefly what are all the contents of the starter package.

Some users have requested the ability to delete their own accounts. This is 
mostly because they don't like their username, and they want to change it. 

This can be accomplished by creating a "Delete My Account" page. A link to 
this page can be placed somewhere on a page that only the user can see.

There are many security considerations for a feature like this:
  * It should not be overly easy to find. This is the one sort of feature 
that you should have to look around for a minute or two to find.
  * There should be a couple warnings to make sure the user understands 
what they are doing. An "Are You Really Really Really Sure?" page would be 
great. The user should have to specifically input their password to 
indicate that it's really them taking the action. People leave their 
screens unlocked and stuff.
  * Before deleting the account, we need to be careful that the person is 
logged in as the account being deleted. If someone figures out that they 
can delete any other person's account by accessing delete_account.php?
user_id=123 we're going to have a lot of angry users.
  * The action should be undoable by contest admins. Don't actually delete 
the account from the database, just mark it as inactive, so it looks like 
it's been deleted from all the users' point of view.

This is a dangerous feature! Be very careful! Before pushing this to the 
live website, have two other experienced people take a close look to make 
sure there is no conceivable way that the feature could be misused by 
anybody.

C# is pretty popular. It seems to be quite accessible to beginners. It would 
probably be pretty easy to translate the Java starter package to C#.

Common Lisp is popular. Let's make a starter package. The compile logic is 
already in place.

Python seems to be a very popular language. We definitely must support it.

It would be so dope if the planet_wars engine was written in Python, since 
the two other components that it deals with (the planet_wars tournament 
manager and the sadbox) are also written in python.

What steps will reproduce the problem?
1. Go to http://csclub.uwaterloo.ca/~j3camero/ai-
contest/planet_wars/www/login.php and you will see.

What is the expected output? What do you see instead?
The login form should be right under the header, instead of down at the 
bottom.

Purpose of code changes on this branch:

To fix issues http://code.google.com/p/ai-contest/issues/detail?id=38 and 
http://code.google.com/p/ai-contest/issues/detail?id=46.

These issues describe off-by-one bugs in the client- and server-side engines, 
respectively. These off-by-one bugs are located in the battle resolution code, 
and result in confusing behavior.

After the review, I'll merge this branch into:
/trunk

Purpose of code changes on this branch:

To familiarize with code reviews in Google Code.

After the review, I'll merge this branch into:
/trunk

The client-side engine is a Java program that will be included with the 
starter packages that allows the user to invoke two bots and watch them 
graphically play against one another on his own machine.

There is a fair bit of work already done on this. The game logic is already 
done, and the visualization code has been written. What remains is to create 
the actual game loop and call the visualization code each frame, and use 
AWT/Swing to actually draw the picture of the game state on a graphical 
surface.

We should probably build a password reset feature. This was highly 
requested by the users last time around.

This could be a form that is visible to non-logged-in users. They fill in 
their username and the email address they used to create the account. If 
their account is activated and the email matches the username, fire them an 
email explaining that there has been a password reset request. In the 
email, there would be a link that they can click to reset their password.

This feature is very similar to the account activation process, which you 
can see in register.php, check_registration.php, and 
account_activation.php.

Security is a huge issue with this feature. We need to be extremely careful 
that this feature doesn't accidentally make it computationally feasible for 
a clever attacker to steal a person's account. We need to be really 
careful. Before this feature is publicly launched, we need to have a few 
people look at it, think about it, think of all the ways it could be 
attacked, and then okay it.

One goal for the upcoming contest is to get the contestants themselves involved 
in creating and operating new contests. There are a number of strategies that 
we can use to help recruit volunteers from amongst the contestants themselves.

Haskell is awesome. Let's make a starter package. The compile logic is already 
in place.

We should have this feature. On the users' profile pages, there will be a 
list of his most recently-played games. When a row in this list is clicked, 
it should lead to a game playback page. This would look sort of like a video 
player and would allow the user to step through the game frame-by-frame or 
just play it all back at once.

Scheme is popular at the University of Waterloo, especially amongst younger 
students, since it's used in first year CS courses.

Let's make a starter package. The compile logic is already in place.

What steps will reproduce the problem?
1. Visit http://csclub.uwaterloo.ca/~j3camero/ai-
contest/planet_wars/www/index.php
2. Sign in using the admin username and password that I sent to the concom 
mailing list.
3. See the navbar on the right. It runs into the page footer.

One of the beta testers (Andre) is unable to submit his code. Apparently the 
zip file is not being handled correctly by the submission pipeline. Andre was 
using a Mac computer to zip up his files. One hypothesis is that Mac is doing 
something while creating the zip file that makes the contest unable to unzip it 
properly. I will have to go find the zip file that Andre submitted and see 
what's wrong.

Currently the tutorials don't work because of this bug.

Blah!

http://www.ai-contest.com/visualizer.php?game_id=4410721 shows a couple of 
cases where both red and green attack a neutral planet simultaneously, with one 
fleet disappearing entirely.

See also a thread about this: 
http://www.ai-contest.com/forum/viewtopic.php?f=18&t=390.

One-line fix attached (missing increment in the loop at line 172).
I also included some other increments in places I think may cause infinite 
loops.

We need a leaderboard.

One of the top entries last time was written in Go. Let's make a starter 
package. The compile logic is already in place.

Currently when running the first command from this tutorial 
(http://www.ai-contest.com/using_the_tools.php), I get the following output:

...

Turn 86
Turn 87
Turn 88
Turn 89
Turn 90
Turn 91
Turn 92
Turn 93
Turn 94
Turn 95
Player 2 Wins!
Exception in thread "Thread-2" java.lang.ArrayIndexOutOfBoundsException: 2
    at ViewerPanel.run(ViewerPanel.java:97)
    at java.lang.Thread.run(Thread.java:636)

And then the visualizer pops up but does not display the game. It just spins as 
though it's loading without ever finishing.

Each user should have a profile with information about his ranking, a list 
of his recently played games, some account management stuff, etc.

A contestant on the forums (mtcbot) has ported the starter package to Ocaml. 
Try to get this up and running.

Right now the Planet Wars engine doesn't actually use the Sadbox to 
encapsulate untrusted code. We should change the engine such that code is 
run securely using the Sadbox.

Here is how the matching system works right now: choose two different 
submissions at random.

Here is how it should work:
  1. Find active submission with the least games played.
  2. If the submission has no ranking, choose an opponent at random.
  3. If the submission does have a ranking, choose an opponent of similar rank (+/- 10 or so)

Some of the automated email messages may be out of date or sound dumb. Go over 
them so they look professional and clear.

We should support ten languages in the compile daemon for to make much 
accessibility yeah.

If you have a look to this match : 
http://ai-contest.com/visualizer.php?game_id=4407488
I lost and I have no idea of the reason.

You should at least provide us this kind of information about the match : 
normal, playerX timed out, playerX has done something wrong...
And it should be even better when we have done something wrong to know what was 
our bad move.

One of the beta testers reported that the win/loss/draw column is broken. 
Investigate and fix if necessary.

If a planet has zero ships and you hit it with one ship, the planet becomes 
your but with zero ships. It should become yours but with one ship.

The user profile pages suck. Fix them.