protected async UniTaskVoid HandleRequestCharacters(
RequestHandlerData requestHandler,
EmptyMessage request,
RequestProceedResultDelegate <ResponseCharactersMessage> result)
{
#if UNITY_STANDALONE && !CLIENT_BUILD
long connectionId = requestHandler.ConnectionId;
UITextKeys message = UITextKeys.NONE;
List <PlayerCharacterData> characters = null;
CentralUserPeerInfo userPeerInfo;
if (!userPeers.TryGetValue(connectionId, out userPeerInfo))
{
message = UITextKeys.UI_ERROR_NOT_LOGGED_IN;
}
else
{
CharactersResp charactersResp = await DbServiceClient.ReadCharactersAsync(new ReadCharactersReq()
{
UserId = userPeerInfo.userId
});
characters = charactersResp.List;
}
// Response
result.Invoke(
message == UITextKeys.NONE ? AckResponseCode.Success : AckResponseCode.Error,
new ResponseCharactersMessage()
{
message = message,
characters = characters,
});
#endif
}
public async UniTaskVoid HandleRequestClaimMailItems(RequestHandlerData requestHandler, RequestClaimMailItemsMessage request, RequestProceedResultDelegate <ResponseClaimMailItemsMessage> result)
{
#if UNITY_STANDALONE && !CLIENT_BUILD
IPlayerCharacterData playerCharacter;
if (!GameInstance.ServerUserHandlers.TryGetPlayerCharacter(requestHandler.ConnectionId, out playerCharacter))
{
result.Invoke(AckResponseCode.Error, new ResponseClaimMailItemsMessage()
{
message = UITextKeys.UI_ERROR_NOT_LOGGED_IN,
});
return;
}
UITextKeys message = await ClaimMailItems(request.id, playerCharacter);
if (message != UITextKeys.NONE)
{
result.Invoke(AckResponseCode.Error, new ResponseClaimMailItemsMessage()
{
message = message,
});
return;
}
result.Invoke(AckResponseCode.Success, new ResponseClaimMailItemsMessage());
#endif
}
public async UniTaskVoid HandleRequestDeleteMail(RequestHandlerData requestHandler, RequestDeleteMailMessage request, RequestProceedResultDelegate <ResponseDeleteMailMessage> result)
{
#if UNITY_STANDALONE && !CLIENT_BUILD
string userId;
if (!GameInstance.ServerUserHandlers.TryGetUserId(requestHandler.ConnectionId, out userId))
{
result.Invoke(AckResponseCode.Error, new ResponseDeleteMailMessage()
{
message = UITextKeys.UI_ERROR_NOT_LOGGED_IN,
});
return;
}
UITextKeys message = await DeleteMail(request.id, userId);
if (message != UITextKeys.NONE)
{
result.Invoke(AckResponseCode.Error, new ResponseDeleteMailMessage()
{
message = message,
});
return;
}
result.Invoke(AckResponseCode.Success, new ResponseDeleteMailMessage());
#endif
}
public async UniTaskVoid HandleRequestReadMail(RequestHandlerData requestHandler, RequestReadMailMessage request, RequestProceedResultDelegate <ResponseReadMailMessage> result)
{
#if UNITY_STANDALONE && !CLIENT_BUILD
IPlayerCharacterData playerCharacter;
if (GameInstance.ServerUserHandlers.TryGetPlayerCharacter(requestHandler.ConnectionId, out playerCharacter))
{
UpdateReadMailStateResp resp = await DbServiceClient.UpdateReadMailStateAsync(new UpdateReadMailStateReq()
{
MailId = request.id,
UserId = playerCharacter.UserId,
});
UITextKeys message = resp.Error;
result.Invoke(
message == UITextKeys.NONE ? AckResponseCode.Success : AckResponseCode.Error,
new ResponseReadMailMessage()
{
message = message,
mail = resp.Mail,
});
}
else
{
result.Invoke(AckResponseCode.Error, new ResponseReadMailMessage()
{
message = UITextKeys.UI_ERROR_SERVICE_NOT_AVAILABLE,
});
}
#endif
}
internal async UniTaskVoid HandleRequestSpawnMap(
RequestHandlerData requestHandler,
RequestSpawnMapMessage request,
RequestProceedResultDelegate <ResponseSpawnMapMessage> result)
{
UITextKeys message = UITextKeys.NONE;
if (!ClusterClient.IsAppRegistered)
{
message = UITextKeys.UI_ERROR_APP_NOT_READY;
}
else if (string.IsNullOrEmpty(request.mapId))
{
message = UITextKeys.UI_ERROR_EMPTY_SCENE_NAME;
}
if (message != UITextKeys.NONE)
{
result.Invoke(AckResponseCode.Error, new ResponseSpawnMapMessage()
{
message = message
});
}
else
{
SpawnMap(request, result, false);
}
await UniTask.Yield();
}
private UniTaskVoid HandleRequestSpawnMap(
RequestHandlerData requestHandler,
RequestSpawnMapMessage request,
RequestProceedResultDelegate <ResponseSpawnMapMessage> result)
{
UITextKeys message = UITextKeys.NONE;
if (!CentralAppServerRegister.IsRegisteredToCentralServer)
{
message = UITextKeys.UI_ERROR_APP_NOT_READY;
}
else if (string.IsNullOrEmpty(request.mapId))
{
message = UITextKeys.UI_ERROR_EMPTY_SCENE_NAME;
}
if (message != UITextKeys.NONE)
{
result.Invoke(AckResponseCode.Error, new ResponseSpawnMapMessage()
{
message = message
});
}
else
{
SpawnMap(request, result, false);
}
return(default);
public void Deserialize(NetDataReader reader)
{
message = (UITextKeys)reader.GetPackedUShort();
sceneName = reader.GetString();
networkAddress = reader.GetString();
networkPort = reader.GetInt();
}
public void Deserialize(NetDataReader reader)
{
message = (UITextKeys)reader.GetPackedUShort();
userId = reader.GetString();
accessToken = reader.GetString();
unbanTime = reader.GetPackedLong();
}
protected async UniTaskVoid HandleRequestDeleteCharacter(
RequestHandlerData requestHandler,
RequestDeleteCharacterMessage request,
RequestProceedResultDelegate <ResponseDeleteCharacterMessage> result)
{
#if UNITY_STANDALONE && !CLIENT_BUILD
long connectionId = requestHandler.ConnectionId;
UITextKeys message = UITextKeys.NONE;
CentralUserPeerInfo userPeerInfo;
if (!userPeers.TryGetValue(connectionId, out userPeerInfo))
{
message = UITextKeys.UI_ERROR_NOT_LOGGED_IN;
}
else
{
await DbServiceClient.DeleteCharacterAsync(new DeleteCharacterReq()
{
UserId = userPeerInfo.userId,
CharacterId = request.characterId
});
}
// Response
result.Invoke(
message == UITextKeys.NONE ? AckResponseCode.Success : AckResponseCode.Error,
new ResponseDeleteCharacterMessage()
{
message = message,
});
#endif
}
public async UniTaskVoid HandleRequestCashPackageBuyValidation(
RequestHandlerData requestHandler, RequestCashPackageBuyValidationMessage request,
RequestProceedResultDelegate <ResponseCashPackageBuyValidationMessage> result)
{
#if UNITY_STANDALONE && !CLIENT_BUILD
// TODO: Validate purchasing at server side
// Set response data
UITextKeys message = UITextKeys.NONE;
int dataId = request.dataId;
int cash = 0;
IPlayerCharacterData playerCharacter;
if (!GameInstance.ServerUserHandlers.TryGetPlayerCharacter(requestHandler.ConnectionId, out playerCharacter))
{
// Cannot find user
message = UITextKeys.UI_ERROR_NOT_LOGGED_IN;
}
else
{
// Get user cash amount
CashResp getCashResp = await DbServiceClient.GetCashAsync(new GetCashReq()
{
UserId = playerCharacter.UserId
});
cash = getCashResp.Cash;
CashPackage cashPackage;
if (!GameInstance.CashPackages.TryGetValue(dataId, out cashPackage))
{
// Cannot find package
message = UITextKeys.UI_ERROR_CASH_PACKAGE_NOT_FOUND;
}
else
{
// Increase cash amount
CashResp changeCashResp = await DbServiceClient.ChangeCashAsync(new ChangeCashReq()
{
UserId = playerCharacter.UserId,
ChangeAmount = cashPackage.cashAmount
});
cash = changeCashResp.Cash;
playerCharacter.UserCash = cash;
}
}
// Send response message
result.Invoke(
message == UITextKeys.NONE ? AckResponseCode.Success : AckResponseCode.Error,
new ResponseCashPackageBuyValidationMessage()
{
message = message,
dataId = dataId,
cash = cash,
});
#endif
await UniTask.Yield();
}
private async UniTaskVoid HandleRequestAppServerAddress(
RequestHandlerData requestHandler,
RequestAppServerAddressMessage request,
RequestProceedResultDelegate <ResponseAppServerAddressMessage> result)
{
long connectionId = requestHandler.ConnectionId;
UITextKeys message = UITextKeys.NONE;
CentralServerPeerInfo peerInfo = new CentralServerPeerInfo();
switch (request.peerType)
{
// TODO: Balancing servers when there are multiple servers with same type
case CentralServerPeerType.MapSpawnServer:
if (MapSpawnServerPeers.Count > 0)
{
peerInfo = MapSpawnServerPeers.Values.First();
Logging.Log(LogTag, "Request Map Spawn Address: [" + connectionId + "]");
}
else
{
message = UITextKeys.UI_ERROR_SERVER_NOT_FOUND;
Logging.Log(LogTag, "Request Map Spawn Address: [" + connectionId + "] [" + message + "]");
}
break;
case CentralServerPeerType.MapServer:
string mapName = request.extra;
if (!MapServerPeersByMapId.TryGetValue(mapName, out peerInfo))
{
message = UITextKeys.UI_ERROR_SERVER_NOT_FOUND;
Logging.Log(LogTag, "Request Map Address: [" + connectionId + "] [" + mapName + "] [" + message + "]");
}
break;
case CentralServerPeerType.InstanceMapServer:
string instanceId = request.extra;
if (!MapServerPeersByInstanceId.TryGetValue(instanceId, out peerInfo))
{
message = UITextKeys.UI_ERROR_SERVER_NOT_FOUND;
Logging.Log(LogTag, "Request Map Address: [" + connectionId + "] [" + instanceId + "] [" + message + "]");
}
break;
}
// Response
result.Invoke(
message == UITextKeys.NONE ? AckResponseCode.Success : AckResponseCode.Error,
new ResponseAppServerAddressMessage()
{
message = message,
peerInfo = peerInfo,
});
await UniTask.Yield();
}
protected async UniTaskVoid HandleRequestValidateAccessToken(
RequestHandlerData requestHandler,
RequestValidateAccessTokenMessage request,
RequestProceedResultDelegate <ResponseValidateAccessTokenMessage> result)
{
#if UNITY_STANDALONE && !CLIENT_BUILD
long connectionId = requestHandler.ConnectionId;
UITextKeys message = UITextKeys.NONE;
string userId = request.userId;
string accessToken = request.accessToken;
ValidateAccessTokenResp validateAccessTokenResp = await DbServiceClient.ValidateAccessTokenAsync(new ValidateAccessTokenReq()
{
UserId = userId,
AccessToken = accessToken
});
if (!validateAccessTokenResp.IsPass)
{
message = UITextKeys.UI_ERROR_INVALID_USER_TOKEN;
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(System.Convert.ToBase64String(System.Guid.NewGuid().ToByteArray()), "[/+=]", "");
userPeersByUserId[userId] = userPeerInfo;
userPeers[connectionId] = userPeerInfo;
await DbServiceClient.UpdateAccessTokenAsync(new UpdateAccessTokenReq()
{
UserId = userPeerInfo.userId,
AccessToken = accessToken
});
}
// Response
result.Invoke(
message == UITextKeys.NONE ? AckResponseCode.Success : AckResponseCode.Error,
new ResponseValidateAccessTokenMessage()
{
message = message,
userId = userId,
accessToken = accessToken,
});
#endif
}
public void Deserialize(NetDataReader reader)
{
message = (UITextKeys)reader.GetPackedUShort();
characters = new List <PlayerCharacterData>();
byte count = reader.GetByte();
for (byte i = 0; i < count; ++i)
{
PlayerCharacterData character = new PlayerCharacterData();
characters.Add(character.DeserializeCharacterData(reader, withTransforms: false, withBuffs: false, withSkillUsages: false, withNonEquipItems: false, withSummons: false, withHotkeys: false, withQuests: false));
}
}
protected async UniTaskVoid HandleRequestUserLogin(
RequestHandlerData requestHandler,
RequestUserLoginMessage request,
RequestProceedResultDelegate <ResponseUserLoginMessage> result)
{
#if UNITY_STANDALONE && !CLIENT_BUILD
long connectionId = requestHandler.ConnectionId;
UITextKeys message = UITextKeys.NONE;
ValidateUserLoginResp validateUserLoginResp = await DbServiceClient.ValidateUserLoginAsync(new ValidateUserLoginReq()
{
Username = request.username,
Password = request.password
});
string userId = validateUserLoginResp.UserId;
string accessToken = string.Empty;
if (string.IsNullOrEmpty(userId))
{
message = UITextKeys.UI_ERROR_INVALID_USERNAME_OR_PASSWORD;
userId = string.Empty;
}
else if (userPeersByUserId.ContainsKey(userId) || MapContainsUser(userId))
{
message = UITextKeys.UI_ERROR_ALREADY_LOGGED_IN;
userId = string.Empty;
}
else
{
CentralUserPeerInfo userPeerInfo = new CentralUserPeerInfo();
userPeerInfo.connectionId = connectionId;
userPeerInfo.userId = userId;
userPeerInfo.accessToken = accessToken = Regex.Replace(System.Convert.ToBase64String(System.Guid.NewGuid().ToByteArray()), "[/+=]", "");
userPeersByUserId[userId] = userPeerInfo;
userPeers[connectionId] = userPeerInfo;
await DbServiceClient.UpdateAccessTokenAsync(new UpdateAccessTokenReq()
{
UserId = userId,
AccessToken = accessToken
});
}
// Response
result.Invoke(
message == UITextKeys.NONE ? AckResponseCode.Success : AckResponseCode.Error,
new ResponseUserLoginMessage()
{
message = message,
userId = userId,
accessToken = accessToken,
});
#endif
}
public async UniTaskVoid HandleRequestMoveItemFromStorage(RequestHandlerData requestHandler, RequestMoveItemFromStorageMessage request, RequestProceedResultDelegate <ResponseMoveItemFromStorageMessage> result)
{
#if UNITY_STANDALONE && !CLIENT_BUILD
StorageId storageId = new StorageId(request.storageType, request.storageOwnerId);
IPlayerCharacterData playerCharacter;
if (!GameInstance.ServerUserHandlers.TryGetPlayerCharacter(requestHandler.ConnectionId, out playerCharacter))
{
result.Invoke(AckResponseCode.Error, new ResponseMoveItemFromStorageMessage()
{
message = UITextKeys.UI_ERROR_NOT_LOGGED_IN,
});
return;
}
if (!GameInstance.ServerStorageHandlers.CanAccessStorage(playerCharacter, storageId))
{
result.Invoke(AckResponseCode.Error, new ResponseMoveItemFromStorageMessage()
{
message = UITextKeys.UI_ERROR_CANNOT_ACCESS_STORAGE,
});
return;
}
Storage storage = GameInstance.ServerStorageHandlers.GetStorage(storageId, out _);
MoveItemFromStorageReq req = new MoveItemFromStorageReq();
req.StorageType = request.storageType;
req.StorageOwnerId = request.storageOwnerId;
req.CharacterId = playerCharacter.Id;
req.WeightLimit = storage.weightLimit;
req.SlotLimit = storage.slotLimit;
req.StorageItemIndex = request.storageItemIndex;
req.StorageItemAmount = request.storageItemAmount;
req.InventoryItemIndex = request.inventoryItemIndex;
MoveItemFromStorageResp resp = await DbServiceClient.MoveItemFromStorageAsync(req);
UITextKeys message = (UITextKeys)resp.Error;
if (message != UITextKeys.NONE)
{
result.Invoke(AckResponseCode.Error, new ResponseMoveItemFromStorageMessage()
{
message = message,
});
return;
}
playerCharacter.NonEquipItems = resp.InventoryItemItems;
GameInstance.ServerStorageHandlers.SetStorageItems(storageId, resp.StorageCharacterItems);
GameInstance.ServerStorageHandlers.NotifyStorageItemsUpdated(request.storageType, request.storageOwnerId);
// Success
result.Invoke(AckResponseCode.Success, new ResponseMoveItemFromStorageMessage());
#endif
}
public async UniTaskVoid HandleRequestSwapOrMergeStorageItem(RequestHandlerData requestHandler, RequestSwapOrMergeStorageItemMessage request, RequestProceedResultDelegate <ResponseSwapOrMergeStorageItemMessage> result)
{
#if UNITY_STANDALONE && !CLIENT_BUILD
StorageId storageId = new StorageId(request.storageType, request.storageOwnerId);
IPlayerCharacterData playerCharacter;
if (!GameInstance.ServerUserHandlers.TryGetPlayerCharacter(requestHandler.ConnectionId, out playerCharacter))
{
result.Invoke(AckResponseCode.Error, new ResponseSwapOrMergeStorageItemMessage()
{
message = UITextKeys.UI_ERROR_NOT_LOGGED_IN,
});
return;
}
if (!GameInstance.ServerStorageHandlers.CanAccessStorage(playerCharacter, storageId))
{
result.Invoke(AckResponseCode.Error, new ResponseSwapOrMergeStorageItemMessage()
{
message = UITextKeys.UI_ERROR_CANNOT_ACCESS_STORAGE,
});
return;
}
Storage storage = GameInstance.ServerStorageHandlers.GetStorage(storageId, out _);
SwapOrMergeStorageItemReq req = new SwapOrMergeStorageItemReq();
req.StorageType = (EStorageType)request.storageType;
req.StorageOwnerId = request.storageOwnerId;
req.CharacterId = playerCharacter.Id;
req.WeightLimit = storage.weightLimit;
req.SlotLimit = storage.slotLimit;
req.FromIndex = request.fromIndex;
req.ToIndex = request.toIndex;
SwapOrMergeStorageItemResp resp = await DbServiceClient.SwapOrMergeStorageItemAsync(req);
UITextKeys message = (UITextKeys)resp.Error;
if (message != UITextKeys.NONE)
{
result.Invoke(AckResponseCode.Error, new ResponseSwapOrMergeStorageItemMessage()
{
message = message,
});
return;
}
GameInstance.ServerStorageHandlers.SetStorageItems(storageId, DatabaseServiceUtils.MakeListFromRepeatedByteString <CharacterItem>(resp.StorageCharacterItems));
GameInstance.ServerStorageHandlers.NotifyStorageItemsUpdated(request.storageType, request.storageOwnerId);
// Success
result.Invoke(AckResponseCode.Success, new ResponseSwapOrMergeStorageItemMessage());
#endif
}
protected async UniTaskVoid HandleRequestUserRegister(
RequestHandlerData requestHandler,
RequestUserRegisterMessage request,
RequestProceedResultDelegate <ResponseUserRegisterMessage> result)
{
#if UNITY_STANDALONE && !CLIENT_BUILD
UITextKeys message = UITextKeys.NONE;
string username = request.username;
string password = request.password;
FindUsernameResp findUsernameResp = await DbServiceClient.FindUsernameAsync(new FindUsernameReq()
{
Username = username
});
if (findUsernameResp.FoundAmount > 0)
{
message = UITextKeys.UI_ERROR_USERNAME_EXISTED;
}
else if (string.IsNullOrEmpty(username) || username.Length < minUsernameLength)
{
message = UITextKeys.UI_ERROR_USERNAME_TOO_SHORT;
}
else if (username.Length > maxUsernameLength)
{
message = UITextKeys.UI_ERROR_USERNAME_TOO_LONG;
}
else if (string.IsNullOrEmpty(password) || password.Length < minPasswordLength)
{
message = UITextKeys.UI_ERROR_PASSWORD_TOO_SHORT;
}
else
{
await DbServiceClient.CreateUserLoginAsync(new CreateUserLoginReq()
{
Username = username,
Password = password
});
}
// Response
result.Invoke(
message == UITextKeys.NONE ? AckResponseCode.Success : AckResponseCode.Error,
new ResponseUserRegisterMessage()
{
message = message,
});
#endif
}
protected async UniTaskVoid HandleRequestSelectCharacter(
RequestHandlerData requestHandler,
RequestSelectCharacterMessage request,
RequestProceedResultDelegate <ResponseSelectCharacterMessage> result)
{
#if UNITY_STANDALONE && !CLIENT_BUILD
long connectionId = requestHandler.ConnectionId;
UITextKeys message = UITextKeys.NONE;
CentralServerPeerInfo mapServerPeerInfo = default;
CentralUserPeerInfo userPeerInfo;
if (!userPeers.TryGetValue(connectionId, out userPeerInfo))
{
message = UITextKeys.UI_ERROR_NOT_LOGGED_IN;
}
else
{
CharacterResp characterResp = await DbServiceClient.ReadCharacterAsync(new ReadCharacterReq()
{
UserId = userPeerInfo.userId,
CharacterId = request.characterId
});
PlayerCharacterData character = characterResp.CharacterData;
if (character == null)
{
message = UITextKeys.UI_ERROR_INVALID_CHARACTER_DATA;
}
else if (!mapServerPeersBySceneName.TryGetValue(character.CurrentMapName, out mapServerPeerInfo))
{
message = UITextKeys.UI_ERROR_MAP_SERVER_NOT_READY;
}
}
AckResponseCode responseCode = message == UITextKeys.NONE ? AckResponseCode.Success : AckResponseCode.Error;
ResponseSelectCharacterMessage response = new ResponseSelectCharacterMessage();
response.message = message;
if (message != UITextKeys.UI_ERROR_MAP_SERVER_NOT_READY)
{
response.sceneName = mapServerPeerInfo.extra;
response.networkAddress = mapServerPeerInfo.networkAddress;
response.networkPort = mapServerPeerInfo.networkPort;
}
// Response
result.Invoke(responseCode, response);
#endif
}
public async UniTaskVoid HandleRequestCashPackageInfo(
RequestHandlerData requestHandler, EmptyMessage request,
RequestProceedResultDelegate <ResponseCashPackageInfoMessage> result)
{
#if UNITY_STANDALONE && !CLIENT_BUILD
// Set response data
UITextKeys message = UITextKeys.NONE;
int cash = 0;
List <int> cashPackageIds = new List <int>();
IPlayerCharacterData playerCharacter;
if (!GameInstance.ServerUserHandlers.TryGetPlayerCharacter(requestHandler.ConnectionId, out playerCharacter))
{
// Cannot find user
message = UITextKeys.UI_ERROR_NOT_LOGGED_IN;
}
else
{
// Get user cash amount
CashResp getCashResp = await DbServiceClient.GetCashAsync(new GetCashReq()
{
UserId = playerCharacter.UserId
});
cash = getCashResp.Cash;
// Set cash package ids
cashPackageIds.AddRange(GameInstance.CashPackages.Keys);
}
// Send response message
result.Invoke(
message == UITextKeys.NONE ? AckResponseCode.Success : AckResponseCode.Error,
new ResponseCashPackageInfoMessage()
{
message = message,
cash = cash,
cashPackageIds = cashPackageIds.ToArray(),
});
#endif
await UniTask.Yield();
}
public async UniTaskVoid HandleRequestReadMail(RequestHandlerData requestHandler, RequestReadMailMessage request, RequestProceedResultDelegate <ResponseReadMailMessage> result)
{
#if UNITY_STANDALONE && !CLIENT_BUILD
string userId;
if (GameInstance.ServerUserHandlers.TryGetUserId(requestHandler.ConnectionId, out userId))
{
AsyncResponseData <UpdateReadMailStateResp> resp = await DbServiceClient.UpdateReadMailStateAsync(new UpdateReadMailStateReq()
{
MailId = request.id,
UserId = userId,
});
if (!resp.IsSuccess)
{
result.InvokeError(new ResponseReadMailMessage()
{
message = UITextKeys.UI_ERROR_INTERNAL_SERVER_ERROR,
});
return;
}
UITextKeys message = resp.Response.Error;
result.Invoke(
message == UITextKeys.NONE ? AckResponseCode.Success : AckResponseCode.Error,
new ResponseReadMailMessage()
{
message = message,
mail = resp.Response.Mail,
});
}
else
{
result.Invoke(AckResponseCode.Error, new ResponseReadMailMessage()
{
message = UITextKeys.UI_ERROR_SERVICE_NOT_AVAILABLE,
});
}
#endif
}
public async UniTaskVoid HandleRequestSendMail(RequestHandlerData requestHandler, RequestSendMailMessage request, RequestProceedResultDelegate <ResponseSendMailMessage> result)
{
#if UNITY_STANDALONE && !CLIENT_BUILD
IPlayerCharacterData playerCharacter;
if (GameInstance.ServerUserHandlers.TryGetPlayerCharacter(requestHandler.ConnectionId, out playerCharacter))
{
// Validate gold
if (request.gold < 0)
{
request.gold = 0;
}
if (playerCharacter.Gold >= request.gold)
{
playerCharacter.Gold -= request.gold;
}
else
{
result.Invoke(AckResponseCode.Error, new ResponseSendMailMessage()
{
message = UITextKeys.UI_ERROR_NOT_ENOUGH_GOLD,
});
return;
}
// Find receiver
GetUserIdByCharacterNameResp userIdResp = await DbServiceClient.GetUserIdByCharacterNameAsync(new GetUserIdByCharacterNameReq()
{
CharacterName = request.receiverName,
});
string receiverId = userIdResp.UserId;
if (string.IsNullOrEmpty(receiverId))
{
result.Invoke(AckResponseCode.Error, new ResponseSendMailMessage()
{
message = UITextKeys.UI_ERROR_MAIL_SEND_NO_RECEIVER,
});
return;
}
Mail mail = new Mail()
{
SenderId = playerCharacter.UserId,
SenderName = playerCharacter.CharacterName,
ReceiverId = receiverId,
Title = request.title,
Content = request.content,
Gold = request.gold,
};
SendMailResp resp = await DbServiceClient.SendMailAsync(new SendMailReq()
{
Mail = mail,
});
UITextKeys message = resp.Error;
result.Invoke(
message == UITextKeys.NONE ? AckResponseCode.Success : AckResponseCode.Error,
new ResponseSendMailMessage()
{
message = message,
});
}
else
{
result.Invoke(AckResponseCode.Error, new ResponseSendMailMessage()
{
message = UITextKeys.UI_ERROR_SERVICE_NOT_AVAILABLE,
});
}
#endif
}
public void Deserialize(NetDataReader reader)
{
message = (UITextKeys)reader.GetPackedUShort();
peerInfo = new CentralServerPeerInfo();
peerInfo.Deserialize(reader);
}
public void Deserialize(NetDataReader reader)
{
message = (UITextKeys)reader.GetPackedUShort();
instanceId = reader.GetString();
requestId = reader.GetString();
}
public void Deserialize(NetDataReader reader)
{
Error = (UITextKeys)reader.GetByte();
}
public async UniTaskVoid HandleRequestMoveItemFromStorage(RequestHandlerData requestHandler, RequestMoveItemFromStorageMessage request, RequestProceedResultDelegate <ResponseMoveItemFromStorageMessage> result)
{
#if UNITY_STANDALONE && !CLIENT_BUILD
StorageId storageId = new StorageId(request.storageType, request.storageOwnerId);
IPlayerCharacterData playerCharacter;
if (!GameInstance.ServerUserHandlers.TryGetPlayerCharacter(requestHandler.ConnectionId, out playerCharacter))
{
result.InvokeError(new ResponseMoveItemFromStorageMessage()
{
message = UITextKeys.UI_ERROR_NOT_LOGGED_IN,
});
return;
}
if (!storageUsers.Add(playerCharacter.Id))
{
result.InvokeError(new ResponseMoveItemFromStorageMessage()
{
message = UITextKeys.UI_ERROR_CONTENT_NOT_AVAILABLE,
});
return;
}
if (!GameInstance.ServerStorageHandlers.CanAccessStorage(playerCharacter, storageId))
{
storageUsers.Remove(playerCharacter.Id);
result.InvokeError(new ResponseMoveItemFromStorageMessage()
{
message = UITextKeys.UI_ERROR_CANNOT_ACCESS_STORAGE,
});
return;
}
Storage storage = GameInstance.ServerStorageHandlers.GetStorage(storageId, out _);
AsyncResponseData <MoveItemFromStorageResp> resp = await DbServiceClient.MoveItemFromStorageAsync(new MoveItemFromStorageReq()
{
StorageType = request.storageType,
StorageOwnerId = request.storageOwnerId,
CharacterId = playerCharacter.Id,
WeightLimit = storage.weightLimit,
SlotLimit = storage.slotLimit,
StorageItemIndex = request.storageItemIndex,
StorageItemAmount = request.storageItemAmount,
InventoryItemIndex = request.inventoryItemIndex,
Inventory = new List <CharacterItem>(playerCharacter.NonEquipItems),
});
if (!resp.IsSuccess)
{
result.InvokeError(new ResponseMoveItemFromStorageMessage()
{
message = UITextKeys.UI_ERROR_INTERNAL_SERVER_ERROR,
});
return;
}
UITextKeys message = resp.Response.Error;
if (message != UITextKeys.NONE)
{
storageUsers.Remove(playerCharacter.Id);
result.InvokeError(new ResponseMoveItemFromStorageMessage()
{
message = message,
});
return;
}
playerCharacter.NonEquipItems = resp.Response.InventoryItemItems;
GameInstance.ServerStorageHandlers.SetStorageItems(storageId, resp.Response.StorageCharacterItems);
GameInstance.ServerStorageHandlers.NotifyStorageItemsUpdated(request.storageType, request.storageOwnerId);
// Success
storageUsers.Remove(playerCharacter.Id);
result.InvokeSuccess(new ResponseMoveItemFromStorageMessage());
#endif
}
protected UniTaskVoid HandleRequestAppServerRegister(
RequestHandlerData requestHandler,
RequestAppServerRegisterMessage request,
RequestProceedResultDelegate <ResponseAppServerRegisterMessage> result)
{
#if UNITY_STANDALONE && !CLIENT_BUILD
long connectionId = requestHandler.ConnectionId;
UITextKeys message = UITextKeys.NONE;
if (request.ValidateHash())
{
ResponseAppServerAddressMessage responseAppServerAddressMessage;
CentralServerPeerInfo peerInfo = request.peerInfo;
peerInfo.connectionId = connectionId;
switch (request.peerInfo.peerType)
{
case CentralServerPeerType.MapSpawnServer:
mapSpawnServerPeers[connectionId] = peerInfo;
if (LogInfo)
{
Logging.Log(LogTag, "Register Map Spawn Server: [" + connectionId + "]");
}
break;
case CentralServerPeerType.MapServer:
string sceneName = peerInfo.extra;
if (!mapServerPeersBySceneName.ContainsKey(sceneName))
{
BroadcastAppServers(connectionId, peerInfo);
// Collects server data
mapServerPeersBySceneName[sceneName] = peerInfo;
mapServerPeers[connectionId] = peerInfo;
mapUserIds[connectionId] = new HashSet <string>();
if (LogInfo)
{
Logging.Log(LogTag, "Register Map Server: [" + connectionId + "] [" + sceneName + "]");
}
}
else
{
message = UITextKeys.UI_ERROR_MAP_EXISTED;
if (LogInfo)
{
Logging.Log(LogTag, "Register Map Server Failed: [" + connectionId + "] [" + sceneName + "] [" + message + "]");
}
}
break;
case CentralServerPeerType.InstanceMapServer:
string instanceId = peerInfo.extra;
if (!instanceMapServerPeersByInstanceId.ContainsKey(instanceId))
{
BroadcastAppServers(connectionId, peerInfo);
// Collects server data
instanceMapServerPeersByInstanceId[instanceId] = peerInfo;
instanceMapServerPeers[connectionId] = peerInfo;
mapUserIds[connectionId] = new HashSet <string>();
if (LogInfo)
{
Logging.Log(LogTag, "Register Instance Map Server: [" + connectionId + "] [" + instanceId + "]");
}
}
else
{
message = UITextKeys.UI_ERROR_EVENT_EXISTED;
if (LogInfo)
{
Logging.Log(LogTag, "Register Instance Map Server Failed: [" + connectionId + "] [" + instanceId + "] [" + message + "]");
}
}
break;
case CentralServerPeerType.Chat:
chatServerPeers[connectionId] = peerInfo;
// Send chat peer info to map servers
responseAppServerAddressMessage = new ResponseAppServerAddressMessage()
{
message = UITextKeys.NONE,
peerInfo = peerInfo,
};
foreach (CentralServerPeerInfo mapServerPeer in mapServerPeers.Values)
{
ServerSendPacket(mapServerPeer.connectionId, DeliveryMethod.ReliableOrdered, MMOMessageTypes.AppServerAddress, responseAppServerAddressMessage);
}
if (LogInfo)
{
Logging.Log(LogTag, "Register Chat Server: [" + connectionId + "]");
}
break;
}
}
else
{
message = UITextKeys.UI_ERROR_INVALID_SERVER_HASH;
if (LogInfo)
{
Logging.Log(LogTag, "Register Server Failed: [" + connectionId + "] [" + message + "]");
}
}
// Response
result.Invoke(
message == UITextKeys.NONE ? AckResponseCode.Success : AckResponseCode.Error,
new ResponseAppServerRegisterMessage()
{
message = message,
});
#endif
return(default);
public async UniTaskVoid HandleRequestCashShopBuy(
RequestHandlerData requestHandler, RequestCashShopBuyMessage request,
RequestProceedResultDelegate<ResponseCashShopBuyMessage> result)
{
#if UNITY_STANDALONE && !CLIENT_BUILD
// Set response data
UITextKeys message = UITextKeys.NONE;
int dataId = request.dataId;
int userCash = 0;
int userGold = 0;
IPlayerCharacterData playerCharacter;
if (!GameInstance.ServerUserHandlers.TryGetPlayerCharacter(requestHandler.ConnectionId, out playerCharacter))
{
// Cannot find user
message = UITextKeys.UI_ERROR_NOT_LOGGED_IN;
}
else
{
// Get user cash amount
CashResp getCashResp = await DbServiceClient.GetCashAsync(new GetCashReq()
{
UserId = playerCharacter.UserId
});
userCash = getCashResp.Cash;
// Get user gold amount
GoldResp getGoldResp = await DbServiceClient.GetGoldAsync(new GetGoldReq()
{
UserId = playerCharacter.UserId
});
userGold = getGoldResp.Gold;
CashShopItem cashShopItem;
if (!GameInstance.CashShopItems.TryGetValue(dataId, out cashShopItem))
{
// Cannot find item
message = UITextKeys.UI_ERROR_ITEM_NOT_FOUND;
}
else if (userCash < cashShopItem.sellPriceCash)
{
// Not enough cash
message = UITextKeys.UI_ERROR_NOT_ENOUGH_CASH;
}
else if (userGold < cashShopItem.sellPriceGold)
{
// Not enough cash
message = UITextKeys.UI_ERROR_NOT_ENOUGH_GOLD;
}
else if (playerCharacter.IncreasingItemsWillOverwhelming(cashShopItem.receiveItems))
{
// Cannot carry all rewards
message = UITextKeys.UI_ERROR_WILL_OVERWHELMING;
}
else
{
// Decrease cash amount
CashResp changeCashResp = await DbServiceClient.ChangeCashAsync(new ChangeCashReq()
{
UserId = playerCharacter.UserId,
ChangeAmount = -cashShopItem.sellPriceCash
});
userCash = changeCashResp.Cash;
playerCharacter.UserCash = userCash;
// Decrease gold amount
GoldResp changeGoldResp = await DbServiceClient.ChangeGoldAsync(new ChangeGoldReq()
{
UserId = playerCharacter.UserId,
ChangeAmount = -cashShopItem.sellPriceGold
});
userGold = changeGoldResp.Gold;
playerCharacter.UserGold = userGold;
// Increase character gold
playerCharacter.Gold = playerCharacter.Gold.Increase(cashShopItem.receiveGold);
// Increase currencies
playerCharacter.IncreaseCurrencies(cashShopItem.receiveCurrencies);
// Increase character item
if (cashShopItem.receiveItems != null && cashShopItem.receiveItems.Length > 0)
{
foreach (ItemAmount receiveItem in cashShopItem.receiveItems)
{
if (receiveItem.item == null || receiveItem.amount <= 0) continue;
playerCharacter.AddOrSetNonEquipItems(CharacterItem.Create(receiveItem.item, 1, receiveItem.amount));
}
playerCharacter.FillEmptySlots();
}
}
}
// Send response message
result.Invoke(
message == UITextKeys.NONE ? AckResponseCode.Success : AckResponseCode.Error,
new ResponseCashShopBuyMessage()
{
message = message,
dataId = dataId,
userCash = userCash,
userGold = userGold,
});
#endif
await UniTask.Yield();
}
public async UniTaskVoid HandleRequestClaimMailItems(RequestHandlerData requestHandler, RequestClaimMailItemsMessage request, RequestProceedResultDelegate <ResponseClaimMailItemsMessage> result)
{
#if UNITY_STANDALONE && !CLIENT_BUILD
IPlayerCharacterData playerCharacter;
if (GameInstance.ServerUserHandlers.TryGetPlayerCharacter(requestHandler.ConnectionId, out playerCharacter))
{
UITextKeys message = UITextKeys.NONE;
GetMailResp mailResp = await DbServiceClient.GetMailAsync(new GetMailReq()
{
MailId = request.id,
UserId = playerCharacter.UserId,
});
Mail mail = mailResp.Mail;
if (mail.IsClaim)
{
message = UITextKeys.UI_ERROR_MAIL_CLAIM_ALREADY_CLAIMED;
}
else if (mail.IsDelete)
{
message = UITextKeys.UI_ERROR_CANNOT_ACCESS_STORAGE;
}
else
{
if (mail.Items.Count > 0)
{
List <CharacterItem> increasingItems = new List <CharacterItem>();
foreach (KeyValuePair <int, short> mailItem in mail.Items)
{
increasingItems.Add(CharacterItem.Create(mailItem.Key, amount: mailItem.Value));
}
if (playerCharacter.IncreasingItemsWillOverwhelming(increasingItems))
{
message = UITextKeys.UI_ERROR_WILL_OVERWHELMING;
}
else
{
playerCharacter.IncreaseItems(increasingItems);
}
}
if (message == UITextKeys.NONE && mail.Currencies.Count > 0)
{
List <CurrencyAmount> increasingCurrencies = new List <CurrencyAmount>();
Currency tempCurrency;
foreach (KeyValuePair <int, int> mailCurrency in mail.Currencies)
{
if (!GameInstance.Currencies.TryGetValue(mailCurrency.Key, out tempCurrency))
{
continue;
}
increasingCurrencies.Add(new CurrencyAmount()
{
currency = tempCurrency,
amount = mailCurrency.Value
});
}
playerCharacter.IncreaseCurrencies(increasingCurrencies);
}
if (message == UITextKeys.NONE && mail.Gold > 0)
{
playerCharacter.Gold = playerCharacter.Gold.Increase(mail.Gold);
}
}
if (message != UITextKeys.NONE)
{
result.Invoke(AckResponseCode.Error, new ResponseClaimMailItemsMessage()
{
message = message,
});
return;
}
UpdateClaimMailItemsStateResp resp = await DbServiceClient.UpdateClaimMailItemsStateAsync(new UpdateClaimMailItemsStateReq()
{
MailId = request.id,
UserId = playerCharacter.UserId,
});
message = resp.Error;
result.Invoke(
message == UITextKeys.NONE ? AckResponseCode.Success : AckResponseCode.Error,
new ResponseClaimMailItemsMessage()
{
message = message,
mail = resp.Mail,
});
}
else
{
result.Invoke(AckResponseCode.Error, new ResponseClaimMailItemsMessage()
{
message = UITextKeys.UI_ERROR_SERVICE_NOT_AVAILABLE,
});
}
#endif
}
public void Deserialize(NetDataReader reader)
{
message = (UITextKeys)reader.GetPackedUShort();
}
protected async UniTaskVoid HandleRequestCreateCharacter(
RequestHandlerData requestHandler,
RequestCreateCharacterMessage request,
RequestProceedResultDelegate <ResponseCreateCharacterMessage> result)
{
#if UNITY_STANDALONE && !CLIENT_BUILD
long connectionId = requestHandler.ConnectionId;
NetDataReader reader = requestHandler.Reader;
UITextKeys message = UITextKeys.NONE;
string characterName = request.characterName;
int dataId = request.dataId;
int entityId = request.entityId;
int factionId = request.factionId;
CentralUserPeerInfo userPeerInfo;
FindCharacterNameResp findCharacterNameResp = await DbServiceClient.FindCharacterNameAsync(new FindCharacterNameReq()
{
CharacterName = characterName
});
if (findCharacterNameResp.FoundAmount > 0)
{
message = UITextKeys.UI_ERROR_CHARACTER_NAME_EXISTED;
}
else if (!userPeers.TryGetValue(connectionId, out userPeerInfo))
{
message = UITextKeys.UI_ERROR_NOT_LOGGED_IN;
}
else if (string.IsNullOrEmpty(characterName) || characterName.Length < minCharacterNameLength)
{
message = UITextKeys.UI_ERROR_CHARACTER_NAME_TOO_SHORT;
}
else if (characterName.Length > maxCharacterNameLength)
{
message = UITextKeys.UI_ERROR_CHARACTER_NAME_TOO_LONG;
}
else if (!GameInstance.PlayerCharacters.ContainsKey(dataId) ||
!GameInstance.PlayerCharacterEntities.ContainsKey(entityId) ||
(GameInstance.Factions.Count > 0 && !GameInstance.Factions.ContainsKey(factionId)))
{
// If there is factions, it must have faction with the id stored in faction dictionary
message = UITextKeys.UI_ERROR_INVALID_DATA;
}
else
{
string characterId = GenericUtils.GetUniqueId();
PlayerCharacterData characterData = new PlayerCharacterData();
characterData.Id = characterId;
characterData.SetNewPlayerCharacterData(characterName, dataId, entityId);
characterData.FactionId = factionId;
DeserializeCreateCharacterExtra(characterData, reader);
await DbServiceClient.CreateCharacterAsync(new CreateCharacterReq()
{
UserId = userPeerInfo.userId,
CharacterData = characterData,
});
}
// Response
result.Invoke(
message == UITextKeys.NONE ? AckResponseCode.Success : AckResponseCode.Error,
new ResponseCreateCharacterMessage()
{
message = message,
});
#endif
}
