// Update is called once per frame
void Update()
{
recBuffer = new byte[1024];
NetworkEventType recData = NetworkTransport.Receive(out recHostId, out connectionId, out channelId, recBuffer, bufferSize, out dataSize, out error);
switch (recData)
{
case NetworkEventType.Nothing:
break;
case NetworkEventType.ConnectEvent:
ConnectionEvent?.Invoke(null,
new UnetConnectionMsg(recHostId, connectionId, channelId, "", 0));
break;
case NetworkEventType.DataEvent:
DataEvent?.Invoke(null, new UnetDataMsg(hostId, connectionId, channelId, System.Text.Encoding.UTF8.GetString(recBuffer)));
break;
case NetworkEventType.DisconnectEvent:
DisconnectionEvent?.Invoke(null,
new UnetConnectionMsg(recHostId, connectionId, channelId, "", 0));
break;
}
}
public void Update()
{
if (!isStarted)
{
return;
}
int recHostId;
int connectionId;
int channelId;
byte[] recBuffer = new byte[1024];
int bufferSize = 1024;
int dataSize;
byte error;
NetworkEventType recData = NetworkTransport.Receive(out recHostId, out connectionId, out channelId, recBuffer, bufferSize, out dataSize, out error);
switch (recData)
{
case NetworkEventType.Nothing: //1
break;
case NetworkEventType.ConnectEvent: //2
Debug.Log(connectionId + " connected!");
break;
case NetworkEventType.DataEvent: //3
break;
case NetworkEventType.DisconnectEvent: //4
Debug.Log(connectionId + " disconnected!");
break;
}
}
public void Handle()
{
NetworkEventType recNetworkEvent = NetworkEventType.Nothing;
do
{
int recConnectionId;
int recChannelId;
int dataSize;
byte error;
recNetworkEvent = NetworkTransport.ReceiveFromHost(_hostId, out recConnectionId, out recChannelId, _buffer, BUFFER_SIZE, out dataSize, out error);
var netError = (NetworkError)error;
if (netError != NetworkError.Ok)
{
Debug.LogErrorFormat("Receive: {0}", netError);
return;
}
switch (recNetworkEvent)
{
case NetworkEventType.ConnectEvent:
onConnected(_hostId, recConnectionId);
break;
case NetworkEventType.DisconnectEvent:
onDisconnected(_hostId, recConnectionId);
break;
case NetworkEventType.DataEvent:
handleData(_hostId, recConnectionId, _buffer, dataSize);
break;
}
} while (recNetworkEvent != NetworkEventType.Nothing);
}
void Update()
{
int recsocketId;
int recConnectionId;
int recChannelId;
byte[] recBuffer = new byte[1024];
int bufferSize = 1024;
int dataSize;
byte error;
NetworkEventType recNetworkEvent = NetworkTransport.Receive(out recsocketId, out recConnectionId, out recChannelId, recBuffer, bufferSize, out dataSize, out error);
switch (recNetworkEvent)
{
case NetworkEventType.Nothing:
Debug.Log("nothing");
break;
case NetworkEventType.ConnectEvent:
Debug.Log("incoming connection event received");
break;
case NetworkEventType.DataEvent:
Stream stream = new MemoryStream(recBuffer);
BinaryFormatter formatter = new BinaryFormatter();
string message = formatter.Deserialize(stream) as string;
Debug.Log("incoming message event received: " + message);
break;
case NetworkEventType.DisconnectEvent:
Debug.Log("remote client event disconnected");
break;
}
}
public NetworkEvent(ushort networkedObjectId, NetworkEventType networkEventType, NetworkSubeventType networkSubeventType, object data)
{
this.destNetId = (NetworkIdentity)NetworkSerializer.GetNetworkedObjects()[networkedObjectId];
this.networkEventType = networkEventType;
this.networkSubeventType = networkSubeventType;
this.data = data;
}
// Takes part of the full data and disassembles it into a NetworkEvent
public static NetworkEvent DisassembleMessage(byte[] message, int startIndex, out int newIndex)
{
ushort objId = DeserializeUShort(message, startIndex);
NetworkEventType netEventType = (NetworkEventType)DeserializeUShort(message, startIndex + 2);
NetworkSubeventType netSubeventType = (NetworkSubeventType)message[startIndex + 4];
object data = null;
newIndex = 1;
switch (netEventType)
{
case NetworkEventType.TriggerEvent:
break;
case NetworkEventType.UpdatePosition:
data = DeserializeTransform(message, startIndex + 5);
newIndex = 41;
break;
default:
break;
}
NetworkEvent returnVal = new NetworkEvent(objId, netEventType, netSubeventType, data);
return(returnVal);
}
// Update is called once per frame
void Update()
{
byte[] buffer = new byte[1024];
int hostid, conid, channelid, datasize;
NetworkEventType netEvent = NetworkTransport.Receive(out hostid, out conid, out channelid, buffer, 1024, out datasize, out error);
switch (netEvent)
{
case NetworkEventType.ConnectEvent:
Debug.Log("Connection from: " + hostid);
connectionID = conid;
NetworkManager.manager.SendSetup();
NetworkManager.manager.SendSync();
NetworkManager.manager.SendNext(MazeController.mcont.maze.seed);
break;
case NetworkEventType.DisconnectEvent:
Debug.Log(hostid + " disconnected");
break;
case NetworkEventType.DataEvent:
string msg = Encoding.Unicode.GetString(buffer);
Debug.Log("Message Recieved: " + msg);
break;
}
}
private void RaiseNetworkEvent(NetworkEventType type, byte[] data)
{
if (DataTransmitted != null)
{
DataTransmitted(new NetworkEventData(type, data));
}
}
public NetworkEvent(NetworkEventType type, ushort id, bool allowClientSend, object data = null)
{
if (!allowClientSend && GameMain.Server == null)
{
return;
}
eventType = type;
if (overridePrevious[(int)type])
{
if (type == NetworkEventType.ComponentUpdate || type == NetworkEventType.ImportantComponentUpdate)
{
if (Events.Any(e => e.id == id && e.eventType == type && data == e.data))
{
return;
}
}
else
{
if (Events.Any(e => e.id == id && e.eventType == type))
{
return;
}
}
}
this.id = id;
isClientEvent = allowClientSend;
this.data = data;
Events.Add(this);
}
// Update is called once per frame
void Update()
{
if (!mHostClientInitialized)
{
return;
}
int SocketId;
int connectionId;
int channelId;
int dataSize;
byte[] buffer = new byte[1024];
byte error;
NetworkEventType networkEvent = NetworkEventType.DataEvent;
// Poll both server/client events
do
{
networkEvent = NetworkTransport.Receive(out SocketId, out connectionId, out channelId, buffer, 1024, out dataSize, out error);
switch (networkEvent)
{
case NetworkEventType.Nothing:
break;
case NetworkEventType.ConnectEvent:
// Server received disconnect event
if (SocketId == mServerSocket)
{
Debug.Log("Server: Player " + connectionId.ToString() + " connected!");
Clients_Id.Add(connectionId);
}
break;
case NetworkEventType.DataEvent:
// Server received data
if (SocketId == mServerSocket)
{
// decode data
Stream stream = new MemoryStream(buffer);
BinaryFormatter f = new BinaryFormatter();
string msg = f.Deserialize(stream).ToString();
Debug.Log(connectionId.ToString() + " : " + msg);
BroadcastData(connectionId.ToString() + " : " + msg);
}
break;
case NetworkEventType.DisconnectEvent:
// Server received disconnect event
if (SocketId == mServerSocket)
{
Debug.Log("Server: Received disconnect from " + connectionId.ToString());
Clients_Id.Remove(connectionId);
}
break;
}
} while (networkEvent != NetworkEventType.Nothing);
}
private void Update()
{
if (ConnectionID == -1)
{
return;
}
int connectionId;
int channelId;
byte[] recBuffer = new byte[1024];
int bufferSize = 1024;
int dataSize;
byte error;
var sender = new RemotePoint();
sender.reliable = channels[QosType.Reliable];
sender.unreliable = channels[QosType.Unreliable];
NetworkEventType recData = NetworkTransport.Receive(out sender.recHostId, out sender.connectionID, out channelId, recBuffer, bufferSize, out dataSize, out error);
switch (recData)
{
case NetworkEventType.Nothing: break;
case NetworkEventType.ConnectEvent:
if (sender.connectionID == ConnectionID)
{
// connection approved
Send(MessageType.Hello, new Hello("HEY THERE! IM A CLIENT!"));
}
else
{
// someone sent a connection request to me
}
break;
case NetworkEventType.DataEvent:
var reader = new NetworkReader(recBuffer);
dispatcher.Notify((MessageType)reader.ReadByte(), reader, sender);
break;
case NetworkEventType.DisconnectEvent:
if (sender.connectionID == ConnectionID)
{
// connection error
Debug.LogError((NetworkError)error);
}
else
{
// someone disconnected from me
}
break;
case NetworkEventType.BroadcastEvent:
break;
}
}
// Update is called once per frame
void Update()
{
int recHostId;
int connectionId;
int channelId;
byte[] recBuffer = new byte[1024];
int bufferSize = 1024;
int dataSize;
byte error;
NetworkEventType recData = NetworkTransport.Receive(out recHostId, out connectionId, out channelId, recBuffer, bufferSize, out dataSize, out error);
switch (recData)
{
case NetworkEventType.ConnectEvent:
Debug.Log("Client Connected on " + connectionId);
break;
case NetworkEventType.DataEvent:
Message msg = Message.ByteArrayToMessage(recBuffer);
Debug.Log(msg);
HandleMessage(msg, connectionId);
break;
case NetworkEventType.DisconnectEvent:
Debug.Log("Client Disconnected");
break;
}
}
private void ListenHost()
{
int connectionId;
int channelId;
byte[] recBuffer = new byte[1024];
int bufferSize = 1024;
int dataSize;
byte error;
NetworkEventType recData = NetworkTransport.ReceiveFromHost(hostId, out connectionId, out channelId, recBuffer, bufferSize, out dataSize, out error);
switch (recData)
{
case NetworkEventType.Nothing: //1
break;
case NetworkEventType.ConnectEvent: //2
ConnectionEvent(connectionId);
break;
case NetworkEventType.DataEvent: //3
DataEvent(connectionId, channelId, dataSize, recBuffer);
break;
case NetworkEventType.DisconnectEvent: //4
DisconnectEvent(connectionId);
break;
}
}
void ReceiveAndHandleData()
{
NetworkEventType receivedData = ReceiveFromHost();
switch (receivedData)
{
case NetworkEventType.DataEvent:
Debug.Log(((char)message.recBuffer[0]).ToString() + ((char)message.recBuffer[1]).ToString() + ((char)message.recBuffer[2]).ToString());
break;
case NetworkEventType.ConnectEvent:
if (myConnectionId == message.connectionId)
{
Debug.Log("my active connect request approved: " + message.connectionId.ToString());
}
else
{
Debug.Log("somebody else connect to me: " + message.connectionId.ToString());
}
break;
case NetworkEventType.DisconnectEvent:
if (myConnectionId == message.connectionId)
{
Debug.Log("cannot connect by some reason see error: " + message.connectionId.ToString());
}
else
{
Debug.Log("one of the established connection has been disconnected: " + message.connectionId.ToString());
}
break;
}
}
private void Client()
{
//all the client code
int recHostID;
int connectionID;
int channelID;
byte[] recBuffer = new byte[1024];
int bufferSize = 1024;
int dataSize;
byte error;
NetworkEventType recData = NetworkTransport.Receive(out recHostID, out connectionID, out channelID, recBuffer, bufferSize, out dataSize, out error);
switch (recData)
{
case NetworkEventType.DataEvent:
if (!Host && connectionID == this.connectionID)
{
string msg = Encoding.Unicode.GetString(recBuffer, 0, dataSize);
message = msg;
processMsg(recBuffer);
}
break;
case NetworkEventType.ConnectEvent:
//if (connectionID == this.connectionID) {
//ConnectedToServer();
//}
break;
}
}
void Update()
{
if (hostId == -1)
{
return;
}
if (m_IsServer)
{
return;
}
int connectionId;
int channelId;
int receivedSize;
byte error;
NetworkEventType networkEvent = NetworkEventType.DataEvent;
do
{
networkEvent = NetworkTransport.ReceiveFromHost(hostId, out connectionId, out channelId, msgInBuffer, kMaxBroadcastMsgSize, out receivedSize, out error);
if (networkEvent == NetworkEventType.BroadcastEvent)
{
NetworkTransport.GetBroadcastConnectionMessage(hostId, msgInBuffer, kMaxBroadcastMsgSize, out receivedSize, out error);
string senderAddr;
int senderPort;
NetworkTransport.GetBroadcastConnectionInfo(hostId, out senderAddr, out senderPort, out error);
OnReceivedBroadcast(senderAddr, BytesToString(msgInBuffer));
}
} while (networkEvent != NetworkEventType.Nothing);
}
void Update()
{
if (!isStarted)
{
return;
}
int recHostId;
int connectionId;
int channelId;
byte[] recBuffer = new byte[1024];
int bufferSize = 1024;
int dataSize;
byte error;
NetworkEventType recData = NetworkTransport.Receive(out recHostId, out connectionId, out channelId, recBuffer, bufferSize, out dataSize, out error);
switch (recData)
{
case NetworkEventType.ConnectEvent:
Debug.Log("Player " + connectionId + " has connected");
OnConnection(connectionId);
break;
case NetworkEventType.DataEvent:
string msg = Encoding.Unicode.GetString(recBuffer, 0, dataSize);
Debug.Log("Recieving from " + connectionId + " : " + msg);
string[] splitData = msg.Split('|');
switch (splitData[0])
{
case "NAMEIS":
OnNameIs(connectionId, splitData[1]);
break;
case "PACKSREQUEST":
packMan.SendPacksInUse();
break;
case "CNN":
break;
case "DC":
OnDisconnect(connectionId);
break;
default:
Debug.LogWarning("Recieved invalid message : " + msg);
break;
}
break;
case NetworkEventType.DisconnectEvent:
OnDisconnect(connectionId);
break;
}
}
void ReceiveData()
{
int outHostId;
int outConnectionId;
int outChannelId;
byte[] buffer = new byte[ChunkSize];
int bufferSize = ChunkSize;
int receiveSize;
byte error;
NetworkEventType evnt = NetworkTransport.Receive(out outHostId, out outConnectionId, out outChannelId, buffer, bufferSize, out receiveSize, out error);
switch (evnt)
{
case NetworkEventType.ConnectEvent:
OnConnect(outHostId, outConnectionId, outChannelId, (NetworkError)error);
break;
case NetworkEventType.DataEvent:
OnData(outHostId, outConnectionId, outChannelId, buffer, receiveSize, (NetworkError)error);
break;
case NetworkEventType.DisconnectEvent:
Debug.Log("Disconnect event");
break;
}
}
public unsafe static NetworkEvent Serialize(ushort typeId, bool reliable, Dictionary <ushort, NetworkEventType> eventTypes, NetworkEventGenerator generator)
{
bool generateSchema = false;
NetworkEventType type;
if (!eventTypes.TryGetValue(typeId, out type))
{
generateSchema = true;
type = new NetworkEventType()
{
typeId = typeId, schema = new NetworkSchema(NetworkConfig.firstEventTypeSchemaId + typeId)
};
eventTypes.Add(typeId, type);
}
var result = Create(type, reliable);
result.sequence = ++s_Sequence;
if (NetworkConfig.netDebug.IntValue > 0)
GameDebug.Log("Serializing event " + ((GameNetworkEvents.EventType)result.type.typeId) + " in seq no: " + result.sequence);
fixed(uint *data = result.data)
{
NetworkWriter writer = new NetworkWriter(data, result.data.Length, type.schema, generateSchema);
generator(ref writer);
writer.Flush();
}
return(result);
}
void Update()
{
int recHostId;
int recConnectionId;
int recChannelId;
byte[] buffer = new byte[1024];
int bufferSize = buffer.Length;
int dataSize;
byte error;
NetworkEventType recData = NetworkTransport.Receive(out recHostId, out recConnectionId, out recChannelId, buffer, bufferSize, out dataSize, out error);
switch (recData)
{
case NetworkEventType.Nothing:
break;
case NetworkEventType.ConnectEvent:
Debug.Log("Connected");
break;
case NetworkEventType.DataEvent:
ProcessMessage(buffer);
break;
case NetworkEventType.DisconnectEvent:
Debug.Log("Disconnected");
break;
}
if (error != 0)
{
Debug.Log("Error Receiving Message: " + (NetworkError)error);
}
}
// Update
void Update()
{
if (!isStarted)
{
return;
}
int receivingHostId;
int connectionId;
int channelId;
int dataSize;
NetworkEventType recData = NetworkTransport.Receive(out receivingHostId, out connectionId, out channelId, receiveBuffer, bufferSize, out dataSize, out error);
if (error != 0)
{
Debug.Log("Network error: " + (NetworkError)error);
}
switch (recData)
{
case NetworkEventType.DataEvent:
var buffer = receiveBuffer.Take(dataSize).ToArray();
RPCManager.instance.HandleMessage(buffer, connectionId);
break;
}
}
// Update is called once per frame
void Update()
{
int recHostId;
int recConnectionId;
int recChannelId;
byte[] recbufffer = new byte[1024];
int bufferSize = 1024;
int dataSize;
byte error;
NetworkEventType recNetworkEvent = NetworkTransport.Receive(out recHostId, out recConnectionId, out recChannelId, recbufffer, bufferSize, out dataSize, out error);
switch (recNetworkEvent)
{
case NetworkEventType.DataEvent:
Stream stream = new MemoryStream(recbufffer);
BinaryFormatter formatter = new BinaryFormatter();
HandTransforms message = JsonUtility.FromJson <HandTransforms>(formatter.Deserialize(stream) as string);
hands[0].transform.SetPositionAndRotation(message.lPos, message.lRot);
hands[1].transform.SetPositionAndRotation(message.rPos, message.rRot);
Debug.Log("incoming message event receive: " + message);
break;
}
}
//this method deals with the socket connection
//connection, deconnecion, recieving of data
public void handleSocketConnection()
{
byte[] recBuffer = new byte[bufferSize];
byte error;
recNetworkEvent = NetworkTransport.Receive(out recHostId, out recConnectionId, out recChannelId, recBuffer, bufferSize, out dataSize, out error);
switch (recNetworkEvent)
{
case NetworkEventType.Nothing:
break;
case NetworkEventType.ConnectEvent:
Debug.Log("incoming connection event received");
networkText.text = "incoming connection event received";
break;
case NetworkEventType.DataEvent:
Stream stream = new MemoryStream(recBuffer);
BinaryFormatter formatter = new BinaryFormatter();
Debug.Log("we should not receive any data");
networkText.text = "we should not receive any data";
break;
case NetworkEventType.DisconnectEvent:
Debug.Log("remote client event disconnected");
networkText.text = "remote client event disconnected";
break;
}
}
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 string Receive()
{
string message = "";
int remoteSocketId;
int remoteConnectionId;
int remoteChannelId;
byte[] recBuffer = new byte[1024];
int bufferSize = 1024;
int dataSize;
byte error;
NetworkEventType receivedData = NetworkTransport.Receive(out remoteSocketId, out remoteConnectionId, out remoteChannelId, recBuffer, bufferSize, out dataSize, out error);
switch (receivedData)
{
case NetworkEventType.Nothing:
break;
case NetworkEventType.ConnectEvent:
Debug.Log("incoming connection event received");
break;
case NetworkEventType.DataEvent:
Stream stream = new MemoryStream(recBuffer);
BinaryFormatter formatter = new BinaryFormatter();
message = formatter.Deserialize(stream) as string;
break;
case NetworkEventType.DisconnectEvent:
Debug.Log("remote client event disconnected");
break;
}
return(message);
}
// Update is called once per frame
void Update()
{
int recHostId;
int connectionId;
int channelId;
byte[] recBuffer = new byte[1024];
int bufferSize = 1024;
int dataSize;
byte error;
NetworkEventType recData = NetworkTransport.Receive(out recHostId, out connectionId, out channelId, recBuffer, bufferSize, out dataSize, out error);
switch (recData)
{
case NetworkEventType.Nothing: break;
case NetworkEventType.ConnectEvent:
break;
case NetworkEventType.DataEvent:
break;
case NetworkEventType.DisconnectEvent:
break;
case NetworkEventType.BroadcastEvent: break;
}
}
// Update is called once per frame
void Update()
{
int dataSize;
int channel;
int connection;
byte error;
NetworkEventType recData = NetworkTransport.ReceiveFromHost(localHostId, out connection, out channel, recBuffer, bufferSize, out dataSize, out error);
switch (recData)
{
case NetworkEventType.Nothing:
break;
case NetworkEventType.ConnectEvent:
connected = true;
connectionId = connection;
Debug.Log("server connected: host " + localHostId + "connection " + connection);
break;
case NetworkEventType.DisconnectEvent:
break;
case NetworkEventType.DataEvent:
OnRecvGameMsg(recBuffer, dataSize);
break;
}
}
void Update()
{
int recHostID;
int recConnectionID;
int recChannelID;
byte[] recBuffer = new byte[1024];
int bufferSize = 1024;
int dataSize;
NetworkEventType recNetworkEvent = NetworkTransport.Receive(out recHostID, out recConnectionID, out recChannelID, recBuffer, bufferSize, out dataSize, out error);
switch (recNetworkEvent)
{
case NetworkEventType.ConnectEvent:
print("connection made to host: " + recHostID.ToString());
break;
case NetworkEventType.DataEvent:
string message = Encoding.Unicode.GetString(recBuffer, 0, dataSize);
print("Recieved: " + message);
testName = message;
break;
case NetworkEventType.DisconnectEvent:
print("d/c from host!");
break;
}
}
public void UpdateMessagePump()
{
if (!isStarted)
{
return;
}
int recHostId; // Is this from Web? Or standalone
int connectionId; // Which user is sending me this?
int channelId; // Which lane is he sending that message from
byte[] recBuffer = new byte[BYTE_SIZE];
int dataSize;
NetworkEventType type = NetworkTransport.Receive(out recHostId, out connectionId, out channelId, recBuffer, BYTE_SIZE, out dataSize, out error);
switch (type)
{
case NetworkEventType.DataEvent:
OnData(connectionId, channelId, recHostId, NetMessageSerializer.Deserialize(recBuffer));
break;
case NetworkEventType.Nothing:
break;
default:
Debug.Log("Received Event of Type: " + type);
break;
}
}
void Update()
{
byte[] recBuffer = new byte[BYTE_SIZE];
NetworkEventType type = NetworkTransport.Receive(out int recHostId, out int connectionId, out int channelId, recBuffer, BYTE_SIZE, out int dataSize, out byte error);
if ((NetworkError)error != NetworkError.Ok)
{
Debug.LogError("Message send error: " + (NetworkError)error);
}
switch (type)
{
case NetworkEventType.DataEvent:
BinaryFormatter formatter = new BinaryFormatter();
MemoryStream ms = new MemoryStream(recBuffer);
string msg = (string)formatter.Deserialize(ms);
Debug.Log(msg);
break;
case NetworkEventType.ConnectEvent:
Debug.Log("We have connected to the server");
break;
case NetworkEventType.DisconnectEvent:
Debug.Log("We have been disconnected");
break;
}
if (Input.GetKeyDown(KeyCode.Q))
{
Debug.Log("Q key pressed");
SendServer("Message from client to server");
}
}
public Recv Ignore( NetworkEventType t )
{
switch( t ) {
case NetworkEventType.ConnectEvent:
handledConnect = true;
break;
case NetworkEventType.DisconnectEvent:
handledDisconnect = true;
break;
case NetworkEventType.DataEvent:
handledData = true;
break;
}
return this;
}
void Update()
{
eventType = NetworkTransport.Receive(out recHostId, out connectionId, out channelId, buffer, bufferSize, out dataSize, out error);
if (error != (byte) NetworkError.Ok) {
Debug.LogError("[ERROR] NetworkAPI :: Update :: Receive : " + error);
if (dataSize > bufferSize) {
Debug.LogError("[ERROR] NetworkAPI :: Update : Message too big for be handled by buffer...");
}
return;
}
if (channelId == channelSetupId) {
switch (eventType) {
case NetworkEventType.ConnectEvent:
NetworkUI.Log("Connection on socket " + recHostId + ", connection : " + connectionId + ", channelId : " + channelId);
if (PlayerId == 0) {
OnConnection();
}
break;
// case NetworkEventType.DataEvent: break;
case NetworkEventType.DisconnectEvent:
Application.Quit(); // TEST quit on disconnect
break;
}
} else if (eventType == NetworkEventType.DataEvent) {
if (channelId == channelActionId && OnAction != null) {
OnAction(PlayerId == 0 ? 1 : 0, GameActionFactory.Get(buffer));
} else if (channelId == channelConfirmationId && OnConfirmation != null) {
OnConfirmation(PlayerId == 0 ? 1 : 0, GameConfirmation.FromBytes(buffer));
}
}
}
/// <summary>
/// Handle server messages for network.test
/// </summary>
/// <param name="networkEvent">Network event.</param>
/// <param name="connectionId">Connection identifier.</param>
/// <param name="channelId">Channel identifier.</param>
/// <param name="buffer">Buffer.</param>
/// <param name="datasize">Datasize.</param>
public void OnServerMessage( NetworkEventType networkEvent , int connectionId , int channelId , byte[] buffer, int datasize )
{
switch(networkEvent){
// Nothing
case NetworkEventType.Nothing:
break;
// Connect
case NetworkEventType.ConnectEvent:
mServer.SendStream("Hello from the server!" , 1024 , connectionId , NetManager.mChannelReliable );
break;
// Data
case NetworkEventType.DataEvent:
string data = mServer.ReceiveStream ( buffer ).ToString ();
switch(data){
case "Hello from the client!":
Debug.Log ( "Test SUCCESS: Received stream from client" );
mServer.BroadcastStream ("Broadcast test!" , 1024 , NetManager.mChannelReliable );
break;
default:
Debug.Log ( "Test FAIL : Data received on server was incorrect!" );
break;
}
break;
// Disconnect
case NetworkEventType.DisconnectEvent:
Debug.Log ("Client disconnect event processed, shutting down server");
NetManager.Shutdown ();
DebugConsole.Log ("All tests passed!");
break;
}
}
/// <summary>
/// Handle client messages for network.test
/// </summary>
/// <param name="networkEvent">Network event.</param>
/// <param name="connectionId">Connection identifier.</param>
/// <param name="channelId">Channel identifier.</param>
/// <param name="buffer">Buffer.</param>
/// <param name="datasize">Datasize.</param>
public void OnClientMessage( NetworkEventType networkEvent , int connectionId , int channelId , byte[] buffer, int datasize )
{
switch(networkEvent){
// Connect
case NetworkEventType.ConnectEvent:
break;
// Data
case NetworkEventType.DataEvent:
string data = mClient.ReceiveStream( buffer ).ToString ();
switch(data){
case "Hello from the server!":
mClient.SendStream ("Hello from the client!", 1024);
Debug.Log("Test SUCCESS : Received stream from server!");
break;
case "Broadcast test!":
Debug.Log ("Test SUCCESS : Received broadcast from server!");
mClient.Disconnect ();
break;
default:
Debug.Log ("Test FAIL : One or more data messages were incorrect!(" + data + ")");
break;
}
break;
// Disconnect
case NetworkEventType.DisconnectEvent:
break;
}
}
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;
}
