Forem: Kenji | Unity Game Dev

Practical Workflow for AI Pixel Art: Gemini 2D Animation Experiment

Kenji | Unity Game Dev — Sat, 14 Mar 2026 21:56:29 +0000

For this experiment, I summarized the workflow of using Gemini's image generation model, "Nano Banana 2," to generate sprite sheets for a 2D action game and implement them into Unity, along with tips to stabilize the output. To jump straight to the conclusion: the results were far more practical than expected.

// Detect dark theme var iframe = document.getElementById('tweet-2032170858035257577-727'); if (document.body.className.includes('dark-theme')) { iframe.src = "https://platform.twitter.com/embed/Tweet.html?id=2032170858035257577&theme=dark" }

【The Prompt Used】

//{Prompt}
//2D side-scrolling pixel art style (dot-picture).
//Only requires the side view; no other directions.
//Create a female sword-wielding protagonist with long red hair.
//The style should be RPG-like, a fusion of medieval and modern fashion, making it cute.
//The character naturally has red hair, which changes to platinum blonde when holding a sword. 
//Include a visual sequence for the transition from red to platinum blonde while drawing the sword.
//Must include the following actions:
//1. Idle Action
//2. Attack Actions (Combo 1,2,3)
//3. Walking/Runing Action
//4. Death Action
//5. Action of eating a steamed bun
//Pure black background for all of the above actions.
//Each action must have its corresponding animation frames.

【Basic Action Generation and the Strength of the "Infinite Gacha"】

First, regarding basic motions like idling and walking. In this regard, Gemini handles the task perfectly.

The biggest advantage of using Gemini is that you can endlessly "pull the gacha" (regenerate) up to 100 times a day until you are satisfied. The consistency of the character design is also exceptionally high; by continuing the chat, you can successively derive different action modules based on the same character.

Furthermore, based on a generated image, you can give instructions like, "Keep this part unchanged, but fix only this specific area." This makes it possible to repeatedly make minor adjustments while maintaining the overall design and vibe of the character. When creating a series of motions for the same character over the long term, this feature is indispensable.

【Challenges and Limitations of Complex Attack Combos】

While simple movements are perfect, once you specify "complex and continuous actions" like attack combos, it suddenly becomes difficult to maintain movement consistency.

Countermeasures and Compromises:

Instead of trying to generate complex actions in a single shot, break down the flow and give instructions frame by frame.
Subdivide the prompts into steps like "raise the sword" and "swing down," and relentlessly regenerate (loop) like a gacha game until you pull an output that is closest to your ideal.

While there is still significant room for improvement in the overall fluidity of the animation, looking at it frame by frame reveals pixel art of more than sufficient quality. Sometimes, it even renders effects that can be used directly as VFX.

Background Transparency Workflow (Black Background + Photoshop)

A clear issue at this point is that the AI alone cannot directly output a "PNG image with a transparent background."

Countermeasure:
Forcefully instruct the prompt to "make the background completely black (or a solid color like green)." After that, bring the generated image into a tool like Photoshop and manually cut out the black background to apply transparency. It takes a bit of extra effort, but this is the most reliable method at present.

Summary

Pros:

Simple movements (idle, walk, etc.) can be generated perfectly while maintaining consistency.

By continuing the chat, you can mass-produce derivative motions of the same character.
Partial modification instructions are possible while preserving the base image.

Cons (Challenges):

It is difficult to maintain continuity for complex actions (combos, etc.), requiring frame-by-frame instructions and trial-and-error (gacha).
Since it cannot output with a transparent background, specifying a solid color background and manually cutting it out with an external tool is mandatory.

While still in the trial-and-error stage, it already has sufficient potential as a tool to dramatically speed up prototype production. I plan to continue verifying and testing this going forward!

X (Twitter): @kenjiDev9662 (I post daily devlogs!)
Portfolio: KenjiDev Portoflio
GitHub: Github@Kenji966
BLUESKY: @kenjidev9662 (I post daily devlogs!)
🇯🇵 Japanese Post (Zenn): Zenn@kenji966

Designing Instant Impact: How I Used Shader & URP to Craft the Rhythm of a Dash Attack

Kenji | Unity Game Dev — Sun, 08 Feb 2026 23:23:26 +0000

✦ Preface | I Don’t Know Shaders—But I Know When It Needs to “Feel Right”

From the start, I never intended to make purely decorative effects.
What I wanted was for players to instantly feel what the character was doing with every action.I’ve never formally learned shaders. This was my first time touching URP as well. My approach was simply:

