split animations

danmaku/game/animated.py

@@ -14,7 +14,7 @@ class Animated(GameObject):
         width_height (tuple[int | float, int | float]): Width and height of the object.
         speed (int | float): Speed of the object.
         frames (list[str]): List of frames
-        freq (int | float): Frequency of animation
+        freq (int | float | None, optional): Frequency of animation
         period (int | float | None, optional): Period of animation. Defaults to None.
 
         You can pass freq as '0' and just use period
@@ -26,8 +26,8 @@ def __init__(
         xy: tuple[int | float, int | float],
         width_height: tuple[int | float, int | float],
         speed: int | float,
-        frames: dict[Direction, list[str]],
-        freq: int | float,
+        frames: list[str],
+        freq: int | float | None = None,
         period: int | float | None = None,
     ) -> None:
         super().__init__(xy, width_height, speed)
@@ -37,17 +37,17 @@ def __init__(
         if period is not None:
             self.animation_period = period
             self.animation_freq = 1 / period
-        else:
+        elif freq is not None:
             self.animation_freq = freq
             self.animation_period = 1 / freq
+        else:
+            raise ValueError("You must pass period or freq")
         self.animation_current = 0
         self.animation_last = 0
         self.last_direction = 0
 
         if len(frames):
-            self.texture_file = self.animation_frames[Direction.STATIC][
-                self.animation_current
-            ]
+            self.texture_file = self.animation_frames[self.animation_current]
 
     def can_animate(self) -> bool:
         """Check if possible to animate"""
@@ -58,15 +58,56 @@ def can_animate(self) -> bool:
             return True
         return False
 
+    def animate(self) -> None:
+        """Animate one frame if possible"""
+        if self.can_animate():
+            self.animation_current = (self.animation_current + 1) % len(
+                self.animation_frames
+            )
+            self.texture_file = self.animation_frames[self.animation_current]
+
+
+class AnimatedDirectional(Animated):
+    def __init__(
+        self,
+        xy: tuple[int | float, int | float],
+        width_height: tuple[int | float, int | float],
+        speed: int | float,
+        frames: list[str],
+        freq: int | float | None = None,
+        period: int | float | None = None,
+    ) -> None:
+        super().__init__(xy, width_height, speed, [], freq, period)
+        self.last_direction = 0
+
+        self.animation_frames = {
+            Direction.LEFT: [],
+            Direction.RIGHT: [],
+            Direction.UP: [],
+            Direction.DOWN: [],
+            Direction.STATIC: [],
+        }
+
+        for file in frames:
+            if "left" in file:
+                self.animation_frames[Direction.LEFT].append(file)
+            if "right" in file:
+                self.animation_frames[Direction.RIGHT].append(file)
+            if "up" in file:
+                self.animation_frames[Direction.UP].append(file)
+            if "down" in file:
+                self.animation_frames[Direction.DOWN].append(file)
+            if "static" in file or "idle" in file:
+                self.animation_frames[Direction.STATIC].append(file)
+
+        self.texture_file = self.animation_frames[Direction.STATIC][
+            self.animation_current
+        ]
+
     def animate(
         self, direction_vector: tuple[int | float, int | float] = (0, 0)
     ) -> None:
         """Animate one frame if possible"""
-        # if self.can_animate():
-        #     self.animation_current = (self.animation_current + 1) % len(
-        #         self.animation_frames
-        #     )
-        #     self.texture_file = self.animation_frames[self.animation_current]
 
         if self.can_animate():
             direction = None
@@ -101,30 +142,3 @@ def animate(
                     self.animation_current
                 ]
                 self.last_direction = direction
-
-    def frames_from_str(self, str_frames, adress):
-        files: list[str] = str_frames.split(";")
-        self.animation_frames = {
-            Direction.LEFT: [],
-            Direction.RIGHT: [],
-            Direction.UP: [],
-            Direction.DOWN: [],
-            Direction.STATIC: [],
-        }
-
-        for i in files:
-            path = f"/{adress}/{i}"
-            if "left" in i:
-                self.animation_frames[Direction.LEFT].append(path)
-            if "right" in i:
-                self.animation_frames[Direction.RIGHT].append(path)
-            if "up" in i:
-                self.animation_frames[Direction.UP].append(path)
-            if "down" in i:
-                self.animation_frames[Direction.DOWN].append(path)
-            if "static" in i or "idle" in i:
-                self.animation_frames[Direction.STATIC].append(path)
-
-        self.texture_file = self.animation_frames[Direction.STATIC][
-            self.animation_current
-        ]

danmaku/game/background.py

@@ -23,19 +23,10 @@ def __init__(
             pass
 
         super().__init__((x, y), (width, height), 0, frames, 0, period=0.1)
-        self.texture_size = self.width, self.height
+        self.texture_size = int(self.width), int(self.height)
 
     def draw(self, graphics: vgame.graphics.Graphics):
         graphics.draw_sprite(self)
 
     def update(self, delta: int | float):
         self.animate()
-
-    def animate(
-        self, direction_vector: tuple[int | float, int | float] = (0, 0)
-    ) -> None:
-        if self.can_animate():
-            self.animation_current = (self.animation_current + 1) % len(
-                self.animation_frames
-            )
-            self.texture_file = self.animation_frames[self.animation_current]

danmaku/game/enemy.py

@@ -3,14 +3,14 @@
 from random import randint, choices
 from math import sin, cos, pi
 
-from danmaku.game.animated import Animated
+from danmaku.game.animated import AnimatedDirectional
 from danmaku.game.bullet import Bullet
 from danmaku.database import get_enemy_type
 from danmaku.game.shooter import Shooter
 from danmaku.game.drop import PowerUp, Points, Drop
 
 
-class Enemy(Shooter, Animated):
+class Enemy(Shooter, AnimatedDirectional):
     """Enemy object."""
 
     def __init__(
@@ -38,10 +38,14 @@ def __init__(
         )
 
         frames = list(map(lambda x: f"/enemy/{x}", args["texture_file"].split(";")))
-        Animated.__init__(
-            self, xy, args["texture_size"], args["speed"], frames, 0, period=0.1
+        AnimatedDirectional.__init__(
+            self,
+            xy,
+            args["texture_size"],
+            args["speed"],
+            frames,
+            period=0.1,
         )
-        self.frames_from_str(args["texture_file"], "enemy")
         self.texture_size = args["texture_size"]
         self.my_type = object_type
         self.cost: int = args["cost"]

danmaku/game/player.py

@@ -6,10 +6,10 @@
 from danmaku.database import get_player_type
 from danmaku.utils import constrain
 from danmaku.game.shooter import Shooter
-from danmaku.game.animated import Animated
+from danmaku.game.animated import AnimatedDirectional
 
 
-class Player(Shooter, Animated):
+class Player(Shooter, AnimatedDirectional):
     """Player object."""
 
     def __init__(
@@ -38,10 +38,16 @@ def __init__(
 
         # Animation
 
-        Animated.__init__(
-            self, xy, args["texture_size"], args["speed"], [], 0, period=0.1
+        address = "player"
+
+        AnimatedDirectional.__init__(
+            self,
+            xy,
+            args["texture_size"],
+            args["speed"],
+            [f"{address}/{i}" for i in args["texture_file"].split(";")],
+            period=0.1,
         )
-        self.frames_from_str(args["texture_file"], "player")
 
         self.texture_size = args["texture_size"]