/// <summary>
/// The constructor.
/// </summary>
/// <param name="physicalMemoryLimitPercentage">The cache memory limit, as a percentage of the total system memory.</param>
/// <param name="performanceDataManager">The performance data manager.</param>
public MemCache(int physicalMemoryLimitPercentage, PerformanceDataManager performanceDataManager)
{
// Sanitize
if (physicalMemoryLimitPercentage <= 0)
{
throw new ArgumentException("cannot be <= 0", "physicalMemoryLimitPercentage");
}
if (performanceDataManager == null)
{
throw new ArgumentNullException("performanceDataManager");
}
var cacheMemoryLimitMegabytes = (int)(((double)physicalMemoryLimitPercentage / 100) * (new ComputerInfo().TotalPhysicalMemory / 1048576)); // bytes / (1024 * 1024) for MB;
_cacheName = "Dache";
_cacheConfig = new NameValueCollection();
_cacheConfig.Add("pollingInterval", "00:00:05");
_cacheConfig.Add("cacheMemoryLimitMegabytes", cacheMemoryLimitMegabytes.ToString());
_cacheConfig.Add("physicalMemoryLimitPercentage", physicalMemoryLimitPercentage.ToString());
_memoryCache = new TrimmingMemoryCache(_cacheName, _cacheConfig);
_internDictionary = new Dictionary <string, string>(100);
_internReferenceDictionary = new Dictionary <string, int>(100);
_performanceDataManager = performanceDataManager;
// Configure per second timer to fire every 1000 ms starting 1000ms from now
_perSecondTimer = new Timer(PerSecondOperations, null, 1000, 1000);
}
/// <summary>
/// AdvanceFrameHistory
/// Progresses the current frame to the next QueueHistoryFrame for the QueueHistoryFrame.QueueFrameType.
/// All other frames other than the current frame is considered the live rollback history
/// </summary>
/// <param name="queueType"></param>
public void AdvanceFrameHistory(RpcQueueHistoryFrame.QueueFrameType queueType)
{
int StreamBufferIndex = GetStreamBufferIndex(queueType);
if (!QueueHistory.ContainsKey(queueType))
{
UnityEngine.Debug.LogError($"You must initialize the {nameof(RpcQueueContainer)} before using MLAPI!");
return;
}
if (!QueueHistory[queueType].ContainsKey(StreamBufferIndex))
{
UnityEngine.Debug.LogError($"{nameof(RpcQueueContainer)} {queueType} queue stream buffer index out of range! [{StreamBufferIndex}]");
return;
}
foreach (KeyValuePair <NetworkUpdateStage, RpcQueueHistoryFrame> queueHistoryByUpdates in QueueHistory[queueType][StreamBufferIndex])
{
var rpcQueueHistoryItem = queueHistoryByUpdates.Value;
//This only gets reset when we advanced to next frame (do not reset this in the ResetQueueHistoryFrame)
rpcQueueHistoryItem.HasLoopbackData = false;
if (rpcQueueHistoryItem.QueueItemOffsets.Count > 0)
{
if (queueType == RpcQueueHistoryFrame.QueueFrameType.Inbound)
{
ProfilerStatManager.RpcInQueueSize.Record((int)rpcQueueHistoryItem.TotalSize);
PerformanceDataManager.Increment(ProfilerConstants.RpcInQueueSize, (int)rpcQueueHistoryItem.TotalSize);
}
else
{
ProfilerStatManager.RpcOutQueueSize.Record((int)rpcQueueHistoryItem.TotalSize);
PerformanceDataManager.Increment(ProfilerConstants.RpcOutQueueSize, (int)rpcQueueHistoryItem.TotalSize);
}
}
ResetQueueHistoryFrame(rpcQueueHistoryItem);
IncrementAndSetQueueHistoryFrame(rpcQueueHistoryItem);
}
//Roll to the next stream buffer
StreamBufferIndex++;
//If we have hit our maximum history, roll back over to the first one
if (StreamBufferIndex >= m_MaxFrameHistory)
{
StreamBufferIndex = 0;
}
if (queueType == RpcQueueHistoryFrame.QueueFrameType.Inbound)
{
m_InboundStreamBufferIndex = StreamBufferIndex;
}
else
{
m_OutBoundStreamBufferIndex = StreamBufferIndex;
}
}
internal static void Send(byte messageType, NetworkChannel networkChannel, ulong clientIdToIgnore, NetworkBuffer messageBuffer)
{
messageBuffer.PadBuffer();
using (var buffer = MessagePacker.WrapMessage(messageType, messageBuffer))
{
#if !UNITY_2020_2_OR_NEWER
NetworkProfiler.StartEvent(TickType.Send, (uint)buffer.Length, networkChannel, NetworkConstants.MESSAGE_NAMES[messageType]);
#endif
for (int i = 0; i < NetworkManager.Singleton.ConnectedClientsList.Count; i++)
{
if (NetworkManager.Singleton.ConnectedClientsList[i].ClientId == clientIdToIgnore ||
(NetworkManager.Singleton.IsServer && NetworkManager.Singleton.ConnectedClientsList[i].ClientId == NetworkManager.Singleton.ServerClientId))
{
continue;
}
NetworkManager.Singleton.NetworkConfig.NetworkTransport.Send(NetworkManager.Singleton.ConnectedClientsList[i].ClientId, new ArraySegment <byte>(buffer.GetBuffer(), 0, (int)buffer.Length), networkChannel);
ProfilerStatManager.BytesSent.Record((int)buffer.Length);
PerformanceDataManager.Increment(ProfilerConstants.ByteSent, (int)buffer.Length);
}
#if !UNITY_2020_2_OR_NEWER
NetworkProfiler.EndEvent();
#endif
}
}
/// <summary>
/// Sends a named message
/// </summary>
/// <param name="name">The message name to send</param>
/// <param name="clientId">The client to send the message to</param>
/// <param name="stream">The message stream containing the data</param>
/// <param name="networkChannel">The channel to send the data on</param>
public static void SendNamedMessage(string name, ulong clientId, Stream stream, NetworkChannel networkChannel = NetworkChannel.Internal)
{
ulong hash = 0;
switch (NetworkManager.Singleton.NetworkConfig.RpcHashSize)
{
case HashSize.VarIntTwoBytes:
hash = name.GetStableHash16();
break;
case HashSize.VarIntFourBytes:
hash = name.GetStableHash32();
break;
case HashSize.VarIntEightBytes:
hash = name.GetStableHash64();
break;
}
using (var messageBuffer = PooledNetworkBuffer.Get())
using (var writer = PooledNetworkWriter.Get(messageBuffer))
{
writer.WriteUInt64Packed(hash);
messageBuffer.CopyFrom(stream);
InternalMessageSender.Send(clientId, NetworkConstants.NAMED_MESSAGE, networkChannel, messageBuffer);
PerformanceDataManager.Increment(ProfilerConstants.NamedMessageSent);
}
}
internal void Send(byte messageType, NetworkChannel networkChannel, List <ulong> clientIds, NetworkBuffer messageBuffer)
{
if (clientIds == null)
{
Send(messageType, networkChannel, messageBuffer);
return;
}
messageBuffer.PadBuffer();
using (var buffer = MessagePacker.WrapMessage(messageType, messageBuffer))
{
#if !UNITY_2020_2_OR_NEWER
NetworkProfiler.StartEvent(TickType.Send, (uint)buffer.Length, networkChannel, NetworkConstants.MESSAGE_NAMES[messageType]);
#endif
for (int i = 0; i < clientIds.Count; i++)
{
if (m_NetworkManager.IsServer && clientIds[i] == m_NetworkManager.ServerClientId)
{
continue;
}
m_NetworkManager.NetworkConfig.NetworkTransport.Send(clientIds[i], new ArraySegment <byte>(buffer.GetBuffer(), 0, (int)buffer.Length), networkChannel);
ProfilerStatManager.BytesSent.Record((int)buffer.Length);
PerformanceDataManager.Increment(ProfilerConstants.ByteSent, (int)buffer.Length);
}
#if !UNITY_2020_2_OR_NEWER
NetworkProfiler.EndEvent();
#endif
}
}
public void HandleUnnamedMessage(ulong clientId, Stream stream)
{
PerformanceDataManager.Increment(ProfilerConstants.UnnamedMessageReceived);
ProfilerStatManager.UnnamedMessage.Record();
#if DEVELOPMENT_BUILD || UNITY_EDITOR
s_HandleUnnamedMessage.Begin();
#endif
NetworkManager.CustomMessagingManager.InvokeUnnamedMessage(clientId, stream);
#if DEVELOPMENT_BUILD || UNITY_EDITOR
s_HandleUnnamedMessage.End();
#endif
}
internal static void HandleUnnamedMessage(ulong clientId, Stream stream)
{
PerformanceDataManager.Increment(ProfilerConstants.NumberOfUnnamedMessages);
ProfilerStatManager.UnnamedMessage.Record();
#if DEVELOPMENT_BUILD || UNITY_EDITOR
s_HandleUnnamedMessage.Begin();
#endif
CustomMessagingManager.InvokeUnnamedMessage(clientId, stream);
#if DEVELOPMENT_BUILD || UNITY_EDITOR
s_HandleUnnamedMessage.End();
#endif
}
/// <summary>
/// Generic Sending Method for Internal Messages ADD_OBJECT and DESTROY_OBJECT
/// </summary>
internal void InternalMessagesSendAndFlush(bool isListening)
{
foreach (RpcFrameQueueItem queueItem in m_InternalMLAPISendQueue)
{
var poolStream = queueItem.NetworkBuffer;
switch (queueItem.QueueItemType)
{
case RpcQueueContainer.QueueItemType.CreateObject:
{
if (isListening)
{
foreach (ulong clientId in queueItem.ClientNetworkIds)
{
m_NetworkManager.MessageSender.Send(clientId, NetworkConstants.ADD_OBJECT, queueItem.NetworkChannel, poolStream);
}
PerformanceDataManager.Increment(ProfilerConstants.RpcSent, queueItem.ClientNetworkIds.Length);
ProfilerStatManager.RpcsSent.Record(queueItem.ClientNetworkIds.Length);
break;
}
PerformanceDataManager.Increment(ProfilerConstants.RpcSent, queueItem.ClientNetworkIds.Length);
ProfilerStatManager.RpcsSent.Record(queueItem.ClientNetworkIds.Length);
break;
}
case RpcQueueContainer.QueueItemType.DestroyObject:
{
if (isListening)
{
foreach (ulong clientId in queueItem.ClientNetworkIds)
{
m_NetworkManager.MessageSender.Send(clientId, NetworkConstants.DESTROY_OBJECT, queueItem.NetworkChannel, poolStream);
}
PerformanceDataManager.Increment(ProfilerConstants.RpcSent, queueItem.ClientNetworkIds.Length);
ProfilerStatManager.RpcsSent.Record(queueItem.ClientNetworkIds.Length);
break;
}
PerformanceDataManager.Increment(ProfilerConstants.RpcSent, queueItem.ClientNetworkIds.Length);
ProfilerStatManager.RpcsSent.Record(queueItem.ClientNetworkIds.Length);
break;
}
}
poolStream.Dispose();
}
m_InternalMLAPISendQueue.Clear();
}
/// <summary>
/// Sends unnamed message to a list of clients
/// </summary>
/// <param name="clientIds">The clients to send to, sends to everyone if null</param>
/// <param name="buffer">The message stream containing the data</param>
/// <param name="networkChannel">The channel to send the data on</param>
public static void SendUnnamedMessage(List <ulong> clientIds, NetworkBuffer buffer, NetworkChannel networkChannel = NetworkChannel.Internal)
{
if (!NetworkManager.Singleton.IsServer)
{
if (NetworkLog.CurrentLogLevel <= LogLevel.Error)
{
NetworkLog.LogWarning("Can not send unnamed messages to multiple users as a client");
}
return;
}
InternalMessageSender.Send(NetworkConstants.UNNAMED_MESSAGE, networkChannel, clientIds, buffer);
PerformanceDataManager.Increment(ProfilerConstants.UnnamedMessageSent);
}
/// <summary>
/// The constructor.
/// </summary>
/// <param name="configuration">The configuration to use for the cache host.</param>
public CacheHostEngine(CacheHostConfigurationSection configuration)
{
// Sanitize
if (configuration == null)
{
throw new ArgumentNullException("configuration");
}
// Set default logger to file if necessary
if (CustomLoggerLoader.DefaultLogger == null)
{
CustomLoggerLoader.DefaultLogger = new FileLogger();
}
var port = configuration.Port;
var physicalMemoryLimitPercentage = configuration.CacheMemoryLimitPercentage;
var maximumConnections = configuration.MaximumConnections;
// Configure the performance counter data manager
PerformanceDataManager performanceDataManager = null;
try
{
performanceDataManager = new PerformanceCounterPerformanceDataManager(port);
}
catch (InvalidOperationException)
{
// Performance counters aren't installed, so don't use them
performanceDataManager = new PerformanceDataManager();
}
// Determine the MemCache to use
IMemCache memCache = new MemCache(physicalMemoryLimitPercentage, performanceDataManager);
if (configuration.CompressData)
{
memCache = new GZipMemCache(memCache);
}
// Initialize the tag routing table
var tagRoutingTable = new TagRoutingTable();
// Initialize the cache host server
var cacheHostServer = new CacheHostServer(memCache, tagRoutingTable, CustomLoggerLoader.LoadLogger(), configuration.Port,
configuration.MaximumConnections, configuration.MessageBufferSize, configuration.CommunicationTimeoutSeconds * 1000, configuration.MaximumMessageSizeKB * 1024);
// Instantiate the cache host runner
_cacheHostRunner = new CacheHostRunner(cacheHostServer);
}
/// <summary>
/// ProcessReceiveQueue
/// Public facing interface method to start processing all RPCs in the current inbound frame
/// </summary>
public void ProcessReceiveQueue(NetworkUpdateStage currentStage)
{
bool advanceFrameHistory = false;
var rpcQueueContainer = NetworkManager.Singleton.RpcQueueContainer;
if (rpcQueueContainer != null)
{
#if DEVELOPMENT_BUILD || UNITY_EDITOR
s_ProcessReceiveQueue.Begin();
#endif
var currentFrame = rpcQueueContainer.GetQueueHistoryFrame(RpcQueueHistoryFrame.QueueFrameType.Inbound, currentStage);
var nextFrame = rpcQueueContainer.GetQueueHistoryFrame(RpcQueueHistoryFrame.QueueFrameType.Inbound, currentStage, true);
if (nextFrame.IsDirty && nextFrame.HasLoopbackData)
{
advanceFrameHistory = true;
}
if (currentFrame != null && currentFrame.IsDirty)
{
var currentQueueItem = currentFrame.GetFirstQueueItem();
while (currentQueueItem.QueueItemType != RpcQueueContainer.QueueItemType.None)
{
advanceFrameHistory = true;
if (rpcQueueContainer.IsTesting())
{
Debug.Log($"RPC invoked during the {currentStage} update stage.");
}
NetworkManager.InvokeRpc(currentQueueItem);
ProfilerStatManager.RpcsQueueProc.Record();
PerformanceDataManager.Increment(ProfilerConstants.NumberOfRPCQueueProcessed);
currentQueueItem = currentFrame.GetNextQueueItem();
}
//We call this to dispose of the shared stream writer and stream
currentFrame.CloseQueue();
}
if (advanceFrameHistory)
{
rpcQueueContainer.AdvanceFrameHistory(RpcQueueHistoryFrame.QueueFrameType.Inbound);
}
#if DEVELOPMENT_BUILD || UNITY_EDITOR
s_ProcessReceiveQueue.End();
#endif
}
}
/// <summary>
/// ProcessReceiveQueue
/// Public facing interface method to start processing all RPCs in the current inbound frame
/// </summary>
public void ProcessReceiveQueue(NetworkUpdateStage currentStage, bool isTesting)
{
bool advanceFrameHistory = false;
if (!ReferenceEquals(m_RpcQueueContainer, null))
{
#if DEVELOPMENT_BUILD || UNITY_EDITOR
s_ProcessReceiveQueue.Begin();
#endif
var currentFrame = m_RpcQueueContainer.GetQueueHistoryFrame(RpcQueueHistoryFrame.QueueFrameType.Inbound, currentStage);
var nextFrame = m_RpcQueueContainer.GetQueueHistoryFrame(RpcQueueHistoryFrame.QueueFrameType.Inbound, currentStage, true);
if (nextFrame.IsDirty && nextFrame.HasLoopbackData)
{
advanceFrameHistory = true;
}
if (currentFrame != null && currentFrame.IsDirty)
{
var currentQueueItem = currentFrame.GetFirstQueueItem();
while (currentQueueItem.QueueItemType != RpcQueueContainer.QueueItemType.None)
{
advanceFrameHistory = true;
if (!isTesting)
{
m_NetworkManager.InvokeRpc(currentQueueItem);
}
ProfilerStatManager.RpcsQueueProc.Record();
PerformanceDataManager.Increment(ProfilerConstants.RpcQueueProcessed);
currentQueueItem = currentFrame.GetNextQueueItem();
}
//We call this to dispose of the shared stream writer and stream
currentFrame.CloseQueue();
}
if (advanceFrameHistory)
{
m_RpcQueueContainer.AdvanceFrameHistory(RpcQueueHistoryFrame.QueueFrameType.Inbound);
}
#if DEVELOPMENT_BUILD || UNITY_EDITOR
s_ProcessReceiveQueue.End();
#endif
}
}
internal static void HandleNamedMessage(ulong clientId, Stream stream)
{
PerformanceDataManager.Increment(ProfilerConstants.NumberOfNamedMessages);
ProfilerStatManager.NamedMessage.Record();
#if DEVELOPMENT_BUILD || UNITY_EDITOR
s_HandleNamedMessage.Begin();
#endif
using (var reader = PooledNetworkReader.Get(stream))
{
ulong hash = reader.ReadUInt64Packed();
CustomMessagingManager.InvokeNamedMessage(hash, clientId, stream);
}
#if DEVELOPMENT_BUILD || UNITY_EDITOR
s_HandleNamedMessage.End();
#endif
}
/// <summary>
/// Converts the stream to a PerformanceQueueItem and adds it to the receive queue
/// </summary>
/// <param name="clientId"></param>
/// <param name="stream"></param>
/// <param name="receiveTime"></param>
internal static void RpcReceiveQueueItem(ulong clientId, Stream stream, float receiveTime, RpcQueueContainer.QueueItemType queueItemType)
{
if (NetworkManager.Singleton.IsServer && clientId == NetworkManager.Singleton.ServerClientId)
{
return;
}
ProfilerStatManager.RpcsRcvd.Record();
PerformanceDataManager.Increment(ProfilerConstants.NumberOfRPCsReceived);
#if DEVELOPMENT_BUILD || UNITY_EDITOR
switch (queueItemType)
{
case RpcQueueContainer.QueueItemType.ServerRpc:
s_RpcReceiveQueueItemServerRpc.Begin();
break;
case RpcQueueContainer.QueueItemType.ClientRpc:
s_RpcReceiveQueueItemClientRpc.Begin();
break;
}
#endif
var rpcQueueContainer = NetworkManager.Singleton.RpcQueueContainer;
rpcQueueContainer.AddQueueItemToInboundFrame(queueItemType, receiveTime, clientId, (NetworkBuffer)stream);
#if DEVELOPMENT_BUILD || UNITY_EDITOR
switch (queueItemType)
{
case RpcQueueContainer.QueueItemType.ServerRpc:
s_RpcReceiveQueueItemServerRpc.End();
break;
case RpcQueueContainer.QueueItemType.ClientRpc:
s_RpcReceiveQueueItemClientRpc.End();
break;
}
#endif
}
internal static void Send(ulong clientId, byte messageType, NetworkChannel networkChannel, NetworkBuffer messageBuffer)
{
messageBuffer.PadBuffer();
if (NetworkManager.Singleton.IsServer && clientId == NetworkManager.Singleton.ServerClientId)
{
return;
}
using (var buffer = MessagePacker.WrapMessage(messageType, messageBuffer))
{
NetworkProfiler.StartEvent(TickType.Send, (uint)buffer.Length, networkChannel, NetworkConstants.MESSAGE_NAMES[messageType]);
NetworkManager.Singleton.NetworkConfig.NetworkTransport.Send(clientId, new ArraySegment <byte>(buffer.GetBuffer(), 0, (int)buffer.Length), networkChannel);
ProfilerStatManager.BytesSent.Record((int)buffer.Length);
PerformanceDataManager.Increment(ProfilerConstants.ByteSent, (int)buffer.Length);
#if !UNITY_2020_2_OR_NEWER
NetworkProfiler.EndEvent();
#endif
}
}
/// <summary>
/// Sends the named message
/// </summary>
/// <param name="name">The message name to send</param>
/// <param name="clientIds">The clients to send to, sends to everyone if null</param>
/// <param name="stream">The message stream containing the data</param>
/// <param name="networkChannel">The channel to send the data on</param>
public static void SendNamedMessage(string name, List <ulong> clientIds, Stream stream, NetworkChannel networkChannel = NetworkChannel.Internal)
{
ulong hash = 0;
switch (NetworkManager.Singleton.NetworkConfig.RpcHashSize)
{
case HashSize.VarIntTwoBytes:
hash = name.GetStableHash16();
break;
case HashSize.VarIntFourBytes:
hash = name.GetStableHash32();
break;
case HashSize.VarIntEightBytes:
hash = name.GetStableHash64();
break;
}
using (var messageBuffer = PooledNetworkBuffer.Get())
using (var writer = PooledNetworkWriter.Get(messageBuffer))
{
writer.WriteUInt64Packed(hash);
messageBuffer.CopyFrom(stream);
if (!NetworkManager.Singleton.IsServer)
{
if (NetworkLog.CurrentLogLevel <= LogLevel.Error)
{
NetworkLog.LogWarning("Can not send named messages to multiple users as a client");
}
return;
}
InternalMessageSender.Send(NetworkConstants.NAMED_MESSAGE, networkChannel, clientIds, messageBuffer);
PerformanceDataManager.Increment(ProfilerConstants.NamedMessageSent);
}
}
/// <summary>
/// SendFrameQueueItem
/// Sends the RPC Queue Item to the specified destination
/// </summary>
/// <param name="queueItem">Information on what to send</param>
private void SendFrameQueueItem(RpcFrameQueueItem queueItem)
{
switch (queueItem.QueueItemType)
{
case RpcQueueContainer.QueueItemType.ServerRpc:
{
m_RpcQueueContainer.NetworkManager.NetworkConfig.NetworkTransport.Send(queueItem.NetworkId, queueItem.MessageData, queueItem.NetworkChannel);
//For each packet sent, we want to record how much data we have sent
PerformanceDataManager.Increment(ProfilerConstants.ByteSent, (int)queueItem.StreamSize);
PerformanceDataManager.Increment(ProfilerConstants.RpcSent);
ProfilerStatManager.BytesSent.Record((int)queueItem.StreamSize);
ProfilerStatManager.RpcsSent.Record();
break;
}
case RpcQueueContainer.QueueItemType.ClientRpc:
{
foreach (ulong clientid in queueItem.ClientNetworkIds)
{
m_RpcQueueContainer.NetworkManager.NetworkConfig.NetworkTransport.Send(clientid, queueItem.MessageData, queueItem.NetworkChannel);
//For each packet sent, we want to record how much data we have sent
PerformanceDataManager.Increment(ProfilerConstants.ByteSent, (int)queueItem.StreamSize);
ProfilerStatManager.BytesSent.Record((int)queueItem.StreamSize);
}
//For each client we send to, we want to record how many RPCs we have sent
PerformanceDataManager.Increment(ProfilerConstants.RpcSent, queueItem.ClientNetworkIds.Length);
ProfilerStatManager.RpcsSent.Record(queueItem.ClientNetworkIds.Length);
break;
}
}
}
internal static void HandleNetworkVariableUpdate(List <INetworkVariable> networkVariableList, Stream stream, ulong clientId, NetworkBehaviour logInstance, NetworkManager networkManager)
{
using (var reader = PooledNetworkReader.Get(stream))
{
for (int i = 0; i < networkVariableList.Count; i++)
{
ushort varSize = 0;
if (networkManager.NetworkConfig.EnsureNetworkVariableLengthSafety)
{
varSize = reader.ReadUInt16Packed();
if (varSize == 0)
{
continue;
}
}
else
{
if (!reader.ReadBool())
{
continue;
}
}
if (networkManager.IsServer && !networkVariableList[i].CanClientWrite(clientId))
{
if (networkManager.NetworkConfig.EnsureNetworkVariableLengthSafety)
{
if (NetworkLog.CurrentLogLevel <= LogLevel.Normal)
{
NetworkLog.LogWarning($"Client wrote to {nameof(NetworkVariable)} without permission. => {(logInstance != null ? ($"{nameof(NetworkObjectId)}: {logInstance.NetworkObjectId} - {nameof(NetworkObject.GetNetworkBehaviourOrderIndex)}(): {logInstance.NetworkObject.GetNetworkBehaviourOrderIndex(logInstance)} - VariableIndex: {i}") : string.Empty)}");
}
stream.Position += varSize;
continue;
}
//This client wrote somewhere they are not allowed. This is critical
//We can't just skip this field. Because we don't actually know how to dummy read
//That is, we don't know how many bytes to skip. Because the interface doesn't have a
//Read that gives us the value. Only a Read that applies the value straight away
//A dummy read COULD be added to the interface for this situation, but it's just being too nice.
//This is after all a developer fault. A critical error should be fine.
// - TwoTen
if (NetworkLog.CurrentLogLevel <= LogLevel.Error)
{
NetworkLog.LogError($"Client wrote to {nameof(NetworkVariable)} without permission. No more variables can be read. This is critical. => {(logInstance != null ? ($"{nameof(NetworkObjectId)}: {logInstance.NetworkObjectId} - {nameof(NetworkObject.GetNetworkBehaviourOrderIndex)}(): {logInstance.NetworkObject.GetNetworkBehaviourOrderIndex(logInstance)} - VariableIndex: {i}") : string.Empty)}");
}
return;
}
long readStartPos = stream.Position;
networkVariableList[i].ReadField(stream, NetworkTickSystem.NoTick, NetworkTickSystem.NoTick);
PerformanceDataManager.Increment(ProfilerConstants.NetworkVarUpdates);
ProfilerStatManager.NetworkVarsRcvd.Record();
if (networkManager.NetworkConfig.EnsureNetworkVariableLengthSafety)
{
if (stream is NetworkBuffer networkBuffer)
{
networkBuffer.SkipPadBits();
}
if (stream.Position > (readStartPos + varSize))
{
if (NetworkLog.CurrentLogLevel <= LogLevel.Normal)
{
NetworkLog.LogWarning($"Var update read too far. {stream.Position - (readStartPos + varSize)} bytes. => {(logInstance != null ? ($"{nameof(NetworkObjectId)}: {logInstance.NetworkObjectId} - {nameof(NetworkObject.GetNetworkBehaviourOrderIndex)}(): {logInstance.NetworkObject.GetNetworkBehaviourOrderIndex(logInstance)} - VariableIndex: {i}") : string.Empty)}");
}
stream.Position = readStartPos + varSize;
}
else if (stream.Position < (readStartPos + varSize))
{
if (NetworkLog.CurrentLogLevel <= LogLevel.Normal)
{
NetworkLog.LogWarning($"Var update read too little. {(readStartPos + varSize) - stream.Position} bytes. => {(logInstance != null ? ($"{nameof(NetworkObjectId)}: {logInstance.NetworkObjectId} - {nameof(NetworkObject.GetNetworkBehaviourOrderIndex)}(): {logInstance.NetworkObject.GetNetworkBehaviourOrderIndex(logInstance)} - VariableIndex: {i}") : string.Empty)}");
}
stream.Position = readStartPos + varSize;
}
}
}
}
}
// Start is called before the first frame update
void Start()
{
gameManager = FindObjectOfType <GameManager>();
if (!multiBlockCreator)
{
multiBlockCreator = FindObjectOfType <MultiBlockCreator>();
}
if (!playerAgent)
{
playerAgent = FindObjectOfType <PlayerAgent>();
}
// the code will check whether or not to execute
// based on the block.name assigned in the Inspector Window
// in the RandomBlockCreator empty child object
if (!randomBlockCreator)
{
randomBlockCreator = FindObjectOfType <RandomBlockCreator>();
}
if (!ball)
{
ball = FindObjectOfType <Ball>();
}
ballOffset = ball.transform.localPosition;
// Performance tracking - has to come before countblocks
if (!isMultiTraining)
{
dataManager = FindObjectOfType <PerformanceDataManager>();
}
if (!paddle)
{
paddle = FindObjectOfType <Paddle>();
}
paddleOffset = paddle.transform.localPosition;
if (!trainingBlocksGroup && gameManager.trainingMode)
{
trainingBlocksGroup = GetTrainingBlocksGroupInstance();
}
// Check if scene is ready for training
if (gameManager.trainingMode)
{
ResetEnvironmentState();
}
else
{
if (useRandomBlocks && randomBlockCreator)
{
randomBlockCreator.setupBlocks();
}
SetBlockSupervisor(randomBlockCreator.transform);
CountBlocks();
}
// Calculate diagonal width
instanceDiagonalSize = Mathf.Sqrt(Mathf.Pow(instanceHeight, 2) + Mathf.Pow(instanceWidth, 2));
// Set the playerData's type, name, and points.
InitializePlayerData();
gameData.PlayerList.Add(playerData);
}
/// <summary>
/// Sends a unnamed message to a specific client
/// </summary>
/// <param name="clientId">The client to send the message to</param>
/// <param name="buffer">The message stream containing the data</param>
/// <param name="networkChannel">The channel tos end the data on</param>
public static void SendUnnamedMessage(ulong clientId, NetworkBuffer buffer, NetworkChannel networkChannel = NetworkChannel.Internal)
{
InternalMessageSender.Send(clientId, NetworkConstants.UNNAMED_MESSAGE, networkChannel, buffer);
PerformanceDataManager.Increment(ProfilerConstants.UnnamedMessageSent);
}
public void Send(string testMessage)
{
PerformanceDataManager.Increment(ProfilerConstants.TransportTestData);
}
