rust/mapgen/src/lib.rs
author unC0Rr
Wed, 18 Sep 2024 13:42:26 +0200
branchtransitional_engine
changeset 16035 0caa3dfb3ba2
parent 16033 1860852892c0
permissions -rw-r--r--
Add templates for different maze styles
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
15922
da6b67f13c12 Refactor mapgen to allow for easy switching between generators
unC0Rr
parents: 15921
diff changeset
     1
mod template;
14151
3c8a33ba06ba start loading theme textures
alfadur
parents: 14137
diff changeset
     2
pub mod theme;
3c8a33ba06ba start loading theme textures
alfadur
parents: 14137
diff changeset
     3
14710
946df0bb3b28 collapse mapgen back
alfadur
parents: 14702
diff changeset
     4
use self::theme::Theme;
15922
da6b67f13c12 Refactor mapgen to allow for easy switching between generators
unC0Rr
parents: 15921
diff changeset
     5
use crate::template::outline::TemplateCollectionDesc as OutlineTemplateCollectionDesc;
da6b67f13c12 Refactor mapgen to allow for easy switching between generators
unC0Rr
parents: 15921
diff changeset
     6
use crate::template::wavefront_collapse::TemplateCollectionDesc as WfcTemplateCollectionDesc;
16033
1860852892c0 Use rust implementation of maze generator in engine
unC0Rr
parents: 16032
diff changeset
     7
use crate::template::maze::TemplateCollectionDesc as MazeTemplateCollectionDesc;
1860852892c0 Use rust implementation of maze generator in engine
unC0Rr
parents: 16032
diff changeset
     8
16024
3402b2185698 Pass full path to WFC for tile loading
unC0Rr
parents: 15925
diff changeset
     9
use std::path::{Path, PathBuf};
15923
d46ad15c6dec Get wavefront collapse generator to work in engine
unC0Rr
parents: 15922
diff changeset
    10
14710
946df0bb3b28 collapse mapgen back
alfadur
parents: 14702
diff changeset
    11
use land2d::Land2D;
15922
da6b67f13c12 Refactor mapgen to allow for easy switching between generators
unC0Rr
parents: 15921
diff changeset
    12
use landgen::{
da6b67f13c12 Refactor mapgen to allow for easy switching between generators
unC0Rr
parents: 15921
diff changeset
    13
    outline_template_based::{
da6b67f13c12 Refactor mapgen to allow for easy switching between generators
unC0Rr
parents: 15921
diff changeset
    14
        outline_template::OutlineTemplate, template_based::TemplatedLandGenerator,
da6b67f13c12 Refactor mapgen to allow for easy switching between generators
unC0Rr
parents: 15921
diff changeset
    15
    },
da6b67f13c12 Refactor mapgen to allow for easy switching between generators
unC0Rr
parents: 15921
diff changeset
    16
    wavefront_collapse::generator::{
da6b67f13c12 Refactor mapgen to allow for easy switching between generators
unC0Rr
parents: 15921
diff changeset
    17
        TemplateDescription as WfcTemplate, WavefrontCollapseLandGenerator,
da6b67f13c12 Refactor mapgen to allow for easy switching between generators
unC0Rr
parents: 15921
diff changeset
    18
    },
16032
31cc1e450273 Add maze land generator ported from pascal engine
unC0Rr
parents: 16031
diff changeset
    19
    maze::{MazeTemplate, MazeLandGenerator},
15922
da6b67f13c12 Refactor mapgen to allow for easy switching between generators
unC0Rr
parents: 15921
diff changeset
    20
    LandGenerationParameters, LandGenerator,
da6b67f13c12 Refactor mapgen to allow for easy switching between generators
unC0Rr
parents: 15921
diff changeset
    21
};
da6b67f13c12 Refactor mapgen to allow for easy switching between generators
unC0Rr
parents: 15921
diff changeset
    22
use rand::{seq::SliceRandom, Rng};
15923
d46ad15c6dec Get wavefront collapse generator to work in engine
unC0Rr
parents: 15922
diff changeset
    23
d46ad15c6dec Get wavefront collapse generator to work in engine
unC0Rr
parents: 15922
diff changeset
    24
use std::{borrow::Borrow, collections::hash_map::HashMap};
14160
c24a76f131d6 implement basic land texturing
alfadur
parents: 14156
diff changeset
    25
use vec2d::Vec2D;
14127
0c5b9cfda9ab add a higher level map generation lib to load yaml templates into somewhere
alfadur
parents:
diff changeset
    26
0c5b9cfda9ab add a higher level map generation lib to load yaml templates into somewhere
alfadur
parents:
diff changeset
    27
#[derive(PartialEq, Eq, Hash, Clone, Debug)]
0c5b9cfda9ab add a higher level map generation lib to load yaml templates into somewhere
alfadur
parents:
diff changeset
    28
struct TemplateType(String);
0c5b9cfda9ab add a higher level map generation lib to load yaml templates into somewhere
alfadur
parents:
diff changeset
    29
0c5b9cfda9ab add a higher level map generation lib to load yaml templates into somewhere
alfadur
parents:
diff changeset
    30
impl Borrow<str> for TemplateType {
0c5b9cfda9ab add a higher level map generation lib to load yaml templates into somewhere
alfadur
parents:
diff changeset
    31
    fn borrow(&self) -> &str {
0c5b9cfda9ab add a higher level map generation lib to load yaml templates into somewhere
alfadur
parents:
diff changeset
    32
        self.0.as_str()
0c5b9cfda9ab add a higher level map generation lib to load yaml templates into somewhere
alfadur
parents:
diff changeset
    33
    }
0c5b9cfda9ab add a higher level map generation lib to load yaml templates into somewhere
alfadur
parents:
diff changeset
    34
}
0c5b9cfda9ab add a higher level map generation lib to load yaml templates into somewhere
alfadur
parents:
diff changeset
    35
0c5b9cfda9ab add a higher level map generation lib to load yaml templates into somewhere
alfadur
parents:
diff changeset
    36
#[derive(Debug)]
15922
da6b67f13c12 Refactor mapgen to allow for easy switching between generators
unC0Rr
parents: 15921
diff changeset
    37
