std::vector<int> person::choose_move (position &pos, bool p)
{
in_out[options[0]]->draw(pos);
in_out[options[0]]->message("You are ");
if (p)
{
in_out[options[0]]->message("red");
}
else
{
in_out[options[0]]->message("black");
}
in_out[options[0]]->message(".\n\nWhich piece do you want to move?\n");
std::vector<int> o = in_out[options[0]]->choose_point();
if (pos.board[o[0]][o[1]] * (2 *!p - 1) <= 0)
{
in_out[options[0]]->message("Please choose one of your pieces.\n\n");
return choose_move(pos, p);
}
in_out[options[0]]->message("\nWhere do you want to move it?\n");
std::vector<int> n = in_out[options[0]]->choose_point();
std::vector<int> m;
bool is_valid = false;
std::vector<std::vector<int> > z;
pos.valid_moves(z, p);
for (unsigned int i = 0; i < z.size(); i ++)
{
if ((o[0] == z[i][0]) && (o[1] == z[i][1]) && (n[0] == z[i][2]) && (n[1] == z[i][3]))
{
is_valid = true;
}
}
if (is_valid)
{
m.push_back(o[0]);
m.push_back(o[1]);
m.push_back(n[0]);
m.push_back(n[1]);
return m;
}
else
{
in_out[options[0]]->message("\nPlease choose a valid move.\n\n");
return choose_move(pos, p);
}
}
static void tick(int *len, char *buf, struct per_session_data *data) {
int path_length = 0;
path_t path;
mask_t random_dots = EMPTY_MASK;
json_object *result;
const char *s;
/* If it's a new game, only send the grid and don't compute a move. */
if (data->new_game) {
data->new_game = 0;
} else {
struct timeval tv;
long ms;
mask_t move;
int no_moves;
gettimeofday(&tv, NULL);
ms = (tv.tv_sec * 1000) + (tv.tv_usec / 1000);
if ((ms - data->last_updated) < MIN_UPDATE_INTERVAL) {
return;
}
data->last_updated = ms;
move = choose_move(data->grid, 0, 100, &no_moves);
apply_move(data->grid, move);
fill_grid(data->grid, GET_CYCLE_COLOR(move));
if (no_moves) {
random_dots = move;
} else {
mask_to_path(move, &path_length, path);
}
}
result = json_object_new_object();
json_object_object_add(result, "grid", json_grid(data->grid));
if (path_length == 0 && random_dots == EMPTY_MASK) {
json_object_object_add(result, "newGrid", json_object_new_boolean(TRUE));
}
if (random_dots) {
json_object_object_add(result, "shrinkRandom", json_shrink_random(random_dots));
}
if (path_length) {
json_object_object_add(result, "path", json_path(path_length, path));
}
s = json_object_to_json_string(result);
*len = strlen(s);
memcpy(buf, s, *len);
buf[*len] = 0;
json_object_put(result);
}
/** Realiza o confronto, alternando os participantes, e retorna o estado
* final da partida.
*
* @return state_t o estado resultante do confronto.
* @see bool allowed(const Move *, const state_t &) const
* @see IIA::Action<state_t>* Player::decide_action(const state_t &)
* @see void Move::execute(state_t &) const
* @see bool over(const state_t &)
* @see void setup(const typename std::deque<player_t *> &) */
state_t play() {
moves.clear();
std::deque<player_t *> match_players(players);
state_t state;
setup(match_players);
do {
Move *move = choose_move(match_players.front(), state);
moves.push_back(move);
if(!allowed(move, state)) break;
move->execute(state);
next(match_players);
} while(!over(state));
// cleanup(match_players);
return state;
}
void test(void)
{
GAME game;
MOVE moves[MAX_MOVES];
int vector[MAX_PLAYERS];
int num_moves;
int i;
MOVE chosen_move;
clock_t start_time, end_time;
int centiseconds, rate;
printf("Rankoids AI test\n");
clear_transposition_table();
init_stack(&game_stack, 100*sizeof(GAME));
initialise_game(&game);
game.num_players = 3;
game.players[0].hand[0] = 1;
game.players[0].hand[1] = 3;
game.players[0].hand[3] = 2;
game.players[1].hand[4] = 1;
game.players[0].hand[6] = 4;
game.players[0].hand[7] = 3;
game.players[0].hand[10] = 2;
game.players[0].hand[JOKER_VALUE] = 1;
game.players[1].hand[1] = 1;
game.players[1].hand[2] = 3;
game.players[1].hand[3] = 1;
game.players[1].hand[4] = 1;
game.players[1].hand[5] = 1;
game.players[1].hand[9] = 3;
game.players[1].hand[12] = 1;
game.players[1].hand[5] = 2;
game.players[2].hand[0] = 3;
game.players[2].hand[2] = 1;
game.players[2].hand[3] = 1;
game.players[1].hand[4] = 2;
game.players[2].hand[5] = 2;
game.players[2].hand[9] = 1;
game.players[2].hand[11] = 4;
game.current_player = 0;
game.pile_owner = 0;
printf("Current game:\n");
print_game(&game);
printf("All moves for player 1:\n");
num_moves = generate_all_moves(game.players[0].hand, moves);
for (i = 0; i < num_moves; i++)
print_move(moves[i]);
printf("\n");
evaluate_game_immediate(&game, vector);
printf("Game vector is: [%d,%d,%d]\n", vector[0], vector[1], vector[2]);
printf("All valid moves for player 1:\n");
num_moves = generate_valid_moves(&game, moves);
for (i = 0; i < num_moves; i++)
print_move(moves[i]);
printf("\n");
chosen_move = MAKE_MOVE(3, 2);
printf("Apply move ");
print_move(chosen_move);
printf(", game is:\n");
apply_move(&game, chosen_move);
print_game(&game);
evaluate_game_immediate(&game, vector);
printf("Game vector is: [%d,%d,%d]\n", vector[0], vector[1], vector[2]);
printf("All valid moves for player 2:\n");
num_moves = generate_valid_moves(&game, moves);
for (i = 0; i < num_moves; i++)
{
print_move(moves[i]);
clear_transposition_table();
evaluate_move(&game, moves[i], vector, parameters.depth);
printf(", with vector [%d,%d,%d]\n", vector[0], vector[1], vector[2]);
}
node_count = 0;
clear_transposition_table();
start_time = clock();
chosen_move = choose_move(&game, vector, parameters.depth+5);
end_time = clock();
centiseconds = (end_time - start_time)*100 / CLOCKS_PER_SEC;
if (centiseconds != 0)
{
rate = (int) (100.0*node_count/centiseconds);
}
else
{
rate = 0;
}
printf("%d nodes examined (%d hits), time was: %0.2f seconds, rate is: %d nodes/sec\n", node_count, hit_count, centiseconds/100.0, rate);
printf("Chosen move was:");
print_move(chosen_move);
printf(", with vector [%d,%d,%d]\n", vector[0], vector[1], vector[2]);
free_stack(&game_stack);
}
void Player::PlayerUCT::walk_tree(Board & board, Node * node, int depth){
int toplay = board.toplay();
if(!node->children.empty() && node->outcome < 0){
//choose a child and recurse
Node * child;
do{
int remain = board.movesremain();
child = choose_move(node, toplay, remain);
if(child->outcome < 0){
movelist.addtree(child->move, toplay);
if(!board.move(child->move, (player->minimax == 0), (player->locality || player->weightedrandom) )){
logerr("move failed: " + child->move.to_s() + "\n" + board.to_s(false));
assert(false && "move failed");
}
child->exp.addvloss(); //balanced out after rollouts
walk_tree(board, child, depth+1);
child->exp.addv(movelist.getexp(toplay));
if(!player->do_backup(node, child, toplay) && //not solved
player->ravefactor > min_rave && //using rave
node->children.num() > 1 && //not a macro move
50*remain*(player->ravefactor + player->decrrave*remain) > node->exp.num()) //rave is still significant
update_rave(node, toplay);
return;
}
}while(!player->do_backup(node, child, toplay));
return;
}
if(player->profile && stage == 0){
stage = 1;
timestamps[1] = Time();
}
int won = (player->minimax ? node->outcome : board.won());
//if it's not already decided
if(won < 0){
//create children if valid
if(node->exp.num() >= player->visitexpand+1 && create_children(board, node, toplay)){
walk_tree(board, node, depth);
return;
}
if(player->profile){
stage = 2;
timestamps[2] = Time();
}
//do random game on this node
for(int i = 0; i < player->rollouts; i++){
Board copy = board;
rollout(copy, node->move, depth);
}
}else{
movelist.finishrollout(won); //got to a terminal state, it's worth recording
}
treelen.add(depth);
movelist.subvlosses(1);
if(player->profile){
timestamps[3] = Time();
if(stage == 1)
timestamps[2] = timestamps[3];
stage = 3;
}
return;
}
