void AcceptConnections()
{
// Accepts the new Connections
NetworkConnection connection;
while ((connection = Driver.Accept()) != default(NetworkConnection))
{
Connections.Add(connection);
//players.Add(new ClientPlayer(connection.GetHashCode()));
//Debug.Log($"Player Id: {connection.GetHashCode()}");
Debug.Log("Server: Accepted a connection");
using (DataStreamWriter writer = new DataStreamWriter(16, Allocator.Temp))
{
writer.Write((int)ServerDataType.IdAssignment);
writer.Write(IdCount);
Driver.Send(NetworkPipeline.Null, connection, writer);
Debug.Log($"Server: Sent client id: {IdCount}");
}
Vector3 spawnPos = new Vector3(0.0f, 4.0f, 0.0f);
Quaternion spawnRot = new Quaternion(0.0f, 0.0f, 0.0f, 0.0f);
ClientObjects.Add(IdCount, Instantiate(PlayerPreFab, spawnPos, spawnRot));
ClientObjectFired.Add(IdCount, new FiredBool());
IdCount++;
}
}
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;
}
}
}
}
}
//private void FlushConnection(NetworkConnection m_con2)
//{
// //Send info to client
// //ReadAll from client
// //deactivate Game
// throw new NotImplementedException();
//}
void NewGameStartProcess(NetworkConnection con, ref ActivGamePlayerState playerState)
{
using (var writer = new DataStreamWriter(8, Allocator.Temp))
{
writer.Write(m_id);
m_driver.Send(NetworkPipeline.Null, con, writer);
Debug.Log("Send NewGameStartProcess");
}
playerState = ActivGamePlayerState.WaitingTurn;
}
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);
}
}
}
}
// 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;
}
}
}
}
IEnumerator SendHelloClient(NetworkConnection c)
{
for (int x = 0; x < 512; ++x)
{
using (var writer = PacketFunctions.WriteHelloClientPacket()) {
//m_Driver.Send(reliableUdpPipe, c, writer);
m_Driver.Send(NetworkPipeline.Null, c, writer);
}
yield return(null);
}
}
protected override void Write(ref UdpNetworkDriver m_Driver, NetworkConnection networkConnection)
{
foreach (var sender in Senders)
{
var writer = sender.GetNew();
writer.Write(sender.Id);
sender.Write(writer);
m_Driver.Send(NetworkPipeline.Null, networkConnection, writer);
writer.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
{
//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 AcceptConnections()
{
Debug.Log($"Server: Accepting Connections");
// Accepts the new Connections
NetworkConnection connection;
while ((connection = Driver.Accept()) != default(NetworkConnection))
{
Connections.Add(connection);
//players.Add(new ClientPlayer(connection.GetHashCode()));
//Debug.Log($"Player Id: {connection.GetHashCode()}");
Debug.Log("Server: Accepted a connection");
using (DataStreamWriter writer = new DataStreamWriter(16, Allocator.Temp))
{
writer.Write((int)ServerDataType.IdAssignment);
writer.Write(IdCount);
Driver.Send(NetworkPipeline.Null, connection, writer);
Debug.Log($"Server: Sent client id: {IdCount}");
}
Vector3 spawnPos = new Vector3(0.0f, 4.0f, 0.0f);
Quaternion spawnRot = new Quaternion(0.0f, 0.0f, 0.0f, 0.0f);
ClientState newState = new ClientState();
newState.PlayerPosition = spawnPos;
newState.PlayerRotation = spawnRot;
newState.Health = 10;
ClientStates.Add(IdCount, newState);
IdCount++;
}
}
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 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);
}
}
}
}
public void Write(DataStreamWriter writer, NetworkConnection connection)
{
m_Driver.Send(NetworkPipeline.Null, connection, writer);
writer.Dispose();
}
