etc
/
SmoOnlineServer
mirror of https://github.com/Sanae6/SmoOnlineServer.git
0
0
Fork 0
Code Issues Projects Releases Wiki Activity

Updated test client to send varsize packets, 8p test

This commit is contained in:
Sanae 2022-03-14 17:48:30 -06:00
parent 15960a8d5a
commit 3974b7022e
2 changed files with 84 additions and 72 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
Shared/Packet/PacketHeader.cs
View File

@ -13,14 +13,14 @@ public struct PacketHeader : IPacket {
public short Size => 20; public short Size => 20;
public void Serialize(Span<byte> data) { public void Serialize(Span<byte> data) {
// MemoryMarshal.Write(data, ref Length);
MemoryMarshal.Write(data, ref Id); MemoryMarshal.Write(data, ref Id);
MemoryMarshal.Write(data[16..], ref Type); MemoryMarshal.Write(data[16..], ref Type);
MemoryMarshal.Write(data[18..], ref PacketSize);
} }
public void Deserialize(Span<byte> data) { public void Deserialize(Span<byte> data) {
Id = MemoryMarshal.Read<Guid>(data); Id = MemoryMarshal.Read<Guid>(data);
Type = MemoryMarshal.Read<PacketType>(data[16..]); Type = MemoryMarshal.Read<PacketType>(data[16..]);
Type = MemoryMarshal.Read<PacketType>(data[16..]); PacketSize = MemoryMarshal.Read<short>(data[16..]);
} }
} }

152
TestClient/Program.cs
View File

