public bool Listen(NetworkEndPoint endpoint)
{
if (_unreliablePipeline == NetworkPipeline.Null)
{
_unreliablePipeline = _driver.CreatePipeline(typeof(NullPipelineStage));
}
if (_reliablePipeline == NetworkPipeline.Null)
{
_reliablePipeline = _driver.CreatePipeline(typeof(ReliableSequencedPipelineStage));
}
// Switching to server mode
if (_driver.Bind(endpoint) != 0)
{
return(false);
}
if (_driver.Listen() != 0)
{
return(false);
}
_listening = true;
// FIXME: Bind breaks all copies of the driver nad makes them send to the wrong socket
_concurrentDriver = _driver.ToConcurrent();
#if UNITY_EDITOR
renameQuery = GetEntityQuery(new EntityQueryDesc
{
All = new ComponentType[] { ComponentType.ReadOnly <NetworkConnectedMessage>() },
});
#endif
return(true);
}
public void UdpC_ConnectSendTest_ShouldConnectAndReceiveData()
{
using (var server = new UdpNetworkDriver(new NetworkDataStreamParameter {
}))
using (var client = new UdpNetworkDriver(new NetworkDataStreamParameter {
}))
{
var serverPort = 50008;
server.Bind(NetworkEndPoint.CreateIpv4(0x7f000001, (ushort)serverPort));
client.Bind(NetworkEndPoint.LoopbackIpv4);
server.Listen();
client.Connect(NetworkEndPoint.CreateIpv4(0x7f000001, (ushort)serverPort));
NetworkConnection serverConnection, clientConnection;
int maxIterations = 100;
ConnectTogether(server, client, maxIterations, out serverConnection, out clientConnection);
var message = new byte[]
{
(byte)'m',
(byte)'e',
(byte)'s',
(byte)'s',
(byte)'a',
(byte)'g',
(byte)'e'
};
SendReceive(client, server, clientConnection, serverConnection, message, maxIterations);
}
}
// Create the ping server driver, bind it to a port and start listening for incoming connections
void Initialize()
{
if (m_Initialized || InTerminalState)
{
return;
}
m_ServerDriver = new UdpNetworkDriver(new INetworkParameter[0]);
var bindStatus = m_ServerDriver.Bind(m_PingServerEndpoint);
if (bindStatus != 0)
{
throw new InvalidOperationException($"Failed to bind to {IpAddress ?? "0.0.0.0"}:{Port}. Bind error code: {bindStatus}.");
}
Debug.Log($"Network driver listening for traffic on {IpAddress ?? "0.0.0.0"}:{Port}");
m_ServerDriver.Listen();
m_Connections = new NativeList <NetworkConnection>(MaxConnections, Allocator.Persistent);
m_ShouldShutdownServer = new NativeArray <bool>(1, Allocator.Persistent)
{
[0] = false
};
m_Initialized = true;
}
public bool Listen(NetworkEndPoint endpoint)
{
LastDriverWriter.Complete();
if (m_UnreliablePipeline == NetworkPipeline.Null)
{
m_UnreliablePipeline = m_Driver.CreatePipeline(typeof(NullPipelineStage));
}
if (m_ReliablePipeline == NetworkPipeline.Null)
{
m_ReliablePipeline = m_Driver.CreatePipeline(typeof(ReliableSequencedPipelineStage));
}
// Switching to server mode
if (m_Driver.Bind(endpoint) != 0)
{
return(false);
}
if (m_Driver.Listen() != 0)
{
return(false);
}
m_DriverListening = true;
// FIXME: Bind breaks all copies of the driver nad makes them send to the wrong socket
m_ConcurrentDriver = m_Driver.ToConcurrent();
return(true);
}
private void Start()
{
//Debug.Log("ServerConnectionsComponent::Start called");
// Set timeout to something larger
NetworkConfigParameter config = new NetworkConfigParameter();
config.connectTimeoutMS = connectTimeoutMs;
config.disconnectTimeoutMS = disconnectTimeoutMs;
NetworkEndPoint addr = NetworkEndPoint.AnyIpv4;
addr.Port = 9000;
m_Driver = new UdpNetworkDriver(config);
if (m_Driver.Bind(addr) != 0)
{
Debug.Log("ServerConnectionsComponent::Start Failed to bind to port 9000");
}
else
{
m_Driver.Listen();
}
m_Connections = new NativeList <NetworkConnection>(MAX_NUM_PLAYERS, Allocator.Persistent);
}
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");
}
void Start()
{
ReliableUtility.Parameters reliabilityParams = new ReliableUtility.Parameters {
WindowSize = 32
};
SimulatorUtility.Parameters simulatorParams = new SimulatorUtility.Parameters {
MaxPacketSize = k_PacketSize, MaxPacketCount = 30, PacketDelayMs = 100
};
m_Driver = new UdpNetworkDriver(simulatorParams, reliabilityParams);
m_Connections = new NativeList <NetworkConnection>(connectionCapacity, Allocator.Persistent); // first parameter is number of connections to accept
m_Unreliable_Pipeline = m_Driver.CreatePipeline(typeof(UnreliableSequencedPipelineStage), typeof(SimulatorPipelineStage));
m_Reliable_Pipeline = m_Driver.CreatePipeline(typeof(UnreliableSequencedPipelineStage), typeof(SimulatorPipelineStage));
NetworkEndPoint endpoint = NetworkEndPoint.AnyIpv4;
endpoint.Port = 9000;
if (m_Driver.Bind(endpoint) != 0)
{
Debug.Log("Failed to bind to port 9000");
}
else
{
m_Driver.Listen();
}
}
void Start()
{
ushort serverPort = 9000;
ushort newPort = 0;
if (CommandLine.TryGetCommandLineArgValue("-port", out newPort))
{
serverPort = newPort;
}
// Create the server driver, bind it to a port and start listening for incoming connections
m_ServerDriver = new UdpNetworkDriver(new INetworkParameter[0]);
var addr = NetworkEndPoint.AnyIpv4;
addr.Port = serverPort;
if (m_ServerDriver.Bind(addr) != 0)
{
Debug.Log($"Failed to bind to port {serverPort}");
}
else
{
m_ServerDriver.Listen();
}
m_connections = new NativeList <NetworkConnection>(16, Allocator.Persistent);
}
//Configures server to connect to clients
void configure()
{
//Creates a network driver that can track up to 32 packets at a time (32 is the limit)
//https://github.com/Unity-Technologies/multiplayer/blob/master/com.unity.transport/Documentation/pipelines-usage.md
networkDriver = new UdpNetworkDriver(new ReliableUtility.Parameters {
WindowSize = 32
});
//This must use the same pipeline(s) as the client(s)
networkPipeline = networkDriver.CreatePipeline(
typeof(ReliableSequencedPipelineStage)
);
//Set up network endpoint to accept any Ipv4 connections on port 9000
NetworkEndPoint networkEndpoint = NetworkEndPoint.AnyIpv4;
networkEndpoint.Port = 9000;
//Binds the network driver to a specific network address and port
if (networkDriver.Bind(networkEndpoint) != 0)
{
Debug.Log("Failed to bind to port 9000");
}
else //Successfully bound to port 9000
{
networkDriver.Listen(); //Start listening for incoming connections
}
//Create list that can hold up to 16 connections
networkConnections = new NativeList <NetworkConnection>(16, Allocator.Persistent);
}
public void Initialize(ushort p_Port)
{
// Server Initialization
m_ServerDriver = new UdpNetworkDriver(new NetworkConfigParameter {
connectTimeoutMS = 35000, disconnectTimeoutMS = 35000, maxConnectAttempts = 10, maxFrameTimeMS = 10
});
NetworkEndPoint t_ServerEndpoint = NetworkEndPoint.AnyIpv4;
t_ServerEndpoint.Port = p_Port;
if (m_ServerDriver.Bind(t_ServerEndpoint) != 0)
{
Debug.Log($"Failed to bind to port {p_Port}");
}
else
{
m_ServerDriver.Listen();
}
m_ServerWorld = new World("Server World");
b_EndOfFrame = m_ServerWorld.CreateSystem <B_EndOfFrame>();
S_ManageServerConnections s_ManageServerConnections = m_ServerWorld.CreateSystem <S_ManageServerConnections>();
s_ManageServerConnections.Driver = m_ServerDriver;
s_ManageServerConnections.ConcurrentDriver = m_ServerDriver.ToConcurrent();
s_ManageServerConnections.CreateConnectionsBarrier = b_EndOfFrame;
S_GenerateGrid s_GenerateGrid = m_ServerWorld.CreateSystem <S_GenerateGrid>(5, 5);
S_MovePlayer s_MovePlayer = m_ServerWorld.CreateSystem <S_MovePlayer>();
s_MovePlayer.CleanupMessageBarrier = b_EndOfFrame;
S_DamageWall s_DamageWall = m_ServerWorld.CreateSystem <S_DamageWall>();
s_DamageWall.CleanupMessageBarrier = b_EndOfFrame;
S_RepairWall s_RepairWall = m_ServerWorld.CreateSystem <S_RepairWall>();
s_RepairWall.CleanupMessageBarrier = b_EndOfFrame;
S_ShootPlayer s_ShootPlayer = m_ServerWorld.CreateSystem <S_ShootPlayer>();
s_ShootPlayer.CleanupMessageBarrier = b_EndOfFrame;
ug_ServerNetwork = m_ServerWorld.CreateSystem <UG_Network>();
ug_ServerNetwork.AddSystemToUpdateList(s_ManageServerConnections);
ug_ServerNetwork.AddSystemToUpdateList(s_GenerateGrid);
ug_ServerNetwork.AddSystemToUpdateList(s_MovePlayer);
ug_ServerNetwork.AddSystemToUpdateList(s_DamageWall);
ug_ServerNetwork.AddSystemToUpdateList(s_RepairWall);
ug_ServerNetwork.AddSystemToUpdateList(s_ShootPlayer);
ug_ServerNetwork.SortSystemUpdateList();
}
protected override JobHandle OnUpdate(JobHandle inputDeps)
{
inputDeps.Complete();
JobHandle serverJobHandle;
//Debug.Log("server system on update");
if (!m_Driver.IsCreated)
{
ReliableUtility.Parameters reliabilityParams = new ReliableUtility.Parameters {
WindowSize = 32
};
SimulatorUtility.Parameters simulatorParams = new SimulatorUtility.Parameters {
MaxPacketSize = k_PacketSize, MaxPacketCount = 30, PacketDelayMs = 100
};
m_Driver = new UdpNetworkDriver(simulatorParams, reliabilityParams);
NetworkEndPoint endpoint = NetworkEndPoint.AnyIpv4;
endpoint.Port = 9000;
if (m_Driver.Bind(endpoint) != 0)
{
Debug.Log("Failed to bind to port 9000");
}
else
{
m_Driver.Listen();
Debug.Log("driver listening on port 9000");
}
currentId = new NativeList <int>(1, Allocator.Persistent);
currentId.Add(0);
}
else
{
serverJobHandle = m_Driver.ScheduleUpdate(inputDeps);
serverJobHandle = new ListenForConnectionsJob
{
commandBuffer = m_Barrier.CreateCommandBuffer(),
driver = m_Driver,
}.Schedule(serverJobHandle);
serverJobHandle.Complete();
serverJobHandle = new UpdateServerJob
{
commandBuffer = m_Barrier.CreateCommandBuffer().ToConcurrent(),
driver = m_Driver.ToConcurrent(),
id = currentId.AsDeferredJobArray()
}.Schedule(this, serverJobHandle);
m_Barrier.AddJobHandleForProducer(serverJobHandle);
//Debug.Log("about to listen for connections");
return(serverJobHandle);
}
return(inputDeps);
}
public void UdpC_BindToEndpoint_ReturnSocketHandle()
{
using (var socket = new UdpNetworkDriver(new NetworkDataStreamParameter {
}))
{
var socketError = socket.Bind(NetworkEndPoint.AnyIpv4);
Assert.AreEqual(socketError, (int)SocketError.Success);
}
}
public UdpCClient(int port, int serverPort = -1)
{
m_Socket = new UdpNetworkDriver(new NetworkDataStreamParameter {
});
m_Socket.Bind(NetworkEndPoint.CreateIpv4(0x7f000001, (ushort)port));
if (serverPort == -1)
{
m_Socket.Listen();
}
this.serverPort = serverPort;
}
public SocketTransport(int port = 0, int maxConnections = 16)
{
m_IdToConnection = new NativeArray <NetworkConnection>(maxConnections, Allocator.Persistent);
var configParams = default(NetworkConfigParameter);
configParams.disconnectTimeoutMS = ServerGameLoop.serverDisconnectTimeout.IntValue;
configParams.connectTimeoutMS = NetworkParameterConstants.ConnectTimeoutMS;
configParams.maxConnectAttempts = NetworkParameterConstants.MaxConnectAttempts;
m_Socket = new UdpNetworkDriver(configParams);
m_Socket.Bind(NetworkEndPoint.CreateIpv4(0, (ushort)port));
}
public void UdpC_ListenThenConnect_ShouldFail()
{
using (var socket = new UdpNetworkDriver(new NetworkDataStreamParameter {
}))
{
var endpoint = NetworkEndPoint.CreateIpv4(0, 50007);
socket.Bind(endpoint);
socket.Listen();
var error = Assert.Throws <SocketException>(() => { socket.Connect(endpoint); });
Assert.AreEqual(error.SocketErrorCode, SocketError.AddressNotAvailable);
}
}
//[Ignore("https://favro.com/organization/c564ede4ed3337f7b17986b6/215d676dd474c0744d2574f8?card=Uni-90284")]
public void UdpC_Timeout_ShouldDisconnect()
{
int customTimeout = 1000;
var config = new NetworkConfigParameter {
maxConnectAttempts = NetworkParameterConstants.MaxConnectAttempts,
connectTimeoutMS = NetworkParameterConstants.ConnectTimeoutMS,
disconnectTimeoutMS = customTimeout,
};
using (var server = new UdpNetworkDriver(config))
using (var client = new UdpNetworkDriver(config))
{
var serverPort = 50006;
server.Bind(NetworkEndPoint.CreateIpv4(0x7f000001, (ushort)serverPort));
client.Bind(NetworkEndPoint.LoopbackIpv4);
server.Listen();
var id = client.Connect(NetworkEndPoint.CreateIpv4(0x7f000001, (ushort)serverPort));
NetworkConnection serverConnection, clientConnection;
int maxIterations = 100;
ConnectTogether(server, client, maxIterations, out serverConnection, out clientConnection);
Assert.AreEqual(id, serverConnection);
// Force timeout
Thread.Sleep(customTimeout + 500);
var message = new DataStreamWriter(7, Allocator.Persistent);
message.Write((byte)'m');
message.Write((byte)'e');
message.Write((byte)'s');
message.Write((byte)'s');
message.Write((byte)'a');
message.Write((byte)'g');
message.Write((byte)'e');
clientConnection.Send(server, message);
var data = new byte[1472];
int size = -1;
NetworkConnection from;
Assert.AreEqual(ExperimentalEventType.Disconnect, PollEvent(ExperimentalEventType.Disconnect, maxIterations, server, ref data, out size, out from));
Assert.AreEqual(from, clientConnection);
}
}
public void UdpC_BindMultipleToSameEndpoint_ReturnSocketError()
{
using (var first = new UdpNetworkDriver(new NetworkDataStreamParameter {
}))
using (var second = new UdpNetworkDriver(new NetworkDataStreamParameter {
}))
{
var endpoint = NetworkEndPoint.CreateIpv4(0, 50001);
var socketError = first.Bind(endpoint);
Assert.AreEqual(socketError, (int)SocketError.Success);
var error = second.Bind(endpoint);
Assert.AreEqual(error, (int)SocketError.AddressAlreadyInUse);
}
}
public void UdpC_ReconnectAndResend_ShouldReconnectAndResend()
{
using (var server = new UdpNetworkDriver(new NetworkDataStreamParameter {
}))
using (var client = new UdpNetworkDriver(new NetworkDataStreamParameter {
}))
{
var serverPort = 50007;
server.Bind(NetworkEndPoint.CreateIpv4(0x7f000001, (ushort)serverPort));
client.Bind(NetworkEndPoint.LoopbackIpv4);
server.Listen();
NetworkConnection serverConnection, clientConnection;
int maxIterations = 100;
var id = client.Connect(NetworkEndPoint.CreateIpv4(0x7f000001, (ushort)serverPort));
ConnectTogether(server, client, maxIterations, out serverConnection, out clientConnection);
client.Disconnect(id);
server.ScheduleUpdate().Complete();
var data = new byte[1472];
var size = 1472;
NetworkConnection from;
Assert.AreEqual(ExperimentalEventType.Disconnect, PollEvent(ExperimentalEventType.Disconnect, maxIterations, server, ref data, out size, out from));
id = client.Connect(NetworkEndPoint.CreateIpv4(0x7f000001, (ushort)serverPort));
ConnectTogether(server, client, maxIterations, out serverConnection, out clientConnection);
var message = new byte[]
{
(byte)'m',
(byte)'e',
(byte)'s',
(byte)'s',
(byte)'a',
(byte)'g',
(byte)'e'
};
SendReceive(client, server, clientConnection, serverConnection, message, maxIterations);
}
}
void Start()
{
m_Driver = new UdpNetworkDriver(new INetworkParameter[0]);
var endpoint = NetworkEndPoint.AnyIpv4;
endpoint.Port = 12666;
if (m_Driver.Bind(endpoint) != 0)
{
Debug.Log("Failed to bind to port");
}
else
{
m_Driver.Listen();
}
Connections = new NativeList <NetworkConnection>(16, Allocator.Persistent);
InvokeRepeating("HeartBeat", 1, 1);
}
void Start()
{
m_Driver = new UdpNetworkDriver(new INetworkParameter[0]);
var endpoint = NetworkConfig.GetServerEndPoint();
if (m_Driver.Bind(endpoint) != 0)
{
Debug.Log("Failed to bind to port 9000");
}
else
{
m_Driver.Listen();
}
m_Connections = new NativeList <NetworkConnection>(16, Allocator.Persistent);
}
void Start()
{
m_Driver = new UdpNetworkDriver(new INetworkParameter[0]);
var addr = NetworkEndPoint.AnyIpv4;
addr.Port = NetworkInfo.Port;
if (m_Driver.Bind(addr) != 0)
{
Debug.Log("Failed to bind to port");
}
else
{
m_Driver.Listen();
}
m_connections = new NativeList <NetworkConnection>(16, Allocator.Persistent);
}
public void UdpC_MultipleConnectTest_ShouldConnect()
{
using (var server = new UdpNetworkDriver(new NetworkDataStreamParameter {
}))
using (var client0 = new UdpNetworkDriver(new NetworkDataStreamParameter {
}))
using (var client1 = new UdpNetworkDriver(new NetworkDataStreamParameter {
}))
using (var client2 = new UdpNetworkDriver(new NetworkDataStreamParameter {
}))
using (var client3 = new UdpNetworkDriver(new NetworkDataStreamParameter {
}))
{
var serverPort = 50005;
server.Bind(NetworkEndPoint.CreateIpv4(0x7f000001, (ushort)serverPort)); //new IPEndPoint(IPAddress.Loopback, serverPort));
client0.Bind(NetworkEndPoint.LoopbackIpv4); // new IPEndPoint(IPAddress.Loopback, 0));
client1.Bind(NetworkEndPoint.LoopbackIpv4); //new IPEndPoint(IPAddress.Loopback, 0));
client2.Bind(NetworkEndPoint.LoopbackIpv4); //new IPEndPoint(IPAddress.Loopback, 0));
client3.Bind(NetworkEndPoint.LoopbackIpv4); //new IPEndPoint(IPAddress.Loopback, 0));
server.Listen();
NetworkConnection serverConnection, clientConnection;
int maxIterations = 100;
var endpoint = NetworkEndPoint.CreateIpv4(0x7f000001, (ushort)serverPort);
var id = client0.Connect(endpoint);
ConnectTogether(server, client0, maxIterations, out serverConnection, out clientConnection);
Assert.AreEqual(id, serverConnection);
id = client1.Connect(endpoint);
ConnectTogether(server, client1, maxIterations, out serverConnection, out clientConnection);
Assert.AreEqual(id, serverConnection);
id = client2.Connect(endpoint);
ConnectTogether(server, client2, maxIterations, out serverConnection, out clientConnection);
Assert.AreEqual(id, serverConnection);
id = client3.Connect(endpoint);
ConnectTogether(server, client3, maxIterations, out serverConnection, out clientConnection);
Assert.AreEqual(id, serverConnection);
}
}
void Start()
{
// Create the server driver, bind it to a port and start listening for incoming connections
m_ServerDriver = new UdpNetworkDriver(new INetworkParameter[0]);
var addr = NetworkEndPoint.AnyIpv4;
addr.Port = port;
if (m_ServerDriver.Bind(addr) != 0)
{
Debug.Log("Failed to bind to port 9000");
}
else
{
m_ServerDriver.Listen();
}
m_connections = new NativeList <NetworkConnection>(16, Allocator.Persistent);
}
public void StartServer()
{
endpoint = NetworkEndPoint.Parse(ipv4, port);
if (driver.Bind(endpoint) != 0)
{
Debug.Log("Failed to bind to Port 9000");
}
else
{
driver.Listen();
started = true;
Debug.Log("Server started on ip : " + ipv4 + " and port : " + port);
}
connection = new NativeList <NetworkConnection>(16, Allocator.Persistent);
gameStartBT.SetActive(true);
}
// Start is called before the first frame update
void Start()
{
m_Driver = new UdpNetworkDriver(new ReliableUtility.Parameters {
WindowSize = 32
});
reliableUdpPipe = m_Driver.CreatePipeline(typeof(ReliableSequencedPipelineStage));
if (m_Driver.Bind(NetworkEndPoint.Parse("0.0.0.0", 9000)) != 0)
{
Debug.Log("Failed to bind to port ...");
}
else
{
m_Driver.Listen();
}
m_Connections = new NativeList <NetworkConnection>(16, Allocator.Persistent);
}
//private NativeList<NetworkConnection> m_Connections;
void Start()
{
games = new List <ActiveGame>();
waitingList = new List <NetworkConnection>();
m_Driver = new UdpNetworkDriver(new INetworkParameter[0]);
var endpoint = NetworkEndPoint.AnyIpv4;
endpoint.Port = 9000;
if (m_Driver.Bind(endpoint) != 0)
{
Debug.Log("Failed to bind to port 9000");
}
else
{
m_Driver.Listen();
}
//m_Connections = new NativeList<NetworkConnection>(16, Allocator.Persistent);
}
public void Start()
{
m_Connections = new NativeList <SoakClientCtx>(1, Allocator.Persistent);
m_ServerDriver = new UdpNetworkDriver(new ReliableUtility.Parameters {
WindowSize = 32
});
//m_Pipeline = m_ServerDriver.CreatePipeline(typeof(UnreliableSequencedPipelineStage));
m_Pipeline = m_ServerDriver.CreatePipeline(typeof(ReliableSequencedPipelineStage));
var addr = NetworkEndPoint.AnyIpv4;
addr.Port = 9000;
if (m_ServerDriver.Bind(addr) != 0)
{
Debug.Log("Failed to bind to port 9000");
}
else
{
m_ServerDriver.Listen();
}
}
//////////////////////////////////
/////// Server functions /////////
void InitServer()
{
ushort serverPort = 9000;
// Create the server driver, bind it to a port and start listening for incoming connections
m_ServerDriver = new UdpNetworkDriver(new INetworkParameter[0]);
NetworkEndPoint addr = NetworkEndPoint.AnyIpv4;
addr.Port = serverPort;
if (m_ServerDriver.Bind(addr) != 0)
{
TimeLogger.Log($"Failed to bind to port {serverPort}");
}
else
{
m_ServerDriver.Listen();
}
m_connections = new NativeList <NetworkConnection>(16, Allocator.Persistent);
}
// Use this for initialization
void Start()
{
NetworkEndPoint endpoint = NetworkEndPoint.AnyIpv4;
endpoint.Port = ServerPort;
Driver = new UdpNetworkDriver(new INetworkParameter[0]);
if (Driver.Bind(endpoint) != 0)
{
Debug.Log($"Server: Failed to bind to port {ServerPort}");
}
else
{
Driver.Listen();
}
Connections = new NativeList <NetworkConnection>(MaxClientCount, Allocator.Persistent);
ClientStates = new Dictionary <int, ClientState>();
}
// Start is called before the first frame update
private void Start()
{
m_Driver = new UdpNetworkDriver(new SimulatorUtility.Parameters {
MaxPacketSize = 256, MaxPacketCount = 30, PacketDelayMs = 100
});
m_Pipeline = m_Driver.CreatePipeline(typeof(UnreliableSequencedPipelineStage), typeof(SimulatorPipelineStage));
m_Endpoint = new NetworkEndPoint();
m_Endpoint = NetworkEndPoint.Parse("0.0.0.0", 9000);
if (m_Driver.Bind(m_Endpoint) != 0)
{
Debug.Log("Failed to bind to port 9000");
}
else
{
m_Driver.Listen();
}
m_Connections = new NativeList <NetworkConnection>(16, Allocator.Persistent);
}
