Hey again, thanks for reading!

This week I've been focusing on two major systems: the turn-based combat system and the crafting UI. On top of that, I started building out level transitions and a LevelManager to handle procedural flow between levels and prebuilt areas. There’s a lot to cover, so here’s the breakdown.

Rebuilding the Combat System for Procedural Worlds

I’ve been following a turn-based combat tutorial for the core system, but the tutorial assumed something very different from how my game actually works. In the tutorial setup, combat always starts in a dedicated scene, where both the player and enemies are already placed in the scene hierarchy. All the UI, healthbars, and actions were prelinked manually. However, this approach doesn't work for this game. Since the levels where enemies appear are mostly procedural, enemies need to spawn dynamically and combat needs to trigger directly from the overworld without loading a new scene.

That meant ripping out all the assumptions about preloaded combat data and replacing them with a dynamic data loading system.

Triggering Combat in a Procedural World

In my case, combat starts when the player physically touches an enemy in the overworld. To handle this, I made a CombatTrigger script that constantly checks for enemies in range using the same method I used for item collection. If the player gets too close to the enemy, the combat system activates immediately.  

This already caused a bunch of headaches because the tutorial’s combat scene expected preloaded references to everything (player, enemies, healthbars). With dynamic entry, none of those existed yet — so I had to write code that:

• Finds the player and enemy that triggered the fight.
• Assigns each other as their combat opponent.
• Grabs their health, stats, and actions from ScriptableObjects, instead of assuming those are already set.
• Registers both characters into the turn manager at runtime, rather than having them baked into the scene.

This whole system needed several rewrites because early versions grabbed the wrong enemy, or forgot to load actions, or just straight-up crashed because references were missing. It’s stable now, but fragile if I change anything major, so this will need further cleanup.

UI-Based Enemies (Not GameObjects)

Another shift: the tutorial treated enemies as physical objects in the scene, so they could walk forward and attack the player. In my system, enemies in combat are just UI images, since the battle screen is essentially a UI overlay on top of the paused world.

That broke all the movement animations from the tutorial, which assumed actual transform movement. I’ll need to rebuild those animations using UI rect transforms, so the enemy "steps forward" to attack without ever being a real GameObject in the scene. For now, they just attack instantly, which works mechanically but looks bad.

Rewiring Healthbars & Events

The tutorial’s healthbars were also pre-placed in the scene, linked directly to characters in the editor. In my case, the UI only exists after combat starts, so the healthbars need to dynamically subscribe to health change events every time combat begins. I added that, but it’s still rough — the very first healthbar update sometimes lags, so health starts at zero for a split second before correcting itself. Not game-breaking, but annoying, so it’s on my polish list.

Debugging Spiral: What Broke & What Works Now

Most of this process was debugging hell — every time I fixed one part, something else collapsed. Some highlights:

• Enemies spawned with zero health at first, dying instantly.
• The turn manager would forget enemies existed after the player’s turn, locking the whole system.
• The combat UI tried to update player data before the player was even assigned.

Current State

• Combat triggers correctly from overworld contact.
• Player and enemy load stats and actions dynamically from ScriptableObjects.
• Healthbars (mostly) work again.
• Player actions (like attacking) correctly damage the enemy.

However:

• Enemy turn flow is still slightly unreliable — sometimes they skip their turn for no reason, which I’m still tracking.
• Enemy attack animations don’t exist yet (since they need to be converted to UI animations).

Crafting Window Setup (UI Works, Table Not Yet Hooked In)

On the crafting side, I finished building out the Crafting Window UI. It displays:

• A list of craftable recipes.
• Each recipe’s icon, name, and resource cost.
• A color-coded background (craftable = normal color, missing resources = grayed out).

This all works — clicking a recipe removes the right materials from inventory and adds the crafted item. The whole thing is driven by CraftingRecipe ScriptableObjects, so adding new recipes is easy.

The one thing I haven’t done yet is placing the actual crafting table in the world. Right now, the only way to open the crafting window is to manually enable it in the editor. I wrote the table’s interaction script, so once the table exists in the scene, the player will be able to walk up, press E, and open the crafting UI properly.

Level Transitions & Early Level Manager

The last major thing this week was level transitions. Since the world is procedural, I needed a system to track progress across levels and decide when to load a prebuilt area instead of another procedural map.

I made a basic LevelManager that tracks how many procedural levels the player has cleared. Right now, it’s hardcoded to load a specific prebuilt area after every 5 procedural levels. This works as a placeholder, but once the game gets more content, I’ll need to replace this with something more flexible (like a progression table that can handle branching paths or optional areas).

For now, though, it’s good enough to link procedural generation to fixed story beats, which was the main goal.

Progress Summary

What Works So Far

• Procedural overworld triggers combat correctly.
• Combat loads player & enemy data at runtime.
• Crafting window displays all recipes correctly.
• Recipes consume materials and give crafted items.
• Level transitions work between procedural & prebuilt scenes.
• Basic LevelManager tracks procedural level count correctly.

What Still Needs Work

• Place the actual crafting table and hook up the interaction.
• Rebuild enemy attack animations using UI movement instead of transforms.
• Fix enemy turn skipping bug.
• Improve healthbar updates at the start of combat (remove initial flicker).
• Expand the LevelManager to support multiple prebuilt areas and branching paths.

That’s it for this update! Combat is finally playable (kind of), crafting works once triggered, and the procedural loop has its first real structure. There’s a lot to clean up, but the core systems are all in place, and that feels like actual progress.

Thanks for reading, and I’ll be back next time with (hopefully) a working crafting table and some more polish on this chaotic combat system.