feat: multiple callback tests

Chillu1 · Aug 8, 2024 · ff7459d · ff7459d
1 parent e273168
commit ff7459d
Show file tree

Hide file tree

Showing 5 changed files with 124 additions and 1 deletion.
diff --git a/ModiBuff/ModiBuff.Tests/CallbackEffectTests.cs b/ModiBuff/ModiBuff.Tests/CallbackEffectTests.cs
@@ -339,5 +339,52 @@ public void DamageOnStun_HealOnAnyNotStunStatusEffectRemoved()
 			Unit.Update(1);
 			Assert.AreEqual(UnitHealth, Unit.Health);
 		}
+
+		[Test]
+		public void MultipleEffectCallbacks()
+		{
+			AddRecipe("DamageEffectCallbacksRemoveOnDisarm")
+				.Effect(new DamageEffect(1), EffectOn.CallbackEffect)
+				.CallbackEffect(CallbackType.StatusEffectAdded, effect => new StatusEffectEvent(
+					(target, source, appliedStatusEffect, oldLegalAction, newLegalAction) =>
+					{
+						if (appliedStatusEffect.HasStatusEffect(StatusEffectType.Stun))
+							((ICallbackEffect)effect).CallbackEffect(target, source);
+					}))
+				.Effect(new DamageEffect(2), EffectOn.CallbackEffect2)
+				.CallbackEffect(CallbackType.StatusEffectAdded, effect => new StatusEffectEvent(
+					(target, source, appliedStatusEffect, oldLegalAction, newLegalAction) =>
+					{
+						if (appliedStatusEffect.HasStatusEffect(StatusEffectType.Freeze))
+							((ICallbackEffect)effect).CallbackEffect(target, source);
+					}))
+				.Effect(new DamageEffect(3), EffectOn.CallbackEffect3)
+				.CallbackEffect(CallbackType.StatusEffectAdded, effect => new StatusEffectEvent(
+					(target, source, appliedStatusEffect, oldLegalAction, newLegalAction) =>
+					{
+						if (appliedStatusEffect.HasStatusEffect(StatusEffectType.Root))
+							((ICallbackEffect)effect).CallbackEffect(target, source);
+					}))
+				.Remove(RemoveEffectOn.CallbackEffect4)
+				.CallbackEffect(CallbackType.StatusEffectAdded, effect => new StatusEffectEvent(
+					(target, source, appliedStatusEffect, oldLegalAction, newLegalAction) =>
+					{
+						if (appliedStatusEffect.HasStatusEffect(StatusEffectType.Disarm))
+							effect.Effect(target, source);
+					}));
+			Setup();
+
+			Unit.AddModifierSelf("DamageEffectCallbacksRemoveOnDisarm");
+			Unit.StatusEffectController.ChangeStatusEffect(0, 0, StatusEffectType.Stun, 1f, Unit);
+			Assert.AreEqual(UnitHealth - 1, Unit.Health);
+			Unit.StatusEffectController.ChangeStatusEffect(1, 0, StatusEffectType.Freeze, 1f, Unit);
+			Assert.AreEqual(UnitHealth - 1 - 2, Unit.Health);
+			Unit.StatusEffectController.ChangeStatusEffect(2, 0, StatusEffectType.Root, 1f, Unit);
+			Assert.AreEqual(UnitHealth - 1 - 2 - 3, Unit.Health);
+			Unit.StatusEffectController.ChangeStatusEffect(3, 0, StatusEffectType.Disarm, 1f, Unit);
+			Unit.Update(0);
+			Assert.AreEqual(UnitHealth - 1 - 2 - 3, Unit.Health);
+			Assert.False(Unit.ContainsModifier("DamageEffectCallbacksRemoveOnDisarm"));
+		}
 	}
 }
diff --git a/ModiBuff/ModiBuff.Tests/CallbackTests.cs b/ModiBuff/ModiBuff.Tests/CallbackTests.cs
@@ -146,5 +146,44 @@ public void Init_RegisterTimerCallback_TogglableState()
 			Enemy.Update(Unit.CallbackTimerCooldown);
 			Assert.AreEqual(EnemyDamage + 5, Enemy.Damage);
 		}
