[Sugar-devel] [PATCH] pep8 syntax fixed

[Manuel Kaufmann]

 - Removed a lot of trailing spaces
 - Add spaces to both sides of operators
---
 maze.py |   59 +++++++++++++++++++++++++++++++----------------------------
 1 files changed, 31 insertions(+), 28 deletions(-)

diff --git a/maze.py b/maze.py
index 8fec99c..f8737cf 100644
--- a/maze.py
+++ b/maze.py
@@ -6,29 +6,30 @@
 #
 # 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 random
 from pygame import Rect
 
+
 class Maze:
     SOLID = 0
     EMPTY = 1
     SEEN = 2
     GOAL = 3
-    
+
     def __init__(self, seed, width, height):
         # use the seed given to us to make a pseudo-random number generator
         # we will use that to generate the maze, so that other players can
@@ -38,31 +39,31 @@ class Maze:
         self.generator = random.Random(seed)
         self.width, self.height = width, height
         self.map = []
-        self.bounds = Rect(0,0,width,height)
+        self.bounds = Rect(0, 0, width, height)
 
         for x in range(0, width):
             self.map.append([self.SOLID] * self.height)
 
-        startx = self.generator.randrange(1,width,2)
-        starty = self.generator.randrange(1,height,2)
-        self.dig(startx,starty)
+        startx = self.generator.randrange(1, width, 2)
+        starty = self.generator.randrange(1, height, 2)
+        self.dig(startx, starty)
 
     def validMove(self, x, y):
-        return self.bounds.collidepoint(x,y) and self.map[x][y]!=self.SOLID
+        return self.bounds.collidepoint(x, y) and self.map[x][y] != self.SOLID
 
     def validDig(self, x, y):
-        return self.bounds.collidepoint(x,y) and self.map[x][y]==self.SOLID
-  
+        return self.bounds.collidepoint(x, y) and self.map[x][y] == self.SOLID
+
     def validDigDirections(self, x, y):
         directions = []
-        if self.validDig(x,y-2):
-            directions.append((0,-1))
-        if self.validDig(x+2,y):
-            directions.append((1,0))
-        if self.validDig(x,y+2):
-            directions.append((0,1))
-        if self.validDig(x-2,y):
-            directions.append((-1,0))
+        if self.validDig(x, y - 2):
+            directions.append((0, -1))
+        if self.validDig(x + 2, y):
+            directions.append((1, 0))
+        if self.validDig(x, y + 2):
+            directions.append((0, 1))
+        if self.validDig(x - 2, y):
+            directions.append((-1, 0))
         return directions
 
     def fill(self, color):
@@ -71,24 +72,26 @@ class Maze:
                 self.map[x][y] = color
 
     def digRecursively(self, x, y):
-        """This works great, except for python's lame limit on recursion depth."""
+        """This works great, except for python's lame limit on
+        recursion depth."""
+
         self.map[x][y] = self.EMPTY
-        directions = self.validDigDirections(x,y)
+        directions = self.validDigDirections(x, y)
         while len(directions) > 0:
             direction = self.generator.choice(directions)
-            self.map[x+direction[0]][y+direction[1]] = self.EMPTY
-            self.dig(x+direction[0]*2, y+direction[1]*2)
-            directions = self.validDigDirections(x,y)
+            self.map[x + direction[0]][y + direction[1]] = self.EMPTY
+            self.dig(x + direction[0] * 2, y + direction[1] * 2)
+            directions = self.validDigDirections(x, y)
 
     def dig(self, x, y):
-        stack = [(x,y)]
+        stack = [(x, y)]
         while len(stack) > 0:
             x, y = stack[-1]
             self.map[x][y] = self.EMPTY
-            directions = self.validDigDirections(x,y)
+            directions = self.validDigDirections(x, y)
             if len(directions) > 0:
                 direction = self.generator.choice(directions)
-                self.map[x+direction[0]][y+direction[1]] = self.EMPTY
-                stack.append((x+direction[0]*2, y+direction[1]*2))
+                self.map[x + direction[0]][y + direction[1]] = self.EMPTY
+                stack.append((x + direction[0] * 2, y + direction[1] * 2))
             else:
                 stack.pop()
-- 
1.7.9.1