Unity C# 전략 패턴으로 스킬 시스템 설계하기 — 조건·효과 분리와 리플렉션

public abstract class TDSkillCondition
{
    protected int conditionValue1;
    protected int conditionValue2;
    protected TDField field = null;
    protected TDCharacter owner = null;

    public void Initialize(TDField field, TDCharacter owner, int conditionValue1, int conditionValue2)
    {
        this.field = field;
        this.owner = owner;
        this.conditionValue1 = conditionValue1;
        this.conditionValue2 = conditionValue2;
    }

    public abstract TDCharacter[] CheckCondition(ElStateTypes currentType, out bool check);
}

public abstract class TDSkillRunner
{
    protected int skillValue1;
    protected int skillValue2;
    protected double actionDelay;
    protected TDField field = null;
    protected TDCharacter owner = null;
    protected ActiveSkill skillInfo = null;

    public bool IsProjectile = false;
    public bool IsMagicCircle = false;
    public bool CanChangeTarget => !IsMagicCircle;

    public virtual void Initialize(TDField field, TDCharacter owner, ActiveSkill skillInfo, int order)
…
    public abstract TDField.TeamTypes GetTargetTeamType();
    public abstract TDCharacter[] RunSkill(TDCharacter[] targetCharacters);
}

public override TDCharacter[] CheckCondition(ElStateTypes currentType, out bool check)
{
    TDCharacter[] targetCharacters;

    targetCharacters = field.GetCharactersInRange(owner.transform.localPosition, owner.GetEnemyTeam(), conditionValue1);
    check = targetCharacters != null && targetCharacters.Length >= conditionValue2;

    return targetCharacters;
}

public override TDCharacter[] CheckCondition(ElStateTypes currentType, out bool check)
{
    check = currentType == ElStateTypes.SKILLING;

    var targetCharacters = field.GetCharactersInRange(owner.transform.localPosition, owner.GetEnemyTeam(), conditionValue2);
    return targetCharacters;
}

