What’s in a Game?: My Experience Using Unity for Game Design.

My entry into game development began in seventh grade, prompted by the acquisition of my first personal laptop. My initial efforts were rudimentary, relying less on formal learning and more on informal mentorship from a peer (thanks Salem). This early exploration culminated in a simple, hard-coded physics game—a rolling ball puzzle—that, while functional, was built on a borrowed understanding of the core principles and was more of an asset store flip.

This man is the devil

This period of curiosity soon transitioned into a phase of stagnation I term 'tutorial purgatory,' a common pitfall for self-directed learners. I became proficient at assembling projects from pre-existing tutorials and assets, but this methodology of direct replication cultivated no underlying engineering intuition. My projects worked, but my knowledge was superficial; I could implement a feature, but I could not diagnose or solve a novel problem.

My catalyst for a fundamental shift in my approach was an under-resourced game design course in my sophomore year. The lack of structured challenges for underclassmen created a vacuum of opportunity, which paradoxically became a powerful motivator. In response, my teammates and I initiated an independent project to pursue a more ambitious technical goal. That objective was to replicate the nuanced, physics-based movement mechanics of the Source engine—specifically airstrafing and momentum conservation—within the Unity engine. This endeavor, which became the game Blow Up Your Feet, required moving beyond imitation to deconstruct and re-engineer a specific, tactile 'game feel' from first principles.

The core mechanic of Blow Up Your Feet—locomotion via self-inflicted rocket explosions—immediately rendered Unity's standard CharacterController component obsolete to me. As a kinematic controller that simulates physics rather than participating in the physics engine directly, it was incapable of reacting to the external forces central to the game's design. The only viable path was to architect a custom controller founded upon Unity's Rigidbody component. The initial implementation of the rocket jump mechanic exposed the limitations of Unity's built-in Rigidbody.AddExplosionForce function. Its force falloff model and inherent unpredictability were antithetical to the precision required for a skill-based platformer. To achieve deterministic and responsive propulsion, I engineered a custom impulse system. This involved calculating a pure directional vector from the explosion's origin to the player's center of mass and applying a meticulously tuned force via ForceMode.Impulse.

// Conceptual overview of the custom propulsion calculation
public void ApplyCustomPropulsion(Rigidbody playerRb, Vector3 explosionOrigin, float baseForce)
{
    // Calculate a pure direction, ensuring consistent launch vectors
    Vector3 propulsionVector = (playerRb.position - explosionOrigin).normalized;

    // Introduce a slight upward bias for intuitive verticality
    propulsionVector += Vector3.up * 0.1f;

    // Implement a controlled falloff curve for predictable force scaling
    float distance = Vector3.Distance(playerRb.position, explosionOrigin);
    float forceFalloff = 1f / (1f + distance * distance); // Inverse square model
    float finalForce = baseForce * forceFalloff;

    // Apply as an instantaneous velocity change for maximum responsiveness
    playerRb.AddForce(propulsionVector.normalized * finalForce, ForceMode.Impulse);
}

However, the most formidable engineering challenge was recreating the complex dynamics of Source-style airstrafing. This required a sophisticated understanding of vector projection within the FixedUpdate loop. The system grants players mid-air maneuverability by applying a continuous force perpendicular to their current velocity vector, scaled by their horizontal input. This design rewards precise, coordinated mouse and keyboard inputs, allowing skilled players to gain speed and alter their trajectory. Weeks were dedicated to iterating on acceleration curves and velocity clamps, tuning the system in an isolated test environment until the desired balance between control and momentum was achieved. The two-year development cycle of Blow Up Your Feet documents a critical transformation in my skillset; The project served as a practical education in physics programming, system design, and the iterative process of translating an abstract 'feeling' into concrete, functional code.

Honestly, I can’t thank unity enough for teaching me one of the biggest lessons in my engineering life: genuine learning is often born not from prescribed lessons, but from deep engagement with a self-defined, compelling problem. Blow Up Your Feet is more than a game; it is the functional artifact of that principle, a complex system built from frustration, obsession, and an unwavering commitment to engineering a specific experience.