//--------------------------------------------------------
|
// [Author]: 第二世界
|
// [ Date ]: Monday, November 20, 2017
|
//--------------------------------------------------------
|
|
|
using System;
|
using System.Collections;
|
using System.Collections.Generic;
|
using UnityEngine;
|
using UnityEngine.UI;
|
|
using System.Linq;
|
|
namespace vnxbqy.UI
|
{
|
|
public class RuneMosaicWin : Window
|
{
|
[SerializeField] RuneHoleBehaviour[] m_RuneHoles;
|
|
[SerializeField] Transform m_ContainerEquiped;
|
[SerializeField] Transform m_ContainerGetRune;
|
[SerializeField] Transform m_ContainerSpecialLock;
|
|
[SerializeField] Button m_LevelUp;
|
[SerializeField] Text m_LevelUpLabel;
|
[SerializeField] Button m_ReplaceRune;
|
[SerializeField] Text m_ReplaceLabel;
|
[SerializeField] Button m_RunePreview;
|
[SerializeField] RedpointBehaviour m_LevelUpRedpoint;
|
[SerializeField] RedpointBehaviour m_ReplaceRedpoint;
|
|
[SerializeField] Image m_RuneIcon;
|
[SerializeField] Text m_RuneName;
|
[SerializeField] Text m_RuneProperty;
|
[SerializeField] Transform m_ContainerLevelUp;
|
[SerializeField] PropertyBehaviour[] m_Propertys;
|
[SerializeField] Text m_CostEssence;
|
[SerializeField] RectTransform m_ContaienrMaxLevel;
|
|
[SerializeField] Button m_GotoGetRuneBtn;
|
[SerializeField] Button m_GotoFindRune;
|
|
[SerializeField] RectTransform m_ContainerSpecial;
|
[SerializeField] Button m_UnlockSpecialHole;
|
[SerializeField] Text m_SpecialCostRemind;
|
[SerializeField] Text m_SpecialLevelRemind;
|
|
[SerializeField] Text m_RuneUnlockRemind;
|
[SerializeField] UIEffect m_LevelUpEffect;
|
[SerializeField] UIEffect m_SpecialHoleEffect;
|
|
[SerializeField] Button m_XunBao;
|
|
RuneHoleState selectHoleState = RuneHoleState.Lock;
|
Coroutine m_CacheCoroutine;
|
|
bool doLevelUp = false;
|
|
RuneModel model { get { return ModelCenter.Instance.GetModel<RuneModel>(); } }
|
|
#region Built-in
|
protected override void BindController()
|
{
|
}
|
|
protected override void AddListeners()
|
{
|
m_ReplaceRune.onClick.AddListener(OpenRunePack);
|
m_LevelUp.onClick.AddListener(OnLevelUp);
|
m_RunePreview.onClick.AddListener(OpenRunePreview);
|
m_GotoGetRuneBtn.onClick.AddListener(OnGotoGetRune);
|
m_GotoFindRune.onClick.AddListener(GotoFindRune);
|
m_UnlockSpecialHole.onClick.AddListener(UnlockSpecialHole);
|
m_XunBao.onClick.AddListener(OpenXB);
|
}
|
|
protected override void OnPreOpen()
|
{
|
model.unlockingSpecialHole = false;
|
|
model.onSelectHoleRefresh += OnSelectHoleRefresh;
|
model.onRuneHoleRefresh += OnRuneHoleRefresh;
|
model.onOpenNewHole += OnOpenNewHole;
|
PlayerDatas.Instance.playerDataRefreshEvent += PlayerDataRefreshEvent;
|
Display();
|
}
|
|
protected override void OnAfterOpen()
|
{
|
HandleAchievement();
|
model.SetDayRemind();
|
}
|
|
protected override void OnPreClose()
|
{
|
model.onSelectHoleRefresh -= OnSelectHoleRefresh;
|
model.onRuneHoleRefresh -= OnRuneHoleRefresh;
|
model.onOpenNewHole -= OnOpenNewHole;
|
PlayerDatas.Instance.playerDataRefreshEvent -= PlayerDataRefreshEvent;
|
|
doLevelUp = false;
|
|
for (int i = 0; i < m_RuneHoles.Length; i++)
|
{
|
m_RuneHoles[i].Dispose();
|
}
|
|
if (m_CacheCoroutine != null)
|
{
|
StopCoroutine(m_CacheCoroutine);
|
m_CacheCoroutine = null;
|
}
|
}
|
|
protected override void OnAfterClose()
|
{
|
}
|
#endregion
|
|
void SetDefaultSelect()
|
{
|
if (NewBieCenter.Instance.inGuiding)
|
{
|
model.selectHole = 0;
|
}
|
if (model.specialHoleRedpoint.state == RedPointState.Simple)
|
{
|
model.selectHole = model.specialHole;
|
return;
|
}
|
for (int i = 0; i < RuneModel.RUNE_HOLE_COUNT; i++)
|
{
|
RuneModel.RuneHoleRedpoint redpoint;
|
if (model.TryGetRedpoint(i, out redpoint))
|
{
|
if (redpoint.redpoint.state == RedPointState.Simple)
|
{
|
model.selectHole = i;
|
return;
|
}
|
}
|
}
|
model.selectHole = 0;
|
}
|
|
void Display()
|
{
|
SetDefaultSelect();
|
|
for (int i = 0; i < m_RuneHoles.Length; i++)
|
{
|
m_RuneHoles[i].Display(i);
|
}
|
|
DisplayHoleDetail();
|
DisplayUnlockRemind();
|
DisplaySpecialHole();
|
}
|
|
void DisplayHoleDetail()
|
{
|
if (!model.IsRuneHoleOpen(model.selectHole, model.holeState))
|
{
|
selectHoleState = RuneHoleState.Lock;
|
}
|
else
|
{
|
RuneItem item;
|
if (!model.TryGetRuneHoleItem(model.selectHole, out item))
|
{
|
selectHoleState = RuneHoleState.UnEquip;
|
}
|
else
|
{
|
selectHoleState = RuneHoleState.Equiped;
|
}
|
}
|
|
RuneModel.RuneHoleRedpoint redpoint;
|
if (model.TryGetRedpoint(model.selectHole, out redpoint))
|
{
|
m_LevelUpRedpoint.redpointId = redpoint.levelUpRedpoint.id;
|
m_ReplaceRedpoint.redpointId = redpoint.replaceRedpoint.id;
|
}
|
|
m_ContainerEquiped.SetActive(selectHoleState == RuneHoleState.Equiped);
|
m_ContainerGetRune.SetActive(selectHoleState == RuneHoleState.UnEquip);
|
m_ContainerSpecialLock.SetActive(selectHoleState == RuneHoleState.Lock
|
&& model.selectHole == model.specialHole);
|
m_ReplaceRune.SetActive(selectHoleState != RuneHoleState.Lock);
|
m_LevelUp.SetActive(selectHoleState == RuneHoleState.Equiped);
|
|
switch (selectHoleState)
|
{
|
case RuneHoleState.Lock:
|
if (model.selectHole == model.specialHole)
|
{
|
DisplaySpecialHoleDetail();
|
}
|
break;
|
case RuneHoleState.UnEquip:
|
break;
|
case RuneHoleState.Equiped:
|
DisplayEquipedHoleDetail();
|
break;
|
}
|
}
|
|
void DisplayEquipedHoleDetail()
|
{
|
RuneItem item;
|
model.TryGetRuneHoleItem(model.selectHole, out item);
|
var config = RuneConfig.Get(item.id);
|
var multiProperty = model.IsMultiPropertyRune(item.id);
|
|
var itemConfig = ItemConfig.Get(item.id);
|
m_RuneIcon.SetSprite(itemConfig.IconKey);
|
m_RuneProperty.text = model.GetRunePropertyDescription(item.id, item.level);
|
m_RuneName.text = StringUtility.Contact(itemConfig.ItemName, Language.Get("Z1024", item.level));
|
m_RuneName.color = UIHelper.GetUIColor(itemConfig.ItemColor, true);
|
|
var isMax = model.IsRuneMaxLevel(item.id, item.level);
|
m_ContaienrMaxLevel.SetActive(isMax);
|
m_ContainerLevelUp.SetActive(!isMax);
|
|
if (!isMax)
|
{
|
for (int i = 0; i < m_Propertys.Length; i++)
|
{
|
m_Propertys[i].SetActive(i < config.AttrType.Length);
|
if (i < config.AttrType.Length)
|
{
|
var propertyValue = model.GetPropertyValue(item.id, item.level, config.AttrType[i]);
|
var upValue = model.GetPropertyValue(item.id, item.level + 1, config.AttrType[i]);
|
m_Propertys[i].DisplayUp(config.AttrType[i], propertyValue, upValue);
|
}
|
}
|
|
int requireEssence = model.GetLevelUpRequireRuneEssence(item.id, item.level);
|
ulong essence = PlayerDatas.Instance.GetPlayerDataByType(PlayerDataType.RuneSplinters);
|
var essenceLabel = UIHelper.AppendColor(essence >= (ulong)requireEssence ? TextColType.Green : TextColType.Red
|
, essence.ToString(), true);
|
m_CostEssence.text = StringUtility.Contact(essenceLabel, "/", requireEssence);
|
}
|
|
m_LevelUp.SetInteractable(m_LevelUpLabel, !isMax);
|
m_LevelUp.SetActive(!isMax);
|
}
|
|
void DisplaySpecialHoleDetail()
|
{
|
RuneHoleCondition condition;
|
if (model.TryGetRuneHoleCondition(model.selectHole, out condition))
|
{
|
m_SpecialCostRemind.text = Language.Get("RuneSpecialHoleCost", condition.diamond);
|
m_SpecialLevelRemind.text = Language.Get("RuneSpecialHoleLevel", condition.playerLevel);
|
}
|
}
|
|
void DisplayUnlockRemind()
|
{
|
var lockHole = -1;
|
for (int i = 0; i < RuneModel.RUNE_HOLE_COUNT; i++)
|
{
|
if (i == model.specialHole)
|
{
|
continue;
|
}
|
if (!model.IsRuneHoleOpen(i, model.holeState))
|
{
|
lockHole = i;
|
break;
|
}
|
}
|
if (lockHole != -1)
|
{
|
RuneHoleCondition condition;
|
if (model.TryGetRuneHoleCondition(lockHole, out condition))
|
{
|
var config = RuneTowerFloorConfig.Get(condition.runeTowerFloor);
|
var tower = RuneTowerConfig.Get(config.TowerId);
|
m_RuneUnlockRemind.text = Language.Get("RuneUnlock",
|
StringUtility.Contact(tower.TowerName, config.FloorName));
|
}
|
}
|
else
|
{
|
var _tower = 0;
|
if (model.IsUnlockAllMultiPropertyInlay(out _tower))
|
{
|
m_RuneUnlockRemind.text = Language.Get("L1060", model.GetMultiPropertyInlayCount());
|
}
|
else
|
{
|
var config = RuneTowerFloorConfig.Get(_tower);
|
var tower = RuneTowerConfig.Get(config.TowerId);
|
m_RuneUnlockRemind.text = Language.Get("RuneDoubleAttr",
|
StringUtility.Contact(tower.TowerName, config.FloorName)
|
, model.GetMultiPropertyInlayCount(_tower));
|
}
|
}
|
}
|
|
void DisplaySpecialHole()
|
{
|
m_SpecialHoleEffect.StopImediatly();
|
if (!model.IsRuneHoleOpen(model.specialHole, model.holeState))
|
{
|
m_SpecialHoleEffect.Play();
|
}
|
}
|
|
private void OnSelectHoleRefresh()
|
{
|
DisplayHoleDetail();
|
}
|
|
private void OnRuneHoleRefresh()
|
{
|
if (model.selectHole == model.specialHole && model.unlockingSpecialHole)
|
{
|
return;
|
}
|
|
DisplayHoleDetail();
|
|
if (doLevelUp)
|
{
|
m_LevelUpEffect.Play();
|
doLevelUp = false;
|
}
|
}
|
|
private void PlayerDataRefreshEvent(PlayerDataType dataType)
|
{
|
if (dataType == PlayerDataType.RuneSplinters)
|
{
|
if (selectHoleState == RuneHoleState.Equiped)
|
{
|
DisplayEquipedHoleDetail();
|
}
|
}
|
}
|
|
void OnOpenNewHole(int hole)
|
{
|
if (model.specialHole == hole)
|
{
|
model.unlockingSpecialHole = true;
|
EffectMgr.Instance.PlayUIEffect(3068, 2500, m_RuneHoles[hole].transform, false);
|
m_CacheCoroutine = StartCoroutine(Co_RefreshHole());
|
}
|
}
|
|
IEnumerator Co_RefreshHole()
|
{
|
yield return WaitingForSecondConst.WaitMS800;
|
model.unlockingSpecialHole = false;
|
DisplaySpecialHole();
|
if (model.selectHole == model.specialHole)
|
{
|
DisplayHoleDetail();
|
}
|
}
|
|
private void OpenXB()
|
{
|
m_SpecialHoleEffect.Stop();
|
var xbModel = ModelCenter.Instance.GetModel<HappyXBModel>();
|
var functionOrder = 1;
|
if (xbModel.runeXBRed.state == RedPointState.Simple)
|
{
|
functionOrder = 1;
|
}
|
else if (xbModel.xbWarehouseRed.state == RedPointState.Simple)
|
{
|
functionOrder = 3;
|
}
|
WindowCenter.Instance.Open<HappyXBWin>(false, functionOrder);
|
}
|
|
private void UnlockSpecialHole()
|
{
|
if (model.selectHole != model.specialHole)
|
{
|
return;
|
}
|
if (model.IsRuneHoleOpen(model.selectHole, model.holeState))
|
{
|
return;
|
}
|
int error = 0;
|
if (!TestUnlockSpeicalHole(model.selectHole, out error))
|
{
|
ProcessUnlockError(error, model.selectHole);
|
return;
|
}
|
CA513_tagCMUnlockRuneHole pak = new CA513_tagCMUnlockRuneHole();
|
pak.HoleIndex = (byte)model.selectHole;
|
GameNetSystem.Instance.SendInfo(pak);
|
}
|
|
bool TestUnlockSpeicalHole(int hole, out int error)
|
{
|
error = 0;
|
RuneHoleCondition condition;
|
if (model.TryGetRuneHoleCondition(hole, out condition))
|
{
|
if (PlayerDatas.Instance.baseData.LV < condition.playerLevel)
|
{
|
error = 1;
|
return false;
|
}
|
if (PlayerDatas.Instance.baseData.diamond < condition.diamond)
|
{
|
error = 2;
|
return false;
|
}
|
}
|
return true;
|
}
|
|
void ProcessUnlockError(int error, int hole)
|
{
|
switch (error)
|
{
|
case 1:
|
RuneHoleCondition condition;
|
if (model.TryGetRuneHoleCondition(hole, out condition))
|
{
|
SysNotifyMgr.Instance.ShowTip("RuneSpecialHoleLevelError", condition.playerLevel);
|
}
|
break;
|
case 2:
|
WindowCenter.Instance.Open<RechargeTipWin>();
|
break;
|
}
|
}
|
|
private void OnGotoGetRune()
|
{
|
WindowJumpMgr.Instance.WindowJumpTo(JumpUIType.RuneTower);
|
}
|
|
private void GotoFindRune()
|
{
|
WindowJumpMgr.Instance.WindowJumpTo(JumpUIType.RuneXB);
|
}
|
|
void HandleAchievement()
|
{
|
if (AchievementGoto.achievementType == AchievementGoto.RuneLevelUp)
|
{
|
for (int i = 0; i < RuneModel.RUNE_HOLE_COUNT; i++)
|
{
|
if (model.SatisfyLevelUpHole(i))
|
{
|
model.selectHole = i;
|
var _effect = AchievementGuideEffectPool.Require(1);
|
_effect.transform.SetParentEx(m_LevelUp.transform, Vector3.zero, Vector3.zero, Vector3.one);
|
AchievementGoto.achievementType = 0;
|
return;
|
}
|
}
|
SysNotifyMgr.Instance.ShowTip("Achievement_45");
|
AchievementGoto.achievementType = 0;
|
}
|
else
|
{
|
var _color = AchievementGoto.guideAchievementId == AchievementGoto.EquipRune1 ? 1 :
|
AchievementGoto.guideAchievementId == AchievementGoto.EquipRune2 ? 2 : 0;
|
if (_color > 0)
|
{
|
int _hole = 0;
|
if (model.TryEquipRuneByColor(_color, out _hole))
|
{
|
model.selectHole = _hole;
|
var _effect = AchievementGuideEffectPool.Require(1);
|
_effect.transform.SetParentEx(m_ReplaceRune.transform, Vector3.zero, Vector3.zero, Vector3.one);
|
}
|
else
|
{
|
SysNotifyMgr.Instance.ShowTip("Achievement_44");
|
}
|
}
|
AchievementGoto.guideAchievementId = 0;
|
}
|
}
|
|
private void OpenRunePack()
|
{
|
RunePackWin.selectHole = model.selectHole;
|
WindowCenter.Instance.Open<RunePackWin>();
|
}
|
|
private void OpenRunePreview()
|
{
|
WindowCenter.Instance.Open<RunePreviewWin>();
|
}
|
|
|
void OnLevelUp()
|
{
|
RuneItem item;
|
if (!model.TryGetRuneHoleItem(model.selectHole, out item))
|
{
|
return;
|
}
|
if (model.IsRuneMaxLevel(item.id, item.level))
|
{
|
return;
|
}
|
var config = RuneConfig.Get(item.id);
|
var itemConfig = ItemConfig.Get(item.id);
|
var requireEssence = model.GetLevelUpRequireRuneEssence(item.id, item.level);
|
LimitedTimeLuxuryGiftModel.Instance.IsItemIdShow(54, 41, requireEssence, 2, 0);
|
if (PlayerDatas.Instance.GetPlayerDataByType(PlayerDataType.RuneSplinters) < (ulong)requireEssence)
|
{
|
SysNotifyMgr.Instance.ShowTip("RuneEssenceLack");
|
return;
|
}
|
CA565_tagCMRuneUp pak = new CA565_tagCMRuneUp();
|
pak.PlaceIndex = (ushort)item.index;
|
pak.PlaceType = (byte)item.placeType;
|
GameNetSystem.Instance.SendInfo(pak);
|
|
doLevelUp = true;
|
}
|
|
public enum RuneHoleState
|
{
|
Lock,
|
UnEquip,
|
Equiped,
|
}
|
}
|
}
|
|
|
|
|
