A1 + A2

Assets/Tests/EditMode/ContinueChallengeMultiplierTests.cs

@@ -0,0 +1,77 @@
+using GeometryTD.Definition;
+using GeometryTD.UI;
+using NUnit.Framework;
+
+namespace GeometryTD.Tests.EditMode
+{
+    public sealed class ContinueChallengeMultiplierTests
+    {
+        [Test]
+        public void BuildRawData_Uses_OneX_Multiplier_For_First_Loop_And_Invalid_Input()
+        {
+            CombatInfoFormRawData firstLoop = CombatInfoFormUseCase.BuildRawData(
+                LevelThemeType.Plain,
+                levelId: 1,
+                currentPhaseIndex: 1,
+                totalPhaseCount: 4,
+                coin: 10,
+                baseHp: 20,
+                baseHpMax: 20,
+                canEnd: true);
+            CombatInfoFormRawData invalidInput = CombatInfoFormUseCase.BuildRawData(
+                LevelThemeType.Plain,
+                levelId: 1,
+                currentPhaseIndex: 0,
+                totalPhaseCount: 0,
+                coin: 10,
+                baseHp: 20,
+                baseHpMax: 20,
+                canEnd: false);
+
+            Assert.That(firstLoop.EnemyHpRateMultiplier, Is.EqualTo(1));
+            Assert.That(invalidInput.EnemyHpRateMultiplier, Is.EqualTo(1));
+        }
+
+        [Test]
+        public void BuildRawData_Doubles_EnemyHp_After_Each_Full_Loop()
+        {
+            CombatInfoFormRawData secondLoop = CombatInfoFormUseCase.BuildRawData(
+                LevelThemeType.Volcano,
+                levelId: 2,
+                currentPhaseIndex: 5,
+                totalPhaseCount: 4,
+                coin: 15,
+                baseHp: 18,
+                baseHpMax: 20,
+                canEnd: true);
+            CombatInfoFormRawData thirdLoop = CombatInfoFormUseCase.BuildRawData(
+                LevelThemeType.Mountain,
+                levelId: 3,
+                currentPhaseIndex: 9,
+                totalPhaseCount: 4,
+                coin: 20,
+                baseHp: 16,
+                baseHpMax: 20,
+                canEnd: true);
+
+            Assert.That(secondLoop.EnemyHpRateMultiplier, Is.EqualTo(2));
+            Assert.That(thirdLoop.EnemyHpRateMultiplier, Is.EqualTo(4));
+        }
+
+        [Test]
+        public void BuildRawData_Clamps_EnemyHp_Multiplier_At_IntMaxValue()
+        {
+            CombatInfoFormRawData rawData = CombatInfoFormUseCase.BuildRawData(
+                LevelThemeType.Plain,
+                levelId: 1,
+                currentPhaseIndex: 121,
+                totalPhaseCount: 4,
+                coin: 30,
+                baseHp: 10,
+                baseHpMax: 20,
+                canEnd: false);
+
+            Assert.That(rawData.EnemyHpRateMultiplier, Is.EqualTo(int.MaxValue));
+        }
+    }
+}

Assets/Tests/EditMode/ContinueChallengeMultiplierTests.cs.meta

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

Assets/Tests/EditMode/EventDefinitionFactoryTests.cs

