[Sugar-devel] [PATCH 2/2] some pep8 errors fixed
Manuel Kaufmann
humitos at gmail.com
Tue Mar 20 14:54:57 EDT 2012
- removed a lot of trailing slashes
- added spaces between operators
- splited lines with more than 80 chars
---
game.py | 315 ++++++++++++++++++++++++++++++++++++---------------------------
1 files changed, 182 insertions(+), 133 deletions(-)
diff --git a/game.py b/game.py
index f98a395..579c5c4 100644
--- a/game.py
+++ b/game.py
@@ -6,27 +6,25 @@
#
# Copyright (C) 2007 Joshua Minor
# This file is part of Maze.activity
-#
+#
# Maze.activity 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.
-#
+#
# Maze.activity is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
-#
+#
# You should have received a copy of the GNU General Public License
# along with Maze.activity. If not, see <http://www.gnu.org/licenses/>.
import sys
-import os
import time
import pygame
-import olpcgames
import olpcgames.pausescreen as pausescreen
import olpcgames.mesh as mesh
@@ -51,30 +49,30 @@ from player import Player
class MazeGame:
"""Maze game controller.
This class handles all of the game logic, event loop, mulitplayer, etc."""
-
+
# Munsell color values http://wiki.laptop.org/go/Munsell
- N10 = (255, 255, 255)
+ N10 = (255, 255, 255)
N9p5 = (243, 243, 243)
- N9 = (232, 232, 232)
- N8 = (203, 203, 203)
- N7 = (179, 179, 179)
- N6 = (150, 150, 150)
- N5 = (124, 124, 124)
- N4 = ( 97, 97, 97)
- N3 = ( 70, 70, 70)
- N2 = ( 48, 48, 48)
- N1 = ( 28, 28, 28)
- N0 = ( 0, 0, 0)
+ N9 = (232, 232, 232)
+ N8 = (203, 203, 203)
+ N7 = (179, 179, 179)
+ N6 = (150, 150, 150)
+ N5 = (124, 124, 124)
+ N4 = (97, 97, 97)
+ N3 = (70, 70, 70)
+ N2 = (48, 48, 48)
+ N1 = (28, 28, 28)
+ N0 = (0, 0, 0)
EMPTY_COLOR = N8
SOLID_COLOR = N1
TRAIL_COLOR = N10
- GOAL_COLOR = (0x00, 0xff, 0x00)
- WIN_COLOR = (0xff, 0xff, 0x00)
+ GOAL_COLOR = (0x00, 0xff, 0x00)
+ WIN_COLOR = (0xff, 0xff, 0x00)
def __init__(self, screen):
# note what time it was when we first launched
self.game_start_time = time.time()
-
+
xoOwner = presenceService.get_owner()
# keep a list of all local players
self.localplayers = []
@@ -87,36 +85,37 @@ class MazeGame:
# keep a dictionary of all remote players, indexed by handle
self.remoteplayers = {}
- # keep a list of all players, local and remote,
+ # keep a list of all players, local and remote,
self.allplayers = [] + self.localplayers
-
+
self.screen = screen
canvas_size = screen.get_size()
self.aspectRatio = canvas_size[0] / float(canvas_size[1])
-
- # start with a small maze using a seed that will be different each time you play
- self.maze = Maze(int(time.time()), int(9*self.aspectRatio), 9)
+
+ # start with a small maze using a seed that will be different
+ # each time you play
+ self.maze = Maze(int(time.time()), int(9 * self.aspectRatio), 9)
self.reset()
self.frame = 0
-
+
self.font = pygame.font.Font(None, 30)
-
+
# support arrow keys, game pad arrows and game pad buttons
# each set maps to a local player index and a direction
self.arrowkeys = {
- # real key: (localplayer index, ideal key)
- pygame.K_UP: (0, pygame.K_UP),
- pygame.K_DOWN: (0, pygame.K_DOWN),
- pygame.K_LEFT: (0, pygame.K_LEFT),
- pygame.K_RIGHT: (0, pygame.K_RIGHT),
- pygame.K_KP8: (1, pygame.K_UP),
- pygame.K_KP2: (1, pygame.K_DOWN),
- pygame.K_KP4: (1, pygame.K_LEFT),
- pygame.K_KP6: (1, pygame.K_RIGHT),
- pygame.K_KP9: (2, pygame.K_UP),
- pygame.K_KP3: (2, pygame.K_DOWN),
- pygame.K_KP7: (2, pygame.K_LEFT),
- pygame.K_KP1: (2, pygame.K_RIGHT)
+ # real key: (localplayer index, ideal key)
+ pygame.K_UP: (0, pygame.K_UP),
+ pygame.K_DOWN: (0, pygame.K_DOWN),
+ pygame.K_LEFT: (0, pygame.K_LEFT),
+ pygame.K_RIGHT: (0, pygame.K_RIGHT),
+ pygame.K_KP8: (1, pygame.K_UP),
+ pygame.K_KP2: (1, pygame.K_DOWN),
+ pygame.K_KP4: (1, pygame.K_LEFT),
+ pygame.K_KP6: (1, pygame.K_RIGHT),
+ pygame.K_KP9: (2, pygame.K_UP),
+ pygame.K_KP3: (2, pygame.K_DOWN),
+ pygame.K_KP7: (2, pygame.K_LEFT),
+ pygame.K_KP1: (2, pygame.K_RIGHT)
}
def game_running_time(self, newelapsed=None):
@@ -132,11 +131,12 @@ class MazeGame:
player.reset()
self.dirtyRect = None
self.dirtyPoints = []
- self.maze.map[self.maze.width-2][self.maze.height-2] = self.maze.GOAL
-
+ self.maze.map[self.maze.width - 2][self.maze.height - 2] = \
+ self.maze.GOAL
+
# clear and mark the whole screen as dirty
- self.screen.fill((0,0,0))
- self.markRectDirty(pygame.Rect(0,0,99999,99999))
+ self.screen.fill((0, 0, 0))
+ self.markRectDirty(pygame.Rect(0, 0, 99999, 99999))
self.mouse_in_use = 0
def markRectDirty(self, rect):
@@ -147,11 +147,11 @@ class MazeGame:
self.dirtyRect = rect
else:
self.dirtyRect.union_ip(rect)
-
+
def markPointDirty(self, pt):
"""Mark a single point that needs to be redrawn."""
self.dirtyPoints.append(pt)
-
+
def processEvent(self, event):
"""Process a single pygame event. This includes keystrokes
as well as multiplayer events from the mesh."""
@@ -164,22 +164,27 @@ class MazeGame:
self.harder()
elif event.key == pygame.K_MINUS:
self.easier()
- elif self.arrowkeys.has_key(event.key):
+ elif event.key in self.arrowkeys:
playernum, direction = self.arrowkeys[event.key]
player = self.localplayers[playernum]
player.hidden = False
-
+
if direction == pygame.K_UP:
- player.direction=(0,-1)
+ player.direction = (0, -1)
elif direction == pygame.K_DOWN:
- player.direction=(0,1)
+ player.direction = (0, 1)
elif direction == pygame.K_LEFT:
- player.direction=(-1,0)
+ player.direction = (-1, 0)
elif direction == pygame.K_RIGHT:
- player.direction=(1,0)
-
- if len(self.remoteplayers)>0:
- mesh.broadcast("move:%s,%d,%d,%d,%d" % (player.nick, player.position[0], player.position[1], player.direction[0], player.direction[1]))
+ player.direction = (1, 0)
+
+ if len(self.remoteplayers) > 0:
+ mesh.broadcast("move:%s,%d,%d,%d,%d" % \
+ (player.nick,
+ player.position[0],
+ player.position[1],
+ player.direction[0],
+ player.direction[1]))
elif event.type == pygame.KEYUP:
pass
elif event.type == pygame.MOUSEMOTION:
@@ -191,26 +196,35 @@ class MazeGame:
elif event.type == pygame.MOUSEBUTTONUP:
if self.mouse_in_use:
new_mouse_pos = pygame.mouse.get_pos()
- mouse_movement = ( new_mouse_pos[0] - self.prev_mouse_pos[0],
- new_mouse_pos[1] - self.prev_mouse_pos[1] )
+ mouse_movement = (new_mouse_pos[0] - self.prev_mouse_pos[0],
+ new_mouse_pos[1] - self.prev_mouse_pos[1])
if ((abs(mouse_movement[0]) > 10) or
- (abs(mouse_movement[1]) > 10)) :
+ (abs(mouse_movement[1]) > 10)):
player = self.localplayers[0]
player.hidden = False
- if abs(mouse_movement[0]) > abs(mouse_movement[1]): # x movement larger
- if mouse_movement[0] > 0: # direction == pygame.K_RIGHT
- player.direction=(1,0)
- else: # direction == pygame.K_LEFT
- player.direction=(-1,0)
+ # x movement larger
+ if abs(mouse_movement[0]) > abs(mouse_movement[1]):
+ # direction == pygame.K_RIGHT
+ if mouse_movement[0] > 0:
+ player.direction = (1, 0)
+ else:
+ # direction == pygame.K_LEFT
+ player.direction = (-1, 0)
else:
- if mouse_movement[1] < 0: # direction == pygame.K_UP
- player.direction=(0,-1)
+ if mouse_movement[1] < 0:
+ # direction == pygame.K_UP
+ player.direction = (0, -1)
else: # direction == pygame.K_DOWN
- player.direction=(0,1)
+ player.direction = (0, 1)
- if len(self.remoteplayers)>0:
- mesh.broadcast("move:%s,%d,%d,%d,%d" % (player.nick, player.position[0], player.position[1], player.direction[0], player.direction[1]))
+ if len(self.remoteplayers) > 0:
+ mesh.broadcast("move:%s,%d,%d,%d,%d" % \
+ (player.nick,
+ player.position[0],
+ player.position[1],
+ player.direction[0],
+ player.direction[1]))
self.mouse_in_use = 0
@@ -230,12 +244,20 @@ class MazeGame:
# send a test message to the new player
mesh.broadcast("Welcome %s" % player.nick)
# tell them which maze we are playing, so they can sync up
- mesh.send_to(event.handle, "maze:%d,%d,%d,%d" % (self.game_running_time(), self.maze.seed, self.maze.width, self.maze.height))
+ mesh.send_to(event.handle, "maze:%d,%d,%d,%d" % \
+ (self.game_running_time(),
+ self.maze.seed,
+ self.maze.width, self.maze.height))
for player in self.localplayers:
if not player.hidden:
- mesh.send_to(event.handle, "move:%s,%d,%d,%d,%d" % (player.nick, player.position[0], player.position[1], player.direction[0], player.direction[1]))
+ mesh.send_to(event.handle, "move:%s,%d,%d,%d,%d" % \
+ (player.nick,
+ player.position[0],
+ player.position[1],
+ player.direction[0],
+ player.direction[1]))
elif event.type == mesh.PARTICIPANT_REMOVE:
- if self.remoteplayers.has_key(event.handle):
+ if event.handle in self.remoteplayers:
player = self.remoteplayers[event.handle]
print "Leave:", player.nick
self.markPointDirty(player.position)
@@ -244,18 +266,21 @@ class MazeGame:
self.markPointDirty(bonusplayer.position)
self.allplayers.remove(bonusplayer)
del self.remoteplayers[event.handle]
- elif event.type == mesh.MESSAGE_UNI or event.type == mesh.MESSAGE_MULTI:
+ elif event.type == mesh.MESSAGE_UNI or \
+ event.type == mesh.MESSAGE_MULTI:
buddy = mesh.get_buddy(event.handle)
- #print "Message from %s / %s: %s" % (buddy.props.nick, event.handle, event.content)
+ # print "Message from %s / %s: %s" % (buddy.props.nick,
+ # event.handle, event.content)
if event.handle == mesh.my_handle():
# ignore messages from ourself
pass
- elif self.remoteplayers.has_key(event.handle):
+ elif event.handle in self.remoteplayers:
player = self.remoteplayers[event.handle]
try:
self.handleMessage(player, event.content)
except:
- print "Error handling message: %s\n%s" % (event, sys.exc_info())
+ print "Error handling message: %s\n%s" % \
+ (event, sys.exc_info())
else:
print "Message from unknown buddy?"
else:
@@ -263,18 +288,26 @@ class MazeGame:
def handleMessage(self, player, message):
"""Handle a message from a player on the mesh.
- We try to be forward compatible with new versions of Maze by allowing messages to
- have extra stuff at the end and ignoring unrecognized messages.
- We allow some messages to contain a different nick than the message's source player
- to support bonus players on that player's XO.
+ We try to be forward compatible with new versions of Maze by
+ allowing messages to have extra stuff at the end and ignoring
+ unrecognized messages.
+
+ We allow some messages to contain a different nick than the
+ message's source player to support bonus players on that
+ player's XO.
+
The valid messages are:
- maze:running_time,seed,width,height
+
+ maze: running_time, seed, width, height
A player has a differen maze.
- The one that has been running the longest will force all other players to use that maze.
+ The one that has been running the longest will force all other
+ players to use that maze.
This way new players will join the existing game properly.
- move:nick,x,y,dx,dy
- A player's at x,y is now moving in direction dx,dy
- finish:nick,elapsed
+
+ move: nick, x, y, dx, dy
+ A player's at x, y is now moving in direction dx, dy
+
+ finish: nick, elapsed
A player has finished the maze
"""
# ignore messages from myself
@@ -282,21 +315,23 @@ class MazeGame:
return
if message.startswith("move:"):
# a player has moved
- nick,x,y,dx,dy = message[5:].split(",")[:5]
+ nick, x, y, dx, dy = message[5:].split(",")[:5]
player = player.bonusPlayer(nick)
player.hidden = False
self.markPointDirty(player.position)
- player.position = (int(x),int(y))
- player.direction = (int(dx),int(dy))
+ player.position = (int(x), int(y))
+ player.direction = (int(dx), int(dy))
self.markPointDirty(player.position)
elif message.startswith("maze:"):
# someone has a different maze than us
- running_time,seed,width,height = map(lambda x: int(x), message[5:].split(",")[:4])
+ running_time, seed, width, height = map(lambda x: int(x),
+ message[5:].split(",")[:4])
# is that maze older than the one we're already playing?
# note that we use elapsed time instead of absolute time because
# people's clocks are often set to something totally wrong
if self.game_running_time() < running_time:
- # make note of the earlier time that the game really started (before we joined)
+ # make note of the earlier time that the game really
+ # started (before we joined)
self.game_start_time = time.time() - running_time
# use the new seed
self.maze = Maze(seed, width, height)
@@ -325,18 +360,19 @@ class MazeGame:
self.draw()
pygame.display.flip()
clock = pygame.time.Clock()
-
+
while self.running:
- a,b,c,d=pygame.cursors.load_xbm('my_cursor.xbm','my_cursor_mask.xbm')
- pygame.mouse.set_cursor(a,b,c,d)
+ a, b, c, d = pygame.cursors.load_xbm('my_cursor.xbm',
+ 'my_cursor_mask.xbm')
+ pygame.mouse.set_cursor(a, b, c, d)
self.frame += 1
# process all queued events
for event in pausescreen.get_events(sleep_timeout=30):
self.processEvent(event)
-
+
self.animate()
self.draw()
-
+
pygame.display.update()
# don't animate faster than about 20 frames per second
# this keeps the speed reasonable and limits cpu usage
@@ -345,36 +381,40 @@ class MazeGame:
def harder(self):
"""Make a new maze that is harder than the current one."""
# both width and height must be odd
- newHeight = self.maze.height+2
+ newHeight = self.maze.height + 2
newWidth = int(newHeight * self.aspectRatio)
if newWidth % 2 == 0:
newWidth -= 1
- self.maze = Maze(self.maze.seed+1, newWidth, newHeight)
+ self.maze = Maze(self.maze.seed + 1, newWidth, newHeight)
self.reset()
# tell everyone which maze we are playing, so they can sync up
- if len(self.remoteplayers)>0:
+ if len(self.remoteplayers) > 0:
# but fudge it a little so that we can be sure they'll use our maze
self.game_start_time -= 10
- mesh.broadcast("maze:%d,%d,%d,%d" % (self.game_running_time(), self.maze.seed, self.maze.width, self.maze.height))
-
+ mesh.broadcast("maze:%d,%d,%d,%d" % \
+ (self.game_running_time(), self.maze.seed,
+ self.maze.width, self.maze.height))
+
def easier(self):
"""Make a new maze that is easier than the current one."""
# both width and height must be odd
- newHeight = max(self.maze.height-2, 5)
+ newHeight = max(self.maze.height - 2, 5)
newWidth = int(newHeight * self.aspectRatio)
if newWidth % 2 == 0:
newWidth -= 1
- self.maze = Maze(self.maze.seed+1, newWidth, newHeight)
+ self.maze = Maze(self.maze.seed + 1, newWidth, newHeight)
self.reset()
# tell everyone which maze we are playing, so they can sync up
- if len(self.remoteplayers)>0:
+ if len(self.remoteplayers) > 0:
# but fudge it a little so that we can be sure they'll use our maze
self.game_start_time -= 10
- mesh.broadcast("maze:%d,%d,%d,%d" % (self.game_running_time(), self.maze.seed, self.maze.width, self.maze.height))
+ mesh.broadcast("maze:%d,%d,%d,%d" % \
+ (self.game_running_time(), self.maze.seed,
+ self.maze.width, self.maze.height))
def animate(self):
"""Animate one frame of action."""
-
+
for player in self.allplayers:
oldposition = player.position
newposition = player.animate(self.maze)
@@ -382,37 +422,45 @@ class MazeGame:
self.markPointDirty(oldposition)
self.markPointDirty(newposition)
if player in self.localplayers:
- self.maze.map[player.previous[0]][player.previous[1]] = self.maze.SEEN
- if self.maze.map[newposition[0]][newposition[1]] == self.maze.GOAL:
+ self.maze.map[player.previous[0]][player.previous[1]] = \
+ self.maze.SEEN
+ if self.maze.map[newposition[0]][newposition[1]] == \
+ self.maze.GOAL:
self.finish(player)
-
+
finish_delay = min(2 * len(self.allplayers), 6)
- if self.finish_time is not None and time.time() > self.finish_time+finish_delay:
+ if self.finish_time is not None and \
+ time.time() > self.finish_time + finish_delay:
self.harder()
-
+
def finish(self, player):
self.finish_time = time.time()
player.elapsed = self.finish_time - self.level_start_time
- if len(self.remoteplayers)>0:
+ if len(self.remoteplayers) > 0:
mesh.broadcast("finish:%s,%.2f" % (player.nick, player.elapsed))
-
+
def draw(self):
"""Draw the current state of the game.
This makes use of the dirty rectangle to reduce CPU load."""
- if self.dirtyRect is None and len(self.dirtyPoints)==0:
+ if self.dirtyRect is None and len(self.dirtyPoints) == 0:
return
-
+
# compute the size of the tiles given the screen size, etc.
size = self.screen.get_size()
- self.tileSize = min(size[0] / self.maze.width, size[1] / self.maze.height)
- self.bounds = pygame.Rect((size[0] - self.tileSize * self.maze.width)/2,
- (size[1] - self.tileSize * self.maze.height)/2,
+ self.tileSize = min(size[0] / self.maze.width,
+ size[1] / self.maze.height)
+ self.bounds = pygame.Rect((size[0] - self.tileSize *
+ self.maze.width) / 2,
+ (size[1] - self.tileSize *
+ self.maze.height) / 2,
self.tileSize * self.maze.width,
self.tileSize * self.maze.height)
- self.outline = int(self.tileSize/5)
+ self.outline = int(self.tileSize / 5)
- def drawPoint(x,y):
- rect = pygame.Rect(self.bounds.x + x*self.tileSize, self.bounds.y + y*self.tileSize, self.tileSize, self.tileSize)
+ def drawPoint(x, y):
+ rect = pygame.Rect(self.bounds.x + x * self.tileSize,
+ self.bounds.y + y * self.tileSize,
+ self.tileSize, self.tileSize)
tile = self.maze.map[x][y]
if tile == self.maze.EMPTY:
pygame.draw.rect(self.screen, self.EMPTY_COLOR, rect, 0)
@@ -420,13 +468,13 @@ class MazeGame:
pygame.draw.rect(self.screen, self.SOLID_COLOR, rect, 0)
elif tile == self.maze.SEEN:
pygame.draw.rect(self.screen, self.EMPTY_COLOR, rect, 0)
- dot = rect.inflate(-self.outline*2, -self.outline*2)
+ dot = rect.inflate(-self.outline * 2, -self.outline * 2)
pygame.draw.ellipse(self.screen, self.TRAIL_COLOR, dot, 0)
elif tile == self.maze.GOAL:
pygame.draw.rect(self.screen, self.GOAL_COLOR, rect, 0)
else:
pygame.draw.rect(self.screen, (0xff, 0x00, 0xff), rect, 0)
-
+
# re-draw the dirty rectangle
if self.dirtyRect is not None:
# compute the area that needs to be redrawn
@@ -434,42 +482,44 @@ class MazeGame:
right = min(self.maze.width, self.dirtyRect.right)
top = max(0, self.dirtyRect.top)
bottom = min(self.maze.height, self.dirtyRect.bottom)
-
+
# loop over the dirty rect and draw
for x in range(left, right):
for y in range(top, bottom):
- drawPoint(x,y)
-
+ drawPoint(x, y)
+
# re-draw the dirty points
- for x,y in self.dirtyPoints:
- drawPoint(x,y)
-
+ for x, y in self.dirtyPoints:
+ drawPoint(x, y)
+
# draw all players
for player in self.allplayers:
if not player.hidden:
player.draw(self.screen, self.bounds, self.tileSize)
# draw the elapsed time for each player that has finished
- finishedPlayers = filter(lambda p: p.elapsed is not None, self.allplayers)
- finishedPlayers.sort(lambda a,b: cmp(a.elapsed,b.elapsed))
+ finishedPlayers = filter(lambda p: p.elapsed is not None,
+ self.allplayers)
+ finishedPlayers.sort(lambda a, b: cmp(a.elapsed, b.elapsed))
y = 0
for player in finishedPlayers:
fg, bg = player.colors
text = "%3.2f - %s" % (player.elapsed, player.nick)
textimg = self.font.render(text, 1, fg)
textwidth, textheight = self.font.size(text)
- rect = pygame.Rect(8, y+4, textwidth, textheight)
- bigrect = rect.inflate(16,8)
+ rect = pygame.Rect(8, y + 4, textwidth, textheight)
+ bigrect = rect.inflate(16, 8)
pygame.draw.rect(self.screen, bg, bigrect, 0)
pygame.draw.rect(self.screen, fg, bigrect, 2)
self.screen.blit(textimg, rect)
-
+
y += bigrect.height + 4
# clear the dirty rect so nothing will be drawn until there is a change
self.dirtyRect = None
self.dirtyPoints = []
+
def main():
"""Run a game of Maze."""
#canvas_size = 1024,768-75
@@ -489,4 +539,3 @@ def main():
if __name__ == '__main__':
main()
-
--
1.7.9.1
More information about the Sugar-devel
mailing list