using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using REPOLib;
using REPOLib.Modules;
using ScaleInCart.Classes;
using ScaleInCart.Enums;
using ScaleInCart.Structs;
using UnityEngine;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: AssemblyTitle("ScaleInCart")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("ScaleInCart")]
[assembly: AssemblyCopyright("Copyright © 2024")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("5e12a72d-c200-488d-940a-653d1003d96e")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace ScaleInCart
{
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInPlugin("bulletbot.scaleincart", "ScaleInCart", "1.2.1")]
internal class Plugin : BaseUnityPlugin
{
public static class REPOLib
{
public const string modGUID = "REPOLib";
public static bool IsLoaded()
{
return Chainloader.PluginInfos.ContainsKey("REPOLib");
}
public static void OnAwake()
{
BundleLoader.OnAllBundlesLoaded += delegate
{
foreach (PrefabRef registeredValuable in Valuables.RegisteredValuables)
{
ValuableObject component = registeredValuable.Prefab.GetComponent<ValuableObject>();
if ((Object)(object)component != (Object)null)
{
instance.SetupValuableObject(component, isModded: true);
}
}
instance.LogMessages();
};
}
}
private const string modGUID = "bulletbot.scaleincart";
private const string modName = "ScaleInCart";
private const string modVer = "1.2.1";
public static Plugin instance;
public ManualLogSource logger;
private readonly Harmony harmony = new Harmony("bulletbot.scaleincart");
public Dictionary<PhysGrabCart, List<PhysGrabObject>> grabObjectsInCarts;
public Dictionary<PhysGrabObject, PhysGrabObjectData> grabObjectDatas;
public List<Vector2> massScaleFactorsList;
public List<Vector2> customScaleCurvesList;
public ConfigEntry<bool> printCartNames;
public ConfigEntry<bool> printValuables;
public ConfigEntry<bool> scaleEverything;
public ConfigEntry<string> excludeCartNames;
public ConfigEntry<bool> revertBackToOriginalScale;
private ConfigEntry<ScaleCurveType> scaleCurveType;
private ConfigEntry<ScaleCurveDirection> scaleCurveDirection;
private ConfigEntry<string> customScaleCurves;
public ConfigEntry<float> scaleSpeed;
public ConfigEntry<float> scaleDelay;
public ConfigEntry<bool> scaleMass;
public ConfigEntry<float> defaultScale;
public ConfigEntry<bool> useMassScaling;
public ConfigEntry<string> massScaleFactors;
public ConfigEntry<float> massScaleDefaultScale;
public Dictionary<string, ValuableConfig> valuableConfigs;
public int vanillaCount;
public int moddedCount = -1;
public static string GetBaseName(string name)
{
return name.Replace("(Clone)", "");
}
public static float GetEffectiveUniformScale(Vector3 vectorScale)
{
//IL_0000: 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)
//IL_000d: Unknown result type (might be due to invalid IL or missing references)
return Mathf.Pow(vectorScale.x * vectorScale.y * vectorScale.z, 1f / 3f);
}
public static float EvaluateScaleCurve(float progress)
{
//IL_0723: Unknown result type (might be due to invalid IL or missing references)
//IL_075f: Unknown result type (might be due to invalid IL or missing references)
//IL_073f: Unknown result type (might be due to invalid IL or missing references)
//IL_0779: Unknown result type (might be due to invalid IL or missing references)
//IL_0796: Unknown result type (might be due to invalid IL or missing references)
//IL_079b: Unknown result type (might be due to invalid IL or missing references)
//IL_07a3: Unknown result type (might be due to invalid IL or missing references)
//IL_07a8: Unknown result type (might be due to invalid IL or missing references)
//IL_07ab: Unknown result type (might be due to invalid IL or missing references)
//IL_07b5: Unknown result type (might be due to invalid IL or missing references)
//IL_0826: Unknown result type (might be due to invalid IL or missing references)
//IL_07cc: Unknown result type (might be due to invalid IL or missing references)
//IL_07d4: Unknown result type (might be due to invalid IL or missing references)
//IL_07db: Unknown result type (might be due to invalid IL or missing references)
//IL_07e6: Unknown result type (might be due to invalid IL or missing references)
//IL_07ed: Unknown result type (might be due to invalid IL or missing references)
progress = Mathf.Clamp01(progress);
float num = progress;
switch (instance.scaleCurveType.Value)
{
case ScaleCurveType.SmoothStep:
num = progress * progress * (3f - 2f * progress);
break;
case ScaleCurveType.QuadIn:
num = progress * progress;
break;
case ScaleCurveType.QuadOut:
num = 1f - (1f - progress) * (1f - progress);
break;
case ScaleCurveType.QuadInOut:
num = ((progress < 0.5f) ? (2f * progress * progress) : (1f - Mathf.Pow(-2f * progress + 2f, 2f) / 2f));
break;
case ScaleCurveType.CubicIn:
num = progress * progress * progress;
break;
case ScaleCurveType.CubicOut:
{
float num8 = 1f - progress;
num = 1f - num8 * num8 * num8;
break;
}
case ScaleCurveType.CubicInOut:
num = ((progress < 0.5f) ? (4f * progress * progress * progress) : (1f - Mathf.Pow(-2f * progress + 2f, 3f) / 2f));
break;
case ScaleCurveType.QuartIn:
num = progress * progress * progress * progress;
break;
case ScaleCurveType.QuartOut:
{
float num4 = 1f - progress;
num = 1f - num4 * num4 * num4 * num4;
break;
}
case ScaleCurveType.QuartInOut:
num = ((progress < 0.5f) ? (8f * Mathf.Pow(progress, 4f)) : (1f - Mathf.Pow(-2f * progress + 2f, 4f) / 2f));
break;
case ScaleCurveType.QuintIn:
num = Mathf.Pow(progress, 5f);
break;
case ScaleCurveType.QuintOut:
{
float num7 = 1f - progress;
num = 1f - Mathf.Pow(num7, 5f);
break;
}
case ScaleCurveType.QuintInOut:
num = ((progress < 0.5f) ? (16f * Mathf.Pow(progress, 5f)) : (1f - Mathf.Pow(-2f * progress + 2f, 5f) / 2f));
break;
case ScaleCurveType.SineIn:
num = 1f - Mathf.Cos(progress * (float)Math.PI / 2f);
break;
case ScaleCurveType.SineOut:
num = Mathf.Sin(progress * (float)Math.PI / 2f);
break;
case ScaleCurveType.SineInOut:
num = (0f - (Mathf.Cos((float)Math.PI * progress) - 1f)) / 2f;
break;
case ScaleCurveType.ExpoIn:
num = ((progress != 0f) ? Mathf.Pow(2f, 10f * (progress - 1f)) : 0f);
break;
case ScaleCurveType.ExpoOut:
num = ((progress != 1f) ? (1f - Mathf.Pow(2f, -10f * progress)) : 1f);
break;
case ScaleCurveType.ExpoInOut:
num = ((progress != 0f) ? ((progress != 1f) ? ((progress < 0.5f) ? (Mathf.Pow(2f, 20f * progress - 10f) / 2f) : ((2f - Mathf.Pow(2f, -20f * progress + 10f)) / 2f)) : 1f) : 0f);
break;
case ScaleCurveType.CircIn:
num = 1f - Mathf.Sqrt(1f - progress * progress);
break;
case ScaleCurveType.CircOut:
{
float num6 = progress - 1f;
num = Mathf.Sqrt(1f - num6 * num6);
break;
}
case ScaleCurveType.CircInOut:
num = ((progress < 0.5f) ? ((1f - Mathf.Sqrt(1f - 4f * progress * progress)) / 2f) : ((Mathf.Sqrt(1f - Mathf.Pow(-2f * progress + 2f, 2f)) + 1f) / 2f));
break;
case ScaleCurveType.BackIn:
num = 2.70158f * progress * progress * progress - 1.70158f * progress * progress;
break;
case ScaleCurveType.BackOut:
{
float num5 = progress - 1f;
num = 1f + 2.70158f * num5 * num5 * num5 + 1.70158f * num5 * num5;
break;
}
case ScaleCurveType.BackInOut:
num = ((progress < 0.5f) ? (Mathf.Pow(2f * progress, 2f) * (7.189819f * progress - 2.5949094f) / 2f) : ((Mathf.Pow(2f * progress - 2f, 2f) * (3.5949094f * (progress * 2f - 2f) + 2.5949094f) + 2f) / 2f));
break;
case ScaleCurveType.ElasticIn:
num = ((progress != 0f) ? ((progress != 1f) ? ((0f - Mathf.Pow(2f, 10f * progress - 10f)) * Mathf.Sin((progress * 10f - 10.75f) * ((float)Math.PI * 2f / 3f))) : 1f) : 0f);
break;
case ScaleCurveType.ElasticOut:
num = ((progress != 0f) ? ((progress != 1f) ? (Mathf.Pow(2f, -10f * progress) * Mathf.Sin((progress * 10f - 0.75f) * ((float)Math.PI * 2f / 3f)) + 1f) : 1f) : 0f);
break;
case ScaleCurveType.ElasticInOut:
num = ((progress != 0f) ? ((progress != 1f) ? ((progress < 0.5f) ? ((0f - Mathf.Pow(2f, 20f * progress - 10f) * Mathf.Sin((20f * progress - 11.125f) * ((float)Math.PI * 4f / 9f))) / 2f) : (Mathf.Pow(2f, -20f * progress + 10f) * Mathf.Sin((20f * progress - 11.125f) * ((float)Math.PI * 4f / 9f)) / 2f + 1f)) : 1f) : 0f);
break;
case ScaleCurveType.BounceIn:
num = 1f - Bounce(1f - progress);
break;
case ScaleCurveType.BounceOut:
num = Bounce(progress);
break;
case ScaleCurveType.BounceInOut:
num = ((progress < 0.5f) ? ((1f - Bounce(1f - 2f * progress)) / 2f) : ((1f + Bounce(2f * progress - 1f)) / 2f));
break;
case ScaleCurveType.Custom:
{
List<Vector2> list = instance.customScaleCurvesList;
if (list.Count == 0)
{
num = progress;
break;
}
if (list.Count == 1 || progress <= list[0].x)
{
num = list[0].y;
break;
}
int num2 = list.Count - 1;
if (progress >= list[num2].x)
{
num = list[num2].y;
break;
}
bool flag = false;
for (int i = 0; i < num2; i++)
{
Vector2 val = list[i];
Vector2 val2 = list[i + 1];
if (progress >= val.x && progress <= val2.x)
{
float num3 = (progress - val.x) / (val2.x - val.x);
num = Mathf.Lerp(val.y, val2.y, num3);
flag = true;
break;
}
}
if (!flag)
{
num = list[num2].y;
}
break;
}
}
return Mathf.Clamp01(num);
static float Bounce(float t)
{
if (t < 0.36363637f)
{
return 7.5625f * t * t;
}
if (t < 0.72727275f)
{
t -= 0.54545456f;
return 7.5625f * t * t + 0.75f;
}
if (t < 0.90909094f)
{
t -= 0.8181818f;
return 7.5625f * t * t + 0.9375f;
}
t -= 21f / 22f;
return 7.5625f * t * t + 63f / 64f;
}
}
public static float GetCurveDirection(float targetProgress, float value)
{
value = Mathf.Clamp01(value);
return instance.scaleCurveDirection.Value switch
{
ScaleCurveDirection.SameBothWays => (targetProgress == 1f) ? value : (1f - value),
ScaleCurveDirection.SameBothWaysFlipped => (targetProgress == 1f) ? (1f - value) : value,
_ => value,
};
}
public static float GetCurveTime(float targetProgress, float progress)
{
progress = Mathf.Clamp01(progress);
float curveDirection = GetCurveDirection(targetProgress, progress);
float value = EvaluateScaleCurve(curveDirection);
float curveDirection2 = GetCurveDirection(targetProgress, value);
return Mathf.Clamp01(curveDirection2);
}
public static float FindProgressForTime(float targetProgress, float desiredTime)
{
desiredTime = Mathf.Clamp01(desiredTime);
float num = 0f;
float num2 = 1f;
for (int i = 0; i < 10; i++)
{
float num3 = 0.5f * (num + num2);
float curveTime = GetCurveTime(targetProgress, num3);
if (curveTime < desiredTime)
{
num = num3;
}
else
{
num2 = num3;
}
}
return 0.5f * (num + num2);
}
private void SetupValuableObject(ValuableObject valuableObject, bool isModded = false)
{
string name = ((Object)valuableObject).name;
if (valuableConfigs.ContainsKey(name))
{
return;
}
string text = (isModded ? "Modded " : "") + "Valuable Scaling (" + name + ")";
ValuableConfig valuableConfig = new ValuableConfig();
valuableConfig.generateConfig = ((BaseUnityPlugin)this).Config.Bind<bool>(text, "Generate Config", false, "If enabled, this will generate config for this valuable. (Note: Restarting the game is required.)");
if (valuableConfig.generateConfig.Value)
{
valuableConfig.useValuableScale = ((BaseUnityPlugin)this).Config.Bind<bool>(text, "Use Valuable Scale", false, "If enabled, this will force the valuable scale to be used no matter what the \"Use Mass Scaling\" and \"Default Scale\" value would be.");
valuableConfig.valuableScale = ((BaseUnityPlugin)this).Config.Bind<float>(text, "Valuable Scale", 1f, "Determines the scale factor for this valuable.");
valuableConfig.useValuableMassScale = ((BaseUnityPlugin)this).Config.Bind<bool>(text, "Use Valuable Mass Scale", false, "If enabled, this will force the valuable mass scale to be used no matter what the \"Scale Mass\" value would be.");
valuableConfig.valuableMassScale = ((BaseUnityPlugin)this).Config.Bind<float>(text, "Valuable Mass Scale", 1f, "Determines the mass scale factor for this valuable.");
}
valuableConfigs[name] = valuableConfig;
if (isModded)
{
if (moddedCount == -1)
{
moddedCount = 0;
}
moddedCount++;
}
else
{
vanillaCount++;
}
}
public void LogMessages()
{
logger.LogMessage((object)$"Found {massScaleFactorsList.Count} mass scale factors.");
logger.LogMessage((object)$"Found {customScaleCurvesList.Count} custom scale curves.");
logger.LogMessage((object)$"Found {vanillaCount} vanilla valuables.");
if (moddedCount != -1)
{
logger.LogMessage((object)$"Found {moddedCount} modded valuables.");
}
logger.LogMessage((object)$"Found {valuableConfigs.Count} valuables in total.");
}
private void Awake()
{
//IL_0329: Unknown result type (might be due to invalid IL or missing references)
//IL_04c2: Unknown result type (might be due to invalid IL or missing references)
instance = this;
logger = Logger.CreateLogSource("ScaleInCart");
grabObjectsInCarts = new Dictionary<PhysGrabCart, List<PhysGrabObject>>();
grabObjectDatas = new Dictionary<PhysGrabObject, PhysGrabObjectData>();
massScaleFactorsList = new List<Vector2>();
customScaleCurvesList = new List<Vector2>();
string text = "! Debugging !";
printCartNames = ((BaseUnityPlugin)this).Config.Bind<bool>(text, "Print Cart Names", false, "If enabled, the cart names will be printed to the console. (Note: Prints at the start of the level.)");
printValuables = ((BaseUnityPlugin)this).Config.Bind<bool>(text, "Print Valuables", false, "If enabled, the valuables data will be printed to the console. (Note: Prints while grabbing the valuable.)");
string text2 = "! General !";
scaleEverything = ((BaseUnityPlugin)this).Config.Bind<bool>(text2, "Scale Everything", false, "If enabled, every grabbable object will be scaled.\nIf disabled, only valuables will be scaled.");
excludeCartNames = ((BaseUnityPlugin)this).Config.Bind<string>(text2, "Exclude Cart Names", "", "Exclude specific carts from scaling their items by listing their names, separated by commas.");
revertBackToOriginalScale = ((BaseUnityPlugin)this).Config.Bind<bool>(text2, "Revert Back To Original Scale", true, "If enabled, valuables will revert to their original scale when not in the cart.\nIf disabled, valuables will remain at their modified scale.");
string text3 = "! Scaling - General !";
scaleCurveType = ((BaseUnityPlugin)this).Config.Bind<ScaleCurveType>(text3, "Scale Curve Type", ScaleCurveType.Linear, "Determines how valuables scale based on the curving style.");
customScaleCurves = ((BaseUnityPlugin)this).Config.Bind<string>(text3, "Custom Scale Curves", "0.0=0.0, 0.3=1.0, 0.5=0.5, 0.7=1.0, 1.0=1.0", "Curve values based on specific time points. Used when \"Scale Curve Type\" is set to Custom.\nFormat: \"time=value\", separated by commas.");
scaleCurveDirection = ((BaseUnityPlugin)this).Config.Bind<ScaleCurveDirection>(text3, "Scale Curve Direction", ScaleCurveDirection.SameBothWays, "Determines how the scale curve behaves during scaling.");
scaleSpeed = ((BaseUnityPlugin)this).Config.Bind<float>(text3, "Scale Speed", 0.45f, "Determines how quickly valuables scale over time. Higher values make them scale faster.");
scaleDelay = ((BaseUnityPlugin)this).Config.Bind<float>(text3, "Scale Delay", 0f, "The initial delay in seconds before valuables begin scaling.");
scaleMass = ((BaseUnityPlugin)this).Config.Bind<bool>(text3, "Scale Mass", true, "If enabled, valuables will scale their mass.\nIf disabled, valuables will not scale their mass.");
defaultScale = ((BaseUnityPlugin)this).Config.Bind<float>(text3, "Default Scale", 0.8f, "Default scale factor for valuables when \"Use Mass Scaling\" is disabled.");
string text4 = "! Scaling - Mass !";
useMassScaling = ((BaseUnityPlugin)this).Config.Bind<bool>(text4, "Use Mass Scaling", true, "If enabled, valuables will scale based on their mass.\nIf disabled, valuables will scale based on their valuable scale or default scale setting.");
massScaleFactors = ((BaseUnityPlugin)this).Config.Bind<string>(text4, "Scale Factors", "1.0=0.75, 1.5=0.7, 2.0=0.65, 2.5=0.6, 3.0=0.55, 3.5=0.5, 4.0=0.45, 4.5=0.4, 5.0=0.35", "Scale factors based on minimum mass thresholds.\nFormat: \"mass=scale\", separated by commas.");
massScaleDefaultScale = ((BaseUnityPlugin)this).Config.Bind<float>(text4, "Default Scale", 0.8f, "Default scale factor for valuables if no mass threshold is met.");
try
{
string[] array = massScaleFactors.Value.Split(new char[1] { ',' });
foreach (string text5 in array)
{
string[] array2 = (from x in text5.Split(new char[1] { '=' })
select x.Trim()).ToArray();
if (array2.Length == 2)
{
float mass = float.Parse(array2[0], CultureInfo.InvariantCulture);
if (massScaleFactorsList.Any((Vector2 x) => Mathf.Approximately(x.x, mass)))
{
logger.LogWarning((object)$"Duplicate found for mass \"{mass}\".");
continue;
}
float num = float.Parse(array2[1], CultureInfo.InvariantCulture);
massScaleFactorsList.Add(new Vector2(mass, num));
}
}
massScaleFactorsList.Sort((Vector2 a, Vector2 b) => b.x.CompareTo(a.x));
string[] array3 = customScaleCurves.Value.Split(new char[1] { ',' });
foreach (string text6 in array3)
{
string[] array4 = (from x in text6.Split(new char[1] { '=' })
select x.Trim()).ToArray();
if (array4.Length != 2)
{
continue;
}
float num2 = float.Parse(array4[0], CultureInfo.InvariantCulture);
bool flag = num2 < 0f || num2 > 1f;
float time = Mathf.Clamp01(num2);
if (customScaleCurvesList.Any((Vector2 x) => Mathf.Approximately(x.x, time)))
{
if (flag)
{
logger.LogWarning((object)$"Duplicate found for time \"{time}\" after clamping from \"{num2}\".");
}
else
{
logger.LogWarning((object)$"Duplicate found for time \"{time}\".");
}
}
else
{
float num3 = float.Parse(array4[1], CultureInfo.InvariantCulture);
customScaleCurvesList.Add(new Vector2(time, num3));
}
}
customScaleCurvesList.Sort((Vector2 a, Vector2 b) => a.x.CompareTo(b.x));
}
catch (Exception ex)
{
logger.LogError((object)("Error parsing mass scale factors or custom curve: " + ex.Message));
logger.LogError((object)"Failed to start ScaleInCart.");
return;
}
valuableConfigs = new Dictionary<string, ValuableConfig>();
ValuableObject[] array5 = Resources.LoadAll<ValuableObject>("Valuables/");
foreach (ValuableObject valuableObject in array5)
{
SetupValuableObject(valuableObject);
}
harmony.PatchAll();
logger.LogMessage((object)"ScaleInCart has started.");
if (REPOLib.IsLoaded())
{
REPOLib.OnAwake();
}
else
{
LogMessages();
}
}
}
}
namespace ScaleInCart.Structs
{
public readonly struct PhysGrabObjectScaleData
{
public readonly float? objectScale;
public readonly float? massScale;
public PhysGrabObjectScaleData(float? scale, float? massScale)
{
objectScale = scale;
this.massScale = massScale;
}
}
}
namespace ScaleInCart.Patches
{
[HarmonyPatch(typeof(RunManager))]
internal class RunManagerPatch
{
[HarmonyPatch("ChangeLevel")]
[HarmonyPrefix]
private static void ChangeLevel()
{
Plugin.instance.grabObjectsInCarts.Clear();
Plugin.instance.grabObjectDatas.Clear();
}
}
[HarmonyPatch(typeof(PhysGrabObject))]
internal class PhysGrabObjectPatch
{
public const float scaleProgressThreshold = 0.0001f;
[HarmonyPatch("Start")]
[HarmonyPostfix]
private static void Start(PhysGrabObject __instance)
{
Plugin.instance.grabObjectDatas[__instance] = new PhysGrabObjectData(__instance);
}
[HarmonyPatch("Update")]
[HarmonyPostfix]
private static void Update(PhysGrabObject __instance, bool ___isValuable)
{
//IL_028d: Unknown result type (might be due to invalid IL or missing references)
//IL_0292: Unknown result type (might be due to invalid IL or missing references)
//IL_0294: Unknown result type (might be due to invalid IL or missing references)
//IL_029d: Unknown result type (might be due to invalid IL or missing references)
//IL_02a2: Unknown result type (might be due to invalid IL or missing references)
//IL_02c6: Unknown result type (might be due to invalid IL or missing references)
//IL_038f: Unknown result type (might be due to invalid IL or missing references)
//IL_0391: Unknown result type (might be due to invalid IL or missing references)
//IL_0395: Unknown result type (might be due to invalid IL or missing references)
//IL_0336: Unknown result type (might be due to invalid IL or missing references)
//IL_0332: Unknown result type (might be due to invalid IL or missing references)
ItemEquippable component = ((Component)__instance).GetComponent<ItemEquippable>();
if (((Object)(object)component != (Object)null && component.IsEquipped()) || (!Plugin.instance.scaleEverything.Value && !___isValuable) || !Plugin.instance.grabObjectDatas.TryGetValue(__instance, out var value))
{
return;
}
PhysGrabObjectScaleData scaleData = value.GetScaleData();
float? objectScale = scaleData.objectScale;
if (!objectScale.HasValue)
{
return;
}
bool shouldScale = true;
bool flag = Plugin.instance.grabObjectsInCarts.Any(delegate(KeyValuePair<PhysGrabCart, List<PhysGrabObject>> x)
{
if (!x.Value.Contains(__instance))
{
return false;
}
shouldScale = !(from y in Plugin.instance.excludeCartNames.Value.Split(new char[1] { ',' })
select y.Trim()).Any((string y) => y.Contains(Plugin.GetBaseName(((Object)x.Key).name)));
return true;
});
if (!shouldScale)
{
return;
}
bool value2 = Plugin.instance.revertBackToOriginalScale.Value;
bool valueOrDefault = value.lastIsInCart.GetValueOrDefault(flag);
bool flag2 = valueOrDefault != flag;
if (!value.lastIsInCart.HasValue)
{
value.lastIsInCart = flag;
value.scaleProgress = (flag ? 1f : 0f);
}
else if (flag2)
{
value.lastIsInCart = flag;
if (value2)
{
float scaleProgress = value.scaleProgress;
if (scaleProgress <= 0.0001f || scaleProgress >= 0.9999f)
{
value.scaleProgress = (flag ? 0f : 1f);
}
else
{
value.scaleProgress = Plugin.FindProgressForTime(flag ? 1f : 0f, Plugin.GetCurveTime(valueOrDefault ? 1f : 0f, scaleProgress));
}
}
}
float num = (flag ? 1f : ((!value2) ? (-1f) : 0f));
float value3 = Plugin.instance.scaleDelay.Value;
if (value3 > 0f && num >= 0f)
{
float time = Time.time;
float num2 = value.lastTime.GetValueOrDefault(time);
if (flag2)
{
num2 = time + value3;
value.lastTime = num2;
}
if (time < num2)
{
num = -2f;
}
else
{
value.lastTime = time;
}
}
value.targetProgress = num;
if (num < 0f)
{
return;
}
Vector3 originalScale = value.originalScale;
Vector3 val = originalScale * objectScale.Value;
float originalMass = value.originalMass;
float num3 = originalMass * scaleData.massScale.Value;
value.scaleProgress = Mathf.MoveTowards(value.scaleProgress, num, Plugin.GetEffectiveUniformScale(originalScale) * Mathf.Max(0f, Plugin.instance.scaleSpeed.Value) * Time.deltaTime);
if (Mathf.Abs(value.scaleProgress - num) <= 0.0001f)
{
value.scaleProgress = num;
((Component)__instance).transform.localScale = ((num == 1f) ? val : originalScale);
if (Plugin.instance.scaleMass.Value)
{
__instance.rb.mass = ((num == 1f) ? num3 : originalMass);
}
}
else
{
float curveTime = Plugin.GetCurveTime(num, value.scaleProgress);
((Component)__instance).transform.localScale = Vector3.Lerp(originalScale, val, curveTime);
if (Plugin.instance.scaleMass.Value)
{
__instance.rb.mass = Mathf.Lerp(originalMass, num3, curveTime);
}
}
}
[HarmonyPatch("GrabStarted")]
[HarmonyPostfix]
private static void GrabStarted(PhysGrabObject __instance, bool ___grabbedLocal, bool ___isValuable)
{
//IL_0043: Unknown result type (might be due to invalid IL or missing references)
//IL_0054: Unknown result type (might be due to invalid IL or missing references)
if (!___grabbedLocal || !___isValuable || !Plugin.instance.printValuables.Value || !Plugin.instance.grabObjectDatas.TryGetValue(__instance, out var value))
{
return;
}
PhysGrabObjectScaleData scaleData = value.GetScaleData();
float effectiveUniformScale = Plugin.GetEffectiveUniformScale(value.originalScale);
float effectiveUniformScale2 = Plugin.GetEffectiveUniformScale(((Component)__instance).transform.localScale);
float? num = null;
float? objectScale = scaleData.objectScale;
if (objectScale.HasValue)
{
num = effectiveUniformScale * objectScale.Value;
}
float originalMass = value.originalMass;
float mass = __instance.rb.mass;
float? num2 = null;
float? massScale = scaleData.massScale;
if (massScale.HasValue)
{
num2 = originalMass * massScale.Value;
}
string arg = null;
float targetProgress = value.targetProgress;
float num3 = targetProgress;
float num4 = num3;
if (num4 != 1f)
{
if (num4 != 0f)
{
if (num4 != -1f)
{
if (num4 == -2f)
{
arg = "Delayed";
}
}
else
{
arg = "None";
}
}
else
{
arg = "Out";
}
}
else
{
arg = "In";
}
float scaleProgress = value.scaleProgress;
float num5 = ((targetProgress >= 0f) ? Plugin.GetCurveTime(targetProgress, scaleProgress) : Plugin.EvaluateScaleCurve(scaleProgress));
string text = "---- Valuable: \"" + value.name + "\" ----";
Plugin.instance.logger.LogMessage((object)("\n" + text + "\nOriginal Scale: " + effectiveUniformScale.ToString(CultureInfo.InvariantCulture) + "\nCurrent Scale: " + effectiveUniformScale2.ToString(CultureInfo.InvariantCulture) + "\nTarget Scale: " + (num.HasValue ? num.Value.ToString(CultureInfo.InvariantCulture) : "Unknown") + "\nScale Multiplier: " + (objectScale.HasValue ? objectScale.Value.ToString(CultureInfo.InvariantCulture) : "Unknown") + "\nOriginal Mass: " + originalMass.ToString(CultureInfo.InvariantCulture) + "\nCurrent Mass: " + mass.ToString(CultureInfo.InvariantCulture) + "\nTarget Mass: " + (num2.HasValue ? num2.Value.ToString(CultureInfo.InvariantCulture) : "Unknown") + "\nMass Scale Multiplier: " + (massScale.HasValue ? massScale.Value.ToString(CultureInfo.InvariantCulture) : "Unknown") + "\nRaw Progress: " + scaleProgress.ToString(CultureInfo.InvariantCulture) + "\n" + $"Target Progress: {arg} ({targetProgress})\n" + "Curved Time: " + num5.ToString(CultureInfo.InvariantCulture) + "\n" + new string('-', text.Length)));
}
}
[HarmonyPatch(typeof(PhysGrabCart))]
internal class PhysGrabCartPatch
{
[HarmonyPatch("Start")]
[HarmonyPostfix]
private static void Start(PhysGrabCart __instance, List<PhysGrabObject> ___itemsInCart)
{
Plugin.instance.grabObjectsInCarts[__instance] = ___itemsInCart;
if (Plugin.instance.printCartNames.Value)
{
Plugin.instance.logger.LogMessage((object)("Cart Name: \"" + Plugin.GetBaseName(((Object)__instance).name) + "\""));
}
}
}
}
namespace ScaleInCart.Enums
{
internal enum ScaleCurveDirection
{
SameBothWays,
SameBothWaysFlipped,
ForwardThenReverse
}
internal enum ScaleCurveType
{
Linear,
SmoothStep,
QuadIn,
QuadOut,
QuadInOut,
CubicIn,
CubicOut,
CubicInOut,
QuartIn,
QuartOut,
QuartInOut,
QuintIn,
QuintOut,
QuintInOut,
SineIn,
SineOut,
SineInOut,
ExpoIn,
ExpoOut,
ExpoInOut,
CircIn,
CircOut,
CircInOut,
BackIn,
BackOut,
BackInOut,
ElasticIn,
ElasticOut,
ElasticInOut,
BounceIn,
BounceOut,
BounceInOut,
Custom
}
}
namespace ScaleInCart.Classes
{
internal class PhysGrabObjectData
{
public readonly string name;
public readonly Vector3 originalScale;
public readonly float originalMass;
public float scaleProgress;
public float targetProgress;
public float? lastTime;
public bool? lastIsInCart;
public PhysGrabObjectData(PhysGrabObject grabObject)
{
//IL_0020: Unknown result type (might be due to invalid IL or missing references)
//IL_0025: Unknown result type (might be due to invalid IL or missing references)
name = Plugin.GetBaseName(((Object)grabObject).name);
originalScale = ((Component)grabObject).transform.localScale;
originalMass = grabObject.massOriginal;
targetProgress = -1f;
}
public PhysGrabObjectScaleData GetScaleData()
{
float? num = null;
float? massScale = null;
if (Plugin.instance.valuableConfigs.TryGetValue(name, out var value) && value.generateConfig.Value)
{
num = (value.useValuableScale.Value ? new float?(value.valuableScale.Value) : ((!Plugin.instance.useMassScaling.Value) ? new float?(Plugin.instance.defaultScale.Value) : new float?(GetScaleByOriginalMass())));
if (value.useValuableMassScale.Value)
{
massScale = value.valuableMassScale.Value;
}
}
else
{
num = (Plugin.instance.useMassScaling.Value ? GetScaleByOriginalMass() : Plugin.instance.defaultScale.Value);
}
if (!massScale.HasValue)
{
massScale = num;
}
if (num.HasValue)
{
num = Mathf.Max(0f, num.Value);
}
if (massScale.HasValue)
{
massScale = Mathf.Max(0f, massScale.Value);
}
return new PhysGrabObjectScaleData(num, massScale);
float GetScaleByOriginalMass()
{
//IL_0016: Unknown result type (might be due to invalid IL or missing references)
//IL_001b: Unknown result type (might be due to invalid IL or missing references)
//IL_0023: 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)
foreach (Vector2 massScaleFactors in Plugin.instance.massScaleFactorsList)
{
if (originalMass >= massScaleFactors.x)
{
return massScaleFactors.y;
}
}
return Plugin.instance.massScaleDefaultScale.Value;
}
}
}
internal class ValuableConfig
{
public ConfigEntry<bool> generateConfig;
public ConfigEntry<bool> useValuableScale;
public ConfigEntry<float> valuableScale;
public ConfigEntry<bool> useValuableMassScale;
public ConfigEntry<float> valuableMassScale;
}
}
