Kachofugetsu~花鳥風月
—— A turn-based role-playing card strategy game in ukiyo-e art style
Kachofugetsu is a turn-based role-playing memory-match game made in a neo-ukiyo-e art style. The name of the game, Kachofugetsu (花鳥風月), means 🌺flower, 🦜bird, 🌪wind, and 🌙moon in Japanese, which is a poetic symbolization of beautiful nature scenery in Japanese culture.
This game is my solo project where I created every tiny bit of the game from scratch -- I drew the art and VFX, animated the sprites, designed the mechanics, wrote the code, and mixed the background music.
👉Click to Quickly Jump to:
👇Brief Game Intro
In this game, you will play as the protagonist Ishikawa Goemon (the samurai) who challenges the computer AI enemy Fujiko (the lady in kimono).
The goal of the game: Flip the cards, and match as many pairs as possible to damage Fujiko's hitpoints.
Win condition: Drop Fujiko's hp below zero or have higher hp than hers when all cards have been paired.
Punishment: The player who manages to match a pair can give the opponent a makeover as humiliation. The makeover can be a funny wig🤠, or an entire head cosplay🤡.
Special Cards: Flower, bird, wind, and moon cards are special and can trigger special game events.
👇Title Screen
👇Animated Narration
👇Fujiko vs Goemon
👇Tutorial (click arrows for slideshow)
👇Main Game Layout
👇 Gameplay Clips
👇Card Types
There are 18 cards coming in 9 pairs, with 4 special pairs, and 5 normal pairs.
Normal Pairs: each time a normal pair is matched, it deals 3 hp damage to the opponent.
Special Pairs: does something extra beyond a 3 hp damage.
🌺Flower: deals double damage to the opponent (6 hp).
🦜Bird: allows the current player to have one more turn at once.
🌪Wind: shuffles all the unflipped cards.
🌙Moon: heals the current player hp by 3 hp.
👇Card Design
Below are the special card patterns: flower, bird, wind, and moon.
The card patterns are designed to have a relatively intricate depiction compared with normal patterns, with a gradient single-colored background, and to have a Japanese/Chinese character written in calligraphy style.
Below are the normal card patterns: 🍙onigiri (rice balls), 🍵matcha, 🍶sake, 🍡dango (sticky rice ball skewer), and 🌰mochi (sticky rice cake stuffed with sweet paste).
These food and drinks are a good companion when enjoying beautiful nature sceneries.
The cards are designed to have single-colored backgrounds, with a round color patch in either a contrasting or a supplementary color. They have a relatively simpler design than the special cards.
👇Arena Design
Before I started to make this game in Unity, I had a rough concept game board in my head that resembles Hearthstone. However, the decorative part in the concept design outweighs the characters.
As I would like to emphasize more on the player interactions, I shrank the static graphics, added UI/HUD boxes, and allowed more space for characters.
Before
After
👇Humiliation Makeover Design
The makeover is the fun part of this game. Characters have to put on quirky makeups/costumes when their opponent has matched a pair.
I chose 18 references from popular games/films/animations , and implanted them to the characters in an ukiyo-e style as a tribute.
Below are the entire transformations of the characters:
👇Modular Cosmetics Assembly
To add dynamics to the characters, I decided to make them blink. Thus, the characters have to be assembled in layers to be as modular as LEGO blocks.
In my way of assembly, a character is put together in 4 layers: naked face & body, hair, eyes, and wig/makeups.
👀A quick blinking example:
👇Player Path
As a turn-based game, a flow chart can be presented to describe the gameplay loop of the player.
👇AI Design
🔹Enemy's memory:
* When the player flips 2 cards, the enemy memorizes them.
* When the enemy flips 2 cards by itself, it memorizes them.
* But the enemy's memory can only contain 2 cards. Previous ones in memory will be overwritten by new ones.
* So, when the enemy's turn starts, it will always have 2 cards in its mind, as the player always starts before the enemy.
🔹Enemy's action:
* Enemy will first flip a random card.
* If it matches one of the memorized cards in its mind, and the matched one is flippable, then it will flip that particular card to make a match.
* If the first flipped one fails to make a match, it will flip another random card to complete this turn.
👇Programming Construction
I love Unity for its component-based fashion. Thus, before I started to program, I have planned out several empty game objects that make up the overall structure. These important components include:
* Game Manager: a third-person general manager that controls game states, and give commands to delegates.
* Card Server: deals with affairs related to cards. It serves cards at the start, shuffles cards when the wind is paired, collects the status of all the cards, and sends card data to other managers.
* Player Agent: receives player input, updates player stats, and distributes player data to other managers.
* Enemy Agent: receives enemy input, updates enemy stats, and distributes enemy data to other managers.
* UI Manager: receives player and enemy state data, changes the UI accordingly, updates Hotpoint display, VFX, and humiliation looks.
* Cosmetics Manager: is a delegate of the UI Manager. It receives commands from the UI Manager, and implements the humiliation looks by changing the sprites accordingly.
* Dialog Manager: is a delegate of the UI Manager. It receives commands from the UI Manager, and displays the dialog when necessary.
Other than the empty objects above, I also have sprite entities with scripts attached, to fulfill the visuals.
*Card: each card has a uniform card script which stores whether this particular card can be flipped, controls the glow emission when the card is hovered on, implements the flip animation coroutine, and moves the card when shuffling happens.
* Slash: is a game object duo used to create a slash visual effect on the hitpoint box when the player is hurt. When a slash effect happens, the slash object along with the trail effect will move to a certain point to create that slash visual. This is implemented by coroutines.
* Swirl: is a sprite object that rotates and shrinks to create a shuffling swirl effect when a wind pair is matched. Also implemented by coroutines.
* There are also other miscellaneous VFX objs.
👇Coding VFX
👇Finally
I hope you like my work🙌!