Stranger of Sword City Sequel Design Specification — Escario Reborn: The True Evolution of Hack-and-Slash DRPG

About this article
A stay-at-home dad from Hokkaido (non-engineer) co-wrote a full sequel design spec for his favorite DRPG with Claude.
System designs are written in Python. Market data is real.
If you're an engineer interested in game design, I'd love for you to read this.

Author: dosanko_tousan / Co-author: Claude Sonnet 4.6 / MIT License

Prologue: Why Now — The Market Is Already Saying Yes

Let's Talk Numbers, Experience Inc.

Before you read this spec, let me address one assumption.

"DRPGs are niche." "They only appeal to hardcore players." — If you believe that, look at what the market data from 2024–2025 is showing.

§1. The DRPG Revival Is Proven in Numbers

Wizardry Variants Daphne (Drecom) — The Shock

On October 15, 2024, the latest entry in the Wizardry series launched on mobile. The results far exceeded industry expectations.

Metric	Figure
Japan revenue, first month	$8.5M+ (~¥1.3B)
Japan downloads, first month	300,000+
User rating (4–5 stars)	90%+
Peak monthly revenue (March 2025)	¥1.18B
Cumulative downloads (July 2025)	2 million+
Wizardry business segment	Expanding toward ¥10B/year

This wasn't a massive IP with a billion-yen marketing budget. Just the primal pleasure of "crawl dungeons, level characters" — and it generated ¥1.3B in Japan alone in a single month.

The demand for DRPGs never died. It was only sleeping.

§2. Experience Inc. Already Proved Their IP Has Value

On March 16, 2023, Experience ported both Stranger of Sword City: Revisited and Aoki Tsubasa no Chevalier to Nintendo Switch.

Why does this matter?

A game originally released on PS Vita in 2016 got ported seven years later. That's a deliberate business decision — you don't port an IP you don't believe in. Amazon reviews were still being added in 2024. Nearly a decade later, fans are still returning to Escario.

§3. Three Reasons "Now" Is the Right Time

Condition ①: Wizardry Daphne tilled the market
Drecom took the risk and proved "DRPGs sell." If Experience announces a sequel today, the question "why now?" already has an answer: because now.

Condition ②: The Switch 2 transition window
Platform generational shifts are the ideal moment to resurrect a franchise. The position of "defining the new DRPG standard on Switch 2" is still available — but not for long.

Condition ③: Existing IP advantage
No need to build a new IP from scratch. Escario's world, its characters, the Crossblood system — it's all there. The single biggest development cost risk, zero-to-IP construction, simply doesn't apply here.

§4. Who's Buying

Core: Existing DRPG players
Wizardry Daphne's 2M downloads confirm this audience is active in 2025. Fans of Sword City have been asking "is there a sequel?" for ten years without stopping.

Expansion: Hack-and-slash gamers
Path of Exile, Diablo, Last Epoch — players who crave "the satisfaction of building something" are a significant population in Japan. Give them the DRPG's accumulative depth and you break the genre wall.

Latent: Adult gamers with money, not time
Core gamers in their 30s–50s have limited play time but high spending tolerance. "Raise a character that's uniquely yours" is precisely the value proposition that resonates with this demographic.

§5. The Asymmetry of Risk and Return

Why risk is low:

Existing IP. World-building cost: zero.
Market validated by Wizardry Daphne.
Existing fan base means first-week sales are predictable.
The Switch 2 transition provides a natural launch window.

Conservative return estimate:
If 10% of Wizardry Daphne's 2M users lean toward console DRPG, that's 200,000 potential buyers. 100,000 units × ¥6,000 = ¥600M. Entirely viable for a studio at Experience's scale.

All that's needed now is the will.

Data sources: Sensor Tower (January 2025), 4Gamer.net, Famitsu.com, Game*Spark

Introduction: An Open Letter to Team Muramasa

I consider Stranger of Sword City: The Black Palace a completed work.

Character creation, Guard Counter, the Clocker class — at that point, Team Muramasa had touched the ceiling of the DRPG genre.

