Game AI programming — A* pathfinding, state machines, and behavior trees

class EnemyFSM {
  constructor(entity) {
    this.entity = entity;
    this.state = 'patrol';
    this.patrolIndex = 0;
    this.patrolPoints = [
      { x: 100, y: 200 }, { x: 400, y: 200 },
      { x: 400, y: 400 }, { x: 100, y: 400 }
    ];
  }

  update(dt, player) {
    const dist = this.distTo(player);

    switch (this.state) {
      case 'patrol':
        this.moveToward(this.patrolPoints[this.patrolIndex], 80, dt);
        if (this.reachedPoint(this.patrolPoints[this.patrolIndex]))
          this.patrolIndex = (this.patrolIndex + 1) % this.patrolPoints.length;
        if (dist < 150) this.state = 'chase';
        break;

      case 'chase':
        this.moveToward(player, 140, dt);
        if (dist < 30) this.state = 'attack';
        if (dist > 250) this.state = 'patrol';
        break;

      case 'attack':
        player.health -= 20 * dt;
        if (dist > 40) this.state = 'chase';
        break;
    }
  }

  moveToward(target, speed, dt) {
    const dx = target.x - this.entity.x;
    const dy = target.y - this.entity.y;
    const len = Math.sqrt(dx * dx + dy * dy);
    if (len > 1) {
      this.entity.x += (dx / len) * speed * dt;
      this.entity.y += (dy / len) * speed * dt;
    }
  }

  reachedPoint(p) { return this.distTo(p) < 5; }
  distTo(p) {
    const dx = p.x - this.entity.x, dy = p.y - this.entity.y;
    return Math.sqrt(dx * dx + dy * dy);
  }
}

function aStar(grid, start, goal) {
  const open = [start];
  const cameFrom = new Map();
  const gScore = new Map();
  const fScore = new Map();
  const key = (n) => `${n.x},${n.y}`;

  gScore.set(key(start), 0);
  fScore.set(key(start), heuristic(start, goal));

  while (open.length > 0) {
    // Node with lowest fScore
    open.sort((a, b) => (fScore.get(key(a)) || Infinity) - (fScore.get(key(b)) || Infinity));
    const current = open.shift();

    if (current.x === goal.x && current.y === goal.y)
      return reconstructPath(cameFrom, current);

    for (const neighbor of getNeighbors(grid, current)) {
      const tentG = (gScore.get(key(current)) || Infinity) + 1;
      if (tentG < (gScore.get(key(neighbor)) || Infinity)) {
        cameFrom.set(key(neighbor), current);
        gScore.set(key(neighbor), tentG);
        fScore.set(key(neighbor), tentG + heuristic(neighbor, goal));
        if (!open.some(n => n.x === neighbor.x && n.y === neighbor.y))
          open.push(neighbor);
      }
    }
  }
  return []; // no path
}

function heuristic(a, b) {
  return Math.abs(a.x - b.x) + Math.abs(a.y - b.y); // Manhattan
}

function getNeighbors(grid, node) {
  const dirs = [{x:0,y:-1},{x:0,y:1},{x:-1,y:0},{x:1,y:0}];
  return dirs
    .map(d => ({ x: node.x + d.x, y: node.y + d.y }))
    .filter(n => grid[n.y]?.[n.x] === 0); // 0 = walkable
}

function reconstructPath(cameFrom, current) {
  const path = [current];
  const key = (n) => `${n.x},${n.y}`;
  while (cameFrom.has(key(current))) {
    current = cameFrom.get(key(current));
    path.unshift(current);
  }
  return path;
}

const SUCCESS = 'success', FAILURE = 'failure', RUNNING = 'running';

class Selector {
  constructor(...children) { this.children = children; }
  tick(ctx) {
    for (const c of this.children) {
      const r = c.tick(ctx);
      if (r !== FAILURE) return r;
    }
    return FAILURE;
  }
}

class Sequence {
  constructor(...children) { this.children = children; }
  tick(ctx) {
    for (const c of this.children) {
      const r = c.tick(ctx);
      if (r !== SUCCESS) return r;
    }
    return SUCCESS;
  }
}

class Condition {
  constructor(fn) { this.fn = fn; }
  tick(ctx) { return this.fn(ctx) ? SUCCESS : FAILURE; }
}

class Action {
  constructor(fn) { this.fn = fn; }
  tick(ctx) { return this.fn(ctx); }
}

// Guard AI: attack if enemy close, else patrol
const guardAI = new Selector(
  new Sequence(
    new Condition(ctx => ctx.distToPlayer < 50),
    new Action(ctx => { ctx.enemy.attack(); return SUCCESS; })
  ),
  new Sequence(
    new Condition(ctx => ctx.distToPlayer < 200),
    new Action(ctx => { ctx.enemy.chasePlayer(); return RUNNING; })
  ),
  new Action(ctx => { ctx.enemy.patrol(); return RUNNING; })
);