internal static void OnFirstSceneSwitchSync(uint sceneIndex, Guid switchSceneGuid)
{
if (!sceneIndexToString.ContainsKey(sceneIndex) || !registeredSceneNames.Contains(sceneIndexToString[sceneIndex]))
{
if (LogHelper.CurrentLogLevel <= LogLevel.Normal)
{
LogHelper.LogWarning("Server requested a scene switch to a non registered scene");
}
return;
}
else if (SceneManager.GetActiveScene().name == sceneIndexToString[sceneIndex])
{
return; //This scene is already loaded. This usually happends at first load
}
lastScene = SceneManager.GetActiveScene();
string sceneName = sceneIndexToString[sceneIndex];
nextScene = SceneManager.GetSceneByName(sceneName);
CurrentActiveSceneIndex = sceneNameToIndex[sceneName];
SceneManager.LoadScene(sceneName);
using (PooledBitStream stream = PooledBitStream.Get())
{
using (PooledBitWriter writer = PooledBitWriter.Get(stream))
{
writer.WriteByteArray(switchSceneGuid.ToByteArray());
InternalMessageHandler.Send(NetworkingManager.Singleton.ServerClientId, MLAPIConstants.MLAPI_CLIENT_SWITCH_SCENE_COMPLETED, "MLAPI_INTERNAL", stream, SecuritySendFlags.None, null);
}
}
isSwitching = false;
}
/// <summary>
/// Switches to a scene with a given name. Can only be called from Server
/// </summary>
/// <param name="sceneName">The name of the scene to switch to</param>
public static SceneSwitchProgress SwitchScene(string sceneName)
{
if (!NetworkingManager.singleton.NetworkConfig.EnableSceneSwitching)
{
if (LogHelper.CurrentLogLevel <= LogLevel.Normal)
{
LogHelper.LogWarning("Scene switching is not enabled");
}
return(null);
}
else if (isSwitching)
{
if (LogHelper.CurrentLogLevel <= LogLevel.Normal)
{
LogHelper.LogWarning("Scene switch already in progress");
}
return(null);
}
else if (!registeredSceneNames.Contains(sceneName))
{
if (LogHelper.CurrentLogLevel <= LogLevel.Normal)
{
LogHelper.LogWarning("The scene " + sceneName + " is not registered as a switchable scene.");
}
return(null);
}
SpawnManager.DestroySceneObjects(); //Destroy current scene objects before switching.
currentSceneIndex = sceneNameToIndex[sceneName];
isSwitching = true;
lastScene = SceneManager.GetActiveScene();
SceneSwitchProgress switchSceneProgress = new SceneSwitchProgress();
sceneSwitchProgresses.Add(switchSceneProgress.guid, switchSceneProgress);
currentSceneSwitchProgressGuid = switchSceneProgress.guid;
AsyncOperation sceneLoad = SceneManager.LoadSceneAsync(sceneName, LoadSceneMode.Additive);
nextScene = SceneManager.GetSceneByName(sceneName);
sceneLoad.completed += (AsyncOperation AsyncOp) => { OnSceneLoaded(AsyncOp, switchSceneProgress.guid); };
switchSceneProgress.SetSceneLoadOperation(sceneLoad);
using (PooledBitStream stream = PooledBitStream.Get())
{
using (PooledBitWriter writer = PooledBitWriter.Get(stream))
{
writer.WriteUInt32Packed(sceneNameToIndex[sceneName]);
writer.WriteByteArray(switchSceneProgress.guid.ToByteArray());
InternalMessageHandler.Send(MLAPIConstants.MLAPI_SWITCH_SCENE, "MLAPI_INTERNAL", stream, SecuritySendFlags.None);
}
}
return(switchSceneProgress);
}
/// <summary>
/// Takes an object, serializes it to json, converts that to a byte array, compresses that byte array, and puts that in a stream\
///
/// Be sure to dispose of the stream
/// </summary>
/// <param name="_obj"></param>
/// <returns></returns>
public static PooledBitStream GetNetworkCompressedStream(this object _obj)
{
PooledBitStream stream = PooledBitStream.Get();
using (PooledBitWriter writer = PooledBitWriter.Get(stream))
{
writer.WriteByteArray(_obj.GetSerializedAndCompressed());
}
return(stream);
}
private static void OnSceneUnload(AsyncOperation operation, Guid switchSceneGuid)
{
if (NetworkingManager.singleton.isServer)
{
SpawnManager.MarkSceneObjects();
NetworkedObject[] networkedObjects = MonoBehaviour.FindObjectsOfType <NetworkedObject>();
for (int i = 0; i < networkedObjects.Length; i++)
{
if (!networkedObjects[i].isSpawned && networkedObjects[i].destroyWithScene == true)
{
networkedObjects[i].Spawn(null, true);
}
}
}
else
{
SpawnManager.SpawnPendingObjectsForScene(CurrentActiveSceneIndex);
NetworkedObject[] netObjects = MonoBehaviour.FindObjectsOfType <NetworkedObject>();
for (int i = 0; i < netObjects.Length; i++)
{
if (netObjects[i].destroyWithScene == null)
{
MonoBehaviour.Destroy(netObjects[i].gameObject);
}
}
}
//Tell server that scene load is completed
if (NetworkingManager.singleton.isHost)
{
OnClientSwitchSceneCompleted(NetworkingManager.singleton.LocalClientId, switchSceneGuid);
}
else if (NetworkingManager.singleton.isClient)
{
using (PooledBitStream stream = PooledBitStream.Get())
{
using (PooledBitWriter writer = PooledBitWriter.Get(stream))
{
writer.WriteByteArray(switchSceneGuid.ToByteArray());
InternalMessageHandler.Send(NetworkingManager.singleton.ServerClientId, MLAPIConstants.MLAPI_CLIENT_SWITCH_SCENE_COMPLETED, "MLAPI_INTERNAL", stream, SecuritySendFlags.None);
}
}
}
isSwitching = false;
}
// Runs on client
internal static void HandleHailRequest(uint clientId, Stream stream, int channelId)
{
X509Certificate2 certificate = null;
byte[] serverDiffieHellmanPublicPart = null;
using (PooledBitReader reader = PooledBitReader.Get(stream))
{
if (netManager.NetworkConfig.EnableEncryption)
{
// Read the certificate
if (netManager.NetworkConfig.SignKeyExchange)
{
// Allocation justification: This runs on client and only once, at initial connection
certificate = new X509Certificate2(reader.ReadByteArray());
if (CryptographyHelper.VerifyCertificate(certificate, netManager.ConnectedHostname))
{
// The certificate is not valid :(
// Man in the middle.
if (LogHelper.CurrentLogLevel <= LogLevel.Normal)
{
if (LogHelper.CurrentLogLevel <= LogLevel.Normal)
{
LogHelper.LogWarning("Invalid certificate. Disconnecting");
}
}
netManager.StopClient();
return;
}
else
{
netManager.NetworkConfig.ServerX509Certificate = certificate;
}
}
// Read the ECDH
// Allocation justification: This runs on client and only once, at initial connection
serverDiffieHellmanPublicPart = reader.ReadByteArray();
// Verify the key exchange
if (netManager.NetworkConfig.SignKeyExchange)
{
byte[] serverDiffieHellmanPublicPartSignature = reader.ReadByteArray();
RSACryptoServiceProvider rsa = certificate.PublicKey.Key as RSACryptoServiceProvider;
if (rsa != null)
{
using (SHA256Managed sha = new SHA256Managed())
{
if (!rsa.VerifyData(serverDiffieHellmanPublicPart, sha, serverDiffieHellmanPublicPartSignature))
{
if (LogHelper.CurrentLogLevel <= LogLevel.Normal)
{
if (LogHelper.CurrentLogLevel <= LogLevel.Normal)
{
LogHelper.LogWarning("Invalid signature. Disconnecting");
}
}
netManager.StopClient();
return;
}
}
}
}
}
}
using (PooledBitStream outStream = PooledBitStream.Get())
{
using (PooledBitWriter writer = PooledBitWriter.Get(outStream))
{
if (netManager.NetworkConfig.EnableEncryption)
{
// Create a ECDH key
EllipticDiffieHellman diffieHellman = new EllipticDiffieHellman(EllipticDiffieHellman.DEFAULT_CURVE, EllipticDiffieHellman.DEFAULT_GENERATOR, EllipticDiffieHellman.DEFAULT_ORDER);
netManager.clientAesKey = diffieHellman.GetSharedSecret(serverDiffieHellmanPublicPart);
byte[] diffieHellmanPublicKey = diffieHellman.GetPublicKey();
writer.WriteByteArray(diffieHellmanPublicKey);
if (netManager.NetworkConfig.SignKeyExchange)
{
RSACryptoServiceProvider rsa = certificate.PublicKey.Key as RSACryptoServiceProvider;
if (rsa != null)
{
using (SHA256CryptoServiceProvider sha = new SHA256CryptoServiceProvider())
{
writer.WriteByteArray(rsa.Encrypt(sha.ComputeHash(diffieHellmanPublicKey), false));
}
}
else
{
throw new CryptographicException("[MLAPI] Only RSA certificates are supported. No valid RSA key was found");
}
}
}
}
// Send HailResponse
InternalMessageHandler.Send(NetworkingManager.Singleton.ServerClientId, MLAPIConstants.MLAPI_CERTIFICATE_HAIL_RESPONSE, "MLAPI_INTERNAL", outStream, SecuritySendFlags.None, true);
}
}
private static void OnSceneUnloadClient(Guid switchSceneGuid, Stream objectStream)
{
if (NetworkingManager.Singleton.NetworkConfig.UsePrefabSync)
{
SpawnManager.DestroySceneObjects();
using (PooledBitReader reader = PooledBitReader.Get(objectStream))
{
uint newObjectsCount = reader.ReadUInt32Packed();
for (int i = 0; i < newObjectsCount; i++)
{
bool isPlayerObject = reader.ReadBool();
ulong networkId = reader.ReadUInt64Packed();
ulong owner = reader.ReadUInt64Packed();
ulong prefabHash = reader.ReadUInt64Packed();
bool destroyWithScene = reader.ReadBool();
Vector3 position = new Vector3(reader.ReadSinglePacked(), reader.ReadSinglePacked(), reader.ReadSinglePacked());
Quaternion rotation = Quaternion.Euler(reader.ReadSinglePacked(), reader.ReadSinglePacked(), reader.ReadSinglePacked());
NetworkedObject networkedObject = SpawnManager.CreateLocalNetworkedObject(false, 0, prefabHash, position, rotation);
SpawnManager.SpawnNetworkedObjectLocally(networkedObject, networkId, true, isPlayerObject, owner, objectStream, false, 0, true, destroyWithScene);
}
}
}
else
{
NetworkedObject[] networkedObjects = MonoBehaviour.FindObjectsOfType <NetworkedObject>();
SpawnManager.ClientCollectSoftSyncSceneObjectSweep(networkedObjects);
using (PooledBitReader reader = PooledBitReader.Get(objectStream))
{
uint newObjectsCount = reader.ReadUInt32Packed();
for (int i = 0; i < newObjectsCount; i++)
{
bool isPlayerObject = reader.ReadBool();
ulong networkId = reader.ReadUInt64Packed();
ulong owner = reader.ReadUInt64Packed();
ulong instanceId = reader.ReadUInt64Packed();
bool destroyWithScene = reader.ReadBool();
NetworkedObject networkedObject = SpawnManager.CreateLocalNetworkedObject(true, instanceId, 0, null, null);
SpawnManager.SpawnNetworkedObjectLocally(networkedObject, networkId, true, isPlayerObject, owner, objectStream, false, 0, true, destroyWithScene);
}
}
}
using (PooledBitStream stream = PooledBitStream.Get())
{
using (PooledBitWriter writer = PooledBitWriter.Get(stream))
{
writer.WriteByteArray(switchSceneGuid.ToByteArray());
InternalMessageHandler.Send(NetworkingManager.Singleton.ServerClientId, MLAPIConstants.MLAPI_CLIENT_SWITCH_SCENE_COMPLETED, "MLAPI_INTERNAL", stream, SecuritySendFlags.None, null);
}
}
isSwitching = false;
if (OnSceneSwitched != null)
{
OnSceneSwitched();
}
}
private static void OnSceneUnloadServer(Guid switchSceneGuid)
{
// Justification: Rare alloc, could(should?) reuse
List <NetworkedObject> newSceneObjects = new List <NetworkedObject>();
{
NetworkedObject[] networkedObjects = MonoBehaviour.FindObjectsOfType <NetworkedObject>();
for (int i = 0; i < networkedObjects.Length; i++)
{
if (networkedObjects[i].IsSceneObject == null)
{
SpawnManager.SpawnNetworkedObjectLocally(networkedObjects[i], SpawnManager.GetNetworkObjectId(), true, false, null, null, false, 0, false, true);
newSceneObjects.Add(networkedObjects[i]);
}
}
}
for (int j = 0; j < NetworkingManager.Singleton.ConnectedClientsList.Count; j++)
{
if (NetworkingManager.Singleton.ConnectedClientsList[j].ClientId != NetworkingManager.Singleton.ServerClientId)
{
using (PooledBitStream stream = PooledBitStream.Get())
{
using (PooledBitWriter writer = PooledBitWriter.Get(stream))
{
writer.WriteUInt32Packed(CurrentActiveSceneIndex);
writer.WriteByteArray(switchSceneGuid.ToByteArray());
uint sceneObjectsToSpawn = 0;
for (int i = 0; i < newSceneObjects.Count; i++)
{
if (newSceneObjects[i].observers.Contains(NetworkingManager.Singleton.ConnectedClientsList[j].ClientId))
{
sceneObjectsToSpawn++;
}
}
writer.WriteUInt32Packed(sceneObjectsToSpawn);
for (int i = 0; i < newSceneObjects.Count; i++)
{
if (newSceneObjects[i].observers.Contains(NetworkingManager.Singleton.ConnectedClientsList[j].ClientId))
{
if (NetworkingManager.Singleton.NetworkConfig.UsePrefabSync)
{
writer.WriteBool(newSceneObjects[i].IsPlayerObject);
writer.WriteUInt64Packed(newSceneObjects[i].NetworkId);
writer.WriteUInt64Packed(newSceneObjects[i].OwnerClientId);
writer.WriteUInt64Packed(newSceneObjects[i].PrefabHash);
writer.WriteBool(newSceneObjects[i].DestroyWithScene);
writer.WriteSinglePacked(newSceneObjects[i].transform.position.x);
writer.WriteSinglePacked(newSceneObjects[i].transform.position.y);
writer.WriteSinglePacked(newSceneObjects[i].transform.position.z);
writer.WriteSinglePacked(newSceneObjects[i].transform.rotation.eulerAngles.x);
writer.WriteSinglePacked(newSceneObjects[i].transform.rotation.eulerAngles.y);
writer.WriteSinglePacked(newSceneObjects[i].transform.rotation.eulerAngles.z);
if (NetworkingManager.Singleton.NetworkConfig.EnableNetworkedVar)
{
newSceneObjects[i].WriteNetworkedVarData(stream, NetworkingManager.Singleton.ConnectedClientsList[j].ClientId);
}
}
else
{
writer.WriteBool(newSceneObjects[i].IsPlayerObject);
writer.WriteUInt64Packed(newSceneObjects[i].NetworkId);
writer.WriteUInt64Packed(newSceneObjects[i].OwnerClientId);
writer.WriteUInt64Packed(newSceneObjects[i].NetworkedInstanceId);
writer.WriteBool(newSceneObjects[i].DestroyWithScene);
if (NetworkingManager.Singleton.NetworkConfig.EnableNetworkedVar)
{
newSceneObjects[i].WriteNetworkedVarData(stream, NetworkingManager.Singleton.ConnectedClientsList[j].ClientId);
}
}
}
}
}
InternalMessageHandler.Send(NetworkingManager.Singleton.ConnectedClientsList[j].ClientId, MLAPIConstants.MLAPI_SWITCH_SCENE, "MLAPI_INTERNAL", stream, SecuritySendFlags.None, null);
}
}
}
//Tell server that scene load is completed
if (NetworkingManager.Singleton.IsHost)
{
OnClientSwitchSceneCompleted(NetworkingManager.Singleton.LocalClientId, switchSceneGuid);
}
isSwitching = false;
if (OnSceneSwitched != null)
{
OnSceneSwitched();
}
}
private static void OnSceneUnloadClient(Guid switchSceneGuid, Stream objectStream)
{
if (!NetworkingManager.Singleton.NetworkConfig.EnableSceneManagement || NetworkingManager.Singleton.NetworkConfig.UsePrefabSync)
{
SpawnManager.DestroySceneObjects();
using (PooledBitReader reader = PooledBitReader.Get(objectStream))
{
uint newObjectsCount = reader.ReadUInt32Packed();
for (int i = 0; i < newObjectsCount; i++)
{
bool isPlayerObject = reader.ReadBool();
ulong networkId = reader.ReadUInt64Packed();
ulong owner = reader.ReadUInt64Packed();
bool hasParent = reader.ReadBool();
ulong?parentNetworkId = null;
if (hasParent)
{
parentNetworkId = reader.ReadUInt64Packed();
}
ulong prefabHash = reader.ReadUInt64Packed();
Vector3? position = null;
Quaternion?rotation = null;
if (reader.ReadBool())
{
position = new Vector3(reader.ReadSinglePacked(), reader.ReadSinglePacked(), reader.ReadSinglePacked());
rotation = Quaternion.Euler(reader.ReadSinglePacked(), reader.ReadSinglePacked(), reader.ReadSinglePacked());
}
NetworkedObject networkedObject = SpawnManager.CreateLocalNetworkedObject(false, 0, prefabHash, parentNetworkId, position, rotation);
SpawnManager.SpawnNetworkedObjectLocally(networkedObject, networkId, true, isPlayerObject, owner, objectStream, false, 0, true, false);
Queue <BufferManager.BufferedMessage> bufferQueue = BufferManager.ConsumeBuffersForNetworkId(networkId);
// Apply buffered messages
if (bufferQueue != null)
{
while (bufferQueue.Count > 0)
{
BufferManager.BufferedMessage message = bufferQueue.Dequeue();
NetworkingManager.Singleton.HandleIncomingData(message.sender, message.channelName, new ArraySegment <byte>(message.payload.GetBuffer(), (int)message.payload.Position, (int)message.payload.Length), message.receiveTime, false);
BufferManager.RecycleConsumedBufferedMessage(message);
}
}
}
}
}
else
{
NetworkedObject[] networkedObjects = MonoBehaviour.FindObjectsOfType <NetworkedObject>();
SpawnManager.ClientCollectSoftSyncSceneObjectSweep(networkedObjects);
using (PooledBitReader reader = PooledBitReader.Get(objectStream))
{
uint newObjectsCount = reader.ReadUInt32Packed();
for (int i = 0; i < newObjectsCount; i++)
{
bool isPlayerObject = reader.ReadBool();
ulong networkId = reader.ReadUInt64Packed();
ulong owner = reader.ReadUInt64Packed();
bool hasParent = reader.ReadBool();
ulong?parentNetworkId = null;
if (hasParent)
{
parentNetworkId = reader.ReadUInt64Packed();
}
ulong instanceId = reader.ReadUInt64Packed();
NetworkedObject networkedObject = SpawnManager.CreateLocalNetworkedObject(true, instanceId, 0, parentNetworkId, null, null);
SpawnManager.SpawnNetworkedObjectLocally(networkedObject, networkId, true, isPlayerObject, owner, objectStream, false, 0, true, false);
Queue <BufferManager.BufferedMessage> bufferQueue = BufferManager.ConsumeBuffersForNetworkId(networkId);
// Apply buffered messages
if (bufferQueue != null)
{
while (bufferQueue.Count > 0)
{
BufferManager.BufferedMessage message = bufferQueue.Dequeue();
NetworkingManager.Singleton.HandleIncomingData(message.sender, message.channelName, new ArraySegment <byte>(message.payload.GetBuffer(), (int)message.payload.Position, (int)message.payload.Length), message.receiveTime, false);
BufferManager.RecycleConsumedBufferedMessage(message);
}
}
}
}
}
using (PooledBitStream stream = PooledBitStream.Get())
{
using (PooledBitWriter writer = PooledBitWriter.Get(stream))
{
writer.WriteByteArray(switchSceneGuid.ToByteArray());
NetworkedObject networkedObject = null;
InternalMessageSender.Send(NetworkingManager.Singleton.ServerClientId, MLAPIConstants.MLAPI_CLIENT_SWITCH_SCENE_COMPLETED, "MLAPI_INTERNAL", stream, SecuritySendFlags.None, networkedObject);
}
}
isSwitching = false;
if (OnSceneSwitched != null)
{
OnSceneSwitched();
}
}
/// <summary>
/// this function splits FILES into MEMORY SAFE sized chunks and safely sends one before starting another
///
/// files receipient needs to receive the same number of headers with each header packet (packet 1 counts as a header packet)
/// </summary>
public IEnumerator SendFilesDownloadRoutine(string[] _paths, ulong _clientID)
{
Debug.Log("coroutine started");
if (State != LargeRPCState.Idle)
{
Debug.LogWarning("Cannot start sending files while files are being sent, waiting for Idle state to begin");
yield break;
}
ReceiverID = _clientID;
ChangeState(LargeRPCState.Send_SendingHeaders);
#region comment -- header sizes
/* -- Header sizes --
* packet 1
* int fileCount 4b | long downloadSize 8b | <start headers>
*
* header packets
* int fileID 4b | string filename varsize | byte[256] hash 32b | long fileLength 8b | bool isLastInPacket 1bit
*
* subsequent packets
* int fileID 4b | int filedata_length 4b | byte[var] filedata <=netChunkSize | bool isLastInPacket 1byte
*/
#endregion
#region Grab Download Information
// grab info for headers
foreach (var path in _paths)
{
if (File.Exists(path))
{
using (FileStream fs = File.Open(path, FileMode.Open))
{
Debug.Log(fs.Name);
int id = Headers.Count;
byte[] fileHash = fs.sha256();
yield return(new WaitForEndOfFrame());
FileHeader header = new FileHeader(id, Path.GetFileName(path), fileHash, fs.Length);
Headers.Add(header);
DownloadSize += header.fileSize;
}
// let it exit if it needs to, giving StopRoutine() a chance
yield return(0);
}
else
{
Debug.LogWarning("File not found, skipping: " + path);
}
}
#endregion
#region send headers
PooledBitStream bitStream = PooledBitStream.Get();
PooledBitWriter writer = PooledBitWriter.Get(bitStream);
// fileCount
writer.WriteInt32(Headers.Count);
// downloadSize
writer.WriteInt64(DownloadSize);
var headersThisPacket = 0;
var packetsSent = 0;
Debug.Log("Sending headers");
foreach (var header in Headers)
{
// let it exit if it needs to, giving StopRoutine() a chance
yield return(0);
Debug.Log(headersThisPacket + " " + packetsSent);
var path = header.path;
var id = header.id;
headersThisPacket++;
// fileID
writer.WriteInt32(header.id);
// filename
writer.WriteString(path);
Debug.Log(Encoding.Unicode.GetString(header.hash));
// hash
writer.WriteByteArray(header.hash, 32);
// fileLength
writer.WriteInt64(header.fileSize);
bool isLastPacket = id >= Headers.Count - 1;
// send it off if we've filled up a packet
if (headersThisPacket >= headersPerPacket || isLastPacket)
{
Debug.Log("message going out");
// isLastInPacket
writer.WriteBit(true);
CustomMessagingManager.SendNamedMessage(MessageName, _clientID, bitStream, "MLAPI_INTERNAL");
/* headers are pretty small, they really don't need the receiver to check in here unless it becomes a problem
*
* // if we haven't sent any packets yet when we get here, wait for an okay from the receiver
* if (packetsSent == 0)
* {
* ChangeState(LargeRPCState.Send_AwaitingOkayToSend);
*
* while (State == LargeRPCState.Send_AwaitingOkayToSend)
* {
* yield return new WaitForSeconds(0.5f);
* }
* }*/
packetsSent++;
Debug.Log("headers: " + headersThisPacket + " packets: " + packetsSent);
headersThisPacket = 0;
writer.Dispose();
bitStream.Dispose();
bitStream = PooledBitStream.Get();
writer = PooledBitWriter.Get(bitStream);
// don't wait on the last one
if (!isLastPacket)
{
yield return(new WaitForSeconds(1 / 14));
}
}
else
{
writer.WriteBit(false);
}
}
writer.Dispose();
bitStream.Dispose();
#endregion
ChangeState(LargeRPCState.Send_AwaitingFilesNeededList);
ListenForFilesNeededListOrCompletion();
// loop start
while (State != LargeRPCState.Complete)
{
// let it exit if it needs to, giving StopRoutine() a chance
yield return(0);
Debug.Log("Not done, running not-complete loop");
#region wait for needed files list
while (State == LargeRPCState.Send_AwaitingFilesNeededList || State == LargeRPCState.Send_EnsuringIntegrity)
{
Debug.Log("waiting for list");
yield return(new WaitForSeconds(0.5f));
}
Debug.Log("No longer waiting for list");
#endregion
// runs ReceiveFilesNeededListFromReceiver, changes state to either Send_SendingFiles or Complete
if (filesToSend.Count > 0)
{
Debug.Log("client still needs more files, sending");
#region send files
bitStream = PooledBitStream.Get();
writer = PooledBitWriter.Get(bitStream);
foreach (var header in Headers)
{
// let it exit if it needs to, giving StopRoutine() a chance
yield return(0);
Debug.Log("processing header");
if (File.Exists(header.path) && filesToSend.Contains(header.id))
{
Debug.Log("file is needed");
using (FileStream fs = File.Open(header.path, FileMode.Open))
{
// while loop pulled from fs.Read docs from microsoft, a little confusing to the glance but works and will be fast
int numBytesToRead = (int)fs.Length;
int numBytesRead = 0;
while (numBytesToRead > 0)
{
Debug.Log("still bytes left");
int thisFileChunkSize = fileChunkSize;
thisFileChunkSize = Mathf.Min(thisFileChunkSize, numBytesToRead);
byte[] fileChunk = new byte[thisFileChunkSize];
// Read may return anything from 0 to numBytesToRead.
int n = fs.Read(fileChunk, numBytesRead, thisFileChunkSize);
foreach (byte[] netChunk in fileChunk.Slices(netChunkSize, false))
{
Debug.Log("processing next chunk");
// fileID
writer.WriteInt32(header.id);
//writer.WriteInt32(netChunk.Length);
Debug.Log("netchunk len: " + netChunk.Length);
// filedata
writer.WriteByteArray(netChunk);
// isLastInPacket, need to add in its own size
bool isLastInPacket = bitStream.Length + 1 >= netChunkSize || netChunk.Length < netChunkSize;
writer.WriteBit(isLastInPacket);
if (isLastInPacket)
{
CustomMessagingManager.SendNamedMessage(MessageName, _clientID, bitStream, "MLAPI_INTERNAL");
Debug.Log("packet sent");
yield return(new WaitForSeconds(1 / 14));
writer.Dispose();
bitStream.Dispose();
bitStream = PooledBitStream.Get();
writer = PooledBitWriter.Get(bitStream);
}
}
// Break when the end of the file is reached.
if (n == 0)
{
Debug.Log("end of file reached, this is a failsafe");
break;
}
numBytesRead += n;
numBytesToRead -= n;
}
}
}
}
Debug.Log("all headers processed");
filesToSend.Clear();
// just failsafing these, should be disposed of already
writer.Dispose();
bitStream.Dispose();
#endregion
ChangeState(LargeRPCState.Send_EnsuringIntegrity);
}
Debug.Log("Waiting before checking completion again");
yield return(new WaitForSeconds(1f));
}
StopListening();
Debug.Log("files sent");
if (OnDownloadComplete != null)
{
OnDownloadComplete(SendOrReceiveFlag.Send, ReceiverID);
}
ChangeState(LargeRPCState.Idle);
yield break;
}
