装备系统完结，修复并加入很多

Assets/_eqpmtSys/equipSystems/eSmelt/SmeltStageRewardSO.asset

@@ -15,7 +15,8 @@ MonoBehaviour:
   simpleRewardAmount: 40
   _1skillRewardAmount: 100
   _2skillRewardAmount: 300
-  quickFinishCost: 200
+  startSmeltCost: 0
+  quickFinishCost: 0
   rewardRandomConfig: {fileID: 11400000, guid: ca394ccb04190524fb487491eedb36e7, type: 2}
   rewardTemplate: {fileID: 11400000, guid: 40fe16e436a81644aa688c80436aa1c1, type: 2}
   smeltEquipmentCapacity: 60
@@ -33,13 +34,13 @@ MonoBehaviour:
     chosenSkillType: 0
     equipRewardName: "60 \u81EA\u9009\u8BB0\u5FC6"
     requiredAmount: 60
-  - equipmentType: 0
-    qualityType: 0
+  - equipmentType: 1
+    qualityType: 1
     skillRequirement: 0
     chosenSkillType: 0
     equipRewardName: "200 \u81EA\u9009\u9AD8\u5929\u8D4B\u8BB0\u5FC6"
-    requiredAmount: 120
-  - equipmentType: 0
+    requiredAmount: 200
+  - equipmentType: 1
     qualityType: 0
     skillRequirement: 1
     chosenSkillType: 0

Assets/_eqpmtSys/equipSystems/eSmelt/equipSmelt.cs

@@ -1,5 +1,6 @@
-using System;
+using System;
 using System.Collections.Generic;
+using System.Linq;
 using UnityEngine;
 using UnityEngine.UI;
 using Bansonic;
