public Tester(NS.Serializer serializer)
{
m_specimens.Add(new NetSerializerSpecimen(serializer));
if (Program.RunProtoBufTests)
m_specimens.Add(new ProtobufSpecimen());
}
protected override void Serialize(NetSerializer s)
{
s.Write(this.data.syncId);
s.Write(this.data.prefabType);
s.WriteExact(this.data.position);
s.Write(this.data.rotation);
}
public static void Write(this NetSerializer s, PrefabType prefabType)
{
var typeMode = PrefabManager.instance.prefabTypeMode;
switch (typeMode)
{
case PrefabTypeMode.Byte:
{
s.Write((byte)prefabType);
break;
}
case PrefabTypeMode.Short:
{
s.Write((short)prefabType);
break;
}
case PrefabTypeMode.Int:
{
s.Write((int)prefabType);
break;
}
default:
{
throw new System.NotImplementedException();
}
}
}
private static NetMessageDestroyValue CreateDestroyMessage(SyncedValueContainer container)
{
return(new NetMessageDestroyValue()
{
TypeId = NetSerializer.GetTypeId(container.DataType)
});
}
protected override void Serialize(NetSerializer s)
{
base.Serialize(s);
s.Write(this.isLeft);
s.Write(this.syncId);
s.Write(this.playerId);
}
public Server(Config config, MasterClient masterClient)
{
Logger.Log($"SERVER creating...");
_masterClient = masterClient;
_config = config;
_gameMode = (GameMode)_config.GameMode;
_world = new World(_config, _gameMode);
_world.OnGameEnd += World_OnGameEnd;
_world.OnPlayerDead += World_OnPlayerDead;
_server = new NetManager(this, 100 + _config.MaxPlayers, _config.ConnectionKey)
{
UpdateTime = _config.UpdateDelay / 3,
};
Logger.Log($"SERVER register packets");
_netSerializer = new NetSerializer();
Packet.Register(_netSerializer);
_netSerializer.SubscribeReusable <ClientConnection, NetPeer>(OnClientConnection);
_netSerializer.SubscribeReusable <ClientInput, NetPeer>(OnClientInput);
_netSerializer.SubscribeReusable <ClientSpawn, NetPeer>(OnClientSpawn);
_netSerializer.SubscribeReusable <ClientLeave, NetPeer>(OnClentLeave);
Logger.Log($"SERVER created");
}
public static object Deserialize_Class(BitStreamReader reader)
{
if (reader.ReadBit() == false)
{
return(null);
}
return(NetSerializer.Deserialize(reader));
}
public static int GetSerializedBitSize_Class(object obj)
{
if (obj == null)
{
return(1);
}
return(1 + NetSerializer.GetSerializedBitSize(obj));
}
public static void Register(NetSerializer netSerializer)
{
netSerializer.RegisterCustomType <ObstacleInfo>();
netSerializer.RegisterCustomType <PlayerInfo>();
netSerializer.RegisterCustomType <PlayerCameraInfo>();
netSerializer.RegisterCustomType <UnitInfo>();
netSerializer.RegisterCustomType <RuneInfo>();
}
/// <summary>
/// Creates a ClientHandler that will use the given socket
/// </summary>
public ClientHandler(Socket sock)
{
var stream = new NetworkStream(sock);
m_serlzr = new NetSerializer <Datagram>(new NetworkStream(sock), new object());
m_alive = true;
m_status = new State(Direction.Stop, -1);
m_orders = new List <Order>();
}
void Init()
{
serializer = new NetSerializer();
serializer.RegisterCustomType(SerializedLobbyPlayer.Serialize, SerializedLobbyPlayer.Deserialize);
serializer.SubscribeReusable <PClientHandshake, NetPeer>(OnReceiveHandshake);
isInit = true;
}
public ServerListener()
{
_netSerializer = new NetSerializer();
_netSerializer.RegisterCustomType(SomeVector2.Serialize, SomeVector2.Deserialize);
_netSerializer.RegisterCustomType <SampleNetSerializable>();
//user data support
_netSerializer.SubscribeReusable <SamplePacket, NetPeer>(OnSamplePacketReceived);
}
public void Run()
{
Console.WriteLine("=== Serializer benchmark ===");
//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 SomeVector2[20]
};
for (int i = 0; i < samplePacket.SomeVectors.Length; i++)
{
samplePacket.SomeVectors[i] = new SomeVector2(i, i);
}
var netSerializer = new NetSerializer();
netSerializer.RegisterNestedType <SampleNetSerializable>();
netSerializer.RegisterNestedType(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");
Console.WriteLine("BinaryFormatter size: " + memoryStream.Position / LoopLength);
DataWriterTest(netDataWriter, stopwatch, samplePacket);
NetSerializerTest(netSerializer, netDataWriter, stopwatch, samplePacket);
DataWriterTest(netDataWriter, stopwatch, samplePacket);
NetSerializerTest(netSerializer, netDataWriter, stopwatch, samplePacket);
DataWriterTest(netDataWriter, stopwatch, samplePacket);
NetSerializerTest(netSerializer, netDataWriter, stopwatch, samplePacket);
Console.ReadKey();
}
public static void Serialize_Class(object obj, BitStreamWriter writer)
{
if (obj == null)
{
writer.WriteBit(false);
return;
}
writer.WriteBit(true);
NetSerializer.Serialize(obj, writer);
}
void Init()
{
serializer = new NetSerializer();
serializer.RegisterCustomType(SerializedLobbyPlayer.Serialize, SerializedLobbyPlayer.Deserialize);
serializer.SubscribeReusable <PLobby, NetPeer>(OnReceiveLobby);
serializer.SubscribeReusable <PLobbyPlayer>(OnClientLobbyAction);
isInit = true;
}
protected override void Serialize(NetSerializer s)
{
base.Serialize(s);
s.Write(this.syncId);
s.Write(this.leftHand);
s.Write(this.position);
s.Write(this.rotation);
s.Write(this.velocity);
s.Write(this.angularVelocity);
}
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 static void PopulateItemDatabase()
{
uint dbId = 1;
Inventory.DbAddNewDefinition(new MeleeWeapon(dbId++, "Sword", 20, 20, 15, 1.5f, true));
Inventory.DbAddNewDefinition(new MeleeWeapon(dbId++, "Hammer", 30, 30, 12, 1.5f, true));
Inventory.DbAddNewDefinition(new Armor(dbId++, "Helmet", 30, 30, 5, "HeadMount", false));
Inventory.DbAddNewDefinition(new Armor(dbId, "Chestplate", 30, 30, 12, "ChestMount", false));
NetSerializer.Add <MeleeWeapon>(ItemSerializer, ItemDeserializer);
NetSerializer.Add <IInvItem>(ItemSerializer, ItemDeserializer);
}
// Use this for initialization
void Start()
{
NetSerializer serializer = new NetSerializer();
SimplePacket packet = new SimplePacket()
{
Login = "******",
Password = "******"
};
serializer.Serialize(packet);
}
private void OnNetMessageReceived(NetMessageDestroyValue destroyMessage, INetworkInterfaceConnection arg2)
{
if (NetSerializer.IsValidType(destroyMessage.TypeId))
{
Type type = NetSerializer.GetTypeFromId(destroyMessage.TypeId);
var container = SyncedValues.GetContainer(type);
if (container != null)
{
SyncedValues.DestroyContainer(container);
}
}
}
/// <summary>
/// Connects to the dispatcher and then enters the main loop.
/// While alive, checks incoming messages from dispatcher, and processes them asynchronously
/// </summary>
public void Run()
{
while (true)
{
try
{
m_client = new TcpClient();
m_client.Connect(m_dispatcherAddr);
Running = true;
m_serlzr = new NetSerializer <Datagram>(m_client.GetStream(), new object());
Console.WriteLine("Web client started");
Datagram[] tempData = new Datagram[m_unsent.Count];
m_unsent.CopyTo(tempData);
foreach (Datagram data in tempData)
{
SendData(data);
}
m_unsent.Clear();
Task.Run(() =>
{
Thread.Sleep(1000);
while (Running)
{
Datagram data = m_serlzr.ExtractFromStream();
ProcessData(data);
}
});
while (true)
{
m_serlzr.WriteToStream(Datagram.CreateDummy());
Thread.Sleep(1000);
}
}
catch
{
if (Running)
{
Running = false;
try { m_client.Close(); }
catch { }
ConnectionLost();
Console.WriteLine("Connection lost");
}
Thread.Sleep(1000);
}
}
}
protected override void Serialize(NetSerializer s)
{
s.WriteExact(this.position);
s.Write(this.headPosition);
s.Write(this.headRotation);
s.Write(this.leftHandPosition);
s.Write(this.leftHandRotation);
s.Write(this.rightHandPosition);
s.Write(this.rightHandRotation);
}
internal void DeserializeStream(NetStream stream)
{
while (NetSerializer.CanReadMessage(stream))
{
var message = NetSerializer.ReadNetMessage(stream);
if (message == null)
{
NetLog.Warning("Failed to parse unreliable message from: " + Connection.Endpoint);
break;
}
Connection.Socket.ReceiveMessage(message, Connection);
}
stream.Release();
}
void Start()
{
socket = GetComponent <NetSocket>();
viewManager = GetComponent <NetViewManager>();
zoneClient = GetComponent <NetZoneClient>();
zoneClient.OnZoneSetupSuccess += ZoneSetupSuccessful;
socket.Events.OnConnectedToServer += ConnectedToServer;
socket.Events.OnDisconnectedFromServer += DisconnectedFromServer;
viewManager.OnNetViewCreated += OnNetViewCreated;
socket.StartSocket();
socket.RegisterRpcListener(this);
NetSerializer.Add <Item>(Item.Serialize, Item.Deserialize);
NetSerializer.Add <Equip>(Item.Serialize, Item.Deserialize);
socket.Connect(serverIps[serverIpIndex] + ":" + serverPort);
}
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,
TestObj = new SampleNetSerializable {
Value = 5
}
};
_serializer = new NetSerializer();
_serializer.RegisterCustomType <SampleNetSerializable>();
_serializer.RegisterCustomType(SomeVector2.Serialize, SomeVector2.Deserialize);
}
internal void SerializeMessage(NetMessage message)
{
if (!NetSerializer.TryWriteMessage(unreliableStream, message))
{
if (retry)
{
NetLog.Warning("SerializeUnreliableMessage failed.");
retry = false;
return;
}
// Stream likely full, flush stream and retry serialization:
retry = true;
FlushStream();
SerializeMessage(message);
}
if (retry)
{
retry = false;
}
}
protected override void Serialize(NetSerializer s)
{
s.Write(this.initial);
var data = this.data;
var count = data.Count;
s.Write((byte)count);
for (int i = 0; i < count; i++)
{
var d = data[i];
s.Write(d.syncId);
s.Write(d.prefabType);
s.WriteExact(d.position);
s.Write(d.rotation);
s.Write(d.velocity);
s.Write(d.angularVelocity);
}
}
public static bool GetMessageFromData(byte[] messageData, out object message)
{
#if DEBUG
if (s_dataLogChannel.Active)
{
Log.Info(s_dataLogChannel, $"[{nameof(NetMessageInterpreter)}] Receive Message byte[{messageData.Length}]");
DebugLogUtility.LogByteArray(s_dataLogChannel, messageData);
}
#endif
try
{
message = NetSerializer.Deserialize(messageData);
return(true);
}
catch (Exception e)
{
message = null;
Log.Error($"[{nameof(NetMessageInterpreter)}] Failed to deserialize Message. {e.Message} - {e.StackTrace}");
return(false);
}
}
void Awake()
{
if (instance != null)
{
Destroy(gameObject);
}
instance = this;
DontDestroyOnLoad(gameObject);
Debug.Log("Starting Console Pro Server on port : " + port);
_dataWriter = new NetDataWriter();
_netServer = new NetManager(this, 100, "ConsolePro");
_netServer.Start(port);
_netServer.DiscoveryEnabled = true;
_netServer.UpdateTime = 15;
_netServer.MergeEnabled = true;
_netServer.NatPunchEnabled = useNATPunch;
_serializer = new NetSerializer();
}
void Start()
{
socket = GetComponent <NetSocket>();
zoneManager = GetComponent <NetZoneManager>();
zoneServer = GetComponent <NetZoneServer>();
netViewManager = GetComponent <NetViewManager>();
zoneServer.OnAssignment += AssignedToZone;
socket.ProtocolAuthority = true;
socket.AcceptConnections = true;
socket.MaxConnections = 512;
socket.Events.OnPeerApproval += PeerApproval;
socket.Events.OnSocketStart += SocketStart;
socket.Events.OnFailedToConnect += FailedToConnect;
socket.Events.OnClientDisconnected += OnClientDisconnect;
socket.StartSocket(ServerAddress + ":" + ServerPortRoot);
socket.RegisterRpcListener(this);
NetSerializer.Add <Item>(Item.Serialize, Item.Deserialize);
NetSerializer.Add <Equip>(Item.Serialize, Item.Deserialize);
}
/// <summary>
/// Initializes a new instance of the <see cref="NETSerializer"/> class.
/// </summary>
/// <param name="serializer">The serializer.</param>
public NETSerializer(NS.Serializer serializer) {
_serializer = serializer;
}
public NetTest(NS.Serializer serializer)
{
m_serializer = serializer;
}
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");
}
public MemStreamTest(NS.Serializer serializer)
{
m_serializer = serializer;
}
public Tester(NS.Serializer serializer)
{
m_serializer = serializer;
}
