public async UniTaskVoid HandleRequestDeleteAllMails(RequestHandlerData requestHandler, EmptyMessage request, RequestProceedResultDelegate <ResponseDeleteAllMailsMessage> result)
{
#if UNITY_STANDALONE && !CLIENT_BUILD
string userId;
if (!GameInstance.ServerUserHandlers.TryGetUserId(requestHandler.ConnectionId, out userId))
{
result.Invoke(AckResponseCode.Error, new ResponseDeleteAllMailsMessage()
{
message = UITextKeys.UI_ERROR_NOT_LOGGED_IN,
});
}
AsyncResponseData <MailListResp> resp = await DbServiceClient.MailListAsync(new MailListReq()
{
UserId = userId,
OnlyNewMails = false,
});
if (!resp.IsSuccess)
{
result.Invoke(AckResponseCode.Error, new ResponseDeleteAllMailsMessage()
{
message = UITextKeys.UI_ERROR_INTERNAL_SERVER_ERROR,
});
return;
}
foreach (MailListEntry entry in resp.Response.List)
{
await DeleteMail(entry.Id, userId);
}
result.Invoke(AckResponseCode.Success, new ResponseDeleteAllMailsMessage());
#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
}
protected async UniTaskVoid HandleRequestDeleteCharacter(
RequestHandlerData requestHandler,
RequestDeleteCharacterMessage request,
RequestProceedResultDelegate <ResponseDeleteCharacterMessage> result)
{
#if UNITY_STANDALONE && !CLIENT_BUILD
long connectionId = requestHandler.ConnectionId;
CentralUserPeerInfo userPeerInfo;
if (!userPeers.TryGetValue(connectionId, out userPeerInfo))
{
result.InvokeError(new ResponseDeleteCharacterMessage()
{
message = UITextKeys.UI_ERROR_NOT_LOGGED_IN,
});
return;
}
AsyncResponseData <EmptyMessage> deleteResp = await DbServiceClient.DeleteCharacterAsync(new DeleteCharacterReq()
{
UserId = userPeerInfo.userId,
CharacterId = request.characterId
});
if (!deleteResp.IsSuccess)
{
result.InvokeError(new ResponseDeleteCharacterMessage()
{
message = UITextKeys.UI_ERROR_INTERNAL_SERVER_ERROR,
});
return;
}
// Response
result.InvokeSuccess(new ResponseDeleteCharacterMessage());
#endif
}
public async UniTaskVoid HandleRequestMailList(RequestHandlerData requestHandler, RequestMailListMessage request, RequestProceedResultDelegate <ResponseMailListMessage> result)
{
#if UNITY_STANDALONE && !CLIENT_BUILD
List <MailListEntry> mails = new List <MailListEntry>();
string userId;
if (GameInstance.ServerUserHandlers.TryGetUserId(requestHandler.ConnectionId, out userId))
{
AsyncResponseData <MailListResp> resp = await DbServiceClient.MailListAsync(new MailListReq()
{
UserId = userId,
OnlyNewMails = request.onlyNewMails,
});
if (resp.IsSuccess)
{
mails.AddRange(resp.Response.List);
}
}
result.Invoke(AckResponseCode.Success, new ResponseMailListMessage()
{
onlyNewMails = request.onlyNewMails,
mails = mails,
});
#endif
}
public async UniTaskVoid HandleRequestDeclinePartyInvitation(RequestHandlerData requestHandler, RequestDeclinePartyInvitationMessage request, RequestProceedResultDelegate <ResponseDeclinePartyInvitationMessage> result)
{
#if UNITY_STANDALONE && !CLIENT_BUILD
await UniTask.Yield();
BasePlayerCharacterEntity playerCharacter;
if (!GameInstance.ServerUserHandlers.TryGetPlayerCharacter(requestHandler.ConnectionId, out playerCharacter))
{
result.Invoke(AckResponseCode.Error, new ResponseDeclinePartyInvitationMessage()
{
message = UITextKeys.UI_ERROR_NOT_LOGGED_IN,
});
return;
}
ValidatePartyRequestResult validateResult = GameInstance.ServerPartyHandlers.CanDeclinePartyInvitation(request.partyId, playerCharacter);
if (!validateResult.IsSuccess)
{
result.Invoke(AckResponseCode.Error, new ResponseDeclinePartyInvitationMessage()
{
message = validateResult.GameMessage,
});
return;
}
GameInstance.ServerPartyHandlers.RemovePartyInvitation(request.partyId, playerCharacter.Id);
result.Invoke(AckResponseCode.Success, new ResponseDeclinePartyInvitationMessage()
{
message = UITextKeys.UI_PARTY_INVITATION_DECLINED,
});
#endif
}
protected async UniTaskVoid HandleRequestUserLogout(
RequestHandlerData requestHandler,
EmptyMessage request,
RequestProceedResultDelegate <EmptyMessage> result)
{
#if UNITY_STANDALONE && !CLIENT_BUILD
long connectionId = requestHandler.ConnectionId;
CentralUserPeerInfo userPeerInfo;
if (userPeers.TryGetValue(connectionId, out userPeerInfo))
{
userPeersByUserId.Remove(userPeerInfo.userId);
userPeers.Remove(connectionId);
AsyncResponseData <EmptyMessage> updateAccessTokenResp = await DbServiceClient.UpdateAccessTokenAsync(new UpdateAccessTokenReq()
{
UserId = userPeerInfo.userId,
AccessToken = string.Empty
});
if (!updateAccessTokenResp.IsSuccess)
{
result.InvokeError(EmptyMessage.Value);
return;
}
}
// Response
result.InvokeSuccess(EmptyMessage.Value);
#endif
}
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 = DatabaseServiceUtils.MakeListFromRepeatedByteString <PlayerCharacterData>(charactersResp.List);
}
// Response
result.Invoke(
message == UITextKeys.NONE ? AckResponseCode.Success : AckResponseCode.Error,
new ResponseCharactersMessage()
{
message = message,
characters = characters,
});
#endif
}
public async UniTaskVoid HandleRequestDepositUserGold(RequestHandlerData requestHandler, RequestDepositUserGoldMessage request, RequestProceedResultDelegate <ResponseDepositUserGoldMessage> result)
{
#if UNITY_STANDALONE && !CLIENT_BUILD
IPlayerCharacterData playerCharacter;
if (!GameInstance.ServerUserHandlers.TryGetPlayerCharacter(requestHandler.ConnectionId, out playerCharacter))
{
result.Invoke(AckResponseCode.Error, new ResponseDepositUserGoldMessage()
{
message = UITextKeys.UI_ERROR_NOT_LOGGED_IN,
});
return;
}
if (playerCharacter.Gold - request.gold < 0)
{
result.Invoke(AckResponseCode.Error, new ResponseDepositUserGoldMessage()
{
message = UITextKeys.UI_ERROR_NOT_ENOUGH_GOLD_TO_DEPOSIT,
});
return;
}
// Update gold
GoldResp changeGoldResp = await DbServiceClient.ChangeGoldAsync(new ChangeGoldReq()
{
UserId = playerCharacter.UserId,
ChangeAmount = request.gold
});
playerCharacter.UserGold = changeGoldResp.Gold;
playerCharacter.Gold -= request.gold;
result.Invoke(AckResponseCode.Success, new ResponseDepositUserGoldMessage());
#endif
}
protected async UniTaskVoid HandleRequestCharacters(
RequestHandlerData requestHandler,
EmptyMessage request,
RequestProceedResultDelegate <ResponseCharactersMessage> result)
{
long connectionId = requestHandler.ConnectionId;
ResponseCharactersMessage.Error error = ResponseCharactersMessage.Error.None;
List <PlayerCharacterData> characters = null;
CentralUserPeerInfo userPeerInfo;
if (!userPeers.TryGetValue(connectionId, out userPeerInfo))
{
error = ResponseCharactersMessage.Error.NotLoggedin;
}
else
{
CharactersResp charactersResp = await DbServiceClient.ReadCharactersAsync(new ReadCharactersReq()
{
UserId = userPeerInfo.userId
});
characters = DatabaseServiceUtils.MakeListFromRepeatedByteString <PlayerCharacterData>(charactersResp.List);
}
// Response
result.Invoke(
error == ResponseCharactersMessage.Error.None ? AckResponseCode.Success : AckResponseCode.Error,
new ResponseCharactersMessage()
{
error = error,
characters = characters,
});
}
protected async UniTaskVoid HandleRequestDeleteCharacter(
RequestHandlerData requestHandler,
RequestDeleteCharacterMessage request,
RequestProceedResultDelegate <ResponseDeleteCharacterMessage> result)
{
long connectionId = requestHandler.ConnectionId;
ResponseDeleteCharacterMessage.Error error = ResponseDeleteCharacterMessage.Error.None;
CentralUserPeerInfo userPeerInfo;
if (!userPeers.TryGetValue(connectionId, out userPeerInfo))
{
error = ResponseDeleteCharacterMessage.Error.NotLoggedin;
}
else
{
await DbServiceClient.DeleteCharacterAsync(new DeleteCharacterReq()
{
UserId = userPeerInfo.userId,
CharacterId = request.characterId
});
}
// Response
result.Invoke(
error == ResponseDeleteCharacterMessage.Error.None ? AckResponseCode.Success : AckResponseCode.Error,
new ResponseDeleteCharacterMessage()
{
error = error,
});
}
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 HandleRequestOpenStorage(RequestHandlerData requestHandler, RequestOpenStorageMessage request, RequestProceedResultDelegate <ResponseOpenStorageMessage> result)
{
#if UNITY_STANDALONE && !CLIENT_BUILD
if (request.storageType != StorageType.Player &&
request.storageType != StorageType.Guild)
{
result.InvokeError(new ResponseOpenStorageMessage()
{
message = UITextKeys.UI_ERROR_CANNOT_ACCESS_STORAGE,
});
return;
}
IPlayerCharacterData playerCharacter;
if (!GameInstance.ServerUserHandlers.TryGetPlayerCharacter(requestHandler.ConnectionId, out playerCharacter))
{
result.InvokeError(new ResponseOpenStorageMessage()
{
message = UITextKeys.UI_ERROR_NOT_LOGGED_IN,
});
return;
}
StorageId storageId;
if (!playerCharacter.GetStorageId(request.storageType, 0, out storageId))
{
result.InvokeError(new ResponseOpenStorageMessage()
{
message = UITextKeys.UI_ERROR_STORAGE_NOT_FOUND,
});
return;
}
GameInstance.ServerStorageHandlers.OpenStorage(requestHandler.ConnectionId, playerCharacter, storageId);
result.InvokeSuccess(new ResponseOpenStorageMessage());
await UniTask.Yield();
#endif
}
public async UniTaskVoid HandleRequestDeclineGuildInvitation(RequestHandlerData requestHandler, RequestDeclineGuildInvitationMessage request, RequestProceedResultDelegate <ResponseDeclineGuildInvitationMessage> result)
{
#if UNITY_STANDALONE && !CLIENT_BUILD
await UniTask.Yield();
BasePlayerCharacterEntity playerCharacter;
if (!GameInstance.ServerUserHandlers.TryGetPlayerCharacter(requestHandler.ConnectionId, out playerCharacter))
{
result.InvokeError(new ResponseDeclineGuildInvitationMessage()
{
message = UITextKeys.UI_ERROR_NOT_LOGGED_IN,
});
return;
}
ValidateGuildRequestResult validateResult = GameInstance.ServerGuildHandlers.CanDeclineGuildInvitation(request.guildId, playerCharacter);
if (!validateResult.IsSuccess)
{
result.InvokeError(new ResponseDeclineGuildInvitationMessage()
{
message = validateResult.GameMessage,
});
return;
}
GameInstance.ServerGuildHandlers.RemoveGuildInvitation(request.guildId, playerCharacter.Id);
// Send message to inviter
GameInstance.ServerGameMessageHandlers.SendGameMessageByCharacterId(request.inviterId, UITextKeys.UI_GUILD_INVITATION_DECLINED);
// Response to invitee
result.InvokeSuccess(new ResponseDeclineGuildInvitationMessage()
{
message = UITextKeys.UI_GUILD_INVITATION_DECLINED,
});
#endif
}
public async UniTaskVoid HandleRequestGuildRequestNotification(RequestHandlerData requestHandler, EmptyMessage request, RequestProceedResultDelegate <ResponseGuildRequestNotificationMessage> result)
{
#if UNITY_STANDALONE && !CLIENT_BUILD
result.Invoke(AckResponseCode.Unimplemented, new ResponseGuildRequestNotificationMessage());
await UniTask.Yield();
#endif
}
public async UniTaskVoid HandleRequestAcceptGuildInvitation(RequestHandlerData requestHandler, RequestAcceptGuildInvitationMessage request, RequestProceedResultDelegate <ResponseAcceptGuildInvitationMessage> result)
{
#if UNITY_STANDALONE && !CLIENT_BUILD
await UniTask.Yield();
BasePlayerCharacterEntity playerCharacter;
if (!GameInstance.ServerUserHandlers.TryGetPlayerCharacter(requestHandler.ConnectionId, out playerCharacter))
{
result.InvokeError(new ResponseAcceptGuildInvitationMessage()
{
message = UITextKeys.UI_ERROR_NOT_LOGGED_IN,
});
return;
}
ValidateGuildRequestResult validateResult = GameInstance.ServerGuildHandlers.CanAcceptGuildInvitation(request.guildId, playerCharacter);
if (!validateResult.IsSuccess)
{
result.InvokeError(new ResponseAcceptGuildInvitationMessage()
{
message = validateResult.GameMessage,
});
return;
}
playerCharacter.GuildId = request.guildId;
validateResult.Guild.AddMember(playerCharacter);
GameInstance.ServerGuildHandlers.SetGuild(request.guildId, validateResult.Guild);
GameInstance.ServerGuildHandlers.RemoveGuildInvitation(request.guildId, playerCharacter.Id);
// Save to database
AsyncResponseData <GuildResp> updateResp = await DbServiceClient.UpdateCharacterGuildAsync(new UpdateCharacterGuildReq()
{
SocialCharacterData = SocialCharacterData.Create(playerCharacter),
GuildId = request.guildId,
GuildRole = validateResult.Guild.GetMemberRole(playerCharacter.Id)
});
if (!updateResp.IsSuccess)
{
result.InvokeError(new ResponseAcceptGuildInvitationMessage()
{
message = UITextKeys.UI_ERROR_INTERNAL_SERVER_ERROR,
});
return;
}
// Broadcast via chat server
if (ClusterClient.IsNetworkActive)
{
ClusterClient.SendAddSocialMember(MMOMessageTypes.UpdateGuildMember, request.guildId, playerCharacter.Id, playerCharacter.CharacterName, playerCharacter.DataId, playerCharacter.Level);
}
GameInstance.ServerGameMessageHandlers.SendSetGuildData(requestHandler.ConnectionId, validateResult.Guild);
GameInstance.ServerGameMessageHandlers.SendAddGuildMembersToOne(requestHandler.ConnectionId, validateResult.Guild);
GameInstance.ServerGameMessageHandlers.SendAddGuildMemberToMembers(validateResult.Guild, playerCharacter.Id, playerCharacter.CharacterName, playerCharacter.DataId, playerCharacter.Level);
// Send message to inviter
GameInstance.ServerGameMessageHandlers.SendGameMessageByCharacterId(request.inviterId, UITextKeys.UI_GUILD_INVITATION_ACCEPTED);
// Response to invitee
result.InvokeSuccess(new ResponseAcceptGuildInvitationMessage()
{
message = UITextKeys.UI_GUILD_INVITATION_ACCEPTED,
});
#endif
}
private UniTaskVoid HandleRequestSpawnMap(
RequestHandlerData requestHandler,
RequestSpawnMapMessage request,
RequestProceedResultDelegate <ResponseSpawnMapMessage> result)
{
ResponseSpawnMapMessage.Error error = ResponseSpawnMapMessage.Error.None;
if (!CentralAppServerRegister.IsRegisteredToCentralServer)
{
error = ResponseSpawnMapMessage.Error.NotReady;
}
else if (string.IsNullOrEmpty(request.mapId))
{
error = ResponseSpawnMapMessage.Error.EmptySceneName;
}
if (error != ResponseSpawnMapMessage.Error.None)
{
result.Invoke(AckResponseCode.Error, new ResponseSpawnMapMessage()
{
error = error
});
}
else
{
SpawnMap(request, result, false);
}
return(default);
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 = (UITextKeys)resp.Error;
result.Invoke(
message == UITextKeys.NONE ? AckResponseCode.Success : AckResponseCode.Error,
new ResponseReadMailMessage()
{
message = message,
mail = resp.Mail.FromByteString <Mail>(),
});
}
else
{
result.Invoke(AckResponseCode.Error, new ResponseReadMailMessage()
{
message = UITextKeys.UI_ERROR_SERVICE_NOT_AVAILABLE,
});
}
#endif
}
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 HandleRequestChangeMemberGuildRole(RequestHandlerData requestHandler, RequestChangeMemberGuildRoleMessage request, RequestProceedResultDelegate <ResponseChangeMemberGuildRoleMessage> result)
{
#if UNITY_STANDALONE && !CLIENT_BUILD
await UniTask.Yield();
IPlayerCharacterData playerCharacter;
if (!GameInstance.ServerUserHandlers.TryGetPlayerCharacter(requestHandler.ConnectionId, out playerCharacter))
{
result.InvokeError(new ResponseChangeMemberGuildRoleMessage()
{
message = UITextKeys.UI_ERROR_NOT_LOGGED_IN,
});
return;
}
ValidateGuildRequestResult validateResult = GameInstance.ServerGuildHandlers.CanChangeGuildMemberRole(playerCharacter, request.memberId);
if (!validateResult.IsSuccess)
{
result.InvokeError(new ResponseChangeMemberGuildRoleMessage()
{
message = validateResult.GameMessage,
});
return;
}
// Save to database
AsyncResponseData <GuildResp> updateResp = await DbServiceClient.UpdateGuildMemberRoleAsync(new UpdateGuildMemberRoleReq()
{
GuildId = validateResult.GuildId,
MemberCharacterId = request.memberId,
GuildRole = request.guildRole
});
if (!updateResp.IsSuccess)
{
result.InvokeError(new ResponseChangeMemberGuildRoleMessage()
{
message = UITextKeys.UI_ERROR_INTERNAL_SERVER_ERROR,
});
return;
}
// Update cache
validateResult.Guild.SetMemberRole(request.memberId, request.guildRole);
GameInstance.ServerGuildHandlers.SetGuild(validateResult.GuildId, validateResult.Guild);
IPlayerCharacterData memberCharacter;
if (GameInstance.ServerUserHandlers.TryGetPlayerCharacterById(request.memberId, out memberCharacter))
{
memberCharacter.GuildRole = request.guildRole;
memberCharacter.SharedGuildExp = validateResult.Guild.GetRole(request.guildRole).shareExpPercentage;
}
// Broadcast via chat server
if (ClusterClient.IsNetworkActive)
{
ClusterClient.SendSetGuildMemberRole(MMOMessageTypes.UpdateGuild, validateResult.GuildId, request.memberId, request.guildRole);
}
GameInstance.ServerGameMessageHandlers.SendSetGuildMemberRoleToMembers(validateResult.Guild, request.memberId, request.guildRole);
result.InvokeSuccess(new ResponseChangeMemberGuildRoleMessage());
#endif
}
public async UniTaskVoid HandleRequestKickMemberFromGuild(RequestHandlerData requestHandler, RequestKickMemberFromGuildMessage request, RequestProceedResultDelegate <ResponseKickMemberFromGuildMessage> result)
{
#if UNITY_STANDALONE && !CLIENT_BUILD
await UniTask.Yield();
IPlayerCharacterData playerCharacter;
if (!GameInstance.ServerUserHandlers.TryGetPlayerCharacter(requestHandler.ConnectionId, out playerCharacter))
{
result.InvokeError(new ResponseKickMemberFromGuildMessage()
{
message = UITextKeys.UI_ERROR_NOT_LOGGED_IN,
});
return;
}
ValidateGuildRequestResult validateResult = GameInstance.ServerGuildHandlers.CanKickMemberFromGuild(playerCharacter, request.memberId);
if (!validateResult.IsSuccess)
{
result.InvokeError(new ResponseKickMemberFromGuildMessage()
{
message = validateResult.GameMessage,
});
return;
}
// Save to database
AsyncResponseData <EmptyMessage> updateResp = await DbServiceClient.ClearCharacterGuildAsync(new ClearCharacterGuildReq()
{
CharacterId = request.memberId
});
if (!updateResp.IsSuccess)
{
result.InvokeError(new ResponseKickMemberFromGuildMessage()
{
message = validateResult.GameMessage,
});
return;
}
// Delete from cache
IPlayerCharacterData memberCharacter;
long memberConnectionId;
if (GameInstance.ServerUserHandlers.TryGetPlayerCharacterById(request.memberId, out memberCharacter) &&
GameInstance.ServerUserHandlers.TryGetConnectionId(request.memberId, out memberConnectionId))
{
memberCharacter.ClearGuild();
GameInstance.ServerGameMessageHandlers.SendClearGuildData(memberConnectionId, validateResult.GuildId);
}
validateResult.Guild.RemoveMember(request.memberId);
GameInstance.ServerGuildHandlers.SetGuild(validateResult.GuildId, validateResult.Guild);
// Broadcast via chat server
if (ClusterClient.IsNetworkActive)
{
ClusterClient.SendRemoveSocialMember(MMOMessageTypes.UpdateGuildMember, validateResult.GuildId, request.memberId);
}
GameInstance.ServerGameMessageHandlers.SendRemoveGuildMemberToMembers(validateResult.Guild, request.memberId);
result.InvokeSuccess(new ResponseKickMemberFromGuildMessage());
#endif
}
protected async UniTaskVoid DbFacebookLogin(RequestHandlerData requestHandler, DbFacebookLoginReq request, RequestProceedResultDelegate <DbFacebookLoginResp> result)
{
#if UNITY_STANDALONE && !CLIENT_BUILD
result.Invoke(AckResponseCode.Success, new DbFacebookLoginResp()
{
userId = await Database.FacebookLogin(request.id, request.email),
});
#endif
}
protected async UniTaskVoid HandleRequestSelectCharacter(
RequestHandlerData requestHandler,
RequestSelectCharacterMessage request,
RequestProceedResultDelegate <ResponseSelectCharacterMessage> result)
{
#if UNITY_STANDALONE && !CLIENT_BUILD
long connectionId = requestHandler.ConnectionId;
CentralServerPeerInfo mapServerPeerInfo = default;
CentralUserPeerInfo userPeerInfo;
if (!userPeers.TryGetValue(connectionId, out userPeerInfo))
{
result.InvokeError(new ResponseSelectCharacterMessage()
{
message = UITextKeys.UI_ERROR_NOT_LOGGED_IN,
});
return;
}
AsyncResponseData <CharacterResp> characterResp = await DbServiceClient.ReadCharacterAsync(new ReadCharacterReq()
{
UserId = userPeerInfo.userId,
CharacterId = request.characterId
});
if (!characterResp.IsSuccess)
{
result.InvokeError(new ResponseSelectCharacterMessage()
{
message = UITextKeys.UI_ERROR_INTERNAL_SERVER_ERROR,
});
return;
}
PlayerCharacterData character = characterResp.Response.CharacterData;
if (character == null)
{
result.InvokeError(new ResponseSelectCharacterMessage()
{
message = UITextKeys.UI_ERROR_INVALID_CHARACTER_DATA,
});
return;
}
if (!ClusterServer.MapServerPeersByMapId.TryGetValue(character.CurrentMapName, out mapServerPeerInfo))
{
result.InvokeError(new ResponseSelectCharacterMessage()
{
message = UITextKeys.UI_ERROR_MAP_SERVER_NOT_READY,
});
return;
}
// Response
result.InvokeSuccess(new ResponseSelectCharacterMessage()
{
sceneName = mapServerPeerInfo.extra,
networkAddress = mapServerPeerInfo.networkAddress,
networkPort = mapServerPeerInfo.networkPort,
});
#endif
}
public async UniTaskVoid HandleRequestChangeGuildRole(RequestHandlerData requestHandler, RequestChangeGuildRoleMessage request, RequestProceedResultDelegate <ResponseChangeGuildRoleMessage> result)
{
#if UNITY_STANDALONE && !CLIENT_BUILD
await UniTask.Yield();
IPlayerCharacterData playerCharacter;
if (!GameInstance.ServerUserHandlers.TryGetPlayerCharacter(requestHandler.ConnectionId, out playerCharacter))
{
result.Invoke(AckResponseCode.Error, new ResponseChangeGuildRoleMessage()
{
message = UITextKeys.UI_ERROR_NOT_LOGGED_IN,
});
return;
}
ValidateGuildRequestResult validateResult = GameInstance.ServerGuildHandlers.CanChangeGuildRole(playerCharacter, request.guildRole, request.name);
if (!validateResult.IsSuccess)
{
result.Invoke(AckResponseCode.Error, new ResponseChangeGuildRoleMessage()
{
message = validateResult.GameMessage,
});
return;
}
validateResult.Guild.SetRole(request.guildRole, request.name, request.canInvite, request.canKick, request.shareExpPercentage);
GameInstance.ServerGuildHandlers.SetGuild(validateResult.GuildId, validateResult.Guild);
// Change characters guild role
IPlayerCharacterData memberCharacter;
foreach (string memberId in validateResult.Guild.GetMemberIds())
{
if (GameInstance.ServerUserHandlers.TryGetPlayerCharacterById(memberId, out memberCharacter))
{
if (validateResult.Guild.GetMemberRole(memberCharacter.Id) == request.guildRole)
{
memberCharacter.SharedGuildExp = request.shareExpPercentage;
}
}
}
// Save to database
_ = DbServiceClient.UpdateGuildRoleAsync(new UpdateGuildRoleReq()
{
GuildId = validateResult.GuildId,
GuildRole = request.guildRole,
RoleName = request.name,
CanInvite = request.canInvite,
CanKick = request.canKick,
ShareExpPercentage = request.shareExpPercentage
});
// Broadcast via chat server
if (ChatNetworkManager.IsClientConnected)
{
ChatNetworkManager.SendSetGuildRole(null, MMOMessageTypes.UpdateGuild, validateResult.GuildId, request.guildRole, request.name, request.canInvite, request.canKick, request.shareExpPercentage);
}
GameInstance.ServerGameMessageHandlers.SendSetGuildRoleToMembers(validateResult.Guild, request.guildRole, request.name, request.canInvite, request.canKick, request.shareExpPercentage);
result.Invoke(AckResponseCode.Success, new ResponseChangeGuildRoleMessage());
#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();
}
public async UniTaskVoid HandleRequestDepositGuildGold(RequestHandlerData requestHandler, RequestDepositGuildGoldMessage request, RequestProceedResultDelegate <ResponseDepositGuildGoldMessage> result)
{
#if UNITY_STANDALONE && !CLIENT_BUILD
IPlayerCharacterData playerCharacter;
if (!GameInstance.ServerUserHandlers.TryGetPlayerCharacter(requestHandler.ConnectionId, out playerCharacter))
{
result.InvokeError(new ResponseDepositGuildGoldMessage()
{
message = UITextKeys.UI_ERROR_NOT_LOGGED_IN,
});
return;
}
GuildData guild;
if (!GameInstance.ServerGuildHandlers.TryGetGuild(playerCharacter.GuildId, out guild))
{
result.InvokeError(new ResponseDepositGuildGoldMessage()
{
message = UITextKeys.UI_ERROR_NOT_JOINED_GUILD,
});
return;
}
if (playerCharacter.Gold - request.gold < 0)
{
result.InvokeError(new ResponseDepositGuildGoldMessage()
{
message = UITextKeys.UI_ERROR_NOT_ENOUGH_GOLD_TO_DEPOSIT,
});
return;
}
// Update gold
AsyncResponseData <GuildGoldResp> changeGoldResp = await DbServiceClient.ChangeGuildGoldAsync(new ChangeGuildGoldReq()
{
GuildId = playerCharacter.GuildId,
ChangeAmount = request.gold
});
if (!changeGoldResp.IsSuccess)
{
result.InvokeError(new ResponseDepositGuildGoldMessage()
{
message = UITextKeys.UI_ERROR_INTERNAL_SERVER_ERROR,
});
return;
}
guild.gold = changeGoldResp.Response.GuildGold;
playerCharacter.Gold -= request.gold;
GameInstance.ServerGuildHandlers.SetGuild(playerCharacter.GuildId, guild);
// Broadcast via chat server
if (ClusterClient.IsNetworkActive)
{
ClusterClient.SendSetGuildGold(MMOMessageTypes.UpdateGuild, guild.id, guild.gold);
}
GameInstance.ServerGameMessageHandlers.SendSetGuildGoldToMembers(guild);
result.InvokeSuccess(new ResponseDepositGuildGoldMessage());
#endif
}
public async UniTaskVoid HandleRequestWithdrawGuildGold(RequestHandlerData requestHandler, RequestWithdrawGuildGoldMessage request, RequestProceedResultDelegate <ResponseWithdrawGuildGoldMessage> result)
{
#if UNITY_STANDALONE && !CLIENT_BUILD
IPlayerCharacterData playerCharacter;
if (!GameInstance.ServerUserHandlers.TryGetPlayerCharacter(requestHandler.ConnectionId, out playerCharacter))
{
result.Invoke(AckResponseCode.Error, new ResponseWithdrawGuildGoldMessage()
{
message = UITextKeys.UI_ERROR_NOT_LOGGED_IN,
});
return;
}
GuildData guild;
if (!GameInstance.ServerGuildHandlers.TryGetGuild(playerCharacter.GuildId, out guild))
{
result.Invoke(AckResponseCode.Error, new ResponseWithdrawGuildGoldMessage()
{
message = UITextKeys.UI_ERROR_NOT_JOINED_GUILD,
});
return;
}
// Get gold
GuildGoldResp goldResp = await DbServiceClient.GetGuildGoldAsync(new GetGuildGoldReq()
{
GuildId = playerCharacter.GuildId
});
int gold = goldResp.GuildGold - request.gold;
if (gold < 0)
{
result.Invoke(AckResponseCode.Error, new ResponseWithdrawGuildGoldMessage()
{
message = UITextKeys.UI_ERROR_NOT_ENOUGH_GOLD_TO_WITHDRAW,
});
return;
}
// Update gold
GuildGoldResp changeGoldResp = await DbServiceClient.ChangeGuildGoldAsync(new ChangeGuildGoldReq()
{
GuildId = playerCharacter.GuildId,
ChangeAmount = -request.gold
});
guild.gold = changeGoldResp.GuildGold;
playerCharacter.Gold = playerCharacter.Gold.Increase(request.gold);
GameInstance.ServerGuildHandlers.SetGuild(playerCharacter.GuildId, guild);
// Broadcast via chat server
if (ChatNetworkManager.IsClientConnected)
{
ChatNetworkManager.SendSetGuildGold(null, MMOMessageTypes.UpdateGuild, guild.id, guild.gold);
}
GameInstance.ServerGameMessageHandlers.SendSetGuildGoldToMembers(guild);
result.Invoke(AckResponseCode.Success, new ResponseWithdrawGuildGoldMessage());
#endif
}
public async UniTaskVoid HandleRequestChangeGuildLeader(RequestHandlerData requestHandler, RequestChangeGuildLeaderMessage request, RequestProceedResultDelegate <ResponseChangeGuildLeaderMessage> result)
{
#if UNITY_STANDALONE && !CLIENT_BUILD
await UniTask.Yield();
IPlayerCharacterData playerCharacter;
if (!GameInstance.ServerUserHandlers.TryGetPlayerCharacter(requestHandler.ConnectionId, out playerCharacter))
{
result.Invoke(AckResponseCode.Error, new ResponseChangeGuildLeaderMessage()
{
message = UITextKeys.UI_ERROR_NOT_LOGGED_IN,
});
return;
}
ValidateGuildRequestResult validateResult = GameInstance.ServerGuildHandlers.CanChangeGuildLeader(playerCharacter, request.memberId);
if (!validateResult.IsSuccess)
{
result.Invoke(AckResponseCode.Error, new ResponseChangeGuildLeaderMessage()
{
message = validateResult.GameMessage,
});
return;
}
byte swappingGuildRole = validateResult.Guild.GetMemberRole(request.memberId);
validateResult.Guild.SetLeader(request.memberId);
validateResult.Guild.SetMemberRole(playerCharacter.Id, swappingGuildRole);
playerCharacter.GuildRole = swappingGuildRole;
GameInstance.ServerGuildHandlers.SetGuild(validateResult.GuildId, validateResult.Guild);
// Save to database
_ = DbServiceClient.UpdateGuildLeaderAsync(new UpdateGuildLeaderReq()
{
GuildId = validateResult.GuildId,
LeaderCharacterId = request.memberId
});
_ = DbServiceClient.UpdateGuildMemberRoleAsync(new UpdateGuildMemberRoleReq()
{
MemberCharacterId = request.memberId,
GuildRole = validateResult.Guild.GetMemberRole(request.memberId)
});
_ = DbServiceClient.UpdateGuildMemberRoleAsync(new UpdateGuildMemberRoleReq()
{
MemberCharacterId = request.memberId,
GuildRole = validateResult.Guild.GetMemberRole(request.memberId)
});
// Broadcast via chat server
if (ChatNetworkManager.IsClientConnected)
{
ChatNetworkManager.SendChangeGuildLeader(null, MMOMessageTypes.UpdateGuild, validateResult.GuildId, request.memberId);
}
GameInstance.ServerGameMessageHandlers.SendSetGuildLeaderToMembers(validateResult.Guild);
GameInstance.ServerGameMessageHandlers.SendSetGuildMemberRoleToMembers(validateResult.Guild, request.memberId, 0);
result.Invoke(AckResponseCode.Success, new ResponseChangeGuildLeaderMessage());
#endif
}
public async UniTaskVoid HandleRequestWithdrawUserGold(RequestHandlerData requestHandler, RequestWithdrawUserGoldMessage request, RequestProceedResultDelegate <ResponseWithdrawUserGoldMessage> result)
{
#if UNITY_STANDALONE && !CLIENT_BUILD
IPlayerCharacterData playerCharacter;
if (!GameInstance.ServerUserHandlers.TryGetPlayerCharacter(requestHandler.ConnectionId, out playerCharacter))
{
result.InvokeError(new ResponseWithdrawUserGoldMessage()
{
message = UITextKeys.UI_ERROR_NOT_LOGGED_IN,
});
return;
}
// Get gold
AsyncResponseData <GoldResp> goldResp = await DbServiceClient.GetGoldAsync(new GetGoldReq()
{
UserId = playerCharacter.UserId
});
if (!goldResp.IsSuccess)
{
result.InvokeError(new ResponseWithdrawUserGoldMessage()
{
message = UITextKeys.UI_ERROR_INTERNAL_SERVER_ERROR,
});
return;
}
if (goldResp.Response.Gold - request.gold < 0)
{
result.InvokeError(new ResponseWithdrawUserGoldMessage()
{
message = UITextKeys.UI_ERROR_NOT_ENOUGH_GOLD_TO_WITHDRAW,
});
return;
}
// Update gold
AsyncResponseData <GoldResp> changeGoldResp = await DbServiceClient.ChangeGoldAsync(new ChangeGoldReq()
{
UserId = playerCharacter.UserId,
ChangeAmount = -request.gold
});
if (!changeGoldResp.IsSuccess)
{
result.InvokeError(new ResponseWithdrawUserGoldMessage()
{
message = UITextKeys.UI_ERROR_INTERNAL_SERVER_ERROR,
});
return;
}
playerCharacter.UserGold = changeGoldResp.Response.Gold;
playerCharacter.Gold = playerCharacter.Gold.Increase(request.gold);
result.InvokeSuccess(new ResponseWithdrawUserGoldMessage());
#endif
}
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
}
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();
}
