Ranbu— Hybrid Action Game<developing>

R

anbu is a hybrid action game project centered on the theme of misunderstanding, judgement, and the difficulty of truly understanding another being. The core idea comes from a simple question: if even a lion could speak, would we really be able to understand it?

In this project, I wanted to explore how action combat could represent the process of observing, misjudging, learning, and finally understanding an opponent. Instead of treating enemies as simple targets to defeat, Ranbu frames combat as a process of interpretation. Players are not only reacting to enemy attacks, but also collecting information, testing assumptions, and deciding when they have understood enough to make a decisive move.

Project Overview

Genre: Hybrid Action / Combat Prototype

Engine: Unity

Role: Combat Designer, System Designer, Programmer

Focus Areas: Combat systems, enemy behavior, player decision-making, prototype implementation

The game combines real-time action combat with a turn-based judgement phase. In real-time combat, the player observes enemy patterns, dodges attacks, manages positioning, and looks for openings. As the player gains enough understanding of the enemy, combat can shift into a more deliberate turn-based phase where the player makes tactical decisions based on the information they have collected.

This structure allows the game to move between two different emotional states:

Real-time combat represents uncertainty, pressure, and incomplete understanding.Turn-based judgement represents analysis, interpretation, and the moment when the player believes they understand the opponent.

Design Goal

The main design goal of Ranbu is to make combat feel like a process of reading another being.

Many action games ask the player to learn enemy patterns, but that learning process usually remains purely mechanical. In this project, I wanted to connect that familiar action-game experience to the narrative theme. The player’s understanding of an enemy becomes both a combat resource and a thematic expression.

The design is built around three key ideas:

Design Pillar	Purpose
Observe	The player studies enemy attacks, movement, and behavior.
Interpret	The player forms assumptions and gains “Tokens” based on what they notice.
Judge	The player uses collected information to enter a decision phase and execute a strategy.

The important twist is that judgement is not always perfect. Tokens help the player understand an enemy, but they can also represent labels or incomplete assumptions. Against simple enemies, these labels may be enough. Against stronger enemies, especially bosses, relying only on surface-level interpretation can lead to failure.

Core System: Judgement and Tokens

The central combat system is built around Judgement.

In Ranbu, judgement has two meanings. It can mean making a decision, but it can also mean passing judgement on something without fully understanding it. This double meaning became the foundation of the combat system.

During real-time combat, the player can gain different types of Tokens by successfully responding to enemy behavior. For example, a token might be earned by blocking a specific attack, dodging at the right timing, or recognizing a repeated pattern.

These Tokens can then be used during the judgement phase to unlock stronger options, expose enemy weaknesses, or influence the outcome of a tactical exchange.

However, Tokens are intentionally not treated as absolute truth. They are fragments of understanding. They help the player build a rough outline of the enemy, but they do not necessarily reveal the full picture.

This creates a design space where the player must ask:

Do I understand this enemy well enough to act, or am I only relying on a convenient label?

Combat Flow

The basic combat loop is designed as follows:

1. Real-Time Engagement

   The player fights the enemy in real time, focusing on movement, dodging, blocking, positioning, and reading attack patterns.

2. Information Gain

   Through successful reactions or specific combat choices, the player gains Tokens that represent partial understanding of the enemy.

3. Stagger / Understanding Threshold

   Once enough information has been collected, the enemy reaches a state where the player can trigger a judgement phase.

4. Turn-Based Judgement Phase

   Combat shifts into a tactical decision space. The player spends Tokens, chooses actions, and attempts to make the correct judgement.

5. Execution or Consequence

   If the player’s judgement is accurate, they can deal major damage or create a decisive advantage. If the judgement is flawed, the enemy may resist, counter, or reveal that the player’s assumption was incomplete.

This structure lets the game combine the physical intensity of action combat with the mental pressure of interpretation and decision-making.

Enemy Design

