Decompiled source of BoomThisHowToFish v1.3.0

HowToFish.Trainer.dll

Decompiled 5 hours ago
using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Configuration;
using FishNet.Object;
using FishNet.Transporting;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using UnityEngine;
using UnityEngine.SceneManagement;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: AssemblyCompany("HowToFish.Trainer")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("HowToFish.Trainer")]
[assembly: AssemblyTitle("HowToFish.Trainer")]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyVersion("1.0.0.0")]
[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 HowToFishTrainer
{
	[HarmonyPatch(typeof(PlayerAimAssist), "IsAimingDownSights")]
	internal static class AimWithoutAdsPatch
	{
		private static bool Prefix(ref bool __result)
		{
			TrainerPlugin instance = TrainerPlugin.Instance;
			if ((Object)(object)instance == (Object)null || !instance.AimWithoutAdsEnabled || !Object.op_Implicit((Object)(object)Player.LocalPlayer) || !Object.op_Implicit((Object)(object)Player.LocalPlayer.Holding) || !Object.op_Implicit((Object)(object)Player.LocalPlayer.Holding.HeldItem) || !Object.op_Implicit((Object)(object)Player.LocalPlayer.Holding.HeldItem.Weapon))
			{
				return true;
			}
			__result = true;
			return false;
		}
	}
	[HarmonyPatch(typeof(PlayerAimAssist), "GetRotationDelta")]
	internal static class ConfigurableAimAssistPatch
	{
		private static bool Prefix(Vector3 cameraPosition, Vector3 cameraEuler, float manualLookAmount, ref Vector2 __result)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: 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_0053: 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_004a: 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)
			TrainerPlugin instance = TrainerPlugin.Instance;
			if ((Object)(object)instance == (Object)null || !instance.TryGetAimRotationDelta(cameraPosition, cameraEuler, manualLookAmount, out var delta))
			{
				return true;
			}
			float num = 2.5f;
			if (((Vector2)(ref delta)).magnitude > num)
			{
				delta = ((Vector2)(ref delta)).normalized * num;
			}
			__result = delta;
			return false;
		}
	}
	[HarmonyPatch(typeof(CreatureManager), "HookItem")]
	internal static class ForcedCatchPatch
	{
		private static void Prefix(ref Item itemPrefab)
		{
			TrainerPlugin instance = TrainerPlugin.Instance;
			if ((Object)(object)instance != (Object)null)
			{
				itemPrefab = instance.GetForcedCatchItem(itemPrefab);
			}
		}

		private static void Postfix(Bait bait)
		{
			TrainerPlugin instance = TrainerPlugin.Instance;
			if (!((Object)(object)instance == (Object)null))
			{
				instance.ApplyForcedCatchResult(bait);
			}
		}
	}
	[HarmonyPatch(typeof(DeadPlayer), "UpdateResurrection")]
	internal static class InfiniteSlapPatch
	{
		private static bool Prefix(DeadPlayer __instance)
		{
			TrainerPlugin instance = TrainerPlugin.Instance;
			return (Object)(object)instance == (Object)null || !instance.TryRunInfiniteSlap(__instance);
		}
	}
	[HarmonyPatch(typeof(PlayerVitals), "TakeDamage")]
	internal static class LocalHostGodModePatch
	{
		private static bool Prefix(PlayerVitals __instance)
		{
			TrainerPlugin instance = TrainerPlugin.Instance;
			return (Object)(object)instance == (Object)null || !instance.SelfGodEnabled || !Object.op_Implicit((Object)(object)Player.LocalPlayer) || (Object)(object)__instance != (Object)(object)Player.LocalPlayer.Vitals || !((NetworkBehaviour)__instance).IsServerInitialized;
		}
	}
	[HarmonyPatch(typeof(ProjectileManager), "AddProjectiles")]
	internal static class MagicBulletMultiplePatch
	{
		private static void Prefix(Player owner, WeaponInfo weaponInfo, bool isLocal, Vector3 pos, Vector3[] velocities)
		{
			//IL_0027: 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)
			//IL_0031: 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)
			TrainerPlugin instance = TrainerPlugin.Instance;
			if (!((Object)(object)instance == (Object)null) && velocities != null)
			{
				for (int i = 0; i < velocities.Length; i++)
				{
					Vector3 velocity = velocities[i];
					instance.RedirectMagicBullet(owner, weaponInfo, isLocal, pos, ref velocity);
					velocities[i] = velocity;
				}
			}
		}
	}
	[HarmonyPatch(typeof(ProjectileManager), "AddProjectile")]
	internal static class MagicBulletSinglePatch
	{
		private static void Prefix(Player owner, WeaponInfo weaponInfo, bool isLocal, Vector3 pos, ref Vector3 velocity)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			TrainerPlugin instance = TrainerPlugin.Instance;
			if (!((Object)(object)instance == (Object)null))
			{
				instance.RedirectMagicBullet(owner, weaponInfo, isLocal, pos, ref velocity);
			}
		}
	}
	[HarmonyPatch(typeof(PlayerMovement), "FixedUpdate")]
	internal static class PlayerFlightPatch
	{
		private static void Postfix(PlayerMovement __instance)
		{
			TrainerPlugin instance = TrainerPlugin.Instance;
			if (!((Object)(object)instance == (Object)null))
			{
				instance.ApplyFlightAfterPhysics(__instance);
			}
		}
	}
	[HarmonyPatch(typeof(CasinoManager), "ServerRouletteResult")]
	internal static class RouletteAlwaysWinPatch
	{
		private static void Prefix(ref BetColor winColor)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Expected I4, but got Unknown
			TrainerPlugin instance = TrainerPlugin.Instance;
			if ((Object)(object)instance != (Object)null)
			{
				winColor = (BetColor)(int)instance.GetForcedRouletteColor(winColor);
			}
		}
	}
	[HarmonyPatch(typeof(Item), "AddBetMultiplier")]
	internal static class RoulettePayoutPatch
	{
		private static void Prefix(ref float multiplier)
		{
			TrainerPlugin instance = TrainerPlugin.Instance;
			if ((Object)(object)instance != (Object)null)
			{
				multiplier = instance.GetRoulettePayout(multiplier);
			}
		}
	}
	[HarmonyPatch(typeof(PlayerAimAssist), "CanUseAimAssist")]
	internal static class StrongAimAssistPatch
	{
		private static bool Prefix(ref bool __result)
		{
			TrainerPlugin instance = TrainerPlugin.Instance;
			if ((Object)(object)instance == (Object)null || !instance.StrongAimEnabled || !Object.op_Implicit((Object)(object)Player.LocalPlayer))
			{
				return true;
			}
			__result = true;
			return false;
		}
	}
	[BepInPlugin("codex.howtofish.trainer", "Boom This HowToFish - By Me0wws", "1.3")]
	public sealed class TrainerPlugin : BaseUnityPlugin
	{
		private struct SkinEntry
		{
			public byte ItemId;

			public byte SkinId;

			public string Display;
		}

		private struct AimCandidate
		{
			public Transform Target;

			public Vector3 Position;

			public Vector3 Velocity;
		}

		private struct MovementDefaults
		{
			public float Walk;

			public float Sprint;

			public float Jump;
		}

		private struct AimDefaults
		{
			public float Distance;

			public float AcquireAngle;

			public float BreakAngle;

			public float RotationSpeed;

			public float Sharpness;
		}

		private struct WeaponDefaults
		{
			public Weapon Weapon;

			public float ShotDelay;

			public float Spread;

			public int Recoil;

			public float ProjectileSpeed;

			public int ProjectileCount;

			public bool FullAuto;

			public bool NoShootDuringAnimation;

			public bool NoQueueingShots;
		}

		private struct RodDefaults
		{
			public FishingRod Rod;

			public float ReelSpeed;

			public float ReelStep;

			public float ThrowSpeed;
		}

		private struct BoatMotorDefaults
		{
			public BoatMotor Motor;

			public float Force;
		}

		private struct BaitDefaults
		{
			public BaitInfo Bait;

			public Vector2 CatchTime;

			public float LostChance;

			public bool RequireReeling;
		}

		internal static TrainerPlugin Instance;

		private bool _useEnglish = true;

		private readonly Dictionary<string, Dictionary<string, string>> _localizationDict = new Dictionary<string, Dictionary<string, string>>
		{
			{
				"zh",
				new Dictionary<string, string>
				{
					{ "menu.title", "Boom This HowToFish - By Me0wws" },
					{ "menu.opened", "菜单已打开(F1/Insert 关闭)" },
					{ "menu.closed", "菜单已关闭" },
					{ "menu.player", "玩家: " },
					{ "menu.none", "无" },
					{ "menu.money", "金钱: " },
					{ "menu.categories", "功能分类" },
					{ "menu.scope", "作用范围" },
					{ "menu.scope_desc", "Thanks for HsJohnL\n[本地] 仅当前客户端\n[同步] 服务器复制结果\n[主机] 房主权威\n[全局] 整个房间规则" },
					{ "menu.close_hint", "F1 / Insert 关闭" },
					{ "menu.lang", "语言: 中文" },
					{ "menu.lang_switch", "切换英文" },
					{ "status.host", "主机/服务器" },
					{ "status.client", "联机客户端" },
					{ "status.none", "未进入世界" },
					{ "status.godmode", "全局无敌=" },
					{ "status.oneshot", "全局一击模式=" },
					{ "status.move", "移动倍数=" },
					{ "status.jump", "跳跃倍数=" },
					{ "status.move_reset", "移动参数已重置" },
					{ "tab.player", "玩家 / 资源" },
					{ "tab.items", "物品 / 背包" },
					{ "tab.teammates", "队友 / 世界" },
					{ "tab.combat", "战斗 / 钓鱼" },
					{ "tab.esp", "透视 / 自瞄 / 准星" },
					{ "tab.casino", "赌博 / 命令" },
					{ "tab.other", "其他 / 设置" },
					{ "desc.player", "金钱、状态、无敌及移动参数" },
					{ "desc.items", "生成物品、解锁背包并编辑手持物" },
					{ "desc.teammates", "队友互动、复活、飞行、传送与世界进度" },
					{ "desc.combat", "枪械、附件、鱼竿、鱼饵及上钩物参数" },
					{ "desc.esp", "实体透视、自瞄瞄准及准星自定义" },
					{ "desc.casino", "轮盘、老虎机及游戏原生命令" },
					{ "desc.other", "更多玩家、房间设置及其他辅助功能" },
					{ "card.money", "金钱" },
					{ "card.money_desc", "共享服务器资源,修改需要房主权限" },
					{ "card.vitals", "生命与状态" },
					{ "card.movement", "移动参数" },
					{ "card.movement_desc", "拥有者本地计算,位置仍会同步" },
					{ "card.items", "物品库与生成" },
					{ "card.items_desc", "按名称、ID、类型或价值筛选;点击条目生成到手中" },
					{ "card.held", "持有物编辑" },
					{ "card.held_desc", "当前持有:" },
					{ "card.skins", "皮肤 ID 与快速解锁" },
					{ "card.skins_desc", "皮肤 ID 按物品分别编号;船皮肤使用物品 ID 255。解锁写入本地存档。" },
					{ "card.teleport", "坐标与传送" },
					{ "card.teleport_desc", "自己的角色由服务器确认并同步" },
					{ "card.world", "世界进度" },
					{ "card.world_desc", "主机权威,影响当前房间与存档" },
					{ "card.boat", "船只参数" },
					{ "card.teammates", "队友互动" },
					{ "card.teammates_desc", "选择玩家后可双向传送、恶搞位置或赠送物品,结果同步到房间" },
					{ "card.revive", "复活与异常状态" },
					{ "card.slap", "扇巴掌恶搞" },
					{ "card.slap_desc", "选择倒地队友并拿起其身体;持续扇模式会循环动画且不会完成复活。" },
					{ "card.flight", "飞行" },
					{ "card.flight_desc", "WASD 水平移动,Space 上升,Ctrl 下降" },
					{ "card.weapon", "枪械参数" },
					{ "card.weapon_desc", "持有武器在本地改参数,射击结果沿原 RPC 同步" },
					{ "card.fishing", "钓竿、鱼饵与上钩物" },
					{ "card.equipped", "当前装备与升级" },
					{ "card.equipped_desc", "当前持有:" },
					{ "card.esp", "透视" },
					{ "card.esp_desc", "本地绘制,不改变实体;实体类型与框体组件均可独立配置" },
					{ "card.aim", "自瞄" },
					{ "card.aim_desc", "按准星夹角优先选择;队友目标点使用头部/摄像机代理位置" },
					{ "card.crosshair", "准星设置" },
					{ "card.crosshair_desc", "自定义准星样式、颜色、大小等参数" },
					{ "card.roulette", "轮盘参数" },
					{ "card.roulette_desc", "结果由主机处理" },
					{ "card.slots", "老虎机奖品" },
					{ "card.slots_desc", "指定下一次奖品的物品与皮肤" },
					{ "card.commands", "游戏原生命令" },
					{ "card.commands_desc", "主机命令;输入完整命令后执行" },
					{ "card.commands_help", "命令帮助" },
					{ "card.max_players", "更多玩家" },
					{ "card.max_players_desc", "修改房间最大玩家数,仅房主生效。修改后需重新创建房间。" },
					{ "card.lobby", "房间设置" },
					{ "card.lobby_desc", "快速切换房间公开/私密状态" },
					{ "card.performance", "性能设置" },
					{ "card.performance_desc", "调整游戏性能相关选项" },
					{ "card.quick", "快捷操作" },
					{ "card.quick_desc", "常用游戏操作快捷按钮" },
					{ "btn.add", "[主机] 增加" },
					{ "btn.remove", "[主机] 减少" },
					{ "btn.set", "[主机] 设为此值" },
					{ "btn.fill_vitals", "[主机] 生命/饱食全满,清除中毒/燃烧" },
					{ "btn.godmode_global", "[主机/全局] 原生无敌: " },
					{ "btn.oneshot", "[主机/全局] 一击模式: " },
					{ "btn.apply", "应用" },
					{ "btn.reset", "重置" },
					{ "btn.refresh_items", "刷新全部物品 ID" },
					{ "btn.clear_filter", "清空筛选" },
					{ "btn.unlock_baits", "[同步/自己] 解锁全部鱼饵" },
					{ "btn.unlock_pockets", "[主机/自己] 解锁全部背包槽" },
					{ "btn.spawn", "[同步] 生成到手中" },
					{ "btn.prev", "上一页" },
					{ "btn.next", "下一页" },
					{ "btn.set_weight", "[主机] 设置重量" },
					{ "btn.raw", "生食" },
					{ "btn.perfect", "完美熟度" },
					{ "btn.burnt", "烤焦" },
					{ "btn.next_skin", "[同步] 下个皮肤" },
					{ "btn.kill_mult", "[同步] 击杀分倍率" },
					{ "btn.bet_mult", "[主机] 下注价值倍率" },
					{ "btn.unlock_all_skins", "[本地存档] 解锁全部物品/船皮肤" },
					{ "btn.unlock_clothes", "[本地/当前会话] 解锁全部角色服装" },
					{ "btn.unlock_skin", "解锁指定皮肤" },
					{ "btn.unlock", "[本地存档] 解锁" },
					{ "btn.teleport", "[同步] 传送" },
					{ "btn.save_pos", "记录当前位置" },
					{ "btn.return_pos", "[同步] 返回记录点" },
					{ "btn.forward", "[同步] 向视线前方 10m" },
					{ "btn.to_boat", "[同步] 传送到船" },
					{ "btn.unlock_boat", "[主机] 解锁船/雷达/最高马达" },
					{ "btn.unlock_grill", "[主机] 解锁烤架" },
					{ "btn.prev_island", "[主机/全局] 上一个岛" },
					{ "btn.next_island", "[主机/全局] 下一个岛" },
					{ "btn.apply_mult", "应用倍率" },
					{ "btn.pull_here", "[同步] 拉到我身边" },
					{ "btn.go_to_teammate", "[同步] 我传送到队友" },
					{ "btn.throw_forward", "[同步] 丢到视线前 10m" },
					{ "btn.give_item", "[同步] 免费塞到队友手中" },
					{ "btn.revive", "[同步] 复活选中队友" },
					{ "btn.revive_all", "[同步] 一键复活全员" },
					{ "btn.clear_self", "[主机] 清除自己异常" },
					{ "btn.clear_teammate", "[主机] 清除队友异常" },
					{ "btn.apply_rod", "应用鱼竿参数" },
					{ "btn.apply_catch", "应用上钩参数" },
					{ "btn.max_attachments", "[主机/同步] 枪械全部附件" },
					{ "btn.max_bullets", "[主机/同步] 弹头升满" },
					{ "btn.max_melee", "[主机/同步] 近战锐度升满" },
					{ "btn.apply_aim", "应用自瞄参数" },
					{ "btn.apply_roulette", "应用轮盘参数" },
					{ "btn.set_prize", "[主机] 指定奖品" },
					{ "btn.random_prize", "[主机] 恢复随机" },
					{ "btn.execute", "[主机] 执行" },
					{ "btn.public", "设为公开房间" },
					{ "btn.private", "设为私密房间" },
					{ "btn.unlimited", "无限制" },
					{ "btn.quit", "退出到主菜单" },
					{ "btn.reload", "重载游戏场景" },
					{ "toggle.godmode", "[主机/自己] 个人无敌" },
					{ "toggle.keep_full", "[主机/自己] 持续满生命、饱食,清毒/火" },
					{ "toggle.infinite_ammo", "[本地] 无限弹药" },
					{ "toggle.no_spread", "[本地] 无散布 + 无后坐击退" },
					{ "toggle.rapid_fire", "[本地] 射击间隔 ×0.12" },
					{ "toggle.skip_bolt", "[本地] 跳过拉栓/开火动画限制" },
					{ "toggle.force_auto", "[本地] 强制全自动(按住射击;可搭配快速射击)" },
					{ "toggle.custom_weapon", "[本地/同步伤害] 启用自定义枪械参数" },
					{ "toggle.fast_fishing", "[本地/同步运动] 收线、线长步进、抛线速度 ×6" },
					{ "toggle.instant_bite", "[主机] 0.1–0.2 秒咬钩、鱼饵零损耗、无需收线触发" },
					{ "toggle.custom_rod", "[本地/同步运动] 启用自定义鱼竿参数" },
					{ "toggle.force_catch", "[主机] 指定下一次/持续上钩物品" },
					{ "toggle.shiny", "强制闪光品质" },
					{ "toggle.esp", "[本地] 启用透视" },
					{ "toggle.players", "队友" },
					{ "toggle.alive", "活体生物" },
					{ "toggle.dead", "死亡生物" },
					{ "toggle.items", "普通物品" },
					{ "toggle.boxes", "实体框" },
					{ "toggle.corners", "角框" },
					{ "toggle.healthbars", "血条" },
					{ "toggle.snaplines", "引导线" },
					{ "toggle.strong_aim", "[本地] 强力辅助瞄准(鼠标也生效)" },
					{ "toggle.no_ads", "[本地] 自瞄无需按住瞄准键" },
					{ "toggle.sticky", "[本地] 锁定当前目标,减少移动时跳目标" },
					{ "toggle.predict", "[本地] 移动预测(目标/自己移动时提前量)" },
					{ "toggle.magic", "[本地/同步命中] 魔法子弹(射击时自动修正弹道)" },
					{ "toggle.ignore", "忽略遮挡" },
					{ "toggle.outline", "显示描边" },
					{ "toggle.spread_ring", "显示扩散圈" },
					{ "toggle.roulette_win", "[主机] 当前下注颜色必中" },
					{ "toggle.roulette_payout", "[主机] 自定义赔付倍率" },
					{ "toggle.auto_slap", "[同步] 持续扇选中队友(不复活)" },
					{ "toggle.fast_slap", "[本地/同步] 加速正常扇巴掌复活" },
					{ "toggle.flight", "[本地] 飞行" },
					{ "toggle.boat_boost", "[主机/全局] 船马达加速" },
					{ "label.move_mult", "移动倍数" },
					{ "label.jump_mult", "跳跃倍数" },
					{ "label.items_count", "物品表:{0} 项匹配,共 {1} 页。点击后免费生成到手中并同步。" },
					{ "label.page", "第 {0} / {1} 页" },
					{ "label.item_id", "物品 ID" },
					{ "label.skin_id", "皮肤 ID" },
					{ "label.skins_count", "皮肤表:{0} 项匹配。格式:物品 ID / 皮肤 ID / 名称 / 稀有度" },
					{ "label.coords", "当前坐标:X {0}  Y {1}  Z {2}" },
					{ "label.selected", "当前选择:" },
					{ "label.downed", " [倒地]" },
					{ "label.holding", "● 已拿起选中队友" },
					{ "label.waiting", "○ 等待拿起选中队友" },
					{ "label.speed", "速度" },
					{ "label.speed_mult", "速度倍率" },
					{ "label.sniper_tip", "狙击枪建议同时开启:跳过拉栓 + 强制全自动 + 射击间隔 ×0.12。" },
					{ "label.delay", "间隔×" },
					{ "label.speed_param", "弹速×" },
					{ "label.count", "弹丸数" },
					{ "label.spread", "散布×" },
					{ "label.recoil", "后坐×" },
					{ "label.damage", "伤害×" },
					{ "label.reel", "收线×" },
					{ "label.step", "线长步进×" },
					{ "label.throw", "抛线×" },
					{ "label.weight", "重量/大小" },
					{ "label.ammo", "武器弹药:" },
					{ "label.damage_colon", " | 伤害:" },
					{ "label.rod_detected", "已检测到钓鱼竿。" },
					{ "label.distance", "距离" },
					{ "label.box_style", "框体样式:" },
					{ "label.esp_color_tip", "颜色:青=队友,绿=活体,红=死亡,黄=物品;标签显示名称、距离及生命/重量。" },
					{ "label.target_type", "目标类型:" },
					{ "label.aim_params", "距离 / 捕获角 / 转速" },
					{ "label.sharpness", "跟随强度 / 预测倍率" },
					{ "label.magic_tip", "魔法子弹沿用上方目标类型;无需准星对准目标。" },
					{ "label.mode", "模式" },
					{ "label.current", "当前: " },
					{ "label.style", "样式" },
					{ "label.current_style", "当前样式: " },
					{ "label.color", "颜色" },
					{ "label.custom", "自定义(#)" },
					{ "label.size", "大小" },
					{ "label.thickness", "粗细" },
					{ "label.gap", "间距" },
					{ "label.t_length", "T长" },
					{ "label.current_color", "当前准星颜色: " },
					{ "label.red_black", "红/黑倍率" },
					{ "label.green", "绿色倍率" },
					{ "label.commands_help_title", "所有命令及说明:" },
					{ "label.commands_list", "spawn / spawndead / spawndrip / grill / boat / addmoney / removemoney / nextisland / previsland / godmode / oneshot / killboss / allskins / noskins / finishgame / unlockachievements / lockachievements" },
					{ "label.command_example", "示例:/spawn fishingrod   /spawndead piranha   /addmoney   /godmode" },
					{ "label.commands_help_detail", "┌─────────────────────────────────────────────────────────┐\n│ 命令                           │ 说明                      │\n├─────────────────────────────────────────────────────────┤\n│ spawn <物品名>                 │ 生成指定物品              │\n│ spawndead <生物名>             │ 生成死亡生物              │\n│ spawndrip <生物名>             │ 生成闪光生物              │\n│ grill                          │ 解锁烤架                  │\n│ boat                           │ 解锁船/雷达/最高马达      │\n│ addmoney <金额>                │ 增加金钱                  │\n│ removemoney <金额>             │ 减少金钱                  │\n│ nextisland                     │ 切换到下一个岛屿          │\n│ previsland                     │ 切换到上一个岛屿          │\n│ godmode                        │ 切换全局无敌模式          │\n│ oneshot                        │ 切换全局一击模式          │\n│ killboss                       │ 击杀当前区域Boss          │\n│ allskins                       │ 解锁所有皮肤              │\n│ noskins                        │ 移除所有皮肤              │\n│ finishgame                     │ 完成游戏                  │\n│ unlockachievements             │ 解锁所有成就              │\n│ lockachievements               │ 锁定所有成就              │\n└─────────────────────────────────────────────────────────┘" },
					{ "label.max_players", "最大玩家数" },
					{ "label.current_fmt", "(当前: {0})" },
					{ "label.max_players_tip", "提示: 更改后需要重新创建房间 (退出到主菜单再重新进入) 才能生效。" },
					{ "label.lobby_status", "当前状态: " },
					{ "label.public", "公开" },
					{ "label.private", "私密" },
					{ "label.fps_limit", "帧率上限" },
					{ "label.current_fps", "当前帧率: {0} FPS" },
					{ "style.dot", "小点" },
					{ "style.cross", "十字" },
					{ "style.t", "T型" },
					{ "style.circle", "圆圈" },
					{ "style.dot_circle", "点圈" },
					{ "style.crosshair", "准星" },
					{ "color.white", "白色" },
					{ "color.red", "红色" },
					{ "color.green", "绿色" },
					{ "color.blue", "蓝色" },
					{ "color.cyan", "青色" },
					{ "color.yellow", "黄色" },
					{ "status.host_required", "该操作需要主机且本地玩家已生成" },
					{ "status.added_money", "增加金钱 " },
					{ "status.removed_money", "减少金钱 " },
					{ "status.money_set", "金钱已设为 " },
					{ "status.vitals_filled", "生命/饱食已全满,中毒/燃烧已清除" },
					{ "status.teleporting", "已请求传送 " },
					{ "status.to", " -> " },
					{ "status.invalid_id", "物品 ID 无效:" },
					{ "status.giving", "已请求给 " },
					{ "status.no_revive_target", "目标当前没有可复活的倒地实体" },
					{ "status.reviving", "已请求复活 " },
					{ "status.revive_all", "已提交全员复活:" },
					{ "status.cleared", "已清除异常状态:" },
					{ "status.aim_applied", "自瞄参数已应用" },
					{ "status.weapon_applied", "自定义枪械参数已应用" },
					{ "status.rod_applied", "自定义鱼竿参数已应用" },
					{ "status.catch_set", "上钩物设为 " },
					{ "status.roulette_applied", "轮盘赔付参数已应用" },
					{ "status.invalid_skin", "物品 ID 或皮肤索引无效" },
					{ "status.slot_prize", "下次老虎机奖品已指定:" },
					{ "status.random_prize", "老虎机已恢复随机奖品" },
					{ "status.command_submitted", "命令已提交:" },
					{ "status.command_invalid", "命令格式未识别:" },
					{ "status.items_refreshed", "物品表已刷新,共 " },
					{ "status.skin_not_found", "未找到该物品 ID / 皮肤 ID 组合" },
					{ "status.skin_unlocked", "皮肤已解锁:" },
					{ "status.all_skins_unlocked", "已写入本地存档,共解锁皮肤 " },
					{ "status.clothes_unlocked", "全部角色服装已在当前会话解锁" },
					{ "status.server_required", "需要已连接的服务器与本地玩家" },
					{ "status.spawning", "已请求生成 " },
					{ "status.baits_unlocked", "已提交全部鱼饵解锁,共 " },
					{ "status.pockets_unlocked", "额外背包槽已设为 5" },
					{ "status.weight_set", "持有物重量已设为 " },
					{ "status.cookness_set", "持有物熟度已设为 " },
					{ "status.no_skin", "该物品没有可切换皮肤" },
					{ "status.skin_switched", "请求切换持有物皮肤到 " },
					{ "status.kill_mult_set", "击杀分倍率已提交:" },
					{ "status.bet_mult_set", "下注价值倍率已设为 " },
					{ "status.attachments_applied", "枪械附件已应用:" },
					{ "status.bullet_upgraded", "弹头升级次数:" },
					{ "status.melee_upgraded", "近战锐度升级次数:" },
					{ "status.teleporting_to", "已请求传送到 " },
					{ "status.boat_required", "需要主机且船实例已生成" },
					{ "status.boat_unlocked", "船、雷达与最高马达已解锁" },
					{ "status.max_players_set", "最大玩家数已设置为 " },
					{ "status.lobby_set", "房间已设为 " },
					{ "status.no_lobby", "无法获取当前房间信息" },
					{ "status.error", "失败: " },
					{ "status.fps_limit", "帧率上限已设为 " },
					{ "status.fps_unlimited", "帧率限制已解除 (无限制)" },
					{ "status.quitting", "正在退出到主菜单..." },
					{ "status.loading_main", "正在加载主菜单..." },
					{ "status.reloading", "正在重载场景: " },
					{ "status.saved_pos", "已记录 " },
					{ "status.no_boat", "当前没有船实例" },
					{ "status.grill_unlocked", "烤架已解锁" },
					{ "status.prev_island", "请求切换到上一个岛" },
					{ "status.next_island", "请求切换到下一个岛" },
					{ "status.boat_mult", "船速倍率=" },
					{ "status.slap_speed", "扇巴掌速度倍率=" },
					{ "status.flight_speed", "飞行速度=" },
					{ "status.esp_distance", "透视距离=" },
					{ "status.crosshair_mode", "准星模式: " },
					{ "status.crosshair_style", "准星样式: " },
					{ "status.crosshair_color", "准星颜色: " },
					{ "status.crosshair_size", "准星大小: " },
					{ "status.crosshair_thickness", "准星粗细: " },
					{ "status.crosshair_gap", "准星间距: " },
					{ "status.crosshair_tlength", "T型长度: " },
					{ "status.color_applied", "准星颜色已应用: #" },
					{ "status.invalid_color", "颜色格式错误,请使用 #RRGGBB 格式" },
					{ "status.lang_switched", "已切换为" }
				}
			},
			{
				"en",
				new Dictionary<string, string>
				{
					{ "menu.title", "Boom This HowToFish - By Me0wws" },
					{ "menu.opened", "Menu opened (F1/Insert to close)" },
					{ "menu.closed", "Menu closed" },
					{ "menu.player", "Player: " },
					{ "menu.none", "None" },
					{ "menu.money", "Money: " },
					{ "menu.categories", "Categories" },
					{ "menu.scope", "Scope" },
					{ "menu.scope_desc", "[Local] Current client only\n[Sync] Server replicates\n[Host] Host authority\n[Global] Room-wide rules" },
					{ "menu.close_hint", "F1 / Insert to close" },
					{ "menu.lang", "Language: English" },
					{ "menu.lang_switch", "Switch to Chinese" },
					{ "status.host", "Host/Server" },
					{ "status.client", "Client" },
					{ "status.none", "Not in world" },
					{ "status.godmode", "Global God Mode=" },
					{ "status.oneshot", "Global One-Shot=" },
					{ "status.move", "Move multiplier=" },
					{ "status.jump", "Jump multiplier=" },
					{ "status.move_reset", "Movement reset" },
					{ "tab.player", "Player / Resources" },
					{ "tab.items", "Items / Inventory" },
					{ "tab.teammates", "Teammates / World" },
					{ "tab.combat", "Combat / Fishing" },
					{ "tab.esp", "ESP / Aim / Crosshair" },
					{ "tab.casino", "Casino / Commands" },
					{ "tab.other", "Other / Settings" },
					{ "desc.player", "Money, status, god mode & movement" },
					{ "desc.items", "Spawn items, unlock inventory & edit held" },
					{ "desc.teammates", "Interact, revive, fly, teleport & world progress" },
					{ "desc.combat", "Weapons, attachments, rods, bait & catch" },
					{ "desc.esp", "Entity ESP, aim assist & crosshair" },
					{ "desc.casino", "Roulette, slots & game commands" },
					{ "desc.other", "Max players, lobby settings & more" },
					{ "card.money", "Money" },
					{ "card.money_desc", "Shared server resource, host required" },
					{ "card.vitals", "Health & Status" },
					{ "card.movement", "Movement" },
					{ "card.movement_desc", "Local calculation, position still synced" },
					{ "card.items", "Item Library & Spawn" },
					{ "card.items_desc", "Filter by name, ID, type or value; click to spawn" },
					{ "card.held", "Held Item Edit" },
					{ "card.held_desc", "Currently holding: " },
					{ "card.skins", "Skin ID & Unlock" },
					{ "card.skins_desc", "Skin IDs per item; boat uses item ID 255. Saves locally." },
					{ "card.teleport", "Coordinates & Teleport" },
					{ "card.teleport_desc", "Your character is confirmed & synced by server" },
					{ "card.world", "World Progress" },
					{ "card.world_desc", "Host authority, affects current room & save" },
					{ "card.boat", "Boat Settings" },
					{ "card.teammates", "Teammate Interaction" },
					{ "card.teammates_desc", "Select player to teleport, prank, or give items" },
					{ "card.revive", "Revive & Status" },
					{ "card.slap", "Slap Prank" },
					{ "card.slap_desc", "Pick up downed teammate; auto-slap loops animation without reviving" },
					{ "card.flight", "Flight" },
					{ "card.flight_desc", "WASD to move, Space up, Ctrl down" },
					{ "card.weapon", "Weapon Settings" },
					{ "card.weapon_desc", "Local modifications, shot RPCs synced" },
					{ "card.fishing", "Rod, Bait & Catch" },
					{ "card.equipped", "Current Equipment" },
					{ "card.equipped_desc", "Currently holding: " },
					{ "card.esp", "ESP" },
					{ "card.esp_desc", "Local drawing, doesn't modify entities" },
					{ "card.aim", "Aim Assist" },
					{ "card.aim_desc", "Prioritizes by crosshair angle; teammates use head/camera proxy" },
					{ "card.crosshair", "Crosshair Settings" },
					{ "card.crosshair_desc", "Style, color, size & more" },
					{ "card.roulette", "Roulette Settings" },
					{ "card.roulette_desc", "Results processed by host" },
					{ "card.slots", "Slots Prizes" },
					{ "card.slots_desc", "Set next prize item & skin" },
					{ "card.commands", "Game Commands" },
					{ "card.commands_desc", "Host commands; type full command to execute" },
					{ "card.commands_help", "Command Help" },
					{ "card.max_players", "Max Players" },
					{ "card.max_players_desc", "Change room max players, host only. Requires re-creating room." },
					{ "card.lobby", "Lobby Settings" },
					{ "card.lobby_desc", "Quick toggle room public/private" },
					{ "card.performance", "Performance" },
					{ "card.performance_desc", "Adjust game performance options" },
					{ "card.quick", "Quick Actions" },
					{ "card.quick_desc", "Common game operations" },
					{ "btn.add", "[Host] Add" },
					{ "btn.remove", "[Host] Remove" },
					{ "btn.set", "[Host] Set" },
					{ "btn.fill_vitals", "[Host] Full health/food, clear poison/fire" },
					{ "btn.godmode_global", "[Host/Global] God Mode: " },
					{ "btn.oneshot", "[Host/Global] One-Shot: " },
					{ "btn.apply", "Apply" },
					{ "btn.reset", "Reset" },
					{ "btn.refresh_items", "Refresh All Items" },
					{ "btn.clear_filter", "Clear Filter" },
					{ "btn.unlock_baits", "[Sync/Self] Unlock all baits" },
					{ "btn.unlock_pockets", "[Host/Self] Unlock all pockets" },
					{ "btn.spawn", "[Sync] Spawn to hand" },
					{ "btn.prev", "Prev" },
					{ "btn.next", "Next" },
					{ "btn.set_weight", "[Host] Set Weight" },
					{ "btn.raw", "Raw" },
					{ "btn.perfect", "Perfect" },
					{ "btn.burnt", "Burnt" },
					{ "btn.next_skin", "[Sync] Next Skin" },
					{ "btn.kill_mult", "[Sync] Kill Multiplier" },
					{ "btn.bet_mult", "[Host] Bet Multiplier" },
					{ "btn.unlock_all_skins", "[Local Save] Unlock all skins" },
					{ "btn.unlock_clothes", "[Local/Session] Unlock all clothes" },
					{ "btn.unlock_skin", "Unlock Skin" },
					{ "btn.unlock", "[Local Save] Unlock" },
					{ "btn.teleport", "[Sync] Teleport" },
					{ "btn.save_pos", "Save Position" },
					{ "btn.return_pos", "[Sync] Return" },
					{ "btn.forward", "[Sync] Forward 10m" },
					{ "btn.to_boat", "[Sync] To Boat" },
					{ "btn.unlock_boat", "[Host] Unlock Boat/Radar/Max Motor" },
					{ "btn.unlock_grill", "[Host] Unlock Grill" },
					{ "btn.prev_island", "[Host/Global] Prev Island" },
					{ "btn.next_island", "[Host/Global] Next Island" },
					{ "btn.apply_mult", "Apply Multiplier" },
					{ "btn.pull_here", "[Sync] Pull to me" },
					{ "btn.go_to_teammate", "[Sync] Go to teammate" },
					{ "btn.throw_forward", "[Sync] Throw forward 10m" },
					{ "btn.give_item", "[Sync] Give item to teammate" },
					{ "btn.revive", "[Sync] Revive selected" },
					{ "btn.revive_all", "[Sync] Revive all" },
					{ "btn.clear_self", "[Host] Clear self" },
					{ "btn.clear_teammate", "[Host] Clear teammate" },
					{ "btn.apply_rod", "Apply Rod Settings" },
					{ "btn.apply_catch", "Apply Catch Settings" },
					{ "btn.max_attachments", "[Host/Sync] Max Attachments" },
					{ "btn.max_bullets", "[Host/Sync] Max Bullets" },
					{ "btn.max_melee", "[Host/Sync] Max Melee" },
					{ "btn.apply_aim", "Apply Aim Settings" },
					{ "btn.apply_roulette", "Apply Roulette Settings" },
					{ "btn.set_prize", "[Host] Set Prize" },
					{ "btn.random_prize", "[Host] Random Prize" },
					{ "btn.execute", "[Host] Execute" },
					{ "btn.public", "Set Public" },
					{ "btn.private", "Set Private" },
					{ "btn.unlimited", "Unlimited" },
					{ "btn.quit", "Quit to Menu" },
					{ "btn.reload", "Reload Scene" },
					{ "toggle.godmode", "[Host/Self] Personal God Mode" },
					{ "toggle.keep_full", "[Host/Self] Keep Full" },
					{ "toggle.infinite_ammo", "[Local] Infinite Ammo" },
					{ "toggle.no_spread", "[Local] No Spread/Recoil" },
					{ "toggle.rapid_fire", "[Local] Rapid Fire ×0.12" },
					{ "toggle.skip_bolt", "[Local] Skip Bolt/Anim" },
					{ "toggle.force_auto", "[Local] Force Full Auto" },
					{ "toggle.custom_weapon", "[Local/Sync] Custom Weapon" },
					{ "toggle.fast_fishing", "[Local/Sync] Fast Fishing ×6" },
					{ "toggle.instant_bite", "[Host] Instant Bite" },
					{ "toggle.custom_rod", "[Local/Sync] Custom Rod" },
					{ "toggle.force_catch", "[Host] Force Catch" },
					{ "toggle.shiny", "Force Shiny" },
					{ "toggle.esp", "[Local] ESP" },
					{ "toggle.players", "Players" },
					{ "toggle.alive", "Alive" },
					{ "toggle.dead", "Dead" },
					{ "toggle.items", "Items" },
					{ "toggle.boxes", "Boxes" },
					{ "toggle.corners", "Corner Boxes" },
					{ "toggle.healthbars", "Health Bars" },
					{ "toggle.snaplines", "Snaplines" },
					{ "toggle.strong_aim", "[Local] Strong Aim" },
					{ "toggle.no_ads", "[Local] No ADS Required" },
					{ "toggle.sticky", "[Local] Sticky Target" },
					{ "toggle.predict", "[Local] Prediction" },
					{ "toggle.magic", "[Local/Sync] Magic Bullet" },
					{ "toggle.ignore", "Ignore Obstacles" },
					{ "toggle.outline", "Show Outline" },
					{ "toggle.spread_ring", "Show Spread Ring" },
					{ "toggle.roulette_win", "[Host] Always Win" },
					{ "toggle.roulette_payout", "[Host] Custom Payout" },
					{ "toggle.auto_slap", "[Sync] Auto Slap" },
					{ "toggle.fast_slap", "[Local/Sync] Fast Slap" },
					{ "toggle.flight", "[Local] Flight" },
					{ "toggle.boat_boost", "[Host/Global] Boat Boost" },
					{ "label.move_mult", "Move Multiplier" },
					{ "label.jump_mult", "Jump Multiplier" },
					{ "label.items_count", "Items: {0} match, {1} pages. Click to spawn free." },
					{ "label.page", "Page {0} / {1}" },
					{ "label.item_id", "Item ID" },
					{ "label.skin_id", "Skin ID" },
					{ "label.skins_count", "Skins: {0} match. Format: Item ID / Skin ID / Name / Rarity" },
					{ "label.coords", "Coords: X {0}  Y {1}  Z {2}" },
					{ "label.selected", "Selected: " },
					{ "label.downed", " [Downed]" },
					{ "label.holding", "● Holding selected" },
					{ "label.waiting", "○ Waiting for selected" },
					{ "label.speed", "Speed" },
					{ "label.speed_mult", "Speed Multiplier" },
					{ "label.sniper_tip", "Sniper tip: Skip Bolt + Full Auto + Rapid Fire ×0.12" },
					{ "label.delay", "Delay×" },
					{ "label.speed_param", "Speed×" },
					{ "label.count", "Count" },
					{ "label.spread", "Spread×" },
					{ "label.recoil", "Recoil×" },
					{ "label.damage", "Damage×" },
					{ "label.reel", "Reel×" },
					{ "label.step", "Step×" },
					{ "label.throw", "Throw×" },
					{ "label.weight", "Weight/Size" },
					{ "label.ammo", "Ammo: " },
					{ "label.damage_colon", " | Damage: " },
					{ "label.rod_detected", "Fishing rod detected." },
					{ "label.distance", "Distance" },
					{ "label.box_style", "Box Style: " },
					{ "label.esp_color_tip", "Colors: Cyan=Player, Green=Alive, Red=Dead, Yellow=Item; shows name, distance & HP/weight." },
					{ "label.target_type", "Target Type: " },
					{ "label.aim_params", "Distance / Acquire / Speed" },
					{ "label.sharpness", "Sharpness / Prediction" },
					{ "label.magic_tip", "Magic Bullet uses target type above; no need to aim." },
					{ "label.mode", "Mode" },
					{ "label.current", "Current: " },
					{ "label.style", "Style" },
					{ "label.current_style", "Current Style: " },
					{ "label.color", "Color" },
					{ "label.custom", "Custom(#)" },
					{ "label.size", "Size" },
					{ "label.thickness", "Thickness" },
					{ "label.gap", "Gap" },
					{ "label.t_length", "T Length" },
					{ "label.current_color", "Current Color: " },
					{ "label.red_black", "Red/Black" },
					{ "label.green", "Green" },
					{ "label.commands_help_title", "All Commands & Description:" },
					{ "label.commands_list", "spawn / spawndead / spawndrip / grill / boat / addmoney / removemoney / nextisland / previsland / godmode / oneshot / killboss / allskins / noskins / finishgame / unlockachievements / lockachievements" },
					{ "label.command_example", "Example: /spawn fishingrod   /spawndead piranha   /addmoney   /godmode" },
					{ "label.commands_help_detail", "┌─────────────────────────────────────────────────────────┐\n│ Command                        │ Description              │\n├─────────────────────────────────────────────────────────┤\n│ spawn <item>                   │ Spawn item               │\n│ spawndead <creature>           │ Spawn dead creature      │\n│ spawndrip <creature>           │ Spawn shiny creature     │\n│ grill                          │ Unlock grill             │\n│ boat                           │ Unlock boat/radar/motor  │\n│ addmoney <amount>              │ Add money                │\n│ removemoney <amount>           │ Remove money             │\n│ nextisland                     │ Next island              │\n│ previsland                     │ Previous island          │\n│ godmode                        │ Toggle God Mode          │\n│ oneshot                        │ Toggle One-Shot          │\n│ killboss                       │ Kill boss                │\n│ allskins                       │ Unlock all skins         │\n│ noskins                        │ Remove all skins         │\n│ finishgame                     │ Finish game              │\n│ unlockachievements             │ Unlock all achievements  │\n│ lockachievements               │ Lock all achievements    │\n└─────────────────────────────────────────────────────────┘" },
					{ "label.max_players", "Max Players" },
					{ "label.current_fmt", "(Current: {0})" },
					{ "label.max_players_tip", "Note: Requires re-creating room (quit to menu and re-enter) to take effect." },
					{ "label.lobby_status", "Status: " },
					{ "label.public", "Public" },
					{ "label.private", "Private" },
					{ "label.fps_limit", "FPS Limit" },
					{ "label.current_fps", "Current FPS: {0}" },
					{ "style.dot", "Dot" },
					{ "style.cross", "Cross" },
					{ "style.t", "T-Shape" },
					{ "style.circle", "Circle" },
					{ "style.dot_circle", "Dot+Circle" },
					{ "style.crosshair", "Crosshair" },
					{ "color.white", "White" },
					{ "color.red", "Red" },
					{ "color.green", "Green" },
					{ "color.blue", "Blue" },
					{ "color.cyan", "Cyan" },
					{ "color.yellow", "Yellow" },
					{ "status.host_required", "Host required with local player spawned" },
					{ "status.added_money", "Added money " },
					{ "status.removed_money", "Removed money " },
					{ "status.money_set", "Money set to " },
					{ "status.vitals_filled", "Health/food full, poison/fire cleared" },
					{ "status.teleporting", "Teleporting " },
					{ "status.to", " -> " },
					{ "status.invalid_id", "Invalid item ID: " },
					{ "status.giving", "Giving to " },
					{ "status.no_revive_target", "No revivable target" },
					{ "status.reviving", "Reviving " },
					{ "status.revive_all", "Revived all: " },
					{ "status.cleared", "Cleared: " },
					{ "status.aim_applied", "Aim settings applied" },
					{ "status.weapon_applied", "Weapon settings applied" },
					{ "status.rod_applied", "Rod settings applied" },
					{ "status.catch_set", "Catch set to " },
					{ "status.roulette_applied", "Roulette settings applied" },
					{ "status.invalid_skin", "Invalid item ID or skin index" },
					{ "status.slot_prize", "Slot prize set: " },
					{ "status.random_prize", "Slot prize randomized" },
					{ "status.command_submitted", "Command submitted: " },
					{ "status.command_invalid", "Invalid command: " },
					{ "status.items_refreshed", "Items refreshed, " },
					{ "status.skin_not_found", "Skin not found" },
					{ "status.skin_unlocked", "Skin unlocked: " },
					{ "status.all_skins_unlocked", "Skins unlocked, " },
					{ "status.clothes_unlocked", "All clothes unlocked" },
					{ "status.server_required", "Server & local player required" },
					{ "status.spawning", "Spawning " },
					{ "status.baits_unlocked", "Baits unlocked, " },
					{ "status.pockets_unlocked", "Pockets set to 5" },
					{ "status.weight_set", "Weight set to " },
					{ "status.cookness_set", "Cookness set to " },
					{ "status.no_skin", "No skin available" },
					{ "status.skin_switched", "Skin switched to " },
					{ "status.kill_mult_set", "Kill multiplier set: " },
					{ "status.bet_mult_set", "Bet multiplier set to " },
					{ "status.attachments_applied", "Attachments applied: " },
					{ "status.bullet_upgraded", "Bullet upgrades: " },
					{ "status.melee_upgraded", "Melee upgrades: " },
					{ "status.teleporting_to", "Teleporting to " },
					{ "status.boat_required", "Host & boat required" },
					{ "status.boat_unlocked", "Boat/radar/motor unlocked" },
					{ "status.max_players_set", "Max players set to " },
					{ "status.lobby_set", "Lobby set to " },
					{ "status.no_lobby", "Unable to get lobby info" },
					{ "status.error", "Error: " },
					{ "status.fps_limit", "FPS limit set to " },
					{ "status.fps_unlimited", "FPS unlimited" },
					{ "status.quitting", "Quitting to menu..." },
					{ "status.loading_main", "Loading main menu..." },
					{ "status.reloading", "Reloading: " },
					{ "status.saved_pos", "Saved " },
					{ "status.no_boat", "No boat instance" },
					{ "status.grill_unlocked", "Grill unlocked" },
					{ "status.prev_island", "Switching to previous island" },
					{ "status.next_island", "Switching to next island" },
					{ "status.boat_mult", "Boat multiplier=" },
					{ "status.slap_speed", "Slap speed=" },
					{ "status.flight_speed", "Flight speed=" },
					{ "status.esp_distance", "ESP distance=" },
					{ "status.crosshair_mode", "Crosshair mode: " },
					{ "status.crosshair_style", "Crosshair style: " },
					{ "status.crosshair_color", "Crosshair color: " },
					{ "status.crosshair_size", "Crosshair size: " },
					{ "status.crosshair_thickness", "Crosshair thickness: " },
					{ "status.crosshair_gap", "Crosshair gap: " },
					{ "status.crosshair_tlength", "T-Length: " },
					{ "status.color_applied", "Color applied: #" },
					{ "status.invalid_color", "Invalid color format, use #RRGGBB" },
					{ "status.lang_switched", "Switched to" }
				}
			}
		};

		public const string PluginGuid = "codex.howtofish.trainer";

		public const string PluginName = "Boom This HowToFish - By Me0wws";

		public const string PluginVersion = "1.3";

		private Harmony _harmony;

		private Rect _window = new Rect(30f, 30f, 1180f, 800f);

		private Vector2 _mainScroll;

		private int _itemPage;

		private bool _menuVisible;

		private int _tab;

		private bool _selfGod;

		private bool _keepVitalsFull;

		private bool _infiniteAmmo;

		private bool _noSpread;

		private bool _rapidFire;

		private bool _skipBoltAction;

		private bool _forceFullAuto;

		private bool _fastFishing;

		private bool _strongAim;

		private bool _instantBite;

		private bool _boatBoost;

		private bool _flight;

		private bool _flightWasActive;

		private bool _aimWithoutAds;

		private bool _aimTeammates;

		private bool _aimAliveCreatures = true;

		private bool _aimDeadCreatures;

		private bool _aimItems;

		private bool _aimIgnoreObstacles;

		private bool _aimStickyTarget = true;

		private bool _aimPredictMovement = true;

		private bool _magicBullet;

		private bool _customWeapon;

		private bool _customRod;

		private bool _espEnabled;

		private bool _espPlayers = true;

		private bool _espAliveCreatures = true;

		private bool _espDeadCreatures;

		private bool _espItems;

		private bool _espBoxes = true;

		private bool _espCornerBoxes;

		private bool _espHealthBars = true;

		private bool _espSnaplines;

		private bool _rouletteAlwaysWin;

		private bool _customRoulettePayout;

		private bool _forceCatchItem;

		private bool _forceCatchShiny;

		private bool _autoSlap;

		private bool _fastSlap;

		private int _maxPlayers = 8;

		private string _maxPlayersText = "8";

		private string _fpsLimitText = "60";

		private string _crosshairModeText = "跟随枪口";

		private string _crosshairColorText = "#FFFFFF";

		private string _crosshairSizeText = "10";

		private string _crosshairThicknessText = "2";

		private string _crosshairGapText = "4";

		private string _crosshairTLengthText = "15";

		private float _moveMultiplier = 1f;

		private float _jumpMultiplier = 1f;

		private float _boatMultiplier = 1f;

		private float _flightSpeed = 15f;

		private float _aimDistance = 200f;

		private float _aimAcquireAngle = 60f;

		private float _aimRotationSpeed = 1440f;

		private float _aimTrackingSharpness = 80f;

		private float _aimPredictionFactor = 1f;

		private float _weaponDelayMultiplier = 1f;

		private float _weaponProjectileSpeedMultiplier = 1f;

		private float _weaponSpreadMultiplier = 1f;

		private float _weaponRecoilMultiplier = 1f;

		private float _weaponDamageMultiplier = 1f;

		private int _weaponProjectileCount = 1;

		private float _rodReelMultiplier = 1f;

		private float _rodStepMultiplier = 1f;

		private float _rodThrowMultiplier = 1f;

		private float _espDistance = 250f;

		private float _rouletteRedBlackMultiplier = 2f;

		private float _rouletteGreenMultiplier = 35f;

		private float _catchWeight = 1f;

		private string _moneyText = "99999";

		private string _moveText = "1";

		private string _jumpText = "1";

		private string _boatText = "1";

		private string _flightSpeedText = "15";

		private string _aimDistanceText = "200";

		private string _aimAngleText = "60";

		private string _aimSpeedText = "1440";

		private string _aimSharpnessText = "80";

		private string _aimPredictionText = "1";

		private string _weaponDelayText = "1";

		private string _weaponProjectileSpeedText = "1";

		private string _weaponProjectileCountText = "1";

		private string _weaponSpreadText = "1";

		private string _weaponRecoilText = "1";

		private string _weaponDamageText = "1";

		private string _rodReelText = "1";

		private string _rodStepText = "1";

		private string _rodThrowText = "1";

		private string _espDistanceText = "250";

		private string _rouletteRedBlackText = "2";

		private string _rouletteGreenText = "35";

		private string _slotItemIdText = "0";

		private string _slotSkinText = "0";

		private string _catchItemIdText = "0";

		private string _catchWeightText = "1";

		private string _teammateItemIdText = "0";

		private string _itemWeightText = "1";

		private string _itemMultiplierText = "5";

		private string _betMultiplierText = "5";

		private string _teleportX = "0";

		private string _teleportY = "0";

		private string _teleportZ = "0";

		private string _itemFilter = "";

		private string _skinFilter = "";

		private string _skinItemIdText = "0";

		private string _skinIndexText = "0";

		private string _slapSpeedText = "4";

		private string _command = "/addmoney";

		private string _status = "按 F1 或 Insert 打开修改器";

		private Vector3 _savedPosition;

		private bool _hasSavedPosition;

		private CursorLockMode _previousCursorLock;

		private bool _previousCursorVisible;

		private PlayerMovement _cachedMovement;

		private MovementDefaults _movementDefaults;

		private PlayerAimAssist _cachedAim;

		private AimDefaults _aimDefaults;

		private readonly Dictionary<EntityId, WeaponDefaults> _weaponDefaults = new Dictionary<EntityId, WeaponDefaults>();

		private readonly Dictionary<EntityId, RodDefaults> _rodDefaults = new Dictionary<EntityId, RodDefaults>();

		private readonly Dictionary<EntityId, BoatMotorDefaults> _boatMotorDefaults = new Dictionary<EntityId, BoatMotorDefaults>();

		private readonly Dictionary<EntityId, BaitDefaults> _baitDefaults = new Dictionary<EntityId, BaitDefaults>();

		private List<Item> _items = new List<Item>();

		private float _nextItemRefresh;

		private float _nextErrorLog;

		private float _nextMenuHotkeyTime;

		private Player _selectedTeammate;

		private int _skinPage;

		private float _slapSpeed = 4f;

		private DeadPlayer _speedModifiedCorpse;

		private float _defaultResurrectSpeed;

		private DeadPlayer _activeSlapCorpse;

		private int _lastSlapCycle = -1;

		private float _nextSlapRpcTime;

		private float _slapCycleStartTime;

		private Transform _lockedAimTarget;

		private readonly List<AimCandidate> _aimCandidates = new List<AimCandidate>();

		private GUIStyle _espStyle;

		private Texture2D _espTexture;

		private GUISkin _uiSkin;

		private GUIStyle _windowStyle;

		private GUIStyle _headerStyle;

		private GUIStyle _sidebarStyle;

		private GUIStyle _contentStyle;

		private GUIStyle _footerStyle;

		private GUIStyle _navStyle;

		private GUIStyle _navActiveStyle;

		private GUIStyle _titleStyle;

		private GUIStyle _pageTitleStyle;

		private GUIStyle _sectionTitleStyle;

		private GUIStyle _mutedStyle;

		private GUIStyle _statusStyle;

		private GUIStyle _badgeStyle;

		private GUIStyle _cardStyle;

		private readonly List<Texture2D> _uiTextures = new List<Texture2D>();

		private bool _isResizing;

		private Vector2 _resizeStartMouse;

		private Rect _resizeStartRect;

		private static readonly FieldInfo WalkSpeedField = AccessTools.Field(typeof(PlayerMovement), "_walkSpeed");

		private static readonly FieldInfo SprintSpeedField = AccessTools.Field(typeof(PlayerMovement), "_sprintSpeed");

		private static readonly FieldInfo JumpForceField = AccessTools.Field(typeof(PlayerMovement), "_jumpForce");

		private static readonly FieldInfo WeaponShotDelayField = AccessTools.Field(typeof(Weapon), "_timeBetweenShots");

		private static readonly FieldInfo WeaponSpreadField = AccessTools.Field(typeof(Weapon), "_spread");

		private static readonly FieldInfo WeaponRecoilField = AccessTools.Field(typeof(Weapon), "_recoilKnockback");

		private static readonly FieldInfo WeaponProjectileSpeedField = AccessTools.Field(typeof(Weapon), "_projSpeed");

		private static readonly FieldInfo WeaponProjectileCountField = AccessTools.Field(typeof(Weapon), "_projectileCountPerShot");

		private static readonly FieldInfo WeaponInfoField = AccessTools.Field(typeof(Weapon), "_weaponInfo");

		private static readonly FieldInfo WeaponFullAutoField = AccessTools.Field(typeof(Weapon), "_fullAuto");

		private static readonly FieldInfo WeaponNoShootDuringAnimationField = AccessTools.Field(typeof(Weapon), "_noShootingDuringShootAnim");

		private static readonly FieldInfo WeaponNoQueueingShotsField = AccessTools.Field(typeof(Weapon), "_noQueueingShots");

		private static readonly PropertyInfo WeaponAmmoProperty = AccessTools.Property(typeof(Weapon), "Ammo");

		private static readonly FieldInfo RodReelSpeedField = AccessTools.Field(typeof(FishingRod), "_holdReelSpeed");

		private static readonly FieldInfo RodReelStepField = AccessTools.Field(typeof(FishingRod), "_lineReelStepLength");

		private static readonly FieldInfo RodThrowSpeedField = AccessTools.Field(typeof(FishingRod), "_lineThrowSpeed");

		private static readonly FieldInfo BoatMotorsField = AccessTools.Field(typeof(Boat), "_motors");

		private static readonly PropertyInfo BoatMotorForceProperty = AccessTools.Property(typeof(BoatMotor), "Force");

		private static readonly FieldInfo AimDistanceField = AccessTools.Field(typeof(PlayerAimAssist), "_maxTargetDistance");

		private static readonly FieldInfo AimAcquireAngleField = AccessTools.Field(typeof(PlayerAimAssist), "_adsAcquireAngle");

		private static readonly FieldInfo AimBreakAngleField = AccessTools.Field(typeof(PlayerAimAssist), "_trackingBreakAngle");

		private static readonly FieldInfo AimRotationSpeedField = AccessTools.Field(typeof(PlayerAimAssist), "_maxRotationSpeed");

		private static readonly FieldInfo AimSharpnessField = AccessTools.Field(typeof(PlayerAimAssist), "_trackingSharpness");

		private static readonly MethodInfo AimCacheSettingsMethod = AccessTools.Method(typeof(PlayerAimAssist), "CacheSettings", (Type[])null, (Type[])null);

		private static readonly FieldInfo DeadPlayerResurrectSpeedField = AccessTools.Field(typeof(DeadPlayer), "_resurrectSpeed");

		private static readonly FieldInfo DeadPlayerResurrectPercentField = AccessTools.Field(typeof(DeadPlayer), "_resurrectPercent");

		private static readonly FieldInfo DeadPlayerIsResurrectingField = AccessTools.Field(typeof(DeadPlayer), "_isResurrecting");

		private static readonly MethodInfo DeadPlayerStartSlapMethod = AccessTools.Method(typeof(DeadPlayer), "StartSlapAnimation", (Type[])null, (Type[])null);

		private static readonly MethodInfo DeadPlayerUpdateSlapMethod = AccessTools.Method(typeof(DeadPlayer), "UpdateSlapHandAnimation", (Type[])null, (Type[])null);

		private static readonly MethodInfo DeadPlayerStartSlapReturnMethod = AccessTools.Method(typeof(DeadPlayer), "StartSlapHandReturn", (Type[])null, (Type[])null);

		private static readonly FieldInfo BaitCatchTimeField = AccessTools.Field(typeof(BaitInfo), "_catchTimeMinMax");

		private static readonly FieldInfo BaitLostChanceField = AccessTools.Field(typeof(BaitInfo), "_lostOnBaitChance");

		private static readonly FieldInfo BaitRequireReelingField = AccessTools.Field(typeof(BaitInfo), "_requireReelingToCatch");

		private static readonly FieldInfo CasinoBetColorField = AccessTools.Field(typeof(CasinoManager), "_curBetColor");

		internal bool SelfGodEnabled => _selfGod;

		internal bool StrongAimEnabled => _strongAim;

		internal bool AimWithoutAdsEnabled => _strongAim && _aimWithoutAds;

		internal bool ForceCatchItemEnabled => _forceCatchItem;

		internal bool ForceCatchShinyEnabled => _forceCatchShiny;

		internal float ForcedCatchWeight => _catchWeight;

		internal bool RouletteAlwaysWinEnabled => _rouletteAlwaysWin;

		internal bool CustomRoulettePayoutEnabled => _customRoulettePayout;

		private bool IsHost => Object.op_Implicit((Object)(object)Server.Instance) && ((NetworkBehaviour)Server.Instance).IsServerInitialized;

		private bool HasServerConnection => Object.op_Implicit((Object)(object)Server.Instance) && ((NetworkBehaviour)Server.Instance).IsClientInitialized;

		private ConfigFile _config => ((BaseUnityPlugin)this).Config;

		[DllImport("user32.dll")]
		private static extern short GetAsyncKeyState(int virtualKey);

		private void Awake()
		{
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Expected O, but got Unknown
			Instance = this;
			_maxPlayers = 8;
			_maxPlayersText = _maxPlayers.ToString();
			_fpsLimitText = "60";
			LoadConfig();
			InitializeCrosshair();
			_harmony = new Harmony("codex.howtofish.trainer");
			_harmony.PatchAll(typeof(TrainerPlugin).Assembly);
			ClientSettings.ToggleCheats(true);
			((BaseUnityPlugin)this).Logger.LogInfo((object)"Boom This HowToFish - By Me0wws v1.3 已加载; F1 或 Insert 切换菜单。");
		}

		private void OnDestroy()
		{
			RestoreFlight();
			RestoreMovement();
			RestoreAllWeapons();
			RestoreAllRods();
			RestoreAim();
			RestoreBoatMotors();
			RestoreBaits();
			RestoreSlapSpeed();
			if (Object.op_Implicit((Object)(object)_espTexture))
			{
				Object.Destroy((Object)(object)_espTexture);
			}
			if (Object.op_Implicit((Object)(object)_uiSkin))
			{
				Object.Destroy((Object)(object)_uiSkin);
			}
			foreach (Texture2D uiTexture in _uiTextures)
			{
				if (Object.op_Implicit((Object)(object)uiTexture))
				{
					Object.Destroy((Object)(object)uiTexture);
				}
			}
			_uiTextures.Clear();
			Harmony harmony = _harmony;
			if (harmony != null)
			{
				harmony.UnpatchSelf();
			}
			Instance = null;
		}

		private void Update()
		{
			if (MenuHotkeyPressed() && Time.unscaledTime >= _nextMenuHotkeyTime)
			{
				_nextMenuHotkeyTime = Time.unscaledTime + 0.35f;
				ToggleMenu();
			}
			try
			{
				ClientSettings.ToggleCheats(true);
				ApplyContinuousOptions();
			}
			catch (Exception ex)
			{
				if (Time.unscaledTime >= _nextErrorLog)
				{
					_nextErrorLog = Time.unscaledTime + 5f;
					((BaseUnityPlugin)this).Logger.LogWarning((object)ex);
				}
			}
		}

		private static bool MenuHotkeyPressed()
		{
			try
			{
				short asyncKeyState = GetAsyncKeyState(112);
				short asyncKeyState2 = GetAsyncKeyState(45);
				return Application.isFocused && ((asyncKeyState & 1) != 0 || (asyncKeyState2 & 1) != 0);
			}
			catch
			{
				return false;
			}
		}

		private void ToggleMenu()
		{
			//IL_0044: 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_0021: Unknown result type (might be due to invalid IL or missing references)
			_menuVisible = !_menuVisible;
			if (_menuVisible)
			{
				_previousCursorLock = Cursor.lockState;
				_previousCursorVisible = Cursor.visible;
				Cursor.lockState = (CursorLockMode)0;
				Cursor.visible = true;
			}
			else
			{
				Cursor.lockState = _previousCursorLock;
				Cursor.visible = _previousCursorVisible;
			}
			SetStatus(_menuVisible ? T("menu.opened") : T("menu.closed"));
		}

		private void ApplyContinuousOptions()
		{
			Player localPlayer = Player.LocalPlayer;
			if (!Object.op_Implicit((Object)(object)localPlayer))
			{
				RestoreFlight();
				RestoreMovement();
				RestoreSlapSpeed();
				return;
			}
			ApplyMovement(localPlayer.Movement);
			ApplyAim(localPlayer.AimAssist);
			ApplyBoatBoost();
			ApplyBaitOptions();
			if (_keepVitalsFull && IsHost && Object.op_Implicit((Object)(object)localPlayer.Vitals))
			{
				localPlayer.Vitals.Heal(1000);
				localPlayer.Vitals.RestoreFullness(1000);
				localPlayer.Vitals._syncedPoison.Value = 0;
				localPlayer.Vitals._syncedFire.Value = 0;
			}
			Item val = (Object.op_Implicit((Object)(object)localPlayer.Holding) ? localPlayer.Holding.HeldItem : null);
			ApplyWeapon(Object.op_Implicit((Object)(object)val) ? val.Weapon : null);
			ApplyRod(Object.op_Implicit((Object)(object)val) ? val.FishingRod : null);
			ApplySlapSpeed((DeadPlayer)(object)((val is DeadPlayer) ? val : null));
		}

		private void ApplyMovement(PlayerMovement movement)
		{
			if (!Object.op_Implicit((Object)(object)movement))
			{
				RestoreMovement();
				return;
			}
			if ((Object)(object)_cachedMovement != (Object)(object)movement)
			{
				RestoreMovement();
				_cachedMovement = movement;
				_movementDefaults = new MovementDefaults
				{
					Walk = GetFloat(WalkSpeedField, movement, 1f),
					Sprint = GetFloat(SprintSpeedField, movement, 1f),
					Jump = GetFloat(JumpForceField, movement, 1f)
				};
			}
			SetFloat(WalkSpeedField, movement, _movementDefaults.Walk * _moveMultiplier);
			SetFloat(SprintSpeedField, movement, _movementDefaults.Sprint * _moveMultiplier);
			SetFloat(JumpForceField, movement, _movementDefaults.Jump * _jumpMultiplier);
		}

		private void RestoreMovement()
		{
			if (Object.op_Implicit((Object)(object)_cachedMovement))
			{
				SetFloat(WalkSpeedField, _cachedMovement, _movementDefaults.Walk);
				SetFloat(SprintSpeedField, _cachedMovement, _movementDefaults.Sprint);
				SetFloat(JumpForceField, _cachedMovement, _movementDefaults.Jump);
			}
			_cachedMovement = null;
		}

		private void ApplyAim(PlayerAimAssist aim)
		{
			if (!Object.op_Implicit((Object)(object)aim))
			{
				RestoreAim();
				return;
			}
			if ((Object)(object)_cachedAim != (Object)(object)aim)
			{
				RestoreAim();
				_cachedAim = aim;
				_aimDefaults = new AimDefaults
				{
					Distance = GetFloat(AimDistanceField, aim, 60f),
					AcquireAngle = GetFloat(AimAcquireAngleField, aim, 18f),
					BreakAngle = GetFloat(AimBreakAngleField, aim, 40f),
					RotationSpeed = GetFloat(AimRotationSpeedField, aim, 120f),
					Sharpness = GetFloat(AimSharpnessField, aim, 10f)
				};
			}
			SetFloat(AimDistanceField, aim, _strongAim ? _aimDistance : _aimDefaults.Distance);
			SetFloat(AimAcquireAngleField, aim, _strongAim ? _aimAcquireAngle : _aimDefaults.AcquireAngle);
			SetFloat(AimBreakAngleField, aim, _strongAim ? 100f : _aimDefaults.BreakAngle);
			SetFloat(AimRotationSpeedField, aim, _strongAim ? _aimRotationSpeed : _aimDefaults.RotationSpeed);
			SetFloat(AimSharpnessField, aim, _strongAim ? _aimTrackingSharpness : _aimDefaults.Sharpness);
			if (AimCacheSettingsMethod != null)
			{
				AimCacheSettingsMethod.Invoke(aim, null);
			}
		}

		private void RestoreAim()
		{
			if (Object.op_Implicit((Object)(object)_cachedAim))
			{
				SetFloat(AimDistanceField, _cachedAim, _aimDefaults.Distance);
				SetFloat(AimAcquireAngleField, _cachedAim, _aimDefaults.AcquireAngle);
				SetFloat(AimBreakAngleField, _cachedAim, _aimDefaults.BreakAngle);
				SetFloat(AimRotationSpeedField, _cachedAim, _aimDefaults.RotationSpeed);
				SetFloat(AimSharpnessField, _cachedAim, _aimDefaults.Sharpness);
				if (AimCacheSettingsMethod != null)
				{
					AimCacheSettingsMethod.Invoke(_cachedAim, null);
				}
			}
			_cachedAim = null;
		}

		private void ApplyBoatBoost()
		{
			//IL_0085: 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_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			Boat boat = BoatManager.Boat;
			if (!Object.op_Implicit((Object)(object)boat) || !IsHost)
			{
				RestoreBoatMotors();
			}
			else
			{
				if (!(BoatMotorsField?.GetValue(boat) is IEnumerable enumerable))
				{
					return;
				}
				foreach (object item in enumerable)
				{
					BoatMotor val = (BoatMotor)((item is BoatMotor) ? item : null);
					if (Object.op_Implicit((Object)(object)val))
					{
						EntityId entityId = ((Object)val).GetEntityId();
						if (!_boatMotorDefaults.ContainsKey(entityId))
						{
							_boatMotorDefaults[entityId] = new BoatMotorDefaults
							{
								Motor = val,
								Force = val.Force
							};
						}
						BoatMotorDefaults boatMotorDefaults = _boatMotorDefaults[entityId];
						if (BoatMotorForceProperty != null)
						{
							BoatMotorForceProperty.SetValue(val, boatMotorDefaults.Force * (_boatBoost ? _boatMultiplier : 1f), null);
						}
					}
				}
			}
		}

		private void RestoreBoatMotors()
		{
			foreach (BoatMotorDefaults value in _boatMotorDefaults.Values)
			{
				if (Object.op_Implicit((Object)(object)value.Motor) && BoatMotorForceProperty != null)
				{
					BoatMotorForceProperty.SetValue(value.Motor, value.Force, null);
				}
			}
			_boatMotorDefaults.Clear();
		}

		private void ApplyBaitOptions()
		{
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			if (!IsHost || !_instantBite)
			{
				RestoreBaits();
				return;
			}
			foreach (BaitInfo allBait in GameInfo.AllBaits)
			{
				if (Object.op_Implicit((Object)(object)allBait))
				{
					EntityId entityId = ((Object)allBait).GetEntityId();
					if (!_baitDefaults.ContainsKey(entityId))
					{
						_baitDefaults[entityId] = new BaitDefaults
						{
							Bait = allBait,
							CatchTime = (Vector2)BaitCatchTimeField.GetValue(allBait),
							LostChance = GetFloat(BaitLostChanceField, allBait, 0f),
							RequireReeling = (bool)BaitRequireReelingField.GetValue(allBait)
						};
					}
					BaitCatchTimeField.SetValue(allBait, (object)new Vector2(0.1f, 0.2f));
					BaitLostChanceField.SetValue(allBait, 0f);
					BaitRequireReelingField.SetValue(allBait, false);
				}
			}
		}

		private void RestoreBaits()
		{
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			foreach (BaitDefaults value in _baitDefaults.Values)
			{
				if (Object.op_Implicit((Object)(object)value.Bait))
				{
					BaitCatchTimeField.SetValue(value.Bait, value.CatchTime);
					BaitLostChanceField.SetValue(value.Bait, value.LostChance);
					BaitRequireReelingField.SetValue(value.Bait, value.RequireReeling);
				}
			}
			_baitDefaults.Clear();
		}

		private void ApplySlapSpeed(DeadPlayer corpse)
		{
			if (!_fastSlap || !Object.op_Implicit((Object)(object)corpse))
			{
				RestoreModifiedSlapSpeed();
				return;
			}
			if ((Object)(object)_speedModifiedCorpse != (Object)(object)corpse)
			{
				RestoreModifiedSlapSpeed();
				_speedModifiedCorpse = corpse;
				_defaultResurrectSpeed = Mathf.Max(0.01f, GetFloat(DeadPlayerResurrectSpeedField, corpse, 0.33f));
			}
			SetFloat(DeadPlayerResurrectSpeedField, corpse, _defaultResurrectSpeed * _slapSpeed);
		}

		private void RestoreModifiedSlapSpeed()
		{
			if (Object.op_Implicit((Object)(object)_speedModifiedCorpse))
			{
				SetFloat(DeadPlayerResurrectSpeedField, _speedModifiedCorpse, _defaultResurrectSpeed);
			}
			_speedModifiedCorpse = null;
			_defaultResurrectSpeed = 0f;
		}

		private void RestoreSlapSpeed()
		{
			RestoreModifiedSlapSpeed();
			StopInfiniteSlap(_activeSlapCorpse);
		}

		internal bool TryRunInfiniteSlap(DeadPlayer corpse)
		{
			Player localPlayer = Player.LocalPlayer;
			DeadPlayer val = ((Object.op_Implicit((Object)(object)_selectedTeammate) && Object.op_Implicit((Object)(object)_selectedTeammate.Dying)) ? _selectedTeammate.Dying.DeadPlayer : null);
			if (!_autoSlap || !Object.op_Implicit((Object)(object)corpse) || !((Object)(object)corpse == (Object)(object)val) || !Object.op_Implicit((Object)(object)localPlayer) || !((Object)(object)((Item)corpse).Holder == (Object)(object)localPlayer) || !Object.op_Implicit((Object)(object)localPlayer.Holding) || !((Object)(object)localPlayer.Holding.HeldItem == (Object)(object)corpse) || !_selectedTeammate.Dying.IsDead)
			{
				if (Object.op_Implicit((Object)(object)corpse) && (Object)(object)corpse == (Object)(object)_activeSlapCorpse)
				{
					StopInfiniteSlap(corpse);
				}
				return false;
			}
			if ((Object)(object)_activeSlapCorpse != (Object)(object)corpse)
			{
				StopInfiniteSlap(_activeSlapCorpse);
				_activeSlapCorpse = corpse;
				_slapCycleStartTime = Time.unscaledTime;
				_lastSlapCycle = -1;
				_nextSlapRpcTime = 0f;
			}
			float num = (((Object)(object)_speedModifiedCorpse == (Object)(object)corpse && _defaultResurrectSpeed > 0f) ? _defaultResurrectSpeed : Mathf.Max(0.01f, GetFloat(DeadPlayerResurrectSpeedField, corpse, 0.33f)));
			float num2 = (_fastSlap ? _slapSpeed : 1f);
			float num3 = Mathf.Max(0f, Time.unscaledTime - _slapCycleStartTime) * num * num2;
			int num4 = Mathf.FloorToInt(num3 / 0.92f);
			float num5 = Mathf.Repeat(num3, 0.92f);
			if (_lastSlapCycle != num4)
			{
				_lastSlapCycle = num4;
				if (DeadPlayerResurrectPercentField != null)
				{
					DeadPlayerResurrectPercentField.SetValue(corpse, 0f);
				}
				if (DeadPlayerIsResurrectingField != null)
				{
					DeadPlayerIsResurrectingField.SetValue(corpse, true);
				}
				if (DeadPlayerStartSlapMethod != null)
				{
					DeadPlayerStartSlapMethod.Invoke(corpse, null);
				}
				if (HasServerConnection)
				{
					Server.Instance.UpdateDeadPlayerResurrectPercent(corpse, 0f, (Channel)0);
				}
			}
			if (DeadPlayerIsResurrectingField != null)
			{
				DeadPlayerIsResurrectingField.SetValue(corpse, true);
			}
			if (DeadPlayerResurrectPercentField != null)
			{
				DeadPlayerResurrectPercentField.SetValue(corpse, num5);
			}
			if (DeadPlayerUpdateSlapMethod != null)
			{
				DeadPlayerUpdateSlapMethod.Invoke(corpse, null);
			}
			if (HasServerConnection && Time.unscaledTime >= _nextSlapRpcTime)
			{
				_nextSlapRpcTime = Time.unscaledTime + 0.1f;
				Server.Instance.UpdateDeadPlayerResurrectPercent(corpse, num5, (Channel)0);
			}
			return true;
		}

		private void StopInfiniteSlap(DeadPlayer corpse)
		{
			if (!Object.op_Implicit((Object)(object)corpse))
			{
				_activeSlapCorpse = null;
				_lastSlapCycle = -1;
				return;
			}
			if (DeadPlayerIsResurrectingField != null)
			{
				DeadPlayerIsResurrectingField.SetValue(corpse, false);
			}
			if (DeadPlayerResurrectPercentField != null)
			{
				DeadPlayerResurrectPercentField.SetValue(corpse, 0f);
			}
			if (DeadPlayerStartSlapReturnMethod != null)
			{
				DeadPlayerStartSlapReturnMethod.Invoke(corpse, null);
			}
			if (HasServerConnection)
			{
				Server.Instance.UpdateDeadPlayerResurrectPercent(corpse, 0f, (Channel)0);
			}
			if ((Object)(object)_activeSlapCorpse == (Object)(object)corpse)
			{
				_activeSlapCorpse = null;
			}
			_lastSlapCycle = -1;
		}

		private void ApplyWeapon(Weapon weapon)
		{
			//IL_0014: 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_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			if (Object.op_Implicit((Object)(object)weapon))
			{
				EntityId entityId = ((Object)weapon).GetEntityId();
				if (!_weaponDefaults.ContainsKey(entityId))
				{
					_weaponDefaults[entityId] = new WeaponDefaults
					{
						Weapon = weapon,
						ShotDelay = GetFloat(WeaponShotDelayField, weapon, 0.2f),
						Spread = GetFloat(WeaponSpreadField, weapon, 0f),
						Recoil = GetInt(WeaponRecoilField, weapon, 0),
						ProjectileSpeed = GetFloat(WeaponProjectileSpeedField, weapon, 1f),
						ProjectileCount = GetInt(WeaponProjectileCountField, weapon, 1),
						FullAuto = GetBool(WeaponFullAutoField, weapon, fallback: false),
						NoShootDuringAnimation = GetBool(WeaponNoShootDuringAnimationField, weapon, fallback: false),
						NoQueueingShots = GetBool(WeaponNoQueueingShotsField, weapon, fallback: false)
					};
				}
				WeaponDefaults weaponDefaults = _weaponDefaults[entityId];
				float num = (_rapidFire ? 0.12f : (_customWeapon ? _weaponDelayMultiplier : 1f));
				SetFloat(WeaponShotDelayField, weapon, Math.Max(0.015f, weaponDefaults.ShotDelay * num));
				SetFloat(WeaponSpreadField, weapon, _noSpread ? 0f : (weaponDefaults.Spread * (_customWeapon ? _weaponSpreadMultiplier : 1f)));
				SetInt(WeaponRecoilField, weapon, (!_noSpread) ? Mathf.RoundToInt((float)weaponDefaults.Recoil * (_customWeapon ? _weaponRecoilMultiplier : 1f)) : 0);
				SetFloat(WeaponProjectileSpeedField, weapon, weaponDefaults.ProjectileSpeed * (_customWeapon ? _weaponProjectileSpeedMultiplier : 1f));
				SetInt(WeaponProjectileCountField, weapon, _customWeapon ? _weaponProjectileCount : weaponDefaults.ProjectileCount);
				SetBool(WeaponNoShootDuringAnimationField, weapon, !_skipBoltAction && weaponDefaults.NoShootDuringAnimation);
				SetBool(WeaponNoQueueingShotsField, weapon, !_skipBoltAction && !_forceFullAuto && weaponDefaults.NoQueueingShots);
				SetBool(WeaponFullAutoField, weapon, _forceFullAuto || weaponDefaults.FullAuto);
				if (_infiniteAmmo && WeaponAmmoProperty != null)
				{
					WeaponAmmoProperty.SetValue(weapon, 999, null);
				}
			}
		}

		private void ApplyRod(FishingRod rod)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: 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)
			if (Object.op_Implicit((Object)(object)rod))
			{
				EntityId entityId = ((Object)rod).GetEntityId();
				if (!_rodDefaults.ContainsKey(entityId))
				{
					_rodDefaults[entityId] = new RodDefaults
					{
						Rod = rod,
						ReelSpeed = GetFloat(RodReelSpeedField, rod, 1f),
						ReelStep = GetFloat(RodReelStepField, rod, 1f),
						ThrowSpeed = GetFloat(RodThrowSpeedField, rod, 1f)
					};
				}
				RodDefaults rodDefaults = _rodDefaults[entityId];
				float num = (_fastFishing ? 6f : (_customRod ? _rodReelMultiplier : 1f));
				float num2 = (_fastFishing ? 6f : (_customRod ? _rodStepMultiplier : 1f));
				float num3 = (_fastFishing ? 6f : (_customRod ? _rodThrowMultiplier : 1f));
				SetFloat(RodReelSpeedField, rod, rodDefaults.ReelSpeed * num);
				SetFloat(RodReelStepField, rod, rodDefaults.ReelStep * num2);
				SetFloat(RodThrowSpeedField, rod, rodDefaults.ThrowSpeed * num3);
			}
		}

		private void RestoreAllWeapons()
		{
			foreach (WeaponDefaults value in _weaponDefaults.Values)
			{
				if (Object.op_Implicit((Object)(object)value.Weapon))
				{
					SetFloat(WeaponShotDelayField, value.Weapon, value.ShotDelay);
					SetFloat(WeaponSpreadField, value.Weapon, value.Spread);
					SetInt(WeaponRecoilField, value.Weapon, value.Recoil);
					SetFloat(WeaponProjectileSpeedField, value.Weapon, value.ProjectileSpeed);
					SetInt(WeaponProjectileCountField, value.Weapon, value.ProjectileCount);
					SetBool(WeaponFullAutoField, value.Weapon, value.FullAuto);
					SetBool(WeaponNoShootDuringAnimationField, value.Weapon, value.NoShootDuringAnimation);
					SetBool(WeaponNoQueueingShotsField, value.Weapon, value.NoQueueingShots);
				}
			}
			_weaponDefaults.Clear();
		}

		private void RestoreAllRods()
		{
			foreach (RodDefaults value in _rodDefaults.Values)
			{
				if (Object.op_Implicit((Object)(object)value.Rod))
				{
					SetFloat(RodReelSpeedField, value.Rod, value.ReelSpeed);
					SetFloat(RodReelStepField, value.Rod, value.ReelStep);
					SetFloat(RodThrowSpeedField, value.Rod, value.ThrowSpeed);
				}
			}
			_rodDefaults.Clear();
		}

		internal void ApplyFlightAfterPhysics(PlayerMovement movement)
		{
			//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_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//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_00d3: 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_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: 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_00f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_010d: 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_0114: Unknown result type (might be due to invalid IL or missing references)
			//IL_0119: Unknown result type (might be due to invalid IL or missing references)
			//IL_013a: Unknown result type (might be due to invalid IL or missing references)
			//IL_013c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0141: Unknown result type (might be due to invalid IL or missing references)
			//IL_0146: 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_0170: Unknown result type (might be due to invalid IL or missing references)
			//IL_015c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0181: Unknown result type (might be due to invalid IL or missing references)
			Player localPlayer = Player.LocalPlayer;
			if (!Object.op_Implicit((Object)(object)localPlayer) || (Object)(object)localPlayer.Movement != (Object)(object)movement || !Object.op_Implicit((Object)(object)localPlayer.Rigidbody))
			{
				return;
			}
			if (!_flight)
			{
				if (_flightWasActive)
				{
					localPlayer.Rigidbody.useGravity = true;
					_flightWasActive = false;
				}
				return;
			}
			_flightWasActive = true;
			localPlayer.Rigidbody.useGravity = false;
			Transform val = (Object.op_Implicit((Object)(object)localPlayer.CurCam) ? ((Component)localPlayer.CurCam).transform : localPlayer.Transform);
			Vector3 val2 = Vector3.ProjectOnPlane(val.forward, Vector3.up);
			Vector3 normalized = ((Vector3)(ref val2)).normalized;
			val2 = Vector3.ProjectOnPlane(val.right, Vector3.up);
			Vector3 normalized2 = ((Vector3)(ref val2)).normalized;
			Vector3 val3 = normalized * Input.GetAxisRaw("Vertical") + normalized2 * Input.GetAxisRaw("Horizontal");
			if (Input.GetKey((KeyCode)32))
			{
				val3 += Vector3.up;
			}
			if (Input.GetKey((KeyCode)306) || Input.GetKey((KeyCode)305))
			{
				val3 += Vector3.down;
			}
			localPlayer.Rigidbody.linearVelocity = ((((Vector3)(ref val3)).sqrMagnitude > 0f) ? (((Vector3)(ref val3)).normalized * _flightSpeed) : Vector3.zero);
			localPlayer.Rigidbody.angularVelocity = Vector3.zero;
		}

		private void RestoreFlight()
		{
			Player localPlayer = Player.LocalPlayer;
			if (_flightWasActive && Object.op_Implicit((Object)(object)localPlayer) && Object.op_Implicit((Object)(object)localPlayer.Rigidbody))
			{
				localPlayer.Rigidbody.useGravity = true;
			}
			_flightWasActive = false;
		}

		private void LoadConfig()
		{
			_config.Save();
		}

		private string T(string key, params object[] args)
		{
			string key2 = (_useEnglish ? "en" : "zh");
			if (_localizationDict.TryGetValue(key2, out var value) && value.TryGetValue(key, out var value2))
			{
				return (args != null && args.Length != 0) ? string.Format(value2, args) : value2;
			}
			if (_localizationDict.TryGetValue("zh", out var value3) && value3.TryGetValue(key, out var value4))
			{
				return (args != null && args.Length != 0) ? string.Format(value4, args) : value4;
			}
			return key;
		}

		private void OnGUI()
		{
			//IL_0137: Unknown result type (might be due to invalid IL or missing references)
			//IL_0143: Unknown result type (might be due to invalid IL or missing references)
			//IL_0158: Expected O, but got Unknown
			//IL_0153: Unknown result type (might be due to invalid IL or missing references)
			//IL_0158: Unknown result type (might be due to invalid IL or missing references)
			if (_espEnabled)
			{
				DrawEsp();
			}
			if (_menuVisible)
			{
				EnsureUiResources();
				GUISkin skin = GUI.skin;
				GUI.skin = _uiSkin;
				GUI.depth = -1000;
				float num = 980f;
				float num2 = 680f;
				float num3 = Mathf.Max(num, (float)Screen.width - 20f);
				float num4 = Mathf.Max(num2, (float)Screen.height - 20f);
				((Rect)(ref _window)).width = Mathf.Clamp(((Rect)(ref _window)).width, num, num3);
				((Rect)(ref _window)).height = Mathf.Clamp(((Rect)(ref _window)).height, num2, num4);
				((Rect)(ref _window)).x = Mathf.Clamp(((Rect)(ref _window)).x, 0f, Mathf.Max(0f, (float)Screen.width - ((Rect)(ref _window)).width));
				((Rect)(ref _window)).y = Mathf.Clamp(((Rect)(ref _window)).y, 0f, Mathf.Max(0f, (float)Screen.height - 40f));
				_window = GUI.Window(987612, _window, new WindowFunction(DrawWindow), GUIContent.none, _windowStyle);
				HandleWindowResize();
				GUI.skin = skin;
			}
		}

		private void HandleWindowResize()
		{
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0103: Invalid comparison between Unknown and I4
			//IL_01a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a6: Invalid comparison between Unknown and I4
			//IL_0113: Unknown result type (might be due to invalid IL or missing references)
			//IL_0119: Unknown result type (might be due to invalid IL or missing references)
			//IL_011e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			//IL_0130: Unknown result type (might be due to invalid IL or missing references)
			//IL_015b: Unknown result type (might be due to invalid IL or missing references)
			Event current = Event.current;
			float num = 12f;
			Rect val = default(Rect);
			((Rect)(ref val))..ctor(((Rect)(ref _window)).xMax - num, ((Rect)(ref _window)).yMin, num, ((Rect)(ref _window)).height);
			Rect val2 = default(Rect);
			((Rect)(ref val2))..ctor(((Rect)(ref _window)).xMin, ((Rect)(ref _window)).yMax - num, ((Rect)(ref _window)).width, num);
			Rect val3 = default(Rect);
			((Rect)(ref val3))..ctor(((Rect)(ref _window)).xMax - num, ((Rect)(ref _window)).yMax - num, num, num);
			bool flag = ((Rect)(ref val3)).Contains(current.mousePosition);
			bool flag2 = ((Rect)(ref val)).Contains(current.mousePosition);
			bool flag3 = ((Rect)(ref val2)).Contains(current.mousePosition);
			if ((int)current.type == 0 && (flag || flag2 || flag3))
			{
				_isResizing = true;
				_resizeStartMouse = current.mousePosition;
				_resizeStartRect = _window;
				current.Use();
			}
			if (_isResizing && (int)current.type == 3)
			{
				Vector2 val4 = current.mousePosition - _resizeStartMouse;
				float width = Mathf.Clamp(((Rect)(ref _resizeStartRect)).width + val4.x, 980f, (float)Screen.width - 20f);
				float height = Mathf.Clamp(((Rect)(ref _resizeStartRect)).height + val4.y, 680f, (float)Screen.height - 20f);
				((Rect)(ref _window)).width = width;
				((Rect)(ref _window)).height = height;
				current.Use();
			}
			if ((int)current.type == 1 && _isResizing)
			{
				_isResizing = false;
				current.Use();
			}
		}

		private void DrawWindow(int id)
		{
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_0297: Unknown result type (might be due to invalid IL or missing references)
			//IL_048a: Unknown result type (might be due to invalid IL or missing references)
			//IL_04e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_04fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0502: Unknown result type (might be due to invalid IL or missing references)
			//IL_05ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_0660: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e5: Unknown result type (might be due to invalid IL or missing references)
			Player localPlayer = Player.LocalPlayer;
			string text = (IsHost ? T("status.host") : (HasServerConnection ? T("status.client") : T("status.none")));
			float num = 68f;
			float num2 = 44f;
			float num3 = 210f;
			float num4 = 12f;
			float num5 = num + num4;
			float num6 = ((Rect)(ref _window)).height - num5 - num2 - num4;
			GUILayout.BeginArea(new Rect(0f, 0f, ((Rect)(ref _window)).width, num), GUIContent.none, _headerStyle);
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			GUILayout.Label(T("menu.title"), _titleStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.ExpandWidth(false) });
			GUILayout.Label("v1.3", _badgeStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.Width(72f),
				GUILayout.Height(28f)
			});
			GUILayout.FlexibleSpace();
			if (GUILayout.Button(T("menu.lang_switch"), _badgeStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.Width(120f),
				GUILayout.Height(28f)
			}))
			{
				_useEnglish = !_useEnglish;
				SetStatus(T("status.lang_switched") + " " + (_useEnglish ? "English" : "中文"));
			}
			GUILayout.Space(8f);
			GUILayout.Label("● " + text, _badgeStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.ExpandWidth(false),
				GUILayout.Height(28f)
			});
			GUILayout.Space(10f);
			GUILayout.Label(T("menu.player") + (Object.op_Implicit((Object)(object)localPlayer) ? localPlayer.SteamName : T("menu.none")), _mutedStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.ExpandWidth(false) });
			GUILayout.Space(14f);
			GUILayout.Label(T("menu.money") + MoneyManager.Money, _mutedStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.ExpandWidth(false) });
			GUILayout.EndHorizontal();
			GUILayout.EndArea();
			GUILayout.BeginArea(new Rect(num4, num5, num3, num6), GUIContent.none, _sidebarStyle);
			GUILayout.Label(T("menu.categories"), _sectionTitleStyle, Array.Empty<GUILayoutOption>());
			GUILayout.Space(6f);
			string[] array = new string[7]
			{
				T("tab.player"),
				T("tab.items"),
				T("tab.teammates"),
				T("tab.combat"),
				T("tab.esp"),
				T("tab.casino"),
				T("tab.other")
			};
			for (int i = 0; i < array.Length; i++)
			{
				if (GUILayout.Button((i + 1).ToString("00", CultureInfo.InvariantCulture) + "   " + array[i], (_tab == i) ? _navActiveStyle : _navStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(46f) }))
				{
					if (_tab != i)
					{
						_mainScroll = Vector2.zero;
					}
					_tab = i;
				}
				GUILayout.Space(4f);
			}
			GUILayout.FlexibleSpace();
			GUILayout.Label(T("menu.scope"), _sectionTitleStyle, Array.Empty<GUILayoutOption>());
			GUILayout.Label(T("menu.scope_desc"), _mutedStyle, Array.Empty<GUILayoutOption>());
			GUILayout.EndArea();
			GUILayout.BeginArea(new Rect(num3 + num4 * 2f, num5, ((Rect)(ref _window)).width - num3 - num4 * 3f, num6), GUIContent.none, _contentStyle);
			GUILayout.Label(GetPageTitle(_tab), _pageTitleStyle, Array.Empty<GUILayoutOption>());
			GUILayout.Label(GetPageDescription(_tab), _mutedStyle, Array.Empty<GUILayoutOption>());
			GUILayout.Space(8f);
			_mainScroll = GUILayout.BeginScrollView(_mainScroll, false, true, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.ExpandHeight(true) });
			switch (_tab)
			{
			case 0:
				DrawResources(localPlayer);
				break;
			case 1:
				DrawItems(localPlayer);
				break;
			case 2:
				DrawTeammates(localPlayer);
				DrawWorld(localPlayer);
				break;
			case 3:
				DrawCombat(localPlayer);
				break;
			case 4:
				DrawEspAimAndCrosshair();
				break;
			case 5:
				DrawCasinoAndCommands();
				break;
			case 6:
				DrawOtherSettings();
				break;
			}
			GUILayout.EndScrollView();
			GUILayout.EndArea();
			GUILayout.BeginArea(new Rect(0f, ((Rect)(ref _window)).height - num2, ((Rect)(ref _window)).width, num2), GUIContent.none, _footerStyle);
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			GUILayout.Label("●", _statusStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(16f) });
			GUILayout.Label(_status, _statusStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.ExpandWidth(true) });
			GUILayout.Label(T("menu.close_hint"), _mutedStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.ExpandWidth(false) });
			GUILayout.EndHorizontal();
			GUILayout.EndArea();
			GUI.DragWindow(new Rect(0f, 0f, ((Rect)(ref _window)).width, num));
		}

		private string GetPageTitle(int tab)
		{
			return tab switch
			{
				0 => T("tab.player"), 
				1 => T("tab.items"), 
				2 => T("tab.teammates"), 
				3 => T("tab.combat"), 
				4 => T("tab.esp"), 
				5 => T("tab.casino"), 
				6 => T("tab.other"), 
				_ => T("tab.casino"), 
			};
		}

		private string GetPageDescription(int tab)
		{
			return tab switch
			{
				0 => T("desc.player"), 
				1 => T("desc.items"), 
				2 => T("desc.teammates"), 
				3 => T("desc.combat"), 
				4 => T("desc.esp"), 
				5 => T("desc.casino"), 
				6 => T("desc.other"), 
				_ => T("desc.casino"), 
			};
		}

		private void BeginUiCard(string title, string description = null)
		{
			GUILayout.BeginVertical(_cardStyle, Array.Empty<GUILayoutOption>());
			GUILayout.Label(title, _sectionTitleStyle, Array.Empty<GUILayoutOption>());
			if (!string.IsNullOrEmpty(description))
			{
				GUILayout.Label(description, _mutedStyle, Array.Empty<GUILayoutOption>());
			}
			GUILayout.Space(5f);
		}

		private static void EndUiCard()
		{
			GUILayout.EndVertical();
			GUILayout.Space(10f);
		}

		private void DrawResources(Player player)
		{
			BeginUiCard(T("card.money"), T("card.money_desc"));
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			_moneyText = GUILayout.TextField(_moneyText, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(130f) });
			if (GUILayout.Button(T("btn.add"), Array.Empty<GUILayoutOption>()))
			{
				HostAddMoney(player, add: true);
			}
			if (GUILayout.Button(T("btn.remove"), Array.Empty<GUILayoutOption>()))
			{
				HostAddMoney(player, add: false);
			}
			if (GUILayout.Button(T("btn.set"), Array.Empty<GUILayoutOption>()))
			{
				HostSetMoney();
			}
			GUILayout.EndHorizontal();
			EndUiCard();
			BeginUiCard(T("card.vitals"));
			GUI.enabled = IsHost && Object.op_Implicit((Object)(object)player);
			if (GUILayout.Button(T("btn.fill_vitals"), Array.Empty<GUILayoutOption>()))
			{
				FillVitals(player);
			}
			GUI.enabled = true;
			_selfGod = GUILayout.Toggle(_selfGod, T("toggle.godmode"), Array.Empty<GUILayoutOption>());
			_keepVitalsFull = GUILayout.Toggle(_keepVitalsFull, T("toggle.keep_full"), Array.Empty<GUILayoutOption>());
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			GUI.enabled = IsHost;
			if (GUILayout.Button(T("btn.godmode_global") + PlayerManager.InGodMode, Array.Empty<GUILayoutOption>()))
			{
				PlayerManager.ToggleGodMode();
				SetStatus(T("status.godmode") + PlayerManager.InGodMode);
			}
			bool flag = Object.op_Implicit((Object)(object)ServerSettings.Instance) && ServerSettings.OneShotEnabled;
			if (GUILayout.Button(T("btn.oneshot") + flag, Array.Empty<GUILayoutOption>()))
			{
				ServerSettings.Instance.ToggleOneShot();
				SetStatus(T("status.oneshot") + !flag);
			}
			GUI.enabled = true;
			GUILayout.EndHorizontal();
			EndUiCard();
			BeginUiCard(T("card.movement"), T("card.movement_desc"));
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			GUILayout.Label(T("label.move_mult"), (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(90f) });
			_moveText = GUILayout.TextField(_moveText, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(90f) });
			if (GUILayout.Button(T("btn.apply"), (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(80f) }))
			{
				_moveMultiplier = ParseClamped(_moveText, 1f, 0.1f, 20f);
				_moveText = _moveMultiplier.ToString("0.##", CultureInfo.InvariantCulture);
				SetStatus(T("status.move") + _moveText);
			}
			GUILayout.Label(T("label.jump_mult"), (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(90f) });
			_jumpText = GUILayout.TextField(_jumpText, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(90f) });
			if (GUILayout.Button(T("btn.apply"), (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(80f) }))
			{
				_jumpMultiplier = ParseClamped(_jumpText, 1f, 0.1f, 20f);
				_jumpText = _jumpMultiplier.ToString("0.##", CultureInfo.InvariantCulture);
				SetStatus(T("status.jump") + _jumpText);
			}
			if (GUILayout.Button(T("btn.reset"), (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(80f) }))
			{
				_moveMultiplier = (_jumpMultiplier = 1f);
				_moveText = (_jumpText = "1");
				SetStatus(T("status.move_reset"));
			}
			GUILayout.EndHorizontal();
			EndUiCard();
		}

		private void DrawItems(Player player)
		{
			//IL_0289: Unknown result type (might be due to invalid IL or missing references)
			BeginUiCard(T("card.items"), T("card.items_desc"));
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			if (GUILayout.Button(T("btn.refresh_items"), (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(160f) }))
			{
				RefreshItems(forced: true);
				_itemPage = 0;
			}
			string itemFilter = _itemFilter;
			_itemFilter = GUILayout.TextField(_itemFilter, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.ExpandWidth(true) });
			if (!string.Equals(itemFilter, _itemFilter, StringComparison.OrdinalIgnoreCase))
			{
				_itemPage = 0;
			}
			if (GUILayout.Button(T("btn.clear_filter"), (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(100f) }))
			{
				_itemFilter = "";
				_itemPage = 0;
			}
			GUILayout.EndHorizontal();
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			GUI.enabled = HasServerConnection && Object.op_Implicit((Object)(object)player);
			if (GUILayout.Button(T("btn.unlock_baits"), Array.Empty<GUILayoutOption>()))
			{
				UnlockAllBaits(player);
			}
			GUI.enabled = IsHost && Object.op_Implicit((Object)(object)player);
			if (GUILayout.Button(T("btn.unlock_pockets"), Array.Empty<GUILayoutOption>()))
			{
				UnlockAllPockets(player);
			}
			GUI.enabled = true;
			GUILayout.EndHorizontal();
			RefreshItems(forced: false);
			string filter = (_itemFilter ?? "").Trim();
			List<Item> list = _items.Where((Item item) => Object.op_Implicit((Object)(object)item) && (filter.Length == 0 || $"ID {item.ID:000} | {((Object)item).name} | 类型 {item.Type} | 价格 {item.Cost} | 价值 {item.DefaultWorth}".IndexOf(filter, StringComparison.OrdinalIgnoreCase) >= 0)).ToList();
			int num = Math.Max(1, (list.Count + 12 - 1) / 12);
			_itemPage = Mathf.Clamp(_itemPage, 0, num - 1);
			GUILayout.Label(string.Format(T("label.items_count"), list.Count, num), Array.Empty<GUILayoutOption>());
			foreach (Item item in list.Skip(_itemPage * 12).Take(12))
			{
				string text = $"ID {item.ID:000} | {((Object)item).name} | 类型 {item.Type} | 价格 {item.Cost} | 价值 {item.DefaultWorth}";
				GUI.enabled = HasServerConnection && Object.op_Implicit((Object)(object)player);
				if (GUILayout.Button(T("btn.spawn") + "  " + text, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(28f) }))
				{
					SpawnHeld(item, player);
				}
				GUI.enabled = true;
			}
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			GUI.enabled = _itemPage > 0;
			if (GUILayout.Button(T("btn.prev"), (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(110f) }))
			{
				_itemPage--;
			}
			GUI.enabled = true;
			GUILayout.FlexibleSpace();
			GUILayout.Label(string.Format(T("label.page"), _itemPage + 1, num), _mutedStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(100f) });
			GUILayout.FlexibleSpace();
			GUI.enabled = _itemPage < num - 1;
			if (GUILayout.Button(T("btn.next"), (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(110f) }))
			{
				_itemPage++;
			}
			GUI.enabled = true;
			GUILayout.EndHorizontal();
			EndUiCard();
			Item val = ((Object.op_Implicit((Object)(object)player) && Object.op_Implicit((Object)(object)player.Holding)) ? player.Holding.HeldItem : null);
			BeginUiCard(T("card.held"), T("card.held_desc") + (Object.op_Implicit((Object)(object)val) ? ((Object)val).name : T("menu.none")));
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			_itemWeightText = GUILa