DEV Community: John

Duckmon: The Demo Was Ready, The Game Was Not

John — Mon, 20 Jul 2026 20:49:24 +0000

Duckmon: The Demo Was Ready, But the Game Was Not

It's been a long time since my last dev.to post, the 12th of February, to be exact. Back then, Duckmon was getting closer and closer to becoming demo ready. After another four or five weeks, it was right on the edge of a release. The loop worked. The systems were stable. The artwork was 99% complete and implemented. The UI flowed end to end, achievements popped, everything was working as intended, and even the server-authoritative backend was humming along with no issues.

I had registration, verification, card packs, a binder, a shop, factions, and over 300 cards with full art, stats, and lore. I had player profiles, avatars, quote systems, experience and leveling systems, a full soundtrack, and full SFX.

I was polishing. I was debugging. I was preparing for a real demo release not just a small vertical slice, but a full demo, fully playable, with some sections intentionally blocked off.

And then something happened.

I realised the demo was ready… but the game wasn't.

Not in the sense of bugs or missing features, those were tamed and handled after months of solo work. It was something deeper.

The loop worked, but it didn't feel alive yet. There was no excitement for me. Every developer's worst self-doubt kicked in: my game is almost finished, but it's boring. After a few matches, even I was bored.

It needed more depth.
More retention.
More strategy.
More "just one more match" energy.
Some excitement.

So instead of releasing the demo, I made one of the hardest decisions a solo dev can probably make: I paused the release and expanded the game.

Falling Off, Then Finding My Way Back

At the same time, I'd been neglecting everything around the project, not just the game itself. My website hadn't been updated since I made it. My Discord had been abandoned. Even here on dev.to, I'd gone quiet for six months.

Eventually I neglected the project itself too. I didn't touch Unity for about six weeks or more. Supabase kept pausing my backend from lack of activity. I lost my motivation.

What pulled me back was simple: I didn't want to have wasted all this time and effort. I wanted to get this project past the point where "working" is enough.

Duckmon started as a minigame in the first project I ever attempted - my first time ever using Unity or writing code. Then it tried to be a game in Roblox, who weren't too happy with my art style and handed me multiple bans. So I came back to Unity, where nothing restricted me, and it became its own standalone project. After a lot of cursing, late nights, and effort, it finally started to feel like my own multiverse.

When I booted the project back up to "finish the fight", the battle loop, as functional as it was, felt too shallow for the kind of game I wanted players to sink into. It felt like a cheap knockoff. A poser. An imposter.

I didn't want Duckmon to be a play-once-and-forget indie game, or something people looked at and called AI slop. I wanted it to be a game people return to, a game with layers, with strategy, with its own identity. Rough, yes. Amateur, hell yeah. But mine.

So I asked myself: what would make Duckmon worth playing for weeks instead of minutes? What does it need to actually feel replayable and engaging?

The answer was obvious: depth, systems, strategy, choice, tactics, all balanced with a little luck and future competition. And that meant expanding the battle system far beyond the original scope.

Squad Battle Mode: The Big Expansion

The first major addition was Squad Battle Mode, a full team-based battler inspired by games like Pokémon and from other RPG battle systems, plus my own obsession with tactical card combat.

This wasn't just "add more cards." It was a structural reimagining, taking my existing dataset, my card databases, and figuring out how to actually use and expand what I already had.

Using the cards a player has collected and their active deck, Squad Battle Mode is a 5v5 battle with active and bench units. Every card becomes a unit with 4 unique skills, HP, team energy, elemental typing, and strengths/weaknesses. On top of that:

KO → auto-swap logic
Graveyard tracking
Team energy economy
A hybrid system of turn-based and action-based status ticking
Damage over time, crowd control, buffs, and debuffs
Team buffs and enemy debuffs
Faction synergy
Real tactical decision making, with a little luck mixed in

Suddenly Duckmon wasn't just a card battler. It was a team strategy game. And it felt right.

Story Mode: A Second Pillar of Duckmon

While Squad Battle Mode was growing the tactical side of the game, a completely different part of the project was growing alongside it, slower, more atmospheric, a narrative-driven aspect.

Story Mode is inspired by classic choose-your-own-adventure books. Every decision leads to a new node, every node branches into two choices, and every choice pushes the player toward one of ten real endings, plus plenty of game-over endings along the way. It's not a card battler. It's backstory. It's lore you can actually walk through.

Chapter one of the Electric Faction is already done — full artwork, its own soundtrack, a complete narrative arc. The rest of the faction chapters will get built out depending on how Story Mode lands in the demo.

Story Mode rewards gold for card packs, but it's not required for progression. It sits alongside the other modes as something optional and atmospheric — a way to explore the world behind the cards without having to fight for it.

The Battle Modes That Now Define Duckmon

Duckmon now has multiple gameplay pillars working together instead of competing with each other: Story Mode for narrative depth, the original battle mode for fast matches, and Squad Battle Mode for tactical depth. Squad Battle Mode itself is planned to expand into six variants:

Classic Squad Battle Mode — the core 5v5 team battler, built around a player's own cards, deck, synergies, and strategy.
Ranked PVP — a competitive mode where players fight each other with their own squads, rewarding consistency, strategy, and mastery.
Friendly PVP — the casual version. No pressure, no ranking, just play.
Seasonal Squad Mode — a rotating format using predetermined batches of cards. One season might be Ice Faction only, another Epic rarity only, another a curated balance set. Ranked and friendly versions will exist here too.
Challenge Mode — fighting AI-controlled squads with predetermined cards. No deck building, no collection advantage, just pure tactical problem-solving.
AI Squad Battles — the AI brain is already built specifically for Squad Battle Mode. It reads the board state, tracks energy, evaluates threats, and makes decisions using the same rules the player does, so players can test their squads against something genuinely smart.

Building a Pokémon-Style Battler With My Existing Assets

I didn't want to reinvent the wheel. I wanted to evolve what I already had.

So I took my existing Duckmon cards : the art, the stats, the lore, and built a full Pokémon-style combat system around them, including:

A draft system based on the player's currently equipped deck
Element types and a full type-effectiveness chart
Status conditions, DOT effects, skip-turn CC, action-based penalties, turn-based durations
Team energy gain rules
Server-authoritative combat resolution

Everything had to be formula accurate, consistent, and scalable. This wasn't a minigame anymore. It was a battle engine.

The Skill System: The Heart of the Depth

To make battles actually mean something, I needed real skills, not placeholders. So I built, and I'm still actively expanding:

A full skill system
A CSV-driven skill database, expanded into a dual-purpose master data holder
A runtime skill executor
A buff/debuff manager and a status manager
A DOT system and a team buff system
A damage calculator, hit chance formula, and turn order formula
Shield and reflect systems
A battle stat recalculation pipeline

Every skill is a mix of power values, percent values, flat values, duration and tick rules, stat scaling (attack, defence, intelligence, dexterity), element synergies, rarity, status effects, team effects, and healing/cleansing/recovery/revival.

I've expanded the CSV to include attack skills, support skills, DOT, CC, team buffs, debuffs, healing, shields, reflects, avoidance, energy manipulation, faction-specific moves, and mythic-tier abilities.

Every Duckmon now has a real identity, not just stats, but a moveset that feels like it belongs to that specific card, built with team synergy and playstyle in mind.

Debugging: The Solo Dev Reality

This part isn't glamorous, but it's real.

I've spent countless nights debugging and refactoring: status stacking, duration ticking, DOT timing, energy economy, turn order, skill resolution, shield absorption, reflect damage, bench logic, KO logic, graveyard logic, swap logic, UI flow, server sync, race conditions, edge cases, null references, CSV parsing, runtime stat recalculation.

Solo dev isn't just building. It's fixing. And fixing. And fixing again. And once it's all fixed (it isn't, so break it and fix it again), every fix still made the game stronger.

The Decision to Reject Monetization

This part matters to me.

I don't want Duckmon to be a gacha trap. I don't want it to be a microtransaction machine. I don't want it to be a "pay to progress" game. I want it to be a game first.

So I made the decision:

*No monetization in the demo. No monetization in the core game loop. No monetization until the game is worth paying for — if ever, and if that happened, the only monetization would be the purchasing of the game at a cheap price anyway (to possibly cover the steam fees, if i ever get there), no micro transactions in the game ... ever *

The cards you get, from the second you get them, are yours at full potential. No grinding for duplicates, no leveling up cards. You own it, you use it, that's it.

I'm building Duckmon because I wanted to build something I can be proud of , something I built alone, by myself, starting with zero coding experience, not for the money, just for the love of it. Something I can point to and say, "I built that." Not because I want to squeeze players.

Where Duckmon Stands Today

Duckmon is no longer a minigame. It's no longer a prototype. It's no longer a "maybe someday" project.

It's a real game:

Server-authoritative backend
Email registration and verification
Card packs, binder, shop, factions
310 cards
Full battle engine, skill system, status system, DOT/CC system
Full team battle mode
Full UI flow and full demo loop
Story Mode chapter one
Multiple planned Squad Battle variants

Real depth. Real strategy. Real retention. Real fun.

The demo isn't delayed. It's evolving. Slowly, i am getting there and i also plan to post updates here more regularly, no promises, but that is my intention.

From my first Dev.to challenge to building my own website.

John — Thu, 12 Feb 2026 10:08:12 +0000

Chaos to Concept: How I Built a Solo Game Dev Site Without a Single "Hello World".

We’ve all seen the "My first website" posts. Usually, they start with a FreeCodeCamp certificate or some YouTube video tutorials, basically, a "Hello World" tutorial.

I didn't do any of that. I don't like being told how to build things. I like breaking things until they work. I’m a solo dev, a dad, and a husband who decided to stop playing games and start building them from scratch. No training. No prior experience.

I have not posted for a while and been absorbed in real life challenges, and my game dev challenges, it has all been one crazy journey, trial by fire and lots of self learned lessons.

Here is the evolution of my web dev journey, from a Dev.to challenge entry to the official home of my solo game studio and i would like to give props to Dev.to for making this even possible for me, in the sense that if i had not participated in this Halloween challenge in October 2025 , i would never have attempted to create this website.

Project 1: The "TextZ Ombie" Shrine
The Goal: A landing page for a Dev.to Halloween challenge. The Reality:https://asxgtr.github.io/TextZ-Ombie-Landing-Page/

This was my "Trial by Fire." I didn't use a tutorial; I just started throwing HTML and CSS at the wall to see what stuck, and if i am being totally honest, a lot of questions to A.I.

The Vibe: Pure 90s-style chaos.

The Win: I actually got audio elements working and figured out how to animate emojis to create a "horde" feel. I was proud of my first attempt although i knew it was very "amateur".

The Lesson: I realized that while I could make a page "work," it didn't tell a story. It was a collection of assets, not a brand. A toe in the water.

The Pivot: Becoming a Solo "Studio" (in a small sense)

Between the first site and the second, my game development spiraled. My first project, TextZ Ombie, taught me about systems and UI. Even if it is temporarily on hold, 6 months of game dev from scratch taught me a lot more than any tutorial ever could, and during this development i was creating something in TextZ Ombie that deserved to be a standalone.. So then Duckmon happened, a duck powered card battler that exploded from a minigame into its own standalone multiverse. A combination of card collecting, and a card battle game inspired by the mechanics from Triple Triad (FF8).

I realized I didn't just need a "page", I needed a headquarters, not a discord server, something that is my own.

Project 2: Quackwork Studios
The Goal: A professional (more so than project one), "Real & Raw" home for my games. The Reality: https://quackworkstudios.com/

This is where the growth really shows. I stayed true to my "No Tutorial" rule, but this time I focused on intentionality.

What changed?

Identity: I moved away from the neon on black chaos to a more sophisticated "Dark Mode" aesthetic that screams "Indie Dev."

The Stack: I integrated things I never thought I'd touch Cloudflare, Ionos, and even Supabase/Resend for the backend contact forms. Wiring together DNS and Github and all other things i basically do not understand , until it just "worked"

The Narrative: Instead of just showing assets, I’m showing a journey. The site now features a devlog, active project tracking, and a clear "About" section that explains my philosophy: A.I assisted, Solo built.

The "No Tutorial" Comparison
Website 1 (TextZ Ombie)
Website 2 (Quackwork Studios)

Why I’m Sharing This
I see a lot of people get stuck in "tutorial hell." They’re afraid to build because they haven't finished a course yet, have not got a certificate, done the training, did the "Hello World".

My advice?

Just build it. My first site was a mess of emojis and raw HTML.

My second site is the more professional (Lightly) face of my studio. All anyone needs is a stubborn idea and the willingness to fail until it looked right.

I’m currently building Duckmon in Unity and this project is coming along fantastically right now, with a working server authoritative stance, working legit Email registration, verification and support. Card pack openings, Card Binder, a Shop, Faction screens, a 310 Card collection each with unique full card art, stats and lore. It is really not too far from a demo release state (with the need for further polishing). But more importantly it is working, like a real game.

If you’re a solo dev or a "creationist" who uses AI to amplify your workflow, I’d love to connect or hear your story/stories.

What was the one project that made you feel like you finally "leveled up" from a idea to a creator?

Dev Log 38 - The Christmas Resurrection (Kind - Of )

John — Mon, 22 Dec 2025 00:48:16 +0000

🎄 Dev Log: The Christmas Resurrection
(a.k.a. “Still No Halloween Results”)

Hello again, internet. Yes, I’m alive. Yes, it’s almost Christmas. No, the Halloween Frontend Challenge results still haven’t been released. I assume the judges were eaten by CSS goblins. Happens.

Anyway. I am here to talk about why I vanished.