@@ -11,7 +12,10 @@ public class equipSmelt : MonoBehaviour
 {
     private static readonly List<equipmentSO> SmeltPoolEquipments = new List<equipmentSO>();
     private static readonly HashSet<equipmentSO> SmeltPoolLookup = new HashSet<equipmentSO>();
+    private static readonly HashSet<string> ConsumedSmeltEquipmentIds = new HashSet<string>(StringComparer.Ordinal);
     private static readonly HashSet<equipmentSO> ConsumedSmeltEquipments = new HashSet<equipmentSO>();
+    private const string SmeltStatePrefsKey = "equip_smelt_state_v1";
+    private static bool persistenceLoaded;
     private static readonly List<equipSmelt> Instances = new List<equipSmelt>();
 
     private static bool isSmeltingState;
@@ -22,6 +26,19 @@ public class equipSmelt : MonoBehaviour
     private static int pendingStoredFragmentsState;
     private static int storedSmeltEnergyState;
 
+    [Serializable]
+    private sealed class SmeltPersistentState
+    {
+        public bool isSmelting;
+        public bool smeltCompleted;
+        public int gamesRequired;
+        public int gamesCompleted;
+        public int pendingDirectFragments;
+        public int pendingStoredFragments;
+        public int storedSmeltEnergy;
+        public string[] consumedEquipmentIds;
+    }
+
     [Header("so")]
     public smeltStageRewardSO ssrso;
 
@@ -69,9 +86,11 @@ public class equipSmelt : MonoBehaviour
     public Transform ctasParent;
 
     private readonly List<GameObject> spawnedPoolItems = new List<GameObject>();
+    private GameObject activeCtasInstance;
 
     private void Awake()
     {
+        EnsurePersistentStateLoaded();
         RegisterInstance();
         BindButtons();
         RefreshAllUi();
@@ -81,35 +100,44 @@ public class equipSmelt : MonoBehaviour
     {
         RegisterInstance();
         BindButtons();
-        settlementController.OnSettlementCompleted -= HandleSettlementCompleted;
-        settlementController.OnSettlementCompleted += HandleSettlementCompleted;
         RefreshAllUi();
     }
 
     private void OnDisable()
     {
-        settlementController.OnSettlementCompleted -= HandleSettlementCompleted;
+        CloseActiveCtas();
         Instances.Remove(this);
     }
 
     private void OnDestroy()
     {
-        settlementController.OnSettlementCompleted -= HandleSettlementCompleted;
+        CloseActiveCtas();
         Instances.Remove(this);
     }
 
     public static bool IsEquipmentAssignedToSmeltPool(equipmentSO equipment)
     {
+        EnsurePersistentStateLoaded();
         return equipment != null && SmeltPoolLookup.Contains(equipment);
     }
 
     public static bool IsEquipmentConsumedBySmelt(equipmentSO equipment)
     {
+        EnsurePersistentStateLoaded();
         return equipment != null && ConsumedSmeltEquipments.Contains(equipment);
     }
 
+    public static bool ShouldHideConsumedEquipment(equipmentSO equipment)
+    {
+        EnsurePersistentStateLoaded();
+        return equipment != null
+            && (ConsumedSmeltEquipments.Contains(equipment)
+            || (!string.IsNullOrWhiteSpace(equipment.name) && ConsumedSmeltEquipmentIds.Contains(equipment.name)));
+    }
+
     public static bool RemoveEquipmentFromSmeltPool(equipmentSO equipment)
     {
+        EnsurePersistentStateLoaded();
         if (equipment == null)
         {
             return false;
@@ -121,6 +149,7 @@ public class equipSmelt : MonoBehaviour
         }
 
         SmeltPoolEquipments.Remove(equipment);
+        SavePersistentState();
         RefreshAllSmeltPools();
         RefreshAllEquipBags();
         return true;
@@ -128,6 +157,7 @@ public class equipSmelt : MonoBehaviour
 
     public static bool TryHandleQuickTransfer(equipmentSO equipment)
     {
+        EnsurePersistentStateLoaded();
         if (equipment == null || IsEquipmentConsumedBySmelt(equipment))
         {
             return false;
@@ -148,6 +178,23 @@ public class equipSmelt : MonoBehaviour
         return IsEquipmentAssignedToSmeltPool(equipment);
     }
 
+    public static void ReinstateRewardEquipment(equipmentSO equipment)
+    {
+        EnsurePersistentStateLoaded();
+        if (equipment == null)
+        {
+            return;
+        }
+
+        ConsumedSmeltEquipments.Remove(equipment);
+        if (!string.IsNullOrWhiteSpace(equipment.name))
+        {
+            ConsumedSmeltEquipmentIds.Remove(equipment.name);
+        }
+
+        SavePersistentState();
+    }
+
     public void SetDragPreviewVisible(bool visible)
     {
         if (dragObj == null)
@@ -197,6 +244,7 @@ public class equipSmelt : MonoBehaviour
 
     public void AcceptDraggedEquipment(equipmentSO equipment)
     {
+        EnsurePersistentStateLoaded();
         if (equipment == null || IsEquipmentConsumedBySmelt(equipment) || !IsPoolOpenForTransfers())
         {
             return;
@@ -211,6 +259,7 @@ public class equipSmelt : MonoBehaviour
         if (SmeltPoolLookup.Add(equipment))
         {
             SmeltPoolEquipments.Add(equipment);
+            SavePersistentState();
             RefreshAllUi();
             RefreshAllEquipBags();
         }
@@ -256,6 +305,13 @@ public class equipSmelt : MonoBehaviour
             return;
         }
 
+        int startCost = GetStartSmeltCost();
+        if (!PlayerEconomyLedger.EnsureInstance().TrySpendCoins(startCost))
+        {
+            RefreshAllUi();
+            return;
+        }
+
         isSmeltingState = true;
         smeltCompletedState = false;
         gamesCompletedForCurrentBatchState = 0;
@@ -266,6 +322,7 @@ public class equipSmelt : MonoBehaviour
         pendingStoredFragmentsState = Mathf.Max(0, totalFragments - pendingDirectFragmentsState);
 
         ConsumeCurrentPoolEquipments();
+        SavePersistentState();
         RefreshAllUi();
         RefreshAllEquipBags();
     }
@@ -285,26 +342,40 @@ public class equipSmelt : MonoBehaviour
 
         gamesCompletedForCurrentBatchState = gamesRequiredForCurrentBatchState;
         smeltCompletedState = true;
+        SavePersistentState();
         RefreshAllUi();
     }
 
-    private void HandleSettlementCompleted()
+    public static void NotifySettlementCompleted()
     {
         if (!isSmeltingState || smeltCompletedState)
         {
             return;
         }
 
+        if (GameConfig.autoPlayEnabled)
+        {
+            return;
+        }
+
         gamesCompletedForCurrentBatchState = Mathf.Min(gamesRequiredForCurrentBatchState, gamesCompletedForCurrentBatchState + 1);
         if (gamesCompletedForCurrentBatchState >= gamesRequiredForCurrentBatchState)
         {
             smeltCompletedState = true;
+            ClaimCurrentBatchRewardsStatic();
+            return;
         }
 
-        RefreshAllUi();
+        SavePersistentState();
+        RefreshAllSmeltPools();
     }
 
     private void ClaimCurrentBatchRewards()
+    {
+        ClaimCurrentBatchRewardsStatic();
+    }
+
+    private static void ClaimCurrentBatchRewardsStatic()
     {
         if (!smeltCompletedState)
         {
@@ -316,7 +387,7 @@ public class equipSmelt : MonoBehaviour
             PlayerEconomyLedger.EnsureInstance().AddMaterial(pendingDirectFragmentsState);
         }
 
-        storedSmeltEnergyState = Mathf.Clamp(storedSmeltEnergyState + pendingStoredFragmentsState, 0, GetSmeltStorageCapacity());
+        storedSmeltEnergyState = Mathf.Clamp(storedSmeltEnergyState + pendingStoredFragmentsState, 0, GetSmeltStorageCapacityStatic());
 
         pendingDirectFragmentsState = 0;
         pendingStoredFragmentsState = 0;
@@ -324,18 +395,8 @@ public class equipSmelt : MonoBehaviour
         gamesCompletedForCurrentBatchState = 0;
         isSmeltingState = false;
         smeltCompletedState = false;
-
-        if (d_mf_Amount != null)
-        {
-            d_mf_Amount.text = "0";
-        }
-
-        if (s_mf_Amount != null)
-        {
-            s_mf_Amount.text = "0";
-        }
-
-        RefreshAllUi();
+        SavePersistentState();
+        RefreshAllSmeltPools();
         RefreshAllEquipBags();
     }
 
@@ -353,15 +414,13 @@ public class equipSmelt : MonoBehaviour
             return;
         }
 
-        equipmentSO generated = equipmentGenerator.GenerateFromSmeltReward(ssrso, requirement);
-        if (generated == null)
+        if (RequiresRewardSelection(requirement))
         {
+            OpenRewardSelector(requirement);
             return;
         }
 
-        storedSmeltEnergyState = Mathf.Max(0, storedSmeltEnergyState - requiredAmount);
-        RefreshAllUi();
-        RefreshAllEquipBags();
+        GrantReward(requirement, null, 0);
     }
 
     private void HandleRewardSelectionChanged(int _)
@@ -369,6 +428,127 @@ public class equipSmelt : MonoBehaviour
         RefreshButtons();
     }
 
+    private bool RequiresRewardSelection(smeltStageRewardSO.SmeltStageRewardRequirement requirement)
+    {
+        if (requirement == null)
+        {
+            return false;
+        }
+
+        return RequiresTypeSelection(requirement)
+            || RequiresSkillSelection(requirement);
+    }
+
+    private bool RequiresTypeSelection(smeltStageRewardSO.SmeltStageRewardRequirement requirement)
+    {
+        if (requirement == null)
+        {
+            return false;
+        }
+
+        if (requirement.equipmentType == smeltStageRewardSO.equipType.selfChosenType)
+        {
+            return true;
+        }
+
+        return !string.IsNullOrWhiteSpace(requirement.equipRewardName)
+            && requirement.equipRewardName.Contains("自选", StringComparison.Ordinal);
+    }
+
+    private bool RequiresSkillSelection(smeltStageRewardSO.SmeltStageRewardRequirement requirement)
+    {
+        return requirement != null
+            && requirement.skillRequirement == smeltStageRewardSO.skillOwned.selfChosen;
+    }
+
+    private void OpenRewardSelector(smeltStageRewardSO.SmeltStageRewardRequirement requirement)
+    {
+        if (ctasPrefab == null || ctasParent == null || ssrso == null || ssrso.rewardRandomConfig == null)
+        {
+            return;
+        }
+
+        CloseActiveCtas();
+
+        GameObject instance = Instantiate(ctasPrefab, ctasParent);
+        activeCtasInstance = instance;
+
+        global::ctasPrefab selector = instance.GetComponent<global::ctasPrefab>();
+        if (selector == null)
+        {
+            return;
+        }
+
+        equipmentSO selectionTemplate = ssrso.rewardTemplate != null
+            ? UnityEngine.Object.Instantiate(ssrso.rewardTemplate)
+            : ScriptableObject.CreateInstance<equipmentSO>();
+        selectionTemplate.hideFlags = HideFlags.DontSave;
+        selectionTemplate.sa_skillID = 0;
+        selectionTemplate.ia_skillID = 0;
+        bool requireTypeSelection = RequiresTypeSelection(requirement);
+        bool requireSkillSelection = RequiresSkillSelection(requirement);
+
+        if (requireTypeSelection)
+        {
+            selectionTemplate.skillType = requirement.chosenSkillType;
+        }
+
+        selector.Initialize(
+            selectionTemplate,
+            ssrso.rewardRandomConfig,
+            requireTypeSelection,
+            requireSkillSelection,
+            (selectedType, selectedSkillGroupId) => HandleRewardSelectionConfirmed(requirement, selectedType, selectedSkillGroupId),
+            HandleRewardSelectorClosed);
+    }
+
+    private void HandleRewardSelectionConfirmed(smeltStageRewardSO.SmeltStageRewardRequirement requirement, equipmentSO.EquipmentSkillType selectedType, int selectedSkillGroupId)
+    {
+        activeCtasInstance = null;
+        GrantReward(requirement, selectedType, selectedSkillGroupId);
+    }
+
+    private void GrantReward(smeltStageRewardSO.SmeltStageRewardRequirement requirement, equipmentSO.EquipmentSkillType? selectedTypeOverride, int selectedSkillGroupId)
+    {
+        if (requirement == null)
+        {
+            return;
+        }
+
+        int requiredAmount = Mathf.Max(0, requirement.requiredAmount);
+        if (requiredAmount > storedSmeltEnergyState)
+        {
+            return;
+        }
+
+        equipmentSO generated = equipmentGenerator.GenerateFromSmeltReward(ssrso, requirement, selectedTypeOverride, selectedSkillGroupId);
+        if (generated == null)
+        {
+            return;
+        }
+
+        ReinstateRewardEquipment(generated);
+        storedSmeltEnergyState = Mathf.Max(0, storedSmeltEnergyState - requiredAmount);
+        SavePersistentState();
+        RefreshAllUi();
+        RefreshAllEquipBags();
+    }
+
+    private void HandleRewardSelectorClosed()
+    {
+        activeCtasInstance = null;
+        RefreshButtons();
+    }
+
+    private void CloseActiveCtas()
+    {
+        if (activeCtasInstance != null)
+        {
+            Destroy(activeCtasInstance);
+            activeCtasInstance = null;
+        }
+    }
+
     private void ConsumeCurrentPoolEquipments()
     {
         if (SmeltPoolEquipments.Count == 0)
@@ -385,6 +565,10 @@ public class equipSmelt : MonoBehaviour
             }
 
             ConsumedSmeltEquipments.Add(equipment);
+            if (!string.IsNullOrWhiteSpace(equipment.name))
+            {
+                ConsumedSmeltEquipmentIds.Add(equipment.name);
+            }
 
 #if UNITY_EDITOR
             string assetPath = AssetDatabase.GetAssetPath(equipment);
@@ -402,6 +586,8 @@ public class equipSmelt : MonoBehaviour
         AssetDatabase.SaveAssets();
         AssetDatabase.Refresh();
 #endif
+
+        SavePersistentState();
     }
 
     private void RefreshAllUi()
