chore(release): merge dev into main for v0.2.14

Author: BAKAOLC

CardPiles/IModCardPileFlightContext.cs

@@ -0,0 +1,43 @@
+using Godot;
+using MegaCrit.Sts2.Core.Entities.Cards;
+using MegaCrit.Sts2.Core.Models;
+using MegaCrit.Sts2.Core.Nodes.Cards;
+
+namespace STS2RitsuLib.CardPiles
+{
+    /// <summary>
+    ///     Common subset of data exposed by mod card pile flight contexts.
+    /// </summary>
+    public interface IModCardPileFlightContext
+    {
+        /// <summary>
+        ///     Definition associated with the flight request.
+        /// </summary>
+        ModCardPileDefinition Definition { get; }
+
+        /// <summary>
+        ///     Ritsulib's default position for this request.
+        /// </summary>
+        Vector2 DefaultPosition { get; }
+
+        /// <summary>
+        ///     Source pile for this request, when applicable.
+        /// </summary>
+        CardPile? StartPile { get; }
+
+        /// <summary>
+        ///     Destination pile for this request, when applicable.
+        /// </summary>
+        CardPile? TargetPile { get; }
+
+        /// <summary>
+        ///     Live card node involved in the flight, when available.
+        /// </summary>
+        NCard? CardNode { get; }
+
+        /// <summary>
+        ///     Card model involved in the flight, when available.
+        /// </summary>
+        CardModel? CardModel { get; }
+    }
+}

CardPiles/ModCardPileFlightHistory.cs

@@ -0,0 +1,27 @@
+using MegaCrit.Sts2.Core.Entities.Cards;
+using MegaCrit.Sts2.Core.Models;
+
+namespace STS2RitsuLib.CardPiles
+{
+    internal static class ModCardPileFlightHistory
+    {
+        private static readonly Dictionary<CardModel, CardPile> LastRemovedPileByCard = [];
+
+        internal static void RecordRemoved(CardPile pile, CardModel card)
+        {
+            if (pile == null || card == null)
+                return;
+            LastRemovedPileByCard[card] = pile;
+        }
+
+        internal static CardPile? TryGetLastRemovedPile(CardModel card)
+        {
+            return card == null ? null : LastRemovedPileByCard.GetValueOrDefault(card);
+        }
+
+        internal static void Clear()
+        {
+            LastRemovedPileByCard.Clear();
+        }
+    }
+}

CardPiles/ModCardPileFlightStartContext.cs

@@ -1,30 +1,34 @@
 using Godot;
 using MegaCrit.Sts2.Core.Entities.Cards;
+using MegaCrit.Sts2.Core.Models;
+using MegaCrit.Sts2.Core.Nodes.Cards;
 
 namespace STS2RitsuLib.CardPiles
 {
     /// <summary>
     ///     Context passed to <see cref="ModCardPileSpec.FlightStartPositionResolver" /> when shuffle-style fly
     ///     visuals need a source/start position for a mod pile.
     /// </summary>
-    public sealed class ModCardPileFlightStartContext
+    public sealed class ModCardPileFlightStartContext : IModCardPileFlightContext
     {
         internal ModCardPileFlightStartContext(
             ModCardPileDefinition definition,
             CardPile startPile,
             CardPile targetPile,
-            Vector2 defaultStartPosition)
+            Vector2 defaultStartPosition,
+            NCard? cardNode = null)
         {
             Definition = definition;
             StartPile = startPile;
             TargetPile = targetPile;
             DefaultStartPosition = defaultStartPosition;
+            CardNode = cardNode;
         }
 
         /// <summary>
-        ///     Definition of the source pile.
+        ///     Ritsulib's default start position for this request.
         /// </summary>
-        public ModCardPileDefinition Definition { get; }
+        public Vector2 DefaultStartPosition { get; }
 
         /// <summary>
         ///     Source pile for this shuffle fly visual.
@@ -37,8 +41,17 @@ internal ModCardPileFlightStartContext(
         public CardPile TargetPile { get; }
 
         /// <summary>
-        ///     Ritsulib's default start position for this request.
+        ///     Definition of the source pile.
         /// </summary>
-        public Vector2 DefaultStartPosition { get; }
+        public ModCardPileDefinition Definition { get; }
+
+        /// <inheritdoc />
+        public Vector2 DefaultPosition => DefaultStartPosition;
+
+        /// <inheritdoc />
+        public NCard? CardNode { get; }
+
+        /// <inheritdoc />
+        public CardModel? CardModel => CardNode?.Model;
     }
 }

CardPiles/ModCardPileFlightTargetContext.cs

@@ -1,4 +1,6 @@
 using Godot;
+using MegaCrit.Sts2.Core.Entities.Cards;
+using MegaCrit.Sts2.Core.Models;
 using MegaCrit.Sts2.Core.Nodes.Cards;
 
 namespace STS2RitsuLib.CardPiles
@@ -7,7 +9,7 @@ namespace STS2RitsuLib.CardPiles
     ///     Context passed to <see cref="ModCardPileSpec.FlightTargetPositionResolver" /> each time a card
     ///     requests a fly-in target position for a mod pile.
     /// </summary>
