using System.Collections.Generic;
|
using UnityEngine;
|
using LitJson;
|
using System;
|
using System.Linq;
|
|
|
public class MinggeManager : GameSystemManager<MinggeManager>
|
{
|
public int m_GanwuLV; //感悟等级，从1开始
|
public int m_GanwuExp; //当前感悟等级经验，每级从0开始
|
public int m_Lingying; //当前灵应值
|
public event Action OnMinggeInfoUpdate;
|
|
public int equipShowPresetID; // 显示装备时，当前的子方案ID
|
public ItemModel selectFloorEquip;
|
|
public bool waitTYOPPack;
|
public event Action<int> OnOPCallbackEvent;
|
|
public Dictionary<int, long> minggeAttrDict = new Dictionary<int, long>();
|
|
|
|
public bool qlNotNotify;
|
|
//配置
|
public const int TotleEquip = 12; //一套装备的总数
|
public int[] unlockAttrLVList; //解锁属性所需命格物品等级列表
|
public int tyItemID; //推演物品ID
|
public int qlItemID; //祈灵物品ID
|
public int[] minggeItemTypeList; //可携带意象的卦玉类型列表
|
public List<int> minggeSkillEquipPlaceList = new List<int>(); //可携带意象的卦玉类型的装备位置
|
public int maxSuiteSkillCount;
|
public int[] minggeSkillTypeIDList; //意向效果技能TypeID列表
|
public int deitemID; //卦玉分解的物品ID
|
|
public override void Init()
|
{
|
DTC0102_tagCDBPlayer.beforePlayerDataInitializeEventOnRelogin += OnBeforePlayerDataInitializeRelogin;
|
DTC0102_tagCDBPlayer.beforePlayerDataInitializeEvent += OnBeforePlayerDataInitialize;
|
PackManager.Instance.RefreshItemEvent += RefreshItemEvent;
|
DTCA814_tagMCMakeItemAnswer.MakeItemAnswerEvent += OnEquipResult;
|
DTC0403_tagPlayerLoginLoadOK.playerLoginOkEvent += OnPlayerLoginOK;
|
FuncPresetManager.Instance.OnFuncPresetUseDataEvent += OnFuncPresetUseDataEvent;
|
GlobalTimeEvent.Instance.MSEvent += OnMSEvent;
|
FuncOpen.Instance.OnFuncStateChangeEvent += OnFuncStateChangeEvent;
|
ParseConfig();
|
}
|
|
public override void Release()
|
{
|
DTC0102_tagCDBPlayer.beforePlayerDataInitializeEventOnRelogin -= OnBeforePlayerDataInitializeRelogin;
|
DTC0102_tagCDBPlayer.beforePlayerDataInitializeEvent -= OnBeforePlayerDataInitialize;
|
PackManager.Instance.RefreshItemEvent -= RefreshItemEvent;
|
DTCA814_tagMCMakeItemAnswer.MakeItemAnswerEvent -= OnEquipResult;
|
DTC0403_tagPlayerLoginLoadOK.playerLoginOkEvent -= OnPlayerLoginOK;
|
FuncPresetManager.Instance.OnFuncPresetUseDataEvent -= OnFuncPresetUseDataEvent;
|
GlobalTimeEvent.Instance.MSEvent -= OnMSEvent;
|
FuncOpen.Instance.OnFuncStateChangeEvent -= OnFuncStateChangeEvent;
|
}
|
|
|
void ParseConfig()
|
{
|
var config = FuncConfigConfig.Get("MinggeCfg");
|
unlockAttrLVList = JsonMapper.ToObject<int[]>(config.Numerical1);
|
tyItemID = int.Parse(config.Numerical2);
|
qlItemID = int.Parse(config.Numerical3);
|
|
config = FuncConfigConfig.Get("MinggeTY");
|
deitemID = ConfigParse.GetMultipleStr<int>(config.Numerical1)[0];
|
minggeItemTypeList = JsonMapper.ToObject<int[]>(config.Numerical4);
|
minggeSkillTypeIDList = JsonMapper.ToObject<int[]>(config.Numerical5);
|
|
config = FuncConfigConfig.Get("MinggeTY2");
|
fightAttrIDList = JsonMapper.ToObject<int[]>(config.Numerical1);
|
deFightAttrIDList = JsonMapper.ToObject<int[]>(config.Numerical2);
|
autoCostCntList = JsonMapper.ToObject<int[]>(config.Numerical3);
|
autoTYCDs = JsonMapper.ToObject<float[]>(config.Numerical4);
|
needOfficialRank = int.Parse(config.Numerical5);
|
|
for (int i = 0; i < minggeItemTypeList.Length; i++)
|
{
|
minggeSkillEquipPlaceList.Add(MGGuayuTypeConfig.Get(minggeItemTypeList[i]).EquipPlace);
|
}
|
maxSuiteSkillCount = minggeSkillEquipPlaceList.Count;
|
|
}
|
|
private void OnBeforePlayerDataInitializeRelogin()
|
{
|
m_GanwuLV = 1;
|
m_GanwuExp = 0;
|
m_Lingying = 0;
|
isStartAuto = false;
|
isPauseAuto = false;
|
qlNotNotify = false;
|
decomposeMGList.Clear();
|
}
|
|
private void OnBeforePlayerDataInitialize()
|
{
|
waitTYOPPack = false;
|
}
|
|
void OnFuncStateChangeEvent(int id)
|
{
|
if (id == (int)FuncOpenEnum.Mingge)
|
{
|
InitAutoSet();
|
}
|
}
|
|
void OnPlayerLoginOK()
|
{
|
InitAutoSet();
|
UpdateRedPoint();
|
redpointAuto.state = RedPointState.None;
|
isMGEquipUIDecomposeToggle = true;
|
}
|
|
private void OnEquipResult(HA814_tagMCMakeItemAnswer info)
|
{
|
if (info.MakeType == (int)MakeType.MinggeTY)
|
{
|
waitTYOPPack = false;
|
autoTYTime = Time.time;
|
CalcEquip();
|
OnOPCallbackEvent?.Invoke(0);
|
}
|
else if (info.MakeType == (int)MakeType.MinggeEquip)
|
{
|
waitTYOPPack = false;
|
autoTYTime = Time.time;
|
CalcEquip();
|
OnOPCallbackEvent?.Invoke(1);
|
}
|
|
}
|
|
void RefreshItemEvent(PackType type, int index, int itemID)
|
{
|
if (type == PackType.Item && (itemID == tyItemID || itemID == qlItemID))
|
{
|
UpdateRedPoint();
|
}
|
}
|
|
//处理未处理的命格
|
public bool CalcEquip()
|
{
|
var items = PackManager.Instance.GetItems(PackType.MinggeDrop);
|
if (items.IsNullOrEmpty())
|
{
|
if (UIManager.Instance.IsOpened<MinggeEquipWin>())
|
{
|
UIManager.Instance.CloseWindow<MinggeEquipWin>();
|
}
|
return false;
|
}
|
Debug.Log("命格掉落背包中的物品数量：" + items.Count);
|
|
foreach (var item in items)
|
{
|
if (OpenMinggeEquipWin(item))
|
{
|
//需要玩家处理装备
|
if (!decomposeMGList.IsNullOrEmpty())
|
{
|
SendDecompose(decomposeMGList.ToArray());
|
decomposeMGList.Clear();
|
}
|
|
return true;
|
}
|
}
|
|
//需要玩家处理装备
|
if (!decomposeMGList.IsNullOrEmpty())
|
{
|
SendDecompose(decomposeMGList.ToArray());
|
decomposeMGList.Clear();
|
}
|
return false;
|
}
|
|
public void UpdateMinggeInfo(HB132_tagSCMinggeInfo netPack)
|
{
|
var beforeLV = m_GanwuLV;
|
m_GanwuLV = netPack.GanwuLV;
|
m_GanwuExp = (int)netPack.GanwuExp;
|
m_Lingying = (int)netPack.Lingying;
|
|
if (beforeLV != m_GanwuLV)
|
{
|
UpdateRedPoint();
|
beforeLV = m_GanwuLV;
|
}
|
OnMinggeInfoUpdate?.Invoke();
|
}
|
|
void OnFuncPresetUseDataEvent(int type)
|
{
|
UpdateRedPoint();
|
}
|
|
|
//获取当前在使用方案的技能信息 意向技能类型ID：【物品guid..】
|
public Dictionary<int, List<string>> GetMinggeSkillTypeIDDict()
|
{
|
var presetID = FuncPresetManager.Instance.GetFuncPresetIDByBattleType((int)BattlePreSetType.Story, (int)FuncPresetType.Mingge);
|
var startIndex = (presetID - 1) * TotleEquip;//对应卦玉背包索引 = (套编号-1)*12+装备位-1
|
|
var dict = new Dictionary<int, List<string>>();
|
for (int i = 0; i < minggeSkillEquipPlaceList.Count; i++)
|
{
|
var equip = PackManager.Instance.GetItemByIndex(PackType.Mingge, startIndex + minggeSkillEquipPlaceList[i] - 1);
|
var skillID = EquipModel.Instance.GetEquipSkillID(equip);
|
if (skillID == 0) continue;
|
if (dict.ContainsKey(skillID))
|
{
|
dict[skillID].Add(equip.guid);
|
}
|
else
|
{
|
dict[skillID] = new List<string>() { equip.guid };
|
}
|
}
|
return dict;
|
}
|
|
//获取指定方案的技能信息 意向技能类型ID：数量
|
public Dictionary<int, int> GetMinggeSkillCountDictByPresetID(int presetID)
|
{
|
var startIndex = (presetID - 1) * TotleEquip;//对应卦玉背包索引 = (套编号-1)*12+装备位-1
|
|
var dict = new Dictionary<int, int>();
|
for (int i = 0; i < minggeSkillEquipPlaceList.Count; i++)
|
{
|
var equip = PackManager.Instance.GetItemByIndex(PackType.Mingge, startIndex + minggeSkillEquipPlaceList[i] - 1);
|
var skillID = EquipModel.Instance.GetEquipSkillID(equip);
|
if (skillID == 0) continue;
|
if (dict.ContainsKey(skillID))
|
{
|
dict[skillID] += 1;
|
}
|
else
|
{
|
dict[skillID] = 1;
|
}
|
}
|
return dict;
|
}
|
|
public bool OpenMinggeEquipWin(ItemModel equip)
|
{
|
if (equip == null)
|
{
|
return false;
|
}
|
|
if (!DTC0403_tagPlayerLoginLoadOK.finishedLogin)
|
{
|
return false;
|
}
|
|
//自动处理： 判断分解 和战力高低 和决定是哪个方案下的装备对比
|
int autoPreseetID;
|
if (!AutoCalcMG(equip, out autoPreseetID))
|
{
|
return false;
|
}
|
|
|
//非自动情况下，默认当前方案
|
if (autoPreseetID == 0)
|
{
|
equipShowPresetID = FuncPresetManager.Instance.GetFuncPresetIDByBattleType((int)BattlePreSetType.Story, (int)FuncPresetType.Mingge);
|
}
|
else
|
{
|
equipShowPresetID = autoPreseetID;
|
}
|
selectFloorEquip = equip;
|
if (UIManager.Instance.IsOpened<MinggeWin>())
|
{
|
if (selectFloorEquip.config.EquipPlace == 0)
|
{
|
Debug.LogError($"配置错误物品 {selectFloorEquip.itemId} 装备位为0");
|
return true;
|
}
|
if (!UIManager.Instance.IsOpened<MinggeEquipWin>())
|
{
|
UIManager.Instance.OpenWindow<MinggeEquipWin>();
|
}
|
else
|
{
|
//刷新界面
|
var win = UIManager.Instance.GetUI<MinggeEquipWin>();
|
win.RefreshUI();
|
}
|
}
|
else
|
{
|
//打开界面 且外部提醒有需要处理的装备，在关闭界面的时候判断重置标识
|
isPauseAuto = true;
|
redpointAuto.state = RedPointState.Simple;
|
}
|
return true;
|
|
}
|
|
public int GetPackIndex(int presetID, int equipPlace)
|
{
|
return (presetID - 1) * TotleEquip + equipPlace - 1;//对应卦玉背包索引 = (套编号-1)*12+装备位-1
|
}
|
|
public void SendTY(int count)
|
{
|
// if (CalcEquip())
|
// {
|
// return;
|
// }
|
// if (waitTYOPPack)
|
// {
|
// return;
|
// }
|
|
// if (!ItemLogicUtility.CheckItemCount(PackType.Item, tyItemID, count, 2))
|
// {
|
// return;
|
// }
|
if (waitTYOPPack)
|
{
|
return;
|
}
|
waitTYOPPack = true;
|
|
var pack = new CB250_tagCSMinggeTuiyan();
|
pack.Count = (byte)count;
|
GameNetSystem.Instance.SendInfo(pack);
|
|
}
|
|
public void SendChangeMingge(int selectMinggePresetID, int dropIndex, bool autodec)
|
{
|
var pack = new CB252_tagCSMinggeEquip();
|
pack.MGNum = (byte)selectMinggePresetID;
|
pack.Index = (byte)dropIndex;
|
pack.AutoDec = (byte)(autodec ? 1 : 0);
|
GameNetSystem.Instance.SendInfo(pack);
|
autoTYTime = Time.time;
|
waitTYOPPack = true;
|
}
|
|
public void SendDecompose(byte[] itemIndexList)
|
{
|
var pack = new CB251_tagCSMinggeDecompose();
|
pack.IndexList = itemIndexList;
|
pack.Count = (byte)itemIndexList.Length;
|
GameNetSystem.Instance.SendInfo(pack);
|
autoTYTime = Time.time;
|
waitTYOPPack = true;
|
}
|
|
|
public void RefrehMinggeAttrs()
|
{
|
minggeAttrDict.Clear(); //身上命格属性重置
|
|
var minggePresetID = FuncPresetManager.Instance.GetFuncPresetIDByBattleType((int)BattlePreSetType.Story, (int)FuncPresetType.Mingge);
|
var starIndex = (minggePresetID - 1) * TotleEquip;
|
|
for (int i = starIndex; i < starIndex + TotleEquip; i++)
|
{
|
var equip = PackManager.Instance.GetItemByIndex(PackType.Mingge, i);
|
if (equip == null)
|
{
|
continue;
|
}
|
|
var fightIDAttrs = EquipModel.Instance.GetEquipFightAttrs(equip);
|
var fightValueAttrs = EquipModel.Instance.GetEquipFightValues(equip);
|
if (fightIDAttrs != null)
|
{
|
for (int j = 0; j < fightIDAttrs.Count; j++)
|
{
|
if (!minggeAttrDict.ContainsKey(fightIDAttrs[j]))
|
{
|
minggeAttrDict[fightIDAttrs[j]] = fightValueAttrs[j];
|
}
|
else
|
{
|
minggeAttrDict[fightIDAttrs[j]] += fightValueAttrs[j];
|
}
|
}
|
}
|
}
|
|
}
|
|
public List<int> GetQLRate(int value)
|
{
|
var keys = MGLingyingQualityConfig.GetKeys();
|
keys.Sort();
|
|
int littleValue = 0;
|
int bigValue = 0;
|
for (int i = 0; i < keys.Count; i++)
|
{
|
var key = keys[i];
|
if (value < key)
|
{
|
bigValue = key;
|
littleValue = keys[i - 1];
|
break;
|
}
|
else if (i == keys.Count - 1 && value >= key)
|
{
|
bigValue = key;
|
littleValue = key;
|
}
|
}
|
|
var littleRateList = MGLingyingQualityConfig.Get(littleValue).ItemColorWeightList;
|
if (littleValue == bigValue)
|
{
|
return littleRateList.ToList();
|
}
|
var bigRateList = MGLingyingQualityConfig.Get(bigValue).ItemColorWeightList;
|
|
//对比下一阶段的灵应值配置，比较同品质的权重差值与两个阶段的灵应差值求出每增加1点灵应对某个品质的权重变化值，变化值可能提升或者降低
|
|
var rateList = new List<int>();
|
|
for (int i = 0; i < littleRateList.Length; i++)
|
{
|
var littleRateValue = littleRateList[i];
|
var bigRateValue = bigRateList[i];
|
var diffRate = littleRateValue + (bigRateValue - littleRateValue) / (float)(bigValue - littleValue) * (value - littleValue);
|
rateList.Add((int)diffRate);
|
}
|
|
return rateList;
|
}
|
|
|
#region 红点
|
Redpoint tmpRP = new Redpoint(MainRedDot.MainAffairsRedpoint, MainRedDot.RedPoint_Mingge);
|
Redpoint redpointMG = new Redpoint(MainRedDot.RedPoint_Mingge, MainRedDot.RedPoint_Mingge * 10 + 1);
|
Redpoint redpointPray = new Redpoint(MainRedDot.RedPoint_Mingge, MainRedDot.RedPoint_Mingge * 10 + 2);
|
Redpoint redpointPreset = new Redpoint(MainRedDot.RedPoint_Mingge, MainRedDot.RedPoint_Mingge * 10 + 3);
|
public Redpoint redpointAuto = new Redpoint(MainRedDot.RedPoint_Mingge, MainRedDot.RedPoint_Mingge * 10 + 4);
|
void UpdateRedPoint()
|
{
|
|
redpointMG.state = RedPointState.None;
|
redpointPray.state = RedPointState.None;
|
redpointPreset.state = RedPointState.None;
|
if (!FuncOpen.Instance.IsFuncOpen((int)FuncOpenEnum.Mingge))
|
{
|
return;
|
}
|
if (PackManager.Instance.GetItemCountByID(PackType.Item, tyItemID) > 0 && !isStartAuto)
|
{
|
redpointMG.state = RedPointState.Simple;
|
}
|
|
if (PackManager.Instance.GetItemCountByID(PackType.Item, qlItemID) > 0)
|
{
|
redpointPray.state = RedPointState.Simple;
|
}
|
if (FuncPresetManager.Instance.GetNeedShowRedID((int)FuncPresetType.Mingge) != 0)
|
{
|
redpointPreset.state = RedPointState.Simple;
|
}
|
}
|
|
#endregion
|
|
|
#region 自动设置
|
|
public int[] fightAttrIDList;
|
public int[] deFightAttrIDList;
|
public int[] autoCostCntList;
|
public float[] autoTYCDs; //秒
|
public float autoTYTime;
|
public int needOfficialRank;
|
|
public bool isMGEquipUIDecomposeToggle; //装备对比界面 是否勾选了分解
|
|
//公共部分
|
public bool autoCostToggle
|
{
|
get
|
{
|
return LocalSave.GetBool($"MGCost_{PlayerDatas.Instance.baseData.PlayerID}", false);
|
}
|
set
|
{
|
LocalSave.SetBool($"MGCost_{PlayerDatas.Instance.baseData.PlayerID}", value);
|
}
|
}
|
|
//勾选后展示用的
|
public int autoCostCount
|
{
|
get
|
{
|
return LocalSave.GetInt($"MGCostCnt_{PlayerDatas.Instance.baseData.PlayerID}", 1);
|
}
|
set
|
{
|
LocalSave.SetInt($"MGCostCnt_{PlayerDatas.Instance.baseData.PlayerID}", value);
|
}
|
}
|
|
//实际消耗用的 不勾选的时候默认返回1
|
public int useAutoCostCnt
|
{
|
get
|
{
|
if (!autoCostToggle)
|
{
|
return 1;
|
}
|
return autoCostCount;
|
}
|
|
}
|
public bool autoSpeedUP
|
{
|
get
|
{
|
return LocalSave.GetBool($"MGSpeedUP_{PlayerDatas.Instance.baseData.PlayerID}", false);
|
}
|
set
|
{
|
LocalSave.SetBool($"MGSpeedUP_{PlayerDatas.Instance.baseData.PlayerID}", value);
|
}
|
}
|
|
|
public event Action ChangeAutoEvent;
|
|
bool m_IsStartAuto;
|
//是否开启自动
|
public bool isStartAuto
|
{
|
get
|
{
|
return m_IsStartAuto;
|
}
|
private set
|
{
|
m_IsStartAuto = value;
|
isPauseAuto = false;
|
decomposeMGList.Clear();
|
UpdateRedPoint();
|
ChangeAutoEvent?.Invoke();
|
}
|
}
|
public bool isPauseAuto; //开启的情况下，因为某些原因暂停自动
|
|
|
//每套方案各自的信息
|
public List<MinggeAutoSet> autoSetList = new List<MinggeAutoSet>();
|
|
public void InitAutoSet()
|
{
|
autoSetList.Clear();
|
if (!FuncOpen.Instance.IsFuncOpen((int)FuncOpenEnum.Mingge))
|
{
|
return;
|
}
|
var maxCnt = PresetUnlockConfig.GetFuncPresetMaxCount((int)FuncPresetType.Mingge);
|
for (int i = 1; i <= maxCnt; i++)
|
{
|
var autoSet = new MinggeAutoSet();
|
autoSet.presetID = i;
|
autoSetList.Add(autoSet);
|
}
|
}
|
|
public MinggeAutoSet GetMGAutoSet(int presetID)
|
{
|
for (int i = 0; i < autoSetList.Count; i++)
|
{
|
if (autoSetList[i].presetID == presetID)
|
{
|
return autoSetList[i];
|
}
|
}
|
return null;
|
}
|
|
//检查至少要有一个启动中
|
public bool CanChangeStartToFalse(int presetID)
|
{
|
for (int i = 0; i < autoSetList.Count; i++)
|
{
|
if (autoSetList[i].presetID != presetID && autoSetList[i].startToggle)
|
{
|
return true;
|
}
|
}
|
return false;
|
}
|
|
public void StartAuto(bool isStart)
|
{
|
if (isStart)
|
{
|
|
bool canStart = false;
|
for (int i = 0; i < autoSetList.Count; i++)
|
{
|
if (autoSetList[i].startToggle)
|
{
|
canStart = true;
|
}
|
}
|
|
if (!canStart)
|
{
|
SysNotifyMgr.Instance.ShowTip("MinggeAuto2");
|
isStartAuto = false;
|
return;
|
}
|
|
|
if (!ItemLogicUtility.CheckItemCount(PackType.Item, tyItemID, useAutoCostCnt, 2))
|
{
|
isStartAuto = false;
|
TimingGiftManager.Instance.TryAddWhenInsufficient(6, PackType.Item, tyItemID, useAutoCostCnt);
|
return;
|
}
|
UIManager.Instance.CloseWindow<MinggeAutoSetWin>();
|
TimingGiftManager.Instance.TryAddWhenExactConsumption(6, PackType.Item, tyItemID, useAutoCostCnt);
|
|
}
|
|
isStartAuto = isStart;
|
if (isStartAuto)
|
{
|
//先处理装备一次，后续通过物品包自动处理
|
CalcEquip();
|
}
|
else
|
{
|
SysNotifyMgr.Instance.ShowTip("MinggeAuto1");
|
}
|
}
|
|
//自动处理装备，返回成功代表需要手动处理装备，其他情况一律返回false如分解 或防范
|
bool AutoCalcMG(ItemModel mgEquip, out int autoPreseetID)
|
{
|
autoPreseetID = 0;
|
if (mgEquip == null)
|
{
|
return false;
|
}
|
|
if (!isStartAuto)
|
return true;
|
if (!isMGEquipUIDecomposeToggle && UIManager.Instance.IsOpened<MinggeEquipWin>())
|
{
|
//玩家没有勾选装备对比界面的分解， 那么自动不可处理分解
|
return true;
|
}
|
|
//优先判断当前方案命格
|
var curPresetID = FuncPresetManager.Instance.GetFuncPresetID((int)FuncPresetType.Mingge);
|
var autoSet = GetMGAutoSet(curPresetID);
|
|
|
if (!CanDecomposeMG(mgEquip, autoSet))
|
{
|
autoPreseetID = curPresetID;
|
return true;
|
}
|
//判断其他方案
|
for (int i = 0; i < autoSetList.Count; i++)
|
{
|
if (autoSetList[i].presetID == curPresetID)
|
{
|
continue;
|
}
|
if (!CanDecomposeMG(mgEquip, autoSetList[i]))
|
{
|
autoPreseetID = autoSetList[i].presetID;
|
return true;
|
}
|
}
|
|
// SendDecompose(new byte[] { (byte)mgEquip.gridIndex });
|
AddDecomposeMG((byte)mgEquip.gridIndex);
|
return false;
|
}
|
|
List<byte> decomposeMGList = new List<byte>();
|
void AddDecomposeMG(byte index)
|
{
|
if (decomposeMGList.Contains(index))
|
{
|
return;
|
}
|
decomposeMGList.Add(index);
|
}
|
|
|
//单方案判断，未开启的也当作可分解，外层多套判断有一套需要就是需要穿戴
|
bool CanDecomposeMG(ItemModel mgEquip, MinggeAutoSet autoSet)
|
{
|
if (!autoSet.startToggle)
|
{
|
return true;
|
}
|
if (mgEquip.config.ItemColor < autoSet.quanlity)
|
{
|
//品质不满足
|
return true;
|
}
|
if (!autoSet.fightPowerToggle && !autoSet.fightAttrToggle && !autoSet.skillToggle)
|
{
|
//都不勾选
|
return false;
|
}
|
|
|
//先判断技能，再判断属性 最后战力（比较消耗）
|
|
//技能勾选的情况
|
if (autoSet.skillToggle && !autoSet.fightPowerToggle && !autoSet.fightAttrToggle)
|
{
|
return !IsSkillOK(mgEquip, autoSet);
|
}
|
|
if (autoSet.skillToggle && autoSet.fightAttrToggle && !autoSet.fightPowerToggle)
|
{
|
if (autoSet.andOrSkillToggle == 1)
|
{
|
return !(IsSkillOK(mgEquip, autoSet) && IsFightAttrOK(mgEquip, autoSet));
|
}
|
else
|
{
|
return !(IsSkillOK(mgEquip, autoSet) || IsFightAttrOK(mgEquip, autoSet));
|
}
|
}
|
|
if (autoSet.skillToggle && autoSet.fightPowerToggle && !autoSet.fightAttrToggle)
|
{
|
if (autoSet.andOrSkillToggle == 1)
|
{
|
return !(IsSkillOK(mgEquip, autoSet) && IsFightPowerOK(mgEquip, autoSet));
|
}
|
else
|
{
|
return !(IsSkillOK(mgEquip, autoSet) || IsFightPowerOK(mgEquip, autoSet));
|
}
|
}
|
|
if (autoSet.skillToggle && autoSet.fightPowerToggle && autoSet.fightAttrToggle)
|
{
|
if (autoSet.andOrSkillToggle == 1 && autoSet.andOrFPToggle == 1)
|
{
|
return !(IsSkillOK(mgEquip, autoSet) && IsFightAttrOK(mgEquip, autoSet) && IsFightPowerOK(mgEquip, autoSet));
|
}
|
else if (autoSet.andOrSkillToggle == 1 && autoSet.andOrFPToggle == 2)
|
{
|
return !((IsSkillOK(mgEquip, autoSet) && IsFightAttrOK(mgEquip, autoSet)) || IsFightPowerOK(mgEquip, autoSet));
|
}
|
else if (autoSet.andOrSkillToggle == 2 && autoSet.andOrFPToggle == 1)
|
{
|
return !((IsFightAttrOK(mgEquip, autoSet) && IsFightPowerOK(mgEquip, autoSet)) || IsSkillOK(mgEquip, autoSet));
|
}
|
else
|
{
|
return !(IsSkillOK(mgEquip, autoSet) || IsFightAttrOK(mgEquip, autoSet) || IsFightPowerOK(mgEquip, autoSet));
|
}
|
}
|
|
//属性勾选的情况
|
if (autoSet.fightAttrToggle && !autoSet.fightPowerToggle)
|
{
|
return !IsFightAttrOK(mgEquip, autoSet);
|
}
|
if (autoSet.fightAttrToggle && autoSet.fightPowerToggle)
|
{
|
if (autoSet.andOrFPToggle == 1)
|
{
|
return !(IsFightAttrOK(mgEquip, autoSet) && IsFightPowerOK(mgEquip, autoSet));
|
}
|
else
|
{
|
return !(IsFightAttrOK(mgEquip, autoSet) || IsFightPowerOK(mgEquip, autoSet));
|
}
|
}
|
|
//战力勾选的情况
|
if (autoSet.fightPowerToggle)
|
{
|
return !IsFightPowerOK(mgEquip, autoSet);
|
}
|
|
return false;
|
}
|
|
//技能是否满足条件
|
bool IsSkillOK(ItemModel mgEquip, MinggeAutoSet autoSet)
|
{
|
var skillID = EquipModel.Instance.GetEquipSkillID(mgEquip);
|
if (skillID == 0)
|
{
|
return false;
|
}
|
if (autoSet.skillID == 0)
|
{
|
//任意
|
return true;
|
}
|
if (skillID != autoSet.skillID)
|
{
|
return false;
|
}
|
|
return true;
|
}
|
|
//属性是否满足条件
|
bool IsFightAttrOK(ItemModel mgEquip, MinggeAutoSet autoSet)
|
{
|
var fightAttrs = EquipModel.Instance.GetEquipFightAttrs(mgEquip);
|
|
// 如果指定了属性，则检查装备是否包含该属性
|
bool deFightAttrOK = autoSet.deFightAttrID == 0 || fightAttrs.Contains(autoSet.deFightAttrID);
|
bool fightAttrOK = autoSet.fightAttrID == 0 || fightAttrs.Contains(autoSet.fightAttrID);
|
|
return deFightAttrOK && fightAttrOK;
|
}
|
|
bool IsFightPowerOK(ItemModel mgEquip, MinggeAutoSet autoSet)
|
{
|
long showFightPower = FightPowerManager.Instance.GetFightPowerMinggeChange(mgEquip, autoSet.presetID);
|
if (showFightPower > 0)
|
{
|
return true;
|
}
|
return false;
|
}
|
|
|
public void AutoTY()
|
{
|
//先处理装备，再推演
|
// 每一套方案都要综合判断
|
// if (CalcEquip())
|
// {
|
// return;
|
// }
|
if (UIManager.Instance.IsOpened<MinggeEquipWin>())
|
{
|
return;
|
}
|
|
if (!PackManager.Instance.GetItems(PackType.MinggeDrop).IsNullOrEmpty())
|
{
|
return;
|
}
|
|
if (!ItemLogicUtility.CheckItemCount(PackType.Item, tyItemID, useAutoCostCnt, 1))
|
{
|
isStartAuto = false;
|
SysNotifyMgr.Instance.ShowTip("MinggeAuto1");
|
TimingGiftManager.Instance.TryAddWhenInsufficient(6, PackType.Item, tyItemID, useAutoCostCnt);
|
return;
|
}
|
|
TimingGiftManager.Instance.TryAddWhenExactConsumption(6, PackType.Item, tyItemID, useAutoCostCnt);
|
|
autoTYTime = Time.time;
|
SendTY(useAutoCostCnt);
|
|
|
}
|
|
void OnMSEvent()
|
{
|
if (isPauseAuto)
|
{
|
return;
|
}
|
if (!isStartAuto)
|
{
|
return;
|
}
|
if (Time.time - autoTYTime < autoTYCDs[autoSpeedUP ? 1 : 0])
|
{
|
if (!waitTYOPPack)
|
{
|
if (UIManager.Instance.IsOpened<MinggeWin>())
|
{
|
//显示特效
|
var ui = UIManager.Instance.GetUI<MinggeWin>();
|
if (!ui.tyEffect.isPlaying)
|
{
|
ui.tyEffect.onComplete = null;
|
ui.tyEffect.Play();
|
if (autoSpeedUP)
|
{
|
ui.tyEffect.SetSpeed(autoTYCDs[0] / autoTYCDs[1]);
|
}
|
else
|
{
|
ui.tyEffect.SetSpeed(1);
|
}
|
}
|
}
|
|
}
|
return;
|
}
|
|
AutoTY();
|
}
|
|
#endregion
|
}
|
|
public class MinggeAutoSet
|
{
|
public int presetID;
|
public bool startToggle
|
{
|
get
|
{
|
return LocalSave.GetBool($"MGStart{presetID}_{PlayerDatas.Instance.baseData.PlayerID}", false);
|
}
|
set
|
{
|
LocalSave.SetBool($"MGStart{presetID}_{PlayerDatas.Instance.baseData.PlayerID}", value);
|
}
|
}
|
public int quanlity
|
{
|
get
|
{
|
return LocalSave.GetInt($"MGQuanlity{presetID}_{PlayerDatas.Instance.baseData.PlayerID}", 1);
|
}
|
set
|
{
|
LocalSave.SetInt($"MGQuanlity{presetID}_{PlayerDatas.Instance.baseData.PlayerID}", value);
|
}
|
}
|
public bool fightPowerToggle
|
{
|
get
|
{
|
return LocalSave.GetBool($"MGFightPower{presetID}_{PlayerDatas.Instance.baseData.PlayerID}", false);
|
}
|
set
|
{
|
LocalSave.SetBool($"MGFightPower{presetID}_{PlayerDatas.Instance.baseData.PlayerID}", value);
|
}
|
}
|
//0 都不勾选 1同时 2 或者
|
public int andOrFPToggle
|
{
|
get
|
{
|
return LocalSave.GetInt($"MGAndOrFP{presetID}_{PlayerDatas.Instance.baseData.PlayerID}", 0);
|
}
|
set
|
{
|
LocalSave.SetInt($"MGAndOrFP{presetID}_{PlayerDatas.Instance.baseData.PlayerID}", value);
|
}
|
}
|
|
public bool fightAttrToggle
|
{
|
get
|
{
|
return LocalSave.GetBool($"MGFightAttr{presetID}_{PlayerDatas.Instance.baseData.PlayerID}", false);
|
}
|
set
|
{
|
LocalSave.SetBool($"MGFightAttr{presetID}_{PlayerDatas.Instance.baseData.PlayerID}", value);
|
}
|
}
|
public int fightAttrID
|
{
|
get
|
{
|
return LocalSave.GetInt($"MGFightAttrID{presetID}_{PlayerDatas.Instance.baseData.PlayerID}", 0);
|
}
|
set
|
{
|
LocalSave.SetInt($"MGFightAttrID{presetID}_{PlayerDatas.Instance.baseData.PlayerID}", value);
|
}
|
}
|
public int deFightAttrID
|
{
|
get
|
{
|
return LocalSave.GetInt($"MGDeFightAttrID{presetID}_{PlayerDatas.Instance.baseData.PlayerID}", 0);
|
}
|
set
|
{
|
LocalSave.SetInt($"MGDeFightAttrID{presetID}_{PlayerDatas.Instance.baseData.PlayerID}", value);
|
}
|
}
|
public bool skillToggle
|
{
|
get
|
{
|
return LocalSave.GetBool($"MGSkill{presetID}_{PlayerDatas.Instance.baseData.PlayerID}", false);
|
}
|
set
|
{
|
LocalSave.SetBool($"MGSkill{presetID}_{PlayerDatas.Instance.baseData.PlayerID}", value);
|
}
|
}
|
public int skillID
|
{
|
get
|
{
|
return LocalSave.GetInt($"MGSkillID{presetID}_{PlayerDatas.Instance.baseData.PlayerID}", 0);
|
}
|
set
|
{
|
LocalSave.SetInt($"MGSkillID{presetID}_{PlayerDatas.Instance.baseData.PlayerID}", value);
|
}
|
}
|
//0 都不勾选 1同时 2 或者
|
public int andOrSkillToggle
|
{
|
get
|
{
|
return LocalSave.GetInt($"MGAndOrSkill{presetID}_{PlayerDatas.Instance.baseData.PlayerID}", 0);
|
}
|
set
|
{
|
LocalSave.SetInt($"MGAndOrSkill{presetID}_{PlayerDatas.Instance.baseData.PlayerID}", value);
|
}
|
}
|
|
|
|
}
|
