Jay Webb | Portfolio

In this phase of development, the focus shifted from conceptual design to Core Systems Integration. My goal was to establish a robust foundation for character movement and camera behavior that could handle multiple class types seamlessly while maintaining a high level of “Game Feel.”

Technical Foundation
1. Universal Player Controller & Shared Logic

To maintain a “Clean Code” approach, I developed a centralized PlayerController script. Instead of duplicating movement logic for the Knight, Cleric, and Ranger, all characters share this core driver.

  • The Benefit: This ensures that movement speed, gravity, and input handling remain consistent across all classes, making future balancing and systemic updates significantly more efficient.
2. Mixamo Integration & 2D Simple Directional Blend Trees

I successfully imported three distinct archetypes—Knight, Cleric, and Ranger—along with their respective animation sets from Mixamo. To ensure responsive movement, I implemented 2D Simple Directional Blend Trees within unique Animator Controllers for each prefab.

  • The Logic: The blend tree monitors two float parameters: MoveX and MoveY. By mapping the animations (Idle, Walk, and Run in all directions) to these vectors, the system handles 8-way movement dynamically.
  • Input Interpolation: To avoid “snapping” between animations, I configured the system to interpolate the input values. As the player moves the joystick or presses keys, the values transition smoothly toward the target, creating natural acceleration and deceleration that makes the character feel weighted and grounded.
3. The GameController & Dynamic Spawning

I implemented a GameController object to act as the “Manager” for the game state. This object handles the initialization of the player character using a custom C# script.

  • Systemic Selection: I utilized a C# Enum to define the character types. This allows the current character prefab to be selected easily within the Inspector.
  • Dynamic Instantiation: The script references the chosen prefab and a designated Spawn Point, ensuring that the character is correctly initialized in the world regardless of which class is selected for the session.
Visual & Camera Systems

Cinemachine: Third-Person Follow Logic

A key component of this project’s visual identity is the camera perspective. I integrated Unity Cinemachine to handle character tracking with professional-grade smoothness.

  • Perspective: I configured a Third Person Follow component at a fixed, top-down angled perspective. This provides a clear view of the player’s immediate surroundings while offering enough forward visibility to show the range of the procedural rooms.
  • Automation: To keep the focus on strategy and movement, I locked the camera to stay behind the player at all times. This removes the “camera management” burden from the player and ensures the view is always optimized for tactical combat.
Key Programming & Multimedia Skills Demonstrated

In this update, I have successfully applied several industry-standard skills:

  • Asset Pipeline Management: Processing FBX models and animations from external sources (Mixamo) into Unity-ready prefabs.
  • Smooth Character Feedback: Using Blend Trees and value interpolation to create polished transitions.
  • Manager Design Patterns: Establishing a GameController to centralize scene initialization.
  • C# Enumerations: Using Enums to create readable, designer-friendly code for class selection.
The Final Milestone of Phase 1: The Space-Filling Dungeon

With the characters moving and the camera tracking, the final milestone for Phase 1 is the implementation of the Procedural Room Generation System.To conclude Phase 1, I am implementing a specialized Hamiltonian Path Generator. Unlike standard branching dungeons, this 5 X 5 grid system requires the player to navigate through all 25 rooms in a single, non-overlapping sequence. This creates a high-tension ‘Dungeon Marathon’ where the player cannot skip content.​

Technical Focus
  • Pathfinding Logic: Developing a C# script that calculates a 25-room sequence from a corner start, ensuring no ‘dead ends’ are generated before the final room.
  • ​Spatial Variation: Integrating three distinct room scales (Small, Medium, Large) from the Fab asset kits to ensure the 25-room journey remains visually and tactically engaging.
  • ​State-Based Seeding: Using a single integer seed to lock the 25-room sequence, allowing the path to be persistent if the player reaches a campfire.”
Closing: A Hero Without a Map

With the movement logic finalized and the 2D Simple Directional Blend Trees providing smooth, interpolated transitions, our character archetypes are officially “game-ready.” We have the Knight, the Ranger, and the Cleric fully animated and tracking perfectly with our Cinemachine camera system.

However, a hero with nowhere to go is just a tech demo. To wrap up Phase 1, I need to move from the character to the world itself.

Stay tuned for Dev Log #3, where I will break down the final milestone of our foundation: the Hamiltonian Path Generator. I’ll be showing how I use a 5 X 5 grid and deterministic seeding to ensure that every journey through the labyrinth is a unique, 25-room marathon that never intersects itself.

The characters are ready. Next time, we build the dungeon.