rovhult.cpp

一个扑克牌游戏集合的源码,包含了很多基本c-c++语言应用

/// Checks if the passed pile has a card which can be played
/// \param player: ID of player to analyze
/// \param card: Last played card
//-----------------------------------------------------------------------------
bool Rovhult::playerCanContinue (unsigned int player, CardWidget::NUMBERS card) const {
   TRACE3 ("Rovhult::playerCanContinue (unsigned int, CardWidget::NUMBERS) const - "
           << player << "; Card: " << card);
   Check3 (player < NUM_PLAYERS);

   if (card == CardWidget::UNREACHABLE)
      return false;

   if (players[player].hand.size ())
      return playerHandCanContinue (players[player].hand, card);

   // Check pile: Analyze only visible cards; if there are none, return true
   bool hasNoVisibleCards (true);
   for (int i (0); i < 3; ++i)
      if (players[player].reserve[i].size () > 1) {
         TRACE5 ("Rovhult::playerCanContinue (unsigned int, CardWidget::NUMBERS) const"
                 " - Checking pile " << i << "; "
                 << players[player].reserve[i].size () << " cards");
         hasNoVisibleCards = false;

         CardWidget::NUMBERS nr (players[player].reserve[i].getTopCard ().number ());
         if ((nr == CardWidget::TWO) || (nr == cardNuke))
            return true;
	 else {
            TRACE7 ("Rovhult::playerCanContinue (unsigned int, CardWidget::NUMBERS) const"
                    " - Value of card: " << nr);
            if ((card == cardReverse)
                ? (nr <= cardReverse) : (nr >= card))
               return true;
	 }
      } // endif pile contains cards

   return hasNoVisibleCards ? (card != CardWidget::UNREACHABLE) : false;
}

//-----------------------------------------------------------------------------
/// Checks if the passed pile has a card which can be played
/// \param player: ID of player to analyze
/// \param card: Last played card
//-----------------------------------------------------------------------------
bool Rovhult::playerHandCanContinue (const ICardPile& pile, CardWidget::NUMBERS card) const {
   TRACE3 ("Rovhult::playerHandCanContinue (const ICardPile&, CardWidget::NUMBERS) const"
           << " - Card " << card << " in " << pile.size () << " cards");
   Check3 (pile.size ());

   // Check if first/last is smaller/bigger then passed one
   if (card == cardReverse) {
      if (pile[0]->number () <= card)
         return true;
   }
   else {
      if (pile[pile.size () - 1]->number () >= card)
         return true;
   }

   TRACE3 ("Rovhult::playerHandCanContinue (const ICardPile&, CardWidget::NUMBERS"
           " - Special check");
   // Simple check failed -> Check for special card (2 or 10)
   if (pile[0]->number () == CardWidget::TWO)
      return true;

   return pile.exists (cardNuke);
}

//-----------------------------------------------------------------------------
/// Fills up the passed pile til it contains the specified number of cards
/// \param pile: Pile to fill up
/// \param minCards: Minimal number of cards pile should hold
//-----------------------------------------------------------------------------
void Rovhult::fillUpPile (ICardPile& pile, unsigned int minCards) {
   TRACE3 ("Rovhult::fillUpPile (ICardPile&, unsinged int) - "
           << pile.size () << " -> " << minCards);

   while ((pile.size () < minCards) && staple.size ())
      pile.insertSorted (staple.removeTopCard ());
}

//-----------------------------------------------------------------------------
/// Returns the number of equal cards from the played pile
/// \returns \c unsigned int: Number of equal cards
//-----------------------------------------------------------------------------
unsigned int Rovhult::numberOfEqualTopCards () const {
   TRACE8 ("Rovhult::numberOfEqualTopCards () const");
   unsigned int nrCards (played.size ());

   if (nrCards)
      --nrCards;
   else
      return 0;

   unsigned int i (1);
   CardWidget& card (played.getTopCard ());
   while (i <= nrCards) {
      TRACE9 ("Rovhult::numberOfEqualTopCards () const - Checking "
              << played[nrCards - i] << " with " << card);

      if (played[nrCards - i]->number () != card.number ()) {
         TRACE8 ("Rovhult::numberOfEqualTopCards () const - found " << i);
         break;
      }
      ++i;
   }
   return i;
}

//-----------------------------------------------------------------------------
/// Clears the played staple if the last 4 cards are equal
/// \returns \c bool: True, if 4 equal cards found
//-----------------------------------------------------------------------------
bool Rovhult::clearPlayedIf4Equal () {
   TRACE8 ("Rovhult::clearPlayedIf4Equal ()");

   int cards (numberOfEqualTopCards ()); Check3 (cards <= 4);
   if (cards < 4)
      return false;

   TRACE7 ("Rovhult::clearPlayedIf4Equal () - found 4");
   played.clear ();
   return true;
}