🎃 1. The Great Dev Log Hiatus
I fully intended to keep posting dev logs. I really did.

Then the challenge results never came out and my brain went:

“Ah. Time to hibernate.”

And so I did.

🧪 2. The Mini Game That Became a Monster

I started building a tiny mini‑game inside my main project.

I thought it was a "mini" game anyway , some fun collectable cards , maybe play again AI in my project, just a little side thing. A distraction. A palate cleanser.

Naturally, it mutated into its own ecosystem, a full blown 2nd project complete with:

its own UI

its own logic

its own lore

its own problems

its own identity crisis

Classic me.

🟦 3. The Roblox Arc (a.k.a. My Exile)
Then I decided to “learn Roblox scripting for fun.”

Turns out roblox has it's own coding language , a version of Lua, specifically a customized version known as Luau.

I had never even heard of it , but the promise of free server hosting , and taking care of all the fiddly stuff, was enough for me to give it a try.

This was a mistake.

Within days ( or weeks ):

I got a warning

Then a 1‑day ban

Then a 3‑day ban

All because the AI moderation system decided that any amount of visible skin is a war crime.

I wasn’t even making anything weird. I was making a card game. A card Game where the main subject is ducks. Apparently elbows are forbidden, as are any ducks with 6 packs.

So I left Roblox like a disgraced wizard and returned to Unity while i await the banishment, like a peasant thrown from the village.

🧱 4. The Birth of This New Project

Out of the ashes of my Roblox exile came this new Unity project. ( side project )

It started simple:

Title screen

Credits panel

Settings panel

Then I blinked and suddenly I had:

A global audio engine

using UnityEngine;
using System.Collections;

namespace Audio
{
    public class AudioManager : MonoBehaviour
    {
        public static AudioManager Instance;

        [Header("Music")]
        public AudioClip titleTheme;
        private AudioSource musicSource;

        [Header("SFX Looping")]
        private AudioSource sfxLoopSource;

        private bool hasFadedOut = false;
        private float fadeDuration = 8f;

        void Awake()
        {
            if (Instance != null && Instance != this)
            {
                Destroy(gameObject);
                return;
            }

            Instance = this;
            DontDestroyOnLoad(gameObject);

            // Create audio sources
            musicSource = gameObject.AddComponent<AudioSource>();
            musicSource.loop = true;
            musicSource.playOnAwake = false;

            sfxLoopSource = gameObject.AddComponent<AudioSource>();
            sfxLoopSource.loop = true;
            sfxLoopSource.playOnAwake = false;

            ApplyVolumesFromOptions();
            PlayTitleTheme();
        }

        public void ApplyVolumesFromOptions()
        {
            if (AudioOptionsManager.Instance != null)
            {
                AudioListener.volume = AudioOptionsManager.Instance.MasterVolume;
                musicSource.volume = AudioOptionsManager.Instance.MusicVolume;
                sfxLoopSource.volume = AudioOptionsManager.Instance.SFXVolume;

                Debug.Log("[AudioManager] Volumes synced from AudioOptionsManager.");
            }
        }

        public void PlayTitleTheme()
        {
            if (titleTheme != null && !hasFadedOut)
            {
                musicSource.clip = titleTheme;
                musicSource.loop = true;
                musicSource.Play();
            }
        }

        public void StopMusic()
        {
            musicSource.Stop();
        }

        public void FadeOutMusic()
        {
            if (!hasFadedOut)
            {
                StartCoroutine(FadeOutRoutine());
            }
        }

        private IEnumerator FadeOutRoutine()
        {
            hasFadedOut = true;
            float startVolume = musicSource.volume;
            musicSource.loop = false;

            for (float t = 0; t < fadeDuration; t += Time.deltaTime)
            {
                musicSource.volume = Mathf.Lerp(startVolume, 0f, t / fadeDuration);
                yield return null;
            }

            musicSource.volume = 0f;
            musicSource.Stop();
        }

        public void PlayLoop(AudioClip clip, float volume = 1f)
        {
            if (clip == null)
            {
                Debug.LogWarning("[AudioManager] Tried to play null AudioClip.");
                return;
            }

            sfxLoopSource.clip = clip;
            sfxLoopSource.volume = Mathf.Clamp01(volume);
            sfxLoopSource.loop = true;
            sfxLoopSource.Play();
        }

        // Expose sources for external control
        public AudioSource MusicSource => musicSource;
        public AudioSource SFXLoopSource => sfxLoopSource;
    }
}

using UnityEngine;
using UnityEngine.UI;
using Audio;

public class AudioOptionsManager : MonoBehaviour
{
    public static AudioOptionsManager Instance { get; private set; }

    [Header("UI")]
    [SerializeField] private Slider masterSlider;
    [SerializeField] private Slider musicSlider;
    [SerializeField] private Slider sfxSlider;
    [SerializeField] private Button resetButton;
    [SerializeField] private Button closeButton;

    [Header("Audio Sources")]
    [SerializeField] private AudioSource musicSource;
    [SerializeField] private AudioSource sfxLoopSource;

    public const float DefaultMasterVolume = 0.75f;
    public const float DefaultMusicVolume = 0.75f;
    public const float DefaultSFXVolume = 0.75f;

    private float masterVolume = DefaultMasterVolume;
    private float musicVolume = DefaultMusicVolume;
    private float sfxVolume = DefaultSFXVolume;

    public float MasterVolume => masterVolume;
    public float MusicVolume => musicVolume;
    public float SFXVolume => sfxVolume;

    private void Awake()
    {
        Instance = this;
    }

    private void Start()
    {
        // Auto-assign sources from AudioManager
        if (AudioManager.Instance != null)
        {
            if (musicSource == null)
                musicSource = AudioManager.Instance.MusicSource;

            if (sfxLoopSource == null)
                sfxLoopSource = AudioManager.Instance.SFXLoopSource;
        }

        // Wire UI
        masterSlider.onValueChanged.AddListener(OnMasterVolumeChanged);
        musicSlider.onValueChanged.AddListener(OnMusicVolumeChanged);
        sfxSlider.onValueChanged.AddListener(OnSFXVolumeChanged);
        resetButton.onClick.AddListener(OnResetAudio);
        closeButton.onClick.AddListener(OnClosePressed);

        // Initialize sliders
        masterSlider.value = masterVolume;
        musicSlider.value = musicVolume;
        sfxSlider.value = sfxVolume;

        ApplyVolumes();
    }

    private void OnMasterVolumeChanged(float value)
    {
        masterVolume = Mathf.Clamp01(value);
        ApplyVolumes();
    }

    private void OnMusicVolumeChanged(float value)
    {
        musicVolume = Mathf.Clamp01(value);
        ApplyVolumes();
    }

    private void OnSFXVolumeChanged(float value)
    {
        sfxVolume = Mathf.Clamp01(value);
        ApplyVolumes();
    }

    private void OnResetAudio()
    {
        masterVolume = DefaultMasterVolume;
        musicVolume = DefaultMusicVolume;
        sfxVolume = DefaultSFXVolume;

        masterSlider.value = masterVolume;
        musicSlider.value = musicVolume;
        sfxSlider.value = sfxVolume;

        ApplyVolumes();
    }

    private void ApplyVolumes()
    {
        AudioListener.volume = masterVolume;

        if (musicSource != null)
            musicSource.volume = musicVolume;

        if (sfxLoopSource != null)
            sfxLoopSource.volume = sfxVolume;
    }

    private void OnClosePressed()
    {
        // MenuManager handles showing/hiding the panel
        gameObject.SetActive(false);
    }
}

A clean UI architecture

A proper menu flow

A credits panel that actually scrolls ( growth! )

Progress is faster this time because I actually know Unity now. I no longer open the editor, panic, and close it for two days.

Character development.

🧩 5. The PlayFab Signup

At some point I also signed up for PlayFab. ( Today )

Why? Because future me will need:

cloud saves

player data

inventory syncing

maybe multiplayer

maybe trading

maybe a full backend economy

Or maybe I just like dashboards. Hard to say.

🃏 6. The 310‑Card Database

Yes. I imported 310 cards into Unity.

All with:

names

stats

rarities

factions

lore

effects

spreadsheet‑driven data

This is the moment I realised:

“Oh. This isn’t a mini‑project anymore.”

This is a real game now.

A few Examples ..

and another 306 more !! ( i was still busy , sidetracked very much )

🧠 7. The Present Day
Right now the project has:

a clean title screen

a working settings panel

a scrolling credits panel

a global audio system

a database of 310 cards

a PlayFab backend ready to be used

a developer who is no longer afraid of Unity

and a dev log that has risen from the dead

🎁 8. What’s Next

In no particular order:

UI transitions

One‑shot SFX

Scene loading

Card binder

Card inspection

Gameplay prototype

More lore

More chaos

And maybe — just maybe — the Halloween challenge results.

Merry Christmas

Dev Log 37 - Consolidated Update

John — Sat, 15 Nov 2025 13:44:13 +0000

Consolidated Update
Date: 15 November 2025

Hi, to anyone still reading my logs, this log entry is a consolidation of some recent personal dev logs , consolidated as a single log for myself, so not much of a fun or exciting read.

Fixed discard/resurrection and opener-swap bugs;
Hardened inventory/registry/loot flows;
Centralized shrine-safe equip checks;
Rewired and polished Use/Loot/Inventory/Gear UI;
Implemented Options + Audio UI and Credits polish;
Restored tooltip pipeline compatibility;
Added defensive guards, logging, and tests.

Discard flow: true removal of runtime instances; no resurrection from loot or saves.

InventoryStateManager: unregister-by-reference, compatibility shims, TryGetLiveItemByReference.

Loot pickup: always instantiate fresh runtime clones and register them before adding to inventory.

Equip logic: all entry points use TryEquipInventoryItemIfSlotEmpty to prevent Hands overwrite; tooltip remains open on blocked equip.

Open flow: exact-slot replacement for opened items; apply opener damage only (no removal); preserve state copy from sealed → opened item.

UI robustness: defensive ExecuteInventoryAction; OpenOptionSlot UI no auto-invoke; Use/Loot/Inventory panels relabeled and rewired.

Options & Audio UI: OptionsScene + in-game panel; ScreenFader/SceneSkipBlocker integration for Title Menu; functioning Master/Music/SFX sliders.

Credits screen: new unique background, prefab-safe layout and polish.

Tooltip pipeline: merged missing members into InventoryItem, ensured hydration and prefab bindings restored.

Many minor bugs and runtime NREs fixed; added lots of logging / debuggers and probe points.

Conversation summary (diagnosis → fixes)

ItemFactory crash due to null registry and opener (knife types) disappearing when opening sealed items.

Discarded items reappearing when taking loot.

Tooltip fields/labels not showing after restoring backup → compile errors and prefab binding mismatches.

Diagnosis and result

Crash: PlayerInventoryManager.itemRegistry could be null; ItemFactory used it → NRE.

Knife disappearance: ambiguous ID-based removals or incorrect slot replacement removed openers; asset-reference hydration issues allowed the wrong instance to be removed.

Discard resurrection: discarded backing assets remained referenced (registry, gear.ContainedAssets or saves) and loot/pickup code reused those references instead of creating fresh instances.

Tooltip regressions: InventoryItem in current project lacked fields/methods used by other advanced systems; prefab bindings inconsistent between backup and main project.

Files inspected and iteratively edited

ItemFactory: add null-registry guards and ensure fresh clone creation via Instantiate or ItemFactory.Create.

OpenPanelUI.cs: canonical swap now uses ItemFactory.CS - Create, copies sealed→opened state, replaces exact gear slot, applies opener damage without removing opener, refreshes UI.

ItemOpenerResolver.cs: verified it applies durability only; validated special-case logic (charcoal, tin can).

PlayerInventoryManager.cs: added instance-based removal overloads (RemoveItem(InventoryItem), RemoveItem(Object)), InsertItemAt/ReplaceItemInPlace, TryGetGearAndIndex, GetSlotIndex; destroyed runtime clones on discard and improved logging.

InventoryStateManager.cs: added UnregisterItem(InventoryItem), restored MarkItemAsEquipped overloads, TryGetLiveItemByReference, and defensive RegisterItem behavior.

UsePanelIconRegistry.cs: corrected syntax, added missing keys (slice, repair) and returned clean registry.

OpenOptionSlotUIManager: Initialize shows target (sealed container) and attaches single click listener (no auto invoke).

ItemTooltipManager: ExecuteInventoryAction rewritten defensively; preserves attach, discard, equip, use, open, fill, pour, eat, drink flows.

LootTooltipManager & LootButtonActionManager: patched to use TryEquipInventoryItemIfSlotEmpty and to instantiate fresh clones when taking loot.

InventorySlotUI: ensured LoadItem/HasItem/GetAsset behave reliably with runtime clones.

UI wiring: updated Use/Loot/Inventory/Gear button labels and logic to reflect new guard flows.

Concrete code patterns applied

Discard pipeline:

PlayerInventoryManager.RemoveItem(instance) removes from gear.ContainedAssets, destroys runtime asset clone, RefreshInventoryState(), OnInventoryChanged, InventoryStateManager.UnregisterItem(item).

Loot pickup:

itemRegistry.GetCloneByID(template) + Object.Instantiate(template) → register new InventoryItem → AddItemToFirstFreeSlot(newItem, runtimeAsset).

Open swap:

Hydrate sealed asset reference → find exact gear slot (gear + index) → ReplaceItemInPlace(openedAsset) → ItemOpenerResolver.ApplyOpenerDamage(opener) → PlayerInventoryManager.UpdateItem(opener) → InventoryStateManager.Register/Unregister as needed.

Equip:

