DEV Community: DomTech Gaming

Building Unlockable Ability UI + HUD Integration in UE5 (Dev Log #10)

DomTech Gaming — Mon, 27 Apr 2026 18:57:58 +0000

Development continues on the core gameplay and progression systems for Magickness™.

This dev log focuses on integrating the first unlockable combat ability into the gameplay UI, HUD hotbar, and input mapping framework.

In this update

Added unlockable ability support to the Ability Menu UI
Integrated the first ability icon into the HUD hotbar
Continued gameplay input/key mapping workflow
Expanded UI-to-gameplay interaction systems
Used Claude AI to assist with implementation and iteration

The long-term goal is to build a scalable progression and ability framework centered around discovery and experimentation rather than rigid class restrictions.

This is still part of the foundation phase — connecting isolated systems into a cohesive gameplay structure that can scale long term.

Magickness™ is a discovery-driven MMORPG currently in development using Unreal Engine 5.4.

The project is being developed for an adult (18+) audience to maintain a more mature, focused community environment during development and beyond.

Follow Development

Website:
https://magickness.com/

YouTube:
https://youtu.be/zeqAcAZpWM0

Ko-fi:
https://ko-fi.com/domtechgaming

From Systems to Gameplay: Implementing the First Ability in UE5 (Animation Blending)

DomTech Gaming — Wed, 22 Apr 2026 17:40:48 +0000

Dev Log #9 — First Ability System (Magickness™)

This is a turning point in development.

Up to now, most work has been focused on systems:

stats
UI
combat structure
player flow

Dev Log #9 is where those systems start becoming actual gameplay.

What Changed

The first unlockable combat ability has been implemented and integrated into the animation system.

Key Work:

Ability activation logic
Animation blending with locomotion
Combat system integration
Early gameplay testing

The Challenge: Blending with Locomotion

Abilities can’t feel disconnected.

They need to:

transition cleanly from movement
maintain responsiveness
avoid breaking flow

This required careful blending inside UE5’s animation system to ensure:

no snapping
no input lag feeling
consistent player control

Design Direction

Abilities in Magickness™ are not fixed loadouts.

They are designed to be:

discovered through gameplay
combined into new mechanics
evolved over time

This first ability is the foundation for that system.

Why This Matters

This is the shift from:

“building systems”

to:

“creating gameplay”

Everything from here becomes more visible, testable, and improvable.

Dev Log Video

https://youtu.be/3zpdf9sd0-I

Project Links

https://magickness.com/

https://ko-fi.com/domtechgaming

Magickness™ is being developed for an adult (18+) audience to maintain a focused, mature community environment during development and beyond.

Designing a Scalable Character Stats & Abilities System for an MMORPG (UE5)

DomTech Gaming — Sun, 19 Apr 2026 20:35:36 +0000

Dev Log #8 — Character Stats & Abilities System (Magickness™)

Development is moving deeper into core RPG systems for Magickness™.

This dev log focuses on building the foundation for:

Character stats
Ability systems
Progression structure

Why This Layer Matters

This is one of the most critical systems in an RPG.

It defines:

how players grow
how combat behaves
how choices impact gameplay

If this layer is weak, everything built on top of it feels shallow.

What’s Being Built

Character Stats System

Structuring player attributes with scalability in mind.

Not just flat stats, but systems that can:

interact with abilities
influence gameplay outcomes
evolve over time

Abilities Framework

Beginning the structure for abilities that will eventually support:

discovery mechanics
combination systems
progression-based evolution

Design Goal

Avoid rigid, predefined builds.

Instead:

allow systems to interact
allow players to experiment
allow progression to emerge

Long-Term Integration

These systems will connect directly into:

combat systems
inventory/equipment
magic discovery mechanics

Dev Log Video

https://youtu.be/6RYDO6qPI2E

Project Links

https://magickness.com/

https://ko-fi.com/domtechgaming

Magickness™ is being developed for an adult (18+) audience to maintain a focused, mature community environment during development and beyond.

Designing an Inventory UI System in UE5 + Using AI to Accelerate UI Development

DomTech Gaming — Fri, 17 Apr 2026 20:27:50 +0000

Dev Log #7 — Inventory UI Foundation + AI Workflow (Magickness™)

We’re continuing the foundation phase of development for Magickness™, shifting focus into UI systems and development workflow improvements.

What This Dev Log Covers

Inventory UI foundation
Character stats menu structure
AI-assisted UI workflow using Claude

Inventory System Foundation

The goal here is not to build a quick UI, but to establish a structure that can scale with:

Equipment systems
Item interaction
Progression mechanics

The inventory UI needs to support future complexity without requiring a full rebuild later.

Character Stats Menu

At the same time, work has started on the character stats interface.

This will eventually act as the central point for:

Player progression tracking
Attribute systems
System interaction visibility

AI-Assisted Workflow

This dev log also explores integrating AI (Claude) into the development workflow.

The goal is not automation, but acceleration:

Faster iteration
Cleaner UI structuring
Reduced friction when building systems

The challenge is maintaining control while improving speed.

Why This Matters

UI is not just presentation — it’s how players understand systems.

If the UI is weak:

systems feel unclear
progression feels shallow
interaction becomes confusing

This phase ensures the foundation is strong before expanding features.

Dev Log Video

https://youtu.be/bibsoGISW9k

Project Links

https://magickness.com/

https://ko-fi.com/domtechgaming

Magickness™ is being developed for an adult (18+) audience to maintain a focused, mature community environment during development and beyond.

From Broken Onboarding to a Playable Loop — Fixing Player Flow, Combat, and HUD in UE5

DomTech Gaming — Mon, 13 Apr 2026 22:01:50 +0000

Dev Log #6 — Stabilizing Player Flow + Core Gameplay Integration (Magickness™)

We’re currently in the foundation phase of development for Magickness™, focusing on stabilizing systems and bringing them together into a working gameplay loop.

This update marks a key milestone.

What This Dev Log Covers

In this build, we moved from isolated systems into a connected player experience:

Account creation
Email verification (bug fixed)
Character creation

With the onboarding flow working end-to-end, we were able to test gameplay systems inside a real player context.

The Problem

Previously, systems worked in isolation:

Character preview UI was functional
Locomotion pipeline was stable
Combat systems existed independently

But once connected, issues appeared:

Email verification blocking progression
UI state inconsistencies
Character initialization edge cases
Locomotion and combat blending conflicts

This is where most systems actually break — at integration.

What Was Fixed

This dev log focuses on stabilizing those connections:

Fixed the email verification bug blocking onboarding
Completed full player flow from account → character
Integrated locomotion and basic combat systems
Resolved locomotion/combat blending issues
HUD wiring now functional (stamina drain + regeneration)

First Playable Loop

This is the first point where:

A player can enter the system
Create a character
Move and interact
Engage with core gameplay mechanics

That transition — from systems to loop — is one of the most important steps in development.

Why This Matters

Systems working individually is not enough.

They need to:

communicate cleanly
maintain consistent state
behave predictably under real usage

This phase is about removing friction between systems so the game can scale without breaking.

Design Direction

Magickness™ is being built as a discovery-driven MMORPG, where progression comes from interaction between systems rather than predefined paths.

That only works if:

systems are stable
interactions are reliable
edge cases are controlled

This stage defines the long-term integrity of the game.

Tech Stack (Current)

Unreal Engine 5.4
Mixamo (animation base)
MakeHuman (character mesh base)
Custom UI + gameplay systems

Dev Log Video

https://youtu.be/gyy1uA2CXyA

Project Links

Website:

https://magickness.com/

Support development:

https://ko-fi.com/domtechgaming

Magickness™ is being developed for an adult (18+) audience to maintain a focused, mature community environment during development and beyond.

Further updates will continue as systems stabilize and iteration speed increases.

Building a Full Player Onboarding Flow in UE5 (Account Email Character Creation)

DomTech Gaming — Thu, 09 Apr 2026 20:30:19 +0000

Dev Log #5 — Full New Player Flow (Magickness™)

We’re currently in the foundation phase of development for Magickness™, focusing on connecting core systems into a working player experience.

This dev log covers a full dry run of the new player onboarding flow:

Account registration
Email verification
Character creation
UI → system transitions

Why This Step Matters

Up to this point, development has focused on stabilizing individual systems:

Character preview and UI rendering
Mesh alignment using Mixamo + MakeHuman
Animation and locomotion pipelines

This is the first pass where those systems are connected together into a real user flow.

And that’s where problems start showing up.

What Broke (and Why)

Running the full flow exposed issues that weren’t visible in isolation:

Authentication → character system data handoff issues
UI state inconsistencies between steps
Character initialization edge cases
Preview system vs finalized character mismatch

This is expected.

Systems can work perfectly on their own and still fail when combined.

Core Focus

Right now the priority is:

Clean data flow between systems
Stable UI state transitions
Reliable character initialization
Predictable behavior from first interaction

The onboarding flow is the first real test of whether the foundation is solid.

Design Philosophy

Magickness™ is being built around discovery-driven systems.

That only works if:

systems are consistent
behavior is predictable
interactions don’t break under real usage

This phase is slower, but it determines the long-term depth of the game.

Tech Stack (Current)

Unreal Engine 5.4
Mixamo (animation base)
MakeHuman (character mesh base)
Custom UI + character pipeline

Dev Log Video

https://youtu.be/xf0v43geCjU

Project Links

Website:

https://magickness.com/

Support development:

https://ko-fi.com/domtechgaming

More detailed breakdowns will follow as systems continue to stabilize and evolve.

Debugging Character Systems in UE5.4 + Integrating AI Into My Dev Workflow

DomTech Gaming — Sun, 05 Apr 2026 18:46:39 +0000

I’m currently deep in the foundation phase of building Magickness™ — a system-driven MMORPG — where the focus is on stabilizing core systems before expanding gameplay.

This dev log continues work on the character preview system, but shifts more into debugging the codebase and refining the development workflow itself.

Continuing the Character Preview Fix

The preview system is still being refined, specifically around:

Resetting character state cleanly between changes
Fixing inconsistencies between UI preview and in-world representation
Ensuring mesh + animation updates propagate correctly

At this stage, the issue isn’t just visual — it’s systemic.

If state isn’t handled correctly, bugs compound quickly across UI, animation, and gameplay layers.

Codebase Review & System Clarity

Instead of continuing to patch issues, I stepped back and started reviewing the structure of the system:

Where state is stored and updated
How UI interacts with character data
How animation and mesh updates are triggered

This is where a lot of hidden problems show up.

When systems are being built quickly, logic can become fragmented:

duplicated updates
unclear data flow
implicit dependencies

Cleaning this up early prevents major refactors later.

Using AI as a Development Tool

I’ve been integrating AI (Claude) into my workflow during this phase.

Not for writing game logic directly — but for:

Reviewing system structure
Breaking down complex debugging paths
Identifying where logic may be inconsistent or redundant

It’s essentially acting as a second-pass analysis layer.

The key is treating it as a tool — not a source of truth.

Workflow Shift

This dev log marks a subtle shift in approach:

From:

Fixing visible issues

To:

Understanding and stabilizing underlying systems

That includes:

Tracing data flow through the character system
Ensuring predictable behavior across UI and runtime
Reducing hidden dependencies

Why This Phase Matters

Foundation work like this is slow, but it defines everything that comes after.

If systems aren’t:

predictable
consistent
scalable

…then adding features just creates more problems.

Project Context

Magickness™ is being built around:

discovery-driven mechanics
system-based progression
player experimentation

That only works if the underlying systems are solid.

Dev Log

Full breakdown here:
https://youtu.be/hbOMcn82Nas

Website

https://magickness.com/

If you’re working in UE5 and have dealt with character systems or UI-driven previews, I’d be interested in how you’re structuring state and updates across systems.

Rebuilding Character Preview Systems in UE5.4 (Mixamo + MakeHuman Pipeline)

DomTech Gaming — Sun, 05 Apr 2026 18:35:03 +0000

I’m currently rebuilding core systems for an in-development MMORPG (Magickness™), focusing on long-term scalability rather than short-term implementations.

This phase has been centered around fixing and restructuring the character preview system — specifically how UI, meshes, and animation data interact inside Unreal Engine 5.4.

The Problem

The character preview system wasn’t behaving consistently:

Mesh alignment issues between MakeHuman base and Mixamo skeleton
Character preview rendering incorrectly in UI
Scale inconsistencies across imported assets
Animation mismatch due to skeleton differences

This created a chain reaction where UI preview, animation playback, and mesh proportions all conflicted.

What I’m Fixing

1. Mesh + Skeleton Alignment

Using a Mixamo-based skeleton with MakeHuman meshes required:

Rescaling mesh assets to match skeleton proportions
Verifying bone hierarchy compatibility
Ensuring consistent import settings across all assets

Small inconsistencies here break everything downstream.

2. Character Preview UI Issues

The preview system itself needed adjustment:

Camera positioning inside the UI
Mesh anchoring and offsets
Consistent scaling so characters render correctly across all customization states

This is one of those systems where visual bugs often come from underlying data inconsistencies.

3. Animation Pipeline Stability

Animations imported from Mixamo required cleanup:

Verifying retargeting settings
Adjusting animation playback within UE5
Ensuring animations match updated mesh proportions

This is especially important early — animation pipelines become painful to fix later if the foundation is wrong.

AI-Assisted Workflow

I’ve also been integrating AI (Claude) into the workflow — not as a game feature, but as a development tool:

Reviewing system logic
Identifying inconsistencies in setup
Accelerating iteration when debugging pipelines

Used correctly, it acts more like a second set of eyes than a replacement for engineering.

Why This Matters

This is part of a broader foundation phase.

Instead of building forward on unstable systems, I’m:

Fixing pipelines early
Standardizing asset behavior
Building systems that can scale as the project grows

It’s slower upfront, but prevents exponential problems later.

Project Context

Magickness™ is a discovery-driven MMORPG built around:

System-based progression (not predefined classes)
Player experimentation and mechanic combinations
Emergent gameplay systems

This stage is focused entirely on making sure those systems can actually support that vision.

Dev Log

If you want to see the actual implementation and issues in real time:

https://youtu.be/hbOMcn82Nas

Site

https://magickness.com/

If you’re working with UE5 + Mixamo + custom meshes, I’d be interested to hear how you’re handling pipeline consistency — especially around preview systems and scaling.