top of page

Games

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

Chimping

  • Used existing code and customized it to match the required gameplay.

  • Designed & Implemented UI using Unity's native UI.

  • Implemented Mobile Push Notification using OneSignal API.

  • Game Performance Optimization using Unity Profiler.

  • Deployed to Google Play, Amazon & Apple App Stores.

Chimping

Other

⚙️ Configurable UI & Data System

GitHub.png

  • Modern UI Architecture: Leveraged Unity UI Toolkit to enforce a strict separation between the visual layer (UXML/USS) and application logic (SettingsView), mirroring modern MVC web development standards.

  • Robust Data Persistence: Engineered a centralised SettingsManager Singleton to wrap PlayerPrefs and AudioMixer logic, ensuring type safety and data integrity across game sessions.

  • Responsive Visual Design: Utilised Flexbox architecture and USS styling to create a resolution-independent, professional dark-themed interface with custom control overrides for a consistent user experience.

  • System Integration: Seamlessly bridged UI events with Unity's core systems, mapping slider values to exposed Audio Mixer parameters and dropdowns to global Quality Settings in real-time.

🎮 Modular Player Controller

  • Interface-Based Decoupling: Utilised the IInputReceiver interface to create a strict contract between input handling and movement logic, ensuring the controller is agnostic to the input source (e.g., AI vs. Player).

  • Reliable Physics Implementation: Engineered movement logic within the FixedUpdate lifecycle using Rigidbody forces and velocity (using Unity 6 linearVelocity), ensuring smooth, frame-rate independent gameplay physics.

  • Modern Input Integration: Implemented the Unity New Input System with event-driven callbacks (performed, cancelled), forwarding data purely through the interface to maintain modularity.

  • Separation of Concerns: Strictly divided responsibilities: PlayerInputHandler solely manages input events, while PlayerController exclusively handles physics and state, adhering to SOLID principles.

GitHub.png
GitHub.png

💻Modular Game Flow System

  • Decoupled Architecture: Built a scalable, professional core using the FSM (Finite State Machine) and Observer Pattern to eliminate direct class dependencies (i.e., no more FindObjectOfType<>()).

  • Singleton Management: Implemented the Singleton Pattern (GameStateManager) to ensure safe, persistent, and globally accessible control over the application state.

  • Decoupled Input: Integrated the Unity New Input System and C# Interfaces to separate input reading logic from the state transition logic, making input controls flexible and easy to modify.

  • FSM Lifecycle Control: Successfully implemented the core FSM logic, ensuring every state transition reliably calls the required ExitState() (cleanup) and EnterState() (initialization) methods.

  • Event Broadcasting: Used C# Events/Delegates to broadcast key changes (OnGameStart, OnGameOver), enabling UI and Audio systems to react without knowing which script triggered the change.

Able 3 Authenticator

  • Biometric Authentication: The app integrates biometric authentication (fingerprint or facial recognition) using Android's BiometricPrompt. This enhances security and provides a modern, user-friendly authentication experience.

  • OTP Generation: The app generates time-based one-time passwords (TOTP) using the HMAC-SHA1 algorithm. This functionality is critical for multi-factor authentication (MFA), enhancing the security of services such as GitHub, Google, etc.

  • Barcode/QR Code Scanning: The app allows users to scan barcodes/QR codes to retrieve service-specific information, such as secret keys for OTP generation.

  • Resource-Sensitive UI: The app uses Material Design 3 with both dark and light themes. It dynamically adjusts the status bar colour based on the system's theme and uses customized colour schemes to enhance the user experience.

  • Secure Data Storage: Uses SharedPreferences for securely storing secret keys, website names, and other sensitive information locally. OTP and user data are safely stored and managed on the device.

  • User-Friendly Clipboard Interaction: The app allows users to copy OTP to the clipboard with a long press for easy access, improving the user experience.

  • Dynamic UI Elements: The app has an interactive UI with a delete icon that dynamically appears when the user long-presses the OTP. This provides a clean and intuitive user experience by hiding unnecessary UI elements until needed.

  • Countdown Timer for OTP: Displays a countdown timer indicating the expiration of the current OTP, allowing the user to know when the OTP will refresh.

  • Camera Permission Handling: Integrates a runtime camera permission request for barcode scanning, handling permission denial gracefully and providing user feedback.

  • Modern Android Development Techniques: Uses Jetpack Compose for the UI, showcasing the use of modern declarative UI frameworks for Android development.

bottom of page