wownerogue/src/game/monster.js

const ROT = require('./rot.js');
const { seededShuffle } = require('./provablyFair');

/**
 * Monster class - Manages monster state and AI with improved pathfinding
 * 
 * AI Behavior:
 * - Uses A* pathfinding when player is visible (line of sight)
 * - Patrols toward last known player position when player not visible
 * - Falls back to wandering when no target
 * - Vision limited to configurable range (not omniscient)
 */
class Monster {
    constructor(x = 0, y = 0, options = {}) {
        this.x = x;
        this.y = y;
        
        // AI state
        this.lastKnownPlayerX = null;
        this.lastKnownPlayerY = null;
        this.visionRange = options.visionRange || 12; // tiles the monster can "see"
        this.pathCache = null;
        this.pathCacheTarget = null;
    }

    // Move monster to new position
    moveTo(x, y) {
        this.x = x;
        this.y = y;
    }

    // Check if monster is at given coordinates
    isAt(x, y) {
        return this.x === x && this.y === y;
    }
    
    /**
     * Check if monster has line of sight to a position
     * Uses Bresenham's line algorithm
     */
    hasLineOfSight(targetX, targetY, dungeon, isPassable) {
        const dx = Math.abs(targetX - this.x);
        const dy = Math.abs(targetY - this.y);
        const sx = this.x < targetX ? 1 : -1;
        const sy = this.y < targetY ? 1 : -1;
        let err = dx - dy;
        let x = this.x;
        let y = this.y;
        
        while (x !== targetX || y !== targetY) {
            const e2 = 2 * err;
            if (e2 > -dy) {
                err -= dy;
                x += sx;
            }
            if (e2 < dx) {
                err += dx;
                y += sy;
            }
            
            // Check if we hit the target
            if (x === targetX && y === targetY) return true;
            
            // Check if blocked by wall
            if (!dungeon.map[y] || !isPassable(dungeon.map[y][x])) {
                return false;
            }
        }
        return true;
    }
    
    /**
     * Calculate distance to a point
     */
    distanceTo(x, y) {
        return Math.sqrt((x - this.x) ** 2 + (y - this.y) ** 2);
    }
    
    /**
     * Find path using A* pathfinding
     * Returns array of [x, y] positions or null if no path
     */
    findPath(targetX, targetY, dungeon, isPassable) {
        // Use ROT.js A* pathfinding
        const passableCallback = (x, y) => {
            if (!dungeon.map[y]) return false;
            return isPassable(dungeon.map[y][x]);
        };
        
        const path = [];
        const astar = new ROT.Path.AStar(targetX, targetY, passableCallback, { topology: 4 });
        
        astar.compute(this.x, this.y, (x, y) => {
            path.push([x, y]);
        });
        
        // Remove the starting position from path
        if (path.length > 0 && path[0][0] === this.x && path[0][1] === this.y) {
            path.shift();
        }
        
        return path.length > 0 ? path : null;
    }

