using System;
using System.Collections;
using System.Collections.Generic;
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.Threading;
using BepInEx;
using GameNetcodeStuff;
using HarmonyLib;
using LethalCompanyInputUtils.Api;
using Microsoft.CodeAnalysis;
using TMPro;
using Unity.Netcode;
using UnityEngine;
using UnityEngine.InputSystem;
using UnityEngine.SceneManagement;
[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("MinimumQuotaFinder")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyDescription("Calculates and highlights the minimum total value of scraps to sell to reach the quota")]
[assembly: AssemblyFileVersion("1.1.4.0")]
[assembly: AssemblyInformationalVersion("1.1.4")]
[assembly: AssemblyProduct("MinimumQuotaFinder")]
[assembly: AssemblyTitle("MinimumQuotaFinder")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.1.4.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 MinimumQuotaFinder
{
[HarmonyPatch]
internal class HUDPatch
{
[HarmonyPostfix]
[HarmonyPatch(typeof(HUDManager), "Awake")]
public static void OnAwake(HUDManager __instance)
{
int i;
for (i = 0; i < __instance.controlTipLines.Length && ((TMP_Text)__instance.controlTipLines[i]).text != ""; i++)
{
}
if (i < __instance.controlTipLines.Length)
{
((TMP_Text)__instance.controlTipLines[i]).text = "Highlight Minimum Quota : [H]";
}
}
[HarmonyPostfix]
[HarmonyPatch(typeof(HUDManager), "PingScan_performed")]
public static void OnPing(HUDManager __instance, CallbackContext context)
{
if (!MinimumQuotaFinder.Instance.CanHighlight(displayReason: false))
{
return;
}
int i;
for (i = 0; i < __instance.controlTipLines.Length && ((TMP_Text)__instance.controlTipLines[i]).text != ""; i++)
{
if (((TMP_Text)__instance.controlTipLines[i]).text == "Highlight Minimum Quota : [H]")
{
return;
}
}
if (i < __instance.controlTipLines.Length)
{
((TMP_Text)__instance.controlTipLines[i]).text = "Highlight Minimum Quota : [H]";
}
}
[HarmonyPostfix]
[HarmonyPatch(typeof(StartOfRound), "SceneManager_OnLoad")]
public static void OnChangeLevel(StartOfRound __instance, ulong clientId, string sceneName, LoadSceneMode loadSceneMode, AsyncOperation asyncOperation)
{
if (sceneName == "CompanyBuilding")
{
MinimumQuotaFinder.Instance.TurnOnHighlight(displayIfCached: true, displayReason: false);
}
}
[HarmonyPostfix]
[HarmonyPatch(typeof(DepositItemsDesk), "PlaceItemOnCounter")]
public static void OnItemPlacedOnCounter(DepositItemsDesk __instance, PlayerControllerB playerWhoTriggered)
{
if (MinimumQuotaFinder.Instance.IsToggled())
{
MinimumQuotaFinder.Instance.TurnOnHighlight(displayIfCached: false, displayReason: false);
}
}
}
public class MathUtilities
{
private const int THRESHOLD = 300000;
public static List<GrabbableObject> GetGreedyApproximation(List<GrabbableObject> allScrap, int target)
{
List<GrabbableObject> list = allScrap.OrderByDescending((GrabbableObject scrap) => scrap.scrapValue).ToList();
List<GrabbableObject> list2 = new List<GrabbableObject>();
int num = 0;
foreach (GrabbableObject item in list)
{
int scrapValue = item.scrapValue;
if (num + scrapValue <= target)
{
list2.Add(item);
num += scrapValue;
continue;
}
break;
}
if (list2.Sum((GrabbableObject s) => s.scrapValue) == target)
{
return list2;
}
for (int num2 = list.Count - 1; num2 >= 0; num2--)
{
GrabbableObject val = list[num2];
if (num + val.scrapValue >= target)
{
list2.Add(val);
break;
}
}
return list2;
}
public static IEnumerator GetIncludedCoroutine(List<GrabbableObject> allScrap, bool inverseTarget, int target, int calculationTarget, HashSet<GrabbableObject> includedScrap)
{
int numItems = allScrap.Count;
MemCell[] prev = new MemCell[calculationTarget + 1];
MemCell[] current = new MemCell[calculationTarget + 1];
for (int i = 0; i < prev.Length; i++)
{
prev[i] = new MemCell(0, new HashSet<GrabbableObject>());
}
int earlyTerminationTarget = (inverseTarget ? calculationTarget : target);
int calculations = 0;
for (int y = 1; y <= numItems; y++)
{
for (int x = 0; x <= calculationTarget; x++)
{
int currentScrapValue = allScrap[y - 1].scrapValue;
if (x < currentScrapValue)
{
current[x] = prev[x];
continue;
}
int include = currentScrapValue + prev[x - currentScrapValue].Max;
int exclude = prev[x].Max;
if (include > exclude)
{
current[x] = new MemCell(include, new HashSet<GrabbableObject>(prev[x - currentScrapValue].Included) { allScrap[y - 1] });
}
else
{
current[x] = prev[x];
}
}
prev = current;
current = new MemCell[calculationTarget + 1];
if (prev[earlyTerminationTarget].Max == earlyTerminationTarget)
{
if (inverseTarget)
{
includedScrap.UnionWith(allScrap.Where((GrabbableObject scrap) => !prev[earlyTerminationTarget].Included.Contains(scrap)));
}
else
{
includedScrap.UnionWith(prev[earlyTerminationTarget].Included);
}
yield break;
}
calculations += calculationTarget;
if (calculations > 300000)
{
yield return null;
calculations = 0;
}
}
if (inverseTarget)
{
includedScrap.UnionWith(allScrap.Where((GrabbableObject scrap) => !prev[calculationTarget].Included.Contains(scrap)));
}
else
{
for (int j = target; j < prev.Length; j++)
{
if (prev[j].Max >= target)
{
includedScrap.UnionWith(prev[j].Included);
break;
}
}
}
yield return null;
}
}
public class MemCell
{
public int Max { get; }
public HashSet<GrabbableObject> Included { get; }
public MemCell(int max, HashSet<GrabbableObject> included)
{
Max = max;
Included = included;
}
}
[BepInPlugin("com.github.riceisacereal.MinimumQuotaFinder", "MinimumQuotaFinder", "1.1.4")]
[BepInDependency(/*Could not decode attribute arguments.*/)]
public class MinimumQuotaFinder : BaseUnityPlugin
{
private const string GUID = "com.github.riceisacereal.MinimumQuotaFinder";
private const string NAME = "MinimumQuotaFinder";
private const string VERSION = "1.1.4";
internal static HighlightInputClass InputActionsInstance = new HighlightInputClass();
public Material wireframeMaterial;
private bool _toggled = false;
private int _highlightLockState = 0;
private int previousQuota = -1;
private int previousResult = -1;
private HashSet<GrabbableObject> previousInclude;
private HashSet<GrabbableObject> previousAllScraps;
private Dictionary<MeshRenderer, Material[]> _highlightedObjects = new Dictionary<MeshRenderer, Material[]>();
private List<string> excludedItemNames = new List<string> { "Shotgun", "Ammo", "Gift" };
public static MinimumQuotaFinder Instance { get; private set; }
private void Awake()
{
//IL_001b: Unknown result type (might be due to invalid IL or missing references)
//IL_0021: Expected O, but got Unknown
Instance = this;
SetupKeybindCallbacks();
CreateShader();
Harmony val = new Harmony("com.github.riceisacereal.MinimumQuotaFinder");
val.PatchAll(Assembly.GetExecutingAssembly());
((BaseUnityPlugin)this).Logger.LogInfo((object)"MinimumQuotaFinder successfully loaded!");
}
private void SetupKeybindCallbacks()
{
InputActionsInstance.HighlightKey.performed += OnHighlightKeyPressed;
}
private void CreateShader()
{
//IL_003b: Unknown result type (might be due to invalid IL or missing references)
//IL_0045: Expected O, but got Unknown
string text = Path.Join((ReadOnlySpan<char>)Path.GetDirectoryName(((BaseUnityPlugin)this).Info.Location), (ReadOnlySpan<char>)"wireframe");
AssetBundle val = AssetBundle.LoadFromFile(text);
Shader val2 = val.LoadAsset<Shader>("assets/wireframeshader.shader");
wireframeMaterial = new Material(val2);
val.Unload(false);
}
private void OnHighlightKeyPressed(CallbackContext highlightContext)
{
if (((CallbackContext)(ref highlightContext)).performed && !((Object)(object)GameNetworkManager.Instance.localPlayerController == (Object)null) && HUDManager.Instance.CanPlayerScan() && !(HUDManager.Instance.playerPingingScan > -0.5f))
{
if (!_toggled)
{
TurnOnHighlight(displayIfCached: true, displayReason: true);
}
else
{
TurnOffHighlight();
}
}
}
public void TurnOnHighlight(bool displayIfCached, bool displayReason)
{
if (CanHighlight(displayReason))
{
((MonoBehaviour)GameNetworkManager.Instance).StartCoroutine(HighlightObjectsCoroutine(displayIfCached));
}
}
public void TurnOffHighlight()
{
int num = Interlocked.CompareExchange(ref _highlightLockState, 1, 0);
if (num == 1)
{
return;
}
try
{
UnhighlightObjects();
}
finally
{
_toggled = false;
Interlocked.Exchange(ref _highlightLockState, 0);
}
}
private List<GrabbableObject> GetAllScrap(int level)
{
GameObject val = GameObject.Find((level == 3) ? "/Environment" : "/Environment/HangarShip");
if ((Object)(object)val == (Object)null)
{
return new List<GrabbableObject>();
}
return (from obj in val.GetComponentsInChildren<GrabbableObject>()
where obj.itemProperties.isScrap && obj.scrapValue > 0 && ((Component)obj).transform.position.y > -30f && !excludedItemNames.Contains(obj.itemProperties.itemName)
select obj).ToList();
}
private List<GrabbableObject> GetDeskScrap()
{
List<GrabbableObject> list = new List<GrabbableObject>();
DepositItemsDesk val = Object.FindFirstObjectByType<DepositItemsDesk>();
if ((Object)(object)val != (Object)null)
{
list.AddRange(from obj in ((Component)val.deskObjectsContainer).GetComponentsInChildren<GrabbableObject>()
where obj.itemProperties.isScrap
select obj);
}
return list;
}
private int GetDeskScrapValue()
{
return GetDeskScrap().Sum((GrabbableObject obj) => obj.scrapValue);
}
private IEnumerator HighlightObjectsCoroutine(bool displayIfCached)
{
int oldValue = Interlocked.CompareExchange(ref _highlightLockState, 1, 0);
if (oldValue == 1)
{
yield break;
}
try
{
if (displayIfCached)
{
HUDManager.Instance.DisplayTip("MinimumQuotaFinder", "Calculating...", false, false, "LC_Tip1");
}
List<GrabbableObject> allScrap = GetAllScrap(StartOfRound.Instance.currentLevelID);
HashSet<GrabbableObject> toHighlight = new HashSet<GrabbableObject>();
yield return ((MonoBehaviour)GameNetworkManager.Instance).StartCoroutine(GetSetToHighlight(allScrap, toHighlight, displayIfCached));
List<GrabbableObject> deskScrap = GetDeskScrap();
if (toHighlight.Count + deskScrap.Count > 0)
{
UnhighlightObjects();
HighlightObjects(toHighlight);
HighlightObjects(deskScrap);
_toggled = true;
}
else
{
_toggled = false;
}
}
finally
{
Interlocked.Exchange(ref _highlightLockState, 0);
}
}
private void HighlightObjects(IEnumerable<GrabbableObject> objectsToHighlight)
{
foreach (GrabbableObject item in objectsToHighlight)
{
MeshRenderer[] componentsInChildren = ((Component)item).GetComponentsInChildren<MeshRenderer>();
MeshRenderer[] array = componentsInChildren;
foreach (MeshRenderer val in array)
{
if (!_highlightedObjects.ContainsKey(val))
{
_highlightedObjects.Add(val, ((Renderer)val).materials);
Material[] materials = ((Renderer)val).materials;
int num = ((materials != null) ? materials.Length : 0);
Material[] array2 = (Material[])(object)new Material[num];
Array.Fill(array2, wireframeMaterial);
((Renderer)val).materials = array2;
}
}
}
}
private void UnhighlightObjects()
{
foreach (KeyValuePair<MeshRenderer, Material[]> highlightedObject in _highlightedObjects)
{
if (!((Object)(object)highlightedObject.Key == (Object)null) && ((Renderer)highlightedObject.Key).materials != null)
{
((Renderer)highlightedObject.Key).materials = highlightedObject.Value;
}
}
_highlightedObjects.Clear();
}
private IEnumerator GetSetToHighlight(List<GrabbableObject> allScrap, HashSet<GrabbableObject> includedScrap, bool displayIfCached)
{
int sold = TimeOfDay.Instance.quotaFulfilled + GetDeskScrapValue();
int quota = TimeOfDay.Instance.profitQuota;
if (sold >= quota)
{
string colour = ((sold - quota == 0) ? "#A5D971" : "#992403");
HUDManager.Instance.DisplayTip("MinimumQuotaFinder", $"Quota has been reached (<color={colour}>{sold}</color>/{quota}).", false, false, "LC_Tip1");
yield break;
}
if (allScrap == null || allScrap.Count == 0)
{
HUDManager.Instance.DisplayTip("MinimumQuotaFinder", "No scrap detected within the ship.", false, false, "LC_Tip1");
yield break;
}
if (quota == previousQuota && !ThrewAwayIncludedOrSoldExcluded(allScrap, sold) && (SubsetOfPrevious(allScrap) || quota == previousResult))
{
includedScrap.UnionWith(previousInclude.Where(allScrap.Contains));
if (displayIfCached)
{
DisplayCalculationResult(includedScrap, sold, quota);
}
yield break;
}
previousQuota = quota;
int sumScrapValue = allScrap.Sum((GrabbableObject scrap) => scrap.scrapValue);
if (sold + sumScrapValue < quota)
{
HUDManager.Instance.DisplayTip("MinimumQuotaFinder", $"Not enough scrap to reach quota ({sumScrapValue + sold} < {quota}). Sell everything.", false, false, "LC_Tip1");
yield break;
}
allScrap.Sort((GrabbableObject x, GrabbableObject y) => ((NetworkBehaviour)x).NetworkObjectId.CompareTo(((NetworkBehaviour)y).NetworkObjectId));
previousAllScraps = allScrap.ToHashSet();
int target = quota - sold;
int inverseTarget = allScrap.Sum((GrabbableObject scrap) => scrap.scrapValue) - target;
if (inverseTarget <= quota)
{
yield return ((MonoBehaviour)GameNetworkManager.Instance).StartCoroutine(MathUtilities.GetIncludedCoroutine(allScrap, inverseTarget: true, target, inverseTarget, includedScrap));
}
else
{
List<GrabbableObject> greedyApproximation = MathUtilities.GetGreedyApproximation(allScrap, quota - sold);
int greedyTarget = greedyApproximation.Sum((GrabbableObject scrap) => scrap.scrapValue);
if (greedyTarget == quota - sold)
{
includedScrap.UnionWith(greedyApproximation);
}
else
{
yield return ((MonoBehaviour)GameNetworkManager.Instance).StartCoroutine(MathUtilities.GetIncludedCoroutine(allScrap, inverseTarget: false, target, greedyTarget, includedScrap));
}
}
previousInclude = includedScrap;
DisplayCalculationResult(includedScrap, sold, quota);
yield return null;
}
private bool ThrewAwayIncludedOrSoldExcluded(List<GrabbableObject> allScrap, int sold)
{
if (previousInclude == null)
{
return true;
}
int num = previousInclude.Intersect(allScrap.ToHashSet()).Sum((GrabbableObject scrap) => scrap.scrapValue);
return num + sold != previousResult;
}
private bool SubsetOfPrevious(List<GrabbableObject> allScrap)
{
if (allScrap == null || previousInclude == null || previousAllScraps == null)
{
return false;
}
return allScrap.ToHashSet().IsSubsetOf(previousAllScraps);
}
private void DisplayCalculationResult(IEnumerable<GrabbableObject> toHighlight, int sold, int quota)
{
int num = (previousResult = toHighlight.Sum((GrabbableObject scrap) => scrap.scrapValue) + sold);
int num2 = num - quota;
string arg = ((num2 == 0) ? "#A5D971" : "#992403");
HUDManager.Instance.DisplayTip("MinimumQuotaFinder", $"Optimal scrap combination found: {num} ({sold} already sold). " + $"<color={arg}>{num2}</color> over quota. ", false, false, "LC_Tip1");
}
public bool IsToggled()
{
return _toggled;
}
public bool CanHighlight(bool displayReason)
{
bool flag = IsOnCompanyMoon(StartOfRound.Instance.currentLevelID);
if (flag && Math.Abs(StartOfRound.Instance.companyBuyingRate - 1f) >= 0.001f)
{
if (displayReason)
{
HUDManager.Instance.DisplayTip("MinimumQuotaFinder", "Buying rate is not at 100%, no scrap has been highlighted as the calculations would be inaccurate.", false, false, "LC_Tip1");
}
return false;
}
if (!flag && !GameNetworkManager.Instance.localPlayerController.isInHangarShipRoom)
{
if (displayReason)
{
HUDManager.Instance.DisplayTip("MinimumQuotaFinder", "Highlighting disabled, player is not on the ship", false, false, "LC_Tip1");
}
return false;
}
return true;
}
private bool IsOnCompanyMoon(int levelID)
{
return ((Object)StartOfRound.Instance.levels[levelID]).name == "CompanyBuildingLevel";
}
}
public class HighlightInputClass : LcInputActions
{
[InputAction("<Keyboard>/h", Name = "Toggle scrap highlight")]
public InputAction HighlightKey { get; set; }
}
}
