private void InitializeHandlerPriority()
{
foreach (var entry in _handlerDict)
{
var key = entry.Key;
var handlers = entry.Value;
MessageHandlerData <THandlerProxyInterface> handlerData = new MessageHandlerData <THandlerProxyInterface>();
var listHandlers = new List <THandlerProxyInterface>();
var queueHandlerDict = new Dictionary <THandlerProxyInterface, int>();
foreach (var handler in handlers)
{
var priority = GetHandleMethodPriority(handler, key);
if (priority == null)
{
listHandlers.Add(handler);
}
else
{
queueHandlerDict.Add(handler, priority.Value);
}
}
handlerData.AllHandlers = handlers;
handlerData.ListHandlers = listHandlers;
handlerData.QueuedHandlers = queueHandlerDict.OrderBy(x => x.Value).Select(x => x.Key);
_messageHandlerDict.Add(key, handlerData);
}
}
protected override void HandleChatAtServer(MessageHandlerData messageHandler)
{
ChatMessage message = FillChatChannelId(messageHandler.ReadMessage <ChatMessage>());
// Local chat will processes immediately, not have to be sent to chat server
if (message.channel == ChatChannel.Local)
{
ReadChatMessage(message);
return;
}
if (message.channel == ChatChannel.System)
{
if (CanSendSystemAnnounce(message.sender))
{
// Send chat message to chat server, for MMO mode chat message handling by chat server
if (ChatNetworkManager.IsClientConnected)
{
ChatNetworkManager.SendEnterChat(null, MMOMessageTypes.Chat, message.channel, message.message, message.sender, message.receiver, message.channelId);
}
}
return;
}
// Send chat message to chat server, for MMO mode chat message handling by chat server
if (ChatNetworkManager.IsClientConnected)
{
ChatNetworkManager.SendEnterChat(null, MMOMessageTypes.Chat, message.channel, message.message, message.sender, message.receiver, message.channelId);
}
}
private void HandleChat(MessageHandlerData messageHandler)
{
long connectionId = messageHandler.ConnectionId;
ChatMessage message = messageHandler.ReadMessage <ChatMessage>();
switch (message.channel)
{
case ChatChannel.Local:
case ChatChannel.Global:
case ChatChannel.System:
case ChatChannel.Party:
case ChatChannel.Guild:
// Send message to all map servers, let's map servers filter messages
SendPacketToAllConnections(0, DeliveryMethod.ReliableOrdered, MMOMessageTypes.Chat, (writer) => writer.PutValue(message));
break;
case ChatChannel.Whisper:
long senderConnectionId = 0;
long receiverConnectionId = 0;
// Send message to map server which have the character
if (!string.IsNullOrEmpty(message.sender) && ConnectionIdsByCharacterName.TryGetValue(message.sender, out senderConnectionId))
{
SendPacket(senderConnectionId, 0, DeliveryMethod.ReliableOrdered, MMOMessageTypes.Chat, (writer) => writer.PutValue(message));
}
if (!string.IsNullOrEmpty(message.receiver) && ConnectionIdsByCharacterName.TryGetValue(message.receiver, out receiverConnectionId) && (receiverConnectionId != senderConnectionId))
{
SendPacket(receiverConnectionId, 0, DeliveryMethod.ReliableOrdered, MMOMessageTypes.Chat, (writer) => writer.PutValue(message));
}
break;
}
}
protected override void HandleWarpAtClient(MessageHandlerData messageHandler)
{
MMOWarpMessage message = messageHandler.ReadMessage <MMOWarpMessage>();
Assets.offlineScene.SceneName = string.Empty;
StopClient();
StartClient(message.networkAddress, message.networkPort);
}
private void HandleUpdatePartyMemberAtClient(MessageHandlerData messageHandler)
{
UpdateSocialMemberMessage message = messageHandler.ReadMessage <UpdateSocialMemberMessage>();
if (mapNetworkManager != null)
{
mapNetworkManager.OnUpdatePartyMember(message);
}
}
private void HandleUpdateMapUserAtClient(MessageHandlerData messageHandler)
{
UpdateUserCharacterMessage message = messageHandler.ReadMessage <UpdateUserCharacterMessage>();
if (mapNetworkManager != null)
{
mapNetworkManager.OnUpdateMapUser(message);
}
}
private void HandleUpdateGuildAtClient(MessageHandlerData messageHandler)
{
UpdateGuildMessage message = messageHandler.ReadMessage <UpdateGuildMessage>();
if (mapNetworkManager != null)
{
mapNetworkManager.OnUpdateGuild(message);
}
}
private void HandleChatAtClient(MessageHandlerData messageHandler)
{
ChatMessage message = messageHandler.ReadMessage <ChatMessage>();
if (mapNetworkManager != null)
{
mapNetworkManager.OnChatMessageReceive(message);
}
}
private void HandleAppServerAddress(MessageHandlerData messageHandler)
{
ResponseAppServerAddressMessage response = messageHandler.ReadMessage <ResponseAppServerAddressMessage>();
if (onResponseAppServerAddress != null)
{
onResponseAppServerAddress.Invoke(AckResponseCode.Success, response.peerInfo);
}
}
private void HandleGuildWarStatusAtClient(MessageHandlerData messageHandler)
{
if (IsServer)
{
return;
}
GuildWarRunning = messageHandler.Reader.GetBool();
DefenderGuildId = messageHandler.Reader.GetInt();
DefenderGuildName = messageHandler.Reader.GetString();
}
private void HandleResponseAppServerAddress(MessageHandlerData messageHandler)
{
ResponseAppServerAddressMessage message = messageHandler.ReadMessage <ResponseAppServerAddressMessage>();
CentralServerPeerInfo peerInfo = message.peerInfo;
switch (peerInfo.peerType)
{
case CentralServerPeerType.MapServer:
if (!string.IsNullOrEmpty(peerInfo.extra))
{
if (LogInfo)
{
Logging.Log(LogTag, "Register map server: " + peerInfo.extra);
}
mapServerConnectionIdsBySceneName[peerInfo.extra] = peerInfo;
}
break;
case CentralServerPeerType.InstanceMapServer:
if (!string.IsNullOrEmpty(peerInfo.extra))
{
if (LogInfo)
{
Logging.Log(LogTag, "Register instance map server: " + peerInfo.extra);
}
instanceMapServerConnectionIdsByInstanceId[peerInfo.extra] = peerInfo;
// Warp characters
HashSet <uint> warpingCharacters;
if (instanceMapWarpingCharactersByInstanceId.TryGetValue(peerInfo.extra, out warpingCharacters))
{
BasePlayerCharacterEntity warpingCharacterEntity;
foreach (uint warpingCharacter in warpingCharacters)
{
if (!Assets.TryGetSpawnedObject(warpingCharacter, out warpingCharacterEntity))
{
continue;
}
WarpCharacterToInstanceRoutine(warpingCharacterEntity, peerInfo.extra).Forget();
}
}
}
break;
case CentralServerPeerType.Chat:
if (!ChatNetworkManager.IsClientConnected)
{
if (LogInfo)
{
Logging.Log(LogTag, "Connecting to chat server");
}
ChatNetworkManager.StartClient(this, peerInfo.networkAddress, peerInfo.networkPort);
}
break;
}
}
protected void ReadMsgMatchStatus(MessageHandlerData messageHandler)
{
var msg = messageHandler.ReadMessage <OpMsgMatchStatus>();
RemainsMatchTime = msg.remainsMatchTime;
if (!IsMatchEnded && msg.isMatchEnded)
{
IsMatchEnded = true;
MatchEndedAt = Time.unscaledTime;
}
}
private void HandleUpdateMapUserAtServer(MessageHandlerData messageHandler)
{
long connectionId = messageHandler.ConnectionId;
UpdateUserCharacterMessage message = messageHandler.ReadMessage <UpdateUserCharacterMessage>();
if (mapServerConnectionIds.Contains(connectionId))
{
UserCharacterData userData;
switch (message.type)
{
case UpdateUserCharacterMessage.UpdateType.Add:
if (!mapUsersById.ContainsKey(message.data.id))
{
mapUsersById[message.data.id] = message.data;
connectionIdsByCharacterId[message.data.id] = connectionId;
connectionIdsByCharacterName[message.data.characterName] = connectionId;
UpdateMapUser(UpdateUserCharacterMessage.UpdateType.Add, message.data, connectionId);
if (LogInfo)
{
Logging.Log(LogTag, "Add map user: "******" by " + connectionId);
}
}
break;
case UpdateUserCharacterMessage.UpdateType.Remove:
if (mapUsersById.TryGetValue(message.data.id, out userData))
{
mapUsersById.Remove(userData.id);
connectionIdsByCharacterId.Remove(userData.id);
connectionIdsByCharacterName.Remove(userData.characterName);
UpdateMapUser(UpdateUserCharacterMessage.UpdateType.Remove, userData, connectionId);
if (LogInfo)
{
Logging.Log(LogTag, "Remove map user: "******" by " + connectionId);
}
}
break;
case UpdateUserCharacterMessage.UpdateType.Online:
if (mapUsersById.ContainsKey(message.data.id))
{
mapUsersById[message.data.id] = message.data;
UpdateMapUser(UpdateUserCharacterMessage.UpdateType.Online, message.data, connectionId);
if (LogInfo)
{
Logging.Log(LogTag, "Update map user: "******" by " + connectionId);
}
}
break;
}
}
}
protected void ReadMsgGameRule(MessageHandlerData messageHandler)
{
if (IsServer)
{
return;
}
var msg = messageHandler.ReadMessage <OpMsgGameRule>();
BaseNetworkGameRule foundGameRule;
if (BaseNetworkGameInstance.GameRules.TryGetValue(msg.gameRuleName, out foundGameRule))
{
gameRule = foundGameRule;
gameRule.InitialClientObjects(Client);
}
}
private void HandleUpdateGuild(MessageHandlerData messageHandler)
{
long connectionId = messageHandler.ConnectionId;
UpdateGuildMessage message = messageHandler.ReadMessage <UpdateGuildMessage>();
if (MapServerPeers.ContainsKey(connectionId))
{
foreach (long mapServerConnectionId in MapServerPeers.Keys)
{
if (mapServerConnectionId != connectionId)
{
SendPacket(mapServerConnectionId, 0, DeliveryMethod.ReliableOrdered, MMOMessageTypes.UpdateGuild, (writer) => writer.PutValue(message));
}
}
}
}
private void HandleUpdateGuildAtServer(MessageHandlerData messageHandler)
{
long connectionId = messageHandler.ConnectionId;
UpdateGuildMessage message = messageHandler.ReadMessage <UpdateGuildMessage>();
if (mapServerConnectionIds.Contains(connectionId))
{
foreach (long mapServerConnectionId in mapServerConnectionIds)
{
if (mapServerConnectionId != connectionId)
{
ServerSendPacket(mapServerConnectionId, DeliveryMethod.ReliableOrdered, MMOMessageTypes.UpdateGuild, message);
}
}
}
}
private void HandleChatAtServer(MessageHandlerData messageHandler)
{
long connectionId = messageHandler.ConnectionId;
ChatMessage message = messageHandler.ReadMessage <ChatMessage>();
if (LogInfo)
{
Logging.Log(LogTag, "Handle chat: " + message.channel + " sender: " + message.sender + " receiver: " + message.receiver + " message: " + message.message);
}
switch (message.channel)
{
case ChatChannel.Global:
case ChatChannel.System:
ServerSendPacketToAllConnections(DeliveryMethod.ReliableOrdered, MMOMessageTypes.Chat, message);
break;
case ChatChannel.Party:
case ChatChannel.Guild:
// Send message to all map servers, let's map servers filter messages
ServerSendPacketToAllConnections(DeliveryMethod.ReliableOrdered, MMOMessageTypes.Chat, message);
break;
case ChatChannel.Whisper:
long senderConnectionId = 0;
long receiverConnectionId = 0;
// Send message to map server which have the character
if (!string.IsNullOrEmpty(message.sender) &&
connectionIdsByCharacterName.TryGetValue(message.sender, out senderConnectionId))
{
ServerSendPacket(senderConnectionId, DeliveryMethod.ReliableOrdered, MMOMessageTypes.Chat, message);
}
if (!string.IsNullOrEmpty(message.receiver) &&
connectionIdsByCharacterName.TryGetValue(message.receiver, out receiverConnectionId) &&
(receiverConnectionId != senderConnectionId))
{
ServerSendPacket(receiverConnectionId, DeliveryMethod.ReliableOrdered, MMOMessageTypes.Chat, message);
}
break;
}
}
private void HandleUpdateMapUser(MessageHandlerData messageHandler)
{
long connectionId = messageHandler.ConnectionId;
UpdateUserCharacterMessage message = messageHandler.ReadMessage <UpdateUserCharacterMessage>();
SocialCharacterData userData;
switch (message.type)
{
case UpdateUserCharacterMessage.UpdateType.Add:
if (!MapUsersByCharacterId.ContainsKey(message.character.id))
{
MapUsersByCharacterId[message.character.id] = message.character;
ConnectionIdsByCharacterId[message.character.id] = connectionId;
ConnectionIdsByCharacterName[message.character.characterName] = connectionId;
UpdateMapUser(UpdateUserCharacterMessage.UpdateType.Add, message.character, connectionId);
}
break;
case UpdateUserCharacterMessage.UpdateType.Remove:
if (MapUsersByCharacterId.TryGetValue(message.character.id, out userData))
{
MapUsersByCharacterId.Remove(userData.id);
ConnectionIdsByCharacterId.Remove(userData.id);
ConnectionIdsByCharacterName.Remove(userData.characterName);
UpdateMapUser(UpdateUserCharacterMessage.UpdateType.Remove, userData, connectionId);
}
break;
case UpdateUserCharacterMessage.UpdateType.Online:
if (MapUsersByCharacterId.ContainsKey(message.character.id))
{
MapUsersByCharacterId[message.character.id] = message.character;
UpdateMapUser(UpdateUserCharacterMessage.UpdateType.Online, message.character, connectionId);
}
break;
}
}
protected void ReadMsgSendScores(MessageHandlerData messageHandler)
{
var msg = messageHandler.ReadMessage <OpMsgSendScores>();
UpdateScores(msg.scores);
}
private void OnMessageReceivedHandler(MessageHandlerData netmsg)
{
NetworkReceivedPacket(netmsg.ConnectionId, new ArraySegment <byte>(netmsg.Reader.GetArray <byte>()));
}
protected void ReadMsgKillNotify(MessageHandlerData messageHandler)
{
var msg = messageHandler.ReadMessage <OpMsgKillNotify>();
KillNotify(msg.killerName, msg.victimName, msg.weaponId);
}
