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);
}
}
void RPC_L2C_CreateRoleFailed(uLink.BitStream stream, LobbyMessageInfo info)
{
int _error;
stream.TryRead <int>(out _error);
if (_error == 1)//name used
{
MessageBox_N.ShowOkBox(PELocalization.GetString(ErrorMessage.NAME_HAS_EXISTED));
}
else if (_error == 2)//something must be wrong
{
RoleInfo[] _myRoles;
stream.TryRead <RoleInfo[]>(out _myRoles);
myRoles = new List <RoleInfo>();
myRolesExisted = new List <RoleInfo>();
myRolesDeleted = new List <RoleInfo>();
myRoles.AddRange(_myRoles);
for (int m = 0; m < myRoles.Count; m++)
{
if (myRoles[m].deletedFlag != 1 && myRolesExisted.Count <= 3)
{
myRolesExisted.Add(myRoles[m]);
}
else
{
myRolesDeleted.Add(myRoles[m]);
}
}
MessageBox_N.ShowOkBox(PELocalization.GetString(8000496), PeSceneCtrl.Instance.GotoMultiRoleScene);
}
Debug.Log("Create Role Failed");
}
protected void RPC_LobbyMsg(BitStream stream, LobbyMessageInfo info)
{
ELobbyMsgType msgType = ELobbyMsgType.Max;
try
{
msgType = stream.Read <ELobbyMsgType>();
if (CheckHandler(msgType))
{
msgHandlers[msgType](stream, info);
}
else
if (LogFilter.logError)
{
Debug.LogWarningFormat("Message:[{0}]|[{1}] does not implement", msgType, GetType());
}
}
catch (Exception e)
{
if (LogFilter.logError)
{
Debug.LogErrorFormat("Message:[{0}]\r\n{1}\r\n{2}\r\n{3}", GetType(), msgType, e.Message, e.StackTrace);
}
}
}
IEnumerator SetFriendNote(string friendName, string groupName, string note, LobbyMessageInfo info)
{
LobbyPlayer player = LobbyServer.GetLobbyPlayer(info);
LogManager.General.Log(string.Format("'{0}' sets friends list note for '{1}' to '{2}'", player.name, friendName, note));
// Find friends group
var selectedGroup = player.friends.GetGroupByName(groupName);
// Get account ID
string friendAccountId = null;
yield return(LobbyGameDB.GetAccountIdByPlayerName(friendName, data => {
friendAccountId = data;
}));
// Error getting account ID?
if (friendAccountId == null)
{
Lobby.RPC("SetFriendNotePlayerDoesntExistError", info.sender, friendName);
yield break;
}
// Remove player from the group
selectedGroup.friends.Find(friend => friend.accountId == friendAccountId).note = note;
// Save friends list in database
yield return(FriendsDB.SetFriends(
player.accountId,
player.friends,
null
));
}
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);
}
void RPC_L2C_RoleLoggedIn(uLink.BitStream stream, LobbyMessageInfo info)
{
RoleInfoProxy role = stream.Read <RoleInfoProxy>();
m_RolesInLobby.RemoveAll(iter => iter.steamId == role.steamId);
m_RolesInLobby.Add(role);
}
IEnumerator ClientArtifactEquip(int itemId, LobbyMessageInfo info)
{
LobbyPlayer player = LobbyServer.GetLobbyPlayer(info);
// Wait for all actions to execute
while (player.artifactsEditingFlag)
{
yield return(null);
}
try {
var arti = new Artifact(itemId);
player.artifactsEditingFlag = true;
if (player.artifactTree.AddArtifact(itemId))
{
player.artifactInventory.RemoveArtifact(arti);
Lobby.RPC("ArtifactEquip", player.peer, itemId);
// Save changes
yield return(ArtifactsDB.SetArtifactTree(
player,
player.artifactTree
));
yield return(ArtifactsDB.SetArtifactInventory(
player,
player.artifactInventory
));
}
} finally {
player.artifactsEditingFlag = false;
}
}
IEnumerator ClientArtifactDiscard(byte level, byte slotId, LobbyMessageInfo info)
{
LobbyPlayer player = LobbyServer.GetLobbyPlayer(info);
// Wait for all actions to execute
while (player.artifactsEditingFlag)
{
yield return(null);
}
try {
player.artifactsEditingFlag = true;
player.artifactInventory.bags[level].RemoveItemSlot(slotId);
Lobby.RPC("ArtifactDiscard", player.peer, level, slotId);
// Save changes
yield return(ArtifactsDB.SetArtifactTree(
player,
player.artifactTree
));
yield return(ArtifactsDB.SetArtifactInventory(
player,
player.artifactInventory
));
} finally {
player.artifactsEditingFlag = false;
}
}
void RPC_L2C_CloseServer(uLink.BitStream stream, LobbyMessageInfo info)
{
string msg = stream.Read <string>();
MessageBox_N.CancelMask(MsgInfoType.ServerDeleteMask);
MessageBox_N.ShowOkBox(msg);
}
IEnumerator PlayerNameChange(string newName, LobbyMessageInfo info)
{
// Prettify to be safe
newName = newName.PrettifyPlayerName();
// Validate data
if (!Validator.playerName.IsMatch(newName))
{
LogManager.General.LogError("Player name is not valid: '" + newName + "'");
yield break;
}
// Check if name exists already
yield return(LobbyGameDB.GetAccountIdByPlayerName(newName, data => {
if (data != null)
{
Lobby.RPC("PlayerNameAlreadyExists", info.sender, newName);
}
else
{
// Get the account
LobbyPlayer player = GetLobbyPlayer(info);
// Change name
LogManager.General.Log("Account " + player.accountId + " has requested to change its player name to '" + newName + "'");
LobbyGameDB.SetPlayerName(player, newName);
}
}));
}
void RequestGameServerInfo(LobbyMessageInfo info)
{
LobbyPlayer player = GetLobbyPlayer(info);
Lobby.RPC("ReceiveServerType", player.peer, player.gameInstance.serverType);
Lobby.RPC("LoadMap", player.peer, player.gameInstance.mapName);
}
void Ready(LobbyMessageInfo info)
{
LobbyPlayer player = GetLobbyPlayer(info);
LogManager.General.Log(string.Format("Player '{0}' is now ready after logging in, connecting him to town", player.name));
// Return player to his location in the game world
LocationsDB.GetLocation(player.accountId, (data) => {
// If that's the first time logging in, set the location to the default map
if (data == null)
{
data = new PlayerLocation(MapManager.startingMap, ServerType.World);
}
// This will connect the player to a new or existing server
// using the location data we just received.
player.location = data;
});
// Add player to chat channels
LobbyServer.globalChannel.AddPlayer(player);
LobbyServer.announceChannel.AddPlayer(player);
// Login message
SendSystemMessage(player, loginMessage);
}
void RPC_L2C_QueryLobbyExp(uLink.BitStream stream, LobbyMessageInfo info)
{
float exp = stream.Read <float> ();
float balance = stream.Read <float> ();
role.lobbyExp = exp;
AccountItems.self.balance = balance;
}
void RPC_L2C_RolesInLobby(uLink.BitStream stream, LobbyMessageInfo info)
{
RoleInfoProxy[] roles = stream.Read <RoleInfoProxy[]>();
m_RolesInLobby.Clear();
m_RolesInLobby.AddRange(roles);
Debug.Log("Roles In Lobby. Num:" + roles.Length);
}
void RPC_L2C_RepeatLogin(uLink.BitStream stream, LobbyMessageInfo info)
{
Disconnect();
MessageBox_N.ShowOkBox(PELocalization.GetString(8000041));
// if (null != LoginGui_N.Instance)
// LoginGui_N.Instance.HideMask();
}
void RPC_L2C_ShopData(uLink.BitStream stream, LobbyMessageInfo info)
{
LobbyShopData [] shopdata = stream.Read <LobbyShopData[]> ();
int startIndex = stream.Read <int> ();
int tabIndex = stream.Read <int> ();
LobbyShopMgr.AddRange(shopdata, startIndex, tabIndex);
}
IEnumerator ChangePassword(string newPassword, LobbyMessageInfo info)
{
// Get the account
var player = LobbyServer.GetLobbyPlayer(info);
// Change name
LogManager.General.Log("Player '" + player.name + "' has requested to change its password.");
yield return(StartCoroutine(LobbyGameDB.SetPassword(player, newPassword)));
}
void ClientInputSettings(string inputSettingsString, LobbyMessageInfo info)
{
LobbyPlayer player = LobbyServer.GetLobbyPlayer(info);
//LogManager.General.Log("Player '" + player.name + "' sent new input settings");
InputSettings inputSettings = Jboy.Json.ReadObject <InputSettings>(inputSettingsString);
SettingsDB.SetInputSettings(player, inputSettings);
}
void ClientArtifactTree(string jsonTree, LobbyMessageInfo info)
{
LobbyPlayer player = LobbyServer.GetLobbyPlayer(info);
//LogManager.General.Log(jsonTree);
ArtifactTree tree = Jboy.Json.ReadObject <ArtifactTree>(jsonTree);
LogManager.General.Log("Player '" + player.name + "' sent new artifact tree " + tree.ToString());
ArtifactsDB.SetArtifactTree(player, tree);
}
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);
}
void RPC_L2C_SyncInviteData(uLink.BitStream stream, LobbyMessageInfo info)
{
long [] serverUID = stream.Read <long[]> ();
ulong[] steamIds = stream.Read <ulong[]> ();
if (serverUID.Length > 0)
{
for (int i = 0; i < serverUID.Length; i++)
{
PeSteamFriendMgr.Instance.ReciveInvite(steamIds[i], serverUID[i]);
}
}
}
void RequestPlayerEmail(string accountId, LobbyMessageInfo info)
{
LogManager.General.Log("Requested mail for: " + accountId);
// Query email
LobbyGameDB.GetEmail(accountId, data => {
if (data != null)
{
Lobby.RPC("ReceivePlayerEmail", info.sender, accountId, data);
}
});
}
void RPC_L2C_SendMsg(uLink.BitStream stream, LobbyMessageInfo info)
{
/*EMsgType msgType = */ stream.Read <EMsgType>();
/*ulong steamId = */ stream.Read <ulong>();
string roleName = stream.Read <string>();
string msg = stream.Read <string>();
if (UILobbyMainWndCtrl.Instance != null && UILobbyMainWndCtrl.Instance.isShow)
{
UILobbyMainWndCtrl.Instance.AddTalk(roleName, msg);
}
}
void LeaveQueue(LobbyMessageInfo info)
{
LobbyPlayer player = LobbyServer.GetLobbyPlayer(info);
// Make the player leave the queue
if (player.LeaveQueue())
{
// Let the player know he left the queue
LogManager.General.Log("'" + player.name + "' left the queue");
Lobby.RPC("LeftQueue", player.peer);
}
}
void ResendActivationMail(string email, LobbyMessageInfo info)
{
LobbyGameDB.GetAccountAwaitingActivation(
email,
(token) => {
if (!string.IsNullOrEmpty(token))
{
SendActivationMail(email, token);
Lobby.RPC("ActivationMailSent", info.sender);
}
}
);
}
IEnumerator PlayerNameExists(string newName, LobbyMessageInfo info)
{
yield return(LobbyGameDB.GetAccountIdByPlayerName(newName, data => {
if (data != null)
{
Lobby.RPC("PlayerNameAlreadyExists", info.sender, newName);
}
else
{
Lobby.RPC("PlayerNameFree", info.sender, newName);
}
}));
}
void MailFeedback(string text, LobbyMessageInfo info)
{
LobbyPlayer player = GetLobbyPlayer(info);
LogManager.General.Log("Sending feedback mail from '" + player.name + "'...");
Mail.Send(
mailFeedbackReceiver,
"Feedback from '" + player.name + "'",
"E-Mail: " + player.account.name + "\n\n" + text,
player.account.name
);
}
void StaffInfoRequest(LobbyMessageInfo info)
{
LobbyPlayer player = GetLobbyPlayer(info);
// Access level check
if (player.accessLevel == AccessLevel.Player)
{
LogManager.General.LogWarning("Player '" + player.name + "' attempted to get staff information!");
return;
}
SendStaffInfo(player);
}
void ClientCharacterStats(CharacterStats charStats, LobbyMessageInfo info)
{
LobbyPlayer player = LobbyServer.GetLobbyPlayer(info);
if (!charStats.valid)
{
LogManager.General.LogWarning("Detected character stat points hack on player '" + player.name + "'");
return;
}
//LogManager.General.Log("Player '" + player.name + "' sent new character stats " + charStats.ToString());
TraitsDB.SetCharacterStats(player, charStats);
}
void RPC_L2C_BuyItems(uLink.BitStream stream, LobbyMessageInfo info)
{
int itemType = stream.Read <int> ();
int amount = stream.Read <int> ();
float balance = stream.Read <float> ();
if (AccountItems.self != null)
{
AccountItems.self.AddItems(itemType, amount);
AccountItems.self.balance = balance;
UIMallWnd.Instance.SetMyBalance((int)balance);
UILobbyShopItemMgr._self.MallItemEvent(0, UIMallWnd.Instance.mCurrentTab);
}
}
