/* Full board matching in database for fuseki moves. Return 1 if any
* pattern found.
*/
static int
search_fuseki_database(int color)
{
struct fullboard_pattern *database;
int q;
int k;
int best_fuseki_value;
/* Disable matching after a certain number of stones are placed on
* the board.
*/
if (stones_on_board(BLACK | WHITE) > MAX_FUSEKI_DATABASE_STONES)
return 0;
/* We only have databases for 9x9, 13x13 and 19x19. */
if (board_size == 9)
database = fuseki9;
else if (board_size == 13)
database = fuseki13;
else if (board_size == 19)
database = fuseki19;
else
return 0;
/* Do the matching. */
num_fuseki_moves = 0;
fuseki_total_value = 0;
fullboard_matchpat(fuseki_callback, color, database);
/* No match. */
if (num_fuseki_moves == 0)
return 0;
/* Choose randomly with respect to relative weights for matched moves. */
/* Do not choose moves with less value than 20% of the best move */
best_fuseki_value = fuseki_value[0];
q = gg_rand() % fuseki_total_value;
for (k = 0; k < num_fuseki_moves; k++) {
if (fuseki_value[k] < (best_fuseki_value / 5))
break;
q -= fuseki_value[k];
if (q < 0)
break;
}
gg_assert(k < num_fuseki_moves);
/* Give this move an arbitrary value of 75. The actual value doesn't
* matter much since the intention is that we should play this move
* whatever the rest of the analysis thinks.
*/
announce_move(fuseki_moves[k], 75, color);
/* Also make sure the other considered moves can be seen in the
* traces and in the output file.
*/
for (k = 0; k < num_fuseki_moves; k++)
set_minimum_move_value(fuseki_moves[k], 74);
return 1;
}
int main (int argc, char** argv)
{
world_skeleton_t *s;
map_t *map;
announcer_t a;
char* name = "mrscolumbo";
brain_t* brain;
if(argc>1)
{
srand(argv[1][0]);
}
a = init_announcer(stdout);
announce_reg(a, name, PTYPE_COP_FOOT);
s = parse_world_skeleton(stdin);
//parser_print_world_skeleton(s);
map = build_map(s);
dprintf("NAME: %s\n", s->name);
brain = create_brain(s->name, map);
/*
printf("dist: %d\n", get_dist(map, CHOOSE_FOOT,
node_index(map, "55-and-woodlawn"),
node_index(map, "54-and-ridgewood")));
*/
for(;;)
{
world_message_t *m;
node_line_t *my_node;
cop_inform_msg_t* inform;
cop_plan_msg_t* plans;
cop_vote_msg_t* votes;
vote_tally_t* tally;
int bestdst;
int* path;
m = parse_world_message(s);
announce_inform(a, NULL);
if(!m->game_running)
break;
my_node = player_node(m, map, s->name, 0);
update_brain(s, m, map, brain);
inform = parse_inform_messages(s);
free_inform_messages(inform);
announce_plan(a, NULL);
plans = parse_plan_messages(s);
free_plan_messages(plans);
votes = make_stupid_votes(s, brain);
announce_vote(a, votes);
free(votes);
tally = parse_vote_tally(s);
free_vote_tally(tally);
bestdst = get_dest(s, m, map, brain);
if(ada_kurds_here_p(s, m, map, brain))
{
bestdst = (rand()%(map->num_nodes));
}
//path = get_combined_prev(map, CHOOSE_FROM_PTYPE(brain->my_ptype), brain->my_pos);
// ALERT
path = get_prev(map, CHOOSE_FROM_PTYPE(brain->my_ptype), brain->my_pos);
if(get_combined_switchp(map, CHOOSE_FROM_PTYPE(brain->my_ptype), brain->my_pos))
{
// ALERT
//switch_transport(brain, map);
}
while(path[bestdst]!=brain->my_pos)
{
bestdst = path[bestdst];
}
announce_move(a, s, m, node_by_index(map, bestdst)->loc, brain->my_ptype);
}
return 0;
}
/* Generate move in empty corner or in middle of small board.*/
void
fuseki(int color)
{
int i = -1;
int j = -1;
int width; /* Side of the open region required in the corner. */
int empty_corner_value = EMPTY_CORNER_VALUE * board_size/19;
/* Return immediately if --disable_fuseki option used. */
if (disable_fuseki)
return;
set_symmetries();
/* Search in fuseki database unless disabled by --nofusekidb option. */
if (fusekidb && search_fuseki_database(color))
return;
/* On 9x9, only play open corners after the first move if nothing
* else useful is found.
*/
if (board_size == 9 && stones_on_board(color) > 0)
empty_corner_value = 5;
if (board_size <= 11) {
/* For boards of size 11x11 or smaller we first go for the center point. */
int middle = board_size/2;
if (openregion(middle-2, middle+2, middle-2, middle+2)) {
announce_move(POS(middle, middle), 45, color);
}
}
if (board_size < 9)
return;
if (board_size >= 18)
width = 8;
else if (board_size == 9)
width = 5;
else
width = board_size/2;
if (openregion(0, width-1, board_size-width, board_size-1)) {
choose_corner_move(UPPER_RIGHT, &i, &j);
announce_move(POS(i, j), empty_corner_value, color);
}
if (openregion(board_size-width, board_size-1, 0, width-1)) {
choose_corner_move(LOWER_LEFT, &i, &j);
announce_move(POS(i, j), empty_corner_value, color);
}
if (openregion(board_size-width, board_size-1,
board_size-width, board_size-1)) {
choose_corner_move(LOWER_RIGHT, &i, &j);
announce_move(POS(i, j), empty_corner_value, color);
}
if (openregion(0, width-1, 0, width-1)) {
choose_corner_move(UPPER_LEFT, &i, &j);
announce_move(POS(i, j), empty_corner_value, color);
}
}
int main (int argc, char** argv)
{
world_skeleton_t *s;
map_t *map;
announcer_t a;
int i;
char* name = "resi";
int move[NUM_COPS];
brain_t* mcduff[NUM_COPS];
char* mc_duff_names[NUM_COPS];
if(argc>1)
{
srand(argv[1][0]);
if(argv[1][0]=='1')
{
dump_scores = 1;
}
}
a = init_announcer(stdout);
ptype_t t = PTYPE_COP_FOOT;
/* if(rand()%9>6) */
/* { */
/* t = PTYPE_COP_CAR; */
/* } */
announce_reg(a, name, t);
dprintf("GETTING SKEL\n");
s = parse_world_skeleton(stdin);
dprintf("GOT SKEL\n");
//parser_print_world_skeleton(s);
map = build_map(s);
dprintf("NAME: %s\n", s->name);
//////////////////////////////// <RESI>
for(i=0; i<NUM_COPS; i++ )
{
mcduff[i] = reserl_create_brain(s, map);
dprintf("mcduff[%d] = %p\n", i, mcduff[i]);
}
//////////////////////////////// </RESI>
for(i=0; i<NUM_COPS; i++ )
{
mc_duff_names[i] = s->cops[i];
mcduff[i]->name = s->cops[i];
}
/*
printf("dist: %d\n", get_dist(map, CHOOSE_FOOT,
node_index(map, "55-and-woodlawn"),
node_index(map, "54-and-ridgewood")));
*/
/* dprintf("---- %d %d\n", */
/* node_by_loc(map, "54-and-ridgewood")->index, */
/* node_by_loc(map, "54-and-blackstone")->index); */
/* dprintf("*********** %d\n", */
/* get_combined_dist(map, CHOOSE_FOOT, */
/* node_by_loc(map, "54-and-ridgewood")->index, */
/* node_by_loc(map, "54-and-blackstone")->index)); */
/* dprintf("*********** %d\n", */
/* get_combined_dist(map, CHOOSE_FOOT, */
/* node_by_loc(map, "54-and-blackstone")->index, */
/* node_by_loc(map, "54-and-ridgewood")->index)); */
for(;;)
{
dprintf("entering loop \n");
world_message_t *m;
cop_inform_msg_t* inform;
cop_plan_msg_t* other_plans;
cop_vote_msg_t* votes;
vote_tally_t* tally;
cop_plan_msg_t plans[NUM_COPS];
dprintf("GETTING WORLD\n");
m = parse_world_message(s);
dprintf("GOT WORLD\n");
//////////////////////////////// <RESI>
for(i=0; i<NUM_COPS; i++)
{
reserl_update_brain(m, mcduff[i]);
}
//////////////////////////////// </RESI>
announce_inform(a, NULL);
if(!m->game_running)
break;
dprintf("GETTING inform\n");
inform = parse_inform_messages(s);
free_inform_messages(inform);
dprintf("GOT inform\n");
//////////////////////////////// <RESI>
for(i=0; i<NUM_COPS; i++)
{
move[i] = reserl_get_move(m, mcduff[i]);
}
//////////////////////////////// </RESI>
for (i = 0; i<NUM_COPS; i++) {
dprintf("mcduff name = %s\n", mcduff[i]->name);
plans[i].bot = mcduff[i]->name;
plans[i].node = node_by_index(map, move[i]);
plans[i].type = mcduff[i]->my_ptype;
plans[i].world = m->world + 1;
plans[i].next = &plans[i+1];
}
plans[NUM_COPS-1].next = NULL;
// dprintf("announcing plan\n");
announce_plan(a, plans);
dprintf("GETTING PLAN\n");
other_plans = parse_plan_messages(s);
dprintf("GOT PLAN\n");
free_plan_messages(other_plans);
//////////////////////////////// <RESI>
votes = reserl_make_stupid_votes(s);
//////////////////////////////// </RESI>
// dprintf("announcing vote\n");
announce_vote(a, votes);
// dprintf("announced vote\n");
free(votes);
dprintf("GETTING vote\n");
tally = parse_vote_tally(s);
free_vote_tally(tally);
dprintf("GOT vote\n");
int k=0;
int myindex = 0;
for(k=0; k<NUM_COPS; k++)
{
if(0==strcmp(s->name, mcduff[k]->name))
{
myindex = k;
break;
}
}
dprintf("--------------- %d\n", myindex);
//dprintf("announcing move to %s \n", node_by_index(map, bestdst)->loc);
announce_move(a, s, m, node_by_index(map, move[myindex])->loc, mcduff[myindex]->my_ptype);
}
return 0;
}
void move_char (CHAR_DATA * ch, int door, bool follow)
{
CHAR_DATA *fch;
CHAR_DATA *fch_next;
ROOM_INDEX_DATA *in_room;
ROOM_INDEX_DATA *to_room;
EXIT_DATA *pexit;
if(ch->infight)
{
if(!TURN(ch))
{
printf_to_char(ch,"It's not your turn.\n");
return;
}
refresh(ch->in_room);
if(ch->MoveLeft == 0)
{
printf_to_char(ch,"You have no moves left.\n");
return;
}
switch(door)
{
case DIR_EAST:
if(find_char_xy(ch,ch->mposx+1,ch->mposy) == NULL)
{
if(hdif(ch,DIR_EAST) > ch->jump || hdif(ch,DIR_EAST) < -(ch->jump) || ch->mposx > 24)
{
printf_to_char(ch,"You can't jump that high.\n");
return;
}
ch->mposx++;
ch->in_room->map.index[ch->mposy][ch->mposx].occupied = FALSE;
ch->in_room->map.index[ch->mposy][ch->mposx+1].occupied = TRUE;
announce_move(ch,"east");
}
else
printf_to_char(ch,"Somebody's in the way.\n");
break;
case DIR_WEST:
if(find_char_xy(ch,ch->mposx-1,ch->mposy) == NULL)
{
if(hdif(ch,DIR_WEST) > (ch->jump) || hdif(ch,DIR_WEST) < -(ch->jump) || ch->mposx < 1)
{
printf_to_char(ch,"You can't jump that high.\n");
return;
}
ch->in_room->map.index[ch->mposy][ch->mposx].occupied = FALSE;
ch->in_room->map.index[ch->mposy][ch->mposx-1].occupied = TRUE;
ch->mposx--;
announce_move(ch,"west");
}
else
printf_to_char(ch,"Somebody's in the way.\n");
break;
case DIR_NORTH:
if(hdif(ch,DIR_NORTH) > (ch->jump) || hdif(ch,DIR_NORTH) < -(ch->jump) || ch->mposy < 1)
{
printf_to_char(ch,"You can't jump that high.\n");
return;
}
if(find_char_xy(ch,ch->mposx,ch->mposy-1) == NULL)
{
ch->in_room->map.index[ch->mposy][ch->mposx].occupied = FALSE;
ch->in_room->map.index[ch->mposy-1][ch->mposx].occupied = TRUE;
ch->mposy--;
announce_move(ch,"north");
}
else
printf_to_char(ch,"Somebody's in the way.\n");
break;
case DIR_SOUTH:
if(hdif(ch,DIR_SOUTH) > (ch->jump) || hdif(ch,DIR_SOUTH) < -(ch->jump) || ch->mposy > 14)
{
printf_to_char(ch,"You can't jump that high.\n");
return;
}
if(find_char_xy(ch,ch->mposx,ch->mposy+1) == NULL)
{
ch->in_room->map.index[ch->mposy][ch->mposx].occupied = FALSE;
ch->in_room->map.index[ch->mposy+1][ch->mposx].occupied = TRUE;
ch->mposy++;
announce_move(ch,"south");
}
else
printf_to_char(ch,"Somebody's in the way.\n");
break;
}
return;
}
if (door < 0 || door > 5)
{
bug ("Do_move: bad door %d.", door);
return;
}
/*
* Exit trigger, if activated, bail out. Only PCs are triggered.
*/
in_room = ch->in_room;
if ((pexit = in_room->exit[door]) == NULL
|| (to_room = pexit->u1.to_room) == NULL
|| !can_see_room (ch, pexit->u1.to_room))
{
send_to_char ("Alas, you cannot go that way.\n\r", ch);
return;
}
if (IS_SET (pexit->exit_info, EX_CLOSED)
|| IS_SET (pexit->exit_info, EX_NOPASS))
{
act ("The $d is closed.", ch, NULL, pexit->keyword, TO_CHAR);
return;
}
if (!is_room_owner (ch, to_room) && room_is_private (to_room))
{
send_to_char ("That room is private right now.\n\r", ch);
return;
}
if ( ch->invis_level < LEVEL_HERO)
act ("$n leaves $T.", ch, NULL, dir_name[door], TO_ROOM);
char_from_room (ch);
char_to_room (ch, to_room);
if ( ch->invis_level < LEVEL_HERO)
act ("$n has arrived.", ch, NULL, NULL, TO_ROOM);
do_function (ch, &do_look, "auto");
if (in_room == to_room) /* no circular follows */
return;
for (fch = in_room->people; fch != NULL; fch = fch_next)
{
fch_next = fch->next_in_room;
if (fch->master == ch && fch->position == POS_STANDING
&& can_see_room (fch, to_room))
{
if (IS_SET (ch->in_room->room_flags, ROOM_LAW)
&& (IS_NPC (fch) && IS_SET (fch->act, ACT_AGGRESSIVE)))
{
act ("You can't bring $N into the city.",
ch, NULL, fch, TO_CHAR);
act ("You aren't allowed in the city.",
fch, NULL, NULL, TO_CHAR);
continue;
}
act ("You follow $N.", fch, NULL, ch, TO_CHAR);
move_char (fch, door, TRUE);
}
}
/*
* If someone is following the char, these triggers get activated
* for the followers before the char, but it's safer this way...
*/
// if(number_range(1,10) > 2)
// gen_random_battle(ch);
return;
}
