using LitJson;
|
using Snxxz.UI;
|
using System;
|
using System.Collections;
|
using System.Collections.Generic;
|
using System.Linq;
|
using TableConfig;
|
using UnityEngine;
|
namespace Snxxz.UI
|
{
|
public class RealmModel : Model, IPlayerLoginOk, IBeforePlayerDataInitialize
|
{
|
DungeonModel m_DungeonModel;
|
DungeonModel dungeonModel
|
{
|
get
|
{
|
return m_DungeonModel ?? (m_DungeonModel = ModelCenter.Instance.GetModel<DungeonModel>());
|
}
|
}
|
|
public void OnBeforePlayerDataInitialize()
|
{
|
PlayerDatas.Instance.realm.holdDataList.Clear();
|
openedRealmUpWin = false;
|
serverInited = false;
|
leaderId = 0;
|
cacheRealmLv = 0;
|
beforeRealmPoint = 0;
|
}
|
|
public override void Init()
|
{
|
ParseConfig();
|
FuncOpen.Instance.OnFuncStateChangeEvent += OnFuncStateChangeEvent;
|
PlayerDatas.Instance.PlayerDataRefreshInfoEvent += RefreshInfo;
|
StageManager.Instance.onStageLoadFinish += OnStageLoadFinish;
|
NewBieCenter.Instance.guideCompletedEvent += GuideCompletedEvent;
|
BossShowModel.Instance.bossShowCompletedEvent += BossShowCompletedEvent;
|
}
|
|
private int cacheMapId = 0;
|
|
bool serverInited = false;
|
|
public int cacheRealmLv { get; set; }
|
|
public bool openByDungeonStep { get; set; }
|
|
public int leaderId { get; set; }
|
|
public int beforeRealmPoint { get; private set; }
|
|
public int realmGuardianDisplayTime { get; private set; }
|
|
public bool realmDungeonState
|
{
|
get { return LocalSave.GetBool(StringUtility.Contact(PlayerDatas.Instance.PlayerId, "_RealmDungeon_Show")); }
|
set { LocalSave.SetBool(StringUtility.Contact(PlayerDatas.Instance.PlayerId, "_RealmDungeon_Show"), value); }
|
}
|
|
private void GuideCompletedEvent(int _id)
|
{
|
SnxxzGame.Instance.StartCoroutine(Co_GuideComplete());
|
}
|
|
IEnumerator Co_GuideComplete()
|
{
|
yield return null;
|
if (StageManager.Instance.CurrentStage is DungeonStage)
|
{
|
if (PlayerDatas.Instance.realm.holdDataList.Count > 0
|
&& !WindowCenter.Instance.CheckOpen<RealmUpHoldWin>() && !NewBieCenter.Instance.inGuiding && !BossShowModel.Instance.BossShowing)
|
{
|
WindowCenter.Instance.Open<RealmUpHoldWin>();
|
}
|
}
|
}
|
|
private void OnStageLoadFinish()
|
{
|
if (!(StageManager.Instance.CurrentStage is DungeonStage))
|
{
|
cacheMapId = 0;
|
return;
|
}
|
if (PlayerDatas.Instance.baseData.MapID == REALM_DUNGEON_ID)
|
{
|
cacheRealmLv = PlayerDatas.Instance.baseData.realmLevel;
|
}
|
if (PlayerDatas.Instance.realm.holdDataList.Count > 0
|
&& !WindowCenter.Instance.CheckOpen<RealmUpHoldWin>() && !NewBieCenter.Instance.inGuiding && !BossShowModel.Instance.BossShowing)
|
{
|
WindowCenter.Instance.Open<RealmUpHoldWin>();
|
}
|
if (cacheMapId == REALM_DUNGEON_ID)
|
{
|
if (dungeonModel.dungeonResult.leaderID == PlayerDatas.Instance.PlayerId)
|
{
|
if (!WindowCenter.Instance.CheckOpen<RealmWin>() && !NewBieCenter.Instance.inGuiding)
|
{
|
openByDungeonStep = cacheRealmLv < PlayerDatas.Instance.baseData.realmLevel;
|
WindowCenter.Instance.Open<RealmWin>();
|
}
|
}
|
}
|
cacheMapId = PlayerDatas.Instance.baseData.MapID;
|
}
|
|
private void BossShowCompletedEvent()
|
{
|
if (StageManager.Instance.CurrentStage is DungeonStage)
|
{
|
if (PlayerDatas.Instance.realm.holdDataList.Count > 0
|
&& !WindowCenter.Instance.CheckOpen<RealmUpHoldWin>() && !NewBieCenter.Instance.inGuiding && !BossShowModel.Instance.BossShowing)
|
{
|
WindowCenter.Instance.Open<RealmUpHoldWin>();
|
}
|
}
|
}
|
|
private void RefreshInfo(PlayerDataRefresh refreshType)
|
{
|
if (refreshType == PlayerDataRefresh.OfficialRank)
|
{
|
openedRealmUpWin = false;
|
}
|
if (refreshType == PlayerDataRefresh.RealmPoint)
|
{
|
if (!IsRealmHighest && serverInited)
|
{
|
var config = Config.Instance.Get<RealmConfig>(PlayerDatas.Instance.baseData.realmLevel);
|
if (beforeRealmPoint < config.NeedPoint && PlayerDatas.Instance.extersion.realmPoint >= config.NeedPoint)
|
{
|
realmDungeonState = true;
|
}
|
}
|
beforeRealmPoint = PlayerDatas.Instance.extersion.realmPoint;
|
}
|
if (refreshType == PlayerDataRefresh.RealmPoint || refreshType == PlayerDataRefresh.OfficialRank)
|
{
|
UpdateRedpoint();
|
}
|
}
|
|
private void OnFuncStateChangeEvent(int func)
|
{
|
if (func == (int)FuncOpenEnum.Realm)
|
{
|
UpdateRedpoint();
|
}
|
}
|
|
public override void UnInit()
|
{
|
}
|
|
#region 玩家是否在打坐状态
|
public bool IsInJumpToDaZuo = false;
|
public Dictionary<uint, byte> playerSitDic = new Dictionary<uint, byte>();
|
public void OnRefreshData(H0411_tagPlayerSit vNetData)
|
{
|
if (playerSitDic.ContainsKey(vNetData.PlayerID))
|
{
|
playerSitDic[vNetData.PlayerID] = vNetData.Type;
|
}
|
else
|
{
|
playerSitDic.Add(vNetData.PlayerID, vNetData.Type);
|
}
|
GActorPlayerBase player = GAMgr.Instance.GetBySID(vNetData.PlayerID) as GActorPlayerBase;
|
if (player != null)
|
{
|
if (vNetData.Type == 0)
|
{
|
GA_Player _otherPlayer = player as GA_Player;
|
if (_otherPlayer != null)
|
{
|
_otherPlayer.StopMoveToPosition();
|
}
|
player.Dazuo();
|
}
|
else if (vNetData.Type == 1)
|
{
|
player.IdleImmediate();
|
}
|
}
|
}
|
#endregion
|
|
#region 配置
|
public const int REALM_DUNGEON_ID = 31110;
|
public int realmHoleLimit { get; private set; }
|
public int realmInspireCoolDownTime { get; private set; }
|
public int realmMaxLevel { get; private set; }
|
public int realmSuppressHurt { get; private set; }
|
private Dictionary<int, List<int>> realmHelperAttrDic = new Dictionary<int, List<int>>();
|
private Dictionary<int, Dictionary<int, int>> realmSitTimesDict = new Dictionary<int, Dictionary<int, int>>();
|
private Dictionary<int, int> realmStageDict = new Dictionary<int, int>();
|
private void ParseConfig()
|
{
|
var config = Config.Instance.Get<FuncConfigConfig>("RealmFBHelpAttr");
|
realmHoleLimit = int.Parse(config.Numerical2);
|
realmInspireCoolDownTime = int.Parse(config.Numerical3);
|
JsonData _jsonData = JsonMapper.ToObject(config.Numerical1);
|
foreach (var typeKey in _jsonData.Keys)
|
{
|
List<int> list = new List<int>();
|
foreach (var attrKey in _jsonData[typeKey].Keys)
|
{
|
list.Add(int.Parse(_jsonData[typeKey][attrKey].ToString()));
|
}
|
realmHelperAttrDic.Add(int.Parse(typeKey), list);
|
}
|
|
var configs = Config.Instance.GetAllValues<RealmConfig>();
|
var start = 0;
|
for (int i = 0; i < configs.Count; i++)
|
{
|
var _dict = new Dictionary<int, int>();
|
var _json = JsonMapper.ToObject(configs[i].SitTime);
|
foreach (var _key in _json.Keys)
|
{
|
_dict.Add(int.Parse(_key), int.Parse(_json[_key].ToString()));
|
}
|
realmSitTimesDict.Add(configs[i].Lv, _dict);
|
|
if (configs[i].IsBigRealm == 1)
|
{
|
realmStageDict.Add(start, configs[i].Lv);
|
start = configs[i].Lv + 1;
|
}
|
|
realmMaxLevel = configs[i].Lv > realmMaxLevel ? configs[i].Lv : realmMaxLevel;
|
}
|
|
config = Config.Instance.Get<FuncConfigConfig>("RealmGuardian");
|
realmGuardianDisplayTime = int.Parse(config.Numerical1);
|
|
config = Config.Instance.Get<FuncConfigConfig>("RealmSuppressHurt");
|
realmSuppressHurt = config != null ? int.Parse(config.Numerical1) : 0;
|
}
|
|
public int GetRealmHelperAttr(int type, int index)
|
{
|
List<int> list = null;
|
realmHelperAttrDic.TryGetValue(type, out list);
|
if (index < list.Count)
|
{
|
return list[index];
|
}
|
return 0;
|
}
|
|
public bool IsBigRealm()
|
{
|
var config = Config.Instance.Get<RealmConfig>(PlayerDatas.Instance.baseData.realmLevel);
|
return config != null && config.IsBigRealm == 1;
|
}
|
|
public bool TryGetRealmStage(int _realmLv, out int start, out int end)
|
{
|
start = 0; end = 0;
|
foreach (var _key in realmStageDict.Keys)
|
{
|
if (_realmLv >= _key && _realmLv <= realmStageDict[_key])
|
{
|
start = _key;
|
end = realmStageDict[_key];
|
return true;
|
}
|
}
|
return false;
|
}
|
#endregion
|
|
public bool IsRealmHighest
|
{
|
get
|
{
|
var config = Config.Instance.Get<RealmConfig>(PlayerDatas.Instance.baseData.realmLevel + 1);
|
return config == null;
|
}
|
}
|
|
public bool IsDungeonState
|
{
|
get
|
{
|
var _realmPoint = PlayerDatas.Instance.extersion.realmPoint;
|
if (IsRealmHighest)
|
{
|
return false;
|
}
|
var config = Config.Instance.Get<RealmConfig>(PlayerDatas.Instance.baseData.realmLevel);
|
return _realmPoint >= config.NeedPoint;
|
}
|
}
|
|
public Redpoint realmRedpoint = new Redpoint(114, 11401);
|
|
public bool openedRealmUpWin = false;
|
|
public void UpdateRedpoint()
|
{
|
realmRedpoint.state = RedPointState.None;
|
if (!FuncOpen.Instance.IsFuncOpen((int)FuncOpenEnum.Realm))
|
{
|
return;
|
}
|
if (IsRealmHighest)
|
{
|
return;
|
}
|
var config = Config.Instance.Get<RealmConfig>(PlayerDatas.Instance.baseData.realmLevel);
|
var _realmPoint = PlayerDatas.Instance.extersion.realmPoint;
|
if (_realmPoint >= config.NeedPoint && !openedRealmUpWin)
|
{
|
realmRedpoint.state = RedPointState.Simple;
|
}
|
}
|
|
public void GotoDungeon()
|
{
|
var _realmCfg = Config.Instance.Get<RealmConfig>(PlayerDatas.Instance.baseData.realmLevel);
|
if (_realmCfg == null)
|
{
|
return;
|
}
|
if (PlayerDatas.Instance.extersion.realmPoint < _realmCfg.NeedPoint)
|
{
|
return;
|
}
|
if (_realmCfg != null && _realmCfg.IsBigRealm == 1)
|
{
|
dungeonModel.GroupChallenge(REALM_DUNGEON_ID, 1);
|
}
|
else
|
{
|
dungeonModel.SingleChallenge(REALM_DUNGEON_ID);
|
}
|
}
|
|
public void OnPlayerLoginOk()
|
{
|
UpdateRedpoint();
|
beforeRealmPoint = PlayerDatas.Instance.extersion.realmPoint;
|
serverInited = true;
|
}
|
}
|
}
|
