// 3D world renderer: isometric (orthographic) camera with free rotation and tilt,
// chunked tile meshes with irregular (noise-displaced) walls, a lit material with
// flickering point lights (torches, core, portal, gate), billboard sprites and 3D effects.

use crate::game::*;
use crate::gfx::*;
use crate::map::*;
use macroquad::miniquad::{BlendFactor, BlendState, BlendValue, Comparison, Equation, PipelineParams, UniformDesc, UniformType};
use macroquad::models::{Mesh, Vertex};
use macroquad::prelude::*;

pub const WALL_H: f32 = 0.95;
const CHUNK: i32 = 16;
const NCH: i32 = MW as i32 / CHUNK;
pub const MAX_LIGHTS: usize = 24;
const ATLAS_W: f32 = 256.0;
const ATLAS_H: f32 = 80.0;
const WALL_SUB: usize = 3; // subdivisions per wall face edge
const DISP_AMP: f32 = 0.11; // wall surface irregularity

// ------------------------------------------------------------------ camera

pub struct Cam {
    pub tx: f32, // look-at target on the ground (world x)
    pub tz: f32, // look-at target on the ground (world z = map y)
    pub yaw: f32,
    pub pitch: f32,
    pub zoom: f32, // visible world height in tiles (orthographic)
}

impl Cam {
    pub fn new(tx: f32, tz: f32) -> Cam {
        Cam { tx, tz, yaw: 0.785, pitch: 0.6155, zoom: 18.0 }
    }

    pub fn eye_dir(&self) -> Vec3 {
        vec3(self.pitch.cos() * self.yaw.sin(), self.pitch.sin(), self.pitch.cos() * self.yaw.cos())
    }

    fn target(&self) -> Vec3 {
        vec3(self.tx, 0.0, self.tz)
    }

    pub fn camera(&self) -> Camera3D {
        Camera3D {
            position: self.target() + self.eye_dir() * 60.0,
            target: self.target(),
            up: Vec3::Y,
            fovy: self.zoom,
            projection: Projection::Orthographics,
            z_near: 1.0,
            z_far: 200.0,
            ..Default::default()
        }
    }

    // forward (into the screen), right, up
    fn basis(&self) -> (Vec3, Vec3, Vec3) {
        let f = -self.eye_dir();
        let r = f.cross(Vec3::Y).normalize();
        let u = r.cross(f);
        (f, r, u)
    }

    // Ground-plane directions for panning: screen-right and screen-up
    pub fn ground_axes(&self) -> (Vec2, Vec2) {
        let (f, r, _) = self.basis();
        (vec2(r.x, r.z).normalize(), vec2(f.x, f.z).normalize())
    }

    pub fn ray(&self, sx: f32, sy: f32) -> (Vec3, Vec3) {
        let (f, r, u) = self.basis();
        let half_h = self.zoom * 0.5;
        let half_w = half_h * screen_width() / screen_height();
        let nx = sx / screen_width() * 2.0 - 1.0;
        let ny = 1.0 - sy / screen_height() * 2.0;
        let pos = self.target() + self.eye_dir() * 60.0;
        (pos + r * (nx * half_w) + u * (ny * half_h), f)
    }

    pub fn ground_point(&self, sx: f32, sy: f32) -> Vec2 {
        let (o, d) = self.ray(sx, sy);
        let t = -o.y / d.y.min(-0.001);
        let p = o + d * t;
        vec2(p.x, p.z)
    }

    pub fn matrix(&self) -> Mat4 {
        self.camera().matrix()
    }

    pub fn project(m: &Mat4, p: Vec3) -> Vec2 {
        let c = *m * p.extend(1.0);
        let n = c.truncate() / c.w;
        vec2((n.x + 1.0) * 0.5 * screen_width(), (1.0 - n.y) * 0.5 * screen_height())
    }

    // Tile under the mouse: wall tops/sides first, otherwise the floor
    pub fn pick_tile(&self, map: &Map, sx: f32, sy: f32) -> Option<(i32, i32, Vec3)> {
        let (o, d) = self.ray(sx, sy);
        if d.y >= -0.001 {
            return None;
        }
        let top = WALL_H + 0.3;
        let t0 = (o.y - top) / -d.y;
        let t1 = o.y / -d.y;
        let mut t = t0;
        while t <= t1 {
            let p = o + d * t;
            let (x, z) = (p.x.floor() as i32, p.z.floor() as i32);
            if inb(x, z) && map.t[idx(x, z)].solid() && p.y <= WALL_H {
                return Some((x, z, p));
            }
            t += 0.03;
        }
        let p = o + d * t1;
        let (x, z) = (p.x.floor() as i32, p.z.floor() as i32);
        if inb(x, z) {
            Some((x, z, p))
        } else {
            None
        }
    }
}

// ------------------------------------------------------------------ noise

fn h3(x: i32, y: i32, z: i32, s: u32) -> f32 {
    let mut h = (x as u32).wrapping_mul(374761393) ^ (y as u32).wrapping_mul(668265263) ^ (z as u32).wrapping_mul(2147483647) ^ s.wrapping_mul(2246822519);
    h = (h ^ (h >> 13)).wrapping_mul(1274126177);
    h ^= h >> 16;
    (h & 0xffff) as f32 / 32767.5 - 1.0
}

fn vnoise(p: Vec3, s: u32) -> f32 {
    let (x0, y0, z0) = (p.x.floor(), p.y.floor(), p.z.floor());
    let (fx, fy, fz) = (p.x - x0, p.y - y0, p.z - z0);
    let sm = |t: f32| t * t * (3.0 - 2.0 * t);
    let (ux, uy, uz) = (sm(fx), sm(fy), sm(fz));
    let (xi, yi, zi) = (x0 as i32, y0 as i32, z0 as i32);
    let mut acc = 0.0;
    for dz in 0..2 {
        for dy in 0..2 {
            for dx in 0..2 {
                let w = (if dx == 1 { ux } else { 1.0 - ux }) * (if dy == 1 { uy } else { 1.0 - uy }) * (if dz == 1 { uz } else { 1.0 - uz });
                acc += w * h3(xi + dx, yi + dy, zi + dz, s);
            }
        }
    }
    acc
}

// Displacement depends only on the world position -> seamless between neighbours
fn displace(p: Vec3) -> Vec3 {
    let q = p * 2.3;
    let r = p * 5.1;
    let n = |s: u32| vnoise(q, s) + 0.35 * vnoise(r, s + 10);
    let dy = if p.y < 0.01 { 0.0 } else { n(2) * 0.6 };
    vec3(n(1), dy, n(3)) * DISP_AMP
}

