On 7/15/07, Hugh Perkins wrote:

Had an idea: a real shootout game for Haskell.

The way it would work is: - you email a haskell program to a specific address - it shows up on a web-page

The webpage shows the last submitted solution for each person - anyone can select two solutions and click "Fight" -> the scripts "fight" in an arena for a second or so, and the results are published to the website

The arena itself comprises: - a 2d grid, of a certain size (or maybe variable size) - each grid cell can be a wall, or one of the opponents - the boundaries of the grid are walls - random blocks of wall are placed around the grid

The opponents only perceive what is in a section of space to their front, in a 45 degree arc from either side of the direction they are facing - each player can face along one of the four grid axes

Each player takes it in turns to move - at each move the player can: - move one square - turn 90 degrees, in either direction - fire

Firing will score one point if the opponent is in the line of fire at that time, and there are no intervening walls.

Opponents can see the direction the other opponent is facing, as long as the other opponent is in their view arc, and there are no intervening walls.

Each turn is represented by a function something like:

doturn :: String -> [[GridValue]] -> (Action,String)

-- [[GridValue]] is a map of what Me sees this turn, or has seen previously -- the Strings are a way for the function to pass state to itself between moves

data GridValue = Opponent | Me | Wall | Empty data Action = Fire | MoveNorth | MoveSouth |MoveEast | MoveWest | TurnLeft | TurnRight | Wait -- (players can move backwards and sideways) many :: Parser a -> Parser [a] many p = do { x <- p; xs <- many p; return (x:xs) } The turn would be run as a separate thread, which either terminates successfully, or is aborted after a fixed time x milliseconds (maybe 10 milliseconds?)

The String that doturn produces at the end of a turn is passed back in at the beginning of the next turn (so one could use gread/gshow to serialize/deserialize arbitrary data types, and there is no limitation on what data can be stored in the state).

After say 1000 turns, the results are the points of each script. (or we could give each script a number of "lives" and if its loses them all the other script wins outright)

This can run on a hosted webserver probably, because each match is part of a webpage request, and lasts a maximum of about a second, so shouldnt be terminated prematurely by cpu-monitoring scripts.

I think this is a great idea! Besides being a nice AI testing ground, it might be a lot of fun. Of course, that web-hosting issue could end up being more of a minefield than one might expect... David

This would be a lot of fun! Make sure to take the lessons from http://haskell.org/haskellwiki/Safely_running_untrusted_Haskell_code into account. regards, Bas van Dijk On 7/15/07, Hugh Perkins wrote:

Had an idea: a real shootout game for Haskell.

The way it would work is: - you email a haskell program to a specific address - it shows up on a web-page

The webpage shows the last submitted solution for each person - anyone can select two solutions and click "Fight" -> the scripts "fight" in an arena for a second or so, and the results are published to the website

The arena itself comprises: - a 2d grid, of a certain size (or maybe variable size) - each grid cell can be a wall, or one of the opponents - the boundaries of the grid are walls - random blocks of wall are placed around the grid

The opponents only perceive what is in a section of space to their front, in a 45 degree arc from either side of the direction they are facing - each player can face along one of the four grid axes

Each player takes it in turns to move - at each move the player can: - move one square - turn 90 degrees, in either direction - fire

Firing will score one point if the opponent is in the line of fire at that time, and there are no intervening walls.

Opponents can see the direction the other opponent is facing, as long as the other opponent is in their view arc, and there are no intervening walls.

Each turn is represented by a function something like:

doturn :: String -> [[GridValue]] -> (Action,String)

-- [[GridValue]] is a map of what Me sees this turn, or has seen previously -- the Strings are a way for the function to pass state to itself between moves

data GridValue = Opponent | Me | Wall | Empty data Action = Fire | MoveNorth | MoveSouth |MoveEast | MoveWest | TurnLeft | TurnRight | Wait -- (players can move backwards and sideways)

The turn would be run as a separate thread, which either terminates successfully, or is aborted after a fixed time x milliseconds (maybe 10 milliseconds?)

The String that doturn produces at the end of a turn is passed back in at the beginning of the next turn (so one could use gread/gshow to serialize/deserialize arbitrary data types, and there is no limitation on what data can be stored in the state).

After say 1000 turns, the results are the points of each script. (or we could give each script a number of "lives" and if its loses them all the other script wins outright)

This can run on a hosted webserver probably, because each match is part of a webpage request, and lasts a maximum of about a second, so shouldnt be terminated prematurely by cpu-monitoring scripts.

_______________________________________________ Haskell-Cafe mailing list Haskell-Cafe@haskell.org http://www.haskell.org/mailman/listinfo/haskell-cafe