top of page
Squares Proximity

Game Development:

  • Engineered a robust PlayerPrefsManager to seamlessly handle data storage and retrieval, ensuring data integrity across game sessions.

  • Spearheaded the design and implementation of a dynamic PlayerTurnsManager, featuring turn logic, random turn generation, and AI decision-making using Lists and nested Lists.

  • Orchestrated the creation of a comprehensive ScoreManager responsible for managing in-game scoring, capturing coins, and determining game outcomes.

  • Architected a flexible GridManager to govern the game grid, cell interactions, and the strategic placement of coins.

User Interface (UI) Enhancements:

  • Crafted visually appealing UI elements, such as dynamic coin value displays, using Unity's UI system.

  • Designed and integrated UI components in the ScoreManager, providing players with real-time scoring information and enhancing overall user experience.

  • Engineered utility classes like RadioButton to streamline UI toggle management efficiently.

Mobile and Platform Adaptation:

  • Innovated the SceneInitializer class, enabling dynamic instantiation of scene and UI objects tailored to different platforms, including iOS, Android, and WebGL.

Input Handling Expertise:

  • Implemented the PlayerController class, showcasing adept handling of diverse input methods, such as keyboard, mouse, and touchscreen, for a seamless and intuitive user experience.

Utility Class Innovation:

  • Pioneered the creation of a versatile CoinPlacer class, responsible for the strategic placement of coins, capturing adjacent coins, and managing buffs within the game.

  • Introduced utility classes like CellMarker and ColourAdjuster, contributing to the game's visual appeal and providing enhanced user feedback.

Code Quality and Optimization:

  • Demonstrated a commitment to code robustness by incorporating error-handling techniques, including exception handling in the PlayerPrefsManager.

  • Optimized data serialization and deserialization processes in the PlayerPrefsManager for improved efficiency and performance.

Collaboration and Integration:

  • Collaborated seamlessly across different modules, exemplified in the successful integration of the CoinPlacer with the GridManager and GameManager.

Testing and Debugging:

  • Conducted rigorous testing, ensuring the flawless operation of critical mechanics such as coin placement, buffing, and capturing in the CoinPlacer.

  • Engineered debugging features like the CellMarker to visualize cell indices during development, streamlining the debugging process.

SP Trailer

Core Architecture: Generic Grid Framework

  • Architecture & Inheritance: Leveraged a generic base class (GridData<T>) to create specialized, type-safe data containers like this GameObjectGridData for automated object handling.

  • Memory Management: Overrode the DisposeData method to ensure all instantiated GameObjects are properly destroyed, preventing memory leaks—a critical factor in high-performance Unity games.

  • System Scalability: This modular approach allows for rapid expansion, as new grid-based data types (like Boolean or Integer states) can be implemented with zero code duplication.

Code.png

Manager Orchestration: Async Service Initialization

  • System Bootstrapping: Engineered a centralised manager-of-managers system that utilises Service Locators and UniTask to ensure core systems initialise in a thread-safe, non-blocking sequence.

  • Architectural Leadership: Managed the transition and refactoring of this collaborative script, overseeing the integration of gameplay commands while personally authoring the underlying manager lifecycle and dependency injection logic.

  • Robustness & Safety: Implemented a comprehensive validation layer to verify critical ScriptableObject (SOAP) dependencies before runtime, significantly reducing initialisation errors and improving project stability.

Manager Orchestration: Async Service Initialization Code.png

State Preservation: Robust Restart Logic

  • Data Integrity: Implemented a state preservation system that captures the exact turn order and random number sequences at the start of a match, ensuring a perfect restart state.

  • Procedural Consistency: Engineered logic to track and restore grid-specific data, such as blocked cells and hole counts, maintaining consistency across game sessions.

  • Memory Management: Utilised a centralised cleanup routine to cancel active UniTasks and clear command queues during transitions, preventing memory leaks and ensuring stable performance after multiple restarts.

State Preservation: Robust Restart Logic Code.png
bottom of page