Is there any way to use events without breaking class and component separation?

Question

I just started using events, and got stuck a little. I have a problem with the following code:

class InputHandler
{
      public delegate void Shooting();
      public static  event Shooting OnShoot;

      void Update()
      {
            if( fireButtonPressed)
                OnShoot();
      }
    // Rest of the class.
}

class Weapon
{
     void Shoot()
     {
         //Do the shooting.
     }

    void OnEnable()
   {
         InputHandler.OnShoot += shooting;
   }

   void OnDisable()
   {
         InputHandler.OnShoot -= shooting;         
   }
}

class UI
{
     void UpdateBulletsCount(int bulletsLeft, int magSize)
     {
         //Update the UI.
     }

    void OnEnable()
   {
         InputHandler.OnShoot += UpdateBulletsCount; //  clearly can't do that. 
   }

   void OnDisable()
   {
         InputHandler.OnShoot -= UpdateBulletsCount;
   }
}

My UI class has a method to update the bullet count when you fire, reload or change the weapon. As you can clearly see, it takes in different parameters. This allows me to change the UpdateBulletsCount() to accept no parameters, and find the weapons info through GetComponent or Find, in order to update UI.

However, then the UI class will depend on the Weapon class, which breaks the separation of classes and components that I am trying to achieve. Is there any way to use events without breaking class and component separation?

Answer 1

I think the problem here is your input handler class doesn't know anything about your weapon class. Therefore you can't actually transfer information from the weapon class to the UI class. If you want to make this event driven, what you really need to is create an event that signals the UI to update when the weapon properties change. Something like...

class

 InputHandler
{
    void Start()
    {
        // connecting current weapon to current UI to create the pipeline
        activeWeapon.WeaponPropertiesChangedHandler += activeUI.UpdateWeaponPropertiesDisplay;
        activeWeapon.WeaponPropertiesChangedHandler += classA.UpdateWeaponPropertiesForClassA;
        activeWeapon.WeaponPropertiesChangedHandler += classB.UpdateWeaponPropertiesForClassB;
    }

    void Update()
    {
        if (fireButtonPressed)
            OnShoot();
    }
}

class Weapon
{
    public delegate void WeaponPropertiesChanged(int bulletsLeft, int magSize);
    public event WeaponPropertiesChanged WeaponPropertiesChangedHandler;

    void Shoot()
    {
        //Do the shooting.

        // Call this anytime weapon properties change (i.e. ammo, mag size, dam)
        OnWeaponPropertiesChanged();
    }

    public void OnWeaponPropertiesChanged()
    {
        // good practice to check events are assigned so won't blow up if not
        if (WeaponPropertiesChangedHandler != null)
        {
            // Call the property changed handler which is actually calling...
            WeaponPropertiesChangedHandler(bulletsLeft, magSize);
        }
    }
}

class UI
{
    // .... this function in the UI class and... 
    void UpdateWeaponPropertiesDisplay(int bulletsLeft, int magSize)
    {
        //Update the UI.
    }
}

class SomeClassA
{
    // .... this function in class A and... 
    void UpdateWeaponPropertiesForClassA(int bulletsLeft, int magSize)
    {
        // Update class A with weapon properties
    }
}

class SomeClassB
{
    // .... this function in class B
    void UpdateWeaponPropertiesForClassB(int bulletsLeft, int magSize)
    {
        // Update class B with weapon properties
    }
}

This will now give you a pipeline from weapon to UI. So now if your weapon properties change, you just need to call the OnWeaponPropertiesChanged event and pass whatever arguments you need to update the UI.

You will also have to take care with registering your events somewhere else. For example, if you change weapons, you will need to re-register the UI events and unregister the old weapons events. Since I don't know where you store this data, I made a dummy "activeWeapon" and "activeUI" variable that you will need to adjust.

Hope this helps.

Side Note: Right now there are 2 arguments being passed, if this start becomes large and cumbersome, it is a good practice to create an WeaponPropertiesChangedEventArgs Class to pass instead of the two ints.