main.c

Go to the documentation of this file.

// Copyright (C) 2025  Giulio Salvi, Jacopo Paradisi
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <https://www.gnu.org/licenses/>.

 
#include "tui.h"
#include "ansi.h"
#include "main.h"
#include "logs.h"
#include "ansi_const.h"
 
int main(int argc, char** argv) {
    //     
    // return 0;
 
    srand(time(NULL));
    const GameConfiguration gameCfg = getGameConfiguration(handleCLIArguments(argv, argc), getConfigurationFromArguments(argv, argc));
    const LogsConfiguration logsCfg = gameCfg.beVerbose ? prepareLogs() : (LogsConfiguration){.fileName = "", .useConsole = true};
    
    if(gameCfg.useTui) {
        checkTerminal();
        setupTerminal();
    }
    
    clearScreen();
 
    if(gameCfg.beVerbose)
        printGameConfiguration(gameCfg, logsCfg, true);
 
    Card* deck = prepareCardDeck();
    const int playersCounter = askPlayerNumber();
    clearScreen();
 
    Game game = prepareGame(playersCounter, deck, gameCfg, logsCfg);
    if(gameCfg.beVerbose)
        printPlayers(game, false);
    
    while(!handleGamePhase(&game) && game.playersCounter) {
        removeDeadPlayers(&game);
        withdrawCards(&game);
        shuffleDeck(deck);
        giveCards(&game, deck);
 
        if(gameCfg.beVerbose)
            printPlayers(game, false);
    }
 
    withdrawCards(&game);
    removeDeadPlayers(&game);
    
    if(game.playersCounter)
        announceWinner(*game.players[0]);
    else
        printfgr("#b##%d#No player has won.#r#\n", FgBrightRed);
 
    freeDeck(deck);
    freeGame(&game);
 
    return 0;
}
 
void checkTerminal() {
    if(!checkTerminalSize()) {
        printfgr("#b##%d#The terminal is too small for the game to be played.#r#\n", FgBrightRed);
        exit(EXIT_TERMINAL_TOO_SMALL);
    }
    if(!checkTerminalHost()) {
        printf("The terminal's host is not supported. Please, use Windows Terminal App.\n");
        exit(EXIT_WINDOWS_TERMINAL_HOST_NOT_SUPPORTED);
    }
}
 
void setupTerminal() {
    #ifdef _WIN32
        SetConsoleOutputCP(CP_UTF8);
    #endif
}
 
bool checkTerminalSize() {
    int maxRows = 0, maxColumns = 0;
    screenSize(&maxColumns, &maxRows);
    
    return isTerminalSizeValid(maxRows, maxColumns);
}
 
bool checkTerminalHost() {
    #ifdef _WIN32
        HANDLE hSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
        if (hSnapshot == INVALID_HANDLE_VALUE)
            return false;
 
        DWORD processId = GetCurrentProcessId();
        while (processId != 0) {
            PROCESSENTRY32 pe32;
            pe32.dwSize = sizeof(PROCESSENTRY32);
 
            int found = 0;
            if (Process32First(hSnapshot, &pe32)) {
                do {
                    if (pe32.th32ProcessID == processId) {
                        if(strcmp(pe32.szExeFile, "WindowsTerminal.exe") == 0)
                            return true;
 
                        processId = pe32.th32ParentProcessID;
                        found = 1;
                        break;
                    }
                } while (Process32Next(hSnapshot, &pe32));
            }
 
            if (!found) {
                CloseHandle(hSnapshot);
                return false;
            }
 
            if (processId == 0) {
                CloseHandle(hSnapshot);
                return false;
            }
        }
 
        CloseHandle(hSnapshot);
        return false;
    #else
        return true;
    #endif
}
 
int randomInt(const int min, const int max) {
    return rand()%(max - min + 1) + min;
}
 