pub struct MapGenerator<T> {
da6b67f13c12 Refactor mapgen to allow for easy switching between generators
unC0Rr
parents: 15921
diff changeset
    38
    pub(crate) templates: HashMap<TemplateType, Vec<T>>,
16024
3402b2185698 Pass full path to WFC for tile loading
unC0Rr
parents: 15925
diff changeset
    39
    data_path: PathBuf,
14127
0c5b9cfda9ab add a higher level map generation lib to load yaml templates into somewhere
alfadur
parents:
diff changeset
    40
}
0c5b9cfda9ab add a higher level map generation lib to load yaml templates into somewhere
alfadur
parents:
diff changeset
    41
15922
da6b67f13c12 Refactor mapgen to allow for easy switching between generators
unC0Rr
parents: 15921
diff changeset
    42
impl<T> MapGenerator<T> {
16024
3402b2185698 Pass full path to WFC for tile loading
unC0Rr
parents: 15925
diff changeset
    43
    pub fn new(data_path: &Path) -> Self {
14710
946df0bb3b28 collapse mapgen back
alfadur
parents: 14702
diff changeset
    44
        Self {
946df0bb3b28 collapse mapgen back
alfadur
parents: 14702
diff changeset
    45
            templates: HashMap::new(),
16024
3402b2185698 Pass full path to WFC for tile loading
unC0Rr
parents: 15925
diff changeset
    46
            data_path: data_path.to_owned(),
14710
946df0bb3b28 collapse mapgen back
alfadur
parents: 14702
diff changeset
    47
        }
14127
0c5b9cfda9ab add a higher level map generation lib to load yaml templates into somewhere
alfadur
parents:
diff changeset
    48
    }
0c5b9cfda9ab add a higher level map generation lib to load yaml templates into somewhere
alfadur
parents:
diff changeset
    49
15922
da6b67f13c12 Refactor mapgen to allow for easy switching between generators
unC0Rr
parents: 15921
diff changeset
    50
    pub fn get_template<R: Rng>(&self, template_type: &str, rng: &mut R) -> Option<&T> {
14710
946df0bb3b28 collapse mapgen back
alfadur
parents: 14702
diff changeset
    51
        self.templates
946df0bb3b28 collapse mapgen back
alfadur
parents: 14702
diff changeset
    52
            .get(template_type)
15903
230dc46487ea Update mapgen to take into account actual values for 'zero' and 'basic' colors
unC0Rr
parents: 15828
diff changeset
    53
            .and_then(|t| t.as_slice().choose(rng))
14127
0c5b9cfda9ab add a higher level map generation lib to load yaml templates into somewhere
alfadur
parents:
diff changeset
    54
    }
14151
3c8a33ba06ba start loading theme textures
alfadur
parents: 14137
diff changeset
    55
15903
230dc46487ea Update mapgen to take into account actual values for 'zero' and 'basic' colors
unC0Rr
parents: 15828
diff changeset
    56
    pub fn make_texture<LandT>(
230dc46487ea Update mapgen to take into account actual values for 'zero' and 'basic' colors
unC0Rr
parents: 15828
diff changeset
    57
        &self,
230dc46487ea Update mapgen to take into account actual values for 'zero' and 'basic' colors
unC0Rr
parents: 15828
diff changeset
    58
        land: &Land2D<LandT>,
230dc46487ea Update mapgen to take into account actual values for 'zero' and 'basic' colors
unC0Rr
parents: 15828
diff changeset
    59
        parameters: &LandGenerationParameters<LandT>,
230dc46487ea Update mapgen to take into account actual values for 'zero' and 'basic' colors
unC0Rr
parents: 15828
diff changeset
    60
        theme: &Theme,
230dc46487ea Update mapgen to take into account actual values for 'zero' and 'basic' colors
unC0Rr
parents: 15828
diff changeset
    61
    ) -> Vec2D<u32>
14710
946df0bb3b28 collapse mapgen back
alfadur
parents: 14702
diff changeset
    62
    where
946df0bb3b28 collapse mapgen back
alfadur
parents: 14702
diff changeset
    63
        LandT: Copy + Default + PartialEq,
946df0bb3b28 collapse mapgen back
alfadur
parents: 14702
diff changeset
    64
    {
15914
c571d4b8879c Fix mapgen
unC0Rr
parents: 15903
diff changeset
    65
        let mut texture = Vec2D::new(&land.size().size(), 0);
14170
a4c1a2d0ac24 implement basic land bordering
alfadur
parents: 14164
diff changeset
    66
14160
c24a76f131d6 implement basic land texturing
alfadur
parents: 14156
diff changeset
    67
        if let Some(land_sprite) = theme.land_texture() {
14710
946df0bb3b28 collapse mapgen back
alfadur
parents: 14702
diff changeset
    68
            for (row_index, (land_row, tex_row)) in land.rows().zip(texture.rows_mut()).enumerate()
14160
c24a76f131d6 implement basic land texturing
alfadur
parents: 14156
diff changeset
    69
            {
c24a76f131d6 implement basic land texturing
alfadur
parents: 14156
diff changeset
    70
                let sprite_row = land_sprite.get_row(row_index % land_sprite.height());
c24a76f131d6 implement basic land texturing
alfadur
parents: 14156
diff changeset
    71
                let mut x_offset = 0;
c24a76f131d6 implement basic land texturing
alfadur
parents: 14156
diff changeset
    72
                while sprite_row.len() < land.width() - x_offset {
c24a76f131d6 implement basic land texturing
alfadur
parents: 14156
diff changeset
    73
                    let copy_range = x_offset..x_offset + sprite_row.len();
c24a76f131d6 implement basic land texturing
alfadur
parents: 14156
diff changeset
    74
                    tex_row_copy(
15903
230dc46487ea Update mapgen to take into account actual values for 'zero' and 'basic' colors
unC0Rr
parents: 15828
diff changeset
    75
                        parameters.basic(),
14160
c24a76f131d6 implement basic land texturing
alfadur
parents: 14156
diff changeset
    76
                        &land_row[copy_range.clone()],
c24a76f131d6 implement basic land texturing
alfadur
parents: 14156
diff changeset
    77
                        &mut tex_row[copy_range],
14710
946df0bb3b28 collapse mapgen back
alfadur
parents: 14702
diff changeset
    78
                        sprite_row,
14160
c24a76f131d6 implement basic land texturing
alfadur
parents: 14156
diff changeset
    79
                    );
c24a76f131d6 implement basic land texturing
alfadur
parents: 14156
diff changeset
    80
c24a76f131d6 implement basic land texturing
alfadur
parents: 14156
diff changeset
    81
                    x_offset += land_sprite.width()
c24a76f131d6 implement basic land texturing
alfadur
parents: 14156
diff changeset
    82
                }
14151
3c8a33ba06ba start loading theme textures
alfadur
parents: 14137
diff changeset
    83
14160
c24a76f131d6 implement basic land texturing
alfadur
parents: 14156
diff changeset
    84
                if x_offset < land.width() {
14164
1749961647b9 fix texturing and add a theme loading option to land_dump
alfadur
parents: 14160
diff changeset
    85
                    let final_range = x_offset..land.width();
14160
c24a76f131d6 implement basic land texturing
alfadur
parents: 14156
diff changeset
    86
                    tex_row_copy(
15903
230dc46487ea Update mapgen to take into account actual values for 'zero' and 'basic' colors
unC0Rr
parents: 15828
diff changeset
    87
                        parameters.basic(),
14160
c24a76f131d6 implement basic land texturing
alfadur
parents: 14156
diff changeset
    88
                        &land_row[final_range.clone()],
c24a76f131d6 implement basic land texturing
alfadur
parents: 14156
diff changeset
    89
                        &mut tex_row[final_range],
14710
946df0bb3b28 collapse mapgen back
alfadur
parents: 14702
diff changeset
    90
                        &sprite_row[..land.width() - x_offset],
14160
c24a76f131d6 implement basic land texturing
alfadur
parents: 14156
diff changeset
    91
                    );
c24a76f131d6 implement basic land texturing
alfadur
parents: 14156
diff changeset
    92
                }
c24a76f131d6 implement basic land texturing
alfadur
parents: 14156
diff changeset
    93
            }
c24a76f131d6 implement basic land texturing
alfadur
parents: 14156
diff changeset
    94
        }
14170
a4c1a2d0ac24 implement basic land bordering
alfadur
parents: 14164
diff changeset
    95
a4c1a2d0ac24 implement basic land bordering
alfadur
parents: 14164
diff changeset
    96
        if let Some(border_sprite) = theme.border_texture() {
a4c1a2d0ac24 implement basic land bordering
alfadur
parents: 14164
diff changeset
    97
            assert!(border_sprite.height() <= 512);
a4c1a2d0ac24 implement basic land bordering
alfadur
parents: 14164
diff changeset
    98
            let border_width = (border_sprite.height() / 2) as u8;
14175
76a52e8149e3 add some texture transforms
alfadur
parents: 14170
diff changeset
    99
            let border_sprite = border_sprite.to_tiled();
14170
a4c1a2d0ac24 implement basic land bordering
alfadur
parents: 14164
diff changeset
   100
a4c1a2d0ac24 implement basic land bordering
alfadur
parents: 14164
diff changeset
   101
            let mut offsets = vec![255u8; land.width()];
a4c1a2d0ac24 implement basic land bordering
alfadur
parents: 14164
diff changeset
   102
a4c1a2d0ac24 implement basic land bordering
alfadur
parents: 14164
diff changeset
   103
            land_border_pass(
15903
230dc46487ea Update mapgen to take into account actual values for 'zero' and 'basic' colors
unC0Rr
parents: 15828
diff changeset
   104
                parameters.basic(),
14170
a4c1a2d0ac24 implement basic land bordering
alfadur
parents: 14164
diff changeset
   105
                land.rows().rev().zip(texture.rows_mut().rev()),
a4c1a2d0ac24 implement basic land bordering
alfadur
parents: 14164
diff changeset
   106
                &mut offsets,
a4c1a2d0ac24 implement basic land bordering
alfadur
parents: 14164
diff changeset
   107
                border_width,
14710
946df0bb3b28 collapse mapgen back
alfadur
parents: 14702
diff changeset
   108
                |x, y| {
946df0bb3b28 collapse mapgen back
alfadur
parents: 14702
diff changeset
   109
                    border_sprite
946df0bb3b28 collapse mapgen back
alfadur
parents: 14702
diff changeset
   110
                        .get_pixel(x % border_sprite.width(), border_sprite.height() - 1 - y)
946df0bb3b28 collapse mapgen back
alfadur
parents: 14702
diff changeset
   111
                },
14170
a4c1a2d0ac24 implement basic land bordering
alfadur
parents: 14164
diff changeset
   112
            );
a4c1a2d0ac24 implement basic land bordering
alfadur
parents: 14164
diff changeset
   113
a4c1a2d0ac24 implement basic land bordering
alfadur
parents: 14164
diff changeset
   114
            offsets.iter_mut().for_each(|v| *v = 255);
a4c1a2d0ac24 implement basic land bordering
alfadur
parents: 14164
diff changeset
   115
a4c1a2d0ac24 implement basic land bordering
alfadur
parents: 14164
diff changeset
   116
            land_border_pass(
15903
230dc46487ea Update mapgen to take into account actual values for 'zero' and 'basic' colors
unC0Rr
parents: 15828
diff changeset
   117
                parameters.basic(),
14170
a4c1a2d0ac24 implement basic land bordering
alfadur
parents: 14164
diff changeset
   118
                land.rows().zip(texture.rows_mut()),
a4c1a2d0ac24 implement basic land bordering
alfadur
parents: 14164
diff changeset
   119
                &mut offsets,
a4c1a2d0ac24 implement basic land bordering
alfadur
parents: 14164
diff changeset
   120
                border_width,
14710
946df0bb3b28 collapse mapgen back
alfadur
parents: 14702
diff changeset
   121
                |x, y| border_sprite.get_pixel(x % border_sprite.width(), y),
14702
29dbe9ce8b7d add basic map rendering with gl
fkaa
parents: 14175
diff changeset
   122
            );
29dbe9ce8b7d add basic map rendering with gl
fkaa
parents: 14175
diff changeset
   123
        }
29dbe9ce8b7d add basic map rendering with gl
fkaa
parents: 14175
diff changeset
   124
29dbe9ce8b7d add basic map rendering with gl
fkaa
parents: 14175
diff changeset
   125
        texture
29dbe9ce8b7d add basic map rendering with gl
fkaa
parents: 14175
diff changeset
   126
    }
14127
0c5b9cfda9ab add a higher level map generation lib to load yaml templates into somewhere
alfadur
parents:
diff changeset
   127
}
0c5b9cfda9ab add a higher level map generation lib to load yaml templates into somewhere
alfadur
parents:
diff changeset
   128
