public bool AddToQueue(Guid playerId)
{
var success = PlayerWaitingQueue.AddToQueue(playerId);
if (success)
{
PlayerAdded?.Invoke(this, new EventArgs());
}
return(success);
}
private void OnLobbyNetworkReceived(NetPeer peer, NetDataReader dataReader)
{
NetMessage instruction = (NetMessage)dataReader.GetInt();
switch (instruction)
{
case NetMessage.ServerClosed:
OnServerClosed();
break;
case NetMessage.ClientsCount:
int count = dataReader.GetInt();
OnClientsCount(count);
break;
case NetMessage.AddPlayer:
PlayerAdded?.Invoke(this, new LobbyPlayerEventArgs()
{
PlayerID = dataReader.GetString(),
ControllerIndex = (PlayerControllerIndex)dataReader.GetInt()
});
break;
case NetMessage.RemovePlayer:
PlayerRemoved?.Invoke(this, new LobbyPlayerEventArgs()
{
PlayerID = dataReader.GetString()
});
break;
case NetMessage.PrepareToStartGame:
PreparingGameToStart?.Invoke(this, new LobbyOptionsArgs {
PlayersCount = dataReader.GetInt(),
Map = dataReader.GetInt(),
Biome = dataReader.GetInt(),
});
break;
case NetMessage.InstantiateCharacter:
InstantiateCharacter?.Invoke(this, new LobbyPlayerEventArgs {
PlayerID = dataReader.GetString(),
ControllerIndex = (PlayerControllerIndex)dataReader.GetInt(),
Type = (Pj.Type)dataReader.GetInt(),
X = dataReader.GetFloat(), Y = dataReader.GetFloat()
});
break;
case NetMessage.StartGame:
this.SetGameplay();
GameStarted?.Invoke(this, EventArgs.Empty);
break;
}
}
/// <summary>
/// send the player all the existing network views
/// </summary>
/// <param name="player"></param>
internal void SendViewInstantiates(Player player)
{
CleanupInvalidNetworkViewOwners();
try
{
PlayerAdded?.Invoke(player);
}
catch (Exception e)
{
Debug.LogException(e);
}
}
public void Add(ServerPlayer player)
{
lock (Members)
{
if (Members.Count == 0)
{
Wins = 0;
Losses = 0;
}
Members.Add(player);
}
player.Info.Team = this;
PlayerAdded?.Invoke(this, this);
}
public INetworkClient CreateLocalClient()
{
// TODO(james7132): Make this dynamic
var clientToServer = new LocalInterface();
var serverInterface = clientToServer.Mirror;
var serverToClient = serverInterface.Connection;
var localClient = new NetworkClientPlayer(serverToClient, LowestAvailablePlayerID(serverToClient));
localClient.Config.PlayerID = localClient.PlayerID;
clients[serverToClient] = localClient;
PlayerAdded?.Invoke(localClient);
AddNetworkInterface(serverInterface);
return(new NetworkGameClient(clientToServer.Connection));
}
public void AddPlayer(Player player)
{
if (PlayerAdded != null)
{
PlayerEventArgs pea = new PlayerEventArgs(player);
foreach (System.EventHandler <PlayerEventArgs> e in PlayerAdded?.GetInvocationList())
{
e.BeginInvoke(this, pea, e.EndInvoke, null);
}
}
if (!PlayerExists(player.Name))
{
characters.Add(player.Name, player);
}
}
public void AddPlayer(Player player)
{
if (PlayerAdded != null)
{
PlayerEventArgs pea = new PlayerEventArgs(player);
foreach (System.EventHandler <PlayerEventArgs> e in PlayerAdded?.GetInvocationList())
{
Task.Run(() => e.Invoke(this, pea));
}
}
if (!PlayerExists(player.Name))
{
characters.Add(player.Name, player);
charactersByGuid.Add(player.Guid, player);
}
}
internal void FinalizePlayerAdd(Player player)
{
if (player.Id == 0)
{
return;
}
//update the slot with the correct player.
lock (_players)
_players.Add(player.Id, player);
try
{
PlayerAdded?.Invoke(player);
}
catch (Exception e) { Debug.LogException(e); }
}
/*********
** Private methods
*********/
private static void OnUpdateTicked(object sender, EventArgs e)
{
if (!Context.IsWorldReady)
{
return;
}
var currentLength = MegaStorageMod.ModHelper.Multiplayer.GetConnectedPlayers().Count();
if (currentLength > _prevLength)
{
PlayerAdded?.Invoke(null, null);
}
else if (currentLength < _prevLength)
{
PlayerRemoved?.Invoke(null, null);
}
_prevLength = currentLength;
}
public void HandleAddPlayer(NetworkMessage msg)
{
MsgAddPlayer ap = msg as MsgAddPlayer;
if (!PlayerList.ContainsKey(ap.PlayerID))
{
if (LocalPlayerID == ap.PlayerID)
{
PlayerList.Add(ap.PlayerID, new LocalPlayer(null));
}
else
{
PlayerList.Add(ap.PlayerID, new Player());
}
}
Player player = PlayerList[ap.PlayerID];
player.PlayerID = ap.PlayerID;
player.Callsign = ap.Callsign;
player.Motto = ap.Motto;
player.PlayerType = (PlayerTypes)ap.PlayerType;
player.Team = ap.Team;
player.Wins = ap.Wins;
player.Losses = ap.Losses;
player.TeamKills = ap.TeamKills;
if (player.IsLocalPlayer) // hey it's us!
{
Me = player as LocalPlayer;
if (SelfAdded != null)
{
SelfAdded.Invoke(this, player);
}
}
if (PlayerAdded != null)
{
PlayerAdded.Invoke(this, player);
}
}
public string LoginPlayer(string guestId, string playerName)
{
var board = _hostService.GetBoardForGuest(guestId);
var game = Games.FirstOrDefault(x => x.BoardId == board.Id);
if (game == null)
{
return("Invalid Room Code");
}
else if (string.IsNullOrEmpty(playerName))
{
return("Name is required.");
}
else
{
lock (_loginLock)
{
var player = game.Players.FirstOrDefault(x => x.Name == playerName);
if (player != null)
{
return("Name is already taken.");
}
else if (game.Players.Count < game.MaxPlayers)
{
game.Players.Add(new Player {
Name = playerName
});
PlayerAdded?.Invoke(this, new GameChangedEventArgs
{
BoardId = board.Id,
Action = GameChangedEventActions.PlayerAdded,
PlayerIndex = game.Players.Count - 1
});
}
}
return(null);
}
}
private void OnPlayerAdded(List <PlayerDto> players)
{
PlayerAdded?.Invoke(this, players);
}
public void AddPlayer(Player player)
{
_players.Add(player);
PlayerAdded?.Invoke(player);
}
public void Apply(PlayerAdded playerAdded)
{
_players.Add(new Player(playerAdded.PlayerId, playerAdded.PlayerName));
}
public bool AddPlayer(LobbyUserExtension playerExt, out string error)
{
error = null;
if (playerExt.CurrentLobby != null)
{
error = "You're already in a lobby";
return(false);
}
var username = TryGetUsername(playerExt.Peer);
if (username == null)
{
error = "Invalid username";
return(false);
}
if (Members.ContainsKey(username))
{
error = "Already in the lobby";
return(false);
}
if (IsDestroyed)
{
error = "Lobby is destroyed";
return(false);
}
if (!IsPlayerAllowed(username, playerExt))
{
error = "You're not allowed";
return(false);
}
if (Members.Values.Count >= MaxPlayers)
{
error = "Lobby is full";
return(false);
}
if (!Config.AllowJoiningWhenGameIsLive && State != LobbyState.Preparations)
{
error = "Game is already in progress";
return(false);
}
// Create an "instance" of the member
var member = CreateMember(username, playerExt);
// Add it to a team
var team = PickTeamForPlayer(member);
if (team == null)
{
error = "Invalid lobby team";
return(false);
}
if (!team.AddMember(member))
{
error = "Not allowed to join a team";
return(false);
}
Members[member.Username] = member;
MembersByPeerId[playerExt.Peer.Id] = member;
// Set this lobby as player's current lobby
playerExt.CurrentLobby = this;
if (GameMaster == null)
{
PickNewGameMaster(false);
}
Subscribe(playerExt.Peer);
playerExt.Peer.Disconnected += OnPeerDisconnected;
OnPlayerAdded(member);
if (PlayerAdded != null)
{
PlayerAdded.Invoke(member);
}
return(true);
}
protected virtual void OnPlayerAdded(Player player)
{
PlayerAdded?.Invoke(this, player);
_ghostObjectTimer.Start();
}
public void RaisePlayerAddedEvent(Entity entity)
{
PlayerAdded?.Invoke(entity);
}
internal void RaisePlayerAdded(PlayerState state)
{
Logger.Debug($"event {nameof(RaisePlayerAdded)}({state.Player.DisplayName})");
Core.Logger.Flush();
PlayerAdded?.Invoke(state);
}
protected override void PlayerNameConfimred(PlayerAdded obj)
{
player = obj.Player;
Events.Publish(new PlayerReady(obj.Player));
}
protected virtual void OnPlayerAdded(Player player)
{
PlayerAdded?.Invoke(this, player);
}
public void Apply(PlayerAdded evt) => Players.Add(evt.Name);
public void AddPlayer(PlayerInfo player)
{
Players.Add(player);
PlayerAdded?.Invoke(player);
}
public static void HandlePackage(byte[] package, int playerId = -1)
{
try
{
IncomingGameEvent gameEvent;
Debug.Log((IncomingGameEventTypes)package[0]);
switch ((IncomingGameEventTypes)package[0])
{
case IncomingGameEventTypes.CirclesFrameUpdate:
gameEvent = new CirclesFrameUpdate(package);
break;
case IncomingGameEventTypes.RoundStarted:
gameEvent = new RoundStarted(package);
break;
case IncomingGameEventTypes.PlayerAdded:
gameEvent = new PlayerAdded(package);
break;
case IncomingGameEventTypes.PlayerDied:
gameEvent = new PlayerDied(package);
break;
case IncomingGameEventTypes.RoundOver:
gameEvent = new RoundOver(package);
break;
case IncomingGameEventTypes.CirclesAdded:
gameEvent = new CirclesAdded(package);
break;
case IncomingGameEventTypes.CirclesRemoved:
gameEvent = new CirclesRemoved(package);
break;
case IncomingGameEventTypes.FoodAdded:
gameEvent = new FoodAdded(package);
break;
case IncomingGameEventTypes.FoodRemoved:
gameEvent = new FoodRemoved(package);
break;
case IncomingGameEventTypes.PlayerLeft:
gameEvent = new PlayerLeft(package);
break;
default:
throw new Exception(String.Format("Incorrect package type: {0}", (IncomingGameEventTypes)package[0]));
break;
}
GameManager.Instance.GameEvents.Enqueue(gameEvent);
}
catch (Exception e)
{
Debug.LogError(e.Message);
}
}