GameConfiguration askConfigurationOptionsViaTerminal() {
    GameConfiguration cfg;
    int n = -1;
    char opt = '\0';
 
    do {
        if(opt != '\0') {
            clearScreen();
            printfgr("#b##%d#The valid options are y, Y, n and N.\n#r#", (int)FgBrightRed);
        }
 
        printgr("#b#Can the players have the cards with the same rank? (y,Y,n,N) #r#");
        fflush(stdin);
        int _ = scanf("%c", &opt);
    } while(opt != 'y' && opt != 'Y' && opt != 'n' && opt != 'N');
    cfg.allowSameRank = opt == 'y' || opt == 'Y';
 
    opt = '\0';
    do {
        if(opt != '\0') {
            clearScreen();
            printfgr("#b##%d#The valid options are y, Y, n, N.\n#r#", (int)FgBrightRed);
        }
 
        printgr("#b#Can the players have the cards with the same suit? (y, Y, n, N) #r#");
        fflush(stdin);
        int _ = scanf("%c", &opt);
    } while(opt != 'y' && opt != 'Y' && opt != 'n' && opt != 'N');
    cfg.allowSameSuit = opt == 'y' || opt == 'Y';
 
    do {
        if(n < 0 && n != -1) {
            clearScreen();
            printfgr("#b##%d#The value must be positive.\n#r#", (int)FgBrightRed);
        }
 
        printgr("#b#How many LPs on the field should there be by default? #r#");
        fflush(stdin);
        const int a = scanf("%d", &n);
        if(a == 0)
            n = -2;
    } while(n < 0);
    cfg.defaultLPsOnField = n;
 
    n = -1;
    do {
        if(n <= 0 && n != -1) {
            clearScreen();
            printfgr("#b##%d#The value must be positive and not zero.\n#r#", (int)FgBrightRed);
        }
 
        printgr("#b#How many LPs should the players have by default? #r#");
        fflush(stdin);
        const int a = scanf("%d", &n);
        if(a == 0)
            n = -2;
    } while(n < 1);
    cfg.defaultPlayersLPs = n;
 
    cfg.beVerbose = false;
 
    return cfg;
}
 
int askPlayerNumber() {
    int playersCounter = 2;
 
    do {
        if(playersCounter < 2 || playersCounter > 20) {
            playersCounter = 0;
            clearScreen();
            
            printfgr("#b##%d#The players number must be between 2 and 20.\n#r#", (int)FgBrightRed);
        }
 
        printgr("#b#Please, insert the players number: #r#");
        int _ = scanf("%d", &playersCounter);
    } while(playersCounter < 2 || playersCounter > 20);
 
    return playersCounter;
}
 
Card buildCard() {
    Card card;
 
    card.suit = -1;
    card.rank = -1;
 
    return card;
}
 
Card* buildDeck() {
    Card* deck = malloc(sizeof(Card)*40);
    if(!deck)
        exit(EXIT_ALLOC_FAILURE);
 
    for(int i = 0; i < 40; i++)
        deck[i] = buildCard();
 
    return deck;
}
 
Player* buildPlayer() {
    Player* player = malloc(sizeof(Player));
    if(!player)
        exit(EXIT_ALLOC_FAILURE);
 
    player->id = -1;
    player->facedUpCard = buildCard();
    player->facedDownCard = buildCard();
    player->revealedFacedDownCard = false;
 
    return player;
}
 
Game buildGame(int playersCounter) {
    Game game;
 
    game.playersCounter = playersCounter;
    game.players = malloc(sizeof(Player*)*game.playersCounter);
    if(!game.players)
        exit(EXIT_ALLOC_FAILURE);
 
    for(int i = 0; i < game.playersCounter; i++)
        game.players[i] = buildPlayer();
 
    return game;
}
 
void freeDeck(Card* deck) {
    free(deck);
}
 
void freePlayer(Player* player) {
    free(player);
}
 
void freePlayers(Player** players, int playersCounter) {
    for(int i = 0; i < playersCounter; i++)
        freePlayer(players[i]);
    free(players);
}
 
void freeGame(Game* game) {
    freePlayers(game->players, game->playersCounter);
}
 
Card* prepareCardDeck() {
    Card* deck = buildDeck();
 
    for(int i = 0; i < 40; i++) {
        Card card = buildCard();
 
        do {
            card.suit = randomInt(Clubs, Hearts); 
            card.rank = randomInt(Ace, King);
        } while(deckHasCard(deck, card));
 
        deck[i] = card;
    }
 
    return deck;
}
 
Game prepareGame(int playersCounter, Card* deck, GameConfiguration gameConfiguration, LogsConfiguration logsConfiguration) {
    Game game = buildGame(playersCounter);
    game.lifePointsOnTheField = gameConfiguration.defaultLPsOnField;
 
    for(int i = 0; i < game.playersCounter; i++) {
        Player* player = malloc(sizeof(Player));
        if(!player)
            exit(EXIT_ALLOC_FAILURE);
        
        do
            player = preparePlayer(i + 1, deck, gameConfiguration);
        while(
            cardsWereGiven(game.players, game.playersCounter, *player) ||
            cardAreEqual(player->facedUpCard, player->facedDownCard) || (
                !gameConfiguration.allowSameRank ?
                player->facedUpCard.rank == player->facedDownCard.rank : false
            ) || (
                !gameConfiguration.allowSameSuit ?
                player->facedUpCard.suit == player->facedDownCard.suit : false
            )
        );
 
        game.players[i] = player;
    }
 
    game.gameConfiguration = gameConfiguration;
    game.logsConfiguration = logsConfiguration;
 
    return game;
}
 