15922
da6b67f13c12 Refactor mapgen to allow for easy switching between generators
unC0Rr
parents: 15921
diff changeset
   129
impl MapGenerator<OutlineTemplate> {
da6b67f13c12 Refactor mapgen to allow for easy switching between generators
unC0Rr
parents: 15921
diff changeset
   130
    pub fn import_yaml_templates(&mut self, text: &str) {
da6b67f13c12 Refactor mapgen to allow for easy switching between generators
unC0Rr
parents: 15921
diff changeset
   131
        let mut desc: OutlineTemplateCollectionDesc = serde_yaml::from_str(text).unwrap();
15923
d46ad15c6dec Get wavefront collapse generator to work in engine
unC0Rr
parents: 15922
diff changeset
   132
        let templates = std::mem::take(&mut desc.templates);
15922
da6b67f13c12 Refactor mapgen to allow for easy switching between generators
unC0Rr
parents: 15921
diff changeset
   133
        self.templates = desc
da6b67f13c12 Refactor mapgen to allow for easy switching between generators
unC0Rr
parents: 15921
diff changeset
   134
            .template_types
da6b67f13c12 Refactor mapgen to allow for easy switching between generators
unC0Rr
parents: 15921
diff changeset
   135
            .into_iter()
da6b67f13c12 Refactor mapgen to allow for easy switching between generators
unC0Rr
parents: 15921
diff changeset
   136
            .map(|(size, indices)| {
da6b67f13c12 Refactor mapgen to allow for easy switching between generators
unC0Rr
parents: 15921
diff changeset
   137
                (
da6b67f13c12 Refactor mapgen to allow for easy switching between generators
unC0Rr
parents: 15921
diff changeset
   138
                    TemplateType(size),
16029
9cbd18220eb7 Fix cavern templates
unC0Rr
parents: 16024
diff changeset
   139
                    indices
9cbd18220eb7 Fix cavern templates
unC0Rr
parents: 16024
diff changeset
   140
                        .indices
9cbd18220eb7 Fix cavern templates
unC0Rr
parents: 16024
diff changeset
   141
                        .iter()
9cbd18220eb7 Fix cavern templates
unC0Rr
parents: 16024
diff changeset
   142
                        .map(|i| Into::<OutlineTemplate>::into(&templates[*i]))
9cbd18220eb7 Fix cavern templates
unC0Rr
parents: 16024
diff changeset
   143
                        .map(|o| {
9cbd18220eb7 Fix cavern templates
unC0Rr
parents: 16024
diff changeset
   144
                            if indices.force_invert == Some(true) {
9cbd18220eb7 Fix cavern templates
unC0Rr
parents: 16024
diff changeset
   145
                                o.cavern()
9cbd18220eb7 Fix cavern templates
unC0Rr
parents: 16024
diff changeset
   146
                            } else {
9cbd18220eb7 Fix cavern templates
unC0Rr
parents: 16024
diff changeset
   147
                                o
9cbd18220eb7 Fix cavern templates
unC0Rr
parents: 16024
diff changeset
   148
                            }
9cbd18220eb7 Fix cavern templates
unC0Rr
parents: 16024
diff changeset
   149
                        })
9cbd18220eb7 Fix cavern templates
unC0Rr
parents: 16024
diff changeset
   150
                        .collect(),
15922
da6b67f13c12 Refactor mapgen to allow for easy switching between generators
unC0Rr
parents: 15921
diff changeset
   151
                )
da6b67f13c12 Refactor mapgen to allow for easy switching between generators
unC0Rr
parents: 15921
diff changeset
   152
            })
da6b67f13c12 Refactor mapgen to allow for easy switching between generators
unC0Rr
parents: 15921
diff changeset
   153
            .collect();
da6b67f13c12 Refactor mapgen to allow for easy switching between generators
unC0Rr
parents: 15921
diff changeset
   154
    }
da6b67f13c12 Refactor mapgen to allow for easy switching between generators
unC0Rr
parents: 15921
diff changeset
   155
da6b67f13c12 Refactor mapgen to allow for easy switching between generators
unC0Rr
parents: 15921
diff changeset
   156
    pub fn build_generator(&self, template: OutlineTemplate) -> impl LandGenerator {
da6b67f13c12 Refactor mapgen to allow for easy switching between generators
unC0Rr
parents: 15921
diff changeset
   157
        TemplatedLandGenerator::new(template)
da6b67f13c12 Refactor mapgen to allow for easy switching between generators
unC0Rr
parents: 15921
diff changeset
   158
    }
da6b67f13c12 Refactor mapgen to allow for easy switching between generators
unC0Rr
parents: 15921
diff changeset
   159
}
da6b67f13c12 Refactor mapgen to allow for easy switching between generators
unC0Rr
parents: 15921
diff changeset
   160
