Renamed variables and inserted whitespaces, to increase readability.

7 files changed, 88 insertions, 90 deletions

diff --git a/Gambiarra/command.py b/Gambiarra/command.py
index 694f251..4508d6c 100644
--- a/Gambiarra/command.py
+++ b/Gambiarra/command.py
@@ -32,7 +32,7 @@ class Command(pygame.sprite.Sprite):
     def draw(self, screen, pos):
         # temos a imagem na variavel <img> e
         # o 'zero' (ponto onde deve ser desenhado <pos>
-        screen.blit(self.image, (pos[0],pos[1]))
+        screen.blit(self.image, (pos[0], pos[1]))
 
 class Play(Command):
     def __init__(self):
diff --git a/Gambiarra/gambiarra.py b/Gambiarra/gambiarra.py
index acbbc31..31ec76d 100644
--- a/Gambiarra/gambiarra.py
+++ b/Gambiarra/gambiarra.py
@@ -51,14 +51,14 @@ class Game(object):
     screen = None
     menu = None
     congrats = None
-    congratsSnd = None
+    congrats_snd = None
 
     def __init__(self, play_sounds=True):
         pygame.init()
         self.play_sounds = play_sounds
         if self.play_sounds:
             pygame.mixer.init()
-        self.screen = pygame.display.set_mode((1200,900)) #omitindo flags
+        self.screen = pygame.display.set_mode((1200, 900)) #omitindo flags
         pygame.display.flip()
         self.running = True
         self.playing = False
@@ -87,7 +87,7 @@ class Game(object):
 
             # executa a simulacao
             objs = check_collision(self.levels[self.level].simulator.objects,
-                                self.levels[self.level].simulator.staticObjs)
+                                self.levels[self.level].simulator.static_objs)
             self.levels[self.level].simulator.objects = objs
             for obj in self.levels[self.level].simulator.objects:
                 obj.update()
@@ -96,35 +96,31 @@ class Game(object):
                 if self.selected_element.editable:
                     self.selected_element.rect.center = pygame.mouse.get_pos()
 
-    def mouse_event(self, mousePos):
+    def mouse_event(self, mouse_pos):
         if not self.selected_element:
-            collided = False
-            mouseMove = (0,0)
-            mouseMove = pygame.mouse.get_rel()
+            mouse_move = (0, 0)
+            mouse_move = pygame.mouse.get_rel()
 
             for element in self.levels[self.level].simulator.objects:
-                if element.rect.collidepoint(mousePos):
-                    collided = True
+                if element.rect.collidepoint(mouse_pos):
                     self.selected_element = element
                     break
 
             if not self.selected_element:
-                for element in self.levels[self.level].simulator.staticObjs:
-                    if element.rect.collidepoint(mousePos):
-                        collided = True
+                for element in self.levels[self.level].simulator.static_objs:
+                    if element.rect.collidepoint(mouse_pos):
                         self.selected_element = element
 
-                        if isinstance(element,Esteira) and element.editable:
+                        if isinstance(element, Esteira) and element.editable:
                             self.count += 1
                         if self.count == 1:
-                            element.sentido=-element.sentido
+                            element.sentido = -element.sentido
                             self.count = 0
                         break
 
             if not self.selected_element: #se nao encontrou no for anterior
                 for element in self.levels[self.level].objbar.objects:
-                    if element.rect.collidepoint(mousePos):
-                        collided = True
+                    if element.rect.collidepoint(mouse_pos):
                         element.remove(self.levels[self.level].objbar.objects)
                         self.levels[self.level].simulator.add(element)
                         self.selected_element = element
@@ -132,15 +128,16 @@ class Game(object):
 
             if not self.selected_element: #se nao encontrou no for anterior
                 for element in self.levels[self.level].cmdbar.commands:
-                    if element.rect.collidepoint(mousePos):
+                    if element.rect.collidepoint(mouse_pos):
                         if isinstance(element, Play):
                             element.image = pygame.transform.flip(element.image,
                                                                   True, False)
                             self.playing = not self.playing
                             if not self.playing:
-                                for element in self.levels[self.level].simulator.objects:
-                                    element.speed = [0,0]
-                                    element.rect.topleft = element.initialPosition
+                                objs = self.levels[self.level].simulator.objects
+                                for obj in objs:
+                                    obj.speed = [0, 0]
+                                    obj.rect.topleft = obj.initial_pos
                         elif isinstance(element, Help):
                             self.levels[self.level].show_help(self.screen)
                         elif isinstance(element, Quit):
@@ -149,18 +146,18 @@ class Game(object):
 
         else:
             if self.selected_element.editable and not self.playing:
