//function to print the board void print_board(board_t *board, player_t *player, int player_id, int turn) { //print this if player1 if (player_id == 1) { print_player(player, turn); print_hand(&player->player_hand, &player->player_deck); printf("\n"); } //print the middle of the board printf("# "); if (board->lane1 == 0) { printf(" "); } else{ play_card(&board->lane1_card); } printf(" # "); if (board->lane2 == 0) { printf(" "); } else { play_card(&board->lane2_card); } printf(" # "); if (board->lane3 == 0) { printf(" "); } else { play_card(&board->lane3_card); } printf(" # "); if (board->lane4 == 0) { printf(" "); } else { play_card(&board->lane4_card); } printf(" # "); if (board->lane5 == 0) { printf(" "); } else { play_card(&board->lane5_card); } printf(" #\n\n"); //print this if player2 if (player_id == 2) { print_hand(&player->player_hand, &player->player_deck); print_player(player, turn); } if(board->lane1_card.special_index != 0){board->lane1=0;} if(board->lane2_card.special_index != 0){board->lane2=0;} if(board->lane3_card.special_index != 0){board->lane3=0;} if(board->lane4_card.special_index != 0){board->lane4=0;} if(board->lane5_card.special_index != 0){board->lane5=0;} }
static void card_clicked (HandDisplay *handdisp, int card, int *seatp) { if (card == -1) return; PROTECT_BEGIN; board *b = CUR_BOARD; assert (card >= 0 && card < 52); //printf("Clicked: %s for %c.\n", card_string(card), "WNES"[*seatp - 1]); int redraw = 0; if (*seatp != b->current_turn && b->n_played_cards > 0 && b->dealt_cards[b->played_cards[b->n_played_cards - 1]] == *seatp) { /* quick undo */ rewind_card (b); redraw = 1; } if (play_card(b, *seatp, card)) { redraw = 1; } if (redraw) { compute_dd_scores (b, run_dd); show_board(b, REDRAW_HANDS | REDRAW_NAMES | REDRAW_TRICKS | REDRAW_PLAY); } PROTECT_END; }
int turn(board_t *board){ int attack_lane, put_lane, put_num, i, check_card; switch(turn_options()){ case 1: i = 0; check_card=0; while(i < NUM_OF_CARDS_IN_HAND){ ++i; if((board->p[P_ONE].hand[i].name[0]!='\0')&&(board->p[P_ONE].hand[i].force!=0)&& (board->p[P_ONE].hand[i].life!=0)&&(board->p[P_ONE].hand[i].cost!=0)&& (board->p[P_ONE].hand[i].cost <= board->p[P_ONE].manapool.current_mana)){ check_card=1; break; } } if(check_card==0){ printf("Not enough mana\n"); break; } printf("Choose a lane\n"); while(1) { put_lane = validate_input(1, 5); // if the lane is not taken if(is_card_empty(board->lanes[P_ONE][put_lane-1])) { break; } printf("This line is taken.\n"); } --put_lane; // the counting is 1-based while(1) { print_hand(board->p[P_ONE]); printf("Choose number of corresponding card\n"); put_num = validate_input(1, num_of_cards_in_hand(board->p[P_ONE])); --put_num; // the actual game uses 0-based counting // mostly needed for when this function is used for the AI if(can_play_card(board, P_ONE, get_card_from_hand(&board->p[P_ONE], put_num), put_lane)){ break; } sleep(2); } play_card(board, P_ONE, get_card_from_hand(&board->p[P_ONE], put_num), put_lane); break; case 2: // yep, empty case; SUE ME mwahahaha break; case 3: return 1; case 4: return shuffleChoice(board->p[P_ONE].deck); break; } return 0; }
int main() { struct board_t board; int winner = 0; int pTurn = 0; int pCard = 0; int mLane = 0; struct card_t generatedCard; struct deck_t generatedDeck = GenerateMultipleCards(30); WriteGeneratedDeckToFile(&generatedDeck,"idiocracy.csv"); generatedCard = GenerateCard(); print_card(generatedCard,1); // INIT STUFF HERE ! if (!init_board(&board)) { printf("Error.File Not Found! WTF, DO NOT TOUCH THE DATA !\n"); return -1; } // ================= winner = 0; while(winner == 0) { pCard = 0; turn_begin(&board.Player[pTurn]); //Print Board Here ! PrintBoard(board); //================== if (pTurn == 0) while (pCard != 6) { printf("Choose card:"); scanf("%d",&pCard); if (pCard !=6 && board.Player[pTurn].Open_Spots_Hand[pCard-1] != 1) { printf("\nChoose lane:"); scanf("%d",&mLane); int result = play_card(&board,pTurn,pCard-1,mLane-1); PrintBoard(board); } } else RunSimpleAI(&board,pTurn); turn_end(&board,pTurn); if (board.Player[pTurn].health <= 0) { winner = 1-pTurn; break; } pTurn = 1-pTurn; } printf("\n\nWinner is Player: %d\n\n",winner+1); return 0; }
int main() { struct card_t card[2]; struct deck_t deck1; struct player_t Player1; struct board_t board; int winner = 0; int pTurn = 0; int pCard = 0; int mLane = 0; // INIT STUFF HERE ! if (!init_board(&board)) { printf("Error.File Not Found! WTF, DO NOT TOUCH THE DATA !\n"); return -1; } // ================= winner = 0; while(winner == 0) { pCard = 0; turn_begin(&board.Player[pTurn]); //Print Board Here ! PrintBoard(board); //================== while (pCard != 6) { printf("Choose card:"); scanf("%d",&pCard); if (pCard !=6 && board.Player[pTurn].Open_Spots_Hand[pCard-1] != 1) { printf("\nChoose lane:"); scanf("%d",&mLane); int result = play_card(&board,pTurn,pCard-1,mLane-1); PrintBoard(board); } } turn_end(&board,pTurn); pTurn = 1-pTurn; if (board.Player[pTurn].health <= 0) winner = pTurn+1; } if("\n\nWinner is Player: %d\n\n",winner); return 0; }
void RunSimpleAI(struct board_t *board, int pTurn) { int hasMana = 1; int CardToPlay = 0; while(hasMana) { int i; for (i = 1; i < 5; i++ ) { if (board -> Player[pTurn].Open_Spots_Hand[i] != 1) //Check if there is Card in the hand slot if (board->Player[pTurn].cards_in_hand.card_deck[i].mana < board -> Player[pTurn].cards_in_hand.card_deck[CardToPlay].mana) //Checks mana cost on the current card vs selected . CardToPlay = i; } //Look for empty lanes to put the card in. for (i = 0; i < 5; i ++) if (board -> Card_Positions[i][pTurn] == -1) { i = play_card(board,pTurn,CardToPlay,i); if (i == 2) hasMana = 0; break; } } }
int main() { struct board_t boardd; int player = 0; init_board(&boardd); init_deck(&boardd.Player[player].deck); card_generator( &boardd, player); //deck_from_file(&boardd, "ggop.txt", player); init_player(&boardd.Player[player]); init_manapool(&boardd.Player[player].manapool); init_deck(&boardd.Player[player + 1].deck); //card_generator( *boardd, player + 1); deck_from_file(&boardd, "ggopme.txt", player + 1); init_player(&boardd.Player[player +1]); init_manapool(&boardd.Player[player + 1].manapool); int i; for(i = 0; i < 5; i++){ turn_begin( &boardd.Player[player]); turn_begin( &boardd.Player[player + 1]); } int card; int board_num = 0; int board_num2 = 0; int choice; player++; do{ if ( bot(&boardd,&board_num2) == 1 ) board_num2++; PrintBoard(boardd); scanf("%d",&choice); if (choice > 0 && choice <= 5 ){ card = choice - 1; if (play_card(&boardd, player, card, board_num) == 1 ) { boardd.Card_Positions[board_num][player] = 0; board_num++; boardd.Player[player].manapool.left -= boardd.Player[player].cards_in_hand[card].magic_cost; /*struct card_t card_to_use; draw_card(&boardd.Player[player].deck, &card_to_use); boardd.Player[player].cards_in_hand[card] = card_to_use;*/ } } PrintBoard(boardd); turn_end(&boardd, player, &board_num, &board_num2); PrintBoard(boardd); char a; scanf("%s",&a); //system("cls"); printf("\033[2J\033[1;1H"); if(board_num >= 5) board_num = 0; if(board_num2 >= 5) board_num2 = 0; }while(boardd.Player[player].health > 0 && boardd.Player[1 - player].health > 0); if(boardd.Player[player].health > 0) printf("Ti pechelish ;) \n"); else printf("Ti gubish\n"); return 0; }
/* * Perform the given action. */ static void perform_act(game *g, action a) { player *p, *opp; int old_phase; /* Get player pointers */ p = &g->p[g->turn]; opp = &g->p[!g->turn]; /* Remember current phase */ old_phase = p->phase; /* Switch on action */ switch (a.act) { /* No action, advance phase counter */ case ACT_NONE: { /* Advance phase counter */ p->phase++; /* Take care of bookkeeping */ switch (old_phase) { /* Start of turn */ case PHASE_START: /* Start turn */ start_turn(g); /* Done */ break; /* After support/booster */ case PHASE_AFTER_SB: /* End support phase */ end_support(g); /* Done */ break; /* Refresh hand */ case PHASE_REFRESH: /* Refresh */ refresh_phase(g); /* Done */ break; /* End of turn */ case PHASE_END: /* End current turn */ end_turn(g); /* Done */ break; /* Move to next player */ case PHASE_OVER: /* Player is done */ p->phase = PHASE_NONE; /* Next player */ g->turn = !g->turn; /* Start opponent's turn */ opp->phase = PHASE_START; /* Done (completely) */ return; } /* Clear last played card */ p->last_played = 0; /* Done */ break; } /* Retreat */ case ACT_RETREAT: { /* Retreat */ retreat(g); /* Done */ break; } /* Retrieve a card */ case ACT_RETRIEVE: { /* Set last played */ p->last_played = a.index; /* Retrieve card */ retrieve_card(g, a.arg); /* Done */ break; } /* Play a card */ case ACT_PLAY: { /* Set last played */ p->last_played = a.index; /* Play card */ play_card(g, a.arg, 0, 0); /* Done */ break; } /* Play a card without special effect */ case ACT_PLAY_NO: { /* Set last played */ p->last_played = a.index; /* Play card */ play_card(g, a.arg, 1, 0); /* Done */ break; } /* Announce power */ case ACT_ANN_FIRE: case ACT_ANN_EARTH: { /* Increment phase counter */ p->phase++; /* Announce power */ announce_power(g, a.act - ACT_ANN_FIRE); /* Done */ break; } /* Use card special power */ case ACT_USE: { /* Use card */ use_special(g, a.arg); /* Done */ break; } /* Satisfy opponent's "discard" card */ case ACT_SATISFY: { /* Satisfy requirement */ satisfy_discard(g, a.arg); /* Done */ break; } /* Land a ship */ case ACT_LAND: { /* Set last played */ p->last_played = a.index; /* Land ship */ land_ship(g, a.arg); /* Done */ break; } /* Load a card onto a ship */ case ACT_LOAD: { /* Set last played */ p->last_played = a.index; /* Load card */ load_card(g, a.arg, a.target); /* Done */ break; } /* Play a bluff card */ case ACT_BLUFF: { /* Set last played */ p->last_played = a.index; /* Play bluff */ play_bluff(g, a.arg); /* Done */ break; } /* Reveal a bluff card */ case ACT_REVEAL: { /* Set last played */ p->last_played = a.index; /* Reveal bluff */ reveal_bluff(g, g->turn, a.arg); /* Done */ break; } } }
int main() { //struct card_t card_to_push; struct card_t one = { "card_one", 1, 7, 3 }; struct card_t two = { "card_two", 3, 7, 10 }; struct card_t three = { "card_three", 3, 2, 5 }; struct card_t four = { "card_four", 1, 2, 2 }; struct card_t five = { "card_five", 3, 2, 4 }; struct card_t six = { "card_six", 5, 4, 1 }; struct card_t seven = { "card_seven", 6, 2, 4 }; struct card_t eight = { "card_eight", 1, 7, 2 }; struct card_t nine = { "card_nine", 3, 7, 1 }; struct card_t ten = { "card_ten", 3, 2, 2 }; struct card_t eleven = { "card_eleven", 1, 2, 2 }; struct card_t twelve = { "card_twelve", 3, 2, 4 }; struct card_t thirteen = { "card_thirteen", 5, 4, 2 }; struct card_t fourteen = { "card_fourteen", 2, 2, 1 }; struct card_t one_special = { "special_card_one", -1, 0, 1};// +5 life struct card_t two_special = { "special_card_two", -2, 0, 1};// *2 card_power and +5 card_life struct card_t three_special = { "special_card_three", -3, 0, 5};// +1 mana struct card_t shaman = {"shaman", 4, 5, 2}; struct card_t grivna = {"grivna", 6, 3, 3}; struct card_t kolelo = {"kolelo", 5, 2, 2}; //printf("%d\n", attack(&one, &two)); //--------------------------------------------------------------- //struct deck_t player_deck; //struct player_t player; struct player_t first_player; struct player_t second_player; struct deck_t first_player_deck; struct deck_t second_player_deck; first_player.name_player = "TGS"; second_player.name_player = "Baba Gusi"; init_deck(&first_player_deck); init_deck(&second_player_deck); push_card(one, &first_player_deck); push_card(two, &first_player_deck); push_card(three, &first_player_deck); push_card(four, &first_player_deck); push_card(five, &first_player_deck); push_card(six, &first_player_deck); push_card(seven, &first_player_deck); push_card(eight, &first_player_deck); push_card(nine, &first_player_deck); push_card(ten, &first_player_deck); push_card(eleven, &second_player_deck); push_card(twelve, &second_player_deck); push_card(thirteen, &second_player_deck); push_card(fourteen, &second_player_deck); push_card(one_special, &second_player_deck); push_card(two_special, &second_player_deck); push_card(three_special, &second_player_deck); push_card(shaman, &second_player_deck); push_card(grivna, &second_player_deck); push_card(kolelo, &second_player_deck); print_stack(first_player_deck); print_stack(second_player_deck); Null_player_hand(&first_player); Null_player_hand(&second_player); init_player(&first_player_deck, &first_player); init_player(&second_player_deck, &second_player); down_hp(&second_player,5); up_hp(&second_player,2); turn_begin(&first_player_deck, &first_player); turn_begin(&second_player_deck, &second_player); printf("\n--------------------------------------------------------"); printf("\nTGS hand:\n"); print_cards_in_hand(&first_player); printf("\n--------------------------------------------------------"); printf("\nBaba Gusi hand:\n"); print_cards_in_hand(&second_player); //play_card_from_hand(&player, "card_four"); struct board_t board; init_board(&board); turn_end(&board, &first_player, 0); turn_end(&board, &second_player, 1); turn_end(&board, &first_player, 0); turn_end(&board, &second_player, 1); turn_end(&board, &first_player, 0); turn_end(&board, &second_player, 1); turn_end(&board, &first_player, 0); turn_end(&board, &second_player, 1); turn_end(&board, &first_player, 0); turn_end(&board, &second_player, 1); turn_end(&board, &first_player, 0); can_play_card(&board, &first_player, 0, six, 3);// players 0 or 1 play_card(&board, &first_player, 0, six, 3);// players 0 or 1 can_play_card(&board, &second_player, 1, grivna, 3);// players 0 or 1 play_card(&board, &second_player, 1, grivna, 3);// players 0 or 1 print_board(board, first_player, second_player, 1); printf("\n--------------------------------------------------------\n"); turn_begin(&first_player_deck, &first_player); turn_begin(&second_player_deck, &second_player); play_card(&board, &first_player, 0, seven, 2);// players 0 or 1 play_card(&board, &second_player, 1, two_special, 3);// players 0 or 1 print_board(board, first_player, second_player, 3); printf("\n--------------------------------------------------------\n"); turn_begin(&first_player_deck, &first_player); turn_begin(&second_player_deck, &second_player); play_card(&board, &first_player, 0, eight, 1);// players 0 or 1 play_card(&board, &second_player, 1, shaman, 1);// players 0 or 1 print_board(board, first_player, second_player, 5); printf("\n--------------------------------------------------------\n"); winner(first_player, second_player); printf("\n--------------------------------------------------------\n"); /* //--------------------------------------------------------------- // manapool struct manapool_t pool; init_mana(&pool); print_manapool(&pool); push_mana(&pool);//2 mana push_mana(&pool);//3 mana push_mana(&pool);//4 mana push_mana(&pool);//5 mana push_mana(&pool);//6 mana printf("\nCan we put card?(yes-1, no-0): %d\n", can_put_card(one, &pool)); take_mana(one, &pool);//1 mana push_mana(&pool);//7 mana printf("\nCan we put card?(yes-1, no-0): %d\n", can_put_card(two, &pool)); take_mana(two, &pool);//3 mana push_mana(&pool);//8 mana push_mana(&pool);//9 mana push_mana(&pool);//10 mana push_mana(&pool);//10 mana printf("\nCan we put card?(yes-1, no-0): %d\n", can_put_card(two, &pool)); take_mana(three, &pool);//6 mana push_mana(&pool);//=> 10 mana //--------------------------------------------------------------- // board //--------------------------------------------------------------- */ return 0; }
void mouseClick(int button, int state, int x, int y) { float *objectCoords = getRayFromMouse(x, y); float posXs = *objectCoords; float posYs = *(++objectCoords); float posZs = *(++objectCoords); float posXe = *(++objectCoords); float posYe = *(++objectCoords); float posZe = *(++objectCoords); if (button == GLUT_LEFT_BUTTON) { // button release if (state == GLUT_UP) { if (gameData.get_game_state() == CHAT_SCREEN) { if (x > 100 && y > 510 && x < 220 && y < 550) { messages.push_back("...ready..."); glutPostRedisplay(); send_ready(); gameData.toggle_player_ready(); } } else if (gameData.get_game_state() == GAME) { if (cardGrabbed) { if (hoverCard->getY() > -0.35f) play_card(hoverID); cardGrabbed = false; } else if (attack_drag) { //&& hoverCard != attackingCard // some allowance for click-and-move? // check attack ... if (hoverCard != nullptr && hoverCard->isAttackable()) { // attack. send_attack(attackerID, hoverID); gameData.setup_attack(attackerID, hoverID); gameData.queue_action(&attack); } attack_drag = false; for (auto &it : opponent.in_play) { it.second.set_attackable(false); } } position_hand(player.hand); movX = 0; movY = 0; arrow_head_x = 0; arrow_head_y = 0; } } else if (state == GLUT_DOWN) { if (gameData.get_game_state() == GAME) { if (gameData.is_my_turn() && hoverCard == nullptr) { float t = (0.0f - posZs) / (posZe - posZs); float x = posXs + t*(posXe - posXs); float y = posYs + t*(posYe - posYs); if (x > 1.7f && y > 0.0f && x < 2.0f && y < 0.15f) { gameData.queue_action(&end_turn); } } if (gameData.is_my_turn() && hoverCard != nullptr) { if (player.hand.find(hoverID) != player.hand.end() && hoverCard->getCard().getCost() <= gameData.get_energy_player().get_current()) { cardGrabbed = true; } else if (player.in_play.find(hoverID) != player.in_play.end() && hoverCard->getCard().can_attack()) { attackingCard = hoverCard; attackerID = hoverID; attack_drag = true; arrow_head_x = hoverCard->getX() + 0.075f; arrow_head_y = hoverCard->getY() + 0.15f; bool taunt_present = false; for (auto &it : opponent.in_play) { // Highlighting creatures that can be attacked. // Problem -> visual feedback on which one you're choosing. if (it.second.getCard().getStatus() & STATUS_TAUNT) { it.second.set_attackable(true); taunt_present = true; } } for (auto &it : opponent.in_play) { if (!(it.second.getCard().getStatus() & STATUS_TAUNT)) { if (!taunt_present) { it.second.set_attackable(true); } else { it.second.set_attackable(false); } } } } } } } } glutPostRedisplay(); }