@@ -0,0 +1,102 @@
+using GeometryTD.Definition;
+using GeometryTD.Factory;
+using Newtonsoft.Json.Linq;
+using NUnit.Framework;
+
+namespace GeometryTD.Tests.EditMode
+{
+    public sealed class EventDefinitionFactoryTests
+    {
+        [Test]
+        public void RequirementFactory_Creates_GoldAtLeast_From_Count_Or_Gold_Field()
+        {
+            EventRequirementBase countRequirement = EventRequirementFactory.Create(
+                "GoldAtLeast",
+                JObject.Parse(@"{ ""Count"": 35 }"));
+            EventRequirementBase goldRequirement = EventRequirementFactory.Create(
+                "GoldAtLeast",
+                JObject.Parse(@"{ ""Gold"": 21 }"));
+
+            Assert.That(countRequirement, Is.TypeOf<GoldAtLeastRequirement>());
+            Assert.That(((GoldAtLeastParam)countRequirement.Param).Gold, Is.EqualTo(35));
+            Assert.That(goldRequirement, Is.TypeOf<GoldAtLeastRequirement>());
+            Assert.That(((GoldAtLeastParam)goldRequirement.Param).Gold, Is.EqualTo(21));
+        }
+
+        [Test]
+        public void RequirementFactory_Creates_Component_And_Relic_Requirements_With_Expected_Params()
+        {
+            EventRequirementBase compRequirement = EventRequirementFactory.Create(
+                "CompCountAtLeast",
+                JObject.Parse(@"{ ""Count"": 2, ""Rarity"": ""Blue"" }"));
+            EventRequirementBase relicRequirement = EventRequirementFactory.Create(
+                "HasRelic",
+                JObject.Parse(@"{ ""Id"": 9001 }"));
+
+            Assert.That(compRequirement, Is.TypeOf<CompCountAtLeastRequirement>());
+            CompCountAtLeastParam compParam = (CompCountAtLeastParam)compRequirement.Param;
+            Assert.That(compParam.Count, Is.EqualTo(2));
+            Assert.That(compParam.Rarity, Is.EqualTo(RarityType.Blue));
+
+            Assert.That(relicRequirement, Is.TypeOf<HasRelicRequirement>());
+            Assert.That(((HasRelicParam)relicRequirement.Param).RelicId, Is.EqualTo(9001));
+        }
+
+        [Test]
+        public void EffectFactory_Creates_AddGold_And_Component_Effects_With_Probability()
+        {
+            EventEffectBase addGoldEffect = EventEffectFactory.Create(
+                "AddGold",
+                JObject.Parse(@"{ ""Count"": 80 }"),
+                0.75f);
+            EventEffectBase addRandomCompEffect = EventEffectFactory.Create(
+                "AddRandomComps",
+                JObject.Parse(@"{ ""Count"": 1, ""Rarity"": ""Purple"" }"),
+                0.5f);
+            EventEffectBase removeRandomCompEffect = EventEffectFactory.Create(
+                "RemoveRandomComps",
+                JObject.Parse(@"{ ""Count"": 2, ""Rarity"": ""Blue"" }"),
+                0.25f);
+
+            Assert.That(addGoldEffect, Is.TypeOf<AddGoldEffect>());
+            Assert.That(((AddGoldParam)addGoldEffect.Param).Count, Is.EqualTo(80));
+            Assert.That(addGoldEffect.Probability, Is.EqualTo(0.75f));
+
+            Assert.That(addRandomCompEffect, Is.TypeOf<AddRandomCompsEffect>());
+            AddRandomCompsParam addParam = (AddRandomCompsParam)addRandomCompEffect.Param;
+            Assert.That(addParam.Count, Is.EqualTo(1));
+            Assert.That(addParam.Rarity, Is.EqualTo(RarityType.Purple));
+            Assert.That(addRandomCompEffect.Probability, Is.EqualTo(0.5f));
+
+            Assert.That(removeRandomCompEffect, Is.TypeOf<RemoveRandomCompsEffect>());
+            RemoveRandomCompsParam removeParam = (RemoveRandomCompsParam)removeRandomCompEffect.Param;
+            Assert.That(removeParam.Count, Is.EqualTo(2));
+            Assert.That(removeParam.Rarity, Is.EqualTo(RarityType.Blue));
+            Assert.That(removeRandomCompEffect.Probability, Is.EqualTo(0.25f));
+        }
+
+        [Test]
+        public void EffectFactory_Creates_DamageRandomTowerEnduranceEffect_With_Expected_Params()
+        {
+            EventEffectBase effect = EventEffectFactory.Create(
+                "DamageRandomTowersEndurance",
+                JObject.Parse(@"{ ""Count"": 3, ""Amount"": 15 }"),
+                0.4f);
+
+            Assert.That(effect, Is.TypeOf<DamageRandomTowerEnduranceEffect>());
+            DamageRandomTowerEnduranceParam param = (DamageRandomTowerEnduranceParam)effect.Param;
+            Assert.That(param.Count, Is.EqualTo(3));
+            Assert.That(param.Amount, Is.EqualTo(15));
+            Assert.That(effect.Probability, Is.EqualTo(0.4f));
+        }
+
+        [Test]
+        public void Factories_Return_Null_For_Unsupported_Or_Empty_Type()
+        {
+            Assert.That(EventRequirementFactory.Create(string.Empty, JObject.Parse("{}")), Is.Null);
+            Assert.That(EventRequirementFactory.Create("UnknownRequirement", JObject.Parse("{}")), Is.Null);
+            Assert.That(EventEffectFactory.Create(string.Empty, JObject.Parse("{}")), Is.Null);
+            Assert.That(EventEffectFactory.Create("UnknownEffect", JObject.Parse("{}")), Is.Null);
+        }
+    }
+}

Assets/Tests/EditMode/EventDefinitionFactoryTests.cs.meta

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

Assets/Tests/EditMode/GeometryTD.Tests.EditMode.asmdef

@@ -3,7 +3,9 @@
     "rootNamespace": "GeometryTD.Tests.EditMode",
     "references": [
         "GeometryTD.Runtime",
-        "UnityGameFramework.Runtime"
+        "UnityGameFramework.Runtime",
+        "UnityEngine.TestRunner",
+        "UnityEditor.TestRunner"
     ],
     "includePlatforms": [
         "Editor"
@@ -12,13 +14,14 @@
     "allowUnsafeCode": false,
     "overrideReferences": true,
     "precompiledReferences": [
-        "GameFramework.dll"
+        "GameFramework.dll",
+        "nunit.framework.dll",
+        "Newtonsoft.Json.dll"
     ],
     "autoReferenced": false,
-    "defineConstraints": [],
+    "defineConstraints": [
+        "UNITY_INCLUDE_TESTS"
+    ],
     "versionDefines": [],
-    "noEngineReferences": false,
-    "optionalUnityReferences": [
-        "TestAssemblies"
-    ]
-}
+    "noEngineReferences": false
+}

Assets/Tests/EditMode/ProcedureMainFlowTests.cs

@@ -98,7 +98,7 @@ namespace GeometryTD.Tests.EditMode
                     0,
                     RunNodeCompletionStatus.Completed,
                     true,
-                    new BackpackInventoryData { Gold = 77 }));
+                    CreateCompletionSnapshot(new BackpackInventoryData { Gold = 77 })));
 
             Assert.That(GetFlowPhase(procedure), Is.EqualTo(ProcedureMainFlowPhase.Hub));
             Assert.That(runState.CurrentNodeIndex, Is.EqualTo(1));
@@ -133,7 +133,7 @@ namespace GeometryTD.Tests.EditMode
                     0,
                     RunNodeCompletionStatus.Exception,
                     false,
-                    new BackpackInventoryData { Gold = 12 }));
+                    CreateCompletionSnapshot(new BackpackInventoryData { Gold = 12 })));
 
             Assert.That(GetFlowPhase(procedure), Is.EqualTo(ProcedureMainFlowPhase.Hub));
             Assert.That(runState.CurrentNodeIndex, Is.EqualTo(0));
@@ -165,7 +165,7 @@ namespace GeometryTD.Tests.EditMode
                     0,
                     RunNodeCompletionStatus.Completed,
                     true,
-                    brokenSnapshot));
+                    CreateCompletionSnapshot(brokenSnapshot)));
 
             BackpackInventoryData replacedInventory = inventoryComponent.GetInventorySnapshot();
             DialogFormRawData dialogRawData = recorderRouter.DialogController.LastOpenedUserData as DialogFormRawData;
