internal void Send <T>(T packet) where T : class, new()
{
var data = _processor.Write(packet);
var peer = _client.FirstPeer;
peer.Send(data, DeliveryMethod.ReliableUnordered);
}
public void CustomPackageTest()
{
var writer = new NetDataWriter();
_packetProcessor.Write(writer, _samplePacket);
var reader = new NetDataReader(writer.CopyData());
SamplePacket readPackage = null;
_packetProcessor.SubscribeReusable <SamplePacket>(
packet =>
{
readPackage = packet;
});
_packetProcessor.ReadAllPackets(reader);
Assert.NotNull(readPackage);
Assert.IsTrue(AreSame(_samplePacket.EmptyString, readPackage.EmptyString));
Assert.AreEqual(_samplePacket.SomeFloat, readPackage.SomeFloat);
Assert.AreEqual(_samplePacket.SomeIntArray, readPackage.SomeIntArray);
Assert.IsTrue(AreSame(_samplePacket.SomeString, readPackage.SomeString));
Assert.AreEqual(_samplePacket.SomeVector2, readPackage.SomeVector2);
Assert.AreEqual(_samplePacket.SomeVectors, readPackage.SomeVectors);
Assert.AreEqual(_samplePacket.SomeEnum, readPackage.SomeEnum);
Assert.AreEqual(_samplePacket.TestObj.Value, readPackage.TestObj.Value);
Assert.AreEqual(_samplePacket.SomeByteArray, readPackage.SomeByteArray);
}
public void SendPacket <T>(T packet) where T : class, new()
{
lock (pendingPackets)
{
byte[] rawData = packetProcessor.Write(packet);
pendingPackets.Enqueue(rawData);
ProcessPacketQueue();
}
}
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));
}
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 SendPacket <T>(T packet, DeliveryMethod deliveryMethod) where T : class, Packet, new()
{
if (netManager != null)
{
writer.Reset();
packetProcessor.Write(writer, packet);
netManager.SendToAll(writer, deliveryMethod);
}
}
private void Send <T>(T packet, IPEndPoint target) where T : class, new()
{
SocketError errorCode = 0;
_cacheWriter.Reset();
_cacheWriter.Put((byte)PacketProperty.NatMessage);
_netPacketProcessor.Write(_cacheWriter, packet);
_socket.SendTo(_cacheWriter.Data, 0, _cacheWriter.Length, target, ref errorCode);
}
// update from network
void FixedUpdate()
{
netManager.PollEvents();
netManager.NatPunchModule.PollEvents();
// send data packets
netManager.SendToAll(netPacketProcessor.Write(dataToHost.ToPacket()), DeliveryMethod.Sequenced);
// cleanup
messages.Update();
}
public static void SendPacket <T>(T packet, NetPeer peer, DeliveryMethod deliveryMethod) where T : class, new()
{
if (peer != null)
{
writer.Reset();
packetProcessor.Write(writer, packet);
peer.Send(writer, deliveryMethod);
}
}
private void LoginAndWalk()
{
Random rnd = new Random();
float x = 0;
float y = 0.13f;
float z = 0;
NetManager _client;
NetPacketProcessor _netPacketProcessor = new NetPacketProcessor();
EventBasedNetListener listener = new EventBasedNetListener();
listener.NetworkReceiveEvent += Listener_NetworkReceiveEvent;
_client = new NetManager(listener);
_client.Start();
_client.Connect("localhost", 9050, "SomeConnectionKey");
string userName = Thread.CurrentThread.ManagedThreadId.ToString();
Console.WriteLine(userName);
_client.SendToAll(_netPacketProcessor.Write(new Packet.Login {
userName = userName
}), DeliveryMethod.ReliableOrdered);
while (true)
{
Thread.Sleep(100);
var bytes = _netPacketProcessor.Write(new Packet.PlayerTransform
{
x = x,
y = y,
z = z,
rot_x = 0,
rot_y = 0,
rot_z = 0,
rot_w = 0,
userName = userName
});
x += (float)rnd.NextDouble() + -(float)rnd.NextDouble();
y += 0;
z += (float)rnd.NextDouble() + -(float)rnd.NextDouble();
_client.SendToAll(bytes, DeliveryMethod.ReliableOrdered);
}
}
public void SendPacket <T>(T packet) where T : class, new()
{
if (peerSocket.ReadyState == WebSocketState.Open)
{
peerSocket.Send(packetProcessor.Write(packet));
}
else
{
Log.Warn($"Cannot send packet {packet?.GetType()} to a closed connection {peerEndpoint}");
}
}
public void SendPacket <T>(T packet, DeliveryMethod deliveryMethod) where T : class, new()
{
if (_server == null)
{
return;
}
_writer.Reset();
_writer.Put((byte)PacketType.Serialized);
_packetProcessor.Write(_writer, packet);
_server.Send(_writer, deliveryMethod);
}
public void SendPacket <T>(T packet, DeliveryMethod deliveryMethod, PacketType packetType = PacketType.Serialized) where T : class, new()
{
if (Server != null)
{
NetDataWriter.Reset();
NetDataWriter.Put((byte)packetType);
NetPacketProcessor.Write(NetDataWriter, packet);
Server.Send(NetDataWriter, deliveryMethod);
// Logger.Log($"[CLIENT] SendPacket sending {NetDataWriter.Length} bytes for {packet}".ColoredLog(Colors.Yellow));
}
}
public void SendPacket <T>(T packet, DeliveryMethod deliveryMethod = DeliveryMethod.ReliableOrdered) where T : class, new()
{
if (peer.ConnectionState == ConnectionState.Connected)
{
peer.Send(packetProcessor.Write(packet), deliveryMethod);
peer.Flush();
}
else
{
Console.WriteLine($"Cannot send packet {packet?.GetType()} to a closed connection {peer?.EndPoint}");
}
}
public void SendPacket <T>(T packet, SendType sendType) where T : class, new()
{
if (_peer == null)
{
return;
}
_writer.Reset();
_writer.Put((byte)PacketType.Serialized);
_packetProcessor.Write(_writer, packet); // 내부에서 시리얼라이즈
_peer.Send(_writer, sendType);
}
public void SendPacket <T>(NetPeer server, T packet, DeliveryMethod deliveryMethod) where T : class, new()
{
if (server == null)
{
return;
}
_writer.Reset();
_writer.Put((byte)PacketType.Serialized);
_packetProcessor.Write(_writer, packet);
server.Send(_writer, deliveryMethod);
Debug.Log("Packet sent to " + server.EndPoint);
}
// update from network
void FixedUpdate()
{
netManager.PollEvents();
netManager.NatPunchModule.PollEvents();
// send data packets
netManager.SendToAll(netPacketProcessor.Write(data.ToPacket()), DeliveryMethod.Sequenced);
// cleanup
foreach (int peerID in clientMessages.Keys)
{
clientMessages[peerID].Update();
}
}
public void SendPacket(Packet packet)
{
if (peer.ConnectionState == ConnectionState.Connected)
{
peer.Send(netPacketProcessor.Write(packet.ToWrapperPacket()), NitroxDeliveryMethod.ToLiteNetLib(packet.DeliveryMethod));
peer.Flush();
}
else
{
Log.Info("Cannot send packet to a closed connection.");
}
}
public override void Send(uint frame, List <Order> orders)
{
var scheduledFrame = frame + OrderSchedulingOffsetInFrames;
base.Send(scheduledFrame, orders);
_writer.Reset();
var packet = new SkirmishOrderPacket()
{
Frame = scheduledFrame,
Orders = orders
};
_processor.Write(_writer, packet);
_manager.SendToAll(_writer, DeliveryMethod.ReliableOrdered);
}
public override void Send(uint frame, List <Order> orders)
{
var scheduledFrame = frame + OrderSchedulingOffsetInFrames;
Logger.Trace($"Frame {frame}: Sending {orders.Count} for frame {scheduledFrame}");
var packet = new SkirmishOrderPacket()
{
Frame = scheduledFrame,
Orders = orders
};
StorePacket(packet);
_writer.Reset();
_processor.Write(_writer, packet);
_manager.SendToAll(_writer, DeliveryMethod.ReliableOrdered);
}
private void Loop()
{
var writer = new NetDataWriter();
var processId = Process.GetCurrentProcess().Id;
while (_isRunning)
{
writer.Reset();
_processor.Write(writer, new LobbyBroadcastPacket()
{
ProcessId = processId,
Username = Username,
IsHosting = _game.SkirmishManager?.IsHosting ?? false,
});
_manager.PollEvents();
_manager.SendBroadcast(writer, Ports.LobbyScan);
var removedCount = _players.RemoveAll(IsTimedOut);
if (removedCount > 0)
{
Logger.Info($"Timeout: Removed {removedCount} players from lobby.");
}
try
{
Thread.Sleep(100);
}
catch (ThreadInterruptedException)
{
// Ignore this
}
}
bool IsTimedOut(LobbyPlayer player) =>
(DateTime.Now - player.LastSeen).TotalSeconds >= 3.0;
}
private void Run()
{
var turn = 1;
var writer = new NetDataWriter();
var processor = new NetPacketProcessor();
processor.RegisterNestedType <Order>(() => new Order());
while (manager != null)
{
manager.PollEvents();
Thread.Sleep(100);
if (gameStarted)
{
writer.Reset();
writer.Put((byte)PacketType.Orders);
var orderPacket = new OrderPacket()
{
Turn = turn,
Orders = orders.ToArray()
};
processor.Write(writer, orderPacket);
manager.SendToAll(writer, DeliveryMethod.ReliableOrdered);
foreach (var order in orders)
{
OrderReceived?.Invoke(order);
}
orders.Clear();
turn++;
}
}
}
public void SendToAll(ZeroGPacket packet, DeliveryMethod deliveryType)
{
server.SendToAll(localPacketProcessor.Write(packet), deliveryType);
}
public void Send(Packet packet)
{
client.SendToAll(netPacketProcessor.Write(packet.ToWrapperPacket()), NitroxDeliveryMethod.ToLiteNetLib(packet.DeliveryMethod));
client.Flush();
}
public void Send <T>(T payload) where T : class, new()
{
Manager.FirstPeer.Send(_processor.Write(payload), DeliveryMethod.Unreliable);
}
public void CustomPackageTest()
{
var writer = new NetDataWriter();
_packetProcessor.Write(writer, _samplePacket);
var reader = new NetDataReader(writer);
SamplePacket readPackage = null;
_packetProcessor.SubscribeReusable <SamplePacket>(
packet =>
{
readPackage = packet;
});
_packetProcessor.ReadAllPackets(reader);
Assert.NotNull(readPackage);
Assert.IsTrue(AreSame(_samplePacket.EmptyString, readPackage.EmptyString));
Assert.AreEqual(_samplePacket.SomeFloat, readPackage.SomeFloat);
Assert.AreEqual(_samplePacket.SomeIntArray, readPackage.SomeIntArray);
Assert.IsTrue(AreSame(_samplePacket.SomeString, readPackage.SomeString));
Assert.AreEqual(_samplePacket.SomeVector2, readPackage.SomeVector2);
Assert.AreEqual(_samplePacket.SomeVectors, readPackage.SomeVectors);
Assert.AreEqual(_samplePacket.SomeEnum, readPackage.SomeEnum);
Assert.AreEqual(_samplePacket.TestObj.Value, readPackage.TestObj.Value);
Assert.AreEqual(_samplePacket.TestArray, readPackage.TestArray);
Assert.AreEqual(_samplePacket.SomeByteArray, readPackage.SomeByteArray);
Assert.AreEqual(_samplePacket.SampleClassArray, readPackage.SampleClassArray);
CollectionAssert.AreEqual(_samplePacket.SampleClassList, readPackage.SampleClassList);
CollectionAssert.AreEqual(_samplePacket.VectorList, readPackage.VectorList);
//remove test
_samplePacket.SampleClassList.RemoveAt(0);
_samplePacket.SampleClassArray = new [] { new SampleClass {
Value = 1
} };
_samplePacket.VectorList.RemoveAt(0);
writer.Reset();
_packetProcessor.Write(writer, _samplePacket);
reader.SetSource(writer);
_packetProcessor.ReadAllPackets(reader);
Assert.AreEqual(_samplePacket.SampleClassArray, readPackage.SampleClassArray);
CollectionAssert.AreEqual(_samplePacket.SampleClassList, readPackage.SampleClassList);
//add test
_samplePacket.SampleClassList.Add(new SampleClass {
Value = 152
});
_samplePacket.SampleClassList.Add(new SampleClass {
Value = 154
});
_samplePacket.SampleClassArray = new[] { new SampleClass {
Value = 1
}, new SampleClass {
Value = 2
}, new SampleClass {
Value = 3
} };
_samplePacket.VectorList.Add(new SomeVector2(500, 600));
writer.Reset();
_packetProcessor.Write(writer, _samplePacket);
reader.SetSource(writer);
_packetProcessor.ReadAllPackets(reader);
Assert.AreEqual(_samplePacket.SampleClassArray, readPackage.SampleClassArray);
CollectionAssert.AreEqual(_samplePacket.SampleClassList, readPackage.SampleClassList);
}
