More loosely coupled way to design this attack and target concept?

Question

In my 2d game in unity and c sharp, my friendly units are squares. Each square has a grid on it. Each cell of the grid can have one enemy attached to it at a time.

This means that my enemy's targets are not just the friendly game object, but the cell as well. Because of this, I've created a Target class for this (just contains a gameobject and cell). Enemies carry their Target reference so they know where to move to and who to attack.

However, my friendlies do not need the cell to target an enemy. Enemies are small and don't have grids on them. I cannot figure out a nice way to make this polymorphic(?) Target concept work without doing checks for "if cell is not null" in all of my targeting code.

For example, code in my behavior tree for checks like "HasTarget" are tightly coupled to check for existence of a gameobject and cell. It just feels wrong. Am I stuck using custom checks and code for an enemy vs friendly target?

I tried interfaces but they require the same return types. That differs depending on if they are an enemy or friendly. Something like unit.Itargettable.GetTarget() won't work.

Help!

Answer 1

I tried interfaces but they require the same return types. That differs depending on if they are an enemy or friendly. Something like unit.Itargettable.GetTarget() won't work.

It sounds like you haven't used interfaces correctly. If the return type needs to be the same type, then make the return type an interface. Then have both your friendly and enemy units implement that interface.

It's hard to understand exactly how your game is currently set up, because you haven't shared any of your code, but here's a rough example of how you might use an interface:

public ITargetableEvent : UnityEvent<ITargetable> {}

public interface ITargetable {
    string Name { get; }
    int HP { get; set; }
    Vector3 Position { get; set; }
    ITargetableEvent DeathEvent { get; }
}

public class Unit : ITargetable {
    [SerializeField] private string name;
    [SerializeField] private int hp = 100;
    [SerializeField] private int attackPower = 5;
    [SerializeField] private ITargetableEvent deathEvent = new ITargetableEvent();
    private ITargetable target;

    public string Name => name;
    public int HP {
        get => hp; 
        set {
            this.hp = value;
            if (this.hp <= 0) deathEvent.Invoke(this);
        }
    }

    virtual public Vector3 Position => transform.position;

    //our target can be anything that implements ITargetable
    public ITargetable Target { get => target; set => target = value; }

    public void Attack() {
        if (target != null) target.HP -= attackPower;
    }
}

//friendly unit position is determined by the cell?
public class FriendlyUnit : Unit {
    [SerializeField] private Cell cell;
    override public Vector3 Position => cell.transform.position;
}