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 grid with PvE (single battles, bosses, endless dungeon) and PvP (player vs. player battles) modes. The project is being built for WebGL and is integrated as a Telegram Mini App: the Unity client runs within a React wrapper and communicates 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, a system of relics, potions, buffs, clans, and seasonal events (Halloween, New Year, Flooded Lands).
-
Architecture: state machine hierarchy (global game + separate battle), service layer via interfaces, factories, ScriptableObject settings, Addressables for asset loading.
-
Networking: REST via Best HTTP, PvP turn synchronization via WebSocket bridge (mirror-action protocol), custom P2P consensus anti-cheat with deterministic RNG and nonce protection.
Tech 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 3 years of commercial experience with Unity, including at least 1 year on a single production project with a medium or large codebase (30k+ lines of C#).
- Experience building and optimizing projects for WebGL (build size, Addressables warm-up, memory limitations,
[DllImport("__Internal")], Application.ExternalEval) — critical.
- Experience with deterministic multiplayer networking (turn-based 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 big advantage.
Mandatory Technical Skills
- Above-average C# proficiency: delegates and events, generics, LINQ, async/await, understanding of GC and allocations in the Unity context.
- Unity API: Addressables, coroutines, UniTask, ScriptableObject for 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.
- Networking: 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, WebGL build debugging in 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 — the project extensively uses
[FoldoutGroup], [BoxGroup], [ShowIf], etc.
- Experience with decomposing and refactoring 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, client modification protection.
- 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 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.
- Accuracy when working with PvP logic: any client/server desynchronization breaks the match.
- Readiness for code review (giving and receiving) and working within 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 recruiter contact: working with
TelegramAuthorizatrecruiter contact, TelegramProrecruiter contact, new Game API, handling battle lifecycle events.
- WebGL build optimization: size, loading time, memory consumption, GC profiling, correct Addressables behavior in the browser.
- Refactoring and technical debt reduction: decomposing classes like
Hero.cs (~2000 lines) and battle states (~1500–2000 lines) into narrower components, extracting services.
- UI Features: improving the battle 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 recruiter contact.
- 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-world PvP synchronization case.
- Test task (by agreement): a small feature on a grid with two turn states or a review of a provided code snippet with refactoring suggestions.
How to Apply
Send your resume, a link to your GitHub/GitLab/portfolio, and a brief cover letter: what Unity project do you consider your strongest work and why. As a bonus — any materials on projects with turn-based tactics, multiplayer, or WebGL builds.
