Responsive mobile gameplay
A major focus was creating controls that felt immediate and satisfying on a mobile device. Since the game was inspired by fast-paced arcade gameplay, the player's movement needed to feel readable and reactive.
Back to projects
University project
Reincarnated as a Bird, Now I Am on the Run from the Cops
A 2D mobile endless runner made in Unity by a team of six over 10 weeks.
RoleProgrammer
EngineUnity
LanguageC#
FocusGameplay and UI systems
In motion
Gameplay and systems
Selected moments from the team's gameplay recording, showing the systems and player-facing features in context.
Overview
Project concept
RBRC is a 2D mobile game developed in Unity by a team of six over 10 weeks. The player controls a bird escaping from the police while avoiding obstacles, surviving hazards, and moving through a fast-paced side-scrolling environment.
The project focused on creating a fun and accessible mobile gameplay experience with responsive controls, readable action, and a simple loop that players could understand quickly.
Role
What I worked on
In this project, I was responsible for programming and worked on several of the game's core systems in Unity. Since this was one of my first group projects, it gave me experience both in implementing gameplay features and in developing systems that had to work together as part of a larger team production.
My work included implementing and refining parts of the game flow, such as menu navigation, UI-related systems, gameplay behaviour, and player-facing features. I also worked with testing, debugging, and iteration to improve stability and make the game feel more coherent and functional as a complete mobile experience.
In addition to gameplay programming, I was involved in integrating and working with assets, interface elements, and other technical parts of the project inside Unity. This project became an important step in developing my understanding of team-based game development, especially how programming supports both the player experience and the overall structure of the game.
Design focus
Core pillars
Clear gameplay systems
My programming work aimed to support simple but reliable systems that could be expanded during development. This helped the team test ideas quickly and build the overall experience more efficiently.
Arcade-style pacing
The game was designed around a fast and accessible loop. The player should quickly understand the objective, stay engaged through movement and obstacles, and feel encouraged to try again for a better result.
Implementation
Technical contributions
Player-facing gameplay
Implemented and refined gameplay behaviour so the player experience felt responsive, readable, and suitable for short mobile play sessions.
Game flow and UI
Worked on menu navigation and interface-related systems that supported the game's start, options, statistics, and moment-to-moment flow.
Unity integration
Integrated assets and connected systems inside Unity while making practical decisions around scope, time, and team needs.
Testing and iteration
Tested features, debugged issues, and adjusted behaviour throughout development to make the final prototype more coherent and stable.
Process
Implementation notes
Player and gameplay systems
A large part of my contribution involved implementing and refining the game's core gameplay systems. My goal was to make the player experience feel responsive and readable, while keeping the systems flexible enough to be adjusted throughout development.
Iteration and testing
Because the game was developed in a short time frame, iteration was an important part of the process. I regularly tested features, adjusted gameplay behaviour, and debugged issues to improve both functionality and feel.
Working in Unity
Since the project was built in Unity 2D, I worked directly with the engine to integrate mechanics, connect systems, and support the game's moment-to-moment flow. This also meant making practical decisions based on scope, time, and what created the best result for the player.
Code samples
Selected C# systems
Excerpts from systems I contributed to during the project, lightly trimmed for a focused portfolio presentation.
BirdControllerVer3.cs
Responsive flight and pacing
Keeps the bird within the camera bounds, turns input into immediate vertical motion, and gradually increases the runner speed based on distance travelled.
private void FixedUpdate()
{
UpdateScreenBounds();
if (isFlying && transform.position.y < maxHeight)
{
rigidBody.velocity = new Vector2(
rigidBody.velocity.x,
flapForce
);
}
if (transform.position.y >= maxHeight && rigidBody.velocity.y > 0f)
rigidBody.velocity = new Vector2(rigidBody.velocity.x, 0f);
DataSaver.instance.metersTraveled +=
DataSaver.instance.mps * Time.deltaTime;
DataSaver.instance.mps = startingSpeed
+ accelerationAmplitude
* DataSaver.instance.metersTraveled / 100f;
}BirdShooter.cs
Swipe-to-shoot input
Converts a mobile swipe into a projectile direction, applies a cooldown, rejects backwards shots, and prevents the projectile colliding with the player.
private void Shoot(Vector2 start, Vector2 end)
{
if (Time.time - lastShootTime < shootCooldown)
return;
lastShootTime = Time.time;
Vector2 direction = end - start;
direction = direction.magnitude < minSwipeDistance
? Vector2.right
: direction.normalized;
if (direction.x <= 0f)
direction = Vector2.right;
GameObject projectile = Instantiate(
projectilePrefab,
shootPoint.position,
Quaternion.identity
);
projectile.GetComponent<Rigidbody2D>().velocity =
direction * shootForce;
Physics2D.IgnoreCollision(
projectile.GetComponent<Collider2D>(),
GetComponent<Collider2D>()
);
}LocalizationManager.cs
Data-driven localization
Loads the selected language from a JSON resource, stores it for later sessions, and gives missing keys a visible fallback for easier debugging.
public void LoadLocalizedText(string languageCode)
{
TextAsset json = Resources.Load<TextAsset>(
$"Localization/{languageCode}"
);
if (json == null)
{
Debug.LogError("Localization file not found");
return;
}
localizedText = JsonUtility
.FromJson<LocalizationData>(json.text)
.ToDictionary();
currentLanguage = languageCode;
DataSaver.instance.selectedLanguage = languageCode;
UpdateAllTexts();
}
public string GetLocalizedValue(string key) =>
localizedText.TryGetValue(key, out string value)
? value
: $"[{key}]";Reflection
Challenges
Balancing simplicity with game feel was the main challenge. Because the concept is easy to understand, the quality depends heavily on how responsive and polished the mechanics feel in motion.
The short production period also meant that solutions had to be practical, testable, and possible to improve quickly when needed.
Learning
What I learned
I learned how important it is to make mechanics not only functional, but clear and enjoyable for the player.
I also improved my ability to test and refine systems during development instead of only focusing on the first implementation.
Next steps
Future iterations
If I continued the project, I would spend more time refining the technical structure behind the gameplay systems and improving long-term flexibility.
I would also continue polishing the player experience through iteration, especially in areas where responsiveness, feedback, and balance could be pushed further.
Overall, this project is valuable in my portfolio because it shows my contribution to a complete game project, my role as a programmer in a team, and my focus on building gameplay that supports the player experience.
Explore