// ------------------------------------------------------------------ lit material

const VERTEX: &str = r#"#version 100
attribute vec3 position;
attribute vec2 texcoord;
attribute vec4 color0;
attribute vec4 normal;

varying lowp vec2 uv;
varying lowp vec4 color;
varying highp vec3 wpos;
varying mediump vec3 wnorm;

uniform mat4 Model;
uniform mat4 Projection;

void main() {
    vec4 w = Model * vec4(position, 1.0);
    wpos = w.xyz;
    wnorm = normal.xyz;
    color = color0 / 255.0;
    uv = texcoord;
    gl_Position = Projection * w;
}
"#;

const FRAGMENT: &str = r#"#version 100
precision mediump float;
varying lowp vec2 uv;
varying lowp vec4 color;
varying highp vec3 wpos;
varying mediump vec3 wnorm;

uniform sampler2D Texture;
uniform vec4 LightPos[24];
uniform vec4 LightCol[24];
uniform float LightCount;

void main() {
    vec4 tex = texture2D(Texture, uv);
    if (tex.a < 0.5) discard;
    vec3 n = normalize(wnorm);
    vec3 light = color.rgb;
    for (int i = 0; i < 24; i++) {
        if (float(i) >= LightCount) break;
        vec3 d = LightPos[i].xyz - wpos;
        float dist = length(d);
        float att = clamp(1.0 - dist / LightPos[i].w, 0.0, 1.0);
        att *= att;
        float ndl = max(dot(n, d / max(dist, 0.001)), 0.0) * 0.8 + 0.2;
        light += LightCol[i].rgb * LightCol[i].a * att * ndl;
    }
    gl_FragColor = vec4(tex.rgb * min(light, vec3(1.7)), 1.0);
}
"#;

fn lit_material() -> Material {
    load_material(
        ShaderSource::Glsl { vertex: VERTEX, fragment: FRAGMENT },
        MaterialParams {
            pipeline_params: PipelineParams { depth_test: Comparison::LessOrEqual, depth_write: true, ..Default::default() },
            uniforms: vec![
                UniformDesc::new("LightPos", UniformType::Float4).array(MAX_LIGHTS),
                UniformDesc::new("LightCol", UniformType::Float4).array(MAX_LIGHTS),
                UniformDesc::new("LightCount", UniformType::Float1),
            ],
            textures: vec![],
        },
    )
    .expect("lit material")
}

// Unlit, alpha-blended material for glows, shadows and effects
fn glow_material() -> Material {
    const V: &str = r#"#version 100
attribute vec3 position;
attribute vec2 texcoord;
attribute vec4 color0;
attribute vec4 normal;
varying lowp vec2 uv;
varying lowp vec4 color;
uniform mat4 Model;
uniform mat4 Projection;
void main() {
    gl_Position = Projection * Model * vec4(position, 1.0);
    color = color0 / 255.0;
    uv = texcoord;
}
"#;
    const F: &str = r#"#version 100
precision mediump float;
varying lowp vec4 color;
varying lowp vec2 uv;
uniform sampler2D Texture;
void main() {
    gl_FragColor = color * texture2D(Texture, uv);
}
"#;
    load_material(
        ShaderSource::Glsl { vertex: V, fragment: F },
        MaterialParams {
            pipeline_params: PipelineParams {
                depth_test: Comparison::LessOrEqual,
                depth_write: false,
                color_blend: Some(BlendState::new(Equation::Add, BlendFactor::Value(BlendValue::SourceAlpha), BlendFactor::OneMinusValue(BlendValue::SourceAlpha))),
                ..Default::default()
            },
            uniforms: vec![],
            textures: vec![],
        },
    )
    .expect("glow material")
}

// ------------------------------------------------------------------ mesh building

struct MB {
    v: Vec<Vertex>,
    i: Vec<u16>,
}

fn col(c: Vec3, a: f32) -> [u8; 4] {
    [(c.x.clamp(0.0, 1.0) * 255.0) as u8, (c.y.clamp(0.0, 1.0) * 255.0) as u8, (c.z.clamp(0.0, 1.0) * 255.0) as u8, (a.clamp(0.0, 1.0) * 255.0) as u8]
}

fn cell_uv(id: u32) -> (Vec2, Vec2) {
    let r = Gfx::cell(id);
    let inset = 0.3;
    (vec2((r.x + inset) / ATLAS_W, (r.y + inset) / ATLAS_H), vec2((r.x + r.w - inset) / ATLAS_W, (r.y + r.h - inset) / ATLAS_H))
}

impl MB {
    fn new() -> MB {
        MB { v: Vec::new(), i: Vec::new() }
    }
    fn vert(&mut self, p: Vec3, uv: Vec2, c: [u8; 4], n: Vec3) -> u16 {
        self.v.push(Vertex { position: p, uv, color: c, normal: n.extend(0.0) });
        (self.v.len() - 1) as u16
    }
    fn quad(&mut self, p: [Vec3; 4], uv: [Vec2; 4], c: [[u8; 4]; 4], n: [Vec3; 4]) {
        let b = self.v.len() as u16;
        for k in 0..4 {
            self.vert(p[k], uv[k], c[k], n[k]);
        }
        self.i.extend_from_slice(&[b, b + 1, b + 2, b, b + 2, b + 3]);
    }
    // Two crossed vertical quads (decor, billboards in the mesh)
    fn cross(&mut self, cx: f32, cz: f32, w: f32, h: f32, cell: u32, c: [u8; 4]) {
        let (a, b) = cell_uv(cell);
        let n = Vec3::Y;
        for k in 0..2 {
            let (dx, dz) = if k == 0 { (w * 0.5, 0.0) } else { (0.0, w * 0.5) };
            self.quad(
                [vec3(cx - dx, h, cz - dz), vec3(cx + dx, h, cz + dz), vec3(cx + dx, 0.0, cz + dz), vec3(cx - dx, 0.0, cz - dz)],
                [vec2(a.x, a.y), vec2(b.x, a.y), vec2(b.x, b.y), vec2(a.x, b.y)],
                [c; 4],
                [n; 4],
            );
        }
    }
    fn into_mesh(self, tex: &Texture2D) -> Option<Mesh> {
        if self.v.is_empty() {
            None
        } else {
            Some(Mesh { vertices: self.v, indices: self.i, texture: Some(tex.clone()) })
        }
    }
}

