Hi guys, I am trying to figure out a generic way to do my collision detection in Unity for a while both in terms of maintainability and performance. I will explain where I am now and I hope that you could provide me with some feedback. As a simple example, I have a bullet that could hit something and some GameObjects with a (MonoBevahiour) component that has the function 'hit' with some parameters such as 'damage'. The first way to handle this is providing the objects with a tag such as "Hittable" or more generic such as "Player". Now when the bullet is doing collision detection, it compares the tag and calls the hit function when the comparison returns true. I have a few problems with this approach: 1. Comparing for a string is not very stable, what if the string changes or somewhere the string is misspelled? 2. A GameObject can have only one tag. What if I want it to be Hittable (hit) and Talkable (talk)? 3. There is no guarantee that a GameObject with a certain tag implements the corresponding function. My first thought was making a child class of MonoBehaviour (GameObjectInterface for instance) and let every GameObject that collides extend from it. This class functions as the interface of a GameObject to other GameObjects in the scene. When doing collision detection, only the GameObjectInterface functions will be called. By also implementing interfaces, it is able to communicate which collisions it will handle. For example, my Player could have a PlayerGameObjectInterface which extends the GameObjectInterface class and implements the interface Hittable (which forces it to implement a hit method). These methods could be implemented by hand or use ScriptableObjects with the delegate pattern. In any case, I like the modularity of this approach. The big question is, what is the most efficient way to detect whether a Hittable interface is implemented by a colliding object? Technically, the bullet could fetch the GameObjectInterface and do a type check for the Hittable interface. But is this efficient? This requires a call to GetComponent<>(), a typecheck and a cast. Ideally every GameObject that should handle collisions has a list of enums associated with it, just like it has a tag and layer. Than a ScriptableObject could store a Dictionary with enum values referring to interfaces (the Hit enum value refers to the Hittable interface), a compile time script could check all enum values a GameObject is associated with and throw an error when an enum value is associated with a GameObject but the corresponding interface is not implemented. Now the bullet can efficiently check the enum values at runtime and safely call the corresponding functions. Unfortunately, I could not find a way to efficiently associate such data with GameObjects. What do you guys think? Is there a way to do this or should I tackle this entirely different? The main goal for me is to find a way to define interfaces of GameObjects to other GameObjects in the scene, mainly for collision detection. The Hittable is a simple example, but I really think it would be worth having a generic and stable system for this when games grow more complex. Thank's in advance!