• 📖 Description
• ✨ Features
• 🎨 Gallery
• 💻 Requirements
• 📦 Dependencies
• 📚 Documentation
• 👥 Contributors
• 🛠️ Installation Guide
• 🎮 Games
  • R-Type
  • BeatSaber
• 📄 License
• ❤️ Coded with Love

The R-Type Project is a comprehensive game development ecosystem centered around the TKD Engine (TekyoDrift Engine), a production-ready, modular game engine designed specifically for networked multiplayer applications. This project demonstrates enterprise-grade software architecture principles through its implementation of complete game prototypes and development tools.

Built entirely in modern C++20, the project encompasses:

• 🎯 TKD Engine: A dual-mode (client/server) game engine with robust networking capabilities
• 🎮 Complete Games: Two fully functional game implementations showcasing engine capabilities
• 🔧 Development Tools: Specialized utilities for asset management, resource packing, and debugging
• 🌐 Network Architecture: High-performance client-server multiplayer system with real-time synchronization
• 🏗️ Modular Design: Reusable components following SOLID principles and modern C++ best practices

The engine leverages cutting-edge technologies including Entity-Component-System (ECS) architecture, Asio-based networking, SFML graphics, and experimental OpenVR integration for virtual reality experiences. Designed with cross-platform compatibility, performance optimization, and developer productivity in mind, the TKD Engine provides a solid foundation for building complex, networked multiplayer games.

• Modern C++20 Architecture: Leveraging latest language features for type safety, performance, and maintainability
• Dual-Build System: Single codebase producing both client (with graphics) and server (headless) executables
• Entity-Component-System (ECS): Flexible, composition-based game object management with runtime behavior modification
• Thread-Safe Components: Built-in concurrency primitives and synchronization for parallel execution
• Memory Management: RAII principles, smart pointers, and deterministic resource management
• Cross-Platform Support: Consistent behavior across Linux, Windows, and macOS

• High-Performance UDP Protocol: Custom binary protocol optimized for minimal bandwidth and latency
• Asio-Powered I/O: Asynchronous, non-blocking network operations for maximum throughput
• Reliable Transmission Layer: ACK/NACK system with automatic retransmission and duplicate detection
• Client-Server Architecture: Dedicated server support with multiple concurrent client connections
• Real-Time Synchronization: Delta compression and snapshot interpolation for smooth gameplay
• Network Statistics: Built-in monitoring for latency, packet loss, and bandwidth utilization
• Type-Safe Packet System: Automatic serialization/deserialization with virtual dispatch

• SFML-Based Pipeline: Modern OpenGL backend with shader support
• Component-Based Rendering: Modular rendering system with material and texture management
• Camera System: Multi-viewport support with 2D/3D transformations
• Sprite & Animation Management: FlipBook system for 2D sprite animations
• Shader System: Custom shader support for advanced visual effects
• ImGui Integration: Immediate-mode GUI for debug tools and in-game interfaces

• 3D Positional Audio: Spatial sound processing with listener management
• Multi-Format Support: WAV, OGG, FLAC audio playback
• Audio Streaming: Efficient streaming for large audio files
• Effect Processing: Real-time audio effects and filters
• Sound Source Management: Multiple simultaneous audio sources with priority system

• Comprehensive Math Library: Vectors (2D/3D/4D), matrices, quaternions, transforms
• Geometric Primitives: Rectangles, circles, spheres, planes, boxes, capsules, rays
• Collision Detection: AABB, OBB, sphere, and ray-based collision systems
• Interpolation Functions: Linear, spherical, cubic, and custom interpolation utilities
• Color Management: 8-bit and floating-point color spaces with conversion utilities

• TKDPack: Asset packaging utility for bundling resources into optimized .pak archives with compression
• TKDEmbed: Binary-to-C++ header converter for compile-time asset embedding
• TKDGraph: Visual debugging and profiling tools with ImGui-based interface
• Testing Framework: Comprehensive unit tests using Catch2
• Logging System: Multi-level logging (Debug, Info, Warning, Error, Critical) with file output

• Actor-Component Model: Flexible game object composition with inheritance and polymorphism
• World Management: Scene organization, level loading, and object lifecycle management
• Time Management: Delta time calculation, fixed timestep support, and time scaling
• Input System: Unified keyboard, mouse, and gamepad input handling with action mapping
• Event System: Type-safe event broadcasting and subscription
• Configuration Management: INI-based configuration with runtime modification
• Save/Load System: Binary and JSON serialization for game state persistence

• OpenVR Integration: Steam VR support for HTC Vive, Valve Index, and compatible headsets
• VR Camera System: Head-mounted display tracking and stereoscopic rendering
• Motion Controllers: Hand tracking and controller input
• Room-Scale Experiences: Chaperone system integration for safe VR gameplay