// Ambient light field: own territory is lit, foreign areas are dim
fn ambient_field(map: &Map) -> Vec<f32> {
    let mut f = vec![0.0f32; N];
    for (i, t) in map.t.iter().enumerate() {
        f[i] = match (t.solid(), t.owner) {
            (false, Owner::Player) => 1.0,
            (false, Owner::Hero) => 0.6,
            _ => 0.0,
        };
        if t.kind == Kind::Core {
            f[i] = 1.0;
        }
    }
    for _ in 0..2 {
        let src = f.clone();
        for y in 0..MH as i32 {
            for x in 0..MW as i32 {
                let mut s = 0.0;
                let mut n = 0.0;
                for dy in -1..=1 {
                    for dx in -1..=1 {
                        if inb(x + dx, y + dy) {
                            s += src[idx(x + dx, y + dy)];
                            n += 1.0;
                        }
                    }
                }
                f[idx(x, y)] = (s / n).max(src[idx(x, y)] * 0.85);
            }
        }
    }
    f
}

fn amb_at(f: &[f32], x: f32, z: f32) -> f32 {
    let gx = (x - 0.5).clamp(0.0, MW as f32 - 1.001);
    let gz = (z - 0.5).clamp(0.0, MH as f32 - 1.001);
    let (x0, z0) = (gx.floor() as i32, gz.floor() as i32);
    let (fx, fz) = (gx - x0 as f32, gz - z0 as f32);
    let g = |x: i32, z: i32| f[idx(x.min(MW as i32 - 1), z.min(MH as i32 - 1))];
    let a = g(x0, z0) * (1.0 - fx) + g(x0 + 1, z0) * fx;
    let b = g(x0, z0 + 1) * (1.0 - fx) + g(x0 + 1, z0 + 1) * fx;
    0.15 + 0.45 * (a * (1.0 - fz) + b * fz)
}

const LIGHT_DIR: Vec3 = Vec3::new(0.45, 0.8, 0.35);

fn solid_at(map: &Map, x: i32, z: i32) -> bool {
    map.get(x, z).map_or(true, |t| t.solid())
}

fn build_chunk(map: &Map, amb: &[f32], cx: i32, cz: i32, gold_fill: f32, atlas: &Texture2D) -> (Option<Mesh>, Option<Mesh>) {
    let mut mb = MB::new();
    let mut ov = MB::new();
    let ld = LIGHT_DIR.normalize();
    for z in cz * CHUNK..(cz + 1) * CHUNK {
        for x in cx * CHUNK..(cx + 1) * CHUNK {
            let t = map.t[idx(x, z)];
            let tex = Gfx::tile_tex(t.kind, t.owner == Owner::Player, t.owner == Owner::Hero, t.var);
            let (ua, ub) = cell_uv(tex);
            let (xf, zf) = (x as f32, z as f32);
            if !t.solid() {
                // floor with corner ambient occlusion
                let corners = [(0, 0), (1, 0), (1, 1), (0, 1)];
                let mut c = [[0u8; 4]; 4];
                for (k, &(ox, oz)) in corners.iter().enumerate() {
                    let (vx, vz) = (x + ox, z + oz);
                    let solid_n = [(vx - 1, vz - 1), (vx, vz - 1), (vx - 1, vz), (vx, vz)].iter().filter(|&&(a, b)| solid_at(map, a, b)).count();
                    let ao = 1.0 - 0.17 * solid_n as f32;
                    let a = amb_at(amb, vx as f32, vz as f32) * ao;
                    c[k] = col(Vec3::splat(a), 1.0);
                }
                mb.quad(
                    [vec3(xf, 0.0, zf), vec3(xf + 1.0, 0.0, zf), vec3(xf + 1.0, 0.0, zf + 1.0), vec3(xf, 0.0, zf + 1.0)],
                    [vec2(ua.x, ua.y), vec2(ub.x, ua.y), vec2(ub.x, ub.y), vec2(ua.x, ub.y)],
                    c,
                    [Vec3::Y; 4],
                );
                // room decor
                let dc = col(Vec3::splat(amb_at(amb, xf + 0.5, zf + 0.5)), 1.0);
                match t.kind {
                    Kind::Lair => {
                        let (a, b) = cell_uv(D_BED);
                        mb.quad(
                            [vec3(xf + 0.05, 0.02, zf + 0.05), vec3(xf + 0.95, 0.02, zf + 0.05), vec3(xf + 0.95, 0.02, zf + 0.95), vec3(xf + 0.05, 0.02, zf + 0.95)],
                            [vec2(a.x, a.y), vec2(b.x, a.y), vec2(b.x, b.y), vec2(a.x, b.y)],
                            [dc; 4],
                            [Vec3::Y; 4],
                        );
                    }
                    Kind::Farm => {
                        let pos = [(0.3, 0.3), (0.7, 0.4), (0.45, 0.72)];
                        for (k, &(ox, oz)) in pos.iter().enumerate() {
                            if t.food >= k as f32 + 1.0 {
                                mb.cross(xf + ox, zf + oz, 0.45, 0.45, D_MUSHROOM, dc);
                            }
                        }
                    }
                    Kind::Training if (x + z) % 2 == 0 => mb.cross(xf + 0.5, zf + 0.5, 0.7, 0.75, D_DUMMY, dc),
                    Kind::Library if z % 2 == 0 => mb.cross(xf + 0.5, zf + 0.5, 0.9, 0.85, D_SHELF, dc),
                    Kind::Treasury if gold_fill > 0.02 => {
                        let s = 0.35 + 0.55 * gold_fill;
                        mb.cross(xf + 0.5, zf + 0.5, s, s * 0.8, D_COINS, dc);
                    }
                    _ => {}
                }
                continue;
            }

            // ---- wall: dark floor below (fills gaps), bumpy top, irregular open sides
            let dark = col(Vec3::splat(0.04), 1.0);
            mb.quad(
                [vec3(xf, -0.01, zf), vec3(xf + 1.0, -0.01, zf), vec3(xf + 1.0, -0.01, zf + 1.0), vec3(xf, -0.01, zf + 1.0)],
                [ua, ua, ua, ua],
                [dark; 4],
                [Vec3::Y; 4],
            );
            let n = WALL_SUB;
            let top_amb = amb_at(amb, xf + 0.5, zf + 0.5) * 0.95 + 0.1;
            build_grid(
                &mut mb,
                |u, v| vec3(xf + u, WALL_H, zf + v),
                Vec3::Y,
                n,
                (ua, ub),
                |_p, nrm| Vec3::splat(top_amb * (0.75 + 0.25 * nrm.dot(ld).max(0.0))),
            );
            if t.marked {
                let (a, b) = cell_uv(T_MARK);
                let y = WALL_H + 0.12;
                ov.quad(
                    [vec3(xf, y, zf), vec3(xf + 1.0, y, zf), vec3(xf + 1.0, y, zf + 1.0), vec3(xf, y, zf + 1.0)],
                    [vec2(a.x, a.y), vec2(b.x, a.y), vec2(b.x, b.y), vec2(a.x, b.y)],
                    [[255, 255, 255, 230]; 4],
                    [Vec3::Y; 4],
                );
            }
            for (d, &(dx, dz)) in DIR4.iter().enumerate() {
                if solid_at(map, x + dx, z + dz) {
                    continue;
                }
                let side_amb = amb_at(amb, xf + 0.5 + dx as f32 * 0.9, zf + 0.5 + dz as f32 * 0.9);
                // edge from a to b as seen from outside, u along the edge, v = height
                let (a, b) = match d {
                    0 => (vec3(xf + 1.0, 0.0, zf), vec3(xf, 0.0, zf)),             // north
                    1 => (vec3(xf + 1.0, 0.0, zf + 1.0), vec3(xf + 1.0, 0.0, zf)), // east
                    2 => (vec3(xf, 0.0, zf + 1.0), vec3(xf + 1.0, 0.0, zf + 1.0)), // south
                    _ => (vec3(xf, 0.0, zf), vec3(xf, 0.0, zf + 1.0)),             // west
                };
                let out = vec3(dx as f32, 0.0, dz as f32);
                build_grid(
                    &mut mb,
                    |u, v| a + (b - a) * u + vec3(0.0, WALL_H * (1.0 - v), 0.0),
                    out,
                    n,
                    (ua, ub),
                    |p, nrm| {
                        let h = (p.y / WALL_H).clamp(0.0, 1.0);
                        Vec3::splat(side_amb * (0.5 + 0.5 * nrm.dot(ld).max(0.0)) * (0.55 + 0.45 * h))
                    },
                );
            }
        }
    }
    (mb.into_mesh(atlas), ov.into_mesh(atlas))
}