Player* preparePlayer(int id, Card* deck, GameConfiguration configuration) {
    Player* player = buildPlayer();
 
    player->id = id;
    player->lifePoints = configuration.defaultPlayersLPs;
    player->facedUpCard = deck[randomInt(0, 39)];
    player->facedDownCard = deck[randomInt(0, 39)];
 
    return player;
}
 
void shuffleDeck(Card* deck) {
    for(int i = 39; i > 0; i--) {
        int j = randomInt(0, i);
 
        Card tmp = deck[i];
        deck[i] = deck[j];
        deck[j] = tmp;
    }
}
 
bool handleGamePhase(Game* game) {
    PageData* pages;
    int starterPlayerPosition = randomInt(0, game->playersCounter - 1);
    int maxRows = 0, maxColumns = 0, totalPages = 0, bestStartColumn = 0;
    
    if(game->gameConfiguration.useTui) {
        screenSize(&maxColumns, &maxRows);
        pages = getPageData(maxRows, maxColumns, game->players, game->playersCounter, &totalPages, &bestStartColumn);
 
        drawPageFrame(maxRows, maxColumns);
        cursorPosition(maxRows - (LOG_SECTION_HEIGHT + 1) + 1, 3);
 
        if(game->gameConfiguration.beVerbose)
            printPageData(pages, game->logsConfiguration, totalPages, true);
    }
 
    printfgr("The current phase starts from #b#player %d#r#.", game->players[starterPlayerPosition]->id);
    Pause(false);
 
    for(int i = 0; i < game->playersCounter; i++) {
        int position = (i + starterPlayerPosition)%game->playersCounter, id = game->players[position]->id;
 
        if(game->gameConfiguration.useTui)
            navigatePages(pages, totalPages, maxRows, maxColumns, bestStartColumn, position, game);
        else {
            Player* player = game->players[position];
            printfgr("%s#b#It's your turn, player %d!!#r# You have #b##%d#%d LPs#r#.\n", i == 0 ? "\n\n" : "", id, FgBrightCyan, player->lifePoints);
            
            revealCard(player->facedUpCard, id, true, true);
            applyEffect(game, position, true);
            printgr("\n");
 
            if(!player->revealedFacedDownCard) {
                revealCard(player->facedDownCard, id, false, false);
 
                if(revealFacedDownCard(player->facedDownCard))
                    applyEffect(game, position, false);
                else
                    printgr("#b#The card has not been revealed#r#.\n");
            } else
                printfgr("#b#Player %d#r#, your #b#faced down card#r# has been #b##%d#already revealed#r#!\n", id, FgBrightRed);
            
            Pause(true);
        }
    }
 
    announceDeadPlayers(game);
    if(game->gameConfiguration.useTui)
        freePageData(pages, totalPages);
 
    return isGameEnded(game);
}
 
bool isGameEnded(Game* game) {
    int c = 0;
 
    for(int i = 0; i < game->playersCounter; i++)
        if(game->players[i]->lifePoints > 0)
            c++;
    
    return c <= 1;
}
 
