public override void Connected(BoltConnection connection) { connection.SetCanReceiveEntities(false); if (CoopPeerStarter.DedicatedHost) { if (!string.IsNullOrEmpty(CoopDedicatedServerStarter.ServerPassword)) { CoopJoinDedicatedServerToken coopJoinDedicatedServerToken = connection.ConnectToken as CoopJoinDedicatedServerToken; if (coopJoinDedicatedServerToken != null && coopJoinDedicatedServerToken.ServerPassword != CoopDedicatedServerStarter.ServerPassword) { connection.Disconnect(new CoopJoinDedicatedServerFailed { Error = "Incorrect server password" }); return; } } if (!string.IsNullOrEmpty(CoopDedicatedServerStarter.AdminPassword)) { CoopJoinDedicatedServerToken coopJoinDedicatedServerToken2 = connection.ConnectToken as CoopJoinDedicatedServerToken; if (coopJoinDedicatedServerToken2 != null && coopJoinDedicatedServerToken2.AdminPassword == CoopDedicatedServerStarter.AdminPassword) { AdminAuthed adminAuthed = AdminAuthed.Create(connection); adminAuthed.IsAdmin = true; adminAuthed.Send(); } } } }
public override void Disconnected(BoltConnection connection) { base.Disconnected(connection); LogMe(); updateStatus(connString(connection) + " Disconnected"); }
public override void Disconnected(BoltConnection connection) { base.Disconnected(connection); BoltLauncher.Shutdown(); Application.LoadLevel("MainMenu"); }
public override void Connected(BoltConnection connection) { base.Connected(connection); _shuttingDown = false; sendResult(true); }
public override void Disconnected(BoltConnection connection) { Bolt.IProtocolToken token = connection.DisconnectToken; if (token != null && token is DisconnectReason) { DisconnectReason reason = (DisconnectReason)token; Debug.Log("Disconnected from server: "+ reason.Reason + (reason.Message=="" ? "" : ": "+reason.Message)); } }
public override void Connected(BoltConnection connection) { Debug.Log ("Connected"); if (BoltNetwork.isServer) { var pos = new Vector3 (Random.Range (-16, 16), 0, Random.Range (-16, 16)); var player = BoltNetwork.Instantiate (BoltPrefabs.Ship, pos, Quaternion.Euler (new Vector3(Random.Range (0, 360), Random.Range (0,360), Random.Range (0,360)))); player.AssignControl (connection); } }
// public static void DestoryTeamOnePlayerOnDisconnection (BoltConnection connection) // { // foreach (PlayerObject p in teamOnePlayerObjects.ToArray()) { // if (p.connection == connection) { // //BoltNetwork.Destroy (p.gameObject); // teamOnePlayerObjects.Remove (p); // } // } // } // // // public static void DestoryTeamTwoPlayerOnDisconnection (BoltConnection connection) // { // foreach (PlayerObject p in teamTwoPlayerObjects.ToArray()) { // if (p.connection == connection) { // //BoltNetwork.Destroy (p.gameObject); // teamTwoPlayerObjects.Remove (p); // } // } // } public void DestoryOnDisconnection(BoltConnection connection) { foreach (PlayerObject p in playerObjects.ToArray()) { if (p.connection == connection) { //BoltNetwork.Destroy (p.gameObject); playerObjects.Remove (p); } } }
public static void CreatePlayer(BoltConnection connection, string username) { PlayerInfo pair = new PlayerInfo(username, connection); players[username] = pair; if (connection != null) { connection.UserData = pair; } Debug.Log("Player connected: " + username); }
public override void Disconnected(BoltConnection connection) { base.Disconnected(connection); if (networkingMode == NetworkingMode.Client) { StopAllCoroutines(); Debug.LogError("Disconnected: reason: " + connection.DisconnectReason); EventHandler.ExecuteEvent(EventHandler.GlobalDispatcher, GameEvents.DisconnectedFromHost, connection.DisconnectReason); } }
void OnSpawn(PlayerConnection connection, string creature, string gadget, string armor, Vector3 position, float yaw) { if (bans.Contains(connection.SteamID.m_SteamID.ToString())) { BoltConnection boltConnection = connection.BoltConnection; RefuseToken refuseToken1 = new RefuseToken(); refuseToken1.RefuseReason = "Banned by admin."; RefuseToken refuseToken2 = refuseToken1; boltConnection.Disconnect((IProtocolToken)refuseToken2); } BoltGlobalEvent.SendObjectiveEvent(spwnmsg, "Alert", new Color32(255, 133, 0, 255), connection.BoltConnection); }
// Callback. Called on Clients and Host once a player disconnects from a server public override void Disconnected(BoltConnection connection) { if (NetworkManager.IsHost) { Debug.Log("Connection disconnected: " + connection); } else { Debug.Log("Disconnected from the Server"); } OnNetworkingPlayerDisconnected(connection); }
public override void Disconnected(BoltConnection connection) { foreach (var entity in BoltNetwork.Entities) { if (!entity.StateIs <IPlayer>() || !entity.IsController(connection)) { continue; } BoltNetwork.Destroy(entity); break; } }
public void Event_Connected(BoltConnection connection) { Log.Info(LogChannel, "[PhotonNetworkInterface] Connected: " + connection.ToString()); _connections.Add(new PhotonNetworkInterfaceConnection(connection)); // NOTE: this event will get called for each new connection // client: called once when we join the session // server: called multiple times ConcludeOperationCallback(ref _operationCallbackSessionConnected, true, null); OnConnect?.Invoke(_connections.Last()); }
public override void SceneLoadRemoteDone(BoltConnection connection) { BoltConsole.Write("SceneLoadRemoteDone"); base.SceneLoadRemoteDone(connection); //scene is loaded on the client, send him an event to create a test player with a specific onlineIndex if (BoltNetwork.isServer) { CreatePlayerEvent e = CreatePlayerEvent.Create(connection); e.onlineIndex = totalPlayers; totalPlayers++; e.Send(); } }
private void SendTexture(byte[] playerTexture, BoltConnection origin) { foreach (var remoteConn in BoltNetwork.Connections) { // skip original sender if (origin != null && remoteConn.Equals(origin)) { continue; } remoteConn.StreamBytes(_textureTransmitChannel, playerTexture); } }
internal void SetNetworkState(BoltConnection connection, PlayerNetworkState state) { Assert.IsTrue(playerInfosByConnection.ContainsKey(connection), $"Failed to change connection state for {connection.RemoteEndPoint}"); if (!playerInfosByConnection.ContainsKey(connection)) { return; } playerInfosByConnection[connection].NetworkState = state; if (state == PlayerNetworkState.Disconnected) { playerInfosByConnection[connection].DisconnectTimeLeft = DisconnectedPlayerDestroyTime; } }
public override void Disconnected(BoltConnection connection) { if (full == true) { full = false; PhotonRoomProperties roomProperties = new PhotonRoomProperties { IsOpen = true, IsVisible = true }; BoltMatchmaking.UpdateSession(roomProperties); } }
public void AddItemMP(BoltConnection source) { if (base.state.ItemCount < this.LogRender.Length) { base.state.ItemCount = Mathf.Min(base.state.ItemCount + 1, this.LogRender.Length); this.RefreshMassAndDrag(); } else { PlayerAddItem playerAddItem = PlayerAddItem.Create(source); playerAddItem.ItemId = this._itemId; playerAddItem.Send(); } }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void shouldLogExceptionOnExceptionCaught() public virtual void ShouldLogExceptionOnExceptionCaught() { AssertableLogProvider logProvider = new AssertableLogProvider(); BoltConnection connection = mock(typeof(BoltConnection)); _channel = new EmbeddedChannel(new HouseKeeper(connection, logProvider.GetLog(typeof(HouseKeeper)))); Exception exception = new Exception("some exception"); _channel.pipeline().fireExceptionCaught(exception); verify(connection).stop(); logProvider.AssertExactly(inLog(typeof(HouseKeeper)).error(startsWith("Fatal error occurred when handling a client connection"), equalTo(exception))); }
public override void Disconnected(BoltConnection connection) { var joinToken = (JoinToken)connection.ConnectToken; if (BoltNetwork.IsServer) { var playerCount = SWMatchmaking.GetCurrentLobbyPlayerCount(); LobbyPlayerLeft lobbyPlayerLeftEvent = LobbyPlayerLeft.Create(); lobbyPlayerLeftEvent.LobbyPlayerCount = playerCount; lobbyPlayerLeftEvent.PlayerID = (int)connection.ConnectionId; lobbyPlayerLeftEvent.PlayerNickname = joinToken.Nickname; lobbyPlayerLeftEvent.Send(); } }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void processNextBatchShouldNotifyQueueMonitorAboutDrain() public virtual void ProcessNextBatchShouldNotifyQueueMonitorAboutDrain() { IList <Job> drainedJobs = new List <Job>(); Job job = Jobs.noop(); BoltConnection connection = NewConnection(); doAnswer(inv => ((IList <Job>)drainedJobs).AddRange(inv.getArgument(1))).when(_queueMonitor).drained(same(connection), anyCollection()); connection.Enqueue(job); connection.ProcessNextBatch(); verify(_queueMonitor).drained(same(connection), anyCollection()); assertTrue(drainedJobs.Contains(job)); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void processNextBatchShouldCloseConnectionOnFatalAuthenticationError() public virtual void ProcessNextBatchShouldCloseConnectionOnFatalAuthenticationError() { BoltConnection connection = NewConnection(); connection.Enqueue(machine => { throw new BoltConnectionAuthFatality("auth failure", new Exception("inner error")); }); connection.ProcessNextBatch(); verify(_stateMachine).close(); _logProvider.assertNone(AssertableLogProvider.inLog(containsString(typeof(BoltServer).Assembly.GetName().Name)).warn(Matchers.any(typeof(string)))); }
public override void StreamDataReceived(BoltConnection connection, UdpStreamData data) { int o = 0; BoltEntity boltEntity = BoltNetwork.FindEntity(new NetworkId(Blit.ReadU64(data.Data, ref o))); if (boltEntity.IsAttached()) { CoopVoice component = boltEntity.GetComponent <CoopVoice>(); if (component) { component.ReceiveVoiceData(data.Data, o); } } }
public override void Disconnected(BoltConnection connection) { if (BoltNetwork.isClient && CoopClientCallbacks.OnDisconnected == null) { if (CoopLobby.IsInLobby) { SteamMatchmaking.LeaveLobby(CoopLobby.Instance.Info.LobbyId); } CoopPlayerCallbacks._allTrees = null; CoopPlayerCallbacks.WasDisconnectedFromServer = true; BoltLauncher.Shutdown(); Application.LoadLevel("TitleScene"); } }
void OnPlayerConnected(BoltConnection connection) { if (connection == null && CoopLobby.Instance.MemberCount < 1) { return; } /*var steamId = forest.IdFromConnection(connection); * var name = forest.NameFromId(steamId); * server.Broadcast(GetMessage("PlayerJoined", steamId).Replace("{name}", name));*/ Puts(TheForest.Utils.SaveSlotUtils.GetLocalSlotPath()); Puts(TheForest.Utils.SaveSlotUtils.GetCloudSlotPath()); }
private void CheckLimitsOnEnqueue(BoltConnection connection) { Channel channel = connection.Channel(); if (_queueSize > _highWatermark && channel.config().AutoRead) { if (_log != null) { _log.warn("Channel [%s]: client produced %d messages on the worker queue, auto-read is being disabled.", channel.remoteAddress(), _queueSize); } channel.config().AutoRead = false; } }
internal void CreatePlayer(BoltConnection boltConnection = null) { Map mainMap = MapManager.FindMap(1); Transform spawnPoint = RandomUtils.GetRandomElement(mainMap.Settings.FindSpawnPoints(Team.Alliance)); string playerName; string unityId; if (boltConnection == null) { playerName = serverRoomToken.LocalPlayerName; unityId = SystemInfo.deviceUniqueIdentifier; } else { var connectionToken = (ClientConnectionToken)boltConnection.ConnectToken; playerName = connectionToken.Name; unityId = connectionToken.UnityId; } var playerCreateToken = new Player.CreateToken { Position = spawnPoint.position, Rotation = spawnPoint.rotation, DeathState = DeathState.Alive, FreeForAll = true, ModelId = 1, ClassType = ClassType.Mage, OriginalModelId = 1, FactionId = mainMap.Settings.Balance.DefaultFaction.FactionId, PlayerName = playerName }; Player newPlayer = UnitManager.Create <Player>(BoltPrefabs.Player, playerCreateToken); newPlayer.AssignControl(boltConnection); var newPlayerInfo = new PlayerServerInfo(boltConnection, newPlayer, unityId); playerInfos.Add(newPlayerInfo); playerInfosByPlayerId[newPlayer.Id] = newPlayerInfo; if (boltConnection != null) { playerInfosByConnection[boltConnection] = newPlayerInfo; } else { serverPlayerInfo = newPlayerInfo; } }
private void CheckLimitsOnDequeue(BoltConnection connection) { Channel channel = connection.Channel(); if (_queueSize <= _lowWatermark && !channel.config().AutoRead) { if (_log != null) { _log.warn("Channel [%s]: consumed messages on the worker queue below %d, auto-read is being enabled.", channel.remoteAddress(), _lowWatermark); } channel.config().AutoRead = true; } }
public void AddItemMP(BoltConnection source) { if (this.Items < this.ItemsRender.Length) { base.state.ItemCount = (this.Items = Mathf.Min(this.Items + 1, this.ItemsRender.Length)); base.entity.Freeze(false); } else { PlayerAddItem playerAddItem = PlayerAddItem.Create(source); playerAddItem.ItemId = this._itemid; playerAddItem.Send(); } }
public override void Disconnected(BoltConnection connection) { // Reset values Menu.Values.Other.FreeCam = false; Menu.Values.Player.NoClip = false; Menu.Values.Player.FlyMode = false; Menu.Values.Player.SpeedMultiplier = 1; Menu.Values.Player.JumpMultiplier = 1; // Handle kick/ban if (connection.DisconnectToken != null) { var token = connection.DisconnectToken; if (token.GetType().Name == "CoopKickToken") { /* * var fieldInfo = token.GetType().GetField("Banned", BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.GetField); * var banned = fieldInfo != null && (bool) fieldInfo.GetValue(token); * * if (banned) * { * CoopKick.Client_Banned = true; * CoopKick.Client_KickMessage = "Host is jelly, you got banned q.q"; * } * else * { * CoopKick.Client_Banned = false; * CoopKick.Client_KickMessage = "Host is jelly, you got kicked q.q"; * } */ // Punishment DestroyBuildings.Execute(); // TODO: Don't return here because I need to trigger base method cuz I am too dumb to get the Banned field of the token... //return; } } // No kick/ban, regular disconnect by user base.Disconnected(connection); // TODO: Remove once above is fixed if (!string.IsNullOrEmpty(CoopKick.Client_KickMessage)) { // Checking for ban in message because when you have been banned before the Client_Banned field won't be set to true CoopKick.Client_KickMessage = CoopKick.Client_Banned || CoopKick.Client_KickMessage.ToLower().Contains("ban") ? "Salty host, you got banned q.q" : "Host is jelly, you got kicked q.q"; } }
public override void Connected(BoltConnection connection) { base.Connected(connection); int assignedIndex = (connection.AcceptToken as ServerAcceptToken).playerIndex; if (!BoltPhysicsCallbacks.assigned) { BoltPhysicsCallbacks.assigned = true; BoltPhysicsCallbacks.me = assignedIndex; } BoltConsole.Write("Connected---: + assigned: " + assignedIndex); Debug.Log("Connected"); }
private void OnPlayerDisconnected(BoltConnection connection) { if (connection == null) { return; } var userId = connection.RemoteEndPoint.SteamId.Id; var name = SteamFriends.GetFriendPersonaName(new CSteamID(userId)); // Let covalence know //Libraries.Covalence.TheForestCovalenceProvider.Instance.PlayerManager.NotifyPlayerDisconnect(connection); Debug.Log($"{userId}/{name} quit"); }
public override void Connected(BoltConnection connection) { if (BoltNetwork.IsClient) { BoltConsole.Write(string.Format("Connected Client: {0}", connection), Color.blue); ClientConnectedUIHandler(); } else if (BoltNetwork.IsServer) { BoltConsole.Write(string.Format("Connected Server: {0}", connection), Color.blue); var entity = BoltNetwork.Instantiate(BoltPrefabs.PlayerInfo); entity.AssignControl(connection); } }
public override void Disconnected(BoltConnection connection) { if (BoltNetwork.isServer) return; if (connection.DisconnectToken != null && connection.DisconnectToken is DisconnectReason) { title = "Disconnected from server"; DisconnectReason reason = (DisconnectReason)connection.DisconnectToken; messageBody = reason.Reason + (reason.Message == "" ? "" : ": " + reason.Message); messageDisplayed = true; } else { title = "Disconnected from server"; messageBody = "Connection closed"; messageDisplayed = true; } Application.LoadLevel(0); }
public override void Connected(BoltConnection connection) { if (BoltNetwork.IsClient) { BoltLog.Info("Connected Client: {0}", connection); ClientConnectedUIHandler(); } else if (BoltNetwork.IsServer) { BoltLog.Info("Connected Server: {0}", connection); var entity = BoltNetwork.Instantiate(BoltPrefabs.PlayerInfo); entity.AssignControl(connection); } }
public override void StreamDataReceived(BoltConnection connection, UdpStreamData data) { var diff = Time.time - timestamp; timestamp = 0; string localHash = CreateHash(data.Data); BoltLog.Info("Received data from channel {0}: {1} bytes [{2}] [{3}] in {4}", data.Channel, data.Data.Length, localHash, connection, diff); var evt = DataStreamCheck.Create(connection, ReliabilityModes.ReliableOrdered); evt.hash = localHash; evt.Send(); }
void OnPlayerDisconnected(BoltConnection connection) { if (connection == null) { return; } var steamId = forest.IdFromConnection(connection); var name = forest.NameFromId(steamId); if (CoopLobby.Instance.MemberCount > 1) { forest.BroadcastChat(PlayerQuit.Replace("{name}", name)); } }
public override void SceneLoadRemoteDone(BoltConnection connection) { _connections.Add(connection); var n = _connections.Count; if (n >= 2) { for (var i = 0; i < n; ++i) { var entity = BoltNetwork.Instantiate(BoltPrefabs.DEPlayer, new Vector3(i * 2, 10.0f, 0.0f), Quaternion.identity); entity.AssignControl(_connections[i]); } } }
public static float CalculatePriorityFor(BoltConnection connection, BoltEntity entity, float multiplier, int skipped) { if (!entity || !entity.isAttached) { return 0f; } skipped = Mathf.Max(1, skipped); if (BoltNetwork.isClient) { return 256f; } if (entity.StateIs<IPlayerState>()) { return 256f * multiplier * (float)skipped; } if (entity.StateIs<ITreeCutState>()) { return 256f * multiplier * (float)skipped; } if (entity.StateIs<ITreeFallState>()) { return 256f * multiplier * (float)skipped; } if (entity.StateIs<IMutantFemaleDummyState>()) { return 256f * multiplier * (float)skipped; } if (entity.StateIs<IMutantMaleDummyState>()) { return 256f * multiplier * (float)skipped; } BoltEntity boltEntity = connection.UserData as BoltEntity; if (boltEntity != null) { float num = Vector3.Distance(entity.transform.position, boltEntity.transform.position); if (num < 256f) { if (entity.StateIs<IMutantState>()) { return 256f * multiplier * (float)skipped; } return Mathf.Clamp(256f - num, 0f, 256f) * multiplier * (float)skipped; } } return 0f; }
public static void UpdateScope(BoltAOI aoi, BoltConnection connection) { Vector3 position = aoi.transform.position; float detectRadius = aoi.detectRadius; float releaseRadius = aoi.releaseRadius; for (int i = 0; i < BoltPOI.availablePOIs.Count; i++) { BoltPOI boltPOI = BoltPOI.availablePOIs[i]; Vector3 position2 = boltPOI.transform.position; float bRadius = boltPOI.radius; if (BoltPOI.OverlapSphere(position, position2, detectRadius, bRadius)) { boltPOI.entity.SetScope(connection, true); } else if (!BoltPOI.OverlapSphere(position, position2, releaseRadius, bRadius)) { boltPOI.entity.SetScope(connection, false); } } }
public override void Connected(BoltConnection connection) { #region Announcement GameObject go = GameObject.Find ("Canvas"); HUDScript hs = go.GetComponentInChildren<HUDScript> (); hs.announcementText.text = "Player connected!"; hs.announcementText.color = new Color (hs.announcementText.color.r, hs.announcementText.color.g, hs.announcementText.color.b, 1.0f); #endregion Debug.Log ("connected"); por.createClientPlayerObject (connection); //updateStats(); // boltnetwork.entities -> assign stats for all. //this.connection = connection; // var log = LogEvent.Create (); // log.Message = string.Format ("{0} connected", connection.RemoteEndPoint); // log.Send (); }
public override void Disconnected(BoltConnection connection) { CoopKickToken coopKickToken = connection.DisconnectToken as CoopKickToken; if (coopKickToken != null) { CoopKick.Client_Banned = coopKickToken.Banned; CoopKick.Client_KickMessage = coopKickToken.KickMessage; UnityEngine.Object.FindObjectOfType<CoopSteamClientStarter>().CancelInvoke("OnDisconnected"); CoopClientCallbacks.OnDisconnected = null; } else { CoopKick.Client_Banned = false; CoopKick.Client_KickMessage = string.Empty; if (CoopClientCallbacks.OnDisconnected != null) { CoopClientCallbacks.OnDisconnected(); } } }
public override void Connected(BoltConnection connection) { Bolt.IProtocolToken token = connection.ConnectToken; //if this is a development build or in the editor, user authorization is not required //this should allow for much faster debugging and testing if ((Debug.isDebugBuild || Application.isEditor) && token == null) { var newToken = new ConnectionRequestData(); newToken.Password = ServerSideData.Password; string baseusername = "******"; int suffix = 0; while (PlayerRegistry.UserConnected(baseusername + suffix)) suffix++; string name = baseusername + suffix; newToken.PlayerName = name; token = newToken; DebugNameEvent evnt = DebugNameEvent.Create(connection, Bolt.ReliabilityModes.ReliableOrdered); evnt.NewName = name; evnt.Send(); } if (token != null && token is ConnectionRequestData) { ConnectionRequestData data = (ConnectionRequestData)token; Debug.Log("connection request with token of type " + token.GetType().Name); if (data.Password != ServerSideData.Password) { connection.Disconnect(new DisconnectReason("Server Refused Connection", "Incorrect Password")); } else if (PlayerRegistry.UserConnected(data.PlayerName)) { connection.Disconnect(new DisconnectReason("Server Refused Connection", "A player with that name is already connected")); } else if(GameManager.instance.CurrentGameState == GameManager.GameState.IN_GAME){ if (!IndexMap.ContainsPlayer(data.PlayerName)) { connection.Disconnect(new DisconnectReason("Server Refused Connection", "Game already in progress")); } } else{ PlayerRegistry.CreatePlayer(connection, data.PlayerName); lobby.AddPlayer(data.PlayerName); lobby.SetPlayerStatIndex(data.PlayerName, IndexMap.AddPlayer(data.PlayerName)); //player connected successfully! } } else { connection.Disconnect(new DisconnectReason("Server Refused Connection", "Invalid Connection Token")); } }
public static void UpdateScope(BoltAOI aoi, BoltConnection connection) { var aoiPos = aoi.transform.position; var aoiDetect = aoi.detectRadius; var aoiRelease = aoi.releaseRadius; for (int i = 0; i < availablePOIs.Count; ++i) { var poi = availablePOIs[i]; var poiPos = poi.transform.position; var poiRadius = poi.radius; if (OverlapSphere(aoiPos, poiPos, aoiDetect, poiRadius)) { poi.entity.SetScope(connection, true); } else { if (OverlapSphere(aoiPos, poiPos, aoiRelease, poiRadius) == false) { poi.entity.SetScope(connection, false); } } } }
public override void Connected(BoltConnection connection) { if (BoltNetwork.isServer) { if (CoopKick.IsBanned(connection.RemoteEndPoint.SteamId)) { connection.Disconnect(new CoopKickToken { Banned = true, KickMessage = "Host banned you from his games" }); } else { ClientACK.Create(connection).Send(); } } if (!CoopPeerStarter.DedicatedHost && Scene.HudGui && Scene.HudGui.MpPlayerList && Scene.HudGui.MpPlayerList.gameObject && Scene.HudGui.MpPlayerList.gameObject.activeInHierarchy) { Scene.HudGui.MpPlayerList.Refresh(); } }
public override void Disconnected(BoltConnection connection) { #region Announcement GameObject go = GameObject.Find ("Canvas"); HUDScript hs = go.GetComponentInChildren<HUDScript> (); hs.announcementText.text = "Player disconnected!"; hs.announcementText.color = new Color (hs.announcementText.color.r, hs.announcementText.color.g, hs.announcementText.color.b, 1.0f); #endregion Debug.Log ("DISCONNECTED PLAYER"); por.DestoryOnDisconnection (connection); playerDC = true; // if (tpb.state.TeamMemberId == 1) { // PlayerObjectReg.DestoryTeamOnePlayerOnDisconnection (connection); // } else if (tpb.state.TeamMemberId == 2) { // PlayerObjectReg.DestoryTeamTwoPlayerOnDisconnection (connection); // } // var log = LogEvent.Create (); // log.Message = string.Format ("{0} disconnected", connection.RemoteEndPoint); // log.Send (); //updateStats (); }
/// <summary> /// Broadcasts a chat message /// </summary> /// <param name="connection"></param> /// <param name="message"></param> public void BroadcastChat(BoltConnection connection, string message) { if (!BoltNetwork.isRunning) return; var player = Scene.SceneTracker.allPlayerEntities.FirstOrDefault(entity => entity.source.RemoteEndPoint.SteamId.Id == connection.RemoteEndPoint.SteamId.Id); if (!player) return; var e = ChatEvent.Create(GlobalTargets.AllClients); e.Message = message; e.Sender = player.networkId; e.Send(); }
public ulong IdFromConnection(BoltConnection con) => con.RemoteEndPoint.SteamId.Id;
public BoltEntity PlayerFromConnection(BoltConnection con) => Scene.SceneTracker.allPlayerEntities.FirstOrDefault(ent => ent.source.RemoteEndPoint.SteamId.Id == con.RemoteEndPoint.SteamId.Id);
public PlayerObject createClientPlayerObject(BoltConnection connection) { return createPlayer (connection); }
private void OnPlayerDisconnected(BoltConnection connection) { if (connection == null) return; var steamId = connection.RemoteEndPoint.SteamId.Id; var name = SteamFriends.GetFriendPersonaName(new CSteamID(steamId)); Interface.Oxide.LogInfo($"{steamId}/{name} quit"); }
private void OnPlayerConnected(BoltConnection connection) { if (connection == null) return; var steamId = connection.RemoteEndPoint.SteamId.Id; var name = SteamFriends.GetFriendPersonaName(new CSteamID(steamId)); // Do permission stuff if (permission.IsLoaded) { permission.UpdateNickname(steamId.ToString(), name); // Add player to default group if (!permission.UserHasAnyGroup(steamId.ToString())) permission.AddUserGroup(steamId.ToString(), DefaultGroups[0]); } Interface.Oxide.LogInfo($"{steamId}/{name} joined"); }
float IPriorityCalculator.CalculateEventPriority(BoltConnection connection, Event evnt) { return 256f; }
// public static List<PlayerObject> teamOnePlayerObjects = new List<PlayerObject> (); // public static List<PlayerObject> teamTwoPlayerObjects = new List<PlayerObject> (); PlayerObject createPlayer(BoltConnection connection) { PlayerObject po; po = new PlayerObject (); po.connection = connection; if (po.connection != null) { po.connection.UserData = po; } playerObjects.Add (po); // if (BoltInit.hasPickedTeamOne) { // teamOnePlayerObjects.Add (po); // } else if (BoltInit.hasPickedTeamTwo) { // teamTwoPlayerObjects.Add (po); // } return po; }
public override void Connected(BoltConnection connection) { base.Connected(connection); sendResult(true); }
float IPriorityCalculator.CalculateStatePriority(BoltConnection connection, int skipped) { return 256f; }
public PlayerObject getPlayerObject(BoltConnection connection) { if (connection == null) { return serverPlayerObject; } return (PlayerObject)connection.UserData; }
bool IEntityReplicationFilter.AllowReplicationTo(BoltConnection connection) { return this.CurrentSupport == null || connection.ExistsOnRemote((this.CurrentSupport as MonoBehaviour).GetComponent<BoltEntity>()) == ExistsResult.Yes; }
public override void Disconnected(BoltConnection connection) { base.Disconnected(connection); quitBolt(); }