Crafting Immersive Gaming Experiences
Bringing Adventures to Life Through Games
3D Shooting/Tower Defense Game
-
​Developed a mission-based space defense game with player, drone, and spacecraft systems on an alien planet.
-
Applied Singleton, Service Locator, MVC, and State Machine patterns for modular and scalable architecture.
-
Built core mechanics including drone , resource collection, and spacecraft missile-combat system.
-
Designed interactive rooms like the Spacecraft Terminal, Drone Control Room, and Resource Warehouse.
-
Implemented a dynamic minimap system with alerts, tracking, and role-based UI panels.
-
Optimized performance using object pooling and occlusion culling, achieving ~100 FPS
Tank 3D
Tank Shooter/Action Game
-
Built a modular tank system using MVC pattern with separate Model, View, and Controller components.
-
Implemented comprehensive game management system with centralized GameManager and dynamic scoring.
-
Developed physics-based combat system with shell mechanics and explosion effects.
-
Created service-based architecture with TankSpawner and CameraController for enhanced gameplay.
Space Shooter
Top-Down Space Shooter game
-
Object Pooling System: Implements efficient object reuse through GenericObjectPool<T> for bullets, enemies, VFX, and power-ups, optimizing performance by preventing constant object creation/destruction.
-
Service Architecture: Uses a centralized GameService singleton managing specialized services (Player, Enemy, PowerUp, VFX, Sound) for clean separation of game systems.
-
Data Management: Leverages Scriptable Objects for configurable game data (player stats, enemy properties, bullet settings, power-ups) enabling easy game balancing without code changes.
-
MVC Pattern: Follows Model-View-Controller architecture with clear separation between game logic (Controllers), visual representation (Views), and data structures (Models/Scriptable Objects).
Shooting/Tower Defense Game
-
Structured the game into modular components (Defender, Attacker, Grid, Audio, etc.) for maintainability and scalability.
-
Applied State Machine pattern to manage dynamic behaviors of units (Idle, Attack, Die, etc.). Used MVC architecture to separate logic, visuals, and data for units and UI components.
-
Implemented Observer pattern with EventService for decoupled communication between systems.
-
Leveraged Service Locator with GameService and custom Object Pooling to improve system access and performance.
Angry Monkeys
Shooting/Tower Defense Game
-
​Tower defense game using Service Locator pattern with GameService managing Player, Wave, Map, UI, and Sound services.
-
Implements Generic Singleton for MonoBehaviour classes, Dependency Injection for service communication, and Object Pooling for projectiles and bloons.
-
Map system with tower placement validation, bloon path waypoints, and resource management for player health and money.
-
UI system with gameplay panels, level selection, and sound effects, connected through an observer pattern event system.
Turn-Based Strategy Game
-
The system uses a command pattern to encapsulate game actions as objects, with each command having execute and undo capabilities.
-
A central manager maintains a history of commands in a stack, allowing for both immediate execution and reversal of actions.
-
Commands are organized hierarchically with a base interface and concrete implementations for specific game actions.
-
The implementation supports command replay functionality and ownership verification, enabling both undo operations and sequence replay.
Space Dwarfs Odyssey
Color Matching Game
-
Implemented Singleton design pattern, OOP principles, and Coroutines in game development.
-
Used Object Pooling to efficiently manage items, special effects, and unique objects.
-
Designed and integrated a State Machine using delegates and events to control game states like Level Start, Tutorial, Preplay, Play, Prewin, Level Win, Prefailed, and Level Failed.
-
Created ScriptableObjects for storing level data and design.
-
Developed tutorial functionality for levels designed to introduce core mechanics and item interactions.
Horror House
First-Person Horror Survival Game
-
The project uses a centralized Observer pattern via a Singleton event service and controller for efficient, decoupled communication.
-
Core systems—Player, UI, Interactables, Camera, and Sound—follow the MVC architecture.
-
The event system handles key gameplay triggers like light toggles, item pickups, player death, and enemy rushes.
-
Components subscribe to relevant events during their lifecycle, ensuring clean and responsive event handling.
Hunter Assassin
Top-down 2D Action game
-
A top-down 2D action game where you control a character that moves with WASD and attacks with spacebar, fighting against various types of enemies in different levels.
-
Enemies use state machines to switch between behaviors like chasing, shooting, and patrolling, with each enemy type (OnePunchMan, PatrolMan, Hitman, Robot) having unique attack patterns.
-
The player must manage their health while defeating enemies, with a UI showing health bar and enemy count, and enemies can damage the player if they get too close.
-
The game features a level selection system where you progress through increasingly challenging levels, with win conditions being defeating all enemies and lose conditions being player death.
Shop/Inventory Management Game
-
A Unity-based shop and inventory system implementing MVC architecture with separate modules for inventory management, shop functionality, and item handling.
-
Core GameService acts as a service locator managing coins, weight limits, and coordinating between different services (Audio, Event, Shop, Inventory) using the singleton pattern.
-
Slot system handles individual item storage with support for different item types (Materials, Weapons, Consumables, Treasure) and implements the observer pattern for item selection and updates.
-
Event-driven architecture using the observer pattern for communication between components, with a modular design that separates business logic (Controllers), data (Models), and presentation (Views) for maintainable and extensible code.
Chest Opening Management Game
-
Created a modular slot-and-chest gameplay system using MVC, Service Locator and Observer patterns
-
Built a ChestService to manage chest states (locked, unlocking, open), unlock timers, and reward distribution.
-
Designed all UI elements for slots, chests, overlays, and currency displays with smooth animations
-
Developed a save/load system using PlayerPrefs and JSON to persist chest states, currency, and unlock time
Platformer Game
-
Utilized Singleton, OOP principles, and Coroutines for efficient game development.
-
Added animations for Player, Collectibles, and Enemy for engaging visuals.
-
Designed adventurous and challenging levels.
-
Implemented a state machine for seamless player behavior control (walk, jump, idle).
Strategy Game
-
Implemented the MVC (Model-View-Controller) pattern to structure the Minesweeper game efficiently, improving code maintainability and scalability.
-
Developed smooth and responsive controls for revealing tiles, flagging mines, and handling user interactions seamlessly.
-
Utilized arrays and enums to generate, modify, and expand the game grid dynamically, allowing flexible difficulty scaling and level customization.
-
Implemented optimized algorithms for mine placement, number calculations, and win/loss detection to ensure fast and accurate game state updates.
Hyper Casual Game
-
Implemented Singleton, OOP principles, and Coroutines for efficient game architecture.
-
Developed a multiplayer snake game with dynamic growth mechanics upon eating.
-
Added power-up features to enhance gameplay and strategy.
Hyper Casual Game
-
Implemented the MVC (Model-View-Controller) pattern to enhance code organization, maintainability, and scalability.
-
Refined Player Controls: Developed smooth and responsive jump and movement functionality for an engaging gameplay experience.
-
Flexible Level System: Utilized arrays and enums to efficiently create, improve, and extend levels, ensuring modularity and easy expansion.
Top-Down Shooter game
-
Added animations for the Player, Collectibles, and Enemies to enhance visual appeal and engagement.
-
Designed challenging levels with progressively increasing difficulty and diverse enemy patterns.
-
Developed a scoring system to track player progress and achievements effectively.
-
Implemented collision detection for realistic interactions between game objects.
-
Optimized game performance for smooth gameplay across various devices by implementing object pooling, reducing CPU load, and improving overall efficiency.
Hyper Casual Game
-
GameService.h: Core game management script that handles game states (boot, menu, gameplay), window management, and the main game loop. It serves as the central coordinator for the entire game system.
-
Player/SnakeController.h: Controls the snake's movement, growth, and collision detection. It manages the linked list implementation of the snake's body parts and handles player input for direction changes.
-
Player/BodyPart.h: Defines the structure of individual snake body segments, including their position, rendering properties, and connection to other body parts in the linked list structure.
-
Player/Node.h: Implements the basic node structure for the linked list that represents the snake's body, providing the foundation for the snake's movement and growth mechanics.