pocket_friends/game_files/elements/__init__.py

@@ -1 +0,0 @@
-"""Sub-module for use in the game. Helps with the drawing of various objects such as sprites and text boxes."""

pocket_friends/game_files/io/data.py

@@ -4,11 +4,9 @@ import json
 
 class SaveData:
     """
-    Class used to read and write save data for the game
-
-    Attributes:
-        attributes (dict): Dictionary containing all the attributes to read and write from a save file.
+    Class that represents the save data of the game.
     """
+
     def __init__(self):
         """
         Constructs the object with all starting values.

pocket_friends/game_files/io/fake_gpio.py

@@ -1,6 +1,6 @@
 """
-Dummy module that contains empty functions and variables that exist in RPi.GPIO. This module is to be imported
-if importing RPi.GPIO fails.
+Module used to fake the RPi.GPIO module so that
+the program can be run without the actual hardware.
 """
 
 # Constants used by RPi.GPIO
@@ -12,11 +12,7 @@ FALLING = 0
 def setmode(new_mode):
     """
     Fake setmode function.
-    Args:
-        new_mode:
-
-    Returns:
-
+    :param new_mode:
     """
     pass
 
@@ -24,14 +20,10 @@ def setmode(new_mode):
 def setup(channel, mode, initial=None, pull_up_down=None):
     """
     Fake setup function.
-    Args:
-        channel:
-        mode:
-        initial:
-        pull_up_down:
-
-    Returns:
-
+    :param channel:
+    :param mode:
+    :param initial:
+    :param pull_up_down:
     """
     pass
 
@@ -39,14 +31,10 @@ def setup(channel, mode, initial=None, pull_up_down=None):
 def add_event_detect(channel, edge_type, callback=None, bouncetime=0):
     """
     Fake function to add a non-existent event detect.
-    Args:
-        channel:
-        edge_type:
-        callback:
-        bouncetime:
-
-    Returns:
-
+    :param channel:
+    :param edge_type:
+    :param callback:
+    :param bouncetime:
     """
     pass
 
@@ -54,11 +42,8 @@ def add_event_detect(channel, edge_type, callback=None, bouncetime=0):
 def event_detected(channel):
     """
     Fake function to detect an event. Always returns false.
-    Args:
-        channel:
-
-    Returns:
-
+    :param channel:
+    :return:
     """
     return False
 
@@ -66,10 +51,6 @@ def event_detected(channel):
 def cleanup(channel=None):
     """
     Fake cleanup function.
-    Args:
-        channel:
-
-    Returns:
-
+    :param channel:
     """
     pass

pocket_friends/game_files/io/gpio_handler.py

@@ -1,19 +1,15 @@
-"""Handle inputs from the GPIO pins on the Raspberry Pi and converting them to events to be used in other places (
-pygame, etc.)"""
+"""
+Handle inputs from the GPIO pins on the Raspberry Pi and converting them to events to be used in other places (pygame, etc.)
+"""
 import importlib.util
 
 # If the RPi.GPIO module is not found (aka the program is not running on a Pi), import the fake
 # GPIO module instead to prevent a crash.
-
-ON_HARDWARE = None  # Flag to tell other methods if the program is running on hardware or not
-
 try:
     importlib.util.find_spec('RPi.GPIO')
     import RPi.GPIO as GPIO
-    ON_HARDWARE = True
 except ImportError:
     import pocket_friends.game_files.io.fake_gpio as GPIO
-    ON_HARDWARE = False
 
 # Dictionary of all the buttons used and what their corresponding GPIO codes are
 BUTTONS = {
@@ -28,7 +24,9 @@ BUTTONS = {
 
 
 def setup():
-    """Prime the GPIO pins for reading the inputs of the buttons."""
+    """
+    Primes the GPIO pins for reading the inputs of the buttons.
+    """
     GPIO.setmode(GPIO.BOARD)
 
     GPIO.setup(BUTTONS.get('a'), GPIO.IN)
@@ -49,17 +47,16 @@ def setup():
 
 
 def teardown():
-    """Clean up the GPIO handler."""
+    """
+    Cleans up the GPIO handler.
+    """
     GPIO.cleanup()
 
 
 def get_press(button):
     """
