Игра. Добавление врагов

import math
import random as rnd
import tkinter as tk
 
 
class Point:
    """Represents a point on a 2D plane.
 
    Attributes:
        x (int): The x-coordinate of the point.
        y (int): The y-coordinate of the point.
    """
    def __init__(self, x, y):
        self.x = x
        self.y = y
 
    def get_tuple_cords(self):
        """Returns the coordinates of the point as a tuple.
 
        Returns:
            tuple[int, int]: The x and y coordinates of the point.
        """
        return self.x, self.y
 
 
class CircleGame:
    """Represents a circle game object.
 
    Attributes:
        center (Point): The center point of the circle.
        radius (int): The radius of the circle.
        fill_color (str): The color of the circle.
    """
    def __init__(self, center: Point, radius: int, fill_color: str):
        self.center = center
        self.radius = radius
        self.fill_color = fill_color
 
    def get_central_point(self):
        """Returns the center point of the circle.
 
        Returns:
            Point: The center point of the circle.
        """
        return self.center
 
    def _get_graph_space(self) -> tuple[int, ...]:
        """Returns the coordinates of the bounding box for the circle.
 
        Returns:
            tuple[int, ...]: The coordinates of the top-left and bottom-right points of the bounding box.
        """
        p_top_l = Point(self.center.x - self.radius, self.center.y - self.radius)
        p_bottom_r = Point(self.center.x + self.radius, self.center.y + self.radius)
 
        return *p_top_l.get_tuple_cords(), *p_bottom_r.get_tuple_cords()
 
    def __eq__(self, other: 'CircleGame') -> bool:
        """Compares two CircleGame objects for equality.
 
        Args:
            other (CircleGame): The other CircleGame object to compare.
 
        Returns:
            bool: True if the circles are overlapping, False otherwise.
        """
        if not isinstance(other, CircleGame):
            return NotImplemented
 
        return math.dist(self.center.get_tuple_cords(), other.center.get_tuple_cords()) < (self.radius + other.radius)
 
    def draw(self, canvas):
        """Draws the circle on the given canvas.
 
        Args:
            canvas (tk.Canvas): The canvas to draw the circle on.
        """
        canvas.create_oval(self._get_graph_space(), fill=self.fill_color)
 
    def move_up(self, distance):
        """Moves the circle up by the given distance.
 
        Args:
            distance (int): The distance to move the circle up.
        """
        self.center.y -= distance
 
    def move_down(self, distance):
        """Moves the circle down by the given distance.
 
        Args:
            distance (int): The distance to move the circle down.
        """
        self.center.y += distance
 
    def move_left(self, distance):
        """Moves the circle left by the given distance.
 
        Args:
            distance (int): The distance to move the circle left.
        """
        self.center.x -= distance
 
    def move_right(self, distance):
        """Moves the circle right by the given distance.
 
        Args:
            distance (int): The distance to move the circle right.
        """
        self.center.x += distance
 
    @classmethod
    def get_color_circles_list(cls, circle_counts: dict, canvas_size: int) -> list['CircleGame']:
        """Generates a list of CircleGame objects with the specified colors and counts.
 
        Args:
            circle_counts (dict): A dictionary mapping color strings to the number of circles of that color.
            canvas_size (int): The size of the canvas (width or height).
 
        Returns:
            list[CircleGame]: A list of CircleGame objects.
        """
        radius = canvas_size // 30
        low_brd = radius
        hi_brd = canvas_size - radius
        ret_list = []
        all_counts = 0
 
        for color, count in circle_counts.items():
            all_counts += count
            while len(ret_list) < all_counts:
                tmp_cg = CircleGame(Point(rnd.randint(low_brd, hi_brd), rnd.randint(low_brd, hi_brd)), radius, color)
                if tmp_cg not in ret_list:
                    ret_list.append(tmp_cg)
 
        return ret_list
 
    @classmethod
    def get_colliding_circles_list(cls, circle_moveable: 'CircleGame', circles: list['CircleGame']) -> list['CircleGame']:
        """Returns a list of circles that are colliding with the given moveable circle.
 
        Args:
            circle_moveable (CircleGame): The moveable circle.
            circles (list[CircleGame]): The list of circles to check for collisions.
 
        Returns:
            list[CircleGame]: A list of circles that are colliding with the moveable circle.
        """
        return [c for c in circles if c.fill_color != circle_moveable.fill_color and c == circle_moveable]
 
 
