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));
}