-                mouseMove = pygame.mouse.get_rel()
-                if mouseMove != (0,0):
+                mouse_move = pygame.mouse.get_rel()
+                if mouse_move != (0, 0):
                     self.count -= 1
                 self.selected_element.rect.center = pygame.mouse.get_pos()
-                #self.selected_element.rect = self.selected_element.rect.move(mouseMove)
-                self.selected_element.initialPosition = self.selected_element.rect.topleft
+                new_pos = self.selected_element.rect.topleft
+                self.selected_element.initial_pos = new_pos
             self.selected_element = None
 
     def show_congratulations(self):
         if self.play_sounds:
             pygame.mixer.stop()
-            self.congratsSnd.play()
+            self.congrats_snd.play()
 
         self.screen.blit(self.congrats, (600 - self.congrats.get_width()/2,
                                          450 - self.congrats.get_height()/2) )
diff --git a/Gambiarra/gamemenu.py b/Gambiarra/gamemenu.py
index 744f3cf..3488af2 100644
--- a/Gambiarra/gamemenu.py
+++ b/Gambiarra/gamemenu.py
@@ -40,7 +40,7 @@ class GameMenu(object):
         self.start = StartButton(520)
 
     def run(self):
-        self.screen.blit(self.background, (0,0))
+        self.screen.blit(self.background, (0, 0))
 #        self.level.draw(self.screen)
         self.start.draw(self.screen)
         pygame.display.flip()
@@ -65,15 +65,16 @@ class GameMenu(object):
 #                    self.level.clicked = False
 
     def event_handler(self):
-        validEventFound = False
         while True:
             for event in pygame.event.get():
-                if event.type == MOUSEMOTION:
-                    if self.start.current_img.get_rect(topleft = self.start.position).collidepoint(pygame.mouse.get_pos()):
+                if event.type == pygame.MOUSEMOTION:
+                    img = self.start.current_img
+                    rect = img.get_rect(topleft = self.start.position)
+                    if rect.collidepoint(pygame.mouse.get_pos()):
                         if self.start.current == 0 :
 #                            if self.level.current == 1:
 #                                self.level.current = 0
-#                                self.level.current_img = self.level.img[self.level.current]
+#                                self.level.current_img = self.level.img[0]
                             self.start.current = 1
                             self.start.current_img = self.start.img[self.start.current]
                             return MOUSEMOTION
@@ -115,21 +116,21 @@ class LevelButton(object):
     level = None
     current = None
     current_img = None
-    numberOfLevels = None
+    levels_number = None
     current_level_img = None
     clicked = None
 
-    def __init__(self, position, numberOfLevels = 1):
-        nonHover = pygame.image.load(
-                          abspath("data/images/nivel_normal.png") )
-        hover = pygame.image.load(
-                           abspath("data/images/nivel_hover.png") )
-        self.img = [nonHover,hover]
-        self.position = [600 - nonHover.get_width()/2, position]
+    def __init__(self, position, levels_number = 1):
+        img = abspath("data/images/nivel_normal.png")
+        non_hover = pygame.image.load(img)
+        img = abspath("data/images/nivel_hover.png")
+        hover = pygame.image.load(img)
+        self.img = [non_hover, hover]
+        self.position = [600 - non_hover.get_width()/2, position]
         self.level = 0
         self.current = 0
         self.current_img = self.img[self.current]
-        self.numberOfLevels = numberOfLevels
+        self.levels_number = levels_number
         self.current_level_img = None # Precisa 'renderizar' o numero do nivel
         self.clicked = False
 
@@ -139,7 +140,7 @@ class LevelButton(object):
     def click(self):
         self.clicked = True
         self.level += 1
-        if self.level == self.numberOfLevels :
+        if self.level == self.levels_number :
             self.level = 0
 
 class StartButton(object):
@@ -150,12 +151,12 @@ class StartButton(object):
     clicked = None
 
     def __init__(self, position):
-        nonHover=pygame.image.load(
-                        abspath("data/images/iniciar_normal.png") )
-        hover = pygame.image.load(
-                         abspath("data/images/iniciar_hover.png") )
-        self.img = [nonHover,hover]
-        self.position = [600 - nonHover.get_width()/2 - 50, position]
+        img = abspath("data/images/iniciar_normal.png")
+        non_hover = pygame.image.load(img)
+        img = abspath("data/images/iniciar_hover.png")
+        hover = pygame.image.load(img)
+        self.img = [non_hover, hover]
+        self.position = [600 - non_hover.get_width()/2 - 50, position]
         self.current = 0
         self.current_img = self.img[self.current]
         self.clicked = False
