using System;
|
using System.Collections.Generic;
|
using UnityEngine;
|
using UnityEngine.UI;
|
|
|
namespace vnxbqy.UI
|
{
|
|
public class WishingPoolModel : Model, IBeforePlayerDataInitialize, IPlayerLoginOk, IOpenServerActivity
|
{
|
public event Action<int> UpdateWishingDataEvent;
|
public event Action<int> UpdatePoolDataEvent;
|
public event Action UpdateWishAwardEvent;
|
public event Action<int> onStateUpdate;
|
public const int WishRedKey = 20915;
|
public bool isOpenPrompting { get; set; }
|
public override void Init()
|
{
|
ParseConfig();
|
OperationTimeHepler.Instance.operationStartEvent += OperationStartEvent;
|
OperationTimeHepler.Instance.operationEndEvent += OperationEndEvent;
|
OperationTimeHepler.Instance.operationAdvanceEvent += OperationAdvanceEvent;
|
OpenServerActivityCenter.Instance.Register(15, this);
|
SetWishRedpoint();
|
}
|
|
public void OnBeforePlayerDataInitialize()
|
{
|
GlobalTimeEvent.Instance.secondEvent -= UpdateSecond;
|
isOpenPrompting = true;
|
ResetDragData();
|
ResetPoolData();
|
}
|
|
public void OnPlayerLoginOk()
|
{
|
GlobalTimeEvent.Instance.secondEvent += UpdateSecond;
|
UpdateRedpoint();
|
UpdateFreeWishRedpoint();
|
}
|
|
public override void UnInit()
|
{
|
|
}
|
|
public bool IsOpen {
|
get {
|
return OperationTimeHepler.Instance.SatisfyOpenCondition(Operation.WishingWellInfo);
|
}
|
}
|
|
public bool priorityOpen {
|
get {
|
return wishPoolRedpoint.state == RedPointState.Simple;
|
}
|
}
|
|
public bool IsAdvance {
|
get {
|
return OperationTimeHepler.Instance.SatisfyAdvanceCondition(Operation.WishingWellInfo);
|
}
|
}
|
|
private void OperationEndEvent(Operation type, int state)
|
{
|
if (type == Operation.WishingWellInfo && state == 0)
|
{
|
UpdateRedpoint();
|
UpdateFreeWishRedpoint();
|
if (onStateUpdate != null)
|
{
|
onStateUpdate(15);
|
}
|
}
|
}
|
|
private void OperationAdvanceEvent(Operation type)
|
{
|
if (type == Operation.WishingWellInfo)
|
{
|
if (onStateUpdate != null)
|
{
|
onStateUpdate(15);
|
}
|
}
|
}
|
|
private void OperationStartEvent(Operation type, int state)
|
{
|
if (type == Operation.WishingWellInfo && state == 0)
|
{
|
|
UpdateRedpoint();
|
UpdateFreeWishRedpoint();
|
if (onStateUpdate != null)
|
{
|
onStateUpdate(15);
|
}
|
}
|
}
|
|
public OperationWishingWellInfo GetOperationWishing()
|
{
|
OperationBase operationBase;
|
if (OperationTimeHepler.Instance.TryGetOperationTime(Operation.WishingWellInfo, out operationBase))
|
{
|
return operationBase as OperationWishingWellInfo;
|
}
|
|
return null;
|
}
|
|
public bool TryGetFreeWishCoolTime(out int second)
|
{
|
second = 0;
|
int endSeconds = freeStartTime + freeRefreshCoolTime;
|
DateTime endTime = TimeUtility.GetTime((uint)endSeconds);
|
second = Mathf.CeilToInt((float)(endTime - TimeUtility.ServerNow).TotalSeconds);
|
if (second > 0)
|
{
|
return true;
|
}
|
return false;
|
}
|
|
public bool IsBestItem()
|
{
|
foreach (var key in poolDataDict.Keys)
|
{
|
if (poolDataDict[key].rare == 1)
|
{
|
return true;
|
}
|
}
|
return false;
|
}
|
|
public bool TryGetItemRareIcon(int rare, out string iconKey)
|
{
|
iconKey = string.Empty;
|
return wishItemRareDict.TryGetValue(rare, out iconKey);
|
}
|
|
public int handStartIndex { get; private set; }
|
public int handEndIndex { get; private set; }
|
public event Action UpdateHandMoveEvent;
|
public bool isClick { get; set; }
|
public void SetHandMovePos(int wishIndex)
|
{
|
if (!isClick) return;
|
|
foreach (var key in poolDataDict.Keys)
|
{
|
if (poolDataDict[key].itemId != 0)
|
{
|
handStartIndex = key;
|
break;
|
}
|
}
|
handEndIndex = wishIndex;
|
if (UpdateHandMoveEvent != null)
|
{
|
isClick = false;
|
UpdateHandMoveEvent();
|
}
|
}
|
|
private void UpdateSecond()
|
{
|
if (!IsOpen || freeWishRedpoint.state != RedPointState.None) return;
|
|
int second = 0;
|
bool isCool = TryGetFreeWishCoolTime(out second);
|
if (!isCool)
|
{
|
UpdateFreeWishRedpoint();
|
}
|
}
|
|
#region 本地数据
|
public bool isDraging { get; set; }
|
public int dragIndex { get; set; }
|
public void ResetDragData()
|
{
|
isDraging = false;
|
dragIndex = -1;
|
}
|
public int freeRefreshCoolTime { get; private set; }
|
public string wishingPriceFormula { get; private set; }
|
public Dictionary<int, string> wishItemRareDict { get; private set; }
|
|
public void ParseConfig()
|
{
|
FuncConfigConfig funcConfig = FuncConfigConfig.Get("WishingWellCfg");
|
freeRefreshCoolTime = int.Parse(funcConfig.Numerical1);
|
wishingPriceFormula = funcConfig.Numerical2;
|
FuncConfigConfig WishingIcon = FuncConfigConfig.Get("WishingIcon");
|
wishItemRareDict = ConfigParse.GetDic<int, string>(WishingIcon.Numerical1);
|
}
|
#endregion
|
|
#region 协议
|
Dictionary<int, WishingWellItem> poolDataDict = new Dictionary<int, WishingWellItem>();
|
public int freeStartTime { get; private set; }// 免费开始倒计时时间
|
public int alreadyWishNum { get; private set; } // 许愿付费刷新次数
|
public int wishingPrice { get; private set; }
|
public void SetWishingWellPlayerInfo(HAA1A_tagMCActWishingWellPlayerInfo wishInfo)
|
{
|
freeStartTime = (int)wishInfo.FreeStartTime;
|
alreadyWishNum = (int)wishInfo.WishCnt;
|
wishingPrice = GetWishingPrice((int)wishInfo.WishCnt);
|
for (int i = 0; i < wishInfo.WellItemCnt; i++)
|
{
|
var itemInfo = wishInfo.WellItemInfo[i];
|
WishingWellItem wellItem = new WishingWellItem((int)itemInfo.ItemID, itemInfo.ItemCnt, itemInfo.IsSpecial);
|
SetWishingPoolData(i, wellItem);
|
}
|
|
for (int i = 0; i < wishInfo.CurAwardCnt; i++)
|
{
|
var itemInfo = wishInfo.CurAwardItemInfo[i];
|
WishingWellItem wellItem = new WishingWellItem((int)itemInfo.ItemID, itemInfo.ItemCnt, itemInfo.IsSpecial);
|
SetWishingData(i, wellItem);
|
}
|
|
wishingAwardDict.Clear();
|
for (int i = 0; i < wishInfo.LastAwardCnt; i++)
|
{
|
var itemInfo = wishInfo.LastAwardItemInfo[i];
|
if (itemInfo.ItemID != 0)
|
{
|
WishingWellItem wellItem = new WishingWellItem((int)itemInfo.ItemID, itemInfo.ItemCnt, itemInfo.IsSpecial);
|
SetWishingAwardData(i, wellItem);
|
}
|
}
|
UpdateRedpoint();
|
UpdateFreeWishRedpoint();
|
if (UpdateWishAwardEvent != null)
|
{
|
UpdateWishAwardEvent();
|
}
|
}
|
|
public int GetWishingPrice(int wishNum)
|
{
|
Equation.Instance.Clear();
|
Equation.Instance.AddKeyValue("refreshCnt", wishNum);
|
return Equation.Instance.Eval<int>(wishingPriceFormula);
|
}
|
|
public void SetWishingResultInfo(HAA1B_tagMCActWishingDragResult result)
|
{
|
for (int i = 0; i < result.Cnt; i++)
|
{
|
var resultInfo = result.InfoList[i];
|
WishingWellItem wellItem = new WishingWellItem((int)resultInfo.ItemID, resultInfo.ItemCnt, resultInfo.IsSpecial);
|
switch (resultInfo.WellType)
|
{
|
case 0:
|
SetWishingPoolData(resultInfo.Index, wellItem);
|
break;
|
case 1:
|
SetWishingData(resultInfo.Index, wellItem);
|
break;
|
}
|
}
|
UpdateRedpoint();
|
UpdateFreeWishRedpoint();
|
}
|
|
public void SetWishingPoolData(int index, WishingWellItem wellItem)
|
{
|
if (!poolDataDict.ContainsKey(index))
|
{
|
poolDataDict.Add(index, wellItem);
|
}
|
else
|
{
|
poolDataDict[index] = wellItem;
|
}
|
if (UpdatePoolDataEvent != null)
|
{
|
UpdatePoolDataEvent(index);
|
}
|
}
|
|
public void RemovetWishingPoolData(int index)
|
{
|
if (poolDataDict.ContainsKey(index))
|
{
|
poolDataDict.Remove(index);
|
}
|
if (UpdatePoolDataEvent != null)
|
{
|
UpdatePoolDataEvent(index);
|
}
|
}
|
|
Dictionary<int, WishingWellItem> wishingDataDict = new Dictionary<int, WishingWellItem>();
|
public void SetWishingData(int index, WishingWellItem wellItem)
|
{
|
if (!wishingDataDict.ContainsKey(index))
|
{
|
wishingDataDict.Add(index, wellItem);
|
}
|
else
|
{
|
wishingDataDict[index] = wellItem;
|
}
|
|
if (UpdateWishingDataEvent != null)
|
{
|
UpdateWishingDataEvent(index);
|
}
|
}
|
|
public Dictionary<int, WishingWellItem> wishingAwardDict = new Dictionary<int, WishingWellItem>();
|
public void SetWishingAwardData(int index, WishingWellItem wellItem)
|
{
|
if (!wishingAwardDict.ContainsKey(index))
|
{
|
wishingAwardDict.Add(index, wellItem);
|
}
|
else
|
{
|
wishingAwardDict[index] = wellItem;
|
}
|
}
|
|
public bool IsBetterItem()
|
{
|
return false;
|
}
|
|
public bool TryGetPoolDataByIndex(int index, out WishingWellItem wellItem)
|
{
|
if (poolDataDict.TryGetValue(index, out wellItem))
|
{
|
if (wellItem.itemId != 0)
|
{
|
return true;
|
}
|
}
|
return false;
|
}
|
|
public bool TryGetWishDataByIndex(int index, out WishingWellItem wellItem)
|
{
|
if (wishingDataDict.TryGetValue(index, out wellItem))
|
{
|
if (wellItem.itemId != 0)
|
{
|
return true;
|
}
|
}
|
return false;
|
}
|
|
public void SendRefreshPoolInfo(int refreshType)
|
{
|
CAA07_tagCMActWishingRefresh wishingRefresh = new CAA07_tagCMActWishingRefresh();
|
wishingRefresh.IsFree = (byte)refreshType;
|
GameNetSystem.Instance.SendInfo(wishingRefresh);
|
}
|
|
public void SendGetAwardQuest()
|
{
|
CA504_tagCMPlayerGetReward getReward = new CA504_tagCMPlayerGetReward();
|
getReward.RewardType = (byte)GotServerRewardType.Def_RewardType_WishingWell;
|
getReward.DataEx = 0;
|
getReward.DataExStrLen = 0;
|
getReward.DataExStr = string.Empty;
|
GameNetSystem.Instance.SendInfo(getReward);
|
}
|
|
public void SendRefreshWishInfo(int poolIndex, int wishIndex)
|
{
|
CAA06_tagCMActWishing actWishing = new CAA06_tagCMActWishing();
|
actWishing.SrcWellType = 0;
|
actWishing.SrcIndex = (byte)poolIndex;
|
actWishing.DesWellType = 1;
|
actWishing.DesIndex = (byte)wishIndex;
|
GameNetSystem.Instance.SendInfo(actWishing);
|
|
}
|
#endregion
|
|
#region 红点
|
public Redpoint wishPoolRedpoint = new Redpoint(MainRedDot.REDPOINT_OPENSERVER, WishRedKey);
|
public const int FREEWISH_REDKEY = 2091501;
|
public Redpoint freeWishRedpoint = new Redpoint(WishRedKey, FREEWISH_REDKEY);
|
public List<Redpoint> wishPointlist = new List<Redpoint>();
|
public void SetWishRedpoint()
|
{
|
wishPointlist.Clear();
|
for (int i = 0; i < 5; i++)
|
{
|
int redKey = WishRedKey * 100 + (i + 2);
|
Redpoint redpoint = new Redpoint(WishRedKey, redKey);
|
wishPointlist.Add(redpoint);
|
}
|
}
|
|
private void UpdateFreeWishRedpoint()
|
{
|
freeWishRedpoint.state = RedPointState.None;
|
if (!IsOpen) return;
|
for (int i = 0; i < wishPointlist.Count; i++)
|
{
|
var wishPoint = wishPointlist[i];
|
if (wishPoint.state != RedPointState.None)
|
{
|
return;
|
}
|
}
|
|
int second = 0;
|
bool isCool = TryGetFreeWishCoolTime(out second);
|
if (!isCool)
|
{
|
freeWishRedpoint.state = RedPointState.Simple;
|
}
|
}
|
|
private void UpdateRedpoint()
|
{
|
for (int i = 0; i < wishPointlist.Count; i++)
|
{
|
var wishPoint = wishPointlist[i];
|
wishPoint.state = RedPointState.None;
|
}
|
|
if (!IsOpen) return;
|
|
for (int i = 0; i < wishPointlist.Count; i++)
|
{
|
var wishPoint = wishPointlist[i];
|
WishingWellItem wellItem = null;
|
bool isWishData = TryGetWishDataByIndex(i, out wellItem);
|
if (!isWishData)
|
{
|
wishPoint.state = RedPointState.Simple;
|
return;
|
}
|
}
|
}
|
#endregion
|
|
public void ResetPoolData()
|
{
|
freeStartTime = 0;
|
poolDataDict.Clear();
|
wishingDataDict.Clear();
|
wishingAwardDict.Clear();
|
}
|
|
public class WishingWellItem
|
{
|
public int itemId;
|
public int itemCount;
|
public int rare;
|
|
public WishingWellItem(int id, int count, int rare)
|
{
|
this.itemId = id;
|
this.itemCount = count;
|
this.rare = rare;
|
}
|
}
|
}
|
}
|
