void HandleData(int connectionId, int channelId, int receivedSize, NetworkError error)
{
var client = FindConnection(connectionId);
if (client == null)
{
return;
}
client.LastError = error;
#if NETWORK_DEBUGGER_ENABLED
var logMessage = new System.Text.StringBuilder("ServerPeer");
logMessage.Append(" Incoming");
logMessage.Append(" ConnectionId:").Append(connectionId);
logMessage.Append(" ChannelId:").Append(channelId);
logMessage.Append(" Size:").Append(receivedSize);
UnityEngine.Debug.Log(logMessage);
#endif
#if NETWORK_PROFILER_ENABLED && UNITY_EDITOR
var profilerName = new System.Text.StringBuilder("ServerPeer");
profilerName.Append(channelId);
Profiler.NetworkProfiler.RecordChannelIncoming(profilerName.ToString(), (ushort)receivedSize);
#endif
if (DataEvent != null)
{
DataEvent.Invoke(client, channelId, m_RecievedBuffer, receivedSize);
}
}
void HandleConnectingFailedEvent(NetworkError error)
{
if (ConnectingFailedEvent != null)
{
ConnectingFailedEvent.Invoke(error);
}
}
public bool Connect(out NetworkError error)
{
Disconnect = false;
ProcessWorkers = new Thread[workerProcessCount];
// Create and start a separate thread for each worker
for (int i = 0; i < workerProcessCount; i++)
{
ProcessWorkers[i] = new Thread(MessagesConsumer);
ProcessWorkers[i].Name = "LLApi Process Thread " + i;
ProcessWorkers[i].Start();
}
SocketId = NetworkTransport.AddHost(Topology);
byte errorByte;
ConnectionId = NetworkTransport.Connect(SocketId, EndPoint, Port, 0, out errorByte);
error = (NetworkError)errorByte;
if (error != NetworkError.Ok)
{
isConnecting = false;
isConnected = false;
Debug.LogError("LLApiClient Error Connecting to " + EndPoint + ":" + Port + " Error: " + error);
}
else
{
isConnecting = true;
Debug.Log("LLApiClient Connecting to " + EndPoint + ":" + Port + " ConnectionId : " + ConnectionId + "SocketID : "+SocketId);
}
return isConnecting;
}
public void AddNetworkListeners(NetworkConnected netConCall, DataSent dataSentCall, DataReceived dataRecvCall, NetworkError netErrorCall)
{
OnNetworkConnected += netConCall;
OnDataSent += dataSentCall;
OnDataReceived += dataRecvCall;
OnNetworkError += netErrorCall;
}
void OnError(NetworkConnection conn, NetworkError netError)
{
if (netError == NetworkError.Timeout)
{
Connect();
}
}
//This function is called when data is sent
void OnData(int hostId, int connectionId, int channelId, byte[] data, int size, NetworkError error)
{
//Here the message being received is deserialized and output to the console
Stream serializedMessage = new MemoryStream(data);
BinaryFormatter formatter = new BinaryFormatter();
string message = formatter.Deserialize(serializedMessage).ToString();
Debug.Log(message);
string[] splitString = message.Split(',');
if (splitString.Length < 1)
{
Debug.LogError("ThisShould not happen I need more infor to change the screen");
}
if (splitString[0].Equals("i"))
{
OnInitConsole(int.Parse(splitString[1]));
}
else if (splitString[0].Equals("s"))
{
OnSelectCar(int.Parse(splitString[1]));
}
else
{
Debug.Log("I got something I am not sure if that works");
}
//Output the deserialized message as well as the connection information to the console
Debug.Log("OnData(hostId = " + hostId + ", connectionId = "
+ connectionId + ", channelId = " + channelId + ", data = "
+ message + ", size = " + size + ", error = " + error.ToString() + ")");
}
void OnData(int hostId, int connectionId, int channelId, int size, NetworkError error)
{
//Output the deserialized message as well as the connection information to the console
Debug.Log("OnData(hostId = " + hostId + ", connectionId = "
+ connectionId + ", channelId = " + channelId +
", size = " + size + ", error = " + error.ToString() + ")");
}
//Inizializzazione Client, richiesta connessione al host.
//Il client si collega al host all'indirizzo IP e Port definito.
//Una volta collegato rimane in attesa di avvenuta connessione per poi richiedere la richiesta di partecipazione al "Party"
public void StartClienting(string hostIP, int port)
{
_isServer = false;
_isStarted = true;
NetworkTransport.Init();
this.hostIP = hostIP;
this.port = port;
_myIp = GetLocalIPAddress();
commandsSent = 0;
commandsReceived = 0;
_genericHostId = NetworkTransport.AddHost(new HostTopology(_config, 24), 0); //?
byte error;
_connectionID = NetworkTransport.Connect(_genericHostId, hostIP, port, 0, out error);
NetworkError nError = (NetworkError)error;
if (nError != NetworkError.WrongChannel)
{
Debug.LogError(nError.ToString());
_lastMessageError = nError.ToString();
}
}
public bool SendCommand(BaseCommand command)
{
if (!_isStarted)
{
return(false);
}
byte error;
byte[] bytes = Encoding.UTF32.GetBytes(JsonUtility.ToJson(command));
NetworkTransport.Send(_hostID, command.idReceiver, _communicationChannel, bytes, bytes.Length, out error);
NetworkError nError = (NetworkError)error;
if (nError != NetworkError.Ok)
{
Debug.LogError(nError.ToString());
_lastMessageError = nError.ToString() + " HID:" + _hostID + " RID:" + command.idReceiver + " CH" + _communicationChannel;
NetworkTransport.Send(_hostID, command.idReceiver, _communicationChannel == 0 ? 1 : 0, bytes, bytes.Length, out error); //Remove this
return(false);
}
_lastMessageError = nError.ToString() + " HID:" + _hostID + " RID:" + command.idReceiver + " CH" + _communicationChannel;
_lastCommandSent = command.commandType;
commandsSent++;
return(true);
}
private void ErrorHandler(NetworkMessage netMsg)
{
ErrorMessage errorMsg = netMsg.ReadMessage <ErrorMessage>();
NetworkError error = (NetworkError)errorMsg.errorCode;
Debug.LogError("Network Error: " + error);
}
public override void JoinGame(object serverAddress, OnJoinGameDelegate callback)
{
Application.runInBackground = true;
NetworkTransport.Init();
ConnectionConfig connectionConfig = new ConnectionConfig();
reliableChannelId = connectionConfig.AddChannel(QosType.Reliable);
unreliableChannelId = connectionConfig.AddChannel(QosType.Unreliable);
HostTopology topology = new HostTopology(connectionConfig, 4);
hostId = NetworkTransport.AddHost(topology);
if (hostId < 0)
{
callback(null, "Server socket creation failed!");
return;
}
serverConnectionId = NetworkTransport.Connect(hostId, (string)serverAddress, 8888, 0, out byte error);
if (error != 0)
{
NetworkError networkError = (NetworkError)error;
callback(null, "Error: " + networkError.ToString());
}
else
{
callback(serverConnectionId, null);
}
}
public void Connect(string address, int port)
{
var topology = new HostTopology(_connectionConfig, 1);
_socketId = NetworkTransport.AddHost(topology);
byte error;
_connectionId = NetworkTransport.Connect(_socketId, address, port, 0, out error);
NetworkError errorType = (NetworkError)error;
if (errorType == NetworkError.Ok)
{
Debug.Log("Connected to server. Connection id: " + _connectionId);
if (OnConnectedToServer != null)
{
OnConnectedToServer.Invoke();
}
}
else
{
Debug.LogError("Connection failed with errorType: " + _connectionId);
if (OnConnectionFail != null)
{
OnConnectionFail.Invoke(errorType.ToString());
}
}
}
public void Host_SendCommand_ToParty(BaseCommand baseCommand)
{
if (!_isStarted)
{
return;
}
if (!_isServer)
{
return;
}
baseCommand.idSender = _connectionID;
baseCommand.ipSender = MyIP;
foreach (int id in _partyIDs)
{
byte error;
byte[] bytes = Encoding.UTF32.GetBytes(JsonUtility.ToJson(baseCommand));
NetworkTransport.Send(_hostID, id, _communicationChannel, bytes, bytes.Length, out error);
NetworkError nError = (NetworkError)error;
if (nError != NetworkError.Ok)
{
Debug.LogError(nError.ToString());
_lastMessageError = nError.ToString() + " HID:" + _hostID + " RID:" + id + " CH" + _communicationChannel;
}
else
{
_lastCommandSent = baseCommand.commandType;
commandsSent++;
}
}
}
public NetEventType PollReceive(out uint clientId, out int channelId, ref byte[] data, int bufferSize, out int receivedSize, out byte error)
{
NetworkEventType eventType = NetworkTransport.Receive(out int hostId, out int connectionId, out channelId, data, bufferSize, out receivedSize, out byte err);
clientId = new NetId((byte)hostId, (ushort)connectionId, false).GetClientId();
NetworkError errorType = (NetworkError)err;
if (errorType == NetworkError.Timeout)
{
eventType = NetworkEventType.DisconnectEvent; //In UNET. Timeouts are not disconnects. We have to translate that here.
}
error = 0;
//Translate NetworkEventType to NetEventType
switch (eventType)
{
case NetworkEventType.DataEvent:
return(NetEventType.Data);
case NetworkEventType.ConnectEvent:
return(NetEventType.Connect);
case NetworkEventType.DisconnectEvent:
return(NetEventType.Disconnect);
case NetworkEventType.Nothing:
return(NetEventType.Nothing);
case NetworkEventType.BroadcastEvent:
return(NetEventType.Nothing);
}
return(NetEventType.Nothing);
}
public void StartClient()
{
NetworkTransport.Init();
byte error;
config = new ConnectionConfig();
config.SendDelay = 0; // hmm
reliableSequencedChannelId = config.AddChannel(QosType.ReliableSequenced); // For RPC Input commands like switching teams and of course, PlayerConnect.
unreliableChannelId = config.AddChannel(QosType.Unreliable); // All input that goes on a frame per frame basis like moving & shooting
hostTopology = new HostTopology(config, 1);
hostId = NetworkTransport.AddHost(hostTopology);
connectionId = NetworkTransport.Connect(hostId, ip, port, 0, out error);
NetworkError networkError = (NetworkError)error;
if (networkError != NetworkError.Ok)
{
Debug.LogError(string.Format("Unable to connect to {0}:{1}, Error: {2}", ip, port, networkError));
}
else
{
OperationNetwork.initialConnected = 0;
}
Debug.LogError("Connected initial");
}
// MsgType.Error handler
// Called on this client when there was a network error
void OnClientError(NetworkMessage msg)
{
int errorCode = msg.ReadMessage <ErrorMessage>().errorCode;
NetworkError networkError = (NetworkError)errorCode;
Debug.Log("[CLIENT] NetworkMessage : OnClientError - Error address: " + StripIPv6Formatting(msg.conn.address) + "\n NetworkError." + networkError + " (code " + errorCode + ")");
}
private static void TriggerErrorEvent(NetworkError error, string msg)
{
if (OnNetworkError != null)
{
OnNetworkError(NetworkError.Login_Failed, "Error Could not login");
}
}
protected virtual bool StartClient()
{
Initialize();
NetworkIdentity[] identities = FindObjectsOfType <NetworkIdentity>();
foreach (NetworkIdentity identity in identities)
{
Destroy(identity.gameObject);
}
m_hostID = NetworkTransport.AddHost(m_hostTopology);
byte error;
m_clientID = NetworkTransport.Connect(m_hostID, m_Address, m_Port, 0, out error);
NetworkError networkError = (NetworkError)error;
if (networkError != NetworkError.Ok)
{
Debug.LogError($"Fehler beim Erstellen des Clients! ({networkError})",
this);
return(false);
}
m_isServer = false;
return(true);
}
private void GenerateError(int error)
{
NetworkError netError = (NetworkError)error;
if (LogFilter.logError)
{
Debug.LogError("Client Net Error: " + netError);
}
NetworkMessageDelegate msgDelegate = handlers.ContainsKey(MsgType.Error) ? handlers[MsgType.Error] : null;
if (msgDelegate != null)
{
ErrorMessage msg = new ErrorMessage();
msg.errorCode = error;
// write the message to a local buffer
byte[] errorBuffer = new byte[200];
NetworkWriter writer = new NetworkWriter(errorBuffer);
msg.Serialize(writer);
// pass a reader (attached to local buffer) to handler
NetworkReader reader = new NetworkReader(errorBuffer);
NetworkMessage netMsg = new NetworkMessage();
netMsg.msgType = MsgType.Error;
netMsg.reader = reader;
netMsg.conn = m_myConnection;
netMsg.channelId = 0;
msgDelegate(netMsg);
}
}
private bool IsFatalError(NetworkError error)
{
switch (error)
{
case NetworkError.WrongHost:
case NetworkError.WrongConnection:
case NetworkError.WrongChannel:
case NetworkError.NoResources:
case NetworkError.Timeout:
case NetworkError.VersionMismatch:
case NetworkError.DNSFailure:
case NetworkError.CRCMismatch:
case NetworkError.BadMessage:
case NetworkError.UsageError:
return(true);
case NetworkError.Ok:
case NetworkError.MessageToLong:
case NetworkError.WrongOperation:
return(false);
default:
Log.CreatePossibleBugException(string.Format("Dissonance UNet received unknown NetworkError: '{0}'", error), "BF18ADA4-CDC0-43F6-B99D-DC52E9A991F4");
return(true);
}
}
/// <summary>
/// Sends the specified <see cref="DataMessage"/> to the server.
/// </summary>
/// <param name="message">The message.</param>
/// <param name="channel">The channel.</param>
/// <param name="error">The error.</param>
/// <returns></returns>
protected bool Send(DataMessage message, QosType channel, out NetworkError error)
{
//Debug.Log(this.ToString() + " Sending message of type: " + message.type.ToString() + " on channel: " + type.ToString());
var buffer = message.Serialize();
return(base.Send(_localConnectionId, buffer, channel, message.GetTotalByteSize(), out error));
}
internal Connection(int socketId, int connectionId, bool isConnected, NetworkError lastError)
{
SocketId = socketId;
ConnectionId = connectionId;
IsConnected = isConnected;
LastError = lastError;
}
private void Start()
{
// Init Transport using default values.
NetworkTransport.Init();
// Create a connection config and add a Channel.
ConnectionConfig config = new ConnectionConfig();
channelId = config.AddChannel(QosType.ReliableSequenced);
// Create a topology based on the connection config.
HostTopology topology = new HostTopology(config, 10);
// Create a host based on the topology we just created, and bind the socket to port.
hostId = NetworkTransport.AddHost(topology, clientSockedPort);
Debug.Log("Socket Open. SocketId is: " + hostId);
// Connect to the host with IP and port.
byte error;
connectionId = NetworkTransport.Connect(hostId, serverAddress, serverSocketPort, 0, out error);
NetworkError networkError = (NetworkError)error;
if (networkError != NetworkError.Ok)
{
Debug.LogError($"Unable to connect to {serverAddress}:{serverSocketPort}, Error: {networkError}");
}
else
{
Debug.Log($"Connected to {serverAddress}:{serverSocketPort} with hostId: {hostId}, connectionId: {connectionId}, channelId: {channelId},");
}
}
public override SocketTasks StartClient()
{
SocketTask task = SocketTask.Working;
serverHostId = RelayTransport.AddHost(new HostTopology(GetConfig(), 1), false);
serverConnectionId = RelayTransport.Connect(serverHostId, ConnectAddress, ConnectPort, 0, out byte error);
NetworkError connectError = (NetworkError)error;
switch (connectError)
{
case NetworkError.Ok:
task.Success = true;
task.TransportCode = error;
task.SocketError = System.Net.Sockets.SocketError.Success;
task.IsDone = false;
// We want to continue to wait for the successful connect
connectTask = task;
break;
default:
task.Success = false;
task.TransportCode = error;
task.SocketError = System.Net.Sockets.SocketError.SocketError;
task.IsDone = true;
break;
}
return(task.AsTasks());
}
public void SendData(byte[] data, bool reliableChannel)
{
if (connected)
{
if (id == 32767)
{
try {
file.Write(data, 0, data.Length);
} catch (Exception e) {
Debug.LogError(e.Message);
}
}
else
{
byte error;
if (data.Length > 1000)
{
Debug.LogError("NEARING DATA LIMIT of 1400- this can be increased!");
}
byte channel = parent.unreliableChannelId;
if (reliableChannel)
{
channel = parent.reliableSequencedChannelId;
}
NetworkTransport.Send(parent.hostId, recConnectionId, channel, data, data.Length, out error);
NetworkError networkError = (NetworkError)error;
if (networkError != NetworkError.Ok)
{
Debug.LogError(string.Format("Error: {0}, hostId: {1}, connectionId: {2}, channelId: {3}", networkError, parent.hostId, this.recConnectionId, channel));
}
}
}
}
public static void SendNetworkWriter <TPeer>(NetworkWriter writer, IEnumerable <TPeer> peers) where TPeer : NetworkPeer
{
byte error;
byte[] bufferData = writer.AsArray();
short bufferSize = writer.Position;
foreach (TPeer peer in peers)
{
if (!peer.isConnected)
{
return;
}
NetworkTransport.Send(peer.hostId, peer.connectionId, 0, bufferData, bufferSize, out error);
#if SHOW_SEND_ERRORS
NetworkError nerror = (NetworkError)error;
if (nerror != NetworkError.Ok)
{
Debug.LogError("Network error: " + nerror);
}
#endif
}
}
void ClientManager_ConnectingFailed(NetworkError error)
{
Assert.IsTrue(m_ClientNetworkManager.Connection.IsConnected == false);
Assert.IsTrue(m_ClientNetworkManager.Connection.LastError == error);
Debug.Log("ClientManager_ConnectingFailed " + error);
}
private bool IsFatalError(NetworkError error)
{
switch (error)
{
case NetworkError.WrongHost:
case NetworkError.WrongConnection:
case NetworkError.WrongChannel:
case NetworkError.NoResources:
case NetworkError.VersionMismatch:
case NetworkError.DNSFailure:
case NetworkError.CRCMismatch:
case NetworkError.BadMessage:
case NetworkError.UsageError:
return(true);
case NetworkError.Timeout: // Timeout is not considered an error for the server. A client can timeout without killing the server.
case NetworkError.Ok:
case NetworkError.MessageToLong:
case NetworkError.WrongOperation:
return(false);
default:
Log.CreatePossibleBugException(string.Format("Dissonance UNet received unknown NetworkError: '{0}'", error), "7975E556-3821-4360-8C60-31E9C03C4C4F");
return(true);
}
}
public void Init(bool isServer)
{
byte error;
host = hostText.text;
port = Convert.ToInt32(portText.text.ToString());
this.isServer = isServer;
NetworkTransport.Init();
config = new ConnectionConfig();
config.AddChannel(QosType.Reliable);
if (isServer)
{
topology = new HostTopology(config, 10);
hostId = NetworkTransport.AddHost(topology, port);
Debug.Log("Server started on port" + port + " with id of " + hostId);
}
else
{
topology = new HostTopology(config, 1);
hostId = NetworkTransport.AddHost(topology, 0);
connectionId = NetworkTransport.Connect(hostId, host, port, 0, out error);
NetworkError networkError = (NetworkError)error;
if (networkError != NetworkError.Ok)
{
Debug.LogError(string.Format("Unable to connect to {0}:{1}, Error: {2}", host, port, networkError));
}
else
{
Debug.Log(string.Format("Connected to {0}:{1} with hostId: {2}, connectionId: {3}, channelId: {4},", host, port, hostId, connectionId, channelId));
}
}
isInit = true;
}
public void actuallySendData()
{
// count size:
if (outgoingMessages.Count > 0 && OperationNetwork.connected)
{
int size = 0;
for (int i = 0; i < outgoingMessages.Count; i++)
{
size += outgoingMessages[i].Length;
}
byte[] sendData = new byte[size];
size = 0;
for (int i = 0; i < outgoingMessages.Count; i++)
{
Buffer.BlockCopy(outgoingMessages[i], 0, sendData, size, outgoingMessages[i].Length);
size += outgoingMessages[i].Length;
}
dataOutRate += sendData.Length;
byte error;
if (sendData.Length > 600)
{
Debug.LogError("Nearing Buffer Limit on Client! Count: " + sendData.Length);
}
NetworkTransport.Send(hostId, connectionId, reliableSequencedChannelId, sendData, sendData.Length, out error);
NetworkError networkError = (NetworkError)error;
if (networkError != NetworkError.Ok)
{
Debug.LogError(string.Format("Error: {0}, hostId: {1}, connectionId: {2}, channelId: {3}", networkError, hostId, connectionId, reliableSequencedChannelId));
}
}
outgoingMessages.Clear();
}
public void OnDisconnect(int hostId, int connectionId, NetworkError error)
{
Destroy(connectionClient[connectionId].Gtext);
connectionClient.Remove(connectionId);
Debug.Log("OnDisconnect(hostId = " + hostId + ", connectionId = "
+ connectionId + ", error = " + error.ToString() + ")");
}
public bool SendMessage(int connectionId, NetworkWriter writer, int channel, out NetworkError Error)
{
byte error;
byte[] buffer = writer.ToArray();
NetworkTransport.Send(SocketId, connectionId, channel, buffer, buffer.Length, out error);
Error = (NetworkError)error;
if (Error != NetworkError.Ok)
{
return true;
}
else
{
return false;
}
}
public Recv( int hid )
{
// TODO: Make the buffer size configurable
buffer = new byte[1024];
byte err;
msg = NetworkTransport.ReceiveFromHost( hid, out conId, out chanId, buffer
, 1024, out recvSize, out err );
error = (NetworkError)err;
}
public void AddNetworkListeners(NetworkConnected netConCall, DataSent dataSentCall, DataReceived dataRecvCall, NetworkError netErrorCall) {
OnNetworkConnected += netConCall;
OnDataSent += dataSentCall;
OnDataReceived += dataRecvCall;
OnNetworkError += netErrorCall;
}
private void Listen()
{
byte[] buffer = new byte[packetSize];
NetworkEventType rEvent = NetworkEventType.DataEvent;
while (rEvent != NetworkEventType.Nothing) {
byte rError;
rEvent = NetworkTransport.Receive(out recSocketId, out recConnectionId, out recChannelId, buffer, buffer.Length, out recievedSize, out rError);
recError = (NetworkError)rError;
switch (rEvent) {
case NetworkEventType.Nothing:
break;
case NetworkEventType.ConnectEvent:
bool unexpectedConnection = isClient && recConnectionId != attemptConnectionId;
if (recSocketId == localSocketId && !unexpectedConnection && recError == NetworkError.Ok) {
ConnectionData data = GetConnectionData(recConnectionId);
if (isServer) {
for (int i = 0; i < clientConnectionIds.Length; i++) {
if (clientConnectionIds[i] < 0) {
clientConnectionIds[i] = recSocketId;
break;
}
}
numConnections++;
foreach (NetScript inst in NetScript.Instances) {
inst.OnBackstabClientConnected(data);
}
} else if (isClient) {
serverConnectionId = recConnectionId;
foreach (NetScript inst in NetScript.Instances) {
inst.OnBackstabConnectedToServer(data);
}
} else {
Debug.LogError("Can't connect if neither server nor client.");
}
} else {
Debug.Log(string.Format("recieved socket id: {0} expected socket id: {1}", recSocketId, localSocketId));
//Debug.Log(string.Format("recieved connection id: {0} expected connection id: {1}", recConnectionId, attemptConnectionId));
foreach (NetScript inst in NetScript.Instances) {
inst.OnBackstabFailedToConnect();
}
}
break;
case NetworkEventType.DataEvent:
System.Object packet = Deserialize(buffer);
if (packet is RpcData) {
GetRpc(packet as RpcData);
}
break;
case NetworkEventType.DisconnectEvent:
numConnections--;
if (isServer) {
clientConnectionIds[recConnectionId] = -99;
foreach (NetScript inst in NetScript.Instances) {
inst.OnBackstabClientDisconnected();
}
} else {
foreach (NetScript inst in NetScript.Instances) {
inst.OnBackstabDisconnectedFromServer();
}
}
break;
case NetworkEventType.BroadcastEvent:
string address;
int recPort;
byte error;
NetworkTransport.GetBroadcastConnectionInfo(broadcastSocket, out address, out recPort, out error);
if (error != (byte)NetworkError.Ok) Debug.Log("Recieved broadcast from bad connection.");
NetworkTransport.GetBroadcastConnectionMessage(broadcastSocket, buffer, buffer.Length, out recievedSize, out error);
string message = (string)Deserialize(buffer);
TryAddBroadcaster(address, port, message);
foreach (NetScript inst in NetScript.Instances) {
inst.OnBackstabGotBroadcast();
}
break;
default:
Debug.LogError("Unrecognized event type");
break;
}
}
}
private void onSent(IAsyncResult ar)
{
int tx = -1;
try
{
tx = clientSocket.EndSend(ar);
}
catch (SocketException se)
{
ErrorOccured = true;
Error = NetworkError.TransmissionError;
ErrorMessage = se.Message;
if (NetworkErrorOccured != null)
NetworkErrorOccured();
return;
}
if (tx < 0)
{
ErrorOccured = true;
Error = NetworkError.TransmissionError;
ErrorMessage = "Transmission recieve error, data recieved was zero bytes";
if (NetworkErrorOccured != null)
NetworkErrorOccured();
return;
}
}
public bool SendMessage(int connectionId, NetworkWriter writer, out NetworkError Error)
{
return SendMessage(connectionId, writer, 0, out Error);
}
private bool SendMessage(NetworkWriter writer, int channelId, out NetworkError error)
{
error = NetworkError.WrongConnection;
if (!isConnected)
{
Debug.LogWarning("LLApiClient is not Connected");
return false;
}
byte errorByte;
byte[] buffer = writer.ToArray();
NetworkTransport.Send(SocketId, ConnectionId, channelId, buffer, buffer.Length, out errorByte);
error = (NetworkError)errorByte;
if(error!= NetworkError.Ok)
{
Debug.LogError("LLApiClient Sock: " + SocketId + " ConId: " + ConnectionId + " Error Sending Message : " + error);
return false;
}
return true;
}
private void onConnectComplete(IAsyncResult ar)
{
try
{
clientSocket.EndConnect(ar);
this.Connected = true;
}
catch (SocketException se)
{
ErrorOccured = true;
Error = NetworkError.ConnectionError;
ErrorMessage = se.Message;
if (NetworkErrorOccured != null)
NetworkErrorOccured();
return;
}
catch (Exception e)
{
ErrorOccured = true;
Error = NetworkError.UnknownError;
ErrorMessage = e.Message;
if (NetworkErrorOccured != null)
NetworkErrorOccured();
return;
}
try
{
clientSocket.BeginReceive(buffer, 0, 1024, SocketFlags.None, onRecieveCallback, null);
}
catch (SocketException se)
{
if (se.ErrorCode == 10054)
{
this.Connected = false;
ErrorOccured = true;
Error = NetworkError.ConnectionError;
ErrorMessage = se.Message;
if (NetworkErrorOccured != null)
NetworkErrorOccured();
}
}
if (OnConnectComplete != null)
OnConnectComplete();
}
private void onRecieve(IAsyncResult ar)
{
int rx = -1;
try
{
rx = clientSocket.EndReceive(ar);
}
catch (SocketException se)
{
if (se.ErrorCode == 10054)
{
ErrorOccured = true;
Error = NetworkError.Disconnect;
ErrorMessage = se.Message;
return;
}
}
byte[] recieved = new byte[rx];
Array.Copy(buffer, recieved, rx);
string message = Encoding.ASCII.GetString(recieved);
clientSocket.BeginReceive(buffer, 0, 1024, SocketFlags.None, onRecieveCallback, null);
if (message.StartsWith("#LOGIN"))
{
var success = (message.Split('|')[1] == "true" ? true : false);
if (success)
{
var isAdmin = (message.Split('|')[2] == "true" ? true : false);
Usable = true;
if (LoginComplete != null)
LoginComplete(true);
}
else if (LoginComplete != null)
LoginComplete(false);
}
else if (DataReady != null)
DataReady(message);
this.connecting = false;
}
private bool SendMessage(NetworkWriter writer, out NetworkError error)
{
return SendMessage(writer, 0, out error);
}
public void WriteLine(string line)
{
if (Usable || line.StartsWith("#LOGIN"))
{
byte[] data = Encoding.ASCII.GetBytes(line);
try
{
clientSocket.BeginSend(data, 0, data.Length, SocketFlags.None, onSentCallback, null);
}
catch (SocketException se)
{
if (se.ErrorCode == 10054)
{
ErrorOccured = true;
Error = NetworkError.Disconnect;
ErrorMessage = se.Message;
return;
}
}
}
}