All equip calls go through PlayerEquipManager.TryEquipInventoryItemIfSlotEmpty(item). Failure shows warning and leaves tooltip open.

UI safety:

OpenOptionSlotUIManager shows correct target and waits for explicit click.

ItemTooltipManager guards slot/asset/injectable/item presence and logs failure points.

Why the final fix stopped the knife disappearing

Replaced ambiguous ID-based removals with instance/slot-specific ReplaceItemInPlace; asset hydration ensures the slot contains the expected backing asset; opener damage reduces durability only and never removes the opener; this prevents accidental removal of the opener or another instance.

Tooltip pipeline rescue (backup → main merge)
Problem context

Tooltip fields (descriptions, use labels, temperature, contamination) displayed in backup but not in main project.

Restoring backup into main project produced compile errors because the backup InventoryItem lacked newer fields/methods current systems required.

Prefab and scene bindings mismatched, causing hydration failures and CS0117/CS1061 compile errors.

Root causes identified

Missing InventoryItem members (UseButton1Label…UseButton5Label, TemperatureCelsius, ContaminationLevel, GetUseLabel(int)).

Tooltip prefab bindings unassigned or different between projects.

Some code was operating on stale prefab references instead of freshly instantiated, hydrated runtime clones.

Concrete fixes applied

Restored and merged missing InventoryItem fields:

UseButton1Label … UseButton5Label

TemperatureCelsius

ContaminationLevel

Added accessor GetUseLabel(int index)

Ensured tooltip UI reads from hydrated InventoryItem instances (not from template assets).

Added validator logs to confirm tooltip UI bindings are assigned and active at runtime.

Compared backup and main project, merged required members into current InventoryItem, then updated backups with the fixed state.

Why this approach worked

The backup proved the core logic; missing members in the current InventoryItem made advanced systems fail. Merging required members preserved new features while restoring compatibility. Validator logs exposed null bindings so they were fixed surgically.

Recommended follow-ups (TO-DO)

GitHub update - Commit and tag this working state (e.g., vTooltipRelic-YYYYMMDD).

Export working tooltip prefab and InventoryItem.cs as portable relics.

Tests performed (representative)

Discard lifecycle: discard B → loot with B picked up → created fresh instance; discarded instance never returns; save/load confirmed none-resurrection.

Equip protection: attempts from loot/inventory when Hands occupied blocked and tooltip retained.

Open flow: container→open and opener→open validated; no auto-selection; exact-slot replacement; opener persistence and durability decrement verified.

Tooltip pipeline: restored tooltip fields displayed correctly; no compile errors after merge; prefab bindings validated at runtime.

Options/Audio: Title Menu → OptionsScene via fader and blocker; in-game panel toggle now correctly , with resolved EventSystem conflicts; sliders update AudioManager live and working.

UI stability: repeated interactions produced no NREs after defensive patches.

Logs, probes and instrumentation added
Ghost item detection in PlayerInventoryManager.LogGhostItems.

ReplaceItemInPlace probes: log gear slot, index, expected vs actual asset reference before replacement.

InventoryStateManager logs for RegisterItem, UnregisterItem, RemoveItem.

ItemTooltipManager added explicit logs for missing slot/asset/injectable/item to pinpoint NRE sources.

Tooltip Validator helper logs extended to confirm live bindings are assigned and active.

Implementation notes & caveats
Only destroy runtime clones; do not destroy template ScriptableObjects from ItemRegistry — mark runtime clones at creation or track them.

InventoryStateManager is keyed by ItemID for compatibility; UnregisterItem removes by reference first then by ID fallback.

Ensure persistence respects unique instance identification if you want save-level exclusion of removed instances.

Audit other systems for use of InventoryStateManager.GetLiveItem for construction — they must instead use ItemFactory/Create or Instantiate templates.

updated code ( personal reference )

Itemtooltipmanager

using Game.Inventory;
using Game.Items;
using Game.Player;
using System.Collections.Generic;
using TMPro;
using UnityEngine;
using UnityEngine.UI;
using static UnityEditor.Progress;

public class ItemTooltipManager : MonoBehaviour
{
    public static ItemTooltipManager Instance { get; private set; }

    [Header("UI References")]
    public GameObject panel;
    public TextMeshProUGUI ItemDisplayNameText;
    public TextMeshProUGUI ItemDescriptionText;
    public TextMeshProUGUI ItemLoreTagText;
    public TextMeshProUGUI ItemWeightLabelText;
    public TextMeshProUGUI ItemWeightValueText;
    public TextMeshProUGUI ItemConditionLabelText;
    public TextMeshProUGUI ItemDurabilityValueText;
    public TextMeshProUGUI ItemUsesText;
    public TextMeshProUGUI ItemRarityText;
    public TextMeshProUGUI ItemLiquidVolumeText;
    public TextMeshProUGUI ItemGasVolumeText;

    [Header("Overlay")]
    public Image overlayImage;

    [Header("Inventory Buttons")]
    public Button Button1;
    public Button Button2;
    public Button Button3;
    public Button Button4;
    public Button Button5;

    public TextMeshProUGUI Button1Label;
    public TextMeshProUGUI Button2Label;
    public TextMeshProUGUI Button3Label;
    public TextMeshProUGUI Button4Label;
    public TextMeshProUGUI Button5Label;

    [Header("Use Panel Button Icons")]
    public Image Button1Icon;
    public Image Button2Icon;
    public Image Button3Icon;
    public Image Button4Icon;
    public Image Button5Icon;

    [Header("Panel References")]
    [SerializeField] private UsePanelManager usePanelManager;

    [Header("Liquid Info Panel")]
    public GameObject LiquidInfoPanel;
    public TextMeshProUGUI LiquidTypeText;
    public TextMeshProUGUI ContaminationValueText;
    public TextMeshProUGUI TemperatureValueText;

    private InventoryItem currentItem;
    private InventorySlotUI activeSlot;

    private Dictionary<int, Button> buttonMap;
    private Dictionary<int, TextMeshProUGUI> labelMap;
    private Dictionary<int, Image> iconMap;

    private void Awake()
    {
        Instance = this;

        buttonMap = new()
        {
            { 1, Button1 },
            { 2, Button2 },
            { 3, Button3 },
            { 4, Button4 },
            { 5, Button5 }
        };

        labelMap = new()
        {
            { 1, Button1Label },
            { 2, Button2Label },
            { 3, Button3Label },
            { 4, Button4Label },
            { 5, Button5Label }
        };

        iconMap = new()
        {
            { 1, Button1Icon },
            { 2, Button2Icon },
            { 3, Button3Icon },
            { 4, Button4Icon },
            { 5, Button5Icon }
        };

        Button1.onClick.AddListener(() => ExecuteInventoryAction(1));
        Button2.onClick.AddListener(() => ExecuteInventoryAction(2));
        Button3.onClick.AddListener(() => ExecuteInventoryAction(3));
        Button4.onClick.AddListener(() => ExecuteInventoryAction(4));
        Button5.onClick.AddListener(() => ExecuteInventoryAction(5));

        SetTextVisibility(false);
        foreach (var kvp in buttonMap)
        {
            kvp.Value.gameObject.SetActive(false);
            labelMap[kvp.Key].text = "";
            iconMap[kvp.Key].enabled = false;
        }

        LiquidInfoPanel?.SetActive(false);
        ItemLiquidVolumeText?.gameObject.SetActive(false);
        ItemGasVolumeText?.gameObject.SetActive(false);
    }

    public void ShowTooltip(InventoryItem item, InventorySlotUI slot = null)
    {
        if (panel == null || item == null || !item.IsValid())
        {
            HideTooltip();
            return;
        }

        var liveItem = InventoryStateManager.Instance?.GetLiveItem(item.ItemID);
        if (liveItem != null)
        {
            item = liveItem;
            Debug.Log($"[Worm] 🧬 Live item rebound for tooltip: {item.ItemID}");
        }

        currentItem = item;
        activeSlot = slot;

        panel.SetActive(true);
        panel.transform.SetAsLastSibling();
        overlayImage?.gameObject.SetActive(false);

        SetTextVisibility(true);
        ItemDisplayNameText.text = !string.IsNullOrEmpty(item.DisplayName)
            ? item.DisplayName
            : "[Unnamed Item]";

        ItemDescriptionText.text = item.GetDescription();
        ItemLoreTagText.text = item.GetLoreTag();

        ItemWeightLabelText.text = "Weight";
        ItemWeightLabelText.color = ItemConditionResolver.GetWeightColor(item.GetWeight());
        ItemWeightValueText.text = $"{item.GetWeight():0.00} kg";
        ItemWeightValueText.color = ItemConditionResolver.GetWeightColor(item.GetWeight());

        UpdateUses(item);
        InjectInventoryButtons(item);

        bool hasLiquid = item.CurrentVolumeML > 0 || item.MaxVolumeML > 0;
        bool hasGas = item.CurrentGasVolumeML > 0 || item.MaxGasVolumeML > 0;

        if (hasLiquid)
        {
            ItemLiquidVolumeText.text = $"Volume {item.CurrentVolumeML}/{item.MaxVolumeML}ml";
            ItemLiquidVolumeText.gameObject.SetActive(true);

            if (item.CurrentVolumeML > 0)
            {
                LiquidInfoPanel?.SetActive(true);
                LiquidTypeText.text = item.CurrentLiquidType ?? "";
                ContaminationValueText.text = item.ContaminationTag ?? "";
                TemperatureValueText.text = item.LiquidTemperatureCelsius > 0
                    ? $"{item.LiquidTemperatureCelsius:0.#}°C"
                    : "";
            }
            else
            {
                LiquidInfoPanel?.SetActive(false);
            }
        }
        else
        {
            ItemLiquidVolumeText.text = "";
            ItemLiquidVolumeText.gameObject.SetActive(false);
            LiquidInfoPanel?.SetActive(false);
        }

        if (hasGas)
        {
            ItemGasVolumeText.text = $"Volume {item.CurrentGasVolumeML}/{item.MaxGasVolumeML}ml";
            ItemGasVolumeText.gameObject.SetActive(true);
        }
        else
        {
            ItemGasVolumeText.text = "";
            ItemGasVolumeText.gameObject.SetActive(false);
        }

        Debug.Log($"[Worm] 🧪 Tooltip data: Liquid={item.CurrentVolumeML}/{item.MaxVolumeML}, Gas={item.CurrentGasVolumeML}/{item.MaxGasVolumeML}");
    }

    public void RebindTooltip(InventoryItem item, InventorySlotUI slot)
    {
        if (item == null || slot == null || string.IsNullOrEmpty(item.ItemID))
        {
            Debug.LogWarning("[Worm] ❌ RebindTooltip failed.");
            return;
        }

        currentItem = item;
        activeSlot = slot;
        ShowTooltip(item, slot);
        Debug.Log($"[Worm] 🔁 Tooltip rebound for item: {item.ItemID}, slot: {slot.name}");
    }
    private void ExecuteInventoryAction(int slot)
    {
        if (currentItem == null)
        {
            Debug.LogWarning("[Tenchu] currentItem is null.");
            return;
        }

        string action = currentItem.GetButtonLabel(slot, "inventory");
        if (string.IsNullOrEmpty(action))
        {
            Debug.LogWarning("[Tenchu] Action label is empty.");
            return;
        }

        Debug.Log($"[Tenchu] Slot {slot} triggered action: {action}");

        switch (action.ToLowerInvariant())
        {
            case "attach":
                UniversalAttachmentManager.Instance?.TryAttach(currentItem.assetReference);
                HideTooltip();
                break;

            case "discard":
                if (currentItem == null)
                {
                    Debug.LogWarning("[Tenchu] ❌ Discard failed: currentItem is null.");
                    return;
                }

                bool removed = false;

                // Prefer removal by live instance if possible
                if (PlayerInventoryManager.Instance != null)
                {
                    removed = PlayerInventoryManager.Instance.RemoveItem(currentItem);
                    if (!removed)
                        removed = PlayerInventoryManager.Instance.RemoveItem(currentItem.ItemID);
                }
                else
                {
                    Debug.LogWarning("[Tenchu] ❌ Discard failed: PlayerInventoryManager.Instance is null.");
                }

                // Ensure global registry no longer references the instance
                if (InventoryStateManager.Instance != null)
                {
                    InventoryStateManager.Instance.UnregisterItem(currentItem);
                }
                else
                {
                    Debug.LogWarning("[Tenchu] ⚠️ InventoryStateManager.Instance is null; cannot unregister item.");
                }

                if (removed)
                {
                    if (activeSlot != null)
                    {
                        activeSlot.ClearSlot();
                        Debug.Log($"[Tenchu] 🧼 Cleared slot: {activeSlot.name}");
                    }

                    HideTooltip();
                    Debug.Log($"[Tenchu] 🗑️ Discarded item: {currentItem.ItemID}");
                }
                else
                {
                    Debug.LogWarning($"[Tenchu] ⚠️ Failed to remove item '{currentItem.ItemID}' from PlayerInventoryManager.");
                    // Still hide tooltip and attempt UI clear to avoid stale UI state
                    if (activeSlot != null)
                    {
                        activeSlot.ClearSlot();
                        Debug.Log($"[Tenchu] 🧼 Cleared slot (fallback): {activeSlot.name}");
                    }
                    HideTooltip();
                }
                break;

            case "equip":
                bool equipped = PlayerEquipManager.Instance?.TryEquipInventoryItemIfSlotEmpty(currentItem) ?? false;
                if (!equipped)
                {
                    Debug.LogWarning($"[Tooltip] 🚫 Equip blocked for '{currentItem.ItemID}' — slot may be occupied.");
                    PlayerEquipManager.Instance?.ShowEquipWarning("Hands slot is occupied. Unequip first.");
                }
                HideTooltip();
                break;

            case "use":
            case "fill":
            case "empty":
            case "combine":
            case "place":
            case "pour":
            case "eat":
            case "drink":
                usePanelManager?.OpenPanel(currentItem, activeSlot);
                break;

            case "open":
                Debug.Log($"[Tenchu] 🧿 Opening ritual triggered for '{currentItem.ItemID}'");
                OpenPanelManager.Instance?.ShowOpenersFor(currentItem);
                break;

            default:
                Debug.LogWarning($"[Tenchu] Unhandled action: {action}");
                break;
        }
    }

