Refactor TriggerManager out of BattleController

Assets/Battle/BattleController.cs

@@ -118,8 +118,6 @@ public class BattleController : MonoBehaviour, IBattleEffectApplier, IBattleEffe
     private IEnumerator RunBattleRound() {
         this.state.Clock.AdvanceRound();
         
-        this.damageTriggers.RemoveAll(t => t.Expiration == TriggerExpiration.StartOfNextHeroTurn);
-
         this.state.HeroEnergy.Replenish();
         this.state.MonsterEnergy.Replenish();
 
@@ -162,6 +160,12 @@ public class BattleController : MonoBehaviour, IBattleEffectApplier, IBattleEffe
                 } else {
                     HeroCard card = playerAction.GetCardUsed();
                     yield return UseHeroCard(card);
+
+                    // TODO: Implement a stack/queue to resolve triggers in order.
+                    // Do this after the card resolution is over to avoid reentraint effects.
+                    this.state.TriggerManager.RunActivatedTriggers(this);
+                    CheckState();
+                    OnBattleStateChanged();
                 }
             } else {
                 yield return null;
@@ -170,6 +174,12 @@ public class BattleController : MonoBehaviour, IBattleEffectApplier, IBattleEffe
 
         // End of hero turn
         yield return this.state.PlayArea.UseHeroDefaults(this.state.Heroes, this.participantActivity, UseHeroDefault);
+        // TODO: Implement a stack/queue to resolve triggers in order.
+        // Do this after the card resolution is over to avoid reentraint effects.
+        this.state.TriggerManager.RunActivatedTriggers(this);
+        CheckState();
+        OnBattleStateChanged();
+
         if (STABLE_HAND_STYLE) {
             this.state.HeroDeck.DiscardInExcessOf(3);
         } else {
@@ -203,6 +213,12 @@ public class BattleController : MonoBehaviour, IBattleEffectApplier, IBattleEffe
             MonsterCard monsterCard = monsterHand[i];
             if (monsterCard.Type == CardType.Emotion && CanUseMonsterCard(monsterCard)) {
                 yield return UseMonsterCard(monsterCard);
+
+                // TODO: Implement a stack/queue to resolve triggers in order.
+                // Do this after the card resolution is over to avoid reentraint effects.
+                this.state.TriggerManager.RunActivatedTriggers(this);
+                CheckState();
+                OnBattleStateChanged();
             }
         }
 
@@ -214,8 +230,13 @@ public class BattleController : MonoBehaviour, IBattleEffectApplier, IBattleEffe
             MonsterCard monsterCard = FirstMonsterActionToPlay();
             if (monsterCard != null) {
                 yield return UseMonsterCard(monsterCard);
-                OnBattleStateChanged();
                 anyCardPlayed = true;
+
+                // TODO: Implement a stack/queue to resolve triggers in order.
+                // Do this after the card resolution is over to avoid reentraint effects.
+                this.state.TriggerManager.RunActivatedTriggers(this);
+                CheckState();
+                OnBattleStateChanged();
             }
         }
 
@@ -304,20 +325,6 @@ public class BattleController : MonoBehaviour, IBattleEffectApplier, IBattleEffe
         return this.monsterHandPlayability.IsPlayableImmediately(card);
     }
 
-    private void EnqueueActivatedTrigger(Trigger trigger) {
-        this.activatedTriggers.Add(trigger);
-    }
-
-    private void RunActivatedTriggers() {
-        foreach (Trigger t in this.activatedTriggers) {
-            t.Run(this);
-        }
-        this.activatedTriggers.Clear();
-
-        // Cleanup expired triggers
-        this.damageTriggers.RemoveAll(t => t.Expired);
-    }
-
     private void CheckState() {
         foreach (BattleParticipant p in this.state.Heroes) {
             p.CheckState();
@@ -420,8 +427,6 @@ public class BattleController : MonoBehaviour, IBattleEffectApplier, IBattleEffe
         }
     }
 
-    private List<Trigger> activatedTriggers = new List<Trigger>();
-    private List<DamageTrigger> damageTriggers = new List<DamageTrigger>();
 
     public int DealDamage(DealDamageEffect effect) {
         if (effect.Target == null) return 0;
@@ -431,14 +436,7 @@ public class BattleController : MonoBehaviour, IBattleEffectApplier, IBattleEffe
             amount += this.state.BuffManager.GetTotalBuffAmountOfType(effect.Source, BuffType.Power);
         }
         int damageDealt = effect.Target.DealDamage(amount);
