isometric_board/

isometric-board.rs

//! A fixed diagonal view over a small board, with no foreshortening —
//! `Projection::orthographic`, the only example that uses it. A unit
//! takes each turn: a click on its `Ray::hit_aabb` box selects it, then a
//! click on a board tile orders it there. Around the board, a rock is drawn
//! for each `seed`, built by plain arithmetic, its own cached mesh.
//! Movement is fixed-step in `tick`, at thirty steps a second — half the
//! engine's default rate; drawing interpolates between the last two
//! steps.

use core::time::Duration;

use mirage_engine::prelude::*;
use mirage_engine::ray;

/// Tiles on a side.
const BOARD_TILES: i32 = 6;

/// A tile's footprint, center to center, in meters.
const TILE_SIZE: f32 = 1.0;

/// The gap left between tiles' footprints, for a visible grid line.
const TILE_GAP: f32 = 0.05;

const TILE_THICKNESS: f32 = 0.16;

/// Half the board's width and depth, in meters.
const BOARD_HALF: f32 = BOARD_TILES as f32 * TILE_SIZE * 0.5;

/// The unit's speed toward an ordered tile, in meters per second.
const UNIT_SPEED: f32 = 2.5;

/// The sprite unit's drawn size, in meters, matching its texture cell's
/// `16x27` pixel aspect.
const SPRITE_HEIGHT: f32 = 0.9;
const SPRITE_WIDTH: f32 = SPRITE_HEIGHT * 16.0 / 27.0;

const BLOCK_SIZE: f32 = 0.6;

/// The half-extents `Ray::hit_aabb` reads the sprite unit's box by.
const SPRITE_HALF_EXTENTS: Vec3 =
    Vec3::new(SPRITE_WIDTH * 0.5, SPRITE_HEIGHT * 0.5, SPRITE_WIDTH * 0.5);

/// The half-extents `Ray::hit_aabb` reads the block unit's box by.
const BLOCK_HALF_EXTENTS: Vec3 = Vec3::splat(BLOCK_SIZE * 0.5);

/// The name `assets.texture` pulls the sheet under, once loaded.
const SPRITE_TEXTURE: &str = "walker";
const SPRITE_SOURCE: &str = "examples/assets/walker.png";
const CLICK_SOURCE: &str = "examples/assets/click.ogg";

/// The texture's grid: rows top to bottom are toward, right, away, and
/// left; four frames of a walk cycle across each row. The sprite unit
/// draws the right row always, mirrored across its own width for a left
/// order, in place of a left row of its own.
const SPRITE_COLUMNS: u32 = 4;
const SPRITE_ROWS: u32 = 4;
const SPRITE_ROW: u32 = 1;
const SPRITE_COLUMN: u32 = 0;

/// Each rock around the board: position, a `seed` for its mesh, and a
/// scale for the transform that places it.
const ROCKS: [(f32, f32, u32, f32); 5] = [
    (-BOARD_HALF - 1.2, -BOARD_HALF - 0.6, 11, 1.0),
    (-BOARD_HALF - 0.8, BOARD_HALF + 1.0, 37, 0.8),
    (BOARD_HALF + 1.4, -BOARD_HALF - 0.2, 58, 1.3),
    (BOARD_HALF + 1.0, BOARD_HALF + 1.2, 71, 0.9),
    (0.3, BOARD_HALF + 1.6, 94, 1.1),
];

/// How far a rock's corner is displaced from its position on a unit
/// cube, on each axis.
const ROCK_JITTER: f32 = 0.16;

/// Half the ground's width and depth under the board and its rock ring,
/// in meters.
const GROUND_HALF: f32 = BOARD_HALF + 3.0;

/// The ground's surface height, just under the board's own tiles, clear
/// of a z-fighting seam with them.
const GROUND_Y: f32 = -0.01;

