DENIZ SEKER
Unity Game Developer
Embedded Files
Unity Game Developer with 3+ years of experience across 3 studios, specializing in Unity for Android and iOS. Architected and shipped 8 production F2P mobile games (3M+ users) with full monetization stacks (IAP + 6-network ad mediation), Firebase analytics pipelines (100+ events), and LiveOps systems. Experienced in end-to-end game development (0 → store release → after release updates) including scalable architecture, gameplay systems (combat, progression, economy, physics), performance optimization for low-end devices, and live service management.
Architected a service-oriented Unity architecture across 600+ C# scripts using event-driven systems, ScriptableObject data pipelines, and modular services.
Built a production-grade save system with atomic file writes, crash recovery (.bak fallback), versioned migrations, and encrypted JSON persistence.
Implemented 3 combat systems (arcade naval combat, hex-based TBS, RTS battles) and large-scale gameplay systems including exploration, trade routes, equipment fusion, and crew management.
Integrated 16 IAP products with Unity Purchasing and 6-network ad mediation via IronSource LevelPlay with impression-level revenue tracking.
Developed a 100+ event analytics pipeline with Firebase Analytics, Crashlytics, and Remote Config for LiveOps feature control.
Engineered Addressables-based asset architecture (100+ groups) with async loading and distance-based island LOD for memory optimization.
Implemented offline progression systems including resource generation, trade route completion, and energy regeneration.
Built LiveOps features including daily tasks, time-limited IAP offers, remote-configurable ads, and tutorial-driven onboarding.
Designed GDPR/CCPA compliant ad consent flow using Google UMP SDK with iOS ATT tracking integration via Facebook SDK
Developed and shipped a production-ready mobile game on Unity (Android & iOS) with a scalable modular architecture.
Architected an event-driven game framework using Singleton managers and ScriptableObject data-driven systems.
Implemented grid-based gameplay systems including BFS pathfinding, rail traversal, and dynamic grid optimization.
Built a train management gameplay system with wagon chaining, auto-merge mechanics, and resource collection.
Designed meta-progression systems including card upgrades and equipment fusion mechanics.
Created a MapSaga level progression system with multi-biome support and unlockable progression flow.
Integrated Firebase stack (Analytics, Crashlytics, Remote Config, FCM) with 30+ gameplay and monetization events.
Implemented full monetization stack: Unity IAP, IronSource LevelPlay mediation, and rewarded/interstitial ad systems.
Developed secure save system with encryption, JSON serialization, and versioned data migration.
Built LiveOps infrastructure via Firebase Remote Config for server-side gameplay and monetization tuning.
Optimized performance using object pooling system (800+ objects) maintaining stable 60 FPS on mobile.
Developed a mobile idle harvesting game in Unity featuring destructible environments and scalable gameplay systems supporting 300–400+ trees per level with optimized data structures and centralized managers.
Implemented a grid-based resource spawning and persistence system where tree states and level progress are efficiently stored and restored across sessions.
Designed a stacking and resource collection system with dynamic grid placement, capacity management, and animated collection feedback integrated with the selling economy loop.
Built a progression and upgrade system affecting multiple gameplay parameters such as movement speed, blade speed, detection radius, damage, stack capacity, and resource value.
Implemented a data-driven level system using ScriptableObjects, enabling configurable level layouts, grid spawning, and progression without requiring code changes.
Built a temporary and permanent multiplier system combining upgrades, rewarded ad bonuses, and premium purchases into a unified gameplay scaling mechanic.
Optimized runtime performance through object pooling, event-driven systems, and reduced per-object Update calls, ensuring stable performance on mobile devices with dense interactive environments.
Implemented a physics-based UFO beam collection mechanic with weight-based attraction, level-gated collection thresholds, and upgrade-driven beam progression.
Designed a dynamic destructible item system including tower structures and a BFS-based cascade collapse algorithm enabling large-scale domino-style physics interactions.
Built a custom level editor and level generation pipeline with parametric structure tools, Scene View gizmos, and reusable structure templates to accelerate content creation.
Implemented a complete mobile monetization stack including Unity IAP, rewarded and interstitial ads via mediation, and piggy bank mechanics integrated into gameplay progression.
Integrated a Firebase backend pipeline (Analytics, Remote Config, Crashlytics, Cloud Messaging) enabling event tracking, live gameplay tuning, crash reporting, and push notifications.
Developed a modular UI framework with an abstract popup architecture and sequential reaction system to orchestrate complex reward and progression animations.
Optimized gameplay performance for mobile through object pooling, non-allocating physics queries, kinematic-at-rest physics, and cached runtime resources.
Developed high-performance grass rendering system using custom shaders for optimized draw calls and mobile GPU efficiency
Developed production-ready Unity games with modular gameplay systems, scalable architecture, and data-driven design patterns.
Architected event-driven and manager-based game frameworks enabling modular systems, reusable components, and maintainable large-scale Unity projects.
Implemented core gameplay mechanics and progression systems including resource collection, upgrades, economy balancing, and player progression loops.
Integrated complete F2P monetization pipelines including in-app purchases, rewarded and interstitial ads, and ad mediation across multiple networks.
Built analytics and LiveOps pipelines using Firebase services to track gameplay events, monitor performance, and remotely tune gameplay parameters.
Optimized runtime performance through object pooling, reduced Update usage, and efficient data structures for dense interactive environments.
Implemented data-driven content pipelines using ScriptableObjects to enable configurable gameplay systems and scalable content management.
OOP (Object-Oriented Programming): Principles like classes, inheritance, and polymorphism are utilized to structure the code efficiently.
Generics: Generic methods, such as DeactivateEntities<T> and ActivateEntities<T>, are employed to handle various types of entities in a flexible manner.
Unity Editor Scripting: Custom scripts, like GridEditor, are specifically written to extend the Unity Editor's functionality, improving the development workflow.
Complex DOTween animation sequences: Advanced animations are created using DOTween, allowing for intricate and chained movements, transitions, and effects in a smooth, time-based manner.
Singleton Pattern: The CellManager script implements the Singleton pattern to ensure a single, globally accessible instance of the manager throughout the game.
Prefab Management: Prefabs are managed and instantiated within the Default_Cell and GridEditor scripts, allowing for reusable game objects.
MVP/MVC: Design patterns like Model-View-Presenter (MVP) or Model-View-Controller (MVC) are used to separate the concerns of data (Model), user interface (View), and the logic that binds them together (Presenter/Controller)
State Machines: Controls the transitions between different states of a character or object, such as idle, attacking, or fleeing.
NavMesh: A navigation mesh that allows NPCs or characters to find the optimal path to their target while avoiding obstacles.
NPC AI: Artificial intelligence that governs the behavior of non-playable characters (NPCs), making them react to the environment and player actions.
Interaction System: Manages how players or NPCs interact with objects or other characters in the game world.
UI System: The user interface system that handles all on-screen elements like menus, health bars, and inventory, allowing players to interact with the game.
Hand-made camera system: A custom camera system that is manually scripted to offer specific perspectives or behaviors not provided by standard camera tools.
Fog of War: A gameplay mechanic that hides unexplored or unseen areas on the game map, revealing them only as the player or units move closer.
Day and Night Cycle: A dynamic system that simulates the passage of time in the game world.
Medieval Market Simulator
( Still Under Development )
Complex NPC Behaviours: NPCs follow intricate routines and interactions that change dynamically based on various factors.
Complex DOTween Animation Sequences: Advanced animations are crafted using DOTween to create smooth and visually appealing transitions, movements, and effects throughout the game.
TextWriter: Used to create a typewriter effect, where text is displayed one character at a time, simulating the look of someone typing.
ChatBubble System: A dialog system that uses chat bubbles to present conversations.
Lag-free FPS Cinemachine: A firstperson camera system that is optimized to ensure smooth and responsive movement without lag, even during complex in-game sequences, maintaining immersion.
Finite State Machine: A system that organizes and controls an entity’s behavior by defining specific states and managing the transitions between these states based on certain conditions or events.
Singleton: A design pattern used to ensure that a particular class or system has only one instance running throughout the game.
UI System: Manages all user interface elements, such as buttons, sliders, and status displays, allowing players to interact with the game easily and track their progress, upgrades, and earnings.
Core Game Mechanics Development: Designing and implementing the fundamental gameplay elements that define the player's interaction with the game.
Canvas Optimization: Improves the performance and responsiveness of the game's UI by efficiently managing and rendering UI elements.
Custom Game Engine: A bespoke software framework created specifically for the game, built from scratch using Java
Implemented Football Mechanics: Adding football rules and physics to the game, such as ball control and player movement.
Worked on Game Engine and the Game: Contributed to both the development of the custom engine and the football game itself.
Engine Optimization: Improving the performance and efficiency of the game engine.
Animation and Image Rendering Process: Creating and displaying animations and visuals in the game.
Custom Game Engine: A bespoke software framework created specifically for the game, built from scratch using Java
Worked on Game Engine and the Game: Contributed to both the development of the custom engine and the space force game itself.
Engine Optimization: Improving the performance and efficiency of the game engine.
Animation and Image Rendering Process: Creating and displaying animations and visuals in the game.
Core Game Mechanics Development: Designing and implementing the fundamental gameplay elements that define the player's interaction with the game.
CV_DenizSeker_GameDeveloper.pdfPage updated
Report abuse