+
+		[Test]
+		public void MultipleEffectUnitCallbacks()
+		{
+			AddRecipe("DamageEffectUnitCallbacks")
+				.Effect(new DamageEffect(1), EffectOn.CallbackEffectUnits)
+				.CallbackEffectUnits(CallbackType.StatusEffectAdded, effect => (origTarget, origSource) =>
+					new StatusEffectEvent(
+						(target, source, appliedStatusEffect, oldLegalAction, newLegalAction) =>
+						{
+							if (appliedStatusEffect.HasStatusEffect(StatusEffectType.Stun))
+								((ICallbackEffect)effect).CallbackEffect(origTarget, origSource);
+						}))
+				.Effect(new DamageEffect(2), EffectOn.CallbackEffectUnits2)
+				.CallbackEffectUnits(CallbackType.StatusEffectAdded, effect => (origTarget, origSource) =>
+					new StatusEffectEvent(
+						(target, source, appliedStatusEffect, oldLegalAction, newLegalAction) =>
+						{
+							if (appliedStatusEffect.HasStatusEffect(StatusEffectType.Freeze))
+								((ICallbackEffect)effect).CallbackEffect(origTarget, origSource);
+						}))
+				.Effect(new DamageEffect(3), EffectOn.CallbackEffectUnits3)
+				.CallbackEffectUnits(CallbackType.StatusEffectAdded, effect => (origTarget, origSource) =>
+					new StatusEffectEvent(
+						(target, source, appliedStatusEffect, oldLegalAction, newLegalAction) =>
+						{
+							if (appliedStatusEffect.HasStatusEffect(StatusEffectType.Root))
+								((ICallbackEffect)effect).CallbackEffect(origTarget, origSource);
+						}));
+			Setup();
+
+			Unit.AddModifierSelf("DamageEffectUnitCallbacks");
+			Unit.StatusEffectController.ChangeStatusEffect(0, 0, StatusEffectType.Stun, 1f, Unit);
+			Assert.AreEqual(UnitHealth - 1, Unit.Health);
+			Unit.StatusEffectController.ChangeStatusEffect(1, 0, StatusEffectType.Freeze, 1f, Unit);
+			Assert.AreEqual(UnitHealth - 1 - 2, Unit.Health);
+			Unit.StatusEffectController.ChangeStatusEffect(2, 0, StatusEffectType.Root, 1f, Unit);
+			Assert.AreEqual(UnitHealth - 1 - 2 - 3, Unit.Health);
+		}
 	}
 }
diff --git a/ModiBuff/ModiBuff.Tests/CallbackUnitTests.cs b/ModiBuff/ModiBuff.Tests/CallbackUnitTests.cs
@@ -149,5 +149,31 @@ public void Init_AddDamage_HalfHealth_TriggerCallback_RemoveAndRevert_Twice()
 			Unit.TakeDamage(UnitHealth * 0.6f, Unit);
 			Assert.AreEqual(UnitDamage, Unit.Damage);
 		}
+
+		[Test]
+		public void MultipleUnitCallbacks()
+		{
+			AddRecipe("AddDamageUnitCallbacksRemoveOnStrongDispel")
+				.Effect(new AddDamageEffect(1, EffectState.IsRevertible), EffectOn.CallbackUnit)
+				.CallbackUnit(CallbackUnitType.WhenAttacked)
+				.Effect(new AddDamageEffect(2, EffectState.IsRevertible), EffectOn.CallbackUnit2)
+				.CallbackUnit(CallbackUnitType.WhenHealed)
+				.Effect(new AddDamageEffect(3, EffectState.IsRevertible, targeting: Targeting.SourceTarget),
+					EffectOn.CallbackUnit3)
+				.CallbackUnit(CallbackUnitType.OnAttack)
+				.Remove(RemoveEffectOn.CallbackUnit4)
+				.CallbackUnit(CallbackUnitType.StrongDispel);
+			Setup();
+
+			Unit.AddModifierSelf("AddDamageUnitCallbacksRemoveOnStrongDispel");
+			Enemy.Attack(Unit);
+			Assert.AreEqual(UnitDamage + 1, Unit.Damage);
+			Unit.Heal(0, Unit);
+			Assert.AreEqual(UnitDamage + 1 + 2, Unit.Damage);
+			Unit.Attack(Enemy);
+			Assert.AreEqual(UnitDamage + 1 + 2 + 3, Unit.Damage);
+			Unit.StrongDispel(Unit);
+			Assert.AreEqual(UnitDamage, Unit.Damage);
+		}
 	}
 }
