public void StartClient(GameObject canvas) { canvas.SetActive(false); Debug.LogError("starting client"); netListener = new EventBasedNetListener(); netListener.PeerConnectedEvent += (server) => { Debug.LogError($"Connected to server: {server}"); }; 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(); netManager.Connect("localhost", 12345, ""); connected = true; }
public void Connect(string ip, int port) { serverIp = ip; serverPort = port; EventBasedNetListener listener = new EventBasedNetListener(); listener.PeerConnectedEvent += OnPeerConnected; listener.PeerDisconnectedEvent += OnPeerDisconnected; listener.NetworkReceiveEvent += OnNetworkReceive; client = new NetManager(listener) { AutoRecycle = true, }; PacketProcessor = new NetPacketProcessor(); LiteNetLibUtils.RegisterAllPacketNestedTypes(PacketProcessor); LiteNetLibUtils.RegisterAllPacketProcessorsInCallingAssembly(PacketProcessor); client.Start(); client.Connect(ip, port, "nebula"); SimulatedWorld.Initialize(); LocalPlayer.IsMasterClient = false; LocalPlayer.SetNetworkProvider(this); }
public void StartServer() { DontDestroyOnLoad(gameObject); _logicTimer = new LogicTimer(OnLogicUpdate); _playerManager = new ServerPlayerManager(this); //_packetProcessor = new NetPacketProcessor(); ////register auto serializable vector2 //_packetProcessor.RegisterNestedType((w, v) => w.Put(v), r => r.GetVector2()); ////register auto serializable PlayerState //_packetProcessor.RegisterNestedType<PlayerState>(); //_packetProcessor.SubscribeReusable<JoinPacket, NetPeer>(OnJoinReceived); //_netManager = new NetManager(this) //{ // AutoRecycle = true //}; _netManager = G.CSEngineApp.LiteNet._netManager; _packetProcessor = G.CSEngineApp.LiteNet._packetProcessor; _packetProcessor.RegisterNestedType((w, v) => w.Put(v), r => r.GetVector2()); _packetProcessor.RegisterNestedType <PlayerState>(); _packetProcessor.SubscribeReusable <JoinPacket, NetPeer>(OnJoinReceived); _netManager.Start(10515); _logicTimer.Start(); }
public void StartServer(int port, bool loadSaveFile = false) { PlayerManager = new PlayerManager(); if (loadSaveFile) { SaveManager.LoadServerData(); } SaveManager.SaveOnExit = true; PacketProcessor = new NetPacketProcessor(); StatisticsManager = new StatisticsManager(); #if DEBUG PacketProcessor.SimulateLatency = true; #endif PacketUtils.RegisterAllPacketNestedTypes(PacketProcessor); PacketUtils.RegisterAllPacketProcessorsInCallingAssembly(PacketProcessor); socketServer = new WebSocketServer(port); socketServer.AddWebSocketService("/socket", () => new WebSocketService(PlayerManager, PacketProcessor)); socketServer.Start(); SimulatedWorld.Initialize(); LocalPlayer.SetNetworkProvider(this); LocalPlayer.IsMasterClient = true; // TODO: Load saved player info here LocalPlayer.SetPlayerData(new PlayerData(PlayerManager.GetNextAvailablePlayerId(), GameMain.localPlanet?.id ?? -1, new Float3(1.0f, 0.6846404f, 0.243137181f))); }
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 TestSocketAddress() { IPEndPoint endPoint = new IPEndPoint(new IPAddress(0), 1); SocketAddress socketAddress = endPoint.Serialize(); var serializedSocketAddress = new SerializedSocketAddress(socketAddress); var packet = new Packet { SerializedSocketAddress = serializedSocketAddress }; var writer = new NetDataWriter(); NetPacketProcessor processor = new NetPacketProcessor(); SerializedSocketAddress.RegisterWith(processor); processor.Write(writer, packet); var reader = new NetDataReader(writer.CopyData()); Packet readPacket = null; processor.Subscribe <Packet>(packet => readPacket = packet, () => new Packet()); processor.ReadAllPackets(reader); Assert.IsNotNull(readPacket); Assert.AreEqual(serializedSocketAddress.SocketAddress, readPacket.SerializedSocketAddress.SocketAddress); }
void Awake() { m_ClientScene = SceneManager.LoadScene("client_scene", Constants.DefaultSceneParams); m_ClientSimulation = m_ClientScene.GetPhysicsScene(); SceneManager.MoveGameObjectToScene(m_GetPlayer.gameObject, m_ClientScene); m_LogicLoop = new GameLoop(OnNetworkUpdate); m_Simulation = new SimulationStep[Constants.SNAPSHOT_RATE]; m_Snapshots = new RingBuffer <Snapshot>(Constants.SNAPSHOT_RATE); m_Input = new InputMessage(0, 0, new List <InputData>()); m_PacketProcessor = new NetPacketProcessor(); m_PacketProcessor.RegisterNestedType <EntityState>(); m_PacketProcessor.SubscribeNetSerializable <Snapshot>(OnStateMessage); m_Manager = new NetManager(this); m_LogicLoop.Start(); if (m_Manager.Start()) { m_Manager.Connect("127.0.0.1", 5000, "key"); print("CLIENT NET MANAGER STARTED!"); } else { print("CLIENT NET MANAGER FAILED!"); } m_Poller = GetComponent <InputPoller>(); UI_Handler.instance.TurnOn(); UIControl.instance.TurnOff(); }
void Awake() { client = new NetManager(this); client.Start(); processor = PacketUtils.CreateProcessor(); processor.Subscribe <ClientID>( (packet) => { clientID = packet.ID; clientIDSet = true; }, () => new ClientID() ); processor.Subscribe <WorldInitPacket>(NotifyPacketListeners <WorldInitPacket>, () => new WorldInitPacket()); processor.Subscribe <WorldChunkPacket>(NotifyPacketListeners <WorldChunkPacket>, () => new WorldChunkPacket()); //processor.Subscribe<StateChangePacket>(NotifyPacketListeners<StateChangePacket>, () => new StateChangePacket()); processor.Subscribe <NetCreatePacket>(NotifyPacketListeners <NetCreatePacket>, () => new NetCreatePacket()); processor.Subscribe <NetUpdatePacket>(NotifyPacketListeners <NetUpdatePacket>, () => new NetUpdatePacket()); processor.Subscribe <NetDestroyPacket>(NotifyPacketListeners <NetDestroyPacket>, () => new NetDestroyPacket()); //eventTable = new Dictionary<Type, List<Action<object>>>(); eventTable = new EventTable <object>(); }
private void ConnectInternal() { LocalPlayer.TryLoadGalacticScale2(); clientSocket = new WebSocket(socketAddress); clientSocket.OnOpen += ClientSocket_OnOpen; clientSocket.OnClose += ClientSocket_OnClose; clientSocket.OnMessage += ClientSocket_OnMessage; PacketProcessor = new NetPacketProcessor(); #if DEBUG PacketProcessor.SimulateLatency = true; #endif PacketUtils.RegisterAllPacketNestedTypes(PacketProcessor); PacketUtils.RegisterAllPacketProcessorsInCallingAssembly(PacketProcessor); clientSocket.Connect(); SimulatedWorld.Initialize(); LocalPlayer.IsMasterClient = false; LocalPlayer.SetNetworkProvider(this); if (Config.Options.RememberLastIP) { // We've successfully connected, set connection as last ip, cutting out "ws://" and "/socket" Config.Options.LastIP = socketAddress.Substring(5, socketAddress.Length - 12); Config.SaveOptions(); } }
private void Awake() { DontDestroyOnLoad(gameObject); Random r = new Random(); _cachedServerState = new ServerState(); _cachedShootData = new ShootPacket(); _userName = Environment.MachineName + " " + r.Next(100000); LogicTimer = new LogicTimer(OnLogicUpdate); _writer = new NetDataWriter(); _playerManager = new ClientPlayerManager(this); _shootsPool = new GamePool <ShootEffect>(ShootEffectContructor, 100); _packetProcessor = new NetPacketProcessor(); _packetProcessor.RegisterNestedType((w, v) => w.Put(v), reader => reader.GetVector2()); _packetProcessor.RegisterNestedType <PlayerState>(); _packetProcessor.SubscribeReusable <PlayerJoinedPacket>(OnPlayerJoined); _packetProcessor.SubscribeReusable <JoinAcceptPacket>(OnJoinAccept); _packetProcessor.SubscribeReusable <PlayerLeavedPacket>(OnPlayerLeaved); _netManager = new NetManager(this) { AutoRecycle = true, IPv6Enabled = IPv6Mode.Disabled }; _netManager.Start(); }
public static void RegisterAllPacketProcessorsInCallingAssembly(NetPacketProcessor packetProcessor) { var processors = Assembly.GetCallingAssembly().GetTypes() .Where(t => t.GetCustomAttributes(typeof(RegisterPacketProcessorAttribute), true).Length > 0); foreach (Type type in processors) { var packetProcessorInterface = type.GetInterfaces().FirstOrDefault(i => i.IsGenericType && i.GetGenericTypeDefinition() == typeof(IPacketProcessor <>)); if (packetProcessorInterface != null) { Type packetType = packetProcessorInterface.GetGenericArguments().FirstOrDefault(); Console.WriteLine($"Registering {type.Name} to process packet of type: {packetType.Name}"); // Create instance of the processor Type delegateType = typeof(Action <,>).MakeGenericType(packetType, typeof(NebulaConnection)); object processor = Activator.CreateInstance(type); Delegate callback = Delegate.CreateDelegate(delegateType, processor, type.GetMethod("ProcessPacket")); // Register our processor callback to the PacketProcessor Type subscribeGenericType = typeof(Action <,>).MakeGenericType(packetType, typeof(NebulaConnection)); // TODO: Find a better way to get the "SubscribeReusable" that as the Action<T, TUserData> param. MethodInfo method = packetProcessor.GetType().GetMethods().Where(m => m.Name == "SubscribeReusable").ToArray()[1]; MethodInfo generic = method.MakeGenericMethod(packetType, typeof(NebulaConnection)); generic.Invoke(packetProcessor, new object[] { callback }); } } }
public void Connect(string ip, int port) { serverIp = ip; serverPort = port; clientSocket = new WebSocket($"ws://{ip}:{port}/socket"); clientSocket.OnOpen += ClientSocket_OnOpen; clientSocket.OnClose += ClientSocket_OnClose; clientSocket.OnMessage += ClientSocket_OnMessage; PacketProcessor = new NetPacketProcessor(); #if DEBUG PacketProcessor.SimulateLatency = true; #endif PacketUtils.RegisterAllPacketNestedTypes(PacketProcessor); PacketUtils.RegisterAllPacketProcessorsInCallingAssembly(PacketProcessor); clientSocket.Connect(); SimulatedWorld.Initialize(); LocalPlayer.IsMasterClient = false; LocalPlayer.SetNetworkProvider(this); }
public void Initialize() { Manager = new NetManager(this); Processor = new NetPacketProcessor(); ConfigureListeners(); }
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 NetChannel(DebugNetworkSettings debugNetworkSettings) { netManager = new NetManager(this) { AutoRecycle = true, EnableStatistics = true, UnconnectedMessagesEnabled = true, // For ping/pong }; netPacketProcessor = new NetPacketProcessor(); netDataWriter = new NetDataWriter(); this.debugNetworkSettings = debugNetworkSettings; ApplyDebugNetworkSettings(); // Register nested types used in net commands. netPacketProcessor.RegisterNestedType( NetExtensions.SerializeVector3, NetExtensions.DeserializeVector3); netPacketProcessor.RegisterNestedType( NetExtensions.SerializeQuaternion, NetExtensions.DeserializeQuaternion); netPacketProcessor.RegisterNestedType <PlayerSetupData>(); netPacketProcessor.RegisterNestedType <PlayerMetadata>(); netPacketProcessor.RegisterNestedType <InitialPlayerState>(); netPacketProcessor.RegisterNestedType <PlayerState>(); netPacketProcessor.RegisterNestedType <NetworkObjectState>(); // The client network manager is started immediately for unconnected pings. netManager.Start(); }
public static void RegisterAllPacketProcessorsInCallingAssembly(NetPacketProcessor packetProcessor) { var processors = Assembly.GetCallingAssembly().GetTypes() .Where(t => t.GetCustomAttributes(typeof(RegisterPacketProcessorAttribute), true).Length > 0); MethodInfo method = packetProcessor.GetType().GetMethods() .Where(m => m.Name == nameof(NetPacketProcessor.SubscribeReusable)) .Where(m => m.IsGenericMethod && m.GetGenericArguments().Length == 2) .FirstOrDefault(); foreach (Type type in processors) { var packetProcessorInterface = type.GetInterfaces().FirstOrDefault(i => i.IsGenericType && i.GetGenericTypeDefinition() == typeof(IPacketProcessor <>)); if (packetProcessorInterface != null) { Type packetType = packetProcessorInterface.GetGenericArguments().FirstOrDefault(); Console.WriteLine($"Registering {type.Name} to process packet of type: {packetType.Name}"); // Create instance of the processor Type delegateType = typeof(Action <,>).MakeGenericType(packetType, typeof(NebulaConnection)); object processor = Activator.CreateInstance(type); Delegate callback = Delegate.CreateDelegate(delegateType, processor, type.GetMethod(nameof(IPacketProcessor <object> .ProcessPacket))); // Register our processor callback to the PacketProcessor Type subscribeGenericType = typeof(Action <,>).MakeGenericType(packetType, typeof(NebulaConnection)); MethodInfo generic = method.MakeGenericMethod(packetType, typeof(NebulaConnection)); generic.Invoke(packetProcessor, new object[] { callback }); } else { Log.Warn($"{type.FullName} registered, but doesn't implement {typeof(IPacketProcessor<>).FullName}"); } } }
void Awake() { m_serverScene = SceneManager.LoadScene("server_scene", Constants.DefaultSceneParams); m_ServerSimulation = m_serverScene.GetPhysicsScene(); SceneManager.MoveGameObjectToScene(m_ServerSharedPlayer.gameObject, m_serverScene); m_LogicLoop = new GameLoop(OnNetworkUpdate); m_Inputs = new RingBuffer <InputMessage>(Constants.SNAPSHOT_RATE); m_PacketProcessor = new NetPacketProcessor(); m_PacketProcessor.RegisterNestedType <EntityState>(); m_PacketProcessor.RegisterNestedType <InputData>(); m_PacketProcessor.SubscribeNetSerializable <InputMessage, NetPeer>(OnPlayerInput); m_Manager = new NetManager(this); m_LogicLoop.Start(); if (m_Manager.Start(5000)) { print("SERVER NET MANAGER STARTED!"); } else { print("SERVER NET MANAGER FAILED!"); } }
public void TestThingMessage() { // Test whether the serialization framework supports property inheritance. // ThingMessage.Create derives from CreateMessage which has an Id property. var createThingMessage = new ThingMessages.Create(1, new int[] { }); var writer = new NetDataWriter(); NetPacketProcessor processor = new NetPacketProcessor(); processor.RegisterNestedType <DistributedId>(); processor.Write(writer, createThingMessage); var reader = new NetDataReader(writer.CopyData()); ThingMessages.Create readMessage = null; processor.Subscribe( createMessage => readMessage = createMessage, () => new ThingMessages.Create()); processor.ReadAllPackets(reader); Assert.IsNotNull(readMessage); Assert.AreEqual(new DistributedId(1), readMessage.Id); }
public static void RegisterAllPacketNestedTypes(NetPacketProcessor packetProcessor) { var nestedTypes = AssembliesUtils.GetTypesWithAttribute <RegisterNestedTypeAttribute>(); foreach (Type type in nestedTypes) { Console.WriteLine($"Registering Nested Type: {type.Name}"); if (type.IsClass) { // TODO: Find a better way to get the "NetPacketProcessor.RegisterNestedType" that as the Func<T> param instead of by index. MethodInfo registerMethod = packetProcessor.GetType() .GetMethods() .Where(m => m.Name == nameof(NetPacketProcessor.RegisterNestedType)) .ToArray()[2] .MakeGenericMethod(type); MethodInfo delegateMethod = packetProcessor.GetType().GetMethod(nameof(NetPacketProcessor.CreateNestedClassInstance)).MakeGenericMethod(type); var funcType = typeof(Func <>).MakeGenericType(type); var callback = Delegate.CreateDelegate(funcType, packetProcessor, delegateMethod); registerMethod.Invoke(packetProcessor, new object[] { callback }); } else if (type.IsValueType) { MethodInfo method = typeof(NetPacketProcessor).GetMethod(nameof(NetPacketProcessor.RegisterNestedType), Type.EmptyTypes); MethodInfo generic = method.MakeGenericMethod(type); generic.Invoke(packetProcessor, null); } else { Log.Error($"Could not register nested type: {type.Name}. Must be a class or struct."); } } }
/// <summary> /// Initializes a new instance of the <see cref="NPServer"/> class. /// </summary> /// <param name="server">Server.</param> /// <param name="processor">Packet Processor.</param> /// <param name="serverAddress">Server Address.</param> /// <param name="port">Server Port.</param> /// <param name="maxPlayers">Max Players.</param> public NPServer(NetPacketProcessor processor, string serverAddress, ushort port, int maxPlayers) { this.PacketProcessor = processor; this.ServerAddress = serverAddress; this.ServerPort = port; this.MaxPlayers = maxPlayers; }
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 Init() { _samplePacket = new SamplePacket { SomeFloat = 3.42f, SomeIntArray = new[] { 6, 5, 4 }, SomeString = "Test String", SomeVector2 = new SomeVector2(4, 5), SomeVectors = new[] { new SomeVector2(1, 2), new SomeVector2(3, 4) }, SomeEnum = TestEnum.B, SomeByteArray = new byte[] { 255, 1, 0 }, TestObj = new SampleNetSerializable { Value = 5 }, TestArray = new [] { new SampleNetSerializable { Value = 6 }, new SampleNetSerializable { Value = 15 } }, SampleClassArray = new[] { new SampleClass { Value = 6 }, new SampleClass { Value = 15 } } }; _packetProcessor = new NetPacketProcessor(); _packetProcessor.RegisterNestedType <SampleNetSerializable>(); _packetProcessor.RegisterNestedType(() => new SampleClass()); _packetProcessor.RegisterNestedType(SomeVector2.Serialize, SomeVector2.Deserialize); }
public static void RegisterAllPacketNestedTypesInAssembly(Assembly assembly, NetPacketProcessor packetProcessor) { System.Collections.Generic.IEnumerable <Type> nestedTypes = AssembliesUtils.GetTypesWithAttributeInAssembly <RegisterNestedTypeAttribute>(assembly); foreach (Type type in nestedTypes) { Log.Info($"Registering Nested Type: {type.Name}"); if (type.IsClass) { MethodInfo registerMethod = packetProcessor.GetType().GetMethods() .Where(m => m.Name == nameof(NetPacketProcessor.RegisterNestedType)) .FirstOrDefault(m => m.GetParameters().Length == 1 && m.GetParameters()[0].ParameterType.Name.Equals(typeof(Func <>).Name)) .MakeGenericMethod(type); MethodInfo delegateMethod = packetProcessor.GetType().GetMethod(nameof(NetPacketProcessor.CreateNestedClassInstance)).MakeGenericMethod(type); Type funcType = typeof(Func <>).MakeGenericType(type); Delegate callback = Delegate.CreateDelegate(funcType, packetProcessor, delegateMethod); registerMethod.Invoke(packetProcessor, new object[] { callback }); } else if (type.IsValueType) { MethodInfo method = typeof(NetPacketProcessor).GetMethod(nameof(NetPacketProcessor.RegisterNestedType), Type.EmptyTypes); MethodInfo generic = method.MakeGenericMethod(type); generic.Invoke(packetProcessor, null); } else { Log.Error($"Could not register nested type: {type.Name}. Must be a class or struct."); } } }
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 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); }
static void Main(string[] args) { NetPacketProcessor _netPacketProcessor = new NetPacketProcessor(); LCRClient listener = new LCRClient(); NetManager client = new NetManager(listener); listener.client = client; client.Start(); var server = client.Connect("localhost" /* host ip or name */, 9050 /* port */, "SomeConnectionKey" /* text key or NetDataWriter */); client.DisconnectTimeout = 6000; pl mpl = new pl { Name = "Bob", Tickets = 3 }; NetDataWriter dw = new NetDataWriter(); listener.tpl = mpl; SamplePacket samPack = new SamplePacket { }; Thread.Sleep(500); while (server.ConnectionState != ConnectionState.Connected) { int cd = 1000; Console.WriteLine($"[Client {DateTime.Now}] connection to localhost port 9050 failed. Trying again in {cd} ms."); Thread.Sleep(cd); server = client.Connect("localhost" /* host ip or name */, 9050 /* port */, "SomeConnectionKey" /* text key or NetDataWriter */); } listener.AttachServer(server); while (server.ConnectionState == ConnectionState.Connected) { client.PollEvents(); Thread.Sleep(15); if (Console.KeyAvailable) { var key = Console.ReadKey(false); if (key.KeyChar == 'r') { listener.SendPacket(listener.tpl); } else if (key.KeyChar == 'c') { CreateGamePacket cgp = new CreateGamePacket(); listener.SendCreateGameRequest(cgp); } } if (server.ConnectionState != ConnectionState.Connected) { break; } } client.Stop(); }
private void StartProcessor() { _processor = new NetPacketProcessor(); _processor.SubscribeReusable <LoginResponse, NetPeer>(_broadcaster.Login); _processor.SubscribeReusable <PlayerJoined, NetPeer>(_broadcaster.PlayerJoined); _processor.SubscribeReusable <Move, NetPeer>(_broadcaster.Move); }
public DistributedHost( IWorkQueue workQueue, ushort listenPort, bool isListener = true, int disconnectTimeout = -1, INetLogger logger = null) { Contract.Requires(listenPort != 0); ListenPort = listenPort; this.workQueue = workQueue; this.logger = logger; // determine our IP // hat tip https://stackoverflow.com/questions/6803073/get-local-ip-address IPHostEntry host = Dns.GetHostEntry(Dns.GetHostName()); IPAddress ipv4Address = host .AddressList .FirstOrDefault(ip => ip.AddressFamily == AddressFamily.InterNetwork); SocketAddress = new SerializedSocketAddress(new IPEndPoint(ipv4Address, listenPort).Serialize()); netManager = new NetManager(new Listener(this)) { BroadcastReceiveEnabled = true, UnconnectedMessagesEnabled = true }; if (disconnectTimeout != -1) { netManager.DisconnectTimeout = disconnectTimeout; } netPacketProcessor = new NetPacketProcessor(); RegisterType <SerializedSocketAddress>(); RegisterType <DistributedId>(); netPacketProcessor.SubscribeReusable <AnnounceMessage, IPEndPoint>(OnAnnounceReceived); netPacketProcessor.SubscribeReusable <AnnounceResponseMessage, IPEndPoint>(OnAnnounceResponseReceived); netDataWriter = new NetDataWriter(); bool managerStarted; if (isListener) { managerStarted = netManager.Start(ListenPort); } else { managerStarted = netManager.Start(); } if (!managerStarted) { throw new PeerException("Could not start netManager"); } }
public void SendPacket <T>(NetPeer peer, T packet, DeliveryMethod deliveryMethod, PacketType packetType = PacketType.Serialized) where T : class, new() { NetDataWriter.Reset(); NetDataWriter.Put((byte)packetType); NetPacketProcessor.Write(NetDataWriter, packet); // Logger.Log($"[SERVER] SendPacket sending {peer.Id} {NetDataWriter.Length} bytes for {packet}".ColoredLog(Colors.Yellow)); peer.Send(NetDataWriter, deliveryMethod); }
public void SendPacketToEveryone <T>(T packet, DeliveryMethod deliveryMethod, PacketType packetType = PacketType.Serialized) where T : class, new() { NetDataWriter.Reset(); NetDataWriter.Put((byte)packetType); NetPacketProcessor.Write(NetDataWriter, packet); NetManager?.SendToAll(NetDataWriter, deliveryMethod); // Logger.Log($"[SERVER] SendPacketToEveryone sending {NetDataWriter.Length} bytes for {packet}".ColoredLog(Colors.Yellow)); }