warlock/NanoPark
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Basic Networking done

Browse Source
This commit is contained in:
warlock
2022-01-26 19:10:12 +05:30
parent d852b2bb2c
commit 891318680d
1111 changed files with 105855 additions and 780 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
Assets/Mirror/Runtime/Transport/Ignorance/Core.meta Normal file
View File

@@ -0,0 +1,8 @@
fileFormatVersion: 2
guid: e03829cb9e647274db0f6a7b8b1b757b
folderAsset: yes
DefaultImporter:
externalObjects: {}
userData:
assetBundleName:
assetBundleVariant:

296
Assets/Mirror/Runtime/Transport/Ignorance/Core/IgnoranceClient.cs Normal file
View File

@@ -0,0 +1,296 @@
// Ignorance 1.4.x
// Ignorance. It really kicks the Unity LLAPIs ass.
// https://github.com/SoftwareGuy/Ignorance
// -----------------
// Copyright (c) 2019 - 2020 Matt Coburn (SoftwareGuy/Coburn64)
// Ignorance Transport is licensed under the MIT license. Refer
// to the LICENSE file for more information.
using ENet;
// using NetStack.Buffers;
using System;
using System.Collections.Concurrent;
using System.Threading;
using UnityEngine;
using Event = ENet.Event; // fixes CS0104 ambigous reference between the same thing in UnityEngine
using EventType = ENet.EventType; // fixes CS0104 ambigous reference between the same thing in UnityEngine
using Object = System.Object; // fixes CS0104 ambigous reference between the same thing in UnityEngine
namespace IgnoranceTransport
{
public class IgnoranceClient
{
// Client connection address and port
public string ConnectAddress = "127.0.0.1";
public int ConnectPort = 7777;
// How many channels are expected
public int ExpectedChannels = 2;
// Native poll waiting time
public int PollTime = 1;
// Maximum Packet Size
public int MaximumPacketSize = 33554432;
// General Verbosity by default.
public int Verbosity = 1;
// Queues
public ConcurrentQueue<IgnoranceIncomingPacket> Incoming = new ConcurrentQueue<IgnoranceIncomingPacket>();
public ConcurrentQueue<IgnoranceOutgoingPacket> Outgoing = new ConcurrentQueue<IgnoranceOutgoingPacket>();
public ConcurrentQueue<IgnoranceCommandPacket> Commands = new ConcurrentQueue<IgnoranceCommandPacket>();
public ConcurrentQueue<IgnoranceConnectionEvent> ConnectionEvents = new ConcurrentQueue<IgnoranceConnectionEvent>();
public ConcurrentQueue<IgnoranceClientStats> StatusUpdates = new ConcurrentQueue<IgnoranceClientStats>();
public bool IsAlive => WorkerThread != null && WorkerThread.IsAlive;
private volatile bool CeaseOperation = false;
private Thread WorkerThread;
public void Start()
{
Debug.Log("IgnoranceClient.Start()");
if (WorkerThread != null && WorkerThread.IsAlive)
{
// Cannot do that.
Debug.LogError("A worker thread is already running. Cannot start another.");
return;
}
CeaseOperation = false;
ThreadParamInfo threadParams = new ThreadParamInfo()
{
Address = ConnectAddress,
Port = ConnectPort,
Channels = ExpectedChannels,
PollTime = PollTime,
PacketSizeLimit = MaximumPacketSize,
Verbosity = Verbosity
};
// Drain queues.
if (Incoming != null) while (Incoming.TryDequeue(out _)) ;
if (Outgoing != null) while (Outgoing.TryDequeue(out _)) ;
if (Commands != null) while (Commands.TryDequeue(out _)) ;
if (ConnectionEvents != null) while (ConnectionEvents.TryDequeue(out _)) ;
if (StatusUpdates != null) while (StatusUpdates.TryDequeue(out _)) ;
WorkerThread = new Thread(ThreadWorker);
WorkerThread.Start(threadParams);
Debug.Log("Client has dispatched worker thread.");
}
public void Stop()
{
Debug.Log("Telling client thread to stop, this may take a while depending on network load");
CeaseOperation = true;
}
// This runs in a seperate thread, be careful accessing anything outside of it's thread
// or you may get an AccessViolation/crash.
private void ThreadWorker(Object parameters)
{
if (Verbosity > 0)
Debug.Log("Ignorance Client: Initializing. Please stand by...");
ThreadParamInfo setupInfo;
Address clientAddress = new Address();
Peer clientPeer;
Host clientENetHost;
Event clientENetEvent;
IgnoranceClientStats icsu = default;
// Grab the setup information.
if (parameters.GetType() == typeof(ThreadParamInfo))
{
setupInfo = (ThreadParamInfo)parameters;
}
else
{
Debug.LogError("Ignorance Client: Startup failure: Invalid thread parameters. Aborting.");
return;
}
// Attempt to initialize ENet inside the thread.
if (Library.Initialize())
{
Debug.Log("Ignorance Client: ENet initialized.");
}
else
{
Debug.LogError("Ignorance Client: Failed to initialize ENet. This threads' fucked.");
return;
}
// Attempt to connect to our target.
clientAddress.SetHost(setupInfo.Address);
clientAddress.Port = (ushort)setupInfo.Port;
using (clientENetHost = new Host())
{
// TODO: Maybe try catch this
clientENetHost.Create();
clientPeer = clientENetHost.Connect(clientAddress, setupInfo.Channels);
while (!CeaseOperation)
{
bool pollComplete = false;
// Step 0: Handle commands.
while (Commands.TryDequeue(out IgnoranceCommandPacket commandPacket))
{
switch (commandPacket.Type)
{
default:
break;
case IgnoranceCommandType.ClientWantsToStop:
CeaseOperation = true;
break;
case IgnoranceCommandType.ClientRequestsStatusUpdate:
// Respond with statistics so far.
if (!clientPeer.IsSet)
break;
icsu.RTT = clientPeer.RoundTripTime;
icsu.BytesReceived = clientPeer.BytesReceived;
icsu.BytesSent = clientPeer.BytesSent;
icsu.PacketsReceived = clientENetHost.PacketsReceived;
icsu.PacketsSent = clientPeer.PacketsSent;
icsu.PacketsLost = clientPeer.PacketsLost;
StatusUpdates.Enqueue(icsu);
break;
}
}
// Step 1: Send out data.
// ---> Sending to Server
while (Outgoing.TryDequeue(out IgnoranceOutgoingPacket outgoingPacket))
{
// TODO: Revise this, could we tell the Peer to disconnect right here?
// Stop early if we get a client stop packet.
// if (outgoingPacket.Type == IgnorancePacketType.ClientWantsToStop) break;
int ret = clientPeer.Send(outgoingPacket.Channel, ref outgoingPacket.Payload);
if (ret < 0 && setupInfo.Verbosity > 0)
Debug.LogWarning($"Ignorance Client: ENet error code {ret} while sending packet to Peer {outgoingPacket.NativePeerId}.");
}
// Step 2:
// <----- Receive Data packets
// This loops until polling is completed. It may take a while, if it's
// a slow networking day.
while (!pollComplete)
{
Packet incomingPacket;
Peer incomingPeer;
int incomingPacketLength;
// Any events worth checking out?
if (clientENetHost.CheckEvents(out clientENetEvent) <= 0)
{
// If service time is met, break out of it.
if (clientENetHost.Service(setupInfo.PollTime, out clientENetEvent) <= 0) break;
// Poll is done.
pollComplete = true;
}
// Setup the packet references.
incomingPeer = clientENetEvent.Peer;
// Now, let's handle those events.
switch (clientENetEvent.Type)
{
case EventType.None:
default:
break;
case EventType.Connect:
ConnectionEvents.Enqueue(new IgnoranceConnectionEvent()
{
NativePeerId = incomingPeer.ID,
IP = incomingPeer.IP,
Port = incomingPeer.Port
});
break;
case EventType.Disconnect:
case EventType.Timeout:
ConnectionEvents.Enqueue(new IgnoranceConnectionEvent()
{
WasDisconnect = true
});
break;
case EventType.Receive:
// Receive event type usually includes a packet; so cache its reference.
incomingPacket = clientENetEvent.Packet;
if (!incomingPacket.IsSet)
{
if (setupInfo.Verbosity > 0)
Debug.LogWarning($"Ignorance Client: A receive event did not supply us with a packet to work with. This should never happen.");
break;
}
incomingPacketLength = incomingPacket.Length;
// Never consume more than we can have capacity for.
if (incomingPacketLength > setupInfo.PacketSizeLimit)
{
if (setupInfo.Verbosity > 0)
Debug.LogWarning($"Ignorance Client: Incoming packet is too big. My limit is {setupInfo.PacketSizeLimit} byte(s) whilest this packet is {incomingPacketLength} bytes.");
incomingPacket.Dispose();
break;
}
IgnoranceIncomingPacket incomingQueuePacket = new IgnoranceIncomingPacket
{
Channel = clientENetEvent.ChannelID,
NativePeerId = incomingPeer.ID,
Payload = incomingPacket
};
Incoming.Enqueue(incomingQueuePacket);
break;
}
}
}
Debug.Log("Ignorance Server: Shutdown commencing, disconnecting and flushing connection.");
// Flush the client and disconnect.
clientPeer.Disconnect(0);
clientENetHost.Flush();
// Fix for client stuck in limbo, since the disconnection event may not be fired until next loop.
ConnectionEvents.Enqueue(new IgnoranceConnectionEvent()
{
WasDisconnect = true
});
}
// Deinitialize
Library.Deinitialize();
if (setupInfo.Verbosity > 0)
Debug.Log("Ignorance Client: Shutdown complete.");
}
private struct ThreadParamInfo
{
public int Channels;
public int PollTime;
public int Port;
public int PacketSizeLimit;
public int Verbosity;
public string Address;
}
}
}

