Break out spawnable entities and use a registry to spawn them.

Signed-off-by: Hans Kokx <hans.d.kokx@gmail.com>

lib/features/entities/decorative.dart

@@ -0,0 +1,42 @@
+import 'package:wolf_dart/features/entities/entity.dart';
+
+class Decorative extends Entity {
+  Decorative({
+    required super.x,
+    required super.y,
+    required super.spriteIndex,
+    required super.mapId,
+    super.state = EntityState.staticObj, // Defaults to static
+  });
+
+  // Checks if the Map ID belongs to a standard decoration
+  static bool isDecoration(int objId) {
+    return (objId >= 23 && objId <= 70) || objId == 124;
+  }
+
+  // Safely calculates the VSWAP sprite index for standard decorations
+  static int getSpriteIndex(int objId) {
+    if (objId == 124) return 95; // Dead guard
+    return objId - 21;
+  }
+
+  static Decorative? trySpawn(
+    int objId,
+    double x,
+    double y,
+    int difficultyLevel,
+  ) {
+    if (isDecoration(objId)) {
+      return Decorative(
+        x: x,
+        y: y,
+        spriteIndex: getSpriteIndex(objId),
+        mapId: objId,
+        state: objId == 124 ? EntityState.dead : EntityState.staticObj,
+      );
+    }
+
+    // Not a decoration!
+    return null;
+  }
+}

lib/features/entities/enemies/brown_guard.dart

@@ -0,0 +1,137 @@
+import 'dart:math' as math;
+
+import 'package:wolf_dart/classes/linear_coordinates.dart';
+import 'package:wolf_dart/features/entities/enemies/enemy.dart';
+import 'package:wolf_dart/features/entities/entity.dart';
+
+class BrownGuard extends Enemy {
+  static const double speed = 0.03;
+  bool _hasFiredThisCycle = false;
+
+  BrownGuard({
+    required super.x,
+    required super.y,
+    required super.angle,
+    required super.mapId,
+  }) : super(
+         // Default front-facing idle
+         spriteIndex: 50,
+         state: EntityState.idle,
+       );
+
+  static BrownGuard? trySpawn(
+    int objId,
+    double x,
+    double y,
+    int difficultyLevel,
+  ) {
+    bool canSpawn = false;
+    switch (difficultyLevel) {
+      case 0:
+        canSpawn = objId >= 108 && objId <= 115;
+        break;
+      case 1:
+        canSpawn = objId >= 144 && objId <= 151;
+        break;
+      case 2:
+        canSpawn = objId >= 180 && objId <= 187;
+        break;
+      case 3:
+        canSpawn = objId >= 216 && objId <= 223;
+        break;
+    }
+
+    if (canSpawn) {
+      return BrownGuard(
+        x: x,
+        y: y,
+        angle: Enemy.getInitialAngle(objId),
+        mapId: objId,
+      );
+    }
+    return null; // Not a Brown Guard!
+  }
+
+  @override
+  void update({
+    required int elapsedMs,
+    required LinearCoordinates player,
+    required bool Function(int x, int y) isWalkable,
+    required void Function(int damage) onDamagePlayer,
+  }) {
+    // 1. Wake up if the player is spotted!
+    if (state == EntityState.idle) {
+      // Look how clean this is now:
+      if (hasLineOfSight(player, isWalkable)) {
+        state = EntityState.patrolling;
+        lastActionTime = elapsedMs;
+      }
+    }
+
+    // 2. State-based Logic & Animation
+    if (state == EntityState.idle ||
+        state == EntityState.patrolling ||
+        state == EntityState.shooting) {
+      double dx = player.x - x;
+      double dy = player.y - y;
+      double distance = math.sqrt(dx * dx + dy * dy);
+      double angleToPlayer = math.atan2(dy, dx);
+
+      if (state == EntityState.patrolling || state == EntityState.shooting) {
+        angle = angleToPlayer;
+      }
+
+      double diff = angle - angleToPlayer;
+      while (diff <= -math.pi) {
+        diff += 2 * math.pi;
+      }
+      while (diff > math.pi) {
+        diff -= 2 * math.pi;
+      }
+
+      int octant = ((diff + (math.pi / 8)) / (math.pi / 4)).floor() % 8;
+      if (octant < 0) octant += 8;
+
+      if (state == EntityState.idle) {
+        spriteIndex = 50 + octant;
+      } else if (state == EntityState.patrolling) {
+        if (distance > 0.8) {
+          double moveX = x + math.cos(angle) * speed;
+          double moveY = y + math.sin(angle) * speed;
+
+          if (isWalkable(moveX.toInt(), y.toInt())) x = moveX;
+          if (isWalkable(x.toInt(), moveY.toInt())) y = moveY;
+        }
+
+        int walkFrame = (elapsedMs ~/ 150) % 4;
+        spriteIndex = 58 + (walkFrame * 8) + octant;
+
+        if (distance < 5.0 && elapsedMs - lastActionTime > 2000) {
+          // Clean call here too:
+          if (hasLineOfSight(player, isWalkable)) {
+            state = EntityState.shooting;
+            lastActionTime = elapsedMs;
+            _hasFiredThisCycle = false;
+          }
+        }
+      } else if (state == EntityState.shooting) {
+        int timeShooting = elapsedMs - lastActionTime;
+
+        if (timeShooting < 150) {
+          spriteIndex = 96;
+        } else if (timeShooting < 300) {
+          spriteIndex = 97;
+          if (!_hasFiredThisCycle) {
+            onDamagePlayer(10);
+            _hasFiredThisCycle = true;
+          }
+        } else if (timeShooting < 450) {
+          spriteIndex = 98;
+        } else {
+          state = EntityState.patrolling;
+          lastActionTime = elapsedMs;
+        }
+      }
+    }
+  }
+}