diff --git a/Gambiarra/levels.py b/Gambiarra/levels.py
index 1fbc7d4..72a4951 100644
--- a/Gambiarra/levels.py
+++ b/Gambiarra/levels.py
@@ -39,20 +39,20 @@ class SimulationView(object):
     def __init__(self, objects):
         self.running = False
         self.background = pygame.Surface((1200, 770))
-        self.background.fill([99,157,237])
+        self.background.fill([99, 157, 237])
         self.objects = pygame.sprite.RenderPlain()
-        self.staticObjs = []
+        self.static_objs = []
 
         for obj in objects.values():
             if obj.mobility:
                 obj.add(self.objects)
             else:
-                self.staticObjs.append(obj)
+                self.static_objs.append(obj)
 
-        self.staticObjs.append(LeftWall())
-        self.staticObjs.append(RightWall())
-        self.staticObjs.append(UpWall())
-        self.staticObjs.append(DownWall())
+        self.static_objs.append(LeftWall())
+        self.static_objs.append(RightWall())
+        self.static_objs.append(UpWall())
+        self.static_objs.append(DownWall())
 
     def draw(self, pos = None):
         screen = pygame.display.get_surface()
@@ -61,7 +61,7 @@ class SimulationView(object):
         else:
             screen.blit(self.background, (0, 0))
 
-        for obj in self.staticObjs:
+        for obj in self.static_objs:
             obj.draw(screen, obj.rect)
 
         for item in self.objects:
@@ -71,14 +71,14 @@ class SimulationView(object):
         if obj.mobility:
             obj.add(self.objects)
         else:
-            self.staticObjs.append(obj)
+            self.static_objs.append(obj)
 
 class ObjectBar(object):
     """ This widget contains the objects available for the problem. """
 
     def __init__(self, objects):
         self.background = pygame.Surface((1000, 130))
-        self.background.fill([0,255,0])   #TODO: achar uma cor melhor =D
+        self.background.fill([0, 255, 0])
         self.objects = pygame.sprite.RenderPlain(objects.values())
 
     def draw(self, pos = None):
@@ -103,7 +103,7 @@ class CommandBar(object):
     def __init__(self):
         self.background = pygame.Surface((200, 130))
         self.width, self.height = self.background.get_size()
-        self.background.fill([0,0,255])   #TODO: achar uma cor melhor =D
+        self.background.fill([0, 0, 255])
         self.commands = [ Play(), Help(), Quit() ]
 
     def draw(self, pos=None):
