1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
|
#Copyright (c) 2009,10 Walter Bender
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 3 of the License, or
# (at your option) any later version.
# You should have received a copy of the GNU General Public License
# along with this library; if not, write to the Free Software
# Foundation, 51 Franklin Street, Suite 500 Boston, MA 02110-1335 USA
import pygtk
pygtk.require('2.0')
import gtk
import gobject
import random
from constants import ROW, COL, MATCH_POSITION, DEAL
import logging
_logger = logging.getLogger('visualmatch-activity')
def _distance_squared(pos1, pos2):
''' simple distance function '''
return (pos1[0] - pos2[0]) * (pos1[0] - pos2[0]) + \
(pos1[1] - pos2[1]) * (pos1[1] - pos2[1])
class Grid:
''' Class for managing ROWxCOL matrix of cards '''
def __init__(self, width, height, card_width, card_height):
''' Initialize the playing surface '''
self.grid = []
for i in range(ROW * COL):
self.grid.append(None)
# Card spacing
self.left = int((width - (card_width * 2)) / 2)
self.xinc = int(card_width * 1.2)
self.top = 10
self.yinc = int(card_height * 1.33)
self.dx = [0, 0, 0, 0, 0, 0]
self.dy = [0, 0, 0, 0, 0, 0]
self.sx = [0, 0, 0, 0, 0, 0]
self.sy = [0, 0, 0, 0, 0, 0]
self.ex = [0, 0, 0, 0, 0, 0]
self.ey = [0, 0, 0, 0, 0, 0]
self.stop_animation = False
self.animation_lock = [False, False, False, False, False, False]
def deal(self, deck):
''' Deal an initial set of cards. '''
for i in range(ROW * COL):
self.grid[i] = None
if i < (ROW - 1) * COL:
if not deck.empty():
self.grid[i] = deck.deal_next_card()
self.place_a_card(self.grid[i], self.grid_to_xy(i)[0],
self.grid_to_xy(i)[1])
def deal_extra_cards(self, deck):
''' Add cards to the bottom row when there is no match.
But only if there are still cards in the deck
and only 12 cards in the grid
'''
if not deck.empty() and self.cards_in_grid() == DEAL:
for c in range(0, COL):
i = self.grid.index(None)
self.grid[i] = deck.deal_next_card()
self.place_a_card(self.grid[i], self.grid_to_xy(i)[0],
self.grid_to_xy(i)[1])
def cards_in_grid(self):
''' How many cards are on the grid? '''
return ROW * COL - self.grid.count(None)
def restore(self, deck, saved_card_index):
''' Restore cards to grid upon resume or share. '''
self.hide()
j = 0
for i in saved_card_index:
if i is None:
self.grid[j] = None
else:
self.grid[j] = deck.index_to_card(i)
j += 1
self.show()
def find_an_empty_slot(self):
''' Return the position of an empty slot in the grid '''
for i in range(len(self.grid)):
if self.grid[i] is None:
return i
return None # No empty slots
def replace(self, clicked_set, deck):
''' Deal new cards. '''
for j, a in enumerate(clicked_set):
# Don't add new cards if bottom row is occupied
if self.cards_in_grid() < DEAL:
if not deck.empty():
i = self.find_an_empty_slot()
# Put new card in grid position of card we are replacing.
self.grid[i] = deck.deal_next_card()
timeout_id = gobject.timeout_add(
1200, self.place_a_card, self.grid[i],
self.grid_to_xy(i)[0], self.grid_to_xy(i)[1], j)
def display_match(self, spr, i):
''' Move card to the match area. '''
self.stop_animation = False
spr.set_layer(2000)
self.ex[i] = MATCH_POSITION
self.ey[i] = self.top + i * self.yinc
self.sx[i] = spr.get_xy()[0]
self.sy[i] = spr.get_xy()[1]
self.dx[i] = int((self.ex[i] - self.sx[i]) / 10)
self.dy[i] = int((self.ey[i] - self.sy[i]) / 10)
timeout_id = gobject.timeout_add(
100, self._move_to_position, spr, i)
def return_to_grid(self, spr, i, j):
''' Move card to the match area. '''
self.stop_animation = False
self.animation_lock[j] = True
spr.set_layer(2000)
self.ex[j] = self.grid_to_xy(i)[0]
self.ey[j] = self.grid_to_xy(i)[1]
self.sx[j] = spr.get_xy()[0]
self.sy[j] = spr.get_xy()[1]
self.dx[j] = int((self.ex[j] - self.sx[j]) / 10)
self.dy[j] = int((self.ey[j] - self.sy[j]) / 10)
timeout_id = gobject.timeout_add(
100, self._move_to_position, spr, j)
def _move_to_position(self, spr, i):
''' Piece-wise animation of card movement '''
spr.move_relative((self.dx[i], self.dy[i]))
if self.stop_animation:
spr.move((self.sx[i], self.sy[i]))
self.animation_lock[i] = False
elif _distance_squared(spr.get_xy(), (self.ex[i], self.ey[i])) < 200:
spr.move((self.ex[i], self.ey[i]))
self.animation_lock[i] = False
else:
timeout_id = gobject.timeout_add(
100, self._move_to_position, spr, i)
def consolidate(self):
''' If we have removed cards from an expanded grid,
we have to consolidate.
'''
for j in range((ROW - 1) * COL, ROW * COL):
i = 0
while(self.grid[j] is not None):
if self.grid[i] is None:
self.grid[i] = self.grid[j]
self.grid[i].spr.move(self.grid_to_xy(i))
self.grid[i].spr.set_layer(2000)
self.grid[j] = None
else:
i += 1
def place_a_card(self, c, x, y, animate=-1):
''' Place a card at position x,y and display it. '''
self.stop_animation = False
if c is not None:
if animate == -1:
c.spr.move((x, y))
c.show_card()
else:
c.spr.set_layer(3000)
self.ex[animate + 3] = x
self.ey[animate + 3] = y
self.dx[animate + 3] = int(
(self.ex[animate + 3] - c.spr.get_xy()[0]) / 10)
self.dy[animate + 3] = int(
(self.ey[animate + 3] - c.spr.get_xy()[1]) / 10)
self.animation_lock[animate + 3] = True
timeout_id = gobject.timeout_add(100, self._move_to_position,
c.spr, animate + 3)
def xy_to_match(self, pos):
''' Convert from sprite x,y to match index. '''
return int((pos[1] - self.top) / self.yinc)
def match_to_xy(self, i):
''' Convert from match index to x, y position. '''
return ((MATCH_POSITION, self.top + i * self.yinc))
def xy_to_grid(self, pos):
''' Convert from sprite x,y to grid index. '''
return COL * int((pos[1] - self.top) / self.yinc)\
+ int((pos[0] - self.left) / self.xinc)
def grid_to_xy(self, i):
''' Convert from grid index to sprite x,y. '''
return ((self.left + i % COL * self.xinc),
(self.top + (i / COL) * self.yinc))
def grid_to_spr(self, i):
''' Return the sprite in grid-position i. '''
return self.grid[i].spr
def spr_to_grid(self, spr):
''' Return the index of a sprite in grid. '''
for i in range(ROW * COL):
if self.grid[i] is not None and self.grid[i].spr == spr:
return(i)
return None
def hide(self):
''' Hide all of the cards on the grid. '''
for i in range(ROW * COL):
if self.grid[i] is not None:
self.grid[i].hide_card()
def show(self):
''' Restore all card on the grid to their x,y positions. '''
for i in range(ROW * COL):
self.place_a_card(self.grid[i], self.grid_to_xy(i)[0],
self.grid_to_xy(i)[1])
|