    private void InjectInventoryButtons(InventoryItem item)
    {
        foreach (var kvp in buttonMap)
        {
            kvp.Value.gameObject.SetActive(false);
            labelMap[kvp.Key].text = "";
            iconMap[kvp.Key].enabled = false;
        }

        SetButton(1, item.InventoryButton1Label);
        SetButton(2, item.InventoryButton2Label);
        SetButton(3, item.InventoryButton3Label);
        SetButton(4, item.InventoryButton4Label);
        SetButton(5, item.InventoryButton5Label);
    }

    private void SetButton(int slot, string labelText)
    {
        bool hasLabel = !string.IsNullOrEmpty(labelText);
        buttonMap[slot].gameObject.SetActive(hasLabel);
        labelMap[slot].text = hasLabel ? labelText : "";

        if (iconMap.TryGetValue(slot, out var icon))
        {
            var sprite = UsePanelIconRegistry.GetIcon(labelText);
            icon.sprite = sprite;
            icon.enabled = sprite != null;
        }
    }

    public void UpdateUses(InventoryItem item)
    {
        string conditionLabel = item.GetConditionLabel();
        Color conditionColor = ItemConditionResolver.GetConditionColorByDurability(item.Durability);

        ItemConditionLabelText.text = $"Condition: {conditionLabel}";
        ItemConditionLabelText.color = conditionColor;

        ItemDurabilityValueText.text = $"Durability: {item.Durability}/100";
        ItemDurabilityValueText.color = conditionColor;

        if (item.ZeroUseMode == ZeroUseMode.UntilDurabilityZero)
        {
            ItemUsesText.gameObject.SetActive(false);
        }
        else if (item.RemainingUses > 0)
        {
            float percent = item.MaxUses > 0 ? (float)item.RemainingUses / item.MaxUses : 0f;
            Color useColor = ItemConditionResolver.GetUseColorByPercentage(percent);

            ItemUsesText.text = $"Uses: {item.RemainingUses}";
            ItemUsesText.color = useColor;
            ItemUsesText.gameObject.SetActive(true);
        }
        else
        {
            switch (item.ZeroUseMode)
            {
                case ZeroUseMode.Unlimited:
                    ItemUsesText.text = "Uses: Unlimited";
                    ItemUsesText.color = ItemConditionResolver.GetUseColorByPercentage(1.0f);
                    ItemUsesText.gameObject.SetActive(true);
                    break;
                case ZeroUseMode.Zero:
                    ItemUsesText.text = "Uses: 0";
                    ItemUsesText.color = ItemConditionResolver.GetUseColorByPercentage(0f);
                    ItemUsesText.gameObject.SetActive(true);
                    break;
                default:
                    ItemUsesText.gameObject.SetActive(false);
                    break;
            }
        }

        if (!string.IsNullOrEmpty(item.Rarity))
        {
            ItemRarityText.text = $"Rarity: {item.Rarity}";
            ItemRarityText.color = GetColorForRarity(item.Rarity);
        }
    }

    private Color GetColorForRarity(string rarity)
    {
        return rarity switch
        {
            "Common" => Color.white,
            "Uncommon" => new Color(0.3f, 1.0f, 0.3f),
            "Rare" => new Color(0.3f, 0.5f, 1.0f),
            "Epic" => new Color(0.6f, 0.2f, 0.8f),
            "Legendary" => new Color(1.0f, 0.84f, 0.0f),
            _ => Color.white
        };
    }

    public void HideTooltip()
    {
        Debug.Log($"[Worm] 🧹 Tooltip hidden. Clearing slot: {(activeSlot != null ? activeSlot.name : "null")}");
        currentItem = null;
        activeSlot = null;
        SetTextVisibility(false);

        foreach (var kvp in buttonMap)
        {
            kvp.Value.gameObject.SetActive(false);
            labelMap[kvp.Key].text = "";
            iconMap[kvp.Key].enabled = false;
        }

        ItemLiquidVolumeText.text = "";
        ItemLiquidVolumeText.gameObject.SetActive(false);

        ItemGasVolumeText.text = "";
        ItemGasVolumeText.gameObject.SetActive(false);

        LiquidInfoPanel?.SetActive(false);
        panel?.SetActive(false);
    }

    private void SetTextVisibility(bool visible)
    {
        ItemDisplayNameText.enabled = visible;
        ItemDescriptionText.enabled = visible;
        ItemLoreTagText.enabled = visible;
        ItemWeightLabelText.enabled = visible;
        ItemWeightValueText.enabled = visible;
        ItemConditionLabelText.enabled = visible;
        ItemDurabilityValueText.enabled = visible;
        ItemUsesText.enabled = visible;
        ItemRarityText.enabled = visible;
        ItemLiquidVolumeText.enabled = visible;
        ItemGasVolumeText.enabled = visible;
    }
}

Inventorystatemanager

using Game.Inventory;
using System.Collections.Generic;
using UnityEngine;

public class InventoryStateManager : MonoBehaviour
{
    public static InventoryStateManager Instance { get; private set; }

    // Keyed by item.ItemID for backwards compatibility, but we also support removal by reference.
    private Dictionary<string, InventoryItem> liveItems = new();

    private void Awake()
    {
        if (Instance == null)
        {
            Instance = this;
            DontDestroyOnLoad(gameObject);
            Debug.Log("[Worm] 🧬 InventoryStateManager initialized.");
        }
        else
        {
            Destroy(gameObject);
        }
    }

    public void RegisterItem(InventoryItem item)
    {
        if (item == null || string.IsNullOrEmpty(item.ItemID))
        {
            Debug.LogWarning("[Worm] ❌ Attempted to register null or invalid item.");
            return;
        }

        // If there's already a registered instance for this ItemID, warn if it's a different reference.
        if (liveItems.TryGetValue(item.ItemID, out var existing))
        {
            if (!ReferenceEquals(existing, item))
            {
                Debug.LogWarning($"[Worm] ⚠️ RegisterItem: replacing existing registered instance for ID '{item.ItemID}'. Existing instance will be overwritten.");
            }
        }

        liveItems[item.ItemID] = item;
        Debug.Log($"[Worm] ✅ Registered item: {item.ItemID} | Volume={item.CurrentVolumeML} | LiquidType={item.CurrentLiquidType}");
    }

    public bool IsItemRegistered(string itemID)
    {
        return !string.IsNullOrEmpty(itemID) && liveItems.ContainsKey(itemID);
    }

    public InventoryItem GetLiveItem(string itemID)
    {
        if (string.IsNullOrEmpty(itemID))
        {
            Debug.LogWarning("[Worm] ❌ GetLiveItem called with null or empty ID.");
            return null;
        }

        if (liveItems.TryGetValue(itemID, out var item))
        {
            Debug.Log($"[Worm] 🧪 Retrieved live item: {itemID} | Volume={item.CurrentVolumeML} | LiquidType={item.CurrentLiquidType}");
            return item;
        }

        // Silent null is fine for normal flow; keep warning for debug visibility
        Debug.LogWarning($"[Worm] ⚠️ No live item found for ID: {itemID}");
        return null;
    }

    // Restore compatibility: mark a registered item as equipped (by ID)
    public void MarkItemAsEquipped(string itemID)
    {
        if (string.IsNullOrEmpty(itemID))
        {
            Debug.LogWarning("[Worm] ❌ MarkItemAsEquipped called with null or empty ID.");
            return;
        }

        if (liveItems.TryGetValue(itemID, out var item))
        {
            item.IsEquipped = true;
            Debug.Log($"[Worm] 🧬 Item '{itemID}' marked as equipped.");
        }
        else
        {
            Debug.LogWarning($"[Worm] ❌ Item '{itemID}' not found in registry when marking equipped.");
        }
    }

    // Overload: mark as equipped by instance reference
    public void MarkItemAsEquipped(InventoryItem item)
    {
        if (item == null)
        {
            Debug.LogWarning("[Worm] ❌ MarkItemAsEquipped called with null item.");
            return;
        }

        // Prefer reference-based lookup
        if (TryGetLiveItemByReference(item, out var registered))
        {
            registered.IsEquipped = true;
            Debug.Log($"[Worm] 🧬 Item '{registered.ItemID}' marked as equipped by reference.");
            return;
        }

        // Fallback by ID
        MarkItemAsEquipped(item.ItemID);
    }

    // New: Unregister by InventoryItem instance (preferred)
    public void UnregisterItem(InventoryItem item)
    {
        if (item == null)
        {
            Debug.LogWarning("[Worm] ❌ UnregisterItem called with null.");
            return;
        }

        // Try remove by reference first
        string keyToRemove = null;
        foreach (var kvp in liveItems)
        {
            if (ReferenceEquals(kvp.Value, item))
            {
                keyToRemove = kvp.Key;
                break;
            }
        }

        if (!string.IsNullOrEmpty(keyToRemove))
        {
            liveItems.Remove(keyToRemove);
            Debug.Log($"[Worm] 🗑️ Unregistered live item by reference: {keyToRemove}");
            return;
        }

        // Fallback: remove by matching ItemID if present
        if (!string.IsNullOrEmpty(item.ItemID) && liveItems.Remove(item.ItemID))
        {
            Debug.Log($"[Worm] 🗑️ Unregistered live item by ID fallback: {item.ItemID}");
            return;
        }

        Debug.LogWarning($"[Worm] ⚠️ UnregisterItem: item '{item.ItemID}' not found in registry.");
    }

    // Keep RemoveItem by ID for callers that only have itemID
    public void RemoveItem(string itemID)
    {
        if (string.IsNullOrEmpty(itemID))
        {
            Debug.LogWarning("[Worm] ❌ RemoveItem called with null or empty ID.");
            return;
        }

        if (liveItems.Remove(itemID))
        {
            Debug.Log($"[Worm] 🗑️ Removed item: {itemID} from live registry.");
        }
        else
        {
            Debug.LogWarning($"[Worm] ⚠️ Item '{itemID}' not found in live registry.");
        }
    }

    public Dictionary<string, InventoryItem> GetAllLiveItems()
    {
        return liveItems;
    }

    public void ClearAll()
    {
        liveItems.Clear();
        Debug.Log("[Worm] 🧹 InventoryStateManager cleared all live items.");
    }

    // Helper: attempt to find a live item by exact instance reference
    public bool TryGetLiveItemByReference(InventoryItem instance, out InventoryItem found)
    {
        found = null;
        if (instance == null) return false;
        foreach (var kvp in liveItems)
        {
            if (ReferenceEquals(kvp.Value, instance))
            {
                found = kvp.Value;
                return true;
            }
        }
        return false;
    }
}

Usepanelmanager

using Game.Inventory;
using Game.Player;
using System.Collections.Generic;
using TMPro;
using UnityEngine;
using UnityEngine.UI;
using Game.UI;

public class UsePanelManager : MonoBehaviour
{
    public static UsePanelManager Instance { get; private set; }

    public bool IsOpen => panelRoot != null && panelRoot.activeInHierarchy;

    [Header("Panel Root")]
    [SerializeField] private GameObject panelRoot;

    [Header("UI References")]
    [SerializeField] private TMP_Text TitleText;
    [SerializeField] private Image BlackoutImage;
    [SerializeField] private Image ItemIcon;
    [SerializeField] private TMP_Text ItemName;

    [Header("Buttons")]
    [SerializeField] private Button Button2;
    [SerializeField] private Button Button3;
    [SerializeField] private Button Button4;
    [SerializeField] private Button Button5;
    [SerializeField] private Button Button6;

    [Header("Labels")]
    [SerializeField] private TMP_Text Button2Label;
    [SerializeField] private TMP_Text Button3Label;
    [SerializeField] private TMP_Text Button4Label;
    [SerializeField] private TMP_Text Button5Label;
    [SerializeField] private TMP_Text Button6Label;

    [Header("Icons")]
    [SerializeField] private Image Button2Icon;
    [SerializeField] private Image Button3Icon;
    [SerializeField] private Image Button4Icon;
    [SerializeField] private Image Button5Icon;
    [SerializeField] private Image Button6Icon;

    [Header("Use Sprite Registry")]
    [SerializeField] private UseSpriteRegistry useSpriteRegistry;

    [Header("Attachment Panel")]
    [SerializeField] private UniversalAttachmentPanel attachmentPanel;

    [Header("Story Node")]
    [SerializeField] private StoryNodeLoader storyNodeLoader;

    [Header("Close Button")]
    [SerializeField] private Button closeButton;

    private List<Button> buttons;
    private List<TMP_Text> labels;
    private List<Image> icons;

    private InventorySlotUI currentSlot;

    private void Awake()
    {
        Instance = this;
        buttons = new List<Button> { Button2, Button3, Button4, Button5, Button6 };
        labels = new List<TMP_Text> { Button2Label, Button3Label, Button4Label, Button5Label, Button6Label };
        icons = new List<Image> { Button2Icon, Button3Icon, Button4Icon, Button5Icon, Button6Icon };

        if (BlackoutImage != null)
            BlackoutImage.gameObject.SetActive(false);
    }