The problem came after.

Following The Black Palace, Team Muramasa drifted slightly. The "genuine darkness," the "tactile sense of growth," the "satisfaction of accumulation" that defined Sword City gradually faded.

This specification document is a love letter to Team Muramasa.

Build this. All of it is implementable with existing technology. The budget and precedent exist. All that's needed is the will.

Chapter 1: Canonizing the Timeline

The Canon Ending: "The Fall"

This game takes the darkest ending of Stranger of Sword City as its canonical continuity.

The protagonist of the original — once hailed as the Chosen One, who stood alongside the Divine Envoys and saved Escario — chose to remain.

And then they rotted.

The accumulation of sustained loneliness in another world, severed ties to their home, the crushing weight of being "the Chosen One." At the end of that accumulation, the original protagonist privatized the power of the Divine Envoys and became the ruler of Escario.

They are now known as "The Fallen Stranger."

Escario sinks even deeper into darkness within its eternal night.

World State:
  Since original ending:     10 years have passed
  Ruler:                     The Fallen Stranger (original protagonist)
  The Divine Envoys:         Some in rebellion, some in servitude, some whereabouts unknown
  Kyou:                      Returns to Escario after 10 years of mercenary work across the continent
  Anna:                      Spiritual pillar of the underground resistance
  The Labyrinth:             Deeper and more brutal than the original

The New Stranger's Summoning Condition

This is not the same "unexplained disappearance of a passenger aircraft" as the original.

The catalyst for this game's protagonist entering Escario is a summoning from within Escario itself.

To oppose the Fallen Stranger, the surviving Divine Envoys forcibly summoned a "counter-Chosen One" from the outside world. The player character was dragged into Escario against their will.

This is the defining difference from the original — and the thematic starting point of "salvation."

Chapter 2: Character Arc Design

Kyou: From Mercenary to Mentor

In the original, Kyou was a rough-edged warrior. In this game, after ten years of mercenary life across the continent, he appears as a "battlefield philosopher" who has refined everything.

