using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Text;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using LethalNetworkAPI;
using QuotaTournament;
using QuotaTourney.Patches;
using TMPro;
using TerminalApi;
using TerminalApi.Classes;
using Unity.Netcode;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("QuotaTourney")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("QuotaTourney")]
[assembly: AssemblyCopyright("Copyright ©  2024")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("ad905924-f5e1-4c12-97b3-cb78bd1cedb3")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace QuotaTournament
{
	internal enum MoonIDs
	{
		Experimentation,
		Assurance,
		Vow,
		Company,
		March,
		Adamance,
		Rend,
		Dine,
		Offense,
		Titan,
		Artifice,
		Liquidation,
		Embrion
	}
	public class ModNetworkBehavior<T>
	{
		private T Value;

		private LNetworkMessage<T> server;

		private LNetworkMessage<T> client;

		public ModNetworkBehavior(string networkName, Action<T, ulong> serverResponse, Action<T> clientResponse)
		{
			server = LNetworkMessage<T>.Create(networkName, serverResponse, (Action<T>)null, (Action<T, ulong>)null);
			client = LNetworkMessage<T>.Connect(networkName, (Action<T, ulong>)null, clientResponse, (Action<T, ulong>)null);
		}

		public void SendClients(T data)
		{
			server.SendClients(data);
		}

		public void SendServer(T data)
		{
			client.SendServer(data);
		}

		public void SetValue(T value)
		{
			Value = value;
		}

		public T GetValue()
		{
			return Value;
		}
	}
	[BepInPlugin("OreoM.QuotaTournament", "QuotaTournament", "1.4.4")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public class QuotaTournament : BaseUnityPlugin
	{
		private static class TerminalKeywords
		{
			public static TerminalKeyword seed;

			public static TerminalKeyword freq;

			public static TerminalKeyword ban;

			public static TerminalKeyword blank;
		}

		private static class TerminalNodes
		{
			public static TerminalNode seed;

			public static TerminalNode freq;

			public static TerminalNode ban;
		}

		private const string modGuid = "OreoM.QuotaTournament";

		private const string modName = "QuotaTournament";

		private const string modVersion = "1.4.4";

		private readonly Harmony harmony = new Harmony("OreoM.QuotaTournament");

		private static QuotaTournament Instance;

		internal ManualLogSource internalLogger;

		private static List<int> allowedMoons = new List<int>();

		public const int seedMax = int.MaxValue;

		public static bool seedHasBeenSet = false;

		public static string terminalInput = "";

		private static ConfigEntry<bool> allowShopBypassAnyDay;

		private static ConfigEntry<bool> speedrunBonus;

		private static ConfigEntry<int> wipeLossPercentage;

		private static ModNetworkBehavior<int> netSeed;

		private static ModNetworkBehavior<int> netScore;

		private static ModNetworkBehavior<string> netBuy;

		private static ModNetworkBehavior<string> netMoonFrequency;

		private static ModNetworkBehavior<string> netAllowedMoons;

		private void Awake()
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Expected O, but got Unknown
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Expected O, but got Unknown
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Expected O, but got Unknown
			//IL_0368: Unknown result type (might be due to invalid IL or missing references)
			//IL_036d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0378: Unknown result type (might be due to invalid IL or missing references)
			//IL_0383: 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_03a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b0: Expected O, but got Unknown
			//IL_03b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_03fd: Expected O, but got Unknown
			//IL_0402: Unknown result type (might be due to invalid IL or missing references)
			//IL_0407: Unknown result type (might be due to invalid IL or missing references)
			//IL_0412: Unknown result type (might be due to invalid IL or missing references)
			//IL_041d: Unknown result type (might be due to invalid IL or missing references)
			//IL_042f: Unknown result type (might be due to invalid IL or missing references)
			//IL_043a: Unknown result type (might be due to invalid IL or missing references)
			//IL_044a: Expected O, but got Unknown
			if ((Object)(object)Instance == (Object)null)
			{
				Instance = this;
			}
			allowShopBypassAnyDay = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "Allow shop bypass any day", true, new ConfigDescription("Allow items and cruiser to be bought directly to ship any day instead of only before first day", (AcceptableValueBase)null, Array.Empty<object>()));
			speedrunBonus = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "Speedrun Bonus", false, new ConfigDescription("Get more score if ship leaves early", (AcceptableValueBase)null, Array.Empty<object>()));
			wipeLossPercentage = ((BaseUnityPlugin)this).Config.Bind<int>("General", "Wipe loss percentage", 50, new ConfigDescription("What percentage of score is lost if all players die", (AcceptableValueBase)(object)new AcceptableValueRange<int>(0, 100), Array.Empty<object>()));
			internalLogger = Logger.CreateLogSource("OreoM.QuotaTournament");
			internalLogger.LogInfo((object)"QuotaTournament v1.4.4 is patching.");
			try
			{
				harmony.PatchAll(typeof(QuotaTournament));
				harmony.PatchAll(typeof(GameNetworkManagerPatch));
				harmony.PatchAll(typeof(StartOfRoundPatch));
				harmony.PatchAll(typeof(TerminalPatch));
				internalLogger.LogInfo((object)"QuotaTournament v1.4.4 is done patching.");
			}
			catch (Exception ex)
			{
				internalLogger.LogInfo((object)"QuotaTournament v1.4.4 failed to patch.");
				Debug.LogException(ex);
			}
			internalLogger.LogInfo((object)"QuotaTournament v1.4.4 is creating the Network");
			try
			{
				netSeed = new ModNetworkBehavior<int>("netSeed", SetSeedClientRequest, SetSeedServerRequest);
				netScore = new ModNetworkBehavior<int>("netScore", SyncScoreClientRequest, SyncScoreServerRequest);
				netBuy = new ModNetworkBehavior<string>("netBuy", BuyFromShopClientRequest, BuyFromShopServerRequest);
				netMoonFrequency = new ModNetworkBehavior<string>("netMoonFrequency", SetMoonFrequencyClientRequest, SetMoonFrequencyServerRequest);
				netMoonFrequency.SetValue("day");
				netAllowedMoons = new ModNetworkBehavior<string>("netAllowedMoons", BanMoonClientRequest, BanMoonServerRequest);
				netAllowedMoons.SetValue("default");
				ResetAllowedMoonList();
				internalLogger.LogInfo((object)"QuotaTournament v1.4.4 is done creating the Network");
			}
			catch (Exception ex2)
			{
				internalLogger.LogInfo((object)"QuotaTournament v1.4.4 failed to create Network");
				Debug.LogException(ex2);
			}
			internalLogger.LogInfo((object)"QuotaTournament v1.4.4 is implementing terminal commands");
			try
			{
				TerminalNodes.seed = TerminalApi.CreateTerminalNode("seedNode", true, "");
				TerminalNodes.freq = TerminalApi.CreateTerminalNode("freqNode", true, "");
				TerminalNodes.ban = TerminalApi.CreateTerminalNode("banNode", true, "");
				TerminalKeywords.blank = TerminalApi.CreateTerminalKeyword("whyCanINotGetCustomInputWithoutThis???", true, (TerminalNode)null);
				TerminalKeywords.seed = TerminalApi.CreateTerminalKeyword("seed", false, TerminalNodes.seed);
				TerminalKeywords.freq = TerminalApi.CreateTerminalKeyword("freq", false, TerminalNodes.freq);
				TerminalKeywords.ban = TerminalApi.CreateTerminalKeyword("ban", false, TerminalNodes.ban);
				TerminalExtenstionMethods.AddCompatibleNoun(TerminalKeywords.blank, TerminalKeywords.seed, TerminalNodes.seed);
				TerminalExtenstionMethods.AddCompatibleNoun(TerminalKeywords.blank, TerminalKeywords.freq, TerminalNodes.freq);
				TerminalExtenstionMethods.AddCompatibleNoun(TerminalKeywords.blank, TerminalKeywords.ban, TerminalNodes.ban);
				TerminalKeywords.seed.defaultVerb = TerminalKeywords.blank;
				TerminalKeywords.freq.defaultVerb = TerminalKeywords.blank;
				TerminalKeywords.ban.defaultVerb = TerminalKeywords.blank;
				TerminalApi.AddTerminalKeyword(TerminalKeywords.seed, new CommandInfo
				{
					Title = "Seed [num]",
					TriggerNode = TerminalNodes.seed,
					DisplayTextSupplier = SetSeed,
					Category = "Other",
					Description = "Type a seed to start the challenge"
				});
				TerminalApi.AddTerminalKeyword(TerminalKeywords.freq, new CommandInfo
				{
					Title = "Freq [day/quota]",
					TriggerNode = TerminalNodes.freq,
					DisplayTextSupplier = SetMoonFrequency,
					Category = "Other",
					Description = "Change the frequency with which moon changes"
				});
				TerminalApi.AddTerminalKeyword(TerminalKeywords.ban, new CommandInfo
				{
					Title = "Ban [moon]",
					TriggerNode = TerminalNodes.ban,
					DisplayTextSupplier = BanMoon,
					Category = "Other",
					Description = "Ban moon from being choosen"
				});
				internalLogger.LogInfo((object)"QuotaTournament v1.4.4 is done implementing terminal commands");
			}
			catch (Exception ex3)
			{
				internalLogger.LogInfo((object)"QuotaTournament v1.4.4 failed to implement terminal commands");
				Debug.LogException(ex3);
			}
		}

		public static void AddScore(int inputScore)
		{
			float num = (speedrunBonus.Value ? (2f - TimeOfDay.Instance.normalizedTimeOfDay) : 1f);
			netScore.SetValue(netScore.GetValue() + (int)((float)inputScore * num));
		}

		public static void LoseScoreToWipe()
		{
			netScore.SetValue((int)((float)netScore.GetValue() * (float)(100 - wipeLossPercentage.Value) / 100f));
		}

		public static void ResetScore()
		{
			netScore.SetValue(0);
		}

		public static int GetScore()
		{
			return netScore.GetValue();
		}

		public static void SyncScore()
		{
			netScore.SendServer(0);
		}

		public static void SyncScoreClientRequest(int option, ulong clientID)
		{
			if (option == 0)
			{
				netScore.SendClients(netScore.GetValue());
			}
		}

		public static void SyncScoreServerRequest(int serverScore)
		{
			netScore.SetValue(serverScore);
		}

		public static string SetMoonFrequency()
		{
			if (TimeOfDay.Instance.daysUntilDeadline < 3 || !StartOfRound.Instance.inShipPhase)
			{
				return "Moon frequency can only be changed before starting the quota\n\n";
			}
			string text = terminalInput.Split(new char[1] { ' ' }, StringSplitOptions.RemoveEmptyEntries)[1];
			if (text != "quota" && text != "day")
			{
				return text + " is an invalid option\n\n";
			}
			netMoonFrequency.SendServer(text);
			return "Moon will change every " + text + "\n\n";
		}

		public static void SetMoonFrequencyClientRequest(string config, ulong clientID)
		{
			netMoonFrequency.SendClients(config);
		}

		public static void SetMoonFrequencyServerRequest(string config)
		{
			netMoonFrequency.SetValue(config);
		}

		public static string GetMoonFrequencyValue()
		{
			return netMoonFrequency.GetValue();
		}

		public static string SetSeed()
		{
			if (TimeOfDay.Instance.daysUntilDeadline < 3 || !StartOfRound.Instance.inShipPhase)
			{
				return "Seed can only be set before starting the quota\n\n";
			}
			if (!int.TryParse(terminalInput.Split(new char[1] { ' ' }, StringSplitOptions.RemoveEmptyEntries)[1], out var result))
			{
				return $"{result} is not a valid number\n\n";
			}
			netSeed.SendServer(result);
			return $"Seed {result} is set\n\n";
		}

		public static void SetSeedClientRequest(int seed, ulong clientID)
		{
			StartOfRound.Instance.ChangeLevelServerRpc(allowedMoons[seed % allowedMoons.Count], Object.FindObjectOfType<Terminal>().groupCredits = new Random(seed + 9114523).Next(1000, 1600));
			netSeed.SendClients(seed);
		}

		public static void SetSeedServerRequest(int seed)
		{
			Debug.Log((object)$"Seed set: {seed}");
			netSeed.SetValue(seed);
			seedHasBeenSet = true;
			StartOfRound instance = StartOfRound.Instance;
			instance.randomMapSeed = new Random(netSeed.GetValue()).Next(1, int.MaxValue);
			instance.SetPlanetsWeather(0);
			instance.overrideRandomSeed = true;
			instance.overrideSeedNumber = netSeed.GetValue();
			ResetScore();
			((TMP_Text)instance.profitQuotaMonitorText).text = "CURRENT SCORE:\n  $" + GetScore();
			TerminalPatch.ForceItemSales(TimeOfDay.Instance.daysUntilDeadline);
		}

		public static void BuyFromShop(string buyType)
		{
			if ((allowShopBypassAnyDay.Value || TimeOfDay.Instance.daysUntilDeadline == 3) && StartOfRound.Instance.inShipPhase)
			{
				netBuy.SendServer(buyType);
			}
		}

		public static void BuyFromShopClientRequest(string buyType, ulong clientID)
		{
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: 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)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			Terminal val = Object.FindObjectOfType<Terminal>();
			if (buyType.Equals("Item"))
			{
				foreach (int item in val.orderedItemsFromTerminal)
				{
					Object.Instantiate<GameObject>(val.buyableItemsList[item].spawnPrefab, new Vector3((float)item / 7f, 2f, -15f + (float)item / 7f), Quaternion.identity, RoundManager.Instance.spawnedScrapContainer).GetComponent<NetworkObject>().Spawn(false);
				}
				netBuy.SendClients(buyType);
			}
			if (buyType.Equals("Cruiser"))
			{
				if (val.orderedVehicleFromTerminal != 1 && !Object.op_Implicit((Object)(object)Object.FindObjectOfType<VehicleController>()))
				{
					Object.Instantiate<GameObject>(val.buyableVehicles[0].vehiclePrefab, new Vector3(3f, 3f, -21f), new Quaternion(0f, 1f, 0f, 1f), RoundManager.Instance.VehiclesContainer).GetComponent<NetworkObject>().Spawn(false);
					StartOfRound.Instance.SetMagnetOn(true);
				}
				netBuy.SendClients(buyType);
			}
		}

		public static void BuyFromShopServerRequest(string buyType)
		{
			Terminal val = Object.FindObjectOfType<Terminal>();
			if (buyType.Equals("Item"))
			{
				val.ClearBoughtItems();
			}
			if (buyType.Equals("Cruiser"))
			{
				StartOfRound.Instance.magnetLever.boolValue = true;
				val.orderedVehicleFromTerminal = -1;
				val.vehicleInDropship = false;
			}
		}

		public static string BanMoon()
		{
			if (seedHasBeenSet)
			{
				return "Moons can only be banned before setting the seed\n\n";
			}
			string[] array = terminalInput.Split(new char[1] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
			string moon = array[1];
			string text = Enum.GetNames(typeof(MoonIDs)).FirstOrDefault((string s) => s.StartsWith(moon, StringComparison.OrdinalIgnoreCase));
			if (text != null && allowedMoons.Contains((int)Enum.Parse(typeof(MoonIDs), text)))
			{
				netAllowedMoons.SendServer(text);
				return text + " has been banned from the list\n\n";
			}
			return moon + " is an invalid option\n\n";
		}

		public static void BanMoonClientRequest(string moonName, ulong clientID)
		{
			netAllowedMoons.SendClients(moonName);
		}

		public static void BanMoonServerRequest(string moonName)
		{
			netAllowedMoons.SetValue("modified");
			allowedMoons.Remove((int)Enum.Parse(typeof(MoonIDs), moonName));
		}

		public static void ResetAllowedMoonList()
		{
			allowedMoons.Clear();
			foreach (int value in Enum.GetValues(typeof(MoonIDs)))
			{
				if (value != 3 && value != 11)
				{
					allowedMoons.Add(value);
				}
			}
			netAllowedMoons.SetValue("default");
		}

		public static List<int> GetAllowedMoonList()
		{
			return allowedMoons;
		}
	}
}
namespace QuotaTourney.Patches
{
	[HarmonyPatch(typeof(GameNetworkManager))]
	internal class GameNetworkManagerPatch
	{
		[HarmonyPatch("Disconnect")]
		[HarmonyPrefix]
		private static void DisconnectPrePatch(ref GameNetworkManager __instance)
		{
			global::QuotaTournament.QuotaTournament.seedHasBeenSet = false;
			global::QuotaTournament.QuotaTournament.ResetAllowedMoonList();
			global::QuotaTournament.QuotaTournament.ResetScore();
		}
	}
	[HarmonyPatch(typeof(StartOfRound))]
	internal class StartOfRoundPatch
	{
		[HarmonyPatch("SetShipReadyToLand")]
		[HarmonyPostfix]
		private static void SetShipReadyToLandPostPatch(ref StartOfRound __instance)
		{
			if (!global::QuotaTournament.QuotaTournament.seedHasBeenSet)
			{
				return;
			}
			if (TimeOfDay.Instance.daysUntilDeadline == 0)
			{
				RoundManager.Instance.DespawnPropsAtEndOfRound(true);
				__instance.ResetShip();
				((TMP_Text)__instance.profitQuotaMonitorText).text = "TOTAL SCORE:\n  $" + global::QuotaTournament.QuotaTournament.GetScore();
				global::QuotaTournament.QuotaTournament.ResetScore();
				global::QuotaTournament.QuotaTournament.ResetAllowedMoonList();
				if (global::QuotaTournament.QuotaTournament.GetMoonFrequencyValue().Equals("quota"))
				{
					__instance.ChangeLevelServerRpc(global::QuotaTournament.QuotaTournament.GetAllowedMoonList()[__instance.overrideSeedNumber % global::QuotaTournament.QuotaTournament.GetAllowedMoonList().Count], Object.FindObjectOfType<Terminal>().groupCredits);
				}
			}
			if (global::QuotaTournament.QuotaTournament.GetMoonFrequencyValue().Equals("day"))
			{
				__instance.ChangeLevelServerRpc(global::QuotaTournament.QuotaTournament.GetAllowedMoonList()[__instance.overrideSeedNumber % global::QuotaTournament.QuotaTournament.GetAllowedMoonList().Count], Object.FindObjectOfType<Terminal>().groupCredits);
			}
			Debug.Log((object)$"Next seed: {__instance.overrideSeedNumber}\n{global::QuotaTournament.QuotaTournament.GetMoonFrequencyValue()}");
		}