da6b67f13c12 Refactor mapgen to allow for easy switching between generators
unC0Rr
parents: 15921
diff changeset
   161
impl MapGenerator<WfcTemplate> {
da6b67f13c12 Refactor mapgen to allow for easy switching between generators
unC0Rr
parents: 15921
diff changeset
   162
    pub fn import_yaml_templates(&mut self, text: &str) {
da6b67f13c12 Refactor mapgen to allow for easy switching between generators
unC0Rr
parents: 15921
diff changeset
   163
        let mut desc: WfcTemplateCollectionDesc = serde_yaml::from_str(text).unwrap();
15923
d46ad15c6dec Get wavefront collapse generator to work in engine
unC0Rr
parents: 15922
diff changeset
   164
        let templates = std::mem::take(&mut desc.templates);
15922
da6b67f13c12 Refactor mapgen to allow for easy switching between generators
unC0Rr
parents: 15921
diff changeset
   165
        self.templates = desc
da6b67f13c12 Refactor mapgen to allow for easy switching between generators
unC0Rr
parents: 15921
diff changeset
   166
            .template_types
da6b67f13c12 Refactor mapgen to allow for easy switching between generators
unC0Rr
parents: 15921
diff changeset
   167
            .into_iter()
da6b67f13c12 Refactor mapgen to allow for easy switching between generators
unC0Rr
parents: 15921
diff changeset
   168
            .map(|(size, indices)| {
da6b67f13c12 Refactor mapgen to allow for easy switching between generators
unC0Rr
parents: 15921
diff changeset
   169
                (
da6b67f13c12 Refactor mapgen to allow for easy switching between generators
unC0Rr
parents: 15921
diff changeset
   170
                    TemplateType(size),
da6b67f13c12 Refactor mapgen to allow for easy switching between generators
unC0Rr
parents: 15921
diff changeset
   171
                    indices.iter().map(|i| (&templates[*i]).into()).collect(),
da6b67f13c12 Refactor mapgen to allow for easy switching between generators
unC0Rr
parents: 15921
diff changeset
   172
                )
da6b67f13c12 Refactor mapgen to allow for easy switching between generators
unC0Rr
parents: 15921
diff changeset
   173
            })
da6b67f13c12 Refactor mapgen to allow for easy switching between generators
unC0Rr
parents: 15921
diff changeset
   174
            .collect();
da6b67f13c12 Refactor mapgen to allow for easy switching between generators
unC0Rr
parents: 15921
diff changeset
   175
    }
da6b67f13c12 Refactor mapgen to allow for easy switching between generators
unC0Rr
parents: 15921
diff changeset
   176
da6b67f13c12 Refactor mapgen to allow for easy switching between generators
unC0Rr
parents: 15921
diff changeset
   177
    pub fn build_generator(&self, template: WfcTemplate) -> impl LandGenerator {
16024
3402b2185698 Pass full path to WFC for tile loading
unC0Rr
parents: 15925
diff changeset
   178
        WavefrontCollapseLandGenerator::new(template, &self.data_path)
15922
da6b67f13c12 Refactor mapgen to allow for easy switching between generators
unC0Rr
parents: 15921
diff changeset
   179
    }
da6b67f13c12 Refactor mapgen to allow for easy switching between generators
unC0Rr
parents: 15921
diff changeset
   180
}
da6b67f13c12 Refactor mapgen to allow for easy switching between generators
unC0Rr
parents: 15921
diff changeset
   181