• Resource Handles: Smart pointer-based asset management with automatic lifetime tracking
• Pak File System: Custom archive format for efficient asset distribution
• Hot Reloading: Runtime asset reloading for rapid iteration during development
• Texture Atlas Support: Sprite sheet management with automatic sub-texture extraction
• Async Loading: Background asset loading to prevent frame drops

OpenVR Integration Tests

VR Camera Tracking & Rendering	Motion Controller Integration

🎥 Note: Video demonstrations showcasing experimental VR features with the TKD Engine

• CMake 3.21 or higher
• Python 3.7+ with pip
• C++ Compiler with C++20 support:
  • Linux: GCC 10+ or Clang 12+
  • Windows: Visual Studio 2019+ or MinGW-w64
  • macOS: Xcode 12+ or Clang 12+
• Git for version control
• Conan 2.x package manager

The R-Type project utilizes the following third-party libraries, automatically managed through Conan:

All dependencies are automatically downloaded, configured, and linked during the build process via Conan package manager. No manual installation required.

Comprehensive documentation is available in the Documentation/ directory:

• Project Overview - Executive summary, architecture, and technical stack
• Getting Started - Quick start guide and first steps
• Features - Detailed feature descriptions and technical capabilities
• Directory Layout - Project structure and organization
• Changelog - Version history and release notes
• Contributing - Contribution guidelines and coding standards
• License - Licensing information

Located in Documentation/Engine/:

• Engine Overview - TKD Engine architecture and design
• Building the Engine - Compilation instructions and configuration
• Usage Examples - Code samples and tutorials
• Testing - Unit testing and quality assurance

Detailed API documentation for each engine module in Documentation/Engine/Modules/:

• Core - Foundation systems, containers, mathematics, concurrency
• Runtime - Actor-component system, world management, game loop
• Network - Client-server architecture, packet system, protocols
• Renderer - Graphics pipeline, materials, shaders, cameras
• Audio - Sound management, 3D audio, streaming
• Config - Configuration system and engine settings
• Static - Engine initialization and bootstrapping
• Debug - Logging, profiling, and debugging utilities

Complete API references in Documentation/Engine/Scripting References/:

• Actors - Base actor classes, cameras, pawns, HUD
• Animations - 2D animations, flipbooks, state machines
• Assets - Resource management, pak files, loading system
• Audio - Audio buffers, sources, effects, listeners
• Controllers - Player and AI controller systems
• Math - Vectors, matrices, quaternions, transforms, geometry
• Network - Networking classes, packets, binary serialization
• Renderer - Rendering components, materials, shaders
• Widgets - UI system and widget classes

Located in Documentation/Tools/:

• TKDPack - Asset packaging tool documentation
• TKDEmbed - Binary embedding utility guide
• TKDGraph - Visual debugging tool manual

This project is the result of collaborative effort from our talented development team:

👑 Project Leadership

Mallory SCOTTON
Project Leader · Lead Engine Developer

🛠️ Core Development Team

Nathan FIEVET	Hugo CATHELAIN
Team Coordinator · Engine & Network Developer	Game Engine Developer

🎮 Game Development Team

Ossan MSOILI	Raphael OSTIER
Game Developer	Game Developer

---

💡 Contributions Welcome!
See our Contributing Guide and Code of Conduct

The easiest way to build R-Type is using our automated build scripts that handle all dependencies and configuration:

chmod +x Scripts/Build.sh
./Scripts/Build.sh

.\Scripts\Build.bat

These scripts automatically:

• ✅ Install system dependencies (pipx, cmake, build tools)
• ✅ Install and configure Conan package manager
• ✅ Set up the build environment
• ✅ Configure CMake with optimal settings
• ✅ Build the project with all games and tools

If you prefer manual control over the build process:

Linux (Ubuntu/Debian):

sudo apt update
sudo apt install build-essential cmake python3-pip pipx git

Linux (CentOS/RHEL/Fedora):

sudo yum groupinstall "Development Tools"
sudo yum install cmake python3-pip git
python3 -m pip install --user pipx

macOS:

# Install Homebrew if not present
/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

# Install dependencies
brew install cmake pipx git

Windows:

• Install Visual Studio 2019+ with "Desktop development with C++" workload
• Install CMake and add to PATH
• Install Python 3.7+ with pip
• Install Git for Windows

Linux/macOS:

pipx install conan
pipx ensurepath

Windows:

python -m pip install conan

conan profile detect --force

git clone https://github.com/mallory-scotton/rtype.git
cd rtype

conan install . \
  --output-folder=Build \
  --build=missing \
  --settings=build_type=Release \
  --settings=compiler.cppstd=20 \
  -c tools.system.package_manager:mode=install

cmake -B Build -S . -DCMAKE_BUILD_TYPE=Release

cmake --build Build --config Release