@@ -180,7 +180,8 @@ namespace GeometryTD.Tests.EditMode
         }
 
         [Test]
-        public void OnNodeComplete_Boss_Run_Completed_Shows_Run_Complete_Dialog_And_Does_Not_Override_It_With_Cleanup_Dialog()
+        public void
+            OnNodeComplete_Boss_Run_Completed_Shows_Run_Complete_Dialog_And_Does_Not_Override_It_With_Cleanup_Dialog()
         {
             RecorderUIRouter recorderRouter = CreateBoundUIRouter();
             PlayerInventoryComponent inventoryComponent = CreateBoundPlayerInventory(CreateParticipantInventory(100f));
@@ -207,7 +208,7 @@ namespace GeometryTD.Tests.EditMode
                     0,
                     RunNodeCompletionStatus.Completed,
                     true,
-                    brokenSnapshot));
+                    CreateCompletionSnapshot(brokenSnapshot)));
 
             BackpackInventoryData replacedInventory = inventoryComponent.GetInventorySnapshot();
             DialogFormRawData dialogRawData = recorderRouter.DialogController.LastOpenedUserData as DialogFormRawData;
@@ -220,7 +221,8 @@ namespace GeometryTD.Tests.EditMode
             Assert.That(recorderRouter.DialogController.OpenCount, Is.EqualTo(1));
             Assert.That(dialogRawData, Is.Not.Null);
             Assert.That(dialogRawData.Title, Is.EqualTo("Run Complete"));
-            Assert.That(dialogRawData.Message, Is.EqualTo("Boss node completed. This run is finished and will return to the main menu."));
+            Assert.That(dialogRawData.Message,
+                Is.EqualTo("Boss node completed. This run is finished and will return to the main menu."));
             Assert.That(dialogRawData.OnClickConfirm, Is.Not.Null);
 
             dialogRawData.OnClickConfirm(null);
@@ -428,7 +430,8 @@ namespace GeometryTD.Tests.EditMode
                 new BackpackInventoryData { Gold = 50 },
                 new[]
                 {
-                    new RunNodeSeed { NodeId = 101, NodeType = RunNodeType.Combat, LinkedLevelId = 1, SequenceIndex = 0 },
+                    new RunNodeSeed
+                        { NodeId = 101, NodeType = RunNodeType.Combat, LinkedLevelId = 1, SequenceIndex = 0 },
                     new RunNodeSeed { NodeId = 102, NodeType = RunNodeType.Event, SequenceIndex = 1 }
                 },
                 "testrun");
@@ -467,6 +470,20 @@ namespace GeometryTD.Tests.EditMode
             return inventory;
         }
 
+        private static RunNodeCompletionSnapshot CreateCompletionSnapshot(BackpackInventoryData inventorySnapshot)
+        {
+            return new RunNodeCompletionSnapshot
+            {
+                InventorySnapshot = inventorySnapshot,
+                ThemeType = LevelThemeType.Plain,
+                ThemeStageIndex = 0,
+                CurrentThemePool = new List<LevelThemeType> { LevelThemeType.Plain },
+                ThemeHistory = new List<LevelThemeType> { LevelThemeType.Plain },
+                CurrentNodeContinueChallengeLayer = 0,
+                RunItems = new List<RunItemState>()
+            };
+        }
+
         private sealed class RecorderUIRouter
         {
             private readonly Dictionary<UIFormType, RecorderController> _controllers = new();

Assets/Tests/EditMode/ProcedureMainServicesTests.cs

@@ -16,7 +16,7 @@ namespace GeometryTD.Tests.EditMode
             ProcedureMainRunAdvanceResult result = ProcedureMainRunFlowService.TryAdvanceRun(
                 runState,
                 RunNodeCompletionStatus.Completed,
-                new BackpackInventoryData { Gold = 88 });
+                CreateCompletionSnapshot(new BackpackInventoryData { Gold = 88 }, continueChallengeLayer: 4));
 
             Assert.That(result, Is.EqualTo(ProcedureMainRunAdvanceResult.AdvancedToNextNode));
             Assert.That(runState.IsCompleted, Is.False);
@@ -24,6 +24,7 @@ namespace GeometryTD.Tests.EditMode
             Assert.That(runState.CurrentNodeIndex, Is.EqualTo(1));
             Assert.That(runState.CurrentNode.Status, Is.EqualTo(RunNodeStatus.Available));
             Assert.That(runState.RunInventorySnapshot.Gold, Is.EqualTo(88));
+            Assert.That(runState.CurrentNodeContinueChallengeLayer, Is.EqualTo(0));
         }
 
         [Test]
@@ -34,7 +35,7 @@ namespace GeometryTD.Tests.EditMode
             ProcedureMainRunAdvanceResult result = ProcedureMainRunFlowService.TryAdvanceRun(
                 runState,
                 RunNodeCompletionStatus.Exception,
-                new BackpackInventoryData { Gold = 5 });
+                CreateCompletionSnapshot(new BackpackInventoryData { Gold = 5 }, continueChallengeLayer: 2));
 
             Assert.That(result, Is.EqualTo(ProcedureMainRunAdvanceResult.NodeException));
             Assert.That(runState.IsCompleted, Is.False);
@@ -42,6 +43,7 @@ namespace GeometryTD.Tests.EditMode
             Assert.That(runState.CurrentNode.Status, Is.EqualTo(RunNodeStatus.Exception));
             Assert.That(runState.Nodes[1].Status, Is.EqualTo(RunNodeStatus.Locked));
             Assert.That(runState.RunInventorySnapshot.Gold, Is.EqualTo(5));
+            Assert.That(runState.CurrentNodeContinueChallengeLayer, Is.EqualTo(2));
         }
 
         [Test]
