State Pattern1

class IState {
public:
    virtual void Enter(Unit* unit) = 0;
    virtual void Execute(Unit* unit, float dt) = 0;
    virtual void Exit(Unit* unit) = 0;
};

class RunState : public IState
{
protected:
    static RunState* m_instance;
    RunState()
    {
    }

public:
    static RunState* GetInstance()
    {
        return m_instance;
    }

    static RunState* CreateInstance()
    {
        if (!m_instance)
            m_instance = new RunState();
        return m_instance;
    }
    static void ReleaseInstance()
    {
        if (m_instance)
            delete m_instance;
        m_instance = nullptr;
    }

    virtual ~RunState()
    {
        printf("RunState delete\n");
    }
   
    virtual void Enter(Unit* unit) override
    {
        printf("RunState enter\n");
    }
    virtual void Execute(Unit* unit, float dt) override
    {
        printf("RunState execute\n");
    }
    virtual void Exit(Unit* unit) override
    {
        printf("RunState exit\n");
    }
};

int main()
{
    RunState::CreateInstance();
    AttackState::CreateInstance();

    Player player;
    player.ChangeState(RunState::GetInstance());
    player.Update(0.1f);
    player.ChangeState(AttackState::GetInstance());
    player.Update(0.2f);

    RunState::ReleaseInstance();
    AttackState::ReleaseInstance();
    return 0;
}

class IState {
    enter(unit) {
        console.log('enter');
    }
    execute(unit, dt) {
        console.log('execute');
    }
    exit(unit) {
        console.log('exit');
    }
};

class StateManager {   
    constructor(uUnit) {
        this.unit = uUnit;
        this.previousState = null;
        this.currentState = null;
        this.nextState = null;
    }
    changeState(uState) {
        this.previousState = this.currentState;
        if (this.currentState != null) {           
            this.currentState.exit(this.unit);
        }
        this.currentState = uState;
        this.currentState.enter(this.unit);    
    }
    update(dt) {
        if (this.currentState != null)
            this.currentState.execute(this.unit, dt);
    }
}


class RunState extends  StateInterface {
    static get instance() {
        return this._instance;
    }

    static set instance(obj) {
        this._instance = obj;
    }
    
    static createInstance() {
        if(!RunState.instance) {
            console.log('create RunState Instance');
            RunState.instance = new RunState();
        }
    }
    
    constructor() {
        super();
    }
   
    enter(unit) {
        console.log('RunState enter');
    }
    execute(unit, dt) {
        console.log('RunState execute');
    }
    exit(unit) {
        console.log('RunState exit');
    }
}

class AttackState extends  StateInterface {
    static get instance() {
        return this._instance;
    }

    static set instance(obj) {
        this._instance = obj;
    }
    
    static createInstance() {
        if(!AttackState.instance) {
            console.log('create AttackState Instance');
            AttackState.instance = new AttackState();
        }
    }
    
    constructor() {
        super();
    }
   
    enter(unit) {
        console.log('AttackState enter');
    }
    execute(unit, dt) {
        console.log('AttackState execute');
    }
    exit(unit) {
        console.log('AttackState exit');
    }
}

class Player {
    constructor() {
        this.stateManager = new StateManager(this);
    }
 
    changeState(uState) {
        this.stateManager.changeState(uState);
    }
    
    update(dt) {
        this.stateManager.update(dt);
    }
}

player = new Player();
RunState.createInstance();
AttackState.createInstance();

player.changeState(RunState.instance);
player.update(0.1);
player.changeState(AttackState.instance);
player.update(0.2);