|
using System;
|
using System.Collections;
|
using System.Collections.Generic;
|
using System.Linq;
|
|
using UnityEngine;
|
using UnityEngine.UI;
|
namespace vnxbqy.UI
|
{
|
public class RuneResolveWin : Window
|
{
|
[SerializeField] Text m_ItemCount0;
|
[SerializeField] Text m_ItemCount1;
|
[SerializeField] Text m_ItemResolveCount0;
|
[SerializeField] Text m_ItemResolveCount1;
|
[SerializeField] Button m_Resolve;
|
[SerializeField] ScrollerController m_Controller;
|
[SerializeField] List<Button> m_CheckBtns;
|
[SerializeField] Transform[] m_CheckSigns;
|
[SerializeField] UIEffect m_FlutterEffect;
|
[SerializeField] UIEffect m_AbsorbEffect;
|
[SerializeField] Button m_JumpBtn0;
|
[SerializeField] Button m_JumpBtn1;
|
[SerializeField] RectTransform m_ContainerRuneSoul;
|
[SerializeField] Text m_RuneSoulAdd;
|
|
List<ushort> resolveItems { get { return runeResolveModel.resolveItems; } }
|
List<Transform> resolveObjs { get { return runeResolveModel.resolveObjs; } }
|
List<int> itemIndexs { get { return runeResolveModel.itemIndexs; } }
|
Dictionary<int, bool> resolveSigns { get { return runeResolveModel.resolveSigns; } }
|
|
bool doResolveItem = false;
|
|
RuneModel model { get { return ModelCenter.Instance.GetModel<RuneModel>(); } }
|
RuneResolveModel runeResolveModel { get { return ModelCenter.Instance.GetModel<RuneResolveModel>(); } }
|
VirtualPackModel virtualPackModel { get { return ModelCenter.Instance.GetModel<VirtualPackModel>(); } }
|
RuneComposeModel runeComposeModel { get { return ModelCenter.Instance.GetModel<RuneComposeModel>(); } }
|
|
protected override void BindController()
|
{
|
}
|
|
protected override void AddListeners()
|
{
|
m_Resolve.onClick.AddListener(OnResolve);
|
for (int i = 0; i < m_CheckBtns.Count; i++)
|
{
|
int itemColor = i + 1;
|
m_CheckBtns[i].onClick.AddListener(() =>
|
{
|
OnClickCheck(itemColor);
|
});
|
}
|
m_JumpBtn0.onClick.AddListener(OnJumpRuneTower);
|
m_JumpBtn1.onClick.AddListener(OnJumpRuneTower);
|
|
m_Controller.OnRefreshCell += OnRefreshCell;
|
}
|
|
protected override void OnPreOpen()
|
{
|
virtualPackModel.virtualPackRefresh += VirtualPackRefresh;
|
PlayerDatas.Instance.playerDataRefreshEvent += PlayerDataRefreshInfoEvent;
|
runeResolveModel.onResolveSelect += OnResolveSelect;
|
|
doResolveItem = false;
|
|
DisplayRuneItems();
|
|
m_ContainerRuneSoul.SetActive(false);
|
}
|
|
protected override void OnAfterOpen()
|
{
|
HandleAchievement();
|
}
|
|
protected override void OnPreClose()
|
{
|
doResolveItem = false;
|
virtualPackModel.virtualPackRefresh -= VirtualPackRefresh;
|
PlayerDatas.Instance.playerDataRefreshEvent -= PlayerDataRefreshInfoEvent;
|
runeResolveModel.onResolveSelect -= OnResolveSelect;
|
|
StopAllCoroutines();
|
}
|
|
protected override void OnAfterClose()
|
{
|
|
}
|
|
private void VirtualPackRefresh(PackType packType)
|
{
|
if (packType == PackType.RunePack)
|
{
|
DisplayRuneItems();
|
RefreshResolveGetItems();
|
}
|
}
|
|
private void OnResolve()
|
{
|
resolveItems.Clear();
|
foreach (var key in resolveSigns.Keys)
|
{
|
if (resolveSigns[key]
|
&& key < itemIndexs.Count)
|
{
|
var index = itemIndexs[key];
|
RuneItem item;
|
if (virtualPackModel.TryGetItem(PackType.RunePack, index, out item))
|
{
|
resolveItems.Add((ushort)item.index);
|
}
|
}
|
}
|
if (resolveItems.Count < 1)
|
{
|
ServerTipDetails.DisplayNormalTip(Language.Get("L1059"));
|
return;
|
}
|
|
var page = Mathf.CeilToInt((float)resolveItems.Count / 50);
|
doResolveItem = true;
|
for (int i = 0; i < page; i++)
|
{
|
ushort[] resolves = resolveItems.Skip(i * 50).Take((i < page - 1) ? 50 : (resolveItems.Count - i * 50)).ToArray();
|
var pak = new CA566_tagCMRuneDecompose();
|
pak.QualityCnt = 0;
|
pak.QualityList = new byte[0];
|
pak.PlaceIndexList = resolves;
|
pak.Count = (byte)resolves.Length;
|
GameNetSystem.Instance.SendInfo(pak);
|
}
|
}
|
|
void OnClickCheck(int itemColor)
|
{
|
bool check = runeResolveModel.IsQualitySign(itemColor);
|
OnCheck(itemColor, !check);
|
}
|
|
private void OnCheck(int itemColor, bool check)
|
{
|
runeResolveModel.SetQualityMark(itemColor, check);
|
|
var checkSign = GetCheckSign(itemColor);
|
|
if (checkSign != null)
|
{
|
checkSign.SetActive(runeResolveModel.IsQualitySign(itemColor));
|
}
|
|
for (int i = 0; i < itemIndexs.Count; i++)
|
{
|
var index = itemIndexs[i];
|
RuneItem item;
|
if (virtualPackModel.TryGetItem(PackType.RunePack, index, out item))
|
{
|
var config = ItemConfig.Get(item.id);
|
if (config.ItemColor == itemColor && config.Type == RuneModel.RUNE_TYPE)
|
{
|
resolveSigns[i] = check;
|
}
|
}
|
}
|
|
m_Controller.m_Scorller.RefreshActiveCellViews();
|
RefreshResolveGetItems();
|
}
|
|
void DisplayRuneItems()
|
{
|
if (resolveObjs.Count > 0 && doResolveItem)
|
{
|
var _time = 0.0f;
|
for (int i = 0; i < resolveObjs.Count; i++)
|
{
|
if (resolveObjs[i] != null)
|
{
|
resolveObjs[i].SetActive(false);
|
var _uieffect = EffectMgr.Instance.PlayUIEffect(1007, 2500, resolveObjs[i].parent, false);
|
_time = _uieffect != null ? _uieffect.duration : 0.0f;
|
_uieffect.target.transform.localPosition = resolveObjs[i].localPosition;
|
}
|
}
|
doResolveItem = false;
|
StartCoroutine(Co_PlayEffect(_time));
|
}
|
else
|
{
|
DisplayResolveItems();
|
}
|
}
|
|
IEnumerator Co_PlayEffect(float _t)
|
{
|
yield return WaitingForSecondConst.GetWaitForSeconds(_t);
|
DisplayResolveItems();
|
m_FlutterEffect.Play();
|
m_FlutterEffect.OnComplete = OnFlutterComplete;
|
}
|
|
void DisplayResolveItems()
|
{
|
resolveObjs.Clear();
|
DisplayRunes();
|
ResetResolveSelect();
|
}
|
|
void ResetResolveSelect()
|
{
|
resolveSigns.Clear();
|
|
for (int i = 0; i < itemIndexs.Count; i++)
|
{
|
var index = itemIndexs[i];
|
RuneItem item;
|
if (virtualPackModel.TryGetItem(PackType.RunePack, index, out item))
|
{
|
resolveSigns[i] = item.itemType == RuneModel.RUNE_CREAMTYPE;
|
}
|
}
|
|
OnCheck(1, runeResolveModel.IsQualitySign(1));
|
OnCheck(2, runeResolveModel.IsQualitySign(2));
|
OnCheck(3, runeResolveModel.IsQualitySign(3));
|
OnCheck(4, runeResolveModel.IsQualitySign(4));
|
}
|
|
private void OnFlutterComplete()
|
{
|
m_AbsorbEffect.Play();
|
}
|
|
void DisplayRunes()
|
{
|
m_Controller.Refresh();
|
|
virtualPackModel.GetItemIndexs(PackType.RunePack, ref runeResolveModel.itemIndexs);
|
itemIndexs.Sort(Compare);
|
int _line = Mathf.CeilToInt((float)itemIndexs.Count / 4);
|
for (int i = 0; i < _line; i++)
|
{
|
m_Controller.AddCell(ScrollerDataType.Normal, i);
|
}
|
|
m_Controller.Restart();
|
}
|
|
void RefreshResolveGetItems()
|
{
|
float _itemCnt = 0;
|
float _magicCnt = 0;
|
float _soulCnt = 0;
|
foreach (int key in resolveSigns.Keys)
|
{
|
if (!resolveSigns[key])
|
{
|
continue;
|
}
|
|
if (key < itemIndexs.Count)
|
{
|
var index = itemIndexs[key];
|
RuneItem item;
|
if (virtualPackModel.TryGetItem(PackType.RunePack, index, out item))
|
{
|
_itemCnt += runeResolveModel.GetRuneResolveGetSplinters(item.id, item.level);
|
_soulCnt += runeResolveModel.GetRuneResolveGetSouls(item.id);
|
if (model.IsMultiPropertyRune(item.id)
|
&& runeResolveModel.IsComposeSource(item.sourceType))
|
{
|
var composeConfig = RuneComposeConfig.Get(item.id);
|
_magicCnt += (composeConfig == null ? 0 : composeConfig.NeedMJ);
|
}
|
}
|
}
|
}
|
m_ItemCount1.text = UIHelper.ReplaceLargeNum(PlayerDatas.Instance.GetPlayerDataByType(PlayerDataType.RuneSplinters));
|
m_ItemCount0.text = UIHelper.ReplaceLargeNum(PlayerDatas.Instance.GetPlayerDataByType(PlayerDataType.MagicEssence));
|
m_ItemResolveCount1.SetActive(_itemCnt != 0);
|
m_ItemResolveCount0.SetActive(_magicCnt != 0);
|
m_ItemResolveCount0.text = StringUtility.Contact("+", UIHelper.ReplaceLargeNum(_magicCnt));
|
m_ItemResolveCount1.text = StringUtility.Contact("+", UIHelper.ReplaceLargeNum((int)_itemCnt));
|
m_RuneSoulAdd.text = Language.Get("RuneSoul", UIHelper.ReplaceLargeNum((int)_soulCnt));
|
}
|
|
private void OnRefreshCell(ScrollerDataType type, CellView cell)
|
{
|
var resolveCell = cell as RuneResolveCell;
|
resolveCell.Display(cell.index);
|
}
|
|
private void OnJumpRuneTower()
|
{
|
WindowJumpMgr.Instance.WindowJumpTo(JumpUIType.RuneTower);
|
}
|
|
private void PlayerDataRefreshInfoEvent(PlayerDataType type)
|
{
|
if (type == PlayerDataType.MagicEssence
|
|| type == PlayerDataType.RuneSplinters)
|
{
|
RefreshResolveGetItems();
|
}
|
}
|
|
private void OnResolveSelect(int line)
|
{
|
m_Controller.RefreshSingleCellView(line);
|
RefreshResolveGetItems();
|
}
|
|
void HandleAchievement()
|
{
|
if (AchievementGoto.achievementType == AchievementGoto.RuneResolve)
|
{
|
var _effect = AchievementGuideEffectPool.Require(1);
|
_effect.transform.SetParentEx(m_Resolve.transform, Vector3.zero, Vector3.zero, Vector3.one);
|
}
|
}
|
|
Transform GetCheckSign(int itemColor)
|
{
|
switch (itemColor)
|
{
|
case 1:
|
return m_CheckSigns.Length > 0 ? m_CheckSigns[0] : null;
|
case 2:
|
return m_CheckSigns.Length > 1 ? m_CheckSigns[1] : null;
|
case 3:
|
return m_CheckSigns.Length > 2 ? m_CheckSigns[2] : null;
|
case 4:
|
return m_CheckSigns.Length > 3 ? m_CheckSigns[3] : null;
|
}
|
return null;
|
}
|
|
int Compare(int lhs, int rhs)
|
{
|
RuneItem lhsItem = null;
|
RuneItem rhsItem = null;
|
if (virtualPackModel.TryGetItem(PackType.RunePack, lhs, out lhsItem)
|
&& virtualPackModel.TryGetItem(PackType.RunePack, rhs, out rhsItem))
|
{
|
var lhsConfig = ItemConfig.Get(lhsItem.id);
|
var rhsConfig = ItemConfig.Get(rhsItem.id);
|
if (lhsConfig.Type != rhsConfig.Type)
|
{
|
return lhsConfig.Type.CompareTo(rhsConfig.Type);
|
}
|
if (lhsConfig.ItemColor != rhsConfig.ItemColor)
|
{
|
return -lhsConfig.ItemColor.CompareTo(rhsConfig.ItemColor);
|
}
|
if (lhsItem.level != rhsItem.level)
|
{
|
return -lhsItem.level.CompareTo(rhsItem.level);
|
}
|
if (lhsItem.id != rhsItem.id)
|
{
|
return -lhsItem.id.CompareTo(rhsItem.id);
|
}
|
}
|
return 1;
|
}
|
}
|
}
|
|