@@ -58,7 +60,7 @@ namespace GeometryTD.Tests.EditMode
             ProcedureMainRunAdvanceResult result = ProcedureMainRunFlowService.TryAdvanceRun(
                 runState,
                 RunNodeCompletionStatus.Completed,
-                new BackpackInventoryData { Gold = 123 });
+                CreateCompletionSnapshot(new BackpackInventoryData { Gold = 123 }));
 
             Assert.That(result, Is.EqualTo(ProcedureMainRunAdvanceResult.RunCompleted));
             Assert.That(runState.IsCompleted, Is.True);
@@ -73,7 +75,7 @@ namespace GeometryTD.Tests.EditMode
             ProcedureMainRunAdvanceResult nullRunResult = ProcedureMainRunFlowService.TryAdvanceRun(
                 null,
                 RunNodeCompletionStatus.Completed,
-                new BackpackInventoryData { Gold = 1 });
+                CreateCompletionSnapshot(new BackpackInventoryData { Gold = 1 }));
 
             Assert.That(nullRunResult, Is.EqualTo(ProcedureMainRunAdvanceResult.NoChange));
 
@@ -85,7 +87,7 @@ namespace GeometryTD.Tests.EditMode
             ProcedureMainRunAdvanceResult completedRunResult = ProcedureMainRunFlowService.TryAdvanceRun(
                 completedRun,
                 RunNodeCompletionStatus.Completed,
-                new BackpackInventoryData { Gold = 20 });
+                CreateCompletionSnapshot(new BackpackInventoryData { Gold = 20 }));
 
             Assert.That(completedRunResult, Is.EqualTo(ProcedureMainRunAdvanceResult.NoChange));
             Assert.That(completedRun.RunInventorySnapshot.Gold, Is.EqualTo(10));
@@ -99,12 +101,13 @@ namespace GeometryTD.Tests.EditMode
             ProcedureMainRunAdvanceResult result = ProcedureMainRunFlowService.TryAdvanceRun(
                 runState,
                 RunNodeCompletionStatus.None,
-                new BackpackInventoryData { Gold = 999 });
+                CreateCompletionSnapshot(new BackpackInventoryData { Gold = 999 }, themeStageIndex: 4));
 
             Assert.That(result, Is.EqualTo(ProcedureMainRunAdvanceResult.NoChange));
             Assert.That(runState.CurrentNodeIndex, Is.EqualTo(0));
             Assert.That(runState.CurrentNode.Status, Is.EqualTo(RunNodeStatus.Available));
             Assert.That(runState.RunInventorySnapshot.Gold, Is.EqualTo(999));
+            Assert.That(runState.ThemeStageIndex, Is.EqualTo(4));
         }
 
         [Test]
@@ -462,5 +465,31 @@ namespace GeometryTD.Tests.EditMode
             inventory.ParticipantTowerInstanceIds.Add(90001);
             return inventory;
         }
+
+        private static RunNodeCompletionSnapshot CreateCompletionSnapshot(
+            BackpackInventoryData inventorySnapshot,
+            LevelThemeType themeType = LevelThemeType.Plain,
+            int themeStageIndex = 0,
+            int continueChallengeLayer = 0)
+        {
+            RunNodeCompletionSnapshot snapshot = new RunNodeCompletionSnapshot
+            {
+                InventorySnapshot = inventorySnapshot,
+                ThemeType = themeType,
+                ThemeStageIndex = themeStageIndex,
+                CurrentThemePool = new System.Collections.Generic.List<LevelThemeType>(),
+                ThemeHistory = new System.Collections.Generic.List<LevelThemeType>(),
+                CurrentNodeContinueChallengeLayer = continueChallengeLayer,
+                RunItems = new System.Collections.Generic.List<RunItemState>()
+            };
+
+            if (themeType != LevelThemeType.None)
+            {
+                snapshot.CurrentThemePool.Add(themeType);
+                snapshot.ThemeHistory.Add(themeType);
+            }
+
+            return snapshot;
+        }
     }
 }

Assets/Tests/EditMode/RunStateTests.cs

@@ -38,6 +38,11 @@ namespace GeometryTD.Tests.EditMode
             Assert.That(runState.Nodes[0].Status, Is.EqualTo(RunNodeStatus.Available));
             Assert.That(runState.Nodes[1].Status, Is.EqualTo(RunNodeStatus.Locked));
             Assert.That(runState.RunInventorySnapshot.Gold, Is.EqualTo(120));
+            Assert.That(runState.ThemeStageIndex, Is.EqualTo(0));
+            Assert.That(runState.CurrentThemePool, Is.EqualTo(new[] { LevelThemeType.Plain }));
+            Assert.That(runState.ThemeHistory, Is.EqualTo(new[] { LevelThemeType.Plain }));
+            Assert.That(runState.CurrentNodeContinueChallengeLayer, Is.EqualTo(0));
+            Assert.That(runState.RunItems, Is.Empty);
 
             sourceInventory.Gold = 1;
             sourceInventory.ParticipantTowerInstanceIds[0] = 99;
@@ -62,22 +67,30 @@ namespace GeometryTD.Tests.EditMode
             bool firstCompleted = RunStateAdvanceService.TryCompleteCurrentNode(
                 runState,
                 RunNodeCompletionStatus.Completed,
-                new BackpackInventoryData { Gold = 80 });
+                CreateCompletionSnapshot(
+                    new BackpackInventoryData { Gold = 80 },
+                    continueChallengeLayer: 3,
+                    runItemId: 1001,
+                    runItemStackCount: 2));
 
             Assert.That(firstCompleted, Is.True);
             Assert.That(runState.Nodes[0].Status, Is.EqualTo(RunNodeStatus.Completed));
             Assert.That(runState.CurrentNodeIndex, Is.EqualTo(1));
             Assert.That(runState.Nodes[1].Status, Is.EqualTo(RunNodeStatus.Available));
             Assert.That(runState.RunInventorySnapshot.Gold, Is.EqualTo(80));