diff --git a/ModiBuff/ModiBuff/Core/Modifier/Creation/Recipe/ModifierRecipe.cs b/ModiBuff/ModiBuff/Core/Modifier/Creation/Recipe/ModifierRecipe.cs
@@ -415,6 +415,7 @@ public ModifierRecipe ModifierAction(ModifierAction modifierAction, EffectOn eff
 		/// <summary>
 		///		Registers a callback register effect to a unit, will trigger all <see cref="EffectOn.CallbackUnit"/>
 		///		effects when <see cref="callbackType"/> is triggered.
+		///		When using multiple CallbackUnits, the order matters.
 		/// </summary>
 		public ModifierRecipe CallbackUnit<TCallbackUnit>(TCallbackUnit callbackType)
 		{
@@ -472,7 +473,7 @@ public ModifierRecipe Callback<TCallback, TStateData>(TCallback callbackType,
 		///		Special callbacks, all EffectOn.<see cref="EffectOn.CallbackEffect"/> effects will
 		///		trigger when <see cref="callbackType"/> is triggered.
 		///		Supports custom callback signatures (beside <see cref="UnitCallback"/>.
-		///		Callback effects now have to be in order
+		///		When using multiple CallbackEffects, the order matters.
 		/// </summary>
 		public ModifierRecipe CallbackEffect<TCallbackEffect>(TCallbackEffect callbackType,
 			Func<IEffect, object> @event)
@@ -489,6 +490,7 @@ public ModifierRecipe CallbackEffect<TCallbackEffect>(TCallbackEffect callbackTy
 		///		trigger when <see cref="callbackType"/> is triggered.
 		///		Supports custom callback signatures (beside <see cref="UnitCallback"/>.
 		///		Allows to save state through state context.
+		///		When using multiple CallbackEffects, the order matters.
 		/// </summary>
 		public ModifierRecipe CallbackEffect<TCallbackEffect, TStateData>(TCallbackEffect callbackType,
 			Func<IEffect, CallbackStateContext<TStateData>> @event)
@@ -505,6 +507,7 @@ public ModifierRecipe CallbackEffect<TCallbackEffect, TStateData>(TCallbackEffec
 		///		trigger when <see cref="callbackType"/> is triggered.
 		///		Supports custom callback signatures (beside <see cref="UnitCallback"/>.
 		///		Allows to store the target and source when registering the callback, for further access.
+		///		When using multiple CallbackEffectUnits, the order matters.
 		/// </summary>
 		public ModifierRecipe CallbackEffectUnits<TCallbackEffect>(TCallbackEffect callbackType,
 			Func<IEffect, Func<IUnit, IUnit, object>> @event)

diff --git a/ModiBuff/ModiBuff/Core/Modifier/Creation/Recipe/RemoveEffectOn.cs b/ModiBuff/ModiBuff/Core/Modifier/Creation/Recipe/RemoveEffectOn.cs
@@ -9,6 +9,14 @@ public enum RemoveEffectOn
 		Stack = EffectOn.Stack,
 		CallbackUnit = EffectOn.CallbackUnit,
 		CallbackEffect = EffectOn.CallbackEffect,
+
+		CallbackUnit2 = EffectOn.CallbackUnit2,
+		CallbackUnit3 = EffectOn.CallbackUnit3,
+		CallbackUnit4 = EffectOn.CallbackUnit4,
+
+		CallbackEffect2 = EffectOn.CallbackEffect2,
+		CallbackEffect3 = EffectOn.CallbackEffect3,
+		CallbackEffect4 = EffectOn.CallbackEffect4,
 	}
 
 	public static class RemoveEffectOnExtensions