Kami-dō (in progress)
Solo turn-based strategy
Tech Designer & Gameplay Programmer
Unity 6
Perforce
Notion
Description
Kami-dō is a strategy game where you play as a paper Samurai, slaying your foes to retrieve the soul of your lost sister.
This game is a post-graduation project made with friends, under the studio Steak Machine Studio.
Communication
-
Large production (18 people)
-
Everyone working remotely
-
No one with prior real professional experience
Main Challenges
Scoping
-
Production time of 3 months
-
Uneven resources depending on departments
-
Very short pre-production time
My work
During pre-production, I was in charge of designing the gameplay and all the mechanics, and prototyping them to make sure they're working well.
I was also responsible for setting up all the pipelines for the Programmers, as well as setting up the workspaces for the whole team (Perforce, Unity and shared spaces).
Here are the main systems I'm currently working on:
Player Input System
We want to have juicy, reactive environments and gameplay elements.
So I created a Player Input Manager:
-
Raycast cursor from camera
-
On new GameObject hovered, trigger OnHoverStart() behaviour, and OnHoverStop() on previous GameObject
-
Event for user click detection
-
Each GameObject handles its own behaviour via the Interactible component
-
Exposed events in inspector make it easy-to-use for Designers
Observations
This would be better by using interfaces implemented more reliably in code, but I wanted an intuitive and easy-to-use tool for the Level Designers. It might make debugging a bit more tedious too.
Aim Assist & Ingredient snapping
Subtitles & Scripted Events systems
-
Created a parameterized trigger box-based modular trigger system for cutscenes and scripted events.
-
Automatically synchronized subtitles with voice lines by hooking into the audio pipeline.
-
Allowed non-programmers (narrative and sound teams) to easily set up events through Blueprints.
-
Allowed subtitles to dynamically adapt to playback timing, increasing accessibility and pacing.
Localized Subtitles Blueprint
Save & Load architecture
Created a modular save/load system using Blueprint interfaces.
All objects have decoupled and scalable save and load implementation.
Utilizing a custom SaveGame Blueprint class for centralized data storage.Allowed uniform saving of game state and player preferences (e.g., options menu).
Localization & Menus
-
Scalable localization with synced Data Tables
-
10 languages on release (subtitles and UI)
-
Fluid menu navigation with independent widgets
Tools & Polish
-
Created tools for debug navigation, screenshot capture, and platform path previews.
-
Improved UX with ingredient hover feedback and persistent options saving.
Turn-based Game State Machine
I implemented a flexible Finite State Machine that handles the logic of the game depending on its state.
Implemented with a State Pattern:
-
Each state is a class deriving from a StateBase abstract class.
They implement the abstract methods BeginState(), Update() and EndState(), as well as individual methods. -
The StateMachine class serves as the context to trigger the different states' behaviours.
-
Each state can request a state change via StateMachine.
Event-Driven Architecture (Mediator Pattern / Event Bus)
-
Centralized communications with a ScriptableObject Event Manager.
-
Decoupling every system through UnityEvent triggers.
-
Simplified iteration by reducing direct dependencies.
Observations
This method is very useful but can get messy pretty fast if there are too many different events and if the communication isn't crystal clear between devs.
But, it is very good for Version Control, since we simply need to create a UnityEvent if needed, and not check out whole classes.
Tiles & Grid System
-
Based on Unity's grids
-
Levels composed of Tile prefabs
-
Easy to modify by Level Designers
-
TileRegistry auto-updates based on modifications, and has public methods such as GetTileAtWorldPosition() or GetAllTiles() to facilitate communication between characters, ingredients and the level
-
Player and enemies auto-snap to Tile center on start
-
Each Tile handles its own state (occupied, free, disabled, etc...)
Cards & Player Movement
-
Card prefab pulls its data from a Card ScriptableObject (visuals, movement pattern, weight, ...)
-
Card Slots instantiate Card prefabs when needed, drawing a random weighted card from the DeckManager static class
-
DeckManager handles the level's Deck (chosen by Designers)
-
Decks are ScriptableObjects, composed of Card ScriptableObjects
HUD Event Dispatcher
One main canvas, with sub-canvases to reduce draw calls and decouple displaying logics.
The UI_EventDispatcher class serves as a relay between the Event Manager and the different HUD elements.
It gives easier control to Designers, as each canvas dispatches events to its elements as it pleases, and is highly modular.
Decoupled canvases
Exposed events to bind easily