Shayan Memon

Technologies: Unity | C# | Netcode for GameObjects | Unity Relay | Mobile Optimization

Developed a lightweight, real-time multiplayer racing game inspired by the “mini-Asphalt” style, built entirely in Unity. Leveraged Netcode for GameObjects with Unity Relay for smooth online play, enabling players to join matches via join codes and race with physics-accurate cars. Implemented WheelColliders for realistic vehicle handling, complete with reverse lights (via Light Probes), engine sounds, and synchronized flame and smoke effects visible to all players in real time.

Key Gameplay Features:

• Lap tracking & win/lose states: Centralized game object logic ensures accurate race results across all clients — e.g., if an opponent finishes 3 laps, the player sees an immediate “You Lose” message.
• Mobile-first optimization: APK size reduced to just 49MB while retaining high visual fidelity and smooth performance.
• Camera & UI polish: Implemented smooth camera follow, countdown synchronization, and color-assigned cars for clear player differentiation.
• Multiplayer-aware respawn system: Designed to correctly reposition cars back onto the track for both local and remote players without desynchronization issues.

Challenges & Solutions:

• Synchronizing visual effects: Integrated smoke, fire, and reverse light behaviors into a multiplayer-safe C# system, ensuring effects are triggered consistently and visible to all connected clients.
• Cross-client race state management: Solved win/lose logic discrepancies by introducing a centralized race controller, ensuring race results remain accurate and synchronized for every player.
• Reliable respawn logic: Built a respawn handler that supports network ownership rules, preventing cars from spawning incorrectly in remote clients.

This project demonstrates strong skills in multiplayer networking, performance optimization, gameplay systems engineering, and visual polish — combining technical problem-solving with a high-quality player experience.

Technologies: Blender | Unity | URP | Light Probes | Low-Poly Optimization

Created a highly detailed 3D recreation of the Faculty of Engineering and Technology (FET) Department in Blender, designed as part of my Final Year Project to showcase architectural modeling expertise. The project offers an immersive, walkable environment on both desktop and mobile, allowing users to virtually explore the department as if physically present. Lighting was handled using Unity’s Universal Render Pipeline (URP) with baked lightmaps, realistic sun effects, and strategic light probe placement for optimal visual quality.

Key Features:

• Accurate architectural modeling: Carefully modeled building structure and interior elements based on real-world reference images for high visual authenticity.
• Mobile & desktop optimization: Reduced polygon count significantly by converting high-poly meshes into optimized low-poly assets while maintaining visual fidelity.
• Efficient prop creation: Designed all props under strict low-poly constraints to improve performance without compromising detail.
• Memory-efficient object duplication: Utilized Alt+D linked duplication instead of Shift+D, drastically reducing memory usage and improving render times.
• Mesh collider accuracy: Streamlined collider setup by reusing linked objects, ensuring accurate physical interactions across the environment.

Challenges & Solutions:

• Performance bottlenecks: Initial build suffered from slow performance due to excessive triangles/vertices; resolved by thorough mesh optimization and polygon reduction.
• Lighting realism: Achieved natural lighting using URP’s sun effects combined with light probes, producing a more lifelike experience without impacting frame rate.
• Precision modeling: Ensured accurate scaling, proportions, and alignment throughout the model to reflect the real FET department layout.

This project demonstrates expertise in architectural visualization, low-poly optimization, lighting design, and environment performance tuning for interactive 3D applications.

Technologies: Unity | C# | 2D Animation | A* Pathfinding | Tilemaps | Custom Shaders | Particle Systems | URP | Mobile & PC Optimization

Open-World Boss Battle Game — Overview: A 2D open-world adventure where players freely explore, discover bosses, and engage in fluid combat. Each encounter features intelligent tracking and attack behavior while the player wields diverse moves, including a cinematic ultimate slash. The world comes alive with editable tilemaps, animated rain, drifting leaves, swaying trees via shaders, and hand-crafted 2D art and UI. The experience is built to run smoothly on both PC and mobile.

Core Systems — Exploration & Customization: The environment is constructed with fully editable tilemaps, allowing terrain and structures to be customized for new paths, arenas, and layouts without rebuilding scenes.

Core Systems — Boss AI: Bosses use the A* pathfinding algorithm to chase the player across varied terrain, with diagonal-aware heuristics and limited recalculation to keep pursuit smooth and fair.

Core Systems — Combat: The player executes responsive light/heavy attacks, can jump in the air for aerial mobility, and unleashes an ultimate slash that sends a large energy wave on hit, reinforced by strong hit-stop, camera shake, and VFX.

Core Systems — Atmosphere: Rain, clouds, and leaf particles pair with URP lighting and subtle tree shaders so foliage appears to move naturally, enhancing immersion without heavy performance cost.

Core Systems — Audio: Footstep sounds are synced to animation events so each step lands audibly and consistently, complemented by weather, attack, and boss cues for clear feedback.

Key Gameplay Features: Open-world exploration with hand-drawn visuals; A*-driven bosses that intelligently track the player; aerial jumps and a spectacle-style ultimate slash; dynamic weather and lighting; tilemap-based world editing for replayability; smooth performance on mobile and PC.

