]>
Commit | Line | Data |
---|---|---|
1 | ///////////////////////////////////////////////////////////////////////////// | |
2 | // Name: pile.cpp | |
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 | //+-------------------------------------------------------------+ | |
14 | //| Description: | | |
15 | //| The base class for holding piles of playing cards. | | |
16 | //+-------------------------------------------------------------+ | |
17 | ||
18 | #ifdef __GNUG__ | |
19 | #pragma implementation | |
20 | #pragma interface | |
21 | #endif | |
22 | ||
23 | // For compilers that support precompilation, includes "wx/wx.h". | |
24 | #include "wx/wxprec.h" | |
25 | ||
26 | #ifdef __BORLANDC__ | |
27 | #pragma hdrstop | |
28 | #endif | |
29 | ||
30 | #ifndef WX_PRECOMP | |
31 | #include "wx/wx.h" | |
32 | #endif | |
33 | #ifdef __GNUG__ | |
34 | #pragma implementation | |
35 | #endif | |
36 | ||
37 | #include <stdlib.h> | |
38 | #include <stdio.h> | |
39 | #include <time.h> | |
40 | #include <string.h> | |
41 | #include "card.h" | |
42 | #include "pile.h" | |
43 | ||
44 | #include "wx/app.h" | |
45 | ||
46 | //+-------------------------------------------------------------+ | |
47 | //| Pile::Pile() | | |
48 | //+-------------------------------------------------------------+ | |
49 | //| Description: | | |
50 | //| Initialise the pile to be empty of cards. | | |
51 | //+-------------------------------------------------------------+ | |
52 | Pile::Pile(int x, int y, int dx, int dy) | |
53 | { | |
54 | m_x = x; | |
55 | m_y = y; | |
56 | m_dx = dx; | |
57 | m_dy = dy; | |
58 | for (m_topCard = 0; m_topCard < NumCards; m_topCard++) | |
59 | { | |
60 | m_cards[m_topCard] = 0; | |
61 | } | |
62 | m_topCard = -1; // i.e. empty | |
63 | } | |
64 | ||
65 | ||
66 | //+-------------------------------------------------------------+ | |
67 | //| Pile::Redraw() | | |
68 | //+-------------------------------------------------------------+ | |
69 | //| Description: | | |
70 | //| Redraw the pile on the screen. If the pile is empty | | |
71 | //| just draw a NULL card as a place holder for the pile. | | |
72 | //| Otherwise draw the pile from the bottom up, starting | | |
73 | //| at the origin of the pile, shifting each subsequent | | |
74 | //| card by the pile's x and y offsets. | | |
75 | //+-------------------------------------------------------------+ | |
76 | void Pile::Redraw(wxDC& dc ) | |
77 | { | |
78 | wxWindow *frame = wxTheApp->GetTopWindow(); | |
79 | wxWindow *canvas = (wxWindow *) NULL; | |
80 | if (frame) | |
81 | { | |
82 | wxNode *node = frame->GetChildren().First(); | |
83 | if (node) canvas = (wxWindow*)node->Data(); | |
84 | } | |
85 | ||
86 | if (m_topCard >= 0) | |
87 | { | |
88 | if (m_dx == 0 && m_dy == 0) | |
89 | { | |
90 | if ((canvas) && (canvas->IsExposed(m_x,m_y,Card::GetScale()*60,Card::GetScale()*200))) | |
91 | m_cards[m_topCard]->Draw(dc, m_x, m_y); | |
92 | } | |
93 | else | |
94 | { | |
95 | int x = m_x; | |
96 | int y = m_y; | |
97 | for (int i = 0; i <= m_topCard; i++) | |
98 | { | |
99 | if ((canvas) && (canvas->IsExposed(x,y,Card::GetScale()*60,Card::GetScale()*200))) | |
100 | m_cards[i]->Draw(dc, x, y); | |
101 | x += (int)Card::GetScale()*m_dx; | |
102 | y += (int)Card::GetScale()*m_dy; | |
103 | } | |
104 | } | |
105 | } | |
106 | else | |
107 | { | |
108 | if ((canvas) && (canvas->IsExposed(m_x,m_y,Card::GetScale()*60,Card::GetScale()*200))) | |
109 | Card::DrawNullCard(dc, m_x, m_y); | |
110 | } | |
111 | } | |
112 | ||
113 | ||
114 | //+-------------------------------------------------------------+ | |
115 | //| Pile::GetTopCard() | | |
116 | //+-------------------------------------------------------------+ | |
117 | //| Description: | | |
118 | //| Return a pointer to the top card in the pile or NULL | | |
119 | //| if the pile is empty. | | |
120 | //| NB: Gets a copy of the card without removing it from the | | |
121 | //| pile. | | |
122 | //+-------------------------------------------------------------+ | |
123 | Card* Pile::GetTopCard() | |
124 | { | |
125 | Card* card = 0; | |
126 | ||
127 | if (m_topCard >= 0) | |
128 | { | |
129 | card = m_cards[m_topCard]; | |
130 | } | |
131 | return card; | |
132 | } | |
133 | ||
134 | ||
135 | //+-------------------------------------------------------------+ | |
136 | //| Pile::RemoveTopCard() | | |
137 | //+-------------------------------------------------------------+ | |
138 | //| Description: | | |
139 | //| If the pile is not empty, remove the top card from the | | |
140 | //| pile and return the pointer to the removed card. | | |
141 | //| If the pile is empty return a NULL pointer. | | |
142 | //+-------------------------------------------------------------+ | |
143 | Card* Pile::RemoveTopCard() | |
144 | { | |
145 | Card* card = 0; | |
146 | ||
147 | if (m_topCard >= 0) | |
148 | { | |
149 | card = m_cards[m_topCard--]; | |
150 | } | |
151 | return card; | |
152 | } | |
153 | ||
154 | ||
155 | //+-------------------------------------------------------------+ | |
156 | //| Pile::RemoveTopCard() | | |
157 | //+-------------------------------------------------------------+ | |
158 | //| Description: | | |
159 | //| As RemoveTopCard() but also redraw the top of the pile | | |
160 | //| after the card has been removed. | | |
161 | //| NB: the offset allows for the redrawn area to be in a | | |
162 | //| bitmap ready for 'dragging' cards acrosss the screen. | | |
163 | //+-------------------------------------------------------------+ | |
164 | Card* Pile::RemoveTopCard(wxDC& dc, int xOffset, int yOffset) | |
165 | { | |
166 | int topX, topY, x, y; | |
167 | ||
168 | GetTopCardPos(topX, topY); | |
169 | Card* card = RemoveTopCard(); | |
170 | ||
171 | if (card) | |
172 | { | |
173 | card->Erase(dc, topX - xOffset, topY - yOffset); | |
174 | GetTopCardPos(x, y); | |
175 | if (m_topCard < 0) | |
176 | { | |
177 | Card::DrawNullCard(dc, x - xOffset, y - yOffset); | |
178 | } | |
179 | else | |
180 | { | |
181 | m_cards[m_topCard]->Draw(dc, x - xOffset, y - yOffset); | |
182 | } | |
183 | } | |
184 | ||
185 | return card; | |
186 | } | |
187 | ||
188 | ||
189 | void Pile::GetTopCardPos(int& x, int& y) | |
190 | { | |
191 | if (m_topCard < 0) | |
192 | { | |
193 | x = m_x; | |
194 | y = m_y; | |
195 | } | |
196 | else | |
197 | { | |
198 | x = m_x + (int)Card::GetScale()*m_dx * m_topCard; | |
199 | y = m_y + (int)Card::GetScale()*m_dy * m_topCard; | |
200 | } | |
201 | } | |
202 | ||
203 | void Pile::AddCard(Card* card) | |
204 | { | |
205 | if (m_topCard < -1) m_topCard = -1; | |
206 | ||
207 | m_cards[++m_topCard] = card; | |
208 | } | |
209 | ||
210 | void Pile::AddCard(wxDC& dc, Card* card) | |
211 | { | |
212 | AddCard(card); | |
213 | int x, y; | |
214 | GetTopCardPos(x, y); | |
215 | card->Draw(dc, x, y); | |
216 | } | |
217 | ||
218 | // Can the card leave this pile. | |
219 | // If it is a member of the pile then the answer is yes. | |
220 | // Derived classes may override this behaviour to incorporate | |
221 | // the rules of the game | |
222 | bool Pile::CanCardLeave(Card* card) | |
223 | { | |
224 | for (int i = 0; i <= m_topCard; i++) | |
225 | { | |
226 | if (card == m_cards[i]) return TRUE; | |
227 | } | |
228 | return FALSE; | |
229 | } | |
230 | ||
231 | // Calculate how far x, y is from top card in the pile | |
232 | // Returns the square of the distance | |
233 | int Pile::CalcDistance(int x, int y) | |
234 | { | |
235 | int cx, cy; | |
236 | GetTopCardPos(cx, cy); | |
237 | return ((cx - x) * (cx - x) + (cy - y) * (cy - y)); | |
238 | } | |
239 | ||
240 | ||
241 | // Return the card at x, y. Check the top card first, then | |
242 | // work down the pile. If a card is found then return a pointer | |
243 | // to the card, otherwise return NULL | |
244 | Card* Pile::GetCard(int x, int y) | |
245 | { | |
246 | int cardX; | |
247 | int cardY; | |
248 | GetTopCardPos(cardX, cardY); | |
249 | ||
250 | for (int i = m_topCard; i >= 0; i--) | |
251 | { | |
252 | if (x >= cardX && x <= cardX + Card::GetWidth() && | |
253 | y >= cardY && y <= cardY + Card::GetHeight()) | |
254 | { | |
255 | return m_cards[i]; | |
256 | } | |
257 | cardX -= (int)Card::GetScale()*m_dx; | |
258 | cardY -= (int)Card::GetScale()*m_dy; | |
259 | } | |
260 | return 0; | |
261 | } | |
262 | ||
263 | ||
264 | // Return the position of the given card. If it is not a member of this pile | |
265 | // return the origin of the pile. | |
266 | void Pile::GetCardPos(Card* card, int& x, int& y) | |
267 | { | |
268 | x = m_x; | |
269 | y = m_y; | |
270 | ||
271 | for (int i = 0; i <= m_topCard; i++) | |
272 | { | |
273 | if (card == m_cards[i]) | |
274 | { | |
275 | return; | |
276 | } | |
277 | x += (int)Card::GetScale()*m_dx; | |
278 | y += (int)Card::GetScale()*m_dy; | |
279 | } | |
280 | ||
281 | // card not found in pile, return origin of pile | |
282 | x = m_x; | |
283 | y = m_y; | |
284 | } | |
285 | ||
286 | ||
287 | bool Pile::Overlap(int x, int y) | |
288 | { | |
289 | int cardX; | |
290 | int cardY; | |
291 | GetTopCardPos(cardX, cardY); | |
292 | ||
293 | if (x >= cardX - Card::GetWidth() && x <= cardX + Card::GetWidth() && | |
294 | y >= cardY - Card::GetHeight() && y <= cardY + Card::GetHeight()) | |
295 | { | |
296 | return TRUE; | |
297 | } | |
298 | return FALSE; | |
299 | } | |
300 | ||
301 | ||
302 | Pile::~Pile() | |
303 | { | |
304 | // nothing special at the moment | |
305 | } |