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 wxWindows 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         ~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         ~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         ~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         ~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 NewPlayer(int wins, int games, int score);
  77         void Deal();            // Shuffle and deal a new game
  78         bool CanYouGo(int x, int y);    // can card under (x,y) go somewhere?
  79         bool HaveYouWon();              // have you won the game?
  80
  81         void Undo(wxDC& dc);            // Undo the last go
  82         void Redo(wxDC& dc);            // Redo the last go
  83
  84         void Redraw(wxDC& dc);
  85         void DisplayScore(wxDC& dc);
  86         bool LButtonDown(wxDC& dc, int mx, int my);     //
  87         void LButtonUp(wxDC& dc, int mx, int my);
  88         void LButtonDblClk(wxDC& dc, int mx, int my);
  89         void MouseMove(wxDC& dc, int mx, int my);
  90
  91         int GetNumWins() const  { return m_numWins; }
  92         int GetNumGames() const { return m_numGames; }
  93         int GetScore() const    { return m_currentScore + m_totalScore; }
  94
  95         bool InPlay() const             { return m_inPlay; }
  96
  97 private:
  98         bool DropCard(int x, int y, Pile* pile, Card* card);
  99                         //  can the card at (x, y) be dropped on the pile?
 100         Pile* WhichPile(int x, int y);  // which pile is (x, y) over?
 101         void DoMove(wxDC& dc, Pile* src, Pile* dest);
 102
 103         bool m_inPlay;          // flag indicating that the game has started
 104
 105         // undo buffer
 106         struct {
 107                 Pile* src;
 108                 Pile* dest;
 109         } m_moves[MaxMoves];
 110         int m_moveIndex;        // current position in undo/redo buffer
 111         int m_redoIndex;        // max move index available for redo
 112
 113         // the various piles of cards
 114         Pack*           m_pack;
 115         Discard*        m_discard;
 116         Base*           m_bases[10];
 117         Foundation*     m_foundations[8];
 118
 119         // variables to do with dragging cards
 120         Pile*           m_srcPile;
 121         Card*           m_liftedCard;
 122         int m_xPos, m_yPos;             // current coords of card being dragged
 123         int m_xOffset, m_yOffset;       // card/mouse offset when dragging a card
 124
 125         wxBitmap* m_bmap;
 126         wxBitmap* m_bmapCard;
 127
 128         // variables to do with scoring
 129         int m_numGames;
 130         int m_numWins;
 131         int m_totalScore;
 132         int m_currentScore;
 133 };
 134
 135 #endif // _GAME_H_