//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();
}