const LIGHT_TILE: Color = Color::rgb(0.80, 0.76, 0.64);
const DARK_TILE: Color = Color::rgb(0.55, 0.50, 0.40);
/// A reachable tile's own mark, smaller than the tile itself so the
/// checker tone still shows around its edge.
const REACHABLE_MARK: Color = Color::rgb(0.20, 0.85, 0.35);
/// The fraction of a tile's own footprint the reachable mark draws at,
/// small enough that the tile's own checker tone still shows around it.
const REACHABLE_MARK_SCALE: f32 = 0.45;
/// The reachable mark's own lift over the tile's surface, clear of
/// z-fighting with it.
const REACHABLE_MARK_LIFT: f32 = 0.01;
/// The mark under the selected unit, its own color bright enough to read
/// past the sprite's own tint at a distance.
const CURRENT_MARK: Color = Color::rgb(1.0, 0.2, 0.75);
const CURRENT_MARK_SCALE: f32 = 0.85;
/// The mark under the unit whose turn it is while nothing is selected:
/// smaller and dim next to [`CURRENT_MARK`], a hint rather than a claim.
const TURN_MARK: Color = Color::rgb(0.85, 0.75, 0.15);
const TURN_MARK_SCALE: f32 = 0.5;
/// The tile a hover reads while a unit is selected: reachable, or blocked
/// by the other unit standing there.
const HOVER_REACHABLE_TILE: Color = Color::rgb(0.35, 0.75, 0.68);
const HOVER_BLOCKED_TILE: Color = Color::rgb(0.62, 0.28, 0.26);
const BLOCK_IDLE: Color = Color::rgb(0.32, 0.42, 0.58);
/// `BLOCK_IDLE`, scaled toward white to mark the block unit's own turn.
const BLOCK_TURN: Color = Color::rgb(0.42, 0.54, 0.72);
const GROUND_COLOR: Color = Color::rgb(0.15, 0.16, 0.13);
const ROCK_COLOR: Color = Color::rgb(0.42, 0.40, 0.38);
const SUN_COLOR: Color = Color::rgb(0.95, 0.92, 0.85);

/// The current unit's tint, close to white so the sprite's own texture
/// still reads under it, and the light it adds on its own, low enough
/// that the same texture still reads under its bloom too — distinct from
/// `SELECTED_TINT`, so a hover and a selection never read the same.
const HOVER_TINT: Color = Color::rgb(0.9, 1.15, 1.15);
const HOVER_GLOW: Color = Color::rgb(0.02, 0.15, 0.2);

/// The current unit's tint, close to white with more red where
/// `HOVER_TINT` raises green and blue instead, so the sprite's own
/// texture still reads under it, and the light it adds on its own,
/// scaled down the same way `HOVER_GLOW` is — distinct from `HOVER_TINT`.
const SELECTED_TINT: Color = Color::rgb(1.15, 0.95, 0.85);
const SELECTED_GLOW: Color = Color::rgb(0.22, 0.11, 0.0);

/// The unit whose turn it is shows this tint and glow before any hover or
/// selection, so it reads as the one a click selects.
const TURN_TINT: Color = Color::rgb(1.0, 1.0, 0.82);
const TURN_GLOW: Color = Color::rgb(0.08, 0.08, 0.02);

/// The fraction of the frame `set_bloom` spreads, so `HOVER_GLOW` and
/// `SELECTED_GLOW` read as light around the current unit, not only a
/// larger fill.
const BLOOM: f32 = 0.35;

/// The size a world-space prompt naming a click's effect reads at, in
/// logical points.
const PROMPT_SIZE: f32 = 15.0;
/// Height a prompt is lifted over the tile it names, clear of the tile's
/// own top corner under the diagonal view.
const PROMPT_TILE_LIFT: f32 = 0.55;
/// Height a prompt is lifted over the unit it names, past its own height.
const PROMPT_UNIT_LIFT: f32 = 0.25;
/// Margin a prompt's own backdrop keeps past its galley, in logical points.
const PROMPT_PADDING: f32 = 4.0;
/// How much dark a prompt's own backdrop puts behind its text.
const PROMPT_BACKDROP: u8 = 190;
const PROMPT_TEXT_COLOR: egui::Color32 = egui::Color32::from_gray(230);

