fix programme start and add entity parent class

Author: ltuffery

api/entity/apple.py

@@ -1,4 +1,5 @@
 from enum import Enum
+from api.entity.entity import Entity
 
 
 class AppleType(Enum):
@@ -13,21 +14,24 @@ class AppleType(Enum):
     GREEN = 1
 
 
-class Apple:
+class Apple(Entity):
     """
     Represents an apple in the game, which can be either red or green.
 
     Attributes:
         apple_type (AppleType): The type of the apple (RED or GREEN).
     """
 
-    def __init__(self, apple_type: AppleType):
+    def __init__(self, x: int, y: int, apple_type: AppleType):
         """
-        Initializes an apple with a specified type.
+        Initializes an apple with a specified type and position.
 
         Args:
+            x (int): The x-coordinate of the apple's position.
+            y (int): The y-coordinate of the apple's position.
             apple_type (AppleType): The type of the apple (RED or GREEN).
         """
+        super().__init__(x, y)
         self.apple_type = apple_type
 
     def is_green(self) -> bool:
@@ -47,3 +51,17 @@ def is_red(self) -> bool:
             bool: True if the apple is red, False otherwise.
         """
         return self.apple_type == AppleType.RED
+
+    def get_char(self) -> str:
+        """
+        Returns a character representation of the apple, colored based on its
+        type.
+
+        Returns:
+            str: A string representing the apple with appropriate color
+            formatting for the terminal.
+        """
+        if self.is_green():
+            return "\033[32m@\033[0m"  # Green apple
+
+        return "\033[31m@\033[0m"  # Red apple

api/entity/entity.py

@@ -0,0 +1,26 @@
+from abc import ABC, abstractmethod
+
+
+class Entity(ABC):
+    def __init__(self, x: int, y: int):
+        self.__x = x
+        self.__y = y
+
+    def get_x(self) -> int:
+        return self.__x
+
+    def get_y(self) -> int:
+        return self.__y
+
+    def set_x(self, x: int) -> None:
+        self.__x = x
+
+    def set_y(self, y: int) -> None:
+        self.__y = y
+
+    @abstractmethod
+    def get_char(self) -> str:
+        pass
+
+    def __str__(self):
+        return self.get_char()

api/entity/snake.py

@@ -2,9 +2,10 @@
 from api.exception.gameover import GameOver
 from api.entity.apple import Apple
 from api.world import World
+from api.entity.entity import Entity
 
 
-class SnakeBody:
+class SnakeBody(Entity):
     """
     Represents a segment of a snake's body in a game.
 
@@ -18,43 +19,34 @@ def __init__(self, x: int, y: int):
         Initializes a body segment of the snake at a specific position.
 
         Args:
-            x (int): The initial X position.
-            y (int): The initial Y position.
+            x (int): The initial X position of the body segment.
+            y (int): The initial Y position of the body segment.
         """
-        self.__x = x
-        self.__y = y
+        super().__init__(x, y)
 
-    def get_x(self) -> int:
+    def move(self, x: int, y: int):
         """
-        Returns the X-coordinate of the body segment.
+        Moves the body segment to a new position.
 
-        Returns:
-            int: The X-coordinate.
+        Args:
+            x (int): The new X position of the body segment.
+            y (int): The new Y position of the body segment.
         """
-        return self.__x
+        self.set_x(x)
+        self.set_y(y)
 
-    def get_y(self) -> int:
+    def get_char(self) -> str:
         """
-        Returns the Y-coordinate of the body segment.
+        Returns the character representation of a body segment for rendering in
+        the terminal.
 
         Returns:
-            int: The Y-coordinate.
+            str: The character "#" representing the body segment.
         """
-        return self.__y
+        return "#"
 
-    def move(self, x: int, y: int):
-        """
-        Moves the body segment to a new position.
 
-        Args:
-            x (int): The new X position.
-            y (int): The new Y position.
-        """
-        self.__x = x
-        self.__y = y
-
-
-class Snake:
+class Snake(Entity):
     """
     Represents a snake in the game, which moves, grows, and interacts with the
     world.
@@ -79,11 +71,11 @@ def __init__(self, world: World, x: int, y: int, direction: Direction):
             y (int): The initial Y position of the snake's head.
             direction (Direction): The initial movement direction of the snake.
         """
-        self.__x = x
-        self.__y = y
+        super().__init__(x, y)
+
         self.__body: list[SnakeBody] = []
-        self.__world = world
-        self.__last_direction = direction
+        self.__world: World = world
+        self.__last_direction: Direction = direction
 
         dir_x, dir_y = direction.value
 
@@ -93,7 +85,7 @@ def __init__(self, world: World, x: int, y: int, direction: Direction):
             y += dir_y
 
             self.__body.append(SnakeBody(x, y))
-            self.__world.spaw_entity(self.__body[-1])
+            self.__world.spawn_entity(self.__body[-1])
 
     def move(self, direction: Direction):
         """