Watching how the values in the inspector changed
Keyframing animation frame by frame
Experimenting with whatever tools I had on hand, cobbling things together through trial and error.

So the whole dash attack sequence is built on a set of “unconventional,” but practical, techniques.

✦ Starting Out: The Character Instantly Disappears

When the Dash begins, I didn’t just want to stretch out an animation—I wanted the whole character to vanish.

I created a float parameter called _Alpha in the shader graph and used the Animator to control this value.

When the character disappears, the scene naturally enters an “unexpected” moment of empty space—a brief pause that hints at what’s coming next.
It wasn’t about making things flashy, but rather creating the illusion of a real, sudden dodge—breaking the usual rhythm and making the player subconsciously tense up.

✦ Fisheye with URP: Creating Momentum Visually (Not with Sound)

When the dash starts, I added a fisheye squeeze effect to the center of the screen using URP’s post-processing volume.
This wasn’t a visual gimmick—it was about “tightening the space” to signal: “Now comes a fast movement.”

The effect is: “character disappears → screen compresses → camera zooms in”—a transition from stillness to motion.

✦ Reappear & Attack: Sudden Entrance + Camera Closes In

The end of the dash isn’t at the starting point—it’s in front of the enemy.At the moment the character reappears, I swapped in a different shader with a glowing edge, as if a flash of light bursts out, and the screen shakes slightly.For the camera, I didn’t use a binding method to lock it to the character. Instead, I wrote a script that constantly calculates the character’s position and uses slerp to move towards it.
So when the character teleports in front of the enemy, the camera doesn’t just hard cut—instead, it slides smoothly to the new target, making it feel like you’re right behind the character, delivering the hit.

Vector3 targetPosition = Vector3.Lerp(transform.position, targetTransform.position, delta / followSpeed);
transform.position = targetPosition;

“I didn’t use a binding method to lock the camera, but scripted it to constantly track the character’s position and slerp over.”

This approach is built into the entire camera system as “calculated tracking”—the dash just causes the camera to slide naturally to a new spot, creating a bonus effect: the camera smoothly sticks back to the character.

Finale: Resetting Everything, Letting the Rhythm Calm Down

Finale: Resetting Everything, Letting the Rhythm Calm DownAfter the attack, all shader and volume effects are removed, the character returns to an idle pose, and the scene becomes still—no extra movement.This calm isn’t any technical trick; it’s about bringing the rhythm down, letting the player know: “The move’s finished, it’s your turn now.”

Development Process: Iterative Experimentation

The entire flow didn’t use Timeline or any fancy VFX tools. I simply:

Used the Animator to control material float values;
Used shader dissolve for the death effect, slowly fading the character out;
Managed all shader states with a custom material controller script;
Implemented transparency, flashing, and dissolve just by swapping shaders/controlling values.

//Normal Mode
public Material[] PlayerNormalMaterialList;

//Attack Mode
public Material[] PlayerAttackMaterialList

To avoid hardcoding during implementation, I used a separate material for each state. This way, switching effects just takes a single line, and future tweaks are easy.

I didn’t have a complete VFX pipeline. Everything came from experimentation, observation, breaking things down, and putting them back together.

✦ My Effects Aren’t Design—They’re About Making the Action Feel Right

I don’t really see myself as doing “visual design”—what I’m actually doing is deconstructing the feel of the action on screen.For example:

Start → character vanishes (stillness + squeeze)
Reappear → attack (entrance + camera zoom + FX)
End → reset (scene goes still)

Each part is something I tried out by feel, always asking myself: “Does this bit feel right? Is it clear enough?”

✦ My Effects Aren’t Design—They’re About Making the Action Feel Right

This dash combo definitely isn’t industry-standard VFX. It’s something I figured out, step by step, by picturing it in my head.I don’t know how to write shaders, but I know how to make things make sense;

I don’t have an artistic sense, but I know when there needs to be a “key moment” on screen;

I don’t rely on prebuilt tools—I build up the rhythm step by step.If you’re a beginner, a solo dev, or just unfamiliar with shaders—but you have a vision, intuition, and imagination—you can absolutely create your own sense of impact too.

This post builds on the main RPG development log.
For the full story and system overview, read the main post here:

My RPG Battle System Development Log

📬 Connect with me

HI I’m Kenji, a Unity Dev & Technical Designer with a background in AR, Motion Games & WebGL.
Currently experimenting with diverse Unity tech (Action, VFX, Shaders) and logging the R&D process. Follow for daily devlogs!

I am currently open to new opportunities (Remote / Japan / UK). If you are looking for someone who bridges the gap between Code and Art, let's talk!