11
Assets/Mirror/Runtime/Transport/Ignorance/Core/IgnoranceClient.cs.meta Normal file
View File

@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: b7b9e2c091c3d42439840a02fe700252
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

328
Assets/Mirror/Runtime/Transport/Ignorance/Core/IgnoranceServer.cs Normal file
View File

@@ -0,0 +1,328 @@
// Ignorance 1.4.x
// Ignorance. It really kicks the Unity LLAPIs ass.
// https://github.com/SoftwareGuy/Ignorance
// -----------------
// Copyright (c) 2019 - 2020 Matt Coburn (SoftwareGuy/Coburn64)
// Ignorance Transport is licensed under the MIT license. Refer
// to the LICENSE file for more information.
using ENet;
// using NetStack.Buffers;
using System.Collections.Concurrent;
using System.Threading;
using UnityEngine;
using Event = ENet.Event; // fixes CS0104 ambigous reference between the same thing in UnityEngine
using EventType = ENet.EventType; // fixes CS0104 ambigous reference between the same thing in UnityEngine
using Object = System.Object; // fixes CS0104 ambigous reference between the same thing in UnityEngine
namespace IgnoranceTransport
{
public class IgnoranceServer
{
// Server Properties
// - Bind Settings
public string BindAddress = "127.0.0.1";
public int BindPort = 7777;
// - Maximum allowed channels, peers, etc.
public int MaximumChannels = 2;
public int MaximumPeers = 100;
public int MaximumPacketSize = 33554432; // ENet.cs: uint maxPacketSize = 32 * 1024 * 1024 = 33554432
// - Native poll waiting time
public int PollTime = 1;
public int Verbosity = 1;
public bool IsAlive => WorkerThread != null && WorkerThread.IsAlive;
private volatile bool CeaseOperation = false;
// Queues
public ConcurrentQueue<IgnoranceIncomingPacket> Incoming = new ConcurrentQueue<IgnoranceIncomingPacket>();
public ConcurrentQueue<IgnoranceOutgoingPacket> Outgoing = new ConcurrentQueue<IgnoranceOutgoingPacket>();
public ConcurrentQueue<IgnoranceCommandPacket> Commands = new ConcurrentQueue<IgnoranceCommandPacket>();
public ConcurrentQueue<IgnoranceConnectionEvent> ConnectionEvents = new ConcurrentQueue<IgnoranceConnectionEvent>();
public ConcurrentQueue<IgnoranceConnectionEvent> DisconnectionEvents = new ConcurrentQueue<IgnoranceConnectionEvent>();
// Thread
private Thread WorkerThread;
public void Start()
{
if (WorkerThread != null && WorkerThread.IsAlive)
{
// Cannot do that.
Debug.LogError("A worker thread is already running. Cannot start another.");
return;
}
CeaseOperation = false;
ThreadParamInfo threadParams = new ThreadParamInfo()
{
Address = BindAddress,
Port = BindPort,
Peers = MaximumPeers,
Channels = MaximumChannels,
PollTime = PollTime,
PacketSizeLimit = MaximumPacketSize,
Verbosity = Verbosity
};
// Drain queues.
if (Incoming != null) while (Incoming.TryDequeue(out _)) ;
if (Outgoing != null) while (Outgoing.TryDequeue(out _)) ;
if (Commands != null) while (Commands.TryDequeue(out _)) ;
if (ConnectionEvents != null) while (ConnectionEvents.TryDequeue(out _)) ;
if (DisconnectionEvents != null) while (DisconnectionEvents.TryDequeue(out _)) ;
WorkerThread = new Thread(ThreadWorker);
WorkerThread.Start(threadParams);
// Announce
if (Verbosity > 0)
Debug.Log("Server has dispatched worker thread.");
}
public void Stop()
{
if (Verbosity > 0)
Debug.Log("Telling server thread to stop, this may take a while depending on network load");
CeaseOperation = true;
}
private void ThreadWorker(Object parameters)
{
if (Verbosity > 0)
Debug.Log("Ignorance Server: Initializing. Please stand by...");
// Thread cache items
ThreadParamInfo setupInfo;
Address serverAddress = new Address();
Host serverENetHost;
Event serverENetEvent;
Peer[] serverPeerArray;
// Grab the setup information.
if (parameters.GetType() == typeof(ThreadParamInfo))
{
setupInfo = (ThreadParamInfo)parameters;
}
else
{
Debug.LogError("Ignorance Server: Startup failure: Invalid thread parameters. Aborting.");
return;
}
// Attempt to initialize ENet inside the thread.
if (Library.Initialize())
{
Debug.Log("Ignorance Server: ENet initialized.");
}
else
{
Debug.LogError("Ignorance Server: Failed to initialize ENet. This threads' fucked.");
return;
}
// Configure the server address.
serverAddress.SetHost(setupInfo.Address);
serverAddress.Port = (ushort)setupInfo.Port;
serverPeerArray = new Peer[setupInfo.Peers];
using (serverENetHost = new Host())
{
// Create the server object.
serverENetHost.Create(serverAddress, setupInfo.Peers, setupInfo.Channels);
// Loop until we're told to cease operations.
while (!CeaseOperation)
{
// Intermission: Command Handling
while (Commands.TryDequeue(out IgnoranceCommandPacket commandPacket))
{
switch (commandPacket.Type)
{
default:
break;
// Boot a Peer off the Server.
case IgnoranceCommandType.ServerKickPeer:
uint targetPeer = commandPacket.PeerId;
if (!serverPeerArray[targetPeer].IsSet) continue;
if (setupInfo.Verbosity > 0)
Debug.Log($"Ignorance Server: Booting Peer {targetPeer} off this server instance.");
IgnoranceConnectionEvent iced = new IgnoranceConnectionEvent()
{
WasDisconnect = true,
NativePeerId = targetPeer
};
DisconnectionEvents.Enqueue(iced);
// Disconnect and reset the peer array's entry for that peer.
serverPeerArray[targetPeer].DisconnectNow(0);
serverPeerArray[targetPeer] = default;
break;
}
}
// Step One:
// ---> Sending to peers
while (Outgoing.TryDequeue(out IgnoranceOutgoingPacket outgoingPacket))
{
// Only create a packet if the server knows the peer.
if (serverPeerArray[outgoingPacket.NativePeerId].IsSet)
{
int ret = serverPeerArray[outgoingPacket.NativePeerId].Send(outgoingPacket.Channel, ref outgoingPacket.Payload);
if (ret < 0 && setupInfo.Verbosity > 0)
Debug.LogWarning($"Ignorance Server: ENet error code {ret} while sending packet to Peer {outgoingPacket.NativePeerId}.");
}
else
{
// A peer might have disconnected, this is OK - just log the packet if set to paranoid.
if (setupInfo.Verbosity > 1)
Debug.LogWarning("Ignorance Server: Can't send packet, a native peer object is not set. This may be normal if the Peer has disconnected before this send cycle.");
}
}
// Step 2
// <--- Receiving from peers
bool pollComplete = false;
while (!pollComplete)
{
Packet incomingPacket;
Peer incomingPeer;
int incomingPacketLength;
// Any events happening?
if (serverENetHost.CheckEvents(out serverENetEvent) <= 0)
{
// If service time is met, break out of it.
if (serverENetHost.Service(setupInfo.PollTime, out serverENetEvent) <= 0) break;
pollComplete = true;
}
// Setup the packet references.
incomingPeer = serverENetEvent.Peer;
switch (serverENetEvent.Type)
{
// Idle.
case EventType.None:
default:
break;
// Connection Event.
case EventType.Connect:
if (setupInfo.Verbosity > 1)
Debug.Log("Ignorance Server: Here comes a new Peer connection.");
IgnoranceConnectionEvent ice = new IgnoranceConnectionEvent()
{
NativePeerId = incomingPeer.ID,
IP = incomingPeer.IP,
Port = incomingPeer.Port
};
ConnectionEvents.Enqueue(ice);
// Assign a reference to the Peer.
serverPeerArray[incomingPeer.ID] = incomingPeer;
break;
// Disconnect/Timeout. Mirror doesn't care if it's either, so we lump them together.
case EventType.Disconnect:
case EventType.Timeout:
if (!serverPeerArray[incomingPeer.ID].IsSet) break;
if (setupInfo.Verbosity > 1)
Debug.Log("Ignorance Server: Peer disconnection.");
IgnoranceConnectionEvent iced = new IgnoranceConnectionEvent()
{
WasDisconnect = true,
NativePeerId = incomingPeer.ID
};
DisconnectionEvents.Enqueue(iced);
// Reset the peer array's entry for that peer.
serverPeerArray[incomingPeer.ID] = default;
break;
case EventType.Receive:
// Receive event type usually includes a packet; so cache its reference.
incomingPacket = serverENetEvent.Packet;
if (!incomingPacket.IsSet)
{
if (setupInfo.Verbosity > 0)
Debug.LogWarning($"Ignorance Server: A receive event did not supply us with a packet to work with. This should never happen.");
break;
}
incomingPacketLength = incomingPacket.Length;
// Firstly check if the packet is too big. If it is, do not process it - drop it.
if (incomingPacketLength > setupInfo.PacketSizeLimit)
{
if (setupInfo.Verbosity > 0)
Debug.LogWarning($"Ignorance Server: Incoming packet is too big. My limit is {setupInfo.PacketSizeLimit} byte(s) whilest this packet is {incomingPacketLength} bytes.");
incomingPacket.Dispose();
break;
}
IgnoranceIncomingPacket incomingQueuePacket = new IgnoranceIncomingPacket
{
Channel = serverENetEvent.ChannelID,
NativePeerId = incomingPeer.ID,
Payload = incomingPacket,
};
// Enqueue.
Incoming.Enqueue(incomingQueuePacket);
break;
}
}
}
if (Verbosity > 0)
Debug.Log("Ignorance Server: Shutdown commencing, flushing connections.");
// Cleanup and flush everything.
serverENetHost.Flush();
// Kick everyone.
for (int i = 0; i < serverPeerArray.Length; i++)
{
if (!serverPeerArray[i].IsSet) continue;
serverPeerArray[i].DisconnectNow(0);
}
}
// Flush again to ensure ENet gets those Disconnection stuff out.
// May not be needed; better to err on side of caution
if (setupInfo.Verbosity > 0)
Debug.Log("Ignorance Server: Shutdown complete.");
Library.Deinitialize();
}
private struct ThreadParamInfo
{
public int Channels;
public int Peers;
public int PollTime;
public int Port;
public int PacketSizeLimit;
public int Verbosity;
public string Address;
}
}
}

