public void StartServer(int port)
{
EventBasedNetListener listener = new EventBasedNetListener();
listener.ConnectionRequestEvent += OnConnectionRequest;
listener.PeerConnectedEvent += OnPeerConnected;
listener.PeerDisconnectedEvent += OnPeerDisconnected;
listener.NetworkReceiveEvent += OnNetworkReceive;
server = new NetManager(listener)
{
AutoRecycle = true,
#if DEBUG
SimulateLatency = true,
SimulatePacketLoss = true,
SimulationMinLatency = 50,
SimulationMaxLatency = 100,
#endif
};
PlayerManager = new PlayerManager();
PacketProcessor = new NetPacketProcessor();
LiteNetLibUtils.RegisterAllPacketNestedTypes(PacketProcessor);
LiteNetLibUtils.RegisterAllPacketProcessorsInCallingAssembly(PacketProcessor);
server.Start(port);
SimulatedWorld.Initialize();
LocalPlayer.SetNetworkProvider(this);
LocalPlayer.IsMasterClient = true;
// TODO: Load saved player info here
LocalPlayer.SetPlayerData(new PlayerData(PlayerManager.GetNextAvailablePlayerId(), new Float3(1.0f, 0.6846404f, 0.243137181f)));
}
public void Start()
{
// not if already started
if (server != null)
{
logger.LogWarning("LiteNetLib: server already started.");
return;
}
logger.Log("LiteNet SV: starting...");
// create server
EventBasedNetListener listener = new EventBasedNetListener();
server = new NetManager(listener);
server.UpdateTime = updateTime;
server.DisconnectTimeout = disconnectTimeout;
// set up events
listener.ConnectionRequestEvent += Listener_ConnectionRequestEvent;
listener.PeerConnectedEvent += Listener_PeerConnectedEvent;
listener.NetworkReceiveEvent += Listener_NetworkReceiveEvent;
listener.PeerDisconnectedEvent += Listener_PeerDisconnectedEvent;
listener.NetworkErrorEvent += Listener_NetworkErrorEvent;
// start listening
server.Start(port);
}
private void InitAsClient(string address, int port, int maxConnections, string version, bool enableNatPunch)
{
Debug.Log("InitAsClient");
Profiler.BeginSample("InitAsClient");
_listener = new EventBasedNetListener();
_manager = new NetManager(_listener, maxConnections, version);
_manager.NatPunchEnabled = enableNatPunch;
_manager.UpdateTime = 0;
InitializeEvents();
RespondToPings();
if (!_manager.Start())
{
throw new ConnectionException($"Could not connect to {address}:{port}.");
}
Debug.Log("Connecting");
_manager.Connect(address, port);
// TODO: support more players
LocalClientRef.ClientId = 2;
Server.ClientId = 1;
_isServer = false;
var firstPeer = _manager.GetFirstPeer();
if (firstPeer != null)
{
AddClient(new Client(_isServer ? 2 : 1), false);
}
Profiler.EndSample();
}
public void StartHost(GameObject canvas)
{
canvas.SetActive(false);
Debug.LogError("starting host");
netListener = new EventBasedNetListener();
netListener.PeerConnectedEvent += (client) =>
{
Debug.LogError($"Connected to client: {client}");
Debug.LogError("Sending InitialTickPacket");
SendPacket(new InitialTickPacket {
tick = Tick
}, DeliveryMethod.ReliableUnordered);
};
netListener.ConnectionRequestEvent += (request) =>
{
request.Accept();
};
netListener.NetworkReceiveEvent += (peer, reader, deliveryMethod) =>
{
packetProcessor.ReadAllPackets(reader);
};
packetProcessor = new NetPacketProcessor();
writer = new NetDataWriter();
PacketRegistrar.RegisterPackets(packetProcessor);
netManager = new NetManager(netListener);
netManager.Start(12345);
ticking = true;
}
public void Init(string ip, int port, string key)
{
_key = key;
this._ip = ip;
this._port = port;
_listener = new EventBasedNetListener();
_listener.NetworkReceiveEvent += (fromPeer, dataReader, deliveryMethod) => {
OnNetMsg(dataReader.GetRemainingBytes());
dataReader.Recycle();
};
_listener.PeerConnectedEvent += (peer) => {
UnityEngine.Debug.Log("Connected!!");
_peer = peer;
OnConnected?.Invoke();
};
_listener.PeerDisconnectedEvent += (peer, disconnectInfo) => {
UnityEngine.Debug.Log("DisConnected!!");
};
_client = new NetManager(_listener)
{
DisconnectTimeout = 300000
};
_isInit = true;
Debug.Log($"Try Connect to {ip}:{port}");
}
public static void Start()
{
Config();
if (bIsCheck)
{
if (client == null)
{
EventBasedNetListener listener = new EventBasedNetListener();
client = new NetManager(listener);
client.Start();
client.Connect(server /* host ip or name */, port /* port */, "SomeConnectionKey" /* text key or NetDataWriter */);
listener.NetworkReceiveEvent += (fromPeer, dataReader, deliveryMethod) =>
{
Console.WriteLine("We got: {0}", dataReader.GetString(100 /* max length of string */));
dataReader.Recycle();
};
}
while (!Console.KeyAvailable)
{
client.PollEvents();
Thread.Sleep(15);
}
}
}
private void Awake()
{
netListener = new EventBasedNetListener();
netManager = new NetManager(netListener);
audioSource = GetComponent <AudioSource>();
}
private void RequestNtpService(string ntpService)
{
Console.WriteLine($"Request time from \"{ntpService}\" service");
var ntpComplete = false;
EventBasedNetListener listener = new EventBasedNetListener();
listener.NtpResponseEvent += ntpPacket =>
{
if (ntpPacket != null)
{
Console.WriteLine("[MAIN] NTP time test offset: " + ntpPacket.CorrectionOffset);
}
else
{
Console.WriteLine("[MAIN] NTP time error");
}
ntpComplete = true;
};
NetManager nm = new NetManager(listener);
nm.Start();
nm.CreateNtpRequest(ntpService);
while (!ntpComplete)
{
Thread.Yield();
}
}
public void Connect(string address, int maxConnectAttempts, bool ipv6Enabled, string connectKey)
{
// not if already connected or connecting
if (client != null)
{
logger.LogWarning("LiteNet: client already connected/connecting.");
return;
}
logger.Log("LiteNet CL: connecting...");
// create client
EventBasedNetListener listener = new EventBasedNetListener();
client = new NetManager(listener);
client.UpdateTime = updateTime;
client.DisconnectTimeout = disconnectTimeout;
client.MaxConnectAttempts = maxConnectAttempts;
// DualMode seems to break some addresses, so make this an option so that it can be turned on when needed
if (ipv6Enabled)
{
client.IPv6Enabled = IPv6Mode.DualMode;
}
// set up events
listener.PeerConnectedEvent += Listener_PeerConnectedEvent;
listener.NetworkReceiveEvent += Listener_NetworkReceiveEvent;
listener.PeerDisconnectedEvent += Listener_PeerDisconnectedEvent;
listener.NetworkErrorEvent += Listener_NetworkErrorEvent;
// start & connect
client.Start();
client.Connect(address, port, connectKey);
}
public void ConnectionDualMode()
{
var listener = new EventBasedNetListener();
var server = new NetManager(listener, new Crc32cLayer());
server.IPv6Mode = IPv6Mode.DualMode;
server.Start(DefaultPort);
listener.ConnectionRequestEvent += request => request.AcceptIfKey(DefaultAppKey);
var client1 = ManagerStack.Client(1);
var client2 = ManagerStack.Client(2);
client1.Connect("127.0.0.1", DefaultPort, DefaultAppKey);
client2.Connect("::1", DefaultPort, DefaultAppKey);
while (server.ConnectedPeersCount != 2 || client1.ConnectedPeersCount != 1 || client2.ConnectedPeersCount != 1)
{
Thread.Sleep(15);
server.PollEvents();
}
Assert.AreEqual(2, server.ConnectedPeersCount);
Assert.AreEqual(1, client1.ConnectedPeersCount);
Assert.AreEqual(1, client2.ConnectedPeersCount);
server.Stop(false);
}
public NetworkBase(NetworkLogger logger)
{
this.Listener = new EventBasedNetListener();
this.NetManager = new NetManager(this.Listener)
{
NatPunchEnabled = true,
DisconnectTimeout = (int)TimeSpan.FromSeconds(60).TotalMilliseconds,
};
this.processor = new NetPacketProcessor();
// TODO: somehow register all types via dependency injection?
this.processor.RegisterNestedType(Vector3Serializer.Write, Vector3Serializer.Read);
this.processor.SubscribeReusable <NetCommand, NetPeer>(this.OnCommandReceived);
this.Writer = new NetDataWriter();
this.Logger = logger;
this.RegisterHandlers();
this.Listener.NetworkReceiveEvent += (fromPeer, dataReader, deliveryMethod) =>
{
this.processor.ReadAllPackets(dataReader, fromPeer);
};
}
public void Start(string ipAddress, int serverPort)
{
Log.Info("Initializing LiteNetLibClient...");
SynchronizationContext.SetSynchronizationContext(new SynchronizationContext());
netPacketProcessor.SubscribeReusable <WrapperPacket, NetPeer>(OnPacketReceived);
EventBasedNetListener listener = new EventBasedNetListener();
listener.PeerConnectedEvent += Connected;
listener.PeerDisconnectedEvent += Disconnected;
listener.NetworkReceiveEvent += ReceivedNetworkData;
client = new NetManager(listener)
{
UpdateTime = 15,
UnsyncedEvents = true, //experimental feature, may need to replace with calls to client.PollEvents();
#if DEBUG
DisconnectTimeout = 300000 //Disables Timeout (for 5 min) for debug purpose (like if you jump though the server code)
#endif
};
client.Start();
client.Connect(ipAddress, serverPort, "nitrox");
connectedEvent.WaitOne(2000);
connectedEvent.Reset();
}
public EchoClient(int id, Configuration config, BenchmarkStatistics benchmarkStatistics) : base(config)
{
this.id = id;
this.config = config;
this.benchmarkStatistics = benchmarkStatistics;
deliveryMethod = LiteNetLibBenchmark.GetDeliveryMethod(config.Transmission);
listener = new EventBasedNetListener();
netManager = new NetManager(listener);
if (!config.Address.Contains(':'))
{
// For LiteNetLib 1.0 and above
//netManager.IPv6Mode = IPv6Mode.Disabled;
// LiteNetLib up to 0.9.4
netManager.IPv6Enabled = IPv6Mode.Disabled;
}
netManager.UpdateTime = Utilities.CalculateTimeout(config.ClientTickRate);
netManager.UnsyncedEvents = true;
netManager.DisconnectTimeout = 10000;
isConnected = false;
isDisposed = false;
listener.PeerConnectedEvent += OnPeerConnected;
listener.PeerDisconnectedEvent += OnPeerDisconnected;
listener.NetworkReceiveEvent += OnNetworkReceive;
listener.NetworkErrorEvent += OnNetworkError;
}
public static void TryConnect(IPAddress address, int port)
{
EventBasedNetListener listener = new EventBasedNetListener();
Multiplayer.session = new MultiplayerSession();
NetManager netClient = new NetManager(listener);
netClient.Start();
netClient.ReconnectDelay = 300;
netClient.MaxConnectAttempts = 8;
listener.PeerConnectedEvent += peer =>
{
IConnection conn = new MpNetConnection(peer);
conn.username = Multiplayer.username;
conn.State = ConnectionStateEnum.ClientJoining;
Multiplayer.session.client = conn;
MpLog.Log("Net client connected");
};
listener.PeerDisconnectedEvent += (peer, info) =>
{
string reason;
if (info.AdditionalData.AvailableBytes > 0)
{
reason = info.AdditionalData.GetString();
}
else
{
reason = DisconnectReasonString(info.Reason);
if (info.SocketErrorCode != SocketError.Success)
{
reason += ": " + info.SocketErrorCode;
}
}
Multiplayer.session.disconnectNetReason = reason;
ConnectionStatusListeners.TryNotifyAll_Disconnected();
OnMainThread.StopMultiplayer();
MpLog.Log("Net client disconnected");
};
listener.NetworkReceiveEvent += (peer, reader, method) =>
{
byte[] data = reader.GetRemainingBytes();
Multiplayer.HandleReceive(new ByteReader(data), method == DeliveryMethod.ReliableOrdered);
};
listener.NetworkErrorEvent += (endpoint, error) =>
{
Log.Warning($"Net client error {error}");
};
Multiplayer.session.netClient = netClient;
netClient.Connect(address.ToString(), port, "");
}
public ServerBrowser()
{
EventBasedNetListener listener = new EventBasedNetListener();
listener.NetworkReceiveUnconnectedEvent += (endpoint, data, type) =>
{
if (type != UnconnectedMessageType.DiscoveryRequest)
{
return;
}
string s = Encoding.UTF8.GetString(data.GetRemainingBytes());
if (s == "mp-server")
{
AddOrUpdate(endpoint);
}
};
net = new NetManager(listener);
net.DiscoveryEnabled = true;
net.ReuseAddress = true;
net.Start(5100);
doCloseX = true;
closeOnAccept = false;
}
private void InitEvents()
{
_listener = new EventBasedNetListener();
_listener.NetworkReceiveEvent += (fromPeer, dataReader, deliveryMethod) => {
_peer.HandleDataReceived(dataReader.GetRemainingBytes(), 0);
dataReader.Recycle();
};
_listener.PeerConnectedEvent += (peer) => {
Status = EConnectionStatus.Connected;
var pe = new PeerLn(peer);
pe.SetConnectedState(true);
pe.MessageReceived += HandleMessage;
_peer = pe;
Peer = pe;
Connected?.Invoke();
};
_listener.PeerDisconnectedEvent += (peer, disconnectInfo) => {
if (Peer != null)
{
Peer.MessageReceived -= HandleMessage;
}
_peer?.SetConnectedState(false);
Status = EConnectionStatus.Disconnected;
Disconnected?.Invoke();
};
_netManager = new NetManager(_listener)
{
DisconnectTimeout = 300000
};
_netManager.Start();
}
public void Start(string ipaddress, int port)
{
listener = new EventBasedNetListener();
clientUDP = new NetManager(listener, "ConnectionKey");
clientUDP.UnsyncedEvents = true;
clientUDP.Start();
clientUDP.Connect(ipaddress, port);
listener.PeerDisconnectedEvent += (c, i) =>
{
Client client = GetClientRecord(c);
onDisconnectCallBack.Invoke(client);
};
listener.PeerConnectedEvent += c =>
{
Client client = new Client(c.EndPoint.Host, c.EndPoint.Port);
ClientToNetPeerMap.Add(client, c);
onConnectCallBack?.Invoke(client);
};
listener.NetworkReceiveEvent += (fromPeer, dataReader) =>
{
Client client = GetClientRecord(fromPeer);
var payload = dataReader.GetString();
ReceivedMessage receivedMessage = new ReceivedMessage(client, payload);
onReceiveCallback.Invoke(receivedMessage);
};
clientUDP.PollEvents();
WaitTillConnectionMade();
this._LocalPort = clientUDP.LocalPort;
}
public ServerBrowser()
{
EventBasedNetListener listener = new EventBasedNetListener();
listener.NetworkReceiveUnconnectedEvent += (endpoint, data, type) =>
{
if (type != UnconnectedMessageType.DiscoveryRequest)
{
return;
}
string s = Encoding.UTF8.GetString(data.GetRemainingBytes());
if (s == "mp-server")
{
AddOrUpdate(endpoint);
}
};
byte ipSupport = 0;
IPAddress[] allIPs = Dns.GetHostAddresses(Dns.GetHostName());
foreach (IPAddress ip in allIPs)
{
switch (ip.AddressFamily)
{
case AddressFamily.InterNetworkV6:
ipSupport &= 1;
break;
case AddressFamily.InterNetwork:
ipSupport &= 2;
break;
}
}
net = new NetManager(listener)
{
DiscoveryEnabled = true,
ReuseAddress = true
};
if ((ipSupport | 3) == 3)
{
Log.Message($"Starting with DualStack");
net.Start(5100);
}
else if ((ipSupport | 1) == 1 && (ipSupport | 2) == 0)
{
Log.Message($"Starting with IPv4 only");
net.Start(IPAddress.Any, IPAddress.IPv6None, 5100);
}
else if ((ipSupport | 1) == 0 && (ipSupport | 2) == 2)
{
Log.Message($"Starting with IPv6 only");
net.Start(IPAddress.None, IPAddress.IPv6Any, 5100);
}
doCloseX = true;
closeOnAccept = false;
}
internal static void ConnectClient(string code)
{
try
{
if (LiteNetLib4MirrorCore.State == LiteNetLib4MirrorCore.States.Discovery)
{
LiteNetLib4MirrorCore.StopTransport();
}
EventBasedNetListener listener = new EventBasedNetListener();
LiteNetLib4MirrorCore.Host = new NetManager(listener);
listener.NetworkReceiveEvent += OnNetworkReceive;
listener.NetworkErrorEvent += OnNetworkError;
listener.PeerConnectedEvent += OnPeerConnected;
listener.PeerDisconnectedEvent += OnPeerDisconnected;
LiteNetLib4MirrorCore.SetOptions(false);
LiteNetLib4MirrorCore.Host.Start();
LiteNetLib4MirrorCore.Host.Connect(LiteNetLib4MirrorUtils.Parse(LiteNetLib4MirrorTransport.Singleton.clientAddress, LiteNetLib4MirrorTransport.Singleton.port), code);
LiteNetLib4MirrorTransport.Polling = true;
LiteNetLib4MirrorCore.State = LiteNetLib4MirrorCore.States.ClientConnecting;
}
catch (Exception ex)
{
LiteNetLib4MirrorCore.State = LiteNetLib4MirrorCore.States.Idle;
LiteNetLib4MirrorUtils.LogException(ex);
}
}
public void Start(string ipaddress, int port)
{
listener = new EventBasedNetListener();
//Create a new server and only allow 32 connections
server = new NetManager(listener, 32, "ConnectionKey");
server.UnsyncedEvents = true;
server.Start(port);
LocalPort = server.LocalPort;
listener.PeerDisconnectedEvent += (c, i) =>
{
Client client = GetClientRecord(c);
onDisconnectCallBack?.Invoke(client);
};
listener.PeerConnectedEvent += c =>
{
Client client = new Client(c.EndPoint.Host, c.EndPoint.Port);
ClientToNetPeerMap.Add(client, c);
onConnectCallBack?.Invoke(client);
};
listener.NetworkReceiveEvent += (fromPeer, dataReader) =>
{
Client client = GetClientRecord(fromPeer);
var payload = dataReader.GetString();
ReceivedMessage receivedMessage = new ReceivedMessage(client, payload);
onReceiveCallback.Invoke(receivedMessage);
};
}
public void Server()
{
EventBasedNetListener listener = new EventBasedNetListener();
NetManager server = new NetManager(listener);
server.Start(9050 /* port */);
listener.ConnectionRequestEvent += request =>
{
if (server.ConnectedPeersCount < 10 /* max connections */)
{
request.AcceptIfKey("SomeConnectionKey");
}
else
{
request.Reject();
}
};
listener.PeerConnectedEvent += peer =>
{
Console.WriteLine("We got connection: {0}", peer.EndPoint); // Show peer ip
NetDataWriter writer = new NetDataWriter(); // Create writer class
writer.Put("Hello client!"); // Put some string
peer.Send(writer, DeliveryMethod.ReliableOrdered); // Send with reliability
};
while (!Console.KeyAvailable)
{
server.PollEvents();
Thread.Sleep(15);
}
server.Stop();
}
public bool Start(NewPlayerInfo playerInfo, int port)
{
listener = new EventBasedNetListener();
server = new NetManager(listener);
localPacketProcessor = new NetPacketProcessor();
Console.WriteLine("started instances...");
localPacketProcessor.SubscribeReusable <ZeroGPacket, NetPeer>(OnDataRecieve);
if (!server.Start(port))
{
Console.WriteLine("Failed to start server");
//return false;
throw new Exception("Failed to start server...");
}
newPlayerData = playerInfo;
listener.ConnectionRequestEvent += Listener_ConnectionRequestEvent;
listener.NetworkReceiveEvent += Listener_NetworkReceiveEvent;
listener.PeerConnectedEvent += Listener_PeerConnectedEvent;
listener.PeerDisconnectedEvent += Listener_PeerDisconnectedEvent;
zeroPacketProcessor = new ProcessPacket();
InstanceKeeper.SetServerinstance(this);
GetEvents();
// while (/*!Console.KeyAvailable*/1-1==0)
//{
// server.PollEvents();
// Thread.Sleep(15);
// }
// this.server.Stop();
return(true);
}
public void Start()
{
listener = new EventBasedNetListener();
listener.PeerConnectedEvent += (peer) => {
Console.WriteLine("[DEBUG] Connected peer");
SetState(State.Online);
};
listener.PeerDisconnectedEvent += (peer, disconnetInfo) =>
{
Console.WriteLine(
"Disconnected: {0}, Reason: {1}",
peer.EndPoint,
disconnetInfo.Reason
);
SetState(State.Offline);
};
listener.NetworkReceiveEvent += (fromPeer, dataReader, deliveryMethod) => {
packetProcessor.ReadAllPackets(dataReader, fromPeer);
};
client = new NetManager(listener);
client.Start();
}
void UpdateNetwork()
{
networkListener = new EventBasedNetListener();
networkListener.NetworkReceiveEvent += ReceivePackage;
client = new NetManager(networkListener);
client.Start();
client.Connect("localhost", 9050, "SomeConnectionKey");
NetDataWriter writer = new NetDataWriter();
while (true)
{
foreach (var obj in NetworkObjects)
{
if (obj.Value.networkId == MyNetworkId)
{
if (!obj.Value.CheckChanges())
{
writer.Reset();
obj.Value.WriteData(writer);
Send(writer, DeliveryMethod.Unreliable);
}
}
}
client.PollEvents();
Thread.Sleep(16);
}
client.Stop();
}
public RUdp() : base(NetworkProtocol.RUDP)
{
listener = new EventBasedNetListener();
client = new NetManager(listener)
{
DisconnectTimeout = 20 * 1000
};
client.UpdateTime = 15;
listener.PeerConnectedEvent += (NetPeer peer) =>
{
LogProxy.WriteLine("Connect Success : " + peer.EndPoint);
this.peer = peer;
fireCompleteConnect();
};
listener.PeerDisconnectedEvent += (NetPeer peer, DisconnectInfo disconnectInfo) =>
{
client.Flush();
client.Stop();
fireCompleteDisconnect();
};
listener.NetworkReceiveEvent += (fromPeer, dataReader, deliveryMethod) =>
{
byte[] packet = new byte[dataReader.AvailableBytes];
dataReader.GetBytes(packet, dataReader.AvailableBytes);
fireCompleteReadFromServerStream(packet);
dataReader.Recycle();
};
}
private NetManager ListenServer()
{
var listener = new EventBasedNetListener();
listener.ConnectionRequestEvent += OnConnectionRequestEvent;
listener.PeerConnectedEvent += OnConnectedEvent;
listener.PeerDisconnectedEvent += OnDisconnectedEvent;
listener.NetworkReceiveEvent += OnNetworkReceiveEvent;
var server = new NetManager(listener);
for (var i = 0; i < 10; i++)
{
if (!server.Start())
{
continue;
}
// 10000 - 60000 の範囲外の場合は再度ポートを割り当ててみる
var port = server.LocalPort;
if (10000 <= port && port <= 60000)
{
break;
}
_logger.InfoFormat("out of port range: {0}, restart server", port);
server.Stop();
}
return(server);
}
public static void Start()
{
listener = new EventBasedNetListener();
server = new NetManager(listener);
server.AutoRecycle = true;
server.DiscoveryEnabled = true;
server.UnconnectedMessagesEnabled = true;
for (int i = 0; i < LANDiscoveryConstants.BROADCAST_PORTS.Length; i++)
{
if (server.Start(LANDiscoveryConstants.BROADCAST_PORTS[i]))
{
break;
}
}
listener.NetworkReceiveUnconnectedEvent += NetworkReceiveUnconnected;
pollTimer = new Timer((state) =>
{
server.PollEvents();
});
pollTimer.Change(0, 100);
}
private NetManager GetListener()
{
var listener = new EventBasedNetListener();
listener.NetworkErrorEvent += (point, error) =>
{
Console.WriteLine("err: {0}", error.ToString());
_isRunning = false;
};
listener.PeerDisconnectedEvent += (peer, info) =>
{
Console.WriteLine("info: {0}", info.Reason);
_isRunning = false;
};
listener.NetworkReceiveEvent += (peer, reader, method) =>
{
var json = reader.GetString();
var msg = Message.FromString(json);
Console.WriteLine();
Console.WriteLine($"({msg.Name})>> {msg.Body}");
Console.Write(">> ");
reader.Recycle();
};
var client = new NetManager(listener);
client.Start();
return(client);
}
public void StartClientConnection()
{
//Listener es el encargado de gestionar todos los paquetes recibidos
netListenerClient = new EventBasedNetListener();
//Packet processor es el encargado de procesar los paquetes creados por nosotros, pudiendo leerlos y enviarlos
netPacketProcessorClient = new NetPacketProcessor();
//Manager es donde tenemos todos los datos de la conexion, como el peer
netManagerClient = new NetManager(netListenerClient);
//netManagerServer.NatPunchEnabled = true;
//Evento recibido al conectarse al servidor
netListenerClient.PeerConnectedEvent += (server) =>
{
Debug.Log("Connected to server: " + server);
};
//Evento estandar, cualquier que no es especial como conectarse, desconectarse o ping
netListenerClient.NetworkReceiveEvent += (server, reader, deliveryMethod) =>
{
//Lee los paquetes recibidos y llama a los listeners de cada paquete de los que haya recibido
netPacketProcessorClient.ReadAllPackets(reader, server);
};
//Aqui estaran todos los listeners necesarios para cada paquete
RegisterPacketsListeners();
netManagerClient.Start();
netManagerClient.Connect(ip, port, connectionKey);
}
public void Initialize()
{
EventBasedNetListener listener = new EventBasedNetListener();
listener.NetworkReceiveUnconnectedEvent += OnNetworkReceiveUnconnected;
// TODO: make this a function of the class
listener.ConnectionRequestEvent += request =>
{
if (server.ConnectedPeersCount < serverSettings.MaxPlayers &&
serverState.ServerMode.Value == ServerState.Mode.WAITING)
{
request.AcceptIfKey(serverSettings.Key);
}
else
{
request.Reject();
}
};
listener.PeerConnectedEvent += OnPlayerConnected;
listener.PeerDisconnectedEvent += OnPlayerDisconnected;
listener.NetworkReceiveEvent += OnNetworkReceive;
server = new NetManager(listener);
server.BroadcastReceiveEnabled = true;
server.Start(serverSettings.Port);
Debug.Log($"Local server started on port {serverSettings.Port}");
}