// Subdivided, displaced face. pos(u, v) gives the undisplaced point (u, v in 0..1).
fn build_grid(mb: &mut MB, pos: impl Fn(f32, f32) -> Vec3, face_n: Vec3, n: usize, uv: (Vec2, Vec2), shade: impl Fn(Vec3, Vec3) -> Vec3) {
    let m = n + 1;
    let mut p = Vec::with_capacity(m * m);
    for j in 0..m {
        for i in 0..m {
            let base = pos(i as f32 / n as f32, j as f32 / n as f32);
            p.push(base + displace(base));
        }
    }
    let at = |i: usize, j: usize| p[j * m + i];
    let base_idx = mb.v.len() as u16;
    for j in 0..m {
        for i in 0..m {
            let du = at((i + 1).min(n), j) - at(i.saturating_sub(1), j);
            let dv = at(i, (j + 1).min(n)) - at(i, j.saturating_sub(1));
            let mut nrm = du.cross(dv).normalize_or_zero();
            if nrm.dot(face_n) < 0.0 {
                nrm = -nrm;
            }
            if nrm == Vec3::ZERO {
                nrm = face_n;
            }
            let u = i as f32 / n as f32;
            let v = j as f32 / n as f32;
            let tuv = vec2(uv.0.x + (uv.1.x - uv.0.x) * u, uv.0.y + (uv.1.y - uv.0.y) * v);
            let c = shade(at(i, j), nrm);
            mb.vert(at(i, j), tuv, col(c, 1.0), nrm);
        }
    }
    for j in 0..n {
        for i in 0..n {
            let a = base_idx + (j * m + i) as u16;
            let b = a + 1;
            let c = a + m as u16 + 1;
            let d = a + m as u16;
            mb.i.extend_from_slice(&[a, b, c, a, c, d]);
        }
    }
}

// ------------------------------------------------------------------ renderer

struct Chunk {
    sig: u64,
    mesh: Option<Mesh>,
    overlay: Option<Mesh>,
}

pub struct Overlay {
    pub hover: Option<(i32, i32)>,
    pub rect: Option<(i32, i32, i32, i32)>,
    pub color: Color,
    pub radius: Option<(f32, f32, f32)>,
    pub high: bool, // outline on wall tops (digging)
}

pub struct R3d {
    lit: Material,
    glow: Material,
    chunks: Vec<Chunk>,
}

fn rgba(u: u32) -> Color {
    Color::from_rgba(u as u8, (u >> 8) as u8, (u >> 16) as u8, (u >> 24) as u8)
}

fn chunk_sig(map: &Map, cx: i32, cz: i32, fill_bucket: u8) -> u64 {
    let mut h: u64 = 1469598103934665603;
    for z in cz * CHUNK - 3..(cz + 1) * CHUNK + 3 {
        for x in cx * CHUNK - 3..(cx + 1) * CHUNK + 3 {
            let v = match map.get(x, z) {
                Some(t) => {
                    let extra = match t.kind {
                        Kind::Farm => t.food as u64,
                        Kind::Treasury => fill_bucket as u64,
                        _ => 0,
                    };
                    (t.kind as u64) | (t.owner as u64) << 4 | (t.marked as u64) << 6 | extra << 8
                }
                None => 0xff,
            };
            h = (h ^ v).wrapping_mul(1099511628211);
        }
    }
    h
}

impl R3d {
    pub fn new() -> R3d {
        let chunks = (0..NCH * NCH).map(|_| Chunk { sig: 0, mesh: None, overlay: None }).collect();
        R3d { lit: lit_material(), glow: glow_material(), chunks }
    }

    fn update_chunks(&mut self, g: &Game, gfx: &Gfx) {
        let fill = (g.gold / g.gold_cap()).clamp(0.0, 1.0);
        let bucket = (fill * 6.0) as u8;
        let mut amb: Option<Vec<f32>> = None;
        for cz in 0..NCH {
            for cx in 0..NCH {
                let sig = chunk_sig(&g.map, cx, cz, bucket);
                let ch = &mut self.chunks[(cz * NCH + cx) as usize];
                if ch.sig != sig {
                    let a = amb.get_or_insert_with(|| ambient_field(&g.map));
                    let (m, o) = build_chunk(&g.map, a, cx, cz, bucket as f32 / 6.0, &gfx.atlas);
                    ch.mesh = m;
                    ch.overlay = o;
                    ch.sig = sig;
                }
            }
        }
    }