After successful compilation, executables are located in Build/bin/:

# Run R-Type game server
./Build/bin/RTypeGameServer

# Run R-Type game client
./Build/bin/RTypeGameClient

# Run TKDPack tool
./Build/bin/TKDPack --help

Build/
├── bin/                      # Executable files
│   ├── RTypeGameClient       # R-Type client executable
│   ├── RTypeGameServer       # R-Type server executable
│   ├── BeatSaberGameClient   # BeatSaber client executable
│   ├── BeatSaberGameServer   # BeatSaber server executable
│   ├── TKDEngineClient       # Engine client library test
│   ├── TKDEngineServer       # Engine server library test
│   ├── TKDEngineTests        # Engine unit tests
│   ├── TKDPack               # Asset packing tool
│   └── TKDEmbed              # Binary embedding tool
├── lib/                      # Shared libraries (.dll, .so, .dylib)
└── Assets/                   # Game assets (copied from Games/)

conan profile detect --force

conan profile path default
# Edit the file and ensure C++20 is set

Need Additional Help?

• Check the Documentation
• Review build logs for specific error messages
• Open an issue on GitHub

This project uses clang-format-19 for consistent code style.

Installation:

# Ubuntu/Debian
sudo apt install clang-format-19

# macOS
brew install clang-format

# Windows (via Chocolatey)
choco install llvm

Usage:

# Format single file
clang-format-19 -i path/to/file.cpp

# Format all C++ files
find . -name "*.cpp" -o -name "*.hpp" | xargs clang-format-19 -i

VS Code Integration:

Add to .vscode/settings.json:

{
  "C_Cpp.clang_format_path": "clang-format-19",
  "C_Cpp.clang_format_style": "file",
  "editor.formatOnSave": true,
  "[cpp]": {
    "editor.defaultFormatter": "ms-vscode.cpptools"
  }
}

The R-Type project includes two complete game implementations showcasing the TKD Engine's capabilities:

A complete recreation of the classic R-Type arcade shooter featuring networked multiplayer gameplay. Demonstrates the engine's capabilities in 2D game development, real-time networking, and client-server architecture.

• ✨ Classic Gameplay: Faithful recreation of R-Type mechanics
• 🌐 Multiplayer Support: Up to 4 simultaneous players via client-server architecture
• 🎮 Real-Time Synchronization: Smooth gameplay with delta compression and interpolation
• 🎨 Sprite Animation System: FlipBook-based 2D animations
• 💥 Particle Effects: Explosions, weapon effects, and environmental particles
• 🎵 Audio Integration: Music and sound effects with 3D positional audio
• 🏆 Scoring System: Player statistics and leaderboards
• 📦 Pak File Assets: Optimized asset loading using TKDPack format

• Entity-Component-System for game object management
• Custom network protocol with reliable UDP transmission
• State synchronization with snapshot interpolation
• Client-side prediction for responsive controls
• Server-authoritative gameplay preventing cheating

# Start dedicated server
cd Build/bin
./RTypeGameServer --port 4242

# Start client and connect
./RTypeGameClient --server localhost --port 4242

Configuration:

• Server settings: Build/bin/Data/server.ini
• Client settings: Build/bin/Data/client.ini

An experimental VR rhythm game prototype showcasing the TKD Engine's OpenVR integration capabilities. Features head-mounted display tracking, motion controller support, and 3D audio for immersive gameplay.

• 🥽 VR Support: OpenVR integration for SteamVR-compatible headsets
• 🎯 Motion Controllers: Hand tracking and gesture recognition
• 🎵 Rhythm Gameplay: Music-synchronized obstacle generation
• 🎨 3D Rendering: Stereoscopic rendering for VR displays
• 🔊 Spatial Audio: 3D positional audio for immersive sound
• 🏠 Room-Scale: Chaperone system integration

• OpenVR SDK integration for HMD and controller tracking
• Custom VR camera system with stereoscopic projection
• Motion controller input mapping
• Performance optimization for 90Hz VR rendering
• Experimental physics-based sword mechanics

Requirements:

• SteamVR-compatible VR headset (HTC Vive, Valve Index, Oculus Rift, etc.)
• SteamVR runtime installed
• Motion controllers

# Ensure SteamVR is running, then start the game
cd Build/bin
./BeatSaberGameClient

⚠️ Note: This is an experimental prototype demonstrating VR capabilities. Full gameplay features are still in development.

This project is licensed under the MIT License - see the LICENSE.md file for complete details.

MIT License

Copyright (c) 2025 TekyoDrift

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.

This project uses several open-source libraries, each with their own licenses:

• SFML - zlib/libpng License
• Asio - Boost Software License 1.0
• ImGui - MIT License
• Catch2 - Boost Software License 1.0
• OpenVR - BSD 3-Clause License
• nlohmann_json - MIT License