void init_game(t_env *e)
{
t_iterator iter;
char *name;
t_team *team;
int i;
e->n_sq = e->opt.height * e->opt.width;
e->client_lst = ft_lst_new(NULL);
e->gfx_lst = ft_lst_new(NULL);
e->team = ft_lst_new(NULL);
iter = NULL;
while ((name = (char *)ft_lst_iter_next_content(e->opt.team_name, &iter)))
{
team = team_new(name, e->opt.limit);
i = 0;
while (i < team->limit)
{
ft_lst_pushend(team->unconnected, bot_new(team));
i++;
}
ft_lst_pushend(e->team, team);
}
board_create(e);
}
Test(Player, MoveUp)
{
player_t *pl = player_create_at((vector2d_t){12, 12});
board_t *bd = board_create(24, 24);
pl->p_dir = (vector2d_t){0, -1};
cr_assert_eq(pl->p_pos.v_y, 12);
cr_assert_eq(pl->p_pos.v_x, 12);
player_move_foward(pl, bd);
cr_assert_eq(pl->p_pos.v_y, 11);
cr_assert_eq(pl->p_pos.v_x, 12);
player_move_foward(pl, bd);
cr_assert_eq(pl->p_pos.v_y, 10);
cr_assert_eq(pl->p_pos.v_x, 12);
player_move_foward(pl, bd);
cr_assert_eq(pl->p_pos.v_y, 9);
cr_assert_eq(pl->p_pos.v_x, 12);
player_move_foward(pl, bd);
cr_assert_eq(pl->p_pos.v_y, 8);
cr_assert_eq(pl->p_pos.v_x, 12);
player_move_foward(pl, bd);
cr_assert_eq(pl->p_pos.v_y, 7);
cr_assert_eq(pl->p_pos.v_x, 12);
player_move_foward(pl, bd);
cr_assert_eq(pl->p_pos.v_y, 6);
cr_assert_eq(pl->p_pos.v_x, 12);
player_move_foward(pl, bd);
cr_assert_eq(pl->p_pos.v_y, 5);
cr_assert_eq(pl->p_pos.v_x, 12);
player_move_foward(pl, bd);
cr_assert_eq(pl->p_pos.v_y, 4);
cr_assert_eq(pl->p_pos.v_x, 12);
player_move_foward(pl, bd);
cr_assert_eq(pl->p_pos.v_y, 3);
cr_assert_eq(pl->p_pos.v_x, 12);
player_move_foward(pl, bd);
cr_assert_eq(pl->p_pos.v_y, 2);
cr_assert_eq(pl->p_pos.v_x, 12);
player_move_foward(pl, bd);
cr_assert_eq(pl->p_pos.v_y, 1);
cr_assert_eq(pl->p_pos.v_x, 12);
player_move_foward(pl, bd);
cr_assert_eq(pl->p_pos.v_y, 0);
cr_assert_eq(pl->p_pos.v_x, 12);
player_move_foward(pl, bd);
cr_assert_eq(pl->p_pos.v_y, 23, "got %d", pl->p_pos.v_y);
cr_assert_eq(pl->p_pos.v_x, 12);
player_move_foward(pl, bd);
cr_assert_eq(pl->p_pos.v_y, 22);
cr_assert_eq(pl->p_pos.v_x, 12);
player_move_foward(pl, bd);
cr_assert_eq(pl->p_pos.v_y, 21);
cr_assert_eq(pl->p_pos.v_x, 12);
board_delete(bd);
player_delete(pl);
}
board* board_copy(board* src) {
int i, j;
board* retval = board_create(src->rows, src->cols);
for (i=0; i < retval->rows; i++)
for (j=0; j < retval->cols; j++)
retval->grid[i][j] = src->grid[i][j];
return retval;
}
int main(void)
{
board = board_create();
white = player_create( WHITE );
black = player_create( BLACK );
play();
return 0;
}
int main(int argc, char **argv) {
// Randomise random unmber generator initial state.
srandom(time(0));
int board_size = 4;
int **board = board_create(board_size);
if (!board) {
printf("failed to create board.\n");
exit(0);
}
board_spawn_tile(board_size, board);
board_spawn_tile(board_size, board);
int tile = 0;
while (1) {
board_display(board_size, board);
printf("Next move? ");
fflush(stdout);
int action = read_input();
switch (action) {
case GO_LEFT:
tilt_board_left(board_size, board);
break;
case GO_RIGHT:
tilt_board_right(board_size, board);
break;
case GO_UP:
tilt_board_up(board_size, board);
break;
case GO_DOWN:
tilt_board_down(board_size, board);
break;
case GO_NOWHERE:
break;
case INVALID_INPUT:
default:
printf("Invalid input. Type l, r, u or d to tilt board.\n");
break;
}
if (action == INVALID_INPUT) {
printf("Invalid input. Type l, r, u or d to tilt board.\n");
}
else {
tile = board_spawn_tile(board_size, board);
}
if (tile == 1) {
break;
}
}
return 0;
}
Test(Player, Move)
{
player_t *pl = player_create_at((vector2d_t){12, 12});
board_t *bd = board_create(24, 24);
cr_assert_eq(pl->p_pos.v_x, 12);
cr_assert_eq(pl->p_pos.v_y, 12);
player_move_foward(pl, bd);
cr_assert_eq(pl->p_pos.v_x, 13);
cr_assert_eq(pl->p_pos.v_y, 12);
player_move_foward(pl, bd);
cr_assert_eq(pl->p_pos.v_x, 14);
cr_assert_eq(pl->p_pos.v_y, 12);
player_move_foward(pl, bd);
cr_assert_eq(pl->p_pos.v_x, 15);
cr_assert_eq(pl->p_pos.v_y, 12);
player_move_foward(pl, bd);
cr_assert_eq(pl->p_pos.v_x, 16);
cr_assert_eq(pl->p_pos.v_y, 12);
player_move_foward(pl, bd);
cr_assert_eq(pl->p_pos.v_x, 17);
cr_assert_eq(pl->p_pos.v_y, 12);
player_move_foward(pl, bd);
cr_assert_eq(pl->p_pos.v_x, 18);
cr_assert_eq(pl->p_pos.v_y, 12);
player_move_foward(pl, bd);
cr_assert_eq(pl->p_pos.v_x, 19);
cr_assert_eq(pl->p_pos.v_y, 12);
player_move_foward(pl, bd);
cr_assert_eq(pl->p_pos.v_x, 20);
cr_assert_eq(pl->p_pos.v_y, 12);
player_move_foward(pl, bd);
cr_assert_eq(pl->p_pos.v_x, 21);
cr_assert_eq(pl->p_pos.v_y, 12);
player_move_foward(pl, bd);
cr_assert_eq(pl->p_pos.v_x, 22);
cr_assert_eq(pl->p_pos.v_y, 12);
player_move_foward(pl, bd);
cr_assert_eq(pl->p_pos.v_x, 23);
cr_assert_eq(pl->p_pos.v_y, 12);
player_move_foward(pl, bd);
cr_assert_eq(pl->p_pos.v_x, 0);
cr_assert_eq(pl->p_pos.v_y, 12);
player_move_foward(pl, bd);
cr_assert_eq(pl->p_pos.v_x, 1);
cr_assert_eq(pl->p_pos.v_y, 12);
player_move_foward(pl, bd);
cr_assert_eq(pl->p_pos.v_x, 2);
cr_assert_eq(pl->p_pos.v_y, 12);
board_delete(bd);
player_delete(pl);
}
game_t *game_create(unsigned int board_x, unsigned int board_y,
unsigned int freq, unsigned int max_players)
{
game_t *game = malloc(sizeof(game_t));
if (!game)
return (NULL);
game->ga_freq = freq;
game->ga_max_players = max_players;
game->ga_board = board_create(board_x, board_y);
game->ga_players = list_create(NULL);
game->ga_eggs = list_create(egg_delete);
game->ga_teams = list_create(team_delete);
chrono_init(&game->ga_board->b_refresh_timer, 0);
if (!game->ga_board) {
free(game);
return (NULL);
}
return (game);
}
result_t* play(uint8_t board_size, neuralnet_t* black, neuralnet_t* white, uint8_t komi, FILE* record)
{
board_t* board = board_create(board_size);
bool game_over = false;
int8_t passed = 0;
result_t* final = result_init(black, white);
//Game loop
while(game_over == false)
{
move_t* move = genmove(board, final);
//No move left
if(move->x == -1)
{
game_over = true;
break;
}
//Pass
else if(move->x >= board_size)
{
board_pass(board);
++passed;
if(passed > 1)
{
game_over = true;
break;
}
}
//Placement
else
{
write_move(record, board->turn, (uint8_t)move->x, (uint8_t)move->y);
board_place(board, (uint8_t)move->x, (uint8_t)move->y);
passed = 0;
}
}
//Scoring
int score_val = board_score(board);
final->score_black = score_val;
// run_martet: The game loop. Returns final score.
int run_martet(SDL_Surface* screen, SDL_Surface* board) {
Tetromino* active_tetromino;
Tetromino* next_tetromino;
// Create ingame menu
struct Menu* ingame_menu = menu_create();
menu_addelement(ingame_menu, "Continue");
menu_addelement(ingame_menu, "Quit Current Game");
ingame_menu->active_element = &ingame_menu->elements[0];
ingame_menu->active_element->active = 1;
int score = 0;
srand((unsigned) time(NULL));
board_create();
next_tetromino = tetcreaterand();
update_status_bar(next_tetromino, screen, score);
active_tetromino = tetcreaterand();
active_tetromino->position[0] = 4;
struct Timer* timer = create_timer();
timer_change_alarm_interval(timer, GAME_SPEED);
timer_start(timer);
bool running = true;
while (running){
int event = process_key_events(active_tetromino, tetaction);
if (event == KEYEVENT_EXIT)
exit(0);
else if (event == KEYEVENT_MENU) {
if (ingame_menu_martet(screen, board, ingame_menu) == 1)
running = false;
}
else if (event == KEYEVENT_PAUSE)
pause_martet(screen, board);
if (timer_update(timer)) {
// If collision and tetromino not deleted
if ( tetmove('d', active_tetromino) == 0
&& active_tetromino->color != TETROMINO_DELETE) {
place_tetromino(active_tetromino);
active_tetromino->color = TETROMINO_DELETE;
}
else if ( active_tetromino->color == TETROMINO_DELETE ) {
free(active_tetromino);
active_tetromino = next_tetromino;
next_tetromino = tetcreaterand();
if (check_rows(&score)) { // If score has increased.
timer_change_alarm_interval(timer,
GAME_SPEED /
sqrt( (double) score/5) + 1);
}
}
if ( next_tetromino == NULL ) // If game over
break;
update_status_bar(next_tetromino, screen, score);
}
clear_surface(board, NULL);
draw_board(board);
draw_tetromino(board, active_tetromino);
draw_ghost_tetromino(board, active_tetromino);
draw_surface(0, 0, board, screen, NULL);
SDL_Flip(screen);
}
if (active_tetromino) {
free(active_tetromino);
}
free(next_tetromino);
free(timer);
menu_destroy(ingame_menu);
return score;
}
