public void Clear()
{
PlayerRemoved?.Invoke(this, new PlayerEventArgs(new Player()
{
Id = -1
}));
}
public void OnPlayerRemoved(Player player)
{
if (PlayerAdded != null)
{
PlayerRemoved.Invoke(player);
}
}
internal void RemovePlayer(Player player)
{
if (player.Id == 0)
{
Debug.LogWarning("Player disconnected with id 0. They probably didn't finish connecting");
}
else
{
Player oplayer;
_players.TryGetValue(player.Id, out oplayer);
if (oplayer != player)
{
Debug.Log($"Finished removing player {player} over contention with id {player.Id}");
}
else
{
_players.Remove(player.Id);
PlayerCount--;
}
try
{
PlayerRemoved.Raise(player);
}
catch (Exception e)
{
Debug.LogException(e);
}
}
}
/// <summary>
/// Removes a player from this match and stops the required timers
/// </summary>
/// <param name="playerUid">Unique uid of this player</param>
/// <returns>true if a player was removed, false if no player was removed</returns>
public bool RemovePlayer(string playerUid)
{
var player = Players.FirstOrDefault(p => p.Uid == playerUid);
if (player != null)
{
Players.Remove(player);
PlayedPlayers.Remove(player);
if (Players.Count < 2)
{
StopMatch();
}
else
{
if (player.Status == PlayerStatus.Drawing)
{
StopSubRoundTimer();
}
else if (player.Status == PlayerStatus.Preparing)
{
StopPreparationTimer();
StopSubRoundTimer();
}
}
PlayerRemoved?.Invoke(this, new PlayerRemovedEventArgs(playerUid));
return(true);
}
return(false);
}
private void RemovePlayer(Player player)
{
if (player.Id == 0)
{
return;
}
//first need to inform the room, if there is one, of the player's disconnect.
//Otherwise a new player might obtain the id and send that to a new room before this message gets there
player.DisconnectOnRoom();
//this will clean up the player whether or not they actually finished being added.
lock (_players)
_players.Remove(player.Id);
Room.MovePlayerCount(this, player.CurrentRoomGuid, Guid.Empty);
//todo: anything else? this is run on disconnect
try
{
PlayerRemoved?.Invoke(player);
}
catch (Exception e) { Debug.LogException(e); }
}
/// <summary>
/// Removes a <see cref="PlayerManager" /> using their assigned ID
/// </summary>
/// <param name="playerId"></param>
public static void RemovePlayer(string playerId)
{
Players.Remove(playerId);
PlayerRemoved?.Invoke(playerId);
Logger.Debug("Removed player {@PlayerId}", playerId);
}
public void UpdateGame(UpdateResponseData data)
{
foreach (var mdlPlayer in data.players)
{
if (players.ContainsKey(mdlPlayer.id))
{
var pos = new Vector2(mdlPlayer.x, mdlPlayer.y);
players[mdlPlayer.id].UpdatePlayer(pos, mdlPlayer.r, mdlPlayer.s, mdlPlayer.h);
continue;
}
var player = new MdlPlayer(mdlPlayer.id, mdlPlayer.h);
players.Add(mdlPlayer.id, player);
NewPlayerSpawned?.Invoke(player);
}
var existingPlayers = players.Keys.ToList();
foreach (var playerId in existingPlayers)
{
if (data.players.Any(p => p.id == playerId))
{
continue;
}
players.Remove(playerId);
PlayerRemoved?.Invoke(playerId);
}
}
// Don't actually remove the player, just inform others they have left
public void RemovePlayer(Player player)
{
if (player != null && PlayerExists(player.Name))
{
PlayerRemoved?.Invoke(this, new PlayerEventArgs(player));
}
}
public void Handle(PlayerRemoved domainEvent)
{
var playerDtos = PlayerList.Where(p => p.PlayerId != domainEvent.PlayerId);
PlayerList = playerDtos;
TeamChest = domainEvent.NewTeamChestBalance;
}
public void HandleRemovePlayer(NetworkMessage msg)
{
MsgRemovePlayer rp = msg as MsgRemovePlayer;
var player = GetPlayerByID(rp.PlayerID);
if (player == null)
{
return;
}
PlayerList.Remove(player.PlayerID);
if (PlayerRemoved != null)
{
PlayerRemoved.Invoke(this, player);
}
if (player.IsLocalPlayer) //oh shit it's us!
{
Me = null;
if (SelfRemoved != null)
{
SelfRemoved.Invoke(this, player);
}
}
}
public void Handle(PlayerRemoved e)
{
lock (Players)
{
Players.RemoveAll(p => p.Id == e.Id);
}
}
internal void RemovePlayer(Player player)
{
if (player.Id != 0)
{
//first need to inform the room, if there is one, of the player's disconnect.
//Otherwise a new player might obtain the id and send that to a new room before this message gets there
player.DisconnectOnRoom();
//this will clean up the player whether or not they actually finished being added.
lock (_players)
{
_players.Remove(player.Id);
PlayerCount--;
}
Room.MovePlayerCount(this, player.CurrentRoomGuid, Guid.Empty);
}
//it is necessary that we still raise the event, in case users are doing something during verification
try
{
PlayerRemoved?.Invoke(player);
}
catch (Exception e) { Debug.LogException(e); }
}
public MessengerSet(GameHost host, IMessenger serverCommands, IMessenger serverBroadcast, IMessenger localPlayer, string localPlayerName)
{
Host = host;
ServerCommands = serverCommands;
ServerBroadcast = serverBroadcast;
LocalPlayer = localPlayer;
LocalPlayerName = localPlayerName;
var tmp = new ObservableCollection <IMessenger>();
tmp.CollectionChanged += (s, e) =>
{
if (e.NewItems != null)
{
foreach (IMessenger item in e.NewItems)
{
PlayerAdded?.Invoke(this, item);
}
}
if (e.OldItems != null)
{
foreach (IMessenger item in e.OldItems)
{
PlayerRemoved?.Invoke(this, item);
}
}
};
OtherPlayers = tmp;
}
public void Remove(ServerPlayer player)
{
lock (Members)
Members.Remove(player);
player.Info.Team = null;
PlayerRemoved?.Invoke(this, this);
}
// Don't actually remove the player, just inform others they have left
public void RemovePlayer(Player player)
{
if (player != null && PlayerExists(player.Name) && PlayerRemoved != null)
{
PlayerEventArgs pea = new PlayerEventArgs(player);
foreach (System.EventHandler <PlayerEventArgs> e in PlayerRemoved?.GetInvocationList())
{
Task.Run(() => e.Invoke(this, pea));
}
}
}
public DomainResult RemovePlayer(Guid playerId)
{
var playerReadModel = Players.Single(p => p.PlayerId == playerId);
var playerBuyConfig = AllowedPlayers.Single(ap => ap.PlayerTypeId.Equals(playerReadModel.PlayerTypeId));
var newTeamMoney = TeamMoney.Plus(playerBuyConfig.Cost);
var playerRemovedFromDraft = new PlayerRemoved(TeamId, playerId, newTeamMoney);
Apply(playerRemovedFromDraft);
return(DomainResult.Ok(playerRemovedFromDraft));
}
// Don't actually remove the player, just inform others they have left
public void RemovePlayer(Player player)
{
if (player != null && PlayerExists(player.Name) && PlayerRemoved != null)
{
PlayerEventArgs pea = new PlayerEventArgs(player);
foreach (System.EventHandler <PlayerEventArgs> e in PlayerRemoved?.GetInvocationList())
{
e.BeginInvoke(this, pea, e.EndInvoke, null);
}
}
}
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;
}
}
public void Clear()
{
if (PlayerRemoved != null)
{
PlayerEventArgs pea = new PlayerEventArgs(new Player()
{
Id = -1
});
foreach (System.EventHandler <PlayerEventArgs> e in PlayerRemoved?.GetInvocationList())
{
e.BeginInvoke(this, pea, e.EndInvoke, null);
}
}
}
public void Clear()
{
if (PlayerRemoved != null)
{
PlayerEventArgs pea = new PlayerEventArgs(new Player()
{
Id = -1
});
foreach (System.EventHandler <PlayerEventArgs> e in PlayerRemoved?.GetInvocationList())
{
Task.Run(() => e.Invoke(this, pea));
}
}
}
public void RemovePlayer(LobbyUserExtension playerExt)
{
var username = TryGetUsername(playerExt.Peer);
LobbyMember member;
Members.TryGetValue(username, out member);
// If this player was never in the lobby
if (member == null)
{
return;
}
Members.Remove(username);
MembersByPeerId.Remove(playerExt.Peer.Id);
if (playerExt.CurrentLobby == this)
{
playerExt.CurrentLobby = null;
}
// Remove member from it's current team
if (member.Team != null)
{
member.Team.RemoveMember(member);
}
// Change the game master
if (GameMaster == member)
{
PickNewGameMaster();
}
// Unsubscribe
playerExt.Peer.Disconnected -= OnPeerDisconnected;
Unsubscribe(playerExt.Peer);
// Notify player himself that he's removed
playerExt.Peer.SendMessage((short)MsfOpCodes.LeftLobby, Id);
OnPlayerRemoved(member);
if (PlayerRemoved != null)
{
PlayerRemoved.Invoke(member);
}
}
public bool DestroyPlayer(Guid playerId, DisconnectReason reason)
{
bool removed = connectedPlayers.Remove(playerId);
Console.WriteLine($"Player destroyed: {playerId}");
PlayerDisconnectedPacket playerDisconnectedPacket = new PlayerDisconnectedPacket(playerId, reason);
server.SendPacketToAll(playerDisconnectedPacket);
PlayerEventArgs playerEventArgs = new PlayerEventArgs(playerId);
PlayerRemoved?.Invoke(this, playerEventArgs);
return(removed);
}
public bool RemoveCharacter(Character character)
{
var success = Characters.TryRemove(character.Id, out character);
if (success)
{
PlayerRemoved?.Invoke(this, new CharacterArgs(character));
foreach (var otherPlayer in Characters.Values)
{
if (otherPlayer is Player)
{
(otherPlayer as Player).RemoveInRangeCharacter(character);
}
}
}
return(success);
}
private void OnPlayerRemoved(Player player)
{
PlayerRemoved?.Invoke(player);
foreach (var view in NetworkManager.AllViews)
{
if (view == null)
{
continue;
}
if (view.Owner == player)
{
view.Owner = player.CopyInvalid();
}
view.OnPlayerLeftRoom(player);
}
CleanupInvalidNetworkViewOwners();
}
/*********
** 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 UnregisterPlayer(Player player)
{
if (_players.Contains(player))
{
LogEx.Log <BattleSystem>("Unregistered player: '{0}'", player.name);
_players.Remove(player);
// TEMP!!!
UnregisterCharacter(player.ActiveCharacter);
if (PlayerRemoved != null)
{
PlayerRemoved.Invoke(player);
}
}
else
{
LogEx.LogError <BattleSystem>("Cannot unregister player '{0}' as they were never registered.", player.name);
}
}
internal void RemovePlayerNoNotify(Player player)
{
Debug.Log($"removing {player} from room, without notifying the room");
if (player.Id == 0)
{
return;
}
//this will clean up the player whether or not they actually finished being added.
lock (_players)
_players.Remove(player.Id);
Room.MovePlayerCount(this, player.CurrentRoomGuid, Guid.Empty);
//todo: anything else? this is run on disconnect
try
{
PlayerRemoved?.Invoke(player);
}
catch (Exception e) { Debug.LogException(e); }
}
public void RemovePlayerByName(string playerName)
{
var playerToRemove = Players.FirstOrDefault(p => p.Name.Equals(playerName, StringComparison.Ordinal));
if (playerToRemove == null)
{
return;
}
Players.Remove(playerToRemove);
foreach (var playerResult in PlayerResults.Where(p => p.PlayerId == playerToRemove.Id).ToList())
{
PlayerResults.Remove(playerResult);
}
foreach (var handicap in Handicaps.Where(p => p.PlayerId == playerToRemove.Id).ToList())
{
Handicaps.Remove(handicap);
}
PlayerRemoved?.Invoke();
}
public void RemovePlayer(Player p)
{
PlayerRemoved?.Invoke(p);
_playerDic.Remove(p.Id);
log.Debug("player removed " + p);
}
internal void InvokePlayerRemoved(int id)
{
PlayerRemoved?.Invoke(id);
}
