morkovmap_rc 0.4.1

A data-driven, Markov Chain-based tilemap generator library and app. Single-thread-flavored.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71

use crate::adjacency::{OctileAdjacencyGenerator, CardinalAdjacencyGenerator};
use crate::position2d::Position2D;
use crate::ruleset::GeneratorRuleset;
use crate::sampler::DistributionKey;

pub mod sampler;
pub mod map2d;
pub mod visualizers;
pub mod assigner;
pub mod mapgen_presets;
pub mod ruleset;
pub mod map;
pub mod position;
pub mod position2d;
pub mod map2dnode;
pub mod adjacency;

const COLORMAP_FILENAME: &str = "coloring_rules.json";
const RULESET_FILENAME: &str = "layout_rules.json";
const COMBINED_RULESET_FILENAME: &str = "rules.json";


#[allow(dead_code)]
fn generate(colormap_path: Option<&str>, rule_path: Option<&str>, map_size: Option<u32>) {
    let rules: GeneratorRuleset<i8> = GeneratorRuleset::from((
        colormap_path.unwrap_or(COLORMAP_FILENAME),
        rule_path.unwrap_or(RULESET_FILENAME),
        map_size
    ));
    rules.save(COMBINED_RULESET_FILENAME);
    match rules.map_size {
        0..=254 => rules.generate::<OctileAdjacencyGenerator<Position2D<u8>>, Position2D<u8>>(),
        255..=65534 => rules.generate::<OctileAdjacencyGenerator<Position2D<u16>>, Position2D<u16>>(),
        _ => rules.generate::<OctileAdjacencyGenerator<Position2D<u32>>, Position2D<u32>>()
    };
}


#[allow(dead_code)]
fn generate_from_ruleset<T: DistributionKey>(ruleset: &GeneratorRuleset<T>) {
    let normalized_adjacency = ruleset.adjacency.as_ref().map(
        |s| s.as_str().trim().to_lowercase()

    ).unwrap_or_default();

    match normalized_adjacency.as_str() {
        "cardinal" => match ruleset.map_size {
            0..=254 => ruleset.generate::<CardinalAdjacencyGenerator<Position2D<u8>>, Position2D<u8>>(),
            255..=65534 => ruleset.generate::<CardinalAdjacencyGenerator<Position2D<u16>>, Position2D<u16>>(),
            _ => ruleset.generate::<CardinalAdjacencyGenerator<Position2D<u32>>, Position2D<u32>>()
        },
        "octile" | _ => match ruleset.map_size {
            0..=254 => ruleset.generate::<OctileAdjacencyGenerator<Position2D<u8>>, Position2D<u8>>(),
            255..=65534 => ruleset.generate::<OctileAdjacencyGenerator<Position2D<u16>>, Position2D<u16>>(),
            _ => ruleset.generate::<OctileAdjacencyGenerator<Position2D<u32>>, Position2D<u32>>()
        },
    }
}


pub fn generate_from_file(ruleset_file: Option<&str>) {
    let rules = GeneratorRuleset::load(
        ruleset_file.unwrap_or(COMBINED_RULESET_FILENAME)
    );
    match rules {
        Ok(ruleset) => generate_from_ruleset(&ruleset),
        Err(e) => {
            eprintln!("{}", e);
            generate(None, None, None)
        }
    };
}