//--------------------------------------------------------
|
// [Author]: 第二世界
|
// [ Date ]: Tuesday, October 10, 2017
|
//--------------------------------------------------------
|
|
using LitJson;
|
using System;
|
using System.Collections.Generic;
|
using UnityEngine;
|
using UnityEngine.UI;
|
|
namespace vnxbqy.UI
|
{
|
|
public class RealmWin : Window
|
{
|
[SerializeField] Transform m_ContainerRealmUp;
|
[SerializeField] RealmBriefBehaviour m_RealmBrief;
|
[SerializeField] RealmLevelUpBehaviour m_RealmLevelUp;
|
[SerializeField] RealmPoolBehaviour m_RealmPool;
|
[SerializeField] RealmAnimationBehaviour m_RealmAnimation;
|
[SerializeField] RealmStageBehaviour[] m_RealmStages;
|
[SerializeField] Transform m_ContainerUnlockEquip;
|
[SerializeField] Image m_EquipName;
|
[SerializeField] Transform m_ContainerBoss;
|
[SerializeField] RealmHeartMagicBehaviour m_RealmHeartMagic;
|
[SerializeField] Button m_RealmRestraint;
|
[SerializeField] Button m_GotoBoss;
|
[SerializeField] Button m_Close;
|
|
[SerializeField] PositionTween m_RealmBriefTween;
|
[SerializeField] PositionTween m_RealmLevelUpTween;
|
[SerializeField] UIEffect m_EffectCover;
|
[SerializeField] UIEffect m_EffectBoss;
|
[SerializeField] UIEffect m_EffectBase;
|
|
[SerializeField] Transform m_RealmContainer;
|
[SerializeField] Transform m_XxzlContainer;
|
[SerializeField] List<ButtonEx> juanImgs;
|
[SerializeField] List<UIEffect> juanEffects;
|
[SerializeField] List<ItemCell> items;
|
[SerializeField] Text xxzlMission;
|
[SerializeField] IntensifySmoothSlider ExpSlider;
|
[SerializeField] Text processTxt;
|
[SerializeField] Button activeBtn;
|
[SerializeField] Image activedImg;
|
[SerializeField] Button leftBtn;
|
[SerializeField] Button rightBtn;
|
[SerializeField] UIEffect xxzlOverEffect;
|
[SerializeField] Button towerBtn;
|
|
int cacheRealmLevel = 0;
|
ulong cacheFightPower = 0;
|
ulong customUpPower = 0;
|
bool tweenOnStart = false;
|
|
const int REALM_STAGE_COUNT = 5;
|
|
RealmState m_RealmState = RealmState.LevelUp;
|
RealmState realmState
|
{
|
get { return m_RealmState; }
|
set
|
{
|
if (m_RealmState != value)
|
{
|
switch (m_RealmState)
|
{
|
case RealmState.LevelUp:
|
HideRealmUp();
|
break;
|
case RealmState.Boss:
|
HideRealmBoss();
|
break;
|
}
|
m_RealmState = value;
|
switch (m_RealmState)
|
{
|
case RealmState.LevelUp:
|
DisplayRealmUp();
|
break;
|
case RealmState.Boss:
|
DisplayRealmBoss();
|
break;
|
}
|
}
|
}
|
}
|
|
RealmModel model
|
{
|
get
|
{
|
return ModelCenter.Instance.GetModel<RealmModel>();
|
}
|
}
|
|
DungeonModel dungeonModel { get { return ModelCenter.Instance.GetModel<DungeonModel>(); } }
|
PlayerMainDate mainDateModel { get { return ModelCenter.Instance.GetModel<PlayerMainDate>(); } }
|
|
#region Built-in
|
protected override void BindController()
|
{
|
}
|
|
protected override void AddListeners()
|
{
|
m_Close.onClick.AddListener(OnBack);
|
m_GotoBoss.AddListener(GotoBoss);
|
m_RealmRestraint.AddListener(RealmRestraint);
|
for (int i = 0; i < juanImgs.Count; i++)
|
{
|
int index = i;
|
juanImgs[i].AddListener(() =>
|
{
|
model.selectXXZL = index;
|
DisplayXXZL();
|
juanEffects[index].Play();
|
});
|
}
|
|
leftBtn.AddListener(() => {
|
if (model.selectXXZL == 0) return;
|
model.selectXXZL--;
|
juanImgs[model.selectXXZL].onClick.Invoke();
|
});
|
rightBtn.AddListener(() =>
|
{
|
if (model.selectXXZL == juanImgs.Count - 1) return;
|
model.selectXXZL++;
|
juanImgs[model.selectXXZL].onClick.Invoke();
|
});
|
|
towerBtn.AddListener(() => {
|
WindowJumpMgr.Instance.WindowJumpToEx("RealmTowerWin");
|
});
|
}
|
|
protected override void OnPreOpen()
|
{
|
PlayerDatas.Instance.playerDataRefreshEvent += PlayerDataRefreshEvent;
|
model.selectRealmRefresh += SelectRealmRefresh;
|
m_RealmAnimation.onRotateComplete += OnRotateComplete;
|
m_RealmAnimation.onLevelUpComplete += OnLevelUpComplete;
|
m_RealmAnimation.onBossAppearComplete += OnBossAppearComplete;
|
m_RealmAnimation.onCoverChange += OnCoverChange;
|
mainDateModel.customDisplayPower += CustomDisplayPower;
|
WindowCenter.Instance.windowAfterCloseEvent += WindowAfterCloseEvent;
|
model.xxzlStateRefresh += Model_xxzlStateRefresh;
|
|
cacheRealmLevel = PlayerDatas.Instance.baseData.realmLevel;
|
cacheFightPower = PlayerDatas.Instance.baseData.FightPoint;
|
customUpPower = 0;
|
|
model.SetDayRemind();
|
|
model.FocusSelectIndex();
|
}
|
|
|
|
protected override void OnActived()
|
{
|
var isOver = model.IsRealmXXZLOver();
|
m_RealmContainer.SetActive(isOver);
|
m_XxzlContainer.SetActive(!isOver);
|
m_RealmState = RealmState.LevelUp;
|
HideRealmBoss();
|
|
DisplayRealmUp();
|
|
tweenOnStart = true;
|
m_RealmBriefTween.SetStartState();
|
m_RealmLevelUpTween.SetStartState();
|
if (!m_RealmAnimation.isPlayingBossEffect)
|
{
|
StartTween();
|
}
|
}
|
|
protected override void OnAfterOpen()
|
{
|
DisplayXXZL();
|
}
|
|
protected override void OnPreClose()
|
{
|
PlayerDatas.Instance.playerDataRefreshEvent -= PlayerDataRefreshEvent;
|
model.selectRealmRefresh -= SelectRealmRefresh;
|
m_RealmAnimation.onRotateComplete -= OnRotateComplete;
|
m_RealmAnimation.onLevelUpComplete -= OnLevelUpComplete;
|
m_RealmAnimation.onBossAppearComplete -= OnBossAppearComplete;
|
mainDateModel.customDisplayPower -= CustomDisplayPower;
|
m_RealmAnimation.onCoverChange -= OnCoverChange;
|
WindowCenter.Instance.windowAfterCloseEvent -= WindowAfterCloseEvent;
|
model.xxzlStateRefresh -= Model_xxzlStateRefresh;
|
|
HideRealmUp();
|
}
|
|
protected override void OnAfterClose()
|
{
|
if (!WindowJumpMgr.Instance.IsJumpState)
|
{
|
WindowCenter.Instance.Open<MainInterfaceWin>();
|
}
|
}
|
#endregion
|
|
void DisplayRealmUp()
|
{
|
m_ContainerRealmUp.SetActive(true);
|
|
model.displayRealms.Clear();
|
var realmLevel = PlayerDatas.Instance.baseData.realmLevel;
|
if (realmLevel < model.realmMaxLevel)
|
{
|
model.selectRealm = realmLevel + 1;
|
}
|
else
|
{
|
model.selectRealm = realmLevel;
|
}
|
|
DisplayRealmLevelUp();
|
DisplayRealmStages();
|
DisplayRealmBrief();
|
DisplayRealmPool();
|
DisplayUnlockEquip();
|
DisplayCover();
|
|
if (model.SatisfyChallengeBoss(model.displayRealmLevel))
|
{
|
if (!model.GetBossEffectShow(model.displayRealmLevel))
|
{
|
m_RealmAnimation.StartBossEffectShow();
|
m_GotoBoss.SetActive(false);
|
model.SetBossEffectShow(model.displayRealmLevel);
|
return;
|
}
|
}
|
DisplayEffectBoss();
|
|
}
|
|
void HideRealmUp()
|
{
|
m_ContainerRealmUp.SetActive(false);
|
m_RealmAnimation.Dispose();
|
m_RealmBriefTween.Stop();
|
m_RealmBriefTween.SetEndState();
|
m_RealmLevelUpTween.Stop();
|
m_RealmLevelUpTween.SetEndState();
|
//m_RealmPool.Dispose();
|
model.displayRealms.Clear();
|
foreach (var item in m_RealmStages)
|
{
|
item.Dispose();
|
}
|
}
|
|
void DisplayRealmBoss()
|
{
|
m_ContainerBoss.SetActive(true);
|
var realmLevel = PlayerDatas.Instance.baseData.realmLevel;
|
m_RealmHeartMagic.Display(realmLevel);
|
}
|
|
void HideRealmBoss()
|
{
|
m_ContainerBoss.SetActive(false);
|
m_RealmHeartMagic.Dispose();
|
}
|
|
void DisplayRealmStages()
|
{
|
var stage = model.GetRealmStage(model.displayRealmLevel);
|
m_RealmAnimation.SetDefault();
|
List<int> realms = null;
|
if (model.TryGetRealmStages(stage, out realms))
|
{
|
for (int i = 0; i < m_RealmStages.Length; i++)
|
{
|
var index = m_RealmStages[i].animIndex;
|
m_RealmStages[i].SetActive(index < REALM_STAGE_COUNT);
|
if (realms[0] + index <= model.realmMaxLevel)
|
{
|
m_RealmStages[i].Display(realms[0] + index);
|
}
|
}
|
}
|
}
|
|
void DisplayRealmLevelUp()
|
{
|
var requireLevelUp = model.displayRealmLevel < model.realmMaxLevel
|
&& model.selectRealm > model.displayRealmLevel;
|
m_RealmLevelUp.SetActive(requireLevelUp);
|
if (requireLevelUp)
|
{
|
m_RealmLevelUp.Display(model.selectRealm);
|
}
|
|
m_GotoBoss.SetActive(model.SatisfyChallengeBoss(model.displayRealmLevel));
|
}
|
|
void DisplayRealmBrief()
|
{
|
m_RealmBrief.Display(model.selectRealm);
|
}
|
|
void DisplayRealmPool()
|
{
|
m_RealmPool.SetActive(false);
|
//if (model.displayRealmLevel >= model.realmPoolOpenLevel - 1)
|
//{
|
// m_RealmPool.SetActive(true);
|
// m_RealmPool.Display(model.displayRealmLevel);
|
//}
|
//else
|
//{
|
// m_RealmPool.SetActive(false);
|
//}
|
}
|
|
void DisplayUnlockEquip()
|
{
|
m_ContainerUnlockEquip.SetActive(false);
|
|
if (model.displayRealmLevel < model.realmEquipDisplayLevel)
|
{
|
return;
|
}
|
|
var stage = model.GetRealmStage(model.displayRealmLevel);
|
List<int> realms = null;
|
if (model.TryGetRealmStages(stage, out realms))
|
{
|
for (int i = 0; i < REALM_STAGE_COUNT; i++)
|
{
|
var level = realms[0] + i;
|
var equipSet = 0;
|
if (model.displayRealmLevel < level && model.selectRealm != level
|
&& model.IsUnlockEquipRealm(level, out equipSet))
|
{
|
var index = i;
|
m_ContainerUnlockEquip.SetActive(true);
|
foreach (var realmStage in m_RealmStages)
|
{
|
if (realmStage.animIndex == index)
|
{
|
var worldpos = realmStage.transform.TransformPoint(Vector2.zero + Vector2.down * 60);
|
var localpos = m_ContainerRealmUp.InverseTransformPoint(worldpos);
|
m_ContainerUnlockEquip.localPosition = localpos;
|
break;
|
}
|
}
|
var config = RealmConfig.Get(level);
|
m_EquipName.SetSprite(config.equipNameIcon);
|
break;
|
}
|
}
|
}
|
}
|
|
void DisplayCover()
|
{
|
m_EffectCover.StopImediatly();
|
if (model.displayRealmLevel == model.realmMaxLevel)
|
{
|
var id = model.GetRealmCoverEffect(model.realmMaxLevel);
|
m_EffectCover.effect = id;
|
m_EffectCover.Play();
|
}
|
else
|
{
|
var config = RealmConfig.Get(model.displayRealmLevel);
|
var isBossExist = model.SatisfyChallengeBoss(model.displayRealmLevel);
|
if (isBossExist)
|
{
|
return;
|
}
|
var stage = model.GetRealmStage(model.displayRealmLevel);
|
List<int> realms = null;
|
if (model.TryGetRealmStages(stage, out realms))
|
{
|
var id = model.GetRealmCoverEffect(realms[0]);
|
m_EffectCover.effect = id;
|
m_EffectCover.Play();
|
}
|
}
|
}
|
|
void DisplayEffectBoss()
|
{
|
bool requireBossEffect = false;
|
m_EffectBoss.StopImediatly();
|
if (model.SatisfyChallengeBoss(model.displayRealmLevel))
|
{
|
requireBossEffect = true;
|
m_EffectBoss.Play();
|
Animator animator = null;
|
if (m_EffectBoss.target != null)
|
{
|
animator = m_EffectBoss.target.GetAnimator();
|
animator.Play("Effect_JingJieBJ_021", 0, 1);
|
}
|
}
|
|
if (m_EffectBase.target != null)
|
{
|
var obj = m_EffectBase.target.transform.Find("GameObject/b/b (3)");
|
if (obj != null)
|
{
|
obj.SetActive(!requireBossEffect);
|
}
|
}
|
}
|
|
void StartTween()
|
{
|
if (!model.IsRealmXXZLOver()) return;
|
|
m_RealmBriefTween.Play();
|
|
var realmLevel = PlayerDatas.Instance.baseData.realmLevel;
|
var requireLevelUp = realmLevel < model.realmMaxLevel && model.selectRealm > realmLevel;
|
if (requireLevelUp)
|
{
|
m_RealmLevelUpTween.Play();
|
}
|
|
tweenOnStart = false;
|
}
|
|
private void PlayerDataRefreshEvent(PlayerDataType dataType)
|
{
|
if (dataType == PlayerDataType.RealmLevel)
|
{
|
var realmLevel = PlayerDatas.Instance.baseData.realmLevel;
|
if (!model.displayRealms.Contains(realmLevel))
|
{
|
model.displayRealms.Add(realmLevel);
|
if (model.displayRealms.Count == 1)
|
{
|
TryStartAnimation();
|
}
|
}
|
}
|
else if (dataType == PlayerDataType.FightPower)
|
{
|
if (CustomDisplayPower() && PlayerDatas.Instance.baseData.FightPoint > cacheFightPower)
|
{
|
customUpPower += (PlayerDatas.Instance.baseData.FightPoint - cacheFightPower);
|
}
|
cacheFightPower = PlayerDatas.Instance.baseData.FightPoint;
|
}
|
else if (dataType == PlayerDataType.LV)
|
{
|
m_RealmLevelUp.DisplayCondition();
|
if (m_RealmAnimation.isPlayingAnimation || m_RealmAnimation.rotating)
|
{
|
return;
|
}
|
if (model.SatisfyChallengeBoss(model.displayRealmLevel)
|
&& !model.GetBossEffectShow(model.displayRealmLevel))
|
{
|
model.SetBossEffectShow(model.displayRealmLevel);
|
m_RealmAnimation.StartBossEffectShow();
|
}
|
}
|
}
|
|
private void TryStartAnimation()
|
{
|
var stage = model.GetRealmStage(model.displayRealmLevel);
|
var currentStage = model.GetRealmStage(cacheRealmLevel);
|
if (cacheRealmLevel > model.displayRealmLevel || stage > currentStage + 1)
|
{
|
model.displayRealms.Clear();
|
model.selectRealm = PlayerDatas.Instance.baseData.realmLevel + 1;
|
DisplayRealmStages();
|
DisplayRealmPool();
|
DisplayCover();
|
DisplayEffectBoss();
|
}
|
else
|
{
|
if (cacheRealmLevel < model.displayRealmLevel)
|
{
|
List<int> realms = null;
|
if (model.TryGetRealmStages(currentStage, out realms))
|
{
|
var index = realms.IndexOf(cacheRealmLevel);
|
m_RealmAnimation.DisplayLevelUp(realms.IndexOf(cacheRealmLevel));
|
}
|
}
|
}
|
cacheRealmLevel = model.displayRealmLevel;
|
}
|
|
private void OnRotateComplete()
|
{
|
var stage = model.GetRealmStage(model.displayRealmLevel);
|
List<int> realms = null;
|
if (model.TryGetRealmStages(stage, out realms))
|
{
|
for (int i = 0; i < m_RealmStages.Length; i++)
|
{
|
var index = m_RealmStages[i].animIndex;
|
if (index >= REALM_STAGE_COUNT && realms[0] + index <= model.realmMaxLevel)
|
{
|
m_RealmStages[i].Display(realms[0] + index);
|
}
|
}
|
}
|
DisplayUnlockEquip();
|
|
RealmPromoteWin.realmLevel = model.displayRealmLevel;
|
WindowCenter.Instance.Open<RealmPromoteWin>();
|
if (model.displayRealms.Count > 0)
|
{
|
model.displayRealms.RemoveAt(0);
|
}
|
//if (model.displayRealms.Count > 0)
|
//{
|
// TryStartAnimation();
|
//}
|
|
DisplayRealmPool();
|
}
|
|
private void OnLevelUpComplete()
|
{
|
if (model.displayRealmLevel == model.realmMaxLevel)
|
{
|
model.selectRealm = model.displayRealmLevel;
|
DisplayRealmLevelUp();
|
}
|
else
|
{
|
model.selectRealm = model.displayRealmLevel + 1;
|
}
|
|
DisplayCover();
|
|
if (!m_RealmAnimation.rotating)
|
{
|
RealmPromoteWin.realmLevel = model.displayRealmLevel;
|
WindowCenter.Instance.Open<RealmPromoteWin>();
|
if (model.displayRealms.Count > 0)
|
{
|
model.displayRealms.RemoveAt(0);
|
}
|
|
//if (model.displayRealms.Count > 0)
|
//{
|
// TryStartAnimation();
|
//}
|
}
|
|
DisplayRealmPool();
|
|
if (customUpPower > 0)
|
{
|
mainDateModel.CustomPowerUp(customUpPower);
|
}
|
customUpPower = 0;
|
}
|
|
private void WindowAfterCloseEvent(Window window)
|
{
|
if (window is RealmPromoteWin)
|
{
|
var equipLevel = 0;
|
if (RealmPromoteWin.realmLevel >= model.realmEquipDisplayLevel
|
&& model.IsUnlockEquipRealm(RealmPromoteWin.realmLevel, out equipLevel))
|
{
|
RealmNewEquipWin.realmLevel = RealmPromoteWin.realmLevel;
|
WindowCenter.Instance.Open<RealmNewEquipWin>();
|
}
|
else
|
{
|
if (model.displayRealms.Count > 0)
|
{
|
TryStartAnimation();
|
}
|
}
|
}
|
if (window is RealmNewEquipWin)
|
{
|
if (model.displayRealms.Count > 0)
|
{
|
TryStartAnimation();
|
}
|
}
|
}
|
|
public void OnBossAppearComplete()
|
{
|
m_GotoBoss.SetActive(true);
|
|
if (tweenOnStart)
|
{
|
StartTween();
|
}
|
|
if (m_EffectCover.IsPlaying)
|
{
|
m_EffectCover.StopImediatly();
|
}
|
}
|
|
private void OnCoverChange()
|
{
|
var id = model.GetRealmCoverEffect(model.displayRealmLevel + 1);
|
m_EffectCover.StopImediatly();
|
m_EffectCover.effect = id;
|
m_EffectCover.Play();
|
}
|
|
private bool CustomDisplayPower()
|
{
|
return m_RealmAnimation.isPlayingAnimation;
|
}
|
|
private void SelectRealmRefresh()
|
{
|
DisplayRealmBrief();
|
DisplayRealmLevelUp();
|
if (!m_RealmAnimation.rotating)
|
{
|
DisplayUnlockEquip();
|
}
|
}
|
|
private void OnBack()
|
{
|
if (realmState == RealmState.Boss)
|
{
|
realmState = RealmState.LevelUp;
|
return;
|
}
|
CloseClick();
|
}
|
|
private void GotoBoss()
|
{
|
if (realmState == RealmState.LevelUp)
|
{
|
realmState = RealmState.Boss;
|
}
|
}
|
|
private void RealmRestraint()
|
{
|
WindowCenter.Instance.Open<RealmRestraintWin>();
|
}
|
|
public enum RealmState
|
{
|
LevelUp,
|
Boss,
|
}
|
|
public void DisplayXXZL()
|
{
|
var isOver = model.IsRealmXXZLOver();
|
m_RealmContainer.SetActive(isOver);
|
m_XxzlContainer.SetActive(!isOver);
|
|
if (isOver) return;
|
|
int process;
|
for (int i = 0; i < juanImgs.Count; i++)
|
{
|
juanImgs[i].SetColorful(null, model.IsGetAward(i+1));
|
|
var alphaObj = juanImgs[i].GetComponent<UIAlphaTween>();
|
if (i == model.selectXXZL)
|
{
|
alphaObj.Play();
|
}
|
else
|
{
|
alphaObj.Stop();
|
}
|
}
|
|
int missionID = model.selectXXZL + 1;
|
var config = RealmXXZLConfig.Get(missionID);
|
xxzlMission.text = config.Desc;
|
process = 0;
|
bool isMissionFinish = model.IsRealmXXZLMissionFinish(missionID, out process);
|
var needValue = config.NeedValue;
|
if (config.TaskType == 1 || config.TaskType == 5)
|
needValue = 1;
|
ExpSlider.value = Math.Min(1, (float)process/needValue);
|
processTxt.text = process + "/" + needValue;
|
var awards = JsonMapper.ToObject<int[][]>(config.AwardItemList);
|
for (int i = 0; i < items.Count; i++)
|
{
|
if (i < awards.Length)
|
{
|
items[i].SetActive(true);
|
int itemID = awards[i][0];
|
items[i].Init(new ItemCellModel(itemID, false, (ulong)awards[i][1]));
|
items[i].button.AddListener(() =>
|
{
|
ItemTipUtility.Show(itemID);
|
});
|
}
|
else
|
{
|
items[i].SetActive(false);
|
}
|
}
|
|
bool awardState = model.IsGetAward(missionID);
|
activeBtn.SetActive(!awardState);
|
activeBtn.interactable = isMissionFinish;
|
activeBtn.SetColorful(null, isMissionFinish);
|
activeBtn.AddListener(() =>
|
{
|
CA504_tagCMPlayerGetReward pak = new CA504_tagCMPlayerGetReward();
|
pak.RewardType = 62;
|
pak.DataEx = (uint)missionID;
|
GameNetSystem.Instance.SendInfo(pak);
|
|
juanImgs[missionID - 1].SetColorful(null, true);
|
juanImgs[missionID - 1].GetComponent<ScaleTween>().Play();
|
juanEffects[missionID - 1].Play();
|
});
|
activedImg.SetActive(awardState);
|
juanEffects[model.selectXXZL].Play();
|
|
}
|
|
private void Model_xxzlStateRefresh(bool obj)
|
{
|
DisplayXXZL();
|
if (obj)
|
{
|
xxzlOverEffect.Play();
|
OnActived();
|
}
|
}
|
}
|
|
}
|
|
|
|
|
