Game web api

[acautin]

To start we should implement:

• create_challenge (board_parameters, category, time_limit) -> game_id.
• accept_challenge (game_id) -> already_accepted | game_state.
• cancel_challenge(game_id) -> ok | invalid_game_id.
• play (game_id, player, position) -> invalid | accepted | you_won | tie | you_lost | game_state.

Anyone (initially also non registered users) can create a challenge (game), gets a unique game_id and must wait until another player accepts this challenge.

game_state :: {board_parameters, last_player, last_move, next_player, board}

board_parameters ::
{ width :: integer() % board width >= 3
, height :: integer() % board height >= 3
, run :: integer() % sucess run length
, gravity :: boolean() % do moves fall towards higher row numbers
, periodic :: boolean() % unbounded repeating board
}

board: string [width * height] of characters indicating state of a cell.
possible cell states (in ascii): O | X | * | $
the opener of the challenge uses 79 (ascii O)
the player accepting the challenge uses 88 (ascii X)
the * character represents a joker
the $ character represents a block

player :: integer() % player alias in this game (same type for last_player, next_plaxer)

[stoch]

How to bootstrap external bots?

Strong bot players might need to implement the whole game mechanics in order to locally compute winning chances for certain moves. Do they really?
A pure (and maybe naive) ML strategy would be to start with a very silly bot with enough randomness and to let it learn from its many failures and scarce successes.

In order to make it really easy to help an external bot getting off the ground, egambo could use the already builtin bot (1 move lookahead or random move) to propose a next move to the external player. In lack of a better strategy, the beginner-bot could simply turn this proposal into its next move and start playing like that with minimum effort. After learning enough (by whatever means) it could stop asking for proposals and play on its own feet (neurons).

The egambo server can then be improved by implementing a better bot or proposals by classical means (e.g. minimax algorithm) and eventually the internal bot will forest through all the games played and improve itself on ML techniques itself.

[acautin]

@stoch The idea of proposing new moves is not practical for training, what we could do is make the simple bot play against itself for 10000+ times and record the matches to offer that as a prerecorded data set.

One of the reasons is that when designing and testing different network configurations we would like the training data to be stable, as there are many hyper parameters that need to be tweaked (number of hidden layers, learning rate, regularization, activation functions, etc..) we need to compare the new configuration with previous runs, but if the data set provided is not fixed then it will be very difficult to know if we are moving in the right direction.

Another reason for this is we would like to take advantage of all the cores on the GPUs so we can train the models efficiently, for that we need to feed the positions in batches so they can be processed in parallel which wouldn't be practical if the bots are requesting the moves one by one.