/// Thirty steps a second, half the engine's default rate; movement stays
/// smooth through `alpha()` interpolation.
const TICK_INTERVAL: Duration = Duration::from_nanos(33_333_333);

/// Faces of a cube, each a normal with its right and up axes — the same
/// layout `mesh::Cube` builds from, shared so a rock's corners hold the
/// same eight positions between the faces that meet there.
const ROCK_FACES: [(Vec3, Vec3, Vec3); 6] = [
    (Vec3::X, Vec3::NEG_Z, Vec3::Y),
    (Vec3::NEG_X, Vec3::Z, Vec3::Y),
    (Vec3::Y, Vec3::X, Vec3::NEG_Z),
    (Vec3::NEG_Y, Vec3::X, Vec3::Z),
    (Vec3::Z, Vec3::X, Vec3::Y),
    (Vec3::NEG_Z, Vec3::NEG_X, Vec3::Y),
];

const ROCK_TRIANGLES: [u32; 6] = [0, 1, 2, 0, 2, 3];

fn main() {
    run(
        Config::new("Mirage: isometric board")
            .with_size(1280, 720)
            .with_assets([SPRITE_SOURCE, CLICK_SOURCE])
            .with_tick_interval(TICK_INTERVAL),
        Board::init,
    );
}

/// A rock built for its own `seed`; each value is its own mesh.
#[derive(Catalog, Clone, PartialEq, Eq, Hash)]
#[catalog(Self { seed: 0 })]
struct Rock {
    seed: u32,
}

impl Mesh for Rock {
    fn build(&self, _: &Assets) -> MeshData {
        build_rock(self.seed)
    }
}

/// The sprite unit: a quad windowed to the walk sheet's row facing right.
#[derive(Catalog, Clone, PartialEq, Eq, Hash)]
struct Sprite;

impl Mesh for Sprite {
    fn build(&self, assets: &Assets) -> MeshData {
        Quad.build(assets)
            .with_texture(assets.texture(SPRITE_TEXTURE).pixelated())
    }
}

// Everything else this game draws: the ground and board tiles are the
// engine's own Plane and Cube, given their color per draw; the block unit
// draws as a plain Cube too.
meshes! { enum Shape { Plane, Cube, Rock, Sprite } }

/// The board's own sky: a dim gradient, so the sun stays the scene's
/// brightest light.
#[derive(Catalog, Clone, Copy, Debug, PartialEq, Eq, Hash)]
enum Sky {
    Day,
}

impl Skyboxes for Sky {
    fn build(&self, _assets: &Assets) -> SkyboxData {
        SkyboxData::gradient(
            Color::rgb(0.55, 0.75, 0.95),
            Color::rgb(0.85, 0.90, 0.95),
            Color::rgb(0.35, 0.33, 0.30),
        )
        .lit_by(0.3)
    }
}

/// The one sound this game plays.
#[derive(Catalog, Clone, PartialEq, Eq, Hash)]
enum Sound {
    Click,
}

impl Sounds for Sound {
    fn build(&self, assets: &Assets) -> SoundData {
        match self {
            Sound::Click => assets.sound("click"),
        }
    }
}

/// The one control this game reads: a click, which selects the unit whose
/// turn it is or orders it to a tile.
#[derive(InputButtonAction, Clone, Copy)]
enum Button {
    Select,
}

impl InputButtonAction for Button {
    fn bindings(&self) -> Vec<ButtonBinding> {
        match self {
            Button::Select => vec![MouseButton::Left.into()],
        }
    }
}

struct Controls;

impl InputActions for Controls {
    type Button = Button;
    type Axis = NoInputAxes;
    type Axis2 = NoInputAxes2;
}

/// Whose turn it is: `Sprite` draws the unit with a texture, `Block` the
/// plain one.
#[derive(Clone, Copy, PartialEq, Eq)]
enum Turn {
    Sprite,
    Block,
}

impl Turn {
    fn other(self) -> Self {
        match self {
            Turn::Sprite => Turn::Block,
            Turn::Block => Turn::Sprite,
        }
    }
}