@@ -520,6 +706,11 @@ public class equipSmelt : MonoBehaviour
 
     private void RefreshProgressDisplay()
     {
+        if (costText != null)
+        {
+            costText.text = GetStartSmeltCost().ToString();
+        }
+
         if (qf_cost_text != null)
         {
             qf_cost_text.text = GetQuickFinishCost().ToString();
@@ -578,6 +769,10 @@ public class equipSmelt : MonoBehaviour
             return;
         }
 
+        int previousValue = selectAReward.options != null && selectAReward.options.Count > 0
+            ? Mathf.Max(0, selectAReward.value)
+            : 0;
+
         selectAReward.ClearOptions();
         if (selectAReward.captionText != null)
         {
@@ -610,7 +805,7 @@ public class equipSmelt : MonoBehaviour
         }
 
         selectAReward.AddOptions(options);
-        selectAReward.value = 0;
+        selectAReward.value = Mathf.Clamp(previousValue, 0, options.Count - 1);
         selectAReward.RefreshShownValue();
     }
 
@@ -618,7 +813,10 @@ public class equipSmelt : MonoBehaviour
     {
         if (startSmeltButton != null)
         {
-            startSmeltButton.interactable = smeltCompletedState || (!isSmeltingState && SmeltPoolEquipments.Count > 0);
+            bool canStart = !isSmeltingState
+                && SmeltPoolEquipments.Count > 0
+                && PlayerEconomyLedger.EnsureInstance().HasEnoughCoins(GetStartSmeltCost());
+            startSmeltButton.interactable = smeltCompletedState || canStart;
             Text startButtonText = startSmeltButton.GetComponentInChildren<Text>(true);
             if (startButtonText != null)
             {
@@ -634,7 +832,7 @@ public class equipSmelt : MonoBehaviour
         if (getReward != null)
         {
             smeltStageRewardSO.SmeltStageRewardRequirement requirement = GetSelectedRewardRequirement();
-            getReward.interactable = requirement != null && Mathf.Max(0, requirement.requiredAmount) <= storedSmeltEnergyState;
+            getReward.interactable = (activeCtasInstance == null) && requirement != null && Mathf.Max(0, requirement.requiredAmount) <= storedSmeltEnergyState;
         }
     }
 
@@ -670,6 +868,12 @@ public class equipSmelt : MonoBehaviour
         }
 
         reasonWhy.text = string.Empty;
+
+        if (!PlayerEconomyLedger.EnsureInstance().HasEnoughCoins(GetStartSmeltCost()))
+        {
+            reasonWhy.text = "硬币不足";
+            return;
+        }
     }
 
     private int CalculateTotalFragmentsForCurrentPool()
