/// <summary>
/// Gets the path to the Uconomy assembly. Will return null if not found.
/// </summary>
public static string?GetUconomyFile()
{
var pluginsFolder = Path.Combine(RocketModIntegration.GetRocketFolder(), "Plugins");
if (!Directory.Exists(pluginsFolder))
{
return(null);
}
foreach (var file in Directory.GetFiles(pluginsFolder, "*.dll", SearchOption.AllDirectories))
{
try
{
var assemblyName = AssemblyName.GetAssemblyName(file);
if (assemblyName.Name.Equals("Uconomy"))
{
return(file);
}
}
catch
{
// ignored
}
}
return(null);
}
public Task HandleEventAsync(object?sender, OpenModInitializedEvent @event)
{
if (RocketModIntegration.IsRocketModUnturnedLoaded(out _))
{
if (s_RocketInitialized)
{
StartRocketModRconWithRocketModSettings();
}
// Use RocketModInitializedEvent instead
return(Task.CompletedTask);
}
var rocketRconEnabled = m_UnturnedConfiguration.GetSection("rcon:rocketmod:enabled").Get <bool>();
if (!rocketRconEnabled)
{
return(Task.CompletedTask);
}
var bind = m_OpenModConfiguration.GetSection("rcon:bind").Get <string>();
var port = m_UnturnedConfiguration.GetSection("rcon:rocketmod:port").Get <int>();
StartRocketModRcon(bind, port);
return(Task.CompletedTask);
}
private void CallRocketPlayerChatted(UnturnedPlayer player, EChatMode mode, string message, ref Color color,
ref bool cancel)
{
if (!RocketModIntegration.IsRocketModUnturnedLoaded(out _))
{
return;
}
m_Logger.LogDebug("Calling the event UnturnedChat.OnPlayerChatted");
var colorEx = color;
var cancelEx = cancel;
m_PermissionExtensions.CallRocketEvent(player, mode, message, ref colorEx, ref cancelEx);
if (m_Configuration.GetSection("rocketmodIntegration:canOverrideColor").Get <bool>())
{
color = colorEx;
}
if (cancelEx)
{
m_Logger.LogDebug("RocketMod cancel the message!");
}
if (color != colorEx)
{
m_Logger.LogDebug("RocketMod override the color! {FromColor} -> {ToColor}", color, colorEx);
}
cancel = cancelEx && m_Configuration.GetSection("rocketmodIntegration:canCancelMessage").Get <bool>();
}
public void Dispose()
{
RocketModIntegration.Uninstall();
if (m_IsDisposing)
{
return;
}
Dedicator.commandWindow.removeIOHandler(m_OpenModIoHandler);
m_IoHandlers.Reverse();
foreach (var ioHandler in m_IoHandlers)
{
Dedicator.commandWindow.addIOHandler(ioHandler);
}
m_IoHandlers.Clear();
IsComponentAlive = false;
m_IsDisposing = true;
TlsWorkaround.Uninstalll();
m_Harmony.UnpatchAll(OpenModComponentId);
UnbindUnturnedEvents();
}
private bool IsRocketModRole(string id)
{
if (!RocketModIntegration.IsRocketModReady())
{
return(false);
}
return(R.Permissions.GetGroup(id) != null);
}
protected override UniTask OnLoadAsync()
{
m_Logger.LogInformation("Made with <3 by EvolutionPlugins");
m_Logger.LogInformation("https://github.com/evolutionplugins \\ https://github.com/diffoz");
m_Logger.LogInformation("Support discord: https://discord.gg/6KymqGv");
if (RocketModIntegration.IsRocketModUnturnedLoaded(out var asm) && RocketModIntegration.IsRocketModInstalled())
{
m_HandleChatPatch =
ActivatorUtilitiesEx.CreateInstance <RocketModHandleChatPatch>(m_LifetimeScope,
m_Logger, Harmony, asm !);
}
return(AddExample().AsUniTask(false));
}
private async Task ProcessLoginAsync(RocketModRconPacket packet)
{
var arguments = ArgumentsParser.ParseArguments(packet.Body !);
var rocketModLoaded = RocketModIntegration.IsRocketModUnturnedLoaded(out _);
if (rocketModLoaded && arguments.Length == 2)
{
if (ProcessRocketModLogin(packet))
{
Id = "root";
IsAuthenticated = true;
await SendMessageAsync("Logged in.");
return;
}
await SendMessageAsync("Authentication failed.");
IncreaseFailedAuthAttempts();
await DisconnectOnFailedLoginAttemptsAsync();
return;
}
if (arguments.Length != 3)
{
await SendMessageAsync("Invalid Syntax! Usage: login <username> <password>");
IncreaseFailedAuthAttempts();
await DisconnectOnFailedLoginAttemptsAsync();
return;
}
await OnAuthenticatingAsync(arguments[1], arguments[2]);
}
public void ConfigureServices(IOpenModServiceConfigurationContext openModStartupContext, IServiceCollection serviceCollection)
{
serviceCollection.Configure <PermissionCheckerOptions>(options =>
{
options.AddPermissionCheckProvider <UnturnedAdminPermissionCheckProvider>();
});
serviceCollection.Configure <CommandStoreOptions>(options =>
{
options.AddCommandSource <UnturnedCommandSource>();
});
serviceCollection.Configure <UserManagerOptions>(options =>
{
options.AddUserProvider <UnturnedUserProvider>();
});
serviceCollection.Configure <CommandParameterResolverOptions>(options =>
{
options.AddCommandParameterResolveProvider <UnturnedPlayerCommandParameterResolveProvider>();
});
if (RocketModIntegration.IsRocketModInstalled())
{
// todo: check direction for permission link from config
serviceCollection.Configure <PermissionCheckerOptions>(options =>
{
options.AddPermissionSource <RocketPermissionStore>();
});
serviceCollection.AddTransient <IPermissionRoleStore, RocketPermissionRoleStore>();
}
serviceCollection.AddSingleton <UnturnedCommandHandler>();
}
private bool RocketModIntegrationEnabled()
{
// todo: check from config
return(RocketModIntegration.IsRocketModReady());
}
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
}
public void ConfigureServices(IOpenModServiceConfigurationContext openModStartupContext, IServiceCollection serviceCollection)
{
var unturnedConfiguration = new OpenModUnturnedConfiguration(openModStartupContext.Runtime.WorkingDirectory);
serviceCollection.AddSingleton <IOpenModUnturnedConfiguration>(unturnedConfiguration);
serviceCollection.AddSingleton <IGameHostInformation, UnturnedHostInformation>();
serviceCollection.Configure <PermissionCheckerOptions>(options =>
{
options.AddPermissionCheckProvider <UnturnedAdminPermissionCheckProvider>();
});
serviceCollection.Configure <CommandStoreOptions>(options =>
{
options.AddCommandSource <UnturnedCommandSource>();
var logger = openModStartupContext.LoggerFactory.CreateLogger <OpenModComponentCommandSource>();
var host = openModStartupContext.Runtime.LifetimeScope.Resolve <IOpenModHost>();
options.AddCommandSource(new OpenModComponentCommandSource(logger, host, typeof(OpenModUnturnedHost).Assembly));
});
serviceCollection.Configure <UserManagerOptions>(options =>
{
options.AddUserProvider <UnturnedUserProvider>();
});
serviceCollection.Configure <CommandParameterResolverOptions>(options =>
{
options.AddCommandParameterResolveProvider <UnturnedPlayerCommandParameterResolveProvider>();
options.AddCommandParameterResolveProvider <UnturnedLocationCommandParameterResolveProvider>();
options.AddCommandParameterResolveProvider <CSteamIDCommandParameterResolveProvider>();
});
if (RocketModIntegration.IsRocketModInstalled())
{
serviceCollection.AddSingleton <IRocketModComponent, RocketModComponent>();
var permissionSystem = unturnedConfiguration.Configuration
.GetSection("rocketmodIntegration:permissionSystem")
.Get <string>();
if (permissionSystem.Equals("RocketMod", StringComparison.OrdinalIgnoreCase))
{
serviceCollection.Configure <PermissionCheckerOptions>(options =>
{
options.AddPermissionSource <RocketPermissionStore>();
options.AddPermissionCheckProvider <RocketCooldownPermissionCheckProvider>();
});
serviceCollection.AddTransient <IPermissionRoleStore, RocketPermissionRoleStore>();
}
var economySystem = unturnedConfiguration.Configuration
.GetSection("rocketmodIntegration:economySystem")
.Get <string>();
if (economySystem.Equals("RocketMod_Uconomy", StringComparison.OrdinalIgnoreCase))
{
if (UconomyIntegration.IsUconomyInstalled())
{
serviceCollection.AddSingleton <IEconomyProvider, UconomyEconomyProvider>();
}
else
{
var logger = openModStartupContext.LoggerFactory.CreateLogger <RocketModIntegration>();
logger.LogWarning("Economy system was set to RocketMod_Uconomy but Uconomy is not installed. Defaulting to Separate");
}
}
}
serviceCollection.AddSingleton <UnturnedCommandHandler>();
}
private bool EnsureUconomyReady()
{
if (m_UconomyReady)
{
return(true);
}
if (!RocketModIntegration.IsRocketModReady())
{
return(false);
}
var uconomyAssembly = UconomyIntegration.GetUconomyAssembly();
if (uconomyAssembly == null)
{
return(false);
}
var uconomyType = uconomyAssembly.GetType("fr34kyn01535.Uconomy.Uconomy");
if (uconomyType == null)
{
throw new Exception($"Failed to find Uconomy type in {uconomyAssembly}");
}
var instanceField = uconomyType.GetField("Instance", c_BindingFlags);
if (instanceField == null)
{
throw new Exception($"Failed to find Instance field in {uconomyType}");
}
m_DatabaseField = uconomyType.GetField("Database", c_BindingFlags);
m_DatabaseType = m_DatabaseField.FieldType;
m_GetBalanceMethod = m_DatabaseType.GetMethod("GetBalance", c_BindingFlags);
m_IncreaseBalanceMethod = m_DatabaseType.GetMethod("IncreaseBalance", c_BindingFlags);
var uconomyConfigurationType = uconomyAssembly.GetType("fr34kyn01535.Uconomy.UconomyConfiguration");
m_MoneySymbolField = uconomyConfigurationType.GetField("MoneySymbol", c_BindingFlags);
m_MoneyNameField = uconomyConfigurationType.GetField("MoneyName", c_BindingFlags);
m_UconomyInstance = instanceField.GetValue(null);
if (m_UconomyInstance == null)
{
return(false);
}
var pluginType = typeof(RocketPlugin <>).MakeGenericType(uconomyConfigurationType);
var pluginConfigurationAssetField = pluginType.GetField("configuration", c_BindingFlags);
var pluginConfigurationAssetInstance = pluginConfigurationAssetField.GetValue(m_UconomyInstance);
var uconomyConfigurationInstanceProperty = pluginConfigurationAssetField.FieldType.GetProperty("Instance", c_BindingFlags);
m_UconomyConfigurationInstance = uconomyConfigurationInstanceProperty.GetGetMethod()
.Invoke(pluginConfigurationAssetInstance, new object[0]);
m_DatabaseInstance = m_DatabaseField.GetValue(m_UconomyInstance);
if (m_DatabaseInstance == null)
{
return(false);
}
PatchUconomy();
m_UconomyReady = true;
return(true);
}
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
}
