IEnumerator GuildLeaveRequest(string guildId, string accountId, LobbyMessageInfo info)
{
// Get guild members from database
if (!GameDB.guildIdToGuildMembers.ContainsKey(guildId))
{
yield return(GuildsDB.GetGuildMembers(guildId));
}
var guildMembers = GameDB.guildIdToGuildMembers[guildId];
var index = guildMembers.FindIndex(o => o.accountId == accountId);
if (index == -1)
{
Lobby.RPC("GuildKickError", info.sender, guildId, accountId);
yield break;
}
// Check rank: You can not kick guild leaders.
if (guildMembers[index].rank == (byte)GuildMember.Rank.Leader)
{
Lobby.RPC("GuildKickError", info.sender, guildId, accountId);
yield break;
}
guildMembers.RemoveAt(index);
// Set guild members
yield return(GuildsDB.SetGuildMembers(guildId, guildMembers));
// Update guild ID list
yield return(StartCoroutine(RemoveGuildFromGuildList(guildId, accountId, info.sender)));
// Notify all guild members
SendGuildMemberList(guildId, guildMembers);
}
IEnumerator GuildMembersRequest(string guildId, LobbyMessageInfo info)
{
// Get guild members from database
if (!GameDB.guildIdToGuildMembers.ContainsKey(guildId))
{
yield return(GuildsDB.GetGuildMembers(guildId));
}
// Send guild info to player
if (GameDB.guildIdToGuildMembers.ContainsKey(guildId))
{
var guildMembers = GameDB.guildIdToGuildMembers[guildId];
// Member names
foreach (var member in guildMembers)
{
if (!GameDB.accountIdToName.TryGetValue(member.accountId, out member.name))
{
yield return(LobbyGameDB.GetPlayerName(member.accountId, data => {
if (data != null)
{
member.name = data;
GameDB.accountIdToName[member.accountId] = data;
}
}));
}
}
Lobby.RPC("ReceiveGuildMembers", info.sender, guildId, guildMembers.ToArray(), true);
}
else
{
Lobby.RPC("ReceiveGuildMembersError", info.sender, guildId);
}
}
// Removes a guild ID from a player's guild list
IEnumerator RemoveGuildFromGuildList(string guildId, string accountId, LobbyPeer requester = null)
{
// Player online?
if (LobbyPlayer.accountIdToLobbyPlayer.ContainsKey(accountId))
{
var playerKicked = LobbyPlayer.accountIdToLobbyPlayer[accountId];
// Get guild ID list
if (playerKicked.guildList == null)
{
yield return(GuildsDB.GetGuildList(accountId, data => {
if (data == null)
{
playerKicked.guildList = new GuildList();
}
else
{
playerKicked.guildList = data;
}
}));
}
// Remove guild ID from the kicked player's guild ID list
playerKicked.guildList.Remove(guildId);
// Set guild ID list
yield return(GuildsDB.SetGuildList(accountId, playerKicked.guildList));
// Send the kicked player the new guild ID list
SendGuildList(playerKicked);
// Player offline
}
else
{
GuildList guildList = null;
// Get guild ID list
yield return(GuildsDB.GetGuildList(accountId, data => {
guildList = data;
}));
if (guildList == null)
{
if (requester != null)
{
Lobby.RPC("GuildKickError", requester, guildId, accountId);
}
yield break;
}
// Remove guild ID from the kicked player's guild ID list
guildList.Remove(guildId);
// Set guild ID list
yield return(GuildsDB.SetGuildList(accountId, guildList));
}
}
IEnumerator GuildRepresentRequest(string guildId, bool represent, LobbyMessageInfo info)
{
LobbyPlayer player = LobbyServer.GetLobbyPlayer(info);
string accountId = player.accountId;
// Get guild members from database
if (!GameDB.guildIdToGuildMembers.ContainsKey(guildId))
{
yield return(GuildsDB.GetGuildMembers(guildId));
}
var guildMembers = GameDB.guildIdToGuildMembers[guildId];
var index = guildMembers.FindIndex(o => o.accountId == accountId);
if (index == -1)
{
Lobby.RPC("GuildRepresentError", info.sender, guildId, represent);
yield break;
}
// Get guild ID list
if (player.guildList == null)
{
yield return(GuildsDB.GetGuildList(accountId, data => {
if (data == null)
{
player.guildList = new GuildList();
}
else
{
player.guildList = data;
}
}));
}
// Set/unset main guild
if (represent)
{
// Start representing
player.guildList.mainGuildId = guildId;
}
else
{
// Stop representing
if (player.guildList.mainGuildId == guildId)
{
player.guildList.mainGuildId = "";
}
}
// Set guild ID list
yield return(GuildsDB.SetGuildList(accountId, player.guildList));
Lobby.RPC("GuildRepresentSuccess", info.sender, guildId, represent);
}
IEnumerator GuildInfoRequest(string guildId, LobbyMessageInfo info)
{
// Get guild info from database
if (!GameDB.guildIdToGuild.ContainsKey(guildId))
{
yield return(GuildsDB.GetGuild(guildId));
}
// Send guild info to player
if (GameDB.guildIdToGuild.ContainsKey(guildId))
{
string guildInfoString = Jboy.Json.WriteObject(GameDB.guildIdToGuild[guildId]);
Lobby.RPC("ReceiveGuildInfo", info.sender, guildId, guildInfoString);
}
else
{
Lobby.RPC("ReceiveGuildInfoError", info.sender, guildId);
}
}
IEnumerator GuildDisbandRequest(string guildId, LobbyMessageInfo info)
{
LobbyPlayer player = LobbyServer.GetLobbyPlayer(info);
// Get guild members from database
if (!GameDB.guildIdToGuildMembers.ContainsKey(guildId))
{
yield return(GuildsDB.GetGuildMembers(guildId));
}
// Does the player have rights to disband?
if (!Guild.CanDisband(guildId, player.accountId))
{
Lobby.RPC("GuildDisbandError", info.sender, guildId);
yield break;
}
// We checked whether the player has the right to disband the guild.
// Now we need to do this:
// 1.) Remove the guild from the players' guild list (AccountToGuilds).
// 2.) Remove the member list for that guild (GuildToMembers).
// 3.) Remove the guild entry itself (Guilds).
// 4.) Remove the cache data about that guild (automatically done in 2 and 3).
// 1.) Remove the guild from the players' guild list (AccountToGuilds)
foreach (GuildMember member in GameDB.guildIdToGuildMembers[guildId])
{
// Update guild ID list
StartCoroutine(RemoveGuildFromGuildList(guildId, member.accountId, info.sender));
}
// 2.) Remove the member list for that guild (GuildToMembers)
yield return(GuildsDB.RemoveGuildMembers(guildId));
// 3.) Remove the guild entry itself (Guilds)
yield return(GuildsDB.RemoveGuild(guildId));
// Notify the player who requested it
Lobby.RPC("GuildDisbandSuccess", info.sender, guildId);
}
IEnumerator GuildInvitationsListRequest(LobbyMessageInfo info)
{
LobbyPlayer player = LobbyServer.GetLobbyPlayer(info);
// Get guild invitations
if (player.guildInvitations == null)
{
yield return(GuildsDB.GetGuildInvitations(player.accountId, data => {
if (data == null)
{
player.guildInvitations = new List <string>();
}
else
{
player.guildInvitations = data;
}
}));
}
Lobby.RPC("ReceiveGuildInvitationsList", player.peer, player.guildInvitations.ToArray(), true);
}
void GuildRepresentRequest(string guildId, bool represent, uLink.NetworkMessageInfo info)
{
if (info.sender != networkView.owner)
{
return;
}
// Stop representing
if (!represent)
{
networkView.RPC("ReceiveMainGuildInfo", uLink.RPCMode.All, "", "");
return;
}
// Represent new guild
GuildsDB.GetGuild(guildId, guild => {
if (guild != null)
{
networkView.RPC("ReceiveMainGuildInfo", uLink.RPCMode.All, guild.name, guild.tag);
}
});
}
void GuildListRequest(LobbyMessageInfo info)
{
LobbyPlayer player = LobbyServer.GetLobbyPlayer(info);
if (player.guildList == null)
{
GuildsDB.GetGuildList(player.accountId, data => {
if (data == null)
{
player.guildList = new GuildList();
}
else
{
player.guildList = data;
}
GuildsServer.SendGuildList(player);
});
}
else
{
GuildsServer.SendGuildList(player);
}
}
// InstantiatePlayer
void InstantiatePlayer(uLink.NetworkPlayer networkPlayer, string accountId, string playerName, Vector3 respawnPosition, float cameraYRotation, int partyId)
{
LogManager.General.Log(string.Format("Instantiating player prefabs for '{0}' with account ID '{1}'", playerName, accountId));
var party = GameServerParty.partyList[partyId];
// Instantiates an avatar for the player connecting to the server
// The player will be the "owner" of this object. Read the manual chapter 7 for more
// info about object roles: Creator, Owner and Proxy.
GameObject obj = uLink.Network.Instantiate(
networkPlayer, // Owner
proxyPrefab,
ownerPrefab,
creatorPrefab,
respawnPosition,
Cache.quaternionIdentity,
0, // Network group
accountId // Initial data
);
// Player component
Player player = obj.GetComponent <Player>();
player.accountId = accountId;
networkPlayer.localData = player;
// Send name
player.networkView.RPC("ReceivePlayerName", uLink.RPCMode.All, playerName);
// Async: DB requests
if (isTestServer)
{
// This section is for quick client tests on the test server
// Send other players and myself information about stats
player.skillBuild = SkillBuild.GetStarterBuild();
player.customization = new CharacterCustomization();
player.networkView.RPC("ReceiveSkillBuild", uLink.RPCMode.All, player.skillBuild);
player.networkView.RPC("ReceiveCharacterCustomization", uLink.RPCMode.All, player.customization);
player.networkView.RPC("ReceiveCharacterStats", uLink.RPCMode.All, new CharacterStats());
player.networkView.RPC("ReceiveArtifactTree", uLink.RPCMode.All, Jboy.Json.WriteObject(ArtifactTree.GetStarterArtifactTree()));
// After the skill build has been sent, switch the attunement
player.networkView.RPC("SwitchWeapon", uLink.RPCMode.All, (byte)0);
player.networkView.RPC("SwitchAttunement", uLink.RPCMode.All, (byte)0);
}
else
{
// Experience / Level
ExperienceDB.GetExperience(
accountId,
data => {
uint exp = 0;
if (data != null)
{
exp = data.experience;
}
player.networkView.RPC("SetExperience", uLink.RPCMode.All, exp);
}
);
// TODO: We need to wait until this is finished in ApplyCharacterStats
// Skill build
SkillBuildsDB.GetSkillBuild(
accountId,
data => {
if (data == null)
{
player.skillBuild = SkillBuild.GetStarterBuild();
}
else
{
player.skillBuild = data;
}
// Send build
player.networkView.RPC("ReceiveSkillBuild", uLink.RPCMode.All, player.skillBuild);
// After the build has been sent, switch the attunement
player.networkView.RPC("SwitchWeapon", uLink.RPCMode.All, (byte)0);
player.networkView.RPC("SwitchAttunement", uLink.RPCMode.All, (byte)0);
}
);
// Character customization
CharacterCustomizationDB.GetCharacterCustomization(
accountId,
data => {
if (data == null)
{
player.customization = new CharacterCustomization();
}
else
{
player.customization = data;
}
// Send customization
player.networkView.RPC("ReceiveCharacterCustomization", uLink.RPCMode.All, player.customization);
}
);
// Character stats
StartCoroutine(ServerGameDB.GetCharacterStats(player));
// Guild
GuildsDB.GetGuildList(accountId, data => {
if (data != null)
{
GuildsDB.GetGuild(data.mainGuildId, guild => {
if (guild != null)
{
player.networkView.RPC("ReceiveMainGuildInfo", uLink.RPCMode.All, guild.name, guild.tag);
}
});
}
});
// Artifacts
ArtifactsDB.GetArtifactTree(
accountId,
data => {
if (data == null)
{
player.artifactTree = ArtifactTree.GetStarterArtifactTree();
}
else
{
player.artifactTree = data;
}
player.networkView.RPC("ReceiveArtifactTree", uLink.RPCMode.All, Jboy.Json.WriteObject(player.artifactTree));
}
);
// Retrieve arena stats
var statsBucket = new Bucket("AccountToStats");
statsBucket.Get(
accountId,
Constants.Replication.Default,
(request) => {
var statsInDB = request.GetValue <PlayerStats>();
LogManager.General.Log("Queried stats of account '" + accountId + "' successfully (Ranking: " + statsInDB.bestRanking + ")");
// Send ranking
player.networkView.RPC("ReceiveBestRanking", uLink.RPCMode.All, statsInDB.bestRanking);
}, (request) => {
var statsInDB = new PlayerStats();
LogManager.General.Log("Account '" + accountId + "' aka player '" + playerName + "' doesn't have any player stats yet");
// Send ranking
player.networkView.RPC("ReceiveBestRanking", uLink.RPCMode.All, statsInDB.bestRanking);
}
);
}
if (GameManager.isArena)
{
player.networkView.RPC("GameMaxScore", uLink.RPCMode.Owner, gameMode.scoreNeededToWin);
}
// Layer
if (GameManager.isPvP)
{
player.networkView.RPC("ChangeParty", uLink.RPCMode.All, partyId);
player.networkView.RPC("ChangeLayer", uLink.RPCMode.All, party.layer);
}
else
{
player.networkView.RPC("ChangeLayer", uLink.RPCMode.All, Config.instance.openWorldPvPLayer);
}
// Respawn
player.networkView.RPC("Respawn", uLink.RPCMode.All, respawnPosition);
player.networkView.RPC("SetCameraYRotation", uLink.RPCMode.Owner, cameraYRotation);
// On non account restricted servers we start the game instantly
if (!GameManager.isArena || isTestServer)
{
player.networkView.RPC("StartGame", uLink.RPCMode.Owner);
GameManager.gameStarted = true;
}
// Disable encryption in non-ranked games
//if(!GameManager.isRankedGame)
// uLink.Network.UninitializeSecurity(networkPlayer);
}
IEnumerator GuildCreationRequest(string name, string tag, LobbyMessageInfo info)
{
LobbyPlayer founder = LobbyServer.GetLobbyPlayer(info);
// Protection against modified RPC packets
if (!Validator.guildName.IsMatch(name))
{
yield break;
}
if (!Validator.guildTag.IsMatch(tag))
{
yield break;
}
// Check if guild name has already been registered
bool guildNameExists = false;
yield return(GuildsDB.GetGuildIdByGuildName(name, data => {
if (data != null)
{
guildNameExists = true;
}
}));
if (guildNameExists)
{
Lobby.RPC("GuildNameAlreadyExists", info.sender);
yield break;
}
// Store new guild in database
string guildId = null;
var guild = new Guild(name, tag, founder.accountId);
yield return(GuildsDB.PutGuild(
guild,
(key, data) => {
if (key != null)
{
if (founder.guildList == null)
{
founder.guildList = new GuildList();
}
guildId = key;
}
}
));
if (guildId == null)
{
Lobby.RPC("GuildCreationError", info.sender);
yield break;
}
// Founder joins the guild automatically
var memberList = new List <GuildMember>(); //GameDB.guildIdToGuildMembers[guildId];
memberList.Add(new GuildMember(founder.accountId, (byte)GuildMember.Rank.Leader));
yield return(GuildsDB.SetGuildMembers(guildId, memberList));
founder.guildList.Add(guildId);
// Store new guild membership in database
yield return(GuildsDB.SetGuildList(founder.accountId, founder.guildList));
// Let the player know that it worked
Lobby.RPC("GuildCreationSuccess", info.sender);
// Send him the new guild ID list
SendGuildList(founder);
LogManager.General.Log("Guild " + guild + " has been created.");
}
IEnumerator GuildInvitationResponse(string guildId, bool accepted, LobbyMessageInfo info)
{
LobbyPlayer player = LobbyServer.GetLobbyPlayer(info);
// Get guild invitations
if (player.guildInvitations == null)
{
yield return(GuildsDB.GetGuildInvitations(player.accountId, data => {
if (data == null)
{
player.guildInvitations = new List <string>();
}
else
{
player.guildInvitations = data;
}
}));
}
if (player.guildInvitations == null)
{
Lobby.RPC("GuildInvitationResponseError", info.sender, guildId);
yield break;
}
// Were you invited?
if (!player.guildInvitations.Contains(guildId))
{
Lobby.RPC("GuildInvitationResponseError", info.sender, guildId);
yield break;
}
// Did the player accept the invitation?
if (accepted)
{
// Get guild members from database
if (!GameDB.guildIdToGuildMembers.ContainsKey(guildId))
{
yield return(GuildsDB.GetGuildMembers(guildId));
}
var guildMembers = GameDB.guildIdToGuildMembers[guildId];
guildMembers.Add(new GuildMember(player.accountId, player.name, (byte)GuildMember.Rank.Default));
// Set guild members
yield return(GuildsDB.SetGuildMembers(guildId, guildMembers));
// Get guild ID list
if (player.guildList == null)
{
yield return(GuildsDB.GetGuildList(player.accountId, data => {
if (data == null)
{
player.guildList = new GuildList();
}
else
{
player.guildList = data;
}
}));
}
// Add to guild ID list
player.guildList.Add(guildId);
// Set guild ID list
yield return(GuildsDB.SetGuildList(player.accountId, player.guildList));
// Notify all guild members
SendGuildMemberList(guildId, guildMembers);
}
// Remove guild from invitation list
player.guildInvitations.Remove(guildId);
// Set guild invitations
yield return(GuildsDB.SetGuildInvitations(player.accountId, player.guildInvitations, data => {
if (data == null)
{
Lobby.RPC("GuildInvitationResponseError", info.sender, guildId);
}
else
{
player.guildInvitations = data;
Lobby.RPC("GuildInvitationResponseSuccess", info.sender, guildId, accepted);
SendGuildList(player);
}
}));
}
IEnumerator GuildInvitationRequest(string guildId, string playerName, LobbyMessageInfo info)
{
LobbyPlayer player = LobbyServer.GetLobbyPlayer(info);
// Check if the player has guild invitation rights
if (!Guild.CanInvite(guildId, player.accountId))
{
Lobby.RPC("GuildInvitationError", info.sender, playerName);
yield break;
}
List <string> guildInvitations = null;
string accountIdToInvite = null;
// Get account ID
yield return(LobbyGameDB.GetAccountIdByPlayerName(playerName, data => {
accountIdToInvite = data;
}));
if (accountIdToInvite == null)
{
Lobby.RPC("GuildInvitationPlayerDoesntExistError", info.sender, playerName);
yield break;
}
// Get guild members
if (!GameDB.guildIdToGuildMembers.ContainsKey(guildId))
{
yield return(GuildsDB.GetGuildMembers(guildId));
}
// Already a member?
var guildMembers = GameDB.guildIdToGuildMembers[guildId];
if (guildMembers.Find(m => m.accountId == accountIdToInvite) != null)
{
Lobby.RPC("GuildInvitationAlreadyMember", info.sender, playerName);
yield break;
}
// Get guild invitations
if (LobbyPlayer.accountIdToLobbyPlayer.ContainsKey(accountIdToInvite))
{
guildInvitations = LobbyPlayer.accountIdToLobbyPlayer[accountIdToInvite].guildInvitations;
}
if (guildInvitations == null)
{
yield return(GuildsDB.GetGuildInvitations(accountIdToInvite, data => {
if (data == null)
{
guildInvitations = new List <string>();
}
else
{
guildInvitations = data;
}
}));
}
if (guildInvitations == null)
{
Lobby.RPC("GuildInvitationError", info.sender, playerName);
yield break;
}
// Guild invitation already sent?
if (guildInvitations.Contains(guildId))
{
Lobby.RPC("GuildInvitationAlreadySent", info.sender, playerName);
yield break;
}
// Add guild to invitation list
guildInvitations.Add(guildId);
// Set guild invitations
yield return(GuildsDB.SetGuildInvitations(accountIdToInvite, guildInvitations, data => {
if (data == null)
{
Lobby.RPC("GuildInvitationError", info.sender, playerName);
}
else
{
// Notify player if he is online
if (LobbyPlayer.accountIdToLobbyPlayer.ContainsKey(accountIdToInvite))
{
var invitedPlayer = LobbyPlayer.accountIdToLobbyPlayer[accountIdToInvite];
invitedPlayer.guildInvitations = data;
Lobby.RPC("ReceiveGuildInvitationsList", invitedPlayer.peer, invitedPlayer.guildInvitations.ToArray(), true);
}
Lobby.RPC("GuildInvitationSuccess", info.sender, playerName);
}
}));
}