public override TDCharacter[] RunSkill(TDCharacter[] targetCharacters)
{
    if (CanChangeTarget)
    {
        targetCharacters = field.GetCharactersInRange(owner.transform.localPosition, owner.GetTeam(), skillValue1);
    }

    if (targetCharacters != null)
    {
        int damage = Mathf.FloorToInt((float)owner.AttackPoint * ((float)skillValue2 / 100f));
        var userChr = owner.GetUserCharacter();
        int theologyLevel = GameData.GetStudyLevel(userChr.Study_Theology);
        if (userChr != null && theologyLevel > 0) // 신학 적용
        {
            damage += Mathf.FloorToInt(damage * (theologyLevel * 5 / 100f));
        }

        foreach (var target in targetCharacters)
        {
            target.TakeHeal(owner, damage, false);
        }

public override TDCharacter[] RunSkill(TDCharacter[] targetCharacters)
{
    if (targetCharacters != null)
    {
        for (int i = 0; i < targetCharacters.Length; i++)
        {
            TDCharacter targetCharacter = targetCharacters[i];
            if (targetCharacter != null)
            {
                targetCharacter.TakeAttackPointBuff(owner, skillValue1, Mathf.CeilToInt((float)owner.AttackPoint * ((float)skillValue2 / 100f)));
            }
        }
    }

    return targetCharacters;
}

if (runner.CanChangeTarget)
{
    skillDelaying = true;
    DoAction(delegate
    {
        targetCharacters = runner.RunSkill(targetCharacters);

        if (!string.IsNullOrEmpty(skillInfo.TargetEffectPath) && skillInfo.TargetEffectPath != "-" && targetCharacters != null && targetCharacters.Length > 0)
        {
            foreach (var target in targetCharacters)
            {
                var eff = CreateEffect(skillInfo.TargetEffectPath, target.transform);
                OnCreateTargetEffect(eff, target, runner);
            }
        }

        if (runner2 != null)
        {
            targetCharacters = runner2.RunSkill(targetCharacters);
        }

        skillDelaying = false;
    });

string conditionClassName = "TDSkillCondition_" + skillInfo.ConditionType;

Type type = Type.GetType(conditionClassName);

if (type != null)
{
    object instance = Activator.CreateInstance(type);

    if (instance is TDSkillCondition myClassInstance)
    {
        condition = (TDSkillCondition)instance;
    }
}

if (condition == null)
    condition = new TDSkillCondition_Whenever();

condition.Initialize(field, owner, skillInfo.ConditionValue1, skillInfo.ConditionValue2);


CreateRunner(skillInfo.SkillType, 1, ref runner);
CreateRunner(skillInfo.SecondarySkillType, 2, ref runner2);

private void CreateRunner(string typeString, int order, ref TDSkillRunner runner)
{
    string className = "TDSkillRunner_" + typeString;

    Type type = Type.GetType(className);

    if (type != null)
    {
        object instance = Activator.CreateInstance(type);

        if (instance is TDSkillRunner myClassInstance)
        {
            runner = (TDSkillRunner)instance;
        }
    }

    if (runner == null)
        runner = new TDSkillRunner_AreaDamage();

    runner.Initialize(field, owner, skillInfo, order);
}

<assembly fullname="Assembly-CSharp">
    <type fullname="TDSkillCondition_EnemyBack" preserve="all"/>
    <type fullname="TDSkillCondition_EnemyFar" preserve="all"/>
    <type fullname="TDSkillCondition_EnemyNear" preserve="all"/>
    <type fullname="TDSkillCondition_EnemyStraight" preserve="all"/>
    <type fullname="TDSkillCondition_FriendlyNear" preserve="all"/>
    <type fullname="TDSkillCondition_LongPressEnemy" preserve="all"/>
    <type fullname="TDSkillCondition_LongPressFriendly" preserve="all"/>
    <type fullname="TDSkillCondition_Whenever" preserve="all"/>
    <type fullname="TDSkillRunner_AbnormalStatus" preserve="all"/>
    <type fullname="TDSkillRunner_AccuracyPointBuff" preserve="all"/>
    <type fullname="TDSkillRunner_AreaDamage" preserve="all"/>

public static TDBoardSkill Create(BoardWorld parent, int skillIdx)
{
    var skillInfo = JsonDataStorage.BoardSkillInfoTable[skillIdx];
    var skillType = Enum.Parse<BoardSkillType>(skillInfo.SkillType, true);
    switch (skillType)
    {
        case BoardSkillType.AccelLearning:
            return new TDBoardSkill_AccelLearning(parent, skillInfo);
        case BoardSkillType.ArrivalQuest:
            return new TDBoardSkill_ArrivalQuest(parent, skillInfo);
        case BoardSkillType.BattleResultBuff:
            return new TDBoardSkill_BattleResultBuff(parent, skillInfo);
…
        case BoardSkillType.WoodStage:
            return new TDBoardSkill_WoodStage(parent, skillInfo);
        default:
            throw new UnityException($"Invalid skill type: {skillType}");
    }
}

public TDBoardSkill(BoardWorld parent, BoardSkillInfo info)
{
    owner = parent;
    skillInfo = info;
    BoardSkillType = Enum.Parse<BoardSkillType>(info.SkillType, true);
}

public virtual void Trigger(BoardEvent eventResult)
{
    Execute(eventResult);
    owner.OnEndRunSkill(this);
}

protected abstract void Execute(BoardEvent eventResult);

public void VisitBoardSkill(TDBoardSkill boardSkill)
{
    if (!IsRunning) return;

    // Debug.Log($"VisitBoardSkill: {boardSkill.GetType()}");
    switch (boardSkill)
    {
        case TDBoardSkill_AccelLearning:
        case TDBoardSkill_ArrivalQuest:
        case TDBoardSkill_BattleResultBuff:
        case TDBoardSkill_CharacterStatBuff:
        case TDBoardSkill_CharacterStatDebuff:
        case TDBoardSkill_DecelLearning:
        case TDBoardSkill_RandomStatBuff:
        case TDBoardSkill_RandomStatDebuff:
        case TDBoardSkill_RetainExperience:
        case TDBoardSkill_RetainGold:

if (JsonDataStorage.ActiveSkillTable.TryGetValue(chrInfo.ActiveSkillIDX1, out var skill1))
{
    ret.activeSkillInfo1 = skill1;
    ret.activeSkill1 = new TDActiveSkill(ret, skill1);
}

if (JsonDataStorage.ActiveSkillTable.TryGetValue(chrInfo.ActiveSkillIDX2, out var skill2))
{
    ret.activeSkillInfo2 = skill2;
    ret.activeSkill2 = new TDActiveSkill(ret, skill2);
}

if (JsonDataStorage.PassiveSkillTable.TryGetValue(chrInfo.PassiveSkillIDX1, out var passiveSkill1))
{
    ret.passiveSkillInfo1 = passiveSkill1;
}

if (JsonDataStorage.PassiveSkillTable.TryGetValue(chrInfo.PassiveSkillIDX2, out var passiveSkill2))
{
    ret.passiveSkillInfo2 = passiveSkill2;
}

public abstract class TDPassiveEffect          // 액티브의 TDSkillRunner 에 해당하는 전략
{
    protected TDCharacter owner;
    protected PassiveSkill info;

    public virtual void OnBattleStart() { }
    public virtual void OnTick(float deltaTime) { }
    public virtual void OnEnemyDead(TDCharacter enemy) { }
    public virtual void OnSkillUsed(TDActiveSkill skill) { }
    public virtual void OnAllyDead(TDCharacter ally) { }
}

public class TDPassiveEffect_PassiveAttack : TDPassiveEffect
{
    public override void OnBattleStart() => owner.TakeAttackPointBuff(owner, int.MaxValue, info.PassiveValue1);
}

// 등록은 한 곳에서, 시작할 때 표의 모든 PassiveType 을 검사한다
static readonly Dictionary<string, Func<TDPassiveEffect>> registry = new()
{
    ["PassiveAttack"] = () => new TDPassiveEffect_PassiveAttack(),
};