475 lines
21 KiB
C#
475 lines
21 KiB
C#
using Barotrauma.LuaCs;
|
|
using Barotrauma.LuaCs.Compatibility;
|
|
using Barotrauma.LuaCs.Data;
|
|
using Barotrauma.LuaCs.Events;
|
|
using LightInject;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Collections.Immutable;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using System.Runtime.CompilerServices;
|
|
using AssemblyLoader = Barotrauma.LuaCs.AssemblyLoader;
|
|
|
|
[assembly: InternalsVisibleTo("ImpromptuInterfaceDynamicAssembly")]
|
|
[assembly: InternalsVisibleTo("Dynamitey")]
|
|
namespace Barotrauma
|
|
{
|
|
internal delegate void LuaCsMessageLogger(string message);
|
|
internal delegate void LuaCsErrorHandler(Exception ex, LuaCsMessageOrigin origin);
|
|
internal delegate void LuaCsExceptionHandler(Exception ex, LuaCsMessageOrigin origin);
|
|
|
|
partial class LuaCsSetup : IDisposable, IEventScreenSelected, IEventEnabledPackageListChanged,
|
|
IEventReloadAllPackages
|
|
{
|
|
public LuaCsSetup()
|
|
{
|
|
// == startup
|
|
_servicesProvider = SetupServicesProvider();
|
|
_runStateMachine = SetupStateMachine();
|
|
_servicesProvider.GetService<HarmonyEventPatchesService>();
|
|
SubscribeToLuaCsEvents();
|
|
}
|
|
|
|
private void SubscribeToLuaCsEvents()
|
|
{
|
|
EventService.Subscribe<IEventScreenSelected>(this); // game state hook in
|
|
EventService.Subscribe<IEventEnabledPackageListChanged>(this);
|
|
EventService.Subscribe<IEventReloadAllPackages>(this);
|
|
}
|
|
|
|
#region CONST_DEF
|
|
|
|
#if SERVER
|
|
public const bool IsServer = true;
|
|
#else
|
|
public const bool IsServer = false;
|
|
#endif
|
|
public const bool IsClient = !IsServer;
|
|
|
|
#endregion
|
|
|
|
#region Services_CVars
|
|
|
|
/*
|
|
* === Singleton Services
|
|
*/
|
|
|
|
private readonly IServicesProvider _servicesProvider;
|
|
|
|
public PerformanceCounterService PerformanceCounter => _servicesProvider.GetService<PerformanceCounterService>();
|
|
public ILoggerService Logger => _servicesProvider.GetService<ILoggerService>();
|
|
public IConfigService ConfigService => _servicesProvider.GetService<IConfigService>();
|
|
public IPackageManagementService PackageManagementService => _servicesProvider.GetService<IPackageManagementService>();
|
|
public IPluginManagementService PluginManagementService => _servicesProvider.GetService<IPluginManagementService>();
|
|
public ILuaScriptManagementService LuaScriptManagementService => _servicesProvider.GetService<ILuaScriptManagementService>();
|
|
public INetworkingService NetworkingService => _servicesProvider.GetService<INetworkingService>();
|
|
public IEventService EventService => _servicesProvider.GetService<IEventService>();
|
|
public LuaGame Game => _servicesProvider.GetService<LuaGame>();
|
|
|
|
internal IStorageService StorageService => _servicesProvider.GetService<IStorageService>();
|
|
|
|
/// <summary>
|
|
/// Whether C# plugin code is enabled.
|
|
/// </summary>
|
|
public bool IsCsEnabled
|
|
{
|
|
get => _isCsEnabled?.Value ?? false;
|
|
internal set => _isCsEnabled?.TrySetValue(value);
|
|
}
|
|
|
|
private ISettingBase<bool> _isCsEnabled;
|
|
|
|
/// <summary>
|
|
/// Whether the popup error GUI should be hidden/suppressed.
|
|
/// </summary>
|
|
public bool DisableErrorGUIOverlay
|
|
{
|
|
get => _disableErrorGUIOverlay?.Value ?? false;
|
|
internal set => _disableErrorGUIOverlay?.TrySetValue(value);
|
|
}
|
|
private ISettingBase<bool> _disableErrorGUIOverlay;
|
|
|
|
/// <summary>
|
|
/// Whether usernames are anonymized or show in logs.
|
|
/// </summary>
|
|
public bool HideUserNamesInLogs
|
|
{
|
|
get => _hideUserNamesInLogs?.Value ?? false;
|
|
internal set => _hideUserNamesInLogs?.TrySetValue(value);
|
|
}
|
|
private ISettingBase<bool> _hideUserNamesInLogs;
|
|
|
|
/// <summary>
|
|
/// The SteamId of the Workshop LuaCs CPackage in use, if available.
|
|
/// </summary>
|
|
public ulong LuaForBarotraumaSteamId
|
|
{
|
|
get => _luaForBarotraumaSteamId?.Value ?? 0;
|
|
internal set => _luaForBarotraumaSteamId?.TrySetValue(value);
|
|
}
|
|
private ISettingBase<ulong> _luaForBarotraumaSteamId;
|
|
|
|
/// <summary>
|
|
/// Whether the maximum message size over the network should be restricted.
|
|
/// </summary>
|
|
public bool RestrictMessageSize
|
|
{
|
|
get => _restrictMessageSize?.Value ?? false;
|
|
internal set => _restrictMessageSize?.TrySetValue(value);
|
|
}
|
|
private ISettingBase<bool> _restrictMessageSize;
|
|
|
|
/// <summary>
|
|
/// The local save path for all local data storage for mods.
|
|
/// </summary>
|
|
public string LocalDataSavePath
|
|
{
|
|
get => _localDataSavePath?.Value ?? Path.Combine(Directory.GetCurrentDirectory(), "/Data/Mods");
|
|
internal set => _localDataSavePath?.TrySetValue(value);
|
|
}
|
|
private ISettingBase<string> _localDataSavePath;
|
|
|
|
void LoadLuaCsConfig()
|
|
{
|
|
var luaCsPackage = ContentPackageManager.EnabledPackages.Regular.FirstOrDefault(cp => cp.NameMatches("LuaCsForBarotrauma"), null)
|
|
?? ContentPackageManager.LocalPackages.FirstOrDefault(cp => cp.NameMatches("LuaCsForBarotrauma"))
|
|
?? ContentPackageManager.WorkshopPackages.FirstOrDefault(cp => cp.NameMatches("LuaCsForBarotrauma"));
|
|
|
|
_isCsEnabled =
|
|
ConfigService.TryGetConfig<ISettingBase<bool>>(luaCsPackage, "IsCsEnabled", out var val1)
|
|
? val1
|
|
: null;
|
|
_disableErrorGUIOverlay =
|
|
ConfigService.TryGetConfig<ISettingBase<bool>>(luaCsPackage, "DisableErrorGUIOverlay", out var val3)
|
|
? val3
|
|
: null;
|
|
_hideUserNamesInLogs =
|
|
ConfigService.TryGetConfig<ISettingBase<bool>>(luaCsPackage, "HideUserNamesInLogs", out var val4)
|
|
? val4
|
|
: null;
|
|
_luaForBarotraumaSteamId =
|
|
ConfigService.TryGetConfig<ISettingBase<ulong>>(luaCsPackage, "LuaForBarotraumaSteamId", out var val5)
|
|
? val5
|
|
: null;
|
|
_restrictMessageSize =
|
|
ConfigService.TryGetConfig<ISettingBase<bool>>(luaCsPackage, "RestrictMessageSize", out var val7)
|
|
? val7
|
|
: null;
|
|
_localDataSavePath =
|
|
ConfigService.TryGetConfig<ISettingBase<string>>(luaCsPackage, "LocalDataSavePath", out var val8)
|
|
? val8
|
|
: null;
|
|
}
|
|
|
|
private IServicesProvider SetupServicesProvider()
|
|
{
|
|
var servicesProvider = new ServicesProvider();
|
|
|
|
// Base Service
|
|
servicesProvider.RegisterServiceType<ILoggerService, LoggerService>(ServiceLifetime.Singleton);
|
|
servicesProvider.RegisterServiceType<PerformanceCounterService, PerformanceCounterService>(ServiceLifetime.Singleton);
|
|
servicesProvider.RegisterServiceType<IStorageService, StorageService>(ServiceLifetime.Transient);
|
|
servicesProvider.RegisterServiceType<ISafeStorageService, SafeStorageService>(ServiceLifetime.Transient);
|
|
servicesProvider.RegisterServiceType<IEventService, EventService>(ServiceLifetime.Singleton);
|
|
servicesProvider.RegisterServiceResolver<ILuaCsHook>(factory => factory.GetInstance<IEventService>() as ILuaCsHook);
|
|
servicesProvider.RegisterServiceType<IPackageManagementService, PackageManagementService>(ServiceLifetime.Singleton);
|
|
servicesProvider.RegisterServiceType<IAssemblyManagementService, PluginManagementService>(ServiceLifetime.Singleton);
|
|
servicesProvider.RegisterServiceResolver<IPluginManagementService>(factory => factory.GetInstance<IAssemblyManagementService>());
|
|
servicesProvider.RegisterServiceType<ILuaScriptManagementService, LuaScriptManagementService>(ServiceLifetime.Singleton);
|
|
servicesProvider.RegisterServiceType<IConfigService, ConfigService>(ServiceLifetime.Singleton);
|
|
servicesProvider.RegisterServiceType<INetworkingService, NetworkingService>(ServiceLifetime.Singleton);
|
|
servicesProvider.RegisterServiceType<INetworkIdProvider, NetworkingIdProvider>(ServiceLifetime.Transient);
|
|
servicesProvider.RegisterServiceType<HarmonyEventPatchesService, HarmonyEventPatchesService>(ServiceLifetime.Singleton);
|
|
|
|
// Extension/Sub Services
|
|
servicesProvider.RegisterServiceType<IAssemblyLoaderService.IFactory, AssemblyLoader.Factory>(ServiceLifetime.Transient);
|
|
servicesProvider.RegisterServiceType<ISettingsRegistrationProvider, SettingsEntryRegistrar>(ServiceLifetime.Transient);
|
|
servicesProvider.RegisterServiceType<IModConfigService, ModConfigService>(ServiceLifetime.Transient);
|
|
servicesProvider.RegisterServiceType<IParserServiceAsync<ResourceParserInfo, IAssemblyResourceInfo>, ModConfigFileParserService>(ServiceLifetime.Transient);
|
|
servicesProvider.RegisterServiceType<IParserServiceAsync<ResourceParserInfo, ILuaScriptResourceInfo>, ModConfigFileParserService>(ServiceLifetime.Transient);
|
|
servicesProvider.RegisterServiceType<IParserServiceAsync<ResourceParserInfo, IConfigResourceInfo>, ModConfigFileParserService>(ServiceLifetime.Transient);
|
|
servicesProvider.RegisterServiceType<IParserServiceOneToManyAsync<IConfigResourceInfo, IConfigInfo>, SettingsFileParserService>(ServiceLifetime.Transient);
|
|
servicesProvider.RegisterServiceType<IParserServiceOneToManyAsync<IConfigResourceInfo, IConfigProfileInfo>, SettingsFileParserService>(ServiceLifetime.Transient);
|
|
servicesProvider.RegisterServiceType<INetworkIdProvider, NetworkingIdProvider>(ServiceLifetime.Transient);
|
|
|
|
// All Lua Extras
|
|
servicesProvider.RegisterServiceType<IDefaultLuaRegistrar, DefaultLuaRegistrar>(ServiceLifetime.Singleton);
|
|
servicesProvider.RegisterServiceType<ILuaPatcher, LuaPatcherService>(ServiceLifetime.Singleton);
|
|
servicesProvider.RegisterServiceType<ILuaUserDataService, LuaUserDataService>(ServiceLifetime.Singleton);
|
|
servicesProvider.RegisterServiceType<ISafeLuaUserDataService, SafeLuaUserDataService>(ServiceLifetime.Singleton);
|
|
servicesProvider.RegisterServiceType<ILuaCsInfoProvider, LuaCsInfoProvider>(ServiceLifetime.Transient);
|
|
servicesProvider.RegisterServiceType<ILuaScriptLoader, LuaScriptLoader>(ServiceLifetime.Transient);
|
|
servicesProvider.RegisterServiceType<LuaGame, LuaGame>(ServiceLifetime.Singleton);
|
|
servicesProvider.RegisterServiceType<ILuaCsTimer, LuaCsTimer>(ServiceLifetime.Singleton);
|
|
|
|
// service config data
|
|
servicesProvider.RegisterServiceType<IStorageServiceConfig, StorageServiceConfig>(ServiceLifetime.Singleton);
|
|
servicesProvider.RegisterServiceType<ILuaScriptServicesConfig, LuaScriptServicesConfig>(ServiceLifetime.Singleton);
|
|
servicesProvider.RegisterServiceType<IConfigServiceConfig, ConfigServiceConfig>(ServiceLifetime.Singleton);
|
|
servicesProvider.RegisterServiceType<IPackageManagementServiceConfig, PackageManagementServiceConfig>(ServiceLifetime.Singleton);
|
|
|
|
#if CLIENT
|
|
SetupServicesProviderClient(servicesProvider);
|
|
#endif
|
|
|
|
// gen IL
|
|
servicesProvider.CompileAndRun();
|
|
return servicesProvider;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region StateMachine
|
|
|
|
private RunState _runState;
|
|
/// <summary>
|
|
/// The current run state of all services managed by LuaCs.
|
|
/// </summary>
|
|
public RunState CurrentRunState
|
|
{
|
|
get => _runState;
|
|
private set => _runState = value;
|
|
}
|
|
|
|
private readonly StateMachine<RunState> _runStateMachine;
|
|
|
|
public void OnEnabledPackageListChanged(CorePackage package, IEnumerable<RegularPackage> regularPackages)
|
|
{
|
|
ProcessEnabledPackageChanges(new []{ package }.Concat<ContentPackage>(regularPackages).ToImmutableArray());
|
|
}
|
|
|
|
public void OnReloadAllPackages()
|
|
{
|
|
if (CurrentRunState <= RunState.Unloaded)
|
|
{
|
|
return;
|
|
}
|
|
|
|
CoroutineManager.Invoke(() =>
|
|
{
|
|
var state = CurrentRunState;
|
|
SetRunState(RunState.Unloaded);
|
|
SetRunState(state);
|
|
});
|
|
}
|
|
|
|
private void ProcessEnabledPackageChanges(ImmutableArray<ContentPackage> packages)
|
|
{
|
|
if (CurrentRunState < RunState.LoadedNoExec)
|
|
{
|
|
return;
|
|
}
|
|
|
|
var state = CurrentRunState;
|
|
if (CurrentRunState > RunState.LoadedNoExec)
|
|
{
|
|
SetRunState(RunState.LoadedNoExec);
|
|
}
|
|
|
|
this.Logger.LogResults(PackageManagementService.SyncLoadedPackagesList(packages));
|
|
SetRunState(state); // restore
|
|
}
|
|
|
|
private void SetRunState(RunState targetRunState)
|
|
{
|
|
if (CurrentRunState == targetRunState)
|
|
{
|
|
return;
|
|
}
|
|
_runStateMachine.GotoState(targetRunState);
|
|
}
|
|
|
|
private ImmutableArray<ContentPackage> GetEnabledPackagesList()
|
|
{
|
|
var enabledRegular = ContentPackageManager.EnabledPackages.Regular.ToImmutableArray<ContentPackage>();
|
|
if (!enabledRegular.Any(
|
|
p => p.Name.Equals("LuaCsForBarotrauma", StringComparison.InvariantCultureIgnoreCase)
|
|
|| p.Name.Equals("Lua for Barotrauma", StringComparison.InvariantCultureIgnoreCase)))
|
|
{
|
|
var luaCs = ContentPackageManager.AllPackages.FirstOrDefault(
|
|
p => p.Name.Equals("LuaCsForBarotrauma", StringComparison.InvariantCultureIgnoreCase)
|
|
|| p.Name.Equals("Lua For Barotrauma", StringComparison.InvariantCultureIgnoreCase));
|
|
if (luaCs is null)
|
|
{
|
|
DebugConsole.ThrowError($"The 'LuaCsForBarotrauma' mod could not be found. Please subscribe to it and add it to the EnabledPackages List!",
|
|
new NullReferenceException($"The 'LuaCsForBarotrauma' mod could not be found. Please subscribe to it and add it to the EnabledPackages List!"),
|
|
createMessageBox: true);
|
|
return enabledRegular;
|
|
}
|
|
|
|
enabledRegular = new[] { luaCs }.Concat(enabledRegular).ToImmutableArray();
|
|
}
|
|
|
|
return enabledRegular;
|
|
}
|
|
|
|
private StateMachine<RunState> SetupStateMachine()
|
|
{
|
|
return new StateMachine<RunState>(false, RunState.Unloaded, onEnter: RunStateUnloaded_OnEnter, null)
|
|
.AddState(RunState.LoadedNoExec, onEnter: RunStateLoadedNoExec_OnEnter, null)
|
|
.AddState(RunState.Running, onEnter: RunStateRunning_OnEnter, RunStateRunning_OnExit);
|
|
|
|
// ReSharper disable InconsistentNaming
|
|
void RunStateUnloaded_OnEnter(State<RunState> currentState)
|
|
{
|
|
if (PackageManagementService.IsAnyPackageRunning())
|
|
{
|
|
Logger.LogResults(PackageManagementService.StopRunningPackages());
|
|
}
|
|
|
|
if (PackageManagementService.IsAnyPackageLoaded())
|
|
{
|
|
DisposeLuaCsConfig();
|
|
Logger.LogResults(PackageManagementService.UnloadAllPackages());
|
|
}
|
|
|
|
EventService.Reset();
|
|
ConfigService.Reset();
|
|
LuaScriptManagementService.Reset();
|
|
PackageManagementService.Reset();
|
|
NetworkingService.Reset();
|
|
|
|
SubscribeToLuaCsEvents();
|
|
|
|
CurrentRunState = RunState.Unloaded;
|
|
}
|
|
|
|
void RunStateLoadedNoExec_OnEnter(State<RunState> currentState)
|
|
{
|
|
if (PackageManagementService.IsAnyPackageRunning())
|
|
{
|
|
Logger.LogResults(PackageManagementService.StopRunningPackages());
|
|
}
|
|
|
|
if (!PackageManagementService.IsAnyPackageLoaded())
|
|
{
|
|
foreach (var registrationProvider in _servicesProvider.GetAllServices<ISettingsRegistrationProvider>())
|
|
{
|
|
registrationProvider.RegisterTypeProviders(ConfigService, null);
|
|
}
|
|
Logger.LogResults(PackageManagementService.LoadPackagesInfo(GetEnabledPackagesList()));
|
|
Logger.LogResults(ConfigService.LoadSavedConfigsValues());
|
|
LoadLuaCsConfig();
|
|
|
|
}
|
|
|
|
CurrentRunState = RunState.LoadedNoExec;
|
|
}
|
|
|
|
void RunStateRunning_OnEnter(State<RunState> currentState)
|
|
{
|
|
if (!PackageManagementService.IsAnyPackageLoaded())
|
|
{
|
|
foreach (var registrationProvider in _servicesProvider.GetAllServices<ISettingsRegistrationProvider>())
|
|
{
|
|
registrationProvider.RegisterTypeProviders(ConfigService, null);
|
|
}
|
|
Logger.LogResults(PackageManagementService.LoadPackagesInfo(GetEnabledPackagesList()));
|
|
Logger.LogResults(ConfigService.LoadSavedConfigsValues());
|
|
LoadLuaCsConfig();
|
|
}
|
|
|
|
if (!PackageManagementService.IsAnyPackageRunning())
|
|
{
|
|
Logger.LogResults(PackageManagementService.ExecuteLoadedPackages(GetEnabledPackagesList(), IsCsEnabled));
|
|
}
|
|
|
|
#if CLIENT
|
|
// Technically not very accurate, but we want to call after we run mods anyway
|
|
if (GameMain.Client != null)
|
|
{
|
|
EventService.PublishEvent<IEventServerConnected>(static p => p.OnServerConnected());
|
|
}
|
|
#endif
|
|
CurrentRunState = RunState.Running;
|
|
}
|
|
|
|
void RunStateRunning_OnExit(State<RunState> currentState)
|
|
{
|
|
Logger.LogResults(PackageManagementService.StopRunningPackages());
|
|
}
|
|
// ReSharper restore InconsistentNaming
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region LegacyRedirects
|
|
|
|
public ILuaCsHook Hook => this.EventService;
|
|
public INetworkingService Networking => this.NetworkingService;
|
|
|
|
#endregion
|
|
|
|
public void Dispose()
|
|
{
|
|
try
|
|
{
|
|
SetRunState(RunState.Unloaded);
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
Logger.LogError(e.Message);
|
|
}
|
|
|
|
try
|
|
{
|
|
DisposeLuaCsConfig();
|
|
|
|
PluginManagementService.Dispose();
|
|
LuaScriptManagementService.Dispose();
|
|
ConfigService.Dispose();
|
|
PackageManagementService.Dispose();
|
|
// TODO: Add all missing services.
|
|
//NetworkingService.Dispose();
|
|
EventService.Dispose();
|
|
|
|
_servicesProvider.DisposeAndReset();
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
Console.WriteLine(e);
|
|
throw;
|
|
}
|
|
|
|
GC.SuppressFinalize(this);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Handles changes in game states tracked by screen changes.
|
|
/// </summary>
|
|
/// <param name="screen">The new game screen.</param>
|
|
public partial void OnScreenSelected(Screen screen);
|
|
|
|
void DisposeLuaCsConfig()
|
|
{
|
|
_isCsEnabled = null;
|
|
_disableErrorGUIOverlay = null;
|
|
_hideUserNamesInLogs = null;
|
|
_luaForBarotraumaSteamId = null;
|
|
_restrictMessageSize = null;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Specifies the current run state of the LuaCs Modding System.
|
|
/// <b>[Important]Enum State values ordering must be in the form of (lower state) === (higher state)</b>
|
|
/// </summary>
|
|
public enum RunState : byte
|
|
{
|
|
/// <summary>
|
|
/// No assets are loaded, code execution suspended.
|
|
/// </summary>
|
|
Unloaded = 0,
|
|
/// <summary>
|
|
/// Loaded mod configs, settings and assets. No code execution.
|
|
/// </summary>
|
|
LoadedNoExec = 1,
|
|
/// <summary>
|
|
/// All assets loaded, code execution is active.
|
|
/// </summary>
|
|
Running = 2
|
|
}
|
|
}
|
|
|