		[HarmonyPatch("StartGame")]
		[HarmonyPrefix]
		private static void StartGamePrePatch(ref StartOfRound __instance)
		{
			if (TimeOfDay.Instance.daysUntilDeadline == 1 && global::QuotaTournament.QuotaTournament.seedHasBeenSet)
			{
				__instance.isChallengeFile = true;
			}
		}

		[HarmonyPatch("ShipHasLeft")]
		[HarmonyPostfix]
		private static void ShipHasLeftPostPatch(ref StartOfRound __instance)
		{
			if (!global::QuotaTournament.QuotaTournament.seedHasBeenSet)
			{
				return;
			}
			if (((NetworkBehaviour)StartOfRound.Instance).IsHost)
			{
				if (__instance.livingPlayers == 0)
				{
					global::QuotaTournament.QuotaTournament.LoseScoreToWipe();
				}
				else
				{
					global::QuotaTournament.QuotaTournament.AddScore(__instance.GetValueOfAllScrap(true, true));
				}
				global::QuotaTournament.QuotaTournament.SyncScore();
			}
			__instance.overrideSeedNumber = NextSeed(__instance.overrideSeedNumber);
			__instance.randomMapSeed = NextSeed(__instance.randomMapSeed);
			__instance.isChallengeFile = false;
		}

