937 lines
31 KiB
C#
937 lines
31 KiB
C#
using asap.core;
|
|
using cfg;
|
|
using GameCore;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using UniRx;
|
|
using UnityEngine;
|
|
using UnityEngine.AddressableAssets;
|
|
using UnityEngine.U2D;
|
|
using UnityEngine.UI;
|
|
|
|
namespace game
|
|
{
|
|
public class EventScratchTicketDataManager
|
|
{
|
|
#if UNITY_EDITOR
|
|
private bool m_IsCheckCondition = true;
|
|
private bool m_IsSyncData = true;
|
|
private int m_DefaultToken = 100;
|
|
#else
|
|
private bool m_IsCheckCondition = true;
|
|
private bool m_IsSyncData = true;
|
|
private int m_DefaultToken = 0;
|
|
#endif
|
|
|
|
#region 埋点相关
|
|
public int TempRecordRewardTaskID { get; set; } = 0;
|
|
public int TempRecordRewardTaskConsumedToken { get; set; } = 0;
|
|
public void SyncTempRecordData()
|
|
{
|
|
ClearRecordList();
|
|
|
|
TempRecordRewardTaskID = m_ScratchTicketData.EventScratchRewardTaskID;
|
|
TempRecordRewardTaskConsumedToken = m_ScratchTicketData.RewardTaskConsumedToken;
|
|
}
|
|
public void RecordStatisticalData()
|
|
{
|
|
int fromToken = TempRecordRewardTaskConsumedToken;
|
|
|
|
int taskID = TempRecordRewardTaskID;
|
|
EventScratchReward curScratchReward = GetEventScratchReward(taskID);
|
|
|
|
int count = m_RecordList.Count;
|
|
|
|
for (int i = 0; i < count; i++)
|
|
{
|
|
var data = m_RecordList[i];
|
|
fromToken += 1;
|
|
if (fromToken >= curScratchReward.TokenRequired)
|
|
{
|
|
data.MilestoneTask = curScratchReward.TaskID;
|
|
|
|
fromToken = 0;
|
|
|
|
taskID = curScratchReward.NextTask;
|
|
curScratchReward = GetEventScratchReward(taskID);
|
|
}
|
|
|
|
#if AGG
|
|
using (var e = GEvent.GameEvent("event_scratchticket"))
|
|
{
|
|
e.AddContent("ticket_id", data.TicketID)
|
|
.AddContent("ticketfinish_id", data.TicketFinishID)
|
|
.AddContent("scratch_type", data.ScratchType)
|
|
.AddContent("milestone_task", data.MilestoneTask);
|
|
}
|
|
#endif
|
|
}
|
|
|
|
#if UNITY_EDITOR
|
|
Debug.LogError("--- RecordStatisticalData m_RecordList: " + Newtonsoft.Json.JsonConvert.SerializeObject(m_RecordList));
|
|
#endif
|
|
}
|
|
private List<EventScratchTicketRecordData> m_RecordList = new List<EventScratchTicketRecordData>();
|
|
public void InitRecordList()
|
|
{
|
|
ClearRecordList();
|
|
}
|
|
public void ClearRecordList()
|
|
{
|
|
m_RecordList?.Clear();
|
|
TempRecordRewardTaskID = 0;
|
|
TempRecordRewardTaskConsumedToken = 0;
|
|
}
|
|
public EventScratchTicketRecordData AddRecordData()
|
|
{
|
|
EventScratchTicketRecordData data = new EventScratchTicketRecordData();
|
|
m_RecordList.Add(data);
|
|
return data;
|
|
}
|
|
public EventScratchTicketRecordData GetRecordData(int index)
|
|
{
|
|
return m_RecordList[index];
|
|
}
|
|
#endregion
|
|
|
|
#region 数据相关
|
|
private EventScratchTicketData m_ScratchTicketData;
|
|
public EventScratchTicketData ScratchTicketData { get { return m_ScratchTicketData; } }
|
|
public EventScratchMain GetFreshScratchTicketData()
|
|
{
|
|
// 获取当前开放并符合解锁条件的刮刮乐活动ID
|
|
FishingEventData fishingEventData = GContext.container.Resolve<FishingEventData>();
|
|
FishingEvent fishingEvent = fishingEventData.GetEventByTypeAndSubType(7, 3, m_IsCheckCondition);
|
|
if (fishingEvent == null) return null;
|
|
int eventID = fishingEvent.ID;
|
|
int scratchMainID = fishingEvent.RedirectID;
|
|
if (scratchMainID < 0) return null;
|
|
|
|
// 获取当前刮刮乐活动数据
|
|
EventScratchMain scratchMain = m_TbEventScratchMain.GetOrDefault(scratchMainID);
|
|
if (scratchMain == null) return null;
|
|
|
|
int token = m_DefaultToken;
|
|
if (m_ScratchTicketData != null) m_ScratchTicketData.Clear();
|
|
m_ScratchTicketData = null;
|
|
|
|
token = GContext.container.Resolve<FishingEventData>().GetInitWelcomeGift2(eventID);
|
|
|
|
m_ScratchTicketData = new EventScratchTicketData();
|
|
m_ScratchTicketData.EventID = eventID;
|
|
m_ScratchTicketData.ScratchMainID = scratchMainID;
|
|
|
|
m_ScratchTicketData.IsOver = false;
|
|
m_ScratchTicketData.Token = token;
|
|
m_ScratchTicketData.ConsumedToken = 0;
|
|
|
|
m_ScratchTicketData.LuckyValue = 0f;
|
|
m_ScratchTicketData.EventScratchCardID = 0;
|
|
|
|
m_ScratchTicketData.TotalConsumedToken = 0;
|
|
m_ScratchTicketData.ChainPackProgress = 0;
|
|
|
|
m_ScratchTicketData.StampRewardDict = new Dictionary<int, EventScratchTicketOwnedStampRewardData>();
|
|
|
|
EventScratchReward eventScratchReward = m_TbEventScratchReward.DataList[0];
|
|
m_ScratchTicketData.EventScratchRewardTaskID = eventScratchReward.TaskID;
|
|
m_ScratchTicketData.RewardTaskConsumedToken = 0;
|
|
|
|
m_ScratchTicketData.StampRewardList.Clear();
|
|
|
|
ClearSaveData(EventScratchTicketConfig.key_first_in);
|
|
|
|
GContext.container.Resolve<FishingEventData>().SaveTransitionData(m_ScratchTicketData.EventID, m_ScratchTicketData.Token);
|
|
|
|
UpdateLuckyValueAndWeight();
|
|
|
|
foreach (var item in scratchMain.GuidanceGroupList)
|
|
{
|
|
GContext.container.Resolve<GuideDataCenter>().ClearGuide(item);
|
|
}
|
|
|
|
// 同步数据
|
|
SyncData();
|
|
return scratchMain;
|
|
}
|
|
public EventScratchMain GetNextScratchTicketData()
|
|
{
|
|
// 获取当前开放并符合解锁条件的刮刮乐活动ID
|
|
FishingEventData fishingEventData = GContext.container.Resolve<FishingEventData>();
|
|
FishingEvent fishingEvent = fishingEventData.GetEventByTypeAndSubType(7, 3, m_IsCheckCondition);
|
|
if (fishingEvent == null) return null;
|
|
int eventID = fishingEvent.ID;
|
|
int scratchMainID = fishingEvent.RedirectID;
|
|
if (scratchMainID < 0) return null;
|
|
|
|
// 获取当前刮刮乐活动数据
|
|
EventScratchMain scratchMain = m_TbEventScratchMain.GetOrDefault(scratchMainID);
|
|
if (scratchMain == null) return null;
|
|
|
|
m_ScratchTicketData.EventID = eventID;
|
|
m_ScratchTicketData.ScratchMainID = scratchMainID;
|
|
|
|
m_ScratchTicketData.IsOver = false;
|
|
m_ScratchTicketData.ConsumedToken = 0;
|
|
|
|
UpdateLuckyValueAndWeight();
|
|
|
|
// 同步数据
|
|
SyncData();
|
|
return scratchMain;
|
|
}
|
|
public EventScratchMain ContinueGame()
|
|
{
|
|
if (m_ScratchTicketData == null) return GetFreshScratchTicketData();
|
|
|
|
// 获取当前开放并符合解锁条件的刮刮乐活动ID
|
|
FishingEventData fishingEventData = GContext.container.Resolve<FishingEventData>();
|
|
FishingEvent fishingEvent = fishingEventData.GetEventByTypeAndSubType(7, 3, m_IsCheckCondition);
|
|
if (fishingEvent == null) return null;
|
|
int eventID = fishingEvent.ID;
|
|
int scratchMainID = fishingEvent.RedirectID;
|
|
if (scratchMainID < 0) return null;
|
|
|
|
if (eventID != m_ScratchTicketData.EventID || scratchMainID != m_ScratchTicketData.ScratchMainID) return GetFreshScratchTicketData();
|
|
|
|
// 获取当前刮刮乐活动数据
|
|
EventScratchMain scratchMain = m_TbEventScratchMain.GetOrDefault(scratchMainID);
|
|
if (scratchMain == null) return null;
|
|
|
|
return scratchMain;
|
|
}
|
|
public List<float> m_PointWeightList = new List<float>();
|
|
public EventScratchCard UpdateLuckyValueAndWeight()
|
|
{
|
|
if (m_TbEventScratchCard == null) return null;
|
|
|
|
m_PointWeightList.Clear();
|
|
|
|
float luckyValue = m_ScratchTicketData.LuckyValue;
|
|
int count = m_TbEventScratchCard.DataList.Count;
|
|
|
|
float total = 0;
|
|
for (int i = 0; i < count; ++i)
|
|
{
|
|
EventScratchCard item = m_TbEventScratchCard.DataList[i];
|
|
|
|
float weight = item.Weight + luckyValue * item.LuckParameter;
|
|
total += weight;
|
|
float tmp = total;
|
|
m_PointWeightList.Add(tmp);
|
|
}
|
|
|
|
float randomValue = UnityEngine.Random.Range(0f, total);
|
|
int index = FindInsertionIndex(m_PointWeightList, randomValue);
|
|
|
|
EventScratchCard target = m_TbEventScratchCard.DataList[index];
|
|
if (float.MaxValue - target.DeltaLuck <= m_ScratchTicketData.LuckyValue)
|
|
{
|
|
m_ScratchTicketData.LuckyValue = 0;
|
|
}
|
|
else
|
|
{
|
|
m_ScratchTicketData.LuckyValue += target.DeltaLuck;
|
|
if (m_ScratchTicketData.LuckyValue < 0f)
|
|
{
|
|
m_ScratchTicketData.LuckyValue = 0f;
|
|
}
|
|
}
|
|
|
|
m_ScratchTicketData.EventScratchCardID = target.ID;
|
|
|
|
return target;
|
|
}
|
|
public EventScratchCard GetCurrentEventScratchCard()
|
|
{
|
|
if (m_ScratchTicketData == null) return null;
|
|
return GetEventScratchCard(m_ScratchTicketData.EventScratchCardID);
|
|
}
|
|
public int FindInsertionIndex(List<float> sortedList, float target)
|
|
{
|
|
if (sortedList == null || sortedList.Count == 0)
|
|
{
|
|
Debug.LogError("---- EventScratchTicketDataManager->FindInsertionIndex 数组为空");
|
|
return -1;
|
|
}
|
|
|
|
if (target < sortedList[0])
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
if (target >= sortedList[sortedList.Count - 1])
|
|
{
|
|
return -1;
|
|
}
|
|
|
|
// 使用二分查找算法
|
|
int left = 0;
|
|
int right = sortedList.Count - 1;
|
|
int result = -1;
|
|
|
|
while (left <= right)
|
|
{
|
|
int mid = left + (right - left) / 2;
|
|
|
|
if (sortedList[mid] > target)
|
|
{
|
|
if (mid > 0 && target > sortedList[mid - 1] && target < sortedList[mid])
|
|
{
|
|
result = mid;
|
|
break;
|
|
}
|
|
right = mid - 1;
|
|
}
|
|
else
|
|
{
|
|
if (mid < sortedList.Count - 1 && target >= sortedList[mid] && target < sortedList[mid + 1])
|
|
{
|
|
result = mid + 1;
|
|
break;
|
|
}
|
|
left = mid + 1;
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
public EventScratchMain GetCurrentEventScratchMain()
|
|
{
|
|
if (m_ScratchTicketData == null) return GetFreshScratchTicketData();
|
|
|
|
return m_TbEventScratchMain.GetOrDefault(m_ScratchTicketData.ScratchMainID);
|
|
}
|
|
private EventScratchTicketChainPackData m_ChainPackData;
|
|
public EventScratchTicketChainPackData GetChainPackData()
|
|
{
|
|
if (m_ChainPackData == null)
|
|
{
|
|
EventScratchMain scratchMain = GetCurrentEventScratchMain();
|
|
if (scratchMain == null) return null;
|
|
|
|
var chainList = m_Tables.TbEventPackManager[scratchMain.PackId].VIPPackList[0];
|
|
|
|
var expireTime = GetExpireTime;
|
|
|
|
var chainListIdSet = chainList.ToHashSet();
|
|
var packs = m_Tables.TbPack.DataList.Where(p => chainListIdSet.Contains(p.ID)).ToArray();
|
|
|
|
m_ChainPackData = new EventScratchTicketChainPackData(chainList, expireTime, packs, m_ScratchTicketData.EventID, m_ScratchTicketData.ChainPackProgress);
|
|
RedPointManager.Instance.SetRedPointState(m_ChainPackData.RedPointKey, m_ChainPackData.DoNeedPackRedPoint);
|
|
}
|
|
return m_ChainPackData;
|
|
}
|
|
public void InitChainPackData()
|
|
{
|
|
ClearChainPackData();
|
|
}
|
|
public void ClearChainPackData()
|
|
{
|
|
if (m_ChainPackData != null)
|
|
{
|
|
m_ChainPackData = null;
|
|
}
|
|
}
|
|
private EventBreakNormalPackInfo m_NormalPackData;
|
|
public EventBreakNormalPackInfo GetNormalPackData()
|
|
{
|
|
if (m_NormalPackData == null)
|
|
{
|
|
EventScratchMain scratchMain = GetCurrentEventScratchMain();
|
|
if (scratchMain == null) return null;
|
|
|
|
var expireTime = GetExpireTime;
|
|
|
|
var packList = m_Tables.TbEventPackManager[scratchMain.PackId2].VIPPackList[0];
|
|
|
|
m_NormalPackData = new EventBreakNormalPackInfo
|
|
{
|
|
EventId = m_ScratchTicketData.EventID,
|
|
PackLeft = m_Tables.TbPack[packList[0]],
|
|
PackRight = m_Tables.TbPack[packList[1]],
|
|
ExpireTime = expireTime,
|
|
};
|
|
}
|
|
|
|
return m_NormalPackData;
|
|
}
|
|
private void InitNormalPackData()
|
|
{
|
|
ClearNormalPackDatas();
|
|
}
|
|
private void ClearNormalPackDatas()
|
|
{
|
|
m_NormalPackData = null;
|
|
}
|
|
public void InitRewardBagData()
|
|
{
|
|
GContext.container.Resolve<IDeferredRewardStashService>().Reset();
|
|
|
|
//List<int> rewardList = new List<int>();
|
|
|
|
//EventScratchMain curScratchMain = GetCurrentEventScratchMain();
|
|
|
|
//foreach (var item in curScratchMain.CardList)
|
|
//{
|
|
// var card = GetEventScratchCard(item);
|
|
// if (card.DropReward > 0)
|
|
// {
|
|
// rewardList.Add(card.DropReward);
|
|
// }
|
|
//}
|
|
|
|
//EventScratchReward curReward = GetEventScratchReward(m_ScratchTicketData.EventScratchRewardTaskID);
|
|
//if (curReward.DropReward > 0)
|
|
//{
|
|
// rewardList.Add(curReward.DropReward);
|
|
//}
|
|
|
|
//GContext.Publish(new RewardStashService.EventStashDropList { DropList = rewardList });
|
|
}
|
|
public void ClearRewardBagData()
|
|
{
|
|
|
|
}
|
|
public void SetChainProgress(int progress)
|
|
{
|
|
m_ScratchTicketData.ChainPackProgress = progress;
|
|
SyncData();
|
|
}
|
|
public int GetChainProgress()
|
|
{
|
|
return m_ScratchTicketData.ChainPackProgress;
|
|
}
|
|
public void AddStampReward(int cardID)
|
|
{
|
|
m_ScratchTicketData.StampRewardList.Add(cardID);
|
|
SyncData();
|
|
}
|
|
public int GetStampRewardNum()
|
|
{
|
|
return m_ScratchTicketData.StampRewardList.Count;
|
|
}
|
|
public EventScratchCard GetFirstStampReward()
|
|
{
|
|
return GetEventScratchCard(m_ScratchTicketData.StampRewardList[0]);
|
|
}
|
|
public void RemoveFirstStampReward()
|
|
{
|
|
m_ScratchTicketData.StampRewardList.RemoveAt(0);
|
|
SyncData();
|
|
}
|
|
public void ClearStampReward()
|
|
{
|
|
m_ScratchTicketData.StampRewardList.Clear();
|
|
SyncData();
|
|
}
|
|
private List<int> m_ScratchStampList = new List<int>();
|
|
public List<int> ScratchStampList { get { return m_ScratchStampList; } }
|
|
private void InitScratchStampList()
|
|
{
|
|
m_ScratchStampList.Clear();
|
|
}
|
|
public void ClearScratchStampList()
|
|
{
|
|
m_ScratchStampList.Clear();
|
|
}
|
|
public void AddScratchStamp(int cardID)
|
|
{
|
|
m_ScratchStampList.Add(cardID);
|
|
}
|
|
public EventScratchCard GetFirstScratchStamp()
|
|
{
|
|
return GetEventScratchCard(m_ScratchStampList[0]);
|
|
}
|
|
#endregion
|
|
|
|
#region 代币相关
|
|
public int GetToken()
|
|
{
|
|
if (m_ScratchTicketData != null)
|
|
return m_ScratchTicketData.Token;
|
|
return 0;
|
|
}
|
|
public void AddToken(int count)
|
|
{
|
|
if (m_ScratchTicketData != null)
|
|
{
|
|
m_ScratchTicketData.Token += count;
|
|
}
|
|
else
|
|
{
|
|
if (m_ScratchTicketData == null) return;
|
|
m_ScratchTicketData.Token += count;
|
|
}
|
|
|
|
if (m_ScratchTicketData.Token > 0) RedPointManager.Instance.SetRedPointState(RedPointName.Home_ScratchTicket, true);
|
|
else RedPointManager.Instance.SetRedPointState(RedPointName.Home_ScratchTicket, false);
|
|
|
|
FishingScratchTicketAct.Publish<EventScratchTicketTokenUpdateData>(new EventScratchTicketTokenUpdateData());
|
|
|
|
GContext.container.Resolve<FishingEventData>().SaveTransitionData(m_ScratchTicketData.EventID, m_ScratchTicketData.Token);
|
|
|
|
SyncData();
|
|
}
|
|
public bool ConsumeTokens(int count)
|
|
{
|
|
bool isEnough = IsEnough(count);
|
|
if (isEnough == false) return false;
|
|
|
|
m_ScratchTicketData.ConsumedToken += count;
|
|
m_ScratchTicketData.TotalConsumedToken += count;
|
|
AddToken(-count);
|
|
return isEnough;
|
|
}
|
|
|
|
public bool IsEnough(int spend)
|
|
{
|
|
if (m_ScratchTicketData == null) return false;
|
|
return (m_ScratchTicketData.Token - spend) >= 0;
|
|
}
|
|
#endregion
|
|
|
|
#region 活动相关
|
|
public void ActivateEvent(FishingEvent fishingEvent)
|
|
{
|
|
if (fishingEvent == null) return;
|
|
|
|
if (!Init()) return;
|
|
|
|
if (m_ScratchTicketData == null) GetFreshScratchTicketData();
|
|
else FixScratchTicketData();
|
|
}
|
|
|
|
public void GetDataFromServer(string json)
|
|
{
|
|
if (string.IsNullOrEmpty(json))
|
|
{
|
|
GameDebug.LogWarning("EventScratchTicket get data from server has encountered empty data.");
|
|
return;
|
|
}
|
|
|
|
try
|
|
{
|
|
m_ScratchTicketData = Newtonsoft.Json.JsonConvert.DeserializeObject<EventScratchTicketData>(json);
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
GameDebug.LogWarning("EventScratchTicket deserialize data has failed. Exception: " + e.ToString());
|
|
return;
|
|
}
|
|
|
|
if (!Init()) return;
|
|
}
|
|
public int FixScratchTicketData()
|
|
{
|
|
if (m_ScratchTicketData == null) return 0;
|
|
|
|
// 获取当前开放并符合解锁条件的刮刮乐活动ID
|
|
FishingEventData fishingEventData = GContext.container.Resolve<FishingEventData>();
|
|
FishingEvent fishingEvent = fishingEventData.GetEventByTypeAndSubType(7, 3, m_IsCheckCondition);
|
|
if (fishingEvent == null) return ClearData();
|
|
int eventID = fishingEvent.ID;
|
|
int scratchMainID = fishingEvent.RedirectID;
|
|
if (scratchMainID < 0) return ClearData();
|
|
|
|
if (eventID != m_ScratchTicketData.EventID || scratchMainID != m_ScratchTicketData.ScratchMainID) return ClearData();
|
|
|
|
return 0;
|
|
}
|
|
public DateTime GetExpireTime
|
|
{
|
|
get => DateTime.Parse((m_Tables.TbFishingEvent[m_ScratchTicketData.EventID].TimeDefinition as LimitedTime).EndTime);
|
|
}
|
|
public TimeSpan RemainingTime
|
|
{
|
|
get => GetExpireTime - ZZTimeHelper.UtcNow();
|
|
}
|
|
public int ClearData()
|
|
{
|
|
if (m_ScratchTicketData == null) return 0;
|
|
|
|
m_ScratchTicketData.Clear();
|
|
m_ScratchTicketData = null;
|
|
return 0;
|
|
}
|
|
public void SyncData()
|
|
{
|
|
if (!m_IsSyncData) return;
|
|
PlayFabMgr.Instance.UpdateUserDataValue(EventScratchTicketConfig.SAVE_DATA_KEY, Newtonsoft.Json.JsonConvert.SerializeObject(m_ScratchTicketData));
|
|
}
|
|
#endregion
|
|
|
|
#region 生命周期
|
|
public bool Init()
|
|
{
|
|
InitTables();
|
|
return true;
|
|
}
|
|
public void StartData()
|
|
{
|
|
ClearUIData();
|
|
InitUIData();
|
|
InitChainPackData();
|
|
InitNormalPackData();
|
|
InitRewardBagData();
|
|
InitSpriteDict();
|
|
InitScratchStampList();
|
|
InitRecordList();
|
|
}
|
|
public void StopData()
|
|
{
|
|
ClearUIData();
|
|
ClearChainPackData();
|
|
ClearNormalPackDatas();
|
|
ClearSpriteAtlas();
|
|
ClearRewardBagData();
|
|
ClearSpriteDict();
|
|
ClearScratchStampList();
|
|
ClearRecordList();
|
|
}
|
|
#endregion
|
|
|
|
#region UI 设置相关
|
|
private UIType m_UIPanel = null, m_InfoPanel = null, m_RewardPanel = null, m_ChainPackPanel = null, m_PackPanel = null;
|
|
public void ClearUIData()
|
|
{
|
|
m_UIPanel = null;
|
|
m_InfoPanel = null;
|
|
m_RewardPanel = null;
|
|
m_ChainPackPanel = null;
|
|
m_PackPanel = null;
|
|
}
|
|
public void InitUIData()
|
|
{
|
|
GetUIPanel();
|
|
GetInfoPanel();
|
|
GetChainPackPanel();
|
|
GetPackPanel();
|
|
}
|
|
public UIType GetUIPanel()
|
|
{
|
|
if (m_UIPanel == null)
|
|
{
|
|
var data = GetCurrentEventScratchMain();
|
|
m_UIPanel = new UIType(data.UIPanel);
|
|
}
|
|
return m_UIPanel;
|
|
}
|
|
public UIType GetRewardPanel()
|
|
{
|
|
if (m_RewardPanel == null)
|
|
{
|
|
var data = GetCurrentEventScratchMain();
|
|
m_RewardPanel = new UIType(data.RewardPanel);
|
|
}
|
|
return m_RewardPanel;
|
|
}
|
|
public UIType GetInfoPanel()
|
|
{
|
|
if (m_InfoPanel == null)
|
|
{
|
|
var data = GetCurrentEventScratchMain();
|
|
m_InfoPanel = new UIType(data.InfoPanel);
|
|
}
|
|
return m_InfoPanel;
|
|
}
|
|
public UIType GetChainPackPanel()
|
|
{
|
|
if (m_ChainPackPanel == null)
|
|
{
|
|
var data = GetCurrentEventScratchMain();
|
|
m_ChainPackPanel = new UIType(data.ChainPackPanel);
|
|
}
|
|
return m_ChainPackPanel;
|
|
}
|
|
public UIType GetPackPanel()
|
|
{
|
|
if (m_PackPanel == null)
|
|
{
|
|
var data = GetCurrentEventScratchMain();
|
|
m_PackPanel = new UIType(data.PackPanel);
|
|
}
|
|
return m_PackPanel;
|
|
}
|
|
#endregion
|
|
|
|
#region 图集等
|
|
private SpriteAtlas m_SpriteAtlas;
|
|
public SpriteAtlas SpriteAtlas
|
|
{
|
|
get { return m_SpriteAtlas; }
|
|
set { m_SpriteAtlas = value; }
|
|
}
|
|
public void ClearSpriteAtlas()
|
|
{
|
|
m_SpriteAtlas = null;
|
|
}
|
|
private Dictionary<string, Sprite> m_SpriteDict;
|
|
private void InitSpriteDict()
|
|
{
|
|
if (m_SpriteDict != null)
|
|
{
|
|
m_SpriteDict.Clear();
|
|
m_SpriteDict = null;
|
|
}
|
|
m_SpriteDict = new Dictionary<string, Sprite>();
|
|
}
|
|
public void AddSprite(string name, Sprite sprite)
|
|
{
|
|
m_SpriteDict.Add(name, sprite);
|
|
}
|
|
public Sprite GetSprite(string name)
|
|
{
|
|
return m_SpriteDict[name];
|
|
}
|
|
private void ClearSpriteDict()
|
|
{
|
|
if (m_SpriteDict == null) return;
|
|
|
|
foreach (var pair in m_SpriteDict)
|
|
{
|
|
Addressables.Release(pair.Value);
|
|
}
|
|
|
|
m_SpriteDict.Clear();
|
|
m_SpriteDict = null;
|
|
}
|
|
#endregion
|
|
|
|
#region Table Data
|
|
private Tables m_Tables;
|
|
private TbEventScratchMain m_TbEventScratchMain;
|
|
private TbEventScratchCard m_TbEventScratchCard;
|
|
private TbEventScratchReward m_TbEventScratchReward;
|
|
private TbEventScratchConfig m_TbEventScratchConfig;
|
|
private TbItem m_TbItem;
|
|
|
|
private void InitTables()
|
|
{
|
|
m_Tables = GContext.container.Resolve<Tables>();
|
|
if (m_Tables == null) return;
|
|
|
|
m_TbEventScratchMain = m_Tables.TbEventScratchMain;
|
|
m_TbEventScratchCard = m_Tables.TbEventScratchCard;
|
|
m_TbEventScratchReward = m_Tables.TbEventScratchReward;
|
|
m_TbEventScratchConfig = m_Tables.TbEventScratchConfig;
|
|
m_TbItem = m_Tables.TbItem;
|
|
}
|
|
public Item GetItem(int itemID)
|
|
{
|
|
return m_TbItem.GetOrDefault(itemID);
|
|
}
|
|
public EventScratchReward GetEventScratchReward(int taskID)
|
|
{
|
|
return m_TbEventScratchReward.GetOrDefault(taskID);
|
|
}
|
|
public EventScratchReward GetEventScratchFinalReward()
|
|
{
|
|
int count = m_TbEventScratchReward.DataList.Count;
|
|
return m_TbEventScratchReward.DataList[count - 1];
|
|
}
|
|
public EventScratchCard GetEventScratchCard(int cardID)
|
|
{
|
|
return m_TbEventScratchCard.GetOrDefault(cardID);
|
|
}
|
|
#endregion
|
|
|
|
#region 本地存储数据相关
|
|
public string GetSaveKey(string key)
|
|
{
|
|
if (m_ScratchTicketData == null) return key;
|
|
return m_ScratchTicketData.EventID + "-" + m_ScratchTicketData.ScratchMainID + "-" + key;
|
|
}
|
|
public bool HasSaveKey(string key)
|
|
{
|
|
return PlayerPrefs.HasKey(GetSaveKey(key));
|
|
}
|
|
public void SaveData(string key, string value)
|
|
{
|
|
PlayerPrefs.SetString(GetSaveKey(key), value);
|
|
PlayerPrefs.Save();
|
|
}
|
|
public void ClearSaveData(string key)
|
|
{
|
|
PlayerPrefs.DeleteKey(GetSaveKey(key));
|
|
}
|
|
public string GetSaveData(string key)
|
|
{
|
|
return PlayerPrefs.GetString(GetSaveKey(key));
|
|
}
|
|
#endregion
|
|
|
|
#region 红点相关
|
|
public bool IsRedDotDisplayed()
|
|
{
|
|
if (m_ScratchTicketData == null) return false;
|
|
return m_ScratchTicketData.Token > 0;
|
|
}
|
|
#endregion
|
|
}
|
|
public enum EventScratchTicketScratchType
|
|
{
|
|
TypeInvalid,
|
|
TypeScratch1,
|
|
TypeScratch5,
|
|
TypeTemporary
|
|
}
|
|
public class EventScratchTicketData
|
|
{
|
|
public int EventID { get; set; }
|
|
public int ScratchMainID { get; set; }
|
|
|
|
public bool IsOver { get; set; }
|
|
public int Token { get; set; }
|
|
public int ConsumedToken { get; set; }
|
|
|
|
public int RewardTaskConsumedToken { get; set; }
|
|
public int EventScratchRewardTaskID { get; set; }
|
|
|
|
public int EventScratchCardID { get; set; }
|
|
public float LuckyValue { get; set; }
|
|
|
|
public int TotalConsumedToken { get; set; }
|
|
public int ChainPackProgress { get; set; }
|
|
|
|
public List<int> StampRewardList = new List<int>();
|
|
|
|
public Dictionary<int, EventScratchTicketOwnedStampRewardData> StampRewardDict { get; set; }
|
|
|
|
public void Clear()
|
|
{
|
|
if (StampRewardDict != null)
|
|
{
|
|
StampRewardDict.Clear();
|
|
}
|
|
StampRewardList.Clear();
|
|
}
|
|
public void ClearAllLocalData()
|
|
{
|
|
Clear();
|
|
}
|
|
}
|
|
public class EventScratchTicketConfig
|
|
{
|
|
public const string SAVE_DATA_KEY = "estdk"; // event scratch ticket data key
|
|
public const string key_first_in = "scratch_kfcw"; // 本地存储数据key
|
|
|
|
public static Vector2 ConvertUiPosition(RectTransform from, RectTransform to, Camera camera)
|
|
{
|
|
Vector2 screenPoint = RectTransformUtility.WorldToScreenPoint(camera, from.position);
|
|
RectTransformUtility.ScreenPointToLocalPointInRectangle(
|
|
to,
|
|
screenPoint,
|
|
camera,
|
|
out Vector2 localPoint);
|
|
return localPoint;
|
|
}
|
|
|
|
public static Vector2 ScreenToGraphicLocalPoint(Graphic graphic, Vector2 screenPoint)
|
|
{
|
|
var canvas = graphic.canvas.rootCanvas;
|
|
var camera = canvas.renderMode == RenderMode.ScreenSpaceOverlay ? null : canvas.worldCamera;
|
|
var rt = graphic.rectTransform;
|
|
|
|
return RectTransformUtility.ScreenPointToLocalPointInRectangle(rt, screenPoint, camera, out var result) ? result : default;
|
|
}
|
|
}
|
|
|
|
public class EventScratchTicketTokenUpdateData
|
|
{
|
|
|
|
}
|
|
public class EventScratchTicketRewardTaskUpdateData
|
|
{
|
|
public EventScratchTicketScratchType ScratchType;
|
|
public int Token;
|
|
}
|
|
public class EventScratchTicketRewardDisplayUpdateData
|
|
{
|
|
public int TaskID;
|
|
public int FromToken;
|
|
public int TargetToken;
|
|
public int LevelToken;
|
|
public float FromRatio;
|
|
public float TargetRatio;
|
|
public EventScratchReward Reward;
|
|
}
|
|
public class EventScratchTicketChangeScratchTypeData
|
|
{
|
|
public EventScratchTicketScratchType ScratchType;
|
|
}
|
|
public class EventScratchTicketRevealedAllData
|
|
{
|
|
public EventScratchTicketScratchType ScratchType;
|
|
}
|
|
public class EventScratchTicketStampRewardUpdateData
|
|
{
|
|
|
|
}
|
|
public class EventScratchTicketStartStampRewardCountUpdateData
|
|
{
|
|
|
|
}
|
|
public class EventScratchTicketStopStampRewardCountUpdateData
|
|
{
|
|
|
|
}
|
|
public class EventScratchTicketOwnedStampRewardData
|
|
{
|
|
public int EventScratchCardID;
|
|
public int Count;
|
|
}
|
|
public class EventScratchTicketStampRewardFlyData
|
|
{
|
|
public EventScratchTicketScratchType ScratchType;
|
|
public Vector3 SrcPosition;
|
|
//public Vector3 DestPosition;
|
|
public Vector3 LocalScale;
|
|
public float IconSize;
|
|
}
|
|
public class EventScratchTicketRewardEmptyData
|
|
{
|
|
public EventScratchTicketScratchType ScratchType;
|
|
}
|
|
public class EventScratchTicketUpdateEventScratchCardData
|
|
{
|
|
|
|
}
|
|
public class EventScratchTicketPanelPlayEndAnimData
|
|
{
|
|
public EventScratchTicketScratchType ScratchType;
|
|
}
|
|
public class EventScratchTicketPlayScratchType5
|
|
{
|
|
|
|
}
|
|
public class EventScratchTicketStartMaskData
|
|
{
|
|
|
|
}
|
|
public class EventScratchTicketOutData
|
|
{
|
|
public EventScratchTicketScratchType ScratchType;
|
|
}
|
|
public class EventScratchTicketRecordData
|
|
{
|
|
public int TicketID;
|
|
public int TicketFinishID;
|
|
public int ScratchType;
|
|
public int MilestoneTask;
|
|
|
|
public void SetScratchType(EventScratchTicketScratchType type)
|
|
{
|
|
if (type == EventScratchTicketScratchType.TypeScratch1)
|
|
{
|
|
ScratchType = 1;
|
|
}
|
|
else if (type == EventScratchTicketScratchType.TypeScratch5)
|
|
{
|
|
ScratchType = 2;
|
|
}
|
|
}
|
|
}
|
|
}
|