//--------------------------------------------------------
|
// [Author]: 第二世界
|
// [ Date ]: Wednesday, February 20, 2019
|
//--------------------------------------------------------
|
|
using System;
|
using System.Collections;
|
using System.Collections.Generic;
|
using UnityEngine;
|
using UnityEngine.UI;
|
|
namespace Snxxz.UI
|
{
|
[XLua.Hotfix]
|
public class TreasureSkillWin : Window
|
{
|
[SerializeField] ScrollerController m_Controller;
|
|
[SerializeField] SkillWidget m_SkillNow;
|
|
[SerializeField] Button m_SkillExpertBtn;
|
[SerializeField] SkillExpertWidget m_SkillExpert;
|
[SerializeField] RedpointBehaviour m_SelectRedpoint;
|
[SerializeField] SkillExpertBehaviour[] m_SkillExpertBehaviours;
|
|
[SerializeField] FunctionUnlockFlyObjectTarget m_FlyTarget;
|
[SerializeField] Image m_DragSkillIcon;
|
|
[SerializeField] float m_DisappearTime = 1f;
|
|
FunctionUnlockFlyObject flyObject;
|
|
public static int autoSelectSkill = 0;
|
|
int functionGuideId = 0;
|
|
float functionGuideTime = 0f;
|
|
List<int> displaySkills = new List<int>();
|
|
TreasureSkillModel model
|
{
|
get { return ModelCenter.Instance.GetModel<TreasureSkillModel>(); }
|
}
|
|
PackModel packModel
|
{
|
get { return ModelCenter.Instance.GetModel<PackModel>(); }
|
}
|
|
SkillModel skillModel { get { return ModelCenter.Instance.GetModel<SkillModel>(); } }
|
|
ReikiRootModel reikiRootModel { get { return ModelCenter.Instance.GetModel<ReikiRootModel>(); } }
|
TreasureModel treasureModel { get { return ModelCenter.Instance.GetModel<TreasureModel>(); } }
|
|
#region Built-in
|
protected override void BindController()
|
{
|
}
|
|
protected override void AddListeners()
|
{
|
m_Controller.OnRefreshCell += OnRefreshCell;
|
m_SkillExpertBtn.AddListener(OpenExpert);
|
}
|
|
protected override void OnPreOpen()
|
{
|
SetDefaultSelect();
|
|
model.selectActivePriority = false;
|
|
functionGuideId = 0;
|
|
m_DragSkillIcon.gameObject.SetActive(false);
|
|
if (flyObject != null)
|
{
|
GameObject.Destroy(flyObject.gameObject);
|
flyObject = null;
|
}
|
|
Display();
|
|
model.treasureSkillRefresh += TreasureSkillRefresh;
|
model.selectRefresh += SelectRefresh;
|
model.skillLevelUpRefresh += SkillLevelUpRefresh;
|
packModel.refreshItemCountEvent += RefreshItemCountEvent;
|
model.expertSkillRefresh += ExpertSkillRefresh;
|
WindowCenter.Instance.windowAfterCloseEvent += WindowAfterCloseEvent;
|
}
|
|
protected override void OnActived()
|
{
|
base.OnActived();
|
|
var index = displaySkills.IndexOf(model.selectSkill);
|
if (index != -1)
|
{
|
var offset = 0f;
|
m_Controller.JumpIndex(index, ref offset);
|
var rect = m_Controller.mScrollRect.transform as RectTransform;
|
m_Controller.JumpIndex(offset - rect.rect.height / 2 + 50, 0, EnhancedUI.EnhancedScroller.EnhancedScroller.TweenType.immediate);
|
}
|
}
|
|
protected override void OnAfterOpen()
|
{
|
TreasureSkill treasureSkill;
|
if (model.TryGetSkill(model.selectSkill, out treasureSkill))
|
{
|
if (treasureSkill.expertSelectRedpoint.state == RedPointState.Simple)
|
{
|
PlaySelectGuide(true);
|
}
|
}
|
}
|
|
protected override void OnPreClose()
|
{
|
model.treasureSkillRefresh -= TreasureSkillRefresh;
|
model.selectRefresh -= SelectRefresh;
|
model.skillLevelUpRefresh -= SkillLevelUpRefresh;
|
packModel.refreshItemCountEvent -= RefreshItemCountEvent;
|
model.expertSkillRefresh -= ExpertSkillRefresh;
|
WindowCenter.Instance.windowAfterCloseEvent -= WindowAfterCloseEvent;
|
|
if (flyObject != null)
|
{
|
GameObject.Destroy(flyObject.gameObject);
|
flyObject = null;
|
}
|
|
if (autoSelectSkill != 0)
|
{
|
var pak = new CA516_tagCMSelectSkillElement();
|
pak.SkillTypeID = (uint)autoSelectSkill;
|
pak.DoType = 1;
|
GameNetSystem.Instance.SendInfo(pak);
|
}
|
|
if(NewBieCenter.Instance.inGuiding&& NewBieCenter.Instance.currentGuide == 62)
|
{
|
NewBieCenter.Instance.FinishNewBieGuide(62);
|
}
|
}
|
|
protected override void OnAfterClose()
|
{
|
}
|
#endregion
|
|
void SetDefaultSelect()
|
{
|
|
displaySkills.Clear();
|
|
var _skill = 0;
|
List<int> list;
|
if (model.TryGetSkills(out list))
|
{
|
displaySkills.AddRange(list);
|
|
var index = displaySkills.FindIndex((x) =>
|
{
|
var treasureId = treasureModel.GetTreasureBySkillId(x);
|
var treasureConfig = TreasureConfig.Get(treasureId);
|
return treasureConfig.Category == (int)TreasureCategory.Fairy;
|
});
|
|
if (index != -1)
|
{
|
var skillId = displaySkills[index];
|
TreasureSkill treasureSkill;
|
var isActive = model.TryGetSkill(skillId, out treasureSkill)
|
&& treasureSkill.level > 0;
|
displaySkills.RemoveAt(index);
|
if (isActive)
|
{
|
displaySkills.Insert(0, skillId);
|
}
|
else
|
{
|
displaySkills.Add(skillId);
|
}
|
}
|
|
foreach (var skillId in displaySkills)
|
{
|
TreasureSkill skill;
|
if (model.TryGetSkill(skillId, out skill))
|
{
|
if (_skill == 0 && skill.level > 0)
|
{
|
_skill = skillId;
|
}
|
if (skill.redpoint.state == RedPointState.Simple)
|
{
|
_skill = skillId;
|
}
|
if (model.selectActivePriority && skill.expertRedpoint.state == RedPointState.Simple)
|
{
|
_skill = skillId;
|
break;
|
}
|
}
|
}
|
if (_skill == 0)
|
{
|
_skill = list[0];
|
}
|
}
|
model.selectSkill = _skill;
|
}
|
|
private void Display()
|
{
|
DisplaySkills();
|
DisplaySkillDetial();
|
DisplayExpertSkill();
|
|
TryStartGuide();
|
}
|
|
private void DisplaySkills()
|
{
|
m_Controller.Refresh();
|
for (int i = 0; i < displaySkills.Count; i++)
|
{
|
m_Controller.AddCell(ScrollerDataType.Header, displaySkills[i]);
|
}
|
m_Controller.Restart();
|
}
|
|
void DisplaySkillDetial()
|
{
|
TreasureSkill skill;
|
if (model.TryGetSkill(model.selectSkill, out skill))
|
{
|
m_SelectRedpoint.redpointId = skill.expertSelectRedpoint.id;
|
|
var config = skill.GetSkillConfig(skill.level);
|
if (config == null)
|
{
|
return;
|
}
|
|
m_SkillNow.Display(skill.skillId, skill.level);
|
}
|
}
|
|
void DisplayExpertSkill()
|
{
|
var skillId = 0;
|
var level = 0;
|
if (model.TryGetExpertSkill(model.selectSkill, out skillId))
|
{
|
TreasurePotential potential;
|
if (model.TryGetPotential(skillId, out potential))
|
{
|
level = potential.level;
|
}
|
}
|
m_SkillExpert.Display(skillId, level);
|
|
DisplayExpertSkills();
|
}
|
|
void DisplayExpertSkills()
|
{
|
TreasureSkill skill;
|
if (model.TryGetSkill(model.selectSkill, out skill))
|
{
|
for (int i = 0; i < m_SkillExpertBehaviours.Length; i++)
|
{
|
var potential = skill.potentials[i];
|
var level = 0;
|
model.TryGetExpertActiveLevel(potential.id, out level);
|
m_SkillExpertBehaviours[i].Display(potential.id, level);
|
}
|
}
|
}
|
|
private void ExpertSelect()
|
{
|
ExpertSkillSelectWin.skillId = model.selectSkill;
|
WindowCenter.Instance.Open<ExpertSkillSelectWin>();
|
}
|
|
private void OnRefreshCell(ScrollerDataType type, CellView cell)
|
{
|
var skillCell = cell as TreasureSkillCell;
|
skillCell.Display(cell.index);
|
}
|
|
private void WindowAfterCloseEvent(Window win)
|
{
|
if (win is ExpertSkillSelectWin)
|
{
|
TryAutoUse();
|
TryStartGuide();
|
}
|
}
|
|
private void TreasureSkillRefresh(int skillId)
|
{
|
m_Controller.m_Scorller.RefreshActiveCellViews();
|
if (skillId == model.selectSkill)
|
{
|
DisplaySkillDetial();
|
}
|
}
|
|
private void SelectRefresh()
|
{
|
m_Controller.m_Scorller.RefreshActiveCellViews();
|
DisplaySkillDetial();
|
DisplayExpertSkill();
|
|
TryStartGuide();
|
|
TreasureSkill treasureSkill;
|
if (model.TryGetSkill(model.selectSkill, out treasureSkill))
|
{
|
if (treasureSkill.expertSelectRedpoint.state == RedPointState.Simple)
|
{
|
PlaySelectGuide(true);
|
}
|
}
|
}
|
|
private void SkillLevelUpRefresh(int id)
|
{
|
if (model.selectSkill == id)
|
{
|
m_Controller.m_Scorller.RefreshActiveCellViews();
|
DisplaySkillDetial();
|
}
|
}
|
|
private void ExpertSkillRefresh()
|
{
|
DisplayExpertSkill();
|
m_Controller.m_Scorller.RefreshActiveCellViews();
|
|
TryStartGuide();
|
}
|
|
private void RefreshItemCountEvent(PackType packType, int arg2, int itemId)
|
{
|
if (packType == PackType.Item && model.skillLevelUpItems.Contains(itemId))
|
{
|
DisplaySkillDetial();
|
}
|
}
|
|
void TrySwitchExpertSkill()
|
{
|
var des = RectTransformUtility.CalculateRelativeRectTransformBounds(this.transform, m_SkillExpert.dragAccepter);
|
var src = RectTransformUtility.CalculateRelativeRectTransformBounds(this.transform, m_DragSkillIcon.rectTransform);
|
var dis = Vector3.Distance(des.center, src.center);
|
if (dis < m_SkillExpert.dragAccepter.rect.width / 2)
|
{
|
var skillId = 0;
|
if (model.TryGetExpertSkill(model.selectSkill, out skillId)
|
&& skillId == skillModel.skillDragId)
|
{
|
return;
|
}
|
|
var pak = new CA516_tagCMSelectSkillElement();
|
pak.SkillTypeID = (uint)skillModel.skillDragId;
|
pak.DoType = 1;
|
GameNetSystem.Instance.SendInfo(pak);
|
}
|
}
|
|
void TryAutoUse()
|
{
|
var skill = 0;
|
if (model.GetTotalExpertSkillLevel() == 1 &&
|
!model.TryGetExpertSkill(model.selectSkill, out skill)
|
&& model.ExistAnyActiveExpert(model.selectSkill, out skill)
|
&& PlayerDatas.Instance.baseData.LV < reikiRootModel.resetReikiLimitLevel)
|
{
|
if (flyObject != null)
|
{
|
GameObject.Destroy(flyObject.gameObject);
|
flyObject = null;
|
}
|
|
RectTransform parent = null;
|
for (int i = 0; i < m_SkillExpertBehaviours.Length; i++)
|
{
|
if (m_SkillExpertBehaviours[i].skillId == skill)
|
{
|
parent = m_SkillExpertBehaviours[i].flyContainer;
|
}
|
}
|
|
m_FlyTarget.IdList = new int[1] { skill };
|
FunctionUnlockFlyObjectTargetCenter.Register(FunctionUnlockType.Skill, new int[] { skill }, m_FlyTarget);
|
var instance = UIUtility.CreateWidget("SkillUnlockFlyObject", "SkillUnlockFlyObject");
|
instance.transform.SetParentEx(parent, Vector3.zero, Quaternion.identity, Vector3.one);
|
flyObject = instance.GetComponent<FunctionUnlockFlyObject>();
|
flyObject.SetContent(FunctionUnlockType.Skill, skill);
|
|
autoSelectSkill = skill;
|
|
flyObject.Begin(() =>
|
{
|
var pak = new CA516_tagCMSelectSkillElement();
|
pak.SkillTypeID = (uint)skill;
|
pak.DoType = 1;
|
GameNetSystem.Instance.SendInfo(pak);
|
|
autoSelectSkill = 0;
|
});
|
}
|
}
|
|
void TryStartGuide()
|
{
|
if (NewBieCenter.Instance.inGuiding)
|
{
|
return;
|
}
|
if (!NewBieCenter.Instance.IsGuideCompleted(62))
|
{
|
var treasureModel = ModelCenter.Instance.GetModel<TreasureModel>();
|
var treasureId = treasureModel.GetTreasureBySkillId(model.selectSkill);
|
if (treasureId == 102)
|
{
|
var skill = 0;
|
if (model.ExistAnyActiveExpert(model.selectSkill)
|
&& !WindowCenter.Instance.IsOpen<ExpertSkillSelectWin>()
|
&& !model.TryGetExpertSkill(model.selectSkill, out skill))
|
{
|
NewBieCenter.Instance.StartNewBieGuide(62);
|
}
|
}
|
}
|
}
|
|
private void OpenExpert()
|
{
|
var skillId = 0;
|
if (model.TryGetExpertSkill(model.selectSkill, out skillId))
|
{
|
ExpertSkillSelectWin.skillId = skillId;
|
WindowCenter.Instance.Open<ExpertSkillSelectWin>();
|
}
|
else
|
{
|
var expertSkill = 0;
|
if (model.ExistAnyActiveExpert(model.selectSkill, out expertSkill))
|
{
|
PlaySelectGuide();
|
}
|
else
|
{
|
SysNotifyMgr.Instance.ShowTip("NoneOfAnyActiveExpert");
|
}
|
}
|
}
|
|
private void PlaySelectGuide(bool disappear = false)
|
{
|
if (NewBieCenter.Instance.inGuiding)
|
{
|
return;
|
}
|
|
List<int> indexs = new List<int>();
|
TreasureSkill treasureSkill;
|
if (model.TryGetSkill(model.selectSkill, out treasureSkill))
|
{
|
for (int i = 0; i < treasureSkill.potentials.Count; i++)
|
{
|
var level = 0;
|
if (model.TryGetExpertActiveLevel(treasureSkill.potentials[i].id, out level)
|
&& level > 0)
|
{
|
indexs.Add(i);
|
}
|
}
|
}
|
|
if (indexs.Count == 0)
|
{
|
return;
|
}
|
|
var index = indexs[UnityEngine.Random.Range(0, indexs.Count)];
|
functionGuideTime = Time.time;
|
switch (index)
|
{
|
case 0:
|
if (disappear)
|
{
|
functionGuideId = 65;
|
}
|
NewBieCenter.Instance.StartNewBieGuide(65);
|
break;
|
case 1:
|
if (disappear)
|
{
|
functionGuideId = 63;
|
}
|
NewBieCenter.Instance.StartNewBieGuide(63);
|
break;
|
case 2:
|
if (disappear)
|
{
|
functionGuideId = 64;
|
}
|
NewBieCenter.Instance.StartNewBieGuide(64);
|
break;
|
}
|
}
|
|
protected override void LateUpdate()
|
{
|
base.LateUpdate();
|
if (skillModel.skillDraging)
|
{
|
if (!m_DragSkillIcon.gameObject.activeSelf)
|
{
|
m_DragSkillIcon.gameObject.SetActive(true);
|
var config = SkillConfig.Get(skillModel.skillDragId);
|
if (config != null)
|
{
|
m_DragSkillIcon.SetSprite(config.IconName);
|
}
|
}
|
Vector2 _pos;
|
if (RectTransformUtility.ScreenPointToLocalPointInRectangle(this.transform as RectTransform,
|
Input.mousePosition, CameraManager.uiCamera, out _pos))
|
{
|
m_DragSkillIcon.rectTransform.localPosition = _pos;
|
}
|
|
if (Input.GetMouseButtonUp(0))
|
{
|
skillModel.skillDraging = false;
|
TrySwitchExpertSkill();
|
m_DragSkillIcon.gameObject.SetActive(false);
|
}
|
}
|
|
if (functionGuideId != 0)
|
{
|
if (Time.time - functionGuideTime >= m_DisappearTime)
|
{
|
NewBieCenter.Instance.FinishNewBieGuide(functionGuideId);
|
functionGuideId = 0;
|
}
|
}
|
}
|
|
[Serializable]
|
public class SkillWidget
|
{
|
[SerializeField] Transform m_Container;
|
[SerializeField] Text m_SkillLevel;
|
[SerializeField] Text m_SkillCoolDown;
|
[SerializeField] Text m_SkillDesc;
|
|
TreasureSkillModel model { get { return ModelCenter.Instance.GetModel<TreasureSkillModel>(); } }
|
|
public void Display(int skillId, int level)
|
{
|
m_SkillLevel.text = Language.Get("SkillActLevel", level);
|
TreasureSkill skill;
|
model.TryGetSkill(skillId, out skill);
|
var skillConfig = skill.GetSkillConfig(level);
|
m_SkillCoolDown.text = skillConfig.CoolDownTime == 0 ? string.Empty
|
: Language.Get("L1065", skillConfig.CoolDownTime / 1000);
|
m_SkillDesc.text = skillConfig.Description;
|
}
|
|
public void SetActive(bool active)
|
{
|
m_Container.gameObject.SetActive(active);
|
}
|
}
|
|
[Serializable]
|
public class SkillExpertWidget
|
{
|
[SerializeField] RectTransform m_DragAccepter;
|
[SerializeField] Image m_SkillIcon;
|
[SerializeField] Text m_SkillName;
|
[SerializeField] Transform m_ContainerReikiIcon;
|
[SerializeField] Image[] m_ReikiIcons;
|
[SerializeField] Text m_UnSelectRemind;
|
[SerializeField] Text m_Description;
|
|
public RectTransform dragAccepter
|
{
|
get { return m_DragAccepter; }
|
}
|
|
TreasureSkillModel model { get { return ModelCenter.Instance.GetModel<TreasureSkillModel>(); } }
|
|
public void Display(int skillId, int level)
|
{
|
m_SkillIcon.gameObject.SetActive(skillId != 0);
|
m_SkillName.gameObject.SetActive(skillId != 0);
|
m_UnSelectRemind.gameObject.SetActive(skillId == 0);
|
m_Description.gameObject.SetActive(false);
|
|
|
m_ContainerReikiIcon.gameObject.SetActive(skillId != 0);
|
|
if (skillId != 0)
|
{
|
SkillConfig skillConfig;
|
if (level == 0)
|
{
|
skillConfig = SkillConfig.Get(skillId);
|
}
|
else
|
{
|
skillConfig = SkillConfig.Get(skillId + level - 1);
|
}
|
|
m_SkillIcon.SetSprite(skillConfig.IconName);
|
m_SkillName.text = skillConfig.SkillName;
|
|
var property = skillConfig.RequireProperty();
|
var propertyConfig = PlayerPropertyConfig.Get(property);
|
|
m_ReikiIcons[0].gameObject.SetActive(property == (int)PropertyType.Mater);
|
m_ReikiIcons[1].gameObject.SetActive(property == (int)PropertyType.Wood);
|
m_ReikiIcons[2].gameObject.SetActive(property == (int)PropertyType.Water);
|
m_ReikiIcons[3].gameObject.SetActive(property == (int)PropertyType.Fire);
|
m_ReikiIcons[4].gameObject.SetActive(property == (int)PropertyType.Earth);
|
|
if (level == 0)
|
{
|
var conditionLabel = string.Format("（{0}{1}激活）", propertyConfig.Name, skillConfig.RequirePropertyValue());
|
conditionLabel = UIHelper.AppendColor(TextColType.Red, conditionLabel, true);
|
m_Description.text = StringUtility.Contact(skillConfig.Description, conditionLabel);
|
m_Description.color = UIHelper.s_BrightWhiteColor;
|
}
|
else
|
{
|
m_Description.text = skillConfig.Description;
|
m_Description.color = UIHelper.s_NavyBrown;
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
|
|
