Need some advice on how to decide where to implement my enemy behaviours

Question

I'm in the middle of writing a platformer game in Unity using C#. I have my character, if he presses the kick button his state switches to kicking. During this "kicking" state the character doesn't actually do anything, he only publicly exposes the kicking information such as kickForce etc.

The enemies however have a check in their update functions for the players isKicking value, if he is and the enemy lies within the range for being kicked by the player then the enemy has forces applied to itself and such. All this works fine but I've been thinking about future implementation of different enemy types, if I want to implement other types of enemies that do not behave the same this same script will not work.

To me this is inintutive, part of me thinks that the kicking behavior should be in the player class, he should retrieve all enemies within the area of kicking and run them through some sort of KickObject method. However this is my very issue, I am unsure of what the cleanest and most straightforward (and easily extendable) way of doing this is. I have this problem in general when it comes to implementing the structure of the game, i don't know the best answer and I feel that often when I am planning things they get much more complicated than I had originally planned for down the line and the structure i had in place starts to fall apart.

Any advice on this matter would be greatly appreciated.

TL:DR - For kicking enemies, should the behaviour be applied by the player or is the method of every enemy having its own "be kicked" code the better way to do this. General game development code structure questions.

Answer 1

Why not use colliders and tags. When an enemy trigger/collider detects a player trigger/collider tagged say "Player kick" (child game object of the player) then that enemy executes his reaction with OnTriggerEnter(2D)/OnCollisionEnter(2D). Player just needs to enable and then disable its kick game object when kick is pressed.

The most important thing is that each object should only be responsible for his own actions/behavior. Player should only care to kick and nothing else. Enemies should only execute the consequences of being kicked.

Answer 2

The way I would handle this sort of scenario is to use some form of event messaging system. Each entity in your game world(and possibly the game world itself) should have the ability to send and receive messages.

A simple way to set this up would be to have a MessageTypeEnum that signals which type of message is being sent and then some way of sending the rest of the event data(i.e. use of dynamic to store a struct of data that the receiving entity can convert back to its original type, or through use of inheritance and extending a base message class with derived types for each message etc.).

You can then have a simple EventManager object that other entities can use to register for event types. When an event comes in to the manager it can then be dispatched off to the receiver method for each registered entity.

The main advantages of the above is that it is easily extendable and the sender object doesn't really care who the message is intended for. It just fires and forgets. This results in far less coupling in the code. It also allows for each entity to react differently if needs be to each message type.

For instance an EnemyDied message might result in the player handling it by adding some value to a score and the game world might handle it by removing the enemy from its update list.