using System.Collections.Generic;
|
using UnityEngine;
|
using LitJson;
|
using System;
|
|
//方案预设：流派设定
|
// 这里存储的是流派id设定; 功能预设在各个功能里如命格的是存在命格背包对应，武将是另外通知使用的格子索引
|
public class FuncPresetManager : GameSystemManager<FuncPresetManager>
|
{
|
//预设方案：功能类型（含全局和子功能，配表）-子方案ID-预设方案解锁名称信息
|
Dictionary<int, Dictionary<int, FuncPreset>> m_FuncPresetDict = new Dictionary<int, Dictionary<int, FuncPreset>>();
|
|
//对应 BattlePreSetType 战斗类型 ： 全局方案ID
|
Dictionary<int, int> battlePreSetDict = new Dictionary<int, int>();
|
|
//所有预设方案的保存信息 全局方案ID ：子功能类型（配表）：子方案ID
|
Dictionary<int, Dictionary<int, int>> m_FuncPresetSaveDict = new Dictionary<int, Dictionary<int, int>>();
|
public Action<int> OnFuncPresetUseDataEvent; //0 更换子方案，1 更换全局方案，2 解锁/更改名
|
|
public const int GlobalDefaultPresetID = 1; //默认全局方案ID
|
public const int FuncDefaultPresetID = 1; //默认子功能方案ID
|
|
public int[] openConditions; //流派预设（也叫全局方案/战斗方案） 开启条件【开服第N天，主线通关X-Y，定军阁达到N层】
|
|
public Action<int, int, int, bool> OnSelectPresetEvent; //选择功能预设方案事件 功能类型 方案ID 是否展开
|
|
public override void Init()
|
{
|
DTC0102_tagCDBPlayer.beforePlayerDataInitializeEventOnRelogin += OnBeforePlayerDataInitialize;
|
ParseConfig();
|
}
|
|
public override void Release()
|
{
|
DTC0102_tagCDBPlayer.beforePlayerDataInitializeEventOnRelogin -= OnBeforePlayerDataInitialize;
|
}
|
|
|
void ParseConfig()
|
{
|
var config = FuncConfigConfig.Get("FuncPreset");
|
openConditions = JsonMapper.ToObject<int[]>(config.Numerical1);
|
}
|
|
private void OnBeforePlayerDataInitialize()
|
{
|
battlePreSetDict.Clear();
|
m_FuncPresetSaveDict.Clear();
|
InitFuncPreset();
|
}
|
|
//流派解锁
|
public bool IsOpen()
|
{
|
//特殊约定
|
if (!FuncOpen.Instance.IsFuncOpen((int)FuncOpenEnum.FuncPreset))
|
return false;
|
|
if (TimeUtility.OpenDay < openConditions[0] - 1)
|
{
|
return false;
|
}
|
if (PlayerDatas.Instance.baseData.ExAttr1 / 100 <= openConditions[1])
|
{
|
return false;
|
}
|
if (!WarlordPavilionManager.Instance.TryGetHistoryMaxFinishProgress(out int layerNum, out int levelNum))
|
return false;
|
|
if (layerNum*100 + levelNum < openConditions[2])
|
{
|
return false;
|
}
|
|
return true;
|
}
|
|
//提前显示
|
public bool IsPreShow()
|
{
|
return FuncOpen.Instance.IsFuncOpen((int)FuncOpenEnum.FuncPreset);
|
}
|
|
void InitFuncPreset()
|
{
|
m_FuncPresetDict.Clear();
|
// if (!FuncOpen.Instance.IsFuncOpen((int)FuncOpenEnum.Mingge))
|
// {
|
// return;
|
// }
|
var keys = PresetUnlockConfig.GetKeys();
|
for (int i = 0; i < keys.Count; i++)
|
{
|
var config = PresetUnlockConfig.Get(keys[i]);
|
if (!m_FuncPresetDict.ContainsKey(config.PresetType))
|
{
|
m_FuncPresetDict[config.PresetType] = new Dictionary<int, FuncPreset>();
|
}
|
m_FuncPresetDict[config.PresetType][config.PresetID] = new FuncPreset()
|
{
|
unLock = config.UnlockType == 0,
|
PresetName = Language.Get(config.PresetType == 1 ? "FuncPreset10" : "Mingge13", config.PresetID)
|
};
|
}
|
}
|
|
public void UpdateFuncPresetInfoList(HB161_tagSCFuncPresetInfoList vNetData)
|
{
|
for (int i = 0; i < vNetData.FuncCnt; i++)
|
{
|
var funcPresetInfo = vNetData.FuncPresetList[i];
|
if (!m_FuncPresetDict.ContainsKey(funcPresetInfo.FuncPresetType))
|
{
|
m_FuncPresetDict[funcPresetInfo.FuncPresetType] = new Dictionary<int, FuncPreset>();
|
}
|
for (int j = 0; j < funcPresetInfo.PresetCnt; j++)
|
{
|
var preset = funcPresetInfo.PresetList[j];
|
//该功能预设解锁状态，按预设ID二进制位运算记录是否已解锁
|
bool _unlock = (funcPresetInfo.UnlockState & (1 << preset.PresetID)) != 0;
|
m_FuncPresetDict[funcPresetInfo.FuncPresetType][preset.PresetID] = new FuncPreset()
|
{
|
unLock = _unlock,
|
PresetName = string.IsNullOrEmpty(preset.PresetName) ?
|
Language.Get(funcPresetInfo.FuncPresetType == 1 ? "FuncPreset10" : "Mingge13", preset.PresetID) : preset.PresetName,
|
};
|
}
|
}
|
|
OnFuncPresetUseDataEvent?.Invoke(2);
|
}
|
|
//每个全局方案的存储信息
|
public void UpdateFuncPresetUseData(HB162_tagSCFuncPresetSwitchInfo vNetData)
|
{
|
for (int i = 0; i < vNetData.BatPresetCnt; i++)
|
{
|
var batPreset = vNetData.BatPresetList[i];
|
if (!m_FuncPresetSaveDict.ContainsKey(batPreset.BatPresetID))
|
{
|
m_FuncPresetSaveDict[batPreset.BatPresetID] = new Dictionary<int, int>();
|
}
|
for (int j = 0; j < batPreset.FuncCnt; j++)
|
{
|
var funcPreset = batPreset.FuncPresetList[j];
|
m_FuncPresetSaveDict[batPreset.BatPresetID][funcPreset.FuncPresetType] = funcPreset.FuncPresetID;
|
}
|
}
|
OnFuncPresetUseDataEvent?.Invoke(0);
|
}
|
|
//当前战斗功能的全局方案ID使用情况
|
public void UpdateBatPresetNowUseInfo(HB163_tagSCBatPresetSwitchInfo netPack)
|
{
|
for (int i = 0; i < netPack.BatFuncCnt; i++)
|
{
|
battlePreSetDict[netPack.BatPresetList[i].BatPresetType] = netPack.BatPresetList[i].BatPresetID;
|
}
|
OnFuncPresetUseDataEvent?.Invoke(1);
|
}
|
|
//根据战斗获取全局方案ID，如果取不到默认方案1
|
public int GetGlobalPresetID(int battlePresetType)
|
{
|
if (battlePreSetDict.ContainsKey(battlePresetType))
|
{
|
return battlePreSetDict[battlePresetType];
|
}
|
return 1;
|
}
|
|
//指定战斗模式下获取子功能方案ID，如果取不到默认方案1
|
public int GetFuncPresetIDByBattleType(int battlePresetType, int funcType)
|
{
|
int globalPresetID = GetGlobalPresetID(battlePresetType);
|
if (m_FuncPresetSaveDict.ContainsKey(globalPresetID) && m_FuncPresetSaveDict[globalPresetID].ContainsKey(funcType))
|
{
|
return m_FuncPresetSaveDict[globalPresetID][funcType];
|
}
|
return 1;
|
}
|
|
//指定流派获取子功能方案ID，如果取不到默认方案1
|
public int GetFuncPresetID(int globalPresetID, int funcType)
|
{
|
if (m_FuncPresetSaveDict.ContainsKey(globalPresetID) && m_FuncPresetSaveDict[globalPresetID].ContainsKey(funcType))
|
{
|
return m_FuncPresetSaveDict[globalPresetID][funcType];
|
}
|
return 1;
|
}
|
|
//获取当前流派下的子功能的方案ID，如果取不到默认方案1
|
public int GetFuncPresetID(int funcType)
|
{
|
int globalPresetID = GetGlobalPresetID((int)BattlePreSetType.Story);
|
if (m_FuncPresetSaveDict.ContainsKey(globalPresetID) && m_FuncPresetSaveDict[globalPresetID].ContainsKey(funcType))
|
{
|
return m_FuncPresetSaveDict[globalPresetID][funcType];
|
}
|
return 1;
|
}
|
|
//指定预设信息
|
public FuncPreset GetFuncPreset(int funcType, int presetID)
|
{
|
if (m_FuncPresetDict.ContainsKey(funcType) && m_FuncPresetDict[funcType].ContainsKey(presetID))
|
{
|
return m_FuncPresetDict[funcType][presetID];
|
}
|
return null;
|
}
|
|
// 这里虽然传的是 battleType，但是实际还是根据全局方案ID做对应修改；如果这个全局方案其他地方有使用也是同步变化
|
public void SaveFuncPresetID(int battleType, int funcType, int presetID)
|
{
|
if (funcType == 1)
|
{
|
SaveBattlePresetID(battleType, presetID);
|
return;
|
}
|
var pack = new CB262_tagCSFuncPresetSwitch();
|
pack.FuncPresetType = (byte)funcType;
|
pack.PresetID = (byte)presetID;
|
pack.BatPresetID = (byte)GetGlobalPresetID(battleType);
|
GameNetSystem.Instance.SendInfo(pack);
|
}
|
|
public void SaveBattlePresetID(int battleType, int globalPresetID)
|
{
|
var pack = new CB263_tagCSBatPresetSwitch();
|
pack.BatPresetID = (byte)globalPresetID;
|
pack.BatPresetType = (byte)battleType;
|
GameNetSystem.Instance.SendInfo(pack);
|
}
|
|
public void UnLockPreset(int funcType, int presetID)
|
{
|
var pack = new CB260_tagCSFuncPresetUnlock();
|
pack.FuncPresetType = (byte)funcType;
|
pack.PresetID = (byte)presetID;
|
GameNetSystem.Instance.SendInfo(pack);
|
SysNotifyMgr.Instance.ShowTip("FuncPreset2");
|
}
|
|
//要显示的方案数量; 根据情况会包含未解锁
|
//a. 按元宝解锁的为逐一开启，默认开启x个，第x+1个显示条件需要【流派预设】功能开启, 可解锁后逐一保留一个锁住的（直到全开启）；
|
//b. 按功能条件开启的，如果默认只开其一个方案的情况不显示，达到下一个方案的条件满足后全显示；默认大于1个的情况直接全显示
|
public int GetShowFuncPresetCount(int funcType)
|
{
|
var unlockCnt = GetUnlockCnt(funcType);
|
var maxCount = PresetUnlockConfig.GetFuncPresetMaxCount(funcType);
|
var unlockType = PresetUnlockConfig.GetUnlockType(funcType);
|
if (unlockType == 2)
|
{
|
//命格按推演境界解锁
|
//只有1个方案则不显示，大于1个则全显示
|
if (unlockCnt == 1)
|
{
|
var config = PresetUnlockConfig.GetPresetUnlockConfig(funcType, 2);
|
if (MinggeManager.Instance.m_GanwuLV >= config.UnlockValue)
|
{
|
return maxCount;
|
}
|
return 0;
|
}
|
return maxCount;
|
}
|
if (!IsOpen())
|
{
|
//未开启时，默认大于1则显示
|
return unlockCnt == 1 ? 0 : unlockCnt;
|
}
|
|
return unlockCnt == maxCount ? unlockCnt : unlockCnt + 1;
|
}
|
|
public int GetUnlockCnt(int funcType)
|
{
|
int count = 0;
|
if (m_FuncPresetDict.ContainsKey(funcType))
|
{
|
for (int i = 0; i < m_FuncPresetDict[funcType].Count; i++)
|
{
|
if (m_FuncPresetDict[funcType][i + 1].unLock)
|
{
|
count++;
|
}
|
}
|
}
|
return count;
|
}
|
|
//选择方案：解锁或选中
|
// 选择方案返回true，否则返回false
|
public bool ClickFuncPreset(int battleType, int funcType, int id)
|
{
|
var config = PresetUnlockConfig.GetPresetUnlockConfig(funcType, id);
|
var data = GetFuncPreset(funcType, id);
|
if (!data.unLock)
|
{
|
// 未解锁 则购买
|
if (config.UnlockType == 1)
|
{
|
ConfirmCancel.MoneyIconToggleConfirmByType(ToggleCheckType.FuncPreset, config.UnlockValue, 1,
|
Language.Get("FuncPreset12", UIHelper.GetIconNameWithMoneyType(1), config.UnlockValue), () =>
|
{
|
if (!UIHelper.CheckMoneyCount(1, config.UnlockValue, 2))
|
return;
|
|
UnLockPreset(funcType, id);
|
});
|
}
|
else if (config.UnlockType == 2)
|
{
|
|
if (MinggeManager.Instance.m_GanwuLV < config.UnlockValue)
|
{
|
SysNotifyMgr.Instance.ShowTip("FuncPreset1", config.UnlockValue);
|
return false;
|
}
|
UnLockPreset(funcType, id);
|
}
|
return false;
|
}
|
|
SaveFuncPresetID(battleType, funcType, id);
|
return true;
|
}
|
|
// 点击流派/防守预设按钮
|
public void ClickBattlePreset(int battleType)
|
{
|
if (battleType > 1)
|
{
|
UIManager.Instance.OpenWindow<FuncPresetWin>(battleType);
|
return;
|
}
|
|
if (!IsOpen())
|
{
|
UIManager.Instance.OpenWindow<FuncPresetUnLockWin>(battleType);
|
}
|
else
|
{
|
UIManager.Instance.OpenWindow<FuncPresetWin>(battleType);
|
}
|
}
|
|
//功能类的满足条件后，提示红点手动解锁
|
// 某个方案是否要红点提示
|
public bool ShowRed(int funcType, int id)
|
{
|
if (funcType == (int)FuncPresetType.Mingge)
|
{
|
var presetData = GetFuncPreset(funcType, id);
|
if (presetData.unLock)
|
{
|
return false;
|
}
|
var config = PresetUnlockConfig.GetPresetUnlockConfig(funcType, id);
|
if (config != null && config.UnlockType == 2 && MinggeManager.Instance.m_GanwuLV < config.UnlockValue)
|
{
|
return false;
|
}
|
return true;
|
}
|
|
return false;
|
}
|
|
public int GetNeedShowRedID(int funcType)
|
{
|
if (funcType == (int)FuncPresetType.Mingge)
|
{
|
var maxCnt = PresetUnlockConfig.GetFuncPresetMaxCount(funcType); ;
|
for (int i = 1; i <= maxCnt; i++)
|
{
|
if (ShowRed(funcType, i))
|
{
|
return i;
|
}
|
}
|
}
|
return 0;
|
}
|
|
|
}
|
|
|
public class FuncPreset
|
{
|
public bool unLock; //是否解锁
|
public string PresetName; //预设名称
|
}
|
|
|
|
//战斗功能区分对应存储全局方案ID，如演武场防守用哪个全局方案ID的分类
|
public enum BattlePreSetType
|
{
|
None = 0,
|
Story = 1, //主线
|
Arena = 2, //演武场防守
|
|
}
|
|
//功能预设类型 1-全局战斗；2-阵容；3-命格；
|
public enum FuncPresetType
|
{
|
Global = 1,
|
Team = 2,
|
Mingge = 3,
|
}
|
