home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / wxos2233.zip / wxOS2-2_3_3.zip / wxWindows-2.3.3 / demos / forty / game.h < prev    next >
C/C++ Source or Header  |  2002-03-06  |  4KB  |  137 lines
  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: game.h,v 1.2 2002/03/06 17:50:52 JS Exp $
  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 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_
  137.