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.Configuration;
using BepInEx.Logging;
using FishNet.Object;
using HarmonyLib;
using TMPro;
using UnityEngine;
using UnityEngine.UI;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: AssemblyCompany("FishPerksMod")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("FishPerksMod")]
[assembly: AssemblyTitle("FishPerksMod")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
namespace FishPerksMod
{
public class FishPerkDefinition
{
public FishPerkType Type;
public string Name;
}
public static class FishPerkDatabase
{
public static readonly Dictionary<FishPerkType, FishPerkDefinition> Definitions = new Dictionary<FishPerkType, FishPerkDefinition>
{
{
FishPerkType.StoppingPower,
new FishPerkDefinition
{
Type = FishPerkType.StoppingPower,
Name = "Stopping Power"
}
},
{
FishPerkType.Juggernaut,
new FishPerkDefinition
{
Type = FishPerkType.Juggernaut,
Name = "Juggernaut"
}
},
{
FishPerkType.SpeedCola,
new FishPerkDefinition
{
Type = FishPerkType.SpeedCola,
Name = "Speed Cola"
}
},
{
FishPerkType.DoubleTap,
new FishPerkDefinition
{
Type = FishPerkType.DoubleTap,
Name = "Double Tap"
}
},
{
FishPerkType.FizzyYummy,
new FishPerkDefinition
{
Type = FishPerkType.FizzyYummy,
Name = "Fizzy Yummy"
}
},
{
FishPerkType.QuickFix,
new FishPerkDefinition
{
Type = FishPerkType.QuickFix,
Name = "Quick Fix"
}
},
{
FishPerkType.Hardline,
new FishPerkDefinition
{
Type = FishPerkType.Hardline,
Name = "Hardline"
}
},
{
FishPerkType.QuickRevive,
new FishPerkDefinition
{
Type = FishPerkType.QuickRevive,
Name = "Quick Revive"
}
}
};
}
public static class FishPerkManager
{
public const float StoppingPowerDamageMulti = 1.55f;
public const float JuggernautDamageTakenMulti = 0.1f;
public const float SpeedColaReloadMulti = 1.4f;
public const float DoubleTapFireRateMulti = 1.4f;
public const float FizzyYummySpeedMulti = 1.3f;
public const int QuickFixRestorePercent = 5;
public const float HardlineMultiplier = 1.35f;
public const float BuffDurationSeconds = 120f;
public static bool VerboseLogging = true;
private static readonly Dictionary<Creature, FishPerkType> _sessionPerkCache = new Dictionary<Creature, FishPerkType>();
private static readonly List<FishPerkType> _perkBag = new List<FishPerkType>();
private static int _perkBagCycle;
private static readonly Dictionary<Player, (FishPerkType perk, float expireTime)> _activeBuffs = new Dictionary<Player, (FishPerkType, float)>();
private static readonly Dictionary<Player, float> _quickFixNextTick = new Dictionary<Player, float>();
public static ulong CurrentlyLoadingSteamId;
public static SavedPlayer CurrentlyLoadingSavedPlayer;
internal static void Announce(string message)
{
if ((Object)(object)Server.Instance != (Object)null && ((NetworkBehaviour)Server.Instance).IsServerInitialized)
{
ChatManager.ChatMessage("<i>" + message + "</i>");
}
}
public static void ClearSession()
{
_sessionPerkCache.Clear();
_perkBag.Clear();
_perkBagCycle = 0;
_activeBuffs.Clear();
_quickFixNextTick.Clear();
}
public static FishPerkType GetOrAssignPerk(Creature creature)
{
if ((Object)(object)creature == (Object)null)
{
return FishPerkType.StoppingPower;
}
if (_sessionPerkCache.TryGetValue(creature, out var value))
{
return value;
}
FishPerkType fishPerkType = TakeNextPerkFromBag();
_sessionPerkCache[creature] = fishPerkType;
if (VerboseLogging)
{
Plugin.Log.LogInfo((object)$"[FishPerksMod] Assigned perk '{fishPerkType}' to '{SafeGetName(creature)}' (shuffled bag).");
}
return fishPerkType;
}
public static void AssignSpecificPerk(Creature creature, FishPerkType perk)
{
if (!((Object)(object)creature == (Object)null))
{
_sessionPerkCache[creature] = perk;
if (VerboseLogging)
{
Plugin.Log.LogInfo((object)$"[FishPerksMod] Restored persisted perk '{perk}' on '{SafeGetName(creature)}'.");
}
}
}
private static int GetStableSeed(Creature creature)
{
//IL_0041: 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)
//IL_004b: 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_007d: Unknown result type (might be due to invalid IL or missing references)
try
{
int num = ((NetworkBehaviour)creature).ObjectId;
string text = SafeGetName(creature);
string text2 = text;
foreach (char c in text2)
{
num = num * 31 + c;
}
Vector3 position = ((Component)creature).transform.position;
num = num * 31 + ((int)(position.x * 1000f) & 0xFFFF);
num = num * 31 + ((int)(position.y * 1000f) & 0xFFFF);
return num * 31 + ((int)(position.z * 1000f) & 0xFFFF);
}
catch (Exception ex)
{
Plugin.Log.LogWarning((object)("[FishPerksMod] Could not generate stable seed - falling back to GetInstanceID(). The assigned perk may NOT match across clients! (" + ex.Message + ")"));
return ((Object)creature).GetInstanceID();
}
}
private static FishPerkType TakeNextPerkFromBag()
{
FishPerkType[] array = (FishPerkType[])Enum.GetValues(typeof(FishPerkType));
if (array.Length == 0)
{
return FishPerkType.StoppingPower;
}
if (_perkBag.Count == 0)
{
_perkBag.AddRange(array);
Random random = new Random(1179210568 + _perkBagCycle);
for (int num = _perkBag.Count - 1; num > 0; num--)
{
int index = random.Next(num + 1);
FishPerkType value = _perkBag[num];
_perkBag[num] = _perkBag[index];
_perkBag[index] = value;
}
_perkBagCycle++;
}
int index2 = _perkBag.Count - 1;
FishPerkType result = _perkBag[index2];
_perkBag.RemoveAt(index2);
return result;
}
private static string SafeGetName(Creature c)
{
try
{
return ((Item)c).GetName();
}
catch
{
return ((Object)c).name;
}
}
public static string GetDisplayName(FishPerkType perk)
{
FishPerkDefinition value;
return FishPerkDatabase.Definitions.TryGetValue(perk, out value) ? value.Name : perk.ToString();
}
public static string GetDescription(FishPerkType perk)
{
return perk switch
{
FishPerkType.StoppingPower => $"Increases bullet damage by {54.999996f:0}%.",
FishPerkType.Juggernaut => $"Reduces incoming damage by {90f:0}%.",
FishPerkType.SpeedCola => $"Increases reload speed by {39.999996f:0}%.",
FishPerkType.DoubleTap => $"Increases fire rate by {39.999996f:0}%.",
FishPerkType.FizzyYummy => $"Increases movement speed by {29.999996f:0}%.",
FishPerkType.QuickFix => $"Restores {5}% of health and hunger every second.",
FishPerkType.Hardline => $"Increases all trickshot score multipliers by {35.000004f:0}%.",
FishPerkType.QuickRevive => "Revives you during a boss fight while another player is still alive.",
_ => string.Empty,
};
}
public static void ApplyBuff(Player player, FishPerkType perk, float? durationOverrideSeconds = null)
{
if (!((Object)(object)player == (Object)null))
{
float num = durationOverrideSeconds ?? 120f;
_activeBuffs[player] = (perk, Time.time + num);
if (perk == FishPerkType.QuickFix)
{
_quickFixNextTick[player] = Time.time + 1f;
}
if (VerboseLogging)
{
Plugin.Log.LogInfo((object)$"[FishPerksMod] Applied buff '{perk}' to '{SafePlayerName(player)}' for {num:0}s.");
}
}
}
public static bool TryGetActiveBuff(Player player, out FishPerkType perk)
{
perk = FishPerkType.StoppingPower;
if ((Object)(object)player == (Object)null)
{
return false;
}
if (!_activeBuffs.TryGetValue(player, out (FishPerkType, float) value))
{
return false;
}
if (Time.time >= value.Item2)
{
_activeBuffs.Remove(player);
_quickFixNextTick.Remove(player);
Announce("<b>" + SafePlayerName(player) + "</b>'s <b>" + GetDisplayName(value.Item1) + "</b> effect has expired.");
if (VerboseLogging)
{
Plugin.Log.LogInfo((object)$"[FishPerksMod] Buff '{value.Item1}' expired for '{SafePlayerName(player)}'.");
}
return false;
}
(perk, _) = value;
return true;
}
public static bool HasActivePerk(Player player, FishPerkType perk)
{
FishPerkType perk2;
return TryGetActiveBuff(player, out perk2) && perk2 == perk;
}
public static float GetRemainingBuffTime(Player player)
{
if ((Object)(object)player == (Object)null || !_activeBuffs.TryGetValue(player, out (FishPerkType, float) value))
{
return 0f;
}
return Mathf.Max(0f, value.Item2 - Time.time);
}
public static void UpdatePeriodicEffects()
{
foreach (KeyValuePair<Player, (FishPerkType, float)> item in new List<KeyValuePair<Player, (FishPerkType, float)>>(_activeBuffs))
{
if (TryGetActiveBuff(item.Key, out var perk) && perk == FishPerkType.QuickFix && !item.Key.Dying.IsDead && (!_quickFixNextTick.TryGetValue(item.Key, out var value) || Time.time >= value))
{
item.Key.Vitals.Heal(5);
item.Key.Vitals.RestoreFullness(5);
_quickFixNextTick[item.Key] = Time.time + 1f;
}
}
}
private static string SafePlayerName(Player p)
{
try
{
return p.SteamName;
}
catch
{
return ((Object)p).name;
}
}
}
public enum FishPerkType
{
StoppingPower,
Juggernaut,
SpeedCola,
DoubleTap,
FizzyYummy,
QuickFix,
Hardline,
QuickRevive
}
internal sealed class PerkHud : MonoBehaviour
{
private TextMeshProUGUI _text;
public static void Create()
{
//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
//IL_00de: Unknown result type (might be due to invalid IL or missing references)
//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
//IL_010a: Unknown result type (might be due to invalid IL or missing references)
//IL_0120: Unknown result type (might be due to invalid IL or missing references)
if (!((Object)(object)PlayerUI.CanvasTextPrefab == (Object)null) && !((Object)(object)PlayerUI.FXCanvasTrans == (Object)null))
{
Transform val = PlayerUI.FXCanvasTrans.Find("FishPerksActivePerk");
if (!((Object)(object)val != (Object)null))
{
TextMeshProUGUI val2 = Object.Instantiate<TextMeshProUGUI>(PlayerUI.CanvasTextPrefab, PlayerUI.FXCanvasTrans);
((Object)val2).name = "FishPerksActivePerk";
((Graphic)val2).raycastTarget = false;
((TMP_Text)val2).alignment = (TextAlignmentOptions)257;
((TMP_Text)val2).enableWordWrapping = false;
((TMP_Text)val2).fontSize = ((TMP_Text)val2).fontSize * 0.72f;
((Graphic)val2).color = Color32.op_Implicit(new Color32(byte.MaxValue, (byte)220, (byte)120, byte.MaxValue));
RectTransform rectTransform = ((TMP_Text)val2).rectTransform;
rectTransform.anchorMin = new Vector2(0f, 1f);
rectTransform.anchorMax = new Vector2(0f, 1f);
rectTransform.pivot = new Vector2(0f, 1f);
rectTransform.anchoredPosition = new Vector2(20f, -20f);
rectTransform.sizeDelta = new Vector2(320f, 32f);
PerkHud perkHud = ((Component)val2).gameObject.AddComponent<PerkHud>();
perkHud._text = val2;
perkHud.UpdateText();
}
}
}
private void Update()
{
UpdateText();
}
private void UpdateText()
{
Player localPlayer = Player.LocalPlayer;
if (Plugin.HudEnabled == null || !Plugin.HudEnabled.Value || (Object)(object)localPlayer == (Object)null || !FishPerkManager.TryGetActiveBuff(localPlayer, out var perk))
{
((Behaviour)_text).enabled = false;
return;
}
((Behaviour)_text).enabled = true;
((TMP_Text)_text).text = $"<b>{FishPerkManager.GetDisplayName(perk)}</b> <color=#FFFFFF>{FishPerkManager.GetRemainingBuffTime(localPlayer):0}s</color>";
}
}
[HarmonyPatch(typeof(PlayerUI), "InitializeLocal")]
internal static class PerkHudInitializationPatch
{
[HarmonyPostfix]
private static void Postfix()
{
PerkHud.Create();
}
}
internal static class PersistenceStore
{
[Serializable]
private class Entry
{
public ulong SteamId;
public byte Slot;
public string Perk;
}
[Serializable]
private class SaveFile
{
public List<Entry> Entries = new List<Entry>();
}
private static readonly Dictionary<ulong, Dictionary<byte, FishPerkType>> _data = new Dictionary<ulong, Dictionary<byte, FishPerkType>>();
private static string _currentSaveName;
private static string GetPath(string saveName)
{
string text = Path.Combine(Paths.ConfigPath, "FishPerksMod");
Directory.CreateDirectory(text);
char[] invalidFileNameChars = Path.GetInvalidFileNameChars();
string text2 = string.Join("_", saveName.Split(invalidFileNameChars, StringSplitOptions.None));
return Path.Combine(text, text2 + "_perks.json");
}
public static void Load(string saveName)
{
_currentSaveName = saveName;
_data.Clear();
try
{
string path = GetPath(saveName);
if (!File.Exists(path))
{
Plugin.Log.LogInfo((object)("[FishPerksMod] No persisted fish perk data found for save '" + saveName + "' (this is normal the first time)."));
return;
}
string text = File.ReadAllText(path);
SaveFile saveFile = JsonUtility.FromJson<SaveFile>(text);
if (saveFile?.Entries == null)
{
return;
}
int num = 0;
foreach (Entry entry in saveFile.Entries)
{
if (Enum.TryParse<FishPerkType>(entry.Perk, out var result))
{
if (!_data.TryGetValue(entry.SteamId, out var value))
{
value = new Dictionary<byte, FishPerkType>();
_data[entry.SteamId] = value;
}
value[entry.Slot] = result;
num++;
}
}
Plugin.Log.LogInfo((object)$"[FishPerksMod] Loaded {num} persisted fish perk(s) for save '{saveName}'.");
}
catch (Exception arg)
{
Plugin.Log.LogWarning((object)$"[FishPerksMod] Failed to load persisted fish perks: {arg}");
}
}
public static void Set(ulong steamId, byte slot, FishPerkType perk)
{
if (!_data.TryGetValue(steamId, out var value))
{
value = new Dictionary<byte, FishPerkType>();
_data[steamId] = value;
}
value[slot] = perk;
}
public static void Remove(ulong steamId, byte slot)
{
if (_data.TryGetValue(steamId, out var value))
{
value.Remove(slot);
}
}
public static bool TryGet(ulong steamId, byte slot, out FishPerkType perk)
{
perk = FishPerkType.StoppingPower;
Dictionary<byte, FishPerkType> value;
return _data.TryGetValue(steamId, out value) && value.TryGetValue(slot, out perk);
}
public static void Save(string saveName = null)
{
saveName = saveName ?? _currentSaveName;
if (string.IsNullOrEmpty(saveName))
{
return;
}
try
{
SaveFile saveFile = new SaveFile();
foreach (KeyValuePair<ulong, Dictionary<byte, FishPerkType>> datum in _data)
{
foreach (KeyValuePair<byte, FishPerkType> item in datum.Value)
{
saveFile.Entries.Add(new Entry
{
SteamId = datum.Key,
Slot = item.Key,
Perk = item.Value.ToString()
});
}
}
string contents = JsonUtility.ToJson((object)saveFile, true);
File.WriteAllText(GetPath(saveName), contents);
if (FishPerkManager.VerboseLogging)
{
Plugin.Log.LogInfo((object)$"[FishPerksMod] Persisted {saveFile.Entries.Count} fish perk(s) for save '{saveName}'.");
}
}
catch (Exception arg)
{
Plugin.Log.LogWarning((object)$"[FishPerksMod] Failed to save persisted fish perks: {arg}");
}
}
}
[BepInPlugin("com.fishperksmod.fishperks", "CODFish Perks", "1.3.0")]
public sealed class Plugin : BaseUnityPlugin
{
public const string PluginGuid = "com.fishperksmod.fishperks";
public const string PluginName = "CODFish Perks";
public const string PluginVersion = "1.3.0";
private Harmony _harmony;
internal static Plugin Instance { get; private set; }
internal static ManualLogSource Log { get; private set; }
internal static ConfigEntry<bool> HudEnabled { get; private set; }
private void Awake()
{
//IL_003b: Unknown result type (might be due to invalid IL or missing references)
//IL_0045: Expected O, but got Unknown
Instance = this;
Log = ((BaseUnityPlugin)this).Logger;
HudEnabled = ((BaseUnityPlugin)this).Config.Bind<bool>("HUD", "Show Active Perk HUD", true, "Show or hide the active perk and remaining time on screen.");
_harmony = new Harmony("com.fishperksmod.fishperks");
_harmony.PatchAll();
Log.LogInfo((object)"CODFish Perks 1.3.0 loaded.");
}
private void Update()
{
FishPerkManager.UpdatePeriodicEffects();
}
private void OnDestroy()
{
Harmony harmony = _harmony;
if (harmony != null)
{
harmony.UnpatchSelf();
}
Instance = null;
}
}
internal static class ReflectionUtil
{
private static readonly Dictionary<(Type, string), FieldInfo> _cache = new Dictionary<(Type, string), FieldInfo>();
private static FieldInfo FindField(Type type, string name)
{
(Type, string) key = (type, name);
if (_cache.TryGetValue(key, out var value))
{
return value;
}
FieldInfo fieldInfo = null;
Type type2 = type;
while (type2 != null)
{
fieldInfo = type2.GetField(name, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
if (fieldInfo != null)
{
break;
}
type2 = type2.BaseType;
}
_cache[key] = fieldInfo;
if (fieldInfo == null)
{
ManualLogSource log = Plugin.Log;
if (log != null)
{
log.LogWarning((object)("[FishPerksMod] Reflection: could not find field '" + name + "' on type '" + type.FullName + "' or any of its base types. This usually means the field was renamed in a game update."));
}
}
return fieldInfo;
}
public static T GetField<T>(object instance, string fieldName)
{
if (instance == null)
{
return default(T);
}
FieldInfo fieldInfo = FindField(instance.GetType(), fieldName);
if (fieldInfo == null)
{
return default(T);
}
try
{
return (T)fieldInfo.GetValue(instance);
}
catch (Exception ex)
{
ManualLogSource log = Plugin.Log;
if (log != null)
{
log.LogWarning((object)("[FishPerksMod] Reflection: failed to read field '" + fieldName + "' on '" + instance.GetType().Name + "': " + ex.Message));
}
return default(T);
}
}
public static void SetField<T>(object instance, string fieldName, T value)
{
if (instance == null)
{
return;
}
FieldInfo fieldInfo = FindField(instance.GetType(), fieldName);
if (fieldInfo == null)
{
return;
}
try
{
fieldInfo.SetValue(instance, value);
}
catch (Exception ex)
{
ManualLogSource log = Plugin.Log;
if (log != null)
{
log.LogWarning((object)("[FishPerksMod] Reflection: failed to set field '" + fieldName + "' on '" + instance.GetType().Name + "': " + ex.Message));
}
}
}
}
}
namespace FishPerksMod.Patches
{
[HarmonyPatch(typeof(Attachments), "get_Damage")]
internal static class StoppingPowerPatch
{
[HarmonyPostfix]
private static void Postfix(Attachments __instance, ref int __result)
{
try
{
Weapon weapon = __instance.Weapon;
Player val = (((Object)(object)weapon != (Object)null) ? ((Item)weapon).Holder : null);
if (!((Object)(object)val == (Object)null) && FishPerkManager.HasActivePerk(val, FishPerkType.StoppingPower))
{
int num = Mathf.RoundToInt((float)__result * 1.55f);
if (FishPerkManager.VerboseLogging)
{
Plugin.Log.LogInfo((object)$"[FishPerksMod] Stopping Power: {__result} -> {num} damage for '{((Object)val).name}'.");
}
__result = num;
}
}
catch (Exception arg)
{
Plugin.Log.LogWarning((object)$"[FishPerksMod] StoppingPowerPatch failed: {arg}");
}
}
}
[HarmonyPatch(typeof(PlayerVitals), "TakeDamage")]
internal static class JuggernautPatch
{
[HarmonyPrefix]
private static void Prefix(PlayerVitals __instance, ref int amount)
{
try
{
Player field = ReflectionUtil.GetField<Player>(__instance, "_player");
if (!((Object)(object)field == (Object)null) && FishPerkManager.HasActivePerk(field, FishPerkType.Juggernaut))
{
int num = Mathf.Max(1, Mathf.RoundToInt((float)amount * 0.1f));
if (FishPerkManager.VerboseLogging)
{
Plugin.Log.LogInfo((object)$"[FishPerksMod] Juggernaut: incoming damage {amount} -> {num} for '{((Object)field).name}'.");
}
amount = num;
}
}
catch (Exception arg)
{
Plugin.Log.LogWarning((object)$"[FishPerksMod] JuggernautPatch failed: {arg}");
}
}
}
[HarmonyPatch(typeof(Weapon), "Shoot")]
internal static class DoubleTapPatch
{
[HarmonyPrefix]
private static void Prefix(Weapon __instance, ref float __state)
{
__state = ReflectionUtil.GetField<float>(__instance, "_timeBetweenShots");
if ((Object)(object)((Item)__instance).Holder != (Object)null && FishPerkManager.HasActivePerk(((Item)__instance).Holder, FishPerkType.DoubleTap))
{
ReflectionUtil.SetField(__instance, "_timeBetweenShots", __state / 1.4f);
}
}
[HarmonyPostfix]
private static void Postfix(Weapon __instance, float __state)
{
ReflectionUtil.SetField(__instance, "_timeBetweenShots", __state);
}
}
[HarmonyPatch(typeof(Weapon), "Reload")]
internal static class SpeedColaPatch
{
[HarmonyPostfix]
private static void Postfix(Weapon __instance)
{
if (!((Object)(object)((Item)__instance).Holder == (Object)null))
{
Animation field = ReflectionUtil.GetField<Animation>(__instance, "_anim");
string field2 = ReflectionUtil.GetField<string>(__instance, "_activeReloadAnimName");
if ((Object)(object)field != (Object)null && !string.IsNullOrEmpty(field2) && (TrackedReference)(object)field[field2] != (TrackedReference)null)
{
field[field2].speed = (FishPerkManager.HasActivePerk(((Item)__instance).Holder, FishPerkType.SpeedCola) ? 1.4f : 1f);
}
}
}
}
[HarmonyPatch(typeof(PlayerEating), "FinishEating")]
internal static class ClientFinishEatingPatch
{
[HarmonyPostfix]
private static void Postfix(PlayerEating __instance)
{
try
{
Creature field = ReflectionUtil.GetField<Creature>(__instance, "_curFood");
Player field2 = ReflectionUtil.GetField<Player>(__instance, "_player");
if (!((Object)(object)field == (Object)null) && !((Object)(object)field2 == (Object)null) && field.IsDrip)
{
FishPerkType orAssignPerk = FishPerkManager.GetOrAssignPerk(field);
FishPerkManager.ApplyBuff(field2, orAssignPerk);
if (FishPerkManager.VerboseLogging)
{
Plugin.Log.LogInfo((object)$"[FishPerksMod] (client) '{((Object)field2).name}' ate a drip fish and gained '{orAssignPerk}'.");
}
}
}
catch (Exception arg)
{
Plugin.Log.LogWarning((object)$"[FishPerksMod] ClientFinishEatingPatch failed: {arg}");
}
}
}
[HarmonyPatch(typeof(Server), "RpcLogic___FinishEatingCreature___1039939981")]
internal static class ServerFinishEatingPatch
{
[HarmonyPostfix]
private static void Postfix(object[] __args)
{
try
{
if (__args == null || __args.Length < 2)
{
return;
}
object obj = __args[0];
Creature val = (Creature)((obj is Creature) ? obj : null);
object obj2 = __args[1];
Player val2 = (Player)((obj2 is Player) ? obj2 : null);
if (!((Object)(object)val == (Object)null) && !((Object)(object)val2 == (Object)null) && val.IsDrip)
{
FishPerkType orAssignPerk = FishPerkManager.GetOrAssignPerk(val);
FishPerkManager.ApplyBuff(val2, orAssignPerk);
FishPerkManager.Announce("<b>" + val2.SteamName + "</b> consumed <b>" + FishPerkManager.GetDisplayName(orAssignPerk) + "</b>.");
if (FishPerkManager.VerboseLogging)
{
Plugin.Log.LogInfo((object)$"[FishPerksMod] (server) Registered buff '{orAssignPerk}' for '{((Object)val2).name}'.");
}
}
}
catch (Exception arg)
{
Plugin.Log.LogWarning((object)$"[FishPerksMod] ServerFinishEatingPatch failed: {arg}");
}
}
}
[HarmonyPatch(typeof(Item), "InitializeBait")]
internal static class DripFishCaughtAnnouncementPatch
{
private static readonly HashSet<Item> AnnouncedItems = new HashSet<Item>();
[HarmonyPostfix]
private static void Postfix(Item __instance, FishingRod rod)
{
if (!((Object)(object)__instance == (Object)null) && !((Object)(object)rod == (Object)null) && Object.op_Implicit((Object)(object)__instance.Creature) && __instance.Creature.IsDrip && !((Object)(object)((Item)rod).Holder == (Object)null) && !AnnouncedItems.Contains(__instance))
{
FishPerkType orAssignPerk = FishPerkManager.GetOrAssignPerk(__instance.Creature);
AnnouncedItems.Add(__instance);
FishPerkManager.Announce("<b>" + ((Item)rod).Holder.SteamName + "</b> has obtained <b>" + FishPerkManager.GetDisplayName(orAssignPerk) + "</b>.");
}
}
}
[HarmonyPatch(typeof(Creature), "SetDrip")]
internal static class DripPerkAssignmentPatch
{
[HarmonyPostfix]
private static void Postfix(Creature __instance)
{
if (!((Object)(object)__instance == (Object)null) && __instance.IsDrip)
{
FishPerkManager.GetOrAssignPerk(__instance);
}
}
}
[HarmonyPatch(typeof(Item), "SetAttachedRod")]
internal static class HookedDripPerkAssignmentPatch
{
[HarmonyPostfix]
private static void Postfix(Item __instance)
{
Creature val = (((Object)(object)__instance != (Object)null) ? __instance.Creature : null);
if ((Object)(object)val != (Object)null && val.IsDrip)
{
FishPerkManager.GetOrAssignPerk(val);
}
}
}
[HarmonyPatch(typeof(Item), "OnStartClient")]
internal static class SyncedDripPerkAssignmentPatch
{
[HarmonyPostfix]
private static void Postfix(Item __instance)
{
Creature val = (((Object)(object)__instance != (Object)null) ? __instance.Creature : null);
if ((Object)(object)val != (Object)null && val.IsDrip)
{
FishPerkManager.GetOrAssignPerk(val);
}
}
}
[HarmonyPatch(typeof(Creature), "OnDeath")]
internal static class DefeatedDripPerkAssignmentPatch
{
[HarmonyPostfix]
private static void Postfix(Creature __instance)
{
if ((Object)(object)__instance != (Object)null && __instance.IsDrip)
{
FishPerkManager.GetOrAssignPerk(__instance);
}
}
}
[HarmonyPatch(typeof(KillScoreCalculator), "GetRangedBonuses")]
internal static class HardlinePatch
{
[HarmonyPostfix]
private static void Postfix(ref List<Bonus> __result)
{
//IL_002f: Unknown result type (might be due to invalid IL or missing references)
//IL_0034: 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)
Player localPlayer = Player.LocalPlayer;
if (!((Object)(object)localPlayer == (Object)null) && FishPerkManager.HasActivePerk(localPlayer, FishPerkType.Hardline) && __result != null)
{
for (int i = 0; i < __result.Count; i++)
{
Bonus value = __result[i];
value.Worth *= 1.35f;
__result[i] = value;
}
if (FishPerkManager.VerboseLogging)
{
Plugin.Log.LogInfo((object)$"[FishPerksMod] Hardline increased {__result.Count} ranged score multipliers by {35.000004f:0}%.");
}
}
}
}
[HarmonyPatch(typeof(WeaponUI), "ShowInspectText", new Type[]
{
typeof(Item),
typeof(string)
})]
internal static class InspectItemPatch
{
[HarmonyPrefix]
private static void Prefix(Item item, ref string extraDescription)
{
try
{
Creature val = (((Object)(object)item != (Object)null) ? item.Creature : null);
if (!((Object)(object)val == (Object)null) && val.IsDrip)
{
FishPerkType orAssignPerk = FishPerkManager.GetOrAssignPerk(val);
string text = "<b>" + FishPerkManager.GetDisplayName(orAssignPerk) + "</b>\n" + FishPerkManager.GetDescription(orAssignPerk);
extraDescription = (string.IsNullOrEmpty(extraDescription) ? text : (extraDescription + "\n\n" + text));
if (FishPerkManager.VerboseLogging)
{
Plugin.Log.LogInfo((object)$"[FishPerksMod] Inspect panel updated for '{((Object)val).name}' with perk '{orAssignPerk}'.");
}
}
}
catch (Exception arg)
{
Plugin.Log.LogWarning((object)$"[FishPerksMod] InspectItemPatch failed: {arg}");
}
}
}
[HarmonyPatch(typeof(PlayerMovement), "Move")]
internal static class FizzyYummyPatch
{
private struct MovementState
{
public float WalkSpeed;
public float SprintSpeed;
public bool Changed;
}
[HarmonyPrefix]
private static void Prefix(PlayerMovement __instance, ref MovementState __state)
{
Player field = ReflectionUtil.GetField<Player>(__instance, "_player");
if (!((Object)(object)field == (Object)null) && FishPerkManager.HasActivePerk(field, FishPerkType.FizzyYummy))
{
__state.WalkSpeed = ReflectionUtil.GetField<float>(__instance, "_walkSpeed");
__state.SprintSpeed = ReflectionUtil.GetField<float>(__instance, "_sprintSpeed");
float num = 1.3f;
ReflectionUtil.SetField(__instance, "_walkSpeed", __state.WalkSpeed * num);
ReflectionUtil.SetField(__instance, "_sprintSpeed", __state.SprintSpeed * num);
__state.Changed = true;
}
}
[HarmonyPostfix]
private static void Postfix(PlayerMovement __instance, MovementState __state)
{
if (__state.Changed)
{
ReflectionUtil.SetField(__instance, "_walkSpeed", __state.WalkSpeed);
ReflectionUtil.SetField(__instance, "_sprintSpeed", __state.SprintSpeed);
}
}
}
[HarmonyPatch(typeof(PlayerMovement), "Move")]
internal static class FizzyYummyVelocityPatch
{
[HarmonyPostfix]
private static void Postfix(PlayerMovement __instance)
{
//IL_0041: 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)
//IL_0047: Unknown result type (might be due to invalid IL or missing references)
//IL_0052: Unknown result type (might be due to invalid IL or missing references)
//IL_0058: Unknown result type (might be due to invalid IL or missing references)
//IL_0062: Unknown result type (might be due to invalid IL or missing references)
//IL_0067: 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_006f: 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_007b: Unknown result type (might be due to invalid IL or missing references)
Player field = ReflectionUtil.GetField<Player>(__instance, "_player");
Rigidbody field2 = ReflectionUtil.GetField<Rigidbody>(__instance, "_rig");
if (!((Object)(object)field == (Object)null) && !((Object)(object)field2 == (Object)null) && FishPerkManager.HasActivePerk(field, FishPerkType.FizzyYummy))
{
Vector3 linearVelocity = field2.linearVelocity;
Vector3 val = new Vector3(linearVelocity.x, 0f, linearVelocity.z) * 1.3f;
field2.linearVelocity = new Vector3(val.x, linearVelocity.y, val.z);
}
}
}
[HarmonyPatch(typeof(SaveManager), "OnServerLoaded")]
internal static class LoadPerksPatch
{
[HarmonyPostfix]
private static void Postfix()
{
if (SaveManager.CurServerSave != null)
{
PersistenceStore.Load(SaveManager.CurServerSave.Name);
}
}
}
[HarmonyPatch(typeof(PlayerInventory), "LoadFromSave")]
internal static class RestorePerksPatch
{
[HarmonyPostfix]
private static void Postfix(PlayerInventory __instance)
{
SavedPlayer field = ReflectionUtil.GetField<SavedPlayer>(__instance, "_toLoadFrom");
Player field2 = ReflectionUtil.GetField<Player>(__instance, "_player");
if (field == null || (Object)(object)field2 == (Object)null)
{
return;
}
Dictionary<byte, Item> field3 = ReflectionUtil.GetField<Dictionary<byte, Item>>(__instance, "_items");
if (field3 != null)
{
foreach (KeyValuePair<byte, Item> item in field3)
{
if ((Object)(object)item.Value != (Object)null && Object.op_Implicit((Object)(object)item.Value.Creature) && item.Value.Creature.IsDrip && PersistenceStore.TryGet(field.SteamID, item.Key, out var perk))
{
FishPerkManager.AssignSpecificPerk(item.Value.Creature, perk);
}
}
}
Item uninitializedHeldItem = field2.Holding.UninitializedHeldItem;
if ((Object)(object)uninitializedHeldItem != (Object)null && Object.op_Implicit((Object)(object)uninitializedHeldItem.Creature) && uninitializedHeldItem.Creature.IsDrip && PersistenceStore.TryGet(field.SteamID, 0, out var perk2))
{
FishPerkManager.AssignSpecificPerk(uninitializedHeldItem.Creature, perk2);
}
}
}
[HarmonyPatch(typeof(SaveManager), "SavePlayer")]
internal static class CapturePerksPatch
{
[HarmonyPostfix]
private static void Postfix(Player player, Item heldItem, Dictionary<byte, Item> slotToItem)
{
if ((Object)(object)player == (Object)null)
{
return;
}
Capture(player.SteamID, 0, heldItem);
if (slotToItem == null)
{
return;
}
foreach (KeyValuePair<byte, Item> item in slotToItem)
{
Capture(player.SteamID, item.Key, item.Value);
}
}
private static void Capture(ulong steamId, byte slot, Item item)
{
if ((Object)(object)item != (Object)null && Object.op_Implicit((Object)(object)item.Creature) && item.Creature.IsDrip)
{
PersistenceStore.Set(steamId, slot, FishPerkManager.GetOrAssignPerk(item.Creature));
}
else
{
PersistenceStore.Remove(steamId, slot);
}
}
}
[HarmonyPatch(typeof(SaveManager), "SaveServer")]
internal static class SavePerksPatch
{
[HarmonyPostfix]
private static void Postfix()
{
if (SaveManager.CurServerSave != null)
{
PersistenceStore.Save(SaveManager.CurServerSave.Name);
}
}
}
[HarmonyPatch(typeof(Server), "OnStopServer")]
internal static class ClearSessionPatch
{
[HarmonyPostfix]
private static void Postfix()
{
FishPerkManager.ClearSession();
}
}
[HarmonyPatch(typeof(PlayerDying), "ServerDie")]
internal static class QuickRevivePatch
{
[HarmonyPrefix]
private static bool Prefix(PlayerDying __instance)
{
try
{
Player player = ReflectionUtil.GetField<Player>(__instance, "_player");
if ((Object)(object)player == (Object)null || !FishPerkManager.HasActivePerk(player, FishPerkType.QuickRevive))
{
return true;
}
Creature boss = BossManager.Boss;
bool flag = (Object)(object)boss != (Object)null && !boss.IsDead;
bool flag2 = PlayerManager.Players != null && PlayerManager.Players.Any((Player other) => (Object)(object)other != (Object)null && (Object)(object)other != (Object)(object)player && !other.Dying.IsDead && other.Vitals.Health > 0);
if (!flag || !flag2)
{
return true;
}
player.Vitals.OnResurrect();
if (FishPerkManager.VerboseLogging)
{
Plugin.Log.LogInfo((object)("[FishPerksMod] Quick Revive saved '" + ((Object)player).name + "' during a boss fight."));
}
return false;
}
catch (Exception arg)
{
Plugin.Log.LogWarning((object)$"[FishPerksMod] Quick Revive patch failed: {arg}");
return true;
}
}
}
[HarmonyPatch(typeof(PlayerDying), "LocalResurrect")]
internal static class QuickReviveLocalSignalPatch
{
[HarmonyPostfix]
private static void Postfix(PlayerDying __instance)
{
QuickReviveSignals.Play(__instance);
}
}
[HarmonyPatch(typeof(PlayerDying), "ResurrectEffect")]
internal static class QuickReviveObserverSignalPatch
{
[HarmonyPostfix]
private static void Postfix(PlayerDying __instance)
{
QuickReviveSignals.Play(__instance);
}
}
internal static class QuickReviveSignals
{
internal static void Play(PlayerDying dying)
{
Player field = ReflectionUtil.GetField<Player>(dying, "_player");
if (!((Object)(object)field == (Object)null) && FishPerkManager.HasActivePerk(field, FishPerkType.QuickRevive))
{
field.Effects.OnRestoredFullness();
field.Effects.OnRestoredFullness();
AudioManager.PlayRandomPlayerClip("ShinyCreatureCaught_0", 1, 3, field, false, (AudioDistance)2, 0.5f, 0.1f);
}
}
}
}
