Yunus Burkut

Game Developer.

Game developer with 4+ years of professional experience in Unity and Unreal Engine. I’ve worked at Zynga Turkey, Frostline Games, and Funverse Games.

Outside of work, I used to play American football — now I watch local league games and build side projects to explore new mechanics, system design patterns, and technical workflows.

GitHub ↗ Resume
Yunus Burkut

Personal Projects

Side projects I built to explore algorithms, game feel, and system design.

Magic Sort gameplay
🧪 Personal Project — Magic Sort Clone Water Sort Puzzle  ·  Unity 6
Game Feel Clean Architecture Haptics

A Water Sort puzzle clone built with game feel as the primary engineering constraint — not the puzzle logic. Wired through a manual composition root with no DI framework; a lightweight EventBus decouples layers without hard dependencies. Every interaction point has a dedicated animation pass grounded in Disney's 12 Principles of Animation.

Interaction Technique
Tube select Anticipation dip → lift with OutBack ease.
Invalid move Procedural shake with exponential decay.
Pour arc Two-phase path (OutSine → InSine) + tilt with OutBack.
Tube solved Squash & Stretch — elastic bounce (1.15× / 0.85y).
Level enter Staggered slide-in from off-screen so the player reads the board first.
Fill VFX Particle colour matched to solved tube colour at runtime.
Manual composition root — no DI framework
Strict one-way layer dependency (Data → View)
Platform-aware haptics — iOS & Android API 26+
TweenScope — zero DOTween memory leaks
All animation params in one ScriptableObject
Pour speed multiplier for back-to-back momentum
Unity 6 C# DOTween Pro ScriptableObjects EventBus Android VibrationEffect
GitHub ↗
Blokfit gameplay
⦿ Personal Project — Blokfit Procedural Puzzle  ·  Unity 6
Procedural Gen Pure C# Unit Tested

Players drag organically-shaped pieces onto a triangular half-cell grid — each square cell split diagonally into two triangles. Every level is generated at runtime via BFS flood-fill partitioning; no hand-authored content exists. The triangular grid was chosen deliberately because its asymmetric adjacency rules forced every system to be designed from scratch.

System Approach
Flat index encoding Each triangle addressed by a single int — position + orientation in one value, no helper struct needed.
BFS partitioner Zero-allocation flood-fill with pre-allocated buffers; O(1) amortised seed lookup via forward cursor.
Constraint pass Size floor/ceiling + piece cap enforced post-BFS; all parameters in a DifficultyConfig ScriptableObject.
O(1) snap lookup Divide → round → clamp. No spatial hash, no distance loop.
Undo system Command pattern — every snap pushes a PlacePieceCommand to a Stack<ICommand>.
Rendering Two shared static Sprites + per-piece MaterialPropertyBlock — GPU batching unbroken.
Custom IMGUI Level Editor (Ctrl+Alt+L)
Domain-reload-safe editor state
Snap-dot VFX with interior vertex detection
Manual composition root
Haptic feedback on snap & invalid placement
Learn some unit tests
Unity 6 C# DOTween ScriptableObjects IMGUI EditorWindow NUnit
GitHub ↗
BFS visualization
Breadth-First Search
A* visualization
A* Search
🛣️ Personal Project — Pathfinding Visualizer BFS & A*  ·  Unity 6  ·  Side Project
Algorithms Zero Allocation Pure C#

Real-time interactive visualizer for BFS and A* running on a live grid. Click to set start/end nodes, toggle walls, and watch each algorithm explore step by step. Built around a strict zero-allocation architecture to eliminate GC pressure in the hot path.

System Approach
BFS queue int[] ring buffer with head/tail pointers — no Queue<T> allocation.
A* open set Hand-rolled binary min-heap with openHeapPosByIndex[] for O(log n) DecreaseKey.
Visited tracking Visit-stamp technique — single int counter per run; no boolean array cleared per frame.
Visual reset coloredIndicesThisRun tracks only painted cells — reset is O(k) not O(n).
Maze generation Stochastic wall placement + BFS validity check; retries up to N times, guarantees a solvable layout.
Architecture Strict separation: GridManager owns data, Pathfinder owns search, InputController owns input (29 lines, zero game logic).
BFS — guaranteed shortest path (unweighted)
A* — Manhattan heuristic, admissible & optimal
Coroutine-safe with OnDisable / OnDestroy guard
Configurable step delay — watch each frame live
Random maze at user-controlled wall density
WaitForSeconds cached, recreated only on change
Unity 6 C# Min-Heap Coroutines ScriptableObject
GitHub ↗

Work Experience

Professional roles at game studios — live titles, production codebases, real player bases.

Gin Rummy Plus
Gin Rummy Plus
Spades Plus
Spades Plus
Zynga Zynga — Spades Plus & Gin Rummy Plus Mobile Game Engineer  ·  Unity  ·  Live Production
Live Game Mobile DI Framework Large Scale

Worked as a Mobile Game Engineer on two of Zynga's live card game titles. Contributed to feature client side development, UI systems, and legacy code maintenance on large-scale production projects with real active player bases.

Area Work done
Profile System Player profile screens and flows — displaying user data, connecting it to the UI layer, integrating with existing systems.
Report System Player reporting flows — handling user actions, collecting required data, and integrating into game systems.
Inbox System In-game inbox: data parsing, UI display, and reliable message presentation to players.
Popup Systems In-game popup flows — correct ordering, flow integration, and smooth UX maintenance.
Legacy Maintenance Bug fixing, small refactors, and feature integration in live codebases without breaking existing architecture.
Dependency Injection framework
Event-driven module communication
JSON data parsing & runtime usage
2D mobile game optimization
Async programming fundamentals
Safe development in legacy codebases
Unity C# DI Framework Flow Systems Mobile
Hit and Boom gameplay
💥 Funverse Games — Hit and Boom Multiplayer MOBA / Battle Royale  ·  Unreal Engine  ·  2.5 years
Lead Developer Multiplayer GAS Unreal C++

Worked on Hit and Boom for 2.5 years — first as a Gameplay Developer, then as Lead Developer. Responsible for gameplay systems: skills, zone logic, UI, animation integration, and game feel. Built with Unreal Engine, C++, and the Gameplay Ability System.

Area Work done
Gameplay Ability System Skill activation, cooldowns, gameplay effects, tags, cancellation rules, animation-driven ability flow, and server-side validation.
Multiplayer / RPC Client↔server RPCs, multicast calls, replicated variables, network-safe ability activation, and gameplay state sync.
Architecture Inheritance-based ability hierarchy, SOLID principles, reusable base classes keeping ability-specific logic clean and isolated.
Game feel Iterative game feel improvements for competitive multiplayer — separating cosmetic feedback from authoritative gameplay logic.
Server-authoritative gameplay design
Ability cancellation & interruption rules
Animation-driven ability flow
UI feedback for ability states
Zone logic & game loop systems
Led development for 1.5 years as Lead Dev
Unreal Engine C++ Gameplay Ability System Multiplayer / RPC Replication
Steam ↗