public void DisconnectAndCleanup()
{
clientToServerConnection.Close(client_driver);
//update drivers
client_driver.ScheduleUpdate().Complete();
server_driver.ScheduleUpdate().Complete();
ev = server_driver.PopEventForConnection(connectionToClient, out stream);
Assert.IsTrue(ev == NetworkEvent.Type.Disconnect, "NetworkEvent.Type.Disconnect was expected to appear, but " + ev + "appeared");
server_driver.Dispose();
client_driver.Dispose();
}
//Process any
void processNetworkEvents()
{
DataStreamReader stream; //Used for reading data from data network events
for (int i = 0; i < networkConnections.Length; i++) //For each active connection
{
if (!networkConnections[i].IsCreated)
{
Assert.IsTrue(true);
}
//Get network events for the connection
NetworkEvent.Type networkEvent;
while ((networkEvent = networkDriver.PopEventForConnection(networkConnections[i], out stream)) !=
NetworkEvent.Type.Empty)
{
if (networkEvent == NetworkEvent.Type.Data) //Connection sent data
{
#region Custom Data Processing
MessageParser.parse(stream); //Parse data
#endregion Custom Data Processing
}
else if (networkEvent == NetworkEvent.Type.Disconnect) //Connection disconnected
{
Debug.Log("Client disconnected from server");
//This ensures the connection will be cleaned up in cleanupConnections()
networkConnections[i] = default(NetworkConnection);
}
}
}
}
private void QueryForNewEvents()
{
DataStreamReader stream;
for (int i = 0; i < m_Connections.Length; i++)
{
if (!m_Connections[i].IsCreated)
{
continue;
}
NetworkEvent.Type cmd;
while ((cmd = m_Driver.PopEventForConnection(m_Connections[i], out stream)) !=
NetworkEvent.Type.Empty)
{
if (cmd == NetworkEvent.Type.Data)
{
var readerCtx = default(DataStreamReader.Context);
uint number = stream.ReadUInt(ref readerCtx);
Debug.Log("Got " + number + " from the Client adding + 2 to it.");
number += 2;
using (var writer = new DataStreamWriter(4, Allocator.Temp)) {
writer.Write(number);
m_Driver.Send(m_Pipeline, m_Connections[i], writer);
}
}
else if (cmd == NetworkEvent.Type.Disconnect)
{
Debug.Log("Client disconnected from server");
m_Connections[i] = default(NetworkConnection);
}
}
}
}
void Update()
{
driver.ScheduleUpdate().Complete();
AcceptNewConnections();
numClients.text = "Clients: " + connections.Length.ToString();
PrintClientMessages();
UpdateClientPositions(Time.deltaTime);
DataStreamReader stream;
for (int i = 0; i < connections.Length; i++)
{
if (!connections[i].IsCreated)
{
Assert.IsTrue(true);
}
clientTimers[i] += Time.deltaTime;
if (clientTimers[i] > dropTime)
{
DropConnection(i);
}
else
{
NetworkEvent.Type cmd;
while ((cmd = driver.PopEventForConnection(connections[i], out stream)) != NetworkEvent.Type.Empty)
{
clientMessages[i] = ReadMessage(stream);
clientTimers[i] = 0;
SendMessage(GenerateFinalString(), driver, connections[i]);
}
}
}
}
public void SetupServerAndClientAndConnectThem(int bufferSize)
{
//setup server
server_driver = new UdpNetworkDriver(new NetworkDataStreamParameter {
size = bufferSize
});
NetworkEndPoint server_endpoint = NetworkEndPoint.LoopbackIpv4;
server_endpoint.Port = 1337;
server_driver.Bind(server_endpoint);
server_driver.Listen();
//setup client
client_driver = new UdpNetworkDriver(new NetworkDataStreamParameter {
size = bufferSize
});
clientToServerConnection = client_driver.Connect(server_endpoint);
//update drivers
client_driver.ScheduleUpdate().Complete();
server_driver.ScheduleUpdate().Complete();
//accept connection
connectionToClient = server_driver.Accept();
server_driver.ScheduleUpdate().Complete();
ev = server_driver.PopEventForConnection(connectionToClient, out stream);
Assert.IsTrue(ev == NetworkEvent.Type.Empty, "Not empty NetworkEvent on the server appeared");
client_driver.ScheduleUpdate().Complete();
ev = clientToServerConnection.PopEvent(client_driver, out stream);
Assert.IsTrue(ev == NetworkEvent.Type.Connect, "NetworkEvent should have Type.Connect on the client");
}
// Update is called once per frame
private void Update()
{
m_Driver.ScheduleUpdate().Complete();
// Clean up connections
for (int i = 0; i < m_Connections.Length; i++)
{
if (!m_Connections[i].IsCreated)
{
m_Connections.RemoveAtSwapBack(i);
--i;
}
}
// Accept new connections
NetworkConnection connection;
while ((connection = m_Driver.Accept()) != default(NetworkConnection))
{
m_Connections.Add(connection);
Debug.Log("Accepted a connection");
}
DataStreamReader stream;
for (int i = 0; i < m_Connections.Length; i++)
{
if (!m_Connections[i].IsCreated)
{
continue;
}
NetworkEvent.Type cmd;
while ((cmd = m_Driver.PopEventForConnection(m_Connections[i], out stream)) != NetworkEvent.Type.Empty)
{
if (cmd == NetworkEvent.Type.Data)
{
var readerCtx = default(DataStreamReader.Context);
uint number = stream.ReadUInt(ref readerCtx);
Debug.Log("Got " + number + " from the client adding + 2 to it and sending it back.");
number += 2;
using (var writer = new DataStreamWriter(4, Allocator.Temp))
{
writer.Write(number);
m_Driver.Send(m_Pipeline, m_Connections[i], writer);
}
}
else if (cmd == NetworkEvent.Type.Disconnect)
{
Debug.Log("Client disconnected from the server.");
m_Connections[i] = default;
}
}
}
}
// Update is called once per frame
void Update()
{
m_Driver.ScheduleUpdate().Complete();
// Clean up connections
for (int i = 0; i < m_Connections.Length; i++)
{
if (!m_Connections[i].IsCreated)
{
m_Connections.RemoveAtSwapBack(i);
--i;
}
}
// Accept new connections
NetworkConnection c;
while ((c = m_Driver.Accept()) != default(NetworkConnection))
{
m_Connections.Add(c);
Debug.Log("Accepted a connection");
}
DataStreamReader stream;
for (int i = 0; i < m_Connections.Length; i++)
{
if (!m_Connections[i].IsCreated)
{
continue;
}
NetworkEvent.Type cmd;
while ((cmd = m_Driver.PopEventForConnection(m_Connections[i], out stream)) !=
NetworkEvent.Type.Empty)
{
if (cmd == NetworkEvent.Type.Data)
{
//read received packet
DataStreamReader.Context readerCtx = default(DataStreamReader.Context);
PacketFunctions.ReadPacket(stream, ref readerCtx);
StartCoroutine(SendHelloClient(m_Connections[i]));
/*
* var readerCtx = default(DataStreamReader.Context);
* uint number = stream.ReadUInt(ref readerCtx);
* using (var writer = new DataStreamWriter(4, Allocator.Temp))
* {
* writer.Write(number);
* //other option
* //m_Connections[i].Send(m_Driver, writer);
* m_Driver.Send(NetworkPipeline.Null, m_Connections[i], writer);
* }
*/
}
}
}
}
private void Update()
{
m_Driver.ScheduleUpdate().Complete();
// CleanUpConnections
for (int i = 0; i < m_Connections.Length; i++)
{
if (!m_Connections[i].IsCreated)
{
Debug.Log($"Connection {i} has been cleaned up");
m_Connections.RemoveAtSwapBack(i);
--i;
}
}
NetworkConnection c;
while ((c = m_Driver.Accept()) != default(NetworkConnection))
{
Debug.Log($"New user connected: {c.InternalId}");
m_Connections.Add(c);
ClientConnected(c);
OnClientConnected?.Invoke(c);
}
DataStreamReader stream;
for (int i = 0; i < m_Connections.Length; i++)
{
if (!m_Connections[i].IsCreated)
{
Assert.IsTrue(true);
}
NetworkEvent.Type cmd;
var readerCtx = default(DataStreamReader.Context);
while ((cmd = m_Driver.PopEventForConnection(m_Connections[i], out stream)) != NetworkEvent.Type.Empty)
{
if (cmd == NetworkEvent.Type.Data)
{
Read(i, stream, ref readerCtx);
}
else if (cmd == NetworkEvent.Type.Disconnect)
{
Debug.Log("Client disconnected from server");
m_Connections[i] = default(NetworkConnection);
ClientDisconnected(m_Connections[i].InternalId);
OnClientDisconnected?.Invoke(m_Connections[i].InternalId);
}
}
}
OnUpdate();
}
void FixedUpdate()
{
if (!m_ServerDriver.IsCreated)
{
return;
}
// Update the NetworkDriver. It schedules a job so we must wait for that job with Complete
m_ServerDriver.ScheduleUpdate().Complete();
// Accept all new connections
while (true)
{
var con = m_ServerDriver.Accept();
// "Nothing more to accept" is signaled by returning an invalid connection from accept
if (!con.IsCreated)
{
break;
}
m_connections.Add(con);
}
for (int i = 0; i < m_connections.Length; ++i)
{
DataStreamReader strm;
NetworkEvent.Type cmd;
// Pop all events for the connection
while ((cmd = m_ServerDriver.PopEventForConnection(m_connections[i], out strm)) != NetworkEvent.Type.Empty)
{
if (cmd == NetworkEvent.Type.Data)
{
// For ping requests we reply with a pong message
// A DataStreamReader.Context is required to keep track of current read position since
// DataStreamReader is immutable
var readerCtx = default(DataStreamReader.Context);
int id = strm.ReadInt(ref readerCtx);
// Create a temporary DataStreamWriter to keep our serialized pong message
var pongData = new DataStreamWriter(4, Allocator.Temp);
pongData.Write(id);
// Send the pong message with the same id as the ping
m_ServerDriver.Send(NetworkPipeline.Null, m_connections[i], pongData);
}
else if (cmd == NetworkEvent.Type.Disconnect)
{
// This connection no longer exist, remove it from the list
// The next iteration will operate on the new connection we swapped in so as long as it exist the
// loop can continue
m_connections.RemoveAtSwapBack(i);
if (i >= m_connections.Length)
{
break;
}
}
}
}
}
void WaitingTurnProcess(NetworkConnection con, ref ActivGamePlayerState playerState, ref States playerTurn)
{
DataStreamReader reader;
NetworkEvent.Type cmd;
if ((cmd = m_driver.PopEventForConnection(con, out reader)) !=
NetworkEvent.Type.Empty)
{
if (cmd == NetworkEvent.Type.Data)
{
var readerCtx = default(DataStreamReader.Context);
int number = reader.ReadInt(ref readerCtx);
playerTurn = (States)number;
Debug.Log(string.Format("Client 1 from game {0} send {1}", m_id, number));
}
else if (cmd == NetworkEvent.Type.Disconnect)
{
Debug.Log(string.Format("Client 1 of game {0} disconnected from server", m_id));
con = default(NetworkConnection);
}
playerState = ActivGamePlayerState.WaitingOpponentTurn;
}
}
//Process any
void processNetworkEvents()
{
DataStreamReader stream; //Used for reading data from data network events
for (int i = 0; i < networkConnections.Length; i++) //For each active connection
{
if (!networkConnections[i].IsCreated)
{
Assert.IsTrue(true);
}
//Get network events for the connection
NetworkEvent.Type networkEvent;
while ((networkEvent = networkDriver.PopEventForConnection(networkConnections[i], out stream)) !=
NetworkEvent.Type.Empty)
{
if (networkEvent == NetworkEvent.Type.Data) //Connection sent data
{
//Tracks where in the data stream you are and how much you've read
var readerContext = default(DataStreamReader.Context);
#region Custom Data Processing
//Attempt to read uint from stream
uint number = stream.ReadUInt(ref readerContext);
int dataSize = 4; //Size of data being sent in bytes
Debug.Log("Got " + number + " from the Client adding + 2 to it.");
number += 2;
//DataStreamWriter is needed to send data
//using statement makes sure DataStreamWriter memory is disposed
using (var writer = new DataStreamWriter(dataSize, Allocator.Temp))
{
writer.Write(number); //Write response data
networkDriver.Send(networkPipeline, networkConnections[i], writer); //Send response data to client
}
#endregion Custom Data Processing
}
else if (networkEvent == NetworkEvent.Type.Disconnect) //Connection disconnected
{
Debug.Log("Client disconnected from server");
//This ensures the connection will be cleaned up in cleanupConnections()
networkConnections[i] = default(NetworkConnection);
}
}
}
}
void ReceiveData(int connIdx)
{
DataStreamReader stream;
NetworkEvent.Type cmd;
var conn = m_Connections[connIdx];
while ((cmd = m_Driver.PopEventForConnection(conn, out stream)) !=
NetworkEvent.Type.Empty)
{
Debug.Log("[SERVER] In the while loop to get messages");
if (cmd == NetworkEvent.Type.Data)
{
Debug.Log("[SERVER] If we've received data then");
var readerCtx = default(DataStreamReader.Context);
var infoBuffer = new byte[stream.Length];
stream.ReadBytesIntoArray(ref readerCtx, ref infoBuffer, stream.Length);
var resultString = Encoding.ASCII.GetString(infoBuffer);
Debug.Log("[SERVER] Got " + resultString + " from the Client: " + conn.InternalId);
var message = Decoder.Decode(resultString);
if (message != null && message.cmd == Commands.MOVEMENT)
{
dirty = true;
if (m_Players.ContainsKey(conn.InternalId))
{
m_Players[conn.InternalId].position.x += message.movePlayer.x;
m_Players[conn.InternalId].position.y += message.movePlayer.y;
}
else
{
Debug.Log("Cound not find player with Id: " + conn.InternalId);
}
}
}
else if (cmd == NetworkEvent.Type.Disconnect)
{
Debug.Log("[SERVER] Client disconnected from server with id: " + conn.InternalId);
conn = default(NetworkConnection);
m_DisconnectedPlayers.Add(m_Players[m_Connections[connIdx].InternalId]);
m_Players.Remove(m_Connections[connIdx].InternalId);
Debug.Log("[SERVER] Connection lost with " + m_Connections[connIdx].InternalId);
//var connTemp = m_Connections[i];
//connTemp.Dispose();
m_Connections.RemoveAtSwapBack(connIdx);
SendDisconnectedPlayers();
}
}
}
/// <summary>
/// Process any new network events.
/// </summary>
private void processNetworkEvents()
{
DataStreamReader stream; //Used for reading data from data network events
if (hasConnections) //There are clients connected
{
List <short> clientIDs = new List <short>(connectedClients.Keys);
for (int i = 0; i < clientIDs.Count; i++)
{
short clientID = clientIDs[i];
NetworkConnection connection = connectedClients[clientID];
if (!connection.IsCreated)
{
Assert.IsTrue(true);
}
//Get network events for the connection
NetworkEvent.Type networkEvent;
while ((networkEvent = networkDriver.PopEventForConnection(connection, out stream)) != NetworkEvent.Type.Empty)
{
if (networkEvent == NetworkEvent.Type.Data) //Connection sent data
{
MessageParser.parse(stream); //Parse data
}
else if (networkEvent == NetworkEvent.Type.Disconnect) //Connection disconnected
{
Debug.Log("<color=magenta><b>[Server]</b></color> Client " + clientID + " disconnected from server.");
OnClientDisconnected?.Invoke(clientID); //Notify any observers of the disconnection event
clientMessageQueues.Remove(clientID); //Remove any queued messages for the connection
connection = default; //This ensures the connections will be cleaned up in cleanupConnections()
}
}
}
}
}
void HandleConnections()
{
Debug.Log($"Server: Handling Connections");
// querying for events that might have happened sincd last event
DataStreamReader stream;
for (int connection_i = 0; connection_i < Connections.Length; connection_i++)
{
if (!Connections[connection_i].IsCreated)
{
Assert.IsTrue(true);
}
// while there are more events needed to process, we will keep popping
// events for connection
NetworkEvent.Type netEvent;
while ((netEvent = Driver.PopEventForConnection(Connections[connection_i], out stream)) != NetworkEvent.Type.Empty)
{
// This is where we will process different types of events
// Date Event
switch (netEvent)
{
case NetworkEvent.Type.Data:
DataStreamReader.Context readerContext = default(DataStreamReader.Context);
int clientId = stream.ReadInt(ref readerContext);
int dataSize = stream.ReadInt(ref readerContext);
int dataCount = 0;
//Debug.Log("Server: Receiving Data");
//Debug.Log("Server: Data size " + dataSize);
while (dataCount < dataSize)
{
int stateType = (int)stream.ReadFloat(ref readerContext);
switch (stateType)
{
case (int)StateType.PlayerMove:
float posX = stream.ReadFloat(ref readerContext);
float posY = stream.ReadFloat(ref readerContext);
float posZ = stream.ReadFloat(ref readerContext);
float rotX = stream.ReadFloat(ref readerContext);
float rotY = stream.ReadFloat(ref readerContext);
float rotZ = stream.ReadFloat(ref readerContext);
if (ClientStates.TryGetValue(clientId, out ClientState client))
{
Vector3 newPosition = new Vector3(posX, posY, posZ);
Vector3 newRotation = new Vector3(rotX, rotY, rotZ);
//Vector3 newChildRotation = new Vector3(rotX, 0.0f, 0.0f);
client.PlayerPosition = newPosition;
client.PlayerRotation.eulerAngles = newRotation;
//Client.transform.GetChild(0).gameObject.transform.eulerAngles = newChildRotation;
}
//Debug.Log("Server: Player pos_x: " + posX + "Player pos_y: " + posY + "Player pos_z: " + posZ);
//Debug.Log("Server: Player rot_x: " + rotX + "Player rot_y: " + rotY + "Player rot_z: " + rotZ);
dataCount += 7;
break;
case (int)StateType.PlayerFired:
if (ClientStates.TryGetValue(clientId, out ClientState clientFired))
{
clientFired.HasFired = true;
}
Debug.Log("Server: Player fired");
dataCount++;
break;
}
}
/*
* using (DataStreamWriter connectionWriter = new DataStreamWriter(4, Allocator.Temp))
* {
* connectionWriter.Write(number);
* Driver.Send(NetworkPipeline.Null, Connections[connection_i], connectionWriter);
* }
*/
break;
case NetworkEvent.Type.Disconnect:
//Debug.Log("Server: Client disconnected from server");
Connections[connection_i] = default(NetworkConnection);
break;
}
}
}
}
private void Update()
{
if (!started)
{
return;
}
if (timer <= 25)
{
timer += Time.deltaTime;
}
else
{
timer = 0f;
SendCmdToAllClients("LEER");
Debug.Log("Sending empty to keep connection");
}
driver.ScheduleUpdate().Complete();
for (int i = 0; i < connection.Length; i++)
{
if (!connection[i].IsCreated)
{
connection.RemoveAtSwapBack(i);
Debug.LogError("is created abfrage 1");
--i;
}
}
NetworkConnection con;
while ((con = driver.Accept()) != default(NetworkConnection))
{
connection.Add(con);
string cmdString = "AUTHENTICATE|";
SendCmdToClient(cmdString, con);
}
DataStreamReader sr;
for (int i = 0; i < connection.Length; i++)
{
if (!connection[i].IsCreated)
{
Debug.LogError("created abfrage");
continue;
}
NetworkEvent.Type cmd;
while ((cmd = driver.PopEventForConnection(connection[i], out sr)) != NetworkEvent.Type.Empty)
{
if (cmd == NetworkEvent.Type.Connect)
{
Debug.Log("client " + i + " has connected");
}
if (cmd == NetworkEvent.Type.Disconnect)
{
playerHasDisconnected = true;
playerDic.Remove(FindKeyByConID(i));
for (int j = 0; j < connection.Length; j++)
{
if (j != i)
{
}
}
}
if (cmd == NetworkEvent.Type.Data)
{
var readerCtx = default(DataStreamReader.Context);
byte[] data = sr.ReadBytesAsArray(ref readerCtx, sr.Length);
string cmdString = System.Text.Encoding.UTF8.GetString(data);
ProcessCmd(cmdString, i);
}
}
}
}
public void SendAndReceiveMessage_RealNetwork()
{
using (var clientSendData = new DataStreamWriter(64, Allocator.Persistent))
{
DataStreamReader stream;
var serverEndpoint = NetworkEndPoint.LoopbackIpv4;
serverEndpoint.Port = (ushort)Random.Range(2000, 65000);
var serverDriver = new UdpNetworkDriver(new NetworkDataStreamParameter {
size = 64
});
serverDriver.Bind(serverEndpoint);
serverDriver.Listen();
var clientDriver = new UdpNetworkDriver(new NetworkDataStreamParameter {
size = 64
});
clientDriver.Bind(NetworkEndPoint.LoopbackIpv4);
var clientToServerId = clientDriver.Connect(serverEndpoint);
NetworkConnection serverToClientId = default(NetworkConnection);
// Retry a few times since the network might need some time to process
for (int i = 0; i < 10 && serverToClientId == default(NetworkConnection); ++i)
{
serverDriver.ScheduleUpdate().Complete();
serverToClientId = serverDriver.Accept();
}
Assert.That(serverToClientId != default(NetworkConnection));
clientDriver.ScheduleUpdate().Complete();
var eventId = clientDriver.PopEventForConnection(clientToServerId, out stream);
Assert.That(eventId == NetworkEvent.Type.Connect);
int testInt = 100;
float testFloat = 555.5f;
byte[] testByteArray = Encoding.ASCII.GetBytes("Some bytes blablabla 1111111111111111111");
clientSendData.Write(testInt);
clientSendData.Write(testFloat);
clientSendData.Write(testByteArray.Length);
clientSendData.Write(testByteArray);
var sentBytes = clientDriver.Send(NetworkPipeline.Null, clientToServerId, clientSendData);
// Header size is included in the sent bytes count (4 bytes overhead)
Assert.AreEqual(clientSendData.Length + 4, sentBytes);
clientDriver.ScheduleUpdate().Complete();
serverDriver.ScheduleUpdate().Complete();
DataStreamReader serverReceiveStream;
eventId = serverDriver.PopEventForConnection(serverToClientId, out serverReceiveStream);
var readerCtx = default(DataStreamReader.Context);
Assert.True(eventId == NetworkEvent.Type.Data);
var receivedInt = serverReceiveStream.ReadInt(ref readerCtx);
var receivedFloat = serverReceiveStream.ReadFloat(ref readerCtx);
var byteArrayLength = serverReceiveStream.ReadInt(ref readerCtx);
var receivedBytes = serverReceiveStream.ReadBytesAsArray(ref readerCtx, byteArrayLength);
Assert.True(testInt == receivedInt);
Assert.That(Mathf.Approximately(testFloat, receivedFloat));
Assert.AreEqual(testByteArray, receivedBytes);
clientDriver.Dispose();
serverDriver.Dispose();
}
}
// Update is called once per frame
void Update()
{
Driver.ScheduleUpdate().Complete();
// cleanes up old state connections
// before processing new ones
for (int connection_i = 0; connection_i < Connections.Length; connection_i++)
{
if (!Connections[connection_i].IsCreated)
{
Connections.RemoveAtSwapBack(connection_i);
--connection_i;
}
}
// Accepts the new connections
NetworkConnection connection;
while ((connection = Driver.Accept()) != default(NetworkConnection))
{
Connections.Add(connection);
Debug.Log("Accepted a connection");
}
// Connections are now up to date, so now we are
// querying for events that might have happened sincd last event
DataStreamReader stream;
for (int connection_i = 0; connection_i < Connections.Length; connection_i++)
{
if (!Connections[connection_i].IsCreated)
{
Assert.IsTrue(true);
}
// while there are more events needed to process, we will keep popping
// events for connection
NetworkEvent.Type netEvent;
while ((netEvent = Driver.PopEventForConnection(Connections[connection_i], out stream)) != NetworkEvent.Type.Empty)
{
// This is where we will process different types of events
// Date Event
if (netEvent == NetworkEvent.Type.Data)
{
DataStreamReader.Context readerContext = default(DataStreamReader.Context);
uint number = stream.ReadUInt(ref readerContext);
Debug.Log("Got " + number + " from the Client adding + 2 to it.");
number += 2;
using (DataStreamWriter connectionWriter = new DataStreamWriter(4, Allocator.Temp))
{
connectionWriter.Write(number);
Driver.Send(NetworkPipeline.Null, Connections[connection_i], connectionWriter);
}
}
// Disconnect Event
else if (netEvent == NetworkEvent.Type.Disconnect)
{
Debug.Log("Client disconnected from server");
Connections[connection_i] = default(NetworkConnection);
}
}
}
}
void Update()
{
m_Driver.ScheduleUpdate().Complete();
// Clean up connections
for (int i = 0; i < m_Connections.Length; i++)
{
if (!m_Connections[i].IsCreated)
{
m_Connections.RemoveAtSwapBack(i);
--i;
}
}
// Accept new connections
NetworkConnection c;
while ((c = m_Driver.Accept()) != default(NetworkConnection))
{
m_Connections.Add(c);
Debug.Log("Accepted a connection");
}
DataStreamReader stream;
for (int i = 0; i < m_Connections.Length; i++)
{
if (!m_Connections[i].IsCreated)
{
continue;
}
NetworkEvent.Type cmd;
while ((cmd = m_Driver.PopEventForConnection(m_Connections[i], out stream)) !=
NetworkEvent.Type.Empty)
{
if (cmd == NetworkEvent.Type.Data)
{
var readerCtx = default(DataStreamReader.Context);
byte[] value = stream.ReadBytesAsArray(ref readerCtx, stream.Length);
CustomType ct = cts.DeSerialize(value);
Debug.Log("Got " + ct.val + " from the Client adding + 2 to it.");
ct.val += 2;
var buff = cts.Serialize(ct);
using (var writer = new DataStreamWriter(buff.Length, Allocator.Temp))
{
writer.Write(buff);
m_Connections[i].Send(m_Driver, writer);
}
}
else if (cmd == NetworkEvent.Type.Disconnect)
{
Debug.Log("Client disconnected from server");
m_Connections[i] = default(NetworkConnection);
}
}
}
}
void FixedUpdate()
{
// Update the NetworkDriver. It schedules a job so we must wait for that job with Complete
m_ServerDriver.ScheduleUpdate().Complete();
// Accept all new connections
while (true)
{
var con = m_ServerDriver.Accept();
// "Nothing more to accept" is signaled by returning an invalid connection from accept
if (!con.IsCreated)
{
break;
}
m_connections.Add(con);
// Debug.Log("Connected is " + con.InternalId);
// var idData = new DataStreamWriter(4, Allocator.Temp);
// idData.Write(con.InternalId);
// DataStreamReader strm;
// m_ServerDriver.PopEventForConnection(con, out strm);
//m_ServerDriver.Send(NetworkPipeline.Null, con, idData);
}
List <Player> clientList = ServerManager.GetClients();
for (int i = 0; i < m_connections.Length; ++i)
{
DataStreamReader strm;
NetworkEvent.Type cmd;
// Pop all events for the connection
while ((cmd = m_ServerDriver.PopEventForConnection(m_connections[i], out strm)) != NetworkEvent.Type.Empty)
{
if (cmd == NetworkEvent.Type.Data)
{
var readerCtx = default(DataStreamReader.Context);
byte data = strm.ReadByte(ref readerCtx);
CMD command = (CMD)data;
switch (command)
{
case CMD.CONNECT:
var id = ServerManager.RegisterPlayer(m_connections[i].InternalId);
Debug.Log("Connected " + id);
byte[] idData = NetworkLayer.newCommand(CMD.CONNECT, BitConverter.GetBytes(id));
var newID = new DataStreamWriter(idData.Length, Allocator.Temp);
newID.Write(idData);
m_ServerDriver.Send(NetworkPipeline.Null, m_connections[i], newID);
break;
case CMD.PLAYER_UPDATE:
byte[] playerByte = strm.ReadBytesAsArray(ref readerCtx, 32);
var player = ByteConverter.toPlayer(playerByte);
ServerManager.OnUpdatePlayer(player);
break;
case CMD.SHOOT:
var shootBye = NetworkLayer.newCommand(CMD.SHOOT, BitConverter.GetBytes(m_connections[i].InternalId));
var shootData = new DataStreamWriter(shootBye.Length, Allocator.Temp);
shootData.Write(shootBye);
for (int y = 0; y < m_connections.Length; ++y)
{
if (m_connections[i] != m_connections[y])
{
m_ServerDriver.Send(NetworkPipeline.Null, m_connections[y], shootData);
}
}
;
break;
case CMD.PLAYER_DIE:
Debug.LogWarning(" S DIE");
var dieByte = NetworkLayer.newCommand(CMD.PLAYER_DIE, BitConverter.GetBytes(m_connections[i].InternalId));
var dieData = new DataStreamWriter(dieByte.Length, Allocator.Temp);
dieData.Write(dieByte);
for (int y = 0; y < m_connections.Length; ++y)
{
m_ServerDriver.Send(NetworkPipeline.Null, m_connections[y], dieData);
}
;
break;
}
for (int clientIndex = 0; clientIndex < clientList.Count; clientIndex++)
{
byte[] playerData = NetworkLayer.newCommand(CMD.PLAYER_UPDATE, ByteConverter.playerToByte(clientList[clientIndex]));
var player = new DataStreamWriter(playerData.Length, Allocator.Temp);
player.Write(playerData);
m_ServerDriver.Send(NetworkPipeline.Null, m_connections[i], player);
}
;
// Send the pong message with the same id as the ping
}
else if (cmd == NetworkEvent.Type.Disconnect)
{
// This connection no longer exist, remove it from the list
// The next iteration will operate on the new connection we swapped in so as long as it exist the
// loop can continue
Debug.Log("Desconnected " + m_connections[i].InternalId);
byte[] disconnectData = NetworkLayer.newCommand(CMD.PLAYER_DISCONNECTED, BitConverter.GetBytes(m_connections[i].InternalId));
var player = new DataStreamWriter(disconnectData.Length, Allocator.Temp);
player.Write(disconnectData);
ServerManager.OnDisconnectPlayer(m_connections[i].InternalId);
m_connections.RemoveAtSwapBack(i);
for (int y = 0; y < m_connections.Length; ++y)
{
m_ServerDriver.Send(NetworkPipeline.Null, m_connections[y], player);
}
;
if (i >= m_connections.Length)
{
break;
}
}
}
}
}
public IEnumerator ServerAnd5Clients_Connect_Successfully()
{
int numberOfClients = 5;
NativeArray <NetworkConnection> connectionToClientArray;
UdpNetworkDriver[] client_driversArray = new UdpNetworkDriver[numberOfClients];
NativeArray <NetworkConnection> clientToServerConnectionsArray;
//setup server
connectionToClientArray = new NativeArray <NetworkConnection>(numberOfClients, Allocator.Persistent);
server_driver = new UdpNetworkDriver(new NetworkDataStreamParameter {
size = 0
});
NetworkEndPoint server_endpoint = NetworkEndPoint.LoopbackIpv4;
server_endpoint.Port = 1337;
server_driver.Bind(server_endpoint);
server_driver.Listen();
//setup clients
clientToServerConnectionsArray = new NativeArray <NetworkConnection>(numberOfClients, Allocator.Persistent);
for (int i = 0; i < numberOfClients; i++)
{
client_driversArray[i] = new UdpNetworkDriver(new NetworkDataStreamParameter {
size = 0
});
clientToServerConnectionsArray[i] = client_driversArray[i].Connect(server_endpoint);
}
//update drivers
for (int i = 0; i < numberOfClients; i++)
{
client_driversArray[i].ScheduleUpdate().Complete();
}
server_driver.ScheduleUpdate().Complete();
//accept connections
for (int i = 0; i < numberOfClients; i++)
{
connectionToClientArray[i] = server_driver.Accept();
server_driver.ScheduleUpdate().Complete();
ev = server_driver.PopEventForConnection(connectionToClientArray[i], out stream);
Assert.IsTrue(ev == NetworkEvent.Type.Empty, "Not empty NetworkEvent on the server appeared");
client_driversArray[i].ScheduleUpdate().Complete();
ev = clientToServerConnectionsArray[i].PopEvent(client_driversArray[i], out stream);
Assert.IsTrue(ev == NetworkEvent.Type.Connect, "NetworkEvent should have Type.Connect on the client");
}
//close connections
for (int i = 0; i < numberOfClients; i++)
{
clientToServerConnectionsArray[i].Close(client_driversArray[i]);
//update drivers
client_driversArray[i].ScheduleUpdate().Complete();
server_driver.ScheduleUpdate().Complete();
ev = server_driver.PopEventForConnection(connectionToClientArray[i], out stream);
Assert.IsTrue(ev == NetworkEvent.Type.Disconnect, "NetworkEvent.Type.Disconnect was expected to appear, but " + ev + "appeared");
}
server_driver.Dispose();
for (int i = 0; i < numberOfClients; i++)
{
client_driversArray[i].Dispose();
}
connectionToClientArray.Dispose();
clientToServerConnectionsArray.Dispose();
yield return(null);
}
