"Games are built by developers, run by players, and owned by communities."
Rox-Engine is an innovative, decentralized game engine/framework written in C++, designed to revolutionize the development of Web3-native games. It empowers developers to create immersive, secure, and decentralized gaming experiences with advanced cryptographic features and seamless blockchain integration.
Note: Rox-Engine is currently in its early development stages (Alpha phase). We are actively expanding its capabilities and maintaining consistency across our repositories:
Contributions from the community are highly encouraged!
- Key Features
- Architecture Overview
- Getting Started
- Documentation
- Roadmap
- Contributing
- License
- Contact
- Important Notice
- Decentralized Multiplayer: Enables direct peer-to-peer connections between players, allowing each game instance to function as a node within a decentralized network.
- Serverless Architecture: Eliminates reliance on centralized servers, reducing costs and single points of failure.
- Scalable Networking: Designed to support a large number of concurrent players with efficient resource utilization.
- Enhanced Privacy: Plans to integrate with anonymity networks such as Tor or I2P to conceal players' IP addresses and metadata.
- Secure Communication: Utilizes encrypted channels to protect data exchange between nodes.
- User Safety: Protects players from potential DDoS attacks and location tracking.
-
Secure Verification: Implements experimental ZKP mechanisms, allowing players to prove ownership of in-game assets without revealing sensitive information.
-
Anti-Cheating Measures: Verifies player actions and transactions without exposing underlying data, reducing fraud and cheating.
-
Cryptographic Innovations: Explores cutting-edge cryptographic techniques to enhance game security and integrity.
Note: ZKPs are advanced cryptographic protocols that enable one party (the prover) to prove to another (the verifier) that a statement is true without revealing any information beyond the validity of the statement itself.
- Blockchain Integration: Synchronizes game state across all nodes using blockchain technology.
- Consensus Mechanisms: Implements consensus algorithms (e.g., Proof of Stake, Practical Byzantine Fault Tolerance) to ensure fairness and consistency.
- Immutable Records: Maintains a tamper-proof ledger of game events, transactions, and player interactions.
- Asset Management: Supports the creation and integration of NFTs and other blockchain-based assets within games.
- Smart Contract Interaction: Provides interfaces for seamless interaction with smart contracts on various blockchain networks.
- Developer Tools and SDKs: Offers a suite of tools and libraries in C++ to streamline the development process and reduce complexity.
- Seamless Wallet Connections: Enables players to connect their crypto wallets through their web browsers, similar to popular Web3 applications and games.
- Enhanced User Experience: Simplifies the process of linking wallets without requiring in-game software modifications.
- Security and Privacy: Ensures secure handling of wallet data and transactions through encrypted communication channels.
- Cross-Platform Compatibility: Supports major wallet providers and browsers, ensuring broad accessibility for players.
Rox-Engine's architecture is modular and extensible, consisting of the following core components:
- Networking Module: Handles P2P connections, data transmission, and network topology management.
- Blockchain Module: Manages blockchain interactions, including transactions, smart contracts, and asset management.
- Security Module: Implements cryptographic functions, ZKPs, and anonymity features.
- Game Engine Core: Provides essential game development functionalities like rendering, physics, input handling, and scene management.
- Wallet Integration Module: Facilitates secure connections between the game engine and players crypto wallets via web browsers.
- SDK and APIs: Offers a set of tools and interfaces for developers to build and customize their games efficiently.
Visual representation coming soon.
-
Operating System:
- Windows 10 or higher
- macOS Catalina or higher
- Linux (Ubuntu 18.04+)
-
Compiler:
- A modern C++ compiler (e.g., GCC 9+, Clang 9+, MSVC 2015+)
-
Build System:
- CMake 3.16 or higher
-
Dependencies:
- OpenGL: For rendering graphics. Installation Guide
- GLFW: A library for OpenGL, window, and input management. Installation Guide
- Boost Libraries: Installation Guide
- OpenSSL: For cryptographic functions. Installation Guide
- Torox-Math Library: For advanced mathematical functions.
- Orox-Token Library: For token and blockchain interactions.
Note: Torox-Math, Torox-Token, SDL3 and Assimp are under consideration for future integration and are not required at this stage.
-
Clone the Repository
git clone https://github.com/Torox-Lab/rox-engine.git cd rox-engine -
Initialize Submodules
If using Git submodules for dependencies:
git submodule update --init --recursive
-
Install Dependencies
Ensure all external libraries are installed and properly linked. Refer to the Prerequisites section for installation guides.
-
Build the Engine
mkdir build && cd build cmake .. make
After building the engine, you can start creating your game project:
-
Create a New Project
Use the provided project generator script:
./tools/create_project.sh MyGameProject
-
Include Rox-Engine Headers
In your C++ source files:
#include <rox/app.hpp>
Note: Currently, to use the engine, you need to include
rox/app.hpp. We plan to update this torox/rox.hppin future releases for consistency. -
Initialize the Engine
int main() { Rox::Engine engine; engine.initialize(); // Your game logic here engine.run(); return 0; }
-
Build and Run Your Game
Use your preferred build system to compile and run your game project.
Comprehensive documentation is being developed and will include:
- API Reference: Detailed descriptions of all classes, functions, and modules.
- Tutorials: Step-by-step guides for common tasks and features.
- Sample Projects: Example game projects demonstrating various engine capabilities.
- Integration Guides: Instructions on integrating with different blockchain networks, anonymity services, and wallet providers.
Documentation will be available in the /docs directory and online at docs.torox.org (coming soon).
Our roadmap outlines the planned development stages of Rox-Engine:
- Set up project repository and development environment.
- Establish the foundational codebase for Rox-Engine.
- Develop core engine functionalities (rendering, physics, input handling) using OpenGL, DirectX, and Metal.
- Implement basic P2P networking capabilities.
- Establish initial blockchain interaction layer.
- Release Alpha version for internal testing.
- Enhance P2P networking with NAT traversal and connection stability improvements.
- Integrate Torox-Math for advanced mathematical computations.
- Implement anonymity network support (Tor/I2P integration).
- Develop experimental ZKP functionalities for secure verification.
- Introduce smart contract interaction capabilities.
- Implement Wallet Integration via Browser for seamless crypto wallet connections.
- Evaluate and possibly integrate SDL3 and Assimp for additional functionality.
- Release Beta version for community testing.
- Optimize engine performance for various platforms.
- Conduct security audits and vulnerability assessments.
- Refine ZKP implementations and test extensively.
- Enhance consensus algorithms for distributed ledger synchronization.
- Expand documentation and create developer tutorials.
- Implement comprehensive Wallet Integration features and support for major wallet providers.
- Release Version 1.0 for public use.
- Establish a community forum and support channels.
- Host developer workshops and webinars.
- Encourage community contributions and third-party integrations.
- Explore partnerships with blockchain platforms and gaming studios.
- Continuously update and improve the engine based on feedback.
- Develop a marketplace for Web3 assets and plugins.
- Incomplete Task
- In progress
- Completed Task
We are excited to collaborate with developers and enthusiasts who share our vision. To contribute:
-
Fork the Repository
Click the "Fork" button at the top right of this page.
-
Create a Feature Branch
git checkout -b feature/YourFeature
-
Commit Your Changes
git commit -m "Add YourFeature" -
Push to Your Fork
git push origin feature/YourFeature
-
Submit a Pull Request
Open a pull request detailing your changes and contributions.
Please refer to our Contributing Guidelines for more information.
Rox-Engine is licensed under the MIT License, allowing you flexibility in how you use the engine in your projects.
For inquiries, support, or feedback:
- Email: [email protected]
- Website: torox.org
- GitHub Issues: Submit an issue
Rox-Engine is currently in active development and certain features are in the conceptual or experimental stages. We are committed to transparency and will keep the community updated on our progress through regular commits and roadmap adjustments.
We invite you to join us on this exciting journey to pioneer the future of decentralized, community-driven gaming.
By focusing on creating a robust and decentralized game engine, we believe that Rox-Engine embodies the spirit of community-driven development where games are truly built by developers, run by players, and owned by communities.
We would like to thank all contributors, supporters, and the open-source community for their invaluable input and collaboration.
Note: This README is intended to provide an overview of Rox-Engine's vision and direction. We encourage developers and enthusiasts to contribute, provide feedback, and help shape the future of decentralized gaming.
Last updated on, December 01, 2024