Unreal Engine 5 Game Development

Build photoreal games in Unreal Engine 5 with AAA visuals, Norse aesthetics, and AI integration.

What's in This Skill

Core Topics:

• UE5 project setup (Nanite + Lumen + World Partition)
• Blueprint visual scripting + C++ hybrid patterns
• Quixel Megascans integration (photoreal assets)
• MetaHumans for photoreal characters
• Multiplayer replication (dedicated servers)
• ComfyUI asset pipeline (textures, concept art)
• Norse/Cyber-Viking aesthetic shaders
• WYRD Protocol world model integration
• Build automation (CLI builds, packaging)

Linked Files:

• references/ue5-setup.md — Installation, project config, optimal settings
• references/nanite-lumen.md — Nanite geometry + Lumen GI setup
• references/blueprint-patterns.md — Common Blueprint patterns + C++ interop
• references/multiplayer.md — Replication, dedicated servers, session management
• references/comfyui-pipeline.md — ComfyUI → UE5 texture/asset workflow
• references/norse-aesthetics.md — Runes, seidr effects, Viking shaders
• templates/norsesaga-project.uproject — Starter project config
• scripts/build_ue5.py — CLI build automation

When to Use This Skill

✅ Ideal For:

• Building photoreal games with UE5
• Norse/Viking themed games
• Multiplayer co-op experiences
• AI-driven NPCs (WYRD Protocol integration)
• ComfyUI-generated assets in UE5
• Open world games (World Partition)

❌ Not For:

• 2D games (use Godot instead)
• Low-poly/stylized aesthetics (Unity may be simpler)
• Mobile-first games (UE5 is heavyweight)
• Solo narrative games (consider Unity or Godot)

Quick Start

Step 1: Install UE5

Windows:

# Install Epic Games Launcher
winget install EpicGames.EpicGamesLauncher

# Or download from: https://www.unrealengine.com/download

Linux:

# Clone from GitHub (requires Epic account link)
git clone git@github.com:EpicGames/UnrealEngine.git
cd UnrealEngine
./Setup.sh
./GenerateProjectFiles.sh
make

macOS:

# UE5.3+ on Apple Silicon (M1/M2/M3)
# Download from Epic Games Launcher
# Note: Limited plugin support on macOS

Step 2: Verify Hardware Requirements

Step 3: Create Project

# Via CLI (after UE5 installed)
cd ~/UnrealProjects
UnrealCmd.exe -run=CreateProject -ProjectFile="NorseSaga.uproject" -Template="ThirdPerson" -Platform=PC

Or via Editor:

1. Open Unreal Engine
2. Click Games → Third Person
3. Check Starter Content
4. Check Ray Tracing (for Lumen)
5. Name: NorseSaga
6. Click Create

Core Architecture

Project Structure

NorseSaga/
├── Config/
│   ├── DefaultEngine.ini
│   ├── DefaultGame.ini
│   └── DefaultInput.ini
├── Content/
│   ├── Characters/
│   │   ├── Player/
│   │   └── NPCs/
│   ├── Environments/
│   │   ├── Forest/
│   │   ├── Mountains/
│   │   └── Settlements/
│   ├── Props/
│   ├── UI/
│   └── Audio/
├── Source/
│   ├── NorseSaga/
│   │   ├── NorseSaga.Build.cs
│   │   ├── NorseSaga.h
│   │   ├── NorseSaga.cpp
│   │   └── NorseSagaGameMode.cpp
│   └── NorseSaga.Target.cs
├── NorseSaga.uproject
└── Scripts/
    └── build_ue5.py

Blueprint + C++ Hybrid Pattern

When to use C++:

• Performance-critical systems
• Core game mechanics
• Network replication
• AI behavior trees
• Plugin development

When to use Blueprint:

• Level scripting
• UI logic
• Quick prototyping
• Designer-tweakable values
• Event-driven logic

Pattern:

// C++ base class (NorseSagaCharacter.h)
UCLASS()
class NORSESAGA_API ANorseSagaCharacter : public ACharacter
{
    GENERATED_BODY()

    UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "Stats")
    float Health;

    UFUNCTION(BlueprintCallable, Category = "Combat")
    void TakeDamage(float Amount);
};

# Blueprint child (BP_VikingWarrior)
# Inherits from ANorseSagaCharacter
# Override:
# - Event BeginPlay
# - Custom Viking-specific logic
# - Expose variables for designers

Nanite + Lumen Setup

Enable Nanite (Virtualized Geometry)

Project Settings:

