R-Type is a multiplayer shoot 'em up game developed as part of the Advanced C++ / Network Programming module at Epitech Technology.

This project recreates the classic R-Type experience with modern multiplayer capabilities, implementing:

• Client/server architecture in C++17
• UDP network communication via Asio for low-latency real-time gameplay
• Modular game engine based on ECS (Entity Component System)
• Support for up to 4 simultaneous players

Players can connect to a server, choose a game, control their character, shoot enemies or avoid obstacles, and face waves of opponents or obstacles in real-time cooperative gameplay.

• CMake ≥ 3.16
• C++17 compiler (GCC, Clang, or MSVC)
• Asio (standalone or Boost.Asio)
• SFML 3.0.2 (for client rendering)

• Linux
• Windows

git clone https://github.com/EpitechPGE3-2025/G-CPP-500-BDX-5-1-rtype-7.git
cd G-CPP-500-BDX-5-1-rtype-7

mkdir build && cd build
cmake ..
cmake --build .

Executables will be generated at the project root:

• r-type_server — Game server
• r-type_client — Game client

./r-type_server -h 0.0.0.0 -p 8080

./r-type_client -h 127.0.0.1 -p 8080

Multiple clients can connect to the same server for multiplayer gameplay.

R-Type/
├── .github/              # CI/CD workflows
├── assets/               # Game sprites and resources
├── client/               # Client application
│   ├── src/
│   └── CMakeLists.txt
├── gameEngine/           # ECS game engine
│   ├── src/
│   ├── include/
│   └── docs/
├── server/               # Server application
│   ├── src/
│   ├── docs/
│   └── CMakeLists.txt
├── CMakeLists.txt        # Root build configuration
└── README.md

• Real-time server connection via UDP
• Keyboard input handling (movement, shooting)
• Entity rendering (player ships, enemies, projectiles, power-ups)
• Network synchronization with server snapshots
• Low-latency gameplay experience

• Asynchronous UDP networking with Asio
• Dynamic player ID assignment
• Player slot management (max 4 players)
• Game event broadcasting to all connected clients
• Entity management: spawn, movement, collision, destruction
• Timeout-based disconnection detection

• ECS (Entity Component System) for modular and scalable game logic
• UDP protocol for minimal latency (see comparative study)
• Binary packet serialization for efficient network transmission
• Timestamp synchronization for consistent game state

The game uses UDP with a compact binary packet structure:

[Type:1 byte][PacketID:2 bytes][Timestamp:4 bytes][Payload:variable]

Client → Server:

Server → Client:

For complete protocol specification, see Network Protocol Documentation.

• API Documentation — Doxygen-generated API reference
• Game Engine Guide — How to implement game logic with our ECS
• Comparative Studies:
  • Why ECS for Game Engine?
  • Why SFML for Rendering?
  • Why UDP over TCP?

Unit tests can be enabled during build:

cmake -DENABLE_TESTS=ON ..
cmake --build .- **[Game Engine Guide](https://remythai.github.io/R-TYPE/gameEngine)** — How to implement game logic with our ECS
ctest

Tests cover:

• Packet serialization/deserialization
• ECS component behavior
• Client/server interaction logic

• Asio Documentation: https://think-async.com
• ECS Pattern: https://skypjack.github.io/entt/
• UDP Game Networking: Valve Developer Wiki
• SFML Documentation: https://www.sfml-dev.org

This project was developed as part of Epitech's educational curriculum.
Use is restricted to learning and technical demonstration purposes.

For questions, suggestions, or contributions, please open an issue on the GitHub repository.

Repository: https://github.com/EpitechPGE3-2025/G-CPP-500-BDX-5-1-rtype-7