Ignore multiple OnTriggerEnter for same parent colliders

Physics
1

Umm, I’m having some issues with triggers and colliders.

857×319 54.3 KB

I decided to use multiple collider on enemy (A and B) so that I could have more complex damage detection than single collider with better performance than mesh collider. It worked well when I shoot a bullet which has small collider (single enemy damaged once every single bullet hit). But didn’t work for bigger trigger damage source.

When a bomb (C) explodes and activate it’s trigger, single enemy can be damaged multiple times because OnTriggerEnter on the bomb’s script is called for every single parts of the enemy that inside the trigger (then I realize that this can also happen if the bullet has a big collider). The expected outcome is that an enemy damaged once for a single explosion source.

The flow is: a bomb with disabled trigger detonates when it hit the ground and enables it’s trigger, the monobehaviour on the bomb call OnTriggerEnter and get the enemy script on the triggered enemy (parts) and then call the Hit method on enemy monobehaviour.

The solution that came in mind is that the OnTriggerEnter on the bomb flag an “isDamage” bool and send the damage int to the enemy monobehaviour without do the damage calculation and then the enemy do the damage calculation every update (and re-flag the bool so that there can only be one damage for every frame). Isn’t this a bit difficult? Am I missing something obvious or some basic workaround?

2

A very, very easy workaround is to enumerate all of your damage sources.

Simply have a publicly available int counter that you grab every time you send out damage from a damage source, and when something takes damage, it remembers the damage instances it’s received, and ignores damage if it has already taken that damage.

So something like:

//DamageCounter script:
static int _counter
public static int counter {
  get {
    return _counter++;
  }
}

//explosion script:
void explode {
  int counter = DamageCounter.counter;
  foreach(BodyPart hit in TheListOfStuffTheExplosionHit) {
    hit.damaged(myDamage, counter);
  }
}

//BodyPart script:
void damaged(int damage, int counter) {
  parent.damaged(damage, counter);
}

//Enemy script:
void damaged(int damage, int counter) {
  if(counterList.contains(counter)
    return;
  hp -= damage;
  counterList.Add(counter);
}
1 Like
3

What I do is I have a tag called ‘root’.

Every ‘entity’ in my game (player, NPC, so on so forth) is made up of several GameObjects, of which there is some top most parent that could be considered the ‘root’ or ‘base’ of that individual entity.

I then have an extension method that searches up the parent chain until it finds the ‘root’, if none is found it returns the self.

You can see this in action here (note, I have a component called ‘MultiTag’ that allows more than one tag on the same GameObject, this handles that as well):

        public static GameObject FindRoot(this GameObject go)
        {
            if (go == null) return null;

            var root = FindParentWithTag(go.transform, SPConstants.TAG_ROOT);
            return (root != null) ? root : go; //we return self if no root was found...
        }
     
        public static GameObject FindParentWithTag(this Transform t, string stag)
        {
            if (t.tag == stag) return t.gameObject;
            MultiTag multitag = t.GetComponent<MultiTag>();
            if (multitag != null && multitag.ContainsTag(stag)) return t.gameObject;

            Transform p = t.parent;
            while (p != null)
            {
                if (p.tag == stag) return p.gameObject;

                multitag = p.GetComponent<MultiTag>();
                if (multitag != null && multitag.ContainsTag(stag)) return p.gameObject;

                p = p.parent;
            }

            return null;
        }

use is simple:

var someRoot = someGameObject.FindRoot();

Now all colliders inside some entity will return the same exact GameObject for its root. So in the explosion script every collider that is hit during the explosion I will ‘FindRoot’ on and place in a temporary list, if the list already contains that GameObject, then I’ve already dealt with this entity and I don’t do anything, otherwise I apply damage.

private List<GameObject> _hits = new List<GameObject>();

void OnTriggerEnter(Collider coll)
{
    var root = coll.gameObject.FindRoot();
    if(_hits.Contains(root)) return; //we already dealt with this guy

    _hits.Add(root);
    //I have a special method called 'FindComponent' that will search an entire entity for a script as well
    var health = root.FindComponent<HealthScript>();
    if(health != null) health.Damage(DamageAmount);
}

You can see this all here:

Constants (where my tags have a const representation for clean coding):

MultiTag (allows more than one tag on a GameObject):

GameObjectUtil (all GameObject extension methods, where ‘FindRoot’ is):

ComponentUtil (all Component extension methods, where ‘FindComponent’ is):

Of course there’s several parts to my solution because it falls out of a larger design.

You can scale it back for yourself. You don’t need ‘MultiTag’ for instance.

1 Like
4

Thanks guys! yeah so like mapping/flagging and ignoring same incoming damage or same “top root” target damage right?
So there is no “easy-basic-automatic” way like treat multiple collider on same parents as a single collider or something?
I mean this is no beginner collider problem right? I’m afraid I miss something like a tick on collider component

5

Can’t you just put a rigidbody component on the root, then have your OnCollisionEnter logic on that same gameobject? That way, any collisions which occur beneath that rigidbody in the hierarchy will get sent to the gameobject with the rigidbody.

1 Like
6

That works on the side of the Rigidbody getting hit.

But the bombs trigger collider’s OnTriggerEnter still fires for every Collider.

7

Yeah, it still called multiple times

Gotta go with a hashset of root enemy inside the trigger to check before do the damage calculation on the bullet script