Kung Kong

Kung Kong is a intense pick-up & play arcade game that blends Pong and Air hockey to create a new, intense and fun gameplay experience!

Role

Gameplay designer - Co-scripting

Team size: 4 Students (2 Designers, 1 Programmer, 1 2D Artist)

Engine: Unity

Production Time: 2 Weeks

Platform: PC

Project Overview

Kung Kong is a local multiplayer arcade gameinspired by classics like Pong and air hockey, designed to be fast, readable, and fun both to play and to watch.

The goal was to create a easy to pick-up-and-play experience where players immediately understand the game, but still find depth through speed, feedback, and mastery.

Design Goal

Our Main challenge was:

How do we evolve a familiar concept into something that feels fresh and engaging?

We didn’t want to overcomplicate the idea. Instead, we focused on making the game feel fast, clear, and satisfying, both for the players and for people watching.

That became the foundation for everything we built.

My Role & Contribution

My role was a mix of design, scripting.

I helped shape the overall direction of the game, what it should feel like, what we should prioritize, and what we should cut. From there, I worked hands-on with gameplay systems, scripting, and testing, while also making sure the team stayed aligned.

Because the project was only two weeks long, a big part of my job was making sure we didn’t lose focus.

Core Design Pillars

Fast-Paced Gameplay
Strong Audio Feedback
Vibrant Visual Identity
Clear Player Feedback

These pillars guided every design decision throughout development.

Gameplay Design Breakdown

Instead of adding lots of mechanics, we focused on making a few things feel really good.

One of the most important systems was the ball behavior.

Each time the ball was hit, it increased slightly in speed. Over time, this created a natural build-up of tension in every match.

On top of that, we added stronger feedback for specific actions, like successful serves, where the ball would suddenly gain a large burst of speed. This created moments where the pace of the game would spike and force players to fully focus.

We turned a simple mechanic into something that constantly escalated.

Readability & Feedback

A big part of making the game feel good was feedback.

Instead of relying only on UI or effects, we used the player characters (the monkeys) as a core part of that feedback.

I worked closely with our 2D artist to shape how they behaved. We wanted them to:

React clearly to what was happening
Show emotion in a readable way
Reinforce player actions

So when something happened in the game, the player didn’t just seeit, they feltit through animation, sound, and timing.

For example:

Getting hit had a clear, expressive reaction
Failed actions showed frustration
Successful hits had stronger, more energetic feedback

All of this helped make the game more readable and more satisfying.

Designing for Spectators

From early on, we also designed Kung Kong as something that should be fun to watch, not just play.

The game was set up to be played on two screens placed on a table, encouraging people to stand around and engage with it together.

That influenced a lot of our decisions:

Bright, high-contrast visuals
Strong, exaggerated feedback
Fast-paced gameplay that creates exciting moments

The goal was:

Even if you’re not playing, you should still be engaged

Iteration & QA

With only 2 weeks of production, efficiency was critical.

I led QA by:

Testing new features and changes continuously
Documenting bugs and gameplay issues
Coordinating fixes with the team

With only two weeks, iteration had to be fast and focused.

I spent a lot of time testing the game as we added features, trying to break things, finding issues, and making sure everything still worked together.

One of the most interesting moments came from a bug.

Players could hit the ball at a very specific angle into a wall and create a much stronger shot than intended.

At first, this was something we could have removed. Instead, we tested it more and realized it added something valuable, it rewarded skill and gave players something to master and after discussing it we decided to keep it.

Embracing Emergent Gameplay

One of the most interesting moments during development came from something we didn’t plan.

During testing, I discovered that if you hit the ball at a very specific angle into the wall, you could create a much more powerful, high-speed shot. At first, this was just a bug, and we already had a fix for it.

Instead of removing it immediately, I spent some time testing it further. The more I played with it, the more it felt like something valuable. It rewarded precision, added a layer of mastery, and gave experienced players a way to push the system further.

After discussing it with the team, we decided to keep it.

What started as a bug became a small but meaningful mechanic, a “trick-shot” that added depth to the gameplay and gave players something to discover and improve at.

What I Took Away

Working on Kung Kong taught me how much impact small design decisions can have, especially in a short project.

Instead of adding more, we focused on refining what we had:

Making feedback clearer
Improving pacing
Adjusting small details that changed how the game felt

It also reinforced how important it is to stay focused. With limited time, having a clear direction made the difference between something messy and something polished.

Final Thoughts

Kung Kong is a simple game on the surface, but it works because everything supports the same goal: fast, readable, and satisfying gameplay.

For me, this project was about:

- Knowing what to prioritize
- Iterating quickly
- Recognizing when something unexpected (like a bug) actually improves the experience

CV