//--------------------------------------------------------
|
// [Author]: 第二世界
|
// [ Date ]: Thursday, May 03, 2018
|
//--------------------------------------------------------
|
|
using System;
|
using System.Collections;
|
using System.Collections.Generic;
|
using System.Linq;
|
|
using UnityEngine;
|
using UnityEngine.UI;
|
|
namespace Snxxz.UI {
|
[XLua.Hotfix]
|
public class TreasureLevelUpWin : Window
|
{
|
[SerializeField] TreasureAnimation m_TreasureAnimation;
|
[SerializeField] RectTransform m_DisplayContainer;
|
|
[SerializeField] RectTransform m_ContainerUnGet;
|
[SerializeField] RectTransform m_ContainerLockDetail;
|
[SerializeField] PositionTween m_LockDetailPosTween;
|
[SerializeField] ScrollerController m_Controller;
|
[SerializeField] Button m_GetTreasureBtn;
|
[SerializeField] RectTransform m_ContainerLimit;
|
[SerializeField] Text m_TreasureChallengeLimit;
|
[SerializeField] Text m_TreasureStory;
|
|
[SerializeField] RectTransform m_ContainerTip;
|
[SerializeField] Text m_NewStageTip;
|
|
[SerializeField] RectTransform m_ContainerLevelUp;
|
[SerializeField] RectTransform m_ContainerMeridian;
|
[SerializeField] TreasureCyclicScroll m_AchievementScroll;
|
[SerializeField] TreasureProperty m_TreasureProperty;
|
[SerializeField] TreasureMeridianBehaviour[] m_TreasureMeridians;
|
[Header("Progress")]
|
[SerializeField] RectTransform m_ContainerPropgress;
|
[SerializeField] Image m_CurrentStageIcon;
|
[SerializeField] Text m_TreasureLevelProgress;
|
[SerializeField] Text m_TreasureStageDesc;
|
[SerializeField] AchievementAwardEffectResponse m_AwardEffectResponse;
|
[SerializeField] SmoothSlider m_Slider;
|
[SerializeField] Button m_LevelUpBtn;
|
[SerializeField] Text m_LevelUpTxt;
|
[SerializeField] UIEffect m_LevelUpSfx;
|
[SerializeField] RectTransform m_ContainerSkillShow;
|
[SerializeField] Image m_HeroShowSkill;
|
[SerializeField] Image m_HeroShowSkillName;
|
|
[SerializeField] RectTransform m_ContainerPotential;
|
[SerializeField] TreasurePotentialPanel m_TreasurePotential;
|
|
TreasureModel m_Model;
|
TreasureModel model
|
{
|
get
|
{
|
return m_Model ?? (m_Model = ModelCenter.Instance.GetModel<TreasureModel>());
|
}
|
}
|
|
AchievementModel m_AchievementModel;
|
AchievementModel achievementModel
|
{
|
get
|
{
|
return m_AchievementModel ?? (m_AchievementModel = ModelCenter.Instance.GetModel<AchievementModel>());
|
}
|
}
|
|
DungeonModel m_DungeonModel;
|
DungeonModel dungeonModel
|
{
|
get
|
{
|
return m_DungeonModel ?? (m_DungeonModel = ModelCenter.Instance.GetModel<DungeonModel>());
|
}
|
}
|
|
PlayerTaskDatas task { get { return ModelCenter.Instance.GetModel<PlayerTaskDatas>(); } }
|
|
Treasure m_Treasure;
|
|
bool m_OnLevelUpStage = false;
|
bool m_NewBieGuide = false;
|
|
int mainTaskId = 0;
|
|
int cacheTreasureExp = 0;
|
|
float timer = 0;
|
|
public event Action OnLineStepComplete;
|
|
int beforePlayerLv = 0;
|
|
#region Built-in
|
protected override void BindController()
|
{
|
|
}
|
|
protected override void AddListeners()
|
{
|
m_GetTreasureBtn.onClick.AddListener(OnGetTreasure);
|
m_LevelUpBtn.onClick.AddListener(OnLevelUp);
|
m_Controller.OnRefreshCell += OnRefreshCell;
|
}
|
|
protected override void OnPreOpen()
|
{
|
m_DisplayContainer.gameObject.SetActive(true);
|
m_ContainerSkillShow.gameObject.SetActive(false);
|
m_ContainerTip.gameObject.SetActive(false);
|
|
m_OnLevelUpStage = false;
|
m_NewBieGuide = false;
|
model.treasureStepUpShow = false;
|
m_TreasureAnimation.stepComplete = true;
|
beforePlayerLv = PlayerDatas.Instance.baseData.LV;
|
|
model.SetTreasureUnlockShow(TreasureCategory.Human, 0);
|
}
|
|
protected override void OnActived()
|
{
|
base.OnActived();
|
PlayerTaskDatas.CardLevelChange += CardLevelChange;
|
model.treasureLevelProgressUpdateEvent += TreasureLevelProgressUpdateEvent;
|
model.treasureSelectedEvent += TreasureSelectedEvent;
|
model.treasureStageUpEvent += TreasureStageUpEvent;
|
m_TreasureAnimation.OnStepComplete += OnStepComplete;
|
RedpointCenter.Instance.redpointValueChangeEvent += RedpointValueChangeEvent;
|
achievementModel.achievementCompletedEvent += AchievementCompletedEvent;
|
m_TreasureAnimation.OnAchievementSfxComplete += OnAchievementSfxComplete;
|
m_TreasureAnimation.OnAchievementTweenComplete += OnAchievementTweenComplete;
|
WindowCenter.Instance.windowAfterCloseEvent += WindowAfterCloseEvent;
|
m_Slider.slider.onValueChanged.AddListener(OnSliderValueUpdate);
|
NewBieCenter.Instance.guideCompletedEvent += GuideCompletedEvent;
|
FuncOpen.Instance.OnFuncStateChangeEvent += OnFuncStateChangeEvent;
|
model.treasureStateChangeEvent += TreasureStateChangeEvent;
|
TreasureBaseWin.allowSelectTreasure += AllowSelectTreasure;
|
TreasureBaseWin.prepareSelectTreasure += PrepareSelectTreasure;
|
TreasureBaseWin.allowBack += AllowBack;
|
TreasureBaseWin.prepareBack += PrepareBack;
|
mainTaskId = 0;
|
|
Display();
|
}
|
|
protected override void OnAfterOpen()
|
{
|
|
}
|
|
protected override void OnPreClose()
|
{
|
model.treasureLevelProgressUpdateEvent -= TreasureLevelProgressUpdateEvent;
|
PlayerTaskDatas.CardLevelChange -= CardLevelChange;
|
model.treasureSelectedEvent -= TreasureSelectedEvent;
|
model.treasureStageUpEvent -= TreasureStageUpEvent;
|
m_TreasureAnimation.OnStepComplete -= OnStepComplete;
|
RedpointCenter.Instance.redpointValueChangeEvent -= RedpointValueChangeEvent;
|
achievementModel.achievementCompletedEvent -= AchievementCompletedEvent;
|
m_TreasureAnimation.OnAchievementSfxComplete -= OnAchievementSfxComplete;
|
m_TreasureAnimation.OnAchievementTweenComplete -= OnAchievementTweenComplete;
|
WindowCenter.Instance.windowAfterCloseEvent -= WindowAfterCloseEvent;
|
NewBieCenter.Instance.guideCompletedEvent -= GuideCompletedEvent;
|
model.treasureStateChangeEvent -= TreasureStateChangeEvent;
|
FuncOpen.Instance.OnFuncStateChangeEvent -= OnFuncStateChangeEvent;
|
TreasureBaseWin.allowSelectTreasure -= AllowSelectTreasure;
|
TreasureBaseWin.prepareSelectTreasure -= PrepareSelectTreasure;
|
TreasureBaseWin.allowBack -= AllowBack;
|
TreasureBaseWin.prepareBack -= PrepareBack;
|
m_Slider.slider.onValueChanged.RemoveAllListeners();
|
m_TreasurePotential.Dispose();
|
m_AchievementScroll.Dispose();
|
if (FunctionalGuideCenter.Instance.ExistUnderwayGuide(65))
|
{
|
FunctionalGuideCenter.Instance.RemoveGuide(65);
|
}
|
if (m_TreasureAnimation.step == TreasureAnimation.TreasureShowStep.FirstUnLock)
|
{
|
model.treasureEntranceShowId = 0;
|
}
|
m_TreasureAnimation.step = TreasureAnimation.TreasureShowStep.None;
|
model.treasureStepUpShow = false;
|
model.openFromTreasureSoul = false;
|
model.openFromTreasureUnlockShow = false;
|
m_TreasureAnimation.stepComplete = true;
|
model.openFromTaskId = 0;
|
model.SetTreasureUnlockShow(TreasureCategory.Human, 0);
|
}
|
|
protected override void OnAfterClose()
|
{
|
}
|
#endregion
|
|
private void OnRefreshCell(ScrollerDataType type, CellView cell)
|
{
|
TreasureUnlockCell treasureUnlockCell = cell as TreasureUnlockCell;
|
treasureUnlockCell.Display(model.selectedTreasure, cell.index);
|
}
|
|
private void TreasureStateChangeEvent(int _id)
|
{
|
Treasure _treasure;
|
model.TryGetTreasure(_id, out _treasure);
|
if (_id == model.selectedTreasure && _treasure != null
|
&& _treasure.state == TreasureState.Collecting && model.serverInited)
|
{
|
Display();
|
}
|
}
|
|
private void Display(int _state = 0)
|
{
|
m_TreasureAnimation.selectTreasureId = model.selectedTreasure;
|
model.TryGetTreasure(model.selectedTreasure, out m_Treasure);
|
m_TreasureProperty.SetActive(false);
|
m_TreasureProperty.Display(model.selectedTreasure);
|
model.cacheGotAchievements.Clear();
|
var _config = TreasureConfig.Get(m_Treasure.id);
|
m_TreasureProperty.treasureNameTween.SetEndState();
|
beforePlayerLv = PlayerDatas.Instance.baseData.LV;
|
model.treasureStepUpShow = false;
|
SelectHumanTreasure(_state);
|
}
|
|
private void SelectHumanTreasure(int _state = 0)
|
{
|
m_AchievementScroll.Dispose();
|
m_TreasurePotential.Dispose();
|
if (m_Treasure == null || m_Treasure.state != TreasureState.Collected)
|
{
|
m_ContainerUnGet.gameObject.SetActive(true);
|
m_ContainerPotential.gameObject.SetActive(false);
|
m_ContainerLevelUp.gameObject.SetActive(false);
|
UpdateTreasureUnlockDetail();
|
m_TreasureAnimation.step = TreasureAnimation.TreasureShowStep.Lock;
|
m_TreasureProperty.containerName.gameObject.SetActive(true);
|
|
if (model.openFromTreasureUnlockShow)
|
{
|
if(m_Treasure.id == TreasureModel.TREASURE_GUIDE_ID)
|
{
|
NewBieCenter.Instance.StartNewBieGuide(13);
|
}
|
else if (model.guideTreasures.Contains(m_Treasure.id))
|
{
|
FunctionalGuideCenter.Instance.StartGuide(62);
|
}
|
}
|
}
|
else
|
{
|
m_ContainerUnGet.gameObject.SetActive(false);
|
|
if ((m_Treasure.IsHighestStage && FuncOpen.Instance.IsFuncOpen(82)
|
&& model.GetSpAnim(m_Treasure.id)) || _state == 2)
|
{
|
if (_state != 2)
|
{
|
m_ContainerLevelUp.gameObject.SetActive(false);
|
m_ContainerPotential.gameObject.SetActive(true);
|
m_TreasureAnimation.stepComplete = true;
|
}
|
else
|
{
|
m_TreasureProperty.SetActive(true);
|
model.SetSpAnim(m_Treasure.id);
|
}
|
m_TreasurePotential.Display(m_Treasure, _state);
|
}
|
else
|
{
|
m_ContainerLevelUp.gameObject.SetActive(true);
|
m_ContainerPropgress.gameObject.SetActive(!m_Treasure.IsHighestStage);
|
m_ContainerPotential.gameObject.SetActive(false);
|
if (model.treasureEntranceShowId == model.selectedTreasure)
|
{
|
UpdateLevelUp(true);
|
m_TreasureAnimation.step = TreasureAnimation.TreasureShowStep.FirstUnLock;
|
return;
|
}
|
UpdateLevelUp();
|
}
|
if (_state != 2)
|
{
|
if (m_TreasureAnimation.step == TreasureAnimation.TreasureShowStep.UnLock)
|
{
|
RequestMeridianLine();
|
if (model.GetTreasureStageShow(m_Treasure.id) != -1)
|
{
|
model.SetTreasureStageShow(m_Treasure.id, -1);
|
m_TreasureAnimation.OnStageLock(m_Treasure.IndexOfStage(m_Treasure.stage));
|
}
|
m_TreasureProperty.SetActive(m_Treasure.state == TreasureState.Collected);
|
if (_state == 1 && m_Treasure.IsHighestStage
|
&& FuncOpen.Instance.IsFuncOpen(82) && !model.GetSpAnim(m_Treasure.id))
|
{
|
m_TreasureAnimation.step = TreasureAnimation.TreasureShowStep.FirstPotential;
|
Display(2);
|
return;
|
}
|
}
|
m_TreasureAnimation.step = TreasureAnimation.TreasureShowStep.UnLock;
|
}
|
}
|
}
|
|
private void OnFuncStateChangeEvent(int _id)
|
{
|
if (_id == 82 && FuncOpen.Instance.IsFuncOpen(_id) && model.serverInited)
|
{
|
if (m_TreasureAnimation.stepComplete && m_Treasure.IsHighestStage
|
&& !model.GetSpAnim(m_Treasure.id))
|
{
|
m_TreasureAnimation.step = TreasureAnimation.TreasureShowStep.FirstPotential;
|
Display(2);
|
}
|
}
|
}
|
|
private void UpdateTreasureUnlockDetail()
|
{
|
var _cfg = TreasureConfig.Get(model.selectedTreasure);
|
m_TreasureStory.text = _cfg.Story;
|
|
m_Controller.Refresh();
|
for (int i = 0; i < m_Treasure.treasureStages.Count; i++)
|
{
|
var stage = m_Treasure.treasureStages[i];
|
switch (stage.unlockType)
|
{
|
case TreasureStageUnlock.Skill:
|
case TreasureStageUnlock.Func:
|
case TreasureStageUnlock.Treasure:
|
case TreasureStageUnlock.TreasureSoul:
|
m_Controller.AddCell(ScrollerDataType.Header, stage.stage);
|
break;
|
}
|
}
|
m_Controller.Restart();
|
|
Achievement achievement = null;
|
int _achievementId = 0;
|
bool _unlockAchievement = false;
|
if (model.TryGetTreasureUnlockAchievement(m_Treasure.id, out _achievementId))
|
{
|
if (achievementModel.TryGetAchievement(_achievementId, out achievement))
|
{
|
_unlockAchievement = true;
|
}
|
}
|
m_GetTreasureBtn.gameObject.SetActive(!_unlockAchievement || achievement.completed);
|
m_ContainerLimit.gameObject.SetActive(_unlockAchievement && !achievement.completed);
|
|
if (model.IsVersionUnOpenTreasure(m_Treasure.id))
|
{
|
m_TreasureChallengeLimit.text = Language.Get("TreasureNoOpen");
|
return;
|
}
|
|
if (_unlockAchievement && !achievement.completed)
|
{
|
var _achievementConfig = SuccessConfig.Get(_achievementId);
|
var _missionId = _achievementConfig.Condition[0];
|
var _taskConfig = PyTaskConfig.Get(_missionId);
|
if (_taskConfig == null)
|
{
|
return;
|
}
|
switch (_achievementConfig.Type)
|
{
|
case 1:
|
m_TreasureChallengeLimit.text = Language.Get("TreasureChallengeLv", _achievementConfig.Condition[0]);
|
break;
|
case 3:
|
m_TreasureChallengeLimit.text = Language.Get("TreasureGetRequire", _taskConfig.lv);
|
break;
|
}
|
}
|
}
|
|
private void TreasureSelectedEvent(int _id)
|
{
|
Display(1);
|
}
|
|
private bool AllowSelectTreasure(int treasureId)
|
{
|
if (model.TreasureStageUpLimit(model.selectedTreasure))
|
{
|
return false;
|
}
|
return m_TreasureAnimation.stepComplete && !model.treasureStepUpShow && !m_NewBieGuide;
|
}
|
|
private void PrepareSelectTreasure(int treasureId)
|
{
|
model.openFromTaskId = 0;
|
if (FunctionalGuideCenter.Instance.ExistUnderwayGuide(65))
|
{
|
FunctionalGuideCenter.Instance.RemoveGuide(65);
|
}
|
}
|
|
private int AllowBack()
|
{
|
if (!m_TreasureAnimation.stepComplete || model.treasureStepUpShow || m_NewBieGuide)
|
{
|
return 1;
|
}
|
if (model.TreasureStageUpLimit(model.selectedTreasure))
|
{
|
return 1;
|
}
|
if (NewBieCenter.Instance.inGuiding
|
&& NewBieCenter.Instance.currentGuide == 13)
|
{
|
return 1;
|
}
|
return 0;
|
}
|
|
private void PrepareBack()
|
{
|
model.SetTreasureUnlockShow(TreasureCategory.Human, 0);
|
}
|
|
private void OnGetTreasure()
|
{
|
var _cfg = TreasureConfig.Get(model.selectedTreasure);
|
if (_cfg != null)
|
{
|
if (PlayerDatas.Instance.baseData.LV >= _cfg.ChallengeLevel)
|
{
|
model.collectingHuman = model.selectedTreasure;
|
dungeonModel.SingleChallenge(TreasureModel.TREASURE_DATAMAPID, _cfg.LineId);
|
}
|
}
|
}
|
|
private void UpdateLevelUp(bool _firstUnlock = false)
|
{
|
DisplayAchievements(true, !_firstUnlock);
|
UpdateTreasureMeridian();
|
UpdateTreasureProgress(true);
|
UpdateLevelUpSfx(m_TreasureAnimation.step != TreasureAnimation.TreasureShowStep.UnLock);
|
}
|
|
private void OnAchievementTweenComplete()
|
{
|
DisplayAchievements(true, true);
|
if (m_Treasure.id == TreasureModel.TREASURE_GUIDE_ID
|
&& !NewBieCenter.Instance.completeGuidesBuf.Contains(15) && NewBieCenter.Instance.completeGuidesBuf.Contains(14)
|
&& IsComplete15GuidAchivement())
|
{
|
m_NewBieGuide = true;
|
m_AchievementScroll.ResetScrollItemName();
|
NewBieCenter.Instance.StartNewBieGuide(15);
|
}
|
else
|
{
|
CheckGuide65();
|
}
|
}
|
|
private bool IsComplete15GuidAchivement()
|
{
|
Achievement achievement;
|
if (achievementModel.TryGetAchievement(11, out achievement))
|
{
|
if (!Achievement.IsReach(11, achievement.progress) || achievement.completed)
|
{
|
return false;
|
}
|
}
|
else
|
{
|
return false;
|
}
|
if (achievementModel.TryGetAchievement(12, out achievement))
|
{
|
if (!Achievement.IsReach(12, achievement.progress) || achievement.completed)
|
{
|
return false;
|
}
|
}
|
else
|
{
|
return false;
|
}
|
return true;
|
}
|
|
private void CheckGuide65()
|
{
|
if (model.openFromTreasureCollect)
|
{
|
model.openFromTreasureCollect = false;
|
foreach (var value in task.MainTaskDic.Values)
|
{
|
if (task.GetTaskStatus(value.ID) == PlayerTaskDatas.TaskStatus.TreasureCardLevel)
|
{
|
model.openFromTaskId = value.ID;
|
break;
|
}
|
}
|
}
|
if (model.openFromTaskId != 0
|
&& model.castSoulGuideTaskIds.Contains(model.openFromTaskId)
|
&& task.GetTaskStatus(model.openFromTaskId) == PlayerTaskDatas.TaskStatus.TreasureCardLevel
|
&& m_Treasure.achievementRedpoint.state == RedPointState.None
|
&& m_Treasure is HumanTreasure
|
&& (m_Treasure as HumanTreasure).castSoulRedpoint.state == RedPointState.None)
|
{
|
m_AchievementScroll.ResetScrollItemName();
|
if (NewBieCenter.Instance.completeGuidesBuf.Contains(65))
|
{
|
NewBieCenter.Instance.ResetGuide(65);
|
}
|
FunctionalGuideCenter.Instance.StartGuide(65);
|
}
|
}
|
|
private void DisplayAchievements(bool _stepByStep, bool _show = true)
|
{
|
if (m_Treasure.achievementGroups != null)
|
{
|
m_AchievementScroll.HideAll();
|
m_AchievementScroll.gameObject.SetActive(true);
|
if (_show)
|
{
|
var achievementGroups = new List<AchievementGroup>(m_Treasure.achievementGroups.Values);
|
m_AchievementScroll.ShowTreasures(achievementGroups, _stepByStep);
|
}
|
}
|
else
|
{
|
m_AchievementScroll.gameObject.SetActive(false);
|
}
|
}
|
|
private void AchievementCompletedEvent(int _id)
|
{
|
var config = TreasureConfig.Get(model.selectedTreasure);
|
if (config == null || (TreasureCategory)config.Category != TreasureCategory.Human
|
|| m_Treasure.state != TreasureState.Collected || m_Treasure.IsHighestStage)
|
{
|
return;
|
}
|
TreasureAchievement treasureAchievement;
|
m_AchievementScroll.TryGetTreasureAchievement(_id, out treasureAchievement);
|
if (treasureAchievement != null)
|
{
|
m_TreasureAnimation.ShowAchievementCompleteSfx(treasureAchievement.rectTransform, _id);
|
}
|
}
|
|
private void OnAchievementSfxComplete(int _id)
|
{
|
if (model.cacheGotAchievements.Contains(_id))
|
{
|
model.cacheGotAchievements.Remove(_id);
|
UpdateTreasureProgress(false, _id);
|
CheckGuide65();
|
}
|
}
|
|
private void UpdateTreasureMeridian()
|
{
|
TreasureMeridianConfig _config = ScriptableObjectLoader.LoadSoTreasureMeridian(model.selectedTreasure);
|
if (m_Treasure != null)
|
{
|
var _index = 0;
|
for (int i = 0; i < m_Treasure.treasureStages.Count; i++)
|
{
|
m_TreasureMeridians[_index].StopSfx();
|
if (i == 0 && m_Treasure.treasureStages[0].unlockType == TreasureStageUnlock.None)
|
{
|
continue;
|
}
|
if (_index < m_TreasureMeridians.Length)
|
{
|
m_TreasureMeridians[_index].gameObject.SetActive(true);
|
m_TreasureMeridians[_index].Display(i, _index, this);
|
if (_config != null)
|
{
|
m_TreasureMeridians[_index].scaleTween.to = Vector3.one;
|
m_TreasureMeridians[_index].scaleTween.SetEndState();
|
m_TreasureMeridians[_index].transform.localPosition = _config[_index].position;
|
//m_TreasureMeridians[_index].icon.transform.localScale = _config[_index].scale * Vector3.one;
|
m_TreasureMeridians[_index].SetScale(_config[_index].scale);
|
m_TreasureMeridians[_index].scaleTween.delay = _config[_index].scaleTweenDelay;
|
m_TreasureMeridians[_index].scaleTween.from = _config[_index].scaleTweenTo * Vector3.one;
|
}
|
_index++;
|
}
|
}
|
for (int i = _index; i < m_TreasureMeridians.Length; i++)
|
{
|
m_TreasureMeridians[i].gameObject.SetActive(false);
|
m_TreasureMeridians[_index].StopSfx();
|
}
|
}
|
}
|
|
private void OnStepComplete(TreasureAnimation.TreasureShowStep _step)
|
{
|
switch (_step)
|
{
|
case TreasureAnimation.TreasureShowStep.UnLock:
|
RequestMeridianLine();
|
UpdateLevelUpSfx(false);
|
m_TreasureProperty.SetActive(m_Treasure.state == TreasureState.Collected);
|
if (model.openFromTreasureSoul)
|
{
|
var config = ScriptableObjectLoader.LoadSoTreasureMeridian(model.selectedTreasure);
|
m_TreasureMeridians[config.stagePointNum - 1].StartSoulTween();
|
}
|
if (model.GetTreasureStageShow(m_Treasure.id) != -1)
|
{
|
model.SetTreasureStageShow(m_Treasure.id, -1);
|
m_TreasureAnimation.OnStageLock(m_Treasure.IndexOfStage(m_Treasure.stage));
|
}
|
if (!m_Treasure.IsHighestStage)
|
{
|
CheckGuide65();
|
}
|
else if (FuncOpen.Instance.IsFuncOpen(82) && !model.GetSpAnim(m_Treasure.id))
|
{
|
m_TreasureAnimation.step = TreasureAnimation.TreasureShowStep.FirstPotential;
|
Display(2);
|
}
|
break;
|
case TreasureAnimation.TreasureShowStep.FirstUnLock:
|
UpdateLevelUpSfx(false);
|
m_TreasureProperty.SetActive(m_Treasure.state == TreasureState.Collected);
|
var _config = ScriptableObjectLoader.LoadSoTreasureMeridian(model.selectedTreasure);
|
for (int i = 0; i < _config.stagePointNum; i++)
|
{
|
m_TreasureMeridians[i].RequestStateSfx();
|
}
|
if (m_Treasure.treasureStages[0].unlockType != TreasureStageUnlock.None)
|
{
|
model.SetTreasureStageShow(m_Treasure.id, m_Treasure.stage);
|
}
|
break;
|
case TreasureAnimation.TreasureShowStep.FirstPotential:
|
break;
|
}
|
}
|
|
private void WindowAfterCloseEvent(Window _win)
|
{
|
if (_win is TreasureNewStageWin || _win is TreasureSoulActiveWin)
|
{
|
if (m_Treasure.IsHighestStage && FuncOpen.Instance.IsFuncOpen(82))
|
{
|
m_TreasureAnimation.step = TreasureAnimation.TreasureShowStep.FirstPotential;
|
Display(2);
|
}
|
else
|
{
|
if (mainTaskId != 0)
|
{
|
WindowCenter.Instance.Close<TreasureBaseWin>();
|
WindowCenter.Instance.Open<MainInterfaceWin>();
|
task.AutomaticTripToTask(mainTaskId);
|
}
|
else
|
{
|
var stage = m_Treasure.treasureStages[m_Treasure.stage];
|
model.SetTreasureStageShow(m_Treasure.id, -1);
|
m_TreasureAnimation.OnStageLock(m_Treasure.IndexOfStage(stage.stage));
|
}
|
}
|
}
|
}
|
|
private void RequestMeridianLine()
|
{
|
if (m_Treasure.IsHighestStage && FuncOpen.Instance.IsFuncOpen(82))
|
{
|
return;
|
}
|
var _config = ScriptableObjectLoader.LoadSoTreasureMeridian(model.selectedTreasure);
|
for (int i = 0; i < _config.stagePointNum; i++)
|
{
|
m_TreasureMeridians[i].RequestSfx();
|
}
|
}
|
|
private void TreasureLevelProgressUpdateEvent(int _treasureId)
|
{
|
if (_treasureId != model.selectedTreasure)
|
{
|
return;
|
}
|
if (model.cacheGotAchievements.Count == 0 || m_OnLevelUpStage)
|
{
|
UpdateTreasureProgress();
|
}
|
}
|
|
private void TreasureStageUpEvent(int _treasureId)
|
{
|
if (_treasureId != model.selectedTreasure)
|
{
|
return;
|
}
|
m_TreasureProperty.Display(_treasureId, true);
|
if (m_OnLevelUpStage)
|
{
|
var stage = m_Treasure.treasureStages[m_Treasure.stage];
|
var _index = stage.stage;
|
if (m_Treasure.treasureStages[0].unlockType == TreasureStageUnlock.None)
|
{
|
_index -= 1;
|
}
|
m_TreasureAnimation.OnStageUpLineComplete -= OnStageUpLineComplete;
|
m_TreasureAnimation.OnStageUpLineComplete += OnStageUpLineComplete;
|
timer = 0f;
|
model.treasureStepUpShow = true;
|
m_TreasureAnimation.OnStageUp(_index);
|
model.cacheGotAchievements.Clear();
|
}
|
}
|
|
private void OnStageUpLineComplete()
|
{
|
if (OnLineStepComplete != null)
|
{
|
OnLineStepComplete();
|
}
|
|
m_OnLevelUpStage = false;
|
|
m_TreasureAnimation.OnStageUpLineComplete -= OnStageUpLineComplete;
|
var stage = m_Treasure.treasureStages[m_Treasure.stage];
|
switch (stage.unlockType)
|
{
|
case TreasureStageUnlock.Func:
|
m_ContainerTip.gameObject.SetActive(true);
|
var _funcConfig = FuncOpenLVConfig.Get(stage.func);
|
m_NewStageTip.text = StringUtility.Contact(Language.Get("TreasureGetNewFunc"),
|
UIHelper.AppendStringColor(TextColType.Green, _funcConfig.Remark));
|
break;
|
}
|
StartCoroutine(Co_StepUpComplete());
|
}
|
|
IEnumerator Co_StepUpComplete()
|
{
|
var _selectTreasure = model.selectedTreasure;
|
yield return WaitingForSecondConst.WaitMS1000;
|
m_ContainerTip.gameObject.SetActive(false);
|
if (_selectTreasure != model.selectedTreasure)
|
{
|
yield break;
|
}
|
model.treasureStepUpShow = false;
|
var stage = m_Treasure.treasureStages[m_Treasure.stage];
|
var _index = m_Treasure.IndexOfStage(stage.stage);
|
model.SetTreasureStageShow(m_Treasure.id, stage.stage);
|
|
if (WindowCenter.Instance.IsOpen<TreasureStageTipWin>())
|
{
|
WindowCenter.Instance.Close<TreasureStageTipWin>();
|
}
|
|
switch (stage.unlockType)
|
{
|
case TreasureStageUnlock.Skill:
|
var _config = SkillConfig.Get(m_Treasure.unlockSkill);
|
m_ContainerSkillShow.gameObject.SetActive(true);
|
m_HeroShowSkill.SetSprite(_config.IconName);
|
m_HeroShowSkillName.SetSprite(StringUtility.Contact("SkillName_", _config.SkillID));
|
m_HeroShowSkillName.SetNativeSize();
|
m_TreasureAnimation.OnHeroSkillShow(_index);
|
PlaySkillShow();
|
break;
|
case TreasureStageUnlock.Func:
|
StartScreenShot();
|
break;
|
case TreasureStageUnlock.Item:
|
case TreasureStageUnlock.Property:
|
WindowCenter.Instance.Open<TreasureNewStageWin>(true);
|
break;
|
case TreasureStageUnlock.Treasure:
|
WindowJumpMgr.Instance.ClearJumpData();
|
WindowCenter.Instance.Close<TreasureBaseWin>();
|
WindowCenter.Instance.Open<MainInterfaceWin>();
|
break;
|
case TreasureStageUnlock.TreasureSoul:
|
TreasureSoulActiveWin.treasureSoulId = stage.treasureSoul;
|
WindowCenter.Instance.Open<TreasureSoulActiveWin>(true);
|
break;
|
}
|
}
|
|
private void CardLevelChange(int _id)
|
{
|
if (task.MainTaskDic.ContainsKey(_id))
|
{
|
mainTaskId = _id;
|
}
|
}
|
|
private void StartScreenShot()
|
{
|
CameraUtility.ScreenShotCut((Action<Texture2D>)((Texture2D _tex) =>
|
{
|
TreasureStageUpTriggerWin.screenShotCut = _tex;
|
WindowJumpMgr.Instance.ClearJumpData();
|
WindowCenter.Instance.Close<TreasureBaseWin>();
|
WindowCenter.Instance.Open<TreasureStageUpTriggerWin>(true);
|
WindowCenter.Instance.Open<MainInterfaceWin>();
|
if (WindowCenter.Instance.IsOpen<DialogueDuidanceWin>())
|
{
|
WindowCenter.Instance.Close<DialogueDuidanceWin>();
|
}
|
if (WindowCenter.Instance.IsOpen<TaskBoxBGMWin>())
|
{
|
WindowCenter.Instance.Close<TaskBoxBGMWin>();
|
}
|
m_ContainerSkillShow.gameObject.SetActive(false);
|
}));
|
}
|
|
private void PlaySkillShow()
|
{
|
var baseWin = WindowCenter.Instance.Get<TreasureBaseWin>();
|
if (baseWin != null)
|
{
|
baseWin.DisplayContainer(false);
|
}
|
m_DisplayContainer.gameObject.SetActive(false);
|
UI3DTreasureSelectStage.Instance.CloseRenderCamera();
|
UI3DHeroSkillShow.Instance.ShowTreasureSkill(m_Treasure.id, () =>
|
{
|
m_DisplayContainer.gameObject.SetActive(true);
|
if (baseWin != null)
|
{
|
baseWin.DisplayContainer(true);
|
}
|
UI3DTreasureSelectStage.Instance.OpenRenderCamera();
|
StartScreenShot();
|
});
|
}
|
|
private void OnLevelUp()
|
{
|
if (!m_TreasureAnimation.stepComplete)
|
{
|
return;
|
}
|
if (m_Treasure == null)
|
{
|
return;
|
}
|
var _nextStage = m_Treasure.treasureStages.Find((x) =>
|
{
|
return x.stage == m_Treasure.stage + 1;
|
});
|
if (_nextStage != null)
|
{
|
if (m_Treasure.exp >= _nextStage.exp)
|
{
|
m_OnLevelUpStage = true;
|
CA515_tagCMMagicWeaponUp _pak = new CA515_tagCMMagicWeaponUp();
|
_pak.MWID = (uint)model.selectedTreasure;
|
GameNetSystem.Instance.SendInfo(_pak);
|
}
|
}
|
}
|
|
private void UpdateLevelUpSfx(bool _animation)
|
{
|
m_LevelUpSfx.StopImediatly();
|
HumanTreasure humanTreasure = m_Treasure as HumanTreasure;
|
m_LevelUpBtn.SetInteractable(m_LevelUpTxt, false);
|
if (humanTreasure == null)
|
{
|
return;
|
}
|
if (humanTreasure.castSoulRedpoint.state == RedPointState.Simple)
|
{
|
m_LevelUpBtn.SetInteractable(m_LevelUpTxt, true);
|
if (!_animation)
|
{
|
m_LevelUpSfx.Play();
|
if (m_Treasure.id == TreasureModel.TREASURE_GUIDE_ID && m_Treasure.stage == 0
|
&& !NewBieCenter.Instance.completeGuidesBuf.Contains(16)
|
&& NewBieCenter.Instance.completeGuidesBuf.Contains(15)
|
&& humanTreasure.castSoulRedpoint.state == RedPointState.Simple)
|
{
|
NewBieCenter.Instance.StartNewBieGuide(16);
|
}
|
}
|
}
|
}
|
|
private void GuideCompletedEvent(int _id)
|
{
|
if (_id == 15)
|
{
|
m_NewBieGuide = false;
|
}
|
}
|
|
private void UpdateTreasureProgress(bool _force = false, int _id = 0)
|
{
|
if (_id == 0)
|
{
|
cacheTreasureExp = m_Treasure.exp;
|
model.cacheGotAchievements.Clear();
|
}
|
else
|
{
|
var _successConfig = SuccessConfig.Get(_id);
|
var _exp = 0;
|
int.TryParse(_successConfig.MagicWeaponExp, out _exp);
|
cacheTreasureExp += _exp;
|
}
|
var _nextStage = m_Treasure.treasureStages.Find((x) =>
|
{
|
return x.stage == m_Treasure.stage + 1;
|
});
|
if (_nextStage != null)
|
{
|
m_Slider.delay = _force ? 0 : 0.2f;
|
float _value= (float)cacheTreasureExp / _nextStage.exp;
|
if (_value < m_Slider.value)
|
{
|
m_Slider.delay = 0;
|
}
|
m_Slider.value = _value;
|
m_TreasureLevelProgress.text = StringUtility.Contact(cacheTreasureExp, "/",
|
_nextStage.exp);
|
switch (_nextStage.unlockType)
|
{
|
case TreasureStageUnlock.Property:
|
foreach (var _key in _nextStage.propertyDict.Keys)
|
{
|
var _propertyCfg = PlayerPropertyConfig.Get(_key);
|
m_TreasureStageDesc.text = StringUtility.Contact(_propertyCfg.Name, " +",
|
UIHelper.ReplaceLargeNum(_nextStage.propertyDict[_key]));
|
if (GeneralDefine.propertyIconDict.ContainsKey(_key))
|
{
|
m_CurrentStageIcon.SetSprite(GeneralDefine.propertyIconDict[_key]);
|
}
|
break;
|
}
|
break;
|
case TreasureStageUnlock.Skill:
|
var _skillId = _nextStage.GetSkill(PlayerDatas.Instance.baseData.Job);
|
var _skillCfg = SkillConfig.Get(_skillId);
|
m_TreasureStageDesc.text = Language.Get("TreasureLevelUpFunction", _skillCfg.SkillName);
|
m_CurrentStageIcon.SetSprite(_skillCfg.IconName);
|
break;
|
case TreasureStageUnlock.Func:
|
var _funcCfg = FuncOpenLVConfig.Get(_nextStage.func);
|
m_TreasureStageDesc.text = Language.Get("TreasureLevelUpSkill", _funcCfg.Remark);
|
m_CurrentStageIcon.SetSprite(_funcCfg.Icon);
|
break;
|
case TreasureStageUnlock.Item:
|
var _itemConfig = ItemConfig.Get(_nextStage.item.id);
|
m_CurrentStageIcon.SetSprite(_itemConfig.IconKey);
|
m_TreasureStageDesc.text = Language.Get("TreasureLevelUpItem", _itemConfig.ItemName);
|
break;
|
case TreasureStageUnlock.Treasure:
|
var _treasureConfig = TreasureConfig.Get(_nextStage.treasure);
|
m_CurrentStageIcon.SetSprite(_treasureConfig.Icon);
|
m_TreasureStageDesc.text = Language.Get("TreasureLevelUpTreasure", _treasureConfig.Name);
|
break;
|
case TreasureStageUnlock.TreasureSoul:
|
var _treasureSoulConfig = TreasurePrivilegeConfig.Get(_nextStage.treasureSoul);
|
m_CurrentStageIcon.SetSprite(_treasureSoulConfig.Icon);
|
m_TreasureStageDesc.text = Language.Get("TreasureLevelUpTreasureSoul", _treasureSoulConfig.Name);
|
break;
|
}
|
}
|
else
|
{
|
m_Slider.delay = 0;
|
m_Slider.value = 1;
|
m_TreasureLevelProgress.text = StringUtility.Contact(m_Treasure.exp, "/", m_Treasure.exp);
|
m_TreasureStageDesc.text = string.Empty;
|
}
|
var effectType = cacheTreasureExp == 0 ? 0 : m_Slider.value < 1 ? 1 : 2;
|
m_AwardEffectResponse.ActiveEffect(effectType);
|
if (m_Slider.value < 1)
|
{
|
m_AwardEffectResponse.FullEffectState(false);
|
}
|
}
|
|
private void OnSliderValueUpdate(float _progress)
|
{
|
m_AwardEffectResponse.FullEffectState(_progress >= 0.99f);
|
if (m_LevelUpBtn.interactable)
|
{
|
return;
|
}
|
if (_progress >= 0.99f)
|
{
|
UpdateLevelUpSfx(false);
|
}
|
}
|
|
private void RedpointValueChangeEvent(int _id)
|
{
|
var _human = m_Treasure as HumanTreasure;
|
if (_human != null && _human.castSoulRedpoint.id == _id)
|
{
|
if (_human.castSoulRedpoint.state == RedPointState.None || m_Slider.slider.value > 0.98f)
|
{
|
UpdateLevelUpSfx(false);
|
}
|
}
|
}
|
|
protected override void LateUpdate()
|
{
|
base.LateUpdate();
|
if (model.treasureStepUpShow)
|
{
|
timer += Time.deltaTime;
|
if (timer > 8f)
|
{
|
model.treasureStepUpShow = false;
|
}
|
}
|
}
|
|
#if UNITY_EDITOR
|
[SerializeField, Header("测试技能Show技能id")] int m_PreviewHeroSkillId;
|
[ContextMenu("Preview")]
|
public void PreviewHreoSkill()
|
{
|
m_TreasureAnimation.OnHeroSkillShow(m_Treasure.IndexOfStage(m_Treasure.stage));
|
PlaySkillShow();
|
}
|
|
[ContextMenu("测试动画")]
|
public void PreviewAnimation()
|
{
|
m_TreasureAnimation.step = TreasureAnimation.TreasureShowStep.FirstPotential;
|
Display(2);
|
}
|
|
[ContextMenu("测试功能开启")]
|
public void PreviewFuncOpen()
|
{
|
StartScreenShot();
|
}
|
|
[ContextMenu("测试成就特效")]
|
public void PreviewSfx()
|
{
|
AchievementCompletedEvent(m_Treasure.achievementGroups.Values.First().GetDoingAchievement());
|
}
|
#endif
|
}
|
|
}
|
|
|
|
|
