private void HandleResponseAppServerAddress(LiteNetLibMessageHandler messageHandler)
{
var message = messageHandler.ReadMessage <ResponseAppServerAddressMessage>();
if (message.responseCode == AckResponseCode.Success)
{
var peerInfo = message.peerInfo;
switch (peerInfo.peerType)
{
case CentralServerPeerType.MapServer:
if (!string.IsNullOrEmpty(peerInfo.extra))
{
if (LogInfo)
{
Debug.Log("Register map server: " + peerInfo.extra);
}
mapServerConnectionIdsBySceneName[peerInfo.extra] = peerInfo;
}
break;
case CentralServerPeerType.Chat:
if (!ChatNetworkManager.IsClientConnected)
{
if (LogInfo)
{
Debug.Log("Connecting to chat server");
}
ChatNetworkManager.StartClient(this, peerInfo.networkAddress, peerInfo.networkPort, peerInfo.connectKey);
}
break;
}
}
}
protected override void HandleChatAtServer(MessageHandlerData messageHandler)
{
ChatMessage message = FillChatChannelId(messageHandler.ReadMessage <ChatMessage>());
// Local chat will processes immediately, not have to be sent to chat server
if (message.channel == ChatChannel.Local)
{
ReadChatMessage(message);
return;
}
if (message.channel == ChatChannel.System)
{
if (CanSendSystemAnnounce(message.sender))
{
// Send chat message to chat server, for MMO mode chat message handling by chat server
if (ChatNetworkManager.IsClientConnected)
{
ChatNetworkManager.SendEnterChat(null, MMOMessageTypes.Chat, message.channel, message.message, message.sender, message.receiver, message.channelId);
}
}
return;
}
// Send chat message to chat server, for MMO mode chat message handling by chat server
if (ChatNetworkManager.IsClientConnected)
{
ChatNetworkManager.SendEnterChat(null, MMOMessageTypes.Chat, message.channel, message.message, message.sender, message.receiver, message.channelId);
}
}
public override void OnStopServer()
{
base.OnStopServer();
CentralAppServerRegister.OnStopServer();
if (ChatNetworkManager.IsClientConnected)
{
ChatNetworkManager.StopClient();
}
}
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 override void OnStopServer()
{
base.OnStopServer();
CentralAppServerRegister.OnStopServer();
if (ChatNetworkManager.IsClientConnected)
{
ChatNetworkManager.StopClient();
}
mapServerConnectionIdsBySceneName.Clear();
}
private void HandleResponseAppServerAddress(MessageHandlerData messageHandler)
{
ResponseAppServerAddressMessage message = messageHandler.ReadMessage <ResponseAppServerAddressMessage>();
CentralServerPeerInfo peerInfo = message.peerInfo;
switch (peerInfo.peerType)
{
case CentralServerPeerType.MapServer:
if (!string.IsNullOrEmpty(peerInfo.extra))
{
if (LogInfo)
{
Logging.Log(LogTag, "Register map server: " + peerInfo.extra);
}
mapServerConnectionIdsBySceneName[peerInfo.extra] = peerInfo;
}
break;
case CentralServerPeerType.InstanceMapServer:
if (!string.IsNullOrEmpty(peerInfo.extra))
{
if (LogInfo)
{
Logging.Log(LogTag, "Register instance map server: " + peerInfo.extra);
}
instanceMapServerConnectionIdsByInstanceId[peerInfo.extra] = peerInfo;
// Warp characters
HashSet <uint> warpingCharacters;
if (instanceMapWarpingCharactersByInstanceId.TryGetValue(peerInfo.extra, out warpingCharacters))
{
BasePlayerCharacterEntity warpingCharacterEntity;
foreach (uint warpingCharacter in warpingCharacters)
{
if (!Assets.TryGetSpawnedObject(warpingCharacter, out warpingCharacterEntity))
{
continue;
}
WarpCharacterToInstanceRoutine(warpingCharacterEntity, peerInfo.extra).Forget();
}
}
}
break;
case CentralServerPeerType.Chat:
if (!ChatNetworkManager.IsClientConnected)
{
if (LogInfo)
{
Logging.Log(LogTag, "Connecting to chat server");
}
ChatNetworkManager.StartClient(this, peerInfo.networkAddress, peerInfo.networkPort);
}
break;
}
}
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 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.Invoke(AckResponseCode.Error, new ResponseAcceptGuildInvitationMessage()
{
message = UITextKeys.UI_ERROR_NOT_LOGGED_IN,
});
return;
}
ValidateGuildRequestResult validateResult = GameInstance.ServerGuildHandlers.CanAcceptGuildInvitation(request.guildId, playerCharacter);
if (!validateResult.IsSuccess)
{
result.Invoke(AckResponseCode.Error, 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
_ = DbServiceClient.UpdateCharacterGuildAsync(new UpdateCharacterGuildReq()
{
SocialCharacterData = SocialCharacterData.Create(playerCharacter),
GuildId = request.guildId,
GuildRole = validateResult.Guild.GetMemberRole(playerCharacter.Id)
});
// Broadcast via chat server
if (ChatNetworkManager.IsClientConnected)
{
ChatNetworkManager.SendAddSocialMember(null, 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);
result.Invoke(AckResponseCode.Success, new ResponseAcceptGuildInvitationMessage()
{
message = UITextKeys.UI_GUILD_INVITATION_ACCEPTED,
});
#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.Invoke(AckResponseCode.Error, new ResponseKickMemberFromGuildMessage()
{
message = UITextKeys.UI_ERROR_NOT_LOGGED_IN,
});
return;
}
ValidateGuildRequestResult validateResult = GameInstance.ServerGuildHandlers.CanKickMemberFromGuild(playerCharacter, request.memberId);
if (!validateResult.IsSuccess)
{
result.Invoke(AckResponseCode.Error, new ResponseKickMemberFromGuildMessage()
{
message = validateResult.GameMessage,
});
return;
}
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);
// Save to database
_ = DbServiceClient.ClearCharacterGuildAsync(new ClearCharacterGuildReq()
{
CharacterId = request.memberId
});
// Broadcast via chat server
if (ChatNetworkManager.IsClientConnected)
{
ChatNetworkManager.SendRemoveSocialMember(null, MMOMessageTypes.UpdateGuildMember, validateResult.GuildId, request.memberId);
}
GameInstance.ServerGameMessageHandlers.SendRemoveGuildMemberToMembers(validateResult.Guild, request.memberId);
result.Invoke(AckResponseCode.Success, new ResponseKickMemberFromGuildMessage());
#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 = DatabaseServiceUtils.FromByteString <PartyData>(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
}
public async UniTaskVoid HandleRequestIncreaseGuildSkillLevel(RequestHandlerData requestHandler, RequestIncreaseGuildSkillLevelMessage request, RequestProceedResultDelegate <ResponseIncreaseGuildSkillLevelMessage> result)
{
#if UNITY_STANDALONE && !CLIENT_BUILD
await UniTask.Yield();
IPlayerCharacterData playerCharacter;
if (!GameInstance.ServerUserHandlers.TryGetPlayerCharacter(requestHandler.ConnectionId, out playerCharacter))
{
result.Invoke(AckResponseCode.Error, new ResponseIncreaseGuildSkillLevelMessage()
{
message = UITextKeys.UI_ERROR_NOT_LOGGED_IN,
});
return;
}
ValidateGuildRequestResult validateResult = GameInstance.ServerGuildHandlers.CanIncreaseGuildSkillLevel(playerCharacter, request.dataId);
if (!validateResult.IsSuccess)
{
result.Invoke(AckResponseCode.Error, new ResponseIncreaseGuildSkillLevelMessage()
{
message = validateResult.GameMessage,
});
return;
}
// Save to database
GuildResp resp = await DbServiceClient.AddGuildSkillAsync(new AddGuildSkillReq()
{
GuildId = validateResult.GuildId,
SkillId = request.dataId,
});
GuildData guild = resp.GuildData;
GameInstance.ServerGuildHandlers.SetGuild(validateResult.GuildId, guild);
// Broadcast via chat server
if (ChatNetworkManager.IsClientConnected)
{
ChatNetworkManager.SendSetGuildSkillLevel(null, MMOMessageTypes.UpdateGuild, validateResult.GuildId, request.dataId, guild.GetSkillLevel(request.dataId));
ChatNetworkManager.SendSetGuildLevelExpSkillPoint(null, MMOMessageTypes.UpdateGuild, validateResult.GuildId, guild.level, guild.exp, guild.skillPoint);
}
GameInstance.ServerGameMessageHandlers.SendSetGuildSkillLevelToMembers(guild, request.dataId);
GameInstance.ServerGameMessageHandlers.SendSetGuildLevelExpSkillPointToMembers(guild);
result.Invoke(AckResponseCode.Success, new ResponseIncreaseGuildSkillLevelMessage());
#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 IncreaseGuildExp(IPlayerCharacterData playerCharacter, int exp)
{
#if UNITY_STANDALONE && !CLIENT_BUILD
ValidateGuildRequestResult validateResult = this.CanIncreaseGuildExp(playerCharacter, exp);
if (!validateResult.IsSuccess)
{
return;
}
GuildResp resp = await DbServiceClient.IncreaseGuildExpAsync(new IncreaseGuildExpReq()
{
GuildId = validateResult.GuildId,
Exp = exp,
});
GuildData guild = resp.GuildData;
SetGuild(validateResult.GuildId, guild);
// Broadcast via chat server
if (ChatNetworkManager.IsClientConnected)
{
ChatNetworkManager.SendSetGuildLevelExpSkillPoint(null, MMOMessageTypes.UpdateGuild, guild.id, guild.level, guild.exp, guild.skillPoint);
}
GameInstance.ServerGameMessageHandlers.SendSetGuildLevelExpSkillPointToMembers(guild);
#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.Invoke(AckResponseCode.Error, new ResponseCreateGuildMessage()
{
message = UITextKeys.UI_ERROR_NOT_LOGGED_IN,
});
return;
}
ValidateGuildRequestResult validateResult = playerCharacter.CanCreateGuild(request.guildName);
if (!validateResult.IsSuccess)
{
result.Invoke(AckResponseCode.Error, new ResponseCreateGuildMessage()
{
message = validateResult.GameMessage,
});
return;
}
FindGuildNameResp findGuildNameResp = await DbServiceClient.FindGuildNameAsync(new FindGuildNameReq()
{
GuildName = request.guildName,
});
if (findGuildNameResp.FoundAmount > 0)
{
result.Invoke(AckResponseCode.Error, new ResponseCreateGuildMessage()
{
message = UITextKeys.UI_ERROR_GUILD_NAME_EXISTED,
});
return;
}
GuildResp createGuildResp = await DbServiceClient.CreateGuildAsync(new CreateGuildReq()
{
LeaderCharacterId = playerCharacter.Id,
GuildName = request.guildName,
});
GuildData guild = createGuildResp.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;
if (playerCharacter is BasePlayerCharacterEntity)
{
// Sync guild name to client
(playerCharacter as BasePlayerCharacterEntity).GuildName = request.guildName;
}
// Broadcast via chat server
if (ChatNetworkManager.IsClientConnected)
{
ChatNetworkManager.SendCreateGuild(null, MMOMessageTypes.UpdateGuild, guild.id, request.guildName, playerCharacter.Id);
ChatNetworkManager.SendAddSocialMember(null, 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.Invoke(AckResponseCode.Success, new ResponseCreateGuildMessage());
#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
}