void FixedUpdate()
{
if (runTest)
{
runTest = false;
}
int recHostId;
int connectionId;
int channelId;
int bufferSize = 1024;
int dataSize;
byte error;
bool loop = true;
for (int i = 0; i < 10 && loop; ++i)
{
NetworkEventType recData = NetworkTransport.Receive(out recHostId, out connectionId, out channelId, recvBuffer, bufferSize, out dataSize, out error);
//if(channelId == unreliableCHN) {
// Debug.Log("unreliable: " + dataSize);
//}
switch (recData)
{
case NetworkEventType.Nothing: //1
loop = false;
break;
case NetworkEventType.ConnectEvent: //2
serverConId = recHostId;
Debug.Log("ConnectEvent datasize " + dataSize + " error " + error);
break;
case NetworkEventType.DataEvent: //3
decodeRawData(recvBuffer, synchronizedComponents);
break;
case NetworkEventType.DisconnectEvent: //4
Debug.Log(recData.ToString());
break;
}
}
sendRPCs();
}
private IEnumerator Receiver()
{
int recSocketId, recConnectionId, recChannelId, recDataSize;
byte error = 0;
byte[] recBuffer = new byte[_bufferSize];
while (true)
{
NetworkEventType netEventType = NetworkTransport.Receive
(
out recSocketId,
out recConnectionId,
out recChannelId,
recBuffer,
_bufferSize,
out recDataSize,
out error
);
if (error != 0)
{
Debug.Log($"Error ID -> {error}");
}
else
{
switch (netEventType)
{
case NetworkEventType.Nothing:
{
yield return(null);
break;
}
case NetworkEventType.DataEvent:
{
OnDataReceived(recConnectionId, recChannelId, recBuffer, recDataSize);
break;
}
case NetworkEventType.ConnectEvent:
{
OnConnectedToServer(recConnectionId);
break;
}
case NetworkEventType.DisconnectEvent:
{
OnDisconnected(recSocketId, recConnectionId);
break;
}
default:
{
Debug.LogWarning($"Receiver -> Unrecognized Message Type [{netEventType.ToString()}]");
break;
}
}
if (error != 0)
{
Debug.Log($"Error ID -> {error}");
}
}
}
}
static void Start(RelayConfig rConfig)
{
RelayConfig.CurrentConfig = rConfig;
Console.WriteLine("================================");
Console.WriteLine("[INFO] Starting relay...");
unet = new NetLibraryManager(rConfig.globalConfig);
messageBuffer = new byte[RelayConfig.CurrentConfig.bufferSize];
HostTopology hostTopology = new HostTopology(RelayConfig.CurrentConfig.connectionConfig, RelayConfig.CurrentConfig.maxConnections);
unet.AddHost(hostTopology, RelayConfig.CurrentConfig.relayPort, null);
Console.WriteLine("[INFO] Relay started!");
Console.WriteLine("[INFO] Press [Q] to quit the application");
while ((!Console.KeyAvailable || Console.ReadKey(true).Key != ConsoleKey.Q))
{
NetworkEventType @event = unet.Receive(out int hostId, out int connectionId, out int channelId, messageBuffer, RelayConfig.CurrentConfig.bufferSize, out int receivedSize, out byte errorByte);
NetworkError error = (NetworkError)errorByte;
if (error != NetworkError.Ok)
{
ConsoleColor previousColor = Console.ForegroundColor;
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine("[ERROR] Relay encountered UNET transport error \"" + error.ToString() + "\" during a \"" + @event.ToString() + "\" event.");
Console.ForegroundColor = previousColor;
}
switch (@event)
{
case NetworkEventType.DataEvent:
{
MessageType mType = (MessageType)messageBuffer[receivedSize - 1];
switch (mType)
{
case MessageType.StartServer:
{
//Check if they are already connected or perhaps are already hosting, if so return
Client client;
Room room = new Room(client = new Client()
{
connectionId = (ushort)connectionId,
hostId = (byte)hostId,
isServer = true,
connectTick = DateTime.UtcNow.Ticks
});
rooms.Add(room);
unet.GetConnectionInfo(hostId, connectionId, out string address, out int port, out byte byteError);
if (RelayConfig.CurrentConfig.enableRuntimeMetaLogging)
{
Console.WriteLine("[INFO] Server started from address " + address);
}
addressToRoom.Add(address + ":" + port, room);
}
break;
case MessageType.ConnectToServer:
{
//Check if they are already connected or perhaps are already hosting; if so, return
byte addressLength = (byte)(receivedSize - 1); //messageBuffer[1]; // address length + ip type
string addressAndPort = Encoding.ASCII.GetString(messageBuffer, 0, addressLength);
addressAndPort = addressAndPort.AsIPv6CompatString();
if (RelayConfig.CurrentConfig.enableRuntimeMetaLogging)
{
Console.WriteLine("[INFO] Connection requested to address " + addressAndPort);
}
if (addressToRoom.ContainsKey(addressAndPort))
{
if (RelayConfig.CurrentConfig.enableRuntimeMetaLogging)
{
Console.WriteLine("[INFO] Connection approved");
}
Room room = addressToRoom[addressAndPort];
Client client = new Client()
{
connectionId = (ushort)connectionId,
hostId = (byte)hostId,
isServer = false,
connectTick = DateTime.UtcNow.Ticks
};
room.HandleClientConnect(client);
}
}
break;
case MessageType.Data:
{
foreach (var room in rooms)
{
if (room.HasPeer((ushort)connectionId, out bool isServer))
{
// Found a matching client in room
if (isServer)
{
ushort destination = (ushort)(messageBuffer[receivedSize - 3] | (messageBuffer[receivedSize - 2] << 8));
//Safety check. Make sure who they want to send to ACTUALLY belongs to their room
if (room.HasPeer(destination, out isServer) && !isServer)
{
// TODO: Use unsafe to make messageBuffer look smaller
//ReverseOffset(messageBuffer, 2, receivedSize);
messageBuffer[receivedSize - 3] = (byte)MessageType.Data; // [data, data, data, dest1, dest2, mtype_r, none, none, none] => [{data, data, data, mtype_s}, dest2, mtype_r, none, none, none]
room.Send(hostId, destination, connectionId, channelId, messageBuffer, receivedSize - 2, out errorByte);
}
}
else
{
// Read client message
//ForwardOffset(messageBuffer, 2, receivedSize);
messageBuffer.ToBytes((ushort)connectionId, receivedSize - 1); // Put connection id at the end of the recieved message (because optimization)
messageBuffer[receivedSize + 1] = (byte)MessageType.Data; // Set message type
room.Send(hostId, room.ServerID, connectionId, channelId, messageBuffer, receivedSize + 2, out errorByte);
}
}
}
}
break;
case MessageType.ClientDisconnect:
{
ushort cid = messageBuffer.FromBytes(1);
if (RelayConfig.CurrentConfig.enableRuntimeMetaLogging)
{
Console.WriteLine("[INFO] Client disconnect request");
}
foreach (Room room in rooms)
{
if (room.HandleClientDisconnect((ushort)cid, true))
{
--connectedPeers;
break;
}
}
}
break;
}
}
break;
case NetworkEventType.DisconnectEvent:
{
if (RelayConfig.CurrentConfig.enableRuntimeMetaLogging)
{
Console.WriteLine("[INFO] Peer disconnected");
}
foreach (Room room in rooms)
{
if (room.HandleClientDisconnect((ushort)connectionId))
{
--connectedPeers;
break;
}
}
}
break;
case NetworkEventType.Nothing:
Thread.Sleep(1);
break;
case NetworkEventType.ConnectEvent:
{
connectedPeers++;
}
break;
}
if (lastConnectedClients != connectedPeers && (DateTime.UtcNow.Ticks - lastPrintedConnectedClientsTick) > 30 * TimeSpan.TicksPerSecond)
{
lastPrintedConnectedClientsTick = DateTime.UtcNow.Ticks;
lastConnectedClients = connectedPeers;
PrintStatusUpdate();
}
}
Console.WriteLine("[INFO] Relay shutting down...");
}
void FixedUpdate()
{
bool loop = true;
int recHostId;
int recConnectionId;
int channelId;
int dataSize;
byte error;
newConnectionList.Clear();
for (int i = 0; i < 10 && loop; ++i)
{
NetworkEventType recData = NetworkTransport.Receive(out recHostId, out recConnectionId, out channelId, recvBuffer, bufferSize, out dataSize, out error);
if (dataSize >= bufferSize)
{
Debug.LogWarning("the data received exceeds the buffer size!");
}
//if (channelId == unreliableCHN) {
// Debug.Log("unreliable: " + dataSize);
//}
switch (recData)
{
case NetworkEventType.Nothing: //1
loop = false;
break;
case NetworkEventType.ConnectEvent: //2
Debug.Log("socket id " + recHostId + ", conn " + recConnectionId + ", channel " + channelId);
newConnectionList.Add(recConnectionId);
break;
case NetworkEventType.DataEvent: //3
ClientTest.decodeRawData(recvBuffer, synchronizedComponents);
break;
case NetworkEventType.DisconnectEvent: //4
int idx = getIndexByConnectionId(recConnectionId);
if (idx >= 0)
{
Debug.Log("player " + recConnectionId + " disconnected.");
for (int j = 0; j < playerOwned.Count; ++j)
{
if (playerOwned[j].connectionId == recConnectionId)
{
//playerStates.RemoveAt(j);
//sendBuffers.RemoveAt(j * 2 + 1);
//sendBuffers.RemoveAt(j * 2);
List <GameObjectSpawnInfo> toRemove = playerOwned[j].gameObjectsOwned;
for (int k = 0; k < toRemove.Count; ++k)
{
GameObject.Destroy(toRemove[k].obj);
}
playerOwned.RemoveAt(j);
break;
}
}
}
Debug.Log(recData.ToString());
break;
}
}
for (int i = 0; i < newConnectionList.Count; ++i)
{
// create player state
playerOwned.Add(new PlayerOwnedInfo(newConnectionList[i]));
replicateExistingGameObjectsToNewClient(newConnectionList[i]);
spawnReplicatedGameObject(newConnectionList[i], PlayerStatePrefabPath);
}
sendAllBuffers();
}
private IEnumerator Receiver()
{
int recSocketId, recConnectionId, recChannelId, recDataSize;
byte error = 0;
byte[] recBuffer = new byte[_bufferSize];
while (true)
{
NetworkEventType netEventType = NetworkTransport.Receive
(
out recSocketId,
out recConnectionId,
out recChannelId,
recBuffer,
_bufferSize,
out recDataSize,
out error
);
if (error != 0)
{
Debug.LogError($"@Client -> @Receiver : Error ID [{error}]");
}
else
{
switch (netEventType)
{
case NetworkEventType.Nothing:
{
yield return(null);
break;
}
case NetworkEventType.DataEvent:
{
OnDataReceived(recChannelId, recBuffer, recDataSize);
break;
}
case NetworkEventType.ConnectEvent:
{
Debug.Log($"@Client -> Receiver.Connect : Socket[{recSocketId}], userId[{recConnectionId}]");
break;
}
case NetworkEventType.DisconnectEvent:
{
Debug.Log($"@Client -> Receiver.Disconnect : Socket[{recSocketId}], userId[{recConnectionId}]");
Application.Quit();
break;
}
default:
{
Debug.LogError($"@Client -> @Receiver : Unrecognized Message Type [{netEventType.ToString()}]");
break;
}
}
}
}
}
