World and Noise Generation in Rust.

A library for simple generation of noisemaps and maps of objects in Rust.

The full documentation can be found here.

Usage

To use this library, simply add the following line to your Cargo.toml dependencies section:

worldgen = "0.1.1"

Then import the crate in your code:

extern crate worldgen;

Introduction

To start generating a world, we need a source of noise. The noise module contains different noise generators, for example for perlin noise:

let noise = PerlinNoise::new();

We can generate a single value from a generator using its generate method, as follows:

// x, y, seed
let value = noise.generate(1.0, 1.0, 15);

This on its own is not very useful or convenient, however by plugging this into a NoiseMap (from the noisemap module) we can generate a field of continuous noise:

let nm = NoiseMap::new(noise)
    .set(Size::of(10, 10))
    .set(Step::of(0.05, 0.05));
                                                                              
let vec = nm.generate();

These can be combined and scaled to your liking:

let nm = nm1 + nm2 * 5;

Finally, we can wrap this into a World, and produce a vector of specific tiles (represented by anything you want) based on given constraints:

let world = World::new(nm)
    .add(Tile::new('~').when(Constraint::LT(0.0)))
    .add(Tile::new(','));
                                                                              
let tiles = world.generate();

For more information on each of the three components, look at the documentation of each relevent module.

Full Example

use worldgen::noise::perlin::PerlinNoise;
use worldgen::noisemap::{NoiseMapGenerator, NoiseMap, Seed, Step, Size};
use worldgen::world::{World, Tile};
use worldgen::world::tile::Constraint;
                                                                              
let noise = PerlinNoise::new();
                                                                              
let nm1 = NoiseMap::new(noise)
    .set(Seed::of("Hello?"))
    .set(Step::of(0.005, 0.005))
    .set(Size::of(80, 50));
                                                                              
let nm2 = NoiseMap::new(noise)
    .set(Seed::of("Hello!"))
    .set(Step::of(0.05, 0.05));
                                                                              
let nm = nm1 + nm2 * 3;
                                                                              
let world = World::new(nm)
    
    // Water
    .add(Tile::new('~')
         .when(Constraint::LT(-0.1)))
                                                                              
    // Grass
    .add(Tile::new(',')
         .when(Constraint::LT(0.45)))
                                                                              
    // Mountains
    .add(Tile::new('^')
         .when(Constraint::GT(0.8)))
                                                                              
    // Hills
    .add(Tile::new('n'));
                                                                              
for row in world.generate().iter() {
    for val in row.iter() {
        print!("{}", val);
    }
                                                                              
    println!("");
}