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 Custom_Consumables;
using Custom_Consumables.Logging;
using HarmonyLib;
using MelonLoader;
using Microsoft.CodeAnalysis;
using RainsCustomConsumables;
using ScheduleOne;
using ScheduleOne.DevUtilities;
using ScheduleOne.Equipping;
using ScheduleOne.ItemFramework;
using ScheduleOne.UI.Shop;
using UnityEngine;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: MelonInfo(typeof(global::Custom_Consumables.Custom_Consumables), "RainsCustomConsumables", "0.0.1", "RainingDeath", null)]
[assembly: MelonGame("TVGS", "Schedule I")]
[assembly: IgnoresAccessChecksTo("Assembly-CSharp")]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("RainsCustomConsumables")]
[assembly: AssemblyConfiguration("DebugMelon")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("RainsCarMod")]
[assembly: AssemblyTitle("RainsCustomConsumables")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.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.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
internal sealed class NullableAttribute : Attribute
{
public readonly byte[] NullableFlags;
public NullableAttribute(byte P_0)
{
NullableFlags = new byte[1] { P_0 };
}
public NullableAttribute(byte[] P_0)
{
NullableFlags = P_0;
}
}
[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 Custom_Consumables
{
public class Custom_Consumables : MelonMod
{
[CompilerGenerated]
private sealed class <InitAfterRegistryReady>d__4 : IEnumerator<object>, IEnumerator, IDisposable
{
private int <>1__state;
private object <>2__current;
public Custom_Consumables <>4__this;
private List<CustomShopItem>.Enumerator <>s__1;
private CustomShopItem <item>5__2;
private Dictionary<string, float>.Enumerator <>s__3;
private string <shop>5__4;
private float <price>5__5;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <InitAfterRegistryReady>d__4(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<>s__1 = default(List<CustomShopItem>.Enumerator);
<item>5__2 = null;
<>s__3 = default(Dictionary<string, float>.Enumerator);
<shop>5__4 = null;
<>1__state = -2;
}
private bool MoveNext()
{
//IL_0029: Unknown result type (might be due to invalid IL or missing references)
//IL_0033: Expected O, but got Unknown
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
break;
case 1:
<>1__state = -1;
break;
}
if ((Object)(object)Singleton<Registry>.Instance == (Object)null)
{
<>2__current = (object)new WaitForSeconds(1f);
<>1__state = 1;
return true;
}
<>s__1 = ItemDatabase.Items.GetEnumerator();
try
{
while (<>s__1.MoveNext())
{
<item>5__2 = <>s__1.Current;
RegistryManager.RegisterItem<Equippable>(<item>5__2.ID, <item>5__2.PrefabName, <item>5__2.AssetName);
<>s__3 = <item>5__2.ShopPrices.GetEnumerator();
try
{
while (<>s__3.MoveNext())
{
(<shop>5__4, <price>5__5) = (KeyValuePair<string, float>)(ref <>s__3.Current);
ShopManager.AddItemToShop(<shop>5__4, <item>5__2.ID, <price>5__5);
<shop>5__4 = null;
}
}
finally
{
((IDisposable)<>s__3).Dispose();
}
<>s__3 = default(Dictionary<string, float>.Enumerator);
<item>5__2 = null;
}
}
finally
{
((IDisposable)<>s__1).Dispose();
}
<>s__1 = default(List<CustomShopItem>.Enumerator);
return false;
}
bool IEnumerator.MoveNext()
{
//ILSpy generated this explicit interface implementation from .override directive in MoveNext
return this.MoveNext();
}
[DebuggerHidden]
void IEnumerator.Reset()
{
throw new NotSupportedException();
}
}
public static Dictionary<string, GameObject> LoadedPrefabs = new Dictionary<string, GameObject>();
private static AssetBundle? embeddedBundle;
public override void OnApplicationStart()
{
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
//IL_000c: Expected O, but got Unknown
Harmony val = new Harmony("com.mod.customitems");
val.PatchAll();
LoadEmbeddedBundle();
MelonCoroutines.Start(InitAfterRegistryReady());
Assembly executingAssembly = Assembly.GetExecutingAssembly();
string[] manifestResourceNames = executingAssembly.GetManifestResourceNames();
foreach (string text in manifestResourceNames)
{
}
}
private void LoadEmbeddedBundle()
{
Assembly executingAssembly = Assembly.GetExecutingAssembly();
using Stream stream = executingAssembly.GetManifestResourceStream("RainsCarMod.Resources.customconsumables");
if (stream == null)
{
return;
}
using MemoryStream memoryStream = new MemoryStream();
stream.CopyTo(memoryStream);
embeddedBundle = AssetBundle.LoadFromMemory(memoryStream.ToArray());
if ((Object)(object)embeddedBundle == (Object)null)
{
MelonLogger.Error("[Custom_Consumables] ❌ Failed to load embedded AssetBundle.");
return;
}
Object[] array = embeddedBundle.LoadAllAssets();
foreach (Object val in array)
{
GameObject val2 = (GameObject)(object)((val is GameObject) ? val : null);
if (val2 != null && !LoadedPrefabs.ContainsKey(((Object)val2).name))
{
LoadedPrefabs[((Object)val2).name] = val2;
}
}
}
[IteratorStateMachine(typeof(<InitAfterRegistryReady>d__4))]
private IEnumerator InitAfterRegistryReady()
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <InitAfterRegistryReady>d__4(0)
{
<>4__this = this
};
}
public static T LoadAsset<T>(string assetName) where T : Object
{
AssetBundle? obj = embeddedBundle;
return (obj != null) ? obj.LoadAsset<T>(assetName) : default(T);
}
}
public static class RegistryManager
{
public static void RegisterItem<T>(string id, string prefabName, string definitionName) where T : Object
{
//IL_008e: Unknown result type (might be due to invalid IL or missing references)
//IL_0093: Unknown result type (might be due to invalid IL or missing references)
//IL_009f: Unknown result type (might be due to invalid IL or missing references)
//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
//IL_00af: Expected O, but got Unknown
ScriptableObject obj = Custom_Consumables.LoadAsset<ScriptableObject>(definitionName);
ItemDefinition val = (ItemDefinition)(object)((obj is ItemDefinition) ? obj : null);
if ((Object)(object)val == (Object)null)
{
MelonLogger.Error("❌ Failed to load item definition: " + definitionName);
return;
}
Registry instance = Singleton<Registry>.Instance;
List<ItemRegister> list = typeof(Registry).GetField("ItemRegistry", BindingFlags.Instance | BindingFlags.NonPublic)?.GetValue(instance) as List<ItemRegister>;
if (list == null || !list.Any((ItemRegister x) => x.ID == id))
{
ItemRegister val2 = new ItemRegister
{
ID = id,
Definition = val,
AssetPath = prefabName
};
list?.Add(val2);
typeof(Registry).GetMethod("AddToItemDictionary", BindingFlags.Instance | BindingFlags.NonPublic)?.Invoke(instance, new object[1] { val2 });
}
}
}
public static class ShopManager
{
private static readonly Dictionary<string, List<ShopListing>> _customShopListings = new Dictionary<string, List<ShopListing>>();
public static void AddItemToShop(string shopCode, string itemCode, float? price = null)
{
//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
//IL_0106: Expected O, but got Unknown
Registry instance = Singleton<Registry>.Instance;
if ((Object)(object)instance == (Object)null)
{
MelonLogger.Error("❌ Registry singleton is not initialized.");
return;
}
ItemRegister val = ((typeof(Registry).GetField("ItemRegistry", BindingFlags.Instance | BindingFlags.NonPublic)?.GetValue(instance) is List<ItemRegister> source) ? ((IEnumerable<ItemRegister>)source).FirstOrDefault((Func<ItemRegister, bool>)((ItemRegister x) => x.ID == itemCode)) : null);
if (val == null)
{
MelonLogger.Warning("⚠\ufe0f Could not find item '" + itemCode + "' to add to shop.");
return;
}
ItemDefinition definition = val.Definition;
StorableItemDefinition val2 = (StorableItemDefinition)(object)((definition is StorableItemDefinition) ? definition : null);
if (val2 != null)
{
ShopListing val3 = new ShopListing
{
Item = val2,
name = $"{((ItemDefinition)val2).Name} ({price ?? val2.BasePurchasePrice})"
};
if (price.HasValue)
{
typeof(ShopListing).GetField("OverridePrice", BindingFlags.Instance | BindingFlags.NonPublic)?.SetValue(val3, true);
typeof(ShopListing).GetField("OverriddenPrice", BindingFlags.Instance | BindingFlags.NonPublic)?.SetValue(val3, price.Value);
}
if (!_customShopListings.ContainsKey(shopCode))
{
_customShopListings[shopCode] = new List<ShopListing>();
}
_customShopListings[shopCode].Add(val3);
}
}
public static List<ShopListing> GetShopListings(string shopCode)
{
List<ShopListing> value;
return _customShopListings.TryGetValue(shopCode, out value) ? value : null;
}
}
[HarmonyPatch(typeof(ShopInterface))]
public class ShopPatch
{
[HarmonyPatch("Awake")]
[HarmonyPrefix]
public static void InjectListings(ShopInterface __instance)
{
List<ShopListing> shopListings = ShopManager.GetShopListings(__instance.ShopCode);
if (shopListings == null)
{
return;
}
foreach (ShopListing item in shopListings)
{
if (__instance.Listings.All((ShopListing x) => x.name != item.name))
{
__instance.Listings.Add(item);
}
}
}
}
public static class ItemDatabase
{
public static readonly List<CustomShopItem> Items = new List<CustomShopItem>
{
new CustomShopItem("Ciggy", "Ciggy_equippable", "Ciggy_Weed", new Dictionary<string, float>
{
{ "gas_mart_central", 1f },
{ "gas_mart_west", 1f },
{ "dark_market_shop", 2f }
}),
new CustomShopItem("HorseDrink", "HorseDrink_Equippable", "HorseDrink", new Dictionary<string, float>
{
{ "gas_mart_central", 5f },
{ "gas_mart_west", 5f },
{ "dark_market_shop", 30f }
}),
new CustomShopItem("Coffee", "Coffee_equippable", "Coffee", new Dictionary<string, float>
{
{ "gas_mart_central", 1f },
{ "gas_mart_west", 1f },
{ "dark_market_shop", 5f }
})
};
}
public class CustomShopItem
{
public string ID { get; }
public string PrefabName { get; }
public string AssetName { get; }
public Dictionary<string, float> ShopPrices { get; }
public CustomShopItem(string id, string prefab, string asset, Dictionary<string, float> prices)
{
ID = id;
PrefabName = prefab;
AssetName = asset;
ShopPrices = prices;
}
}
}
namespace Custom_Consumables.Logging
{
public static class Log
{
public static void LogInfo(string message)
{
Melon<Core>.Logger.Msg(message);
}
public static void LogWarning(string message)
{
Melon<Core>.Logger.Warning(message);
}
public static void LogError(string message)
{
Melon<Core>.Logger.Error(message);
}
public static void LogFatal(string message)
{
Melon<Core>.Logger.BigError(message);
}
}
}
namespace RainsCustomConsumables
{
public class Core : MelonMod
{
public override void OnInitializeMelon()
{
Log.LogInfo("Initializing RainsCustomConsumables...");
}
}
}
namespace System.Runtime.CompilerServices
{
[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
internal sealed class IgnoresAccessChecksToAttribute : Attribute
{
public IgnoresAccessChecksToAttribute(string assemblyName)
{
}
}
}
