ai-system

AI System

When to Use

Use this skill when:

• Creating enemy AI
• Implementing NPC behavior
• Building autonomous agents
• Creating steering and pathfinding
• Implementing decision-making systems
• Building tactical AI

Core Principles

1. Separation of Logic: AI separate from rendering/physics
2. Hierarchical Behavior: Break complex behaviors into simple tasks
3. State-Driven: Use FSMs or behavior trees
4. Performance-Aware: Update frequency based on importance
5. Debuggable: Visualize AI state and decisions
6. Data-Driven: Configure AI in data files

AI System Implementation

1. Finite State Machine (FSM)

// ai/StateMachine.ts
export interface State {
  name: string;
  onEnter?: (entity: Entity) => void;
  onUpdate?: (entity: Entity, deltaTime: number) => void;
  onExit?: (entity: Entity) => void;
}

export interface Transition {
  from: string;
  to: string;
  condition: (entity: Entity) => boolean;
}

export class StateMachine {
  private states = new Map<string, State>();
  private transitions: Transition[] = [];
  private currentState: State | null = null;

  addState(state: State): void {
    this.states.set(state.name, state);
  }

  addTransition(transition: Transition): void {
    this.transitions.push(transition);
  }

  start(stateName: string, entity: Entity): void {
    const state = this.states.get(stateName);
    if (!state) {
      console.warn(`State not found: ${stateName}`);
      return;
    }

    if (this.currentState?.onExit) {
      this.currentState.onExit(entity);
    }

    this.currentState = state;

    if (this.currentState.onEnter) {
      this.currentState.onEnter(entity);
    }
  }

  update(entity: Entity, deltaTime: number): void {
    if (!this.currentState) return;

    // Update current state
    if (this.currentState.onUpdate) {
      this.currentState.onUpdate(entity, deltaTime);
    }

    // Check transitions
    for (const transition of this.transitions) {
      if (transition.from === this.currentState.name && transition.condition(entity)) {
        this.start(transition.to, entity);
        break;
      }
    }
  }

  getCurrentStateName(): string | null {
    return this.currentState?.name ?? null;
  }
}