private void UpdateConnectionsList(NetConnection connection, NetConnectionStatus status)
{
if (status == NetConnectionStatus.Connected)
{
string name = connection.RemoteHailMessage.ReadString();
Output(name + " @" + connection.RemoteEndPoint + " has connected");
ConnectionInfo info = new ConnectionInfo {
Name = name, Connection = connection
};
_connectionInfoList.Add(info);
if (PlayerJoined != null)
{
PlayerJoined.Invoke(info, null);
}
}
else if (status == NetConnectionStatus.Disconnected)
{
ConnectionInfo info = _connectionInfoList.Find((x) => { return(x.Connection == connection); });
Output(info.Name + " @" + connection.RemoteEndPoint + " has disconnected");
_connectionInfoList.Remove(info);
if (PlayerLeft != null)
{
PlayerLeft.Invoke(info, null);
}
// _connectionInfoList.RemoveAll((x)=> { return x.Connection == connection;});
}
}
/// <summary>
/// Checks if access token is valid
/// </summary>
/// <param name="token"></param>
/// <param name="peer"></param>
/// <returns></returns>
public bool ValidateAccess(string token, out IPeer peer)
{
_unconfirmedAccesses.TryGetValue(token, out var data);
peer = null;
// If there's no data
if (data == null)
{
return(false);
}
// Remove unconfirmed
_unconfirmedAccesses.Remove(token);
// If player is no longer connected
if (!data.Peer.IsConnected)
{
return(false);
}
// Set access as used
_accessesInUse.Add(data.Peer.Id, data.Access);
peer = data.Peer;
// Invoke the event
PlayerJoined?.Invoke(peer);
return(true);
}
private PlayerAstronautController AddPlayer(Rewired.Player rewiredPlayer)
{
Transform spawnPoint = _spawnPoints[_nextSpawnIndex];
PlayerAstronautController astroPlayer = Instantiate(_playerPrefab, transform);
astroPlayer.RewiredPlayer = rewiredPlayer;
astroPlayer.transform.position = spawnPoint.transform.position;
astroPlayer.transform.rotation = Quaternion.Euler(0, Random.value * 360, 0);
_players.Add(astroPlayer);
_nextSpawnIndex = (_nextSpawnIndex + 1) % _spawnPoints.Length;
// Set joined state
if (rewiredPlayer != null)
{
while (_playerJoinedStates.Count <= rewiredPlayer.id)
{
_playerJoinedStates.Add(false);
}
_playerJoinedStates[rewiredPlayer.id] = true;
}
PlayerJoined?.Invoke(astroPlayer);
return(astroPlayer);
}
private IEnumerator InvokePlayerJoinedMethod(int actorNumber)
{
if (debug)
{
Debug.Log("[StartMenuController] InvokePlayerJoinedMethod IEnumerator called");
}
yield return(new WaitForSeconds(1.0f));
var i = 0;
for (; i < PlayerNumbering.SortedPlayers.Length; i++)
{
if (actorNumber == PlayerNumbering.SortedPlayers[i].ActorNumber)
{
break;
}
}
PlayerJoined?.Invoke(i);
if (debug)
{
Debug.Log("[StartMenuController] PlayerJoined invoked");
}
SetCamera?.Invoke(i);
if (debug)
{
Debug.Log("[StartMenuController] SetCamera invoked");
}
GameCanStart?.Invoke();
}
internal async Task PlayerJoinedNotification(PlayerJoinedNotification notification)
{
if (PlayerJoined != null)
{
await PlayerJoined?.Invoke(notification);
}
}
internal virtual void OnPlayerJoined(RoomPlayerEventArgs e)
{
if (Disposed)
{
return;
}
PlayerJoined?.Invoke(this, e);
RoomManager.Channel.BroadcastCencored(new RoomChangeRoomInfoAck2Message(GetRoomInfo()));
}
protected void RaiseClientJoined(ulong steamId)
{
var vm = new PlayerViewModel(steamId)
{
State = ConnectionState.Connected
};
_log.Info($"Player {vm.Name} joined ({vm.SteamId})");
Players.Add(steamId, vm);
PlayerJoined?.Invoke(vm);
}
/// <summary>
/// Initialize the game to be played offline
/// </summary>
private void LocalPlaySetup()
{
mainMenu.Deactivation();
playMenu.Deactivation();
//welcomeMessageText.text = messages[1];
OfflinePlayReady?.Invoke();
PlayerJoined?.Invoke(0);
}
protected virtual void OnPlayerJoined(UnetMsfPlayer player)
{
// Add to lookups
PlayersByPeerId[player.PeerId] = player;
PlayersByUsername[player.Username] = player;
PlayersByConnectionId[player.Connection.connectionId] = player;
if (PlayerJoined != null)
{
PlayerJoined.Invoke(player);
}
}
private void UserAccepted(ulong steamId)
{
typeof(MyDedicatedServerBase).GetMethod("UserAccepted", BindingFlags.NonPublic | BindingFlags.Instance).Invoke(MyMultiplayer.Static, new object[] { steamId });
var vm = new PlayerViewModel(steamId)
{
State = ConnectionState.Connected
};
Log.Info($"Player {vm.Name} joined ({vm.SteamId})");
Players.Add(steamId, vm);
PlayerJoined?.Invoke(vm);
}
private void PlayerConnected(long playerId)
{
MyAPIGateway.Utilities.InvokeOnGameThread(() =>
{
Refresh();
PlayerAuxData aux;
if (_playerById.TryGetValue(playerId, out aux) && aux.RealPlayer != null)
{
PlayerJoined?.Invoke(aux.RealPlayer);
}
});
}
private void UserAccepted(ulong steamId)
{
UserAcceptedImpl.Invoke((MyDedicatedServerBase)MyMultiplayer.Static, steamId);
var vm = new PlayerViewModel(steamId)
{
State = ConnectionState.Connected
};
Log.Info($"Player {vm.Name} joined ({vm.SteamId})");
Players.Add(steamId, vm);
PlayerJoined?.Invoke(vm);
}
internal void Join(TAccountModel player)
{
if (player.RoomToken != null)
{
return;
}
if (Players.Count < MaxPlayerCount && !_gameStarted)
{
player.RoomToken = RoomToken;
Players.Add(player);
PlayerJoined.Invoke(this, player);
}
}
public PlayerCollection()
{
MyVisualScriptLogicProvider.PlayerConnected += PlayerConnected;
MyVisualScriptLogicProvider.PlayerDisconnected += PlayerDisconnected;
Refresh();
foreach (var p in _playerBySteamId.Values)
{
if (p.RealPlayer != null)
{
PlayerJoined?.Invoke(p.RealPlayer);
}
}
}
private void LocalPlaySetup()
{
localPlayButton.gameObject.SetActive(false);
onlinePlayButton.gameObject.SetActive(false);
createRoomButton.gameObject.SetActive(false);
joinRoomButton.gameObject.SetActive(false);
OfflinePlayReady?.Invoke();
PlayerJoined?.Invoke(0);
PlayerJoined?.Invoke(1);
PlayerJoined?.Invoke(2);
PlayerJoined?.Invoke(3);
}
private IEnumerator InformPlayerJoinedEndOfFrame(int actorNumber)
{
yield return(new WaitForSeconds(4f));
var i = 0;
for (; i < PlayerNumbering.SortedPlayers.Length; i++)
{
if (actorNumber == PlayerNumbering.SortedPlayers[i].ActorNumber)
{
break;
}
}
PlayerJoined?.Invoke(i);
}
public void Initialize(int playerID, Vector3 position, Quaternion rotation)
{
//spawned[playerID] = true;
var playerObject = Instantiate(playerPrefab, position, rotation, pool.parent);
playerObject.name = (playerObject.name + playerID);
PlayerController controller = playerObject.GetComponentInChildren <PlayerController>();
//if (controller == null)
//Debug.LogError("ERROR: Couldn't find PlayerController");
DamageableBehaviour initDamageable = playerObject.GetComponentInChildren <DamageableBehaviour>();
//if (initDamageable == null)
//Debug.LogError("ERROR: Couldn't find DamageableBehaviour");
controller.myID = playerID;
PoolablePlayer PlayerInit = new PoolablePlayer
{
movementController = controller,
damageableBehaviour = initDamageable
};
if (PlayerInit.DamageableConfig != null)
{
PlayerInit.DamageableConfig.playerID = playerID;
PlayerInit.DamageableConfig.AlignmentProvider = teams[playerID].alignment;
var meshRenderer = PlayerInit.DamageableConfig.materialObject.GetComponentInChildren <SkinnedMeshRenderer>();
if (meshRenderer != null)
{
meshRenderer.material = teams[playerID].material;
}
PlayerInit.DamageableConfig.IsAlive = true;
}
else
{
//Debug.LogError("No DamageableBehaviour component on player object");
}
PlayerJoined?.Invoke(playerID);
players.Add(PlayerInit);
}
private void PlayerConnected(long playerId)
{
MyAPIGateway.Utilities.InvokeOnGameThread(() =>
{
Refresh();
PlayerAuxData aux;
if (_playerById.TryGetValue(playerId, out aux) && aux.RealPlayer != null)
{
PlayerJoined?.Invoke(aux.RealPlayer);
}
else
{
ResearchCore.ResearchCore.LoggerStatic?.Warning(
$"Failed to find real player for connecting player {playerId}");
}
});
}
private IEnumerator SearchForActivateAvatar()
{
yield return(new WaitForSeconds(0.1f));
var i = 0;
while (i < AvatarToUserId.Length && AvatarToUserId[i] != "")
{
i++;
}
if (PhotonNetwork.IsMasterClient && !isGameStart)
{
AvatarToUserId[i] = PhotonNetwork.AuthValues.UserId;
mineQ = true;
PlayerJoined?.Invoke(i);
}
}
private IEnumerator ActivateClientAvatar(string userId)
{
yield return(new WaitForSeconds(0.1f));
var i = 0;
while (i < AvatarToUserId.Length && AvatarToUserId[i] != "")
{
i++;
}
if (!isGameStart)
{
AvatarToUserId[i] = userId;
PlayerJoined?.Invoke(i); //ActivateAvatar
}
photonView.RPC("initAvatarUserIdRPC", RpcTarget.Others, AvatarToUserId, userId);
}
private void EventReceivedHandler(object sender, EvmChainEventArgs e)
{
//Debug.Log("Event: " + e.EventName);
switch (e.EventName)
{
case "RoomCreated":
{
RoomCreatedEventData eventDto = e.DecodeEventDto <RoomCreatedEventData>();
this.eventActions.Enqueue(() => RoomCreated?.Invoke((Address)eventDto.Creator, eventDto.RoomId));
break;
}
case "PlayerJoined":
{
PlayerJoinedEventData eventDto = e.DecodeEventDto <PlayerJoinedEventData>();
this.eventActions.Enqueue(() => PlayerJoined?.Invoke(eventDto.RoomId, (Address)eventDto.Player));
break;
}
case "GameStageChanged":
{
GameStageChangedEventData eventDto = e.DecodeEventDto <GameStageChangedEventData>();
this.eventActions.Enqueue(() => GameStageChanged?.Invoke(eventDto.RoomId, eventDto.Stage));
break;
}
case "CurrentPlayerIndexChanged":
{
CurrentPlayerIndexChangedEventData eventDto = e.DecodeEventDto <CurrentPlayerIndexChangedEventData>();
this.eventActions.Enqueue(() => CurrentPlayerIndexChanged?.Invoke(eventDto.RoomId, eventDto.PlayerIndex, (Address)eventDto.PlayerAddress));
break;
}
case "PlayerDecisionReceived":
{
PlayerDecisionReceivedEventData eventDto = e.DecodeEventDto <PlayerDecisionReceivedEventData>();
this.eventActions.Enqueue(() => PlayerDecisionReceived?.Invoke(eventDto.RoomId, eventDto.PlayerIndex, (Address)eventDto.PlayerAddress, eventDto.PlayerDecision));
break;
}
}
}
private void OnDataReceived(object sender, string json)
{
Parameter parameter = JsonConvert.DeserializeObject <Parameter>(json);
if (parameter.ActionType == ActionType.UpdateGameboard && UpdateGameboard != null)
{
UpdateGameboard.Invoke(this, JsonConvert.DeserializeObject <UpdateGameboardParameter>(json));
}
else if (parameter.ActionType == ActionType.JoinRoom && PlayerJoined != null)
{
PlayerJoined.Invoke(this, EventArgs.Empty);
}
else if (parameter.ActionType == ActionType.LeaveRoom && PlayerLeft != null)
{
PlayerLeft.Invoke(this, EventArgs.Empty);
}
else if (parameter.ActionType == ActionType.StartGame && GameStarted != null)
{
GameStarted.Invoke(this, EventArgs.Empty);
}
}
static Server()
{
Events.GameLobby.Initialized.Subscribe(data =>
{
LobbyInitialized?.Invoke(null, System.EventArgs.Empty);
});
Events.ServerToClient.AddClient.Subscribe(data =>
{
if (G.Sys.NetworkingManager_.IsOnline_)
{
var eventArgs = new PlayerEventArgs(data.clientName_, data.ready_, (LevelCompatibility)data.status_);
PlayerJoined?.Invoke(null, eventArgs);
}
});
Events.ServerToClient.RemovePlayerFromClientList.Subscribe(data =>
{
var serverLogicObject = GameObject.Find("GameManager")?.GetComponent <ServerLogic>();
var clientLogic = serverLogicObject?.GetType().GetField("clientLogic_", BindingFlags.Instance | BindingFlags.NonPublic)?.GetValue(serverLogicObject) as ClientLogic;
var clientInfo = clientLogic?.GetPlayerInfo(data.playerIndex_);
if (clientInfo != null)
{
var eventArgs = new PlayerEventArgs(clientInfo.Username_, clientInfo.Ready_, (LevelCompatibility)clientInfo.LevelCompatabilityStatus_);
PlayerLeft?.Invoke(null, eventArgs);
}
});
Events.ServerToClient.SetGameMode.Subscribe(data =>
{
if (G.Sys.NetworkingManager_.IsOnline_)
{
var eventArgs = new GameModeChangedEventArgs(data.mode_);
GameModeChanged?.Invoke(null, eventArgs);
}
});
}
private IEnumerator SetWelcomeMessageAndSetReadyAtTheEndOfFrame()
{
yield return(new WaitForSeconds(1f));
var i = 0;
for (; i < PlayerNumbering.SortedPlayers.Length; i++)
{
if (PhotonNetwork.LocalPlayer.ActorNumber == PlayerNumbering.SortedPlayers[i].ActorNumber)
{
break;
}
}
OnlinePlayReady?.Invoke();
if (PhotonNetwork.IsMasterClient)
{
PlayerJoined?.Invoke(i);
}
PlayerSetup?.Invoke(i);
}
private IEnumerator InvokeRoomJoinedMethod()
{
//This is the actual method called in the connection process
if (debug)
{
Debug.Log("[StartMenuController] InvokeRoomJoinedMethod IEnumerator called");
}
yield return(new WaitForSeconds(1.0f));
var i = 0;
for (; i < PlayerNumbering.SortedPlayers.Length; i++)
{
if (PhotonNetwork.LocalPlayer.ActorNumber == PlayerNumbering.SortedPlayers[i].ActorNumber)
{
break;
}
}
OnlinePlayReady?.Invoke();
//Only the MasterClient should activate players
if (PhotonNetwork.IsMasterClient)
{
PlayerJoined?.Invoke(i);
GameCanStart?.Invoke();
}
if (debug)
{
Debug.Log("[StartMenuController] PlayerJoined invoked");
}
SetCamera?.Invoke(i);
if (debug)
{
Debug.Log("[StartMenuController] SetCamera invoked");
}
}
private IEnumerator InvokeRoomJoinedMethod()
{
yield return(new WaitForSeconds(0.1f));
var i = 0;
for (; i < PlayerNumbering.SortedPlayers.Length; i++)
{
if (PhotonNetwork.LocalPlayer.ActorNumber == PlayerNumbering.SortedPlayers[i].ActorNumber)
{
break;
}
}
Debug.Log("You are Actor : " + PhotonNetwork.LocalPlayer.ActorNumber + " \n You are controlling Avatar " + i);
OnlinePlayReady?.Invoke();
//Only the MasterClient should instantiate players
if (PhotonNetwork.IsMasterClient)
{
PlayerJoined?.Invoke(i);
}
}
private void talker_SpringEvent(object sender, Talker.SpringEventArgs e)
{
try
{
switch (e.EventType)
{
case Talker.SpringEventType.PLAYER_JOINED:
var entry = Context?.GetOrAddPlayer(e.PlayerName);
if (entry != null)
{
entry.IsIngame = true;
}
PlayerJoined?.Invoke(this, new SpringLogEventArgs(e.PlayerName));
break;
case Talker.SpringEventType.PLAYER_LEFT:
entry = Context?.GetOrAddPlayer(e.PlayerName);
if (entry != null)
{
entry.IsIngame = false;
entry.QuitTime = (int)DateTime.UtcNow.Subtract(Context.IngameStartTime ?? Context.StartTime).TotalSeconds;
}
if (e.Param == 0)
{
PlayerDisconnected?.Invoke(this, new SpringLogEventArgs(e.PlayerName));
}
PlayerLeft?.Invoke(this, new SpringLogEventArgs(e.PlayerName));
break;
case Talker.SpringEventType.GAME_LUAMSG:
HandleSpecialMessages(e);
break;
case Talker.SpringEventType.PLAYER_CHAT:
if (e.Param == 255)
{
HandleSpecialMessages(e);
}
else
{
AddToLogs(e);
}
if ((PlayerSaid != null) && !string.IsNullOrEmpty(e.PlayerName))
{
SpringChatLocation location = SpringChatLocation.Private;
if (((e.Param == Talker.TO_EVERYONE) || (e.Param == Talker.TO_EVERYONE_LEGACY)))
{
location = SpringChatLocation.Public;
}
if (e.Param == Talker.TO_ALLIES)
{
location = SpringChatLocation.Allies;
}
if (e.Param == Talker.TO_SPECTATORS)
{
location = SpringChatLocation.Spectators;
}
PlayerSaid(this, new SpringChatEventArgs(e.PlayerName, e.Text, location));
}
break;
case Talker.SpringEventType.PLAYER_DEFEATED:
MarkPlayerDead(e.PlayerName, true);
if (PlayerLost != null)
{
PlayerLost(this, new SpringLogEventArgs(e.PlayerName));
}
break;
case Talker.SpringEventType.SERVER_GAMEOVER:
if (!Context.GameEndedOk) // server gameover runs multiple times
{
foreach (var p in Context.ActualPlayers)
{
if (!p.IsIngame && !p.IsSpectator)
{
MarkPlayerDead(p.Name, true);
}
p.IsIngame = false;
}
// set victory team for all allied with currently alive
if (e.winningAllyTeams.Length > 0)
{
foreach (var ally in e.winningAllyTeams)
{
foreach (var p in Context.ActualPlayers.Where(x => !x.IsSpectator && (x.AllyNumber == ally)))
{
p.IsVictoryTeam = true;
}
}
}
else // Fallback, shouldn't happen
{
foreach (var p in Context.ActualPlayers.Where(x => !x.IsSpectator && (x.LoseTime == null)))
{
foreach (var q in Context.ActualPlayers.Where(x => !x.IsSpectator && (x.AllyNumber == p.AllyNumber)))
{
q.IsVictoryTeam = true;
}
}
}
if (Context.IngameStartTime != null)
{
Context.GameEndedOk = true;
Context.Duration = (int)DateTime.UtcNow.Subtract(Context.IngameStartTime ?? Context.StartTime).TotalSeconds;
GameOver?.Invoke(this, new SpringLogEventArgs(e.PlayerName));
}
else
{
Trace.TraceWarning("recieved GAMEOVER before STARTPLAYING!");
}
Task.Delay(10000).ContinueWith(x => ExitGame());
}
break;
case Talker.SpringEventType.PLAYER_READY:
if (e.Param == 1)
{
entry = Context.GetOrAddPlayer(e.PlayerName);
if (entry != null)
{
entry.IsIngameReady = true;
}
}
break;
case Talker.SpringEventType.SERVER_STARTPLAYING:
Context.ReplayName = e.ReplayFileName;
Context.EngineBattleID = e.GameID;
Context.IngameStartTime = DateTime.UtcNow;
Context.PlayersUnreadyOnStart = Context.ActualPlayers.Where(x => !x.IsSpectator && !(x.IsIngameReady && x.IsIngame)).Select(x => x.Name).ToList();
foreach (var p in Context.ActualPlayers.Where(x => !x.IsSpectator))
{
p.IsIngameReady = true;
}
process.PriorityClass = ProcessPriorityClass.High;
BattleStarted(this, Context);
break;
case Talker.SpringEventType.SERVER_QUIT:
if (LobbyStartContext != null)
{
foreach (var p in Context.ActualPlayers)
{
p.IsIngame = false;
}
}
//if (GameOver != null) GameOver(this, new SpringLogEventArgs(e.PlayerName));
break;
}
}
catch (Exception ex)
{
Trace.TraceError("Error processing spring message:{0}", ex);
}
}
protected virtual void OnPlayerJoined(ChannelPlayerJoinedEventArgs e)
{
PlayerJoined?.Invoke(this, e);
}
public static void InvokePlayerJoined(Player player)
{
PlayerJoined?.Invoke(player);
}
public void HandlePlayerJoin(Player player) => PlayerJoined?.Invoke(player);