    public void OpenPanel(InventoryItem item, InventorySlotUI slot)
    {
        if (slot == null || item == null) return;

        if (panelRoot.activeInHierarchy)
        {
            HidePanel();
        }

        currentSlot = slot;

        panelRoot.SetActive(true);
        panelRoot.transform.localScale = Vector3.one;
        panelRoot.transform.SetAsLastSibling();

        var cg = panelRoot.GetComponent<CanvasGroup>();
        if (cg != null)
        {
            cg.alpha = 1f;
            cg.interactable = true;
            cg.blocksRaycasts = true;
        }

        HideAllButtons();
        UpdateItemDisplay(item);

        if (TitleText != null)
            TitleText.text = "Item Use Menu";

        if (BlackoutImage != null)
            BlackoutImage.gameObject.SetActive(true);

        // ✅ Only show contextual use actions (not Attach/Equip)
        for (int i = 1; i <= 5; i++)
        {
            string label = item.GetUseLabel(i);
            if (!string.IsNullOrEmpty(label) && i - 1 < buttons.Count)
            {
                if (label.Equals("Attach", System.StringComparison.OrdinalIgnoreCase) ||
                    label.Equals("Equip", System.StringComparison.OrdinalIgnoreCase))
                {
                    continue;
                }

                Sprite icon = GetIconForLabel(label);

                UnityEngine.Events.UnityAction action = () =>
                {
                    Debug.Log($"[UsePanelManager] Action triggered: {label} for item {item.ItemID}");

                    switch (label.ToLowerInvariant())
                    {
                        case "open":
                            if (ItemOpenerResolver.IsOpenerTool(item))
                            {
                                // Tool path → show containers, then close
                                OpenPanelManager.Instance?.ShowOpenersFor(item);
                                HidePanel();
                            }
                            else
                            {
                                // Container path → show tools, keep panel open
                                OpenPanelManager.Instance?.ShowOpenersFor(item);
                            }
                            break;

                        case "slice":
                            Debug.Log($"[UsePanelManager] Slice action placeholder for {item.ItemID}");
                            HidePanel();
                            break;

                        case "repair":
                            Debug.Log($"[UsePanelManager] Repair action placeholder for {item.ItemID}");
                            HidePanel();
                            break;

                        case "fill":
                        case "empty":
                        case "combine":
                        case "place":
                        case "pour":
                        case "eat":
                        case "drink":
                            InventoryStateManager.Instance?.RegisterItem(item);
                            HidePanel();
                            break;

                        default:
                            Debug.LogWarning($"[UsePanelManager] Unhandled action: {label}");
                            HidePanel();
                            break;
                    }
                };

                ShowButton(i - 1, label, icon, action);
            }
        }
    }

    private void HideAllButtons()
    {
        foreach (var btn in buttons)
        {
            if (btn != null)
            {
                btn.gameObject.SetActive(false);
                btn.onClick.RemoveAllListeners();
            }
        }

        foreach (var icon in icons)
        {
            if (icon != null)
            {
                icon.sprite = null;
                icon.gameObject.SetActive(false);
            }
        }
    }

    private void UpdateItemDisplay(InventoryItem item)
    {
        if (ItemIcon != null)
            ItemIcon.sprite = item?.Icon;

        if (ItemName != null)
            ItemName.text = item?.DisplayName ?? "Unknown Item";
    }

    private void ShowButton(int index, string label, Sprite icon, UnityEngine.Events.UnityAction action)
    {
        if (index < 0 || index >= buttons.Count) return;

        var btn = buttons[index];
        var lbl = labels[index];
        var icn = icons[index];

        if (btn != null)
        {
            btn.gameObject.SetActive(true);
            btn.onClick.RemoveAllListeners();
            btn.onClick.AddListener(action);
        }

        if (lbl != null)
            lbl.text = label;

        if (icn != null)
        {
            icn.sprite = icon;
            icn.enabled = icon != null;
            icn.gameObject.SetActive(icon != null);
        }
    }

    private Sprite GetIconForLabel(string label)
    {
        if (useSpriteRegistry == null || string.IsNullOrEmpty(label)) return null;
        return useSpriteRegistry.GetSprite(label);
    }

    public void HidePanel()
    {
        if (panelRoot != null)
        {
            panelRoot.SetActive(false);

            var cg = panelRoot.GetComponent<CanvasGroup>();
            if (cg != null)
            {
                cg.blocksRaycasts = false;
                cg.interactable = false;
            }
        }

        if (BlackoutImage != null)
            BlackoutImage.gameObject.SetActive(false);

        currentSlot = null;

        ItemTooltipManager.Instance?.HideTooltip();
    }

    public void ManualClosePanel()
    {
        Debug.Log("[UsePanelManager] 🧹 ManualClosePanel triggered via inspector button");
        HidePanel();
    }

    public void ForceClosePanel()
    {
        Debug.Log("[UsePanelManager] 🧹 ForceClosePanel invoked — forcibly collapsing panel");

        try
        {
            if (panelRoot != null)
            {
                panelRoot.SetActive(false);

                var cg = panelRoot.GetComponent<CanvasGroup>();
                if (cg != null)
                {
                    cg.alpha = 0f;
                    cg.interactable = false;
                    cg.blocksRaycasts = false;
                }
            }

            if (BlackoutImage != null)
                BlackoutImage.gameObject.SetActive(false);

            currentSlot = null;

            ItemTooltipManager.Instance?.HideTooltip();

            Debug.Log("[UsePanelManager] ✅ Panel forcibly closed and state reset");
        }
        catch (System.Exception ex)
        {
            Debug.LogError($"[UsePanelManager] ❌ ForceClosePanel failed: {ex.Message}");
        }
    }
}

Dev Log 36 - Mythic Pause

John — Sat, 08 Nov 2025 16:28:46 +0000

🧊 🌋 ❄️ ✈️ ⚔️ 9-Day Break: The Mythic Pause

A personal reflection and journal log

🌍 Icelandic Interlude: The First Real Break
I travelled to the beautiful country of Iceland — a land of glaciers, volcanoes, and mythic quiet. It felt like stepping into another world. My first real vacation, and it was everything I hoped for:

A slower, more intentional pace of life

Surprisingly delicious food (despite the warnings)

Friendly locals and a calm atmosphere, even with tourists

Expensive, yes — but worth every krona

After seven days of awe, I returned home and took two days to re-sync with reality. Then I reopened my survival engine project — and it felt like deciphering someone else’s code.

🧭 Reentry Ritual: Reforging Flow
I eased back in slowly, rekindling my dev rituals:

Reviewed commits and journal entries

Revisited ItemTooltipManager.cs and InventoryStateManager.cs

Verified tooltip accuracy and runtime truth

Rebound live item data and refreshed UI bindings

Reconnected with my discard ritual sabotage

🧨 Sabotage Discovered: False Discard Ritual
❌ Issue
Pressing the discard button triggered the use panel instead of purging the item.

Symptoms:

Use panel opened on discard

Item visually disappeared but wasn’t truly deleted

Discarded items reappeared after looting

🔧 Fixes Applied: The True Purge Path
Separated discard logic in ExecuteInventoryAction()

Removed "discard" from use panel logic

Added null guards and slot cleanup

Forged RemoveItem() in InventoryStateManager

Added RemoveItemByID() in PlayerInventoryManager

Called activeSlot.ClearSlot() to purge lingering UI

Verified resurrection trap → loot panel was rehydrating from ContainedAssets

Purged item from all sources

✅ Outcome: Ritual Sealed
Discard now fully deletes item across all systems

No false panel summons

No ghost sprites

No resurrection on loot

Console logs confirm true purge

🧪 Debug Tags

[Tenchu] 🗑️ Discarded item: {itemID}  
[Unicorn] 🧹 Removed item '{itemID}' from gear slot  
[Worm] 🧬 Removed item: {itemID} from live registry

🧤 Equip Ritual Reforged: The Hands Transfer Purge
❌ Issue
Equipped items were appearing in both the hands slot and the inventory — violating runtime truth.

Symptoms:

Item appeared in hands and inventory simultaneously

Unequipping duplicated the item

InventoryStateManager and gear slots retained stale references

🔧 Fixes Applied: The True Equip Path
Purged from InventoryStateManager → RemoveItem(itemID)

Purged from PlayerInventoryManager → RemoveItem(itemID)

Cleared from UI slot → slot.GetItem()?.ItemID == item.ItemID → slot.ClearSlot()

Injected into hands slot → GearSlotUI.RefreshSlotWithInventoryItem(item)

Verified equip flow in EquipInventoryItem() → All purges occur before injection

✅ Outcome: Ritual Sealed
Item now transfers cleanly from inventory to hands

No duplication on unequip

No ghost sprites or registry remnants

Console confirms full purge and equip

🧪 Debug Tags

[EquipManager] 🧼 Removed '{itemID}' from InventoryStateManager  
[EquipManager] 🧼 Removed '{itemID}' from PlayerInventoryManager  
[EquipManager] 🧹 Cleared inventory UI slot for '{itemID}'  
[EquipManager] 🧤 InventoryItem equipped to slot 'Hands' → {itemID}

📜 Relic Logged: The Hands Transfer Purge Ritual
Restores runtime truth by ensuring equipped items are fully purged from inventory systems before injection into hands.

🧠 Dev Mindset: From Fog to Flow
The first few hours felt like wandering through someone else's shrine. My keyboard was unfamiliar, my systems distant. But each debug tag was a breadcrumb. By the time I traced the discard sabotage, I was fully reawakened. The rituals returned. The myth resumed.

🧪 Test Rituals
Equipped item from slot 3 → verified removal from UI and registry

Unequipped item → confirmed reappearance in first free slot

Discarded item → confirmed no resurrection on loot

Attempted equip with no free slot → verified graceful failure

Rebound tooltip after contamination → confirmed live data accuracy

🧰 Ritual Hooks
ExecuteInventoryAction() → Entry point for discard and equip logic

RemoveItem() → Purges item from registry and gear slots

ClearSlot() → Wipes UI remnants

EquipInventoryItem() → Seals the hands transfer ritual

RefreshSlotWithInventoryItem() → Injects item into hands slot

📈 Impact
Enables true equip/unequip cycles

Prevents inventory overflow and ghost duplication

Strengthens tooltip accuracy and runtime clarity

Paves the way for equip swap fallback and slot registry automation

🧩 Open Threads
Tooltip overlay cleanup on unequip

Equip swap fallback logic

Slot registry automation

Ghost item detection on scene reload

🔮 Reflection & Reconnection
This return wasn’t just technical — it was emotional. I reconnected with my systems, my rituals, and my mythic mindset. I remembered why I build: to immortalize clarity, to ritualize resilience, and to seal every fix as a legacy relic.

🧩 Next Steps: The HUD Binding Ritual
Continue wiring function logic to HUD and inventory buttons

Polish tooltip overlays and contamination indicators

Expand systems: battle logic, equip swap fallback, slot registry automation

Revisit vector purification and overlay controller cleanup

Slowly but surely the progress will continue.

Dev Log 35 - Equip Hands Tooltips

John — Wed, 22 Oct 2025 21:39:10 +0000

🧙‍♂️ Survival Engine Debug Log: Hands Slot Resurrection & Tooltip Bifurcation Ritual

🔍 Initial Problem: The Ghost of Hands Slot

The Hands slot was a phantom. No sprite. No tooltip. No runtime truth. Clicking it felt like whispering into the void. Hovering? Nothing.

Meanwhile, gear slots were living their best lives — fully wired, fully responsive. Hands was the neglected middle child of the UI hierarchy.

🧪 Phase 1: Interface Alignment & Shrine Purification
✅ Verified:

GearSlotUI.cs was referencing ghost fields like GetRarity() and GetArmourValue() — banished.

IInjectableItem was shrine-pure, defining all necessary methods for runtime injection.

🔧 Actions:

Refactored GearSlotUI.cs to use only valid IInjectableItem methods: GetItemID(), GetDisplayName(), GetDescription(), GetLoreTag(), GetWeight(), GetConditionState(), GetItem()

📚 Lesson Learned: Don’t trust legacy fields. They lie. Interfaces are truth.

🧱 Phase 2: Hands Slot Injection Ritual
✅ Implemented:

AssignItemFromInteraction() now detects IInjectableItem and injects into Hands slot

RefreshSlotWithInventoryItem() wires up overlay sprite

ShowTooltip() pulls live data via InventoryManager.Instance.itemRegistry.GetByID(item.ItemID)

🧪 Result:

Sprite now appears in Hands slot

Tooltip sometimes works, but responsiveness was flaky — like a cursed relic half-awake

🧼 Phase 3: Tooltip Locking & Responsiveness Fix

🔍 Problem: Clicking gear slots sometimes failed to show tooltip. Tooltip locking logic was interfering with slot switching.

✅ Fix:

Patched OnPointerClick() to:

Unlock and hide previous slot’s tooltip

Lock and show current slot’s tooltip

Reset currentSelectedSlot properly

📚 Lesson Learned: Tooltips are like jealous spirits. You must banish the old one before summoning the new.

🧪 Phase 4: Runtime Validation Ritual
✅ Created:

RuntimeValidator.cs to scan:

GearSlotUI prefab bindings

Tooltip fields

ItemEntry prefab components

🧼 Fixes:

Removed invalid rarityText reference

Added individual checks for all tooltip fields

Confirmed prefab bindings were shrine-pure

📚 Lesson Learned: Prefab validation is not optional. It’s the holy water that keeps runtime demons away.