/// One unit's position on the board.
struct Unit {
    tile: (i32, i32),
    position: Vec3,
    previous: Vec3,
    target: Option<Vec3>,
    /// The order the unit last moved along `+X` under, kept while it
    /// stays still.
    facing_right: bool,
}

impl Unit {
    fn resting(tile: (i32, i32), lift: f32) -> Self {
        let position = tile_center(tile) + Vec3::Y * lift;
        Self {
            tile,
            position,
            previous: position,
            target: None,
            facing_right: true,
        }
    }

    /// Steps the unit toward its ordered position by one tick's distance;
    /// returns whether it landed on the position this tick.
    fn advance(&mut self, dt: Duration) -> bool {
        let Some(target) = self.target else {
            return false;
        };
        let to_target = target - self.position;
        let distance = to_target.length();
        let step = UNIT_SPEED * dt.as_secs_f32();
        if distance <= step {
            self.position = target;
            self.target = None;
            true
        } else {
            self.position += to_target * (step / distance);
            false
        }
    }
}

/// The vertical lift from a tile's surface to a unit's center, and the
/// half-extents `Ray::hit_aabb` reads its box by.
fn unit_geometry(turn: Turn) -> (f32, Vec3) {
    match turn {
        Turn::Sprite => (SPRITE_HEIGHT * 0.5, SPRITE_HALF_EXTENTS),
        Turn::Block => (BLOCK_SIZE * 0.5, BLOCK_HALF_EXTENTS),
    }
}

/// The world position a tile's center is at, on the board's surface
/// plane.
fn tile_center((col, row): (i32, i32)) -> Vec3 {
    let half = (BOARD_TILES - 1) as f32 * 0.5;
    Vec3::new(
        (col as f32 - half) * TILE_SIZE,
        0.0,
        (row as f32 - half) * TILE_SIZE,
    )
}

/// The tile `point` falls over, ignoring its height; `None` off the board.
fn tile_at(point: Vec3) -> Option<(i32, i32)> {
    let half = (BOARD_TILES - 1) as f32 * 0.5;
    let col = (point.x / TILE_SIZE + half + 0.5).floor() as i32;
    let row = (point.z / TILE_SIZE + half + 0.5).floor() as i32;
    ((0..BOARD_TILES).contains(&col) && (0..BOARD_TILES).contains(&row)).then_some((col, row))
}

/// Cursor target this frame: nothing, the unit whose turn it is, or a
/// board tile.
#[derive(Clone, Copy, PartialEq)]
enum Hover {
    None,
    CurrentUnit,
    Tile((i32, i32)),
}

struct Board {
    sprite: Unit,
    block: Unit,
    turn: Turn,
    selected: bool,
}

impl Board {
    fn init(ctx: &mut InitContext<'_, Board>) -> Result<Self, Error> {
        for &(_, _, seed, _) in &ROCKS {
            ctx.prepare(Rock { seed });
        }

        let (sprite_lift, _) = unit_geometry(Turn::Sprite);
        let (block_lift, _) = unit_geometry(Turn::Block);
        Ok(Self {
            sprite: Unit::resting((1, 1), sprite_lift),
            block: Unit::resting((BOARD_TILES - 2, BOARD_TILES - 2), block_lift),
            turn: Turn::Sprite,
            selected: false,
        })
    }

    fn camera() -> Camera {
        let eye = Vec3::new(9.0, 9.0, 9.0);
        Camera::new(
            View::look_at(eye, Vec3::ZERO),
            Projection::orthographic(11.0),
        )
    }

    fn current(&self) -> &Unit {
        match self.turn {
            Turn::Sprite => &self.sprite,
            Turn::Block => &self.block,
        }
    }

    fn current_mut(&mut self) -> &mut Unit {
        match self.turn {
            Turn::Sprite => &mut self.sprite,
            Turn::Block => &mut self.block,
        }
    }

