fc7995487f
git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@14465 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
1001 lines
22 KiB
C++
1001 lines
22 KiB
C++
/////////////////////////////////////////////////////////////////////////////
|
|
// 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;
|
|
}
|
|
|
|
|
|
void Game::Layout()
|
|
{
|
|
int i;
|
|
|
|
m_pack->SetPos(2, 2 + 4 * (CardHeight + 2));
|
|
|
|
m_discard->SetPos(2, 2 + 5 * (CardHeight + 2));
|
|
|
|
for (i = 0; i < 8; i++)
|
|
{
|
|
m_foundations[i]->SetPos(2 + (i / 4) * (CardWidth + 2),
|
|
2 + (i % 4) * (CardHeight + 2));
|
|
}
|
|
|
|
for (i = 0; i < 10; i++)
|
|
{
|
|
m_bases[i]->SetPos(8 + (i + 2) * (CardWidth + 2), 2);
|
|
}
|
|
delete m_bmap;
|
|
delete m_bmapCard;
|
|
m_bmap = 0;
|
|
m_bmapCard = 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);
|
|
|
|
if (HaveYouWon())
|
|
{
|
|
wxWindow *frame = wxTheApp->GetTopWindow();
|
|
wxWindow *canvas = (wxWindow *) NULL;
|
|
|
|
if (frame)
|
|
{
|
|
wxNode *node = frame->GetChildren().First();
|
|
if (node) canvas = (wxWindow*)node->Data();
|
|
}
|
|
|
|
// This game is over
|
|
m_inPlay = FALSE;
|
|
|
|
// Redraw the score box to update games won
|
|
DisplayScore(dc);
|
|
|
|
if (wxMessageBox("Do you wish to play again?",
|
|
"Well Done, You have won!", wxYES_NO | wxICON_QUESTION) == wxYES)
|
|
{
|
|
Deal();
|
|
canvas->Refresh();
|
|
}
|
|
else
|
|
{
|
|
// user cancelled the dialog - exit the app
|
|
((wxFrame*)canvas->GetParent())->Close(TRUE);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
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.SetPen( *wxTRANSPARENT_PEN );
|
|
memoryDC.SetBrush(FortyApp::BackgroundBrush());
|
|
memoryDC.DrawRectangle(0, 0, CardWidth, CardHeight);
|
|
memoryDC.SelectObject(*m_bmap);
|
|
memoryDC.DrawRectangle(0, 0, CardWidth, CardHeight);
|
|
memoryDC.SelectObject(wxNullBitmap);
|
|
}
|
|
}
|
|
|
|
|
|
// 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 = m_foundations[i]->GetTopCard();
|
|
if ( m_topCard )
|
|
{
|
|
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.SetBackgroundMode( wxSOLID );
|
|
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
|
|
};
|