ch'tit exercice matinal en python :-D

import math
from dataclasses import dataclass, field
from enum import Enum
from tkinter import Tk, Canvas, YES, BOTH
from tkinter.ttk import Label
from typing import Any

from numpy import array
from scipy.linalg import norm


class EntityType(Enum):
    SPIDER = 0
    HERO = 1


@dataclass
class Entity:
    x: int
    y: int
    radius: int
    speed: int
    type: EntityType
    health: int
    location: array = field(init=False)  # calculated value after instance creation
    new_location: array = field(init=False)  # calculated value after instance creation
    circle: Any = field(init=False)

    def __post_init__(self):
        self.location = array([self.x, self.y], dtype=float)

    def dist(self, other):
        return norm(self.location - other.location) if isinstance(other, Entity) else norm(self.location - other)

    def move(self, target):
        if isinstance(target, Entity):
            u: array = target.location - self.location
        else:
            u: array = target - self.location
        v: array = u / norm(u) if norm(u) > 0 else 0
        speed: float = min(self.speed, self.dist(target))
        return self.location + speed * v


@dataclass
class Game:
    root: Tk = Tk()
    canvas: Canvas = None
    dbg_label: Label = None
    hp_label: Label = None
    base: array = None
    spider: Entity = None
    hero: Entity = None
    map_width: int = None
    map_height: int = None
    zoom: float = None

    def populate(self):
        self.spider = Entity(health=30, type=EntityType.SPIDER, x=3000, y=3000, radius=400, speed=400)
        self.hero = Entity(health=math.inf, type=EntityType.HERO, x=4000, y=4000, radius=800, speed=800)

    def init_tk(self, map_width: int, map_height: int, zoom: int):
        self.canvas = Canvas(width=map_width * zoom, height=map_height * zoom, bg='white')
        self.zoom = zoom
        self.canvas.bind("<Button-1>", self.callback)
        self.canvas.pack(expand=YES, fill=BOTH)
        self.base = array([0, 0])
        self.dbg_label = Label(self.root, text="Hello World!")
        self.dbg_label.pack(pady=20)
        self.hp_label = Label(self.root)
        x, y = self.spider.location
        self.hp_label.place(x=x, y=y)
        self.hp_label['text'] = f"{self.spider.health}"
        self.hp_label.pack(pady=20)

        self.spider.circle = self.draw_circle(entity=self.spider, color='red')
        self.hero.circle = self.draw_circle(entity=self.hero, color='blue')

        self.root.mainloop()

    # All of this would do better as a subclass of Canvas with specialize methods

    def draw_circle(self, entity: Entity, color: str):
        # changed this to return the ID
        x, y = entity.location
        oval = x - entity.radius, y - entity.radius, x + entity.radius, y + entity.radius
        x0, y0, x1, y1 = map(lambda x: x * self.zoom, oval)
        return self.canvas.create_oval(x0, y0, x1, y1, width=1, outline=color)

    def move_circle(self, entity):
        new_location = entity.move(self.base) if entity.type == EntityType.SPIDER else entity.move(self.spider)
        dx, dy = map(lambda x: x * self.zoom, new_location - entity.location)
        self.canvas.move(entity.circle, dx, dy)
        entity.location = new_location
        if entity.type == EntityType.SPIDER:
            x, y = map(lambda x: x * self.zoom, entity.location)
            self.hp_label.place(x=x, y=y)
            self.hp_label['text'] = f"{entity.health}"
            if entity.dist(self.base) > 300:
                self.dbg_label['text'] = f'distance spider to base = {round(entity.dist(self.base), 2)}'
            else:
                self.dbg_label['text'] = 'GAME OVER!'
        else:
            if entity.dist(self.spider) <= entity.radius:
                self.spider.health -= 2
                if self.spider.health < 0:
                    self.hp_label['text'] = 'GAME OVER!'
        if self.dbg_label['text'] == 'GAME OVER!':
            self.dbg_label['text'] = f'GAME OVER! -> distance spider to base = {round(entity.dist(self.base), 2)}'
            self.canvas.unbind("<Button-1>", self.callback)

    def callback(self, event):
        self.move_circle(entity=self.hero)
        self.move_circle(entity=self.spider)


if __name__ == "__main__":
    MAP_WIDTH, MAP_HEIGHT = 17630, 9000
    ZOOM = 0.1

    game: Game = Game()
    game.populate()
    game.init_tk(map_width=MAP_WIDTH, map_height=MAP_HEIGHT, zoom=ZOOM)