🎮 Multiplayer FPS - Rust Game Engine

A modern multiplayer first-person shooter built from scratch with Rust and Bevy Engine

Features • Architecture • Getting Started • Tech Stack

---

📋 About The Project

Multiplayer FPS is a modern take on classic maze-based first-person shooters, inspired by Maze Wars. Built entirely in Rust using the Bevy game engine, this project demonstrates advanced game development concepts including real-time networking, 3D physics, and multiplayer synchronization.

🎯 Project Goals

• ✅ Learn Rust Game Development: Master Rust's ownership system in a game context
• ✅ Multiplayer Networking: Implement client-server architecture with UDP
• ✅ 3D Physics: Integrate Rapier3D for realistic collisions and movement
• ✅ Real-time Gameplay: Achieve 50+ FPS with low-latency networking
• ✅ Modern Game Architecture: Use Bevy's ECS (Entity Component System)

---

✨ Features

🎮 Core Gameplay

• First-Person Shooter Mechanics:

  • Smooth camera control with mouse look
  • WASD movement with collision detection
  • Shooting system with bullet physics
  • Health system and player elimination

• 3D Maze Navigation:

  • Procedurally generated or JSON-loaded mazes
  • Dynamic lighting system
  • Wall collisions with Rapier3D physics
  • Multiple spawn points for players

🌐 Multiplayer Features

• UDP Networking:

  • Low-latency client-server architecture
  • Asynchronous networking with Tokio
  • 20 Hz update rate for smooth synchronization
  • Supports up to 10 concurrent players

• Real-time Synchronization:

  • Player position and rotation updates
  • Enemy player rendering and tracking
  • Death state synchronization
  • Automatic game start when lobby is full

📊 UI & Feedback

• In-Game HUD:

  • Real-time FPS counter (green overlay)
  • Minimap with player position
  • Player information display
  • Connection status

• Audio System:

  • Footstep sounds during movement
  • Shooting sound effects
  • Spatial audio (3D positioning)

🎨 Graphics & Physics

• Bevy Rendering:

  • 3D mesh rendering for players and environment
  • Dynamic lighting and shadows
  • Material system with color customization
  • Camera system with configurable sensitivity

• Rapier3D Physics:

  • Rigid body dynamics
  • Collider detection (walls, bullets, players)
  • Gravity-free player movement
  • Locked rotation axes for FPS controls

---

🛠️ Tech Stack

Core Technologies

Technology	Version	Purpose
	1.70+	Primary language (98.8%)
	0.15.1	Game engine & ECS
	0.23.0	Physics engine
	1.x	Async runtime

Key Dependencies

[dependencies]
bevy = "0.15.1"                  # Game engine
rapier3d = "0.23.0"             # Physics simulation
bevy_rapier3d = "0.28.0"        # Bevy-Rapier integration
tokio = { version = "1", features = ["full"] }  # Async networking
serde = "1.0.217"               # Serialization
bincode = "1.3.3"               # Binary encoding
serde_json = "1.0.137"          # JSON parsing
thiserror = "2.0.11"            # Error handling
lazy_static = "1.5.0"           # Static variables
bevy_dev_tools = "0.15.2"       # Development utilities

---

🏗️ Architecture

Project Structure