11
Assets/Mirror/Runtime/Transport/Ignorance/Core/IgnoranceServer.cs.meta Normal file
View File

@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: 1069f42b88a4adb4ab1990cec4949343
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

8
Assets/Mirror/Runtime/Transport/Ignorance/Dependencies.meta Normal file
View File

@@ -0,0 +1,8 @@
fileFormatVersion: 2
guid: 12f903db684732e45b130ad56f7c86c1
folderAsset: yes
DefaultImporter:
externalObjects: {}
userData:
assetBundleName:
assetBundleVariant:

1411
Assets/Mirror/Runtime/Transport/Ignorance/Dependencies/ENet.cs Normal file
View File

File diff suppressed because it is too large Load Diff

11
Assets/Mirror/Runtime/Transport/Ignorance/Dependencies/ENet.cs.meta Normal file
View File

@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: 12a7875e95f5ebb4a9b58390441dd933
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

8
Assets/Mirror/Runtime/Transport/Ignorance/Editor.meta Normal file
View File

@@ -0,0 +1,8 @@
fileFormatVersion: 2
guid: 0995e08af14888348b42ecaa6eb21544
folderAsset: yes
DefaultImporter:
externalObjects: {}
userData:
assetBundleName:
assetBundleVariant:

83
Assets/Mirror/Runtime/Transport/Ignorance/Editor/AddScriptingDefine.cs Normal file
View File

@@ -0,0 +1,83 @@
#if UNITY_EDITOR
using System.Collections.Generic;
using System.Linq;
using UnityEditor;
namespace IgnoranceTransport
{
/// <summary>
/// Adds the given define symbols to PlayerSettings define symbols.
/// Just add your own define symbols to the Symbols property at the below.
/// </summary>
[InitializeOnLoad]
public class AddIgnoranceDefine : Editor
{
private static string existingDefines = string.Empty;
/// <summary>
/// Symbols that will be added to the editor
/// </summary>
public static readonly string[] Symbols = new string[] {
"IGNORANCE", // Ignorance exists
"IGNORANCE_1", // Major version
"IGNORANCE_1_4" // Major and minor version
};
/// <summary>
/// Do not remove these symbols
/// </summary>
public static readonly string[] DoNotRemoveTheseSymbols = new string[]
{
"IGNORANCE_NO_UPNP",
"IGNORANCE_MIRROR_POLLING"
};
/// <summary>
/// Add define symbols as soon as Unity gets done compiling.
/// </summary>
static AddIgnoranceDefine()
{
// Get the current scripting defines
string definesString = PlayerSettings.GetScriptingDefineSymbolsForGroup(EditorUserBuildSettings.selectedBuildTargetGroup);
if (existingDefines == definesString)
{
// 1.2.6: There is no need to apply the changes, return.
return;
}
// Convert the string to a list
List<string> allDefines = definesString.Split(';').ToList();
// Remove any old version defines from previous installs
allDefines.RemoveAll(IsSafeToRemove);
// x => x.StartsWith("IGNORANCE") && !DoesSymbolExistInBlacklist(x));
// Add any symbols that weren't already in the list
allDefines.AddRange(Symbols.Except(allDefines));
string newDefines = string.Join(";", allDefines.ToArray());
PlayerSettings.SetScriptingDefineSymbolsForGroup(
EditorUserBuildSettings.selectedBuildTargetGroup,
newDefines
);
existingDefines = newDefines;
}
// 1.2.4: Workaround to stop things from eating custom IGNORANCE_ symbols
static bool DoesSymbolExistInBlacklist(string symbol)
{
foreach(string s in DoNotRemoveTheseSymbols)
{
if (s == symbol.Trim()) return true;
}
return false;
}
static bool IsSafeToRemove (string input)
{
if (input.StartsWith("IGNORANCE") && !DoesSymbolExistInBlacklist(input)) return true;
return false;
}
}
}
#endif

11
Assets/Mirror/Runtime/Transport/Ignorance/Editor/AddScriptingDefine.cs.meta Normal file
View File

@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: ed8acbde141f2d8469baf2142712de9e
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

44
Assets/Mirror/Runtime/Transport/Ignorance/Editor/IgnoranceToolbox.cs Normal file
View File

@@ -0,0 +1,44 @@
#if UNITY_EDITOR
using System.Collections.Generic;
using UnityEditor;
namespace IgnoranceTransport
{
public class IgnoranceToolbox
{
#pragma warning disable IDE0051
[MenuItem("Ignorance/Mirror/Switch Update Method")]
public static void SwitchIgnoranceUpdateMethod ()
{
}
[MenuItem("Ignorance/Debug/Reveal ENet Native Library Name")]
public static void RevealEnetLibraryName()
{
EditorUtility.DisplayDialog("Enet Library Name", $"Use this for debugging.\nYour platform expects the native Enet library to be called: {ENet.Native.nativeLibraryName}", "Got it");
}
[MenuItem("Ignorance/RTFM/Github Repository")]
private static void LaunchGithubRepo()
{
UnityEngine.Application.OpenURL("https://github.com/SoftwareGuy/Ignorance");
}
[MenuItem("Ignorance/RTFM/Github Issue Tracker")]
private static void LaunchGithubIssueTracker()
{
UnityEngine.Application.OpenURL("https://github.com/SoftwareGuy/Ignorance/issues");
}
[MenuItem("Ignorance/RTFM/ENet-CSharp Fork")]
private static void LaunchENetCSharpForkRepo()
{
UnityEngine.Application.OpenURL("https://github.com/SoftwareGuy/ENet-CSharp");
}
#pragma warning restore
}
}
#endif

11
Assets/Mirror/Runtime/Transport/Ignorance/Editor/IgnoranceToolbox.cs.meta Normal file
View File

@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: 1fdecc996313d614ca16214d4e2b9162
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

746
Assets/Mirror/Runtime/Transport/Ignorance/Ignorance.cs Normal file
View File

