using DG.Tweening;
|
using System;
|
using System.Collections;
|
using System.Collections.Generic;
|
using System.Linq;
|
using UnityEngine;
|
using UnityEngine.UI;
|
|
namespace Snxxz.UI
|
{
|
public class RuneXBWin : Window
|
{
|
[SerializeField] Transform horTopContent;
|
[SerializeField] Transform horBottomContent;
|
[SerializeField] Transform verLeftContent;
|
[SerializeField] Transform verRightContent;
|
[SerializeField] Button xbBtn;
|
[SerializeField] Text xbBtnText;
|
[SerializeField] Text xbBtnMoneyText;
|
[SerializeField] Button xbManyBtn;
|
[SerializeField] Text xbManyBtnText;
|
[SerializeField] Text xbManyMoneyText;
|
[SerializeField] Button freeXbBtn;
|
[SerializeField] GameObject luckDesObj;
|
[SerializeField] Text luckText;
|
[SerializeField] Text freeXBTimeText;
|
[SerializeField] Transform getXBItemParent;
|
[SerializeField] GameObject xbResultObj;
|
[SerializeField] Button lookRuneBtn;
|
[SerializeField] GameObject maskObj;
|
|
[Header("控制寻宝转动圈数")]
|
[SerializeField] int cycleTimes = 1;
|
[Header("时间间隔")]
|
[SerializeField] float delayTime = 0.1f;
|
[Header("得到物品停留时间")]
|
[SerializeField] float stopTime = 0.5f;
|
[Header("寻宝得到物品动画时间")]
|
[SerializeField] float scaleTime = 0.2f;
|
|
List<XBItemCell> xbItemlist = new List<XBItemCell>();
|
|
List<XBGetItem> targetIndexs;
|
int curSelectIndex = 0;
|
bool isHaveFreeTime = false;
|
List<XBGetItem> getItemlist;
|
int xbOneMoney = 0;
|
int xbManyMoney = 0;
|
List<GameObject> xbResultObjlist = new List<GameObject>();
|
List<CommonItemBaisc> xbResultItemBasiclist = new List<CommonItemBaisc>();
|
HappyXBModel XBModel { get { return ModelCenter.Instance.GetModel<HappyXBModel>(); } }
|
|
protected override void BindController()
|
{
|
xbItemlist.Clear();
|
int length = horTopContent.childCount;
|
for(int i = 0; i < length; i++)
|
{
|
XBItemCell xbItem = horTopContent.GetChild(i).GetComponent<XBItemCell>();
|
xbItemlist.Add(xbItem);
|
}
|
length = verRightContent.childCount;
|
for (int i = 0; i < length; i++)
|
{
|
XBItemCell xbItem = verRightContent.GetChild(i).GetComponent<XBItemCell>();
|
xbItemlist.Add(xbItem);
|
}
|
length = horBottomContent.childCount;
|
for (int i = length - 1; i > - 1; i--)
|
{
|
XBItemCell xbItem = horBottomContent.GetChild(i).GetComponent<XBItemCell>();
|
xbItemlist.Add(xbItem);
|
}
|
|
length = verLeftContent.childCount;
|
for (int i = length - 1; i > -1; i--)
|
{
|
XBItemCell xbItem = verLeftContent.GetChild(i).GetComponent<XBItemCell>();
|
xbItemlist.Add(xbItem);
|
}
|
|
}
|
protected override void AddListeners()
|
{
|
xbBtn.AddListener(ClickXBBtn);
|
xbManyBtn.AddListener(ClickXBManyBtn);
|
freeXbBtn.AddListener(ClickFreeXbBtn);
|
lookRuneBtn.AddListener(ClickLookRuneBtn);
|
}
|
|
private void ClickLookRuneBtn()
|
{
|
WindowCenter.Instance.Open<RunePreviewWin>();
|
}
|
|
protected override void OnPreOpen()
|
{
|
XBModel.RefreshAgainXBAct += RefreshAgainXB;
|
XBModel.RefreshRuneXBTimeAct += RefreshFreeTime;
|
XBModel.RefreshXBTypeInfoAct += RefreshXBTypeInfo;
|
XBModel.RefreshXBResultAct += RefreshXBResult;
|
getItemlist = XBModel.GetXBGetItemByID(2).Values.ToList();
|
isHaveFreeTime = XBModel.IsHaveFreeXBTime(2);
|
InitUI();
|
TimeDownMgr.CoolTimeData data;
|
if (TimeDownMgr.Instance.Get(TimeDownMgr.CoolTimeType.HappyFreeBestXB, out data))
|
{
|
data.func = RefreshFreeTime;
|
RefreshFreeTime(Mathf.CeilToInt(data.duration - data.time));
|
}
|
else
|
{
|
RefreshFreeTime(0);
|
}
|
}
|
|
protected override void OnAfterOpen()
|
{
|
|
}
|
|
protected override void OnPreClose()
|
{
|
XBModel.RefreshAgainXBAct -= RefreshAgainXB;
|
XBModel.RefreshRuneXBTimeAct -= RefreshFreeTime;
|
XBModel.RefreshXBResultAct -= RefreshXBResult;
|
XBModel.RefreshXBTypeInfoAct -= RefreshXBTypeInfo;
|
}
|
protected override void OnAfterClose()
|
{
|
|
}
|
|
private void InitUI()
|
{
|
|
for (int i = 0; i < xbItemlist.Count;i++)
|
{
|
if(getItemlist.Count > i)
|
{
|
xbItemlist[i].gameObject.SetActive(true);
|
xbItemlist[i].SetModel(getItemlist[i].itemId, getItemlist[i].count, getItemlist[i].gridIndex);
|
}
|
else
|
{
|
xbItemlist[i].gameObject.SetActive(false);
|
}
|
|
}
|
maskObj.SetActive(false);
|
luckDesObj.SetActive(true);
|
getXBItemParent.gameObject.SetActive(false);
|
xbResultObj.SetActive(false);
|
freeXbBtn.gameObject.SetActive(false);
|
XBFuncSet funcSet = XBModel.GetXBFuncSet(2);
|
if(funcSet != null)
|
{
|
xbBtnText.text = Language.Get("HappyXB101", funcSet.xbNums[0]);
|
xbManyBtnText.text = Language.Get("HappyXB101", funcSet.xbNums[1]);
|
xbBtnMoneyText.text = funcSet.xbPrices[0].ToString();
|
xbManyMoneyText.text = funcSet.xbPrices[1].ToString();
|
xbOneMoney = funcSet.xbPrices[0];
|
xbManyMoney = funcSet.xbPrices[1];
|
}
|
|
RefreshXBTypeInfo();
|
}
|
|
private void RefreshFreeTime(float time)
|
{
|
if(isHaveFreeTime)
|
{
|
if (XBModel.IsHaveFreeXB(2))
|
{
|
freeXBTimeText.gameObject.SetActive(false);
|
freeXbBtn.gameObject.SetActive(true);
|
xbBtn.gameObject.SetActive(false);
|
}
|
else
|
{
|
freeXBTimeText.gameObject.SetActive(true);
|
freeXBTimeText.text = Language.Get("HappyXB102", TimeUtility.SecondsToHMSCHSRetain((int)time));
|
freeXbBtn.gameObject.SetActive(false);
|
xbBtn.gameObject.SetActive(true);
|
}
|
}
|
else
|
{
|
freeXBTimeText.gameObject.SetActive(false);
|
}
|
|
}
|
|
private void RefreshAgainXB(HappXBTitle title, int xbType)
|
{
|
if (title != HappXBTitle.Rune) return;
|
if (xbType == 0) ClickXBBtn();
|
else if (xbType == 1) ClickXBManyBtn();
|
}
|
|
bool isXBMany = false;
|
private void ClickXBManyBtn()
|
{
|
if (XBModel.CheckIsEmptyGrid(PackType.rptRunePack))
|
{
|
if (UIHelper.GetMoneyCnt(1) >= (ulong)xbManyMoney)
|
{
|
maskObj.SetActive(true);
|
isXBMany = true;
|
XBModel.SendXBQuest(2, 1, 0);
|
}
|
else
|
{
|
WindowCenter.Instance.Open<RechargeTipWin>();
|
}
|
}
|
}
|
|
private void ClickXBBtn()
|
{
|
if(XBModel.CheckIsEmptyGrid(PackType.rptRunePack))
|
{
|
if (UIHelper.GetMoneyCnt(1) >= (ulong)xbOneMoney)
|
{
|
maskObj.SetActive(true);
|
isXBMany = false;
|
XBModel.SendXBQuest(2, 0, 0);
|
}
|
else
|
{
|
WindowCenter.Instance.Open<RechargeTipWin>();
|
}
|
}
|
}
|
|
private void ClickFreeXbBtn()
|
{
|
if (XBModel.CheckIsEmptyGrid(PackType.rptRunePack))
|
{
|
maskObj.SetActive(true);
|
isXBMany = false;
|
XBModel.SendXBQuest(2, 0, 1);
|
}
|
}
|
|
private void RefreshXBTypeInfo()
|
{
|
XBTypeInfo typeInfo = XBModel.GetXBInfoByType(2);
|
if (typeInfo == null) return;
|
|
luckText.text = typeInfo.luckValue.ToString();
|
}
|
|
private void RefreshXBResult()
|
{
|
CreateGetItem();
|
targetIndexs = XBModel.GetXbResultDict().Values.ToList();
|
StartCoroutine(PlayXBAni(0,0));
|
}
|
|
private void CreateGetItem()
|
{
|
List<XBGetItem> xbResultlist = XBModel.GetXbResultDict().Values.ToList();
|
if (xbResultlist.Count < 2) return;
|
luckDesObj.SetActive(false);
|
getXBItemParent.gameObject.SetActive(true);
|
DestroyGetItemlist();
|
xbResultObjlist.Clear();
|
xbResultItemBasiclist.Clear();
|
for (int i = 0; i < xbResultlist.Count; i++)
|
{
|
XBGetItem xbItem = xbResultlist[i];
|
GameObject item = Instantiate(xbResultObj);
|
item.transform.SetParent(getXBItemParent);
|
item.transform.localPosition = Vector3.zero;
|
item.transform.localScale = Vector3.one;
|
item.name = StringUtility.Contact("XBItem", i);
|
item.gameObject.SetActive(true);
|
CommonItemBaisc itemBasic = item.transform.Find("CommonItemCell").GetComponent<CommonItemBaisc>();
|
ItemCellModel cellModel = new ItemCellModel(xbItem.itemId, false, (ulong)xbItem.count, xbItem.isBind);
|
itemBasic.Init(cellModel);
|
itemBasic.transform.localScale = Vector3.zero;
|
itemBasic.transform.localPosition = Vector3.zero;
|
xbResultObjlist.Add(item);
|
itemBasic.gameObject.SetActive(false);
|
xbResultItemBasiclist.Add(itemBasic);
|
}
|
}
|
|
private void ShowXBResultCtrl(int index)
|
{
|
if (index < xbResultItemBasiclist.Count)
|
{
|
xbResultItemBasiclist[index].gameObject.SetActive(true);
|
xbResultItemBasiclist[index].transform.DOScale(new Vector3(1, 1, 1), scaleTime);
|
if(xbResultItemBasiclist[index].itemConfig != null)
|
{
|
XBModel.GetNotifyResult(xbResultItemBasiclist[index].itemConfig.ID, int.Parse(xbResultItemBasiclist[index].countText.text));
|
}
|
}
|
}
|
|
private void DestroyGetItemlist()
|
{
|
for (int i = 0; i < xbResultObjlist.Count; i++)
|
{
|
Destroy(xbResultObjlist[i]);
|
}
|
}
|
|
IEnumerator PlayXBAni(int targetIndex, int curSelectIndex)
|
{
|
int cycle = 1;
|
while (true)
|
{
|
curSelectIndex += 1;
|
curSelectIndex %= xbItemlist.Count;
|
if (curSelectIndex <= 0)
|
{
|
curSelectIndex = xbItemlist.Count;
|
}
|
for (int i = 0; i < xbItemlist.Count; i++)
|
{
|
if (isXBMany)
|
{
|
xbItemlist[i].RefreshSelectIcon(curSelectIndex);
|
}
|
else
|
{
|
xbItemlist[i].RefreshSelectIcon(curSelectIndex);
|
}
|
}
|
|
if (curSelectIndex == targetIndexs[targetIndex].gridIndex)
|
{
|
if (cycle > cycleTimes)
|
{
|
if (isXBMany)
|
{
|
if (targetIndex >= targetIndexs.Count - 1)
|
{
|
StartCoroutine(PlaySelectItemAni(true));
|
}
|
else
|
{
|
|
StartCoroutine(PlaySelectItemAni(false, targetIndex, curSelectIndex));
|
}
|
}
|
else
|
{
|
StartCoroutine(PlaySelectItemAni(true));
|
}
|
break;
|
}
|
cycle += 1;
|
}
|
yield return new WaitForSeconds(delayTime);
|
}
|
}
|
|
IEnumerator PlaySelectItemAni(bool isEndXB, int targetIndex = 0, int curSelectIndex = 0)
|
{
|
yield return new WaitForSeconds(stopTime);
|
if (isEndXB)
|
{
|
RestXBItemState();
|
}
|
else
|
{
|
ShowXBResultCtrl(targetIndex);
|
StartCoroutine(PlayXBAni(targetIndex + 1, curSelectIndex));
|
}
|
}
|
|
private void RestXBItemState()
|
{
|
luckDesObj.SetActive(true);
|
maskObj.SetActive(false);
|
getXBItemParent.gameObject.SetActive(false);
|
for (int i = 0; i < xbItemlist.Count; i++)
|
{
|
xbItemlist[i].RefreshSelectIcon(0);
|
}
|
|
WindowCenter.Instance.Open<HappyXBGetItemWin>();
|
}
|
}
|
}
|
