781 lines
24 KiB
C#
781 lines
24 KiB
C#
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>();
|
|
}
|
|
}
|
|
|
|
|
|
|