void Start()
{
networkDriver = NetworkDriver.Create();
NetworkEndPoint endpoint = NetworkEndPoint.AnyIpv4;
endpoint.Port = 9000;
if (!GameManager.Instance.LOCAL)
{
endpoint = NetworkEndPoint.Parse(IPAdress, 9000);
}
if (networkDriver.Bind(endpoint) != 0)
{
Debug.Log("Failed to bind port");
}
else
{
networkDriver.Listen();
}
connections = new NativeList <NetworkConnection>(16, Allocator.Persistent);
serverMessagesQueue = new Queue <MessageHeader>();
for (int i = 0; i < ServerCallbacks.Length; i++)
{
ServerCallbacks[i] = new MessageEvent();
}
ServerCallbacks[(int)MessageHeader.MessageType.SetName].AddListener(HandleSetName);
ServerCallbacks[(int)MessageHeader.MessageType.PlayerLeft].AddListener(DisconnectClient);
}
public static void SendMessage(NetworkDriver networkDriver, MessageHeader message, NetworkConnection id)
{
var writer = networkDriver.BeginSend(id);
message.SerializeObject(ref writer);
networkDriver.EndSend(writer);
}
public void DisconnectFromARemoteEndPoint()
{
using (var host = new LocalDriverHelper(default(NetworkEndPoint)))
{
host.Host();
var driver = new NetworkDriver(new IPCNetworkInterface(), new NetworkDataStreamParameter {
size = 64
});
// Need to be connected in order to be able to send a disconnect packet.
NetworkConnection connectionId = driver.Connect(host.EndPoint);
Assert.True(connectionId != default(NetworkConnection));
driver.ScheduleUpdate().Complete();
var local = driver.LocalEndPoint();
host.Assert_GotConnectionRequest(local, true);
NetworkConnection con;
DataStreamReader slice;
// Pump so we get the accept message back.
driver.ScheduleUpdate().Complete();
Assert.AreEqual(NetworkEvent.Type.Connect, driver.PopEvent(out con, out slice));
driver.Disconnect(connectionId);
driver.ScheduleUpdate().Complete();
host.Assert_GotDisconnectionRequest(local);
driver.Dispose();
}
}
void Start()
{
m_Connections = new NativeList <NetworkConnection>(16, Allocator.Persistent);
m_Room = new NativeList <Room>(16, Allocator.Persistent);
m_ConnectedClients = new NativeMultiHashMap <int, Client>(16, Allocator.Persistent);
m_ConnectionIndexToRoomID = new NativeHashMap <int, int>(1, Allocator.Persistent);
m_ServerAddressToRoomID = new NativeHashMap <FixedString32, int>(1, Allocator.Persistent);
m_ReleasedRoomIds = new NativeList <Room>(Allocator.Persistent);
// Driver can be used as normal
m_Driver = NetworkDriver.Create();
// Driver now knows about this pipeline and can explicitly be asked to send packets through it (by default it sends directly)
m_Pipeline = m_Driver.CreatePipeline(typeof(UnreliableSequencedPipelineStage));
var endpoint = NetworkEndPoint.AnyIpv4;
endpoint.Port = Config.ListenPort;
if (m_Driver.Bind(endpoint) != 0)
{
Console.WriteLine($"[ERROR]Failed to bind to port {Config.ListenPort}");
}
else
{
m_Driver.Listen();
}
}
public void ShouldAcceptConnection()
{
Server.Instance.Init(new ushort[] { 9099 }, 100, true, false);
var serverDriver = new NetworkDriver(new IPCNetworkInterface(), new NetworkDataStreamParameter {
size = 64
});
Server.Instance.Start(serverDriver);
// send out connection request
var clientDriver = new NetworkDriver(new IPCNetworkInterface(), new NetworkDataStreamParameter {
size = 64
});
NetworkConnection networkConnection = clientDriver.Connect(serverDriver.LocalEndPoint());
Assert.True(networkConnection != default);
clientDriver.ScheduleUpdate().Complete();
var numberOfConnectedClients = 0;
var onClientConnected = new Server.ConnectionDelegate(id => numberOfConnectedClients++);
Server.Instance.ClientConnected += onClientConnected;
Server.Instance.Tick();
Assert.AreEqual(1, numberOfConnectedClients);
Server.Instance.ClientConnected -= onClientConnected;
if (clientDriver.IsCreated)
{
clientDriver.Dispose();
}
}
public virtual void SendNetMessage(ref NetworkDriver _driver, NetworkConnection _connection, MessageBase _msg)
{
DataStreamWriter _writer = _driver.BeginSend(_connection);
WriteMessage(ref _writer, _msg);
_driver.EndSend(_writer);
}
public void Init(string ip, ushort port, bool useLocalhost, float timeout, bool useSimulationPipeline)
{
SetEndpoint(ip, port, useLocalhost);
_timeout = timeout;
_averageServerTimeOffset = 0;
if (_clientDriver.IsCreated)
{
_clientDriver.Dispose();
}
_clientDriver = new NetworkDriver(new BaselibNetworkInterface(), new SimulatorUtility.Parameters
{
MaxPacketCount = 30,
PacketDropPercentage = 5,
MaxPacketSize = 256,
PacketDelayMs = 50
}, new ReliableUtility.Parameters {
WindowSize = 32
});
_unreliablePipeline = useSimulationPipeline
? _clientDriver.CreatePipeline(typeof(SimulatorPipelineStage))
: NetworkPipeline.Null;
_reliablePipeline = useSimulationPipeline
? _clientDriver.CreatePipeline(typeof(ReliableSequencedPipelineStage), typeof(SimulatorPipelineStage))
: _clientDriver.CreatePipeline(typeof(ReliableSequencedPipelineStage));
_initialized = true;
}
public void SetupServerAndClientAndConnectThem(int bufferSize)
{
//setup server
server_driver = NetworkDriver.Create(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 = NetworkDriver.Create(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");
}
/// <summary>
/// Gets the network drivers.
/// </summary>
/// <returns>List<NetworkDriver>.</returns>
private static List <NetworkDriver> GetNetworkDrivers()
{
var mak = new List <NetworkDriver>()
{
};
#if NETFRAMEWORK
try {
var scope = new ManagementScope($@"\\{Environment.MachineName}\root\cimv2", new ConnectionOptions()); scope.Connect();
var objectSearcher = new ManagementObjectSearcher(scope, new ObjectQuery("SELECT * FROM Win32_NetworkAdapterConfiguration where IPEnabled=True"));
foreach (var o in objectSearcher.Get())
{
var mo = (ManagementObject)o;
var item = new NetworkDriver();
mak.Add(item);
item.MacAddress = mo["MacAddress"] as string;
item.DhcpEnabled = (bool)mo["DHCPEnabled"];
item.IpAddress = mo["IPAddress"] as string[];
item.DefaultIpGateway = mo["DefaultIPGateway"] as string[];
item.DhcpServer = mo["DHCPServer"] as string;
item.Description = mo["Description"] as string;
item.ServiceName = mo["ServiceName"] as string;
item.Caption = mo["Caption"] as string;
}
}catch (Exception) {
// ignore
}
#endif
return(mak);
}
private void Awake()
{
if (instance == null)
{
instance = this;
}
else
{
Destroy(this);
}
m_Driver = NetworkDriver.Create();
var endpoint = NetworkEndPoint.AnyIpv4;
endpoint.Port = 12345;
if (m_Driver.Bind(endpoint) != 0)
{
Debug.Log("Failed to bind to port 12345");
}
else
{
m_Driver.Listen();
}
m_Connections = new NativeList <NetworkConnection>(2, Allocator.Persistent);
}
void Start()
{ //Create driver
m_Driver = NetworkDriver.Create();
//Create server address
var endpoint = NetworkEndPoint.AnyIpv4;
endpoint.Port = serverPort;
//If bind is not failed - listen
if (m_Driver.Bind(endpoint) != 0)
{
Debug.Log("Failed to bind to port " + serverPort);
}
else
{
m_Driver.Listen();
}
//Create list of connections
m_Connections = new NativeList <NetworkConnection>(16, Allocator.Persistent);
playersIds = new NativeList <int>(16, Allocator.Persistent);
//Create dictionary of players ids and data
players = new Dictionary <string, NetworkObjects.NetworkPlayer>();
//Reset timer
curTimeToSend = timeToSend;
}
//private List<NetworkConnection> m_Connections;
public UnreliableServer()
{
m_Driver = TestNetworkDriver.Create(new NetworkDataStreamParameter
{
size = NetworkParameterConstants.MTU
});
}
private void Start()
{
Debug.Log("[Notice] Setting up server...");
m_clientIDDict = new Dictionary <int, NetworkObjects.NetworkPlayer>();
m_Driver = NetworkDriver.Create();
var endpoint = NetworkEndPoint.AnyIpv4; //Get this server side IP
endpoint.Port = serverPort; // Apply server port
//Try to bind driver to address
if (m_Driver.Bind(endpoint) != 0)
{
Debug.LogError("[Error] Failed to bind to port " + serverPort);
}
else
{
m_Driver.Listen(); //Start listening for messages on successful bind
}
Debug.Log("[Notice] Server Ready.");
m_Connections = new NativeList <NetworkConnection>(16, Allocator.Persistent); //Set initial capacity to 16, set memory allocation to persistent (?)
StartCoroutine(UpdateClientsRoutine(m_serverUpdateInterval));
}
public static void StartServer()
{
Console.Log("Starting server..");
var config = new NetworkConfigParameter
{
connectTimeoutMS = CONNECT_TIMEOUT,
disconnectTimeoutMS = DISCONNECT_TIMEOUT,
maxConnectAttempts = MAX_CONNECTION_ATTEMPTS
};
Driver = NetworkDriver.Create(config);
var endpoint = NetworkEndPoint.AnyIpv4;
endpoint.Port = PORT;
if (Driver.Bind(endpoint) != 0)
{
Debug.Log("Failed to bind to port " + PORT);
}
else
{
Driver.Listen(); // Sets the NetworkDriver in the Listen state
}
connections = new NativeList <NetworkConnection>(MAX_CONNECTIONS, Allocator.Persistent);
Console.Log("Server is up and running!");
}
// Start is called before the first frame update
void Start()
{
serverDataHolder = new ServerDataHolder();
networkDriver = NetworkDriver.Create();
NetworkEndPoint endPoint = NetworkEndPoint.AnyIpv4; //might use var instead
endPoint.Port = 9000;
if (!Tools.LOCAL)
{
endPoint = NetworkEndPoint.Parse(Tools.IP, 9000);
}
if (networkDriver.Bind(endPoint) != 0)
{
Debug.Log("Failed to bind port to" + endPoint.Port);
}
else
{
networkDriver.Listen();
}
connections = new NativeList <NetworkConnection>(16, Allocator.Persistent);
messagesQueue = new Queue <MessageHeader>();
for (int i = 0; i < ServerCallbacks.Length; i++)
{
ServerCallbacks[i] = new MessageEvent();
}
ServerCallbacks[(int)MessageHeader.MessageType.setName].AddListener(HandleSetName);
}
void Start()
{
CurrentGameState = GameState.Lobby;
m_Driver = NetworkDriver.Create();
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);
aliveMessage = new GameObject().AddComponent <AliveMessageHandler>();
aliveMessage.InitializeMessage(3f, false);
aliveMessage.gameObject.name = "AliveMessage_Server";
DontDestroyOnLoad(aliveMessage);
}
private void Awake()
{
if (instance == null)
{
instance = this;
}
else
{
Destroy(this);
}
m_Driver = NetworkDriver.Create();
var endpoint = NetworkEndPoint.AnyIpv4;
endpoint.Port = 12345;
if (m_Driver.Bind(endpoint) != 0)
{
Debug.Log("Failed to Bind to Port9000"); //Its over 9000!
}
else
{
m_Driver.Listen();
}
m_Connections = new NativeList <NetworkConnection>(16, Allocator.Persistent);
clients = new List <Client>();
players = new List <GameObject>();
}
void Start()
{
lastTimeSendAllPlayerInfo = Time.time;
intervalTimeSendingAllPlayerInfo = 0.03f;
// Driver -> like socket
m_Driver = NetworkDriver.Create();
// 어디에 연결할지, AnyIpv4--> 머신이 돌아가는 위치의 IP
// -> where to connect. AnyIpv4 is the location of machine's ip
var endpoint = NetworkEndPoint.AnyIpv4;
// Port setting
endpoint.Port = serverPort;
// Bind the socket
if (m_Driver.Bind(endpoint) != 0)
{
Debug.Log("Failed to bind to port " + serverPort);
}
//if bind is good, server is ready to accept clients' connections
else
{
m_Driver.Listen();
}
//커넥션 - 서버가 클라들의 접속을 알수있게(관리함) 해주는 다리, NativeList--> List와 비슷
// -> m_Connections is like bridges that server knows which clients want to connect to the server. NativeList is a List
m_Connections = new NativeList <NetworkConnection>(16, Allocator.Persistent);
}
//#endif
public virtual void Init()
{
updateTimer = 1 / TICKS_PER_SECONDS;
lastUpdate = Time.time;
driver = NetworkDriver.Create();
NetworkEndPoint endPoint = NetworkEndPoint.AnyIpv4; // Allow anybody to connect to us
endPoint.Port = PORT;
netMessageHandlerManager = new NetMessageHandlerManager(this);
messageSender = new MessageSender(this);
entityManager = new EntityManager();
players = new Dictionary <int, NetworkConnection>();
if (driver.Bind(endPoint) != 0)
{
Logs.Error($"Error while binding to {PORT}");
Shutdown();
}
else
{
driver.Listen();
Logs.Print($"Server running at port {PORT} with {TICKS_PER_SECONDS} ticks/s");
}
connections = new NativeList <NetworkConnection>(MAX_CLIENTS, Allocator.Persistent);
}
public void CreateClientDriver(World world, out NetworkDriver driver, out NetworkPipeline unreliablePipeline, out NetworkPipeline reliablePipeline, out NetworkPipeline unreliableFragmentedPipeline)
{
var reliabilityParams = new ReliableUtility.Parameters {
WindowSize = 32
};
var netParams = new NetworkConfigParameter
{
maxConnectAttempts = NetworkParameterConstants.MaxConnectAttempts,
connectTimeoutMS = NetworkParameterConstants.ConnectTimeoutMS,
disconnectTimeoutMS = NetworkParameterConstants.DisconnectTimeoutMS,
maxFrameTimeMS = 100,
fixedFrameTimeMS = DriverFixedTime
};
var packetDelay = DriverSimulatedDelay;
int networkRate = 60;
// All 3 packet types every frame stored for maximum delay, doubled for safety margin
int maxPackets = 2 * (networkRate * 3 * packetDelay + 999) / 1000;
var fuzzFactor = 0;
const int kStringLength = 10; // we name it ClientTest e.g. 10 bytes long.
var worldId = int.Parse(world.Name.Substring(kStringLength, world.Name.Length - kStringLength));
if (DriverFuzzFactor?.Length >= worldId + 1)
{
fuzzFactor = DriverFuzzFactor[worldId];
}
var simParams = new SimulatorUtility.Parameters
{
MaxPacketSize = NetworkParameterConstants.MTU, MaxPacketCount = maxPackets,
PacketDelayMs = packetDelay,
FuzzFactor = fuzzFactor,
FuzzOffset = DriverFuzzOffset,
RandomSeed = DriverRandomSeed
};
driver = new NetworkDriver(new IPCNetworkInterface(), netParams, reliabilityParams, simParams);
if (DriverSimulatedDelay + fuzzFactor > 0)
{
unreliablePipeline = driver.CreatePipeline(
typeof(SimulatorPipelineStage),
typeof(SimulatorPipelineStageInSend));
reliablePipeline = driver.CreatePipeline(
typeof(SimulatorPipelineStage),
typeof(ReliableSequencedPipelineStage),
typeof(SimulatorPipelineStageInSend));
unreliableFragmentedPipeline = driver.CreatePipeline(
typeof(SimulatorPipelineStage),
typeof(FragmentationPipelineStage),
typeof(SimulatorPipelineStageInSend));
}
else
{
unreliablePipeline = driver.CreatePipeline(typeof(NullPipelineStage));
reliablePipeline = driver.CreatePipeline(typeof(ReliableSequencedPipelineStage));
unreliableFragmentedPipeline = driver.CreatePipeline(typeof(FragmentationPipelineStage));
}
}
private void Init()
{
networkDriver = NetworkDriver.Create();
connection = default;
receivedMessagesQueue = new Queue <Message>();
sendMessagesQueue = new Queue <Message>();
//assign all eventlisteners
for (int i = 0; i < ClientCallbacks.Length; i++)
{
ClientCallbacks[i] = new MessageEvent();
}
ClientCallbacks[(int)Message.MessageType.NewPlayer].AddListener(clientManager.HandleNewPlayer);
ClientCallbacks[(int)Message.MessageType.Welcome].AddListener(clientManager.HandleWelcome);
ClientCallbacks[(int)Message.MessageType.RequestDenied].AddListener(clientManager.HandleRequestDenied);
ClientCallbacks[(int)Message.MessageType.PlayerLeft].AddListener(clientManager.HandlePlayerLeft);
ClientCallbacks[(int)Message.MessageType.StartGame].AddListener(clientManager.HandleStartGame);
ClientCallbacks[(int)Message.MessageType.PlayerTurn].AddListener(clientManager.HandlePlayerTurn);
ClientCallbacks[(int)Message.MessageType.RoomInfo].AddListener(clientManager.HandleRoomInfo);
ClientCallbacks[(int)Message.MessageType.PlayerEnterRoom].AddListener(clientManager.HandlePlayerEnterRoom);
ClientCallbacks[(int)Message.MessageType.PlayerLeaveRoom].AddListener(clientManager.HandlePlayerLeaveRoom);
ClientCallbacks[(int)Message.MessageType.ObtainTreasure].AddListener(clientManager.HandleObtainTreasure);
ClientCallbacks[(int)Message.MessageType.HitMonster].AddListener(clientManager.HandleHitMonster);
ClientCallbacks[(int)Message.MessageType.HitByMonster].AddListener(clientManager.HandleHitByMonster);
ClientCallbacks[(int)Message.MessageType.PlayerDefends].AddListener(clientManager.HandlePlayerDefends);
ClientCallbacks[(int)Message.MessageType.PlayerLeftDungeon].AddListener(clientManager.HandlePlayerLeftDungeon);
ClientCallbacks[(int)Message.MessageType.PlayerDies].AddListener(clientManager.HandlePlayerDies);
ClientCallbacks[(int)Message.MessageType.EndGame].AddListener(clientManager.HandleEndGame);
}
public void DisconnectByRemote()
{
using (var host = new LocalDriverHelper(default(NetworkEndPoint)))
using (var client = new NetworkDriver(new IPCNetworkInterface()))
{
host.Host();
var popEvent = NetworkEvent.Type.Empty;
var c = client.Connect(host.EndPoint);
client.ScheduleUpdate().Complete();
host.Assert_GotConnectionRequest(client.LocalEndPoint(), true);
byte reason = 0;
DataStreamReader reader;
for (int frm = 0; frm < 10; ++frm)
{
if (c.GetState(client) == NetworkConnection.State.Connected)
{
c.Disconnect(client);
}
if ((popEvent = host.m_LocalDriver.PopEvent(out var id, out reader)) != NetworkEvent.Type.Empty)
{
reason = (reader.IsCreated && reader.Length > 0) ? reason = reader.ReadByte() : (byte)0;
break;
}
host.Update();
client.ScheduleUpdate().Complete();
}
Assert.AreEqual(NetworkEvent.Type.Disconnect, popEvent);
Assert.AreEqual((byte)DisconnectReason.ClosedByRemote, reason);
}
}
public void ClientStart(string ipAdress)
{
// create the network connection
networkDriver = NetworkDriver.Create();
connection = default;
var endpoint = NetworkEndPoint.LoopbackIpv4;
endpoint.Port = 9000;
if (ipAdress != "")
{
endpoint = NetworkEndPoint.Parse(ipAdress, 9000);
}
connection = networkDriver.Connect(endpoint);
// Instatiate & Finds
messagesQueue = new Queue <MessageConnection>();
for (int i = 0; i < ClientCallbacks.Length; i++)
{
ClientCallbacks[i] = new MessageEvent(); // Instantiate all Message Type events.
}
LobbyManager = GameObject.FindGameObjectWithTag("GameController").GetComponent <LobbyManager>();
AddProtocolEventListeners();
doneInitializing = true;
}
public void DisconnectByMaxConnectionAttempts()
{
using (var host = new LocalDriverHelper(default(NetworkEndPoint)))
using (var client = new NetworkDriver(new IPCNetworkInterface(), new NetworkConfigParameter {
maxConnectAttempts = 1, fixedFrameTimeMS = 10, connectTimeoutMS = 25
}))
{
host.Host();
var popEvent = NetworkEvent.Type.Empty;
var c = client.Connect(host.EndPoint);
client.ScheduleUpdate().Complete();
byte reason = 0;
var reader = default(DataStreamReader);
for (int frm = 0; frm < 10; ++frm)
{
if ((popEvent = client.PopEvent(out var id, out reader)) != NetworkEvent.Type.Empty)
{
reason = (reader.IsCreated && reader.Length > 0) ? reason = reader.ReadByte() : (byte)0;
break;
}
client.ScheduleUpdate().Complete();
}
Assert.AreEqual(NetworkEvent.Type.Disconnect, popEvent);
Assert.AreEqual((byte)DisconnectReason.MaxConnectionAttempts, reason);
}
}
void Start()
{
networkDriver = NetworkDriver.Create();
var endpoint = NetworkEndPoint.AnyIpv4;
endpoint.Port = 9000;
if (networkDriver.Bind(endpoint) != 0)
{
Debug.Log("Failed to bind port");
}
else
{
networkDriver.Listen();
}
connections = new NativeList <NetworkConnection>(16, Allocator.Persistent);
messagesQueue = new Queue <MessageHeader>();
for (int i = 0; i < ServerCallbacks.Length; i++)
{
ServerCallbacks[i] = new MessageEvent();
}
ServerCallbacks[(int)MessageHeader.MessageType.SetName].AddListener(HandleSetName);
}
public static void SendPing(NetworkDriver driver, NetworkConnection connection)
{
var writer = driver.BeginSend(connection);
writer.WriteByte(0);
driver.EndSend(writer);
}
public void CreateDriver(int minConnections, int maxConnections)
{
this.minConnections = minConnections;
this.maxConnections = maxConnections;
DestroyDriver();
// Create a new driver and listen for connections.
driver = NetworkDriver.Create(new ReliableUtility.Parameters {
WindowSize = 32
});
reliablePipeline = driver.CreatePipeline(typeof(ReliableSequencedPipelineStage));
var endPoint = NetworkEndPoint.AnyIpv4;
endPoint.Port = 9000;
var binding = driver.Bind(endPoint);
Assert.AreEqual(0, binding);
driver.Listen();
connections = new NativeList <NetworkConnection>(maxConnections, Allocator.Persistent);
playerInfoByID = new NativeHashMap <int, PlayerInfo>(maxConnections, Allocator.Persistent);
readMessage = ReadJoingingAreaMessages;
}
public void CreateServerDriver(World world, out NetworkDriver driver, out NetworkPipeline unreliablePipeline, out NetworkPipeline reliablePipeline, out NetworkPipeline unreliableFragmentedPipeline)
{
var reliabilityParams = new ReliableUtility.Parameters {
WindowSize = 32
};
var fragmentationParams = new FragmentationUtility.Parameters {
PayloadCapacity = 16 * 1024
};
#if UNITY_EDITOR || DEVELOPMENT_BUILD
var netParams = new NetworkConfigParameter
{
maxConnectAttempts = NetworkParameterConstants.MaxConnectAttempts,
connectTimeoutMS = NetworkParameterConstants.ConnectTimeoutMS,
disconnectTimeoutMS = NetworkParameterConstants.DisconnectTimeoutMS,
maxFrameTimeMS = 100
};
driver = NetworkDriver.Create(netParams, reliabilityParams, fragmentationParams);
#else
driver = NetworkDriver.Create(reliabilityParams);
#endif
unreliablePipeline = driver.CreatePipeline(typeof(NullPipelineStage));
reliablePipeline = driver.CreatePipeline(typeof(ReliableSequencedPipelineStage));
unreliableFragmentedPipeline = driver.CreatePipeline(typeof(FragmentationPipelineStage));
}
public LocalDriverHelper(NetworkEndPoint endpoint, params INetworkParameter[] networkParams)
{
if (networkParams.Length == 0)
{
m_LocalDriver = new NetworkDriver(new IPCNetworkInterface(), new NetworkDataStreamParameter
{
size = NetworkParameterConstants.MTU
});
}
else
{
m_LocalDriver = new NetworkDriver(new IPCNetworkInterface(), networkParams);
}
m_LocalData = new NativeArray <byte>(NetworkParameterConstants.MTU, Allocator.Persistent);
if (endpoint.IsValid)
{
EndPoint = endpoint;
}
else
{
EndPoint = NetworkEndPoint.LoopbackIpv4.WithPort(1);
}
Connection = default(NetworkConnection);
ClientConnections = new List <NetworkConnection>();
}
public virtual void Start()
{
//RESETS OUT DATA
m_Driver = NetworkDriver.Create();
//CONFIGURATION
NetworkEndPoint endpoint = NetworkEndPoint.AnyIpv4;
endpoint.Port = 9000;
//BIND THE NET DRIVER
if (m_Driver.Bind(endpoint) != 0)
{
Debug.Log(LogPrefix + "Faileld to bind port 9000");
}
else
{
//start listening
m_Driver.Listen();
}
//init the list to hold out connections
m_Connections = new NativeList <NetworkConnection>(16, Allocator.Persistent);
RegisterMessageHandlerClasses();
}