    fn chunk_visible(m: &Mat4, cx: i32, cz: i32) -> bool {
        let (x0, z0) = ((cx * CHUNK) as f32, (cz * CHUNK) as f32);
        let (x1, z1) = (x0 + CHUNK as f32, z0 + CHUNK as f32);
        let (mut minx, mut miny, mut maxx, mut maxy) = (f32::MAX, f32::MAX, f32::MIN, f32::MIN);
        for &x in &[x0, x1] {
            for &z in &[z0, z1] {
                for &y in &[0.0, WALL_H + 0.5] {
                    let s = Cam::project(m, vec3(x, y, z));
                    minx = minx.min(s.x);
                    maxx = maxx.max(s.x);
                    miny = miny.min(s.y);
                    maxy = maxy.max(s.y);
                }
            }
        }
        maxx >= 0.0 && minx <= screen_width() && maxy >= 0.0 && miny <= screen_height()
    }

    fn lights(&self, g: &Game, cam: &Cam, t: f32) -> (Vec<Vec4>, Vec<Vec4>) {
        let mut l: Vec<(f32, Vec4, Vec4)> = Vec::new();
        let center = vec2(cam.tx, cam.tz);
        let mut push = |p: Vec3, radius: f32, c: Vec3, intensity: f32, prio: f32| {
            let d = vec2(p.x, p.z).distance(center) - prio;
            l.push((d, p.extend(radius), c.extend(intensity)));
        };
        for (k, tr) in g.torches.iter().enumerate() {
            let (x, z) = tr.pos();
            let fl = 0.85 + 0.1 * (t * 9.0 + k as f32 * 1.7).sin() + 0.05 * (t * 23.0 + k as f32).sin();
            push(vec3(x, 0.75, z), 4.5, vec3(1.0, 0.62, 0.28), 0.9 * fl, 0.0);
        }
        let (cx, cy) = g.map.core;
        let hp = (g.core_hp / CORE_HP).clamp(0.0, 1.0);
        push(vec3(cx as f32 + 1.5, 1.2, cy as f32 + 1.5), 7.0, vec3(1.0, 0.25, 0.2), 1.1 + 0.2 * (t * 3.0).sin() * (1.5 - hp), 100.0);
        let (px, py) = g.map.portal;
        let owned = g.portal_owned();
        push(vec3(px as f32 + 1.5, 0.8, py as f32 + 1.5), 6.0, vec3(0.7, 0.3, 1.0), if owned { 1.0 } else { 0.35 }, 50.0);
        if g.gate_hp > 0.0 {
            let (gx, gz) = g.gate_center();
            push(vec3(gx, 1.2, gz), 7.0, vec3(0.75, 0.85, 1.0), 1.0, 50.0);
        }
        for f in &g.fx {
            if f.kind == 1 {
                push(vec3(f.x, 2.0, f.y), 8.0, vec3(1.0, 1.0, 0.85), 3.0 * (1.0 - f.t / f.max), 200.0);
            }
        }
        l.sort_by(|a, b| a.0.partial_cmp(&b.0).unwrap_or(std::cmp::Ordering::Equal));
        l.truncate(MAX_LIGHTS);
        let mut pos = vec![Vec4::ZERO; MAX_LIGHTS];
        let mut colr = vec![Vec4::ZERO; MAX_LIGHTS];
        for (k, (_, p, c)) in l.iter().enumerate() {
            pos[k] = *p;
            colr[k] = *c;
        }
        let n = l.len() as f32;
        pos.push(Vec4::new(n, 0.0, 0.0, 0.0));
        (pos, colr)
    }

    // Entity under the mouse (screen-space test against the projected sprite)
    pub fn pick_ent(&self, g: &Game, cam: &Cam, sx: f32, sy: f32, player_only: bool) -> Option<usize> {
        let m = cam.matrix();
        let px_per_tile = screen_height() / cam.zoom;
        let mut best = None;
        let mut bd = (px_per_tile * 0.4).max(10.0);
        for (j, e) in g.ents.iter().enumerate() {
            if !e.alive || e.held || (player_only && e.hero) {
                continue;
            }
            let s = Cam::project(&m, vec3(e.x, 0.3, e.y));
            let d = s.distance(vec2(sx, sy));
            if d < bd {
                bd = d;
                best = Some(j);
            }
        }
        best
    }

    pub fn draw(&mut self, g: &Game, gfx: &Gfx, cam: &Cam, time: f64, ov: &Overlay) {
        let t = time as f32;
        self.update_chunks(g, gfx);
        let m = cam.matrix();
        EYE.with(|e| e.set(cam.eye_dir()));
        set_camera(&cam.camera());

        // ---- lit geometry
        let (lp, lc) = self.lights(g, cam, t);
        let count = lp[MAX_LIGHTS].x;
        self.lit.set_uniform_array("LightPos", &lp[..MAX_LIGHTS]);
        self.lit.set_uniform_array("LightCol", &lc[..]);
        self.lit.set_uniform("LightCount", count);
        gl_use_material(&self.lit);
        for cz in 0..NCH {
            for cx in 0..NCH {
                if !Self::chunk_visible(&m, cx, cz) {
                    continue;
                }
                if let Some(mesh) = &self.chunks[(cz * NCH + cx) as usize].mesh {
                    draw_mesh(mesh);
                }
            }
        }
        // sprites as billboards
        if let Some(mesh) = self.billboards(g, gfx, cam, t) {
            draw_mesh(&mesh);
        }
        // solid unlit objects (default material, depth tested)
        gl_use_default_material();
        for tr in &g.torches {
            let (x, z) = tr.pos();
            draw_cube(vec3(x, 0.55, z), vec3(0.07, 0.3, 0.07), None, Color::from_rgba(70, 45, 28, 255));
        }
        draw_landmarks_solid(g, t);

        // ---- unlit glow / overlays
        gl_use_material(&self.glow);
        for c in &self.chunks {
            if let Some(o) = &c.overlay {
                draw_mesh(o);
            }
        }
        for (k, tr) in g.torches.iter().enumerate() {
            let (x, z) = tr.pos();
            let fl = 1.0 + 0.15 * (t * 11.0 + k as f32 * 2.3).sin();
            draw_sphere(vec3(x, 0.78, z), 0.09 * fl, None, Color::new(1.0, 0.55, 0.15, 0.9));
            draw_sphere(vec3(x, 0.8, z), 0.05 * fl, None, Color::new(1.0, 0.95, 0.6, 1.0));
        }
        draw_shadows(g);
        draw_landmarks_glow(g, t);
        if let Some(f) = g.flag {
            draw_flag(f, t);
        }
        for f in &g.fx {
            draw_fx(f, t);
        }
        draw_overlay(&g.map, ov);
        gl_use_default_material();
        set_default_camera();

        // ---- 2D overlay: health bars, sleep marks, levels, gate HP
        self.draw_2d(g, gfx, cam, &m, t);
    }

