[C#] RPG battle system question (destroying enemies)

Unity Engine
1

Hello all!

So… I have a simple turn based RPG, and after all actions are delegated, it goes to the battle phase (when characters smash each others):

(this is a resumed algorithm, the actual one is more complicated, but I can share it if needed)

	IEnumerator BattlePhase (){
		
		for (int i = 0; i < characters.Length; i++){
			DamageApplication()
			DestroyEnemyIfHPisZero();		//it checks ALL enemies on battle (and destroy if condition is met)
		}
	}

What should have happened is, supposing I have 4 characters in battle:

  1. character 1 attacks and enemy HP becomes -3
  2. enemy is destroyed

But what really happens is:

  1. character 1 attacks and enemy HP becomes -3
  2. character 2 attacks and enemy HP becomes -10
  3. enemy is destroyed

For some reason, the enemy is being destroyed one loop after the one he indeed died (even if the second attack misses).
The curious thing is, if a put the DestroyEnemyIfHPisZero function inside Update () it works fine, they enemy is destroyed right after the attack!

So, is there a reason for IEnumerators calling the function later instead of calling at the time it was requested?

2

If the method is being called as a coroutine, I believe that after it yields for the first time, there are specific points where they can resume their execution. This mean like before FixedUpdate or after all Updates. If it is not a coroutine, I think we need to know why it is a IEnumerator to guess more reasons.

On a side note, once I participated in a project that had a bug like this, but the enemies would end up immortal instead of having a late death. The reason was that our procedures to deal the damage to the enemies depended on a state machine, and we were not checking the current state nor fixing the next state in our damage method, meaning that the enemy would only understand their death in the next update loop (by checking and updating the state machine).

3

Yes, it’s a coroutine.

I tried putting the destroy function in a lot of different parts of the coroutine, but all of them had the same result. I don’t want to overload Update with unnecessary validations, it would be perfect if I could do the check after each attack.

ps: vai Brasil! :stuck_out_tongue:

4

Guess we’ll need more information on the code then. The only reason I can think is that DestroyEnemyIfHPisZero() fails to detect a death because of a flag or value that will be updated only in the next call to DamageApplication(). Since it is a coroutine, it is more likely related to what you do before and after each yielding.

5

It’s not that complicated but good luck with that :slight_smile:

	IEnumerator Start () {			
		
		while (battle){
			
			yield return StartCoroutine (ActionSelectPhase());
			yield return StartCoroutine (BattlePhase());
			battle = false;
		}
	}

	IEnumerator BattlePhase (){
		
		yield return new WaitForSeconds(1);		
		for (int i = 0; i < charactersFindResults.Length; i++){			
			switch (characterDatabase[i].action){				
			case "Attack":
				while (characterDatabase[i].transform.position.x > 3.5f){
					characterDatabase[i].transform.Translate (Vector3.left * 15 * Time.deltaTime);
					yield return null;
				}
								
				if (Random.Range(1,101) <= ((characterDatabase[i].Hit - enemyDatabase[characterDatabase[i].target].Evasion) * 3) + 90){ //ATTACK HITS!
					if (Random.Range(1,101) <= ((characterDatabase[i].Luck - enemyDatabase[characterDatabase[i].target].Luck) * 2) + 90){ //CRITICAL HIT!!!
						totalDamage = (characterDatabase[i].Attack + Random.Range (characterDatabase[i].Attack/2, characterDatabase[i].Attack))*4 - 
							enemyDatabase[characterDatabase[i].target].Defense +
								Random.Range (enemyDatabase[characterDatabase[i].target].Defense/2, enemyDatabase[characterDatabase[i].target].Defense); //damage calculation
						enemyDatabase[characterDatabase[i].target].CurrentHP -= totalDamage; //target HP reduction
						damageText = true;
						yield return new WaitForSeconds(0.5f);
						damageText = false;							
					}
					else{ //NORMAL HIT :(
						totalDamage = (characterDatabase[i].Attack + Random.Range (characterDatabase[i].Attack/2, characterDatabase[i].Attack))*2 - 
							enemyDatabase[characterDatabase[i].target].Defense +
								Random.Range (enemyDatabase[characterDatabase[i].target].Defense/2, enemyDatabase[characterDatabase[i].target].Defense); //damage calculation
						enemyDatabase[characterDatabase[i].target].CurrentHP -= totalDamage; //target HP reduction						
						damageText = true;
						yield return new WaitForSeconds(0.5f);
						damageText = false;
					}
				}
				else{ //ATTACK MISSES :(
					missText = true;
					yield return new WaitForSeconds(0.5f);
					missText = false;
				}								
				yield return new WaitForSeconds(0.2f);
				while (characterDatabase[i].transform.position.x < 4.8f){
					characterDatabase[i].transform.Translate (Vector3.right * 5 * Time.deltaTime);
					yield return null;
				}
				yield return new WaitForSeconds(1);	
						
				DestroyEnemy();
				break;			
			case "Special":
				break;
			case "Item":
				break;
			case "Defend":
				break;
			}
		}
	}

	void DestroyEnemy (){
		
		for (int a = 0; a < enemiesFindResults.Length; a++){
			if (enemyDatabase[a].CurrentHP <= 0){				
				Destroy (enemiesFindResults[a]);	
				BattleScope (); //recheck the battlefield
			}					
		}		
	}
6

If the problem is that they die after the current round (not after the next round), right at the start of the next round, then the problem is more likely this:

More exactly, “Actual object destruction is always delayed until after the current Update loop, but will always be done before rendering.”. And then you learn a somewhat common but unusual pitfall.

The current expected behavior (what is actually happening) for your code is:
1 - First unit attacks one alive enemy, and we will assume that it dies
2 - Enemy is scheduled to destruction. However, there is no yield there, so on to the next loop.
3 - Loop until the next attacking player unit. If no more unit attacks, we will have a yield only after all units are evaluated (and then the enemy dies)
3.1 - A unit attack any other enemy, dead or not. Every possible attack result has on yield statement.
3.2 - At least one Update will be called, and after that, the enemy dies.
Is the above correct?

Possible solution: add another yield after the DestroyEnemy. This will put your implicit state machine out of synch with the ActionSelectPhase. Or you can add a “dead flag” to the enemy and make the unit change its target.

7

What’s in your DamageApplication() function?

In that function do you have a cutout statement that exits the coroutine if enemy health is less than zero?

Try adding something like this in that function:

if(enemyhealth <0)
return;

I could be wrong, since I don’t know what’s in DamageApplication();

8

So… that could make sense, except for a detail: destroy is not delayed until the end of the loop, it happens DURING the loop, and yet a character attack late. Let me illustrate it:

The battle has 4 characters, and each attack is part of the “for” loop:

  1. First one attacks and kills (but the object is still there), “for” goes to the next
  2. Second one attacks the dead object, then it miraculously disappears
  3. The remaining two attacks continues

As you can see, the destroy doesn’t wait until “for” is over, it simply happens a tick later.

Check the code two posts above, it will show what DamageApplication() is.

9

I might have written in a confusing way. The “Update loop” is the unity calling Update of your scripts, not a iteration of the for loop. Destroy is not delayed until the end of the iteration. It is delayed until the end of all Updates of all active objects in your running scene. Still, before rendering the screen. However, coroutines are synchronous, so the Unity engine won’t execute any Update call on scripts while your coroutine does not yield or end.

There is no yield between when the enemy is killed and the next attack of a player unit, so the enemy is effectively alive (but flagged for destruction). Since unity is still in your coroutine, it did not reach the point where it can remove the object yet. There is a yield of one second right before you check if the enemy died. You can put your call before that yield and see what happens.

10

Got it! And it worked!

Thank you sir :slight_smile: