File indexing completed on 2024-04-14 04:02:24

 /*
     This file is part of the KDE games lskat program
     SPDX-FileCopyrightText: 2006 Martin Heni <kde@heni-online.de>
 
     SPDX-License-Identifier: LGPL-2.0-or-later
 */
 
 #include "engine_two.h"
 
 // Qt includes
 #include <QTimer>
 
 // KF includes
 #include <KLocalizedString>
 
 // Local includes
 #include "lskatglobal.h"
 #include "display_two.h"
 
 #define TIME_END_MOVE    1000  /* Wait this [ms] after end of move */
 
 // Constructor for the game document/engine
 EngineTwo::EngineTwo(QWidget *parent, Deck *deck, DisplayTwo *display)
                : AbstractEngine(parent)
 {
     mDisplay       = display;
     mDeck          = deck;
     mCurrentPlayer = 0;
 
     connect(mDisplay, &DisplayTwo::dealingDone, this, &EngineTwo::gameLoopStart);
 }
 
 // Initial part of the game loop. Prepare new move etc
 void EngineTwo::gameLoopStart()
 {
     if (global_debug > 1) qCDebug(LSKAT_LOG) << "GAME LOOP START";
     if (!isGameRunning()) return;
 
     // Switch to the current player
     activatePlayer(mCurrentPlayer);
 }
 
 // Middle part of the game loop. Receive input of a player
 // Here: inputId == playerNumber
 void EngineTwo::playerInput(int inputId, int playerNumber, int cardNumber)
 {
     if (global_debug > 0)
         qCDebug(LSKAT_LOG) << "Engine got player input: card=" << cardNumber
                 << "Player=" << playerNumber << "Id=" << inputId;
     if (playerNumber != mCurrentPlayer)
     {
         if (global_debug > 0)
             qCDebug(LSKAT_LOG) << "EngineTwo::playerInput: Input from wrong player";
         return;
     }
 
     Player *player = mPlayers[playerNumber];
     int height = 0;
     int card = player->getCard(cardNumber);
     // Check whether top card is still available - if not try bottom one
     if (card < 0)
     {
         height = 1;
         card = player->getCard(cardNumber + 8 * height);
     }
 
     // Check whether player still has this card
     if (card < 0)
     {
         if (global_debug > 0)
             qCDebug(LSKAT_LOG) << "EngineTwo::playerInput: Card" << cardNumber + 8 * height
                     << "not available anymore ";
         return;
     }
 
     // Remove this, Debug current card
     if (global_debug > 0)
     {
         Suite   suite = Deck::getSuite(card);
         CardType type = Deck::getCardType(card);
         qCDebug(LSKAT_LOG) << "Gameloop " <<mCurrentPlayer <<" plays" << Deck::name(suite, type);
     }
 
     // Check for legal move (first player always ok)
     if (mCurrentMovePhase == SecondPlayerTurn)
     {
         //   Check (card of player 1), (card of player 2), (player 2)
         if (!isLegalMove(mCurrentMoveCards[FirstPlayerTurn], card, playerNumber))
         {
             if (global_debug > 0)
                 qCDebug(LSKAT_LOG) << "EngineTwo::playerInput: Card" << cardNumber + 8 * height
                         << "is not a valid move ";
             return;
         }
     }
 
     // Delete card from player
     player->deleteCard(cardNumber + 8 * height);
 
     // Finish input from player
     player->stopTurn();
 
     // Play out card
     mDisplay->play(card, playerNumber, mCurrentMovePhase);
 
     // Turn back card if top card is played
     if (height == 0)
     {
         int backcard = player->getCard(cardNumber + 8);
         mCurrentTurnCards[mCurrentMovePhase] = backcard;
     }
     else
     {
         mCurrentTurnCards[mCurrentMovePhase] = -1;
     }
 
     // Store currently played card
     mCurrentMoveCards[mCurrentMovePhase] = card;
 
     // Finish game loop
     if (mCurrentMovePhase == SecondPlayerTurn)
     {
         QTimer::singleShot(TIME_END_MOVE, this, &EngineTwo::gameLoopFinish);
     }
     else
     {
         QTimer::singleShot(0, this, &EngineTwo::gameLoopFinish);
     }
 }
 
 // Final part of the game loop. Switch player etc.
 void EngineTwo::gameLoopFinish()
 {
     if (!isGameRunning()) return;
 
     // If second move phase, remove cards
     if (mCurrentMovePhase == SecondPlayerTurn)
     {
         // Turn cards if available
         if (mCurrentTurnCards[FirstPlayerTurn] >= 0)
             mDisplay->turn(mCurrentTurnCards[FirstPlayerTurn]);
         if (mCurrentTurnCards[SecondPlayerTurn] >= 0)
             mDisplay->turn(mCurrentTurnCards[SecondPlayerTurn]);
 
         // Switch the current player if second player one
         int winner = whoWonMove(mCurrentMoveCards[FirstPlayerTurn],
                                 mCurrentMoveCards[SecondPlayerTurn],
                                 mTrump);
         // The first mover won. This means to switch the current player back
         // to him.  Otherwise the current player stays untouched, that is the
         // second player plays again.
         if (winner == 0)
         {
             mCurrentPlayer = 1 - mCurrentPlayer;
         }
 
         // Move both cards away from play area. Move them to the winning mover's side
         Player *player = mPlayers[mCurrentPlayer];
         mDisplay->remove(mCurrentPlayer,
                         mCurrentMoveCards[FirstPlayerTurn],
                         player->noOfMovesWon());
         mDisplay->remove(mCurrentPlayer,
                         mCurrentMoveCards[SecondPlayerTurn],
                         player->noOfMovesWon() + 1);
         player->increaseMovesWon();
         player->addWonCard(mCurrentMoveCards[FirstPlayerTurn]);
         player->addWonCard(mCurrentMoveCards[SecondPlayerTurn]);
 
         if (global_debug > 0)
         {
             qCDebug(LSKAT_LOG) << "Winner = " << winner << "current =" << mCurrentPlayer;
             qCDebug(LSKAT_LOG) << "   He has won" << player->noOfMovesWon() << "moves.";
             qCDebug(LSKAT_LOG) << "   He has" << player->points() << "points.";
         }
         // Switch move phase (half moves)
         mCurrentMovePhase = FirstPlayerTurn;
     }
     // For the first part of a half move always swap players
     else if (mCurrentMovePhase == FirstPlayerTurn)
     {
         mCurrentPlayer = 1 - mCurrentPlayer;
         // Switch move phase (half moves)
         mCurrentMovePhase = SecondPlayerTurn;
     }
 
     // Check whether the game is over
     if (gameOver())
     {
         if (global_debug > 0) qCDebug(LSKAT_LOG) << "GAME OVER";
         mGameStatus = Stopped;
         mDisplay->showMove(-1);
         int winner = evaluateGame();
         Q_EMIT signalGameOver(winner);
     }
     // Game continues
     else
     {
         // Increase move number
         mMoveNumber++;
 
         // Delayed call to game loop start
         QTimer::singleShot(0, this, &EngineTwo::gameLoopStart);
     }
 }
 
 // Check whether the game is over
 bool EngineTwo::gameOver()
 {
     if (global_debug > 0) qCDebug(LSKAT_LOG) << "Move number in game over" << mMoveNumber;
     // Check number of moves. If all moves are done game is over.
     if (mMoveNumber >= 31) return true;
     return false;
 }
 
 // Called after game ends..give points to players
 int EngineTwo::evaluateGame()
 {
     int winner = -1;
     Player *player1 = mPlayers[0];
     Player *player2 = mPlayers[1];
 
     // Points in game
     int points1 = player1->points();
     int points2 = player2->points();
 
     // Score awarded
     int score1 = 0;
     int score2 = 0;
 
     QString text;
 
     // Game was aborted
     if (points1 + points2 != 120)
     {
         text = i18n("Game was ended - no winner");
         winner = -2;
     }
     // Drawn
     else if (points1 == points2)
     {
         // Add score
         score1 = 1;
         score2 = 1;
         text = i18n("Game is drawn");
         winner = -1;
     }
     // First player won
     else if (points1 > points2)
     {
         text = i18n("Player 1 - %1 won ", player1->name());
 
         score1 = 2;
         player1->addWonGame(1);
         if (points1 > 90)
         {
             score1 += 1;  // Schneider
             text = i18n("%1 won with over 90 points. Super!", player1->name());
         }
         // Do not use 'else if' here!
         if (points1 >= 120)
         {
             score1 += 1; // Schwarz
             text = i18n("%1 won to nil. Congratulations!", player1->name());
         }
         winner = 0;
     }
     // Second player won
     else
     {
         text = i18n("Player 2 - %1 won ", player2->name());
 
         score2 = 2;
         player2->addWonGame(1);
         if (points2 > 90)
         {
             score2 += 1;  // Schneider
             text = i18n("%1 won with over 90 points. Super!", player2->name());
         }
         // Do not use 'else if' here!
         if (points2 >= 120)
         {
             score2 += 1; // Schwarz
             text = i18n("%1 won to nil. Congratulations!", player2->name());
         }
         winner = 1;
     }
 
     // Add score to players
     player1->addScore(score1);
     player2->addScore(score2);
 
     // Display game over data
     mDisplay->showText(text);
     mDisplay->showScore(0, score1);
     mDisplay->showScore(1, score2);
 
     return winner;
 }
 
 // Start a new game
 void EngineTwo::startGame(Suite trump, int startPlayer)
 {
     // Set the new trump
     mTrump = trump;
 
     // Set game status to running
     mGameStatus    = Running;
 
     // Switch to the start player
     mCurrentPlayer = startPlayer;
 
     // Set first player to move
     mCurrentMovePhase = FirstPlayerTurn;
 
     // Game starts, reset moves
     mMoveNumber = 0;
 
     // Loop players to deal cards
     for (int p = 0; p < 2; p++)
     {
         Player *player = mPlayers[p];
         player->addGame(1); // Increase games of player
         mDisplay->deal(player, p);
     }
 
     // Delayed call to game loop start via display signal 'dealingDone'
     // (see constructor)
 }
 
 // Stop a game
 void EngineTwo::stopGame()
 {
     // Disable inputs for two players
     for (int i = 0; i < 2; i++)
     {
         mPlayers[i]->stopTurn();
     }
 
     mDisplay->showMove(-1);
 
     if (isGameRunning())
     {
         // Display game over data
         QString text = i18n("Game ended");
         mDisplay->showText(text);
 
         // Set game status to stopped
         mGameStatus    = Stopped;
         Q_EMIT signalGameOver(-2);
     }
 }
 
 // Switch the current player to the given player number.
 void EngineTwo::activatePlayer(int playerNumber)
 {
     // Disable inputs for two players
     for (int i = 0; i < 2; i++)
     {
         mPlayers[i]->stopTurn();
     }
     // enable input of current player
     Player *player = mPlayers[playerNumber];
     player->startTurn();
     mDisplay->showMove(playerNumber);
     mCurrentPlayer = playerNumber;
 
     Q_EMIT signalNextPlayer(player);
 }
 
 // Check whether the two cards played are legal, supposed the
 // given player is the second one (as the first player always
 // plays a legal card)
 bool EngineTwo::isLegalMove(int card1, int card2, int playerNumber)
 {
     Suite suite1   = Deck::getSuite(card1);
     Suite suite2   = Deck::getSuite(card2);
     CardType type1 = Deck::getCardType(card1);
     CardType type2 = Deck::getCardType(card2);
 
     // Force trump colour as Jacks count as Trump
     if (type1 == Jack) suite1 = mTrump;
     if (type2 == Jack) suite2 = mTrump;
 
     // Same suite is always ok
     if (suite1 == suite2) return true;
 
     // Search if current player has a card of the same colour
     // but didn't play it (if it was played we checked already
     // above)
     Player *p = player(playerNumber);
     bool validMove = true;
     for (int i = 0; i < 8; i++)
     {
         int card = p->getCard(i);
         // Ignore played card
         if (card == card2) continue;
 
         // Check whether top card is still available - if not try bottom one
         if (card < 0)
         {
             card = p->getCard(i + 8);
         }
         // This card is not available anymore
         if (card < 0) continue;
 
         // Analyze card
         Suite suite   = Deck::getSuite(card);
         CardType type = Deck::getCardType(card);
 
         // Force trump colour as Jacks count as Trump
         if (type == Jack) suite = mTrump;
 
         // Check whether current card matches the first player card
         if (suite == suite1)
         {
             validMove = false;
             break;
         }
     }
     return validMove;
 }
 
 // Check who won a move, the first or the second card.
 // The first card was played first and take precedence
 // when possible. The function returns 0 if the first
 // card won, 1 if the second card won.
 int EngineTwo::whoWonMove(int card1, int card2, Suite trump)
 {
     Suite suite1   = Deck::getSuite(card1);
     Suite suite2   = Deck::getSuite(card2);
     CardType type1 = Deck::getCardType(card1);
     CardType type2 = Deck::getCardType(card2);
 
     // Two jacks
     if (type1 == Jack && type2 == Jack)
     {
         if (suite1 < suite2) return 0;
         else return 1;
     }
     // One Jack wins always
     if ((int)type1 == (int)Jack) return 0;
     if ((int)type2 == (int)Jack) return 1;
 
     // Higher card wins if both have same suite
     if (suite1 == suite2)
     {
         // Check Ten because it is not in the right card
         // sequence. Ten is only beaten by Ace
         if (type1 == Ten)
         {
             if (type2 == Ace) return 1;
             else return 0;
         }
         if (type2 == Ten)
         {
             if (type1 == Ace) return 0;
             return 1;
         }
 
         // Otherwise the higher card wins
         if ((int)card1 < (int)card2) return 0;
         return 1;
     }
 
     if (global_debug > 0)
     {
         if (suite1 == trump) qCDebug(LSKAT_LOG) << "FIRST card wins TRUMP";
         if (suite2 == trump) qCDebug(LSKAT_LOG) << "SECOND card wins TRUMP";
     }
 
     // If cards are not of the same suite a trump wins
     if (suite1 == trump) return 0;
     if (suite2 == trump) return 1;
 
     // In all other cases the first card wins
     return 0;
 }
 
 #include "moc_engine_two.cpp"