Component-based ability system for turn-based rpg

Question

I am trying to make a component-based ability system for my new turn based game that I am working on. I not sure with the architecture and the approach I am following.

So here my idea:

Every Ability is a Prefab.
Four Ability Prefabs will be attached to every Character, those are their abilities.

An Ability consists of an AbilityController.cs. This will have the name and some basic data for the ability. Then I will attach one or more AbilityTargetMode.cs. Here I can pick a target mode (enemySingle, enemyAll, enemyRandom, AllySelf, ...) and attach one or more AbilityComponent.cs to every AbilityTargetMode. AbilityComponents are things like "Do Damage", "Apply Poison", and so on.

The idea behind this is that I can build complex abilities:

Do damage to a random enemy and poison him, then heal self, then apply buff to all allies.

The structure for an ability would be:

-- Controller
---- TargetMode: EnemySingle
------ Component 1: Damage
------ Component 2: Poison
---- TargetMode: Self
------ Component 1: Heal
---- TargetMode: AlliesAll
------ Component 1 : Buff

And so on..

But I'm not sure about the whole system. Is it something that sounds right? Should I overthink something?

And another problem that I have is that I do not know how to attach my Components and my target mode to my Controller/Prefab. Is it better to use scriptable objects? What are your thoughts on the system?

######EDIT######

So yesterday i got my system working. At least a prototype for it. Here is a picture what i can do with it in the inspector:

Cool thing about it is, that i can make Components like "DoDamage" or "ApplyPoison". Then chain them and compose my custom abilitys. One ability can have more effects. Like a chain of effects. Damage one Enemy > heal one ally > buff all other allys

Its not optimal. I really would like to have something like this with scriptabla objects, but i was not able to pull it off. Is this system okay how i did it?

My game is turn based. The game is based around the combat and around a lot of characters. thats why i want an easy ability composer.

I have 3 codes:

1. AbilityController

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class AbilityController : MonoBehaviour
{
    public string abilityName;
    public AbilityTargetMode[] targetModes;

    private void Update()
    {
        if (Input.GetMouseButtonDown(0))
        {
            for(int i = 0; i < targetModes.Length; i++)
            {
                targetModes[i].Execute();
            }
        }
    }

}

2. AbilityTargetMode

using System.Collections;
using System.Collections.Generic;
using UnityEngine;


public enum TargetMode { EnemySingle, EnemyAll, EnemyRandom, AllySingle, AllySingleOther, AllyAll, AllyAllOther, AllyRandom, AllyRandomOther, AllySelf}

[System.Serializable]
public class AbilityTargetMode
{
    public TargetMode targetMode;

    public AbilityComponent[] abilityComponents;

    private Character[] targets; 

    public void Execute()
    {
        CastAbilityComponentsOnTarget();
    }

    private void CastAbilityComponentsOnTarget()
    {
        for (int i = 0; i < abilityComponents.Length; i++)
        {
            abilityComponents[i].CastAbilityComponent(targets);
        }
    }

    private void SelectTargets()
    {
        switch (targetMode)
        {
            case TargetMode.EnemySingle:
                break;
            case TargetMode.EnemyAll:
                break;
            case TargetMode.EnemyRandom:
                break;
            case TargetMode.AllySingle:
                break;
            case TargetMode.AllySingleOther:
                break;
            case TargetMode.AllyAll:
                break;
            case TargetMode.AllyAllOther:
                break;
            case TargetMode.AllyRandom:
                break;
            case TargetMode.AllyRandomOther:
                break;
            case TargetMode.AllySelf:
                break;

        }
    }

}

3. AbilityComponent

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

[System.Serializable]
public class AbilityComponent : MonoBehaviour
{
    public virtual void CastAbilityComponent(Character[] _targets)
    {
        //do stuff
    }
}

Answer 1

Problems with this implementation:

1. The first most obvious problem with your implementation is with AbilityTargetMode. You will run into a problem that one class implements a lot of logic and will become bloated, hard to manage. Basically it doesn't follow the Single Responsibility principle. The main culprit is switch statement. Not only there is this problem, but the issue with adding new types of targets, while game is in development it's really hard to predict what kind of types you are going to need in the future, thus making you add more and more code to this class.

2. It is limited in aspect of conditions. (Imagine you have a water spirit in your party, it neglects any water based damage, how would you define here if it takes this damage or not? This can of course be handled by passing damage information when actually doing damage to a target. But what if there are other conditions that do not depend on what character knows? Like "Swamp Blessing"[if you are in swamp location - restore 20hp to all allies], how would you handle such a case? It is not a passive skill of a character, nor this is something you want to have in your ability code - because again it will become a mess once you have a few hundred conditions.) Casting of a single AbilityComponent should be able to be under conditions.

3. It uses prefabs which will work fine, but it could be harder to manage if ability is complicated. The main issue with referencing, it would be hard to tell if you are referencing the correct component, as well as assigning them would be quite tedious. ScriptableObjects are a much better fit.

Possible solution:

I understand that this is link a based answer, but there are 11 scripts and fitting them here would make this answer quite long. If that is necessary to copy them here, let me know, I will do that. But this link will be up as long as this account here exists anyway.

Component-based ability system for turn-based rpg

There is a scene with an example, so I recommend downloading and playing with it because it may look complicated, but it's pretty easy in essence.

[TEST Ability] has a button.

And I apologise in advance for my over modular design, but it's intended to be scalable solution for different types of games. Also, some of the stuff can be used for other systems.

Future possible improvements:

1. Maybe, condition per action instead or both?
2. Selection of target providers can be improved by writing a custom inspector that will find them all and show you options to choose from, or using Addressables, though, I would not suggest going with this if you are not fully comfortable in Unity yet, it's a complicated beast and it serves a different purpose, having it for editor stuff is probably an overkill.
3. FunctionalConditionsGroup is definitely not the best way to handle this, but it's an ok way. A better solution is possible I think, but I would need to work with it to see what works and what not.