using System.Collections;
|
using System.Collections.Generic;
|
using UnityEngine;
|
|
using System;
|
using System.Linq;
|
using vnxbqy.UI;
|
|
namespace vnxbqy.UI
|
{
|
|
|
public class MagicianModel : Model, IBeforePlayerDataInitialize, IPlayerLoginOk
|
{
|
public event Action onSelectUpdate;
|
|
PackModel packModel
|
{
|
get { return ModelCenter.Instance.GetModel<PackModel>(); }
|
}
|
|
bool serverInited = false;
|
|
public override void Init()
|
{
|
ParseConfig();
|
packModel.refreshItemCountEvent += RefreshPackItem;
|
FuncOpen.Instance.OnFuncStateChangeEvent += OnFuncStateChangeEvent;
|
PlayerDatas.Instance.playerDataRefreshEvent += PlayerDataRefreshInfoEvent;
|
}
|
|
private void OnFuncStateChangeEvent(int func)
|
{
|
if (func == (int)FuncOpenEnum.GodWeapon)
|
{
|
UpdateRedPoint();
|
}
|
}
|
|
private void RefreshPackItem(PackType packType, int index, int id)
|
{
|
if (packType != PackType.Item)
|
{
|
return;
|
}
|
UpdateRedPoint();
|
}
|
|
private void PlayerDataRefreshInfoEvent(PlayerDataType refreshType)
|
{
|
if (refreshType == PlayerDataType.LV)
|
{
|
UpdateRedPoint();
|
}
|
}
|
|
public override void UnInit()
|
{
|
packModel.refreshItemCountEvent -= RefreshPackItem;
|
FuncOpen.Instance.OnFuncStateChangeEvent -= OnFuncStateChangeEvent;
|
PlayerDatas.Instance.playerDataRefreshEvent -= PlayerDataRefreshInfoEvent;
|
}
|
|
public void OnBeforePlayerDataInitialize()
|
{
|
serverInited = false;
|
foreach (var godWeapon in godWeaponInfoDict.Values)
|
{
|
godWeapon.level = 0;
|
godWeapon.exp = 0;
|
}
|
}
|
|
public void OnPlayerLoginOk()
|
{
|
serverInited = true;
|
UpdateRedPoint();
|
}
|
|
private Dictionary<int, int[]> godWeaponLevelUpCost = new Dictionary<int, int[]>();
|
public List<int> godWeaponTypes { get; private set; }
|
public Dictionary<int, int> godWeaponBoxDict { get; private set; } //key 神兵石礼包 value 神兵类型
|
public Dictionary<int, string> godWeaponIcons { get; private set; }
|
public Dictionary<int, Dictionary<int, int>> godWeaponSkillDict = new Dictionary<int, Dictionary<int, int>>();
|
Dictionary<int, List<GodWeaponCondition>> godWeaponConditions = new Dictionary<int, List<GodWeaponCondition>>();
|
Dictionary<int, int> playerLevelConditions = new Dictionary<int, int>();
|
public List<int> godWeaponSorts = new List<int>();
|
Dictionary<int, AutoHammerCost> autoHammerCostDict = new Dictionary<int, AutoHammerCost>();
|
Dictionary<int, int> exteriorPowerDict = new Dictionary<int, int>();
|
Dictionary<int, int> godWeaponSkillEffect = new Dictionary<int, int>();
|
Dictionary<int, int> singleHarmmerExp = new Dictionary<int, int>();
|
int[] autoHammerExpArea { get; set; }
|
int[] autoHammerCount { get; set; }
|
|
int m_SelectType = 0;
|
public int selectType
|
{
|
get { return m_SelectType; }
|
set
|
{
|
if (m_SelectType != value)
|
{
|
m_SelectType = value;
|
if (onSelectUpdate != null)
|
{
|
onSelectUpdate();
|
}
|
}
|
}
|
}
|
|
public int selectItemIndex = 0;
|
public int gotoType = 0;
|
|
public int autoHammerLevel { get; set; }
|
|
public int hammerAudioId { get; private set; }
|
public int audioLength { get; private set; }
|
void ParseConfig()
|
{
|
var godWeaponBox = FuncConfigConfig.Get("GodWeaponBox");
|
godWeaponBoxDict = ConfigParse.GetDic<int, int>(godWeaponBox.Numerical1);
|
|
godWeaponTypes = GodWeaponConfig.GetGodWeaponType();
|
for (int i = 0; i < godWeaponTypes.Count; i++)
|
{
|
GodWeaponInfo godWeapon = new GodWeaponInfo()
|
{
|
exp = 0,
|
level = 0,
|
type = godWeaponTypes[i],
|
};
|
godWeaponInfoDict.Add(godWeapon.type, godWeapon);
|
|
if (!redpointDict.ContainsKey(godWeapon.type))
|
{
|
Redpoint redpoint = new Redpoint(MAGICAIN_REDPOINT, MAGICAIN_REDPOINT * MAGICAIN_INTERVAL + godWeapon.type);
|
redpointDict.Add(godWeapon.type, redpoint);
|
redpoint.state = RedPointState.None;
|
}
|
|
var config = FuncConfigConfig.Get(string.Format("GodWeapon{0}", godWeaponTypes[i]));
|
int[] itemarray = ConfigParse.GetMultipleStr<int>(config.Numerical1);
|
godWeaponLevelUpCost.Add(godWeaponTypes[i], itemarray);
|
}
|
|
godWeaponIcons = new Dictionary<int, string>();
|
var _cfg = FuncConfigConfig.Get("GodModel");
|
var _godWeaponJson = LitJson.JsonMapper.ToObject(_cfg.Numerical2);
|
foreach (var _key in _godWeaponJson.Keys)
|
{
|
var _godWeaponType = int.Parse(_key);
|
if (!godWeaponIcons.ContainsKey(_godWeaponType))
|
{
|
godWeaponIcons.Add(_godWeaponType, _godWeaponJson[_key].ToString());
|
}
|
}
|
|
var configs = GodWeaponConfig.GetValues();
|
for (int i = 0; i < configs.Count; i++)
|
{
|
if (configs[i].SkillID != 0)
|
{
|
Dictionary<int, int> _dict = null;
|
if (!godWeaponSkillDict.TryGetValue(configs[i].Type, out _dict))
|
{
|
_dict = new Dictionary<int, int>();
|
godWeaponSkillDict.Add(configs[i].Type, _dict);
|
}
|
_dict.Add(configs[i].Lv, configs[i].SkillID);
|
}
|
}
|
|
var conditionConfig = FuncConfigConfig.Get("GodWeaponActive");
|
var json = LitJson.JsonMapper.ToObject(conditionConfig.Numerical2);
|
foreach (var key in json.Keys)
|
{
|
var type = int.Parse(key);
|
List<GodWeaponCondition> list;
|
if (!godWeaponConditions.TryGetValue(type, out list))
|
{
|
list = new List<GodWeaponCondition>();
|
godWeaponConditions.Add(type, list);
|
}
|
int[][] conditions = LitJson.JsonMapper.ToObject<int[][]>(json[key].ToJson());
|
for (int i = 0; i < conditions.Length; i++)
|
{
|
var condition = conditions[i];
|
list.Add(new GodWeaponCondition()
|
{
|
type = condition[0],
|
level = condition[1],
|
});
|
}
|
}
|
|
json = LitJson.JsonMapper.ToObject(conditionConfig.Numerical3);
|
foreach (var key in json.Keys)
|
{
|
var type = int.Parse(key);
|
playerLevelConditions.Add(type, int.Parse(json[key].ToString()));
|
}
|
|
var sortConfig = FuncConfigConfig.Get("GodWeaponSort");
|
godWeaponSorts.AddRange(ConfigParse.GetMultipleStr<int>(sortConfig.Numerical1));
|
|
var autoHammerConfig = FuncConfigConfig.Get("GodWeaponAutoHammer");
|
if (autoHammerConfig != null)
|
{
|
autoHammerExpArea = ConfigParse.GetMultipleStr<int>(autoHammerConfig.Numerical1);
|
autoHammerCount = ConfigParse.GetMultipleStr<int>(autoHammerConfig.Numerical2);
|
singleHarmmerExp = ConfigParse.GetDic<int, int>(autoHammerConfig.Numerical3);
|
}
|
|
var funcConfig = FuncConfigConfig.Get("GodMagicExp");
|
json = LitJson.JsonMapper.ToObject(funcConfig.Numerical1);
|
foreach (var key in json.Keys)
|
{
|
var type = int.Parse(key);
|
var array = LitJson.JsonMapper.ToObject<int[]>(json[key].ToJson());
|
autoHammerCostDict.Add(type, new AutoHammerCost()
|
{
|
cost = array[0],
|
exp = array[1],
|
});
|
}
|
|
funcConfig = FuncConfigConfig.Get("MagicExterior");
|
json = LitJson.JsonMapper.ToObject(funcConfig.Numerical1);
|
foreach (var key in json.Keys)
|
{
|
var type = int.Parse(key);
|
var power = int.Parse(json[key].ToString());
|
exteriorPowerDict.Add(type, power);
|
}
|
|
funcConfig = FuncConfigConfig.Get("Godvideo");
|
hammerAudioId = int.Parse(funcConfig.Numerical1);
|
audioLength = int.Parse(funcConfig.Numerical2);
|
}
|
|
public int[] GetLevelUpItemByType(int type)
|
{
|
return godWeaponLevelUpCost[type];
|
}
|
|
public bool TryGetMagicType(int itemId,out int type)
|
{
|
type = 0;
|
foreach(var key in godWeaponLevelUpCost.Keys)
|
{
|
var costlist = godWeaponLevelUpCost[key];
|
if(costlist.Contains(itemId))
|
{
|
type = key;
|
return true;
|
}
|
}
|
|
if(godWeaponBoxDict.ContainsKey(itemId))
|
{
|
type = godWeaponBoxDict[itemId];
|
return true;
|
}
|
return false;
|
}
|
|
#region 红点
|
public const int MAGICAIN_REDPOINT = 10102;
|
public const int MAGICAIN_INTERVAL = 100;
|
public Dictionary<int, Redpoint> redpointDict = new Dictionary<int, Redpoint>();
|
Redpoint magicianPoint = new Redpoint(101, MAGICAIN_REDPOINT);
|
public Redpoint magicianRedpoint { get { return magicianPoint; } }
|
public void UpdateRedPoint()
|
{
|
foreach (var redpoint in redpointDict.Values)
|
{
|
redpoint.state = RedPointState.None;
|
}
|
if (!FuncOpen.Instance.IsFuncOpen((int)FuncOpenEnum.GodWeapon))
|
{
|
return;
|
}
|
foreach (var key in redpointDict.Keys)
|
{
|
if (IsGodWeaponMaxLevel(key))
|
{
|
continue;
|
}
|
if (!IsGodWeaponUnlock(key) && ContainsCondition(key))
|
{
|
if (SatisfyUnlockCondition(key))
|
{
|
redpointDict[key].state = RedPointState.Simple;
|
}
|
continue;
|
}
|
int[] items = GetLevelUpItemByType((int)key);
|
for (int i = 0; i < items.Length; i++)
|
{
|
if (packModel.GetItemCountByID(PackType.Item, items[i]) > 0)
|
{
|
redpointDict[key].state = RedPointState.Simple;
|
break;
|
}
|
}
|
}
|
}
|
|
public bool GetRedpointLightByType(int _type)
|
{
|
if (redpointDict.ContainsKey(_type))
|
{
|
return redpointDict[_type].state == RedPointState.Simple;
|
}
|
return false;
|
}
|
#endregion
|
|
public void HammerGodWeapon(int type)
|
{
|
GodWeaponInfo godWeaponInfo = GetGodWeaponInfo(type);
|
if (godWeaponInfo == null)
|
{
|
return;
|
}
|
if (IsGodWeaponMaxLevel(type))
|
{
|
ServerTipDetails.DisplayNormalTip(Language.Get("L1054"));
|
return;
|
}
|
int[] items = GetLevelUpItemByType(type);
|
if (selectItemIndex >= items.Length)
|
{
|
return;
|
}
|
var itemId = items[selectItemIndex];
|
ItemConfig itemConfig = ItemConfig.Get(itemId);
|
var count = packModel.GetItemCountByID(PackType.Item, itemId);
|
if (count < 1)
|
{
|
ItemTipUtility.Show(itemId);
|
return;
|
}
|
CA555_tagCMGodWeaponPlus pak = new CA555_tagCMGodWeaponPlus();
|
pak.WeaponType = (uint)type;
|
pak.ItemID = (uint)itemId;
|
pak.ItemCount = 1;
|
pak.IsAutoBuy = 0;
|
GameNetSystem.Instance.SendInfo(pak);
|
PlayHammerAudio();
|
}
|
|
DateTime lastAudioTime = DateTime.Now;
|
public void PlayHammerAudio()
|
{
|
var seconds = (float)audioLength / 1000;
|
if ((DateTime.Now - lastAudioTime).TotalSeconds < seconds)
|
{
|
return;
|
}
|
lastAudioTime = DateTime.Now;
|
SoundPlayer.Instance.PlayUIAudio(hammerAudioId);
|
}
|
|
public event Action godWeaponUpdate;
|
private Dictionary<int, GodWeaponInfo> godWeaponInfoDict = new Dictionary<int, GodWeaponInfo>();
|
public void UpdateGodWeaponInfo(HA31D_tagMCGodWeaponLVList package)
|
{
|
for (byte i = 0; i < package.WeaponNum; i++)
|
{
|
HA31D_tagMCGodWeaponLVList.tagMCGodWeaponLVInfo data = package.WeaponInfoList[i];
|
GodWeaponInfo godWeaponInfo = GetGodWeaponInfo(data.WeaponType);
|
if (godWeaponInfo != null)
|
{
|
var beforeLevel = godWeaponInfo.level;
|
godWeaponInfo.exp = data.WeaponExp;
|
godWeaponInfo.level = data.WeaponLV;
|
CheckActivate(godWeaponInfo.type, beforeLevel, data.WeaponLV);
|
}
|
}
|
UpdateRedPoint();
|
if (godWeaponUpdate != null)
|
{
|
godWeaponUpdate();
|
}
|
}
|
|
void CheckActivate(int _type, int _beforeLv, int _nowLv)
|
{
|
var _skillId = 0;
|
if (serverInited && _beforeLv != _nowLv
|
&& (_beforeLv == 0 || TryGetUnlockSkill(_type, _beforeLv, _nowLv, out _skillId)))
|
{
|
if (WindowCenter.Instance.IsOpen<MagicianWin>()
|
&& !NewBieCenter.Instance.inGuiding)
|
{
|
if (WindowCenter.Instance.IsOpen<HowToPlayWin>())
|
{
|
WindowCenter.Instance.Close<HowToPlayWin>();
|
}
|
ActivateShow.GodWeaponActivate(_type, _nowLv, _beforeLv);
|
}
|
}
|
}
|
|
public bool TryGetUnlockSkill(int _type, int _beforeLv, int _nowLv,out int _skillid)
|
{
|
_skillid = 0;
|
if (godWeaponSkillDict.ContainsKey(_type))
|
{
|
var _dict = godWeaponSkillDict[_type];
|
foreach (var _lv in _dict.Keys)
|
{
|
if (_beforeLv < _lv && _lv <= _nowLv)
|
{
|
_skillid = _dict[_lv];
|
return true;
|
}
|
}
|
}
|
return false;
|
}
|
|
public bool TryGetGodWeaponSkills(int type, out Dictionary<int, int> skills)
|
{
|
return godWeaponSkillDict.TryGetValue(type, out skills);
|
}
|
|
public GodWeaponInfo GetGodWeaponInfo(int type)
|
{
|
GodWeaponInfo data = null;
|
godWeaponInfoDict.TryGetValue(type, out data);
|
return data;
|
}
|
|
public bool IsGodWeaponMaxLevel(int _type)
|
{
|
var _data = GetGodWeaponInfo(_type);
|
var config = GodWeaponConfig.GetConfig(_type, _data.level + 1);
|
return config == null;
|
}
|
|
public bool IsGodWeaponHammerItem(int _type,int _itemId)
|
{
|
var items = GetLevelUpItemByType(_type);
|
if (items == null)
|
{
|
return false;
|
}
|
for (int i = 0; i < items.Length; i++)
|
{
|
if (items[i] == _itemId)
|
{
|
return true;
|
}
|
}
|
return false;
|
}
|
|
public bool IsGodWeaponUnlock(int type)
|
{
|
var godWeaponInfo = GetGodWeaponInfo(type);
|
if (godWeaponInfo != null && godWeaponInfo.level >= 1)
|
{
|
return true;
|
}
|
return false;
|
}
|
|
public bool SatisfyUnlockCondition(int type)
|
{
|
if (!playerLevelConditions.ContainsKey(type)
|
&& !godWeaponConditions.ContainsKey(type))
|
{
|
return true;
|
}
|
List<GodWeaponCondition> list;
|
bool satisfyCondition = false;
|
if (godWeaponConditions.TryGetValue(type, out list))
|
{
|
bool satisfy = true;
|
for (int i = 0; i < list.Count; i++)
|
{
|
var godWeaponInfo = GetGodWeaponInfo(list[i].type);
|
if (godWeaponInfo == null || godWeaponInfo.level < list[i].level)
|
{
|
satisfy = false;
|
break;
|
}
|
}
|
if (satisfy)
|
{
|
satisfyCondition = true;
|
}
|
}
|
var playerLevelLimit = 0;
|
if (TryGetPlayerLevelCondition(type, out playerLevelLimit))
|
{
|
if (PlayerDatas.Instance.baseData.LV >= playerLevelLimit)
|
{
|
satisfyCondition = true;
|
}
|
}
|
return satisfyCondition;
|
}
|
|
public int GetAutoHammerCount(int type)
|
{
|
ulong totalExp = 0;
|
var godWeaponInfo = GetGodWeaponInfo(type);
|
if (godWeaponInfo == null || autoHammerExpArea == null || autoHammerCount == null)
|
{
|
return 1;
|
}
|
var config = GodWeaponConfig.GetConfig(type, godWeaponInfo.level);
|
totalExp = (ulong)config.NeedExp;
|
var index = 0;
|
for (int i = 0; i < autoHammerExpArea.Length; i++)
|
{
|
if (totalExp < (ulong)autoHammerExpArea[i])
|
{
|
index = i;
|
break;
|
}
|
else
|
{
|
index++;
|
}
|
}
|
if (index < autoHammerCount.Length)
|
{
|
return autoHammerCount[index];
|
}
|
return autoHammerCount[autoHammerCount.Length - 1];
|
}
|
|
public int GetAutoHammerCount(int type, int index)
|
{
|
var items = GetLevelUpItemByType(type);
|
var moneyCount = GetAutoHammerCount(type);
|
AutoHammerCost autoHammerCost;
|
var totalExp = 0;
|
if (TryGetAutoHammerCost(type, out autoHammerCost))
|
{
|
totalExp = moneyCount * autoHammerCost.exp;
|
}
|
else if (singleHarmmerExp.ContainsKey(type))
|
{
|
totalExp = moneyCount * singleHarmmerExp[type];
|
}
|
var itemId = items[index];
|
var itemConfig = ItemConfig.Get(itemId);
|
var expCount = Mathf.CeilToInt((float)totalExp / itemConfig.EffectValueA1);
|
var packCount = packModel.GetItemCountByID(PackType.Item, itemId);
|
return Mathf.Min(expCount, packCount);
|
}
|
|
public bool ContainsCondition(int type)
|
{
|
return godWeaponConditions.ContainsKey(type) || playerLevelConditions.ContainsKey(type);
|
}
|
|
public bool TryGetConditions(int type, out List<GodWeaponCondition> list)
|
{
|
return godWeaponConditions.TryGetValue(type, out list);
|
}
|
|
public bool TryGetPlayerLevelCondition(int type,out int level)
|
{
|
return playerLevelConditions.TryGetValue(type, out level);
|
}
|
|
public bool IsGodWeaponMaxLevelByItem(int _itemId)
|
{
|
foreach (var _key in godWeaponLevelUpCost.Keys)
|
{
|
for (int i = 0; i < godWeaponLevelUpCost[_key].Length; i++)
|
{
|
if (godWeaponLevelUpCost[_key][i] == _itemId)
|
{
|
return IsGodWeaponMaxLevel(_key);
|
}
|
}
|
}
|
return false;
|
}
|
|
public bool TryGetAutoHammerCost(int type,out AutoHammerCost autoHammerCost)
|
{
|
return autoHammerCostDict.TryGetValue(type, out autoHammerCost);
|
}
|
|
public bool TryGetExteriorPower(int type, out int power)
|
{
|
return exteriorPowerDict.TryGetValue(type, out power);
|
}
|
|
public List<int> TryGetDisplaySkillLevels(int type)
|
{
|
List<int> displaySkillLevels = new List<int>();
|
Dictionary<int, int> dict;
|
if (TryGetGodWeaponSkills(type, out dict))
|
{
|
displaySkillLevels.AddRange(dict.Keys);
|
}
|
displaySkillLevels.Sort();
|
return displaySkillLevels;
|
}
|
}
|
|
public class GodWeaponInfo
|
{
|
public int type;
|
public int level;
|
public uint exp;
|
}
|
|
public struct GodWeaponCondition
|
{
|
public int type;
|
public int level;
|
}
|
|
public struct AutoHammerCost
|
{
|
public int cost;
|
public int exp;
|
}
|
}
|
|
