refactor original code into separate modules

Author: ng-lis

projects/Snake Game/constants.py

@@ -0,0 +1,27 @@
+from enum import Enum
+from collections import namedtuple
+
+
+class RgbColors:
+    WHITE = (255, 255, 255)
+    RED = (200, 0, 0)
+    BLUE1 = (0, 0, 255)
+    BLUE2 = (0, 100, 255)
+    BLACK = (0, 0, 0)
+
+
+class GameSettings:
+    BLOCK_SIZE = 20
+    SPEED = 5
+    WIDTH = 640
+    HEIGHT = 480
+
+
+class Direction(Enum):
+    RIGHT = 1
+    LEFT = 2
+    UP = 3
+    DOWN = 4
+
+
+Point = namedtuple('Point', ['x', 'y'])

projects/Snake Game/display.py

@@ -0,0 +1,38 @@
+import pygame
+from constants import RgbColors, GameSettings
+
+
+class Display:
+    def __init__(self):
+        pygame.init()
+        self.width = GameSettings.WIDTH
+        self.height = GameSettings.HEIGHT
+        self.font = pygame.font.Font(None, 25)
+        self.window = pygame.display.set_mode((self.width, self.height))
+        pygame.display.set_caption("Snake")
+        self.clock = pygame.time.Clock()
+
+    def update_ui(self, snake, food, score):
+        self.window.fill(RgbColors.BLACK)
+        # Draw snake
+        for block in snake.blocks:
+            pygame.draw.rect(
+                self.window, RgbColors.BLUE1,
+                pygame.Rect(block.x, block.y, GameSettings.BLOCK_SIZE, GameSettings.BLOCK_SIZE)
+            )
+            pygame.draw.rect(
+                self.window, RgbColors.BLUE2, pygame.Rect(block.x + 4, block.y + 4, 12, 12)
+            )
+        # Draw food
+        pygame.draw.rect(
+            self.window,
+            RgbColors.RED,
+            pygame.Rect(food.x, food.y, GameSettings.BLOCK_SIZE, GameSettings.BLOCK_SIZE),
+        )
+        # Draw score
+        score_display = self.font.render(f"Score: {score}", True, RgbColors.WHITE)
+        self.window.blit(score_display, [0, 0])  # score in top left corner of window
+        pygame.display.flip()
+
+    def clock_tick(self, speed):
+        self.clock.tick(speed)

projects/Snake Game/game.py

@@ -1,162 +1,81 @@
 import pygame
 import random
-from enum import Enum
-from collections import namedtuple
+from snake import Snake, Direction, Point
+from display import Display
+from constants import GameSettings
 
-pygame.init()
-font = pygame.font.Font(None, 25)
-
-
-class Direction(Enum):
-    RIGHT = 1
-    LEFT = 2
-    UP = 3
-    DOWN = 4
-
-
-Point = namedtuple("Point", "x, y")
-
-# rgb colors
-WHITE = (255, 255, 255)
-RED = (200, 0, 0)
-BLUE1 = (0, 0, 255)
-BLUE2 = (0, 100, 255)
-BLACK = (0, 0, 0)
-
-BLOCK_SIZE = 20
-SPEED = 5
-
-
-class SnakeGame:
-    def __init__(self, w=640, h=480):
-        self.w = w
-        self.h = h
-        # init display
-        self.display = pygame.display.set_mode((self.w, self.h))
-        pygame.display.set_caption("Snake")
-        self.clock = pygame.time.Clock()
-
-        # init game state
-        self.direction = Direction.RIGHT
-
-        self.head = Point(self.w / 2, self.h / 2)
-        self.snake = [
-            self.head,
-            Point(self.head.x - BLOCK_SIZE, self.head.y),
-            Point(self.head.x - (2 * BLOCK_SIZE), self.head.y),
-        ]
 
+class Game:
+    def __init__(self):
+        self.display = Display()
+        self.snake = Snake()
         self.score = 0
         self.food = None
-        self._place_food()
+        self.place_food()
+
+    def game_loop(self):
+        while True:
+            self.play_step()
+            game_over, score = self.play_step()
+            if game_over:
+                break
+        print("Final Score:", self.score)
+        pygame.quit()
+
+    def is_collision(self):
+        # Snake hits boundary
+        if (
+                self.snake.head.x > self.display.width - self.snake.block_size
+                or self.snake.head.x < 0
+                or self.snake.head.y > self.display.height - self.snake.block_size
+                or self.snake.head.y < 0
+        ):
+            return True
+        # Snake hits itself
+        if self.snake.self_collision():
+            return True
+        return False
 