+            Assert.That(runState.CurrentNodeContinueChallengeLayer, Is.EqualTo(0));
+            Assert.That(runState.RunItems.Count, Is.EqualTo(1));
+            Assert.That(runState.RunItems[0].ItemId, Is.EqualTo(1001));
+            Assert.That(runState.RunItems[0].StackCount, Is.EqualTo(2));
 
             RunStateAdvanceService.TryCompleteCurrentNode(
                 runState,
                 RunNodeCompletionStatus.Completed,
-                new BackpackInventoryData { Gold = 95 });
+                CreateCompletionSnapshot(new BackpackInventoryData { Gold = 95 }));
             RunStateAdvanceService.TryCompleteCurrentNode(
                 runState,
                 RunNodeCompletionStatus.Completed,
-                new BackpackInventoryData { Gold = 130 });
+                CreateCompletionSnapshot(new BackpackInventoryData { Gold = 130 }));
 
             Assert.That(runState.IsCompleted, Is.True);
             Assert.That(runState.CurrentNodeIndex, Is.EqualTo(3));
@@ -124,19 +137,26 @@ namespace GeometryTD.Tests.EditMode
             bool result = RunStateAdvanceService.TryCompleteCurrentNode(
                 runState,
                 RunNodeCompletionStatus.Exception,
-                new BackpackInventoryData { Gold = 5 });
+                CreateCompletionSnapshot(new BackpackInventoryData { Gold = 5 }, continueChallengeLayer: 4));
 
             Assert.That(result, Is.True);
             Assert.That(runState.IsCompleted, Is.False);
             Assert.That(runState.CurrentNodeIndex, Is.EqualTo(0));
             Assert.That(runState.CurrentNode.Status, Is.EqualTo(RunNodeStatus.Exception));
             Assert.That(runState.RunInventorySnapshot.Gold, Is.EqualTo(5));
+            Assert.That(runState.CurrentNodeContinueChallengeLayer, Is.EqualTo(4));
         }
 
         [Test]
-        public void NodeCompleteEventArgs_Completed_Win_Clones_Inventory_And_Clears_State()
+        public void NodeCompleteEventArgs_Completed_Win_Clones_CompletionSnapshot_And_Clears_State()
         {
-            BackpackInventoryData inventory = new BackpackInventoryData { Gold = 66 };
+            RunNodeCompletionSnapshot completionSnapshot = CreateCompletionSnapshot(
+                new BackpackInventoryData { Gold = 66 },
+                themeType: LevelThemeType.Volcano,
+                themeStageIndex: 2,
+                continueChallengeLayer: 5,
+                runItemId: 901,
+                runItemStackCount: 3);
             NodeCompleteEventArgs eventArgs = NodeCompleteEventArgs.Create(
                 "run-1",
                 7,
@@ -144,9 +164,11 @@ namespace GeometryTD.Tests.EditMode
                 3,
                 RunNodeCompletionStatus.Completed,
                 true,
-                inventory);
+                completionSnapshot);
 
-            inventory.Gold = 1;
+            completionSnapshot.InventorySnapshot.Gold = 1;
+            completionSnapshot.CurrentThemePool[0] = LevelThemeType.Mountain;
+            completionSnapshot.RunItems[0].StackCount = 99;
 
             Assert.That(eventArgs.RunId, Is.EqualTo("run-1"));
             Assert.That(eventArgs.NodeId, Is.EqualTo(7));
@@ -154,7 +176,11 @@ namespace GeometryTD.Tests.EditMode
             Assert.That(eventArgs.SequenceIndex, Is.EqualTo(3));
             Assert.That(eventArgs.CompletionStatus, Is.EqualTo(RunNodeCompletionStatus.Completed));
             Assert.That(eventArgs.CombatWon, Is.True);
-            Assert.That(eventArgs.InventorySnapshotAfterNode.Gold, Is.EqualTo(66));
+            Assert.That(eventArgs.CompletionSnapshot.InventorySnapshot.Gold, Is.EqualTo(66));
+            Assert.That(eventArgs.CompletionSnapshot.ThemeType, Is.EqualTo(LevelThemeType.Volcano));
+            Assert.That(eventArgs.CompletionSnapshot.ThemeStageIndex, Is.EqualTo(2));
+            Assert.That(eventArgs.CompletionSnapshot.CurrentThemePool, Is.EqualTo(new[] { LevelThemeType.Volcano }));
+            Assert.That(eventArgs.CompletionSnapshot.RunItems[0].StackCount, Is.EqualTo(3));
 
             eventArgs.Clear();
 
@@ -164,13 +190,13 @@ namespace GeometryTD.Tests.EditMode
             Assert.That(eventArgs.SequenceIndex, Is.EqualTo(-1));
             Assert.That(eventArgs.CompletionStatus, Is.EqualTo(RunNodeCompletionStatus.None));
             Assert.That(eventArgs.CombatWon, Is.False);
-            Assert.That(eventArgs.InventorySnapshotAfterNode, Is.Null);
+            Assert.That(eventArgs.CompletionSnapshot, Is.Null);
         }
 
         [Test]
         public void NodeCompleteEventArgs_Completed_Loss_Preserves_NonWin_Semantics()
         {
-            BackpackInventoryData inventory = new BackpackInventoryData { Gold = 12 };
+            RunNodeCompletionSnapshot completionSnapshot = CreateCompletionSnapshot(new BackpackInventoryData { Gold = 12 });
             NodeCompleteEventArgs eventArgs = NodeCompleteEventArgs.Create(
                 "run-2",
                 8,
@@ -178,9 +204,9 @@ namespace GeometryTD.Tests.EditMode
                 4,
                 RunNodeCompletionStatus.Completed,
                 false,
-                inventory);
+                completionSnapshot);
 