@@ -0,0 +1,746 @@
// Ignorance 1.4.x
// Ignorance. It really kicks the Unity LLAPIs ass.
// https://github.com/SoftwareGuy/Ignorance
// -----------------
// Copyright (c) 2019 - 2020 Matt Coburn (SoftwareGuy/Coburn64)
// Ignorance Transport is licensed under the MIT license. Refer
// to the LICENSE file for more information.
// -----------------
// Ignorance Experimental (New) Version
// -----------------
using ENet;
using Mirror;
using System;
using System.Collections.Generic;
using UnityEngine;
namespace IgnoranceTransport
{
[DisallowMultipleComponent]
public class Ignorance : Transport
{
#region Inspector options
public int port = 7777;
[Header("Debug & Logging Configuration")]
[Tooltip("How verbose do you want Ignorance to be?")]
public IgnoranceLogType LogType = IgnoranceLogType.Standard;
[Tooltip("Uses OnGUI to present you with statistics for Server and Client backend instances.")]
public bool DebugDisplay = false;
[Header("Server Configuration")]
[Tooltip("Should the server bind to all interfaces?")]
public bool serverBindsAll = true;
[Tooltip("This is only used if Server Binds All is unticked.")]
public string serverBindAddress = string.Empty;
[Tooltip("This tells ENet how many Peer slots to create. Helps performance, avoids looping over huge native arrays. Recommended: Max Mirror players, rounded to nearest 10. (Example: 16 -> 20).")]
public int serverMaxPeerCapacity = 50;
[Tooltip("How long ENet waits in native world. The higher this value, the more CPU usage. Lower values may/may not impact performance at high packet load.")]
public int serverMaxNativeWaitTime = 1;
[Header("Client Configuration")]
[Tooltip("How long ENet waits in native world. The higher this value, the more CPU usage used. This is for the client, unlike the one above. Higher value probably trades CPU for more responsive networking.")]
public int clientMaxNativeWaitTime = 3;
[Tooltip("Interval between asking ENet for client status updates. Set to -1 to disable.")]
public int clientStatusUpdateInterval = -1;
[Header("Channel Configuration")]
[Tooltip("You must define your channels in the array shown here, otherwise ENet will not know what channel delivery type to use.")]
public IgnoranceChannelTypes[] Channels;
[Header("Low-level Tweaking")]
[Tooltip("Used internally to keep allocations to a minimum. This is how much memory will be consumed by the packet buffer on startup, and then reused.")]
public int PacketBufferCapacity = 4096;
[Tooltip("For UDP based protocols, it's best to keep your data under the safe MTU of 1200 bytes. You can increase this, however beware this may open you up to allocation attacks.")]
public int MaxAllowedPacketSize = 33554432;
#endregion
#region Public Statistics
public IgnoranceClientStats ClientStatistics;
#endregion
#if MIRROR_26_0_OR_NEWER
public override bool Available()
{
// Ignorance is not available for Unity WebGL, the PS4 (no dev kit to confirm) or Switch (port exists but I have no access to said code).
// Ignorance is available for most other operating systems.
#if (UNITY_WEBGL || UNITY_PS4 || UNITY_SWITCH)
return false;
#else
return true;
#endif
}
public void Awake()
{
if (LogType != IgnoranceLogType.Nothing)
Debug.Log($"Thanks for using Ignorance {IgnoranceInternals.Version}. Keep up to date, report bugs and support the developer at https://github.com/SoftwareGuy/Ignorance!");
}
public override string ToString()
{
return $"Ignorance v{IgnoranceInternals.Version}";
}
public override void ClientConnect(string address)
{
ClientState = ConnectionState.Connecting;
cachedConnectionAddress = address;
// Initialize.
InitializeClientBackend();
// Get going.
ignoreDataPackets = false;
// Start!
Client.Start();
}
public override void ClientConnect(Uri uri)
{
if (uri.Scheme != IgnoranceInternals.Scheme)
throw new ArgumentException($"You used an invalid URI: {uri}. Please use {IgnoranceInternals.Scheme}://host:port instead", nameof(uri));
if (!uri.IsDefaultPort)
// Set the communication port to the one specified.
port = uri.Port;
// Pass onwards to the proper handler.
ClientConnect(uri.Host);
}
public override bool ClientConnected() => ClientState == ConnectionState.Connected;
public override void ClientDisconnect()
{
if (Client != null)
Client.Stop();
// TODO: Figure this one out to see if it's related to a race condition.
// Maybe experiment with a while loop to pause main thread when disconnecting,
// since client might not stop on a dime.
// while(Client.IsAlive) ;
// v1.4.0b1: Probably fixed in IgnoranceClient.cs; need further testing.
// ignoreDataPackets = true;
ClientState = ConnectionState.Disconnected;
}
#if !MIRROR_37_0_OR_NEWER
public override void ClientSend(int channelId, ArraySegment<byte> segment)
#else
// v1.4.0b6: Mirror rearranged the ClientSend params, so we need to apply a fix for that or
// we end up using the obsoleted version. The obsolete version isn't a fatal error, but
// it's best to stick with the new structures.
public override void ClientSend(ArraySegment<byte> segment, int channelId)
#endif
{
if (Client == null)
{
Debug.LogError("Client object is null, this shouldn't really happen but it did...");
return;
}
if (channelId < 0 || channelId > Channels.Length)
{
Debug.LogError("Channel ID is out of bounds.");
return;
}
// Create our struct...
Packet clientOutgoingPacket = default;
int byteCount = segment.Count;
int byteOffset = segment.Offset;
// Set our desired flags...
PacketFlags desiredFlags = (PacketFlags)Channels[channelId];
// Warn if over recommended MTU...
bool flagsSet = (desiredFlags & ReliableOrUnreliableFragmented) > 0;
if (LogType != IgnoranceLogType.Nothing && byteCount > 1200 && !flagsSet)
Debug.LogWarning($"Warning: Client trying to send a Unreliable packet bigger than the recommended ENet 1200 byte MTU ({byteCount} > 1200). ENet will force Reliable Fragmented delivery.");
// Create the packet.
clientOutgoingPacket.Create(segment.Array, byteOffset, byteCount + byteOffset, desiredFlags);
// byteCount
// Enqueue the packet.
IgnoranceOutgoingPacket dispatchPacket = new IgnoranceOutgoingPacket
{
Channel = (byte)channelId,
Payload = clientOutgoingPacket
};
// Pass the packet onto the thread for dispatch.
Client.Outgoing.Enqueue(dispatchPacket);
}
public override bool ServerActive()
{
// Very simple check.
return Server != null && Server.IsAlive;
}
#if !MIRROR_37_0_OR_NEWER
// Workaround for legacy Mirror versions.
public override bool ServerDisconnect(int connectionId) => ServerDisconnectLegacy(connectionId);
#else
public override void ServerDisconnect(int connectionId)
{
if (Server == null)
{
Debug.LogError("Cannot enqueue kick packet; our Server object is null. Something has gone wrong.");
// Return here because otherwise we will get a NRE when trying to enqueue the kick packet.
return;
}
IgnoranceCommandPacket kickPacket = new IgnoranceCommandPacket
{
Type = IgnoranceCommandType.ServerKickPeer,
PeerId = (uint)connectionId - 1 // ENet's native peer ID will be ConnID - 1
};
// Pass the packet onto the thread for dispatch.
Server.Commands.Enqueue(kickPacket);
}
#endif
public override string ServerGetClientAddress(int connectionId)
{
if (ConnectionLookupDict.TryGetValue(connectionId, out PeerConnectionData details))
return $"{details.IP}:{details.Port}";
return "(unavailable)";
}
#if !MIRROR_37_0_OR_NEWER
public override void ServerSend(int connectionId, int channelId, ArraySegment<byte> segment)
#else
// v1.4.0b6: Mirror rearranged the ServerSend params, so we need to apply a fix for that or
// we end up using the obsoleted version. The obsolete version isn't a fatal error, but
// it's best to stick with the new structures.
public override void ServerSend(int connectionId, ArraySegment<byte> segment, int channelId)
#endif
{
// Debug.Log($"ServerSend({connectionId}, {channelId}, <{segment.Count} byte segment>)");
if (Server == null)
{
Debug.LogError("Cannot enqueue data packet; our Server object is null. Something has gone wrong.");
return;
}
if (channelId < 0 || channelId > Channels.Length)
{
Debug.LogError("Channel ID is out of bounds.");
return;
}
// Packet Struct
Packet serverOutgoingPacket = default;
int byteCount = segment.Count;
int byteOffset = segment.Offset;
PacketFlags desiredFlags = (PacketFlags)Channels[channelId];
// Warn if over recommended MTU
bool flagsSet = (desiredFlags & ReliableOrUnreliableFragmented) > 0;
if (LogType != IgnoranceLogType.Nothing && byteCount > 1200 && !flagsSet)
Debug.LogWarning($"Warning: Server trying to send a Unreliable packet bigger than the recommended ENet 1200 byte MTU ({byteCount} > 1200). ENet will force Reliable Fragmented delivery.");
// Create the packet.
serverOutgoingPacket.Create(segment.Array, byteOffset, byteCount + byteOffset, (PacketFlags)Channels[channelId]);
// Enqueue the packet.
IgnoranceOutgoingPacket dispatchPacket = new IgnoranceOutgoingPacket
{
Channel = (byte)channelId,
NativePeerId = (uint)connectionId - 1, // ENet's native peer ID will be ConnID - 1
Payload = serverOutgoingPacket
};
Server.Outgoing.Enqueue(dispatchPacket);
}
public override void ServerStart()
{
if (LogType != IgnoranceLogType.Nothing)
Debug.Log("Ignorance Server Instance starting up...");
InitializeServerBackend();
Server.Start();
}
public override void ServerStop()
{
if (Server != null)
{
if (LogType != IgnoranceLogType.Nothing)
Debug.Log("Ignorance Server Instance shutting down...");
Server.Stop();
}
ConnectionLookupDict.Clear();
}
public override Uri ServerUri()
{
UriBuilder builder = new UriBuilder
{
Scheme = IgnoranceInternals.Scheme,
Host = serverBindAddress,
Port = port
};
return builder.Uri;
}
public override void Shutdown()
{
// TODO: Nothing needed here?
}
// Check to ensure channels 0 and 1 mimic LLAPI. Override this at your own risk.
private void OnValidate()
{
if (Channels != null && Channels.Length >= 2)
{
// Check to make sure that Channel 0 and 1 are correct.
if (Channels[0] != IgnoranceChannelTypes.Reliable)
{
Debug.LogWarning("Please do not modify Ignorance Channel 0. The channel will be reset to Reliable delivery. If you need a channel with a different delivery, define and use it instead.");
Channels[0] = IgnoranceChannelTypes.Reliable;
}
if (Channels[1] != IgnoranceChannelTypes.Unreliable)
{
Debug.LogWarning("Please do not modify Ignorance Channel 1. The channel will be reset to Unreliable delivery. If you need a channel with a different delivery, define and use it instead.");
Channels[1] = IgnoranceChannelTypes.Unreliable;
}
}
else
{
Debug.LogWarning("Invalid Channels setting, fixing. If you've just added Ignorance to your NetworkManager GameObject, seeing this message is normal.");
Channels = new IgnoranceChannelTypes[2]
{
IgnoranceChannelTypes.Reliable,
IgnoranceChannelTypes.Unreliable
};
}
// ENet only supports a maximum of 32MB packet size.
if (MaxAllowedPacketSize > 33554432)
MaxAllowedPacketSize = 33554432;
}
private void InitializeServerBackend()
{
if (Server == null)
{
Debug.LogWarning("IgnoranceServer reference for Server mode was null. This shouldn't happen, but to be safe we'll reinitialize it.");
Server = new IgnoranceServer();
}
// Set up the new IgnoranceServer reference.
if (serverBindsAll)
// MacOS is special. It's also a massive thorn in my backside.
Server.BindAddress = IgnoranceInternals.BindAllMacs;
else
// Use the supplied bind address.
Server.BindAddress = serverBindAddress;
// Sets port, maximum peers, max channels, the server poll time, maximum packet size and verbosity.
Server.BindPort = port;
Server.MaximumPeers = serverMaxPeerCapacity;
Server.MaximumChannels = Channels.Length;
Server.PollTime = serverMaxNativeWaitTime;
Server.MaximumPacketSize = MaxAllowedPacketSize;
Server.Verbosity = (int)LogType;
// Initializes the packet buffer.
// Allocates once, that's it.
if (InternalPacketBuffer == null)
InternalPacketBuffer = new byte[PacketBufferCapacity];
}
private void InitializeClientBackend()
{
if (Client == null)
{
Debug.LogWarning("Ignorance: IgnoranceClient reference for Client mode was null. This shouldn't happen, but to be safe we'll reinitialize it.");
Client = new IgnoranceClient();
}
// Sets address, port, channels to expect, verbosity, the server poll time and maximum packet size.
Client.ConnectAddress = cachedConnectionAddress;
Client.ConnectPort = port;
Client.ExpectedChannels = Channels.Length;
Client.PollTime = clientMaxNativeWaitTime;
Client.MaximumPacketSize = MaxAllowedPacketSize;
Client.Verbosity = (int)LogType;
// Initializes the packet buffer.
// Allocates once, that's it.
if (InternalPacketBuffer == null)
InternalPacketBuffer = new byte[PacketBufferCapacity];
}
private void ProcessServerPackets()
{
IgnoranceIncomingPacket incomingPacket;
IgnoranceConnectionEvent connectionEvent;
int adjustedConnectionId;
Packet payload;
// Incoming connection events.
while (Server.ConnectionEvents.TryDequeue(out connectionEvent))
{
adjustedConnectionId = (int)connectionEvent.NativePeerId + 1;
if (LogType == IgnoranceLogType.Verbose)
Debug.Log($"Processing a server connection event from ENet native peer {connectionEvent.NativePeerId}. This peer would be Mirror ConnID {adjustedConnectionId}.");
// TODO: Investigate ArgumentException: An item with the same key has already been added. Key: <id>
ConnectionLookupDict.Add(adjustedConnectionId, new PeerConnectionData
{
NativePeerId = connectionEvent.NativePeerId,
IP = connectionEvent.IP,
Port = connectionEvent.Port
});
OnServerConnected?.Invoke(adjustedConnectionId);
}
// Handle incoming data packets.
// Console.WriteLine($"Server Incoming Queue is {Server.Incoming.Count}");
while (Server.Incoming.TryDequeue(out incomingPacket))
{
adjustedConnectionId = (int)incomingPacket.NativePeerId + 1;
payload = incomingPacket.Payload;
int length = payload.Length;
ArraySegment<byte> dataSegment;
// Copy to working buffer and dispose of it.
if (length > InternalPacketBuffer.Length)
{
byte[] oneFreshNTastyGcAlloc = new byte[length];
payload.CopyTo(oneFreshNTastyGcAlloc);
dataSegment = new ArraySegment<byte>(oneFreshNTastyGcAlloc, 0, length);
}
else
{
payload.CopyTo(InternalPacketBuffer);
dataSegment = new ArraySegment<byte>(InternalPacketBuffer, 0, length);
}
payload.Dispose();
OnServerDataReceived?.Invoke(adjustedConnectionId, dataSegment, incomingPacket.Channel);
// Some messages can disable the transport
// If the transport was disabled by any of the messages, we have to break out of the loop and wait until we've been re-enabled.
if (!enabled)
break;
}
// Disconnection events.
while (Server.DisconnectionEvents.TryDequeue(out IgnoranceConnectionEvent disconnectionEvent))
{
adjustedConnectionId = (int)disconnectionEvent.NativePeerId + 1;
if (LogType == IgnoranceLogType.Verbose)
Debug.Log($"ProcessServerPackets fired; handling disconnection event from native peer {disconnectionEvent.NativePeerId}.");
ConnectionLookupDict.Remove(adjustedConnectionId);
// Invoke Mirror handler.
OnServerDisconnected?.Invoke(adjustedConnectionId);
}
}
private void ProcessClientPackets()
{
IgnoranceIncomingPacket incomingPacket;
IgnoranceCommandPacket commandPacket;
IgnoranceClientStats clientStats;
Packet payload;
IgnoranceConnectionEvent connectionEvent;
// Handle connection events.
while (Client.ConnectionEvents.TryDequeue(out connectionEvent))
{
if (LogType == IgnoranceLogType.Verbose)
Debug.Log($"ProcessClientConnectionEvents fired: processing a client ConnectionEvents queue item.");
if (connectionEvent.WasDisconnect)
{
// Disconnected from server.
ClientState = ConnectionState.Disconnected;
if (LogType != IgnoranceLogType.Nothing)
Debug.Log($"Ignorance Client has been disconnected from server.");
ignoreDataPackets = true;
OnClientDisconnected?.Invoke();
}
else
{
// Connected to server.
ClientState = ConnectionState.Connected;
if (LogType != IgnoranceLogType.Nothing)
Debug.Log($"Ignorance Client successfully connected to server at address {connectionEvent.IP}:{connectionEvent.Port}");
ignoreDataPackets = false;
OnClientConnected?.Invoke();
}
}
// Now handle the incoming messages.
while (Client.Incoming.TryDequeue(out incomingPacket))
{
// Temporary fix: if ENet thread is too fast for Mirror, then ignore the packet.
// This is seen sometimes if you stop the client and there's still stuff in the queue.
if (ignoreDataPackets)
{
if (LogType == IgnoranceLogType.Verbose)
Debug.Log("ProcessClientPackets cycle skipped; ignoring data packet");
break;
}
// Otherwise client recieved data, advise Mirror.
// print($"Byte array: {incomingPacket.RentedByteArray.Length}. Packet Length: {incomingPacket.Length}");
payload = incomingPacket.Payload;
int length = payload.Length;
ArraySegment<byte> dataSegment;
// Copy to working buffer and dispose of it.
if (length > InternalPacketBuffer.Length)
{
// Unity's favourite: A fresh 'n' tasty GC Allocation!
byte[] oneFreshNTastyGcAlloc = new byte[length];
payload.CopyTo(oneFreshNTastyGcAlloc);
dataSegment = new ArraySegment<byte>(oneFreshNTastyGcAlloc, 0, length);
}
else
{
payload.CopyTo(InternalPacketBuffer);
dataSegment = new ArraySegment<byte>(InternalPacketBuffer, 0, length);
}
payload.Dispose();
OnClientDataReceived?.Invoke(dataSegment, incomingPacket.Channel);
// Some messages can disable the transport
// If the transport was disabled by any of the messages, we have to break out of the loop and wait until we've been re-enabled.
if (!enabled)
break;
}
// Step 3: Handle other commands.
while (Client.Commands.TryDequeue(out commandPacket))
{
switch (commandPacket.Type)
{
// ...
default:
break;
}
}
// Step 4: Handle status updates.
if (Client.StatusUpdates.TryDequeue(out clientStats))
{
ClientStatistics = clientStats;
}
}
#region Main Thread Processing and Polling
// Ignorance 1.4.0b5: To use Mirror's polling or not use Mirror's polling, that is up to the developer to decide
#if !IGNORANCE_MIRROR_POLLING
// IMPORTANT: Set Ignorance' execution order before everything else. Yes, that's -32000 !!
// This ensures it has priority over other things.
// FixedUpdate can be called many times per frame.
// Once we've handled stuff, we set a flag so that we don't poll again for this frame.
private bool fixedUpdateCompletedWork;
public void FixedUpdate()
{
if (!enabled) return;
if (fixedUpdateCompletedWork) return;
ProcessAndExecuteAllPackets();
// Flip the bool to signal we've done our work.
fixedUpdateCompletedWork = true;
}
// Normally, Mirror blocks Update() due to poor design decisions...
// But thanks to Vincenzo, we've found a way to bypass that block.
// Update is called once per frame. We don't have to worry about this shit now.
public new void Update()
{
if (!enabled) return;
// Process what FixedUpdate missed, only if the boolean is not set.
if (!fixedUpdateCompletedWork)
ProcessAndExecuteAllPackets();
// Flip back the bool, so it can be reset.
fixedUpdateCompletedWork = false;
}
// Processes and Executes All Packets.
private void ProcessAndExecuteAllPackets()
{
// Process Server Events...
if (Server.IsAlive)
ProcessServerPackets();
// Process Client Events...
if (Client.IsAlive)
{
ProcessClientPackets();
if (ClientState == ConnectionState.Connected && clientStatusUpdateInterval > -1)
{
statusUpdateTimer += Time.deltaTime;
if (statusUpdateTimer >= clientStatusUpdateInterval)
{
Client.Commands.Enqueue(new IgnoranceCommandPacket { Type = IgnoranceCommandType.ClientRequestsStatusUpdate });
statusUpdateTimer = 0f;
}
}
}
}
#else
// This section will be compiled in instead if you enable IGNORANCE_MIRROR_POLLING.
public override void ServerEarlyUpdate() {
// This is used by Mirror to consume the incoming server packets.
if (!enabled) return;
// Process Server Events...
if (Server.IsAlive)
ProcessServerPackets();
}
public override void ClientEarlyUpdate() {
// This is used by Mirror to consume the incoming client packets.
if(!enabled) return;
if(Client.IsAlive)
{
ProcessClientPackets();
if (ClientState == ConnectionState.Connected && clientStatusUpdateInterval > -1)
{
statusUpdateTimer += Time.deltaTime;
if (statusUpdateTimer >= clientStatusUpdateInterval)
{
Client.Commands.Enqueue(new IgnoranceCommandPacket { Type = IgnoranceCommandType.ClientRequestsStatusUpdate });
statusUpdateTimer = 0f;
}
}
}
}
/*
public override void ClientLateUpdate() {
// This is used by Mirror to send out the outgoing client packets.
if (!enabled) return;
}
public override void ServerLateUpdate() {
// This is used by Mirror to send out the outgoing server packets.
if (!enabled) return;
}
*/
#endif
#endregion
#region Debug
private void OnGUI()
{
if (DebugDisplay)
GUI.Box(new Rect(
new Vector2(32, Screen.height - 240), new Vector2(200, 160)),
"-- CLIENT --\n" +
$"State: {ClientState}\n" +
$"Incoming Queue: {Client.Incoming.Count}\n" +
$"Outgoing Queue: {Client.Outgoing.Count}\n\n" +
"-- SERVER --\n" +
$"Incoming Queue: {Server.Incoming.Count}\n" +
$"Outgoing Queue: {Server.Outgoing.Count}\n" +
$"ConnEvent Queue: {Server.ConnectionEvents.Count}"
);
}
#endregion
public override int GetMaxPacketSize(int channelId = 0) => MaxAllowedPacketSize;
// UDP Recommended Max MTU = 1200.
public override int GetMaxBatchSize(int channelId) {
bool isFragmentedAlready = ((PacketFlags)Channels[channelId] & ReliableOrUnreliableFragmented) > 0;
return isFragmentedAlready ? MaxAllowedPacketSize : 1200;
}
#region Internals
private bool ignoreDataPackets;
private string cachedConnectionAddress = string.Empty;
private IgnoranceServer Server = new IgnoranceServer();
private IgnoranceClient Client = new IgnoranceClient();
private Dictionary<int, PeerConnectionData> ConnectionLookupDict = new Dictionary<int, PeerConnectionData>();
private enum ConnectionState { Connecting, Connected, Disconnecting, Disconnected }
private ConnectionState ClientState = ConnectionState.Disconnected;
private byte[] InternalPacketBuffer;
private const PacketFlags ReliableOrUnreliableFragmented = PacketFlags.Reliable | PacketFlags.UnreliableFragmented;
private float statusUpdateTimer = 0f;
#endregion
#region Legacy Overrides
#if !MIRROR_37_0_OR_NEWER
public bool ServerDisconnectLegacy(int connectionId)
{
if (Server == null)
{
Debug.LogError("Cannot enqueue kick packet; our Server object is null. Something has gone wrong.");
// Return here because otherwise we will get a NRE when trying to enqueue the kick packet.
return false;
}
IgnoranceCommandPacket kickPacket = new IgnoranceCommandPacket
{
Type = IgnoranceCommandType.ServerKickPeer,
PeerId = (uint)connectionId - 1 // ENet's native peer ID will be ConnID - 1
};
// Pass the packet onto the thread for dispatch.
Server.Commands.Enqueue(kickPacket);
return true;
}
#endif
#endregion
#endif
}
}

