Struct GridWorld 

pub struct GridWorld {
    pub position: Vec2<f32>,
    pub pivot: Vec2<f32>,
    pub tile_size: Vec2<f32>,
    pub tileset: TileSet,
    pub visible_layers: Range<usize>,
    /* private fields */
}

Fields

position: Vec2<f32>

pivot: Vec2<f32>

tile_size: Vec2<f32>

tileset: TileSet

visible_layers: Range<usize>

Implementations

impl GridWorld

pub fn new( tile_size: Vec2<f32>, tileset: TileSet, terrain_layer: GridWorldLayer, ) -> Self

Examples found in repository

examples/pcg_island.rs (lines 124-141)

    fn default() -> Self {
        let mut height = Grid::<f64>::generate(
            SIZE,
            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, |location: Vec2<usize>, size: Vec2<usize>, _| {
                let center = size / 2;
                let x = location.x.abs_diff(center.x) as f64;
                let y = location.y.abs_diff(center.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,
            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(), true),
            ),
            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 from_layers( tile_size: Vec2<f32>, tileset: TileSet, terrain_layers: impl IntoIterator<Item = GridWorldLayer>, ) -> Option<Self>

pub fn with_position(self, value: Vec2<f32>) -> Self

pub fn with_pivot(self, value: Vec2<f32>) -> Self

pub fn with_visible_layers(self, value: Range<usize>) -> Self

pub fn with_layer(self, layer: GridWorldLayer) -> Self

pub fn with_visible_layer(self, layer: GridWorldLayer) -> Self

pub fn with_tile_instance(self, instance: TileInstance) -> Self

pub fn with_tile_instances( self, instances: impl IntoIterator<Item = TileInstance>, ) -> Self

pub fn with_colliders(self, grid: Grid<u8>) -> Self

pub fn with_collider(self, location: Vec2<usize>) -> Self

pub fn insert_tile_instance(&mut self, instance: TileInstance)

pub fn remove_tile_instances(&mut self, instance: &TileInstance)

pub fn remove_tile_instances_at_location(&mut self, location: Vec2<usize>)

pub fn collider(&self, location: Vec2<usize>) -> bool

pub fn set_collider(&mut self, location: Vec2<usize>, value: bool) -> u8

pub fn clear_collider(&mut self, location: Vec2<usize>)

pub fn layers(&self) -> &[GridWorldLayer]

pub fn layers_mut(&mut self) -> &mut [GridWorldLayer]

pub fn locations_iter(&self) -> impl Iterator<Item = Vec2<usize>>

pub fn world_to_local(&self, location: Vec2<f32>) -> Option<Vec2<usize>>

pub fn local_to_world(&self, location: Vec2<usize>) -> Vec2<f32>

Trait Implementations

impl Drawable for GridWorld

fn draw( &self, context: &mut DrawContext, graphics: &mut dyn GraphicsTarget<Vertex>, )