//--------------------------------------------------------
|
// [Author]: 第二世界
|
// [ Date ]: Wednesday, September 06, 2017
|
//--------------------------------------------------------
|
using UnityEngine;
|
using System.Collections;
|
using System.Collections.Generic;
|
|
using System;
|
|
namespace vnxbqy.UI
|
{
|
|
|
public class MapModel : Model, IBeforePlayerDataInitialize, IAfterPlayerDataInitialize, IPlayerLoginOk, IMapInitOk
|
{
|
Dictionary<int, WorldMapArea> worldMapAreas = new Dictionary<int, WorldMapArea>();
|
Dictionary<int, bool> worldMapUnLockStates = new Dictionary<int, bool>();
|
Dictionary<int, List<int>> localMapEventPoints = new Dictionary<int, List<int>>();
|
Dictionary<int, List<string>> mapFunctionNPCsToRefreshID = new Dictionary<int, List<string>>();
|
Dictionary<int, List<string>> mapCollectNPCsToRefreshID = new Dictionary<int, List<string>>();
|
Dictionary<int, List<MapLine>> allMapLines = new Dictionary<int, List<MapLine>>();
|
List<int> sortedMapEventPoints = new List<int>();
|
List<int> sortedHangUpPoints = new List<int>();
|
List<int> sortedMaps = new List<int>();
|
|
TaskModel taskModel { get { return ModelCenter.Instance.GetModel<TaskModel>(); } }
|
|
int m_NewUnlockedMap = 0;
|
public int newUnlockedMap {
|
get { return m_NewUnlockedMap; }
|
set { m_NewUnlockedMap = value; }
|
}
|
|
public int newUnlockMapTip {
|
get { return LocalSave.GetInt(StringUtility.Contact(PlayerDatas.Instance.baseData.PlayerID, "NewUnLockMapsTip")); }
|
set { LocalSave.SetInt(StringUtility.Contact(PlayerDatas.Instance.baseData.PlayerID, "NewUnLockMapsTip"), value); }
|
}
|
|
int m_SelectedMapEventPoint;
|
public int selectedMapEventPoint {
|
get { return this.m_SelectedMapEventPoint; }
|
set {
|
if (m_SelectedMapEventPoint != value)
|
{
|
m_SelectedMapEventPoint = value;
|
if (selectMapEventPointEvent != null)
|
{
|
selectMapEventPointEvent(this.m_SelectedMapEventPoint);
|
}
|
}
|
}
|
}
|
|
public int wannaLookLocalMap { get; set; }
|
int mapUnLockIndex = 0;
|
|
public event Action<int> selectMapEventPointEvent;
|
public event Action<int> mapLinesUpdateEvent;
|
|
public override void Init()
|
{
|
ParseWorldMaps();
|
ParseLocalMaps();
|
|
PlayerDatas.Instance.playerDataRefreshEvent += OnPlayerDataChange;
|
TaskModel.Event_TaskInformation += OnMainLineTaskInfoUpdate;
|
}
|
|
public override void UnInit()
|
{
|
PlayerDatas.Instance.playerDataRefreshEvent -= OnPlayerDataChange;
|
TaskModel.Event_TaskInformation -= OnMainLineTaskInfoUpdate;
|
}
|
|
public void OnBeforePlayerDataInitialize()
|
{
|
mapUnLockIndex = 0;
|
newUnlockedMap = 0;
|
}
|
|
public void OnAfterPlayerDataInitialize()
|
{
|
}
|
|
public void OnPlayerLoginOk()
|
{
|
UpdateMapsUnlockedState();
|
newUnlockedMap = 0;
|
}
|
|
public void OnMapInitOk()
|
{
|
if (newUnlockMapTip == PlayerDatas.Instance.baseData.MapID)
|
{
|
newUnlockMapTip = 0;
|
}
|
}
|
|
public void RequestMapTransport(int _mapId, int _lineId = 255)
|
{
|
if (PlayerDatas.Instance.extersion.pkState == 1)
|
{
|
SysNotifyMgr.Instance.ShowTip("PK_Leave");
|
return;
|
}
|
|
var currentMapConfig = MapConfig.Get(PlayerDatas.Instance.baseData.MapID);
|
if (currentMapConfig.MapFBType != 0)
|
{
|
SysNotifyMgr.Instance.ShowTip("DungeonNoGO");
|
return;
|
}
|
|
if (!worldMapUnLockStates.ContainsKey(_mapId))
|
{
|
return;
|
}
|
|
if (!worldMapUnLockStates[_mapId])
|
{
|
SysNotifyMgr.Instance.ShowTip("Map_Delivery");
|
return;
|
}
|
|
InGameDownLoad.Instance.UnRegisterMapAssetDownLoadOk();
|
var map = MapConfig.Get(_mapId);
|
var position = new Vector3(map.BornPoints[0].x, 0, map.BornPoints[0].y);
|
MapTransferUtility.Send_WorldTransfer(_mapId, position, MapTransferType.WorldTransport, (byte)_lineId, 0);
|
}
|
|
public void RequestSelectedLine(int _lineId)
|
{
|
var hero = PlayerDatas.Instance.hero;
|
if (hero != null)
|
{
|
hero.Behaviour.StopHandupAI();
|
hero.Behaviour.StopKillUntilDieAI();
|
}
|
|
if (PlayerDatas.Instance.baseData.FBID != _lineId)
|
{
|
var sendInfo = new C010B_tagCChangeLine();
|
sendInfo.Line = (short)_lineId;
|
GameNetSystem.Instance.SendInfo(sendInfo);
|
}
|
}
|
|
public void RequestQueryMapLineState(int _mapId, byte[] _lineIds = null, bool _isAllLine = true)
|
{
|
var config = MapConfig.Get(_mapId);
|
if (config.MapFBType == (int)MapType.OpenCountry)
|
{
|
var lineState = new CA003_tagPyGetLineState();
|
lineState.MapID = (uint)_mapId;
|
GameNetSystem.Instance.SendInfo(lineState);
|
}
|
else
|
{
|
var lineState = new CA004_tagCGGetFBLinePlayerCnt();
|
lineState.MapID = (uint)_mapId;
|
lineState.LineCount = (byte)(_isAllLine ? 0 : _lineIds.Length);
|
if (_isAllLine)
|
{
|
lineState.LineIDList = new byte[0];
|
}
|
GameNetSystem.Instance.SendInfo(lineState);
|
}
|
}
|
|
public List<MapLine> GetMapLines(int _mapId)
|
{
|
var mapLines = new List<MapLine>();
|
if (allMapLines.ContainsKey(_mapId))
|
{
|
mapLines.AddRange(allMapLines[_mapId]);
|
//CheckActivityLine(_mapId, mapLines);
|
mapLines.Sort(SortMaplines);
|
return mapLines;
|
}
|
else
|
{
|
return null;
|
}
|
}
|
|
public void UpdateMapLines(HA006_tagGCPyServerMapState _serverInfo)
|
{
|
for (int i = 0; i < _serverInfo.MapCount; i++)
|
{
|
var mapState = _serverInfo.MapStateList[i];
|
var mapId = (int)mapState.MapID;
|
var lines = allMapLines[mapId] = new List<MapLine>();
|
for (int j = 0; j < mapState.LineCnt; j++)
|
{
|
var playerCount = (int)mapState.LineCurPlayerCntList[j];
|
var playerMaxCount = (int)mapState.LineMaxPlayerCntList[j];
|
lines.Add(new MapLine(mapId, j + 1, playerCount, playerMaxCount));
|
}
|
|
if (mapLinesUpdateEvent != null)
|
{
|
mapLinesUpdateEvent(mapId);
|
}
|
}
|
}
|
|
public void UpdateDungeonMapLines(HA007_tagGCFBLinePlayerCnt _serverInfo)
|
{
|
var mapId = (int)_serverInfo.MapID;
|
var lines = allMapLines[mapId] = new List<MapLine>();
|
|
for (int i = 0; i < _serverInfo.Count; i++)
|
{
|
var mapState = _serverInfo.FBLineInfoList[i];
|
lines.Add(new MapLine(mapId, mapState.FBLineID, mapState.PlayerCnt));
|
}
|
|
if (mapLinesUpdateEvent != null)
|
{
|
mapLinesUpdateEvent(mapId);
|
}
|
}
|
|
public bool TryGetWorldMapArea(int _id, out WorldMapArea _area)
|
{
|
return worldMapAreas.TryGetValue(_id, out _area);
|
}
|
|
public List<int> GetWorldMapAreas()
|
{
|
return new List<int>(worldMapAreas.Keys);
|
}
|
|
public List<int> GetMapEventPoints(int dataMapId, int lineId)
|
{
|
var key = dataMapId * 100 + lineId;
|
if (!localMapEventPoints.ContainsKey(key))
|
{
|
key = dataMapId * 100;
|
}
|
|
if (localMapEventPoints.ContainsKey(key))
|
{
|
return localMapEventPoints[key];
|
}
|
else
|
{
|
return null;
|
}
|
}
|
|
public List<string> GetMapNPCRefreshIds(int _mapId)
|
{
|
if (mapFunctionNPCsToRefreshID.ContainsKey(_mapId))
|
{
|
return mapFunctionNPCsToRefreshID[_mapId];
|
}
|
|
return null;
|
}
|
|
public List<string> GetMapCollectNPCRefreshIds(int _mapId)
|
{
|
if (mapCollectNPCsToRefreshID.ContainsKey(_mapId))
|
{
|
return mapCollectNPCsToRefreshID[_mapId];
|
}
|
|
return null;
|
}
|
|
public bool CanOpenLocalMapWin(int mapId)
|
{
|
var dataMapId = MapUtility.GetDataMapId(mapId);
|
var lineId = MapUtility.GetLineId();
|
var mapResConfig = MapResourcesConfig.GetConfig(dataMapId, lineId);
|
var config = MapConfig.Get(mapId);
|
if (string.IsNullOrEmpty(mapResConfig.BigMap)
|
|| mapId == FairyLeagueModel.FAIRY_LEAGUE_DUNGEON)
|
{
|
return false;
|
}
|
else
|
{
|
return true;
|
}
|
}
|
|
public int GetRecommendHangPoint(int _mapId, int lineId)
|
{
|
var eventPoints = new List<int>(GetMapEventPoints(_mapId, lineId));
|
for (int i = eventPoints.Count - 1; i >= 0; i--)
|
{
|
var config = MapEventPointConfig.Get(eventPoints[i]);
|
if (config.IsShowInfo == 0)
|
{
|
eventPoints.RemoveAt(i);
|
}
|
}
|
|
eventPoints.Sort((int a, int b) =>
|
{
|
var configA = MapEventPointConfig.Get(a);
|
var configB = MapEventPointConfig.Get(b);
|
return configA.LowLV < configB.LowLV ? -1 : 1;
|
});
|
|
var playerLevel = PlayerDatas.Instance.baseData.LV;
|
var eventPointsPool = new List<int>();
|
var levelMatchPointIndex = 0;
|
for (int i = eventPoints.Count - 1; i >= 0; i--)
|
{
|
var config = MapEventPointConfig.Get(eventPoints[i]);
|
if (playerLevel >= config.LowLV)
|
{
|
levelMatchPointIndex = i;
|
break;
|
}
|
}
|
|
if (levelMatchPointIndex < eventPoints.Count - 1)
|
{
|
eventPointsPool.Add(eventPoints[levelMatchPointIndex + 1]);
|
}
|
|
eventPointsPool.Add(eventPoints[levelMatchPointIndex]);
|
|
if (levelMatchPointIndex > 0)
|
{
|
eventPointsPool.Add(eventPoints[levelMatchPointIndex - 1]);
|
}
|
|
var recommendPoint = 0;
|
if (eventPointsPool.Count > 0)
|
{
|
recommendPoint = eventPointsPool[eventPointsPool.Count - 1];
|
for (int i = 0; i < eventPointsPool.Count; i++)
|
{
|
var config = MapEventPointConfig.Get(eventPointsPool[i]);
|
if (PlayerDatas.Instance.extersion.DEF >= config.Defense)
|
{
|
recommendPoint = eventPointsPool[i];
|
break;
|
}
|
}
|
}
|
else
|
{
|
var lowest = MapEventPointConfig.Get(eventPoints[0]);
|
if (playerLevel < lowest.LowLV)
|
{
|
recommendPoint = lowest.Key;
|
}
|
else
|
{
|
var hightest = MapEventPointConfig.Get(eventPoints[eventPoints.Count - 1]);
|
recommendPoint = hightest.Key;
|
}
|
}
|
|
return recommendPoint;
|
}
|
|
public int GetRecommendHangPoint()
|
{
|
var unLockedHangeUpPoints = new List<int>();
|
|
for (int i = 0; i < sortedHangUpPoints.Count; i++)
|
{
|
var config = MapEventPointConfig.Get(sortedHangUpPoints[i]);
|
if (IsMapUnlocked(MapUtility.GetMapId(config.DataMapID, config.LineId)))
|
{
|
unLockedHangeUpPoints.Add(sortedHangUpPoints[i]);
|
}
|
}
|
|
var playerLevel = PlayerDatas.Instance.baseData.LV;
|
var eventPointsPool = new List<int>();
|
var levelMatchPointIndex = 0;
|
for (int i = unLockedHangeUpPoints.Count - 1; i >= 0; i--)
|
{
|
var config = MapEventPointConfig.Get(unLockedHangeUpPoints[i]);
|
if (playerLevel >= config.LowLV)
|
{
|
levelMatchPointIndex = i;
|
break;
|
}
|
}
|
|
if (levelMatchPointIndex < unLockedHangeUpPoints.Count - 1)
|
{
|
eventPointsPool.Add(unLockedHangeUpPoints[levelMatchPointIndex + 1]);
|
}
|
|
eventPointsPool.Add(unLockedHangeUpPoints[levelMatchPointIndex]);
|
if (levelMatchPointIndex > 0)
|
{
|
eventPointsPool.Add(unLockedHangeUpPoints[levelMatchPointIndex - 1]);
|
}
|
|
var recommendPoint = 0;
|
if (eventPointsPool.Count > 0)
|
{
|
recommendPoint = eventPointsPool[eventPointsPool.Count - 1];
|
for (int i = 0; i < eventPointsPool.Count; i++)
|
{
|
var config = MapEventPointConfig.Get(eventPointsPool[i]);
|
if (PlayerDatas.Instance.extersion.DEF >= config.Defense)
|
{
|
recommendPoint = eventPointsPool[i];
|
break;
|
}
|
}
|
}
|
else
|
{
|
var lowest = MapEventPointConfig.Get(unLockedHangeUpPoints[0]);
|
if (playerLevel < lowest.LowLV)
|
{
|
recommendPoint = lowest.Key;
|
}
|
else
|
{
|
var count = unLockedHangeUpPoints.Count;
|
var hightest = MapEventPointConfig.Get(unLockedHangeUpPoints[count - 1]);
|
recommendPoint = hightest.Key;
|
}
|
}
|
|
return recommendPoint;
|
}
|
|
public bool IsMapUnlocked(int _mapId)
|
{
|
if (worldMapUnLockStates.ContainsKey(_mapId))
|
{
|
return worldMapUnLockStates[_mapId];
|
}
|
else
|
{
|
return false;
|
}
|
}
|
|
private void UpdateMapsUnlockedState()
|
{
|
foreach (var mapId in worldMapAreas.Keys)
|
{
|
var canUnlock = CanMapUnlock(mapId);
|
if (worldMapUnLockStates.ContainsKey(mapId)
|
&& !worldMapUnLockStates[mapId]
|
&& canUnlock && mapId != 10010)
|
{
|
newUnlockedMap = mapId;
|
newUnlockMapTip = mapId;
|
}
|
|
worldMapUnLockStates[mapId] = canUnlock;
|
}
|
}
|
|
private bool CanMapUnlock(int _mapId)
|
{
|
var config = MapConfig.Get(_mapId);
|
if (config.LV != 0 && PlayerDatas.Instance.baseData.LV < config.LV)
|
{
|
return false;
|
}
|
|
if (config.MainTaskID != 0 && mapUnLockIndex < config.MainTaskID)
|
{
|
return false;
|
}
|
|
if (config.realmLevel != 0 && PlayerDatas.Instance.baseData.realmLevel < config.realmLevel)
|
{
|
return false;
|
}
|
|
return true;
|
}
|
|
private void OnPlayerDataChange(PlayerDataType refreshType)
|
{
|
switch (refreshType)
|
{
|
case PlayerDataType.LV:
|
case PlayerDataType.RealmLevel:
|
UpdateMapsUnlockedState();
|
break;
|
}
|
}
|
|
private void OnMainLineTaskInfoUpdate(int _id, Dictionary<int, Dictionary<string, string>> _Dic)
|
{
|
if (_id == 1)
|
{
|
if (taskModel._DicTaskInformation.ContainsKey(1) && taskModel._DicTaskInformation[1].ContainsKey("OpenMap"))
|
{
|
int.TryParse(taskModel._DicTaskInformation[1]["OpenMap"], out mapUnLockIndex);
|
}
|
else
|
{
|
mapUnLockIndex = 0;
|
}
|
|
UpdateMapsUnlockedState();
|
}
|
}
|
|
private void ParseWorldMaps()
|
{
|
var mapConfigs = MapConfig.GetValues();
|
foreach (var mapConfig in mapConfigs)
|
{
|
if (mapConfig.MapFBType == 0)
|
{
|
worldMapAreas.Add(mapConfig.MapID, new WorldMapArea(mapConfig.MapID, true));
|
sortedMaps.Add(mapConfig.MapID);
|
}
|
}
|
|
sortedMaps.Sort(
|
(int a, int b) =>
|
{
|
var configA = MapConfig.Get(a);
|
var configB = MapConfig.Get(b);
|
|
return configA.LV > configB.LV ? -1 : 1;
|
}
|
);
|
}
|
|
private void ParseLocalMaps()
|
{
|
var mapEventConfigs = MapEventPointConfig.GetValues();
|
foreach (var config in mapEventConfigs)
|
{
|
var mapId = MapUtility.GetMapId(config.DataMapID, config.LineId);
|
var key = config.DataMapID * 100 + config.LineId;
|
List<int> eventPointIds = null;
|
if (!localMapEventPoints.ContainsKey(key))
|
{
|
localMapEventPoints[key] = eventPointIds = new List<int>();
|
}
|
else
|
{
|
eventPointIds = localMapEventPoints[key];
|
}
|
|
eventPointIds.Add(config.Key);
|
if (config.IsShowInfo == 1 && GeneralDefine.autoOnHookMap.Contains(mapId))
|
{
|
sortedMapEventPoints.Add(config.Key);
|
}
|
}
|
|
sortedMapEventPoints.Sort((int a, int b) =>
|
{
|
var configA = MapEventPointConfig.Get(a);
|
var configB = MapEventPointConfig.Get(b);
|
|
return configA.LowLV < configB.LowLV ? -1 : 1;
|
});
|
|
for (int i = 0; i < sortedMapEventPoints.Count; i++)
|
{
|
var eventPoint = sortedMapEventPoints[i];
|
var config = MapEventPointConfig.Get(eventPoint);
|
var mapId = MapUtility.GetMapId(config.DataMapID, config.LineId);
|
if (GeneralDefine.autoOnHookMap.Contains(mapId))
|
{
|
sortedHangUpPoints.Add(eventPoint);
|
}
|
}
|
|
var mapNpcConfigs = mapnpcConfig.GetValues();
|
foreach (var config in mapNpcConfigs)
|
{
|
var mapId = config.MapID;
|
if (config.NPCID != 0)
|
{
|
if (config.NPCType == (int)E_NpcType.Func)
|
{
|
List<string> npcRefreshIs;
|
if (!mapFunctionNPCsToRefreshID.ContainsKey(mapId))
|
{
|
mapFunctionNPCsToRefreshID[mapId] = npcRefreshIs = new List<string>();
|
}
|
else
|
{
|
npcRefreshIs = mapFunctionNPCsToRefreshID[mapId];
|
}
|
|
npcRefreshIs.Add(config.RefreshID.ToString());
|
}
|
else if (config.NPCType == (int)E_NpcType.Flag)
|
{
|
List<string> npcRefreshIs;
|
if (!mapCollectNPCsToRefreshID.ContainsKey(mapId))
|
{
|
mapCollectNPCsToRefreshID[mapId] = npcRefreshIs = new List<string>();
|
}
|
else
|
{
|
npcRefreshIs = mapCollectNPCsToRefreshID[mapId];
|
}
|
|
npcRefreshIs.Add(config.RefreshID.ToString());
|
}
|
}
|
}
|
|
}
|
|
int SortMaplines(MapLine x, MapLine y)
|
{
|
return x.lineIndex.CompareTo(y.lineIndex);
|
}
|
}
|
|
public struct WorldMapArea
|
{
|
public int id;
|
public bool unLocked;
|
|
public WorldMapArea(int _id, bool _unLocked)
|
{
|
this.id = _id;
|
this.unLocked = _unLocked;
|
}
|
|
}
|
|
public struct MapLine
|
{
|
public int mapId;
|
public int lineIndex;
|
public int playerCount;
|
public int playerMaxCount;
|
|
public MapLine(int _mapId, int _lineIndex, int _playerCount, int _playerMaxCount)
|
{
|
this.mapId = _mapId;
|
this.lineIndex = _lineIndex;
|
this.playerCount = _playerCount;
|
this.playerMaxCount = _playerMaxCount;
|
}
|
|
public MapLine(int _mapId, int _lineId, int _playerCount)
|
{
|
this.mapId = _mapId;
|
this.lineIndex = _lineId;
|
this.playerCount = _playerCount;
|
this.playerMaxCount = 99999;
|
}
|
|
}
|
|
|
}
|
|
|
|