16032
31cc1e450273 Add maze land generator ported from pascal engine
unC0Rr
parents: 16031
diff changeset
   182
impl MapGenerator<MazeTemplate> {
31cc1e450273 Add maze land generator ported from pascal engine
unC0Rr
parents: 16031
diff changeset
   183
    pub fn import_yaml_templates(&mut self, text: &str) {
31cc1e450273 Add maze land generator ported from pascal engine
unC0Rr
parents: 16031
diff changeset
   184
        let mut desc: MazeTemplateCollectionDesc = serde_yaml::from_str(text).unwrap();
31cc1e450273 Add maze land generator ported from pascal engine
unC0Rr
parents: 16031
diff changeset
   185
        let templates = std::mem::take(&mut desc.templates);
31cc1e450273 Add maze land generator ported from pascal engine
unC0Rr
parents: 16031
diff changeset
   186
        self.templates = desc
31cc1e450273 Add maze land generator ported from pascal engine
unC0Rr
parents: 16031
diff changeset
   187
            .template_types
31cc1e450273 Add maze land generator ported from pascal engine
unC0Rr
parents: 16031
diff changeset
   188
            .into_iter()
31cc1e450273 Add maze land generator ported from pascal engine
unC0Rr
parents: 16031
diff changeset
   189
            .map(|(size, indices)| {
31cc1e450273 Add maze land generator ported from pascal engine
unC0Rr
parents: 16031
diff changeset
   190
                (
31cc1e450273 Add maze land generator ported from pascal engine
unC0Rr
parents: 16031
diff changeset
   191
                    TemplateType(size),
16035
0caa3dfb3ba2 Add templates for different maze styles
unC0Rr
parents: 16033
diff changeset
   192
                    indices.iter().map(|i| (&templates[*i]).into()).collect(),
16032
31cc1e450273 Add maze land generator ported from pascal engine
unC0Rr
parents: 16031
diff changeset
   193
                )
31cc1e450273 Add maze land generator ported from pascal engine
unC0Rr
parents: 16031
diff changeset
   194
            })
31cc1e450273 Add maze land generator ported from pascal engine
unC0Rr
parents: 16031
diff changeset
   195
            .collect();
31cc1e450273 Add maze land generator ported from pascal engine
unC0Rr
parents: 16031
diff changeset
   196
    }
31cc1e450273 Add maze land generator ported from pascal engine
unC0Rr
parents: 16031
diff changeset
   197
31cc1e450273 Add maze land generator ported from pascal engine
unC0Rr
parents: 16031
diff changeset
   198
    pub fn build_generator(&self, template: MazeTemplate) -> impl LandGenerator {
31cc1e450273 Add maze land generator ported from pascal engine
unC0Rr
parents: 16031
diff changeset
   199
        MazeLandGenerator::new(template)
31cc1e450273 Add maze land generator ported from pascal engine
unC0Rr
parents: 16031
diff changeset
   200
    }
31cc1e450273 Add maze land generator ported from pascal engine
unC0Rr
parents: 16031
diff changeset
   201
}
31cc1e450273 Add maze land generator ported from pascal engine
unC0Rr
parents: 16031
diff changeset
   202
14170
a4c1a2d0ac24 implement basic land bordering
alfadur
parents: 14164
diff changeset
   203
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
a4c1a2d0ac24 implement basic land bordering
alfadur
parents: 14164
diff changeset
   204
struct Color(u32);
a4c1a2d0ac24 implement basic land bordering
alfadur
parents: 14164
diff changeset
   205
a4c1a2d0ac24 implement basic land bordering
alfadur
parents: 14164
diff changeset
   206
