Adding more enemy types

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

lib/features/entities/enemies/officer.dart

@@ -0,0 +1,156 @@
+import 'dart:math' as math;
+
+import 'package:wolf_dart/classes/coordinate_2d.dart';
+import 'package:wolf_dart/features/difficulty/difficulty.dart';
+import 'package:wolf_dart/features/entities/enemies/enemy.dart';
+import 'package:wolf_dart/features/entities/entity.dart';
+import 'package:wolf_dart/features/entities/map_objects.dart';
+
+class Officer extends Enemy {
+  static const double speed = 0.055;
+  static const int _baseSprite = 50;
+  bool _hasFiredThisCycle = false;
+
+  Officer({
+    required super.x,
+    required super.y,
+    required super.angle,
+    required super.mapId,
+  }) : super(
+         spriteIndex: _baseSprite,
+         state: EntityState.idle,
+       ) {
+    health = 50;
+    damage = 15;
+  }
+
+  static Officer? trySpawn(
+    int objId,
+    double x,
+    double y,
+    Difficulty difficulty,
+  ) {
+    if (objId >= MapObject.officerStart &&
+        objId <= MapObject.officerStart + 35) {
+      bool isPatrolling = objId >= MapObject.officerStart + 18;
+
+      return Officer(
+        x: x,
+        y: y,
+        angle: MapObject.getAngle(objId),
+        mapId: objId,
+      )..state = isPatrolling ? EntityState.patrolling : EntityState.idle;
+    }
+    return null;
+  }
+
+  @override
+  ({Coordinate2D movement, double newAngle}) update({
+    required int elapsedMs,
+    required Coordinate2D playerPosition,
+    required bool Function(int x, int y) isWalkable,
+    required void Function(int damage) onDamagePlayer,
+    required void Function(int x, int y) tryOpenDoor,
+  }) {
+    Coordinate2D movement = const Coordinate2D(0, 0);
+    double newAngle = angle;
+
+    checkWakeUp(
+      elapsedMs: elapsedMs,
+      playerPosition: playerPosition,
+      isWalkable: isWalkable,
+    );
+
+    double distance = position.distanceTo(playerPosition);
+    double angleToPlayer = position.angleTo(playerPosition);
+
+    if (state != EntityState.idle && state != EntityState.dead) {
+      newAngle = angleToPlayer;
+    }
+
+    double diff = angleToPlayer - newAngle;
+    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;
+
+    switch (state) {
+      case EntityState.idle:
+        spriteIndex = _baseSprite + octant;
+        break;
+
+      case EntityState.patrolling:
+        if (distance > 0.8) {
+          double moveX = math.cos(angleToPlayer) * speed;
+          double moveY = math.sin(angleToPlayer) * speed;
+          movement = getValidMovement(
+            Coordinate2D(moveX, moveY),
+            isWalkable,
+            tryOpenDoor,
+          );
+        }
+
+        int walkFrame = (elapsedMs ~/ 150) % 4;
+        spriteIndex = (_baseSprite + 8) + (walkFrame * 8) + octant;
+
+        if (distance < 6.0 && elapsedMs - lastActionTime > 1000) {
+          if (hasLineOfSight(playerPosition, isWalkable)) {
+            state = EntityState.attacking;
+            lastActionTime = elapsedMs;
+            _hasFiredThisCycle = false;
+          }
+        }
+        break;
+
+      case EntityState.attacking:
+        int timeShooting = elapsedMs - lastActionTime;
+        if (timeShooting < 150) {
+          spriteIndex = _baseSprite + 46; // Aiming
+        } else if (timeShooting < 300) {
+          spriteIndex = _baseSprite + 47; // Firing
+          if (!_hasFiredThisCycle) {
+            onDamagePlayer(damage);
+            _hasFiredThisCycle = true;
+          }
+        } else if (timeShooting < 450) {
+          spriteIndex = _baseSprite + 48; // Recoil
+        } else {
+          state = EntityState.patrolling;
+          lastActionTime = elapsedMs;
+        }
+        break;
+
+      case EntityState.pain:
+        spriteIndex = _baseSprite + 44;
+        if (elapsedMs - lastActionTime > 250) {
+          state = EntityState.patrolling;
+          lastActionTime = elapsedMs;
+        }
+        break;
+
+      case EntityState.dead:
+        if (isDying) {
+          int deathFrame = (elapsedMs - lastActionTime) ~/ 150;
+          if (deathFrame < 4) {
+            spriteIndex = (_baseSprite + 40) + deathFrame;
+          } else {
+            spriteIndex = _baseSprite + 45;
+            isDying = false;
+          }
+        } else {
+          spriteIndex = _baseSprite + 45;
+        }
+        break;
+
+      default:
+        break;
+    }
+
+    return (movement: movement, newAngle: newAngle);
+  }
+}