    fn billboards(&self, g: &Game, gfx: &Gfx, cam: &Cam, t: f32) -> Option<Mesh> {
        let (_, r, _) = cam.basis();
        let toward = cam.eye_dir();
        let amb = |x: f32, z: f32| {
            let (ix, iz) = (x as i32, z as i32);
            let own = g.map.get(ix, iz).map_or(false, |t| t.owner == Owner::Player);
            if own {
                0.75
            } else {
                0.5
            }
        };
        let mut mb = MB::new();
        let sw = 120.0;
        let sh = 24.0;
        for e in &g.ents {
            if !e.alive || e.held {
                continue;
            }
            let big = matches!(e.kind, EK::Ogre | EK::Paladin);
            let w = if big { 0.8 } else { 0.62 };
            let h = w;
            let sleeping = matches!(e.job, Job::Sleep(_)) && !e.moving;
            let bob = if e.moving { (e.anim * 12.0).sin().abs() * 0.06 } else { 0.0 };
            let rot = if e.working && !sleeping { (t * 14.0 + e.anim).sin() * 0.15 } else { 0.0 };
            let white = e.flash > 0.07;
            let src = Gfx::sprite_rect(e.kind, white);
            let (mut u0, v0) = (src.x / sw, src.y / sh);
            let (mut u1, v1) = ((src.x + src.w) / sw, (src.y + src.h) / sh);
            if e.face < 0.0 {
                std::mem::swap(&mut u0, &mut u1);
            }
            let a = amb(e.x, e.y) * if sleeping { 0.6 } else { 1.0 };
            let c = if white { [255, 255, 255, 255] } else { col(Vec3::splat(a), 1.0) };
            let base = vec3(e.x, bob, e.y);
            let (sr, cr) = rot.sin_cos();
            let corner = |dx: f32, dy: f32| {
                let x = dx * cr - dy * sr;
                let y = dx * sr + dy * cr;
                base + r * x + Vec3::Y * y
            };
            mb.quad(
                [corner(-w * 0.5, h), corner(w * 0.5, h), corner(w * 0.5, 0.0), corner(-w * 0.5, 0.0)],
                [vec2(u0, v0), vec2(u1, v0), vec2(u1, v1), vec2(u0, v1)],
                [c; 4],
                [toward; 4],
            );
        }
        if mb.v.is_empty() {
            None
        } else {
            Some(Mesh { vertices: mb.v, indices: mb.i, texture: Some(gfx.sprites.clone()) })
        }
    }

    fn draw_2d(&self, g: &Game, gfx: &Gfx, cam: &Cam, m: &Mat4, t: f32) {
        let px_per_tile = screen_height() / cam.zoom;
        for e in &g.ents {
            if !e.alive || e.held {
                continue;
            }
            let big = matches!(e.kind, EK::Ogre | EK::Paladin);
            let head = Cam::project(m, vec3(e.x, if big { 0.9 } else { 0.72 }, e.y));
            let w = (px_per_tile * 0.6).clamp(12.0, 40.0);
            if e.hp < e.max_hp || e.hero {
                let f = (e.hp / e.max_hp).clamp(0.0, 1.0);
                let c = if e.hero {
                    Color::from_rgba(120, 180, 255, 255)
                } else if f > 0.5 {
                    Color::from_rgba(90, 220, 90, 255)
                } else if f > 0.25 {
                    Color::from_rgba(240, 200, 60, 255)
                } else {
                    Color::from_rgba(230, 60, 50, 255)
                };
                draw_rectangle(head.x - w * 0.5 - 1.0, head.y - 1.0, w + 2.0, 4.0, Color::new(0.0, 0.0, 0.0, 0.8));
                draw_rectangle(head.x - w * 0.5, head.y, w * f, 2.0, c);
            }
            if e.guard {
                gfx.glyph(0x0F, head.x - 3.0, head.y - 11.0, 1.0, Color::from_rgba(255, 220, 90, 255));
            }
            if e.level > 1 && px_per_tile >= 24.0 {
                gfx.text_sh(&e.level.to_string(), head.x - w * 0.5 - 8.0, head.y - 3.0, 1.0, Color::from_rgba(255, 220, 90, 255));
            }
            if matches!(e.job, Job::Sleep(_)) && !e.moving {
                let k = (t * 1.5 + e.anim) % 1.0;
                gfx.glyph(b'z', head.x + w * 0.3, head.y - 6.0 - k * 14.0, 2.0, Color::new(0.8, 0.85, 1.0, 1.0 - k));
            }
            if e.carry > 0 {
                let p = Cam::project(m, vec3(e.x, 0.35, e.y));
                draw_circle(p.x + w * 0.35, p.y, 3.0, Color::from_rgba(250, 210, 60, 255));
            }
        }
        if g.gate_hp > 0.0 && g.gate_hp < GATE_HP {
            let (gx, gz) = g.gate_center();
            let p = Cam::project(m, vec3(gx, 2.4, gz));
            let w = 100.0;
            draw_rectangle(p.x - w * 0.5 - 1.0, p.y - 1.0, w + 2.0, 8.0, BLACK);
            draw_rectangle(p.x - w * 0.5, p.y, w * g.gate_hp / GATE_HP, 6.0, Color::from_rgba(120, 180, 255, 255));
        }
    }
}

// ------------------------------------------------------------------ landmarks, fx, overlay

// Camera direction for camera-facing line quads (set once per frame)
thread_local! {
    static EYE: std::cell::Cell<Vec3> = std::cell::Cell::new(Vec3::Y);
}

// Thick 3D line as a camera-facing quad (GL lines don't work with custom materials)
fn line3(a: Vec3, b: Vec3, w: f32, color: Color) {
    let eye = EYE.with(|e| e.get());
    let side = (b - a).cross(eye).normalize_or_zero() * (w * 0.5);
    let c = [(color.r * 255.0) as u8, (color.g * 255.0) as u8, (color.b * 255.0) as u8, (color.a * 255.0) as u8];
    let v = |p: Vec3| Vertex { position: p, uv: Vec2::ZERO, color: c, normal: Vec4::Y };
    draw_mesh(&Mesh { vertices: vec![v(a - side), v(a + side), v(b + side), v(b - side)], indices: vec![0, 1, 2, 0, 2, 3], texture: None });
}

