Feature Showcase¶

A visual walkthrough of MIP's core systems. Each section shows what the plugin provides out of the box.

Top-Down ARPG Gameplay¶

MIP is built for top-down ARPG gameplay. Movement and interaction are handled through a cursor-driven system:

WASD movement — direct character movement with automatic path following via nav-mesh.
Click to interact — left-click on an NPC, gate, or any interactable actor and the character automatically walks to it and triggers the interaction.
Click to attack — left-click on an enemy to move into range and use your ability.
Cursor detection — the system continuously traces under the mouse and classifies what's under it (interactable, enemy, or player), changing the cursor and outline to match.
Action queue — actions like move-to, interact, and use-ability are queued so inputs during movement aren't lost.
Auto-face cursor — optional setting to have the character always face the mouse position (configurable, can force-enable in towns).

Inventory & Equipment¶

MIP ships with a full server-authoritative inventory system:

Slot-based grid — starts at 24 slots, unlockable up to 192 (configurable per project), with support for temporary slot unlocks (e.g. from buffs or items).
Unlimited stacking — stackable items have no hard-coded max stack. Stack size is unlimited by default.
Drag-and-drop — between inventory, equipment slots, storage, quick bar, and drop-on-screen to discard. All operations are server-validated.
Sorting — one-click inventory sort with configurable sort rules.
Swap & move — swap slot positions, move items between inventories (player ↔ storage ↔ vendor).
Use & consume — server-authoritative item usage with pre-checks (cooldown, class restriction, combat state), confirmation popups, and client delegates for UI feedback.
7 item types — Equipment, Consumable, Material, Junk, Currency, Enhancement Material, Repair Material — each defined as a C++ item definition class with built-in pieces.
Modular item pieces — every item is composed of pieces (stackable, equipment stats, durability, enhancement, cooldown, expiring, class restriction). Add custom pieces without modifying base classes.
Item tooltips — stat breakdowns showing static stats, rolled dynamic stats, and randomized pool stats with color-coded rarity.

Four equipment modification operations let players alter stats on existing equipment: Reforge, Recalibrate, Seal, and Transmute. These are distinct from crafting (which creates new items from materials). All stat modifiers are GAS-driven and fully replicated. Each operation has its own cost configuration via data assets.

Gameplay Ability System¶

Full GAS integration with ability leveling, cooldown management, ability points, and status effects. Abilities are slotted into a quick bar and cast with configurable input bindings.

Save / Load & Character Select¶

MIP's save system is split into server-side persistence (MongoDB via the backend) and client-side local saves (UE5 USaveGame slots). Everything is handled automatically — you just add properties and they save.

Adding Your Own Saved Data¶

Any component that extends UMIPBaseSaveableComponent is automatically discovered, serialized, and persisted. To save a new property, mark it with UPROPERTY(SaveGame):

UPROPERTY(BlueprintReadOnly, SaveGame, Category=MyFeature)
TMap<FGameplayTag, int32> MyCustomDataMap;

UPROPERTY(BlueprintReadOnly, SaveGame, Category=MyFeature)
bool bSomeFlag = false;

That's it. The system scans all SaveGame-tagged properties at save time, serializes them to JSON, and sends them to the backend. On load, the JSON is deserialized back into the properties. No manual serialization code, no registration — just the SaveGame specifier.

How It Works¶

                    Server                                    Client
  ┌────────────────────────────────┐        ┌──────────────────────────────┐
  │ UMIPBaseServerLoadComponent    │        │ UMIPBaseClientLoadComponent  │
  │  ← Socket.IO events from BE   │        │  ← USaveGame local slot     │
  │  → batch-loads items, saveable │        │  → quick slots, UI state    │
  │    components, currencies,     │        │                              │
  │    temp-duration objects       │        │ UMIPClientBaseSaveComponent  │
  │  → parallel streams, 32/tick  │        │  → SaveToSlot()              │
  ├────────────────────────────────┤        └──────────────────────────────┘
  │ UMIPBaseServerSaveComponent    │
  │  (on GameMode)                 │
  │  → per-player save handler    │
  │  → ticks every ~2s, flushes   │
  │    dirty components to backend │
  └────────────────────────────────┘