@@ -739,11 +943,30 @@ public class equipSmelt : MonoBehaviour
         return Mathf.Clamp(ssrso.smeltStorageCapacity, 0, 5000);
     }
 
+    private static int GetSmeltStorageCapacityStatic()
+    {
+        for (int i = 0; i < Instances.Count; i++)
+        {
+            equipSmelt instance = Instances[i];
+            if (instance != null && instance.ssrso != null)
+            {
+                return Mathf.Clamp(instance.ssrso.smeltStorageCapacity, 0, 5000);
+            }
+        }
+
+        return 5000;
+    }
+
     private int GetQuickFinishCost()
     {
         return ssrso != null ? Mathf.Max(0, ssrso.quickFinishCost) : 0;
     }
 
+    private int GetStartSmeltCost()
+    {
+        return ssrso != null ? Mathf.Max(0, ssrso.startSmeltCost) : 0;
+    }
+
     private smeltStageRewardSO.SmeltStageRewardRequirement GetSelectedRewardRequirement()
     {
         if (ssrso == null || ssrso.rewardRequirements == null || ssrso.rewardRequirements.Length == 0)
@@ -802,6 +1025,122 @@ public class equipSmelt : MonoBehaviour
         }
     }
 
+    private void OnApplicationPause(bool pauseStatus)
+    {
+        if (pauseStatus)
+        {
+            SavePersistentState();
+        }
+    }
+
+    private void OnApplicationQuit()
+    {
+        SavePersistentState();
+    }
+
+    private static void EnsurePersistentStateLoaded()
+    {
+        if (persistenceLoaded)
+        {
+            return;
+        }
+
+        persistenceLoaded = true;
+        ConsumedSmeltEquipmentIds.Clear();
+
+        if (!PlayerPrefs.HasKey(SmeltStatePrefsKey))
+        {
+            return;
+        }
+
+        string json = PlayerPrefs.GetString(SmeltStatePrefsKey, string.Empty);
+        if (string.IsNullOrWhiteSpace(json))
+        {
+            return;
+        }
+
+        SmeltPersistentState state = null;
+        try
+        {
+            state = JsonUtility.FromJson<SmeltPersistentState>(json);
+        }
+        catch (Exception ex)
+        {
+            Debug.LogWarning($"[equipSmelt] Failed to parse persistent state: {ex.Message}");
+        }
+
+        if (state == null)
+        {
+            return;
+        }
+
+        isSmeltingState = state.isSmelting;
+        smeltCompletedState = state.smeltCompleted;
+        gamesRequiredForCurrentBatchState = Mathf.Max(0, state.gamesRequired);
+        gamesCompletedForCurrentBatchState = Mathf.Clamp(state.gamesCompleted, 0, gamesRequiredForCurrentBatchState);
+        pendingDirectFragmentsState = Mathf.Max(0, state.pendingDirectFragments);
+        pendingStoredFragmentsState = Mathf.Max(0, state.pendingStoredFragments);
+        storedSmeltEnergyState = Mathf.Max(0, state.storedSmeltEnergy);
+
+        if (state.consumedEquipmentIds != null)
+        {
+            for (int i = 0; i < state.consumedEquipmentIds.Length; i++)
+            {
+                string id = state.consumedEquipmentIds[i];
+                if (!string.IsNullOrWhiteSpace(id))
+                {
+                    ConsumedSmeltEquipmentIds.Add(id);
+                }
+            }
+        }
+    }
+
+    private static void SavePersistentState()
+    {
+        if (!persistenceLoaded)
+        {
+            return;
+        }
+
+        var state = new SmeltPersistentState
+        {
+            isSmelting = isSmeltingState,
+            smeltCompleted = smeltCompletedState,
+            gamesRequired = gamesRequiredForCurrentBatchState,
+            gamesCompleted = gamesCompletedForCurrentBatchState,
+            pendingDirectFragments = pendingDirectFragmentsState,
+            pendingStoredFragments = pendingStoredFragmentsState,
+            storedSmeltEnergy = storedSmeltEnergyState,
+            consumedEquipmentIds = ConsumedSmeltEquipmentIds.Count > 0 ? ConsumedSmeltEquipmentIds.ToArray() : Array.Empty<string>()
+        };
+
+        PlayerPrefs.SetString(SmeltStatePrefsKey, JsonUtility.ToJson(state));
+        PlayerPrefs.Save();
+    }
+
+    public static void ClearPersistentState()
+    {
+        SmeltPoolEquipments.Clear();
+        SmeltPoolLookup.Clear();
+        ConsumedSmeltEquipments.Clear();
+        ConsumedSmeltEquipmentIds.Clear();
+
+        isSmeltingState = false;
+        smeltCompletedState = false;
+        gamesRequiredForCurrentBatchState = 0;
+        gamesCompletedForCurrentBatchState = 0;
+        pendingDirectFragmentsState = 0;
+        pendingStoredFragmentsState = 0;
+        storedSmeltEnergyState = 0;
+
+        persistenceLoaded = true;
+        PlayerPrefs.DeleteKey(SmeltStatePrefsKey);
+        PlayerPrefs.Save();
+
+        RefreshAllSmeltPools();
+        RefreshAllEquipBags();
+    }
+
     private static void RefreshAllSmeltPools()
     {
         for (int i = 0; i < Instances.Count; i++)
@@ -830,3 +1169,4 @@ public class equipSmelt : MonoBehaviour
         }
     }
 }
+

Assets/_eqpmtSys/equipSystems/eSmelt/smeltStageRewardSO.cs

@@ -26,6 +26,7 @@ public class smeltStageRewardSO : ScriptableObject
     public int simpleRewardAmount = 40;
     public int _1skillRewardAmount = 100;
     public int _2skillRewardAmount = 300;
+    public int startSmeltCost = 200;
     public int quickFinishCost = 200;
 
     [Header("reward generation")]