fn disc(c: Vec3, r: f32, color: Color, seg: usize) {
    let mut v = Vec::with_capacity(seg + 1);
    let cc = [(color.r * 255.0) as u8, (color.g * 255.0) as u8, (color.b * 255.0) as u8, (color.a * 255.0) as u8];
    v.push(Vertex { position: c, uv: Vec2::ZERO, color: cc, normal: Vec4::Y });
    for k in 0..seg {
        let a = k as f32 / seg as f32 * std::f32::consts::TAU;
        v.push(Vertex { position: c + vec3(a.cos() * r, 0.0, a.sin() * r), uv: Vec2::ZERO, color: cc, normal: Vec4::Y });
    }
    let mut i = Vec::with_capacity(seg * 3);
    for k in 0..seg as u16 {
        i.extend_from_slice(&[0, 1 + k, 1 + (k + 1) % seg as u16]);
    }
    draw_mesh(&Mesh { vertices: v, indices: i, texture: None });
}

fn ring(c: Vec3, r: f32, color: Color) {
    let seg = 32;
    for k in 0..seg {
        let a0 = k as f32 / seg as f32 * std::f32::consts::TAU;
        let a1 = (k + 1) as f32 / seg as f32 * std::f32::consts::TAU;
        line3(c + vec3(a0.cos() * r, 0.0, a0.sin() * r), c + vec3(a1.cos() * r, 0.0, a1.sin() * r), 0.035, color);
    }
}

fn draw_landmarks_solid(g: &Game, t: f32) {
    // core pedestal
    let (cx, cy) = g.map.core;
    let c = vec3(cx as f32 + 1.5, 0.0, cy as f32 + 1.5);
    draw_cube(c + vec3(0.0, 0.15, 0.0), vec3(2.4, 0.3, 2.4), None, Color::from_rgba(45, 16, 20, 255));
    draw_cube(c + vec3(0.0, 0.4, 0.0), vec3(1.4, 0.2, 1.4), None, Color::from_rgba(70, 26, 30, 255));
    // gate pillars
    let (gx, gz) = g.gate_center();
    if g.gate_hp > 0.0 {
        let stone = Color::from_rgba(150, 155, 172, 255);
        draw_cube(vec3(gx - 1.1, 1.0, gz), vec3(0.45, 2.0, 0.45), None, stone);
        draw_cube(vec3(gx + 1.1, 1.0, gz), vec3(0.45, 2.0, 0.45), None, stone);
        draw_cube(vec3(gx, 2.1, gz), vec3(2.8, 0.35, 0.55), None, stone);
        draw_cube(vec3(gx, 2.35, gz), vec3(0.5, 0.2, 0.5), None, Color::from_rgba(230, 200, 100, 255));
    } else {
        for k in 0..10 {
            let a = k as f32 * 1.7;
            draw_cube(vec3(gx + a.cos() * 1.0, 0.15, gz + a.sin() * 0.8), vec3(0.35, 0.3, 0.3), None, Color::from_rgba(150, 150, 160, 255));
        }
    }
    let _ = t;
}

fn draw_landmarks_glow(g: &Game, t: f32) {
    // soul core
    let (cx, cy) = g.map.core;
    let hp = (g.core_hp / CORE_HP).clamp(0.0, 1.0);
    let pulse = 1.0 + (t * (2.0 + (1.0 - hp) * 6.0)).sin() * 0.06;
    let c = vec3(cx as f32 + 1.5, 1.15 + (t * 1.3).sin() * 0.06, cy as f32 + 1.5);
    draw_sphere(c, 0.75 * pulse, None, Color::new(0.4 + 0.5 * hp, 0.05, 0.08, 1.0));
    draw_sphere(c, 0.95 * pulse, None, Color::new(1.0, 0.2, 0.15, 0.25));
    draw_sphere(c + vec3(-0.2, 0.25, 0.2), 0.18, None, Color::new(1.0, 0.85, 0.7, 0.8));
    // portal
    let (px, py) = g.map.portal;
    let owned = g.portal_owned();
    let pc = vec3(px as f32 + 1.5, 0.03, py as f32 + 1.5);
    let arm = if owned { Color::new(0.8, 0.4, 1.0, 1.0) } else { Color::new(0.45, 0.42, 0.5, 1.0) };
    disc(pc, 1.35, if owned { Color::new(0.2, 0.05, 0.3, 0.9) } else { Color::new(0.1, 0.1, 0.12, 0.9) }, 32);
    let speed = if owned { 1.6 } else { 0.3 };
    for a in 0..3 {
        for k in 0..18 {
            let f = k as f32 / 18.0;
            let ang = t * speed + a as f32 * 2.094 + f * 4.0;
            let r = f * 1.3;
            let p = pc + vec3(ang.cos() * r, 0.1 + (1.0 - f) * 0.5, ang.sin() * r);
            draw_cube(p, Vec3::splat(0.05 + 0.06 * (1.0 - f)), None, Color::new(arm.r, arm.g, arm.b, 0.4 + 0.6 * (1.0 - f)));
        }
    }
    // gate light
    if g.gate_hp > 0.0 {
        let (gx, gz) = g.gate_center();
        let gc = vec3(gx, 1.0, gz);
        draw_sphere(gc, 0.45 + 0.04 * (t * 3.0).sin(), None, Color::new(0.95, 0.97, 1.0, 0.95));
        draw_sphere(gc, 0.8, None, Color::new(0.7, 0.85, 1.0, 0.2));
        for k in 0..8 {
            let a = t * 0.6 + k as f32 * 0.785;
            line3(gc, gc + vec3(a.cos() * 1.0, a.sin() * 0.9, 0.0), 0.05, Color::new(0.85, 0.92, 1.0, 0.6));
        }
    }
}

fn draw_shadows(g: &Game) {
    for e in &g.ents {
        if !e.alive || e.held {
            continue;
        }
        let r = if matches!(e.kind, EK::Ogre | EK::Paladin) { 0.32 } else { 0.24 };
        disc(vec3(e.x, 0.012, e.y), r, Color::new(0.0, 0.0, 0.0, 0.4), 12);
        let rc = if e.guard {
            Color::new(1.0, 0.85, 0.3, 0.9)
        } else if e.hero {
            Color::new(0.5, 0.8, 1.0, 0.8)
        } else {
            Color::new(0.95, 0.3, 0.35, 0.7)
        };
        ring(vec3(e.x, 0.02, e.y), r + 0.03, rc);
    }
}

