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);
}
