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.Text.RegularExpressions;
using BepInEx;
using BepInEx.Logging;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using UnityEngine;
using UnityEngine.Localization;
using UnityEngine.Localization.Settings;
using UnityEngine.Localization.Tables;
using UnityEngine.SceneManagement;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: IgnoresAccessChecksTo("Assembly-CSharp")]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("Kalamies")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("0.1.0.0")]
[assembly: AssemblyInformationalVersion("0.1.0")]
[assembly: AssemblyProduct("StrongerBeer")]
[assembly: AssemblyTitle("StrongerBeer")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.1.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
[CompilerGenerated]
[Embedded]
internal sealed class EmbeddedAttribute : Attribute
{
}
}
namespace System.Runtime.CompilerServices
{
[CompilerGenerated]
[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 StrongerBeer
{
[BepInPlugin("kalamies.StrongerBeer", "StrongerBeer", "0.1.0")]
public class Plugin : BaseUnityPlugin
{
public const string Guid = "kalamies.StrongerBeer";
public const string Name = "StrongerBeer";
public const string Version = "0.1.0";
internal static ManualLogSource Log;
private void Awake()
{
//IL_0010: Unknown result type (might be due to invalid IL or missing references)
Log = ((BaseUnityPlugin)this).Logger;
try
{
new Harmony("kalamies.StrongerBeer").PatchAll();
}
catch (Exception arg)
{
Log.LogError((object)$"Could not patch; bait models may look wrong. {arg}");
}
((MonoBehaviour)this).StartCoroutine(Run());
}
private IEnumerator Run()
{
while ((Object)(object)LocalizationSettings.SelectedLocale == (Object)null || GameInfo.AllCreatureCount == 0)
{
yield return null;
}
try
{
Text.Apply();
}
catch (Exception arg)
{
Log.LogError((object)$"Text pass failed, game untouched: {arg}");
}
try
{
Models.Apply();
}
catch (Exception arg2)
{
Log.LogError((object)$"Model pass failed, game untouched: {arg2}");
}
LocalizationSettings.SelectedLocaleChanged += delegate
{
((MonoBehaviour)this).StartCoroutine(Reapply());
};
SceneManager.sceneLoaded += delegate
{
try
{
Models.ApplyToScene();
}
catch (Exception ex)
{
Log.LogWarning((object)("Scene pass failed: " + ex.Message));
}
};
}
private IEnumerator Reapply()
{
yield return (object)new WaitForSeconds(1f);
try
{
Text.Apply();
}
catch (Exception ex)
{
Log.LogWarning((object)("Re-apply failed: " + ex.Message));
}
}
}
internal static class Text
{
private static readonly (string Pattern, string Replacement)[] Rules = new(string, string)[14]
{
("empty beer cans", "empty Koskenkorva bottles"),
("empty beer can", "empty Koskenkorva bottle"),
("Empty Beer Can", "Empty Koskenkorva Bottle"),
("beer can", "Koskenkorva bottle"),
("\\bBeer\\b", "Koskenkorva"),
("\\bbeer\\b", "Koskenkorva"),
("Leere Bierdose", "Leere Koskenkorva-Flasche"),
("leeren bierdose", "leeren Koskenkorva-Flasche"),
("\\bBierdose\\b", "Koskenkorva-Flasche"),
("\\bBier\\b", "Koskenkorva"),
("Lattina di birra vuota", "Bottiglia di Koskenkorva vuota"),
("lattina di birra", "bottiglia di Koskenkorva"),
("\\bBirra\\b", "Koskenkorva"),
("\\bbirra\\b", "Koskenkorva")
};
internal static void Apply()
{
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
//IL_000b: Unknown result type (might be due to invalid IL or missing references)
foreach (StringTable item in ((LocalizedDatabase<StringTable, StringTableEntry>)(object)LocalizationSettings.StringDatabase).GetAllTables((Locale)null).WaitForCompletion())
{
if ((Object)(object)item == (Object)null)
{
continue;
}
foreach (StringTableEntry value in ((DetailedLocalizationTable<StringTableEntry>)(object)item).Values)
{
if (value == null)
{
continue;
}
string localizedValue = ((TableEntry)value).LocalizedValue;
if (!string.IsNullOrEmpty(localizedValue))
{
string text = Rules.Aggregate(localizedValue, (string input, (string Pattern, string Replacement) rule) => Regex.Replace(input, rule.Pattern, rule.Replacement));
if (!(text == localizedValue))
{
value.Value = text;
}
}
}
}
}
}
internal static class Models
{
private const string BundleFile = "koskenkorva.bundle";
private static readonly string[] OriginalMeshes = new string[1] { "beercan" };
private static Mesh _source;
private static Material _material;
private static Mesh _bottle;
private static readonly Dictionary<MeshRenderer, Material> Borrowed = new Dictionary<MeshRenderer, Material>();
private static Item Beer
{
get
{
if (!GameInfo._nameToSpawnable.TryGetValue("beer", out var value))
{
return null;
}
return value;
}
}
internal static void Apply()
{
var (val, val2) = LoadModel();
if (!Object.op_Implicit((Object)(object)val))
{
Plugin.Log.LogWarning((object)"No bottle model available; text changed, models left alone.");
return;
}
CheckShader(val2);
_source = val;
_material = (Object.op_Implicit((Object)(object)val2) ? val2 : CloneMaterialFrom(Beer));
Item beer = Beer;
if (!Build(Reference(beer)))
{
return;
}
if (Object.op_Implicit((Object)(object)beer))
{
MeshFilter[] componentsInChildren = ((Component)beer).GetComponentsInChildren<MeshFilter>(true);
for (int i = 0; i < componentsInChildren.Length; i++)
{
Swap(componentsInChildren[i]);
}
if (IsOriginal(beer._mesh))
{
beer._mesh = _bottle;
}
}
else
{
Plugin.Log.LogWarning((object)"Could not find the beer item.");
}
foreach (BaitInfo allBait in GameInfo.AllBaits)
{
if (Object.op_Implicit((Object)(object)allBait) && ((Object)allBait).name.IndexOf("beercan", StringComparison.OrdinalIgnoreCase) >= 0)
{
if (IsOriginal(allBait._mesh))
{
allBait._mesh = _bottle;
}
if (IsOriginal(allBait._meshForNpc))
{
allBait._meshForNpc = _bottle;
}
}
}
ApplyToScene();
}
internal static void ApplyToScene()
{
if (!Object.op_Implicit((Object)(object)_bottle))
{
return;
}
MeshFilter[] array = Resources.FindObjectsOfTypeAll<MeshFilter>();
foreach (MeshFilter val in array)
{
if (Object.op_Implicit((Object)(object)val))
{
Swap(val);
}
}
}
internal static void Materialise(MeshFilter filter)
{
try
{
MeshRenderer val = default(MeshRenderer);
if (!Object.op_Implicit((Object)(object)filter) || !((Component)filter).TryGetComponent<MeshRenderer>(ref val))
{
return;
}
Material value;
if (Object.op_Implicit((Object)(object)_bottle) && Object.op_Implicit((Object)(object)_material) && (Object)(object)filter.sharedMesh == (Object)(object)_bottle)
{
if (!Borrowed.ContainsKey(val))
{
Borrowed[val] = ((Renderer)val).sharedMaterial;
}
((Renderer)val).sharedMaterial = _material;
}
else if (Borrowed.TryGetValue(val, out value))
{
((Renderer)val).sharedMaterial = value;
Borrowed.Remove(val);
}
}
catch (Exception ex)
{
Plugin.Log.LogWarning((object)("Could not set the bottle material: " + ex.Message));
}
}
private static void Swap(MeshFilter filter)
{
if (Object.op_Implicit((Object)(object)_bottle) && IsOriginal(filter.sharedMesh))
{
filter.sharedMesh = _bottle;
MeshRenderer val = default(MeshRenderer);
if (Object.op_Implicit((Object)(object)_material) && ((Component)filter).TryGetComponent<MeshRenderer>(ref val))
{
((Renderer)val).sharedMaterial = _material;
}
}
}
private static Mesh Reference(Item beer)
{
//IL_0070: Unknown result type (might be due to invalid IL or missing references)
//IL_0075: Unknown result type (might be due to invalid IL or missing references)
//IL_0079: Unknown result type (might be due to invalid IL or missing references)
//IL_0084: Unknown result type (might be due to invalid IL or missing references)
//IL_0089: Unknown result type (might be due to invalid IL or missing references)
//IL_008d: Unknown result type (might be due to invalid IL or missing references)
if (Object.op_Implicit((Object)(object)beer))
{
if (IsOriginal(beer._mesh))
{
return beer._mesh;
}
MeshFilter[] componentsInChildren = ((Component)beer).GetComponentsInChildren<MeshFilter>(true);
foreach (MeshFilter val in componentsInChildren)
{
if (IsOriginal(val.sharedMesh))
{
return val.sharedMesh;
}
}
}
Mesh val2 = null;
Mesh[] array = Resources.FindObjectsOfTypeAll<Mesh>();
foreach (Mesh val3 in array)
{
if (!IsOriginal(val3))
{
continue;
}
if (Object.op_Implicit((Object)(object)val2))
{
Bounds bounds = val3.bounds;
float num = Longest(((Bounds)(ref bounds)).size);
bounds = val2.bounds;
if (!(num > Longest(((Bounds)(ref bounds)).size)))
{
continue;
}
}
val2 = val3;
}
return val2;
}
private static bool Build(Mesh reference)
{
//IL_0026: Unknown result type (might be due to invalid IL or missing references)
//IL_002b: Unknown result type (might be due to invalid IL or missing references)
//IL_002f: Unknown result type (might be due to invalid IL or missing references)
//IL_003f: Unknown result type (might be due to invalid IL or missing references)
//IL_0044: 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_0106: Unknown result type (might be due to invalid IL or missing references)
//IL_010c: Unknown result type (might be due to invalid IL or missing references)
//IL_0111: Unknown result type (might be due to invalid IL or missing references)
if (!Object.op_Implicit((Object)(object)_source) || !Object.op_Implicit((Object)(object)reference))
{
Plugin.Log.LogWarning((object)"Nothing to size the bottle against; models left alone.");
return false;
}
Bounds bounds = reference.bounds;
float num = Longest(((Bounds)(ref bounds)).size);
bounds = _source.bounds;
float num2 = Longest(((Bounds)(ref bounds)).size);
if (num <= 0f || num2 <= 0f)
{
return false;
}
float num3 = num / num2;
Mesh val = Object.Instantiate<Mesh>(_source);
((Object)val).name = "KoskenkorvaBottle";
if (!_source.isReadable)
{
Plugin.Log.LogWarning((object)("'" + ((Object)_source).name + "' is not readable, so it cannot be resized here. It is " + Size(_source) + " against the can's " + Size(reference) + " - either scale the model to match via the importer's Scale Factor, or tick Read/Write Enabled to let this resize it."));
_bottle = _source;
return true;
}
Vector3[] vertices = val.vertices;
for (int i = 0; i < vertices.Length; i++)
{
ref Vector3 reference2 = ref vertices[i];
reference2 *= num3;
}
val.vertices = vertices;
val.RecalculateBounds();
_bottle = val;
return true;
}
private static string Size(Mesh mesh)
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
//IL_0009: Unknown result type (might be due to invalid IL or missing references)
//IL_000e: Unknown result type (might be due to invalid IL or missing references)
//IL_001c: 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)
//IL_0038: Unknown result type (might be due to invalid IL or missing references)
//IL_0046: Unknown result type (might be due to invalid IL or missing references)
Bounds bounds = mesh.bounds;
Vector3 size = ((Bounds)(ref bounds)).size;
return $"{size.x:0.####} x {size.y:0.####} x {size.z:0.####} units (longest {Longest(size):0.####})";
}
private static bool IsOriginal(Mesh mesh)
{
if (Object.op_Implicit((Object)(object)mesh))
{
return OriginalMeshes.Any((string n) => ((Object)mesh).name.IndexOf(n, StringComparison.OrdinalIgnoreCase) >= 0);
}
return false;
}
private static bool Approximately(Vector3 v, Vector3 to)
{
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
//IL_0013: Unknown result type (might be due to invalid IL or missing references)
//IL_0019: Unknown result type (might be due to invalid IL or missing references)
//IL_0026: Unknown result type (might be due to invalid IL or missing references)
//IL_002c: Unknown result type (might be due to invalid IL or missing references)
if (Mathf.Approximately(v.x, to.x) && Mathf.Approximately(v.y, to.y))
{
return Mathf.Approximately(v.z, to.z);
}
return false;
}
private static float Longest(Vector3 size)
{
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
//IL_000c: Unknown result type (might be due to invalid IL or missing references)
return Mathf.Max(size.x, Mathf.Max(size.y, size.z));
}
private static (Mesh, Material) LoadModel()
{
//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
//IL_00df: Unknown result type (might be due to invalid IL or missing references)
//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
//IL_0105: Unknown result type (might be due to invalid IL or missing references)
//IL_0111: Unknown result type (might be due to invalid IL or missing references)
//IL_011d: 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_013f: Unknown result type (might be due to invalid IL or missing references)
//IL_014b: Unknown result type (might be due to invalid IL or missing references)
//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
string text = Path.Combine(Path.GetDirectoryName(typeof(Plugin).Assembly.Location) ?? ".", "koskenkorva.bundle");
if (!File.Exists(text))
{
Plugin.Log.LogWarning((object)"koskenkorva.bundle is missing from the plugin folder.");
return (null, null);
}
try
{
AssetBundle val = AssetBundle.LoadFromFile(text);
if (!Object.op_Implicit((Object)(object)val))
{
Plugin.Log.LogWarning((object)"koskenkorva.bundle could not be opened.");
return (null, null);
}
GameObject[] array = val.LoadAllAssets<GameObject>();
foreach (GameObject val2 in array)
{
MeshFilter val3 = (Object.op_Implicit((Object)(object)val2) ? val2.GetComponentInChildren<MeshFilter>(true) : null);
if (Object.op_Implicit((Object)(object)val3) && Object.op_Implicit((Object)(object)val3.sharedMesh))
{
Vector3 localScale = val2.transform.localScale;
Vector3 localScale2 = ((Component)val3).transform.localScale;
if (!Approximately(localScale, Vector3.one) || !Approximately(localScale2, Vector3.one))
{
Plugin.Log.LogWarning((object)($"The bundled prefab is scaled ({localScale.x:0.###},{localScale.y:0.###},{localScale.z:0.###}) " + $"with the mesh at ({localScale2.x:0.###},{localScale2.y:0.###},{localScale2.z:0.###}). That scale " + "is ignored - set the size on the model importer's Scale Factor instead."));
}
Renderer component = ((Component)val3).GetComponent<Renderer>();
return (val3.sharedMesh, Object.op_Implicit((Object)(object)component) ? component.sharedMaterial : null);
}
}
Mesh val4 = ((IEnumerable<Mesh>)val.LoadAllAssets<Mesh>()).FirstOrDefault((Func<Mesh, bool>)((Mesh m) => Object.op_Implicit((Object)(object)m)));
Material item = ((IEnumerable<Material>)val.LoadAllAssets<Material>()).FirstOrDefault((Func<Material, bool>)((Material m) => Object.op_Implicit((Object)(object)m)));
if (!Object.op_Implicit((Object)(object)val4))
{
Plugin.Log.LogWarning((object)"koskenkorva.bundle holds no mesh.");
}
return (val4, item);
}
catch (Exception ex)
{
Plugin.Log.LogWarning((object)("koskenkorva.bundle failed to load: " + ex.Message));
return (null, null);
}
}
private static void CheckShader(Material material)
{
if (Object.op_Implicit((Object)(object)material) && (!Object.op_Implicit((Object)(object)material.shader) || ((Object)material.shader).name == "Hidden/InternalErrorShader"))
{
Plugin.Log.LogError((object)"The bundle's shader did not load, so the bottle will be magenta. Usual causes: the bundle was built by an editor other than 6000.4.4f1, the shader was not a dependency of the tagged prefab, or its name collides with one already in the game.");
}
}
private static Material CloneMaterialFrom(Item item)
{
//IL_0030: Unknown result type (might be due to invalid IL or missing references)
//IL_0035: Unknown result type (might be due to invalid IL or missing references)
//IL_0041: Expected O, but got Unknown
Renderer val = (Object.op_Implicit((Object)(object)item) ? ((Component)item).GetComponentInChildren<Renderer>(true) : null);
if (!Object.op_Implicit((Object)(object)val) || !Object.op_Implicit((Object)(object)val.sharedMaterial))
{
return null;
}
return new Material(val.sharedMaterial)
{
name = "KoskenkorvaBottle"
};
}
}
[HarmonyPatch(typeof(Bait), "SetBaitInfo")]
internal static class SetBaitInfo_Patch
{
private static void Postfix(Bait __instance)
{
Models.Materialise(__instance._meshFilter);
}
}
[HarmonyPatch(typeof(BaitSlot), "SetBait")]
internal static class SetBait_Patch
{
private static void Postfix(BaitSlot __instance)
{
Models.Materialise(((InventorySlot)__instance)._filter);
}
}
[HarmonyPatch(typeof(QuestInteractable), "SetQuest")]
internal static class SetQuest_Patch
{
private static void Postfix(QuestInteractable __instance)
{
Models.Materialise(__instance._meshToUpdate);
}
}
}
namespace System.Runtime.CompilerServices
{
[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
internal sealed class IgnoresAccessChecksToAttribute : Attribute
{
public IgnoresAccessChecksToAttribute(string assemblyName)
{
}
}
}
