Create a Decorative object class

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

lib/features/renderer/renderer.dart

@@ -3,6 +3,7 @@ import 'dart:math' as math;
 import 'package:flutter/material.dart';
 import 'package:flutter/scheduler.dart';
 import 'package:flutter/services.dart';
+import 'package:wolf_dart/classes/decorative.dart';
 import 'package:wolf_dart/classes/difficulty.dart';
 import 'package:wolf_dart/classes/enemy.dart';
 import 'package:wolf_dart/classes/entity.dart';
@@ -87,43 +88,31 @@ class _WolfRendererState extends State<WolfRenderer>
             case 22:
               playerAngle = math.pi;
           }
-        }
-        // NEW: Populate the Entities!
-        else if (objId >= 23 && objId <= 70) {
-          int calculatedSpriteIndex = objId - 21;
-          if (calculatedSpriteIndex >= 0 &&
-              calculatedSpriteIndex < gameMap.sprites.length) {
+        } // 1. POPULATE DECORATIONS & DEAD BODIES
+        else if (Decorative.isDecoration(objId)) {
+          int spriteIdx = Decorative.getSpriteIndex(objId);
+          if (spriteIdx >= 0 && spriteIdx < gameMap.sprites.length) {
             entities.add(
-              Entity(
+              Decorative(
                 x: x + 0.5,
                 y: y + 0.5,
-                spriteIndex: calculatedSpriteIndex,
-                state: EntityState.staticObj,
+                spriteIndex: spriteIdx,
                 mapId: objId,
+                // NEW: Dynamically assign the state!
+                state: objId == 124 ? EntityState.dead : EntityState.staticObj,
               ),
             );
           }
-        }
-        // NEW: The Dead Guard (FIXED INDEX)
-        else if (objId == 124) {
-          if (95 < gameMap.sprites.length) {
-            entities.add(
-              Entity(
-                x: x + 0.5,
-                y: y + 0.5,
-                spriteIndex: 95,
-                state: EntityState.dead,
-                mapId: objId,
-              ),
-            );
-          }
-        } else if (_isGuardForDifficulty(objId)) {
+        } else if (BrownGuard.isSpawnableForDifficulty(
+          objId,
+          widget.difficulty.level,
+        )) {
           if (50 < gameMap.sprites.length) {
             entities.add(
               BrownGuard(
                 x: x + 0.5,
                 y: y + 0.5,
-                angle: _getGuardAngle(objId),
+                angle: Enemy.getInitialAngle(objId),
                 mapId: objId,
               ),
             );
@@ -291,8 +280,7 @@ class _WolfRendererState extends State<WolfRenderer>
           elapsedMs: elapsed.inMilliseconds,
           player: player,
           isWalkable: _isWalkable,
-          hasLineOfSight: _hasLineOfSight,
-          onDamagePlayer: _takeDamage, // Pass the callback!
+          onDamagePlayer: _takeDamage,
         );
       }
     }
@@ -305,83 +293,6 @@ class _WolfRendererState extends State<WolfRenderer>
     setState(() {});
   }
 
-  bool _isGuardForDifficulty(int objId) {
-    switch (widget.difficulty.level) {
-      case 0: // Baby
-        return objId >= 108 && objId <= 115;
-      case 1: // Easy
-        return objId >= 144 && objId <= 151;
-      case 2: // Normal
-        return objId >= 180 && objId <= 187;
-      case 3: // Hard
-        return objId >= 216 && objId <= 223;
-      default:
-        return false;
-    }
-  }
-
-  // Decodes the Map ID to figure out which way the guard is facing
-  double _getGuardAngle(int objId) {
-    // Normalizes the ID across the 4 difficulty tiers
-    int normalizedId = (objId - 108) % 36;
-    int direction = normalizedId % 4; // 0=East, 1=North, 2=West, 3=South
-
-    // Matches the player spawn angles you already set up
-    switch (direction) {
-      case 0:
-        return 0.0; // East
-      case 1:
-        return 3 * math.pi / 2; // North
-      case 2:
-        return math.pi; // West
-      case 3:
-        return math.pi / 2; // South
-      default:
-        return 0.0;
-    }
-  }
-
-  bool _hasLineOfSight(Entity guard) {
-    double dx = player.x - guard.x;
-    double dy = player.y - guard.y;
-    double distance = math.sqrt(dx * dx + dy * dy);
-
-    // 1. FOV Check (Are you in front of them?)
-    double angleToPlayer = math.atan2(dy, dx);
-    double diff = guard.angle - angleToPlayer;
-
-    while (diff <= -math.pi) {
-      diff += 2 * math.pi;
-    }
-    while (diff > math.pi) {
-      diff -= 2 * math.pi;
-    }
-
-    // A standard guard FOV is about 180 degrees (90 degrees left/right)
-    if (diff.abs() > math.pi / 2) {
-      return false; // You are behind them!
-    }
-
-    // 2. Line of Sight Check (Are there walls in the way?)
-    double dirX = dx / distance;
-    double dirY = dy / distance;
-
-    // Step along the ray in small increments to check for solid blocks
-    double stepSize = 0.2;
-    for (double i = 0; i < distance; i += stepSize) {
-      int checkX = (guard.x + dirX * i).toInt();
-      int checkY = (guard.y + dirY * i).toInt();
-
-      // If we hit a solid wall or closed door, vision is blocked
-      if (!_isWalkable(checkX, checkY)) {
-        return false;
-      }
-    }
-
-    // If we made it all the way to the player without hitting a wall...
-    return true;
-  }
-
   // A helper method to handle getting shot
   void _takeDamage(int damage) {
     playerHealth -= damage;