Skip to content

Latest commit

 

History

History
124 lines (86 loc) · 4.23 KB

README.md

File metadata and controls

124 lines (86 loc) · 4.23 KB
Raw

Vienna

Experimental game engine for visual novels.

Goal

This is a work in progress game engine that focuses on making it simple but flexible to write visual novels.

The goal is to allow writing a visual novel without having to write any code, while also allowing more complex interactive novels by building game logic in your programming language of choice.

Visual Novel

The term "visual novel" is somewhat broad and vague.

In Vienna's case, it represents the following characteristics:

  1. The game provides a visual story.
  2. The gameplay ranges from minimal to full interactivity.
  3. You play a (non-linear) sequence of scenes.
  4. The world operates in 2D space.
  5. It does not require high-performance computing.

There are more genres that fit this description, and all are a focus point of the engine:

The biggest inspiration for this engine is an all-time classic game: Indiana Jones and the Fate of Atlantis.

There are others, such as Myst, Broken Age, The Walking Dead, The Longest Journey, Life is Strange, Broken Sword, Dreamfall, The Curse of Monkey Island, Blade Runner, Syberia and Starship Titanic.

Not all of these can be represented by this engine, but the goal is to cover as much as possible, by offering a flexible system of plugins and widgets.

Concept

  • Engine written in Rust
  • First class support for WebAssembly based plugins and widgets
  • Games built using a storybook and plugins

Development

During development, you can run the test setup as follows:

  1. Install Rust.
  2. Clone project.
  3. Build test plugin.
  4. Run test game.

on macOS, this will get you started:

curl --proto "=https" --tlsv1.2 -sSf "https://sh.rustup.rs" | sh
git clone "https://github.com/rustic-games/vienna"
cargo build --target "wasm32-unknown-unknown" --manifest-path "plugins/test/Cargo.toml"
cargo run

Crates

The project consists of separate crates, each with their own set of responsibilities.

Engine

The responsibility of the vienna-engine crate is to advance the game state based on (player) input and render the results to the screen.

Runner

The vienna-runner crate will become the binary to run the engine with a set of external configuration files and assets. This allows you to distribute a visual novel without having to compile the game itself.

Until then, the purpose of this crate is to allow running cargo run from the project root to test the engine.

SDK

The vienna crate provides a Software Development Kit interface to build Wasm plugins in Rust.

While technically not required, the crate vastly simplifies the process of creating a new plugin, and handles all unsafe FFI operations needed to communicate with the engine at runtime.

The crate has the naked vienna name, since it is the one most often used by external developers.

Plugins

A set of default engine plugins live in the plugins directory.

The engine embeds these plugins by default to provide the core functionality for any game. Custom plugins can further extend the capability of a game.

Currently, a single test plugin exists to validate the functionality of the engine.