bool applyEffect(Game* game, int playerPosition, bool facedUpCard) {
    Player* player = game->players[playerPosition];
    
    if(!facedUpCard) {
        if(game->players[playerPosition]->revealedFacedDownCard) {
            printfgr("#b#Player %d's faced down card#r# has been #b##%d#already revealed#r#! #b#No effect by the last card has been applied#r#.", player->id, FgBrightRed);
            return game->gameConfiguration.useTui;
        }
        
        player->revealedFacedDownCard = true;
    }
 
    if((facedUpCard ? player->facedUpCard.rank : player->facedDownCard.rank) == Ace) {
        if(player->lifePoints > 0) {
            game->lifePointsOnTheField++;
            player->lifePoints--;
        }
        
        if(game->gameConfiguration.useTui) {
            printfgr("By the effect of the #b#player %d's faced %s card#r# now on the #b#playing field#r# there are #b##%d#%d LPs#r#.", player->id, facedUpCard ? "up" : "down", FgGreen, game->lifePointsOnTheField);
 
            return true;
        } else {
            printfgr("Now #b#player %d#r# has #b##%d#%d LPs#r#. ", player->id, FgBrightRed, player->lifePoints);
            printfgr("Now on the #b#playing field#r# there are #b##%d#%d LPs#r#.\n", FgGreen, game->lifePointsOnTheField);
 
            return false;
        }
    } else if((facedUpCard ? player->facedUpCard.rank : player->facedDownCard.rank) == Seven) {
        if(game->gameConfiguration.useTui) {
            tellFacedDownCard(game->players[(playerPosition + 1)%game->playersCounter]->facedDownCard, game->players[(playerPosition + 1)%game->playersCounter]->id);
 
            Pause(false);
            cursorHorizontalAbsolute(3);
            for(int i = 0; i < 137; i++)
                printgr(" ");
            cursorHorizontalAbsolute(3);
        } else
            revealCard(game->players[(playerPosition + 1)%game->playersCounter]->facedDownCard, game->players[(playerPosition + 1)%game->playersCounter]->id, false, true);
 
        return applyEffect(game, (playerPosition + 1)%game->playersCounter, false);
    } else if((facedUpCard ? player->facedUpCard.rank : player->facedDownCard.rank) == Jack) {
        if(player->lifePoints > 0) {
            player->lifePoints--;
            game->players[(playerPosition == 0 ? game->playersCounter : playerPosition) - 1]->lifePoints++;
        }
        
        if(!game->gameConfiguration.useTui) {
            printfgr("Now #b#player %d#r# has #b##%d#%d LPs#r#. ", player->id, FgBrightRed, player->lifePoints);
            printfgr("Now #b#player %d#r# has #b##%d#%d LPs#r#.\n", game->players[(playerPosition == 0 ? game->playersCounter : playerPosition) - 1]->id, FgGreen, game->players[(playerPosition == 0 ? game->playersCounter : playerPosition) - 1]->lifePoints);
        }
 
        return false;
    } else if((facedUpCard ? player->facedUpCard.rank : player->facedDownCard.rank) == Queen) {
        if(player->lifePoints > 0) {
            player->lifePoints--;
            game->players[(playerPosition + 2)%game->playersCounter]->lifePoints++;
        }
 
        if(!game->gameConfiguration.useTui) {
            printfgr("Now #b#player %d#r# has #b##%d#%d LPs#r#. ", player->id, FgBrightRed, player->lifePoints);
            printfgr("Now #b#player %d#r# has #b##%d#%d LPs#r#.\n", game->players[(playerPosition + 2)%game->playersCounter]->id, FgGreen, game->players[(playerPosition + 2)%game->playersCounter]->lifePoints);
        }
 
        return false;
    } else if((facedUpCard ? player->facedUpCard.rank : player->facedDownCard.rank) == King) {
        player->lifePoints += game->lifePointsOnTheField;
        game->lifePointsOnTheField = 0;
 
        if(game->gameConfiguration.useTui) {
            printfgr("By the effect of the #b#player %d's faced %s card#r# now on the #b#playing field#r# there are #b##%d#0 LPs#r#.", player->id, facedUpCard ? "up" : "down", FgBrightYellow);
            
            return true;
        } else {
            printfgr("Now #b#player %d#r# has #b##%d#%d LPs#r#. ", player->id, FgGreen, player->lifePoints);
            printfgr("Now on the #b#playing field#r# there are #b##%d#0 LPs#r#.\n", FgBrightYellow);
 
            return false;
        }
    } else {
        printfgr("#b#No effect by the player %d's faced %s card has been applied#r#.", player->id, facedUpCard ? "up" : "down");
        return game->gameConfiguration.useTui;
    }
}
 
bool revealFacedDownCard(Card card) {
    char ans = '\0';
    fflush(stdin);
 
    do {
        if(ans != '\0') {
            scrollUp(1);
            cursorHorizontalAbsolute(1);
            eraseInDisplay(0);
        }
 
        printgr("Do you want to #b#reveal#r# your #b#faced down#r# card and #b#apply its effect#r#?? (y,Y,n,N) ");
        int _ = scanf("%c", &ans);
    } while(ans != 'Y' && ans != 'N' && ans != 'y' && ans != 'n');
 
    printgr("\n");
 
    return ans == 'Y' || ans == 'y';
}
 