-            inventory.Gold = 99;
+            completionSnapshot.InventorySnapshot.Gold = 99;
 
             Assert.That(eventArgs.RunId, Is.EqualTo("run-2"));
             Assert.That(eventArgs.NodeId, Is.EqualTo(8));
@@ -188,13 +214,13 @@ namespace GeometryTD.Tests.EditMode
             Assert.That(eventArgs.SequenceIndex, Is.EqualTo(4));
             Assert.That(eventArgs.CompletionStatus, Is.EqualTo(RunNodeCompletionStatus.Completed));
             Assert.That(eventArgs.CombatWon, Is.False);
-            Assert.That(eventArgs.InventorySnapshotAfterNode.Gold, Is.EqualTo(12));
+            Assert.That(eventArgs.CompletionSnapshot.InventorySnapshot.Gold, Is.EqualTo(12));
         }
 
         [Test]
         public void NodeCompleteEventArgs_Exception_Preserves_Exception_Semantics()
         {
-            BackpackInventoryData inventory = new BackpackInventoryData { Gold = 7 };
+            RunNodeCompletionSnapshot completionSnapshot = CreateCompletionSnapshot(new BackpackInventoryData { Gold = 7 });
             NodeCompleteEventArgs eventArgs = NodeCompleteEventArgs.Create(
                 "run-3",
                 9,
@@ -202,9 +228,9 @@ namespace GeometryTD.Tests.EditMode
                 5,
                 RunNodeCompletionStatus.Exception,
                 false,
-                inventory);
+                completionSnapshot);
 
-            inventory.Gold = 100;
+            completionSnapshot.InventorySnapshot.Gold = 100;
 
             Assert.That(eventArgs.RunId, Is.EqualTo("run-3"));
             Assert.That(eventArgs.NodeId, Is.EqualTo(9));
@@ -212,7 +238,54 @@ namespace GeometryTD.Tests.EditMode
             Assert.That(eventArgs.SequenceIndex, Is.EqualTo(5));
             Assert.That(eventArgs.CompletionStatus, Is.EqualTo(RunNodeCompletionStatus.Exception));
             Assert.That(eventArgs.CombatWon, Is.False);
-            Assert.That(eventArgs.InventorySnapshotAfterNode.Gold, Is.EqualTo(7));
+            Assert.That(eventArgs.CompletionSnapshot.InventorySnapshot.Gold, Is.EqualTo(7));
+        }
+
+        [Test]
+        public void CreateCurrentNodeContext_Clones_Run_State_Collections()
+        {
+            RunState runState = RunStateFactory.Create(
+                LevelThemeType.Plain,
+                new BackpackInventoryData { Gold = 20 },
+                new[]
+                {
+                    new RunNodeSeed { NodeId = 99, NodeType = RunNodeType.Combat, LinkedLevelId = 1 },
+                    new RunNodeSeed { NodeId = 100, NodeType = RunNodeType.Event }
+                });
+
+            RunNodeCompletionSnapshot seededSnapshot = new RunNodeCompletionSnapshot
+            {
+                InventorySnapshot = new BackpackInventoryData { Gold = 35 },
+                ThemeType = LevelThemeType.Mountain,
+                ThemeStageIndex = 3,
+                CurrentThemePool = new List<LevelThemeType> { LevelThemeType.Mountain, LevelThemeType.Volcano },
+                ThemeHistory = new List<LevelThemeType> { LevelThemeType.Plain, LevelThemeType.Mountain },
+                CurrentNodeContinueChallengeLayer = 6,
+                RunItems = new List<RunItemState>
+                {
+                    new RunItemState { ItemId = 2001, StackCount = 4 }
+                }
+            };
+            RunStateAdvanceService.TryCompleteCurrentNode(
+                runState,
+                RunNodeCompletionStatus.Completed,
+                seededSnapshot);
+            runState.ApplyCompletionSnapshot(seededSnapshot);
+
+            RunNodeExecutionContext context = runState.CreateCurrentNodeContext();
+
+            runState.CurrentThemePool[0] = LevelThemeType.Plain;
+            runState.ThemeHistory[0] = LevelThemeType.Volcano;
+            runState.RunItems[0].StackCount = 1;
+
+            Assert.That(context.RunId, Is.EqualTo(runState.RunId));
+            Assert.That(context.NodeId, Is.EqualTo(100));
+            Assert.That(context.ThemeStageIndex, Is.EqualTo(3));
+            Assert.That(context.CurrentThemePool, Is.EqualTo(new[] { LevelThemeType.Mountain, LevelThemeType.Volcano }));
+            Assert.That(context.ThemeHistory, Is.EqualTo(new[] { LevelThemeType.Plain, LevelThemeType.Mountain }));
+            Assert.That(context.CurrentNodeContinueChallengeLayer, Is.EqualTo(6));
+            Assert.That(context.RunItems[0].ItemId, Is.EqualTo(2001));
+            Assert.That(context.RunItems[0].StackCount, Is.EqualTo(4));
         }
 
         [Test]
@@ -275,7 +348,7 @@ namespace GeometryTD.Tests.EditMode
                 bool advanced = RunStateAdvanceService.TryCompleteCurrentNode(
                     runState,
                     RunNodeCompletionStatus.Completed,
-                    new BackpackInventoryData { Gold = 100 + i });
+                    CreateCompletionSnapshot(new BackpackInventoryData { Gold = 100 + i }));
 
                 Assert.That(advanced, Is.True);
             }
@@ -285,5 +358,42 @@ namespace GeometryTD.Tests.EditMode
             Assert.That(runState.CurrentNodeIndex, Is.EqualTo(10));
             Assert.That(runState.RunInventorySnapshot.Gold, Is.EqualTo(109));
         }