    fn other(&self) -> &Unit {
        match self.turn {
            Turn::Sprite => &self.block,
            Turn::Block => &self.sprite,
        }
    }

    /// Resolves a left click: hitting the current unit's box toggles its
    /// selection; while selected, a ground hit that lands on an open tile
    /// orders a move there.
    fn handle_click(&mut self, ctx: &mut TickContext<'_, Board>) {
        if ctx.ui_wants_pointer() || !ctx.pressed(Button::Select) {
            return;
        }
        let ray = ctx
            .last_camera()
            .ray_through(ctx.pointer(), ctx.window_size());
        let (lift, half) = unit_geometry(self.turn);

        if self.current().target.is_none() {
            let center = self.current().position;
            if ray.hit_aabb(center - half, center + half).is_some() {
                self.selected = !self.selected;
                return;
            }
        }
        if !self.selected {
            return;
        }

        let Some(distance) = ray.hit_plane(ray::Plane {
            point: Vec3::ZERO,
            normal: Vec3::Y,
        }) else {
            return;
        };
        let Some(tile) = tile_at(ray.at(distance)) else {
            return;
        };
        if tile == self.current().tile || tile == self.other().tile {
            return;
        }

        let destination = tile_center(tile) + Vec3::Y * lift;
        let heading = destination.x - self.current().position.x;
        let current = self.current_mut();
        if heading.abs() > f32::EPSILON {
            current.facing_right = heading > 0.0;
        }
        current.target = Some(destination);
        self.selected = false;
        ctx.play(Sound::Click);
    }

    /// Cursor target, `None` while the UI has the pointer.
    fn hovered(&self, ctx: &FrameContext<'_, Board>) -> Hover {
        if ctx.ui_wants_pointer() {
            return Hover::None;
        }
        let ray = ctx
            .last_camera()
            .ray_through(ctx.pointer(), ctx.window_size());

        if self.current().target.is_none() {
            let (_, half) = unit_geometry(self.turn);
            let center = self.current().position;
            if ray.hit_aabb(center - half, center + half).is_some() {
                return Hover::CurrentUnit;
            }
        }
        let Some(distance) = ray.hit_plane(ray::Plane {
            point: Vec3::ZERO,
            normal: Vec3::Y,
        }) else {
            return Hover::None;
        };
        match tile_at(ray.at(distance)) {
            Some(tile) => Hover::Tile(tile),
            None => Hover::None,
        }
    }

    /// Whether a selected unit could move to `tile`: on the board, and
    /// standing under neither unit.
    fn reachable(&self, tile: (i32, i32)) -> bool {
        tile != self.current().tile && tile != self.other().tile
    }

    fn draw_board(&self, ctx: &mut FrameContext<'_, Board>, hover: Hover) {
        let scale = Vec3::new(TILE_SIZE - TILE_GAP, TILE_THICKNESS, TILE_SIZE - TILE_GAP);
        for col in 0..BOARD_TILES {
            for row in 0..BOARD_TILES {
                let tile = (col, row);
                let center = tile_center(tile) - Vec3::Y * (TILE_THICKNESS * 0.5);
                let reachable = self.selected && self.reachable(tile);
                let hovered = self.selected && hover == Hover::Tile(tile);
                let color = if hovered {
                    if reachable {
                        HOVER_REACHABLE_TILE
                    } else {
                        HOVER_BLOCKED_TILE
                    }
                } else if (col + row) % 2 == 0 {
                    LIGHT_TILE
                } else {
                    DARK_TILE
                };
                ctx.draw(
                    Cube.at(Transform::from_scale_rotation_translation(
                        scale,
                        Quat::IDENTITY,
                        center,
                    ))
                    .material(Material::lit(color)),
                );
                if reachable && !hovered {
                    self.draw_reachable_mark(ctx, tile);
                }
            }
        }
    }

