protected override void HandleWarpAtClient(LiteNetLibMessageHandler messageHandler)
{
var message = messageHandler.ReadMessage <MMOWarpMessage>();
Assets.offlineScene.SceneName = string.Empty;
StopClient();
Assets.onlineScene.SceneName = message.sceneName;
StartClient(message.networkAddress, message.networkPort, message.connectKey);
}
private void HandleChatAtClient(LiteNetLibMessageHandler messageHandler)
{
ChatMessage message = messageHandler.ReadMessage <ChatMessage>();
if (mapNetworkManager != null)
{
mapNetworkManager.OnChatMessageReceive(message);
}
}
private void HandleUpdatePartyMemberAtClient(LiteNetLibMessageHandler messageHandler)
{
UpdateSocialMemberMessage message = messageHandler.ReadMessage <UpdateSocialMemberMessage>();
if (mapNetworkManager != null)
{
mapNetworkManager.OnUpdatePartyMember(message);
}
}
private void HandleUpdateMapUserAtClient(LiteNetLibMessageHandler messageHandler)
{
UpdateUserCharacterMessage message = messageHandler.ReadMessage <UpdateUserCharacterMessage>();
if (mapNetworkManager != null)
{
mapNetworkManager.OnUpdateMapUser(message);
}
}
protected virtual void HandleChatAtClient(LiteNetLibMessageHandler messageHandler)
{
var message = messageHandler.ReadMessage <ChatMessage>();
if (onClientReceiveChat != null)
{
onClientReceiveChat.Invoke(message);
}
}
protected virtual void HandleGameMessageAtClient(LiteNetLibMessageHandler messageHandler)
{
var message = messageHandler.ReadMessage <GameMessage>();
if (onClientReceiveGameMessage != null)
{
onClientReceiveGameMessage.Invoke(message);
}
}
private void HandleUpdateGuildAtClient(LiteNetLibMessageHandler messageHandler)
{
var message = messageHandler.ReadMessage <UpdateGuildMessage>();
if (mapNetworkManager != null)
{
mapNetworkManager.OnUpdateGuild(message);
}
}
protected override void HandleChatAtServer(LiteNetLibMessageHandler messageHandler)
{
// Send chat message to chat server, for MMO mode chat message handling by chat server
if (ChatNetworkManager.IsClientConnected)
{
var message = FillChatChannelId(messageHandler.ReadMessage <ChatMessage>());
ChatNetworkManager.Client.SendEnterChat(null, MMOMessageTypes.Chat, message.channel, message.message, message.sender, message.receiver, message.channelId);
}
}
protected virtual void HandleUpdateGuildAtClient(LiteNetLibMessageHandler messageHandler)
{
var message = messageHandler.ReadMessage <UpdateGuildMessage>();
if (message.type == UpdateGuildMessage.UpdateType.Create)
{
ClientGuild = new GuildData(message.id, message.guildName, message.characterId);
}
else if (ClientGuild != null && ClientGuild.id == message.id)
{
switch (message.type)
{
case UpdateGuildMessage.UpdateType.ChangeLeader:
ClientGuild.SetLeader(message.characterId);
break;
case UpdateGuildMessage.UpdateType.SetGuildMessage:
ClientGuild.guildMessage = message.guildMessage;
break;
case UpdateGuildMessage.UpdateType.SetGuildRole:
ClientGuild.SetRole(message.guildRole, message.roleName, message.canInvite, message.canKick, message.shareExpPercentage);
break;
case UpdateGuildMessage.UpdateType.SetGuildMemberRole:
ClientGuild.SetMemberRole(message.characterId, message.guildRole);
break;
case UpdateGuildMessage.UpdateType.SetSkillLevel:
ClientGuild.SetSkillLevel(message.dataId, message.level);
if (BasePlayerCharacterController.OwningCharacter != null)
{
BasePlayerCharacterController.OwningCharacter.ForceMakeCaches();
}
break;
case UpdateGuildMessage.UpdateType.LevelExpSkillPoint:
ClientGuild.level = message.level;
ClientGuild.exp = message.exp;
ClientGuild.skillPoint = message.skillPoint;
break;
case UpdateGuildMessage.UpdateType.Terminate:
ClientGuild = null;
if (BasePlayerCharacterController.OwningCharacter != null)
{
BasePlayerCharacterController.OwningCharacter.ForceMakeCaches();
}
break;
}
}
if (onClientUpdateGuild != null)
{
onClientUpdateGuild.Invoke(ClientGuild);
}
}
IEnumerator HandleRequestGooglePlayLoginRoutine(LiteNetLibMessageHandler messageHandler)
{
long connectionId = messageHandler.connectionId;
RequestGooglePlayLoginMessage message = messageHandler.ReadMessage <RequestGooglePlayLoginMessage>();
ResponseUserLoginMessage.Error error = ResponseUserLoginMessage.Error.None;
string userId = string.Empty;
string accessToken = string.Empty;
// Validate by google api
string url = "https://www.googleapis.com/oauth2/v3/tokeninfo?id_token=" + message.idToken;
WebClient webClient = new WebClient();
string json = webClient.DownloadString(url);
Dictionary <string, object> dict = Json.Deserialize(json) as Dictionary <string, object>;
if (dict.ContainsKey("sub") && dict.ContainsKey("email"))
{
string gId = (string)dict["sub"];
string email = (string)dict["email"];
GooglePlayLoginJob job = new GooglePlayLoginJob(Database, gId, email);
job.Start();
yield return(StartCoroutine(job.WaitFor()));
userId = job.result;
}
// Response clients
if (string.IsNullOrEmpty(userId))
{
error = ResponseUserLoginMessage.Error.InvalidUsernameOrPassword;
userId = string.Empty;
}
else if (userPeersByUserId.ContainsKey(userId) || MapContainsUser(userId))
{
error = ResponseUserLoginMessage.Error.AlreadyLogin;
userId = string.Empty;
}
else
{
CentralUserPeerInfo userPeerInfo = new CentralUserPeerInfo();
userPeerInfo.connectionId = connectionId;
userPeerInfo.userId = userId;
userPeerInfo.accessToken = accessToken = Regex.Replace(Convert.ToBase64String(Guid.NewGuid().ToByteArray()), "[/+=]", "");
userPeersByUserId[userId] = userPeerInfo;
userPeers[connectionId] = userPeerInfo;
UpdateAccessTokenJob updateAccessTokenJob = new UpdateAccessTokenJob(Database, userId, accessToken);
updateAccessTokenJob.Start();
yield return(StartCoroutine(updateAccessTokenJob.WaitFor()));
}
ResponseUserLoginMessage responseMessage = new ResponseUserLoginMessage();
responseMessage.ackId = message.ackId;
responseMessage.responseCode = error == ResponseUserLoginMessage.Error.None ? AckResponseCode.Success : AckResponseCode.Error;
responseMessage.error = error;
responseMessage.userId = userId;
responseMessage.accessToken = accessToken;
ServerSendPacket(connectionId, DeliveryMethod.ReliableOrdered, MMOMessageTypes.ResponseUserLogin, responseMessage);
}
protected virtual void HandleRequestCashPackageBuyValidation(LiteNetLibMessageHandler messageHandler)
{
long connectionId = messageHandler.connectionId;
RequestCashPackageBuyValidationMessage message = messageHandler.ReadMessage <RequestCashPackageBuyValidationMessage>();
ResponseCashPackageBuyValidationMessage responseMessage = new ResponseCashPackageBuyValidationMessage();
responseMessage.ackId = message.ackId;
responseMessage.responseCode = AckResponseCode.Error;
responseMessage.error = ResponseCashPackageBuyValidationMessage.Error.NotAvailable;
ServerSendPacket(connectionId, DeliveryMethod.ReliableOrdered, MsgTypes.CashPackageBuyValidation, responseMessage);
}
/// <summary>
/// This is function which read request from map server to spawn another map servers
/// Then it will response back when requested map server is ready
/// </summary>
/// <param name="messageHandler"></param>
protected void HandleRequestSpawnMap(LiteNetLibMessageHandler messageHandler)
{
RequestSpawnMapMessage message = messageHandler.ReadMessage <RequestSpawnMapMessage>();
List <long> connectionIds = new List <long>(mapSpawnServerPeers.Keys);
// Random map-spawn server to spawn map, will use returning ackId as reference to map-server's transport handler and ackId
uint ackId = RequestSpawnMap(connectionIds[Random.Range(0, connectionIds.Count)], message, OnRequestSpawnMap);
// Add ack Id / transport handler to dictionary which will be used in OnRequestSpawnMap() function
// To send map spawn response to map-server
requestSpawnMapHandlers.Add(ackId, new KeyValuePair <TransportHandler, uint>(messageHandler.transportHandler, message.ackId));
}
protected virtual void HandleRequestCashPackageInfo(LiteNetLibMessageHandler messageHandler)
{
var connectionId = messageHandler.connectionId;
var message = messageHandler.ReadMessage <BaseAckMessage>();
var responseMessage = new ResponseCashPackageInfoMessage();
responseMessage.ackId = message.ackId;
responseMessage.responseCode = AckResponseCode.Error;
responseMessage.error = ResponseCashPackageInfoMessage.Error.NotAvailable;
ServerSendPacket(connectionId, SendOptions.ReliableOrdered, MsgTypes.CashPackageInfo, responseMessage);
}
protected virtual void HandleUpdateMapInfoAtClient(LiteNetLibMessageHandler messageHandler)
{
// Don't set map info again at server
if (IsServer)
{
return;
}
UpdateMapInfoMessage message = messageHandler.ReadMessage <UpdateMapInfoMessage>();
SetMapInfo(message.mapId);
}
private IEnumerator HandleRequestCreateCharacterRoutine(LiteNetLibMessageHandler messageHandler)
{
long connectionId = messageHandler.connectionId;
RequestCreateCharacterMessage message = messageHandler.ReadMessage <RequestCreateCharacterMessage>();
ResponseCreateCharacterMessage.Error error = ResponseCreateCharacterMessage.Error.None;
string characterName = message.characterName;
int dataId = message.dataId;
int entityId = message.entityId;
CentralUserPeerInfo userPeerInfo;
FindCharacterNameJob findCharacterNameJob = new FindCharacterNameJob(Database, characterName);
findCharacterNameJob.Start();
yield return(StartCoroutine(findCharacterNameJob.WaitFor()));
if (findCharacterNameJob.result > 0)
{
error = ResponseCreateCharacterMessage.Error.CharacterNameAlreadyExisted;
}
else if (!userPeers.TryGetValue(connectionId, out userPeerInfo))
{
error = ResponseCreateCharacterMessage.Error.NotLoggedin;
}
else if (string.IsNullOrEmpty(characterName) || characterName.Length < minCharacterNameLength)
{
error = ResponseCreateCharacterMessage.Error.TooShortCharacterName;
}
else if (characterName.Length > maxCharacterNameLength)
{
error = ResponseCreateCharacterMessage.Error.TooLongCharacterName;
}
else if (!GameInstance.PlayerCharacters.ContainsKey(dataId) ||
!GameInstance.PlayerCharacterEntities.ContainsKey(entityId))
{
error = ResponseCreateCharacterMessage.Error.InvalidData;
}
else
{
string characterId = GenericUtils.GetUniqueId();
PlayerCharacterData characterData = new PlayerCharacterData();
characterData.Id = characterId;
characterData.SetNewPlayerCharacterData(characterName, dataId, entityId);
DeserializeCreateCharacterExtra(characterData, messageHandler.reader);
CreateCharacterJob createCharacterJob = new CreateCharacterJob(Database, userPeerInfo.userId, characterData);
createCharacterJob.Start();
yield return(StartCoroutine(createCharacterJob.WaitFor()));
}
ResponseCreateCharacterMessage responseMessage = new ResponseCreateCharacterMessage();
responseMessage.ackId = message.ackId;
responseMessage.responseCode = error == ResponseCreateCharacterMessage.Error.None ? AckResponseCode.Success : AckResponseCode.Error;
responseMessage.error = error;
ServerSendPacket(connectionId, DeliveryMethod.ReliableOrdered, MMOMessageTypes.ResponseCreateCharacter, responseMessage);
}
protected void HandleRequestAppServerAddress(LiteNetLibMessageHandler messageHandler)
{
var connectionId = messageHandler.connectionId;
var message = messageHandler.ReadMessage <RequestAppServerAddressMessage>();
var error = ResponseAppServerAddressMessage.Error.None;
var peerInfo = new CentralServerPeerInfo();
switch (message.peerType)
{
// TODO: Balancing servers when there are multiple servers with same type
case CentralServerPeerType.MapSpawnServer:
if (mapSpawnServerPeers.Count > 0)
{
peerInfo = mapSpawnServerPeers.Values.First();
Debug.Log("[Central] Request Map Spawn Address: [" + connectionId + "]");
}
else
{
error = ResponseAppServerAddressMessage.Error.ServerNotFound;
Debug.Log("[Central] Request Map Spawn Address: [" + connectionId + "] [" + error + "]");
}
break;
case CentralServerPeerType.MapServer:
var mapName = message.extra;
if (!mapServerPeersBySceneName.TryGetValue(mapName, out peerInfo))
{
error = ResponseAppServerAddressMessage.Error.ServerNotFound;
Debug.Log("[Central] Request Map Address: [" + connectionId + "] [" + mapName + "] [" + error + "]");
}
break;
case CentralServerPeerType.Chat:
if (chatServerPeers.Count > 0)
{
peerInfo = chatServerPeers.Values.First();
Debug.Log("[Central] Request Chat Address: [" + connectionId + "]");
}
else
{
error = ResponseAppServerAddressMessage.Error.ServerNotFound;
Debug.Log("[Central] Request Chat Address: [" + connectionId + "] [" + error + "]");
}
break;
}
var responseMessage = new ResponseAppServerAddressMessage();
responseMessage.ackId = message.ackId;
responseMessage.responseCode = error == ResponseAppServerAddressMessage.Error.None ? AckResponseCode.Success : AckResponseCode.Error;
responseMessage.error = error;
responseMessage.peerInfo = peerInfo;
ServerSendPacket(connectionId, SendOptions.ReliableOrdered, MMOMessageTypes.ResponseAppServerAddress, responseMessage);
}
private void HandleUpdateMapUserAtServer(LiteNetLibMessageHandler 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)
{
Debug.Log("[Chat] 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)
{
Debug.Log("[Chat] 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)
{
Debug.Log("[Chat] Update map user: "******" by " + connectionId);
}
}
break;
}
}
}
private IEnumerator HandleRequestCashPackageBuyValidationRoutine(LiteNetLibMessageHandler messageHandler)
{
long connectionId = messageHandler.connectionId;
RequestCashPackageBuyValidationMessage message = messageHandler.ReadMessage <RequestCashPackageBuyValidationMessage>();
// TODO: Validate purchasing at server side
// Set response data
ResponseCashPackageBuyValidationMessage.Error error = ResponseCashPackageBuyValidationMessage.Error.None;
int dataId = message.dataId;
int cash = 0;
BasePlayerCharacterEntity playerCharacter;
UserCharacterData userData;
if (!playerCharacters.TryGetValue(connectionId, out playerCharacter) ||
!usersById.TryGetValue(playerCharacter.Id, out userData))
{
error = ResponseCashPackageBuyValidationMessage.Error.UserNotFound;
}
else
{
// Get current cash will return this in case it cannot increase cash
GetCashJob job = new GetCashJob(Database, userData.userId);
job.Start();
yield return(StartCoroutine(job.WaitFor()));
cash = job.result;
CashPackage cashPackage;
if (!GameInstance.CashPackages.TryGetValue(dataId, out cashPackage))
{
error = ResponseCashPackageBuyValidationMessage.Error.PackageNotFound;
}
else
{
IncreaseCashJob increaseCashJob = new IncreaseCashJob(Database, userData.userId, cashPackage.cashAmount);
increaseCashJob.Start();
yield return(StartCoroutine(increaseCashJob.WaitFor()));
cash = increaseCashJob.result;
}
}
// Send response message
ResponseCashPackageBuyValidationMessage responseMessage = new ResponseCashPackageBuyValidationMessage();
responseMessage.ackId = message.ackId;
responseMessage.responseCode = error == ResponseCashPackageBuyValidationMessage.Error.None ? AckResponseCode.Success : AckResponseCode.Error;
responseMessage.error = error;
responseMessage.dataId = dataId;
responseMessage.cash = cash;
ServerSendPacket(connectionId, SendOptions.ReliableOrdered, MsgTypes.CashPackageBuyValidation, responseMessage);
}
private async UniTaskVoid HandleRequestValidateAccessTokenRoutine(LiteNetLibMessageHandler messageHandler)
{
long connectionId = messageHandler.connectionId;
RequestValidateAccessTokenMessage message = messageHandler.ReadMessage <RequestValidateAccessTokenMessage>();
ResponseValidateAccessTokenMessage.Error error = ResponseValidateAccessTokenMessage.Error.None;
string userId = message.userId;
string accessToken = message.accessToken;
ValidateAccessTokenResp validateAccessTokenResp = await DbServiceClient.ValidateAccessTokenAsync(new ValidateAccessTokenReq()
{
UserId = userId,
AccessToken = accessToken
});
if (!validateAccessTokenResp.IsPass)
{
error = ResponseValidateAccessTokenMessage.Error.InvalidAccessToken;
userId = string.Empty;
accessToken = string.Empty;
}
else
{
CentralUserPeerInfo userPeerInfo;
if (userPeersByUserId.TryGetValue(userId, out userPeerInfo))
{
userPeersByUserId.Remove(userPeerInfo.userId);
userPeers.Remove(userPeerInfo.connectionId);
}
userPeerInfo = new CentralUserPeerInfo();
userPeerInfo.connectionId = connectionId;
userPeerInfo.userId = userId;
userPeerInfo.accessToken = accessToken = Regex.Replace(Convert.ToBase64String(Guid.NewGuid().ToByteArray()), "[/+=]", "");
userPeersByUserId[userId] = userPeerInfo;
userPeers[connectionId] = userPeerInfo;
await DbServiceClient.UpdateAccessTokenAsync(new UpdateAccessTokenReq()
{
UserId = userPeerInfo.userId,
AccessToken = accessToken
});
}
ResponseValidateAccessTokenMessage responseMessage = new ResponseValidateAccessTokenMessage();
responseMessage.ackId = message.ackId;
responseMessage.responseCode = error == ResponseValidateAccessTokenMessage.Error.None ? AckResponseCode.Success : AckResponseCode.Error;
responseMessage.error = error;
responseMessage.userId = userId;
responseMessage.accessToken = accessToken;
ServerSendResponse(connectionId, MMOMessageTypes.ResponseValidateAccessToken, responseMessage);
}
private async UniTaskVoid HandleRequestUserLoginRoutine(LiteNetLibMessageHandler messageHandler)
{
long connectionId = messageHandler.connectionId;
RequestUserLoginMessage message = messageHandler.ReadMessage <RequestUserLoginMessage>();
ResponseUserLoginMessage.Error error = ResponseUserLoginMessage.Error.None;
ValidateUserLoginResp validateUserLoginResp = await DbServiceClient.ValidateUserLoginAsync(new ValidateUserLoginReq()
{
Username = message.username,
Password = message.password
});
string userId = validateUserLoginResp.UserId;
string accessToken = string.Empty;
if (string.IsNullOrEmpty(userId))
{
error = ResponseUserLoginMessage.Error.InvalidUsernameOrPassword;
userId = string.Empty;
}
else if (userPeersByUserId.ContainsKey(userId) || MapContainsUser(userId))
{
error = ResponseUserLoginMessage.Error.AlreadyLogin;
userId = string.Empty;
}
else
{
CentralUserPeerInfo userPeerInfo = new CentralUserPeerInfo();
userPeerInfo.connectionId = connectionId;
userPeerInfo.userId = userId;
userPeerInfo.accessToken = accessToken = Regex.Replace(Convert.ToBase64String(Guid.NewGuid().ToByteArray()), "[/+=]", "");
userPeersByUserId[userId] = userPeerInfo;
userPeers[connectionId] = userPeerInfo;
await DbServiceClient.UpdateAccessTokenAsync(new UpdateAccessTokenReq()
{
UserId = userId,
AccessToken = accessToken
});
}
ResponseUserLoginMessage responseMessage = new ResponseUserLoginMessage();
responseMessage.ackId = message.ackId;
responseMessage.responseCode = error == ResponseUserLoginMessage.Error.None ? AckResponseCode.Success : AckResponseCode.Error;
responseMessage.error = error;
responseMessage.userId = userId;
responseMessage.accessToken = accessToken;
ServerSendResponse(connectionId, MMOMessageTypes.ResponseUserLogin, responseMessage);
}
private void HandleUpdateGuildAtServer(LiteNetLibMessageHandler messageHandler)
{
var connectionId = messageHandler.connectionId;
var message = messageHandler.ReadMessage <UpdateGuildMessage>();
if (mapServerConnectionIds.Contains(connectionId))
{
foreach (var mapServerConnectionId in mapServerConnectionIds)
{
if (mapServerConnectionId != connectionId)
{
ServerSendPacket(mapServerConnectionId, SendOptions.ReliableOrdered, MMOMessageTypes.UpdateGuild, message);
}
}
}
}
private void HandleUpdateGuildAtServer(LiteNetLibMessageHandler 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 HandleUpdatePartyMemberAtServer(LiteNetLibMessageHandler messageHandler)
{
long connectionId = messageHandler.connectionId;
UpdateSocialMemberMessage message = messageHandler.ReadMessage <UpdateSocialMemberMessage>();
if (mapServerConnectionIds.Contains(connectionId))
{
foreach (long mapServerConnectionId in mapServerConnectionIds)
{
if (mapServerConnectionId != connectionId)
{
ServerSendPacket(mapServerConnectionId, SendOptions.ReliableOrdered, MMOMessageTypes.UpdatePartyMember, message);
}
}
}
}
private IEnumerator HandleRequestValidateAccessTokenRoutine(LiteNetLibMessageHandler messageHandler)
{
long connectionId = messageHandler.connectionId;
RequestValidateAccessTokenMessage message = messageHandler.ReadMessage <RequestValidateAccessTokenMessage>();
ResponseValidateAccessTokenMessage.Error error = ResponseValidateAccessTokenMessage.Error.None;
string userId = message.userId;
string accessToken = message.accessToken;
ValidateAccessTokenJob validateAccessTokenJob = new ValidateAccessTokenJob(Database, userId, accessToken);
validateAccessTokenJob.Start();
yield return(StartCoroutine(validateAccessTokenJob.WaitFor()));
if (!validateAccessTokenJob.result)
{
error = ResponseValidateAccessTokenMessage.Error.InvalidAccessToken;
userId = string.Empty;
accessToken = string.Empty;
}
else
{
CentralUserPeerInfo userPeerInfo;
if (userPeersByUserId.TryGetValue(userId, out userPeerInfo))
{
userPeersByUserId.Remove(userPeerInfo.userId);
userPeers.Remove(userPeerInfo.connectionId);
}
userPeerInfo = new CentralUserPeerInfo();
userPeerInfo.connectionId = connectionId;
userPeerInfo.userId = userId;
userPeerInfo.accessToken = accessToken = Regex.Replace(Convert.ToBase64String(Guid.NewGuid().ToByteArray()), "[/+=]", "");
userPeersByUserId[userId] = userPeerInfo;
userPeers[connectionId] = userPeerInfo;
UpdateAccessTokenJob updateAccessTokenJob = new UpdateAccessTokenJob(Database, userId, accessToken);
updateAccessTokenJob.Start();
yield return(StartCoroutine(updateAccessTokenJob.WaitFor()));
}
ResponseValidateAccessTokenMessage responseMessage = new ResponseValidateAccessTokenMessage();
responseMessage.ackId = message.ackId;
responseMessage.responseCode = error == ResponseValidateAccessTokenMessage.Error.None ? AckResponseCode.Success : AckResponseCode.Error;
responseMessage.error = error;
responseMessage.userId = userId;
responseMessage.accessToken = accessToken;
ServerSendPacket(connectionId, DeliveryMethod.ReliableOrdered, MMOMessageTypes.ResponseValidateAccessToken, responseMessage);
}
private void HandleChatAtServer(LiteNetLibMessageHandler messageHandler)
{
var connectionId = messageHandler.connectionId;
var message = messageHandler.ReadMessage <ChatMessage>();
if (LogInfo)
{
Debug.Log("Handle chat: " + message.channel + " sender: " + message.sender + " receiver: " + message.receiver + " message: " + message.message);
}
switch (message.channel)
{
case ChatChannel.Global:
if (GMCommands.IsGMCommand(message.message))
{
HandleGMCommand(message.sender, message.message);
}
else
{
ServerSendPacketToAllConnections(SendOptions.ReliableOrdered, MMOMessageTypes.Chat, message);
}
break;
case ChatChannel.Party:
case ChatChannel.Guild:
// Send message to all map servers, let's map servers filter messages
ServerSendPacketToAllConnections(SendOptions.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, SendOptions.ReliableOrdered, MMOMessageTypes.Chat, message);
}
if (!string.IsNullOrEmpty(message.receiver) &&
connectionIdsByCharacterName.TryGetValue(message.receiver, out receiverConnectionId) &&
(receiverConnectionId != senderConnectionId))
{
ServerSendPacket(receiverConnectionId, SendOptions.ReliableOrdered, MMOMessageTypes.Chat, message);
}
break;
}
}
protected override void HandleChatAtServer(LiteNetLibMessageHandler messageHandler)
{
var message = FillChatChannelId(messageHandler.ReadMessage <ChatMessage>());
// Local chat will processes immediately, not have to be sent to chat server
if (message.channel == ChatChannel.Local &&
!GMCommands.IsGMCommand(message.message))
{
ReadChatMessage(message);
return;
}
// Send chat message to chat server, for MMO mode chat message handling by chat server
if (ChatNetworkManager.IsClientConnected)
{
ChatNetworkManager.Client.SendEnterChat(null, MMOMessageTypes.Chat, message.channel, message.message, message.sender, message.receiver, message.channelId);
}
}
private IEnumerator HandleRequestUserLoginRoutine(LiteNetLibMessageHandler messageHandler)
{
long connectionId = messageHandler.connectionId;
RequestUserLoginMessage message = messageHandler.ReadMessage <RequestUserLoginMessage>();
ResponseUserLoginMessage.Error error = ResponseUserLoginMessage.Error.None;
ValidateUserLoginJob validateJob = new ValidateUserLoginJob(Database, message.username, message.password);
validateJob.Start();
yield return(StartCoroutine(validateJob.WaitFor()));
string userId = validateJob.result;
string accessToken = string.Empty;
if (string.IsNullOrEmpty(userId))
{
error = ResponseUserLoginMessage.Error.InvalidUsernameOrPassword;
userId = string.Empty;
}
else if (userPeersByUserId.ContainsKey(userId) || MapContainsUser(userId))
{
error = ResponseUserLoginMessage.Error.AlreadyLogin;
userId = string.Empty;
}
else
{
CentralUserPeerInfo userPeerInfo = new CentralUserPeerInfo();
userPeerInfo.connectionId = connectionId;
userPeerInfo.userId = userId;
userPeerInfo.accessToken = accessToken = Regex.Replace(Convert.ToBase64String(Guid.NewGuid().ToByteArray()), "[/+=]", "");
userPeersByUserId[userId] = userPeerInfo;
userPeers[connectionId] = userPeerInfo;
UpdateAccessTokenJob updateAccessTokenJob = new UpdateAccessTokenJob(Database, userId, accessToken);
updateAccessTokenJob.Start();
yield return(StartCoroutine(updateAccessTokenJob.WaitFor()));
}
ResponseUserLoginMessage responseMessage = new ResponseUserLoginMessage();
responseMessage.ackId = message.ackId;
responseMessage.responseCode = error == ResponseUserLoginMessage.Error.None ? AckResponseCode.Success : AckResponseCode.Error;
responseMessage.error = error;
responseMessage.userId = userId;
responseMessage.accessToken = accessToken;
ServerSendPacket(connectionId, DeliveryMethod.ReliableOrdered, MMOMessageTypes.ResponseUserLogin, responseMessage);
}
private async UniTaskVoid HandleRequestUserRegisterRoutine(LiteNetLibMessageHandler messageHandler)
{
long connectionId = messageHandler.connectionId;
RequestUserRegisterMessage message = messageHandler.ReadMessage <RequestUserRegisterMessage>();
ResponseUserRegisterMessage.Error error = ResponseUserRegisterMessage.Error.None;
string username = message.username;
string password = message.password;
FindUsernameResp findUsernameResp = await DbServiceClient.FindUsernameAsync(new FindUsernameReq()
{
Username = username
});
if (findUsernameResp.FoundAmount > 0)
{
error = ResponseUserRegisterMessage.Error.UsernameAlreadyExisted;
}
else if (string.IsNullOrEmpty(username) || username.Length < minUsernameLength)
{
error = ResponseUserRegisterMessage.Error.TooShortUsername;
}
else if (username.Length > maxUsernameLength)
{
error = ResponseUserRegisterMessage.Error.TooLongUsername;
}
else if (string.IsNullOrEmpty(password) || password.Length < minPasswordLength)
{
error = ResponseUserRegisterMessage.Error.TooShortPassword;
}
else
{
await DbServiceClient.CreateUserLoginAsync(new CreateUserLoginReq()
{
Username = username,
Password = password
});
}
ResponseUserRegisterMessage responseMessage = new ResponseUserRegisterMessage();
responseMessage.ackId = message.ackId;
responseMessage.responseCode = error == ResponseUserRegisterMessage.Error.None ? AckResponseCode.Success : AckResponseCode.Error;
responseMessage.error = error;
ServerSendResponse(connectionId, MMOMessageTypes.ResponseUserRegister, responseMessage);
}
private async UniTaskVoid HandleRequestSelectCharacterRoutine(LiteNetLibMessageHandler messageHandler)
{
long connectionId = messageHandler.connectionId;
RequestSelectCharacterMessage message = messageHandler.ReadMessage <RequestSelectCharacterMessage>();
ResponseSelectCharacterMessage.Error error = ResponseSelectCharacterMessage.Error.None;
CentralServerPeerInfo mapServerPeerInfo = default(CentralServerPeerInfo);
CentralUserPeerInfo userPeerInfo;
if (!userPeers.TryGetValue(connectionId, out userPeerInfo))
{
error = ResponseSelectCharacterMessage.Error.NotLoggedin;
}
else
{
CharacterResp characterResp = await DbServiceClient.ReadCharacterAsync(new ReadCharacterReq()
{
UserId = userPeerInfo.userId,
CharacterId = message.characterId
});
PlayerCharacterData character = characterResp.CharacterData.FromByteString <PlayerCharacterData>();
if (character == null)
{
error = ResponseSelectCharacterMessage.Error.InvalidCharacterData;
}
else if (!mapServerPeersBySceneName.TryGetValue(character.CurrentMapName, out mapServerPeerInfo))
{
error = ResponseSelectCharacterMessage.Error.MapNotReady;
}
}
ResponseSelectCharacterMessage responseMessage = new ResponseSelectCharacterMessage();
responseMessage.ackId = message.ackId;
responseMessage.responseCode = error == ResponseSelectCharacterMessage.Error.None ? AckResponseCode.Success : AckResponseCode.Error;
responseMessage.error = error;
if (error != ResponseSelectCharacterMessage.Error.MapNotReady)
{
responseMessage.sceneName = mapServerPeerInfo.extra;
responseMessage.networkAddress = mapServerPeerInfo.networkAddress;
responseMessage.networkPort = mapServerPeerInfo.networkPort;
}
ServerSendResponse(connectionId, MMOMessageTypes.ResponseSelectCharacter, responseMessage);
}
private IEnumerator HandleRequestSelectCharacterRoutine(LiteNetLibMessageHandler messageHandler)
{
long connectionId = messageHandler.connectionId;
RequestSelectCharacterMessage message = messageHandler.ReadMessage <RequestSelectCharacterMessage>();
ResponseSelectCharacterMessage.Error error = ResponseSelectCharacterMessage.Error.None;
CentralServerPeerInfo mapServerPeerInfo = null;
CentralUserPeerInfo userPeerInfo;
if (!userPeers.TryGetValue(connectionId, out userPeerInfo))
{
error = ResponseSelectCharacterMessage.Error.NotLoggedin;
}
else
{
ReadCharacterJob job = new ReadCharacterJob(Database, userPeerInfo.userId, message.characterId, false, false, false, false, false, false, false, false, false);
job.Start();
yield return(StartCoroutine(job.WaitFor()));
PlayerCharacterData character = job.result;
if (character == null)
{
error = ResponseSelectCharacterMessage.Error.InvalidCharacterData;
}
else if (!mapServerPeersBySceneName.TryGetValue(character.CurrentMapName, out mapServerPeerInfo))
{
error = ResponseSelectCharacterMessage.Error.MapNotReady;
}
}
ResponseSelectCharacterMessage responseMessage = new ResponseSelectCharacterMessage();
responseMessage.ackId = message.ackId;
responseMessage.responseCode = error == ResponseSelectCharacterMessage.Error.None ? AckResponseCode.Success : AckResponseCode.Error;
responseMessage.error = error;
if (mapServerPeerInfo != null)
{
responseMessage.sceneName = mapServerPeerInfo.extra;
responseMessage.networkAddress = mapServerPeerInfo.networkAddress;
responseMessage.networkPort = mapServerPeerInfo.networkPort;
responseMessage.connectKey = mapServerPeerInfo.connectKey;
}
ServerSendPacket(connectionId, DeliveryMethod.ReliableOrdered, MMOMessageTypes.ResponseSelectCharacter, responseMessage);
}
