private void OnSaveReply(Msg_DL_SaveResult msg, PBChannel channel, int src, uint session)
{
KeyString key = KeyString.Wrap(msg.PrimaryKeys);
ConcurrentDictionary <KeyString, ConcurrentQueue <SaveRequestInfo> > dict;
if (m_SaveRequestQueues.TryGetValue(msg.MsgId, out dict))
{
ConcurrentQueue <SaveRequestInfo> reqQueue;
if (dict.TryGetValue(key, out reqQueue))
{
SaveRequestInfo info;
if (reqQueue.TryPeek(out info))
{
if (info.m_Request.SerialNo == msg.SerialNo)
{
if (null != info.m_Callback)
{
info.m_Callback(msg);
}
SaveRequestInfo delInfo;
if (reqQueue.TryDequeue(out delInfo))
{
m_SaveRequestPool.Recycle(delInfo);
}
//发送队列中的下一个消息
if (reqQueue.TryPeek(out info))
{
info.m_LastSendTime = TimeUtility.GetLocalMilliseconds();
m_DataStoreChannel.Send(info.m_Request);
}
}
}
}
}
}
private void DoSaveReply(NLRep_Save msg, PBChannel channel, int src, uint session)
{
string timeoutKey = string.Format("{0}:{1}", msg.DsMsgId, msg.Key);
SaveCallback cb = saveOpt_timeout_.Get(timeoutKey);
if (null != cb)
{
DSSaveResult saveRet = DSSaveResult.UnknownError;
string errorStr = "Save Unknown Error";
if (msg.Result == NLRep_Save.Types.SaveResult.Success)
{
saveRet = DSSaveResult.Success;
errorStr = "Save Success";
}
else if (msg.Result == NLRep_Save.Types.SaveResult.Error)
{
saveRet = DSSaveResult.PostError;
if (msg.HasError)
{
errorStr = msg.Error.ToString();
}
else
{
errorStr = "Save Post Error";
}
}
cb(saveRet, errorStr);
saveOpt_timeout_.Remove(timeoutKey);
}
}
private void HandleBattleEnd(Msg_RL_BattleEnd msg, PBChannel channel, int src, uint session)
{
int roomID = msg.RoomID;
LogSys.Log(LOG_TYPE.DEBUG, "Battle Info: RoomID = {0}", roomID);
m_RoomProcessThread.QueueAction(m_RoomProcessThread.OnRoomBattleEnd, msg);
}
private void ConnectHandler(LNReq_Connect msg, PBChannel channel, int handle, uint seq)
{
if (!Enable)
{
LogSys.Log(LOG_TYPE.ERROR, "Connect to DataStorNode while DataOperator is Disable");
return;
}
try
{
bool ret = true;
string errorMsg = string.Empty;
LogSys.Log(LOG_TYPE.INFO, "DataStoreClient connect :{0} ", msg.ClientName);
var reply = NLRep_Connect.CreateBuilder();
reply.SetResult(ret);
reply.SetError(errorMsg);
channel.Send(reply.Build());
}
catch (Exception e)
{
var reply = NLRep_Connect.CreateBuilder();
reply.SetResult(false);
reply.SetError(e.Message);
channel.Send(reply.Build());
}
}
private void HandleReconnectUser(Msg_LR_ReconnectUser urMsg, PBChannel channel, int handle, uint seq)
{
bool isFieldThread;
int ix = GetActiveRoomThreadIndex(urMsg.RoomID, out isFieldThread);
if (ix < 0)
{
Msg_RL_ReplyReconnectUser replyBuilder = new Msg_RL_ReplyReconnectUser();
replyBuilder.UserGuid = urMsg.UserGuid;
replyBuilder.RoomID = urMsg.RoomID;
replyBuilder.Result = (int)Msg_RL_ReplyReconnectUser.ReconnectResultEnum.NotExist;
channel.Send(replyBuilder);
}
else
{
if (isFieldThread)
{
RoomThread roomThread = field_roomthread_list_[ix];
roomThread.QueueAction(roomThread.HandleReconnectUser, urMsg, channel, handle, seq);
}
else
{
RoomThread roomThread = roomthread_list_[ix];
roomThread.QueueAction(roomThread.HandleReconnectUser, urMsg, channel, handle, seq);
}
}
}
private void HandleUserQuit(Msg_LR_UserQuit msg, PBChannel channel, int handle, uint seq)
{
bool isFieldThread;
int ix = GetActiveRoomThreadIndex(msg.RoomID, out isFieldThread);
if (ix >= 0)
{
if (isFieldThread)
{
RoomThread roomThread = field_roomthread_list_[ix];
roomThread.QueueAction(roomThread.HandleUserQuit, msg, channel);
}
else
{
RoomThread roomThread = roomthread_list_[ix];
roomThread.QueueAction(roomThread.HandleUserQuit, msg, channel);
}
}
else
{
Msg_RL_UserQuit replyBuilder = new Msg_RL_UserQuit();
replyBuilder.UserGuid = msg.UserGuid;
replyBuilder.RoomID = msg.RoomID;
channel.Send(replyBuilder);
}
}
/// <summary>
/// 解码protobuf消息
/// </summary>
/// <param name="data">字节数据</param>
/// <param name="t_query">消息(id->type)查询函数</param>
/// <param name="msg">返回的消息object</param>
/// <param name="id">返回的消息id</param>
/// <returns></returns>
public static bool Decode(
byte[] data, PBChannel.MsgTypeQuery t_query,
out object msg, out int id)
{
bool ret = false;
id = BitConverter.ToInt32(data, 0);
id = IPAddress.NetworkToHostOrder(id);
Type t = t_query(id);
if (null != t) {
DataStream.SetLength(0);
DataStream.Write(data, 4, data.Length - 4);
DataStream.Position = 0;
try {
msg = Serializer.Deserialize(DataStream, null, t);
if (msg == null) {
ret = false;
} else {
ret = true;
}
} catch {
msg = null;
ret = false;
}
} else {
msg = null;
}
return ret;
}
private void HandleActiveScene(Msg_LR_ActiveScene msg, PBChannel channel, int handle, uint seq)
{
int roomid = msg.RoomID;
int sceneId = msg.SceneID;
List <ulong> users = msg.UserGuids;
int thread_id = GetIdleThread();
if (thread_id < 0)
{
LogSys.Log(LOG_TYPE.ERROR, "all room are using, active room failed!");
Msg_RL_ActiveSceneResult retMsg = new Msg_RL_ActiveSceneResult();
retMsg.UserGuids.AddRange(users);
retMsg.RoomID = roomid;
retMsg.Result = (int)SceneOperationResultEnum.Cant_Find_Room;
return;
}
RoomThread roomThread = roomthread_list_[thread_id];
AddActiveRoom(roomid, thread_id, false);
roomThread.PreActiveRoom();
LogSys.Log(LOG_TYPE.INFO, "queue active room {0} scene {1} thread {2}", roomid, sceneId, thread_id);
roomThread.QueueAction(roomThread.ActiveRoom, roomid, sceneId, (MyAction <bool>)((bool val) => {
Msg_RL_ActiveSceneResult retMsg = new Msg_RL_ActiveSceneResult();
retMsg.UserGuids.AddRange(users);
retMsg.RoomID = roomid;
retMsg.Result = val ? (int)SceneOperationResultEnum.Success : (int)SceneOperationResultEnum.Cant_Find_Room;
}));
}
internal void Init(PBChannel channel)
{
channel_ = channel;
channel_.Register <LNReq_Connect>(ConnectHandler);
channel_.Register <LNReq_Load>(LoadHandler);
LogSys.Log(LOG_TYPE.INFO, "DataScheduler initialized");
}
private void OnLoadReply(NLRep_Load msg, PBChannel channel, int src, uint session)
{
if (null != m_RunningThread)
{
m_RunningThread.QueueAction(this.DoLoadReply, msg, channel, src, session);
}
}
internal void HandleReconnectUser(Msg_LR_ReconnectUser urMsg, PBChannel channel, int handle, uint seq)
{
Msg_RL_ReplyReconnectUser.ReconnectResultEnum result;
User us = GetUserByGuid(urMsg.UserGuid);
if (null != us)
{
if ((int)UserControlState.UserDropped == us.UserControlState || !us.IsConnected())
{
result = Msg_RL_ReplyReconnectUser.ReconnectResultEnum.Drop;
}
else
{
result = Msg_RL_ReplyReconnectUser.ReconnectResultEnum.Online;
}
}
else
{
result = Msg_RL_ReplyReconnectUser.ReconnectResultEnum.NotExist;
}
Msg_RL_ReplyReconnectUser replyBuilder = new Msg_RL_ReplyReconnectUser();
replyBuilder.UserGuid = urMsg.UserGuid;
replyBuilder.RoomID = urMsg.RoomID;
replyBuilder.Result = (int)result;
channel.Send(replyBuilder);
}
private void OnLoadReply(Msg_DL_LoadResult msg, PBChannel channel, int src, uint session)
{
KeyString key = KeyString.Wrap(msg.PrimaryKeys);
ConcurrentDictionary <KeyString, LoadRequestInfo> dict;
if (m_LoadRequests.TryGetValue(msg.MsgId, out dict))
{
LoadRequestInfo info;
if (dict.TryGetValue(key, out info))
{
if (info.m_Request.SerialNo == msg.SerialNo)
{
if (null != info.m_Callback)
{
info.m_Callback(msg);
}
LoadRequestInfo delInfo;
if (dict.TryRemove(key, out delInfo))
{
m_LoadRequestPool.Recycle(delInfo);
}
}
}
}
}
private void Init(string[] args)
{
m_NameHandleCallback = this.OnNameHandleChanged;
m_MsgCallback = this.OnMessage;
m_MsgResultCallback = this.OnMessageResultCallback;
m_CmdCallback = this.OnCommand;
m_LogHandler = this.OnCenterLog;
CenterClientApi.SetCenterLogHandler(m_LogHandler);
CenterClientApi.Init("datacache", args.Length, args, m_NameHandleCallback, m_MsgCallback, m_MsgResultCallback, m_CmdCallback);
m_Channel = new PBChannel(DataMessageEnum2Type.Query,
DataMessageEnum2Type.Query);
m_Channel.DefaultServiceName = "UserSvr";
LogSys.Init("./config/logconfig.xml");
DataCacheConfig.Init();
GlobalVariables.Instance.IsClient = false;
string key = "防君子不防小人";
byte[] xor = Encoding.UTF8.GetBytes(key);
ResourceReadProxy.OnReadAsArray = ((string filePath) => {
byte[] buffer = null;
try {
buffer = File.ReadAllBytes(filePath);
} catch (Exception e) {
LogSys.Log(LOG_TYPE.ERROR, "Exception:{0}\n{1}", e.Message, e.StackTrace);
return(null);
}
return(buffer);
});
LogSystem.OnOutput += (Log_Type type, string msg) => {
switch (type)
{
case Log_Type.LT_Debug:
LogSys.Log(LOG_TYPE.DEBUG, msg);
break;
case Log_Type.LT_Info:
LogSys.Log(LOG_TYPE.INFO, msg);
break;
case Log_Type.LT_Warn:
LogSys.Log(LOG_TYPE.WARN, msg);
break;
case Log_Type.LT_Error:
case Log_Type.LT_Assert:
LogSys.Log(LOG_TYPE.ERROR, msg);
break;
}
};
DbThreadManager.Instance.Init(DataCacheConfig.LoadThreadNum, DataCacheConfig.SaveThreadNum);
DataOpSystem.Instance.Init(m_Channel);
DataCacheSystem.Instance.Init();
LogSys.Log(LOG_TYPE.INFO, "DataCache initialized");
}
private void HandleUserChangeScene(Msg_BL_UserChangeScene msg_, PBChannel channel, int src, uint session)
{
UserProcessScheduler dataProcess = UserServer.Instance.UserProcessScheduler;
UserInfo user = dataProcess.GetUserInfo(msg_.Guid);
if (user != null) {
user.SceneId = msg_.SceneId;
}
}
private void HandleQueryUserStateResult(Msg_BL_QueryUserStateResult msg_, PBChannel channel, int src, uint session)
{
UserProcessScheduler dataProcess = UserServer.Instance.UserProcessScheduler;
UserInfo user = dataProcess.GetUserInfo(msg_.Guid);
if (user != null && user.CurrentState == UserState.Room) {
user.CurrentState = UserState.Online;
}
}
internal void Init(PBChannel channel)
{
m_DataStoreChannel = channel;
channel.Register <Msg_DL_Connect>(OnConnectDataStore);
channel.Register <Msg_DL_LoadResult>(OnLoadReply);
channel.Register <Msg_DL_SaveResult>(OnSaveReply);
}
private void Init(string[] args)
{
m_NameHandleCallback = this.OnNameHandleChanged;
m_MsgCallback = this.OnMessage;
m_CmdCallback = this.OnCommand;
m_MsgResultCallback = this.OnMessageResult;
CenterClientApi.Init("store", args.Length, args, m_NameHandleCallback, m_MsgCallback, m_MsgResultCallback, m_CmdCallback);
m_Channel = new PBChannel(DashFire.DataStore.MessageMapping.Query,
DashFire.DataStore.MessageMapping.Query);
m_Channel.DefaultServiceName = "Lobby";
LogSys.Init("./config/logconfig.xml");
DataStoreConfig.Init();
ArkCrossEngine.GlobalVariables.Instance.IsClient = false;
FileReaderProxy.RegisterReadFileHandler((string filePath) =>
{
byte[] buffer = null;
try
{
buffer = File.ReadAllBytes(filePath);
}
catch (Exception e)
{
LogSys.Log(LOG_TYPE.ERROR, "Exception:{0}\n{1}", e.Message, e.StackTrace);
return(null);
}
return(buffer);
}, (string filepath) => { return(File.Exists(filepath)); });
LogSystem.OnOutput += (Log_Type type, string msg) =>
{
switch (type)
{
case Log_Type.LT_Debug:
LogSys.Log(LOG_TYPE.DEBUG, msg);
break;
case Log_Type.LT_Info:
LogSys.Log(LOG_TYPE.INFO, msg);
break;
case Log_Type.LT_Warn:
LogSys.Log(LOG_TYPE.WARN, msg);
break;
case Log_Type.LT_Error:
case Log_Type.LT_Assert:
LogSys.Log(LOG_TYPE.ERROR, msg);
break;
}
};
DbThreadManager.Instance.Init(DataStoreConfig.LoadThreadNum, DataStoreConfig.SaveThreadNum);
DataOpSystem.Instance.Init(m_Channel);
DataCacheSystem.Instance.Init();
LogSys.Log(LOG_TYPE.INFO, "DataStore initialized");
}
private void HandleUserOffline(Msg_BL_UserOffline msg_, PBChannel channel, int src, uint session)
{
UserProcessScheduler dataProcess = UserServer.Instance.UserProcessScheduler;
UserInfo user = dataProcess.GetUserInfo(msg_.Guid);
if (user != null && user.CurrentState == UserState.Room) {
user.CurrentState = UserState.Online;
user.LeftLife = 0;
}
}
private void HandleStoryMessageFromRoom(Msg_LRL_StoryMessage msg, PBChannel channel, int src, uint session)
{
UserInfo user = m_UserProcessScheduler.GetUserInfo(msg.UserGuid);
if (null != user)
{
ForwardToWorld(user.UserSvrName, msg);
}
}
internal void Init(PBChannel channel)
{
channel_ = channel;
channel_.Register <LNReq_Connect>(ConnectHandler);
channel_.Register <LNReq_Load>(LoadHandler);
channel_.Register <LNReq_Save>(SaveHandler);
InitDSNodeVersion();
LogSys.Log(LOG_TYPE.INFO, "DataOperator initialized");
}
private void HandleRoomServerUpdateInfo(Msg_RL_RoomServerUpdateInfo updateMsg, PBChannel channel, int src, uint session)
{
//更新RoomServer信息
m_RoomProcessThread.UpdateRoomServerInfo(new RoomServerInfo {
RoomServerName = updateMsg.ServerName,
IdleRoomNum = updateMsg.IdleRoomNum,
UserNum = updateMsg.UserNum
});
}
private void HandleRegisterRoomServer(Msg_RL_RegisterRoomServer msg_, PBChannel channel, int src, uint session)
{
m_RoomProcessThread.RegisterRoomServer(new RoomServerInfo {
RoomServerName = msg_.ServerName,
MaxRoomNum = msg_.MaxRoomNum,
ServerIp = msg_.ServerIp,
ServerPort = msg_.ServerPort
});
}
private void HandleRegisterRoomServer(Msg_RL_RegisterRoomServer msg_, PBChannel channel, int src, uint session)
{
m_RoomProcessThread.RegisterRoomServer(new RoomServerInfo {
RoomServerName = msg_.ServerName,
MaxRoomNum = msg_.MaxRoomNum,
ServerIp = msg_.ServerIp,
ServerPort = msg_.ServerPort
});
}
private void HandleUserRelive(Msg_LR_UserReLive msg, PBChannel channel, int handle, uint seq)
{
int ix = GetActiveRoomThreadIndex(msg.RoomID);
if (ix >= 0)
{
RoomThread roomThread = roomthread_list_[ix];
roomThread.QueueAction(roomThread.HandleUserRelive, msg);
}
}
private void HandleQueryUserStateResult(Msg_BL_QueryUserStateResult msg_, PBChannel channel, int src, uint session)
{
UserProcessScheduler dataProcess = UserServer.Instance.UserProcessScheduler;
UserInfo user = dataProcess.GetUserInfo(msg_.Guid);
if (user != null && user.CurrentState == UserState.Room)
{
user.CurrentState = UserState.Online;
}
}
private void HandleUserChangeScene(Msg_BL_UserChangeScene msg_, PBChannel channel, int src, uint session)
{
UserProcessScheduler dataProcess = UserServer.Instance.UserProcessScheduler;
UserInfo user = dataProcess.GetUserInfo(msg_.Guid);
if (user != null)
{
user.SceneId = msg_.SceneId;
}
}
private void InstallMessageHandlers()
{
m_DataCacheChannel = new PBChannel(DataMessageEnum2Type.Query, DataMessageEnum2Type.Query);
m_DataCacheChannel.WorldId = UserServerConfig.WorldId;
m_DataCacheChannel.DefaultServiceName = "DataCache";
InstallNodeHandlers();
InstallGmJsonHandlers();
InstallBigworldHandlers();
}
private void HandleRoomStoryMessage(Msg_LRL_StoryMessage msg_, PBChannel channel, int src, uint session)
{
UserProcessScheduler dataProcess = UserServer.Instance.UserProcessScheduler;
UserThread userThread = dataProcess.GetUserThread(msg_.UserGuid);
if (null != userThread) {
userThread.QueueAction(userThread.HandleRoomStoryMessage, msg_);
} else {
dataProcess.DefaultUserThread.QueueAction(dataProcess.DefaultUserThread.HandleRoomStoryMessage, msg_);
}
}
private void InstallServerHandlers()
{
m_RoomSvrChannel = new PBChannel(MessageMapping.Query, MessageMapping.Query);
m_RoomSvrChannel.Register <Msg_RL_RegisterRoomServer>(HandleRegisterRoomServer);
m_RoomSvrChannel.Register <Msg_RL_RoomServerUpdateInfo>(HandleRoomServerUpdateInfo);
m_RoomSvrChannel.Register <Msg_RL_ReplyCreateBattleRoom>(HandelReplyCreateBattleRoom);
m_RoomSvrChannel.Register <Msg_RL_UserQuit>(HandleUserQuit);
m_RoomSvrChannel.Register <Msg_RL_ReplyReconnectUser>(HandelReplyReconnectUser);
m_RoomSvrChannel.Register <Msg_RL_BattleEnd>(HandleBattleEnd);
}
private void InstallMessageHandlers()
{
m_DataCacheChannel = new PBChannel(DataMessageEnum2Type.Query,
DataMessageEnum2Type.Query);
m_DataCacheChannel.DefaultServiceName = "DataCache";
InstallUserHandlers();
InstallServerHandlers();
InstallNodeHandlers();
}
public BillingClient(PBChannel channel, MyServerThread thread)
{
channel_ = channel;
m_RunningThread = thread;
channel_.Register <BL_VerifyAccountResult>(OnVerifyAccountResult);
m_VerifyAccountTimeout = new Timeout <VerifyAccountCB>();
m_VerifyAccountTimeout.DefaultTimeoutMS = 10000; //超时时间
m_VerifyAccountWatch = new OperationWatch();
}
/// <summary>
/// 注意，userserver来的消息在主线程处理，再分发到其它线程
/// </summary>
private void InstallUserHandlers()
{
m_UserChannel = new PBChannel(BigworldAndRoomServerMessageEnum2Type.Query, BigworldAndRoomServerMessageEnum2Type.Query);
m_UserChannel.Register <Msg_LBL_Message>(HandleGeneralMessage);
m_UserChannel.Register <Msg_LB_UpdateUserServerInfo>(HandleUpdateUserServerInfo);
m_UserChannel.Register <Msg_LB_QueryUserState>(HandleQueryUserState);
m_UserChannel.Register <Msg_LB_UserOffline>(HandleUserOffline);
m_UserChannel.Register <Msg_LB_UserRelogin>(HandleUserRelogin);
m_UserChannel.Register <Msg_LB_RequestEnterScene>(HandleRequestEnterScene);
m_UserChannel.Register <Msg_LRL_StoryMessage>(HandleStoryMessageFromUserServer);
}
//--------------------------------------
internal void RegisterMsgHandler(PBChannel channel)
{
channel.Register <Msg_LR_EnterScene>(HandleEnterScene);
channel.Register <Msg_LR_ChangeScene>(HandleChangeScene);
channel.Register <Msg_LR_ActiveScene>(HandleActiveScene);
channel.Register <Msg_LR_ReconnectUser>(HandleReconnectUser);
channel.Register <Msg_LR_UserReLive>(HandleUserRelive);
channel.Register <Msg_LR_UserQuit>(HandleUserQuit);
channel.Register <Msg_LR_ReclaimItem>(HandleReclaimItem);
channel.Register <Msg_LRL_StoryMessage>(HandleRoomStoryMessage);
}
private void HandleChangeSceneResult(Msg_RL_ChangeSceneResult msg, PBChannel channel, int src, uint session)
{
//响应RoomServer消息，进入野外场景结果消息
int hp = 0;
int mp = 0;
if (msg.HP > 0 && msg.MP > 0) {
hp = msg.HP;
mp = msg.MP;
}
m_RoomProcessThread.OnChangeSceneResult(msg.UserGuid, msg.RoomID, msg.TargetRoomID, msg.Result, hp, mp);
}
private void Init(string[] args)
{
m_NameHandleCallback = this.OnNameHandleChanged;
m_MsgCallback = this.OnMessage;
m_MsgResultCallback = this.OnMessageResultCallback;
m_CmdCallback = this.OnCommand;
m_LogHandler = this.OnCenterLog;
CenterClientApi.SetCenterLogHandler(m_LogHandler);
CenterClientApi.Init("datacache", args.Length, args, m_NameHandleCallback, m_MsgCallback, m_MsgResultCallback, m_CmdCallback);
m_Channel = new PBChannel(DataMessageEnum2Type.Query,
DataMessageEnum2Type.Query);
m_Channel.DefaultServiceName = "UserSvr";
LogSys.Init("./config/logconfig.xml");
DataCacheConfig.Init();
GlobalVariables.Instance.IsClient = false;
string key = "防君子不防小人";
byte[] xor = Encoding.UTF8.GetBytes(key);
ResourceReadProxy.OnReadAsArray = ((string filePath) => {
byte[] buffer = null;
try {
buffer = File.ReadAllBytes(filePath);
} catch (Exception e) {
LogSys.Log(LOG_TYPE.ERROR, "Exception:{0}\n{1}", e.Message, e.StackTrace);
return null;
}
return buffer;
});
LogSystem.OnOutput += (Log_Type type, string msg) => {
switch (type) {
case Log_Type.LT_Debug:
LogSys.Log(LOG_TYPE.DEBUG, msg);
break;
case Log_Type.LT_Info:
LogSys.Log(LOG_TYPE.INFO, msg);
break;
case Log_Type.LT_Warn:
LogSys.Log(LOG_TYPE.WARN, msg);
break;
case Log_Type.LT_Error:
case Log_Type.LT_Assert:
LogSys.Log(LOG_TYPE.ERROR, msg);
break;
}
};
DbThreadManager.Instance.Init(DataCacheConfig.LoadThreadNum, DataCacheConfig.SaveThreadNum);
DataOpSystem.Instance.Init(m_Channel);
DataCacheSystem.Instance.Init();
LogSys.Log(LOG_TYPE.INFO, "DataCache initialized");
}
private void HandleUserOffline(Msg_BL_UserOffline msg_, PBChannel channel, int src, uint session)
{
UserProcessScheduler dataProcess = UserServer.Instance.UserProcessScheduler;
UserInfo user = dataProcess.GetUserInfo(msg_.Guid);
if (user != null && user.CurrentState == UserState.Room)
{
user.CurrentState = UserState.Online;
user.LeftLife = 0;
}
}
internal void Init(PBChannel channel)
{
channel_ = channel;
channel_.Register <Msg_LD_Connect>(DSConnectHandler);
channel_.Register <Msg_LD_Load>(DSLoadHandler);
channel_.Register <Msg_LD_Save>(DSSaveHandler);
InitDSNodeVersion();
InitGlobalDataVersion();
LogSys.Log(LOG_TYPE.INFO, "DataOperator initialized");
}
private void LoadHandler(LNReq_Load msg, PBChannel channel, int handle, uint seq)
{
if (!Enable)
{
LogSys.Log(LOG_TYPE.ERROR, "Load a message while DataOperator is Disable");
return;
}
try
{
DataCacheSystem.Instance.LoadActionQueue.QueueAction((MyAction <uint, string, MyAction <DSLoadResult, string, IMessage> >)DataCacheSystem.Instance.Load,
msg.DsMsgId,
msg.Key,
(ret, error, data) =>
{
//这段代码必须保证线程安全，会在不同线程调用！！！
var reply = NLRep_Load.CreateBuilder();
reply.SetDsMsgId(msg.DsMsgId);
reply.SetKey(msg.Key);
if (ret == DSLoadResult.Success)
{
reply.SetResult(NLRep_Load.Types.LoadResult.Success);
reply.SetData(ByteString.Unsafe.FromBytes(channel_.Encode(data)));
}
else if (ret == DSLoadResult.Undone)
{
reply.SetResult(NLRep_Load.Types.LoadResult.Undone);
reply.SetData(ByteString.Unsafe.FromBytes(channel_.Encode(data)));
}
else if (ret == DSLoadResult.NotFound)
{
reply.SetResult(NLRep_Load.Types.LoadResult.NotFound);
reply.SetError(error);
}
else
{
reply.SetResult(NLRep_Load.Types.LoadResult.Error);
reply.SetError(error);
}
NLRep_Load replyData = reply.Build();
channel.Send(replyData);
LogSys.Log(LOG_TYPE.INFO, "Load data finished. msgId:({0}) key:({1}) result:({2}) ", msg.DsMsgId, msg.Key, ret);
});
}
catch (Exception e)
{
var errorReply = NLRep_Load.CreateBuilder();
errorReply.SetResult(NLRep_Load.Types.LoadResult.Error);
errorReply.SetError(e.Message);
channel.Send(errorReply.Build());
LogSys.Log(LOG_TYPE.ERROR, "DataStore load data failed. msgId:({0}) key:({1}) seq:({2}) error:({3} detail:{4})",
msg.DsMsgId, msg.Key, seq, e.Message, e.StackTrace);
}
}
internal void Init(PBChannel channel)
{
channel_ = channel;
channel_.Register<Msg_LD_Connect>(DSConnectHandler);
channel_.Register<Msg_LD_Load>(DSLoadHandler);
channel_.Register<Msg_LD_Save>(DSSaveHandler);
InitDSNodeVersion();
InitGlobalDataVersion();
LogSys.Log(LOG_TYPE.INFO, "DataOperator initialized");
}
/// <summary>
/// 初始化一个channel
/// </summary>
/// <param name="channel">CoreMessageExtendType的枚举值</param>
/// <param name="msgid_query">id->type的查询函数</param>
/// <param name="msgtype_query">type->id的查询函数</param>
public void AddChannel(byte channel,
PBChannel.MsgIdQuery msgid_query,
PBChannel.MsgTypeQuery msgtype_query)
{
if (channel < channels_.Length)
{
if (null == channels_[channel])
{
channels_[channel] = new PBChannel(channel, svr_api_, msgid_query, msgtype_query);
}
}
}
private void HandleGeneralMessage(Msg_LBL_Message msg_, PBChannel channel, int src, uint session)
{
try {
if (msg_.MsgType == Msg_LBL_Message.MsgTypeEnum.Node) {
m_UserProcessScheduler.DispatchJsonMessage(session, src, GetMyHandle(), msg_.Data);
} else if (msg_.MsgType == Msg_LBL_Message.MsgTypeEnum.Room) {
byte[] msgData = msg_.Data;
m_UserChannel.Dispatch(src, session, msgData);
}
} catch (Exception ex) {
LogSys.Log(LOG_TYPE.ERROR, "Exception:{0}\n{1}", ex.Message, ex.StackTrace);
}
}
private void HandleQueryUserState(Msg_LB_QueryUserState msg_, PBChannel channel, int src, uint session)
{
Msg_BL_QueryUserStateResult builder = new Msg_BL_QueryUserStateResult();
builder.Guid = msg_.Guid;
UserInfo info = m_UserProcessScheduler.GetUserInfo(msg_.Guid);
if (null == info) {
builder.State = (int)UserState.DropOrOffline;
} else {
builder.State = (int)info.CurrentState;
}
m_UserChannel.Send(src, builder);
}
private void HandleGeneralMessage(Msg_LBL_Message msg_, PBChannel channel, int src, uint session)
{
try {
if (msg_.MsgType == Msg_LBL_Message.MsgTypeEnum.Node) {
byte[] msgData = msg_.Data;
//观察
m_UserProcessScheduler.DispatchJsonMessage(false, session, 0, 0, msgData);
//转发
NodeMessageDispatcher.ForwardMessage(msg_.TargetName, msgData);
} else if (msg_.MsgType == Msg_LBL_Message.MsgTypeEnum.Room) {
m_BigworldChannel.Dispatch(src, session, msg_.Data);
}
} catch (Exception ex) {
LogSys.Log(LOG_TYPE.ERROR, "Exception:{0}\n{1}", ex.Message, ex.StackTrace);
}
}
private void HandleUserDrop(Msg_RL_UserDrop msg_, PBChannel channel, int src, uint session)
{
}
internal void HandleUserQuit(Msg_LR_UserQuit msg, PBChannel channel)
{
Room room = GetRoomByID(msg.RoomID);
if (null != room) {
User user = room.GetUserByGuid(msg.UserGuid);
if (null != user) {
room.DeleteUser(user);
}
}
Msg_RL_UserQuit replyBuilder = new Msg_RL_UserQuit();
replyBuilder.UserGuid = msg.UserGuid;
replyBuilder.RoomID = msg.RoomID;
channel.Send(replyBuilder);
}
private void HandlePickMoney(Msg_RL_PickMoney msg_, PBChannel channel, int src, uint session)
{
}
private void HandleUserDrop(Msg_RL_UserDrop msg, PBChannel channel, int src, uint session)
{
//响应RoomServer游戏客户端退出消息
m_RoomProcessThread.OnRoomUserDrop(msg.RoomID, msg.UserGuid, msg.IsBattleEnd, msg);
}
private void HandleStoryMessageFromRoom(Msg_LRL_StoryMessage msg, PBChannel channel, int src, uint session)
{
UserInfo user = m_UserProcessScheduler.GetUserInfo(msg.UserGuid);
if(null!=user){
ForwardToWorld(user.UserSvrName, msg);
}
}
private void DSLoadHandler(Msg_LD_Load msg, PBChannel channel, int handle, uint seq)
{
try {
DataCacheSystem.Instance.LoadActionQueue.QueueAction<Msg_LD_Load, PBChannel, int>(DataCacheSystem.Instance.Load, msg, channel, handle);
} catch (Exception e) {
var errorReply = new Msg_DL_LoadResult();
errorReply.MsgId = msg.MsgId;
errorReply.PrimaryKeys.AddRange(msg.PrimaryKeys);
errorReply.SerialNo = msg.SerialNo;
errorReply.ErrorNo = Msg_DL_LoadResult.ErrorNoEnum.Exception;
errorReply.ErrorInfo = e.Message;
channel.Send(errorReply);
LogSys.Log(LOG_TYPE.ERROR, "Load data failed. MsgId:{0}, Key:{1} Error:{2} Detail:{3}", msg.MsgId, msg.PrimaryKeys, e.Message, e.StackTrace);
}
}
private void DSSaveHandler(Msg_LD_Save msg, PBChannel channel, int handle, uint seq)
{
var saveResult = new Msg_DL_SaveResult();
saveResult.MsgId = msg.MsgId;
saveResult.PrimaryKeys.AddRange(msg.PrimaryKeys);
saveResult.SerialNo = msg.SerialNo;
saveResult.ErrorNo = Msg_DL_SaveResult.ErrorNoEnum.Success;
saveResult.ErrorInfo = string.Empty;
try {
//写入数据缓存
//TODO:是否将byte[]解析出protobuf对象? 提前反序列化成对象的好处:1.若数据有错误,反序列化失败,可反馈给lobby;2.protobuf对象可重用?
//TODO:解析primaryKey和foreignKey
DataCacheSystem.Instance.SaveActionQueue.QueueAction(DataCacheSystem.Instance.Save, msg.MsgId, msg.PrimaryKeys, msg.ForeignKeys, msg.Data, msg.SerialNo);
} catch (Exception e) {
saveResult.ErrorNo = Msg_DL_SaveResult.ErrorNoEnum.PostError;
saveResult.ErrorInfo = e.Message;
LogSys.Log(LOG_TYPE.ERROR, "Save data ERROR: MsgId:{0}, Key:{1}, Error:{2}, Detail:{3}", msg.MsgId, msg.PrimaryKeys, e.Message, e.StackTrace);
}
channel.Send(saveResult);
}
private void HandleUserQuit(Msg_RL_UserQuit msg_, PBChannel channel, int src, uint session)
{
}
internal void Release()
{
channel_ = null;
LogSys.Log(LOG_TYPE.INFO, "DataOperator disposed");
}
/// <summary>
/// 注意，bigworld的消息已经分发到RoomProcessThread线程里进行处理，不需要再QueueAction到RoomProcessThread线程
/// </summary>
private void InstallBigworldHandlers()
{
if (UserServerConfig.WorldIdNum > 0) {
m_BigworldChannel = new PBChannel(BigworldAndRoomServerMessageEnum2Type.Query, BigworldAndRoomServerMessageEnum2Type.Query);
m_BigworldChannel.WorldId = UserServerConfig.WorldId1;
m_BigworldChannel.DefaultServiceName = "Lobby";
m_BigworldChannel.Register<Msg_LBL_Message>(HandleGeneralMessage);
m_BigworldChannel.Register<Msg_BL_QueryUserStateResult>(HandleQueryUserStateResult);
m_BigworldChannel.Register<Msg_BL_UserOffline>(HandleUserOffline);
m_BigworldChannel.Register<Msg_BL_BroadcastText>(HandleBroadcastText);
m_BigworldChannel.Register<Msg_BL_UserChangeScene>(HandleUserChangeScene);
m_BigworldChannel.Register<Msg_RL_UserDrop>(HandleUserDrop);
m_BigworldChannel.Register<Msg_RL_UserQuit>(HandleUserQuit);
m_BigworldChannel.Register<Msg_RL_PickMoney>(HandlePickMoney);
m_BigworldChannel.Register<Msg_RL_PickItem>(HandlePickItem);
m_BigworldChannel.Register<Msg_LRL_StoryMessage>(HandleRoomStoryMessage);
}
}
internal void HandleReclaimItem(Msg_LR_ReclaimItem msg, PBChannel channel)
{
Room room = GetRoomByID(msg.RoomID);
if (null != room) {
User user = room.GetUserByGuid(msg.UserGuid);
Scene curScene = room.ActiveScene;
if (null != curScene) {
}
}
}
internal void HandleReconnectUser(Msg_LR_ReconnectUser urMsg, PBChannel channel, int handle, uint seq)
{
Msg_RL_ReplyReconnectUser.ReconnectResultEnum result;
User us = GetUserByGuid(urMsg.UserGuid);
if (null != us) {
if ((int)UserControlState.UserDropped == us.UserControlState || !us.IsConnected()) {
result = Msg_RL_ReplyReconnectUser.ReconnectResultEnum.Drop;
} else {
result = Msg_RL_ReplyReconnectUser.ReconnectResultEnum.Online;
}
} else {
result = Msg_RL_ReplyReconnectUser.ReconnectResultEnum.NotExist;
}
Msg_RL_ReplyReconnectUser replyBuilder = new Msg_RL_ReplyReconnectUser();
replyBuilder.UserGuid = urMsg.UserGuid;
replyBuilder.RoomID = urMsg.RoomID;
replyBuilder.Result = (int)result;
channel.Send(replyBuilder);
}
private void HandlePickItem(Msg_RL_PickItem msg_, PBChannel channel, int src, uint session)
{
}
private void DSConnectHandler(Msg_LD_Connect msg, PBChannel channel, int handle, uint seq)
{
try {
LogSys.Log(LOG_TYPE.INFO, "DataStoreClient connect :{0} ", msg.ClientName);
var reply = new Msg_DL_Connect();
reply.Result = true;
reply.Error = string.Empty;
channel.Send(reply);
} catch (Exception e) {
var reply = new Msg_DL_Connect();
reply.Result = false;
reply.Error = e.Message;
channel.Send(reply);
LogSys.Log(LOG_TYPE.ERROR, "Connect failed. ClientName:{0}", msg.ClientName);
}
}
private void RemoveUserForChangeScene(Room room, User user, ulong userGuid, int roomId, int targetRoomId, PBChannel channel, int handle, uint seq)
{
Msg_RL_ChangeSceneResult replyBuilder = new Msg_RL_ChangeSceneResult();
EntityInfo info = user.Info;
if (null != info) {
replyBuilder.HP = info.Hp;
replyBuilder.MP = info.Energy;
}
room.RemoveUserFromRoomThread(user, true);
replyBuilder.UserGuid = userGuid;
replyBuilder.RoomID = roomId;
replyBuilder.TargetRoomID = targetRoomId;
replyBuilder.Result = (int)SceneOperationResultEnum.Success;
channel.Send(replyBuilder);
}
internal void HandleRoomStoryMessage(Msg_LRL_StoryMessage msg, PBChannel channel)
{
Room room = GetRoomByID(msg.RoomId);
if (null != room) {
User user = room.GetUserByGuid(msg.UserGuid);
Scene curScene = room.ActiveScene;
if (null != user && null != curScene) {
try {
string msgId = string.Format("server:{0}", msg.MsgId);
ArrayList args = new ArrayList();
args.Add(user.RoleId);
for (int i = 0; i < msg.Args.Count; i++) {
switch (msg.Args[i].val_type) {
case Msg_LRL_StoryMessage.ArgType.NULL://null
args.Add(null);
break;
case Msg_LRL_StoryMessage.ArgType.INT://int
args.Add(int.Parse(msg.Args[i].str_val));
break;
case Msg_LRL_StoryMessage.ArgType.FLOAT://float
args.Add(float.Parse(msg.Args[i].str_val));
break;
default://string
args.Add(msg.Args[i].str_val);
break;
}
}
object[] objArgs = args.ToArray();
curScene.StorySystem.SendMessage(msgId, objArgs);
} catch (Exception ex) {
LogSys.Log(LOG_TYPE.ERROR, "Msg_CRC_StoryMessage throw exception:{0}\n{1}", ex.Message, ex.StackTrace);
}
}
}
}
private void HandleBroadcastText(Msg_BL_BroadcastText msg_, PBChannel channel, int src, uint session)
{
m_UserProcessScheduler.DefaultUserThread.QueueAction(m_UserProcessScheduler.HandleBroadcast, (BroadcastType)msg_.BroadcastType, msg_.Content, msg_.RollCount);
}