BLUESKY: @kenjidev9662 (I post daily devlogs!)
X (Twitter): @kenjiDev9662 (I post daily devlogs!)
Portfolio: KenjiDev Portoflio
GitHub: Github@Kenji966
🇯🇵 Japanese Post (Zenn): Zenn@kenji966

From Animation to Game Feel: My RPG Battle System Development Log

Kenji | Unity Game Dev — Wed, 28 Jan 2026 12:08:50 +0000

This post records how, while building an RPG prototype in Unity, I integrated character animation, effect systems, combo mechanics, and shader implementation into a cohesive battle scene. Through diagrams, code snippets, and animation breakdowns, I’ll share what I learned through hands-on experimentation.

Preface: This Isn’t Just Testing Hit Effects—It’s an Experiment in Interactive Rhythm

I’ve always been hypersensitive to “action rhythm” and “impact feel.”
It’s not because I’m good at fighting games, but because I always imagine: what if, when a character attacks, the screen could pause, give feedback, or even have a certain atmosphere—wouldn’t that feel more real than just seeing a damage number?That’s why I started making this prototype. I wasn’t aiming to finish a full game, but to construct a system that could hold all the elements of impact design, skill effects, animation combos, feedback, and visual clarity. What follows is a record of my development process.

Part 1: From Animation Design to Combo Flow—How I Structured Character Attacks

Instead of starting from animation design, I began by imagining the rhythm of a three-hit combo in my head:

The first hit is quick, not heavy.
The second hit can link up, but with a slight delay.
The third hit pauses for dramatic effect and visual “pop.”

I used Unity’s Animator to assemble different states and set up a combo buffer and animation tags to judge input timing, making chaining natural and error-tolerant. The idea wasn’t just to “play animations,” but to keep the logic between inputs and rhythm under control and visualized.

Part 2: Impact Isn’t Just About Visuals—How I Handled Dash and Magic Effects

When developing the dash attack, I realized just moving the character didn’t convey the feeling of “dashing through” the enemy. So I added:

A fisheye-style camera shader to create a sense of compressed space,
A sword trail shader for afterimages,
Hitstop for that “frozen hit” sensation,
Sound effects and knockback timed together for a sharper sense of contact.

I also tried a “spatial magic” effect—letting the enemy phase through walls, using a custom shader to display their silhouette behind obstacles, as a foundation for future environment-based magic skills.

Part 3: Character Modeling—No Asset Store: I Drew the Hair and Textures Myself

(Vroid) Drawing the main character’s hair

(Vroid) How I painted the face texture

Finished version

I’m not an artist, but I wanted my protagonist to have more personality than just a default model—I wanted them to reflect my own ideas.So I used Vroid Studio for the first time, painting hair layer by layer and designing custom textures.

Layering the hair actually feels a lot like building a character: deciding where the rhythm should be, which edges should be neat, where to express personality. For me, that’s also a part of “impact and rhythm”—just visualized on the character itself.

Part 4: For Maintainability—I Designed a Simple Yet Expandable Battle System

Exposing "Game Feel" variables (frames, distance) to the Inspector allows non-programmers to tweak the combat rhythm without touching the code.

Instead of hardcoding a single fighting character, I thought about how to build a reusable combo/skill system. Key points:

Combo system and input judgment are independent, so different characters can share the same input logic,
Skill execution is stored as ScriptableObjects, allowing new skills to be added dynamically without rewriting code,
Enemy reactions (hitstun / state changes when hit) are a separate reaction system, making it easy to add effects and combo interactions,
All hit detection and reactions can be reused for any character—just swap out the animation or timings.

These four code sections became a sort of “core battle language”—each time I create a character, I can piece together a fighting style like building sentences, not rewriting everything from scratch.

Closing: This Isn’t a Product—It’s a Practice in Understanding Rhythm and Feel

I don’t plan to turn this demo into a finished game, but I do want to use it to build my sense of character movement, skill design, and scene rhythm.

Impact isn’t just about adding effects and sounds—it comes from input rhythm, enemy reactions, animation transitions, and layered visual feedback.This is my current understanding of “battle systems,” and my first action development project that reflects my own logic and style.

Github Link →

Next: For a deep dive into dash attack shaders and animation integration, check out the follow-up post

📬 Connect with me

I am currently open to new opportunities (Remote / Japan / UK). If you are looking for someone who bridges the gap between Code and Art, let's talk!

X (Twitter): @kenjiDev9662 (I post daily devlogs!)
Portfolio: KenjiDev Portoflio
GitHub: Github@Kenji966
🇯🇵 Japanese Post (Zenn): Zenn@kenji966