Technical Highlights: Shader-driven foliage for natural motion; URP lighting with efficient particle effects for rain and clouds; batched tilemaps and trimmed particle lifetimes to reduce draw calls; pathfinding that minimizes recalculations while preserving responsiveness.

Challenges & Solutions — Performance: Early builds showed frame drops on mobile; fixed by batching tilemaps, shortening particle lifetimes, culling off-screen effects, and adjusting resolution scaling.

Challenges & Solutions — Pathfinding: Bosses occasionally stuck on corners; resolved with corner detection, small positional nudges, and fallback path refresh when velocity stalls.

Challenges & Solutions — Audio Sync: Inconsistent footstep timing was corrected by moving playback to animation events rather than relying on distance checks or timers.

Result: A polished, atmospheric 2D open-world experience showcasing AI pathfinding, optimized rendering, responsive combat, and customizable environments that run reliably across PC and mobile.

Technologies: Unity | C# | Procedural Generation | A* Pathfinding | Tile-based Grid | Particle Systems | URP | File I/O (leaderboard)

Auto Dungeon Generation Game — Overview

A procedurally generated dungeon crawler developed in Unity to demonstrate advanced gameplay systems, enemy AI, and a complete game loop (menus, leaderboard, death screen). Each playthrough generates a unique dungeon (Castle or Desert theme) featuring lava lakes, quicksand, traps, dynamic weather effects, and five distinct enemy types — including a multi-phase boss appearing every three levels. The game balances randomness with fairness using pathfinding, connectivity checks, and structured spawn rules, while delivering a polished experience with dynamic lighting, particle effects, and smooth camera work.

Core Systems

• Procedural Map Generation: Creates themed dungeons with large rooms, corridors, traps, and environmental hazards. Uses BFS connectivity checks and a Minimum Spanning Tree (MST) for guaranteed navigable paths.
• Enemy AI: Five unique archetypes (Shooter, Assassin, Heavy, Summoner, Boss) each with tailored animations, attack patterns, and AI logic. Bosses spawn every 3 levels, introducing multi-phase combat.
• Player Abilities: Five unlockable skills (Circle Slash, Blink Step, Hammer Slam, Homing Arrows, Fireballs) with cooldowns, visual effects, and damage feedback.
• UI & Game Flow: Main menu, in-game HUD, minimap, death screen with name input, and persistent leaderboard stored via file I/O.
• Atmospheric Effects: Earthquakes, sandstorms, lava glow, and other effects created using Unity’s particle system, camera shake, and URP lighting.

Key Gameplay Features

• Fully randomized runs with fair enemy and trap distribution.
• Chests every two levels containing unique, non-repeating upgrades.
• Color-coded minimap with player orientation and enemy type markers.
• Optimized rendering using camera frustum culling and efficient draw order for layered environments.

Technical Highlights

• Optimized A* Pathfinding: Uses a line-of-sight shortcut before running A*, diagonal heuristics for natural movement, and recalculates paths only when necessary.
• Performance-focused Generation: Low-poly models and efficient instancing keep frame rates high, even with many enemies and effects active.
• Event-driven Effects: Particle systems and sound triggers activate only during relevant events (e.g., boss attacks, trap triggers, weather changes).

Challenges & Solutions

• Ensuring playable maps: Random generation initially created unreachable zones; fixed by adding BFS checks and corridor carving to connect all areas.
• AI spawn balance: Summoners previously overwhelmed players; solved by capping their count and adjusting spawn probabilities per level.
• Rendering performance: Reduced particle lifetimes, batched similar effects, and updated only visible tiles/entities to maintain 60 FPS.
• Collision issues from dashing/knockback: Implemented position validation and snapping to prevent clipping through walls.

This project showcases expertise in procedural generation, AI programming, optimization, game design, and Unity’s particle and lighting systems — delivering a highly replayable and technically polished gameplay experience.

A 2D physics-based simulation where two balls bounce around within the same circular boundary, both aiming for the same goal. The game uses vector mathematics and advanced collision detection to simulate realistic motion and interactions between the balls, creating a dynamic and unpredictable environment. Everything in the game is fully automated, with no player input required.

A rhythm-based game where MIDI files drive music that syncs with a square colliding with platforms. The game features precise timing mechanics to ensure the collisions align perfectly with the music, creating a visually and audibly immersive experience. Various effects enhance the gameplay, though they can't all be captured in a single video.

A 2D fighting game built in Unity featuring Goku and Luffy. The game utilizes animated sprites and dynamic backgrounds to enhance the visual experience. It includes engaging audio, damage effects, and polished gameplay mechanics for a fun and immersive player experience.

A simple racing game focused on timing gear changes to outpace the opponent. The core mechanics revolve around precise gear shifting, with an emphasis on realistic speed and sound effects. The game delivers an immersive audio experience, ensuring the gear shift sounds sync perfectly with gameplay.

I designed and developed a boss rush game for a game competition, completing it in about a month. It was a challenging yet rewarding experience, especially integrating all the mechanics and sound effects.