void giveCards(Game* game, Card* deck) {
    for(int i = 0; i < game->playersCounter; i++)
        if(game->players[i]->lifePoints > 0) {
            Player* player = buildPlayer();
            player->id = game->players[i]->id;
            player->lifePoints = game->players[i]->lifePoints;
 
            do {
                player->facedUpCard = deck[randomInt(0, 39)];
                player->facedDownCard = deck[randomInt(0, 39)];
            } while(cardsWereGiven(game->players, game->playersCounter, *player) ||
                cardAreEqual(player->facedUpCard, player->facedDownCard) ||
                (!game->gameConfiguration.allowSameRank ? player->facedUpCard.rank == player->facedDownCard.rank : false) || (!game->gameConfiguration.allowSameSuit ? player->facedUpCard.suit == player->facedDownCard.suit : false)
            );
 
            freePlayer(game->players[i]);
            game->players[i] = player;
        }
}
 
void announceDeadPlayers(Game* game) {
    for(int i = 0; i < game->playersCounter; i++)
        if(game->players[i]->lifePoints == 0)
            printfgr("#%d##b#Player %d, you are dead.#r#\n", FgBrightRed, game->players[i]->id);
}
 
int countDeadPlayers(Game* game) {
    int c = 0;
 
    for(int i = 0; i < game->playersCounter; i++)
        if(game->players[i]->lifePoints == 0)
            c++;
 
    return c;
}
 
void removeDeadPlayers(Game* game) {
    int newPlayersCounter = game->playersCounter - countDeadPlayers(game);
    if(game->playersCounter == newPlayersCounter)
        return;
    
    Player** players = (Player**)malloc(newPlayersCounter*sizeof(Player*));
    if(!players)
        exit(EXIT_ALLOC_FAILURE);
 
    for(int i = 0, p = 0; i < game->playersCounter; i++) {
        if(game->players[i]->lifePoints > 0)
            players[p++] = game->players[i];
        else
            freePlayer(game->players[i]);
    }
    free(game->players);
 
    game->players = players;
    game->playersCounter = newPlayersCounter;
}
 
void withdrawCards(Game* game) {
    for(int i = 0; i < game->playersCounter; i++) {
        game->players[i]->facedUpCard = buildCard();
        game->players[i]->facedDownCard = buildCard();
    }
}
 
void announceWinner(Player player) {
    printfgr("\n#b##%d#Congratulations player %d, you have won!!#r#\n", FgBrightGreen, player.id);
}
 
bool deckHasCard(Card* deck, Card card) {
    for(int i = 0; i < 40; i++)
        if(cardAreEqual(deck[i], card))
            return true;
    
    return false;
}
 
bool cardAreEqual(Card card1, Card card2) {
    return card1.rank == card2.rank && card1.suit == card2.suit;
}
 
bool cardsWereGiven(Player** players, int playersCounter, Player player) {
    for(int i = 0; i < playersCounter; i++)
        if(players[i]->lifePoints > 0)
            if(cardAreEqual(player.facedDownCard, players[i]->facedDownCard) || cardAreEqual(player.facedUpCard, players[i]->facedUpCard))
                return true;
 
    return false;
}
 
void printCardEffect(Card card, bool newLine) {
    if(card.rank == Ace)
        printgr("you drop #b#1 LP#r# to the #b#playing field#r#.");
    else if(card.rank >= Two && card.rank <= Six)
        printgr("#b#none#r#.");
    else if(card.rank == Seven)
        printgr("you force the #b#next player#r# to reveal #b#his faced down card#r# and #b#apply its effect#r#.");
    else if(card.rank == Jack)
        printgr("you give #b#1 LP#r# to the #b#previous player#r#.");
    else if(card.rank == Queen)
        printgr("you give #b#1 LP#r# to the #b#second following player#r#.");
    else if(card.rank == King)
        printgr("you claim #b#all#r# the #b#LPs#r# on the playing field.");
    
    if(newLine)
        printgr("\n");
}
 
void revealCard(Card card, int playerId, bool facedUp, bool newLine) {
    printfgr("Player %d #b#faced %s#r# card is a #b#", playerId, facedUp ? "up" : "down");
    printCard(card, (LogsConfiguration){.fileName = "", .useConsole = true}, false);
    printgr("#r#, the effect is: ");
    printCardEffect(card, true);
 
    if(newLine)
        printgr("\n");
}
 
void tellFacedDownCard(Card card, int playerId) {
    LogsConfiguration logsConfiguration = {.fileName = "", .useConsole = true};
    
    if(playerId == 0)
        printgr("Your");
    else
        printfgr("Player %d's", playerId);
    printgr(" #b#faced down#r# card is a #b#");
    printCard(card, logsConfiguration, false);
 
    printgr("#r#. The effect is: ");
    printCardEffect(card, false);
}