public static void CancelConnection()
{
byte error = 0;
NetworkTransport.Disconnect(hostId, connectionId, out error);
isConnected = false;
}
public static void Disconnect()
{
if (!hasStarted)
{
Debug.LogWarning("Tried to disconnect without starting network!");
return;
}
if (isServer)
{
Debug.LogWarning("Can't disconnect a server. use CloseServer() instead.");
}
bool success = NetworkTransport.Disconnect(clientHostId, clientConnectionId, out err);
CheckNetworkError();
if (success)
{
Debug.Log("Disconnected successfully.");
}
else
{
Debug.Log("Disconnect failed! see above error msg");
}
if (isClient)
{
NetworkTransport.RemoveHost(clientHostId);
}
Shutdown();
}
public virtual byte Disconnect()
{
byte error;
NetworkTransport.Disconnect(SocketId, ConnectionId, out error);
return(error);
}
public static bool Disconnect(int connId)
{
byte error;
bool res = NetworkTransport.Disconnect(localHostId, connId, out error);
return(res);
}
void OnDestroy()
{
if (connected)
{
byte error = 0;
if (!NetworkTransport.Disconnect(clientHostId, clientConnId, out error))
{
Debug.Log("Error while disconnecting: " + (NetworkError)error);
}
}
if (clientHostId >= 0)
{
NetworkTransport.RemoveHost(clientHostId);
clientHostId = -1;
}
if (bcastHostId >= 0)
{
NetworkTransport.RemoveHost(bcastHostId);
bcastHostId = -1;
}
// shitdown the transport layer
NetworkTransport.Shutdown();
}
public static void ManuallyDisconnectSelf()
{
byte error;
NetworkTransport.Disconnect(HostID, connectionID, out error);
ClientID = -1;
}
public void Disconnect()
{
byte error;
NetworkTransport.Disconnect(HostID, ConnectionID, out error);
UNETUtility.HandleError(error);
}
public void Disconnect()
{
byte error;
var result = NetworkTransport.Disconnect(_socketId, _localConnectionId, out error);
Debug.Log(this.ToString() + " Client disconnect result == " + result.ToString() + " error == " + ((NetworkError)error).ToString());
}
/// <summary>
/// Disconnect client to server
/// </summary>
public void Disconnect()
{
byte error;
NetworkTransport.Disconnect(socketId, connectionId, out error);
Debug.Log("Disconnect to server. ConnectionId: " + connectionId);
}
public void OnBackToMain()
{
byte error;
NetworkTransport.Disconnect(ClientConnection.Instance.MSSocketID, ClientConnection.Instance.MSConnectionID, out error);
WindowManager.Instance.ToggleWindows(WindowIDs.GameSelect, WindowIDs.StartWindow);
}
private void OnApplicationQuit()
{
foreach (var client in _clients.Values)
{
NetworkTransport.Disconnect(_hostID, client.ConnectionId, out _error);
}
}
void OnDestroy()
{
try
{
if (connected)
{
byte error = 0;
if (!NetworkTransport.Disconnect(clientHostId, clientConnId, out error))
{
Debug.Log("Error while disconnecting: " + (NetworkError)error);
}
}
if (clientHostId >= 0)
{
NetworkTransport.RemoveHost(clientHostId);
clientHostId = -1;
}
if (bcastHostId >= 0)
{
NetworkTransport.RemoveHost(bcastHostId);
bcastHostId = -1;
}
}
catch (System.Exception ex)
{
Debug.LogError(ex.Message + "\n" + ex.StackTrace);
}
// shitdown the transport layer
NetworkTransport.Shutdown();
}
public void UpdateProcesses()
{
UpdateLocalProcessList();
localProcessManager.UpdateProcesses(localProcessList);
MemoryStream stream = new MemoryStream();
stream.WriteByte(MESSAGE_PROCESS_LIST);
new BinaryFormatter().Serialize(stream, localProcessList);
byte[] b = stream.ToArray();
foreach (KeyValuePair <int, PlayerProcessManager> player in playerProcessManagers)
{
if (player.Key == 0)
{
continue; // ignore local player
}
byte error;
NetworkTransport.Send(hostId, player.Key, channelId, b, b.Length, out error);
if (error != 0)
{
Debug.LogError("Send error: " + error);
NetworkTransport.Disconnect(hostId, player.Key, out error);
}
}
}
public override void Disconnect(int connectionId)
{
byte error;
NetworkTransport.Disconnect(HostID, connectionId, out error);
UNETUtility.HandleError(error);
}
private void Disconnect()
{
if (isConnected())
{
// ByteContructor bc = new ByteContructor();
// bc.add (System.BitConverter.GetBytes ((int)DataType.Disconnect));
// if (isClient ())
// send (bc.bytes.ToArray (), clientConnectionID);
// else
// foreach (PlayerInfo playerInfo in playerInfoList) {
// send (bc.bytes.ToArray (), playerInfo.connID);
// }
byte error;
if (isClient())
{
NetworkTransport.Disconnect(thisSocket, clientConnectionID, out error);
NetErrorEvent(error);
}
else if (isServer())
{
foreach (PlayerInfo playerInfo in playerInfoList)
{
NetworkTransport.Disconnect(thisSocket, playerInfo.connID, out error);
NetErrorEvent(error);
}
}
}
}
public void Stop()
{
byte error;
NetworkTransport.Disconnect(_clientId, _connectionId, out error);
Debug.Log("Client halted.");
}
public void Disconnect()
{
connected = false;
NetworkTransport.Disconnect(hostId, connectionId, out error);
connectMenu.SetActive(true);
gameMenu.SetActive(false);
GetComponent <InputController>().doneSetup = false;
}
public void Disconnect()
{
NetworkTransport.Disconnect(HostID, ConnectionID, out var error);
if ((NetworkError)error != NetworkError.Ok)
{
Debug.LogError((NetworkError)error);
}
}
/// <summary>
///
/// </summary>
private void OnApplicationQuit()
{
byte error;
NetworkTransport.Disconnect(m_genericHostId, m_connectionId, out error);
NetworkTransport.Shutdown();
m_isSetup = false;
}
public void Disconnect()
{
NetworkTransport.Disconnect(socket, myConnectionId, out message.error);
if (printMessageError)
{
PrintErrorMessage(message.error);
}
}
public void Disconnect()
{
NetworkTransport.Disconnect(_hostId, _connectionId, out _error);
if (_error != 0)
{
Debug.Log((NetworkError)_error);
}
}
void IRouterInternal.Update()
{
if (_state != RouterState.None)
{
NetworkEventType eventType;
Connection conn;
int connId;
int channelId;
var buffer = _receiveBuffer;
int length;
byte error;
do
{
eventType = NetworkTransport.ReceiveFromHost(_hostId, out connId,
out channelId, buffer, buffer.Length, out length, out error);
switch (eventType)
{
case NetworkEventType.ConnectEvent:
if (!_shuttingDown && (_state == RouterState.Server || connId == _clientId))
{
conn = new Connection(this, _hostId, connId);
_connections.Add(conn);
}
else
{
NetworkTransport.Disconnect(_hostId, connId, out error);
}
break;
case NetworkEventType.DisconnectEvent:
if (_connectionMap.TryGetValue(connId, out conn))
{
((IConnectionInternal)conn).TransportLayerDisconnected();
TryFinalizeShutdown();
}
break;
case NetworkEventType.DataEvent:
if (error == (byte)NetworkError.MessageToLong)
{
// TODO: Use buffer pool / output warning if messages frequently are too long.
buffer = new byte[length];
}
else if (_connectionMap.TryGetValue(connId, out conn))
{
Receive(new Message(conn, buffer, length));
}
else
{
Debug.LogWarningFormat("Unknown connection: {0}", connId);
}
break;
}
} while (eventType != NetworkEventType.Nothing && _hostId >= 0);
}
}
public void Cancel()
{
GameManager.Instance.cnnCnnGroup.SetActive(true);
GameManager.Instance.cnnWaitGroup.SetActive(false);
NetworkTransport.Disconnect(hostId, connectionId, out error);
isConnected = false;
}
public void StopClient()
{
byte networkErrorByteCode;
NetworkTransport.Disconnect(_ClientHostId, _ConnectionId, out networkErrorByteCode);
NetworkEventDispatcher.GetInstance.RemoveHost(_ClientHostId);
NetworkTransport.RemoveHost(_ClientHostId);
_ClientHostId = -1;
}
void OnApplicationQuit()
{
// Gracefully disconnect
if (m_hostId != -1 && m_serverConnectionId != -1)
{
byte error;
NetworkTransport.Disconnect(m_hostId, m_serverConnectionId, out error);
}
}
public void StopClient()
{
byte error;
NetworkTransport.Disconnect(SocketId, ConnectionId, out error);
NetworkTransport.RemoveHost(SocketId);
HandleDisconnect(ConnectionId, error);
OnStopClient();
}
public void StopClient()
{
ClientConnected = false;
NetworkTransport.Disconnect(hostID, connectionID, out error);
if (server.Started())
{
StopHost();
}
}
void MyWindow(int id)
{
GUILayout.BeginHorizontal();
GUILayout.Label("IP");
_ipField = GUILayout.TextField(_ipField);
GUILayout.Label("Port");
_portField = GUILayout.TextField(_portField);
if (GUILayout.Button("Connect"))
{
byte error;
var connectionId = NetworkTransport.Connect(_mHostId, _ipField, int.Parse(_portField), 0, out error);
if (connectionId != 0) // Could go over total connect count
{
_mConnectionId = connectionId;
}
}
if (GUILayout.Button("Disconnect"))
{
byte error;
var ret = NetworkTransport.Disconnect(_mHostId, _mConnectionId, out error);
print("Disconnect " + ret + " error " + error);
}
GUILayout.FlexibleSpace();
GUILayout.EndHorizontal();
GUILayout.BeginHorizontal();
GUILayout.Label("Size");
_sizeField = GUILayout.TextField(_sizeField);
if (GUILayout.Button("Send"))
{
//TODO: test message
Message testMsg = new Message(Enum_Action.Trigger);
testMsg.AddData((byte)Enum_Trigger.Klappen);
byte error;
// Just send junk
var ret = NetworkTransport.Send(_mHostId, _mConnectionId, _reliableChannel, testMsg.GetBuffer(), testMsg.GetSize(), out error);
print("Send " + ret + " error " + error);
}
GUILayout.FlexibleSpace();
GUILayout.EndHorizontal();
_scrollPos = GUILayout.BeginScrollView(_scrollPos, GUILayout.Height(200.0f), GUILayout.Width(400.0f));
GUILayout.Label(_receiveLabel);
GUILayout.EndScrollView();
GUILayout.BeginHorizontal();
if (GUILayout.Button("Clear"))
{
_receiveLabel = "";
}
GUILayout.FlexibleSpace();
GUILayout.EndHorizontal();
GUI.DragWindow();
}
public void StopHost()
{
byte error;
NetworkTransport.Disconnect(SocketId, ConnectionId, out error);
StopServer();
HandleDisconnect(ConnectionId, error);
OnStopHost();
}
public void StartDisconnect()
{
if (m_IsConnect)
{
byte error;
NetworkTransport.Disconnect(m_HostId, m_ConnectionId, out error);
m_IsConnect = false;
}
}
