internal static void OnServerWorldSerialization(QNetMessage message, QNetMessageReader reader,
ref bool disallowRecycle)
{
// CLIENT: server qnet object send ends
// server ends sending of serialized objects
// now client can starts it's de-serialization but if client is also host, this operation is completely ignored
// because all object was serialized at server startup
if (QNetManager.IsServerActive)
{
// ignoring all operations and continuing by sending WORLD_SERIALIZED message
JEMLogger.Log("Ignoring QNetObject serialization. (Host)");
QNetManager.Client.Send(QNetLocalChannel.DEFAULT, QNetMessageMethod.ReliableOrdered,
QNetUnityLocalHeader.WORLD_SERIALIZED);
}
else
{
// run late client world serializer to load all serialized objects from memory
JEMLogger.Log("Client received all QNetObjects. Starting serialization.");
QNetGameInitializer.RunLateClientWorldSerializer(() =>
{
// send WORLD_SERIALIZED message
JEMLogger.Log("QNetObject serialized.");
QNetManager.Client.Send(QNetLocalChannel.DEFAULT, QNetMessageMethod.ReliableOrdered,
QNetUnityLocalHeader.WORLD_SERIALIZED);
});
}
}
internal static void OnPlayerCreate(QNetMessage message, QNetMessageReader reader, ref bool disallowRecycle)
{
JEMLogger.Log("QNet is receiving player create event.");
// de-serialized message
var serializedPlayer = reader.ReadMessage <QNetPlayerSerialized>();
// resolve qNetPlayer
var qNetPlayer = QNetPlayer.GetQNetPlayer(serializedPlayer.ConnectionIdentity);
if (qNetPlayer == null)
{
if (QNetManager.IsHostActive)
{
throw new InvalidOperationException(
$"Host is unable to GetQNetPlayer by identity {serializedPlayer.ConnectionIdentity}.");
}
qNetPlayer =
QNetPlayer.CreateQNetPlayer(serializedPlayer.ConnectionIdentity, serializedPlayer.NickName, 0);
}
if (QNetManager.Client.ConnectionIdentity == serializedPlayer.ConnectionIdentity)
{
// do something with local player
// we can't TagAsReady because WORLD_SERIALIZED message already do this
}
else
{
// tag player as ready
qNetPlayer.TagAsReady();
}
}
/// <summary>
/// Invokes network messages.
/// </summary>
/// <param name="index">Index of message.</param>
/// <param name="reader">Reader of message.</param>
public void InvokeNetworkMessage(byte index, QNetMessageReader reader)
{
if (!NetworkMessages.ContainsKey(index))
{
return; // throw new InvalidOperationException($"QNetEntity of type {GetType()} does not have registered network message of identity {index}.");
}
// trowing a exception disallowing to register behaviours that relay on QNetEntity
var isClient = reader.Connection.ConnectionIdentity != 0;
var isServer = reader.Connection.ConnectionIdentity == 0 || QNetManager.IsHostActive &&
reader.Connection.ConnectionIdentity == QNetManager.Client.ConnectionIdentity;
if (!QNetManager.IsServerActive && QNetManager.IsClientActive)
{
isClient = false;
isServer = true;
}
var isOwner = reader.Connection.ConnectionIdentity == OwnerIdentity;
NetworkMessages[index].Invoke(new QNetEntityIncomingMessage
{
MessageIndex = index,
Reader = reader,
IsClient = isClient,
IsServer = isServer,
IsOwner = isOwner
});
}
internal static void OnClientLevelLoaded(QNetMessage message, QNetMessageReader reader, ref bool disallowRecycle)
{
// SERVER: player loads level
if (QNetManager.IsHostActive)
{
if (QNetManager.Client.ConnectionIdentity == reader.Connection.ConnectionIdentity)
{
// loaded level message has been send from host client, send only WORLD_SERIALIZATION message
QNetManager.Server.Send(reader.Connection, QNetLocalChannel.DEFAULT,
QNetMessageMethod.ReliableOrdered, QNetUnityLocalHeader.WORLD_SERIALIZATION);
return;
}
}
JEMLogger.Log($"Connection {reader.Connection} loads level. Sending world objects.");
// send WORLD_SERIALIZING message to prepare client
QNetManager.Server.Send(reader.Connection, QNetLocalChannel.DEFAULT, QNetMessageMethod.ReliableOrdered,
QNetUnityLocalHeader.WORLD_SERIALIZING);
// send all objects to client
QNetServerObjects.SendAllObjectsToConnection(reader.Connection);
// send WORLD_SERIALIZATION message to start object loading on client
QNetManager.Server.Send(reader.Connection, QNetLocalChannel.DEFAULT, QNetMessageMethod.ReliableOrdered,
QNetUnityLocalHeader.WORLD_SERIALIZATION);
}
internal static void OnServerObjectDelete(QNetMessage message, QNetMessageReader reader, ref bool disallowRecycle)
{
// read object identity to remove
var objectIdentity = reader.ReadInt16();
// and do it!
QNetWorldSerializer.RemoveSerializedObjectFromMemory(objectIdentity);
}
/// <inheritdoc />
public override void DeSerialize(QNetMessageReader reader)
{
ObjectIdentity = reader.ReadInt16();
PrefabIdentity = reader.ReadInt16();
OwnerIdentity = reader.ReadInt16();
Position = reader.ReadVector3();
Rotation = Quaternion.Euler(reader.ReadVector3());
Scale = reader.ReadVector3();
}
internal static void OnServerWorldSerializing(QNetMessage message, QNetMessageReader reader, ref bool disallowRecycle)
{
// CLIENT: server starts to send qnet objects
if (QNetManager.IsServerActive)
{
throw new InvalidOperationException(
"OnWorldSerializing message has been received while server(host) is active.");
}
// we can activate now some loading algorithms to view progress
}
public static void OnClientLevelLoadedOnFly(QNetMessage message, QNetMessageReader reader, ref bool disallowRecycle)
{
var player = QNetPlayer.GetQNetPlayer(reader.Connection);
if (player == null)
{
throw new NullReferenceException("player");
}
if (player.Loaded)
{
return;
}
}
internal static void OnPlayerDelete(QNetMessage message, QNetMessageReader reader, ref bool disallowRecycle)
{
JEMLogger.Log("QNet is receiving player delete event.");
var connectionIdentity = reader.ReadInt16();
var player = QNetPlayer.GetQNetPlayer(connectionIdentity);
if (player == null)
{
throw new InvalidOperationException("InvalidConnectionIdentityError");
}
player.TagAsNotReady();
QNetPlayer.DestroyQNetPlayer(player);
}
internal static void OnServerObjectCreate(QNetMessage message, QNetMessageReader reader, ref bool disallowRecycle)
{
// write new object in to serializer
var obj = reader.ReadMessage <QNetObjectSerialized>();
//JEMLogger.Log($"Local QNet received object create message. PrefabIdentity -> {obj.PrefabIdentity}, ObjectIdentity -> {obj.ObjectIdentity}, OwnerIdentity -> {obj.OwnerIdentity} at position -> {obj.Position}");
QNetWorldSerializer.WriteSerializedObjectToMemory(new QNetWorldSerializerObject
{
Object = obj,
SerializedServerState = reader
});
// disallow to recycle this message
disallowRecycle = true;
}
internal static void OnClientWorldSerialized(QNetMessage message, QNetMessageReader reader, ref bool disallowRecycle)
{
// SERVER: player loads all sent qnet objects
// prepare this client's controller and send final message so the player can play
// we will tag this connection as ready, so the system should send this player to all connections on server including owner
// if owner receive it's player instance from server, they will initialize local systems including camera and movement controller
var player = QNetPlayer.GetQNetPlayer(reader.Connection);
if (player == null)
{
JEMLogger.LogError("QNet encounter an unexcepted error. Connection QNetPlayer not exists.");
QNetManager.Server.CloseConnection(reader.Connection, "QNetUnexceptedError");
}
else
{
player.TagAsReady();
}
}
internal static void OnServerObjectState(QNetMessage message, QNetMessageReader reader, ref bool disallowRecycle)
{
if (!QNetWorldSerializer.WorldIsSerialized)
{
return; // system can't receive query data while initializing,
}
var objectIdentity = reader.ReadInt16();
var qNetObject = QNetObjectBehaviour.GetObject(objectIdentity);
if (qNetObject == null)
{
if (QNetManager.PrintNetworkWarnings)
{
JEMLogger.LogWarning($"Local machine received QNetEntity state update message but object of identity {objectIdentity} not exists in local world.");
}
return;
}
qNetObject.DeSerializeServerState(reader);
}
/// <summary>
/// Reads fixed vector3.
/// </summary>
public static Vector3 ReadFixedVector3(this QNetMessageReader reader, Vector3 previousVector3)
{
var flag = (NetworkVectorAxis)reader.ReadByte();
var x = previousVector3.x;
var y = previousVector3.y;
var z = previousVector3.z;
if (flag.HasFlag(NetworkVectorAxis.X))
{
x = reader.ReadSingle();
}
if (flag.HasFlag(NetworkVectorAxis.Y))
{
y = reader.ReadSingle();
}
if (flag.HasFlag(NetworkVectorAxis.Z))
{
z = reader.ReadSingle();
}
return(new Vector3(x, y, z));
}
internal static void OnServerLevelLoading(QNetMessage message, QNetMessageReader reader, ref bool disallowRecycle)
{
// write new object in to serializer
if (QNetManager.IsServerActive)
{
JEMLogger.Log(
$"We are on server. Client initialization from {nameof(OnServerLevelLoading)} will be ignored.");
// send level loaded message instantly
QNetManager.Client.Send(QNetLocalChannel.DEFAULT, QNetMessageMethod.ReliableOrdered,
QNetUnityLocalHeader.LEVEL_LOADED);
}
else
{
QNetGameInitializer.RunClient(new QNetGameInitializerData {
LevelName = reader.ReadString()
},
() =>
{
QNetManager.Client.Send(QNetLocalChannel.DEFAULT, QNetMessageMethod.ReliableOrdered,
QNetUnityLocalHeader.LEVEL_LOADED);
});
}
}
public static void OnLevelLoadingOnFly(QNetMessage message, QNetMessageReader reader, ref bool disallowRecycle)
{
/*
* // write new object in to serializer
* if (QNetManager.IsServerActive)
* {
* JEMLogger.Log(
* $"We are on server. Client initialization from {nameof(OnServerLevelLoading)} will be ignored.");
* // send level loaded message instantly
* QNetManager.Client.Send(QNetLocalChannel.DEFAULT, QNetMessageMethod.ReliableOrdered,
* QNetUnityLocalHeader.LEVEL_LOADED_ON_FLY);
* }
* else
* {
* var levelName = reader.ReadString();
* QNetGameInitializer.LoadLevelOnFly(levelName, () =>
* {
* QNetManager.Client.Send(QNetLocalChannel.DEFAULT, QNetMessageMethod.ReliableOrdered,
* QNetUnityLocalHeader.LEVEL_LOADED_ON_FLY);
* });
* }
*/
}
public static void OnClientEntityQuery(QNetMessage message, QNetMessageReader reader, ref bool disallowRecycle)
{
if (!QNetWorldSerializer.WorldIsSerialized)
{
return; // system can't receive entity query data while initializing,
}
var objectIdentity = reader.ReadInt16();
var qNetObject = QNetObjectBehaviour.GetObject(objectIdentity);
if (qNetObject == null)
{
if (QNetManager.PrintNetworkWarnings)
{
JEMLogger.LogWarning(
$"Local machine received QNetEntity query message but object of identity {objectIdentity} not exists in local world.");
}
return;
}
var entity = qNetObject.GetComponent <QNetEntity>();
if (entity == null)
{
throw new NullReferenceException(
$"QNetEntity query target exists but does not have {nameof(QNetEntity)} based script.");
}
if (message.IsClientMessage)
{
QNetSimulation.ReceivedServerFrame = reader.ReadUInt32();
QNetSimulation.AdjustServerFrames = QNetSimulation.ReceivedServerFrame > QNetTime.ServerFrame;
}
var index = reader.ReadByte();
entity.InvokeNetworkMessage(index, reader);
}
internal static void OnPlayerQuery(QNetMessage message, QNetMessageReader reader, ref bool disallowRecycle)
{
JEMLogger.Log("QNet is receiving player query event.");
}
/// <summary>
/// De-serialize object state send by server.
/// </summary>
public virtual void DeSerializeServerState(QNetMessageReader reader)
{
// de-serialize state send by server!
}
public static void OnServerLevelLoadingOnFlyRun(QNetMessage message, QNetMessageReader reader, ref bool disallowRecycle)
{
}
/// <summary>
/// Reads vector2.
/// </summary>
public static Vector2 ReadVector2(this QNetMessageReader reader)
{
return(new Vector3(reader.ReadSingle(), reader.ReadSingle()));
}
/// <inheritdoc />
public override void DeSerialize(QNetMessageReader reader)
{
ConnectionIdentity = reader.ReadInt16();
NickName = reader.ReadString();
}
