870 lines
31 KiB
Rust
870 lines
31 KiB
Rust
// Map, tiles, generation and path finding.
|
|
//
|
|
// The map size is chosen per game (64..256 tiles per side). Only one map is active at a time;
|
|
// its dimensions are kept in a thread-local so the many small helpers (idx, xy, inb) stay simple.
|
|
// Map::generate and loading a savegame (Map::activate) set them.
|
|
|
|
use serde::{Deserialize, Deserializer, Serialize, Serializer};
|
|
use std::cell::Cell;
|
|
use std::cmp::Reverse;
|
|
use std::collections::BinaryHeap;
|
|
|
|
pub const MIN_SIZE: usize = 64;
|
|
pub const MAX_SIZE: usize = 256;
|
|
|
|
thread_local! {
|
|
static DIMS: Cell<(usize, usize)> = Cell::new((64, 64));
|
|
}
|
|
|
|
fn set_dims(w: usize, h: usize) {
|
|
DIMS.with(|d| d.set((w, h)));
|
|
}
|
|
#[inline]
|
|
pub fn mw() -> usize {
|
|
DIMS.with(|d| d.get().0)
|
|
}
|
|
#[inline]
|
|
pub fn mh() -> usize {
|
|
DIMS.with(|d| d.get().1)
|
|
}
|
|
#[inline]
|
|
pub fn n() -> usize {
|
|
mw() * mh()
|
|
}
|
|
|
|
#[derive(Clone, Copy, PartialEq, Eq, Debug, Serialize, Deserialize)]
|
|
pub enum Kind {
|
|
Rock,
|
|
Earth,
|
|
Gold,
|
|
Floor,
|
|
Treasury,
|
|
Lair,
|
|
Farm,
|
|
Training,
|
|
Library,
|
|
Core,
|
|
Portal,
|
|
Gate,
|
|
Torture,
|
|
Tower, // floor tile occupied by a defence tower (not walkable)
|
|
Temple,
|
|
Water, // underground river: not walkable, needs a bridge
|
|
Lava, // lava river: not walkable, burns what falls in
|
|
Bridge, // wooden bridge over water (walkable)
|
|
LavaBridge, // stone bridge over lava (walkable)
|
|
Shard, // floor with a shard of the soul core (campaign)
|
|
Silver, // silver vein: common, little value
|
|
Ruby, // ruby vein: rare, valuable
|
|
Diamond, // diamond vein: very rare, very valuable
|
|
Aerie, // room for flying creatures (their beds)
|
|
Steel, // steel wall: hardly anyone gets through
|
|
ManaSpring, // crystal spring: once claimed, more mana and a higher mana maximum
|
|
RuneChest, // dwarven chest with the plans of a rune forge tower (claim it: one free build)
|
|
Forge, // room: creatures manufacture traps and doors
|
|
Door, // floor with an installed door (res bit 0: locked)
|
|
Prison, // room: prisoners wait in cells
|
|
Graveyard, // room: the fallen are buried, some rise again
|
|
GuardPost, // room: creatures hold the position
|
|
Arena, // room: sparring
|
|
Altar, // room: sacrifices
|
|
}
|
|
|
|
// options for the map generator (campaign missions)
|
|
#[derive(Clone, Debug)]
|
|
pub struct GenOpts {
|
|
pub portals: Option<usize>, // None: one per 64 x 64 tiles
|
|
pub treasures: Option<usize>, // knight treasure caves; None: none (free play has dwarf caves instead)
|
|
pub gate: bool, // hero gate at the far side
|
|
pub core_y: Option<i32>, // row of the core (None: about the middle)
|
|
}
|
|
|
|
impl Default for GenOpts {
|
|
fn default() -> GenOpts {
|
|
GenOpts { portals: None, treasures: None, gate: true, core_y: None }
|
|
}
|
|
}
|
|
|
|
// An underground river across the map
|
|
#[derive(Clone, Debug)]
|
|
pub struct River {
|
|
pub lava: bool,
|
|
pub vertical: bool, // runs from top to bottom (else from left to right)
|
|
pub pos: f32, // position across the map (0..1)
|
|
pub width: i32,
|
|
pub bridges: u32, // fixed bridges of the knights
|
|
}
|
|
|
|
// order matters for the packed savegame codec: only append new kinds
|
|
const KINDS: [Kind; 34] = [
|
|
Kind::Rock,
|
|
Kind::Earth,
|
|
Kind::Gold,
|
|
Kind::Floor,
|
|
Kind::Treasury,
|
|
Kind::Lair,
|
|
Kind::Farm,
|
|
Kind::Training,
|
|
Kind::Library,
|
|
Kind::Core,
|
|
Kind::Portal,
|
|
Kind::Gate,
|
|
Kind::Torture,
|
|
Kind::Tower,
|
|
Kind::Temple,
|
|
Kind::Water,
|
|
Kind::Lava,
|
|
Kind::Bridge,
|
|
Kind::LavaBridge,
|
|
Kind::Shard,
|
|
Kind::Silver,
|
|
Kind::Ruby,
|
|
Kind::Diamond,
|
|
Kind::Aerie,
|
|
Kind::Steel,
|
|
Kind::ManaSpring,
|
|
Kind::RuneChest,
|
|
Kind::Forge,
|
|
Kind::Door,
|
|
Kind::Prison,
|
|
Kind::Graveyard,
|
|
Kind::GuardPost,
|
|
Kind::Arena,
|
|
Kind::Altar,
|
|
];
|
|
|
|
// treasures (veins, treasury content, imp loads): 0 gold, 1 silver, 2 ruby, 3 diamond
|
|
pub const RES_GOLD: u8 = 0;
|
|
// value taken per pick strike for each treasure
|
|
pub const RES_STRIKE: [i32; 4] = [25, 20, 40, 60];
|
|
|
|
#[derive(Clone, Copy, PartialEq, Eq, Debug, Serialize, Deserialize)]
|
|
pub enum Owner {
|
|
None,
|
|
Player,
|
|
Hero,
|
|
Rival1, // AI dungeon masters (free play, campaign)
|
|
Rival2,
|
|
Rival3, // the fourth master side: a third rival, or a human master in a match
|
|
}
|
|
|
|
const OWNERS: [Owner; 6] = [Owner::None, Owner::Player, Owner::Hero, Owner::Rival1, Owner::Rival2, Owner::Rival3];
|
|
|
|
impl Owner {
|
|
pub fn of_side(side: u8) -> Owner {
|
|
match side {
|
|
0 => Owner::Player,
|
|
1 => Owner::Hero,
|
|
2 => Owner::Rival1,
|
|
3 => Owner::Rival2,
|
|
4 => Owner::Rival3,
|
|
_ => Owner::None,
|
|
}
|
|
}
|
|
|
|
// the masters of a match: the four sides a dungeon master can play (1 is the heroes' side)
|
|
#[allow(dead_code)] // the sides of a match; the lobby (step C/D) uses them
|
|
pub const MASTER_SIDES: [u8; 4] = [0, 2, 3, 4];
|
|
}
|
|
|
|
// Short serde names (only used by version 1 savegames, newer ones use the packed codec)
|
|
#[derive(Clone, Copy, PartialEq, Serialize, Deserialize)]
|
|
pub struct Tile {
|
|
#[serde(rename = "k")]
|
|
pub kind: Kind,
|
|
#[serde(rename = "o")]
|
|
pub owner: Owner,
|
|
#[serde(rename = "h")]
|
|
pub hp: f32, // dig resistance
|
|
#[serde(rename = "g")]
|
|
pub gold: i32, // gold left (gold vein)
|
|
#[serde(rename = "m")]
|
|
pub marked: bool, // marked for digging
|
|
#[serde(rename = "r")]
|
|
pub reserved: u32, // entity id + 1 working on this tile
|
|
#[serde(rename = "f")]
|
|
pub food: f32, // mushrooms in the mushroom garden
|
|
#[serde(rename = "b")]
|
|
pub bed: u32, // entity id + 1 sleeping here
|
|
#[serde(rename = "v")]
|
|
pub var: u8, // texture variant
|
|
#[serde(rename = "rf", default)]
|
|
pub reinforced: bool, // wall reinforced by imps
|
|
#[serde(rename = "rs", default)]
|
|
pub res: u8, // treasury: kind of treasure stored here (see RES_GOLD)
|
|
}
|
|
|
|
impl Tile {
|
|
pub fn new(kind: Kind) -> Tile {
|
|
Tile { kind, owner: Owner::None, hp: 0.0, gold: 0, marked: false, reserved: 0, food: 0.0, bed: 0, var: 0, reinforced: false, res: 0 }
|
|
}
|
|
pub fn solid(&self) -> bool {
|
|
matches!(self.kind, Kind::Rock | Kind::Earth | Kind::Gold | Kind::Silver | Kind::Ruby | Kind::Diamond | Kind::Steel)
|
|
}
|
|
pub fn diggable(&self) -> bool {
|
|
matches!(self.kind, Kind::Earth | Kind::Gold | Kind::Silver | Kind::Ruby | Kind::Diamond | Kind::Steel)
|
|
}
|
|
// the treasure of a vein (None for everything else)
|
|
pub fn vein(&self) -> Option<u8> {
|
|
match self.kind {
|
|
Kind::Gold => Some(0),
|
|
Kind::Silver => Some(1),
|
|
Kind::Ruby => Some(2),
|
|
Kind::Diamond => Some(3),
|
|
_ => None,
|
|
}
|
|
}
|
|
pub fn walkable(&self) -> bool {
|
|
matches!(
|
|
self.kind,
|
|
Kind::Floor
|
|
| Kind::Treasury
|
|
| Kind::Lair
|
|
| Kind::Farm
|
|
| Kind::Training
|
|
| Kind::Library
|
|
| Kind::Portal
|
|
| Kind::Gate
|
|
| Kind::Torture
|
|
| Kind::Temple
|
|
| Kind::Bridge
|
|
| Kind::LavaBridge
|
|
| Kind::Shard
|
|
| Kind::Aerie
|
|
| Kind::ManaSpring
|
|
| Kind::RuneChest
|
|
| Kind::Forge
|
|
| Kind::Door
|
|
| Kind::Prison
|
|
| Kind::Graveyard
|
|
| Kind::GuardPost
|
|
| Kind::Arena
|
|
| Kind::Altar
|
|
)
|
|
}
|
|
// river tiles (open, but nobody can walk there)
|
|
pub fn liquid(&self) -> bool {
|
|
matches!(self.kind, Kind::Water | Kind::Lava)
|
|
}
|
|
pub fn bridge(&self) -> bool {
|
|
matches!(self.kind, Kind::Bridge | Kind::LavaBridge)
|
|
}
|
|
// the river below a bridge or river tile
|
|
pub fn river(&self) -> Option<Kind> {
|
|
match self.kind {
|
|
Kind::Water | Kind::Bridge => Some(Kind::Water),
|
|
Kind::Lava | Kind::LavaBridge => Some(Kind::Lava),
|
|
_ => None,
|
|
}
|
|
}
|
|
}
|
|
|
|
pub fn idx(x: i32, y: i32) -> usize {
|
|
y as usize * mw() + x as usize
|
|
}
|
|
pub fn xy(i: usize) -> (i32, i32) {
|
|
let w = mw();
|
|
((i % w) as i32, (i / w) as i32)
|
|
}
|
|
pub fn inb(x: i32, y: i32) -> bool {
|
|
x >= 0 && y >= 0 && (x as usize) < mw() && (y as usize) < mh()
|
|
}
|
|
|
|
pub const DIR4: [(i32, i32); 4] = [(0, -1), (1, 0), (0, 1), (-1, 0)];
|
|
pub const DIR8: [(i32, i32); 8] = [(0, -1), (1, 0), (0, 1), (-1, 0), (1, -1), (1, 1), (-1, 1), (-1, -1)];
|
|
|
|
#[derive(Serialize, Deserialize)]
|
|
pub struct Rng(pub u32);
|
|
impl Rng {
|
|
pub fn next(&mut self) -> u32 {
|
|
let mut x = self.0;
|
|
x ^= x << 13;
|
|
x ^= x >> 17;
|
|
x ^= x << 5;
|
|
self.0 = x;
|
|
x
|
|
}
|
|
pub fn f(&mut self) -> f32 {
|
|
(self.next() >> 8) as f32 / (1u32 << 24) as f32
|
|
}
|
|
pub fn range(&mut self, a: i32, b: i32) -> i32 {
|
|
if b <= a {
|
|
return a;
|
|
}
|
|
a + (self.next() % (b - a + 1) as u32) as i32
|
|
}
|
|
}
|
|
|
|
#[derive(Serialize, Deserialize)]
|
|
pub struct Map {
|
|
#[serde(default = "default_size")]
|
|
pub w: usize,
|
|
#[serde(default = "default_size")]
|
|
pub h: usize,
|
|
#[serde(serialize_with = "tiles_ser", deserialize_with = "tiles_de")]
|
|
pub t: Vec<Tile>,
|
|
pub core: (i32, i32), // top-left corner of the core (3x3)
|
|
#[serde(default)]
|
|
pub portals: Vec<(i32, i32)>, // top-left corners of the portals (3x3)
|
|
#[serde(default, rename = "portal", skip_serializing)]
|
|
legacy_portal: Option<(i32, i32)>, // version 1 savegames had a single portal
|
|
pub gate: (i32, i32),
|
|
#[serde(default)]
|
|
pub treasures: Vec<(i32, i32)>, // centres of the treasure caves
|
|
#[serde(default, with = "crate::fog::bits")]
|
|
pub explored: Vec<bool>, // fog of war: tiles the dungeon knows (empty: no fog)
|
|
#[serde(skip)]
|
|
pub visible: Vec<bool>, // fog of war: tiles in sight right now
|
|
}
|
|
|
|
fn default_size() -> usize {
|
|
64
|
|
}
|
|
|
|
impl Map {
|
|
// Make this map's dimensions the active ones (after loading a savegame)
|
|
pub fn activate(&mut self) {
|
|
set_dims(self.w, self.h);
|
|
if self.portals.is_empty() {
|
|
if let Some(p) = self.legacy_portal.take() {
|
|
self.portals.push(p);
|
|
}
|
|
}
|
|
}
|
|
|
|
pub fn get(&self, x: i32, y: i32) -> Option<&Tile> {
|
|
if inb(x, y) {
|
|
Some(&self.t[idx(x, y)])
|
|
} else {
|
|
None
|
|
}
|
|
}
|
|
|
|
pub fn walk(&self, x: i32, y: i32) -> bool {
|
|
inb(x, y) && self.t[idx(x, y)].walkable()
|
|
}
|
|
|
|
// Index of the portal containing tile (x, y)
|
|
pub fn portal_at(&self, x: i32, y: i32) -> Option<usize> {
|
|
self.portals.iter().position(|&(px, py)| x >= px && x < px + 3 && y >= py && y < py + 3)
|
|
}
|
|
|
|
pub fn portal_owned(&self, k: usize) -> bool {
|
|
let (px, py) = self.portals[k];
|
|
self.t[idx(px, py)].owner == Owner::Player
|
|
}
|
|
|
|
pub fn generate(seed: u32, w: usize, h: usize) -> Map {
|
|
Map::generate_with(seed, w, h, &GenOpts::default())
|
|
}
|
|
|
|
pub fn generate_with(seed: u32, w: usize, h: usize, opts: &GenOpts) -> Map {
|
|
let w = w.clamp(MIN_SIZE, MAX_SIZE);
|
|
let h = h.clamp(MIN_SIZE, MAX_SIZE);
|
|
set_dims(w, h);
|
|
let mut s = seed;
|
|
loop {
|
|
let m = Map::try_generate(s, w, h, opts);
|
|
// make sure heroes can reach the core
|
|
if !opts.gate || m.hero_path_to_core(idx(m.gate.0 + 1, m.gate.1 + 1)).is_some() {
|
|
return m;
|
|
}
|
|
s = s.wrapping_mul(747796405).wrapping_add(2891336453) | 1;
|
|
}
|
|
}
|
|
|
|
fn try_generate(seed: u32, w: usize, h: usize, opts: &GenOpts) -> Map {
|
|
let (wi, hi) = (w as i32, h as i32);
|
|
let mut rng = Rng(seed | 1);
|
|
for _ in 0..10 {
|
|
rng.next();
|
|
}
|
|
// content scales with the area; one portal per 64x64 tiles
|
|
let area = (w * h) as f32 / 4096.0;
|
|
let scale = |n: f32| (n * area).round() as i32;
|
|
let n_portals = opts.portals.unwrap_or((area.round() as usize).max(1));
|
|
let n_treasures = opts.treasures.unwrap_or(0);
|
|
|
|
let mut t = vec![Tile::new(Kind::Earth); w * h];
|
|
for (i, tile) in t.iter_mut().enumerate() {
|
|
let (x, y) = ((i % w) as i32, (i / w) as i32);
|
|
tile.var = (rng.next() % 4) as u8;
|
|
tile.hp = 6.0;
|
|
if x < 2 || y < 2 || x >= wi - 2 || y >= hi - 2 {
|
|
tile.kind = Kind::Rock;
|
|
}
|
|
}
|
|
let inner = |x: i32, y: i32| x >= 2 && y >= 2 && x < wi - 2 && y < hi - 2;
|
|
let core = (11, opts.core_y.unwrap_or(hi / 2 + rng.range(-5, 3)));
|
|
let gate = (wi - 13 + rng.range(-2, 2), rng.range(10, hi - 14));
|
|
|
|
// places features far apart: best of several random candidates
|
|
let mut taken: Vec<(i32, i32)> = vec![(core.0 + 1, core.1 + 1), (gate.0 + 1, gate.1 + 1)];
|
|
let place = |rng: &mut Rng, taken: &mut Vec<(i32, i32)>, margin: i32| -> (i32, i32) {
|
|
let mut best = (margin, margin);
|
|
let mut bd = -1;
|
|
for _ in 0..40 {
|
|
let p = (rng.range(margin, wi - margin - 3), rng.range(margin, hi - margin - 3));
|
|
let d = taken.iter().map(|q| (p.0 - q.0).pow(2) + (p.1 - q.1).pow(2)).min().unwrap_or(0);
|
|
if d > bd {
|
|
bd = d;
|
|
best = p;
|
|
}
|
|
}
|
|
taken.push(best);
|
|
best
|
|
};
|
|
// the first portal is close to the start
|
|
let first = (core.0 + rng.range(13, 19), (core.1 + if rng.f() < 0.5 { rng.range(-14, -10) } else { rng.range(10, 14) }).clamp(5, hi - 9));
|
|
taken.push(first);
|
|
let mut portals = if n_portals > 0 { vec![first] } else { Vec::new() };
|
|
for _ in 1..n_portals {
|
|
portals.push(place(&mut rng, &mut taken, 6));
|
|
}
|
|
let mut treasures = Vec::new();
|
|
for _ in 0..n_treasures {
|
|
let p = place(&mut rng, &mut taken, 7);
|
|
treasures.push((p.0 + 1, p.1 + 1));
|
|
}
|
|
|
|
let blob = |t: &mut Vec<Tile>, rng: &mut Rng, cx: i32, cy: i32, r: i32, k: Kind, gold: (i32, i32)| {
|
|
for y in cy - r..=cy + r {
|
|
for x in cx - r..=cx + r {
|
|
if !inner(x, y) {
|
|
continue;
|
|
}
|
|
let d = ((x - cx) * (x - cx) + (y - cy) * (y - cy)) as f32;
|
|
if d <= (r as f32 + 0.5).powi(2) - rng.f() * r as f32 {
|
|
let tl = &mut t[y as usize * w + x as usize];
|
|
tl.kind = k;
|
|
if tl.vein().is_some() {
|
|
tl.gold = rng.range(gold.0, gold.1);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
for _ in 0..scale(22.0) {
|
|
let (cx, cy) = (rng.range(4, wi - 5), rng.range(4, hi - 5));
|
|
let r = rng.range(1, 3);
|
|
blob(&mut t, &mut rng, cx, cy, r, Kind::Rock, (0, 0));
|
|
}
|
|
for _ in 0..scale(16.0) {
|
|
let (cx, cy) = (rng.range(4, wi - 5), rng.range(4, hi - 5));
|
|
let r = rng.range(1, 2);
|
|
blob(&mut t, &mut rng, cx, cy, r, Kind::Gold, (250, 550));
|
|
}
|
|
// more treasures: silver is common, rubies are rare, diamonds very rare and far away
|
|
for _ in 0..scale(7.0) {
|
|
let (cx, cy) = (rng.range(4, wi - 5), rng.range(4, hi - 5));
|
|
let r = rng.range(1, 2);
|
|
blob(&mut t, &mut rng, cx, cy, r, Kind::Silver, (200, 400));
|
|
}
|
|
for _ in 0..scale(3.0) {
|
|
let (cx, cy) = (rng.range(wi / 4, wi - 5), rng.range(4, hi - 5));
|
|
blob(&mut t, &mut rng, cx, cy, 1, Kind::Ruby, (500, 800));
|
|
}
|
|
for _ in 0..scale(1.2).max(1) {
|
|
let (cx, cy) = (rng.range(wi / 3, wi - 5), rng.range(4, hi - 5));
|
|
let r = rng.range(0, 1);
|
|
blob(&mut t, &mut rng, cx, cy, r, Kind::Diamond, (1000, 1500));
|
|
}
|
|
// guaranteed gold near the start
|
|
for k in 0..3 {
|
|
let cx = core.0 + rng.range(-3, 9);
|
|
let cy = core.1 + if k % 2 == 0 { rng.range(-9, -6) } else { rng.range(7, 9) };
|
|
blob(&mut t, &mut rng, cx, cy, 1, Kind::Gold, (250, 550));
|
|
}
|
|
|
|
let room = |t: &mut Vec<Tile>, x0: i32, y0: i32, x1: i32, y1: i32, owner: Owner| {
|
|
for y in y0..=y1 {
|
|
for x in x0..=x1 {
|
|
if inner(x, y) {
|
|
let tl = &mut t[y as usize * w + x as usize];
|
|
tl.kind = Kind::Floor;
|
|
tl.owner = owner;
|
|
tl.gold = 0;
|
|
}
|
|
}
|
|
}
|
|
};
|
|
// small natural caves
|
|
for _ in 0..scale(4.0) {
|
|
let (cx, cy) = (rng.range(20, wi - 16), rng.range(6, hi - 6));
|
|
let (cw, ch) = (rng.range(1, 2), rng.range(1, 2));
|
|
room(&mut t, cx - cw, cy - ch, cx + cw, cy + ch, Owner::None);
|
|
}
|
|
// treasure caves: a cave surrounded by very rich gold veins (guarded by heroes, see Game::new)
|
|
for &(cx, cy) in &treasures {
|
|
blob(&mut t, &mut rng, cx, cy, 4, Kind::Gold, (1000, 1600));
|
|
// some of the riches are gems
|
|
for y in cy - 4..=cy + 4 {
|
|
for x in cx - 4..=cx + 4 {
|
|
if inner(x, y) && t[y as usize * w + x as usize].kind == Kind::Gold {
|
|
let r = rng.f();
|
|
let tl = &mut t[y as usize * w + x as usize];
|
|
if r < 0.08 {
|
|
tl.kind = Kind::Diamond;
|
|
tl.gold = rng.range(1200, 1800);
|
|
} else if r < 0.3 {
|
|
tl.kind = Kind::Ruby;
|
|
tl.gold = rng.range(800, 1200);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
room(&mut t, cx - 2, cy - 2, cx + 2, cy + 2, Owner::None);
|
|
}
|
|
// starting area and core
|
|
room(&mut t, core.0 - 3, core.1 - 3, core.0 + 5, core.1 + 5, Owner::Player);
|
|
for y in 0..3 {
|
|
for x in 0..3 {
|
|
let tl = &mut t[(core.1 + y) as usize * w + (core.0 + x) as usize];
|
|
tl.kind = Kind::Core;
|
|
tl.owner = Owner::Player;
|
|
}
|
|
}
|
|
// portal caves
|
|
for &(px, py) in &portals {
|
|
room(&mut t, px - 2, py - 2, px + 4, py + 4, Owner::None);
|
|
for y in 0..3 {
|
|
for x in 0..3 {
|
|
t[(py + y) as usize * w + (px + x) as usize].kind = Kind::Portal;
|
|
}
|
|
}
|
|
}
|
|
// hero gate (campaign maps place the gate of the order in a fortress instead)
|
|
let gate = if opts.gate {
|
|
room(&mut t, gate.0 - 2, gate.1 - 2, gate.0 + 4, gate.1 + 4, Owner::Hero);
|
|
for y in 0..3 {
|
|
for x in 0..3 {
|
|
let tl = &mut t[(gate.1 + y) as usize * w + (gate.0 + x) as usize];
|
|
tl.kind = Kind::Gate;
|
|
tl.owner = Owner::Hero;
|
|
}
|
|
}
|
|
gate
|
|
} else {
|
|
(0, 0)
|
|
};
|
|
for tl in t.iter_mut() {
|
|
if tl.vein().is_some() {
|
|
tl.hp = 6.0;
|
|
}
|
|
}
|
|
Map { w, h, t, core, portals, legacy_portal: None, gate, treasures, explored: Vec::new(), visible: Vec::new() }
|
|
}
|
|
|
|
// Carves a meandering river; the player's area, the core and portals stay dry.
|
|
// Returns the tiles of the knight bridges.
|
|
pub fn carve_river(&mut self, r: &River, seed: u32) -> Vec<usize> {
|
|
let mut rng = Rng(seed | 1);
|
|
let (w, h) = (self.w as i32, self.h as i32);
|
|
let len = if r.vertical { h } else { w };
|
|
let across = if r.vertical { w } else { h };
|
|
let base = (r.pos * across as f32) as i32;
|
|
let (f1, f2) = (0.05 + rng.f() * 0.06, 0.13 + rng.f() * 0.08);
|
|
let (p1, p2) = (rng.f() * 6.0, rng.f() * 6.0);
|
|
let amp = (across as f32 * 0.06).min(6.0);
|
|
let mut centre = Vec::with_capacity(len as usize);
|
|
for s in 0..len {
|
|
let c = base as f32 + (s as f32 * f1 + p1).sin() * amp + (s as f32 * f2 + p2).sin() * amp * 0.4;
|
|
centre.push(c.round() as i32);
|
|
}
|
|
let at = |s: i32, o: i32| if r.vertical { (o, s) } else { (s, o) };
|
|
let kind = if r.lava { Kind::Lava } else { Kind::Water };
|
|
for s in 1..len - 1 {
|
|
for k in 0..r.width {
|
|
let o = centre[s as usize] - r.width / 2 + k;
|
|
let (x, y) = at(s, o);
|
|
if x < 1 || y < 1 || x >= w - 1 || y >= h - 1 {
|
|
continue;
|
|
}
|
|
let t = &mut self.t[idx(x, y)];
|
|
if t.owner == Owner::Player || matches!(t.kind, Kind::Core | Kind::Portal | Kind::Gate) {
|
|
continue;
|
|
}
|
|
t.kind = kind;
|
|
t.owner = Owner::None;
|
|
t.gold = 0;
|
|
t.marked = false;
|
|
t.reinforced = false;
|
|
}
|
|
}
|
|
// knight bridges, evenly spread, with a little landing at both ends
|
|
let mut out = Vec::new();
|
|
for b in 0..r.bridges {
|
|
let s = ((b as f32 + 0.5) / r.bridges as f32 * (len - 6) as f32) as i32 + 3;
|
|
for k in -1..=r.width {
|
|
let o = centre[s as usize] - r.width / 2 + k;
|
|
let (x, y) = at(s, o);
|
|
if !inb(x, y) || x < 1 || y < 1 || x >= w - 1 || y >= h - 1 {
|
|
continue;
|
|
}
|
|
let t = &mut self.t[idx(x, y)];
|
|
if t.liquid() {
|
|
t.kind = if r.lava { Kind::LavaBridge } else { Kind::Bridge };
|
|
t.owner = Owner::Hero;
|
|
out.push(idx(x, y));
|
|
} else if t.solid() && t.kind != Kind::Rock {
|
|
t.kind = Kind::Floor;
|
|
t.owner = Owner::None;
|
|
t.gold = 0;
|
|
}
|
|
}
|
|
}
|
|
out
|
|
}
|
|
|
|
// Generic Dijkstra search.
|
|
// cost(i) -> None = impassable, Some(c) = cost of entering.
|
|
// goal(i) -> true = goal reached.
|
|
pub fn search<C, G>(&self, start: usize, cost: C, goal: G, diag: bool) -> Option<Vec<usize>>
|
|
where
|
|
C: Fn(usize) -> Option<u32>,
|
|
G: Fn(usize) -> bool,
|
|
{
|
|
let mut dist = vec![u32::MAX; self.t.len()];
|
|
let mut prev = vec![usize::MAX; self.t.len()];
|
|
let mut heap = BinaryHeap::new();
|
|
dist[start] = 0;
|
|
heap.push(Reverse((0u32, start)));
|
|
while let Some(Reverse((d, i))) = heap.pop() {
|
|
if d > dist[i] {
|
|
continue;
|
|
}
|
|
if goal(i) {
|
|
let mut path = Vec::new();
|
|
let mut c = i;
|
|
while c != start {
|
|
path.push(c);
|
|
c = prev[c];
|
|
}
|
|
path.reverse();
|
|
return Some(path);
|
|
}
|
|
let (x, y) = xy(i);
|
|
let dirs: &[(i32, i32)] = if diag { &DIR8 } else { &DIR4 };
|
|
for (k, &(dx, dy)) in dirs.iter().enumerate() {
|
|
let nx = x + dx;
|
|
let ny = y + dy;
|
|
if !inb(nx, ny) {
|
|
continue;
|
|
}
|
|
let ni = idx(nx, ny);
|
|
let Some(c) = cost(ni) else { continue };
|
|
let mut step = c * 10;
|
|
if k >= 4 {
|
|
// diagonal only if both neighbours are walkable (no corner cutting)
|
|
if c > 1 || !self.walk(x + dx, y) || !self.walk(x, y + dy) {
|
|
continue;
|
|
}
|
|
step = 14;
|
|
}
|
|
let nd = d + step;
|
|
if nd < dist[ni] {
|
|
dist[ni] = nd;
|
|
prev[ni] = i;
|
|
heap.push(Reverse((nd, ni)));
|
|
}
|
|
}
|
|
}
|
|
None
|
|
}
|
|
|
|
pub fn walk_cost(&self) -> impl Fn(usize) -> Option<u32> + '_ {
|
|
move |i| {
|
|
let t = &self.t[i];
|
|
// a locked door stops the dungeon's own creatures too
|
|
if t.walkable() && !(t.kind == Kind::Door && t.res & 1 == 1) {
|
|
Some(1)
|
|
} else {
|
|
None
|
|
}
|
|
}
|
|
}
|
|
|
|
// flying creatures also cross water and lava
|
|
pub fn fly_cost(&self) -> impl Fn(usize) -> Option<u32> + '_ {
|
|
move |i| if self.t[i].walkable() || self.t[i].liquid() { Some(1) } else { None }
|
|
}
|
|
|
|
pub fn fly_path_to(&self, start: usize, target: usize) -> Option<Vec<usize>> {
|
|
self.search(start, self.fly_cost(), |i| i == target, true)
|
|
}
|
|
|
|
pub fn hero_cost(&self) -> impl Fn(usize) -> Option<u32> + '_ {
|
|
move |i| {
|
|
let tl = &self.t[i];
|
|
match tl.kind {
|
|
Kind::Earth if tl.reinforced => Some(70),
|
|
Kind::Steel => Some(300),
|
|
Kind::Earth => Some(7),
|
|
Kind::Gold | Kind::Silver | Kind::Ruby | Kind::Diamond => Some(12),
|
|
Kind::Rock | Kind::Core | Kind::Tower | Kind::Water | Kind::Lava => None,
|
|
Kind::Door => Some(10),
|
|
_ => Some(1),
|
|
}
|
|
}
|
|
}
|
|
|
|
// next to the player's soul core
|
|
pub fn adj_core(&self, i: usize) -> bool {
|
|
self.adj_core_of(i, Owner::Player)
|
|
}
|
|
|
|
// next to the soul core of a master (player or rival)
|
|
pub fn adj_core_of(&self, i: usize, owner: Owner) -> bool {
|
|
let (x, y) = xy(i);
|
|
DIR4.iter().any(|&(dx, dy)| self.get(x + dx, y + dy).map_or(false, |t| t.kind == Kind::Core && t.owner == owner))
|
|
}
|
|
|
|
pub fn hero_path_to_core(&self, start: usize) -> Option<Vec<usize>> {
|
|
self.search(start, self.hero_cost(), |i| self.adj_core(i), true)
|
|
}
|
|
|
|
|
|
pub fn path_to(&self, start: usize, target: usize) -> Option<Vec<usize>> {
|
|
self.search(start, self.walk_cost(), |i| i == target, true)
|
|
}
|
|
}
|
|
|
|
// ------------------------------------------------------------------ compact tile codec
|
|
//
|
|
// Savegame version 2 stores the tiles as one base64 string: the 2-bit texture variants,
|
|
// then run-length encoded tile records (kind, owner, marked, hp, gold, food, reserved, bed).
|
|
// A 256x256 map shrinks from ~4.5 MB of JSON to a few hundred KB.
|
|
|
|
const B64: &[u8; 64] = b"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
|
|
|
|
pub fn b64_encode(data: &[u8]) -> String {
|
|
let mut out = String::with_capacity(data.len() * 4 / 3 + 4);
|
|
for chunk in data.chunks(3) {
|
|
let b = [chunk[0], *chunk.get(1).unwrap_or(&0), *chunk.get(2).unwrap_or(&0)];
|
|
let v = (b[0] as u32) << 16 | (b[1] as u32) << 8 | b[2] as u32;
|
|
for k in 0..4 {
|
|
if k <= chunk.len() {
|
|
out.push(B64[(v >> (18 - 6 * k) & 63) as usize] as char);
|
|
} else {
|
|
out.push('=');
|
|
}
|
|
}
|
|
}
|
|
out
|
|
}
|
|
|
|
pub fn b64_decode(s: &str) -> Option<Vec<u8>> {
|
|
let mut val = [255u8; 256];
|
|
for (i, &c) in B64.iter().enumerate() {
|
|
val[c as usize] = i as u8;
|
|
}
|
|
let bytes: Vec<u8> = s.bytes().filter(|&c| c != b'=').collect();
|
|
let mut out = Vec::with_capacity(bytes.len() * 3 / 4);
|
|
for chunk in bytes.chunks(4) {
|
|
let mut v = 0u32;
|
|
for (k, &c) in chunk.iter().enumerate() {
|
|
let d = val[c as usize];
|
|
if d == 255 {
|
|
return None;
|
|
}
|
|
v |= (d as u32) << (18 - 6 * k);
|
|
}
|
|
let n = chunk.len() * 6 / 8;
|
|
for k in 0..n {
|
|
out.push((v >> (16 - 8 * k)) as u8);
|
|
}
|
|
}
|
|
Some(out)
|
|
}
|
|
|
|
const REC: usize = 23;
|
|
|
|
fn tile_record(t: &Tile) -> [u8; REC] {
|
|
let mut r = [0u8; REC];
|
|
r[0] = KINDS.iter().position(|&k| k == t.kind).unwrap_or(0) as u8;
|
|
r[1] = OWNERS.iter().position(|&o| o == t.owner).unwrap_or(0) as u8;
|
|
r[2] = t.marked as u8 | (t.reinforced as u8) << 1 | (t.res & 3) << 2;
|
|
r[3..7].copy_from_slice(&t.hp.to_le_bytes());
|
|
r[7..11].copy_from_slice(&t.gold.to_le_bytes());
|
|
r[11..15].copy_from_slice(&t.food.to_le_bytes());
|
|
r[15..19].copy_from_slice(&t.reserved.to_le_bytes());
|
|
r[19..23].copy_from_slice(&t.bed.to_le_bytes());
|
|
r
|
|
}
|
|
|
|
fn tiles_ser<S: Serializer>(tiles: &[Tile], s: S) -> Result<S::Ok, S::Error> {
|
|
let mut out = Vec::new();
|
|
out.extend_from_slice(&(tiles.len() as u32).to_le_bytes());
|
|
// texture variants, 4 per byte
|
|
for chunk in tiles.chunks(4) {
|
|
let mut b = 0u8;
|
|
for (k, t) in chunk.iter().enumerate() {
|
|
b |= (t.var & 3) << (k * 2);
|
|
}
|
|
out.push(b);
|
|
}
|
|
// runs of identical records
|
|
let mut i = 0;
|
|
while i < tiles.len() {
|
|
let rec = tile_record(&tiles[i]);
|
|
let mut run = 1;
|
|
while i + run < tiles.len() && run < 65535 && tile_record(&tiles[i + run]) == rec {
|
|
run += 1;
|
|
}
|
|
out.extend_from_slice(&(run as u16).to_le_bytes());
|
|
out.extend_from_slice(&rec);
|
|
i += run;
|
|
}
|
|
s.serialize_str(&format!("v2:{}", b64_encode(&out)))
|
|
}
|
|
|
|
#[derive(Deserialize)]
|
|
#[serde(untagged)]
|
|
enum TilesIn {
|
|
Packed(String),
|
|
Plain(Vec<Tile>), // version 1 savegames
|
|
}
|
|
|
|
fn tiles_de<'de, D: Deserializer<'de>>(d: D) -> Result<Vec<Tile>, D::Error> {
|
|
use serde::de::Error;
|
|
match TilesIn::deserialize(d)? {
|
|
TilesIn::Plain(v) => Ok(v),
|
|
TilesIn::Packed(s) => {
|
|
let data = s.strip_prefix("v2:").and_then(b64_decode).ok_or_else(|| D::Error::custom("bad tile data"))?;
|
|
let rd32 = |o: usize| -> Option<[u8; 4]> { data.get(o..o + 4).map(|s| [s[0], s[1], s[2], s[3]]) };
|
|
let count = u32::from_le_bytes(rd32(0).ok_or_else(|| D::Error::custom("bad tile data"))?) as usize;
|
|
if count > MAX_SIZE * MAX_SIZE {
|
|
return Err(D::Error::custom("map too large"));
|
|
}
|
|
let mut tiles = Vec::with_capacity(count);
|
|
let mut o = 4 + (count + 3) / 4;
|
|
while tiles.len() < count {
|
|
let run = data.get(o..o + 2).map(|s| u16::from_le_bytes([s[0], s[1]])).ok_or_else(|| D::Error::custom("bad tile data"))? as usize;
|
|
let r = data.get(o + 2..o + 2 + REC).ok_or_else(|| D::Error::custom("bad tile data"))?;
|
|
let f = |a: usize| [r[a], r[a + 1], r[a + 2], r[a + 3]];
|
|
let t = Tile {
|
|
kind: *KINDS.get(r[0] as usize).unwrap_or(&Kind::Rock),
|
|
owner: *OWNERS.get(r[1] as usize).unwrap_or(&Owner::None),
|
|
marked: r[2] & 1 != 0,
|
|
reinforced: r[2] & 2 != 0,
|
|
res: (r[2] >> 2) & 3,
|
|
hp: f32::from_le_bytes(f(3)),
|
|
gold: i32::from_le_bytes(f(7)),
|
|
food: f32::from_le_bytes(f(11)),
|
|
reserved: u32::from_le_bytes(f(15)),
|
|
bed: u32::from_le_bytes(f(19)),
|
|
var: 0,
|
|
};
|
|
for _ in 0..run.min(count - tiles.len()) {
|
|
tiles.push(t);
|
|
}
|
|
o += 2 + REC;
|
|
}
|
|
for (i, t) in tiles.iter_mut().enumerate() {
|
|
t.var = (data[4 + i / 4] >> ((i % 4) * 2)) & 3;
|
|
}
|
|
Ok(tiles)
|
|
}
|
|
}
|
|
}
|