    /**
     * Improved AI to move toward player using A* pathfinding with limited vision
     */
    moveTowardPlayer(player, dungeon, rng = Math.random) {
        if (!dungeon || !dungeon.map) return;

        // Check if a tile is passable (floor, stairs, treasure)
        const isPassable = (tile) => {
            return tile === "'1" || tile === "'2" || tile === 0 || 
                   tile === '>' || tile === '$M'; // Can walk on stairs and treasure
        };

        // If no player target, wander randomly
        if (!player) {
            this._wander(dungeon, isPassable, rng);
            return;
        }
        
        const distToPlayer = this.distanceTo(player.x, player.y);
        let canSeePlayer = false;
        
        // Check if player is within vision range AND line of sight
        if (distToPlayer <= this.visionRange) {
            canSeePlayer = this.hasLineOfSight(player.x, player.y, dungeon, isPassable);
        }
        
        if (canSeePlayer) {
            // Player visible - update last known position and use A* pathfinding
            this.lastKnownPlayerX = player.x;
            this.lastKnownPlayerY = player.y;
            
            // Find path to player
            const path = this.findPath(player.x, player.y, dungeon, isPassable);
            if (path && path.length > 0) {
                // Move to next position in path
                const [nextX, nextY] = path[0];
                this.x = nextX;
                this.y = nextY;
                return;
            }
            
            // Fallback: direct move toward player
            this._moveDirectToward(player.x, player.y, dungeon, isPassable, rng);
            
        } else if (this.lastKnownPlayerX !== null) {
            // Player not visible but we have last known position - patrol toward it
            const distToLastKnown = this.distanceTo(this.lastKnownPlayerX, this.lastKnownPlayerY);
            
            if (distToLastKnown < 1) {
                // Reached last known position, clear it and wander
                this.lastKnownPlayerX = null;
                this.lastKnownPlayerY = null;
                this._wander(dungeon, isPassable, rng);
            } else {
                // Path toward last known position
                const path = this.findPath(this.lastKnownPlayerX, this.lastKnownPlayerY, dungeon, isPassable);
                if (path && path.length > 0) {
                    const [nextX, nextY] = path[0];
                    this.x = nextX;
                    this.y = nextY;
                } else {
                    // Can't reach last known position, clear and wander
                    this.lastKnownPlayerX = null;
                    this.lastKnownPlayerY = null;
                    this._wander(dungeon, isPassable, rng);
                }
            }
        } else {
            // No player info - wander randomly
            this._wander(dungeon, isPassable, rng);
        }
    }
    
    /**
     * Simple direct movement toward a target (fallback)
     */
    _moveDirectToward(targetX, targetY, dungeon, isPassable, rng = Math.random) {
        const dx = Math.sign(targetX - this.x);
        const dy = Math.sign(targetY - this.y);
        
        // Try both directions, prioritize the one with more distance to cover
        const xDist = Math.abs(targetX - this.x);
        const yDist = Math.abs(targetY - this.y);
        
        if (xDist >= yDist && dx !== 0) {
            // Try horizontal first
            const newX = this.x + dx;
            if (dungeon.map[this.y] && isPassable(dungeon.map[this.y][newX])) {
                this.x = newX;
                return;
            }
        }
        
        if (dy !== 0) {
            const newY = this.y + dy;
            if (dungeon.map[newY] && isPassable(dungeon.map[newY][this.x])) {
                this.y = newY;
                return;
            }
        }
        
        // Try horizontal if we haven't yet
        if (xDist < yDist && dx !== 0) {
            const newX = this.x + dx;
            if (dungeon.map[this.y] && isPassable(dungeon.map[this.y][newX])) {
                this.x = newX;
                return;
            }
        }
        
        // Blocked in preferred directions, try diagonals (A* backup)
        this._wander(dungeon, isPassable, rng);
    }
    
    /**
     * Random wandering behavior
     */
    _wander(dungeon, isPassable, rng = Math.random) {
        const dirs = [[0,1],[1,0],[0,-1],[-1,0]];
        // Deterministic shuffle from the per-game seeded RNG (provably fair).
        const shuffledDirs = seededShuffle(rng, dirs.slice());
        
        for (const [dx, dy] of shuffledDirs) {
            const nx = this.x + dx;
            const ny = this.y + dy;
            if (dungeon.map[ny] && isPassable(dungeon.map[ny][nx])) {
                this.x = nx;
                this.y = ny;
                return;
            }
        }
    }

    // Check if monster has caught the player
    hasCaughtPlayer(player) {
        if (!player) return false;

        // Check for direct overlap - monster on same tile as player
        return this.x === player.x && this.y === player.y;
    }

    // Get monster state as object
    getState() {
        return {
            x: this.x,
            y: this.y
        };
    }

    // Set monster state from object
    setState(state) {
        if (state.x !== undefined) this.x = state.x;
        if (state.y !== undefined) this.y = state.y;
    }
}

module.exports = Monster;