    /// A mark over a reachable tile, its own tone apart from the
    /// checker's tone and the hover tone, so the checker still reads
    /// under it.
    fn draw_reachable_mark(&self, ctx: &mut FrameContext<'_, Board>, tile: (i32, i32)) {
        let center = tile_center(tile) + Vec3::Y * REACHABLE_MARK_LIFT;
        ctx.draw(
            Plane
                .at(Transform::from_scale_rotation_translation(
                    Vec3::new(
                        TILE_SIZE * REACHABLE_MARK_SCALE,
                        1.0,
                        TILE_SIZE * REACHABLE_MARK_SCALE,
                    ),
                    Quat::IDENTITY,
                    center,
                ))
                .material(Material::color(REACHABLE_MARK)),
        );
    }

    /// A mark bright enough to read past the sprite's own tint under the
    /// selected unit, or a smaller, dim one under the unit whose turn it
    /// is while nothing is selected — so the current unit reads from the
    /// ground alone.
    fn draw_current_mark(&self, ctx: &mut FrameContext<'_, Board>) {
        let (color, scale) = if self.selected {
            (CURRENT_MARK, CURRENT_MARK_SCALE)
        } else {
            (TURN_MARK, TURN_MARK_SCALE)
        };
        let center = tile_center(self.current().tile) + Vec3::Y * REACHABLE_MARK_LIFT;
        ctx.draw(
            Plane
                .at(Transform::from_scale_rotation_translation(
                    Vec3::new(TILE_SIZE * scale, 1.0, TILE_SIZE * scale),
                    Quat::IDENTITY,
                    center,
                ))
                .material(Material::color(color)),
        );
    }

    fn draw_rocks(&self, ctx: &mut FrameContext<'_, Board>) {
        for &(x, z, seed, scale) in &ROCKS {
            let angle = hash_signed(seed, 99) * core::f32::consts::PI;
            ctx.draw(
                Rock { seed }
                    .at(Transform::from_scale_rotation_translation(
                        Vec3::splat(scale),
                        Quat::from_rotation_y(angle),
                        Vec3::new(x, 0.5 * scale, z),
                    ))
                    .material(Material::lit(ROCK_COLOR)),
            );
        }
    }

    fn draw_sprite(&self, ctx: &mut FrameContext<'_, Board>, hover: Hover) {
        let position = self.sprite.previous.lerp(self.sprite.position, ctx.alpha());
        let current = self.turn == Turn::Sprite;
        let (tint, glow) = if current && self.selected {
            (SELECTED_TINT, SELECTED_GLOW)
        } else if current && hover == Hover::CurrentUnit {
            (HOVER_TINT, HOVER_GLOW)
        } else if current {
            (TURN_TINT, TURN_GLOW)
        } else {
            (Color::WHITE, Color::BLACK)
        };
        ctx.draw(
            Sprite
                .at(Transform::from_scale_rotation_translation(
                    Vec3::new(SPRITE_WIDTH, SPRITE_HEIGHT, 1.0),
                    Quat::IDENTITY,
                    position,
                ))
                .upright()
                .frame(sprite_frame(self.sprite.facing_right))
                .material(Material::lit(tint).cutout().emissive(glow)),
        );
    }

    fn draw_block(&self, ctx: &mut FrameContext<'_, Board>, hover: Hover) {
        let position = self.block.previous.lerp(self.block.position, ctx.alpha());
        let current = self.turn == Turn::Block;
        let (color, glow) = if current && self.selected {
            (SELECTED_TINT, SELECTED_GLOW)
        } else if current && hover == Hover::CurrentUnit {
            (HOVER_TINT, HOVER_GLOW)
        } else if current {
            (BLOCK_TURN, TURN_GLOW)
        } else {
            (BLOCK_IDLE, Color::BLACK)
        };
        ctx.draw(
            Cube.at(Transform::from_scale_rotation_translation(
                Vec3::splat(BLOCK_SIZE),
                Quat::IDENTITY,
                position,
            ))
            .material(Material::lit(color).emissive(glow)),
        );
    }

