Company: Empire's Battle
Work format: remote
Employment: part-time
PvE / PvP turn-based tactical game « Empire's Battle Combat Arena »
About the project
«Empire's Battle Combat Arena» is a turn-based tactical 2D game on a hexagonal grid with PvE (single battles, bosses, endless dungeon) and PvP modes (player vs player battles). The project is built for WebGL and integrated as a Telegram Mini App: the Unity client runs within a React wrapper and exchanges messages with it via a JavaScript bridge (Application.ExternalEval, custom SocketUtility).
Key characteristics of the codebase:
- Size: ~42,000 lines of C# in 280+ files, active development, technical debt exists (large classes of 1500–2100 lines requiring decomposition).
- Content: 17+ playable heroes with complex active and passive skills, 5+ unique bosses, systems for relics, potions, buffs, clans, and seasonal events (Halloween, New Year, Flooded Lands).
- Architecture: state machine hierarchy (global game + separate combat), service layer via interfaces, factories, ScriptableObject configurations, Addressables asset loading.
- Networking: REST via Best HTTP, PvP turn synchronization via WebSocket bridge (mirror-action protocol), custom anti-cheat on P2P consensus with deterministic RNG and nonce protection.
Technology Stack
Category
Technologies
- Engine and Pipeline
- Unity 2022.x LTS, Universal Render Pipeline (URP) 14, 2D Sprite/Tilemap, Post-processing
- Build Platform
- WebGL (as Telegram Mini App), interop with React via Application.ExternalEval
- Asynchronicity
- UniTask (Cysharp.Threading.Tasks), coroutines, async/await
- Network Layer
- Best HTTP/2, custom JS-bridge over WebSocket, REST API, Newtonsoft.Json, SimpleJSON
- Content Loading
- Unity Addressables 1.21, AssetReferenceGameObject, asynchronous initialization
- UI
- uGUI, TextMesh Pro, Unity Localization, UI Extensions, custom radar charts
- Editor Tools
- Odin Inspector (Sirenix) — widely used throughout the codebase, NuGetForUnity, Toolbar Extender
- Monetization and Analytics
- Unity IAP 4.11, Unity Ads 4.4, Unity Analytics, custom error logging server
- Version Control
- GitLab (corporate), classic Git flow model
Candidate Requirements
Level and Experience
Target level — Middle+ / Senior Unity Developer. Minimum of 3 years of commercial experience with Unity, including at least 1 year on one production project with a medium or large codebase (from 30k+ lines of C#).
- Experience building and optimizing projects for WebGL (build size, Addressables warmup, memory limitations,
[DllImport("__Internal")], Application.ExternalEval) — critical.
- Experience with deterministic logic network multiplayer (turn synchronization, lockstep / mirror-action, fixed-point or deterministic random).
- Experience with Telegram Mini Apps / WebApp SDK or similar integration of a Unity client into a web wrapper — a significant advantage.
Mandatory Technical Skills
- C# at an intermediate to advanced level: delegates and events, generics, LINQ, async/await, understanding of GC and allocations in the Unity context.
- Unity API: Addressables, coroutines, UniTask, ScriptableObject as content configs, MonoBehaviour lifecycle, Animator, Particle System, 2D Sprite Renderer.
- Architectural Patterns: State Machine (two nested state hierarchies in the project — understanding is mandatory), Observer/Event-driven, Service Locator or DI, MVC/MVP for UI, factories.
- Network Operations: REST clients (Best HTTP or UnityWebRequest), Newtonsoft.Json serialization, error handling and reconnections, understanding of JWT/Bearer tokens.
- Debugging and Profiling: Unity Profiler, Memory Profiler, Frame Debugger, debugging WebGL builds in the browser (Chrome DevTools, .symbols).
- Git and Teamwork in GitLab: branches, MR/Code Review, understanding merge conflicts, writing adequate commit messages.
Desirable
- Experience with Odin Inspector — almost the entire project uses
[FoldoutGroup], [BoxGroup], [ShowIf], etc.
- Experience with decomposition and refactoring of large monolithic classes (God Objects) into services, controllers, and states — the project has several such classes.
- Understanding of cryptography basics and anti-cheat mechanics: HMAC, nonce, deterministic RNG, protection against client modification.
- Experience with turn-based tactical games (XCOM-like, Heroes-like, chess engines) — will be a huge plus for understanding gameplay logic.
- Basic knowledge of JavaScript/TypeScript — for debugging the React ↔ Unity bridge.
- Experience with integrating IAP, ads (Unity Ads / AppLovin / IronSource), analytics.
Soft Skills
- Ability to read and understand others' code in a large codebase (individual files of 1500–2000 lines).
- Independence in tasks, ability to ask the right questions — the project has monolithic sections without detailed documentation.
- Meticulousness when working with PvP logic: any client/server desynchronization breaks the match.
- Willingness for code review (giving and receiving) and working in Git Flow with mandatory MRs.
Role Responsibilities
- Development of game mechanics: new heroes, skills (active and passive), bosses, dungeon types, seasonal events — adding to the existing
SkillRegistry and effect system.
- Working with PvP states (
PvpPlayerTurnState, PvpOpponentTurnState): turn synchronization via mirror-action, handling reconnections, expanding anti-cheat mechanics (P2PSecurityManager, P2PConsensusManager).
- Integration with backend and Telegram WebApp: working with
TelegramAuthorizationProvider, TelegramProvider, new Game API, handling battle lifecycle events.
- WebGL build optimization: size, loading time, memory consumption, GC profiling, correct Addressables operation in the browser.
- Refactoring and technical debt reduction: decomposing classes like
Hero.cs (~2000 lines) and battle states (~1500–2000 lines) into more focused components, extracting services.
- UI features: improving the combat HUD, hero selection screens, potion and relic inventory, interface localization.
- Build pipeline and CI support: building via GitLab CI, auto-deploying WebGL builds to the Telegram environment.
- Code review of colleagues' MRs, maintaining project style and architectural conventions.
Selection Process
- Resume screening — relevant experience in Unity + WebGL + network code.
- Technical interview (60–90 min): C#, Unity architecture, state machines, discussion of a real case with PvP synchronization.
- Test task (upon agreement): a small feature on a hexagonal grid with two turn states or a review of a provided code snippet with refactoring suggestions.
How to Apply
Please send your resume, a link to your GitHub/GitLab/portfolio, and a short cover letter: which Unity project you consider your strongest work and why. As a bonus — any materials on projects with turn-based tactics, multiplayer, or WebGL builds.
