298 lines
11 KiB
C#
298 lines
11 KiB
C#
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using asap.core;
|
|
using cfg;
|
|
using GameCore;
|
|
using UnityEngine;
|
|
|
|
public class EventCanTableContext
|
|
{
|
|
private Tables _tables;
|
|
private EventCanMain _eventCanMain = null;
|
|
private TbEventCanRange _totalRewardPool = null;
|
|
private FishingEventCycleItem2 _tableCycle = null;
|
|
private FishingEvent _tableEvent = null;
|
|
|
|
private EventCanTableContext(Tables tables, EventCanMain eventCanMain,
|
|
FishingEventCycleItem2 tableCycle, FishingEvent tableEvent)
|
|
{
|
|
_tables = tables;
|
|
_eventCanMain = eventCanMain;
|
|
_totalRewardPool = _tables.TbEventCanRange;
|
|
_tableCycle = tableCycle;
|
|
_tableEvent = tableEvent;
|
|
}
|
|
|
|
public EventCanTableContext() { }
|
|
|
|
public void ReadTables(int eventId)
|
|
{
|
|
int redirectId, cycleId;
|
|
_tables = GContext.container.Resolve<Tables>();
|
|
cycleId = _tables.TbFishingEvent[eventId].RedirectID;
|
|
redirectId = _tables.TbFishingEventCycleItem2[cycleId].RedirectID;
|
|
_tableEvent = _tables.TbFishingEvent[eventId];
|
|
_tableCycle = _tables.TbFishingEventCycleItem2[cycleId];
|
|
_eventCanMain = _tables.TbEventCanMain[redirectId];
|
|
_totalRewardPool = _tables.TbEventCanRange;
|
|
return;
|
|
}
|
|
|
|
public List<EventCanRewardInfo> InitRewardPool()
|
|
{
|
|
var rewardIdList = _eventCanMain.CanRange;
|
|
var rewardPool = new List<EventCanRewardInfo>();
|
|
EEventCanRewardType rewardType;
|
|
int weight;
|
|
foreach (var idx in rewardIdList)
|
|
{
|
|
if (!_totalRewardPool.DataMap.TryGetValue(idx, out var eventCanRange))
|
|
{
|
|
Debug.Log($"[EventCan]No table data found for reward id {idx}");
|
|
continue;
|
|
}
|
|
if (eventCanRange.Weight <= 0)
|
|
continue;
|
|
rewardType = GetRewardType(idx);
|
|
weight = eventCanRange.MinMax.Count == 2 ? 0 : eventCanRange.Weight;
|
|
rewardPool.Add(new EventCanRewardInfo()
|
|
{
|
|
RewardId = eventCanRange.RangeID,
|
|
RewardType = rewardType,
|
|
ItemId = eventCanRange.ItemID,
|
|
ItemCount = eventCanRange.ItemNum,
|
|
BaseWeight = weight
|
|
});
|
|
}
|
|
return rewardPool;
|
|
}
|
|
|
|
public EEventCanRewardType GetRewardType(int rewardId)
|
|
{
|
|
return (EEventCanRewardType)(rewardId % 10000 / 1000);
|
|
}
|
|
|
|
public bool GetWeightChangeThreshold(int rewardId, out (int rewardAppearDraws, int rewardMustDropDraws) res)
|
|
{
|
|
if (!_tables.TbEventCanRange.DataMap.TryGetValue(rewardId, out var eventCanRange) || eventCanRange.MinMax.Count != 2)
|
|
{
|
|
// Debug.Log($"[EventCan]No weigth change data found for reward id {rewardId}");
|
|
res = (0, 0);
|
|
return false;
|
|
}
|
|
res = (eventCanRange.MinMax[0], eventCanRange.MinMax[1]);
|
|
return true;
|
|
}
|
|
|
|
public int GetRewardWeight(int rewardId)
|
|
{
|
|
if (!_tables.TbEventCanRange.DataMap.TryGetValue(rewardId, out var eventCanRange))
|
|
{
|
|
Debug.Log($"[EventCan]No table data found for reward id {rewardId}");
|
|
return 0;
|
|
}
|
|
return eventCanRange.Weight;
|
|
}
|
|
|
|
public Dictionary<EEventCanRewardType, EventCanGemTaskInfo> InitGemTaskInfo()
|
|
{
|
|
var res = new List<EventCanGemTaskInfo>();
|
|
_eventCanMain.GemReward.ForEach(
|
|
x =>
|
|
{
|
|
var gemTask = _tables.TbEventCanGemReward.Get(x);
|
|
var rewardItemData = new ItemData(gemTask.ItemDrop, gemTask.ItemDropNum);
|
|
GContext.container.Resolve<PlayerItemData>().ItemTransition(rewardItemData);
|
|
res.Add(new EventCanGemTaskInfo()
|
|
{
|
|
TaskId = x,
|
|
CurrentGemProgress = 0,
|
|
TotalGemRequired = gemTask.GemRequired,
|
|
Reward = rewardItemData
|
|
});
|
|
}
|
|
);
|
|
return res.ToDictionary(x => (EEventCanRewardType)(x.TaskId % 1000 / 100), x => x);
|
|
}
|
|
|
|
public EventCanGemTaskInfo GetGemTaskInfo(int taskId, int currentGemProgress = 0)
|
|
{
|
|
// var gemTask = _tables.TbEventCanGemReward.Get(TaskId);
|
|
if (!_tables.TbEventCanGemReward.DataMap.TryGetValue(taskId, out var gemTask))
|
|
{
|
|
Debug.Log($"[EventCan]Gem task id {taskId} not found in gem reward table.");
|
|
return null;
|
|
}
|
|
var rewardItemData = new ItemData(gemTask.ItemDrop, gemTask.ItemDropNum);
|
|
GContext.container.Resolve<PlayerItemData>().ItemTransition(rewardItemData);
|
|
return new EventCanGemTaskInfo()
|
|
{
|
|
TaskId = taskId,
|
|
CurrentGemProgress = currentGemProgress,
|
|
TotalGemRequired = gemTask.GemRequired,
|
|
Reward = rewardItemData
|
|
};
|
|
}
|
|
|
|
public bool GetNextProgressTaskInfo(EventCanProgressTaskInfo currentTaskInfo)
|
|
{
|
|
var rewardList = _eventCanMain.CanReward;
|
|
var idx = (currentTaskInfo.TaskIdx + 1) % rewardList.Count;
|
|
var rewardId = rewardList[idx];
|
|
if (!_tables.TbEventCanReward.DataMap.TryGetValue(rewardId, out var eventCanReward))
|
|
{
|
|
Debug.Log($"[EventCan]No table data found for reward id {rewardId}");
|
|
return false;
|
|
}
|
|
var itemData = new ItemData(eventCanReward.ItemID, eventCanReward.Num);
|
|
GContext.container.Resolve<PlayerItemData>().ItemTransition(itemData);
|
|
currentTaskInfo.TaskIdx = idx;
|
|
currentTaskInfo.CurrentProgress -= currentTaskInfo.TotalProgressRequired;
|
|
currentTaskInfo.TotalProgressRequired = eventCanReward.Consume;
|
|
currentTaskInfo.Reward = itemData;
|
|
return true;
|
|
}
|
|
|
|
public EventCanProgressTaskInfo InitProgressTaskInfo()
|
|
{
|
|
var eventCanReward = _tables.TbEventCanReward.DataList[0];
|
|
var itemData = new ItemData(eventCanReward.ItemID, eventCanReward.Num);
|
|
GContext.container.Resolve<PlayerItemData>().ItemTransition(itemData);
|
|
return new EventCanProgressTaskInfo()
|
|
{
|
|
TaskIdx = 0,
|
|
CurrentProgress = 0,
|
|
TotalProgressRequired = eventCanReward.Consume,
|
|
Reward = itemData,
|
|
};
|
|
}
|
|
|
|
public bool GetProgressInfoByIdx(int idx, out int ProgressRequired, out ItemData Reward)
|
|
{
|
|
var taskIdList = _eventCanMain.CanReward;
|
|
ProgressRequired = 0;
|
|
Reward = null;
|
|
if (idx >= taskIdList.Count || idx < 0)
|
|
{
|
|
Debug.Log($"[EventCan]Idx {idx} out of range {taskIdList.Count}.");
|
|
return false;
|
|
}
|
|
var task = _tables.TbEventCanReward[taskIdList[idx]];
|
|
Reward = new ItemData(task.ItemID, task.Num);
|
|
GContext.container.Resolve<PlayerItemData>().ItemTransition(Reward);
|
|
ProgressRequired = task.Consume;
|
|
return true;
|
|
}
|
|
|
|
public bool GetNextGemTaskInfo(EventCanGemTaskInfo currentTaskInfo)
|
|
{
|
|
var id = currentTaskInfo.TaskId;
|
|
if (!_tables.TbEventCanGemReward.DataMap.TryGetValue(id, out var eventCanGemRewardData))
|
|
{
|
|
Debug.Log($"[EventCan]No table data found for gem reward id {id}");
|
|
return false;
|
|
}
|
|
if (!_tables.TbEventCanGemReward.DataMap.TryGetValue(eventCanGemRewardData.NextTarget, out var newGemRewardData))
|
|
{
|
|
Debug.Log($"[EventCan]No table data found for gem reward id {eventCanGemRewardData.NextTarget}");
|
|
return false;
|
|
}
|
|
var itemData = new ItemData(newGemRewardData.ItemDrop, newGemRewardData.ItemDropNum);
|
|
GContext.container.Resolve<PlayerItemData>().ItemTransition(itemData);
|
|
currentTaskInfo.TaskId = newGemRewardData.TaskID;
|
|
currentTaskInfo.CurrentGemProgress -= currentTaskInfo.TotalGemRequired;
|
|
currentTaskInfo.TotalGemRequired = newGemRewardData.GemRequired;
|
|
currentTaskInfo.Reward = itemData;
|
|
return true;
|
|
}
|
|
|
|
public int GetMaxCanCount()
|
|
{
|
|
return _eventCanMain.CanMax;
|
|
}
|
|
|
|
|
|
public int GetWelcomeGift()
|
|
{
|
|
return _tableCycle.WelcomeGift;
|
|
}
|
|
|
|
public Dictionary<int, int> GetInitialDrawsSinceLastRewards()
|
|
{
|
|
return _eventCanMain.CanRange.Select(id => _tables.TbEventCanRange[id])
|
|
.Where(reward => reward.MinMax.Count == 2)
|
|
.ToDictionary(reward => reward.RangeID, _ => 0);
|
|
}
|
|
|
|
public EventCanEntranceBtnData GetEntranceBtnData()
|
|
{
|
|
var res = new EventCanEntranceBtnData();
|
|
res.BtnIconUrl = _eventCanMain.Icon;
|
|
res.RedPointTicketThreshold = _tableCycle.RedDot;
|
|
System.DateTime et = new System.DateTime(), st = new System.DateTime();
|
|
try
|
|
{
|
|
et = System.DateTime.Parse((_tableEvent.TimeDefinition as LimitedTime).EndTime);
|
|
st = System.DateTime.Parse((_tableEvent.TimeDefinition as LimitedTime).StartTime);
|
|
}
|
|
catch (System.Exception e)
|
|
{
|
|
Debug.Log($"[EventCan] {e.Message}\n{e.StackTrace}");
|
|
return null;
|
|
}
|
|
finally
|
|
{
|
|
res.ExpiryTime = et;
|
|
res.StartTime = st;
|
|
}
|
|
return res;
|
|
}
|
|
|
|
public EventChainPackInfo GetPackData()
|
|
{
|
|
var chainList = _tables.TbEventPackManager[_eventCanMain.PackId].VIPPackList[0];
|
|
var expireTime = new System.DateTime();
|
|
try
|
|
{
|
|
expireTime = System.DateTime.Parse((_tableEvent.TimeDefinition as LimitedTime).EndTime);
|
|
}
|
|
catch (System.Exception e)
|
|
{
|
|
Debug.Log($"[EventBreak] {e.Message}\n{e.StackTrace}");
|
|
return null;
|
|
}
|
|
var chainListIdSet = chainList.ToHashSet();
|
|
var packs = _tables.TbPack.DataList.Where(p => chainListIdSet.Contains(p.ID)).ToArray();//?
|
|
return new EventChainPackInfo()
|
|
{
|
|
ChainList = chainList,
|
|
ExpireTime = expireTime,
|
|
Packs = packs,
|
|
RedPointKey = "eventcan.pack"
|
|
};
|
|
}
|
|
|
|
public GeneralEventNormalPackInfo GetNormalPackInfo()
|
|
{
|
|
var expireTime = new System.DateTime();
|
|
try
|
|
{
|
|
expireTime = System.DateTime.Parse((_tableEvent.TimeDefinition as LimitedTime).EndTime);
|
|
}
|
|
catch (System.Exception e)
|
|
{
|
|
Debug.Log($"[EventBreak] {e.Message}\n{e.StackTrace}");
|
|
return null;
|
|
}
|
|
var packList = _tables.TbEventPackManager[_eventCanMain.PackId2].VIPPackList[0];
|
|
return new GeneralEventNormalPackInfo
|
|
{
|
|
EventId = _tableEvent.ID,
|
|
PackLeft = _tables.TbPack[packList[0]],
|
|
PackRight = _tables.TbPack[packList[1]],
|
|
ExpireTime = expireTime,
|
|
};
|
|
}
|
|
}
|
|
|