备份CatanBuilding瘦身独立工程

Assets/Scripts/DataCenter/BattlePassData.cs

@@ -0,0 +1,780 @@
+using asap.core;
+using cfg;
+using game;
+using GameCore;
+using Newtonsoft.Json;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using tysdk;
+using UniRx;
+using UnityEditor;
+using UnityEngine;
+
+public class GetBattlePassRewardEvent
+{
+    public List<int> NormalLevels = new();
+    public List<int> VipLevels = new();
+}
+
+public struct GetAllBPRewards
+{
+
+}
+
+public struct BpGetExp
+{
+
+}
+
+public struct BpVipUnlock
+{
+
+}
+
+public class BattlePassData
+{
+    public BattlePassRecord BattlePassRecord;
+    public BattleTask BattleTask;
+
+    private Tables _tables;
+
+
+    public BattlePassData(Tables tables)
+    {
+        if (BattlePassRecord == null)
+            BattlePassRecord = new BattlePassRecord();
+        if (BattleTask == null)
+            BattleTask = new BattleTask();
+
+        _tables = tables;
+    }
+
+    #region Load&Save
+    public void LoadBattlePassRecord(string data)
+    {
+        BattlePassRecord = JsonConvert.DeserializeObject<BattlePassRecord>(data);
+    }
+    public void LoadBattleTask(string data)
+    {
+        BattleTask = JsonConvert.DeserializeObject<BattleTask>(data);
+    }
+
+    public void SaveBattlePassRecord()
+    {
+        GContext.container.Resolve<BattlePassDataProvider>().SetRedPoint();
+        PlayFabMgr.Instance.UpdateUserDataValue("BattlePassRecord", JsonConvert.SerializeObject(BattlePassRecord));
+    }
+
+    public void SaveBattleTask()
+    {
+        GContext.container.Resolve<BattlePassDataProvider>().SetRedPoint();
+        PlayFabMgr.Instance.UpdateUserDataValue("BattleTask", JsonConvert.SerializeObject(BattleTask));
+    }
+    #endregion
+
+    #region BattlePass
+
+    public void RefreshBattlePassRecord(FishingEvent t = null)
+    {
+        //没有开启的战令
+        if (t == null)
+        {
+            GContext.container.Resolve<BattlePassDataProvider>().RecordLastBPUnGetDropIDs();
+            BattlePassRecord.ID = 0;
+            SaveBattlePassRecord();
+            return;
+        }
+        if (t.ID != BattlePassRecord.ID)
+        {
+            GContext.container.Resolve<BattlePassDataProvider>().RecordLastBPUnGetDropIDs();
+            BattlePassRecord.Init(t.ID);
+            RefreshDaiyTask();
+            RefreshWeeklyTask();
+            SaveBattlePassRecord();
+        }
+    }
+
+    #endregion
+
+    #region Task
+
+    public void RefreshDaiyTask()
+    {
+        var bpMain = _tables.TbBattlePassMain.GetOrDefault(_tables.TbFishingEvent.GetOrDefault(BattlePassRecord.ID).RedirectID);
+        if (bpMain != null)
+        {
+            BattleTask.DailyTaskEndTime = ConvertTools.GetDateTimeYMD(ZZTimeHelper.UtcNow().UtcNowOffset()).AddDays(1);
+            var dailyTasks = bpMain.DailyTaskList;
+            BattleTask.dic_dailyTasks.Clear();
+            foreach (var task in dailyTasks)
+            {
+                BattleTask.dic_dailyTasks.Add(task, 0);
+            }
+        }
+        else
+        {
+            BattleTask = new BattleTask();
+        }
+        GContext.Publish(new ConditionTypeEvent { type = ConditionType.LoginDays, count = 1 });
+        SaveBattleTask();
+    }
+
+    public void RefreshWeeklyTask()
+    {
+
+        var bpMain = _tables.TbBattlePassMain.GetOrDefault(_tables.TbFishingEvent.GetOrDefault(BattlePassRecord.ID).RedirectID);
+        if (bpMain != null)
+        {
+            var weeklyTasks = bpMain.WeeklyTaskList;
+            BattleTask.dic_weeklyTasks.Clear();
+            foreach (var task in weeklyTasks)
+            {
+                BattleTask.dic_weeklyTasks.Add(task, 0);
+            }
+            BattleTask.WeeklyTaskEndTime = ConvertTools.GetDateTimeSunDay(ZZTimeHelper.UtcNow().UtcNowOffset()).AddDays(1);
+        }
+        //当前没有战令了
+        else
+        {
+            BattleTask = new BattleTask();
+        }
+        GContext.Publish(new ConditionTypeEvent { type = ConditionType.LoginDays, count = 1 });
+        BattleTask.loginDays.Clear();
+        SaveBattleTask();
+    }
+
+    #endregion
+
+}
+
+public class BattlePassDataProvider : IDisposable
+{
+    #region Fields
+
+    public BattlePassData Data;
+    private PlayerItemData _itemData;
+
+    public bool IsUnlock;
+    public int LockTipID;
+
+    public int DefaultBuyLevel
+    {
+        get
+        {
+            return curPassMain.BuyLevel;
+        }
+    }
+
+
+
+    private Tables _tables;
+    private Dictionary<int, BattlePassLevel> dic_BPLevel;
+
+    public bool IsActivating => IsUnlock && Data.BattlePassRecord.ID != 0;
+
+    public bool IsUnlockVip => Data.BattlePassRecord.IsUnlockVip == 1;
+
+    CompositeDisposable disposables = new CompositeDisposable();
+
+    public BattlePassMain curPassMain
+    {
+        get
+        {
+            var fishingEvent = _tables.TbFishingEvent.GetOrDefault(Data.BattlePassRecord.ID);
+            if (fishingEvent == null) { return null; }
+
+            return _tables.TbBattlePassMain.GetOrDefault(fishingEvent.RedirectID);
+        }
+    }
+    public BattlePassLevel curPassLevel
+    {
+        get
+        {
+            if (curPassMain != null)
+                return dic_BPLevel.GetValueOrDefault(curPassMain.LevelList[Data.BattlePassRecord.Level - 1]);
+            return null;
+        }
+    }
+
+
+    public BattlePassDataProvider(Tables tables, BattlePassData data, PlayerItemData itemData)
+    {
+        _tables = tables;
+        Data = data;
+        dic_BPLevel = tables.TbBattlePassLevel.DataMap;
+        _itemData = itemData;
+        GContext.OnEvent<ConditionTypeEvent>().Subscribe(UpdateTaskData).AddTo(disposables);
+    }
+
+    #endregion
+
+    #region Check Func
+
+    public void CheckIfRefreshBattblePass()
+    {
+        DateTime endTime = GContext.container.Resolve<FishingEventData>().GetEventEndTime(Data.BattlePassRecord.ID);
+
+        if (ZZTimeHelper.UtcNow().UtcNowOffset() >= endTime && IsUnlock)
+        {
+            RecordLastBPUnGetDropIDs();
+            Data.RefreshBattlePassRecord();
+            //GContext.container.Resolve<FishingEventData>().GetEventAndInit(3, 7);
+        }
+    }
+
+    public void CheckIfRefreshDailyTask()
+    {
+        if (ZZTimeHelper.UtcNow().UtcNowOffset() >= Data.BattleTask.DailyTaskEndTime && IsUnlock)
+        {
+            Data.RefreshDaiyTask();
+        }
+    }
+
+    public void CheckIfRefreshWeekTask()
+    {
+
+        if (ZZTimeHelper.UtcNow().UtcNowOffset() >= Data.BattleTask.WeeklyTaskEndTime && IsUnlock)
+        {
+            Data.RefreshWeeklyTask();
+        }
+    }
+
+    public bool CheckIfPopBuyVipPanel()
+    {
+        if (Data.BattlePassRecord.BuyVipToastIndex >= curPassMain.RemindLevel.Count)
+        {
+            return false;
+        }
+
+        return Data.BattlePassRecord.Level >= curPassMain.RemindLevel[Data.BattlePassRecord.BuyVipToastIndex] && Data.BattlePassRecord.IsUnlockVip == 0;
+    }
+
+    public bool CheckIfGetLastBpRewards()
+    {
+        if (LastBpDropIds.Count != 0)
+        {
+            var playerData = GContext.container.Resolve<PlayerItemData>();
+            var itemDatas = playerData.AddItemByDropList(LastBpDropIds.GetRange(1, LastBpDropIds.Count - 1));
+#if AGG
+            using (var e = GEvent.GameEvent("bp_level_reward"))
+            {
+                e.AddContent("bp_level", GetBPCurLevel)
+                  .AddContent("drop_id_list", JsonConvert.SerializeObject(LastBpDropIds.GetRange(1, LastBpDropIds.Count - 1)));
+                if (itemDatas != null && itemDatas.Count > 0)
+                {
+                    for (int i = 0; i < itemDatas.Count; i++)
+                    {
+                        if (itemDatas[i].id == 1001)
+                        {
+                            e.AddContent("reward_hook", itemDatas[i].count);
+                        }
+                        else if (itemDatas[i].id == 1002)
+                        {
+                            e.AddContent("reward_cash", itemDatas[i].count);
+                        }
+                    }
+                }
+            }
+#endif
+            if (LastBpDropIds[0] > 0)
+            {
+#if AGG
+                using (var e = GEvent.GameEvent("bp_cash_reward"))
+                {
+                    e.AddContent("bp_level", GetBPCurLevel)
+                      .AddContent("cash_num", LastBpDropIds[0]);
+                }
+#endif
+
+                var cash = new ItemData { id = 1002, count = LastBpDropIds[0] };
+                playerData.AddItem(cash);
+                GContext.Publish(new ShowData(cash));
+            }
+            GContext.Publish(new ShowData(textValue: LocalizationMgr.GetText("UI_BattlePassPanel_25")));
+            LastBpDropIds.Clear();
+            Data.SaveBattlePassRecord();
+            return true;
+        }
+        return false;
+    }
+    #endregion
+
+    #region Get Func
+
+    public TimeSpan GetDailyTaskDuration()
+    {
+        return Data.BattleTask.DailyTaskEndTime - ZZTimeHelper.UtcNow().UtcNowOffset();
+    }
+
+    public TimeSpan GetWeeklyTaskDuration()
+    {
+        return Data.BattleTask.WeeklyTaskEndTime - ZZTimeHelper.UtcNow().UtcNowOffset();
+    }
+
+    public int GetBPCurLevel => Data.BattlePassRecord.Level;
+    public int GetBPNextLevel => Mathf.Clamp(Data.BattlePassRecord.Level + 1, 1, BPMaxLevel);
+
+    public int BPMaxLevel => curPassMain.LevelList.Count;
+    public List<int> LastBpDropIds => Data.BattlePassRecord.LastDropIDs;
+
+    public BattlePassLevel GetBPLevel(int level) => dic_BPLevel[curPassMain.LevelList[level - 1]];
+
+    public int GetBPCurExp() => Data.BattlePassRecord.Exp;
+
+    public int GetNeedExpToLevelUp(int upLevel)
+    {
+        var curLevel = Data.BattlePassRecord.Level;
+        return GetTotalExpFromLevelRange(curLevel, curLevel + upLevel) - Data.BattlePassRecord.Exp;
+    }
+
+    public int GetCashBoxCount()
+    {
+        var count = 0;
+        if (GetBPCurLevel == BPMaxLevel)
+            count = GetBPCurExp() / 100 * curPassMain.ExpToCash;
+        return count;
+    }
+
+    /// <summary>
+    /// Level Up From StartLevel To EndLevel
+    /// </summary>
+    /// <param name="startLevel"></param>
+    /// <param name="endLevel"></param>
+    /// <returns></returns>
+    public int GetTotalExpFromLevelRange(int startLevel, int endLevel)
+    {
+        var expNeed = 0;
+        endLevel = endLevel > BPMaxLevel ? BPMaxLevel : endLevel;
+        for (int i = startLevel; i < endLevel; i++)
+        {
+            expNeed += dic_BPLevel[curPassMain.LevelList[i - 1]].Exp;
+        }
+        return expNeed;
+    }
+
+    public BPRewardSlot.ESlotState GetSlotState(int level, bool isNormalReward)
+    {
+        //        if ( !IsUnlockVip&&!isNormalReward )
+        //            return BPRewardSlot.ESlotState.VipLock;
+        if (Data.BattlePassRecord.Level < level || (!isNormalReward && !IsUnlockVip))
+        {
+            return BPRewardSlot.ESlotState.LevelLock;
+        }
+        if (isNormalReward)
+        {
+            if (Data.BattlePassRecord.NormalRewardGet.Contains(level))
+                return BPRewardSlot.ESlotState.HasGotReward;
+        }
+        else if (Data.BattlePassRecord.VipRewardGet.Contains(level))
+            return BPRewardSlot.ESlotState.HasGotReward;
+        return BPRewardSlot.ESlotState.CanGetReward;
+    }
+
+    public void GetAllBpRewards()
+    {
+        var playItemData = GContext.container.Resolve<PlayerItemData>();
+        var dropIds = new List<int>();
+        for (int i = 1; i <= Data.BattlePassRecord.Level; i++)
+        {
+            if (GetSlotState(i, true) == BPRewardSlot.ESlotState.CanGetReward)
+            {
+                dropIds.Add(GetSlotDropID(i, true));
+                SetLevelRewardGet(i, true);
+            }
+        }
+        if (IsUnlockVip)
+        {
+            for (int i = 1; i <= Data.BattlePassRecord.Level; i++)
+            {
+                if (GetSlotState(i, false) == BPRewardSlot.ESlotState.CanGetReward)
+                {
+                    dropIds.Add(GetSlotDropID(i, false));
+                    SetLevelRewardGet(i, false);
+                }
+            }
+        }
+        Data.SaveBattlePassRecord();
+        var itemDatas = playItemData.AddItemByDropList(dropIds);
+#if AGG
+        using (var e = GEvent.GameEvent("bp_level_reward"))
+        {
+            e.AddContent("bp_level", GContext.container.Resolve<BattlePassDataProvider>().GetBPCurLevel)
+              .AddContent("drop_id_list", JsonConvert.SerializeObject(dropIds));
+            if (itemDatas != null && itemDatas.Count > 0)
+            {
+                for (int i = 0; i < itemDatas.Count; i++)
+                {
+                    if (itemDatas[i].id == 1001)
+                    {
+                        e.AddContent("reward_hook", itemDatas[i].count);
+                    }
+                    else if (itemDatas[i].id == 1002)
+                    {
+                        e.AddContent("reward_cash", itemDatas[i].count);
+                    }
+                }
+            }
+        }
+#endif
+    }
+
+    public int GetAllToGetRewardCount()
+    {
+        var count = 0;
+        for (int i = 1; i <= Data.BattlePassRecord.Level; i++)
+        {
+            if (GetSlotState(i, true) == BPRewardSlot.ESlotState.CanGetReward)
+            {
+                count++;
+            }
+        }
+        if (IsUnlockVip)
+        {
+            for (int i = 1; i <= Data.BattlePassRecord.Level; i++)
+            {
+                if (GetSlotState(i, false) == BPRewardSlot.ESlotState.CanGetReward)
+                {
+                    count++;
+                }
+            }
+        }
+        return count;
+    }
+
+    public int GetSlotDropID(int level, bool isNormalReward)
+    {
+        if (isNormalReward)
+        {
+            return curPassMain.FreeRewardList[level - 1];
+        }
+        return curPassMain.PrimeRewardList[level - 1];
+    }
+    public ItemData GetSlotDropItem(int level, bool isNormalReward)
+    {
+        if (isNormalReward)
+        {
+            return _itemData.GetItemDataOne(curPassMain.FreeRewardList[level - 1]);
+        }
+        return _itemData.GetItemDataOne(curPassMain.PrimeRewardList[level - 1]);
+    }
+
+    public int GetDiamondCostByUpLevel(int upLevel)
+    {
+        var needExp = GetNeedExpToLevelUp(upLevel);
+        if (needExp % 100 > 0)
+        {
+            needExp = (needExp / 100 + 1) * 100;
+        }
+        return needExp / 100 * curPassMain.ExpPrice;
+    }
+
+    public int GetUpLevelByExp(int exp)
+    {
+        exp += Data.BattlePassRecord.Exp;
+        var curLevel = Data.BattlePassRecord.Level;
+        var upLevel = 0;
+        var expNeed = GetNeedExpToLevelUp(upLevel + 1);
+        while (exp >= expNeed && upLevel + curLevel < BPMaxLevel)
+        {
+            expNeed = GetNeedExpToLevelUp(++upLevel + 1);
+        }
+        return upLevel;
+    }
+
+    public List<ItemData> GetRewardsByUpLevel(int upLevel, bool isNormal)
+    {
+        return GetRewardsByLevelRange(GetBPCurLevel + 1, GetBPCurLevel + upLevel, isNormal);
+    }
+
+    public List<ItemData> GetRewardsByLevelRange(int startLevel, int endLevel, bool isNormal)
+    {
+
+        var curLevel = startLevel;
+        var maxLevel = BPMaxLevel;
+        var curPass = curPassMain;
+
+        Dictionary<int, int> dic_allRewards = new();
+
+        var dic_items = GContext.container.Resolve<Tables>().TbItem.DataMap;
+        var playerItemData = GContext.container.Resolve<PlayerItemData>();
+        var rewardList = isNormal ? curPass.FreeRewardList : curPass.PrimeRewardList;
+
+        for (int i = curLevel - 1; i < endLevel && i < maxLevel; i++)
+        {
+            var curItemData = playerItemData.GetItemDataByDropId(rewardList[i])[0];
+            if (dic_allRewards.ContainsKey(curItemData.id))
+            {
+                dic_allRewards[curItemData.id] += curItemData.count;
+            }
+            else
+                dic_allRewards.Add(curItemData.id, curItemData.count);
+        }
+
+        var rewards = dic_allRewards.OrderByDescending(x => dic_items[x.Key].Quality).Select(x => new ItemData { id = x.Key, count = x.Value }).ToList();
+        return rewards;
+    }
+
+    public int GetBarsDefaultPos()
+    {
+        for (int i = 1; i <= GetBPCurLevel; i++)
+        {
+            if (GetSlotState(i, true) == BPRewardSlot.ESlotState.CanGetReward)
+                return Mathf.Clamp(i - 1, 1, BPMaxLevel - 3);
+
+            if (GetSlotState(i, false) == BPRewardSlot.ESlotState.CanGetReward)
+                return Mathf.Clamp(i - 1, 1, BPMaxLevel - 3);
+        }
+        return Mathf.Clamp(GetBPCurLevel - 1, 1, BPMaxLevel - 3);
+    }
+
+
+    #endregion
+
+    #region Set Func
+    public void RecordLastBPUnGetDropIDs()
+    {
+        if (curPassMain == null)
+            return;
+        var drops = Data.BattlePassRecord.LastDropIDs;
+        if (Data.BattlePassRecord.ID == 0 || drops.Count > 0)
+            return;
+        drops.Add(GContext.container.Resolve<PlayerItemData>().GetExtraCoinMag(GetCashBoxCount()));
+        for (int i = 1; i <= GetBPCurLevel; i++)
+        {
+            if (GetSlotState(i, true) == BPRewardSlot.ESlotState.CanGetReward)
+                drops.Add(curPassMain.FreeRewardList[i - 1]);
+
+            if (GetSlotState(i, false) == BPRewardSlot.ESlotState.CanGetReward)
+                drops.Add(curPassMain.PrimeRewardList[i - 1]);
+        }
+
+    }
+    public void SetRedPoint()
+    {
+        var flag = 0;
+        for (int i = 1; i <= GetBPCurLevel; i++)
+        {
+            if (GetSlotState(i, false) == BPRewardSlot.ESlotState.CanGetReward || GetSlotState(i, true) == BPRewardSlot.ESlotState.CanGetReward)
+            {
+                RedPointManager.Instance.SetRedPointState(RedPointName.Home_BattlePass_Reward, true);
+                flag = 1;
+                break;
+            }
+        }
+        if (flag == 0)
+            RedPointManager.Instance.SetRedPointState(RedPointName.Home_BattlePass_Reward, false);
+
+        foreach (var taskInfo in Data.BattleTask.dic_dailyTasks)
+        {
+            var task = _tables.TbBattlePassTask.Get(taskInfo.Key);
+            if (taskInfo.Value >= int.Parse(task.Param[0]))
+            {
+                RedPointManager.Instance.SetRedPointState(RedPointName.Home_BattlePass_Task, true);
+                return;
+            }
+        }
+        foreach (var taskInfo in Data.BattleTask.dic_weeklyTasks)
+        {
+            var task = _tables.TbBattlePassTask.Get(taskInfo.Key);
+            if (taskInfo.Value >= int.Parse(task.Param[0]))
+            {
+                RedPointManager.Instance.SetRedPointState(RedPointName.Home_BattlePass_Task, true);
+                return;
+            }
+        }
+        RedPointManager.Instance.SetRedPointState(RedPointName.Home_BattlePass_Task, false);
+    }
+
+    public void SetVipUnlock()
+    {
+        Data.BattlePassRecord.IsUnlockVip = 1;
+        Data.SaveBattlePassRecord();
+    }
+
+    public void SetLevelRewardGet(int level, bool isNormal)
+    {
+        if (isNormal)
+        {
+            if (Data.BattlePassRecord.NormalRewardGet.Contains(level))
+            {
+                Debug.LogError("Has Get Reward" + level);
+                return;
+            }
+            Data.BattlePassRecord.NormalRewardGet.Add(level);
+        }
+        else
+        {
+            if (Data.BattlePassRecord.VipRewardGet.Contains(level))
+            {
+                Debug.LogError("Has Get Reward" + level);
+                return;
+            }
+            Data.BattlePassRecord.VipRewardGet.Add(level);
+        }
+    }
+
+    public void SetBPExp(int exp)
+    {
+        var curExp = Data.BattlePassRecord.Exp + exp;
+        //Debug.Log("StartExp:" + Data.BattlePassRecord.Exp);
+        var upLevel = 0;
+        var curLevel = GetBPCurLevel;
+        while (curExp - GetTotalExpFromLevelRange(curLevel, curLevel + upLevel + 1) >= 0 && curLevel + upLevel < BPMaxLevel)
+        {
+            upLevel++;
+        }
+
+        Data.BattlePassRecord.Exp = curExp - GetTotalExpFromLevelRange(curLevel, curLevel + upLevel);
+        Data.BattlePassRecord.Level = curLevel + upLevel;
+        //Debug.Log("EndExp:" + Data.BattlePassRecord.Exp + "Get:" + exp + "  Level" + Data.BattlePassRecord.Level);
+        Data.SaveBattlePassRecord();
+        SetRedPoint();
+    }
+
+    public void UpdateVipToastLevel()
+    {
+        Data.BattlePassRecord.BuyVipToastIndex++;
+        Data.SaveBattlePassRecord();
+    }
+
+    void UpdateTaskData(ConditionTypeEvent conditionTypeEvent)
+    {
+        if (!IsActivating)
+            return;
+        bool isUpdata = false;
+        var tasks = _tables.TbBattlePassTask;
+        var curTasks = Data.BattleTask.dic_dailyTasks;
+        var curTasksId = Data.BattleTask.dic_dailyTasks.Keys.ToList();
+        //每日任务
+        foreach (var taskId in curTasksId)
+        {
+            var task = tasks.GetOrDefault(taskId);
+            if (task == null)
+                continue;
+            if (task.Type == conditionTypeEvent.type)
+            {
+                if (curTasks[taskId] == int.Parse(task.Param[0]) || curTasks[taskId] == -1)
+                {
+                    continue;
+                }
+                if (task.Type == ConditionType.LoginDays && Data.BattleTask.loginDays.Contains((int)ZZTimeHelper.UtcNow().UtcNowOffset().DayOfWeek))
+                {
+                    continue;
+                }
+
+                curTasks[taskId] += conditionTypeEvent.count;
+                if (curTasks[taskId] >= int.Parse(task.Param[0]))
+                {
+                    curTasks[taskId] = int.Parse(task.Param[0]);
+                }
+
+                isUpdata = true;
+            }
+        }
+        curTasks = Data.BattleTask.dic_weeklyTasks;
+        curTasksId = Data.BattleTask.dic_weeklyTasks.Keys.ToList();
+        //每周任务
+        foreach (var taskId in curTasksId)
+        {
+            var task = tasks.GetOrDefault(taskId);
+            if (task == null)
+                continue;
+            if (task.Type == conditionTypeEvent.type)
+            {
+                if (curTasks[taskId] == int.Parse(task.Param[0]) || curTasks[taskId] == -1)
+                {
+                    continue;
+                }
+
+                if (task.Type == ConditionType.LoginDays && Data.BattleTask.loginDays.Contains((int)ZZTimeHelper.UtcNow().UtcNowOffset().DayOfWeek))
+                {
+                    continue;
+                }
+
+                curTasks[taskId] += conditionTypeEvent.count;
+                if (curTasks[taskId] >= int.Parse(task.Param[0]))
+                {
+                    curTasks[taskId] = int.Parse(task.Param[0]);
+                }
+
+                isUpdata = true;
+            }
+        }
+        if (isUpdata)
+        {
+            if (conditionTypeEvent.type == ConditionType.LoginDays && Data.BattleTask.loginDays.Contains((int)ZZTimeHelper.UtcNow().UtcNowOffset().DayOfWeek))
+            {
+                Data.BattleTask.loginDays.Add((int)ZZTimeHelper.UtcNow().UtcNowOffset().DayOfWeek);
+            }
+            Data.SaveBattleTask();
+        }
+
+
+    }
+
+    public void SetTaskDone(int taskID, bool isDailyTask)
+    {
+        var tasks = isDailyTask ? Data.BattleTask.dic_dailyTasks : Data.BattleTask.dic_weeklyTasks;
+        tasks[taskID] = -1;
+        Data.SaveBattleTask();
+    }
+    #endregion
+    public void Dispose()
+    {
+        disposables?.Dispose();
+        disposables = null;
+    }
+
+}
+
+public class BattlePassRecord
+{
+    public int ID;
+    public int Level;
+    public int Exp;
+    //0:Lock,1:Unlock
+    public int IsUnlockVip;
+    public int BuyVipToastIndex;
+    public List<int> NormalRewardGet;
+    public List<int> VipRewardGet;
+    public List<int> LastDropIDs;
+
+    public BattlePassRecord()
+    {
+        ID = 0;
+        BuyVipToastIndex = 0;
+        Level = 1;
+        NormalRewardGet = new List<int>();
+        VipRewardGet = new List<int>();
+        LastDropIDs = new();
+    }
+    public void Init(int id)
+    {
+        ID = id;
+        Level = 1;
+        Exp = 0;
+        BuyVipToastIndex = 0;
+        IsUnlockVip = 0;
+        NormalRewardGet.Clear();
+        VipRewardGet.Clear();
+
+    }
+}
+public class BattleTask
+{
+    public Dictionary<int, int> dic_dailyTasks;
+    public Dictionary<int, int> dic_weeklyTasks;
+    public List<int> loginDays;
+    public DateTime DailyTaskEndTime;
+    public DateTime WeeklyTaskEndTime;
+    public BattleTask()
+    {
+        dic_dailyTasks = new Dictionary<int, int>();
+        dic_weeklyTasks = new Dictionary<int, int>();
+        loginDays = new List<int>();
+    }
+}
+
+
+