using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Text;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using UnityEngine;
using UnityEngine.SceneManagement;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("Valheimprefabparser")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("Valheimprefabparser")]
[assembly: AssemblyCopyright("Copyright © 2026")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("3b0a1528-adb0-4755-9b2f-2d2b5d70ab58")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace ValheimPrefabParser;
[BepInPlugin("com.yourname.valheimprefabparser", "Valheim Prefab Parser", "2.0.0")]
public class PrefabParserPlugin : BaseUnityPlugin
{
[HarmonyPatch(typeof(ZNetScene), "Awake")]
public static class ZNetScene_Awake_Patch
{
private static void Postfix()
{
Log.LogInfo((object)"ZNetScene.Awake finished — waiting for ObjectDB...");
if (!_parsingStarted)
{
((MonoBehaviour)_instance).StartCoroutine(_instance.WaitForObjectDBAndParse());
}
}
}
[HarmonyPatch(typeof(ObjectDB), "CopyOtherDB")]
public static class ObjectDB_CopyOtherDB_Patch
{
private static void Postfix()
{
Log.LogInfo((object)"ObjectDB.CopyOtherDB finished.");
if (!_parsingStarted && (Object)(object)ZNetScene.instance != (Object)null)
{
Log.LogInfo((object)"ZNetScene is ready — starting parse from CopyOtherDB.");
_parsingStarted = true;
TriggerParsing();
}
}
}
[CompilerGenerated]
private sealed class <ParseCoroutine>d__22 : IEnumerator<object>, IDisposable, IEnumerator
{
private int <>1__state;
private object <>2__current;
private List<GameObject> <prefabs>5__2;
private Dictionary<string, List<GameObject>> <categories>5__3;
private int <processed>5__4;
private List<GameObject>.Enumerator <>7__wrap4;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <ParseCoroutine>d__22(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
int num = <>1__state;
if (num == -3 || num == 2)
{
try
{
}
finally
{
<>m__Finally1();
}
}
<prefabs>5__2 = null;
<categories>5__3 = null;
<>7__wrap4 = default(List<GameObject>.Enumerator);
<>1__state = -2;
}
private bool MoveNext()
{
try
{
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
Log.LogInfo((object)"Starting parse (coroutine mode)...");
<prefabs>5__2 = GetAllPrefabs();
<>2__current = null;
<>1__state = 1;
return true;
case 1:
<>1__state = -1;
<categories>5__3 = new Dictionary<string, List<GameObject>>();
<processed>5__4 = 0;
<>7__wrap4 = <prefabs>5__2.GetEnumerator();
<>1__state = -3;
break;
case 2:
<>1__state = -3;
break;
}
while (<>7__wrap4.MoveNext())
{
GameObject current = <>7__wrap4.Current;
if (!((Object)(object)current == (Object)null))
{
string key = DeterminePrefabCategory(current);
if (!<categories>5__3.TryGetValue(key, out var value))
{
value = new List<GameObject>();
<categories>5__3[key] = value;
}
value.Add(current);
if (++<processed>5__4 % 50 == 0)
{
Log.LogInfo((object)$"Categorized: {<processed>5__4}/{<prefabs>5__2.Count}");
<>2__current = null;
<>1__state = 2;
return true;
}
}
}
<>m__Finally1();
<>7__wrap4 = default(List<GameObject>.Enumerator);
WriteFile(BuildContent(<prefabs>5__2.Count, <categories>5__3));
Log.LogInfo((object)$"Done! Total prefabs found: {<prefabs>5__2.Count}");
return false;
}
catch
{
//try-fault
((IDisposable)this).Dispose();
throw;
}
}
bool IEnumerator.MoveNext()
{
//ILSpy generated this explicit interface implementation from .override directive in MoveNext
return this.MoveNext();
}
private void <>m__Finally1()
{
<>1__state = -1;
((IDisposable)<>7__wrap4).Dispose();
}
[DebuggerHidden]
void IEnumerator.Reset()
{
throw new NotSupportedException();
}
}
[CompilerGenerated]
private sealed class <WaitForObjectDBAndParse>d__15 : IEnumerator<object>, IDisposable, IEnumerator
{
private int <>1__state;
private object <>2__current;
private float <elapsed>5__2;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <WaitForObjectDBAndParse>d__15(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<>1__state = -2;
}
private bool MoveNext()
{
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
<elapsed>5__2 = 0f;
break;
case 1:
<>1__state = -1;
break;
}
if ((Object)(object)ObjectDB.instance == (Object)null || ObjectDB.instance.m_items.Count == 0)
{
<elapsed>5__2 += Time.deltaTime;
if (!(<elapsed>5__2 > 30f))
{
<>2__current = null;
<>1__state = 1;
return true;
}
Log.LogWarning((object)"Timeout: ObjectDB was not ready within 30 seconds. Starting parse without it.");
}
if (_parsingStarted)
{
return false;
}
_parsingStarted = true;
Log.LogInfo((object)$"ObjectDB ready ({ObjectDB.instance?.m_items.Count ?? 0} items) — starting parse.");
TriggerParsing();
return false;
}
bool IEnumerator.MoveNext()
{
//ILSpy generated this explicit interface implementation from .override directive in MoveNext
return this.MoveNext();
}
[DebuggerHidden]
void IEnumerator.Reset()
{
throw new NotSupportedException();
}
}
public const string PluginGUID = "com.yourname.valheimprefabparser";
public const string PluginName = "Valheim Prefab Parser";
public const string PluginVersion = "2.0.0";
internal static ManualLogSource Log;
private static PrefabParserPlugin _instance;
private Harmony _harmony;
internal static ConfigEntry<bool> UseCoroutine;
internal static ConfigEntry<string> OutputFileName;
internal static ConfigEntry<bool> IncludeComponentList;
private static bool _parsingStarted;
private void Awake()
{
//IL_007b: Unknown result type (might be due to invalid IL or missing references)
//IL_0085: Expected O, but got Unknown
_instance = this;
Log = ((BaseUnityPlugin)this).Logger;
UseCoroutine = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "UseCoroutine", true, "Spread parsing across frames to avoid a freeze on load.");
OutputFileName = ((BaseUnityPlugin)this).Config.Bind<string>("General", "OutputFileName", "valheim_prefabs.txt", "Output file name. Created next to the plugin .dll.");
IncludeComponentList = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "IncludeComponentList", false, "Print every Unity component on each prefab. Makes the file large.");
_harmony = new Harmony("com.yourname.valheimprefabparser");
_harmony.PatchAll();
Log.LogInfo((object)"Valheim Prefab Parser v2.0.0 loaded.");
}
private void OnDestroy()
{
Harmony harmony = _harmony;
if (harmony != null)
{
harmony.UnpatchSelf();
}
}
internal static void TriggerParsing()
{
if (!((Object)(object)_instance == (Object)null))
{
if (UseCoroutine.Value)
{
((MonoBehaviour)_instance).StartCoroutine(_instance.ParseCoroutine());
}
else
{
ParseSync();
}
}
}
[IteratorStateMachine(typeof(<WaitForObjectDBAndParse>d__15))]
private IEnumerator WaitForObjectDBAndParse()
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <WaitForObjectDBAndParse>d__15(0);
}
private static List<GameObject> GetAllPrefabs()
{
//IL_01eb: Unknown result type (might be due to invalid IL or missing references)
//IL_01f0: Unknown result type (might be due to invalid IL or missing references)
HashSet<int> seen = new HashSet<int>();
List<GameObject> prefabs = new List<GameObject>();
if ((Object)(object)ObjectDB.instance != (Object)null)
{
Log.LogInfo((object)" Reading ObjectDB.m_items...");
foreach (GameObject item in ObjectDB.instance.m_items)
{
if ((Object)(object)item != (Object)null)
{
TryAdd(item.gameObject);
}
}
Log.LogInfo((object)" Reading ObjectDB.m_recipes...");
foreach (Recipe recipe in ObjectDB.instance.m_recipes)
{
if ((Object)(object)recipe?.m_item != (Object)null)
{
TryAdd(((Component)recipe.m_item).gameObject);
}
}
Log.LogInfo((object)$" Items: {ObjectDB.instance.m_items.Count}, Recipes: {ObjectDB.instance.m_recipes.Count}");
}
else
{
Log.LogWarning((object)"ObjectDB.instance is null — item data will be incomplete.");
}
if ((Object)(object)ZNetScene.instance != (Object)null)
{
Log.LogInfo((object)" Reading ZNetScene.m_prefabs...");
foreach (GameObject prefab in ZNetScene.instance.m_prefabs)
{
TryAdd(prefab);
}
Log.LogInfo((object)$" ZNetScene prefabs: {ZNetScene.instance.m_prefabs.Count}");
}
else
{
Log.LogWarning((object)"ZNetScene.instance is null — scene data will be incomplete.");
}
Log.LogInfo((object)" Scanning Resources.FindObjectsOfTypeAll...");
GameObject[] array = Resources.FindObjectsOfTypeAll<GameObject>();
foreach (GameObject val in array)
{
Scene scene = val.scene;
if (string.IsNullOrEmpty(((Scene)(ref scene)).name))
{
TryAdd(val);
}
}
Log.LogInfo((object)$" Total unique prefabs collected: {prefabs.Count}");
return prefabs;
void TryAdd(GameObject go)
{
if (!((Object)(object)go == (Object)null) && seen.Add(((Object)go).GetInstanceID()))
{
prefabs.Add(go);
}
}
}
private static string DeterminePrefabCategory(GameObject go)
{
//IL_001e: 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_0024: Unknown result type (might be due to invalid IL or missing references)
//IL_0026: Unknown result type (might be due to invalid IL or missing references)
//IL_0088: Expected I4, but got Unknown
ItemDrop component = go.GetComponent<ItemDrop>();
if ((Object)(object)component != (Object)null)
{
ItemType itemType = component.m_itemData.m_shared.m_itemType;
switch (itemType - 1)
{
case 2:
case 3:
case 13:
case 21:
return "01_Weapons";
case 4:
return "02_Shields";
case 5:
case 6:
case 10:
case 11:
case 16:
return "03_Armor";
case 8:
case 22:
return "04_Ammunition";
case 1:
if (!(component.m_itemData.m_shared.m_food > 0f))
{
return "06_Consumables";
}
return "05_Food";
case 0:
return "07_Materials";
case 12:
return "08_Trophies";
case 18:
return "09_Tools";
case 14:
return "10_Torches";
case 17:
return "11_Utility";
default:
return "12_Other_Items";
}
}
if ((Object)(object)go.GetComponent<Piece>() != (Object)null)
{
return "13_Buildings";
}
Character component2 = go.GetComponent<Character>();
if ((Object)(object)component2 != (Object)null)
{
if (component2.m_boss)
{
return "14_Bosses";
}
if (((Object)go).name.Contains("Player"))
{
return "15_Player";
}
if ((Object)(object)go.GetComponent<Humanoid>() != (Object)null)
{
return "16_Humanoids";
}
if ((Object)(object)go.GetComponent<MonsterAI>() != (Object)null)
{
return "17_Monsters";
}
if ((Object)(object)go.GetComponent<Tameable>() != (Object)null)
{
return "18_Tameable";
}
return "19_Creatures";
}
if ((Object)(object)go.GetComponent<Plant>() != (Object)null)
{
return "20_Plants";
}
if ((Object)(object)go.GetComponent<TreeBase>() != (Object)null)
{
return "21_Trees";
}
if ((Object)(object)go.GetComponent<MineRock>() != (Object)null)
{
return "22_Minerals";
}
if ((Object)(object)go.GetComponent<MineRock5>() != (Object)null)
{
return "22_Minerals";
}
if ((Object)(object)go.GetComponent<Container>() != (Object)null)
{
return "23_Containers";
}
if ((Object)(object)go.GetComponent<CraftingStation>() != (Object)null)
{
return "24_Crafting_Stations";
}
if ((Object)(object)go.GetComponent<Fireplace>() != (Object)null)
{
return "25_Fireplaces";
}
if ((Object)(object)go.GetComponent<TeleportWorld>() != (Object)null)
{
return "26_Portals";
}
if ((Object)(object)go.GetComponent<Pickable>() != (Object)null)
{
return "27_Pickables";
}
if ((Object)(object)go.GetComponent<SpawnArea>() != (Object)null)
{
return "28_Spawners";
}
if ((Object)(object)go.GetComponent<Ship>() != (Object)null)
{
return "29_Ships";
}
if ((Object)(object)go.GetComponent<Projectile>() != (Object)null)
{
return "30_Projectiles";
}
if ((Object)(object)go.GetComponent<ParticleSystem>() != (Object)null)
{
return "31_VFX_Effects";
}
if ((Object)(object)go.GetComponent<AudioSource>() != (Object)null && (Object)(object)go.GetComponent<ZNetView>() == (Object)null)
{
return "32_SFX";
}
string name = ((Object)go).name;
if (name.StartsWith("vfx_") || name.StartsWith("sfx_") || name.StartsWith("fx_"))
{
return "31_VFX_Effects";
}
return "99_Other";
}
private static Dictionary<string, List<GameObject>> CategorizePrefabs(List<GameObject> prefabs)
{
Dictionary<string, List<GameObject>> dictionary = new Dictionary<string, List<GameObject>>();
foreach (GameObject prefab in prefabs)
{
if (!((Object)(object)prefab == (Object)null))
{
string key = DeterminePrefabCategory(prefab);
if (!dictionary.TryGetValue(key, out var value))
{
value = (dictionary[key] = new List<GameObject>());
}
value.Add(prefab);
}
}
return dictionary;
}
private static string BuildContent(int totalCount, Dictionary<string, List<GameObject>> categories)
{
StringBuilder stringBuilder = new StringBuilder();
stringBuilder.AppendLine("╔══════════════════════════════════════════════════════════╗");
stringBuilder.AppendLine("║ VALHEIM PREFAB PARSER — FULL LIST ║");
stringBuilder.AppendLine("╚══════════════════════════════════════════════════════════╝");
stringBuilder.AppendLine($" Date: {DateTime.Now:yyyy-MM-dd HH:mm:ss}");
stringBuilder.AppendLine($" Total prefabs: {totalCount}");
stringBuilder.AppendLine($" Categories: {categories.Count}");
stringBuilder.AppendLine();
stringBuilder.AppendLine("── SUMMARY ─────────────────────────────────────────────────");
foreach (KeyValuePair<string, List<GameObject>> item in categories.OrderBy((KeyValuePair<string, List<GameObject>> c) => c.Key))
{
stringBuilder.AppendLine($" {item.Key,-35} {item.Value.Count,5} pcs.");
}
stringBuilder.AppendLine();
stringBuilder.AppendLine("── DETAILED LIST ───────────────────────────────────────────");
foreach (KeyValuePair<string, List<GameObject>> item2 in categories.OrderBy((KeyValuePair<string, List<GameObject>> c) => c.Key))
{
stringBuilder.AppendLine();
stringBuilder.AppendLine($"┌─ {item2.Key} ({item2.Value.Count})");
foreach (GameObject item3 in item2.Value.OrderBy((GameObject g) => ((Object)g).name))
{
stringBuilder.AppendLine("│ " + ((Object)item3).name);
if (IncludeComponentList.Value)
{
IOrderedEnumerable<string> values = from s in (from c in item3.GetComponents<Component>()
where (Object)(object)c != (Object)null
select ((object)c).GetType().Name).Distinct()
orderby s
select s;
stringBuilder.AppendLine("│ [" + string.Join(", ", values) + "]");
}
}
stringBuilder.AppendLine("└───────────────────────────────────────────────────────────");
}
return stringBuilder.ToString();
}
private static void WriteFile(string content)
{
try
{
string text = Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), OutputFileName.Value);
File.WriteAllText(text, content, Encoding.UTF8);
Log.LogInfo((object)("File written: " + text));
}
catch (Exception ex)
{
Log.LogError((object)("Failed to write file: " + ex.Message));
}
}
private static void ParseSync()
{
try
{
Log.LogInfo((object)"Starting parse (synchronous mode)...");
List<GameObject> allPrefabs = GetAllPrefabs();
Dictionary<string, List<GameObject>> categories = CategorizePrefabs(allPrefabs);
WriteFile(BuildContent(allPrefabs.Count, categories));
Log.LogInfo((object)$"Done! Total prefabs found: {allPrefabs.Count}");
}
catch (Exception arg)
{
Log.LogError((object)$"Parse failed: {arg}");
}
}
[IteratorStateMachine(typeof(<ParseCoroutine>d__22))]
private IEnumerator ParseCoroutine()
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <ParseCoroutine>d__22(0);
}
}
