Add test coverage for TargetingSystem

src/scenes/systems/__tests__/TargetingSystem.test.ts

@@ -0,0 +1,170 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+// Mock Phaser
+vi.mock('phaser', () => {
+  const mockGraphics = {
+    setDepth: vi.fn().mockReturnThis(),
+    clear: vi.fn().mockReturnThis(),
+    lineStyle: vi.fn().mockReturnThis(),
+    lineBetween: vi.fn().mockReturnThis(),
+  };
+
+  const mockSprite = {
+    setDepth: vi.fn().mockReturnThis(),
+    setVisible: vi.fn().mockReturnThis(),
+    setAlpha: vi.fn().mockReturnThis(),
+    setPosition: vi.fn().mockReturnThis(),
+  };
+
+  return {
+    default: {
+      Scene: class {
+        add = {
+          graphics: vi.fn(() => mockGraphics),
+          sprite: vi.fn(() => mockSprite),
+        };
+      }
+    }
+  };
+});
+
+// Mock CombatLogic
+vi.mock('../../../engine/gameplay/CombatLogic', () => ({
+    traceProjectile: vi.fn(),
+    getClosestVisibleEnemy: vi.fn(),
+}));
+
+import { TargetingSystem } from '../TargetingSystem';
+import { traceProjectile, getClosestVisibleEnemy } from '../../../engine/gameplay/CombatLogic';
+import { TILE_SIZE } from '../../../core/constants';
+
+describe('TargetingSystem', () => {
+    let targetingSystem: TargetingSystem;
+    let mockWorld: any;
+    let mockEntityManager: any;
+    let mockScene: any;
+    let mockGraphics: any;
+    let mockSprite: any;
+
+    beforeEach(() => {
+        vi.clearAllMocks();
+        
+        mockGraphics = {
+            setDepth: vi.fn().mockReturnThis(),
+            clear: vi.fn().mockReturnThis(),
+            lineStyle: vi.fn().mockReturnThis(),
+            lineBetween: vi.fn().mockReturnThis(),
+        };
+
+        mockSprite = {
+            setDepth: vi.fn().mockReturnThis(),
+            setVisible: vi.fn().mockReturnThis(),
+            setAlpha: vi.fn().mockReturnThis(),
+            setPosition: vi.fn().mockReturnThis(),
+        };
+
+        mockScene = {
+            add: {
+                graphics: vi.fn(() => mockGraphics),
+                sprite: vi.fn(() => mockSprite),
+            },
+        } as any;
+
+        targetingSystem = new TargetingSystem(mockScene);
+        mockWorld = { width: 10, height: 10 };
+        mockEntityManager = {};
+        
+        // Default return for traceProjectile
+        (traceProjectile as any).mockReturnValue({
+            blockedPos: { x: 0, y: 0 },
+            hitActorId: undefined,
+            path: []
+        });
+    });
+
+    it('should initialize with graphics and crosshair sprite hidden', () => {
+        expect(mockScene.add.graphics).toHaveBeenCalled();
+        expect(mockScene.add.sprite).toHaveBeenCalled();
+        expect(mockSprite.setVisible).toHaveBeenCalledWith(false);
+    });
+
+    it('should start targeting and auto-select closest enemy', () => {
+        const playerPos = { x: 1, y: 1 };
+        const enemyPos = { x: 3, y: 3 };
+        (getClosestVisibleEnemy as any).mockReturnValue(enemyPos);
+
+        targetingSystem.startTargeting(
+            'item-1',
+            playerPos,
+            mockWorld,
+            mockEntityManager!,
+            1 as any,
+            new Uint8Array(100),
+            10
+        );
+
+        expect(targetingSystem.isActive).toBe(true);
+        expect(targetingSystem.itemId).toBe('item-1');
+        expect(targetingSystem.cursorPos).toEqual(enemyPos);
+        expect(mockSprite.setVisible).toHaveBeenCalledWith(true);
+    });
+
+    it('should fallback to mouse position if no enemy found', () => {
+        const playerPos = { x: 1, y: 1 };
+        const mousePos = { x: 5, y: 5 };
+        (getClosestVisibleEnemy as any).mockReturnValue(null);
+
+        targetingSystem.startTargeting(
+            'item-1',
+            playerPos,
+            mockWorld,
+            mockEntityManager!,
+            1 as any,
+            new Uint8Array(100),
+            10,
+            mousePos
+        );
+
+        expect(targetingSystem.cursorPos).toEqual(mousePos);
+    });
+
+    it('should update visuals with predictive impact point', () => {
+        const playerPos = { x: 1, y: 1 };
+        const targetPos = { x: 5, y: 1 };
+        const blockedPos = { x: 3, y: 1 }; // Wall at 3,1
+
+        (traceProjectile as any).mockReturnValue({
+            blockedPos: blockedPos,
+            hitActorId: undefined,
+            path: []
+        });
+
+        // Start targeting
+        targetingSystem.startTargeting(
+            'item-1',
+            playerPos,
+            mockWorld,
+            mockEntityManager!,
+            1 as any,
+            new Uint8Array(100),
+            10,
+            targetPos
+        );
+
+        // The crosshair should be at blockedPos, not targetPos
+        const expectedX = blockedPos.x * TILE_SIZE + TILE_SIZE / 2;
+        const expectedY = blockedPos.y * TILE_SIZE + TILE_SIZE / 2;
+        expect(mockSprite.setPosition).toHaveBeenCalledWith(expectedX, expectedY);
+
+        // Verify dashed line was drawn (multiple lineBetween calls)
+        expect(mockGraphics.lineBetween).toHaveBeenCalled();
+        expect(mockGraphics.lineBetween.mock.calls.length).toBeGreaterThan(1);
+    });
+
+    it('should clear visuals on cancel', () => {
+        targetingSystem.cancel();
+        expect(targetingSystem.isActive).toBe(false);
+        expect(mockGraphics.clear).toHaveBeenCalled();
+        expect(mockSprite.setVisible).toHaveBeenCalledWith(false);
+    });
+});