    fn draw_ground(&self, ctx: &mut FrameContext<'_, Board>) {
        ctx.draw(
            Plane
                .at(Transform::from_scale_rotation_translation(
                    Vec3::new(GROUND_HALF * 2.0, 1.0, GROUND_HALF * 2.0),
                    Quat::IDENTITY,
                    Vec3::new(0.0, GROUND_Y, 0.0),
                ))
                .material(Material::lit(GROUND_COLOR)),
        );
    }

    /// Whose turn it is, and what a click does next.
    fn overlay(&self, ctx: &mut FrameContext<'_, Board>) {
        ctx.ui(|ui| {
            ui.label(match self.turn {
                Turn::Sprite => "the sprite unit's turn",
                Turn::Block => "the block unit's turn",
            });
            ui.label(if self.selected {
                "click a marked tile to order the move"
            } else {
                "click the glowing unit to select it"
            });
        });
    }

    /// What a click at `hover` does, named for the player; `None` where a
    /// click has no effect.
    fn click_effect(&self, hover: Hover) -> Option<&'static str> {
        match hover {
            Hover::CurrentUnit if self.selected => Some("deselect"),
            Hover::CurrentUnit => Some("select"),
            Hover::Tile(tile) if self.selected && self.reachable(tile) => Some("move here"),
            Hover::Tile(_) if self.selected => Some("occupied"),
            _ => None,
        }
    }

    /// A prompt beside the pointer's target, naming what its click does;
    /// absent where [`Self::click_effect`] reads no effect.
    fn draw_prompt(&self, ctx: &mut FrameContext<'_, Board>, camera: Camera, hover: Hover) {
        let Some(text) = self.click_effect(hover) else {
            return;
        };
        let point = match hover {
            Hover::CurrentUnit => {
                let (lift, _) = unit_geometry(self.turn);
                self.current().position + Vec3::Y * (lift * 2.0 + PROMPT_UNIT_LIFT)
            }
            Hover::Tile(tile) => tile_center(tile) + Vec3::Y * PROMPT_TILE_LIFT,
            Hover::None => return,
        };
        let galley = ctx.text_layout(text, egui::FontId::proportional(PROMPT_SIZE));
        let window_size = ctx.window_size();
        let pixels_per_point = ctx.pixels_per_point();
        let Some(pixel) = camera.pixel_of(point, window_size) else {
            return;
        };
        let at = logical(pixel, pixels_per_point);
        ctx.ui(|ui| {
            let painter = ui.painter();
            let ink = galley.mesh_bounds;
            let pos = egui::pos2(at.x - ink.center().x, at.y - ink.center().y);
            let backdrop = egui::Rect::from_center_size(
                at,
                ink.size() + egui::Vec2::splat(PROMPT_PADDING * 2.0),
            );
            painter.rect_filled(
                backdrop,
                PROMPT_PADDING,
                egui::Color32::from_black_alpha(PROMPT_BACKDROP),
            );
            painter.galley(pos, galley, PROMPT_TEXT_COLOR);
        });
    }
}

/// The logical point egui paints the physical pixel `pixel` at.
fn logical(pixel: Vec2, pixels_per_point: f32) -> egui::Pos2 {
    let point = pixel / pixels_per_point;
    egui::pos2(point.x, point.y)
}

/// The texture window for the sprite unit's draw: the right row's cell,
/// mirrored for a left order in place of a left row of its own.
fn sprite_frame(facing_right: bool) -> Frame {
    let cell = Sheet::new(UVec2::new(SPRITE_COLUMNS, SPRITE_ROWS))
        .cell_at(UVec2::new(SPRITE_COLUMN, SPRITE_ROW));
    if facing_right { cell } else { cell.mirrored() }
}

