using System;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Core.Logging.Interpolation;
using BepInEx.Logging;
using BepInEx.Unity.IL2CPP;
using BigActions.Features.Discovery;
using BigActions.Features.SelfStow;
using BigActions.Game;
using HarmonyLib;
using Il2CppInterop.Runtime.Injection;
using Il2CppSystem.Collections.Generic;
using Microsoft.CodeAnalysis;
using UnityEngine;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName = ".NET 6.0")]
[assembly: AssemblyCompany("BigActions")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("BigActions")]
[assembly: AssemblyTitle("BigActions")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
[CompilerGenerated]
[Embedded]
internal sealed class EmbeddedAttribute : Attribute
{
}
}
namespace System.Runtime.CompilerServices
{
[CompilerGenerated]
[Embedded]
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
internal sealed class NullableAttribute : Attribute
{
public readonly byte[] NullableFlags;
public NullableAttribute(byte P_0)
{
NullableFlags = new byte[1] { P_0 };
}
public NullableAttribute(byte[] P_0)
{
NullableFlags = P_0;
}
}
[CompilerGenerated]
[Embedded]
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
internal sealed class NullableContextAttribute : Attribute
{
public readonly byte Flag;
public NullableContextAttribute(byte P_0)
{
Flag = P_0;
}
}
[CompilerGenerated]
[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 BigActions
{
[BepInPlugin("com.ruan.bigactions", "Big Actions", "1.0.0")]
public sealed class Plugin : BasePlugin
{
public const string Guid = "com.ruan.bigactions";
public const string Name = "Big Actions";
public const string Version = "1.0.0";
internal static ManualLogSource Logger;
public override void Load()
{
//IL_0071: Unknown result type (might be due to invalid IL or missing references)
//IL_0077: Expected O, but got Unknown
//IL_0038: Unknown result type (might be due to invalid IL or missing references)
Logger = ((BasePlugin)this).Log;
PluginConfig.Init(((BasePlugin)this).Config);
if (PluginConfig.EnableInteropDumper.Value)
{
InteropDumper.Dump();
}
if (PluginConfig.EnableGuardPatches.Value)
{
new Harmony("com.ruan.bigactions").PatchAll(typeof(SelfGuardPatches));
Logger.LogInfo((object)"SelfGuardPatches aplicados.");
}
ClassInjector.RegisterTypeInIl2Cpp<SelfStowInput>();
((BasePlugin)this).AddComponent<SelfStowInput>();
ManualLogSource logger = Logger;
bool flag = default(bool);
BepInExInfoLogInterpolatedStringHandler val = new BepInExInfoLogInterpolatedStringHandler(12, 2, ref flag);
if (flag)
{
((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>("Big Actions");
((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" ");
((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>("1.0.0");
((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" carregado.");
}
logger.LogInfo(val);
}
}
internal static class PluginConfig
{
public static ConfigEntry<bool> Enabled;
public static ConfigEntry<KeyCode> BackpackKey;
public static ConfigEntry<KeyCode> BeltKey;
public static ConfigEntry<BothFullBehavior> BothFull;
public static ConfigEntry<bool> EnableGuardPatches;
public static ConfigEntry<bool> EnableInteropDumper;
public static ConfigEntry<bool> Verbose;
public static void Init(ConfigFile config)
{
Enabled = config.Bind<bool>("General", "Enabled", true, "Liga/desliga o mod.");
BackpackKey = config.Bind<KeyCode>("Keys", "Backpack", (KeyCode)49, "Tecla pra mochila (toggle contextual: guarda/retira/troca conforme o estado).");
BeltKey = config.Bind<KeyCode>("Keys", "Belt", (KeyCode)50, "Tecla pro cinto (toggle contextual).");
BothFull = config.Bind<BothFullBehavior>("General", "BothOccupied", BothFullBehavior.DoNothing, "O que fazer quando mao E container estao cheios. O jogo nao tem swap nativo e voce so tem uma mao, entao troca atomica nao existe. DoNothing = seguro, nao faz nada. TryPlaceOverFull = experimental, so funciona se colocar num container cheio devolver o item antigo pra mao (a confirmar in-game).");
EnableGuardPatches = config.Bind<bool>("Advanced", "EnableGuardPatches", false, "Aplica Harmony prefixes pra neutralizar o bloqueio de auto-interacao nos proprios pockets. So ligue se a predicao do cliente brigar com o mod; o caminho principal chama os Commands direto, pulando a mira.");
EnableInteropDumper = config.Bind<bool>("Dev", "EnableInteropDumper", false, "Ferramenta de dev: despeja tipos/membros da interop que batem em keywords, num txt, no boot. Desligado por padrao.");
Verbose = config.Bind<bool>("General", "Verbose", false, "Logs verbosos de cada acao.");
}
}
}
namespace BigActions.Game
{
internal static class GameBindings
{
public static PlayerCharacter? LocalPlayer
{
get
{
if (!((Object)(object)WorldManager.localPlayerCharacter == (Object)null))
{
return WorldManager.localPlayerCharacter;
}
return null;
}
}
public static PropHome? BackpackSlot(PlayerCharacter player)
{
PlayerRegistry registry = player.registry;
if (registry != null)
{
return registry.backpackPocket;
}
return null;
}
public static PropHome? BeltSlot(PlayerCharacter player)
{
PlayerRegistry registry = player.registry;
if (registry != null)
{
return registry.holsterPocket;
}
return null;
}
public static bool HandOccupied(PlayerCharacter player)
{
PlayerHands hands = player.hands;
if (hands != null)
{
return hands.isHoldingSomething;
}
return false;
}
public static Prop? HeldProp(PlayerCharacter player)
{
PlayerHands hands = player.hands;
if (hands != null)
{
return hands.heldProp;
}
return null;
}
public static bool IsHomeEmpty(PropHome home)
{
return (Object)(object)home.pinnedProp == (Object)null;
}
public static Prop? PinnedProp(PropHome home)
{
return home.pinnedProp;
}
public static bool HomeAccepts(PropHome home, Prop prop)
{
return home.IsSafeToPlace(prop);
}
public static List<PropHome>? ContentPockets(Prop wearable)
{
return wearable.childPropHomes;
}
public static void PlaceInHome(PlayerCharacter player, Prop prop, PropHome home)
{
//IL_0008: Unknown result type (might be due to invalid IL or missing references)
player.playerNetworking.CmdPlaceInHome(prop, home.shellReference);
}
public static void TakeFromHome(PlayerCharacter player, Prop prop)
{
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
//IL_0011: Expected O, but got Unknown
player.playerNetworking.CmdPickUp(new PlayerHeldInformation(prop));
}
public static string HomeName(PropHome home)
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
return ((object)home.saveableHomeName/*cast due to .constrained prefix*/).ToString();
}
}
internal sealed class ItemContainer
{
private readonly PlayerCharacter _player;
private readonly PropHome _equipSlot;
private Prop? _held;
private Prop? _wearable;
private PropHome? _emptyFitPocket;
private PropHome? _occupiedPocket;
public ContainerKind Kind { get; }
public ItemContainer(PlayerCharacter player, ContainerKind kind, PropHome equipSlot)
{
_player = player;
Kind = kind;
_equipSlot = equipSlot;
}
public void Toggle()
{
_held = GameBindings.HeldProp(_player);
_wearable = GameBindings.PinnedProp(_equipSlot);
_emptyFitPocket = null;
_occupiedPocket = null;
bool heldFitsEquipSlot = (Object)(object)_held != (Object)null && GameBindings.IsHomeEmpty(_equipSlot) && GameBindings.HomeAccepts(_equipSlot, _held);
int value = 0;
if ((Object)(object)_wearable != (Object)null)
{
List<PropHome> val = GameBindings.ContentPockets(_wearable);
if (val != null)
{
value = val.Count;
if ((Object)(object)_held != (Object)null)
{
_emptyFitPocket = FirstEmptyAccepting(val, _held);
}
_occupiedPocket = FirstOccupied(val);
}
}
StowAction stowAction = StowDecider.Decide(new StowState((Object)(object)_held != (Object)null, heldFitsEquipSlot, (Object)(object)_wearable != (Object)null, (Object)(object)_emptyFitPocket != (Object)null, (Object)(object)_occupiedPocket != (Object)null));
Log($"held={(Object)(object)_held != (Object)null} equipado={(Object)(object)_wearable != (Object)null} bolsos={value} vaga={(Object)(object)_emptyFitPocket != (Object)null} item={(Object)(object)_occupiedPocket != (Object)null} -> {stowAction}");
StowExecutor.Execute(stowAction, this);
}
public void Equip()
{
if (!((Object)(object)_held == (Object)null))
{
GameBindings.PlaceInHome(_player, _held, _equipSlot);
}
}
public void Unequip()
{
if (!((Object)(object)_wearable == (Object)null))
{
GameBindings.TakeFromHome(_player, _wearable);
}
}
public void Stow()
{
if (!((Object)(object)_held == (Object)null) && !((Object)(object)_emptyFitPocket == (Object)null))
{
GameBindings.PlaceInHome(_player, _held, _emptyFitPocket);
}
}
public void Take()
{
if (!((Object)(object)_occupiedPocket == (Object)null))
{
Prop val = GameBindings.PinnedProp(_occupiedPocket);
if (!((Object)(object)val == (Object)null))
{
GameBindings.TakeFromHome(_player, val);
}
}
}
public void Swap()
{
if (!((Object)(object)_held == (Object)null) && !((Object)(object)_occupiedPocket == (Object)null))
{
GameBindings.PlaceInHome(_player, _held, _occupiedPocket);
}
}
private static PropHome? FirstEmptyAccepting(List<PropHome> pockets, Prop held)
{
for (int i = 0; i < pockets.Count; i++)
{
PropHome val = pockets[i];
if ((Object)(object)val != (Object)null && GameBindings.IsHomeEmpty(val) && GameBindings.HomeAccepts(val, held))
{
return val;
}
}
return null;
}
private static PropHome? FirstOccupied(List<PropHome> pockets)
{
for (int i = 0; i < pockets.Count; i++)
{
PropHome val = pockets[i];
if ((Object)(object)val != (Object)null && !GameBindings.IsHomeEmpty(val))
{
return val;
}
}
return null;
}
private void Log(string msg)
{
//IL_0015: Unknown result type (might be due to invalid IL or missing references)
//IL_001b: Expected O, but got Unknown
if (PluginConfig.Verbose.Value)
{
ManualLogSource logger = Plugin.Logger;
bool flag = default(bool);
BepInExInfoLogInterpolatedStringHandler val = new BepInExInfoLogInterpolatedStringHandler(3, 2, ref flag);
if (flag)
{
((BepInExLogInterpolatedStringHandler)val).AppendLiteral("[");
((BepInExLogInterpolatedStringHandler)val).AppendFormatted<ContainerKind>(Kind);
((BepInExLogInterpolatedStringHandler)val).AppendLiteral("] ");
((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(msg);
}
logger.LogInfo(val);
}
}
}
internal static class LocalPlayer
{
public static bool TryGetContainer(ContainerKind kind, out ItemContainer container)
{
container = null;
PlayerCharacter localPlayer = GameBindings.LocalPlayer;
if ((Object)(object)localPlayer == (Object)null)
{
return false;
}
PropHome val = ((kind == ContainerKind.Backpack) ? GameBindings.BackpackSlot(localPlayer) : GameBindings.BeltSlot(localPlayer));
if ((Object)(object)val == (Object)null)
{
return false;
}
container = new ItemContainer(localPlayer, kind, val);
return true;
}
public static bool InGameplay()
{
//IL_000f: Unknown result type (might be due to invalid IL or missing references)
//IL_0015: Invalid comparison between Unknown and I4
if ((Object)(object)GameBindings.LocalPlayer == (Object)null)
{
return false;
}
if ((int)Cursor.lockState != 1)
{
return false;
}
return true;
}
}
}
namespace BigActions.Features.SelfStow
{
public enum BothFullBehavior
{
DoNothing,
TryPlaceOverFull
}
public enum ContainerKind
{
Backpack,
Belt
}
internal static class SelfGuardPatches
{
[HarmonyPatch(/*Could not decode attribute arguments.*/)]
[HarmonyPrefix]
private static bool ForceAllowGrab(PropHome __instance, ref bool __result)
{
if (!IsLocalOwnPocket(__instance))
{
return true;
}
__result = false;
return false;
}
[HarmonyPatch(/*Could not decode attribute arguments.*/)]
[HarmonyPrefix]
private static bool ForceAllowPlace(PropHome __instance, ref bool __result)
{
if (!IsLocalOwnPocket(__instance))
{
return true;
}
__result = false;
return false;
}
private static bool IsLocalOwnPocket(PropHome home)
{
PlayerCharacter localPlayer = GameBindings.LocalPlayer;
if ((Object)(object)localPlayer != (Object)null && (Object)(object)home != (Object)null)
{
return (Object)(object)home.parentCharacter == (Object)(object)localPlayer;
}
return false;
}
}
internal sealed class SelfStowInput : MonoBehaviour
{
public SelfStowInput(IntPtr ptr)
: base(ptr)
{
}
private void Update()
{
//IL_001a: Unknown result type (might be due to invalid IL or missing references)
//IL_0032: Unknown result type (might be due to invalid IL or missing references)
if (PluginConfig.Enabled.Value && LocalPlayer.InGameplay())
{
if (Input.GetKeyDown(PluginConfig.BackpackKey.Value))
{
Trigger(ContainerKind.Backpack);
}
else if (Input.GetKeyDown(PluginConfig.BeltKey.Value))
{
Trigger(ContainerKind.Belt);
}
}
}
private static void Trigger(ContainerKind kind)
{
if (LocalPlayer.TryGetContainer(kind, out ItemContainer container))
{
container.Toggle();
}
}
}
public enum StowAction
{
None,
Equip,
Unequip,
Stow,
Take,
Swap
}
public static class StowDecider
{
public static StowAction Decide(StowState s)
{
if (s.HeldFitsEquipSlot)
{
return StowAction.Equip;
}
if (!s.WearableEquipped)
{
return StowAction.None;
}
if (s.HandOccupied)
{
if (s.PocketHasRoomForHeld)
{
return StowAction.Stow;
}
if (s.PocketHasItem)
{
return StowAction.Swap;
}
return StowAction.None;
}
if (s.PocketHasItem)
{
return StowAction.Take;
}
return StowAction.Unequip;
}
}
internal static class StowExecutor
{
public static void Execute(StowAction action, ItemContainer container)
{
switch (action)
{
case StowAction.Equip:
container.Equip();
break;
case StowAction.Unequip:
container.Unequip();
break;
case StowAction.Stow:
container.Stow();
break;
case StowAction.Take:
container.Take();
break;
case StowAction.Swap:
if (PluginConfig.BothFull.Value == BothFullBehavior.TryPlaceOverFull)
{
container.Swap();
}
break;
case StowAction.None:
break;
}
}
}
public readonly struct StowState
{
public readonly bool HandOccupied;
public readonly bool HeldFitsEquipSlot;
public readonly bool WearableEquipped;
public readonly bool PocketHasRoomForHeld;
public readonly bool PocketHasItem;
public StowState(bool handOccupied, bool heldFitsEquipSlot, bool wearableEquipped, bool pocketHasRoomForHeld, bool pocketHasItem)
{
HandOccupied = handOccupied;
HeldFitsEquipSlot = heldFitsEquipSlot;
WearableEquipped = wearableEquipped;
PocketHasRoomForHeld = pocketHasRoomForHeld;
PocketHasItem = pocketHasItem;
}
}
}
namespace BigActions.Features.Discovery
{
internal static class InteropDumper
{
private static readonly string[] Keywords = new string[18]
{
"Pocket", "Holster", "Backpack", "Belt", "Home", "Pin", "Prop", "Stow", "Hand", "Held",
"Cmd", "Rpc", "Server", "Snatch", "Grab", "Place", "Inventory", "Container"
};
private static readonly string[] TargetAssemblies = new string[2] { "Assembly-CSharp", "Mirror" };
public static void Dump()
{
//IL_01b6: Unknown result type (might be due to invalid IL or missing references)
//IL_01bd: Expected O, but got Unknown
//IL_0182: Unknown result type (might be due to invalid IL or missing references)
//IL_0189: Expected O, but got Unknown
bool flag = default(bool);
try
{
StringBuilder stringBuilder = new StringBuilder();
foreach (Assembly item in AppDomain.CurrentDomain.GetAssemblies().Where(delegate(Assembly a)
{
string name = a.GetName().Name;
return name != null && ((ReadOnlySpan<string>)TargetAssemblies).Contains(name);
}))
{
StringBuilder stringBuilder2 = stringBuilder;
StringBuilder.AppendInterpolatedStringHandler handler = new StringBuilder.AppendInterpolatedStringHandler(8, 1, stringBuilder2);
handler.AppendLiteral("=== ");
handler.AppendFormatted(item.GetName().Name);
handler.AppendLiteral(" ===");
stringBuilder2.AppendLine(ref handler);
foreach (Type item2 in from t in SafeTypes(item)
orderby t.FullName
select t)
{
if (Matches(item2.Name))
{
stringBuilder.AppendLine(item2.FullName);
MemberInfo[] members = item2.GetMembers(BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public);
foreach (MemberInfo memberInfo in members)
{
stringBuilder.Append(" ").AppendLine(memberInfo.ToString());
}
}
}
}
string text = Path.Combine(Paths.PluginPath, "BigActions");
Directory.CreateDirectory(text);
string text2 = Path.Combine(text, "interop-dump.txt");
File.WriteAllText(text2, stringBuilder.ToString());
ManualLogSource logger = Plugin.Logger;
BepInExInfoLogInterpolatedStringHandler val = new BepInExInfoLogInterpolatedStringHandler(26, 1, ref flag);
if (flag)
{
((BepInExLogInterpolatedStringHandler)val).AppendLiteral("InteropDumper: escrito em ");
((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(text2);
}
logger.LogInfo(val);
}
catch (Exception ex)
{
ManualLogSource logger2 = Plugin.Logger;
BepInExErrorLogInterpolatedStringHandler val2 = new BepInExErrorLogInterpolatedStringHandler(22, 1, ref flag);
if (flag)
{
((BepInExLogInterpolatedStringHandler)val2).AppendLiteral("InteropDumper falhou: ");
((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<Exception>(ex);
}
logger2.LogError(val2);
}
}
private static bool Matches(string name)
{
return Keywords.Any((string k) => name.IndexOf(k, StringComparison.OrdinalIgnoreCase) >= 0);
}
private static Type[] SafeTypes(Assembly asm)
{
try
{
return asm.GetTypes();
}
catch (ReflectionTypeLoadException ex)
{
return ex.Types.Where((Type t) => t != null).ToArray();
}
}
}
}
