protected async UniTaskVoid HandleRequestUserRegister(
RequestHandlerData requestHandler,
RequestUserRegisterMessage request,
RequestProceedResultDelegate <ResponseUserRegisterMessage> result)
{
#if UNITY_STANDALONE && !CLIENT_BUILD
if (disableDefaultLogin)
{
result.InvokeError(new ResponseUserRegisterMessage()
{
message = UITextKeys.UI_ERROR_SERVICE_NOT_AVAILABLE
});
return;
}
string username = request.username.Trim();
string password = request.password.Trim();
string email = request.email.Trim();
if (!NameValidating.ValidateUsername(username))
{
result.InvokeError(new ResponseUserRegisterMessage()
{
message = UITextKeys.UI_ERROR_INVALID_USERNAME
});
return;
}
if (requireEmail)
{
if (string.IsNullOrEmpty(email) || !Email.IsValid(email))
{
result.InvokeError(new ResponseUserRegisterMessage()
{
message = UITextKeys.UI_ERROR_INVALID_EMAIL,
});
return;
}
AsyncResponseData <FindEmailResp> findEmailResp = await DbServiceClient.FindEmailAsync(new FindEmailReq()
{
Email = email
});
if (!findEmailResp.IsSuccess)
{
result.InvokeError(new ResponseUserRegisterMessage()
{
message = UITextKeys.UI_ERROR_INTERNAL_SERVER_ERROR,
});
return;
}
if (findEmailResp.Response.FoundAmount > 0)
{
result.InvokeError(new ResponseUserRegisterMessage()
{
message = UITextKeys.UI_ERROR_EMAIL_ALREADY_IN_USE,
});
return;
}
}
AsyncResponseData <FindUsernameResp> findUsernameResp = await DbServiceClient.FindUsernameAsync(new FindUsernameReq()
{
Username = username
});
if (!findUsernameResp.IsSuccess)
{
result.InvokeError(new ResponseUserRegisterMessage()
{
message = UITextKeys.UI_ERROR_INTERNAL_SERVER_ERROR,
});
return;
}
if (findUsernameResp.Response.FoundAmount > 0)
{
result.InvokeError(new ResponseUserRegisterMessage()
{
message = UITextKeys.UI_ERROR_USERNAME_EXISTED,
});
return;
}
if (string.IsNullOrEmpty(username) || username.Length < minUsernameLength)
{
result.InvokeError(new ResponseUserRegisterMessage()
{
message = UITextKeys.UI_ERROR_USERNAME_TOO_SHORT,
});
return;
}
if (username.Length > maxUsernameLength)
{
result.InvokeError(new ResponseUserRegisterMessage()
{
message = UITextKeys.UI_ERROR_USERNAME_TOO_LONG,
});
return;
}
if (string.IsNullOrEmpty(password) || password.Length < minPasswordLength)
{
result.InvokeError(new ResponseUserRegisterMessage()
{
message = UITextKeys.UI_ERROR_PASSWORD_TOO_SHORT,
});
return;
}
AsyncResponseData <EmptyMessage> createResp = await DbServiceClient.CreateUserLoginAsync(new CreateUserLoginReq()
{
Username = username,
Password = password,
Email = email,
});
if (!createResp.IsSuccess)
{
result.InvokeError(new ResponseUserRegisterMessage()
{
message = UITextKeys.UI_ERROR_INTERNAL_SERVER_ERROR,
});
return;
}
// Response
result.InvokeSuccess(new ResponseUserRegisterMessage());
#endif
}
public async UniTaskVoid HandleRequestCreateGuild(RequestHandlerData requestHandler, RequestCreateGuildMessage request, RequestProceedResultDelegate <ResponseCreateGuildMessage> result)
{
#if UNITY_STANDALONE && !CLIENT_BUILD
await UniTask.Yield();
IPlayerCharacterData playerCharacter;
if (!GameInstance.ServerUserHandlers.TryGetPlayerCharacter(requestHandler.ConnectionId, out playerCharacter))
{
result.InvokeError(new ResponseCreateGuildMessage()
{
message = UITextKeys.UI_ERROR_NOT_LOGGED_IN,
});
return;
}
ValidateGuildRequestResult validateResult = playerCharacter.CanCreateGuild(request.guildName);
if (!validateResult.IsSuccess)
{
result.InvokeError(new ResponseCreateGuildMessage()
{
message = validateResult.GameMessage,
});
return;
}
string guildName = request.guildName.Trim();
if (!NameValidating.ValidateGuildName(guildName))
{
result.InvokeError(new ResponseCreateGuildMessage()
{
message = UITextKeys.UI_ERROR_INVALID_GUILD_NAME
});
return;
}
AsyncResponseData <FindGuildNameResp> findGuildNameResp = await DbServiceClient.FindGuildNameAsync(new FindGuildNameReq()
{
GuildName = guildName,
});
if (!findGuildNameResp.IsSuccess)
{
result.InvokeError(new ResponseCreateGuildMessage()
{
message = UITextKeys.UI_ERROR_INTERNAL_SERVER_ERROR,
});
return;
}
if (findGuildNameResp.Response.FoundAmount > 0)
{
result.InvokeError(new ResponseCreateGuildMessage()
{
message = UITextKeys.UI_ERROR_GUILD_NAME_EXISTED,
});
return;
}
AsyncResponseData <GuildResp> createGuildResp = await DbServiceClient.CreateGuildAsync(new CreateGuildReq()
{
LeaderCharacterId = playerCharacter.Id,
GuildName = guildName,
});
if (!createGuildResp.IsSuccess)
{
result.InvokeError(new ResponseCreateGuildMessage()
{
message = UITextKeys.UI_ERROR_INTERNAL_SERVER_ERROR,
});
return;
}
// Update cache
GuildData guild = createGuildResp.Response.GuildData;
GameInstance.Singleton.SocialSystemSetting.DecreaseCreateGuildResource(playerCharacter);
GameInstance.ServerGuildHandlers.SetGuild(guild.id, guild);
playerCharacter.GuildId = guild.id;
playerCharacter.GuildRole = guild.GetMemberRole(playerCharacter.Id);
playerCharacter.SharedGuildExp = 0;
// Broadcast via chat server
if (ClusterClient.IsNetworkActive)
{
ClusterClient.SendCreateGuild(MMOMessageTypes.UpdateGuild, guild.id, guildName, playerCharacter.Id);
ClusterClient.SendAddSocialMember(MMOMessageTypes.UpdateGuildMember, guild.id, playerCharacter.Id, playerCharacter.CharacterName, playerCharacter.DataId, playerCharacter.Level);
}
GameInstance.ServerGameMessageHandlers.SendSetGuildData(requestHandler.ConnectionId, guild);
GameInstance.ServerGameMessageHandlers.SendAddGuildMembersToOne(requestHandler.ConnectionId, guild);
result.InvokeSuccess(new ResponseCreateGuildMessage());
#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.InvokeError(new ResponseChangeGuildLeaderMessage()
{
message = UITextKeys.UI_ERROR_NOT_LOGGED_IN,
});
return;
}
ValidateGuildRequestResult validateResult = GameInstance.ServerGuildHandlers.CanChangeGuildLeader(playerCharacter, request.memberId);
if (!validateResult.IsSuccess)
{
result.InvokeError(new ResponseChangeGuildLeaderMessage()
{
message = validateResult.GameMessage,
});
return;
}
// Save to database
AsyncResponseData <GuildResp> updateResp = await DbServiceClient.UpdateGuildLeaderAsync(new UpdateGuildLeaderReq()
{
GuildId = validateResult.GuildId,
LeaderCharacterId = request.memberId
});
if (!updateResp.IsSuccess)
{
result.InvokeError(new ResponseChangeGuildLeaderMessage()
{
message = validateResult.GameMessage,
});
return;
}
AsyncResponseData <GuildResp> updateRoleResp = await DbServiceClient.UpdateGuildMemberRoleAsync(new UpdateGuildMemberRoleReq()
{
GuildId = validateResult.GuildId,
MemberCharacterId = request.memberId,
GuildRole = validateResult.Guild.GetMemberRole(request.memberId)
});
if (!updateRoleResp.IsSuccess)
{
result.InvokeError(new ResponseChangeGuildLeaderMessage()
{
message = validateResult.GameMessage,
});
return;
}
// Update cache
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);
// Broadcast via chat server
if (ClusterClient.IsNetworkActive)
{
ClusterClient.SendChangeGuildLeader(MMOMessageTypes.UpdateGuild, validateResult.GuildId, request.memberId);
}
GameInstance.ServerGameMessageHandlers.SendSetGuildLeaderToMembers(validateResult.Guild);
GameInstance.ServerGameMessageHandlers.SendSetGuildMemberRoleToMembers(validateResult.Guild, request.memberId, 0);
result.InvokeSuccess(new ResponseChangeGuildLeaderMessage());
#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 = (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
}
public async UniTaskVoid HandleRequestCashShopBuy(
RequestHandlerData requestHandler, RequestCashShopBuyMessage request,
RequestProceedResultDelegate <ResponseCashShopBuyMessage> result)
{
#if UNITY_STANDALONE && !CLIENT_BUILD
IPlayerCharacterData playerCharacter;
if (!GameInstance.ServerUserHandlers.TryGetPlayerCharacter(requestHandler.ConnectionId, out playerCharacter))
{
result.InvokeError(new ResponseCashShopBuyMessage()
{
message = UITextKeys.UI_ERROR_NOT_LOGGED_IN,
});
return;
}
if (request.amount <= 0)
{
result.InvokeError(new ResponseCashShopBuyMessage()
{
message = UITextKeys.UI_ERROR_INVALID_DATA,
});
return;
}
CashShopItem cashShopItem;
if (!GameInstance.CashShopItems.TryGetValue(request.dataId, out cashShopItem))
{
result.InvokeError(new ResponseCashShopBuyMessage()
{
message = UITextKeys.UI_ERROR_ITEM_NOT_FOUND,
});
return;
}
if ((request.currencyType == CashShopItemCurrencyType.CASH && cashShopItem.SellPriceCash <= 0) ||
(request.currencyType == CashShopItemCurrencyType.GOLD && cashShopItem.SellPriceGold <= 0))
{
result.InvokeError(new ResponseCashShopBuyMessage()
{
message = UITextKeys.UI_ERROR_INVALID_ITEM_DATA,
});
return;
}
int characterGold = playerCharacter.Gold;
int userCash = playerCharacter.UserCash;
int priceGold = 0;
int priceCash = 0;
int changeCharacterGold = 0;
int changeUserCash = 0;
// Validate cash
if (request.currencyType == CashShopItemCurrencyType.CASH)
{
priceCash = cashShopItem.SellPriceCash * request.amount;
if (userCash < priceCash)
{
result.InvokeError(new ResponseCashShopBuyMessage()
{
message = UITextKeys.UI_ERROR_NOT_ENOUGH_CASH,
});
return;
}
changeUserCash -= priceCash;
}
// Validate gold
if (request.currencyType == CashShopItemCurrencyType.GOLD)
{
priceGold = cashShopItem.SellPriceGold * request.amount;
if (characterGold < priceGold)
{
result.InvokeError(new ResponseCashShopBuyMessage()
{
message = UITextKeys.UI_ERROR_NOT_ENOUGH_GOLD,
});
return;
}
changeCharacterGold -= priceGold;
}
// Increase gold
if (cashShopItem.ReceiveGold > 0)
{
changeCharacterGold += cashShopItem.ReceiveGold * request.amount;
}
// Increase items
List <RewardedItem> rewardItems = new List <RewardedItem>();
if (cashShopItem.ReceiveItems != null &&
cashShopItem.ReceiveItems.Length > 0)
{
foreach (ItemAmount itemAmount in cashShopItem.ReceiveItems)
{
for (int i = 0; i < request.amount; ++i)
{
rewardItems.Add(new RewardedItem()
{
item = itemAmount.item,
level = 1,
amount = itemAmount.amount,
randomSeed = (short)Random.Range(short.MinValue, short.MaxValue),
});
}
}
if (playerCharacter.IncreasingItemsWillOverwhelming(rewardItems))
{
result.InvokeError(new ResponseCashShopBuyMessage()
{
message = UITextKeys.UI_ERROR_WILL_OVERWHELMING,
});
return;
}
}
// Increase custom currencies
List <CharacterCurrency> customCurrencies = new List <CharacterCurrency>();
if (cashShopItem.ReceiveCurrencies != null &&
cashShopItem.ReceiveCurrencies.Length > 0)
{
foreach (CurrencyAmount currencyAmount in cashShopItem.ReceiveCurrencies)
{
for (int i = 0; i < request.amount; ++i)
{
customCurrencies.Add(CharacterCurrency.Create(currencyAmount.currency, currencyAmount.amount));
}
}
}
// Update currency
characterGold += changeCharacterGold;
if (request.currencyType == CashShopItemCurrencyType.CASH)
{
AsyncResponseData <CashResp> changeCashResp = await DbServiceClient.ChangeCashAsync(new ChangeCashReq()
{
UserId = playerCharacter.UserId,
ChangeAmount = -priceCash
});
if (!changeCashResp.IsSuccess)
{
result.InvokeError(new ResponseCashShopBuyMessage()
{
message = UITextKeys.UI_ERROR_INTERNAL_SERVER_ERROR,
});
return;
}
userCash = changeCashResp.Response.Cash;
}
playerCharacter.Gold = characterGold;
playerCharacter.UserCash = userCash;
playerCharacter.IncreaseItems(rewardItems);
playerCharacter.IncreaseCurrencies(customCurrencies);
playerCharacter.FillEmptySlots();
// Response to client
result.InvokeSuccess(new ResponseCashShopBuyMessage()
{
dataId = request.dataId,
rewardGold = cashShopItem.ReceiveGold,
rewardItems = rewardItems,
});
#endif
}
public async UniTaskVoid HandleRequestCloseStorage(RequestHandlerData requestHandler, EmptyMessage request, RequestProceedResultDelegate <ResponseCloseStorageMessage> result)
{
#if UNITY_STANDALONE && !CLIENT_BUILD
IPlayerCharacterData playerCharacter;
if (!GameInstance.ServerUserHandlers.TryGetPlayerCharacter(requestHandler.ConnectionId, out playerCharacter))
{
result.Invoke(AckResponseCode.Error, new ResponseCloseStorageMessage()
{
message = UITextKeys.UI_ERROR_NOT_LOGGED_IN,
});
return;
}
GameInstance.ServerStorageHandlers.CloseStorage(requestHandler.ConnectionId);
await UniTask.Yield();
#endif
}
public async UniTaskVoid HandleRequestMailList(RequestHandlerData requestHandler, RequestMailListMessage request, RequestProceedResultDelegate <ResponseMailListMessage> result)
{
#if UNITY_STANDALONE && !CLIENT_BUILD
List <MailListEntry> mails = new List <MailListEntry>();
IPlayerCharacterData playerCharacter;
if (GameInstance.ServerUserHandlers.TryGetPlayerCharacter(requestHandler.ConnectionId, out playerCharacter))
{
MailListResp resp = await DbServiceClient.MailListAsync(new MailListReq()
{
UserId = playerCharacter.UserId,
OnlyNewMails = request.onlyNewMails,
});
mails.AddRange(resp.List.MakeListFromRepeatedByteString <MailListEntry>());
}
result.Invoke(AckResponseCode.Success, new ResponseMailListMessage()
{
onlyNewMails = request.onlyNewMails,
mails = mails.ToArray(),
});
#endif
}
public async UniTaskVoid HandleRequestKickMemberFromParty(RequestHandlerData requestHandler, RequestKickMemberFromPartyMessage request, RequestProceedResultDelegate <ResponseKickMemberFromPartyMessage> result)
{
#if UNITY_STANDALONE && !CLIENT_BUILD
await UniTask.Yield();
IPlayerCharacterData playerCharacter;
if (!GameInstance.ServerUserHandlers.TryGetPlayerCharacter(requestHandler.ConnectionId, out playerCharacter))
{
result.Invoke(AckResponseCode.Error, new ResponseKickMemberFromPartyMessage()
{
message = UITextKeys.UI_ERROR_NOT_LOGGED_IN,
});
return;
}
ValidatePartyRequestResult validateResult = GameInstance.ServerPartyHandlers.CanKickMemberFromParty(playerCharacter, request.memberId);
if (!validateResult.IsSuccess)
{
result.Invoke(AckResponseCode.Error, new ResponseKickMemberFromPartyMessage()
{
message = validateResult.GameMessage,
});
return;
}
IPlayerCharacterData memberCharacter;
long memberConnectionId;
if (GameInstance.ServerUserHandlers.TryGetPlayerCharacterById(request.memberId, out memberCharacter) &&
GameInstance.ServerUserHandlers.TryGetConnectionId(request.memberId, out memberConnectionId))
{
memberCharacter.ClearParty();
GameInstance.ServerGameMessageHandlers.SendClearPartyData(memberConnectionId, validateResult.PartyId);
}
validateResult.Party.RemoveMember(request.memberId);
GameInstance.ServerPartyHandlers.SetParty(validateResult.PartyId, validateResult.Party);
// Save to database
_ = DbServiceClient.ClearCharacterPartyAsync(new ClearCharacterPartyReq()
{
CharacterId = request.memberId
});
// Broadcast via chat server
if (ChatNetworkManager.IsClientConnected)
{
ChatNetworkManager.SendRemoveSocialMember(null, MMOMessageTypes.UpdatePartyMember, validateResult.PartyId, request.memberId);
}
GameInstance.ServerGameMessageHandlers.SendRemovePartyMemberToMembers(validateResult.Party, request.memberId);
result.Invoke(AckResponseCode.Success, new ResponseKickMemberFromPartyMessage());
#endif
}
public async UniTaskVoid HandleRequestLeaveParty(RequestHandlerData requestHandler, EmptyMessage request, RequestProceedResultDelegate <ResponseLeavePartyMessage> result)
{
#if UNITY_STANDALONE && !CLIENT_BUILD
await UniTask.Yield();
IPlayerCharacterData playerCharacter;
if (!GameInstance.ServerUserHandlers.TryGetPlayerCharacter(requestHandler.ConnectionId, out playerCharacter))
{
result.Invoke(AckResponseCode.Error, new ResponseLeavePartyMessage()
{
message = UITextKeys.UI_ERROR_NOT_LOGGED_IN,
});
return;
}
ValidatePartyRequestResult validateResult = GameInstance.ServerPartyHandlers.CanLeaveParty(playerCharacter);
if (!validateResult.IsSuccess)
{
result.Invoke(AckResponseCode.Error, new ResponseLeavePartyMessage()
{
message = validateResult.GameMessage,
});
return;
}
// If it is leader kick all members and terminate party
if (validateResult.Party.IsLeader(playerCharacter.Id))
{
IPlayerCharacterData memberCharacter;
long memberConnectionId;
foreach (string memberId in validateResult.Party.GetMemberIds())
{
if (GameInstance.ServerUserHandlers.TryGetPlayerCharacterById(memberId, out memberCharacter) &&
GameInstance.ServerUserHandlers.TryGetConnectionId(memberId, out memberConnectionId))
{
memberCharacter.ClearParty();
GameInstance.ServerGameMessageHandlers.SendClearPartyData(memberConnectionId, validateResult.PartyId);
}
// Save to database
_ = DbServiceClient.ClearCharacterPartyAsync(new ClearCharacterPartyReq()
{
CharacterId = memberId
});
// Broadcast via chat server
if (ChatNetworkManager.IsClientConnected)
{
ChatNetworkManager.SendRemoveSocialMember(null, MMOMessageTypes.UpdatePartyMember, validateResult.PartyId, memberId);
}
}
GameInstance.ServerPartyHandlers.RemoveParty(validateResult.PartyId);
// Save to database
_ = DbServiceClient.DeletePartyAsync(new DeletePartyReq()
{
PartyId = validateResult.PartyId
});
// Broadcast via chat server
if (ChatNetworkManager.IsClientConnected)
{
ChatNetworkManager.SendPartyTerminate(null, MMOMessageTypes.UpdateParty, validateResult.PartyId);
}
}
else
{
playerCharacter.ClearParty();
validateResult.Party.RemoveMember(playerCharacter.Id);
GameInstance.ServerPartyHandlers.SetParty(validateResult.PartyId, validateResult.Party);
GameInstance.ServerGameMessageHandlers.SendRemovePartyMemberToMembers(validateResult.Party, playerCharacter.Id);
GameInstance.ServerGameMessageHandlers.SendClearPartyData(requestHandler.ConnectionId, validateResult.PartyId);
// Save to database
_ = DbServiceClient.ClearCharacterPartyAsync(new ClearCharacterPartyReq()
{
CharacterId = playerCharacter.Id
});
// Broadcast via chat server
if (ChatNetworkManager.IsClientConnected)
{
ChatNetworkManager.SendRemoveSocialMember(null, MMOMessageTypes.UpdatePartyMember, validateResult.PartyId, playerCharacter.Id);
}
}
result.Invoke(AckResponseCode.Success, new ResponseLeavePartyMessage());
#endif
}
public async UniTaskVoid HandleRequestChangePartySetting(RequestHandlerData requestHandler, RequestChangePartySettingMessage request, RequestProceedResultDelegate <ResponseChangePartySettingMessage> result)
{
#if UNITY_STANDALONE && !CLIENT_BUILD
await UniTask.Yield();
IPlayerCharacterData playerCharacter;
if (!GameInstance.ServerUserHandlers.TryGetPlayerCharacter(requestHandler.ConnectionId, out playerCharacter))
{
result.Invoke(AckResponseCode.Error, new ResponseChangePartySettingMessage()
{
message = UITextKeys.UI_ERROR_NOT_LOGGED_IN,
});
return;
}
ValidatePartyRequestResult validateResult = GameInstance.ServerPartyHandlers.CanChangePartySetting(playerCharacter);
if (!validateResult.IsSuccess)
{
result.Invoke(AckResponseCode.Error, new ResponseChangePartySettingMessage()
{
message = validateResult.GameMessage,
});
return;
}
validateResult.Party.Setting(request.shareExp, request.shareItem);
GameInstance.ServerPartyHandlers.SetParty(validateResult.PartyId, validateResult.Party);
// Save to database
_ = DbServiceClient.UpdatePartyAsync(new UpdatePartyReq()
{
PartyId = validateResult.PartyId,
ShareExp = request.shareExp,
ShareItem = request.shareItem
});
// Broadcast via chat server
if (ChatNetworkManager.IsClientConnected)
{
ChatNetworkManager.SendPartySetting(null, MMOMessageTypes.UpdateParty, validateResult.PartyId, request.shareExp, request.shareItem);
}
GameInstance.ServerGameMessageHandlers.SendSetPartySettingToMembers(validateResult.Party);
result.Invoke(AckResponseCode.Success, new ResponseChangePartySettingMessage());
#endif
}
public async UniTaskVoid HandleRequestAcceptPartyInvitation(RequestHandlerData requestHandler, RequestAcceptPartyInvitationMessage request, RequestProceedResultDelegate <ResponseAcceptPartyInvitationMessage> result)
{
#if UNITY_STANDALONE && !CLIENT_BUILD
await UniTask.Yield();
BasePlayerCharacterEntity playerCharacter;
if (!GameInstance.ServerUserHandlers.TryGetPlayerCharacter(requestHandler.ConnectionId, out playerCharacter))
{
result.Invoke(AckResponseCode.Error, new ResponseAcceptPartyInvitationMessage()
{
message = UITextKeys.UI_ERROR_NOT_LOGGED_IN,
});
return;
}
ValidatePartyRequestResult validateResult = GameInstance.ServerPartyHandlers.CanAcceptPartyInvitation(request.partyId, playerCharacter);
if (!validateResult.IsSuccess)
{
result.Invoke(AckResponseCode.Error, new ResponseAcceptPartyInvitationMessage()
{
message = validateResult.GameMessage,
});
return;
}
playerCharacter.PartyId = request.partyId;
validateResult.Party.AddMember(playerCharacter);
GameInstance.ServerPartyHandlers.SetParty(request.partyId, validateResult.Party);
GameInstance.ServerPartyHandlers.RemovePartyInvitation(request.partyId, playerCharacter.Id);
// Save to database
_ = DbServiceClient.UpdateCharacterPartyAsync(new UpdateCharacterPartyReq()
{
SocialCharacterData = SocialCharacterData.Create(playerCharacter),
PartyId = request.partyId
});
// Broadcast via chat server
if (ChatNetworkManager.IsClientConnected)
{
ChatNetworkManager.SendAddSocialMember(null, MMOMessageTypes.UpdatePartyMember, request.partyId, playerCharacter.Id, playerCharacter.CharacterName, playerCharacter.DataId, playerCharacter.Level);
}
GameInstance.ServerGameMessageHandlers.SendSetPartyData(requestHandler.ConnectionId, validateResult.Party);
GameInstance.ServerGameMessageHandlers.SendAddPartyMembersToOne(requestHandler.ConnectionId, validateResult.Party);
GameInstance.ServerGameMessageHandlers.SendAddPartyMemberToMembers(validateResult.Party, playerCharacter.Id, playerCharacter.CharacterName, playerCharacter.DataId, playerCharacter.Level);
result.Invoke(AckResponseCode.Success, new ResponseAcceptPartyInvitationMessage()
{
message = UITextKeys.UI_PARTY_INVITATION_ACCEPTED,
});
#endif
}
public async UniTaskVoid HandleRequestCreateParty(RequestHandlerData requestHandler, RequestCreatePartyMessage request, RequestProceedResultDelegate <ResponseCreatePartyMessage> result)
{
#if UNITY_STANDALONE && !CLIENT_BUILD
await UniTask.Yield();
IPlayerCharacterData playerCharacter;
if (!GameInstance.ServerUserHandlers.TryGetPlayerCharacter(requestHandler.ConnectionId, out playerCharacter))
{
result.Invoke(AckResponseCode.Error, new ResponseCreatePartyMessage()
{
message = UITextKeys.UI_ERROR_NOT_LOGGED_IN,
});
return;
}
ValidatePartyRequestResult validateResult = playerCharacter.CanCreateParty();
if (!validateResult.IsSuccess)
{
result.Invoke(AckResponseCode.Error, new ResponseCreatePartyMessage()
{
message = validateResult.GameMessage,
});
return;
}
PartyResp createPartyResp = await DbServiceClient.CreatePartyAsync(new CreatePartyReq()
{
LeaderCharacterId = playerCharacter.Id,
ShareExp = request.shareExp,
ShareItem = request.shareItem
});
PartyData party = createPartyResp.PartyData;
GameInstance.ServerPartyHandlers.SetParty(party.id, party);
playerCharacter.PartyId = party.id;
// Broadcast via chat server
if (ChatNetworkManager.IsClientConnected)
{
ChatNetworkManager.SendCreateParty(null, MMOMessageTypes.UpdateParty, party.id, party.shareExp, party.shareItem, playerCharacter.Id);
ChatNetworkManager.SendAddSocialMember(null, MMOMessageTypes.UpdatePartyMember, party.id, playerCharacter.Id, playerCharacter.CharacterName, playerCharacter.DataId, playerCharacter.Level);
}
GameInstance.ServerGameMessageHandlers.SendSetPartyData(requestHandler.ConnectionId, party);
GameInstance.ServerGameMessageHandlers.SendAddPartyMembersToOne(requestHandler.ConnectionId, party);
result.Invoke(AckResponseCode.Success, new ResponseCreatePartyMessage());
#endif
}
protected async UniTaskVoid HandleRequestUserLogin(
RequestHandlerData requestHandler,
RequestUserLoginMessage request,
RequestProceedResultDelegate <ResponseUserLoginMessage> result)
{
#if UNITY_STANDALONE && !CLIENT_BUILD
if (disableDefaultLogin)
{
result.InvokeError(new ResponseUserLoginMessage()
{
message = UITextKeys.UI_ERROR_SERVICE_NOT_AVAILABLE,
});
return;
}
long connectionId = requestHandler.ConnectionId;
AsyncResponseData <ValidateUserLoginResp> validateUserLoginResp = await DbServiceClient.ValidateUserLoginAsync(new ValidateUserLoginReq()
{
Username = request.username,
Password = request.password
});
if (!validateUserLoginResp.IsSuccess)
{
result.InvokeError(new ResponseUserLoginMessage()
{
message = UITextKeys.UI_ERROR_INTERNAL_SERVER_ERROR,
});
return;
}
string userId = validateUserLoginResp.Response.UserId;
string accessToken = string.Empty;
long unbanTime = 0;
if (string.IsNullOrEmpty(userId))
{
result.InvokeError(new ResponseUserLoginMessage()
{
message = UITextKeys.UI_ERROR_INVALID_USERNAME_OR_PASSWORD,
});
return;
}
if (userPeersByUserId.ContainsKey(userId) || MapContainsUser(userId))
{
result.InvokeError(new ResponseUserLoginMessage()
{
message = UITextKeys.UI_ERROR_ALREADY_LOGGED_IN,
});
return;
}
bool emailVerified = true;
if (requireEmailVerification)
{
AsyncResponseData <ValidateEmailVerificationResp> validateEmailVerificationResp = await DbServiceClient.ValidateEmailVerificationAsync(new ValidateEmailVerificationReq()
{
UserId = userId
});
if (!validateEmailVerificationResp.IsSuccess)
{
result.InvokeError(new ResponseUserLoginMessage()
{
message = UITextKeys.UI_ERROR_INTERNAL_SERVER_ERROR,
});
return;
}
emailVerified = validateEmailVerificationResp.Response.IsPass;
}
AsyncResponseData <GetUserUnbanTimeResp> unbanTimeResp = await DbServiceClient.GetUserUnbanTimeAsync(new GetUserUnbanTimeReq()
{
UserId = userId
});
if (!unbanTimeResp.IsSuccess)
{
result.InvokeError(new ResponseUserLoginMessage()
{
message = UITextKeys.UI_ERROR_INTERNAL_SERVER_ERROR,
});
return;
}
unbanTime = unbanTimeResp.Response.UnbanTime;
if (unbanTime > System.DateTimeOffset.UtcNow.ToUnixTimeSeconds())
{
result.InvokeError(new ResponseUserLoginMessage()
{
message = UITextKeys.UI_ERROR_USER_BANNED,
});
return;
}
if (!emailVerified)
{
result.InvokeError(new ResponseUserLoginMessage()
{
message = UITextKeys.UI_ERROR_EMAIL_NOT_VERIFIED,
});
return;
}
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;
AsyncResponseData <EmptyMessage> updateAccessTokenResp = await DbServiceClient.UpdateAccessTokenAsync(new UpdateAccessTokenReq()
{
UserId = userId,
AccessToken = accessToken
});
if (!updateAccessTokenResp.IsSuccess)
{
result.InvokeError(new ResponseUserLoginMessage()
{
message = UITextKeys.UI_ERROR_INTERNAL_SERVER_ERROR,
});
return;
}
// Response
result.InvokeSuccess(new ResponseUserLoginMessage()
{
userId = userId,
accessToken = accessToken,
unbanTime = unbanTime,
});
#endif
}
protected async UniTaskVoid HandleRequestValidateAccessToken(
RequestHandlerData requestHandler,
RequestValidateAccessTokenMessage request,
RequestProceedResultDelegate <ResponseValidateAccessTokenMessage> result)
{
#if UNITY_STANDALONE && !CLIENT_BUILD
long connectionId = requestHandler.ConnectionId;
string userId = request.userId;
string accessToken = request.accessToken;
long unbanTime = 0;
AsyncResponseData <ValidateAccessTokenResp> validateAccessTokenResp = await DbServiceClient.ValidateAccessTokenAsync(new ValidateAccessTokenReq()
{
UserId = userId,
AccessToken = accessToken
});
if (!validateAccessTokenResp.IsSuccess)
{
result.InvokeError(new ResponseValidateAccessTokenMessage()
{
message = UITextKeys.UI_ERROR_INTERNAL_SERVER_ERROR,
});
return;
}
if (!validateAccessTokenResp.Response.IsPass)
{
result.InvokeError(new ResponseValidateAccessTokenMessage()
{
message = UITextKeys.UI_ERROR_INVALID_USER_TOKEN,
});
return;
}
AsyncResponseData <GetUserUnbanTimeResp> unbanTimeResp = await DbServiceClient.GetUserUnbanTimeAsync(new GetUserUnbanTimeReq()
{
UserId = userId
});
if (!unbanTimeResp.IsSuccess)
{
result.InvokeError(new ResponseValidateAccessTokenMessage()
{
message = UITextKeys.UI_ERROR_INTERNAL_SERVER_ERROR,
});
return;
}
unbanTime = unbanTimeResp.Response.UnbanTime;
if (unbanTime > System.DateTimeOffset.UtcNow.ToUnixTimeSeconds())
{
result.InvokeError(new ResponseValidateAccessTokenMessage()
{
message = UITextKeys.UI_ERROR_USER_BANNED,
});
return;
}
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;
AsyncResponseData <EmptyMessage> updateAccessTokenResp = await DbServiceClient.UpdateAccessTokenAsync(new UpdateAccessTokenReq()
{
UserId = userPeerInfo.userId,
AccessToken = accessToken
});
if (!updateAccessTokenResp.IsSuccess)
{
result.InvokeError(new ResponseValidateAccessTokenMessage()
{
message = UITextKeys.UI_ERROR_INTERNAL_SERVER_ERROR,
});
return;
}
// Response
result.InvokeSuccess(new ResponseValidateAccessTokenMessage()
{
userId = userId,
accessToken = accessToken,
});
#endif
}
protected async UniTaskVoid HandleRequestCreateCharacter(
RequestHandlerData requestHandler,
RequestCreateCharacterMessage request,
RequestProceedResultDelegate <ResponseCreateCharacterMessage> result)
{
#if UNITY_STANDALONE && !CLIENT_BUILD
long connectionId = requestHandler.ConnectionId;
NetDataReader reader = requestHandler.Reader;
string characterName = request.characterName.Trim();
int dataId = request.dataId;
int entityId = request.entityId;
int factionId = request.factionId;
CentralUserPeerInfo userPeerInfo;
if (!NameValidating.ValidateCharacterName(characterName))
{
result.InvokeError(new ResponseCreateCharacterMessage()
{
message = UITextKeys.UI_ERROR_INVALID_CHARACTER_NAME
});
return;
}
// Validate character name
AsyncResponseData <FindCharacterNameResp> findCharacterNameResp = await DbServiceClient.FindCharacterNameAsync(new FindCharacterNameReq()
{
CharacterName = characterName
});
if (!findCharacterNameResp.IsSuccess)
{
result.InvokeError(new ResponseCreateCharacterMessage()
{
message = UITextKeys.UI_ERROR_INTERNAL_SERVER_ERROR,
});
return;
}
if (findCharacterNameResp.Response.FoundAmount > 0)
{
result.InvokeError(new ResponseCreateCharacterMessage()
{
message = UITextKeys.UI_ERROR_CHARACTER_NAME_EXISTED,
});
return;
}
if (!userPeers.TryGetValue(connectionId, out userPeerInfo))
{
result.InvokeError(new ResponseCreateCharacterMessage()
{
message = UITextKeys.UI_ERROR_NOT_LOGGED_IN,
});
return;
}
if (string.IsNullOrEmpty(characterName) || characterName.Length < minCharacterNameLength)
{
result.InvokeError(new ResponseCreateCharacterMessage()
{
message = UITextKeys.UI_ERROR_CHARACTER_NAME_TOO_SHORT,
});
return;
}
if (characterName.Length > maxCharacterNameLength)
{
result.InvokeError(new ResponseCreateCharacterMessage()
{
message = UITextKeys.UI_ERROR_CHARACTER_NAME_TOO_LONG,
});
return;
}
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
result.InvokeError(new ResponseCreateCharacterMessage()
{
message = UITextKeys.UI_ERROR_INVALID_DATA,
});
return;
}
string characterId = GenericUtils.GetUniqueId();
PlayerCharacterData characterData = new PlayerCharacterData();
characterData.Id = characterId;
characterData.SetNewPlayerCharacterData(characterName, dataId, entityId);
characterData.FactionId = factionId;
DeserializeCreateCharacterExtra(characterData, reader);
AsyncResponseData <CharacterResp> createResp = await DbServiceClient.CreateCharacterAsync(new CreateCharacterReq()
{
UserId = userPeerInfo.userId,
CharacterData = characterData,
});
if (!createResp.IsSuccess)
{
result.InvokeError(new ResponseCreateCharacterMessage()
{
message = UITextKeys.UI_ERROR_INTERNAL_SERVER_ERROR,
});
return;
}
// Response
result.InvokeSuccess(new ResponseCreateCharacterMessage());
#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
}
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.Invoke(AckResponseCode.Error, new ResponseOpenStorageMessage()
{
message = UITextKeys.UI_ERROR_CANNOT_ACCESS_STORAGE,
});
return;
}
IPlayerCharacterData playerCharacter;
if (!GameInstance.ServerUserHandlers.TryGetPlayerCharacter(requestHandler.ConnectionId, out playerCharacter))
{
result.Invoke(AckResponseCode.Error, new ResponseOpenStorageMessage()
{
message = UITextKeys.UI_ERROR_NOT_LOGGED_IN,
});
return;
}
StorageId storageId;
if (!playerCharacter.GetStorageId(request.storageType, 0, out storageId))
{
result.Invoke(AckResponseCode.Error, new ResponseOpenStorageMessage()
{
message = UITextKeys.UI_ERROR_STORAGE_NOT_FOUND,
});
return;
}
GameInstance.ServerStorageHandlers.OpenStorage(requestHandler.ConnectionId, playerCharacter, storageId);
await UniTask.Yield();
#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 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 = (EStorageType)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 = DatabaseServiceUtils.MakeListFromRepeatedByteString <CharacterItem>(resp.InventoryItemItems);
GameInstance.ServerStorageHandlers.SetStorageItems(storageId, DatabaseServiceUtils.MakeListFromRepeatedByteString <CharacterItem>(resp.StorageCharacterItems));
GameInstance.ServerStorageHandlers.NotifyStorageItemsUpdated(request.storageType, request.storageOwnerId);
// Success
result.Invoke(AckResponseCode.Success, new ResponseMoveItemFromStorageMessage());
#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 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 = DatabaseServiceUtils.ToByteString(mail),
});
UITextKeys message = (UITextKeys)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 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 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.FromByteString <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 = (UITextKeys)resp.Error;
result.Invoke(
message == UITextKeys.NONE ? AckResponseCode.Success : AckResponseCode.Error,
new ResponseClaimMailItemsMessage()
{
message = message,
mail = resp.Mail.FromByteString <Mail>(),
});
}
else
{
result.Invoke(AckResponseCode.Error, new ResponseClaimMailItemsMessage()
{
message = UITextKeys.UI_ERROR_SERVICE_NOT_AVAILABLE,
});
}
#endif
}
public async UniTaskVoid HandleRequestMailNotification(RequestHandlerData requestHandler, EmptyMessage request, RequestProceedResultDelegate <ResponseMailNotificationMessage> result)
{
#if UNITY_STANDALONE && !CLIENT_BUILD
int notificationCount = 0;
string userId;
if (GameInstance.ServerUserHandlers.TryGetUserId(requestHandler.ConnectionId, out userId))
{
AsyncResponseData <GetMailNotificationResp> resp = await DbServiceClient.GetMailNotificationAsync(new GetMailNotificationReq()
{
UserId = userId,
});
if (resp.IsSuccess)
{
notificationCount = resp.Response.NotificationCount;
}
}
result.Invoke(AckResponseCode.Success, new ResponseMailNotificationMessage()
{
notificationCount = notificationCount,
});
#endif
}
public async UniTaskVoid HandleRequestSendGuildInvitation(RequestHandlerData requestHandler, RequestSendGuildInvitationMessage request, RequestProceedResultDelegate <ResponseSendGuildInvitationMessage> result)
{
#if UNITY_STANDALONE && !CLIENT_BUILD
await UniTask.Yield();
BasePlayerCharacterEntity playerCharacter;
if (!GameInstance.ServerUserHandlers.TryGetPlayerCharacter(requestHandler.ConnectionId, out playerCharacter))
{
result.InvokeError(new ResponseSendGuildInvitationMessage()
{
message = UITextKeys.UI_ERROR_NOT_LOGGED_IN,
});
return;
}
BasePlayerCharacterEntity inviteeCharacter;
if (!GameInstance.ServerUserHandlers.TryGetPlayerCharacterById(request.inviteeId, out inviteeCharacter))
{
result.InvokeError(new ResponseSendGuildInvitationMessage()
{
message = UITextKeys.UI_ERROR_CHARACTER_NOT_FOUND,
});
return;
}
ValidateGuildRequestResult validateResult = GameInstance.ServerGuildHandlers.CanSendGuildInvitation(playerCharacter, inviteeCharacter);
if (!validateResult.IsSuccess)
{
result.InvokeError(new ResponseSendGuildInvitationMessage()
{
message = validateResult.GameMessage,
});
return;
}
GameInstance.ServerGuildHandlers.AppendGuildInvitation(playerCharacter.GuildId, request.inviteeId);
GameInstance.ServerGameMessageHandlers.SendNotifyGuildInvitation(inviteeCharacter.ConnectionId, new GuildInvitationData()
{
InviterId = playerCharacter.Id,
InviterName = playerCharacter.CharacterName,
InviterLevel = playerCharacter.Level,
GuildId = validateResult.GuildId,
GuildName = validateResult.Guild.guildName,
GuildLevel = validateResult.Guild.level,
});
result.InvokeSuccess(new ResponseSendGuildInvitationMessage());
#endif
}
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 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
}
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 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 UniTaskVoid HandleRequestAppServerRegister(
RequestHandlerData requestHandler,
RequestAppServerRegisterMessage request,
RequestProceedResultDelegate <ResponseAppServerRegisterMessage> result)
{
long connectionId = requestHandler.ConnectionId;
ResponseAppServerRegisterMessage.Error error = ResponseAppServerRegisterMessage.Error.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
{
error = ResponseAppServerRegisterMessage.Error.MapAlreadyExisted;
if (LogInfo)
{
Logging.Log(LogTag, "Register Map Server Failed: [" + connectionId + "] [" + sceneName + "] [" + error + "]");
}
}
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
{
error = ResponseAppServerRegisterMessage.Error.EventAlreadyExisted;
if (LogInfo)
{
Logging.Log(LogTag, "Register Instance Map Server Failed: [" + connectionId + "] [" + instanceId + "] [" + error + "]");
}
}
break;
case CentralServerPeerType.Chat:
chatServerPeers[connectionId] = peerInfo;
// Send chat peer info to map servers
responseAppServerAddressMessage = new ResponseAppServerAddressMessage()
{
error = ResponseAppServerAddressMessage.Error.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
{
error = ResponseAppServerRegisterMessage.Error.InvalidHash;
if (LogInfo)
{
Logging.Log(LogTag, "Register Server Failed: [" + connectionId + "] [" + error + "]");
}
}
// Response
result.Invoke(
error == ResponseAppServerRegisterMessage.Error.None ? AckResponseCode.Success : AckResponseCode.Error,
new ResponseAppServerRegisterMessage()
{
error = error,
});
return(default);