lib/features/entities/enemies/enemy.dart

@@ -0,0 +1,79 @@
+import 'dart:math' as math;
+
+import 'package:wolf_dart/classes/linear_coordinates.dart';
+import 'package:wolf_dart/features/entities/entity.dart';
+
+abstract class Enemy extends Entity {
+  Enemy({
+    required super.x,
+    required super.y,
+    required super.spriteIndex,
+    super.angle,
+    super.state,
+    super.mapId,
+    super.lastActionTime,
+  });
+
+  // Decodes the Map ID to figure out which way the enemy is facing
+  static double getInitialAngle(int objId) {
+    int normalizedId = (objId - 108) % 36;
+    int direction = normalizedId % 4; // 0=East, 1=North, 2=West, 3=South
+
+    switch (direction) {
+      case 0:
+        return 0.0;
+      case 1:
+        return 3 * math.pi / 2;
+      case 2:
+        return math.pi;
+      case 3:
+        return math.pi / 2;
+      default:
+        return 0.0;
+    }
+  }
+
+  // The enemy can now check its own line of sight!
+  bool hasLineOfSight(
+    LinearCoordinates player,
+    bool Function(int x, int y) isWalkable,
+  ) {
+    double dx = player.x - x;
+    double dy = player.y - y;
+    double distance = math.sqrt(dx * dx + dy * dy);
+
+    // 1. FOV Check
+    double angleToPlayer = math.atan2(dy, dx);
+    double diff = angle - angleToPlayer;
+
+    while (diff <= -math.pi) {
+      diff += 2 * math.pi;
+    }
+    while (diff > math.pi) {
+      diff -= 2 * math.pi;
+    }
+
+    if (diff.abs() > math.pi / 2) return false;
+
+    // 2. Map Check
+    double dirX = dx / distance;
+    double dirY = dy / distance;
+    double stepSize = 0.2;
+    for (double i = 0; i < distance; i += stepSize) {
+      int checkX = (x + dirX * i).toInt();
+      int checkY = (y + dirY * i).toInt();
+
+      if (!isWalkable(checkX, checkY)) return false;
+    }
+
+    return true;
+  }
+
+  // Update signature is cleaner now
+  void update({
+    required int elapsedMs,
+    required LinearCoordinates player,
+    required bool Function(int x, int y) isWalkable,
+    required void Function(int damage) onDamagePlayer,
+  });
+}

lib/features/entities/entity.dart

@@ -0,0 +1,21 @@
+enum EntityState { staticObj, idle, patrolling, shooting, pain, dead }
+
+abstract class Entity<T> {
+  double x;
+  double y;
+  int spriteIndex;
+  double angle;
+  EntityState state;
+  int mapId;
+  int lastActionTime;
+
+  Entity({
+    required this.x,
+    required this.y,
+    required this.spriteIndex,
+    this.angle = 0.0,
+    this.state = EntityState.staticObj,
+    this.mapId = 0,
+    this.lastActionTime = 0,
+  });
+}

lib/features/entities/entity_registry.dart

@@ -0,0 +1,35 @@
+import 'package:wolf_dart/features/entities/decorative.dart';
+import 'package:wolf_dart/features/entities/enemies/brown_guard.dart';
+import 'package:wolf_dart/features/entities/entity.dart';
+
+typedef EntitySpawner =
+    Entity? Function(int objId, double x, double y, int difficultyLevel);
+
+abstract class EntityRegistry {
+  // Add future enemies (SSGuard, Dog, etc.) to this list!
+  static final List<EntitySpawner> _spawners = [
+    Decorative.trySpawn,
+    BrownGuard.trySpawn,
+  ];
+
+  static Entity? spawn(
+    int objId,
+    double x,
+    double y,
+    int difficultyLevel,
+    int maxSprites,
+  ) {
+    for (final spawner in _spawners) {
+      Entity? entity = spawner(objId, x, y, difficultyLevel);
+
+      if (entity != null) {
+        // Safety bounds check for the VSWAP array
+        if (entity.spriteIndex >= 0 && entity.spriteIndex < maxSprites) {
+          return entity;
+        }
+        return null; // VSWAP doesn't have this sprite!
+      }
+    }
+    return null; // No class claimed this Map ID
+  }
+}