age-rs / age-rs

age-rs - Cross-platform RTS game engine core based on Age of Empires mechanics

age-rs

Cross-platform RTS game engine based on Age of Empires mechanics

For now we focus to port nyan and libopenage (part of openage) to rust-lang and create a stable toolchain around it. Both are part of the engine core of openage which is written mainly in C++17 and Python 3. While we are trying to stick to fundamental design decisions (regarding e.g. architecture, multiplayer) that the openage authors did - we are going to use Rust to build a reliable cross-platform toolchain that empowers everyone to develop on age-rs easily and efficiently.

Goals

• reimplement nyan

• reimplement libopenage

• create a stable rust/python-interface

• create extensive documentation around the project

• Ultimate goals:

  • lower the bar on developing
  • create secure, reliable software that is easy to maintain long-term

Current State of the Project

This project has just begun, if you are eager to help feel free to contribute or open an issue to get in touch. You can also send me a message on Discord: simonsanone#4039

Cloning this repository

As we are dealing with git submodules here, you should use the following command to clone, initialize and update:

git clone --recurse-submodules https://github.com/age-rs/age-rs.git

If you need more information you find them here in the Git submodules documentation

How to contribute?

If you want to contribute to this project feel free to do so. The easiest way would be that you fork this repository, create a branch for the things you want to do and make a PR to this main repository.

We've collected some essential knowledge about contributions in contributing, please read it.

Dependencies, Building and Running

• You will need everything that is stated in the openage build documentation

  • so you will need to be able to build openage it self for the beginning
  • if you have any questions, feel free to ask either the openage-authors or send me a message on Discord (simonsanone#4039)
  • you can also ask in the forum of openage for help (I'm active there as well)

• Make sure you initialize and use the submodules of nyan and openage from this repository here as we will probably need to patch some things in/out for compatibility reasons

License

GNU GPLv3 or later; see COPYING.md and LICENSE.

I know that probably nobody is ever gonna look at the COPYING file, but if you want to contribute code to openage, please take the time to skim through it and add yourself to the authors list.

age-rs's Issues

[NEW FEATURE] General purpose RTS engine

I’m working together with some people on a RTS engine, starting from first-principles with ascii graphics. Here’s an earlier prototype (newest going public soon):

https://github.com/Maxgy/text-rts

If you’re interested in learning more just reply here and I can expand on what we’re doing. A little bit about me: https://community.amethyst.rs/t/welcome-say-hello/99/4?u=erlend_sh

[NEW FEATURE] Serialization support for permanent storage

Description

If the application terminates because of any reason, the state is gone. It can be recreated if the application stores the order and timestamps of successful transactions permanently on disk, those can then be restored by recreation of the initial state and replaying the transactions. Currently, there is no serialization support for permanent storage. This is offloaded to the application, but can be added to the implementation if needed.

p.63, Database properties

What problem does this solve? What need does it fill?

It would give the possible to restore a "gamestate" without replaying all of the transactions.

Describe the solution you'd like

Use serialisation (e.g. serde) and create a permanent storage system.

Generate FFI interfaces for Rust from libnyan

Use bindgen to create bindings to libnyan

Example with bindgen and Microsoft Flight Simulator:
https://www.youtube.com/watch?v=jNNz4h3iIlw

Command-line interface

For the nyancat executable we will need a straight-forward CLI. There are two really useful crates to get it right in nearly no time. For creation I would recommend Clap and for testing of the CLI assert_cmd

Create CLI:
https://github.com/clap-rs/clap

Testing CLI:
https://github.com/assert-rs/assert_cmd

Implementation discussion nyan-rs library

This is the component overview of nyan from the master thesis of Jonas Jelten.

An example nyan file you can find here example.nyan

I would propose that we use logos/logos-derive to create our lexer.

Tokens are found in the masters thesis as well on p.40:

For the parsing into some rust structs we can use pest.rs and create a pest-file with parsing expression grammars (or PEG) for nyan as an input.

For the nyan type and value databases we could maybe use a component-graph-system like froggy, create a Rust API and build cdylibs.

Something like Legion and PumpkinDB sound promising as well, but are either pure ECS or lack other features we might want to have. For example PumpkinDB has ACID transactions, but has the last activity 3 years ago.

Generate FFI interfaces for Rust from libopenage

Use bindgen to create bindings to libopenage

Example with bindgen and Microsoft Flight Simulator:
https://www.youtube.com/watch?v=jNNz4h3iIlw