Stage 01
Learning the engine
Started with the fundamentals of how Unity puts a scene together: GameObjects, components, prefabs, transforms, cameras, colliders and rigidbodies, UI, animation, input and scene management.
Unity Game Developer · C# Programmer · Lahore, Pakistan
I build games, not just code.
I'm Hasan, a Unity developer with 3+ years building gameplay systems, mechanics, integrations and complete playable experiences with Unity and C#. From a mechanic in your head to a build you can hold.
One engine. One language. Endless possibilities.
With Unity and C# I can approach different gameplay problems, mechanics, systems and genres while keeping performance, scalability and player experience in mind.
Scene / About
Who I am
I'm a Unity Game Developer from Lahore, Pakistan, with more than three years working with Unity Engine and C#. My focus has been on understanding how games actually work beneath the surface — gameplay logic, player interaction, physics, UI, systems, optimization, integrations and monetization.
How I approach a project
I take an idea and break it down into individual systems before turning those systems into a playable experience. Fast arcade mechanics, physics-driven gameplay, simulation systems, hypercasual loops, action gameplay or mobile-focused builds — each one is a technical problem solved through clean architecture and thoughtful gameplay programming.
gameplay programminggame systems
unity physicsunity ui
mobile buildsfirebase
ads & monetizationanalytics
optimization.net concepts
Scene / Journey
My journey with Unity
Five stages, in the order they actually happened — engine, language, systems, production, and the perspective that came out of all of it.
Stage 02
Learning C# properly
Moved past wiring components together and went deep on programming — object-oriented design, interfaces, inheritance, encapsulation, events and delegates, collections, generics, LINQ, async work, coroutines and tasks, reflection, design patterns and code architecture.
Stage 03
Gameplay systems
Building complete systems rather than isolated scripts: player controllers, camera systems, enemy logic, game managers, level and progression systems, UI systems, save/load, physics interactions, input, spawning, object pooling and game state.
Stage 04
Production and integrations
Expanded into everything that surrounds a modern game: Firebase, advertisement SDKs, analytics and event tracking, monetization, player data, remote configuration, mobile integrations and performance work.
Stage 05
Versatile development
Today I work from a broader view rather than one genre: mechanics, then systems, then player experience, then performance, then monetization.
Scene / Skills
What I work with every day
Four things carry everything else: the engine, the language, the gameplay code and the way it's all structured.
Unity Engine
Three-plus years of practical development inside Unity — scenes, prefabs, physics, UI, animation and builds.
C#
A strong practical grasp of C# and object-oriented programming, used to shape systems rather than glue scripts together.
Gameplay programming
Mechanics and gameplay systems written from scratch — movement, combat, interaction, state, feel.
Game architecture
Structuring a project so systems stay separable, testable and cheap to change three months in.
Scene / Language
C# is my foundation
C# isn't just the scripting language I type into Unity — it's how I decide what a system is, what it owns, and how it talks to the rest of the game. Pick a concept to see how I use it.
Strong practical understanding of C# for Unity development — enough to build and debug the systems above, and still learning the parts of the language I haven't needed yet.
// One contract, any object that can take a hit. public interface IDamageable { void TakeDamage(float amount, Vector3 point); } public class Enemy : MonoBehaviour, IDamageable { [SerializeField] private float _health = 100f; public void TakeDamage(float amount, Vector3 point) { _health -= amount; SpawnHitFx(point); if (_health <= 0f) Die(); } } // The weapon never needs to know what it hit. if (hit.collider.TryGetComponent(out IDamageable target)) target.TakeDamage(_damage, hit.point);
// Systems react to the game, not to each other. public static class GameEvents { public static event Action<int> ScoreChanged; public static event Action PlayerDied; public static void RaiseScore(int value) => ScoreChanged?.Invoke(value); public static void RaiseDeath() => PlayerDied?.Invoke(); } public class HudView : MonoBehaviour { private void OnEnable() => GameEvents.ScoreChanged += Redraw; private void OnDisable() => GameEvents.ScoreChanged -= Redraw; private void Redraw(int score) => _label.text = score.ToString("N0"); }
// One pool, any prefab — no allocations mid-gameplay. public class Pool<T> where T : Component { private readonly Queue<T> _idle = new(); private readonly T _prefab; public Pool(T prefab, int warm) { _prefab = prefab; for (int i = 0; i < warm; i++) _idle.Enqueue(Create()); } public T Get(Vector3 at) { T item = _idle.Count > 0 ? _idle.Dequeue() : Create(); item.transform.position = at; item.gameObject.SetActive(true); return item; } public void Release(T item) { item.gameObject.SetActive(false); _idle.Enqueue(item); } }
// Coroutines for gameplay timing… private IEnumerator DashRoutine() { _state = State.Dashing; float t = 0f; while (t < _dashTime) { t += Time.deltaTime; _rb.MovePosition(_rb.position + _dir * _dashSpeed * Time.deltaTime); yield return null; } _state = State.Grounded; } // …async for anything that waits on the outside world. private async Task LoadRemoteConfigAsync() { await _remote.FetchAsync(); _difficulty = _remote.GetInt("start_difficulty", 1); }
// Reading game state without writing another loop. var nearest = _enemies .Where(e => e.IsAlive) .OrderBy(e => (e.Position - player.Position).sqrMagnitude) .FirstOrDefault(); var unlocked = _levels .Where(l => l.StarsEarned > 0) .GroupBy(l => l.World) .ToDictionary(g => g.Key, g => g.Count()); // Kept out of Update() — LINQ allocates, and mobile notices.
Scene / Unity
Inside the engine
The six areas a gameplay build usually lives in, and what I handle in each.
Gameplay
- character controllers
- movement
- combat
- interaction
- mechanics
- game states
Physics
- rigidbody systems
- collision detection
- triggers
- forces
- physics interactions
Systems
- managers
- spawn systems
- object pooling
- save systems
- progression
- level management
UI
- menus
- hud
- progress bars
- buttons
- game states
- mobile interfaces
Input
- keyboard
- mouse
- touch
- mobile controls
- custom input systems
Optimization
- object pooling
- efficient update loops
- memory awareness
- mobile performance
Scene / Genres
I don't build one type of game.
Give me a mechanic. I'll build the system behind it. Genre isn't the limitation — mechanics and systems are what matter.
Action
Combat, movement, enemies, weapons, abilities and responsive gameplay.
Simulation
Systems, resources, interactions, progression and state management.
Arcade
Fast mechanics, scoring, feedback loops and replayability.
Hypercasual
Simple controls, instant feedback, short loops and mobile optimization.
Puzzle
Logic systems, interactions, progression and level-based mechanics.
Racing
Vehicle movement, physics, checkpoints, racing logic and progression.
Physics
Rigidbody interactions, forces, collisions and emergent gameplay.
Casual
Accessible mechanics, UI, progression, rewards and monetization.
Interactive / Can I build it?
What kind of game are you thinking about?
Pick a direction and I'll show you the systems I'd start writing.
Yes — here's how I'd start.
Scene / Pipeline
How a mechanic becomes a build
The same eight steps every time, whether it's a weekend prototype or a full mobile project.
01
Idea
The concept or the core mechanic, stated in one sentence.
02
Design
Break that mechanic down into the systems it actually needs.
03
Prototype
Build the core loop and find out whether it feels good yet.
04
Systems
UI, progression, physics, enemies, levels, save data.
05
Integration
Firebase, ads, analytics and the services around the game.
06
Polish
Feedback, animation, sound hooks, game feel, UX.
07
Optimization
Frame time, memory and stability on real devices.
08
Build
Prepare the final playable build and ship it.
Scene / Services
Beyond gameplay
A modern game is more than its gameplay code. I can integrate the services that connect the game to the wider ecosystem.
Firebase
Integrating Firebase into Unity projects — analytics, remote configuration, player data, event tracking and backend-connected functionality.
Advertising
Advertisement SDK integration: rewarded ads, interstitials, ad callbacks and the monetization flows around them.
Game analytics
Measuring what players actually do — events, sessions, engagement, retention concepts and monetization events feeding back into design.
Scene / Mobile
Built with mobile in mind
Mobile games have different constraints. Touch input, screen sizes, performance, memory, loading times, monetization and retention all change how a game should be designed — not just how it's ported.
Touch controls
Input built for thumbs, not remapped from a keyboard.
Mobile UI
Layouts that survive every aspect ratio and safe area.
Performance
Lightweight systems, pooled objects, disciplined update loops.
Live services
Ads, analytics, progression and fast loading on real devices.
Scene / Capabilities
What I can build
Gameplay
- player controllers
- combat systems
- movement
- interaction
- enemy logic
- weapons
- abilities
- health
- game states
Systems
- level systems
- progression
- save / load
- object pooling
- spawning
- inventory
- currency
- rewards
Mobile
- touch controls
- mobile ui
- ads
- firebase
- analytics
- performance
Polish
- ui animation
- gameplay feedback
- camera effects
- game feel
- juice
- transitions
Scene / Philosophy
How I think about game development
01
Mechanics first
A game should feel good before it looks impressive.
02
Systems should be understandable
Clean code makes iteration faster — and iteration is what makes games good.
03
Performance matters
Especially on mobile. Every system has a cost, and something has to pay it.
04
Player experience comes first
Technology exists to serve gameplay, never the other way round.
05
Build, test, improve
Game development is iterative. The first version is a question, not an answer.
Scene / Mindset
Behind the Inspector
I like understanding what's happening behind the Inspector.
When a system behaves unexpectedly, I want to understand why.
When performance drops, I want to identify the bottleneck.
When a mechanic feels wrong, I break it into smaller systems and rebuild it.
That's the mindset I bring to game development.
Scene / Portfolio
The work is coming. The skills are already here.
I'm currently building my public portfolio. Rather than filling this site with fabricated case studies, I'd rather let my technical understanding, development approach and this page itself speak for me.
Build interesting games. Solve difficult gameplay problems. Keep learning. Keep shipping.
Scene / Stack
Development stack
Unityengine
C#language
Firebasebackend services
Analyticsplayer behaviour
Ad SDKsmonetization
Gitversion control
Visual Studio / Rideride
.NETconcepts
Scene / Next
What I'm building toward
My long-term goal is to keep developing increasingly ambitious games and eventually expand from mobile-focused development into larger PC and Steam projects.
I want to keep improving not only as a programmer, but as a complete game developer who understands mechanics, systems, optimization, monetization, player experience and production.
Have a game idea?
Let's turn the mechanic in your head into something playable.