multiplayer-fps/
├── src/
│   ├── bin/
│   │   ├── client.rs          # Client entry point
│   │   └── server.rs          # Server entry point
│   ├── client/                # Client-side code
│   │   ├── components/        # ECS Components
│   │   │   ├── player_component.rs
│   │   │   ├── enemy_component.rs
│   │   │   ├── camera_component.rs
│   │   │   ├── bullet.rs
│   │   │   └── world_component.rs
│   │   ├── systems/           # ECS Systems
│   │   │   ├── player/        # Player mechanics
│   │   │   │   ├── setup_player.rs
│   │   │   │   ├── move_player.rs
│   │   │   │   ├── rotate_player.rs
│   │   │   │   ├── shooting.rs
│   │   │   │   ├── send_update_player.rs
│   │   │   │   └── step.rs (audio)
│   │   │   ├── enemy/         # Enemy synchronization
│   │   │   │   ├── setup_enemy.rs
│   │   │   │   ├── receiving_update_enemy.rs
│   │   │   │   ├── move_enemy.rs
│   │   │   │   └── handle_animation_enemy.rs
│   │   │   ├── world/         # World generation
│   │   │   │   ├── load_json_world.rs
│   │   │   │   ├── spawn_map.rs
│   │   │   │   └── models_world.rs
│   │   │   └── common/        # Shared systems
│   │   │       ├── fps_display_system.rs
│   │   │       ├── window_config_system.rs
│   │   │       └── light_system.rs
│   │   ├── plugins/           # Bevy Plugins
│   │   │   ├── player_plugin.rs
│   │   │   ├── enemy_plugin.rs
│   │   │   └── world_plugin.rs
│   │   ├── resources/         # Bevy Resources
│   │   │   ├── network_resource.rs
│   │   │   ├── player_resource.rs
│   │   │   ├── enemy_resource.rs
│   │   │   ├── world_resource.rs
│   │   │   └── animation_resource.rs
│   │   └── udp.rs             # Client networking
│   ├── server/                # Server-side code
│   │   ├── udp.rs             # Server networking
│   │   └── utils/             # Server utilities
│   │       └── exception.rs
│   ├── common/                # Shared code
│   │   ├── types/
│   │   │   ├── protocol.rs    # Network protocol
│   │   │   └── game_state.rs
│   │   └── utils/
│   │       └── socket_utils.rs
│   └── lib.rs                 # Library root
├── assets/                    # Game assets
│   ├── sounds/
│   │   ├── running.ogg
│   │   └── shoot.ogg
│   └── models/
├── Cargo.toml                 # Project dependencies
└── README.md

ECS Architecture (Bevy)

Components - Data containers:

• Player, Enemy, Bullet, Camera, Wall

Systems - Logic functions:

• Movement, Rotation, Shooting, Collision, Networking

Resources - Global state:

• NetworkResource, PlayerResource, EnemyResource, MazeResource

Plugins - Feature modules:

• PlayerPlugin, EnemyPlugin, WorldPlugin

---

🚀 Getting Started

Prerequisites

• Rust 1.70 or higher
• Cargo (comes with Rust)
• Git

Installation

1. Clone the repository

git clone https://github.com/mamadbah2/multiplayer-fps.git
cd multiplayer-fps

2. Build the project

cargo build --release

This will compile both client and server binaries.

---

🎮 How to Play

Starting the Server

Option 1: Using Cargo

cargo run --bin server --release

Option 2: Using the compiled binary

./target/release/server

Server Configuration:

Enter the number of players: (default 2) 
> 4

The server will:

• Start listening on 0.0.0.0:8080
• Wait for the specified number of players to connect
• Automatically start the game when lobby is full

Starting the Client

Option 1: Using Cargo

cargo run --bin client --release

Option 2: Using the compiled binary

./target/release/client

Client Configuration:

Enter your name: 
> Player1

Enter the server address (default: 192.168.1.100:8080): 
> localhost:8080

The client will:

• Connect to the server
• Wait in lobby until all players join
• Start rendering the game when ready

---

🎮 Controls

Movement

• W - Move forward
• A - Move left
• S - Move backward
• D - Move right

Combat

• Mouse - Look around / Aim
• Left Click - Shoot
• Spacebar - Jump (if enabled)

UI

• ESC - Exit game
• F3 - Toggle debug info (FPS, position)

---

🌐 Networking

Protocol Design

Message Types:

pub enum Message {
    Join { name: String },
    
    PlayerUpdateSending {
        position: Vec3,
        rotation: Quat,
        all_dead_players: Vec<String>,
    },
    
    PlayerUpdateReceiving {
        name: String,
        position: Vec3,
        rotation: Quat,
        all_dead_players: Vec<String>,
    },
    
    StartGame {
        player: CommonPlayer,
        enemies: Vec<CommonPlayer>,
    },
    
    Leave,
}

Network Architecture

Server:

• UDP socket binding on port 8080
• Broadcast system for player updates
• 20 Hz tick rate
• Player state management with RwLock

Client:

• Asynchronous message receiving
• 20 Hz update sending
• Non-blocking socket operations
• Client-side prediction

Serialization

Uses Bincode for efficient binary serialization:

• Compact message size (~64 bytes per update)
• Fast encoding/decoding
• Zero-copy deserialization where possible

---

🎨 Graphics & Physics

