using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using FishNet.Object;
using HarmonyLib;
using UnityEngine;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("RandomCreatureSize")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyDescription("随机生物尺寸：海鸥/鱼类/螃蟹/Boss 外观随机缩放，s 即重量（影响售价/存档/联机一致）")]
[assembly: AssemblyFileVersion("1.1.3.0")]
[assembly: AssemblyInformationalVersion("1.1.3")]
[assembly: AssemblyProduct("RandomCreatureSize")]
[assembly: AssemblyTitle("RandomCreatureSize")]
[assembly: AssemblyVersion("1.1.3.0")]
namespace RandomCreatureSize;
internal static class SizeLogic
{
private static readonly FieldInfo _skipRandomizedWeightField = AccessTools.Field(typeof(Creature), "_skipRandomizedWeight");
public static bool IsBoss(Creature c)
{
//IL_000a: Unknown result type (might be due to invalid IL or missing references)
//IL_0010: Invalid comparison between Unknown and I4
if ((Object)(object)c != (Object)null)
{
return (int)c.BossType > 0;
}
return false;
}
private static bool SkipsRandomizedWeight(Creature c)
{
try
{
if (_skipRandomizedWeightField == null)
{
return false;
}
object value = _skipRandomizedWeightField.GetValue(c);
bool flag = default(bool);
int num;
if (value is bool)
{
flag = (bool)value;
num = 1;
}
else
{
num = 0;
}
return (byte)((uint)num & (flag ? 1u : 0u)) != 0;
}
catch
{
return false;
}
}
public static bool ShouldScale(Creature c)
{
try
{
if ((Object)(object)c == (Object)null || !Plugin.Enabled.Value)
{
return false;
}
if (SkipsRandomizedWeight(c))
{
return false;
}
if (IsBoss(c) && !Plugin.ScaleBosses.Value)
{
return false;
}
if (c is Bird)
{
return Plugin.ScaleBirds.Value;
}
if (c is Fish)
{
return Plugin.ScaleFish.Value;
}
return Plugin.ScaleOthers.Value;
}
catch (Exception ex)
{
Plugin.LogWarn("ShouldScale 异常: " + ex.Message);
return false;
}
}
public static float RollSize(bool boss)
{
float num = (boss ? Plugin.BossMinScale.Value : Plugin.MinScale.Value);
float num2 = (boss ? Plugin.BossMaxScale.Value : Plugin.MaxScale.Value);
if (num2 < num)
{
float num3 = num;
num = num2;
num2 = num3;
}
if (num <= 0f)
{
num = 0.01f;
}
float num4 = BiasUnit(Random.value);
if (Plugin.LogUniform.Value)
{
return num * Mathf.Pow(num2 / num, num4);
}
return Mathf.Lerp(num, num2, num4);
}
private static float BiasUnit(float u)
{
float num = Mathf.Clamp01(Plugin.ExtremeBias.Value);
if (num <= 0f)
{
return u;
}
float num2 = 2f * u - 1f;
float num3 = (num2 * num2 * num2 + 1f) * 0.5f;
return Mathf.Lerp(u, num3, num);
}
public static void ApplyFromWeight(Creature c)
{
if (!((Object)(object)c == (Object)null))
{
float num = ((Item)c).RandomizedWeight;
if (num <= 0f || float.IsNaN(num))
{
num = 1f;
}
Apply(c, num);
}
}
public static void Apply(Creature c, float s)
{
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
//IL_000b: Unknown result type (might be due to invalid IL or missing references)
//IL_0013: 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_0023: Unknown result type (might be due to invalid IL or missing references)
//IL_002a: Unknown result type (might be due to invalid IL or missing references)
Vector3 val = AxisFactors(((NetworkBehaviour)c).ObjectId);
((Component)c).transform.localScale = new Vector3(s * val.x, s * val.y, s * val.z);
}
public static Vector3 AxisFactors(int objectId)
{
//IL_000c: Unknown result type (might be due to invalid IL or missing references)
//IL_008d: Unknown result type (might be due to invalid IL or missing references)
//IL_002a: Unknown result type (might be due to invalid IL or missing references)
if (!Plugin.JitterEnabled.Value)
{
return Vector3.one;
}
float num = Mathf.Clamp01(Plugin.JitterPercent.Value);
if (num <= 0f)
{
return Vector3.one;
}
return new Vector3(1f + (DetUnit(objectId * 31 + 1) * 2f - 1f) * num, 1f + (DetUnit(objectId * 31 + 2) * 2f - 1f) * num, 1f + (DetUnit(objectId * 31 + 3) * 2f - 1f) * num);
}
private static float DetUnit(int seed)
{
int num = seed ^ (seed << 13);
int num2 = num ^ (num >>> 17);
return (float)(uint)((num2 ^ (num2 << 5)) & 0x3FFFFFFF) / 1.0737418E+09f;
}
public static float SpeedFactor(Creature c)
{
try
{
if ((Object)(object)c == (Object)null || !Plugin.SpeedEnabled.Value)
{
return 1f;
}
float randomizedWeight = ((Item)c).RandomizedWeight;
if (randomizedWeight <= 1f || float.IsNaN(randomizedWeight))
{
return 1f;
}
float num = Mathf.Max(0f, Plugin.SpeedPow.Value);
return Mathf.Max(Mathf.Pow(randomizedWeight, 0f - num), Mathf.Clamp(Plugin.SpeedMinFactor.Value, 0.01f, 1f));
}
catch (Exception ex)
{
Plugin.LogWarn("SpeedFactor 异常: " + ex.Message);
return 1f;
}
}
public static void DampHorizontalVelocity(Creature c)
{
//IL_0055: Unknown result type (might be due to invalid IL or missing references)
//IL_005a: Unknown result type (might be due to invalid IL or missing references)
//IL_0074: Unknown result type (might be due to invalid IL or missing references)
if ((Object)(object)c == (Object)null || c.IsDead)
{
return;
}
RigidbodySync rigidbodySync = ((Item)c).RigidbodySync;
if ((Object)(object)rigidbodySync == (Object)null || !rigidbodySync.IsSimulatedLocal)
{
return;
}
float num = SpeedFactor(c);
if (!(num >= 1f))
{
Rigidbody rig = ((Item)c).Rig;
if (!((Object)(object)rig == (Object)null) && !rig.isKinematic)
{
Vector3 linearVelocity = rig.linearVelocity;
linearVelocity.x *= num;
linearVelocity.z *= num;
rig.linearVelocity = linearVelocity;
}
}
}
public static void ServerRollAndApply(Creature c)
{
if (!((Object)(object)c == (Object)null) && ShouldScale(c))
{
if (!SaveRestore.Restoring.Contains(c))
{
((Item)c)._syncedRandomWeight.Value = RollSize(IsBoss(c));
}
Apply(c, Mathf.Max(((Item)c).RandomizedWeight, 0.01f));
if (c._hp.Value > 0)
{
float num = Mathf.Max(((Item)c).RandomizedWeight, 0.01f);
c._hp.Value = Mathf.Max(1, Mathf.RoundToInt((float)c._hp.Value * num));
}
}
}
}
internal static class SaveRestore
{
public static readonly HashSet<Creature> Restoring = new HashSet<Creature>();
}
[HarmonyPatch(typeof(Creature), "OnStartServer")]
internal static class Patch_Creature_OnStartServer
{
private static void Postfix(Creature __instance)
{
try
{
SizeLogic.ServerRollAndApply(__instance);
}
catch (Exception ex)
{
Plugin.LogWarn("OnStartServer 补丁异常: " + ex.Message);
}
}
}
[HarmonyPatch(/*Could not decode attribute arguments.*/)]
internal static class Patch_Creature_MaxHp
{
private static void Postfix(Creature __instance, ref int __result)
{
try
{
if (!((Object)(object)__instance == (Object)null) && __result > 0 && SizeLogic.ShouldScale(__instance))
{
float randomizedWeight = ((Item)__instance).RandomizedWeight;
if (!(randomizedWeight <= 0f) && !float.IsNaN(randomizedWeight))
{
__result = Mathf.Max(1, Mathf.RoundToInt((float)__result * randomizedWeight));
}
}
}
catch (Exception ex)
{
Plugin.LogWarn("MaxHp 补丁异常: " + ex.Message);
}
}
}
[HarmonyPatch(typeof(AttackingFish), "OnStartServer")]
internal static class Patch_AttackingFish_OnStartServer
{
private static void Postfix(Creature __instance)
{
try
{
SizeLogic.ServerRollAndApply(__instance);
}
catch (Exception ex)
{
Plugin.LogWarn("AttackingFish.OnStartServer 补丁异常: " + ex.Message);
}
}
}
[HarmonyPatch(typeof(Piranha), "OnStartServer")]
internal static class Patch_Piranha_OnStartServer
{
private static void Postfix(Creature __instance)
{
try
{
SizeLogic.ServerRollAndApply(__instance);
}
catch (Exception ex)
{
Plugin.LogWarn("Piranha.OnStartServer 补丁异常: " + ex.Message);
}
}
}
[HarmonyPatch(typeof(Pufferfish), "OnStartServer")]
internal static class Patch_Pufferfish_OnStartServer
{
private static void Postfix(Creature __instance)
{
try
{
SizeLogic.ServerRollAndApply(__instance);
}
catch (Exception ex)
{
Plugin.LogWarn("Pufferfish.OnStartServer 补丁异常: " + ex.Message);
}
}
}
[HarmonyPatch(typeof(Spidercrab), "OnStartServer")]
internal static class Patch_Spidercrab_OnStartServer
{
private static void Postfix(Creature __instance)
{
try
{
SizeLogic.ServerRollAndApply(__instance);
}
catch (Exception ex)
{
Plugin.LogWarn("Spidercrab.OnStartServer 补丁异常: " + ex.Message);
}
}
}
[HarmonyPatch(typeof(Creature), "LoadFromSave")]
internal static class Patch_Creature_LoadFromSave
{
private static void Prefix(Creature __instance)
{
try
{
SaveRestore.Restoring.Add(__instance);
}
catch
{
}
}
private static void Postfix(Creature __instance)
{
try
{
if (SizeLogic.ShouldScale(__instance))
{
SizeLogic.Apply(__instance, Mathf.Max(((Item)__instance).RandomizedWeight, 0.01f));
}
}
catch (Exception ex)
{
Plugin.LogWarn("LoadFromSave 补丁异常: " + ex.Message);
}
finally
{
try
{
SaveRestore.Restoring.Remove(__instance);
}
catch
{
}
}
}
}
[HarmonyPatch(typeof(Creature), "OnStartClient")]
internal static class Patch_Creature_OnStartClient
{
private static void Postfix(Creature __instance)
{
try
{
if (!SizeLogic.ShouldScale(__instance))
{
return;
}
SizeLogic.ApplyFromWeight(__instance);
((Item)__instance)._syncedRandomWeight.OnChange += delegate
{
try
{
if (SizeLogic.ShouldScale(__instance))
{
SizeLogic.ApplyFromWeight(__instance);
}
}
catch (Exception ex2)
{
Plugin.LogWarn("重量同步回调异常: " + ex2.Message);
}
};
}
catch (Exception ex)
{
Plugin.LogWarn("OnStartClient 补丁异常: " + ex.Message);
}
}
}
[HarmonyPatch(typeof(Item), "PickUp")]
internal static class Patch_Item_PickUp
{
private static void Postfix(Item __instance)
{
try
{
if (!((Object)(object)__instance == (Object)null))
{
Creature creature = __instance.Creature;
if (!((Object)(object)creature == (Object)null) && SizeLogic.ShouldScale(creature))
{
SizeLogic.ApplyFromWeight(creature);
}
}
}
catch (Exception ex)
{
Plugin.LogWarn("PickUp 补丁异常: " + ex.Message);
}
}
}
[HarmonyPatch(typeof(Item), "SpawnFromInventory")]
internal static class Patch_Item_SpawnFromInventory
{
private static void Postfix(Item __instance)
{
try
{
if (!((Object)(object)__instance == (Object)null))
{
Creature creature = __instance.Creature;
if (!((Object)(object)creature == (Object)null) && SizeLogic.ShouldScale(creature))
{
SizeLogic.ApplyFromWeight(creature);
}
}
}
catch (Exception ex)
{
Plugin.LogWarn("SpawnFromInventory 补丁异常: " + ex.Message);
}
}
}
[HarmonyPatch(typeof(InventorySlot), "SetItem")]
internal static class Patch_InventorySlot_SetItem
{
private static readonly FieldInfo _filterField = AccessTools.Field(typeof(InventorySlot), "_filter");
private static void Postfix(InventorySlot __instance, Item item)
{
//IL_0072: Unknown result type (might be due to invalid IL or missing references)
//IL_007d: Unknown result type (might be due to invalid IL or missing references)
//IL_0083: Unknown result type (might be due to invalid IL or missing references)
try
{
if ((Object)(object)item == (Object)null)
{
return;
}
Creature creature = item.Creature;
if ((Object)(object)creature == (Object)null || !SizeLogic.ShouldScale(creature) || _filterField == null)
{
return;
}
object? value = _filterField.GetValue(__instance);
MeshFilter val = (MeshFilter)((value is MeshFilter) ? value : null);
if (!((Object)(object)val == (Object)null))
{
float randomizedWeight = item.RandomizedWeight;
if (!(randomizedWeight <= 0f) && !float.IsNaN(randomizedWeight))
{
((Component)val).transform.localScale = Vector3.one * item.InventoryMeshScale * randomizedWeight;
}
}
}
catch (Exception ex)
{
Plugin.LogWarn("InventorySlot 补丁异常: " + ex.Message);
}
}
}
[HarmonyPatch(typeof(Fish), "FixedUpdate")]
internal static class Patch_Fish_FixedUpdate
{
private static void Postfix(Fish __instance)
{
try
{
if (!(__instance is RunningFish) && !(__instance is Pufferfish) && !(__instance is BowheadWhale))
{
SizeLogic.DampHorizontalVelocity((Creature)(object)__instance);
}
}
catch (Exception ex)
{
Plugin.LogWarn("Fish.FixedUpdate 补丁异常: " + ex.Message);
}
}
}
[HarmonyPatch(typeof(RunningFish), "FixedUpdate")]
internal static class Patch_RunningFish_FixedUpdate
{
private static void Postfix(RunningFish __instance)
{
try
{
SizeLogic.DampHorizontalVelocity((Creature)(object)__instance);
}
catch (Exception ex)
{
Plugin.LogWarn("RunningFish.FixedUpdate 补丁异常: " + ex.Message);
}
}
}
[HarmonyPatch(typeof(Pufferfish), "FixedUpdate")]
internal static class Patch_Pufferfish_FixedUpdate
{
private static void Postfix(Pufferfish __instance)
{
try
{
SizeLogic.DampHorizontalVelocity((Creature)(object)__instance);
}
catch (Exception ex)
{
Plugin.LogWarn("Pufferfish.FixedUpdate 补丁异常: " + ex.Message);
}
}
}
[HarmonyPatch(typeof(BowheadWhale), "FixedUpdate")]
internal static class Patch_BowheadWhale_FixedUpdate
{
private static void Postfix(BowheadWhale __instance)
{
try
{
SizeLogic.DampHorizontalVelocity((Creature)(object)__instance);
}
catch (Exception ex)
{
Plugin.LogWarn("BowheadWhale.FixedUpdate 补丁异常: " + ex.Message);
}
}
}
[HarmonyPatch(typeof(Crab), "FixedUpdate")]
internal static class Patch_Crab_FixedUpdate
{
private static void Postfix(Crab __instance)
{
try
{
if (!(__instance is Spidercrab))
{
SizeLogic.DampHorizontalVelocity((Creature)(object)__instance);
}
}
catch (Exception ex)
{
Plugin.LogWarn("Crab.FixedUpdate 补丁异常: " + ex.Message);
}
}
}
[HarmonyPatch(typeof(Spidercrab), "FixedUpdate")]
internal static class Patch_Spidercrab_FixedUpdate
{
private static void Postfix(Spidercrab __instance)
{
try
{
SizeLogic.DampHorizontalVelocity((Creature)(object)__instance);
}
catch (Exception ex)
{
Plugin.LogWarn("Spidercrab.FixedUpdate 补丁异常: " + ex.Message);
}
}
}
[HarmonyPatch(typeof(BirdManager), "SimulateBird")]
internal static class Patch_BirdManager_SimulateBird
{
private static readonly string[] _speedFields = new string[7] { "_defaultFlySpeed", "_horizontalSpeed", "_verticalSpeed", "_attackingFoodSpeed", "_attackingHorizontalSpeed", "_closeToFoodSpeed", "_closeToFoodHorizontalSpeed" };
private static FieldInfo[] _fields;
private static float[] _originals;
private static void Prefix(BirdManager __instance, Bird bird)
{
try
{
float num = SizeLogic.SpeedFactor((Creature)(object)bird);
if (num >= 1f)
{
return;
}
_fields = new FieldInfo[_speedFields.Length];
_originals = new float[_speedFields.Length];
for (int i = 0; i < _speedFields.Length; i++)
{
_fields[i] = AccessTools.Field(typeof(BirdManager), _speedFields[i]);
if (!(_fields[i] == null))
{
_originals[i] = (float)_fields[i].GetValue(__instance);
_fields[i].SetValue(__instance, _originals[i] * num);
}
}
}
catch (Exception ex)
{
Plugin.LogWarn("SimulateBird Prefix 异常: " + ex.Message);
Restore(__instance);
}
}
private static void Postfix(BirdManager __instance)
{
Restore(__instance);
}
private static void Restore(BirdManager __instance)
{
try
{
if (_fields == null || _originals == null)
{
return;
}
for (int i = 0; i < _fields.Length; i++)
{
if (!(_fields[i] == null))
{
try
{
_fields[i].SetValue(__instance, _originals[i]);
}
catch
{
}
}
}
_fields = null;
_originals = null;
}
catch
{
}
}
}
[HarmonyPatch(typeof(Albatross), "Move")]
internal static class Patch_Albatross_Move
{
private static readonly string[] _speedFields = new string[7] { "_defaultFlySpeed", "_horizontalSpeed", "_verticalSpeed", "_attackingTargetSpeed", "_attackingHorizontalSpeed", "_closeToTargetSpeed", "_closeToTargetHorizontalSpeed" };
private static FieldInfo[] _fields;
private static float[] _originals;
private static void Prefix(Albatross __instance)
{
try
{
float num = SizeLogic.SpeedFactor((Creature)(object)__instance);
if (num >= 1f)
{
return;
}
_fields = new FieldInfo[_speedFields.Length];
_originals = new float[_speedFields.Length];
for (int i = 0; i < _speedFields.Length; i++)
{
_fields[i] = AccessTools.Field(typeof(Albatross), _speedFields[i]);
if (!(_fields[i] == null))
{
_originals[i] = (float)_fields[i].GetValue(__instance);
_fields[i].SetValue(__instance, _originals[i] * num);
}
}
}
catch (Exception ex)
{
Plugin.LogWarn("Albatross.Move Prefix 异常: " + ex.Message);
Restore(__instance);
}
}
private static void Postfix(Albatross __instance)
{
Restore(__instance);
}
private static void Restore(Albatross __instance)
{
try
{
if (_fields == null || _originals == null)
{
return;
}
for (int i = 0; i < _fields.Length; i++)
{
if (!(_fields[i] == null))
{
try
{
_fields[i].SetValue(__instance, _originals[i]);
}
catch
{
}
}
}
_fields = null;
_originals = null;
}
catch
{
}
}
}
[BepInPlugin("top.yw.randomcreaturesize", "RandomCreatureSize", "1.1.3")]
public class Plugin : BaseUnityPlugin
{
internal static ManualLogSource Log;
internal static ConfigEntry<bool> Enabled;
internal static ConfigEntry<bool> ScaleBirds;
internal static ConfigEntry<bool> ScaleFish;
internal static ConfigEntry<bool> ScaleOthers;
internal static ConfigEntry<bool> ScaleBosses;
internal static ConfigEntry<float> MinScale;
internal static ConfigEntry<float> MaxScale;
internal static ConfigEntry<float> BossMinScale;
internal static ConfigEntry<float> BossMaxScale;
internal static ConfigEntry<bool> LogUniform;
internal static ConfigEntry<bool> JitterEnabled;
internal static ConfigEntry<float> JitterPercent;
internal static ConfigEntry<float> ExtremeBias;
internal static ConfigEntry<bool> SpeedEnabled;
internal static ConfigEntry<float> SpeedPow;
internal static ConfigEntry<float> SpeedMinFactor;
internal static void LogInfo(string msg)
{
try
{
Log.LogInfo((object)msg);
}
catch
{
}
}
internal static void LogWarn(string msg)
{
try
{
Log.LogWarning((object)msg);
}
catch
{
}
}
private void Awake()
{
//IL_0016: Unknown result type (might be due to invalid IL or missing references)
//IL_001c: Expected O, but got Unknown
//IL_005c: Unknown result type (might be due to invalid IL or missing references)
Log = ((BaseUnityPlugin)this).Logger;
InitConfig();
Harmony val = new Harmony("top.yw.randomcreaturesize");
int num = 0;
int num2 = 0;
Type[] types = typeof(Plugin).Assembly.GetTypes();
foreach (Type type in types)
{
if (type.GetCustomAttributes(typeof(HarmonyPatch), inherit: false).Length != 0)
{
try
{
new PatchClassProcessor(val, type).Patch();
num++;
}
catch (Exception ex)
{
num2++;
LogWarn("补丁应用失败：" + type.Name + " => " + ex.GetType().Name + ": " + ex.Message);
}
}
}
LogInfo("Harmony 补丁应用完成（成功 " + num + " 失败 " + num2 + "）");
LogInfo("随机生物尺寸模组已加载！(cfg: " + Paths.ConfigPath + ")");
}
private void InitConfig()
{
//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
//IL_00d8: Expected O, but got Unknown
//IL_010b: Unknown result type (might be due to invalid IL or missing references)
//IL_0115: Expected O, but got Unknown
//IL_0148: Unknown result type (might be due to invalid IL or missing references)
//IL_0152: Expected O, but got Unknown
//IL_0185: Unknown result type (might be due to invalid IL or missing references)
//IL_018f: Expected O, but got Unknown
//IL_0202: Unknown result type (might be due to invalid IL or missing references)
//IL_020c: Expected O, but got Unknown
//IL_023f: Unknown result type (might be due to invalid IL or missing references)
//IL_0249: Expected O, but got Unknown
//IL_029c: Unknown result type (might be due to invalid IL or missing references)
//IL_02a6: Expected O, but got Unknown
//IL_02d9: Unknown result type (might be due to invalid IL or missing references)
//IL_02e3: Expected O, but got Unknown
Enabled = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "Enabled", true, "总开关（Master switch；关闭后所有生物保持原版尺寸与原版重量随机）");
ScaleBirds = ((BaseUnityPlugin)this).Config.Bind<bool>("Category", "ScaleBirds", true, "海鸥随机尺寸（Seagulls）");
ScaleFish = ((BaseUnityPlugin)this).Config.Bind<bool>("Category", "ScaleFish", true, "鱼类随机尺寸（Fish，含钓上来的鱼/陆跑鱼/攻击鱼）");
ScaleOthers = ((BaseUnityPlugin)this).Config.Bind<bool>("Category", "ScaleOthers", true, "其他生物随机尺寸（Other creatures：螃蟹/蜘蛛蟹/信天翁/诱饵生物等）");
ScaleBosses = ((BaseUnityPlugin)this).Config.Bind<bool>("Category", "ScaleBosses", true, "Boss 随机尺寸（Bosses，使用独立倍率范围；关闭后 Boss 完全原版）");
MinScale = ((BaseUnityPlugin)this).Config.Bind<float>("Size", "MinScale", 0.1f, new ConfigDescription("普通生物最小尺寸倍率（Min multiplier, 默认 0.1）", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.01f, 100f), Array.Empty<object>()));
MaxScale = ((BaseUnityPlugin)this).Config.Bind<float>("Size", "MaxScale", 10f, new ConfigDescription("普通生物最大尺寸倍率（Max multiplier, 默认 10）", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.01f, 100f), Array.Empty<object>()));
BossMinScale = ((BaseUnityPlugin)this).Config.Bind<float>("Size", "BossMinScale", 0.5f, new ConfigDescription("Boss 最小尺寸倍率（Boss min multiplier, 默认 0.5）", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.01f, 100f), Array.Empty<object>()));
BossMaxScale = ((BaseUnityPlugin)this).Config.Bind<float>("Size", "BossMaxScale", 2f, new ConfigDescription("Boss 最大尺寸倍率（Boss max multiplier, 默认 2）", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.01f, 100f), Array.Empty<object>()));
LogUniform = ((BaseUnityPlugin)this).Config.Bind<bool>("Size", "LogUniform", true, "对数均匀分布（推荐）：0.1/1/10 概率均衡；关闭 = 均匀分布（false = uniform）");
JitterEnabled = ((BaseUnityPlugin)this).Config.Bind<bool>("Size", "JitterEnabled", true, "分轴抖动：长/宽/高在尺寸附近各自随机（Per-axis jitter；关闭 = 纯等比缩放）");
JitterPercent = ((BaseUnityPlugin)this).Config.Bind<float>("Size", "JitterPercent", 0.3f, new ConfigDescription("分轴抖动幅度（Jitter amount, 默认 0.3 = ±30%）", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 1f), Array.Empty<object>()));
ExtremeBias = ((BaseUnityPlugin)this).Config.Bind<float>("Size", "ExtremeBias", 0.3f, new ConfigDescription("随机偏极端程度：让明显大/小体型出现更频繁（0 = 对数均匀，1 = 全偏极值；默认 0.3）", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 1f), Array.Empty<object>()));
SpeedEnabled = ((BaseUnityPlugin)this).Config.Bind<bool>("Size", "SpeedEnabled", true, "尺寸越大移动越慢（Bigger creatures move slower；s≤1 速度不变）");
SpeedPow = ((BaseUnityPlugin)this).Config.Bind<float>("Size", "SpeedPow", 0.5f, new ConfigDescription("速度衰减指数：速度 = 1/尺寸^指数（Speed exponent, 默认 0.5）", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 5f), Array.Empty<object>()));
SpeedMinFactor = ((BaseUnityPlugin)this).Config.Bind<float>("Size", "SpeedMinFactor", 0.4f, new ConfigDescription("速度下限（Speed floor, 默认 0.4 = 最多减少 60% 速度；速度最低为原来的 40%）", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.4f, 1f), Array.Empty<object>()));
}
}