//-----------------------------------------------------------------------------
/// Method to move the cards of the actual round to the winner
/// \param nrLooser: Nr. of player getting all played cards
/// \returns \c unsigned int: Next player
//-----------------------------------------------------------------------------
unsigned int Rovhult::movePlayedCardsToLooser (unsigned int nrLooser) {
   TRACE8 ("Rovhult::movePlayedCardsToLooser () - Player " << nrLooser << " gets "
           << played.size () << " cards");
   Check3 (nrLooser < NUM_PLAYERS);
   Check3 (played.size ());
   Check3 (actPlayers[nrLooser]);

   movePile (players[nrLooser].hand, played);
   players[nrLooser].hand.sortByNumber ();
   Glib::ustring stat (_("%1 can't continue -> Taking the whole pile. "));
   stat.replace (stat.find ("%1"), 2, actPlayers[nrLooser]->getName ());
   displayTurn (nrLooser = nextAvailablePlayer (nrLooser), stat);
   return nrLooser;
}

//-----------------------------------------------------------------------------
/// Checks which player has still cards left
/// \param actPlayer: ID of actual player
/// \returns \c int: ID of player or -1 (if none can continue)
//-----------------------------------------------------------------------------
int Rovhult::nextAvailablePlayer (unsigned int actPlayer) const {
   // We assume (without checking), that the acutal player still has cards
   for (unsigned int i (1); i < NUM_PLAYERS; ++i) {
      actPlayer = (actPlayer + 1) & 0x3;
      if ((players[actPlayer].hand.size ())
          || players[actPlayer].reserve[0].size ()
          || players[actPlayer].reserve[1].size ()
          || players[actPlayer].reserve[2].size ()) {
         TRACE8 ("Rovhult::nextAvailablePlayer (unsigned int) const - Player: " << actPlayer);
         return actPlayer;
      }
   }
   return -1;
}

//-----------------------------------------------------------------------------
/// Remove cards from everything which can hold them and unregister any
/// signals (DND)
//-----------------------------------------------------------------------------
void Rovhult::clean () {
   TRACE8 ("Rovhult::clean () - Status: " << gameStatus ());

   if (gameStatus () == EXCHANGE)
      unregisterDND ();

   staple.clear ();                                             // Clear staple
   for (unsigned int i (0); i < NUM_PLAYERS; ++i) {   // Clear cards of players
      for (unsigned int j (0); j < 3; ++j)
         players[i].reserve[j].clear ();

      players[i].hand.clear ();
   }
   played.clear ();

   players[0].hand.setStyle (ICardPile::NORMAL);
   disableHuman ();

   Game::clean ();
}

//-----------------------------------------------------------------------------
/// Prepares the card for drag磏磀rop (starting from the table, ending on the
/// hand or ending on the table, starting from the hand)
/// \param card: Card to prepare for drag磏磀rop
/// \param pile: Number of pile on reserve holding card
//-----------------------------------------------------------------------------
void Rovhult::registerTableDND (CardWidget& card, unsigned int pile) {
   TRACE8 ("Rovhult::registerTableDND (CardWidget&, unsigned int) - "
           << card << " for pile " << pile);
   Check1 (pile < 3);
   Check3 (gameStatus () == EXCHANGE);

   // Card accepts drops from hand and drags from table
   card.drag_dest_set (dndTypeHand, Gtk::DEST_DEFAULT_ALL, Gdk::ACTION_MOVE);
   card.drag_source_set
      (dndTypeTable, Gdk::ModifierType (GDK_BUTTON1_MASK | GDK_BUTTON2_MASK | GDK_BUTTON3_MASK),
                                        Gdk::ACTION_MOVE);

   card.drag_source_set_icon (card.getImage ());
   aTableDND[&card] = card.signal_drag_data_received ().connect
       (bind (mem_fun (*this, &Rovhult::cardDroppedOnTable), pile));
   aTableData[&card] = card.signal_drag_data_get ().connect
       (bind (mem_fun (*this, &Rovhult::getDropData), pile));
}

