zombie-escape 1.5.0__tar.gz → 1.5.4__tar.gz

{zombie_escape-1.5.0 → zombie_escape-1.5.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: zombie-escape
-Version: 1.5.0
+Version: 1.5.4
 Summary: Top-down zombie survival game built with pygame.
 Project-URL: Homepage, https://github.com/tos-kamiya/zombie-escape
 Author-email: Toshihiro Kamiya <kamiya@mbj.nifty.com>
@@ -48,7 +48,7 @@ This game is a simple 2D top-down action game where the player aims to escape by
 -   **Enter Car:** Overlap the player with the car.
 -   **Quit Game:** `ESC` key
 -   **Restart:** `R` key (on Game Over/Clear screen)
--   **Window Scale (title/settings only):** `[` to shrink, `]` to enlarge
+-   **Window/Fullscreen (title/settings only):** `[` to shrink, `]` to enlarge, `F` to toggle fullscreen
 -   **Time Acceleration:** Hold either `Shift` key to run the entire world 4x faster; release to return to normal speed.
 
 ## Title Screen
@@ -142,10 +142,6 @@ Launch using the following command line:
 zombie-escape
 ```
 
-### Debug Mode
-
-<!-- For Stage 5 balancing or capture needs, run `zombie-escape --debug`. This hides the pause overlay and starts survival stages with 3 minutes remaining so you can immediately test late-night behavior. -->
-
 ## License
 
 This project is licensed under the MIT License - see the [LICENSE.txt](LICENSE.txt) file for details.

{zombie_escape-1.5.0 → zombie_escape-1.5.4}/README.md

@@ -26,7 +26,7 @@ This game is a simple 2D top-down action game where the player aims to escape by
 -   **Enter Car:** Overlap the player with the car.
 -   **Quit Game:** `ESC` key
 -   **Restart:** `R` key (on Game Over/Clear screen)
--   **Window Scale (title/settings only):** `[` to shrink, `]` to enlarge
+-   **Window/Fullscreen (title/settings only):** `[` to shrink, `]` to enlarge, `F` to toggle fullscreen
 -   **Time Acceleration:** Hold either `Shift` key to run the entire world 4x faster; release to return to normal speed.
 
 ## Title Screen
@@ -120,10 +120,6 @@ Launch using the following command line:
 zombie-escape
 ```
 
-### Debug Mode
-
-<!-- For Stage 5 balancing or capture needs, run `zombie-escape --debug`. This hides the pause overlay and starts survival stages with 3 minutes remaining so you can immediately test late-night behavior. -->
-
 ## License
 
 This project is licensed under the MIT License - see the [LICENSE.txt](LICENSE.txt) file for details.

{zombie_escape-1.5.0 → zombie_escape-1.5.4}/src/zombie_escape/__about__.py

@@ -1,4 +1,4 @@
 # SPDX-FileCopyrightText: 2025-present Toshihiro Kamiya <kamiya@mbj.nifty.com>
 #
 # SPDX-License-Identifier: MIT
-__version__ = "1.5.0"
+__version__ = "1.5.4"

{zombie_escape-1.5.0 → zombie_escape-1.5.4}/src/zombie_escape/colors.py

@@ -13,6 +13,8 @@ LIGHT_GRAY: tuple[int, int, int] = (200, 200, 200)
 YELLOW: tuple[int, int, int] = (255, 255, 0)
 ORANGE: tuple[int, int, int] = (255, 165, 0)
 DARK_RED: tuple[int, int, int] = (139, 0, 0)
+TRACKER_OUTLINE_COLOR: tuple[int, int, int] = (170, 70, 220)
+WALL_FOLLOWER_OUTLINE_COLOR: tuple[int, int, int] = (140, 140, 140)
 
 
 @dataclass(frozen=True)
@@ -146,6 +148,8 @@ __all__ = [
     "YELLOW",
     "ORANGE",
     "DARK_RED",
+    "TRACKER_OUTLINE_COLOR",
+    "WALL_FOLLOWER_OUTLINE_COLOR",
     "DAWN_AMBIENT_PALETTE_KEY",
     "INTERNAL_WALL_COLOR",
     "INTERNAL_WALL_BORDER_COLOR",

{zombie_escape-1.5.0 → zombie_escape-1.5.4}/src/zombie_escape/entities.py

@@ -18,6 +18,8 @@ from .colors import (
     RED,
     STEEL_BEAM_COLOR,
     STEEL_BEAM_LINE_COLOR,
+    TRACKER_OUTLINE_COLOR,
+    WALL_FOLLOWER_OUTLINE_COLOR,
     YELLOW,
 )
 from .gameplay_constants import (
@@ -26,9 +28,9 @@ from .gameplay_constants import (
     CAR_SPEED,
     CAR_WALL_DAMAGE,
     CAR_WIDTH,
-    COMPANION_COLOR,
-    COMPANION_FOLLOW_SPEED,
-    COMPANION_RADIUS,
+    BUDDY_COLOR,
+    BUDDY_FOLLOW_SPEED,
+    BUDDY_RADIUS,
     FAST_ZOMBIE_BASE_SPEED,
     FLASHLIGHT_HEIGHT,
     FLASHLIGHT_WIDTH,
@@ -57,7 +59,10 @@ from .gameplay_constants import (
     ZOMBIE_TRACKER_WANDER_INTERVAL_MS,
     ZOMBIE_WALL_DAMAGE,
     ZOMBIE_WALL_FOLLOW_LOST_WALL_MS,
+    ZOMBIE_WALL_FOLLOW_PROBE_ANGLE_DEG,
+    ZOMBIE_WALL_FOLLOW_PROBE_STEP,
     ZOMBIE_WALL_FOLLOW_SENSOR_DISTANCE,
+    ZOMBIE_WALL_FOLLOW_TARGET_GAP,
     ZOMBIE_WANDER_INTERVAL_MS,
     car_body_radius,
 )
@@ -71,6 +76,50 @@ MovementStrategy = Callable[
     ["Zombie", tuple[int, int], list["Wall"], list[dict[str, object]]],
     tuple[float, float],
 ]
+WallIndex = dict[tuple[int, int], list["Wall"]]
+
+
+def build_wall_index(walls: Iterable["Wall"]) -> WallIndex:
+    index: WallIndex = {}
+    for wall in walls:
+        if not wall.alive():
+            continue
+        cell_x = int(wall.rect.centerx // CELL_SIZE)
+        cell_y = int(wall.rect.centery // CELL_SIZE)
+        index.setdefault((cell_x, cell_y), []).append(wall)
+    return index
+
+
+def _sprite_center_and_radius(
+    sprite: pygame.sprite.Sprite,
+) -> tuple[tuple[int, int], float]:
+    center = sprite.rect.center
+    radius = float(
+        getattr(sprite, "radius", max(sprite.rect.width, sprite.rect.height) / 2)
+    )
+    return center, radius
+
+
+def walls_for_radius(
+    wall_index: WallIndex, center: tuple[float, float], radius: float
+) -> list["Wall"]:
+    search_radius = radius + CELL_SIZE
+    min_x = max(0, int((center[0] - search_radius) // CELL_SIZE))
+    max_x = min(GRID_COLS - 1, int((center[0] + search_radius) // CELL_SIZE))
+    min_y = max(0, int((center[1] - search_radius) // CELL_SIZE))
+    max_y = min(GRID_ROWS - 1, int((center[1] + search_radius) // CELL_SIZE))
+    candidates: list[Wall] = []
+    for cy in range(min_y, max_y + 1):
+        for cx in range(min_x, max_x + 1):
+            candidates.extend(wall_index.get((cx, cy), []))
+    return candidates
+
+
+def _walls_for_sprite(
+    sprite: pygame.sprite.Sprite, wall_index: WallIndex
+) -> list["Wall"]:
+    center, radius = _sprite_center_and_radius(sprite)
+    return walls_for_radius(wall_index, center, radius)
 
 
 def circle_rect_collision(
@@ -108,7 +157,7 @@ def _build_beveled_polygon(
     if d == 0 or not any(bevels):
         return [(0, 0), (width, 0), (width, height), (0, height)]
 
-    segments = max(4, d // 2)
+    segments = 4
     tl, tr, br, bl = bevels
     points: list[tuple[int, int]] = []
 
@@ -311,17 +360,36 @@ def spritecollide_walls(
     walls: pygame.sprite.Group,
     *,
     dokill: bool = False,
+    wall_index: WallIndex | None = None,
 ) -> list[pygame.sprite.Sprite]:
-    return pygame.sprite.spritecollide(
-        sprite, walls, dokill, collided=collide_sprite_wall
-    )
+    if wall_index is None:
+        return pygame.sprite.spritecollide(
+            sprite, walls, dokill, collided=collide_sprite_wall
+        )
+    candidates = _walls_for_sprite(sprite, wall_index)
+    if not candidates:
+        return []
+    hit_list = [wall for wall in candidates if collide_sprite_wall(sprite, wall)]
+    if dokill:
+        for wall in hit_list:
+            wall.kill()
+    return hit_list
 
 
 def spritecollideany_walls(
     sprite: pygame.sprite.Sprite,
     walls: pygame.sprite.Group,
+    *,
+    wall_index: WallIndex | None = None,
 ) -> pygame.sprite.Sprite | None:
-    return pygame.sprite.spritecollideany(sprite, walls, collided=collide_sprite_wall)
+    if wall_index is None:
+        return pygame.sprite.spritecollideany(
+            sprite, walls, collided=collide_sprite_wall
+        )
+    for wall in _walls_for_sprite(sprite, wall_index):
+        if collide_sprite_wall(sprite, wall):
+            return wall
+    return None
 
 
 def circle_wall_collision(
@@ -490,8 +558,10 @@ class Wall(pygame.sprite.Sprite):
         return rect_polygon_collision(rect_obj, self._collision_polygon)
 
     def collides_circle(self: Self, center: tuple[float, float], radius: float) -> bool:
+        if not circle_rect_collision(center, radius, self.rect):
+            return False
         if self._collision_polygon is None:
-            return circle_rect_collision(center, radius, self.rect)
+            return True
         return circle_polygon_collision(center, radius, self._collision_polygon)
 
     def set_palette_colors(
@@ -621,7 +691,14 @@ class Player(pygame.sprite.Sprite):
         self.x = float(self.rect.centerx)
         self.y = float(self.rect.centery)
 
-    def move(self: Self, dx: float, dy: float, walls: pygame.sprite.Group) -> None:
+    def move(
+        self: Self,
+        dx: float,
+        dy: float,
+        walls: pygame.sprite.Group,
+        *,
+        wall_index: WallIndex | None = None,
+    ) -> None:
         if self.in_car:
             return
 
@@ -629,7 +706,7 @@ class Player(pygame.sprite.Sprite):
             self.x += dx
             self.x = min(LEVEL_WIDTH, max(0, self.x))
             self.rect.centerx = int(self.x)
-            hit_list_x = spritecollide_walls(self, walls)
+            hit_list_x = spritecollide_walls(self, walls, wall_index=wall_index)
             if hit_list_x:
                 damage = max(1, PLAYER_WALL_DAMAGE // len(hit_list_x))
                 for wall in hit_list_x:
@@ -642,7 +719,7 @@ class Player(pygame.sprite.Sprite):
             self.y += dy
             self.y = min(LEVEL_HEIGHT, max(0, self.y))
             self.rect.centery = int(self.y)
-            hit_list_y = spritecollide_walls(self, walls)
+            hit_list_y = spritecollide_walls(self, walls, wall_index=wall_index)
             if hit_list_y:
                 damage = max(1, PLAYER_WALL_DAMAGE // len(hit_list_y))
                 for wall in hit_list_y:
@@ -654,18 +731,20 @@ class Player(pygame.sprite.Sprite):
         self.rect.center = (int(self.x), int(self.y))
 
 
-class Companion(pygame.sprite.Sprite):
-    """Simple survivor sprite used in Stage 3."""
+class Survivor(pygame.sprite.Sprite):
+    """Civilians that gather near the player; optional buddy behavior."""
 
-    def __init__(self: Self, x: float, y: float) -> None:
+    def __init__(self: Self, x: float, y: float, *, is_buddy: bool = False) -> None:
         super().__init__()
-        self.radius = COMPANION_RADIUS
+        self.is_buddy = is_buddy
+        self.radius = BUDDY_RADIUS if is_buddy else SURVIVOR_RADIUS
         self.image = pygame.Surface((self.radius * 2, self.radius * 2), pygame.SRCALPHA)
+        fill_color = BUDDY_COLOR if is_buddy else SURVIVOR_COLOR
         _draw_outlined_circle(
             self.image,
             (self.radius, self.radius),
             self.radius,
-            COMPANION_COLOR,
+            fill_color,
             HUMANOID_OUTLINE_COLOR,
             HUMANOID_OUTLINE_WIDTH,
         )
@@ -676,88 +755,71 @@ class Companion(pygame.sprite.Sprite):
         self.rescued = False
 
     def set_following(self: Self) -> None:
-        if not self.rescued:
+        if self.is_buddy and not self.rescued:
             self.following = True
 
     def mark_rescued(self: Self) -> None:
-        self.following = False
-        self.rescued = True
+        if self.is_buddy:
+            self.following = False
+            self.rescued = True
 
     def teleport(self: Self, pos: tuple[int, int]) -> None:
-        """Reposition the companion (used for quiet respawns)."""
+        """Reposition the survivor (used for quiet respawns)."""
         self.x, self.y = float(pos[0]), float(pos[1])
         self.rect.center = (int(self.x), int(self.y))
-        self.following = False
+        if self.is_buddy:
+            self.following = False
 
-    def update_follow(
-        self: Self, target_pos: tuple[float, float], walls: pygame.sprite.Group
+    def update_behavior(
+        self: Self,
+        player_pos: tuple[int, int],
+        walls: pygame.sprite.Group,
+        *,
+        wall_index: WallIndex | None = None,
     ) -> None:
-        """Follow the target at a slightly slower speed than the player."""
-        if self.rescued or not self.following:
-            self.rect.center = (int(self.x), int(self.y))
-            return
+        if self.is_buddy:
+            if self.rescued or not self.following:
+                self.rect.center = (int(self.x), int(self.y))
+                return
 
-        dx = target_pos[0] - self.x
-        dy = target_pos[1] - self.y
-        dist = math.hypot(dx, dy)
-        if dist <= 0:
-            self.rect.center = (int(self.x), int(self.y))
-            return
+            dx = player_pos[0] - self.x
+            dy = player_pos[1] - self.y
+            dist = math.hypot(dx, dy)
+            if dist <= 0:
+                self.rect.center = (int(self.x), int(self.y))
+                return
 
-        move_x = (dx / dist) * COMPANION_FOLLOW_SPEED
-        move_y = (dy / dist) * COMPANION_FOLLOW_SPEED
+            move_x = (dx / dist) * BUDDY_FOLLOW_SPEED
+            move_y = (dy / dist) * BUDDY_FOLLOW_SPEED
 
-        if move_x != 0:
-            self.x += move_x
-            self.rect.centerx = int(self.x)
-            if spritecollideany_walls(self, walls):
-                self.x -= move_x
+            if move_x:
+                self.x += move_x
                 self.rect.centerx = int(self.x)
-        if move_y != 0:
-            self.y += move_y
-            self.rect.centery = int(self.y)
-            if spritecollideany_walls(self, walls):
-                self.y -= move_y
+                if spritecollideany_walls(self, walls, wall_index=wall_index):
+                    self.x -= move_x
+                    self.rect.centerx = int(self.x)
+            if move_y:
+                self.y += move_y
                 self.rect.centery = int(self.y)
+                if spritecollideany_walls(self, walls, wall_index=wall_index):
+                    self.y -= move_y
+                    self.rect.centery = int(self.y)
+
+            overlap_radius = (self.radius + PLAYER_RADIUS) * 1.05
+            dx_after = player_pos[0] - self.x
+            dy_after = player_pos[1] - self.y
+            dist_after = math.hypot(dx_after, dy_after)
+            if dist_after > 0 and dist_after < overlap_radius:
+                push_dist = overlap_radius - dist_after
+                self.x -= (dx_after / dist_after) * push_dist
+                self.y -= (dy_after / dist_after) * push_dist
+                self.rect.center = (int(self.x), int(self.y))
 
-        # Avoid fully overlapping the player target
-        overlap_radius = (self.radius + PLAYER_RADIUS) * 1.05
-        dx_after = target_pos[0] - self.x
-        dy_after = target_pos[1] - self.y
-        dist_after = math.hypot(dx_after, dy_after)
-        if dist_after > 0 and dist_after < overlap_radius:
-            push_dist = overlap_radius - dist_after
-            self.x -= (dx_after / dist_after) * push_dist
-            self.y -= (dy_after / dist_after) * push_dist
+            self.x = min(LEVEL_WIDTH, max(0, self.x))
+            self.y = min(LEVEL_HEIGHT, max(0, self.y))
             self.rect.center = (int(self.x), int(self.y))
+            return
 
-        self.x = min(LEVEL_WIDTH, max(0, self.x))
-        self.y = min(LEVEL_HEIGHT, max(0, self.y))
-        self.rect.center = (int(self.x), int(self.y))
-
-
-class Survivor(pygame.sprite.Sprite):
-    """Civilians that gather near the player during Stage 4."""
-
-    def __init__(self: Self, x: float, y: float) -> None:
-        super().__init__()
-        self.radius = SURVIVOR_RADIUS
-        self.image = pygame.Surface((self.radius * 2, self.radius * 2), pygame.SRCALPHA)
-        _draw_outlined_circle(
-            self.image,
-            (self.radius, self.radius),
-            self.radius,
-            SURVIVOR_COLOR,
-            HUMANOID_OUTLINE_COLOR,
-            HUMANOID_OUTLINE_WIDTH,
-        )
-        self.rect = self.image.get_rect(center=(int(x), int(y)))
-        self.x = float(self.rect.centerx)
-        self.y = float(self.rect.centery)
-
-    def update_behavior(
-        self: Self, player_pos: tuple[int, int], walls: pygame.sprite.Group
-    ) -> None:
         dx = player_pos[0] - self.x
         dy = player_pos[1] - self.y
         dist = math.hypot(dx, dy)
@@ -770,13 +832,13 @@ class Survivor(pygame.sprite.Sprite):
         if move_x:
             self.x += move_x
             self.rect.centerx = int(self.x)
-            if spritecollideany_walls(self, walls):
+            if spritecollideany_walls(self, walls, wall_index=wall_index):
                 self.x -= move_x
                 self.rect.centerx = int(self.x)
         if move_y:
             self.y += move_y
             self.rect.centery = int(self.y)
-            if spritecollideany_walls(self, walls):
+            if spritecollideany_walls(self, walls, wall_index=wall_index):
                 self.y -= move_y
                 self.rect.centery = int(self.y)
 
@@ -832,6 +894,38 @@ def zombie_wall_follow_has_wall(
     )
 
 
+def zombie_wall_follow_wall_distance(
+    zombie: Zombie,
+    walls: list[Wall],
+    angle: float,
+    max_distance: float,
+    *,
+    step: float = ZOMBIE_WALL_FOLLOW_PROBE_STEP,
+) -> float:
+    direction_x = math.cos(angle)
+    direction_y = math.sin(angle)
+    max_search = max_distance + 120
+    candidates = [
+        wall
+        for wall in walls
+        if abs(wall.rect.centerx - zombie.x) < max_search
+        and abs(wall.rect.centery - zombie.y) < max_search
+    ]
+    if not candidates:
+        return max_distance
+    distance = step
+    while distance <= max_distance:
+        check_x = zombie.x + direction_x * distance
+        check_y = zombie.y + direction_y * distance
+        if any(
+            circle_wall_collision((check_x, check_y), zombie.radius, wall)
+            for wall in candidates
+        ):
+            return distance
+        distance += step
+    return max_distance
+
+
 def zombie_wall_follow_movement(
     zombie: Zombie,
     player_center: tuple[int, int],
@@ -844,22 +938,28 @@ def zombie_wall_follow_movement(
     if zombie.wall_follow_side == 0:
         sensor_distance = ZOMBIE_WALL_FOLLOW_SENSOR_DISTANCE + zombie.radius
         forward_angle = zombie.wall_follow_angle
-        left_angle = forward_angle + math.pi / 2.0
-        right_angle = forward_angle - math.pi / 2.0
-        left_wall = zombie_wall_follow_has_wall(
+        probe_offset = math.radians(ZOMBIE_WALL_FOLLOW_PROBE_ANGLE_DEG)
+        left_angle = forward_angle + probe_offset
+        right_angle = forward_angle - probe_offset
+        left_dist = zombie_wall_follow_wall_distance(
             zombie, walls, left_angle, sensor_distance
         )
-        right_wall = zombie_wall_follow_has_wall(
+        right_dist = zombie_wall_follow_wall_distance(
             zombie, walls, right_angle, sensor_distance
         )
-        forward_wall = zombie_wall_follow_has_wall(
+        forward_dist = zombie_wall_follow_wall_distance(
             zombie, walls, forward_angle, sensor_distance
         )
+        left_wall = left_dist < sensor_distance
+        right_wall = right_dist < sensor_distance
+        forward_wall = forward_dist < sensor_distance
         if left_wall or right_wall or forward_wall:
             if left_wall and not right_wall:
                 zombie.wall_follow_side = 1.0
             elif right_wall and not left_wall:
                 zombie.wall_follow_side = -1.0
+            elif left_wall and right_wall:
+                zombie.wall_follow_side = 1.0 if left_dist <= right_dist else -1.0
             else:
                 zombie.wall_follow_side = RNG.choice([-1.0, 1.0])
             zombie.wall_follow_last_wall_time = pygame.time.get_ticks()
@@ -870,13 +970,16 @@ def zombie_wall_follow_movement(
             return zombie_wander_move(zombie, walls)
 
     sensor_distance = ZOMBIE_WALL_FOLLOW_SENSOR_DISTANCE + zombie.radius
-    side_angle = zombie.wall_follow_angle + zombie.wall_follow_side * (math.pi / 2.0)
-    side_has_wall = zombie_wall_follow_has_wall(
+    probe_offset = math.radians(ZOMBIE_WALL_FOLLOW_PROBE_ANGLE_DEG)
+    side_angle = zombie.wall_follow_angle + zombie.wall_follow_side * probe_offset
+    side_dist = zombie_wall_follow_wall_distance(
         zombie, walls, side_angle, sensor_distance
     )
-    forward_has_wall = zombie_wall_follow_has_wall(
+    forward_dist = zombie_wall_follow_wall_distance(
         zombie, walls, zombie.wall_follow_angle, sensor_distance
     )
+    side_has_wall = side_dist < sensor_distance
+    forward_has_wall = forward_dist < sensor_distance
     now = pygame.time.get_ticks()
     wall_recent = (
         zombie.wall_follow_last_wall_time is not None
@@ -890,16 +993,22 @@ def zombie_wall_follow_movement(
         zombie.wall_follow_last_wall_time = now
     if side_has_wall:
         zombie.wall_follow_last_side_has_wall = True
+        gap_error = ZOMBIE_WALL_FOLLOW_TARGET_GAP - side_dist
+        if abs(gap_error) > 0.1:
+            ratio = min(1.0, abs(gap_error) / ZOMBIE_WALL_FOLLOW_TARGET_GAP)
+            turn = turn_step * ratio
+            if gap_error > 0:
+                zombie.wall_follow_angle -= zombie.wall_follow_side * turn
+            else:
+                zombie.wall_follow_angle += zombie.wall_follow_side * turn
+        if forward_dist < ZOMBIE_WALL_FOLLOW_TARGET_GAP:
+            zombie.wall_follow_angle -= zombie.wall_follow_side * (turn_step * 1.5)
+    else:
+        zombie.wall_follow_last_side_has_wall = False
         if forward_has_wall:
             zombie.wall_follow_angle -= zombie.wall_follow_side * turn_step
-    else:
-        if wall_recent:
-            if zombie.wall_follow_last_side_has_wall and not forward_has_wall:
-                zombie.wall_follow_angle += zombie.wall_follow_side * (math.pi / 2.0)
-                zombie.wall_follow_last_side_has_wall = False
-            elif zombie.wall_follow_last_side_has_wall:
-                zombie.wall_follow_angle += zombie.wall_follow_side * turn_step
-                zombie.wall_follow_last_side_has_wall = False
+        elif wall_recent:
+            zombie.wall_follow_angle += zombie.wall_follow_side * (turn_step * 0.75)
         else:
             zombie.wall_follow_angle += zombie.wall_follow_side * (math.pi / 2.0)
             zombie.wall_follow_side = 0.0
@@ -1037,7 +1146,20 @@ class Zombie(pygame.sprite.Sprite):
         super().__init__()
         self.radius = ZOMBIE_RADIUS
         self.image = pygame.Surface((self.radius * 2, self.radius * 2), pygame.SRCALPHA)
-        pygame.draw.circle(self.image, RED, (self.radius, self.radius), self.radius)
+        if tracker:
+            outline_color = TRACKER_OUTLINE_COLOR
+        elif wall_follower:
+            outline_color = WALL_FOLLOWER_OUTLINE_COLOR
+        else:
+            outline_color = DARK_RED
+        _draw_outlined_circle(
+            self.image,
+            (self.radius, self.radius),
+            self.radius,
+            RED,
+            outline_color,
+            1,
+        )
         if start_pos:
             x, y = start_pos
         elif hint_pos:
@@ -1443,7 +1565,6 @@ __all__ = [
     "SteelBeam",
     "Camera",
     "Player",
-    "Companion",
     "Survivor",
     "Zombie",
     "Car",