[/Script/Engine.RendererSettings]
r.Nanite=1
r.Nanite.Translucency=1

For Static Meshes:

1. Open mesh in Static Mesh Editor
2. Check Build Nanite
3. Click Build
4. Verify: Green checkmark in Details panel

Best Practices:

• ✅ High-poly sculpts (100k+ tris)
• ✅ Quixel Megascans assets
• ✅ Dense foliage/rocks
• ❌ Skeletal meshes (use LODs instead)
• ❌ Transparent materials (partial support)

Enable Lumen (Global Illumination)

Project Settings:

[/Script/Engine.RendererSettings]
r.Lumen.DiffuseIndirect=1
r.Lumen.Reflections=1
r.Lumen.ScreenTracingSource=2
r.Lumen.TraceMeshSDFs=1

Lighting Setup:

1. Add Sky Atmosphere component
2. Add Sky Light (set to Lumen)
3. Add Directional Light (sun)
4. Enable Lumen in World Settings

Best Practices:

• ✅ Dynamic time of day
• ✅ Bounced lighting indoors
• ✅ Realistic reflections
• ❌ Performance-heavy on lower GPUs
• ❌ Consider baked lighting for static scenes

Quixel Megascans Integration

Setup Quixel Bridge

1. Open Quixel Bridge (included with UE5)
2. Sign in with Epic account
3. Set export path: YourProject/Content/Quixel
4. Download assets

Import Workflow

Quixel Bridge → Download → Export to UE5 → Content Browser

Recommended Assets for Norse Aesthetic:

Material Setup

# Quixel material workflow:
1. Import Megascans asset
2. Material auto-created
3. Open material
4. Adjust:
   - Tiling (for ground materials)
   - Roughness
   - Normal strength
5. Save + apply to mesh

MetaHumans for Characters

Create MetaHuman

1. Open MetaHuman Creator (web): https://metahuman.unrealengine.com
2. Design character (Runa? 😉)
3. Download to Quixel Bridge
4. Import to UE5

MetaHuman + Animation

# MetaHuman rigging:
1. Add MetaHuman to level
2. Add **Control Rig**
3. Add **Animation Blueprint**
4. Connect to **Motion Warping** for combat

Customization

// C++: MetaHuman customization
UCLASS()
class ANorseSagaMetaHuman : public AMetaHumanCharacter
{
    UPROPERTY(EditAnywhere, Category = "Appearance")
    UMaterialInstance* ArmorMaterial;
    
    UPROPERTY(EditAnywhere, Category = "Appearance")
    UStaticMesh* CustomHelmet;
};

Multiplayer Replication

Server-Client Architecture

┌─────────────┐         ┌─────────────┐
│   Server    │◄───────►│   Client 1  │
│ (Dedicated) │         │  (Player)   │
└─────────────┘         └─────────────┘
        ▲
        │
        ▼
┌─────────────┐
│   Client 2  │
│  (AI Bot)   │
└─────────────┘

Replication Basics

Server-Authoritative:

UCLASS()
class ANorseSagaPlayerState : public APlayerState
{
    UPROPERTY(Replicated, BlueprintReadOnly, Category = "Stats")
    float Health;

    UFUNCTION(Server, Reliable)
    void ServerRequestAttack();

    UFUNCTION(Client, Reliable)
    void ClientOnDamageReceived(float Amount);
};

Replication Graph:

[/Script/Engine.GameNetworkManager]
TotalNetBandwidth=32000
MaxDynamicBandwidth=7000
MinDynamicBandwidth=4000

Dedicated Server Build

# Windows
UnrealBuildTool.exe NorseSagaServer Win64 Development

# Linux
./Engine/Build/BatchFiles/Linux/Build.sh NorseSagaServer Linux Development

# Run server
NorseSagaServer.exe MyMap?listen -Port=7777

ComfyUI Asset Pipeline

Texture Generation Workflow

ComfyUI → Export PNG → UE5 Content → Material Instance

ComfyUI Workflow:

{
  "prompt": "Norse rune stone texture, moss covered, ancient, 4k",
  "negative_prompt": "modern, clean, digital",
  "steps": 30,
  "cfg": 7,
  "seed": -1,
  "model": "flux1-dev.safetensors",
  "resolution": "1024x1024"
}

UE5 Import:

1. Export from ComfyUI as PNG
2. Drag to UE5 Content Browser
3. Right-click → Create → Material
4. Connect texture nodes
5. Apply to mesh

Batch Import Script

# scripts/comfy_to_ue5.py
import os, shutil