impl Color {
a4c1a2d0ac24 implement basic land bordering
alfadur
parents: 14164
diff changeset
   207
    #[inline]
a4c1a2d0ac24 implement basic land bordering
alfadur
parents: 14164
diff changeset
   208
    fn red(self) -> u8 {
15923
d46ad15c6dec Get wavefront collapse generator to work in engine
unC0Rr
parents: 15922
diff changeset
   209
        (self.0 & 0xFF) as u8
14170
a4c1a2d0ac24 implement basic land bordering
alfadur
parents: 14164
diff changeset
   210
    }
a4c1a2d0ac24 implement basic land bordering
alfadur
parents: 14164
diff changeset
   211
a4c1a2d0ac24 implement basic land bordering
alfadur
parents: 14164
diff changeset
   212
    #[inline]
a4c1a2d0ac24 implement basic land bordering
alfadur
parents: 14164
diff changeset
   213
    fn green(self) -> u8 {
a4c1a2d0ac24 implement basic land bordering
alfadur
parents: 14164
diff changeset
   214
        (self.0 >> 8 & 0xFF) as u8
a4c1a2d0ac24 implement basic land bordering
alfadur
parents: 14164
diff changeset
   215
    }
a4c1a2d0ac24 implement basic land bordering
alfadur
parents: 14164
diff changeset
   216
a4c1a2d0ac24 implement basic land bordering
alfadur
parents: 14164
diff changeset
   217
    #[inline]
a4c1a2d0ac24 implement basic land bordering
alfadur
parents: 14164
diff changeset
   218
    fn blue(self) -> u8 {
a4c1a2d0ac24 implement basic land bordering
alfadur
parents: 14164
diff changeset
   219
        (self.0 >> 16 & 0xFF) as u8
a4c1a2d0ac24 implement basic land bordering
alfadur
parents: 14164
diff changeset
   220
    }
a4c1a2d0ac24 implement basic land bordering
alfadur
parents: 14164
diff changeset
   221
a4c1a2d0ac24 implement basic land bordering
alfadur
parents: 14164
diff changeset
   222
    #[inline]
a4c1a2d0ac24 implement basic land bordering
alfadur
parents: 14164
diff changeset
   223
    fn alpha(self) -> u8 {
a4c1a2d0ac24 implement basic land bordering
alfadur
parents: 14164
diff changeset
   224
        (self.0 >> 24 & 0xFF) as u8
a4c1a2d0ac24 implement basic land bordering
alfadur
parents: 14164
diff changeset
   225
    }
a4c1a2d0ac24 implement basic land bordering
alfadur
parents: 14164
diff changeset
   226
}
a4c1a2d0ac24 implement basic land bordering
alfadur
parents: 14164
diff changeset
   227
a4c1a2d0ac24 implement basic land bordering
alfadur
parents: 14164
diff changeset
   228
#[inline]
a4c1a2d0ac24 implement basic land bordering
alfadur
parents: 14164
diff changeset
   229
fn lerp(from: u8, to: u8, coef: u8) -> u8 {
a4c1a2d0ac24 implement basic land bordering
alfadur
parents: 14164
diff changeset
   230
    ((from as u16 * (256 - coef as u16) + to as u16 * coef as u16) / 256) as u8
a4c1a2d0ac24 implement basic land bordering
alfadur
parents: 14164
diff changeset
   231
}
a4c1a2d0ac24 implement basic land bordering
alfadur
parents: 14164
diff changeset
   232
a4c1a2d0ac24 implement basic land bordering
alfadur
parents: 14164
diff changeset
   233
#[inline]
a4c1a2d0ac24 implement basic land bordering
alfadur
parents: 14164
diff changeset
   234
fn blend(source: u32, target: u32) -> u32 {
a4c1a2d0ac24 implement basic land bordering
alfadur
parents: 14164
diff changeset
   235
    let source = Color(source);
a4c1a2d0ac24 implement basic land bordering
alfadur
parents: 14164
diff changeset
   236
    let target = Color(target);
a4c1a2d0ac24 implement basic land bordering
alfadur
parents: 14164
diff changeset
   237
    let alpha = lerp(target.alpha(), 255, source.alpha());
a4c1a2d0ac24 implement basic land bordering
alfadur
parents: 14164
diff changeset
   238
    let red = lerp(target.red(), source.red(), source.alpha());
a4c1a2d0ac24 implement basic land bordering
alfadur
parents: 14164
diff changeset
   239
    let green = lerp(target.green(), source.green(), source.alpha());
a4c1a2d0ac24 implement basic land bordering
alfadur
parents: 14164
diff changeset
   240
    let blue = lerp(target.blue(), source.blue(), source.alpha());
15923
d46ad15c6dec Get wavefront collapse generator to work in engine
unC0Rr
parents: 15922
diff changeset
   241
    (red as u32) | (green as u32) << 8 | (blue as u32) << 16 | (alpha as u32) << 24
14170
a4c1a2d0ac24 implement basic land bordering
alfadur
parents: 14164
diff changeset
   242
}
a4c1a2d0ac24 implement basic land bordering
alfadur
parents: 14164
diff changeset
   243
15903
230dc46487ea Update mapgen to take into account actual values for 'zero' and 'basic' colors
unC0Rr
parents: 15828
diff changeset
   244
fn land_border_pass<'a, LandT, T, F>(
230dc46487ea Update mapgen to take into account actual values for 'zero' and 'basic' colors
unC0Rr
parents: 15828
diff changeset
   245
    basic_value: LandT,
230dc46487ea Update mapgen to take into account actual values for 'zero' and 'basic' colors
unC0Rr
parents: 15828
diff changeset
   246
    rows: T,
230dc46487ea Update mapgen to take into account actual values for 'zero' and 'basic' colors
unC0Rr
parents: 15828
diff changeset
   247
    offsets: &mut [u8],
230dc46487ea Update mapgen to take into account actual values for 'zero' and 'basic' colors
unC0Rr
parents: 15828
diff changeset
   248
    border_width: u8,
230dc46487ea Update mapgen to take into account actual values for 'zero' and 'basic' colors
unC0Rr
parents: 15828
diff changeset
   249
    pixel_getter: F,
230dc46487ea Update mapgen to take into account actual values for 'zero' and 'basic' colors
unC0Rr
parents: 15828
diff changeset
   250
) where
14710
946df0bb3b28 collapse mapgen back
alfadur
parents: 14702
diff changeset
   251
    LandT: Default + PartialEq + 'a,
946df0bb3b28 collapse mapgen back
alfadur
parents: 14702
diff changeset
   252
    T: Iterator<Item = (&'a [LandT], &'a mut [u32])>,
946df0bb3b28 collapse mapgen back
alfadur
parents: 14702
diff changeset
   253
    F: (Fn(usize, usize) -> u32),
14170
a4c1a2d0ac24 implement basic land bordering
alfadur
parents: 14164
diff changeset
   254
{
a4c1a2d0ac24 implement basic land bordering
alfadur
parents: 14164
diff changeset
   255
    for (land_row, tex_row) in rows {
14710
946df0bb3b28 collapse mapgen back
alfadur
parents: 14702
diff changeset
   256
        for (x, ((land_v, tex_v), offset_v)) in land_row
946df0bb3b28 collapse mapgen back
alfadur
parents: 14702
diff changeset
   257
            .iter()
14170
a4c1a2d0ac24 implement basic land bordering
alfadur
parents: 14164
diff changeset
   258
            .zip(tex_row.iter_mut())
a4c1a2d0ac24 implement basic land bordering
alfadur
parents: 14164
diff changeset
   259
            .zip(offsets.iter_mut())
a4c1a2d0ac24 implement basic land bordering
alfadur
parents: 14164
diff changeset
   260
            .enumerate()
a4c1a2d0ac24 implement basic land bordering
alfadur
parents: 14164
diff changeset
   261
        {
15903
230dc46487ea Update mapgen to take into account actual values for 'zero' and 'basic' colors
unC0Rr
parents: 15828
diff changeset
   262
            *offset_v = if *land_v == basic_value {
14170
a4c1a2d0ac24 implement basic land bordering
alfadur
parents: 14164
diff changeset
   263
                if *offset_v < border_width {
14710
946df0bb3b28 collapse mapgen back
alfadur
parents: 14702
diff changeset
   264
                    *tex_v = blend(pixel_getter(x, *offset_v as usize), *tex_v)
14170
a4c1a2d0ac24 implement basic land bordering
alfadur
parents: 14164
diff changeset
   265
                }
a4c1a2d0ac24 implement basic land bordering
alfadur
parents: 14164
diff changeset
   266
                offset_v.saturating_add(1)
a4c1a2d0ac24 implement basic land bordering
alfadur
parents: 14164
diff changeset
   267
            } else {
a4c1a2d0ac24 implement basic land bordering
alfadur
parents: 14164
diff changeset
   268
                0
a4c1a2d0ac24 implement basic land bordering
alfadur
parents: 14164
diff changeset
   269
            }
a4c1a2d0ac24 implement basic land bordering
alfadur
parents: 14164
diff changeset
   270
        }
a4c1a2d0ac24 implement basic land bordering
alfadur
parents: 14164
diff changeset
   271
    }
a4c1a2d0ac24 implement basic land bordering
alfadur
parents: 14164
diff changeset
   272
}
a4c1a2d0ac24 implement basic land bordering
alfadur
parents: 14164
diff changeset
   273
15903
230dc46487ea Update mapgen to take into account actual values for 'zero' and 'basic' colors
unC0Rr
parents: 15828
diff changeset
   274
fn tex_row_copy<LandT>(
230dc46487ea Update mapgen to take into account actual values for 'zero' and 'basic' colors
unC0Rr
parents: 15828
diff changeset
   275
    basic_value: LandT,
230dc46487ea Update mapgen to take into account actual values for 'zero' and 'basic' colors
unC0Rr
parents: 15828
diff changeset
   276
    land_row: &[LandT],
230dc46487ea Update mapgen to take into account actual values for 'zero' and 'basic' colors
unC0Rr
parents: 15828
diff changeset
   277
    tex_row: &mut [u32],
230dc46487ea Update mapgen to take into account actual values for 'zero' and 'basic' colors
unC0Rr
parents: 15828
diff changeset
   278
    sprite_row: &[u32],
230dc46487ea Update mapgen to take into account actual values for 'zero' and 'basic' colors
unC0Rr
parents: 15828
diff changeset
   279
) where
14710
946df0bb3b28 collapse mapgen back
alfadur
parents: 14702
diff changeset
   280
    LandT: Default + PartialEq,
14702
29dbe9ce8b7d add basic map rendering with gl
fkaa
parents: 14175
diff changeset
   281
{
14710
946df0bb3b28 collapse mapgen back
alfadur
parents: 14702
diff changeset
   282
    for ((land_v, tex_v), sprite_v) in land_row.iter().zip(tex_row.iter_mut()).zip(sprite_row) {
15903
230dc46487ea Update mapgen to take into account actual values for 'zero' and 'basic' colors
unC0Rr
parents: 15828
diff changeset
   283
        *tex_v = if *land_v == basic_value { *sprite_v } else { 0 }
14702
29dbe9ce8b7d add basic map rendering with gl
fkaa
parents: 14175
diff changeset
   284
    }
29dbe9ce8b7d add basic map rendering with gl
fkaa
parents: 14175
diff changeset
   285
}
29dbe9ce8b7d add basic map rendering with gl
fkaa
parents: 14175
diff changeset
   286
14127
0c5b9cfda9ab add a higher level map generation lib to load yaml templates into somewhere
alfadur
parents:
diff changeset
   287
#[cfg(test)]
0c5b9cfda9ab add a higher level map generation lib to load yaml templates into somewhere
alfadur
parents:
diff changeset
   288
mod tests {
16031
1b1d5729ff3e Fix test to match new yaml structure
unC0Rr
parents: 16029
diff changeset
   289
    use std::path::Path;
15925
b0e8cc72bfef Allow defining compatible edges for grid, add few more templates
unC0Rr
parents: 15924
diff changeset
   290
    use crate::{MapGenerator, OutlineTemplate, TemplateType};
15924
9502611bffc1 Some bug fixes, build fixes and code formatting
unC0Rr
parents: 15923
diff changeset
   291
    use rand::thread_rng;
14127
0c5b9cfda9ab add a higher level map generation lib to load yaml templates into somewhere
alfadur
parents:
diff changeset
   292
0c5b9cfda9ab add a higher level map generation lib to load yaml templates into somewhere
alfadur
parents:
diff changeset
   293
    #[test]
0c5b9cfda9ab add a higher level map generation lib to load yaml templates into somewhere
alfadur
parents:
diff changeset
   294
    fn simple_load() {
0c5b9cfda9ab add a higher level map generation lib to load yaml templates into somewhere
alfadur
parents:
diff changeset
   295
        let text = r#"
14128
b04dac00e8e2 add command arguments to use a template from file into land_dump
alfadur
parents: 14127
diff changeset
   296
# comment
b04dac00e8e2 add command arguments to use a template from file into land_dump
alfadur
parents: 14127
diff changeset
   297
14127
0c5b9cfda9ab add a higher level map generation lib to load yaml templates into somewhere
alfadur
parents:
diff changeset
   298
templates:
0c5b9cfda9ab add a higher level map generation lib to load yaml templates into somewhere
alfadur
parents:
diff changeset
   299
  -
0c5b9cfda9ab add a higher level map generation lib to load yaml templates into somewhere
alfadur
parents:
diff changeset
   300
    width: 3072
0c5b9cfda9ab add a higher level map generation lib to load yaml templates into somewhere
alfadur
parents:
diff changeset
   301
    height: 1424
0c5b9cfda9ab add a higher level map generation lib to load yaml templates into somewhere
alfadur
parents:
diff changeset
   302
    can_flip: false
0c5b9cfda9ab add a higher level map generation lib to load yaml templates into somewhere
alfadur
parents:
diff changeset
   303
    can_invert: false
0c5b9cfda9ab add a higher level map generation lib to load yaml templates into somewhere
alfadur
parents:
diff changeset
   304
    can_mirror: true
0c5b9cfda9ab add a higher level map generation lib to load yaml templates into somewhere
alfadur
parents:
diff changeset
   305
    is_negative: false
0c5b9cfda9ab add a higher level map generation lib to load yaml templates into somewhere
alfadur
parents:
diff changeset
   306
    put_girders: true
0c5b9cfda9ab add a higher level map generation lib to load yaml templates into somewhere
alfadur
parents:
diff changeset
   307
    max_hedgehogs: 18
0c5b9cfda9ab add a higher level map generation lib to load yaml templates into somewhere
alfadur
parents:
diff changeset
   308
    outline_points:
0c5b9cfda9ab add a higher level map generation lib to load yaml templates into somewhere
alfadur
parents:
diff changeset
   309
      -
0c5b9cfda9ab add a higher level map generation lib to load yaml templates into somewhere
alfadur
parents:
diff changeset
   310
        - {x: 748, y: 1424, w: 1, h: 1}
0c5b9cfda9ab add a higher level map generation lib to load yaml templates into somewhere
alfadur
parents:
diff changeset
   311
        - {x: 636, y: 1252, w: 208, h: 72}
0c5b9cfda9ab add a higher level map generation lib to load yaml templates into somewhere
alfadur
parents:
diff changeset
   312
        - {x: 898, y: 1110, w: 308, h: 60}
0c5b9cfda9ab add a higher level map generation lib to load yaml templates into somewhere
alfadur
parents:
diff changeset
   313
        - {x: 1128, y: 1252, w: 434, h: 40}
0c5b9cfda9ab add a higher level map generation lib to load yaml templates into somewhere
alfadur
parents:
diff changeset
   314
        - {x: 1574, y: 1112, w: 332, h: 40}
0c5b9cfda9ab add a higher level map generation lib to load yaml templates into somewhere
alfadur
parents:
diff changeset
   315
        - {x: 1802, y: 1238, w: 226, h: 36}
0c5b9cfda9ab add a higher level map generation lib to load yaml templates into somewhere
alfadur
parents:
diff changeset
   316
        - {x: 1930, y: 1424, w: 1, h: 1}
0c5b9cfda9ab add a higher level map generation lib to load yaml templates into somewhere
alfadur
parents:
diff changeset
   317
    fill_points:
0c5b9cfda9ab add a higher level map generation lib to load yaml templates into somewhere
alfadur
parents:
diff changeset
   318
      - {x: 1023, y: 0}
14128
b04dac00e8e2 add command arguments to use a template from file into land_dump
alfadur
parents: 14127
diff changeset
   319
      - {x: 1023, y: 0}
14127
0c5b9cfda9ab add a higher level map generation lib to load yaml templates into somewhere
alfadur
parents:
diff changeset
   320
0c5b9cfda9ab add a higher level map generation lib to load yaml templates into somewhere
alfadur
parents:
diff changeset
   321
template_types:
16031
1b1d5729ff3e Fix test to match new yaml structure
unC0Rr
parents: 16029
diff changeset
   322
    test:
1b1d5729ff3e Fix test to match new yaml structure
unC0Rr
parents: 16029
diff changeset
   323
      indices: [0]
14127
0c5b9cfda9ab add a higher level map generation lib to load yaml templates into somewhere
alfadur
parents:
diff changeset
   324
"#;
0c5b9cfda9ab add a higher level map generation lib to load yaml templates into somewhere
alfadur
parents:
diff changeset
   325
16031
1b1d5729ff3e Fix test to match new yaml structure
unC0Rr
parents: 16029
diff changeset
   326
        let mut generator = MapGenerator::<OutlineTemplate>::new(Path::new(""));
14127
0c5b9cfda9ab add a higher level map generation lib to load yaml templates into somewhere
alfadur
parents:
diff changeset
   327
        generator.import_yaml_templates(&text);
0c5b9cfda9ab add a higher level map generation lib to load yaml templates into somewhere
alfadur
parents:
diff changeset
   328
14710
946df0bb3b28 collapse mapgen back
alfadur
parents: 14702
diff changeset
   329
        assert!(generator
946df0bb3b28 collapse mapgen back
alfadur
parents: 14702
diff changeset
   330
            .templates
946df0bb3b28 collapse mapgen back
alfadur
parents: 14702
diff changeset
   331
            .contains_key(&TemplateType("test".to_string())));
14127
0c5b9cfda9ab add a higher level map generation lib to load yaml templates into somewhere
alfadur
parents:
diff changeset
   332
15924
9502611bffc1 Some bug fixes, build fixes and code formatting
unC0Rr
parents: 15923
diff changeset
   333
        let template = generator.get_template("test", &mut thread_rng()).unwrap();
14127
0c5b9cfda9ab add a higher level map generation lib to load yaml templates into somewhere
alfadur
parents:
diff changeset
   334
0c5b9cfda9ab add a higher level map generation lib to load yaml templates into somewhere
alfadur
parents:
diff changeset
   335
        assert_eq!(template.islands[0].len(), 7);
0c5b9cfda9ab add a higher level map generation lib to load yaml templates into somewhere
alfadur
parents:
diff changeset
   336
    }
0c5b9cfda9ab add a higher level map generation lib to load yaml templates into somewhere
alfadur
parents:
diff changeset
   337
}