private IEnumerator CreateGuildRoutine(BasePlayerCharacterEntity playerCharacterEntity, string guildName)
{
FindGuildNameJob findGuildNameJob = new FindGuildNameJob(Database, guildName);
findGuildNameJob.Start();
yield return(StartCoroutine(findGuildNameJob.WaitFor()));
if (findGuildNameJob.result > 0)
{
// Cannot create guild because guild name is already existed
SendServerGameMessage(playerCharacterEntity.ConnectionId, GameMessage.Type.ExistedGuildName);
}
else
{
CreateGuildJob createGuildJob = new CreateGuildJob(Database, guildName, playerCharacterEntity.Id);
createGuildJob.Start();
yield return(StartCoroutine(createGuildJob.WaitFor()));
int guildId = createGuildJob.result;
// Create guild
base.CreateGuild(playerCharacterEntity, guildName, guildId);
// Save to database
new SetCharacterGuildJob(Database, playerCharacterEntity.Id, guildId, guilds[guildId].GetMemberRole(playerCharacterEntity.Id)).Start();
// Broadcast via chat server
if (ChatNetworkManager.IsClientConnected)
{
ChatNetworkManager.Client.SendCreateGuild(null, MMOMessageTypes.UpdateGuild, guildId, guildName, playerCharacterEntity.Id);
ChatNetworkManager.Client.SendAddSocialMember(null, MMOMessageTypes.UpdateGuildMember, guildId, playerCharacterEntity.Id, playerCharacterEntity.CharacterName, playerCharacterEntity.DataId, playerCharacterEntity.Level);
}
}
}
public override void RegisterPlayerCharacter(long connectionId, BasePlayerCharacterEntity playerCharacterEntity)
{
// Set user data to map server
if (!usersById.ContainsKey(playerCharacterEntity.Id))
{
SocialCharacterData userData = new SocialCharacterData();
userData.userId = playerCharacterEntity.UserId;
userData.id = playerCharacterEntity.Id;
userData.characterName = playerCharacterEntity.CharacterName;
userData.dataId = playerCharacterEntity.DataId;
userData.level = playerCharacterEntity.Level;
userData.currentHp = playerCharacterEntity.CurrentHp;
userData.maxHp = playerCharacterEntity.MaxHp;
userData.currentMp = playerCharacterEntity.CurrentMp;
userData.maxMp = playerCharacterEntity.MaxMp;
usersById.TryAdd(userData.id, userData);
// Add map user to central server and chat server
UpdateMapUser(CentralAppServerRegister, UpdateUserCharacterMessage.UpdateType.Add, userData);
if (ChatNetworkManager.IsClientConnected)
{
UpdateMapUser(ChatNetworkManager.Client, UpdateUserCharacterMessage.UpdateType.Add, userData);
}
}
base.RegisterPlayerCharacter(connectionId, playerCharacterEntity);
}
public override void WarpCharacterToInstance(BasePlayerCharacterEntity playerCharacterEntity, string mapName, Vector3 position, bool overrideRotation, Vector3 rotation)
{
#if UNITY_STANDALONE && !CLIENT_BUILD
if (!CanWarpCharacter(playerCharacterEntity))
{
return;
}
// Generate instance id
string instanceId = GenericUtils.GetUniqueId();
// Prepare data for warp character later when instance map server registered to this map server
HashSet <uint> instanceMapWarpingCharacters = new HashSet <uint>();
PartyData party;
if (ServerPartyHandlers.TryGetParty(playerCharacterEntity.PartyId, out party))
{
// If character is party leader, will bring party member to join instance
if (party.IsLeader(playerCharacterEntity.Id))
{
List <BasePlayerCharacterEntity> aliveAllies = playerCharacterEntity.FindAliveCharacters <BasePlayerCharacterEntity>(CurrentGameInstance.joinInstanceMapDistance, true, false, false);
foreach (BasePlayerCharacterEntity aliveAlly in aliveAllies)
{
if (!party.IsMember(aliveAlly.Id))
{
continue;
}
instanceMapWarpingCharacters.Add(aliveAlly.ObjectId);
aliveAlly.IsWarping = true;
}
instanceMapWarpingCharacters.Add(playerCharacterEntity.ObjectId);
playerCharacterEntity.IsWarping = true;
}
else
{
ServerGameMessageHandlers.SendGameMessage(playerCharacterEntity.ConnectionId, UITextKeys.UI_ERROR_PARTY_MEMBER_CANNOT_ENTER_INSTANCE);
return;
}
}
else
{
// If no party enter instance alone
instanceMapWarpingCharacters.Add(playerCharacterEntity.ObjectId);
playerCharacterEntity.IsWarping = true;
}
instanceMapWarpingCharactersByInstanceId.TryAdd(instanceId, instanceMapWarpingCharacters);
instanceMapWarpingLocations.TryAdd(instanceId, new InstanceMapWarpingLocation()
{
mapName = mapName,
position = position,
overrideRotation = overrideRotation,
rotation = rotation,
});
ClusterClient.SendRequest(MMORequestTypes.RequestSpawnMap, new RequestSpawnMapMessage()
{
mapId = mapName,
instanceId = instanceId,
instanceWarpPosition = position,
instanceWarpOverrideRotation = overrideRotation,
instanceWarpRotation = rotation,
}, responseDelegate: (responseHandler, responseCode, response) => OnRequestSpawnMap(responseHandler, responseCode, response, instanceId), millisecondsTimeout: mapSpawnMillisecondsTimeout);
#endif
}
private IEnumerator DepositGuildGoldRoutine(BasePlayerCharacterEntity playerCharacterEntity, int amount)
{
GuildData guild;
if (guilds.TryGetValue(playerCharacterEntity.GuildId, out guild))
{
if (playerCharacterEntity.Gold - amount >= 0)
{
playerCharacterEntity.Gold -= amount;
IncreaseGuildGoldJob increaseGuildGoldJob = new IncreaseGuildGoldJob(Database, playerCharacterEntity.GuildId, amount);
increaseGuildGoldJob.Start();
yield return(StartCoroutine(increaseGuildGoldJob.WaitFor()));
guild.gold = increaseGuildGoldJob.result;
guilds[playerCharacterEntity.GuildId] = guild;
SendSetGuildGoldToClients(guild);
}
else
{
SendServerGameMessage(playerCharacterEntity.ConnectionId, GameMessage.Type.NotEnoughGoldToDeposit);
}
}
else
{
SendServerGameMessage(playerCharacterEntity.ConnectionId, GameMessage.Type.NotJoinedGuild);
}
}
private IEnumerator MoveItemFromStorageRoutine(BasePlayerCharacterEntity playerCharacterEntity, StorageId storageId, short storageItemIndex, short amount, short nonEquipIndex)
{
List <CharacterItem> storageItemList = new List <CharacterItem>();
ReadStorageItemsJob readStorageItemsJob = new ReadStorageItemsJob(Database, storageId.storageType, storageId.storageOwnerId);
readStorageItemsJob.Start();
yield return(StartCoroutine(readStorageItemsJob.WaitFor()));
if (readStorageItemsJob.result != null)
{
// Set storage items
storageItemList = readStorageItemsJob.result;
}
if (storageItemIndex < 0 || storageItemIndex >= storageItemList.Count)
{
// Don't do anything, if storage item index is invalid
}
else
{
// Prepare storage data
Storage storage = GetStorage(storageId);
bool isLimitSlot = storage.slotLimit > 0;
short slotLimit = storage.slotLimit;
// Prepare item data
CharacterItem movingItem = storageItemList[storageItemIndex].Clone();
movingItem.amount = amount;
if (nonEquipIndex < 0 ||
nonEquipIndex >= playerCharacterEntity.NonEquipItems.Count ||
playerCharacterEntity.NonEquipItems[nonEquipIndex].IsEmptySlot() ||
playerCharacterEntity.NonEquipItems[nonEquipIndex].dataId == movingItem.dataId)
{
// Add to inventory or merge
bool isOverwhelming = playerCharacterEntity.IncreasingItemsWillOverwhelming(movingItem.dataId, movingItem.amount);
if (!isOverwhelming && playerCharacterEntity.IncreaseItems(movingItem))
{
// Remove from storage
storageItemList.DecreaseItemsByIndex(storageItemIndex, amount);
}
}
else
{
// Swapping
CharacterItem storageItem = storageItemList[storageItemIndex];
CharacterItem nonEquipItem = playerCharacterEntity.NonEquipItems[nonEquipIndex];
storageItemList[storageItemIndex] = nonEquipItem;
playerCharacterEntity.NonEquipItems[nonEquipIndex] = storageItem;
}
storageItemList.FillEmptySlots(isLimitSlot, slotLimit);
}
// Update storage list immediately
// TODO: Have to test about race condition while running multiple-server
UpdateStorageItemsJob updateStorageItemsJob = new UpdateStorageItemsJob(Database, storageId.storageType, storageId.storageOwnerId, storageItemList);
updateStorageItemsJob.Start();
yield return(StartCoroutine(updateStorageItemsJob.WaitFor()));
// Update storage items to characters that open the storage
UpdateStorageItemsToCharacters(usingStorageCharacters[storageId], storageItemList);
}
private IEnumerator WithdrawGuildGoldRoutine(BasePlayerCharacterEntity playerCharacterEntity, int amount)
{
GuildData guild;
if (guilds.TryGetValue(playerCharacterEntity.GuildId, out guild))
{
GetGuildGoldJob getGuildGoldJob = new GetGuildGoldJob(Database, playerCharacterEntity.GuildId);
getGuildGoldJob.Start();
yield return(StartCoroutine(getGuildGoldJob.WaitFor()));
if (getGuildGoldJob.result - amount >= 0)
{
DecreaseGuildGoldJob decreaseGuildGoldJob = new DecreaseGuildGoldJob(Database, playerCharacterEntity.GuildId, amount);
decreaseGuildGoldJob.Start();
guild.gold = decreaseGuildGoldJob.result;
playerCharacterEntity.Gold += amount;
guilds[playerCharacterEntity.GuildId] = guild;
SendSetGuildGoldToClients(guild);
}
else
{
SendServerGameMessage(playerCharacterEntity.ConnectionId, GameMessage.Type.NotEnoughGoldToWithdraw);
}
}
else
{
SendServerGameMessage(playerCharacterEntity.ConnectionId, GameMessage.Type.NotJoinedGuild);
}
}
protected override bool IsPlayerEnemy(BasePlayerCharacterEntity playerCharacter, EntityInfo targetEntity)
{
if (string.IsNullOrEmpty(targetEntity.Id))
{
return(false);
}
if (targetEntity.Type == EntityTypes.Player)
{
return(targetEntity.GuildId == 0 || targetEntity.GuildId != playerCharacter.GuildId);
}
if (targetEntity.Type == EntityTypes.GuildWarMonster)
{
return(BaseGameNetworkManager.Singleton.DefenderGuildId == 0 || BaseGameNetworkManager.Singleton.DefenderGuildId != playerCharacter.GuildId);
}
if (targetEntity.Type == EntityTypes.Monster)
{
// If this character is not summoner so it is enemy
if (targetEntity.HasSummoner)
{
// If summoned by someone, will have same enemies with summoner
return(playerCharacter.IsEnemy(targetEntity.Summoner));
}
else
{
// Monster always be player's enemy
return(true);
}
}
return(false);
}
protected override void WarpCharacter(BasePlayerCharacterEntity playerCharacterEntity, string mapName, Vector3 position)
{
if (!CanWarpCharacter(playerCharacterEntity))
{
return;
}
if (!IsInstanceMap())
{
base.WarpCharacter(playerCharacterEntity, mapName, position);
StartCoroutine(WarpCharacterRoutine(playerCharacterEntity, mapName, position, false));
}
else
{
if (string.IsNullOrEmpty(mapName))
{
// Warp in the map
base.WarpCharacter(playerCharacterEntity, mapName, position);
}
else
{
// Warp to other map
StartCoroutine(WarpCharacterRoutine(playerCharacterEntity, mapName, position, true));
}
}
}
public override void SetGuildRole(BasePlayerCharacterEntity playerCharacterEntity, byte guildRole, string roleName, bool canInvite, bool canKick, byte shareExpPercentage)
{
int guildId;
GuildData guild;
if (!CanSetGuildRole(playerCharacterEntity, guildRole, roleName, out guildId, out guild))
{
return;
}
guild.SetRole(guildRole, roleName, canInvite, canKick, shareExpPercentage);
guilds[guildId] = guild;
// Change characters guild role
foreach (string memberId in guild.GetMemberIds())
{
BasePlayerCharacterEntity memberCharacterEntity;
if (playerCharactersById.TryGetValue(memberId, out memberCharacterEntity))
{
memberCharacterEntity.GuildRole = guildRole;
// Save to database
new UpdateGuildMemberRoleJob(Database, memberId, guildRole).Start();
}
}
SendSetGuildRoleToClients(guild, guildRole, roleName, canInvite, canKick, shareExpPercentage);
// Save to database
new UpdateGuildRoleJob(Database, guildId, guildRole, roleName, canInvite, canKick, shareExpPercentage).Start();
// Broadcast via chat server
if (ChatNetworkManager.IsClientConnected)
{
ChatNetworkManager.Client.SendSetGuildRole(null, MMOMessageTypes.UpdateGuild, guildId, guildRole, roleName, canInvite, canKick, shareExpPercentage);
}
}
public override Vector3 GetCurrentPosition(BasePlayerCharacterEntity playerCharacterEntity)
{
if (!IsInstanceMap())
{
return(base.GetCurrentPosition(playerCharacterEntity));
}
return(instanceMapCurrentLocations[playerCharacterEntity.ObjectId].Value);
}
public override string GetCurrentMapId(BasePlayerCharacterEntity playerCharacterEntity)
{
if (!IsInstanceMap())
{
return(base.GetCurrentMapId(playerCharacterEntity));
}
return(instanceMapCurrentLocations[playerCharacterEntity.ObjectId].Key);
}
public override void CreateParty(BasePlayerCharacterEntity playerCharacterEntity, bool shareExp, bool shareItem)
{
if (!CanCreateParty(playerCharacterEntity))
{
return;
}
StartCoroutine(CreatePartyRoutine(playerCharacterEntity, shareExp, shareItem));
}
public override void CloseStorage(BasePlayerCharacterEntity playerCharacterEntity)
{
if (usingStorageCharacters.ContainsKey(playerCharacterEntity.CurrentStorageId))
{
usingStorageCharacters[playerCharacterEntity.CurrentStorageId].Remove(playerCharacterEntity.ObjectId);
}
playerCharacterEntity.StorageItems.Clear();
}
public override void CreateGuild(BasePlayerCharacterEntity playerCharacterEntity, string guildName)
{
if (!CanCreateGuild(playerCharacterEntity, guildName))
{
return;
}
StartCoroutine(CreateGuildRoutine(playerCharacterEntity, guildName));
}
public override void MoveItemFromStorage(BasePlayerCharacterEntity playerCharacterEntity, StorageId storageId, short storageItemIndex, short amount, short nonEquipIndex)
{
if (!CanAccessStorage(playerCharacterEntity, storageId))
{
SendServerGameMessage(playerCharacterEntity.ConnectionId, GameMessage.Type.CannotAccessStorage);
return;
}
StartCoroutine(MoveItemFromStorageRoutine(playerCharacterEntity, storageId, storageItemIndex, amount, nonEquipIndex));
}
private IEnumerator RemoveFriendRoutine(BasePlayerCharacterEntity playerCharacterEntity, string friendCharacterId)
{
DeleteFriendJob job = new DeleteFriendJob(Database, playerCharacterEntity.Id, friendCharacterId);
job.Start();
yield return(StartCoroutine(job.WaitFor()));
GetFriends(playerCharacterEntity);
}
public override void WarpCharacter(BasePlayerCharacterEntity playerCharacterEntity, string mapName, Vector3 position)
{
if (!CanWarpCharacter(playerCharacterEntity))
{
return;
}
base.WarpCharacter(playerCharacterEntity, mapName, position);
StartCoroutine(WarpCharacterRoutine(playerCharacterEntity, mapName, position));
}
private IEnumerator GetFriendsRoutine(BasePlayerCharacterEntity playerCharacterEntity)
{
ReadFriendsJob job = new ReadFriendsJob(Database, playerCharacterEntity.Id);
job.Start();
yield return(StartCoroutine(job.WaitFor()));
SendUpdateFriendsToClient(playerCharacterEntity.ConnectionId, job.result.ToArray());
}
public override void LeaveGuild(BasePlayerCharacterEntity playerCharacterEntity)
{
int guildId;
GuildData guild;
if (!CanLeaveGuild(playerCharacterEntity, out guildId, out guild))
{
return;
}
// If it is leader kick all members and terminate guild
if (guild.IsLeader(playerCharacterEntity))
{
foreach (string memberId in guild.GetMemberIds())
{
BasePlayerCharacterEntity memberCharacterEntity;
if (playerCharactersById.TryGetValue(memberId, out memberCharacterEntity))
{
memberCharacterEntity.ClearGuild();
SendGuildTerminateToClient(memberCharacterEntity.ConnectionId, guildId);
}
// Save to database
new SetCharacterGuildJob(Database, memberId, 0, 0).Start();
// Broadcast via chat server
if (ChatNetworkManager.IsClientConnected)
{
ChatNetworkManager.Client.SendRemoveSocialMember(null, MMOMessageTypes.UpdateGuildMember, guildId, memberId);
}
}
guilds.Remove(guildId);
// Save to database
new DeleteGuildJob(Database, guildId).Start();
// Broadcast via chat server
if (ChatNetworkManager.IsClientConnected)
{
ChatNetworkManager.Client.SendGuildTerminate(null, MMOMessageTypes.UpdateGuild, guildId);
}
}
else
{
playerCharacterEntity.ClearGuild();
SendGuildTerminateToClient(playerCharacterEntity.ConnectionId, guildId);
guild.RemoveMember(playerCharacterEntity.Id);
guilds[guildId] = guild;
SendRemoveGuildMemberToClients(guild, playerCharacterEntity.Id);
// Save to database
new SetCharacterGuildJob(Database, playerCharacterEntity.Id, 0, 0).Start();
// Broadcast via chat server
if (ChatNetworkManager.IsClientConnected)
{
ChatNetworkManager.Client.SendRemoveSocialMember(null, MMOMessageTypes.UpdateGuildMember, guildId, playerCharacterEntity.Id);
}
}
}
public override void LeaveParty(BasePlayerCharacterEntity playerCharacterEntity)
{
int partyId;
PartyData party;
if (!CanLeaveParty(playerCharacterEntity, out partyId, out party))
{
return;
}
// If it is leader kick all members and terminate party
if (party.IsLeader(playerCharacterEntity))
{
foreach (string memberId in party.GetMemberIds())
{
BasePlayerCharacterEntity memberCharacterEntity;
if (playerCharactersById.TryGetValue(memberId, out memberCharacterEntity))
{
memberCharacterEntity.ClearParty();
SendPartyTerminateToClient(memberCharacterEntity.ConnectionId, partyId);
}
// Save to database
new SetCharacterPartyJob(Database, memberId, 0).Start();
// Broadcast via chat server
if (ChatNetworkManager.IsClientConnected)
{
ChatNetworkManager.Client.SendRemoveSocialMember(null, MMOMessageTypes.UpdatePartyMember, partyId, memberId);
}
}
parties.Remove(partyId);
// Save to database
new DeletePartyJob(Database, partyId).Start();
// Broadcast via chat server
if (ChatNetworkManager.IsClientConnected)
{
ChatNetworkManager.Client.SendPartyTerminate(null, MMOMessageTypes.UpdateParty, partyId);
}
}
else
{
playerCharacterEntity.ClearParty();
SendPartyTerminateToClient(playerCharacterEntity.ConnectionId, partyId);
party.RemoveMember(playerCharacterEntity.Id);
parties[partyId] = party;
SendRemovePartyMemberToClients(party, playerCharacterEntity.Id);
// Save to database
new SetCharacterPartyJob(Database, playerCharacterEntity.Id, 0).Start();
// Broadcast via chat server
if (ChatNetworkManager.IsClientConnected)
{
ChatNetworkManager.Client.SendRemoveSocialMember(null, MMOMessageTypes.UpdatePartyMember, partyId, playerCharacterEntity.Id);
}
}
}
public override void IncreaseGuildExp(BasePlayerCharacterEntity playerCharacterEntity, int exp)
{
int guildId;
GuildData guild;
if (!CanIncreaseGuildExp(playerCharacterEntity, exp, out guildId, out guild))
{
return;
}
StartCoroutine(IncreaseGuildExpRoutine(playerCharacterEntity, exp, guildId, guild));
}
public override string GetCurrentMapId(BasePlayerCharacterEntity playerCharacterEntity)
{
#if UNITY_STANDALONE && !CLIENT_BUILD
if (!IsInstanceMap())
{
return(base.GetCurrentMapId(playerCharacterEntity));
}
return(instanceMapCurrentLocations[playerCharacterEntity.ObjectId].Key);
#else
return(string.Empty);
#endif
}
public override Vector3 GetCurrentPosition(BasePlayerCharacterEntity playerCharacterEntity)
{
#if UNITY_STANDALONE && !CLIENT_BUILD
if (!IsInstanceMap())
{
return(base.GetCurrentPosition(playerCharacterEntity));
}
return(instanceMapCurrentLocations[playerCharacterEntity.ObjectId].Value);
#else
return(Vector3.zero);
#endif
}
public override void OpenStorage(BasePlayerCharacterEntity playerCharacterEntity)
{
if (!CanAccessStorage(playerCharacterEntity, playerCharacterEntity.CurrentStorageId))
{
SendServerGameMessage(playerCharacterEntity.ConnectionId, GameMessage.Type.CannotAccessStorage);
return;
}
if (!usingStorageCharacters.ContainsKey(playerCharacterEntity.CurrentStorageId))
{
usingStorageCharacters[playerCharacterEntity.CurrentStorageId] = new HashSet <uint>();
}
usingStorageCharacters[playerCharacterEntity.CurrentStorageId].Add(playerCharacterEntity.ObjectId);
StartCoroutine(OpenStorageRoutine(playerCharacterEntity));
}
private IEnumerator DepositGoldRoutine(BasePlayerCharacterEntity playerCharacterEntity, int amount)
{
if (playerCharacterEntity.Gold - amount >= 0)
{
playerCharacterEntity.Gold -= amount;
IncreaseGoldJob increaseGoldJob = new IncreaseGoldJob(Database, playerCharacterEntity.UserId, amount);
increaseGoldJob.Start();
yield return(StartCoroutine(increaseGoldJob.WaitFor()));
playerCharacterEntity.UserGold = increaseGoldJob.result;
}
else
{
SendServerGameMessage(playerCharacterEntity.ConnectionId, GameMessage.Type.NotEnoughGoldToDeposit);
}
}
private IEnumerator FindCharactersRoutine(BasePlayerCharacterEntity playerCharacterEntity, string characterName)
{
FindCharactersJob job = new FindCharactersJob(Database, characterName);
job.Start();
yield return(StartCoroutine(job.WaitFor()));
SocialCharacterData[] characters = new SocialCharacterData[job.result.Count];
SocialCharacterData tempCharacter;
for (int i = 0; i < job.result.Count; ++i)
{
tempCharacter = job.result[i];
characters[i] = tempCharacter;
}
SendUpdateFoundCharactersToClient(playerCharacterEntity.ConnectionId, characters);
}
protected override void WarpCharacterToInstance(BasePlayerCharacterEntity playerCharacterEntity, string mapName, Vector3 position)
{
if (!CanWarpCharacter(playerCharacterEntity))
{
return;
}
// Generate instance id
string instanceId = GenericUtils.GetUniqueId();
RequestSpawnMapMessage requestSpawnMapMessage = new RequestSpawnMapMessage();
requestSpawnMapMessage.mapId = mapName;
requestSpawnMapMessage.instanceId = instanceId;
// Prepare data for warp character later when instance map server registered to this map server
HashSet <uint> instanceMapWarpingCharacters = new HashSet <uint>();
PartyData party;
if (parties.TryGetValue(playerCharacterEntity.PartyId, out party))
{
// If character is party member, will bring party member to join instance
if (party.IsLeader(playerCharacterEntity))
{
List <BasePlayerCharacterEntity> aliveAllies = playerCharacterEntity.FindAliveCharacters <BasePlayerCharacterEntity>(gameInstance.joinInstanceMapDistance, true, false, false);
foreach (BasePlayerCharacterEntity aliveAlly in aliveAllies)
{
if (!party.IsMember(aliveAlly))
{
continue;
}
instanceMapWarpingCharacters.Add(aliveAlly.ObjectId);
aliveAlly.IsWarping = true;
}
instanceMapWarpingCharacters.Add(playerCharacterEntity.ObjectId);
playerCharacterEntity.IsWarping = true;
}
}
else
{
// If no party enter instance alone
instanceMapWarpingCharacters.Add(playerCharacterEntity.ObjectId);
playerCharacterEntity.IsWarping = true;
}
instanceMapWarpingCharactersByInstanceId.Add(instanceId, instanceMapWarpingCharacters);
instanceMapWarpingLocations.Add(instanceId, new KeyValuePair <string, Vector3>(mapName, position));
CentralAppServerRegister.ClientSendAckPacket(DeliveryMethod.ReliableOrdered, MMOMessageTypes.RequestSpawnMap, requestSpawnMapMessage, OnRequestSpawnMap);
}
public override void SetGuildMemberRole(BasePlayerCharacterEntity playerCharacterEntity, string characterId, byte guildRole)
{
int guildId;
GuildData guild;
if (!CanSetGuildMemberRole(playerCharacterEntity, out guildId, out guild))
{
return;
}
base.SetGuildMemberRole(playerCharacterEntity, characterId, guildRole);
// Save to database
new UpdateGuildMemberRoleJob(Database, characterId, guildRole).Start();
// Broadcast via chat server
if (ChatNetworkManager.IsClientConnected)
{
ChatNetworkManager.Client.SendSetGuildMemberRole(null, MMOMessageTypes.UpdateGuild, guildId, characterId, guildRole);
}
}
public override void AddGuildMember(BasePlayerCharacterEntity inviteCharacterEntity, BasePlayerCharacterEntity acceptCharacterEntity)
{
int guildId;
GuildData guild;
if (!CanAddGuildMember(inviteCharacterEntity, acceptCharacterEntity, out guildId, out guild))
{
return;
}
base.AddGuildMember(inviteCharacterEntity, acceptCharacterEntity);
// Save to database
new SetCharacterGuildJob(Database, acceptCharacterEntity.Id, guildId, guild.GetMemberRole(acceptCharacterEntity.Id)).Start();
// Broadcast via chat server
if (ChatNetworkManager.IsClientConnected)
{
ChatNetworkManager.Client.SendAddSocialMember(null, MMOMessageTypes.UpdateGuildMember, guildId, acceptCharacterEntity.Id, acceptCharacterEntity.CharacterName, acceptCharacterEntity.DataId, acceptCharacterEntity.Level);
}
}
public override void KickFromGuild(BasePlayerCharacterEntity playerCharacterEntity, string characterId)
{
int guildId;
GuildData guild;
if (!CanKickFromGuild(playerCharacterEntity, characterId, out guildId, out guild))
{
return;
}
base.KickFromGuild(playerCharacterEntity, characterId);
// Save to database
new SetCharacterGuildJob(Database, characterId, 0, 0).Start();
// Broadcast via chat server
if (ChatNetworkManager.IsClientConnected)
{
ChatNetworkManager.Client.SendRemoveSocialMember(null, MMOMessageTypes.UpdateGuildMember, guildId, characterId);
}
}