11
Assets/Mirror/Runtime/Transport/Ignorance/Ignorance.cs.meta Normal file
View File

@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: 872fa23ef6e77334ca452ce16f6cd091
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: -32000
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

94
Assets/Mirror/Runtime/Transport/Ignorance/IgnoranceDefinitions.cs Normal file
View File

@@ -0,0 +1,94 @@
using System;
using ENet;
namespace IgnoranceTransport
{
// Snipped from the transport files, as this will help
// me keep things up to date.
[Serializable]
public enum IgnoranceChannelTypes
{
Reliable = PacketFlags.Reliable, // TCP Emulation.
ReliableUnsequenced = PacketFlags.Reliable | PacketFlags.Unsequenced, // TCP Emulation, but no sequencing.
Unreliable = PacketFlags.Unsequenced, // Pure UDP.
UnreliableFragmented = PacketFlags.UnreliableFragmented, // Pure UDP, but fragmented.
UnreliableSequenced = PacketFlags.None, // Pure UDP, but sequenced.
Unthrottled = PacketFlags.Unthrottled, // Apparently ENet's version of Taco Bell.
}
public class IgnoranceInternals
{
public const string Version = "1.4.0b6";
public const string Scheme = "enet";
public const string BindAllIPv4 = "0.0.0.0";
public const string BindAllMacs = "::0";
}
public enum IgnoranceLogType
{
Nothing,
Standard,
Verbose
}
// Struct optimized for cache efficiency. (Thanks Vincenzo!)
public struct IgnoranceIncomingPacket
{
public byte Channel;
public uint NativePeerId;
public Packet Payload;
}
// Struct optimized for cache efficiency. (Thanks Vincenzo!)
public struct IgnoranceOutgoingPacket
{
public byte Channel;
public uint NativePeerId;
public Packet Payload;
}
// Struct optimized for cache efficiency. (Thanks Vincenzo!)
public struct IgnoranceConnectionEvent
{
public bool WasDisconnect;
public ushort Port;
public uint NativePeerId;
public string IP;
}
public struct IgnoranceCommandPacket
{
public IgnoranceCommandType Type;
public uint PeerId;
}
public struct IgnoranceClientStats
{
// Stats only - may not always be used!
public uint RTT;
public ulong BytesReceived;
public ulong BytesSent;
public ulong PacketsReceived;
public ulong PacketsSent;
public ulong PacketsLost;
}
public enum IgnoranceCommandType
{
// Client
ClientWantsToStop,
ClientRequestsStatusUpdate,
// ENet internal
ResponseToClientStatusRequest,
// Server
ServerKickPeer
}
// TODO: Optimize struct for Cache performance.
public struct PeerConnectionData
{
public ushort Port;
public uint NativePeerId;
public string IP;
}
}

