The R-Type project represents a comprehensive game development framework centered around the TKD Engine (TekyoDrift Engine), a modern, modular game engine designed for networked multiplayer applications. The project demonstrates enterprise-grade software architecture principles through its implementation of two complete game prototypes: a networked multiplayer recreation of the classic R-Type arcade shooter and an experimental VR rhythm game (Beat Saber).
Built entirely in C++20, the project encompasses a full-stack game development ecosystem including a dual-mode game engine (client and server variants), specialized asset management tools, and complete game implementations showcasing the engine's capabilities in both 2D and experimental 3D/VR contexts.
- Game Engine Development: Design and implement a production-ready game engine with robust networking capabilities, optimized for multiplayer gaming scenarios
- Client-Server Architecture: Demonstrate scalable network architecture supporting multiple concurrent clients with real-time synchronization
- Cross-Platform Compatibility: Ensure consistent behavior across Linux, Windows, and macOS platforms
- Modular Design: Create reusable, maintainable components that can be leveraged across multiple game projects
- Asset Pipeline: Develop efficient asset management and distribution systems for game resources
- Leverage modern C++20 features for type safety, performance, and maintainability
- Implement Entity-Component-System (ECS) architecture for flexible game object management
- Provide both headless server and graphical client builds from a unified codebase
- Achieve sub-millisecond frame times with efficient memory management
- Support binary asset packing for optimized distribution and loading
The R-Type project consists of three primary layers:
The foundation of the entire project, providing essential game engine functionality:
- Core Systems: Memory management, mathematics library, data structures, and type utilities
- Runtime Systems: Game loop implementation, actor-component framework, world management, and time synchronization
- Network Layer: High-performance networking powered by Asio, featuring binary serialization, custom packet protocols, and connection management
- Renderer: SFML-based graphics pipeline with material system, shader support, and camera management
- Audio: Sound management and 3D audio processing
- Configuration: INI-based configuration system and build-time constants
The engine is distributed as two separate libraries:
- TKDEngineClient: Full-featured client library with graphics and audio support
- TKDEngineServer: Lightweight headless server library optimized for dedicated game servers
Specialized utilities supporting the development and distribution pipeline:
- TKDPack: Asset packaging utility for bundling game resources into optimized binary archives
- TKDEmbed: Resource embedding tool for compile-time asset integration
- TKDGraph: Development and debugging utilities for engine visualization
Reference implementations demonstrating engine capabilities:
- R-Type Game: Networked multiplayer side-scrolling shooter featuring real-time client-server synchronization
- Beat Saber Game: Experimental VR rhythm game prototype utilizing OpenVR integration
| Technology | Version | Purpose |
|---|---|---|
| C++ | 20 | Primary implementation language |
| CMake | 3.21+ | Build system and project configuration |
| Conan | 2.x | Package management and dependency resolution |
| SFML | 2.6.2 | Graphics, windowing, and audio rendering |
| Asio | 1.36.0 | Asynchronous networking and I/O |
| Catch2 | 3.10.0 | Unit testing framework |
| ImGui | 1.91.8 | Immediate-mode GUI for debugging tools |
| OpenVR | 1.16.8 | Virtual reality integration |
| nlohmann_json | 3.12.0 | JSON serialization and configuration |
- OpenGL: Hardware-accelerated rendering
- GLEW (2.2.0): OpenGL extension loading
- zlib (1.3.1): Compression for asset archives
- mesa-glu (9.0.3): OpenGL utility library (Linux/macOS)
- Dual-Build System: Single codebase producing both client and server executables, reducing maintenance overhead
- Actor-Component Model: Flexible composition-based game object system enabling runtime behavior modification
- Thread-Safe Design: Concurrent systems with built-in synchronization primitives
- Memory-Efficient: RAII principles and smart pointer usage ensuring deterministic resource management
- Hot-Reloadable Assets: Support for runtime asset reloading during development
- High-Performance Protocol: Custom binary protocol optimized for low-latency communication
- Hybrid Transport: UDP for game state updates, TCP for reliable critical messages
- Client Prediction: Client-side prediction with server reconciliation for responsive gameplay
- Network Statistics: Built-in monitoring for bandwidth, latency, and packet loss
- Scalable Architecture: Designed to support multiple concurrent game sessions
- Automated Build System: Cross-platform build scripts handling dependency installation and configuration
- Asset Pipeline: Integrated tools for resource processing, packing, and embedding
- Unit Testing: Comprehensive test suite with Catch2 framework
- Code Formatting: Clang-Format integration for consistent code style
- Cross-Platform: Unified build system supporting Linux, Windows, and macOS
rtype/
├── Engine/ # TKD Engine core implementation
│ ├── Source/ # Engine source code
│ │ ├── Core/ # Foundation systems
│ │ ├── Runtime/ # Game loop and actor framework
│ │ ├── Network/ # Networking layer
│ │ ├── Renderer/ # Graphics pipeline
│ │ └── Audio/ # Audio systems
│ ├── Tests/ # Engine unit tests
│ └── cmake/ # Build configuration
│
├── Games/ # Game implementations
│ ├── RType/ # Networked shooter implementation
│ └── BeatSaber/ # VR rhythm game prototype
│
├── Tools/ # Development utilities
│ ├── TKDPack/ # Asset packing tool
│ ├── TKDEmbed/ # Resource embedding utility
│ └── TKDGraph/ # Debugging and visualization tools
│
├── Documentation/ # Technical documentation
├── Scripts/ # Build automation scripts
└── Build/ # Build output directory
- Linux: Ubuntu 20.04+, Debian 11+, CentOS 8+, Arch Linux
- Windows: Windows 10/11 (x64)
- macOS: macOS 10.15+ (Catalina and later)
- GCC: 10.0 or higher
- Clang: 12.0 or higher
- MSVC: Visual Studio 2019 or higher
- Apple Clang: Xcode 12.0 or higher
All compilers must provide full C++20 standard library support including concepts, ranges, and coroutines.
- Frame Time: Target 60 FPS (16.67ms per frame) with typical performance exceeding 120 FPS
- Network Latency: Sub-50ms client-to-server round-trip time on local networks
- Memory Footprint:
- Client: ~200MB base + asset memory
- Server: ~50MB base (headless)
- Concurrent Connections: Tested with 32+ simultaneous clients per server instance
- Zero-copy serialization where applicable
- Object pooling for frequently allocated objects
- Spatial partitioning for collision detection and rendering culls
- Multithreaded asset loading
- Efficient packet batching to minimize network overhead
The R-Type project serves as a reference implementation for developing networked multiplayer games with the following characteristics:
- Fast-paced action requiring low latency
- Multiple concurrent players in shared game sessions
- Real-time state synchronization
- Client-server authority model
- Educational Platform: Demonstrates modern game engine architecture and networking principles
- Prototyping Framework: Rapid game concept development with established infrastructure
- Research Platform: Network protocol experimentation and performance analysis
- Portfolio Project: Showcases enterprise-level software engineering practices
Current Version: 1.0.0
Release Date: October 2025
Status: Stable Release
The project has reached feature completeness for its initial release objectives. All core engine systems are production-ready, with comprehensive testing coverage and documentation. Both reference games (R-Type and Beat Saber) are fully playable and demonstrate the engine's capabilities.
- Engine Core: Production-ready
- Networking Layer: Stable
- Asset Pipeline: Functional
- Documentation: Comprehensive
- Testing: Unit tests for critical systems
- Platform Support: All target platforms validated
License: MIT License
Copyright: 2025 R-Type Development Team
The project is released under the permissive MIT license, allowing for both commercial and non-commercial use with minimal restrictions. See LICENSE.md for complete terms.
This project builds upon several open-source libraries and frameworks. Full attribution and licensing information for all dependencies can be found in the respective component documentation.
For detailed installation instructions, build procedures, and development guidelines, please refer to:
- Getting Started Guide - Installation and build instructions
- Features Documentation - Detailed feature descriptions
- Engine Documentation - TKD Engine architecture and API reference
- Contributing Guide - Development workflow and contribution guidelines
For technical inquiries, bug reports, or contributions, please refer to:
- Repository: GitHub Repository
- Documentation: See the
Documentation/directory - Issues: GitHub Issues for bug tracking and feature requests
- Authors: See
AUTHORS.mdfor contributor information
This document provides a high-level overview of the R-Type project architecture and capabilities. For detailed technical specifications, API documentation, and implementation guides, please consult the specialized documentation in the respective component directories.