@@ -108,28 +100,27 @@ def move(self, direction: Direction):
             GameOver: If the snake collides with an obstacle or itself.
         """
         x, y = direction.value
-        info = self.__world.get_location(self.__x + x, self.__y + y)
+        info = self.__world.get_location(self.get_x() + x, self.get_y() + y)
 
         if not info.is_passable():
             raise GameOver("End game")
 
-        self.__x += x
-        self.__y += y
+        self.set_x(self.get_x() + x)
+        self.set_y(self.get_y() + y)
         self.__last_direction = direction
 
         # Move the body segments following the head
         for i, body in reversed(list(enumerate(self.__body))):
             if i == 0:
-                body.move(self.__x - x, self.__y - y)
+                body.move(self.get_x() - x, self.get_y() - y)
             else:
                 last = self.__body[i - 1]
                 body.move(last.get_x(), last.get_y())
 
     def eat(self, apple: Apple):
         """
         Handles the snake eating an apple. The snake grows if the apple is
-        green,
-        otherwise, it loses a segment.
+        green, otherwise, it loses a segment.
 
         Args:
             apple (Apple): The apple that the snake is eating.
@@ -141,6 +132,7 @@ def eat(self, apple: Apple):
             x, y = self.__last_direction
             last_body = self.__body[-1]
 
+            # Grow the snake by adding a new body segment
             self.__body.append(
                 SnakeBody(
                     last_body.get_x() + x,
@@ -151,6 +143,7 @@ def eat(self, apple: Apple):
             if len(self.__body) == 0:
                 raise GameOver("End game")
 
+            # Remove the last body segment
             del self.__body[-1]
 
     def size(self) -> int:
@@ -163,29 +156,21 @@ def size(self) -> int:
         """
         return len(self.__body) + 1
 
-    def get_x(self) -> int:
-        """
-        Returns the X-coordinate of the snake's head.
-
-        Returns:
-            int: The X position of the snake's head.
-        """
-        return self.__x
-
-    def get_y(self) -> int:
+    def get_body(self) -> list[SnakeBody]:
         """
-        Returns the Y-coordinate of the snake's head.
+        Returns the list of body segments of the snake.
 
         Returns:
-            int: The Y position of the snake's head.
+            list[SnakeBody]: The body segments of the snake.
         """
-        return self.__y
+        return self.__body
 
-    def get_body(self) -> list[SnakeBody]:
+    def get_char(self) -> str:
         """
-        Returns the list of body segments of the snake.
+        Returns the character representation of the snake, colored for
+        terminal output.
 
         Returns:
-            list[SnakeBody]: The body segments of the snake.
+            str: A string representing the snake, colored in yellow.
         """
-        return self.__body
+        return "\033[33m#\033[0m"

api/world.py

@@ -1,4 +1,5 @@
 from api.map_location import MapLocation
+from api.entity.entity import Entity
 import sys
 import copy
 
@@ -25,7 +26,7 @@ def __init__(self, height=10, width=10):
         self.__world: list = []
         self.__height: int = height
         self.__width: int = width
-        self.__entities: list = []
+        self.__entities: list[Entity] = []
 
         self.__make_world()
 
@@ -104,7 +105,7 @@ def render(self):
         world = copy.deepcopy(self.__world)
 
         for entity in self.__entities:
-            world[entity.get_y()][entity.get_x()] = '#'
+            world[entity.get_y()][entity.get_x()] = entity.get_char()
 
             # Uncomment if you want to render the snake's body
             # for body in entity.get_body():

main.py

@@ -2,11 +2,14 @@
 from api.direction import Direction
 from api.exception.gameover import GameOver
 from api.entity.snake import Snake
+from api.entity.apple import Apple, AppleType
 
 world = World()
-snake = Snake(world, 5, 5, Direction.SUD)
+snake = Snake(world, 5, 5, Direction.SOUTH)
+green_apple = Apple(2, 2, AppleType.GREEN)
 
-world.spaw_entity(snake)
+world.spawn_entity(snake)
+world.spawn_entity(green_apple)
 
 while True:
     world.render()
@@ -21,9 +24,9 @@
         if key == 'w':
             snake.move(Direction.NORTH)
         elif key == 's':
-            snake.move(Direction.SUD)
+            snake.move(Direction.SOUTH)
         elif key == 'a':
-            snake.move(Direction.WEAST)
+            snake.move(Direction.WEST)
         elif key == 'd':
             snake.move(Direction.EAST)
     except GameOver: