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.