worldgen 0.5.3

Noisemap and world generation library
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
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96

//////////////////////////////////////////////////////////////////////////////
//  File: rust-worldgen/world/mod.rs
//////////////////////////////////////////////////////////////////////////////
//  Copyright 2015 Samuel Sleight
//
//  Licensed under the Apache License, Version 2.0 (the "License");
//  you may not use this file except in compliance with the License.
//  You may obtain a copy of the License at
//
//      http://www.apache.org/licenses/LICENSE-2.0
//
//  Unless required by applicable law or agreed to in writing, software
//  distributed under the License is distributed on an "AS IS" BASIS,
//  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
//  See the License for the specific language governing permissions and
//  limitations under the License.
//////////////////////////////////////////////////////////////////////////////

//! For generating maps of specfic objects based on thresholds.
//!
//! Once we have a `NoiseMap` we can use a `World` and generate a map
//! of specific tiles using threshold constraints.

use std::collections::HashMap;

use self::property::Property;
pub use self::property::Size;
pub use self::tile::Tile;

#[macro_use]
pub mod tile;

mod property;

/// The World class.
///
/// `NM` is the `NoiseMap` class, `T` is the type for each tile. See the
/// module documentation for for information.
pub struct World<T> {
    tiles: Vec<Tile<T>>,

    size: Size
}

impl<T> Default for World<T> {
    fn default() -> World<T> {
        World {
            tiles: Vec::new(),

            size: Default::default()
        }
    }
}

impl<T: Clone> World<T> {
    /// Constructs a new world using a given noisemap
    pub fn new() -> World<T> {
        World {
            tiles: Vec::new(),

            ..Default::default()
        }
    }

    /// Add a tile definition to the world
    pub fn add(self, tile: Tile<T>) -> World<T> {
        let mut new = self;
        new.tiles.push(tile);
        new
    }

    /// Set a property on the world
    pub fn set<P: Property>(self, property: P) -> World<T> {
        property.set_to(self)
    }

    pub fn set_size(self, size: Size) -> World<T> {
        let mut new = self;
        new.size = size;
        new
    }

    pub fn generate(&self, chunk_x: i64, chunk_y: i64) -> Option<Vec<Vec<T>>> {
        let mut nms = HashMap::new();

        (chunk_y * self.size.h .. (chunk_y + 1) * self.size.h).map(|y|
            (chunk_x * self.size.w .. (chunk_x + 1) * self.size.w).map(|x| {
                match self.tiles.iter().find(|tile| tile.satisfied_by(x, y, self.size, chunk_x, chunk_y, &mut nms)) {
                    Some(tile) => Some(tile.value()),
                    None => None
                }
            }
            ).collect()

        ).collect()
    }
}