+
+        private static RunNodeCompletionSnapshot CreateCompletionSnapshot(
+            BackpackInventoryData inventorySnapshot,
+            LevelThemeType themeType = LevelThemeType.Plain,
+            int themeStageIndex = 0,
+            int continueChallengeLayer = 0,
+            int runItemId = 0,
+            int runItemStackCount = 0)
+        {
+            RunNodeCompletionSnapshot snapshot = new RunNodeCompletionSnapshot
+            {
+                InventorySnapshot = inventorySnapshot,
+                ThemeType = themeType,
+                ThemeStageIndex = themeStageIndex,
+                CurrentThemePool = new List<LevelThemeType>(),
+                ThemeHistory = new List<LevelThemeType>(),
+                CurrentNodeContinueChallengeLayer = continueChallengeLayer,
+                RunItems = new List<RunItemState>()
+            };
+
+            if (themeType != LevelThemeType.None)
+            {
+                snapshot.CurrentThemePool.Add(themeType);
+                snapshot.ThemeHistory.Add(themeType);
+            }
+
+            if (runItemId > 0)
+            {
+                snapshot.RunItems.Add(new RunItemState
+                {
+                    ItemId = runItemId,
+                    StackCount = runItemStackCount
+                });
+            }
+
+            return snapshot;
+        }
     }
 }

Assets/Tests/EditMode/ShopPricingRuleTests.cs

