veloren_world/site/plot/

savannah_airship_dock.rs

use super::*;
use crate::{
    Land,
    site::generation::{place_circular_as_vec, spiral_staircase},
    util::{CARDINALS, DIAGONALS, RandomField, Sampler, within_distance},
};
use common::{
    generation::SpecialEntity,
    terrain::{BlockKind, SpriteKind},
};
use rand::prelude::*;
use std::{f32::consts::TAU, sync::Arc};
use vek::*;

/// Represents house data generated by the `generate()` method
pub struct SavannahAirshipDock {
    /// Tile position of the door tile
    pub door_tile: Vec2<i32>,
    /// Approximate altitude of the door tile
    pub(crate) alt: i32,
    pub center: Vec2<i32>,
    length: i32,
    platform_height: i32,
    pub docking_positions: Vec<Vec3<i32>>,
}

impl SavannahAirshipDock {
    pub fn generate(
        land: &Land,
        _rng: &mut impl Rng,
        site: &Site,
        door_tile: Vec2<i32>,
        tile_aabr: Aabr<i32>,
    ) -> Self {
        let door_tile_pos = site.tile_center_wpos(door_tile);
        let bounds = Aabr {
            min: site.tile_wpos(tile_aabr.min),
            max: site.tile_wpos(tile_aabr.max),
        };
        let center = bounds.center();
        let length = 21;

        // dock is 5 tiles = 30 blocks in radius
        // airships are 37 blocks wide = 6 tiles.
        // distance from the center to the outside edge of the airship when docked is 11
        // tiles. The area covered by all four airships is a square 22 tiles on
        // a side.

        // Sample the surface altitude every 4 tiles (= 24 blocks) around the dock
        // center to find the highest point of terrain surrounding the dock.
        let mut max_surface_alt = i32::MIN;
        // -12 -8 -4 0 +4 +8 +12
        for dx in -3..=3 {
            for dy in -3..=3 {
                let pos = center + Vec2::new(dx * 24, dy * 24);
                let alt = land.get_surface_alt_approx(pos) as i32;
                if alt > max_surface_alt {
                    max_surface_alt = alt;
                }
            }
        }

        // The foundation has a radius of length + 4 blocks.
        // Sample the surface altitude over the foundation area to get the
        // foundation min alt.
        let foundation_qtr = (length + 4) / 2;
        let mut min_foundation_alt = i32::MAX;
        for dx in -2..=2 {
            for dy in -2..=2 {
                let pos = center + Vec2::new(dx * foundation_qtr, dy * foundation_qtr);
                let alt = land.get_surface_alt_approx(pos) as i32;
                if alt < min_foundation_alt {
                    min_foundation_alt = alt;
                }
            }
        }

        let mut base_alt = min_foundation_alt + 2;
        let mut platform_height = 40;
        let mut top_floor = base_alt + 1 + platform_height - 3;
        let clearance = top_floor - (max_surface_alt + 5);
        if clearance < 0 {
            base_alt -= clearance;
            platform_height -= clearance;
            top_floor -= clearance;
        }

        let docking_positions = CARDINALS
            .iter()
            .map(|dir| (center + dir * 31).with_z(top_floor))
            .collect::<Vec<_>>();
        Self {
            door_tile: door_tile_pos,
            alt: base_alt,
            center,
            length,
            platform_height,
            docking_positions,
        }
    }

    pub fn spawn_rules(&self, wpos: Vec2<i32>) -> SpawnRules {
        SpawnRules {
            trees: {
                // dock is 5 tiles = 30 blocks in radius
                // airships are 39 blocks wide.
                // Tree can be up to 20 blocks in radius.
                // Don't allow trees within 30 + 39 + 20 = 89 blocks of the dock center
                const AIRSHIP_MIN_TREE_DIST2: i32 = 89;
                !within_distance(wpos, self.center, AIRSHIP_MIN_TREE_DIST2)
            },
            waypoints: false,
            ..SpawnRules::default()
        }
    }
}

impl Structure for SavannahAirshipDock {
    #[cfg(feature = "use-dyn-lib")]
    const UPDATE_FN: &'static [u8] = b"render_savannah_airship_dock\0";

