using System;
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 BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using LobbyCompatibility.Enums;
using LobbyCompatibility.Features;
using Microsoft.CodeAnalysis;
using TMPro;
using Unity.Netcode;
using UnityEngine;
using UpturnedVariety.Defs.Items;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: IgnoresAccessChecksTo("Assembly-CSharp")]
[assembly: AssemblyCompany("UpturnedVariety")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyDescription("Includes some assets from The Upturned for vanilla-friendly variety")]
[assembly: AssemblyFileVersion("2.2.0.0")]
[assembly: AssemblyInformationalVersion("2.2.0+6496fa70b5bb4a5f7ae9f893269d4ab9d81e0783")]
[assembly: AssemblyProduct("UpturnedVariety")]
[assembly: AssemblyTitle("UpturnedVariety")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("2.2.0.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 UpturnedVariety
{
internal static class LobbyCompatibility
{
internal static void Init()
{
PluginHelper.RegisterPlugin("butterystancakes.lethalcompany.upturnedvariety", Version.Parse("2.2.0"), (CompatibilityLevel)0, (VersionStrictness)0);
}
}
[BepInPlugin("butterystancakes.lethalcompany.upturnedvariety", "Upturned Variety", "2.2.0")]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInDependency(/*Could not decode attribute arguments.*/)]
public class Plugin : BaseUnityPlugin
{
internal const string PLUGIN_GUID = "butterystancakes.lethalcompany.upturnedvariety";
internal const string PLUGIN_NAME = "Upturned Variety";
internal const string PLUGIN_VERSION = "2.2.0";
internal static ManualLogSource Logger;
private const string GUID_LOBBY_COMPATIBILITY = "BMX.LobbyCompatibility";
private const string GUID_GENERAL_IMPROVEMENTS = "ShaosilGaming.GeneralImprovements";
internal static ConfigEntry<bool> configBoombox;
internal static ConfigEntry<bool> configRecord;
internal static AudioClip boombox;
internal static AudioClip collectChocolateBar;
internal static AudioClip collectedAllChocolateBarsJingle;
internal static AudioClip hauntedRecordPlayer1;
internal static bool INSTALLED_GENERAL_IMPROVEMENTS;
private void Awake()
{
//IL_0124: Unknown result type (might be due to invalid IL or missing references)
Logger = ((BaseUnityPlugin)this).Logger;
if (Chainloader.PluginInfos.ContainsKey("BMX.LobbyCompatibility"))
{
Logger.LogInfo((object)"CROSS-COMPATIBILITY - Lobby Compatibility detected");
LobbyCompatibility.Init();
}
if (Chainloader.PluginInfos.ContainsKey("ShaosilGaming.GeneralImprovements"))
{
INSTALLED_GENERAL_IMPROVEMENTS = true;
Logger.LogInfo((object)"CROSS-COMPATIBILITY - GeneralImprovements detected");
}
configBoombox = ((BaseUnityPlugin)this).Config.Bind<bool>("Items", "Boombox", true, "Enables alternate models for the \"Boombox\" item.");
configRecord = ((BaseUnityPlugin)this).Config.Bind<bool>("Furniture", "RecordPlayer", true, "Enables alternate tracks for the \"Record player\" furniture.");
SkinManager.LoadAllConfigs(((BaseUnityPlugin)this).Config);
try
{
AssetBundle obj = AssetBundle.LoadFromFile(Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), "upturnedvariety"));
boombox = obj.LoadAsset<AudioClip>("Boombox");
collectChocolateBar = obj.LoadAsset<AudioClip>("CollectChocolateBar");
collectedAllChocolateBarsJingle = obj.LoadAsset<AudioClip>("CollectedAllChocolateBarsJingle");
hauntedRecordPlayer1 = obj.LoadAsset<AudioClip>("HauntedRecordPlayer1");
SkinManager.LoadAllSkins(obj);
obj.Unload(false);
}
catch
{
Logger.LogError((object)"Encountered some error loading asset bundle. Did you install the plugin correctly?");
return;
}
new Harmony("butterystancakes.lethalcompany.upturnedvariety").PatchAll();
Logger.LogInfo((object)"Upturned Variety v2.2.0 loaded");
}
}
[HarmonyPatch]
internal class UpturnedVarietyPatches
{
private static readonly Color SHINY_BOOMBOX = new Color(0.5799929f, 0.5799929f, 0.5799929f);
private static StartMatchLever _startMatchLever;
private static Random recordRandom;
private static AnimatedObjectTrigger recordPlayerTrigger;
private static AudioClip recordPlayerJazz;
private static float recordDoppler;
private static float recordVolume;
private static StartMatchLever StartMatchLever
{
get
{
if ((Object)(object)_startMatchLever == (Object)null)
{
_startMatchLever = Object.FindAnyObjectByType<StartMatchLever>();
}
return _startMatchLever;
}
}
[HarmonyPatch(typeof(StartOfRound), "Awake")]
[HarmonyPostfix]
private static void StartOfRound_Post_Awake(StartOfRound __instance)
{
if ((Object)(object)Plugin.boombox != (Object)null)
{
Item val = ((IEnumerable<Item>)__instance.allItemsList.itemsList).FirstOrDefault((Func<Item, bool>)((Item item) => ((Object)item).name == "Boombox" && item.itemId == 9));
if ((Object)(object)val != (Object)null)
{
BoomboxItem component = val.spawnPrefab.GetComponent<BoomboxItem>();
if (Array.IndexOf(component.musicAudios, Plugin.boombox) < 0)
{
component.musicAudios = new List<AudioClip>(component.musicAudios) { Plugin.boombox }.ToArray();
Plugin.Logger.LogDebug((object)"Loaded Upturned track into Boombox");
}
}
}
SkinManager.Reset();
}
[HarmonyPatch(typeof(RoundManager), "SyncScrapValuesClientRpc")]
[HarmonyPostfix]
private static void RoundManager_Post_SyncScrapValuesClientRpc(NetworkObjectReference[] spawnedScrap)
{
SkinManager.ApplySkinsToItems(spawnedScrap);
}
[HarmonyPatch(typeof(GrabbableObject), "Start")]
[HarmonyPostfix]
private static void GrabbableObject_Post_Start(GrabbableObject __instance)
{
if (((Object)__instance.itemProperties).name == "FishTestProp" && (Object)(object)__instance.mainObjectRenderer != (Object)null)
{
SkinManager.fish.Add((Renderer)(object)__instance.mainObjectRenderer);
}
}
[HarmonyPatch(typeof(GrabbableObject), "SetControlTipsForItem")]
[HarmonyPostfix]
private static void GrabbableObject_Post_SetControlTipsForItem(GrabbableObject __instance)
{
SubstituteItemName substituteItemName = default(SubstituteItemName);
if (((Component)__instance).TryGetComponent<SubstituteItemName>(ref substituteItemName))
{
((TMP_Text)HUDManager.Instance.controlTipLines[0]).SetText(((TMP_Text)HUDManager.Instance.controlTipLines[0]).text.Replace(__instance.itemProperties.itemName, substituteItemName.subName), true);
}
if (!((Object)(object)((Component)__instance).GetComponent<UnusableItem>() != (Object)null))
{
return;
}
for (int i = 0; i < HUDManager.Instance.controlTipLines.Length; i++)
{
if (((TMP_Text)HUDManager.Instance.controlTipLines[i]).text.StartsWith("Use"))
{
((TMP_Text)HUDManager.Instance.controlTipLines[i]).SetText(string.Empty, true);
}
}
}
[HarmonyPatch(typeof(BoomboxItem), "Start")]
[HarmonyPostfix]
private static void BoomboxItem_Post_Start(BoomboxItem __instance)
{
//IL_0079: Unknown result type (might be due to invalid IL or missing references)
//IL_008b: Unknown result type (might be due to invalid IL or missing references)
NetworkObject val = default(NetworkObject);
if (Plugin.configBoombox.Value && !((Object)(object)((GrabbableObject)__instance).mainObjectRenderer == (Object)null) && !((Object)(object)StartMatchLever == (Object)null) && StartMatchLever.leverHasBeenPulled && ((Component)__instance).TryGetComponent<NetworkObject>(ref val) && new Random(StartOfRound.Instance.randomMapSeed * (int)val.NetworkObjectId).NextDouble() >= 0.5)
{
Material[] materials = ((Renderer)((GrabbableObject)__instance).mainObjectRenderer).materials;
materials[3].SetColor("_Color", SHINY_BOOMBOX);
materials[3].SetColor("_BaseColor", SHINY_BOOMBOX);
materials[3].SetFloat("_Metallic", 0.6833333f);
materials[3].SetFloat("_Smoothness", 0.275f);
((Renderer)((GrabbableObject)__instance).mainObjectRenderer).materials = materials;
}
}
[HarmonyPatch(typeof(RoundManager), "DespawnPropsAtEndOfRound")]
[HarmonyPostfix]
private static void RoundManager_Post_DespawnPropsAtEndOfRound()
{
SkinManager.chocolates.Clear();
recordRandom = new Random(StartOfRound.Instance.randomMapSeed + 3232022);
}
[HarmonyPatch(typeof(HUDManager), "AddNewScrapFoundToDisplay")]
[HarmonyPostfix]
private static void HUDManager_Post_AddNewScrapFoundToDisplay(GrabbableObject GObject)
{
if (SkinManager.chocolates.Count > 0 && SkinManager.chocolates.Contains(GObject))
{
SkinManager.chocolates.Remove(GObject);
HUDManager.Instance.UIAudio.PlayOneShot(Plugin.collectChocolateBar);
if (SkinManager.chocolates.Count < 1)
{
HUDManager.Instance.UIAudio.PlayOneShot(Plugin.collectedAllChocolateBarsJingle);
}
}
}
[HarmonyPatch(typeof(GrabbableObject), "EquipItem")]
[HarmonyPostfix]
private static void GrabbableObject_Post_EquipItem(GrabbableObject __instance)
{
if (((NetworkBehaviour)__instance).IsOwner && SkinManager.chocolates.Contains(__instance))
{
Transform obj = ((Component)__instance).transform.Find("Jingle");
AudioSource val = ((obj != null) ? ((Component)obj).GetComponent<AudioSource>() : null);
if ((Object)(object)val != (Object)null)
{
val.Stop();
val.pitch = Random.Range(1.6f, 2.3f);
val.Play();
}
}
}
[HarmonyPatch(typeof(AnimatedObjectTrigger), "PlayAudio")]
[HarmonyPrefix]
private static void AnimatedObjectTrigger_Pre_PlayAudio(AnimatedObjectTrigger __instance)
{
if ((!Plugin.configRecord.Value && (Object)(object)recordPlayerTrigger == (Object)null) || (Object)(object)GameNetworkManager.Instance?.localPlayerController == (Object)null || (Object)(object)__instance.thisAudioSource == (Object)null || (Object)(object)__instance.playWhileTrue == (Object)null || (Object)(object)Plugin.hauntedRecordPlayer1 == (Object)null)
{
return;
}
if ((Object)(object)recordPlayerTrigger == (Object)null && (Object)(object)__instance.triggerAnimator != (Object)null && ((Object)__instance.triggerAnimator).name.StartsWith("RecordPlayerContainer"))
{
recordPlayerTrigger = __instance;
if ((Object)(object)recordPlayerJazz == (Object)null)
{
recordPlayerJazz = __instance.playWhileTrue;
recordDoppler = __instance.thisAudioSource.dopplerLevel;
recordVolume = __instance.thisAudioSource.volume;
}
}
if (!((Object)(object)__instance == (Object)(object)recordPlayerTrigger) || recordRandom == null)
{
return;
}
AudioClip val = ((Plugin.configRecord.Value && recordRandom.NextDouble() < 0.5) ? Plugin.hauntedRecordPlayer1 : recordPlayerJazz);
if (!((Object)(object)__instance.thisAudioSource.clip == (Object)(object)val))
{
__instance.playWhileTrue = val;
if ((Object)(object)val == (Object)(object)Plugin.hauntedRecordPlayer1)
{
__instance.thisAudioSource.dopplerLevel = 1.78f;
__instance.thisAudioSource.volume = recordVolume * 0.5f;
Plugin.Logger.LogDebug((object)"Loaded Upturned track into Record player");
}
else
{
__instance.thisAudioSource.dopplerLevel = recordDoppler;
__instance.thisAudioSource.volume = recordVolume;
Plugin.Logger.LogDebug((object)"Loaded default track into Record player");
}
__instance.audioTime = 0f;
}
}
[HarmonyPatch(typeof(StartOfRound), "Start")]
[HarmonyPostfix]
private static void StartOfRound_Post_Start(StartOfRound __instance)
{
recordRandom = new Random(__instance.randomMapSeed + 3232022);
}
[HarmonyPatch(typeof(StartOfRound), "OnPlayerConnectedClientRpc")]
[HarmonyPostfix]
private static void StartOfRound_Post_OnPlayerConnectedClientRpc(StartOfRound __instance)
{
recordRandom = new Random(__instance.randomMapSeed + 3232022);
}
[HarmonyPatch(typeof(TimeOfDay), "SyncTimeClientRpc")]
[HarmonyPostfix]
private static void TimeOfDay_Post_SyncTimeClientRpc(TimeOfDay __instance)
{
recordRandom = new Random(StartOfRound.Instance.randomMapSeed + 3232022 / __instance.RoundUpToNearestTen(__instance.globalTime));
}
}
internal static class SharedPalette
{
internal static readonly Color RUBBER_HANDLE_UPTURNED = new Color(0.01842319f, 0.01562534f, 0.01562534f);
internal static readonly Color DARK_STEEL_UPTURNED = new Color(0.2547169f, 0.2547169f, 0.2547169f);
}
internal static class SkinManager
{
private static readonly List<IUpturnedItem> allSkinnedItems = new List<IUpturnedItem>(11)
{
new UpturnedGiftBox(),
new UpturnedCandy(),
new UpturnedCashRegister(),
new UpturnedPerfume(),
new UpturnedPills(),
new UpturnedMug(),
new UpturnedControlPad(),
new UpturnedFish(),
new UpturnedSteeringWheel(),
new UpturnedPickles(),
new UpturnedLamp()
};
private static HashSet<ulong> cache = new HashSet<ulong>();
private static Random random;
internal static List<Renderer> fish = new List<Renderer>();
internal static List<GrabbableObject> chocolates = new List<GrabbableObject>();
internal static void LoadAllConfigs(ConfigFile cfg)
{
foreach (IUpturnedItem allSkinnedItem in allSkinnedItems)
{
allSkinnedItem.LoadConfigs(cfg);
}
}
internal static void LoadAllSkins(AssetBundle bundle)
{
foreach (IUpturnedItem allSkinnedItem in allSkinnedItems)
{
allSkinnedItem.LoadSkins(bundle);
}
}
internal static void Reset()
{
cache.Clear();
fish.Clear();
chocolates.Clear();
}
internal static void ApplySkinsToItems(NetworkObjectReference[] netRefs)
{
//IL_0025: Unknown result type (might be due to invalid IL or missing references)
//IL_002a: Unknown result type (might be due to invalid IL or missing references)
random = new Random(StartOfRound.Instance.randomMapSeed + 32322);
NetworkObject val2 = default(NetworkObject);
GrabbableObject item = default(GrabbableObject);
for (int i = 0; i < netRefs.Length; i++)
{
NetworkObjectReference val = netRefs[i];
if (!((NetworkObjectReference)(ref val)).TryGet(ref val2, (NetworkManager)null) || !cache.Add(val2.NetworkObjectId) || !((Component)val2).TryGetComponent<GrabbableObject>(ref item))
{
continue;
}
IUpturnedItem upturnedItem = allSkinnedItems.FirstOrDefault((IUpturnedItem skin) => skin.GetItemName() == ((Object)item.itemProperties).name);
if (upturnedItem != null)
{
int[] randomData = upturnedItem.GetRandomData();
int[] array = new int[randomData.Length];
for (int j = 0; j < randomData.Length; j++)
{
array[j] = random.Next(randomData[j]);
}
if (upturnedItem.MatchToVanillaItem(item))
{
upturnedItem.ApplySkin(item, array);
}
}
}
}
internal static bool IsThereABanana()
{
bool flag = false;
bool result = false;
for (int i = 0; i < fish.Count; i++)
{
if ((Object)(object)fish[i] == (Object)null)
{
flag = true;
}
else if (fish[i].sharedMaterials != null && fish[i].sharedMaterials.Length == 3)
{
result = true;
}
}
if (flag)
{
fish.RemoveAll((Renderer x) => x == null);
}
return result;
}
}
public class SubstituteItemName : MonoBehaviour
{
public string subName;
}
public class UnusableItem : MonoBehaviour
{
private GrabbableObject item;
private void LateUpdate()
{
if ((Object)(object)item == (Object)null)
{
item = ((Component)this).GetComponent<GrabbableObject>();
if ((Object)(object)item == (Object)null)
{
((Behaviour)this).enabled = false;
}
else
{
item.useCooldown = 50f;
}
}
else
{
item.currentUseCooldown = item.useCooldown;
}
}
}
public static class PluginInfo
{
public const string PLUGIN_GUID = "UpturnedVariety";
public const string PLUGIN_NAME = "UpturnedVariety";
public const string PLUGIN_VERSION = "2.2.0";
}
}
namespace UpturnedVariety.Defs.Items
{
internal interface IUpturnedItem
{
internal string GetItemName();
internal int[] GetRandomData();
internal void LoadConfigs(ConfigFile cfg);
internal void LoadSkins(AssetBundle bundle);
internal bool MatchToVanillaItem(GrabbableObject item);
internal void ApplySkin(GrabbableObject item, int[] rand);
}
internal class UpturnedCandy : IUpturnedItem
{
private static readonly Color CANDY_WRAPPER = new Color(0.4528301f, 0.03396226f, 0f);
private static readonly Color WRAPPER_FOIL = new Color(0.3584906f, 0.3584906f, 0.3584906f);
private static readonly Color CHOCOLATE = new Color(0.1792453f, 0.07193222f, 0.03973834f);
private static ConfigEntry<bool> enableTextures;
private static ConfigEntry<bool> enableMeshes;
private static ConfigEntry<int> chocolateChance;
private static Material lollyPop;
private static Material lightWood;
private static Material candyPink;
private static Material chocolateLabel;
private static Material barcode;
private static Mesh cylinder;
private static Mesh sucker;
private static Mesh cube;
private static AudioClip chocolateBarJingle;
public string GetItemName()
{
return "Candy";
}
public int[] GetRandomData()
{
return new int[3] { 2, 2, 100 };
}
public void LoadConfigs(ConfigFile cfg)
{
enableTextures = cfg.Bind<bool>("Items", "Candy", true, "Enables alternate palettes for the \"Candy\" item.");
enableMeshes = cfg.Bind<bool>("Items", "CandyModels", true, "Enables alternate models for the \"Candy\" item.");
chocolateChance = cfg.Bind<int>("Items", "Chocolate", 20, "Chance (in percentage) for the \"Candy\" item to be replaced with a \"Chocolate bar\" collectible.");
}
public void LoadSkins(AssetBundle bundle)
{
lollyPop = bundle.LoadAsset<Material>("LollyPop");
lightWood = bundle.LoadAsset<Material>("LightWood");
candyPink = bundle.LoadAsset<Material>("CandyPink");
chocolateLabel = bundle.LoadAsset<Material>("chocolateLabel");
barcode = bundle.LoadAsset<Material>("barcode");
cylinder = bundle.LoadAsset<Mesh>("Cylinder.001");
sucker = bundle.LoadAsset<Mesh>("Sucker");
cube = bundle.LoadAsset<Mesh>("Cube");
chocolateBarJingle = bundle.LoadAsset<AudioClip>("ChocolateBarJingle");
if ((Object)(object)lollyPop == (Object)null || (Object)(object)lightWood == (Object)null || (Object)(object)candyPink == (Object)null || (Object)(object)cylinder == (Object)null || (Object)(object)sucker == (Object)null || (Object)(object)chocolateLabel == (Object)null || (Object)(object)barcode == (Object)null || (Object)(object)cube == (Object)null || (Object)(object)chocolateBarJingle == (Object)null)
{
throw new Exception("Failed to load assets for \"Candy\" item");
}
}
public bool MatchToVanillaItem(GrabbableObject item)
{
MeshRenderer mainObjectRenderer = item.mainObjectRenderer;
if (((mainObjectRenderer != null) ? ((Renderer)mainObjectRenderer).sharedMaterials : null) != null && ((Renderer)item.mainObjectRenderer).sharedMaterials.Length == 2)
{
return ((Object)((Renderer)item.mainObjectRenderer).sharedMaterials[0]).name.StartsWith("LollyPop");
}
return false;
}
public void ApplySkin(GrabbableObject item, int[] rand)
{
//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
//IL_0133: Unknown result type (might be due to invalid IL or missing references)
//IL_0145: Unknown result type (might be due to invalid IL or missing references)
//IL_01b4: Unknown result type (might be due to invalid IL or missing references)
//IL_01b9: Unknown result type (might be due to invalid IL or missing references)
//IL_01c9: Unknown result type (might be due to invalid IL or missing references)
//IL_01da: Unknown result type (might be due to invalid IL or missing references)
//IL_01e0: Unknown result type (might be due to invalid IL or missing references)
//IL_01e5: Unknown result type (might be due to invalid IL or missing references)
//IL_01f4: Unknown result type (might be due to invalid IL or missing references)
if (chocolateChance.Value > 0 && (chocolateChance.Value >= 100 || rand[2] < chocolateChance.Value))
{
((Component)item.mainObjectRenderer).GetComponent<MeshFilter>().mesh = cube;
Material[] array = (Material[])(object)new Material[5]
{
Object.Instantiate<Material>(((Renderer)item.mainObjectRenderer).sharedMaterials[0]),
Object.Instantiate<Material>(((Renderer)item.mainObjectRenderer).sharedMaterials[0]),
Object.Instantiate<Material>(((Renderer)item.mainObjectRenderer).sharedMaterials[0]),
chocolateLabel,
barcode
};
array[0].SetColor("_Color", CANDY_WRAPPER);
array[0].SetColor("_BaseColor", CANDY_WRAPPER);
array[0].SetFloat("_Metallic", 0f);
array[0].SetFloat("_Smoothness", 0.733f);
array[1].SetColor("_Color", WRAPPER_FOIL);
array[1].SetColor("_BaseColor", WRAPPER_FOIL);
array[1].SetFloat("_Metallic", 0.692f);
array[1].SetFloat("_Smoothness", 0.521f);
array[2].SetColor("_Color", CHOCOLATE);
array[2].SetColor("_BaseColor", CHOCOLATE);
array[2].SetFloat("_Metallic", 0.439f);
array[2].SetFloat("_Smoothness", 0.35f);
((Renderer)item.mainObjectRenderer).materials = array;
ScanNodeProperties componentInChildren = ((Component)item).GetComponentInChildren<ScanNodeProperties>();
if ((Object)(object)componentInChildren != (Object)null)
{
componentInChildren.headerText = "Chocolate bar";
}
((Component)item).gameObject.AddComponent<SubstituteItemName>().subName = "Chocolate bar";
GameObject val = new GameObject("Jingle");
val.AddComponent<AudioSource>().clip = chocolateBarJingle;
val.transform.SetParent(((Component)item).transform);
val.transform.SetLocalPositionAndRotation(Vector3.zero, Quaternion.identity);
val.transform.localScale = Vector3.one;
if (!SkinManager.chocolates.Contains(item))
{
SkinManager.chocolates.Add(item);
}
Plugin.Logger.LogDebug((object)$"Candy #{((Component)item).GetComponent<NetworkObject>().NetworkObjectId} becomes chocolate bar");
return;
}
if (enableTextures.Value && rand[0] == 1)
{
((Renderer)item.mainObjectRenderer).materials = (Material[])(object)new Material[2] { lollyPop, lightWood };
Plugin.Logger.LogDebug((object)$"Candy #{((Component)item).GetComponent<NetworkObject>().NetworkObjectId} using alternate texture");
if (rand[1] == 0)
{
((Component)item.mainObjectRenderer).GetComponent<MeshFilter>().mesh = cylinder;
}
}
if (enableMeshes.Value && rand[1] == 1)
{
((Component)item.mainObjectRenderer).GetComponent<MeshFilter>().mesh = sucker;
Plugin.Logger.LogDebug((object)$"Candy #{((Component)item).GetComponent<NetworkObject>().NetworkObjectId} using alternate model");
if (rand[0] == 0)
{
((Renderer)item.mainObjectRenderer).materials = (Material[])(object)new Material[2]
{
candyPink,
((Renderer)item.mainObjectRenderer).sharedMaterials[1]
};
}
}
}
}
internal class UpturnedCashRegister : IUpturnedItem
{
private static readonly Color BLUE_COUNTER = new Color(0.08535064f, 0.08980062f, 0.1320755f);
private static readonly Color BRASS = new Color(0.3867925f, 0.2725252f, 0.2244126f);
private static ConfigEntry<bool> enableModels;
private static Mesh cashRegister;
private static Material steelDoorKnob;
public string GetItemName()
{
return "CashRegister";
}
public int[] GetRandomData()
{
return new int[1] { 2 };
}
public void LoadConfigs(ConfigFile cfg)
{
enableModels = cfg.Bind<bool>("Items", "CashRegister", true, "Enables alternate models for the \"Cash register\" item.");
}
public void LoadSkins(AssetBundle bundle)
{
cashRegister = bundle.LoadAsset<Mesh>("CashRegister");
steelDoorKnob = bundle.LoadAsset<Material>("SteelDoorKnob");
if ((Object)(object)cashRegister == (Object)null || (Object)(object)steelDoorKnob == (Object)null)
{
throw new Exception("Failed to load assets for \"Cash register\" item");
}
}
public bool MatchToVanillaItem(GrabbableObject item)
{
MeshRenderer mainObjectRenderer = item.mainObjectRenderer;
if ((Object)(object)((mainObjectRenderer != null) ? ((Renderer)mainObjectRenderer).sharedMaterial : null) != (Object)null && ((Object)((Renderer)item.mainObjectRenderer).sharedMaterial).name.StartsWith("CashRegisterMat"))
{
NoisemakerProp val = (NoisemakerProp)(object)((item is NoisemakerProp) ? item : null);
if (val != null)
{
return (Object)(object)val.triggerAnimator != (Object)null;
}
}
return false;
}
public void ApplySkin(GrabbableObject item, int[] rand)
{
//IL_0098: Unknown result type (might be due to invalid IL or missing references)
//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
//IL_0128: Unknown result type (might be due to invalid IL or missing references)
//IL_013a: Unknown result type (might be due to invalid IL or missing references)
//IL_0170: Unknown result type (might be due to invalid IL or missing references)
//IL_0182: Unknown result type (might be due to invalid IL or missing references)
if (!enableModels.Value || rand[0] != 1)
{
return;
}
((Component)item.mainObjectRenderer).GetComponent<MeshFilter>().mesh = cashRegister;
Material val = Object.Instantiate<Material>(((Renderer)item.mainObjectRenderer).sharedMaterial);
val.SetTexture("_MainTex", (Texture)null);
val.SetTexture("_BaseColorMap", (Texture)null);
val.SetTexture("_NormalMap", (Texture)null);
Material[] array = (Material[])(object)new Material[5]
{
val,
Object.Instantiate<Material>(val),
steelDoorKnob,
Object.Instantiate<Material>(val),
Object.Instantiate<Material>(val)
};
array[0].SetColor("_Color", BLUE_COUNTER);
array[0].SetColor("_BaseColor", BLUE_COUNTER);
array[0].SetFloat("_Metallic", 0f);
array[0].SetFloat("_Smoothness", 0.5f);
array[1].SetColor("_Color", SharedPalette.DARK_STEEL_UPTURNED);
array[1].SetColor("_BaseColor", SharedPalette.DARK_STEEL_UPTURNED);
array[1].SetFloat("_Metallic", 0.724f);
array[1].SetFloat("_Smoothness", 0.5f);
array[3].SetColor("_Color", SharedPalette.RUBBER_HANDLE_UPTURNED);
array[3].SetColor("_BaseColor", SharedPalette.RUBBER_HANDLE_UPTURNED);
array[3].SetFloat("_Metallic", 0f);
array[3].SetFloat("_Smoothness", 0.5f);
array[4].SetColor("_Color", BRASS);
array[4].SetColor("_BaseColor", BRASS);
array[4].SetFloat("_Metallic", 0.78f);
array[4].SetFloat("_Smoothness", 0.64f);
((Renderer)item.mainObjectRenderer).materials = array;
NoisemakerProp val2 = (NoisemakerProp)(object)((item is NoisemakerProp) ? item : null);
if (val2 != null)
{
Renderer[] componentsInChildren = ((Component)val2.triggerAnimator).GetComponentsInChildren<Renderer>();
foreach (Renderer obj in componentsInChildren)
{
obj.forceRenderingOff = true;
obj.enabled = false;
}
((Component)val2).gameObject.AddComponent<UnusableItem>();
}
Plugin.Logger.LogDebug((object)$"Register #{((Component)item).GetComponent<NetworkObject>().NetworkObjectId} using alternate model");
}
}
internal class UpturnedControlPad : IUpturnedItem
{
private static ConfigEntry<bool> enableTextures;
private static Texture arcadeControlPanel2;
public string GetItemName()
{
return "ControlPad";
}
public int[] GetRandomData()
{
return new int[1] { 2 };
}
public void LoadConfigs(ConfigFile cfg)
{
enableTextures = cfg.Bind<bool>("Items", "ControlPad", true, "Enables alternate palettes for the \"Control pad\" item.");
}
public void LoadSkins(AssetBundle bundle)
{
arcadeControlPanel2 = bundle.LoadAsset<Texture>("ArcadeControlPanel2");
if ((Object)(object)arcadeControlPanel2 == (Object)null)
{
throw new Exception("Failed to load assets for \"Control pad\" item");
}
}
public bool MatchToVanillaItem(GrabbableObject item)
{
Renderer val = default(Renderer);
if (((Component)item).TryGetComponent<Renderer>(ref val) && (Object)(object)val.sharedMaterial != (Object)null)
{
return ((Object)val.sharedMaterial).name.StartsWith("ArcadeControlPanel");
}
return false;
}
public void ApplySkin(GrabbableObject item, int[] rand)
{
if (enableTextures.Value && rand[0] == 1)
{
((Component)item).GetComponent<Renderer>().material.mainTexture = arcadeControlPanel2;
Plugin.Logger.LogDebug((object)$"Controller #{((Component)item).GetComponent<NetworkObject>().NetworkObjectId} using alternate texture");
}
}
}
internal class UpturnedFish : IUpturnedItem
{
private static readonly Color YELLOW_FISH = new Color(0.773024f, 0.8392157f, 0.3692549f);
private static readonly Color SILVER_FISH = new Color(0.5019608f, 0.1780566f, 0.1556078f);
private static readonly Color YELLOW_RUBBER = new Color(0.44f, 0.4296874f, 0.2028124f);
private static readonly Color MATERIAL_001 = new Color(0.3799999f, 0.243271f, 0.1527103f);
private static ConfigEntry<bool> enableMeshes;
private static Mesh fish2;
private static Mesh sardine;
private static Mesh sardine001;
public string GetItemName()
{
return "FishTestProp";
}
public int[] GetRandomData()
{
return new int[2] { 4, 3 };
}
public void LoadConfigs(ConfigFile cfg)
{
enableMeshes = cfg.Bind<bool>("Items", "Fish", true, "Enables alternate models for the \"Plastic fish\" item.");
}
public void LoadSkins(AssetBundle bundle)
{
fish2 = bundle.LoadAsset<Mesh>("Fish2");
sardine = bundle.LoadAsset<Mesh>("Sardine");
sardine001 = bundle.LoadAsset<Mesh>("Sardine.001");
if ((Object)(object)fish2 == (Object)null || (Object)(object)sardine == (Object)null || (Object)(object)sardine001 == (Object)null)
{
throw new Exception("Failed to load assets for \"Plastic fish\" item");
}
}
public bool MatchToVanillaItem(GrabbableObject item)
{
MeshRenderer mainObjectRenderer = item.mainObjectRenderer;
if (((mainObjectRenderer != null) ? ((Renderer)mainObjectRenderer).sharedMaterials : null) != null && ((Renderer)item.mainObjectRenderer).sharedMaterials.Length == 2)
{
return ((Object)((Renderer)item.mainObjectRenderer).sharedMaterials[0]).name.StartsWith("Eye");
}
return false;
}
public void ApplySkin(GrabbableObject item, int[] rand)
{
//IL_006d: Unknown result type (might be due to invalid IL or missing references)
//IL_007d: Unknown result type (might be due to invalid IL or missing references)
//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
//IL_013e: Unknown result type (might be due to invalid IL or missing references)
//IL_014f: Unknown result type (might be due to invalid IL or missing references)
//IL_0160: Unknown result type (might be due to invalid IL or missing references)
//IL_0171: Unknown result type (might be due to invalid IL or missing references)
if (!enableMeshes.Value)
{
return;
}
int num = rand[0];
if (num == 3 && SkinManager.IsThereABanana())
{
num = rand[1];
}
if (num > 0)
{
MeshFilter component = ((Component)item.mainObjectRenderer).GetComponent<MeshFilter>();
switch (num)
{
case 1:
{
component.mesh = fish2;
Material val4 = ((Renderer)item.mainObjectRenderer).materials[1];
val4.SetColor("_Color", YELLOW_FISH);
val4.SetColor("_BaseColor", YELLOW_FISH);
((Renderer)item.mainObjectRenderer).materials = (Material[])(object)new Material[2]
{
val4,
((Renderer)item.mainObjectRenderer).sharedMaterials[0]
};
break;
}
case 2:
{
component.mesh = sardine;
Material val3 = ((Renderer)item.mainObjectRenderer).materials[1];
val3.SetColor("_Color", SILVER_FISH);
val3.SetColor("_BaseColor", SILVER_FISH);
((Renderer)item.mainObjectRenderer).materials = (Material[])(object)new Material[2]
{
((Renderer)item.mainObjectRenderer).sharedMaterials[0],
val3
};
break;
}
case 3:
{
component.mesh = sardine001;
Material val = ((Renderer)item.mainObjectRenderer).materials[1];
Material val2 = Object.Instantiate<Material>(val);
val.SetColor("_Color", YELLOW_RUBBER);
val.SetColor("_BaseColor", YELLOW_RUBBER);
val2.SetColor("_Color", MATERIAL_001);
val2.SetColor("_BaseColor", MATERIAL_001);
((Renderer)item.mainObjectRenderer).materials = (Material[])(object)new Material[3]
{
((Renderer)item.mainObjectRenderer).sharedMaterials[0],
val,
val2
};
break;
}
}
Plugin.Logger.LogDebug((object)$"Fish #{((Component)item).GetComponent<NetworkObject>().NetworkObjectId} using alternate model");
}
}
}
internal class UpturnedGiftBox : IUpturnedItem
{
private static ConfigEntry<bool> enableTextures;
private static Texture giftBoxTex2;
public string GetItemName()
{
return "GiftBox";
}
public int[] GetRandomData()
{
return new int[1] { 2 };
}
public void LoadConfigs(ConfigFile cfg)
{
enableTextures = cfg.Bind<bool>("Items", "Gift", true, "Enables alternate palettes for the \"Gift box\" item.");
}
public void LoadSkins(AssetBundle bundle)
{
giftBoxTex2 = bundle.LoadAsset<Texture>("GiftBoxTex2");
if ((Object)(object)giftBoxTex2 == (Object)null)
{
throw new Exception("Failed to load assets for \"Gift box\" item");
}
}
public bool MatchToVanillaItem(GrabbableObject item)
{
if (item is GiftBoxItem)
{
return item.itemProperties.itemId == 152767;
}
return false;
}
public void ApplySkin(GrabbableObject item, int[] rand)
{
if (enableTextures.Value && rand[0] == 1)
{
((Component)item).GetComponent<Renderer>().material.mainTexture = giftBoxTex2;
Plugin.Logger.LogDebug((object)$"Gift #{((Component)item).GetComponent<NetworkObject>().NetworkObjectId} using alternate texture");
}
}
}
internal class UpturnedLamp : IUpturnedItem
{
private static readonly Color LAMP_STAND_UPTURNED = new Color(0.2395526f, 0.2213185f, 0.1565525f);
private static readonly Color LAMPSHADE_LETHAL = new Color(0.513327f, 0.4134762f, 0.3871232f);
private static readonly Color LAMP_STAND_LETHAL = new Color(0.5266604f, 0.5077859f, 0.4321852f);
private static readonly Color DARK_STEEL_LETHAL = new Color(0.1733264f, 0.1733264f, 0.1733264f);
private static ConfigEntry<bool> enableMeshes;
private static Material lampshade;
private static Mesh cylinder;
public string GetItemName()
{
return "FancyLamp";
}
public int[] GetRandomData()
{
return new int[2] { 2, 2 };
}
public void LoadConfigs(ConfigFile cfg)
{
enableMeshes = cfg.Bind<bool>("Items", "Lamp", true, "Enables alternate models for the \"Fancy lamp\" item.");
}
public void LoadSkins(AssetBundle bundle)
{
lampshade = bundle.LoadAsset<Material>("Lampshade");
cylinder = bundle.LoadAsset<Mesh>("Cylinder.000");
if ((Object)(object)lampshade == (Object)null || (Object)(object)cylinder == (Object)null)
{
throw new Exception("Failed to load assets for \"Fancy lamp\" item");
}
}
public bool MatchToVanillaItem(GrabbableObject item)
{
if (Plugin.INSTALLED_GENERAL_IMPROVEMENTS && (Object)(object)item.mainObjectRenderer == (Object)null)
{
item.mainObjectRenderer = ((Component)item).GetComponent<MeshRenderer>();
}
MeshRenderer mainObjectRenderer = item.mainObjectRenderer;
if ((Object)(object)((mainObjectRenderer != null) ? ((Renderer)mainObjectRenderer).sharedMaterial : null) != (Object)null)
{
return ((Object)((Renderer)item.mainObjectRenderer).sharedMaterial).name.StartsWith("FancyLampTex");
}
return false;
}
public void ApplySkin(GrabbableObject item, int[] rand)
{
//IL_00af: Unknown result type (might be due to invalid IL or missing references)
//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
//IL_01e1: Unknown result type (might be due to invalid IL or missing references)
//IL_01f3: Unknown result type (might be due to invalid IL or missing references)
//IL_0229: Unknown result type (might be due to invalid IL or missing references)
//IL_023b: Unknown result type (might be due to invalid IL or missing references)
//IL_0271: Unknown result type (might be due to invalid IL or missing references)
//IL_0283: Unknown result type (might be due to invalid IL or missing references)
//IL_02b9: Unknown result type (might be due to invalid IL or missing references)
//IL_02cb: Unknown result type (might be due to invalid IL or missing references)
//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
//IL_0102: Unknown result type (might be due to invalid IL or missing references)
//IL_0138: Unknown result type (might be due to invalid IL or missing references)
//IL_014a: Unknown result type (might be due to invalid IL or missing references)
//IL_0180: Unknown result type (might be due to invalid IL or missing references)
//IL_0192: Unknown result type (might be due to invalid IL or missing references)
if (enableMeshes.Value && rand[1] == 1)
{
((Component)item.mainObjectRenderer).GetComponent<MeshFilter>().mesh = cylinder;
Plugin.Logger.LogDebug((object)$"Lamp #{((Component)item).GetComponent<NetworkObject>().NetworkObjectId} using alternate model");
Material val = Object.Instantiate<Material>(((Renderer)item.mainObjectRenderer).sharedMaterial);
val.SetTexture("_MainTex", (Texture)null);
val.SetTexture("_BaseColorMap", (Texture)null);
Material[] array = (Material[])(object)new Material[4]
{
default(Material),
val,
Object.Instantiate<Material>(val),
Object.Instantiate<Material>(val)
};
Light componentInChildren = ((Component)item.mainObjectRenderer).GetComponentInChildren<Light>();
((Component)componentInChildren).transform.localPosition = new Vector3(((Component)componentInChildren).transform.localPosition.x, ((Component)componentInChildren).transform.localPosition.y, 1.626763f);
if (rand[0] == 0)
{
array[0] = lampshade;
array[1].SetColor("_Color", LAMP_STAND_UPTURNED);
array[1].SetColor("_BaseColor", LAMP_STAND_UPTURNED);
array[1].SetFloat("_Metallic", 0.7f);
array[1].SetFloat("_Smoothness", 0.5f);
array[2].SetColor("_Color", SharedPalette.RUBBER_HANDLE_UPTURNED);
array[2].SetColor("_BaseColor", SharedPalette.RUBBER_HANDLE_UPTURNED);
array[2].SetFloat("_Metallic", 0f);
array[2].SetFloat("_Smoothness", 0.5f);
array[3].SetColor("_Color", SharedPalette.DARK_STEEL_UPTURNED);
array[3].SetColor("_BaseColor", SharedPalette.DARK_STEEL_UPTURNED);
array[3].SetFloat("_Metallic", 0.724f);
array[3].SetFloat("_Smoothness", 0.5f);
componentInChildren.colorTemperature = 4846f;
}
else
{
array[0] = Object.Instantiate<Material>(val);
array[0].SetColor("_Color", LAMPSHADE_LETHAL);
array[0].SetColor("_BaseColor", LAMPSHADE_LETHAL);
array[0].SetFloat("_Metallic", 0f);
array[0].SetFloat("_Smoothness", 0.5f);
array[1].SetColor("_Color", LAMP_STAND_LETHAL);
array[1].SetColor("_BaseColor", LAMP_STAND_LETHAL);
array[1].SetFloat("_Metallic", 0.4583333f);
array[1].SetFloat("_Smoothness", 0.5f);
array[2].SetColor("_Color", Color.black);
array[2].SetColor("_BaseColor", Color.black);
array[2].SetFloat("_Metallic", 0f);
array[2].SetFloat("_Smoothness", 0.0916667f);
array[3].SetColor("_Color", DARK_STEEL_LETHAL);
array[3].SetColor("_BaseColor", DARK_STEEL_LETHAL);
array[3].SetFloat("_Metallic", 0.3416667f);
array[3].SetFloat("_Smoothness", 0.55f);
componentInChildren.colorTemperature = 4412f;
}
((Renderer)item.mainObjectRenderer).sharedMaterials = array;
}
}
}
internal class UpturnedMug : IUpturnedItem
{
private static ConfigEntry<bool> enableTextures;
private static Material coffeeMug6;
public string GetItemName()
{
return "Mug";
}
public int[] GetRandomData()
{
return new int[1] { 6 };
}
public void LoadConfigs(ConfigFile cfg)
{
enableTextures = cfg.Bind<bool>("Items", "Mug", true, "Enables alternate palettes for the \"Mug\" item.");
}
public void LoadSkins(AssetBundle bundle)
{
coffeeMug6 = bundle.LoadAsset<Material>("CoffeeMug6");
if ((Object)(object)coffeeMug6 == (Object)null)
{
throw new Exception("Failed to load assets for \"Mug\" item");
}
}
public bool MatchToVanillaItem(GrabbableObject item)
{
MeshRenderer mainObjectRenderer = item.mainObjectRenderer;
if ((Object)(object)((mainObjectRenderer != null) ? ((Renderer)mainObjectRenderer).sharedMaterial : null) != (Object)null)
{
return ((Object)((Renderer)item.mainObjectRenderer).sharedMaterial).name.StartsWith("CoffeeMug");
}
return false;
}
public void ApplySkin(GrabbableObject item, int[] rand)
{
if (enableTextures.Value && rand[0] == 5)
{
((Renderer)item.mainObjectRenderer).material = coffeeMug6;
Plugin.Logger.LogDebug((object)$"Mug #{((Component)item).GetComponent<NetworkObject>().NetworkObjectId} using alternate texture");
}
}
}
internal class UpturnedPerfume : IUpturnedItem
{
private static readonly Color RED = new Color(0.9f, 0.3922666f, 0.324f, 0.6313726f);
private static readonly Color RED_TRANS = new Color(1f, 0.4f, 0.4f);
private static readonly Color BLUE = new Color(0.4509091f, 0.416f, 0.8f, 0.6313726f);
private static readonly Color BLUE_TRANS = new Color(0.59f, 0.6241666f, 1f);
private static readonly Color BLACK = new Color(0.01f, 0.01f, 0.01f, 0.6313726f);
private static readonly Color BLACK_TRANS = new Color(0.48f, 0.48f, 0.48f);
private static ConfigEntry<bool> enableTextures;
private static ConfigEntry<bool> enableMeshes;
private static Mesh[] meshes;
public string GetItemName()
{
return "PerfumeBottle";
}
public int[] GetRandomData()
{
return new int[2] { 4, 6 };
}
public void LoadConfigs(ConfigFile cfg)
{
enableTextures = cfg.Bind<bool>("Items", "Perfume", true, "Enables alternate palettes for the \"Perfume bottle\" item.");
enableMeshes = cfg.Bind<bool>("Items", "PerfumeModels", true, "Enables alternate models for the \"Perfume bottle\" item.");
}
public void LoadSkins(AssetBundle bundle)
{
meshes = (Mesh[])(object)new Mesh[5]
{
bundle.LoadAsset<Mesh>("PerfumeBottle_001"),
bundle.LoadAsset<Mesh>("PerfumeBottle_002"),
bundle.LoadAsset<Mesh>("PerfumeBottle_003"),
bundle.LoadAsset<Mesh>("PerfumeBottle_004"),
bundle.LoadAsset<Mesh>("PerfumeBottle_005")
};
if (meshes.Any((Mesh mesh) => mesh == null))
{
throw new Exception("Failed to load assets for \"Perfume bottle\" item");
}
}
public bool MatchToVanillaItem(GrabbableObject item)
{
MeshRenderer mainObjectRenderer = item.mainObjectRenderer;
if (((mainObjectRenderer != null) ? ((Renderer)mainObjectRenderer).sharedMaterials : null) != null && ((Renderer)item.mainObjectRenderer).sharedMaterials.Length == 2)
{
return ((Object)((Renderer)item.mainObjectRenderer).sharedMaterials[0]).name.StartsWith("Material.004");
}
return false;
}
public void ApplySkin(GrabbableObject item, int[] rand)
{
//IL_001a: Unknown result type (might be due to invalid IL or missing references)
//IL_0022: Unknown result type (might be due to invalid IL or missing references)
//IL_0042: Unknown result type (might be due to invalid IL or missing references)
//IL_0047: Unknown result type (might be due to invalid IL or missing references)
//IL_0048: Unknown result type (might be due to invalid IL or missing references)
//IL_004d: Unknown result type (might be due to invalid IL or missing references)
//IL_0050: Unknown result type (might be due to invalid IL or missing references)
//IL_0055: 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_005b: Unknown result type (might be due to invalid IL or missing references)
//IL_005e: Unknown result type (might be due to invalid IL or missing references)
//IL_0063: Unknown result type (might be due to invalid IL or missing references)
//IL_0064: Unknown result type (might be due to invalid IL or missing references)
//IL_0069: Unknown result type (might be due to invalid IL or missing references)
//IL_007e: Unknown result type (might be due to invalid IL or missing references)
//IL_008a: Unknown result type (might be due to invalid IL or missing references)
//IL_0096: Unknown result type (might be due to invalid IL or missing references)
if (enableTextures.Value && rand[0] > 0)
{
Color val = default(Color);
Color val2 = default(Color);
switch (rand[0])
{
case 1:
val = RED;
val2 = RED_TRANS;
break;
case 2:
val = BLUE;
val2 = BLUE_TRANS;
break;
case 3:
val = BLACK;
val2 = BLACK_TRANS;
break;
}
Material val3 = ((Renderer)item.mainObjectRenderer).materials[0];
val3.SetColor("_Color", val);
val3.SetColor("_BaseColor", val);
val3.SetColor("_TransmittanceColor", val2);
((Renderer)item.mainObjectRenderer).materials = (Material[])(object)new Material[2]
{
val3,
((Renderer)item.mainObjectRenderer).sharedMaterials[1]
};
Plugin.Logger.LogDebug((object)$"Perfume #{((Component)item).GetComponent<NetworkObject>().NetworkObjectId} using alternate color");
}
if (enableMeshes.Value && rand[1] > 0 && rand[1] <= meshes.Length)
{
((Component)item.mainObjectRenderer).GetComponent<MeshFilter>().mesh = meshes[rand[1] - 1];
Plugin.Logger.LogDebug((object)$"Perfume #{((Component)item).GetComponent<NetworkObject>().NetworkObjectId} using alternate model");
}
}
}
internal class UpturnedPickles : IUpturnedItem
{
private static ConfigEntry<bool> enableMeshes;
private static Material glassCase;
private static Material displayCasePlastic;
private static Mesh glassJar;
private static GameObject candyGlob;
public string GetItemName()
{
return "PickleJar";
}
public int[] GetRandomData()
{
return new int[1] { 2 };
}
public void LoadConfigs(ConfigFile cfg)
{
enableMeshes = cfg.Bind<bool>("Items", "Pickles", true, "Enables \"Candy jar\" replacement for the \"Jar of pickles\" item.");
}
public void LoadSkins(AssetBundle bundle)
{
glassJar = bundle.LoadAsset<Mesh>("GlassJar");
glassCase = bundle.LoadAsset<Material>("GlassCase");
displayCasePlastic = bundle.LoadAsset<Material>("DisplayCasePlastic");
candyGlob = bundle.LoadAsset<GameObject>("CandyGlob");
if ((Object)(object)glassJar == (Object)null || (Object)(object)glassCase == (Object)null || (Object)(object)displayCasePlastic == (Object)null || (Object)(object)candyGlob == (Object)null)
{
throw new Exception("Failed to load assets for \"Jar of pickles\" item");
}
}
public bool MatchToVanillaItem(GrabbableObject item)
{
Renderer val = default(Renderer);
if (((Component)item).TryGetComponent<Renderer>(ref val) && val.sharedMaterials != null && val.sharedMaterials.Length == 2 && ((Object)val.sharedMaterials[0]).name.StartsWith("JarGlass"))
{
return (Object)(object)((Component)item).transform.Find("Pickles.001") != (Object)null;
}
return false;
}
public void ApplySkin(GrabbableObject item, int[] rand)
{
if (enableMeshes.Value && rand[0] == 1)
{
((Component)((Component)item).transform.Find("Pickles.001")).gameObject.SetActive(false);
((Component)item).GetComponent<MeshFilter>().mesh = glassJar;
((Component)item).GetComponent<Renderer>().materials = (Material[])(object)new Material[2] { glassCase, displayCasePlastic };
Object.Instantiate<GameObject>(candyGlob, ((Component)item).transform);
ScanNodeProperties componentInChildren = ((Component)item).GetComponentInChildren<ScanNodeProperties>();
if ((Object)(object)componentInChildren != (Object)null)
{
componentInChildren.headerText = "Candy filled jar";
}
((Component)item).gameObject.AddComponent<SubstituteItemName>().subName = "Candy jar";
Plugin.Logger.LogDebug((object)$"Pickles #{((Component)item).GetComponent<NetworkObject>().NetworkObjectId} is alternate");
}
}
}
internal class UpturnedPills : IUpturnedItem
{
private static ConfigEntry<bool> enableTextures;
private static Texture pillBottleTextureB2;
public string GetItemName()
{
return "PillBottle";
}
public int[] GetRandomData()
{
return new int[1] { 2 };
}
public void LoadConfigs(ConfigFile cfg)
{
enableTextures = cfg.Bind<bool>("Items", "Pills", true, "Enables alternate palettes for the \"Pill bottle\" item.");
}
public void LoadSkins(AssetBundle bundle)
{
pillBottleTextureB2 = bundle.LoadAsset<Texture>("PillBottleTextureB2");
if ((Object)(object)pillBottleTextureB2 == (Object)null)
{
throw new Exception("Failed to load assets for \"Pill bottle\" item");
}
}
public bool MatchToVanillaItem(GrabbableObject item)
{
MeshRenderer mainObjectRenderer = item.mainObjectRenderer;
if ((Object)(object)((mainObjectRenderer != null) ? ((Renderer)mainObjectRenderer).sharedMaterial : null) != (Object)null)
{
return ((Object)((Renderer)item.mainObjectRenderer).sharedMaterial).name.StartsWith("Material.002");
}
return false;
}
public void ApplySkin(GrabbableObject item, int[] rand)
{
if (enableTextures.Value && rand[0] == 1)
{
((Renderer)item.mainObjectRenderer).material.mainTexture = pillBottleTextureB2;
Plugin.Logger.LogDebug((object)$"Pills #{((Component)item).GetComponent<NetworkObject>().NetworkObjectId} using alternate texture");
}
}
}
internal class UpturnedSteeringWheel : IUpturnedItem
{
private static ConfigEntry<bool> enableTextures;
private static Material darkPlastic;
public string GetItemName()
{
return "SteeringWheel";
}
public int[] GetRandomData()
{
return new int[1] { 2 };
}
public void LoadConfigs(ConfigFile cfg)
{
enableTextures = cfg.Bind<bool>("Items", "SteeringWheel", true, "Enables alternate palettes for the \"Steering wheel\" item.");
}
public void LoadSkins(AssetBundle bundle)
{
darkPlastic = bundle.LoadAsset<Material>("DarkPlastic");
if ((Object)(object)darkPlastic == (Object)null)
{
throw new Exception("Failed to load assets for \"Steering wheel\" item");
}
}
public bool MatchToVanillaItem(GrabbableObject item)
{
if ((Object)(object)item.mainObjectRenderer != (Object)null && (Object)(object)((Renderer)item.mainObjectRenderer).sharedMaterial != (Object)null)
{
return ((Object)((Renderer)item.mainObjectRenderer).sharedMaterial).name.StartsWith("DirtySmoothSteel");
}
return false;
}
public void ApplySkin(GrabbableObject item, int[] rand)
{
if (enableTextures.Value && rand[0] == 1)
{
((Renderer)item.mainObjectRenderer).material = darkPlastic;
Plugin.Logger.LogDebug((object)$"Wheel #{((Component)item).GetComponent<NetworkObject>().NetworkObjectId} using alternate texture");
}
}
}
}
namespace System.Runtime.CompilerServices
{
[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
internal sealed class IgnoresAccessChecksToAttribute : Attribute
{
public IgnoresAccessChecksToAttribute(string assemblyName)
{
}
}
}