-    public sealed class ModCardPileFlightTargetContext
+    public sealed class ModCardPileFlightTargetContext : IModCardPileFlightContext
     {
         internal ModCardPileFlightTargetContext(
             ModCardPileDefinition definition,
@@ -19,6 +21,11 @@ internal ModCardPileFlightTargetContext(
             DefaultTargetPosition = defaultTargetPosition;
         }
 
+        /// <summary>
+        ///     Ritsulib's default target position for this request.
+        /// </summary>
+        public Vector2 DefaultTargetPosition { get; }
+
         /// <summary>
         ///     Definition of the target pile.
         /// </summary>
@@ -29,9 +36,16 @@ internal ModCardPileFlightTargetContext(
         /// </summary>
         public NCard? CardNode { get; }
 
-        /// <summary>
-        ///     Ritsulib's default target position for this request.
-        /// </summary>
-        public Vector2 DefaultTargetPosition { get; }
+        /// <inheritdoc />
+        public Vector2 DefaultPosition => DefaultTargetPosition;
+
+        /// <inheritdoc />
+        public CardPile? StartPile => null;
+
+        /// <inheritdoc />
+        public CardPile? TargetPile => null;
+
+        /// <inheritdoc />
+        public CardModel? CardModel => CardNode?.Model;
     }
 }

CardPiles/ModCardPileLayout.cs

@@ -52,41 +52,55 @@ private static Vector2 GetDefaultTargetPosition(ModCardPileDefinition definition
             var fallback = FallbackPosition();
 
             if (definition.Anchor.Kind == ModCardPileAnchorKind.Custom)
-                return definition.Anchor.CustomPosition + definition.Anchor.Offset;
+                return ApplyCardNodeOffset(definition.Anchor.CustomPosition + definition.Anchor.Offset, node);
 
             var button = ModCardPileButtonRegistry.TryGetButton(definition);
             if (button != null && button.IsInsideTree())
-                return button.GlobalPosition + button.Size * 0.5f + definition.Anchor.Offset;
+                return ApplyCardNodeOffset(button.GlobalPosition + button.Size * 0.5f + definition.Anchor.Offset, node);
 
             var extraHand = ModCardPileButtonRegistry.TryGetExtraHand(definition);
             if (extraHand != null && extraHand.IsInsideTree())
-                return extraHand.GlobalPosition + extraHand.Size * 0.5f + definition.Anchor.Offset;
+                return ApplyCardNodeOffset(extraHand.GlobalPosition + extraHand.Size * 0.5f + definition.Anchor.Offset,
+                    node);
 
             if (definition.Style == ModCardPileUiStyle.TopBarDeck)
             {
                 var deck = NRun.Instance?.GlobalUi?.TopBar?.Deck;
                 if (deck != null)
-                    return deck.GlobalPosition + deck.Size * 0.5f + new Vector2(-120f, 0f) + definition.Anchor.Offset;
+                    return ApplyCardNodeOffset(
+                        deck.GlobalPosition + deck.Size * 0.5f + new Vector2(-120f, 0f) + definition.Anchor.Offset,
+                        node);
             }
 
             if (!CombatManager.Instance.IsInProgress || NCombatRoom.Instance?.Ui == null)
-                return fallback + definition.Anchor.Offset;
+                return ApplyCardNodeOffset(fallback + definition.Anchor.Offset, node);
 
             var ui = NCombatRoom.Instance.Ui;
             return definition.Style switch
             {
                 ModCardPileUiStyle.BottomLeft =>
-                    ui.DrawPile.GlobalPosition + ui.DrawPile.Size * 0.5f + new Vector2(0f, -140f) +
-                    definition.Anchor.Offset,
+                    ApplyCardNodeOffset(
+                        ui.DrawPile.GlobalPosition + ui.DrawPile.Size * 0.5f + new Vector2(0f, -140f) +
+                        definition.Anchor.Offset,
+                        node),
                 ModCardPileUiStyle.BottomRight =>
-                    ui.ExhaustPile.GlobalPosition + ui.ExhaustPile.Size * 0.5f + new Vector2(-140f, 0f) +
-                    definition.Anchor.Offset,
+                    ApplyCardNodeOffset(
+                        ui.ExhaustPile.GlobalPosition + ui.ExhaustPile.Size * 0.5f + new Vector2(-140f, 0f) +
+                        definition.Anchor.Offset,
+                        node),
                 ModCardPileUiStyle.ExtraHand =>
-                    new Vector2(fallback.X - (node?.Size.X ?? 0f) * 0.5f, fallback.Y - 260f) + definition.Anchor.Offset,
-                _ => fallback + definition.Anchor.Offset,
+                    ApplyCardNodeOffset(new Vector2(fallback.X, fallback.Y - 260f) + definition.Anchor.Offset, node),
+                _ => ApplyCardNodeOffset(fallback + definition.Anchor.Offset, node),
             };
         }
 
+        private static Vector2 ApplyCardNodeOffset(Vector2 centerPosition, NCard? node)
+        {
+            if (node == null)
+                return centerPosition;
+            return centerPosition - node.Size * 0.5f;
+        }
+
         private static Vector2 FallbackPosition()
         {
             var game = NGame.Instance;

CardPiles/Patches/ModCardPileCardFlyVfxStartPositionPatch.cs

@@ -0,0 +1,74 @@
+using System.Reflection;
+using Godot;
+using HarmonyLib;
+using MegaCrit.Sts2.Core.Entities.Cards;
+using MegaCrit.Sts2.Core.Nodes.Cards;
+using MegaCrit.Sts2.Core.Nodes.Vfx;
+using STS2RitsuLib.Patching.Models;
+
+namespace STS2RitsuLib.CardPiles.Patches
+{
+    /// <summary>
+    ///     When a card fly visual is spawned after the card has already been reparented, the node may no
+    ///     longer carry enough "old pile" context to choose a correct start position. This patch consults
+    ///     <see cref="ModCardPileFlightHistory" /> (fed by <see cref="CardPile.CardRemoved" />) to recover the
+    ///     source pile and applies <see cref="ModCardPileSpec.FlightStartPositionResolver" /> when the source
+    ///     pile is a mod pile.
+    /// </summary>
+    public sealed class ModCardPileCardFlyVfxStartPositionPatch : IPatchMethod
+    {
+        private static readonly FieldInfo? StartPositionField =
+            AccessTools.Field(typeof(NCardFlyVfx), "_startPos");
+
+        /// <inheritdoc />
+        public static string PatchId => "ritsulib_mod_pile_card_fly_vfx_start_position";
+
+        /// <inheritdoc />
+        public static string Description => "Allow mod piles to customize NCardFlyVfx start positions";
+
+        /// <inheritdoc />
+        public static bool IsCritical => false;
+
+        /// <inheritdoc />
+        public static ModPatchTarget[] GetTargets()
+        {
+            return [new(typeof(NCardFlyVfx), nameof(NCardFlyVfx.Create))];
+        }
+
+        // ReSharper disable InconsistentNaming
+        /// <summary>
+        ///     Post-processes the created fly vfx and overwrites its start position when the recovered
+        ///     source pile is a mod pile with a start-position resolver.
+        /// </summary>
+        public static void Postfix(NCard card, Vector2 end, bool isAddingToPile, string trailPath,
+            ref NCardFlyVfx? __result)
+        {
+            if (__result == null || StartPositionField == null)
+                return;
+
+            var model = card.Model;
+            if (model == null)
+                return;
+
+            var oldPile = ModCardPileFlightHistory.TryGetLastRemovedPile(model);
+            if (oldPile == null)
+                return;
+            if (!ModCardPileRegistry.TryGetByPileType(oldPile.Type, out var definition))
+                return;
+
+            var resolver = definition.FlightStartPositionResolver;
+            if (resolver == null)
+                return;
+
+            var targetPile = model.Pile ?? oldPile;
+            var defaultStartPosition = ModCardPileLayout.GetTargetPosition(definition, card);
+            var context =
+                new ModCardPileFlightStartContext(definition, oldPile, targetPile, defaultStartPosition, card);
+            var resolved = resolver(context) ?? defaultStartPosition;
+
+            StartPositionField.SetValue(__result, resolved);
+            card.GlobalPosition = resolved;
+        }
+        // ReSharper restore InconsistentNaming
+    }
+}

CardPiles/Patches/ModCardPileFlightHistoryCardPilePatch.cs

@@ -0,0 +1,44 @@
+using MegaCrit.Sts2.Core.Entities.Cards;
+using MegaCrit.Sts2.Core.Models;
+using STS2RitsuLib.Patching.Models;
+
+namespace STS2RitsuLib.CardPiles.Patches
+{
+    /// <summary>
+    ///     Records the last pile a card was removed from, to help flight/VFX patches recover "old pile"
+    ///     information when the call-site does not provide it.
+    /// </summary>
+    public sealed class ModCardPileFlightHistoryCardPilePatch : IPatchMethod
+    {
+        /// <inheritdoc />
+        public static string PatchId => "ritsulib_mod_pile_flight_history_card_pile_remove";
+
+        /// <inheritdoc />
+        public static string Description => "Track last removed CardPile for flight start recovery";
+
+        /// <inheritdoc />
+        public static bool IsCritical => false;
+
+        /// <inheritdoc />
+        public static ModPatchTarget[] GetTargets()
+        {
+            return
+            [
+                new(typeof(CardPile), nameof(CardPile.RemoveInternal), [typeof(CardModel), typeof(bool)]),
+            ];
+        }
+
+        // ReSharper disable InconsistentNaming
+        /// <summary>
+        ///     Records the pile a card was removed from so later VFX patches can recover the "old pile"
+        ///     context when it is not provided by the call-site.
+        /// </summary>
+        public static void Prefix(CardPile __instance, CardModel card, bool silent)
+        {
+            if (silent)
+                return;
+            ModCardPileFlightHistory.RecordRemoved(__instance, card);
+        }
+        // ReSharper restore InconsistentNaming
+    }
+}