@@ -127,12 +127,12 @@ class Level(object):
     on the screen"""
     objects = None
 
-    def __init__(self, objInPlace, objToAdd, goals, helpImage):
-        self.simulator = SimulationView(objInPlace)
-        self.objbar = ObjectBar(objToAdd)
+    def __init__(self, obj_in_place, obj_to_add, goals, help_img):
+        self.simulator = SimulationView(obj_in_place)
+        self.objbar = ObjectBar(obj_to_add)
         self.cmdbar = CommandBar()
         self.goals = goals
-        self.helpImage = helpImage
+        self.help_img = help_img
 
     def goal_reached(self):
         for obj, goal in self.goals:
@@ -146,8 +146,8 @@ class Level(object):
         self.cmdbar.draw()
 
     def show_help(self, screen):
-        screen.blit(self.helpImage, (600 - self.helpImage.get_width()/2,
-                                     450 - self.helpImage.get_height()/2) )
+        screen.blit(self.help_img, (600 - self.help_img.get_width()/2,
+                                    450 - self.help_img.get_height()/2) )
         pygame.display.flip()
         while True:
             for event in pygame.event.get():
@@ -162,12 +162,12 @@ def load_levels():
     files = os.listdir(level_dir)
     levels = []
     for level_file in sorted(f for f in files if f.split(".")[-1] == "level"):
-        fp = open(os.path.join(level_dir, level_file))
+        raw = open(os.path.join(level_dir, level_file))
         try:
-            level = json.load(fp)
-        except ValueError, e:
-            print level_file, "-> invalid json file: ", e
-            fp.close()
+            level = json.load(raw)
+        except ValueError, error:
+            print level_file, "-> invalid json file: ", error
+            raw.close()
         else:
             lvl = load_level(level, level_dir, level_file)
             if lvl:
@@ -180,24 +180,24 @@ def load_level(level, level_dir, level_name):
     for obj in level["placed"]:
         try:
             klass = globals()[obj["type"]]
-        except KeyError, e:
-            print level_name, "-> Invalid type for object:", e
+        except KeyError, error:
+            print level_name, "-> Invalid type for object:", error
             return None
 
-        o = klass( ( int(obj["xpos"]), int(obj["ypos"]) ), editable=False)
-        objs[obj["name"]] = o
+        new = klass( ( int(obj["xpos"]), int(obj["ypos"]) ), editable=False)
+        objs[obj["name"]] = new
 
     toadd = {}
     for obj in level["available"]:
         try:
             klass = globals()[obj["type"]]
-        except KeyError, e:
-            print level_name, "-> Invalid type for object:", e
+        except KeyError, error:
+            print level_name, "-> Invalid type for object:", error
             return None
 
         try:
             toadd[obj["name"]] = klass()
-        except KeyError, e:
+        except KeyError:
             print level_name, "-> Object name not available"
             return None
 
@@ -205,11 +205,11 @@ def load_level(level, level_dir, level_name):
     for goal in level["goals"]:
         try:
             proj = objs[ goal[0] ]
-            target = objs[ goal[1] ]
-        except KeyError:
-            print level_name, "-> Object not available:", e
+            trg = objs[ goal[1] ]
+        except KeyError, error:
+            print level_name, "-> Object not available:", error
             return None
-        goals.append( (proj, target) )
+        goals.append( (proj, trg) )
 
     img_file = os.path.join(level_dir, level['help'])
     if os.path.isfile(img_file):
diff --git a/Gambiarra/objects/animals.py b/Gambiarra/objects/animals.py
index b22f146..8ce1d41 100644
--- a/Gambiarra/objects/animals.py
+++ b/Gambiarra/objects/animals.py
@@ -34,4 +34,4 @@ class Penguin(Thing):
              editable, snd,
              initial_pos, elasticity = 100, mobility = True,
              gravity = 5)
-        self.speed=[5,0]
+        self.speed = [5, 0]
diff --git a/Gambiarra/objects/esteira.py b/Gambiarra/objects/esteira.py
index cb2812c..02a3316 100644
--- a/Gambiarra/objects/esteira.py
+++ b/Gambiarra/objects/esteira.py
@@ -41,9 +41,9 @@ class Esteira(Thing):
         # temos a imagem na variavel <img> e
         # o 'zero' (ponto onde deve ser desenhado <pos>
         if self.sentido == 1:
-            screen.blit(self.image_dir, (pos[0],pos[1]))
+            screen.blit(self.image_dir, (pos[0], pos[1]))
         elif self.sentido == -1:
-            screen.blit(self.image_esq, (pos[0],pos[1]))
+            screen.blit(self.image_esq, (pos[0], pos[1]))
 
     def collide(self, obj):
         if obj.rect.colliderect(self.rect):
diff --git a/Gambiarra/objects/things.py b/Gambiarra/objects/things.py
index f39ba36..7d8ac79 100644
--- a/Gambiarra/objects/things.py
+++ b/Gambiarra/objects/things.py
@@ -63,7 +63,7 @@ class Thing(pygame.sprite.Sprite):
             self.rect.topleft = initial_pos[0], initial_pos[1]
         self.elasticity = elasticity
         self.editable = editable
-        self.speed = [0,0]
+        self.speed = [0, 0]
         self.mobility = mobility
         self.gravity = gravity
         self.snd = snd
@@ -71,7 +71,7 @@ class Thing(pygame.sprite.Sprite):
     def draw(self, screen, pos ):
         # temos a imagem na variavel <img> e
         # o 'zero' (ponto onde deve ser desenhado <pos>
-        screen.blit(self.image, (pos[0],pos[1]))
+        screen.blit(self.image, (pos[0], pos[1]))
 
     def play(self):
         if self.snd and pygame.mixer.get_init():
@@ -80,7 +80,7 @@ class Thing(pygame.sprite.Sprite):
     def collide(self, obj):
         ''' Very basic implementation of elastic collision'''
         #TODO: verify mobility attribute
-        hitbox = self.rect.inflate(5,5)
+        hitbox = self.rect.inflate(5, 5)
         if hitbox.colliderect(obj.rect):
             if self.rect.left < obj.rect.right:
                 self.speed[0], obj.speed[0] = obj.speed[0], self.speed[0]
@@ -99,7 +99,7 @@ class Thing(pygame.sprite.Sprite):
 
     def update(self):
         if self.mobility:
-            newpos = self.rect.move((self.speed[0],self.speed[1]))
+            newpos = self.rect.move((self.speed[0], self.speed[1]))
             self.rect = newpos
             self.speed[0] *= 0.99
             if self.speed[1] <= self.rect[3]*0.04 and self.speed[1] > 0:
@@ -118,10 +118,10 @@ def check_collision(sprite_list, wall_list):
 #                obj.play()
 #                s.play()
 
-        for w in wall_list:
-            if w.collide(obj):
+        for wall in wall_list:
+            if wall.collide(obj):
                 obj.play()
-                w.play()
+                wall.play()
 
     return new_objects