11
Assets/Mirror/Runtime/Transport/Ignorance/IgnoranceDefinitions.cs.meta Normal file
View File

@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: 3b2d1f7f7d9d3d64297755419f6ab925
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

8
Assets/Mirror/Runtime/Transport/Ignorance/Plugins.meta Normal file
View File

@@ -0,0 +1,8 @@
fileFormatVersion: 2
guid: e8bd04b9965420e40ac911fbf4294e1c
folderAsset: yes
DefaultImporter:
externalObjects: {}
userData:
assetBundleName:
assetBundleVariant:

8
Assets/Mirror/Runtime/Transport/Ignorance/Plugins/Android.meta Normal file
View File

@@ -0,0 +1,8 @@
fileFormatVersion: 2
guid: c90c88052305a054d87177362f63dea8
folderAsset: yes
DefaultImporter:
externalObjects: {}
userData:
assetBundleName:
assetBundleVariant:

8
Assets/Mirror/Runtime/Transport/Ignorance/Plugins/Android/arm64-v8a.meta Normal file
View File

@@ -0,0 +1,8 @@
fileFormatVersion: 2
guid: e4a42b5855436864693138f74335c094
folderAsset: yes
DefaultImporter:
externalObjects: {}
userData:
assetBundleName:
assetBundleVariant:

BIN
Assets/Mirror/Runtime/Transport/Ignorance/Plugins/Android/arm64-v8a/libenet.so Normal file
View File

Binary file not shown.

111
Assets/Mirror/Runtime/Transport/Ignorance/Plugins/Android/arm64-v8a/libenet.so.meta Normal file
View File

@@ -0,0 +1,111 @@
fileFormatVersion: 2
guid: 4b3abd2268dea254da11190b00d16051
PluginImporter:
externalObjects: {}
serializedVersion: 2
iconMap: {}
executionOrder: {}
defineConstraints: []
isPreloaded: 0
isOverridable: 0
isExplicitlyReferenced: 0
validateReferences: 1
platformData:
- first:
: Any
second:
enabled: 0
settings:
Exclude Android: 0
Exclude Editor: 1
Exclude Linux: 1
Exclude Linux64: 1
Exclude LinuxUniversal: 1
Exclude OSXUniversal: 1
Exclude WebGL: 1
Exclude Win: 1
Exclude Win64: 1
Exclude iOS: 1
- first:
Android: Android
second:
enabled: 1
settings:
CPU: ARM64
- first:
Any:
second:
enabled: 0
settings: {}
- first:
Editor: Editor
second:
enabled: 0
settings:
CPU: AnyCPU
DefaultValueInitialized: true
OS: AnyOS
- first:
Facebook: Win
second:
enabled: 0
settings:
CPU: AnyCPU
- first:
Facebook: Win64
second:
enabled: 0
settings:
CPU: AnyCPU
- first:
Standalone: Linux
second:
enabled: 0
settings:
CPU: None
- first:
Standalone: Linux64
second:
enabled: 0
settings:
CPU: None
- first:
Standalone: LinuxUniversal
second:
enabled: 0
settings:
CPU: None
- first:
Standalone: OSXUniversal
second:
enabled: 0
settings:
CPU: None
- first:
Standalone: Win
second:
enabled: 0
settings:
CPU: AnyCPU
- first:
Standalone: Win64
second:
enabled: 0
settings:
CPU: AnyCPU
- first:
WebGL: WebGL
second:
enabled: 0
settings: {}
- first:
iPhone: iOS
second:
enabled: 0
settings:
AddToEmbeddedBinaries: false
CompileFlags:
FrameworkDependencies:
userData:
assetBundleName:
assetBundleVariant:

8
Assets/Mirror/Runtime/Transport/Ignorance/Plugins/Android/armeabi-v7a.meta Normal file
View File

@@ -0,0 +1,8 @@
fileFormatVersion: 2
guid: bfbaf4fbcf8987e4585ca666e28f4871
folderAsset: yes
DefaultImporter:
externalObjects: {}
userData:
assetBundleName:
assetBundleVariant:

BIN
Assets/Mirror/Runtime/Transport/Ignorance/Plugins/Android/armeabi-v7a/libenet.so Normal file
View File

Binary file not shown.

106
Assets/Mirror/Runtime/Transport/Ignorance/Plugins/Android/armeabi-v7a/libenet.so.meta Normal file
View File

