//===================================================================
//野外分线相关处理
//===================================================================
internal void RequestSceneRoomInfo(ulong guid)
{
UserProcessScheduler dataProcess = LobbyServer.Instance.UserProcessScheduler;
UserInfo user = dataProcess.GetUserInfo(guid);
if (null != user)
{
if (user.CurrentState == UserState.Room)
{
RoomInfo room = user.Room;
if (null != room)
{
SceneRoomInfo info = m_LobbyInfo.GetSceneRoomInfo(room.SceneType, room.RoomId);
if (null != info)
{
string chapterName;
TableConfig.Level cfg = TableConfig.LevelProvider.Instance.GetLevel(info.m_SceneId);
if (null != cfg)
{
chapterName = "unknown";
}
else
{
chapterName = "unknown";
}
LobbyServer.Instance.SendStoryMessage(user, "onroominfo", info.m_RoomIndex, info.m_UserCount, info.m_TotalUserCount, info.m_RoomId, info.m_SceneId, chapterName);
}
}
}
}
}
public void PreloadSceneStories()
{
TableConfig.Level cfg = TableConfig.LevelProvider.Instance.GetLevel(m_Scene.SceneResId);
if (null != cfg)
{
string[] filePath;
int ct1 = cfg.SceneDslFile.Count;
int ct2 = cfg.RoomDslFile.Count;
filePath = new string[ct1 + ct2];
for (int i = 0; i < ct1; i++)
{
filePath[i] = HomePath.GetAbsolutePath(FilePathDefine_Server.C_DslPath + cfg.SceneDslFile[i]);
}
for (int i = 0; i < ct2; i++)
{
filePath[ct1 + i] = HomePath.GetAbsolutePath(FilePathDefine_Server.C_DslPath + cfg.RoomDslFile[i]);
}
StoryConfigManager.Instance.LoadStories(m_Scene.SceneResId, string.Empty, filePath);
Dictionary <string, StoryInstance> stories = StoryConfigManager.Instance.GetStories(m_Scene.SceneResId);
if (null != stories)
{
foreach (KeyValuePair <string, StoryInstance> pair in stories)
{
AddStoryInstance(pair.Key, pair.Value.Clone());
}
}
}
}
public void OnSceneLoaded(TableConfig.Level lvl)
{
m_SceneId = lvl.id;
GfxStorySystem.Instance.SceneId = m_SceneId;
Preload();
if (lvl.type == (int)SceneTypeEnum.MainUi)
{
m_LastMainUiSceneId = m_SceneId;
Utility.SendMessage("GameRoot", "OnLoadMainUiComplete", lvl.id);
}
else if (lvl.type == (int)SceneTypeEnum.Story)
{
Utility.SendMessage("GameRoot", "OnLoadBattleComplete", lvl.id);
}
else if (lvl.type == (int)SceneTypeEnum.Room)
{
Utility.SendMessage("GameRoot", "OnLoadBattleComplete", lvl.id);
GameFrameworkMessage.Msg_CR_Enter build = new GameFrameworkMessage.Msg_CR_Enter();
NetworkSystem.Instance.SendMessage(RoomMessageDefine.Msg_CR_Enter, build);
LogSystem.Warn("send Msg_CR_Enter to roomserver");
}
m_IsSceneLoaded = true;
}
private bool IsPveScene(int sceneId)
{
bool ret = false;
TableConfig.Level cfg = TableConfig.LevelProvider.Instance.GetLevel(sceneId);
if (null != cfg && (int)SceneTypeEnum.Story == cfg.type)
{
ret = true;
}
return(ret);
}
internal void DelayChangeScene(int levelId)
{
TableConfig.Level cfg = TableConfig.LevelProvider.Instance.GetLevel(levelId);
if (null != cfg && cfg.type == (int)SceneTypeEnum.Room)
{
UserNetworkSystem.Instance.EnterScene(levelId, 0);
}
else
{
QueueAction(ChangeScene, levelId);
}
}
static public int get_id(IntPtr l)
{
try {
TableConfig.Level self = (TableConfig.Level)checkSelf(l);
pushValue(l, true);
pushValue(l, self.id);
return(2);
}
catch (Exception e) {
return(error(l, e));
}
}
public bool Init(string roomServerName)
{
m_Lock = new object();
m_ActiveRooms = new Dictionary <int, int>();
m_UserPool.Init(m_UserPoolSize);
// 初始化场景房间
int startId = 1;
MyDictionary <int, object> scenes = TableConfig.LevelProvider.Instance.LevelMgr.GetData();
foreach (KeyValuePair <int, object> pair in scenes)
{
TableConfig.Level cfg = pair.Value as TableConfig.Level;
if (null != cfg && cfg.type == (int)SceneTypeEnum.Story)
{
foreach (string roomSvrName in cfg.RoomServer)
{
for (int ix = 0; ix < cfg.ThreadCountPerScene; ++ix)
{
if (0 == roomServerName.CompareTo(roomSvrName))
{
RoomThread fieldThread = new RoomThread(this);
fieldThread.Init(m_ThreadTickInterval, (uint)cfg.RoomCountPerThread, m_UserPool, m_Connector);
for (int rix = 0; rix < cfg.RoomCountPerThread; ++rix)
{
fieldThread.ActiveFieldRoom(startId, cfg.id);
AddActiveRoom(startId, m_FieldRoomthreadList.Count, true);
AddFieldSceneRoomId(cfg.id, startId);
++startId;
}
m_FieldRoomthreadList.Add(fieldThread);
}
else
{
for (int rix = 0; rix < cfg.RoomCountPerThread; ++rix)
{
++startId;
}
}
}
}
}
}
// 初始化房间线程
for (int i = 0; i < m_ThreadAmount; ++i)
{
m_RoomThreadList[i] = new RoomThread(this);
m_RoomThreadList[i].Init(m_ThreadTickInterval, m_RoomAmount, m_UserPool, m_Connector);
}
m_NextRoomId = startId;
return(true);
}
internal bool Init(string roomServerName)
{
lock_obj_ = new object();
active_rooms_ = new Dictionary <int, int>();
user_pool_.Init(user_pool_size_);
// 初始化场景房间
int startId = 1;
MyDictionary <int, object> scenes = TableConfig.LevelProvider.Instance.LevelMgr.GetData();
foreach (KeyValuePair <int, object> pair in scenes)
{
TableConfig.Level cfg = pair.Value as TableConfig.Level;
if (null != cfg && cfg.type == (int)SceneTypeEnum.Room)
{
foreach (string roomSvrName in cfg.RoomServer)
{
for (int ix = 0; ix < cfg.ThreadCountPerScene; ++ix)
{
if (0 == roomServerName.CompareTo(roomSvrName))
{
RoomThread fieldThread = new RoomThread(this);
fieldThread.Init(thread_tick_interval_, (uint)cfg.RoomCountPerThread, user_pool_, connector_);
for (int rix = 0; rix < cfg.RoomCountPerThread; ++rix)
{
fieldThread.ActiveFieldRoom(startId, cfg.id);
AddActiveRoom(startId, field_roomthread_list_.Count, true);
AddFieldSceneRoomId(cfg.id, startId);
++startId;
}
field_roomthread_list_.Add(fieldThread);
}
else
{
for (int rix = 0; rix < cfg.RoomCountPerThread; ++rix)
{
++startId;
}
}
}
}
}
}
// 初始化房间线程
for (int i = 0; i < thread_amount_; ++i)
{
roomthread_list_[i] = new RoomThread(this);
roomthread_list_[i].Init(thread_tick_interval_, room_amount_, user_pool_, connector_);
}
next_room_id_ = startId;
return(true);
}
static public int GetId(IntPtr l)
{
try {
TableConfig.Level self = (TableConfig.Level)checkSelf(l);
var ret = self.GetId();
pushValue(l, true);
pushValue(l, ret);
return(2);
}
catch (Exception e) {
return(error(l, e));
}
}
private IEnumerator UnloadBattle(TableConfig.Level lvl)
{
LoadingManager.Instance.Show();
yield return(null);
LoadingManager.Instance.SetProgress(0.1f);
UnityEngine.SceneManagement.SceneManager.UnloadSceneAsync(lvl.prefab);
LoadingManager.Instance.SetProgress(0.9f);
yield return(Resources.UnloadUnusedAssets());
LoadingManager.Instance.SetProgress(1.0f);
PluginFramework.Instance.OnBattleUnloaded(lvl);
}
static public int constructor(IntPtr l)
{
try {
TableConfig.Level o;
o = new TableConfig.Level();
pushValue(l, true);
pushValue(l, o);
return(2);
}
catch (Exception e) {
return(error(l, e));
}
}
static public int WriteToBinary(IntPtr l)
{
try {
TableConfig.Level self = (TableConfig.Level)checkSelf(l);
GameFramework.BinaryTable a1;
checkType(l, 2, out a1);
self.WriteToBinary(a1);
pushValue(l, true);
return(1);
}
catch (Exception e) {
return(error(l, e));
}
}
static public int set_EnterRadius(IntPtr l)
{
try {
TableConfig.Level self = (TableConfig.Level)checkSelf(l);
System.Single v;
checkType(l, 2, out v);
self.EnterRadius = v;
pushValue(l, true);
return(1);
}
catch (Exception e) {
return(error(l, e));
}
}
static public int set_RoomServer(IntPtr l)
{
try {
TableConfig.Level self = (TableConfig.Level)checkSelf(l);
System.Collections.Generic.List <System.String> v;
checkType(l, 2, out v);
self.RoomServer = v;
pushValue(l, true);
return(1);
}
catch (Exception e) {
return(error(l, e));
}
}
static public int set_id(IntPtr l)
{
try {
TableConfig.Level self = (TableConfig.Level)checkSelf(l);
System.Int32 v;
checkType(l, 2, out v);
self.id = v;
pushValue(l, true);
return(1);
}
catch (Exception e) {
return(error(l, e));
}
}
internal void InitSceneRooms()
{
// 初始化野外场景房间
MyDictionary <int, object> scenes = TableConfig.LevelProvider.Instance.LevelMgr.GetData();
foreach (KeyValuePair <int, object> pair in scenes)
{
TableConfig.Level cfg = pair.Value as TableConfig.Level;
if (null != cfg && cfg.type == (int)SceneTypeEnum.Room)
{
SceneRoomsInfo fieldInfo;
if (!m_SceneInfos.TryGetValue(cfg.id, out fieldInfo))
{
fieldInfo = new SceneRoomsInfo();
fieldInfo.m_SceneId = cfg.id;
m_SceneInfos.Add(cfg.id, fieldInfo);
}
foreach (string roomServerName in cfg.RoomServer)
{
for (int ix = 0; ix < cfg.ThreadCountPerScene; ++ix)
{
for (int rix = 0; rix < cfg.RoomCountPerThread; ++rix)
{
RoomInfo room = NewRoomInfo();
room.RoomId = ++m_CurRoomId;
room.IsField = true;
room.SceneType = cfg.id;
room.RoomServerName = roomServerName;
room.TotalCount = cfg.MaxUserCount;
if (!m_Rooms.ContainsKey(room.RoomId))
{
m_Rooms.Add(room.RoomId, room);
}
else
{
m_Rooms[room.RoomId] = room;
}
if (!fieldInfo.m_RoomIds.Contains(room.RoomId))
{
fieldInfo.m_RoomIds.Add(room.RoomId);
}
room.Creator = 0;
}
}
}
}
}
}
private IEnumerator LoadBattle(TableConfig.Level lvl)
{
LoadingManager.Instance.Show();
yield return(null);
LoadingManager.Instance.SetProgress(0.1f);
yield return(Resources.UnloadUnusedAssets());
LoadingManager.Instance.SetProgress(0.2f);
var asyncOper = UnityEngine.SceneManagement.SceneManager.LoadSceneAsync(lvl.prefab, UnityEngine.SceneManagement.LoadSceneMode.Additive);
LoadingManager.Instance.SetAsync(asyncOper, 0.3f, 0.7f);
yield return(asyncOper);
PluginFramework.Instance.OnBattleLoaded(lvl);
}
public void OnLevelWasLoaded(TableConfig.Level level)
{
camera = Camera.main;
cameraSetting = camera.gameObject.GetComponent <SkillViewerCameraSetting>();
if (cameraSetting == null)
{
cameraSetting = camera.gameObject.AddComponent <SkillViewerCameraSetting>();
}
//camera.transform.rotation = cameraSetting.GetRotation();// 注释掉，临时让摄像机设置不起作用 peterdou
SetState(State.Lookat);
followPose.pos = camera.transform.position;
followPose.rot = camera.transform.rotation;
fixPose.pos = camera.transform.position;
fixPose.rot = camera.transform.rotation;
}
static public int ReadFromBinary(IntPtr l)
{
try {
TableConfig.Level self = (TableConfig.Level)checkSelf(l);
GameFramework.BinaryTable a1;
checkType(l, 2, out a1);
System.Int32 a2;
checkType(l, 3, out a2);
var ret = self.ReadFromBinary(a1, a2);
pushValue(l, true);
pushValue(l, ret);
return(2);
}
catch (Exception e) {
return(error(l, e));
}
}
private IEnumerator LoadLevel(TableConfig.Level lvl)
{
HighlightPromptManager.Instance.Release();
BattleTopMenuManager.Instance.Release();
SkillBarManager.Instance.Release();
OverHeadBarManager.Instance.Release();
m_CameraController = null;
yield return(null);
yield return(UnityEngine.SceneManagement.SceneManager.LoadSceneAsync("Loading"));
yield return(Resources.UnloadUnusedAssets());
yield return(UnityEngine.SceneManagement.SceneManager.LoadSceneAsync(lvl.prefab));
ClientModule.Instance.OnSceneLoaded(lvl);
Utility.EventSystem.Publish("loading_complete", "ui", null);
}
private void PreloadUiStories()
{
if (null != m_SceneInfo)
{
TableConfig.Level level = m_SceneInfo;
int ct = level.SceneUi.Count;
for (int ix = 0; ix < ct; ++ix)
{
int uiId = level.SceneUi[ix];
TableConfig.UI ui = TableConfig.UIProvider.Instance.GetUI(uiId);
if (null != ui)
{
if (!string.IsNullOrEmpty(ui.dsl) && !string.IsNullOrEmpty(ui.name))
{
GfxStorySystem.Instance.PreloadNamespacedStory(ui.name, ui.dsl);
}
}
}
}
}
private void LoadUi(int levelId)
{
TableConfig.Level level = TableConfig.LevelProvider.Instance.GetLevel(levelId);
if (null != level)
{
int ct = level.SceneUi.Count;
for (int i = 0; i < ct; ++i)
{
int uiId = level.SceneUi[i];
TableConfig.UI ui = TableConfig.UIProvider.Instance.GetUI(uiId);
if (null != ui)
{
GameObject asset = UiResourceSystem.Instance.GetUiResource(ui.path) as GameObject;
if (null != asset)
{
GameObject uiObj = GameObject.Instantiate(asset);
if (null != uiObj)
{
uiObj.name = ui.name;
if (!string.IsNullOrEmpty(ui.dsl))
{
GameFramework.Story.UiStoryInitializer initer = uiObj.GetComponent <GameFramework.Story.UiStoryInitializer>();
if (null == initer)
{
initer = uiObj.AddComponent <GameFramework.Story.UiStoryInitializer>();
}
if (null != initer)
{
initer.WindowName = ui.name;
initer.Init();
}
}
}
}
}
}
}
}
private IEnumerator LoadScene(TableConfig.Level lvl)
{
LoadingManager.Instance.Show();
TopMenuManager.Instance.Release();
HighlightPromptManager.Instance.Release();
OverHeadBarManager.Instance.Release();
m_CameraController = null;
yield return(null);
LoadingManager.Instance.SetProgress(0.1f);
yield return(UnityEngine.SceneManagement.SceneManager.LoadSceneAsync("Loading"));
LoadingManager.Instance.SetProgress(0.2f);
yield return(Resources.UnloadUnusedAssets());
LoadingManager.Instance.SetProgress(0.3f);
var asyncOper = UnityEngine.SceneManagement.SceneManager.LoadSceneAsync(lvl.prefab);
LoadingManager.Instance.SetAsync(asyncOper, 0.3f, 0.7f);
yield return(asyncOper);
PluginFramework.Instance.OnSceneLoaded(lvl);
}
private void RequestEnterSceneRoom(UserInfo info, int roomId, int hp, int mp, float x, float y)
{
RoomInfo room = m_LobbyInfo.GetRoomByID(roomId);
if (null != room)
{
int campId = (int)CampIdEnum.Blue;
TableConfig.Level cfg = TableConfig.LevelProvider.Instance.GetLevel(room.SceneType);
if (null != cfg)
{
campId = (int)CampIdEnum.FreedomCamp_Begin + info.WorldId;//room.GenNextCampId();
}
room.AddUsers(campId, info.Guid);
Msg_LR_EnterScene enterSceneMsg = new Msg_LR_EnterScene();
enterSceneMsg.UserGuid = info.Guid;
enterSceneMsg.RoomID = roomId;
Msg_LR_RoomUserInfo ruiBuilder = info.RoomUserInfo;
ruiBuilder.Key = info.Key;
ruiBuilder.Camp = info.CampId;
if (hp > 0 && mp > 0)
{
enterSceneMsg.HP = hp;
enterSceneMsg.MP = mp;
}
if (x > 0 && y > 0)
{
ruiBuilder.EnterX = x;
ruiBuilder.EnterY = y;
}
enterSceneMsg.UserInfo = ruiBuilder;
LobbyServer.Instance.RoomSvrChannel.Send(room.RoomServerName, enterSceneMsg);
LogSys.Log(LOG_TYPE.DEBUG, "Request enter field, user {0} room {1}", info.Guid, roomId);
}
}
private IEnumerator LoadLevel(TableConfig.Level lvl)
{
ClientModule.Instance.OnSceneLoaded(lvl);
yield return(null);
}
internal void LoadData(int resId)
{
try {
m_SceneResId = resId;
m_SceneContext.SceneResId = resId;
m_SceneContext.IsRunWithRoomServer = true;
LogSys.Log(LOG_TYPE.DEBUG, "Scene {0} start Preloading.", resId);
m_SceneConfig = TableConfig.LevelProvider.Instance.GetLevel(m_SceneResId);
m_SceneState = SceneState.Preloading;
} catch (Exception ex) {
LogSystem.Error("Scene.LoadData throw exception:{0}\n{1}", ex.Message, ex.StackTrace);
}
}
private StoryInstance NewStoryInstance(string storyId, string _namespace, bool logIfNotFound, params string[] overloadFiles)
{
if (!string.IsNullOrEmpty(_namespace))
{
storyId = string.Format("{0}:{1}", _namespace, storyId);
}
StoryInstance instance = GetStoryInstance(storyId);
if (null == instance)
{
TableConfig.Level cfg = TableConfig.LevelProvider.Instance.GetLevel(m_Scene.SceneResId);
if (null != cfg)
{
string[] filePath;
if (overloadFiles.Length <= 0)
{
int ct1 = cfg.SceneDslFile.Count;
int ct2 = cfg.RoomDslFile.Count;
filePath = new string[ct1 + ct2];
for (int i = 0; i < ct1; i++)
{
filePath[i] = HomePath.GetAbsolutePath(FilePathDefine_Server.C_DslPath + cfg.SceneDslFile[i]);
}
for (int i = 0; i < ct2; i++)
{
filePath[ct1 + i] = HomePath.GetAbsolutePath(FilePathDefine_Server.C_DslPath + cfg.RoomDslFile[i]);
}
}
else
{
int ct = overloadFiles.Length;
filePath = new string[ct];
for (int i = 0; i < ct; i++)
{
filePath[i] = HomePath.GetAbsolutePath(FilePathDefine_Server.C_DslPath + overloadFiles[i]);
}
}
StoryConfigManager.Instance.LoadStories(m_Scene.SceneResId, _namespace, filePath);
instance = StoryConfigManager.Instance.NewStoryInstance(storyId, m_Scene.SceneResId);
if (instance == null)
{
if (logIfNotFound)
{
LogSystem.Error("Can't load story config, story:{0} scene:{1} !", storyId, m_Scene.SceneResId);
}
return(null);
}
for (int ix = 0; ix < filePath.Length; ++ix)
{
Dictionary <string, StoryInstance> stories = StoryConfigManager.Instance.GetStories(filePath[ix]);
if (null != stories)
{
foreach (KeyValuePair <string, StoryInstance> pair in stories)
{
if (pair.Key != storyId)
{
AddStoryInstance(pair.Key, pair.Value.Clone());
}
}
}
}
AddStoryInstance(storyId, instance);
return(instance);
}
else
{
if (logIfNotFound)
{
LogSystem.Error("Can't find story config, story:{0} scene:{1} !", storyId, m_Scene.SceneResId);
}
return(null);
}
}
else
{
return(instance);
}
}
private IEnumerator LoadLevel(TableConfig.Level lvl)
{
PluginFramework.Instance.OnSceneLoaded(lvl);
yield return(null);
}
