demos/forty/game.h

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        game.h
   3 // Purpose:     Forty Thieves patience game
   4 // Author:      Chris Breeze
   5 // Modified by:
   6 // Created:     21/07/97
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) 1993-1998 Chris Breeze
   9 // Licence:     wxWindows licence
  10 //---------------------------------------------------------------------------
  11 // Last modified: 22nd July 1998 - ported to wxWidgets 2.0
  12 /////////////////////////////////////////////////////////////////////////////
  13 #ifndef _GAME_H_
  14 #define _GAME_H_
  15 #include "card.h"
  16 #include "pile.h"
  17
  18 const int MaxMoves = 800;
  19
  20
  21 //---------------------------------------//
  22 // A class which holds the pack of cards //
  23 //---------------------------------------//
  24 class Pack : public Pile {
  25 public:
  26     Pack(int x, int y);
  27     virtual ~Pack();
  28     void Redraw(wxDC& dc);
  29     void ResetPile() { m_topCard = NumCards - 1; }
  30     void Shuffle();
  31     void AddCard(Card* card); // Add card
  32     void AddCard(wxDC& dc, Card* card) { AddCard(card); Redraw(dc); }
  33 };
  34
  35
  36 //----------------------------------------------------------//
  37 // A class which holds a base i.e. the initial 10 x 4 cards //
  38 //----------------------------------------------------------//
  39 class Base : public Pile {
  40 public:
  41     Base(int x, int y);
  42     virtual ~Base(){}
  43     bool AcceptCard(Card* card);
  44 };
  45
  46
  47 //----------------------------------------------------//
  48 // A class which holds a foundation i.e. Ace, 2, 3... //
  49 //----------------------------------------------------//
  50 class Foundation : public Pile {
  51 public:
  52     Foundation(int x, int y);
  53     virtual ~Foundation(){}
  54     bool AcceptCard(Card* card);
  55 };
  56
  57
  58 //--------------------------------------//
  59 // A class which holds the discard pile //
  60 //--------------------------------------//
  61 class Discard : public Pile {
  62 public:
  63     Discard(int x, int y);
  64     virtual ~Discard(){}
  65     void Redraw(wxDC& dc);
  66     void GetTopCardPos(int& x, int& y);
  67     Card* RemoveTopCard(wxDC& dc, int m_xOffset, int m_yOffset);
  68 };
  69
  70
  71 class Game {
  72 public:
  73     Game(int wins, int games, int score);
  74     virtual ~Game();
  75
  76     void Layout();
  77     void NewPlayer(int wins, int games, int score);
  78     void Deal(); // Shuffle and deal a new game
  79     bool CanYouGo(int x, int y); // can card under (x,y) go somewhere?
  80     bool HaveYouWon(); // have you won the game?
  81
  82     void Undo(wxDC& dc); // Undo the last go
  83     void Redo(wxDC& dc); // Redo the last go
  84
  85     void Redraw(wxDC& dc);
  86     void DisplayScore(wxDC& dc);
  87     bool LButtonDown(wxDC& dc, int mx, int my);
  88     void LButtonUp(wxDC& dc, int mx, int my);
  89     void LButtonDblClk(wxDC& dc, int mx, int my);
  90     void MouseMove(wxDC& dc, int mx, int my);
  91
  92     int GetNumWins() const { return m_numWins; }
  93     int GetNumGames() const { return m_numGames; }
  94     int GetScore() const { return m_currentScore + m_totalScore; }
  95
  96     bool InPlay() const { return m_inPlay; }
  97
  98 private:
  99     bool DropCard(int x, int y, Pile* pile, Card* card);
 100             //  can the card at (x, y) be dropped on the pile?
 101     Pile* WhichPile(int x, int y); // which pile is (x, y) over?
 102     void DoMove(wxDC& dc, Pile* src, Pile* dest);
 103
 104     bool m_inPlay; // flag indicating that the game has started
 105
 106     // undo buffer
 107     struct {
 108         Pile* src;
 109         Pile* dest;
 110     } m_moves[MaxMoves];
 111     int m_moveIndex; // current position in undo/redo buffer
 112     int m_redoIndex; // max move index available for redo
 113
 114     // the various piles of cards
 115     Pack* m_pack;
 116     Discard* m_discard;
 117     Base* m_bases[10];
 118     Foundation* m_foundations[8];
 119
 120     // variables to do with dragging cards
 121     Pile* m_srcPile;
 122     Card* m_liftedCard;
 123     int m_xPos, m_yPos; // current coords of card being dragged
 124     int m_xOffset, m_yOffset; // card/mouse offset when dragging a card
 125
 126     wxBitmap* m_bmap;
 127     wxBitmap* m_bmapCard;
 128
 129     // variables to do with scoring
 130     int m_numGames;
 131     int m_numWins;
 132     int m_totalScore;
 133     int m_currentScore;
 134 };
 135
 136 #endif // _GAME_H_