public void Close(EDisconnectReason eReason) { m_Peer.Flush(); m_Peer.NetManager.DisconnectPeer( m_Peer, new[] { Convert.ToByte(EDisconnectReason.ServerIsFull) }); }
public void ErrorDisconnectPlayer(EDisconnectReason reason) { if (!isLocalPlayer && (ownerConnection != null)) { (world as ServerWorld).DisconnectClient(ownerConnection.connection, null, reason, null); } }
public void DisconnectAllClients(EDisconnectReason reason) { while (connectionList.Count > 0) { DisconnectClient(connectionList[0].connection, null, reason, null); } }
protected override void OnDisconnectedFromServer(EDisconnectReason reason) { if (GameManager.instance.serverWorld == null) { GameManager.instance.SetPendingLevel("MainMenu", null); } }
/// <summary> /// Disconnect user /// </summary> /// <param name="user">User</param> /// <param name="disconnectReason">Disconnect reason</param> /// <returns>"true" if disconnected, otherwise "false"</returns> public bool DisconnectUser(IUser user, EDisconnectReason disconnectReason) { bool ret = false; if (user != null) { lock (users) { if (IsRealUser(user)) { IUser real_user = GetRealUser(user); if (real_user != null) { if (real_user is ServerUser) { ServerUser server_user = (ServerUser)real_user; ret = (disconnectReason == (EDisconnectReason.Banned) ? Bans.AddPattern(Regex.Escape(server_user.ServerConnection.IPAddress.ToString())) : true); serverListener.Disconnect(server_user.ServerConnection); } else if (real_user is BotUser) { ret = true; } if (ret) { users.Remove(real_user.ID); switch (disconnectReason) { case EDisconnectReason.Left: OnUserLeft?.Invoke(real_user); break; case EDisconnectReason.Kicked: OnUserKicked?.Invoke(real_user); break; case EDisconnectReason.Banned: OnUserBanned?.Invoke(real_user); break; case EDisconnectReason.TimedOut: OnUserTimedOut?.Invoke(real_user); break; } foreach (IUser u in users) { ServerUser server_user = u as ServerUser; if (server_user != null) { server_user.ServerConnection.SendUserLeftMessageAsync(real_user); } } } } } } } return(ret); }
public override void OnPlayerDisconnected(Actor player, Exception e, EDisconnectReason reason, string msg) { if ((_gameMode != null) && (player != null)) { _gameMode.NotifyPlayerDisconnected((Actors.ServerPlayerController)player, e, reason, msg); } base.OnPlayerDisconnected(player, e, reason, msg); }
public override bool Disconnect(long connectionId, EDisconnectReason disconnectReason) { if (connectPeers.ContainsKey(connectionId)) { netManager.DisconnectPeer(connectPeers[connectionId]); return(true); } return(false); }
public void DisconnectFromServer(EDisconnectReason reason) { if (_serverConnection != null) { _serverConnection.connection.SendReliable(NetMsgs.Disconnect.New(reason, null)); _serverConnection.connection.driverConnection.Dispose(); _serverConnection = null; } }
public virtual void Disconnected(ConnectionServer con, EDisconnectReason eReason) { Logger.Info("Connection closed: {connection}. {reason}.", con, eReason); con.Disconnect(eReason); if (!m_ActiveConnections.Remove(con)) { Logger.Error("Unknown connection: {connection}.", con); } }
public override void Disconnect(EDisconnectReason eReason) { if (!m_StateMachine.IsInState(EConnectionState.Disconnected)) { m_StateMachine.Fire( new StateMachine <EConnectionState, ETrigger> .TriggerWithParameters < EDisconnectReason>(ETrigger.Disconnect), eReason); } }
private void ConnectionDestroyed(EDisconnectReason eReason) { switch (eReason) { case EDisconnectReason.Timeout: case EDisconnectReason.Unknown: TryReconnect(); break; } }
public void Disconnect(EDisconnectReason eReason) { if (Connected) { m_NetManager.DisconnectPeer(m_Peer, new[] { Convert.ToByte(eReason) }); m_NetManager.Stop(); m_Session.Disconnect(eReason); m_NetManager = null; } }
protected override void OnDisconnect(ActorReplicationChannel channel, EDisconnectReason reason, string msg) { if (string.IsNullOrEmpty(msg)) { Debug.LogError("Disconnected by server " + reason); } else { Debug.LogError("Disconnected by server " + reason + " - " + msg); } _serverConnection.connection.driverConnection.Dispose(); _serverConnection = null; OnDisconnectedFromServer(reason); }
public void Disconnect(EDisconnectReason eReason) { if (Connection == null) { throw new InvalidStateException("Client is not connected. Cannot disconnect."); } Connection.Disconnect(eReason); Logger.Debug( "Disconnect from server {connection}. Reason: {reason}.", Connection, eReason); Connection = null; }
public void OnPeerDisconnected(NetPeer peer, DisconnectInfo disconnectInfo) { EDisconnectReason eReason = EDisconnectReason.Unknown; if (disconnectInfo.AdditionalData.AvailableBytes == 1) { eReason = (EDisconnectReason)disconnectInfo.AdditionalData.GetByte(); } if (m_Session.Connection != null) { m_Session.Disconnect(eReason); } }
public override bool Disconnect(long connectionId, EDisconnectReason disconnectReason) { try { if (!IsServer) { client.Disconnect(); } else { server.Disconnect((int)connectionId); } } catch (Exception e) { NetDebug.LogError(e.ToString()); return(false); } return(true); }
public void DisconnectClient(NetConnection connection, Exception e, EDisconnectReason reason, string message) { var channel = connectionList.Find(x => (x.connection == connection)); if ((channel != null) && connectionList.Remove(channel)) { connection.SendReliable(NetMsgs.Disconnect.New(reason, message)); if (channel.owningPlayer != null) { OnPlayerDisconnected(channel.owningPlayer, e, reason, message); } if (string.IsNullOrEmpty(message)) { Debug.Log("Client disconnected (" + connection.address + ") " + reason + "."); } else { Debug.Log("Client disconnected (" + connection.address + ") " + reason + " -- '" + message + "'."); } connection.driverConnection.Dispose(); } }
private void Handle_Quit_Command( CQuitClientSlashCommand command ) { Add_Network_Operation( new CDisconnectRequestOperation( ESessionID.First, EDisconnectReason.Client_Request ) ); PendingDisconnectReason = EDisconnectReason.Client_Request_Quit; }
public EDisconnectInfo(EDisconnectReason Reason, SocketError SocketErrorCode) { this.Reason = Reason; this.SocketErrorCode = SocketErrorCode; }
// Construction public CDisconnectRequestOperation( ESessionID id, EDisconnectReason reason ) : base(ENetworkOperation.Disconnect, id) { Reason = reason; }
public abstract bool Disconnect(long connectionId, EDisconnectReason disconnectReason);
private void Handle_Disconnection_Event() { switch ( PendingDisconnectReason ) { case EDisconnectReason.Client_Request_Quit: throw new CQuitException(); case EDisconnectReason.Client_Request: CClientResource.Output_Text( EClientTextID.Client_Expected_Disconnection ); break; default: CClientResource.Output_Text( EClientTextID.Client_Unexpected_Disconnection ); break; } PendingDisconnectReason = EDisconnectReason.Invalid; Reset_Complete_Logical_State(); }
protected abstract void OnDisconnect(ActorReplicationChannel channel, EDisconnectReason reason, string msg);
public static Disconnect New(EDisconnectReason reason, string message) { instance._reason = (byte)reason; instance._message = message; return(instance); }
// Construction public CDisconnectResultMessage( EDisconnectReason reason ) { Reason = reason; }
/// <summary> /// Closes the connection. /// Postcondition: <see cref="State" /> is equal to <see cref="EConnectionState.Disconnected" />. /// </summary> /// <param name="eReason">Reason that caused the disconnect.</param> public abstract void Disconnect(EDisconnectReason eReason);
public void Close(EDisconnectReason eReason) { throw new NotImplementedException(); }
private void closeConnection(EDisconnectReason eReason) { OnDisconnected?.Invoke(this); Network.Close(eReason); m_StateMachine.Fire(ETrigger.Disconnected); }
protected override void OnDisconnect(ActorReplicationChannel channel, EDisconnectReason reason, string msg) { OnDisconnect(channel.connection.driverConnection); }
protected abstract void OnDisconnectedFromServer(EDisconnectReason reason);
private void ConnectionClosed(EDisconnectReason eReason) { Persistence?.SetConnection(null); }
// Protected interface and overrides protected override void Initialize() { base.Initialize(); base.Initialize_Time_Keeper( TimeKeeperExecutionMode.Internal, TimeKeeperTimeUnit.RealTime, TimeKeeperAuthority.Master, LOGICAL_SERVICE_INTERVAL, true, true ); PendingDisconnectReason = EDisconnectReason.Invalid; CNetworkMessageHandler.Instance.Initialize( delegate( ESessionID session_id ) { return ConnectedID; } ); Register_Message_Handlers(); Register_Generic_Handlers(); CClientPlayerInfoManager.Instance.Initialize(); CClientResource.Output_Text( EClientTextID.Client_Startup_Greeting ); }
public virtual void OnPlayerDisconnected(Actor player, Exception e, EDisconnectReason reason, string msg) { player.Destroy(); }
// Methods // Public interface public void Set_Pending_Disconnect( EDisconnectReason reason ) { if ( PendingDisconnectReason != EDisconnectReason.Invalid ) { return; } PendingDisconnectReason = reason; Send_Message( new CDisconnectResultMessage( reason ) ); }
// Methods // Public interface public void On_Disconnection( ESessionID id, EDisconnectReason reason ) { Add_Event( ENetworkEvent.Disconnection, id ); }
public override bool Receive(out TransportEventData eventData) { SimpleTCP.Message msg; bool state = false; if (IsServer) { state = server.GetNextMessage(out msg); } else { state = client.GetNextMessage(out msg); } if (state) { //NetDebug.Log("接收到消息:" + msg.eventType); ENetworkEvent msgType = ENetworkEvent.DataEvent; switch (msg.eventType) { case SimpleTCP.EventType.Connected: msgType = ENetworkEvent.ConnectEvent; break; case SimpleTCP.EventType.Data: msgType = ENetworkEvent.DataEvent; break; case SimpleTCP.EventType.Disconnected: msgType = ENetworkEvent.DisconnectEvent; break; default: break; } EDisconnectReason disReason = EDisconnectReason.ConnectionFailed; if (msg.disconnectReason == SimpleTCP.DisconnectReason.ConnectionFailed) { disReason = EDisconnectReason.ConnectionFailed; } else if (msg.disconnectReason == SimpleTCP.DisconnectReason.DisconnectPeerCalled) { disReason = EDisconnectReason.DisconnectPeerCalled; } eventData = new TransportEventData() { type = msgType, connectionId = msg.connectionId, data = msg.data, disconnectInfo = new EDisconnectInfo() { Reason = disReason, } }; } else { eventData = default(TransportEventData); } return(state); }