-    Checks if a given button code has been pressed and returns a bool depending on the state.
-    Args:
-        button:  button to be detected
-
-    Returns: True if the button is has been pressed, False otherwise
-
+    Returns true if a button has changed from not pressed to pressed.
+    :param button: button to be detected
+    :return: True if the button is has been pressed, False otherwise
     """
     return GPIO.event_detected(button)

pocket_friends/game_files/io/input_handler.py

@@ -1,4 +1,5 @@
 import pygame
+import importlib.util
 import pocket_friends.game_files.io.gpio_handler as gpio_handler
 
 
@@ -6,40 +7,36 @@ class InputHandler:
     """
     Class that is implemented into surfaces in order to control the
     pressing of buttons on both the real hardware and on a keyboard.
-
-    Attributes:
-        clock (pygame.time.Clock): Pygame clock used for input time calculations.
-        last_input_tick (int): The tick that the last input was registered on.
-
     """
 
     def __init__(self, pygame_clock):
-        """
-        Create a InputHandler object using a given Pygame clock.
-
-        Args:
-            pygame_clock (pygame.time.Clock): A pygame clock to use as the clock for input time calculations.
-
-        """
         self.clock = pygame_clock
+
+        # If not on actual hardware, fake the GPIO in order to get it working correctly.
+        try:
+            importlib.util.find_spec('RPi.GPIO')
+            import RPi.GPIO as GPIO
+            self.on_hardware = True
+        except ImportError:
+            import pocket_friends.game_files.io.fake_gpio as GPIO
+            self.on_hardware = False
+
         self.last_input_tick = 0
 
     def create_event(self, pressed_button):
         """
-        Create a pygame event given a GPIO code and post it to the pygame event handler.
-        Args:
-            pressed_button (int): The GPIO code to be registered and pressed.
-
+        Creates a pygame event with a given keyboard code
+        :param pressed_button:
         """
         # Register a button click so long as the last button click happened no less than two frames ago
-        if pygame.time.get_ticks() - self.last_input_tick > self.clock.get_time() * 2 or not gpio_handler.ON_HARDWARE:
+        if pygame.time.get_ticks() - self.last_input_tick > self.clock.get_time() * 2 or not self.on_hardware:
             pygame.event.post(pygame.event.Event(pygame.KEYDOWN, {'key': pressed_button}))
             pygame.event.post(pygame.event.Event(pygame.KEYUP, {'key': pressed_button}))
         self.last_input_tick = pygame.time.get_ticks()
 
     def handle_gpio(self):
         """
-        Handle GPIO events and create events for them.
+        Handles getting GPIO button presses and making a pygame event when a press is detected.
         """
         for pressed_button in gpio_handler.BUTTONS:
             code = gpio_handler.BUTTONS.get(pressed_button)
@@ -48,8 +45,10 @@ class InputHandler:
             if gpio_handler.get_press(code):
                 self.create_event(code)
 
-    def handle_keyboard(self):
-        """Handle keyboard presses and generate corresponding GPIO codes to create events."""
+    def keyboard_handler(self):
+        """
+        Simulates key presses to GPIO button presses. Also handles quitting the game.
+        """
 
         # Checks if a corresponding keyboard key has been pressed. If it has, emulate a button press.
         for keyboard_event in pygame.event.get():
@@ -74,8 +73,10 @@ class InputHandler:
                     running = False
 
     def update(self):
-        """Run either the GPIO handler or the keyboard handler to check for input and create events."""
-        if gpio_handler.ON_HARDWARE:
+        """
+        Run the input handler and check for inputs.
+        """
+        if self.on_hardware:
             self.handle_gpio()
         else:
-            self.handle_keyboard()
+            self.keyboard_handler()

pocket_friends/game_files/surfaces/egg_select.py

@@ -1,5 +1,5 @@
 import pygame
-from ..elements import sprites
+from . import sprites
 import pocket_friends.game_files.io.gpio_handler as gpio_handler
 from ..io.input_handler import InputHandler
 

pocket_friends/game_files/surfaces/selection_info.py

@@ -1,22 +1,12 @@
 import pygame
-from ..elements import sprites
+from . import sprites
 import pocket_friends.game_files.io.gpio_handler as gpio_handler
+from .sprites import SelectionEgg
 from ..io.input_handler import InputHandler
 
 
 class Surface(pygame.Surface):
-    """
-
-    """
     def __init__(self, window_size, resources_dir, game_fps, **kwargs):
-        """
-
-        Args:
-            window_size:
-            resources_dir:
-            game_fps:
-            **kwargs:
-        """
         super().__init__(window_size, pygame.SRCALPHA)
         self.name = 'selection_info'
         self.running = True

pocket_friends/game_files/surfaces/sprites.py

@@ -4,78 +4,53 @@ import json
 
 class SpriteSheet:
     """