-    def _place_food(self):
-        x = random.randint(0, (self.w - BLOCK_SIZE) // BLOCK_SIZE) * BLOCK_SIZE
-        y = random.randint(0, (self.h - BLOCK_SIZE) // BLOCK_SIZE) * BLOCK_SIZE
-        self.food = Point(x, y)
-        if self.food in self.snake:
-            self._place_food()
+    def game_over(self):
+        return self.is_collision()
 
-    def play_step(self):
-        # 1. collect user input
+    def get_user_input(self):
         for event in pygame.event.get():
             if event.type == pygame.QUIT:
                 pygame.quit()
                 quit()
             if event.type == pygame.KEYDOWN:
                 if event.key == pygame.K_LEFT:
-                    self.direction = Direction.LEFT
+                    self.snake.direction = Direction.LEFT
                 elif event.key == pygame.K_RIGHT:
-                    self.direction = Direction.RIGHT
+                    self.snake.direction = Direction.RIGHT
                 elif event.key == pygame.K_UP:
-                    self.direction = Direction.UP
+                    self.snake.direction = Direction.UP
                 elif event.key == pygame.K_DOWN:
-                    self.direction = Direction.DOWN
-
-        # 2. move
-        self._move(self.direction)  # update the head
-        self.snake.insert(0, self.head)
+                    self.snake.direction = Direction.DOWN
 
-        # 3. check if game over
-        game_over = False
-        if self._is_collision():
-            game_over = True
-            return game_over, self.score
-
-        # 4. place new food or just move
-        if self.head == self.food:
+    def play_step(self):
+        self.get_user_input()
+        self.snake.move(self.snake.direction)
+        if self.snake.head == self.food:
             self.score += 1
-            self._place_food()
+            self.place_food()
         else:
-            self.snake.pop()
-
-        # 5. update ui and clock
-        self._update_ui()
-        self.clock.tick(SPEED)
-        # 6. return game over and score
+            self.snake.blocks.pop()
+        # Update UI and Clock
+        self.display.update_ui(self.snake, self.food, self.score)
+        self.display.clock_tick(GameSettings.SPEED)
+        game_over = self.is_collision()
         return game_over, self.score
 
-    def _is_collision(self):
-        # hits boundary
-        if (
-            self.head.x > self.w - BLOCK_SIZE
-            or self.head.x < 0
-            or self.head.y > self.h - BLOCK_SIZE
-            or self.head.y < 0
-        ):
-            return True
-        # hits itself
-        if self.head in self.snake[1:]:
-            return True
-
-        return False
-
-    def _update_ui(self):
-        self.display.fill(BLACK)
-
-        for pt in self.snake:
-            pygame.draw.rect(
-                self.display, BLUE1, pygame.Rect(pt.x, pt.y, BLOCK_SIZE, BLOCK_SIZE)
-            )
-            pygame.draw.rect(
-                self.display, BLUE2, pygame.Rect(pt.x + 4, pt.y + 4, 12, 12)
-            )
-
-        pygame.draw.rect(
-            self.display,
-            RED,
-            pygame.Rect(self.food.x, self.food.y, BLOCK_SIZE, BLOCK_SIZE),
-        )
-
-        text = font.render("Score: " + str(self.score), True, WHITE)
-        self.display.blit(text, [0, 0])
-        pygame.display.flip()
-
-    def _move(self, direction):
-        x = self.head.x
-        y = self.head.y
-        if direction == Direction.RIGHT:
-            x += BLOCK_SIZE
-        elif direction == Direction.LEFT:
-            x -= BLOCK_SIZE
-        elif direction == Direction.DOWN:
-            y += BLOCK_SIZE
-        elif direction == Direction.UP:
-            y -= BLOCK_SIZE
-
-        self.head = Point(x, y)
-
-
-if __name__ == "__main__":
-    game = SnakeGame()
-
-    # game loop
-    while True:
-        game_over, score = game.play_step()
-
-        if game_over == True:
-            break
-
-    print("Final Score", score)
+    def place_food(self):
+        x = random.randint(0, (
+                self.display.width - GameSettings.BLOCK_SIZE) // GameSettings.BLOCK_SIZE) * GameSettings.BLOCK_SIZE
+        y = random.randint(0, (
+                self.display.height - GameSettings.BLOCK_SIZE) // GameSettings.BLOCK_SIZE) * GameSettings.BLOCK_SIZE
+        self.food = Point(x, y)
+        if self.food in self.snake.blocks:
+            self.place_food()
 
-    pygame.quit()
+    def get_score(self):
+        return self.score

projects/Snake Game/main.py

@@ -0,0 +1,5 @@
+from game import Game
+
+if __name__ == "__main__":
+    game = Game()
+    game.game_loop()

projects/Snake Game/snake.py

@@ -0,0 +1,29 @@
+from constants import GameSettings, Direction, Point
+
+
+class Snake:
+    def __init__(self, init_length=3):
+        self.head = Point(GameSettings.WIDTH / 2, GameSettings.HEIGHT / 2)
+        self.block_size = GameSettings.BLOCK_SIZE
+        self.blocks = ([self.head] +
+                       [Point(self.head.x - (i * self.block_size), self.head.y) for i in range(1, init_length)])
+        self.direction = Direction.RIGHT
+
+    def move(self, direction):
+        x, y = self.head
+        if direction == Direction.RIGHT:
+            x += self.block_size
+        elif direction == Direction.LEFT:
+            x -= self.block_size
+        elif direction == Direction.DOWN:
+            y += self.block_size
+        elif direction == Direction.UP:
+            y -= self.block_size
+        self.head = Point(x, y)
+        self.blocks.insert(0, self.head)
+        return self.head
+
+    def self_collision(self):
+        if self.head in self.blocks[1:]:
+            return True
+        return False