Procedural Generation Project 2

This repository contains basic generation logic for a 2D, pixel art, tile set-based world. It was written in Rust, using Bevy engine (v0.18). The purpose of this project was to familiarise myself a little more with Rust and procedural generation. It's a follow-up on my first attempt to learn Rust, Rusteroids, and my first, non-Rust procedural generation project, Procedural Generation Project 1. You will neither find advanced concepts of Rust being applied (correctly) here nor advanced procedural generation techniques.

Demo

Features

• Generates an infinite and animated, 2D pixel art world that is fully deterministic
• Executes generation processes asynchronously (excluding entity spawning, of course)
• Terrain generation:

- Uses multi-fractal Perlin noise to generate terrain layers - Features 3 biomes (dry, moderate, humid), each with 5 terrain types (water, shore, and three land layers e.g. sand/grass/forest) - Each terrain type supports 16 different tile types, many with transparency allowing for smooth transitions and layering - Uses a chunk-based approach (as can be seen in the GIFs) - Employs contextual layers (Metadata) to make chunks context aware, allowing for gradual elevation changes over great distances and inter-chunk biome changes without reducing generation performance

• Object generation:

- Uses a basic A\* pathfinding algorithm implementation to generate paths crossing multiple chunks - Generates 3 modular building types - each allowing for different door locations, and window/roofs styles - in settled areas along paths - Uses the wave function collapse algorithm to generate additional decorative objects such as trees, ruins, stones, etc. - Supports multi-tile objects and connected objects, the rules for which are expressed in .toml files - for example, ruins can span multiple tiles and span over multiple terrain types

• Features 32x32px sprites (or sprites that fit within a 32x32px grid) that were created by me
• bevy-inspector-egui plugin to play around with the generation parameters at runtime
• iyesperfui plugin for performance metrics in an overlay

Attribution

• Art work is somewhat inspired by sanctumpixel's style
• All sprites were created by myself and are available under CC BY 4.0

How to use

[!NOTE]

When you start the application, the default settings will result in no land or objects being spawned at the

origin cg(0, 0), so you'll have to move the camera in any direction to see something.

• A/D/W/S to move the camera
• Hold Shift to move camera faster
• PageUp/PageDown or use mouse wheel to zoom in/out
• T/F6 to reset the camera's zoom level (and rotation) but not its position
• R/F5 to regenerate the world with the current settings
• Right Click a tile to show and log its debug info
• F1 to toggle world inspector UI
• F2 to toggle settings
• F11 to toggle fullscreen/windowed mode
• Z to toggle performance metrics overlay
• X to toggle debug gizmos
• C to toggle tile debug info being displayed

How to develop

Looking at the codebase for the first time or haven't looked at it in a while?

• Start with the GenerationStage enum in conjunction with the worldgenerationsystem in GenerationPlugin which is

driving the generation process

• The terrain/world generation which generates chunks and tiles sits in crate::generation::world
• The object generation which generates paths and decorative objects placed on the terrain lives in

crate::generation::object

• Resources used for both of the above can be found in crate::generation::resources
• Structs and enums used across multiple modules sit in crate::generation::lib

Using Nix Flakes, JetBrains RustRover & Direnv

You can run this project in any way you like, but I have set things up to make it easy to develop using JetBrains RustRover. For this, you'll need:

• direnv
• Any Direnv integration plugin e.g. https://plugins.jetbrains.com/plugin/15285-direnv-integration
• nix

This way, you'll just need to direnv allow in the project directory after which all prerequisites (incl. Rust, Cargo, all Bevy dependencies, etc.) will be available to you. The JetBrains plugin will ensure that the environment is available to your IDE and you can run the project from there (vs cargo build and cargo run in the terminal).

How to deal with RustRover making problems again

RustRover forgetting where the Rust standard library is?

find /nix/store -type d -name rustlibsrc

Using Nix Flakes

Without direnv, you can use the Nix Flake by running nix develop in the project directory. If you want to use an IDE such as JetBrains RustRover, you'll have to set up the environment manually. You'll most likely have to make LDLIBRARYPATH available to your IDE.

Upgrade the flake by running nix flake update in the repository's base directory.

Reminders

How to add decorative object sprite assets

• Add the sprite to the relevant sprite sheet in assets/objects/
• Add a new option to the ObjectName enum
• Optional: Add the object name to the any.terrain.ruleset.toml file (top, right, bottom, left) if it can be placed

next to a tile that contains no object (i.e. ObjectName::Empty)

• Add the object name to the all.tile-type.ruleset.toml file (like just Fill) to the relevant TileTypes on which

the object can be placed

• Add a new state to the relevant {terrain}.terrain.ruleset.toml file using the index from the sprite sheet

- Make sure provide of permitted neighbours (even if just Empty on all sides) - Make sure the permitted neighbours themselves list the new object name as a neighbour, too - The application will run some validations and prevent startup with clear error messages if the configured state is unresolvable

• Optional: Add the object name to any terrain-climate combination in all.exclusions.ruleset.toml if it shouldn't

be placed in those terrains and/or climates

• Optional: If this is a large asset, make sure to add it to ObjectName.ismultitile()
• Optional: If this is an animated asset, add it to ObjectName.is_animated()

How to add building or path sprite assets

• Add the sprite to the relevant sprite sheet in assets/objects/
• Update the column and row values in constants.rs for buildings/paths, if necessary
• Add the new option(s) to the ObjectName enum
• Add the object name(s) to the isbuilding() or ispath() function in object_name.rs
• Add the object name(s) to the getindexforbuilding() or getindexforpath() function in object_name.rs
• Add the object name(s) to the any.terrain.ruleset.toml file where appropriate (top, right, bottom, left)
• If building sprite: Add the object name(s) to relevant BuildingType in the BuildingComponentRegistry

You can but don't need to update any other ruleset files as buildings and paths are placed prior to decorative objects and therefore don't need to be considered in the wave function collapse algorithm which uses these rulesets. However, the addition to the "any ruleset" file results in the neighbouring tile of the new sprite to be empty (ObjectName::Empty). Without this, you'll see errors in the wave function collapse algorithm.

How to use cargo-flamegraph

• Run the command below to generate a flame graph

- Linux:

CARGOPROFILERELEASE_DEBUG=true RUSTFLAGS='-C force-frame-pointers=y' cargo flamegraph -c "record -g" --package=procedural-generation-2 --bin=procedural-generation-2

- Windows:

$env:CARGOPROFILERELEASE_DEBUG = "true"; $env:RUSTFLAGS = "-C force-frame-pointers=y"; cargo flamegraph -c "record -g" --package=procedural-generation-2 --bin=procedural-generation-2

• This should run the application - once you close it, a flamegraph.svg will be generated at the root of the

repository

• Open it in your browser to see the flame graph

Run configurations

The .run folder contains a few run configurations for RustRover. Alternatively, you may want to consider creating:

• A run configuration with environment variable RUSTLOG=proceduralgeneration_2=debug for debug logs
• A run configuration that also appends

,proceduralgeneration2::generation::object=trace,proceduralgeneration2::generation::path=trace to RUST_LOG for WFC and pathfinding trace logs

• A run configuration with environment variable RUSTLOG=bevyecs=debug to see Bevy ECS logs (e.g. which system

caused an error[B0003]`)