Struct micro_games_kit::grid_world::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 96-113)

    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()),
            ),
        }
    }

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<bool>) -> 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)

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 Graphics<Vertex>)