Paper.io 2 Clone — 3D Multiplayer

A fully authoritative multiplayer territory-capture game inspired by Voodoo's Paper.io 2. Built with a custom Rust server and Unity 3D client (URP) featuring real-time state sync, procedural trail rendering, flood-fill territory claiming, and client-side prediction.

🏗️ Portfolio Project — Built as a technical showcase for a Senior Game Developer application at Voodoo, the original creators of Paper.io.

What is this?

This is a 3D multiplayer Paper.io 2 clone — a territory-capture game where players navigate a grid, leave colored trails, and claim land by circling back to their own territory. Every enclosed region becomes yours — but your trail is your vulnerability. If anyone crosses it before you close the loop, you're eliminated.

All game mechanics are reimplemented from scratch — no original code or assets from Voodoo are used.

Core Features

◈ Territory Claiming — Draw trails outside your zone and return home to claim everything enclosed. Uses edge-based flood-fill to determine captured regions — including enemy territory.

⚡ Trail Collisions — Cross any player's trail (or your own) and they're eliminated. Head-on collisions, self-intersections, and boundary kills are all handled server-side.

↻ Respawn System — Eliminated players respawn after a short delay with a brief invulnerability window. Spawn position algorithm ensures safe distance from other players.

▦ 3D Rendering — Procedural mesh generation for territory and trails in full 3D. Vertex-colored territory grid, glowing emissive trails, and smooth position interpolation between server ticks.

⟐ Client-Side Prediction — Local input applied immediately with pending input buffering. Server reconciliation replays unacknowledged inputs on authoritative state arrival.

△ Delta Compression — Only changed cells and players are transmitted per tick. Full state sent on join and periodically. RLE encoding for territory chunks minimizes bandwidth.

Architecture & Tech Stack

Designed around a strict authoritative server model — the client never determines game outcomes. The server owns simulation, collision detection, and territory state. The client handles input, rendering, and prediction.

Data Flow

Unity Client	⟵ UDP / Protobuf ⟶	Rust Server
Input capture		Session management
Client-side prediction		Room management
Position interpolation		Game trait interface
Territory mesh renderer		Movement simulation
Trail mesh renderer		Collision detection
Player visuals + pooling		Flood-fill claiming
Camera controller		Delta state broadcast

Tech Breakdown

Layer	Technology	Details
Server	Rust + Tokio	Async game server at 20 tick/s. Sessions, rooms, simulation, collision, flood-fill, protobuf broadcasting
Client	Unity (URP)	Universal Render Pipeline. Procedural mesh generation. New Input System. Object pooling for players, trails, VFX
Protocol	Protobuf over UDP	Binary serialization with sequence numbering. Messages: PaperioState, PaperioDelta, PaperioInput, PaperioJoinResponse
Transport	Custom UDP	Lightweight game-agnostic transport. Session management, sequence checking, duplicate filtering, auto cleanup

Server Responsibilities

System	What it does
Tick Loop	Runs at 20 Hz (50ms). Processes inputs, advances simulation, broadcasts state
Movement	Grid-based. Direction changes apply next tick. Boundary collision handling
Trail System	Tracks positions outside own territory. Triggers claim on return home
Territory Claiming	Converts trail cells + flood-fill from edges to find enclosed regions
Collision Detection	Trail crossing, self-intersection, head-on collision, boundary elimination
Respawn	Delayed respawn with invulnerability. Safe spawn distance algorithm
State Sync	Full state on join, delta updates per tick. RLE territory encoding

Client Responsibilities

System	What it does
Prediction	Applies local input immediately. Buffers pending inputs with sequence numbers
Reconciliation	On server state arrival: snap to authoritative position, replay unacknowledged inputs
Territory Renderer	Procedural mesh with vertex colors per cell. Updates on delta arrival
Trail Renderer	3D tube geometry with emissive glow. Per-player trail tracking and pooling
Player Visuals	Spawning, despawning, color assignment. Object pooling for performance
Interpolation	Smooths movement between server ticks for all remote players

How to Play

Move your avatar across the grid. When you leave your own colored territory, you start leaving a trail. Return to your territory to claim everything your trail encloses — including enemy land. But be careful: if another player crosses your trail before you close it, you're eliminated. The goal is to control the largest percentage of the map.

Platform	Controls
Desktop	WASD or Arrow Keys
Mobile	Swipe in direction to move

Development Notes

⚠️ This is a portfolio / technical showcase project, not a commercial release. Built to demonstrate multiplayer game architecture, server-authoritative design, and production-level Unity development.

⚠️ Original game credit: Paper.io and Paper.io 2 are created by Voodoo. This project is an independent clone built for educational and portfolio purposes. All game mechanics are reimplemented from scratch.

About the Developer

Danylo Golosov — Software Engineer / Game Developer, Berlin, Germany

5+ years of experience in software development with deep expertise in Unity Engine, C#, and C++. Professional background in AR/VR development, cross-platform mobile apps, and backend systems. Previously AR & Web Developer at Zaubar (Berlin), building and shipping 10+ projects with AR Foundation, ARKit, ARCore, and XR Interaction Toolkit.

📧 golo7ov.danil@gmail.com

Paper.io 2 Clone — Rust server · Unity URP client · Protobuf/UDP networking · Built by Danylo Golosov, 2025