+/////////////////////////////////////////////////////////////////////////////
+// Name: game.cpp
+// Purpose: Forty Thieves patience game
+// Author: Chris Breeze
+// Modified by:
+// Created: 21/07/97
+// RCS-ID: $Id$
+// Copyright: (c) 1993-1998 Chris Breeze
+// Licence: wxWindows licence
+//---------------------------------------------------------------------------
+// Last modified: 22nd July 1998 - ported to wxWindows 2.0
+/////////////////////////////////////////////////////////////////////////////
+
+#ifdef __GNUG__
+#pragma implementation
+#pragma interface
+#endif
+
+// For compilers that support precompilation, includes "wx/wx.h".
+#include "wx/wxprec.h"
+
+#ifdef __BORLANDC__
+#pragma hdrstop
+#endif
+
+#ifndef WX_PRECOMP
+#include "wx/wx.h"
+#endif
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <time.h>
+#include <string.h>
+#include "forty.h"
+#include "game.h"
+
+Game::Game(int wins, int games, int score) :
+ m_inPlay(FALSE),
+ m_moveIndex(0),
+ m_redoIndex(0),
+ m_bmap(0),
+ m_bmapCard(0)
+{
+ int i;
+
+ m_pack = new Pack(2, 2 + 4 * (CardHeight + 2));
+ srand(time(0));
+
+ for (i = 0; i < 5; i++) m_pack->Shuffle();
+
+ m_discard = new Discard(2, 2 + 5 * (CardHeight + 2));
+
+ for (i = 0; i < 8; i++)
+ {
+ m_foundations[i] = new Foundation(2 + (i / 4) * (CardWidth + 2),
+ 2 + (i % 4) * (CardHeight + 2));
+ }
+
+ for (i = 0; i < 10; i++)
+ {
+ m_bases[i] = new Base(8 + (i + 2) * (CardWidth + 2), 2);
+ }
+ Deal();
+ m_srcPile = 0;
+ m_liftedCard = 0;
+
+ // copy the input parameters for future reference
+ m_numWins = wins;
+ m_numGames = games;
+ m_totalScore = score;
+ m_currentScore = 0;
+}
+
+
+// Make sure we delete all objects created by the game object
+Game::~Game()
+{
+ int i;
+
+ delete m_pack;
+ delete m_discard;
+ for (i = 0; i < 8; i++)
+ {
+ delete m_foundations[i];
+ }
+ for (i = 0; i < 10; i++)
+ {
+ delete m_bases[i];
+ }
+ delete m_bmap;
+ delete m_bmapCard;
+}
+
+/*
+Set the score for a new player.
+NB: call Deal() first if the new player is to start
+a new game
+*/
+void Game::NewPlayer(int wins, int games, int score)
+{
+ m_numWins = wins;
+ m_numGames = games;
+ m_totalScore = score;
+ m_currentScore = 0;
+}
+
+// Undo the last move
+void Game::Undo(wxDC& dc)
+{
+ if (m_moveIndex > 0)
+ {
+ m_moveIndex--;
+ Card* card = m_moves[m_moveIndex].dest->RemoveTopCard(dc);
+ m_moves[m_moveIndex].src->AddCard(dc, card);
+ DisplayScore(dc);
+ }
+}
+
+// Redo the last move
+void Game::Redo(wxDC& dc)
+{
+ if (m_moveIndex < m_redoIndex)
+ {
+ Card* card = m_moves[m_moveIndex].src->RemoveTopCard(dc);
+ if (m_moves[m_moveIndex].src == m_pack)
+ {
+ m_pack->Redraw(dc);
+ card->TurnCard(faceup);
+ }
+ m_moves[m_moveIndex].dest->AddCard(dc, card);
+ DisplayScore(dc);
+ m_moveIndex++;
+ }
+}
+
+void Game::DoMove(wxDC& dc, Pile* src, Pile* dest)
+{
+ if (m_moveIndex < MaxMoves)
+ {
+ if (src == dest)
+ {
+ wxMessageBox("Game::DoMove() src == dest", "Debug message",
+ wxOK | wxICON_EXCLAMATION);
+ }
+ m_moves[m_moveIndex].src = src;
+ m_moves[m_moveIndex].dest = dest;
+ m_moveIndex++;
+
+ // when we do a move any moves in redo buffer are discarded
+ m_redoIndex = m_moveIndex;
+ }
+ else
+ {
+ wxMessageBox("Game::DoMove() Undo buffer full", "Debug message",
+ wxOK | wxICON_EXCLAMATION);
+ }
+
+ if (!m_inPlay)
+ {
+ m_inPlay = TRUE;
+ m_numGames++;
+ }
+ DisplayScore(dc);
+}
+
+
+void Game::DisplayScore(wxDC& dc)
+{
+ wxColour* bgColour = FortyApp::BackgroundColour();
+ wxPen* pen = wxThePenList->FindOrCreatePen(*bgColour, 1, wxSOLID);
+ dc.SetTextBackground(*bgColour);
+ dc.SetTextForeground(*FortyApp::TextColour());
+ dc.SetBrush(FortyApp::BackgroundBrush());
+ dc.SetPen(pen);
+
+ // count the number of cards in foundations
+ m_currentScore = 0;
+ for (int i = 0; i < 8; i++)
+ {
+ m_currentScore += m_foundations[i]->GetNumCards();
+ }
+
+ int x, y;
+ m_pack->GetTopCardPos(x, y);
+ x += 12 * CardWidth - 105;
+
+ int w, h;
+ {
+ long width, height;
+ dc.GetTextExtent("Average score:m_x", &width, &height);
+ w = width;
+ h = height;
+ }
+ dc.DrawRectangle(x + w, y, 20, 4 * h);
+
+ char str[80];
+ sprintf(str, "%d", m_currentScore);
+ dc.DrawText("Score:", x, y);
+ dc.DrawText(str, x + w, y);
+ y += h;
+
+ sprintf(str, "%d", m_numGames);
+ dc.DrawText("Games played:", x, y);
+ dc.DrawText(str, x + w, y);
+ y += h;
+
+ sprintf(str, "%d", m_numWins);
+ dc.DrawText("Games won:", x, y);
+ dc.DrawText(str, x + w, y);
+ y += h;
+
+ int average = 0;
+ if (m_numGames > 0)
+ {
+ average = (2 * (m_currentScore + m_totalScore) + m_numGames ) / (2 * m_numGames);
+ }
+ sprintf(str, "%d", average);
+ dc.DrawText("Average score:", x, y);
+ dc.DrawText(str, x + w, y);
+}
+
+
+// Shuffle the m_pack and deal the cards
+void Game::Deal()
+{
+ int i, j;
+ Card* card;
+
+ // Reset all the piles, the undo buffer and shuffle the m_pack
+ m_moveIndex = 0;
+ m_pack->ResetPile();
+ for (i = 0; i < 5; i++)
+ {
+ m_pack->Shuffle();
+ }
+ m_discard->ResetPile();
+ for (i = 0; i < 10; i++)
+ {
+ m_bases[i]->ResetPile();
+ }
+ for (i = 0; i < 8; i++)
+ {
+ m_foundations[i]->ResetPile();
+ }
+
+ // Deal the initial 40 cards onto the bases
+ for (i = 0; i < 10; i++)
+ {
+ for (j = 1; j <= 4; j++)
+ {
+ card = m_pack->RemoveTopCard();
+ card->TurnCard(faceup);
+ m_bases[i]->AddCard(card);
+ }
+ }
+
+ if (m_inPlay)
+ {
+ // player has started the game and then redealt
+ // and so we must add the score for this game to the total score
+ m_totalScore += m_currentScore;
+ }
+ m_currentScore = 0;
+ m_inPlay = FALSE;
+}
+
+
+// Redraw the m_pack, discard pile, the bases and the foundations
+void Game::Redraw(wxDC& dc)
+{
+ int i;
+ m_pack->Redraw(dc);
+ m_discard->Redraw(dc);
+ for (i = 0; i < 8; i++)
+ {
+ m_foundations[i]->Redraw(dc);
+ }
+ for (i = 0; i < 10; i++)
+ {
+ m_bases[i]->Redraw(dc);
+ }
+ DisplayScore(dc);
+
+ if (m_bmap == 0)
+ {
+ m_bmap = new wxBitmap(CardWidth, CardHeight);
+ m_bmapCard = new wxBitmap(CardWidth, CardHeight);
+
+ // Initialise the card bitmap to the background colour
+ wxMemoryDC memoryDC;
+ memoryDC.SelectObject(m_bmapCard);
+ memoryDC.SetBrush(FortyApp::BackgroundBrush());
+ memoryDC.DrawRectangle(0, 0, CardWidth, CardHeight);
+ memoryDC.SelectObject(m_bmap);
+ memoryDC.DrawRectangle(0, 0, CardWidth, CardHeight);
+ }
+}
+
+
+// Test to see if the point (x, y) is over the top card of one of the piles
+// Returns pointer to the pile, or 0 if (x, y) is not over a pile
+// or the pile is empty
+Pile* Game::WhichPile(int x, int y)
+{
+ if (m_pack->GetCard(x, y) &&
+ m_pack->GetCard(x, y) == m_pack->GetTopCard())
+ {
+ return m_pack;
+ }
+
+ if (m_discard->GetCard(x, y) &&
+ m_discard->GetCard(x, y) == m_discard->GetTopCard())
+ {
+ return m_discard;
+ }
+
+ int i;
+ for (i = 0; i < 8; i++)
+ {
+ if (m_foundations[i]->GetCard(x, y) &&
+ m_foundations[i]->GetCard(x, y) == m_foundations[i]->GetTopCard())
+ {
+ return m_foundations[i];
+ }
+ }
+
+ for (i = 0; i < 10; i++)
+ {
+ if (m_bases[i]->GetCard(x, y) &&
+ m_bases[i]->GetCard(x, y) == m_bases[i]->GetTopCard())
+ {
+ return m_bases[i];
+ }
+ }
+ return 0;
+}
+
+
+// Left button is pressed - if cursor is over the m_pack then deal a card
+// otherwise if it is over a card pick it up ready to be dragged - see MouseMove()
+bool Game::LButtonDown(wxDC& dc, int x, int y)
+{
+ m_srcPile = WhichPile(x, y);
+ if (m_srcPile == m_pack)
+ {
+ Card* card = m_pack->RemoveTopCard();
+ if (card)
+ {
+ m_pack->Redraw(dc);
+ card->TurnCard(faceup);
+ m_discard->AddCard(dc, card);
+ DoMove(dc, m_pack, m_discard);
+ }
+ m_srcPile = 0;
+ }
+ else if (m_srcPile)
+ {
+ m_srcPile->GetTopCardPos(m_xPos, m_yPos);
+ m_xOffset = m_xPos - x;
+ m_yOffset = m_yPos - y;
+
+ // Copy the area under the card
+ // Initialise the card bitmap to the background colour
+ {
+ wxMemoryDC memoryDC;
+ memoryDC.SelectObject(m_bmap);
+ m_liftedCard = m_srcPile->RemoveTopCard(memoryDC, m_xPos, m_yPos);
+ }
+
+ // Draw the card in card bitmap ready for blitting onto
+ // the screen
+ {
+ wxMemoryDC memoryDC;
+ memoryDC.SelectObject(m_bmapCard);
+ m_liftedCard->Draw(memoryDC, 0, 0);
+ }
+ }
+ return m_srcPile != 0;
+}
+
+// Called when the left button is double clicked
+// If a card is under the pointer and it can move elsewhere then move it.
+// Move onto a foundation as first choice, a populated base as second and
+// an empty base as third choice.
+// NB Cards in the m_pack cannot be moved in this way - they aren't in play
+// yet
+void Game::LButtonDblClk(wxDC& dc, int x, int y)
+{
+ Pile* pile = WhichPile(x, y);
+ if (!pile) return;
+
+ // Double click on m_pack is the same as left button down
+ if (pile == m_pack)
+ {
+ LButtonDown(dc, x, y);
+ }
+ else
+ {
+ Card* card = pile->GetTopCard();
+
+ if (card)
+ {
+ int i;
+
+ // if the card is an ace then try to place it next
+ // to an ace of the same suit
+ if (card->GetPipValue() == 1)
+ {
+ for(i = 0; i < 4; i++)
+ {
+ Card* m_topCard;
+ if ((m_topCard = m_foundations[i]->GetTopCard()))
+ {
+ if (m_topCard->GetSuit() == card->GetSuit() &&
+ m_foundations[i + 4] != pile &&
+ m_foundations[i + 4]->GetTopCard() == 0)
+ {
+ pile->RemoveTopCard(dc);
+ m_foundations[i + 4]->AddCard(dc, card);
+ DoMove(dc, pile, m_foundations[i + 4]);
+ return;
+ }
+ }
+ }
+ }
+
+ // try to place the card on a foundation
+ for(i = 0; i < 8; i++)
+ {
+ if (m_foundations[i]->AcceptCard(card) && m_foundations[i] != pile)
+ {
+ pile->RemoveTopCard(dc);
+ m_foundations[i]->AddCard(dc, card);
+ DoMove(dc, pile, m_foundations[i]);
+ return;
+ }
+ }
+ // try to place the card on a populated base
+ for(i = 0; i < 10; i++)
+ {
+ if (m_bases[i]->AcceptCard(card) &&
+ m_bases[i] != pile &&
+ m_bases[i]->GetTopCard())
+ {
+ pile->RemoveTopCard(dc);
+ m_bases[i]->AddCard(dc, card);
+ DoMove(dc, pile, m_bases[i]);
+ return;
+ }
+ }
+ // try to place the card on any base
+ for(i = 0; i < 10; i++)
+ {
+ if (m_bases[i]->AcceptCard(card) && m_bases[i] != pile)
+ {
+ pile->RemoveTopCard(dc);
+ m_bases[i]->AddCard(dc, card);
+ DoMove(dc, pile, m_bases[i]);
+ return;
+ }
+ }
+ }
+ }
+}
+
+
+// Test to see whether the game has been won:
+// i.e. m_pack, discard and bases are empty
+bool Game::HaveYouWon()
+{
+ if (m_pack->GetTopCard()) return FALSE;
+ if (m_discard->GetTopCard()) return FALSE;
+ for(int i = 0; i < 10; i++)
+ {
+ if (m_bases[i]->GetTopCard()) return FALSE;
+ }
+ m_numWins++;
+ m_totalScore += m_currentScore;
+ m_currentScore = 0;
+ return TRUE;
+}
+
+
+// See whether the card under the cursor can be moved somewhere else
+// Returns TRUE if it can be moved, FALSE otherwise
+bool Game::CanYouGo(int x, int y)
+{
+ Pile* pile = WhichPile(x, y);
+ if (pile && pile != m_pack)
+ {
+ Card* card = pile->GetTopCard();
+
+ if (card)
+ {
+ int i;
+ for(i = 0; i < 8; i++)
+ {
+ if (m_foundations[i]->AcceptCard(card) && m_foundations[i] != pile)
+ {
+ return TRUE;
+ }
+ }
+ for(i = 0; i < 10; i++)
+ {
+ if (m_bases[i]->GetTopCard() &&
+ m_bases[i]->AcceptCard(card) &&
+ m_bases[i] != pile)
+ {
+ return TRUE;
+ }
+ }
+ }
+ }
+ return FALSE;
+}
+
+
+// Called when the left button is released after dragging a card
+// Scan the piles to see if this card overlaps a pile and can be added
+// to the pile. If the card overlaps more than one pile on which it can be placed
+// then put it on the nearest pile.
+void Game::LButtonUp(wxDC& dc, int x, int y)
+{
+ if (m_srcPile)
+ {
+ // work out the position of the dragged card
+ x += m_xOffset;
+ y += m_yOffset;
+
+ Pile* nearestPile = 0;
+ int distance = (CardHeight + CardWidth) * (CardHeight + CardWidth);
+
+ // find the nearest pile which will accept the card
+ int i;
+ for (i = 0; i < 8; i++)
+ {
+ if (DropCard(x, y, m_foundations[i], m_liftedCard))
+ {
+ if (m_foundations[i]->CalcDistance(x, y) < distance)
+ {
+ nearestPile = m_foundations[i];
+ distance = nearestPile->CalcDistance(x, y);
+ }
+ }
+ }
+ for (i = 0; i < 10; i++)
+ {
+ if (DropCard(x, y, m_bases[i], m_liftedCard))
+ {
+ if (m_bases[i]->CalcDistance(x, y) < distance)
+ {
+ nearestPile = m_bases[i];
+ distance = nearestPile->CalcDistance(x, y);
+ }
+ }
+ }
+
+ // Restore the area under the card
+ wxMemoryDC memoryDC;
+ memoryDC.SelectObject(m_bmap);
+ dc.Blit(m_xPos, m_yPos, CardWidth, CardHeight,
+ &memoryDC, 0, 0, wxCOPY);
+
+ // Draw the card in its new position
+ if (nearestPile)
+ {
+ // Add to new pile
+ nearestPile->AddCard(dc, m_liftedCard);
+ if (nearestPile != m_srcPile)
+ {
+ DoMove(dc, m_srcPile, nearestPile);
+ }
+ }
+ else
+ {
+ // Return card to src pile
+ m_srcPile->AddCard(dc, m_liftedCard);
+ }
+ m_srcPile = 0;
+ m_liftedCard = 0;
+ }
+}
+
+
+
+
+bool Game::DropCard(int x, int y, Pile* pile, Card* card)
+{
+ bool retval = FALSE;
+ if (pile->Overlap(x, y))
+ {
+ if (pile->AcceptCard(card))
+ {
+ retval = TRUE;
+ }
+ }
+ return retval;
+}
+
+
+void Game::MouseMove(wxDC& dc, int mx, int my)
+{
+ if (m_liftedCard)
+ {
+ wxMemoryDC memoryDC;
+ memoryDC.SelectObject(m_bmap);
+
+ int dx = mx + m_xOffset - m_xPos;
+ int dy = my + m_yOffset - m_yPos;
+
+ if (abs(dx) >= CardWidth || abs(dy) >= CardHeight)
+ {
+ // Restore the area under the card
+ dc.Blit(m_xPos, m_yPos, CardWidth, CardHeight,
+ &memoryDC, 0, 0, wxCOPY);
+
+ // Copy the area under the card in the new position
+ memoryDC.Blit(0, 0, CardWidth, CardHeight,
+ &dc, m_xPos + dx, m_yPos + dy, wxCOPY);
+ }
+ else if (dx >= 0)
+ {
+ // dx >= 0
+ dc.Blit(m_xPos, m_yPos, dx, CardHeight, &memoryDC, 0, 0, wxCOPY);
+ if (dy >= 0)
+ {
+ // dy >= 0
+ dc.Blit(m_xPos + dx, m_yPos, CardWidth - dx, dy, &memoryDC, dx, 0, wxCOPY);
+ memoryDC.Blit(0, 0, CardWidth - dx, CardHeight - dy,
+ &memoryDC, dx, dy, wxCOPY);
+ memoryDC.Blit(0, CardHeight - dy, CardWidth - dx, dy,
+ &dc, m_xPos + dx, m_yPos + CardHeight, wxCOPY);
+ }
+ else
+ {
+ // dy < 0
+ dc.Blit(m_xPos + dx, m_yPos + dy + CardHeight, CardWidth - dx, -dy,
+ &memoryDC, dx, CardHeight + dy, wxCOPY);
+ memoryDC.Blit(0, -dy, CardWidth - dx, CardHeight + dy,
+ &memoryDC, dx, 0, wxCOPY);
+ memoryDC.Blit(0, 0, CardWidth - dx, -dy,
+ &dc, m_xPos + dx, m_yPos + dy, wxCOPY);
+ }
+ memoryDC.Blit(CardWidth - dx, 0, dx, CardHeight,
+ &dc, m_xPos + CardWidth, m_yPos + dy, wxCOPY);
+ }
+ else
+ {
+ // dx < 0
+ dc.Blit(m_xPos + CardWidth + dx, m_yPos, -dx, CardHeight,
+ &memoryDC, CardWidth + dx, 0, wxCOPY);
+ if (dy >= 0)
+ {
+ dc.Blit(m_xPos, m_yPos, CardWidth + dx, dy, &memoryDC, 0, 0, wxCOPY);
+ memoryDC.Blit(-dx, 0, CardWidth + dx, CardHeight - dy,
+ &memoryDC, 0, dy, wxCOPY);
+ memoryDC.Blit(-dx, CardHeight - dy, CardWidth + dx, dy,
+ &dc, m_xPos, m_yPos + CardHeight, wxCOPY);
+ }
+ else
+ {
+ // dy < 0
+ dc.Blit(m_xPos, m_yPos + CardHeight + dy, CardWidth + dx, -dy,
+ &memoryDC, 0, CardHeight + dy, wxCOPY);
+ memoryDC.Blit(-dx, -dy, CardWidth + dx, CardHeight + dy,
+ &memoryDC, 0, 0, wxCOPY);
+ memoryDC.Blit(-dx, 0, CardWidth + dx, -dy,
+ &dc, m_xPos, m_yPos + dy, wxCOPY);
+ }
+ memoryDC.Blit(0, 0, -dx, CardHeight,
+ &dc, m_xPos + dx, m_yPos + dy, wxCOPY);
+ }
+ m_xPos += dx;
+ m_yPos += dy;
+
+ // draw the card in its new position
+ memoryDC.SelectObject(m_bmapCard);
+ dc.Blit(m_xPos, m_yPos, CardWidth, CardHeight,
+ &memoryDC, 0, 0, wxCOPY);
+ }
+}
+
+
+
+//----------------------------------------------//
+// The Pack class: holds the two decks of cards //
+//----------------------------------------------//
+Pack::Pack(int x, int y) : Pile(x, y, 0, 0)
+{
+ for (m_topCard = 0; m_topCard < NumCards; m_topCard++)
+ {
+ m_cards[m_topCard] = new Card(1 + m_topCard / 2, facedown);
+ }
+ m_topCard = NumCards - 1;
+}
+
+
+void Pack::Shuffle()
+{
+ Card* temp[NumCards];
+ int i;
+
+ // Don't try to shuffle an empty m_pack!
+ if (m_topCard < 0) return;
+
+ // Copy the cards into a temporary array. Start by clearing
+ // the array and then copy the card into a random position.
+ // If the position is occupied then find the next lower position.
+ for (i = 0; i <= m_topCard; i++)
+ {
+ temp[i] = 0;
+ }
+ for (i = 0; i <= m_topCard; i++)
+ {
+ int pos = rand() % (m_topCard + 1);
+ while (temp[pos])
+ {
+ pos--;
+ if (pos < 0) pos = m_topCard;
+ }
+ m_cards[i]->TurnCard(facedown);
+ temp[pos] = m_cards[i];
+ m_cards[i] = 0;
+ }
+
+ // Copy each card back into the m_pack in a random
+ // position. If position is occupied then find nearest
+ // unoccupied position after the random position.
+ for (i = 0; i <= m_topCard; i++)
+ {
+ int pos = rand() % (m_topCard + 1);
+ while (m_cards[pos])
+ {
+ pos++;
+ if (pos > m_topCard) pos = 0;
+ }
+ m_cards[pos] = temp[i];
+ }
+}
+
+void Pack::Redraw(wxDC& dc)
+{
+ Pile::Redraw(dc);
+
+ char str[10];
+ sprintf(str, "%d ", m_topCard + 1);
+
+ dc.SetTextBackground(*FortyApp::BackgroundColour());
+ dc.SetTextForeground(*FortyApp::TextColour());
+ dc.DrawText(str, m_x + CardWidth + 5, m_y + CardHeight / 2);
+
+}
+
+void Pack::AddCard(Card* card)
+{
+ if (card == m_cards[m_topCard + 1])
+ {
+ m_topCard++;
+ }
+ else
+ {
+ wxMessageBox("Pack::AddCard() Undo error", "Forty Thieves: Warning",
+ wxOK | wxICON_EXCLAMATION);
+ }
+ card->TurnCard(facedown);
+}
+
+
+Pack::~Pack()
+{
+ for (m_topCard = 0; m_topCard < NumCards; m_topCard++)
+ {
+ delete m_cards[m_topCard];
+ }
+};
+
+
+//------------------------------------------------------//
+// The Base class: holds the initial pile of four cards //
+//------------------------------------------------------//
+Base::Base(int x, int y) : Pile(x, y, 0, 12)
+{
+ m_topCard = -1;
+}
+
+
+bool Base::AcceptCard(Card* card)
+{
+ bool retval = FALSE;
+
+ if (m_topCard >= 0)
+ {
+ if (m_cards[m_topCard]->GetSuit() == card->GetSuit() &&
+ m_cards[m_topCard]->GetPipValue() - 1 == card->GetPipValue())
+ {
+ retval = TRUE;
+ }
+ }
+ else
+ {
+ // pile is empty - ACCEPT
+ retval = TRUE;
+ }
+ return retval;
+}
+
+Base::~Base()
+{
+// nothing special at the moment
+};
+
+
+//----------------------------------------------------------------//
+// The Foundation class: holds the cards built up from the ace... //
+//----------------------------------------------------------------//
+Foundation::Foundation(int x, int y) : Pile(x, y, 0, 0)
+{
+ m_topCard = -1;
+}
+
+bool Foundation::AcceptCard(Card* card)
+{
+ bool retval = FALSE;
+
+ if (m_topCard >= 0)
+ {
+ if (m_cards[m_topCard]->GetSuit() == card->GetSuit() &&
+ m_cards[m_topCard]->GetPipValue() + 1 == card->GetPipValue())
+ {
+ retval = TRUE;
+ }
+ }
+ else if (card->GetPipValue() == 1)
+ {
+ // It's an ace and the pile is empty - ACCEPT
+ retval = TRUE;
+ }
+ return retval;
+}
+
+Foundation::~Foundation()
+{
+// nothing special at the moment
+};
+
+
+//----------------------------------------------------//
+// The Discard class: holds cards dealt from the m_pack //
+//----------------------------------------------------//
+Discard::Discard(int x, int y) : Pile(x, y, 19, 0)
+{
+ m_topCard = -1;
+}
+
+void Discard::Redraw(wxDC& dc)
+{
+ if (m_topCard >= 0)
+ {
+ if (m_dx == 0 && m_dy == 0)
+ {
+ m_cards[m_topCard]->Draw(dc, m_x, m_y);
+ }
+ else
+ {
+ int x = m_x;
+ int y = m_y;
+ for (int i = 0; i <= m_topCard; i++)
+ {
+ m_cards[i]->Draw(dc, x, y);
+ x += m_dx;
+ y += m_dy;
+ if (i == 31)
+ {
+ x = m_x;
+ y = m_y + CardHeight / 3;
+ }
+ }
+ }
+ }
+ else
+ {
+ Card::DrawNullCard(dc, m_x, m_y);
+ }
+}
+
+
+void Discard::GetTopCardPos(int& x, int& y)
+{
+ if (m_topCard < 0)
+ {
+ x = m_x;
+ y = m_y;
+ }
+ else if (m_topCard > 31)
+ {
+ x = m_x + m_dx * (m_topCard - 32);
+ y = m_y + CardHeight / 3;
+ }
+ else
+ {
+ x = m_x + m_dx * m_topCard;
+ y = m_y;
+ }
+}
+
+
+Card* Discard::RemoveTopCard(wxDC& dc, int m_xOffset, int m_yOffset)
+{
+ Card* card;
+
+ if (m_topCard <= 31)
+ {
+ card = Pile::RemoveTopCard(dc, m_xOffset, m_yOffset);
+ }
+ else
+ {
+ int topX, topY, x, y;
+ GetTopCardPos(topX, topY);
+ card = Pile::RemoveTopCard();
+ card->Erase(dc, topX - m_xOffset, topY - m_yOffset);
+ GetTopCardPos(x, y);
+ dc.SetClippingRegion(topX - m_xOffset, topY - m_yOffset,
+ CardWidth, CardHeight);
+
+ for (int i = m_topCard - 31; i <= m_topCard - 31 + CardWidth / m_dx; i++)
+ {
+ m_cards[i]->Draw(dc, m_x - m_xOffset + i * m_dx, m_y - m_yOffset);
+ }
+ if (m_topCard > 31)
+ {
+ m_cards[m_topCard]->Draw(dc, topX - m_xOffset - m_dx, topY - m_yOffset);
+ }
+ dc.DestroyClippingRegion();
+ }
+
+ return card;
+}
+
+
+Discard::~Discard()
+{
+// nothing special at the moment
+};
projects / wxWidgets.git / commitdiff
