DEV Community: DomTech Gaming

Magickness MMORPG Now Running on PC + Mobile Ahead of Open Demo

DomTech Gaming — Fri, 15 May 2026 21:28:52 +0000

Magickness™ has officially crossed a major production milestone.

The current multiplayer build is now successfully running on both Windows PC and Android using the same live backend infrastructure, dedicated server pipeline, and persistent world systems.

This was not a content milestone.

It was a production milestone.

What’s Currently Running

The current playable build now supports:

Account creation
Email verification
Character creation
2D HomeWorld login space
Portal travel into the 3D world
Dedicated multiplayer server connection
Real-time gameplay synchronization
Character stats, inventory, abilities, morality systems, and HUD integration

Both PC and Android builds now connect to the same live multiplayer infrastructure running continuously on Oracle Cloud ARM64 servers.

The Current State of Pangea

The current playable world — Pangea — is still intentionally minimal.

Right now the focus is infrastructure stability and gameplay foundation rather than large-scale world decoration.

The terrain system currently includes:

Runtime voxel terrain generation
Rolling hills and mountain ridges
River and lake generation
Multi-material biome blending
Underground terrain support
Marching-cubes terrain architecture

The current playable world space spans roughly 2km × 2km.

Pangea also plays directly into the larger lore direction of Magickness™, which explores alternate dimensions and simulated realities connected to experimental wormhole research.

That worldbuilding layer will continue expanding over time as development moves deeper into gameplay systems and environmental storytelling.

Why This Milestone Matters

Cross-platform support was always part of the long-term vision for Magickness.

Getting both PC and Android operational before Open Demo dramatically changes future development iteration speed.

The Android pipeline currently supports:

Vulkan SM5 devices
OpenGL ES 3.1 fallback devices
ARM64 deployment
ASTC texture compression
Shared backend authentication
Shared multiplayer server connectivity

Many of the hardest problems in multiplayer game development happen before players ever see meaningful content:

Packaging
Shader compatibility
Runtime networking
Dedicated server deployment
Authentication persistence
Cross-platform synchronization

Those systems are now operational together in a live environment.

What Solo UE5 Development Actually Looks Like

A large portion of the last several weeks involved:

Unreal Engine packaging/debugging
Android compatibility issues
Dedicated server deployment
Multiplayer synchronization
Runtime networking
Infrastructure troubleshooting

Some fixes took minutes once identified.

Some took hours just to diagnose correctly.

That is the reality of building multiplayer infrastructure across multiple platforms simultaneously as a solo developer.

AI-assisted development tools have significantly accelerated iteration speed throughout development, particularly for:

C++ systems
Backend architecture
Tooling workflows
Deployment scripting
Animation prototyping

But AI does not replace production pipeline knowledge.

If anything, this milestone reinforced that shipping experience and infrastructure understanding are still the hardest part of game development.

Current Limitations

The current build is still considered pre-alpha and several systems remain unfinished or placeholder.

Current known limitations include:

Mobile sprint input still needs implementation
Mobile in-game menu behavior still needs refinement
Combat AI systems are still evolving
Audio implementation has not started yet
Some voxel networking systems are still non-replicated

The current milestone is about infrastructure stability and gameplay foundation — not polished content volume.

What Comes Next

Development focus can now shift more aggressively toward:

Worldbuilding
Resource systems
Crafting systems
Expanded combat behavior
Environmental gameplay
Economy foundations
Larger-scale Pangea iteration

The long-term goal remains the same:

Build a discovery-driven online world where progression comes from experimentation, exploration, and player interaction rather than predefined paths.

That transition marks the point where Magickness™ begins evolving from foundational infrastructure into a living game world.

Website:
https://magickness.com/

Support Development:
https://ko-fi.com/domtechgaming

Building an AI-Assisted Animation Pipeline in UE5 with HY-Motion (Dev Log #13)

DomTech Gaming — Wed, 06 May 2026 20:53:47 +0000

Development continues on the gameplay animation systems for Magickness™.

In Dev Log #13, I showcase the current AI-assisted animation workflow being integrated into the project using HY-Motion (HY Animotion), Blender, and Unreal Engine 5.

The goal of this pipeline is to streamline gameplay animation iteration while maintaining compatibility with the existing Mixamo-based character framework already established in the project.

Current Workflow
Generate animation in HY-Motion
Export FBX
Trim/refine in Blender if needed
Import into UE5 using the existing SMPLH skeleton
Retarget using a custom SMPLH → Mixamo retargeter
Export finalized gameplay animation

One important part of the workflow is that the retarget pose is stored directly inside the UE5 retargeter asset itself, meaning future animations can reuse the same pipeline without rebuilding the setup every time.

This allows future gameplay abilities and combat systems to iterate significantly faster while keeping the animation framework consistent across the project.

Magickness™ is a discovery-driven MMORPG currently in active development.

Website:
https://magickness.com/

Support development:
https://ko-fi.com/domtechgaming

YouTube Dev Log:
https://youtu.be/_BEMC1-BY_I

Building a Connected Gameplay Loop (Morality, Abilities, UI) in UE5 — Dev Log #12

DomTech Gaming — Sun, 03 May 2026 23:01:23 +0000

Building a Connected Gameplay Loop (Morality, Abilities, UI) in UE5 — Dev Log #12

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

This dev log focuses on the current game state and provides an overview of how core systems are now interacting in a playable build.

In this update

Full mechanics overview of the current build
Morality system integrated into combat with floating feedback
Ability leveling system implemented
Combat loop updated with visible progression
Settings menu added with navigation options
Continued UI and gameplay integration

This marks a shift in development — from building isolated systems to validating how they interact as a cohesive gameplay loop.

The focus now is ensuring that progression, player choice, and system interaction are all connected in a scalable and extensible framework.

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.

Links

Website:
https://magickness.com/

YouTube:
https://youtu.be/AhswMBZoWs8

Support development:
https://ko-fi.com/domtechgaming

Building a Full Player Onboarding + Gameplay Loop in UE5 (Dev Log #11)

DomTech Gaming — Thu, 30 Apr 2026 02:02:13 +0000

Building a Full Player Onboarding + Gameplay Loop in UE5 (Dev Log #11)

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

This dev log focuses on testing a full player flow — from account creation through early gameplay progression to level 2.

In this update

Full onboarding flow (account creation → email verification → character creation)
Early progression test (Level 1 → Level 2)
Unlockable ability integrated into gameplay
HUD hotbar + ability UI functioning
Base enemy AI implementation
Character stats and progression system active
Morality system integrated into combat loop
Inventory system connected to player state

This marks a major shift in development — moving from isolated systems to a cohesive gameplay loop where multiple systems interact in real-time.

The goal is to build a scalable foundation where progression, player choice, and system interaction drive the gameplay experience.

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.

Links

Website:
https://magickness.com/

YouTube:
https://youtu.be/4xq9g4jQtao

Support development:
https://ko-fi.com/domtechgaming

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.