using System;
|
using System.Collections;
|
using System.Collections.Generic;
|
using UnityEngine;
|
using UnityEngine.UI;
|
|
namespace vnxbqy.UI
|
{
|
public class AlchemyStoveBehaviour : MonoBehaviour
|
{
|
[SerializeField] Transform m_ContainerMaterials;
|
[SerializeField] AlchemyMaterial[] m_AlchemyMaterials;
|
|
[SerializeField] Transform m_ContainerAlcheming;
|
[SerializeField] Text m_AlchemyTime;
|
[SerializeField] Slider m_TimeSlider;
|
[SerializeField] Transform m_ContainerComplete;
|
[SerializeField] Transform m_ContainerNormal;
|
[SerializeField] Text m_StoveLevel;
|
[SerializeField] Text m_StoveExp;
|
[SerializeField] Slider m_StoveExpSlider;
|
[SerializeField] Image m_ViewSlider;
|
[SerializeField] float m_SliderLength;
|
|
[SerializeField] Text m_ReikiPoint;
|
[SerializeField] Transform m_ContainerGrasp;
|
[SerializeField] Button m_Func;
|
[SerializeField] Text m_FuncLabel;
|
[SerializeField] Button m_BatchAlchemy;
|
[SerializeField] Text m_BatchAlchemyLabel;
|
[SerializeField] Transform m_ContainerUnGrasp;
|
|
[SerializeField] UIEffect m_AlchemingEffect;
|
[SerializeField] UIEffect m_AlchemyCompleteEffect;
|
[SerializeField] UIEffect[] m_AlchemyFlyEffects;
|
[SerializeField] Transform m_ContainerFlyMaterials;
|
[SerializeField] Transform[] m_FlyMaterials;
|
[SerializeField] Image[] m_FlyIcons;
|
[SerializeField] UIEffect m_AlchemyBoomEffect;
|
|
int m_State = 0; //0-正常状态 1-炼丹中 2-炼丹结束
|
int state
|
{
|
get { return m_State; }
|
set
|
{
|
if (m_State != value)
|
{
|
m_State = value;
|
DisplayStove();
|
}
|
}
|
}
|
|
float timer = 0f;
|
|
bool animationStep = false;
|
|
AlchemyModel model { get { return ModelCenter.Instance.GetModel<AlchemyModel>(); } }
|
PackModel packModel { get { return ModelCenter.Instance.GetModel<PackModel>(); } }
|
ReikiRootModel reikiRootModel { get { return ModelCenter.Instance.GetModel<ReikiRootModel>(); } }
|
VipModel vipModel { get { return ModelCenter.Instance.GetModel<VipModel>(); } }
|
PackModel playerPack { get { return ModelCenter.Instance.GetModel<PackModel>(); } }
|
|
private void Awake()
|
{
|
m_Func.SetListener(OnFunc);
|
|
if (m_BatchAlchemy != null)
|
{
|
m_BatchAlchemy.SetListener(BatchAlchemy);
|
}
|
}
|
|
public void Display()
|
{
|
model.selectAlchemyRefresh += SelectAlchemyRefresh;
|
model.alchemyStateRefresh += AlchemyStateRefresh;
|
PlayerDatas.Instance.playerDataRefreshEvent += PlayerDataRefreshEvent;
|
packModel.refreshItemCountEvent += RefreshItemCountEvent;
|
reikiRootModel.onReikiRootPointRefresh += OnReikiRootPointRefresh;
|
|
m_State = model.GetStoveState(model.selectAlchemy);
|
|
DisplayAlchemyMaterials();
|
DisplayStove();
|
DisplayReikiPoint();
|
DisplayBatchState();
|
}
|
|
void DisplayAlchemyMaterials()
|
{
|
var grasp = model.IsGraspRecipe(model.selectAlchemy);
|
|
List<Item> materials;
|
model.TryGetAlchemyMaterials(model.selectAlchemy, out materials);
|
|
for (int i = 0; i < m_AlchemyMaterials.Length; i++)
|
{
|
if (grasp && materials != null && i < materials.Count)
|
{
|
m_AlchemyMaterials[i].SetLock(false);
|
m_AlchemyMaterials[i].Display(materials[i]);
|
}
|
else
|
{
|
m_AlchemyMaterials[i].SetLock(true);
|
}
|
}
|
}
|
|
void DisplayStove()
|
{
|
m_ContainerAlcheming.SetActive(state == 1);
|
m_ContainerNormal.SetActive(state == 0);
|
m_ContainerComplete.SetActive(state == 2);
|
|
m_AlchemingEffect.StopImediatly();
|
m_AlchemyCompleteEffect.StopImediatly();
|
|
m_ContainerMaterials.SetActive(false);
|
m_ContainerFlyMaterials.SetActive(false);
|
|
switch (state)
|
{
|
case 0:
|
m_ContainerMaterials.SetActive(true);
|
m_StoveLevel.text = StringUtility.Contact("Lv.", model.stoveLevel);
|
var isMax = !RefineStoveConfig.Has(model.stoveLevel + 1);
|
var stoveConfig = RefineStoveConfig.Get(model.stoveLevel);
|
if (isMax)
|
{
|
m_StoveExp.text = Language.Get("L1055");
|
m_StoveExpSlider.value = 1;
|
}
|
else
|
{
|
m_StoveExp.text = StringUtility.Contact(model.stoveExp, "/", stoveConfig.Exp);
|
var progress = Mathf.Clamp01((float)model.stoveExp / stoveConfig.Exp);
|
m_StoveExpSlider.value = progress;
|
}
|
break;
|
case 1:
|
m_AlchemingEffect.Play();
|
DisplayAlchemyTime();
|
break;
|
case 2:
|
if (model.selectAlchemyType == AlchemyType.Normal && PlayerDatas.Instance.baseData.LV < model.autoFunctionGuideLevel &&
|
!FunctionalGuideCenter.Instance.ExistAnyUnderwayGuide())
|
{
|
NewBieCenter.Instance.ResetGuide(131);
|
StartCoroutine(Co_StartGuied(131));
|
}
|
m_AlchemyCompleteEffect.Play();
|
break;
|
}
|
|
if (model.selectAlchemyType == AlchemyType.Normal && PlayerDatas.Instance.baseData.LV < model.autoFunctionGuideLevel
|
&& !FunctionalGuideCenter.Instance.ExistAnyUnderwayGuide()
|
&& model.alchemyDrugRedpoint3.state == RedPointState.Simple
|
&& state != 2)
|
{
|
NewBieCenter.Instance.ResetGuide(132);
|
StartCoroutine(Co_StartGuied(132));
|
}
|
|
DisplayViewLength();
|
|
DisplayBatchState();
|
|
var grasp = model.IsGraspRecipe(model.selectAlchemy);
|
m_ContainerGrasp.SetActive(grasp);
|
m_ContainerUnGrasp.SetActive(!grasp);
|
if (grasp)
|
{
|
m_Func.SetActive(state != 1);
|
switch (state)
|
{
|
case 0:
|
m_FuncLabel.text = Language.Get("AlchemyStoveStart");
|
break;
|
case 1:
|
//m_FuncLabel.text = Language.Get("AlchemyStoveStop");
|
break;
|
case 2:
|
m_FuncLabel.text = Language.Get("AlchemyStoveGet");
|
break;
|
}
|
}
|
}
|
|
IEnumerator Co_StartGuied(int guide)
|
{
|
yield return null;
|
FunctionalGuideCenter.Instance.StartGuide(guide);
|
}
|
|
void DisplayReikiPoint()
|
{
|
m_ReikiPoint.text = reikiRootModel.GetReikiRootTotalPointWithFree().ToString();
|
}
|
|
void DisplayViewLength()
|
{
|
var isMax = !RefineStoveConfig.Has(model.stoveLevel + 1);
|
m_ViewSlider.SetActive(!isMax);
|
if (!isMax)
|
{
|
var stoveConfig = RefineStoveConfig.Get(model.stoveLevel);
|
var config = AlchemyConfig.Get(model.selectAlchemy);
|
var exp = config.AlchemyExp + model.stoveExp;
|
var progress = Mathf.Clamp01((float)exp / stoveConfig.Exp);
|
m_ViewSlider.rectTransform.sizeDelta = m_ViewSlider.rectTransform.sizeDelta.SetX(progress * m_SliderLength);
|
}
|
}
|
|
void DisplayAlchemyTime()
|
{
|
AlchemyTime alchemyTime;
|
if (model.TryGetAlchemyStartTime(model.selectAlchemy, out alchemyTime))
|
{
|
var config = AlchemyConfig.Get(model.selectAlchemy);
|
var startTime = TimeUtility.GetTime(alchemyTime.startTick);
|
var seconds = (int)(config.NeedTime * alchemyTime.count
|
- (float)(TimeUtility.ServerNow - startTime).TotalSeconds);
|
m_AlchemyTime.text = TimeUtility.SecondsToHMS(seconds);
|
}
|
}
|
|
void DisplayBatchState()
|
{
|
if (m_BatchAlchemy != null)
|
{
|
m_BatchAlchemy.SetActive(state == 0);
|
if (state == 0)
|
{
|
var vipLevel = vipModel.GetPrivilegeVipLv(VipPrivilegeType.BatchAlchemyFairy);
|
var satisfyBatch = true;
|
if (model.selectAlchemyType == AlchemyType.Fairy
|
&& PlayerDatas.Instance.baseData.VIPLv < vipLevel)
|
{
|
satisfyBatch = false;
|
}
|
else if (model.selectAlchemyType == AlchemyType.Normal
|
&& PlayerDatas.Instance.baseData.LV < model.normalBatchAlchemyLevel)
|
{
|
satisfyBatch = false;
|
}
|
m_BatchAlchemy.SetColorful(m_BatchAlchemyLabel, model.GetCanAlchemyCount(model.selectAlchemy) > 0
|
&& satisfyBatch);
|
}
|
}
|
}
|
|
void DisplayAnimation()
|
{
|
m_ContainerMaterials.SetActive(false);
|
m_ContainerFlyMaterials.SetActive(true);
|
List<Item> materials;
|
model.TryGetAlchemyMaterials(model.selectAlchemy, out materials);
|
for (int i = 0; i < m_FlyMaterials.Length; i++)
|
{
|
m_FlyMaterials[i].SetActive(i < materials.Count);
|
if (i < materials.Count)
|
{
|
var itemConfig = ItemConfig.Get(materials[i].id);
|
m_FlyIcons[i].SetSprite(itemConfig.IconKey);
|
m_AlchemyFlyEffects[i].Play();
|
var parent = m_AlchemyFlyEffects[i].target.transform.Find("Animation/GuadianAnimation");
|
if (parent != null)
|
{
|
m_FlyMaterials[i].SetParent(parent);
|
m_FlyMaterials[i].transform.localPosition = Vector3.zero;
|
}
|
}
|
else
|
{
|
m_AlchemyFlyEffects[i].StopImediatly();
|
}
|
}
|
|
StartCoroutine(Co_DisplayAnimation());
|
}
|
|
IEnumerator Co_DisplayAnimation()
|
{
|
m_AlchemyBoomEffect.Play();
|
yield return WaitingForSecondConst.WaitMS700;
|
m_ContainerFlyMaterials.SetActive(false);
|
for (int i = 0; i < m_FlyMaterials.Length; i++)
|
{
|
m_FlyMaterials[i].SetParent(m_ContainerFlyMaterials);
|
}
|
animationStep = false;
|
m_State = model.GetStoveState(model.selectAlchemy);
|
DisplayStove();
|
}
|
|
private void SelectAlchemyRefresh()
|
{
|
m_State = model.GetStoveState(model.selectAlchemy);
|
DisplayStove();
|
DisplayAlchemyMaterials();
|
}
|
|
private void AlchemyStateRefresh()
|
{
|
animationStep = false;
|
|
if (model.isServerPrepare)
|
{
|
var newState = model.GetStoveState(model.selectAlchemy);
|
if (newState == 1 && state == 0)
|
{
|
animationStep = true;
|
}
|
}
|
if (!animationStep)
|
{
|
m_State = model.GetStoveState(model.selectAlchemy);
|
DisplayStove();
|
DisplayAlchemyMaterials();
|
}
|
|
if (animationStep)
|
{
|
DisplayAnimation();
|
}
|
}
|
|
private void PlayerDataRefreshEvent(PlayerDataType dataType)
|
{
|
if (dataType == PlayerDataType.FreePoint)
|
{
|
DisplayReikiPoint();
|
}
|
else if (dataType == PlayerDataType.VIPLv
|
|| dataType == PlayerDataType.LV)
|
{
|
DisplayBatchState();
|
}
|
}
|
|
private void LateUpdate()
|
{
|
timer += Time.deltaTime;
|
if (timer >= 0.5f)
|
{
|
timer = 0f;
|
PerSecond();
|
}
|
|
if (state == 1)
|
{
|
AlchemyTime alchemyTime;
|
if (model.TryGetAlchemyStartTime(model.selectAlchemy, out alchemyTime))
|
{
|
var config = AlchemyConfig.Get(model.selectAlchemy);
|
var startTime = TimeUtility.GetTime(alchemyTime.startTick);
|
var seconds = config.NeedTime * alchemyTime.count
|
- (float)(TimeUtility.ServerNow - startTime).TotalSeconds;
|
m_TimeSlider.value = Mathf.Clamp01(seconds / (config.NeedTime * alchemyTime.count));
|
}
|
}
|
}
|
|
private void PerSecond()
|
{
|
if (animationStep)
|
{
|
return;
|
}
|
|
var _state = model.GetStoveState(model.selectAlchemy);
|
|
if (_state == state)
|
{
|
if (state == 1)
|
{
|
DisplayAlchemyTime();
|
}
|
}
|
else
|
{
|
state = _state;
|
}
|
}
|
|
private void BatchAlchemy()
|
{
|
int alchemyId;
|
if (model.IsStoveAlcheming(model.selectAlchemyType, out alchemyId))
|
{
|
SysNotifyMgr.Instance.ShowTip("AlchemingError");
|
return;
|
}
|
if (model.selectAlchemyType == AlchemyType.Fairy)
|
{
|
var vipLevel = vipModel.GetPrivilegeVipLv(VipPrivilegeType.BatchAlchemyFairy);
|
if (PlayerDatas.Instance.baseData.VIPLv < vipLevel)
|
{
|
SysNotifyMgr.Instance.ShowTip("BatchAlchemyError_Vip");
|
return;
|
}
|
}
|
if (model.selectAlchemyType == AlchemyType.Normal)
|
{
|
if (PlayerDatas.Instance.baseData.LV < model.normalBatchAlchemyLevel)
|
{
|
SysNotifyMgr.Instance.ShowTip("BatchAlchemyError_Level", model.normalBatchAlchemyLevel);
|
return;
|
}
|
}
|
Item item;
|
if (!model.IsAlchemyEnoughMaterial(model.selectAlchemy, out item))
|
{
|
SysNotifyMgr.Instance.ShowTip("BatchAlchemyError");
|
return;
|
}
|
List<Item> materials;
|
if (model.TryGetAlchemyMaterials(model.selectAlchemy, out materials))
|
{
|
for (int i = 0; i < materials.Count; i++)
|
{
|
var mat = materials[i];
|
var count = packModel.GetItemCountByID(PackType.Item, mat.id);
|
if (model.selectAlchemyType == AlchemyType.Normal)
|
LimitedTimeLuxuryGiftModel.Instance.IsItemIdShow(21, mat.id, mat.count, 1, 0);
|
if (model.selectAlchemyType == AlchemyType.Fairy)
|
LimitedTimeLuxuryGiftModel.Instance.IsItemIdShow(22, mat.id, mat.count, 1, 0);
|
}
|
}
|
AlchemyBatchWin.alchemyId = model.selectAlchemy;
|
WindowCenter.Instance.Open<AlchemyBatchWin>();
|
}
|
|
private void OnFunc()
|
{
|
switch (state)
|
{
|
case 0:
|
int alchemyId;
|
if (model.IsStoveAlcheming(model.selectAlchemyType, out alchemyId))
|
{
|
SysNotifyMgr.Instance.ShowTip("AlchemingError");
|
return;
|
}
|
Item item;
|
if (!model.IsAlchemyEnoughMaterial(model.selectAlchemy, out item))
|
{
|
ItemTipUtility.Show(item.id);
|
return;
|
}
|
if (model.selectAlchemyType == AlchemyType.Normal)
|
{
|
AlchemyDrugUseLimit drugUseLimit;
|
var itemId = AlchemyConfig.Get(model.selectAlchemy).AlchemItemID;
|
var itemCount = playerPack.GetItemCountByID(PackType.Item, itemId);
|
if (model.TryGetAlchemyUseLimit(itemId, out drugUseLimit))
|
{
|
var canEatCount = drugUseLimit.GetUseLimit() - drugUseLimit.eatTimes - itemCount;
|
if (canEatCount < 1)
|
{
|
string title = Language.Get("L1003");
|
string info = Language.Get("MaximumMumberOfPills");
|
ConfirmCancel.ShowPopConfirm(title, info, (bool isOk) =>
|
{
|
if (isOk)
|
{
|
SendAlchemyPackage();
|
}
|
});
|
return;
|
}
|
}
|
}
|
//var succRate = model.GetAlchemySuccRate(model.selectAlchemy);
|
//if (succRate / 100 < 100)
|
//{
|
// ConfirmCancel.ShowPopConfirm(Language.Get("Mail101"), Language.Get("AlchemyLowRateRemind"), (bool isOk) =>
|
// {
|
// if (isOk)
|
// {
|
// SendAlchemyPackage();
|
// }
|
// });
|
// return;
|
//}
|
break;
|
case 1:
|
ConfirmCancel.ShowPopConfirm(Language.Get("Mail101"), Language.Get("StopAlchemyDrugRemind"), (bool isOk) =>
|
{
|
if (isOk)
|
{
|
SendAlchemyPackage();
|
}
|
});
|
return;
|
}
|
Item item1;
|
List<Item> materials;
|
if (model.TryGetAlchemyMaterials(model.selectAlchemy, out materials))
|
{
|
for (int i = 0; i < materials.Count; i++)
|
{
|
var mat = materials[i];
|
var count = packModel.GetItemCountByID(PackType.Item, mat.id);
|
if (model.selectAlchemyType == AlchemyType.Normal)
|
LimitedTimeLuxuryGiftModel.Instance.IsItemIdShow(21, mat.id, mat.count, 1, 0);
|
if (model.selectAlchemyType == AlchemyType.Fairy)
|
LimitedTimeLuxuryGiftModel.Instance.IsItemIdShow(22, mat.id, mat.count, 1, 0);
|
}
|
}
|
SendAlchemyPackage();
|
}
|
|
void SendAlchemyPackage()
|
{
|
var pak = new CA576_tagCMPlayerRefine();
|
pak.AlchemyID = (uint)model.selectAlchemy;
|
pak.AlchemyTimes = 1;
|
switch (state)
|
{
|
case 0:
|
pak.DoType = 1;
|
break;
|
case 1:
|
pak.DoType = 2;
|
break;
|
case 2:
|
pak.DoType = 3;
|
|
if (FunctionalGuideCenter.Instance.ExistUnderwayGuide(131))
|
{
|
FunctionalGuideCenter.Instance.RemoveGuide(131);
|
}
|
break;
|
}
|
GameNetSystem.Instance.SendInfo(pak);
|
}
|
|
private void RefreshItemCountEvent(PackType packType, int index, int itemId)
|
{
|
if (packType == PackType.Item)
|
{
|
List<Item> items;
|
if (model.TryGetAlchemyMaterials(model.selectAlchemy, out items))
|
{
|
if (items.FindIndex((x) =>
|
{
|
return x.id == itemId;
|
}) != -1)
|
{
|
DisplayAlchemyMaterials();
|
DisplayBatchState();
|
}
|
}
|
}
|
}
|
|
private void OnReikiRootPointRefresh()
|
{
|
DisplayReikiPoint();
|
}
|
|
public void Dispose()
|
{
|
model.selectAlchemyRefresh -= SelectAlchemyRefresh;
|
model.alchemyStateRefresh -= AlchemyStateRefresh;
|
PlayerDatas.Instance.playerDataRefreshEvent -= PlayerDataRefreshEvent;
|
packModel.refreshItemCountEvent -= RefreshItemCountEvent;
|
reikiRootModel.onReikiRootPointRefresh -= OnReikiRootPointRefresh;
|
|
StopAllCoroutines();
|
animationStep = false;
|
}
|
}
|
|
[Serializable]
|
public class AlchemyMaterial
|
{
|
[SerializeField] Transform m_ContainerItem;
|
[SerializeField] Image m_Icon;
|
[SerializeField] Text m_Count;
|
[SerializeField] Transform m_ContainerLock;
|
[SerializeField] Button m_Func;
|
|
PackModel packModel { get { return ModelCenter.Instance.GetModel<PackModel>(); } }
|
|
public void Display(Item item)
|
{
|
Display(item.id, item.count);
|
}
|
|
public void Display(int id, int count)
|
{
|
var itemConfig = ItemConfig.Get(id);
|
m_Icon.SetSprite(itemConfig.IconKey);
|
|
var packCount = packModel.GetItemCountByID(PackType.Item, id);
|
var enough = packCount >= count;
|
var label = UIHelper.AppendColor(enough ? TextColType.Green : TextColType.Red, packCount.ToString());
|
m_Count.text = StringUtility.Contact(label, "/", count);
|
|
m_Func.SetListener(() =>
|
{
|
ItemTipUtility.Show(id);
|
});
|
}
|
|
public void SetLock(bool _lock)
|
{
|
m_ContainerLock.SetActive(_lock);
|
m_ContainerItem.SetActive(!_lock);
|
}
|
}
|
}
|
|
