using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using PutItBack.Extensions;
using UnityEngine;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETFramework,Version=v4.6.2", FrameworkDisplayName = ".NET Framework 4.6.2")]
[assembly: IgnoresAccessChecksTo("Assembly-CSharp")]
[assembly: AssemblyCompany("PutItBack")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.1.1.0")]
[assembly: AssemblyInformationalVersion("1.1.1+0c511421ed110e4a1f34753613ad7163a213647b")]
[assembly: AssemblyProduct("Put It Back")]
[assembly: AssemblyTitle("PutItBack")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.1.1.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;
}
}
}
internal sealed class ConfigurationManagerAttributes
{
public delegate void CustomHotkeyDrawerFunc(ConfigEntryBase setting, ref bool isCurrentlyAcceptingInput);
public bool? ShowRangeAsPercent;
public Action<ConfigEntryBase> CustomDrawer;
public CustomHotkeyDrawerFunc CustomHotkeyDrawer;
public bool? Browsable;
public string Category;
public object DefaultValue;
public bool? HideDefaultButton;
public bool? HideSettingName;
public string Description;
public string DispName;
public int? Order;
public bool? ReadOnly;
public bool? IsAdvanced;
public Func<object, string> ObjToStr;
public Func<string, object> StrToObj;
}
namespace PutItBack
{
public class HeldCardData
{
public int BinderPageIndex { get; set; }
public int BinderCardSlotIndex { get; set; }
public Transform Transform { get; set; }
public bool SortingChanged { get; set; }
}
[BepInPlugin("PutItBack", "Put It Back", "1.1.1")]
public class Plugin : BaseUnityPlugin
{
internal static ManualLogSource Logger;
private readonly Harmony m_Harmony = new Harmony("PutItBack");
private void Awake()
{
Logger = ((BaseUnityPlugin)this).Logger;
Settings.Instance.Load(this);
m_Harmony.PatchAll();
Logger.LogInfo((object)"Plugin PutItBack v:1.1.1 by GhostNarwhal is loaded!");
}
private void OnDestroy()
{
m_Harmony.UnpatchSelf();
Logger.LogInfo((object)"Plugin Put It Back is unloaded!");
}
}
public class PutItBack : CSingleton<PutItBack>
{
private bool m_IsReturningCard;
private List<HeldCardData> m_HeldCardDataList = new List<HeldCardData>();
private ECollectionSortingType m_SortingType;
private bool m_EnabledWithBinderOpen;
private void Awake()
{
Settings.Instance.isPutItBackEnabled.SettingChanged += delegate
{
((Behaviour)this).enabled = Settings.Instance.isPutItBackEnabled.Value;
};
m_EnabledWithBinderOpen = Settings.Instance.enableWithBinderClosed.Value;
Settings.Instance.enableWithBinderClosed.SettingChanged += delegate
{
m_EnabledWithBinderOpen = Settings.Instance.enableWithBinderClosed.Value;
};
}
private void OnDisable()
{
m_HeldCardDataList.Clear();
}
public void InteractionPlayerControllerOnUpdate(InteractionPlayerController interactionPlayerController)
{
if (!((Behaviour)this).enabled || interactionPlayerController.m_IsViewCardAlbumMode || interactionPlayerController.m_CurrentCardCompartment != null || !m_EnabledWithBinderOpen)
{
return;
}
_ = interactionPlayerController.m_CurrentHoldingCard3dList;
if (Input.GetMouseButtonDown(0))
{
ReturnLastCardToBinder(delegate
{
interactionPlayerController.ExitHoldCardMode();
});
}
}
public void CollectionBinderFlipAnimCtrlOnUpdate(CollectionBinderFlipAnimCtrl collectionBinderFlipAnimCtrl)
{
//IL_0012: Unknown result type (might be due to invalid IL or missing references)
//IL_0017: Unknown result type (might be due to invalid IL or missing references)
//IL_0021: Unknown result type (might be due to invalid IL or missing references)
//IL_004f: Unknown result type (might be due to invalid IL or missing references)
if (((Behaviour)this).enabled && collectionBinderFlipAnimCtrl.m_IsBookOpen)
{
m_SortingType = collectionBinderFlipAnimCtrl.m_SortingType;
if (UnityInput.Current.mouseScrollDelta.y > 0f && CSingleton<InteractionPlayerController>.Instance.m_CurrentHoldingCard3dList.Count > 0)
{
collectionBinderFlipAnimCtrl.OnMouseButtonUp();
}
if (UnityInput.Current.mouseScrollDelta.y < 0f)
{
collectionBinderFlipAnimCtrl.OnRightMouseButtonUp();
}
}
}
public bool OnRightMouseButtonUp(CollectionBinderFlipAnimCtrl collectionBinderFlipAnimCtrl)
{
if (((Behaviour)this).enabled && !m_IsReturningCard)
{
InteractableCard3d currentRaycastedInteractableCard3d = collectionBinderFlipAnimCtrl.m_CurrentRaycastedInteractableCard3d;
bool? flag = ((currentRaycastedInteractableCard3d != null) ? new bool?(currentRaycastedInteractableCard3d.m_Card3dUI.m_CardUI.GetCardData().IsOwned()) : null);
if (!flag.HasValue || !flag.Value)
{
return false;
}
if (InteractionPlayerController.HasEnoughSlotToHoldCard())
{
List<HeldCardData> heldCardDataList = m_HeldCardDataList;
HeldCardData obj = new HeldCardData
{
BinderCardSlotIndex = collectionBinderFlipAnimCtrl.m_CurrentRaycastedCardIndex,
BinderPageIndex = collectionBinderFlipAnimCtrl.m_Index
};
InteractableCard3d currentRaycastedInteractableCard3d2 = collectionBinderFlipAnimCtrl.m_CurrentRaycastedInteractableCard3d;
obj.Transform = ((currentRaycastedInteractableCard3d2 != null) ? ((Component)currentRaycastedInteractableCard3d2).transform : null);
obj.SortingChanged = false;
heldCardDataList.Add(obj);
}
}
return true;
}
public bool OnLeftMouseButtonUp(CollectionBinderFlipAnimCtrl collectionBinderFlipAnimCtrl)
{
if (((Behaviour)this).enabled && !m_IsReturningCard && m_HeldCardDataList.Count > 0 && !collectionBinderFlipAnimCtrl.m_CollectionBinderUI.m_SortAlbumScreen.activeSelf && !collectionBinderFlipAnimCtrl.m_IsSorting && CSingleton<InteractionPlayerController>.Instance.m_CurrentHoldingCard3dList.Count > 0)
{
int num = m_HeldCardDataList.Last().BinderCardSlotIndex;
int num2 = m_HeldCardDataList.Last().BinderPageIndex - collectionBinderFlipAnimCtrl.m_Index;
int index = 0;
if (num2 <= -1)
{
int num3 = num;
int num4;
switch (num)
{
case 8:
case 11:
num4 = 8;
break;
case 7:
case 10:
num4 = 6;
break;
case 6:
case 9:
num4 = 4;
break;
default:
num4 = 0;
break;
}
num = num3 - num4;
index = 2;
}
else if (num2 >= 1)
{
int num4 = num;
int num3;
switch (num)
{
case 0:
case 3:
num3 = 8;
break;
case 1:
case 4:
num3 = 6;
break;
case 2:
case 5:
num3 = 4;
break;
default:
num3 = 0;
break;
}
num = num4 + num3;
index = 1;
}
Transform transform = ((Component)collectionBinderFlipAnimCtrl.m_BinderPageGrpList[index].m_CardList[num]).transform;
((InteractableObject)CSingleton<InteractionPlayerController>.Instance.m_CurrentHoldingCard3dList.Last()).StopLerpToTransform();
((InteractableObject)CSingleton<InteractionPlayerController>.Instance.m_CurrentHoldingCard3dList.Last()).LerpToTransform(transform, transform.parent);
m_IsReturningCard = true;
return false;
}
return true;
}
public void OnCardFinishLerp(ref InteractableCard3d interactableCard3D)
{
if (((Behaviour)this).enabled && m_IsReturningCard && CSingleton<InteractionPlayerController>.Instance.m_CurrentHoldingCard3dList.Count > 0)
{
ReturnLastCardToBinder(delegate
{
CSingleton<InteractionPlayerController>.Instance.EnterViewCardAlbumMode();
});
m_IsReturningCard = false;
}
}
private void ReturnLastCardToBinder(Action emptyHandAction)
{
//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
if (CSingleton<InteractionPlayerController>.Instance.m_CurrentHoldingCard3dList.Count <= 0)
{
return;
}
CPlayerData.AddCard(CSingleton<InteractionPlayerController>.Instance.m_CurrentHoldingCard3dList.Last().m_Card3dUI.m_CardUI.GetCardData(), 1);
if (CSingleton<CollectionBinderFlipAnimCtrl>.Instance.m_IsBookOpen)
{
int num = m_HeldCardDataList.Last().BinderPageIndex - CSingleton<CollectionBinderFlipAnimCtrl>.Instance.m_Index;
if (num >= -1 && num <= 1 && !m_HeldCardDataList.Last().SortingChanged)
{
int index = ((num == -1) ? 2 : num);
int cardAmount = CPlayerData.GetCardAmount(CSingleton<InteractionPlayerController>.Instance.m_CurrentHoldingCard3dList.Last().m_Card3dUI.m_CardUI.m_CardData);
CSingleton<CollectionBinderFlipAnimCtrl>.Instance.m_BinderPageGrpList[index].SetSingleCard(m_HeldCardDataList.Last().BinderCardSlotIndex, CSingleton<InteractionPlayerController>.Instance.m_CurrentHoldingCard3dList.Last().m_Card3dUI.m_CardUI.m_CardData, cardAmount, m_SortingType);
((Component)CSingleton<CollectionBinderFlipAnimCtrl>.Instance.m_BinderPageGrpList[index].m_CardList[m_HeldCardDataList.Last().BinderCardSlotIndex]).gameObject.SetActive(true);
((Component)m_HeldCardDataList.Last().Transform).gameObject.SetActive(true);
}
}
((InteractableObject)CSingleton<InteractionPlayerController>.Instance.m_CurrentHoldingCard3dList.Last()).OnDestroyed();
CSingleton<InteractionPlayerController>.Instance.m_CurrentHoldingCard3dList.RemoveAt(CSingleton<InteractionPlayerController>.Instance.m_CurrentHoldingCard3dList.Count - 1);
CPlayerData.m_HoldCardDataList.RemoveAt(CPlayerData.m_HoldCardDataList.Count - 1);
while (CSingleton<InteractionPlayerController>.Instance.m_CurrentHoldingCard3dList.Count < m_HeldCardDataList.Count)
{
m_HeldCardDataList.RemoveAt(m_HeldCardDataList.Count - 1);
}
SetHoldCardEularRotation(CSingleton<InteractionPlayerController>.Instance.m_CurrentHoldingCard3dList.Count, emptyHandAction);
}
private void SetHoldCardEularRotation(int heldCardCount, Action emptyHandAction)
{
//IL_0051: Unknown result type (might be due to invalid IL or missing references)
//IL_0056: Unknown result type (might be due to invalid IL or missing references)
//IL_0017: Unknown result type (might be due to invalid IL or missing references)
//IL_001c: Unknown result type (might be due to invalid IL or missing references)
if (heldCardCount == 0)
{
CSingleton<InteractionPlayerController>.Instance.m_HoldCardGrpTargetRotation = Quaternion.Euler(0f, 0f, 0f);
emptyHandAction?.Invoke();
}
else
{
CSingleton<InteractionPlayerController>.Instance.m_HoldCardGrpTargetRotation = Quaternion.Euler(0f, 0f, Mathf.Lerp(0f, 15f, (float)heldCardCount / 7f));
}
}
public void OnSortingMethodChange()
{
if (!((Behaviour)this).enabled || m_HeldCardDataList.Count <= 0)
{
return;
}
foreach (HeldCardData heldCardData in m_HeldCardDataList)
{
heldCardData.SortingChanged = true;
}
}
}
public class Settings
{
public ConfigEntry<bool> isPutItBackEnabled;
public ConfigEntry<bool> enableWithBinderClosed;
private static Settings m_instance;
public static Settings Instance
{
get
{
if (m_instance == null)
{
m_instance = new Settings();
}
return m_instance;
}
}
public void Load(Plugin plugin)
{
//IL_0033: Unknown result type (might be due to invalid IL or missing references)
//IL_003d: Expected O, but got Unknown
//IL_0075: Unknown result type (might be due to invalid IL or missing references)
//IL_007f: Expected O, but got Unknown
isPutItBackEnabled = ((BaseUnityPlugin)plugin).Config.Bind<bool>("Put It Back", "Enable", true, new ConfigDescription("Enables or disables put it back", (AcceptableValueBase)null, new object[1]
{
new ConfigurationManagerAttributes
{
Order = 20
}
}));
enableWithBinderClosed = ((BaseUnityPlugin)plugin).Config.Bind<bool>("Put It Back", "Enable With Binder Closed", true, new ConfigDescription("Disables putting cards back if binder is closed.", (AcceptableValueBase)null, new object[1]
{
new ConfigurationManagerAttributes
{
Order = 19
}
}));
}
private Settings()
{
}
}
public static class MyPluginInfo
{
public const string PLUGIN_GUID = "PutItBack";
public const string PLUGIN_NAME = "Put It Back";
public const string PLUGIN_VERSION = "1.1.1";
}
}
namespace PutItBack.Patches
{
[HarmonyPatch(typeof(CollectionBinderFlipAnimCtrl))]
public class CollectionBinderFlipAnimCtrlPatches
{
[HarmonyPatch("Update")]
[HarmonyPostfix]
private static void OnUpdatePostfix(CollectionBinderFlipAnimCtrl __instance)
{
CSingleton<PutItBack>.Instance.CollectionBinderFlipAnimCtrlOnUpdate(__instance);
}
[HarmonyPatch("OnMouseButtonUp")]
[HarmonyPrefix]
private static bool OnMouseButtonUpPrefix(CollectionBinderFlipAnimCtrl __instance)
{
return CSingleton<PutItBack>.Instance.OnLeftMouseButtonUp(__instance);
}
[HarmonyPatch("OnRightMouseButtonUp")]
[HarmonyPrefix]
private static bool OnRightMouseButtonUpPrefix(CollectionBinderFlipAnimCtrl __instance)
{
return CSingleton<PutItBack>.Instance.OnRightMouseButtonUp(__instance);
}
[HarmonyPatch("OnPressSwitchSortingMethod")]
[HarmonyPrefix]
private static void OnSortingMethodChange(int sortingMethodIndex)
{
CSingleton<PutItBack>.Instance.OnSortingMethodChange();
}
[HarmonyPatch("OnPressSwitchExpansion")]
[HarmonyPrefix]
private static void OnExpansionChange(int expansionIndex)
{
CSingleton<PutItBack>.Instance.OnSortingMethodChange();
}
}
[HarmonyPatch(typeof(InteractionPlayerController))]
public class InteractionPlayerControllerPatches
{
[HarmonyPatch("Update")]
[HarmonyPostfix]
private static void OnUpdatePostfix(InteractionPlayerController __instance)
{
CSingleton<PutItBack>.Instance.InteractionPlayerControllerOnUpdate(__instance);
}
}
}
namespace PutItBack.Extensions
{
public static class CardDataExt
{
public static bool IsOwned(this CardData cardData)
{
return CPlayerData.GetCardAmount(cardData) > 0;
}
}
[HarmonyPatch(typeof(InteractableCard3d))]
internal class InteractableCard3dPatches
{
[HarmonyPatch("OnFinishLerp")]
[HarmonyPostfix]
private static void OnFinishLerpPostfix(ref InteractableCard3d __instance)
{
CSingleton<PutItBack>.Instance.OnCardFinishLerp(ref __instance);
}
}
}
namespace System.Runtime.CompilerServices
{
[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
internal sealed class IgnoresAccessChecksToAttribute : Attribute
{
internal IgnoresAccessChecksToAttribute(string assemblyName)
{
}
}
}