@@ -0,0 +1,295 @@
+using System.Collections;
+using System;
+using System.Collections.Generic;
+using System.Reflection;
+using GameFramework.DataTable;
+using GeometryTD.CustomComponent;
+using GeometryTD.DataTable;
+using GeometryTD.Definition;
+using GeometryTD.UI;
+using NUnit.Framework;
+
+namespace GeometryTD.Tests.EditMode
+{
+    public sealed class ShopPricingRuleTests
+    {
+        [Test]
+        public void BuildGoods_Uses_Price_Row_Range_Matching_Item_Rarity()
+        {
+            ShopGoodsBuilder builder = CreateBuilder(
+                CreateShopPriceRow(1, RarityType.Blue, 30, 35),
+                CreateShopPriceRow(2, RarityType.Purple, 60, 70));
+
+            List<GoodsItemRawData> goods = builder.BuildGoods(goodsCount: 12, runSeed: 3001, sequenceIndex: 4);
+
+            Assert.That(goods, Has.Count.EqualTo(12));
+            for (int i = 0; i < goods.Count; i++)
+            {
+                GoodsItemRawData item = goods[i];
+                Assert.That(item, Is.Not.Null);
+                Assert.That(item.SourceItem, Is.Not.Null);
+
+                switch (item.SourceItem.Rarity)
+                {
+                    case RarityType.Blue:
+                        Assert.That(item.Price, Is.InRange(30, 35));
+                        break;
+                    case RarityType.Purple:
+                        Assert.That(item.Price, Is.InRange(60, 70));
+                        break;
+                    default:
+                        Assert.Fail($"Unexpected rarity generated for goods item {i}: {item.SourceItem.Rarity}");
+                        break;
+                }
+            }
+        }
+
+        [Test]
+        public void BuildGoods_Is_Reproducible_For_Same_RunSeed_And_SequenceIndex()
+        {
+            ShopGoodsBuilder builder = CreateBuilder(
+                CreateShopPriceRow(1, RarityType.Blue, 30, 35),
+                CreateShopPriceRow(2, RarityType.Purple, 60, 70));
+
+            string first = BuildGoodsSignature(builder.BuildGoods(goodsCount: 4, runSeed: 901, sequenceIndex: 7));
+            string second = BuildGoodsSignature(builder.BuildGoods(goodsCount: 4, runSeed: 901, sequenceIndex: 7));
+
+            Assert.That(second, Is.EqualTo(first));
+        }
+
+        [Test]
+        public void ResolveRandomPrice_Returns_Zero_When_Rarity_Has_No_Price_Row()
+        {
+            ShopGoodsBuilder builder = CreateBuilder(CreateShopPriceRow(1, RarityType.Blue, 30, 35));
+            MethodInfo method = typeof(ShopGoodsBuilder).GetMethod(
+                "ResolveRandomPrice",
+                BindingFlags.Instance | BindingFlags.NonPublic);
+
+            Assert.That(method, Is.Not.Null);
+
+            int resolvedPrice = (int)method.Invoke(builder, new object[] { RarityType.Red, new Random(7) });
+
+            Assert.That(resolvedPrice, Is.EqualTo(0));
+        }
+
+        private static ShopGoodsBuilder CreateBuilder(params DRShopPrice[] shopPriceRows)
+        {
+            return new ShopGoodsBuilder(
+                shopPriceRows,
+                new FakeDataTable<DRMuzzleComp>(CreateMuzzleRow(1, "火焰枪口")),
+                new FakeDataTable<DRBearingComp>(CreateBearingRow(1, "寒冰轴承")),
+                new FakeDataTable<DRBaseComp>(CreateBaseRow(1, "迅捷底座")));
+        }
+
+        private static string BuildGoodsSignature(IReadOnlyList<GoodsItemRawData> goods)
+        {
+            List<string> parts = new List<string>(goods.Count);
+            for (int i = 0; i < goods.Count; i++)
+            {
+                GoodsItemRawData item = goods[i];
+                parts.Add($"{item.GoodsIndex}:{item.Price}:{item.SourceItem.SlotType}:{item.SourceItem.Rarity}:{item.SourceItem.ConfigId}");
+            }
+
+            return string.Join("|", parts);
+        }
+
+        private static DRShopPrice CreateShopPriceRow(int id, RarityType rarity, int minPrice, int maxPrice)
+        {
+            DRShopPrice row = new DRShopPrice();
+            Assert.That(row.ParseDataRow($"\t{id}\t\t{rarity}\t{minPrice}\t{maxPrice}", null), Is.True);
+            return row;
+        }
+
+        private static DRMuzzleComp CreateMuzzleRow(int id, string name)
+        {
+            DRMuzzleComp row = new DRMuzzleComp();
+            Assert.That(
+                row.ParseDataRow($"\t{id}\t\t{name}\t[10,20,30,40,50]\t3\t0.15\tNormalBullet\t\t[Fire,Crit]", null),
+                Is.True);
+            return row;
+        }
+
+        private static DRBearingComp CreateBearingRow(int id, string name)
+        {
+            DRBearingComp row = new DRBearingComp();
+            Assert.That(
+                row.ParseDataRow($"\t{id}\t\t{name}\t[1,2,3,4,5]\t0.5\t[10,20,30,40,50]\t1\t\t[Ice,Shatter]", null),
+                Is.True);
+            return row;
+        }
+
+        private static DRBaseComp CreateBaseRow(int id, string name)
+        {
+            DRBaseComp row = new DRBaseComp();
+            Assert.That(
+                row.ParseDataRow($"\t{id}\t\t{name}\t[2,4,6,8,10]\t-0.25\tFire\t\t[Fire,Crit]", null),
+                Is.True);
+            return row;
+        }
+
+        private sealed class FakeDataTable<TRow> : IDataTable<TRow> where TRow : class, IDataRow
+        {
+            private readonly Dictionary<int, TRow> _rowsById = new();
+
+            public FakeDataTable(params TRow[] rows)
+            {
+                if (rows == null)
+                {
+                    return;
+                }
+
+                for (int i = 0; i < rows.Length; i++)
+                {
+                    TRow row = rows[i];
+                    if (row != null)
+                    {
+                        _rowsById[row.Id] = row;
+                    }
+                }
+            }
+
+            public string Name => typeof(TRow).Name;
+            public string FullName => typeof(TRow).FullName;
+            public Type Type => typeof(TRow);
+            public int Count => _rowsById.Count;
+            public TRow this[int id] => GetDataRow(id);
+            public TRow MinIdDataRow => _rowsById.Count <= 0 ? null : GetDataRow(GetOrderedIds()[0]);
+            public TRow MaxIdDataRow => _rowsById.Count <= 0 ? null : GetDataRow(GetOrderedIds()[^1]);
+
+            public bool HasDataRow(int id) => _rowsById.ContainsKey(id);
+            public bool HasDataRow(Predicate<TRow> condition) => GetDataRow(condition) != null;
+            public TRow GetDataRow(int id) => _rowsById.TryGetValue(id, out TRow row) ? row : null;
+
+            public TRow GetDataRow(Predicate<TRow> condition)
+            {
+                if (condition == null)
+                {
+                    return null;
+                }
+
+                foreach (TRow row in _rowsById.Values)
+                {
+                    if (row != null && condition(row))
+                    {
+                        return row;
+                    }
+                }
+
+                return null;
+            }
+
+            public TRow[] GetDataRows(Predicate<TRow> condition)
+            {
+                List<TRow> results = new();
+                GetDataRows(condition, results);
+                return results.ToArray();
+            }
+
+            public void GetDataRows(Predicate<TRow> condition, List<TRow> results)
+            {
+                results?.Clear();
+                if (condition == null || results == null)
+                {
+                    return;
+                }
+
+                foreach (TRow row in _rowsById.Values)
+                {
+                    if (row != null && condition(row))
+                    {
+                        results.Add(row);
+                    }
+                }
+            }
+
+            public TRow[] GetDataRows(Comparison<TRow> comparison)
+            {
+                List<TRow> results = new();
+                GetDataRows(comparison, results);
+                return results.ToArray();
+            }
+
+            public void GetDataRows(Comparison<TRow> comparison, List<TRow> results)
+            {
+                results?.Clear();
+                if (results == null)
+                {
+                    return;
+                }
+
+                results.AddRange(_rowsById.Values);
+                if (comparison != null)
+                {
+                    results.Sort(comparison);
+                }
+            }
+
+            public TRow[] GetDataRows(Predicate<TRow> condition, Comparison<TRow> comparison)
+            {
+                List<TRow> results = new();
+                GetDataRows(condition, comparison, results);
+                return results.ToArray();
+            }
+
+            public void GetDataRows(Predicate<TRow> condition, Comparison<TRow> comparison, List<TRow> results)
+            {
+                GetDataRows(condition, results);
+                if (results != null && comparison != null)
+                {
+                    results.Sort(comparison);
+                }
+            }
+
+            public TRow[] GetAllDataRows()
+            {
+                List<TRow> results = new();
+                GetAllDataRows(results);
+                return results.ToArray();
+            }
+
+            public void GetAllDataRows(List<TRow> results)
+            {
+                results?.Clear();
+                if (results == null)
+                {
+                    return;
+                }
+
+                foreach (int id in GetOrderedIds())
+                {
+                    results.Add(_rowsById[id]);
+                }
+            }
+
+            public bool AddDataRow(string dataRowString, object userData) => throw new NotSupportedException();
+            public bool AddDataRow(byte[] dataRowBytes, int startIndex, int length, object userData) => throw new NotSupportedException();
+            public bool RemoveDataRow(int id) => _rowsById.Remove(id);
+
+            public void RemoveAllDataRows()
+            {
+                _rowsById.Clear();
+            }
+
+            public IEnumerator<TRow> GetEnumerator()
+            {
+                foreach (int id in GetOrderedIds())
+                {
+                    yield return _rowsById[id];
+                }
+            }
+
+            IEnumerator IEnumerable.GetEnumerator()
+            {
+                return GetEnumerator();
+            }
+
+            private int[] GetOrderedIds()
+            {
+                int[] ids = new int[_rowsById.Count];
+                _rowsById.Keys.CopyTo(ids, 0);
+                Array.Sort(ids);
+                return ids;
+            }
+        }
+    }
+}

Assets/Tests/EditMode/ShopPricingRuleTests.cs.meta

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