Mastering Finite State Machines for Game Objects: From Basics to NPC Patrols

Finite State Machine (FSM) Basics

A finite state machine (FSM) is a computational model consisting of a limited set of states, events, and transitions. In game development, a state represents a specific condition of an object, an event triggers a change, and a transition defines the path between states.

Why Use FSM in Game Development

Early game code often relies on extensive if‑else chains to control character behavior. This approach leads to:

Code redundancy and high complexity.

State conflicts and logical errors (e.g., jumping while already airborne).

Difficulty extending and maintaining the code as new states are added.

Example of problematic if‑else logic:

void Heroine::handleInput(Input input) {
    if (input == PRESS_UP) {
        if (!isJumping_ && !isDucking_) {
            isJumping_ = true;
            yVelocity_ = JUMP_VELOCITY;
            setGraphics(IMAGE_JUMP);
        }
    } else if (input == PRESS_DOWN) {
        if (!isJumping_) {
            isDucking_ = true;
            setGraphics(IMAGE_DUCK);
        } else {
            isJumping_ = false;
            setGraphics(IMAGE_DIVE);
        }
    } else if (input == RELEASE_DOWN) {
        if (isDucking_) {
            isDucking_ = false;
            setGraphics(IMAGE_STAND);
        }
    }
    // other states
}

Another example shows missing ground‑check logic and potential infinite jumping:

bool isJumping_ = false;
bool isDucking_ = false;

void Heroine::handleInput(Input input) {
    if (input == PRESS_UP) {
        if (!isJumping_) { // should also check if on ground
            isJumping_ = true;
            yVelocity_ = JUMP_VELOCITY;
            setGraphics(IMAGE_JUMP);
        }
    } else if (input == PRESS_DOWN) {
        if (!isJumping_) {
            isDucking_ = true;
            setGraphics(IMAGE_DUCK);
        } else {
            // illegal transition: diving while jumping
            isJumping_ = false;
            setGraphics(IMAGE_DIVE);
        }
    } else if (input == RELEASE_DOWN) {
        if (isDucking_) {
            isDucking_ = false;
            setGraphics(IMAGE_STAND);
        }
    }
    // missing logic to reset isJumping_ when landing
}

FSM Role in Game Development

Behavior control: define actions such as idle, walk, run, attack and trigger them via player input or AI events.

Logic simplification: break complex logic into simple states and events.

State prediction: provide a clear model for AI and enemy behavior prediction.

Code organization: keep state‑related code together, improving readability.

Debugging and testing: visualize state transitions and the events that cause them.

FSM Components: States, Events, Transitions

States : represent a concrete condition or behavior (e.g., "Idle", "Walking", "Attacking").

Events : triggers that cause a transition (player input, environmental change, etc.).

Transitions : define the path from one state to another, each associated with an event.

Case Study: Game Object State Switching

We illustrate FSM usage with a simple 2D character that can be Idle or Moving . The conditions are:

No horizontal input → transition from Moving to Idle.

Horizontal input present → transition from Idle to Moving.

Implementation steps:

Create an abstract BaseState class defining common methods.

Implement a StateMachine component to manage the current state.

Derive concrete states (e.g., Idle, Moving) from BaseState.

Use a MovementSM class to initialize and switch states.

Key code files:

// BaseState.cs
using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public abstract class BaseState {
    public string name;
    protected StateMachine stateMachine;

    public BaseState(string name, StateMachine stateMachine) {
        this.name = name;
        this.stateMachine = stateMachine;
    }
    public virtual void Enter() { }
    public virtual void UpdateLogic() { }
    public virtual void UpdatePhysics() { }
    public virtual void Exit() { }
}

// StateMachine.cs
using System;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class StateMachine : MonoBehaviour {
    BaseState currentState;

    void Start() {
        currentState = GetInitialState();
        if (currentState != null) currentState.Enter();
    }

    void Update() {
        if (currentState != null) currentState.UpdateLogic();
    }

    void LateUpdate() {
        if (currentState != null) currentState.UpdatePhysics();
    }

    public void ChangeState(BaseState newState) {
        currentState.Exit();
        currentState = newState;
        currentState.Enter();
    }

    protected virtual BaseState GetInitialState() { return null; }
}

// MovementSM.cs
using System;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class MovementSM : StateMachine {
    public Idle idleState;
    public Moving movingState;
    public SpriteRenderer spriteRenderer;
    public Rigidbody2D rb;
    public float speed = 4f;

    void Awake() {
        idleState = new Idle(this);
        movingState = new Moving(this);
    }

    protected override BaseState GetInitialState() {
        return idleState;
    }
}

The Tencent Cloud AI Code Assistant can assist with code completion and optimization during this process.

Case Study: NPC Patrol Behavior

Intelligent NPCs in roguelike or open‑world games rely on layered AI systems. Their patrol logic is typically implemented with an FSM that includes states such as Idle, Patrol, Chase, Attack, Hurt, and Death.

Using the AI code assistant, developers can generate state classes like IState.cs, PatrolState.cs, and ChaseState.cs, and receive suggestions for integrating them into existing enemy and player scripts.

After implementing the patrol and chase logic, the assistant can also suggest optimizations and help ensure smooth state transitions.

Summary

Finite state machines provide a powerful, maintainable way to manage complex game logic and character behavior. By replacing tangled if‑else structures with clear states, events, and transitions, developers achieve cleaner code, easier debugging, and better scalability. Tools like the Tencent Cloud AI Code Assistant further accelerate FSM implementation by offering context‑aware code completion and optimization, paving the way for more sophisticated AI‑driven gameplay.