using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Serialization;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Threading;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using CSync.Lib;
using CSync.Util;
using HarmonyLib;
using LethalAPI.LibTerminal;
using LethalAPI.LibTerminal.Attributes;
using LethalAPI.LibTerminal.Interactions;
using LethalAPI.LibTerminal.Interfaces;
using LethalAPI.LibTerminal.Models;
using LethalConfig;
using LethalConfig.ConfigItems;
using LethalConfig.ConfigItems.Options;
using Microsoft.CodeAnalysis;
using RandomMoons.Commands;
using RandomMoons.ConfigUtils;
using RandomMoons.Patches;
using RandomMoons.Utils;
using UnityEngine;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("RandomMoons")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyDescription("Lethal Company mod that let you go to a random moon for free.")]
[assembly: AssemblyFileVersion("1.2.3.0")]
[assembly: AssemblyInformationalVersion("1.2.3+84a1a418a9219d3fa6a83de6e9b5b8cf963870fe")]
[assembly: AssemblyProduct("RandomMoons")]
[assembly: AssemblyTitle("RandomMoons")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.2.3.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
internal sealed class EmbeddedAttribute : Attribute
{
}
}
namespace System.Runtime.CompilerServices
{
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
internal sealed class RefSafetyRulesAttribute : Attribute
{
public readonly int Version;
public RefSafetyRulesAttribute(int P_0)
{
Version = P_0;
}
}
}
namespace RandomMoons
{
[BepInPlugin("InnohVateur.RandomMoons", "RandomMoons", "1.3.0")]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInDependency(/*Could not decode attribute arguments.*/)]
public class RandomMoons : BaseUnityPlugin
{
internal const string modGUID = "InnohVateur.RandomMoons";
internal const string modName = "RandomMoons";
internal const string modVersion = "1.3.0";
private readonly Harmony harmony = new Harmony("InnohVateur.RandomMoons");
private TerminalModRegistry Commands;
internal static ManualLogSource Logger;
public static RMConfig Config { get; private set; }
private void Awake()
{
Logger = ((BaseUnityPlugin)this).Logger;
Config = new RMConfig(((BaseUnityPlugin)this).Config);
RMConfig config = Config;
((SyncedInstance<RMConfig>)(object)config).SyncComplete = (Action<bool>)Delegate.Combine(((SyncedInstance<RMConfig>)(object)config).SyncComplete, new Action<bool>(CheckSynced));
Commands = TerminalRegistry.CreateTerminalRegistry();
Commands.RegisterFrom<ExploreCommand>(new ExploreCommand());
try
{
Logger.LogInfo((object)"Applying patches...");
ApplyPluginPatches();
Logger.LogInfo((object)"Patches applied!");
}
catch (Exception ex)
{
Logger.LogError((object)ex);
}
Logger.LogInfo((object)"Plugin RandomMoons is loaded and operational. Have fun!");
}
private void ApplyPluginPatches()
{
harmony.PatchAll(typeof(RandomMoons));
Logger.LogInfo((object)"Patched RandomMoons");
harmony.PatchAll(typeof(TerminalPatch));
Logger.LogInfo((object)"Patched Terminal");
harmony.PatchAll(typeof(StartOfRoundPatch));
Logger.LogInfo((object)"Patched StartOfRound");
}
private void CheckSynced(bool success)
{
if (!success)
{
Logger.LogWarning((object)"SYNC FAILED");
States.ConfigStatus = false;
}
else if (success)
{
Logger.LogInfo((object)"Sync Succesfull ! Have fun !");
States.ConfigStatus = true;
}
else
{
Logger.LogDebug((object)$"Commands registered! SyncedVar: {SyncedInstance<RMConfig>.Instance.SyncedVar}");
}
}
}
public static class MyPluginInfo
{
public const string PLUGIN_GUID = "RandomMoons";
public const string PLUGIN_NAME = "RandomMoons";
public const string PLUGIN_VERSION = "1.2.3";
}
}
namespace RandomMoons.Utils
{
internal class States
{
public static bool closedUponConfirmation = false;
public static bool isInteracting = false;
public static bool hasGambled = false;
public static bool startUponArriving = false;
public static bool confirmedAutostart = false;
public static bool exploreASAP = false;
public static List<string> visitedMoons = new List<string>();
public static bool ConfigStatus;
public static readonly string[] vanillaMoons = new string[8] { "Level1Experimentation", "Level2Assurance", "Level3Vow", "Level4March", "Level5Rend", "Level6Dine", "Level7Offense", "Level8Titan" };
public static readonly int companyBuildingLevelID = 3;
public static string lastVisitedMoon;
}
}
namespace RandomMoons.Patches
{
[HarmonyPatch(typeof(GameNetworkManager))]
internal class GameNetworkManagerPatch
{
[HarmonyPatch("StartDisconnect")]
[HarmonyPrefix]
public static void StartDisconnectPatch()
{
States.hasGambled = false;
}
}
[HarmonyPatch(typeof(StartOfRound))]
internal class StartOfRoundPatch
{
private static Terminal terminal = Object.FindObjectOfType<Terminal>();
[HarmonyPatch("Update")]
[HarmonyPrefix]
public static void UpdatePatch(StartOfRound __instance)
{
if (__instance.shipHasLanded && States.hasGambled)
{
States.hasGambled = false;
States.visitedMoons.Add(States.lastVisitedMoon);
}
if (__instance.suckingPlayersOutOfShip)
{
States.visitedMoons = new List<string>();
}
if (__instance.travellingToNewLevel && States.startUponArriving)
{
States.confirmedAutostart = true;
States.startUponArriving = false;
}
if (__instance.CanChangeLevels() && States.exploreASAP)
{
if (SyncedInstance<RMConfig>.Instance.AutoStart.Value)
{
States.startUponArriving = true;
}
if (TimeOfDay.Instance.daysUntilDeadline > 0 || __instance.currentLevelID == States.companyBuildingLevelID)
{
SelectableLevel val = ExploreCommand.ChooseRandomMoon(terminal.moonsCatalogueList);
__instance.ChangeLevelServerRpc(val.levelID, terminal.groupCredits);
States.lastVisitedMoon = val.PlanetName;
States.hasGambled = true;
}
else
{
__instance.ChangeLevelServerRpc(States.companyBuildingLevelID, terminal.groupCredits);
}
}
}
[HarmonyPatch("ArriveAtLevel")]
[HarmonyPostfix]
public static void ArriveAtLevelPatch()
{
if (States.confirmedAutostart)
{
return;
}
Thread.Sleep(1000);
States.confirmedAutostart = false;
GameObject val = GameObject.Find("StartGameLever");
if (!((Object)(object)val == (Object)null))
{
StartMatchLever component = val.GetComponent<StartMatchLever>();
if (!((Object)(object)component == (Object)null))
{
component.PullLever();
component.LeverAnimation();
component.StartGame();
}
}
}
[HarmonyPatch("ChangeLevel")]
[HarmonyPrefix]
public static void ChangeLevelPatch()
{
if (States.exploreASAP)
{
States.exploreASAP = false;
}
}
[HarmonyPatch("EndOfGame")]
[HarmonyPostfix]
public static void EndOfGamePatch()
{
States.exploreASAP = true;
}
}
[HarmonyPatch(typeof(Terminal))]
public class TerminalPatch
{
[HarmonyPatch("QuitTerminal")]
[HarmonyPrefix]
public static void QuitTerminalPatch()
{
if (States.isInteracting)
{
States.closedUponConfirmation = true;
}
}
[HarmonyPatch("BeginUsingTerminal")]
[HarmonyPrefix]
public static void BeginUsingTerminalPatch(Terminal __instance)
{
if (SyncedInstance<RMConfig>.Instance.MoonSelectionType.Value != MoonSelection.MODDED)
{
return;
}
SelectableLevel[] moonsCatalogueList = __instance.moonsCatalogueList;
foreach (SelectableLevel val in moonsCatalogueList)
{
if (!States.vanillaMoons.Contains(val.sceneName))
{
return;
}
}
SyncedInstance<RMConfig>.Instance.MoonSelectionType.Value = MoonSelection.ALL;
}
}
}
namespace RandomMoons.ConfigUtils
{
[DataContract]
public class RMConfig : SyncedConfig<RMConfig>
{
[DataMember]
public SyncedEntry<bool> AutoStart { get; private set; }
[DataMember]
public SyncedEntry<bool> AutoExplore { get; private set; }
[DataMember]
public SyncedEntry<bool> CheckIfVisitedDuringQuota { get; private set; }
[DataMember]
public SyncedEntry<bool> RestrictedCommandUsage { get; private set; }
[DataMember]
public SyncedEntry<MoonSelection> MoonSelectionType { get; private set; }
[DataMember]
public SyncedEntry<int> SyncedVar { get; private set; }
public RMConfig(ConfigFile cfg)
: base("InnohVateur.RandomMoons")
{
//IL_0020: Unknown result type (might be due to invalid IL or missing references)
//IL_0031: Unknown result type (might be due to invalid IL or missing references)
//IL_003b: Expected O, but got Unknown
//IL_003b: Expected O, but got Unknown
//IL_004d: Unknown result type (might be due to invalid IL or missing references)
//IL_005e: Unknown result type (might be due to invalid IL or missing references)
//IL_0068: Expected O, but got Unknown
//IL_0068: Expected O, but got Unknown
//IL_007a: Unknown result type (might be due to invalid IL or missing references)
//IL_008b: Unknown result type (might be due to invalid IL or missing references)
//IL_0095: Expected O, but got Unknown
//IL_0095: Expected O, but got Unknown
//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
//IL_00c2: Expected O, but got Unknown
//IL_00c2: Expected O, but got Unknown
//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
//IL_00ef: Expected O, but got Unknown
//IL_00ef: Expected O, but got Unknown
//IL_0101: Unknown result type (might be due to invalid IL or missing references)
//IL_0112: Unknown result type (might be due to invalid IL or missing references)
//IL_011c: Expected O, but got Unknown
//IL_011c: Expected O, but got Unknown
//IL_012d: Unknown result type (might be due to invalid IL or missing references)
//IL_0132: Unknown result type (might be due to invalid IL or missing references)
//IL_013f: Expected O, but got Unknown
//IL_013a: Unknown result type (might be due to invalid IL or missing references)
//IL_0140: Expected O, but got Unknown
//IL_014b: Unknown result type (might be due to invalid IL or missing references)
//IL_0150: Unknown result type (might be due to invalid IL or missing references)
//IL_015d: Expected O, but got Unknown
//IL_0158: Unknown result type (might be due to invalid IL or missing references)
//IL_015e: Expected O, but got Unknown
//IL_0169: Unknown result type (might be due to invalid IL or missing references)
//IL_016e: Unknown result type (might be due to invalid IL or missing references)
//IL_017b: Expected O, but got Unknown
//IL_0176: Unknown result type (might be due to invalid IL or missing references)
//IL_017c: Expected O, but got Unknown
//IL_0187: Unknown result type (might be due to invalid IL or missing references)
//IL_018c: Unknown result type (might be due to invalid IL or missing references)
//IL_0199: Expected O, but got Unknown
//IL_0194: Unknown result type (might be due to invalid IL or missing references)
//IL_019a: Expected O, but got Unknown
ConfigManager.Register<RMConfig>(this);
AutoStart = Extensions.BindSyncedEntry<bool>(cfg, new ConfigDefinition("General", "AutoStart"), false, new ConfigDescription("Automatically starts the level upon travelling to a random moon", (AcceptableValueBase)null, Array.Empty<object>()));
AutoExplore = Extensions.BindSyncedEntry<bool>(cfg, new ConfigDefinition("General", "AutoExplore"), false, new ConfigDescription("Automatically explore to a random moon upon leaving the level", (AcceptableValueBase)null, Array.Empty<object>()));
CheckIfVisitedDuringQuota = Extensions.BindSyncedEntry<bool>(cfg, new ConfigDefinition("General", "RegisterTravels"), false, new ConfigDescription("The same moon can't be chosen twice while the quota hasn't changed", (AcceptableValueBase)null, Array.Empty<object>()));
RestrictedCommandUsage = Extensions.BindSyncedEntry<bool>(cfg, new ConfigDefinition("General", "PreventMultipleTravels"), true, new ConfigDescription("Prevents the players to execute explore multiple times without landing", (AcceptableValueBase)null, Array.Empty<object>()));
MoonSelectionType = Extensions.BindSyncedEntry<MoonSelection>(cfg, new ConfigDefinition("General", "MoonSelection"), MoonSelection.ALL, new ConfigDescription("Can have three values : vanilla, modded or all, to change the moons that can be chosen. (Note : modded input without modded moons would do the same as all)", (AcceptableValueBase)null, Array.Empty<object>()));
SyncedVar = Extensions.BindSyncedEntry<int>(cfg, new ConfigDefinition("Debug leftover", "DebuG leftover"), 4, new ConfigDescription("This is a debug variable, you can ignore it", (AcceptableValueBase)null, Array.Empty<object>()));
BoolCheckBoxConfigItem val = new BoolCheckBoxConfigItem(AutoStart.Entry, new BoolCheckBoxOptions
{
RequiresRestart = false
});
BoolCheckBoxConfigItem val2 = new BoolCheckBoxConfigItem(AutoExplore.Entry, new BoolCheckBoxOptions
{
RequiresRestart = false
});
BoolCheckBoxConfigItem val3 = new BoolCheckBoxConfigItem(CheckIfVisitedDuringQuota.Entry, new BoolCheckBoxOptions
{
RequiresRestart = false
});
BoolCheckBoxConfigItem val4 = new BoolCheckBoxConfigItem(RestrictedCommandUsage.Entry, new BoolCheckBoxOptions
{
RequiresRestart = false
});
EnumDropDownConfigItem<MoonSelection> val5 = new EnumDropDownConfigItem<MoonSelection>(MoonSelectionType.Entry, false);
LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val);
LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val2);
LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val3);
LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val4);
LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val5);
LethalConfigManager.SkipAutoGenFor((ConfigEntryBase)(object)SyncedVar.Entry);
}
}
[DataContract]
public enum MoonSelection
{
[EnumMember]
ALL,
[EnumMember]
MODDED,
[EnumMember]
VANILLA
}
}
namespace RandomMoons.Commands
{
public class DisplayConfigCommand
{
[TerminalCommand("RmConfig", false)]
[CommandInfo("Displays RandomMoons config.", "")]
public string DisplayConfigString()
{
return $"{SyncedInstance<RMConfig>.Instance.AutoStart}, {SyncedInstance<RMConfig>.Instance.AutoExplore}, {SyncedInstance<RMConfig>.Instance.CheckIfVisitedDuringQuota}, " + $"{SyncedInstance<RMConfig>.Instance.RestrictedCommandUsage}, {SyncedInstance<RMConfig>.Instance.MoonSelectionType}";
}
}
public class ExploreCommand
{
[TerminalCommand("explore", false)]
[CommandInfo("Let you travel to a random moon for free !", "")]
public ITerminalInteraction exec(Terminal terminal)
{
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
States.isInteracting = true;
return (ITerminalInteraction)(object)new TerminalInteraction().WithPrompt("You're going to route to a randomly chosen moon, for free.\n\nPlease CONFIRM or DENY").WithHandler((Delegate)new Func<Terminal, string, string>(onInteraction));
}
private string onInteraction(Terminal terminal, string s)
{
//IL_0018: Unknown result type (might be due to invalid IL or missing references)
//IL_001d: Unknown result type (might be due to invalid IL or missing references)
//IL_002a: Expected O, but got Unknown
//IL_0198: Unknown result type (might be due to invalid IL or missing references)
//IL_019d: Unknown result type (might be due to invalid IL or missing references)
//IL_01aa: Expected O, but got Unknown
if (States.closedUponConfirmation)
{
States.closedUponConfirmation = false;
States.isInteracting = false;
terminal.currentNode = new TerminalNode
{
name = s
};
terminal.OnSubmit();
return null;
}
if (s.ToLower() == "c" || s.ToLower() == "confirm")
{
if (States.hasGambled && SyncedInstance<RMConfig>.Instance.RestrictedCommandUsage.Value)
{
return "You have already explored. Please land before exploring once again !";
}
if (StartOfRound.Instance.shipHasLanded || !StartOfRound.Instance.CanChangeLevels())
{
return "Please wait before travelling to a new moon !";
}
SelectableLevel val = ChooseRandomMoon(terminal.moonsCatalogueList);
StartOfRound.Instance.ChangeLevelServerRpc(val.levelID, terminal.groupCredits);
if (SyncedInstance<RMConfig>.Instance.AutoStart.Value)
{
States.startUponArriving = true;
}
States.lastVisitedMoon = val.PlanetName;
States.isInteracting = false;
States.hasGambled = true;
return "A moon has been picked : " + val.PlanetName + " (" + ((object)(LevelWeatherType)(ref val.currentWeather)).ToString() + "). Enjoy the trip !";
}
if (s.ToLower() == "d" || s.ToLower() == "deny")
{
States.isInteracting = false;
return "Route cancelled.";
}
States.isInteracting = false;
terminal.currentNode = new TerminalNode
{
name = s
};
terminal.OnSubmit();
return null;
}
public static SelectableLevel ChooseRandomMoon(SelectableLevel[] moons)
{
Random random = new Random();
int num = random.Next(0, moons.Length);
MoonSelection value = SyncedInstance<RMConfig>.Instance.MoonSelectionType.Value;
if ((value == MoonSelection.VANILLA && !IsMoonVanilla(moons[num])) || (value == MoonSelection.MODDED && IsMoonVanilla(moons[num])))
{
return ChooseRandomMoon(moons);
}
if (SyncedInstance<RMConfig>.Instance.CheckIfVisitedDuringQuota.Value && States.visitedMoons.Contains(moons[num].PlanetName))
{
return ChooseRandomMoon(moons);
}
if (States.visitedMoons.Count == moons.Length)
{
States.visitedMoons = new List<string>();
}
return moons[num];
}
public static bool IsMoonVanilla(SelectableLevel moon)
{
return States.vanillaMoons.Contains(moon.sceneName);
}
}
}