Two accessibility scopes — each saveable component declares whether it belongs to the character (inventory, quests, abilities) or the family (shared storage, account settings). The system routes save/load data to the correct scope automatically.
Auto-dirty — call MarkComponentForSave() when data changes; the server save component picks it up on its next tick and flushes to the backend.
Batch loading — items load in configurable batches (default 32 per tick) to avoid server hitches. Saveable components and currencies load in parallel streams. Delegates fire when each stream completes and again when all loading is done (OnPostAllLoadingCompletedDelegate).
Version migration — each saveable component has a DatabaseVersion and FileVersion. When they differ, OnVersionChanged() fires so you can migrate old save data.

Character Selection¶

The character selection screen runs on its own AMIPCharSelectionGameMode with a dedicated map. The backend returns the player's family info and all characters (name, class, level, last map, equipped items). Players select a character and join the game — the backend routes them to the correct server instance.

Quest System¶

Accept, track, and complete quests with branching objectives and an on-screen HUD tracker.

Quest Journal — toggleable widget with In Progress and Completed tabs. Remembers your last-selected quest and tab between sessions (persisted to client save). Shows quest details, task progress, and reward choices in a detail panel.
Quest Lines — quests are organized into quest lines (story arcs). The journal groups quests by line, shows ordered progress (e.g. "3/7"), and grays out prior completed steps. Quest lines are defined in UMIPQuestSettings and categorized (Main, Side, etc.).
Quest Tasks — kill objectives, go-to-location overlaps, item collection, and custom tasks. Each task tracks progress independently with delegates for UI updates.
Reward choices — quests can offer multiple reward options; the player selects one in the journal before claiming.
Quest-line granting — quest lines can be given by NPCs, items (consumables that grant a quest line on use), or scripted events.

NPCs offer quests through a dialogue system with multiple response options. Quest-givers show indicators above their heads for available, in-progress, and completable quests.

Chat System¶

Real-time chat via Socket.IO with global, area, whisper, and system channels. Supports rich text formatting, profanity filtering, and rate limiting.

NPC & Interaction¶

NPCs support a circular interaction UI with context-dependent options — talk, trade, open storage, accept quests. Vendors and storage NPCs are built-in.

Mobs & Spawners¶

Configurable mob spawners (area, wave, trigger, respawn) with AI behavior, world-level scaling, and loot tables. Mobs display health bars and floating damage numbers.

Dungeon & Game Modes¶

Session-based dungeons with dynamic server allocation via Agones. Supports wave/survival modes, endless colosseum, and party-based instances. Each dungeon runs on its own dedicated server.

Player Progression¶

XP-based leveling with configurable level curves, ability points per level, and multiple currency types. All progression data replicates efficiently via FastArraySerializer.

UI Framework¶

96+ pre-built widget classes covering every system — inventory, equipment, abilities, quests, chat, dialogue, popups, notifications, and more. All widgets are Blueprint-extensible and styled for top-down gameplay.

Editor Tools (Custom Graph Editors)¶

MIP includes three custom visual editors built on Unreal's SGraphEditor — the same framework used by Blueprint graphs. All three are pan/zoom node canvases with drag-and-drop, details panels, and persistent layout saving.

Quest Flow Graph¶

A story-line flow graph where each node represents a quest line (e.g. "Chapter 1"). Quests appear as rich cards inside their node, ordered by progression.