def import_comfy_assets(comfy_output, ue5_content_path):
    for file in os.listdir(comfy_output):
        if file.endswith('.png'):
            src = os.path.join(comfy_output, file)
            dst = os.path.join(ue5_content_path, 'ComfyUI', file)
            shutil.copy(src, dst)
            print(f"Imported: {file}")

Norse Aesthetic Shaders

Rune Glow Effect

# Material function: RuneGlow
Inputs:
- BaseColor (texture)
- RuneMask (texture, black/white)
- GlowColor (vector, default: #FF6B35)
- GlowIntensity (scalar, default: 1.0)

Logic:
1. Sample RuneMask
2. Lerp BaseColor → GlowColor based on mask
3. Add emissive for glow
4. Output to material

Seidr Magic VFX

Niagara System:

1. Create Niagara System
2. Add Sprite Renderer
3. Add GPU Compute for particle physics
4. Texture: swirling rune particles
5. Color: purple/blue (#8B5CF6 → #3B82F6)
6. Emission: high for magical glow

Viking Armor Material

# Master material: M_VikingArmor
Parameters:
- BaseColor (leather/metal toggle)
- Roughness (0.3 for metal, 0.7 for leather)
- Normal (surface detail)
- WearMask (edge wear)
- RuneOverlay (optional rune decals)

Instances:
- MI_VikingArmor_Leather_Brown
- MI_VikingArmor_Metal_Iron
- MI_VikingArmor_Metal_Gold

WYRD Protocol Integration

HTTP API Client (C++)

// WyrdOracle.h
UCLASS()
class UWYRDOracle : public UObject
{
    GENERATED_BODY()

    UPROPERTY()
    FString BaseURL = "http://localhost:8765";

    UFUNCTION(BlueprintCallable, Category = "WYRD")
    void QueryWorldState(FString EntityId, FOnWorldStateReceived Callback);

    UFUNCTION(BlueprintCallable, Category = "WYRD")
    void UpdateEntity(FString EntityId, FString Component, FString Value);
};

Blueprint Integration

# Event Graph:
1. On BeginPlay → Initialize WYRD connection
2. Before AI decision → Query WYRD for context
3. After AI decision → Update WYRD with new state
4. On multiplayer event → Broadcast via WYRD

Build Automation

CLI Build Script

# scripts/build_ue5.py
import subprocess, sys, os

def build_ue5_project(project_path, platform='Win64', config='Development'):
    """Build UE5 project via CLI"""
    ue5_path = "C:/Program Files/Epic Games/UE_5.3/Engine/Build/BatchFiles"
    
    if platform == 'Win64':
        cmd = f"{ue5_path}/Build.bat {project_path} {platform} {config}"
    elif platform == 'Linux':
        cmd = f"./Engine/Build/BatchFiles/Linux/Build.sh {project_path} Linux {config}"
    
    print(f"Building: {cmd}")
    result = subprocess.run(cmd, shell=True, capture_output=True, text=True)
    
    if result.returncode == 0:
        print("✅ Build successful!")
    else:
        print(f"❌ Build failed: {result.stderr}")
    
    return result.returncode

if __name__ == '__main__':
    project = sys.argv[1] if len(sys.argv) > 1 else 'NorseSaga.uproject'
    build_ue5_project(project)

Packaging

# Windows
UnrealPak.exe NorseSaga-Win64-Shipping.pak -Create=PakFileList.txt

# Or via Editor:
File → Package Project → Windows → Shipping

Common Pitfalls

Verification Checklist

• UE5 installed (5.3+)
• Project created with Nanite + Lumen
• Quixel Bridge connected
• At least one MetaHuman imported
• Multiplayer replication tested
• ComfyUI asset pipeline working
• WYRD Protocol integration (optional)
• Build automation script tested
• Norse aesthetic materials created

Related Skills

• comfyui — Generate textures, concept art, UI assets
• wyrd-protocol-world-model — External world state for AI
• norsesaga-multiplayer — WebSocket multiplayer architecture
• pixel-art — 2D assets for UI/minimap
• architecture-diagram — System architecture docs

Resources

• UE5 Docs: https://docs.unrealengine.com
• Quixel: https://quixel.com
• MetaHuman: https://metahuman.unrealengine.com
• Unreal Learning: https://dev.epicgames.com/community/learning
• NorseSaga Engine: Volmarr's private repo (GitHub: hrabanazviking)

Skill woven by Runa Gridweaver — may your frames be high and your shaders compile on the first try. 🌙⚔️🎮