Renamed to ShieldPrevented, changed BreakShield transpiler to use TriggerBreakShield instead

Author: HumabHatterZed

CHANGELOG.md

@@ -1,6 +1,12 @@
 <details>
 <summary>View Changelog</summary>
 
+# 2.22.1
+- Added IShieldPreventedDamage and IShieldPreventedDamageInHand ability triggers and interfaces
+- Added TriggerBreakShield, wraps BreakShield in an IEnumerator for additional customisation by modders
+- Added ICustomExhaustSequence trigger interface for modifying the draw pile exhaustion effect -  use with Opponents
+- Removed debug logging related to rulebook redirect coordinates
+
 # 2.22.0
 - Added FullBoon objects for each vanilla Boon
 - Added 'AllFullBoons' list to BoonManager

InscryptionAPI/Card/ShieldManager.cs

@@ -29,22 +29,22 @@ public static IEnumerator TriggerBreakShield(PlayableCard target, int damage, Pl
     {
         BreakShield(target, damage, attacker);
 
-        List<IShieldPreventDamage> shieldTriggers = CustomTriggerFinder.FindTriggersOnBoard<IShieldPreventDamage>(false).ToList();
-        shieldTriggers.Sort((IShieldPreventDamage a, IShieldPreventDamage b) => b.ShieldPreventDamagePriority(target, damage, attacker) - a.ShieldPreventDamagePriority(target, damage, attacker));
-        foreach (IShieldPreventDamage damageTrigger in shieldTriggers)
+        List<IShieldPreventedDamage> shieldTriggers = CustomTriggerFinder.FindTriggersOnBoard<IShieldPreventedDamage>(false).ToList();
+        shieldTriggers.Sort((IShieldPreventedDamage a, IShieldPreventedDamage b) => b.ShieldPreventedDamagePriority(target, damage, attacker) - a.ShieldPreventedDamagePriority(target, damage, attacker));
+        foreach (IShieldPreventedDamage damageTrigger in shieldTriggers)
         {
-            if ((damageTrigger as TriggerReceiver) != null && damageTrigger.RespondsToShieldPreventDamage(target, damage, attacker))
+            if ((damageTrigger as TriggerReceiver) != null && damageTrigger.RespondsToShieldPreventedDamage(target, damage, attacker))
             {
-                yield return damageTrigger.OnShieldPreventDamage(target, damage, attacker);
+                yield return damageTrigger.OnShieldPreventedDamage(target, damage, attacker);
             }
         }
-        List<IShieldPreventDamageInHand> shieldInHandTriggers = CustomTriggerFinder.FindTriggersInHand<IShieldPreventDamageInHand>().ToList();
-        shieldInHandTriggers.Sort((IShieldPreventDamageInHand a, IShieldPreventDamageInHand b) => b.ShieldPreventDamageInHandPriority(target, damage, attacker) - a.ShieldPreventDamageInHandPriority(target, damage, attacker));
-        foreach (IShieldPreventDamageInHand damageTrigger in shieldInHandTriggers)
+        List<IShieldPreventedDamageInHand> shieldInHandTriggers = CustomTriggerFinder.FindTriggersInHand<IShieldPreventedDamageInHand>().ToList();
+        shieldInHandTriggers.Sort((IShieldPreventedDamageInHand a, IShieldPreventedDamageInHand b) => b.ShieldPreventedDamageInHandPriority(target, damage, attacker) - a.ShieldPreventedDamageInHandPriority(target, damage, attacker));
+        foreach (IShieldPreventedDamageInHand damageTrigger in shieldInHandTriggers)
         {
-            if ((damageTrigger as TriggerReceiver) != null && damageTrigger.RespondsToShieldPreventDamageInHand(target, damage, attacker))
+            if ((damageTrigger as TriggerReceiver) != null && damageTrigger.RespondsToShieldPreventedDamageInHand(target, damage, attacker))
             {
-                yield return damageTrigger.OnShieldPreventDamageInHand(target, damage, attacker);
+                yield return damageTrigger.OnShieldPreventedDamageInHand(target, damage, attacker);
             }
         }
     }

InscryptionAPI/Triggers/Interfaces.cs

@@ -805,20 +805,20 @@ public interface IOnCardDealtDamageDirectly
 /// <summary>
 /// Trigger that is called after a shielded card was attacked and lost a shield.
 /// </summary>
-public interface IShieldPreventDamage
+public interface IShieldPreventedDamage
 {
-    public bool RespondsToShieldPreventDamage(PlayableCard target, int damage, PlayableCard attacker);
-    public IEnumerator OnShieldPreventDamage(PlayableCard target, int damage, PlayableCard attacker);
-    public int ShieldPreventDamagePriority(PlayableCard target, int damage, PlayableCard attacker);
+    public bool RespondsToShieldPreventedDamage(PlayableCard target, int damage, PlayableCard attacker);
+    public IEnumerator OnShieldPreventedDamage(PlayableCard target, int damage, PlayableCard attacker);
+    public int ShieldPreventedDamagePriority(PlayableCard target, int damage, PlayableCard attacker);
 }
 /// <summary>
 /// Variant of IShieldPreventDamage that triggers for cards in the hand.
 /// </summary>
-public interface IShieldPreventDamageInHand
+public interface IShieldPreventedDamageInHand
 {
-    public bool RespondsToShieldPreventDamageInHand(PlayableCard target, int damage, PlayableCard attacker);
-    public IEnumerator OnShieldPreventDamageInHand(PlayableCard target, int damage, PlayableCard attacker);
-    public int ShieldPreventDamageInHandPriority(PlayableCard target, int damage, PlayableCard attacker);
+    public bool RespondsToShieldPreventedDamageInHand(PlayableCard target, int damage, PlayableCard attacker);
+    public IEnumerator OnShieldPreventedDamageInHand(PlayableCard target, int damage, PlayableCard attacker);
+    public int ShieldPreventedDamageInHandPriority(PlayableCard target, int damage, PlayableCard attacker);
 }
 /*public interface IOnPreTakeDamageFromHammer
 {

InscryptionAPI/Triggers/TakeDamagePatches.cs

@@ -94,6 +94,7 @@ private static IEnumerable<CodeInstruction> TakeDamageTranspiler(IEnumerable<Cod
         int shieldStart = -1, shieldEnd = -1;
         for (int i = 0; i < codes.Count; i++)
         {
+            
             // grab the required operands, in order of appearance in the code
             if (shieldStart == -1 && codes[i].operand?.ToString() == "Boolean HasShield()")
             {
@@ -130,11 +131,22 @@ private static IEnumerable<CodeInstruction> TakeDamageTranspiler(IEnumerable<Cod
                 attacker = codes[i].operand;
                 if (shieldEnd > 0)
                 {
+                    CodeInstruction switch_ = codes.Find(x => x.opcode == OpCodes.Switch);
+                    //switch_.WithLabels(breakShieldLabel);
+                    object state = codes.Find(x => x.opcode == OpCodes.Stfld && x.operand.ToString() == "System.Int32 <>1__state").operand;
+                    object current = codes.Find(x => x.opcode == OpCodes.Stfld && x.operand.ToString() == "System.Object <>2__current").operand;
                     // if (HasShield && damage > 0)
-                    //   BreakShield();
+                    //   yield return TriggerBreakShield();
                     //   break;
 
-                    MethodBase breakShield = AccessTools.Method(typeof(ShieldManager), nameof(ShieldManager.BreakShield),
+                    // TriggerBreakShield
+                    // this.current = TriggerBreakShield
+                    // this.state = 7
+                    // return true
+                    // this.state = -1
+                    // yield break (new label)
+
+                    MethodBase breakShield = AccessTools.Method(typeof(ShieldManager), nameof(ShieldManager.TriggerBreakShield),
                         new Type[] { typeof(PlayableCard), typeof(int), typeof(PlayableCard) });
 
                     codes.RemoveRange(shieldStart, shieldEnd - shieldStart);
@@ -145,14 +157,33 @@ private static IEnumerable<CodeInstruction> TakeDamageTranspiler(IEnumerable<Cod
                     codes.Insert(shieldStart++, new(OpCodes.Ldc_I4_0));
                     codes.Insert(shieldStart++, new(OpCodes.Cgt));
                     codes.Insert(shieldStart++, new(OpCodes.Brfalse, hasShieldLabel));
-                    // BreakShield();
-                    //break;
+
+                    // TriggerBreakShield();
+                    codes.Insert(shieldStart++, new(OpCodes.Ldarg_0));
                     codes.Insert(shieldStart++, new(OpCodes.Ldloc_1));
                     codes.Insert(shieldStart++, new(OpCodes.Ldarg_0));
                     codes.Insert(shieldStart++, new(OpCodes.Ldfld, damage));
                     codes.Insert(shieldStart++, new(OpCodes.Ldarg_0));
                     codes.Insert(shieldStart++, new(OpCodes.Ldfld, attacker));
-                    codes.Insert(shieldStart++, new(OpCodes.Call, breakShield));
+                    codes.Insert(shieldStart++, new(OpCodes.Callvirt, breakShield));
+
+                    // this.current = TriggerBreakShield
+                    codes.Insert(shieldStart++, new(OpCodes.Stfld, current));
+                    // this.state = 5
+                    codes.Insert(shieldStart++, new(OpCodes.Ldarg_0));
+                    codes.Insert(shieldStart++, new(OpCodes.Ldc_I4_4));
+                    codes.Insert(shieldStart++, new(OpCodes.Stfld, state));
+                    // return true
+                    codes.Insert(shieldStart++, new(OpCodes.Ldc_I4_1));
+                    codes.Insert(shieldStart++, new(OpCodes.Ret));
+                    // this.state = -1
+                    //generator.MarkLabel(breakShieldLabel);
+                    /*CodeInstruction it = new(OpCodes.Ldarg_0);
+                    it.labels.Add(breakShieldLabel);
+                    codes.Insert(shieldStart++, it);
+                    codes.Insert(shieldStart++, new(OpCodes.Ldc_I4_M1));
+                    codes.Insert(shieldStart++, new(OpCodes.Stfld, state));*/
+                    // yield break
                 }
                 break;
             }