typehints

Author: JaskRendix

pyscroll/animation.py

@@ -1,19 +1,30 @@
 from __future__ import annotations
 
-from collections import namedtuple
 from collections.abc import Sequence
-from typing import Union
+from typing import NamedTuple, Union
+
+from pygame import Surface
+
+
+class AnimationFrame(NamedTuple):
+    image: Surface
+    duration: float
+
 
-AnimationFrame = namedtuple("AnimationFrame", "image duration")
 TimeLike = Union[float, int]
 
 __all__ = ("AnimationFrame", "AnimationToken")
 
 
 class AnimationToken:
-    __slots__ = ["next", "positions", "frames", "index"]
-
-    def __init__(self, positions, frames: Sequence, initial_time: int = 0) -> None:
+    __slots__ = ["_next", "positions", "frames", "index"]
+
+    def __init__(
+        self,
+        positions: set[tuple[int, int, int]],
+        frames: Sequence[AnimationFrame],
+        initial_time: float = 0.0,
+    ) -> None:
         """
         Constructor
 
@@ -26,10 +37,10 @@ def __init__(self, positions, frames: Sequence, initial_time: int = 0) -> None:
         frames = tuple(AnimationFrame(*i) for i in frames)
         self.positions = positions
         self.frames = frames
-        self.next = frames[0].duration + initial_time
+        self._next = frames[0].duration + initial_time
         self.index = 0
 
-    def advance(self, last_time: TimeLike):
+    def advance(self, last_time: TimeLike) -> AnimationFrame:
         """
         Advance the frame, and set timer for next frame
 
@@ -52,11 +63,8 @@ def advance(self, last_time: TimeLike):
 
         # set the timer for the next advance
         next_frame = self.frames[self.index]
-        self.next = next_frame.duration + last_time
+        self._next = next_frame.duration + last_time
         return next_frame
 
-    def __lt__(self, other):
-        try:
-            return self.next < other.next
-        except AttributeError:
-            return self.next < other
+    def __lt__(self, other: AnimationToken) -> bool:
+        return self._next < other._next

pyscroll/data.py

@@ -10,9 +10,10 @@
 from collections.abc import Iterable
 from heapq import heappop, heappush
 from itertools import product
+from typing import Any
 
 import pygame
-from pygame import Surface
+from pygame import Rect, Surface
 
 try:
     # optional pytmx support
@@ -48,20 +49,25 @@ class PyscrollDataAdapter:
     tile_size: tuple[int, int] = (0, 0)
     # (int, int): size of map in tiles
     map_size: tuple[int, int] = (0, 0)
-    visible_tile_layers = None  # list of visible layer integers
+    # list of visible layer integers
+    visible_tile_layers: list[int] = []
 
     def __init__(self) -> None:
-        self._last_time = None  # last time map animations were updated
-        self._animation_queue = list()  # list of animation tokens
-        self._animated_tile = dict()  # mapping of tile substitutions when animated
-        self._tracked_tiles = set()  # track the tiles on screen with animations
+        # last time map animations were updated
+        self._last_time = 0.0
+        # list of animation tokens
+        self._animation_queue: list[AnimationToken] = []
+        # mapping of tile substitutions when animated
+        self._animated_tile: dict[tuple[int, int, int], Surface] = {}
+        # track the tiles on screen with animations
+        self._tracked_tiles = set()
 
     def reload_data(self) -> None:
         raise NotImplementedError
 
     def process_animation_queue(
         self,
-        tile_view: RectLike,
+        tile_view: Rect,
     ) -> list[tuple[int, int, int, Surface]]:
         """
         Given the time and the tile view, process tile changes and return them
@@ -75,7 +81,7 @@ def process_animation_queue(
         # verify that there are tile substitutions ready
         self._update_time()
         try:
-            if self._animation_queue[0].next > self._last_time:
+            if self._animation_queue[0]._next > self._last_time:
                 return new_tiles
 
         # raised with the animation queue is empty (no animations at all)
@@ -87,7 +93,7 @@ def process_animation_queue(
         get_tile_image = self.get_tile_image
 
         # test if the next scheduled tile change is ready
-        while self._animation_queue[0].next <= self._last_time:
+        while self._animation_queue[0]._next <= self._last_time:
 
             # get the next tile/frame which is ready to be changed
             token = heappop(self._animation_queue)
@@ -134,7 +140,7 @@ def _update_time(self) -> None:
         """
         self._last_time = time.time() * 1000
 
-    def prepare_tiles(self, tiles: RectLike):
+    def prepare_tiles(self, tiles: RectLike) -> None:
         """
         Somewhat experimental: The renderer will advise data layer of its view
 
@@ -158,14 +164,13 @@ def reload_animations(self) -> None:
 
         """
         self._update_time()
