private static void Main(string[] args)
{
Log.SetLevel(Log.LogLevel.Info | Log.LogLevel.Debug);
NitroxServiceLocator.InitializeDependencyContainer(new ServerAutoFacRegistrar());
NitroxServiceLocator.BeginNewLifetimeScope();
ConfigureCultureInfo();
Server server;
try
{
server = NitroxServiceLocator.LocateService <Server>();
server.Start();
}
catch (Exception e)
{
Log.Error(e.ToString());
return;
}
CatchExitEvent();
ConsoleCommandProcessor cmdProcessor = NitroxServiceLocator.LocateService <ConsoleCommandProcessor>();
while (server.IsRunning)
{
cmdProcessor.ProcessCommand(Console.ReadLine(), Optional <Player> .Empty(), Perms.CONSOLE);
}
}
public void AllPacketsAreHandled()
{
List <Type> packetTypes = typeof(DefaultServerPacketProcessor).Assembly.GetTypes()
.Where(p => typeof(PacketProcessor).IsAssignableFrom(p) && p.IsClass && !p.IsAbstract)
.ToList();
NitroxServiceLocator.InitializeDependencyContainer(new ClientAutoFacRegistrar(), new SubnauticaServerAutoFacRegistrar(), new TestAutoFacRegistrar());
NitroxServiceLocator.BeginNewLifetimeScope();
foreach (Type packet in typeof(Packet).Assembly.GetTypes()
.Where(p => typeof(Packet).IsAssignableFrom(p) && p.IsClass && !p.IsAbstract)
.ToList())
{
Type clientPacketProcessorType = typeof(ClientPacketProcessor <>);
Type authenticatedPacketProcessorType = typeof(AuthenticatedPacketProcessor <>);
Type unauthenticatedPacketProcessorType = typeof(UnauthenticatedPacketProcessor <>);
Type clientProcessorType = clientPacketProcessorType.MakeGenericType(packet);
Type authProcessorType = authenticatedPacketProcessorType.MakeGenericType(packet);
Type unauthProcessorType = unauthenticatedPacketProcessorType.MakeGenericType(packet);
Console.WriteLine($@"Checking handler for packet {packet}...");
(packetTypes.Contains(packet) ||
NitroxServiceLocator.LocateOptionalService(clientProcessorType).HasValue ||
NitroxServiceLocator.LocateOptionalService(authProcessorType).HasValue ||
NitroxServiceLocator.LocateOptionalService(unauthProcessorType).HasValue).Should()
.BeTrue($"Packet of type '{packet}' should have at least one processor.");
}
}
public void Setup()
{
NitroxServiceLocator.InitializeDependencyContainer(new SubnauticaServerAutoFacRegistrar(), new TestAutoFacRegistrar());
NitroxServiceLocator.BeginNewLifetimeScope();
tempSaveFilePath = Path.Combine(Path.GetTempPath(), "NitroxTestTempDir");
serverSerializers = NitroxServiceLocator.LocateService <IServerSerializer[]>();
worldPersistence = NitroxServiceLocator.LocateService <WorldPersistence>();
serverConfig = NitroxServiceLocator.LocateService <ServerConfig>();
worldData = GeneratePersistedWorldData();
world = worldPersistence.CreateWorld(worldData, serverConfig.GameMode);
worldsDataAfter = new PersistedWorldData[serverSerializers.Length];
for (int index = 0; index < serverSerializers.Length; index++)
{
worldPersistence.UpdateSerializer(serverSerializers[index]);
Assert.IsTrue(worldPersistence.Save(world, tempSaveFilePath));
Assert.IsFalse(worldPersistence.Save(null, tempSaveFilePath));
worldPersistence.UpdateSerializer(serverSerializers[index]);
Optional <World> worldAfter = worldPersistence.LoadFromFile(tempSaveFilePath);
Assert.IsTrue(worldAfter.HasValue);
worldsDataAfter[index] = PersistedWorldData.From(worldAfter.Value);
}
}
public static void BeforeAll(TestContext context)
{
TestAutoFacRegistrar registrar = new TestAutoFacRegistrar();
NitroxServiceLocator.InitializeDependencyContainer(registrar);
NitroxServiceLocator.BeginNewLifetimeScope();
}
static void Main(string[] args)
{
Log.SetLevel(Log.LogLevel.ConsoleInfo | Log.LogLevel.ConsoleDebug | Log.LogLevel.FileLog);
NitroxServiceLocator.InitializeDependencyContainer(new ServerAutoFacRegistrar());
NitroxServiceLocator.BeginNewLifetimeScope();
configureCultureInfo();
Server server;
try
{
server = NitroxServiceLocator.LocateService <Server>();
server.Start();
}
catch (Exception e)
{
Log.Error(e.ToString());
return;
}
ConsoleCommandProcessor CmdProcessor = NitroxServiceLocator.LocateService <ConsoleCommandProcessor>();
while (server.IsRunning)
{
CmdProcessor.ProcessCommand(Console.ReadLine());
}
}
private static void Initialize()
{
Optional.ApplyHasValueCondition <UnityEngine.Object>(o => (bool)o);
if (container != null)
{
throw new Exception($"Patches have already been detected! Call {nameof(Apply)} or {nameof(Restore)} instead.");
}
Log.Info("Registering dependencies");
container = CreatePatchingContainer();
try
{
NitroxServiceLocator.InitializeDependencyContainer(new ClientAutoFacRegistrar());
}
catch (ReflectionTypeLoadException ex)
{
Log.Error($"Failed to load one or more dependency types for Nitrox. Assembly: {ex.Types.FirstOrDefault()?.Assembly.FullName ?? "unknown"}");
foreach (Exception loaderEx in ex.LoaderExceptions)
{
Log.Error(loaderEx);
}
throw;
}
catch (Exception ex)
{
Log.Error(ex, "Error while initializing and loading dependencies.");
throw;
}
InitPatches();
ApplyNitroxBehaviours();
}
private static void Main(string[] args)
{
ConfigureConsoleWindow();
ConfigureCultureInfo();
NitroxModel.Helper.Map.Main = new SubnauticaMap();
NitroxServiceLocator.InitializeDependencyContainer(new SubnauticaServerAutoFacRegistrar());
NitroxServiceLocator.BeginNewLifetimeScope();
Server server;
try
{
server = NitroxServiceLocator.LocateService <Server>();
server.Start();
}
catch (Exception e)
{
Log.Error(e.ToString());
return;
}
CatchExitEvent();
ConsoleCommandProcessor cmdProcessor = NitroxServiceLocator.LocateService <ConsoleCommandProcessor>();
while (server.IsRunning)
{
cmdProcessor.ProcessCommand(Console.ReadLine(), Optional.Empty, Perms.CONSOLE);
}
}
public void RuntimeDetectsAllClientPacketProcessors()
{
ContainerBuilder containerBuilder = new ContainerBuilder();
ClientAutoFacRegistrar clientDependencyRegistrar = new ClientAutoFacRegistrar();
NitroxServiceLocator.InitializeDependencyContainer(clientDependencyRegistrar);
NitroxServiceLocator.BeginNewLifetimeScope();
// Check if every PacketProcessor has been detected:
typeof(Multiplayer).Assembly.GetTypes()
.Where(p => typeof(PacketProcessor).IsAssignableFrom(p) && p.IsClass && !p.IsAbstract)
.ToList()
.ForEach(processor =>
{
try
{
Assert.IsTrue(NitroxServiceLocator.LocateOptionalService(processor.BaseType).IsPresent(),
$"{processor} has not been discovered by the runtime code!");
}
catch (Autofac.Core.DependencyResolutionException ex)
{
if (ex.InnerException.GetType() != typeof(System.Security.SecurityException))
{
throw ex;
}
}
}
);
}
public void AllPacketsAreHandled()
{
World world = new World();
ContainerBuilder serverContainerBuilder = new ContainerBuilder();
ServerAutoFacRegistrar serverDependencyRegistrar = new ServerAutoFacRegistrar();
NitroxServiceLocator.InitializeDependencyContainer(serverDependencyRegistrar);
NitroxServiceLocator.BeginNewLifetimeScope();
List <Type> packetTypes = typeof(DefaultServerPacketProcessor).Assembly.GetTypes()
.Where(p => typeof(PacketProcessor).IsAssignableFrom(p) && p.IsClass && !p.IsAbstract)
.ToList();
ContainerBuilder containerBuilder = new ContainerBuilder();
ClientAutoFacRegistrar clientDependencyRegistrar = new ClientAutoFacRegistrar();
NitroxServiceLocator.InitializeDependencyContainer(clientDependencyRegistrar);
NitroxServiceLocator.BeginNewLifetimeScope();
typeof(Packet).Assembly.GetTypes()
.Where(p => typeof(Packet).IsAssignableFrom(p) && p.IsClass && !p.IsAbstract)
.ToList()
.ForEach(packet =>
{
Type clientPacketProcessorType = typeof(ClientPacketProcessor <>);
Type clientProcessorType = clientPacketProcessorType.MakeGenericType(packet);
Console.WriteLine("Checking handler for packet {0}...", packet);
Assert.IsTrue(packetTypes.Contains(packet) || NitroxServiceLocator.LocateOptionalService(clientProcessorType).IsPresent(),
$"Runtime has not detected a handler for {packet}!");
}
);
}
public static void ClassInitialize(TestContext context)
{
NitroxServiceLocator.InitializeDependencyContainer(new SubnauticaServerAutoFacRegistrar(), new TestAutoFacRegistrar());
NitroxServiceLocator.BeginNewLifetimeScope();
WorldPersistence worldPersistence = NitroxServiceLocator.LocateService <WorldPersistence>();
serverSerializers = NitroxServiceLocator.LocateService <IServerSerializer[]>();
worldsDataAfter = new PersistedWorldData[serverSerializers.Length];
tempSaveFilePath = Path.Combine(Path.GetTempPath(), "NitroxTestTempDir");
worldData = GeneratePersistedWorldData();
World world = worldPersistence.CreateWorld(worldData, ServerGameMode.CREATIVE);
world.EventTriggerer.ResetWorldTime();
for (int index = 0; index < serverSerializers.Length; index++)
{
//Checking saving
worldPersistence.UpdateSerializer(serverSerializers[index]);
Assert.IsTrue(worldPersistence.Save(world, tempSaveFilePath), $"Saving normal world failed while using {serverSerializers[index]}.");
Assert.IsFalse(worldPersistence.Save(null, tempSaveFilePath), $"Saving null world worked while using {serverSerializers[index]}.");
//Checking loading
Optional <World> worldAfter = worldPersistence.LoadFromFile(tempSaveFilePath);
Assert.IsTrue(worldAfter.HasValue, $"Loading saved world failed while using {serverSerializers[index]}.");
worldAfter.Value.EventTriggerer.ResetWorldTime();
worldsDataAfter[index] = PersistedWorldData.From(worldAfter.Value);
}
}
private static void Main(string[] args)
{
ConfigureCultureInfo();
Log.Setup();
ConfigureConsoleWindow();
// Allow game path to be given as command argument
if (args.Length > 0 && Directory.Exists(args[0]) && File.Exists(Path.Combine(args[0], "Subnautica.exe")))
{
string gameDir = Path.GetFullPath(args[0]);
Log.Info($"Using game files from: {gameDir}");
gameInstallDir = new Lazy <string>(() => gameDir);
}
else
{
gameInstallDir = new Lazy <string>(() =>
{
string gameDir = GameInstallationFinder.Instance.FindGame();
Log.Info($"Using game files from: {gameDir}");
return(gameDir);
});
}
AppDomain.CurrentDomain.AssemblyResolve += CurrentDomainOnAssemblyResolve;
AppDomain.CurrentDomain.ReflectionOnlyAssemblyResolve += CurrentDomainOnAssemblyResolve;
NitroxModel.Helper.Map.Main = new SubnauticaMap();
NitroxServiceLocator.InitializeDependencyContainer(new SubnauticaServerAutoFacRegistrar());
NitroxServiceLocator.BeginNewLifetimeScope();
Server server;
try
{
server = NitroxServiceLocator.LocateService <Server>();
Log.Info($"Loaded save\n{server.SaveSummary}");
if (!server.Start())
{
Log.Error("Unable to start server.");
Console.WriteLine("\nPress any key to continue..");
Console.ReadKey(true);
}
}
catch (Exception ex)
{
Log.Error(ex);
return;
}
CatchExitEvent();
ConsoleCommandProcessor cmdProcessor = NitroxServiceLocator.LocateService <ConsoleCommandProcessor>();
while (server.IsRunning)
{
cmdProcessor.ProcessCommand(Console.ReadLine(), Optional.Empty, Perms.CONSOLE);
}
}
public MultiplayerClient(ulong playerId)
{
Log.SetLevel(Log.LogLevel.ConsoleInfo | Log.LogLevel.ConsoleDebug);
playerName = "Player" + playerId.ToString();
NitroxServiceLocator.InitializeDependencyContainer(new ClientAutoFaqRegistrar());
packetReceiver = NitroxServiceLocator.LocateService <DeferringPacketReceiver>();
multiplayerSession = NitroxServiceLocator.LocateService <IMultiplayerSession>();
}
public void TestInitialize()
{
NitroxServiceLocator.InitializeDependencyContainer(new ClientAutoFacRegistrar(), new TestAutoFacRegistrar());
NitroxServiceLocator.BeginNewLifetimeScope();
packetReceiver = NitroxServiceLocator.LocateService <PacketReceiver>();
loadedCell = new AbsoluteEntityCell(loadedActionPosition, CELL_LEVEL);
unloadedCell = new AbsoluteEntityCell(unloadedActionPosition, CELL_LEVEL);
visibleCells.Add(loadedCell);
}
public static void Execute()
{
Log.SetLevel(Log.LogLevel.ConsoleInfo | Log.LogLevel.ConsoleDebug | Log.LogLevel.InGameMessages | Log.LogLevel.FileLog);
if (patches != null)
{
Log.Warn("Patches have already been detected! Call Apply or Restore instead.");
return;
}
Log.Info("Registering Dependencies");
// Our application's entry point. First, register client dependencies with AutoFac.
NitroxServiceLocator.InitializeDependencyContainer(new ClientAutoFacRegistrar());
Log.Info("Patching Subnautica...");
// Enabling this creates a log file on your desktop (why there?), showing the emitted IL instructions.
HarmonyInstance.DEBUG = false;
IEnumerable <NitroxPatch> discoveredPatches = Assembly.GetExecutingAssembly()
.GetTypes()
.Where(p => typeof(NitroxPatch).IsAssignableFrom(p) &&
p.IsClass && !p.IsAbstract
)
.Select(Activator.CreateInstance)
.Cast <NitroxPatch>();
IEnumerable <IGrouping <string, NitroxPatch> > splittedPatches = discoveredPatches.GroupBy(p => p.GetType().Namespace);
splittedPatches.First(g => g.Key == "NitroxPatcher.Patches.Persistent").ForEach(p =>
{
Log.Info("Applying persistent patch " + p.GetType());
p.Patch(harmony);
});
patches = splittedPatches.First(g => g.Key == "NitroxPatcher.Patches").ToArray();
Multiplayer.OnBeforeMultiplayerStart += Apply;
Multiplayer.OnAfterMultiplayerEnd += Restore;
Log.Info("Completed patching using " + Assembly.GetExecutingAssembly().FullName);
Log.Info("Enabling developer console.");
DevConsole.disableConsole = false;
Application.runInBackground = true;
Log.Info($"Unity run in background set to {Application.runInBackground.ToString().ToUpperInvariant()}.");
ApplyNitroxBehaviours();
}
public static void Execute()
{
Log.EnableInGameMessages();
if (container != null)
{
Log.Warn("Patches have already been detected! Call Apply or Restore instead.");
return;
}
Log.Info("Registering Dependencies");
container = CreatePatchingContainer();
NitroxServiceLocator.InitializeDependencyContainer(new ClientAutoFacRegistrar());
InitPatches();
ApplyNitroxBehaviours();
}
public static void Execute()
{
Log.Setup(true);
Optional.ApplyHasValueCondition <Object>(o => (bool)o);
if (container != null)
{
Log.Warn($"Patches have already been detected! Call {nameof(Apply)} or {nameof(Restore)} instead.");
return;
}
Log.Info("Registering dependencies");
container = CreatePatchingContainer();
NitroxServiceLocator.InitializeDependencyContainer(new ClientAutoFacRegistrar());
InitPatches();
ApplyNitroxBehaviours();
}
public void RuntimeDetectsAllServerPacketProcessors()
{
World world = new World();
ContainerBuilder containerBuilder = new ContainerBuilder();
ServerAutoFacRegistrar serverDependencyRegistrar = new NitroxServer_Subnautica.SubnauticaServerAutoFacRegistrar();
NitroxServiceLocator.InitializeDependencyContainer(serverDependencyRegistrar);
NitroxServiceLocator.BeginNewLifetimeScope();
// Check if every PacketProcessor has been detected:
typeof(DefaultServerPacketProcessor).Assembly.GetTypes()
.Where(p => typeof(PacketProcessor).IsAssignableFrom(p) && p.IsClass && !p.IsAbstract)
.ToList()
.ForEach(processor =>
Assert.IsTrue(NitroxServiceLocator.LocateOptionalService(processor.BaseType).IsPresent(),
$"{processor} has not been discovered by the runtime code!")
);
}
public void SameAmountOfServerPacketProcessors()
{
IEnumerable <Type> processors = typeof(PacketHandler).Assembly.GetTypes()
.Where(p => typeof(PacketProcessor).IsAssignableFrom(p) && p.IsClass && !p.IsAbstract);
ServerAutoFacRegistrar serverDependencyRegistrar = new ServerAutoFacRegistrar();
NitroxServiceLocator.InitializeDependencyContainer(serverDependencyRegistrar);
NitroxServiceLocator.BeginNewLifetimeScope();
List <Type> packetTypes = typeof(DefaultServerPacketProcessor).Assembly.GetTypes()
.Where(p => typeof(PacketProcessor).IsAssignableFrom(p) && p.IsClass && !p.IsAbstract)
.ToList();
int both = packetTypes.Count;
Assert.AreEqual(processors.Count(),
both,
"Not all(Un) AuthenticatedPacketProcessors have been discovered by the runtime code " +
$"(auth + unauth: {both} out of {processors.Count()}). " + // this is a small patch to keep this alive a little longer until its put out of its misery
"Perhaps the runtime matching code is too strict, or a processor does not derive from ClientPacketProcessor " +
"(and will hence not be detected).");
}
private static void Main(string[] args)
{
ConfigureConsoleWindow();
ConfigureCultureInfo();
NitroxModel.Helper.Map.Main = new SubnauticaMap();
NitroxServiceLocator.InitializeDependencyContainer(new SubnauticaServerAutoFacRegistrar());
NitroxServiceLocator.BeginNewLifetimeScope();
Server server;
try
{
server = NitroxServiceLocator.LocateService <Server>();
Log.Info($"Loaded save\n{server.SaveSummary}");
if (!server.Start())
{
Log.Error("Unable to start server.");
Console.WriteLine("\nPress any key to continue..");
Console.ReadKey(true);
}
}
catch (Exception e)
{
Log.Error(e.ToString());
return;
}
CatchExitEvent();
ConsoleCommandProcessor cmdProcessor = NitroxServiceLocator.LocateService <ConsoleCommandProcessor>();
while (server.IsRunning)
{
cmdProcessor.ProcessCommand(Console.ReadLine(), Optional.Empty, Perms.CONSOLE);
}
}
public static void BeforeAll(TestContext context)
{
NitroxServiceLocator.InitializeDependencyContainer(new DependencyInjectionTestsAutoFacRegistrar());
NitroxServiceLocator.BeginNewLifetimeScope();
}
private static async Task Main(string[] args)
{
// The thread that writers to console is paused while selecting text in console. So console writer needs to be async.
Log.Setup(asyncConsoleWriter: true, isConsoleApp: true);
AppDomain.CurrentDomain.UnhandledException += CurrentDomainOnUnhandledException;
ConfigureCultureInfo();
AppMutex.Hold(() =>
{
Log.Info("Waiting for 30 seconds on other Nitrox servers to initialize before starting..");
}, 30000);
Server server;
try
{
// Allow game path to be given as command argument
if (args.Length > 0 && Directory.Exists(args[0]) && File.Exists(Path.Combine(args[0], "Subnautica.exe")))
{
string gameDir = Path.GetFullPath(args[0]);
Log.Info($"Using game files from: {gameDir}");
gameInstallDir = new Lazy <string>(() => gameDir);
}
else
{
gameInstallDir = new Lazy <string>(() =>
{
string gameDir = GameInstallationFinder.Instance.FindGame();
Log.Info($"Using game files from: {gameDir}");
return(gameDir);
});
}
AppDomain.CurrentDomain.AssemblyResolve += CurrentDomainOnAssemblyResolve;
AppDomain.CurrentDomain.ReflectionOnlyAssemblyResolve += CurrentDomainOnAssemblyResolve;
Map.Main = new SubnauticaMap();
NitroxServiceLocator.InitializeDependencyContainer(new SubnauticaServerAutoFacRegistrar());
NitroxServiceLocator.BeginNewLifetimeScope();
server = NitroxServiceLocator.LocateService <Server>();
await WaitForAvailablePortAsync(server.Port);
if (!server.Start())
{
throw new Exception("Unable to start server.");
}
Log.Info("Server is waiting for players!");
CatchExitEvent();
}
finally
{
// Allow other servers to start initializing.
AppMutex.Release();
}
Log.Info("To get help for commands, run help in console or /help in chatbox");
ConsoleCommandProcessor cmdProcessor = NitroxServiceLocator.LocateService <ConsoleCommandProcessor>();
while (server.IsRunning)
{
cmdProcessor.ProcessCommand(Console.ReadLine(), Optional.Empty, Perms.CONSOLE);
}
}
