State

Great success!

Implementation

(Unity - C#)

private void Update()
{
    HandleInput();
    UpdatePosition();
}

void HandleInput()
{
    _velocity.x = Input.GetAxis(_horizontalAxisName) * movementSpeed;

    if (Input.GetButtonDown(_jumpAxisName))
    {
        _velocity.y = jumpHeight;
        _renderer.sprite = jumpSprite;
    }
}

Whoops

IsJumping

(Unity - C#)

void HandleInput()
{
    _velocity.x = Input.GetAxis(_horizontalAxisName) * movementSpeed;

    if (!_isJumping && Input.GetButtonDown(_jumpAxisName))
    {
        _isJumping = true;
        _velocity.y = jumpHeight;
        _renderer.sprite = jumpSprite;
    }
}

Ducking

Ducking

(Unity - C#)

void HandleInput()
{
    _velocity.x = Input.GetAxis(_horizontalAxisName) * movementSpeed;

    if (Input.GetButtonDown(_jumpAxisName))
    {
        _velocity.y = jumpHeight;
        _renderer.sprite = jumpSprite;
    }
    else if(Input.GetButtonDown(_duckAxisName))
    {
        if(!_isJumping)
        {
            _renderer.sprite = duckSprite;
        }
    }
    else if(Input.GetButtonUp(_duckAxisName))
    {
        _renderer.sprite = idleSprite;
    }
}

Whoops

No problemo, we're professionals!

void HandleInput()
{
    _velocity.x = Input.GetAxis(_horizontalAxisName) * movementSpeed;

    if (Input.GetButtonDown(_jumpAxisName)) {
        _velocity.y = jumpHeight;
        _renderer.sprite = jumpSprite;
    }
    else if(Input.GetButtonDown(_duckAxisName)) {
        if(!_isJumping)
        {
            _isDucking = true;
            _renderer.sprite = duckSprite;
        }
    }
    else if(Input.GetButtonUp(_duckAxisName)) {
        if(_isDucking)
        {
            _isDucking = false;
            _renderer.sprite = idleSprite;
        }
    }
}

Add mid-air diving

void HandleInput()
{
    _velocity.x = Input.GetAxis(_horizontalAxisName) * movementSpeed;

    if (Input.GetButtonDown(_jumpAxisName)) {
        _velocity.y = jumpHeight;
        _renderer.sprite = jumpSprite;
    }
    else if(Input.GetButtonDown(_duckAxisName)) {
        if(!_isJumping) {
            _isDucking = true;
            _renderer.sprite = duckSprite;
        }
        else {
            _isJumping = false;
            _velocity.y = -jumpHeight;
            _renderer.sprite = diveSprite;
        }
    }
    else if(Input.GetButtonUp(_duckAxisName)) {
        if(_isDucking)
        {
            _isDucking = false;
            _renderer.sprite = idleSprite;
        }
    }
}

FSM

Enter the FSM - Finite State Machine

• Finite number of states
• The machine is always in one state
• Each state has a set of transitions to other states
• Which are triggered by inputs and events.

Implementation

enum CharacterStates{
    Jumping,
    Idle,
    Ducking,
    Diving
}
CharacterStates _currentState;
void HandleInput()
{
    _velocity.x = Input.GetAxis(_horizontalAxisName) * movementSpeed;
    switch (_currentState)
    {
        case CharacterStates.Idle:
            if (Input.GetButtonDown(_jumpAxisName)) {
                _renderer.sprite = jumpSprite;
                _velocity.y = jumpHeight;
                _currentState = CharacterStates.Jumping;
            } else if (Input.GetButtonDown(_duckAxisName)) {
                _renderer.sprite = duckSprite;
                _currentState = CharacterStates.Ducking;
            }
            break;
        case CharacterStates.Jumping:
            if (Input.GetButtonDown(_duckAxisName)) {
                _renderer.sprite = diveSprite;
                _currentState = CharacterStates.Diving;
            }
            break;
        case CharacterStates.Ducking:
            if (Input.GetButtonUp(_duckAxisName)) {
                _renderer.sprite = idleSprite;
                _currentState = CharacterStates.Idle;
            }
            break;
    }
}

Enter the state pattern.

Implementation

Option one: using static instances, set the new state

abstract class PlayerState {
    public static StandingState standing = new StandingState();
    public static DuckingState ducking = new DuckingState();
    public static JumpingState jumping = new JumpingState();
    public static DivingState diving = new DivingState();
    protected Player player;
    public abstract PlayerState HandleInput();
    public abstract void Update();
};

class DuckingState : PlayerState
{
    private string _duckAxisName;
    public override void HandleInput()
    {
        if (Input.GetButtonUp(_duckAxisName)) {
            player.SetState(standing);
        }
    }
    public override void Update() { /* do what you must do when ducking...*/ }
}

Alternative implementation

Option two: return the new state

class DuckingState : PlayerState
{
    private string _duckAxisName;
    public override PlayerState HandleInput()
    {
        if (Input.GetButtonUp(_duckAxisName)) {
            return new StandingState();
        }
        return null;
    }
    public override PlayerState Update() { /* do what you must do when ducking...*/ }
}

class Player
{
    private PlayerState _state
    public void HandleInput() {
        var newState = _state.HandleInput();
        if(newState != null)
            _state = newState
    }
}

Enter/Exit

States often have an Enter and Exit function to initialize their state data and perform cleanup.

class DuckingState : PlayerState
{
    private Sprite _duckSprite;
    private string _duckAxisName;

    public override void OnEnter()
    {
        player.SetSprite(_duckSprite);
    }

    public override PlayerState HandleInput()
    {
        if (Input.GetButtonUp(_duckAxisName)) {
            return new StandingState();
        }
        return null;
    }
    public override PlayerState Update() { /* do what you must do when ducking...*/ }
}

Concurrent state machines

Give the player a gun - then what happens to our states?

What are our options?

UI

The user interface is an FSM

UI

UI

The user interface is an FSM with an extra dimension!

Stacked states

States can be stacked. When calling a state method, it gets called on all the states in the stack.

Next the OnEnter/OnExit methods we can now also add an OnSuspend/OnResume method for each state.

For example the HUD, when suspended,

• Does not respond to input
• Is (partly) invisible
• Blurs the scene.

Rendering pop quiz!

Rendering goes somewhat like this

So why is it that we never get to see an image of the situation in between?

Rendering pop quiz!

So what is this then and how do we avoid it?

Double buffer

• When you have state that changes in steps...
• ...that may be accessed in the middle of those steps
• You want to prevent the accessing code to see the work in progress
• But you don't want to wait until its ready

Then use a double buffer.

• How much time takes the swap?
• Increased memory (double)

Double buffer

This is not only applicable in rendering!

void clown::update()
{
    if(did_i_get_slapped()) 
    {
        slap(next_clown);
    }
}

Double buffer

This is not only applicable in rendering!

void clown::update()
{
    if(did_i_get_slapped()) 
    {
        slap(next_clown);
    }
}

Double buffer

Another example, say we implemented pacman on a grid-based system

class ghost : public component {
  public:
    void update() {
        move_one_unit();
        if(pacman->position() - this->position().length() <= 1) {
            // code for when pacman is caught
        }
    }
}

class pacman {
  public:
    void update()
    {
        move_one_unit();
    }
}

Say a ghost is within two units range of pacman, what possible issue lurks here?

Double buffer

• You could introduce double buffering.
  • Add a get_previous_position() to the ghost and pacman.
• Or you could use a late_update

About the swap

Swap a pointer

• fast
• no persistent references
• previous data in the buffer is from two frames ago
  • Frame 1 drawn on buffer A
  • Frame 2 drawn on buffer B
  • Frame 3 drawn on buffer A
  • ...

Copy the data

• slow(er)
• previous data in the buffer is from one frame ago

About the swap

• Swapping one big buffer
  • Simple to swap
• Or many objects with state that need to swap
  • Iterate over all the objects and tell them to swap
  • Clever trick: have a static "current" index and swap that one once. All objects use that index to work with their current state.

What about a double buffer to transfer state data from one thread to another?

• Swap must happen atomically
• Happens already with the backbuffer and frontbuffer (CPU/GPU)