class Game:
    """Represents the game controller.
 
    Attributes:
        window_width (int): The width of the game window.
        window_height (int): The height of the game window.
        root (tk.Tk): The main Tkinter window.
        canvas (tk.Canvas): The canvas for drawing the game elements.
        circles (list[CircleGame]): The list of CircleGame objects in the game.
        moveable_circle (CircleGame): The moveable circle in the game.
    """
    def __init__(self, window_width: int, window_height: int):
        self.window_width = window_width
        self.window_height = window_height
        self.root = tk.Tk()
        self.root.title(">>>Опасное путешествие красного Колобка<<<")
        self.canvas = tk.Canvas(self.root, width=self.window_width, height=self.window_height)
        self.canvas.pack()
        self.circles = CircleGame.get_color_circles_list({'red': 1, 'green': 2, 'blue': 21}, self.window_width)
        self.moveable_circle = [c for c in self.circles if c.fill_color == 'red'][0]
 
    def redraw(self, message=None):
        """Redraws the game elements on the canvas.
 
        Args:
            message (str, optional): A message to display on the canvas.
        """
        self.canvas.delete("all")
        if message:
            x, y = self.window_width // 2, self.window_height // 2
            self.canvas.create_text(x, y, text=message, fill="red", font=("Arial", 16))
        else:
            for circle in self.circles:
                circle.draw(self.canvas)
 
    def _can_move(self, direction: str, distance: int) -> bool:
        """Checks if the moveable circle can be moved in the given direction by the given distance.
 
        Args:
            direction (str): The direction to move the circle ("up", "down", "left", "right").
            distance (int): The distance to move the circle.
 
        Returns:
            bool: True if the circle can be moved, False otherwise.
        """
        if direction == "up":
            new_y = self.moveable_circle.center.y - distance
            return new_y >= self.moveable_circle.radius
        elif direction == "down":
            new_y = self.moveable_circle.center.y + distance
            return new_y <= self.window_height - self.moveable_circle.radius
        elif direction == "left":
            new_x = self.moveable_circle.center.x - distance
            return new_x >= self.moveable_circle.radius
        elif direction == "right":
            new_x = self.moveable_circle.center.x + distance
            return new_x <= self.window_width - self.moveable_circle.radius
        return False
 
    def move_circle(self, direction: str, distance=10):
        """Moves the moveable circle in the given direction, if possible.
 
        Args:
            direction (str): The direction to move the circle ("up", "down", "left", "right").
            distance (int, optional): The distance to move the circle. Defaults to 10.
        """
        if self._can_move(direction, distance):
            if direction == "up":
                self.moveable_circle.move_up(distance)
            elif direction == "down":
                self.moveable_circle.move_down(distance)
            elif direction == "left":
                self.moveable_circle.move_left(distance)
            elif direction == "right":
                self.moveable_circle.move_right(distance)
 
        colliding_list = CircleGame.get_colliding_circles_list(self.moveable_circle, self.circles)
        if len(colliding_list) > 0:
            if colliding_list[0].fill_color == "blue":
                self.game_over()
            elif colliding_list[0].fill_color == "green":
                self.win()
        else:
            self.redraw()
 
    def game_over(self):
        """Displays the "game over" message and binds the space key to the reset method."""
        self.redraw("Колобок доигрался, конец!\nНачать снова, жми пробел, выход из игры - Escape.")
        self.root.bind("<space>", lambda event: self.reset())
 
    def win(self):
        """Displays the "win" message and binds the space key to the reset method."""
        self.redraw("Колобок нашел свое счастье!\nНачать снова, жми пробел, выход из игры - Escape.")
        self.root.bind("<space>", lambda event: self.reset())
 
    def reset(self):
        """Resets the game by generating a new set of circles."""
        self.circles = CircleGame.get_color_circles_list({'red': 1, 'green': 2, 'blue': 21}, self.window_width)
        self.moveable_circle = [c for c in self.circles if c.fill_color == 'red'][0]
        self.redraw()
 
    def exit(self):
        """Exits the game by destroying the Tkinter window."""
        self.root.destroy()
 
    def run(self):
        """Runs the game by displaying the initial state and binding the keyboard events."""
        self.redraw()
 
        self.root.bind("<Up>", lambda event: self.move_circle("up"))
        self.root.bind("<Down>", lambda event: self.move_circle("down"))
        self.root.bind("<Left>", lambda event: self.move_circle("left"))
        self.root.bind("<Right>", lambda event: self.move_circle("right"))
        self.root.bind("<Escape>", lambda event: self.exit())
 
        self.root.mainloop()
 
if __name__ == "__main__":
    game = Game(600, 600)
    game.run()