-        foreach (DamageTrigger dt in this.damageTriggers) {
+        this.state.TriggerManager.NotifyResolvedDamageEffect(effect);
-            if (dt.IsTriggeredBy(effect)) {
-                EnqueueActivatedTrigger(dt);
-            }
-        }
-
-        // Do this after the card resolution is over to avoid reentraint effects.
-        RunActivatedTriggers();
 
         return damageDealt;
     }
@@ -448,15 +446,8 @@ public class BattleController : MonoBehaviour, IBattleEffectApplier, IBattleEffe
         BattleParticipant[] affectedTeam = GetTeam(effect.Team);
         foreach (BattleParticipant bp in affectedTeam) {
             damageDealt += bp.DealDamage(effect.Amount);
-            foreach (DamageTrigger dt in this.damageTriggers) {
-                if (dt.IsTriggeredBy(effect)) {
-                    EnqueueActivatedTrigger(dt);
-                }
-            }
         }
-
+        this.state.TriggerManager.NotifyResolvedMassDamageEffect(effect);
-        // Do this after the card resolution is over to avoid reentraint effects.
-        RunActivatedTriggers();
 
         return damageDealt;
     }
@@ -531,6 +522,6 @@ public class BattleController : MonoBehaviour, IBattleEffectApplier, IBattleEffe
     }
 
     public void ArmDamageTrigger(DamageTrigger damageTrigger) {
-        this.damageTriggers.Add(damageTrigger);
+        this.state.TriggerManager.ArmDamageTrigger(damageTrigger);
     }
 }

Assets/Battle/BattleState.cs

@@ -14,6 +14,7 @@ public class BattleState: MonsterViewpoint
     private BattleMonster[] monsters;
     private BattleClock clock;
     private BuffManager buffManager;
+    private TriggerManager triggerManager;
     private EnergyPool heroEnergy;
     private EnergyPool monsterEnergy;
     private BattleDeck<HeroCard> heroDeck;
@@ -28,6 +29,7 @@ public class BattleState: MonsterViewpoint
     public BattleState(BattleParameters parameters) {
         this.clock = new BattleClock();
         this.buffManager = new BuffManager(this.clock);
+        this.triggerManager = new TriggerManager(this.clock);
         this.heroEnergy = new EnergyPool();
         this.monsterEnergy = new EnergyPool();
         this.playArea = new PlayArea();
@@ -115,6 +117,7 @@ public class BattleState: MonsterViewpoint
     public BattleMonster[] Monsters {get => this.monsters;}
     public BattleClock Clock {get => this.clock;}
     public BuffManager BuffManager {get => this.buffManager;}
+    public TriggerManager TriggerManager {get => this.triggerManager;}
 
     public EnergyPool HeroEnergy {get => this.heroEnergy;}
     public EnergyPool MonsterEnergy {get => this.monsterEnergy;}

Assets/Battle/TriggerManager.cs

@@ -0,0 +1,53 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+public class TriggerManager
+{
+    private List<Trigger> activatedTriggers = new List<Trigger>();
+    private List<DamageTrigger> damageTriggers = new List<DamageTrigger>();
+
+    public TriggerManager(BattleClock clock) {
+        clock.OnTimeChanged += this.NotifyTimeChanged;
+    }
+
+    private void NotifyTimeChanged(BattleTime now) {
+        if (now.RoundStep == RoundStep.StartOfHeroTurn) {
+            this.damageTriggers.RemoveAll(t => t.Expiration == TriggerExpiration.StartOfNextHeroTurn);
+        }
+    }
+
+    public void NotifyResolvedDamageEffect(DealDamageEffect effect) {
+        foreach (DamageTrigger dt in this.damageTriggers) {
+            if (dt.IsTriggeredBy(effect)) {
+                EnqueueActivatedTrigger(dt);
+            }
+        }
+    }
+
+    public void NotifyResolvedMassDamageEffect(MassDamageEffect effect) {
+        foreach (DamageTrigger dt in this.damageTriggers) {
+            if (dt.IsTriggeredBy(effect)) {
+                EnqueueActivatedTrigger(dt);
+            }
+        }
+    }
+
+    public void ArmDamageTrigger(DamageTrigger damageTrigger) {
+        this.damageTriggers.Add(damageTrigger);
+    }
+
+    private void EnqueueActivatedTrigger(Trigger trigger) {
+        this.activatedTriggers.Add(trigger);
+    }
+
+    public void RunActivatedTriggers(IBattleEffectApplier effectApplier) {
+        foreach (Trigger t in this.activatedTriggers) {
+            t.Run(effectApplier);
+        }
+        this.activatedTriggers.Clear();
+
+        // Cleanup expired triggers
+        this.damageTriggers.RemoveAll(t => t.Expired);
+    }
+}

Assets/Battle/TriggerManager.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 5b09c5a41e91be24b988322cbdb19cba
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: