using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Text;
using System.Threading;
using BepInEx;
using BepInEx.Logging;
using FishNet;
using FishNet.Managing;
using FishNet.Managing.Object;
using FishNet.Object;
using HarmonyLib;
using HowToFish.ItemSDK;
using Microsoft.CodeAnalysis;
using UnityEngine;
using UnityEngine.SceneManagement;
using UnityEngine.UI;
[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("HTFMoreItemAPI")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyDescription("Runtime custom item registration API for How to Fish")]
[assembly: AssemblyFileVersion("2.0.0.0")]
[assembly: AssemblyInformationalVersion("2.0.0+4cf7ec4204765620bc4bfcfabac8a7b944cfe3f3")]
[assembly: AssemblyProduct("HTFMoreItemAPI")]
[assembly: AssemblyTitle("HTFMoreItemAPI")]
[assembly: AssemblyVersion("2.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 HowToFish.ItemAPI
{
public sealed class GeneratedItemRegistration
{
public string ModGuid { get; set; }
public string InternalName { get; set; }
public GameObject ContentPrefab { get; set; }
public InventoryIcon InventoryIcon { get; set; }
public HTFItemHoldPoseAsset HoldPose { get; set; }
public string DisplayName { get; set; }
public float PickupRadius { get; set; } = 0.6f;
public float Buoyancy { get; set; }
public ushort NetworkCollectionId { get; set; }
public static GeneratedItemRegistration FromDefinition(HTFItemDefinitionAsset definition, string modGuid)
{
if (!Object.op_Implicit((Object)(object)definition))
{
throw new ArgumentNullException("definition");
}
string message = default(string);
if (!definition.Validate(ref message))
{
throw new ArgumentException(message, "definition");
}
return new GeneratedItemRegistration
{
ModGuid = modGuid,
InternalName = definition.InternalName,
ContentPrefab = definition.ContentPrefab,
InventoryIcon = InventoryIcon.FromTexture((Texture)(object)definition.InventoryIcon),
HoldPose = definition.HoldPose,
DisplayName = definition.DisplayName,
PickupRadius = definition.PickupRadius,
Buoyancy = definition.Buoyancy
};
}
}
internal static class GeneratedPrefabFactory
{
private const byte GenericTemplateItemId = 55;
private static readonly Guid SupportedGameMvid = new Guid("48815c0b-02c6-4024-a20a-1cb6cbfee2ec");
private static readonly FieldInfo ItemIdField = AccessTools.Field(typeof(Item), "_id");
private static readonly FieldInfo WorldCollidersField = AccessTools.Field(typeof(Item), "_worldColliders");
private static readonly FieldInfo PickupColliderField = AccessTools.Field(typeof(Item), "_pickUpCollider");
private static readonly FieldInfo RenderersField = AccessTools.Field(typeof(Item), "_renderers");
private static readonly FieldInfo SkinRenderersField = AccessTools.Field(typeof(Item), "_skinRenderers");
private static readonly FieldInfo MeshField = AccessTools.Field(typeof(Item), "_mesh");
private static readonly FieldInfo WeightField = AccessTools.Field(typeof(Item), "_weight");
private static readonly FieldInfo BuoyancyField = AccessTools.Field(typeof(Item), "_buoyancy");
private static readonly FieldInfo HeldPositionField = AccessTools.Field(typeof(Item), "_heldPos");
private static readonly FieldInfo HeldRotationField = AccessTools.Field(typeof(Item), "_heldRot");
private static readonly FieldInfo DrawStartPositionField = AccessTools.Field(typeof(Item), "_drawAnimStartPos");
private static readonly FieldInfo DrawStartRotationField = AccessTools.Field(typeof(Item), "_drawAnimStartRot");
private static readonly FieldInfo RightHandTransformsField = AccessTools.Field(typeof(Item), "_handTransformsRight");
private static readonly FieldInfo LeftHandTransformsField = AccessTools.Field(typeof(Item), "_handTransformsLeft");
private static readonly FieldInfo HoldBobMultiplierField = AccessTools.Field(typeof(Item), "_holdBobMulti");
private static readonly FieldInfo OverridePlayerVelocityField = AccessTools.Field(typeof(Item), "_overridePlayerVelAmount");
private static readonly FieldInfo PlayerVelocityAmountField = AccessTools.Field(typeof(Item), "_playerVelAmount");
private static GameObject _runtimeRoot;
internal static bool ValidateSource(GeneratedItemRegistration registration, out string error)
{
//IL_001f: Unknown result type (might be due to invalid IL or missing references)
//IL_0024: Unknown result type (might be due to invalid IL or missing references)
error = null;
if (!Object.op_Implicit((Object)(object)registration.ContentPrefab))
{
error = "ContentPrefab cannot be null.";
return false;
}
Scene scene = registration.ContentPrefab.scene;
if (((Scene)(ref scene)).IsValid())
{
error = "ContentPrefab must be a prefab asset returned by AssetBundle.LoadAsset<GameObject>().";
return false;
}
if (registration.InventoryIcon == null || !Object.op_Implicit((Object)(object)registration.InventoryIcon.Texture))
{
error = "A generated item must provide a valid icon from its AssetBundle.";
return false;
}
if (registration.PickupRadius <= 0f || float.IsNaN(registration.PickupRadius) || float.IsInfinity(registration.PickupRadius))
{
error = "PickupRadius must be a finite value greater than zero.";
return false;
}
if (float.IsNaN(registration.Buoyancy) || float.IsInfinity(registration.Buoyancy))
{
error = "Buoyancy must be a finite value.";
return false;
}
if (Object.op_Implicit((Object)(object)registration.HoldPose) && !registration.HoldPose.Validate(ref error))
{
error = "HoldPose is invalid: " + error;
return false;
}
if (Object.op_Implicit((Object)(object)registration.ContentPrefab.GetComponentInChildren<Item>(true)))
{
error = "ContentPrefab must not contain Item; the API provides it through the game skeleton.";
return false;
}
if (Object.op_Implicit((Object)(object)registration.ContentPrefab.GetComponentInChildren<RigidbodySync>(true)))
{
error = "ContentPrefab must not contain RigidbodySync; the API provides it.";
return false;
}
if (Object.op_Implicit((Object)(object)registration.ContentPrefab.GetComponentInChildren<NetworkObject>(true)))
{
error = "ContentPrefab must not contain NetworkObject; the API provides it.";
return false;
}
Rigidbody[] componentsInChildren = registration.ContentPrefab.GetComponentsInChildren<Rigidbody>(true);
Rigidbody component = registration.ContentPrefab.GetComponent<Rigidbody>();
if (componentsInChildren.Length != 1 || !Object.op_Implicit((Object)(object)component) || (Object)(object)componentsInChildren[0] != (Object)(object)component)
{
error = $"The ContentPrefab root must contain exactly one Rigidbody; the hierarchy currently contains {componentsInChildren.Length}.";
return false;
}
if (registration.ContentPrefab.GetComponentsInChildren<Collider>(true).Length == 0)
{
error = "ContentPrefab must contain at least one Collider.";
return false;
}
return true;
}
internal static bool TryCreate(string key, byte itemId, GeneratedItemRegistration registration, out Item item, out NetworkObject networkObject, out string error)
{
//IL_014c: Unknown result type (might be due to invalid IL or missing references)
//IL_015d: Unknown result type (might be due to invalid IL or missing references)
//IL_01de: Unknown result type (might be due to invalid IL or missing references)
item = null;
networkObject = null;
error = null;
Guid moduleVersionId = typeof(Item).Assembly.ManifestModule.ModuleVersionId;
if (moduleVersionId != SupportedGameMvid)
{
error = "The current Assembly-CSharp is not supported by the generation pipeline; " + $"MVID={moduleVersionId}, Supported={SupportedGameMvid}.";
return false;
}
if (!ValidateSource(registration, out error))
{
return false;
}
if (!ValidateReflection(out error))
{
return false;
}
Item spawnable = GameInfo.GetSpawnable((byte)55);
if (!ValidateTemplate(spawnable, out error))
{
return false;
}
EnsureRuntimeRoot();
GameObject val = null;
try
{
val = Object.Instantiate<GameObject>(((Component)spawnable).gameObject, _runtimeRoot.transform, false);
((Object)val).name = "HTFMoreItemAPI_" + SanitizeObjectName(key);
if (val.activeInHierarchy)
{
throw new InvalidOperationException("The generation container is unexpectedly active.");
}
Item component = val.GetComponent<Item>();
NetworkObject component2 = val.GetComponent<NetworkObject>();
Rigidbody component3 = val.GetComponent<Rigidbody>();
SphereCollider val2 = FindRootPickupCollider(val);
if (!Object.op_Implicit((Object)(object)component) || !Object.op_Implicit((Object)(object)component2) || !Object.op_Implicit((Object)(object)component3) || !Object.op_Implicit((Object)(object)val2))
{
throw new InvalidOperationException("The cloned base-item skeleton is missing required components.");
}
RemoveTemplateChildren(val.transform);
GameObject val3 = Object.Instantiate<GameObject>(registration.ContentPrefab, val.transform, false);
((Object)val3).name = "Content";
val3.transform.localPosition = Vector3.zero;
val3.transform.localRotation = Quaternion.identity;
Rigidbody[] componentsInChildren = val3.GetComponentsInChildren<Rigidbody>(true);
if (componentsInChildren.Length != 1)
{
throw new InvalidOperationException("The number of Rigidbodies changed after cloning the content prefab.");
}
CopyRigidbodySettings(componentsInChildren[0], component3);
Object.DestroyImmediate((Object)(object)componentsInChildren[0]);
Collider[] componentsInChildren2 = val3.GetComponentsInChildren<Collider>(true);
if (componentsInChildren2.Length == 0)
{
throw new InvalidOperationException("The cloned content prefab has no Collider.");
}
Collider[] array = componentsInChildren2;
foreach (Collider obj in array)
{
obj.isTrigger = false;
obj.enabled = true;
}
((Collider)val2).isTrigger = true;
val2.center = Vector3.zero;
val2.radius = registration.PickupRadius;
((Collider)val2).enabled = true;
List<Renderer> list = new List<Renderer>(val3.GetComponentsInChildren<Renderer>(true));
List<Renderer> list2 = new List<Renderer>();
foreach (Renderer item2 in list)
{
if (item2 is SkinnedMeshRenderer)
{
list2.Add(item2);
}
}
Mesh value = FindFirstMesh(val3);
ItemIdField.SetValue(component, itemId);
WorldCollidersField.SetValue(component, componentsInChildren2);
PickupColliderField.SetValue(component, val2);
RenderersField.SetValue(component, list);
SkinRenderersField.SetValue(component, list2);
MeshField.SetValue(component, value);
WeightField.SetValue(component, component3.mass);
BuoyancyField.SetValue(component, registration.Buoyancy);
if (Object.op_Implicit((Object)(object)registration.HoldPose))
{
ApplyHoldPose(component, val.transform, registration.HoldPose);
}
component2.SetIsSpawnable(true);
item = component;
networkObject = component2;
return true;
}
catch (Exception ex)
{
if (Object.op_Implicit((Object)(object)val))
{
Object.DestroyImmediate((Object)(object)val);
}
error = "Failed to generate the item skeleton: " + ex.GetType().Name + ": " + ex.Message;
return false;
}
}
internal static void Shutdown()
{
if (Object.op_Implicit((Object)(object)_runtimeRoot))
{
Object.Destroy((Object)(object)_runtimeRoot);
}
_runtimeRoot = null;
}
private static bool ValidateReflection(out string error)
{
error = null;
if (ItemIdField != null && WorldCollidersField != null && PickupColliderField != null && RenderersField != null && SkinRenderersField != null && MeshField != null && WeightField != null && BuoyancyField != null && HeldPositionField != null && HeldRotationField != null && DrawStartPositionField != null && DrawStartRotationField != null && RightHandTransformsField != null && LeftHandTransformsField != null && HoldBobMultiplierField != null && OverridePlayerVelocityField != null && PlayerVelocityAmountField != null)
{
return true;
}
error = "The current game version is missing Item serialization fields required by the generation pipeline.";
return false;
}
private static bool ValidateTemplate(Item template, out string error)
{
error = null;
if (!Object.op_Implicit((Object)(object)template))
{
error = $"The original generic item template ItemId={(byte)55} was not found.";
return false;
}
if (((object)template).GetType() != typeof(Item))
{
error = "The generic template must be exactly Item, but was " + ((object)template).GetType().FullName + ".";
return false;
}
if (!Object.op_Implicit((Object)(object)((Component)template).GetComponent<NetworkObject>()) || !Object.op_Implicit((Object)(object)((Component)template).GetComponent<RigidbodySync>()) || !Object.op_Implicit((Object)(object)((Component)template).GetComponent<Rigidbody>()))
{
error = "The original generic item template is missing NetworkObject, RigidbodySync, or Rigidbody.";
return false;
}
NetworkBehaviour[] components = ((Component)template).GetComponents<NetworkBehaviour>();
if (components.Length != 2)
{
error = $"The original generic template must contain 2 NetworkBehaviours, but contains {components.Length}.";
return false;
}
if ((Object)(object)FindRootPickupCollider(((Component)template).gameObject) == (Object)null)
{
error = "The original generic item template is missing its root pickup SphereCollider.";
return false;
}
return true;
}
private static void EnsureRuntimeRoot()
{
//IL_0012: Unknown result type (might be due to invalid IL or missing references)
//IL_001c: Expected O, but got Unknown
if (!Object.op_Implicit((Object)(object)_runtimeRoot))
{
_runtimeRoot = new GameObject("HTFMoreItemAPI.RuntimePrefabs");
((Object)_runtimeRoot).hideFlags = (HideFlags)61;
Object.DontDestroyOnLoad((Object)(object)_runtimeRoot);
_runtimeRoot.SetActive(false);
}
}
private static SphereCollider FindRootPickupCollider(GameObject root)
{
SphereCollider[] components = root.GetComponents<SphereCollider>();
foreach (SphereCollider val in components)
{
if (((Collider)val).isTrigger)
{
return val;
}
}
return null;
}
private static void RemoveTemplateChildren(Transform root)
{
for (int num = root.childCount - 1; num >= 0; num--)
{
Object.DestroyImmediate((Object)(object)((Component)root.GetChild(num)).gameObject);
}
}
private static void CopyRigidbodySettings(Rigidbody source, Rigidbody target)
{
//IL_003e: 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_0056: Unknown result type (might be due to invalid IL or missing references)
//IL_009a: Unknown result type (might be due to invalid IL or missing references)
//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
target.mass = source.mass;
target.linearDamping = source.linearDamping;
target.angularDamping = source.angularDamping;
target.useGravity = source.useGravity;
target.isKinematic = source.isKinematic;
target.interpolation = source.interpolation;
target.collisionDetectionMode = source.collisionDetectionMode;
target.constraints = source.constraints;
target.detectCollisions = source.detectCollisions;
target.maxAngularVelocity = source.maxAngularVelocity;
target.maxLinearVelocity = source.maxLinearVelocity;
target.automaticCenterOfMass = source.automaticCenterOfMass;
if (!source.automaticCenterOfMass)
{
target.centerOfMass = source.centerOfMass;
}
target.automaticInertiaTensor = source.automaticInertiaTensor;
if (!source.automaticInertiaTensor)
{
target.inertiaTensor = source.inertiaTensor;
target.inertiaTensorRotation = source.inertiaTensorRotation;
}
}
private static void ApplyHoldPose(Item item, Transform itemRoot, HTFItemHoldPoseAsset pose)
{
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
//IL_001d: Unknown result type (might be due to invalid IL or missing references)
//IL_0033: Unknown result type (might be due to invalid IL or missing references)
//IL_0049: Unknown result type (might be due to invalid IL or missing references)
HeldPositionField.SetValue(item, pose.HeldPosition);
HeldRotationField.SetValue(item, pose.HeldRotation);
DrawStartPositionField.SetValue(item, pose.DrawStartPosition);
DrawStartRotationField.SetValue(item, pose.DrawStartRotation);
RightHandTransformsField.SetValue(item, CreateGameHandPose(pose.RightHand, itemRoot));
LeftHandTransformsField.SetValue(item, CreateGameHandPose(pose.LeftHand, itemRoot));
HoldBobMultiplierField.SetValue(item, pose.HoldBobMultiplier);
OverridePlayerVelocityField.SetValue(item, pose.OverridePlayerVelocityAmount);
PlayerVelocityAmountField.SetValue(item, pose.PlayerVelocityAmount);
}
private static HandTransforms CreateGameHandPose(HTFHandPoseData source, Transform itemRoot)
{
//IL_000c: Unknown result type (might be due to invalid IL or missing references)
//IL_0012: Expected O, but got Unknown
//IL_004f: Unknown result type (might be due to invalid IL or missing references)
//IL_0055: Unknown result type (might be due to invalid IL or missing references)
//IL_005c: Unknown result type (might be due to invalid IL or missing references)
//IL_0062: Expected O, but got Unknown
if (source != null && source.Enabled)
{
Quaternion[] fingerLocalRotations = source.FingerLocalRotations;
if (fingerLocalRotations == null || fingerLocalRotations.Length != 15)
{
throw new InvalidOperationException($"An enabled hand pose must contain {15} finger-joint rotations.");
}
Quaternion[] array = (Quaternion[])(object)new Quaternion[fingerLocalRotations.Length];
Array.Copy(fingerLocalRotations, array, array.Length);
return new HandTransforms(true, source.HandPosition, source.HandRotation, array, itemRoot);
}
return new HandTransforms(false);
}
private static Mesh FindFirstMesh(GameObject content)
{
MeshFilter[] componentsInChildren = content.GetComponentsInChildren<MeshFilter>(true);
foreach (MeshFilter val in componentsInChildren)
{
if (Object.op_Implicit((Object)(object)val.sharedMesh))
{
return val.sharedMesh;
}
}
SkinnedMeshRenderer[] componentsInChildren2 = content.GetComponentsInChildren<SkinnedMeshRenderer>(true);
foreach (SkinnedMeshRenderer val2 in componentsInChildren2)
{
if (Object.op_Implicit((Object)(object)val2.sharedMesh))
{
return val2.sharedMesh;
}
}
return null;
}
private static string SanitizeObjectName(string value)
{
return value.Replace(':', '_').Replace('/', '_').Replace('\\', '_');
}
}
public sealed class InventoryIcon
{
public Texture Texture { get; }
public Rect UvRect { get; }
public Color Tint { get; }
public InventoryIcon(Texture texture)
: this(texture, new Rect(0f, 0f, 1f, 1f), Color.white)
{
}//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)
public InventoryIcon(Texture texture, Rect uvRect, Color tint)
{
//IL_0021: 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_0028: Unknown result type (might be due to invalid IL or missing references)
//IL_0029: Unknown result type (might be due to invalid IL or missing references)
if (!Object.op_Implicit((Object)(object)texture))
{
throw new ArgumentNullException("texture");
}
Texture = texture;
UvRect = uvRect;
Tint = tint;
}
public static InventoryIcon FromTexture(Texture texture)
{
return new InventoryIcon(texture);
}
public static InventoryIcon FromSprite(Sprite sprite)
{
//IL_001b: 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_0065: Unknown result type (might be due to invalid IL or missing references)
//IL_0066: Unknown result type (might be due to invalid IL or missing references)
if (!Object.op_Implicit((Object)(object)sprite))
{
throw new ArgumentNullException("sprite");
}
Texture2D texture = sprite.texture;
Rect textureRect = sprite.textureRect;
Rect uvRect = default(Rect);
((Rect)(ref uvRect))..ctor(((Rect)(ref textureRect)).x / (float)((Texture)texture).width, ((Rect)(ref textureRect)).y / (float)((Texture)texture).height, ((Rect)(ref textureRect)).width / (float)((Texture)texture).width, ((Rect)(ref textureRect)).height / (float)((Texture)texture).height);
return new InventoryIcon((Texture)(object)texture, uvRect, Color.white);
}
}
public static class ItemApiMetadata
{
public const string PluginGuid = "xiaohai.HTF.MoreItemAPI";
public const string PluginName = "HTF MoreItemAPI";
public const string PluginVersion = "2.0.0";
}
[HarmonyPatch(typeof(GameInfo), "Awake")]
internal static class GameInfoAwakePatch
{
[HarmonyPostfix]
private static void Postfix()
{
RegistryRuntime.OnGameInfoAwakeCompleted();
}
}
[HarmonyPatch(typeof(Item), "GetName")]
internal static class CustomItemNamePatch
{
[HarmonyPostfix]
private static void Postfix(Item __instance, ref string __result)
{
if (Object.op_Implicit((Object)(object)__instance) && RegistryRuntime.TryGetDisplayName(__instance.ID, out var displayName))
{
__result = displayName;
}
}
}
[HarmonyPatch(typeof(InventorySlot), "SetItem")]
internal static class InventorySlotIconPatch
{
private sealed class NativeImageState
{
internal Texture Texture;
internal Rect UvRect;
internal Color Color;
internal bool Enabled;
}
private static readonly FieldInfo FilterField = AccessTools.Field(typeof(InventorySlot), "_filter");
private static readonly FieldInfo ImageField = AccessTools.Field(typeof(InventorySlot), "_itemImage");
private static readonly Dictionary<RawImage, NativeImageState> NativeStates = new Dictionary<RawImage, NativeImageState>();
[HarmonyPostfix]
private static void Postfix(InventorySlot __instance, Item item)
{
//IL_0053: Unknown result type (might be due to invalid IL or missing references)
//IL_0058: Unknown result type (might be due to invalid IL or missing references)
//IL_005f: Unknown result type (might be due to invalid IL or missing references)
//IL_0064: Unknown result type (might be due to invalid IL or missing references)
//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
//IL_0113: Unknown result type (might be due to invalid IL or missing references)
//IL_011f: Unknown result type (might be due to invalid IL or missing references)
//IL_0136: Unknown result type (might be due to invalid IL or missing references)
if ((Object)(object)__instance == (Object)null || ImageField == null)
{
return;
}
object? value = ImageField.GetValue(__instance);
RawImage val = (RawImage)((value is RawImage) ? value : null);
if (!Object.op_Implicit((Object)(object)val))
{
return;
}
if (!NativeStates.TryGetValue(val, out var value2))
{
value2 = new NativeImageState
{
Texture = val.texture,
UvRect = val.uvRect,
Color = ((Graphic)val).color,
Enabled = ((Behaviour)val).enabled
};
NativeStates.Add(val, value2);
}
if (!Object.op_Implicit((Object)(object)item) || !RegistryRuntime.TryGetIcon(item.ID, out var icon))
{
val.texture = (Texture)(Object.op_Implicit((Object)(object)value2.Texture) ? ((object)value2.Texture) : ((object)GameInfo.InventoryTexture));
val.uvRect = value2.UvRect;
((Graphic)val).color = value2.Color;
((Behaviour)val).enabled = value2.Enabled;
return;
}
object? obj = FilterField?.GetValue(__instance);
MeshFilter val2 = (MeshFilter)((obj is MeshFilter) ? obj : null);
if (Object.op_Implicit((Object)(object)val2))
{
val2.mesh = null;
}
val.texture = icon.Texture;
val.uvRect = icon.UvRect;
((Graphic)val).color = icon.Tint;
((Behaviour)val).enabled = true;
((Component)val).transform.localScale = Vector3.one;
}
}
[BepInPlugin("xiaohai.HTF.MoreItemAPI", "HTF MoreItemAPI", "2.0.0")]
public sealed class ItemApiPlugin : BaseUnityPlugin
{
private Harmony _harmony;
private void Awake()
{
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
//IL_001b: Expected O, but got Unknown
RegistryRuntime.Initialize(((BaseUnityPlugin)this).Logger);
_harmony = new Harmony("xiaohai.HTF.MoreItemAPI");
_harmony.PatchAll(typeof(ItemApiPlugin).Assembly);
((BaseUnityPlugin)this).Logger.LogInfo((object)"HTF MoreItemAPI v2.0.0 loaded.");
}
private void Update()
{
RegistryRuntime.Tick();
}
private void OnDestroy()
{
Harmony harmony = _harmony;
if (harmony != null)
{
harmony.UnpatchSelf();
}
GeneratedPrefabFactory.Shutdown();
RegistryRuntime.Shutdown();
}
}
internal static class ItemIdAllocator
{
internal const int SlotCount = 256;
internal static Dictionary<string, byte> Allocate(IEnumerable<string> keys, IEnumerable<byte> occupiedIds)
{
if (keys == null)
{
throw new ArgumentNullException("keys");
}
HashSet<byte> hashSet = ((occupiedIds == null) ? new HashSet<byte>() : new HashSet<byte>(occupiedIds));
hashSet.Add(byte.MaxValue);
List<string> list = new List<string>();
foreach (string key in keys)
{
if (string.IsNullOrWhiteSpace(key))
{
throw new ArgumentException("Allocation keys cannot be null or empty.", "keys");
}
list.Add(key);
}
list.Sort(StringComparer.Ordinal);
if (list.Count > 256 - hashSet.Count)
{
throw new InvalidOperationException($"No free Item ID slots remain: requested={list.Count}, free={256 - hashSet.Count}.");
}
Dictionary<string, byte> dictionary = new Dictionary<string, byte>(StringComparer.OrdinalIgnoreCase);
foreach (string item in list)
{
if (dictionary.ContainsKey(item))
{
throw new InvalidOperationException("Duplicate item registration key '" + item + "'.");
}
byte b = DerivePreferredId(item);
bool flag = false;
for (int i = 0; i < 256; i++)
{
byte b2 = (byte)(b + i);
if (hashSet.Add(b2))
{
dictionary.Add(item, b2);
flag = true;
break;
}
}
if (!flag)
{
throw new InvalidOperationException("No free Item ID slots remain.");
}
}
return dictionary;
}
internal static byte DerivePreferredId(string key)
{
uint num = 2166136261u;
byte[] bytes = Encoding.UTF8.GetBytes(key);
foreach (byte b in bytes)
{
num ^= b;
num *= 16777619;
}
return (byte)num;
}
}
public sealed class ItemRegistration
{
public string ModGuid { get; set; }
public string InternalName { get; set; }
public GameObject Prefab { get; set; }
public string DisplayName { get; set; }
public InventoryIcon InventoryIcon { get; set; }
public ushort NetworkCollectionId { get; set; }
}
public enum ItemRegistrationState
{
Rejected,
PendingGameRegistry,
PendingNetworkManager,
Registered,
Failed
}
public sealed class ItemRegistrationHandle
{
public string Key { get; }
public byte? ItemId { get; internal set; }
public bool HasAssignedItemId => ItemId.HasValue;
public ushort NetworkCollectionId { get; }
public Item ItemPrefab { get; internal set; }
public ItemRegistrationState State { get; internal set; }
public string Message { get; internal set; }
public bool IsRegistered => State == ItemRegistrationState.Registered;
internal ItemRegistrationHandle(string key, ushort networkCollectionId, Item itemPrefab, ItemRegistrationState state, string message)
{
Key = key;
NetworkCollectionId = networkCollectionId;
ItemPrefab = itemPrefab;
State = state;
Message = message;
}
public override string ToString()
{
string text = (ItemId.HasValue ? ItemId.Value.ToString() : "<auto-pending>");
return $"{Key} (ItemId={text}, CollectionId={NetworkCollectionId}, State={State})";
}
}
public static class ItemRegistry
{
public static event Action<ItemRegistrationHandle> RegistrationChanged;
public static ItemRegistrationHandle Register(ItemRegistration registration)
{
return RegistryRuntime.Register(registration);
}
public static ItemRegistrationHandle RegisterGenerated(GeneratedItemRegistration registration)
{
return RegistryRuntime.RegisterGenerated(registration);
}
public static bool TryGet(byte itemId, out ItemRegistrationHandle handle)
{
return RegistryRuntime.TryGet(itemId, out handle);
}
public static bool TryGet(string modGuid, string internalName, out ItemRegistrationHandle handle)
{
return RegistryRuntime.TryGet(RegistryRuntime.BuildKey(modGuid, internalName), out handle);
}
public static IReadOnlyList<ItemRegistrationHandle> GetAll()
{
return RegistryRuntime.GetAllHandles();
}
internal static void RaiseRegistrationChanged(ItemRegistrationHandle handle)
{
Action<ItemRegistrationHandle> registrationChanged = ItemRegistry.RegistrationChanged;
if (registrationChanged == null)
{
return;
}
try
{
registrationChanged(handle);
}
catch (Exception exception)
{
RegistryRuntime.LogSubscriberException(exception);
}
}
}
internal static class RegistryRuntime
{
private sealed class RegistrationRecord
{
internal string Key;
internal string NormalizedName;
internal string DisplayName;
internal Item ItemPrefab;
internal NetworkObject NetworkPrefab;
internal InventoryIcon Icon;
internal GeneratedItemRegistration GeneratedRegistration;
internal ItemRegistrationHandle Handle;
internal bool GameRegistryApplied;
internal readonly HashSet<NetworkManager> RegisteredNetworkManagers = new HashSet<NetworkManager>();
}
private static readonly object Sync = new object();
private static readonly Dictionary<string, RegistrationRecord> ByKey = new Dictionary<string, RegistrationRecord>(StringComparer.OrdinalIgnoreCase);
private static readonly Dictionary<byte, RegistrationRecord> ById = new Dictionary<byte, RegistrationRecord>();
private static readonly Dictionary<ushort, RegistrationRecord> ByCollectionId = new Dictionary<ushort, RegistrationRecord>();
private static readonly FieldInfo ItemIdField = AccessTools.Field(typeof(Item), "_id");
private static readonly FieldInfo GameInfoInstanceField = AccessTools.Field(typeof(GameInfo), "_instance");
private static readonly FieldInfo AllItemsField = AccessTools.Field(typeof(GameInfo), "_allItems");
private static readonly FieldInfo NameToSpawnableField = AccessTools.Field(typeof(GameInfo), "_nameToSpawnable");
private static readonly FieldInfo IdToSpawnableField = AccessTools.Field(typeof(GameInfo), "_idToSpawnable");
private static ManualLogSource _logger;
private static int _mainThreadId;
private static bool _initialized;
private static bool _gameInfoAwakeCompleted;
private static float _nextRetryAt;
internal static void Initialize(ManualLogSource logger)
{
_logger = logger;
_mainThreadId = Thread.CurrentThread.ManagedThreadId;
_initialized = true;
_gameInfoAwakeCompleted = GameInfoInstanceField?.GetValue(null) != null;
if (ItemIdField == null || GameInfoInstanceField == null || AllItemsField == null || NameToSpawnableField == null || IdToSpawnableField == null)
{
_logger.LogError((object)"[ItemAPI] The current game version is missing expected Item/GameInfo fields; registration will fail safely.");
}
}
internal static void Shutdown()
{
_initialized = false;
_logger = null;
}
internal static ItemRegistrationHandle Register(ItemRegistration registration)
{
//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
if (!_initialized)
{
return Rejected("<unknown>", 0, null, "The Item API plugin is not initialized. Declare a hard BepInEx dependency.");
}
if (Thread.CurrentThread.ManagedThreadId != _mainThreadId)
{
return Rejected("<unknown>", 0, null, "Register must be called from Unity's main thread.");
}
if (registration == null)
{
return Rejected("<unknown>", 0, null, "registration cannot be null.");
}
string key;
try
{
key = BuildKey(registration.ModGuid, registration.InternalName);
}
catch (ArgumentException ex)
{
return Rejected("<invalid>", 0, null, ex.Message);
}
if (!Object.op_Implicit((Object)(object)registration.Prefab))
{
return Rejected(key, 0, null, "Prefab cannot be null.");
}
Scene scene = registration.Prefab.scene;
if (((Scene)(ref scene)).IsValid())
{
return Rejected(key, 0, null, "Prefab is a scene instance. Pass the prefab asset returned by AssetBundle.LoadAsset<GameObject>() directly.");
}
Item component = registration.Prefab.GetComponent<Item>();
if (!Object.op_Implicit((Object)(object)component))
{
return Rejected(key, 0, null, "The prefab root is missing an Item component.");
}
NetworkObject component2 = registration.Prefab.GetComponent<NetworkObject>();
if (!Object.op_Implicit((Object)(object)component2))
{
return Rejected(key, 0, component, "The prefab root is missing a FishNet NetworkObject component.");
}
if (ItemIdField == null)
{
return Rejected(key, 0, component, "Item._id could not be located in the current game version.");
}
ushort num = ((registration.NetworkCollectionId != 0) ? registration.NetworkCollectionId : DeriveCollectionId(key));
string text = NormalizeName(registration.InternalName);
if (text.Length == 0)
{
return Rejected(key, num, component, "InternalName cannot be empty after normalization.");
}
lock (Sync)
{
if (ByKey.TryGetValue(key, out var value))
{
if ((Object)(object)value.ItemPrefab == (Object)(object)component)
{
return value.Handle;
}
return Rejected(key, num, component, "The registration key is already used by another prefab.");
}
if (ByCollectionId.TryGetValue(num, out var value2))
{
return Rejected(key, num, component, "FishNet collection ID is already used by " + value2.Key + "; explicitly specify another NetworkCollectionId.");
}
component2.SetIsSpawnable(true);
ItemRegistrationHandle itemRegistrationHandle = new ItemRegistrationHandle(key, num, component, ItemRegistrationState.PendingGameRegistry, "Waiting for GameInfo to complete original item registration.");
RegistrationRecord value3 = new RegistrationRecord
{
Key = key,
NormalizedName = text,
DisplayName = registration.DisplayName,
ItemPrefab = component,
NetworkPrefab = component2,
Icon = registration.InventoryIcon,
Handle = itemRegistrationHandle
};
ByKey.Add(key, value3);
ByCollectionId.Add(num, value3);
_logger.LogInfo((object)$"[ItemAPI] Accepted {itemRegistrationHandle}.");
}
ProcessRegistrations();
return GetHandleByKey(key);
}
internal static ItemRegistrationHandle RegisterGenerated(GeneratedItemRegistration registration)
{
if (!_initialized)
{
return Rejected("<unknown>", 0, null, "The Item API plugin is not initialized. Declare a hard BepInEx dependency.");
}
if (Thread.CurrentThread.ManagedThreadId != _mainThreadId)
{
return Rejected("<unknown>", 0, null, "RegisterGenerated must be called from Unity's main thread.");
}
if (registration == null)
{
return Rejected("<unknown>", 0, null, "registration cannot be null.");
}
string key;
try
{
key = BuildKey(registration.ModGuid, registration.InternalName);
}
catch (ArgumentException ex)
{
return Rejected("<invalid>", 0, null, ex.Message);
}
ushort num = ((registration.NetworkCollectionId != 0) ? registration.NetworkCollectionId : DeriveCollectionId(key));
string text = NormalizeName(registration.InternalName);
if (text.Length == 0)
{
return Rejected(key, num, null, "InternalName cannot be empty after normalization.");
}
if (!GeneratedPrefabFactory.ValidateSource(registration, out var error))
{
return Rejected(key, num, null, error);
}
lock (Sync)
{
if (ByKey.TryGetValue(key, out var value))
{
if (value.GeneratedRegistration != null && (Object)(object)value.GeneratedRegistration.ContentPrefab == (Object)(object)registration.ContentPrefab)
{
return value.Handle;
}
return Rejected(key, num, null, "The registration key is already used by another generated-item definition.");
}
if (ByCollectionId.TryGetValue(num, out var value2))
{
return Rejected(key, num, null, "FishNet collection ID is already used by " + value2.Key + "; explicitly specify another NetworkCollectionId.");
}
GeneratedItemRegistration generatedItemRegistration = new GeneratedItemRegistration
{
ModGuid = registration.ModGuid,
InternalName = registration.InternalName,
ContentPrefab = registration.ContentPrefab,
InventoryIcon = registration.InventoryIcon,
HoldPose = registration.HoldPose,
DisplayName = registration.DisplayName,
PickupRadius = registration.PickupRadius,
Buoyancy = registration.Buoyancy,
NetworkCollectionId = num
};
ItemRegistrationHandle itemRegistrationHandle = new ItemRegistrationHandle(key, num, null, ItemRegistrationState.PendingGameRegistry, "Waiting for GameInfo before generating the original item skeleton.");
RegistrationRecord value3 = new RegistrationRecord
{
Key = key,
NormalizedName = text,
DisplayName = generatedItemRegistration.DisplayName,
GeneratedRegistration = generatedItemRegistration,
Icon = generatedItemRegistration.InventoryIcon,
Handle = itemRegistrationHandle
};
ByKey.Add(key, value3);
ByCollectionId.Add(num, value3);
_logger.LogInfo((object)$"[ItemAPI] Accepted generated item {itemRegistrationHandle}.");
}
ProcessRegistrations();
return GetHandleByKey(key);
}
internal static void Tick()
{
if (_initialized && !(Time.unscaledTime < _nextRetryAt))
{
_nextRetryAt = Time.unscaledTime + 0.25f;
ProcessRegistrations();
}
}
internal static void OnGameInfoAwakeCompleted()
{
_gameInfoAwakeCompleted = true;
ProcessRegistrations();
}
private static void ProcessRegistrations()
{
if (!_initialized || Thread.CurrentThread.ManagedThreadId != _mainThreadId)
{
return;
}
RegistrationRecord[] array;
lock (Sync)
{
array = new RegistrationRecord[ByKey.Count];
ByKey.Values.CopyTo(array, 0);
}
if (_gameInfoAwakeCompleted)
{
AssignPendingItemIds(array);
}
RegistrationRecord[] array2 = array;
foreach (RegistrationRecord registrationRecord in array2)
{
if (registrationRecord.Handle.State == ItemRegistrationState.Failed || registrationRecord.Handle.State == ItemRegistrationState.Rejected)
{
continue;
}
if (!_gameInfoAwakeCompleted)
{
SetState(registrationRecord, ItemRegistrationState.PendingGameRegistry, "Waiting for GameInfo before HTF MoreItemAPI assigns a game-local Item ID.");
continue;
}
if (!registrationRecord.Handle.ItemId.HasValue)
{
SetState(registrationRecord, ItemRegistrationState.PendingGameRegistry, "Waiting for HTF MoreItemAPI to assign a free game-local Item ID.");
continue;
}
if (!Object.op_Implicit((Object)(object)registrationRecord.ItemPrefab))
{
if (registrationRecord.GeneratedRegistration == null)
{
Fail(registrationRecord, "The registration record does not contain a valid Item prefab.");
continue;
}
if (!GeneratedPrefabFactory.TryCreate(registrationRecord.Key, registrationRecord.Handle.ItemId.Value, registrationRecord.GeneratedRegistration, out var item, out var networkObject, out var error))
{
Fail(registrationRecord, error);
continue;
}
registrationRecord.ItemPrefab = item;
registrationRecord.NetworkPrefab = networkObject;
registrationRecord.Handle.ItemPrefab = item;
_logger.LogInfo((object)("[ItemAPI] Generated the item skeleton for " + registrationRecord.Key + " through the fixed pipeline; " + $"WorldColliders={((Component)item).GetComponentsInChildren<Collider>(true).Length - 1}."));
}
if (!registrationRecord.GameRegistryApplied && !TryApplyGameRegistry(registrationRecord, out var error2))
{
Fail(registrationRecord, error2);
continue;
}
NetworkManager networkManager = InstanceFinder.NetworkManager;
if (!Object.op_Implicit((Object)(object)networkManager))
{
SetState(registrationRecord, ItemRegistrationState.PendingNetworkManager, "The game registry is ready; waiting for FishNet NetworkManager.");
continue;
}
if (!registrationRecord.RegisteredNetworkManagers.Contains(networkManager))
{
if (!TryApplyNetworkRegistry(registrationRecord, networkManager, out var error3))
{
Fail(registrationRecord, error3);
continue;
}
registrationRecord.RegisteredNetworkManagers.Add(networkManager);
}
SetState(registrationRecord, ItemRegistrationState.Registered, "Registered with GameInfo and the FishNet runtime spawnable collection.");
}
}
private static void AssignPendingItemIds(RegistrationRecord[] records)
{
if (AllItemsField == null || IdToSpawnableField == null || ItemIdField == null)
{
return;
}
Dictionary<byte, Item> dictionary = AllItemsField.GetValue(null) as Dictionary<byte, Item>;
Dictionary<byte, Item> dictionary2 = IdToSpawnableField.GetValue(null) as Dictionary<byte, Item>;
if (dictionary == null || dictionary2 == null)
{
return;
}
List<RegistrationRecord> list = new List<RegistrationRecord>();
HashSet<byte> hashSet = new HashSet<byte>(dictionary.Keys);
hashSet.UnionWith(dictionary2.Keys);
lock (Sync)
{
hashSet.UnionWith(ById.Keys);
foreach (RegistrationRecord registrationRecord in records)
{
if (!registrationRecord.Handle.ItemId.HasValue && registrationRecord.Handle.State != ItemRegistrationState.Failed && registrationRecord.Handle.State != ItemRegistrationState.Rejected)
{
list.Add(registrationRecord);
}
}
}
if (list.Count == 0)
{
return;
}
List<string> list2 = new List<string>(list.Count);
foreach (RegistrationRecord item in list)
{
list2.Add(item.Key);
}
Dictionary<string, byte> dictionary3;
try
{
dictionary3 = ItemIdAllocator.Allocate(list2, hashSet);
}
catch (InvalidOperationException ex)
{
foreach (RegistrationRecord item2 in list)
{
Fail(item2, "Automatic Item ID allocation failed: " + ex.Message);
}
return;
}
lock (Sync)
{
foreach (RegistrationRecord item3 in list)
{
if (!item3.Handle.ItemId.HasValue)
{
byte b = dictionary3[item3.Key];
item3.Handle.ItemId = b;
ById.Add(b, item3);
if (Object.op_Implicit((Object)(object)item3.ItemPrefab))
{
ItemIdField.SetValue(item3.ItemPrefab, b);
}
_logger.LogInfo((object)($"[ItemAPI] Automatically assigned ItemId={b} to {item3.Key}; " + $"Preferred={ItemIdAllocator.DerivePreferredId(item3.Key)}."));
}
}
}
}
private static bool TryApplyGameRegistry(RegistrationRecord record, out string error)
{
error = null;
if (AllItemsField == null || NameToSpawnableField == null || IdToSpawnableField == null)
{
error = "GameInfo registry fields could not be located in the current game version.";
return false;
}
Dictionary<byte, Item> dictionary = AllItemsField.GetValue(null) as Dictionary<byte, Item>;
Dictionary<string, Item> dictionary2 = NameToSpawnableField.GetValue(null) as Dictionary<string, Item>;
Dictionary<byte, Item> dictionary3 = IdToSpawnableField.GetValue(null) as Dictionary<byte, Item>;
if (dictionary == null || dictionary2 == null || dictionary3 == null)
{
error = "The GameInfo registry is not available yet.";
return false;
}
byte value = record.Handle.ItemId.Value;
if (dictionary.TryGetValue(value, out var value2) && (Object)(object)value2 != (Object)(object)record.ItemPrefab)
{
error = $"Automatically assigned Item ID {value} is already used by {Describe(value2)} from the game or another mod.";
return false;
}
if (dictionary3.TryGetValue(value, out var value3) && (Object)(object)value3 != (Object)(object)record.ItemPrefab)
{
error = $"Automatically assigned Spawnable ID {value} is already used by {Describe(value3)}.";
return false;
}
if (dictionary2.TryGetValue(record.NormalizedName, out var value4) && (Object)(object)value4 != (Object)(object)record.ItemPrefab)
{
error = "Normalized name '" + record.NormalizedName + "' is already used by " + Describe(value4) + ".";
return false;
}
dictionary[value] = record.ItemPrefab;
dictionary3[value] = record.ItemPrefab;
dictionary2[record.NormalizedName] = record.ItemPrefab;
record.GameRegistryApplied = true;
_logger.LogInfo((object)$"[ItemAPI] Added {record.Key} to GameInfo, ItemId={value}.");
return true;
}
private static bool TryApplyNetworkRegistry(RegistrationRecord record, NetworkManager manager, out string error)
{
error = null;
ushort networkCollectionId = record.Handle.NetworkCollectionId;
PrefabObjects prefabObjects = manager.GetPrefabObjects<DefaultPrefabObjects>(networkCollectionId, false);
if ((Object)(object)prefabObjects != (Object)null && prefabObjects.GetObjectCount() > 0)
{
if ((Object)(object)prefabObjects.GetObject(true, 0) == (Object)(object)record.NetworkPrefab)
{
return true;
}
error = $"FishNet runtime collection {networkCollectionId} is already used by an external mod.";
return false;
}
if (InstanceFinder.IsClientStarted || InstanceFinder.IsServerStarted)
{
error = "The network session has already started, so network items cannot be appended safely. Call Register before connecting or hosting.";
return false;
}
PrefabObjects val = prefabObjects ?? manager.GetPrefabObjects<DefaultPrefabObjects>(networkCollectionId, true);
if ((Object)(object)val == (Object)null)
{
error = $"FishNet could not create runtime collection {networkCollectionId}.";
return false;
}
val.AddObject(record.NetworkPrefab, true, true);
if (val.GetObjectCount() != 1 || (Object)(object)val.GetObject(true, 0) != (Object)(object)record.NetworkPrefab)
{
error = $"FishNet runtime collection {networkCollectionId} is inconsistent after initialization.";
return false;
}
_logger.LogInfo((object)$"[ItemAPI] Added {record.Key} to FishNet collection={networkCollectionId}, PrefabId=0.");
return true;
}
internal static bool TryGet(byte itemId, out ItemRegistrationHandle handle)
{
lock (Sync)
{
if (ById.TryGetValue(itemId, out var value))
{
handle = value.Handle;
return true;
}
}
handle = null;
return false;
}
internal static bool TryGet(string key, out ItemRegistrationHandle handle)
{
lock (Sync)
{
if (key != null && ByKey.TryGetValue(key, out var value))
{
handle = value.Handle;
return true;
}
}
handle = null;
return false;
}
internal static bool TryGetIcon(byte itemId, out InventoryIcon icon)
{
lock (Sync)
{
if (ById.TryGetValue(itemId, out var value) && value.Icon != null && Object.op_Implicit((Object)(object)value.Icon.Texture))
{
icon = value.Icon;
return true;
}
}
icon = null;
return false;
}
internal static bool TryGetDisplayName(byte itemId, out string displayName)
{
lock (Sync)
{
if (ById.TryGetValue(itemId, out var value) && !string.IsNullOrWhiteSpace(value.DisplayName))
{
displayName = value.DisplayName;
return true;
}
}
displayName = null;
return false;
}
internal static IReadOnlyList<ItemRegistrationHandle> GetAllHandles()
{
lock (Sync)
{
List<ItemRegistrationHandle> list = new List<ItemRegistrationHandle>(ByKey.Count);
foreach (RegistrationRecord value in ByKey.Values)
{
list.Add(value.Handle);
}
list.Sort(delegate(ItemRegistrationHandle left, ItemRegistrationHandle right)
{
if (left.ItemId.HasValue && right.ItemId.HasValue)
{
return left.ItemId.Value.CompareTo(right.ItemId.Value);
}
if (left.ItemId.HasValue)
{
return -1;
}
return right.ItemId.HasValue ? 1 : string.Compare(left.Key, right.Key, StringComparison.Ordinal);
});
return list;
}
}
internal static string BuildKey(string modGuid, string internalName)
{
if (string.IsNullOrWhiteSpace(modGuid))
{
throw new ArgumentException("ModGuid cannot be empty.", "modGuid");
}
if (string.IsNullOrWhiteSpace(internalName))
{
throw new ArgumentException("InternalName cannot be empty.", "internalName");
}
return modGuid.Trim().ToLowerInvariant() + ":" + internalName.Trim().ToLowerInvariant();
}
private static string NormalizeName(string value)
{
return value.Replace(" ", string.Empty).Trim().ToLowerInvariant();
}
private static ushort DeriveCollectionId(string key)
{
uint num = 2166136261u;
byte[] bytes = Encoding.UTF8.GetBytes(key);
foreach (byte b in bytes)
{
num ^= b;
num *= 16777619;
}
return (ushort)(32768 + num % 32767);
}
private static ItemRegistrationHandle Rejected(string key, ushort collectionId, Item item, string message)
{
ManualLogSource logger = _logger;
if (logger != null)
{
logger.LogError((object)("[ItemAPI] Rejected registration " + key + ": " + message));
}
return new ItemRegistrationHandle(key, collectionId, item, ItemRegistrationState.Rejected, message);
}
private static ItemRegistrationHandle GetHandleByKey(string key)
{
lock (Sync)
{
return ByKey[key].Handle;
}
}
private static void Fail(RegistrationRecord record, string message)
{
SetState(record, ItemRegistrationState.Failed, message);
_logger.LogError((object)("[ItemAPI] Registration failed for " + record.Key + ": " + message));
}
private static void SetState(RegistrationRecord record, ItemRegistrationState state, string message)
{
if (record.Handle.State != state || !string.Equals(record.Handle.Message, message, StringComparison.Ordinal))
{
record.Handle.State = state;
record.Handle.Message = message;
ItemRegistry.RaiseRegistrationChanged(record.Handle);
}
}
private static string Describe(Item item)
{
if (!Object.op_Implicit((Object)(object)item))
{
return "<null>";
}
return "'" + ((Object)item).name + "'";
}
internal static void LogSubscriberException(Exception exception)
{
ManualLogSource logger = _logger;
if (logger != null)
{
logger.LogError((object)$"[ItemAPI] A RegistrationChanged subscriber threw an exception: {exception}");
}
}
}
}
