Week3

Week #3 #

Implemented MVP features #

User Journey #

  1. The user launches our Unity game build.
  2. The client (game) automatically connects to the server.
  3. The player is spawned at a random location on the map and can start playing immediately.
  4. All player actions (movement, rotation, shooting, hits) are sent as packets to the server.
  5. The server processes these packets, maintains tick synchronization, and sends world state updates (positions, shots, etc.) back to the client.
  6. If a player is killed, they are disconnected from the server.
  7. The player can open the in-game menu at any time and exit the game through it.

Client-side Features #

  • Weapon selection system: players can choose which weapon to use for shooting.
  • In-game menu: accessible at any time, allows the player to exit the game.
  • Player health and armor system: displays both a bar and a numeric value next to it.
  • Advanced player movement and shooting mechanics.
  • Real-time communication with the server via LiteNetLib (UDP).
  • Player is spawned at a random point on the map at the start of the game.
  • All player actions (movement, rotation, shooting, hits) are sent to the server as packets.
  • The client receives and processes world state updates from the server.

Server-side Features #

  • Tick-based architecture: the server maintains a tick counter and synchronizes it with clients.
  • Lag compensation: the server reconstructs world state for accurate hit registration.
  • All data is stored in-memory for fast access.
  • Processes and validates all client packets (movement, shooting, hit registration).
  • Disconnects players when their HP reaches zero.
  • For each shot, the client sends a packet with the bullet’s direction; the server verifies hits using mathematical calculations and updates player HP accordingly.
  • Sends world state updates to all clients.

Features Implemented This Week #

General #

Refactored the codebase and conducted code reviews for both client and server. !Links to relevant commits where changes were made, if applicable

Client #

Selected player, weapon, and tool models tailored to the target audience. Implemented functionality for player health, shooting, advanced player movement, and set up communication with the server via LiteNetLib (sending and receiving UDP packets). The game map was created and designed with the genre and multiplayer in mind, taking inspiration from popular maps in similar games. Commits where this was implemented: !links to commits

Map

Player 1

Player 2

Implemented complex character animations triggered by user events and reflecting player actions:

  • Idle animation
  • Walking animation
  • Jump animation
  • Shooting animation

A rich arsenal of weapons was implemented, each with unique properties:

Phantom (Riffle)

Phantom

  • Medium damage
  • Fire rate: 0.1 seconds per shoot
  • Large magazine (27 rounds)
  • Total ammo: 200 rounds

Game Server Logic #

  • Implemented a tick-based architecture: the server maintains a tick counter and stores world state snapshots every N ticks, allowing for lag compensation and accurate event processing.
  • Added in-memory storage for player and session data, replacing DB usage for real-time operations to significantly improve performance.
  • Implemented lag compensation: the server can reconstruct the world state at any tick, enabling fair hit registration even with network delays.
  • Developed a new packet exchange protocol:
    • PlayerShootPacket now includes a direction vector.
    • Introduced PlayerHitPacket for client-side hit registration, which the server verifies using world history.
  • Refactored hit logic: all hit checks are now performed against historical world states, not just current positions.
  • Added health (HP) to players, with logic for reducing HP on hit and removing/disconnecting players when HP reaches zero.
  • All legacy DB-based session/player logic is commented out but preserved for reference.
  • Codebase was refactored, bugs fixed, and code review practices established.
  • Database migrations were created and proper server-DB interaction was set up.

Demonstration of the working MVP #

Demo

Internal demo #

Demo demonstrates client view of the game including moving and shooting on map.

Weekly commitments #

Individual contribution of each participant #

Vsevolod Nazmudinov

Igor Kuzmenkov

Ilyas Khatipov

Gleb Lobov

Slava Molchanov

Almas Bagishaev

Plan for Next Week #

At this stage, we have all the core logic required for a shooter, but the project has great potential for further development, optimization, and new features. Next week we plan to:

  • Conduct a full code review, discuss architectural and functional decisions
  • Improve server-side hit detection logic
  • Analyze and, if necessary, revise the game map
  • Perform load testing on the game server and determine optimal configuration (tickrate, world state history length, etc.)
  • Refine existing weapons and add new ones if needed
  • Optimize current algorithms and solutions
  • Finalize database interaction logic
  • Hold several team meetings
  • Explore further use of LiteNetLib to optimize packet exchange between server and clients

Confirmation of the code’s operability #

We confirm that the code in the main branch:

  • [✓] Is in working condition.
  • [✓] Runs via docker-compose (or another alternative described in the README.md).