Struct GridWorldLayer

pub struct GridWorldLayer {
    pub tilemap: TileMap,
    /* private fields */
}

Fields

tilemap: TileMap

Implementations

impl GridWorldLayer

pub fn new(tilemap: TileMap) -> Self

Examples found in repository

examples/pcg_island.rs (line 131)

    fn default() -> Self {
        let mut height = Grid::<f64>::generate(
            SIZE.into(),
            NoiseGenerator::new(Fbm::<SuperSimplex>::default().set_frequency(0.025)),
        );
        height.apply_all(RemapGenerator {
            from: -1.0..1.0,
            to: 0.0..1.0,
        });

        let gradient = Grid::<f64>::generate(
            SIZE.into(),
            |location: Vec2<usize>, size: Vec2<usize>, _| {
                let center = size / 2;
                let x = if location.x >= center.x {
                    location.x - center.x
                } else {
                    center.x - location.x
                } as f64;
                let y = if location.y >= center.y {
                    location.y - center.y
                } else {
                    center.y - location.y
                } as f64;
                let result = (x / center.x as f64).max(y / center.y as f64);
                result * result
            },
        );
        height.apply_all(SubGenerator { other: &gradient });

        let mut biome = Grid::<f64>::generate(
            SIZE.into(),
            NoiseGenerator::new(Fbm::<SuperSimplex>::new(42).set_frequency(0.05)),
        );
        biome.apply_all(RemapGenerator {
            from: -1.0..1.0,
            to: 0.0..1.0,
        });

        let buffer = height
            .into_inner()
            .1
            .into_iter()
            .zip(biome.into_inner().1)
            .map(|(height, biome)| {
                if height > 0.75 {
                    SNOW
                } else if height > 0.6 {
                    ROCK
                } else if height > 0.1 {
                    if biome > 0.8 {
                        SAND
                    } else if biome > 0.5 {
                        GRASS
                    } else {
                        FOREST
                    }
                } else {
                    WATER
                }
            })
            .collect();

        Self {
            world: GridWorld::new(
                10.0.into(),
                TileSet::default()
                    .shader(ShaderRef::name("color"))
                    .mapping(WATER, TileSetItem::default().tint(Rgba::blue()))
                    .mapping(
                        FOREST,
                        TileSetItem::default().tint(Rgba::new_opaque(0.0, 0.5, 0.0)),
                    )
                    .mapping(GRASS, TileSetItem::default().tint(Rgba::green()))
                    .mapping(
                        SAND,
                        TileSetItem::default().tint(Rgba::new_opaque(1.0, 1.0, 0.5)),
                    )
                    .mapping(ROCK, TileSetItem::default().tint(Rgba::gray(0.5)))
                    .mapping(SNOW, TileSetItem::default().tint(Rgba::white())),
                GridWorldLayer::new(TileMap::with_buffer(SIZE.into(), buffer).unwrap()),
            ),
            weather_tileset: TileSet::default()
                .shader(ShaderRef::name("color"))
                .mapping(
                    CLEAR_SKY,
                    TileSetItem::default().tint(Rgba::new(1.0, 1.0, 1.0, 0.0)),
                )
                .mapping(
                    CLOUD_SKY,
                    TileSetItem::default().tint(Rgba::new(1.0, 1.0, 1.0, 0.8)),
                )
                .mapping(
                    RAINY_SKY,
                    TileSetItem::default().tint(Rgba::new(0.3, 0.3, 0.3, 0.8)),
                ),
            weather_noise: Fbm::<SuperSimplex>::default().set_frequency(0.03),
            time: 0.0,
            mouse_position: Default::default(),
        }
    }

pub fn new_filtered<F: GridWorldEmitterFilter + 'static>( tilemap: TileMap, filter: F, ) -> Self

pub fn access_filter<F: GridWorldEmitterFilter + 'static>( &mut self, ) -> Option<&mut F>