diff --git a/.DS_Store b/.DS_Store
new file mode 100644
index 00000000..bdb8e476
Binary files /dev/null and b/.DS_Store differ
diff --git a/.github/copilot-instructions.md b/.github/copilot-instructions.md
new file mode 100644
index 00000000..dad2c527
--- /dev/null
+++ b/.github/copilot-instructions.md
@@ -0,0 +1,1283 @@
+# GitHub Copilot Instructions - Ant Colony Simulation Game
+
+## ⚠️ CRITICAL: Development Principles
+
+**BE CONCISE**: Short, focused responses. No unnecessary explanations.
+
+**REUSE FIRST**: Before creating anything new:
+1. **Scan codebase** - Search for existing classes/functions that do what you need
+2. **Use existing tests** - Add to existing test files instead of creating new ones
+3. **Use test helpers** - Add to `test/helpers/uiTestHelpers.js` if code used >1 time
+4. **Check documentation** - Review `docs/` for existing patterns and APIs
+
+**AVOID DUPLICATION**: If you write the same code twice, extract it to a helper/utility.
+
+### ⚠️ CRITICAL: Test-Driven Development (TDD)
+
+**WE FOLLOW STRICT TDD**. Write tests FIRST, then implement.
+
+### TDD Workflow
+1. **Write failing tests FIRST** before any implementation
+2. **Run tests** - confirm they fail for the right reason
+3. **Write minimal code** to make tests pass
+4. **Run tests again** - confirm they pass
+5. **Refactor** - improve code while keeping tests green
+6. **Repeat** for each feature/bugfix
+
+### Test Type Expectations
+
+**Unit Tests** (862+ tests, write FIRST):
+- ✅ Test individual functions in isolation
+- ✅ Mock all external dependencies (p5.js, managers)
+- ✅ Fast (<10ms per test)
+- ✅ Target 100% coverage for new code
+- ❌ NEVER test loop counters or internal mechanics
+- ❌ NEVER test mocks (test real behavior)
+
+**Integration Tests**:
+- ✅ Test component interactions with real dependencies
+- ✅ Verify data flows between systems
+- ✅ Use JSDOM, sync `global` and `window` objects
+- ❌ Don't mock core systems (MapManager, SpatialGrid)
+
+**E2E Tests** (Puppeteer, PRIMARY with screenshots):
+- ✅ Test complete workflows in real browser
+- ✅ Provide screenshot proof (visual evidence)
+- ✅ Use system APIs, not manual property injection
+- ✅ Run headless for CI/CD
+- ❌ NEVER skip `ensureGameStarted()` (must bypass menu)
+- ❌ NEVER change state without `redraw()` calls
+- ❌ NEVER skip screenshot verification
+
+**BDD Tests** (Python Behave, headless):
+- ✅ Test user-facing behavior
+- ✅ Use plain language (no technical jargon)
+- ❌ NEVER use "real", "actual", "fake" (see BDD_LANGUAGE_STYLE_GUIDE.md)
+- ❌ NEVER hardcode test results
+
+## Core Architecture
+
+### ⚠️ MANDATORY: MVC Pattern for ALL Features
+
+**ALL NEW CODE MUST FOLLOW STRICT MVC SEPARATION**
+
+**Why MVC?**
+- ✅ **Testability**: Each layer tested independently (100% coverage achievable)
+- ✅ **Maintainability**: Clear separation prevents tangled dependencies
+- ✅ **Reusability**: Models/Views can be composed differently
+- ✅ **Debugging**: Isolate issues to specific layer (data vs display vs logic)
+- ✅ **Scalability**: Add features without breaking existing code
+
+**When to use MVC:**
+- ✅ ALL new game entities (ants, resources, buildings, enemies)
+- ✅ ALL new UI components (panels, buttons, overlays)
+- ✅ ALL new game systems (inventory, crafting, quests)
+- ✅ ALL new visual effects (particles, animations, highlights)
+- ❌ ONLY skip for: Simple utility functions, pure math helpers, one-line delegates
+
+**Model (Data Layer)** - `Classes/mvc/models/`
+- ✅ Store state ONLY (position, size, type, properties)
+- ✅ Provide getters/setters for data access
+- ✅ Return copies to prevent external mutation
+- ❌ NO rendering logic
+- ❌ NO update/game loop logic
+- ❌ NO external system calls (no MapManager, no EffectsRenderer)
+- ❌ NO business logic (orchestration)
+
+**View (Presentation Layer)** - `Classes/mvc/views/`
+- ✅ Render sprites, effects, highlights
+- ✅ Read from model (NEVER modify)
+- ✅ Handle visual transformations
+- ❌ NO state mutations
+- ❌ NO update methods
+- ❌ NO controller logic
+- ❌ NO data storage
+
+**Controller (Orchestration Layer)** - `Classes/mvc/controllers/`
+- ✅ Coordinate model + view
+- ✅ Manage sub-controllers (movement, selection, combat)
+- ✅ Handle game loop updates
+- ✅ System integration (spatial grid, MapManager, EffectsRenderer)
+- ❌ NO rendering (delegate to view)
+- ❌ NO direct data storage (delegate to model)
+- ❌ NO drawing methods (push, pop, rect, ellipse)
+
+**Factory (Creation Pattern)** - `Classes/mvc/factories/`
+- ✅ Create complete MVC triads
+- ✅ Handle configuration/defaults
+- ✅ Batch operations (createMultiple, createGrid, createCircle)
+
+### MVC Integration Example
+
+```javascript
+// ✅ CORRECT: Strict MVC separation
+const model = new EntityModel({ x: 100, y: 100, width: 32, height: 32, imagePath: 'ant.png' });
+const view = new EntityView(model);
+const controller = new EntityController(model, view);
+
+// Controller orchestrates
+controller.moveToLocation(200, 200);
+controller.setSelected(true);
+controller.getCurrentTerrain(); // Queries MapManager
+controller.effects.damageNumber(10); // Delegates to EffectsRenderer
+controller.highlight.spinning(); // Delegates to view
+
+// View renders (no state changes)
+view.render();
+view.highlightSelected();
+
+// Model stores data (no logic)
+model.setPosition(200, 200);
+model.getPosition(); // Returns copy
+```
+
+### Common MVC Violations (DO NOT DO)
+
+**❌ WRONG: Model with logic**
+```javascript
+class BadModel {
+ update() { // Models should NOT have update logic
+ this.position.x += this.velocity.x;
+ }
+ render() { // Models should NEVER render
+ rect(this.position.x, this.position.y, 32, 32);
+ }
+}
+```
+
+**✅ CORRECT: Pure data model**
+```javascript
+class GoodModel {
+ getPosition() { return { x: this.position.x, y: this.position.y }; }
+ setPosition(x, y) { this.position.x = x; this.position.y = y; }
+ // Data only, no logic
+}
+```
+
+**❌ WRONG: View mutating state**
+```javascript
+class BadView {
+ render() {
+ this.model.position.x += 5; // NEVER modify model in view
+ rect(this.model.position.x, this.model.position.y, 32, 32);
+ }
+}
+```
+
+**✅ CORRECT: Read-only view**
+```javascript
+class GoodView {
+ render() {
+ const pos = this.model.getPosition(); // Read only
+ rect(pos.x, pos.y, 32, 32);
+ }
+}
+```
+
+**❌ WRONG: Controller with rendering**
+```javascript
+class BadController {
+ render() { // Controllers should NOT render
+ push();
+ rect(this.model.getX(), this.model.getY(), 32, 32);
+ pop();
+ }
+}
+```
+
+**✅ CORRECT: Controller orchestrates**
+```javascript
+class GoodController {
+ update() {
+ // Orchestrate systems
+ this._updateMovement();
+ this._checkCollisions();
+ }
+
+ render() {
+ this.view.render(); // Delegate to view
+ }
+}
+```
+
+**❌ WRONG: Direct data storage in controller**
+```javascript
+class BadController {
+ constructor(model, view) {
+ this.position = { x: 0, y: 0 }; // Don't store data
+ this.size = { x: 32, y: 32 }; // Use model instead
+ }
+}
+```
+
+**✅ CORRECT: Controller delegates to model**
+```javascript
+class GoodController {
+ constructor(model, view) {
+ this.model = model; // Reference to model
+ this.view = view; // Reference to view
+ }
+
+ getPosition() {
+ return this.model.getPosition(); // Delegate to model
+ }
+}
+```
+
+### Legacy Entity-Controller Pattern (DEPRECATED)
+
+**Entity** (`Classes/containers/Entity.js`) - ONLY use for backward compatibility:
+- Legacy system with controllers
+- NEW features MUST use MVC pattern above
+- DO NOT extend Entity for new features
+
+### Creating New MVC Components - TDD CHECKLIST
+
+**STEP 1: Write Model Tests FIRST**
+```javascript
+// test/unit/mvc/MyFeatureModel.test.js
+describe('MyFeatureModel', function() {
+ it('should store data only (no logic)', function() {
+ const model = new MyFeatureModel({ x: 100, y: 200 });
+ expect(model.getPosition()).to.deep.equal({ x: 100, y: 200 });
+ });
+
+ it('should NOT have render methods', function() {
+ const model = new MyFeatureModel();
+ expect(model.render).to.be.undefined;
+ });
+});
+```
+
+**STEP 2: Implement Model**
+```javascript
+// Classes/mvc/models/MyFeatureModel.js
+class MyFeatureModel {
+ constructor(options = {}) {
+ this.position = { x: options.x || 0, y: options.y || 0 };
+ // Data storage ONLY
+ }
+
+ getPosition() { return { x: this.position.x, y: this.position.y }; }
+ setPosition(x, y) { this.position.x = x; this.position.y = y; }
+}
+```
+
+**STEP 3: Write View Tests**
+```javascript
+// test/unit/mvc/MyFeatureView.test.js
+describe('MyFeatureView', function() {
+ it('should render without modifying model', function() {
+ const model = new MyFeatureModel({ x: 100, y: 100 });
+ const view = new MyFeatureView(model);
+
+ view.render();
+
+ expect(model.getPosition()).to.deep.equal({ x: 100, y: 100 });
+ });
+});
+```
+
+**STEP 4: Implement View**
+```javascript
+// Classes/mvc/views/MyFeatureView.js
+class MyFeatureView {
+ constructor(model) {
+ this.model = model;
+ }
+
+ render() {
+ const pos = this.model.getPosition(); // Read only
+ push();
+ rect(pos.x, pos.y, 32, 32);
+ pop();
+ }
+}
+```
+
+**STEP 5: Write Controller Tests**
+```javascript
+// test/unit/mvc/MyFeatureController.test.js
+describe('MyFeatureController', function() {
+ it('should orchestrate model and view', function() {
+ const model = new MyFeatureModel();
+ const view = new MyFeatureView(model);
+ const controller = new MyFeatureController(model, view);
+
+ controller.moveTo(200, 300);
+ expect(model.getPosition()).to.deep.equal({ x: 200, y: 300 });
+ });
+
+ it('should NOT have render methods', function() {
+ expect(controller.render).to.be.undefined;
+ });
+});
+```
+
+**STEP 6: Implement Controller**
+```javascript
+// Classes/mvc/controllers/MyFeatureController.js
+class MyFeatureController {
+ constructor(model, view) {
+ this.model = model;
+ this.view = view;
+ }
+
+ moveTo(x, y) {
+ this.model.setPosition(x, y); // Update model
+ // View reads from model automatically
+ }
+
+ update() {
+ // Game loop orchestration
+ }
+}
+```
+
+**STEP 7: Create Factory**
+```javascript
+// Classes/mvc/factories/MyFeatureFactory.js
+class MyFeatureFactory {
+ static create(options = {}) {
+ const model = new MyFeatureModel(options);
+ const view = new MyFeatureView(model);
+ const controller = new MyFeatureController(model, view);
+ return { model, view, controller };
+ }
+}
+```
+
+**STEP 8: Integration Tests**
+```javascript
+// test/integration/mvc/myFeature.integration.test.js
+it('should coordinate all MVC layers', function() {
+ const entity = MyFeatureFactory.create({ x: 100, y: 100 });
+ entity.controller.moveTo(200, 200);
+ entity.view.render();
+ expect(entity.model.getPosition()).to.deep.equal({ x: 200, y: 200 });
+});
+```
+
+## Rendering Pipeline
+
+**RenderLayerManager** (`Classes/rendering/RenderLayerManager.js`) - Fixed layer order:
+
+**Layers** (bottom to top): `TERRAIN` → `ENTITIES` → `EFFECTS` → `UI_GAME` → `UI_DEBUG` → `UI_MENU`
+
+**State-based visibility**:
+- `MENU`: TERRAIN + UI_MENU
+- `PLAYING`: TERRAIN + ENTITIES + EFFECTS + UI_GAME + UI_DEBUG
+- `PAUSED`: TERRAIN + ENTITIES + EFFECTS + UI_GAME
+
+### Adding to RenderLayerManager - TDD CHECKLIST
+
+**STEP 1: Write tests FIRST**
+```javascript
+// test/integration/rendering/myFeature.test.js
+it('should register with correct layer', function() {
+ const initialCount = RenderManager.getLayerDrawables(RenderManager.layers.ENTITIES).length;
+ registerMyFeatureRenderer();
+ expect(RenderManager.getLayerDrawables(RenderManager.layers.ENTITIES).length).to.equal(initialCount + 1);
+});
+```
+
+**STEP 2: Register drawable**
+```javascript
+RenderManager.addDrawableToLayer(RenderManager.layers.ENTITIES, () => {
+ push();
+ myEntities.forEach(e => e.render());
+ pop();
+});
+```
+
+**STEP 3: For interactive elements**
+```javascript
+RenderManager.addInteractiveDrawable(RenderManager.layers.UI_GAME, {
+ hitTest: (pointer) => pointer.x > x && pointer.x < x + width,
+ onPointerDown: (pointer) => { /* handle click */ }
+});
+```
+
+**⚠️ CRITICAL: Interactive Registration Pattern**
+
+When refactoring UI components to use RenderManager, **ALWAYS**:
+1. **Add `registerInteractive()` method** to component class
+2. **Call method in sketch.js `setup()`** after component creation
+3. **Use `pointer.screen.x/y`** for UI_GAME/UI_MENU layers (screen coords)
+4. **Check GameState** in hitTest/onPointerDown (e.g., `PLAYING` for game UI)
+
+**⚠️ CRITICAL: Normalized UI Coordinate System**
+
+**ALL UI components MUST use normalized coordinates** for resolution independence:
+
+**Coordinate System**:
+- `(0, 0)` = **center of screen**
+- `(-1, -1)` = **bottom-left corner**
+- `(1, 1)` = **top-right corner**
+- X-axis: `-1` (left) to `1` (right)
+- Y-axis: `-1` (bottom) to `1` (top) - **inverted from screen pixels!**
+
+**Implementation Pattern**:
+```javascript
+// In component constructor
+class MyUIComponent {
+ constructor(p5Instance, options = {}) {
+ this.p5 = p5Instance;
+
+ // ALWAYS add coordinate converter
+ this.coordConverter = new UICoordinateConverter(p5Instance);
+
+ // Calculate dimensions first
+ this.width = calculateWidth();
+ this.height = calculateHeight();
+
+ // Use normalized coordinates (default values)
+ const normalizedX = options.normalizedX !== undefined ? options.normalizedX : 0;
+ const normalizedY = options.normalizedY !== undefined ? options.normalizedY : 0.9;
+
+ // Convert to screen coordinates
+ const screenPos = this.coordConverter.normalizedToScreen(normalizedX, normalizedY);
+
+ // Center component on position
+ this.x = screenPos.x - this.width / 2;
+ this.y = screenPos.y - this.height / 2;
+ }
+}
+
+// In initialization (gameUIOverlaySystem.js or sketch.js)
+const myComponent = new MyUIComponent(p5Instance, {
+ normalizedX: 0.7, // 70% right from center
+ normalizedY: 0.8, // 80% up from center
+ // ... other options
+});
+```
+
+**Common Normalized Positions**:
+- Top-left: `normalizedX: -0.8, normalizedY: 0.85`
+- Top-center: `normalizedX: 0, normalizedY: 0.95`
+- Top-right: `normalizedX: 0.7, normalizedY: 0.8`
+- Bottom-left: `normalizedX: -0.8, normalizedY: -0.85`
+- Bottom-right: `normalizedX: 0.8, normalizedY: -0.85`
+- Center: `normalizedX: 0, normalizedY: 0`
+
+**DO NOT use pixel coordinates** (`x`, `y`) in new UI components. Always use `normalizedX` and `normalizedY`.
+
+**Common mistake**: Refactoring registration pattern to new components but forgetting to update old components still in use. If interactive elements stop working after refactoring, check if the component has `registerInteractive()` method and if it's being called.
+
+**Example pattern**:
+```javascript
+// In component class (e.g., AntCountDisplayComponent.js)
+registerInteractive() {
+ if (typeof RenderManager === 'undefined') return;
+
+ RenderManager.addInteractiveDrawable(RenderManager.layers.UI_GAME, {
+ id: 'my-component-id',
+ hitTest: (pointer) => {
+ if (GameState.getState() !== 'PLAYING') return false;
+ const x = pointer.screen ? pointer.screen.x : pointer.x;
+ const y = pointer.screen ? pointer.screen.y : pointer.y;
+ return this.isMouseOver(x, y);
+ },
+ onPointerDown: (pointer) => {
+ if (GameState.getState() !== 'PLAYING') return false;
+ const x = pointer.screen ? pointer.screen.x : pointer.x;
+ const y = pointer.screen ? pointer.screen.y : pointer.y;
+ return this.handleClick(x, y);
+ }
+ });
+}
+
+// In sketch.js setup() - AFTER component creation
+if (g_myComponent && g_myComponent.registerInteractive) {
+ g_myComponent.registerInteractive();
+}
+```
+
+**STEP 4: E2E test with screenshots**
+```javascript
+await page.evaluate(() => {
+ window.gameState = 'PLAYING';
+ if (window.RenderManager) window.RenderManager.render('PLAYING');
+ if (typeof window.redraw === 'function') {
+ window.redraw(); window.redraw(); window.redraw(); // Multiple calls for layers
+ }
+});
+await sleep(500);
+await saveScreenshot(page, 'rendering/my_feature', true);
+```
+
+### EFFECTS Layer Rendering Order
+
+The EFFECTS layer renders in a specific order to ensure proper visual layering:
+
+1. **EffectsLayerRenderer** - Base particle effects (blood, sparks, dust, trails)
+2. **FireballManager** - Active fireball projectiles (via `renderFireballEffects()`)
+3. **LightningManager** - Lightning effects and soot stains
+4. **ParticleEmitter temporary explosions** - Explosion bursts (rendered last, on top)
+
+**Integration in RenderLayerManager**:
+```javascript
+// In renderEffectsLayer()
+if (effectsRenderer && typeof effectsRenderer.renderEffects === 'function') {
+ effectsRenderer.renderEffects(gameState);
+}
+
+// Render Fireball System (projectile effects)
+this.renderFireballEffects(gameState);
+```
+
+**Main Game Loop** (`sketch.js`):
+```javascript
+// Update fireballs in draw loop (PLAYING state)
+if (window.g_fireballManager) window.g_fireballManager.update();
+```
+
+**Temporary Particle Cleanup**:
+Temporary particle emitters (explosion effects) are **NOT** automatically cleaned up by any manager. They rely on:
+- Manual cleanup check in `FireballAimBrush.render()`
+- 2-second lifetime before removal from `window.g_tempParticleEmitters[]`
+- Each emitter stops emission after initial burst (80 particles)
+
+## Terrain System
+
+**MapManager** (`Classes/managers/MapManager.js`) - Perlin noise generation, 32px tiles
+
+**⚠️ CRITICAL BUG**: Grid.get() has inverted Y-axis boundary check. **Always use `MapManager.getTileAtGridCoords()`** instead.
+
+**Terrain types**:
+```javascript
+const TERRAIN_TYPES = {
+ GRASS: 0, // 1.0x cost
+ WATER: 1, // 3.0x cost (slow)
+ STONE: 2, // Infinity (impassable)
+ SAND: 3, // 1.2x cost
+ DIRT: 4 // 1.0x cost
+};
+```
+
+**Correct usage**:
+```javascript
+// ✅ CORRECT
+const tile = g_map2.getTileAtGridCoords(x, y);
+const terrainType = tile ? tile.type : null;
+
+// ❌ WRONG (Y-axis bug)
+const tile = g_map2.grid.get([x, y]); // AVOID
+```
+
+## Pathfinding System
+
+**A* algorithm** (`Classes/pathfinding.js`) with terrain cost integration
+
+**MovementController integration**:
+```javascript
+entity.moveToLocation(targetX, targetY);
+// Internally: MovementController → pathfinding → terrain costs → optimal path
+```
+
+**Testing pathfinding (TDD)**:
+```javascript
+it('should avoid water when pathfinding', function() {
+ const mockTerrain = {
+ getTileAtGridCoords: sinon.stub().callsFake((x, y) => {
+ if (x >= 5 && x <= 7 && y >= 5 && y <= 7) return { type: TERRAIN_TYPES.WATER };
+ return { type: TERRAIN_TYPES.GRASS };
+ })
+ };
+
+ const path = findPath(0, 0, 10, 10, { terrain: mockTerrain, avoidWater: true });
+
+ path.forEach(point => {
+ const tile = mockTerrain.getTileAtGridCoords(point.x, point.y);
+ expect(tile.type).to.not.equal(TERRAIN_TYPES.WATER);
+ });
+});
+```
+
+## Spatial Grid System
+
+**SpatialGridManager** (`Classes/managers/SpatialGridManager.js`) - O(1) spatial queries
+
+**Cell size**: 64px (TILE_SIZE * 2), entities auto-register
+
+**Query methods**:
+- `getNearbyEntities(x, y, radius)` - within radius
+- `findNearestEntity(x, y)` - closest
+- `getEntitiesInRect(x, y, w, h)` - in rectangle
+- `getEntitiesByType('Ant')` - type filtering
+
+**Performance**: 50-200x faster than iteration
+
+## Current Systems Status
+
+### EventManager System (COMPLETE)
+**Status**: Production-ready, fully tested
+- EventManager singleton with full API (`Classes/managers/EventManager.js`)
+- Event types: dialogue, spawn, tutorial, boss
+- Trigger system: time, flag, spatial, conditional, viewport
+- Flag-based conditions and state tracking
+- JSON import/export for level design
+- EventEditorPanel integration (Level Editor)
+- **API Reference**: `docs/api/EventManager_API_Reference.md`
+
+### Level Editor System (IN PROGRESS - DEBUGGING)
+**Status**: Core complete, debugging visual/rendering issues
+- **Complete**:
+ - Terrain editing (paint, fill, eyedropper, select tools)
+ - Material palette (moss, stone, dirt, grass variants)
+ - TerrainEditor, TerrainExporter, TerrainImporter
+ - Save/Load dialogs with LocalStorage
+ - MiniMap with cache system (performance optimized)
+ - EventEditorPanel for random events
+ - Full test coverage (unit, integration, E2E)
+- **Current Focus**: Debugging rendering issues, panel visibility
+- **Documentation**: `docs/LEVEL_EDITOR_SETUP.md`
+
+### Fireball System (COMPLETE)
+**Status**: Production-ready, integrated with Effects Layer
+- **Components**:
+ - `Fireball` class: Projectile with physics, collision detection, visual effects
+ - `FireballManager` singleton: Manages multiple fireballs, handles updates/rendering
+ - `FireballAimBrush`: Charge-and-release UI brush for Queen targeting
+- **Integration**:
+ - Renders on EFFECTS layer via `RenderLayerManager.renderFireballEffects()`
+ - Updates in main game loop (`sketch.js`)
+ - Coordinate conversion: world ↔ screen via MapManager
+- **Key Features**:
+ - Physics-based projectile motion with velocity and targeting
+ - Trail system (8-point fade trail)
+ - Multi-layer rendering (glow → trail → fireball core)
+ - Collision detection with configurable radius (15px default)
+ - Damage on impact with `takeDamage()` integration
+ - Explosion effects via `ParticleEmitter`
+ - Area-of-effect damage (3-tile blast radius, 150 damage)
+ - Soot stains using `SootStain` class (5-8 overlapping stains per impact)
+- **Charge System** (FireballAimBrush):
+ - 1-second charge requirement before firing
+ - Visual feedback: charging ring, particle effects, screen darkening
+ - Radial light glow at 50%+ charge
+ - Audio progression (volume 0.2 → 1.0 during charge)
+ - Particle emitter activates at full charge (fire/smoke/sparks)
+ - Range validation (7 tiles base, scales with power level)
+- **Files**:
+ - `Classes/systems/combat/FireballSystem.js`
+ - `Classes/systems/tools/FireballAimBrush.js`
+ - `test/unit/systems/Fireball.test.js`
+
+### Particle System (COMPLETE)
+**Status**: Production-ready, used by Fireball and other effects
+- **ParticleEmitter** (`Classes/systems/ParticleEmitter.js`):
+ - Continuous particle emission system for fire, smoke, sparks, rain
+ - Framerate-independent updates using deltaTime normalization
+ - Configurable emission rate, max particles, spawn radius
+ - Particle lifecycle: spawn → age → fade → death
+ - Visual properties: size range, speed range, colors per type
+ - Physics: gravity, drift (horizontal), turbulence (random)
+ - Emission modes:
+ - `continuous`: Constant emission (fire, smoke, rain)
+ - `explosion`: Radial burst (fireball impact, explosions)
+- **Particle Presets** (`config/particle-effects.json`):
+ - ✅ **ALWAYS use presets first** - avoid hardcoding particle configs
+ - Available presets: `explosion`, `fireballCharge`, `fireTrail`, `smoke`, `sparks`, `rain`, `heavyRain`
+ - Load presets: `ParticleEmitter.loadPresets()` (called in sketch.js preload)
+ - Use preset: `new ParticleEmitter({ preset: 'explosion', x: 100, y: 100 })`
+ - Override preset values: `new ParticleEmitter({ preset: 'explosion', x: 100, y: 100, maxParticles: 200 })`
+ - Create new presets for reusable effects (avoid duplication)
+- **Particle Types**:
+ - `fire`: Orange/yellow, rises upward (negative Y velocity)
+ - `smoke`: Gray, expands over lifetime, rises slowly
+ - `spark`: Bright yellow/white, small, fast movement
+ - `rain`: Light blue/white, falls downward (positive Y velocity)
+- **Lifecycle Management**:
+ - Fade in: First 20% of lifetime
+ - Fade out: Last 80% of lifetime
+ - Alpha: 0 → 255 → 0 (smooth transitions)
+ - Size changes: smoke grows, fire shrinks, sparks constant
+- **Temporary Emitters** (for explosions):
+ - Stored in `window.g_tempParticleEmitters[]` array
+ - Auto-cleanup after 2 seconds (explosion burst pattern)
+ - Rendered in `FireballAimBrush.render()` after main brush rendering
+ - Created on fireball impact with 80 particles per explosion
+- **Integration with Fireball**:
+ - Charge indicator: Continuous emitter at cursor during charge
+ - Explosion burst: Radial emission mode on impact
+ - Screen-space rendering (converted from world coordinates)
+ - Particles rendered after main game elements but before UI
+
+### Fireball-Particle System Interaction Pattern
+
+**Charge Phase**:
+```javascript
+// In FireballAimBrush.update()
+if (this.chargeProgress >= 1.0 && !this.particleEmitter.isActive()) {
+ this.particleEmitter.start(); // Activate continuous emission
+}
+this.particleEmitter.setPosition(this.cursor.x, this.cursor.y);
+this.particleEmitter.update(); // Update existing particles
+```
+
+**Impact Phase**:
+```javascript
+// In FireballAimBrush.tryStrikeAt()
+// ✅ CORRECT: Use preset
+const explosionEmitter = new ParticleEmitter({
+ preset: 'explosion',
+ x: screenX,
+ y: screenY
+});
+
+// ❌ WRONG: Hardcoded config (avoid this)
+const explosionEmitter = new ParticleEmitter({
+ x: screenX,
+ y: screenY,
+ emissionMode: 'explosion',
+ types: ['fire', 'smoke', 'spark'],
+ speedRange: [3, 10]
+});
+
+explosionEmitter.start();
+for (let i = 0; i < 80; i++) {
+ explosionEmitter.emitParticle(); // Burst emission
+}
+explosionEmitter.stop();
+
+// Store for rendering/cleanup
+window.g_tempParticleEmitters.push({
+ emitter: explosionEmitter,
+ created: millis(),
+ lifetime: 2000
+});
+```
+
+**Rendering Order** (EFFECTS layer):
+1. EffectsRenderer particle effects (blood, sparks, dust)
+2. Fireball projectiles (FireballManager)
+3. Lightning effects and soot stains
+4. ParticleEmitter temporary explosions (last, on top)
+
+**Coordinate Conversion Pattern**:
+```javascript
+// World → Screen (for rendering)
+const tileX = worldX / TILE_SIZE;
+const tileY = worldY / TILE_SIZE;
+const screenPos = g_activeMap.renderConversion.convPosToCanvas([tileX, tileY]);
+
+// Screen → World (for collision/damage)
+const tilePos = g_activeMap.renderConversion.convCanvasToPos([screenX, screenY]);
+const worldX = (tilePos[0] - 0.5) * TILE_SIZE;
+const worldY = (tilePos[1] - 0.5) * TILE_SIZE;
+```
+
+**TDD Pattern for Effects**:
+```javascript
+// Unit test - ParticleEmitter behavior
+it('should emit particles at specified rate', function() {
+ const emitter = new ParticleEmitter({ emissionRate: 10, maxParticles: 50 });
+ emitter.start();
+ emitter.update();
+ expect(emitter.getParticleCount()).to.be.greaterThan(0);
+});
+
+// Integration test - Fireball + Particles
+it('should create explosion particles on impact', function() {
+ const fireball = new Fireball(100, 100, 200, 200, 25);
+ fireball.explode();
+ expect(window.g_tempParticleEmitters.length).to.be.greaterThan(0);
+});
+
+// E2E test - Visual verification
+await page.evaluate(() => {
+ window.g_fireballAimBrush.tryStrikeAt(400, 400);
+ if (typeof window.redraw === 'function') {
+ window.redraw(); window.redraw(); window.redraw();
+ }
+});
+await sleep(500);
+await saveScreenshot(page, 'effects/fireball_impact', true);
+```
+
+### Upcoming Systems (Design Phase)
+
+#### Pheromone System
+**TDD Plan**:
+1. Write unit tests for PheromoneManager (creation, decay, diffusion)
+2. Write integration tests for ant-pheromone interaction
+3. E2E tests with visual pheromone trails (screenshots)
+4. Add PheromoneController to Entity
+5. Register in EFFECTS rendering layer
+
+## E2E Testing Critical Patterns
+
+**MANDATORY**: See `docs/guides/E2E_TESTING_QUICKSTART.md`
+
+### 1. Server Setup
+```bash
+npm run dev # Must be running on localhost:8000
+```
+
+### 2. Menu Bypass (CRITICAL!)
+```javascript
+const cameraHelper = require('../camera_helper');
+const gameStarted = await cameraHelper.ensureGameStarted(page);
+if (!gameStarted.started) throw new Error('Failed to start - still on menu');
+```
+**Without this**: Screenshots show main menu, not game!
+
+### 3. Force Rendering After State Changes
+```javascript
+await page.evaluate(() => {
+ window.gameState = 'PLAYING';
+
+ if (window.draggablePanelManager) {
+ window.draggablePanelManager.renderPanels('PLAYING');
+ }
+
+ if (typeof window.redraw === 'function') {
+ window.redraw(); window.redraw(); window.redraw();
+ }
+});
+await sleep(500);
+await saveScreenshot(page, 'category/name', true);
+```
+**Without this**: Screenshots show old state!
+
+### 4. Panel Visibility System
+```javascript
+await page.evaluate(() => {
+ if (!window.draggablePanelManager.stateVisibility.PLAYING) {
+ window.draggablePanelManager.stateVisibility.PLAYING = [];
+ }
+ window.draggablePanelManager.stateVisibility.PLAYING.push('test-panel-id');
+});
+```
+**Without this**: Panel won't render!
+
+### 5. Screenshot Proof (MANDATORY)
+```javascript
+await saveScreenshot(page, 'ui/test_name', true); // success/
+await saveScreenshot(page, 'ui/test_error', false); // failure/ with timestamp
+```
+
+**Verify screenshots show**:
+- ✅ Game terrain (NOT main menu)
+- ✅ Expected UI elements
+- ✅ Correct visual state
+- ❌ Main menu = test failed
+
+**Location**: `test/e2e/screenshots/{category}/{success|failure}/{name}.png`
+
+## Development Process & Checklists
+
+**CRITICAL**: **ALWAYS use checklists** for feature development, bug fixes, and refactoring. Checklists ensure systematic, test-driven development and prevent missed steps.
+
+### Why Checklists Matter
+
+**Checklists enforce**:
+- TDD at every phase (unit → integration → E2E)
+- Systematic verification (no missed steps)
+- Documentation updates (keep docs current)
+- Quality gates (all tests pass before commit)
+- Consistent process (reproducible outcomes)
+
+**Available Checklists**:
+- `docs/checklists/FEATURE_ENHANCEMENT_CHECKLIST.md` - New features (TDD phases)
+- `docs/checklists/FEATURE_DEVELOPMENT_CHECKLIST.md` - Full development lifecycle
+- Inline checklists in this document (Bug Fix, New Feature, Refactoring)
+
+### Bug Fix Process (TDD)
+
+1. **Document** in `test/KNOWN_ISSUES.md` (file, behavior, root cause, priority)
+2. **Write failing test** reproducing the bug
+3. **Run test** (confirm failure)
+4. **Fix the bug** with minimal code change
+5. **Run test** (confirm pass)
+6. **Run full suite** (`npm test` - no regressions)
+7. **Update docs** (move to "Fixed Issues", add comments in code)
+
+### New Feature Process (TDD + Roadmap + MVC)
+
+**MANDATORY**: Create a roadmap document for features requiring >2 hours work
+
+**CRITICAL**: ALL NEW FEATURES MUST USE MVC PATTERN
+
+1. **Create Roadmap** in `docs/roadmaps/[FEATURE_NAME]_ROADMAP.md`
+ - Break feature into MVC phases (Model → View → Controller → Factory)
+ - Add checklists for each phase (TDD: unit → integration → E2E)
+ - List deliverables, files affected, documentation needs
+ - Estimate time per phase
+
+2. **Write unit tests FIRST** for Model (tests will fail)
+3. **Run tests** (confirm failure)
+4. **Implement Model** (minimal code to pass, data only)
+5. **Run tests** (confirm pass)
+6. **Write unit tests FIRST** for View (presentation only)
+7. **Implement View** (rendering, no state mutations)
+8. **Write unit tests FIRST** for Controller (orchestration)
+9. **Implement Controller** (coordinates model/view/systems)
+10. **Integration tests** (MVC triad working together)
+11. **E2E tests** (browser with screenshots)
+12. **Update roadmap** (mark phases complete, update existing doc)
+13. **Update docs** (usage examples, CHANGELOG, architecture docs)
+14. **Full test suite** (`npm test` - all pass before commit)
+
+**Roadmap Template Structure**:
+```markdown
+# [Feature Name] Roadmap
+
+## Overview
+Brief description, goals, affected systems
+
+## Phases
+
+### Phase 1: Model (Data Layer)
+- [ ] Write unit tests (TDD)
+- [ ] Implement model class (data storage only)
+- [ ] Run tests (pass)
+- [ ] Verify NO logic/rendering
+**Deliverables**: [List files created/modified]
+
+### Phase 2: View (Presentation Layer)
+- [ ] Write unit tests
+- [ ] Implement view class (rendering only)
+- [ ] Run tests (pass)
+- [ ] Verify NO state mutations
+**Deliverables**: [List files]
+
+### Phase 3: Controller (Orchestration)
+- [ ] Write unit tests
+- [ ] Implement controller class
+- [ ] Run tests (pass)
+- [ ] Verify NO rendering/data storage
+**Deliverables**: [List files]
+
+### Phase 4: Factory & Integration
+- [ ] Create factory for MVC triad
+- [ ] Write integration tests
+- [ ] Connect to existing systems
+- [ ] Run tests (pass)
+**Deliverables**: [List files]
+
+### Phase 5: E2E & Documentation
+- [ ] Write E2E tests with screenshots
+- [ ] Create API reference
+- [ ] Update architecture docs
+**Deliverables**: [List docs]
+
+## Testing Strategy
+Unit → Integration → E2E breakdown
+
+## MVC Compliance
+- Model: Pure data, no logic
+- View: Read-only, no mutations
+- Controller: Orchestrates, no rendering
+
+## Documentation Updates
+- [ ] API reference
+- [ ] Architecture docs
+- [ ] Usage examples
+```
+
+**Example**: See `docs/roadmaps/RANDOM_EVENTS_ROADMAP.md` (EventManager implementation)
+
+### Refactoring Process
+
+1. **Ensure coverage** (>80% for code being refactored)
+2. **Refactor** (structure only, behavior unchanged)
+3. **Run tests** (all must pass - behavior unchanged)
+4. **Update tests** (only if public API changed)
+
+## Testing Commands
+
+```bash
+# Unit (write FIRST for all features)
+npm run test:unit
+npm run test:unit:controllers
+npx mocha "test/unit/path/to/file.test.js"
+
+# Integration
+npm run test:integration
+
+# BDD (headless)
+npm run test:bdd
+npm run test:bdd:ants
+
+# E2E (PRIMARY with screenshots)
+npm run test:e2e
+npm run test:e2e:ui
+node test/e2e/ui/pw_panel_minimize.js
+
+# All tests (CI/CD)
+npm test # unit → integration → BDD → E2E
+```
+
+## Development Workflow
+
+### Running the Game
+```bash
+npm run dev # Python server on :8000
+```
+
+### p5.js Lifecycle
+1. `preload()` - Load assets via `*_Preloader()` functions
+2. `setup()` - Initialize canvas, world, controllers (once)
+3. `draw()` - Main loop (60fps), handles game states
+4. Input handlers - `mousePressed()`, `keyPressed()`, etc.
+
+**Load order**: Bootstrap → Rendering → Base Systems → Controllers → Game Logic
+
+## File Organization
+
+```
+Classes/
+ ants/ - Ant entities, state machine, job system, AntFactory, Boss, Queen
+ baseMVC/ - Base MVC framework (adapters/, behaviors/ - empty, future use)
+ buildings/ - Building entities (empty - future expansion)
+ containers/ - Entity base, DropoffLocation, StatsContainer
+ controllers/ - Reusable behavior controllers (Movement, Combat, Health, Selection, Input)
+ events/ - Event system (Event.js, EventTrigger.js, DialogueEvent.SKELETON.js)
+ globals/ - Global utilities (entityManager.js, eventBus.js, windowInitializer.js)
+ initTests/ - Test initialization helpers (functionAsserts.js)
+ managers/ - System managers:
+ - AntManager, ResourceManager, MapManager, SpatialGridManager
+ - EventManager, GameStateManager, GameEvents
+ - BuildingManager, EntityManager, NPCManager, QuestManager, ShopManager
+ - PowerManager, PowerBrushManager, TileInteractionManager
+ - BUIManager, DIAManager, animationManager, soundManager, pheromoneControl
+ mvc/ - MVC components (models/, views/, controllers/, factories/)
+ rendering/ - Rendering pipeline:
+ - RenderLayerManager, RenderController, UIController
+ - EntityLayerRenderer, UILayerRenderer, EffectsLayerRenderer
+ - EntityAccessor, EntityDelegationBuilder, Sprite2d
+ - CacheManager, PerformanceMonitor, UIDebugManager, caches/
+ systems/ - Core systems:
+ - CollisionBox2D, Button, SpatialGrid, CoordinateConverter
+ - Nature, MouseCrosshair, GatherDebugRenderer
+ - FramebufferManager, entityUtils, newPathfinding.js, pheromones.js
+ - combat/, dialogue/, shapes/, text/, tools/, ui/
+ tasks/ - Task system (tasks.js, TaskUI.js)
+ terrainUtils/ - Terrain generation and editing:
+ - MapManager, TerrainEditor, TerrainExporter, TerrainImporter
+ - gridTerrain.js, grid.js, tiles.js, tileSmooth.js, chunk.js
+ - CustomTerrain, SparseTerrain, customLevels.js, terrianGen.js
+ testing/ - Testing utilities (ShareholderDemo.js)
+ ui/ - Level Editor UI:
+ - MaterialPalette, ToolBar, MiniMap, GridOverlay, DynamicMinimap
+ - SaveDialog, LoadDialog, FileMenuBar, ConfirmationDialog
+ - PropertiesPanel, BrushSizeControl, HoverPreviewManager
+ - SelectionManager, FormatConverter, ServerIntegration
+ - LocalStorageManager, NotificationManager, AutoSave
+ - AntCountDisplayComponent, DynamicGridOverlay, menuBar/
+ ui_new/ - New UI components:
+ - components/ (antCountDropDown, arrowComponent, dropdownMenu,
+ gameUIOverlay, informationLine, resourceCountDisplay,
+ resourceInventoryBar, playerResourceInventoryBar)
+ - gameUIOverlaySystem.js
+ pathfinding.js - A* pathfinding with terrain costs
+ resource.js - Resource definitions
+ resources.js - Resource management
+config/
+ button-system.json - Button configuration
+ button-groups/ - Button group configs (gameplay, main-menu, settings, legacy-conversions)
+ events/ - Event configs (dialogue_examples.json)
+debug/
+ UniversalDebugger.js - Universal entity debugger
+ EntityDebugManager.js - Entity debug coordination
+ EventDebugManager.js - Event debug tools
+ coordinateDebug.js - Coordinate system debugging
+ testing.js, test_*.js - Debug test scripts
+ terrainSystemTests.js - Terrain testing
+ tileInspector.js - Tile inspection tool
+ selectionBoxDebug.js - Selection debugging
+ debugRenderingHelpers.js - Debug rendering utilities
+ globalDebugging.js - Global debug state
+ commandLine.js - Debug commands
+ verboseLogger.js - Detailed logging
+ tracing.js - Execution tracing
+ typeChecks/ - Type validation
+docs/
+ KEYBINDS_REFERENCE.md - Keyboard shortcuts
+ checklists/ - Development checklists (bug fixes/)
+scripts/
+ bootstrap-globals.js - Global initialization
+ node-check.js - Node version validation
+ replace-console-logs.ps1 - Log replacement utility
+ README.md - Scripts documentation
+src/
+ globals.d.ts - TypeScript global definitions
+ rect.js - Rectangle utilities
+ levels/ - Level data (gregg.json, tutorialCave_Start.json)
+ types/ - Type definitions
+test/
+ unit/ - Isolated tests (write FIRST):
+ - ants/, controllers/, managers/, mvc/, rendering/, systems/
+ - terrain/, ui/, ui_new/, events/, dialogue/, levelEditor/
+ - containers/, debug/, globals/, helpers/, terrainUtils/
+ integration/ - Component interactions (same structure as unit/)
+ e2e/ - Puppeteer with screenshots (PRIMARY):
+ - ui/, camera/, controllers/, screenshots/
+ - ants/, brain/, combat/, debug/, dialogue/, entity/, events/
+ - levelEditor/, level_editor/, managers/, performance/, queen/
+ - rendering/, resources/, selection/, spatial/, spawn/, state/, systems/, terrain/
+ - puppeteer_helper.js, camera_helper.js (CRITICAL!)
+ - generate_*.js test generators, run-*.js test runners
+ bdd/ - Behave (headless Python tests)
+ baseline/ - Baseline test data
+ helpers/ - Test helper utilities (uiTestHelpers.js)
+ run-all-tests.js - Test suite runner
+types/
+ game-types.js - Game type definitions
+ global.d.ts - Global TypeScript definitions
+Images/, sounds/ - Game assets
+libraries/ - p5.js library files
+```
+
+## Global State
+
+**Critical globals** (defined in sketch.js):
+- `ants[]` - Global ant array (NOT antManager.ants)
+- `selectables[]` - Selection entities
+- `g_map2` - Active terrain map (MapManager)
+- `spatialGridManager` - Spatial queries
+- `draggablePanelManager` - UI panels
+- `cameraManager` - Camera transforms
+- `GameState` - State transitions
+
+**JSDOM requirement**: Always sync `global` and `window`:
+```javascript
+global.SomeClass = MockClass;
+window.SomeClass = global.SomeClass; // Required
+```
+
+## Testing Anti-Patterns (REJECT IMMEDIATELY)
+
+**Language RED FLAGS**:
+- ❌ "**REAL** function" → ✅ "function"
+- ❌ "**actual** data" → ✅ "data"
+- ❌ "**fake**" → ✅ Remove
+- ❌ "**authentic**" → ✅ Remove
+
+**Code RED FLAGS**:
+- ❌ `expect(counter).to.equal(5)` - testing loop counters
+- ❌ `expect(true).to.be.true` - placeholder tests
+- ❌ `obj._privateMethod()` - testing private methods
+- ❌ `antObj.jobPriority = priority` - manual injection without constructors
+- ❌ `results['tests_passed'] = 17` - hardcoded results
+- ❌ Non-headless browser tests
+
+**Quality**: Use system APIs, catch real bugs, run headless, provide screenshots.
+
+## Debug System
+
+**Universal Debugger** (auto-integrates with all entities):
+
+**Keyboard**:
+- `` ` `` - Toggle nearest debugger
+- `Shift + `` ` `` - Show all (up to 200)
+- `Alt + `` ` `` - Hide all
+- `Ctrl+Shift+1` - Performance overlay
+- `Ctrl+Shift+2` - Entity inspector
+- `Ctrl+Shift+3` - Debug console
+
+**Console**: `demonstrateEntityDebugger()`, `setDebugLimit(50)`, `showPerformanceData()`
+
+## Camera System
+
+**CameraManager**: Position, zoom, input
+
+**Transforms**:
+- `screenToWorld(mouseX, mouseY)` - screen to world coords
+- `worldToScreen(entityX, entityY)` - world to screen coords
+
+## Documentation Standards
+
+### Update, Don't Create
+
+**ALWAYS update existing documentation** instead of creating new summary files.
+
+**Correct approach**:
+- Update existing `docs/roadmaps/[FEATURE]_ROADMAP.md` with progress
+- Update `docs/api/[System]_API_Reference.md` with new methods
+- Update `docs/LEVEL_EDITOR_SETUP.md` with new features
+- Update `test/KNOWN_ISSUES.md` when fixing bugs
+- Update `CHANGELOG.md` with user-facing changes
+
+**WRONG approach** (DO NOT DO THIS):
+- Creating `FEATURE_COMPLETE_SUMMARY.md` (update roadmap instead)
+- Creating `BUG_FIX_REPORT.md` (update KNOWN_ISSUES.md instead)
+- Creating `TEST_RESULTS_[DATE].md` (update test docs instead)
+- Creating duplicate documentation (confuses maintainers)
+
+**Exception**: Only create NEW documentation for:
+- New major features (architecture docs, API references)
+- New subsystems (quick reference guides)
+- Entirely new processes (testing guides, checklists)
+
+### Emoji Usage Policy
+
+**Use emojis ONLY for visual clarity** in documentation, NOT in code comments.
+
+**Allowed** (visual scanning):
+- Checkmarks and X marks in checklists
+- Warning symbols for critical sections
+- Status indicators in roadmaps
+
+**Examples**:
+```markdown
+
+- ✅ Unit tests passing
+- ❌ E2E tests failing
+- ⚠️ CRITICAL: Must call ensureGameStarted()
+
+
+- 🎨 Paint tool (use "Paint" instead)
+- 🪣 Fill tool (use "Fill" instead)
+- 💧 Eyedropper (use "Eyedropper" instead)
+```
+
+**Code comments**: NEVER use emojis
+```javascript
+// CORRECT
+// CRITICAL: Must initialize before use
+
+// WRONG
+// ⚠️ CRITICAL: Must initialize before use
+```
+
+## Critical Reminders
+
+1. **MVC ALWAYS** - ALL new features use Model-View-Controller pattern
+2. **TDD ALWAYS** - Write tests before implementation (unit → integration → E2E)
+3. **USE CHECKLISTS** - Follow `FEATURE_ENHANCEMENT_CHECKLIST.md` for all features
+4. **CREATE ROADMAPS** - Document phases for features >2 hours work
+5. **UPDATE DOCS** - Modify existing docs, don't create new summaries
+6. **Script load order matters** - Rendering before Entity, Entity before controllers
+7. **System APIs only** - Never manual property injection in tests
+8. **Headless only** - `--headless=new` for all browser tests
+9. **Read testing docs** - TESTING_METHODOLOGY_STANDARDS.md before any test
+10. **MapManager for terrain** - Never Grid.get() (Y-axis bug)
+11. **E2E screenshots** - Visual proof required, not just internal state
+12. **Force redraw** - Call `window.redraw()` multiple times after state changes
+13. **Ensure game started** - Use `cameraHelper.ensureGameStarted()` in E2E
+14. **Controllers optional** - Check availability before delegation
+15. **No emoji decoration** - Use only for visual clarity (checkmarks, warnings)
+16. **MVC separation** - Model (data), View (render), Controller (orchestrate)
+
+## Quick Reference
+
+**Core APIs**:
+- **Entity API**: `Classes/containers/Entity.js`
+- **EventManager API**: `docs/api/EventManager_API_Reference.md`
+- **Rendering**: `docs/pipelines/RENDERING_PIPELINE.md`
+- **Spatial Grid**: `docs/quick-reference-spatial-grid.md`
+- **MapManager**: `docs/quick-reference-mapmanager.md`
+
+**Testing & Development**:
+- **Testing Guide**: `docs/guides/TESTING_TYPES_GUIDE.md`
+- **E2E Quickstart**: `docs/guides/E2E_TESTING_QUICKSTART.md`
+- **Feature Enhancement Checklist**: `docs/checklists/FEATURE_ENHANCEMENT_CHECKLIST.md`
+- **Feature Development Checklist**: `docs/checklists/FEATURE_DEVELOPMENT_CHECKLIST.md`
+- **Known Issues**: `test/KNOWN_ISSUES.md`
+
+**Current Work**:
+- **Level Editor Setup**: `docs/LEVEL_EDITOR_SETUP.md`
+- **Random Events Roadmap**: `docs/roadmaps/RANDOM_EVENTS_ROADMAP.md` (Phase 3A complete)
diff --git a/.github/workflows/cassiniDeploy.yml b/.github/workflows/cassiniDeploy.yml
new file mode 100644
index 00000000..d26a5ebf
--- /dev/null
+++ b/.github/workflows/cassiniDeploy.yml
@@ -0,0 +1,75 @@
+name: cassiniDeployFlow
+
+on:
+ workflow_dispatch:
+
+env:
+ HOST: cassini.cs.kent.edu
+ USER: ants
+ TARGET: ants@cassini.cs.kent.edu
+ RUN: ssh -o LogLevel=ERROR ants@cassini.cs.kent.edu
+ COPY: scp -o LogLevel=ERROR
+ LOGGING: set -o xtrace
+
+jobs:
+ cassini_deploy:
+ runs-on: ubuntu-latest
+ steps:
+ - name: Checkout files...
+ uses: actions/checkout@v2
+ - name: Get ssh key...
+ uses: shimataro/ssh-key-action@v2
+ with:
+ key: ${{ secrets.ID_ED25519 }}
+ name: id_ed25519
+ known_hosts: ${{ secrets.KNOWN_HOSTS }}
+
+ - name: See VM...
+ run: |
+ echo $ set -o xtrace ; # Log all commands without explicit echo
+ $LOGGING
+
+ ls -la
+ whoami
+
+ - name: See cassini...
+ run:
+ echo "Enabling xtrace on remote, displays commands run on cassini via ssh ~ set -o xtrace" ;
+ $LOGGING
+
+ $RUN ls -la
+
+ - name: Update cassini files for deploy...
+ run:
+ $LOGGING
+
+ $RUN "rm -rf ~/softwareEngineering_teamDelta/" ;
+
+ $RUN git clone https://github.com/AlexTregub/softwareEngineering_teamDelta.git ;
+
+ $RUN "cd ~/softwareEngineering_teamDelta/ ; git fetch ; git switch Dev ; git pull"
+
+ # $RUN "cd softwareEngineering_teamDelta/"
+
+ - name: Clone needed files to web directory...
+ run:
+ $LOGGING
+
+ $RUN "rm -rf ~/web/"
+
+ $RUN "cp -r ~/softwareEngineering_teamDelta/ ~/web"
+
+ - name: Stop previous screen session...
+ run:
+ $LOGGING
+
+ $RUN killall screen
+
+ # $RUN screen -S sessionname -p 0 -X quit
+ continue-on-error: true
+
+ - name: Start screen with http server...
+ run:
+ $LOGGING
+
+ $RUN "cd ~/softwareEngineering_teamDelta/ ; screen -dm python -m http.server 8029"
\ No newline at end of file
diff --git a/.github/workflows/cassiniDeployLatest.yml b/.github/workflows/cassiniDeployLatest.yml
new file mode 100644
index 00000000..11f5d0d6
--- /dev/null
+++ b/.github/workflows/cassiniDeployLatest.yml
@@ -0,0 +1,83 @@
+name: deployToCassiniManual
+
+on:
+ workflow_dispatch:
+
+env:
+ HOST: cassini.cs.kent.edu
+ USER: ants
+ TARGET: ants@cassini.cs.kent.edu
+ RUN: ssh -o LogLevel=ERROR ants@cassini.cs.kent.edu
+ COPY: scp -o LogLevel=ERROR
+ PORT: 8029
+ LOGGING: set -o xtrace
+
+jobs:
+ cassini_deploy:
+ runs-on: ubuntu-latest
+ steps:
+ - name: Checkout files...
+ uses: actions/checkout@v2
+ - name: Get ssh key...
+ uses: shimataro/ssh-key-action@v2
+ with:
+ key: ${{ secrets.ID_ED25519 }}
+ name: id_ed25519
+ known_hosts: ${{ secrets.KNOWN_HOSTS }}
+
+ - name: Zip & copy files to cassini
+ run:
+ $LOGGING
+
+ echo "Remote files" ;
+ ls -la ;
+
+ echo "Target files" ;
+ $RUN ls -la ;
+
+ echo "Prep files for zip... (note dotfiles ignored)" ;
+ echo "Nothing done. Drop remote tests in future." ;
+
+ echo "Zipping + sending... (ignore rmrf fail)" ;
+ zip -r deploy.zip ./* ;
+ $RUN mkdir -p /home/$USER/web ;
+ $RUN "rm -rf /home/$USER/web/* || true " ;
+ $RUN "rm -rf /home/$USER/web/.* || true " ;
+
+ echo "Also providing alternative tar+gz..." ;
+ tar -cf deploy.tar ./* ;
+ gzip -k deploy.tar ;
+
+ echo "Sending zipped...";
+ $COPY deploy.zip $TARGET:/home/$USER/web ;
+ $COPY deploy.tar.gz $TARGET:/home/$USER/web ;
+
+ echo "First attempt direct 'unzip' (keeping all intact incase of failure...)";
+ $RUN "cd /home/$USER/web && unzip -o deploy.zip && echo "unzip success..." && rm deploy.tar.gz && rm deploy.zip || true";
+
+ echo "Fallback incase of unzip missing (currently is...)";
+ $RUN "cd /home/$USER/web && gzip -d deploy.tar.gz && tar -xf deploy.tar && echo "tar+gzip success..." && rm deploy.tar && rm deploy.zip || true";
+
+ echo "Target state after deploy" ;
+ $RUN ls -la /home/$USER/web ;
+
+ - name: Configure screen session
+ run:
+ $LOGGING
+
+ echo "Kill existing screen session...";
+ $RUN "screen -S $USER -X quit || true" ;
+
+ echo "Sleeping to ensure screen session killed...";
+ sleep 5;
+
+ $RUN "cd /home/$USER/web && screen -dmS $USER python -m http.server $PORT";
+
+ - name: Verify deploy+run
+ run:
+ $LOGGING
+
+ echo "Ensure target sever started...";
+ sleep 60;
+
+ curl -f http://$HOST:$PORT && echo "Remote target server running" || echo "Unable to verify remote target started server...";
diff --git a/.github/workflows/deploy.yml b/.github/workflows/deploy.yml
new file mode 100644
index 00000000..ec6cd398
--- /dev/null
+++ b/.github/workflows/deploy.yml
@@ -0,0 +1,49 @@
+name: Deploy to GitHub Pages
+
+on:
+ push:
+ branches: [ main, Dev ]
+ workflow_dispatch:
+
+# Sets permissions of the GITHUB_TOKEN to allow deployment to GitHub Pages
+permissions:
+ contents: read
+ pages: write
+ id-token: write
+
+# Allow only one concurrent deployment, skipping runs queued between the run in-progress and latest queued.
+# However, do NOT cancel in-progress runs as we want to allow these production deployments to complete.
+concurrency:
+ group: "pages"
+ cancel-in-progress: false
+
+jobs:
+ # Build job
+ build:
+ runs-on: ubuntu-latest
+ steps:
+ - name: Checkout
+ uses: actions/checkout@v4
+ with:
+ submodules: false
+
+ - name: Setup Pages
+ uses: actions/configure-pages@v4
+
+ - name: Upload artifact
+ uses: actions/upload-pages-artifact@v3
+ with:
+ # Upload entire repository (since it's a static site)
+ path: '.'
+
+ # Deployment job
+ deploy:
+ environment:
+ name: github-pages
+ url: ${{ steps.deployment.outputs.page_url }}
+ runs-on: ubuntu-latest
+ needs: build
+ steps:
+ - name: Deploy to GitHub Pages
+ id: deployment
+ uses: actions/deploy-pages@v4
\ No newline at end of file
diff --git a/.gitignore b/.gitignore
index 79d3c478..dd2b5ff6 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,3 +1,45 @@
/jsconfig.json
/Ignore
-/.vscode
\ No newline at end of file
+/.vscode
+
+# Node.js dependencies
+node_modules/
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+
+# Package lock files (optional - some teams commit these)
+# package-lock.json
+
+# Environment variables
+.env
+.env.local
+.env.development.local
+.env.test.local
+.env.production.local
+
+# Runtime data
+pids
+*.pid
+*.seed
+*.pid.lock
+
+# Coverage directory used by tools like istanbul
+coverage/
+*.lcov
+
+# Build outputs
+dist/
+build/
+
+# Test outputs and screenshots
+test/puppeteer/screenshots/
+test/bdd/Results
+test/e2e/screenshots/
+test/e2e/**/screenshots/
+test/smoke/**/screenshots/
+test/integration/**/screenshots/
+test/unit/**/screenshots/
+test/baseline/e2e/screenshots/
+test/baseline/e2e/*.json
+test/e2e/MORNING_QUICK_REFERENCE.md
diff --git a/.mocharc.json b/.mocharc.json
new file mode 100644
index 00000000..7fbe0298
--- /dev/null
+++ b/.mocharc.json
@@ -0,0 +1,10 @@
+{
+ "reporter": "spec",
+ "timeout": 5000,
+ "slow": 200,
+ "color": true,
+ "diff": true,
+ "node-option": [
+ "no-warnings"
+ ]
+}
diff --git a/AntStateMachine_Diagram.html b/AntStateMachine_Diagram.html
deleted file mode 100644
index b06a3f08..00000000
--- a/AntStateMachine_Diagram.html
+++ /dev/null
@@ -1,631 +0,0 @@
-
-
-
-
-
- Ant State Machine Diagram
-
-
-
-
-
🐜 Ant State Machine Architecture Diagram
-
-
- Overview: The AntStateMachine uses a hierarchical state system with three independent layers:
- Primary States (main activity), Combat Modifiers (battle status),
- and Terrain Modifiers (environmental effects). States combine to form composite states
- like "MOVING_IN_COMBAT_IN_WATER" with specific action restrictions.
-
-
-
-
-
- Primary States (7 states)
-
-
-
- Combat Modifiers (5 states)
-
-
-
- Terrain Modifiers (5 states)
-
-
-
- Composite State Example
-
-
-
-
-
🎯 Primary States (Main Activities)
-
-
-
-
-
⚔️ Combat Modifiers (Battle Status)
-
-
-
-
-
🌍 Terrain Modifiers (Environmental Effects)
-
-
-
-
-
🔄 Composite State Example
-
-
-
-
-
📋 Action Permission Matrix
-
-
-
-
-
Action
-
IDLE
-
MOVING
-
GATHERING
-
BUILDING
-
MATING
-
IN_COMBAT
-
ATTACKING
-
ON_SLIPPERY
-
IN_WATER
-
-
-
-
-
Move
-
✓
-
✓
-
✓
-
✗
-
✗
-
✓
-
✗
-
✗
-
✓ (50%)
-
-
-
Gather
-
✓
-
✓
-
✓
-
✗
-
✗
-
✗
-
✗
-
✓
-
✓
-
-
-
Attack
-
✗
-
✗
-
✗
-
✗
-
✗
-
✓
-
✓
-
✓
-
✓
-
-
-
Build
-
✓
-
✓
-
✗
-
✓
-
✗
-
✗
-
✗
-
✓
-
✓
-
-
-
Socialize
-
✓
-
✓
-
✗
-
✗
-
✗
-
✗
-
✗
-
✓
-
✓
-
-
-
Mate
-
✓
-
✗
-
✗
-
✗
-
✓
-
✗
-
✗
-
✓
-
✓
-
-
-
-
-
- Note: This matrix shows key state combinations. In practice, all three modifiers
- (Primary + Combat + Terrain) are evaluated together. For example, an ant in
- "BUILDING_IN_COMBAT_ON_SLIPPERY" would be blocked from most actions due to multiple restrictions.
-
-
-
-
-
🔄 State Transition Rules
-
-
Automatic Transitions:
-
-
Combat Detection: OUT_OF_COMBAT → IN_COMBAT when enemy ants detected within range
-
Terrain Changes: Automatic updates based on ant position on game grid
-
Activity Completion: MOVING → IDLE when reaching destination
-
Combat Resolution: IN_COMBAT → OUT_OF_COMBAT when no enemies nearby
-
-
-
Command-Based Transitions:
-
-
Queen Commands: Can force state changes via command queue system
-
Player Input: Direct commands to change primary activities
-
AI Behaviors: Autonomous decisions based on game conditions
-
-
-
Restriction Enforcement:
-
-
State Validation: All transitions checked against canPerformAction()
-
Priority System: Combat and terrain modifiers can override primary state permissions
-
Fallback Mechanisms: Failed actions may trigger return to IDLE state
-
-
-
-
-
-
🎮 Integration with Game Systems
-
-
-
-
-
📊 Implementation Statistics
-
-
-
🔢 State Combinations
-
-
Primary States: 7
-
Combat Modifiers: 5
-
Terrain Modifiers: 5
-
Total Combinations: 175
-
Valid Combinations: ~120 (filtered by restrictions)
-
-
-
-
-
⚡ Performance Features
-
-
O(1) State Queries: Direct property access
-
Efficient Validation: Early exit on restrictions
-
Memory Footprint: ~200 bytes per ant
-
Callback System: Event-driven state changes
-
Debug Support: Comprehensive state logging
-
-
-
-
-
🎯 Design Goals Achieved
-
-
Modularity: Independent state layers
-
Extensibility: Easy to add new states
-
Clarity: Self-documenting state names
-
Testability: Comprehensive test suite
-
Integration: Seamless game system binding
-
-
-
-
-
-
-
\ No newline at end of file
diff --git a/CHANGELOG.md b/CHANGELOG.md
new file mode 100644
index 00000000..2120270d
--- /dev/null
+++ b/CHANGELOG.md
@@ -0,0 +1,286 @@
+# Changelog
+
+All notable changes to the Ant Colony Simulation Game will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+---
+
+## [Unreleased]
+
+### Added
+- EventManager system for random game events (dialogue, spawn, tutorial, boss)
+- Event trigger system (time-based, flag-based, spatial, conditional, viewport)
+- EventEditorPanel for Level Editor (create/edit/test events)
+- JSON import/export for events in Level Editor
+- **SparseTerrain class** for lazy terrain loading (Phase 1B complete)
+ - Map-based sparse tile storage (`Map<"x,y", { material }>`)
+ - Unbounded coordinates (supports negative, very large values)
+ - Dynamic bounds tracking (auto-expands/shrinks with operations)
+ - Sparse JSON export (only painted tiles, massive space savings)
+ - 48 unit tests + 18 integration tests covering all functionality
+ - Foundation for infinite canvas terrain system
+- **DynamicGridOverlay class** for lazy terrain grid rendering (Phase 2A/2B complete)
+ - Grid appears only at painted tiles + 2-tile buffer
+ - Opacity feathering: 1.0 at painted tiles, fades to 0.0 at buffer edge
+ - Shows grid at mouse hover when no tiles painted
+ - Viewport culling for performance (only renders visible lines)
+ - Efficient nearest-tile search using sparse storage
+ - 21 unit tests covering all functionality
+- **DynamicMinimap class** for lazy terrain minimap (Phase 3A/3B complete)
+ - Viewport calculated from painted terrain bounds + padding (not fixed 50x50)
+ - Auto-scaling to fit viewport in minimap dimensions
+ - World-to-minimap coordinate conversion
+ - Renders painted tiles with material colors
+ - Camera viewport outline overlay (yellow)
+ - Handles empty terrain, single tile, negative coords, 1000x1000 bounds
+ - 26 unit tests covering all functionality
+
+### Fixed
+- **Bug Fix 5**: Terrain no longer paints underneath menu bar during drag/click operations
+ - Root cause: `handleDrag()` and `handleClick()` didn't check menu bar position
+ - Solution: Added containsPoint() check before terrain interaction
+ - Tests: 14 unit tests + 6 E2E tests with screenshots
+- **Bug Fix 6**: Terrain no longer paints underneath save/load dialogs
+ - Root cause: `handleClick()` only blocked if dialog consumed click; `handleDrag()` never checked
+ - Solution: Block ALL terrain interaction when either dialog is visible
+ - Tests: 12 unit tests
+- **Bug Fix 7**: View menu panel toggles now work correctly
+ - Root cause: Used wrong panel IDs and accessed wrong manager object
+ - Solution: Use global `draggablePanelManager` with correct full panel IDs
+ - Tests: 9 unit tests
+
+### Changed
+- Level Editor brush size now controlled via menu bar inline controls (+/- buttons)
+- Brush Size draggable panel hidden by default (redundant with menu bar controls)
+- Properties panel hidden by default in Level Editor (toggle via View menu)
+- Events panel hidden by default in Level Editor (toggle via Tools panel)
+
+---
+
+## [0.3.0] - 2025-10-27
+
+### Added - Level Editor Enhancements
+
+#### Feature 1: Brush Size Menu Bar Module
+- Inline brush size controls (+/- buttons) in menu bar
+- Shows/hides based on active tool (visible for paint tool only)
+- Replaces separate draggable brush panel
+- Tests: 10 unit tests + 3 E2E tests with screenshots
+
+#### Feature 2: Shift + Mouse Wheel for Brush Size
+- Shift + scroll up/down adjusts brush size (1-9)
+- Works only when paint tool is active
+- Updates both menu display and terrain editor
+- Normal scroll (without Shift) continues to zoom camera
+- Tests: 9 unit tests + 18 integration tests + 3 E2E tests
+
+#### Feature 3: File → New Clears Terrain
+- Creates blank terrain with confirmation prompt if unsaved changes
+- Resets filename to "Untitled"
+- Clears undo/redo history
+- Default terrain size: 50×50
+- Tests: 8 unit tests + 17 integration tests + 3 E2E tests
+
+#### Feature 4: Save/Export Workflow Redesign
+- File → Save: Prompts for filename (no file download)
+- File → Export: Downloads JSON file (prompts for name if not set)
+- Filename stored without .json extension internally
+- Filename display in editor (top-center)
+- Tests: 10 unit tests + 25 integration tests
+
+#### Feature 5: Menu Open Blocks Terrain Editing
+- Opening menu dropdown disables terrain interaction
+- Menu bar remains clickable while dropdown open
+- Clicking canvas closes menu (click consumed, no painting)
+- Hover preview disabled when menu open
+- Tests: 19 unit tests + 4 E2E tests with screenshots
+
+#### Feature 6: Filename Display
+- Current filename shown at top-center of Level Editor
+- Default: "Untitled"
+- Updates after Save/Load operations
+- Extension (.json) automatically stripped from display
+- Tests: 10 unit tests + 14 integration tests + 3 E2E tests
+
+#### Feature 7: Properties Panel Disabled by Default
+- Properties panel hidden on Level Editor startup
+- Toggle via View → Properties Panel (Ctrl+5)
+- Reduces UI clutter for new users
+- Tests: 7 unit tests + 11 integration tests + 3 E2E tests
+
+#### Feature 8: Events Panel → Tools Panel Toggle
+- Events panel hidden by default
+- Toggle button in Tools panel (not View menu)
+- Contextual placement for event editing workflow
+- Tests: 9 unit tests + 14 integration tests + 3 E2E tests
+
+#### Enhancement 9: Hide Brush Panel by Default
+- Brush Size draggable panel hidden by default
+- Removed "Brush Panel" toggle from View menu
+- Brush size controlled exclusively via menu bar inline controls
+- Other panels (Materials, Tools) remain visible
+- Tests: 5 unit tests + 4 E2E tests with screenshots
+
+### Fixed
+
+#### Bug Fix 1: Feature 1 Redesign
+- Changed from dropdown to inline +/- buttons
+- Fixed visibility logic based on active tool
+- Tests: All Feature 1 tests updated and passing
+
+#### Bug Fix 2: Shift+Scroll Working Correctly
+- Fixed brush size adjustment with Shift modifier
+- Ensured normal scroll continues to zoom
+- Tests: 9 unit tests + 18 integration tests passing
+
+#### Bug Fix 3: Menu Bar Hover Blocks Terrain Interaction
+- Hover preview now disabled when mouse over menu bar
+- Prevents unintended terrain highlighting over UI
+- Tests: 9 unit tests + 4 E2E tests with screenshots
+
+#### Bug Fix 4: Menu Dropdown Blocks All Input
+- **Issue**: Opening menu dropdown froze entire UI
+- **Root Cause**: Click handling checked menu open state FIRST, blocking all clicks
+- **Fix**: Reordered click priority - menu bar checked FIRST, then block terrain if menu open
+- **Result**: Menu bar remains clickable, can switch menus, canvas click closes menu
+- Tests: 19 unit tests + 4 E2E tests with screenshots
+
+#### Bug Fix 5: Terrain Paints Under Menu Bar (Click and Drag)
+- **Issue**: Both click and drag painting occurred when mouse over menu bar
+- **Root Cause**: `handleDrag()` and `handleClick()` didn't check menu bar position
+- **Fix**: Added `containsPoint()` check in both methods before terrain painting
+- **Implementation**:
+ 1. Check if mouse over menu bar → block painting
+ 2. Check if menu is open → block painting
+ 3. EventEditor drag → allow
+ 4. Panel drag → allow
+ 5. Terrain painting (lowest priority)
+- Tests: 14 unit tests + 6 E2E tests with screenshots
+
+### Changed
+- Level Editor click handling priority reordered for better UX
+- Improved test coverage with comprehensive UI mocks in `test/helpers/uiTestHelpers.js`
+
+---
+
+## [0.2.0] - 2025-10-XX
+
+### Added
+- Level Editor with terrain painting, fill tool, eyedropper, select tool
+- TerrainEditor with undo/redo support
+- MaterialPalette for material selection
+- ToolBar for tool selection
+- MiniMap with performance-optimized caching
+- FileMenuBar with Save/Load dialogs
+- DraggablePanelManager for Level Editor UI panels
+- TerrainImporter and TerrainExporter for JSON persistence
+
+### Fixed
+- **DraggablePanel: Boundary Detection Bug**
+ - Off-by-one errors in `isPointInBounds()` method
+ - Tests: 15 passing unit tests
+
+- **GridTerrain & CustomTerrain: imageMode Mismatch**
+ - 0.5-tile visual offset in grid/terrain alignment
+ - Tests: 7 unit + 28 integration + 2 E2E tests passing
+
+- **Grid Coordinate System: Y-Axis Span Boundary Check Bug**
+ - `get()` method incorrectly rejected valid Y-coordinate queries
+ - Workaround: Use `MapManager.getTileAtGridCoords()` instead
+ - Priority: HIGH
+
+- **Level Editor: Select Tool & Hover Preview**
+ - Rectangle selection with click-drag
+ - Paint all tiles under selection
+ - Hover highlights affected tiles
+ - Tests: 19 unit + 13 integration + 4 E2E tests passing
+
+- **Level Editor: Material Names Truncated**
+ - Material names truncated to 4 characters (e.g., "ston" instead of "stone")
+ - Removed `.substring(0, 4)` truncation
+ - Tests: 10 unit tests passing
+
+- **Level Editor: Paint Tool Offset When Zoomed**
+ - **Issue**: Painted tiles appeared offset from cursor when zoomed
+ - **Root Cause**: Transform order was `translate(-camera); scale(zoom)` causing translation to be scaled
+ - **Fix**: Changed to `scale(zoom); translate(-camera)` so translation is not scaled
+ - Mathematical explanation: Wrong order created effective translation of `(-cameraX * zoom)` instead of `(-cameraX)`
+ - Tests: 9 integration tests + 3 E2E tests with screenshots
+
+---
+
+## [0.1.0] - 2025-09-XX
+
+### Added
+- Core game engine with p5.js
+- Ant entity system with state machine
+- Basic terrain generation with Perlin noise
+- Pathfinding system (A* algorithm)
+- Resource collection mechanics
+- Camera system with pan and zoom
+- Spatial grid optimization for entity queries
+- Entity-Controller architecture pattern
+- Basic UI panels and debug overlays
+
+### Infrastructure
+- Test-Driven Development (TDD) methodology
+- Unit test framework (Mocha/Chai)
+- Integration test suite
+- E2E test suite (Puppeteer) with screenshot verification
+- BDD test suite (Python Behave)
+- GitHub Copilot development guidelines
+
+---
+
+## Legend
+
+### Types of Changes
+- **Added**: New features
+- **Changed**: Changes to existing functionality
+- **Deprecated**: Soon-to-be removed features
+- **Removed**: Removed features
+- **Fixed**: Bug fixes
+- **Security**: Vulnerability fixes
+
+### Priority Levels
+- **HIGH**: Blocks core functionality
+- **MEDIUM**: Impacts user experience
+- **LOW**: Minor issues or cosmetic
+
+---
+
+## Testing Summary
+
+### Current Test Coverage
+- **Unit Tests**: 862+ tests
+- **Integration Tests**: 164+ tests
+- **E2E Tests**: 50+ scenarios with screenshot verification
+- **BDD Tests**: Python Behave (headless)
+
+### Test-Driven Development
+All features and bug fixes follow strict TDD:
+1. Write failing tests FIRST
+2. Implement minimal code to pass
+3. Run tests (confirm pass)
+4. Refactor while keeping tests green
+5. Write E2E tests with visual proof (screenshots)
+
+---
+
+## Contributors
+
+David Willman
+- Level Editor development and testing
+- Bug fixes and enhancements
+- Test infrastructure and coverage
+- Documentation and changelogs
+
+---
+
+## Notes
+
+This changelog tracks all changes from version 0.1.0 onwards. For detailed bug tracking, see `test/KNOWN_ISSUES.md`. For development checklists, see `docs/checklists/`.
+
+**Current Status**: 7 total issues tracked, 7 fixed, 0 open
diff --git a/Classes/ants/AntFactory.js b/Classes/ants/AntFactory.js
new file mode 100644
index 00000000..e4f80899
--- /dev/null
+++ b/Classes/ants/AntFactory.js
@@ -0,0 +1,139 @@
+/**
+ * Legacy Ant Factory
+ * Creates instances of the Entity-based ant class with proper job types
+ */
+
+class LegacyAntFactory {
+ /**
+ * Create a single ant with specified job
+ * @param {Object} options - Configuration options
+ * @param {number} options.x - X position
+ * @param {number} options.y - Y position
+ * @param {string} options.jobName - Job type (Scout, Builder, Farmer, Warrior, Spitter, Queen)
+ * @param {string} options.faction - Faction (default: 'player')
+ * @param {number} options.movementSpeed - Movement speed
+ * @returns {ant} Ant instance
+ */
+ static create(options = {}) {
+ const x = options.x || 0;
+ const y = options.y || 0;
+ const jobName = options.jobName || 'Scout';
+ const faction = options.faction || 'player';
+ const movementSpeed = options.movementSpeed || 1;
+
+ // Get job-specific image if available
+ const img = (typeof JobImages !== 'undefined' && JobImages[jobName]) || antBaseSprite;
+
+ // Create ant with proper parameters
+ const newAnt = new ant(x, y, 20, 20, movementSpeed, 0, img, jobName, faction);
+
+ return newAnt;
+ }
+
+ /**
+ * Create a Scout ant
+ */
+ static createScout(x, y, options = {}) {
+ return LegacyAntFactory.create({ x, y, jobName: 'Scout', ...options });
+ }
+
+ /**
+ * Create a Builder ant
+ */
+ static createBuilder(x, y, options = {}) {
+ return LegacyAntFactory.create({ x, y, jobName: 'Builder', ...options });
+ }
+
+ /**
+ * Create a Farmer ant
+ */
+ static createFarmer(x, y, options = {}) {
+ return LegacyAntFactory.create({ x, y, jobName: 'Farmer', ...options });
+ }
+
+ /**
+ * Create a Warrior ant
+ */
+ static createWarrior(x, y, options = {}) {
+ return LegacyAntFactory.create({ x, y, jobName: 'Warrior', ...options });
+ }
+
+ /**
+ * Create a Spitter ant
+ */
+ static createSpitter(x, y, options = {}) {
+ return LegacyAntFactory.create({ x, y, jobName: 'Spitter', ...options });
+ }
+
+ /**
+ * Create a Queen ant
+ */
+ static createQueen(x, y, options = {}) {
+ return LegacyAntFactory.create({ x, y, jobName: 'Queen', ...options });
+ }
+
+ /**
+ * Create multiple ants with spacing
+ * @param {number} count - Number of ants
+ * @param {Object} options - Configuration options
+ * @returns {Array} Array of ant instances
+ */
+ static createMultiple(count, options = {}) {
+ const ants = [];
+ const baseX = options.x || 0;
+ const baseY = options.y || 0;
+ const spacing = options.spacing || 30;
+
+ for (let i = 0; i < count; i++) {
+ const offsetX = baseX + (i % 5) * spacing;
+ const offsetY = baseY + Math.floor(i / 5) * spacing;
+
+ const newAnt = LegacyAntFactory.create({
+ ...options,
+ x: offsetX,
+ y: offsetY
+ });
+
+ ants.push(newAnt);
+ }
+
+ return ants;
+ }
+
+ /**
+ * Create one of each job type for testing
+ * @param {number} x - Base X position
+ * @param {number} y - Base Y position
+ * @param {Object} options - Additional options
+ * @returns {Object} Object with arrays for each job type
+ */
+ static createTestSquad(x = 100, y = 100, options = {}) {
+ const spacing = options.spacing || 50;
+
+ return {
+ scout: LegacyAntFactory.createScout(x, y, options),
+ builder: LegacyAntFactory.createBuilder(x + spacing, y, options),
+ farmer: LegacyAntFactory.createFarmer(x + spacing * 2, y, options),
+ warrior: LegacyAntFactory.createWarrior(x + spacing * 3, y, options),
+ spitter: LegacyAntFactory.createSpitter(x + spacing * 4, y, options)
+ };
+ }
+
+ /**
+ * Get list of available job types
+ * @returns {string[]} Array of job names
+ */
+ static getJobTypes() {
+ return ['Scout', 'Builder', 'Farmer', 'Warrior', 'Spitter', 'Queen'];
+ }
+}
+
+// Export for browser
+if (typeof window !== 'undefined') {
+ window.LegacyAntFactory = LegacyAntFactory;
+}
+
+// Export for Node.js (tests)
+if (typeof module !== 'undefined' && module.exports && typeof window === 'undefined') {
+ module.exports = LegacyAntFactory;
+}
diff --git a/Classes/ants/AntGameExample.js b/Classes/ants/AntGameExample.js
deleted file mode 100644
index 2c4f4c19..00000000
--- a/Classes/ants/AntGameExample.js
+++ /dev/null
@@ -1,218 +0,0 @@
-// AntStateMachine Integration Example
-// This file demonstrates how to use the new state machine features
-
-// Import required classes (adjust paths as needed)
-const AntStateMachine = require('./AntStateMachine.js');
-// const Queen = require('./Queen.js');
-
-// Example usage in your main game file:
-
-function setupAntGame() {
- // Create queens for different factions
- let playerQueen = new Queen(400, 300, "player");
- let enemyQueen = new Queen(100, 100, "enemy");
-
- // Spawn ants and assign to queens
- Ants_Spawn(10); // Your existing spawn function
-
- // Assign first 5 ants to player, next 5 to enemy
- for (let i = 0; i < ant_Index; i++) {
- if (i < 5) {
- playerQueen.addAnt(ants[i].antObject || ants[i]);
- } else {
- enemyQueen.addAnt(ants[i].antObject || ants[i]);
- }
- }
-
- return { playerQueen, enemyQueen };
-}
-
-// Example queen commands
-function demonstrateQueenCommands(queen) {
- // Command all ants to gather resources
- queen.orderGathering();
-
- // Command specific ant to move to location
- if (queen.ants.length > 0) {
- queen.commandAnt(queen.ants[0], { type: "MOVE", x: 500, y: 400 });
- }
-
- // Emergency rally all ants to queen
- queen.emergencyRally();
-
- // Get status report
- const status = queen.getAntStatus();
- console.log("Ant Status Report:", status);
-}
-
-// Example terrain integration (you'll need to adapt this to your grid system)
-function integrateWithTerrain() {
- // Override the detectTerrain method in your ant instances
- ant.prototype.detectTerrain = function() {
- // Example: Check your grid/tile system
- const tileX = Math.floor(this.posX / TILE_SIZE);
- const tileY = Math.floor(this.posY / TILE_SIZE);
-
- // Replace with your actual terrain checking logic
- if (isWaterTile(tileX, tileY)) return "IN_WATER";
- if (isMudTile(tileX, tileY)) return "IN_MUD";
- if (isSlipperyTile(tileX, tileY)) return "ON_SLIPPERY";
- if (isRoughTile(tileX, tileY)) return "ON_ROUGH";
-
- return "DEFAULT";
- };
-}
-
-// Example keyboard controls for commanding ants
-function handleKeyCommands() {
- if (keyIsPressed) {
- switch (key) {
- case 'g':
- // Command selected ant to gather
- if (selectedAnt) {
- selectedAnt.startGathering();
- }
- break;
- case 'b':
- // Command selected ant to build
- if (selectedAnt) {
- selectedAnt.startBuilding();
- }
- break;
- case 'f':
- // Command selected ant to follow mouse
- if (selectedAnt) {
- selectedAnt.followTarget({ x: mouseX, y: mouseY });
- }
- break;
- case 'r':
- // Rally all ants to mouse position
- if (playerQueen) {
- playerQueen.gatherAntsAt(mouseX, mouseY);
- }
- break;
- }
- }
-}
-
-// Example debug display
-function displayAntDebugInfo() {
- if (selectedAnt && typeof devConsoleEnabled !== 'undefined' && devConsoleEnabled) {
- const summary = selectedAnt.getStateSummary();
-
- // Display state information
- fill(255);
- textAlign(LEFT);
- textSize(12);
- text(`Selected Ant State: ${selectedAnt.getCurrentState()}`, 10, 30);
- text(`Faction: ${selectedAnt.faction}`, 10, 50);
- text(`Effective Speed: ${selectedAnt.getEffectiveMovementSpeed()}`, 10, 70);
- text(`In Combat: ${selectedAnt.isInCombat()}`, 10, 90);
- text(`Command Queue: ${selectedAnt.commandQueue.length}`, 10, 110);
- text(`Nearby Enemies: ${selectedAnt.nearbyEnemies.length}`, 10, 130);
-
- // Display available actions
- let y = 160;
- text("Available Actions:", 10, y);
- const actions = ["move", "gather", "attack", "defend", "build", "socialize"];
- actions.forEach(action => {
- y += 20;
- const canPerform = selectedAnt.stateMachine.canPerformAction(action);
- fill(canPerform ? color(0, 255, 0) : color(255, 0, 0));
- text(`${action}: ${canPerform}`, 20, y);
- });
- }
-}
-
-// Integration with your existing mouse controls
-function enhancedAntClickControl() {
- if (selectedAnt) {
- // If holding shift, add command to queue instead of replacing
- if (keyIsDown(SHIFT)) {
- selectedAnt.addCommand({ type: "MOVE", x: mouseX, y: mouseY });
- } else {
- selectedAnt.moveToTarget(mouseX, mouseY);
- }
- selectedAnt.isSelected = false;
- selectedAnt = null;
- return;
- }
-
- // Select ant under mouse
- selectedAnt = ant.selectAntUnderMouse(ants, mouseX, mouseY);
-}
-
-// Example state-based AI behaviors
-function updateAntAI(ant) {
- // Example: Automatic behavior based on state
-
- if (ant.isIdle() && ant.faction === "enemy") {
- // Enemy ants patrol when idle
- if (Math.random() < 0.01) { // 1% chance per frame
- const patrolX = ant.posX + random(-100, 100);
- const patrolY = ant.posY + random(-100, 100);
- ant.moveToTarget(patrolX, patrolY);
- }
- }
-
- if (ant.isInCombat()) {
- // Combat behavior - attack nearest enemy
- if (ant.nearbyEnemies.length > 0 && ant.stateMachine.canPerformAction("attack")) {
- ant.stateMachine.setCombatModifier("ATTACKING");
- // Add actual combat logic here
- }
- }
-}
-
-/*
-Usage in your main game loop:
-
-function setup() {
- // Your existing setup
- const { playerQueen, enemyQueen } = setupAntGame();
- integrateWithTerrain();
-}
-
-function draw() {
- // Your existing rendering
-
- // Update queens
- playerQueen.update();
- enemyQueen.update();
-
- // Update ants (your existing Ants_Update function already calls ant.update())
- Ants_Update();
-
- // Additional AI updates
- for (let i = 0; i < ant_Index; i++) {
- if (ants[i]) {
- const antObj = ants[i].antObject || ants[i];
- updateAntAI(antObj);
- }
- }
-
- // Handle input
- handleKeyCommands();
-
- // Debug display
- displayAntDebugInfo();
-
- // Render queens
- playerQueen.render();
- enemyQueen.render();
-}
-
-function mousePressed() {
- enhancedAntClickControl();
-}
-*/
-
-module.exports = {
- setupAntGame,
- demonstrateQueenCommands,
- integrateWithTerrain,
- handleKeyCommands,
- displayAntDebugInfo,
- enhancedAntClickControl,
- updateAntAI
-};
\ No newline at end of file
diff --git a/Classes/ants/Boss.js b/Classes/ants/Boss.js
new file mode 100644
index 00000000..c4ba38bc
--- /dev/null
+++ b/Classes/ants/Boss.js
@@ -0,0 +1,117 @@
+
+class Boss extends QueenAnt {
+ constructor(entityName,entityFaction,entitySizeX,entitySizeY,tileType=['grass']) {
+ let queenBase = new spawnQueen();
+
+ let a = g_activeMap.sampleTiles(tileType,10000); //
+
+ let tilex = a[0][0]; // Picks initial random position
+ let tiley = a[0][1]; // ...
+
+ for (let pos in a) { // pos is an index in a
+ // let pos = a[pos]
+
+ let temp = a[pos]
+ // console.log(temp)
+ if (temp[0] < 15 & temp[0] > -15 & temp[1] < 15 & temp[1] > -15) { // Bounds close to center
+ tilex = temp[0]
+ tiley = temp[1] // tile positions (grid)
+
+ //console.log("DONE DID IT FOR THE BOSS")
+ break
+ }
+ }
+
+ if (tilex > 15 | tilex < -15 | tiley > 15 | tiley < -15) {
+ tilex = 0
+ tiley = 0
+ // console.log("WARNING: DEFAULT SPAWN POS FOR SPIDER")
+ }
+
+ let convPos = g_activeMap.renderConversion.convPosToCanvas([tilex,tiley])
+
+ queenBase.setPosition(convPos[0],convPos[1])
+
+ //console.log("TARGETBOSSENTITY",queenBase,convPos,Buildings[0])
+
+ super(queenBase,convPos);
+
+
+ this._type = entityName;
+ this._faction = entityFaction;
+ this.assignJob(entityName, JobImages[entityName]);
+ this.setSize(entitySizeX, entitySizeY);
+
+
+ ants.splice(ants.indexOf(queenBase), 1);
+ ants.push(this);
+
+
+ this.currentTarget = null;
+ this.currentTargetDistance = 0;
+ this._gatherState = null;
+ this._movementController._skitterRange = 100;
+ this._attackCooldown = .25; // seconds
+ this._attackRange = 40;
+
+ // Stats
+ this.defaultStats = this.job.stats;
+ this.amountEaten = 0;
+ }
+
+ nearestAnt(){
+ let nearest = null;
+ let minDist = Infinity;
+ for (let ant of ants) {
+ if (ant._faction === this._faction || ant === this) {
+ continue;
+ }
+
+ let d = dist(this.posX, this.posY, ant.posX, ant.posY);
+ if (d < minDist) {
+ minDist = d;
+ nearest = ant;
+ }
+ }
+ return [nearest,minDist];
+ }
+
+ _updateResourceManager(){}
+
+
+ applyBuff(){
+ let buff = {
+ health: this.defaultStats.health * .01, // 1% of max health
+ movementSpeed: this.defaultStats.movementSpeed * .01, // 1% of movement speed
+ strength: this.defaultStats.strength * .01, // 1% of strength
+ gatherSpeed: this.defaultStats.gatherSpeed,
+ };
+ this._applyJobStats(buff);
+
+ if(this.amountEaten % 5 === 0){
+ this.setSize(this.width * .01, this.height * .01); // Increase size by 1%
+ }
+ }
+
+ update() {
+ super.update();
+ if(this._stateMachine && !this._stateMachine.isInCombat()){
+ //console.log(this.getCurrentState());
+ }else{
+ this._performCombatAttack();
+ }
+
+ }
+}
+
+class Spider extends Boss{
+ constructor(type = "Spider", faction = "enemy", x = 50, y = 50) {
+ super(type, faction, x, y);
+ }
+}
+
+class AntEater extends Boss{
+ constructor(type = "AntEater", faction = "enemy", x = 50, y = 50) {
+ super(type, faction, x, y);
+ }
+}
\ No newline at end of file
diff --git a/Classes/ants/GatherState.js b/Classes/ants/GatherState.js
new file mode 100644
index 00000000..d074d657
--- /dev/null
+++ b/Classes/ants/GatherState.js
@@ -0,0 +1,398 @@
+/**
+ * @fileoverview GatherState - Autonomous resource gathering behavior for ants
+ * @module GatherState
+ * @author Software Engineering Team Delta - AI Assistant
+ * @version 1.0.0
+ */
+
+/**
+ * GatherState handles autonomous resource detection and collection within a 7-grid radius.
+ * Ants in this state will continuously scan for resources, move to collect them,
+ * and transition to drop-off behavior when at capacity.
+ *
+ * Features:
+ * - 7-grid tile radius resource detection (224 pixel radius with 32px tiles)
+ * - Prioritized resource selection (closest first)
+ * - Automatic pathfinding to resources
+ * - Inventory management and capacity checking
+ * - State transitions (to DROPPING_OFF when full, back to IDLE when done)
+ *
+ * @class GatherState
+ */
+class GatherState {
+ /**
+ * Creates a new GatherState behavior handler
+ * @param {Object} ant - The ant entity this state controls
+ */
+ constructor(ant) {
+ this.ant = ant;
+ this.gatherRadius = 7; // Grid tiles (7 * 32 = 224 pixels)
+ this.pixelRadius = this.gatherRadius * 32; // Convert to pixels (default TILE_SIZE = 32)
+
+ // State tracking
+ this.targetResource = null;
+ this.searchCooldown = 0;
+ this.searchInterval = 30; // frames between resource scans (0.5 sec at 60fps)
+ this.isActive = false;
+
+ // Timeout mechanism
+ this.gatherTimeout = 6000; // 6 seconds in milliseconds
+ this.gatherStartTime = 0; // Track when gathering started
+ this.lastResourceFoundTime = 0; // Track when we last found a resource
+
+ // Continuous gathering
+ this.keepGathering = true; // Continue gathering until max capacity
+ this.resourcesCollected = 0; // Track resources collected this session
+
+ // Debug info
+ this.debugEnabled = false; // Temporarily enable debug for testing
+ this.lastScanResults = 0;
+
+ logVerbose(`🔍 GatherState initialized for ant - radius: ${this.gatherRadius} tiles (${this.pixelRadius}px)`);
+ }
+
+ /**
+ * Activate the gather state
+ */
+ enter() {
+ this.isActive = true;
+ this.targetResource = null;
+ this.searchCooldown = 0;
+ this.gatherStartTime = 0;
+
+ // Set ant to GATHERING primary state
+ if (this.ant._stateMachine) {
+ this.ant._stateMachine.setPrimaryState("GATHERING");
+ }
+
+ if (this.debugEnabled) {
+ logNormal(`🐜 Ant ${this.ant._antIndex || 'unknown'} entered GATHER state`);
+ }
+ }
+
+ /**
+ * Deactivate the gather state
+ */
+ exit() {
+ this.isActive = false;
+ this.targetResource = null;
+
+ if (this.debugEnabled) {
+ logNormal(`🐜 Ant ${this.ant._antIndex || 'unknown'} exited GATHER state`);
+ }
+
+ return true
+ }
+
+ /**
+ * Main update loop for gathering behavior
+ * Called every frame while ant is in GATHERING state
+ */
+ update() {
+ if (!this.isActive) return;
+
+ // Check if ant is at max capacity - switch to drop-off state
+ if (this.isAtMaxCapacity()) {
+ this.transitionToDropOff();
+ return;
+ }
+
+ // Update search cooldown
+ if (this.searchCooldown > 0) {
+ this.searchCooldown--;
+ }
+
+ // If we have a target resource, move toward it
+ if (this.targetResource) {
+ if (this.debugEnabled) {
+ logNormal(`🎯 Ant ${this.ant.id} moving toward resource at (${this.targetResource.x}, ${this.targetResource.y})`);
+ }
+ this.updateTargetMovement();
+ this.gatherStartTime = 0;
+ }
+ // Otherwise, search for new resources
+ else if (this.searchCooldown <= 0) {
+ if (this.debugEnabled) {
+ logNormal(`🔍 Ant ${this.ant.id} searching for resources...`);
+ }
+ this.searchForResources();
+ this.searchCooldown = this.searchInterval;
+ }
+ this.gatherStartTime += deltaTime;
+
+ if (this.gatherStartTime >= this.gatherTimeout) { return this.exit() }
+ }
+
+ /**
+ * Search for resources within the 7-grid radius
+ * @returns {Array} Array of resources found within range
+ */
+ searchForResources() {
+ const antPos = this.getAntPosition();
+ if (!antPos) {
+ if (this.debugEnabled) logNormal(`❌ Ant ${this.ant.id} could not get position for resource search`);
+ return [];
+ }
+
+ const nearbyResources = this.getResourcesInRadius(antPos.x, antPos.y, this.pixelRadius);
+ this.lastScanResults = nearbyResources.length;
+
+ if (this.debugEnabled) {
+ logNormal(`🔍 Ant ${this.ant.id} found ${nearbyResources.length} resources within ${this.gatherRadius} tiles`);
+ }
+
+ if (nearbyResources.length > 0) {
+ // Sort by distance (closest first)
+ nearbyResources.sort((a, b) => {
+ const distA = this.getDistance(antPos.x, antPos.y, a.x, a.y);
+ const distB = this.getDistance(antPos.x, antPos.y, b.x, b.y);
+ return distA - distB;
+ });
+
+ // Select the closest resource as target
+ this.targetResource = nearbyResources[0];
+
+ if (this.debugEnabled) {
+ logNormal(`🔍 Found ${nearbyResources.length} resources, targeting closest at (${this.targetResource.x}, ${this.targetResource.y})`);
+ }
+ }
+
+ return nearbyResources;
+ }
+
+ /**
+ * Get all resources within the specified radius of a position
+ * @param {number} centerX - Center X coordinate
+ * @param {number} centerY - Center Y coordinate
+ * @param {number} radius - Search radius in pixels
+ * @returns {Array} Array of resources within radius
+ */
+ getResourcesInRadius(centerX, centerY, radius) {
+ const nearbyResources = [];
+
+ try {
+ // Try to get resources from the unified resource system
+ let resourceList = [];
+
+ if (typeof g_resourceManager !== 'undefined' && g_resourceManager) {
+ resourceList = g_resourceManager.getResourceList ? g_resourceManager.getResourceList() : [];
+ if (this.debugEnabled) {
+ logNormal(`🔍 Using g_resourceManager, found ${resourceList.length} total resources`);
+ }
+ }
+
+ // Check each resource
+ for (let i = 0; i < resourceList.length; i++) {
+ const resource = resourceList[i];
+ if (!resource) continue;
+
+ // Get resource position
+ const rx = resource.x !== undefined ? resource.x :
+ resource.posX !== undefined ? resource.posX :
+ (resource.getPosition && resource.getPosition().x);
+ const ry = resource.y !== undefined ? resource.y :
+ resource.posY !== undefined ? resource.posY :
+ (resource.getPosition && resource.getPosition().y);
+
+ if (rx === undefined || ry === undefined) continue;
+
+ // Check if resource is within radius
+ const distance = this.getDistance(centerX, centerY, rx, ry);
+ if (distance <= radius) {
+ nearbyResources.push({
+ resource: resource,
+ x: rx,
+ y: ry,
+ distance: distance,
+ type: resource.type || resource._type || resource.resourceType || 'unknown'
+ });
+ }
+ }
+ } catch (error) {
+ console.warn('GatherState: Error scanning for resources:', error);
+ }
+
+ return nearbyResources;
+ }
+
+ /**
+ * Update movement toward the current target resource
+ */
+ updateTargetMovement() {
+ if (!this.targetResource) return;
+
+ const antPos = this.getAntPosition();
+ if (!antPos) return;
+
+ // Check if we've reached the target resource
+ const distance = this.getDistance(antPos.x, antPos.y, this.targetResource.x, this.targetResource.y);
+ const collectionRange = 15; // pixels - close enough to collect
+
+ if (distance <= collectionRange) {
+ this.attemptResourceCollection();
+ } else {
+ // Move toward the resource
+ this.moveToResource(this.targetResource.x, this.targetResource.y);
+ }
+ }
+
+ /**
+ * Attempt to collect the target resource
+ */
+ attemptResourceCollection() {
+ if (!this.targetResource) return;
+
+ try {
+ // Try to collect the resource using the ant's resource manager
+ let collected = false;
+ collected = this.ant._resourceManager.addResource(this.targetResource.resource);
+
+ if (collected) {
+ // Remove resource from global system
+ this.removeResourceFromSystem(this.targetResource.resource);
+
+ if (this.debugEnabled) {
+ logNormal(`✅ Collected ${this.targetResource.type} resource`);
+ }
+ }
+ } catch (error) {
+ console.warn('GatherState: Error collecting resource:', error);
+ }
+
+ // Clear target regardless of success/failure
+ this.targetResource = null;
+ }
+
+ /**
+ * Remove a resource from the global resource system
+ * @param {Object} resource - The resource to remove
+ */
+ removeResourceFromSystem(resource) {
+ try {
+ // Try unified resource system first
+ if (typeof g_resourceManager !== 'undefined' && g_resourceManager && g_resourceManager.removeResource) {
+ g_resourceManager.removeResource(resource);
+ }
+ } catch (error) {
+ console.warn('GatherState: Error removing resource from system:', error);
+ }
+ }
+
+ /**
+ * Move the ant toward a target position
+ * @param {number} targetX - Target X coordinate
+ * @param {number} targetY - Target Y coordinate
+ */
+ moveToResource(targetX, targetY) {
+ try {
+ if (this.ant._movementController && this.ant._movementController.moveToLocation) {
+ this.ant._movementController.moveToLocation(targetX, targetY);
+ }
+ } catch (error) {
+ console.warn('GatherState: Error moving to resource:', error);
+ }
+ }
+
+ /**
+ * Check if ant is at maximum carrying capacity
+ * @returns {boolean} True if ant is at max capacity
+ */
+ isAtMaxCapacity() {
+ try {
+ if (this.ant._resourceManager) {
+ return this.ant._resourceManager.isAtMaxLoad && this.ant._resourceManager.isAtMaxLoad();
+ }
+ } catch (error) {
+ console.warn('GatherState: Error checking capacity:', error);
+ }
+ return false;
+ }
+
+ /**
+ * Transition ant to drop-off state when at capacity
+ */
+ transitionToDropOff() {
+ if (this.debugEnabled) {
+ logNormal(`📦 Ant ${this.ant._antIndex || 'unknown'} at max capacity, transitioning to drop-off`);
+ }
+
+ // Set ant to DROPPING_OFF state
+ if (this.ant._stateMachine) {
+ this.ant._stateMachine.setPrimaryState("DROPPING_OFF");
+ }
+
+ // If the ant has a resource manager with drop-off functionality, use it
+ if (this.ant._resourceManager && this.ant._resourceManager.startDropOff) {
+ // Find nearest drop-off location (default to origin for now)
+ this.ant._resourceManager.startDropOff(0, 0);
+ }
+
+ this.exit();
+ }
+
+ /**
+ * Get the ant's current position
+ * @returns {Object|null} Position object with x, y properties
+ */
+ getAntPosition() {
+ try {
+ if (this.ant.getPosition) {
+ return this.ant.getPosition();
+ } else if (this.ant.posX !== undefined && this.ant.posY !== undefined) {
+ return { x: this.ant.posX, y: this.ant.posY };
+ }
+ } catch (error) {
+ console.warn('GatherState: Error getting ant position:', error);
+ }
+ return null;
+ }
+
+ /**
+ * Calculate distance between two points
+ * @param {number} x1 - First point X
+ * @param {number} y1 - First point Y
+ * @param {number} x2 - Second point X
+ * @param {number} y2 - Second point Y
+ * @returns {number} Distance in pixels
+ */
+ getDistance(x1, y1, x2, y2) {
+ const dx = x2 - x1;
+ const dy = y2 - y1;
+ return Math.sqrt(dx * dx + dy * dy);
+ }
+
+ /**
+ * Get debug information about the gather state
+ * @returns {Object} Debug information
+ */
+ getDebugInfo() {
+ return {
+ isActive: this.isActive,
+ gatherRadius: `${this.gatherRadius} tiles (${this.pixelRadius}px)`,
+ hasTarget: !!this.targetResource,
+ targetType: this.targetResource ? this.targetResource.type : 'none',
+ searchCooldown: this.searchCooldown,
+ lastScanResults: this.lastScanResults,
+ atCapacity: this.isAtMaxCapacity()
+ };
+ }
+
+ /**
+ * Enable or disable debug logging
+ * @param {boolean} enabled - Whether to enable debug output
+ */
+ setDebugEnabled(enabled) {
+ this.debugEnabled = enabled;
+ logNormal(`🐛 GatherState debug ${enabled ? 'enabled' : 'disabled'}`);
+ }
+}
+
+// Export for use in other files
+if (typeof module !== 'undefined' && module.exports) {
+ module.exports = GatherState;
+}
+
+// Make available globally for browser usage
+if (typeof window !== 'undefined') {
+ window.GatherState = GatherState;
+}
\ No newline at end of file
diff --git a/Classes/ants/JobComponent.js b/Classes/ants/JobComponent.js
new file mode 100644
index 00000000..64caa807
--- /dev/null
+++ b/Classes/ants/JobComponent.js
@@ -0,0 +1,70 @@
+// JobComponent - Simple component for job data and stats
+// Replaces the complex Job inheritance system with composition
+
+class JobComponent {
+ constructor(name, image = null) {
+ this.name = name;
+ this.image = image;
+ this.stats = JobComponent.getJobStats(name);
+ }
+
+ // Static method - moved from Job class
+ static getJobStats(jobName) {
+ switch (jobName) {
+ case "Builder":
+ return { strength: 30, health: 120, gatherSpeed: 15, movementSpeed: 55 };
+
+ case "Scout":
+ return { strength: 30, health: 70, gatherSpeed: 8, movementSpeed: 85 };
+
+ case "Farmer":
+ return { strength: 30, health: 100, gatherSpeed: 35, movementSpeed: 50 };
+
+ case "Warrior":
+ return { strength: 45, health: 300, gatherSpeed: 5, movementSpeed: 45 };
+
+ case "Spitter":
+ return { strength: 40, health: 110, gatherSpeed: 5, movementSpeed: 55 };
+
+ case "DeLozier":
+ return { strength: 45, health: 160, gatherSpeed: 5, movementSpeed: 45 };
+
+ case "Queen":
+ // Playable queen ant stats
+ return { strength: 25, health: 500, gatherSpeed: 1, movementSpeed: 100 };
+
+ case "Spider":
+ return { strength: 80, health: 500, gatherSpeed: 3, movementSpeed: 40 };
+
+ case "AntEater":
+ return { strength: 40, health: 500, gatherSpeed: 3, movementSpeed: 40 };
+
+ default:
+ return { strength: 15, health: 100, gatherSpeed: 10, movementSpeed: 60 };
+ }
+ }
+
+
+ // Helper methods
+ static getJobList() {
+ return ["Builder", "Scout", "Farmer", "Warrior", "Spitter"];
+ }
+
+ static getSpecialJobs() {
+ return ["DeLozier"];
+ }
+
+ static getAllJobs() {
+ return [...JobComponent.getJobList(), ...JobComponent.getSpecialJobs()];
+ }
+}
+
+// Export for Node.js testing
+if (typeof module !== 'undefined' && module.exports) {
+ module.exports = JobComponent;
+}
+
+// Browser global
+if (typeof window !== 'undefined') {
+ window.JobComponent = JobComponent;
+}
\ No newline at end of file
diff --git a/Classes/ants/Queen.js b/Classes/ants/Queen.js
index 7b4702ab..7a7bc00f 100644
--- a/Classes/ants/Queen.js
+++ b/Classes/ants/Queen.js
@@ -1,116 +1,303 @@
-// Queen.js
-// Manages commands and coordinates ant activities
+class QueenAnt extends ant {
+ constructor(baseAnt,target=NONE) {
+ // If a base ant is passed, use its properties; otherwise create a default queen ant
+ // console.log('queen',baseAnt.posX, baseAnt.posY, baseAnt.getSize().x, baseAnt.getSize().y, baseAnt.movementSpeed, baseAnt.rotation || 0, baseAnt.getImage(), baseAnt._faction);
-class Queen {
- constructor(x = 400, y = 300, faction = "player") {
- this.position = createVector(x, y);
- this.faction = faction;
- this.commandRadius = 200; // Range within which queen can command ants
- this.ants = []; // Ants under this queen's command
+ // Call parent ant constructor
+ // console.log(Buildings)
+ // console.log(Buildings[0])
+
+ console.log("TARGETBUILDINGANTHILL",Buildings,Buildings[0])
+
+
+ // super(baseAnt.posX, baseAnt.posY, 55,55, baseAnt.movementSpeed, baseAnt.rotation || 0, baseAnt.getImage(),"Queen", baseAnt._faction);
+ if (target == NONE) {
+ super(Buildings[0]._x, Buildings[0]._y, 55,55, baseAnt.movementSpeed, baseAnt.rotation || 0, baseAnt.getImage(),"Queen", baseAnt._faction);
+ } else {
+ super(target[0], target[1], 55,55, baseAnt.movementSpeed, baseAnt.rotation || 0, baseAnt.getImage(),"Queen", baseAnt._faction)
+ }
+
+ // super(closestHive.posX, closestHive.posY, 55,55, baseAnt.movementSpeed, baseAnt.rotation || 0, baseAnt.getImage(),"Queen", baseAnt._faction);
+
+ // let closestHive = this.nearestFriendlyBuilding(
+ // Buildings.filter(b => b.type === "Building" && b._faction === this._faction)
+ // )[0];
+
+
+ // Queen-specific properties
+ this.commandRadius = 250;
+ this.ants = []; // ants under her command
+ this.coolDown = false;
+ this.showCommandRadius = false;
+ // Queen should not perform idle random skitter movements
+ this.getController('movement').disableSkitter = true;
+ this._attackCooldown = .25; // seconds
+
+ // Power unlock flags (false by default - unlock via cheats or progression)
+ this.unlockedPowers = {
+ fireball: true,
+ lightning: true,
+ blackhole: false,
+ sludge: false,
+ tidalWave: false,
+ finalFlash: true
+ };
+
+ // Power levels (1-3, determines strength/effects)
+ this.powerLevels = {
+ fireball: 1,
+ lightning: 1,
+ blackhole: 1,
+ sludge: 1,
+ tidalWave: 1,
+ finalFlash: 1
+ };
}
- // Add an ant to this queen's command
- addAnt(ant) {
- ant.faction = this.faction;
- this.ants.push(ant);
+ // --- ANT MANAGEMENT ---
+
+ addAnt(antObj) {
+ if (!antObj) return;
+ antObj._faction = this.faction;
+ this.ants.push(antObj);
}
- // Remove an ant from command
- removeAnt(ant) {
- const index = this.ants.indexOf(ant);
- if (index > -1) {
- this.ants.splice(index, 1);
- }
+ removeAnt(antObj) {
+ const index = this.ants.indexOf(antObj);
+ if (index > -1) this.ants.splice(index, 1);
}
- // Send command to all ants in range
+ // --- COMMANDS ---
+
broadcastCommand(command) {
- for (const ant of this.ants) {
- const distance = dist(this.position.x, this.position.y, ant.posX, ant.posY);
+ for (const worker of this.ants) {
+ const pos = worker.getPosition();
+ const queenPos = this.getPosition();
+ const distance = dist(queenPos.x, queenPos.y, pos.x, pos.y);
+
if (distance <= this.commandRadius) {
- ant.addCommand(command);
+ switch (command.type) {
+ case "MOVE":
+ worker.moveToLocation(command.x, command.y);
+ break;
+ case "GATHER":
+ worker.addCommand({ type: "GATHER" });
+ break;
+ case "BUILD":
+ worker.addCommand({ type: "BUILD" });
+ break;
+ case "DEFEND":
+ worker.addCommand({ type: "DEFEND", target: command.target });
+ break;
+ }
}
}
}
- // Send command to specific ant
commandAnt(ant, command) {
if (this.ants.includes(ant)) {
ant.addCommand(command);
}
}
- // Command all ants to gather at a location
gatherAntsAt(x, y) {
- this.broadcastCommand({ type: "MOVE", x: x, y: y });
+ this.broadcastCommand({ type: "MOVE", x, y });
}
- // Command all ants to start gathering resources
orderGathering() {
this.broadcastCommand({ type: "GATHER" });
}
- // Command all ants to start building
orderBuilding() {
this.broadcastCommand({ type: "BUILD" });
}
- // Get status of all ants under command
- getAntStatus() {
- return this.ants.map(ant => ({
- antIndex: ant.antIndex,
- state: ant.getCurrentState(),
- position: { x: ant.posX, y: ant.posY },
- isInCombat: ant.isInCombat(),
- commandQueueLength: ant.commandQueue.length
- }));
+ emergencyRally() {
+ const queenPos = this.getPosition();
+ this.broadcastCommand({
+ type: "MOVE",
+ x: queenPos.x,
+ y: queenPos.y,
+ });
}
- // Find ants in a specific state
- getAntsInState(stateName) {
- return this.ants.filter(ant => ant.getCurrentState().includes(stateName));
+ // --- POWER MANAGEMENT ---
+
+ unlockPower(powerName) {
+ if (this.unlockedPowers.hasOwnProperty(powerName)) {
+ this.unlockedPowers[powerName] = true;
+ logNormal(`👑 Queen unlocked power: ${powerName}`);
+ return true;
+ }
+ console.warn(`⚠️ Unknown power: ${powerName}`);
+ return false;
}
- // Emergency command - bring all ants to queen for defense
- emergencyRally() {
- this.broadcastCommand({
- type: "MOVE",
- x: this.position.x,
- y: this.position.y
- });
+ lockPower(powerName) {
+ if (this.unlockedPowers.hasOwnProperty(powerName)) {
+ this.unlockedPowers[powerName] = false;
+ logNormal(`👑 Queen locked power: ${powerName}`);
+ return true;
+ }
+ return false;
+ }
+
+ isPowerUnlocked(powerName) {
+ return this.unlockedPowers[powerName] === true;
+ }
+
+ getUnlockedPowers() {
+ return Object.keys(this.unlockedPowers).filter(power => this.unlockedPowers[power]);
+ }
+
+ getAllPowers() {
+ return { ...this.unlockedPowers };
+ }
+
+ // --- POWER LEVEL MANAGEMENT ---
+
+ setPowerLevel(powerName, level) {
+ if (this.powerLevels.hasOwnProperty(powerName)) {
+ this.powerLevels[powerName] = Math.max(1, Math.min(3, level));
+ logNormal(`👑 Queen set ${powerName} to level ${this.powerLevels[powerName]}`);
+
+ // Update the corresponding manager's level if it exists
+ if (powerName === 'lightning' && typeof window.g_lightningManager !== 'undefined' && window.g_lightningManager) {
+ window.g_lightningManager.setLevel(this.powerLevels[powerName]);
+ }
+
+ return true;
+ }
+ return false;
+ }
+
+ getPowerLevel(powerName) {
+ return this.powerLevels[powerName] || 1;
+ }
+
+ getAllPowerLevels() {
+ return { ...this.powerLevels };
+ }
+
+ // --- MOVEMENT OVERRIDE ---
+
+ move(direction) {
+ const pos = this.getPosition();
+ const speed = this.movementSpeed ; // queen moves slower
+
+ switch (direction) {
+ case "w":
+ this.moveToLocation(pos.x, pos.y + speed);
+ break;
+ case "a":
+ this.moveToLocation(pos.x - speed, pos.y);
+ break;
+ case "s":
+ this.moveToLocation(pos.x, pos.y - speed);
+ break;
+ case "d":
+ this.moveToLocation(pos.x + speed, pos.y);
+ break;
+ }
}
- // Update queen logic
+ // State Override --
+ startGathering(){return;}
+
+
update() {
- // Queen could have AI logic here, like:
- // - Monitoring ant states
- // - Automatic resource gathering commands
- // - Defense coordination
- // - etc.
+ super.update();
+ let isIdle = this._stateMachine.isPrimaryState("IDLE");
+ if(!isIdle){
+ this._stateMachine.setPrimaryState("IDLE");
+ }
+
+ // Example AI logic placeholder
+ // this.broadcastCommand({ type: "GATHER" });
}
- // Render the queen (optional visual representation)
render() {
- if (typeof push !== "undefined") {
+
+ if (this._type == "Queen") {
+ let temp = this.getPosition()
+ // let temp1 = this._controllers.get("render").worldToScreenPos(temp)
+ let temp1 = this._controllers.get("render").worldToScreenPosition(temp)
+
+ let temp2 = g_activeMap.renderConversion.convCanvasToPos([temp1.x,temp1.y])
+
+ // console.log(temp,temp1,temp2)
+ // console.log("QUEEN POSITION @ ",temp2)
+ // console.log("QueenPos:",this.getPosition(),g_activeMap.renderConversion.convCanvasToPos([this.getPosition().x,this.getPosition().y]))
+ }
+
+
+
+ super.render();
+
+ // Draw command radius if visible
+ if (this.showCommandRadius) {
+ // Use Entity's getScreenPosition for proper coordinate conversion
+ const screenPos = this.getScreenPosition();
+
push();
- fill(255, 215, 0); // Gold color for queen
- stroke(0);
+ noFill();
+ stroke(255, 215, 0, 100);
strokeWeight(2);
- ellipse(this.position.x, this.position.y, 30, 30);
-
- // Draw command radius (optional debug view)
- if (this.showCommandRadius) {
- noFill();
- stroke(255, 215, 0, 100);
- strokeWeight(1);
- ellipse(this.position.x, this.position.y, this.commandRadius * 2, this.commandRadius * 2);
- }
+ ellipse(screenPos.x, screenPos.y, this.commandRadius * 2);
pop();
}
}
}
-// Export for use in other files
-if (typeof module !== "undefined" && module.exports) {
- module.exports = Queen;
-}
\ No newline at end of file
+// Window helper command for upgrading powers
+if (typeof window !== 'undefined') {
+ window.upgradePower = function(powerName, level) {
+ const queen = typeof getQueen === 'function' ? getQueen() : null;
+ if (!queen) {
+ console.error('❌ Queen not found! Make sure the game is running.');
+ return false;
+ }
+
+ if (!level) {
+ console.log('📊 Current power levels:', queen.getAllPowerLevels());
+ console.log('💡 Usage: window.upgradePower("lightning", 2)');
+ return queen.getAllPowerLevels();
+ }
+
+ const success = queen.setPowerLevel(powerName, level);
+ if (success) {
+ console.log(`✅ ${powerName} upgraded to level ${queen.getPowerLevel(powerName)}`);
+
+ // Visual feedback
+ if (powerName === 'lightning') {
+ const rangeInTiles = 7 + ((level - 1) * 7);
+ if (level === 2) {
+ console.log('⚡⚡⚡ Lightning now fires THREE bolts in sequence!');
+ console.log(`📏 Range increased to ${rangeInTiles} tiles (${rangeInTiles * 32}px)`);
+ } else if (level === 3) {
+ console.log('⚡⚡⚡ Lightning Level 3!');
+ console.log(`📏 Range increased to ${rangeInTiles} tiles (${rangeInTiles * 32}px)`);
+ }
+ }
+ } else {
+ console.error(`❌ Failed to upgrade ${powerName}. Available powers:`, Object.keys(queen.powerLevels));
+ }
+ return success;
+ };
+
+ // Also add a shortcut for checking levels
+ window.showPowerLevels = function() {
+ const queen = typeof getQueen === 'function' ? getQueen() : null;
+ if (!queen) {
+ console.error('❌ Queen not found!');
+ return;
+ }
+ const levels = queen.getAllPowerLevels();
+ console.log('📊 Power Levels:');
+ for (const [power, level] of Object.entries(levels)) {
+ const unlocked = queen.isPowerUnlocked(power) ? '✅' : '🔒';
+ console.log(` ${unlocked} ${power}: Level ${level}`);
+ }
+ return levels;
+ };
+}
diff --git a/Classes/ants/antBrain.js b/Classes/ants/antBrain.js
new file mode 100644
index 00000000..59f855c2
--- /dev/null
+++ b/Classes/ants/antBrain.js
@@ -0,0 +1,229 @@
+const HUNGRY = 100;
+const STARVING = 160;
+const DEATH = 200;
+let increment = 1;
+
+/*
+To Do:
+ Add Checks for separate factions
+ setState() (Most likely going to use when emergency switching state and just have state machine deal with normal swaps? May change later)
+*/
+
+class AntBrain{
+ constructor(antInstance, antType){
+ logVerbose(`I LIVE!!!`);
+ this.ant = antInstance;
+ this.antType = antType;
+ this.flag_ = "";
+ this.hunger = 0;
+
+ this.followBuildTrail = 0;
+ this.followForageTrail = 0;
+ this.followFarmTrail = 0;
+ this.followEnemyTrail = 0;
+ this.followBossTrail = 100;
+ this.penalizedTrails = [];
+
+ this.setPriority(antType, 1);
+ }
+
+ setPriority(antType, mult){
+ let job = antType;
+ switch (job) {
+ case "Builder":
+ this.followBuildTrail = 0.9 * mult;
+ this.followForageTrail = 0.05 * mult;
+ this.followFarmTrail = 0 * mult;
+ this.followEnemyTrail = 0.05 * mult;
+ this.followBossTrail = 100 * mult;
+ break;
+ case "Scout":
+ this.followBuildTrail = 0.25 * mult;
+ this.followForageTrail = 0.25 * mult;
+ this.followFarmTrail = 0.25 * mult;
+ this.followEnemyTrail = 0.25 * mult;
+ this.followBossTrail = 100 * mult;
+ break;
+ case "Farmer":
+ this.followBuildTrail = 0 * mult;
+ this.followForageTrail = 0.1 * mult;
+ this.followFarmTrail = 0.85 * mult;
+ this.followEnemyTrail = 0.05 * mult;
+ this.followBossTrail = 100 * mult;
+ break;
+ case "Warrior":
+ this.followBuildTrail = 0 * mult;
+ this.followForageTrail = 0.2 * mult;
+ this.followFarmTrail = 0 * mult;
+ this.followEnemyTrail = 1 * mult;
+ this.followBossTrail = 100 * mult;
+ break;
+ case "Spitter":
+ this.followBuildTrail = 0 * mult;
+ this.followForageTrail = 0.2 * mult;
+ this.followFarmTrail = 0 * mult;
+ this.followEnemyTrail = 1 * mult;
+ this.followBossTrail = 100 * mult;
+ break;
+ case "DeLozier":
+ this.followBuildTrail = 0 * mult;
+ this.followForageTrail = 0 * mult;
+ this.followFarmTrail = 0 * mult;
+ this.followEnemyTrail = 0 * mult;
+ this.followBossTrail = 100 * mult;
+ break;
+ default:
+ this.followBuildTrail = 0 * mult;
+ this.followForageTrail = 0.75 * mult;
+ this.followFarmTrail = 0 * mult;
+ this.followEnemyTrail = 0.25 * mult;
+ this.followBossTrail = 100 * mult;
+ break;
+ }
+ }
+
+ decideState(){
+ /*Deciding State:
+ State is determinant on many variables. If a variable like hunger exceeds a threshold, the brain will set state to immediately fix it.
+ A monitor class that constantly monitors these should happen and this should be called when either:
+ Needs an emergency state change
+ Finished previous state
+ */
+ }
+
+ checkTrail(pheromone){
+ /*Check Trail:
+ Checks a trail using trail type and ant type. Generates number from 0-1. If it falls in the bounds, the ant follows the path, else sets to ignore that type until next state change (maybe make it dynamic (-50% chance))
+ */
+ let priority = this.getTrailPriority(pheromone.name);
+ let penalty = this.getPenalty(pheromone.name);
+ let num = Math.random();
+ let comparison = (pheromone.strength/pheromone.initial) * priority * penalty;
+ if(num < comparison){
+ return true;
+ }
+ this.addPenalty(pheromone.name, 0.5);
+ return false;
+ }
+
+ addPenalty(pheromoneName, penaltyValue = 0.5){
+ this.penalizedTrails.push({name: pheromoneName, penalty: penaltyValue}); //Stores penalty and name as a pair
+ }
+
+ getPenalty(pheromoneName) {
+ const penaltyObj = this.penalizedTrails.find(p => p.name === pheromoneName);
+ return penaltyObj ? penaltyObj.penalty : 1; // default penalty = 1 if not found
+ }
+
+ getTrailPriority(trailType){
+ switch(trailType){
+ //Duh ahh return statement. Returns value tied to each priority
+ case "Build":
+ return this.followBuildTrail;
+ case "Forage":
+ return this.followForageTrail;
+ case "Farm":
+ return this.followFarmTrail;
+ case "Enemy":
+ return this.followEnemyTrail;
+ case "Boss":
+ return this.followBossTrail;
+ }
+ }
+
+ modifyPriorityTrails(){
+ switch(this.flag_){
+ case "reset":
+ this.setPriority(this.antType, 1);
+ break;
+ case "hungry":
+ this.setPriority(this.antType, 0.5);
+ this.followForageTrail = 1;
+ break;
+ case "starving":
+ this.setPriority(this.antType, 0);
+ this.followForageTrail = 2;
+ break;
+ case "death":
+ this.setPriority(this.antType, 0);
+ break;
+ }
+ }
+
+ checkHunger(){
+ this.hunger++;
+ logVerbose(`my belly is bellying`);
+ //Checks hunger meter every second
+ if(this.hunger === HUNGRY){
+ logNormal('hungry')
+ this.flag_ = "hungry";
+ this.runFlagState();
+ this.decideState();
+ }
+ if(this.hunger === STARVING){
+ logNormal(`starving`);
+ this.flag_ = "starving";
+ this.runFlagState();
+ this.decideState();
+ }
+ if(this.hunger === DEATH){
+ logNormal(`dead`);
+ this.flag_ = "death";
+ this.runFlagState();
+ //this.killAnt();//Need to make this
+ if(this.antType != "Queen"){
+ this.ant.takeDamage(999999);
+ }
+ }
+ }
+
+ resetHunger(){
+ //Resets hunger once fed (change to use variable if food has different values of saturation)
+ this.hunger = 0;
+ this.flag_ = "reset";
+ this.runFlagState();
+ }
+ runFlagState(){
+ switch(this.flag_){
+ case "hungry":
+ this.modifyPriorityTrails();
+ break;
+ case "starving":
+ this.modifyPriorityTrails();
+ break;
+ case "death":
+ //killAnt
+ break;
+ case "reset":
+ this.modifyPriorityTrails();
+ this.flag_ = "";
+ //this.penalizedTrails = []; Move this reset somewhere else
+ break;
+ }
+ logNormal(`
+ ${this.flag_}:
+ Build: ${this.followBuildTrail}
+ Forage: ${this.followForageTrail}
+ Farm: ${this.followFarmTrail}
+ Enemy: ${this.followEnemyTrail}
+ Boss: ${this.followBossTrail}
+ `);
+ }
+
+ update(deltaTime){
+ this.internalTimer(deltaTime);
+ }
+
+ changeIncrement(newIncrement){
+ increment /= newIncrement;
+ }
+
+ internalTimer(deltaTime){
+ this._accumulator = (this._accumulator || 0) + deltaTime;
+ if (this._accumulator >= increment) { // every second
+ logVerbose(`${this.hunger}`);
+ this._accumulator = 0;
+ this.checkHunger();
+ }
+ }
+}
diff --git a/Classes/ants/antStateMachine.js b/Classes/ants/antStateMachine.js
index a993d49b..d1192b00 100644
--- a/Classes/ants/antStateMachine.js
+++ b/Classes/ants/antStateMachine.js
@@ -1,4 +1,3 @@
-
// AntStateMachine.js
// Manages the state of an ant character in a game, including primary activities and modifiers.
// Supports complex state combinations and provides methods to query and change states.
@@ -6,7 +5,7 @@ class AntStateMachine {
constructor() {
// Primary activity states
this.primaryState = "IDLE";
- this.primaryStates = ["IDLE", "MOVING", "GATHERING", "FOLLOWING", "BUILDING", "SOCIALIZING", "MATING"];
+ this.primaryStates = ["IDLE", "MOVING", "GATHERING", "FOLLOWING", "BUILDING", "SOCIALIZING", "MATING", "PATROL", "DROPPING_OFF"];
// Combat modifier states
this.combatModifier = "OUT_OF_COMBAT";
@@ -18,6 +17,8 @@ class AntStateMachine {
// State change callbacks
this.onStateChange = null;
+
+ this.preferredState = "GATHERING";
}
// Set the primary activity state
@@ -83,6 +84,29 @@ class AntStateMachine {
return success;
}
+ /**
+ * Will try and resume the preferred state after the ant is idle,
+ */
+ ResumePreferredState(){
+ if(this.primaryState == "IDLE"){ this.setPrimaryState(this.preferredState) }
+ }
+
+ /**
+ * Will try and set the preferred state to be resumed after the ant is idle,
+ */
+ setPreferredState(state){
+ if (this.isValidPrimary(state)) {
+ this.preferredState = state;
+ return true;
+ } else {
+ console.warn(`AntStateMachine: Invalid preferred state '${state}'`);
+ return false;
+ }
+ }
+
+ beginIdle(){
+ if (this.isValidPrimary("IDLE")) { this.primaryState = "IDLE" }
+ }
// Get the complete state as a string
getFullState() {
@@ -92,6 +116,10 @@ class AntStateMachine {
return state;
}
+ getCurrentState(){
+ return this.primaryState
+ }
+
// Check if ant can perform specific actions
canPerformAction(action) {
switch (action.toLowerCase()) {
@@ -104,12 +132,14 @@ class AntStateMachine {
this.terrainModifier !== "ON_SLIPPERY";
case "gather":
- // Can't gather while in combat, following, building, socializing, or mating
+ // Can't gather while in combat, following, building, socializing, mating, patrolling, or dropping off
return this.combatModifier === "OUT_OF_COMBAT" &&
this.primaryState !== "FOLLOWING" &&
this.primaryState !== "BUILDING" &&
this.primaryState !== "SOCIALIZING" &&
- this.primaryState !== "MATING";
+ this.primaryState !== "PATROL" &&
+ this.primaryState !== "MATING" &&
+ this.primaryState !== "DROPPING_OFF";
case "attack":
// Can only attack when in combat states, not while building or mating
@@ -157,13 +187,37 @@ class AntStateMachine {
this.primaryState !== "BUILDING" &&
this.primaryState !== "SOCIALIZING";
+ case "patrol":
+ // Can't patrol while engaged in other activities
+ return this.primaryState !== "BUILDING" &&
+ this.primaryState !== "SOCIALIZING";
+
default:
return true;
}
}
+ // Simple check if a value is an allowed primary state
+ isValidPrimary(state) {
+ return typeof state === 'string' && this.primaryStates.includes(state);
+ }
+
+ // Checks for combat/terrain (accepts null to clear a modifier)
+ isValidCombat(state) {
+ return state === null || (typeof state === 'string' && this.combatStates.includes(state));
+ }
+ isValidTerrain(state) {
+ return state === null || (typeof state === 'string' && this.terrainStates.includes(state));
+ }
+
+ // Check across all state lists (useful for validations)
+ isValidAnyState(state) {
+ return this.isValidPrimary(state) || this.isValidCombat(state) || this.isValidTerrain(state);
+ }
+
// Check current states
isPrimaryState(state) { return this.primaryState === state; }
+ isDroppingOff() { return this.primaryState === "DROPPING_OFF"; }
isInCombat() { return this.combatModifier !== "OUT_OF_COMBAT" && this.combatModifier !== null; }
isOutOfCombat() { return this.combatModifier === "OUT_OF_COMBAT"; }
isOnTerrain(terrain) { return this.terrainModifier === terrain; }
@@ -216,11 +270,11 @@ class AntStateMachine {
// Debug: Print current state
printState() {
- if (typeof devConsoleEnabled !== 'undefined' && devConsoleEnabled) {
- console.log(`AntStateMachine State: ${this.getFullState()}`);
- console.log(` Primary: ${this.primaryState}`);
- console.log(` Combat: ${this.combatModifier || "None"}`);
- console.log(` Terrain: ${this.terrainModifier || "None"}`);
+ if (devConsoleEnabled) {
+ logNormal(`AntStateMachine State: ${this.getFullState()}`);
+ logNormal(` Primary: ${this.primaryState}`);
+ logNormal(` Combat: ${this.combatModifier || "None"}`);
+ logNormal(` Terrain: ${this.terrainModifier || "None"}`);
}
}
@@ -244,41 +298,68 @@ class AntStateMachine {
}
};
}
+
+ // Update method for game loop integration
+ update() {
+ // Currently a no-op - state machine updates happen through explicit state changes
+ // This method exists to satisfy the interface expected by ant.js
+ }
}
-function antSMtest() {
- // Create state machine for an ant
- let antSM = new AntStateMachine();
-
- // Set states
- antSM.setPrimaryState("MOVING");
- antSM.setCombatModifier("IN_COMBAT");
- antSM.setTerrainModifier("IN_MUD");
-
- if (typeof devConsoleEnabled !== 'undefined' && devConsoleEnabled) {
- console.log(antSM.getFullState()); // "MOVING_IN_COMBAT_IN_MUD"
-
- // Check capabilities
- console.log(antSM.canPerformAction("move")); // true
- console.log(antSM.canPerformAction("attack")); // true
- }
-
- // Set callback for state changes
- antSM.setStateChangeCallback((oldState, newState) => {
- if (typeof devConsoleEnabled !== 'undefined' && devConsoleEnabled) {
- console.log(`Ant state changed from ${oldState} to ${newState}`);
+/**
+ * runAntStateCoverageTest
+ * -----------------------
+ * Exercise every state combination defined on AntStateMachine (primary × (null + combat) × (null + terrain)).
+ * Automatically picks up any new states added to primaryStates/combatStates/terrainStates.
+ * Returns a report object { total, checked, failures, visitedCount } and logs a concise summary.
+ */
+function runAntStateCoverageTest(selectedAnt = null, verbose = false) {
+ selectedAnt ??= new AntWrapper();
+ const failures = [];
+ const visited = new Set();
+ selectedAnt.getAntStateMachine().setStateChangeCallback((oldState, newState) => visited.add(newState));
+
+ const primaries = Array.from(selectedAnt.primaryStates);
+ const combats = [null].concat(Array.from(selectedAnt.combatStates));
+ const terrains = [null].concat(Array.from(selectedAnt.terrainStates));
+
+ function buildExpected(primary, combat, terrain) {
+ let s = primary;
+ if (combat) s += `_${combat}`;
+ if (terrain) s += `_${terrain}`;
+ return s;
+ }
+
+ let checked = 0;
+ for (const p of primaries) {
+ for (const c of combats) {
+ for (const t of terrains) {
+ checked++;
+ const ok = sm.setState(p, c, t);
+ const expected = buildExpected(p, c, t);
+ const actual = sm.getFullState();
+ if (!ok) failures.push({ primary: p, combat: c, terrain: t, reason: 'setState returned false' });
+ if (actual !== expected) failures.push({ primary: p, combat: c, terrain: t, reason: 'state mismatch', expected, actual });
+ if (verbose && failures.length === 0) {
+ logNormal(`OK: ${expected}`);
+ }
}
- });
-
- // Reset to idle
- antSM.reset(); // "Ant state changed from MOVING_IN_COMBAT_IN_MUD to IDLE"
- if (typeof devConsoleEnabled !== 'undefined' && devConsoleEnabled) {
- antSM.printState();
- console.log(antSM.getStateSummary());
}
+ }
+
+ const report = {
+ total: primaries.length * combats.length * terrains.length,
+ checked,
+ failures,
+ visitedCount: visited.size
+ };
+
+ logNormal(`AntStateCoverage: checked ${checked} combinations, failures: ${failures.length}, visitedStateCount: ${visited.size}`);
+ if (failures.length) console.table(failures);
+ return report;
}
// Export for use in other files
-if (typeof module !== "undefined" && module.exports) {
+if (typeof module !== 'undefined' && module.exports) {
module.exports = AntStateMachine;
}
\ No newline at end of file
diff --git a/Classes/ants/antWrapper.js b/Classes/ants/antWrapper.js
deleted file mode 100644
index e705deed..00000000
--- a/Classes/ants/antWrapper.js
+++ /dev/null
@@ -1,62 +0,0 @@
-class AntWrapper {
- constructor(antObject, species) {
- this.antObject = antObject; // Instance of ant class
- this.species = species;
- // Optionally: this.healthAmount = this.setHealthAmm(species);
-
- // Set species-specific image if needed
- if (species === "DeLozier") {
- this.antObject.setSpriteImage(gregImg);
- }
- }
-
- update() {
- this.antObject.update();
- }
-
- makeSpeciesTestUi() {
- const center = this.antObject.center;
-
- push();
- rectMode(CENTER);
-
- // 20px below the ant (tweak as needed)
- const labelY = center.y + this.antObject.size / 2 + 20;
-
- outlinedText(
- this.species, // text
- center.x, // x
- labelY, // y
- font, // font
- 14, // size
- color(0), // fill
- color(0) // outline
- );
-
- pop();
- }
-}
-
-if (typeof module !== "undefined" && module.exports) {
- module.exports = AntWrapper;
-}
-
-function outlinedText(txt, x, y, font, size, fillCol, outlineCol) {
- push();
- noStroke();
- textFont(font);
- textSize(size);
- textAlign(CENTER, CENTER);
-
-
- fill(outlineCol);
- for (let dx = -1; dx <= 1; dx++) {
- for (let dy = -1; dy <= 1; dy++) {
- if (dx || dy) text(txt, x + dx, y + dy);
- }
- }
-
- fill(fillCol);
- text(txt, x, y);
- pop();
-}
\ No newline at end of file
diff --git a/Classes/ants/ants.js b/Classes/ants/ants.js
index ec9e6257..7a5e4e40 100644
--- a/Classes/ants/ants.js
+++ b/Classes/ants/ants.js
@@ -1,117 +1,89 @@
// --- Ant Globals ---
let antToSpawn = 0;
-let ant_Index = 0;
+let antIndex = 0;
let antSize;
+let queenSize;
let ants = [];
let globalResource = [];
-let antImg1;
+let antBaseSprite;
let antbg;
let hasDeLozier = false;
+let hasQueen = false;
let selectedAnt = null;
-let speciesImages = {};
+let JobImages = {};
-// AntStateMachine will be available globally from antStateMachine.js
+// Global ant manager instance - will be initialized when AntManager is available
+let antManager = null;
+let animationManager = null;
-// --- Preload Images ---
-function Ants_Preloader() {
+// --- Preload Images and manager ---
+function antsPreloader() {
antSize = createVector(20, 20);
+ queenSize = createVector(30, 30);
+ console.log("queenSize",queenSize)
antbg = [60, 100, 60];
- antImg1 = loadImage("Images/Ants/gray_ant.png");
- speciesImages = {
- Builder: loadImage('Images/Ants/blue_ant.png'),
- Scout: loadImage('Images/Ants/gray_ant.png'),
- Farmer: loadImage('Images/Ants/brown_ant.png'),
- Warrior: loadImage('Images/Ants/blue_ant.png'),
- Spitter: loadImage('Images/Ants/gray_ant.png'),
- DeLozier: loadImage('Images/Ants/greg.jpg')
+ antBaseSprite = loadImage("Images/Ants/gray_ant.png");
+ JobImages = {
+ Builder: loadImage('Images/Ants/gray_ant_builder.png'),
+ Scout: loadImage('Images/Ants/gray_ant_scout.png'),
+ Farmer: loadImage('Images/Ants/gray_ant_farmer.png'),
+ Warrior: loadImage('Images/Ants/gray_ant_soldier.png'), // We don't have a gray ant warrior
+ Spitter: loadImage('Images/Ants/gray_ant_spitter.png'),
+ // DeLozier: loadImage('Images/Ants/greg.jpg'),
+ Queen: loadImage('Images/Ants/gray_ant_queen.png'),
+ Spider: loadImage('Images/Ants/spider.png'),
+ waveEnemy: loadImage("Images/Ants/Enemy.png"),
+ Spider: loadImage('Images/Ants/spider.png'),
+ AntEater: loadImage('Images/Ants/ant_eater.png'),
};
- gregImg = loadImage("Images/Ants/greg.jpg");
+ initializeAntManager();
}
-// --- Spawn Ants ---
-function Ants_Spawn(numToSpawn) {
- for (let i = 0; i < numToSpawn; i++) {
- let sizeR = random(0, 15);
- let speciesName = assignSpecies();
- let baseAnt = new ant(
- random(0, 500), random(0, 500),
- antSize.x + sizeR,
- antSize.y + sizeR,
- 30, 0,
- antImg1,
- speciesName
- );
- ants[i] = new AntWrapper(new Species(baseAnt, speciesName), speciesName);
- ants[i] = new AntWrapper(new Species(baseAnt, speciesName, speciesImages[speciesName]), speciesName);
- ants[i].update();
- }
-}
-
-// --- Update All Ants ---
-function Ants_Update() {
- for (let i = 0; i < ant_Index; i++) {
- if (ants[i] && typeof ants[i].update === "function") {
- ants[i].update();
- }
- }
-}
-
-// --- Single Ant Selection/Movement ---
-function Ant_Click_Control() {
- // Move selected ant if one is already selected
- if (selectedAnt) {
- selectedAnt.moveToLocation(mouseX, mouseY);
- selectedAnt.isSelected = false;
- selectedAnt = null;
- return;
- }
+/** Initializes the AntManager instance */
+function initializeAntManager() { antManager = new AntManager(); animationManager = new AnimationManager(); }
- // Otherwise, select the ant under the mouse
- selectedAnt = null;
- for (let i = 0; i < ant_Index; i++) {
- if (!ants[i]) continue; // Safety check for null/undefined ants
- let antObj = ants[i].antObject ? ants[i].antObject : ants[i];
- if (antObj) antObj.isSelected = false; // Safety check
- }
- for (let i = 0; i < ant_Index; i++) {
- if (!ants[i]) continue; // Safety check for null/undefined ants
- let antObj = ants[i].antObject ? ants[i].antObject : ants[i];
- if (antObj && typeof antObj.isMouseOver === 'function' && antObj.isMouseOver(mouseX, mouseY)) {
- antObj.isSelected = true;
- selectedAnt = antObj;
- break;
- }
- }
-}
+// --- Entity-based Ant Class ---
+// Inherits all controller functionality from Entity base class
+class ant extends Entity {
+ constructor(posX = 0, posY = 0, sizex = 50, sizey = 50, movementSpeed = 1, rotation = 0, img = antBaseSprite, JobName = "Scout", faction = "player") {
+ // Initialize Entity with ant-specific options
+ // Use "Queen" type if JobName is "Queen", otherwise "Ant"
+ super(posX, posY, sizex, sizey, {
+ type: JobName === "Queen" ? "Queen" : "Ant",
+ imagePath: img,
+ movementSpeed: movementSpeed,
+ selectable: true,
+ faction: faction
+ });
+
+ // Ant-specific properties
+ this._JobName = JobName;
+ this._antIndex = antIndex++;
+ this.isBoxHovered = false;
+ this.brain;
+ this.pathType = null;
+ this._idleTimer = 0;
+ this._idleTimerTimeout = 1;
+ this.lastFrameTime = performance.now();
-// --- Ant Class ---
-class ant {
- constructor(posX = 0, posY = 0, sizex = 50, sizey = 50, movementSpeed = 1, rotation = 0, img = antImg1,speciesName) {
+
+ // New job system (component-based)
+ this.job = null; // Will hold JobComponent instance
+ this.jobName = JobName || "Scout"; // Direct job name access
+
+ // Initialize StatsContainer system
const initialPos = createVector(posX, posY);
- this._stats = new stats(
+ this._stats = new StatsContainer(
initialPos,
{ x: sizex, y: sizey },
movementSpeed,
initialPos.copy()
);
- this.speciesName = speciesName;
- this._sprite = new Sprite2D(img, initialPos, createVector(sizex, sizey), rotation);
- this._skitterTimer = random(30, 200);
- this._antIndex = ant_Index++;
- this._isMoving = false;
- this._timeUntilSkitter = this._skitterTimer;
- this._path = null;
- this._isSelected = false;
- this.isBoxHovered = false;
-
-
- // Resource
- this.isDroppingOff = false;
- this.isMaxWeight = false // Ants capacity max
- this.Resources = []; // Resource the ants is carrying
-
+
+ // Initialize resource management
+ this._resourceManager = new ResourceManager(this, 10, 25);
// Initialize state machine
this._stateMachine = new AntStateMachine();
@@ -119,613 +91,1151 @@ class ant {
this._onStateChange(oldState, newState);
});
- // Faction and command system
- this._faction = "neutral"; // Default faction
- this._commandQueue = []; // Queue for receiving commands from queen
- this._nearbyEnemies = []; // Track nearby enemy ants
+ // Initialize Gather State behavior
+ this._gatherState = new GatherState(this);
+
+
+ // Faction and enemy tracking
+ this._faction = faction;
+ this._enemies = [];
+ this._lastEnemyCheck = 0;
+ this._enemyCheckInterval = 50; // frames
+
+ // Combat properties
+ this._health = 100;
+ this._maxHealth = 100;
+ this._damage = 0;
+ this._attackRange = 30;
+ this._combatTarget = null; // Current target this ant is attacking
+ this._attackCooldown = 1; // seconds
+ this._lastAttackTime = 0; // Timestamp of the last attack
+
+ // Set initial image if provided
+ if (img && typeof img !== 'string') {
+ this.setImage(img);
+ }
}
- // --- Getters/Setters ---
- get stats() { return this._stats; }
- set stats(value) { this._stats = value; }
- get sprite() { return this._sprite; }
- set sprite(value) { this._sprite = value; }
+ // --- Ant-specific Getters/Setters ---
get antIndex() { return this._antIndex; }
- set antIndex(value) { this._antIndex = value; }
- get isMoving() { return this._isMoving; }
- set isMoving(value) { this._isMoving = value; }
- get timeUntilSkitter() { return this._timeUntilSkitter; }
- set timeUntilSkitter(value) { this._timeUntilSkitter = value; }
- get skitterTimer() { return this._skitterTimer; }
- set skitterTimer(value) { this._skitterTimer = value; }
- get path() { return this._path; }
- set path(value) { this._path = value; }
- get isSelected() { return this._isSelected; }
- set isSelected(value) { this._isSelected = value; }
-
- // State machine and new properties
+ get JobName() { return this._JobName; }
+ set JobName(value) { this._JobName = value; }
+ get StatsContainer() { return this._stats; }
+ get resourceManager() { return this._resourceManager; }
get stateMachine() { return this._stateMachine; }
+ get gatherState() { return this._gatherState; }
get faction() { return this._faction; }
- set faction(value) { this._faction = value; }
- get commandQueue() { return this._commandQueue; }
- get nearbyEnemies() { return this._nearbyEnemies; }
-
- // --- Sprite2D Helpers ---
- setSpriteImage(img) { this._sprite.setImage(img); }
- setSpritePosition(pos) { this._sprite.setPosition(pos); }
- setSpriteSize(size) { this._sprite.setSize(size); }
- setSpriteRotation(rotation) { this._sprite.setRotation(rotation); }
-
- // --- Rendering ---
- render() {
- noSmooth();
- this._sprite.render();
- smooth();
-
- if (this._isMoving) {
- const pos = this._sprite.pos;
- const size = this._sprite.size;
- const pendingPos = this._stats.pendingPos.statValue;
- stroke(255);
- strokeWeight(2);
- line(
- pos.x + size.x / 2, pos.y + size.y / 2,
- pendingPos.x + size.x / 2, pendingPos.y + size.y / 2
- );
- }
- }
-
- // --- Highlighting ---
- highlight() {
- // Use abstract highlighting functions from selectionBox.js
- if (this._isSelected) {
- highlightEntity(this, "selected");
- renderDebugInfo(this);
- } else if (this.isMouseOver(mouseX, mouseY)) {
- highlightEntity(this, "hover");
- } else if (this.isBoxHovered) {
- highlightEntity(this, "boxHovered");
+ get health() { return this._health; }
+ get maxHealth() { return this._maxHealth; }
+ get damage() { return this._damage; }
+
+ // --- New Job System Methods ---
+ assignJob(jobName, image = null) {
+ // Create job component if JobComponent is available
+ if (typeof JobComponent !== 'undefined') {
+ this.job = new JobComponent(jobName, image);
+ this._applyJobStats(this.job.stats);
+ } else {
+ // Fallback for when JobComponent isn't loaded yet
+ console.warn('JobComponent not available, using fallback job assignment');
+ const stats = this._getFallbackJobStats(jobName);
+ this._applyJobStats(stats);
}
- // Show combat state with red outline
- if (this._stateMachine.isInCombat()) {
- highlightEntity(this, "combat");
+ // Update job name properties
+ this.jobName = jobName;
+ this._JobName = jobName; // Keep legacy property in sync
+ this.brain = new AntBrain(this, jobName);
+
+ // Set image if provided
+ if (image) {
+ this.setImage(image);
}
- // Show state-dependent visual indicators
- renderStateIndicators(this);
+ return this;
}
- // --- Mouse Over Detection ---
- isMouseOver(mx, my) {
- const pos = this._sprite.pos;
- const size = this._sprite.size;
- return (
- mx >= pos.x &&
- mx <= pos.x + size.x &&
- my >= pos.y &&
- my <= pos.y + size.y
- );
+ _applyJobStats(stats) {
+ // Apply job stats to ant properties
+ this._maxHealth = stats.health;
+ this._health = stats.health;
+ this._damage = stats.strength;
+
+ // Apply to StatsContainer if available
+ if (this._stats) {
+ this._stats.strength.statValue = stats.strength;
+ this._stats.health.statValue = stats.health;
+ this._stats.gatherSpeed.statValue = stats.gatherSpeed;
+ this._stats.movementSpeed.statValue = stats.movementSpeed;
+ }
+
+ // Apply to movement controller if available
+ const movementController = this.getController('movement');
+ if (movementController) {
+ movementController.movementSpeed = stats.movementSpeed;
+ }
+
+ const combat = this.getController('combat');
+ switch(this.jobName){
+ case "Queen":
+ combat._detectionRadius = 40;
+ // this._attackRange = combat._detectionRadius - 50;
+ break;
+ case "Spitter":
+ // combat._detectionRadius = 250;
+ // this._attackRange = 250;
+ break;
+ case "Spider":
+ combat._detectionRadius = 300;
+ break;
+ case "Farmer" :
+ combat._detectionRadius = 250;
+ break;
+ case "Builder" :
+ combat._detectionRadius = 250;
+ break;
+ case "Scout" :
+ combat._detectionRadius = 500;
+ break;
+
+ }
}
+
+_getFallbackJobStats(jobName) {
+ // Balanced fallback stats when JobComponent isn't available
+ switch (jobName) {
+ case "Builder":
+ // Strong enough to build and carry, average mobility
+ return { strength: 20, health: 120, gatherSpeed: 15, movementSpeed: 55 };
- setPath(path) { this._path = path; }
+ case "Scout":
+ // Fast and agile, but fragile
+ return { strength: 10, health: 70, gatherSpeed: 8, movementSpeed: 85 };
- // --- Skitter Logic ---
- setTimeUntilSkitter(value) { this._timeUntilSkitter = value; }
- rndTimeUntilSkitter() {
- this._timeUntilSkitter = random(30, 200); // Generate new random value each time
- }
- getTimeUntilSkitter() { return this._timeUntilSkitter; }
+ case "Farmer":
+ // Focused on gathering efficiency
+ return { strength: 15, health: 100, gatherSpeed: 35, movementSpeed: 50 };
+
+ case "Warrior":
+ // Heavy combat role: high strength and durability, slower speed
+ return { strength: 45, health: 6000, gatherSpeed: 5, movementSpeed: 45 };
+
+ case "Spitter":
+ // Ranged attacker: moderate health, good damage, slightly faster than warrior
+ return { strength: 35, health: 110, gatherSpeed: 5, movementSpeed: 55 };
+
+ case "DeLozier":
+ return { strength: 45, health: 160, gatherSpeed: 5, movementSpeed: 45 };
+
+ case "Queen":
+ // Central unit: extremely durable but immobile and weak in combat
+ return { strength: 25, health: 1000, gatherSpeed: 1, movementSpeed: 10 };
- // --- Position and Size ---
- set posX(value) {
- this._stats.position.statValue.x = value;
- this._sprite.pos.x = value;
+ case "Spider":
+ return { strength: 80, health: 6000, gatherSpeed: 3, movementSpeed: 45 };
+
+ default:
+ // Generic fallback for untyped ants
+ return { strength: 15, health: 100, gatherSpeed: 10, movementSpeed: 60 };
}
- get posX() { return this._stats.position.statValue.x; }
+}
- set posY(value) {
- this._stats.position.statValue.y = value;
- this._sprite.pos.y = value;
+ getJobStats() {
+ return this.job ? this.job.stats : this._getFallbackJobStats(this.jobName);
}
- get posY() { return this._stats.position.statValue.y; }
+
+ // --- Controller Access for Test Compatibility ---
+ get _movementController() { return this.getController('movement'); }
+ get _taskManager() { return this.getController('taskManager'); }
+ get _renderController() { return this.getController('render'); }
+ get _selectionController() { return this.getController('selection'); }
+ get _combatController() { return this.getController('combat'); }
+ get _transformController() { return this.getController('transform'); }
+ get _terrainController() { return this.getController('terrain'); }
+ get _interactionController() { return this.getController('interaction'); }
+ get _healthController() { return this.getController('health'); }
+
+ // --- Property/Method Compatibility ---
+ // Backwards-compatible posX/posY accessors used across unit/integration tests
+ // These proxy into the transform controller (or collision box) so older tests
+ // that read/write posX/posY continue to work.
+ get posX() { return this.getPosition().x; }
+ set posX(value) { const p = this.getPosition(); this.setPosition(value, p.y); }
+ get posY() { return this.getPosition().y; }
+ set posY(value) { const p = this.getPosition(); this.setPosition(p.x, value); }
- // Helper methods for abstract highlighting functions
- getPosition() {
- return this._sprite.pos;
+ get isMoving() { return this._delegate('movement', 'getIsMoving') || false; }
+ get isSelected() {
+ const result = this._delegate('selection', 'isSelected') || false;
+ // Debug: log when selection state is queried
+ //
+ return result;
+ }
+ set isSelected(value) {
+ // Debug: log when selection state is set
+ this._delegate('selection', 'setSelected', value);
}
- getSize() {
- return this._sprite.size;
+ // --- Command/Task Compatibility ---
+ addCommand(command) { return this._delegate('taskManager', 'addTask', command); }
+
+ // --- State Machine Integration ---
+ _onStateChange(oldState, newState) {
+ // When entering DROPPING_OFF, find nearest dropoff and move there
+ if (typeof newState === 'string' && newState.includes("DROPPING_OFF")) {
+ this._goToNearestDropoff();
+ }
+ // leaving dropoff clears target
+ if (typeof oldState === 'string' && oldState.includes("DROPPING_OFF") && !(typeof newState === 'string' && newState.includes("DROPPING_OFF"))) {
+ this._targetDropoff = null;
+ }
}
- get center() {
- const pos = this._stats.position.statValue;
- const size = this._stats.size.statValue;
- return createVector(pos.x + (size.x / 2), pos.y + (size.y / 2));
+ // Find nearest DropoffLocation and move to its center. Returns true if a target was found.
+ _goToNearestDropoff() {
+ const list = (window && window.dropoffs) ? window.dropoffs :
+ (typeof dropoffs !== 'undefined' ? dropoffs : []);
+ if (!Array.isArray(list) || list.length === 0) return false;
+ const pos = this.getPosition();
+ let best = null, bestDist = Infinity;
+ for (const d of list) {
+ if (!d) continue;
+ const c = (typeof d.getCenterPx === 'function') ? d.getCenterPx() :
+ { x: (d.x + d.width/2) * (d.tileSize || 32), y: (d.y + d.height/2) * (d.tileSize || 32) };
+ const dx = c.x - pos.x, dy = c.y - pos.y;
+ const dist = Math.hypot(dx, dy);
+ if (dist < bestDist) { bestDist = dist; best = d; }
+ }
+ if (!best) return false;
+ this._targetDropoff = best;
+ const center = best.getCenterPx ? best.getCenterPx() : { x: (best.x + 0.5) * (best.tileSize || 32), y: (best.y + 0.5) * (best.tileSize || 32) };
+ if (typeof this.moveToLocation === 'function') this.moveToLocation(center.x, center.y);
+ return true;
}
- set sizeX(value) { this._stats.size.statValue.x = value; }
- get sizeX() { return this._stats.size.statValue.x; }
- set sizeY(value) { this._stats.size.statValue.y = value; }
- get sizeY() { return this._stats.size.statValue.y; }
+ // Check arrival at target dropoff; deposit carried resources and transition out of dropoff state.
+ _checkDropoffArrival() {
+ if (!this._targetDropoff) return;
+ const pos = this.getPosition();
+ const center = this._targetDropoff.getCenterPx ? this._targetDropoff.getCenterPx() : { x: (this._targetDropoff.x + 0.5) * (this._targetDropoff.tileSize || 32), y: (this._targetDropoff.y + 0.5) * (this._targetDropoff.tileSize || 32) };
+ const dist = Math.hypot(center.x - pos.x, center.y - pos.y);
+ const size = this.getSize();
+ const arrivalThreshold = Math.max(8, (size.x + size.y) * 0.25);
+ if (dist <= arrivalThreshold) {
+ // take resources from ant and deposit into dropoff
+ const taken = (typeof this._resourceManager?.dropAllResources === 'function') ? this._resourceManager.dropAllResources() : [];
+ let deposited = 0;
+ for (const r of taken) {
+ if (!r) continue;
+ if (typeof this._targetDropoff.depositResource === 'function') {
+ if (this._targetDropoff.depositResource(r)) deposited++;
+ } else if (this._targetDropoff.inventory && typeof this._targetDropoff.inventory.addResource === 'function') {
+ if (this._targetDropoff.inventory.addResource(r)) deposited++;
+ } else if (resources && Array.isArray(resources)) {
+ resources.push(r); deposited++;
+ }
+ }
+ if (typeof console !== 'undefined') logNormal(`Ant ${this._antIndex} deposited ${deposited} resource(s) at dropoff.`);
+ if (this._stateMachine) this._stateMachine.setState("IDLE");
+ this._targetDropoff = null;
+ }
+ }
+
+ getCurrentState() { return this._stateMachine?.getCurrentState() || "IDLE"; }
+ setState(newState) { return this._stateMachine?.setState(newState); }
+
+ // --- Combat Methods ---
+ takeDamage(amount) {
+ const oldHealth = this._health;
+ this._health = Math.max(0, this._health - amount);
+
+ // Notify health controller of damage
+ if (this._healthController && oldHealth > this._health) {
+ this._healthController.onDamage();
+ }
- // --- Movement Speed ---
- set movementSpeed(value) { this._stats.movementSpeed.statValue = value; }
- get movementSpeed() { return this._stats.movementSpeed.statValue; }
-
- // Get effective movement speed modified by terrain
- getEffectiveMovementSpeed() {
- let baseSpeed = this.movementSpeed;
+ // Attack animation
+ if(animationManager.isAnimation("Attack")){
+ animationManager.play(this._entity,"Attack");
+ }
- // Apply terrain modifiers
- switch (this._stateMachine.terrainModifier) {
- case "IN_WATER":
- return baseSpeed * 0.5; // 50% speed in water
- case "IN_MUD":
- return baseSpeed * 0.3; // 30% speed in mud
- case "ON_SLIPPERY":
- return 0; // Can't move on slippery terrain
- case "ON_ROUGH":
- return baseSpeed * 0.8; // 80% speed on rough terrain
- case "DEFAULT":
- default:
- return baseSpeed; // Normal speed
+ if (this._health <= 0) {
+ this.die();
}
+ return this._health;
}
-
- // --- Rotation ---
- set rotation(value) {
- this._sprite.rotation = value;
- while (this._sprite.rotation > 360) this._sprite.rotation -= 360;
- while (this._sprite.rotation < -360) this._sprite.rotation += 360;
+
+ heal(amount) {
+ this._health = Math.min(this._maxHealth, this._health + amount);
+ return this._health;
+ }
+
+ attack(target) {
+ if (target && target.takeDamage) {
+ return target.takeDamage(this._damage);
+ }
+ return false;
+ }
+
+ die() {
+ this.isActive = false;
+ // this.setState("DEAD");
+ this._combatTarget = null; // Clear target when dying
+ // Remove this ant from all game systems
+ this._removeFromGame();
}
- get rotation() { return this._sprite.rotation; }
-
- // In Range Of Resource
+ // Used for entering buildings during raids
+ onEnterHive(){
+ this.die();
+ }
+
+ /**
+ * Remove this ant from all game systems when it dies
+ */
+ _removeFromGame() {
+ logNormal(`💀 Removing dead ant ${this._antIndex} from game systems`);
- // --- Move Logic ---
- moveToLocation(X, Y) {
+ // Clear entity from faction attack tracking
+ for(let obj in factionList){
+ if(factionList[obj].isUnderAttack == this){
+ factionList[obj].isUnderAttack = null;
+ }
+ }
+
+ // 1. Remove from global ants array
+ if (typeof ants !== 'undefined' && Array.isArray(ants)) {
+ const index = ants.indexOf(this);
+ if (index !== -1) {
+ ants.splice(index, 1);
+ logNormal(` ✅ Removed from ants array (${ants.length} remaining)`);
+ }
+ }
+
+ // // 2. Remove from TileInteractionManager
+ if (typeof g_tileInteractionManager !== 'undefined' && g_tileInteractionManager) {
+ const pos = this.getPosition();
+ if (pos && typeof g_tileInteractionManager.removeObjectFromTile === 'function') {
+ const tileX = Math.floor(pos.x / (g_tileInteractionManager.tileSize || 32));
+ const tileY = Math.floor(pos.y / (g_tileInteractionManager.tileSize || 32));
+ g_tileInteractionManager.removeObjectFromTile(this, tileX, tileY);
+ logNormal(` ✅ Removed from TileInteractionManager`);
+ }
+ }
+
+ // // 3. Clear from selection systems
+ if (this.isSelected) {
+ this.isSelected = false;
+
+ // Update SelectionBoxController if available
+ if (typeof g_selectionBoxController !== 'undefined' && g_selectionBoxController) {
+ if (g_selectionBoxController.entities && Array.isArray(g_selectionBoxController.entities)) {
+ g_selectionBoxController.entities = ants; // Update to current ants array
+ }
+ }
+
+ // Clear from ant manager if this was the selected ant
+ if (typeof antManager !== 'undefined' && antManager && antManager.selectedAnt === this) {
+ antManager.selectedAnt = null;
+ }
+
+ logNormal(` ✅ Cleared from selection systems`);
+ }
+
+ // // 4. Clear combat targets pointing to this dead ant
+ if (typeof ants !== 'undefined' && Array.isArray(ants)) {
+ ants.forEach(otherAnt => {
+ if (otherAnt._combatTarget === this) {
+ otherAnt._combatTarget = null;
+ logNormal(` ✅ Cleared combat target from ant ${otherAnt._antIndex}`);
+ }
+ });
+ }
+
+ // // 5. Update UI selection entities if function exists
+ if (typeof updateUISelectionEntities === 'function') {
+ updateUISelectionEntities();
+ logNormal(` ✅ Updated UI selection entities`);
+ }
- // Only allow movement if state machine permits it
- if (this._stateMachine.canPerformAction("move")) {
- this._stats.pendingPos.statValue.x = X;
- this._stats.pendingPos.statValue.y = Y;
- this._isMoving = true;
- this._stateMachine.setPrimaryState("MOVING");
+
+ // Remove from selectables so selection system stops referencing it
+ if (typeof selectables !== 'undefined' && Array.isArray(selectables)) {
+ const sidx = selectables.indexOf(this);
+ if (sidx !== -1) selectables.splice(sidx, 1);
}
+
+ //
+ // Also update selection controller's entities if it stores a snapshot
+ // if (typeof g_selectionBoxController !== 'undefined' && g_selectionBoxController) {
+ // if (g_selectionBoxController.entities) g_selectionBoxController.entities = selectables;
+ // }
}
- // Detect terrain at current position (placeholder - you'll need to integrate with your terrain system)
- detectTerrain() {
- // This is a placeholder - you'll need to integrate with your actual terrain/grid system
- // For now, return DEFAULT terrain
- // In the future, you could check grid tiles, water bodies, etc.
-
- // Example terrain detection logic (replace with your actual terrain system):
- // const tileX = Math.floor(this.posX / TILE_SIZE);
- // const tileY = Math.floor(this.posY / TILE_SIZE);
- // const terrainType = getTerrainAt(tileX, tileY);
-
- return "DEFAULT"; // Placeholder
+ // --- Resource Methods ---
+ getResourceCount() { return this._resourceManager?.getCurrentLoad() || 0; }
+ getMaxResources() { return this._resourceManager?.maxCapacity || 0; }
+ addResource(resource) { return this._resourceManager?.addResource(resource) || false; }
+ removeResource(amount = 1) {
+ // ResourceManager doesn't have removeResource, use dropAllResources for now
+ const dropped = this._resourceManager?.dropAllResources() || [];
+ return dropped.length > 0;
+ }
+ dropAllResources() { return this._resourceManager?.dropAllResources() || []; }
+
+ // --- Gather State Methods ---
+ /**
+ * Start autonomous gathering behavior
+ */
+ startGathering() {
+ if (this._stateMachine) {
+ this._stateMachine.setPrimaryState("GATHERING");
+ }
}
- // Update terrain state based on current position
- updateTerrainState() {
- const currentTerrain = this.detectTerrain();
- if (this._stateMachine.terrainModifier !== currentTerrain) {
- this._stateMachine.setTerrainModifier(currentTerrain);
+ /**
+ * Stop gathering and return to idle
+ */
+ stopGathering() {
+ if (this._stateMachine) {
+ this._stateMachine.setPrimaryState("IDLE");
}
-
}
+
+ /**
+ * Check if ant is currently in gathering state
+ * @returns {boolean} True if ant is gathering
+ */
+ isGathering() {
+ return this._stateMachine?.isGathering() || false;
+ }
+
+ // --- Update Override ---
+
+ update() {
+ const now = performance.now();
+ const deltaTime = (now - this.lastFrameTime) / 1000; // seconds
+ this.lastFrameTime = now;
+
+ if (!this.isActive) return;
- // --- Update Loop ---
- // checks and updates ant state each frame
- // if moving, updates position towards target
- // if idle, may skitter randomly
- ResolveMoment() {
- if (this._isMoving) {
- const current = createVector(this.posX, this.posY);
- const target = createVector(
- this._stats.pendingPos.statValue.x,
- this._stats.pendingPos.statValue.y
- );
+ // disable resource gathering for non-player factions
+ let cantCollect = ["Spider","Warrior","DeLozier",'Scout','Spitter'];
+ if(this._gatherState && (this._faction != "player" || cantCollect.includes(this.jobName))){
+ this._gatherState.isActive = false;
+ }
+ // Update Entity systems first
+ super.update();
+
+ // Update ant-specific systems
+ this.brain.update(deltaTime);
+ this._updateStats();
+ this._updateStateMachine();
+ this._updateResourceManager();
+ this._updateEnemyDetection();
+ this._updateHealthController();
+ // If currently dropping off, check arrival each frame
+ if (this._stateMachine && typeof this._stateMachine.isDroppingOff === 'function' && this._stateMachine.isDroppingOff()) {
+ this._checkDropoffArrival();
+ }
+ }
- const direction = p5.Vector.sub(target, current);
- const distance = direction.mag();
- if (distance > 1) {
- direction.normalize();
- const effectiveSpeed = this.getEffectiveMovementSpeed();
- const speedPerMs = effectiveSpeed / 1000;
- const step = Math.min(speedPerMs * deltaTime, distance);
+
+ _updateStats() {
+ if (this._stats) {
+ const pos = this.getPosition();
+ this._stats.position = createVector(pos.x, pos.y);
+ }
+ }
+
+ _updateStateMachine() {
+ if (this._stateMachine) {
+ this._stateMachine.update();
+
+ // Update gather state behavior if ant is in GATHERING state
+ if (this._stateMachine.getCurrentState() == "GATHERING" && this._stateMachine.isGathering() && this._gatherState) {
+ if (!this._gatherState.isActive) {
+ //logNormal(`🔍 Ant ${this.id} entering GatherState (GATHERING state detected)`);
+ this._gatherState.enter()
+ }
+ if (this._gatherState.update()) {this.stateMachine.beginIdle();};
+ } else if (this._gatherState && this._gatherState.isActive) {
+ //logNormal(`🔍 Ant ${this.id} exiting GatherState (no longer GATHERING)`);
+ this._gatherState.exit();
- // Only move if effective speed is greater than 0
- if (effectiveSpeed > 0) {
- current.x += direction.x * step;
- current.y += direction.y * step;
- this.posX = current.x;
- this.posY = current.y;
- this._sprite.setPosition(current);
+ }
+ }
+ if (this._stateMachine.getCurrentState() === "IDLE") {
+ // deltaTime from p5.js is in milliseconds — convert to seconds.
+ const dt = (typeof deltaTime !== 'undefined') ? deltaTime / 1000 : (1 / 60); // fallback ~16.67ms
+ this._idleTimer += dt;
+ } else {
+ this._idleTimer = 0;
+ }if (this._stateMachine.getCurrentState() == "IDLE" && this._idleTimer >= this._idleTimerTimeout) {
+ this._stateMachine.ResumePreferredState()
+ }
+ }
+
+ _updateResourceManager() {
+ if (this._resourceManager) {
+ this._resourceManager.update();
+ // If resource manager reached capacity, enter DROPPING_OFF and navigate to nearest dropoff
+ if (this._resourceManager.isAtMaxLoad && typeof this._resourceManager.isAtMaxLoad === 'function') {
+ if (this._resourceManager.isAtMaxLoad() && this._stateMachine && !this._stateMachine.isDroppingOff()) {
+ // set state and trigger movement via state change callback
+ this._stateMachine.setState("DROPPING_OFF");
}
- } else {
-
- // Target Reached
-
- this.posX = target.x;
- this.posY = target.y;
- this._isMoving = false;
- this._sprite.setPosition(target);
-
+ } else if (this._resourceManager.isAtMaxCapacity) {
+ if (this._resourceManager.isAtMaxCapacity && this._resourceManager.isAtMaxCapacity === true && this._stateMachine && !this._stateMachine.isDroppingOff()) {
+ this._stateMachine.setState("DROPPING_OFF");
+ }
+ }
+ }
+ }
- // Stores Resource and Reset State Upon Dropoff
- if(this.isDroppingOff || this.isMaxWeight ){
- for(let r of this.Resources){
- globalResource.push(r);
- }
+ _updateHealthController() {
+ if (this._healthController) {
+ this._healthController.update();
+ }
+ }
- this.Resources = [];
- this.isDroppingOff = false;
- this.isMaxWeight = false;
+ _renderBoxHover() {
+ this._renderController.highlightBoxHover();
+ }
-
- // Set state back to IDLE when movement is complete, but only if no other activities are ongoing
- if (this._stateMachine.isPrimaryState("MOVING")) {
- // Check if we should go to a different state based on context
- if (this._commandQueue.length > 0) {
- // Don't set to IDLE if there are pending commands - let processCommandQueue handle it
- } else {
- this._stateMachine.setPrimaryState("IDLE");
- }
+ _updateEnemyDetection() {
+ // Check for enemies periodically
+ if (frameCount - this._lastEnemyCheck > this._enemyCheckInterval) {
+ // Use the combat controller's built-in update which detects enemies AND updates combat state
+ const combatController = this.getController('combat');
+ if (combatController && typeof combatController.update === 'function') {
+ combatController.update(); // This calls detectEnemies() and updateCombatState()
+ this._enemies = combatController.getNearbyEnemies() || [];
+ }
+
+ this._lastEnemyCheck = frameCount;
+ // Only attack if we're actually in combat state and have enemies
+ if (this._stateMachine && this._stateMachine.isInCombat() && this._enemies.length > 0) {
+ this._performCombatAttack();
+ }else{
+ if(this._combatTarget != null && this._combatTarget._faction != this._faction){
+ this.moveToLocation(this._combatTarget.posX, this._combatTarget.posY);
}
}
+ }
+ }
- this.render();
+ // Find nearest enemy entity from given array
+ nearestEntity(array){
+ let nearest = null;
+ let minDist = Infinity;
+ for (let obj of array) {
+ if (obj._faction === this._faction || obj === this || obj._faction == "neutral") {
+ continue;
+ }
+ let d = dist(this.posX, this.posY, obj.posX, obj.posY);
+ if (d < minDist) {
+ minDist = d;
+ nearest = obj;
}
+ }
+ return [nearest,minDist];
}
+
+ nearestFriendlyBuilding(array) {
+ let nearest = null;
+ let minDist = Infinity;
+ for (let obj of array) {
+ if ( (obj._faction !== this._faction && obj._faction !== 'neutral') || obj.type !== "Building") continue;
+ let d = dist(this.posX, this.posY, obj.posX, obj.posY);
+ if (d < minDist) {
+ minDist = d;
+ nearest = obj;
+ }
+ }
+ return [nearest, minDist];
}
- // Ants Collect NearBy Fruits/Resources
- resourceCheck(){
- let fruits = resourceList.getResourceList();
- let keys = Object.keys(fruits);
- for(let k of keys){
- let x = fruits[k].x;
- let y = fruits[k].y;
-
- let xDifference = abs(Math.floor(x - this.posX));
- let yDifference = abs(Math.floor(y - this.posY));
- let range = 25;
- let maxWeight = 2; // Change to member variable??
-
- if(xDifference <= range && yDifference <= range){
- let fruit = fruits[k];
- if(this.Resources.length < maxWeight){
- this.Resources.push(fruit);
- delete fruits[k];
- }
- if(this.Resources.length >= maxWeight){
- let dropPointX = 0;
- let dropPointY = 0;
- this.dropOff(dropPointX,dropPointY);
+
+ _soundAlarm(target){
+ let factionObj = factionList[this._faction];
+ if(factionObj){
+ if(factionObj.isUnderAttack != null){return;}
+ factionObj.isUnderAttack = target;
+ let [d, distance] = this.nearestEntity([target]);
+ ants.forEach(ant => {
+ ant._calculateAction([d, distance]);
+ if(ant.jobName === "Queen"){
+ console.log("Queen alerted!");
}
- }
+ })
}
}
- dropOff(X,Y){
- this.isDroppingOff = true;
- this.isMaxWeight = true;
- this.moveToLocation(X,Y);
+ overlaps(a, b) {
+ return (
+ a.posX < b.posX + b.getSize().x &&
+ a.posX + a.getSize().x > b.posX &&
+ a.posY < b.posY + b.getSize().y &&
+ a.posY + a.getSize().y > b.posY
+ );
}
+ _calculateAction(targetData) {
+ let [nearestEnemy, shortestDistance] = targetData;
+ if (!nearestEnemy) return;
- update() {
- // Update terrain state based on current position
- this.updateTerrainState();
-
- // Process any pending commands from queen
- this.processCommandQueue();
-
- // Check for nearby enemies and enter combat if necessary
- this.checkForEnemies();
-
- // Handle pathfinding movement first
- if(!this.isMoving && this._path && this.path.length > 0){//If a path exists and not skittering
- const nextNode = this._path.shift(); //Sets next tile to be travelled as next path tile
- const targetX = nextNode._x * tileSize; //Translates tile coordinate to translatable distance
- const targetY = nextNode._y * tileSize;
- this.moveToLocation(targetX, targetY); //Moves ant
- }
- else if (!this._isMoving && (!this._path || this._path.length === 0)){//Sets back to skittering when not pathfinding
- this._timeUntilSkitter -= 1;
- if (this._timeUntilSkitter < 0) {
- this.rndTimeUntilSkitter();
- this._isMoving = true;
- this.moveToLocation(this.posX + random(-25, 25), this.posY + random(-25, 25));
+ let [closestHive, hiveDistance] = this.nearestFriendlyBuilding(
+ Buildings.filter(b => b.type === "Building" && b._faction === this._faction)
+ );
+
+ const detectionRange = this.getController('combat')._detectionRadius;
+
+
+ let goToHive = () => {
+ if (!closestHive) return this.moveToLocation(nearestEnemy.posX, nearestEnemy.posY);
+ if (hiveDistance > 100) {
+ this.moveToLocation(closestHive.posX, closestHive.posY);
+ } else {
+ closestHive.enter(this);
+ if (this.jobName !== "Scout") this._soundAlarm(nearestEnemy);
+ }
+ };
+
+ let isRanged = ["Spitter", "Queen"].includes(this.jobName);
+ let isMelee = ["Spider", "Warrior"].includes(this.jobName);
+ let isWorker = ["Scout", "DeLozier", "Builder", "Farmer"].includes(this.jobName);
+
+ let isOverlapping = this.overlaps(this, nearestEnemy);
+ // Combat logic
+ this._combatTarget = nearestEnemy;
+ if (isOverlapping || shortestDistance <= this._attackRange) {
+ if (isRanged) {
+ // if (this.jobName === "Spitter") {
+ // window.draggablePanelManager.handleShootLightning(this._combatTarget);
+ // } else if (this.jobName === "Queen" && typeof window.draggablePanelManager?.handleShootLightning === 'function') {
+ // window.draggablePanelManager.handleShootLightning(this._combatTarget);
+ // }
+ }
+
+ if (isMelee || this._faction != "player" || isRanged) {
+ this._attackTarget(this._combatTarget);
+ }
+
+ if (isWorker) {
+ if (this.jobName === "Scout") this._soundAlarm(this._combatTarget);
+ closestHive ? goToHive() : this._attackTarget(this._combatTarget);
}
}
- this.ResolveMoment();
-
- // Only skitter if not moving and in idle state
- if (!this._isMoving && this._stateMachine.isPrimaryState("IDLE") && this._stateMachine.isOutOfCombat()) {
- this._timeUntilSkitter -= 1;
- if (this._timeUntilSkitter < 0) {
- this.rndTimeUntilSkitter();
- // Only skitter if we can actually move
- if (this._stateMachine.canPerformAction("move")) {
- this.moveToLocation(this.posX + random(-25, 25), this.posY + random(-25, 25));
- }
+
+ // Detection logic
+ else if (!isOverlapping || shortestDistance <= detectionRange) {
+ if (isRanged || isMelee || this._faction != "player") {
+ this.moveToLocation(this._combatTarget.posX, this._combatTarget.posY);
+ }
+
+ else if (isWorker) {
+ if (this.jobName === "Scout") this._soundAlarm(this._combatTarget);
+ goToHive()
}
}
-
- this.render();
- this.highlight();
- this.resourceCheck();
}
-
- // State change callback handler
- _onStateChange(oldState, newState) {
- // Handle any special logic when states change
- // Only log state changes for selected ants when dev console is enabled
- if (typeof devConsoleEnabled !== 'undefined' && devConsoleEnabled && this._isSelected) {
- console.log(`Selected Ant ${this._antIndex} state changed: ${oldState} -> ${newState}`);
+
+
+ _performCombatAttack() {
+ // Make sure the ant is ready for combat
+ if (!this._stateMachine || !this._stateMachine.isInCombat()) return;
+
+ if (this._combatTarget) {
+ let targetStillValid = this._enemies.includes(this._combatTarget) && this._combatTarget.health > 0 && this._combatTarget.isActive !== false;
+ let target = this.nearestEntity(this._enemies);
+ if (targetStillValid) {
+ this._calculateAction(target);
+ }
+ // Target is no longer valid, clear it
+ this._combatTarget = null;
}
-
- // Reset skitter timer when entering idle state
- if (this._stateMachine.isIdle()) {
- this.rndTimeUntilSkitter();
+
+ // Acquire a new target if none
+ if (!this._combatTarget) {
+ this._calculateAction(this.nearestEntity(this._enemies)); // Get nearest enemy and decide action
+ return;
}
+ return false;
}
- // --- Command System --- // Static Utility Methods
- addCommand(command) {
- this._commandQueue.push(command);
- }
- processCommandQueue() {
- while (this._commandQueue.length > 0) {
- const command = this._commandQueue.shift();
- this.executeCommand(command);
- }
-
- // If no commands are pending and ant is not moving, ensure it can return to idle
- if (this._commandQueue.length === 0 && !this._isMoving) {
- this.ensureIdleTransition();
+ _attackTarget(target) {
+ if (target && typeof target.takeDamage === 'function' && target.health > 0) {
+ let now = this.lastFrameTime/ 1000; // seconds
+ if (now - this._lastAttackTime < this._attackCooldown) return;
+
+ let randomX = this.posX + random(-10, 10);
+ let randomY = this.posY + random(-10, 10);
+ this.moveToLocation(randomX, randomY);
+ // Use strength stat from StatsContainer, fallback to basic damage
+ const attackPower = this._stats?.strength?.statValue || this._damage;
+ target.takeDamage(attackPower);
+
+ // Show damage effect if available
+ if (this._renderController && typeof this._renderController.showDamageNumber === 'function') {
+ const enemyPos = target.getPosition();
+ this._renderController.showDamageNumber(attackPower, [255, 100, 100]);
+ }
+ this._lastAttackTime = now;
+ logNormal(`🗡️ Ant ${this._antIndex} (${this._faction}) attacked enemy ${target._antIndex || 'unknown'} for ${attackPower} damage`);
}
}
- // Ensure the ant can transition to idle state when appropriate
- ensureIdleTransition() {
- // Only transition to idle if we're in a "temporary" activity state
- const currentPrimary = this._stateMachine.primaryState;
-
- if (currentPrimary === "MOVING" ||
- (currentPrimary === "GATHERING" && Math.random() < 0.01) || // Occasional break from gathering
- (currentPrimary === "BUILDING" && Math.random() < 0.005) || // Occasional break from building
- (currentPrimary === "FOLLOWING" && Math.random() < 0.02)) { // Stop following occasionally
-
- if (this._stateMachine.canPerformAction("move")) {
- this._stateMachine.setPrimaryState("IDLE");
- }
- }
+ _calculateDistance(entity1, entity2) {
+ const pos1 = entity1.getPosition();
+ const pos2 = entity2.getPosition();
+ const dx = pos1.x - pos2.x;
+ const dy = pos1.y - pos2.y;
+ return Math.sqrt(dx * dx + dy * dy);
}
- executeCommand(command) {
- switch (command.type) {
- case "MOVE":
- if (command.x !== undefined && command.y !== undefined) {
- this.moveToLocation(command.x, command.y);
- }
- break;
- case "GATHER":
- if (this._stateMachine.canPerformAction("gather")) {
- this._stateMachine.setPrimaryState("GATHERING");
- // Add gathering logic here
- }
- break;
- case "BUILD":
- if (this._stateMachine.canPerformAction("build")) {
- this._stateMachine.setPrimaryState("BUILDING");
- // Add building logic here
- }
- break;
- case "FOLLOW":
- if (this._stateMachine.canPerformAction("follow") && command.target) {
- this._stateMachine.setPrimaryState("FOLLOWING");
- // Add following logic here
- }
- break;
- default:
- console.warn(`Unknown command type: ${command.type}`);
+ // --- Render Override ---
+ render() {
+ if (!this.isActive) return;
+
+ // Use Entity rendering (handles sprite and highlights automatically)
+ super.render();
+
+ // Add ant-specific rendering
+ if (this._healthController) {
+ this._healthController.render();
+ }
+ this._renderResourceIndicator();
+ if (this.isBoxHovered) {
+ this._renderBoxHover();
}
}
+
+
- // --- Enemy Detection and Combat ---
- checkForEnemies() {
- this._nearbyEnemies = [];
- const detectionRadius = 60; // pixels
-
- // Check all other ants for enemies
- for (let i = 0; i < ant_Index; i++) {
- if (!ants[i] || ants[i] === this) continue;
+ _renderResourceIndicator() {
+ const resourceCount = this.getResourceCount();
+ if (resourceCount > 0) {
+ const pos = this.getPosition();
+ const size = this.getSize();
- const otherAnt = ants[i].antObject ? ants[i].antObject : ants[i];
+ // Convert world position to screen position using terrain's coordinate converter
+ let screenX = pos.x + size.x/2;
+ let screenY = pos.y - 12;
- // Check if different faction
- if (otherAnt.faction !== this._faction && this._faction !== "neutral" && otherAnt.faction !== "neutral") {
- const distance = dist(this.posX, this.posY, otherAnt.posX, otherAnt.posY);
+ if (typeof g_activeMap !== 'undefined' && g_activeMap && g_activeMap.renderConversion && typeof TILE_SIZE !== 'undefined') {
+ // Convert pixel position to tile position
+ const tileX = pos.x / TILE_SIZE;
+ const tileY = pos.y / TILE_SIZE;
- if (distance <= detectionRadius) {
- this._nearbyEnemies.push(otherAnt);
- }
+ // Use terrain's converter to get screen position
+ const screenPos = g_activeMap.renderConversion.convPosToCanvas([tileX, tileY]);
+ screenX = screenPos[0] + size.x/2;
+ screenY = screenPos[1] - 12;
}
+
+ fill(255, 255, 0);
+ textAlign(CENTER);
+ text(resourceCount, screenX, screenY);
}
-
- // Enter combat if enemies are nearby and not already in combat
- if (this._nearbyEnemies.length > 0 && this._stateMachine.isOutOfCombat()) {
- this._stateMachine.setCombatModifier("IN_COMBAT");
- } else if (this._nearbyEnemies.length === 0 && this._stateMachine.isInCombat()) {
- this._stateMachine.setCombatModifier("OUT_OF_COMBAT");
- }
- }
-
- // --- State Query Methods ---
- isIdle() { return this._stateMachine.isIdle(); }
- isInCombat() { return this._stateMachine.isInCombat(); }
- getCurrentState() { return this._stateMachine.getFullState(); }
- getStateSummary() { return this._stateMachine.getStateSummary(); }
-
- // --- Public Command Interface ---
- startGathering() {
- this.addCommand({ type: "GATHER" });
}
- startBuilding() {
- this.addCommand({ type: "BUILD" });
+ // --- Debug Override ---
+ getDebugInfo() {
+ const baseInfo = super.getDebugInfo();
+ const gatherInfo = this._gatherState ? this._gatherState.getDebugInfo() : { isActive: false };
+
+ return {
+ ...baseInfo,
+ antIndex: this._antIndex,
+ JobName: this.JobName,
+ currentState: this.getCurrentState(),
+ health: `${this._health}/${this._maxHealth}`,
+ resources: `${this.getResourceCount()}/${this.getMaxResources()}`,
+ faction: this._faction,
+ enemies: this._enemies.length,
+ gathering: gatherInfo
+ };
}
- followTarget(target) {
- this.addCommand({ type: "FOLLOW", target: target });
+ // --- Selenium Testing Getters (Ant-specific) ---
+
+ /**
+ * Get ant index (for Selenium validation)
+ * @returns {number|null} Ant's index in the ants array
+ */
+ getAntIndex() {
+ return this._antIndex || null;
}
-
- moveToTarget(x, y) {
- this.addCommand({ type: "MOVE", x: x, y: y });
+
+ /**
+ * Get ant health information (for Selenium validation)
+ * @returns {Object} Health data
+ */
+ getHealthData() {
+ return {
+ current: this._health,
+ max: this._maxHealth,
+ percentage: Math.round((this._health / this._maxHealth) * 100)
+ };
}
-
- // Force ant back to idle state (useful for debugging)
- forceIdle() {
- this._isMoving = false;
- this._commandQueue = [];
- this._stateMachine.setPrimaryState("IDLE");
+
+ /**
+ * Get ant resource information (for Selenium validation)
+ * @returns {Object} Resource data
+ */
+ getResourceData() {
+ return {
+ current: this.getResourceCount(),
+ max: this.getMaxResources(),
+ percentage: Math.round((this.getResourceCount() / this.getMaxResources()) * 100)
+ };
}
-
- // Debug method to check ant state
- debugState() {
+
+ /**
+ * Get ant combat information (for Selenium validation)
+ * @returns {Object} Combat data
+ */
+ getCombatData() {
return {
- antIndex: this._antIndex,
- primaryState: this._stateMachine.primaryState,
- fullState: this._stateMachine.getFullState(),
- isMoving: this._isMoving,
- timeUntilSkitter: this._timeUntilSkitter,
- commandQueueLength: this._commandQueue.length,
- canMove: this._stateMachine.canPerformAction("move"),
- isIdle: this._stateMachine.isIdle()
+ enemies: this._enemies.length,
+ inCombat: this._enemies.length > 0,
+ faction: this._faction
};
}
- static moveGroupInCircle(antArray, x, y, radius = 40) {
- const angleStep = (2 * Math.PI) / antArray.length;
- for (let i = 0; i < antArray.length; i++) {
- const angle = i * angleStep;
- const offsetX = Math.cos(angle) * radius;
- const offsetY = Math.sin(angle) * radius;
- antArray[i].moveToLocation(x + offsetX, y + offsetY);
- antArray[i].isSelected = false;
- }
+ /**
+ * Get available jobs list (for Selenium validation)
+ * @returns {Array} Available job types
+ */
+ static getAvailableJobs() {
+ return Object.keys(JobImages || {});
}
- static selectAntUnderMouse(ants, mx, my) {
- let selected = null;
- for (let i = 0; i < ants.length; i++) {
- let antObj = ants[i].antObject ? ants[i].antObject : ants[i];
- antObj.isSelected = false;
- }
- for (let i = 0; i < ants.length; i++) {
- let antObj = ants[i].antObject ? ants[i].antObject : ants[i];
- if (antObj.isMouseOver(mx, my)) {
- antObj.isSelected = true;
- selected = antObj;
- break;
+ /**
+ * Get complete ant validation data (for Selenium validation)
+ * @returns {Object} Complete validation data for testing
+ */
+ getAntValidationData() {
+ const baseData = super.getValidationData();
+ return {
+ ...baseData,
+ antIndex: this.getAntIndex(),
+ health: this.getHealthData(),
+ resources: this.getResourceData(),
+ combat: this.getCombatData(),
+ jobName: this.getJobName(),
+ availableJobs: ant.getAvailableJobs(),
+ antSpecific: {
+ enemies: this._enemies.length,
+ maxHealth: this._maxHealth,
+ maxResources: this.getMaxResources()
}
- }
- return selected;
+ };
+ }
+
+ // --- Cleanup Override ---
+ destroy() {
+ this._stateMachine = null;
+ this._resourceManager = null;
+ this._stats = null;
+ super.destroy();
}
+}
+
+// --- Ant Management Functions ---
+// --- Job Assignment Function ---
+function assignJob() {
+ const JobList = ['Builder', 'Scout', 'Farmer', 'Warrior', 'Spitter'];
+ const specialJobList = ['DeLozier',];
+ const availableSpecialJobs = [];
+ if (!hasDeLozier) availableSpecialJobs.push('DeLozier');
+ const availableJobs = [...JobList, ...availableSpecialJobs];
+
+ const chosenJob = availableJobs[Math.floor(random(0, availableJobs.length))];
+ if (chosenJob === "DeLozier") {
+ hasDeLozier = true;
+ }
+ return chosenJob;
}
-// --- Move Selected Ant to Tile ---
-function moveSelectedAntToTile(mx, my, tileSize) {
- if (selectedAnt) {
- const tileX = Math.floor(mx / tileSize);
- const tileY = Math.floor(my / tileSize); //Gets coordinates clicked tiles
- const grid = GRIDMAP.getGrid();
- const antX = Math.floor(selectedAnt.posX/tileSize);
- const antY = Math.floor(selectedAnt.posY/tileSize); //Gets current ant tile relative to where it started
- const startTile = grid.getArrPos([antX, antY]); //Converts ant start to pos suitable for pathfinding
- const endTile = grid.getArrPos([tileX, tileY]); //Converts clicked tile to pos suitable for pathfinding
- if(startTile && endTile){
- const newPath = findPath(startTile, endTile, GRIDMAP); //Only makes path if everything exists
- selectedAnt.setPath(newPath);
- }
- selectedAnt.isSelected = false;
- selectedAnt = null; //Resets pathfinding/selection info
+
+
+function spawnQueen(){
+ let JobName = 'Queen'
+ let sizeR = random(0, 15);
+
+ // Generate spawn position
+ let spawnX = random(0, 500);
+ let spawnY = random(0, 500);
+
+ // Convert to terrain-aligned coordinates
+ if (typeof g_activeMap !== 'undefined' && g_activeMap && g_activeMap.renderConversion &&
+ typeof g_activeMap.renderConversion.convCanvasToPos === 'function' &&
+ typeof g_activeMap.renderConversion.convPosToCanvas === 'function') {
+ const tilePos = g_activeMap.renderConversion.convCanvasToPos([spawnX, spawnY]);
+ const alignedPos = g_activeMap.renderConversion.convPosToCanvas(tilePos);
+ spawnX = alignedPos[0];
+ spawnY = alignedPos[1];
}
+
+ // Create QueenAnt directly (no need for wrapper ant)
+ console.log(queenSize)
+ let newAnt = new ant(
+ spawnX, spawnY,
+ queenSize.x + sizeR,
+ queenSize.y + sizeR,
+ 30, 0,
+ antBaseSprite,
+ 'Queen', // This makes it type "Queen"
+ 'player'
+ );
+
+ // Wrap in QueenAnt to get Queen-specific behavior
+ // Note: This creates a NEW entity, so we need to remove the old one from spatial grid
+ if (typeof spatialGridManager !== 'undefined' && spatialGridManager) {
+ spatialGridManager.removeEntity(newAnt);
+ }
+
+ newAnt = new QueenAnt(newAnt);
+
+ newAnt.assignJob(JobName, JobImages[JobName]);
+ ants.push(newAnt);
+ // also add to selectables so selection box can see it
+ if (typeof selectables !== 'undefined') selectables.push(newAnt);
+
+ newAnt.update();
+
+ // Register ant with TileInteractionManager for efficient mouse detection
+ if (g_tileInteractionManager) {
+ g_tileInteractionManager.addObject(newAnt, 'ant');
+ }
+
+
+ return newAnt;
}
-function moveSelectedAntsToTile(mx, my, tileSize) {
- if (selectedEntities.length === 0) return;
- const tileX = Math.floor(mx / tileSize);
- const tileY = Math.floor(my / tileSize);
- const grid = GRIDMAP.getGrid();
- const radius = 2; // in tiles
- const angleStep = (2 * Math.PI) / selectedEntities.length;
+// Spawn specific ants
+function spawnAntByType(antObj){
+ let movementController = antObj.getController('movement');
+ let jitter = 12;
+ const sizeX = antObj.getSize().x + (Math.random() * jitter - jitter / 2);
+ const sizeY = antObj.getSize().y + (Math.random() * jitter - jitter / 2);
+ const movementSpeed = movementController && typeof movementController.movementSpeed === 'number'
+ ? movementController.movementSpeed
+ : (antObj.movementSpeed || 30);
+ const img = (typeof antObj.getImage === 'function' && antObj.getImage()) || JobImages[antObj.jobName] || antBaseSprite;
+
+ // Correct argument order: posX, posY, sizex, sizey, movementSpeed, rotation, img, JobName, faction
+ let newAnt = new ant(
+ antObj.posX,
+ antObj.posY,
+ sizeX,
+ sizeY,
+ movementSpeed,
+ 0,
+ img,
+ antObj.jobName,
+ antObj.faction
+ );
+
+
+ newAnt.assignJob(antObj.jobName, JobImages[antObj.jobName]);
+ if (ants && Array.isArray(ants)) {
+ ants.push(newAnt);
+ }
+
+ // Register with TileInteractionManager if available
+ if (g_tileInteractionManager) {
+ g_tileInteractionManager.addObject(newAnt, 'ant');
+ }
+
+
+ if (typeof selectables !== 'undefined' && Array.isArray(selectables)) {
+ if (!selectables.includes(newAnt)) selectables.push(newAnt);
+ }
+ // Ensure selection controller uses selectables reference (some controllers snapshot list)
+ if (typeof g_selectionBoxController !== 'undefined' && g_selectionBoxController) {
+ if (g_selectionBoxController.entities) g_selectionBoxController.entities = selectables;
+ }
- for (let i = 0; i < selectedEntities.length; i++) {
- const ant = selectedEntities[i];
+ return newAnt;
+}
- // assign each ant its own destination tile around the click
- const angle = i * angleStep;
- const offsetTileX = tileX + Math.round(Math.cos(angle) * radius);
- const offsetTileY = tileY + Math.round(Math.sin(angle) * radius);
+// --- Spawn Ants ---
+function antsSpawn(numToSpawn, faction = "neutral", x = null, y = null) {
+ let list = [];
+ for (let i = 0; i < numToSpawn; i++) {
+ let sizeR = random(0, 15);
+ let JobName = assignJob();
+ if (faction != "player") {
+ JobName = "waveEnemy";
+ }
- const antCenterX = ant.posX + ant.sizeX / 2;
- const antCenterY = ant.posY + ant.sizeY / 2;
- const antX = Math.floor(antCenterX / tileSize);
- const antY = Math.floor(antCenterY / tileSize);
+ let px, py;
+ if (x !== null && y !== null) {
+ const jitter = 20;
+ px = x + (Math.random() * jitter - jitter / 2);
+ py = y + (Math.random() * jitter - jitter / 2);
+ } else {
+ px = random(0, 500);
+ py = random(0, 500);
+ }
+
+ // Convert to terrain-aligned coordinates (applies Y-axis inversion)
+ // This ensures entities are stored in the same coordinate space as terrain
+ if (typeof g_activeMap !== 'undefined' && g_activeMap && g_activeMap.renderConversion &&
+ typeof g_activeMap.renderConversion.convCanvasToPos === 'function' &&
+ typeof g_activeMap.renderConversion.convPosToCanvas === 'function') {
+ // Convert screen -> tile -> back to terrain-aligned screen coords
+ const tilePos = g_activeMap.renderConversion.convCanvasToPos([px, py]);
+ const alignedPos = g_activeMap.renderConversion.convPosToCanvas(tilePos);
+ px = alignedPos[0];
+ py = alignedPos[1];
+ }
- const startTile = grid.getArrPos([antX, antY]);
- const endTile = grid.getArrPos([offsetTileX, offsetTileY]);
+ // Create ant directly with new job system
+ let newAnt = new ant(
+ px, py,
+ antSize.x + sizeR,
+ antSize.y + sizeR,
+ 30, 0,
+ antBaseSprite,
+ JobName,
+ faction
+ );
+
+ newAnt.assignJob(JobName, JobImages[JobName]);
+
+ ants.push(newAnt);
+ if (typeof selectables !== 'undefined') selectables.push(newAnt);
- if (startTile && endTile) {
- const newPath = findPath(startTile, endTile, GRIDMAP);
- ant.setPath(newPath);
+ newAnt.update();
+
+ if (g_tileInteractionManager) {
+ g_tileInteractionManager.addObject(newAnt, 'ant');
}
- ant.isSelected = false;
+ list.push(newAnt);
}
- selectedEntities = [];
+ return list;
}
-// --- Debug Functions ---
-function debugAllAnts() {
- if (typeof devConsoleEnabled !== 'undefined' && devConsoleEnabled) {
- console.log("=== Ant State Debug ===");
- for (let i = 0; i < Math.min(ant_Index, 5); i++) { // Only debug first 5 ants
- if (ants[i]) {
- const antObj = ants[i].antObject ? ants[i].antObject : ants[i];
- console.log(`Ant ${i}:`, antObj.debugState());
+// --- Update All Ants ---
+
+function antsUpdate() {
+ for (let i = 0; i < ants.length; i++) {
+ if (ants[i] && typeof ants[i].update === "function") {
+ // Store previous position for TileInteractionManager updates
+ let prevPos = null;
+ if (g_tileInteractionManager && ants[i]) {
+ const currentPos = ants[i].getPosition ? ants[i].getPosition() : (ants[i].sprite ? ants[i].sprite.pos : null);
+ if (currentPos) {
+ prevPos = { x: currentPos.x, y: currentPos.y };
+ }
+ }
+
+ ants[i].update();
+
+ // Update TileInteractionManager with new position if ant moved
+ if (g_tileInteractionManager && ants[i] && prevPos) {
+ const newPos = ants[i].getPosition ? ants[i].getPosition() : (ants[i].sprite ? ants[i].sprite.pos : null);
+ if (newPos && (newPos.x !== prevPos.x || newPos.y !== prevPos.y)) {
+ g_tileInteractionManager.updateObjectPosition(ants[i], newPos.x, newPos.y);
+ }
}
}
}
}
-function forceAllAntsIdle() {
- if (typeof devConsoleEnabled !== 'undefined' && devConsoleEnabled) {
- console.log("Forcing all ants to idle state...");
+function getQueen(){
+ if(queenAnt){
+ return queenAnt;
+ }
+ return false;
+}
+
+// --- Render All Ants (Separated from Updates) ---
+function antsRender() {
+ // Start render phase tracking for legacy rendering
+ if (g_performanceMonitor) {
+ g_performanceMonitor.startRenderPhase('rendering');
}
- for (let i = 0; i < ant_Index; i++) {
- if (ants[i]) {
- const antObj = ants[i].antObject ? ants[i].antObject : ants[i];
- antObj.forceIdle();
+
+ // Render all ants in a single pass for better performance
+ for (let i = 0; i < ants.length; i++) {
+ // Check if ant should be rendered (not culled, active, etc.)
+ if (ants[i].isActive()) {
+ g_performanceMonitor.startEntityRender(ants[i]);
+ ants[i].render();
+ g_performanceMonitor.endEntityRender();
+ }
}
+
+
+ // End render phase tracking and finalize performance data
+ if (g_performanceMonitor) {
+ g_performanceMonitor.endRenderPhase();
+ g_performanceMonitor.recordEntityStats(ants.length, ants.length, 0, { ant: ants.length });
+ g_performanceMonitor.finalizeEntityPerformance();
}
}
+// --- Update and Render All Ants (Legacy function for backward compatibility) ---
+function antsUpdateAndRender() {
+ antsUpdate();
+ antsRender();
+}
+
+
+
+
// Export for Node.js testing
-if (typeof module !== "undefined" && module.exports) {
- module.exports = ant;
+if (typeof module !== 'undefined' && module.exports) {
+ module.exports = {
+ ant,
+ antsSpawn,
+ antsUpdate,
+ antsRender,
+ antsUpdateAndRender,
+ assignJob,
+ handleSpawnCommand,
+ antsPreloader,
+ // Export reference to local variables for testing
+ getAntSize: () => antSize,
+ setAntSize: (size) => { antSize = size; },
+ getAnts: () => ants,
+ getAntIndex: () => antIndex,
+ setAntIndex: (index) => { antIndex = index; }
+ };
+}
+
+// Simple wrapper for handleSpawnCommand to match test expectations
+function handleSpawnCommand(count, faction) {
+ // Create ants using antsSpawn with the new signature
+ antsSpawn(count, faction);
+}
+
+// Make functions available globally for browser environment
+if (typeof window !== 'undefined') {
+ window.ant = ant;
+ window.antsSpawn = antsSpawn;
+ window.antsUpdate = antsUpdate;
+ window.antsRender = antsRender;
+ window.antsUpdateAndRender = antsUpdateAndRender;
+ window.assignJob = assignJob;
+ window.handleSpawnCommand = handleSpawnCommand;
+} else if (typeof global !== 'undefined') {
+ global.ant = ant;
+ global.antsSpawn = antsSpawn;
+ global.antsUpdate = antsUpdate;
+ global.antsRender = antsRender;
+ global.antsUpdateAndRender = antsUpdateAndRender;
+ global.assignJob = assignJob;
+ global.handleSpawnCommand = handleSpawnCommand;
}
\ No newline at end of file
diff --git a/Classes/ants/species.js b/Classes/ants/species.js
deleted file mode 100644
index 46fc7da2..00000000
--- a/Classes/ants/species.js
+++ /dev/null
@@ -1,154 +0,0 @@
-const _speciesList = ["Builder", "Scout", "Farmer", "Warrior", "Spitter"];
-const _specialSpeciesList = ["DeLozier"]
-const _allSpecies = [..._speciesList, ..._specialSpeciesList];
-class Species extends ant {
- constructor(antObject, speciesName, speciesImage) {
- const speciesStats = Species.getSpeciesStats(speciesName);
- super(
- antObject.posX,
- antObject.posY,
- antObject.sizeX,
- antObject.sizeY,
- speciesStats.movementSpeed ?? antObject.movementSpeed,
- antObject.rotation,
- speciesImage // Pass the image here!
- );
- this.img = speciesImage
- this.speciesName = speciesName;
- this.exp = antObject.stats.exp
-
-
- // Overwrite stats with species-specific values
- this.stats.strength.statValue = speciesStats.strength;
- this.stats.health.statValue = speciesStats.health;
- this.stats.gatherSpeed.statValue = speciesStats.gatherSpeed;
- this.stats.movementSpeed.statValue = speciesStats.movementSpeed;
- this.waypoints = []; // Array of {x, y} locations
- }
-
- static getSpeciesStats(speciesName) {
- switch (speciesName) {
- case "Builder":
- return { strength: 20, health: 120, gatherSpeed: 15, movementSpeed: 20 };
- case "Scout":
- return { strength: 10, health: 80, gatherSpeed: 10, movementSpeed: 80 };
- case "Farmer":
- return { strength: 15, health: 100, gatherSpeed: 30, movementSpeed: 15 };
- case "Warrior":
- return { strength: 40, health: 150, gatherSpeed: 5, movementSpeed: 25 };
- case "Spitter":
- return { strength: 30, health: 90, gatherSpeed: 8, movementSpeed: 30 };
- case "DeLozier":
- return { strength: 1000, health: 10000, gatherSpeed: 1, movementSpeed: 10000 };
- default:
- return { strength: 10, health: 100, gatherSpeed: 10, movementSpeed: 20 };
- }
- }
-
- // Example: Override update to show species name
- update() {
- super.update();
-
- // Species labels always enabled
- if (typeof outlinedText !== 'undefined') {
- const center = this.center;
-
- push();
- rectMode(CENTER);
-
- // put the text a bit *below* the ant sprite
- const labelY = center.y + this.sizeY / 2 + 15;
-
- // call your outlinedText helper
- outlinedText(
- this.speciesName,
- center.x,
- labelY,
- font, // <- your preloaded Terraria.TTF font
- 13, // font size
- color(255), // inside (fill) color
- color(0) // outline color
- );
-
- pop();
- }
- }
-
- ResolveMoment() {
- if (this._isMoving) {
- const current = createVector(this.posX, this.posY);
- const target = createVector(
- this._stats.pendingPos.statValue.x,
- this._stats.pendingPos.statValue.y
- );
-
- const direction = p5.Vector.sub(target, current);
- const distance = direction.mag();
-
- if (distance > 1) {
- direction.normalize();
- const speedPerMs = this.movementSpeed / 1000;
- const step = Math.min(speedPerMs * deltaTime, distance);
- current.x += direction.x * step;
- current.y += direction.y * step;
- this.posX = current.x;
- this.posY = current.y;
- this._sprite.setPosition(current);
- } else {
-
- // Target Reach
-
- this.posX = target.x;
- this.posY = target.y;
- this._isMoving = false;
- this._sprite.setPosition(target);
-
- // Stores Resource and Reset State Upon Dropoff
- if(this.isDroppingOff || this.isMaxWeight ){
- for(let r of this.Resources){
- globalResource.push(r);
- }
-
- this.Resources = [];
- this.isDroppingOff = false;
- this.isMaxWeight = false;
- }
- }
-
- this.render();
- }
- }
-
- getStatsSummary() {
- // Gather all exp types and values
- let expSummary = {};
- for (let [key, statObj] of this.stats.exp.entries()) {
- expSummary[key] = statObj.statValue;
- }
- return {
- species: this.speciesName,
- strength: this.stats.strength.statValue,
- health: this.stats.health.statValue,
- gatherSpeed: this.stats.gatherSpeed.statValue,
- movementSpeed: this.stats.movementSpeed.statValue,
- exp: expSummary
- };
- }
-}
-
-// Assigns a random species to an ant
-function assignSpecies() {
- // Add DeLozier to the species list only if it hasn't been created yet
- if (!hasDeLozier) { speciesList = _specialSpeciesList; }
- else speciesList = _speciesList
- const chosenSpecies = speciesList[Math.floor(random(0, speciesList.length))];
-
- // If DeLozier is chosen, set the flag to true
- if (chosenSpecies === "DeLozier") { hasDeLozier = true; }
-
- return chosenSpecies;
-}
-
-if (typeof module !== "undefined" && module.exports) {
- module.exports = Species;
-}
\ No newline at end of file
diff --git a/Classes/containers/DropoffLocation.js b/Classes/containers/DropoffLocation.js
new file mode 100644
index 00000000..da06987e
--- /dev/null
+++ b/Classes/containers/DropoffLocation.js
@@ -0,0 +1,157 @@
+/**
+ * DropoffLocation
+ * ---------------
+ * Small, immobile dropoff that:
+ * - owns a small InventoryController (default capacity 2)
+ * - occupies a rectangle of grid tiles (grid coords)
+ * - can expand/retract (change tile footprint)
+ * - optionally marks a Grid instance with itself
+ * - draws the tiles it occupies in semi-opaque blue
+ *
+ * Usage:
+ * const d = new DropoffLocation(5,4,2,2,{tileSize:32,capacity:2,grid:myGrid});
+ * d.draw(); // render blue tiles
+ * d.expand(1,0); // +1 tile width
+ * d.retract(0,1); // -1 tile height
+ * d.depositResource(res);
+ */
+class DropoffLocation {
+ constructor(gridX, gridY, widthTiles = 1, heightTiles = 1, opts = {}) {
+ this.x = Math.floor(gridX);
+ this.y = Math.floor(gridY);
+ this.width = Math.max(1, Math.floor(widthTiles));
+ this.height = Math.max(1, Math.floor(heightTiles));
+ this.tileSize = opts.tileSize || (typeof TILE_SIZE !== 'undefined' ? TILE_SIZE : 32);
+ this.grid = opts.grid || null; // optional Grid instance to mark
+ // inventory: prefer provided InventoryController or global one
+ const Inventory = (typeof opts.InventoryController !== 'undefined') ? opts.InventoryController :
+ (typeof InventoryController !== 'undefined') ? InventoryController : null;
+ this.inventory = Inventory ? new Inventory(this, opts.capacity || 2) : null;
+ this._filledOnGrid = false;
+ if (this.grid) this._markGrid();
+ }
+
+ // Return array of tile coords this dropoff currently covers
+ tiles() {
+ const out = [];
+ for (let yy = 0; yy < this.height; yy++) {
+ for (let xx = 0; xx < this.width; xx++) {
+ out.push([this.x + xx, this.y + yy]);
+ }
+ }
+ return out;
+ }
+
+ // Mark the Grid (if provided) with this object at each tile (uses grid.set)
+ _markGrid() {
+ if (!this.grid) return;
+ try {
+ for (const t of this.tiles()) {
+ this.grid.set(t, this);
+ }
+ this._filledOnGrid = true;
+ } catch (e) {
+ // don't throw in render code; log for debug
+ console.warn("DropoffLocation._markGrid failed:", e);
+ }
+ }
+
+ // Unmark grid tiles (set to NONE) — safe if grid exists
+ _unmarkGrid() {
+ if (!this.grid || !this._filledOnGrid) return;
+ try {
+ for (const t of this.tiles()) {
+ this.grid.set(t, NONE);
+ }
+ this._filledOnGrid = false;
+ } catch (e) { console.warn("DropoffLocation._unmarkGrid failed:", e); }
+ }
+
+ // Expand footprint by tile deltas (can be negative -> retract)
+ expand(dx = 1, dy = 0) {
+ if (dx === 0 && dy === 0) return;
+ this._unmarkGrid();
+ this.width = Math.max(1, this.width + dx);
+ this.height = Math.max(1, this.height + dy);
+ this._markGrid();
+ }
+
+ // Retract by absolute amounts (keeps at least 1x1)
+ retract(dx = 1, dy = 0) {
+ this.expand(-Math.abs(dx), -Math.abs(dy));
+ }
+
+ // Set absolute footprint
+ setSize(widthTiles, heightTiles) {
+ this._unmarkGrid();
+ this.width = Math.max(1, Math.floor(widthTiles));
+ this.height = Math.max(1, Math.floor(heightTiles));
+ this._markGrid();
+ }
+
+ // Try to add a resource into inventory. Returns true on success.
+ depositResource(resource) {
+ if (!this.inventory) return false;
+ return this.inventory.addResource(resource);
+ }
+
+ // Try to pull resources from an ant-like object that has an inventory or getResources()
+ // returns number transferred
+ acceptFromCarrier(carrier) {
+ if (!carrier || !this.inventory) return 0;
+ // carrier.inventory.transferAllTo exists? use it
+ try {
+ if (carrier.inventory && typeof carrier.inventory.transferAllTo === 'function') {
+ return carrier.inventory.transferAllTo(this.inventory);
+ }
+ // otherwise, attempt to move slot-by-slot via getResources/addResource
+ if (typeof carrier.getResources === 'function') {
+ const res = carrier.getResources();
+ let moved = 0;
+ for (let i = 0; i < res.length; i++) {
+ if (!res[i]) continue;
+ if (this.inventory.addResource(res[i])) {
+ // if carrier has removeResource, call it
+ if (typeof carrier.removeResource === 'function') carrier.removeResource(i, false);
+ else carrier.getResources()[i] = null;
+ moved++;
+ }
+ }
+ return moved;
+ }
+ } catch (e) {
+ console.warn("DropoffLocation.acceptFromCarrier error:", e);
+ }
+ return 0;
+ }
+
+ // Draw blue overlay on occupied tiles. Uses p5 drawing functions.
+ draw() {
+ if (typeof push !== 'function') return; // p5 not available
+ push();
+ noStroke();
+ fill(0, 0, 255, 120);
+ for (const t of this.tiles()) {
+ const px = t[0] * this.tileSize;
+ const py = t[1] * this.tileSize;
+ rect(px, py, this.tileSize, this.tileSize);
+ }
+ // draw thin outline
+ stroke(0, 0, 200, 200);
+ strokeWeight(2);
+ noFill();
+ rect(this.x * this.tileSize, this.y * this.tileSize, this.width * this.tileSize, this.height * this.tileSize);
+ pop();
+ }
+
+ // Convenience: world pixel center
+ getCenterPx() {
+ const cx = (this.x + this.width / 2) * this.tileSize;
+ const cy = (this.y + this.height / 2) * this.tileSize;
+ return { x: cx, y: cy };
+ }
+}
+
+// Expose to browser and Node
+if (typeof window !== 'undefined') window.DropoffLocation = DropoffLocation;
+if (typeof module !== 'undefined' && module.exports) module.exports = DropoffLocation;
diff --git a/Classes/containers/Entity.js b/Classes/containers/Entity.js
new file mode 100644
index 00000000..f947a6b3
--- /dev/null
+++ b/Classes/containers/Entity.js
@@ -0,0 +1,913 @@
+/**
+ * Entity
+ * ----
+ * Base game entity using a controller-based architecture.
+ * - Composes optional controllers (transform, movement, render, selection, interaction, combat, terrain, taskManager).
+ * - Provides simple delegation helpers so game code interacts with a stable Entity API.
+ *
+ * Responsibilities:
+ * - Manage core identity/state (id, type, active).
+ * - Initialize and configure controllers when available.
+ * - Provide convenience methods that delegate to controllers.
+ * - Provide update/render entry points used by the game loop.
+ */
+
+// Import EventBus for entity registration
+let eventBus;
+if (typeof window !== 'undefined' && window.eventBus) {
+ eventBus = window.eventBus;
+} else if (typeof require !== 'undefined') {
+ try {
+ const eventBusModule = require('../globals/eventBus');
+ eventBus = eventBusModule.default || eventBusModule;
+ } catch (e) {
+ // EventBus not available
+ }
+}
+
+//Faction setup
+const factionList = {};
+class Entity {
+ /**
+ * Construct an Entity.
+ * @param {number} x - initial x position
+ * @param {number} y - initial y position
+ * @param {number} width - initial width
+ * @param {number} height - initial height
+ * @param {Object} [options={}] - optional configuration (type, imagePath, movementSpeed, faction, selectable, etc.)
+ */
+ constructor(x = 0, y = 0, width = 32, height = 32, options = {}) { // x,y canvas
+ // Core properties
+ this._id = `entity_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+ this._type = options.type || "Entity";
+ this._isActive = true;
+
+ // Apply +0.5 tile offset for tile-centered positioning
+ // This moves entities to the visual center of their tile, so rendering doesn't need offset
+ const TILE_SIZE = typeof window !== 'undefined' && window.TILE_SIZE ? window.TILE_SIZE : 32;
+ // const centeredX = x + (TILE_SIZE * 0.5); // Canvas cordinates
+ // const centeredY = y + (TILE_SIZE * 0.5); // Tiles offset by -0.5,-0.5 -- matching that
+
+ const centeredX = x + (width * 0.5); // Canvas cordinates
+ const centeredY = y + (height * 0.5);
+
+ // Initialize collision box first (required by some controllers)
+ this._collisionBox = new CollisionBox2D(centeredX, centeredY, width, height);
+
+ // Initialize sprite component (if Sprite2D available) - use centered position
+ this._sprite = typeof Sprite2D !== 'undefined' ?
+ new Sprite2D(options.imagePath || null, createVector(centeredX, centeredY), createVector(width, height), 0) : null;
+
+ // Initialize debugger system (if UniversalDebugger available)
+ this._debugger = null;
+ this._initializeDebugger(options);
+
+ // Initialize controllers and apply options
+ this._initializeControllers(options);
+
+ // Initialize enhanced API
+ this._initializeEnhancedAPI();
+
+ // Ensure transform state propagated to collision box and sprite (use centered position)
+ this.setPosition(centeredX, centeredY);
+ this.setSize(width, height);
+
+
+ // Faction registration
+ if(!(this._faction in factionList)){
+ factionList[this._faction] = {
+ 'isUnderAttack' : null,
+ };
+ }
+
+ // Register with spatial grid manager (if available and not disabled)
+ if (options.useSpatialGrid !== false && typeof spatialGridManager !== 'undefined') {
+ spatialGridManager.addEntity(this);
+ }
+
+ // Emit entity registration signal
+ if (eventBus) {
+ const metadata = {};
+
+ // Add type-specific metadata
+ if (this._type === 'ant' || this._type === 'Ant' || this._type === 'Queen') {
+ metadata.jobName = options.JobName || this._JobName || 'Scout';
+ } else if (this._type === 'Resource') {
+ metadata.resourceType = this._resourceType || options.resourceType || 'unknown';
+ } else if (this._type === 'Building') {
+ metadata.buildingType = this.buildingType || options.buildingType || 'unknown';
+ }
+
+ eventBus.emit('ENTITY_REGISTERED', {
+ type: this._type.toLowerCase(),
+ id: this._id,
+ faction: this._faction || options.faction || 'neutral',
+ metadata: metadata
+ });
+ }
+ }
+
+ // --- Core Properties ---
+ /** @returns {string} unique id */
+ get id() { return this._id; }
+ /** @returns {string} entity type name */
+ get type() { return this._type; }
+ /** @returns {boolean} active flag */
+ get isActive() { return this._isActive; }
+ set isActive(value) { this._isActive = value; }
+
+ // --- Debugger Initialization ---
+ /**
+ * Initialize the debugger system if UniversalDebugger is available.
+ * @param {Object} [options] - Configuration options
+ * @private
+ */
+ _initializeDebugger(options = {}) {
+ if (typeof UniversalDebugger !== 'undefined') {
+ try {
+ // Configure debugger with entity-specific settings
+ const debugConfig = {
+ showBoundingBox: true,
+ showPropertyPanel: options.showDebugPanel !== false,
+ borderColor: options.debugBorderColor || '#FF0000',
+ fillColor: options.debugFillColor || 'rgba(255, 0, 0, 0.1)',
+ autoRefresh: options.debugAutoRefresh || false,
+ fontSize: options.debugFontSize || 10,
+ ...options.debugConfig
+ };
+
+ this._debugger = new UniversalDebugger(this, debugConfig);
+
+ // Register this entity with the global debug manager if available
+ window.EntityDebugManager.registerEntity(this);
+
+ } catch (error) {
+ console.warn('Failed to initialize entity debugger:', error);
+ this._debugger = null;
+ }
+ }
+ }
+
+ // --- Controller Initialization ---
+ /**
+ * Initialize available controllers and register them in a Map.
+ * Controllers are optional and only created if present in the environment.
+ * @param {Object} [options]
+ * @private
+ */
+ _initializeControllers(options = {}) {
+ this._controllers = new Map();
+
+ // Map of controller name -> constructor (or null if not available)
+ const availableControllers = {
+ 'transform': typeof TransformController !== 'undefined' ? TransformController : null,
+ 'movement': typeof MovementController !== 'undefined' ? MovementController : null,
+ 'render': typeof RenderController !== 'undefined' ? RenderController : null,
+ 'selection': typeof SelectionController !== 'undefined' ? SelectionController : null,
+ 'combat': typeof CombatController !== 'undefined' ? CombatController : null,
+ 'terrain': typeof TerrainController !== 'undefined' ? TerrainController : null,
+ 'taskManager': typeof TaskManager !== 'undefined' ? TaskManager : null,
+ 'health': typeof HealthController !== 'undefined' ? HealthController : null
+ };
+
+ Object.entries(availableControllers).forEach(([name, ControllerClass]) => {
+ if (ControllerClass) {
+ try { this._controllers.set(name, new ControllerClass(this)); }
+ catch (error) { console.warn(`Failed to initialize ${name} controller:`, error); }
+ } else {
+ console.warn(`Controller ${name} not available`);
+ }
+ });
+
+ this._configureControllers(options);
+ }
+
+ /**
+ * Apply options to controllers (speed, selectable, faction, etc.).
+ * @param {Object} options
+ * @private
+ */
+ _configureControllers(options) {
+ const movement = this._controllers.get('movement');
+ movement.movementSpeed = options.movementSpeed;
+
+ const selection = this._controllers.get('selection');
+ selection.setSelectable(options.selectable);
+
+ const combat = this._controllers.get('combat');
+ combat.setFaction(options.faction);
+ }
+
+ // --- Controller Access Helper ---
+ /**
+ * Retrieve a controller instance by name, if present.
+ * @param {string} name
+ * @returns {Object|undefined}
+ */
+ getController(name) { return this._controllers.get(name); }
+
+ // --- Generic Delegation Helper ---
+ /**
+ * Delegate a method call to a named controller if available.
+ * @param {string} controllerName
+ * @param {string} methodName
+ * @param {...any} args
+ * @returns {*}
+ * @private
+ */
+ _delegate(controllerName, methodName, ...args) {
+ const controller = this._controllers.get(controllerName);
+ return controller?.[methodName]?.(...args);
+ }
+
+ // --- Position & Transform ---
+ /**
+ * Set position in world coordinates (collision box is single source of truth)
+ * @param {number} x - X coordinate in world space (pixels)
+ * @param {number} y - Y coordinate in world space (pixels)
+ */
+ setPosition(x, y) {
+ // Collision box is the authoritative position storage
+ this._collisionBox.setPosition(x, y);
+
+ // Notify transform controller to sync sprite and mark dirty
+ const result = this._delegate('transform', 'setPosition', this._collisionBox.getPosX(), this._collisionBox.getPosY());
+
+ // Update spatial grid when entity moves
+ if (typeof spatialGridManager !== 'undefined') {
+ spatialGridManager.updateEntity(this);
+ }
+
+ return result;
+ }
+
+ /**
+ * Set position from screen coordinates (converts to world space)
+ * Useful for mouse clicks and UI interactions
+ * @param {number} screenX - X coordinate in screen space (canvas pixels)
+ * @param {number} screenY - Y coordinate in screen space (canvas pixels)
+ */
+ setPositionFromScreen(screenX, screenY) {
+ const worldPos = CoordinateConverter.screenToWorld(screenX, screenY);
+ this.setPosition(worldPos.x, worldPos.y);
+ }
+
+ /** Get position (from transform controller which reads from collision box). */
+ getPosition() { return this._delegate('transform', 'getPosition') }
+
+ /**
+ * Get screen position (converts world position to screen coordinates for rendering)
+ * This matches the coordinate transformation used by Sprite2D rendering
+ * @returns {{x: number, y: number}} Screen coordinates
+ */
+ getScreenPosition() {
+ // Get world position from transform controller
+ const worldPos = this.getPosition();
+ let screenX = worldPos.x;
+ let screenY = worldPos.y;
+
+ // Use terrain's coordinate system if available (syncs with sprite rendering)
+ if (typeof g_activeMap !== 'undefined' && g_activeMap && g_activeMap.renderConversion && typeof TILE_SIZE !== 'undefined') {
+ // Convert world pixels to tile coordinates
+ // Entity position is already tile-centered (+0.5 applied in Entity constructor)
+ const tileX = worldPos.x / TILE_SIZE;
+ const tileY = worldPos.y / TILE_SIZE;
+
+ // Use terrain's converter to get screen position (handles Y-axis inversion and camera)
+ const screenPos = g_activeMap.renderConversion.convPosToCanvas([tileX, tileY]);
+ screenX = screenPos[0];
+ screenY = screenPos[1];
+ }
+
+ return { x: screenX, y: screenY };
+ }
+
+ /**
+ * Get position in tile coordinates
+ * @returns {{x: number, y: number}} Tile coordinates (floored integers)
+ */
+ getTilePosition() {
+ const pos = this.getPosition();
+ if (typeof CoordinateConverter !== 'undefined') {
+ return CoordinateConverter.worldToTile(pos.x, pos.y);
+ }
+ }
+
+ /** Get X coordinate. */
+ getX() {
+ const pos = this.getPosition();
+ return pos.x;
+ }
+ /** Get Y coordinate. */
+ getY() {
+ const pos = this.getPosition();
+ return pos.y;
+ }
+ /** Set size (delegates to transform controller if present). */
+ setSize(w, h) { this._collisionBox.setSize(w, h); return this._delegate('transform', 'setSize', w, h); }
+ /** Get size (from transform controller or collision box). */
+ getSize() { return this._delegate('transform', 'getSize') || { x: this._collisionBox.width, y: this._collisionBox.height }; }
+ /** Get center point (delegates or falls back to collision box). */
+ getCenter() { return this._delegate('transform', 'getCenter') || this._collisionBox.getCenter(); }
+
+ // --- Movement ---
+ /** Instruct movement controller to move to location. */
+ moveToLocation(x, y) { return this._delegate('movement', 'moveToLocation', x, y); }
+ /** Set movement path. */
+ setPath(path) { return this._delegate('movement', 'setPath', path); }
+ /** Query whether entity is moving. */
+ isMoving() { return this._delegate('movement', 'getIsMoving') || false; }
+ /** Stop movement. */
+ stop() { return this._delegate('movement', 'stop'); }
+ /** Get movement speed. */
+ get movementSpeed() {
+ const movement = this._controllers.get('movement');
+ return movement ? movement.movementSpeed : 0;
+ }
+ /** Set movement speed. */
+ set movementSpeed(speed) {
+ const movement = this._controllers.get('movement');
+ if (movement) movement.movementSpeed = speed;
+ }
+
+ // --- Selection ---
+ setSelected(selected) { return this._delegate('selection', 'setSelected', selected); }
+ isSelected() { return this._delegate('selection', 'isSelected') || false; }
+ toggleSelection() { return this._delegate('selection', 'toggleSelection'); }
+
+ // --- Interaction ---
+ isMouseOver() {
+ // Convert mouse screen coordinates to world coordinates for collision detection
+ // Uses CoordinateConverter utility which handles Y-axis inversion automatically
+ const worldMouse = (typeof CoordinateConverter !== 'undefined') ?
+ CoordinateConverter.screenToWorld(mouseX, mouseY) :
+ { x: mouseX, y: mouseY }; // Fallback if converter not available
+
+ const isOver = this._collisionBox.contains(worldMouse.x, worldMouse.y);
+
+ // Only log if mouse moved and hovering
+ if (isOver && (!window._lastDebugMouseX || !window._lastDebugMouseY ||
+ window._lastDebugMouseX !== mouseX || window._lastDebugMouseY !== mouseY)) {
+ const pos = this.getPosition();
+ const size = this.getSize();
+ logNormal(`[Entity.js:isMouseOver:225] Screen:(${mouseX},${mouseY}) World:(${worldMouse.x},${worldMouse.y}) EntityPos:(${pos.x},${pos.y}) Size:(${size.x},${size.y}) isOver:${isOver}`);
+ window._lastDebugMouseX = mouseX;
+ window._lastDebugMouseY = mouseY;
+ }
+
+ return isOver;
+ }
+
+ // TODO: The interaction controller has been removed, need to delegate this somewhere else.
+ onClick() { return this._delegate('interaction', 'onClick'); }
+
+ // --- Combat ---
+ isInCombat() { return this._delegate('combat', 'isInCombat') || false; }
+ detectEnemies() { return this._delegate('combat', 'detectEnemies'); }
+
+ // --- Tasks ---
+ addTask(task) { return this._delegate('taskManager', 'addTask', task); }
+ getCurrentTask() { return this._delegate('taskManager', 'getCurrentTask'); }
+
+ // --- Terrain ---
+ getCurrentTerrain() { return this._delegate('terrain', 'getCurrentTerrain') || "DEFAULT"; }
+
+ // --- Sprite/Image ---
+ setImage(imagePath) { return this._sprite?.setImage(imagePath); }
+ getImage() { return this._sprite?.getImage(); }
+ hasImage() { return this._sprite?.img != null; }
+ setOpacity(alpha) { if (this._sprite) this._sprite.setOpacity(alpha); }
+ getOpacity() { return this._sprite?.getOpacity() || 255; }
+
+ // --- Collision ---
+ /**
+ * Test collision with another entity (via collision boxes).
+ * @param {Entity} other
+ * @returns {boolean}
+ */
+ collidesWith(other) {
+ if (other._collisionBox) return this._collisionBox.intersects(other._collisionBox);
+ return false;
+ }
+
+ /** Point containment test using this entity's collision box. */
+ contains(x, y) { return this._collisionBox.contains(x, y); }
+
+ // --- Core Update Loop ---
+ /**
+ * update
+ * ----
+ * Called each frame to update controllers, collision box, and sprite.
+ */
+ update() {
+ if (!this._isActive) return;
+ this._controllers.forEach((controller, name) => {
+ try { controller?.update(); } catch (error) { console.warn(`Error updating ${name} controller:`, error); }
+ });
+
+ const pos = this.getPosition();
+ const size = this.getSize();
+ this._collisionBox.setPosition(pos.x, pos.y);
+ this._collisionBox.setSize(size.x, size.y);
+ this._sprite?.setPosition(createVector(pos.x, pos.y));
+ this._sprite?.setSize(createVector(size.x, size.y));
+
+ // Update debugger if active
+ if (this._debugger?.isActive) {
+ try { this._debugger.update(); } catch (error) { console.warn('Error updating entity debugger:', error); }
+ }
+ }
+
+ // --- Rendering ---
+ /**
+ * render
+ * ------
+ * Delegates rendering to the render controller when present, otherwise falls back.
+ */
+ render() {
+ if (!this._isActive) {
+ return;
+ }
+
+ const renderController = this._controllers.get('render');
+ renderController.render();
+
+ // Render debugger overlay if active
+ if (this._debugger?.isActive) {
+ try { this._debugger.render(); } catch (error) { console.warn('Error rendering entity debugger:', error); }
+ }
+ }
+
+ // --- Debug ---
+ /**
+ * getDebugInfo
+ * ------------
+ * Return a compact object summarizing the entity's state and controller availability.
+ * Useful for logging / in-editor inspection.
+ * @returns {Object}
+ */
+ getDebugInfo() {
+ const controllerStatus = {};
+ this._controllers.forEach((controller, name) => { controllerStatus[name] = !!controller; });
+ return {
+ id: this._id,
+ type: this._type,
+ position: this.getPosition(),
+ size: this.getSize(),
+ isActive: this._isActive,
+ isSelected: this.isSelected(),
+ isMoving: this.isMoving(),
+ isInCombat: this.isInCombat(),
+ currentTerrain: this.getCurrentTerrain(),
+ controllers: controllerStatus,
+ controllerCount: this._controllers.size,
+ hasSprite: !!this._sprite,
+ hasImage: this.hasImage(),
+ opacity: this.getOpacity(),
+ hasDebugger: !!this._debugger,
+ debuggerActive: this._debugger?.isActive || false
+ };
+ }
+
+ /**
+ * Toggle the entity's debugger visualization.
+ * @param {boolean} [forceState] - Optional forced state (true/false)
+ * @returns {boolean} New debugger state
+ */
+ toggleDebugger(forceState) {
+ if (!this._debugger) return false;
+
+ if (typeof forceState === 'boolean') {
+ if (forceState) this._debugger.activate();
+ else this._debugger.deactivate();
+ } else {
+ this._debugger.toggle();
+ }
+
+ return this._debugger.isActive;
+ }
+
+ /**
+ * Check if debugger is active.
+ * @returns {boolean} True if debugger is active
+ */
+ isDebuggerActive() {
+ return this._debugger?.isActive || false;
+ }
+
+ /**
+ * Get the debugger instance for advanced configuration.
+ * @returns {UniversalDebugger|null} Debugger instance or null
+ */
+ getDebugger() {
+ return this._debugger;
+ }
+
+ // --- Enhanced API ---
+ /**
+ * Initialize the enhanced property-based API for rendering, effects, and highlights
+ * This creates clean namespaced methods like entity.highlight.selected() and entity.effects.add()
+ */
+ _initializeEnhancedAPI() {
+ // Highlight namespace
+ this.highlight = {
+ selected: () => {
+ const controller = this._controllers.get('render');
+ return controller ? controller.highlightSelected() : null;
+ },
+ hover: () => {
+ const controller = this._controllers.get('render');
+ return controller ? controller.highlightHover() : null;
+ },
+ boxHover: () => {
+ const controller = this._controllers.get('render');
+ return controller ? controller.highlightBoxHover() : null;
+ },
+ resourceHover: () => {
+ const controller = this._controllers.get('render');
+ return controller ? controller.highlightResource() : null;
+ },
+ spinning: () => {
+ const controller = this._controllers.get('render');
+ return controller ? controller.highlightSpin() : null;
+ },
+ slowSpin: () => {
+ const controller = this._controllers.get('render');
+ return controller ? controller.highlightSlowSpin() : null;
+ },
+ fastSpin: () => {
+ const controller = this._controllers.get('render');
+ return controller ? controller.highlightFastSpin() : null;
+ },
+ combat: () => {
+ const controller = this._controllers.get('render');
+ return controller ? controller.highlightCombat() : null;
+ },
+ set: (type, intensity) => {
+ const controller = this._controllers.get('render');
+ return controller ? controller.setHighlight(type, intensity) : null;
+ },
+ clear: () => {
+ const controller = this._controllers.get('render');
+ return controller ? controller.clearHighlight() : null;
+ }
+ };
+
+ // Effects namespace
+ this.effects = {
+ add: (effect) => {
+ // Try render controller first, then effects renderer
+ const renderController = this._controllers.get('render');
+ if (renderController && renderController.addEffect) {
+ return renderController.addEffect(effect);
+ }
+
+ // Fallback to global effects renderer
+ const effectsRenderer = (typeof window !== 'undefined') ? window.EffectsRenderer :
+ (typeof global !== 'undefined') ? global.EffectsRenderer : null;
+ if (effectsRenderer) {
+ return effectsRenderer.addEffect(effect.type || effect, {
+ x: this.x,
+ y: this.y,
+ ...effect
+ });
+ }
+
+ return null;
+ },
+ remove: (effectId) => {
+ const controller = this._controllers.get('render');
+ return controller ? controller.removeEffect(effectId) : null;
+ },
+ clear: () => {
+ const controller = this._controllers.get('render');
+ return controller ? controller.clearEffects() : null;
+ },
+ damageNumber: (damage, color = [255, 0, 0]) => {
+ return this.effects.add({
+ type: 'DAMAGE_NUMBER',
+ text: `-${damage}`,
+ color: color,
+ x: this.x,
+ y: this.y - 20
+ });
+ },
+ healNumber: (heal, color = [0, 255, 0]) => {
+ return this.effects.add({
+ type: 'HEAL_NUMBER',
+ text: `+${heal}`,
+ color: color,
+ x: this.x,
+ y: this.y - 20
+ });
+ },
+ floatingText: (text, color = [255, 255, 255]) => {
+ return this.effects.add({
+ type: 'FLOATING_TEXT',
+ text: text,
+ color: color,
+ x: this.x,
+ y: this.y - 15
+ });
+ },
+ bloodSplatter: (options = {}) => {
+ const effectsRenderer = (typeof window !== 'undefined') ? window.EffectsRenderer :
+ (typeof global !== 'undefined') ? global.EffectsRenderer : null;
+ return effectsRenderer ? effectsRenderer.bloodSplatter(this.x, this.y, options) : null;
+ },
+ impactSparks: (options = {}) => {
+ const effectsRenderer = (typeof window !== 'undefined') ? window.EffectsRenderer :
+ (typeof global !== 'undefined') ? global.EffectsRenderer : null;
+ return effectsRenderer ? effectsRenderer.impactSparks(this.x, this.y, options) : null;
+ },
+ selectionSparkle: (options = {}) => {
+ const effectsRenderer = (typeof window !== 'undefined') ? window.EffectsRenderer :
+ (typeof global !== 'undefined') ? global.EffectsRenderer : null;
+ return effectsRenderer ? effectsRenderer.selectionSparkle(this.x, this.y, options) : null;
+ },
+ gatheringSparkle: (options = {}) => {
+ const effectsRenderer = (typeof window !== 'undefined') ? window.EffectsRenderer :
+ (typeof global !== 'undefined') ? global.EffectsRenderer : null;
+ return effectsRenderer ? effectsRenderer.gatheringSparkle(this.x, this.y, options) : null;
+ }
+ };
+
+ // Rendering namespace
+ this.rendering = {
+ setDebugMode: (enabled) => {
+ const controller = this._controllers.get('render');
+ return controller ? controller.setDebugMode(enabled) : null;
+ },
+ setSmoothing: (enabled) => {
+ const controller = this._controllers.get('render');
+ return controller ? controller.setSmoothing(enabled) : null;
+ },
+ render: () => {
+ return this.render(); // Delegate to existing render method
+ },
+ update: () => {
+ return this.update(); // Delegate to existing update method
+ },
+ setVisible: (visible) => {
+ if (this._sprite) {
+ this._sprite.visible = visible;
+ }
+ return this;
+ },
+ isVisible: () => {
+ return this._sprite ? this._sprite.visible !== false : true;
+ },
+ setOpacity: (opacity) => {
+ if (this._sprite) {
+ this._sprite.alpha = opacity;
+ }
+ return this;
+ },
+ getOpacity: () => {
+ return this._sprite ? this._sprite.alpha : 1.0;
+ }
+ };
+
+ // Config namespace for properties
+ this.config = {
+ get debugMode() {
+ const controller = this._controllers.get('render');
+ return controller ? controller.getDebugMode() : false;
+ },
+ set debugMode(value) {
+ const controller = this._controllers.get('render');
+ if (controller && controller.setDebugMode) {
+ controller.setDebugMode(value);
+ }
+ },
+ get smoothing() {
+ const controller = this._controllers.get('render');
+ return controller ? controller.getSmoothing() : true;
+ },
+ set smoothing(value) {
+ const controller = this._controllers.get('render');
+ if (controller && controller.setSmoothing) {
+ controller.setSmoothing(value);
+ }
+ },
+ get visible() {
+ return this.rendering.isVisible();
+ },
+ set visible(value) {
+ this.rendering.setVisible(value);
+ },
+ get opacity() {
+ return this.rendering.getOpacity();
+ },
+ set opacity(value) {
+ this.rendering.setOpacity(value);
+ }
+ };
+
+ }
+
+ /**
+ * Chainable API methods for fluent interface
+ * Allows chaining like entity.chain.highlight().effect().render()
+ */
+ get chain() {
+ if (!this._chainAPI) {
+ this._chainAPI = {
+ highlight: (type = 'selected') => {
+ if (this.highlight[type]) {
+ this.highlight[type]();
+ }
+ return this._chainAPI;
+ },
+ effect: (effectType, options = {}) => {
+ this.effects.add({ type: effectType, ...options });
+ return this._chainAPI;
+ },
+ render: () => {
+ this.render();
+ return this._chainAPI;
+ },
+ update: () => {
+ this.update();
+ return this._chainAPI;
+ },
+ setPosition: (x, y) => {
+ this.setPosition(x, y);
+ return this._chainAPI;
+ },
+ setSize: (width, height) => {
+ this.setSize(width, height);
+ return this._chainAPI;
+ },
+ // End chain and return entity
+ entity: () => this
+ };
+ }
+ return this._chainAPI;
+ }
+
+ // --- Selenium Testing Getters ---
+
+ /**
+ * Get entity job name (for Selenium validation)
+ * @returns {string|null} Current job name
+ */
+ getJobName() {
+ return this._JobName || null;
+ }
+
+ /**
+ * Get entity type (for Selenium validation)
+ * @returns {string} Entity type
+ */
+ getEntityType() {
+ return this._type || 'Unknown';
+ }
+
+ /**
+ * Get entity faction (for Selenium validation)
+ * @returns {string} Entity faction
+ */
+ getFaction() {
+ return this._faction || 'neutral';
+ }
+
+ /**
+ * Get current state from state machine (for Selenium validation)
+ * @returns {string|null} Current entity state
+ */
+ getCurrentState() {
+ if (!this._stateMachine) return null;
+ return this._stateMachine.primaryState || null;
+ }
+
+ // NOTE: isSelected() method is defined earlier at line ~213 and delegates to SelectionController
+ // Removed duplicate isSelected() that was incorrectly reading _isSelected property (which is never set)
+ // The correct implementation delegates: isSelected() { return this._delegate('selection', 'isSelected') || false; }
+
+ /**
+ * Check if entity is active (for Selenium validation)
+ * @returns {boolean} True if entity is active
+ */
+ isActive() {
+ return this._isActive;
+ }
+
+ /**
+ * Get render controller validation data (for Selenium validation)
+ * @returns {Object|null} Render controller validation data
+ */
+ getRenderValidationData() {
+ const renderController = this._controllers.get('render');
+ if (!renderController || !renderController.getValidationData) return null;
+ return renderController.getValidationData();
+ }
+
+ /**
+ * Get complete entity validation data (for Selenium validation)
+ * @returns {Object} Complete validation data for testing
+ */
+ getValidationData() {
+ return {
+ id: this._id,
+ type: this.getEntityType(),
+ jobName: this.getJobName(),
+ faction: this.getFaction(),
+ currentState: this.getCurrentState(),
+ isSelected: this.isSelected(),
+ isActive: this.isActive(),
+ position: this.getPosition(),
+ size: this.getSize(),
+ hasSprite: this.hasImage(),
+ renderData: this.getRenderValidationData(),
+ controllers: Array.from(this._controllers.keys()),
+ timestamp: new Date().toISOString()
+ };
+ }
+
+ // --- Terrain Information (convenience methods) ---
+
+ /**
+ * Get current terrain type at entity position
+ * @returns {string} Current terrain modifier ("DEFAULT", "IN_WATER", "IN_MUD", "ON_SLIPPERY", "ON_ROUGH")
+ */
+ getCurrentTerrain() {
+ const terrainController = this._controllers.get('terrain');
+ return terrainController?.getCurrentTerrain() || "DEFAULT";
+ }
+
+ /**
+ * Get the underlying tile material at entity position
+ * @returns {string|null} Tile material ('grass', 'dirt', 'stone', etc.) or null if unavailable
+ */
+ getCurrentTileMaterial() {
+ const pos = this.getPosition();
+
+ // Try MapManager first (preferred)
+ if (typeof mapManager !== 'undefined' && mapManager.getActiveMap()) {
+ return mapManager.getTileMaterial(pos.x, pos.y);
+ }
+
+ // Fallback to g_activeMap for backwards compatibility
+ if (typeof g_activeMap === 'undefined' || !g_activeMap) {
+ return null;
+ }
+
+ try {
+ const tileSize = window.TILE_SIZE || 32;
+ const tileX = Math.floor(pos.x / tileSize);
+ const tileY = Math.floor(pos.y / tileSize);
+
+ const chunkX = Math.floor(tileX / g_activeMap._chunkSize);
+ const chunkY = Math.floor(tileY / g_activeMap._chunkSize);
+ const chunk = g_activeMap.chunkArray?.get?.([chunkX, chunkY]);
+
+ if (chunk) {
+ const localX = tileX - (chunkX * g_activeMap._chunkSize);
+ const localY = tileY - (chunkY * g_activeMap._chunkSize);
+ const tile = chunk.tileData?.get?.([localX, localY]);
+
+ return tile?.material || null;
+ }
+ } catch (error) {
+ console.warn("getCurrentTileMaterial error:", error);
+ }
+
+ return null;
+ }
+
+ // --- Cleanup ---
+ /** Mark entity inactive; controllers will be released for GC. */
+ destroy() {
+ // Emit entity unregistration signal BEFORE marking inactive
+ if (eventBus && this._isActive) {
+ const metadata = {};
+
+ // Add type-specific metadata
+ if (this._type === 'ant' || this._type === 'Ant' || this._type === 'Queen') {
+ metadata.jobName = this._JobName || 'Scout';
+ } else if (this._type === 'Resource') {
+ metadata.resourceType = this._resourceType || 'unknown';
+ } else if (this._type === 'Building') {
+ metadata.buildingType = this.buildingType || 'unknown';
+ }
+
+ eventBus.emit('ENTITY_UNREGISTERED', {
+ type: this._type.toLowerCase(),
+ id: this._id,
+ faction: this._faction || 'neutral',
+ metadata: metadata
+ });
+ }
+
+ this._isActive = false;
+
+ // Remove from spatial grid
+ if (typeof spatialGridManager !== 'undefined') {
+ spatialGridManager.removeEntity(this);
+ }
+ }
+}
+
+// Export for Node.js testing
+if (typeof module !== 'undefined' && module.exports) { module.exports = Entity; }
\ No newline at end of file
diff --git a/Classes/entities/stats.js b/Classes/containers/StatsContainer.js
similarity index 79%
rename from Classes/entities/stats.js
rename to Classes/containers/StatsContainer.js
index 943029e3..81d9d880 100644
--- a/Classes/entities/stats.js
+++ b/Classes/containers/StatsContainer.js
@@ -1,20 +1,20 @@
-function test_stats() {
- _stats = new stats(createVector(50,0),createVector(150,0))
+function testStats() {
+ _stats = new StatsContainer(createVector(50,0),createVector(150,0))
// _stats.test_Exp()
_stats.size.printStatToDebug()
expTotalFromAllEntities = new stat("Total World EXP")
}
-class stats {
+class StatsContainer {
constructor(pos, size, movementSpeed = 0.05, pendingPos = null, strength = 10, health = 100, gatherSpeed = 1){
this.createExpMap()
// Check if pos is a vector (has x and y properties)
if (!pos || typeof pos.x !== "number" || typeof pos.y !== "number") {
- throw new Error("stats constructor: 'pos' must be a vector with x and y properties.");
+ throw new Error("StatsContainer constructor: 'pos' must be a vector with x and y properties.");
}
if (!size || typeof size.x !== "number" || typeof size.y !== "number") {
- throw new Error("stats constructor: 'size' must be a vector with x and y properties.");
+ throw new Error("StatsContainer constructor: 'size' must be a vector with x and y properties.");
}
this.position = new stat("Position", pos)
@@ -44,8 +44,8 @@ class stats {
// EXP
// EXP is experience points, which will be used to level up ants and other entities
- // Each ant will have its own exp map, which will track the exp gained from various activities
- // The stats class will have a global exp map, which will track the exp gained from all entities in the world
+ // Each ant will have its own exp g_map, which will track the exp gained from various activities
+ // The StatsContainer class will have a global exp g_map, which will track the exp gained from all entities in the world
// maps work like dicts, but the key doesn't need to be a string or int
exp = new Map()
@@ -54,8 +54,8 @@ class stats {
getExpTotal(){ this.setExpTotal(); return this.expTotal; }
setExpTotal(){ this.expTotal = 0; for (const value of this.exp) for (const keys of Object.keys(value)){ this.expTotal += value[keys] }}
printExpTotal(){
- if (typeof devConsoleEnabled !== 'undefined' && devConsoleEnabled) {
- console.log(`Total EXP: ${this.expTotal}`);
+ if (devConsoleEnabled) {
+ logNormal(`Total EXP: ${this.expTotal}`);
}
}
@@ -71,24 +71,24 @@ class stats {
this.exp.set("Scouting",new stat("Scouting EXP")) // exp gained from an ant scouting tasks
}
- test_Map(map) {
- if (typeof devConsoleEnabled !== 'undefined' && devConsoleEnabled) {
- for (const [key, value] of map) { console.log(`${key}: ${value}`); }
+ test_Map(g_map) {
+ if (devConsoleEnabled) {
+ for (const [key, value] of g_map) { logNormal(`${key}: ${value}`); }
}
}
test_Exp() {
- if (typeof devConsoleEnabled !== 'undefined' && devConsoleEnabled) {
+ if (devConsoleEnabled) {
for (const [key, value] of this.exp) {
- console.log(`KEY: ${key}`);
+ logNormal(`KEY: ${key}`);
for (const keys of Object.keys(value)){
- console.log(`${keys}: ${value[keys]}`)
+ logNormal(`${keys}: ${value[keys]}`)
}
}
}
}
}
-// generic stat that will be used to populate all stats
+// generic stat that will be used to populate all StatsContainer
class stat {
constructor(statName="NONAME",statValue=0,statLowerLimit=0,statUpperLimit=500){
this.statName = statName;
@@ -124,21 +124,21 @@ class stat {
this.test_enforceStatLimit();
}
test_enforceStatLimit() {
- if (typeof devConsoleEnabled !== 'undefined' && devConsoleEnabled) {
+ if (devConsoleEnabled) {
if (this.statValue < this.statLowerLimit) console.error(this.statValue, this.statLowerLimit);
if (this.statValue > this.statUpperLimit) console.error(this.statValue, this.statUpperLimit);
}
}
printStatToDebug() {
- if (typeof devConsoleEnabled !== 'undefined' && devConsoleEnabled) {
+ if (devConsoleEnabled) {
for (const key of Object.keys(this)) {
let value = this[key];
// If value is a vector, format as (x, y)
if (value && typeof value === "object" && "x" in value && "y" in value) {
value = `(${value.x}, ${value.y})`;
}
- console.log(`${key}: ${value}`);
+ logNormal(`${key}: ${value}`);
}
}
}
@@ -146,7 +146,7 @@ class stat {
printStatUnderObject(pos, spriteSize, textSize) {
// pos: {x, y} - position of the object
// spriteSize: {x, y} - size of the object
- // textSize: number - font size for the text
+ // textSize: number - g_menuFont size for the text
// Format statValue if it's a vector
let valueToPrint = this.statValue;
@@ -165,13 +165,13 @@ class stat {
);
} else {
// Fallback: log to console if rendering context is unavailable
- if (typeof devConsoleEnabled !== 'undefined' && devConsoleEnabled) {
- console.log(`Print at (${pos.x}, ${pos.y + spriteSize.y + 5}): ${this.statName}: ${valueToPrint}`);
+ if (devConsoleEnabled) {
+ logNormal(`Print at (${pos.x}, ${pos.y + spriteSize.y + 5}): ${this.statName}: ${valueToPrint}`);
}
}
}
}
-if (typeof module !== "undefined" && module.exports) {
- module.exports = { stats, stat };
+if (typeof module !== 'undefined' && module.exports) {
+ module.exports = { StatsContainer, stat };
}
\ No newline at end of file
diff --git a/Classes/controllers/AntUtilities.js b/Classes/controllers/AntUtilities.js
new file mode 100644
index 00000000..fef7ee38
--- /dev/null
+++ b/Classes/controllers/AntUtilities.js
@@ -0,0 +1,853 @@
+
+
+// Expose movement functions globally for browser usage
+if (typeof window !== 'undefined') {
+ window.moveSelectedEntityToTile = moveSelectedEntityToTile;
+ window.moveSelectedEntitiesToTile = moveSelectedEntitiesToTile;
+}
+
+/**
+ * AntUtilities - Static utility methods for ant operations and group management
+ */
+class AntUtilities {
+ /**
+ * Move a single ant to tile coordinates
+ * @param {Object} ant - Ant object
+ * @param {number} tileX - Target tile X coordinate
+ * @param {number} tileY - Target tile Y coordinate
+ * @param {number} tileSize - Size of each tile
+ * @param {Object} pathMap - Pathfinding g_map object
+ */
+ static moveAntToTile(ant, tileX, tileY, tileSize = 32, pathMap = null) {
+ // Use the generic movement controller for all entity movement
+ MovementController.moveEntityToTile(ant, tileX, tileY, tileSize, pathMap);
+ }
+
+ // --- Group Movement ---
+
+ /**
+ * Move a group of ants in a circle formation
+ * @param {Array} antArray - Array of ant objects
+ * @param {number} x - Center X coordinate
+ * @param {number} y - Center Y coordinate
+ * @param {number} radius - Circle radius in pixels
+ */
+ static moveGroupInCircle(antArray, x, y, radius = 40) {
+ if (!antArray || antArray.length === 0) return;
+
+ const angleStep = (2 * Math.PI) / antArray.length;
+
+ for (let i = 0; i < antArray.length; i++) {
+ const ant = antArray[i];
+ const angle = i * angleStep;
+ const offsetX = Math.cos(angle) * radius;
+ const offsetY = Math.sin(angle) * radius;
+
+ // Move ant to position
+ if (ant.moveToLocation) {
+ ant.moveToLocation(x + offsetX, y + offsetY);
+ }
+
+ // Deselect ant
+ if (ant._selectionController) {
+ ant._selectionController.setSelected(false);
+ } else if (ant.isSelected !== undefined) {
+ ant.isSelected = false;
+ }
+ }
+ }
+
+ /**
+ * Move a group of ants in a line formation
+ * @param {Array} antArray - Array of ant objects
+ * @param {number} startX - Line start X coordinate
+ * @param {number} startY - Line start Y coordinate
+ * @param {number} endX - Line end X coordinate
+ * @param {number} endY - Line end Y coordinate
+ */
+ static moveGroupInLine(antArray, startX, startY, endX, endY) {
+ if (!antArray || antArray.length === 0) return;
+
+ const length = antArray.length;
+
+ for (let i = 0; i < length; i++) {
+ const ant = antArray[i];
+ const t = length === 1 ? 0.5 : i / (length - 1); // Normalize position along line
+
+ const x = startX + (endX - startX) * t;
+ const y = startY + (endY - startY) * t;
+
+ if (ant.moveToLocation) {
+ ant.moveToLocation(x, y);
+ }
+ }
+ }
+
+ /**
+ * Move a group of ants in a grid formation
+ * @param {Array} antArray - Array of ant objects
+ * @param {number} centerX - Grid center X coordinate
+ * @param {number} centerY - Grid center Y coordinate
+ * @param {number} spacing - Spacing between ants
+ * @param {number} maxCols - Maximum columns in grid
+ */
+ /**
+ * Move a group of ants in a grid formation using tile-based movement and pathfinding
+ * @param {Array} antArray - Array of ant objects
+ * @param {number} centerTileX - Grid center tile X coordinate
+ * @param {number} centerTileY - Grid center tile Y coordinate
+ * @param {number} tileSpacing - Spacing between ants in tiles
+ * @param {number} maxCols - Maximum columns in grid
+ * @param {number} tileSize - Size of each tile
+ * @param {Object} pathMap - Pathfinding g_map object
+ */
+ static moveGroupInGrid(antArray, centerTileX, centerTileY, tileSpacing = 1, maxCols = null, tileSize = 32, pathMap = null) {
+ if (!antArray || antArray.length === 0) return;
+ const count = antArray.length;
+ const cols = maxCols || Math.ceil(Math.sqrt(count));
+ const rows = Math.ceil(count / cols);
+ // Calculate grid start tile (top-left)
+ const gridWidth = (cols - 1) * tileSpacing;
+ const gridHeight = (rows - 1) * tileSpacing;
+ const startTileX = centerTileX - Math.floor(gridWidth / 2);
+ const startTileY = centerTileY - Math.floor(gridHeight / 2);
+ for (let i = 0; i < count; i++) {
+ const ant = antArray[i];
+ const col = i % cols;
+ const row = Math.floor(i / cols);
+ const tileX = startTileX + col * tileSpacing;
+ const tileY = startTileY + row * tileSpacing;
+ this.moveAntToTile(ant, tileX, tileY, tileSize, pathMap);
+ }
+ }
+
+ // --- Selection Utilities ---
+
+ /**
+ * Select ant under mouse cursor
+ * @param {Array} ants - Array of all ants
+ * @param {number} mouseX - Mouse X coordinate
+ * @param {number} mouseY - Mouse Y coordinate
+ * @param {boolean} clearOthers - Whether to clear other selections
+ * @returns {Object|null} Selected ant object or null
+ */
+ static selectAntUnderMouse(ants, mouseX, mouseY, clearOthers = true) {
+ if (!ants || ants.length === 0) return null;
+ let selectedAnt = null;
+
+ // Clear other selections if requested
+ if (clearOthers) {
+ this.deselectAllAnts(ants);
+ }
+
+ // Find ant under mouse (iterate backwards for top-most ant)
+ for (let i = ants.length - 1; i >= 0; i--) {
+ const ant = ants[i];
+
+ if (this.isAntUnderMouse(ant, mouseX, mouseY)) {
+ // Select this ant
+ if (ant._selectionController) {
+ ant._selectionController.setSelected(true);
+ } else if (ant.isSelected !== undefined) {
+ ant.isSelected = true;
+ }
+
+ selectedAnt = ant;
+ break;
+ }
+ }
+
+ return selectedAnt;
+ }
+
+ /**
+ * Check if ant is under mouse cursor
+ * @param {Object} ant - Ant object
+ * @param {number} mouseX - Mouse X coordinate
+ * @param {number} mouseY - Mouse Y coordinate
+ * @returns {boolean} True if ant is under mouse
+ */
+ static isAntUnderMouse(ant, mouseX, mouseY) {
+ if (!ant) return false;
+
+ // Use interaction controller if available
+ if (ant._interactionController) {
+ return ant._interactionController.isMouseOver();
+ }
+
+ // Use ant's isMouseOver method if available
+ if (ant.isMouseOver) {
+ return ant.isMouseOver(mouseX, mouseY);
+ }
+
+ // Fallback to basic bounds checking
+ const pos = ant.getPosition();
+ const size = ant.getSize();
+
+ return (
+ mouseX >= pos.x &&
+ mouseX <= pos.x + size.x &&
+ mouseY >= pos.y &&
+ mouseY <= pos.y + size.y
+ );
+ }
+
+ /**
+ * Deselect all ants
+ * @param {Array} ants - Array of all ants
+ */
+ static deselectAllAnts(ants) {
+ if (!ants) return;
+
+ for (let i = 0; i < ants.length; i++) {
+ const ant = ants[i];
+
+ if (ant._selectionController) {
+ ant._selectionController.setSelected(false);
+ } else if (ant.isSelected !== undefined) {
+ ant.isSelected = false;
+ }
+ }
+ }
+
+ /**
+ * Get all selected ants
+ * @param {Array} ants - Array of all ants
+ * @returns {Array} Array of selected ants
+ */
+ static getSelectedAnts(ants) {
+ if (!ants) return [];
+
+ const selected = [];
+
+ for (let i = 0; i < ants.length; i++) {
+ const ant = ants[i];
+
+ const isSelected = ant._selectionController ?
+ ant._selectionController.isSelected() :
+ (ant.isSelected || false);
+
+ if (isSelected) {
+ selected.push(ant);
+ }
+ }
+
+ return selected;
+ }
+
+ /**
+ * Synchronize selection between individual ant.isSelected properties and SelectionBoxController
+ * This ensures both selection systems are consistent
+ * @param {Array} ants - Array of all ants
+ */
+ static synchronizeSelections(ants) {
+ if (!ants) return;
+
+ // Get currently selected ants based on individual properties
+ const selectedAnts = this.getSelectedAnts(ants);
+
+ // Update SelectionBoxController to match
+ const controller = typeof SelectionBoxController !== 'undefined' ? SelectionBoxController.getInstance() : null;
+ if (controller) {
+ // Clear the controller's selection
+ controller.deselectAll();
+
+ // Set the controller's selected entities to match individual selections
+ if (selectedAnts.length > 0) {
+ selectedAnts.forEach(ant => {
+ ant.isSelected = true; // Ensure it's marked as selected
+ });
+
+ // Update the controller's internal selected entities array
+ if (controller._selectedEntities) {
+ controller._selectedEntities = [...selectedAnts];
+ }
+ }
+ }
+
+ // Update global selectedAnt if only one ant is selected
+ if (selectedAnts.length === 1) {
+ if (typeof selectedAnt !== 'undefined') {
+ selectedAnt = selectedAnts[0];
+ }
+ if (typeof antManager !== 'undefined' && antManager && antManager.setSelectedAnt) {
+ antManager.setSelectedAnt(selectedAnts[0]);
+ }
+ } else {
+ // Clear single selection if multiple or no ants selected
+ if (typeof selectedAnt !== 'undefined') {
+ selectedAnt = null;
+ }
+ if (typeof antManager !== 'undefined' && antManager && antManager.clearSelection) {
+ antManager.clearSelection();
+ }
+ }
+ }
+
+ // --- Pathfinding Utilities ---
+
+ /**
+ * Move selected ants to tile coordinates
+ * @param {Array} selectedAnts - Array of selected ants
+ * @param {number} tileX - Target tile X coordinate
+ * @param {number} tileY - Target tile Y coordinate
+ * @param {number} tileSize - Size of each tile
+ * @param {Object} pathMap - Pathfinding g_map object
+ */
+ static moveSelectedAntsToTile(selectedAnts, tileX, tileY, tileSize = 32, pathMap = null) {
+ if (!selectedAnts || selectedAnts.length === 0) return;
+
+ const radius = 2; // Formation radius in tiles
+ const angleStep = (2 * Math.PI) / selectedAnts.length;
+
+ for (let i = 0; i < selectedAnts.length; i++) {
+ const ant = selectedAnts[i];
+
+ // Calculate formation position
+ const angle = i * angleStep;
+ const offsetTileX = tileX + Math.round(Math.cos(angle) * radius);
+ const offsetTileY = tileY + Math.round(Math.sin(angle) * radius);
+
+ // Use pathfinding if available
+ if (pathMap && typeof findPath === 'function') {
+ try {
+ const antPos = ant.getPosition();
+ const antTileX = Math.floor(antPos.x / tileSize);
+ const antTileY = Math.floor(antPos.y / tileSize);
+
+ const grid = pathMap.getGrid();
+ // console.log("Pre")
+ const startTile = grid?.get([antTileX, antTileY]); // Should also work...
+ const endTile = grid?.get([offsetTileX, offsetTileY]);
+ // console.log("Post")
+
+ if (startTile && endTile) {
+ const path = findPath(startTile, endTile, pathMap);
+ if (path && ant.setPath) {
+ ant.setPath(path);
+ }
+ }
+ } catch (error) {
+ console.warn("Pathfinding failed for ant:", error);
+ // Fallback to direct movement
+ //this.moveAntDirectly(ant, offsetTileX * tileSize, offsetTileY * tileSize);
+ }
+ } else {
+ // Direct movement fallback
+ //this.moveAntDirectly(ant, offsetTileX * tileSize, offsetTileY * tileSize);
+ }
+
+ // Deselect ant after movement command
+ if (ant._selectionController) {
+ ant._selectionController.setSelected(false);
+ } else if (ant.isSelected !== undefined) {
+ ant.isSelected = false;
+ }
+ }
+ }
+
+ /**
+ * Move ant directly to coordinates
+ * @param {Object} ant - Ant object
+ * @param {number} x - Target X coordinate
+ * @param {number} y - Target Y coordinate
+ */
+ static moveAntDirectly(ant, x, y) {
+ if (ant.moveToLocation) {
+ ant.moveToLocation(x, y);
+ } else if (ant._movementController) {
+ ant._movementController.moveToLocation(x, y);
+ }
+ }
+
+ // --- Spawning Functions ---
+
+ /**
+ * Spawn ant with specific job, faction, and optional custom image
+ * @param {number} x - Spawn X coordinate
+ * @param {number} y - Spawn Y coordinate
+ * @param {string} jobName - Job type from JobComponent
+ * @param {string} faction - Faction name (red, blue, neutral)
+ * @param {Object} customImage - Optional custom image (uses job default if null)
+ * @returns {Object} Spawned ant object
+ */
+ static spawnAnt(x, y, jobName = "Scout", faction = "player", customImage = null) {
+ if (typeof JobComponent === 'undefined') {
+ console.warn('JobComponent not available for spawning');
+ return null;
+ }
+
+ // Validate job name
+ const availableJobs = JobComponent.getAllJobs();
+ if (!availableJobs.includes(jobName)) {
+ console.warn(`Invalid job name: ${jobName}. Using Scout.`);
+ jobName = "Scout";
+ }
+
+ // Validate faction
+ const validFactions = ["red", "blue", "neutral", "player", "enemy"];
+ if (!validFactions.includes(faction)) {
+ console.warn(`Invalid faction: ${faction}. Using neutral.`);
+ faction = "neutral";
+ }
+
+ // Determine image to use
+ let imageToUse = customImage;
+ if (!imageToUse && typeof JobImages !== 'undefined') {
+ imageToUse = JobImages[jobName] || JobImages["Scout"];
+ }
+ if (!imageToUse && typeof antBaseSprite !== 'undefined') {
+ imageToUse = antBaseSprite;
+ }
+
+ try {
+ // Create ant using existing ant constructor
+ const newAnt = new ant(
+ x, y,
+ 20, 20, // Default size
+ 30, 0, // Movement speed, rotation
+ imageToUse,
+ jobName,
+ faction
+ );
+
+ // Assign job using component system
+ newAnt.assignJob(jobName, imageToUse);
+
+ // Add to global ants array if it exists
+ if (ants && Array.isArray(ants)) {
+ ants.push(newAnt);
+ }
+
+ // Register with TileInteractionManager if available
+ if (g_tileInteractionManager) {
+ g_tileInteractionManager.addObject(newAnt, 'ant');
+ }
+
+ // Update UI Selection Box entities
+ if (updateUISelectionEntities) {
+ updateUISelectionEntities();
+ }
+
+ if (typeof selectables !== 'undefined' && Array.isArray(selectables)) {
+ if (!selectables.includes(newAnt)) selectables.push(newAnt);
+ }
+ // Ensure selection controller uses selectables reference (some controllers snapshot list)
+ if (typeof g_selectionBoxController !== 'undefined' && g_selectionBoxController) {
+ if (g_selectionBoxController.entities) g_selectionBoxController.entities = selectables;
+ }
+
+ return newAnt;
+ } catch (error) {
+ console.error('Error spawning ant:', error);
+ return null;
+ }
+ }
+
+ /**
+ * Spawn multiple ants of the same type
+ * @param {number} count - Number of ants to spawn
+ * @param {string} jobName - Job type
+ * @param {string} faction - Faction name
+ * @param {number} centerX - Center X for formation
+ * @param {number} centerY - Center Y for formation
+ * @param {number} radius - Spawn radius
+ * @returns {Array} Array of spawned ants
+ */
+ static spawnMultipleAnts(count, jobName = "Scout", faction = "neutral", centerX = 400, centerY = 400, radius = 50) {
+ const spawnedAnts = [];
+ const angleStep = (2 * Math.PI) / count;
+
+ for (let i = 0; i < count; i++) {
+ const angle = i * angleStep;
+ const spawnX = centerX + Math.cos(angle) * radius;
+ const spawnY = centerY + Math.sin(angle) * radius;
+
+ const ant = this.spawnAnt(spawnX, spawnY, jobName, faction);
+ if (ant) {
+ spawnedAnts.push(ant);
+ }
+ }
+
+ return spawnedAnts;
+ }
+
+ // --- State Management Functions ---
+
+ /**
+ * Change state of all selected ants
+ * @param {Array} ants - Array of all ants
+ * @param {string} primaryState - New primary state
+ * @param {string} combatModifier - Optional combat modifier
+ * @param {string} terrainModifier - Optional terrain modifier
+ */
+ static changeSelectedAntsState(ants, primaryState, combatModifier = null, terrainModifier = null) {
+ const selectedAnts = this.getSelectedAnts(ants);
+
+ if (selectedAnts.length === 0) {
+ logNormal('No ants selected for state change');
+ return;
+ }
+
+ let changedCount = 0;
+ for (const ant of selectedAnts) {
+ if (ant._stateMachine && typeof ant._stateMachine.setState === 'function') {
+ const success = ant._stateMachine.setState(primaryState, combatModifier, terrainModifier);
+ if (success) {
+ changedCount++;
+ }
+ }
+ }
+
+ logNormal(`Changed state of ${changedCount} ants to ${primaryState}`);
+
+ // Synchronize selection systems after state change
+ this.synchronizeSelections(ants);
+ }
+
+ /**
+ * Set all selected ants to IDLE state
+ * @param {Array} ants - Array of all ants
+ */
+ static setSelectedAntsIdle(ants) {
+ this.changeSelectedAntsState(ants, "IDLE", "OUT_OF_COMBAT", "DEFAULT");
+ }
+
+ /**
+ * Set all selected ants to GATHERING state
+ * @param {Array} ants - Array of all ants
+ */
+ static setSelectedAntsGathering(ants) {
+ this.changeSelectedAntsState(ants, "GATHERING", "OUT_OF_COMBAT", "DEFAULT");
+ }
+
+ /**
+ * Set all selected ants to PATROL state
+ * @param {Array} ants - Array of all ants
+ */
+ static setSelectedAntsPatrol(ants) {
+ this.changeSelectedAntsState(ants, "PATROL", "OUT_OF_COMBAT", "DEFAULT");
+ }
+
+ /**
+ * Set all selected ants to combat state
+ * @param {Array} ants - Array of all ants
+ */
+ static setSelectedAntsCombat(ants) {
+ this.changeSelectedAntsState(ants, "MOVING", "IN_COMBAT", "DEFAULT");
+ }
+
+ /**
+ * Set all selected ants to BUILDING state
+ * @param {Array} ants - Array of all ants
+ */
+ static setSelectedAntsBuilding(ants) {
+ this.changeSelectedAntsState(ants, "BUILDING", "OUT_OF_COMBAT", "DEFAULT");
+ }
+
+ /**
+ * Set selected ants to GATHERING state for autonomous resource collection
+ * @param {Array} ants - Array of all ants
+ * @returns {number} Number of ants set to gathering state
+ */
+ static setSelectedAntsGathering(ants) {
+ const selected = this.getSelectedAnts(ants);
+ let gatheringCount = 0;
+
+ selected.forEach(ant => {
+ if (ant._stateMachine && ant._stateMachine.canPerformAction('gather')) {
+ ant._stateMachine.setPrimaryState('GATHERING');
+ gatheringCount++;
+ }
+ });
+
+ logNormal(`🔍 Set ${gatheringCount} ants to GATHERING state (7-grid radius)`);
+ this.synchronizeSelections(ants);
+ return gatheringCount;
+ }
+
+ /**
+ * Get ants currently in gathering state
+ * @param {Array} ants - Array of all ants
+ * @returns {Array} Array of ants in gathering state
+ */
+ static getGatheringAnts(ants) {
+ if (!ants) return [];
+
+ return ants.filter(ant => {
+ return ant && ant._stateMachine && ant._stateMachine.isGathering && ant._stateMachine.isGathering();
+ });
+ }
+
+ /**
+ * Stop gathering for selected ants (return to idle)
+ * @param {Array} ants - Array of all ants
+ * @returns {number} Number of ants stopped from gathering
+ */
+ static stopSelectedAntsGathering(ants) {
+ const selected = this.getSelectedAnts(ants);
+ let stoppedCount = 0;
+
+ selected.forEach(ant => {
+ if (ant._stateMachine && ant._stateMachine.isGathering && ant._stateMachine.isGathering()) {
+ ant._stateMachine.setPrimaryState('IDLE');
+ stoppedCount++;
+ }
+ });
+
+ logNormal(`⏹️ Stopped ${stoppedCount} ants from gathering`);
+ this.synchronizeSelections(ants);
+ return stoppedCount;
+ }
+
+ // --- Utility Functions ---
+
+ /**
+ * Get distance between two points
+ * @param {number} x1 - First point X
+ * @param {number} y1 - First point Y
+ * @param {number} x2 - Second point X
+ * @param {number} y2 - Second point Y
+ * @returns {number} Distance in pixels
+ */
+ static getDistance(x1, y1, x2, y2) {
+ const dx = x2 - x1;
+ const dy = y2 - y1;
+ return Math.sqrt(dx * dx + dy * dy);
+ }
+
+ /**
+ * Get ants within radius of position
+ * @param {Array} ants - Array of all ants
+ * @param {number} centerX - Center X coordinate
+ * @param {number} centerY - Center Y coordinate
+ * @param {number} radius - Search radius
+ * @returns {Array} Array of ants within radius
+ */
+ static getAntsInRadius(ants, centerX, centerY, radius) {
+ if (!ants) return [];
+
+ const nearbyAnts = [];
+
+ for (let i = 0; i < ants.length; i++) {
+ const ant = ants[i];
+
+ const pos = ant.getPosition ? ant.getPosition() :
+ ant.getPosition();
+
+ const distance = this.getDistance(centerX, centerY, pos.x, pos.y);
+
+ if (distance <= radius) {
+ nearbyAnts.push(ant);
+ }
+ }
+
+ return nearbyAnts;
+ }
+
+ /**
+ * Get ants of specific faction
+ * @param {Array} ants - Array of all ants
+ * @param {string} faction - Faction name
+ * @returns {Array} Array of ants in faction
+ */
+ static getAntsByFaction(ants, faction) {
+ if (!ants) return [];
+
+ const factionAnts = [];
+
+ for (let i = 0; i < ants.length; i++) {
+ const ant = ants[i];
+
+ if (ant.faction === faction) {
+ factionAnts.push(ant);
+ }
+ }
+
+ return factionAnts;
+ }
+
+ /**
+ * Get performance statistics for ant operations
+ * @param {Array} ants - Array of all ants
+ * @returns {Object} Performance statistics
+ */
+ static getPerformanceStats(ants) {
+ if (!ants) return { totalAnts: 0 };
+
+ let totalAnts = 0;
+ let selectedCount = 0;
+ let movingCount = 0;
+ let combatCount = 0;
+
+ for (let i = 0; i < ants.length; i++) {
+ const ant = ants[i];
+
+ if (ant) {
+ totalAnts++;
+
+ // Count selected
+ const isSelected = ant._selectionController ?
+ ant._selectionController.isSelected() :
+ (ant.isSelected || false);
+ if (isSelected) selectedCount++;
+
+ // Count moving
+ const isMoving = ant._movementController ?
+ ant._movementController.getIsMoving() :
+ (ant.isMoving || false);
+ if (isMoving) movingCount++;
+
+ // Count in combat
+ const inCombat = ant._combatController ?
+ ant._combatController.isInCombat() :
+ (ant.isInCombat && ant.isInCombat());
+ if (inCombat) combatCount++;
+ }
+ }
+
+ return {
+ totalAnts,
+ selectedCount,
+ movingCount,
+ combatCount,
+ idleCount: totalAnts - movingCount - combatCount
+ };
+ }
+}
+
+
+
+function antLoopPropertyCheck(property) {
+ for (let i = 0; i < antIndex; i++) {
+ if (!ants[i]) continue;
+ return ants[i][property];
+ }
+ IncorrectParamPassed("Boolean", property);
+}
+
+// --- Move Selected Ant to Tile ---
+// --- Generic moveSelectedEntityToTile ---
+function moveSelectedEntityToTile(mx, my, tileSize) {
+ let selectedEntity = null;
+ let useMultiSelection = false;
+
+ // First, check SelectionBoxController's selectedEntities (for drag selection and button selection)
+ const controller = typeof SelectionBoxController !== 'undefined' ? SelectionBoxController.getInstance() : null;
+ const selectedEntities = controller ? controller.getSelectedEntities() : [];
+
+ if (selectedEntities && selectedEntities.length > 0) {
+ // If multiple entities selected, use multi-selection movement
+ if (selectedEntities.length > 1) {
+ moveSelectedEntitiesToTile(mx, my, tileSize);
+ return;
+ } else {
+ // Single entity in multi-selection system
+ selectedEntity = selectedEntities[0];
+ useMultiSelection = true;
+ }
+ }
+
+ // Fallback to global selectedAnt (for individual mouse click selection)
+ if (!selectedEntity && typeof selectedAnt !== 'undefined' && selectedAnt) {
+ selectedEntity = selectedAnt;
+ useMultiSelection = false;
+ }
+
+ // If still no selection found, check if antManager exists
+ if (!selectedEntity && typeof antManager !== 'undefined' && antManager && antManager.getSelectedAnt) {
+ selectedEntity = antManager.getSelectedAnt();
+ useMultiSelection = false;
+ }
+
+ // No selected entity found
+ if (!selectedEntity) {
+ return;
+ }
+
+ // Move the entity
+ const tileX = Math.floor(mx / tileSize);
+ const tileY = Math.floor(my / tileSize);
+
+ if (typeof MovementController !== 'undefined' && MovementController.moveEntityToTile) {
+ MovementController.moveEntityToTile(selectedEntity, tileX, tileY, tileSize, g_gridMap);
+ } else {
+ // Fallback to direct movement
+ AntUtilities.moveAntDirectly(selectedEntity, mx, my);
+ }
+
+ // Deselect based on which system was used
+ if (useMultiSelection) {
+ selectedEntity.isSelected = false;
+ if (controller) controller.deselectAll();
+ } else {
+ selectedEntity.isSelected = false;
+ if (typeof selectedAnt !== 'undefined') {
+ selectedAnt = null;
+ }
+ if (typeof antManager !== 'undefined' && antManager && antManager.clearSelection) {
+ antManager.clearSelection();
+ }
+ }
+}
+
+function moveSelectedEntitiesToTile(mx, my, tileSize) {
+ // Use SelectionBoxController's selectedEntities
+ const controller = typeof SelectionBoxController !== 'undefined' ? SelectionBoxController.getInstance() : null;
+ const selectedEntities = controller ? controller.getSelectedEntities() : [];
+ if (!selectedEntities || selectedEntities.length === 0) {
+ return;
+ }
+
+ const tileX = Math.floor(mx / tileSize);
+ const tileY = Math.floor(my / tileSize);
+ const grid = g_gridMap.getGrid();
+
+ const radius = 2; // in tiles
+ const angleStep = (2 * Math.PI) / selectedEntities.length;
+
+ for (let i = 0; i < selectedEntities.length; i++) {
+ let entity = selectedEntities[i];
+ // Now working with direct ant objects - no unwrapping needed
+
+ // assign each entity its own destination tile around the click
+ const angle = i * angleStep;
+ const offsetTileX = tileX + Math.round(Math.cos(angle) * radius);
+ const offsetTileY = tileY + Math.round(Math.sin(angle) * radius);
+
+ // Use robust property access
+ let entityCenterX, entityCenterY;
+ if (typeof entity.getPosition === 'function' && typeof entity.getSize === 'function') {
+ const pos = entity.getPosition();
+ const size = entity.getSize();
+ entityCenterX = pos.x + size.x / 2;
+ entityCenterY = pos.y + size.y / 2;
+ } else {
+ continue;
+ }
+ const entityX = Math.floor(entityCenterX / tileSize);
+ const entityY = Math.floor(entityCenterY / tileSize);
+
+ // PRIMARY OFFENDER: PATHFINDING CALLS FIXED...
+ // console.log("Pre")
+ console.log(entityX,entityY,offsetTileX,offsetTileY)
+ const startTile = grid.get([entityX, entityY]);
+ const endTile = grid.get([offsetTileX, offsetTileY]);
+ // console.log("Post")
+
+ if (startTile && endTile) {
+ const newPath = findPath(startTile, endTile, g_gridMap);
+ if (typeof entity.setPath === 'function') {
+ entity.setPath(newPath);
+ }
+ }
+ entity.isSelected = false;
+ }
+ // Deselect all after issuing movement
+ if (controller) controller.deselectAll();
+}
+
+// Export for Node.js testing
+if (typeof module !== 'undefined' && module.exports) {
+ module.exports = AntUtilities;
+}
\ No newline at end of file
diff --git a/Classes/controllers/CameraController.js b/Classes/controllers/CameraController.js
new file mode 100644
index 00000000..ea933627
--- /dev/null
+++ b/Classes/controllers/CameraController.js
@@ -0,0 +1,209 @@
+/**
+ * CameraController - Global camera system for handling viewport movement and mouse coordinate compensation
+ *
+ * This controller provides:
+ * - Camera position management
+ * - Mouse coordinate conversion between screen and world space
+ * - Global utilities for camera-aware interactions
+ *
+ * Usage:
+ * CameraController.setCameraPosition(x, y);
+ * const worldPos = CameraController.getWorldMouse();
+ * const screenPos = CameraController.worldToScreen(worldX, worldY);
+ */
+
+// Initialize camera position variables globally
+if (typeof window !== 'undefined') {
+ if (typeof window.cameraX === 'undefined') window.cameraX = 0;
+ if (typeof window.cameraY === 'undefined') window.cameraY = 0;
+}
+
+class CameraController {
+ /**
+ * Get camera-compensated mouse X coordinate
+ * @returns {number} Mouse X position adjusted for camera offset
+ */
+ static getWorldMouseX() {
+ return (typeof mouseX !== 'undefined' ? mouseX : 0) + (typeof cameraX !== 'undefined' ? cameraX : 0);
+ }
+
+ /**
+ * Get camera-compensated mouse Y coordinate
+ * @returns {number} Mouse Y position adjusted for camera offset
+ */
+ static getWorldMouseY() {
+ return (typeof mouseY !== 'undefined' ? mouseY : 0) + (typeof cameraY !== 'undefined' ? cameraY : 0);
+ }
+
+ /**
+ * Get camera-compensated mouse coordinates as an object
+ * @returns {Object} Object with worldX, worldY, screenX, and screenY properties
+ */
+ static getWorldMouse() {
+ return {
+ worldX: this.getWorldMouseX(),
+ worldY: this.getWorldMouseY(),
+ screenX: typeof mouseX !== 'undefined' ? mouseX : 0,
+ screenY: typeof mouseY !== 'undefined' ? mouseY : 0
+ };
+ }
+
+ /**
+ * Convert screen coordinates to world coordinates
+ * @param {number} screenX - Screen X coordinate
+ * @param {number} screenY - Screen Y coordinate
+ * @returns {Object} Object with worldX and worldY properties
+ */
+ static screenToWorld(screenX, screenY) {
+ return {
+ worldX: screenX + (typeof cameraX !== 'undefined' ? cameraX : 0),
+ worldY: screenY + (typeof cameraY !== 'undefined' ? cameraY : 0)
+ };
+ }
+
+ /**
+ * Convert world coordinates to screen coordinates
+ * @param {number} worldX - World X coordinate
+ * @param {number} worldY - World Y coordinate
+ * @returns {Object} Object with screenX and screenY properties
+ */
+ static worldToScreen(worldX, worldY) {
+ return {
+ screenX: worldX - (typeof cameraX !== 'undefined' ? cameraX : 0),
+ screenY: worldY - (typeof cameraY !== 'undefined' ? cameraY : 0)
+ };
+ }
+
+ /**
+ * Set camera position
+ * @param {number} x - Camera X position
+ * @param {number} y - Camera Y position
+ */
+ static setCameraPosition(x, y) {
+ if (typeof window !== 'undefined') {
+ window.cameraX = x;
+ window.cameraY = y;
+ }
+ if (typeof globalThis !== 'undefined') {
+ globalThis.cameraX = x;
+ globalThis.cameraY = y;
+ }
+ }
+
+ /**
+ * Move camera by relative offset
+ * @param {number} deltaX - Change in X position
+ * @param {number} deltaY - Change in Y position
+ */
+ static moveCameraBy(deltaX, deltaY) {
+ const currentX = typeof cameraX !== 'undefined' ? cameraX : 0;
+ const currentY = typeof cameraY !== 'undefined' ? cameraY : 0;
+ this.setCameraPosition(currentX + deltaX, currentY + deltaY);
+ }
+
+ /**
+ * Get current camera position
+ * @returns {Object} Object with x and y properties
+ */
+ static getCameraPosition() {
+ return {
+ x: typeof cameraX !== 'undefined' ? cameraX : 0,
+ y: typeof cameraY !== 'undefined' ? cameraY : 0
+ };
+ }
+
+ /**
+ * Center camera on a specific world position
+ * @param {number} worldX - World X coordinate to center on
+ * @param {number} worldY - World Y coordinate to center on
+ */
+ static centerCameraOn(worldX, worldY) {
+ // Center the camera so the given world position is in the middle of the screen
+ // Camera position is top-left corner, so subtract half the canvas dimensions
+ const canvasWidth = typeof g_canvasX !== 'undefined' ? g_canvasX : 800;
+ const canvasHeight = typeof g_canvasY !== 'undefined' ? g_canvasY : 800;
+
+ this.setCameraPosition(
+ worldX - (canvasWidth / 2),
+ worldY - (canvasHeight / 2)
+ );
+ }
+
+ /**
+ * Get the visible world bounds based on current camera position
+ * @returns {Object} Object with left, right, top, bottom properties
+ */
+ static getVisibleBounds() {
+ const canvasWidth = typeof g_canvasX !== 'undefined' ? g_canvasX : 800;
+ const canvasHeight = typeof g_canvasY !== 'undefined' ? g_canvasY : 800;
+ const camera = this.getCameraPosition();
+
+ return {
+ left: camera.x,
+ right: camera.x + canvasWidth,
+ top: camera.y,
+ bottom: camera.y + canvasHeight
+ };
+ }
+
+ /**
+ * Check if a world position is visible on screen
+ * @param {number} worldX - World X coordinate
+ * @param {number} worldY - World Y coordinate
+ * @returns {boolean} True if position is visible
+ */
+ static isPositionVisible(worldX, worldY) {
+ const bounds = this.getVisibleBounds();
+ return worldX >= bounds.left && worldX <= bounds.right &&
+ worldY >= bounds.top && worldY <= bounds.bottom;
+ }
+}
+
+// Camera functions have been moved to CameraManager.js
+// Use cameraManager.methodName() instead of these functions:
+
+function screenToWorld(px = mouseX, py = mouseY) {
+ return cameraManager ? cameraManager.screenToWorld(px, py) : { worldX: px, worldY: py };
+}
+
+function getWorldMousePosition(px = mouseX, py = mouseY) {
+ return cameraManager ? cameraManager.screenToWorld(px, py) : { worldX: px, worldY: py };
+}
+
+function worldToScreen(worldX, worldY) {
+ return cameraManager ? cameraManager.worldToScreen(worldX, worldY) : { screenX: worldX, screenY: worldY };
+}
+
+function setCameraZoom(targetZoom, focusX, focusY) {
+ return cameraManager ? cameraManager.setZoom(targetZoom, focusX, focusY) : false;
+}
+
+function centerCameraOn(worldX, worldY) {
+ if (cameraManager) cameraManager.centerOn(worldX, worldY);
+}
+
+function centerCameraOnEntity(entity) {
+ if (cameraManager) cameraManager.centerOnEntity(entity);
+}
+
+function toggleCameraFollow() {
+ if (cameraManager) cameraManager.toggleFollow();
+}
+
+// Expose camera controller and utilities globally
+if (typeof window !== 'undefined') {
+ window.CameraController = CameraController;
+
+ // Convenient global functions for common operations
+ window.getWorldMouseX = () => CameraController.getWorldMouseX();
+ window.getWorldMouseY = () => CameraController.getWorldMouseY();
+ window.getWorldMouse = () => CameraController.getWorldMouse();
+ window.screenToWorld = (screenX, screenY) => CameraController.screenToWorld(screenX, screenY);
+ window.worldToScreen = (worldX, worldY) => CameraController.worldToScreen(worldX, worldY);
+ window.setCameraPosition = (x, y) => CameraController.setCameraPosition(x, y);
+ window.moveCameraBy = (deltaX, deltaY) => CameraController.moveCameraBy(deltaX, deltaY);
+ window.getCameraPosition = () => CameraController.getCameraPosition();
+ window.centerCameraOn = (worldX, worldY) => CameraController.centerCameraOn(worldX, worldY);
+ window.getVisibleBounds = () => CameraController.getVisibleBounds();
+ window.isPositionVisible = (worldX, worldY) => CameraController.isPositionVisible(worldX, worldY);
+}
\ No newline at end of file
diff --git a/Classes/controllers/CameraManager.js b/Classes/controllers/CameraManager.js
new file mode 100644
index 00000000..9d5a55a8
--- /dev/null
+++ b/Classes/controllers/CameraManager.js
@@ -0,0 +1,828 @@
+/**
+ * CameraManager - Unified camera management system for the ant game
+ *
+ * This class consolidates all camera functionality including:
+ * - Camera position and zoom management
+ * - Input handling (arrow keys for camera, WASD for ants)
+ * - Coordinate transformations (screen to world, world to screen)
+ * - Camera following and bounds clamping
+ * - Integration with existing CameraController utilities
+ *
+ * Usage:
+ * const cameraManager = new CameraManager();
+ * cameraManager.initialize();
+ * cameraManager.update(); // Call in draw loop
+ * cameraManager.applyTransform(); // Apply camera transform for rendering
+ */
+
+class CameraManager {
+ constructor() {
+ // Camera position and zoom
+ // Don't rely on global canvas values at construction time — they may not be set yet.
+ // We'll set a safe default here and compute the real center in initialize().
+ this.cameraX = 0;
+ this.cameraY = 0;
+ this.canvasWidth = (typeof g_canvasX !== 'undefined') ? g_canvasX : 800;
+ this.canvasHeight = (typeof g_canvasY !== 'undefined') ? g_canvasY : 600;
+ this.cameraZoom = 1;
+ this.cameraPanSpeed = 600; // Increased from 10 to 600 for framerate-independent movement
+
+ // Camera constraints (state-aware: PLAYING uses 1.0, LEVEL_EDITOR uses 0.5)
+ this.MIN_CAMERA_ZOOM_PLAYING = 1.0; // PLAYING state minimum zoom
+ this.MIN_CAMERA_ZOOM_EDITOR = 0.5; // LEVEL_EDITOR state minimum zoom
+ this.MAX_CAMERA_ZOOM = 3;
+ this.CAMERA_ZOOM_STEP = 1.1;
+
+ // Camera following
+ this.cameraFollowEnabled = false;
+ this.cameraFollowTarget = null;
+
+ // Camera toggles
+ this.cameraOutlineToggle = false;
+
+ // Level-specific bounds (null = use current map, or set custom bounds for level)
+ this.customBounds = null; // { width: number, height: number }
+ this.currentLevel = null; // Reference to current level map (defaults to g_activeMap)
+ }
+
+ /**
+ * Initialize the camera manager
+ * Should be called once in setup()
+ */
+ initialize() {
+ // Ensure we have up-to-date canvas dimensions
+ this.canvasWidth = (typeof g_canvasX !== 'undefined') ? g_canvasX : this.canvasWidth || 800;
+ this.canvasHeight = (typeof g_canvasY !== 'undefined') ? g_canvasY : this.canvasHeight || 600;
+
+ // Compute an initial camera position based on available data.
+ // Prefer an existing CameraController position if present; otherwise center on the canvas.
+ if (typeof CameraController !== 'undefined' && typeof CameraController.getCameraPosition === 'function') {
+ const ccPos = CameraController.getCameraPosition();
+ if (ccPos && typeof ccPos.x === 'number' && typeof ccPos.y === 'number') {
+ this.cameraX = ccPos.x;
+ this.cameraY = ccPos.y;
+ } else {
+ // If map dimensions are available, center the view on the full map (top-left camera coords)
+ if (typeof getMapPixelDimensions === 'function') {
+ const dims = getMapPixelDimensions();
+ if (dims && dims.width > 0 && dims.height > 0) {
+ const viewWidth = this.canvasWidth / this.cameraZoom;
+ const viewHeight = this.canvasHeight / this.cameraZoom;
+ this.cameraX = (dims.width - viewWidth) / 2;
+ this.cameraY = (dims.height - viewHeight) / 2;
+ } else {
+ this.cameraX = this.canvasWidth / 2;
+ this.cameraY = this.canvasHeight / 2;
+ }
+ } else {
+ this.cameraX = this.canvasWidth / 2;
+ this.cameraY = this.canvasHeight / 2;
+ }
+ }
+ // Sync CameraController to our computed values to ensure a single source of truth
+ CameraController.setCameraPosition(this.cameraX, this.cameraY);
+ } else {
+ // No CameraController yet - center locally and wait for an available controller later
+ this.cameraX = this.cameraX || (this.canvasWidth / 2);
+ this.cameraY = this.cameraY || (this.canvasHeight / 2);
+ }
+
+ // Clamp to bounds if map dimensions are available (safe-guarded inside clampToBounds)
+ try { this.clampToBounds(); } catch (e) { /* ignore if clamp depends on uninitialized systems */ }
+
+ logVerbose('CameraManager initialized', { cameraX: this.cameraX, cameraY: this.cameraY, canvasWidth: this.canvasWidth, canvasHeight: this.canvasHeight });
+
+ // If the terrain exists at initialization time, sync its camera position so the render
+ // converter and CameraManager agree. Convert camera pixel center to tile coordinates.
+ if (typeof g_activeMap !== 'undefined' && g_activeMap && typeof g_activeMap.setCameraPosition === 'function') {
+ const viewCenterX = this.cameraX + (this.canvasWidth / (2 * this.cameraZoom));
+ const viewCenterY = this.cameraY + (this.canvasHeight / (2 * this.cameraZoom));
+ const centerTilePos = [ viewCenterX / TILE_SIZE, viewCenterY / TILE_SIZE ];
+ try { g_activeMap.setCameraPosition(centerTilePos); } catch (e) { /* ignore */ }
+ }
+ }
+
+ /**
+ * Update camera position based on input and following logic
+ * Should be called every frame in the game loop
+ */
+ update() {
+ // Allow camera updates in both normal game and Level Editor
+ const isLevelEditor = (typeof GameState !== 'undefined' && GameState.getState() === 'LEVEL_EDITOR');
+ const isInGame = this.isInGame();
+
+ if (!isInGame && !isLevelEditor) return;
+
+ this.drawCameraBounds();
+ // Update canvas dimensions in case of window resize
+ if (typeof g_canvasX !== 'undefined') this.canvasWidth = g_canvasX;
+ if (typeof g_canvasY !== 'undefined') this.canvasHeight = g_canvasY;
+
+ // Check for manual camera input (arrow keys only)
+ const left = keyIsDown(LEFT_ARROW);
+ const right = keyIsDown(RIGHT_ARROW);
+ const up = keyIsDown(UP_ARROW);
+ const down = keyIsDown(DOWN_ARROW);
+ const manualInput = left || right || up || down;
+
+ if (manualInput) {
+ // Disable camera following when manually controlling camera
+ if (this.cameraFollowEnabled) {
+ this.cameraFollowEnabled = false;
+ this.cameraFollowTarget = null;
+ }
+
+ // Use deltaTime for framerate-independent panning
+ // p5.js deltaTime is in milliseconds, convert to seconds
+ const dt = (typeof window.deltaTime !== 'undefined' && window.deltaTime > 0 ? window.deltaTime : 16.67) / 1000.0;
+ const panStep = this.cameraPanSpeed * dt / this.cameraZoom; // Direct multiplication, no need for *60
+
+ // Move camera with arrow keys using CameraController
+ if (left && typeof CameraController !== 'undefined') CameraController.moveCameraBy(-panStep, 0);
+ if (right && typeof CameraController !== 'undefined') CameraController.moveCameraBy(panStep, 0);
+ if (up && typeof CameraController !== 'undefined') CameraController.moveCameraBy(0, -panStep);
+ if (down && typeof CameraController !== 'undefined') CameraController.moveCameraBy(0, panStep);
+
+ // Update local variables from CameraController
+ if (typeof CameraController !== 'undefined') {
+ const pos = CameraController.getCameraPosition();
+ this.cameraX = pos.x;
+ this.cameraY = pos.y;
+ }
+ this.clampToBounds();
+
+ } else if (this.cameraFollowEnabled) {
+ // Handle camera following logic
+ const primary = this.getPrimarySelectedEntity();
+ const target = primary || this.cameraFollowTarget;
+ if (target) {
+ this.cameraFollowTarget = target;
+ this.centerOnEntity(target);
+ } else {
+ this.cameraFollowEnabled = false;
+ this.cameraFollowTarget = null;
+ }
+ }
+ // compute view center in world pixels, account for zoom
+ const viewCenterX = this.cameraX + (g_canvasX / (2 * this.cameraZoom));
+ const viewCenterY = this.cameraY + (g_canvasY / (2 * this.cameraZoom));
+
+ // convert to tile/world coordinates expected by gridTerrain (array of #[tileX, tileY])
+ const centerTilePos = [ viewCenterX / TILE_SIZE, viewCenterY / TILE_SIZE ];
+
+ // pass a plain array, not a p5.Vector
+ if (typeof g_activeMap !== 'undefined' && g_activeMap && typeof g_activeMap.setCameraPosition === 'function') {
+ g_activeMap.setCameraPosition(centerTilePos);
+ }
+}
+
+ /**
+ * Draws a rect around the border of what the camera is able to see, should be just outside the range
+ * of the canvas at any time. This is for debugging to make sure the camera and the world map
+ * are still in snyc
+ */
+ drawCameraBounds(){
+ if (this.cameraOutlineToggle) {
+ rectCustom( color(0,0,255,100), color(0,0,255,100),
+ 30, // strokeWidth
+ createVector(this.cameraX, this.cameraY), // pos
+ createVector(this.canvasWidth, this.canvasHeight),// size
+ false, // shouldFill
+ true, // shouldStroke
+ );}
+ }
+
+ /**
+ * Toggles the cameraBounds outline, needs to be assigned to a keypress/button
+ */
+ toggleOutline() { this.cameraOutlineToggle = !this.cameraOutlineToggle }
+
+ /**
+ * Apply camera transformation for rendering
+ * Call this before rendering world objects
+ */
+ applyTransform() {
+ push();
+
+ // Apply camera transformation using CameraController position
+ const cameraPos = typeof CameraController !== 'undefined'
+ ? CameraController.getCameraPosition()
+ : { x: this.cameraX, y: this.cameraY };
+
+ // IMPORTANT: Order matters! Translate first, then scale
+ // This way scaling happens around the translated origin, not the screen origin
+ translate(-cameraPos.x, -cameraPos.y);
+ scale(this.cameraZoom);
+ }
+
+ /**
+ * Restore transformation after rendering
+ * Call this after rendering world objects
+ */
+ restoreTransform() {
+ pop();
+ }
+
+ /**
+ * Get the appropriate minimum zoom based on current game state
+ * @returns {number} Minimum zoom level
+ */
+ getMinZoom() {
+ // Check if we're in Level Editor mode
+ const isLevelEditor = (typeof window !== 'undefined' && window.GameState)
+ ? window.GameState.getState() === 'LEVEL_EDITOR'
+ : false;
+
+ return isLevelEditor ? this.MIN_CAMERA_ZOOM_EDITOR : this.MIN_CAMERA_ZOOM_PLAYING;
+ }
+
+ /**
+ * Set camera zoom level with focus point
+ * @param {number} targetZoom - Target zoom level
+ * @param {number} focusX - Screen X coordinate to focus zoom on (default: center)
+ * @param {number} focusY - Screen Y coordinate to focus zoom on (default: center)
+ * @returns {boolean} True if zoom was changed
+ */
+ setZoom(targetZoom, focusX = this.canvasWidth / 2, focusY = this.canvasHeight / 2) {
+ const minZoom = this.getMinZoom();
+ const clampedZoom = constrain(targetZoom, minZoom, this.MAX_CAMERA_ZOOM);
+ if (clampedZoom === this.cameraZoom) {
+ return false;
+ }
+
+ // Get world position at focus point before zoom
+ const focusWorld = this.screenToWorld(focusX, focusY);
+
+ // DEBUG: Comprehensive zoom debugging
+ if (typeof console !== 'undefined') {
+ logVerbose('[CameraManager] setZoom DETAILED DEBUG', {
+ zoomChange: {
+ from: this.cameraZoom,
+ to: clampedZoom,
+ factor: clampedZoom / this.cameraZoom
+ },
+ focusPoint: {
+ screen: { x: focusX, y: focusY },
+ world: focusWorld,
+ screenPercent: {
+ x: ((focusX / this.canvasWidth) * 100).toFixed(1) + '%',
+ y: ((focusY / this.canvasHeight) * 100).toFixed(1) + '%'
+ }
+ },
+ cameraBefore: {
+ x: this.cameraX,
+ y: this.cameraY,
+ zoom: this.cameraZoom
+ },
+ canvasSize: {
+ width: this.canvasWidth,
+ height: this.canvasHeight
+ }
+ });
+ }
+
+ // Store old zoom for calculation
+ const oldZoom = this.cameraZoom;
+
+ // Update zoom
+ this.cameraZoom = clampedZoom;
+
+ // Calculate new camera position to keep focus point at same screen location
+ //
+ // Transform pipeline (corrected): translate(-cameraX, -cameraY) -> scale(zoom)
+ // A world point (wx, wy) appears on screen at: (wx - cameraX) * zoom, (wy - cameraY) * zoom
+ //
+ // We want the same world point to appear at the same screen coordinates after zoom:
+ // (focusWorld.worldX - newCameraX) * newZoom = focusX
+ // (focusWorld.worldY - newCameraY) * newZoom = focusY
+ //
+ // Solving for new camera position:
+ // newCameraX = focusWorld.worldX - focusX / newZoom
+ // newCameraY = focusWorld.worldY - focusY / newZoom
+ const newCameraX = focusWorld.worldX - focusX / clampedZoom;
+ const newCameraY = focusWorld.worldY - focusY / clampedZoom;
+
+ // Update both local variables and CameraController
+ this.cameraX = newCameraX;
+ this.cameraY = newCameraY;
+ if (typeof CameraController !== 'undefined') {
+ CameraController.setCameraPosition(this.cameraX, this.cameraY);
+ }
+
+ if (typeof console !== 'undefined') {
+ // Test the zoom focus calculation
+ const testScreenCoords = this.worldToScreen(focusWorld.worldX, focusWorld.worldY);
+
+ logVerbose('[CameraManager] setZoom RESULT VERIFICATION', {
+ cameraMovement: {
+ deltaX: newCameraX - this.cameraX,
+ deltaY: newCameraY - this.cameraY,
+ direction: this.getCameraMovementDirection(this.cameraX, this.cameraY, newCameraX, newCameraY)
+ },
+ zoomFocus: {
+ originalScreen: { x: focusX, y: focusY },
+ worldPoint: focusWorld,
+ recalculatedScreen: testScreenCoords,
+ screenError: {
+ x: Math.abs(focusX - testScreenCoords.screenX),
+ y: Math.abs(focusY - testScreenCoords.screenY)
+ }
+ },
+ newCamera: {
+ x: newCameraX,
+ y: newCameraY,
+ zoom: clampedZoom
+ }
+ });
+ }
+
+ this.clampToBounds();
+
+ // DEBUG: Final verification after bounds clamping
+ if (typeof console !== 'undefined') {
+ const finalScreenCoords = this.worldToScreen(focusWorld.worldX, focusWorld.worldY);
+ logVerbose('[CameraManager] FINAL STATE after clampToBounds', {
+ finalCamera: { x: this.cameraX, y: this.cameraY, zoom: this.cameraZoom },
+ boundsEffect: {
+ cameraChanged: (this.cameraX !== newCameraX) || (this.cameraY !== newCameraY),
+ originalCalculated: { x: newCameraX, y: newCameraY },
+ afterBounds: { x: this.cameraX, y: this.cameraY }
+ },
+ focusAccuracy: {
+ target: { x: focusX, y: focusY },
+ actual: finalScreenCoords,
+ error: {
+ x: Math.abs(focusX - finalScreenCoords.screenX).toFixed(2),
+ y: Math.abs(focusY - finalScreenCoords.screenY).toFixed(2)
+ }
+ }
+ });
+ }
+
+ // DEBUG: Print terrain converter and camera controller state after zoom so we can
+ // see whether the render converter (g_activeMap) or CameraController are out of sync.
+ try {
+ const ccPos = (typeof CameraController !== 'undefined' && typeof CameraController.getCameraPosition === 'function')
+ ? CameraController.getCameraPosition()
+ : null;
+
+ if (typeof g_activeMap !== 'undefined' && g_activeMap) {
+ const conv = g_activeMap.renderConversion || {};
+ const convPos = conv._camPosition ?? null;
+ const convCenter = conv._canvasCenter ?? null;
+ const stats = typeof g_activeMap.getCacheStats === 'function' ? g_activeMap.getCacheStats() : null;
+ logVerbose('[CameraManager] post-zoom state', {
+ cameraX: this.cameraX,
+ cameraY: this.cameraY,
+ cameraZoom: this.cameraZoom,
+ cameraControllerPos: ccPos,
+ g_activeMap_convPos: convPos,
+ g_activeMap_convCenter: convCenter,
+ g_activeMap_stats: stats
+ });
+ } else {
+ logVerbose('[CameraManager] post-zoom state', { cameraX: this.cameraX, cameraY: this.cameraY, cameraZoom: this.cameraZoom, cameraControllerPos: ccPos, g_activeMap: null });
+ }
+ } catch (e) {
+ console.warn('CameraManager: post-zoom debug failed', e);
+ }
+
+ // Handle camera following during zoom
+ if (this.cameraFollowEnabled) {
+ const target = this.cameraFollowTarget || this.getPrimarySelectedEntity();
+ if (target) {
+ this.centerOnEntity(target);
+ } else {
+ this.cameraFollowEnabled = false;
+ this.cameraFollowTarget = null;
+ }
+ }
+
+ return true;
+ }
+
+ /**
+ * Handle mouse wheel zoom
+ * @param {Event} event - Mouse wheel event
+ * @returns {boolean} False to prevent default behavior
+ */
+ handleMouseWheel(event) {
+ if (!this.isInGame()) {
+ return true;
+ }
+
+ const wheelDelta = event?.deltaY ?? 0;
+ if (wheelDelta === 0) {
+ return false;
+ }
+
+ // DEBUG: Mouse coordinates and wheel direction
+ logVerbose('[CameraManager] handleMouseWheel DEBUG', {
+ wheelDelta,
+ zoomDirection: wheelDelta > 0 ? 'zoom out' : 'zoom in',
+ mouseX: typeof mouseX !== 'undefined' ? mouseX : 'undefined',
+ mouseY: typeof mouseY !== 'undefined' ? mouseY : 'undefined',
+ canvasWidth: this.canvasWidth,
+ canvasHeight: this.canvasHeight,
+ mousePosition: {
+ relative: {
+ x: typeof mouseX !== 'undefined' ? (mouseX / this.canvasWidth * 100).toFixed(1) + '%' : 'N/A',
+ y: typeof mouseY !== 'undefined' ? (mouseY / this.canvasHeight * 100).toFixed(1) + '%' : 'N/A'
+ },
+ quadrant: this.getMouseQuadrant()
+ }
+ });
+
+ const zoomFactor = wheelDelta > 0 ? (1 / this.CAMERA_ZOOM_STEP) : this.CAMERA_ZOOM_STEP;
+ const targetZoom = this.cameraZoom * zoomFactor;
+ this.setZoom(targetZoom, mouseX, mouseY);
+
+ return false;
+ }
+
+ /**
+ * Helper to determine which quadrant of the screen the mouse is in
+ */
+ getMouseQuadrant() {
+ if (typeof mouseX === 'undefined' || typeof mouseY === 'undefined') {
+ return 'unknown';
+ }
+
+ const centerX = this.canvasWidth / 2;
+ const centerY = this.canvasHeight / 2;
+
+ if (mouseX < centerX && mouseY < centerY) return 'NW (top-left)';
+ if (mouseX >= centerX && mouseY < centerY) return 'NE (top-right)';
+ if (mouseX < centerX && mouseY >= centerY) return 'SW (bottom-left)';
+ return 'SE (bottom-right)';
+ }
+
+ /**
+ * Helper to describe camera movement direction
+ */
+ getCameraMovementDirection(oldX, oldY, newX, newY) {
+ const deltaX = newX - oldX;
+ const deltaY = newY - oldY;
+
+ const directions = [];
+ if (Math.abs(deltaY) > 1) {
+ directions.push(deltaY > 0 ? 'south' : 'north');
+ }
+ if (Math.abs(deltaX) > 1) {
+ directions.push(deltaX > 0 ? 'east' : 'west');
+ }
+
+ return directions.length > 0 ? directions.join('-') : 'no movement';
+ }
+
+ /**
+ * Center camera on world coordinates
+ * @param {number} worldX - World X coordinate
+ * @param {number} worldY - World Y coordinate
+ */
+ centerOn(worldX, worldY) {
+ // Use CameraController's built-in centering function
+ if (typeof CameraController !== 'undefined') {
+ CameraController.centerCameraOn(worldX, worldY);
+
+ // Update local variables
+ const pos = CameraController.getCameraPosition();
+ this.cameraX = pos.x;
+ this.cameraY = pos.y;
+ } else {
+ console.warn("Camera not set correctly. CameraController not yet init.")
+ }
+
+ this.clampToBounds();
+ }
+
+ /**
+ * Center camera on an entity
+ * @param {Object} entity - Entity with position properties
+ */
+ centerOnEntity(entity) {
+ const center = this.getEntityWorldCenter(entity);
+ if (center) {
+ this.centerOn(center.x, center.y);
+ }
+ }
+
+ /**
+ * Toggle camera following for the primary selected entity
+ */
+ toggleFollow() {
+ const target = this.getPrimarySelectedEntity();
+
+ if (this.cameraFollowEnabled) {
+ if (!target || target === this.cameraFollowTarget) {
+ this.cameraFollowEnabled = false;
+ this.cameraFollowTarget = null;
+ return;
+ }
+ }
+
+ if (target) {
+ this.cameraFollowEnabled = true;
+ this.cameraFollowTarget = target;
+ this.centerOnEntity(target);
+ }
+ }
+
+ /**
+ * Set custom level bounds for camera clamping
+ * @param {Object} bounds - {width: number, height: number} or null to use current map
+ * @param {Object} levelMap - Reference to level map object (defaults to g_activeMap)
+ */
+ setLevelBounds(bounds = null, levelMap = null) {
+ this.customBounds = bounds;
+ this.currentLevel = levelMap;
+ logVerbose('CameraManager: Level bounds updated', { bounds, levelMap: levelMap ? 'set' : 'null' });
+ }
+
+ /**
+ * Get current level bounds (pixels)
+ * @returns {Object} {width: number, height: number}
+ */
+ getLevelBounds() {
+ // Use custom bounds if set
+ if (this.customBounds) {
+ return this.customBounds;
+ }
+
+ // Use specified level or default to g_activeMap
+ const map = this.currentLevel || (typeof g_activeMap !== 'undefined' ? g_activeMap : null);
+
+ // Try to get dimensions from map
+ if (map && map._xCount > 0 && map._yCount > 0) {
+ const tileSize = (typeof TILE_SIZE !== 'undefined') ? TILE_SIZE : 32;
+ return {
+ width: map._xCount * tileSize,
+ height: map._yCount * tileSize
+ };
+ }
+
+ // Fallback to getMapPixelDimensions if available
+ if (typeof getMapPixelDimensions === 'function') {
+ return getMapPixelDimensions();
+ }
+
+ // Last resort: use canvas size (no clamping)
+ return {
+ width: this.canvasWidth,
+ height: this.canvasHeight
+ };
+ }
+
+ /**
+ * Clamp camera position to world bounds
+ * Now level-aware and configurable
+ */
+ clampToBounds() {
+ const bounds = this.getLevelBounds();
+
+ // If bounds equals canvas size, we're probably not initialized yet
+ if (bounds.width === this.canvasWidth && bounds.height === this.canvasHeight) {
+ // Don't clamp if we don't have real map bounds yet
+ const map = this.currentLevel || (typeof g_activeMap !== 'undefined' ? g_activeMap : null);
+ if (map && !(map._xCount > 0 && map._yCount > 0)) {
+ return;
+ }
+ }
+
+ const viewWidth = this.canvasWidth / this.cameraZoom;
+ const viewHeight = this.canvasHeight / this.cameraZoom;
+
+ let minX = 0;
+ let maxX = bounds.width - viewWidth;
+ if (viewWidth >= bounds.width) {
+ // View is larger than world - center world in view
+ const excessX = viewWidth - bounds.width;
+ minX = -excessX / 2;
+ maxX = excessX / 2;
+ } else {
+ maxX = Math.max(0, maxX);
+ }
+
+ let minY = 0;
+ let maxY = bounds.height - viewHeight;
+ if (viewHeight >= bounds.height) {
+ // View is larger than world - center world in view
+ const excessY = viewHeight - bounds.height;
+ minY = -excessY / 2;
+ maxY = excessY / 2;
+ } else {
+ maxY = Math.max(0, maxY);
+ }
+
+ this.cameraX = constrain(this.cameraX, minX, maxX);
+ this.cameraY = constrain(this.cameraY, minY, maxY);
+
+ // Update CameraController with clamped position
+ if (typeof CameraController !== 'undefined') {
+ CameraController.setCameraPosition(this.cameraX, this.cameraY);
+ }
+ }
+
+ /**
+ * Convert screen coordinates to world coordinates
+ * @param {number} px - Screen X coordinate
+ * @param {number} py - Screen Y coordinate
+ * @returns {Object} World coordinates {worldX, worldY}
+ */
+ screenToWorld(px = mouseX, py = mouseY) {
+ // Zoom-aware conversion from screen (pixels) to world coordinates.
+ // With corrected transform order: translate first, then scale
+ // Screen point (px, py) -> World point calculation:
+ // Inverse of: translate(-cameraX, -cameraY) then scale(zoom)
+
+ const result = {
+ worldX: this.cameraX + px / this.cameraZoom,
+ worldY: this.cameraY + py / this.cameraZoom
+ };
+
+ return result;
+ }
+
+ /**
+ * Convert world coordinates to screen coordinates
+ * @param {number} worldX - World X coordinate
+ * @param {number} worldY - World Y coordinate
+ * @returns {Object} Screen coordinates {screenX, screenY}
+ */
+ worldToScreen(worldX, worldY) {
+ // Zoom-aware conversion from world to screen coordinates.
+ // With corrected transform order: translate first, then scale
+ // Forward transform: translate(-cameraX, -cameraY) then scale(zoom)
+ return {
+ screenX: (worldX - this.cameraX) * this.cameraZoom,
+ screenY: (worldY - this.cameraY) * this.cameraZoom
+ };
+ }
+
+ /**
+ * Get current world mouse position
+ * @returns {Object} World coordinates {worldX, worldY}
+ */
+ getWorldMousePosition() {
+ return this.screenToWorld(mouseX, mouseY);
+ }
+
+ // Getter methods for compatibility
+ getX() { return this.cameraX; }
+ getY() { return this.cameraY; }
+ getZoom() { return this.cameraZoom; }
+ getPosition() { return { x: this.cameraX, y: this.cameraY }; }
+
+ // Setter methods
+ setPosition(x, y) {
+ this.cameraX = x;
+ this.cameraY = y;
+ if (typeof CameraController !== 'undefined') {
+ CameraController.setCameraPosition(x, y);
+ }
+ }
+
+ // Utility methods (stubs - these should reference actual game functions)
+ isInGame() {
+ return typeof GameState !== 'undefined' ? GameState.isInGame() : true;
+ }
+
+ getPrimarySelectedEntity() {
+ // This should reference your actual selected entity logic
+ return typeof getPrimarySelectedEntity === 'function' ? getPrimarySelectedEntity() : null;
+ }
+
+ getEntityWorldCenter(entity) {
+ // This should reference your actual entity center calculation
+ return typeof getEntityWorldCenter === 'function' ? getEntityWorldCenter(entity) : null;
+ }
+}
+
+// Global utility functions for camera-aware mouse coordinates
+/**
+ * Get world mouse coordinates that account for camera position and zoom
+ * This is a global convenience function that uses the active CameraManager instance
+ * @returns {Object} World coordinates {x, y} or screen coordinates if no camera manager
+ */
+function getWorldMouseX() {
+ if (typeof window !== 'undefined' && window.g_cameraManager && typeof window.g_cameraManager.screenToWorld === 'function') {
+ const worldPos = window.g_cameraManager.screenToWorld(mouseX, mouseY);
+ if (window.g_mouseDebugEnabled) {
+ logVerbose(`[getWorldMouseX] Screen: ${mouseX} -> World: ${worldPos.worldX} (Camera: ${window.g_cameraManager.cameraX}, Zoom: ${window.g_cameraManager.cameraZoom})`);
+ }
+ return worldPos.worldX;
+ }
+ // Fallback to screen coordinates if no camera manager
+ const fallbackX = typeof mouseX !== 'undefined' ? mouseX : 0;
+ if (window.g_mouseDebugEnabled) {
+ logVerbose(`[getWorldMouseX] Fallback mode: ${fallbackX} (no camera manager)`);
+ }
+ return fallbackX;
+}
+
+function getWorldMouseY() {
+ if (typeof window !== 'undefined' && window.g_cameraManager && typeof window.g_cameraManager.screenToWorld === 'function') {
+ const worldPos = window.g_cameraManager.screenToWorld(mouseX, mouseY);
+ if (window.g_mouseDebugEnabled) {
+ logVerbose(`[getWorldMouseY] Screen: ${mouseY} -> World: ${worldPos.worldY} (Camera: ${window.g_cameraManager.cameraY}, Zoom: ${window.g_cameraManager.cameraZoom})`);
+ }
+ return worldPos.worldY;
+ }
+ // Fallback to screen coordinates if no camera manager
+ const fallbackY = typeof mouseY !== 'undefined' ? mouseY : 0;
+ if (window.g_mouseDebugEnabled) {
+ logVerbose(`[getWorldMouseY] Fallback mode: ${fallbackY} (no camera manager)`);
+ }
+ return fallbackY;
+}
+
+/**
+ * Get world mouse position as an object
+ * @returns {Object} World coordinates {x, y}
+ */
+function getWorldMousePosition() {
+ if (typeof window !== 'undefined' && window.g_cameraManager && typeof window.g_cameraManager.screenToWorld === 'function') {
+ const worldPos = window.g_cameraManager.screenToWorld(mouseX, mouseY);
+ if (window.g_mouseDebugEnabled) {
+ logVerbose(`[getWorldMousePosition] Screen: (${mouseX}, ${mouseY}) -> World: (${worldPos.worldX}, ${worldPos.worldY}) | Camera: (${window.g_cameraManager.cameraX}, ${window.g_cameraManager.cameraY}), Zoom: ${window.g_cameraManager.cameraZoom}`);
+ }
+ return { x: worldPos.worldX, y: worldPos.worldY };
+ }
+ // Fallback to screen coordinates if no camera manager
+ const fallback = {
+ x: typeof mouseX !== 'undefined' ? mouseX : 0,
+ y: typeof mouseY !== 'undefined' ? mouseY : 0
+ };
+ if (window.g_mouseDebugEnabled) {
+ logVerbose(`[getWorldMousePosition] Fallback mode: (${fallback.x}, ${fallback.y}) (no camera manager)`);
+ }
+ return fallback;
+}
+
+// Debug system for mouse coordinate functions
+let g_mouseDebugInterval = null;
+
+/**
+ * Start periodic debug output for mouse coordinate functions (once per second)
+ */
+function startMouseDebug() {
+ if (typeof window !== 'undefined') {
+ window.g_mouseDebugEnabled = true;
+ logVerbose("[Mouse Debug] Starting periodic debug output (1 second intervals)");
+
+ // Clear any existing interval
+ if (g_mouseDebugInterval) {
+ clearInterval(g_mouseDebugInterval);
+ }
+
+ // Start new interval to call functions every second
+ g_mouseDebugInterval = setInterval(() => {
+ logVerbose("=== Mouse Debug Sample (1s interval) ===");
+ const worldX = getWorldMouseX();
+ const worldY = getWorldMouseY();
+ const worldPos = getWorldMousePosition();
+ logVerbose(`Summary: Screen(${typeof mouseX !== 'undefined' ? mouseX : 'N/A'}, ${typeof mouseY !== 'undefined' ? mouseY : 'N/A'}) -> World(${worldX}, ${worldY})`);
+ logVerbose("=====================================");
+ }, 1000);
+ }
+}
+
+/**
+ * Stop periodic debug output for mouse coordinate functions
+ */
+function stopMouseDebug() {
+ if (typeof window !== 'undefined') {
+ window.g_mouseDebugEnabled = false;
+ logVerbose("[Mouse Debug] Stopping periodic debug output");
+
+ if (g_mouseDebugInterval) {
+ clearInterval(g_mouseDebugInterval);
+ g_mouseDebugInterval = null;
+ }
+ }
+}
+
+/**
+ * Toggle debug mode for mouse coordinate functions
+ */
+function toggleMouseDebug() {
+ if (typeof window !== 'undefined' && window.g_mouseDebugEnabled) {
+ stopMouseDebug();
+ } else {
+ startMouseDebug();
+ }
+}
+
+// Export for global use
+if (typeof window !== 'undefined') {
+ window.CameraManager = CameraManager;
+ window.getWorldMouseX = getWorldMouseX;
+ window.getWorldMouseY = getWorldMouseY;
+ window.getWorldMousePosition = getWorldMousePosition;
+ window.startMouseDebug = startMouseDebug;
+ window.stopMouseDebug = stopMouseDebug;
+ window.toggleMouseDebug = toggleMouseDebug;
+ window.g_mouseDebugEnabled = false; // Initialize as disabled
+}
+
+
diff --git a/Classes/controllers/CombatController.js b/Classes/controllers/CombatController.js
new file mode 100644
index 00000000..d47bf7e6
--- /dev/null
+++ b/Classes/controllers/CombatController.js
@@ -0,0 +1,226 @@
+/**
+ * CombatController - Handles combat detection, enemy tracking, and combat state management
+ */
+
+
+
+class CombatController {
+ static _states = {OUT: "OUT_OF_COMBAT",IN: "IN_COMBAT"};
+ static _actionStates = {ATTACK: "ATTACKING", DEFEND: "DEFENDING", SPIT: "SPITTING", NONE: "NONE"};
+
+ constructor(entity) {
+ this._entity = entity;
+ this._nearbyEnemies = [];
+ this._detectionRadius = 200; // pixels
+ this._combatState = CombatController._states.OUT;
+ this._combatActionState = CombatController._actionStates.NONE;
+ this._lastEnemyCheck = 0;
+ this._enemyCheckInterval = 100; // Check every 100ms for performance
+ }
+
+ // --- Public API ---
+
+ /**
+ * Update combat state and enemy detection
+ */
+ update() {
+ const now = Date.now();
+ if (now - this._lastEnemyCheck > this._enemyCheckInterval) {
+ this.detectEnemies();
+ this.updateCombatState();
+ this._lastEnemyCheck = now;
+ }
+ }
+
+ /**
+ * Get nearby enemies
+ * @returns {Array} Array of nearby enemy entities
+ */
+ getNearbyEnemies() {
+ return this._nearbyEnemies;
+ }
+
+ /**
+ * Check if entity is currently in combat
+ * @returns {boolean} True if in combat
+ */
+ isInCombat() {
+ return this._combatState === CombatController._states.IN;
+ }
+
+ /**
+ * Set detection radius for enemies
+ * @param {number} radius - Detection radius in pixels
+ */
+ setDetectionRadius(radius) {
+ this._detectionRadius = radius;
+ }
+
+ /**
+ * Set entity faction for combat determination
+ * @param {string} faction - Faction name (e.g., "player", "enemy", "neutral")
+ */
+ setFaction(faction) {
+ this._entity._faction = faction;
+ }
+
+ /**
+ * Get entity faction
+ * @returns {string} Entity faction
+ */
+ getFaction() {
+ return this._entity._faction || this._entity.faction || "neutral";
+ }
+
+ /**
+ * Get current combat state
+ * @returns {string} Combat state
+ */
+ getCombatState() {
+ return this._combatState;
+ }
+
+ /**
+ * Force combat state (for testing/debugging)
+ * @param {string} state - Combat state to set
+ */
+ setCombatState(state) {
+ const oldState = this._combatState;
+ this._combatState = state;
+
+ // Update state machine if available
+ if (this._entity._stateMachine) {
+ this._entity._stateMachine.setCombatModifier(state);
+ }
+
+ this._onCombatStateChange(oldState, state);
+ }
+
+ // --- Private Methods ---
+
+ /**
+ * Detect nearby enemies within detection radius
+ */
+ detectEnemies() {
+ this._nearbyEnemies = [];
+
+ // Access global ants array (this could be improved with dependency injection)
+ if (typeof ants === 'undefined' || typeof antIndex === 'undefined') return;
+
+ const entityFaction = this._entity._faction || this._entity.faction || "neutral";
+
+ // Check all other ants for enemies
+ for (let i = 0; i < ants.length; i++) {
+ if (!ants[i] || ants[i] === this._entity) continue;
+
+ const otherAnt = ants[i];
+
+ // Skip if same faction or either is neutral
+ if (otherAnt.faction === entityFaction ||
+ entityFaction === "neutral" ||
+ otherAnt.faction === "neutral" || otherAnt.faction === "neutral") {
+ continue;
+ }
+
+
+ // Check distance
+ const distance = this.calculateDistance(this._entity, otherAnt);
+
+ if (distance <= this._detectionRadius) {
+ this._nearbyEnemies.push(otherAnt);
+ }
+ }
+
+ // Focus on attacking ants before buildings
+ if( this._nearbyEnemies.length > 0){return;}
+
+ // Detect buildings
+ for (let i = 0; i < Buildings.length; i++) {
+ const building = Buildings[i];
+ if (!building) continue;
+ if (building._faction === entityFaction || entityFaction === "neutral" || building._faction === "neutral" || building._isDead) {
+ continue;
+ }
+
+ const distance = this.calculateDistance(this._entity, building);
+ if (distance <= this._detectionRadius) {
+ console.log("Checking building:", building._faction);
+ this._nearbyEnemies.push(building);
+ }
+ }
+ }
+
+ /**
+ * Calculate distance between two entities
+ * @param {Object} entity1 - First entity
+ * @param {Object} entity2 - Second entity
+ * @returns {number} Distance in pixels
+ */
+ calculateDistance(entity1, entity2) {
+ const pos1 = entity1.getPosition();
+ const pos2 = entity2.getPosition();
+ const dx = pos1.x - pos2.x;
+ const dy = pos1.y - pos2.y;
+ return Math.sqrt(dx * dx + dy * dy);
+ }
+
+ /**
+ * Update combat state based on nearby enemies
+ */
+ updateCombatState() {
+ const wasInCombat = this.isInCombat();
+ const hasEnemies = this._nearbyEnemies.length > 0;
+
+ if (hasEnemies && !wasInCombat) {
+ this.setCombatState(CombatController._states.IN);
+ } else if (!hasEnemies && wasInCombat) {
+ this.setCombatState(CombatController._states.OUT);
+ }
+ }
+
+ /**
+ * Handle combat state changes
+ * @param {string} oldState - Previous combat state
+ * @param {string} newState - New combat state
+ */
+ _onCombatStateChange(oldState, newState) {
+ // Override in subclasses or set callback for custom behavior
+ if (this._onStateChangeCallback) {
+ this._onStateChangeCallback(oldState, newState);
+ }
+ }
+
+ /**
+ * Set callback for combat state changes
+ * @param {Function} callback - Callback function
+ */
+ setStateChangeCallback(callback) {
+ this._onStateChangeCallback = callback;
+ }
+
+ /**
+ * Get combat debug information
+ * @returns {Object} Debug information
+ */
+ getDebugInfo() {
+ return {
+ combatState: this._combatState,
+ nearbyEnemyCount: this._nearbyEnemies.length,
+ detectionRadius: this._detectionRadius,
+ entityFaction: this._entity.faction || "neutral"
+ };
+ }
+
+ /**
+ * draws a circle around an entity that represents is enemy detection range
+ * should only be used if debug state is enabled
+ */
+ drawDetectionRange() {
+
+ }
+}
+
+// Export for Node.js testing
+if (typeof module !== 'undefined' && module.exports) {
+ module.exports = CombatController;
+}
\ No newline at end of file
diff --git a/Classes/controllers/DebugRenderer.js b/Classes/controllers/DebugRenderer.js
new file mode 100644
index 00000000..37c3b16a
--- /dev/null
+++ b/Classes/controllers/DebugRenderer.js
@@ -0,0 +1,38 @@
+// Shared debug rendering helper for entities
+const DebugRenderer = {
+ renderEntityDebug(entity) {
+ try {
+ if (typeof devConsoleEnabled === 'undefined' || !devConsoleEnabled) return;
+
+ const pos = entity.getPosition ? entity.getPosition() : (entity._sprite && entity._sprite.pos) || { x: entity.posX, y: entity.posY };
+ if (!pos || !entity.getCurrentState) return;
+
+ if (typeof push === 'function') push();
+ if (typeof noStroke === 'function') noStroke();
+ if (typeof fill === 'function') fill(255);
+ if (typeof textAlign === 'function') textAlign(LEFT);
+ if (typeof textSize === 'function') textSize(10);
+
+ if (typeof text === 'function') {
+ text(`State: ${entity.getCurrentState()}`, pos.x, pos.y - 30);
+ text(`Faction: ${entity._faction || entity.faction || 'unknown'}`, pos.x, pos.y - 20);
+ if (entity.getEffectiveMovementSpeed && typeof entity.getEffectiveMovementSpeed === 'function') {
+ const sp = entity.getEffectiveMovementSpeed();
+ text(`Speed: ${typeof sp === 'number' ? sp.toFixed(1) : sp}`, pos.x, pos.y - 10);
+ }
+ }
+
+ if (typeof pop === 'function') pop();
+ } catch (e) {
+ // best-effort, do not throw from debug renderer
+ if (typeof console !== 'undefined') console.warn('DebugRenderer.renderEntityDebug error', e);
+ }
+ }
+};
+
+if (typeof module !== 'undefined' && module.exports) {
+ module.exports = DebugRenderer;
+} else {
+ // Attach to window for immediate global fallback usage
+ if (typeof window !== 'undefined') window.DebugRenderer = DebugRenderer;
+}
diff --git a/Classes/controllers/HealthController.js b/Classes/controllers/HealthController.js
new file mode 100644
index 00000000..ddef6497
--- /dev/null
+++ b/Classes/controllers/HealthController.js
@@ -0,0 +1,220 @@
+/**
+ * @fileoverview HealthController - Manages health rendering and display for entities
+ * @module HealthController
+ * @author Software Engineering Team Delta
+ * @version 1.0.0
+ */
+
+/**
+ * HealthController - Controls health display and management for entities
+ * Renders health bars above entities when health is not at maximum
+ */
+class HealthController {
+ constructor(entity) {
+ this.entity = entity;
+
+ // Health bar configuration
+ this.config = {
+ barWidth: null, // Will be set to entity width
+ barHeight: 4,
+ offsetY: 12, // Distance above entity (increased from 8)
+ backgroundColor: [255, 0, 0], // Red background
+ foregroundColor: [0, 255, 0], // Green foreground
+ borderColor: [255, 255, 255], // White border
+ borderWidth: 1,
+ showWhenFull: false, // Only show when health < max
+ fadeInDuration: 500, // ms
+ fadeOutDuration: 1000, // ms
+ displayDuration: 3000 // ms to show after damage
+ };
+
+ // Animation state
+ this.lastDamageTime = 0;
+ this.isVisible = false;
+ this.alpha = 0;
+ this.targetAlpha = 0;
+ }
+
+ /**
+ * Update the health controller (called each frame)
+ */
+ update() {
+ if (!this.entity) return;
+
+ const currentTime = Date.now();
+ const health = this.entity.health || 0;
+ const maxHealth = this.entity.maxHealth || 100;
+
+ // Determine if health bar should be visible
+ const shouldShow = health < maxHealth || this.config.showWhenFull;
+ const recentDamage = (currentTime - this.lastDamageTime) < this.config.displayDuration;
+
+ if (shouldShow && (health < maxHealth || recentDamage)) {
+ this.targetAlpha = 1.0;
+ this.isVisible = true;
+ } else {
+ this.targetAlpha = 0.0;
+ if (this.alpha <= 0.1) {
+ this.isVisible = false;
+ }
+ }
+
+ // Animate alpha
+ if (this.alpha < this.targetAlpha) {
+ this.alpha = Math.min(this.targetAlpha, this.alpha + (1.0 / 30)); // Fade in over ~30 frames
+ } else if (this.alpha > this.targetAlpha) {
+ this.alpha = Math.max(this.targetAlpha, this.alpha - (1.0 / 60)); // Fade out over ~60 frames
+ }
+ }
+
+ /**
+ * Render the health bar
+ */
+ render() {
+ if (!this.isVisible || !this.entity || typeof fill === 'undefined') {
+ return;
+ }
+
+ const health = this.entity.health || 0;
+ const maxHealth = this.entity.maxHealth || 100;
+
+ if (health >= maxHealth && !this.config.showWhenFull) {
+ return;
+ }
+
+ const pos = this.entity.getPosition ? this.entity.getPosition() : { x: this.entity.posX || 0, y: this.entity.posY || 0 };
+ const size = this.entity.getSize ? this.entity.getSize() : { x: this.entity.sizeX || 20, y: this.entity.sizeY || 20 };
+
+ // Set bar width to entity width if not configured
+ const barWidth = this.config.barWidth || size.x;
+ const barHeight = this.config.barHeight;
+
+ // Convert entity position to screen coordinates first
+ let entityScreenX = pos.x;
+ let entityScreenY = pos.y;
+
+ if (typeof CoordinateConverter !== 'undefined' && CoordinateConverter.isAvailable()) {
+ const entityScreenPos = CoordinateConverter.worldToScreen(pos.x, pos.y);
+ entityScreenX = entityScreenPos.x;
+ entityScreenY = entityScreenPos.y;
+ }
+
+ // Now apply offset in screen space (above means negative Y in screen space)
+ const barX = entityScreenX + (size.x - barWidth) / 2;
+ const barY = entityScreenY - this.config.offsetY - barHeight;
+
+ // Calculate health percentage
+ const healthPercent = Math.max(0, Math.min(1, health / maxHealth));
+
+ // Save current drawing state
+ push();
+
+ // Apply alpha for fade effect
+ const alpha = this.alpha * 255;
+
+ // Draw border
+ if (this.config.borderWidth > 0) {
+ stroke(this.config.borderColor[0], this.config.borderColor[1], this.config.borderColor[2], alpha);
+ strokeWeight(this.config.borderWidth);
+ noFill();
+ rect(barX - this.config.borderWidth, barY - this.config.borderWidth,
+ barWidth + this.config.borderWidth * 2, barHeight + this.config.borderWidth * 2);
+ }
+
+ // Draw background
+ fill(this.config.backgroundColor[0], this.config.backgroundColor[1], this.config.backgroundColor[2], alpha);
+ noStroke();
+ rect(barX, barY, barWidth, barHeight);
+
+ // Draw health foreground
+ if (healthPercent > 0) {
+ fill(this.config.foregroundColor[0], this.config.foregroundColor[1], this.config.foregroundColor[2], alpha);
+ rect(barX, barY, barWidth * healthPercent, barHeight);
+ }
+
+ // Restore drawing state
+ pop();
+ }
+
+ /**
+ * Notify that the entity took damage (triggers display)
+ */
+ onDamage() {
+ this.lastDamageTime = Date.now();
+ this.targetAlpha = 1.0;
+ this.isVisible = true;
+ }
+
+ /**
+ * Set health bar configuration
+ * @param {Object} newConfig - Configuration options
+ */
+ setConfig(newConfig) {
+ this.config = { ...this.config, ...newConfig };
+ }
+
+ /**
+ * Get current health bar configuration
+ * @returns {Object} Current configuration
+ */
+ getConfig() {
+ return { ...this.config };
+ }
+
+ /**
+ * Force show/hide the health bar
+ * @param {boolean} visible - Whether to show the health bar
+ */
+ setVisible(visible) {
+ this.targetAlpha = visible ? 1.0 : 0.0;
+ if (visible) {
+ this.isVisible = true;
+ this.lastDamageTime = Date.now();
+ }
+ }
+
+ /**
+ * Check if health bar is currently visible
+ * @returns {boolean} True if visible
+ */
+ getVisible() {
+ return this.isVisible && this.alpha > 0.1;
+ }
+
+ /**
+ * Get debug information
+ * @returns {Object} Debug info
+ */
+ getDebugInfo() {
+ if (!this.entity) return {};
+
+ return {
+ controllerType: 'HealthController',
+ isVisible: this.isVisible,
+ alpha: this.alpha,
+ targetAlpha: this.targetAlpha,
+ health: this.entity.health || 0,
+ maxHealth: this.entity.maxHealth || 100,
+ healthPercent: Math.round(((this.entity.health || 0) / (this.entity.maxHealth || 100)) * 100),
+ lastDamageTime: this.lastDamageTime,
+ timeSinceDamage: Date.now() - this.lastDamageTime
+ };
+ }
+
+ /**
+ * Cleanup controller
+ */
+ destroy() {
+ this.entity = null;
+ }
+}
+
+// Export for Node.js testing
+if (typeof module !== 'undefined' && module.exports) {
+ module.exports = HealthController;
+}
+
+// Make available globally for browser
+if (typeof window !== 'undefined') {
+ window.HealthController = HealthController;
+}
\ No newline at end of file
diff --git a/Classes/controllers/InputController.js b/Classes/controllers/InputController.js
new file mode 100644
index 00000000..e69de29b
diff --git a/Classes/controllers/InventoryController.js b/Classes/controllers/InventoryController.js
new file mode 100644
index 00000000..6bab7551
--- /dev/null
+++ b/Classes/controllers/InventoryController.js
@@ -0,0 +1,97 @@
+/**
+ * InventoryController
+ * -------------------
+ * Simple fixed-size inventory for an entity (default capacity = 2).
+ * - Tracks occupant (owner) and slot array.
+ * - Calls resource.pickUp(owner) when storing and resource.drop() when removing.
+ */
+class InventoryController {
+ constructor(owner, capacity = 2) {
+ this.owner = owner;
+ this.capacity = Math.max(1, capacity);
+ this.slots = Array(this.capacity).fill(null);
+ }
+
+ // Return number of occupied slots
+ getCount() { return this.slots.filter(s => s !== null).length; }
+
+ // Return true when inventory is full
+ isFull() { return this.getCount() >= this.capacity; }
+
+ // Return true when inventory empty
+ isEmpty() { return this.getCount() === 0; }
+
+ // Get resource at slot index (or null)
+ getSlot(index) { return this.slots[index] ?? null; }
+
+ // Return shallow array copy of current resources
+ getResources() { return this.slots.slice(); }
+
+ // Add resource to first available slot. Calls resource.pickUp(owner).
+ // Returns true on success, false if full or invalid resource.
+ addResource(resource) {
+ if (!resource) return false;
+ const idx = this.slots.findIndex(s => s === null);
+ if (idx === -1) return false;
+ this.slots[idx] = resource;
+ if (typeof resource.pickUp === 'function') resource.pickUp(this.owner);
+ return true;
+ }
+
+ // Put resource into specific slot if free. Returns true/false.
+ addResourceToSlot(index, resource) {
+ if (!resource || index < 0 || index >= this.capacity) return false;
+ if (this.slots[index] !== null) return false;
+ this.slots[index] = resource;
+ if (typeof resource.pickUp === 'function') resource.pickUp(this.owner);
+ return true;
+ }
+
+ // Remove resource from slot and return it. Calls resource.drop() and, if global resources array exists, returns it to ground near owner.
+ removeResource(index, dropToGround = true) {
+ if (index < 0 || index >= this.capacity) return null;
+ const res = this.slots[index];
+ if (!res) return null;
+ this.slots[index] = null;
+ if (typeof res.drop === 'function') res.drop();
+ // Place back on ground near owner when requested and global resources exists
+ if (dropToGround && resources && Array.isArray(resources)) {
+ const ox = (this.owner && (this.owner.posX ?? this.owner.getPosition?.().x)) || 0;
+ const oy = (this.owner && (this.owner.posY ?? this.owner.getPosition?.().y)) || 0;
+ if (typeof res.posX !== 'undefined') { res.posX = ox + random(-10,10); res.posY = oy + random(-10,10); }
+ resources.push(res);
+ }
+ return res;
+ }
+
+ // Drop all items (to ground if global resources present) and clear inventory.
+ dropAll() {
+ for (let i = 0; i < this.capacity; i++) {
+ if (this.slots[i]) this.removeResource(i, true);
+ }
+ }
+
+ // Check whether inventory contains a resource of given type
+ containsType(type) {
+ return this.slots.some(r => r && (r.type === type));
+ }
+
+ // Try to transfer all resources into another InventoryController. Returns number transferred.
+ transferAllTo(targetInventory) {
+ if (!targetInventory || typeof targetInventory.addResource !== 'function') return 0;
+ let transferred = 0;
+ for (let i = 0; i < this.capacity; i++) {
+ const r = this.slots[i];
+ if (!r) continue;
+ if (targetInventory.addResource(r)) {
+ this.slots[i] = null;
+ transferred++;
+ }
+ }
+ return transferred;
+ }
+}
+
+// Expose for browser and Node
+if (typeof window !== 'undefined') window.InventoryController = InventoryController;
+if (typeof module !== 'undefined' && module.exports) module.exports = InventoryController;
\ No newline at end of file
diff --git a/Classes/controllers/KeyboardInputController.js b/Classes/controllers/KeyboardInputController.js
new file mode 100644
index 00000000..9af52270
--- /dev/null
+++ b/Classes/controllers/KeyboardInputController.js
@@ -0,0 +1,50 @@
+// KeyboardInputController.js - Simple, modern keyboard input controller
+// Usage:
+// const keyboard = new KeyboardInputController();
+// keyboard.onKeyPress((keyCode, key) => { ... });
+// keyboard.onKeyRelease((keyCode, key) => { ... });
+// keyboard.onKeyType((key) => { ... });
+// // In your p5.js handlers:
+// function keyPressed() { keyboard.handleKeyPressed(keyCode, key); }
+// function keyReleased() { keyboard.handleKeyReleased(keyCode, key); }
+// function keyTyped() { keyboard.handleKeyTyped(key); }
+
+class KeyboardInputController {
+ constructor() {
+ this.keyPressHandlers = [];
+ this.keyReleaseHandlers = [];
+ this.keyTypeHandlers = [];
+ this.pressedKeys = new Set();
+ }
+
+ onKeyPress(fn) {
+ if (typeof fn === 'function') this.keyPressHandlers.push(fn);
+ }
+ onKeyRelease(fn) {
+ if (typeof fn === 'function') this.keyReleaseHandlers.push(fn);
+ }
+ onKeyType(fn) {
+ if (typeof fn === 'function') this.keyTypeHandlers.push(fn);
+ }
+
+ handleKeyPressed(keyCode, key) {
+ this.pressedKeys.add(keyCode);
+ this.keyPressHandlers.forEach(fn => fn(keyCode, key));
+ }
+
+ handleKeyReleased(keyCode, key) {
+ this.pressedKeys.delete(keyCode);
+ this.keyReleaseHandlers.forEach(fn => fn(keyCode, key));
+ }
+
+ handleKeyTyped(key) {
+ this.keyTypeHandlers.forEach(fn => fn(key));
+ }
+
+ isKeyDown(keyCode) {
+ return this.pressedKeys.has(keyCode);
+ }
+}
+
+// Export for use in your main file
+// window.KeyboardInputController = KeyboardInputController;
\ No newline at end of file
diff --git a/Classes/controllers/MouseInputController.js b/Classes/controllers/MouseInputController.js
new file mode 100644
index 00000000..8fa8001d
--- /dev/null
+++ b/Classes/controllers/MouseInputController.js
@@ -0,0 +1,58 @@
+// MouseInputController.js - Simple, modern mouse input controller for games
+// Usage:
+// const mouse = new MouseInputController();
+// mouse.onClick((x, y, button) => { ... });
+// mouse.onDrag((x, y, dx, dy) => { ... });
+// mouse.onRelease((x, y, button) => { ... });
+// // In your p5.js handlers:
+// function mousePressed() { mouse.handleMousePressed(mouseX, mouseY, mouseButton); }
+// function mouseDragged() { mouse.handleMouseDragged(mouseX, mouseY); }
+// function mouseReleased() { mouse.handleMouseReleased(mouseX, mouseY, mouseButton); }
+
+class MouseInputController {
+ constructor() {
+ this.isDragging = false;
+ this.lastX = 0;
+ this.lastY = 0;
+ this.button = null;
+ this.clickHandlers = [];
+ this.dragHandlers = [];
+ this.releaseHandlers = [];
+ }
+
+ onClick(fn) {
+ if (typeof fn === 'function') this.clickHandlers.push(fn);
+ }
+ onDrag(fn) {
+ if (typeof fn === 'function') this.dragHandlers.push(fn);
+ }
+ onRelease(fn) {
+ if (typeof fn === 'function') this.releaseHandlers.push(fn);
+ }
+
+ handleMousePressed(x, y, button) {
+ this.isDragging = false;
+ this.lastX = x;
+ this.lastY = y;
+ this.button = button;
+ this.clickHandlers.forEach(fn => fn(x, y, button));
+ }
+
+ handleMouseDragged(x, y) {
+ if (!this.isDragging) this.isDragging = true;
+ const dx = x - this.lastX;
+ const dy = y - this.lastY;
+ this.dragHandlers.forEach(fn => fn(x, y, dx, dy));
+ this.lastX = x;
+ this.lastY = y;
+ }
+
+ handleMouseReleased(x, y, button) {
+ this.releaseHandlers.forEach(fn => fn(x, y, button));
+ this.isDragging = false;
+ this.button = null;
+ }
+}
+
+// Export for use in your main file
+// window.MouseInputController = MouseInputController;
diff --git a/Classes/controllers/MovementController.js b/Classes/controllers/MovementController.js
new file mode 100644
index 00000000..1638d053
--- /dev/null
+++ b/Classes/controllers/MovementController.js
@@ -0,0 +1,462 @@
+/**
+ * MovementController - Handles all entity movement logic
+ * Provides pathfinding, terrain-aware movement, and position management
+ */
+class MovementController {
+ constructor(entity) {
+ this._entity = entity;
+ this._isMoving = false;
+ this._targetPosition = null;
+ this._path = null;
+ this._movementSpeed = 30; // Default speed
+ this._skitterTimer = 0;
+ this._maxSkitterTime = 200;
+ this._minSkitterTime = 30;
+
+ // Movement state
+ this._lastPosition = null;
+ this._stuckCounter = 0;
+ this._maxStuckFrames = 60; // 1 second at 60fps
+ this.disableSkitter = false;
+ this._skitterRange = 25;
+
+ this.resetSkitterTimer();
+ }
+
+ // --- Public API ---
+
+ /**
+ * Move entity to specific coordinates
+ * @param {number} x - Target X coordinate
+ * @param {number} y - Target Y coordinate
+ * @returns {boolean} - True if movement started successfully
+ */
+ moveToLocation(x, y) {
+ // Check if entity's state machine allows movement
+ if (this._entity._stateMachine && !this._entity._stateMachine.canPerformAction("move")) {
+ return false;
+ }
+
+ if (window.currentNPC && window.currentNPC.dialogueActive === true) {
+ return false; // stop movement while dialogue is active
+ }
+
+ //Flip ants when moving Left or Right
+ const pos = this._entity.getPosition();
+ let flipLeft = (x < pos.x);
+ this._entity._sprite.flipX = flipLeft;
+
+ // Try to use pathfinding if available
+ if (typeof findPath === 'function' && typeof pathMap !== 'undefined' && pathMap) {
+ try {
+ // Convert entity position to grid coordinates
+ const tileSize = window.tileSize || 32;
+ const startX = Math.floor(pos.x / tileSize);
+ const startY = Math.floor(pos.y / tileSize);
+ const endX = Math.floor(x / tileSize);
+ const endY = Math.floor(y / tileSize);
+
+ // Find path using pathfinding system
+ const calculatedPath = findPath([startX, startY], [endX, endY], pathMap);
+
+ if (calculatedPath && calculatedPath.length > 0) {
+ // Set the path and start following it
+ this.setPath(calculatedPath);
+ return true;
+ }
+ } catch (error) {
+ console.warn("Pathfinding failed, using direct movement:", error);
+ }
+ }
+
+ // Fallback to direct movement
+ this._targetPosition = { x, y };
+ this._isMoving = true;
+ this._stuckCounter = 0;
+
+ // Update entity's state if it has a state machine
+ if (this._entity._stateMachine) {
+ this._entity._stateMachine.setPrimaryState("MOVING");
+
+ }
+
+ return true;
+ }
+
+ /**
+ * Set a path for the entity to follow
+ * @param {Array} pathArray - Array of path nodes with x, y coordinates
+ */
+ setPath(pathArray) {
+ this._path = pathArray ? [...pathArray] : null;
+
+ // Start following path if one exists
+ if (this._path && this._path.length > 0) {
+ this.followPath();
+ }
+ }
+
+ /**
+ * Get current path
+ * @returns {Array|null} - Current path array or null
+ */
+ getPath() {
+ return this._path;
+ }
+
+ /**
+ * Stop current movement and clear path
+ */
+ stop() {
+ this._isMoving = false;
+ this._targetPosition = null;
+ this._path = null;
+ this._stuckCounter = 0;
+
+ // Update entity state to idle if it has a state machine
+ if (this._entity._stateMachine && this._entity._stateMachine.isPrimaryState("MOVING")) {
+ this._entity._stateMachine.setPrimaryState("IDLE");
+ }
+ }
+
+ /**
+ * Check if entity is currently moving
+ * @returns {boolean}
+ */
+ getIsMoving() {
+ return this._isMoving;
+ }
+
+ /**
+ * Get current target position
+ * @returns {Object|null} - Target position {x, y} or null
+ */
+ getTarget() {
+ return this._targetPosition;
+ }
+
+ /**
+ * Get movement speed
+ * @returns {number} - Current movement speed
+ */
+ get movementSpeed() {
+ return this._movementSpeed;
+ }
+
+ /**
+ * Set movement speed
+ * @param {number} speed - New movement speed
+ */
+ set movementSpeed(speed) {
+ this._movementSpeed = speed;
+ }
+
+ /**
+ * Update movement logic - call this every frame
+ */
+ update() {
+ // Handle pathfinding movement first
+ if (!this._isMoving && this._path && this._path.length > 0) {
+ this.followPath();
+ }
+
+ // Handle direct movement
+ if (this._isMoving && this._targetPosition) {
+ if(animationManager.isAnimation("Walking")){
+ animationManager.play(this._entity,"Walking");
+ }
+ this.updateDirectMovement();
+ }
+
+ // Handle idle skitter behavior
+ if (!this._isMoving && this.shouldSkitter()) {
+ this.performSkitter();
+ }
+
+ // Update stuck detection
+ this.updateStuckDetection();
+ }
+
+ // --- Private Methods ---
+
+ /**
+ * Follow the current path by moving to the next node
+ */
+ followPath() {
+ if (!this._path || this._path.length === 0) return;
+
+ const nextNode = this._path.shift();
+ let targetX, targetY;
+
+ // Handle different path node formats
+ if (nextNode._x !== undefined && nextNode._y !== undefined) {
+ // Tile-based pathfinding format
+ const tileSize = window.tileSize || 32; // Default tile size
+ targetX = nextNode._x * tileSize;
+ targetY = nextNode._y * tileSize;
+ } else if (nextNode.x !== undefined && nextNode.y !== undefined) {
+ // Direct coordinate format
+ targetX = nextNode.x;
+ targetY = nextNode.y;
+ } else {
+ console.warn("Invalid path node format:", nextNode);
+ return;
+ }
+
+ this.moveToLocation(targetX, targetY);
+ }
+
+ /**
+ * Update direct movement towards target
+ */
+ updateDirectMovement() {
+ if (!this._targetPosition) return;
+
+ const currentPos = this.getCurrentPosition();
+ const target = this._targetPosition;
+
+ const direction = {
+ x: target.x - currentPos.x,
+ y: target.y - currentPos.y
+ };
+
+ const distance = Math.sqrt(direction.x * direction.x + direction.y * direction.y);
+
+ if (distance > 1) {
+ // Normalize direction
+ direction.x /= distance;
+ direction.y /= distance;
+
+ // Calculate movement step (framerate independent)
+ const effectiveSpeed = this.getEffectiveMovementSpeed();
+ // p5.js provides deltaTime in milliseconds
+ const dt = (typeof window.deltaTime !== 'undefined' && window.deltaTime > 0 ? window.deltaTime : 16.67);
+ const step = Math.min((effectiveSpeed * dt) / 1000, distance);
+
+ // Only move if effective speed is greater than 0
+ if (effectiveSpeed > 0) {
+ const newPos = {
+ x: currentPos.x + direction.x * step,
+ y: currentPos.y + direction.y * step
+ };
+ this.setEntityPosition(newPos);
+ }
+ } else {
+ // Target reached
+ this.setEntityPosition(target);
+ this._isMoving = false;
+ this._targetPosition = null;
+
+ // Handle resource drop-off if entity has resource manager
+ if (this._entity._resourceManager && this._entity._resourceManager.isDroppingOff) {
+ const globalResource = window.globalResource || [];
+ this._entity._resourceManager.processDropOff(globalResource);
+ }
+
+ // Set state back to IDLE when movement is complete
+ if (this._entity._stateMachine && this._entity._stateMachine.isPrimaryState("MOVING")) {
+ // Check if there are pending commands
+ if (this._entity._taskManager && this._entity._taskManager.hasPendingTasks()) {
+ // Don't set to IDLE if there are pending tasks
+ } else {
+ this._entity._stateMachine.setPrimaryState("IDLE");
+ }
+ }
+ }
+ }
+
+ /**
+ * Get effective movement speed with terrain modifiers
+ * @returns {number} - Effective speed
+ */
+ getEffectiveMovementSpeed() {
+ let baseSpeed = this._movementSpeed;
+
+ // Get base speed from entity if available
+ if (this._entity.movementSpeed !== undefined) {
+ baseSpeed = this._entity.movementSpeed;
+ }
+
+ // Apply terrain modifiers if entity has state machine
+ if (this._entity._stateMachine) {
+ switch (this._entity._stateMachine.terrainModifier) {
+ case "IN_WATER":
+ return baseSpeed * 0.5; // 50% speed in water
+ case "IN_MUD":
+ return baseSpeed * 0.3; // 30% speed in mud
+ case "ON_SLIPPERY":
+ return 0; // Can't move on slippery terrain
+ case "ON_ROUGH":
+ return baseSpeed * 0.8; // 80% speed on rough terrain
+ case "DEFAULT":
+ default:
+ return baseSpeed; // Normal speed
+ }
+ }
+
+ return baseSpeed;
+ }
+
+ /**
+ * Get current entity position
+ * @returns {Object} - Position {x, y}
+ */
+ getCurrentPosition() {
+ return this._entity.getPosition();
+ }
+
+ /**
+ * Set entity position
+ * @param {Object} position - New position {x, y}
+ */
+ setEntityPosition(position) {
+ this._entity.setPosition(position.x, position.y);
+
+ // Update StatsContainer system if available and properly structured
+ if (this._entity._stats &&
+ this._entity._stats.position &&
+ this._entity._stats.position.statValue) {
+ this._entity._stats.position.statValue.x = position.x;
+ this._entity._stats.position.statValue.y = position.y;
+ }
+
+ // Update sprite position if available
+ if (this._entity._sprite && this._entity._sprite.setPosition) {
+ this._entity._sprite.setPosition(position);
+ }
+ }
+
+ /**
+ * Check if entity should perform skitter behavior
+ * @returns {boolean}
+ */
+ shouldSkitter() {
+ // Don't skitter if movement speed is 0
+ if (this.getEffectiveMovementSpeed() <= 0) {
+ return false;
+ }
+
+ // Allow entities to opt out (e.g., Queen)
+ if (this._entity && this._disableSkitter) {
+ return false;
+ }
+
+ // Only skitter if idle and out of combat
+ if (this._entity._stateMachine) {
+ const canMove = this._entity._stateMachine.canPerformAction("move");
+ const isIdle = this._entity._stateMachine.isPrimaryState("IDLE");
+ const outOfCombat = this._entity._stateMachine.isOutOfCombat();
+
+ if (!canMove || !isIdle || !outOfCombat) {
+ return false;
+ }
+ }
+
+ // Check skitter timer
+ this._skitterTimer -= 1;
+ return this._skitterTimer <= 0;
+ }
+
+ /**
+ * Perform random skitter movement
+ */
+ performSkitter() {
+ this.resetSkitterTimer();
+
+ const currentPos = this.getCurrentPosition();
+ const newX = currentPos.x + (Math.random() - 0.5) * 2 * this._skitterRange;
+ const newY = currentPos.y + (Math.random() - 0.5) * 2 * this._skitterRange;
+
+ this.moveToLocation(newX, newY);
+ }
+
+ /**
+ * Reset skitter timer to random value
+ */
+ resetSkitterTimer() {
+ this._skitterTimer = Math.random() * (this._maxSkitterTime - this._minSkitterTime) + this._minSkitterTime;
+ }
+
+ /**
+ * Update stuck detection logic
+ */
+ updateStuckDetection() {
+ const currentPos = this.getCurrentPosition();
+
+ if (this._lastPosition) {
+ const distance = Math.sqrt(
+ Math.pow(currentPos.x - this._lastPosition.x, 2) +
+ Math.pow(currentPos.y - this._lastPosition.y, 2)
+ );
+
+ // If moving but hasn't moved much, increment stuck counter
+ if (this._isMoving && distance < 0.1) {
+ this._stuckCounter++;
+
+ // If stuck for too long, stop and try to unstuck
+ if (this._stuckCounter >= this._maxStuckFrames) {
+ this.handleStuck();
+ }
+ } else {
+ this._stuckCounter = 0;
+ }
+ }
+
+ this._lastPosition = { x: currentPos.x, y: currentPos.y };
+ }
+
+ /**
+ * Handle stuck entity by stopping movement and clearing path
+ */
+ handleStuck() {
+ console.warn(`Entity stuck for ${this._maxStuckFrames} frames, stopping movement`);
+ this.stop();
+ }
+
+ /**
+ * Get debug information about movement state
+ * @returns {Object} - Debug info
+ */
+ getDebugInfo() {
+ const currentPos = this.getCurrentPosition();
+ return {
+ isMoving: this._isMoving,
+ currentPosition: currentPos,
+ targetPosition: this._targetPosition,
+ pathLength: this._path ? this._path.length : 0,
+ skitterTimer: this._skitterTimer,
+ stuckCounter: this._stuckCounter,
+ effectiveSpeed: this.getEffectiveMovementSpeed()
+ };
+ }
+}
+
+// Static helper to move an entity to a tile coordinate (used by AntUtilities)
+MovementController.moveEntityToTile = function(entity, tileX, tileY, tileSize = 32, pathMap = null) {
+ if (!entity) return false;
+ const px = tileX * tileSize + Math.floor(tileSize / 2);
+ const py = tileY * tileSize + Math.floor(tileSize / 2);
+
+ // Prefer delegating to entity.moveToLocation if present
+ if (typeof entity.moveToLocation === 'function') {
+ return entity.moveToLocation(px, py);
+ }
+
+ // Otherwise use the entity's MovementController instance if available
+ if (entity._movementController && typeof entity._movementController.moveToLocation === 'function') {
+ return entity._movementController.moveToLocation(px, py);
+ }
+
+ // As a last resort, try setting position directly
+ if (typeof entity.setPosition === 'function') {
+ entity.setPosition(px, py);
+ return true;
+ }
+
+ return false;
+};
+
+// Export for Node.js testing
+if (typeof module !== 'undefined' && module.exports) {
+ module.exports = MovementController;
+}
diff --git a/Classes/controllers/RenderController.js b/Classes/controllers/RenderController.js
new file mode 100644
index 00000000..92ea49b0
--- /dev/null
+++ b/Classes/controllers/RenderController.js
@@ -0,0 +1,1009 @@
+/**
+ * RenderController - Standardizes rendering, highlighting, and visual effects
+ * Provides consistent visual representation across all entities
+ */
+class RenderController {
+ constructor(entity) {
+ this._entity = entity;
+ this._effects = [];
+ this._animations = {};
+
+ // Highlight states
+ this._highlightState = null;
+ this._highlightColor = null;
+ this._highlightIntensity = 1.0;
+
+ // Animation properties
+ this._bobOffset = Math.random() * Math.PI * 2; // Random bob start
+ this._pulseOffset = Math.random() * Math.PI * 2; // Random pulse start
+ this._spinOffset = Math.random() * Math.PI * 2; // Random spin start
+
+ // Rendering settings
+ this._smoothing = false; // Pixel art style by default
+ this._debugMode = false;
+
+ // Visual effect types
+ this.HIGHLIGHT_TYPES = {
+ SELECTED: {
+ color: [0, 255, 0], // Green
+ strokeWeight: 3,
+ style: "outline"
+ },
+ HOVER: {
+ color: [255, 255, 0, 200], // White with transparency
+ strokeWeight: 2,
+ style: "outline"
+ },
+ BOX_HOVERED: {
+ color: [0, 255, 0, 150], // Green with transparency
+ strokeWeight: 2,
+ style: "outline"
+ },
+ COMBAT: {
+ color: [255, 0, 0], // Red
+ strokeWeight: 3,
+ style: "pulse"
+ },
+ FRIENDLY: {
+ color: [0, 255, 0], // Green
+ strokeWeight: 2,
+ style: "outline"
+ },
+ ENEMY: {
+ color: [255, 0, 0], // Red
+ strokeWeight: 2,
+ style: "outline"
+ },
+ RESOURCE: {
+ color: [255, 255, 255, 200], // White with transparency
+ strokeWeight: 2,
+ style: "bob"
+ },
+ SPINNING: {
+ color: [0, 255, 255, 200], // Cyan with transparency
+ strokeWeight: 2,
+ style: "spin"
+ },
+ SLOW_SPINNING: {
+ color: [255, 0, 255, 200], // Magenta with transparency
+ strokeWeight: 2,
+ style: "slowSpin"
+ },
+ FAST_SPINNING: {
+ color: [50, 125, 125, 200], // Teal with transparency
+ strokeWeight: 2,
+ style: "fastSpin"
+ }
+ };
+
+ // State indicators
+ this.STATE_INDICATORS = {
+ MOVING: { color: [0, 255, 0], symbol: "→" },
+ GATHERING: { color: [255, 165, 0], symbol: "⛏" },
+ BUILDING: { color: [139, 69, 19], symbol: "🔨" },
+ ATTACKING: { color: [255, 0, 0], symbol: "⚔" },
+ FOLLOWING: { color: [0, 0, 255], symbol: "👥" },
+ FLEEING: { color: [255, 255, 0], symbol: "💨" },
+ IDLE: { color: [128, 128, 128], symbol: "💤" }
+ };
+
+ // Terrain effect indicators
+ this.TERRAIN_INDICATORS = {
+ IN_WATER: { color: [0, 100, 255], symbol: "💧" },
+ IN_MUD: { color: [101, 67, 33], symbol: "🟫" },
+ ON_SLIPPERY: { color: [200, 230, 255], symbol: "❄️" },
+ ON_ROUGH: { color: [128, 128, 128], symbol: "🗿" }
+ };
+ }
+
+ // --- Public API ---
+
+ /**
+ * Update render controller - called every frame
+ */
+ update() {
+ // Update visual effects
+ this.updateEffects();
+
+ // Update animations (bob, pulse, etc.)
+ this._updateAnimations();
+ }
+
+ /**
+ * Update animation offsets for smooth visual effects
+ */
+ _updateAnimations() {
+ // Update bob, pulse, and spin offsets for smooth animation
+ this._bobOffset += 0.1;
+ this._pulseOffset += 0.08;
+ this._spinOffset += 0.05;
+
+ // Keep offsets in reasonable range
+ if (this._bobOffset > Math.PI * 4) this._bobOffset -= Math.PI * 4;
+ if (this._pulseOffset > Math.PI * 4) this._pulseOffset -= Math.PI * 4;
+ if (this._spinOffset > Math.PI * 4) this._spinOffset -= Math.PI * 4;
+ }
+
+ // --- Helper Methods ---
+
+ /**
+ * Check if p5.js rendering functions are available
+ * @returns {boolean} True if p5.js functions are accessible
+ */
+ _isP5Available() {
+ return typeof stroke === 'function' &&
+ typeof fill === 'function' &&
+ typeof rect === 'function' &&
+ typeof strokeWeight === 'function' &&
+ typeof noFill === 'function' &&
+ typeof noStroke === 'function';
+ }
+
+ /**
+ * Safe wrapper for p5.js function calls
+ * @param {function} renderFunction - Function containing p5.js calls
+ */
+ _safeRender(renderFunction) {
+ if (!this._isP5Available()) {
+ console.warn('RenderController: p5.js functions not available, skipping render');
+ return;
+ }
+ try {
+ renderFunction();
+ } catch (error) {
+ console.error('RenderController: Render error:', error);
+ }
+ }
+
+ // --- Public API ---
+
+ /**
+ * Main render method - call this every frame
+ */
+ render() {
+ this._safeRender(() => {
+ push();
+ // Set smoothing preference
+ if (this._smoothing) {
+ smooth();
+ } else {
+ noSmooth();
+ }
+
+ // Render the main entity
+ this.renderEntity();
+
+ // Render movement indicators
+ this.renderMovementIndicators();
+
+ // Render highlighting
+ this.renderHighlighting();
+
+ // Render terrain effects indicator
+ this.renderTerrainIndicator();
+
+ // Render state indicators
+ this.renderStateIndicators();
+
+ // Render debug information
+ if (this._debugMode) {
+ this.renderDebugInfo();
+ }
+
+ // Update and render effects
+ this.updateEffects();
+ this.renderEffects();
+
+ // Reset smoothing
+ if (this._smoothing) {
+ smooth();
+ }
+ pop();
+ });
+ }
+
+ /**
+ * Set highlight state
+ * @param {string} type - Highlight type (SELECTED, HOVER, etc.)
+ * @param {number} intensity - Highlight intensity (0-1)
+ */
+ setHighlight(type, intensity = 1.0) {
+ this._highlightState = type;
+ this._highlightIntensity = Math.max(0, Math.min(1, intensity));
+
+ if (type && this.HIGHLIGHT_TYPES[type]) {
+ this._highlightColor = this.HIGHLIGHT_TYPES[type].color;
+ } else {
+ this._highlightColor = null;
+ }
+ }
+
+ /**
+ * Clear highlight
+ */
+ clearHighlight() {
+ this._highlightState = null;
+ this._highlightColor = null;
+ this._highlightIntensity = 1.0;
+ }
+
+ /**
+ * Add visual effect
+ * @param {Object} effect - Effect configuration
+ */
+ addEffect(effect) {
+ const effectId = this.generateEffectId();
+ const enhancedEffect = {
+ id: effectId,
+ createdAt: Date.now(),
+ duration: effect.duration || 1000,
+ ...effect
+ };
+
+ this._effects.push(enhancedEffect);
+ return effectId;
+ }
+
+ /**
+ * Remove effect by ID
+ * @param {string} effectId - Effect ID
+ */
+ removeEffect(effectId) {
+ this._effects = this._effects.filter(effect => effect.id !== effectId);
+ }
+
+ /**
+ * Clear all effects
+ */
+ clearEffects() {
+ this._effects = [];
+ }
+
+ /**
+ * Toggle debug rendering
+ * @param {boolean} enabled - Debug mode enabled
+ */
+ setDebugMode(enabled) {
+ this._debugMode = enabled;
+ }
+
+ /**
+ * Set smoothing preference
+ * @param {boolean} enabled - Smoothing enabled
+ */
+ setSmoothing(enabled) {
+ this._smoothing = enabled;
+ }
+
+ // --- Convenience Methods ---
+
+ /**
+ * Highlight entity as selected
+ */
+ highlightSelected() {
+ this.setHighlight("SELECTED");
+ }
+
+ /**
+ * Highlight entity as hovered
+ */
+ highlightHover() {
+ // Debug: log when highlight is set
+ if (this._entity._debugger && this._entity._debugger.isActive) {
+ logNormal(`[RenderController.highlightHover] ${this._entity.type || 'Entity'} highlight set to HOVER`);
+ console.trace('Called from:');
+ }
+ this.setHighlight("HOVER");
+ }
+
+ /**
+ * Highlight entity as box hovered
+ */
+ highlightBoxHover() {
+ this.setHighlight("BOX_HOVERED");
+ // Convert world position to screen position before rendering
+ const worldPos = this.getEntityPosition();
+ const screenPos = this.worldToScreenPosition(worldPos);
+ this.renderOutlineHighlight(screenPos, this.getEntitySize(), this._highlightColor, 2);
+ }
+
+ /**
+ * Highlight entity in combat
+ */
+ highlightCombat() {
+ this.setHighlight("COMBAT");
+ }
+
+ highlightResource() {
+ this.setHighlight("RESOURCE");
+ }
+
+ highlightSpin() {
+ this.setHighlight("SPINNING");
+ }
+
+ highlightSlowSpin() {
+ this.setHighlight("SLOW_SPINNING");
+ }
+
+ highlightFastSpin() {
+ this.setHighlight("FAST_SPINNING");
+ }
+
+ /**
+ * Add damage number effect
+ * @param {number} damage - Damage amount
+ * @param {Array} color - Text color [r, g, b]
+ */
+ showDamageNumber(damage, color = [255, 0, 0]) {
+ const pos = this.getEntityCenter();
+ this.addEffect({
+ type: "DAMAGE_NUMBER",
+ text: `-${damage}`,
+ position: { x: pos.x, y: pos.y - 10 },
+ color: color,
+ velocity: { x: 0, y: .5 },
+ duration: 1500,
+ fadeOut: true
+ });
+ }
+
+ /**
+ * Add heal number effect
+ * @param {number} heal - Heal amount
+ */
+ showHealNumber(heal) {
+ this.showDamageNumber(heal, [0, 255, 0]);
+ }
+
+ /**
+ * Add floating text effect
+ * @param {string} text - Text to display
+ * @param {Array} color - Text color
+ */
+ showFloatingText(text, color = [255, 255, 255]) {
+ const pos = this.getEntityCenter();
+ this.addEffect({
+ type: "FLOATING_TEXT",
+ text: text,
+ position: { x: pos.x, y: pos.y - 20 },
+ color: color,
+ velocity: { x: 0, y: 1 },
+ duration: 2000,
+ fadeOut: true
+ });
+ }
+
+ // --- Private Rendering Methods ---
+
+ /**
+ * Render the main entity (sprite)
+ */
+ renderEntity() {
+ // Render using entity's sprite if available
+ if (this._entity._sprite && this._entity._sprite.render) {
+ this._entity._sprite.render();
+ } else {
+ // Fallback rendering
+ this.renderFallbackEntity();
+ }
+ }
+
+ /**
+ * Fallback entity rendering if no sprite system
+ */
+ renderFallbackEntity() {
+ const pos = this.getEntityPosition();
+ const size = this.getEntitySize();
+
+ // Convert world position to screen position using terrain's coordinate converter
+ let screenX = pos.x;
+ let screenY = pos.y;
+
+ if (typeof g_activeMap !== 'undefined' && g_activeMap && g_activeMap.renderConversion && typeof TILE_SIZE !== 'undefined') {
+ // Convert world pixel position to tile position
+ const tileX = pos.x / TILE_SIZE +0.5;
+ const tileY = pos.y / TILE_SIZE +0.5;
+
+ // Use terrain's converter to get screen position (handles Y-axis inversion)
+ const screenPos = g_activeMap.renderConversion.convPosToCanvas([tileX, tileY]);
+ screenX = screenPos[0];
+ screenY = screenPos[1];
+ }
+
+ this._safeRender(() => {
+ fill(100, 100, 100); // Gray default
+ noStroke();
+ rectMode(CENTER); // Draw from center to match sprite rendering
+ rect(screenX, screenY, size.x, size.y);
+ rectMode(CORNER); // Reset to default
+ });
+ }
+
+ /**
+ * Render movement indicators (lines to target, etc.)
+ */
+ renderMovementIndicators() {
+ // We aren't doing this anymore :)
+ }
+
+ /**
+ * Render highlighting around entity
+ */
+ renderHighlighting() {
+ if (!this._highlightState || !this._highlightColor) {
+ return;
+ }
+
+ const highlightType = this.HIGHLIGHT_TYPES[this._highlightState];
+ if (!highlightType) return;
+
+ const pos = this.getEntityPosition();
+ const screenPos = this.worldToScreenPosition(pos);
+ const size = this.getEntitySize();
+
+ // Apply intensity to color
+ const color = [...this._highlightColor];
+ if (color.length === 4) {
+ color[3] *= this._highlightIntensity;
+ } else {
+ color.push(255 * this._highlightIntensity);
+ }
+
+ switch (highlightType.style) {
+ case "outline":
+ this.renderOutlineHighlight(screenPos, size, color, highlightType.strokeWeight);
+ break;
+ case "pulse":
+ this.renderPulseHighlight(screenPos, size, color, highlightType.strokeWeight);
+ break;
+ case "bob":
+ this.renderBobHighlight(screenPos, size, color, highlightType.strokeWeight);
+ break;
+ case "spin":
+ this.renderSpinHighlight(screenPos, size, color, highlightType.strokeWeight);
+ break;
+ case "slow_spin":
+ this.renderSlowSpinHighlight(screenPos, size, color, highlightType.strokeWeight);
+ break;
+ case "fast_spin":
+ this.renderFastSpinHighlight(screenPos, size, color, highlightType.strokeWeight);
+ break;
+ }
+ }
+
+ /**
+ * Render outline highlight
+ */
+ renderOutlineHighlight(pos, size, color, strokeWeightValue, rotation = 0) {
+ // Ensure p5.js functions are available
+ if (typeof stroke !== 'function' || typeof strokeWeight !== 'function') {
+ console.warn('RenderController: p5.js functions not available');
+ return;
+ }
+
+ push(); // Save current transformation matrix
+ stroke(...color);
+ strokeWeight(strokeWeightValue);
+ noFill();
+
+ // pos is screen top-left position, but sprite renders centered
+ // Translate to center and draw rect centered (matching imageMode(CENTER) in Sprite2D)
+ translate(pos.x + size.x / 2, pos.y + size.y / 2);
+ rotate(rotation);
+ rectMode(CENTER);
+ rect(0, 0, size.x + strokeWeightValue * 2, size.y + strokeWeightValue * 2);
+
+ noStroke();
+ pop(); // Restore transformation matrix
+ }
+
+ /**
+ * Render pulsing highlight
+ */
+ renderPulseHighlight(pos, size, color, strokeWeight) {
+ const time = Date.now() * 0.005 + this._pulseOffset;
+ const pulse = Math.sin(time) * 0.3 + 0.7; // 0.4 to 1.0
+
+ const pulsedColor = [...color];
+ if (pulsedColor.length === 4) {
+ pulsedColor[3] *= pulse;
+ } else {
+ pulsedColor.push(255 * pulse);
+ }
+
+ this.renderOutlineHighlight(pos, size, pulsedColor, strokeWeight * pulse);
+ }
+
+ /**
+ * Render bobbing highlight
+ */
+ renderBobHighlight(pos, size, color, strokeWeight) {
+ const time = Date.now() * 0.003 + this._bobOffset;
+ const bob = Math.sin(time) * 2; // ±2 pixels
+
+ const bobbedPos = { x: pos.x, y: pos.y + bob };
+ this.renderOutlineHighlight(bobbedPos, size, color, strokeWeight);
+ }
+
+ /**
+ * Render spinning highlight (normal speed)
+ */
+ renderSpinHighlight(pos, size, color, strokeWeight) {
+ const time = Date.now() * 0.002; // Normal spin speed
+ const rotation = time % (Math.PI * 2);
+
+ const spinPos = { x: pos.x, y: pos.y };
+ this.renderOutlineHighlight(spinPos, size, color, strokeWeight, rotation);
+ }
+
+ /**
+ * Render slow spinning highlight
+ */
+ renderSlowSpinHighlight(pos, size, color, strokeWeight) {
+ const time = Date.now() * 0.001; // Slow spin speed
+ const rotation = time % (Math.PI * 2);
+
+ const spinPos = { x: pos.x, y: pos.y };
+ this.renderOutlineHighlight(spinPos, size, color, strokeWeight, rotation);
+ }
+
+ /**
+ * Render fast spinning highlight
+ */
+ renderFastSpinHighlight(pos, size, color, strokeWeight) {
+ const time = Date.now() * 0.005; // Fast spin speed
+ const rotation = time % (Math.PI * 2);
+
+ const spinPos = { x: pos.x, y: pos.y };
+ this.renderOutlineHighlight(spinPos, size, color, strokeWeight, rotation);
+ }
+
+ /**
+ * Render state indicators (icons, text)
+ */
+ renderStateIndicators() {
+ if (!this._entity._stateMachine) return;
+
+ const currentState = this._entity._stateMachine.primaryState;
+ if (!currentState || currentState === "IDLE") return;
+
+ const indicator = this.STATE_INDICATORS[currentState];
+ if (!indicator) return;
+
+ // Get center position in world coordinates, convert to screen
+ const centerPos = this.getEntityCenter();
+ const screenPos = this.worldToScreenPosition(centerPos);
+
+ // Position indicator above entity (screenPos is already centered)
+ const indicatorX = screenPos.x;
+ const indicatorY = screenPos.y - 15;
+
+ this._safeRender(() => {
+ // Draw background circle
+ fill(0, 0, 0, 100);
+ noStroke();
+ ellipse(indicatorX, indicatorY, 16, 16);
+
+ // Draw state indicator
+ fill(...indicator.color);
+ textAlign(CENTER, CENTER);
+ textSize(10);
+ text(indicator.symbol, indicatorX, indicatorY);
+ });
+ }
+
+ /**
+ * Render terrain effect indicator
+ * Shows visual feedback when terrain is affecting entity movement speed
+ */
+ renderTerrainIndicator() {
+ // Check if entity has state machine (required for terrain modifier)
+ if (!this._entity._stateMachine) return;
+
+ // Get current terrain modifier
+ const terrainModifier = this._entity._stateMachine.terrainModifier;
+
+ // Only show indicator for non-default terrain (when terrain affects movement)
+ if (!terrainModifier || terrainModifier === 'DEFAULT') return;
+
+ // Get indicator configuration for this terrain type
+ const indicator = this.TERRAIN_INDICATORS[terrainModifier];
+ if (!indicator) return;
+
+ // Get center position in world coordinates, convert to screen
+ const centerPos = this.getEntityCenter();
+ const screenPos = this.worldToScreenPosition(centerPos);
+
+ // Render terrain indicator with safe render wrapper
+ this._safeRender(() => {
+ // Position above entity center (screenPos is already centered)
+ const indicatorX = screenPos.x;
+ const indicatorY = screenPos.y - 30; // Position above state indicator (which is at -15)
+
+ // Draw background circle
+ fill(0, 0, 0, 100);
+ noStroke();
+ ellipse(indicatorX, indicatorY, 16, 16);
+
+ // Draw terrain effect icon
+ fill(...indicator.color);
+ textAlign(CENTER, CENTER);
+ textSize(10);
+ text(indicator.symbol, indicatorX, indicatorY);
+ });
+ }
+
+ /**
+ * Render debug information
+ */
+ renderDebugInfo() {
+ if (!this._debugMode) return;
+
+ // Delegate to shared DebugRenderer if available
+ try {
+ if (typeof DebugRenderer !== 'undefined' && DebugRenderer && typeof DebugRenderer.renderEntityDebug === 'function') {
+ DebugRenderer.renderEntityDebug(this._entity);
+ return;
+ }
+
+ // Fallback to legacy behavior if DebugRenderer not available
+ const pos = this.getEntityPosition();
+ const screenPos = this.worldToScreenPosition(pos);
+ const size = this.getEntitySize();
+
+ this._safeRender(() => {
+ // Debug text background
+ fill(0, 0, 0, 150);
+ noStroke();
+ rect(screenPos.x, screenPos.y + size.y + 5, 120, 60);
+
+ // Debug text
+ fill(255);
+ textAlign(LEFT, TOP);
+ textSize(8);
+
+ let debugY = screenPos.y + size.y + 10;
+ const lineHeight = 10;
+
+ // Entity info
+ text(`ID: ${this._entity._antIndex || "unknown"}`, screenPos.x + 2, debugY);
+ debugY += lineHeight;
+
+ // Position
+ text(`Pos: (${Math.round(pos.x)}, ${Math.round(pos.y)})`, screenPos.x + 2, debugY);
+ debugY += lineHeight;
+
+ // State
+ if (this._entity._stateMachine) {
+ const state = this._entity._stateMachine.primaryState || "UNKNOWN";
+ text(`State: ${state}`, screenPos.x + 2, debugY);
+ debugY += lineHeight;
+ }
+
+ // Movement
+ const isMoving = this._entity._movementController ?
+ this._entity._movementController.getIsMoving() :
+ this._entity._isMoving;
+ text(`Moving: ${isMoving ? "YES" : "NO"}`, screenPos.x + 2, debugY);
+ });
+ debugY += lineHeight;
+
+ // Tasks
+ if (this._entity._taskManager) {
+ const taskCount = this._entity._taskManager.getQueueLength();
+ text(`Tasks: ${taskCount}`, screenPos.x + 2, debugY);
+ }
+ } catch (e) {
+ console.warn('RenderController.renderDebugInfo fallback failed', e);
+ }
+ }
+
+ /**
+ * Update all active effects
+ */
+ updateEffects() {
+ const now = Date.now();
+
+ this._effects = this._effects.filter(effect => {
+ const age = now - effect.createdAt;
+
+ // Remove expired effects
+ if (age > effect.duration) {
+ return false;
+ }
+
+ // Update effect properties
+ if (effect.velocity) {
+ effect.position.x += effect.velocity.x;
+ effect.position.y += effect.velocity.y;
+ }
+
+ // Update fade out
+ if (effect.fadeOut) {
+ effect.alpha = 1.0 - (age / effect.duration);
+ }
+
+ return true;
+ });
+ }
+
+ /**
+ * Render all active effects
+ */
+ renderEffects() {
+ this._effects.forEach(effect => {
+ switch (effect.type) {
+ case "DAMAGE_NUMBER":
+ case "FLOATING_TEXT":
+ this.renderTextEffect(effect);
+ break;
+ case "PARTICLE":
+ this.renderParticleEffect(effect);
+ break;
+ // Add more effect types as needed
+ }
+ });
+ }
+
+ /**
+ * Render text effect (damage numbers, floating text)
+ */
+ renderTextEffect(effect) {
+ const alpha = effect.alpha !== undefined ? effect.alpha : 1.0;
+ const color = [...effect.color];
+
+ if (color.length === 3) {
+ color.push(255 * alpha);
+ } else {
+ color[3] *= alpha;
+ }
+
+ // Convert world position to screen position
+ const screenPos = this.worldToScreenPosition(effect.position);
+
+ fill(...color);
+ textAlign(CENTER, CENTER);
+ textSize(effect.size || 12);
+ text(effect.text, screenPos.x, screenPos.y);
+ }
+
+ /**
+ * Render particle effect
+ */
+ renderParticleEffect(effect) {
+ const alpha = effect.alpha !== undefined ? effect.alpha : 1.0;
+ const color = [...effect.color];
+
+ if (color.length === 3) {
+ color.push(255 * alpha);
+ } else {
+ color[3] *= alpha;
+ }
+
+ // Convert world position to screen position
+ const screenPos = this.worldToScreenPosition(effect.position);
+
+ fill(...color);
+ noStroke();
+ ellipse(screenPos.x, screenPos.y, effect.size || 4, effect.size || 4);
+ }
+
+ // --- Helper Methods ---
+
+ /**
+ * Convert world position to screen position using terrain's coordinate system
+ * @param {Object} worldPos - World position {x, y} in pixels
+ * @returns {Object} Screen position {x, y}
+ */
+ worldToScreenPosition(worldPos) {
+ // Use terrain's coordinate system if available (syncs entities with terrain camera)
+ // NOTE: This MUST match the logic in Sprite2d.render() to keep highlights synced with sprites
+ if (typeof g_activeMap !== 'undefined' && g_activeMap && g_activeMap.renderConversion && typeof TILE_SIZE !== 'undefined') {
+ // Convert world pixel position to tile position
+ // Entity position is already tile-centered (+0.5 applied in Entity constructor)
+ const tileX = worldPos.x / TILE_SIZE;
+ const tileY = worldPos.y / TILE_SIZE;
+
+ // Use terrain's converter to get screen position
+ const screenPos = g_activeMap.renderConversion.convPosToCanvas([tileX, tileY]);
+
+ // Return top-left screen position (sprite adds offset to center for rendering)
+ return { x: screenPos[0], y: screenPos[1] };
+ }
+
+ // Fallback: return world position unchanged
+ return { x: worldPos.x, y: worldPos.y };
+ }
+
+ /**
+ * Get entity position
+ * @returns {Object} - Position {x, y}
+ */
+ getEntityPosition() {
+ if (this._entity.getPosition && typeof this._entity.getPosition === 'function') {
+ return this._entity.getPosition();
+ }
+
+ if (this._entity._sprite && this._entity._sprite.pos) {
+ return this._entity._sprite.pos;
+ }
+
+ if (this._entity.posX !== undefined && this._entity.posY !== undefined) {
+ return { x: this._entity.posX, y: this._entity.posY };
+ }
+
+ return { x: 0, y: 0 };
+ }
+
+ /**
+ * Get entity size
+ * @returns {Object} - Size {x, y}
+ */
+ getEntitySize() {
+ if (this._entity.getSize && typeof this._entity.getSize === 'function') {
+ return this._entity.getSize();
+ }
+
+ if (this._entity._sprite && this._entity._sprite.size) {
+ return this._entity._sprite.size;
+ }
+
+ if (this._entity.sizeX !== undefined && this._entity.sizeY !== undefined) {
+ return { x: this._entity.sizeX, y: this._entity.sizeY };
+ }
+
+ return { x: 20, y: 20 }; // Default size
+ }
+
+ /**
+ * Get entity center position
+ * @returns {Object} - Center position {x, y}
+ */
+ getEntityCenter() {
+ const pos = this.getEntityPosition();
+ const size = this.getEntitySize();
+
+ return {
+ x: pos.x + size.x / 2,
+ y: pos.y + size.y / 2
+ };
+ }
+
+ /**
+ * Generate unique effect ID
+ * @returns {string}
+ */
+ generateEffectId() {
+ return `effect_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+ }
+
+ /**
+ * Get debug information
+ * @returns {Object} - Debug info
+ */
+ getDebugInfo() {
+ return {
+ highlightState: this._highlightState,
+ effectCount: this._effects.length,
+ debugMode: this._debugMode,
+ smoothing: this._smoothing,
+ position: this.getEntityPosition(),
+ size: this.getEntitySize(),
+ center: this.getEntityCenter()
+ };
+ }
+
+ // --- Selenium Testing Getters ---
+
+ /**
+ * Get current highlight state (for Selenium validation)
+ * @returns {string|null} Current highlight type
+ */
+ getHighlightState() {
+ return this._highlightState;
+ }
+
+ /**
+ * Get highlight color (for Selenium validation)
+ * @returns {Array|null} Current highlight color [r, g, b, a]
+ */
+ getHighlightColor() {
+ return this._highlightColor ? [...this._highlightColor] : null;
+ }
+
+ /**
+ * Get highlight intensity (for Selenium validation)
+ * @returns {number} Current highlight intensity (0-1)
+ */
+ getHighlightIntensity() {
+ return this._highlightIntensity;
+ }
+
+ /**
+ * Check if highlight is active (for Selenium validation)
+ * @returns {boolean} True if any highlight is active
+ */
+ isHighlighted() {
+ return this._highlightState !== null;
+ }
+
+ /**
+ * Get available highlight types (for Selenium validation)
+ * @returns {Array} Array of available highlight type names
+ */
+ getAvailableHighlights() {
+ return Object.keys(this.HIGHLIGHT_TYPES);
+ }
+
+ /**
+ * Get available state indicators (for Selenium validation)
+ * @returns {Array} Array of available state names
+ */
+ getAvailableStates() {
+ return Object.keys(this.STATE_INDICATORS);
+ }
+
+ /**
+ * Get current entity state from state machine (for Selenium validation)
+ * @returns {string|null} Current entity state
+ */
+ getCurrentEntityState() {
+ if (!this._entity || !this._entity._stateMachine) return null;
+ return this._entity._stateMachine.primaryState || null;
+ }
+
+ /**
+ * Check if state indicator is showing (for Selenium validation)
+ * @returns {boolean} True if state indicator should be visible
+ */
+ isStateIndicatorVisible() {
+ const currentState = this.getCurrentEntityState();
+ return currentState && currentState !== "IDLE" && this.STATE_INDICATORS[currentState];
+ }
+
+ /**
+ * Get expected state indicator symbol (for Selenium validation)
+ * @returns {string|null} Expected symbol for current state
+ */
+ getExpectedStateSymbol() {
+ const currentState = this.getCurrentEntityState();
+ if (!currentState || !this.STATE_INDICATORS[currentState]) return null;
+ return this.STATE_INDICATORS[currentState].symbol;
+ }
+
+ /**
+ * Get visual effects count (for Selenium validation)
+ * @returns {number} Number of active visual effects
+ */
+ getEffectsCount() {
+ return this._effects.length;
+ }
+
+ /**
+ * Get render controller validation data (for Selenium validation)
+ * @returns {Object} Complete validation data for testing
+ */
+ getValidationData() {
+ return {
+ highlightState: this._highlightState,
+ highlightColor: this._highlightColor ? [...this._highlightColor] : null,
+ highlightIntensity: this._highlightIntensity,
+ isHighlighted: this.isHighlighted(),
+ entityState: this.getCurrentEntityState(),
+ isStateIndicatorVisible: this.isStateIndicatorVisible(),
+ expectedStateSymbol: this.getExpectedStateSymbol(),
+ effectsCount: this._effects.length,
+ availableHighlights: this.getAvailableHighlights(),
+ availableStates: this.getAvailableStates(),
+ position: this.getEntityPosition(),
+ size: this.getEntitySize(),
+ timestamp: new Date().toISOString()
+ };
+ }
+}
+
+// Export for Node.js testing
+if (typeof module !== 'undefined' && module.exports) {
+ module.exports = RenderController;
+}
diff --git a/Classes/controllers/SelectionBoxController.js b/Classes/controllers/SelectionBoxController.js
new file mode 100644
index 00000000..be5f211a
--- /dev/null
+++ b/Classes/controllers/SelectionBoxController.js
@@ -0,0 +1,524 @@
+// SelectionBoxController - IIFE implementation with debug delegation
+(function () {
+ function SelectionBoxController(g_mouseController, entities) {
+ if (SelectionBoxController._instance) return SelectionBoxController._instance;
+
+ this._mouse = g_mouseController;
+ this._entities = entities || [];
+
+ this._isSelecting = false;
+ this._selectionStart = null;
+ this._selectionEnd = null;
+ this._selectedEntities = [];
+
+ // Configuration options
+ this._config = {
+ enabled: true,
+ selectionColor: [0, 200, 255], // Cyan
+ strokeWidth: 2,
+ fillAlpha: 30, // 0 = no fill
+ cornerSize: 8,
+ cornerThickness: 3,
+ dragThreshold: 5 // Minimum pixels for selection
+ };
+
+ // Callback system
+ this._callbacks = {
+ onSelectionStart: null,
+ onSelectionUpdate: null,
+ onSelectionEnd: null
+ };
+
+ if (this._mouse) {
+ if (typeof this._mouse.onClick === 'function') this._mouse.onClick((x, y, button) => this.handleClick(x, y, button));
+ if (typeof this._mouse.onDrag === 'function') this._mouse.onDrag((x, y, dx, dy) => this.handleDrag(x, y));
+ if (typeof this._mouse.onRelease === 'function') this._mouse.onRelease((x, y, button) => this.handleRelease(x, y, button));
+ }
+
+ SelectionBoxController._instance = this;
+ }
+
+ SelectionBoxController.getInstance = function (g_mouseController, entities) {
+ if (!SelectionBoxController._instance) SelectionBoxController._instance = new SelectionBoxController(g_mouseController, entities);
+ return SelectionBoxController._instance;
+ };
+
+ /**
+ * registerWithRenderManager
+ * --------------------------
+ * Registers the selection box with RenderManager for rendering and interaction
+ * Handles both drawable and interactive registration in one call
+ */
+ SelectionBoxController.prototype.registerWithRenderManager = function() {
+ if (typeof RenderManager === 'undefined') {
+ console.warn('⚠️ RenderManager not available for SelectionBoxController registration');
+ return false;
+ }
+
+ // Prevent duplicate registration
+ if (!RenderManager._registeredDrawables) RenderManager._registeredDrawables = {};
+
+ // Register interactive drawable (pointer handling)
+ if (!RenderManager._registeredDrawables.selectionBoxInteractive) {
+ const selectionAdapter = {
+ id: 'selection-box-controller',
+ hitTest: function(pointer) { return false; }, // Don't consume all clicks, let UI elements handle first
+ onPointerDown: function(pointer) {
+ try {
+ this.handleClick(pointer.screen.x, pointer.screen.y, 'left');
+ return true;
+ } catch(e) {
+ return false;
+ }
+ }.bind(this),
+ onPointerMove: function(pointer) {
+ try {
+ this.handleDrag(pointer.screen.x, pointer.screen.y);
+ return true;
+ } catch(e) {
+ return false;
+ }
+ }.bind(this),
+ onPointerUp: function(pointer) {
+ try {
+ this.handleRelease(pointer.screen.x, pointer.screen.y, 'left');
+ return true;
+ } catch(e) {
+ return false;
+ }
+ }.bind(this)
+ };
+ RenderManager.addInteractiveDrawable(RenderManager.layers.UI_GAME, selectionAdapter);
+ RenderManager._registeredDrawables.selectionBoxInteractive = true;
+ }
+
+ // Register render drawable (visual drawing)
+ if (!RenderManager._registeredDrawables.selectionBox) {
+ RenderManager.addDrawableToLayer(RenderManager.layers.UI_GAME, this.draw.bind(this));
+ RenderManager._registeredDrawables.selectionBox = true;
+ }
+
+ return true;
+ };
+
+ SelectionBoxController.prototype.handleClick = function (x, y, button) {
+ // Check if selection is enabled
+ if (!this._config.enabled) return;
+
+ // Right-click clears selection
+ if (button === 'right') {
+ this.deselectAll();
+ return;
+ }
+
+ // Convert incoming screen coordinates to world coordinates (camera-aware)
+ var worldPt = this._screenToWorld(x, y);
+ var wx = worldPt.x;
+ var wy = worldPt.y;
+
+ var clicked = false;
+ for (var i = 0; i < this._entities.length; i++) {
+ var entity = this._entities[i];
+ if (SelectionBoxController.isEntityUnderMouse(entity, wx, wy)) {
+ this.deselectAll();
+ entity.isSelected = true;
+ this._selectedEntities = [entity];
+ clicked = true;
+ break;
+ }
+ }
+
+ if (!clicked) {
+ if (this._selectedEntities && this._selectedEntities.length > 0) {
+ if (typeof moveSelectedEntitiesToTile === 'function') moveSelectedEntitiesToTile(wx, wy, typeof TILE_SIZE !== 'undefined' ? TILE_SIZE : 16);
+ }
+ this.deselectAll();
+ this._isSelecting = true;
+ this._selectionStart = createVector(wx, wy);
+ this._selectionEnd = this._selectionStart.copy();
+
+ // Trigger onSelectionStart callback
+ if (this._callbacks.onSelectionStart) {
+ try {
+ this._callbacks.onSelectionStart(wx, wy, []);
+ } catch (e) {
+ console.warn('SelectionBoxController: onSelectionStart callback error', e);
+ }
+ }
+ }
+ try {
+ if ((typeof window !== 'undefined') && (window.TESTING_ENABLED || (window.location && window.location.search && window.location.search.indexOf('test=1') !== -1))) {
+ logNormal('SelectionBoxController.handleClick worldPt=', wx, wy, 'selectionStart=', this._selectionStart && this._selectionStart.x, this._selectionStart && this._selectionStart.y);
+ }
+ } catch (e) {}
+ };
+
+ SelectionBoxController.prototype.handleDrag = function (x, y) {
+ if (this._isSelecting && this._selectionStart) {
+ var worldPt = this._screenToWorld(x, y);
+ this._selectionEnd = createVector(worldPt.x, worldPt.y);
+ var sortedX = [this._selectionStart.x, this._selectionEnd.x].sort(function (a, b) { return a - b; });
+ var sortedY = [this._selectionStart.y, this._selectionEnd.y].sort(function (a, b) { return a - b; });
+ var x1 = sortedX[0], x2 = sortedX[1], y1 = sortedY[0], y2 = sortedY[1];
+
+ // Get entities in selection box
+ var entitiesInBox = [];
+ for (var i = 0; i < this._entities.length; i++) {
+ var inBox = SelectionBoxController.isEntityInBox(this._entities[i], x1, x2, y1, y2);
+ this._entities[i].isBoxHovered = inBox;
+ if (inBox) entitiesInBox.push(this._entities[i]);
+ }
+ }
+ };
+
+ SelectionBoxController.prototype.handleRelease = function (x, y, button) {
+ if (!this._isSelecting) return;
+ this._selectedEntities = [];
+ // ensure release coords are accounted for
+ var worldPt = this._screenToWorld(x, y);
+ if (this._selectionEnd == null) this._selectionEnd = createVector(worldPt.x, worldPt.y);
+ var sortedX = [this._selectionStart.x, this._selectionEnd.x].sort(function (a, b) { return a - b; });
+ var sortedY = [this._selectionStart.y, this._selectionEnd.y].sort(function (a, b) { return a - b; });
+ var x1 = sortedX[0], x2 = sortedX[1], y1 = sortedY[0], y2 = sortedY[1];
+ var dragDistance = dist(x1, y1, x2, y2);
+
+ // Use configurable drag threshold
+ if (dragDistance >= this._config.dragThreshold) {
+ for (var i = 0; i < this._entities.length; i++) {
+ var e = this._entities[i];
+ e.isSelected = SelectionBoxController.isEntityInBox(e, x1, x2, y1, y2);
+ e.isBoxHovered = false;
+ if (e.isSelected) this._selectedEntities.push(e);
+ }
+ }
+
+ // Trigger onSelectionEnd callback
+ if (this._callbacks.onSelectionEnd) {
+ try {
+ var bounds = { x1: x1, y1: y1, x2: x2, y2: y2, width: x2 - x1, height: y2 - y1 };
+ this._callbacks.onSelectionEnd(bounds, this._selectedEntities.slice());
+ } catch (e) {
+ console.warn('SelectionBoxController: onSelectionEnd callback error', e);
+ }
+ }
+
+ try {
+ if ((typeof window !== 'undefined') && (window.TESTING_ENABLED || (window.location && window.location.search && window.location.search.indexOf('test=1') !== -1))) {
+ logNormal('SelectionBoxController.handleRelease selRect=', { x1, x2, y1, y2 }, 'selectedCount=', this._selectedEntities.length);
+ try {
+ // log entity positions
+ var ents = this._entities.map(function(e){ return { idx: e._antIndex || e.antIndex || null, pos: (e.getPosition?e.getPosition():{x:e.posX,y:e.posY}), isSelected: e.isSelected }; });
+ logNormal('SelectionBoxController.entities=', ents);
+ } catch (e) {}
+ }
+ } catch (e) {}
+ this._isSelecting = false;
+ this._selectionStart = null;
+ this._selectionEnd = null;
+ };
+
+ SelectionBoxController.prototype.deselectAll = function () {
+ for (var i = 0; i < this._selectedEntities.length; i++) {
+ var e = this._selectedEntities[i];
+ e.isSelected = false;
+ if (typeof e.isBoxHovered !== 'undefined') e.isBoxHovered = false;
+ }
+ this._selectedEntities = [];
+ if (this._entities && Array.isArray(this._entities)) {
+ for (var j = 0; j < this._entities.length; j++) {
+ if (typeof this._entities[j].isBoxHovered !== 'undefined') this._entities[j].isBoxHovered = false;
+ }
+ }
+ };
+
+ // Public API: return a shallow copy of currently selected entities (wrapper objects)
+ SelectionBoxController.prototype.getSelectedEntities = function () {
+ return Array.isArray(this._selectedEntities) ? this._selectedEntities.slice() : [];
+ };
+
+ // Public API: replace the entities list used for selection tests
+ SelectionBoxController.prototype.setEntities = function (entities) {
+ this._entities = entities || [];
+ };
+
+ // Public API: get the entities list
+ SelectionBoxController.prototype.getEntities = function () {
+ return this._entities;
+ };
+
+ SelectionBoxController.prototype.draw = function () {
+
+ if (this._isSelecting && this._selectionStart && this._selectionEnd) {
+ // Convert world selection coords to screen coords for drawing
+ try {
+ var s1 = this._worldToScreen(this._selectionStart.x, this._selectionStart.y);
+ var s2 = this._worldToScreen(this._selectionEnd.x, this._selectionEnd.y);
+ var rx = Math.min(s1.x, s2.x);
+ var ry = Math.min(s1.y, s2.y);
+ var rw = Math.abs(s2.x - s1.x);
+ var rh = Math.abs(s2.y - s1.y);
+
+ push();
+
+ // Use configurable stroke and fill
+ stroke(this._config.selectionColor[0], this._config.selectionColor[1], this._config.selectionColor[2]);
+ strokeWeight(this._config.strokeWidth);
+
+ if (this._config.fillAlpha > 0) {
+ fill(this._config.selectionColor[0], this._config.selectionColor[1], this._config.selectionColor[2], this._config.fillAlpha);
+ } else {
+ noFill();
+ }
+
+ rect(rx, ry, rw, rh);
+
+ // Draw corner indicators
+ this._drawCornerIndicators(rx, ry, rw, rh);
+
+ pop();
+ } catch (err) {
+ // Fallback: draw using world coords if conversion fails
+ push();
+ stroke(this._config.selectionColor[0], this._config.selectionColor[1], this._config.selectionColor[2]);
+ strokeWeight(this._config.strokeWidth);
+ if (this._config.fillAlpha > 0) {
+ fill(this._config.selectionColor[0], this._config.selectionColor[1], this._config.selectionColor[2], this._config.fillAlpha);
+ } else {
+ noFill();
+ }
+ rect(this._selectionStart.x, this._selectionStart.y, this._selectionEnd.x - this._selectionStart.x, this._selectionEnd.y - this._selectionStart.y);
+ pop();
+ }
+ redraw();
+ }
+
+ if (devConsoleEnabled) {
+ for (var i = 0; i < this._selectedEntities.length; i++) {
+ var entity = this._selectedEntities[i];
+ try {
+ if (entity && typeof entity.getController === 'function') {
+ var rc = entity.getController('render');
+ if (rc && typeof rc.renderDebugInfo === 'function') {
+ rc.renderDebugInfo();
+ continue;
+ }
+ }
+
+ if (typeof DebugRenderer !== 'undefined' && DebugRenderer && typeof DebugRenderer.renderEntityDebug === 'function') {
+ DebugRenderer.renderEntityDebug(entity);
+ continue;
+ }
+
+ var posX = (entity && (entity.posX || entity.x)) || (entity.getPosition && entity.getPosition().x) || 0;
+ var posY = (entity && (entity.posY || entity.y)) || (entity.getPosition && entity.getPosition().y) || 0;
+ push();
+ fill(0, 0, 0, 150);
+ noStroke();
+ rect(posX, posY + 20, 120, 60);
+ fill(255);
+ textSize(8);
+ textAlign(LEFT, TOP);
+ text('ID: ' + (entity && (entity._antIndex || 'unknown')), posX + 2, posY + 24);
+ text('Pos: (' + Math.round(posX) + ', ' + Math.round(posY) + ')', posX + 2, posY + 34);
+ pop();
+ } catch (err) {
+ console.warn('SelectionBoxController debug render failed for entity', entity, err);
+ }
+ }
+ }
+ };
+
+ SelectionBoxController.isEntityInBox = function (entity, x1, x2, y1, y2) {
+ var pos = (entity && typeof entity.getPosition === 'function') ? entity.getPosition() : (entity && entity.sprite && entity.sprite.pos) || { x: (entity && entity.posX) || 0, y: (entity && entity.posY) || 0 };
+ var size = (entity && typeof entity.getSize === 'function') ? entity.getSize() : (entity && entity.sprite && entity.sprite.size) || { x: (entity && entity.sizeX) || 0, y: (entity && entity.sizeY) || 0 };
+ var cx = pos.x + size.x / 2;
+ var cy = pos.y + size.y / 2;
+ return (cx >= x1 && cx <= x2 && cy >= y1 && cy <= y2);
+ };
+
+ SelectionBoxController.isEntityUnderMouse = function (entity, mx, my) {
+ if (entity && typeof entity.isMouseOver === 'function') return entity.isMouseOver(mx, my);
+ var pos = (entity && typeof entity.getPosition === 'function') ? entity.getPosition() : (entity && entity.sprite && entity.sprite.pos) || { x: (entity && entity.posX) || 0, y: (entity && entity.posY) || 0 };
+ var size = (entity && typeof entity.getSize === 'function') ? entity.getSize() : (entity && entity.sprite && entity.sprite.size) || { x: (entity && entity.sizeX) || 0, y: (entity && entity.sizeY) || 0 };
+ return (mx >= pos.x && mx <= pos.x + size.x && my >= pos.y && my <= pos.y + size.y);
+ };
+
+ // Helper: convert screen coords (canvas/client-local) to world coords using camera systems
+ SelectionBoxController.prototype._screenToWorld = function (sx, sy) {
+ try {
+ // Use terrain's coordinate system if available (syncs with terrain camera including Y-axis inversion)
+ if (typeof g_activeMap !== 'undefined' && g_activeMap && g_activeMap.renderConversion &&
+ typeof g_activeMap.renderConversion.convCanvasToPos === 'function' && typeof TILE_SIZE !== 'undefined') {
+ // Use terrain's inverse converter to get tile position from screen coords
+ var tilePos = g_activeMap.renderConversion.convCanvasToPos([sx, sy]);
+
+ // Convert tile position back to world pixel position
+ var worldX = tilePos[0] * TILE_SIZE;
+ var worldY = tilePos[1] * TILE_SIZE;
+
+ return { x: worldX, y: worldY };
+ }
+ } catch (e) { return { x: sx, y: sy }; }
+ };
+
+ // Helper: convert world coords to screen (canvas/client-local) coords
+ SelectionBoxController.prototype._worldToScreen = function (wx, wy) {
+ try {
+ // Use terrain's coordinate system if available (syncs selection box with terrain camera)
+ if (typeof g_activeMap !== 'undefined' && g_activeMap && g_activeMap.renderConversion && typeof TILE_SIZE !== 'undefined') {
+ // Convert pixel position to tile position
+ var tileX = wx / TILE_SIZE;
+ var tileY = wy / TILE_SIZE;
+
+ // Use terrain's converter to get screen position
+ var screenPos = g_activeMap.renderConversion.convPosToCanvas([tileX, tileY]);
+ return { x: Math.round(screenPos[0]), y: Math.round(screenPos[1]) };
+ }
+ } catch (e) { return { x: wx, y: wy }; }
+ };
+
+ /**
+ * Draw corner indicators for the selection box
+ * @param {number} x - Box X position (screen coords)
+ * @param {number} y - Box Y position (screen coords)
+ * @param {number} w - Box width
+ * @param {number} h - Box height
+ * @private
+ */
+ SelectionBoxController.prototype._drawCornerIndicators = function (x, y, w, h) {
+ var cornerSize = this._config.cornerSize;
+ var cornerThickness = this._config.cornerThickness;
+
+ push();
+ stroke(this._config.selectionColor[0], this._config.selectionColor[1], this._config.selectionColor[2]);
+ strokeWeight(cornerThickness);
+ noFill();
+
+ // Top-left corner
+ line(x, y, x + cornerSize, y);
+ line(x, y, x, y + cornerSize);
+
+ // Top-right corner
+ line(x + w - cornerSize, y, x + w, y);
+ line(x + w, y, x + w, y + cornerSize);
+
+ // Bottom-left corner
+ line(x, y + h - cornerSize, x, y + h);
+ line(x, y + h, x + cornerSize, y + h);
+
+ // Bottom-right corner
+ line(x + w - cornerSize, y + h, x + w, y + h);
+ line(x + w, y + h - cornerSize, x + w, y + h);
+
+ pop();
+ };
+
+ /**
+ * Update configuration options
+ * @param {Object} config - Configuration object with any of: enabled, selectionColor, strokeWidth, fillAlpha, cornerSize, cornerThickness, dragThreshold
+ * @returns {SelectionBoxController} this for chaining
+ */
+ SelectionBoxController.prototype.updateConfig = function (config) {
+ if (config && typeof config === 'object') {
+ Object.assign(this._config, config);
+ }
+ return this;
+ };
+
+ /**
+ * Get current configuration
+ * @returns {Object} Current configuration object (copy)
+ */
+ SelectionBoxController.prototype.getConfig = function () {
+ return Object.assign({}, this._config);
+ };
+
+ /**
+ * Set selection callbacks
+ * @param {Object} callbacks - Callbacks object with any of: onSelectionStart, onSelectionUpdate, onSelectionEnd
+ * @returns {SelectionBoxController} this for chaining
+ */
+ SelectionBoxController.prototype.setCallbacks = function (callbacks) {
+ if (callbacks && typeof callbacks === 'object') {
+ if (callbacks.onSelectionStart) this._callbacks.onSelectionStart = callbacks.onSelectionStart;
+ if (callbacks.onSelectionUpdate) this._callbacks.onSelectionUpdate = callbacks.onSelectionUpdate;
+ if (callbacks.onSelectionEnd) this._callbacks.onSelectionEnd = callbacks.onSelectionEnd;
+ }
+ return this;
+ };
+
+ /**
+ * Enable or disable selection functionality
+ * @param {boolean} enabled - Whether selection is enabled
+ * @returns {SelectionBoxController} this for chaining
+ */
+ SelectionBoxController.prototype.setEnabled = function (enabled) {
+ this._config.enabled = !!enabled;
+ return this;
+ };
+
+ /**
+ * Check if selection is currently enabled
+ * @returns {boolean} True if enabled
+ */
+ SelectionBoxController.prototype.isEnabled = function () {
+ return this._config.enabled;
+ };
+
+ /**
+ * Get current selection bounds (during drag or null if not selecting)
+ * @returns {Object|null} Bounds object {x1, y1, x2, y2, width, height} or null
+ */
+ SelectionBoxController.prototype.getSelectionBounds = function () {
+ if (!this._isSelecting || !this._selectionStart || !this._selectionEnd) return null;
+
+ var sortedX = [this._selectionStart.x, this._selectionEnd.x].sort(function (a, b) { return a - b; });
+ var sortedY = [this._selectionStart.y, this._selectionEnd.y].sort(function (a, b) { return a - b; });
+ var x1 = sortedX[0], x2 = sortedX[1], y1 = sortedY[0], y2 = sortedY[1];
+
+ return {
+ x1: x1,
+ y1: y1,
+ x2: x2,
+ y2: y2,
+ width: x2 - x1,
+ height: y2 - y1
+ };
+ };
+
+ /**
+ * Get debug information about selection controller
+ * @returns {Object} Debug info
+ */
+ SelectionBoxController.prototype.getDebugInfo = function () {
+ return {
+ isSelecting: this._isSelecting,
+ isEnabled: this._config.enabled,
+ selectedEntitiesCount: this._selectedEntities.length,
+ totalEntitiesCount: this._entities.length,
+ config: this.getConfig(),
+ hasCallbacks: {
+ onSelectionStart: !!this._callbacks.onSelectionStart,
+ onSelectionUpdate: !!this._callbacks.onSelectionUpdate,
+ onSelectionEnd: !!this._callbacks.onSelectionEnd
+ }
+ };
+ };
+
+ SelectionBoxController.isSelecting = function () {
+ return _isSelecting;
+ }
+
+ // Export
+ // Backwards-compatible property mappings
+ Object.defineProperty(SelectionBoxController.prototype, 'entities', {
+ get: function() { return this._entities; },
+ set: function(val) { this._entities = val || []; }
+ });
+
+ Object.defineProperty(SelectionBoxController.prototype, 'selectedEntities', {
+ get: function() { return this._selectedEntities; }
+ });
+
+ window.SelectionBoxController = SelectionBoxController;
+})();
diff --git a/Classes/controllers/SelectionController.js b/Classes/controllers/SelectionController.js
new file mode 100644
index 00000000..b72a4c19
--- /dev/null
+++ b/Classes/controllers/SelectionController.js
@@ -0,0 +1,376 @@
+/**
+ * SelectionController - Handles selection state, highlighting, and visual feedback
+ */
+class SelectionController {
+ constructor(entity) {
+ this._entity = entity;
+ this._isSelected = false;
+ this._isHovered = false;
+ this._isBoxHovered = false;
+ this._highlightType = "none";
+ this._selectionCallbacks = [];
+ this._selectable = false;
+ this._lastMouseX = -1;
+ this._lastMouseY = -1;
+ this._lastCameraX = undefined;
+ this._lastCameraY = undefined;
+ }
+
+ // --- Public API ---
+
+ /**
+ * Update selection state and highlighting
+ */
+ update() {
+ // Check if camera has moved
+ const cameraX = typeof cameraManager !== 'undefined' ? cameraManager.cameraX : 0;
+ const cameraY = typeof cameraManager !== 'undefined' ? cameraManager.cameraY : 0;
+ const cameraMoved = (cameraX !== this._lastCameraX || cameraY !== this._lastCameraY);
+
+ // Update hover state if mouse moved OR camera moved
+ if (mouseX !== undefined && mouseY !== undefined) {
+ const mouseMoved = (mouseX !== this._lastMouseX || mouseY !== this._lastMouseY);
+ if (mouseMoved || cameraMoved) {
+ this.updateHoverState(mouseX, mouseY);
+ }
+ }
+
+ // Store camera position for next frame
+ this._lastCameraX = cameraX;
+ this._lastCameraY = cameraY;
+
+ // Update highlight type based on current states
+ this.updateHighlightType();
+
+ // Apply highlighting through render controller
+ this.applyHighlighting();
+ }
+
+ // --- Selection Management ---
+
+ /**
+ * Set selection state
+ * @param {boolean} selected - Whether entity is selected
+ */
+ setSelected(selected) {
+ const wasSelected = this._isSelected;
+ this._isSelected = selected;
+
+ if (wasSelected !== selected) {
+ this._onSelectionChange(wasSelected, selected);
+ }
+ }
+
+ /**
+ * Get selection state
+ * @returns {boolean} True if selected
+ */
+ isSelected() {
+ // Debug: log when queried
+
+ return this._isSelected;
+ }
+
+ get selectable() { return this._selectable; }
+ set selectable(value) { this._selectable = value; }
+
+ /**
+ * Set whether entity can be selected
+ * @param {boolean} selectable - Whether entity can be selected
+ */
+ setSelectable(selectable) {
+ this._selectable = selectable;
+ }
+
+ /**
+ * Get whether entity can be selected
+ * @returns {boolean} True if entity can be selected
+ */
+ getSelectable() {
+ return this._selectable;
+ }
+
+ /**
+ * Toggle selection state
+ * @returns {boolean} New selection state
+ */
+ toggleSelection() {
+ this.setSelected(!this._isSelected);
+ return this._isSelected;
+ }
+
+ // --- Hover Management ---
+
+ /**
+ * Set hover state
+ * @param {boolean} hovered - Whether entity is hovered
+ */
+ setHovered(hovered) {
+ // Debug: log when hover state changes
+ if (this._isHovered !== hovered && this._entity._debugger && this._entity._debugger.isActive) {
+ logNormal(`[SelectionController.setHovered] ${this._entity.type || 'Entity'} hover changed: ${this._isHovered} → ${hovered}`);
+ }
+ this._isHovered = hovered;
+ }
+
+ /**
+ * Get hover state
+ * @returns {boolean} True if hovered
+ */
+ isHovered() {
+ return this._isHovered;
+ }
+
+ /**
+ * Set box hover state (for selection box)
+ * @param {boolean} boxHovered - Whether entity is box hovered
+ */
+ setBoxHovered(boxHovered) {
+ this._isBoxHovered = boxHovered;
+ }
+
+ /**
+ * Get box hover state
+ * @returns {boolean} True if box hovered
+ */
+ isBoxHovered() {
+ return this._isBoxHovered;
+ }
+
+ /**
+ * Update hover state based on mouse position
+ * @param {number} mouseX - Mouse X position (screen coordinates)
+ * @param {number} mouseY - Mouse Y position (screen coordinates)
+ */
+ updateHoverState(mouseX, mouseY) {
+ // Only log if mouse has moved
+ const mouseMoved = (mouseX !== this._lastMouseX || mouseY !== this._lastMouseY);
+
+ // Get entity position and size in world pixels
+ const pos = this._entity.getPosition(); // World coords in pixels
+ const size = this._entity.getSize();
+
+ // Convert mouse screen coordinates and entity world coordinates using GridTerrain's coordinate system
+ let isOver = false;
+
+ if (typeof g_activeMap !== 'undefined' && g_activeMap && g_activeMap.renderConversion && typeof TILE_SIZE !== 'undefined') {
+ // Convert screen mouse position to world coordinates
+ const mouseTilePos = g_activeMap.renderConversion.convCanvasToPos([mouseX, mouseY]);
+ const mouseWorldX = mouseTilePos[0] * TILE_SIZE;
+ const mouseWorldY = mouseTilePos[1] * TILE_SIZE;
+
+ // Collision detection happens in WORLD SPACE (where collision box is stored)
+ // Sprite rendering adds +0.5 tiles for visual centering, but collision uses actual stored position
+ // Check if mouse is within entity's collision box bounds
+ isOver = (
+ mouseWorldX >= pos.x &&
+ mouseWorldX <= pos.x + size.x &&
+ mouseWorldY >= pos.y &&
+ mouseWorldY <= pos.y + size.y
+ );
+ } /*else if (this._entity._transformController) {
+ // Fallback: Use TransformController if terrain system not available
+ // TransformController.contains() expects WORLD coordinates, not screen coordinates
+ // Convert screen mouse position to world position
+ let worldMouseX = mouseX;
+ let worldMouseY = mouseY;
+
+ if (typeof CoordinateConverter !== 'undefined' && CoordinateConverter.isAvailable()) {
+ const worldMouse = CoordinateConverter.screenToWorld(mouseX, mouseY);
+ worldMouseX = worldMouse.x;
+ worldMouseY = worldMouse.y;
+ }
+
+ isOver = this._entity._transformController.contains(worldMouseX, worldMouseY);
+ } else {
+ // Final fallback: Direct collision box check with coordinate conversion
+ let worldMouseX = mouseX;
+ let worldMouseY = mouseY;
+
+ if (typeof CoordinateConverter !== 'undefined' && CoordinateConverter.isAvailable()) {
+ const worldMouse = CoordinateConverter.screenToWorld(mouseX, mouseY);
+ worldMouseX = worldMouse.x;
+ worldMouseY = worldMouse.y;
+ }
+
+ // Use collision box directly with converted coords
+ if (this._entity._collisionBox) {
+ isOver = this._entity._collisionBox.contains(worldMouseX, worldMouseY);
+ } else {
+ // Last resort: direct bounds check
+ isOver = (
+ worldMouseX >= pos.x &&
+ worldMouseX <= pos.x + size.x &&
+ worldMouseY >= pos.y &&
+ worldMouseY <= pos.y + size.y
+ );
+ }
+ }
+ */
+ this._lastMouseX = mouseX;
+ this._lastMouseY = mouseY;
+ this.setHovered(isOver);
+ }
+
+ // --- Highlighting ---
+
+ /**
+ * Update highlight type based on current states
+ */
+ updateHighlightType() {
+ if (this._isSelected) {
+ this._highlightType = "selected";
+ } else if (this._isHovered) {
+ this._highlightType = "hover";
+ } else if (this._isBoxHovered) {
+ this._highlightType = "boxHover";
+ } else if (this._entity.isInCombat && this._entity.isInCombat()) {
+ this._highlightType = "combat";
+ } else {
+ this._highlightType = "none";
+ }
+ }
+
+ /**
+ * Get current highlight type
+ * @returns {string} Highlight type
+ */
+ getHighlightType() {
+ return this._highlightType;
+ }
+
+ /**
+ * Apply highlighting through render controller
+ */
+ applyHighlighting() {
+ if (!this._entity._renderController) return;
+
+ switch (this._highlightType) {
+ case "selected":
+ this._entity._renderController.highlightSelected();
+ break;
+ case "hover":
+ this._entity._renderController.highlightHover();
+ break;
+ case "boxHover":
+ this._entity._renderController.highlightBoxHover();
+ break;
+ case "combat":
+ this._entity._renderController.highlightCombat();
+ break;
+ case "none":
+ default:
+ this._entity._renderController.clearHighlight();
+ break;
+ }
+ }
+
+ /**
+ * Force highlight update
+ */
+ updateHighlight() {
+ this.updateHighlightType();
+ this.applyHighlighting();
+ }
+
+ // --- Selection Groups ---
+
+ /**
+ * Add to selection group
+ * @param {Array} selectionGroup - Array to add this entity to
+ */
+ addToGroup(selectionGroup) {
+ if (!selectionGroup.includes(this._entity)) {
+ selectionGroup.push(this._entity);
+ this.setSelected(true);
+ }
+ }
+
+ /**
+ * Remove from selection group
+ * @param {Array} selectionGroup - Array to remove this entity from
+ */
+ removeFromGroup(selectionGroup) {
+ const index = selectionGroup.indexOf(this._entity);
+ if (index !== -1) {
+ selectionGroup.splice(index, 1);
+ this.setSelected(false);
+ }
+ }
+
+ // --- Callbacks ---
+
+ /**
+ * Add selection change callback
+ * @param {Function} callback - Callback function (wasSelected, isSelected)
+ */
+ addSelectionCallback(callback) {
+ this._selectionCallbacks.push(callback);
+ }
+
+ /**
+ * Remove selection change callback
+ * @param {Function} callback - Callback function to remove
+ */
+ removeSelectionCallback(callback) {
+ const index = this._selectionCallbacks.indexOf(callback);
+ if (index !== -1) {
+ this._selectionCallbacks.splice(index, 1);
+ }
+ }
+
+ /**
+ * Handle selection state changes
+ * @param {boolean} wasSelected - Previous selection state
+ * @param {boolean} isSelected - New selection state
+ */
+ _onSelectionChange(wasSelected, isSelected) {
+ // Notify callbacks
+ this._selectionCallbacks.forEach(callback => {
+ try {
+ callback(wasSelected, isSelected);
+ } catch (error) {
+ console.error("Selection callback error:", error);
+ }
+ });
+
+ // Update global selection if available
+ if (antManager) {
+ if (isSelected) {
+ antManager.selectedAnt = this._entity;
+ } else if (antManager.selectedAnt === this._entity) {
+ antManager.selectedAnt = null;
+ }
+ }
+ }
+
+ // --- Utility Methods ---
+
+ /**
+ * Clear all selection states
+ */
+ clearAllStates() {
+ this.setSelected(false);
+ this.setHovered(false);
+ this.setBoxHovered(false);
+ }
+
+ /**
+ * Get debug information
+ * @returns {Object} Debug information
+ */
+ getDebugInfo() {
+ return {
+ isSelected: this._isSelected,
+ isHovered: this._isHovered,
+ isBoxHovered: this._isBoxHovered,
+ highlightType: this._highlightType,
+ callbackCount: this._selectionCallbacks.length
+ };
+ }
+}
+
+// Export for Node.js testing
+if (typeof module !== 'undefined' && module.exports) {
+ module.exports = SelectionController;
+}
\ No newline at end of file
diff --git a/Classes/controllers/TaskManager.js b/Classes/controllers/TaskManager.js
new file mode 100644
index 00000000..85fab271
--- /dev/null
+++ b/Classes/controllers/TaskManager.js
@@ -0,0 +1,614 @@
+/**
+ * TaskManager - Handles task queues, execution, and prioritization
+ * Provides a clean command/task system for entities
+ */
+class TaskManager {
+ constructor(entity) {
+ this._entity = entity;
+ this._taskQueue = [];
+ this._currentTask = null;
+ this._taskHistory = [];
+ this._maxHistorySize = 10;
+
+ // Task priorities (lower number = higher priority)
+ this.TASK_PRIORITIES = {
+ EMERGENCY: 0,
+ HIGH: 1,
+ NORMAL: 2,
+ LOW: 3,
+ IDLE: 4
+ };
+
+ // Task types and their default priorities
+ this.TASK_DEFAULTS = {
+ MOVE: { priority: this.TASK_PRIORITIES.NORMAL, timeout: 5000 },
+ GATHER: { priority: this.TASK_PRIORITIES.NORMAL, timeout: 10000 },
+ BUILD: { priority: this.TASK_PRIORITIES.HIGH, timeout: 15000 },
+ FOLLOW: { priority: this.TASK_PRIORITIES.LOW, timeout: 0 }, // No timeout for follow
+ ATTACK: { priority: this.TASK_PRIORITIES.HIGH, timeout: 3000 },
+ FLEE: { priority: this.TASK_PRIORITIES.EMERGENCY, timeout: 2000 },
+ IDLE: { priority: this.TASK_PRIORITIES.IDLE, timeout: 0 }
+ };
+ }
+
+ // --- Public API ---
+
+ /**
+ * Add a task to the queue
+ * @param {Object} task - Task object {type, priority?, timeout?, ...params}
+ * @returns {string} - Task ID for tracking
+ */
+ addTask(task) {
+ // Validate task
+ if (!task || !task.type) {
+ console.warn("Invalid task - missing type:", task);
+ return null;
+ }
+
+ // Generate unique task ID
+ const taskId = this.generateTaskId();
+
+ // Apply defaults for task type
+ const defaults = this.TASK_DEFAULTS[task.type] || this.TASK_DEFAULTS.IDLE;
+
+ const enhancedTask = {
+ id: taskId,
+ type: task.type,
+ priority: task.priority !== undefined ? task.priority : defaults.priority,
+ timeout: task.timeout !== undefined ? task.timeout : defaults.timeout,
+ createdAt: Date.now(),
+ attempts: 0,
+ maxAttempts: task.maxAttempts || 3,
+ ...task // Include all original task parameters
+ };
+
+ // Add to queue and sort by priority
+ this._taskQueue.push(enhancedTask);
+ this.sortTaskQueue();
+
+ return taskId;
+ }
+
+ /**
+ * Process the task queue - call this every frame
+ */
+ update() {
+ // Check if current task is complete or timed out
+ if (this._currentTask) {
+ if (this.isTaskComplete(this._currentTask) || this.isTaskTimedOut(this._currentTask)) {
+ this.completeCurrentTask();
+ }
+ }
+
+ // Start next task if no current task
+ if (!this._currentTask && this._taskQueue.length > 0) {
+ this.startNextTask();
+ }
+
+ // Update current task
+ if (this._currentTask) {
+ this.updateCurrentTask();
+ }
+
+ // Clean up old history
+ this.cleanupHistory();
+ }
+
+ /**
+ * Clear all tasks
+ */
+ clearAllTasks() {
+ this._taskQueue = [];
+ if (this._currentTask) {
+ this.addToHistory(this._currentTask, "CANCELLED");
+ this._currentTask = null;
+ }
+ }
+
+ /**
+ * Cancel specific task by ID
+ * @param {string} taskId - Task ID to cancel
+ * @returns {boolean} - True if task was found and cancelled
+ */
+ cancelTask(taskId) {
+ // Check current task
+ if (this._currentTask && this._currentTask.id === taskId) {
+ this.addToHistory(this._currentTask, "CANCELLED");
+ this._currentTask = null;
+ return true;
+ }
+
+ // Check queue
+ const index = this._taskQueue.findIndex(task => task.id === taskId);
+ if (index !== -1) {
+ const task = this._taskQueue.splice(index, 1)[0];
+ this.addToHistory(task, "CANCELLED");
+ return true;
+ }
+
+ return false;
+ }
+
+ /**
+ * Get current task
+ * @returns {Object|null} - Current task or null
+ */
+ getCurrentTask() {
+ return this._currentTask;
+ }
+
+ /**
+ * Check if there are pending tasks
+ * @returns {boolean}
+ */
+ hasPendingTasks() {
+ return this._taskQueue.length > 0 || this._currentTask !== null;
+ }
+
+ /**
+ * Get queue length
+ * @returns {number}
+ */
+ getQueueLength() {
+ return this._taskQueue.length;
+ }
+
+ /**
+ * Add high priority emergency task (interrupts current task)
+ * @param {Object} task - Emergency task
+ */
+ addEmergencyTask(task) {
+ task.priority = this.TASK_PRIORITIES.EMERGENCY;
+
+ // If there's a current task, put it back in queue
+ if (this._currentTask && this._currentTask.priority > this.TASK_PRIORITIES.EMERGENCY) {
+ this.pauseCurrentTask();
+ }
+
+ this.addTask(task);
+ }
+
+ // --- Convenience Methods ---
+
+ /**
+ * Add movement task
+ * @param {number} x - Target X
+ * @param {number} y - Target Y
+ * @param {number} priority - Task priority (optional)
+ */
+ moveToTarget(x, y, priority) {
+ return this.addTask({
+ type: "MOVE",
+ x: x,
+ y: y,
+ priority: priority
+ });
+ }
+
+ /**
+ * Add gathering task
+ * @param {Object} target - Resource to gather (optional)
+ */
+ startGathering(target = null) {
+ return this.addTask({
+ type: "GATHER",
+ target: target
+ });
+ }
+
+ /**
+ * Add building task
+ * @param {Object} buildTarget - What to build
+ */
+ startBuilding(buildTarget) {
+ return this.addTask({
+ type: "BUILD",
+ target: buildTarget
+ });
+ }
+
+ /**
+ * Add follow task
+ * @param {Object} target - Entity to follow
+ */
+ followTarget(target) {
+ return this.addTask({
+ type: "FOLLOW",
+ target: target
+ });
+ }
+
+ /**
+ * Add attack task
+ * @param {Object} target - Entity to attack
+ */
+ attackTarget(target) {
+ return this.addTask({
+ type: "ATTACK",
+ target: target,
+ priority: this.TASK_PRIORITIES.HIGH
+ });
+ }
+
+ /**
+ * Add flee task
+ * @param {Object} threat - What to flee from
+ */
+ fleeFrom(threat) {
+ return this.addTask({
+ type: "FLEE",
+ threat: threat,
+ priority: this.TASK_PRIORITIES.EMERGENCY
+ });
+ }
+
+ // --- Private Methods ---
+
+ /**
+ * Generate unique task ID
+ * @returns {string}
+ */
+ generateTaskId() {
+ return `task_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+ }
+
+ /**
+ * Sort task queue by priority
+ */
+ sortTaskQueue() {
+ this._taskQueue.sort((a, b) => {
+ // First sort by priority (lower number = higher priority)
+ if (a.priority !== b.priority) {
+ return a.priority - b.priority;
+ }
+ // If same priority, sort by creation time (FIFO)
+ return a.createdAt - b.createdAt;
+ });
+ }
+
+ /**
+ * Start the next task in the queue
+ */
+ startNextTask() {
+ if (this._taskQueue.length === 0) return;
+
+ this._currentTask = this._taskQueue.shift();
+ this._currentTask.startedAt = Date.now();
+ this._currentTask.attempts++;
+
+ // Execute the task
+ this.executeTask(this._currentTask);
+ }
+
+ /**
+ * Execute a task
+ * @param {Object} task - Task to execute
+ */
+ executeTask(task) {
+ try {
+ switch (task.type) {
+ case "MOVE":
+ this.executeMoveTask(task);
+ break;
+ case "GATHER":
+ this.executeGatherTask(task);
+ break;
+ case "BUILD":
+ this.executeBuildTask(task);
+ break;
+ case "FOLLOW":
+ this.executeFollowTask(task);
+ break;
+ case "ATTACK":
+ this.executeAttackTask(task);
+ break;
+ case "FLEE":
+ this.executeFleeTask(task);
+ break;
+ case "IDLE":
+ this.executeIdleTask(task);
+ break;
+ default:
+ console.warn(`Unknown task type: ${task.type}`);
+ this.completeCurrentTask("FAILED");
+ }
+ } catch (error) {
+ console.error(`Error executing task ${task.type}:`, error);
+ this.completeCurrentTask("ERROR");
+ }
+ }
+
+ /**
+ * Execute movement task
+ * @param {Object} task - Move task
+ */
+ executeMoveTask(task) {
+ if (task.x === undefined || task.y === undefined) {
+ console.warn("Move task missing coordinates:", task);
+ this.completeCurrentTask("FAILED");
+ return;
+ }
+
+ // Use entity's movement controller if available
+ if (this._entity._movementController) {
+ const success = this._entity._movementController.moveToLocation(task.x, task.y);
+ if (!success) {
+ this.completeCurrentTask("FAILED");
+ }
+ } else if (this._entity.moveToLocation) {
+ // Fallback to entity's direct method
+ this._entity.moveToLocation(task.x, task.y);
+ } else {
+ console.warn("Entity has no movement capability");
+ this.completeCurrentTask("FAILED");
+ }
+
+ // Update entity state machine if available
+ if (this._entity._stateMachine && this._entity._stateMachine.canPerformAction("move")) {
+ this._entity._stateMachine.setPrimaryState("MOVING");
+ }
+ }
+
+ /**
+ * Execute gather task
+ * @param {Object} task - Gather task
+ */
+ executeGatherTask(task) {
+ if (this._entity._stateMachine && this._entity._stateMachine.canPerformAction("gather")) {
+ this._entity._stateMachine.setPrimaryState("GATHERING");
+ // Add specific gathering logic here
+ } else {
+ this.completeCurrentTask("FAILED");
+ }
+ }
+
+ /**
+ * Execute build task
+ * @param {Object} task - Build task
+ */
+ executeBuildTask(task) {
+ if (this._entity._stateMachine && this._entity._stateMachine.canPerformAction("build")) {
+ this._entity._stateMachine.setPrimaryState("BUILDING");
+ // Add specific building logic here
+ } else {
+ this.completeCurrentTask("FAILED");
+ }
+ }
+
+ /**
+ * Execute follow task
+ * @param {Object} task - Follow task
+ */
+ executeFollowTask(task) {
+ if (this._entity._stateMachine && this._entity._stateMachine.canPerformAction("follow")) {
+ this._entity._stateMachine.setPrimaryState("FOLLOWING");
+ // Add following logic here - would need to track target position
+ } else {
+ this.completeCurrentTask("FAILED");
+ }
+ }
+
+ /**
+ * Execute attack task
+ * @param {Object} task - Attack task
+ */
+ executeAttackTask(task) {
+ if (this._entity._stateMachine) {
+ this._entity._stateMachine.setCombatModifier("IN_COMBAT");
+ this._entity._stateMachine.setPrimaryState("ATTACKING");
+ // Add combat logic here
+ } else {
+ this.completeCurrentTask("FAILED");
+ }
+ }
+
+ /**
+ * Execute flee task
+ * @param {Object} task - Flee task
+ */
+ executeFleeTask(task) {
+ if (this._entity._stateMachine && this._entity._stateMachine.canPerformAction("move")) {
+ this._entity._stateMachine.setPrimaryState("FLEEING");
+ // Calculate flee direction and move
+ // This would need to be implemented based on threat position
+ } else {
+ this.completeCurrentTask("FAILED");
+ }
+ }
+
+ /**
+ * Execute idle task
+ * @param {Object} task - Idle task
+ */
+ executeIdleTask(task) {
+ if (this._entity._stateMachine) {
+ this._entity._stateMachine.setPrimaryState("IDLE");
+ }
+ // Idle tasks complete immediately
+ this.completeCurrentTask("SUCCESS");
+ }
+
+ /**
+ * Update the current task
+ */
+ updateCurrentTask() {
+ if (!this._currentTask) return;
+
+ // Task-specific update logic can be added here
+ // For now, most tasks are handled by state machine and other controllers
+ }
+
+ /**
+ * Check if current task is complete
+ * @param {Object} task - Task to check
+ * @returns {boolean}
+ */
+ isTaskComplete(task) {
+ switch (task.type) {
+ case "MOVE":
+ // Movement is complete when entity is not moving
+ return this._entity._movementController ?
+ !this._entity._movementController.getIsMoving() :
+ !this._entity._isMoving;
+
+ case "GATHER":
+ // Gathering is complete when no longer in gathering state
+ return this._entity._stateMachine ?
+ !this._entity._stateMachine.isPrimaryState("GATHERING") :
+ true;
+
+ case "BUILD":
+ // Building is complete when no longer in building state
+ return this._entity._stateMachine ?
+ !this._entity._stateMachine.isPrimaryState("BUILDING") :
+ true;
+
+ case "FOLLOW":
+ // Follow tasks don't auto-complete unless cancelled
+ return false;
+
+ case "ATTACK":
+ // Attack complete when out of combat
+ return this._entity._stateMachine ?
+ this._entity._stateMachine.isOutOfCombat() :
+ true;
+
+ case "FLEE":
+ // Flee complete when no longer fleeing
+ return this._entity._stateMachine ?
+ !this._entity._stateMachine.isPrimaryState("FLEEING") :
+ true;
+
+ case "IDLE":
+ // Idle tasks complete immediately
+ return true;
+
+ default:
+ return true;
+ }
+ }
+
+ /**
+ * Check if task has timed out
+ * @param {Object} task - Task to check
+ * @returns {boolean}
+ */
+ isTaskTimedOut(task) {
+ if (!task.timeout || task.timeout === 0) return false;
+
+ const elapsed = Date.now() - task.startedAt;
+ return elapsed > task.timeout;
+ }
+
+ /**
+ * Complete the current task
+ * @param {string} status - Completion status (SUCCESS, FAILED, TIMEOUT, ERROR)
+ */
+ completeCurrentTask(status = "SUCCESS") {
+ if (!this._currentTask) return;
+
+ this._currentTask.completedAt = Date.now();
+ this._currentTask.status = status;
+
+ // Add to history
+ this.addToHistory(this._currentTask, status);
+
+ // Retry failed tasks if attempts remaining
+ if ((status === "FAILED" || status === "TIMEOUT") &&
+ this._currentTask.attempts < this._currentTask.maxAttempts) {
+
+ // Add back to queue for retry with lower priority
+ this._currentTask.priority = Math.min(this._currentTask.priority + 1, this.TASK_PRIORITIES.LOW);
+ this._taskQueue.push(this._currentTask);
+ this.sortTaskQueue();
+ }
+
+ this._currentTask = null;
+
+ // Ensure idle transition if no more tasks
+ if (this._taskQueue.length === 0) {
+ this.ensureIdleTransition();
+ }
+ }
+
+ /**
+ * Pause current task and return to queue
+ */
+ pauseCurrentTask() {
+ if (!this._currentTask) return;
+
+ // Reset task state
+ delete this._currentTask.startedAt;
+ this._taskQueue.unshift(this._currentTask); // Add to front of queue
+ this._currentTask = null;
+ }
+
+ /**
+ * Ensure entity transitions to idle when appropriate
+ */
+ ensureIdleTransition() {
+ if (this._entity._stateMachine) {
+ const currentPrimary = this._entity._stateMachine.primaryState;
+
+ // Only transition to idle from certain states
+ if (currentPrimary === "MOVING" ||
+ currentPrimary === "GATHERING" ||
+ currentPrimary === "BUILDING" ||
+ currentPrimary === "FOLLOWING") {
+
+ if (this._entity._stateMachine.canPerformAction("move")) {
+ this._entity._stateMachine.setPrimaryState("IDLE");
+ }
+ }
+ }
+ }
+
+ /**
+ * Add task to history
+ * @param {Object} task - Task to add
+ * @param {string} status - Final status
+ */
+ addToHistory(task, status) {
+ this._taskHistory.unshift({
+ ...task,
+ finalStatus: status,
+ historyAddedAt: Date.now()
+ });
+ }
+
+ /**
+ * Clean up old history entries
+ */
+ cleanupHistory() {
+ if (this._taskHistory.length > this._maxHistorySize) {
+ this._taskHistory = this._taskHistory.slice(0, this._maxHistorySize);
+ }
+ }
+
+ /**
+ * Get debug information
+ * @returns {Object} - Debug info
+ */
+ getDebugInfo() {
+ return {
+ currentTask: this._currentTask ? {
+ type: this._currentTask.type,
+ priority: this._currentTask.priority,
+ attempts: this._currentTask.attempts,
+ elapsed: this._currentTask.startedAt ? Date.now() - this._currentTask.startedAt : 0
+ } : null,
+ queueLength: this._taskQueue.length,
+ queueTypes: this._taskQueue.g_map(task => task.type),
+ historyLength: this._taskHistory.length,
+ recentHistory: this._taskHistory.slice(0, 3).g_map(task => ({
+ type: task.type,
+ status: task.finalStatus
+ }))
+ };
+ }
+}
+
+// Export for Node.js testing
+if (typeof module !== 'undefined' && module.exports) {
+ module.exports = TaskManager;
+}
diff --git a/Classes/controllers/TerrainController.js b/Classes/controllers/TerrainController.js
new file mode 100644
index 00000000..738dee0c
--- /dev/null
+++ b/Classes/controllers/TerrainController.js
@@ -0,0 +1,329 @@
+/**
+ * TerrainController - Handles terrain detection and terrain-based state modifications
+ */
+class TerrainController {
+ constructor(entity) {
+ this._entity = entity;
+ this._currentTerrain = "DEFAULT";
+ this._lastPosition = { x: -1, y: -1 };
+ this._terrainCheckInterval = 200; // Check every 200ms for performance
+ this._lastTerrainCheck = 0;
+ this._terrainCache = new Map(); // Cache terrain lookups
+ }
+
+ // --- Public API ---
+
+ /**
+ * Update terrain detection and state
+ */
+ update() {
+ const now = Date.now();
+
+ // Only check terrain periodically or when position changed significantly
+ if (now - this._lastTerrainCheck > this._terrainCheckInterval || this._hasPositionChanged()) {
+ this.detectAndUpdateTerrain();
+ this._lastTerrainCheck = now;
+ this._updateLastPosition();
+ }
+ }
+
+ /**
+ * Get current terrain type
+ * @returns {string} Current terrain modifier
+ */
+ getCurrentTerrain() {
+ return this._currentTerrain;
+ }
+
+ /**
+ * Force terrain detection (useful for immediate updates)
+ */
+ forceTerrainCheck() {
+ this.detectAndUpdateTerrain();
+ this._updateLastPosition();
+ }
+
+ /**
+ * Set terrain check interval
+ * @param {number} interval - Interval in milliseconds
+ */
+ setCheckInterval(interval) {
+ this._terrainCheckInterval = interval;
+ }
+
+ // --- Terrain Detection ---
+
+ /**
+ * Detect terrain at current position and update state if changed
+ */
+ detectAndUpdateTerrain() {
+ const newTerrain = this.detectTerrain();
+
+ if (newTerrain !== this._currentTerrain) {
+ const oldTerrain = this._currentTerrain;
+ this._currentTerrain = newTerrain;
+
+ // Update state machine if available
+ if (this._entity._stateMachine) {
+ this._entity._stateMachine.setTerrainModifier(newTerrain);
+ }
+
+ // Debug logging (enable with window.DEBUG_TERRAIN = true)
+ if (typeof window.DEBUG_TERRAIN !== 'undefined' && window.DEBUG_TERRAIN) {
+ logNormal(`[TerrainController] ${this._entity._type} terrain changed: ${oldTerrain} → ${newTerrain}`, {
+ entityId: this._entity._id,
+ position: this._getEntityPosition()
+ });
+ }
+
+ this._onTerrainChange(oldTerrain, newTerrain);
+ }
+ }
+
+ /**
+ * Detect terrain type at current position
+ * @returns {string} Terrain type
+ */
+ detectTerrain() {
+ // Get entity position
+ const pos = this._getEntityPosition();
+ const cacheKey = `${Math.floor(pos.x / 32)},${Math.floor(pos.y / 32)}`;
+
+ // Check cache first
+ if (this._terrainCache.has(cacheKey)) {
+ return this._terrainCache.get(cacheKey);
+ }
+
+ let terrainType = "DEFAULT";
+
+ // Try MapManager first, fallback to g_activeMap for compatibility
+ let tile = null;
+ let detectionMethod = 'none';
+
+ if (typeof mapManager !== 'undefined' && mapManager.getActiveMap()) {
+ // Use MapManager (preferred)
+ tile = mapManager.getTileAtPosition(pos.x, pos.y);
+ detectionMethod = 'mapManager';
+ } else if (typeof g_activeMap !== 'undefined' && g_activeMap) {
+ // Fallback to direct g_activeMap access
+ try {
+ const tileSize = window.TILE_SIZE || 32;
+ const tileX = Math.round(pos.x / tileSize); // Should be round to align with grid
+ const tileY = Math.round(pos.y / tileSize);
+
+ const chunkX = Math.floor(tileX / g_activeMap._chunkSize);
+ const chunkY = Math.floor(tileY / g_activeMap._chunkSize);
+ const chunk = g_activeMap.chunkArray?.get?.([chunkX, chunkY]);
+
+ if (chunk) {
+ const localX = tileX - (chunkX * g_activeMap._chunkSize);
+ const localY = tileY - (chunkY * g_activeMap._chunkSize);
+ tile = chunk.tileData?.get?.([localX, localY]);
+ }
+ detectionMethod = 'g_activeMap';
+ } catch (error) {
+ console.warn("Terrain detection error:", error);
+ }
+ }
+
+ // Map tile to terrain type
+ if (tile) {
+ terrainType = this._mapTerrainType(tile);
+
+ // Debug logging for first detection
+ if (typeof window.DEBUG_TERRAIN !== 'undefined' && window.DEBUG_TERRAIN && !this._terrainCache.has(cacheKey)) {
+ logNormal(`[TerrainController] Detected terrain:`, {
+ method: detectionMethod,
+ position: pos,
+ tileMaterial: tile.material,
+ terrainType: terrainType
+ });
+ }
+ } else if (typeof window.DEBUG_TERRAIN !== 'undefined' && window.DEBUG_TERRAIN && !this._terrainCache.has(cacheKey)) {
+ console.warn(`[TerrainController] No tile found at position:`, pos, `method: ${detectionMethod}`);
+ }
+
+ // Cache the result
+ this._terrainCache.set(cacheKey, terrainType);
+
+ // Clean cache if it gets too large
+ if (this._terrainCache.size > 100) {
+ const firstKey = this._terrainCache.keys().next().value;
+ this._terrainCache.delete(firstKey);
+ }
+
+ return terrainType;
+ }
+
+ /**
+ * Map terrain tile to terrain modifier
+ * @param {Object} terrainTile - Terrain tile object
+ * @returns {string} Terrain modifier
+ */
+ _mapTerrainType(terrainTile) {
+ // Extract terrain type from Tile object (supports multiple formats for flexibility)
+ const terrainName = terrainTile.material || terrainTile.getName?.() || terrainTile.type || terrainTile._materialSet;
+
+ switch (terrainName?.toLowerCase()) {
+ case "water":
+ case "river":
+ case "lake":
+ return "IN_WATER";
+
+ case "mud":
+ case "moss":
+ case "moss_0":
+ case "moss_1":
+ case "swamp":
+ case "marsh":
+ return "IN_MUD";
+
+ case "ice":
+ case "slippery":
+ return "ON_SLIPPERY";
+
+ case "stone":
+ case "rocks":
+ case "rough":
+ case "mountain":
+ return "ON_ROUGH";
+
+ case "grass":
+ case "dirt":
+ case "default":
+ default:
+ return "DEFAULT";
+ }
+ }
+
+ // --- Terrain Effects ---
+
+ /**
+ * Get movement speed modifier for current terrain
+ * @param {number} baseSpeed - Base movement speed
+ * @returns {number} Modified movement speed
+ */
+ getSpeedModifier(baseSpeed) {
+ switch (this._currentTerrain) {
+ case "IN_WATER":
+ return baseSpeed * 0.5; // 50% speed in water
+ case "IN_MUD":
+ return baseSpeed * 0.3; // 30% speed in mud
+ case "ON_SLIPPERY":
+ return baseSpeed * 1.2; // move very fast on slippery terrain
+ case "ON_ROUGH":
+ return baseSpeed * 0.8; // 80% speed on rough terrain
+ case "DEFAULT":
+ default:
+ return baseSpeed; // Normal speed
+ }
+ }
+
+ /**
+ * Check if current terrain allows movement
+ * @returns {boolean} True if movement is allowed
+ */
+ canMove() {
+ return this._currentTerrain !== "ON_SLIPPERY";
+ }
+
+ /**
+ * Get terrain-specific visual effects
+ * @returns {Object} Visual effects object
+ */
+ getVisualEffects() {
+ switch (this._currentTerrain) {
+ case "IN_WATER":
+ return { ripples: true, colorTint: [0, 100, 200, 50] };
+ case "IN_MUD":
+ return { particles: "mud", colorTint: [139, 69, 19, 30] };
+ case "ON_SLIPPERY":
+ return { sparkles: true, colorTint: [200, 200, 255, 40] };
+ case "ON_ROUGH":
+ return { dustParticles: true };
+ default:
+ return {};
+ }
+ }
+
+ // --- Private Methods ---
+
+ /**
+ * Get entity position
+ * @returns {Object} Position object with x, y
+ */
+ _getEntityPosition() {
+ // Use Entity's public API to get position (delegates to transform controller)
+ return this._entity.getPosition();
+ }
+
+ /**
+ * Check if position has changed significantly
+ * @returns {boolean} True if position changed
+ */
+ _hasPositionChanged() {
+ const pos = this._getEntityPosition();
+ const threshold = 16; // pixels
+
+ return (
+ Math.abs(pos.x - this._lastPosition.x) > threshold ||
+ Math.abs(pos.y - this._lastPosition.y) > threshold
+ );
+ }
+
+ /**
+ * Update last known position
+ */
+ _updateLastPosition() {
+ const pos = this._getEntityPosition();
+ this._lastPosition.x = pos.x;
+ this._lastPosition.y = pos.y;
+ }
+
+ /**
+ * Handle terrain changes
+ * @param {string} oldTerrain - Previous terrain type
+ * @param {string} newTerrain - New terrain type
+ */
+ _onTerrainChange(oldTerrain, newTerrain) {
+ // Override in subclasses or set callback for custom behavior
+ if (this._onTerrainChangeCallback) { this._onTerrainChangeCallback(oldTerrain, newTerrain); }
+ }
+
+ /**
+ * Set callback for terrain changes
+ * @param {Function} callback - Callback function
+ */
+ setTerrainChangeCallback(callback) {
+ this._onTerrainChangeCallback = callback;
+ }
+
+ // --- Utility Methods ---
+
+ /**
+ * Clear terrain cache
+ */
+ clearCache() {
+ this._terrainCache.clear();
+ }
+
+ /**
+ * Get debug information
+ * @returns {Object} Debug information
+ */
+ getDebugInfo() {
+ return {
+ currentTerrain: this._currentTerrain,
+ lastPosition: { ...this._lastPosition },
+ cacheSize: this._terrainCache.size,
+ checkInterval: this._terrainCheckInterval,
+ canMove: this.canMove(),
+ visualEffects: this.getVisualEffects()
+ };
+ }
+}
+
+// Export for Node.js testing
+if (typeof module !== 'undefined' && module.exports) {
+ module.exports = TerrainController;
+}
\ No newline at end of file
diff --git a/Classes/controllers/TransformController.js b/Classes/controllers/TransformController.js
new file mode 100644
index 00000000..8314af9c
--- /dev/null
+++ b/Classes/controllers/TransformController.js
@@ -0,0 +1,309 @@
+/**
+ * TransformController - Handles position, size, rotation, and sprite synchronization
+ */
+class TransformController {
+ constructor(entity) {
+ this._entity = entity;
+ this._isDirty = false; // Track if transform needs sprite update
+
+ // Initialize cached values safely (avoid circular dependency during construction)
+ this._lastPosition = { x: 0, y: 0 };
+ this._lastSize = { x: 32, y: 32 };
+ this._lastRotation = 0;
+
+ // Initialize with collision box values if available
+ if (entity._collisionBox) {
+ this._lastPosition.x = entity._collisionBox.x;
+ this._lastPosition.y = entity._collisionBox.y;
+ this._lastSize.x = entity._collisionBox.width;
+ this._lastSize.y = entity._collisionBox.height;
+ }
+ }
+
+ // --- Public API ---
+
+ /**
+ * Update transform - sync with sprite if dirty
+ */
+ update() {
+ if (this._isDirty) {
+ this.syncSprite();
+ this._isDirty = false;
+ }
+ }
+
+ // --- Position Management ---
+
+ /**
+ * Set position - Called by Entity after collision box is updated
+ * Collision box is already updated by Entity.setPosition() before this is called
+ * @param {number} x - X coordinate in world space (pixels)
+ * @param {number} y - Y coordinate in world space (pixels)
+ */
+ setPosition(x, y) {
+ // Update StatsContainer if available -- NEVER AVAILABLE
+ if (this._entity._stats &&
+ this._entity._stats.position &&
+ this._entity._stats.position.statValue) {
+ this._entity._stats.position.statValue.x = x;
+ this._entity._stats.position.statValue.y = y;
+
+ // console.log("QWERTYUI")
+ }
+
+ // Update cache for dirty flag tracking
+ this._lastPosition.x = x;
+ this._lastPosition.y = y;
+ this._isDirty = true;
+
+ // console.log("QWERTYUI")
+ }
+
+ /**
+ * Get position - CollisionBox is the single source of truth
+ * @returns {Object} Position object with x, y
+ */
+ getPosition() {
+ // CollisionBox is the authoritative source for position
+ if (this._entity._collisionBox) {
+ return {
+ x: this._entity._collisionBox.x,
+ y: this._entity._collisionBox.y
+ };
+ }
+ // Last resort cached value
+ if (this._lastPosition && this._lastPosition.x !== undefined) {
+ return this._lastPosition;
+ }
+ }
+
+ /**
+ * Get center position
+ * @returns {Object} Center position with x, y
+ */
+ getCenter() {
+ const pos = this.getPosition();
+ const size = this.getSize();
+ return {
+ x: pos.x + (size.x / 2),
+ y: pos.y + (size.y / 2)
+ };
+ }
+
+ // --- Size Management ---
+
+ /**
+ * Set size
+ * @param {number} width - Width
+ * @param {number} height - Height
+ */
+ setSize(width, height) {
+ if (this._entity._stats &&
+ this._entity._stats.size &&
+ this._entity._stats.size.statValue) {
+ this._entity._stats.size.statValue.x = width;
+ this._entity._stats.size.statValue.y = height;
+ }
+ this._lastSize.x = width;
+ this._lastSize.y = height;
+ this._isDirty = true;
+ }
+
+ /**
+ * Get size
+ * @returns {Object} Size object with x, y
+ */
+ getSize() {
+ // Try to get from StatsContainer system first
+ if (this._entity._stats && this._entity._stats.size && this._entity._stats.size.statValue) {
+ return this._entity._stats.size.statValue;
+ }
+
+ // Fall back to cached size
+ if (this._lastSize && this._lastSize.x !== undefined) {
+ return this._lastSize;
+ }
+
+ // Final fallback to collision box
+ if (this._entity._collisionBox) {
+ return {
+ x: this._entity._collisionBox.width,
+ y: this._entity._collisionBox.height
+ };
+ }
+
+ // Absolute fallback
+ return { x: 32, y: 32 };
+ }
+
+ // --- Rotation Management ---
+
+ /**
+ * Set rotation
+ * @param {number} rotation - Rotation in degrees
+ */
+ setRotation(rotation) {
+ // Normalize rotation to 0-360 range
+ while (rotation > 360) rotation -= 360;
+ while (rotation < 0) rotation += 360;
+
+ this._lastRotation = rotation;
+ this._isDirty = true;
+ }
+
+ /**
+ * Get rotation
+ * @returns {number} Rotation in degrees
+ */
+ getRotation() {
+ return this._lastRotation;
+ }
+
+ /**
+ * Rotate by delta amount
+ * @param {number} delta - Amount to rotate by in degrees
+ */
+ rotate(delta) {
+ this.setRotation(this._lastRotation + delta);
+ }
+
+ // --- Utility Methods ---
+
+ /**
+ * Check if point is within entity bounds
+ * @param {number} x - X coordinate (ASSUMES WORLD COORDINATES)
+ * @param {number} y - Y coordinate (ASSUMES WORLD COORDINATES)
+ * @returns {boolean} True if point is within bounds
+ */
+ contains(x, y) {
+ const pos = this.getPosition();
+ const size = this.getSize();
+
+ const result = (
+ x >= pos.x &&
+ x <= pos.x + size.x &&
+ y >= pos.y &&
+ y <= pos.y + size.y
+ );
+
+ return result;
+ }
+
+ /**
+ * Get distance to another transform controller or position
+ * @param {TransformController|Object} target - Target with getPosition() or {x, y}
+ * @returns {number} Distance in pixels
+ */
+ getDistanceTo(target) {
+ const thisPos = this.getPosition();
+ const targetPos = target.getPosition ? target.getPosition() : target;
+
+ const dx = thisPos.x - targetPos.x;
+ const dy = thisPos.y - targetPos.y;
+ return Math.sqrt(dx * dx + dy * dy);
+ }
+
+ /**
+ * Move by offset amount
+ * @param {number} deltaX - X offset
+ * @param {number} deltaY - Y offset
+ */
+ translate(deltaX, deltaY) {
+ const pos = this.getPosition();
+ this.setPosition(pos.x + deltaX, pos.y + deltaY);
+ }
+
+ /**
+ * Scale size by factor
+ * @param {number} factor - Scale factor
+ */
+ scale(factor) {
+ const size = this.getSize();
+ this.setSize(size.x * factor, size.y * factor);
+ }
+
+ // --- Sprite Synchronization ---
+
+ /**
+ * Sync transform values with sprite and collision box
+ */
+ syncSprite() {
+ if (!this._entity._sprite) return;
+
+ const pos = this.getPosition();
+ const size = this.getSize();
+
+ // Update sprite position and size
+ this._entity._sprite.setPosition(createVector(pos.x, pos.y));
+ this._entity._sprite.setSize(createVector(size.x, size.y));
+ this._entity._sprite.setRotation(this._lastRotation);
+
+ // Update collision box position and size (synced the same way as sprite)
+ this._entity._collisionBox.setPosition(createVector(pos.x, pos.y));
+ this._entity._collisionBox.setSize(size.x, size.y);
+ }
+
+ /**
+ * Force sprite sync (useful for initialization)
+ */
+ forceSyncSprite() {
+ this._isDirty = true;
+ this.syncSprite();
+ this._isDirty = false;
+ }
+
+ // --- Bounds and Collision ---
+
+ /**
+ * Get bounding box
+ * @returns {Object} Bounding box with x, y, width, height
+ */
+ getBounds() {
+ const pos = this.getPosition();
+ const size = this.getSize();
+
+ return {
+ x: pos.x,
+ y: pos.y,
+ width: size.x,
+ height: size.y
+ };
+ }
+
+ /**
+ * Check if this transform intersects with another
+ * @param {TransformController} other - Other transform controller
+ * @returns {boolean} True if intersecting
+ */
+ intersects(other) {
+ const thisBounds = this.getBounds();
+ const otherBounds = other.getBounds();
+
+ return !(
+ thisBounds.x + thisBounds.width < otherBounds.x ||
+ otherBounds.x + otherBounds.width < thisBounds.x ||
+ thisBounds.y + thisBounds.height < otherBounds.y ||
+ otherBounds.y + otherBounds.height < thisBounds.y
+ );
+ }
+
+ /**
+ * Get debug information
+ * @returns {Object} Debug information
+ */
+ getDebugInfo() {
+ return {
+ position: this.getPosition(),
+ size: this.getSize(),
+ rotation: this.getRotation(),
+ center: this.getCenter(),
+ bounds: this.getBounds(),
+ isDirty: this._isDirty
+ };
+ }
+}
+
+// Export for Node.js testing
+if (typeof module !== 'undefined' && module.exports) {
+ module.exports = TransformController;
+}
\ No newline at end of file
diff --git a/Classes/controllers/UISelectionController.js b/Classes/controllers/UISelectionController.js
new file mode 100644
index 00000000..cd00e90f
--- /dev/null
+++ b/Classes/controllers/UISelectionController.js
@@ -0,0 +1,526 @@
+/**
+ * UISelectionController - Manages click-and-drag selection box functionality
+ * Integrates with EffectsLayerRenderer for rendering to UI effects layer
+ */
+class UISelectionController {
+ constructor(effectsRenderer, g_mouseController, entities) {
+ this.effectsRenderer = effectsRenderer;
+ this.mouseController = g_mouseController;
+
+ // Selection state
+ this.isSelecting = false;
+ this.dragStartPos = null;
+ this.dragThreshold = 5; // Minimum pixels to consider as drag vs click
+
+ // Configuration
+ this.config = {
+ enableSelection: true,
+ selectionColor: [0, 200, 255], // Cyan
+ strokeWidth: 2,
+ fillAlpha: 50,
+ minSelectionSize: 10, // Minimum selection box size
+ fillInside: true
+ };
+
+ // Callbacks
+ this.callbacks = {
+ onSelectionStart: null,
+ onSelectionUpdate: null,
+ onSelectionEnd: null,
+ onSingleClick: null
+ };
+
+ this._entities = entities || [];
+ this.selectableEntities = entities || [];
+
+ this._isSelecting = false;
+ this._selectionStart = null;
+ this._selectionEnd = null;
+ this._selectedEntities = [];
+
+ this.setupMouseHandlers();
+ }
+
+ /**
+ * Set up mouse event handlers
+ * @private
+ */
+ setupMouseHandlers() {
+ if (!this.mouseController) return;
+
+ // Handle mouse press - start potential selection
+ this.mouseController.onClick((x, y, button) => {
+ this.handleMousePressed(x, y, button);
+ });
+
+ // Handle mouse drag - update selection box
+ this.mouseController.onDrag((x, y, dx, dy) => {
+ this.handleMouseDrag(x, y, dx, dy);
+ });
+
+ // Handle mouse release - end selection
+ this.mouseController.onRelease((x, y, button) => {
+ this.handleMouseReleased(x, y, button);
+ });
+ }
+
+ /**
+ * Handle mouse pressed event
+ * @param {number} x - Mouse X position
+ * @param {number} y - Mouse Y position
+ * @param {number|string} button - Mouse button
+ */
+ handleMousePressed(x, y, button) {
+ if (!this.config.enableSelection) return;
+
+ this.dragStartPos = { x, y };
+ this.isSelecting = false; // Don't start selection until drag threshold met
+
+ if (button === 'right') {
+ this.deselectAll();
+ return;
+ }
+
+ var clicked = false;
+ for (var i = 0; i < this._entities.length; i++) {
+ var entity = this._entities[i];
+ if (this.isEntityUnderMouse(entity, x, y)) {
+ this.deselectAll();
+ entity.isSelected = true;
+ this._selectedEntities = [entity];
+ clicked = true;
+ break;
+ }
+ }
+
+ if (!clicked) {
+ if (this._selectedEntities && this._selectedEntities.length > 0) {
+ if (typeof moveSelectedEntitiesToTile === 'function') moveSelectedEntitiesToTile(x, y, typeof TILE_SIZE !== 'undefined' ? TILE_SIZE : 16);
+ }
+ this.deselectAll();
+ this._isSelecting = true;
+ this._selectionStart = createVector(x + cameraX, y + cameraY);
+ this._selectionEnd = this._selectionStart.copy();
+ }
+ }
+
+ /**
+ * Handle mouse drag event
+ * @param {number} x - Current mouse X position
+ * @param {number} y - Current mouse Y position
+ * @param {number} dx - Change in X position
+ * @param {number} dy - Change in Y position
+ */
+ handleMouseDrag(x, y, dx, dy) {
+ if (!this.config.enableSelection || !this.dragStartPos) return;
+
+ const dragDistance = Math.sqrt(
+ Math.pow(x - this.dragStartPos.x, 2) +
+ Math.pow(y - this.dragStartPos.y, 2)
+ );
+
+ // Start selection if drag threshold exceeded
+ if (!this.isSelecting && dragDistance >= this.dragThreshold) {
+ this.startSelection(this.dragStartPos.x, this.dragStartPos.y);
+ }
+
+ // Update selection if active
+ if (this._isSelecting && this._selectionStart) {
+ this._selectionEnd = createVector(x + cameraX, y + cameraY);
+ var sortedX = [this._selectionStart.x, this._selectionEnd.x].sort(function (a, b) { return a - b; });
+ var sortedY = [this._selectionStart.y, this._selectionEnd.y].sort(function (a, b) { return a - b; });
+ var x1 = sortedX[0], x2 = sortedX[1], y1 = sortedY[0], y2 = sortedY[1];
+ for (var i = 0; i < this._entities.length; i++) {
+ this._entities[i].isBoxHovered = this.isEntityInBox(this._entities[i], x1, x2, y1, y2);
+ }
+
+ // Also update effects renderer if available
+ if (this.effectsRenderer) {
+ this.effectsRenderer.updateSelectionBox(x, y);
+ }
+ }
+ }
+
+ isEntityInBox (entity, x1, x2, y1, y2) {
+ var pos = (entity && typeof entity.getPosition === 'function') ? entity.getPosition() : (entity && entity.sprite && entity.sprite.pos) || { x: (entity && entity.posX) || 0, y: (entity && entity.posY) || 0 };
+ var size = (entity && typeof entity.getSize === 'function') ? entity.getSize() : (entity && entity.sprite && entity.sprite.size) || { x: (entity && entity.sizeX) || 0, y: (entity && entity.sizeY) || 0 };
+ var cx = pos.x + size.x / 2;
+ var cy = pos.y + size.y / 2;
+ return (cx >= x1 && cx <= x2 && cy >= y1 && cy <= y2);
+ };
+
+ deselectAll() {
+ for (var i = 0; i < this._selectedEntities.length; i++) {
+ var e = this._selectedEntities[i];
+ e.isSelected = false;
+ if (typeof e.isBoxHovered !== 'undefined') e.isBoxHovered = false;
+ }
+ this._selectedEntities = [];
+ if (this._entities && Array.isArray(this._entities)) {
+ for (var j = 0; j < this._entities.length; j++) {
+ if (typeof this._entities[j].isBoxHovered !== 'undefined') this._entities[j].isBoxHovered = false;
+ }
+ }
+ };
+
+ /**
+ * Handle mouse released event
+ * @param {number} x - Mouse X position
+ * @param {number} y - Mouse Y position
+ * @param {number|string} button - Mouse button
+ */
+ handleMouseReleased(x, y, button) {
+ if (!this.config.enableSelection) return;
+
+ if (this._isSelecting) {
+ // End selection using SelectionBoxController logic
+ this._selectedEntities = [];
+ var sortedX = [this._selectionStart.x, this._selectionEnd.x].sort(function (a, b) { return a - b; });
+ var sortedY = [this._selectionStart.y, this._selectionEnd.y].sort(function (a, b) { return a - b; });
+ var x1 = sortedX[0], x2 = sortedX[1], y1 = sortedY[0], y2 = sortedY[1];
+ var dragDistance = dist(x1, y1, x2, y2);
+ if (dragDistance >= 5) {
+ for (var i = 0; i < this._entities.length; i++) {
+ var e = this._entities[i];
+ e.isSelected = this.isEntityInBox(e, x1, x2, y1, y2);
+ e.isBoxHovered = false;
+ if (e.isSelected) this._selectedEntities.push(e);
+ }
+ }
+ this._isSelecting = false;
+ this._selectionStart = null;
+ this._selectionEnd = null;
+
+ // Also end effects renderer selection if available
+ if (this.effectsRenderer) {
+ this.effectsRenderer.endSelectionBox();
+ }
+
+ // Call end callback
+ if (this.callbacks.onSelectionEnd) {
+ this.callbacks.onSelectionEnd({x1, y1, x2, y2}, this._selectedEntities);
+ }
+ } else if (this.dragStartPos) {
+ // Handle single click (no drag occurred)
+ this.handleSingleClick(x, y, button);
+ }
+
+ this.dragStartPos = null;
+ this.isSelecting = false;
+ }
+
+ /**
+ * Start selection box
+ * @param {number} x - Start X position
+ * @param {number} y - Start Y position
+ * @private
+ */
+ startSelection(x, y) {
+ this.isSelecting = true;
+ this._isSelecting = true;
+ this._selectionStart = createVector(x + cameraX, y + cameraY);
+ this._selectionEnd = this._selectionStart.copy();
+
+ if (this.effectsRenderer) {
+ // Configure effects renderer selection box
+ this.effectsRenderer.setSelectionEntities(this.selectableEntities);
+
+ // Start selection box in effects renderer
+ this.effectsRenderer.startSelectionBox(x, y, {
+ color: this.config.selectionColor,
+ strokeWidth: this.config.strokeWidth,
+ fillAlpha: this.config.fillAlpha,
+ onStart: this.callbacks.onSelectionStart,
+ onUpdate: this.callbacks.onSelectionUpdate,
+ onEnd: null // We'll handle this manually
+ });
+ }
+
+ // Call start callback
+ if (this.callbacks.onSelectionStart) {
+ this.callbacks.onSelectionStart(x, y, []);
+ }
+ }
+
+ /**
+ * Update selection box
+ * @param {number} x - Current X position
+ * @param {number} y - Current Y position
+ * @private
+ */
+ updateSelection(x, y) {
+ if (!this.effectsRenderer) return;
+
+ // Update selection box in effects renderer
+ this.effectsRenderer.updateSelectionBox(x, y);
+
+ // Get current selection bounds and entities
+ const bounds = this.effectsRenderer.getSelectionBoxBounds();
+ const entitiesInBox = this.effectsRenderer.selectionBox.entities || [];
+
+ // Call update callback
+ if (this.callbacks.onSelectionUpdate) {
+ this.callbacks.onSelectionUpdate(bounds, entitiesInBox);
+ }
+ }
+
+ /**
+ * End selection box
+ * @param {number} x - End X position
+ * @param {number} y - End Y position
+ * @private
+ */
+ endSelection(x, y) {
+ if (!this.effectsRenderer) return;
+
+ // Get final selection results
+ const selectedEntities = this.effectsRenderer.endSelectionBox();
+ const bounds = this.effectsRenderer.getSelectionBoxBounds();
+
+ // Update internal selected entities
+ this.selectedEntities = [...selectedEntities];
+
+ // Call end callback
+ if (this.callbacks.onSelectionEnd) {
+ this.callbacks.onSelectionEnd(bounds, this.selectedEntities);
+ }
+ }
+
+ /**
+ * Handle single click (no drag)
+ * @param {number} x - Click X position
+ * @param {number} y - Click Y position
+ * @param {number|string} button - Mouse button
+ * @private
+ */
+ handleSingleClick(x, y, button) {
+ // Check if any entity was clicked
+ const clickedEntity = this.getEntityUnderMouse(x, y);
+
+ if (this.callbacks.onSingleClick) {
+ this.callbacks.onSingleClick(x, y, button, clickedEntity);
+ }
+
+ // Default single click behavior: select/deselect single entity
+ if (clickedEntity) {
+ // Clear previous selections
+ this.selectedEntities = [clickedEntity];
+
+ // Activate entity selection if it has selection methods
+ if (clickedEntity.isSelected !== undefined) {
+ clickedEntity.isSelected = true;
+ }
+ if (typeof clickedEntity.onSelected === 'function') {
+ clickedEntity.onSelected();
+ }
+ } else {
+ this.selectedEntities = [];
+ }
+ }
+
+ /**
+ * Get entity under mouse cursor (using SelectionBoxController logic)
+ * @param {Object} entity - Entity to check
+ * @param {number} mx - Mouse X position
+ * @param {number} my - Mouse Y position
+ * @returns {boolean} True if entity is under mouse
+ * @private
+ */
+ isEntityUnderMouse(entity, mx, my) {
+ if (entity && typeof entity.isMouseOver === 'function') return entity.isMouseOver(mx, my);
+ var pos = (entity && typeof entity.getPosition === 'function') ? entity.getPosition() : (entity && entity.sprite && entity.sprite.pos) || { x: (entity && entity.posX) || 0, y: (entity && entity.posY) || 0 };
+ var size = (entity && typeof entity.getSize === 'function') ? entity.getSize() : (entity && entity.sprite && entity.sprite.size) || { x: (entity && entity.sizeX) || 0, y: (entity && entity.sizeY) || 0 };
+ return (mx >= pos.x && mx <= pos.x + size.x && my >= pos.y && my <= pos.y + size.y);
+ }
+
+ /**
+ * Get entity under mouse cursor
+ * @param {number} x - Mouse X position
+ * @param {number} y - Mouse Y position
+ * @returns {Object|null} Entity under mouse or null
+ * @private
+ */
+ getEntityUnderMouse(x, y) {
+ if (!this.selectableEntities) return null;
+
+ for (const entity of this.selectableEntities) {
+ if (this.isEntityUnderMouse(entity, x, y)) {
+ return entity;
+ }
+ }
+ return null;
+ }
+
+ /**
+ * Check if a point is within an entity's bounds
+ * @param {number} x - Point X position
+ * @param {number} y - Point Y position
+ * @param {Object} entity - Entity to check
+ * @returns {boolean} True if point is within entity
+ * @private
+ */
+ isPointInEntity(x, y, entity) {
+ // Use entity's isMouseOver method if available
+ if (entity && typeof entity.isMouseOver === 'function') {
+ return entity.isMouseOver(x, y);
+ }
+
+ // Fallback to position/size calculation
+ const pos = (entity && typeof entity.getPosition === 'function') ? entity.getPosition() :
+ { x: entity?.posX || entity?.x || 0, y: entity?.posY || entity?.y || 0 };
+
+ const size = (entity && typeof entity.getSize === 'function') ? entity.getSize() :
+ { x: entity?.sizeX || entity?.width || 20, y: entity?.sizeY || entity?.height || 20 };
+
+ return (x >= pos.x && x <= pos.x + size.x &&
+ y >= pos.y && y <= pos.y + size.y);
+ }
+
+ // --- PUBLIC API ---
+
+ /**
+ * Set the entities that can be selected
+ * @param {Array} entities - Array of selectable entities
+ */
+ setSelectableEntities(entities) {
+ this.selectableEntities = entities || [];
+ return this;
+ }
+
+ /**
+ * Get currently selected entities (using internal _selectedEntities)
+ * @returns {Array} Array of selected entities
+ */
+ getSelectedEntities() {
+ return Array.isArray(this._selectedEntities) ? this._selectedEntities.slice() : [];
+ }
+
+ /**
+ * Clear current selection
+ */
+ clearSelection() {
+ this.deselectAll();
+ if (this.effectsRenderer && this.effectsRenderer.selectionBox && this.effectsRenderer.selectionBox.active) {
+ this.effectsRenderer.cancelSelectionBox();
+ }
+ return this;
+ }
+
+ /**
+ * Set selection callbacks
+ * @param {Object} callbacks - Object with callback functions
+ */
+ setCallbacks(callbacks) {
+ Object.assign(this.callbacks, callbacks);
+ return this;
+ }
+
+ /**
+ * Update configuration
+ * @param {Object} config - Configuration options
+ */
+ updateConfig(config) {
+ Object.assign(this.config, config);
+ return this;
+ }
+
+ /**
+ * Enable/disable selection functionality
+ * @param {boolean} enabled - Whether selection is enabled
+ */
+ setEnabled(enabled) {
+ this.config.enableSelection = enabled;
+ return this;
+ }
+
+ /**
+ * Check if selection is currently active
+ * @returns {boolean} True if selection box is active
+ */
+ isSelectionActive() {
+ return this.isSelecting;
+ }
+
+ /**
+ * Get current selection bounds (if selection is active)
+ * @returns {Object|null} Selection bounds or null
+ */
+ getSelectionBounds() {
+ if (!this.effectsRenderer || !this.isSelecting) return null;
+ return this.effectsRenderer.getSelectionBoxBounds();
+ }
+
+ /**
+ * Get debug information
+ * @returns {Object} Debug information
+ */
+ getDebugInfo() {
+ return {
+ isSelecting: this.isSelecting,
+ selectedEntitiesCount: this._selectedEntities.length,
+ selectableEntitiesCount: this.selectableEntities.length,
+ config: { ...this.config },
+ hasEffectsRenderer: !!this.effectsRenderer,
+ hasMouseController: !!this.mouseController
+ };
+ }
+
+ /**
+ * Draw selection box and debug info (transferred from SelectionBoxController)
+ */
+ draw() {
+ // Draw selection box
+ if (this._isSelecting && this._selectionStart && this._selectionEnd) {
+ push();
+ stroke(0, 200, 255);
+ noFill();
+ rect(this._selectionStart.x, this._selectionStart.y, this._selectionEnd.x - this._selectionStart.x, this._selectionEnd.y - this._selectionStart.y);
+ pop();
+ }
+
+ // Draw debug info for selected entities
+ if (typeof devConsoleEnabled !== 'undefined' && devConsoleEnabled) {
+ for (var i = 0; i < this._selectedEntities.length; i++) {
+ var entity = this._selectedEntities[i];
+ try {
+ if (entity && typeof entity.getController === 'function') {
+ var rc = entity.getController('render');
+ if (rc && typeof rc.renderDebugInfo === 'function') {
+ rc.renderDebugInfo();
+ continue;
+ }
+ }
+
+ if (typeof DebugRenderer !== 'undefined' && DebugRenderer && typeof DebugRenderer.renderEntityDebug === 'function') {
+ DebugRenderer.renderEntityDebug(entity);
+ continue;
+ }
+
+ var posX = (entity && (entity.posX || entity.x)) || (entity.getPosition && entity.getPosition().x) || 0;
+ var posY = (entity && (entity.posY || entity.y)) || (entity.getPosition && entity.getPosition().y) || 0;
+ push();
+ fill(0, 0, 0, 150);
+ noStroke();
+ rect(posX, posY + 20, 120, 60);
+ fill(255);
+ textSize(8);
+ textAlign(LEFT, TOP);
+ text('ID: ' + (entity && (entity._antIndex || 'unknown')), posX + 2, posY + 24);
+ text('Pos: (' + Math.round(posX) + ', ' + Math.round(posY) + ')', posX + 2, posY + 34);
+ pop();
+ } catch (err) {
+ console.warn('UISelectionController debug render failed for entity', entity, err);
+ }
+ }
+ }
+ }
+}
+
+// Export for use
+if (typeof window !== 'undefined') {
+ window.UISelectionController = UISelectionController;
+}
+
+if (typeof module !== 'undefined' && module.exports) {
+ module.exports = UISelectionController;
+}
\ No newline at end of file
diff --git a/Classes/controllers/keyboardEventHandlers.js b/Classes/controllers/keyboardEventHandlers.js
new file mode 100644
index 00000000..db374e5c
--- /dev/null
+++ b/Classes/controllers/keyboardEventHandlers.js
@@ -0,0 +1,380 @@
+/**
+ * keyboardEventHandlers.js
+ * =========================
+ * Centralized keyboard event handling for p5.js keyboard events.
+ * All keyboard-related functions extracted from sketch.js for better organization.
+ *
+ * Functions:
+ * - handleKeyEvent() - Helper for delegating to keyboard controller
+ * - keyPressed() - Main key press handler
+ * - deactivateActiveBrushes() - Deactivates active brushes (resource, enemy ant)
+ * - getPrimarySelectedEntity() - Gets the primary selected entity
+ */
+
+/**
+ * handleKeyEvent
+ * --------------
+ * Delegates keyboard events to the appropriate handler if the game is in an active state.
+ * @param {string} type - The key event type (e.g., 'handleKeyPressed').
+ * @param {...any} args - Arguments to pass to the handler.
+ */
+function handleKeyEvent(type, ...args) {
+ if (GameState.isInGame() && typeof g_keyboardController[type] === 'function') {
+ g_keyboardController[type](...args);
+ }
+}
+
+/**
+ * handleQueenMovement
+ * -------------------
+ * Handles WASD queen movement using keyIsDown() for smooth continuous movement
+ * Called from draw() loop for frame-by-frame polling
+ */
+function handleQueenMovement() {
+ const playerQueen = getQueen?.();
+ if (!playerQueen || GameState.getState() !== 'PLAYING') return;
+
+ if (keyIsDown(87)) playerQueen.move("s"); // W
+ if (keyIsDown(65)) playerQueen.move("a"); // A
+ if (keyIsDown(83)) playerQueen.move("w"); // S
+ if (keyIsDown(68)) playerQueen.move("d"); // D
+}
+
+/**
+ * keyPressed
+ * ----------
+ * Handles key press events with priority order:
+ * 1. Level Editor (if active)
+ * 2. Debug console keys
+ * 3. ESC (multi-purpose escape)
+ * 4. UI shortcuts (Ctrl+Shift)
+ * 5. Render layer toggles (Shift+key)
+ * 6. Game controls (no modifier)
+ *
+ * See docs/KEYBINDS_REFERENCE.md for complete keybind documentation
+ */
+function keyPressed() {
+ const k = key.toLowerCase();
+ const isInGame = GameState.isInGame();
+
+ // ========================================
+ // PRIORITY 1: Level Editor Mode
+ // ========================================
+ if (GameState.getState() === 'LEVEL_EDITOR') {
+ if (window.levelEditor?.isActive()) {
+ levelEditor.handleKeyPress(key);
+ }
+ return;
+ }
+
+ // ========================================
+ // PRIORITY 2: Debug Console
+ // ========================================
+ if (typeof handleDebugConsoleKeys === 'function' && handleDebugConsoleKeys(keyCode, key)) {
+ return;
+ }
+
+ // ========================================
+ // PRIORITY 3: ESC - Multi-purpose Escape
+ // ========================================
+ if (keyCode === ESCAPE) {
+ // Order: deselect entities → deactivate brushes → clear selection box
+ if (typeof deselectAllEntities === 'function') deselectAllEntities();
+ if (deactivateActiveBrushes()) return;
+ if (g_selectionBoxController) {
+ g_selectionBoxController.deselectAll();
+ return;
+ }
+ }
+
+ // ========================================
+ // PRIORITY 4: UI Manager Shortcuts (Ctrl+Shift)
+ // ========================================
+ if (window.UIManager?.handleKeyPress) {
+ if (window.UIManager.handleKeyPress(keyCode, key, window.event)) return;
+ }
+
+ // ========================================
+ // PRIORITY 5: Render Layer Toggles (Shift+key)
+ // ========================================
+ if (keyIsDown(SHIFT) && RenderManager?.isInitialized) {
+ const layerMap = {
+ 'c': 'terrain',
+ 'v': 'entities',
+ 'b': 'effects',
+ 'n': 'ui_game',
+ 'm': 'ui_debug',
+ ',': 'ui_menu'
+ };
+
+ if (layerMap[k]) {
+ RenderManager.toggleLayer(layerMap[k]);
+ logVerbose('🔧 Layer States:', RenderManager.getLayerStates());
+ return;
+ }
+
+ if (k === '.') { // Enable all layers
+ RenderManager.enableAllLayers();
+ logVerbose('🔧 All layers enabled');
+ return;
+ }
+
+ if (k === 'z' && typeof toggleSprintImageInMenu !== 'undefined') {
+ toggleSprintImageInMenu();
+ return;
+ }
+ }
+
+ // ========================================
+ // PRIORITY 6: Debug Keys (no modifier)
+ // ========================================
+ if (k === '`' || k === '~') {
+ if (typeof toggleCoordinateDebug === 'function') {
+ toggleCoordinateDebug();
+ return;
+ }
+ }
+
+ if (k === 't') {
+ if (typeof toggleTileInspector === 'function') {
+ toggleTileInspector();
+ return;
+ }
+ }
+
+ if (typeof handleTerrainGridKeys === 'function' && handleTerrainGridKeys()) {
+ return;
+ }
+
+ // ========================================
+ // PRIORITY 7: Game Controls (in-game only)
+ // ========================================
+ if (!isInGame) return;
+
+ // Speed Control (X key)
+ if (k === 'x') {
+ if (window.g_speedUpButton?.changeGameSpeed) {
+ window.g_speedUpButton.changeGameSpeed();
+ return;
+ }
+ }
+
+ // Queen Movement (WASD - continuous polling in draw loop handled separately)
+ // Note: Actual movement is handled in sketch.js draw() via keyIsDown() for smooth continuous movement
+ // This section is for documentation purposes - WASD uses keyIsDown() not keyPressed events
+
+ // Queen Commands (R = rally, Shift+R = reset zoom to avoid conflict)
+ const playerQueen = getQueen();
+ if (playerQueen instanceof QueenAnt) {
+ if (k === 'r' && !keyIsDown(SHIFT)) {
+ playerQueen.emergencyRally();
+ return;
+ }
+ }
+
+ // Camera Controls
+ if (cameraManager) {
+ if (k === 'f') {
+ cameraManager.toggleFollow();
+ return;
+ }
+
+ if (k === 'h') {
+ const mapCenterX = (CHUNKS_X * 8 * TILE_SIZE) / 2;
+ const mapCenterY = (CHUNKS_Y * 8 * TILE_SIZE) / 2;
+ cameraManager.centerOn(mapCenterX, mapCenterY);
+ return;
+ }
+
+ if (k === 'o') {
+ cameraManager.setZoom(0.2);
+ return;
+ }
+
+ if (k === 'r' && keyIsDown(SHIFT)) { // Shift+R for reset zoom (avoid conflict with rally)
+ cameraManager.setZoom(1.0);
+ return;
+ }
+
+ // Zoom controls
+ const currentZoom = cameraManager.getZoom();
+ const ZOOM_STEP = 1.1;
+
+ if (k === '-' || k === '_' || keyCode === 189 || keyCode === 109) {
+ setCameraZoom(currentZoom / ZOOM_STEP);
+ return;
+ }
+
+ if (k === '=' || k === '+' || keyCode === 187 || keyCode === 107) {
+ setCameraZoom(currentZoom * ZOOM_STEP);
+ return;
+ }
+ }
+
+ // Unit Management (U = release ants, Shift+U = upgrade building)
+ if (k === 'u') {
+ if (keyIsDown(SHIFT)) {
+ // Upgrade selected building 10x
+ const selectedEntity = getPrimarySelectedEntity();
+ if (selectedEntity?.upgradeBuilding) {
+ for (let i = 0; i < 10; i++) {
+ selectedEntity.upgradeBuilding();
+ }
+ }
+ } else {
+ // Release ants from all buildings
+ Buildings.forEach(building => building._releaseAnts());
+ }
+ return;
+ }
+
+ // Interaction (E key - NPC/Buildings)
+ if (k === 'e') {
+ // Priority: active NPC → nearby NPC → anthill → dead buildings
+ if (window.currentNPC) {
+ window.currentNPC.advanceDialogue();
+ return;
+ }
+
+ const nearbyNPC = NPCList.find(n => n.isPlayerNearby);
+ if (nearbyNPC) {
+ nearbyNPC.startDialogue(NPCDialogues[nearbyNPC.name.toLowerCase()]);
+ return;
+ }
+
+ const nearbyHill = Buildings.find(b =>
+ // b.isPlayerNearby && (b.buildingType === "anthill") && b._faction === "player" && !b._isDead
+ b.isPlayerNearby && b._faction === "player" && !b._isDead
+ );
+ if (nearbyHill) {
+ if (!window.BUIManager.active) {
+ console.log("Opening Building UI for nearby anthill");
+ window.BUIManager.open(nearbyHill);
+ } else {
+ window.BUIManager.close();
+ }
+ return;
+ }
+
+ const deadBuilding = Buildings.find(b =>
+ b._isDead && b.isPlayerNearby
+ );
+
+ if (deadBuilding) {
+ console.log("Rebuilding dead building via BUIManager");
+ window.BUIManager.rebuild(deadBuilding);
+ return;
+ }else{
+ console.log("No interactable NPC or building nearby.");
+ }
+ }
+
+ // Building UI Manager
+ if (window.BUIManager?.active) {
+ if (window.BUIManager.handleKeyPress(key)) return;
+ }
+
+ // Power Button Shortcuts (1, 2 keys)
+ if (k === '1' || k === '2') {
+ console.log(`🔢 Power button shortcut pressed: ${k}`);
+ console.log(` g_powerButtonPanel exists: ${typeof window.g_powerButtonPanel !== 'undefined'}`);
+
+ if (window.g_powerButtonPanel) {
+ const powerIndex = parseInt(k) - 1;
+ console.log(` Power index: ${powerIndex}`);
+ console.log(` Total buttons: ${window.g_powerButtonPanel.buttons?.length}`);
+
+ const button = window.g_powerButtonPanel.buttons[powerIndex];
+ console.log(` Button found: ${button !== undefined}`);
+
+ if (button && button.controller) {
+ console.log(` Button power: ${button.powerName}`);
+ console.log(` Button position: (${button.view.x}, ${button.view.y})`);
+ // Simulate click at button center
+ const clicked = button.controller.handleClick(button.view.x, button.view.y);
+ console.log(` Click handled: ${clicked}`);
+ return;
+ } else {
+ console.log(` ❌ Button or controller not available`);
+ }
+ } else {
+ console.log(` ❌ g_powerButtonPanel not found on window`);
+ }
+ }
+
+ // Ant Selection Bar Shortcuts (Q, W, F, R, T, U keys)
+ if (k === 'q' || k === 'w' || k === 'f' || k === 'r' || k === 't' || k === 'u') {
+ if (window.g_antSelectionBar) {
+ // Map keys to button indices (Q=Queen, W=Builder, F=Scout, R=Farmer, T=Warrior, U=Spitter)
+ const keyMap = { 'q': 0, 'w': 1, 'f': 2, 'r': 3, 't': 4, 'u': 5 };
+ const buttonIndex = keyMap[k];
+
+ const button = window.g_antSelectionBar.buttons[buttonIndex];
+ if (button) {
+ // Simulate click on button
+ window.g_antSelectionBar._onButtonClick(button);
+ return;
+ }
+ }
+ }
+
+ // Power Brush Manager (3, 4, 5 keys)
+ if (k === '3' || k === '4' || k === '5') {
+ if (window.g_powerBrushManager?.switchPower) {
+ window.g_powerBrushManager.switchPower(key);
+ return;
+ }
+ }
+
+ // Fallback to keyboard controller
+ handleKeyEvent('handleKeyPressed', keyCode, key);
+}
+
+/**
+ * getPrimarySelectedEntity
+ * -------------------------
+ * Retrieves the primary selected entity from the ant manager or the global
+ * selectedAnt variable. This function ensures compatibility with both the
+ * new ant manager system and the legacy global selection.
+ *
+ * @returns {Object|null} - The primary selected entity, or null if none is selected.
+ */
+function getPrimarySelectedEntity() {
+ if (typeof antManager !== 'undefined' &&
+ antManager &&
+ typeof antManager.getSelectedAnt === 'function') {
+ const managed = antManager.getSelectedAnt();
+ if (managed) {
+ return managed;
+ }
+ }
+
+ if (typeof selectedAnt !== 'undefined' && selectedAnt) {
+ return selectedAnt;
+ }
+
+ return null;
+}
+
+/**
+ * deactivateActiveBrushes
+ * -----------------------
+ * Deactivates any active brushes (resource, enemy ant) and logs the action.
+ * Returns true if any brush was deactivated.
+ *
+ * @returns {boolean} - True if any brush was deactivated, false otherwise.
+ */
+function deactivateActiveBrushes() {
+ let deactivated = false;
+ if (typeof g_resourceBrush !== 'undefined' && g_resourceBrush && g_resourceBrush.isActive) {
+ g_resourceBrush.toggle();
+ logNormal('🎨 Resource brush deactivated via ESC key');
+ deactivated = true;
+ }
+ if (typeof g_enemyAntBrush !== 'undefined' && g_enemyAntBrush && g_enemyAntBrush.isActive) {
+ g_enemyAntBrush.toggle();
+ logNormal('🎨 Enemy brush deactivated via ESC key');
+ deactivated = true;
+ }
+ return deactivated;
+}
diff --git a/Classes/controllers/mouseEventHandlers.js b/Classes/controllers/mouseEventHandlers.js
new file mode 100644
index 00000000..42710c59
--- /dev/null
+++ b/Classes/controllers/mouseEventHandlers.js
@@ -0,0 +1,439 @@
+/**
+ * mouseEventHandlers.js
+ * =====================
+ * Centralized mouse event handling for p5.js mouse events.
+ * All mouse-related functions extracted from sketch.js for better organization.
+ *
+ * Functions:
+ * - mousePressed() - Main mouse press handler
+ * - mouseDragged() - Mouse drag handler
+ * - mouseReleased() - Mouse release handler
+ * - mouseMoved() - Mouse move/hover handler
+ * - mouseWheel(event) - Mouse wheel/scroll handler
+ * - handleMouseEvent() - Helper function for delegating to mouse controller
+ */
+
+/**
+ * handleMouseEvent
+ * ----------------
+ * Delegates mouse events to the mouse controller if the game is in an active state.
+ * @param {string} type - The mouse event type (e.g., 'handleMousePressed').
+ * @param {...any} args - Arguments to pass to the controller handler.
+ */
+function handleMouseEvent(type, ...args) {
+ if (GameState.isInGame()) {
+ g_mouseController[type](...args);
+ if (g_activeMap && g_activeMap.renderConversion) {
+ logVerbose(g_activeMap.renderConversion.convCanvasToPos([mouseX,mouseY]));
+ }
+ }
+}
+
+/**
+ * mousePressed
+ * ------------
+ * Handles mouse press events by delegating to the mouse controller.
+ */
+function mousePressed() {
+ // Menu State - handle button clicks first
+ if (GameState.getState() === 'MENU' || GameState.getState() === 'OPTIONS') {
+ if (typeof handleButtonsClick === 'function') {
+ handleButtonsClick();
+ return; // Don't process other mouse events
+ }
+ }
+
+ if (window.g_powerBrushManager && window.g_powerBrushManager.currentBrush != null) {
+ console.log(`current brush: ${window.g_powerBrushManager.currentBrush}`);
+ try {
+ window.g_powerBrushManager.usePower(mouseX, mouseY);
+ } catch (error) {
+ console.error('❌ Error using power brush:', error);
+ }
+ }
+ // Level Editor - handle clicks first if active
+ if (GameState.getState() === 'LEVEL_EDITOR') {
+ if (window.levelEditor && levelEditor.isActive()) {
+ levelEditor.handleClick(mouseX, mouseY);
+ return; // Don't process other mouse events
+ }
+ }
+
+ // Tile Inspector - check first
+ if (typeof tileInspectorEnabled !== 'undefined' && tileInspectorEnabled) {
+ if (typeof inspectTileAtMouse === 'function') {
+ inspectTileAtMouse(mouseX, mouseY);
+ return; // Don't process other mouse events
+ }
+ }
+
+ // Handle UI Debug Manager mouse events first
+ if (typeof g_uiDebugManager !== 'undefined' && g_uiDebugManager && g_uiDebugManager.isActive) {
+ const handled = g_uiDebugManager.handlePointerDown({ x: mouseX, y: mouseY });
+ if (handled) return;
+ }
+
+ // PRIORITY 1: Check active brushes FIRST (before UI elements)
+ // This ensures brush clicks work even if panels are visible
+
+ // Handle Enemy Ant Brush events
+ if (window.g_enemyAntBrush && window.g_enemyAntBrush.isActive) {
+ console.log('🖌️ Checking g_enemyAntBrush (active)');
+ try {
+ const buttonName = mouseButton === LEFT ? 'LEFT' : mouseButton === RIGHT ? 'RIGHT' : 'CENTER';
+ const handled = window.g_enemyAntBrush.onMousePressed(mouseX, mouseY, buttonName);
+ if (handled) {
+ console.log('🛑 g_enemyAntBrush consumed the click - returning early');
+ return; // Brush consumed the event, don't process other mouse events
+ }
+ } catch (error) {
+ console.error('❌ Error handling enemy ant brush events:', error);
+ }
+ }
+
+ // Handle Resource Brush events
+ if (window.g_resourceBrush && window.g_resourceBrush.isActive) {
+ console.log('🖌️ Checking g_resourceBrush (active)');
+ try {
+ const buttonName = mouseButton === LEFT ? 'LEFT' : mouseButton === RIGHT ? 'RIGHT' : 'CENTER';
+ const handled = window.g_resourceBrush.onMousePressed(mouseX, mouseY, buttonName);
+ if (handled) {
+ console.log('🛑 g_resourceBrush consumed the click - returning early');
+ return; // Brush consumed the event, don't process other mouse events
+ }
+ } catch (error) {
+ console.error('❌ Error handling resource brush events:', error);
+ }
+ }
+
+ // Handle Building Brush events
+ if (window.g_buildingBrush && window.g_buildingBrush.isActive) {
+ console.log('🖌️ Checking g_buildingBrush (active)');
+ try {
+ const buttonName = mouseButton === LEFT ? 'LEFT' : mouseButton === RIGHT ? 'RIGHT' : 'CENTER';
+ const handled = window.g_buildingBrush.onMousePressed(mouseX, mouseY, buttonName);
+ if (handled) {
+ console.log('🛑 g_buildingBrush consumed the click - returning early');
+ return; // Brush consumed the event, don't process other mouse events
+ }
+ } catch (error) {
+ console.error('❌ Error handling building brush events:', error);
+ }
+ }
+
+ // Handle Lightning Aim Brush events
+ if (window.g_lightningAimBrush && window.g_lightningAimBrush.isActive) {
+ console.log('🖌️ Checking g_lightningAimBrush (active)');
+ try {
+ const buttonName = mouseButton === LEFT ? 'LEFT' : mouseButton === RIGHT ? 'RIGHT' : 'CENTER';
+ const handled = window.g_lightningAimBrush.onMousePressed(mouseX, mouseY, buttonName);
+ if (handled) {
+ return;
+ }
+ } catch (error) {
+ console.error('❌ Error handling lightning aim brush events:', error);
+ }
+ }
+
+ // Handle Final Flash Aim Brush events
+ if (window.g_flashAimBrush && window.g_flashAimBrush.isActive) {
+ console.log('🖌️ Checking g_flashAimBrush (active)');
+ try {
+ const buttonName = mouseButton === LEFT ? 'LEFT' : mouseButton === RIGHT ? 'RIGHT' : 'CENTER';
+ const handled = window.g_flashAimBrush.onMousePressed(mouseX, mouseY, buttonName);
+ if (handled) {
+ return;
+ }
+ } catch (error) {
+ console.error('❌ Error handling Flash Flash aim brush events:', error);
+ }
+ }
+
+ // Handle Fireball Aim Brush events (charge mechanic)
+ if (window.g_fireballAimBrush && window.g_fireballAimBrush.isActive) {
+ console.log('🖌️ Checking g_fireballAimBrush (active)');
+ try {
+ const buttonName = mouseButton === LEFT ? 'LEFT' : mouseButton === RIGHT ? 'RIGHT' : 'CENTER';
+ const handled = window.g_fireballAimBrush.onMousePressed(mouseX, mouseY, buttonName);
+ if (handled) {
+ return;
+ }
+ } catch (error) {
+ console.error('❌ Error handling Fireball aim brush events:', error);
+ }
+ }
+
+ // Handle Queen Control Panel right-click for power cycling
+ if (window.g_queenControlPanel && mouseButton === RIGHT) {
+ try {
+ const handled = window.g_queenControlPanel.handleRightClick();
+ if (handled) return; // Queen panel consumed the right-click
+ } catch (error) {
+ console.error('❌ Error handling queen control panel right-click:', error);
+ }
+ }
+
+ // PRIORITY 2: RenderManager UI elements (buttons, panels, etc.)
+ // Forward to RenderManager interactive dispatch (gives adapters priority)
+ try {
+ const result = RenderManager.dispatchPointerEvent('pointerdown', { x: mouseX, y: mouseY, isPressed: true });
+ if (result && typeof result === 'object' && result.consumed) {
+ return; // consumed by an interactive (buttons/panels/etc.)
+ } else if (result === true) {
+ return; // consumed by an interactive (buttons/panels/etc.)
+ }
+ // If not consumed, let higher-level systems decide; legacy fallbacks removed in favor of RenderManager adapters.
+ } catch (e) {
+ console.error('Error dispatching pointerdown to RenderManager:', e);
+ try {
+ handleMouseEvent('handleMousePressed', window.getWorldMouseX && window.getWorldMouseX(), window.getWorldMouseY && window.getWorldMouseY(), mouseButton); } catch (er) {}
+ }
+
+ // Legacy mouse controller fallbacks removed - RenderManager should handle UI dispatch.
+
+ // Handle DraggablePanel mouse events
+ if (window.draggablePanelManager &&
+ typeof window.draggablePanelManager.handleMouseEvents === 'function') {
+ try {
+ const handled = window.draggablePanelManager.handleMouseEvents(mouseX, mouseY, true);
+ if (handled) return; // Panel consumed the event, don't process other mouse events
+ } catch (error) {
+ console.error('❌ Error handling draggable panel mouse events:', error);
+ }
+ }
+
+ // Handle Queen Control Panel events
+ if (window.g_queenControlPanel && window.g_queenControlPanel.isQueenSelected()) {
+ try {
+ const handled = window.g_queenControlPanel.handleMouseClick(mouseX, mouseY);
+ if (handled) return; // Queen panel consumed the event, don't process other mouse events
+ } catch (error) {
+ console.error('❌ Error handling queen control panel events:', error);
+ }
+ }
+ handleMouseEvent('handleMousePressed', window.getWorldMouseX(), window.getWorldMouseY(), mouseButton);
+}
+
+/**
+ * mouseDragged
+ * ------------
+ * Handles mouse drag events.
+ */
+function mouseDragged() {
+ // Handle level editor drag events FIRST (before UI debug or RenderManager)
+ if (typeof levelEditor !== 'undefined' && levelEditor.isActive()) {
+ levelEditor.handleDrag(mouseX, mouseY);
+ return; // Don't process other drag events when level editor is active
+ }
+
+ // Handle UI Debug Manager drag events
+ if (typeof g_uiDebugManager !== 'undefined' && g_uiDebugManager !== null && g_uiDebugManager.isActive) {
+ g_uiDebugManager.handlePointerMove({ x: mouseX, y: mouseY });
+ }
+ // Forward move to RenderManager
+ try {
+ const consumed = RenderManager.dispatchPointerEvent('pointermove', { x: mouseX, y: mouseY, isPressed: true });
+ // If not consumed, attempt best-effort legacy notification but prefer RenderManager adapters
+ if (!consumed) {
+ try { handleMouseEvent('handleMouseDragged', mouseX, mouseY); } catch (e) {}
+ }
+ } catch (e) {
+ console.error('Error dispatching pointermove to RenderManager:', e);
+ try { handleMouseEvent('handleMouseDragged', mouseX, mouseY); } catch (er) {}
+ }
+}
+
+/**
+ * mouseReleased
+ * -------------
+ * Handles mouse release events.
+ */
+function mouseReleased() {
+ // Handle level editor release events FIRST
+ if (typeof levelEditor !== 'undefined' && levelEditor.isActive()) {
+ levelEditor.handleMouseRelease(mouseX, mouseY);
+ }
+
+ // Handle UI Debug Manager release events
+ if (typeof g_uiDebugManager !== 'undefined' && g_uiDebugManager && g_uiDebugManager.isActive) {
+ g_uiDebugManager.handlePointerUp({ x: mouseX, y: mouseY });
+ }
+
+ // Handle Enemy Ant Brush release events
+ if (window.g_enemyAntBrush && window.g_enemyAntBrush.isActive) {
+ try {
+ const buttonName = mouseButton === LEFT ? 'LEFT' : mouseButton === RIGHT ? 'RIGHT' : 'CENTER';
+ window.g_enemyAntBrush.onMouseReleased(mouseX, mouseY, buttonName);
+ } catch (error) {
+ console.error('❌ Error handling enemy ant brush release events:', error);
+ }
+ }
+
+ // Handle Resource Brush release events
+ if (window.g_resourceBrush && window.g_resourceBrush.isActive) {
+ try {
+ const buttonName = mouseButton === LEFT ? 'LEFT' : mouseButton === RIGHT ? 'RIGHT' : 'CENTER';
+ window.g_resourceBrush.onMouseReleased(mouseX, mouseY, buttonName);
+ } catch (error) {
+ console.error('❌ Error handling resource brush release events:', error);
+ }
+ }
+
+ // Handle Building Brush release events
+ if (window.g_buildingBrush && window.g_buildingBrush.isActive) {
+ try {
+ const buttonName = mouseButton === LEFT ? 'LEFT' : mouseButton === RIGHT ? 'RIGHT' : 'CENTER';
+ window.g_buildingBrush.onMouseReleased(mouseX, mouseY, buttonName);
+ } catch (error) {
+ console.error('❌ Error handling building brush release events:', error);
+ }
+ }
+
+ // Handle Lightning Aim Brush release events
+ if (window.g_lightningAimBrush && window.g_lightningAimBrush.isActive) {
+ try {
+ const buttonName = mouseButton === LEFT ? 'LEFT' : mouseButton === RIGHT ? 'RIGHT' : 'CENTER';
+ window.g_lightningAimBrush.onMouseReleased(mouseX, mouseY, buttonName);
+ } catch (error) {
+ console.error('❌ Error handling lightning aim brush release events:', error);
+ }
+ }
+
+ //Handle Flash Flash Aim Brush release events
+ if (window.g_flashAimBrush && window.g_flashAimBrush.isActive) {
+ try {
+ const buttonName = mouseButton === LEFT ? 'LEFT' : mouseButton === RIGHT ? 'RIGHT' : 'CENTER';
+ window.g_flashAimBrush.onMouseReleased(mouseX, mouseY, buttonName);
+ } catch (error) {
+ console.error('❌ Error handling Final Flash aim brush release events:', error);
+ }
+ }
+
+ // Handle Fireball Aim Brush release events (fires when fully charged)
+ if (window.g_fireballAimBrush && window.g_fireballAimBrush.isActive) {
+ try {
+ const buttonName = mouseButton === LEFT ? 'LEFT' : mouseButton === RIGHT ? 'RIGHT' : 'CENTER';
+ window.g_fireballAimBrush.onMouseReleased(mouseX, mouseY, buttonName);
+ } catch (error) {
+ console.error('❌ Error handling Fireball aim brush release events:', error);
+ }
+ }
+
+ // Forward to RenderManager first
+ try {
+ const consumed = RenderManager.dispatchPointerEvent('pointerup', { x: mouseX, y: mouseY, isPressed: false });
+ if (!consumed) {
+ try { handleMouseEvent('handleMouseReleased', mouseX, mouseY, mouseButton); } catch (e) {}
+ }
+ } catch (e) {
+ console.error('Error dispatching pointerup to RenderManager:', e);
+ try { handleMouseEvent('handleMouseReleased', mouseX, mouseY, mouseButton); } catch (er) {}
+ }
+}
+
+/**
+ * mouseMoved
+ * ----------
+ * Handles mouse move/hover events for Level Editor.
+ */
+function mouseMoved() {
+ // Handle level editor hover for preview highlighting
+ if (typeof levelEditor !== 'undefined' && levelEditor.isActive()) {
+ levelEditor.handleHover(mouseX, mouseY);
+ }
+}
+
+/**
+ * mouseWheel
+ * ----------
+ * Forward mouse wheel events to active brushes so users can cycle brush types
+ * with the scroll wheel. Prevents default page scrolling while in-game.
+ */
+function mouseWheel(event) {
+ try {
+ // Level Editor - Shift+scroll for brush size, normal scroll for zoom
+ if (GameState.getState() === 'LEVEL_EDITOR') {
+ if (window.levelEditor && levelEditor.isActive()) {
+ const delta = event.deltaY || 0;
+ const shiftPressed = event.shiftKey || keyIsDown(SHIFT);
+
+ // Try brush size adjustment first (if Shift is pressed)
+ if (shiftPressed && levelEditor.handleMouseWheel) {
+ const handled = levelEditor.handleMouseWheel(event, shiftPressed);
+ if (handled) {
+ event.preventDefault();
+ return false;
+ }
+ }
+
+ // Otherwise, handle zoom
+ levelEditor.handleZoom(delta);
+ event.preventDefault();
+ return false;
+ }
+ }
+
+ if (!GameState.isInGame()) return false;
+
+ // Determine scroll direction (positive = down, negative = up)
+ const delta = event.deltaY || 0;
+ const step = (delta > 0) ? 1 : (delta < 0) ? -1 : 0;
+
+ // Helper to call directional cycling on a brush if available
+ const tryCycleDir = (brush) => {
+ if (!brush || !brush.isActive || step === 0) return false;
+ // Preferred: BrushBase-style directional API
+ if (typeof brush.cycleTypeStep === 'function') { brush.cycleTypeStep(step); return true; }
+ if (typeof brush.cycleType === 'function') { brush.cycleType(step); return true; }
+ // Legacy resource brush method
+ if (typeof brush.cycleResourceType === 'function') { if (step > 0) brush.cycleResourceType(); else { /* no backward legacy */ } return true; }
+ // Fallback: adjust availableTypes index if exposed
+ if (Array.isArray(brush.availableTypes) && typeof brush.currentIndex === 'number') {
+ const len = brush.availableTypes.length;
+ brush.currentIndex = ((brush.currentIndex + step) % len + len) % len;
+ brush.currentType = brush.availableTypes[brush.currentIndex];
+ if (typeof brush.onTypeChanged === 'function') { try { brush.onTypeChanged(brush.currentType); } catch(e){} }
+ return true;
+ }
+ return false;
+ };
+
+ // Priority order: Enemy brush, Resource brush, Lightning aim brush, Queen powers
+ if (window.g_enemyAntBrush && tryCycleDir(window.g_enemyAntBrush)) {
+ event.preventDefault();
+ return false;
+ }
+ if (window.g_resourceBrush && tryCycleDir(window.g_resourceBrush)) {
+ event.preventDefault();
+ return false;
+ }
+ if (window.g_lightningAimBrush && tryCycleDir(window.g_lightningAimBrush)) {
+ event.preventDefault();
+ return false;
+ }
+ if (window.g_flashAimBrush && tryCycleDir(window.g_flashAimBrush)) {
+ event.preventDefault();
+ return false;
+ }
+ if (window.g_fireballAimBrush && tryCycleDir(window.g_fireballAimBrush)) {
+ event.preventDefault();
+ return false;
+ }
+
+ // Queen power cycling with mouse wheel
+ if (window.g_queenControlPanel && window.g_queenControlPanel.handleMouseWheel(delta)) {
+ event.preventDefault();
+ return false;
+ }
+
+ // If no brush consumed the event, delegate to CameraManager for zoom (PLAYING state)
+ if (cameraManager && typeof cameraManager.handleMouseWheel === 'function') {
+ return cameraManager.handleMouseWheel(event);
+ }
+
+ } catch (e) {
+ console.error('❌ Error handling mouseWheel for brushes:', e);
+ }
+ // Let other handlers/processes receive the event if no brush consumed it
+ return true;
+}
diff --git a/Classes/controllers/p5EventHandlers.js b/Classes/controllers/p5EventHandlers.js
new file mode 100644
index 00000000..fd34283d
--- /dev/null
+++ b/Classes/controllers/p5EventHandlers.js
@@ -0,0 +1,24 @@
+/**
+ * p5EventHandlers.js
+ * ==================
+ * Additional p5.js lifecycle event handlers.
+ * Handles window resizing and other p5.js events that don't fit in mouse/keyboard categories.
+ */
+
+/**
+ * windowResized
+ * -------------
+ * Called automatically by p5.js when the browser window is resized.
+ * Updates canvas size, map conversions, and invalidates terrain cache.
+ */
+function windowResized() {
+ if (g_activeMap && g_activeMap.renderConversion) {
+ g_activeMap.renderConversion.setCanvasSize([windowWidth, windowHeight]);
+ }
+ g_canvasX = windowWidth;
+ g_canvasY = windowHeight;
+
+ g_activeMap.invalidateCache();
+
+ resizeCanvas(g_canvasX, g_canvasY);
+}
diff --git a/Classes/coordinateSystem.js b/Classes/coordinateSystem.js
deleted file mode 100644
index c1ae2013..00000000
--- a/Classes/coordinateSystem.js
+++ /dev/null
@@ -1,100 +0,0 @@
-////// COORDINATES //
-// Defining why we use this:
-// - Initially will be configured by Terrain, grabable by other objects
-// -- Need to consider: real terrain size vs. canvas;
-// -- Potential movement of reference: Terrain unmoved, but camera is
-// -- We need some conversion between Terrain-coords, and pixel coords
-// ...
-
-// Backing formula(s)
-/*
-initially we have: canvas(0-N,0-N), gridCount(0-M,0-M), tileSize, pX,pY on Canvas
-need: x,y on grid.
-
-x = pX/tS ; y = pY/tS; // (0,0) top left
-
-x = (pX - (cX/2))/tS; y = (pY - (cY/2))/tS; // (0,0) dead center
--> Which tile? Use round() func. ie. [-0.5-0.5] = center tile. if ODD.
--> Which tile? Use floor() func. if EVEN.
-aka:
-pX = x*tS + (cX/2) ; pY = y*tS + (cY/2)
-
-Cannot use arbitrary center. In odd, is in middle of existing tile, in even, is in 'ghost tile' - in intersection of border
-
-Define center tile:
- floor(gCX/2)*tS - (tS/2), ... => cX,cY
-
-WORKING formula: (Based on (0,0) position on BACKING CANVAS)
-x = (pX - [floor(gCX/2)*tS - tS/2])/tS ; y = ...
-pX = (x*tS) + [floor(gCX/2)*tS - tS/2]; pY = ...
-
-Optimized formula:
-x = pX/tS - floor(gCX/2) + 1/2 ; y = ...
-pX = (x - 1/2 + floor(gCX/2))*tS
-
-
-View canvas formula:
-x = ((pX + cOX) - [floor(gCX/2)*tS - tS/2])/tS ; y = ...
-pX = ((x*tS) + [floor(gCX/2)*tS - tS/2]) - cOX; pY = ...
-*/
-
-class CoordinateSystem {
- constructor(gridCountX,gridCountY,tileSize,canvasOffsetX,canvasOffsetY) {
- this._tS = tileSize;
-
- this._gCX = gridCountX;
- this._gCY = gridCountY;
-
- this._cOX = canvasOffsetX;
- this._cOY = canvasOffsetY;
- }
-
- //// Util
- roundToTilePos(posPair) {
- // Fix -0
- posPair[0] = round(posPair[0]);
- if (posPair[0] == -0) { posPair[0] = 0; }
- posPair[1] = round(posPair[1]);
- if (posPair[1] == -0) { posPair[1] = 0; }
-
- return posPair;
- }
-
-
-
- //// Backing Canvas Conversions (reference equations, useful for converting positions off of pixel grid to coords)
- // Convert BACKING canvas position to Grid coordinates
- convBackingCanvasToPos(posPair) { // From backing canvas pixels -> grid position (defines grid)
- return [
- posPair[0]/this._tS - floor(this._gCX/2) + 1/2 ,
- posPair[1]/this._tS - floor(this._gCY/2) + 1/2 ,
- ];
- }
-
- // Convert Grid coordinates to BACKING canvas
- convPosToBackingCanvas(posPair) { // From grid position -> backing canvas pixels
- return [
- (posPair[0] - 1/2 + floor(this._gCX/2))*this._tS ,
- (posPair[1] - 1/2 + floor(this._gCY/2))*this._tS ,
- ];
- }
-
-
-
- //// Viewing Canvas Conversions
- setViewCornerBC(posPair) { // Sets corner of viewing canvas (top left) on Backing Canvas
- this._cOX = posPair[0];
- this._cOY = posPair[1];
- }
-
- // Convert VIEWING canvas position to Grid coordinates
- convCanvasToPos(posPair) { // Converting from viewing canvas -> grid position
- return this.convBackingCanvasToPos([posPair[0]+this._cOX,posPair[1]+this._cOY]); // Adds viewing offset to get Backing Canvas position
- }
-
- // Convert Grid coordinates to VIEWING canvas
- convPosToCanvas(posPair) { // Converting from grid position to viewing canvas, does not check if out of bounds
- let backingCanvasPixels = this.convPosToBackingCanvas(posPair);
- return [backingCanvasPixels[0] - this._cOX, backingCanvasPixels[1] - this._cOY]; // Removes offset from backing canvas to get viewing canvas position
- }
-}
\ No newline at end of file
diff --git a/Classes/entities/sprite2d.js b/Classes/entities/sprite2d.js
deleted file mode 100644
index ee57e5de..00000000
--- a/Classes/entities/sprite2d.js
+++ /dev/null
@@ -1,25 +0,0 @@
-class Sprite2D {
- constructor(img, pos, size, rotation = 0) {
- this.img = img; // p5.Image object
- this.pos = pos.copy ? pos.copy() : createVector(pos.x, pos.y); // p5.Vector
- this.size = size.copy ? size.copy() : createVector(size.x, size.y); // p5.Vector
- this.rotation = rotation;
- }
-
- setImage(img) { this.img = img; }
- setPosition(pos) { this.pos = pos.copy ? pos.copy() : createVector(pos.x, pos.y); }
- setSize(size) { this.size = size.copy ? size.copy() : createVector(size.x, size.y); }
- setRotation(rotation) { this.rotation = rotation; }
-
- render() {
- push();
- translate(this.pos.x + this.size.x / 2, this.pos.y + this.size.y / 2);
- rotate(radians(this.rotation));
- imageMode(CENTER);
- image(this.img, 0, 0, this.size.x, this.size.y);
- pop();
- }
-}
-if (typeof module !== "undefined" && module.exports) {
- module.exports = Sprite2D;
-}
\ No newline at end of file
diff --git a/Classes/events/DialogueEvent.SKELETON.js b/Classes/events/DialogueEvent.SKELETON.js
new file mode 100644
index 00000000..3cdcf314
--- /dev/null
+++ b/Classes/events/DialogueEvent.SKELETON.js
@@ -0,0 +1,243 @@
+/**
+ * DialogueEvent - Implementation Skeleton
+ *
+ * This is a starter template based on the test suite requirements.
+ * Complete each TODO to make the tests pass.
+ *
+ * Run tests: npm run test:dialogue
+ */
+
+class DialogueEvent extends Event {
+ /**
+ * Constructor
+ * @param {Object} config - Event configuration
+ * @param {string} config.id - Unique event identifier
+ * @param {Object} config.content - Dialogue content
+ * @param {string} config.content.speaker - Speaker name (defaults to "Dialogue")
+ * @param {string} config.content.message - Dialogue message text
+ * @param {Array} config.content.choices - Array of choice objects
+ * @param {string} [config.content.portrait] - Optional portrait image path
+ * @param {boolean} [config.content.autoContinue] - Auto-close dialogue
+ * @param {number} [config.content.autoContinueDelay] - Delay before auto-close
+ */
+ constructor(config) {
+ // TODO: Call parent constructor with config
+ super(config);
+
+ // TODO: Set type to 'dialogue'
+ this.type = 'dialogue';
+
+ // TODO: Validate message is not empty
+ if (!config.content || !config.content.message || config.content.message.trim() === '') {
+ throw new Error('DialogueEvent requires a non-empty message');
+ }
+
+ // TODO: Set default speaker if not provided
+ if (!this.content.speaker) {
+ this.content.speaker = 'Dialogue';
+ }
+
+ // TODO: Create default "Continue" choice if no choices provided
+ if (!this.content.choices || this.content.choices.length === 0) {
+ this.content.choices = [
+ { text: 'Continue' }
+ ];
+ }
+
+ // TODO: Store reference to dialogue panel (will be created on trigger)
+ this._panel = null;
+ }
+
+ /**
+ * Get array of choices
+ * @returns {Array} Array of choice objects
+ */
+ getChoices() {
+ // TODO: Return filtered/processed choices
+ return this.content.choices || [];
+ }
+
+ /**
+ * Trigger the dialogue event
+ * Shows the dialogue panel with choices
+ */
+ trigger(data) {
+ // TODO: Call parent trigger
+ super.trigger(data);
+
+ // TODO: Get or create dialogue panel from DraggablePanelManager
+ // Check if draggablePanelManager exists
+ if (typeof draggablePanelManager === 'undefined') {
+ console.warn('draggablePanelManager not available');
+ return;
+ }
+
+ // TODO: Create panel configuration
+ const panelConfig = {
+ id: 'dialogue-display',
+ title: this.content.speaker,
+ position: {
+ x: (window.innerWidth / 2) - 250,
+ y: window.innerHeight - 200
+ },
+ size: {
+ width: 500,
+ height: 160
+ },
+ behavior: {
+ draggable: false,
+ closeable: false,
+ minimizable: false
+ },
+ buttons: {
+ layout: 'horizontal',
+ autoSizeToContent: true,
+ spacing: 10,
+ items: this._generateChoiceButtons()
+ }
+ };
+
+ // TODO: Get or create panel
+ this._panel = draggablePanelManager.getOrCreatePanel('dialogue-display', panelConfig);
+
+ // TODO: Set contentSizeCallback for custom rendering
+ this._panel.config.contentSizeCallback = (contentArea) => {
+ return this.renderDialogueContent(contentArea);
+ };
+
+ // TODO: Show the panel
+ this._panel.show();
+ }
+
+ /**
+ * Generate button configurations from choices
+ * @returns {Array} Array of button configs
+ */
+ _generateChoiceButtons() {
+ // TODO: Map choices to button configs
+ return this.getChoices().map((choice, index) => ({
+ caption: choice.text,
+ onClick: () => this.handleChoice(choice, index)
+ }));
+ }
+
+ /**
+ * Handle player choice selection
+ * @param {Object} choice - The selected choice object
+ * @param {number} index - Index of the choice
+ */
+ handleChoice(choice, index) {
+ // TODO: Execute choice callback if exists
+ if (choice.onSelect) {
+ choice.onSelect(choice);
+ }
+
+ // TODO: Set event flag for choice tracking
+ if (typeof eventManager !== 'undefined') {
+ eventManager.setFlag(`${this.id}_choice`, index);
+ }
+
+ // TODO: Trigger next event if specified
+ if (choice.nextEventId && typeof eventManager !== 'undefined') {
+ eventManager.triggerEvent(choice.nextEventId);
+ }
+
+ // TODO: Hide the panel
+ if (typeof draggablePanelManager !== 'undefined') {
+ draggablePanelManager.hidePanel('dialogue-display');
+ }
+
+ // TODO: Complete this dialogue event
+ this.complete();
+ }
+
+ /**
+ * Render dialogue content with word wrapping
+ * @param {Object} contentArea - Area to render within
+ * @param {number} contentArea.x - Left edge
+ * @param {number} contentArea.y - Top edge
+ * @param {number} contentArea.width - Available width
+ * @param {number} contentArea.height - Available height
+ * @returns {Object} Content size { width, height }
+ */
+ renderDialogueContent(contentArea) {
+ // TODO: Use push/pop for rendering isolation
+ push();
+
+ // TODO: Set text properties
+ fill(0);
+ textSize(14);
+ textAlign(LEFT, TOP);
+
+ // TODO: Calculate starting position (offset for portrait if exists)
+ let startX = contentArea.x + 10;
+ let startY = contentArea.y + 10;
+
+ // TODO: Render portrait if exists (future feature)
+ if (this.content.portrait && typeof image === 'function') {
+ // Portrait rendering will be implemented later
+ // For now, just reserve space
+ startX += 74; // 64px portrait + 10px padding
+ }
+
+ // TODO: Render word-wrapped text
+ const words = this.content.message.split(' ');
+ let line = '';
+ let y = startY;
+ const maxWidth = contentArea.width - (startX - contentArea.x) - 10;
+
+ for (let word of words) {
+ const testLine = line + word + ' ';
+ const testWidth = textWidth(testLine);
+
+ if (testWidth > maxWidth && line !== '') {
+ // Draw current line
+ text(line, startX, y);
+ line = word + ' ';
+ y += 18; // Line height
+ } else {
+ line = testLine;
+ }
+ }
+
+ // Draw final line
+ if (line.length > 0) {
+ text(line, startX, y);
+ }
+
+ pop();
+
+ // TODO: Return content size
+ return {
+ width: contentArea.width,
+ height: 100 // Approximate height for dialogue text
+ };
+ }
+
+ /**
+ * Update method (called each frame while active)
+ * Handles auto-continue functionality
+ */
+ update() {
+ super.update();
+
+ // TODO: Implement auto-continue if configured
+ if (this.content.autoContinue && this.active) {
+ const delay = this.content.autoContinueDelay || 0;
+ const elapsed = millis() - this.triggeredAt;
+
+ // Only auto-continue if there's a single "Continue" choice
+ if (this.getChoices().length === 1 && elapsed >= delay) {
+ this.handleChoice(this.getChoices()[0], 0);
+ }
+ }
+ }
+}
+
+// Export for both browser and Node.js
+if (typeof window !== 'undefined') {
+ window.DialogueEvent = DialogueEvent;
+}
+if (typeof module !== 'undefined') {
+ module.exports = DialogueEvent;
+}
diff --git a/Classes/events/Event.js b/Classes/events/Event.js
new file mode 100644
index 00000000..e69cbcda
--- /dev/null
+++ b/Classes/events/Event.js
@@ -0,0 +1,911 @@
+// /**
+// * Event Classes - Base class and specific event types
+// *
+// * Events are triggered by EventTriggers and execute specific game actions.
+// * Each event type handles different gameplay scenarios (dialogue, spawning, tutorials, bosses).
+// *
+// * Following TDD: Implementation written to pass existing unit tests.
+// *
+// * @class GameEvent - Base class for all game events
+// * @class DialogueEvent - Display dialogue/messages to player
+// * @class SpawnEvent - Spawn enemies/entities at specified locations
+// * @class TutorialEvent - Interactive step-by-step tutorials
+// * @class BossEvent - Boss fight encounters with phases
+// */
+
+// /**
+// * GameEvent - Base class for all game events
+// */
+// class GameEvent {
+// /**
+// * Create a new event
+// * @param {Object} config - Event configuration
+// * @param {string} config.id - Unique event ID
+// * @param {string} config.type - Event type (dialogue, spawn, tutorial, boss)
+// * @param {Object} config.content - Event-specific content data
+// * @param {number} [config.priority=999] - Event priority (lower = higher priority)
+// * @param {Object} [config.metadata] - Optional metadata
+// * @param {Function} [config.onTrigger] - Callback when event triggers
+// * @param {Function} [config.onComplete] - Callback when event completes
+// * @param {Function} [config.onUpdate] - Callback during event update
+// * @param {number} [config.duration] - Auto-complete after duration (ms)
+// * @param {Function} [config.completionCondition] - Auto-complete when condition met
+// */
+// constructor(config) {
+// this.id = config.id;
+// this.type = config.type;
+// this.content = config.content || {};
+// this.priority = config.priority !== undefined ? config.priority : 999;
+// this.metadata = config.metadata;
+
+// // State tracking
+// this.active = false;
+// this.completed = false;
+// this.paused = false;
+// this.triggeredAt = null;
+// this.completedAt = null;
+// this._pauseStartTime = null;
+// this._totalPausedTime = 0;
+
+// // Callbacks
+// this.onTrigger = config.onTrigger;
+// this.onComplete = config.onComplete;
+// this.onUpdate = config.onUpdate;
+
+// // Auto-completion strategies
+// this.duration = config.duration;
+// this.autoCompleteAfter = config.autoCompleteAfter; // Alternative duration name
+// this.completionCondition = config.completionCondition;
+// this.completeWhen = config.completeWhen; // Alternative condition name
+// this.customCompletion = config.customCompletion;
+// }
+
+// /**
+// * Trigger the event (start execution)
+// * @param {*} data - Optional data to pass to onTrigger callback
+// */
+// trigger(data) {
+// this.active = true;
+// this.triggeredAt = typeof millis === 'function' ? millis() : Date.now();
+
+// if (this.onTrigger) {
+// this.onTrigger(data);
+// }
+// }
+
+// /**
+// * Complete the event
+// * @returns {boolean} - True if completed, false if not active
+// */
+// complete() {
+// if (!this.active) {
+// return false;
+// }
+
+// this.completed = true;
+// this.active = false;
+// this.completedAt = typeof millis === 'function' ? millis() : Date.now();
+
+// if (this.onComplete) {
+// this.onComplete();
+// }
+
+// return true;
+// }
+
+// /**
+// * Pause the event
+// */
+// pause() {
+// if (this.active && !this.paused) {
+// this.paused = true;
+// this._pauseStartTime = typeof millis === 'function' ? millis() : Date.now();
+// }
+// }
+
+// /**
+// * Resume the event from pause
+// */
+// resume() {
+// if (this.paused) {
+// const currentTime = typeof millis === 'function' ? millis() : Date.now();
+// this._totalPausedTime += (currentTime - this._pauseStartTime);
+// this.paused = false;
+// this._pauseStartTime = null;
+// }
+// }
+
+// /**
+// * Update event (called each frame)
+// * Handles auto-completion strategies
+// */
+// update() {
+// if (!this.active || this.paused) {
+// return;
+// }
+
+// // Execute onUpdate callback
+// if (this.onUpdate) {
+// this.onUpdate();
+// }
+
+// // Check auto-completion strategies
+// this._checkAutoCompletion();
+// }
+
+// /**
+// * Check auto-completion strategies
+// * @private
+// */
+// _checkAutoCompletion() {
+// // Duration-based auto-completion
+// const durationMs = this.duration || this.autoCompleteAfter;
+// if (durationMs !== undefined) {
+// const elapsed = this.getElapsedTime();
+// if (elapsed >= durationMs) {
+// this.complete();
+// return;
+// }
+// }
+
+// // Condition-based auto-completion (custom function)
+// if (this.completionCondition && typeof this.completionCondition === 'function') {
+// if (this.completionCondition()) {
+// this.complete();
+// return;
+// }
+// }
+
+// // Condition-based auto-completion (completeWhen object)
+// if (this.completeWhen) {
+// if (this._evaluateCompleteWhenCondition(this.completeWhen)) {
+// this.complete();
+// return;
+// }
+// }
+
+// // Custom completion callback
+// if (this.customCompletion && typeof this.customCompletion === 'function') {
+// if (this.customCompletion()) {
+// this.complete();
+// return;
+// }
+// }
+// }
+
+// /**
+// * Evaluate completeWhen condition object
+// * @private
+// */
+// _evaluateCompleteWhenCondition(condition) {
+// // Custom function condition
+// if (condition.type === 'custom') {
+// if (typeof condition.condition === 'function') {
+// return condition.condition();
+// }
+// return false;
+// }
+
+// // Flag-based condition
+// if (condition.type === 'flag') {
+// const eventManager = (typeof global !== 'undefined' && global.eventManager) ||
+// (typeof window !== 'undefined' && window.eventManager);
+
+// if (!eventManager || !eventManager.getFlag) {
+// return false;
+// }
+
+// const flagValue = eventManager.getFlag(condition.flag);
+
+// // Apply operator
+// switch (condition.operator) {
+// case '<=':
+// return flagValue <= condition.value;
+// case '>=':
+// return flagValue >= condition.value;
+// case '<':
+// return flagValue < condition.value;
+// case '>':
+// return flagValue > condition.value;
+// case '!=':
+// case '!==':
+// return flagValue !== condition.value;
+// case '==':
+// case '===':
+// default:
+// return flagValue === condition.value;
+// }
+// }
+
+// return false;
+// }
+
+// /**
+// * Get elapsed time since trigger (excluding paused time)
+// * @returns {number} - Elapsed time in milliseconds
+// */
+// getElapsedTime() {
+// if (!this.triggeredAt) {
+// return 0;
+// }
+
+// const currentTime = typeof millis === 'function' ? millis() : Date.now();
+// const pausedTime = this.paused ?
+// (currentTime - this._pauseStartTime + this._totalPausedTime) :
+// this._totalPausedTime;
+
+// return currentTime - this.triggeredAt - pausedTime;
+// }
+
+// /**
+// * Serialize event for JSON export
+// * @returns {Object} - JSON-serializable event data
+// */
+// toJSON() {
+// return {
+// id: this.id,
+// type: this.type,
+// content: this.content,
+// priority: this.priority,
+// metadata: this.metadata
+// };
+// }
+// }
+
+// /**
+// * DialogueEvent - Display dialogue/messages to player
+// *
+// * Shows interactive dialogue panels with speaker names, messages, and choice buttons.
+// * Integrates with DraggablePanelManager for UI and EventManager for choice tracking.
+// *
+// * Features:
+// * - Speaker names and messages
+// * - Multiple choice buttons
+// * - Branching dialogues via nextEventId
+// * - Choice tracking with event flags
+// * - Word-wrapped text rendering
+// * - Auto-continue support
+// * - Portrait support (future)
+// */
+// class DialogueEvent extends GameEvent {
+// /**
+// * Create a new dialogue event
+// * @param {Object} config - Event configuration
+// * @param {string} config.id - Unique event identifier
+// * @param {Object} config.content - Dialogue content
+// * @param {string} [config.content.speaker='Dialogue'] - Speaker name
+// * @param {string} config.content.message - Dialogue message text (required)
+// * @param {Array} [config.content.choices] - Array of choice objects (defaults to "Continue")
+// * @param {string} [config.content.portrait] - Optional portrait image path
+// * @param {boolean} [config.content.autoContinue] - Auto-close dialogue
+// * @param {number} [config.content.autoContinueDelay=0] - Delay before auto-close (ms)
+// */
+// constructor(config) {
+// super({ ...config, type: 'dialogue' });
+
+// // Validate message is not empty
+// if (!config.content || !config.content.message || config.content.message.trim() === '') {
+// throw new Error('DialogueEvent requires a non-empty message');
+// }
+
+// // Set default speaker if not provided
+// if (!this.content.speaker) {
+// this.content.speaker = 'Dialogue';
+// }
+
+// // Create default "Continue" choice if no choices provided
+// if (!this.content.choices || this.content.choices.length === 0) {
+// this.content.choices = [{ text: 'Continue' }];
+// }
+
+// // Store reference to dialogue panel (created on trigger)
+// this._panel = null;
+// this._response = null;
+// this.onResponse = config.onResponse;
+// this.autoCompleteOnResponse = config.autoCompleteOnResponse;
+// }
+
+// /**
+// * Get array of choices (can be filtered in future)
+// * @returns {Array} Array of choice objects
+// */
+// getChoices() {
+// return this.content.choices || [];
+// }
+
+// /**
+// * Trigger the dialogue event
+// * Shows the dialogue panel with choices
+// * @param {*} data - Optional data to pass to parent trigger
+// */
+// trigger(data) {
+// // Call parent trigger
+// super.trigger(data);
+
+// // Check if draggablePanelManager exists
+// const panelManager = (typeof global !== 'undefined' && global.draggablePanelManager) ||
+// (typeof window !== 'undefined' && window.draggablePanelManager);
+
+// if (!panelManager) {
+// console.warn('DialogueEvent: draggablePanelManager not available');
+// return;
+// }
+
+// // Get window dimensions (with fallbacks for testing)
+// const winWidth = (typeof window !== 'undefined' && window.innerWidth) || 1920;
+// const winHeight = (typeof window !== 'undefined' && window.innerHeight) || 1080;
+
+// // Create panel configuration
+// const panelConfig = {
+// id: 'dialogue-display',
+// title: this.content.speaker,
+// position: {
+// x: (winWidth / 2) - 250,
+// y: winHeight - 200
+// },
+// size: {
+// width: 500,
+// height: 160
+// },
+// behavior: {
+// draggable: false,
+// closeable: false,
+// minimizable: false
+// },
+// buttons: {
+// layout: 'horizontal',
+// autoSizeToContent: true,
+// spacing: 10,
+// items: this._generateChoiceButtons()
+// }
+// };
+
+// // Get or create panel (update if exists to handle dialogue changes)
+// this._panel = panelManager.getOrCreatePanel('dialogue-display', panelConfig, true);
+
+// // Set contentSizeCallback for custom rendering
+// if (this._panel && this._panel.config) {
+// this._panel.config.contentSizeCallback = (contentArea) => {
+// return this.renderDialogueContent(contentArea);
+// };
+// }
+
+// // Show the panel
+// if (this._panel && this._panel.show) {
+// this._panel.show();
+// }
+// }
+
+// /**
+// * Generate button configurations from choices
+// * @private
+// * @returns {Array} Array of button configs
+// */
+// _generateChoiceButtons() {
+// return this.getChoices().map((choice, index) => ({
+// caption: choice.text,
+// onClick: () => this.handleChoice(choice, index)
+// }));
+// }
+
+// /**
+// * Handle player choice selection
+// * @param {Object} choice - The selected choice object
+// * @param {number} index - Index of the choice
+// */
+// handleChoice(choice, index) {
+// // Execute choice callback if exists
+// if (choice.onSelect && typeof choice.onSelect === 'function') {
+// choice.onSelect(choice);
+// }
+
+// // Set event flag for choice tracking
+// const eventManager = (typeof global !== 'undefined' && global.eventManager) ||
+// (typeof window !== 'undefined' && window.eventManager);
+
+// if (eventManager && eventManager.setFlag) {
+// eventManager.setFlag(`${this.id}_choice`, index);
+// }
+
+// // Trigger next event if specified
+// if (choice.nextEventId && eventManager && eventManager.triggerEvent) {
+// eventManager.triggerEvent(choice.nextEventId);
+// }
+
+// // Hide the panel
+// const panelManager = (typeof global !== 'undefined' && global.draggablePanelManager) ||
+// (typeof window !== 'undefined' && window.draggablePanelManager);
+
+// if (panelManager && panelManager.hidePanel) {
+// panelManager.hidePanel('dialogue-display');
+// }
+
+// // Store response
+// this._response = choice.text;
+
+// // Execute onResponse callback if exists
+// if (this.onResponse && typeof this.onResponse === 'function') {
+// this.onResponse(choice.text);
+// }
+
+// // Complete this dialogue event
+// this.complete();
+// }
+
+// /**
+// * Render dialogue content with word wrapping
+// * @param {Object} contentArea - Area to render within
+// * @param {number} contentArea.x - Left edge
+// * @param {number} contentArea.y - Top edge
+// * @param {number} contentArea.width - Available width
+// * @param {number} contentArea.height - Available height
+// * @returns {Object} Content size { width, height }
+// */
+// renderDialogueContent(contentArea) {
+// // Get p5.js functions (with fallbacks for testing)
+// const p5Push = (typeof global !== 'undefined' && global.push) ||
+// (typeof window !== 'undefined' && window.push);
+// const p5Pop = (typeof global !== 'undefined' && global.pop) ||
+// (typeof window !== 'undefined' && window.pop);
+// const p5Fill = (typeof global !== 'undefined' && global.fill) ||
+// (typeof window !== 'undefined' && window.fill);
+// const p5TextSize = (typeof global !== 'undefined' && global.textSize) ||
+// (typeof window !== 'undefined' && window.textSize);
+// const p5TextAlign = (typeof global !== 'undefined' && global.textAlign) ||
+// (typeof window !== 'undefined' && window.textAlign);
+// const p5TextWidth = (typeof global !== 'undefined' && global.textWidth) ||
+// (typeof window !== 'undefined' && window.textWidth);
+// const p5Text = (typeof global !== 'undefined' && global.text) ||
+// (typeof window !== 'undefined' && window.text);
+// const p5Image = (typeof global !== 'undefined' && global.image) ||
+// (typeof window !== 'undefined' && window.image);
+// const p5LoadImage = (typeof global !== 'undefined' && global.loadImage) ||
+// (typeof window !== 'undefined' && window.loadImage);
+// const LEFT = (typeof global !== 'undefined' && global.LEFT) ||
+// (typeof window !== 'undefined' && window.LEFT) || 'left';
+// const TOP = (typeof global !== 'undefined' && global.TOP) ||
+// (typeof window !== 'undefined' && window.TOP) || 'top';
+
+// // Use push/pop for rendering isolation
+// if (p5Push) p5Push();
+
+// // Set text properties
+// if (p5Fill) p5Fill(0);
+// if (p5TextSize) p5TextSize(14);
+// if (p5TextAlign) p5TextAlign(LEFT, TOP);
+
+// // Calculate starting position (offset for portrait if exists)
+// let startX = contentArea.x + 10;
+// let startY = contentArea.y + 10;
+
+// // Render portrait if exists
+// if (this.content.portrait && p5Image) {
+// // Load portrait image (in real game, would cache this)
+// let portraitImg = this.content.portrait;
+
+// // If loadImage is available, try to load it
+// if (p5LoadImage && typeof this.content.portrait === 'string') {
+// portraitImg = p5LoadImage(this.content.portrait);
+// }
+
+// // Draw portrait (64x64px)
+// if (portraitImg) {
+// p5Image(portraitImg, contentArea.x + 10, startY, 64, 64);
+// }
+
+// // Offset text to make room for portrait
+// startX += 74; // 64px portrait + 10px padding
+// }
+
+// // Render word-wrapped text
+// const words = this.content.message.split(' ');
+// let line = '';
+// let y = startY;
+// const maxWidth = contentArea.width - (startX - contentArea.x) - 10;
+
+// for (let word of words) {
+// const testLine = line + word + ' ';
+// const testWidth = p5TextWidth ? p5TextWidth(testLine) : testLine.length * 7;
+
+// if (testWidth > maxWidth && line !== '') {
+// // Draw current line
+// if (p5Text) p5Text(line, startX, y);
+// line = word + ' ';
+// y += 18; // Line height
+// } else {
+// line = testLine;
+// }
+// }
+
+// // Draw final line
+// if (line.length > 0 && p5Text) {
+// p5Text(line, startX, y);
+// }
+
+// if (p5Pop) p5Pop();
+
+// // Return content size
+// return {
+// width: contentArea.width,
+// height: 100 // Approximate height for dialogue text
+// };
+// }
+
+// /**
+// * Update method (called each frame while active)
+// * Handles auto-continue functionality
+// */
+// update() {
+// super.update();
+
+// // Handle auto-continue if configured
+// if (this.content.autoContinue && this.active) {
+// const delay = this.content.autoContinueDelay || 0;
+// const elapsed = this.getElapsedTime();
+
+// // Only auto-continue if there's a single choice (prevent auto-continue with multiple choices)
+// if (this.getChoices().length === 1 && elapsed >= delay) {
+// this.handleChoice(this.getChoices()[0], 0);
+// }
+// }
+// }
+
+// /**
+// * Get the user's response
+// * @returns {string|null} - Response text or null if no response yet
+// */
+// getResponse() {
+// return this._response;
+// }
+
+// /**
+// * Handle button response (legacy method for compatibility)
+// * @param {string} buttonText - Text of clicked button
+// */
+// handleResponse(buttonText) {
+// this._response = buttonText;
+
+// if (this.onResponse) {
+// this.onResponse(buttonText);
+// }
+
+// // Auto-complete on response if configured
+// if (this.autoCompleteOnResponse) {
+// this.complete();
+// }
+// }
+// }
+
+// /**
+// * SpawnEvent - Spawn enemies/entities at specified locations
+// *
+// * Generates spawn positions and triggers entity spawning callbacks.
+// */
+// class SpawnEvent extends GameEvent {
+// constructor(config) {
+// super({ ...config, type: 'spawn' });
+
+// // Support spawn callback
+// this.spawnCallback = config.spawnCallback;
+// this.onSpawn = config.onSpawn;
+// }
+
+// /**
+// * Generate spawn positions
+// * @param {Object} [viewport] - Viewport bounds {minX, maxX, minY, maxY}
+// * @returns {Array