Alexander Tokarev

Unity Developer | 6+ years

Production-oriented Unity gameplay, built around explicit ownership.

I build C# gameplay systems with engine-free domain rules, explicit dependency and frame boundaries, failure-safe lifecycles, and validation that catches integration errors before release. The case studies below connect every claim to playable projects and public code.

View selected workContact me

Selected work

Two projects, reviewed through concrete engineering decisions.

The cases cover architecture boundaries, deterministic gameplay, lifecycle rollback and cleanup, automated validation, Editor tooling, and maintainable Unity integration.

Last Seed Survivor rare Acacia Thorn rewardLast Seed Survivor segmented worm enemy combatLast Seed Survivor early gameplay and segmented enemy pressureLast Seed Survivor common, rare, and legendary reward choicesLast Seed Survivor loading screen
1 / 5

01 · Failure-safe Unity architecture

Last Seed Survivor

What happens when a pooled segmented enemy fails halfway through spawn, or an ad callback interrupts a reward flow? Last Seed makes those failure paths explicit, reversible, and testable.

  • Trace one gameplay frame from a single input snapshot through named stages, with engine-free C# state isolated from Unity adapters.
  • Follow segmented-worm construction and reward/ad flows through validation, late commit, reverse rollback, and owned cleanup.
  • See those boundaries enforced by 299 EditMode and 29 PlayMode tests, project validators, deterministic balance simulations, and profiler markers.
  • Unity 6
  • C#
  • Zenject
  • SignalBus
  • UniTask
  • Unity Test Framework
  • Editor Tools
  • Android
Read the case studyGameplaySource code
2D Asteroids Survival gameplay with ship, asteroids, projectiles, score, lives, and recharge state

02 · Architecture & delivery

2D Asteroids Survival

A feature-complete Unity 2022 LTS survival game with custom fixed-step physics, validated JSON configuration, transactional pools, and guarded desktop/mobile delivery.

  • A named fixed-step pipeline runs custom integration, toroidal bounds, collision queries, and presentation synchronization without Unity physics simulation.
  • Four assemblies and domain-focused Zenject installers keep dependencies explicit; one immutable input snapshot is shared by desktop and mobile gameplay.
  • Validated JSON data and transactional enemy/projectile pools make configuration errors, pooled availability, registration ownership, and rollback behavior visible.
  • Unity 2022 LTS
  • C#
  • Custom Physics
  • Zenject
  • SignalBus
  • UniTask
  • JSON
  • Object Pooling
Read the case studyGameplaySource code
Engineering approach & core stack

Engineering approach

Make the normal path readable—and the failure path recoverable.

I separate deterministic C# rules from Unity adapters, then make dependency, frame, and ownership transitions explicit. Tests, project validators, deterministic tooling, and profiler markers verify those boundaries.

Boundaries

Engine-free rules, explicit composition

Domain models and deterministic operations stay in plain C#. Unity and SDK adapters meet them at narrow ports, while focused Zenject composition roots and Assembly Definitions keep dependency direction visible.

Execution

One source of truth per frame

Named coordinators capture input once and run ordered stages. Immutable snapshots and dedicated runtime state keep consumers consistent without magic execution-order values.

Ownership

Commit late, roll back in reverse

Pooled entities, subscriptions, async flows, and scene state have explicit owners. Multi-stage operations validate first, commit ownership after success, and undo completed stages on failure.

Evidence

Runtime rules verified by tools

EditMode and PlayMode tests, scene, configuration, and serialized-reference checks, deterministic simulations, and profiler markers expose regressions before release.

Core stack

Unity gameplay from engine-free rules to platform delivery.

Every capability below maps to public code paths and validation in the two case studies.

Gameplay

C#, Unity, custom 2D simulation, Physics2D, classic Unity Input, Input System, combat, weapons, projectiles, enemies, rewards, progression

Architecture

SOLID, SRP, dependency injection, Zenject, SignalBus, composition roots, Assembly Definitions, validated JSON, ScriptableObjects, domain snapshots

Runtime

Unity Profiler, object pooling, cached lookups, allocation-aware hot paths, explicit frame and lifecycle ownership

Delivery

Unity Test Framework, NUnit, Android, Windows, UGUI, UniTask, Git, GitHub, Unity Editor tooling

Skills & background

Public code for depth, broader Unity tooling for delivery.

The case studies are the evidence layer. This broader toolkit records additional technologies I work with without implying that every item appears in the two public repositories.

Content lifecycle

Async loading with explicit ownership

Addressables handle ownership, UniTask and CancellationToken flows, versioned JSON persistence, localization, Spine, DOTween, and Odin Inspector.

Mobile services

Platform integrations behind clear boundaries

Unity IAP, AppLovin MAX, AdMob, Unity Ads, Firebase Analytics, Crashlytics and Remote Config, plus REST API integration.

Profiling & delivery

Measured runtime work through release

Unity Profiler, Memory Profiler, pooling and non-alloc APIs, TeamCity, Jenkins, Android Studio, Xcode and TestFlight, Git, CI/CD, and code review.

Education & languages

Software engineering

Donetsk National Technical University, Software Engineering (2014). Ukrainian and Russian — native; English — B2.

Contact

Open to Unity gameplay and systems work.

Based in Finland and available for remote B2B or contractor roles as a Unity Developer.

otokarevdev@gmail.comLinkedInGitHub