-    Class to be used by sprites in order to give them a texture and an animation.
-
-    Attributes:
-        images (list) List of all the sprites in the animation separated from the sprite sheet.
+    Imports a sprite sheet as separate pygame images given an image file and a json file.
     """
 
     def __init__(self, sprite_sheet, texture_json):
-        """
-        Creates a sprite sheet given a sprite image and its corresponding JSON file.
-        Args:
-            sprite_sheet (str): The path of the sprite sheet image component.
-            texture_json (str): The path of the sprite sheet JSON component, contains the number of frames in the
-                sprite sheet, and the width and height of an individual sprite from the sprite sheet.
-        """
         # Load in whole sprite sheet as one image.
-        sprite_sheet = pygame.image.load(sprite_sheet).convert_alpha()
+        self.sprite_sheet = pygame.image.load(sprite_sheet).convert_alpha()
         self.images = []
-        print(type(self.images))
 
         # Get the sprite sheet json file.
         with open(texture_json, 'r') as json_file:
-            img_attrib = json.load(json_file)
+            self.img_attrib = json.load(json_file)
             json_file.close()
 
         # Count for how many images have been added in the image list
         image_count = 0
 
         # Get the sprite size as a tuple
-        sprite_size = img_attrib['width'], img_attrib['height']
+        sprite_size = self.img_attrib['width'], self.img_attrib['height']
 
         # Iterate through every image location on the sprite sheet given the sprite size
-        for i in range(sprite_sheet.get_size()[1] // sprite_size[1]):
+        for i in range(self.sprite_sheet.get_size()[1] // sprite_size[1]):
             i *= sprite_size[1]
-            for j in range(sprite_sheet.get_size()[0] // sprite_size[0]):
+            for j in range(self.sprite_sheet.get_size()[0] // sprite_size[0]):
                 j *= sprite_size[0]
 
                 # Create a new transparent surface
                 sprite = pygame.Surface(sprite_size, pygame.SRCALPHA)
                 # Blit the sprite onto the image
-                sprite.blit(sprite_sheet, (0, 0), (j, i, sprite_size[0], sprite_size[1]))
+                sprite.blit(self.sprite_sheet, (0, 0), (j, i, sprite_size[0], sprite_size[1]))
                 # Add the image to the list of images
                 self.images.append(sprite)
 
                 image_count += 1
 
                 # Break the loop if the specified number of frames has been reached.
-                if image_count >= img_attrib['frames']:
+                if image_count >= self.img_attrib['frames']:
                     break
-            if image_count >= img_attrib['frames']:
+            if image_count >= self.img_attrib['frames']:
                 break
 
 
 class SelectionEgg(pygame.sprite.Sprite):
     """
-    Sprite to render the egg on the egg selection screen.
-
-    Attributes:
-        egg_color (str): The color of the egg (also its name).
-        description (str): The description of the egg to be displayed when selected.
-        contentedness (int): How likely the egg is to stay happy, ranges from 0-5.
-        metabolism (int): How quickly the egg will get hungry, ranges from 0-5.
-        rect (pygame.Rect): Pygame rectangle used to position the egg on screen.
-
+    Class for the eggs on the egg selection screen.
     """
 
     def __init__(self, egg_color, resources_dir):
-        """
-        Creates a SelectionEgg object given an egg color and a resource location.
-        Args:
-            egg_color (str): The color egg that should be rendered.
-            resources_dir (str): The path of the resources directory.
-        """
         pygame.sprite.Sprite.__init__(self)
 
         self.egg_color = egg_color
@@ -93,21 +68,20 @@ class SelectionEgg(pygame.sprite.Sprite):
         # Load the egg from the given color and get the bounding rectangle for the image.
         sprite_sheet = SpriteSheet(resources_dir + '/images/bloops/{0}/egg.png'.format(self.egg_color),
                                    resources_dir + '/images/bloops/{0}/egg.json'.format(self.egg_color))
-        self._images = sprite_sheet.images
+        self.images = sprite_sheet.images
 
         # Get the rectangle from the first image in the list
-        self.rect = self._images[0].get_rect()
-        print(type(self.rect))
-        self._index = 0
-        self.image = self._images[self._index]
+        self.rect = self.images[0].get_rect()
+        self.index = 0
+        self.image = self.images[self.index]
 
     def update(self):
         """
-        Update the sprite to the next animation frame.
+        Updates the sprite object.
         """
         # Animate the sprite
-        self._index = (self._index + 1) % len(self._images)
-        self.image = self._images[self._index]
+        self.index = (self.index + 1) % len(self.images)
+        self.image = self.images[self.index]
 
 
 class InfoText: