[wxWidgets.git] / samples / forty / game.h

/////////////////////////////////////////////////////////////////////////////
// Name:        game.h
// 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
/////////////////////////////////////////////////////////////////////////////
#ifndef _GAME_H_
#define _GAME_H_
#include "card.h"
#include "pile.h"

const int MaxMoves = 800;


//---------------------------------------//
// A class which holds the pack of cards //
//---------------------------------------//
class Pack : public Pile {
public:
	Pack(int x, int y);
	~Pack();
	void Redraw(wxDC& dc);
	void ResetPile() { m_topCard = NumCards - 1; }
	void Shuffle();
	void AddCard(Card* card);		// Add card
	void AddCard(wxDC& dc, Card* card) { AddCard(card); Redraw(dc); }
};


//----------------------------------------------------------//
// A class which holds a base i.e. the initial 10 x 4 cards //
//----------------------------------------------------------//
class Base : public Pile {
public:
	Base(int x, int y);
	~Base();
	bool AcceptCard(Card* card);
};


//----------------------------------------------------//
// A class which holds a foundation i.e. Ace, 2, 3... //
//----------------------------------------------------//
class Foundation : public Pile {
public:
	Foundation(int x, int y);
	~Foundation();
	bool AcceptCard(Card* card);
};


//--------------------------------------//
// A class which holds the discard pile //
//--------------------------------------//
class Discard : public Pile {
public:
	Discard(int x, int y);
	~Discard();
	void Redraw(wxDC& dc);
	void GetTopCardPos(int& x, int& y);
	Card* RemoveTopCard(wxDC& dc, int m_xOffset, int m_yOffset);
};


class Game {
public:
	Game(int wins, int games, int score);
	virtual ~Game();

	void NewPlayer(int wins, int games, int score);
	void Deal();		// Shuffle and deal a new game
	bool CanYouGo(int x, int y);	// can card under (x,y) go somewhere?
	bool HaveYouWon();		// have you won the game?

	void Undo(wxDC& dc);		// Undo the last go
	void Redo(wxDC& dc);		// Redo the last go

	void Redraw(wxDC& dc);
	void DisplayScore(wxDC& dc);
	bool LButtonDown(wxDC& dc, int mx, int my);	//
	void LButtonUp(wxDC& dc, int mx, int my);
	void LButtonDblClk(wxDC& dc, int mx, int my);
	void MouseMove(wxDC& dc, int mx, int my);

	int GetNumWins() const	{ return m_numWins; }
	int GetNumGames() const	{ return m_numGames; }
	int GetScore() const	{ return m_currentScore + m_totalScore; }

	bool InPlay() const		{ return m_inPlay; }

private:
	bool DropCard(int x, int y, Pile* pile, Card* card);
			//  can the card at (x, y) be dropped on the pile?
	Pile* WhichPile(int x, int y);	// which pile is (x, y) over?
	void DoMove(wxDC& dc, Pile* src, Pile* dest);

	bool m_inPlay;		// flag indicating that the game has started

	// undo buffer
	struct {
		Pile* src;
		Pile* dest;
	} m_moves[MaxMoves];
	int m_moveIndex;	// current position in undo/redo buffer
	int m_redoIndex;	// max move index available for redo

	// the various piles of cards
	Pack*		m_pack;		
	Discard*	m_discard;
	Base*		m_bases[10];
	Foundation*	m_foundations[8];

	// variables to do with dragging cards
	Pile*		m_srcPile;
	Card*		m_liftedCard;
	int m_xPos, m_yPos;		// current coords of card being dragged
	int m_xOffset, m_yOffset;	// card/mouse offset when dragging a card

	wxBitmap* m_bmap;
	wxBitmap* m_bmapCard;

	// variables to do with scoring
	int m_numGames;		
	int m_numWins;
	int m_totalScore;
	int m_currentScore;
};

#endif // _GAME_H_
Commit	Line	Data
63cafd27 JS	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_