|
0 |
Author: Reiner Herrmann <reiner@reiner-h.de>
|
|
1 |
Description: Port to Python 3
|
|
2 |
Bug-Debian: https://bugs.debian.org/912496
|
|
3 |
|
|
4 |
--- a/pathological.py
|
|
5 |
+++ b/pathological.py
|
|
6 |
@@ -1,4 +1,4 @@
|
|
7 |
-#!/usr/bin/python
|
|
8 |
+#!/usr/bin/python3
|
|
9 |
# -*- coding: iso-8859-1 -*-
|
|
10 |
"""
|
|
11 |
Copyright (C) 2003 John-Paul Gignac
|
|
12 |
@@ -20,7 +20,7 @@
|
|
13 |
"""
|
|
14 |
|
|
15 |
# Import Modules
|
|
16 |
-import os, pygame, random, time, math, re, sys, md5
|
|
17 |
+import os, pygame, random, time, math, re, sys, hashlib
|
|
18 |
from pygame.locals import *
|
|
19 |
|
|
20 |
# Parse the command line
|
|
21 |
@@ -42,7 +42,7 @@
|
|
22 |
sound_on = 0
|
|
23 |
music_on = 0
|
|
24 |
elif arg[0] == '-':
|
|
25 |
- print "Usage: "+sys.argv[0]+" [-cb] [-f] [-s] [highscores-file]\n"
|
|
26 |
+ print("Usage: "+sys.argv[0]+" [-cb] [-f] [-s] [highscores-file]\n")
|
|
27 |
sys.exit(1)
|
|
28 |
else:
|
|
29 |
highscores_file = arg
|
|
30 |
@@ -104,10 +104,10 @@
|
|
31 |
c = math.floor( 0.5 + math.cos(theta)*holecenter_radius)
|
|
32 |
s = math.floor( 0.5 + math.sin(theta)*holecenter_radius)
|
|
33 |
holecenters.append((
|
|
34 |
- (tile_size/2 + s, tile_size/2 - c),
|
|
35 |
- (tile_size/2 + c, tile_size/2 + s),
|
|
36 |
- (tile_size/2 - s, tile_size/2 + c),
|
|
37 |
- (tile_size/2 - c, tile_size/2 - s)))
|
|
38 |
+ (tile_size//2 + s, tile_size//2 - c),
|
|
39 |
+ (tile_size//2 + c, tile_size//2 + s),
|
|
40 |
+ (tile_size//2 - s, tile_size//2 + c),
|
|
41 |
+ (tile_size//2 - c, tile_size//2 - s)))
|
|
42 |
|
|
43 |
# Direction references
|
|
44 |
dirs = ((0,-1),(1,0),(0,1),(-1,0))
|
|
45 |
@@ -125,9 +125,9 @@
|
|
46 |
fullname = os.path.join('graphics', name)
|
|
47 |
try:
|
|
48 |
image = pygame.image.load(fullname)
|
|
49 |
- except pygame.error, message:
|
|
50 |
- print 'Cannot load image:', fullname
|
|
51 |
- raise SystemExit, message
|
|
52 |
+ except pygame.error as message:
|
|
53 |
+ print('Cannot load image:', fullname)
|
|
54 |
+ raise SystemExit(message)
|
|
55 |
|
|
56 |
if size is not None:
|
|
57 |
image = pygame.transform.scale( image, size)
|
|
58 |
@@ -147,8 +147,8 @@
|
|
59 |
fullname = os.path.join('sounds', name)
|
|
60 |
try:
|
|
61 |
sound = pygame.mixer.Sound(fullname)
|
|
62 |
- except pygame.error, message:
|
|
63 |
- print 'Cannot load sound:', fullname
|
|
64 |
+ except pygame.error as message:
|
|
65 |
+ print('Cannot load sound:', fullname)
|
|
66 |
return NoneSound()
|
|
67 |
|
|
68 |
sound.set_volume( volume * sound_effects_volume)
|
|
69 |
@@ -168,14 +168,14 @@
|
|
70 |
return
|
|
71 |
|
|
72 |
if not pygame.mixer or not pygame.mixer.music:
|
|
73 |
- print "Background music not available."
|
|
74 |
+ print("Background music not available.")
|
|
75 |
return
|
|
76 |
pygame.mixer.music.stop()
|
|
77 |
fullname = os.path.join('music', name)
|
|
78 |
try:
|
|
79 |
pygame.mixer.music.load(fullname)
|
|
80 |
- except pygame.error, message:
|
|
81 |
- print 'Cannot load music:', fullname
|
|
82 |
+ except pygame.error as message:
|
|
83 |
+ print('Cannot load music:', fullname)
|
|
84 |
return
|
|
85 |
music_loaded = 1
|
|
86 |
pygame.mixer.music.play(-1)
|
|
87 |
@@ -263,17 +263,17 @@
|
|
88 |
def load_images():
|
|
89 |
Marble.images = []
|
|
90 |
for i in range(9):
|
|
91 |
- Marble.images.append( load_image('marble-'+`i`+cbext, -1,
|
|
92 |
+ Marble.images.append( load_image('marble-'+repr(i)+cbext, -1,
|
|
93 |
(marble_size, marble_size)))
|
|
94 |
|
|
95 |
Tile.plain_tiles = []
|
|
96 |
Tile.tunnels = []
|
|
97 |
for i in range(16):
|
|
98 |
tile = load_image('tile.png', (206,53,53), (tile_size,tile_size))
|
|
99 |
- path = load_image('path-'+`i`+'.png', -1, (tile_size,tile_size))
|
|
100 |
+ path = load_image('path-'+repr(i)+'.png', -1, (tile_size,tile_size))
|
|
101 |
tile.blit( path, (0,0))
|
|
102 |
Tile.plain_tiles.append( tile)
|
|
103 |
- Tile.tunnels.append(load_image('tunnel-'+`i`+'.png',
|
|
104 |
+ Tile.tunnels.append(load_image('tunnel-'+repr(i)+'.png',
|
|
105 |
-1,(tile_size,tile_size)))
|
|
106 |
Tile.paths = 0
|
|
107 |
|
|
108 |
@@ -295,12 +295,12 @@
|
|
109 |
|
|
110 |
Painter.images = []
|
|
111 |
for i in range(8):
|
|
112 |
- Painter.images.append( load_image('painter-'+`i`+cbext, -1,
|
|
113 |
+ Painter.images.append( load_image('painter-'+repr(i)+cbext, -1,
|
|
114 |
(tile_size,tile_size)))
|
|
115 |
|
|
116 |
Filter.images = []
|
|
117 |
for i in range(8):
|
|
118 |
- Filter.images.append( load_image('filter-'+`i`+cbext, -1,
|
|
119 |
+ Filter.images.append( load_image('filter-'+repr(i)+cbext, -1,
|
|
120 |
(tile_size,tile_size)))
|
|
121 |
|
|
122 |
Director.images = (
|
|
123 |
@@ -318,7 +318,7 @@
|
|
124 |
for j in range(4):
|
|
125 |
if i == j: Switch.images[i].append( None)
|
|
126 |
else: Switch.images[i].append( load_image(
|
|
127 |
- 'switch-'+`i`+`j`+'.png',-1,(tile_size,tile_size)))
|
|
128 |
+ 'switch-'+repr(i)+repr(j)+'.png',-1,(tile_size,tile_size)))
|
|
129 |
|
|
130 |
Replicator.image = load_image('replicator.png',-1,(tile_size,tile_size))
|
|
131 |
|
|
132 |
@@ -340,7 +340,7 @@
|
|
133 |
Board.launcher_v = load_image('launcher-v.png', None,
|
|
134 |
(marble_size, vert_tiles * tile_size + marble_size))
|
|
135 |
Board.launcher_corner = load_image('launcher-corner.png', (255,0,0),
|
|
136 |
- ((tile_size-marble_size)/2+marble_size,marble_size))
|
|
137 |
+ ((tile_size-marble_size)//2+marble_size,marble_size))
|
|
138 |
Board.launcher_entrance = load_image('entrance.png', -1,
|
|
139 |
(tile_size,marble_size))
|
|
140 |
|
|
141 |
@@ -414,7 +414,7 @@
|
|
142 |
def click(self, board, posx, posy, tile_x, tile_y): pass
|
|
143 |
|
|
144 |
def affect_marble(self, board, marble, rpos):
|
|
145 |
- if rpos == (tile_size/2,tile_size/2):
|
|
146 |
+ if rpos == (tile_size//2,tile_size//2):
|
|
147 |
if self.paths & (1 << marble.direction): return
|
|
148 |
|
|
149 |
# Figure out the new direction
|
|
150 |
@@ -442,8 +442,8 @@
|
|
151 |
for i in range(4):
|
|
152 |
holecenter = holecenters[self.spinpos][i]
|
|
153 |
surface.blit( self.moving_holes[self.completed],
|
|
154 |
- (holecenter[0]-marble_size/2+self.rect.left,
|
|
155 |
- holecenter[1]-marble_size/2+self.rect.top))
|
|
156 |
+ (holecenter[0]-marble_size//2+self.rect.left,
|
|
157 |
+ holecenter[1]-marble_size//2+self.rect.top))
|
|
158 |
else:
|
|
159 |
surface.blit( self.images[self.completed], self.rect.topleft)
|
|
160 |
|
|
161 |
@@ -452,8 +452,8 @@
|
|
162 |
if color >= 0:
|
|
163 |
holecenter = holecenters[self.spinpos][i]
|
|
164 |
surface.blit( Marble.images[color],
|
|
165 |
- (holecenter[0]-marble_size/2+self.rect.left,
|
|
166 |
- holecenter[1]-marble_size/2+self.rect.top))
|
|
167 |
+ (holecenter[0]-marble_size//2+self.rect.left,
|
|
168 |
+ holecenter[1]-marble_size//2+self.rect.top))
|
|
169 |
|
|
170 |
return 1
|
|
171 |
|
|
172 |
@@ -538,10 +538,10 @@
|
|
173 |
|
|
174 |
def affect_marble(self, board, marble, rpos):
|
|
175 |
# Watch for marbles entering
|
|
176 |
- if rpos[0]+marble_size/2 == wheel_margin or \
|
|
177 |
- rpos[0]-marble_size/2 == tile_size - wheel_margin or \
|
|
178 |
- rpos[1]+marble_size/2 == wheel_margin or \
|
|
179 |
- rpos[1]-marble_size/2 == tile_size - wheel_margin:
|
|
180 |
+ if rpos[0]+marble_size//2 == wheel_margin or \
|
|
181 |
+ rpos[0]-marble_size//2 == tile_size - wheel_margin or \
|
|
182 |
+ rpos[1]+marble_size//2 == wheel_margin or \
|
|
183 |
+ rpos[1]-marble_size//2 == tile_size - wheel_margin:
|
|
184 |
if self.spinpos or self.marbles[marble.direction^2] >= -1:
|
|
185 |
# Reject the marble
|
|
186 |
marble.direction = marble.direction ^ 2
|
|
187 |
@@ -618,8 +618,8 @@
|
|
188 |
if color >= 0:
|
|
189 |
holecenter = self.rect.center
|
|
190 |
surface.blit( Marble.images[color],
|
|
191 |
- (holecenter[0]-marble_size/2,
|
|
192 |
- holecenter[1]-marble_size/2))
|
|
193 |
+ (holecenter[0]-marble_size//2,
|
|
194 |
+ holecenter[1]-marble_size//2))
|
|
195 |
else:
|
|
196 |
surface.blit( self.bottom, self.rect.topleft)
|
|
197 |
|
|
198 |
@@ -633,10 +633,10 @@
|
|
199 |
|
|
200 |
def affect_marble(self, board, marble, rpos):
|
|
201 |
# Watch for marbles entering
|
|
202 |
- if (rpos[0]+marble_size == tile_size/2 and marble.direction == 1) or \
|
|
203 |
- (rpos[0]-marble_size == tile_size/2 and marble.direction == 3) or \
|
|
204 |
- (rpos[1]+marble_size == tile_size/2 and marble.direction == 2) or \
|
|
205 |
- (rpos[1]-marble_size == tile_size/2 and marble.direction == 0):
|
|
206 |
+ if (rpos[0]+marble_size == tile_size//2 and marble.direction == 1) or \
|
|
207 |
+ (rpos[0]-marble_size == tile_size//2 and marble.direction == 3) or \
|
|
208 |
+ (rpos[1]+marble_size == tile_size//2 and marble.direction == 2) or \
|
|
209 |
+ (rpos[1]-marble_size == tile_size//2 and marble.direction == 0):
|
|
210 |
|
|
211 |
if self.entering is not None:
|
|
212 |
# Bump the marble that is currently entering
|
|
213 |
@@ -648,7 +648,7 @@
|
|
214 |
|
|
215 |
# Let the base class affect the marble
|
|
216 |
Tile.affect_marble(self, board, newmarble,
|
|
217 |
- (tile_size/2,tile_size/2))
|
|
218 |
+ (tile_size//2,tile_size//2))
|
|
219 |
elif self.marble >= 0:
|
|
220 |
# Bump the marble that is currently caught
|
|
221 |
newmarble = Marble( self.marble, self.rect.center, marble.direction)
|
|
222 |
@@ -659,7 +659,7 @@
|
|
223 |
|
|
224 |
# Let the base class affect the marble
|
|
225 |
Tile.affect_marble(self, board, newmarble,
|
|
226 |
- (tile_size/2,tile_size/2))
|
|
227 |
+ (tile_size//2,tile_size//2))
|
|
228 |
|
|
229 |
self.marble = -1
|
|
230 |
self.drawn = 0
|
|
231 |
@@ -667,7 +667,7 @@
|
|
232 |
# Remember which marble is on its way in
|
|
233 |
self.entering = marble
|
|
234 |
|
|
235 |
- elif rpos == (tile_size/2, tile_size/2):
|
|
236 |
+ elif rpos == (tile_size//2, tile_size//2):
|
|
237 |
# Catch this marble
|
|
238 |
self.marble = marble.color
|
|
239 |
board.marbles.remove( marble)
|
|
240 |
@@ -686,7 +686,7 @@
|
|
241 |
|
|
242 |
def affect_marble(self, board, marble, rpos):
|
|
243 |
Tile.affect_marble( self, board, marble, rpos)
|
|
244 |
- if rpos == (tile_size/2, tile_size/2):
|
|
245 |
+ if rpos == (tile_size//2, tile_size//2):
|
|
246 |
if marble.color != self.color:
|
|
247 |
# Change the color
|
|
248 |
marble.color = self.color
|
|
249 |
@@ -703,7 +703,7 @@
|
|
250 |
return 0
|
|
251 |
|
|
252 |
def affect_marble(self, board, marble, rpos):
|
|
253 |
- if rpos == (tile_size/2, tile_size/2):
|
|
254 |
+ if rpos == (tile_size//2, tile_size//2):
|
|
255 |
# If the color is wrong, bounce the marble
|
|
256 |
if marble.color != self.color and marble.color != 8:
|
|
257 |
marble.direction = marble.direction ^ 2
|
|
258 |
@@ -723,7 +723,7 @@
|
|
259 |
return 0
|
|
260 |
|
|
261 |
def affect_marble(self, board, marble, rpos):
|
|
262 |
- if rpos == (tile_size/2, tile_size/2):
|
|
263 |
+ if rpos == (tile_size//2, tile_size//2):
|
|
264 |
marble.direction = self.direction
|
|
265 |
play_sound( direct_marble)
|
|
266 |
|
|
267 |
@@ -737,7 +737,7 @@
|
|
268 |
return 0
|
|
269 |
|
|
270 |
def affect_marble(self, board, marble, rpos):
|
|
271 |
- if rpos == (tile_size/2, tile_size/2):
|
|
272 |
+ if rpos == (tile_size//2, tile_size//2):
|
|
273 |
board.marbles.remove( marble)
|
|
274 |
play_sound( shredder)
|
|
275 |
|
|
276 |
@@ -764,7 +764,7 @@
|
|
277 |
return rc
|
|
278 |
|
|
279 |
def affect_marble(self, board, marble, rpos):
|
|
280 |
- if rpos == (tile_size/2, tile_size/2):
|
|
281 |
+ if rpos == (tile_size//2, tile_size//2):
|
|
282 |
marble.direction = self.curdir
|
|
283 |
self.switch()
|
|
284 |
|
|
285 |
@@ -800,7 +800,7 @@
|
|
286 |
|
|
287 |
def affect_marble(self, board, marble, rpos):
|
|
288 |
Tile.affect_marble( self, board, marble, rpos)
|
|
289 |
- if rpos == (tile_size/2, tile_size/2):
|
|
290 |
+ if rpos == (tile_size//2, tile_size//2):
|
|
291 |
# Add the marble to the pending list
|
|
292 |
self.pending.append( [marble.color,marble.direction,
|
|
293 |
self.count - 1, replicator_delay]);
|
|
294 |
@@ -823,7 +823,7 @@
|
|
295 |
other.other = self
|
|
296 |
|
|
297 |
def affect_marble(self, board, marble, rpos):
|
|
298 |
- if rpos == (tile_size/2, tile_size/2):
|
|
299 |
+ if rpos == (tile_size//2, tile_size//2):
|
|
300 |
marble.rect.center = self.other.rect.center
|
|
301 |
play_sound( teleport)
|
|
302 |
|
|
303 |
@@ -857,8 +857,8 @@
|
|
304 |
if self.marbles is not None:
|
|
305 |
for i in range(4):
|
|
306 |
surface.blit( Marble.images[self.marbles[i]],
|
|
307 |
- (holecenters[0][i][0]+self.rect.left-marble_size/2,
|
|
308 |
- holecenters[0][i][1]+self.rect.top-marble_size/2))
|
|
309 |
+ (holecenters[0][i][0]+self.rect.left-marble_size//2,
|
|
310 |
+ holecenters[0][i][1]+self.rect.top-marble_size//2))
|
|
311 |
return 1
|
|
312 |
|
|
313 |
def complete(self, board):
|
|
314 |
@@ -916,7 +916,7 @@
|
|
315 |
# Create the board array
|
|
316 |
self.tiles = []
|
|
317 |
for j in range( vert_tiles):
|
|
318 |
- row = range( horiz_tiles)
|
|
319 |
+ row = list(range( horiz_tiles))
|
|
320 |
self.tiles.append( row)
|
|
321 |
|
|
322 |
# Load the level
|
|
323 |
@@ -928,21 +928,21 @@
|
|
324 |
# Compute a hash of the current level, involving
|
|
325 |
# a static timestamp. This provides a consistent,
|
|
326 |
# backtrackable pseudo-random function.
|
|
327 |
- hash = md5.new(`game.gamestart`+"/"+`game.level`).digest()
|
|
328 |
+ hash = hashlib.md5((repr(game.gamestart)+"/"+repr(game.level)).encode()).digest()
|
|
329 |
hashval = (ord(hash[0]) + (ord(hash[1]) << 8) + \
|
|
330 |
(ord(hash[2]) << 16) + (ord(hash[3]) << 24)) & 32767;
|
|
331 |
self._load( game.circuit, hashval % game.numlevels);
|
|
332 |
|
|
333 |
# Create the launch timer text object
|
|
334 |
self.launch_timer_text = launch_timer_font.render(
|
|
335 |
- `self.launch_timer`, 1, (255,255,255))
|
|
336 |
+ repr(self.launch_timer), 1, (255,255,255))
|
|
337 |
self.launch_timer_text_rect = self.launch_timer_text.get_rect()
|
|
338 |
- self.launch_timer_text_rect.centerx = launch_timer_pos[0]+timer_width/2+1
|
|
339 |
+ self.launch_timer_text_rect.centerx = launch_timer_pos[0]+timer_width//2+1
|
|
340 |
self.launch_timer_text_rect.bottom = \
|
|
341 |
launch_timer_pos[1] + timer_height - timer_margin
|
|
342 |
|
|
343 |
# Fill up the launch queue
|
|
344 |
- for i in range( vert_tiles * tile_size / marble_size + 2):
|
|
345 |
+ for i in range( vert_tiles * tile_size // marble_size + 2):
|
|
346 |
self.launch_queue.append(random.choice(self.colors))
|
|
347 |
|
|
348 |
# Create The Background
|
|
349 |
@@ -964,11 +964,11 @@
|
|
350 |
self.background.blit( self.launcher_entrance,
|
|
351 |
(board_pos[0]+tile_size*i, board_pos[1]-marble_size))
|
|
352 |
self.background.blit( self.launcher_corner,
|
|
353 |
- (board_pos[0]+horiz_tiles*tile_size-(tile_size-marble_size)/2,
|
|
354 |
+ (board_pos[0]+horiz_tiles*tile_size-(tile_size-marble_size)//2,
|
|
355 |
board_pos[1] - marble_size))
|
|
356 |
|
|
357 |
# Draw the board name
|
|
358 |
- board_name = `self.game.level+1` + " - " + self.name
|
|
359 |
+ board_name = repr(self.game.level+1) + " - " + self.name
|
|
360 |
if self.game.level >= self.game.numlevels:
|
|
361 |
board_name += " (Random)"
|
|
362 |
text = info_font.render( board_name, 1, (0,0,0))
|
|
363 |
@@ -1002,7 +1002,7 @@
|
|
364 |
timer_width-timer_margin*2,height))
|
|
365 |
dirty_rects.append( rect)
|
|
366 |
else:
|
|
367 |
- height = timer_height*self.launch_timeout/self.launch_timeout_start
|
|
368 |
+ height = timer_height*self.launch_timeout//self.launch_timeout_start
|
|
369 |
if height < self.launch_timer_height:
|
|
370 |
rect = (launch_timer_pos[0] + timer_margin,
|
|
371 |
launch_timer_pos[1] + timer_height - self.launch_timer_height,
|
|
372 |
@@ -1021,15 +1021,15 @@
|
|
373 |
dirty_rects.append( rect)
|
|
374 |
|
|
375 |
# Draw the score
|
|
376 |
- text = "Score: "+("00000000"+`self.game.score`)[-8:]
|
|
377 |
+ text = "Score: "+("00000000"+repr(self.game.score))[-8:]
|
|
378 |
text = info_font.render( text, 1, (0,0,0))
|
|
379 |
rect = text.get_rect()
|
|
380 |
rect.left = self.score_pos
|
|
381 |
self.screen.blit( text, rect)
|
|
382 |
|
|
383 |
# Draw the board timer
|
|
384 |
- time_remaining = (self.board_timeout+frames_per_sec-1)/frames_per_sec
|
|
385 |
- text = `time_remaining/60`+":"+("00"+`time_remaining%60`)[-2:]
|
|
386 |
+ time_remaining = (self.board_timeout+frames_per_sec-1)//frames_per_sec
|
|
387 |
+ text = repr(time_remaining//60)+":"+("00"+repr(time_remaining%60))[-2:]
|
|
388 |
text = info_font.render( text, 1, (0,0,0))
|
|
389 |
rect = text.get_rect()
|
|
390 |
rect.left = self.board_timer_pos
|
|
391 |
@@ -1039,7 +1039,7 @@
|
|
392 |
right_edge = self.board_timer_pos - 32
|
|
393 |
for i in range(self.game.lives - 1):
|
|
394 |
rect = self.life_marble.get_rect()
|
|
395 |
- rect.centery = info_height / 2
|
|
396 |
+ rect.centery = info_height // 2
|
|
397 |
rect.right = right_edge
|
|
398 |
self.screen.blit( self.life_marble, rect)
|
|
399 |
right_edge -= rect.width + 4
|
|
400 |
@@ -1048,11 +1048,11 @@
|
|
401 |
num_marbles = len(self.marbles)
|
|
402 |
if num_marbles > self.live_marbles_limit:
|
|
403 |
num_marbles = self.live_marbles_limit
|
|
404 |
- text = `num_marbles`+"/"+`self.live_marbles_limit`
|
|
405 |
+ text = repr(num_marbles)+"/"+repr(self.live_marbles_limit)
|
|
406 |
text = active_marbles_font.render( text, 1, (40,40,40))
|
|
407 |
rect = text.get_rect()
|
|
408 |
rect.left = self.pos[0] + 8
|
|
409 |
- rect.centery = self.pos[1] - marble_size / 2
|
|
410 |
+ rect.centery = self.pos[1] - marble_size // 2
|
|
411 |
rect.width += 100
|
|
412 |
self.screen.set_clip( rect)
|
|
413 |
self.screen.blit( self.background, (0,0))
|
|
414 |
@@ -1167,7 +1167,7 @@
|
|
415 |
def set_launch_timer(self, passes):
|
|
416 |
self.launch_timer = passes
|
|
417 |
self.launch_timeout_start = (marble_size +
|
|
418 |
- (horiz_tiles * tile_size - marble_size) * passes) / marble_speed
|
|
419 |
+ (horiz_tiles * tile_size - marble_size) * passes) // marble_speed
|
|
420 |
self.launch_timer_height = None
|
|
421 |
|
|
422 |
def set_board_timer(self, seconds):
|
|
423 |
@@ -1178,8 +1178,8 @@
|
|
424 |
def launch_marble(self):
|
|
425 |
self.launch_queue.append(random.choice(self.colors))
|
|
426 |
self.marbles.insert( 0, Marble( self.launch_queue[0],
|
|
427 |
- (self.pos[0]+tile_size*horiz_tiles+marble_size/2,
|
|
428 |
- self.pos[1]-marble_size/2), 3))
|
|
429 |
+ (self.pos[0]+tile_size*horiz_tiles+marble_size//2,
|
|
430 |
+ self.pos[1]-marble_size//2), 3))
|
|
431 |
del self.launch_queue[0]
|
|
432 |
self.launched = 1
|
|
433 |
|
|
434 |
@@ -1192,15 +1192,15 @@
|
|
435 |
cy = c[1] - self.pos[1]
|
|
436 |
|
|
437 |
# Bounce marbles off of the top
|
|
438 |
- if cy == marble_size/2:
|
|
439 |
+ if cy == marble_size//2:
|
|
440 |
marble.direction = 2
|
|
441 |
return
|
|
442 |
|
|
443 |
if cy < 0:
|
|
444 |
- if cx == marble_size/2:
|
|
445 |
+ if cx == marble_size//2:
|
|
446 |
marble.direction = 1
|
|
447 |
return
|
|
448 |
- if cx == tile_size * horiz_tiles - marble_size/2 \
|
|
449 |
+ if cx == tile_size * horiz_tiles - marble_size//2 \
|
|
450 |
and marble.direction == 1:
|
|
451 |
marble.direction = 3
|
|
452 |
return
|
|
453 |
@@ -1209,11 +1209,11 @@
|
|
454 |
effective_cx = cx
|
|
455 |
effective_cy = cy + marble_size
|
|
456 |
else:
|
|
457 |
- effective_cx = cx + marble_size/2 * dirs[marble.direction][0]
|
|
458 |
- effective_cy = cy + marble_size/2 * dirs[marble.direction][1]
|
|
459 |
+ effective_cx = cx + marble_size//2 * dirs[marble.direction][0]
|
|
460 |
+ effective_cy = cy + marble_size//2 * dirs[marble.direction][1]
|
|
461 |
|
|
462 |
- tile_x = effective_cx / tile_size
|
|
463 |
- tile_y = effective_cy / tile_size
|
|
464 |
+ tile_x = effective_cx // tile_size
|
|
465 |
+ tile_y = effective_cy // tile_size
|
|
466 |
tile_xr = cx - tile_x * tile_size
|
|
467 |
tile_yr = cy - tile_y * tile_size
|
|
468 |
|
|
469 |
@@ -1223,7 +1223,7 @@
|
|
470 |
|
|
471 |
if cy < 0 and marble.direction != 2:
|
|
472 |
# The special case of new marbles at the top
|
|
473 |
- if tile_xr == tile_size / 2 and (tile.paths & 1):
|
|
474 |
+ if tile_xr == tile_size // 2 and (tile.paths & 1):
|
|
475 |
if isinstance( tile, Wheel):
|
|
476 |
if tile.spinpos > 0 or tile.marbles[0] != -3: return
|
|
477 |
tile.marbles[0] = -2
|
|
478 |
@@ -1237,8 +1237,8 @@
|
|
479 |
|
|
480 |
def click(self, pos):
|
|
481 |
# Determine which tile the pointer is in
|
|
482 |
- tile_x = (pos[0] - self.pos[0]) / tile_size
|
|
483 |
- tile_y = (pos[1] - self.pos[1]) / tile_size
|
|
484 |
+ tile_x = (pos[0] - self.pos[0]) // tile_size
|
|
485 |
+ tile_y = (pos[1] - self.pos[1]) // tile_size
|
|
486 |
tile_xr = pos[0] - self.pos[0] - tile_x * tile_size
|
|
487 |
tile_yr = pos[1] - self.pos[1] - tile_y * tile_size
|
|
488 |
if tile_x >= 0 and tile_x < horiz_tiles and \
|
|
489 |
@@ -1491,16 +1491,16 @@
|
|
490 |
except:
|
|
491 |
try:
|
|
492 |
f = os.popen(write_highscores, "w")
|
|
493 |
- except OSError, message:
|
|
494 |
- print "Warning: Can't save highscores:", message
|
|
495 |
+ except OSError as message:
|
|
496 |
+ print("Warning: Can't save highscores:", message)
|
|
497 |
return
|
|
498 |
|
|
499 |
try:
|
|
500 |
for i in self.scores:
|
|
501 |
- f.write( `i[0]`+' '+i[1]+' '+`i[2]`+' '+i[3]+'\n')
|
|
502 |
+ f.write( repr(i[0])+' '+i[1]+' '+repr(i[2])+' '+i[3]+'\n')
|
|
503 |
f.close()
|
|
504 |
except:
|
|
505 |
- print "Warning: Problem saving highscores."
|
|
506 |
+ print("Warning: Problem saving highscores.")
|
|
507 |
|
|
508 |
def wait_one_sec():
|
|
509 |
time.sleep(1)
|
|
510 |
@@ -1580,7 +1580,7 @@
|
|
511 |
if line == '': break
|
|
512 |
if line[0] == '|': j += 1
|
|
513 |
f.close()
|
|
514 |
- self.numlevels = j / vert_tiles
|
|
515 |
+ self.numlevels = j // vert_tiles
|
|
516 |
|
|
517 |
self.level = level
|
|
518 |
self.score = 0
|
|
519 |
@@ -1593,7 +1593,7 @@
|
|
520 |
self.score += amount
|
|
521 |
|
|
522 |
# Award any extra lives that are due
|
|
523 |
- extra_lives = amount / extra_life_frequency + \
|
|
524 |
+ extra_lives = amount // extra_life_frequency + \
|
|
525 |
(self.score % extra_life_frequency < amount % extra_life_frequency)
|
|
526 |
extra_lives = min( extra_lives, max_spare_lives+1 - self.lives)
|
|
527 |
if extra_lives > 0:
|
|
528 |
@@ -1653,7 +1653,7 @@
|
|
529 |
"You have a highscore!\n"+
|
|
530 |
"Please enter your name:", (300, 180))
|
|
531 |
name = get_name( self.screen, popup_font,
|
|
532 |
- ((screen_width-250)/2,310,250,popup_font.get_height()),
|
|
533 |
+ ((screen_width-250)//2,310,250,popup_font.get_height()),
|
|
534 |
(255,255,255), (0,0,0))
|
|
535 |
if name is None: return -1
|
|
536 |
|
|
537 |
@@ -1672,7 +1672,7 @@
|
|
538 |
# The board was completed
|
|
539 |
|
|
540 |
# Compute time remaining bonus
|
|
541 |
- time_remaining = 100 * board.board_timeout / \
|
|
542 |
+ time_remaining = 100 * board.board_timeout // \
|
|
543 |
board.board_timeout_start
|
|
544 |
time_bonus = 5 * time_remaining
|
|
545 |
|
|
546 |
@@ -1685,16 +1685,16 @@
|
|
547 |
total_holes += 4
|
|
548 |
for i in tile.marbles:
|
|
549 |
if i < 0: empty_holes += 1
|
|
550 |
- empty_holes = (100 * empty_holes + total_holes/2) / total_holes
|
|
551 |
+ empty_holes = (100 * empty_holes + total_holes//2) // total_holes
|
|
552 |
holes_bonus = 2 * empty_holes
|
|
553 |
|
|
554 |
self.increase_score( time_bonus + holes_bonus)
|
|
555 |
|
|
556 |
message = 'Level Complete!\n'+ \
|
|
557 |
- "Bonus for " + `time_remaining` + "% time remaining: " + \
|
|
558 |
- `time_bonus` + "\n" + \
|
|
559 |
- "Bonus for " + `empty_holes` + "% holes empty: " + \
|
|
560 |
- `holes_bonus` + '\nClick to continue.'
|
|
561 |
+ "Bonus for " + repr(time_remaining) + "% time remaining: " + \
|
|
562 |
+ repr(time_bonus) + "\n" + \
|
|
563 |
+ "Bonus for " + repr(empty_holes) + "% holes empty: " + \
|
|
564 |
+ repr(holes_bonus) + '\nClick to continue.'
|
|
565 |
|
|
566 |
rc = self.board_dialog( message, 1, 1)
|
|
567 |
self.level += 1
|
|
568 |
@@ -1776,7 +1776,7 @@
|
|
569 |
return key
|
|
570 |
|
|
571 |
def get_name( screen, font, cursor_box, backcol, forecol):
|
|
572 |
- cursor_width = cursor_box[3] / 3
|
|
573 |
+ cursor_width = cursor_box[3] // 3
|
|
574 |
cursor_pos = [cursor_box[0], cursor_box[1], cursor_width, cursor_box[3]]
|
|
575 |
name = ""
|
|
576 |
|
|
577 |
@@ -1835,7 +1835,7 @@
|
|
578 |
"Sound Effects:", "Quit Game")
|
|
579 |
start_level = 1
|
|
580 |
menu_width = 240
|
|
581 |
- menu_pos = ((800 - menu_width)/2, 145)
|
|
582 |
+ menu_pos = ((800 - menu_width)//2, 145)
|
|
583 |
menu_font_height = 32
|
|
584 |
menu_color = (255,255,255)
|
|
585 |
menu_cursor_color = (60,60,60)
|
|
586 |
@@ -2072,7 +2072,7 @@
|
|
587 |
if pos[0] < self.menu_pos[0]: continue
|
|
588 |
if pos[0] >= self.menu_pos[0] + self.menu_width: continue
|
|
589 |
if pos[1] < self.menu_pos[1]: continue
|
|
590 |
- i = (pos[1] - self.menu_pos[1]) / self.menu_font_height
|
|
591 |
+ i = (pos[1] - self.menu_pos[1]) // self.menu_font_height
|
|
592 |
if i >= len(self.menu): continue
|
|
593 |
rc = self.menu_select( i)
|
|
594 |
if rc: return rc
|
|
595 |
@@ -2108,7 +2108,7 @@
|
|
596 |
|
|
597 |
hs_font_height = 24
|
|
598 |
hs_width = 320
|
|
599 |
- hs_pos = ((800-hs_width)/2, 114)
|
|
600 |
+ hs_pos = ((800-hs_width)//2, 114)
|
|
601 |
hs_margin = 8
|
|
602 |
hs_column_margin = 70
|
|
603 |
hs_score_width = 70
|
|
604 |
@@ -2162,7 +2162,7 @@
|
|
605 |
numcolor = color = self.hs_current_color
|
|
606 |
|
|
607 |
y += self.hs_font_height
|
|
608 |
- number = self.hs_font.render(`j+1`+'.',1,numcolor)
|
|
609 |
+ number = self.hs_font.render(repr(j+1)+'.',1,numcolor)
|
|
610 |
self.screen.blit( number,
|
|
611 |
(x + number_width - number.get_size()[0], y))
|
|
612 |
if i[3] != '':
|
|
613 |
@@ -2170,9 +2170,9 @@
|
|
614 |
if name.get_width() > name_width:
|
|
615 |
name = name.subsurface( (0,0,name_width,name.get_height()))
|
|
616 |
self.screen.blit( name, (x + name_left, y))
|
|
617 |
- level = self.hs_font.render( `i[2]`, 1, color)
|
|
618 |
+ level = self.hs_font.render( repr(i[2]), 1, color)
|
|
619 |
self.screen.blit( level, (x + level_right - level.get_width(), y))
|
|
620 |
- score = self.hs_font.render( `i[0]`, 1, color)
|
|
621 |
+ score = self.hs_font.render( repr(i[0]), 1, color)
|
|
622 |
self.screen.blit( score, (x + score_right - score.get_width(), y))
|
|
623 |
|
|
624 |
self.dirty_rects.append( self.hs_rect)
|
|
625 |
@@ -2190,14 +2190,14 @@
|
|
626 |
try:
|
|
627 |
pygame.mixer.init()
|
|
628 |
except:
|
|
629 |
- print "error on pygame.mixer.init() inside setup_everything():"
|
|
630 |
- print sys.exc_info()[0],":",sys.exc_info()[1]
|
|
631 |
- print "...ignoring it"
|
|
632 |
+ print("error on pygame.mixer.init() inside setup_everything():")
|
|
633 |
+ print(sys.exc_info()[0],":",sys.exc_info()[1])
|
|
634 |
+ print("...ignoring it")
|
|
635 |
pygame.font.init()
|
|
636 |
pygame.key.set_repeat(500, 30)
|
|
637 |
|
|
638 |
- if not pygame.font: print 'Warning, fonts disabled'
|
|
639 |
- if not pygame.mixer: print 'Warning, sound disabled'
|
|
640 |
+ if not pygame.font: print('Warning, fonts disabled')
|
|
641 |
+ if not pygame.mixer: print('Warning, sound disabled')
|
|
642 |
|
|
643 |
set_video_mode()
|
|
644 |
load_sounds()
|