using DG.Tweening;
|
using System;
|
using System.Collections;
|
using System.Collections.Generic;
|
using System.Linq;
|
|
using UnityEngine;
|
using UnityEngine.UI;
|
|
namespace vnxbqy.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 xbOneDesText;
|
[SerializeField] Text xbBtnMoneyText;
|
[SerializeField] Button xbManyBtn;
|
[SerializeField] Text xbManyBtnText;
|
[SerializeField] Text xbManyMoneyText;
|
[SerializeField] Text xbManyDesText;
|
[SerializeField] Button freeXbBtn;
|
[SerializeField] GameObject luckDesObj;
|
[SerializeField] Text luckText;
|
[SerializeField] Transform getXBItemParent;
|
[SerializeField] GameObject xbResultObj;
|
[SerializeField] Button lookRuneBtn;
|
[SerializeField] GameObject maskObj;
|
[SerializeField] GameObject toolXBShowObj;
|
[SerializeField] Text toolNumText;
|
[SerializeField] Image toolImg1;
|
[SerializeField] Image toolImg2;
|
[SerializeField] Button skipBtn;
|
[SerializeField] GameObject skipImg;
|
[Header("控制寻宝转动圈数")]
|
[SerializeField] int cycleTimes = 1;
|
[Header("开始圈时间间隔")]
|
[SerializeField] float startDelayTime = 0.15f;
|
[Header("结束圈时间间隔")]
|
[SerializeField] float endDelayTime = 0.005f;
|
[Header("其他圈时间间隔")]
|
[SerializeField] float otherDelayTime = 0.1f;
|
[Header("开始圈初始加速度")]
|
[SerializeField] float a1 = 0.3f;
|
[Header("结束圈初始减速度")]
|
[SerializeField] float a2 = 2f;
|
[Header("其他圈初始加速度")]
|
[SerializeField] float a3 = 0.5f;
|
[Header("最大时间间隔")]
|
[SerializeField] float maxTimeInter = 0.6f;
|
[Header("最小时间间隔")]
|
[SerializeField] float minTimeInter = 0.005f;
|
[Header("闪烁次数")]
|
[SerializeField] public int flashingTimes = 10;
|
[Header("单次闪烁时间")]
|
[SerializeField] public float flashingTime = 0.2f;
|
|
[Header("得到物品停留时间")]
|
[SerializeField] float stopTime = 0.5f;
|
[Header("寻宝得到物品动画时间")]
|
[SerializeField] float scaleTime = 0.2f;
|
|
[Header("音效播放最短时间")]
|
[SerializeField] float minPlayeAudioTime = 0.1f;
|
|
List<XBItemCell> xbItemlist = new List<XBItemCell>();
|
|
List<XBGetItem> targetIndexs;
|
int curSelectIndex = 0;
|
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>(); } }
|
PackModel playerPack { get { return ModelCenter.Instance.GetModel<PackModel>(); } }
|
XBFuncSet funcSet;
|
float coolTime = 3;
|
private bool IsStartPlayAudio = false;
|
private float playeAudioTime = 0;
|
|
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);
|
skipBtn.AddListener(ClickSkipBtn);
|
}
|
|
private void ClickLookRuneBtn()
|
{
|
WindowCenter.Instance.Open<RunePreviewWin>();
|
}
|
|
protected override void OnPreOpen()
|
{
|
XBModel.StartXBEvent += OnStartXB;
|
playerPack.refreshItemCountEvent += RefreshItemCount;
|
XBModel.RefreshAgainXBAct += RefreshAgainXB;
|
XBModel.RefreshXBTypeInfoAct += RefreshXBTypeInfo;
|
XBModel.RefreshXBResultAct += RefreshXBResult;
|
GlobalTimeEvent.Instance.secondEvent += RefreshSecond;
|
getItemlist = XBModel.GetXBGetItemByID(2).Values.ToList();
|
InitUI();
|
RefreshFreeTime();
|
}
|
|
protected override void OnAfterOpen()
|
{
|
|
}
|
protected override void LateUpdate()
|
{
|
base.LateUpdate();
|
if (IsStartPlayAudio)
|
{
|
if (playeAudioTime <= 0)
|
{
|
SoundPlayer.Instance.PlayUIAudio(66);
|
}
|
playeAudioTime += Time.deltaTime;
|
if (playeAudioTime > minPlayeAudioTime)
|
{
|
playeAudioTime = 0;
|
IsStartPlayAudio = false;
|
}
|
}
|
}
|
protected override void OnPreClose()
|
{
|
XBModel.RefreshAgainXBAct -= RefreshAgainXB;
|
XBModel.RefreshXBResultAct -= RefreshXBResult;
|
XBModel.RefreshXBTypeInfoAct -= RefreshXBTypeInfo;
|
playerPack.refreshItemCountEvent -= RefreshItemCount;
|
GlobalTimeEvent.Instance.secondEvent -= RefreshSecond;
|
XBModel.StartXBEvent -= OnStartXB;
|
}
|
protected override void OnAfterClose()
|
{
|
|
}
|
|
private void RefreshSecond()
|
{
|
if (XBModel.isXBCoolTime)
|
{
|
coolTime -= 1;
|
if (coolTime < 0)
|
{
|
XBModel.isXBCoolTime = false;
|
ResetXBItemState();
|
coolTime = 3;
|
DebugEx.Log("请求超时服务端未回包");
|
}
|
}
|
else
|
{
|
coolTime = 3;
|
}
|
}
|
|
private void InitUI()
|
{
|
|
for (int i = 0; i < xbItemlist.Count; i++)
|
{
|
if (getItemlist.Count > i)
|
{
|
xbItemlist[i].SetActive(true);
|
xbItemlist[i].SetModel(getItemlist[i].itemId, getItemlist[i].count, getItemlist[i].gridIndex);
|
}
|
else
|
{
|
xbItemlist[i].SetActive(false);
|
}
|
|
}
|
playeAudioTime = 0;
|
IsStartPlayAudio = false;
|
maskObj.SetActive(false);
|
luckDesObj.SetActive(true);
|
getXBItemParent.SetActive(false);
|
xbResultObj.SetActive(false);
|
freeXbBtn.SetActive(false);
|
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];
|
xbOneDesText.text = Language.Get("HappyXB106", funcSet.costToolNums[0]);
|
xbManyDesText.text = Language.Get("HappyXB106", funcSet.costToolNums[1]);
|
ItemConfig itemConfig1 = ItemConfig.Get(funcSet.costToolIds[0]);
|
ItemConfig itemConfig2 = ItemConfig.Get(funcSet.costToolIds[1]);
|
if (itemConfig1 != null)
|
{
|
toolImg1.SetSprite(itemConfig1.IconKey);
|
}
|
if (itemConfig2 != null)
|
{
|
toolImg2.SetSprite(itemConfig2.IconKey);
|
}
|
}
|
|
RefreshXBTypeInfo();
|
RefreshXBTools();
|
RefreshSkipUI();
|
}
|
|
private void RefreshFreeTime()
|
{
|
if (XBModel.IsHaveFreeXB(2))
|
{
|
freeXbBtn.SetActive(true);
|
xbBtn.SetActive(false);
|
}
|
else
|
{
|
freeXbBtn.SetActive(false);
|
xbBtn.SetActive(true);
|
}
|
}
|
|
private void RefreshSkipUI()
|
{
|
skipImg.SetActive(XBModel.isJumpRuneXB);
|
}
|
|
private void ClickSkipBtn()
|
{
|
XBModel.isJumpRuneXB = !XBModel.isJumpRuneXB;
|
RefreshSkipUI();
|
if (XBModel.isJumpRuneXB && XBModel.rangelist.Count > 0)
|
{
|
StopAllCoroutines();
|
ResetXBItemState();
|
WindowCenter.Instance.Open<HappyXBGetItemWin>();
|
}
|
}
|
|
private void RefreshItemCount(PackType type, int index, int id)
|
{
|
if (type != PackType.Item || !XBModel.CheckIsXBTool(id, 2)) return;
|
RefreshXBTools();
|
}
|
|
public void RefreshXBTools()
|
{
|
int xbToolCnt = 0;
|
int needToolCnt = 0;
|
if (XBModel.IsHaveManyXBTool(2, out xbToolCnt, out needToolCnt))
|
{
|
toolXBShowObj.SetActive(true);
|
toolNumText.text = StringUtility.Contact("x", xbToolCnt);
|
}
|
else
|
{
|
toolXBShowObj.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()
|
{
|
XBModel.SendXBManyQuest(PackType.Treasure, 2);
|
}
|
|
private void ClickXBBtn()
|
{
|
XBModel.SendOneXBQuest(PackType.Treasure, 2);
|
}
|
|
private void ClickFreeXbBtn()
|
{
|
if (XBModel.CheckIsEmptyGrid(PackType.Treasure))
|
{
|
XBModel.SendXBQuest(2, 0, 1);
|
}
|
}
|
|
private void OnStartXB(int oneOrMany)
|
{
|
maskObj.SetActive(true);
|
if (oneOrMany == 0)
|
{
|
isXBMany = false;
|
}
|
else
|
{
|
isXBMany = true;
|
}
|
|
}
|
|
private void RefreshXBTypeInfo()
|
{
|
XBTypeInfo typeInfo = XBModel.GetXBInfoByType(2);
|
if (typeInfo == null) return;
|
|
luckText.text = typeInfo.luckValue.ToString();
|
|
RefreshFreeTime();
|
}
|
|
private void RefreshXBResult()
|
{
|
if (XBModel.isJumpRuneXB)
|
{
|
ResetXBItemState();
|
WindowCenter.Instance.Open<HappyXBGetItemWin>();
|
}
|
else
|
{
|
CreateGetItem();
|
targetIndexs = XBModel.rangelist;
|
StartCoroutine(PlayXBAni(0, 0));
|
}
|
}
|
|
private void CreateGetItem()
|
{
|
List<XBGetItem> xbResultlist = XBModel.rangelist;
|
if (xbResultlist.Count < 2) return;
|
luckDesObj.SetActive(false);
|
getXBItemParent.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.SetActive(true);
|
CommonItemBaisc itemBasic = item.transform.Find("CommonItemCell").GetComponent<CommonItemBaisc>();
|
ItemCellModel cellModel = new ItemCellModel(xbItem.itemId, false, (ulong)xbItem.count);
|
itemBasic.Init(cellModel);
|
itemBasic.transform.localScale = Vector3.zero;
|
itemBasic.transform.localPosition = Vector3.zero;
|
xbResultObjlist.Add(item);
|
itemBasic.SetActive(false);
|
xbResultItemBasiclist.Add(itemBasic);
|
}
|
}
|
|
private void ShowXBResultCtrl(int index)
|
{
|
if (index < xbResultItemBasiclist.Count)
|
{
|
xbResultItemBasiclist[index].SetActive(true);
|
xbResultItemBasiclist[index].transform.DOScale(new Vector3(1, 1, 1), scaleTime).OnComplete(() =>
|
{
|
if (index == xbResultItemBasiclist.Count - 1)
|
{
|
ResetXBItemState();
|
WindowCenter.Instance.Open<HappyXBGetItemWin>();
|
}
|
});
|
|
XBModel.GetNotifyResult(xbResultItemBasiclist[index].itemId, 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;
|
float xbSpeed1 = startDelayTime;
|
float xbSpeed2 = endDelayTime;
|
float xbSpeed3 = otherDelayTime;
|
float xbA1 = a1;
|
float XbA2 = a2;
|
float xbA3 = a3;
|
while (true)
|
{
|
IsStartPlayAudio = true;
|
curSelectIndex += 1;
|
curSelectIndex %= xbItemlist.Count;
|
if (curSelectIndex <= 0)
|
{
|
curSelectIndex = xbItemlist.Count;
|
}
|
for (int i = 0; i < xbItemlist.Count; i++)
|
{
|
xbItemlist[i].RefreshSelectIcon(curSelectIndex);
|
}
|
|
int remainIndex = targetIndexs[targetIndex].gridIndex - curSelectIndex;
|
if (remainIndex < 0)
|
{
|
remainIndex = xbItemlist.Count + remainIndex;
|
}
|
if (curSelectIndex == targetIndexs[targetIndex].gridIndex)
|
{
|
if (cycle > cycleTimes)
|
{
|
for (int i = 0; i < xbItemlist.Count; i++)
|
{
|
xbItemlist[i].CheckToFlashing(2, curSelectIndex);
|
}
|
|
if (isXBMany)
|
{
|
if (targetIndex >= targetIndexs.Count - 1)
|
{
|
StartCoroutine(PlaySelectItemAni(true));
|
}
|
else
|
{
|
|
StartCoroutine(PlaySelectItemAni(false, targetIndex, curSelectIndex));
|
}
|
}
|
else
|
{
|
StartCoroutine(PlaySelectItemAni(true));
|
}
|
break;
|
}
|
cycle += 1;
|
}
|
switch (targetIndex)
|
{
|
case 0:
|
xbSpeed1 -= xbA1 * 0.05f;
|
if (xbSpeed1 <= minTimeInter)
|
{
|
xbSpeed1 = minTimeInter;
|
}
|
yield return new WaitForSeconds(xbSpeed1);
|
break;
|
case 9:
|
if (cycle > cycleTimes && remainIndex <= 4)
|
{
|
xbSpeed2 += XbA2 * 0.05f;
|
if (xbSpeed2 >= maxTimeInter)
|
{
|
xbSpeed2 = maxTimeInter;
|
}
|
}
|
else
|
{
|
xbSpeed2 = endDelayTime;
|
}
|
yield return new WaitForSeconds(xbSpeed2);
|
break;
|
default:
|
xbSpeed3 -= xbA3 * 0.05f;
|
if (xbSpeed3 <= minTimeInter)
|
{
|
xbSpeed3 = minTimeInter;
|
}
|
yield return new WaitForSeconds(xbSpeed3);
|
break;
|
}
|
}
|
}
|
|
IEnumerator PlaySelectItemAni(bool isEndXB, int targetIndex = 0, int curSelectIndex = 0)
|
{
|
XBGetItemConfig getItemConfig = XBModel.GetXBItemConfigByType(2);
|
if (getItemConfig != null && TreasureSetConfig.Get(getItemConfig.TreasureType).LuckyGridNum == curSelectIndex)
|
{
|
yield return new WaitForSeconds(flashingTime * flashingTimes);
|
}
|
else
|
{
|
yield return new WaitForSeconds(stopTime);
|
}
|
|
if (isEndXB)
|
{
|
if (targetIndexs.Count > 1)
|
{
|
ShowXBResultCtrl(targetIndexs.Count - 1);
|
}
|
else
|
{
|
XBGetItem xbItem = targetIndexs[targetIndexs.Count - 1];
|
XBModel.GetNotifyResult(xbItem.itemId, xbItem.count);
|
ResetXBItemState();
|
WindowCenter.Instance.Open<HappyXBGetItemWin>();
|
}
|
}
|
else
|
{
|
ShowXBResultCtrl(targetIndex);
|
StartCoroutine(PlayXBAni(targetIndex + 1, curSelectIndex));
|
}
|
}
|
|
private void ResetXBItemState()
|
{
|
luckDesObj.SetActive(true);
|
maskObj.SetActive(false);
|
getXBItemParent.SetActive(false);
|
for (int i = 0; i < xbItemlist.Count; i++)
|
{
|
xbItemlist[i].RefreshSelectIcon(0);
|
}
|
}
|
}
|
}
|
