void Player::choose() { int type; int n_sectors = m_cake->get_size(); float first_ev, second_ev; CakeCut *ck = m_cake->get_cake_cut(0); calculatePieceEvaluation(0, ck->get_cut_sector(), 0, ck->get_cut_point(), first_ev); cout << "Player " << m_id << " evaluates the first piece of cake as: "<< first_ev << endl; calculatePieceEvaluation(ck->get_cut_sector(), n_sectors - 1 , ck->get_cut_point(), 1, second_ev); cout << "Player " << m_id << " evaluates the second piece of cake as: "<< second_ev << endl; Piece *left_piece; Piece *right_piece; if(first_ev > second_ev) { left_piece = new Piece(this, new CakeCut(this, 0, 0), ck); set_piece(left_piece); m_cake->set_chosen(0); } else { right_piece = new Piece(this, ck, new CakeCut(this, n_sectors - 1, 1)); set_piece(right_piece); m_cake->set_chosen(0); } }
int ky_turn(t_program *tetris, t_tetrimino *tet) { tet->rot = (tet->rot + 1); set_piece(tet); if (move_piece(tetris, tet, &tetris->posit)) { tet->rot = (tet->rot - 1); set_piece(tet); } return (0); }
int solve_map(t_map *map, t_list *list) { int x; int y; t_etris *tetri; if (list == NULL) return (1); y = 0; tetri = (t_etris *)(list->content); while (y < map->size - tetri->height + 1) { x = 0; while (x < map->size - tetri->width + 1) { if (place(tetri, map, x, y)) { if (solve_map(map, list->next)) return (1); else set_piece(tetri, map, point_new(x, y), '.'); } x++; } y++; } return (0); }
Board(Board *b) { // Allocate board memory board.resize(BOARD_SIZE); for (int i = 0; i < BOARD_SIZE; ++i) { for (int j = 0; j < BOARD_SIZE; ++j) { board[i].push_back(NULL); } } // Initialize board to match argument board. for (int i = 0; i < BOARD_SIZE; ++i) { for (int j = 0; j < BOARD_SIZE; ++j) { set_piece(i, j, b->get_piece(i, j)); } } // Set parent board. set_parent(b); // Set player move of current board. turn = !b->get_player(); }
void Player::take() { int n_sectors = m_cake->get_size(); Piece *left_piece; Piece *right_piece; if(m_cake->get_chosen() == 1) { left_piece = new Piece(this, new CakeCut(this, 0, 0), m_cake->get_cake_cut(0)); set_piece(left_piece); } else { right_piece = new Piece(this, m_cake->get_cake_cut(0), new CakeCut(this, n_sectors - 1, 1)); set_piece(right_piece); } }
char *read_piece(piece_t *piece, unsigned long number) { int c; unsigned long rows, columns, cell, i, j; scanf("%lu", &rows); if (!rows) { return NULL; } scanf("%lu", &columns); if (!columns) { return NULL; } while (fgetc(stdin) != '\n'); if (!set_piece(piece, number, rows, columns, 0UL)) { return NULL; } cell = 0; for (i = 0; i < piece->rows; i++) { j = 0; do { c = fgetc(stdin); if (c == '\n') { break; } else if (isblock(c)) { piece->blocks_n++; piece->cells[cell] = (char)c; } else { piece->cells[cell] = ' '; } cell++; j++; } while (j < piece->columns1); if (j < piece->columns1) { while (j < piece->columns1) { piece->cells[cell++] = ' '; j++; } } else { while (fgetc(stdin) != '\n'); } piece->cells[cell++] = '\n'; } piece->cells[cell] = 0; if (!piece->blocks_n || !set_piece_blocks(piece)) { FREE(piece->cells); } return piece->cells; }
char *flip_piece(piece_t *piece, piece_t *flipped) { unsigned long i, j; if (!set_piece(flipped, piece->number, piece->rows, piece->columns1, piece->blocks_n)) { return NULL; } for (i = 0; i < flipped->cells_n; i += flipped->columns2) { for (j = 0; j < flipped->columns2; j++) { flipped->cells[i+j] = piece->cells[flipped->cells_n-flipped->columns2-i+j]; } } flipped->cells[flipped->cells_n] = 0; if (!set_piece_blocks(flipped)) { FREE(flipped->cells); } return flipped->cells; }
char *rotate_piece(piece_t *piece, piece_t *rotated) { unsigned long i, j; if (!set_piece(rotated, piece->number, piece->columns1, piece->rows, piece->blocks_n)) { return NULL; } for (i = 0; i < rotated->rows; i++) { for (j = 0; j < rotated->columns1; j++) { rotated->cells[i*rotated->columns2+j] = piece->cells[piece->cells_n-piece->columns2-j*piece->columns2+i]; } rotated->cells[i*rotated->columns2+j] = '\n'; } rotated->cells[rotated->cells_n] = 0; if (!set_piece_blocks(rotated)) { FREE(rotated->cells); } return rotated->cells; }
bool Board::drop_pieces(Tetris_Shape& shape, const bool to_bottom) { //Move down shape.y(shape.y() + 1); //If bottom or there is a collison, stop, else continue if (shape.y() >= 0 && collision_below(shape) && shape.setable()) { shape.y(shape.y() - 1); set_piece(shape); return false; } else if (shape.y() >= 0 && collision_below(shape) && !shape.setable()) { shape.y(shape.y() - 1); return false; } if (to_bottom && shape.y() >= 0 && !collision_below(shape)) { drop_pieces(shape, true); } return true; }
int game_t::stonify(struct cell_t *cell) { int i; int len = 0; int x = cell->x; int y = cell->y; int left = countline(cell, -1, 0); int right = countline(cell, +1, 0); int up = countline(cell, 0, -1); int down = countline(cell, 0, +1); int topleft = countline(cell, -1, -1); int topright = countline(cell, +1, -1); int botleft = countline(cell, -1, +1); int botright = countline(cell, +1, +1); if (left + right + 1 >= 5) { for (i = 0; i < left; i++) { set_piece(x - (i + 1), y, BOARD_STONE, DROP_FLOATER); len++; } for (i = 0; i < right; i++) { set_piece(x + (i + 1), y, BOARD_STONE, DROP_FLOATER); len++; } } if (up + down + 1 >= 5) { for (i = 0; i < up; i++) { set_piece(x, y - (i + 1), BOARD_STONE, DROP_FLOATER); len++; } for (i = 0; i < down; i++) { set_piece(x, y + (i + 1), BOARD_STONE, DROP_FLOATER); len++; } } if (topleft + botright + 1 >= 5) { for (i = 0; i < topleft; i++) { set_piece(x - (i + 1), y - (i + 1), BOARD_STONE, DROP_FLOATER); len++; } for (i = 0; i < botright; i++) { set_piece(x + (i + 1), y + (i + 1), BOARD_STONE, DROP_FLOATER); len++; } } if (topright + botleft + 1 >= 5) { for (i = 0; i < topright; i++) { set_piece(x + (i + 1), y - (i + 1), BOARD_STONE, DROP_FLOATER); len++; } for (i = 0; i < botleft; i++) { set_piece(x - (i + 1), y + (i + 1), BOARD_STONE, DROP_FLOATER); len++; } } if (len > 0) { set_piece(x, y, BOARD_STONE, DROP_FLOATER); len++; } return len; }
// parse_fen_board // Input: board representation as a fen string // unpopulated board position struct // Output: index of where board description ends or 0 if parsing error // (populated) board position struct static int parse_fen_board(position_t *p, char *fen) { // Invariant: square (f, r) is last square filled. // Fill from last rank to first rank, from first file to last file fil_t f = -1; rnk_t r = BOARD_WIDTH - 1; // Current and next characters from input FEN description char c, next_c; // Invariant: fen[c_count] is next character to be read int c_count = 0; // Loop also breaks internally if (f, r) == (BOARD_WIDTH-1, 0) while ((c = fen[c_count++]) != '\0') { int ori; ptype_t typ; switch (c) { // ignore whitespace until the end case ' ': case '\t': case '\n': case '\r': if ((f == BOARD_WIDTH - 1) && (r == 0)) { // our job is done return c_count; } break; // digits case '1': if (fen[c_count] == '0') { c_count++; c += 9; } case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9': while (c > '0') { if (++f >= BOARD_WIDTH) { fen_error(fen, c_count, "Too many squares in rank.\n"); return 0; } base_board.board[square_of(r, f)] = EMPTY_PIECE; c--; } break; // pieces case 'N': if (++f >= BOARD_WIDTH) { fen_error(fen, c_count, "Too many squares in rank"); return 0; } next_c = fen[c_count++]; if (next_c == 'N') { // White King facing North ori = NN; typ = KING; } else if (next_c == 'W') { // White Pawn facing NW ori = NW; typ = PAWN; } else if (next_c == 'E') { // White Pawn facing NE ori = NE; typ = PAWN; } else { fen_error(fen, c_count+1, "Syntax error"); return 0; } set_piece(p, r, f, typ, ori, WHITE, &base_board); break; case 'n': if (++f >= BOARD_WIDTH) { fen_error(fen, c_count, "Too many squares in rank"); return 0; } next_c = fen[c_count++]; if (next_c == 'n') { // Black King facing North ori = NN; typ = KING; } else if (next_c == 'w') { // Black Pawn facing NW ori = NW; typ = PAWN; } else if (next_c == 'e') { // Black Pawn facing NE ori = NE; typ = PAWN; } else { fen_error(fen, c_count+1, "Syntax error"); return 0; } set_piece(p, r, f, typ, ori, BLACK, &base_board); break; case 'S': if (++f >= BOARD_WIDTH) { fen_error(fen, c_count, "Too many squares in rank"); return 0; } next_c = fen[c_count++]; if (next_c == 'S') { // White King facing SOUTH ori = SS; typ = KING; } else if (next_c == 'W') { // White Pawn facing SW ori = SW; typ = PAWN; } else if (next_c == 'E') { // White Pawn facing SE ori = SE; typ = PAWN; } else { fen_error(fen, c_count+1, "Syntax error"); return 0; } set_piece(p, r, f, typ, ori, WHITE, &base_board); break; case 's': if (++f >= BOARD_WIDTH) { fen_error(fen, c_count, "Too many squares in rank"); return 0; } next_c = fen[c_count++]; if (next_c == 's') { // Black King facing South ori = SS; typ = KING; } else if (next_c == 'w') { // Black Pawn facing SW ori = SW; typ = PAWN; } else if (next_c == 'e') { // Black Pawn facing SE ori = SE; typ = PAWN; } else { fen_error(fen, c_count+1, "Syntax error"); return 0; } set_piece(p, r, f, typ, ori, BLACK, &base_board); break; case 'E': if (++f >= BOARD_WIDTH) { fen_error(fen, c_count, "Too many squares in rank"); return 0; } next_c = fen[c_count++]; if (next_c == 'E') { // White King facing East set_piece(p, r, f, KING, EE, WHITE, &base_board); } else { fen_error(fen, c_count+1, "Syntax error"); return 0; } break; case 'W': if (++f >= BOARD_WIDTH) { fen_error(fen, c_count, "Too many squares in rank"); return 0; } next_c = fen[c_count++]; if (next_c == 'W') { // White King facing West set_piece(p, r, f, KING, WW, WHITE, &base_board); } else { fen_error(fen, c_count+1, "Syntax error"); return 0; } break; case 'e': if (++f >= BOARD_WIDTH) { fen_error(fen, c_count, "Too many squares in rank"); return 0; } next_c = fen[c_count++]; if (next_c == 'e') { // Black King facing East set_piece(p, r, f, KING, EE, BLACK, &base_board); } else { fen_error(fen, c_count+1, "Syntax error"); return 0; } break; case 'w': if (++f >= BOARD_WIDTH) { fen_error(fen, c_count, "Too many squares in rank"); return 0; } next_c = fen[c_count++]; if (next_c == 'w') { // Black King facing West set_piece(p, r, f, KING, WW, BLACK, &base_board); } else { fen_error(fen, c_count+1, "Syntax error"); return 0; } break; // end of rank case '/': if (f == BOARD_WIDTH - 1) { f = -1; if (--r < 0) { fen_error(fen, c_count, "Too many ranks"); return 0; } } else { fen_error(fen, c_count, "Too few squares in rank"); return 0; } break; default: fen_error(fen, c_count, "Syntax error"); return 0; break; } // end switch } // end while if ((f == BOARD_WIDTH - 1) && (r == 0)) { return c_count; } else { fen_error(fen, c_count, "Too few squares specified"); return 0; } }
int maxValue(QuartoPiece a, QuartoBoard *board, MinimaxRes *res, int numPly, int alpha, int beta) { int local_alpha = -10000000; for(int i = 0; i < 4; i++){ for(int j = 0; j < 4; j++){ if(!is_valid_piece(&GET_PIECE(j, i, board->board))){ QuartoBoard newB = *board; set_piece(&newB, j, i, &a); int won = quarto_win(&newB); if(newB.size == 16){ //This placement filled up the board which means that //we can't go further down so we just update the x, j //and return the value of this end state res->x = j; res->y = i; return won*100; }else if(won){ //This is the maximum we can get, which means that we won the game //no reason to go further down since this lead to a victory res->x = j; res->y = i; return 100; }else if(numPly == 0){ //We have reached the bottom of the recursion //and we need only evaluate the possible placements //of the piece that we have gotten int quarto_value = quarto_herustic(&newB); if(quarto_value > local_alpha){ local_alpha = quarto_value; res->x = j; res->y = i; } if(local_alpha >= beta) return local_alpha; }else{ int pieces_left[16]; //Array with 0 or 1 to indicate if the pieces //in that index is available prep_available(&newB, pieces_left); for(int k = 0; k < 16; k++){ if(pieces_left[k]){ MinimaxRes r; int value = minValue(create_piece_from_int(k), &newB, &r, numPly-1, local_alpha, beta); if(value > local_alpha){ //The value we got from below is better //than what we have currently found //which means we need to keep this //position and update our alpha res->x = j; res->y = i; res->next_piece = k; local_alpha = value; } //If alpha is lager than beta there is //no use continuing because the min node above //will always chose the path that lead to beta if(local_alpha >= beta) return local_alpha; } } } } } } return local_alpha; }
int minValue(QuartoPiece a, QuartoBoard *board, MinimaxRes *res, int numPly, int alpha, int beta) { int local_beta = 1000000; for(int i = 0; i < 4; i++){ for(int j = 0; j < 4; j++){ if(!is_valid_piece(&GET_PIECE(j, i, board->board))){ QuartoBoard newB = *board; set_piece(&newB, j, i, &a); int won = quarto_win(&newB); if(newB.size == 16){ //This placement filled up the board which means that //we can't go further down so we just update the x, j //and return the value of this end state res->x = j; res->y = i; return won*-100; }else if(won){ //This is the maximum we can get, which means that we won the game //no reason to go further down since this lead to a victory res->x = j; res->y = i; return -100; }else if(numPly == 0){ //We have reached the bottom of the recursion //and we need only evaluate the possible placements //of the piece that we have gotten int quarto_value = quarto_herustic(&newB)*(-1); if(quarto_value < local_beta){ local_beta = quarto_value; res->x = j; res->y = i; } if(local_beta <= alpha) return local_beta; }else{ int pieces_left[16]; //Array with 0 or 1 to indicate if the pieces //in that index is available prep_available(&newB, pieces_left); for(int k = 0; k < 16; k++){ if(pieces_left[k]){ MinimaxRes r; int value = maxValue(create_piece_from_int(k), &newB, &r, numPly-1, alpha, local_beta); if(value < local_beta){ //The value we got from below is smaller //than the best beta we have found which //means we want that, so we need to update //x, y and update beta res->x = j; res->y = i; res->next_piece = k; local_beta = value; } //Our beta value is smaller than alpha //which means that the max "node" above //will always chose the path which leads //to that alpha value and there is no use //in recursing any more if(local_beta <= alpha) return local_beta; } } } } } } return local_beta; }