🧠 Phase 5: Registry Access Restoration
🔍 Problem: InventoryManager.itemRegistry was private, causing access errors

✅ Fix:

Made itemRegistry public

Alternatively offered a getter method GetItemRegistry()

📚 Lesson Learned: If you can’t access the registry, you are not a priest. You are a peasant.

🧰 Phase 6: Tooltip Panel Bifurcation
✅ Implemented:

Split tooltip system into 3 prefab-safe panels:

🛡️ Gear Tooltip Panel

🧰 Inventory Tooltip Panel

🎯 Ranged Tooltip Panel

✅ Refactored GearSlotUI.cs to:

Route tooltips based on item type

Use safe casting (item.itemAsset as MeleeWeaponItem)

Inject prefab-safe data into each panel

🧼 Fixes:

Removed legacy references to tooltipPanel, displayNameText, etc.

Updated RuntimeValidator.cs to validate new fields

📚 Lesson Learned: One tooltip to rule them all? Nope. Three tooltips to bifurcate runtime truth.

🗡️ Phase 7: Melee Diagnostics Injection
✅ Extended Inventory Tooltip Panel to support:

Base Damage, Melee Type, Armor Pierce, Crit Chance, Bleed Chance, Stun Chance

Rarity, Condition, Weight, Lore, Description

✅ Logic:

Melee fields are shown only for MeleeWeaponItem

Hidden ("—") for non-melee items

✅ Inspector Wiring:

All fields injected into GearSlotUI.cs

Prefab bindings confirmed shrine-pure

📚 Lesson Learned: Melee weapons deserve their own shrine. Don’t lump them in with the peasants.

🧾 Final Result
✅ Hands slot now supports any IInjectableItem, including:

Melee weapons

Ranged weapons

Liquids, food, gear, misc

✅ Tooltip system is:

Modular

Prefab-safe

Inspector-driven

Runtime-resilient

✅ All slot interactions are shrine-sealed and bifurcation-aware

✅ Validator confirms prefab integrity across all tooltip panels

✅ Runtime truth restored. Tooltip spirits appeased. Hands slot resurrected.

Need to complete the ranged equipped item tooltip panel , but that is tomorrows ritual. Happy that the items actually attach correctly into the equipped hands slot as intended, and apply live data.

For now the shrine shines.

Dev Log 34 - Tooltip Resurrection

John — Mon, 20 Oct 2025 21:28:01 +0000

🧾 Dev Log — 20 October 2025

Session 1: Tooltip Resurrection & Live Item Preservation Session 2: Unified State Engine & Save Ritual Breakthrough

The liquid entry was the last task, and this was completed, upon further testing the liquid state was there, but I could not get it to keep a saved state no matter what I tried.

Burned through 3 full version backups and my main with different approaches and ended up with spaghetti code on every version.

Could not see the light or a way to fix everything I had done. Thought that I had finally met the end of me vibe coding my way through this project,

Reverted to the final GitHub backup.

🔧 Core Breakthroughs

✅ Tooltip Reset Diagnosed

Identified that ItemTooltipManager resets filled item data (e.g., liquid volume, type) when items are taken from the loot panel. (this was always a issue and I could not figure out what I was doing wrong for a long time)

Root cause: tooltip rebinding to prefab clones after UI refresh—not item replacement.

✅ Live Item Preservation Protocol Injected
Built and deployed InventoryStateManager.cs to track live InventoryItem instances by ItemID.

Provides:

RegisterItem()

GetLiveItem()

ClearAll()

Ensures runtime truth across tooltip rebinding, panel toggles, and future scene transitions.

✅ ItemTooltipManager Updated
Injected live item rebinding into ShowTooltip():

using Game.Inventory;
using Game.Items;
using Game.Player;
using System.Collections.Generic;
using TMPro;
using UnityEngine;
using UnityEngine.UI;

public class ItemTooltipManager : MonoBehaviour
{
    public static ItemTooltipManager Instance { get; private set; }

    [Header("UI References")]
    public GameObject panel;
    public TextMeshProUGUI ItemDisplayNameText;
    public TextMeshProUGUI ItemDescriptionText;
    public TextMeshProUGUI ItemLoreTagText;
    public TextMeshProUGUI ItemWeightLabelText;
    public TextMeshProUGUI ItemWeightValueText;
    public TextMeshProUGUI ItemConditionLabelText;
    public TextMeshProUGUI ItemDurabilityValueText;
    public TextMeshProUGUI ItemUsesText;
    public TextMeshProUGUI ItemRarityText;
    public TextMeshProUGUI ItemVolumeText;

    [Header("Overlay")]
    public Image overlayImage;

    [Header("Inventory Buttons")]
    public Button Button1;
    public Button Button2;
    public Button Button3;
    public Button Button4;
    public Button Button5;

    public TextMeshProUGUI Button1Label;
    public TextMeshProUGUI Button2Label;
    public TextMeshProUGUI Button3Label;
    public TextMeshProUGUI Button4Label;
    public TextMeshProUGUI Button5Label;

    [Header("Panel References")]
    [SerializeField] private UsePanelManager usePanelManager;

    [Header("Liquid Info Panel")]
    public GameObject LiquidInfoPanel;
    public TextMeshProUGUI LiquidTypeText;

    private InventoryItem currentItem;
    private Dictionary<int, Button> buttonMap;
    private Dictionary<int, TextMeshProUGUI> labelMap;

    private InventorySlotUI activeSlot;

    private void Awake()
    {
        Instance = this;

        buttonMap = new()
        {
            { 1, Button1 },
            { 2, Button2 },
            { 3, Button3 },
            { 4, Button4 },
            { 5, Button5 }
        };

        labelMap = new()
        {
            { 1, Button1Label },
            { 2, Button2Label },
            { 3, Button3Label },
            { 4, Button4Label },
            { 5, Button5Label }
        };

        Button1.onClick.AddListener(() => ExecuteInventoryAction(1));
        Button2.onClick.AddListener(() => ExecuteInventoryAction(2));
        Button3.onClick.AddListener(() => ExecuteInventoryAction(3));
        Button4.onClick.AddListener(() => ExecuteInventoryAction(4));
        Button5.onClick.AddListener(() => ExecuteInventoryAction(5));

        SetTextVisibility(false);
        foreach (var kvp in buttonMap)
        {
            kvp.Value.gameObject.SetActive(false);
            labelMap[kvp.Key].text = "";
        }

        LiquidInfoPanel?.SetActive(false);
    }

    public void ShowTooltip(InventoryItem item, InventorySlotUI slot = null)
    {
        if (panel == null || item == null || !item.IsValid())
        {
            HideTooltip();
            return;
        }

        // 🔐 Live item rebinding
        var liveItem = InventoryStateManager.Instance?.GetLiveItem(item.ItemID);
        if (liveItem != null)
        {
            item = liveItem;
            Debug.Log($"[Worm] 🧬 Live item rebound for tooltip: {item.ItemID}");
        }

        currentItem = item;
        activeSlot = slot;

        panel.SetActive(true);
        panel.transform.SetAsLastSibling();
        overlayImage?.gameObject.SetActive(false);

        SetTextVisibility(true);

        ItemDisplayNameText.text = item.GetDisplayName();
        ItemDescriptionText.text = item.GetDescription();
        ItemLoreTagText.text = item.GetLoreTag();
        ItemWeightLabelText.text = "Weight";
        ItemWeightValueText.text = $"{item.GetWeight():0.00} kg";

        UpdateUses(item);
        InjectInventoryButtons(item);

        if (item.IsFillable)
        {
            ItemVolumeText.text = $"Volume: {item.CurrentVolumeML} / {item.MaxVolumeML} ml";
            ItemVolumeText.gameObject.SetActive(true);

            if (item.CurrentVolumeML > 0)
            {
                LiquidInfoPanel?.SetActive(true);
                LiquidTypeText.text = $"{item.CurrentLiquidType}, {item.ContaminationTag}, {item.LiquidTemperatureCelsius}°C";
            }
            else
            {
                LiquidInfoPanel?.SetActive(false);
            }
        }
        else
        {
            ItemVolumeText.text = "";
            ItemVolumeText.gameObject.SetActive(false);
            LiquidInfoPanel?.SetActive(false);
        }

        Debug.Log($"[Worm] 🧪 Tooltip data: Volume={item.CurrentVolumeML}, Type={item.CurrentLiquidType}, Temp={item.LiquidTemperatureCelsius}, Contam={item.ContaminationTag}");
    }

    public void RebindTooltip(InventoryItem item, InventorySlotUI slot)
    {
        currentItem = item;
        activeSlot = slot;
        ShowTooltip(item, slot);
        Debug.Log($"[Worm] 🔁 Tooltip rebound for item: {item?.ItemID}, slot: {(slot != null ? slot.name : "null")}");
    }

    public void RefreshTooltip()
    {
        if (currentItem == null || activeSlot == null)
        {
            Debug.LogWarning("[Worm] ❌ Cannot refresh tooltip — missing item or slot.");
            return;
        }

        ShowTooltip(currentItem, activeSlot);
        Debug.Log($"[Worm] 🔁 Tooltip refreshed for item: {currentItem.ItemID}, slot: {activeSlot.name}");
    }

    private void InjectInventoryButtons(InventoryItem item)
    {
        foreach (var kvp in buttonMap)
        {
            kvp.Value.gameObject.SetActive(false);
            labelMap[kvp.Key].text = "";
        }

        SetButton(1, item.InventoryButton1Label);
        SetButton(2, item.InventoryButton2Label);
        SetButton(3, item.InventoryButton3Label);
        SetButton(4, item.InventoryButton4Label);
        SetButton(5, item.InventoryButton5Label);
    }
    private void SetButton(int slot, string labelText)
    {
        bool hasLabel = !string.IsNullOrEmpty(labelText);
        buttonMap[slot].gameObject.SetActive(hasLabel);
        labelMap[slot].text = hasLabel ? labelText : "";
    }

    private void ExecuteInventoryAction(int slot)
    {
        if (currentItem == null)
        {
            Debug.LogWarning("[Tenchu] currentItem is null.");
            return;
        }

        string action = slot switch
        {
            1 => currentItem.InventoryButton1Label,
            2 => currentItem.InventoryButton2Label,
            3 => currentItem.InventoryButton3Label,
            4 => currentItem.InventoryButton4Label,
            5 => currentItem.InventoryButton5Label,
            _ => null
        };

        Debug.Log($"[Tenchu] Slot {slot} triggered action: {action}");

        if (string.IsNullOrEmpty(action))
        {
            Debug.LogWarning("[Tenchu] Action label is empty.");
            return;
        }

        switch (action.ToLowerInvariant())
        {
            case "eat":
            case "drink":
                PlayerStats.Instance?.ConsumeInventoryItem(currentItem.ItemID);
                InventoryStateManager.Instance?.RegisterItem(currentItem);
                Debug.Log($"[Worm] 🧬 Registered consumed item: {currentItem.ItemID}");
                HideTooltip();
                break;

            case "use":
            case "fill":
                if (usePanelManager != null)
                {
                    Debug.Log($"[Worm] 🧪 '{action}' action triggered for item: {currentItem?.ItemID}, activeSlot: {(activeSlot != null ? activeSlot.name : "❌ NULL")}");

                    if (activeSlot == null)
                    {
                        Debug.LogWarning("[Worm] ❌ activeSlot is null. Cannot open UsePanel.");
                    }
                    else
                    {
                        usePanelManager.OpenPanel(currentItem, activeSlot);
                    }
                }
                break;

            case "attach":
                try
                {
                    UniversalAttachmentManager.Instance?.TryAttach(currentItem.assetReference);
                    InventoryStateManager.Instance?.RegisterItem(currentItem);
                    Debug.Log($"[Worm] 🧬 Registered attached item: {currentItem.ItemID}");
                }
                catch (System.Exception ex)
                {
                    Debug.LogError($"[Tenchu] TryAttach threw: {ex.Message}");
                }
                break;

            default:
                Debug.LogWarning($"[Tenchu] Unhandled action: {action}");
                HideTooltip();
                break;
        }
    }

    public void HideTooltip()
    {
        Debug.Log($"[Worm] 🧹 Tooltip hidden. Clearing slot: {(activeSlot != null ? activeSlot.name : "null")}");
        currentItem = null;
        activeSlot = null;
        SetTextVisibility(false);

        foreach (var kvp in buttonMap)
        {
            kvp.Value.gameObject.SetActive(false);
            labelMap[kvp.Key].text = "";
        }

        ItemVolumeText.text = "";
        ItemVolumeText.gameObject.SetActive(false);
        LiquidInfoPanel?.SetActive(false);
        panel?.SetActive(false);
    }

    private void SetTextVisibility(bool visible)
    {
        ItemDisplayNameText.enabled = visible;
        ItemDescriptionText.enabled = visible;
        ItemLoreTagText.enabled = visible;
        ItemWeightLabelText.enabled = visible;
        ItemWeightValueText.enabled = visible;
        ItemConditionLabelText.enabled = visible;
        ItemDurabilityValueText.enabled = visible;
        ItemUsesText.enabled = visible;
        ItemRarityText.enabled = visible;
        ItemVolumeText.enabled = visible;
    }

