Seeking focused feedback on UE5 soulslike combat & AI (Blueprints) I’m a solo lead building a 1–2 hour single-player soulslike in UE5 (Blueprints). I’m looking for technical critique on combat architecture, combo handling, and an AI revival system

Development Programming & Scripting
, , , , ,
1

  • Engine / tech: Unreal Engine 5 — Blueprints only.

  • Scope: 1–2 hour single-player experience.

  • Team: Solo lead (project director, programmer, primary 3D artist) with a few external contributors handling non-essential assets (sound, music).

  • Attached media: Due to forum restrictions (new users cannot upload attachments), here is a link to a video compilation of core systems: Google Drive Link

What’s implemented (prototype/polished where noted):

  • Player combat: multiple attacks and many player combos, stamina, dodging, lock-on, damage application.

  • Enemy types: completed far-range and close-range enemies with differing behaviours.

  • Enemy AI: state-machine and behaviour-tree hybrid logic powering patrol, engage, attack, and retreat behaviours.

  • Animation system: montages, root motion, animation notifies implemented for attack windows and events.

  • Death / bonfire loop: death, respawn, leveling, fast travel implemented.

  • UI: health, stamina, boss bars and basic HUD elements.

  • Temporary weapon system: blueprint-based temporary weapons (axes, blades, etc.) that can be summoned for ~20 seconds to expand combo options (upgradeable via skills).

  • Storytelling: world and lore implemented via environment, enemy design, and non-verbal ‘mumbling’ languages per puppeteer region.

Core design notes (world / narrative):

  • The world is a plague-ridden, perpetually overcast setting created by a god-like puppeteer and governed by four puppeteers whose clans embody ideals (Poetism, Selflessness, Rule, Peace). A betrayal and plague reshape those clans into Pride, Tyranny, Chaos (Poetism remains isolated). The player (created by the god) must defeat the four puppeteers; multiple endings depend on choices and side-content. Characters are largely silent; those with free will mumble in region-specific gibberish that conveys tone rather than explicit lines.

Primary problems / what I want feedback on (ranked):

  1. Player combo architecture: I implemented many player combos and now face instability and edge-cases. I need a robust, scalable combo system design (Blueprint patterns, state handling, input buffering, and animation sync strategies). Prefer approaches that keep logic maintainable in Blueprints.

  2. AI revival / minion respawn system: I want certain minor puppeteers to be able to revive enemies (or have enemies respawn under their control) until those puppeteers are permanently defeated. I’m struggling with a clean, network-agnostic (local single-player) pattern to implement controlled revives without causing gameplay exploits or performance spikes.

  3. Combat + AI balance & variety: Advice on designing enemy archetypes, difficulty curves, and how to tune AI aggressiveness vs punishability in a soulslike loop for a 1–2 hour single-player demo.

  4. Performance / blueprint scale concerns: Any Unreal best practices for keeping a Blueprint-only project maintainable and performant as systems grow.

What I’m asking reviewers to provide:

  • High-level architecture critique (combat system and AI revival system).

  • Concrete Blueprint design patterns or diagrams (state machines, event flows, example variable sets) where possible.

  • Suggestions for preventing combo system edge-cases (input buffering, cancel windows, animation blending strategies).

  • Algorithms or patterns for controlled enemy revival/respawn anchored to a puppeteer actor (spawn gating, limiters, tethering revives to puppeteer life-state, cleanup strategies).

  • Balancing advice tailored to a short, single-player soulslike (enemy density, kit complexity, checkpoint placement).

Helpful context / constraints:

  • No networking; single-player only.

  • Project must remain Blueprint-only for now (no C++).

  • Temporary summoned weapons are designed to augment combo variety for limited windows (20s base).

  • The game’s tone is dark, deliberately restrictive (non-sunny world), and systems should reinforce weighty combat.

Direct questions to answer in replies (if possible):

  1. What Blueprint patterns do you recommend for a maintainable combo system that supports many weapon types and temporary summon weapons? Please include a short pseudo-workflow (input → state → animation → damage application).

  2. How would you implement a puppeteer-controlled revive system that can:

    • revive only X enemies per minute, or

    • revive enemies until the puppeteer is defeated, and

    • avoid infinite revive loops or unkillable scenarios?

  3. Any demonstrated examples or public resources (GitHub repos, forum threads, tutorials) that show similar systems implemented in Blueprints?

  4. Best practices in UE5 Blueprints to keep performance sane as gameplay complexity grows. Also, if you have some advice for where to put all of my player combat code, because right now it’s in a component where all of my combat resides for enemy and player resides, maybe I’m overly cautious that I’ll ever need that code for anything else, but please tell me where you usually keep all of that stuff.

If you’re comfortable giving occasional technical feedback (one-off reviews, commenting on architecture diagrams, or short async critiques), please reply here or DM me. I’m not looking for formal mentorship contracts—just focused, practical guidance from experienced Unreal developers.

Thanks for reading—I appreciate detailed, technical responses and will follow up with code/Blueprint screenshots or the Google Drive video link above.

Have a good day evening or night!