/// A rock built from `seed`: a unit cube whose eight corners are each
/// displaced by an integer-hash of `seed` and the corner's index.
fn build_rock(seed: u32) -> MeshData {
    let corners: [Vec3; 8] = core::array::from_fn(|index| {
        let sign = Vec3::new(
            if index & 1 == 0 { -0.5 } else { 0.5 },
            if index & 2 == 0 { -0.5 } else { 0.5 },
            if index & 4 == 0 { -0.5 } else { 0.5 },
        );
        sign + corner_offset(seed, index as u32)
    });
    let corner_at = |sign: Vec3| corners[corner_index(sign)];

    let mut vertices = Vec::with_capacity(ROCK_FACES.len() * 4);
    let mut indices = Vec::with_capacity(ROCK_FACES.len() * 6);
    for (face, &(normal, right, up)) in ROCK_FACES.iter().enumerate() {
        let quad = [
            corner_at(normal - right - up),
            corner_at(normal + right - up),
            corner_at(normal + right + up),
            corner_at(normal - right + up),
        ];
        let normal = (quad[1] - quad[0]).cross(quad[3] - quad[0]).normalize();
        let uvs = [
            Vec2::new(0.0, 1.0),
            Vec2::new(1.0, 1.0),
            Vec2::new(1.0, 0.0),
            Vec2::new(0.0, 0.0),
        ];
        vertices.extend(
            quad.into_iter()
                .zip(uvs)
                .map(|(corner, uv)| Vertex::new(corner, normal, uv)),
        );
        let base = face as u32 * 4;
        indices.extend(ROCK_TRIANGLES.map(|index| base + index));
    }
    MeshData::new(vertices, indices)
}

/// The index `0..8` the corner `sign` (`x`, `y`, and `z` each `-0.5` or
/// `0.5`) is kept at.
fn corner_index(sign: Vec3) -> usize {
    let bit = |component: f32| usize::from(component > 0.0);
    bit(sign.x) | bit(sign.y) << 1 | bit(sign.z) << 2
}

/// How far the corner `index` is displaced from its position on a unit
/// cube, an integer-hash of `seed` and `index` on each axis, scaled to
/// `ROCK_JITTER`.
fn corner_offset(seed: u32, index: u32) -> Vec3 {
    Vec3::new(
        hash_signed(seed, index * 3),
        hash_signed(seed, index * 3 + 1),
        hash_signed(seed, index * 3 + 2),
    ) * ROCK_JITTER
}

/// An integer-hash of `seed` and `salt`.
fn hash(seed: u32, salt: u32) -> u32 {
    let mut x = seed ^ salt.wrapping_mul(0x9E37_79B9);
    x ^= x >> 16;
    x = x.wrapping_mul(0x7FEB_352D);
    x ^= x >> 15;
    x = x.wrapping_mul(0x846C_A68B);
    x ^= x >> 16;
    x
}

/// `hash`, scaled to `-1.0..1.0`.
fn hash_signed(seed: u32, salt: u32) -> f32 {
    hash(seed, salt) as f32 / u32::MAX as f32 * 2.0 - 1.0
}

impl Game for Board {
    type Meshes = Shape;
    type Sounds = Sound;
    type InputActions = Controls;
    type Skyboxes = Sky;
    type SurfaceStyles = NoSurfaceStyles;
    type PostEffects = NoPostEffects;

    fn tick(&mut self, ctx: &mut TickContext<'_, Board>) {
        self.sprite.previous = self.sprite.position;
        self.block.previous = self.block.position;

        self.handle_click(ctx);

        if self.current_mut().advance(ctx.dt()) {
            if let Some(tile) = tile_at(self.current().position) {
                self.current_mut().tile = tile;
            }
            self.turn = self.turn.other();
            self.selected = false;
        }
    }

    fn frame(&mut self, ctx: &mut FrameContext<'_, Board>) {
        let camera = Self::camera();
        ctx.set_camera(camera);
        ctx.set_skybox(Sky::Day);
        ctx.light(Light::directional(Vec3::new(-0.35, -1.0, -0.5), SUN_COLOR).shadow());
        ctx.set_bloom(BLOOM);

        let hover = self.hovered(ctx);
        self.draw_ground(ctx);
        self.draw_board(ctx, hover);
        self.draw_current_mark(ctx);
        self.draw_rocks(ctx);
        self.draw_sprite(ctx, hover);
        self.draw_block(ctx, hover);
        self.draw_prompt(ctx, camera, hover);

        self.overlay(ctx);
    }
}