    public void UpdateUses(InventoryItem item)
    {
        string category = item.Category ?? item.Type.ToString();
        int durability = item.Durability;
        bool isCooked = item.IsCooked;
        string itemType = item.Type.ToString().ToLowerInvariant();
        bool isSealed = itemType.Contains("sealed");

        string conditionLabel = $"Durability {durability}";
        Color conditionColor = Color.gray;

        try
        {
            conditionLabel = ItemConditionResolver.GetConditionLabel(category, durability, isCooked, itemType, isSealed);
            conditionColor = ItemConditionResolver.GetConditionColorByDurability(durability);
        }
        catch (System.Exception ex)
        {
            Debug.LogError($"[Tenchu] Condition resolver failed: {ex.Message}");
        }

        ItemConditionLabelText.text = conditionLabel;
        ItemConditionLabelText.color = conditionColor;
        ItemDurabilityValueText.text = $"Durability: {durability}/100";
        ItemDurabilityValueText.color = conditionColor;

        if (item.ZeroUseMode == ZeroUseMode.UntilDurabilityZero)
        {
            ItemUsesText.gameObject.SetActive(false);
        }
        else if (item.RemainingUses > 0)
        {
            ItemUsesText.text = $"Uses: {item.RemainingUses}";
            ItemUsesText.gameObject.SetActive(true);
        }
        else
        {
            switch (item.ZeroUseMode)
            {
                case ZeroUseMode.Unlimited:
                    ItemUsesText.text = "Uses: Unlimited";
                    ItemUsesText.gameObject.SetActive(true);
                    break;
                case ZeroUseMode.Zero:
                    ItemUsesText.text = "Uses: 0";
                    ItemUsesText.gameObject.SetActive(true);
                    break;
                default:
                    ItemUsesText.gameObject.SetActive(false);
                    break;
            }
        }

        if (!string.IsNullOrEmpty(item.Rarity))
        {
            ItemRarityText.text = $"Rarity: {item.Rarity}";
            ItemRarityText.color = GetColorForRarity(item.Rarity);
        }
    }

    private Color GetColorForRarity(string rarity)
    {
        return rarity switch
        {
            "Common" => Color.white,
            "Uncommon" => new Color(0.3f, 1.0f, 0.3f),
            "Rare" => new Color(0.3f, 0.5f, 1.0f),
            "Epic" => new Color(0.6f, 0.2f, 0.8f),
            "Legendary" => new Color(1.0f, 0.84f, 0.0f),
            _ => Color.white
        };
    }
}

Specifically

csharp var liveItem = InventoryStateManager.Instance?.GetLiveItem(item.ItemID); if (liveItem != null) item = liveItem; Tooltips now reflect the latest filled state.

Added debug worms to trace volume, liquid type, and contamination.

✅ InventorySlotUI Confirmed
OnPointerClick() now passes live InventoryItem to ItemTooltipManager.

Slot logic is prefab-safe and ready for live item injection.

✅ LootPanel Updated
Injected InventoryStateManager.RegisterItem() into PopulateLootPanel().

Every item cloned from the registry is now tracked.

Tooltip and inventory transfers now pull live state.

using Game.Inventory;
using System.Collections.Generic;
using TMPro;
using UnityEngine;

public class LootPanel : MonoBehaviour
{
    [Header("UI References")]
    public TMP_Text panelLabel;
    public LootSlot[] lootSlots;

    [Header("Registry Reference")]
    [SerializeField] private ItemRegistry registry;

    private LootContainerProfile currentProfile;

    public void PopulateLootPanel(string label, List<string> lootItemIDs)
    {
        Debug.Log($"🎯 LootPanel '{name}' populating with label: {label}, items: {lootItemIDs?.Count ?? 0}");

        currentProfile = new LootContainerProfile
        {
            label = label,
            lootItemIDs = lootItemIDs
        };

        if (panelLabel != null)
        {
            panelLabel.text = label;
            Debug.Log($"🦓 zebra: Panel label set to '{label}'");
        }

        if (lootSlots == null || lootSlots.Length == 0)
        {
            Debug.LogError($"❌ LootPanel '{name}' has no lootSlots assigned.");
            return;
        }

        Debug.Log($"🦓 zebra: lootSlots.Length = {lootSlots.Length}");

        if (registry == null)
        {
            Debug.LogError("🦓 zebra: ItemRegistry reference is missing in LootPanel.");
            return;
        }

        for (int i = 0; i < lootSlots.Length; i++)
        {
            if (i < lootItemIDs.Count)
            {
                string id = lootItemIDs[i];
                var clone = registry.GetCloneByID(id);

                Debug.Log($"🧪 Slot {i} → ID: {id} | Clone Type: {clone?.GetType().Name ?? "NULL"}");

                if (clone is IInjectableItem injectable)
                {
                    var item = injectable.GetItem();

                    if (item is InventoryItem invItem)
                    {
                        EnsureLootLabels(invItem);

                        // 🔐 Register live item for tooltip and transfer resilience
                        InventoryStateManager.Instance?.RegisterItem(invItem);
                        Debug.Log($"[Worm] 🧬 Registered loot item: {invItem.ItemID} | Volume={invItem.CurrentVolumeML} | LiquidType={invItem.CurrentLiquidType}");
                    }

                    lootSlots[i].gameObject.SetActive(true);
                    lootSlots[i].Bind(injectable);
                    Debug.Log($"🧬 Bound clone: {item.DisplayName} | ID: {item.ItemID}");
                }
                else
                {
                    lootSlots[i].gameObject.SetActive(false);
                    Debug.LogWarning($"❌ Slot {i} → Clone is not IInjectableItem");
                }
            }
            else
            {
                lootSlots[i].gameObject.SetActive(false);
            }
        }
    }

    private void EnsureLootLabels(InventoryItem item)
    {
        if (string.IsNullOrEmpty(item.LootButton1Label))
            item.LootButton1Label = item.Type switch
            {
                ItemType.Food => "Eat",
                ItemType.Liquid => "Drink",
                ItemType.Weapon => "Equip",
                ItemType.Tool => "Use",
                ItemType.Gear => "Equip",
                _ => "Use"
            };

        if (string.IsNullOrEmpty(item.LootButton2Label))
            item.LootButton2Label = "Take";

        if (string.IsNullOrEmpty(item.LootButton3Label))
            item.LootButton3Label = "Take All";

        if (string.IsNullOrEmpty(item.LootButton4Label))
            item.LootButton4Label = "Discard";

        if (string.IsNullOrEmpty(item.LootButton5Label))
            item.LootButton5Label = "Inspect";
    }

    public LootContainerProfile GetContainerProfile()
    {
        return currentProfile;
    }

    public void ClearPanel()
    {
        Debug.Log($"🧹 LootPanel '{name}' clearing all slots.");

        if (lootSlots != null)
        {
            foreach (var slot in lootSlots)
            {
                if (slot != null)
                {
                    slot.ClearSlot();
                    slot.gameObject.SetActive(false);
                }
            }
        }

        if (panelLabel != null)
        {
            panelLabel.text = "";
        }

        currentProfile = null;
    }

    public void SetVisibility(bool isActive)
    {
        gameObject.SetActive(isActive);
    }

    public bool RemoveItemByID(string itemID)
    {
        if (currentProfile == null || currentProfile.lootItemIDs == null)
            return false;

        bool success = currentProfile.lootItemIDs.Remove(itemID);
        if (success)
        {
            PopulateLootPanel(currentProfile.label, currentProfile.lootItemIDs);
        }

        return success;
    }

    public List<InventoryItem> GetAllItems()
    {
        List<InventoryItem> items = new();

        if (lootSlots == null) return items;

        foreach (var slot in lootSlots)
        {
            if (slot == null || !slot.gameObject.activeSelf) continue;

            var bound = slot.GetBoundItem();
            if (bound is InventoryItem invItem)
                items.Add(invItem);
        }

        return items;
    }

    public InventorySlotUI GetSlotByItemID(string itemID)
    {
        if (lootSlots == null) return null;

        foreach (var slot in lootSlots)
        {
            if (slot == null || !slot.gameObject.activeSelf) continue;

            var bound = slot.GetBoundItem();
            if (bound is InventoryItem invItem && invItem.ItemID == itemID)
                return slot.GetComponent<InventorySlotUI>();
        }

        return null;
    }
}

🧠 Save System Breakthrough

✅ Liquid State Persistence Achieved
Live item rebinding unlocked the final gate for save/load logic.

Filled items now retain volume, contamination, temperature, and type across scene transitions.

✅ Prefab-Free Restoration Chain
On load, restored items are re-registered into InventoryStateManager.

Tooltips, slots, and use panels reflect true state post-load.

✅ Contamination Tag Standardized
"Clean" added as a valid contamination tag.

Tooltip display simplified

🔗 System Interoperability Confirmed

All major systems now pull from InventoryStateManager:

Crafting

Pouring

Emptying

Attaching

Consuming

Contamination logic

No prefab ghosts. No tooltip lies. All systems speak the same runtime truth.

✅ Tooltip Mutation Chain Sealed
ItemTooltipManager re-registers mutated items after actions like eat, drink, attach, fill.

Tooltips reflect post-mutation state instantly.

✅ InventoryClickCatcher Added
Invisible button added to inventory panel.

Triggers HideTooltip() when empty space is clicked—keeping UI clean and shrine-pure.

🧪 Shrine-Safe Methods in Use
🔐 InventoryStateManager
RegisterItem()

GetLiveItem()

ClearAll()

🧬 ItemTooltipManager
ShowTooltip()

RebindTooltip()

RefreshTooltip()

HideTooltip()

UpdateUses()

InjectInventoryButtons()

🧱 InventorySlotUI
OnPointerClick() → passes live item

AssignItemData() → prefab-safe

🧭 LootPanel
PopulateLootPanel() → registers all loot items

Take() logic pending patch

🧰 UsePanelManager
OpenPanel() → receives live item

Mutations now re-register item

🧪 CraftingManager, AttachmentManager, PourManager
All now interoperable with live item registry

📌 Current Task
Patch loot transfer logic (LootSlot.cs, LootButtonManager)

Inject RegisterItem() after loot-to-inventory transfer

Confirm tooltip and slot receive live item

Begin runtime save system planning for scene transitions

🧠 Next Steps

Next Button Functions to be approached using the same or very similar systems

Build save loader that re-registers restored items

Begin mapping shrine zones for gameplay integration

Celebrate the resurrection of the survival engine

Over & Out

Dev Log 33 - Liquid Entry & Landing Page

John — Sat, 18 Oct 2025 15:11:56 +0000

🧾 Dev Log: Wednesday, 15 October 2025
Focus: LiquidEntry automation, relic registration, environmental asset integration

🧪 Initial Context - Struggling to get my liquids systems working -
Shared to Co-Pilot my LiquidEntry class from LiquidDefinitions, which defines shrine-grade metadata for collectible liquids. It includes hydration, contamination, tooltip labels, and a GetItem() method to convert into a usable InventoryItem.

Asked why I still needed to “create more shit” when everything was already in all of my scripts.

🔍 Clarification & Breakdown

It was clarified that:

The LiquidEntry system is complete and shrine-grade.

The only missing link was registration: connecting environmental assets to LiquidContainerManager via GameSceneManager.liquidSourceEntries.

🔧 Idiot-Proof Summary

Create a LiquidEntry for each environmental source.

Add it to GameSceneManager.liquidSourceEntries.

Match the sourceID on the prefab to the liquidID.

🛠️ Automation Request

“Can’t we make a script that just pulls that information from the targeted assets and makes them all for me?”

We built a Unity Editor script that:

Scans all EnvironmentalObjectAssets

Checks for IsWaterSource or IsLiquidSource

Extracts relevant fields

Generates LiquidEntrys

Injects them into GameSceneManager

🧪 First Generator Script

I ran the script. It injected 12 entries — only water sources and not all liquid type sources.

🐛 Debugging Errors

Three compile errors:

LiquidType mismatch — fixed with explicit cast.

FoodDiseaseProfile missing isContaminated — removed and simplified for liquid contamination variant.

ItemRarity missing — defaulted or removed. (unrequired for liquid source)

Patched the script accordingly.

🧪 Second Generator Run

Ran the patched script. It injected 12 entries again.

🔍 Root Cause Identified

Discovery:

Assets like coolant and petrol (fuel) had LiquidType = None in the Inspector.

The generator skipped them due to this filter.

You updated the Inspector to assign proper LiquidType values.

🧪 Third Generator Run

Reran the script. It injected 30 entries.

They did not save in runtime.

🧪 Final Patch

A full overwrite of the generator script to include all liquid sources.

Co-pilot delivered a clean version that:

Includes any asset with a valid LiquidType

Removes unnecessary filters

Injects coolant, petrol, oil, and water sources

Confirmed success.

✅ Final State

30 LiquidEntrys injected

All environmental liquids registered

Generator script fully patched

Scene ready for hydration, purification, and tooltip rituals

=== DEV LOG — 15 OCT 2025 ===

[INIT] Liquid Override Ritual Begins

Created LiquidSourceRegistry.cs with hardcoded "Ocean" source for node_0004(current test node)
Injected override logic into StoryNodeLoader.cs: → node.liquidSources = LiquidSourceRegistry.GetForNode(node.id)

[DEBUG] ASCII Banner + Easter Egg

Added UnityBollocksEasterEgg.cs with ASCII tribute: → "Screw U-nity — we fill the shrine ourselves"
Mythic hierarchy declared: → Paper > Rock > Scissors > Liquid > Unity > Bollocks

Unity was doing the usual, gaslighting me, for days this time, this was a salute to unity.

[REFACTOR] Registry Purification

Removed liquidSources from node_0004.json
Inserted "hasLiquid": true beneath timeAdvanceMinutes
Preserved all original node data

[CODE] StoryNode.cs Update

Removed: public List liquidSources
Added: public bool hasLiquid = false;

[ERROR] 74 Compilation Errors

Caused by lingering references to node.liquidSources
Triggered full rewrite of StoryNodeLoader.cs

[PATCH] StoryNodeLoader.cs Rewritten (3 Parts)