@ -6,73 +6,85 @@ using Shared;
using Shared.Packet; using Shared.Packet;
using Shared.Packet.Packets; using Shared.Packet.Packets;
// TcpClient client = new TcpClient(args[0], 1027); // Guid ownId = new Guid(1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
Guid ownId = new Guid(1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0); Guid baseOtherId = Guid.Parse("8ca3fcdd-2940-1000-b5f8-579301fcbfbb");
// Guid ownId = Guid.NewGuid();
// Guid otherId = Guid.Parse("d5feae62-2e71-1000-88fd-597ea147ae88"); PacketType[] reboundPackets = {
// Logger logger = new Logger("Client"); PacketType.Player,
// NetworkStream stream = client.GetStream(); PacketType.Cap,
// PacketType.Capture,
// Vector3 basePoint = Vector3.Zero; PacketType.Costume,
// PacketType.Tag,
// PacketType[] reboundPackets = { PacketType.Game,
// PacketType.Player, // PacketType.Shine
// PacketType.Cap, };
// PacketType.Capture,
// PacketType.Costume, string lastCapture = "";
// PacketType.Tag,
// PacketType.Shine async Task S(string n, Guid otherId, Guid ownId) {
// }; Logger logger = new Logger($"Client ({n})");
// TcpClient client = new TcpClient(args[0], 1027);
// string lastCapture = ""; NetworkStream stream = client.GetStream();
// logger.Info("Connected!");
// async Task S() { async Task<bool> Read(Memory<byte> readMem, int readSize, int readOffset) {
// IMemoryOwner<byte> owner = MemoryPool<byte>.Shared.Rent(Constants.MaxPacketSize); readSize += readOffset;
// while (true) { while (readOffset < readSize) {
// await stream.ReadAsync(owner.Memory); int size = await stream.ReadAsync(readMem[readOffset..readSize]);
// PacketHeader header = MemoryMarshal.Read<PacketHeader>(owner.Memory.Span); if (size == 0) {
// PacketType type = header.Type; // treat it as a disconnect and exit
// if (header.Id != otherId) continue; logger.Info($"Socket {client.Client.RemoteEndPoint} disconnected.");
// if (type is PacketType.Player) { return false;
// // CapPacket cap = new CapPacket(); }
// PlayerPacket playerPacket = new PlayerPacket();
// playerPacket.Deserialize(owner.Memory.Span[Constants.HeaderSize..]); readOffset += size;
// logger.Info(playerPacket.Hack); }
// if (playerPacket.Hack != lastCapture) logger.Info($"Changed to hack: {lastCapture = playerPacket.Hack}");
// // cap.Position = playerPacket.Position + Vector3.UnitY * 500f; return true;
// // cap.Rotation = Quaternion.CreateFromYawPitchRoll(0,0,0); }
// // cap.CapAnim = "StayR";
// // playerPacket.Position = new Vector3(1000000f); {
// // playerPacket.ThrowingCap = true; ConnectPacket connect = new ConnectPacket {
// // header.Id = ownId; ConnectionType = ConnectPacket.ConnectionTypes.FirstConnection,
// // MemoryMarshal.Write(owner.Memory.Span, ref header); ClientName = n
// // playerPacket.Serialize(owner.Memory.Span[Constants.HeaderSize..]); };
// // await stream.WriteAsync(owner.Memory[..Constants.MaxPacketSize]); PacketHeader coolHeader = new PacketHeader {
// // header.Type = PacketType.Cap; Type = PacketType.Connect,
// // MemoryMarshal.Write(owner.Memory.Span, ref header); Id = ownId,
// // cap.Serialize(owner.Memory.Span[Constants.HeaderSize..]); PacketSize = connect.Size,
// // await stream.WriteAsync(owner.Memory[..Constants.MaxPacketSize]); };
// // continue; IMemoryOwner<byte> connectOwner = MemoryPool<byte>.Shared.RentZero(Constants.HeaderSize + connect.Size);
// } // coolHeader.Serialize(connectOwner.Memory.Span[..Constants.HeaderSize]);
// MemoryMarshal.Write(connectOwner.Memory.Span[..Constants.HeaderSize], ref coolHeader);
// if (reboundPackets.All(x => x != type)) continue; connect.Serialize(connectOwner.Memory.Span[Constants.HeaderSize..(Constants.HeaderSize + connect.Size)]);
// header.Id = ownId; await stream.WriteAsync(connectOwner.Memory[..(Constants.HeaderSize + connect.Size)]);
// MemoryMarshal.Write(owner.Memory.Span, ref header); connectOwner.Dispose();
// await stream.WriteAsync(owner.Memory[..Constants.MaxPacketSize]); }
// }
// } while (true) {
// IMemoryOwner<byte> owner = MemoryPool<byte>.Shared.RentZero(0xFF);
// PacketHeader coolHeader = new PacketHeader { if (!await Read(owner.Memory, Constants.HeaderSize, 0)) return;
// Type = PacketType.Connect, PacketHeader header = MemoryMarshal.Read<PacketHeader>(owner.Memory.Span);
// Id = ownId if (header.Size > 0) {
// }; if (!await Read(owner.Memory, header.PacketSize, Constants.HeaderSize)) return;
// IMemoryOwner<byte> owner = MemoryPool<byte>.Shared.RentZero(Constants.MaxPacketSize); }
// MemoryMarshal.Write(owner.Memory.Span[..], ref coolHeader); PacketType type = header.Type;
// ConnectPacket connect = new ConnectPacket { if (header.Id != otherId) continue;
// ConnectionType = ConnectionTypes.Reconnecting, if (reboundPackets.All(x => x != type)) continue;
// ClientName = "Test Sanae" if (type == PacketType.Player) {
// };
// connect.Serialize(owner.Memory.Span[Constants.HeaderSize..Constants.MaxPacketSize]); }
// await stream.WriteAsync(owner.Memory); header.Id = ownId;
// logger.Info("Connected"); MemoryMarshal.Write(owner.Memory.Span[..Constants.HeaderSize], ref header);
// await S(); await stream.WriteAsync(owner.Memory[..(Constants.HeaderSize + header.PacketSize)]);
owner.Dispose();
}
}
Guid temp = baseOtherId;
IEnumerable<Task> stuff = Enumerable.Range(0, 7).Select(i => {
Guid newOwnId = Guid.NewGuid();
Task task = S($"Sussy {i}", temp, newOwnId);
temp = newOwnId;
return task;
});
await Task.WhenAll(stuff.ToArray());