Roll-a-Ball: Introduction to Game Development

 Overview

This post serves as an introduction to game development in Unity, using the Roll-a-Ball tutorial as a foundation. The purpose of this exercise was to understand the basics of creating game objects, adding components, working with prefabs, scripting, and designing simple levels. This mini-project provided essential knowledge that will be applied to my main game development project for the VIA Arcade Machine in the XR Lab (which I already have the idea :D).

Core Mechanics

  • Physics-based movement: The player sphere uses a Rigidbody component to enable realistic movement.

  • Player input handling: Implemented through Unity’s Input System, allowing responsive controls.

  • UI and score tracking: TextMeshPro displays the player's collected items and if the player wins or loses dynamically.

  • Game logic: A win condition triggers when all collectibles are picked up.



This first picture is the script that allows a "PickUp" object to be picked up by setting the gameObject to false, making it dissappear when colliding with the player and incrementing a counter. 


This second picture is the script that shows the counting text and, when the winning condition is met (23 "PickUp" gameObjects have been picked up), a win text is shown and all the gameObjects with the "Enemy" tag are destroyed.

To keep the player visible at all times, I implemented a camera-follow script:

  • It maintains a fixed offset from the player, preventing erratic movements.


Creating and Managing GameObjects

  • Understanding GameObjects: Everything in Unity is a GameObject, and learning to attach components to modify behavior was the main takeaway from this mini-project.

  • Materials & Customization: I learned how to create and apply materials to objects, giving them different visual styles.

  • Using Prefabs: I created reusable PickUp, Enemy and Dynamic Obstacle prefabs that could be  reused in the scene easily.


Expanding the Game with Zones & Obstacles

After implementing the base Roll-a-Ball mechanics, I explored level design by adding different areas and obstacles, but not so much since I want to spend most of my time in the actual project. Below you will find a snapshot of how the final game looks:

  • Barriers and walls: Added to create more structured gameplay and challenge.

  • Ramps and a "window".




Next step

For the next blog post, I will show the main game design documentation and milestones. It will guide my game implemententation and it will show 3 important milestones for my game development process. 

Comentarios

Publicar un comentario

Entradas populares de este blog

Enemy AIs, UI logic and Adjusting Weapons Architecture

Imagen
NavMesh 2D, Changing Weapon's Architecture, and Implementing first UI For this blog post, I started by cleaning up the weapon system, then gave the enemies some actual AI, and implemented a Pause Menu. A Cleaner Way to Handle Guns At first, the weapons were just hardcoded actions. One script, one gun. But that wouldn’t scale, and it was starting to get messy. I was having some other problems as well, specially when grabbing and dropping the gun, because (for some reason), clones of the GameObject were being created instead of using the original. So I decided to restructure it using an abstract class called "GunBase". Every weapon now inherits from it and implements its own "Shoot()" method and other characteristics a weapon has (ammo, icon, audio, etc). For example, the pistol and machine gun now share the same structure but behave differently (semi-auto vs. full-auto). There’s also built-in logic for ammo, bullet speed, and reloading.  This approach makes i...
Leer más

Core Gameplay Prototype

Imagen
Introduction So far, I’ve been building the foundation of the game by getting the core gameplay running: movement, shooting, and bullet ricochets. These mechanics define the entire feel of the game, so I wanted to make sure I nailed the basics before diving into level design or AI. Movement & Rotation I started by implementing 2D movement using Unity’s new Input System. The player can move using a joystick or keys, and optionally rotate toward the aim direction (in my current setup, that’s the mouse). A key aspect of the experience is that the player always faces where they’re aiming or moving, which makes the action feel more responsive. If you’re holding the "aim" button, the character rotates toward the cursor. Otherwise, the player rotates automatically based on movement direction. Shooting System & Bullet Behavior Next came the shooting system. Once the player picks up a gun, they can shoot in their current facing direction. Bullets are instantiated slightly ahea...
Leer más

Final Game and Conclusion

Imagen
What I Built and How I Did It Throughout the development process, I got to work across nearly every Unity system: Scripting : I wrote dozens of custom scripts using to manage weapons, enemies, player controls, pickups, and more. I also used coroutines for actions like rolling invulnerability or UI transitions, and relied on Unity events to communicate between systems (like triggering win conditions when all enemies are dead).  Input & Vectors : I implemented the new Input System , allowing for both keyboard and arcade stick integration. Movement and aiming are handled using vectors to rotate the player or calculate bullet direction with precision. Physics : All movement and combat use Unity’s 2D physics engine . I configured rigidbodies , colliders , and triggers to manage everything from bullet impacts to object pushing. Careful layer setup and tag filtering helped prevent unwanted collisions (like enemies accidentally killing each other). Graphics & Audi...
Leer más