//-----------------------------------------------------------------------------
/// Prepares the card for drag磏磀rop (starting from the hand ending on table
/// or ending on hand, starting from table)
/// \param card: Card to prepare for drag磏磀rop
/// \param pile: Number of pile on reserve holding card
//-----------------------------------------------------------------------------
void Rovhult::registerHandDND (CardWidget& card,  unsigned int iCard) {
   TRACE8 ("Rovhult::registerHandDND (CardWidget&, unsigned int) - " << card
           << "; pos " << iCard);
   Check3 (gameStatus () == EXCHANGE);

   // Card accepts drops from table and drags from hand
   card.drag_dest_set (dndTypeTable, Gtk::DEST_DEFAULT_ALL, Gdk::ACTION_MOVE);
   card.drag_source_set
      (dndTypeHand,
       Gdk::ModifierType (GDK_BUTTON1_MASK | GDK_BUTTON2_MASK | GDK_BUTTON3_MASK), Gdk::ACTION_MOVE);

   card.drag_source_set_icon (card.getImage ());
   aHandDND[&card] = card.signal_drag_data_received ().connect
       (bind (mem_fun (*this, &Rovhult::cardDroppedOnHand), iCard));
   aHandData[&card] = card.signal_drag_data_get ().connect
       (bind (mem_fun (*this, &Rovhult::getDropData), iCard));

   TRACE9 ("Rovhult::registerHandDND (CardWidget&, unsigned int) - Activate: "
           << activeCards.size () << '/' << activeCards.capacity ());
   Check3 (activeCards.size () >= iCard);
   SigC::Connection conn (card.signal_clicked ().connect
                          (bind (mem_fun (*this, &Rovhult::finishedExchange), iCard)));
   if (activeCards.size () > iCard)
      activeCards[iCard] = conn;
   else
      activeCards.push_back (conn);
   TRACE9 ("Rovhult::registerHandDND (CardWidget&, unsigned int) - End");
}

//-----------------------------------------------------------------------------
/// Stops the drag磏磀rop abilities of the passed card
/// \param card: Card to unregister of dnd
//-----------------------------------------------------------------------------
void Rovhult::unregisterDND (CardWidget& card) const {
   card.drag_dest_unset ();
   card.drag_source_unset ();
}

//-----------------------------------------------------------------------------
/// Stops the drag磏磀rop abilities of the cards of player 0
/// \param card: Card to unregister of dnd
//-----------------------------------------------------------------------------
void Rovhult::unregisterDND () {
   TRACE8 ("Rovhult::unregisterDND () - Status: " << gameStatus ());
   Check3 (gameStatus () == EXCHANGE);
   Check3 (aHandDND.size () == players[0].hand.size ());
   Check3 (aTableDND.size () == players[0].hand.size ());

   for (unsigned int i (0); i < players[0].hand.size (); ++i) {
      CardWidget& card (*players[0].hand[i]);
      unregisterDND (card);
      Check3 (players[0].reserve[i].size () == 2);
      activeCards[i].disconnect ();
      disconnectCardInHand (card);
   }

   for (unsigned int i (0);
        i < (sizeof (players[0].reserve) / sizeof (players[0].reserve[0]));
        ++i) {
      unregisterDND (players[0].reserve[i].getTopCard ());
      disconnectCardOnTable (players[0].reserve[i].getTopCard ());
   }

   Check3 (aHandDND.empty ()); Check3 (aHandData.empty ());
   Check3 (aTableDND.empty ()); Check3 (aTableData.empty ());
   activeCards.clear ();
}

//-----------------------------------------------------------------------------
/// Disconnects the card (in the hand) from every connection hold
//-----------------------------------------------------------------------------
void Rovhult::disconnectCardInHand (const CardWidget& card) {
   TRACE3 ("Rovhult::disconnectCardInHand (const CardWidget&) - " << card);
   Check1 (aHandDND.find (&card) != aHandDND.end ());
   Check1 (aHandData.find (&card) != aHandData.end ());

   aHandDND[&card].disconnect ();
   aHandData[&card].disconnect ();
   aHandDND.erase (&card);
   aHandData.erase (&card);
}

//-----------------------------------------------------------------------------
/// Disconnects the card (on the table) from every connection hold
//-----------------------------------------------------------------------------
void Rovhult::disconnectCardOnTable (const CardWidget& card) {
   TRACE3 ("Rovhult::disconnectCardOnTable (const CardWidget&) - " << card);
   Check1 (aTableDND.find (&card) != aTableDND.end ());
   Check1 (aTableData.find (&card) != aTableData.end ());

   aTableDND[&card].disconnect ();
   aTableData[&card].disconnect ();
   aTableDND.erase (&card);
   aTableData.erase (&card);
}

//-----------------------------------------------------------------------------
/// Deals the cards
//-----------------------------------------------------------------------------
void Rovhult::dealCards () {
   TRACE9 ("Rovhult::dealCards ()");
   Check3 (staple.size () > 36);

   // Show cards on table: For all players put 6 cards on table (only the