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.Serialization.Formatters.Binary;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using CuriosityPlugin.MonoBehaviours;
using CuriosityPlugin.Patches;
using GameNetcodeStuff;
using HarmonyLib;
using LethalLib.Modules;
using Microsoft.CodeAnalysis;
using Unity.Collections;
using Unity.Netcode;
using UnityEngine;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("CuriosityPlugin")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyDescription("My first plugin")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("CuriosityPlugin")]
[assembly: AssemblyTitle("CuriosityPlugin")]
[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.Module, AllowMultiple = false, Inherited = false)]
internal sealed class RefSafetyRulesAttribute : Attribute
{
public readonly int Version;
public RefSafetyRulesAttribute(int P_0)
{
Version = P_0;
}
}
}
namespace CuriosityPlugin
{
[BepInPlugin("Yakua.CuriosityPlugin", "CuriosityPlugin", "0.1.0")]
public class Plugin : BaseUnityPlugin
{
private const string pluginGUID = "Yakua.CuriosityPlugin";
private const string pluginName = "CuriosityPlugin";
private const string pluginVer = "0.1.0";
private readonly Harmony harmony = new Harmony("Yakua.CuriosityPlugin");
public static ManualLogSource Logger;
public static AssetBundle MainAssets;
public static ContentLoader ContentLoader;
public static Dictionary<string, GameObject> Prefabs = new Dictionary<string, GameObject>();
public static List<Turret> friendlyTurrets;
public static Plugin Instance { get; private set; }
public static PluginConfig MyConfig { get; internal set; }
private void Awake()
{
//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
//IL_00aa: Expected O, but got Unknown
if ((Object)(object)Instance == (Object)null)
{
Instance = this;
}
Logger = Logger.CreateLogSource("Yakua.CuriosityPlugin");
Logger.LogInfo((object)"Main: Plugin Yakua.CuriosityPlugin is loaded!");
MyConfig = new PluginConfig(((BaseUnityPlugin)this).Config);
friendlyTurrets = new List<Turret>();
MainAssets = AssetBundle.LoadFromFile(Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), "curiosityplugin"));
ContentLoader = new ContentLoader(((BaseUnityPlugin)this).Info, MainAssets, (Action<CustomContent, GameObject>)delegate(CustomContent content, GameObject prefab)
{
Prefabs.Add(content.ID, prefab);
});
BeerTankard.Init();
TurretSpawner.Init();
harmony.PatchAll(typeof(Plugin));
harmony.PatchAll(typeof(PluginConfig));
harmony.PatchAll(typeof(TurretSpawner));
harmony.PatchAll(typeof(TurretWhisperer));
}
[HarmonyPatch(typeof(EnemyAI), "KillEnemyServerRpc")]
[HarmonyPostfix]
private static void OnEnemyDeath(EnemyAI __instance)
{
TurretSpawner.SpawnTurretOnDeath(__instance);
}
public void OnDespawnTurret(Vector3 pos)
{
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
NetworkObject component = Object.Instantiate<GameObject>(BeerTankard.tankardPrefab, pos, Quaternion.identity).GetComponent<NetworkObject>();
component.Spawn(false);
((GrabbableObject)((Component)component).GetComponent<BeerTankard>()).itemProperties.creditsWorth = 69;
}
public void SpawnFriendlyTurret(Vector3 pos, Quaternion rot)
{
//IL_00cd: 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_00f2: 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_010f: Unknown result type (might be due to invalid IL or missing references)
//IL_0110: Unknown result type (might be due to invalid IL or missing references)
if (!PluginConfig.imaginaryFriend.Value)
{
return;
}
Logger.LogInfo((object)("Current level is: " + ((Object)RoundManager.Instance.currentLevel).name));
GameObject val = null;
SpawnableMapObject[] spawnableMapObjects = RoundManager.Instance.currentLevel.spawnableMapObjects;
foreach (SpawnableMapObject val2 in spawnableMapObjects)
{
if ((Object)(object)val2.prefabToSpawn.GetComponentInChildren<Turret>() != (Object)null)
{
val = val2.prefabToSpawn;
}
}
if ((Object)(object)val == (Object)null)
{
Logger.LogInfo((object)"Main: No turret found to spawn a friendly turret");
return;
}
Logger.LogInfo((object)"SFT: Found a turret");
ManualLogSource logger = Logger;
Vector3 val3 = pos;
logger.LogInfo((object)("SFT: Pos is: " + ((object)(Vector3)(ref val3)).ToString()));
ManualLogSource logger2 = Logger;
Quaternion val4 = rot;
logger2.LogInfo((object)("SFT: Rot is: " + ((object)(Quaternion)(ref val4)).ToString()));
NetworkObject networkObject = Object.Instantiate<GameObject>(val, pos, rot).GetComponent<NetworkObject>();
Logger.LogInfo((object)("NetObj: " + ((Object)networkObject).name));
friendlyTurrets.Add(((Component)networkObject).GetComponentInChildren<Turret>());
networkObject.Spawn(true);
((MonoBehaviour)networkObject).StartCoroutine(WaitForDespawn());
IEnumerator WaitForDespawn()
{
yield return (object)new WaitForSeconds((float)PluginConfig.despawnTurretTimeInSeconds.Value);
Logger.LogInfo((object)"TS: Turret Should Despawn");
friendlyTurrets.Remove(((Component)networkObject).GetComponentInChildren<Turret>());
networkObject.Despawn(true);
}
}
}
public class PluginConfig : SyncedInstance<PluginConfig>
{
[CompilerGenerated]
private static class <>O
{
public static HandleNamedMessageDelegate <0>__OnRequestSync;
public static HandleNamedMessageDelegate <1>__OnReceiveSync;
}
public static ConfigEntry<bool> triggerShenanigans { get; private set; }
public static ConfigEntry<bool> turretsShenanigans { get; private set; }
public static ConfigEntry<bool> itemShenanigans { get; private set; }
public static ConfigEntry<bool> drinkingHurts { get; private set; }
public static ConfigEntry<bool> imaginaryFriend { get; private set; }
public static ConfigEntry<int> drinkingDamage { get; private set; }
public static ConfigEntry<int> tankardRefills { get; private set; }
public static ConfigEntry<float> tankardDrinkingTime { get; private set; }
public static ConfigEntry<bool> spawnMultipleTurrets { get; private set; }
public static ConfigEntry<bool> allowSpawnTurretsOutdoors { get; private set; }
public static ConfigEntry<int> spawnTurretsChance { get; private set; }
public static ConfigEntry<bool> despawnTurrets { get; private set; }
public static ConfigEntry<int> despawnTurretTimeInSeconds { get; private set; }
public static ConfigEntry<string> bannedCreatures { get; private set; }
public PluginConfig(ConfigFile cfg)
{
InitInstance(this);
triggerShenanigans = cfg.Bind<bool>("General", "Enable Shenanigans?", true, "Whether or not to trigger shenanigans on enemy death");
turretsShenanigans = cfg.Bind<bool>("General", "Turrets Shenanigans", true, "Whether or not to spawn turrets shenanigans");
itemShenanigans = cfg.Bind<bool>("General", "Item Shenanigans", true, "Whether or not to spawn item shenanigans");
drinkingHurts = cfg.Bind<bool>("General.Items", "Drinking Hurts", false, "Does drinking hurt you?");
imaginaryFriend = cfg.Bind<bool>("General.Items", "Imaginary Friend", false, "Does drinking spawn a friendly turret?");
drinkingDamage = ConfigBindClamp("General.Items", "Drinking Damage", 20, "How much does drinking hurt you?", 0, 100);
tankardRefills = ConfigBindClamp("General.Items", "Tankard Refills", 4, "How much can your drink refill until empty?", 0, 100);
tankardDrinkingTime = cfg.Bind<float>("General.Items", "Tankard Drinking Time", 2f, "How fast do you drink?(in seconds)");
allowSpawnTurretsOutdoors = cfg.Bind<bool>("General.Turrets", "AllowSpawnTurretsOutdoors", false, "True to spawn turret outdoors as well. False to spawn only indoors");
spawnMultipleTurrets = cfg.Bind<bool>("General.Turrets", "SpawnMultipleTurrets", false, "True to spawn turret on one player. False to spawn on all players");
spawnTurretsChance = ConfigBindClamp("General.Turrets", "SpawnTurretsChance", 20, "Chance to spawn turret on each individual player(in percents from 1 to 100)", 1, 100);
despawnTurrets = cfg.Bind<bool>("General.Turrets", "DespawnTurrets", true, "Do turrets despawn over time");
despawnTurretTimeInSeconds = ConfigBindClamp("General.Turrets", "DespawnTurretsTimeInSeconds", 120, "Time that takes turrets to despawn", 0, 3600);
bannedCreatures = cfg.Bind<string>("General.Misc", "BannedCreatures", "Manticoil, Red Locust Bees, Docile Locust Bees", "List all creatures that don't trigger shenanigans");
ConfigEntry<int> ConfigBindClamp(string section, string key, int defaultValue, string description, int min, int max)
{
ConfigEntry<int> val = cfg.Bind<int>(section, key, defaultValue, description);
val.Value = Mathf.Clamp(val.Value, min, max);
return val;
}
}
public static void RequestSync()
{
//IL_0029: Unknown result type (might be due to invalid IL or missing references)
if (!SyncedInstance<PluginConfig>.IsClient)
{
return;
}
FastBufferWriter val = default(FastBufferWriter);
((FastBufferWriter)(ref val))..ctor(SyncedInstance<PluginConfig>.IntSize, (Allocator)2, -1);
try
{
SyncedInstance<PluginConfig>.MessageManager.SendNamedMessage("ModName_OnRequestConfigSync", 0uL, val, (NetworkDelivery)3);
}
finally
{
((IDisposable)(FastBufferWriter)(ref val)).Dispose();
}
}
public static void OnRequestSync(ulong clientId, FastBufferReader _)
{
//IL_0053: 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)
//IL_0077: Unknown result type (might be due to invalid IL or missing references)
if (!SyncedInstance<PluginConfig>.IsHost)
{
return;
}
Plugin.Logger.LogInfo((object)$"Config: Config sync request received from client: {clientId}");
byte[] array = SyncedInstance<PluginConfig>.SerializeToBytes(SyncedInstance<PluginConfig>.Instance);
int num = array.Length;
FastBufferWriter val = default(FastBufferWriter);
((FastBufferWriter)(ref val))..ctor(num + SyncedInstance<PluginConfig>.IntSize, (Allocator)2, -1);
try
{
((FastBufferWriter)(ref val)).WriteValueSafe<int>(ref num, default(ForPrimitives));
((FastBufferWriter)(ref val)).WriteBytesSafe(array, -1, 0);
SyncedInstance<PluginConfig>.MessageManager.SendNamedMessage("ModName_OnReceiveConfigSync", clientId, val, (NetworkDelivery)3);
}
catch (Exception arg)
{
Plugin.Logger.LogWarning((object)$"Config: Error occurred syncing config with client: {clientId}\n{arg}");
}
finally
{
((IDisposable)(FastBufferWriter)(ref val)).Dispose();
}
}
public static void OnReceiveSync(ulong _, FastBufferReader reader)
{
//IL_002d: Unknown result type (might be due to invalid IL or missing references)
//IL_0033: Unknown result type (might be due to invalid IL or missing references)
if (!((FastBufferReader)(ref reader)).TryBeginRead(SyncedInstance<PluginConfig>.IntSize))
{
Plugin.Logger.LogError((object)"Config: Config sync error: Could not begin reading buffer.");
return;
}
int num = default(int);
((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref num, default(ForPrimitives));
if (!((FastBufferReader)(ref reader)).TryBeginRead(num))
{
Plugin.Logger.LogError((object)"Config: Config sync error: Host could not sync.");
return;
}
byte[] data = new byte[num];
((FastBufferReader)(ref reader)).ReadBytesSafe(ref data, num, 0);
SyncedInstance<PluginConfig>.SyncInstance(data);
Plugin.Logger.LogInfo((object)"Config: Successfully synced config with host.");
}
[HarmonyPostfix]
[HarmonyPatch(typeof(PlayerControllerB), "ConnectClientToPlayerObject")]
public static void InitializeLocalPlayer()
{
//IL_0060: Unknown result type (might be due to invalid IL or missing references)
//IL_0065: Unknown result type (might be due to invalid IL or missing references)
//IL_006b: Expected O, but got Unknown
//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)
//IL_0030: Expected O, but got Unknown
if (SyncedInstance<PluginConfig>.IsHost)
{
CustomMessagingManager messageManager = SyncedInstance<PluginConfig>.MessageManager;
object obj = <>O.<0>__OnRequestSync;
if (obj == null)
{
HandleNamedMessageDelegate val = OnRequestSync;
<>O.<0>__OnRequestSync = val;
obj = (object)val;
}
messageManager.RegisterNamedMessageHandler("CurYATM_OnRequestConfigSync", (HandleNamedMessageDelegate)obj);
SyncedInstance<PluginConfig>.Synced = true;
return;
}
SyncedInstance<PluginConfig>.Synced = false;
CustomMessagingManager messageManager2 = SyncedInstance<PluginConfig>.MessageManager;
object obj2 = <>O.<1>__OnReceiveSync;
if (obj2 == null)
{
HandleNamedMessageDelegate val2 = OnReceiveSync;
<>O.<1>__OnReceiveSync = val2;
obj2 = (object)val2;
}
messageManager2.RegisterNamedMessageHandler("CurYATM_OnReceiveConfigSync", (HandleNamedMessageDelegate)obj2);
RequestSync();
}
[HarmonyPostfix]
[HarmonyPatch(typeof(GameNetworkManager), "StartDisconnect")]
public static void PlayerLeave()
{
SyncedInstance<PluginConfig>.RevertSync();
}
}
[Serializable]
public class SyncedInstance<T>
{
[NonSerialized]
protected static int IntSize = 4;
internal static CustomMessagingManager MessageManager => NetworkManager.Singleton.CustomMessagingManager;
internal static bool IsClient => NetworkManager.Singleton.IsClient;
internal static bool IsHost => NetworkManager.Singleton.IsHost;
public static T Default { get; private set; }
public static T Instance { get; private set; }
public static bool Synced { get; internal set; }
protected void InitInstance(T instance)
{
Default = instance;
Instance = instance;
IntSize = 4;
}
internal static void SyncInstance(byte[] data)
{
Instance = DeserializeFromBytes(data);
Synced = true;
}
internal static void RevertSync()
{
Instance = Default;
Synced = false;
}
public static byte[] SerializeToBytes(T val)
{
BinaryFormatter binaryFormatter = new BinaryFormatter();
using MemoryStream memoryStream = new MemoryStream();
try
{
binaryFormatter.Serialize(memoryStream, val);
return memoryStream.ToArray();
}
catch (Exception arg)
{
Plugin.Logger.LogError((object)$"Error serializing instance: {arg}");
return null;
}
}
public static T DeserializeFromBytes(byte[] data)
{
BinaryFormatter binaryFormatter = new BinaryFormatter();
using MemoryStream serializationStream = new MemoryStream(data);
try
{
return (T)binaryFormatter.Deserialize(serializationStream);
}
catch (Exception arg)
{
Plugin.Logger.LogError((object)$"Error deserializing instance: {arg}");
return default(T);
}
}
}
public static class PluginInfo
{
public const string PLUGIN_GUID = "CuriosityPlugin";
public const string PLUGIN_NAME = "CuriosityPlugin";
public const string PLUGIN_VERSION = "1.0.0";
}
}
namespace CuriosityPlugin.Patches
{
public class TurretSpawner
{
public static Random turretSpawnRandom;
private static List<NetworkObject> spawnedTurrets;
private static ulong currentEnemy = 9999999uL;
public static void Init()
{
spawnedTurrets = new List<NetworkObject>();
}
[HarmonyPatch(typeof(RoundManager), "GenerateNewLevelClientRpc")]
[HarmonyPostfix]
private static void updateCurrentTurretSeed(int randomSeed)
{
turretSpawnRandom = new Random(randomSeed + 24);
Plugin.Logger.LogInfo((object)$"TS: Generated a seed for turrets: {randomSeed + 24}");
}
public static void SpawnTurretOnDeath(EnemyAI instance)
{
Plugin.Logger.LogInfo((object)("TS: Got into Initial Spawn Method called from " + instance.enemyType.enemyName + "."));
if (!PluginConfig.turretsShenanigans.Value || currentEnemy == ((NetworkBehaviour)instance).NetworkObject.NetworkObjectId || !((NetworkBehaviour)instance).IsHost)
{
return;
}
string[] array = PluginConfig.bannedCreatures.Value.Split(',');
string[] array2 = array;
foreach (string text in array2)
{
if (instance.enemyType.enemyName == text)
{
return;
}
}
currentEnemy = ((NetworkBehaviour)instance).NetworkObject.NetworkObjectId;
GameObject val = null;
PlayerControllerB[] allPlayerScripts = StartOfRound.Instance.allPlayerScripts;
PlayerControllerB[] array3 = allPlayerScripts.Where((PlayerControllerB p) => p.isPlayerControlled && !p.isPlayerDead && (p.isInsideFactory | PluginConfig.allowSpawnTurretsOutdoors.Value)).ToArray();
Plugin.Logger.LogInfo((object)$"TS: {instance.enemyType.enemyName} has died. Trying to spawn turret on ({array3.Length}) suitable players.");
SpawnableMapObject[] spawnableMapObjects = RoundManager.Instance.currentLevel.spawnableMapObjects;
foreach (SpawnableMapObject val2 in spawnableMapObjects)
{
if ((Object)(object)val2.prefabToSpawn.GetComponentInChildren<Turret>() != (Object)null)
{
val = val2.prefabToSpawn;
}
}
if ((Object)(object)val == (Object)null)
{
Plugin.Logger.LogInfo((object)"TS: No turret found");
}
else
{
SpawnTurrets(val, array3);
}
}
private static void SpawnTurrets(GameObject tur, PlayerControllerB[] suitablePlayers)
{
if ((Object)(object)tur == (Object)null || suitablePlayers.Length == 0)
{
Plugin.Logger.LogInfo((object)"TS: No turret or player found to spawn a hostile turret");
return;
}
if (!PluginConfig.spawnMultipleTurrets.Value)
{
Spawn(suitablePlayers[turretSpawnRandom.Next(0, suitablePlayers.Length)]);
return;
}
foreach (PlayerControllerB player2 in suitablePlayers)
{
Spawn(player2);
}
GameObject Spawn(PlayerControllerB player)
{
//IL_0086: 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)
int num = turretSpawnRandom.Next(1, 101);
bool flag = ((num <= PluginConfig.spawnTurretsChance.Value) ? true : false);
Plugin.Logger.LogInfo((object)$"TS: Rolled: {num} out of {PluginConfig.spawnTurretsChance.Value}. Target: {player.playerUsername}");
NetworkObject networkObject;
if (flag && (Object)(object)tur != (Object)null)
{
networkObject = null;
try
{
networkObject = Object.Instantiate<GameObject>(tur, ((Component)player).transform.position, Quaternion.identity).GetComponent<NetworkObject>();
networkObject.Spawn(true);
spawnedTurrets.Add(networkObject);
if (PluginConfig.despawnTurrets.Value)
{
((MonoBehaviour)networkObject).StartCoroutine(WaitForDespawn());
}
}
catch (Exception arg)
{
Plugin.Logger.LogWarning((object)$"Exception: {arg}");
}
return ((Component)networkObject).gameObject;
}
if ((Object)(object)tur == (Object)null)
{
Plugin.Logger.LogInfo((object)"TS: No turret object found for this map to spawn a hostile turret");
}
return null;
IEnumerator WaitForDespawn()
{
yield return (object)new WaitForSeconds((float)PluginConfig.despawnTurretTimeInSeconds.Value);
Plugin.Logger.LogInfo((object)"TS: Turret Should Despawn");
Plugin.Instance.OnDespawnTurret(((Component)networkObject).transform.position);
Despawn(networkObject);
}
}
}
public static void Despawn(NetworkObject networkObject)
{
spawnedTurrets.Remove(networkObject);
networkObject.Despawn(true);
}
[HarmonyPatch(typeof(StartOfRound), "ShipLeave")]
[HarmonyPrefix]
private static void DeleteTurretsOnShipLeave()
{
if (spawnedTurrets == null)
{
return;
}
foreach (NetworkObject spawnedTurret in spawnedTurrets)
{
if ((Object)(object)spawnedTurret != (Object)null)
{
spawnedTurret.Despawn(true);
}
}
spawnedTurrets = null;
}
}
[HarmonyPatch(typeof(Turret))]
internal class TurretWhisperer
{
public static float viewRadius = 20f;
public static float viewAngle = 180f;
public static float missChance = 0.97f;
[HarmonyPatch("Update")]
[HarmonyPrefix]
public static void PatchUpdateBefore(ref Turret __instance)
{
//IL_0034: Unknown result type (might be due to invalid IL or missing references)
//IL_0039: Unknown result type (might be due to invalid IL or missing references)
//IL_003a: Unknown result type (might be due to invalid IL or missing references)
//IL_003b: Unknown result type (might be due to invalid IL or missing references)
//IL_003c: Unknown result type (might be due to invalid IL or missing references)
//IL_003d: Unknown result type (might be due to invalid IL or missing references)
//IL_003e: Unknown result type (might be due to invalid IL or missing references)
//IL_0066: Unknown result type (might be due to invalid IL or missing references)
//IL_0043: Unknown result type (might be due to invalid IL or missing references)
//IL_0045: Invalid comparison between Unknown and I4
//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
//IL_00b4: Invalid comparison between Unknown and I4
//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
//IL_00be: Invalid comparison between Unknown and I4
//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
//IL_00c8: Invalid comparison between Unknown and I4
//IL_0130: Unknown result type (might be due to invalid IL or missing references)
//IL_0132: Invalid comparison between Unknown and I4
//IL_0147: Unknown result type (might be due to invalid IL or missing references)
//IL_0134: Unknown result type (might be due to invalid IL or missing references)
//IL_0136: Invalid comparison between Unknown and I4
if (!Plugin.friendlyTurrets.Contains(__instance))
{
return;
}
TurretMode val = (TurretMode)AccessTools.Field(typeof(Turret), "turretModeLastFrame").GetValue(__instance);
TurretMode val2 = val;
TurretMode val3 = val2;
if ((int)val3 != 0)
{
if ((int)val3 == 1 && (Object)(object)CheckForEnemiesInLOS(__instance, 3f, angleRangeCheck: true) != (Object)null)
{
__instance.turretMode = (TurretMode)2;
}
}
else if ((Object)(object)CheckForEnemiesInLOS(__instance, 3f, angleRangeCheck: true) != (Object)null)
{
__instance.turretMode = (TurretMode)1;
SetFieldBase(__instance, "turretInterval", 0f);
}
if ((int)__instance.turretMode == 1 || (int)__instance.turretMode == 2 || (int)__instance.turretMode == 3)
{
EnemyAI val4 = CheckForEnemiesInLOS(__instance, 3f, angleRangeCheck: true);
if ((Object)(object)val4 != (Object)null)
{
__instance.targetTransform = ((Component)val4).transform;
}
else
{
__instance.targetTransform = null;
}
if ((float)GetFieldBase(__instance, "turretInterval") > 0.1f && !TargetEnemy(__instance, val4) && ((int)val == 2 || (int)val == 3))
{
__instance.turretMode = (TurretMode)0;
}
}
}
[HarmonyPatch("TurnTowardsTargetIfHasLOS")]
[HarmonyPrefix]
public static void PatchTurnTowardsTargetIfHasLOS(ref Turret __instance)
{
//IL_0022: Unknown result type (might be due to invalid IL or missing references)
//IL_002e: 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_009d: Unknown result type (might be due to invalid IL or missing references)
//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
if (!Plugin.friendlyTurrets.Contains(__instance))
{
return;
}
bool flag = true;
if (Physics.Linecast(__instance.aimPoint.position, __instance.targetTransform.position, StartOfRound.Instance.collidersAndRoomMask, (QueryTriggerInteraction)1))
{
flag = false;
}
if (flag)
{
SetFieldBase(__instance, "hasLineOfSight", true);
SetFieldBase(__instance, "lostLOSTimer", 0f);
__instance.tempTransform.position = __instance.targetTransform.position;
Transform tempTransform = __instance.tempTransform;
tempTransform.position -= Vector3.up * 0.15f;
__instance.turnTowardsObjectCompass.LookAt(__instance.tempTransform);
return;
}
if ((bool)GetFieldBase(__instance, "hasLineOfSight"))
{
SetFieldBase(__instance, "hasLineOfSight", false);
SetFieldBase(__instance, "lostLOSTimer", 0f);
}
SetFieldBase(__instance, "lostLOSTimer", (float)GetFieldBase(__instance, "lostLOSTimer") + Time.deltaTime);
if (!((double)GetFieldBase(__instance, "lostLOSTimer") < 2.0))
{
SetFieldBase(__instance, "lostLOSTimer", 0f);
Debug.Log((object)"Turret: LOS timer ended on server. checking for new player target");
EnemyAI val = CheckForEnemiesInLOS(__instance);
if ((Object)(object)val != (Object)null)
{
Debug.Log((object)"Turret: Got new enemy target");
}
else
{
Debug.Log((object)"Turret: No new player to target; returning to detection mode.");
}
}
}
public static bool TargetEnemy(Turret turret, EnemyAI visibleEnemy)
{
//IL_0049: Unknown result type (might be due to invalid IL or missing references)
//IL_004f: Unknown result type (might be due to invalid IL or missing references)
bool result = false;
if ((Object)(object)visibleEnemy != (Object)null)
{
if ((double)Random.Range(0f, 1f) > (double)missChance)
{
SetFieldBase(turret, "turretInterval", 0f);
visibleEnemy.HitEnemyOnLocalClient(3, default(Vector3), (PlayerControllerB)null, false, -1);
Plugin.Logger.LogInfo((object)("TW: " + (visibleEnemy.enemyType.enemyName + " was hit by a friendly turret.")));
result = true;
}
else
{
result = false;
}
}
return result;
}
public static EnemyAI CheckForEnemiesInLOS(Turret instance, float radius = 2f, bool angleRangeCheck = false)
{
//IL_000c: Unknown result type (might be due to invalid IL or missing references)
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
//IL_0016: Unknown result type (might be due to invalid IL or missing references)
//IL_0036: Unknown result type (might be due to invalid IL or missing references)
//IL_003b: Unknown result type (might be due to invalid IL or missing references)
//IL_003c: Unknown result type (might be due to invalid IL or missing references)
//IL_0041: 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_006a: Unknown result type (might be due to invalid IL or missing references)
//IL_0085: Unknown result type (might be due to invalid IL or missing references)
//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
//IL_0285: Unknown result type (might be due to invalid IL or missing references)
//IL_028a: Unknown result type (might be due to invalid IL or missing references)
//IL_028b: Unknown result type (might be due to invalid IL or missing references)
//IL_0290: 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_0142: Unknown result type (might be due to invalid IL or missing references)
//IL_0147: Unknown result type (might be due to invalid IL or missing references)
//IL_0151: Unknown result type (might be due to invalid IL or missing references)
//IL_0156: Unknown result type (might be due to invalid IL or missing references)
//IL_0161: Unknown result type (might be due to invalid IL or missing references)
//IL_0166: 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)
//IL_01f0: Unknown result type (might be due to invalid IL or missing references)
//IL_01f5: Unknown result type (might be due to invalid IL or missing references)
//IL_01ff: Unknown result type (might be due to invalid IL or missing references)
//IL_0204: Unknown result type (might be due to invalid IL or missing references)
//IL_020f: Unknown result type (might be due to invalid IL or missing references)
//IL_0214: Unknown result type (might be due to invalid IL or missing references)
//IL_021f: Unknown result type (might be due to invalid IL or missing references)
Vector3 forward = ((Transform)GetFieldBase(instance, "aimPoint")).forward;
Vector3 val = Quaternion.Euler(0f, (float)(int)(0f - (float)GetFieldBase(instance, "rotationRange")) / radius, 0f) * forward;
float num = (float)((double)instance.rotationRange / (double)radius * 2.0);
SetFieldBase(instance, "shootRay", (object)new Ray(instance.centerPoint.position, val));
RaycastHit[] array = Physics.RaycastAll((Ray)GetFieldBase(instance, "shootRay"), 30f);
if (array.Length == 0)
{
return null;
}
RaycastHit[] array2 = array;
EnemyAICollisionDetect val3 = default(EnemyAICollisionDetect);
EnemyAI val4 = default(EnemyAI);
for (int i = 0; i < array2.Length; i++)
{
RaycastHit val2 = array2[i];
if (((Component)((RaycastHit)(ref val2)).transform).CompareTag("Enemy"))
{
SetFieldBase(instance, "hit", val2);
if (((Component)((RaycastHit)(ref val2)).transform).TryGetComponent<EnemyAICollisionDetect>(ref val3))
{
Plugin.Logger.LogWarning((object)("TW: Acquired enemy component from " + ((Object)((RaycastHit)(ref val2)).collider).name));
if (!((Object)(object)val3 == (Object)null))
{
return (angleRangeCheck && (double)Vector3.Angle(((Component)val3).transform.position + Vector3.up * 1.75f - instance.centerPoint.position, instance.forwardFacingPos.forward) > (double)instance.rotationRange) ? null : val3.mainScript;
}
}
else if (((Component)((RaycastHit)(ref val2)).transform).TryGetComponent<EnemyAI>(ref val4))
{
Plugin.Logger.LogWarning((object)("TW: Acquired enemy component from " + ((Object)((RaycastHit)(ref val2)).collider).name));
if (!((Object)(object)val4 == (Object)null))
{
return (angleRangeCheck && (double)Vector3.Angle(((Component)val4).transform.position + Vector3.up * 1.75f - instance.centerPoint.position, instance.forwardFacingPos.forward) > (double)instance.rotationRange) ? null : val4;
}
}
else
{
Plugin.Logger.LogWarning((object)"TW: Doesn't have the EnemyAI or EnemyAICollisionDetect component.");
Plugin.Logger.LogWarning((object)("TW: Hit Name: " + ((Object)((RaycastHit)(ref val2)).collider).name));
}
}
else
{
val = Quaternion.Euler(0f, num / 6f, 0f) * val;
}
}
return null;
}
private static object GetFieldBase(Turret turret, string fieldName)
{
return AccessTools.Field(typeof(Turret), fieldName).GetValue(turret);
}
private static void SetFieldBase(Turret turret, string fieldName, object fieldValue)
{
AccessTools.Field(typeof(Turret), fieldName).SetValue(turret, fieldValue);
}
[HarmonyPatch("CheckForPlayersInLineOfSight")]
[HarmonyPostfix]
public static void PatchCheckForPlayersInLineOfSight(ref Turret __instance, ref PlayerControllerB __result)
{
if (Plugin.friendlyTurrets.Contains(__instance))
{
__result = null;
}
}
}
}
namespace CuriosityPlugin.MonoBehaviours
{
internal class BeerTankard : PhysicsProp
{
private static int DamageNumber = 100;
private static float TimeToEmpty = 2f;
private static int MaxRefills = 4;
public static GameObject tankardPrefab;
private PlayerControllerB previousPlayerHeldBy;
private Coroutine useTankardCoroutine;
public AudioSource audioSource;
public AudioClip interactionSound;
public AudioClip interactionEndSound;
public AudioClip interactionEmptySound;
public AudioClip interactionDeathSound;
private bool runningOut;
private float fuel = 1f;
private int charges;
public static void Init()
{
Item val = Plugin.MainAssets.LoadAsset<Item>("Assets/BeerItem/BeerTankard.asset");
tankardPrefab = val.spawnPrefab;
BeerTankard beerTankard = tankardPrefab.AddComponent<BeerTankard>();
beerTankard.interactionSound = Plugin.MainAssets.LoadAsset<AudioClip>("Assets/BeerItem/BeerInteraction.mp3");
beerTankard.interactionEndSound = Plugin.MainAssets.LoadAsset<AudioClip>("Assets/BeerItem/BeerClarity.mp3");
beerTankard.interactionEmptySound = Plugin.MainAssets.LoadAsset<AudioClip>("Assets/BeerItem/BeerEmpty.mp3");
beerTankard.interactionDeathSound = Plugin.MainAssets.LoadAsset<AudioClip>("Assets/BeerItem/BeerDeath.mp3");
((GrabbableObject)beerTankard).grabbable = true;
((GrabbableObject)beerTankard).grabbableToEnemies = true;
((GrabbableObject)beerTankard).itemProperties = val;
DamageNumber = PluginConfig.drinkingDamage.Value;
TimeToEmpty = PluginConfig.tankardDrinkingTime.Value;
MaxRefills = PluginConfig.tankardRefills.Value;
NetworkPrefabs.RegisterNetworkPrefab(val.spawnPrefab);
Utilities.FixMixerGroups(val.spawnPrefab);
Items.RegisterItem(val);
}
public void Awake()
{
audioSource = ((Component)this).GetComponent<AudioSource>();
charges = MaxRefills;
}
public override void Update()
{
//IL_0203: Unknown result type (might be due to invalid IL or missing references)
//IL_0209: Unknown result type (might be due to invalid IL or missing references)
//IL_0165: Unknown result type (might be due to invalid IL or missing references)
//IL_0175: Unknown result type (might be due to invalid IL or missing references)
//IL_0139: 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)
if (runningOut)
{
if ((Object)(object)previousPlayerHeldBy == (Object)null || !((GrabbableObject)this).isHeld || (double)fuel <= 0.0)
{
RunOutOfFuelServerRpc();
}
previousPlayerHeldBy.drunknessInertia = Mathf.Clamp(previousPlayerHeldBy.drunknessInertia + Time.deltaTime / 1.75f * (22f / (TimeToEmpty * (float)MaxRefills)) * previousPlayerHeldBy.drunknessSpeed, 0.1f, 3f);
previousPlayerHeldBy.increasingDrunknessThisFrame = true;
if ((double)fuel <= 0.0)
{
if (charges <= 0)
{
Plugin.Logger.LogInfo((object)"KILL");
if (((NetworkBehaviour)this).IsOwner)
{
((GrabbableObject)this).playerHeldBy.playerBodyAnimator.SetBool("useTZPItem", false);
((GrabbableObject)this).playerHeldBy.activatingItem = false;
if (PluginConfig.drinkingHurts.Value)
{
((GrabbableObject)this).playerHeldBy.DamagePlayer(DamageNumber, true, true, (CauseOfDeath)0, 1, false, default(Vector3));
}
}
if (((NetworkBehaviour)this).IsHost)
{
Plugin.Instance.SpawnFriendlyTurret(((Component)((GrabbableObject)this).playerHeldBy).transform.position, ((Component)((GrabbableObject)this).playerHeldBy).transform.rotation);
}
audioSource.PlayOneShot(interactionDeathSound);
WalkieTalkie.TransmitOneShotAudio(audioSource, interactionDeathSound, 1f);
}
else
{
Plugin.Logger.LogInfo((object)"Clarity moment");
if (((NetworkBehaviour)this).IsOwner)
{
((GrabbableObject)this).playerHeldBy.playerBodyAnimator.SetBool("useTZPItem", false);
((GrabbableObject)this).playerHeldBy.activatingItem = false;
((GrabbableObject)this).playerHeldBy.DamagePlayer(DamageNumber, true, true, (CauseOfDeath)0, 1, false, default(Vector3));
}
audioSource.PlayOneShot(interactionEndSound);
WalkieTalkie.TransmitOneShotAudio(audioSource, interactionEndSound, 1f);
}
if (charges > 0)
{
charges--;
fuel = 1f;
}
else
{
((GrabbableObject)this).itemProperties.creditsWorth = 10;
}
}
else
{
fuel -= Time.deltaTime / TimeToEmpty;
}
}
((GrabbableObject)this).Update();
}
public override void ItemActivate(bool used, bool buttonDown = true)
{
((GrabbableObject)this).ItemActivate(used, buttonDown);
if (!((GrabbableObject)this).isBeingUsed)
{
((GrabbableObject)this).isBeingUsed = true;
if ((double)fuel <= 0.0)
{
((GrabbableObject)this).isBeingUsed = false;
audioSource.PlayOneShot(interactionEmptySound);
WalkieTalkie.TransmitOneShotAudio(audioSource, interactionEmptySound, 1f);
previousPlayerHeldBy.playerBodyAnimator.SetTrigger("shakeItem");
}
else
{
previousPlayerHeldBy = ((GrabbableObject)this).playerHeldBy;
audioSource.PlayOneShot(interactionSound);
WalkieTalkie.TransmitOneShotAudio(audioSource, interactionSound, 1f);
runningOut = true;
useTankardCoroutine = ((MonoBehaviour)this).StartCoroutine(TankardAnimation());
}
}
}
public override void EquipItem()
{
((PhysicsProp)this).EquipItem();
StartOfRound.Instance.RefreshPlayerVoicePlaybackObjects();
if ((Object)(object)((GrabbableObject)this).playerHeldBy != (Object)null)
{
previousPlayerHeldBy = ((GrabbableObject)this).playerHeldBy;
}
}
[ServerRpc]
public void RunOutOfFuelServerRpc()
{
RunOutOfFuelClientRpc();
}
[ClientRpc]
public void RunOutOfFuelClientRpc()
{
previousPlayerHeldBy.playerBodyAnimator.SetBool("useTZPItem", false);
((MonoBehaviour)this).StopCoroutine(useTankardCoroutine);
previousPlayerHeldBy.activatingItem = false;
((GrabbableObject)this).itemUsedUp = true;
((GrabbableObject)this).isBeingUsed = false;
runningOut = false;
fuel = 0f;
}
public override void DiscardItem()
{
runningOut = false;
((GrabbableObject)this).playerHeldBy.playerBodyAnimator.ResetTrigger("shakeItem");
previousPlayerHeldBy.playerBodyAnimator.SetBool("useTZPItem", false);
if ((Object)(object)previousPlayerHeldBy != (Object)null)
{
previousPlayerHeldBy.activatingItem = false;
}
((GrabbableObject)this).DiscardItem();
}
public IEnumerator TankardAnimation()
{
((GrabbableObject)this).playerHeldBy.activatingItem = true;
((GrabbableObject)this).playerHeldBy.playerBodyAnimator.SetBool("useTZPItem", true);
yield return (object)new WaitForSeconds(0.75f);
HUDManager.Instance.gasHelmetAnimator.SetBool("gasEmitting", true);
}
}
}