@@ -0,0 +1,106 @@
fileFormatVersion: 2
guid: e3ce4b8600e09d74ead46137ba184d01
PluginImporter:
externalObjects: {}
serializedVersion: 2
iconMap: {}
executionOrder: {}
defineConstraints: []
isPreloaded: 0
isOverridable: 0
isExplicitlyReferenced: 0
validateReferences: 1
platformData:
- first:
: Any
second:
enabled: 0
settings:
Exclude Android: 0
Exclude Editor: 1
Exclude Linux: 1
Exclude Linux64: 1
Exclude LinuxUniversal: 1
Exclude OSXUniversal: 1
Exclude WebGL: 1
Exclude Win: 1
Exclude Win64: 1
Exclude iOS: 1
- first:
Android: Android
second:
enabled: 1
settings:
CPU: ARMv7
- first:
Any:
second:
enabled: 0
settings: {}
- first:
Editor: Editor
second:
enabled: 0
settings:
CPU: AnyCPU
DefaultValueInitialized: true
OS: AnyOS
- first:
Facebook: Win
second:
enabled: 0
settings:
CPU: AnyCPU
- first:
Facebook: Win64
second:
enabled: 0
settings:
CPU: AnyCPU
- first:
Standalone: Linux
second:
enabled: 0
settings:
CPU: x86
- first:
Standalone: Linux64
second:
enabled: 0
settings:
CPU: AnyCPU
- first:
Standalone: LinuxUniversal
second:
enabled: 0
settings:
CPU: None
- first:
Standalone: OSXUniversal
second:
enabled: 0
settings:
CPU: AnyCPU
- first:
Standalone: Win
second:
enabled: 0
settings:
CPU: AnyCPU
- first:
Standalone: Win64
second:
enabled: 0
settings:
CPU: AnyCPU
- first:
iPhone: iOS
second:
enabled: 0
settings:
AddToEmbeddedBinaries: false
CompileFlags:
FrameworkDependencies:
userData:
assetBundleName:
assetBundleVariant:

8
Assets/Mirror/Runtime/Transport/Ignorance/Plugins/Android/x86.meta Normal file
View File

@@ -0,0 +1,8 @@
fileFormatVersion: 2
guid: b3486c84aaebff4489e2e11f5bd3030f
folderAsset: yes
DefaultImporter:
externalObjects: {}
userData:
assetBundleName:
assetBundleVariant:

BIN
Assets/Mirror/Runtime/Transport/Ignorance/Plugins/Android/x86/libenet.so Normal file
View File

Binary file not shown.

80
Assets/Mirror/Runtime/Transport/Ignorance/Plugins/Android/x86/libenet.so.meta Normal file
View File

@@ -0,0 +1,80 @@
fileFormatVersion: 2
guid: ba78b07719f786c4cae4c52b9528903f
PluginImporter:
externalObjects: {}
serializedVersion: 2
iconMap: {}
executionOrder: {}
defineConstraints: []
isPreloaded: 0
isOverridable: 0
isExplicitlyReferenced: 0
validateReferences: 1
platformData:
- first:
: Any
second:
enabled: 0
settings:
Exclude Android: 0
Exclude Editor: 1
Exclude Linux64: 1
Exclude OSXUniversal: 1
Exclude Win: 1
Exclude Win64: 1
Exclude iOS: 1
- first:
Android: Android
second:
enabled: 1
settings:
CPU: x86
- first:
Any:
second:
enabled: 0
settings: {}
- first:
Editor: Editor
second:
enabled: 0
settings:
CPU: AnyCPU
DefaultValueInitialized: true
OS: AnyOS
- first:
Standalone: Linux64
second:
enabled: 0
settings:
CPU: None
- first:
Standalone: OSXUniversal
second:
enabled: 0
settings:
CPU: None
- first:
Standalone: Win
second:
enabled: 0
settings:
CPU: None
- first:
Standalone: Win64
second:
enabled: 0
settings:
CPU: None
- first:
iPhone: iOS
second:
enabled: 0
settings:
AddToEmbeddedBinaries: false
CPU: AnyCPU
CompileFlags:
FrameworkDependencies:
userData:
assetBundleName:
assetBundleVariant:

8
Assets/Mirror/Runtime/Transport/Ignorance/Plugins/Linux.meta Normal file
View File

@@ -0,0 +1,8 @@
fileFormatVersion: 2
guid: 8e3ca9b41c9f4064581a6b56ae549a9c
folderAsset: yes
DefaultImporter:
externalObjects: {}
userData:
assetBundleName:
assetBundleVariant:

BIN
Assets/Mirror/Runtime/Transport/Ignorance/Plugins/Linux/libenet.so Normal file
View File

Binary file not shown.

97
Assets/Mirror/Runtime/Transport/Ignorance/Plugins/Linux/libenet.so.meta Normal file
View File

@@ -0,0 +1,97 @@
fileFormatVersion: 2
guid: f2bd341c8082ddd47b4b5cc9bfdf2332
PluginImporter:
externalObjects: {}
serializedVersion: 2
iconMap: {}
executionOrder: {}
defineConstraints: []
isPreloaded: 0
isOverridable: 0
isExplicitlyReferenced: 0
validateReferences: 1
platformData:
- first:
'': Any
second:
enabled: 0
settings:
Exclude Android: 1
Exclude Editor: 0
Exclude Linux: 1
Exclude Linux64: 0
Exclude LinuxUniversal: 0
Exclude OSXUniversal: 1
Exclude WebGL: 1
Exclude Win: 0
Exclude Win64: 0
- first:
Android: Android
second:
enabled: 0
settings:
CPU: ARMv7
- first:
Any:
second:
enabled: 0
settings: {}
- first:
Editor: Editor
second:
enabled: 1
settings:
CPU: x86_64
DefaultValueInitialized: true
OS: Linux
- first:
Facebook: Win
second:
enabled: 0
settings:
CPU: AnyCPU
- first:
Facebook: Win64
second:
enabled: 0
settings:
CPU: AnyCPU
- first:
Standalone: Linux
second:
enabled: 0
settings:
CPU: None
- first:
Standalone: Linux64
second:
enabled: 1
settings:
CPU: x86_64
- first:
Standalone: LinuxUniversal
second:
enabled: 1
settings:
CPU: x86_64
- first:
Standalone: OSXUniversal
second:
enabled: 0
settings:
CPU: None
- first:
Standalone: Win
second:
enabled: 1
settings:
CPU: AnyCPU
- first:
Standalone: Win64
second:
enabled: 1
settings:
CPU: AnyCPU
userData:
assetBundleName:
assetBundleVariant:

8
Assets/Mirror/Runtime/Transport/Ignorance/Plugins/Windows.meta Normal file
View File

@@ -0,0 +1,8 @@
fileFormatVersion: 2
guid: 8837cb1a7320b8b4f824a02e23f4a545
folderAsset: yes
DefaultImporter:
externalObjects: {}
userData:
assetBundleName:
assetBundleVariant:

3
Assets/Mirror/Runtime/Transport/Ignorance/Plugins/Windows/README.txt Normal file
View File

@@ -0,0 +1,3 @@
This is a Windows x64 build of ENet-CSharp.
If you require a version of ENet for 32 Bit computer systems (ie. Windows 7/8/10 32Bit) then please get in touch, or you can install the requirements yourself and compile it using ENet-CSharp's MSBuild-based build system. Get in touch if you want me to compile them for you, but keep in mind that I do not support them when reporting bugs.

7
Assets/Mirror/Runtime/Transport/Ignorance/Plugins/Windows/README.txt.meta Normal file
View File

@@ -0,0 +1,7 @@
fileFormatVersion: 2
guid: 09ee288deb259474c819a5e3daf54b80
TextScriptImporter:
externalObjects: {}
userData:
assetBundleName:
assetBundleVariant:

BIN
Assets/Mirror/Runtime/Transport/Ignorance/Plugins/Windows/enet.dll Normal file
View File

Binary file not shown.

111
Assets/Mirror/Runtime/Transport/Ignorance/Plugins/Windows/enet.dll.meta Normal file
View File

@@ -0,0 +1,111 @@
fileFormatVersion: 2
guid: cc98033c6bc234a419ccd053e7173781
PluginImporter:
externalObjects: {}
serializedVersion: 2
iconMap: {}
executionOrder: {}
defineConstraints: []
isPreloaded: 0
isOverridable: 0
isExplicitlyReferenced: 0
validateReferences: 1
platformData:
- first:
'': Any
second:
enabled: 0
settings:
Exclude Android: 1
Exclude Editor: 0
Exclude Linux: 0
Exclude Linux64: 0
Exclude LinuxUniversal: 0
Exclude OSXUniversal: 0
Exclude WebGL: 1
Exclude Win: 1
Exclude Win64: 0
Exclude iOS: 1
- first:
Android: Android
second:
enabled: 0
settings:
CPU: ARMv7
- first:
Any:
second:
enabled: 0
settings: {}
- first:
Editor: Editor
second:
enabled: 1
settings:
CPU: AnyCPU
DefaultValueInitialized: true
OS: AnyOS
- first:
Facebook: Win
second:
enabled: 0
settings:
CPU: None
- first:
Facebook: Win64
second:
enabled: 0
settings:
CPU: AnyCPU
- first:
Standalone: Linux
second:
enabled: 1
settings:
CPU: x86
- first:
Standalone: Linux64
second:
enabled: 1
settings:
CPU: x86_64
- first:
Standalone: LinuxUniversal
second:
enabled: 1
settings:
CPU: AnyCPU
- first:
Standalone: OSXUniversal
second:
enabled: 1
settings:
CPU: AnyCPU
- first:
Standalone: Win
second:
enabled: 0
settings:
CPU: None
- first:
Standalone: Win64
second:
enabled: 1
settings:
CPU: AnyCPU
- first:
WebGL: WebGL
second:
enabled: 0
settings: {}
- first:
iPhone: iOS
second:
enabled: 0
settings:
AddToEmbeddedBinaries: false
CompileFlags:
FrameworkDependencies:
userData:
assetBundleName:
assetBundleVariant:

