In my researches, I encountered the use of coroutines in simple behaviour scripts. The logic was simple: Using a while loop inside of the coroutines created a mini update function for our use.

So I decided to use it in my melee enemy AI script. Enemy's behaviour logic was simple: 

1.a) Idle mode.

1.b) If it has a patrol point designated, "Patrol Coroutine" is controlling the movement back and forth.

2) If player is in detection range, "Patrol Coroutine" is stopped and "Combat Coroutine" is initiated.

3) If player is out of max range, "Combat Coroutine" is stopped and "Reset Coroutine" is initiated. "Reset Coroutine" moves the enemy back to the starting position and upon arrival, "Reset Coroutine" is stopped. Then the behaviour loops back to the First Logic (Idle or Patrol).

Sounds amazing to create a behaviour pattern when you think this is all you need to do. But here was the harsh truth for me: Even though the enemy object was "technically" patrolling, it was actually ping ponging back and forth. No waiting, no time for turning, just constant movement that looked ugly.

In my opinion, that's why the hard part of writing a behaviour script is not the implementation of "Macro Behaviours". They are easy to plan, and write. But "Micro Behaviours" are the hard and the important parts. And in our case, they are the factors that save your enemy object from looking like a ping pong ball.

For example, after arriving the destination, "Micro Behaviour" can tell the agent to wait for couple seconds before moving to the other point. After some time, enemy object can initiate a rotation before starting to move. And all these little details makes our behaviour script more convincing.

Of course there are tons of micro behaviours in these coroutines and I won't be talking about how every one of them work.

Waiting and walking to sides around player between attack combos.

B) Gap Close State:

When strafe state ends and player is not in the attack range, enemy object starts to run towards player. If player close enough, attack state initiates.

C) Attack State:

And BAM! Attack the player. Can attack multiple times if player is in range.

Just like in the patrol coroutine, we have an unconvincing enemy movement where it's trying to move to the player without even facing them.

So I use dot product values to determine if enemy is looking too far away. If true, stop moving and just continue to turn. If enemy's forward gets into the specified dot product range again, then continue the movement.

A real basic poise system. Enemy has a poise bar. When enemy is damaged, its current health is reduced and at the same time its current poise is reduced. If it reaches 0, enemy's poise is broken and guard down animation plays out. During this waiting time, combat routine stopped.

After the guard down time has ended or enemy has been damaged, the combat routine is started and current poise is full again. If enemy is not taking damage for a specified time, poise starts to regenerate until bar is full. This poise regeneration logic is handled in a seperate coroutine.

When enemy is attacking, movement and rotation of the object is controlled by methods. They can slow or completely stop the speed of movement and rotation. That can give us more convincing attack movement for enemies.

At the start of the attack animation, enemy's movement is stopped and rotation speed is slowed. Rotation speed is back to full for a quick turn to the player at the last few frames before swinging the attack.

Rotation is stopped and movement is turned on during the attack swing. When swing ends, the movement ends too. When animation ends, movement and rotation speed is back to default. This attack movement and rotation rule set is called attack step window.

When enemies take damage, they are usually staggered a bit. Stagger will cancels their attack in midway. But this mechanic is really harsh for our poor enemy AI. Player can beat enemy without a sweat. That's why I added Damage Tolerance micro behaviour which counts all the damages taken.

When current damage count is reached to the damage tolerance limit, enemy gets a buff called "Stagger Block" for specified seconds. In this window, enemy cannot be staggered. And immediately, enemy's heavy attack chance is raised up to 100%, so that it can make an uncontested comeback against the player.

After all these buffs, enemy's damage counter is back to zero. This micro behaviour gives us a great opportunity to create enemies that needs to be dealt with caution.

When player is in the attack range of the enemy, attack state gets activated and enemy attacks until the player is out of range. But that's a big problem for player. This enemy needs to stop sometimes. So I added attack limit behaviour. It is simple, when enemy attacks, current attack count incremented. If attack limit is reached, enemy stops attacking and gets to the strafe state even though the player is still in the attack range. 

Heavy attacks increment the attack count to the attack limit. Let's say that heavy attack tires the enemy out and they need some breathing time. That micro behaviour gives us the opportunity to adjust enemy's combat aggressiveness.

While enemy is waiting in strafe state, there is a timer that counts. Until minimum wait time is reached, enemy is not capable of attacking even when player is in the attack range. When timer is reached to the minimum wait time, enemy will get to the attack state if player is in range. If not, enemy will continue to wait until the maximum wait time. 

After that, enemy will no longer wait for player and gap close state will be activated for attacking. This micro behaviour gives us the opportunity to adjust enemy's wait time between attacks and close range aggressiveness.

Great, now I have talked about all the important behaviours of my enemy AI script. This macro and micro behaviour model gives us a lot of opportunities. Just think about it, with adjusting all the behaviour parameters, you can create various enemy types.