-        self._animation_queue = list()
-        self._tracked_gids = set()
-        self._animation_map = dict()
+        self._tracked_gids: set[int] = set()
+        self._animation_map: dict[int, AnimationToken] = {}
 
         for gid, frame_data in self.get_animations():
             self._tracked_gids.add(gid)
 
-            frames = list()
+            frames: list[AnimationFrame] = []
             for frame_gid, frame_duration in frame_data:
                 image = self._get_tile_image_by_id(frame_gid)
                 frames.append(AnimationFrame(image, frame_duration))
@@ -177,7 +182,7 @@ def reload_animations(self) -> None:
             # locations of an animation, but searching for their locations
             # is slow. so it will be updated as the map is drawn.
 
-            positions = set()
+            positions: set[tuple[int, int, int]] = set()
             ani = AnimationToken(positions, frames, self._last_time)
             self._animation_map[gid] = ani
             heappush(self._animation_queue, ani)
@@ -224,7 +229,7 @@ def _get_tile_image(self, x: int, y: int, l: int) -> Surface:
         """
         raise NotImplementedError
 
-    def _get_tile_image_by_id(self, id):
+    def _get_tile_image_by_id(self, id: int) -> Any:
         """
         Return Image by a custom ID.
 
@@ -248,6 +253,9 @@ def get_animations(self) -> None:
           Where Frames is:
           [ (ID, Duration), ... ]
 
+          [tuple[int, tuple[int, float]]]
+          [tuple[gid, tuple[frame_gid, frame_duration]]]
+
           And ID is a reference to a tile image.
           This will be something accessible using _get_tile_image_by_id
 
@@ -348,14 +356,14 @@ def _get_tile_image(self, x: int, y: int, l: int):
         except ValueError:
             return None
 
-    def _get_tile_image_by_id(self, id) -> Surface:
+    def _get_tile_image_by_id(self, id: int) -> Surface:
         return self.tmx.images[id]
 
     def get_tile_images_by_rect(self, rect: RectLike):
-        def rev(seq:list[int], start:int, stop: int) -> enumerate[int]:
+        def rev(seq: list[int], start: int, stop: int) -> enumerate[int]:
             if start < 0:
                 start = 0
-            return enumerate(seq[start:stop + 1], start)
+            return enumerate(seq[start : stop + 1], start)
 
         x1, y1, x2, y2 = rect_to_bb(rect)
         images = self.tmx.images
@@ -411,7 +419,7 @@ def _get_tile_image(self, x: int, y: int, l: int) -> Surface:
         """
         pass
 
-    def _get_tile_image_by_id(self, id) -> None:
+    def _get_tile_image_by_id(self, id: int) -> None:
         """
         Required for sprite collation - not implemented
 

pyscroll/isometric.py

@@ -1,20 +1,21 @@
 import logging
 
+from pyscroll.common import Vector2D, Vector2DInt
 from pyscroll.orthographic import BufferedRenderer
 
 log = logging.getLogger(__file__)
 
 
-def vector3_to_iso(vector3):
-    offset = 0, 0
+def vector3_to_iso(vector3: tuple[int, int, int]) -> tuple[int, int]:
+    offset = (0, 0)
     return (
         (vector3[0] - vector3[1]) + offset[0],
         ((vector3[0] + vector3[1]) >> 1) - vector3[2] + offset[1],
     )
 
 
-def vector2_to_iso(vector2):
-    offset = 0, 0
+def vector2_to_iso(vector2: tuple[int, int]) -> tuple[int, int]:
+    offset = (0, 0)
     return (
         (vector2[0] - vector2[1]) + offset[0],
         ((vector2[0] + vector2[1]) >> 1) + offset[1],
@@ -34,7 +35,7 @@ def _draw_surfaces(self, surface, rect, surfaces) -> None:
         if surfaces is not None:
             [(surface.blit(i[0], i[1]), i[2]) for i in surfaces]
 
-    def _initialize_buffers(self, view_size) -> None:
+    def _initialize_buffers(self, view_size: Vector2DInt) -> None:
         """Create the buffers to cache tile drawing
 
         :param view_size: (int, int): size of the draw area
@@ -85,7 +86,7 @@ def _flush_tile_queue(self) -> None:
             iso_y = (x + y) * thh
             surface_blit(tile, (iso_x, iso_y))
 
-    def center(self, coords) -> None:
+    def center(self, coords: Vector2D) -> None:
         """center the map on a "map pixel" """
         x, y = [round(i, 0) for i in coords]
         self.view_rect.center = x, y
@@ -102,6 +103,7 @@ def center(self, coords) -> None:
         self._y_offset = iso[1]
 
         print(self._tile_view.size)
+        assert self._buffer
         print(self._buffer.get_size())
 
         # center the buffer on the screen