8
Assets/Mirror/Runtime/Transport/Ignorance/Plugins/iOS.meta Normal file
View File

@@ -0,0 +1,8 @@
fileFormatVersion: 2
guid: 7edc275f3670f4251b90301cbb9f7413
folderAsset: yes
DefaultImporter:
externalObjects: {}
userData:
assetBundleName:
assetBundleVariant:

BIN
Assets/Mirror/Runtime/Transport/Ignorance/Plugins/iOS/libenet-release-arm64.a Normal file
View File

Binary file not shown.

80
Assets/Mirror/Runtime/Transport/Ignorance/Plugins/iOS/libenet-release-arm64.a.meta Normal file
View File

@@ -0,0 +1,80 @@
fileFormatVersion: 2
guid: 1485de7d76884a64bac00df01454081e
PluginImporter:
externalObjects: {}
serializedVersion: 2
iconMap: {}
executionOrder: {}
defineConstraints: []
isPreloaded: 0
isOverridable: 0
isExplicitlyReferenced: 0
validateReferences: 1
platformData:
- first:
: Any
second:
enabled: 0
settings:
Exclude Android: 1
Exclude Editor: 1
Exclude Linux64: 1
Exclude OSXUniversal: 1
Exclude Win: 1
Exclude Win64: 1
Exclude iOS: 0
- first:
Android: Android
second:
enabled: 0
settings:
CPU: ARMv7
- first:
Any:
second:
enabled: 0
settings: {}
- first:
Editor: Editor
second:
enabled: 0
settings:
CPU: AnyCPU
DefaultValueInitialized: true
OS: AnyOS
- first:
Standalone: Linux64
second:
enabled: 0
settings:
CPU: None
- first:
Standalone: OSXUniversal
second:
enabled: 0
settings:
CPU: None
- first:
Standalone: Win
second:
enabled: 0
settings:
CPU: None
- first:
Standalone: Win64
second:
enabled: 0
settings:
CPU: None
- first:
iPhone: iOS
second:
enabled: 1
settings:
AddToEmbeddedBinaries: false
CPU: ARM64
CompileFlags:
FrameworkDependencies:
userData:
assetBundleName:
assetBundleVariant:

BIN
Assets/Mirror/Runtime/Transport/Ignorance/Plugins/iOS/libenet-release-armv7.a Normal file
View File

Binary file not shown.

80
Assets/Mirror/Runtime/Transport/Ignorance/Plugins/iOS/libenet-release-armv7.a.meta Normal file
View File

@@ -0,0 +1,80 @@
fileFormatVersion: 2
guid: fa239cb4c47fc9447816815f80667fea
PluginImporter:
externalObjects: {}
serializedVersion: 2
iconMap: {}
executionOrder: {}
defineConstraints: []
isPreloaded: 0
isOverridable: 0
isExplicitlyReferenced: 0
validateReferences: 1
platformData:
- first:
: Any
second:
enabled: 0
settings:
Exclude Android: 1
Exclude Editor: 1
Exclude Linux64: 1
Exclude OSXUniversal: 1
Exclude Win: 1
Exclude Win64: 1
Exclude iOS: 0
- first:
Android: Android
second:
enabled: 0
settings:
CPU: ARMv7
- first:
Any:
second:
enabled: 0
settings: {}
- first:
Editor: Editor
second:
enabled: 0
settings:
CPU: AnyCPU
DefaultValueInitialized: true
OS: AnyOS
- first:
Standalone: Linux64
second:
enabled: 0
settings:
CPU: None
- first:
Standalone: OSXUniversal
second:
enabled: 0
settings:
CPU: None
- first:
Standalone: Win
second:
enabled: 0
settings:
CPU: None
- first:
Standalone: Win64
second:
enabled: 0
settings:
CPU: None
- first:
iPhone: iOS
second:
enabled: 1
settings:
AddToEmbeddedBinaries: false
CPU: ARMv7
CompileFlags:
FrameworkDependencies:
userData:
assetBundleName:
assetBundleVariant:

BIN
Assets/Mirror/Runtime/Transport/Ignorance/Plugins/iOS/libenet-release-simulator64.a Normal file
View File

Binary file not shown.

80
Assets/Mirror/Runtime/Transport/Ignorance/Plugins/iOS/libenet-release-simulator64.a.meta Normal file
View File

@@ -0,0 +1,80 @@
fileFormatVersion: 2
guid: 385bb48fb124b5f40a79bdecf421671f
PluginImporter:
externalObjects: {}
serializedVersion: 2
iconMap: {}
executionOrder: {}
defineConstraints: []
isPreloaded: 0
isOverridable: 0
isExplicitlyReferenced: 0
validateReferences: 1
platformData:
- first:
: Any
second:
enabled: 0
settings:
Exclude Android: 1
Exclude Editor: 1
Exclude Linux64: 1
Exclude OSXUniversal: 1
Exclude Win: 1
Exclude Win64: 1
Exclude iOS: 0
- first:
Android: Android
second:
enabled: 0
settings:
CPU: ARMv7
- first:
Any:
second:
enabled: 0
settings: {}
- first:
Editor: Editor
second:
enabled: 0
settings:
CPU: AnyCPU
DefaultValueInitialized: true
OS: AnyOS
- first:
Standalone: Linux64
second:
enabled: 0
settings:
CPU: None
- first:
Standalone: OSXUniversal
second:
enabled: 0
settings:
CPU: None
- first:
Standalone: Win
second:
enabled: 0
settings:
CPU: None
- first:
Standalone: Win64
second:
enabled: 0
settings:
CPU: None
- first:
iPhone: iOS
second:
enabled: 1
settings:
AddToEmbeddedBinaries: false
CPU: X64
CompileFlags:
FrameworkDependencies:
userData:
assetBundleName:
assetBundleVariant:

8
Assets/Mirror/Runtime/Transport/Ignorance/Plugins/macOS.meta Normal file
View File

@@ -0,0 +1,8 @@
fileFormatVersion: 2
guid: 957ba76da095cd64aaa658f034ab78e5
folderAsset: yes
DefaultImporter:
externalObjects: {}
userData:
assetBundleName:
assetBundleVariant:

BIN
Assets/Mirror/Runtime/Transport/Ignorance/Plugins/macOS/libenet.dylib Normal file
View File

Binary file not shown.

32
Assets/Mirror/Runtime/Transport/Ignorance/Plugins/macOS/libenet.dylib.meta Normal file
View File

@@ -0,0 +1,32 @@
fileFormatVersion: 2
guid: 5317859893ad2cf48a6df1d585ebdd2c
PluginImporter:
externalObjects: {}
serializedVersion: 2
iconMap: {}
executionOrder: {}
defineConstraints: []
isPreloaded: 0
isOverridable: 0
isExplicitlyReferenced: 0
validateReferences: 1
platformData:
- first:
Any:
second:
enabled: 0
settings: {}
- first:
Editor: Editor
second:
enabled: 1
settings:
DefaultValueInitialized: true
- first:
Standalone: OSXUniversal
second:
enabled: 1
settings: {}
userData:
assetBundleName:
assetBundleVariant:

35
Assets/Mirror/Runtime/Transport/Ignorance/Plugins/readme.txt Normal file
View File

@@ -0,0 +1,35 @@
ENET Pre-compiled Binary Library Blobs
==========================
This folder contains pre-compiled binaries for a variety of different platforms.
A brief summary of these folders are as follows:
- Windows, Mac, Linux
-- 64bit (x64)
- Android (Kitkat 4.4 minimum target OS)
-- ARMv7 (armeabi-v7a), ARMv8/AArch64 (arm64-v8a)
- iOS
-- FAT Library (armv7 + arm64). Targeted for iOS 8 minimum. Unsigned library.
DEBUG VERSIONS
===============
Debug versions of the libraries can be obtained at https://github.com/SoftwareGuy/ENet-CSharp/releases.
Otherwise you can also compile the library yourself with Debug enabled.
DOT POINTS
===========
1. 32bit Support for Ignorance has been removed. Originally, I did not want to support 32bit operating systems,
however due to some countries in the world still stuck in the 32bit era (Brasil, some Russian areas, etc) I added them as a
goodwill gesture. However, since those who needed the libraries have now vanished, I have stopped building 32bit versions of ENet.
COMPILE THE CODE YOURSELF
=========================
If you don't trust the above binaries then git clone the ENET-CSharp repository (http://github.com/SoftwareGuy/ENet-CSharp) and read the readme.
EXCLUSION INSTRUCTIONS
======================
No need, the meta data will cover that for you.
Still don't know what to do with these? Drop by the Mirror discord and post in the Ignorance channel.

7
Assets/Mirror/Runtime/Transport/Ignorance/Plugins/readme.txt.meta Normal file
View File

@@ -0,0 +1,7 @@
fileFormatVersion: 2
guid: a28193472bc84d341ab4aee18c471a93
TextScriptImporter:
externalObjects: {}
userData:
assetBundleName:
assetBundleVariant:

1
Assets/Mirror/Runtime/Transport/Ignorance/version.txt Normal file
View File

@@ -0,0 +1 @@
1.4.0b6

7
Assets/Mirror/Runtime/Transport/Ignorance/version.txt.meta Normal file
View File

@@ -0,0 +1,7 @@
fileFormatVersion: 2
guid: ad80075449f17c548877161f32a9841a
TextScriptImporter:
externalObjects: {}
userData:
assetBundleName:
assetBundleVariant: