/// <summary>
/// Set your avatar to a new id
/// </summary>
/// <param name="avatarID">Next avatar id</param>
public void SetAvatar(int avatarID)
{
IClientMockPlayer player = GetClientMockPlayer(networkObject.MyPlayerId);
player.AvatarID = avatarID;
networkObject.SendRpc(RPC_ASSIGN_AVATAR, Receivers.All, networkObject.MyPlayerId, avatarID);
}
private void SetupComplete()
{
LobbyService.Instance.SetLobbyMaster(this);
LobbyService.Instance.Initialize(NetworkManager.Instance.Networker);
//If I am the host, then I should show the kick button for all players here
LobbyPlayerItem item = GetNewPlayerItem(); //This will just auto generate the 10 items we need to start with
item.SetParent(Grid);
PutBackToPool(item);
_myself = GrabPlayer(LobbyService.Instance.MyMockPlayer);
if (!LobbyPlayers.Contains(_myself))
{
LobbyPlayers.Add(_myself);
}
Myself.Init(this);
Myself.Setup(_myself, true);
List <IClientMockPlayer> currentPlayers = LobbyService.Instance.MasterLobby.LobbyPlayers;
for (int i = 0; i < currentPlayers.Count; ++i)
{
IClientMockPlayer currentPlayer = currentPlayers[i];
if (currentPlayer == _myself)
{
continue;
}
OnFNPlayerConnected(currentPlayers[i]);
}
}
public void OnFNLobbyMasterKnowledgeTransfer(ILobbyMaster previousLobbyMaster)
{
LobbyPlayers.Clear();
LobbyPlayersMap.Clear();
LobbyTeams.Clear();
for (int i = 0; i < previousLobbyMaster.LobbyPlayers.Count; ++i)
{
IClientMockPlayer player = previousLobbyMaster.LobbyPlayers[i];
LobbyPlayers.Add(player);
LobbyPlayersMap.Add(player.NetworkId, player);
}
IEnumerator iter = previousLobbyMaster.LobbyTeams.GetEnumerator();
iter.Reset();
while (iter.MoveNext())
{
if (iter.Current != null)
{
KeyValuePair <int, List <IClientMockPlayer> > kv =
(KeyValuePair <int, List <IClientMockPlayer> >)iter.Current;
LobbyTeams.Add(kv.Key, kv.Value);
}
else
{
break;
}
}
foreach (KeyValuePair <int, List <IClientMockPlayer> > kv in previousLobbyMaster.LobbyTeams)
{
LobbyTeams.Add(kv.Key, kv.Value);
}
}
private LobbyPlayer GrabPlayer(IClientMockPlayer player)
{
LobbyPlayer returnValue = player as LobbyPlayer;
if (returnValue == null)
{
for (int i = 0; i < LobbyPlayers.Count; ++i)
{
if (LobbyPlayers[i].NetworkId == player.NetworkId)
{
LobbyPlayer tPlayer = LobbyPlayers[i] as LobbyPlayer;
if (tPlayer == null)
{
tPlayer = new LobbyPlayer();
tPlayer.Name = player.Name;
tPlayer.NetworkId = player.NetworkId;
LobbyPlayers[i] = tPlayer;
}
returnValue = tPlayer;
returnValue.Name = player.Name;
break;
}
}
if (returnValue == null)
{
returnValue = new LobbyPlayer();
returnValue.Name = player.Name;
returnValue.NetworkId = player.NetworkId;
}
}
return(returnValue);
}
public void OnFNTeamChanged(IClientMockPlayer player, int newId)
{
if (!LobbyTeams.ContainsKey(newId))
{
LobbyTeams.Add(newId, new List <IClientMockPlayer>());
}
//We do this to not make Foreach loops
IEnumerator iter = LobbyTeams.GetEnumerator();
iter.Reset();
while (iter.MoveNext())
{
if (iter.Current != null)
{
KeyValuePair <int, List <IClientMockPlayer> > kv = (KeyValuePair <int, List <IClientMockPlayer> >)iter.Current;
if (kv.Value.Contains(player))
{
kv.Value.Remove(player);
break;
}
}
else
{
break;
}
}
//We prevent the player being added twice to the same team
if (!LobbyTeams[newId].Contains(player))
{
LobbyTeams[newId].Add(player);
}
}
public void OnFNPlayerDisconnected(IClientMockPlayer player)
{
if (LobbyPlayers.Contains(player))
{
LobbyPlayers.Remove(player);
LobbyPlayersMap.Remove(player.NetworkId);
}
}
public void OnFNPlayerConnected(IClientMockPlayer player)
{
if (!LobbyPlayers.Contains(player))
{
LobbyPlayers.Add(player);
LobbyPlayersMap.Add(player.NetworkId, player);
}
}
/// <summary>
/// Sets your team id
/// </summary>
/// <param name="teamId">The new team id</param>
public void SetTeamId(int teamId)
{
IClientMockPlayer player = GetClientMockPlayer(networkObject.MyPlayerId);
player.TeamID = teamId;
// TODO: When someone joins they need to get the current players selections
networkObject.SendRpc(RPC_ASSIGN_TEAM, Receivers.All, networkObject.MyPlayerId, teamId);
}
/// <summary>
/// Assigns a new name for yourself
/// </summary>
/// <param name="newName">The next name you will be referred as</param>
public void SetName(string newName)
{
IClientMockPlayer player = GetClientMockPlayer(networkObject.MyPlayerId);
player.Name = newName;
networkObject.SendRpc(RPC_ASSIGN_NAME,
true,
Receivers.All,
newName,
networkObject.MyPlayerId);
}
public void OnFNPlayerConnected(IClientMockPlayer player)
{
LobbyPlayer convertedPlayer = GrabPlayer(player);
if (convertedPlayer == _myself || _myself == null)
{
return; //Ignore re-adding ourselves
}
bool playerCreated = false;
for (int i = 0; i < _lobbyPlayersPool.Count; ++i)
{
if (_lobbyPlayersPool[i].AssociatedPlayer.NetworkId == player.NetworkId)
{
playerCreated = true;
}
}
playerCreated = convertedPlayer.Created;
if (playerCreated)
{
return;
}
convertedPlayer.Created = true;
if (!LobbyPlayers.Contains(convertedPlayer))
{
_lobbyPlayers.Add(convertedPlayer);
}
if (_lobbyPlayersMap.ContainsKey(convertedPlayer.NetworkId))
{
_lobbyPlayersMap[convertedPlayer.NetworkId] = convertedPlayer;
}
else
{
_lobbyPlayersMap.Add(convertedPlayer.NetworkId, convertedPlayer);
}
OnFNTeamChanged(convertedPlayer);
MainThreadManager.Run(() =>
{
LobbyPlayerItem item = GetNewPlayerItem();
item.Setup(convertedPlayer, false);
if (LobbyService.Instance.IsServer)
{
item.KickButton.SetActive(true);
}
item.SetParent(Grid);
});
}
public void OnFNTeamChanged(IClientMockPlayer player)
{
int newID = player.TeamID;
if (!LobbyTeams.ContainsKey(newID))
{
LobbyTeams.Add(newID, new List <IClientMockPlayer>());
}
//We do this to not make Foreach loops
IEnumerator iter = LobbyTeams.GetEnumerator();
iter.Reset();
while (iter.MoveNext())
{
if (iter.Current != null)
{
KeyValuePair <int, List <IClientMockPlayer> > kv = (KeyValuePair <int, List <IClientMockPlayer> >)iter.Current;
if (kv.Value.Contains(player))
{
kv.Value.Remove(player);
break;
}
}
else
{
break;
}
}
//We prevent the player being added twice to the same team
if (!LobbyTeams[newID].Contains(player))
{
LobbyPlayer convertedPlayer = player as LobbyPlayer;
convertedPlayer.TeamID = newID;
if (_myself == convertedPlayer)
{
Myself.ChangeTeam(newID);
}
else
{
LobbyPlayerItem item = GrabLobbyPlayerItem(convertedPlayer);
if (item != null)
{
item.ChangeTeam(newID);
}
}
LobbyTeams[newID].Add(player);
}
}
private LobbyPlayerItem GrabLobbyPlayerItem(IClientMockPlayer player)
{
LobbyPlayerItem returnValue = null;
for (int i = 0; i < _lobbyPlayersPool.Count; ++i)
{
if (_lobbyPlayersPool[i].AssociatedPlayer.NetworkId == player.NetworkId)
{
returnValue = _lobbyPlayersPool[i];
}
}
return(returnValue);
}
protected override void NetworkStart()
{
base.NetworkStart();
if (networkObject.IsServer)
{
Destroy(controller);
networkObject.Time = 10;
}
mockPlayer = LobbyService.Instance.MyMockPlayer;
GameGUI.INSTANCE.Player1Name.text = mockPlayer.Name;
id = networkObject.MyPlayerId;
Debug.Log("Usuario:" + id + " Nombre: " + mockPlayer.Name + " mockid: " + mockPlayer.NetworkId + " isOwner:" + networkObject.IsOwner);
currentPlayers = LobbyService.Instance.MasterLobby.LobbyPlayers;
}
public void OnFNAvatarIDChanged(IClientMockPlayer player, int newID)
{
LobbyPlayer convertedPlayer = GrabPlayer(player);
convertedPlayer.AvatarID = newID;
if (_myself == convertedPlayer)
{
Myself.ChangeAvatarID(convertedPlayer.AvatarID);
}
else
{
LobbyPlayerItem item = GrabLobbyPlayerItem(convertedPlayer);
item.ChangeAvatarID(convertedPlayer.AvatarID);
}
}
public void OnFNPlayerNameChanged(IClientMockPlayer player)
{
LobbyPlayer convertedPlayer = GrabPlayer(player);
convertedPlayer.Name = player.Name;
if (_myself == convertedPlayer)
{
Myself.ChangeName(convertedPlayer.Name);
}
else
{
LobbyPlayerItem item = GrabLobbyPlayerItem(convertedPlayer);
item.ChangeName(convertedPlayer.Name);
}
}
private IClientMockPlayer GetClientMockPlayer(uint playerId)
{
IClientMockPlayer targetPlayer = null;
if (MasterLobby != null)
{
for (int i = 0; i < MasterLobby.LobbyPlayers.Count; ++i)
{
if (MasterLobby.LobbyPlayers[i].NetworkId == playerId)
{
targetPlayer = MasterLobby.LobbyPlayers[i];
break;
}
}
}
return(targetPlayer);
}
private void PlayerConnected(NetworkingPlayer player, NetWorker sender)
{
//Logging.BMSLog.Log("GG: " + player.Ip);
player.Name = "Player " + player.NetworkId;
networkObject.SendRpc(RPC_PLAYER_JOINED, Receivers.All, player.NetworkId);
sender.IteratePlayers((p) => {
if (p == player)
{
return;
}
networkObject.SendRpc(player, RPC_PLAYER_JOINED, p.NetworkId);
IClientMockPlayer cPlayer = MasterLobby.LobbyPlayers.First(l => l.NetworkId == p.NetworkId);
networkObject.SendRpc(player, RPC_PLAYER_SYNC, p.NetworkId, cPlayer.Name, cPlayer.TeamID,
cPlayer.AvatarID);
});
}
public void OnFNPlayerDisconnected(IClientMockPlayer player)
{
LobbyPlayer convertedPlayer = GrabPlayer(player);
MainThreadManager.Run(() =>
{
if (LobbyPlayers.Contains(convertedPlayer))
{
_lobbyPlayers.Remove(convertedPlayer);
_lobbyPlayersMap.Remove(convertedPlayer.NetworkId);
LobbyPlayerItem item = GrabLobbyPlayerItem(convertedPlayer);
if (item != null)
{
PutBackToPool(item);
}
}
});
}
private void SyncAllPlayers(RpcArgs args)
{
if (networkObject.IsServer)
{
for (int i = 0; i < MasterLobby.LobbyPlayers.Count; i++)
{
networkObject.Networker.IteratePlayers((player) =>
{
IClientMockPlayer lobbyPlayer = MasterLobby.LobbyPlayers.First(x => x.NetworkId == player.NetworkId);
if (player == MasterLobby.LobbyPlayers[i])
{
return;
}
networkObject.SendRpc(networkObject.Networker.Players[i], RPC_PLAYER_JOINED, player.NetworkId);
networkObject.SendRpc(networkObject.Networker.Players[i], RPC_PLAYER_SYNC, player.NetworkId, lobbyPlayer.Name, lobbyPlayer.TeamID, lobbyPlayer.AvatarID);
});
}
}
}
public void OnFNPlayerSync(IClientMockPlayer player)
{
OnFNAvatarIDChanged(player);
OnFNTeamChanged(player);
OnFNPlayerNameChanged(player);
}
public void OnFNAvatarIDChanged(IClientMockPlayer player)
{
//We don't care about the avatar id change because we are a dummy class
}
public void OnFNLobbyPlayerMessageReceived(IClientMockPlayer player, string message)
{
LobbyPlayer convertedPlayer = GrabPlayer(player);
Chatbox.text += string.Format("{0}: {1}\n", convertedPlayer.Name, message);
}
public void OnFNPlayerNameChanged(IClientMockPlayer player)
{
//We don't care about the name change since we are a dummy class
}
public void OnFNLobbyPlayerMessageReceived(IClientMockPlayer player, string message)
{
//We ignore all messages we have received from other players because we are a dummy class
}
public void PlayerConnected(IClientMockPlayer player)
{
//Logging.BMSLog.Log("SEVERRRR: " + player.NetworkId);
player.Name = "Player " + player.NetworkId;
networkObject.SendRpc("PlayerJoined", Receivers.AllBuffered, player.NetworkId);
}
public void OnFNPlayerSync(IClientMockPlayer player)
{
//We dont care about this because we are a dummy class
}
