Release v1.3.14

LethalLevelLoader/NetworkStructs/NetworkEnemyTypeReference.cs

@@ -0,0 +1,78 @@
+using System;
+using System.Collections.Generic;
+using System.Runtime.CompilerServices;
+using System.Text;
+using Unity.Netcode;
+
+namespace LethalLevelLoader
+{
+    public struct NetworkEnemyTypeReference : INetworkSerializable
+    {
+        private List<NetworkPrefab> m_Prefabs => LethalLevelLoaderNetworkManager.networkManager.NetworkConfig.Prefabs.m_Prefabs;
+
+        private uint m_NetworkEnemyTypeObjectId;
+        private static uint s_NullId = uint.MaxValue;
+
+        public uint NetworkEnemyTypeObjectId
+        {
+            get => m_NetworkEnemyTypeObjectId;
+            internal set => m_NetworkEnemyTypeObjectId = value;
+        }
+
+        public NetworkEnemyTypeReference(EnemyType enemy)
+        {
+            if (enemy == null)
+            {
+                m_NetworkEnemyTypeObjectId = s_NullId;
+                return;
+            }
+
+            if (enemy.enemyPrefab == null || enemy.enemyPrefab.GetComponent<EnemyAI>() == false)
+            {
+                throw new ArgumentException(enemy.name + "'s Prefab or Prefab GrabbableObject is Missing!");
+            }
+
+            m_NetworkEnemyTypeObjectId = GetIdHashFromEnemyType(enemy);
+        }
+
+        public bool TryGet(out EnemyType enemy, NetworkManager networkManager = null)
+        {
+            enemy = Resolve(this);
+            return (enemy != null);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private static EnemyType Resolve(NetworkEnemyTypeReference networkEnemy)
+        {
+            if (networkEnemy.m_NetworkEnemyTypeObjectId == s_NullId)
+                return null;
+            return (networkEnemy.GetEnemyTypeFromNetworkPrefabIdHash(networkEnemy.m_NetworkEnemyTypeObjectId));
+        }
+
+        public static implicit operator EnemyType(NetworkEnemyTypeReference networkEnemyRef) => Resolve(networkEnemyRef);
+
+        public static implicit operator NetworkEnemyTypeReference(EnemyType enemy) => new NetworkEnemyTypeReference(enemy);
+
+        public void NetworkSerialize<T>(BufferSerializer<T> serializer) where T : IReaderWriter
+        {
+            serializer.SerializeValue(ref m_NetworkEnemyTypeObjectId);
+        }
+
+        private EnemyType GetEnemyTypeFromNetworkPrefabIdHash(uint idHash)
+        {
+            for (int i = 0; i < m_Prefabs.Count; i++)
+                if (m_Prefabs[i].SourcePrefabGlobalObjectIdHash == idHash)
+                    if (m_Prefabs[i].Prefab.TryGetComponent(out EnemyAI enemyAI))
+                        return (enemyAI.enemyType);
+            return (null);
+        }
+
+        private uint GetIdHashFromEnemyType(EnemyType enemy)
+        {
+            for (int i = 0; i < m_Prefabs.Count; i++)
+                if (m_Prefabs[i].Prefab == enemy.enemyPrefab)
+                    return (m_Prefabs[i].SourcePrefabGlobalObjectIdHash);
+            return (0);
+        }
+    }
+}

LethalLevelLoader/NetworkStructs/NetworkExtendedLevelReference.cs

@@ -0,0 +1,71 @@
+using System;
+using System.Collections.Generic;
+using System.Runtime.CompilerServices;
+using System.Text;
+using Unity.Netcode;
+
+namespace LethalLevelLoader
+{
+    public struct NetworkExtendedLevelReference : INetworkSerializable
+    {
+        private List<ExtendedLevel> m_Levels => PatchedContent.ExtendedLevels;
+
+        private uint m_ExtendedLevelId;
+        private static uint s_NullId = uint.MaxValue;
+
+        public uint ExtendedLevelId
+        {
+            get => m_ExtendedLevelId;
+            internal set => m_ExtendedLevelId = value;
+        }
+
+        public NetworkExtendedLevelReference(ExtendedLevel level)
+        {
+            if (level == null)
+            {
+                m_ExtendedLevelId = s_NullId;
+                return;
+            }
+
+            if (level.SelectableLevel == null)
+            {
+                throw new ArgumentException(level.name + "'s SelectableLevel is Missing!");
+            }
+
+            m_ExtendedLevelId = GetIndexIDFromExtendedLevel(level);
+        }
+
+        public bool TryGet(out ExtendedLevel level, NetworkManager networkManager = null)
+        {
+            level = Resolve(this);
+            return (level != null);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private static ExtendedLevel Resolve(NetworkExtendedLevelReference level)
+        {
+            if (level.m_ExtendedLevelId == s_NullId)
+                return null;
+            return (level.GetExtendedLevelFromIndexID(level.ExtendedLevelId));
+        }
+
+        public static implicit operator ExtendedLevel(NetworkExtendedLevelReference levelRef) => Resolve(levelRef);
+
+        public static implicit operator NetworkExtendedLevelReference(ExtendedLevel level) => new NetworkExtendedLevelReference(level);
+
+        public void NetworkSerialize<T>(BufferSerializer<T> serializer) where T : IReaderWriter
+        {
+            serializer.SerializeValue(ref m_ExtendedLevelId);
+        }
+
+        private ExtendedLevel GetExtendedLevelFromIndexID(uint indexID)
+        {
+            for (int i = 0; i < m_Levels.Count; i++)
+                if (m_Levels[i].SelectableLevel.levelID == indexID)
+                        return (m_Levels[i]);
+            return (null);
+        }
+
+        private uint GetIndexIDFromExtendedLevel(ExtendedLevel level) => (uint)level.SelectableLevel.levelID;
+    }
+}

LethalLevelLoader/NetworkStructs/NetworkItemReference.cs

@@ -0,0 +1,78 @@
+using System;
+using System.Collections.Generic;
+using System.Runtime.CompilerServices;
+using System.Text;
+using Unity.Netcode;
+
+namespace LethalLevelLoader.NetworkStructs
+{
+    public struct NetworkItemReference : INetworkSerializable
+    {
+        private uint m_NetworkItemObjectId;
+        private static uint s_NullId = uint.MaxValue;
+
+        public uint NetworkItemObjectId
+        {
+            get => m_NetworkItemObjectId;
+            internal set => m_NetworkItemObjectId = value;
+        }
+
+        public NetworkItemReference(Item item)
+        {
+            if (item == null)
+            {
+                m_NetworkItemObjectId = s_NullId;
+                return;
+            }
+
+            if (item.spawnPrefab == null || item.spawnPrefab.GetComponent<GrabbableObject>() == false)
+            {
+                throw new ArgumentException(item.name + "'s Prefab or Prefab GrabbableObject is Missing!");
+            }
+
+            m_NetworkItemObjectId = GetIdHashFromItem(item);
+        }
+
+        public bool TryGet(out Item item, NetworkManager networkManager = null)
+        {
+            item = Resolve(this);
+            return (item != null);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private static Item Resolve(NetworkItemReference networkItemRef)
+        {
+            if (networkItemRef.m_NetworkItemObjectId == s_NullId)
+                return null;
+            return (networkItemRef.GetItemFromNetworkPrefabIdHash(networkItemRef.m_NetworkItemObjectId));
+        }
+
+        public static implicit operator Item(NetworkItemReference networkItemRef) => Resolve(networkItemRef);
+
+        public static implicit operator NetworkItemReference(Item item) => new NetworkItemReference(item);
+
+        private List<NetworkPrefab> m_Prefabs => LethalLevelLoaderNetworkManager.networkManager.NetworkConfig.Prefabs.m_Prefabs;
+
+        public void NetworkSerialize<T>(BufferSerializer<T> serializer) where T : IReaderWriter
+        {
+            serializer.SerializeValue(ref m_NetworkItemObjectId);
+        }
+
+        private Item GetItemFromNetworkPrefabIdHash(uint idHash)
+        {
+            for (int i = 0; i < m_Prefabs.Count; i++)
+                if (m_Prefabs[i].SourcePrefabGlobalObjectIdHash == idHash)
+                    if (m_Prefabs[i].Prefab.TryGetComponent(out GrabbableObject grabbableObject))
+                        return (grabbableObject.itemProperties);
+            return (null);
+        }
+
+        private uint GetIdHashFromItem(Item item)
+        {
+            for (int i = 0; i < m_Prefabs.Count; i++)
+                if (m_Prefabs[i].Prefab == item.spawnPrefab)
+                    return (m_Prefabs[i].SourcePrefabGlobalObjectIdHash);
+            return (0);
+        }
+    }
+}

LethalLevelLoader/Plugin.cs

@@ -24,7 +24,7 @@ public class Plugin : BaseUnityPlugin
     {
         public const string ModGUID = "imabatby.lethallevelloader";
         public const string ModName = "LethalLevelLoader";
-        public const string ModVersion = "1.3.13";
+        public const string ModVersion = "1.3.14";
 
         internal static Plugin Instance;