public void OnPeerDisconnected(NetPeer peer, DisconnectInfo disconnectInfo)
{
if (Peers.Contains(peer))
{
Peers.Remove(peer);
}
LobbyPlayer lp = LobbyMenu.instance.GetPeer(peer);
if (lp)
{
LobbyMenu.instance.RemovePlayer(lp);
}
PLobbyPlayer packet = new PLobbyPlayer();
packet.id = lp.id;
packet.name = lp.name;
packet.action = false;
for (int i = 0; i < Peers.Count; i++)
{
Peers[i].Send(serializer.Serialize <PLobbyPlayer>(packet), SendOptions.ReliableOrdered);
}
Debug.Log("Peer disconnected, reason: " + disconnectInfo.Reason.ToString());
}
public void CustomPackageTest()
{
var writer = new NetDataWriter();
writer.Put(_serializer.Serialize(_samplePacket));
var reader = new NetDataReader(writer.CopyData());
SamplePacket readPackage = null;
_serializer.SubscribeReusable <SamplePacket>(
packet =>
{
readPackage = packet;
});
_serializer.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);
}
public static void Serialize_Class(object obj, BitStreamWriter writer)
{
if (obj == null)
{
writer.WriteBit(false);
return;
}
writer.WriteBit(true);
NetSerializer.Serialize(obj, writer);
}
private void NetSerializerTest(NetSerializer serializer, NetDataWriter netDataWriter, Stopwatch stopwatch, SamplePacket samplePacket)
{
netDataWriter.Reset();
stopwatch.Restart();
for (int i = 0; i < LoopLength; i++)
{
serializer.Serialize(netDataWriter, samplePacket);
}
stopwatch.Stop();
Console.WriteLine($"NetSerializer time: {stopwatch.ElapsedMilliseconds} ms, size: { netDataWriter.Length / LoopLength} bytes");
}
public void OnPeerConnected(NetPeer peer)
{
Debug.Log("Connected to " + peer.EndPoint);
string cName = clientName;
PClientHandshake packet = new PClientHandshake();
packet.clientName = cName;
host.Send(serializer.Serialize(packet), SendOptions.ReliableOrdered);
}
// Use this for initialization
void Start()
{
NetSerializer serializer = new NetSerializer();
SimplePacket packet = new SimplePacket()
{
Login = "******",
Password = "******"
};
serializer.Serialize(packet);
}
public void OnPeerConnected(NetPeer peer)
{
Console.WriteLine("[Client] connected to: {0}:{1}", peer.EndPoint.Host, peer.EndPoint.Port);
SamplePacket sp = 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) }
};
Console.WriteLine("Sending to server:\n" + sp);
peer.Send(_serializer.Serialize(sp), SendOptions.ReliableOrdered);
}
public void OnPeerConnected(NetPeer peer)
{
Console.WriteLine("[Client] connected to: {0}:{1}", peer.EndPoint.Host, peer.EndPoint.Port);
SamplePacket sp = 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) },
TestObj = new SampleNetSerializable {
Value = 5
}
};
byte[] data = _serializer.Serialize(sp);
Console.WriteLine("Sending to server (length {0}):\n{1}", data.Length, sp);
peer.Send(data, SendOptions.ReliableOrdered);
}
private async void OnClientConnection(ClientConnection clientConnection, NetPeer peer)
{
GC.Collect();
//check game state
if (_gameMode == GameMode.Royale && (_serverState == ServerState.Playing || _serverState == ServerState.EndGame))
{
Logger.Log($"SERVER connection attempt during game: {clientConnection.UserId}");
_server.DisconnectPeer(peer);
return;
}
//check player
var clientData = await _masterClient.RequestClientInfo(clientConnection.UserId, clientConnection.UserKey);
if (!clientData.Valid)
{
Logger.Log($"SERVER invalid connection attempt: {clientConnection.UserId}", true);
_server.DisconnectPeer(peer);
return;
}
//add player to wait list
if (_gameMode == GameMode.Free)
{
_waitingPlayers.Add(peer.GetUId(), clientData);
}
//create player for royale
if (_gameMode == GameMode.Royale)
{
var player = new Player(clientData.UserId, peer.GetUId(), clientData.Name, clientData.DoubleUnits, _config)
{
UnitSkins = clientData.UnitSkins
};
_players.Add(peer.GetUId(), player);
if (_players.Count == 1)
{
_waitTime = _config.PlayerWaitTime;
_serverState = ServerState.WaitingPlayers;
}
}
//send map
peer.Send(_netSerializer.Serialize(_world.GetServerMap()), SendOptions.ReliableUnordered);
//add time
if (_waitTime < _config.MinWaitTime)
{
_waitTime = _config.MinWaitTime;
}
//min time if last player
if (_players.Count >= _config.MaxPlayers && _waitTime > _config.MinWaitTime)
{
_waitTime = _config.MinWaitTime;
}
//send player info
Logger.Log($"SERVER player '{clientData.Name}' connected");
SendPlayersInfo();
//Send info to master
await SendInfoToMaster();
}
private void TestPerformance()
{
const int LoopLength = 100000;
//Test serializer performance
Stopwatch stopwatch = new Stopwatch();
BinaryFormatter binaryFormatter = new BinaryFormatter();
MemoryStream memoryStream = new MemoryStream();
NetDataWriter netDataWriter = new NetDataWriter();
SamplePacket samplePacket = new SamplePacket
{
SomeFloat = 0.3f,
SomeString = "TEST",
SomeIntArray = new [] { 1, 2, 3 },
SomeVector2 = new SomeVector2(1, 2),
SomeVectors = new [] { new SomeVector2(3, 4), new SomeVector2(5, 6) }
};
NetSerializer netSerializer = new NetSerializer();
netSerializer.RegisterCustomType <SampleNetSerializable>();
netSerializer.RegisterCustomType(SomeVector2.Serialize, SomeVector2.Deserialize);
//Prewarm cpu
for (int i = 0; i < 10000000; i++)
{
double c = Math.Sin(i);
}
//Test binary formatter
stopwatch.Start();
for (int i = 0; i < LoopLength; i++)
{
binaryFormatter.Serialize(memoryStream, samplePacket);
}
stopwatch.Stop();
Console.WriteLine("BinaryFormatter time: " + stopwatch.ElapsedMilliseconds + " ms");
//Test NetSerializer
stopwatch.Restart();
for (int i = 0; i < LoopLength; i++)
{
netSerializer.Serialize(netDataWriter, samplePacket);
}
stopwatch.Stop();
Console.WriteLine("NetSerializer first run time: " + stopwatch.ElapsedMilliseconds + " ms");
//Test NetSerializer
netDataWriter.Reset();
stopwatch.Restart();
for (int i = 0; i < LoopLength; i++)
{
netSerializer.Serialize(netDataWriter, samplePacket);
}
stopwatch.Stop();
Console.WriteLine("NetSerializer second run time: " + stopwatch.ElapsedMilliseconds + " ms");
//Test RAW
netDataWriter.Reset();
stopwatch.Restart();
for (int i = 0; i < LoopLength; i++)
{
netDataWriter.Put(samplePacket.SomeFloat);
netDataWriter.Put(samplePacket.SomeString);
netDataWriter.PutArray(samplePacket.SomeIntArray);
netDataWriter.Put(samplePacket.SomeVector2.X);
netDataWriter.Put(samplePacket.SomeVector2.Y);
netDataWriter.Put(samplePacket.SomeVectors.Length);
for (int j = 0; j < samplePacket.SomeVectors.Length; j++)
{
netDataWriter.Put(samplePacket.SomeVectors[j].X);
netDataWriter.Put(samplePacket.SomeVectors[j].Y);
}
netDataWriter.Put(samplePacket.EmptyString);
netDataWriter.Put(samplePacket.TestObj.Value);
}
stopwatch.Stop();
Console.WriteLine("DataWriter (raw put method calls) time: " + stopwatch.ElapsedMilliseconds + " ms");
}
protected override IEnumerator ExecuteRoutine()
{
Log.Info("Start Sim Serialization Process...");
Dictionary <uint, byte[]> blobAssetsMap = new Dictionary <uint, byte[]>();
Dictionary <ComponentType, Type> compToManaged = new Dictionary <ComponentType, Type>();
Dictionary <ComponentType, DynamicComponentTypeHandle> compToHandle = new Dictionary <ComponentType, DynamicComponentTypeHandle>();
NativeArray <ArchetypeChunk> chunks = _simulationWorld.EntityManager.GetAllChunks(Allocator.TempJob);
foreach (var item in BlobAssetDataCollectors.Values)
{
item.BeginCollect(_simulationWorld);
}
// iterate over all chunks
for (int i = 0; i < chunks.Length; i++)
{
ArchetypeChunk chunk = chunks[i];
// iterate over all components in chunk
foreach (ComponentType c in chunk.Archetype.GetComponentTypes())
{
ComponentType componentType = c;
componentType.AccessModeType = ComponentType.AccessMode.ReadOnly;
// get managed type
if (!compToManaged.TryGetValue(componentType, out Type managedType))
{
managedType = componentType.GetManagedType();
compToManaged[componentType] = managedType;
}
// if collector exists for given component, invoke it
if (BlobAssetDataCollectors.TryGetValue(managedType, out IPtrObjectCollector collector))
{
// get componentTypeHandle (necessary for chunk data access)
if (!compToHandle.TryGetValue(componentType, out DynamicComponentTypeHandle typeHandle))
{
typeHandle = _simulationWorld.EntityManager.GetDynamicComponentTypeHandle(componentType);
compToHandle[componentType] = typeHandle;
}
// invoke!
collector.Collect(typeHandle, chunk, blobAssetsMap);
}
}
}
chunks.Dispose();
foreach (var item in BlobAssetDataCollectors.Values)
{
item.EndCollect();
}
SerializedWorld serializedWorld = new SerializedWorld();
{
serializedWorld.BlobAssets = new SerializedWorld.BlobAsset[blobAssetsMap.Count];
int i = 0;
foreach (var item in blobAssetsMap)
{
serializedWorld.BlobAssets[i] = new SerializedWorld.BlobAsset()
{
Id = item.Key,
Data = item.Value,
};
i++;
}
}
serializedWorld.WorldData = SerializeUtilityX.SerializeWorld(_simulationWorld.EntityManager, out object[] referencedObjects);
SerializationData = NetSerializer.Serialize(serializedWorld);
foreach (var obj in referencedObjects)
{
Log.Warning($"The ECS simulation references {obj}, which is a managed object. " +
$"This is not allowed for now due to serialization");
}
Log.Info("Sim Serialization Complete!");
TerminateWithSuccess();
yield break;
}
public byte[] Serialize(object toSerialize)
{
return(Serializer.Serialize(toSerialize));
}
