How to deal damage every 2 seconds while enemy is touching the player, rather than every frame?

Question

I have made an up and down movement RPG prototype and I wanted to have a fighting system.

I made it so that the enemy follows the player and that I get damage every time he collides with me. The problem was that he only gave me damage once and would have to stop colliding with me, to attack again. I fixed that by changing OnCollisionEnter2D to OnCollisionStay2D, but now he attacks every frame, which makes him way too strong.

I already asked some people how to change it and they said you could do it with coroutines. The thing is that I have no idea how to code that and it gets even more complicated, because the enemy is constantly touching the player (When you're not dodging). I would be really happy if someone could help me with that

EnemyAttack.cs:

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
public class EnemyAttack : MonoBehaviour
{
    [SerializeField] private GameObject Player;
    [SerializeField] private int timer;
    public int damage;
    public PlayerHealth playerHealth;
    public float AttackCooldown;
    public float WaitForSecondsRealTime;
    float PlayerHealthh;
private void OnCollisionStay2D(Collision2D collision) {
    if(collision.gameObject.tag == "Player") {
        playerHealth.TakeDamage(damage);

    }
}

}

Answer 1

I wouldn't use a coroutine for this - just tracking the time since the last attack is enough.

public class EnemyAttack : MonoBehaviour
{
    public int damage;
    public PlayerHealth playerHealth;
    public float attackCooldown;
float _lastAttackTime;

private void OnCollisionStay2D(Collision2D collision) {
    // Abort if we already attacked recently.
    if (Time.time - _lastAttackTime < attackCooldown) return;

    // CompareTag is cheaper than .tag ==
    if(collision.gameObject.CompareTag("Player")) {
        playerHealth.TakeDamage(damage);

        // Remember that we recently attacked.
        _lastAttackTime = Time.time;
    }
}

}

The advantage here is that we don't have to allocate and construct a new Coroutine instance. Just updating a float is dirt cheap. Subtracting float timestamps is not entirely precise, but for values that don't need sub-millisecond precision like an attack cooldown on the order of a half-second or more, this is "good enough".

But if you really want to do it with a coroutine, you can do it like this:

public class EnemyAttack : MonoBehaviour
{
    public int damage;
    public PlayerHealth playerHealth;
    public float attackCooldown;
Coroutine _attackInProgress;
int _playerContacts;

private void OnCollisionEnter2D(Collision2D collision) {

    if(collision.gameObject.CompareTag("Player")) {
        _playerContacts++;
        if (_attackInProgress == null)
             _attackInProgress = StartCoroutine(AttackLoop);
    }
}

private void OnCollisionExit2D(Collision2D collision) {

    if(collision.gameObject.CompareTag("Player")) {
        _playerContacts--;
    }
}

private IEnumerator AttackLoop() {
    while(_playerContacts > 0) {
        playerHealth.TakeDamage(damage);

        // You can construct this once and cache it if you like.
        yield return new WaitForSeconds(attackCooldown);
    }
    _attackInProgress = null;
}

}

I've used the _playerContacts counter to exit the coroutine instead of calling StopCoroutine in OnCollisionExit for a couple of reasons:

• It preserves the cooldown even if we briefly separate and re-collide, instead of short-circuiting and letting another attack through early.

• It correctly handles cases where the player or enemy have multiple colliders (and so might get an exit message for one pair of colliders while another pair is still touching).

Answer 2

Use the following code to match the one off code, no co-routines required.

Note the damage time is now in terms of seconds, so adjust the values accordingly. I suggest damage/600 as a starting point.

This change entirely removes the FPS dependency that your original code had, and makes the attack speed machine independent.

I would add some random variation to increase replay value, as indicated in the commented line (adjust values as needed):

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
public class EnemyAttack : MonoBehaviour
{
    [SerializeField] private GameObject Player;
    [SerializeField] private int timer;
    public int damagePerSecond;
    public PlayerHealth playerHealth;
    public float AttackCooldown;
    public float WaitForSecondsRealTime;
    float PlayerHealthh;
private void OnCollisionStay2D(Collision2D collision) {
    if(collision.gameObject.CompareTag("Player")) { # attributed to DMGregory as faster.
        If (!player.Dodge) playerHealth.TakeDamage(Time.deltaTime * damagePerSecond);

//If (!player.Dodge) 
//   playerHealth.TakeDamage(Time.deltaTime * (damagePerSecond * Random.Range(.9f, 1f));
//else 
//   playerHealth.TakeDamage(Time.deltaTime * (damagePerSecond * Random.Range(.1f, .4f);
        }
    }
}