fn draw_flag(f: usize, t: f32) {
    let (fx, fz) = xy(f);
    let base = vec3(fx as f32 + 0.4, 0.0, fz as f32 + 0.5);
    draw_cube(base + vec3(0.0, 0.7, 0.0), vec3(0.05, 1.4, 0.05), None, Color::from_rgba(200, 200, 200, 255));
    let wave = (t * 6.0).sin() * 0.08;
    let p1 = base + vec3(0.0, 1.38, 0.0);
    let p2 = base + vec3(0.6, 1.22 + wave, 0.1);
    let p3 = base + vec3(0.0, 1.0, 0.0);
    let c = [210, 40, 40, 255];
    let v = vec![
        Vertex { position: p1, uv: Vec2::ZERO, color: c, normal: Vec4::Y },
        Vertex { position: p2, uv: Vec2::ZERO, color: c, normal: Vec4::Y },
        Vertex { position: p3, uv: Vec2::ZERO, color: c, normal: Vec4::Y },
    ];
    draw_mesh(&Mesh { vertices: v, indices: vec![0, 1, 2], texture: None });
}

fn draw_fx(f: &Fx, t: f32) {
    let p = (f.t / f.max).clamp(0.0, 1.0);
    let c = rgba(f.col);
    let a = |alpha: f32| Color::new(c.r, c.g, c.b, alpha);
    let at = vec3(f.x, 0.4, f.y);
    match f.kind {
        0 => {
            let from = vec3(f.x, 0.45, f.y);
            let to = vec3(f.x2, 0.45, f.y2);
            let head = from.lerp(to, p);
            let tail = from.lerp(to, (p - 0.35).max(0.0));
            line3(tail, head, 0.06, a(0.8));
            draw_sphere(head, 0.08, None, c);
        }
        1 => {
            let mut prev = vec3(f.x, 7.0, f.y);
            for k in 1..=9 {
                let y = 7.0 - 7.0 * k as f32 / 9.0;
                let j = if k == 9 { 0.0 } else { (t * 50.0 + k as f32 * 13.7).sin() * 0.5 };
                let next = vec3(f.x + j, y, f.y + j * 0.5);
                line3(prev, next, 0.12, Color::new(1.0, 1.0, 0.85, 1.0 - p));
                prev = next;
            }
            disc(vec3(f.x, 0.05, f.y), 1.6 * (0.5 + p), Color::new(1.0, 1.0, 0.7, 0.35 * (1.0 - p)), 24);
        }
        2 => {
            let r = 0.1 + 0.3 * p;
            for k in 0..6 {
                let ang = k as f32 * 1.047;
                line3(at, at + vec3(ang.cos() * r, (k as f32 - 2.5) * 0.06, ang.sin() * r), 0.04, a(1.0 - p));
            }
        }
        3 => draw_sphere(vec3(f.x, 0.3, f.y), 0.2 + 0.5 * p, None, a(0.4 * (1.0 - p))),
        4 => {
            for k in 0..3 {
                let o = vec3((k as f32 - 1.0) * 0.2, 0.3 + p * 0.9 + k as f32 * 0.1, 0.0);
                draw_cube(at + o, vec3(0.16, 0.05, 0.05), None, a(1.0 - p));
                draw_cube(at + o, vec3(0.05, 0.16, 0.05), None, a(1.0 - p));
            }
        }
        5 => {
            for k in 0..4 {
                let ang = k as f32 * 1.9 + f.x * 3.0;
                let o = vec3(ang.cos() * 0.3 * p, 0.2 + p * 0.7, ang.sin() * 0.3 * p);
                draw_cube(at + o, Vec3::splat(0.06), None, a(1.0 - p));
            }
        }
        6 => {
            for k in 0..4 {
                let ang = k as f32 * 1.7 + f.y * 5.0;
                let o = vec3(ang.cos() * 0.35 * p, 0.6 - p * 0.5, ang.sin() * 0.35 * p);
                draw_cube(at + o, Vec3::splat(0.06), None, a(1.0 - p));
            }
        }
        7 => ring(vec3(f.x, 0.05, f.y), 0.3 + 1.2 * p, a(1.0 - p)),
        8 => disc(vec3(f.x, 0.03, f.y), 0.55, a(0.45 * (1.0 - p)), 4),
        _ => {}
    }
}

fn outline(x0: f32, z0: f32, x1: f32, z1: f32, y: f32, c: Color) {
    let p = [vec3(x0, y, z0), vec3(x1, y, z0), vec3(x1, y, z1), vec3(x0, y, z1)];
    for k in 0..4 {
        line3(p[k], p[(k + 1) % 4], 0.06, c);
    }
}

fn draw_overlay(map: &Map, ov: &Overlay) {
    let y_of = |x: i32, z: i32| if ov.high && map.get(x, z).map_or(false, |t| t.solid()) { WALL_H + 0.14 } else { 0.04 };
    if let Some((x0, z0, x1, z1)) = ov.rect {
        let (ax, bx) = (x0.min(x1), x0.max(x1));
        let (az, bz) = (z0.min(z1), z0.max(z1));
        let y = if ov.high { WALL_H + 0.14 } else { 0.04 };
        outline(ax as f32, az as f32, bx as f32 + 1.0, bz as f32 + 1.0, y, ov.color);
    } else if let Some((x, z)) = ov.hover {
        outline(x as f32, z as f32, x as f32 + 1.0, z as f32 + 1.0, y_of(x, z), ov.color);
    }
    if let Some((x, z, r)) = ov.radius {
        ring(vec3(x, 0.05, z), r, ov.color);
    }
}

// Minimap colour of a tile
pub fn minimap_color(tile: &Tile) -> [u8; 4] {
    match tile.kind {
        Kind::Rock => [40, 40, 48, 255],
        Kind::Earth => [86, 60, 40, 255],
        Kind::Gold => [220, 180, 50, 255],
        Kind::Floor => match tile.owner {
            Owner::Player => [140, 60, 80, 255],
            Owner::Hero => [170, 175, 190, 255],
            Owner::None => [70, 64, 60, 255],
        },
        Kind::Treasury => [200, 160, 60, 255],
        Kind::Lair => [150, 110, 60, 255],
        Kind::Farm => [70, 140, 60, 255],
        Kind::Training => [160, 100, 60, 255],
        Kind::Library => [150, 40, 60, 255],
        Kind::Core => [255, 60, 60, 255],
        Kind::Portal => [190, 90, 240, 255],
        Kind::Gate => [230, 230, 255, 255],
    }
}