public async Task <IVehicleShop> AddVehicleShopBuyable(string id, decimal price)
{
var data = await GetVehicleShopData(id);
var dbContext = GetDbContext();
if (data == null)
{
data = new VehicleShopModel
{
VehicleId = id,
BuyPrice = price
};
await dbContext.VehicleShops.AddAsync(data);
}
else
{
data.BuyPrice = price;
dbContext.VehicleShops.Update(data);
}
await dbContext.SaveChangesAsync();
return(ActivatorUtilitiesEx.CreateInstance <VehicleShop>(GetPluginScope(), data));
}
public async Task <IItemShop> AddItemShopSellable(string id, decimal price)
{
var data = await GetItemShopData(id);
var dbContext = GetDbContext();
if (data == null)
{
data = new ItemShopModel
{
ItemId = id,
SellPrice = price
};
await dbContext.ItemShops.AddAsync(data);
}
else
{
data.SellPrice = price;
dbContext.ItemShops.Update(data);
}
await dbContext.SaveChangesAsync();
return(ActivatorUtilitiesEx.CreateInstance <ItemShop>(GetPluginScope(), data));
}
public JobScheduler(
IRuntime runtime,
ILogger <JobScheduler> logger,
IDataStoreFactory dataStoreFactory,
IOptions <JobExecutorOptions> options)
{
m_Runtime = runtime;
m_Logger = logger;
m_DataStore = dataStoreFactory.CreateDataStore(new DataStoreCreationParameters
{
Component = runtime,
LogOnChange = true,
WorkingDirectory = runtime.WorkingDirectory
});
AsyncHelper.RunSync(ReadJobsFileAsync);
m_ScheduledJobs = new List <ScheduledJob>();
m_DataStore.AddChangeWatcher(c_DataStoreKey, runtime, () =>
{
m_ScheduledJobs.Clear();
AsyncHelper.RunSync(() => StartAsync(isFromFileChange: true));
});
m_JobExecutors = new List <ITaskExecutor>();
foreach (var provider in options.Value.JobExecutorTypes)
{
m_JobExecutors.Add(
(ITaskExecutor)ActivatorUtilitiesEx.CreateInstance(runtime.LifetimeScope, provider));
}
}
public IDataStore CreateDataStore(DataStoreCreationParameters parameters)
{
var lifetime = parameters.Component?.LifetimeScope
?? m_ServiceProvider.GetRequiredService <IRuntime>().LifetimeScope;
return(ActivatorUtilitiesEx.CreateInstance <YamlDataStore>(lifetime, parameters));
}
[EventListener(Priority = EventListenerPriority.Lowest)] // Lowest so it starts up as early as possible
public Task HandleEventAsync(object?sender, OpenModInitializedEvent @event)
{
var bind = m_OpenModConfiguration.GetSection("rcon:bind").Get <string>();
var cancellationToken = GetCancellationToken();
var sourceRconEnabled = m_OpenModConfiguration.GetSection("rcon:srcds:enabled").Get <bool>();
if (sourceRconEnabled)
{
var port = m_OpenModConfiguration.GetSection("rcon:srcds:port").Get <int>();
var endpoint = new IPEndPoint(IPAddress.Parse(bind), port);
var sourceRconListener = ActivatorUtilitiesEx.CreateInstance <SourceRconHost>(m_Runtime.LifetimeScope);
Task.Run(() => sourceRconListener.StartListeningAsync(endpoint, cancellationToken), cancellationToken);
}
var minecraftRconEnabled = m_OpenModConfiguration.GetSection("rcon:minecraft:enabled").Get <bool>();
if (minecraftRconEnabled)
{
var port = m_OpenModConfiguration.GetSection("rcon:minecraft:port").Get <int>();
var endpoint = new IPEndPoint(IPAddress.Parse(bind), port);
var minecraftRconListener = ActivatorUtilitiesEx.CreateInstance <MinecraftRconHost>(m_Runtime.LifetimeScope);
Task.Run(() => minecraftRconListener.StartListeningAsync(endpoint, cancellationToken), cancellationToken);
}
return(Task.CompletedTask);
}
public async Task InitAsync(ILifetimeScope lifetimeScope)
{
if (m_LifetimeScope != null && lifetimeScope != m_LifetimeScope)
{
return;
}
m_LifetimeScope = lifetimeScope;
var configuration = lifetimeScope.Resolve <IConfiguration>();
m_Plugin = lifetimeScope.Resolve <Kits>();
var configType = configuration["database:connectionType"];
var database = m_Options.GetPreferredDatabase(configType);
if (database == null)
{
m_Database = ActivatorUtilitiesEx.CreateInstance <DataStoreKitDatabase>(lifetimeScope);
m_Logger.LogWarning(
$"Unable to parse {configType}. Setting to default: `datastore`");
}
else
{
m_Logger.LogInformation($"Datastore type set to `{configType}`");
m_Database = (IKitDatabaseProvider)ActivatorUtilitiesEx.CreateInstance(lifetimeScope, database);
}
m_ConfigurationChangedWatcher = m_EventBus.Subscribe <PluginConfigurationChangedEvent>(m_Plugin,
PluginConfigurationChanged);
await m_Database.LoadDatabaseAsync();
await RegisterPermissionsAsync();
}
private void StartRocketModRcon(string bind, int port)
{
var cancellationToken = GetCancellationToken();
var endpoint = new IPEndPoint(IPAddress.Parse(bind), port);
var rocketRconListener = ActivatorUtilitiesEx.CreateInstance <RocketModRconHost>(m_Runtime.LifetimeScope);
Task.Run(() => rocketRconListener.StartListeningAsync(endpoint, cancellationToken), cancellationToken);
}
public async Task <IVehicleShop?> GetVehicleShop(string id)
{
var data = await GetVehicleShopData(id);
return(data == null
? null
: ActivatorUtilitiesEx.CreateInstance <VehicleShop>(GetPluginScope(), data));
}
public UserManager(IOptions <UserManagerOptions> options, ILifetimeScope lifetimeScope)
{
m_UserProviders = new List <IUserProvider>();
foreach (var provider in options.Value.UserProviderTypes)
{
m_UserProviders.Add((IUserProvider)ActivatorUtilitiesEx.CreateInstance(lifetimeScope, provider));
}
}
public static TContainer WithOpenModConsole <TContainer>(
this TContainer @this,
string baseRoute,
IServiceProvider serviceProvider)
where TContainer : class, IWebModuleContainer
{
var lifetime = serviceProvider.GetRequiredService <ILifetimeScope>();
var module = ActivatorUtilitiesEx.CreateInstance <OpenModConsoleModule>(lifetime, baseRoute);
return(@this.WithModule(module));
}
public Task InitAsync()
{
foreach (var permissionSourceType in m_Options.Value.PermissionSources)
{
m_PermissionSources.Add((IPermissionStore)ActivatorUtilitiesEx.CreateInstance(m_LifetimeScope, permissionSourceType));
}
foreach (var permissionCheckProviderType in m_Options.Value.PermissionCheckProviders)
{
m_PermissionCheckProviders.Add((IPermissionCheckProvider)ActivatorUtilitiesEx.CreateInstance(m_LifetimeScope, permissionCheckProviderType));
}
return(Task.CompletedTask);
}
public static TContainer WithOpenModFileSystem <TContainer>(
this TContainer @this,
string baseRoute,
IServiceProvider serviceProvider,
Action <OpenModFileSystemModule> configure)
where TContainer : class, IWebModuleContainer
{
configure = Validate.NotNull(nameof(configure), configure);
var lifetime = serviceProvider.GetRequiredService <ILifetimeScope>();
var module = ActivatorUtilitiesEx.CreateInstance <OpenModFileSystemModule>(lifetime, baseRoute);
return(@this.WithModule(module, configure));
}
private Task CreateDatabaseProvider()
{
var dataBaseType = DbStoreType switch
{
StoreType.DataStore => typeof(DataStoreDatabase),
StoreType.LiteDb => typeof(LiteDbDatabase),
StoreType.MySql => typeof(MySqlDatabase),
StoreType.UserData => typeof(UserDataDatabase),
_ => throw new ArgumentOutOfRangeException(nameof(DbStoreType), DbStoreType, null)
};
// ReSharper disable once PossibleNullReferenceException
m_Database = ActivatorUtilitiesEx.CreateInstance(LifetimeScope, dataBaseType) as IEconomyProvider;
return(m_Database is MySqlDatabase mySqlDatabase?mySqlDatabase.CheckShemasAsync() : Task.CompletedTask);
}
public void ActivateEventListeners()
{
m_Logger.LogTrace("Activating oxide events listeners");
foreach (var type in FindListenerTypes())
{
var eventsListener = (OxideEventsListenerBase)ActivatorUtilitiesEx.CreateInstance(m_LifetimeScope, type);
m_RustEventsListeners.Add(eventsListener);
}
foreach (var eventsListener in m_RustEventsListeners)
{
Interface.Oxide.RootPluginManager.AddPlugin(eventsListener);
}
}
public ICommand Instantiate(IServiceProvider serviceProvider)
{
if (serviceProvider == null)
{
throw new ArgumentNullException(nameof(serviceProvider));
}
if (CommandType != null)
{
var lifetime = serviceProvider.GetRequiredService <ILifetimeScope>();
return((ICommand)ActivatorUtilitiesEx.CreateInstance(lifetime, CommandType));
}
return(new MethodCommandWrapper(CommandMethod !, serviceProvider));
}
protected override async UniTask OnLoadAsync()
{
await UniTask.SwitchToThreadPool();
RegisterPermissions();
await RegisterDataStores();
m_TpaRequestManager.SetLocalizer(m_StringLocalizer);
// https://github.com/aspnet/Configuration/issues/451
m_BroadcastingService.Configure(m_Configuration.GetValue <ushort>("broadcasting:effectId"),
m_Configuration.GetSection("broadcasting:repeatingMessages").Get <string[]>(),
m_Configuration.GetValue <int>("broadcasting:repeatingInterval"),
m_Configuration.GetValue <int>("broadcasting:repeatingDuration"));
ActivatorUtilitiesEx.CreateInstance <AfkChecker>(LifetimeScope);
}
public void Install()
{
if (!IsRocketModInstalled())
{
return;
}
if (!IsRocketModUnturnedLoaded(out _))
{
return;
}
if (m_Installed)
{
return;
}
m_Logger.LogInformation("RocketMod is installed, enabling RocketMod integration");
m_HarmonyInstance = new Harmony(c_HarmonyId);
m_HarmonyInstance.PatchAllConditional(typeof(OpenModUnturnedHost).Assembly, "rocketmod");
m_EventBus.Subscribe <CommandExecutedEvent>(m_RocketModComponent, (services, sender, @event) =>
{
var scope = services.GetRequiredService <ILifetimeScope>();
var listener = ActivatorUtilitiesEx.CreateInstance <RocketModCommandEventListener>(scope);
return(listener.HandleEventAsync(sender, @event));
});
if (U.Settings != null)
{
// Rocketmod already initialized
OnRocketModIntialized();
OnRocketModPluginsLoaded();
}
else
{
PatchInitialize();
PatchLogging();
PatchPluginsLoaded();
PatchRcon();
}
m_Installed = true;
}
public IReadOnlyCollection <ICommandSource> CreateCommandSources(IServiceProvider serviceProvider)
{
if (serviceProvider == null)
{
throw new ArgumentNullException(nameof(serviceProvider));
}
var lifetime = serviceProvider.GetService <ILifetimeScope>();
var sources = new List <ICommandSource>();
sources.AddRange(m_CommandSources);
foreach (var type in m_CommandSourceTypes)
{
sources.Add((ICommandSource)ActivatorUtilitiesEx.CreateInstance(lifetime, type));
}
return(sources);
}
public void ActivateEventListeners()
{
m_Logger.LogTrace("Activating unturned events listeners");
var listenerTypes = GetType().Assembly.FindTypes <IUnturnedEventsListener>(false).ToList();
foreach (var type in listenerTypes)
{
var eventsListener = (IUnturnedEventsListener)ActivatorUtilitiesEx.CreateInstance(m_LifetimeScope, type);
m_UnturnedEventsListeners.Add(eventsListener);
}
foreach (var eventsListener in m_UnturnedEventsListeners)
{
eventsListener.Subscribe();
}
Provider.clients.Do(SubscribePlayer);
Provider.onEnemyConnected += SubscribePlayer;
Provider.onEnemyDisconnected += UnsubscribePlayer;
}
public CommandParameterResolver(
ILifetimeScope lifetimeScope,
IOptions <CommandParameterResolverOptions> options)
{
m_CommandParameterResolveProviders = options.Value.CommandParameterResolverTypes
.Select(type => (ICommandParameterResolveProvider)ActivatorUtilitiesEx.CreateInstance(lifetimeScope, type))
.ToList();
}
public Task InitAsync()
{
try
{
if (RocketModIntegration.IsRocketModInstalled())
{
var rocketModIntegration = ActivatorUtilitiesEx.CreateInstance <RocketModIntegration>(LifetimeScope);
rocketModIntegration.Install();
}
}
catch (Exception ex)
{
m_Logger.LogError(ex, "Failed to integrate with RocketMod");
}
// ReSharper disable PossibleNullReferenceException
IsComponentAlive = true;
try
{
m_Harmony = new Harmony(OpenModComponentId);
m_Harmony.PatchAll(GetType().Assembly);
}
catch (Exception ex)
{
m_Logger.LogError(ex, "Failed to patch with Harmony. Report this error on the OpenMod discord: https://discord.com/invite/jRrCJVm");
}
m_UnturnedCommandHandler.Value.Subscribe();
BindUnturnedEvents();
var ioHandlers = (List <ICommandInputOutput>) typeof(CommandWindow)
.GetField("ioHandlers", BindingFlags.NonPublic | BindingFlags.Instance)
.GetValue(Dedicator.commandWindow);
CommandLineFlag?shouldManageConsole = null;
var previousShouldManageConsoleValue = true;
if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
{
/* Fix Unturned destroying console and breaking Serilog formatting and colors */
var windowsConsole = typeof(Provider).Assembly.GetType("SDG.Unturned.WindowsConsole");
var shouldManageConsoleField = windowsConsole?.GetField("shouldManageConsole",
BindingFlags.Static | BindingFlags.NonPublic);
if (shouldManageConsoleField != null)
{
shouldManageConsole = (CommandLineFlag)shouldManageConsoleField.GetValue(null);
previousShouldManageConsoleValue = shouldManageConsole.value;
shouldManageConsole.value = false;
}
}
m_IoHandlers = ioHandlers.ToList(); // copy Unturneds IoHandlers
// unturned built-in io handlers
var defaultIoHandlers = ioHandlers.Where(c =>
c.GetType().FullName
.Equals("SDG.Unturned.ThreadedWindowsConsoleInputOutput") || // type doesnt exist on Linux
c.GetType().FullName.Equals("SDG.Unturned.WindowsConsoleInputOutput") || // type doesnt exist on Linux
c.GetType() == typeof(ThreadedConsoleInputOutput) ||
c.GetType() == typeof(ConsoleInputOutput)).ToList();
foreach (var ioHandler in defaultIoHandlers)
{
Dedicator.commandWindow.removeIOHandler(ioHandler);
}
if (shouldManageConsole != null)
{
shouldManageConsole.value = previousShouldManageConsoleValue;
}
m_OpenModIoHandler = RuntimeInformation.IsOSPlatform(OSPlatform.Windows)
? ActivatorUtilities.CreateInstance <OpenModWindowsConsoleInputOutput>(m_ServiceProvider)
: ActivatorUtilities.CreateInstance <OpenModConsoleInputOutput>(m_ServiceProvider);
Dedicator.commandWindow.addIOHandler(m_OpenModIoHandler);
m_Logger.LogInformation("OpenMod for Unturned v{HostVersion} is initializing...",
m_HostInformation.HostVersion);
m_Logger.LogInformation("OpenMod for Unturned is ready");
return(Task.CompletedTask);
// ReSharper restore PossibleNullReferenceException
}
protected virtual Task <TClient> CreateRconClientAsync(TcpClient tcpClient)
{
return(Task.FromResult(ActivatorUtilitiesEx.CreateInstance <TClient>(m_LifetimeScope, tcpClient, this)));
}
public async Task <IOpenModPlugin?> TryActivatePluginAsync(Assembly assembly)
{
try
{
if (m_IsDisposing)
{
throw new ObjectDisposedException(nameof(PluginActivator));
}
var pluginMetadata = assembly.GetCustomAttribute <PluginMetadataAttribute>();
if (pluginMetadata == null)
{
m_Logger.LogError(
$"Failed to load plugin from assembly {assembly}: couldn't find any plugin metadata");
return(null);
}
var pluginTypes = assembly.FindTypes <IOpenModPlugin>().ToList();
if (pluginTypes.Count == 0)
{
m_Logger.LogError(
$"Failed to load plugin from assembly {assembly}: couldn't find any IOpenModPlugin implementation");
return(null);
}
if (pluginTypes.Count > 1)
{
m_Logger.LogError(
$"Failed to load plugin from assembly {assembly}: assembly has multiple IOpenModPlugin instances");
return(null);
}
var pluginType = pluginTypes.Single();
IOpenModPlugin pluginInstance;
try
{
var lifetimeScope = m_LifetimeScope.BeginLifetimeScopeEx(containerBuilder =>
{
var workingDirectory = PluginHelper.GetWorkingDirectory(m_Runtime, pluginMetadata.Id);
var configurationBuilder = new ConfigurationBuilder();
if (Directory.Exists(workingDirectory))
{
configurationBuilder
.SetBasePath(workingDirectory)
.AddYamlFile("config.yaml", optional: true, reloadOnChange: true);
}
var configuration = configurationBuilder
.AddEnvironmentVariables(pluginMetadata.Id.Replace(".", "_") + "_")
.Build();
containerBuilder.Register(_ => configuration)
.As <IConfiguration>()
.As <IConfigurationRoot>()
.SingleInstance()
.OwnedByLifetimeScope();
containerBuilder.RegisterType(pluginType)
.AsSelf()
.As <IOpenModComponent>()
.As <IOpenModPlugin>()
.SingleInstance()
.OwnedByLifetimeScope();
containerBuilder.RegisterType <ScopedPermissionChecker>()
.As <IPermissionChecker>()
.InstancePerLifetimeScope()
.OwnedByLifetimeScope();
containerBuilder.Register(_ => m_DataStoreFactory.CreateDataStore(new DataStoreCreationParameters
{
#pragma warning disable 618
ComponentId = pluginMetadata.Id,
#pragma warning restore 618
Prefix = null,
Suffix = "data",
WorkingDirectory = workingDirectory
}))
.As <IDataStore>()
.SingleInstance()
.OwnedByLifetimeScope();
var stringLocalizer = Directory.Exists(workingDirectory)
? m_StringLocalizerFactory.Create("translations", workingDirectory)
: NullStringLocalizer.Instance;
containerBuilder.Register(_ => stringLocalizer)
.As <IStringLocalizer>()
.SingleInstance()
.OwnedByLifetimeScope();
var services =
ServiceRegistrationHelper.FindFromAssembly <PluginServiceImplementationAttribute>(assembly,
m_Logger);
var servicesRegistrations = services.OrderBy(d => d.Priority,
new PriorityComparer(PriortyComparisonMode.LowestFirst));
foreach (var servicesRegistration in servicesRegistrations)
{
var implementationType = servicesRegistration.ServiceImplementationType;
containerBuilder.RegisterType(implementationType)
.As(implementationType)
.WithLifetime(servicesRegistration.Lifetime)
.OwnedByLifetimeScope();
foreach (var service in servicesRegistration.ServiceTypes)
{
containerBuilder.Register(c => c.Resolve(implementationType))
.As(service)
.WithLifetime(servicesRegistration.Lifetime)
.OwnedByLifetimeScope();
}
}
foreach (var type in pluginType.Assembly.FindTypes <IPluginContainerConfigurator>())
{
var configurator = (IPluginContainerConfigurator)ActivatorUtilitiesEx.CreateInstance(m_LifetimeScope, type);
configurator.ConfigureContainer(new PluginServiceConfigurationContext(m_LifetimeScope, configuration, containerBuilder));
}
var configurationEvent = new PluginContainerConfiguringEvent(pluginMetadata, pluginType,
configuration, containerBuilder, workingDirectory);
AsyncHelper.RunSync(() => m_EventBus.EmitAsync(m_Runtime, this, configurationEvent));
});
pluginInstance = (IOpenModPlugin)lifetimeScope.Resolve(pluginType);
var pluginLoggerType = typeof(ILogger <>).MakeGenericType(pluginType);
var pluginLogger = (ILogger)pluginInstance.LifetimeScope.Resolve(pluginLoggerType);
RegisterConfigChangeCallback(pluginInstance, pluginLogger);
var pluginActivateEvent = new PluginActivatingEvent(pluginInstance);
await m_EventBus.EmitAsync(m_Runtime, this, pluginActivateEvent);
if (pluginActivateEvent.IsCancelled)
{
await lifetimeScope.DisposeAsync();
return(null);
}
}
catch (Exception ex)
{
m_Logger.LogError(ex,
$"Failed to load plugin from type: {pluginType.FullName} in assembly: {assembly.FullName}");
return(null);
}
try
{
await pluginInstance.LoadAsync();
var serviceProvider = pluginInstance.LifetimeScope.Resolve <IServiceProvider>();
var pluginHelpWriter = ActivatorUtilities.CreateInstance <PluginHelpWriter>(serviceProvider);
await pluginHelpWriter.WriteHelpFileAsync();
}
catch (Exception ex)
{
m_Logger.LogError(ex, $"Failed to load plugin: {pluginInstance.DisplayName} v{pluginInstance.Version}");
try
{
await pluginInstance.LifetimeScope.DisposeAsync();
}
catch (Exception e)
{
m_Logger.LogError(e, "Failed to unload plugin: {DisplayName} v{Version}", pluginInstance.DisplayName, pluginInstance.Version);
}
return(null);
}
m_ActivatedPlugins.Add(new WeakReference(pluginInstance));
return(pluginInstance);
}
catch (Exception ex)
{
m_Logger.LogError(ex, $"Failed to load plugin from assembly: {assembly.FullName}");
return(null);
}
}
public Task InitAsync()
{
if (RocketModIntegration.IsRocketModInstalled())
{
var rocketModIntegration = ActivatorUtilitiesEx.CreateInstance <RocketModIntegration>(LifetimeScope);
rocketModIntegration.Install();
}
// ReSharper disable PossibleNullReferenceException
IsComponentAlive = true;
m_Harmony = new Harmony(OpenModComponentId);
m_Harmony.PatchAll(GetType().Assembly);
m_UnturnedCommandHandler.Value.Subscribe();
BindUnturnedEvents();
var ioHandlers = (List <ICommandInputOutput>) typeof(CommandWindow)
.GetField("ioHandlers", BindingFlags.NonPublic | BindingFlags.Instance)
.GetValue(Dedicator.commandWindow);
CommandLineFlag?shouldManageConsole = null;
var previousShouldManageConsoleValue = true;
if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
{
/* Fix Unturned destroying console and breaking Serilog formatting and colors */
var windowsConsole = typeof(Provider).Assembly.GetType("SDG.Unturned.WindowsConsole");
var shouldManageConsoleField = windowsConsole?.GetField("shouldManageConsole",
BindingFlags.Static | BindingFlags.NonPublic);
if (shouldManageConsoleField != null)
{
shouldManageConsole = (CommandLineFlag)shouldManageConsoleField.GetValue(null);
previousShouldManageConsoleValue = shouldManageConsole.value;
shouldManageConsole.value = false;
}
}
m_IoHandlers = ioHandlers.ToList(); // copy Unturneds IoHandlers
// unturned built-in io handlers
var defaultIoHandlers = ioHandlers.Where(c =>
c.GetType().FullName
.Equals("SDG.Unturned.ThreadedWindowsConsoleInputOutput") || // type doesnt exist on Linux
c.GetType().FullName.Equals("SDG.Unturned.WindowsConsoleInputOutput") || // type doesnt exist on Linux
c.GetType() == typeof(ThreadedConsoleInputOutput) ||
c.GetType() == typeof(ConsoleInputOutput)).ToList();
foreach (var ioHandler in defaultIoHandlers)
{
Dedicator.commandWindow.removeIOHandler(ioHandler);
}
if (shouldManageConsole != null)
{
shouldManageConsole.value = previousShouldManageConsoleValue;
}
m_OpenModIoHandler = RuntimeInformation.IsOSPlatform(OSPlatform.Windows)
? ActivatorUtilities.CreateInstance <OpenModWindowsConsoleInputOutput>(m_ServiceProvider)
: ActivatorUtilities.CreateInstance <OpenModConsoleInputOutput>(m_ServiceProvider);
Dedicator.commandWindow.addIOHandler(m_OpenModIoHandler);
m_Logger.LogInformation($"OpenMod for Unturned v{m_HostInformation.HostVersion} is initializing...");
TlsWorkaround.Install();
if (!s_UniTaskInited)
{
var unitySynchronizationContetextField =
typeof(PlayerLoopHelper).GetField("unitySynchronizationContetext",
BindingFlags.Static | BindingFlags.NonPublic);
unitySynchronizationContetextField.SetValue(null, SynchronizationContext.Current);
var mainThreadIdField =
typeof(PlayerLoopHelper).GetField("mainThreadId", BindingFlags.Static | BindingFlags.NonPublic);
mainThreadIdField.SetValue(null, Thread.CurrentThread.ManagedThreadId);
var playerLoop = PlayerLoop.GetDefaultPlayerLoop();
PlayerLoopHelper.Initialize(ref playerLoop);
s_UniTaskInited = true;
}
m_Logger.LogInformation("OpenMod for Unturned is ready.");
return(Task.CompletedTask);
// ReSharper restore PossibleNullReferenceException
}
private OpenModController CreateComponentFactory(Type type, IOpenModComponent component)
{
var scope = component.LifetimeScope.BeginLifetimeScope("AutofacWebRequest");
return((OpenModController)ActivatorUtilitiesEx.CreateInstance(scope, type));
}
public Task HandleEventAsync(object sender, RocketModPluginsLoadedEvent @event)
{
var permissionSystem = m_UnturnedConfiguration.Configuration
.GetSection("rocketmodIntegration:permissionSystem")
.Get <string>();
if (permissionSystem.Equals("OpenMod", StringComparison.OrdinalIgnoreCase))
{
var scope = m_RocketModComponent.LifetimeScope;
var permissionProxyProvider = ActivatorUtilitiesEx.CreateInstance <RocketModPermissionProxyProvider>(scope);
permissionProxyProvider.Install();
}
var economySystem = m_UnturnedConfiguration.Configuration
.GetSection("rocketmodIntegration:economySystem")
.Get <string>();
if (economySystem.Equals("OpenMod_Uconomy", StringComparison.OrdinalIgnoreCase))
{
var uconomyAssembly = UconomyIntegration.GetUconomyAssembly();
if (uconomyAssembly != null)
{
var databaseType = uconomyAssembly.GetType("fr34kyn01535.Uconomy.DatabaseManager");
var harmonyInstance = new Harmony(UconomyIntegration.HarmonyId);
var getBalanceMethod = databaseType.GetMethod("GetBalance", c_BindingFlags);
var getBalancePrefixMethod = typeof(UconomyGetBalancePatch)
.GetMethod(nameof(UconomyGetBalancePatch.GetBalancePrefix), c_BindingFlags);
harmonyInstance.Patch(getBalanceMethod, prefix: new HarmonyMethod(getBalancePrefixMethod));
var increaseBalancePrefixMethod = typeof(UconomyBalanceIncreasePatch)
.GetMethod(nameof(UconomyBalanceIncreasePatch.IncreaseBalancePrefix), c_BindingFlags);
var increaseBalanceMethod = databaseType.GetMethod("IncreaseBalance", c_BindingFlags);
harmonyInstance.Patch(increaseBalanceMethod, prefix: new HarmonyMethod(increaseBalancePrefixMethod));
var checkSchemaMethod = databaseType.GetMethod("CheckSchema", c_BindingFlags) !;
harmonyInstance.NopPatch(checkSchemaMethod);
var checkSetupAccount = databaseType.GetMethod("CheckSetupAccount", c_BindingFlags) !;
harmonyInstance.NopPatch(checkSetupAccount);
var executeQueryMethod = databaseType.GetMethod("ExecuteQuery", c_BindingFlags);
var executeQueryPrefixMethod = typeof(UconomyExecuteQueryPatch)
.GetMethod(nameof(UconomyExecuteQueryPatch.ExecuteQueryPrefix), c_BindingFlags);
harmonyInstance.Patch(executeQueryMethod, prefix: new HarmonyMethod(executeQueryPrefixMethod));
UconomyGetBalancePatch.OnPreGetBalance += OnPreGetBalance;
UconomyBalanceIncreasePatch.OnPreIncreaseBalance += OnPreIncreaseBalance;
m_RocketModComponent.LifetimeScope.Disposer.AddInstanceForDisposal(new DisposeAction(() =>
{
harmonyInstance.UnpatchAll(UconomyIntegration.HarmonyId);
UconomyGetBalancePatch.OnPreGetBalance -= OnPreGetBalance;
UconomyBalanceIncreasePatch.OnPreIncreaseBalance -= OnPreIncreaseBalance;
}));
}
else
{
var logger = m_LoggerFactory.CreateLogger <RocketModIntegration>();
logger.LogWarning("Economy system was set to OpenMod_Uconomy but Uconomy is not loaded. Defaulting to Separate.");
}
}
RemoveRocketCommandListeners();
return(Task.CompletedTask);
}