//--------------------------------------------------------
|
// [Author]: 第二世界
|
// [ Date ]: Thursday, February 28, 2019
|
//--------------------------------------------------------
|
|
using System;
|
using System.Collections;
|
using System.Collections.Generic;
|
using UnityEngine;
|
using UnityEngine.UI;
|
|
namespace Snxxz.UI
|
{
|
|
public class EquipStarWin : Window
|
{
|
[SerializeField] RectTransform m_LevelContainer;
|
[SerializeField] Star[] m_Stars;
|
[SerializeField] ItemCell m_TargetEquip;
|
[SerializeField] Text m_EquipStar;
|
[SerializeField] Materials m_Materials;
|
[SerializeField] Text m_SuccessRate;
|
[SerializeField] RectTransform m_EmptyHint;
|
[SerializeField] RectTransform m_PropertyDetails;
|
[SerializeField] BaseProperty[] m_BasePropertys;
|
[SerializeField] Text[] m_LevelUpPropertys;
|
[SerializeField] Button m_StarUpgrade;
|
[SerializeField] RectTransform m_MaxStarLevelHint;
|
[SerializeField] EquipStarMaterialCandidateWidget m_MaterialCandidateWidget;
|
[SerializeField] UIEffect m_EffectStarFill;
|
[SerializeField] UIEffect m_EffectSuccess;
|
[SerializeField] UIEffect m_EffectFailed;
|
|
List<EquipStarLevelSelectBehaviour> levelBehaviours = new List<EquipStarLevelSelectBehaviour>();
|
|
EquipStarModel model { get { return ModelCenter.Instance.GetModel<EquipStarModel>(); } }
|
EquipModel equipModel { get { return ModelCenter.Instance.GetModel<EquipModel>(); } }
|
PackModel packModel { get { return ModelCenter.Instance.GetModel<PackModel>(); } }
|
|
#region Built-in
|
protected override void BindController()
|
{
|
|
}
|
|
protected override void AddListeners()
|
{
|
m_StarUpgrade.SetListener(StarUpgrade);
|
}
|
|
protected override void OnPreOpen()
|
{
|
if (model.selectedLevel.value == 0)
|
{
|
model.SelectLevel(equipModel.GetLastestUnLockEquipSet());
|
}
|
|
DisplayBaseInfo();
|
}
|
|
protected override void OnAfterOpen()
|
{
|
}
|
|
protected override void OnPreClose()
|
{
|
|
}
|
|
protected override void OnAfterClose()
|
{
|
model.ResetOperateParams();
|
}
|
|
protected override void OnActived()
|
{
|
base.OnActived();
|
DisplayDynamicInfo(true);
|
}
|
|
protected override void LateUpdate()
|
{
|
base.LateUpdate();
|
DisplayDynamicInfo(false);
|
}
|
|
#endregion
|
|
private void DisplayBaseInfo()
|
{
|
CreateLevelBehaviours();
|
}
|
|
private void DisplayDynamicInfo(bool force)
|
{
|
if (force || model.selectedLevel.dirty)
|
{
|
var level = model.selectedLevel.Fetch();
|
for (var i = 0; i < levelBehaviours.Count; i++)
|
{
|
var behaviour = levelBehaviours[i];
|
if (behaviour.level != level)
|
{
|
behaviour.Dispose();
|
}
|
}
|
|
for (var i = 0; i < levelBehaviours.Count; i++)
|
{
|
var behaviour = levelBehaviours[i];
|
if (behaviour.level == level)
|
{
|
behaviour.Display();
|
}
|
}
|
}
|
|
if (force || model.selectedPlace.dirty)
|
{
|
var currentStarLevel = 0;
|
var equipPosition = new Int2(model.selectedLevel.value, model.selectedPlace.Fetch());
|
|
var equipGuid = equipModel.GetEquip(equipPosition);
|
var equip = packModel.GetItemByGuid(equipGuid);
|
if (equip != null)
|
{
|
m_TargetEquip.gameObject.SetActive(true);
|
m_TargetEquip.Init(equip);
|
m_TargetEquip.button.SetListener(ViewEquipTip);
|
currentStarLevel = model.GetEquipStarLevel(equipPosition);
|
|
m_EquipStar.gameObject.SetActive(true);
|
m_EquipStar.text = currentStarLevel >= 1 ? string.Format("{0}星", currentStarLevel) : "";
|
}
|
else
|
{
|
m_EquipStar.gameObject.SetActive(false);
|
m_TargetEquip.gameObject.SetActive(false);
|
}
|
|
DisplayMaterialSlots(equipPosition, currentStarLevel);
|
DisplayPropertyPreview(equipPosition, currentStarLevel, EquipStarModel.GetMaxStarLevel(equipPosition.x));
|
DisplayStarUpgradeButton(equipPosition, currentStarLevel);
|
}
|
|
if (force || model.equipStarLevel.dirty || model.equipMaxStarLevel.dirty)
|
{
|
var equipPosition = new Int2(model.selectedLevel.value, model.selectedPlace.value);
|
var starLevel = model.equipStarLevel.Fetch();
|
var maxStar = model.equipMaxStarLevel.Fetch();
|
DisplayPropertyPreview(equipPosition, starLevel, EquipStarModel.GetMaxStarLevel(equipPosition.x));
|
DisplayStarUpgradeButton(equipPosition, starLevel);
|
}
|
|
if (force || model.stars.dirty)
|
{
|
DisplayStars(model.stars.Fetch());
|
}
|
|
if (force || model.starUpgradeProbability.dirty)
|
{
|
DisplaySuccessRate(model.starUpgradeProbability.Fetch());
|
}
|
|
if (force || model.operateMaterialIndex.dirty)
|
{
|
var index = model.operateMaterialIndex.Fetch();
|
DisplayMaterialCandidates(index);
|
}
|
|
if (force || model.starResultEffect.dirty)
|
{
|
var result = model.starResultEffect.Fetch();
|
model.starResultEffect.value = 0;
|
PlayStarUpgradeEffect(result);
|
}
|
}
|
|
private void DisplayStars(List<EquipStarModel.Star> stars)
|
{
|
StopCoroutine("Co_DisplayStars");
|
StartCoroutine("Co_DisplayStars", stars);
|
}
|
|
private void DisplayMaterialSlots(Int2 equipPosition, int currentStarLevel)
|
{
|
var equipGuid = equipModel.GetEquip(equipPosition);
|
var equip = packModel.GetItemByGuid(equipGuid);
|
|
var maxStarLevel = equip != null ? EquipStarModel.GetMaxStarLevel(equip.config.ItemColor, equip.config.LV) : 0;
|
var upgradable = maxStarLevel > 0;
|
var isMax = upgradable && currentStarLevel >= maxStarLevel;
|
|
if (!upgradable || isMax)
|
{
|
for (var i = 1; i <= 5; i++)
|
{
|
m_Materials[i].Display(false);
|
}
|
|
m_Materials.materialSpecial.Display(false, 0, 0);
|
}
|
else
|
{
|
var starConfig = EquipStarConfig.Get(equipPosition.x, equipPosition.y, currentStarLevel + 1);
|
for (var i = 1; i <= 5; i++)
|
{
|
m_Materials[i].Display(starConfig != null && i <= starConfig.CostEquipCnt);
|
}
|
|
if (starConfig != null)
|
{
|
m_Materials.materialSpecial.Display(starConfig.CostItemDict.x != 0, starConfig.CostItemDict.x, starConfig.CostItemDict.y);
|
}
|
}
|
}
|
|
private void DisplayPropertyPreview(Int2 equipPosition, int currentStar, int maxStar)
|
{
|
var equipGuid = equipModel.GetEquip(equipPosition);
|
var isMax = maxStar > 0 && currentStar >= maxStar;
|
var upgradable = model.IsEquipPlaceUpgradable(equipGuid);
|
|
if (isMax)
|
{
|
m_EmptyHint.gameObject.SetActive(false);
|
m_PropertyDetails.gameObject.SetActive(true);
|
DisplayBaseProperty(equipPosition, currentStar, currentStar);
|
DisplayLevelUpProperty(equipPosition, currentStar, currentStar);
|
}
|
else if (upgradable)
|
{
|
m_EmptyHint.gameObject.SetActive(false);
|
m_PropertyDetails.gameObject.SetActive(true);
|
DisplayBaseProperty(equipPosition, currentStar, currentStar + 1);
|
DisplayLevelUpProperty(equipPosition, currentStar, currentStar + 1);
|
}
|
else
|
{
|
m_EmptyHint.gameObject.SetActive(true);
|
m_PropertyDetails.gameObject.SetActive(false);
|
}
|
}
|
|
private void DisplayBaseProperty(Int2 equipPosition, int currentStar, int nextStar)
|
{
|
var nowConfig = EquipStarConfig.Get(equipPosition.x, equipPosition.y, currentStar);
|
var nextConfig = EquipStarConfig.Get(equipPosition.x, equipPosition.y, nextStar);
|
if (nextConfig == null)
|
{
|
nextConfig = nowConfig;
|
}
|
|
var count = nextConfig != null ? nextConfig.BaseAttrInfo.Length : 0;
|
for (var i = 0; i < m_BasePropertys.Length; i++)
|
{
|
var behaviour = m_BasePropertys[i];
|
if (i < count)
|
{
|
var current = nowConfig == null ? 0 : nowConfig.BaseAttrInfo[i].y;
|
var next = nextConfig == null ? 0 : nextConfig.BaseAttrInfo[i].y;
|
behaviour.Display(nextConfig == null ? 0 : nextConfig.BaseAttrInfo[i].x, current, next);
|
}
|
else
|
{
|
behaviour.Hide();
|
}
|
}
|
}
|
|
private void DisplayLevelUpProperty(Int2 equipPosition, int currentStar, int nextStar)
|
{
|
var configs = EquipStarConfig.GetConfigs(equipPosition.x, equipPosition.y);
|
var levelUpProperties = new Dictionary<int, Int2>();
|
var prePropertiesCount = 0;
|
foreach (var config in configs)
|
{
|
if (config.StarAttrInfo.Length > prePropertiesCount)
|
{
|
var length = config.StarAttrInfo.Length;
|
levelUpProperties[config.Star] = config.StarAttrInfo[length - 1];
|
prePropertiesCount = config.StarAttrInfo.Length;
|
}
|
}
|
|
var keys = new List<int>(levelUpProperties.Keys);
|
for (var i = 0; i < m_LevelUpPropertys.Length; i++)
|
{
|
var behaviour = m_LevelUpPropertys[i];
|
if (i < keys.Count)
|
{
|
var star = keys[i];
|
var property = levelUpProperties[star];
|
behaviour.gameObject.SetActive(true);
|
behaviour.text = string.Format("【{0}星】{1}", star, PlayerPropertyConfig.GetFullDescription(property));
|
behaviour.color = UIHelper.GetUIColor(nextStar >= star ? TextColType.Green : TextColType.Gray);
|
}
|
else
|
{
|
behaviour.gameObject.SetActive(false);
|
}
|
}
|
}
|
|
private void DisplaySuccessRate(int successRate)
|
{
|
if (successRate >= 0)
|
{
|
m_SuccessRate.text = string.Format("成功率 {0}%", successRate);
|
}
|
else
|
{
|
m_SuccessRate.text = string.Empty;
|
}
|
}
|
|
private void DisplayMaterialCandidates(int materialIndex)
|
{
|
if (materialIndex == 0)
|
{
|
m_MaterialCandidateWidget.gameObject.SetActive(false);
|
}
|
else
|
{
|
m_MaterialCandidateWidget.gameObject.SetActive(true);
|
|
var equipPosition = new Int2(model.selectedLevel.value, model.selectedPlace.value);
|
var starLevel = model.GetEquipStarLevel(equipPosition);
|
m_MaterialCandidateWidget.Display(equipPosition, starLevel + 1);
|
|
var position = Vector3.zero;
|
m_MaterialCandidateWidget.transform.localPosition = position;
|
}
|
}
|
|
private void DisplayStarUpgradeButton(Int2 equipPosition, int currentStarLevel)
|
{
|
if (equipPosition.y == 0)
|
{
|
m_StarUpgrade.gameObject.SetActive(false);
|
m_MaxStarLevelHint.gameObject.SetActive(false);
|
}
|
else
|
{
|
var maxLevel = EquipStarModel.GetMaxStarLevel(equipPosition.x);
|
var isMax = currentStarLevel >= maxLevel;
|
m_StarUpgrade.gameObject.SetActive(!isMax);
|
m_MaxStarLevelHint.gameObject.SetActive(isMax);
|
}
|
}
|
|
private void StarUpgrade()
|
{
|
var equipPosition = new Int2(model.selectedLevel.value, model.selectedPlace.value);
|
var currentStarLevel = model.GetEquipStarLevel(equipPosition);
|
model.DoStarUpgrade(equipPosition, currentStarLevel + 1);
|
}
|
|
private void CreateLevelBehaviours()
|
{
|
var levels = equipModel.GetUnLockedEquipSets();
|
var gap = levels.Count - levelBehaviours.Count;
|
for (var i = 0; i < gap; i++)
|
{
|
var instance = UIUtility.CreateWidget("EquipStarLevelSelectBehaviour", "EquipStarLevelSelectBehaviour");
|
var behaviour = instance.GetComponent<EquipStarLevelSelectBehaviour>();
|
behaviour.transform.SetParentEx(m_LevelContainer, Vector3.zero, Quaternion.identity, Vector3.one);
|
levelBehaviours.Add(behaviour);
|
}
|
|
for (var i = 0; i < levelBehaviours.Count; i++)
|
{
|
var behaviour = levelBehaviours[i];
|
if (i < levels.Count)
|
{
|
behaviour.gameObject.SetActive(true);
|
behaviour.UnInit();
|
behaviour.Init(levels[i]);
|
}
|
else
|
{
|
behaviour.UnInit();
|
behaviour.gameObject.SetActive(false);
|
}
|
}
|
}
|
|
private void PlayStarUpgradeEffect(int result)
|
{
|
if (result == 1 || result == -1)
|
{
|
StopCoroutine("Co_PlaySuccessEffect");
|
StopCoroutine("Co_PlayFailedEffect");
|
}
|
|
if (result == 1)
|
{
|
StartCoroutine("Co_PlaySuccessEffect");
|
}
|
else if (result == -1)
|
{
|
StartCoroutine("Co_PlayFailedEffect");
|
}
|
}
|
|
IEnumerator Co_PlaySuccessEffect()
|
{
|
m_EffectStarFill.Play();
|
yield return WaitingForSecondConst.WaitMS700;
|
m_EffectSuccess.Play();
|
}
|
|
IEnumerator Co_PlayFailedEffect()
|
{
|
m_EffectStarFill.Play();
|
yield return WaitingForSecondConst.WaitMS700;
|
m_EffectFailed.Play();
|
}
|
|
IEnumerator Co_DisplayStars(List<EquipStarModel.Star> stars)
|
{
|
var hasNewStar = stars.FindIndex(x => { return x.newGet; }) != -1;
|
if (hasNewStar)
|
{
|
yield return WaitingForSecondConst.WaitMS2000;
|
}
|
|
for (var i = 0; i < m_Stars.Length; i++)
|
{
|
if (i < stars.Count)
|
{
|
var star = stars[i];
|
m_Stars[i].Display(star.actived);
|
if (star.newGet)
|
{
|
m_Stars[i].PlayEffect();
|
}
|
}
|
else
|
{
|
m_Stars[i].Hide();
|
}
|
}
|
}
|
|
private void ViewEquipTip()
|
{
|
var level = model.selectedLevel.value;
|
var place = model.selectedPlace.value;
|
var equipPosition = new Int2(level, place);
|
var equipGuid = equipModel.GetEquip(equipPosition);
|
|
var itemTipsModel = ModelCenter.Instance.GetModel<ItemTipsModel>();
|
itemTipsModel.SetItemTipsModel(PackType.Item, equipGuid, false, true);
|
itemTipsModel.ShowTip();
|
}
|
|
[System.Serializable]
|
public class Star
|
{
|
public RectTransform container;
|
public Image imageBase;
|
public Image imageStar;
|
public UIEffect newStarEffect;
|
|
public void Display(bool active)
|
{
|
container.gameObject.SetActive(true);
|
imageStar.gameObject.SetActive(active);
|
}
|
|
public void Hide()
|
{
|
container.gameObject.SetActive(false);
|
}
|
|
public void PlayEffect()
|
{
|
newStarEffect.Play();
|
}
|
}
|
|
[System.Serializable]
|
public class Materials
|
{
|
public EquipStarUpgradeMaterialBehaviour m_Material1;
|
public EquipStarUpgradeMaterialBehaviour m_Material2;
|
public EquipStarUpgradeMaterialBehaviour m_Material3;
|
public EquipStarUpgradeMaterialBehaviour m_Material4;
|
public EquipStarUpgradeMaterialBehaviour m_Material5;
|
public EquipStarUpgradeSpecialMaterialBehaviour materialSpecial;
|
|
public EquipStarUpgradeMaterialBehaviour this[int index] {
|
get {
|
switch (index)
|
{
|
case 1:
|
return m_Material1;
|
case 2:
|
return m_Material2;
|
case 3:
|
return m_Material3;
|
case 4:
|
return m_Material4;
|
case 5:
|
return m_Material5;
|
default:
|
return null;
|
}
|
}
|
}
|
|
}
|
|
[System.Serializable]
|
public class BaseProperty
|
{
|
public RectTransform container;
|
public Text current;
|
public Image arrow;
|
public Text next;
|
|
public void Display(int propertyId, int currentValue, int nextValue)
|
{
|
container.gameObject.SetActive(true);
|
var config = PlayerPropertyConfig.Get(propertyId);
|
if (config != null)
|
{
|
this.current.text = StringUtility.Contact(config.Name, ":", PlayerPropertyConfig.GetValueDescription(propertyId, currentValue));
|
if (currentValue != nextValue)
|
{
|
this.arrow.gameObject.SetActive(true);
|
this.next.gameObject.SetActive(true);
|
this.next.text = PlayerPropertyConfig.GetValueDescription(propertyId, nextValue);
|
}
|
else
|
{
|
this.arrow.gameObject.SetActive(false);
|
this.next.gameObject.SetActive(false);
|
}
|
}
|
}
|
|
public void Hide()
|
{
|
container.gameObject.SetActive(false);
|
}
|
}
|
|
|
}
|
|
}
|