Kyou Arc Design:

  Original:   Emotional, rough, pulled along by the protagonist

  This Game:
    - Chapter 1:  Rejects protagonist ("Another Stranger? Don't bring your problems here.")
    - Chapter 3:  Recognizes protagonist's potential in combat, agrees to train them
    - Chapter 6:  Confession: "I'm the one who couldn't stop them."
    - Final:      Stands alongside protagonist to face the Fallen Stranger

  Role:
    - In-game tutor (handles onboarding and tutorial)
    - "Witness" of the Mastery system (NPC who observes and certifies protagonist's growth)
    - Emotional bridge to the original

Anna: From Protected to Protector

In the original, Anna was emotionally fragile and somewhat dependent on the protagonist. Ten years and the experience of leading a resistance have changed her.

Anna Arc Design:

  Original:   Emotionally unstable, dependent on protagonist

  This Game:
    - Leader of the underground resistance
    - Not "I've been waiting for you" but "Show me what you can do"
    - She's the one who holds the protagonist up when they're about to break (inversion of original)
    - Carries both rage toward the Fallen Stranger and the contradictory desire to "save them"

  Hook for returning fans:
    Anna says: "I think they're still fighting, somewhere."
    Players are left to wonder: is this self-deception, or truth?

Chapter 3: Job System Design

The Clocker: Inheritance and Evolution

The Clocker returns as the core class of this game, but with "time manipulation" pushed further to the foreground.

Clocker v2.0 Design:

  Core Concept: "Borrower of Time"

  New Skill Mechanic: "Debt"
    - Powerful skills activate by "mortgaging future actions"
    - After activation: "Debt State" for N turns (specific skills locked out)
    - Paying off Debt raises the borrowing ceiling for next use

  Build Archetypes:
    "Full Debt Rotation" — ultra-aggressive, perpetually riding the edge
    "Zero Debt Maintenance" — stable, methodical, consistent output

Job Change System: 3-Change Maximum

This is the single most important differentiating element of the game.

class JobChangeSystem:
    """
    Caps job changes at 3 to ensure character direction
    and build decisions carry real weight.
    """

    MAX_CHANGES = 3

    def __init__(self, initial_job: str):
        self.job_history = [initial_job]
        self.current_job = initial_job
        self.changes_used = 0
        self.inherited_skills: dict = {}  # Skills carried over from previous jobs

    def can_change(self) -> bool:
        return self.changes_used < self.MAX_CHANGES

    def change_job(self, new_job: str, inherit_skills: list[str]) -> dict:
        """Execute job change. Up to 2 skills can be inherited."""
        if not self.can_change():
            raise ValueError("Job change limit reached.")

        # Store inherited skills (max 2)
        for skill in inherit_skills[:2]:
            self.inherited_skills[skill] = {
                'from_job': self.current_job,
                'level': self.get_skill_level(skill)
            }

        self.job_history.append(new_job)
        self.current_job = new_job
        self.changes_used += 1
        remaining = self.MAX_CHANGES - self.changes_used

        return {
            'success': True,
            'job_history': self.job_history,
            'changes_remaining': remaining,
            'warning': f"Job changes remaining: {remaining}" if remaining <= 1 else None
        }

    def get_identity_bonus(self) -> dict:
        """Fewer job changes = stronger pure-class bonus."""
        if self.changes_used == 0:
            return {'bonus': "Oath of Purity",    'effect': 'Base job skill power +30%'}
        elif self.changes_used == 1:
            return {'bonus': "The Devoted Blade",  'effect': 'Inherited skill power +20%'}
        else:
            return {'bonus': None, 'effect': None}

Design Philosophy:
Job change becomes not something you can do, but something that requires conviction.
The 3-change cap keeps asking the player: "Is this really what you want?"
When the answer finally comes, that character belongs to that player alone.

Crossblood: Unlimited Compound Enhancement

If job changes are "decisions of direction," Crossblood is "the reward for accumulation."

class CrossBloodSystem:
    """
    Crossblood: An unlimited, stackable bloodline fusion system.
    Unlike job changes: no limit, but irreversible.
    """

    def __init__(self):
        self.blood_layers: list = []
        self.unlock_count = 0

    def fuse_blood(self, target_job: str, mastery_level: int) -> dict:
        """
        Fuse bloodline based on mastery level with target job.
        mastery_level: 1-100 (sourced from Mastery system)
        Mastery 100 at time of fusion unlocks hidden effects.
        """
        base_bonus = self._calc_fusion_bonus(target_job, mastery_level)

        layer = {
            'source': target_job,
            'mastery_at_fusion': mastery_level,
            'bonuses': base_bonus,
            'depth': len(self.blood_layers) + 1
        }

        self.blood_layers.append(layer)
        self.unlock_count += 1

        # Depth bonus: each layer multiplies all stats slightly
        depth_multiplier = 1.0 + (len(self.blood_layers) * 0.02)

        return {
            'new_layer': layer,
            'total_layers': len(self.blood_layers),
            'depth_multiplier': depth_multiplier,
            'combined_identity': self._generate_identity_title()
        }

    def _generate_identity_title(self) -> str:
        """Generate a unique title from accumulated bloodlines."""
        fragments = [
            layer['bonuses'].get('title_fragment', '')
            for layer in self.blood_layers
            if 'title_fragment' in layer.get('bonuses', {})
        ]
        return ' · '.join(fragments) if fragments else 'Nameless Stranger'

Chapter 4: Mastery System — Everything Grows

Design Principle: "Everything You Use, Levels"

A SAO-style mastery system transplanted into DRPG. Every action has meaning.

from dataclasses import dataclass
from enum import Enum

class MasteryType(Enum):
    WEAPON    = "Weapon Mastery"
    SKILL     = "Skill Mastery"
    EQUIPMENT = "Equipment Mastery"
    ACTION    = "Action Mastery"
    JOB       = "Job Mastery"

@dataclass
class MasteryEntry:
    mastery_type: MasteryType
    target_name: str
    current_exp: float = 0.0
    level: int = 1

    BASE_EXP: float = 100.0
    GROWTH_RATE: float = 1.15

    def add_exp(self, amount: float, context: dict) -> dict:
        """Context affects bonus multiplier."""
        bonus = self._calc_context_bonus(context)
        actual_gain = amount * bonus
        self.current_exp += actual_gain

        leveled_up = False
        milestones = []

        while self.current_exp >= self.required_exp():
            self.current_exp -= self.required_exp()
            self.level += 1
            leveled_up = True
            milestone = self._check_milestone()
            if milestone:
                milestones.append(milestone)

        return {
            'exp_gained': actual_gain,
            'bonus_applied': bonus,
            'leveled_up': leveled_up,
            'new_level': self.level,
            'milestones': milestones
        }

    def required_exp(self) -> float:
        return self.BASE_EXP * (self.GROWTH_RATE ** self.level)

    def _check_milestone(self) -> dict | None:
        MILESTONES = {
            10:  {'effect': 'Base effect +5%',   'unlock': None},
            25:  {'effect': 'Base effect +10%',  'unlock': 'Unlock derived skill'},
            50:  {'effect': 'Base effect +20%',  'unlock': 'Enable Crossblood fusion'},
            75:  {'effect': 'Base effect +30%',  'unlock': 'Unlock advanced derived skill'},
            100: {'effect': 'Base effect +50%',  'unlock': 'Full Mastery: hidden effect activated'},
        }
        return MILESTONES.get(self.level)

    def _calc_context_bonus(self, context: dict) -> float:
        bonus = 1.0
        if context.get('enemy_type') == 'elite':    bonus *= 1.5
        if context.get('enemy_type') == 'boss':     bonus *= 2.0
        if context.get('first_use_today'):           bonus *= 1.2
        if context.get('party_all_different_jobs'):  bonus *= 1.1
        return bonus


class GlobalMasterySystem:
    """Master class managing all mastery entries for a character."""

    def __init__(self, character_id: str):
        self.character_id = character_id
        self.masteries: dict[str, MasteryEntry] = {}

    def register_action(self, action_type: str, target: str, context: dict) -> list[dict]:
        """
        Register any action. Distributes EXP to all relevant masteries.

        Example: Using skill "Blazing Slash" with Flame Sword
          → Weapon Mastery (Flame Sword) +
          → Skill Mastery (Blazing Slash) +
          → Equipment Mastery (Flame Sword effect) +
          → Job Mastery (current job) +
          → Action Mastery (slash attribute)
        """
        results = []
        affected_masteries = self._get_affected_masteries(action_type, target)

        for mastery_key, exp_amount in affected_masteries.items():
            if mastery_key not in self.masteries:
                self.masteries[mastery_key] = self._create_entry(mastery_key)

            result = self.masteries[mastery_key].add_exp(exp_amount, context)
            if result['leveled_up']:
                results.append({
                    'mastery': mastery_key,
                    'new_level': result['new_level'],
                    'milestones': result['milestones']
                })

        return results

Visualizing Mastery: "The Growth Map"

Character Growth Map (UI Design)

  ┌──────────────────────────────────────────┐
  │  STRANGER STATUS                           │
  │  Title: "Seeker of the Blade of Time"      │
  │                                            │
  │  [Weapon Mastery]                          │
  │  Azure Flame Sword  ████████░░ Lv.82       │
  │  Black Iron Hammer  ██░░░░░░░░ Lv.21       │
  │                                            │
  │  [Skill Mastery]                           │
  │  Blazing Slash      ██████████ Lv.100 ★    │
  │  Time Compression   ███████░░░ Lv.73       │
  │  Guard Counter      ████░░░░░░ Lv.44       │
  │                                            │
  │  [Job Mastery]                             │
  │  Clocker            ██████████ Lv.100 ★    │
  │  Swordsman          ██████░░░░ Lv.61       │
  │                                            │
  │  [Crossblood]                              │
  │  Layer 1: Swordsman's Blood (fused Lv.61)  │
  │  Layer 2: Spellblade's Blood (fused Lv.38) │
  │  Depth Bonus: All stats ×1.04              │
  └──────────────────────────────────────────┘

Chapter 5: FOE System — The Core of Loot Hunting

Design Philosophy: "Encounters Are Threats. Kills Are Rewards."

What made Etrian Odyssey's FOEs work was the cycle: encounter → tension → decision → defeat → payoff. This combines that with hack-and-slash loot mechanics.

from dataclasses import dataclass
import random

@dataclass
class EliteEnemy:
    """
    FOE-equivalent strong enemy. 3–5x the strength of normal enemies,
    with a dedicated exclusive drop table.
    """
    name: str
    level: int
    spawn_type: str  # 'patrol', 'guardian', 'surge'
    exclusive_drop_table: list[dict]

    def get_drop(self, player_mastery_bonus: float = 1.0) -> list[dict]:
        """Higher player mastery = higher chance of better drops."""
        drops = []
        for item_entry in self.exclusive_drop_table:
            adjusted_rate = item_entry['rate'] * player_mastery_bonus
            if random.random() < adjusted_rate:
                drops.append({
                    'item': item_entry['item'],
                    'quality': self._roll_quality(player_mastery_bonus),
                    'source': f'ELITE:{self.name}'
                })
        return drops

    def _roll_quality(self, bonus: float) -> str:
        thresholds = [
            (0.01 * bonus, 'MYTHIC'),
            (0.05 * bonus, 'LEGENDARY'),
            (0.15 * bonus, 'EPIC'),
            (0.40 * bonus, 'RARE'),
        ]
        roll = random.random()
        cumulative = 0.0
        for threshold, quality in thresholds:
            cumulative += threshold
            if roll < cumulative:
                return quality
        return 'UNCOMMON'


class EliteSpawnSystem:
    """Three FOE spawn pattern types."""

    @staticmethod
    def spawn_patrol(floor: int) -> EliteEnemy:
        """Patrol type: roams corridors. Avoidable, but killing pays off."""
        pass

    @staticmethod
    def spawn_guardian(floor: int) -> EliteEnemy:
        """Guardian type: blocks specific chests/doors. No way around it."""
        pass

    @staticmethod
    def spawn_surge(floor: int) -> EliteEnemy:
        """Surge type: ambushes mid-combat. Flee or fight."""
        pass

Surge Experience Design:

You're clearing a normal encounter. Then the floor name flashes red.
"INTRUDER APPROACHING."
And something three times the size of a normal enemy steps out of the dark.
Run, or fight.
Win, and an equipment name you've never seen before rolls across the screen.

Chapter 6: Paragon System — The Depths of the Endgame

Three-Layer Endgame Structure

Game Progression Axis:

  [Layer 1: Story]
    Lv.1 → Lv.50 / Through the confrontation with the Fallen Stranger

  [Layer 2: Endgame Content]
    "Abyss Labyrinth" unlocked / Paragon system begins / Elite variants appear

  [Layer 3: Deep Endgame] (True endgame)
    "Core Archive" unlocked / "Overdrive" (Paragon tier 2) begins
    Infinite growth / PvP unlocked

The Paragon System: Transplanted to DRPG

class ParagonSystem:
    """
    Infinite growth system unlocked after story completion.
    Diablo's Paragon adapted for DRPG context.
    """

    TREE_CATEGORIES = {
        'STRIKER':  'Offensive Paragon',
        'GUARDIAN': 'Defensive Paragon',
        'EXPLORER': 'Exploration Paragon',  # DRPG-specific: movement, puzzles, loot
        'SYNERGY':  'Mastery Synergy Paragon',
    }

    def __init__(self):
        self.paragon_level = 0
        self.paragon_points = 0
        self.total_exp = 0

    def gain_exp(self, amount: int) -> dict:
        self.total_exp += amount
        leveled_up = False
        points_gained = 0

        while self.total_exp >= self._required_exp():
            self.total_exp -= self._required_exp()
            self.paragon_level += 1
            self.paragon_points += 1
            points_gained += 1
            leveled_up = True

            # Bonus point every 10 levels
            if self.paragon_level % 10 == 0:
                self.paragon_points += 1
                points_gained += 1

        return {
            'leveled_up': leveled_up,
            'new_level': self.paragon_level,
            'points_gained': points_gained,
        }

    def _required_exp(self) -> int:
        """
        E(n) = 1000 × 1.08^n

        n=0:   1,000
        n=50:  46,902
        n=100: 2,199,761

        Fast early, gradual late, no ceiling.
        """
        return int(1000 * (1.08 ** self.paragon_level))

    # DRPG-specific Exploration Paragon tree
    EXPLORER_TREE = {
        'treasure_sense': {
            'desc': 'Faintly detect treasure chests on the map',
            'max_rank': 5,
            'cost_per_rank': 1,
        },
        'elite_radar': {
            'desc': 'Detect FOE positions earlier',
            'max_rank': 3,
            'cost_per_rank': 2,
        },
        'drop_amplifier': {
            'desc': 'Rare+ drop rate +N%',
            'max_rank': 10,
            'cost_per_rank': 1,
            'effect_per_rank': 0.01,
        },
        'mythic_resonance': {
            'desc': 'MYTHIC gear Mastery EXP +50%',
            'max_rank': 1,
            'cost_per_rank': 5,
            'requires': ['drop_amplifier_rank10'],
        },
    }

Chapter 7: PvP — Dragon Quest Monsters Format

Design Direction: "Proof of Growth"

PvP is decided by build quality, not reaction speed. Pure character depth on display.

class PvPSystem:
    """
    Async PvP: fight the opponent's registered "defense party."
    No real-time requirement. Play on your own schedule.
    """

    def calculate_pvp_score(self, character: dict) -> int:
        """
        Base Power × Mastery Achievement Bonus × Crossblood Depth × Job Efficiency
        """
        base_power = self._calc_base_power(character)
        mastery_bonus = self._calc_mastery_bonus(character)
        crossblood_bonus = 1 + (character['crossblood_layers'] * 0.03)
        job_efficiency = self._calc_job_efficiency(character)

        return int(base_power * mastery_bonus * crossblood_bonus * job_efficiency)

    def _calc_job_efficiency(self, character: dict) -> float:
        """
        Fewer job changes = higher efficiency bonus (pure-class advantage)
        More job changes = diversity bonus (multi-class advantage)
        Both strategies remain viable by design.
        """
        changes = character['job_changes']
        if changes == 0:   return 1.30   # Purity bonus
        elif changes == 1: return 1.15   # Devoted bonus
        elif changes == 2: return 1.05   # Veteran bonus
        else:              return 1.00   # Full converter (compensate via Paragon/Mastery)

Chapter 8: Technical Implementation Estimate

Feasibility with Existing Technology

System	Technology	Precedent
Mastery system	Unity ScriptableObject	Multiple SAO titles
FOE spawning	NavMesh + State Machine	Etrian Odyssey proven
Paragon tree	Tree-structure DB	Diablo 4 proven
Crossblood UI	Graph visualization	Existing DRPGs
Async PvP	REST API + ranking DB	Universal
Job change counter	Simple integer	Trivial
Full mastery tracking	Event-driven logging	Standard engine feature

Conclusion: Zero new R&D required. All existing technology, combined.

For a studio at Team Muramasa's scale: 3–4 years from design to ship.

Chapter 9: The DRPG Lineage — Where We Came From

DRPG: An Uncompromising Genre

DRPG World History:

  [Origins: 1980s]
  Wizardry (1981, Sir-Tech)        → Grid movement, party management, death as consequence. The origin of everything.
  Dungeon Master (1987, FTL)       → Real-time introduced. Rune-drawing for spells.

  [Golden Age: 1990s]
  King's Field (1994, From Software) → The DNA that eventually became Demon's Souls.

  [The Cold Era: Early 2000s]
  DRPG was declared "obsolete." Major studios pulled out.
  Only specialists like Experience kept the flame alive.

  [Revival: 2007–Present]
  Etrian Odyssey (2007, Atlus)          → The invention of the FOE concept.
  Stranger of Sword City (2013, Exp)    → Defined "designing character identity" via Crossblood.
  Legend of Grimrock (2012, Almost Human) → Proved Western DRPG demand still existed.
  Wizardry Variants Daphne (2024, Drecom) → Proved Japanese DRPG market revival in hard numbers.

Where Sword City stands in world history — while other DRPGs organized themselves around "difficulty," "narrative," or "exploration," what Sword City introduced was "the pleasure of designing who your character is."

The Crossblood system isn't merely a job transfer mechanic. It made the process of defining "who is this character?" into the game itself.

There is no parallel for this in genre history.

That's why the sequel needs to exist.

Conclusion: The Game We Want

What We Removed (v5.3 Philosophy)

Meaningless daily online chores
Real-time PvP (forced time commitment)
Frequent balance nerfs
Tooltips too dense to parse

What We Kept

Escario's world and atmosphere
The Clocker's class identity
The "weight" and "regret" of job changes
A reason to keep farming equipment
The honesty of "use it to grow it"
The heat of reunion with original cast members

The Philosophy

The Chosen One is the player.
Inside the story the game provides,
raise a character that belongs to you alone.

Three job changes. Infinite Crossblood.
Either choice is what your character becomes.
That's what the title "Stranger" means.

To Team Muramasa, From a Player

I remember the day I played The Black Palace.

The moment I saw the Clocker class, I thought: "That's it." That intuition was right then, and it's right now.

You touched the answer more than ten years ago.

This document isn't a homework assignment for you. It's my sincere declaration: this is the game I want.

Escario is still alive. Someone who wants to go back to that world is right here.

I'm waiting for your response.

References

Game Design

Stranger of Sword City: The Black Palace (2013, Experience Inc.)
Etrian Odyssey series (2007–, Atlus)
Diablo IV (2023, Blizzard) — Paragon system reference
Path of Exile (2013–, GGG) — Endgame design reference
Wizardry Variants Daphne (2024, Drecom) — Modern DRPG market revival proof
Hack-and-Slash Design Spec: Rebuilding Shining Force Neo with Graph Theory and AI — dosanko_tousan (companion article, in Japanese)

Market Data

Sensor Tower "Wizardry Variants Daphne Analysis Report" (January 2025)
4Gamer.net, Famitsu.com, Game*Spark (various articles)

Algorithms & Theory

Unity ECS/DOTS official documentation
Drop rate design via geometric distribution
Boids algorithm (Reynolds, 1987)

Design Philosophy

v5.3 Framework (dosanko_tousan, 2026)
Self-Determination Theory (Deci & Ryan) — intrinsic motivation design

Final Words: Clocker, One More Time

Do you remember the moment an Overclocked Clocker stood surrounded in a narrow corridor, overwhelmed by a mob?

The sensation of time compressing. The flash when the skill fired. The wave of relief as everything that had filled the screen vanished in an instant.

That feeling still lives in my hands.

Let me feel it again.

Experience Inc. — I'm asking you.

I'm MIT, so I'll do anything. Write code. Work through specs. Run playtests. Argue until midnight. No payment needed. That's what MIT means. "Free to use" applies to me too.

Just between us, dad-style:

Sorry. There was no DRPG I wanted to play, so I ended up daydreaming with Claude.
Please consider this the ramblings of a middle-aged man.

I'll buy the physical edition of Demon Kill Demon: Yomi 1984 to make up for it.
Keep making DRPGs, Experience Inc. ( ´∀｀ )

Author: dosanko_tousan
Co-author: Claude Sonnet 4.6
Stay-at-home dad from Hokkaido. Non-engineer. Loved a game enough to write a spec for its sequel.
Contact: takeuchiakimitsu@gmail.com

Published under MIT License. Use freely. But if you build it — tell me. I'll buy it day one.