Bevy Rendering Pipeline

1. Setup Phase:

   • Load 3D models and materials
   • Spawn entities (player, enemies, world)
   • Setup camera and lighting

2. Update Phase (60 FPS target):

   • Process input
   • Update physics
   • Network synchronization
   • Animation updates

3. Render Phase:

   • Frustum culling
   • Shadow mapping
   • Material rendering
   • UI overlay

Rapier3D Integration

Colliders:

Collider::cuboid(0.7, 0.1, 0.7)  // Player
Collider::cuboid(2.0, 5.0, 2.0)  // Wall
Collider::ball(0.1)              // Bullet

Physics Configuration:

RigidBody::Dynamic              // Player & bullets
RigidBody::Fixed                // Walls & floor
GravityScale(0.0)              // Disabled for FPS
LockedAxes::ROTATION_LOCKED    // Prevent player tipping

---

🎵 Audio System

Sound Effects

• Footsteps: Looped during movement
• Gunshots: Triggered on fire
• Impacts: Bullet hit sounds

Implementation:

AudioPlayer::new(asset_server.load("sounds/running.ogg"))

Playback controlled by movement state.

---

📊 Performance

Optimization Strategies

Compile-time:

[profile.dev]
opt-level = 1                    # Basic optimization

[profile.dev.package."*"]
opt-level = 3                    # Full optimization for dependencies

[profile.release]
lto = true                       # Link-time optimization
codegen-units = 1               # Single codegen unit

Runtime:

• Entity pooling for bullets
• Spatial partitioning for collision
• LOD system for distant players
• Update rate limiting (20 Hz networking)

Target Performance

• 60 FPS minimum (client rendering)
• < 50ms network latency
• < 100ms input response time
• 10 concurrent players supported

---

🐛 Debugging

Development Tools

Bevy Dev Tools:

bevy_dev_tools = "0.15.2"

Features:

• FPS overlay (green, top-right)
• Entity inspector
• Resource browser
• System profiler

Rapier Debug Rendering:

RapierDebugRenderPlugin::default()

Visualizes:

• Colliders (wireframe)
• Rigid bodies (colored)
• Contact points

---

🚧 Known Issues & Limitations

• Player Limit: Maximum 10 concurrent players
• Lag Compensation: Basic interpolation only
• Collision: Occasional bullet pass-through at high speeds
• Audio: No spatial audio attenuation yet

---

🗺️ Roadmap

Planned Features

• 🎯 Raycast-based shooting (hitscan)
• 🏆 Scoreboard and kill/death tracking
• 🎨 Character models and animations
• 🗺️ Multiple map support
• 🔊 Spatial 3D audio
• 🎮 Gamepad support
• 🌐 Matchmaking system
• 💾 Save/load game state
• 🏅 Achievement system
• 🎥 Spectator mode

Future Improvements

• Lag compensation with server reconciliation
• Client-side prediction improvements
• Anti-cheat measures
• Better error handling and recovery
• Performance profiling and optimization
• Cross-platform testing (Windows, Linux, macOS)

---

🤝 Contributing

Contributions are welcome! Here's how you can help:

1. Fork the repository
2. Create a feature branch (git checkout -b feature/AmazingFeature)
3. Commit your changes (git commit -m 'Add some AmazingFeature')
4. Push to the branch (git push origin feature/AmazingFeature)
5. Open a Pull Request

Development Guidelines

• Write idiomatic Rust code
• Follow Bevy's ECS best practices
• Add documentation for public APIs
• Include tests for new features
• Keep commits atomic and well-described

---

📚 Learning Resources

Rust Game Development

• Bevy Book
• Rapier User Guide
• Rust Async Book

Multiplayer Networking

• Gaffer on Games - Networking
• Source Multiplayer Networking

---

📄 License

This project is available for educational purposes.

---

📧 Contact

Mamadou Bah - @mamadbah2

Project Link: https://github.com/mamadbah2/multiplayer-fps

---

🙏 Acknowledgments

• Bevy Engine Team - For the amazing game engine
• Rapier Physics - For the robust physics library
• Tokio Team - For async runtime
• Rust Community - For excellent documentation and support

---

🎮 Built with Rust & Bevy for Learning Game Development 🎮

⭐ If you found this project helpful, please give it a star! ⭐