┌─────────────────────────────────────────────────────────────────────┐
│ [●In]  CHAPTER 1                                           [Out●]  │
├─────────────────────────────────────────────────────────────────────┤
│ ┌──────────────┐  ┌──────────────┐  ┌──────────────┐  ┌────────┐  │
│ │ Quest Title  │  │ Quest Title  │  │ Quest7       │  │ + Add  │  │
│ │ [GoTo]       │  │ [GoTo]       │  │ [→ SideQ07]  │  │        │  │
│ │ [◀][▶]  [×]  │  │ [◀][▶]  [×]  │  │ [◀][▶]  [×]  │  │        │  │
│ └──────────────┘  └──────────────┘  └──────────────┘  └────────┘  │
└─────────────────────────────────────────────────────────────────────┘

Quest cards — each card shows title, task breakdown (kill/goto/collect), reward item chips with icons and quality-coloured names, and target player/ability levels
Add / reorder / remove quests within a line directly on the node with + Add, ◀ ▶, and × buttons
Drag wires between nodes to define story-line progression and unlock dependencies
Per-quest UnlocksQuestLines — badges on quest cards that wire to other story lines; click a badge to zoom to the target node
Import Quest from JSON — create quests from structured JSON files
Generate Routes — auto-generate quest route data
Click a quest card to inspect and edit it in a details panel; set target levels that cascade forward to subsequent quests
Persistent layout — node positions saved to a simulation data asset and restored on reopen

Map Flow Graph¶

A map connection graph where each node represents a playable map.

┌────────────────────────────────────────────────────────────┐
│  [+ Add Map]   [Generate Paths]   [Save Layout]           │
├────────────────────────────────────────────────────────────┤
│                                                            │
│   (Town A) ──gate──▶ (Area B) ──gate──▶ (Dungeon C)       │
│                                                            │
└────────────────────────────────────────────────────────────┘

Gate connections — drag from Out pin to In pin to define gates between maps; colour-coded by map type (green = Area, blue = Town, red = Dungeon)
BFS path generation — auto-generates navigation paths between all maps and saves to UMIPMinimapSettings config
Info panel — click a map node to see:
- NPCs with names, occupations, and tags (loaded on demand from the level package)
- Mob spawners with mob names and world positions
- Loot/combat overrides per spawner (with item icon chips)
- Gate-to-gate navigation distances (nav-mesh or straight-line)
- Connection validation (shows missing gates with warnings)
- Minimap preview with NPC/marker overlay, zoom control, and hide toggles
Add maps from the data table with a picker wizard (filters already-added maps)
Auto-save — piggybacks on Ctrl+S / Save All to flush layout and connections

Item Definition Browser¶

A visual item browser where each node is a UMIPItemDefinition asset displayed as a rich card.

┌─ quality-colour stripe ───────────────────────────┐
│  Title bar  (item DisplayName, quality colour)     │
├────────────────────────────────────────────────────┤
│  [52×52 icon]  │  Quality: …  Category: …          │
│                │  Description (clamped)             │
│                │  [currency icon]  sell value        │
├────────────────────────────────────────────────────┤
│  Pieces: Stackable, Equipment, Cooldown …          │
└────────────────────────────────────────────────────┘

Type tabs — switch between Consumable, Equipment, Material, Junk, etc.; each tab shows only that type's assets
Rich item cards — quality-coloured borders, icon, category, description, sell price, and piece list — all live-bound to the underlying data asset
Click a node to edit the item definition in the details panel; property changes reflect on the card immediately
Create new items with step-by-step creation wizards (consumable wizard with usable piece creation, material wizard)
Navigate to item — programmatic search-and-zoom to any item definition across type tabs
Gameplay tag tree picker — reusable hierarchical tag picker widget for selecting item tags, class restrictions, etc.

Custom Editor Engine¶

MIP replaces the default editor engine with UMIPEditorEngine to handle multi-instance PIE (Play In Editor) sessions. It manages instance counting and allocation so that multiple clients and a dedicated server can launch from the editor with correct backend connections.

Backend Dashboard¶

The NestJS backend handles authentication, player persistence, real-time events, and game server orchestration. Connects to MongoDB for storage, Redis for pub/sub, and Kubernetes/Agones for dedicated server management.