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
}
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 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,
});
}
protected override async UniTask PreSpawnEntities()
{
// Spawn buildings
if (!IsInstanceMap())
{
// Load buildings
// Don't load buildings if it's instance map
BuildingsResp resp = await DbServiceClient.ReadBuildingsAsync(new ReadBuildingsReq()
{
MapName = CurrentMapInfo.Id,
});
HashSet <StorageId> storageIds = new HashSet <StorageId>();
List <BuildingSaveData> buildings = resp.List;
BuildingEntity buildingEntity;
foreach (BuildingSaveData building in buildings)
{
buildingEntity = CreateBuildingEntity(building, true);
if (buildingEntity is StorageEntity)
{
storageIds.Add(new StorageId(StorageType.Building, (buildingEntity as StorageEntity).Id));
}
}
List <UniTask> tasks = new List <UniTask>();
// Load building storage
foreach (StorageId storageId in storageIds)
{
tasks.Add(LoadStorageRoutine(storageId));
}
// Wait until all building storage loaded
await UniTask.WhenAll(tasks);
}
}
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 async UniTaskVoid HandleRequestDeleteCharacterRoutine(LiteNetLibMessageHandler messageHandler)
{
long connectionId = messageHandler.connectionId;
RequestDeleteCharacterMessage message = messageHandler.ReadMessage <RequestDeleteCharacterMessage>();
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 = message.characterId
});
}
ResponseDeleteCharacterMessage responseMessage = new ResponseDeleteCharacterMessage();
responseMessage.ackId = message.ackId;
responseMessage.responseCode = error == ResponseDeleteCharacterMessage.Error.None ? AckResponseCode.Success : AckResponseCode.Error;
responseMessage.error = error;
ServerSendResponse(connectionId, MMOMessageTypes.ResponseDeleteCharacter, responseMessage);
}
public async UniTaskVoid IncreaseGuildExp(IPlayerCharacterData playerCharacter, int exp)
{
#if UNITY_STANDALONE && !CLIENT_BUILD
ValidateGuildRequestResult validateResult = this.CanIncreaseGuildExp(playerCharacter, exp);
if (!validateResult.IsSuccess)
{
return;
}
AsyncResponseData <GuildResp> resp = await DbServiceClient.IncreaseGuildExpAsync(new IncreaseGuildExpReq()
{
GuildId = validateResult.GuildId,
Exp = exp,
});
if (!resp.IsSuccess)
{
return;
}
GuildData guild = resp.Response.GuildData;
SetGuild(validateResult.GuildId, guild);
// Broadcast via chat server
if (ClusterClient.IsNetworkActive)
{
ClusterClient.SendSetGuildLevelExpSkillPoint(MMOMessageTypes.UpdateGuild, guild.id, guild.level, guild.exp, guild.skillPoint);
}
GameInstance.ServerGameMessageHandlers.SendSetGuildLevelExpSkillPointToMembers(guild);
#endif
}
private async UniTaskVoid HandleRequestCharactersRoutine(LiteNetLibMessageHandler messageHandler)
{
long connectionId = messageHandler.connectionId;
RequestCharactersMessage message = messageHandler.ReadMessage <RequestCharactersMessage>();
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);
}
ResponseCharactersMessage responseMessage = new ResponseCharactersMessage();
responseMessage.ackId = message.ackId;
responseMessage.responseCode = error == ResponseCharactersMessage.Error.None ? AckResponseCode.Success : AckResponseCode.Error;
responseMessage.error = error;
responseMessage.characters = characters;
ServerSendResponse(connectionId, MMOMessageTypes.ResponseCharacters, responseMessage);
}
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)
{
#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
}
/// <summary>
/// Adds the loot bag items to the specified loot bag storage.
/// </summary>
/// <param name="storageId">loot bag storage ID</param>
/// <param name="addingItems">items to add to loot bag</param>
/// <returns>true if successful, false otherwise</returns>
public async UniTask <bool> AddLootBagItems(StorageId storageId, List <CharacterItem> lootItems)
{
#if UNITY_STANDALONE && !CLIENT_BUILD
// Attempt to read from storage first. This registers it and adds it to cache.
ReadStorageItemsReq rsir = new ReadStorageItemsReq();
rsir.StorageType = storageId.storageType;
rsir.StorageOwnerId = storageId.storageOwnerId;
ReadStorageItemsResp rsiresp = await DbServiceClient.ReadStorageItemsAsync(rsir);
foreach (CharacterItem lootItem in lootItems)
{
Storage storge = GetStorage(storageId, out _);
IncreaseStorageItemsReq req = new IncreaseStorageItemsReq();
req.StorageType = storageId.storageType;
req.StorageOwnerId = storageId.storageOwnerId;
req.WeightLimit = storge.weightLimit;
req.SlotLimit = storge.slotLimit;
req.Item = lootItem;
IncreaseStorageItemsResp resp = await DbServiceClient.IncreaseStorageItemsAsync(req);
if (UITextKeys.NONE != resp.Error)
{
return(false);
}
SetStorageItems(storageId, resp.StorageCharacterItems);
}
return(true);
#else
return(false);
#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 = charactersResp.List;
}
// Response
result.Invoke(
message == UITextKeys.NONE ? AckResponseCode.Success : AckResponseCode.Error,
new ResponseCharactersMessage()
{
message = message,
characters = characters,
});
#endif
}
protected async override void OnDestroy()
{
// Save immediately
#if UNITY_STANDALONE && !CLIENT_BUILD
if (IsServer)
{
foreach (BasePlayerCharacterEntity playerCharacter in ServerUserHandlers.GetPlayerCharacters())
{
if (playerCharacter == null)
{
continue;
}
await DbServiceClient.UpdateCharacterAsync(new UpdateCharacterReq()
{
CharacterData = playerCharacter.CloneTo(new PlayerCharacterData())
});
}
string mapName = CurrentMapInfo.Id;
foreach (BuildingEntity buildingEntity in ServerBuildingHandlers.GetBuildings())
{
if (buildingEntity == null)
{
continue;
}
await DbServiceClient.UpdateBuildingAsync(new UpdateBuildingReq()
{
MapName = mapName,
BuildingData = buildingEntity.CloneTo(new BuildingSaveData())
});
}
}
#endif
base.OnDestroy();
}
private async UniTaskVoid HandleRequestCreateCharacterRoutine(LiteNetLibMessageHandler messageHandler)
{
long connectionId = messageHandler.connectionId;
RequestCreateCharacterMessage message = messageHandler.ReadMessage <RequestCreateCharacterMessage>();
ResponseCreateCharacterMessage.Error error = ResponseCreateCharacterMessage.Error.None;
string characterName = message.characterName;
int dataId = message.dataId;
int entityId = message.entityId;
int factionId = message.factionId;
CentralUserPeerInfo userPeerInfo;
FindCharacterNameResp findCharacterNameResp = await DbServiceClient.FindCharacterNameAsync(new FindCharacterNameReq()
{
CharacterName = characterName
});
if (findCharacterNameResp.FoundAmount > 0)
{
error = ResponseCreateCharacterMessage.Error.CharacterNameAlreadyExisted;
}
else if (!userPeers.TryGetValue(connectionId, out userPeerInfo))
{
error = ResponseCreateCharacterMessage.Error.NotLoggedin;
}
else if (string.IsNullOrEmpty(characterName) || characterName.Length < minCharacterNameLength)
{
error = ResponseCreateCharacterMessage.Error.TooShortCharacterName;
}
else if (characterName.Length > maxCharacterNameLength)
{
error = ResponseCreateCharacterMessage.Error.TooLongCharacterName;
}
else if (!GameInstance.PlayerCharacters.ContainsKey(dataId) ||
!GameInstance.PlayerCharacterEntities.ContainsKey(entityId) ||
(GameInstance.Factions.Count > 0 && !GameInstance.Factions.ContainsKey(factionId)))
{
// If there is factions, it must have faction with the id stored in faction dictionary
error = ResponseCreateCharacterMessage.Error.InvalidData;
}
else
{
string characterId = GenericUtils.GetUniqueId();
PlayerCharacterData characterData = new PlayerCharacterData();
characterData.Id = characterId;
characterData.SetNewPlayerCharacterData(characterName, dataId, entityId);
characterData.FactionId = factionId;
DeserializeCreateCharacterExtra(characterData, messageHandler.reader);
await DbServiceClient.CreateCharacterAsync(new CreateCharacterReq()
{
UserId = userPeerInfo.userId,
CharacterData = characterData.ToByteString()
});
}
ResponseCreateCharacterMessage responseMessage = new ResponseCreateCharacterMessage();
responseMessage.ackId = message.ackId;
responseMessage.responseCode = error == ResponseCreateCharacterMessage.Error.None ? AckResponseCode.Success : AckResponseCode.Error;
responseMessage.error = error;
ServerSendResponse(connectionId, MMOMessageTypes.ResponseCreateCharacter, responseMessage);
}
public ActionResult Update(wniosekWithDecyzja wwd)
{
using (DbServiceClient client = new DbServiceClient())
{
client.EditWniosek(wwd.Id_wniosek, wwd.Klient_skrot, wwd.Klient_skrot, wwd.Kwota_kredytu_brutto, wwd.Wnioskowana_kwota_kredytu, wwd.Data_rejestracji_wniosku);
}
return(RedirectToAction("ListaWnioskow", new { data1 = data1, data2 = data2 }));
}
private async UniTask DestroyBuildingEntityRoutine(string id)
{
await DbServiceClient.DeleteBuildingAsync(new DeleteBuildingReq()
{
MapName = Assets.onlineScene.SceneName,
BuildingId = id
});
}
private async UniTask DestroyBuildingEntityRoutine(string id)
{
await DbServiceClient.DeleteBuildingAsync(new DeleteBuildingReq()
{
MapName = CurrentMapInfo.Id,
BuildingId = id
});
}
public override void DestroyBuildingEntity(string id)
{
base.DestroyBuildingEntity(id);
DbServiceClient.DeleteBuildingAsync(new DeleteBuildingReq()
{
MapName = Assets.onlineScene.SceneName,
BuildingId = id
});
}
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
}
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 ActionResult ListaWnioskow(string data1, string data2)
{
using (DbServiceClient client = new DbServiceClient())
{
IEnumerable <wniosekWithDecyzja> wwdList = client.GetWnioskiBetweenDates(data1, data2);
return(View(wwdList));
}
}
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
}
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 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
}
private async UniTask CreateBuildingEntityRoutine(BuildingSaveData saveData, bool initialize)
{
if (!initialize)
{
await DbServiceClient.CreateBuildingAsync(new CreateBuildingReq()
{
MapName = CurrentMapInfo.Id,
BuildingData = saveData,
});
}
}
private async UniTask CreateBuildingEntityRoutine(BuildingSaveData saveData, bool initialize)
{
if (!initialize)
{
await DbServiceClient.CreateBuildingAsync(new CreateBuildingReq()
{
MapName = Assets.onlineScene.SceneName,
BuildingData = saveData.ToByteString()
});
}
}
public override BuildingEntity CreateBuildingEntity(BuildingSaveData saveData, bool initialize)
{
if (!initialize)
{
DbServiceClient.CreateBuildingAsync(new CreateBuildingReq()
{
MapName = Assets.onlineScene.SceneName,
BuildingData = saveData.ToByteString()
});
}
return(base.CreateBuildingEntity(saveData, initialize));
}
public ActionResult Edit(int id_wniosek)
{
wniosekWithDecyzja wwd;
using (DbServiceClient client = new DbServiceClient())
{
wwd = client.GetWniosek(id_wniosek);
}
ViewBag.Date1 = data1;
ViewBag.Date2 = data2;
return(View(wwd));
}
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.InvokeError(new ResponseCreatePartyMessage()
{
message = UITextKeys.UI_ERROR_NOT_LOGGED_IN,
});
return;
}
ValidatePartyRequestResult validateResult = playerCharacter.CanCreateParty();
if (!validateResult.IsSuccess)
{
result.InvokeError(new ResponseCreatePartyMessage()
{
message = validateResult.GameMessage,
});
return;
}
AsyncResponseData <PartyResp> createPartyResp = await DbServiceClient.CreatePartyAsync(new CreatePartyReq()
{
LeaderCharacterId = playerCharacter.Id,
ShareExp = request.shareExp,
ShareItem = request.shareItem
});
if (!createPartyResp.IsSuccess)
{
result.InvokeError(new ResponseCreatePartyMessage()
{
message = UITextKeys.UI_ERROR_INTERNAL_SERVER_ERROR,
});
return;
}
// Update cache
PartyData party = createPartyResp.Response.PartyData;
GameInstance.ServerPartyHandlers.SetParty(party.id, party);
playerCharacter.PartyId = party.id;
// Broadcast via chat server
if (ClusterClient.IsNetworkActive)
{
ClusterClient.SendCreateParty(MMOMessageTypes.UpdateParty, party.id, party.shareExp, party.shareItem, playerCharacter.Id);
ClusterClient.SendAddSocialMember(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.InvokeSuccess(new ResponseCreatePartyMessage());
#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
}
public ActionResult ViewCity(string id)
{
DbServiceClient client = new DbServiceClient();
return View(client.GetAddress("Bothell").ToList());
}
