Unity中OnTriggerEnter2D如何调用多种敌人的外部脚本函数

Got it, let's tackle this problem—you've got a working attack script on your attack box GameObject, but you need it to interface with multiple enemy types that have similar (but separate) scripts. The cleanest way to solve this is to use interfaces or abstract classes to standardize the behavior your attack script needs to interact with. Here's how to implement both approaches:

Option 1: Use an Interface (Best for Flexible, Disparate Enemy Scripts) #

Interfaces let you define a set of methods/properties that any enemy script must implement, without forcing them to share a common parent class beyond MonoBehaviour.

Step 1: Create the Enemy Interface #

First, make a new C# script called IEnemy (the I prefix is standard for interfaces in C#):

public interface IEnemy
{
    // Define all the actions your attack script needs to trigger
    void TakeDamage(int damageAmount);
    void PlayHitAnimation();
}

Step 2: Update All Enemy Scripts to Implement the Interface #

Go through each of your enemy scripts and have them implement IEnemy. Even if their internal logic differs, they just need to match the interface's method signatures. For example:

EnemyA.cs

public class EnemyA : MonoBehaviour, IEnemy
{
    public int health = 100;
    public Animator animator;

    public void TakeDamage(int damageAmount)
    {
        health -= damageAmount;
        if (health <= 0)
        {
            // EnemyA-specific death logic (e.g., play explosion, drop loot)
            Destroy(gameObject);
        }
    }

    public void PlayHitAnimation()
    {
        animator.SetTrigger("TakeHit");
    }
}

EnemyB.cs

public class EnemyB : MonoBehaviour, IEnemy
{
    public float health = 150f; // Even uses a float instead of int—interface doesn't care about internal details
    public Animator enemyAnimator;

    public void TakeDamage(int damageAmount)
    {
        health -= damageAmount;
        if (health <= 0)
        {
            // EnemyB-specific death logic (e.g., sink into ground)
            enemyAnimator.SetTrigger("Die");
            Destroy(gameObject, 1.2f);
        }
    }

    public void PlayHitAnimation()
    {
        enemyAnimator.SetTrigger("GotHit");
    }
}

Step 3: Modify Your Attack Script to Use the Interface #

Instead of checking for specific enemy script components, your attack box will look for the IEnemy interface. This way, any enemy that implements the interface will work automatically:

public class AttackBox : MonoBehaviour
{
    public int attackDamage = 25;

    private void OnTriggerEnter2D(Collider2D other)
    {
        // Try to get the IEnemy interface from the colliding object
        IEnemy targetEnemy = other.GetComponent<IEnemy>();
        
        if (targetEnemy != null)
        {
            // Trigger the required actions—works for ANY enemy implementing IEnemy
            targetEnemy.TakeDamage(attackDamage);
            targetEnemy.PlayHitAnimation();
        }
    }
}

Option 2: Use an Abstract Class (Best for Enemies With Shared Logic) #

If your enemies share a lot of common code (like health management, basic hit animations), an abstract class is a better fit. It lets you define shared logic once, while letting each enemy override specific behaviors.

Step 1: Create the Base Enemy Abstract Class #

Make a new script called BaseEnemy:

public abstract class BaseEnemy : MonoBehaviour
{
    // Shared properties
    public int maxHealth = 100;
    protected int currentHealth;
    public Animator animator;

    protected virtual void Start()
    {
        currentHealth = maxHealth;
    }

    // Shared damage logic (can be overridden if needed)
    public virtual void TakeDamage(int damageAmount)
    {
        currentHealth -= damageAmount;
        PlayHitAnimation();
        
        if (currentHealth <= 0)
        {
            Die();
        }
    }

    // Shared hit animation trigger
    public virtual void PlayHitAnimation()
    {
        animator.SetTrigger("Hit");
    }

    // Abstract method—each enemy must implement their own death logic
    protected abstract void Die();
}

Step 2: Inherit From the Abstract Class in Enemy Scripts #

Each enemy script will inherit from BaseEnemy and override only the parts that are unique:

EnemyA.cs

public class EnemyA : BaseEnemy
{
    protected override void Die()
    {
        // EnemyA's unique death behavior
        animator.SetTrigger("EnemyADeath");
        Destroy(gameObject, 0.8f);
    }

    // Optional: Override TakeDamage if EnemyA needs custom damage handling
    public override void TakeDamage(int damageAmount)
    {
        // Example: EnemyA takes 20% extra damage from fire attacks
        if (attackType == AttackType.Fire)
        {
            damageAmount = Mathf.RoundToInt(damageAmount * 1.2f);
        }
        base.TakeDamage(damageAmount); // Call the base class's damage logic
    }
}

EnemyB.cs

public class EnemyB : BaseEnemy
{
    protected override void Die()
    {
        // EnemyB's unique death behavior
        GetComponent<Rigidbody2D>().AddForce(Vector2.up * 5f, ForceMode2D.Impulse);
        Destroy(gameObject, 1.5f);
    }
}

Step 3: Update the Attack Script to Target the Abstract Class #

Just like with the interface, modify your attack script to look for BaseEnemy instead of specific enemy types:

public class AttackBox : MonoBehaviour
{
    public int attackDamage = 25;

    private void OnTriggerEnter2D(Collider2D other)
    {
        BaseEnemy targetEnemy = other.GetComponent<BaseEnemy>();
        
        if (targetEnemy != null)
        {
            targetEnemy.TakeDamage(attackDamage);
            // No need to call PlayHitAnimation separately if it's already in TakeDamage
        }
    }
}

Key Takeaways #

• Use interfaces when your enemies have similar required actions but different underlying logic (no shared code).
• Use abstract classes when your enemies share a lot of common functionality (health, basic animations) but need unique behaviors (death, damage resistances).
• Both approaches let you add new enemy types later without modifying your attack script—just implement the interface or inherit from the abstract class, and it'll work automatically.

内容的提问来源于stack exchange，提问作者Joe Clark