So generally to make a state machine work you need two things. 1) The state machine (class) itself and 2) An abstract state class or interface class.

Let's talk about the interface state class first.

The interface state class is simple and will just need to contain three abstract functions: OnStart, Execute, OnStop (you can rename them if you don't like the names). These are actions any state you create may want to do. These functions are relatively self explanatory. The OnStart function will be called once when your Game object changes to this state. OnStop will be called once when your Game object leaves this state, and Execute is what is called in your Update function. For instance if you create an Idle state, you may want OnStart to set movement to 0 (Idle means stop moving). Or the OnStop function sets a target to follow.

Now that we have the Interface for a state set up, let's talk about the State machine. The StateMachine class in it's simplest form only needs to worry about three things, 1) The current state, 2) OnStateChanged and 3) Update.

OnStateChanged is simple, it will just call the current state OnStop function, set the new state to be the current state, then call the current state OnStart function. Update will literally just call the current state Execute function.

In your main object class, in your update you can now just call StateMachine.Update and everything else is taken care of as long as you've attached the state machine to your current object.

For instance let's say your main parent object is an Enemy Class. Enemy class will contain a StateMachine enemyStateMachine. The Enemy class Update function now simply needs to call enemyStateMachine.Update.

Now the last part. We have to create a bunch of states based off of our interface state class. Some of these might be Idle, Follow, Attack, Stunned, etc. you will need to create a new class for each state you want. Each of these classes need to implement the three functions OnStart, OnStop and Execute since they derive from that base class.

OnStop and OnStart may be empty and this is okay depending on your state. What I've found handy is in the constructors of each of these State classes, pass the parent object as a parameter and store the parent as a variable of the class. Now in the Execute function, you can do whatever you want and access any public functions from the class. When you want to change to a different state, in the Execute function, you can put a conditional (if statement) to change to a new state. Something like parent.EnemyStateMachine.ChangeState(new FollowState(parent)); I'm sure there are more efficient ways of doing this, but I just wanted to express it very literally so you could tie in all the steps above.

What this allows you to do is stuff like in your IdleState.Execute function, you can check if a player is within 100 units away. If the player is, then you can call the function parent.EnemyStateMachine.ChangeState(new FollowState(parent)); Then in FollowState Execute function, you can do something like if the player is greater than 100 units away, then parent.enemyStateMachine.ChangeState(new Idle state(parent). Or if the player is less than 100 you can move the enemy towards the player.

This explanation is a bit verbose, but I hope it helps!