Removed all node.liquidSources references
Introduced local List liquidSources
Injected from registry if node.hasLiquid == true
Called panel.RefreshFromStoryNode() instead of nonexistent method

[UI] LiquidDetailsSubpanelUI Refactored

Rewrote RefreshFromStoryNode() to: → Check node.hasLiquid → Pull from LiquidSourceRegistry → Display first source (e.g., "Ocean")
Removed dependency on node.liquidSources

[FIX] Method Call Error

Incorrect: panel.RefreshFromLiquidSource(source)
Fixed: panel.RefreshFromStoryNode()

[CONFIRM] Shrine State Verified

Registry override working
UI panel displays "Ocean"
No errors in StoryNodeLoader.cs
All systems flowing

=== END LOG ===

🛠️ Dev Log: Survival Engine Resurrection
Date: 17 October 2025 Status: ✅ Runtime Success

🔧 Context
After days of battling prefab chaos and schema drift, the survival engine was declared a “disastrous mess.”

Tooltip logic was fragmented, inventory systems had become brittle, and runtime truth felt like a myth.

🧪 Action

Injected inventory button labels across all item types: fruit, fish, egg, gear, liquid, misc, seed, vegetable, cooking, melee weapon, ranged weapon, attachment, generic.

Ensured prefab-safe, schema-driven tooltip activation across the entire survival engine.

Blocked internal history logging via shell script using icacls, preserving runtime purity.

Rebuilt modular condition resolver with category-specific durability logic, preserving all existing mappings and extending shrine logic.

⚡ Breakthrough
“Holy shit it worked.”

Runtime test passed. Tooltip systems activated. Inventory logic held. No prefab leaks. No phantom states.

🧠 Reflection

Didn’t believe it would work. But shrine persistence paid off. Every ritual, every debug pass, every mythic call back led to this moment.

🏆 Outcome
Survival engine now stable.

Tooltip logic is prefab-safe and schema-driven.

Inventory UI is fully activated across item types.

Runtime truth restored.

🌐 Web Shrine Creation (17–18 Oct) Dev Log Update -

Built and deployed my first-ever landing page using HTML, CSS, and JavaScript:

Created TextZ Ombie: a shrine-themed Halloween page for the Dev.to challenge

Designed hero section with emoji-framed zombie horde

Added animated zombie descent triggered by button

Integrated music player with mirrored waveform visualizers

Built bat and spider swarm animations

Added zombie chase ritual with dynamic emoji trail

Created asset gallery with hover effects

Mythified footer with summon/dig/crypt links

Unified fonts using Griffy and Creepster

Overrode Bootstrap styles for shrine-pure consistency

Deployed to GitHub Pages and verified live demo

Submitted first entry to the challenge

✅ Shrine sealed ✅ Submission published ✅ Legacy unlocked

🧠 Reflection

This was my first time using HTML, CSS, and GitHub Pages. I mythified every fix, debugged every phantom reference, and ritualized every animation. With help from Copilot, I turned raw chaos into a living shrine.

Every system now flows. Every relic is animated. Every ritual is logged.

Now back to the game project. See what unity gaslights me with this time.

Frontend Challenge - Halloween Edition, Perfect Landing - TextZ Ombie

John — Sat, 18 Oct 2025 14:46:36 +0000

This is a submission for Frontend Challenge - Halloween Edition, Perfect Landing

What I Built

I built TextZ Ombie, with the help of AI. (Rules-Permitted).
A shrine-themed Halloween landing page that animates the undead in savage style. It themes nicely with my current first ever project, so thought I would try to participate, despite never participating before or even ever using CSS or HTML Code before.

It features:

🧟‍♂️ A hero section with emoji-framed zombie horde

🧟‍♂️ Drop down animated zombie horde

🎵 A music player for “Plague of Zombies V1” with mirrored pop up waveform visualizers

🦇🕷️ Bat and spider swarms that animate across the screen

🏃 A zombie chase animation with dynamic emoji descent

☠️ 4 Asset / Art Examples from my project

☠️ Footer links to summon, dig, and crypt-crawl through the project

The theme is inspired by the Halloween subject and my own 2D text-based hardcore survival game project, now mythified into a living shrine with animated effects, emoji rituals, and legacy-grade layout with project links, GitHub link and my personal Dev.to developer dev log links.
So despite the lack of polish, it fits into my project theme very well with the retro styling and simplicity.

Live Demo

Live demo: TextZ Ombie Shrine

Journey

This was my first time building a full landing page from scratch. I started with basic HTML and CSS, then ritualized each section with:

Dynamic emoji animations

JavaScript-powered audio playback and waveform bars

Responsive layout and custom fonts

GitHub Pages deployment and asset hosting

I learned how I can use my GitHub as a hosting platform for a website, how to code it with the correct code, solve and debug layout issues, unify fonts across Bootstrap overrides, and mirror canvas animations using ctx.scale(-1, 1). Every fix felt like a resurrection ritual.

I’m proud of how the shrine evolved from static relics to animated, living effects. Next, I plan to summon a Steam portal integration once I have a demo version of my game ready and possibly add further depth and polish in the future.

All of this was possible with the help from Co-pilot, My AI of Choice, who helped me with this entire process, despite my lack of knowledge.

Submitted by: John (ASXGTR)

LICENSE

MIT License

⚠️ Game Content Protection Clause

All game-related content—including mechanics, story, characters, assets, audio and source code from the survival engine - is strictly proprietary and not covered under this license.

Redistribution, modification, or use of game content without explicit permission is prohibited.

Violators risk unleashing ancient curses, recursive bugs, and plague-grade runtime errors.

🧙‍♂️ Enter the Crypt - GitHub

Dev Log 32 - Relic 001 - Plague of Rot

John — Tue, 14 Oct 2025 12:16:54 +0000

🧾 Spectral Relic Log: RELIC-001 — Plague of Rot
🔮 Ritual Initiated
Date: Tuesday, 14 October 2025

Got side-tracked using Co Pilot and talking about gibber link.
this is what it lead to...

🧠 Objective
Create a covert ultrasonic messaging system that embeds a machine-readable message into audio, invisible to human ears but decodable by AI or forensic tools.

🛠️ Tools Used
Python 3.10

NumPy (installed via pip install numpy)

Audacity (for spectral inspection)

Git Bash (ritual terminal)

Custom Encoder & Decoder Scripts:

gibberlink_encoder.py

gibberlink_decoder.py

🧪 Ritual Steps

Encoder Script Created Message: "RELIC-001: Plague of Rot"

Modulation: Binary encoding using 18.5 kHz carrier

Output: gibberlink_relic.wav

Script Executed
bash
winpty python gibberlink_encoder.py
Result: Successfully generated .wav file with ultrasonic pulses
Spectrogram Inspection
Audacity settings:

Min freq: 0 Hz

Max freq: 22050 Hz

Gain: 30 dB

Range: 100 dB

Window size: 4096

Observed: Horizontal carrier at 18.5 kHz, vertical pulses forming binary pattern

Decoder Script Created Scanned .wav file for 18.5 kHz pulses

Reconstructed binary stream

Converted to ASCII text

Decoder Executed bash winpty python gibberlink_decoder.py Output:

plaintext
Decoded message: RELIC-001: Plague of Rot
🧬 Outcome
Successfully encoded and decoded a covert ultrasonic message

Created a reusable forensic ritual pipeline

Proved resilience and machine readability of spectral relics

Achieved full encode–embed–decode cycle

🏆 Boast Points Earned
🔓 First successful Python ritual execution

🧠 Built a covert messaging system from scratch

🧬 Embedded machine-readable data into audio

🕵️‍♂️ Created a spy-grade relic with forensic integrity

🎵 Ready to embed relics into music, games, or spectral archives

That was a fun project that took around 20 minutes. Distracted and Side-tracked , might come in use for some fun Easter eggs during development.

Still working on my use labels and functions/logic effects for my inventory items inside of my panels in my game , progress is slow (especially when distracted), but making progress, which is important.

Game Dev Continues...

Dev Log 31 - Attachment Panel

John — Sat, 11 Oct 2025 16:05:46 +0000

🧾 Dev Log — October 11, 2025
Prefab Purged, Static Shrine Rises, Blackout Descends
Subtitle: Fusion Ritual Complete — Registry Bound, Resolver Awakened

🔮 Summary
The prefab-based attachment panel has been officially retired. I was working on this for a couple of days but I have changed direction away from the prefab set up.

In its place stands a static, Inspector-wired shrine panel this is now a permanent structure built for clarity, control, and mythic permanence. Slot references are now explicitly declared, eliminating prefab instantiation bugs and runtime ghosts.

A blackout overlay was added to enforce visual dominance. Loot panels now bow before the attachment ritual, hidden when summoned, restored only if deemed worthy. Panel hierarchy is enforced via transform.SetAsLastSibling() — the shrine always floats to the top.

The Close button was summoned and bound, finally offering a way out of the ritual without sacrificing a candidate.

A title text field was added to crown the panel with “Attachment Menu” bringing clarity to the ritual’s purpose.

And now, the fusion ritual is complete.

A centralized ItemAttachmentResolver script handles all fusion logic, querying the ItemRegistry for shrine-tier relics. Fused items are injected into the inventory, originals removed, and debug logs mythified.

✅ Tasks Completed

Replaced prefab-based panel with static Inspector-wired UniversalAttachmentPanel

Added blackout image overlay to visually suppress loot panels beneath

Implemented loot panel visibility tracking and restoration logic

Ensured attachment panel always renders on top via sibling sort

Added Close button with direct HidePanel() binding

Added title text field for panel header

Refactored ShowAttachmentOptions() and HidePanel() for shrine clarity

Confirmed full blackout logic and slot visibility control working in tandem

Created ItemAttachmentResolver.cs to handle fusion logic

Defined fusionMap with valid item pairings and resulting relic IDs

Integrated ItemRegistry for asset lookup and clone injection

Updated UniversalAttachmentPanel.cs to call resolver and inject fused item

Wired slot buttons to open correct popup panels (ConfirmPopupPanel vs CancelOnlyPopupPanel)

Renamed confirmButton to selectButton for clarity in UniversalAttachmentSlotUI.cs

Added SlotType enum to distinguish target vs candidate slots

Verified fusion works for:

attachable_gas_hob + personal_gas_canister_large → personal_gas_hob_attached_large

attachable_gas_hob + personal_gas_canister_regular → personal_gas_hob_attached_regular

🧪 Methods Used
Fusion Mapping: Defined valid fusion pairs in fusion map using (string, string) → string tuples

Registry Lookup: Used ItemRegistry.Instance.GetByID(...) to fetch fused assets

Interface Injection: Required all assets to implement IInjectableItem for GetItem() access

Panel Integration: Called ItemAttachmentResolver.TryResolveFusion(...) from ConfirmFusion() in the panel

Inventory Mutation: Injected fused item via PlayerInventoryManager.Instance.AddItemToFirstFreeSlot(...) Removed source items via RemoveItem(...)

Slot Wiring: Used Load(item, callback) to bind overlay buttons to popup triggers Slot 0 → opens CancelOnlyPopupPanel Slots 1–5 → open ConfirmPopupPanel

Debug Rituals: Added [Shrine] 🧬, [Shrine] ❌, and [Shrine] 🔗 logs for tracing fusion flow

📝 Notes
Loot panel visibility now fully automated — no UnityEvents, no manual toggling

Attachment panel now feels like a true shrine: static, layered, and self-aware

Fusion logic centralized, decoupled, and mythically expandable

Registry now acts as a relic vault — every asset preserved, every fusion traced

Continuing to adjust each item individually so there is a nice crisp tooltip for both loot and inventory panels, each item having their own manually injected button labels and function for each panel separately, so all logic lines up with no mistakes. Attachment , Take , Equip and Eat Buttons now all working flawlessly.

Next to adjust the discard, combine, drink and fill functions - and further cook/ clean / and camping/base systems. work on the cooking system, and the recipe system, will create a similar system to how the attachment system is working to create or combine items, Should be easier now with a solid blueprint reference in the attachment system.

“The shrine no longer flickers. The blackout holds. The slots await fusion. The ritual nears completion. The registry speaks. The resolver listens. The altar accepts its offering.”

Dev Log 30 - Discord Invite

John — Mon, 06 Oct 2025 11:35:06 +0000

🛠️ Dev Log – Discord Server | 6 Oct 2025
Server: ASXGTR Server Status: 🚀 Live and Operational

🔧 What’s New - everything

Server Online – Modular channels now active for development, feedback, and schema echo archiving.

Channel Overview:

about – Dev origin story and schema roots

dev-log – Technical updates and legacy milestones

dev-log-thread – Threaded rituals for deeper breakdowns

dev-snapshots-assets – Visual assets, sprites, and prefab echoes

dev-snapshots-gameplay – Mechanics, UI rituals, and gameplay logic

dev-video-screencapture – OBS captures, debug walkthroughs, and visual logs

bugs – Runtime errors and prefab disobedience

feedback – Tactical input from collaborators

game-snapshots-open – Public-facing gameplay echoes

general – Off-topic schema banter

ideas – Concept rituals and mechanic pitches

links – External assets, tools, and legacy references

welcome – Entry point for new members and schema initiates

🧠 Why This Exists
To archive the grind, not glamorize it

To keep access to all of my dev logs in one place

To mythify the grind, have a feedback point

To connect with devs who treat survival mechanics like sacred schema

To echo the emotional toll and tactical triumphs of solo development

This is my first discord server, if you want to lurk, say hi or have a look into how my progress is going visually or even provide criticism or feedback - feel free to join up in the link below.

Invite link here Discord Invite Link