    #[cfg_attr(
        feature = "be-dyn-lib",
        unsafe(export_name = "render_savannah_airship_dock")
    )]
    fn render_inner(&self, _site: &Site, _land: &Land, painter: &Painter) {
        let base = self.alt + 1;
        let center = self.center;
        let wood_dark = Fill::Brick(BlockKind::Misc, Rgb::new(142, 67, 27), 12);
        let reed = Fill::Brick(BlockKind::Misc, Rgb::new(72, 55, 46), 22);
        let clay = Fill::Brick(BlockKind::Misc, Rgb::new(209, 124, 57), 22);
        let color = Fill::Sampling(Arc::new(|center| {
            Some(match (RandomField::new(0).get(center)) % 7 {
                0 => Block::new(BlockKind::GlowingRock, Rgb::new(153, 82, 40)),
                1 => Block::new(BlockKind::GlowingRock, Rgb::new(172, 104, 57)),
                2 => Block::new(BlockKind::GlowingRock, Rgb::new(135, 106, 100)),
                3 => Block::new(BlockKind::GlowingRock, Rgb::new(198, 164, 139)),
                4 => Block::new(BlockKind::GlowingRock, Rgb::new(168, 163, 157)),
                5 => Block::new(BlockKind::GlowingRock, Rgb::new(73, 53, 42)),
                _ => Block::new(BlockKind::GlowingRock, Rgb::new(178, 124, 90)),
            })
        }));
        let length = self.length;
        let height = length / 2;
        let platform_height = self.platform_height;
        let storeys = 1;
        let radius = length + (length / 3);
        let reed_var = (1 + RandomField::new(0).get(center.with_z(base)) % 4) as f32;
        let reed_parts = 36_f32 + reed_var;
        let phi = TAU / reed_parts;

        // foundation
        painter
            .cylinder(Aabb {
                min: (center - length).with_z(base - 3),
                max: (center + length + 1).with_z(base - 2),
            })
            .fill(clay.clone());
        painter
            .cylinder(Aabb {
                min: (center - length - 1).with_z(base - 4),
                max: (center + length + 2).with_z(base - 3),
            })
            .fill(clay.clone());
        painter
            .cylinder(Aabb {
                min: (center - length - 2).with_z(base - 5),
                max: (center + length + 3).with_z(base - 4),
            })
            .fill(clay.clone());
        painter
            .cylinder(Aabb {
                min: (center - length - 3).with_z(base - height),
                max: (center + length + 4).with_z(base - 5),
            })
            .fill(clay.clone());
        // platform
        painter
            .cylinder(Aabb {
                min: (center - (2 * (length / 3)) - 1).with_z(base + platform_height - 4),
                max: (center + (2 * (length / 3)) + 1).with_z(base + platform_height - 3),
            })
            .fill(color.clone());
        painter
            .cylinder(Aabb {
                min: (center - (2 * (length / 3))).with_z(base + platform_height - 4),
                max: (center + (2 * (length / 3))).with_z(base + platform_height - 3),
            })
            .fill(clay.clone());
        painter
            .cylinder(Aabb {
                min: (center - length - 2).with_z(base + platform_height - 3),
                max: (center + length + 2).with_z(base + platform_height - 2),
            })
            .fill(color.clone());
        painter
            .cylinder(Aabb {
                min: (center - length - 1).with_z(base + platform_height - 3),
                max: (center + length + 1).with_z(base + platform_height - 2),
            })
            .fill(clay.clone());
        // docks
        for dir in CARDINALS {
            let dock_pos = center + dir * 26;
            painter
                .cylinder(Aabb {
                    min: (dock_pos - 5).with_z(base + platform_height - 3),
                    max: (dock_pos + 5).with_z(base + platform_height - 2),
                })
                .fill(color.clone());
            painter
                .cylinder(Aabb {
                    min: (dock_pos - 4).with_z(base + platform_height - 3),
                    max: (dock_pos + 4).with_z(base + platform_height - 2),
                })
                .fill(wood_dark.clone());
        }

        // lanterns, crates & barrels
        for dir in CARDINALS {
            let lantern_pos = center + (dir * length);

            painter.sprite(
                lantern_pos.with_z(base + platform_height - 2),
                SpriteKind::Lantern,
            );
        }
        for dir in DIAGONALS {
            let cargo_pos = center + (dir * ((length / 2) - 1));
            for dir in CARDINALS {
                let sprite_pos = cargo_pos + dir;
                let rows = (RandomField::new(0).get(sprite_pos.with_z(base)) % 3) as i32;
                for r in 0..rows {
                    painter
                        .aabb(Aabb {
                            min: (sprite_pos).with_z(base + platform_height - 2 + r),
                            max: (sprite_pos + 1).with_z(base + platform_height - 1 + r),
                        })
                        .fill(Fill::Block(Block::air(
                            match (RandomField::new(0).get(sprite_pos.with_z(base + r)) % 2) as i32
                            {
                                0 => SpriteKind::Barrel,
                                _ => SpriteKind::CrateBlock,
                            },
                        )));
                    if r > 0 {
                        painter.owned_resource_sprite(
                            sprite_pos.with_z(base + platform_height - 1 + r),
                            SpriteKind::Crate,
                            0,
                        );
                    }
                }
            }
        }
        // campfire
        let campfire_pos = (center - (2 * (length / 3)) - 1).with_z(base + platform_height);
        painter.spawn(
            EntityInfo::at(campfire_pos.map(|e| e as f32 + 0.5))
                .into_special(SpecialEntity::Waypoint),
        );
        for b in 0..2 {
            let base = base + (b * platform_height);
            let radius = radius - (b * (radius / 3));
            let length = length - (b * (length / 3));
            // roof cone
            painter
                .cone(Aabb {
                    min: (center - radius).with_z(base + (storeys * height) - (height / 2) + 1),
                    max: (center + radius)
                        .with_z(base + (storeys * height) + (height / 2) - 1 + reed_var as i32),
                })
                .fill(reed.clone());
            painter
                .cone(Aabb {
                    min: (center - radius).with_z(base + (storeys * height) - (height / 2)),
                    max: (center + radius)
                        .with_z(base + (storeys * height) + (height / 2) - 2 + reed_var as i32),
                })
                .clear();

            if b == 1 {
                // Agent Desk
                let agent_z_pos = base - 2 + ((storeys - 1) * (height + 2));
                painter
                    .cylinder_with_radius(
                        center.with_z(agent_z_pos),
                        (length + 1 - (storeys - 1)) as f32,
                        6.0,
                    )
                    .intersect(painter.aabb(Aabb {
                        min: (Vec2::new(center.x - 3, center.y + 4)).with_z(agent_z_pos),
                        max: (Vec2::new(center.x - 30, center.y + 30)).with_z(agent_z_pos + 7),
                    }))
                    .fill(clay.clone());
                painter
                    .cylinder_with_radius(
                        center.with_z(agent_z_pos),
                        (length + 1 - (storeys - 1)) as f32,
                        5.0,
                    )
                    .intersect(painter.aabb(Aabb {
                        min: (Vec2::new(center.x - 4, center.y + 5)).with_z(agent_z_pos),
                        max: (Vec2::new(center.x - 30, center.y + 30)).with_z(agent_z_pos + 6),
                    }))
                    .clear();
                painter
                    .cylinder_with_radius(
                        Vec2::new(center.x - 4, center.y + 5).with_z(agent_z_pos),
                        (length - 4 - (storeys - 1)) as f32,
                        1.0,
                    )
                    .intersect(painter.aabb(Aabb {
                        min: (Vec2::new(center.x - 4, center.y + 5)).with_z(agent_z_pos),
                        max: (Vec2::new(center.x - 30, center.y + 30)).with_z(agent_z_pos + 2),
                    }))
                    .fill(color.clone());
                painter
                    .cylinder_with_radius(
                        Vec2::new(center.x - 4, center.y + 5).with_z(agent_z_pos),
                        (length - 5 - (storeys - 1)) as f32,
                        1.0,
                    )
                    .intersect(painter.aabb(Aabb {
                        min: (Vec2::new(center.x - 4, center.y + 5)).with_z(agent_z_pos),
                        max: (Vec2::new(center.x - 30, center.y + 30)).with_z(agent_z_pos + 2),
                    }))
                    .clear();
            }
            // room
            for s in 0..storeys {
                let room = painter.cylinder(Aabb {
                    min: (center - length + 2 + s).with_z(base - 2 + (s * height)),
                    max: (center + 1 + length - 2 - s).with_z(base + height + (s * height)),
                });
                room.fill(clay.clone());
                // decor inlays
                for dir in DIAGONALS {
                    let decor_pos = center + dir * (length - 2 - s);
                    let decor = painter
                        .line(
                            center.with_z(base - 1 + (s * (height + 2))),
                            decor_pos.with_z(base - 1 + (s * (height + 2))),
                            5.0,
                        )
                        .intersect(room);
                    decor.fill(color.clone());
                    painter
                        .line(
                            center.with_z(base - 1 + (s * (height + 2))),
                            decor_pos.with_z(base - 1 + (s * (height + 2))),
                            4.0,
                        )
                        .intersect(decor)
                        .fill(clay.clone());
                }
            }

            // clear rooms
            painter
                .cylinder(Aabb {
                    min: (center - length + 4).with_z(base - 2),
                    max: (center + 1 + length - 4).with_z(base + (storeys * height)),
                })
                .clear();
            // wood decor
            painter
                .cylinder(Aabb {
                    min: (center - length + 4).with_z(base - 1),
                    max: (center + 1 + length - 4).with_z(base),
                })
                .fill(wood_dark.clone());
            painter
                .cylinder(Aabb {
                    min: (center - length + 4).with_z(base + (storeys * height) - 1),
                    max: (center + 1 + length - 4).with_z(base + (storeys * height) + 1),
                })
                .fill(wood_dark.clone());

            for s in 0..storeys {
                // entries, windows
                for dir in CARDINALS {
                    let frame_pos = center + dir * (length - 2 - s);
                    let clear_pos = center + dir * (length + 2 - s);

                    painter
                        .line(
                            center.with_z(base - 1 + (s * (height + 2))),
                            frame_pos.with_z(base - 1 + (s * (height + 2))),
                            3.0,
                        )
                        .fill(color.clone());
                    painter
                        .line(
                            center.with_z(base - 1 + (s * (height + 2))),
                            clear_pos.with_z(base - 1 + (s * (height + 2))),
                            2.0,
                        )
                        .clear();
                }
            }
            // re clear room
            painter
                .cylinder(Aabb {
                    min: (center - length + 5).with_z(base - 2),
                    max: (center + 1 + length - 5).with_z(base + (storeys * height) + 1),
                })
                .clear();
            // floor
            painter
                .cylinder(Aabb {
                    min: (center - (length / 2) - 1).with_z(base - 3),
                    max: (center + (length / 2) + 1).with_z(base - 2),
                })
                .fill(color.clone());
            painter
                .cylinder(Aabb {
                    min: (center - (length / 2) + 1).with_z(base - 3),
                    max: (center + (length / 2) - 1).with_z(base - 2),
                })
                .fill(clay.clone());

            // reed roof lines
            for n in 1..=reed_parts as i32 {
                let pos = Vec2::new(
                    center.x + ((radius as f32) * ((n as f32 * phi).cos())) as i32,
                    center.y + ((radius as f32) * ((n as f32 * phi).sin())) as i32,
                );
                painter
                    .line(
                        pos.with_z(base + (storeys * height) - (height / 2)),
                        center.with_z(base + (storeys * height) + (height / 2) + reed_var as i32),
                        1.0,
                    )
                    .fill(reed.clone());
            }
        }

        // tower
        let beams_low = place_circular_as_vec(center, (2 * (length / 3)) as f32, 10);
        let beams_high = place_circular_as_vec(center, (2 * (length / 4)) as f32, 10);

        for b in 0..beams_low.len() {
            painter
                .cylinder(Aabb {
                    min: (beams_low[b] - 4).with_z(base + height - 1),
                    max: (beams_low[b] + 4).with_z(base + height),
                })
                .fill(wood_dark.clone());

            painter
                .line(
                    beams_low[b].with_z(base + height),
                    beams_high[b].with_z(base + platform_height - 4),
                    1.5,
                )
                .fill(wood_dark.clone());
        }
        //stairs
        painter
            .cylinder(Aabb {
                min: (center - (length / 3)).with_z(base),
                max: (center + (length / 3)).with_z(base + platform_height),
            })
            .clear();

        let stairs = painter.cylinder(Aabb {
            min: (center - (length / 3)).with_z(base - 3),
            max: (center + (length / 3)).with_z(base + platform_height - 2),
        });

        stairs
            .sample(spiral_staircase(
                center.with_z(base - 3),
                ((length / 3) + 1) as f32,
                0.5,
                (platform_height / 4) as f32,
            ))
            .fill(clay.clone());
    }
}