/// <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 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);
}
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);
}
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 HandleRequestCreateCharacterRoutine(LiteNetLibMessageHandler messageHandler)
{
var connectionId = messageHandler.connectionId;
var message = messageHandler.ReadMessage <RequestCreateCharacterMessage>();
var error = ResponseCreateCharacterMessage.Error.None;
var characterName = message.characterName;
var dataId = message.dataId;
var entityId = message.entityId;
CentralUserPeerInfo userPeerInfo;
var 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
{
var characterId = GenericUtils.GetUniqueId();
var characterData = new PlayerCharacterData();
characterData.Id = characterId;
characterData.SetNewPlayerCharacterData(characterName, dataId, entityId);
var createCharacterJob = new CreateCharacterJob(Database, userPeerInfo.userId, characterData);
createCharacterJob.Start();
yield return(StartCoroutine(createCharacterJob.WaitFor()));
}
var responseMessage = new ResponseCreateCharacterMessage();
responseMessage.ackId = message.ackId;
responseMessage.responseCode = error == ResponseCreateCharacterMessage.Error.None ? AckResponseCode.Success : AckResponseCode.Error;
responseMessage.error = error;
ServerSendPacket(connectionId, SendOptions.ReliableOrdered, MMOMessageTypes.ResponseCreateCharacter, responseMessage);
}
// CentralAppServerRegister message handlers
private void SampleHandleMsgFromCentralServer(LiteNetLibMessageHandler messageHandler)
{
string text = messageHandler.reader.GetString();
long clientTime = messageHandler.reader.GetLong();
long connectionId = messageHandler.reader.GetLong();
Debug.Log("[CustomFromClientToCentralServer] map-server receive from central-server: " + text + " " + clientTime + " then send this to client");
ServerSendPacket(connectionId, LiteNetLib.DeliveryMethod.ReliableOrdered, 10001, (writer) =>
{
writer.Put(text);
writer.Put(ServerUnixTime);
});
}
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);
}
// Map-Server message handlers
private void SampleHandleMsgFromMapServer(LiteNetLibMessageHandler messageHandler)
{
string text = messageHandler.reader.GetString();
long clientTime = messageHandler.reader.GetLong();
long connectionId = messageHandler.reader.GetLong();
Debug.Log("[CustomFromClientToCentralServer] central-server receive: " + text + " " + clientTime + " then send lower-case text back to map-server");
ServerSendPacket(messageHandler.connectionId, LiteNetLib.DeliveryMethod.ReliableOrdered, 10001, (writer) =>
{
writer.Put(text.ToLower());
writer.Put(clientTime);
writer.Put(connectionId);
});
}
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);
}
// Server message handlers
private void SampleHandleMsgFromClient(LiteNetLibMessageHandler messageHandler)
{
// Receive message from client at map-server
// Then keep transport handler at server to use later to send message to client
string text = messageHandler.reader.GetString();
long clientTime = messageHandler.reader.GetLong();
Debug.Log("[CustomFromClientToCentralServer] map-server receive from client: " + text + " " + clientTime + " then send this to central-server");
CentralAppServerRegister.SendPacket(LiteNetLib.DeliveryMethod.ReliableOrdered, 10001, (writer) =>
{
writer.Put(sampleMessageToCentralServer);
writer.Put(ServerUnixTime);
writer.Put(messageHandler.connectionId);
});
}
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 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 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 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 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 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 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);
}
private IEnumerator 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;
FindUsernameJob findUsernameJob = new FindUsernameJob(Database, username);
findUsernameJob.Start();
yield return(StartCoroutine(findUsernameJob.WaitFor()));
if (findUsernameJob.result > 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
{
CreateUserLoginJob createUserLoginJob = new CreateUserLoginJob(Database, username, password);
createUserLoginJob.Start();
yield return(StartCoroutine(createUserLoginJob.WaitFor()));
}
ResponseUserRegisterMessage responseMessage = new ResponseUserRegisterMessage();
responseMessage.ackId = message.ackId;
responseMessage.responseCode = error == ResponseUserRegisterMessage.Error.None ? AckResponseCode.Success : AckResponseCode.Error;
responseMessage.error = error;
ServerSendPacket(connectionId, DeliveryMethod.ReliableOrdered, MMOMessageTypes.ResponseUserRegister, responseMessage);
}
private IEnumerator HandleRequestUserLogoutRoutine(LiteNetLibMessageHandler messageHandler)
{
long connectionId = messageHandler.connectionId;
BaseAckMessage message = messageHandler.ReadMessage <BaseAckMessage>();
CentralUserPeerInfo userPeerInfo;
if (userPeers.TryGetValue(connectionId, out userPeerInfo))
{
userPeersByUserId.Remove(userPeerInfo.userId);
userPeers.Remove(connectionId);
UpdateAccessTokenJob updateAccessTokenJob = new UpdateAccessTokenJob(Database, userPeerInfo.userId, string.Empty);
updateAccessTokenJob.Start();
yield return(StartCoroutine(updateAccessTokenJob.WaitFor()));
}
BaseAckMessage responseMessage = new BaseAckMessage();
responseMessage.ackId = message.ackId;
responseMessage.responseCode = AckResponseCode.Success;
ServerSendPacket(connectionId, DeliveryMethod.ReliableOrdered, MMOMessageTypes.ResponseUserLogout, responseMessage);
}
private IEnumerator HandleRequestCashPackageInfoRoutine(LiteNetLibMessageHandler messageHandler)
{
long connectionId = messageHandler.connectionId;
BaseAckMessage message = messageHandler.ReadMessage <BaseAckMessage>();
// Set response data
ResponseCashPackageInfoMessage.Error error = ResponseCashPackageInfoMessage.Error.None;
int cash = 0;
List <int> cashPackageIds = new List <int>();
BasePlayerCharacterEntity playerCharacter;
UserCharacterData userData;
if (!playerCharacters.TryGetValue(connectionId, out playerCharacter) ||
!usersById.TryGetValue(playerCharacter.Id, out userData))
{
error = ResponseCashPackageInfoMessage.Error.UserNotFound;
}
else
{
GetCashJob job = new GetCashJob(Database, userData.userId);
job.Start();
yield return(StartCoroutine(job.WaitFor()));
cash = job.result;
foreach (int cashShopItemId in GameInstance.CashPackages.Keys)
{
cashPackageIds.Add(cashShopItemId);
}
}
// Send response message
ResponseCashPackageInfoMessage responseMessage = new ResponseCashPackageInfoMessage();
responseMessage.ackId = message.ackId;
responseMessage.responseCode = error == ResponseCashPackageInfoMessage.Error.None ? AckResponseCode.Success : AckResponseCode.Error;
responseMessage.error = error;
responseMessage.cash = cash;
responseMessage.cashPackageIds = cashPackageIds.ToArray();
ServerSendPacket(connectionId, SendOptions.ReliableOrdered, MsgTypes.CashPackageInfo, responseMessage);
}
private async UniTaskVoid HandleRequestUserLogoutRoutine(LiteNetLibMessageHandler messageHandler)
{
long connectionId = messageHandler.connectionId;
BaseAckMessage message = messageHandler.ReadMessage <BaseAckMessage>();
CentralUserPeerInfo userPeerInfo;
if (userPeers.TryGetValue(connectionId, out userPeerInfo))
{
userPeersByUserId.Remove(userPeerInfo.userId);
userPeers.Remove(connectionId);
await DbServiceClient.UpdateAccessTokenAsync(new UpdateAccessTokenReq()
{
UserId = userPeerInfo.userId,
AccessToken = string.Empty
});
}
BaseAckMessage responseMessage = new BaseAckMessage();
responseMessage.ackId = message.ackId;
responseMessage.responseCode = AckResponseCode.Success;
ServerSendResponse(connectionId, MMOMessageTypes.ResponseUserLogout, responseMessage);
}
private void HandleRequestSpawnMap(LiteNetLibMessageHandler messageHandler)
{
RequestSpawnMapMessage message = messageHandler.ReadMessage <RequestSpawnMapMessage>();
ResponseSpawnMapMessage.Error error = ResponseSpawnMapMessage.Error.None;
if (!CentralAppServerRegister.IsRegisteredToCentralServer)
{
error = ResponseSpawnMapMessage.Error.NotReady;
}
else if (string.IsNullOrEmpty(message.mapId))
{
error = ResponseSpawnMapMessage.Error.EmptySceneName;
}
if (error != ResponseSpawnMapMessage.Error.None)
{
ReponseMapSpawn(message.ackId, error);
}
else
{
SpawnMap(message, false);
}
}
private IEnumerator HandleRequestDeleteCharacterRoutine(LiteNetLibMessageHandler messageHandler)
{
var connectionId = messageHandler.connectionId;
var message = messageHandler.ReadMessage <RequestDeleteCharacterMessage>();
var error = ResponseDeleteCharacterMessage.Error.None;
CentralUserPeerInfo userPeerInfo;
if (!userPeers.TryGetValue(connectionId, out userPeerInfo))
{
error = ResponseDeleteCharacterMessage.Error.NotLoggedin;
}
else
{
var job = new DeleteCharactersJob(Database, userPeerInfo.userId, message.characterId);
job.Start();
yield return(StartCoroutine(job.WaitFor()));
}
var responseMessage = new ResponseDeleteCharacterMessage();
responseMessage.ackId = message.ackId;
responseMessage.responseCode = error == ResponseDeleteCharacterMessage.Error.None ? AckResponseCode.Success : AckResponseCode.Error;
responseMessage.error = error;
ServerSendPacket(connectionId, SendOptions.ReliableOrdered, MMOMessageTypes.ResponseDeleteCharacter, responseMessage);
}
protected void HandleUpdateMapUser(LiteNetLibMessageHandler messageHandler)
{
var connectionId = messageHandler.connectionId;
var message = messageHandler.ReadMessage <UpdateUserCharacterMessage>();
if (mapUserIds.ContainsKey(connectionId))
{
switch (message.type)
{
case UpdateUserCharacterMessage.UpdateType.Add:
if (!mapUserIds[connectionId].Contains(message.UserId))
{
mapUserIds[connectionId].Add(message.UserId);
Debug.Log("[Central] Add map user: "******" by " + connectionId);
}
break;
case UpdateUserCharacterMessage.UpdateType.Remove:
mapUserIds[connectionId].Remove(message.UserId);
Debug.Log("[Central] Remove map user: "******" by " + connectionId);
break;
}
}
}