		[HarmonyPatch("ChangeLevel")]
		[HarmonyPrefix]
		private static void ChangeLevelPrePatch(ref StartOfRound __instance)
		{
			Debug.Log((object)$"Current random seed: {__instance.randomMapSeed}");
			__instance.SetPlanetsWeather(0);
		}

		[HarmonyPatch("PassTimeToNextDay")]
		[HarmonyPostfix]
		private static void PassTimeToNextDayPostPatch(ref StartOfRound __instance)
		{
			if (global::QuotaTournament.QuotaTournament.seedHasBeenSet)
			{
				((TMP_Text)__instance.profitQuotaMonitorText).text = "CURRENT SCORE:\n  $" + global::QuotaTournament.QuotaTournament.GetScore();
				TerminalPatch.ForceItemSales(TimeOfDay.Instance.daysUntilDeadline);
			}
		}

		public static int NextSeed(int seed)
		{
			return new Random(Math.Abs(seed + 84936687)).Next(1, int.MaxValue);
		}
	}
	[HarmonyPatch(typeof(Terminal))]
	internal class TerminalPatch
	{
		[HarmonyPatch("ParsePlayerSentence")]
		[HarmonyPrefix]
		private static void ParsePlayerSentencePrePatch(ref Terminal __instance)
		{
			string text = __instance.screenText.text.Substring(__instance.screenText.text.Length - __instance.textAdded);
			StringBuilder stringBuilder = new StringBuilder();
			string text2 = text;
			foreach (char c in text2)
			{
				if (!char.IsPunctuation(c))
				{
					stringBuilder.Append(c);
				}
			}
			global::QuotaTournament.QuotaTournament.terminalInput = stringBuilder.ToString().ToLower();
		}

