TH1/Unity/Assets/Scripts/TH1_Logic/Achievement/AchievementItem.cs

/*
* @Author: 白哉
* @Description: 成就条目
* @Date: 2025年05月13日 星期二 16:05:48
* @Modify: 
*/


using System;
using System.Collections.Generic;
using Logic.Multilingual;
using RuntimeData;
using UnityEngine;


namespace Logic.Achievement
{
    [Serializable]
    public class AchievementItem : ISerializationCallbackReceiver
    {
        // 成就ID
        public uint BigID;
        public uint SmallID;
        public uint InternalID;

        // 核心数据  用来标记当前的地图 ID 防止继续游戏
        public uint MapID;
        public bool IsFinished;
        
        //成就名称
        [MultilingualField]
        public string Name;
        // 成就描述
        [MultilingualField]
        public string Desc;
        
        public List<AchievementConditionBase> Conditions;
        public uint ID => BigID * 10000 + SmallID * 100 + InternalID;

        public AchievementItem()
        {
            BigID = 0;
            SmallID = 0;
            InternalID = 0;

            MapID = 0;
            IsFinished = false;
            
            Conditions = new List<AchievementConditionBase>();
        }

        public void OnTurnStart(MapData map, PlayerData player)
        {
            foreach (var condition in Conditions) condition.OnTurnStart(map, player);
            CheckConditions(map);
        }

        public void OnTrainUnit(MapData map, PlayerData player, CityData city, UnitData newUnit)
        {
            foreach (var condition in Conditions) condition.OnTrainUnit(map, player, city, newUnit);
            CheckConditions(map);
        }

        public void OnBuildWonder(MapData map, PlayerData player, CityData city, GridData grid)
        {
            foreach (var condition in Conditions) condition.OnBuildWonder(map, player, city, grid);
            CheckConditions(map);
        }

        public void OnKillUnit(MapData map, UnitData origin, UnitData target)
        {
            foreach (var condition in Conditions) condition.OnKillUnit(map, origin, target);
            CheckConditions(map);
        }

        public void OnUnitMove(MapData map, UnitData unit, GridData gridData)
        {
            foreach (var condition in Conditions) condition.OnUnitMove(map, unit, gridData);
            CheckConditions(map);
        }

        public void ReCheckConditionsNotComplete()
        {
            foreach (var condition in Conditions)
            {
                if (condition.ReCheckCondition()) continue;
                IsFinished = false;
                return;
            }
        }
        
        public void CheckConditions(MapData mapData)
        {
            if (IsFinished) return;
            CheckMapMatch(mapData);
            foreach (var condition in Conditions)
            {
                if (condition.CheckCondition(this, mapData)) continue;
                IsFinished = false;
                return;
            }

            IsFinished = true;
            AchievementDataManager.Instance.FinishedCache.Add(ID);
        }

        public void BindMapData(MapData mapData)
        {
            if (mapData.MapID != MapID)
            {
                foreach (var condition in Conditions) condition.ClearCache();
            }
            MapID = mapData.MapID;
        }

        private void CheckMapMatch(MapData mapData)
        {
            if (mapData.MapID == MapID) return;
            foreach (var condition in Conditions) condition.ClearCache();
        }
        
        public string GetConditionDescription()
        {
            foreach (var condition in Conditions)
            {
                var str = condition.GetConditionDescription();
                if (string.IsNullOrEmpty(str)) continue;
                return str;
            }

            return "";
        }
        
        public void GetConditionProgress(out int current, out int target)
        {
            current = 0;
            target = 0;
            foreach (var condition in Conditions)
            {
                condition.GetProgress(out int c, out int t);
                current += c;
                target += t;
            }
            current = Mathf.Min(current, target);
            if (IsFinished) current = target;
        }

        public bool CheckChanged(AchievementItem target)
        {
            if (target == null) return true;
            Name = target.Name;
            Desc = target.Desc;
            if (target.Conditions.Count != Conditions.Count) return true;
            for (int i = 0; i < Conditions.Count; i++)
            {
                if (Conditions[i].CheckChanged(target.Conditions[i])) return true;
            }
            return false;
        }

        //--------------        序列化相关       -------------------//
        // 辅助序列化字段
        [SerializeField] 
        private List<string> _typeNames = new List<string>();
        [SerializeField] 
        private List<string> _jsonData = new List<string>();
        
        public void OnBeforeSerialize()
        {
            _typeNames.Clear();
            _jsonData.Clear();
            foreach (var skill in Conditions) 
            {
                _typeNames.Add(skill.GetType().AssemblyQualifiedName);
                _jsonData.Add(JsonUtility.ToJson(skill));
            }
        }

        public void OnAfterDeserialize()
        {
            Conditions ??= new List<AchievementConditionBase>();
            Conditions.Clear();
            for (int i = 0; i < _typeNames.Count; i++) 
            {
                var type = Type.GetType(_typeNames[i]);
                var condition = (AchievementConditionBase) JsonUtility.FromJson(_jsonData[i], type);
                Conditions.Add(condition);
            }
        }
    }
}