Enemy design in Ranbu is built around how easily an enemy can be understood.

Simple enemies are designed to be readable. They have clear patterns and can often be defeated once the player identifies the correct Token. These enemies represent surface-level categorization: once the player understands the “type,” they can respond effectively.

Boss enemies are different.

Bosses are designed to resist simple labeling. They may disguise their intentions, change behavior after being read, or punish the player for relying too heavily on one interpretation. This creates a stronger connection between mechanics and theme: powerful enemies are not just harder because they have more health or damage, but because they are harder to truly understand.

For example, a boss might appear to follow a recognizable attack pattern, encouraging the player to make a quick judgement. Later, the same boss may break that pattern, revealing that the player’s previous understanding was incomplete.

This supports the project’s core theme: labels can help us approach the unknown, but they are not the same as true understanding.

Player System

The player character is designed around flexible combat responses.

The current system direction includes:

Player Action	Design Purpose
Basic Attacks	Maintain pressure and build combat rhythm.
Dodge / Movement	Create spacing and reward timing.
Block / Parry Response	Reward precise reading of enemy attacks.
Token-Based Skills	Let players convert observation into advantage.
Judgement Trigger	Shift combat from real-time pressure into tactical decision-making.

The goal is not to overwhelm the player with too many mechanics, but to make every action contribute to the larger loop of reading, understanding, and judging.

Technical Implementation

As the project’s designer and programmer, I focused on building the combat prototype in a way that supports iteration.

The system is planned around modular components:

System	Implementation Goal
Player Controller	Responsive movement, attack input, dodge, and defensive actions.
Enemy AI	Behavior states such as patrol, detection, attack, retreat, and pattern adjustment.
Token System	Track information gained from combat interactions.
Judgement Phase Manager	Handle transitions between real-time combat and tactical decision phase.
Enemy Pattern Database	Define attack groups, readable behaviors, and reaction rewards.
Combat State Machine	Manage real-time combat, stagger, judgement, execution, and recovery states.

One important technical goal is to make enemy behavior data-driven where possible. This allows different enemies to share the same underlying combat structure while still having unique attacks, Token conditions, and judgement outcomes.

Design Challenge: Combining Real-Time and Turn-Based Combat

The biggest design challenge in Ranbu is making the hybrid structure feel unified.

Real-time action and turn-based decision-making can easily feel like two separate games. To avoid that, the project treats the turn-based phase as a direct result of real-time observation. The player does not enter the tactical phase randomly. They earn it by surviving, reading, and interacting with the enemy correctly.

This means the two systems support each other:

Real-time combat gives the player information. Turn-based judgement asks the player what that information means.

That relationship keeps the hybrid structure connected both mechanically and thematically.

What I Contributed

For this project, I worked on:

• Designing the core hybrid combat loop.

• Defining the relationship between real-time action and turn-based judgement.

• Creating the Token system as both a gameplay resource and thematic metaphor.

• Planning enemy behavior around readability, misdirection, and resistance to simple classification.

• Designing the player’s combat options and progression of understanding.

• Prototyping the system structure in Unity.

• Building technical plans for player control, enemy AI, combat state transitions, and judgement-phase logic.

• Connecting narrative themes directly to combat mechanics.

This project allowed me to practice the kind of system design I care about most: mechanics that are not only functional, but also expressive.

Reflection

Ranbu is a project about action, but it is also a project about perception.

I wanted to design a combat system where “reading the enemy” is not just a player skill, but the central language of the game. The player fights by observing, interpreting, and making decisions under uncertainty. Sometimes that judgement is correct. Sometimes it is incomplete. That tension is where the project becomes interesting.

Through this project, I explored how combat design can carry narrative meaning without relying only on dialogue or cutscenes. The result is a system where every dodge, block, Token, and judgement phase contributes to the same central question:

How do we approach another world when complete understanding may be impossible?

For me, Ranbu is an attempt to turn that question into gameplay.