		[HarmonyPatch("LoadNewNodeIfAffordable")]
		[HarmonyPostfix]
		private static void LoadNewNodeIfAffordablePostPatch(ref Terminal __instance)
		{
			if (global::QuotaTournament.QuotaTournament.seedHasBeenSet)
			{
				global::QuotaTournament.QuotaTournament.BuyFromShop("Item");
			}
		}

		[HarmonyPatch("BuyVehicleClientRpc")]
		[HarmonyPostfix]
		private static void BuyVehicleClientRpcPostPatch(ref Terminal __instance)
		{
			if (global::QuotaTournament.QuotaTournament.seedHasBeenSet)
			{
				global::QuotaTournament.QuotaTournament.BuyFromShop("Cruiser");
			}
		}

		public static void ForceItemSales(int force)
		{
			force = ((force == 0) ? 1 : force);
			Terminal val = Object.FindObjectOfType<Terminal>();
			List<int> list = new List<int>();
			for (int i = 0; i < val.buyableItemsList.Length + val.buyableVehicles.Length; i++)
			{
				list.Add(i);
				list[i] = i;
			}
			Random random = new Random(StartOfRound.Instance.overrideSeedNumber);
			int num = 1 + random.Next(0, val.buyableItemsList.Length + val.buyableVehicles.Length) / force;
			for (int j = 0; j < num; j++)
			{
				int num2 = list[random.Next(0, list.Count)];
				int num3 = 100 - random.Next(20 * (3 - force), 80) / force;
				num3 = (int)Math.Round((double)num3 / 10.0) * 10;
				val.itemSalesPercentages[num2] = num3;
				list.Remove(num2);
			}
		}
	}
}