Merge main (#2114 merged)
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
Generated
+24
@@ -1444,6 +1444,7 @@ dependencies = [
|
||||
"serde_json",
|
||||
"sha2",
|
||||
"toml",
|
||||
"wasmparser",
|
||||
"wasmtime",
|
||||
"wit-component",
|
||||
"wit-parser",
|
||||
@@ -4148,6 +4149,28 @@ dependencies = [
|
||||
"wit-parser",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "wast"
|
||||
version = "254.0.2"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "febc59cde513fc8f39b8ffd487893723c555fdd024e2e3dc7d165181e6397ea0"
|
||||
dependencies = [
|
||||
"bumpalo",
|
||||
"leb128fmt",
|
||||
"memchr",
|
||||
"unicode-width",
|
||||
"wasm-encoder",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "wat"
|
||||
version = "1.254.2"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "7db96351e51a3a1bbe6812f029e1100b4d9a5e02161fb63104bd2271fc847e7e"
|
||||
dependencies = [
|
||||
"wast",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "wayland-backend"
|
||||
version = "0.3.17"
|
||||
@@ -5013,6 +5036,7 @@ dependencies = [
|
||||
"wasm-encoder",
|
||||
"wasm-metadata",
|
||||
"wasmparser",
|
||||
"wat",
|
||||
"wit-parser",
|
||||
]
|
||||
|
||||
|
||||
@@ -47,6 +47,7 @@ impl Report {
|
||||
"api": self.facts.api,
|
||||
"side": self.facts.side,
|
||||
"capabilities": self.facts.capabilities,
|
||||
"api_level": self.facts.api_level,
|
||||
"game": self.facts.game,
|
||||
"requires": requires,
|
||||
"sha256": self.sha256,
|
||||
@@ -87,6 +88,9 @@ impl Report {
|
||||
")\n {} bytes, SHA-256 {}, {signed}\n",
|
||||
self.size, self.sha256
|
||||
);
|
||||
if let Some(level) = f.api_level {
|
||||
out += &format!(" needs mod API level {level} or newer\n");
|
||||
}
|
||||
for c in &f.capabilities {
|
||||
out += &format!(" may {}\n", c.describe());
|
||||
}
|
||||
|
||||
@@ -24,6 +24,20 @@ pub fn block_strategy() -> Strategy {
|
||||
Strategy::blocks(BLOCK_BITS.load(std::sync::atomic::Ordering::Relaxed))
|
||||
}
|
||||
|
||||
/// Frees `columns` (`count` of them) on a short-lived thread of its own
|
||||
/// when there are many: a teleport or a dimension change drops a few
|
||||
/// thousand columns at once, and freeing their sections took the frame
|
||||
/// 15-20 ms. A few are freed here.
|
||||
pub fn free_columns<T: Send + 'static>(columns: T, count: usize) {
|
||||
if count < 64 {
|
||||
return;
|
||||
}
|
||||
// Should the thread not start, the closure drops `columns` here.
|
||||
let _ = std::thread::Builder::new()
|
||||
.name("Chunk freeing".into())
|
||||
.spawn(move || drop(columns));
|
||||
}
|
||||
|
||||
/// Sizes the block states' global palette for a registry of `states`.
|
||||
pub fn set_block_states(states: usize) {
|
||||
let bits = horizon_core::paletted::ceil_log2(states).max(16);
|
||||
|
||||
@@ -11021,11 +11021,7 @@ impl Game<'_> {
|
||||
bytes += size;
|
||||
}
|
||||
}
|
||||
for c in unloaded {
|
||||
for sy in 0..(HEIGHT / 16) {
|
||||
renderer.remove((c.x, sy, c.z));
|
||||
}
|
||||
}
|
||||
renderer.remove_columns(unloaded.iter().map(|c| (c.x, c.z)));
|
||||
if let (Some(lod), Some(player)) = (&mut self.lod, &self.player) {
|
||||
let lod_distance = self.settings.horizon.lod_distance_on(&renderer.info);
|
||||
lod.set_near_loading(self.streaming.busy());
|
||||
|
||||
@@ -11,7 +11,7 @@ use super::{Dim, Game, Mining, Screen};
|
||||
use horizon_client::first_person::{Hand, SwingAnimation};
|
||||
use horizon_client::{
|
||||
Result,
|
||||
chunk::{Chunk, SECTIONS},
|
||||
chunk::Chunk,
|
||||
containers::{BlockEntity, Furnace, FurnaceKind},
|
||||
entities::{Experience, ExperienceOrb, ItemEntity},
|
||||
hud::{HudBatch, rgba},
|
||||
@@ -998,6 +998,9 @@ impl Game<'_> {
|
||||
self.world.day_time,
|
||||
self.world.weather,
|
||||
);
|
||||
let old = std::mem::take(&mut self.world.chunks);
|
||||
let count = old.len();
|
||||
horizon_client::chunk::free_columns(old, count);
|
||||
self.world = World::new(self.res.facts().air, spawn.seed);
|
||||
self.world.game_time = time;
|
||||
self.world.day_time = day;
|
||||
@@ -1059,14 +1062,14 @@ impl Game<'_> {
|
||||
if gone.is_empty() {
|
||||
return;
|
||||
}
|
||||
let mut freed = Vec::with_capacity(gone.len());
|
||||
for &(x, z) in &gone {
|
||||
self.streaming.forget(&mut self.world, x, z);
|
||||
if let Some(renderer) = self.renderer.as_mut() {
|
||||
for sy in 0..SECTIONS as i32 {
|
||||
renderer.remove((x, sy, z));
|
||||
}
|
||||
}
|
||||
freed.extend(self.streaming.forget(&mut self.world, x, z));
|
||||
}
|
||||
if let Some(renderer) = self.renderer.as_mut() {
|
||||
renderer.remove_columns(gone.iter().copied());
|
||||
}
|
||||
horizon_client::chunk::free_columns(freed, gone.len());
|
||||
// One pass for all of them.
|
||||
self.world
|
||||
.block_entities
|
||||
@@ -1631,9 +1634,7 @@ impl Game<'_> {
|
||||
.block_entities
|
||||
.retain(|k, _| (k.0 >> 4, k.2 >> 4) != (x, z));
|
||||
if let Some(renderer) = self.renderer.as_mut() {
|
||||
for sy in 0..SECTIONS as i32 {
|
||||
renderer.remove((x, sy, z));
|
||||
}
|
||||
renderer.remove_columns([(x, z)]);
|
||||
}
|
||||
}
|
||||
C::ChunkBatchFinished(_) => {
|
||||
|
||||
@@ -88,6 +88,7 @@ mod stars;
|
||||
mod timing;
|
||||
pub mod translucency;
|
||||
pub(crate) mod upload;
|
||||
mod wgsl_prefix;
|
||||
mod world_post;
|
||||
|
||||
/// A column whose every section has its mesh (`Renderer::lod_detail_columns`).
|
||||
@@ -459,7 +460,7 @@ pub struct Renderer {
|
||||
lod_retiring: crate::fast_hash::FxHashSet<SectionKey>,
|
||||
/// Finished tile meshes `upload_lods` has yet to upload.
|
||||
lod_pending: Option<lod::Pending>,
|
||||
detail_columns: HashMap<(i32, i32), u32>,
|
||||
detail_columns: crate::fast_hash::FxHashMap<(i32, i32), u32>,
|
||||
/// Bumped whenever a column becomes or stops being complete.
|
||||
detail_revision: u64,
|
||||
arena: arena::Arena,
|
||||
@@ -493,7 +494,7 @@ pub struct Renderer {
|
||||
/// The shadow camera's draws by page, in bands of distance from the light.
|
||||
shadow_runs: page_runs::PageRuns,
|
||||
/// Block-entity blocks per meshed section (world position, state id).
|
||||
block_entities: HashMap<SectionKey, Vec<([i32; 3], u32)>>,
|
||||
block_entities: crate::fast_hash::FxHashMap<SectionKey, Vec<([i32; 3], u32)>>,
|
||||
/// Changes whenever `block_entities` does (unique across renderers).
|
||||
block_entity_revision: u64,
|
||||
/// VisGraph face connectivity per meshed section (cave culling).
|
||||
@@ -2390,7 +2391,7 @@ impl Renderer {
|
||||
lod_cutout: Default::default(),
|
||||
lod_retiring: Default::default(),
|
||||
lod_pending: None,
|
||||
detail_columns: HashMap::new(),
|
||||
detail_columns: Default::default(),
|
||||
detail_revision: 0,
|
||||
arena,
|
||||
sorted_indices,
|
||||
@@ -2411,7 +2412,7 @@ impl Renderer {
|
||||
solid_runs: page_runs::PageRuns::default(),
|
||||
phase2_runs: page_runs::PageRuns::default(),
|
||||
shadow_runs: page_runs::PageRuns::default(),
|
||||
block_entities: HashMap::new(),
|
||||
block_entities: Default::default(),
|
||||
block_entity_revision: next_block_entity_revision(),
|
||||
occlusion: occlusion::Occlusion::new(crate::chunk::MIN_Y, crate::chunk::HEIGHT / 16),
|
||||
world_post,
|
||||
@@ -2847,18 +2848,47 @@ impl Renderer {
|
||||
self.detail_columns.insert(column, next);
|
||||
}
|
||||
}
|
||||
pub fn remove(&mut self, key: SectionKey) {
|
||||
self.set_detail(key, false);
|
||||
if self.block_entities.remove(&key).is_some() {
|
||||
/// Every section of these columns goes: one lookup per column where the
|
||||
/// tables are by column, and the meshes' ranges freed in one batch. A
|
||||
/// teleport removes a few thousand columns in one frame.
|
||||
pub fn remove_columns(&mut self, columns: impl IntoIterator<Item = (i32, i32)>) {
|
||||
let mut released = Vec::new();
|
||||
let mut block_entities = false;
|
||||
for (x, z) in columns {
|
||||
if self.detail_columns.remove(&(x, z)) == Some(COMPLETE_COLUMN) {
|
||||
self.detail_revision += 1;
|
||||
}
|
||||
self.occlusion.remove_column(x, z);
|
||||
let retiring = !self.lod_cutout.is_empty() && self.lod_cutout.contains(&(x, z));
|
||||
for sy in 0..crate::chunk::SECTIONS as i32 {
|
||||
let key = (x, sy, z);
|
||||
block_entities |= self.block_entities.remove(&key).is_some();
|
||||
if retiring {
|
||||
// Distant tiles still leave its column out: drawn until they don't.
|
||||
self.lod_retiring.insert(key);
|
||||
} else if let Some(section) = self.sections.remove(key) {
|
||||
released.push(section);
|
||||
}
|
||||
}
|
||||
}
|
||||
if block_entities {
|
||||
self.block_entity_revision = next_block_entity_revision();
|
||||
}
|
||||
self.occlusion.remove(key);
|
||||
if !self.lod_cutout.is_empty() && self.lod_cutout.contains(&(key.0, key.2)) {
|
||||
// Distant tiles still leave its column out: drawn until they don't.
|
||||
self.lod_retiring.insert(key);
|
||||
} else {
|
||||
self.release_section(key);
|
||||
if let Some(flat) = &mut self.flat {
|
||||
for id in released.iter().filter_map(|s| s.flat_id) {
|
||||
flat.remove(id);
|
||||
}
|
||||
}
|
||||
self.sorted_indices
|
||||
.release_all(released.iter().filter_map(|s| {
|
||||
let (page, start) = s.sorted_indices?;
|
||||
Some((page, start, u64::from(s.translucent) * 6))
|
||||
}));
|
||||
self.arena.release_all(
|
||||
released
|
||||
.iter()
|
||||
.map(|s| (s.page, s.start, u64::from(s.solid + s.translucent) * 4)),
|
||||
);
|
||||
}
|
||||
/// Horizon's resolution scale (world pixels per window pixel) and FXAA.
|
||||
pub fn set_world_post(&mut self, scale: f32, antialias: bool) {
|
||||
|
||||
@@ -39,6 +39,35 @@ impl FreeList {
|
||||
}
|
||||
self.0.insert(start, len);
|
||||
}
|
||||
/// `give` for many ranges: one merge of the sorted ranges into the list,
|
||||
/// where giving them one by one costs a few tree lookups each.
|
||||
fn give_all(&mut self, mut ranges: Vec<(u64, u64)>) {
|
||||
if ranges.len() < 64 {
|
||||
for (start, len) in ranges {
|
||||
self.give(start, len);
|
||||
}
|
||||
return;
|
||||
}
|
||||
ranges.sort_unstable();
|
||||
let mut free = std::mem::take(&mut self.0).into_iter().peekable();
|
||||
let mut given = ranges.into_iter().peekable();
|
||||
let mut merged: Vec<(u64, u64)> = Vec::new();
|
||||
loop {
|
||||
let next = match (free.peek(), given.peek()) {
|
||||
(Some(a), Some(b)) if a.0 <= b.0 => free.next(),
|
||||
(_, Some(_)) => given.next(),
|
||||
(Some(_), None) => free.next(),
|
||||
(None, None) => break,
|
||||
};
|
||||
let (start, len) = next.expect("peeked");
|
||||
match merged.last_mut() {
|
||||
Some(last) if last.0 + last.1 == start => last.1 += len,
|
||||
_ => merged.push((start, len)),
|
||||
}
|
||||
}
|
||||
// Sorted: the tree is built in one pass.
|
||||
self.0 = merged.into_iter().collect();
|
||||
}
|
||||
}
|
||||
|
||||
/// One vertex buffer of the arena; only the newest page grows.
|
||||
@@ -237,6 +266,26 @@ impl Arena {
|
||||
.free
|
||||
.give(start, len);
|
||||
}
|
||||
/// `release` for many ranges (page, start, vertices) at once.
|
||||
pub fn release_all(&mut self, ranges: impl IntoIterator<Item = (u32, u64, u64)>) {
|
||||
let mut by_page: Vec<Vec<(u64, u64)>> = Vec::new();
|
||||
for (page, start, vertices) in ranges {
|
||||
let page = page as usize;
|
||||
if by_page.len() <= page {
|
||||
by_page.resize_with(page + 1, Vec::new);
|
||||
}
|
||||
by_page[page].push((start, Self::span(vertices).min(self.page_limit)));
|
||||
}
|
||||
for (page, ranges) in by_page.into_iter().enumerate() {
|
||||
if !ranges.is_empty() {
|
||||
self.pages[page]
|
||||
.as_mut()
|
||||
.expect("live arena page")
|
||||
.free
|
||||
.give_all(ranges);
|
||||
}
|
||||
}
|
||||
}
|
||||
/// Moves a page into a larger buffer; false (the page unchanged) when
|
||||
/// there is no memory for it.
|
||||
fn grow(
|
||||
@@ -435,6 +484,44 @@ mod tests {
|
||||
assert_eq!(free, FreeList::new(4 * GRAIN));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn many_ranges_given_at_once_coalesce_as_one_by_one() {
|
||||
let fill = || {
|
||||
let mut free = FreeList::new(1 << 30);
|
||||
let taken: Vec<(u64, u64)> = (0..500u64)
|
||||
.map(|i| {
|
||||
let len = GRAIN * (1 + i * 7 % 5);
|
||||
(free.take(len).unwrap(), len)
|
||||
})
|
||||
.collect();
|
||||
for &(start, len) in taken.iter().step_by(3) {
|
||||
free.give(start, len);
|
||||
}
|
||||
(free, taken)
|
||||
};
|
||||
// Every other range of those still taken, in a scattered order.
|
||||
let (mut one_by_one, taken) = fill();
|
||||
let (mut at_once, _) = fill();
|
||||
let mut given: Vec<(u64, u64)> = (0..taken.len())
|
||||
.filter(|i| i % 3 != 0 && i % 2 == 0)
|
||||
.map(|i| taken[i])
|
||||
.collect();
|
||||
given.sort_by_key(|&(start, _)| start.wrapping_mul(0x9E37_79B9_7F4A_7C15));
|
||||
assert!(given.len() >= 64);
|
||||
for &(start, len) in &given {
|
||||
one_by_one.give(start, len);
|
||||
}
|
||||
at_once.give_all(given);
|
||||
assert_eq!(at_once, one_by_one);
|
||||
// The rest too: everything is free again, in one range.
|
||||
let rest: Vec<(u64, u64)> = (0..taken.len())
|
||||
.filter(|i| i % 3 != 0 && i % 2 != 0)
|
||||
.map(|i| taken[i])
|
||||
.collect();
|
||||
at_once.give_all(rest);
|
||||
assert_eq!(at_once, FreeList::new(1 << 30));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn first_fit_reuses_the_lowest_hole() {
|
||||
let mut free = FreeList::new(8 * GRAIN);
|
||||
|
||||
@@ -9,9 +9,9 @@
|
||||
use horizon_shader_api::{check::CheckedStage, stages::GROUP};
|
||||
|
||||
use super::native_post::{NativeFrame, present_constants};
|
||||
use super::wgsl_prefix::{TERRAIN, prefixed, section};
|
||||
|
||||
const PREFIX: &str = "horizon_sky_";
|
||||
const TERRAIN: &str = include_str!("../terrain.wgsl");
|
||||
|
||||
/// The fragment entry that calls the pack: vanilla's colour in, an opaque colour out.
|
||||
const PACK_ENTRY: &str = "
|
||||
@@ -26,62 +26,15 @@ pub struct NativeSky {
|
||||
pub label: String,
|
||||
}
|
||||
|
||||
/// The text of `source` from the line starting with `start` up to (not including) the one
|
||||
/// starting with `end`.
|
||||
fn section<'a>(source: &'a str, start: &str, end: &str) -> &'a str {
|
||||
let from = source
|
||||
.find(&format!("\n{start}"))
|
||||
.expect("terrain.wgsl has the section")
|
||||
+ 1;
|
||||
let to = from
|
||||
+ source[from..]
|
||||
.find(&format!("\n{end}"))
|
||||
.expect("terrain.wgsl ends the section")
|
||||
+ 1;
|
||||
&source[from..to]
|
||||
}
|
||||
|
||||
/// terrain.wgsl's sky with every name it declares (and `globals`) prefixed.
|
||||
fn vanilla_sky() -> String {
|
||||
let text = [
|
||||
section(TERRAIN, "struct Globals {", "@group(0) @binding(0)"),
|
||||
section(TERRAIN, "struct Globals {", "@group(0) @binding(1)"),
|
||||
section(TERRAIN, "fn linear_fog(", "fn apply_fog("),
|
||||
section(TERRAIN, "struct SkyOut {", "// rendertype_lines"),
|
||||
]
|
||||
.concat();
|
||||
let mut names = vec!["globals"];
|
||||
for line in text.lines() {
|
||||
let line = line
|
||||
.trim_start_matches("@vertex ")
|
||||
.trim_start_matches("@fragment ");
|
||||
for keyword in ["fn ", "struct ", "const "] {
|
||||
if let Some(rest) = line.strip_prefix(keyword) {
|
||||
let end = rest
|
||||
.find(|c: char| !(c.is_ascii_alphanumeric() || c == '_'))
|
||||
.unwrap_or(rest.len());
|
||||
names.push(&rest[..end]);
|
||||
}
|
||||
}
|
||||
}
|
||||
let mut out = String::with_capacity(text.len() * 2);
|
||||
let mut word = String::new();
|
||||
let flush = |word: &mut String, out: &mut String| {
|
||||
if names.contains(&word.as_str()) {
|
||||
out.push_str(PREFIX);
|
||||
}
|
||||
out.push_str(word);
|
||||
word.clear();
|
||||
};
|
||||
for c in text.chars() {
|
||||
if c.is_ascii_alphanumeric() || c == '_' {
|
||||
word.push(c);
|
||||
} else {
|
||||
flush(&mut word, &mut out);
|
||||
out.push(c);
|
||||
}
|
||||
}
|
||||
flush(&mut word, &mut out);
|
||||
out + &format!("@group(0) @binding(0) var<uniform> {PREFIX}globals: {PREFIX}Globals;\n")
|
||||
prefixed(&text, PREFIX)
|
||||
}
|
||||
|
||||
/// The sky shader for the pack's sky stage `source`.
|
||||
|
||||
@@ -522,16 +522,27 @@ impl Occlusion {
|
||||
}
|
||||
pub fn set(&mut self, key: SectionKey, vis: u64) {
|
||||
if self.columns.set(key, vis) {
|
||||
self.edits.push(Edit::Set(key, vis));
|
||||
self.dirty = true;
|
||||
self.changed.push(key);
|
||||
if self.running.is_some() {
|
||||
self.changed_late.push(key);
|
||||
}
|
||||
self.changed(key, vis);
|
||||
}
|
||||
}
|
||||
pub fn remove(&mut self, key: SectionKey) {
|
||||
self.set(key, ALL_VISIBLE);
|
||||
fn changed(&mut self, key: SectionKey, vis: u64) {
|
||||
self.edits.push(Edit::Set(key, vis));
|
||||
self.dirty = true;
|
||||
self.changed.push(key);
|
||||
if self.running.is_some() {
|
||||
self.changed_late.push(key);
|
||||
}
|
||||
}
|
||||
/// Every section of the column `x`, `z` goes (sees through every face).
|
||||
pub fn remove_column(&mut self, x: i32, z: i32) {
|
||||
let Some(column) = self.columns.map.remove(&(x, z)) else {
|
||||
return;
|
||||
};
|
||||
for (y, &vis) in column.iter().enumerate() {
|
||||
if vis != ALL_VISIBLE {
|
||||
self.changed((x, y as i32, z), ALL_VISIBLE);
|
||||
}
|
||||
}
|
||||
}
|
||||
pub fn clear(&mut self) {
|
||||
self.columns.map.clear();
|
||||
|
||||
@@ -0,0 +1,124 @@
|
||||
//! Copies of the renderer's own WGSL that run beside a shader pack's code in one module (the
|
||||
//! sky and material stages of Horizon's packs, docs/shaders.md): every name such a copy
|
||||
//! declares takes a prefix starting with `horizon_`, which the pack check refuses in a pack,
|
||||
//! so no pack name can meet one of Horizon's.
|
||||
|
||||
/// terrain.wgsl, which the copies are taken from.
|
||||
pub const TERRAIN: &str = include_str!("../terrain.wgsl");
|
||||
|
||||
/// The text of `source` from the line starting with `start` up to (not including) the one
|
||||
/// starting with `end`.
|
||||
pub fn section<'a>(source: &'a str, start: &str, end: &str) -> &'a str {
|
||||
let from = source
|
||||
.find(&format!("\n{start}"))
|
||||
.expect("the source has the section")
|
||||
+ 1;
|
||||
let to = from
|
||||
+ source[from..]
|
||||
.find(&format!("\n{end}"))
|
||||
.expect("the source ends the section")
|
||||
+ 1;
|
||||
&source[from..to]
|
||||
}
|
||||
|
||||
/// The names `text` declares at its top level: functions, structs, constants, overrides and
|
||||
/// module variables (bindings).
|
||||
fn declared(text: &str) -> Vec<&str> {
|
||||
let mut names = Vec::new();
|
||||
for line in text.lines() {
|
||||
// Top level only: a function's own `var` and `let` stay as they are.
|
||||
if line.starts_with(char::is_whitespace) {
|
||||
continue;
|
||||
}
|
||||
let mut line = line;
|
||||
while let Some(rest) = line.strip_prefix('@') {
|
||||
// An attribute: `@vertex`, `@group(0)`, `@binding(1)`.
|
||||
let end = rest.find(' ').unwrap_or(rest.len());
|
||||
line = rest[end..].trim_start();
|
||||
}
|
||||
let rest = ["fn ", "struct ", "const ", "override ", "var "]
|
||||
.iter()
|
||||
.find_map(|k| line.strip_prefix(k))
|
||||
.or_else(|| {
|
||||
// `var<uniform> name`, `var<storage, read> name`.
|
||||
let rest = line.strip_prefix("var<")?;
|
||||
Some(rest[rest.find('>')? + 1..].trim_start())
|
||||
});
|
||||
if let Some(rest) = rest {
|
||||
let end = rest
|
||||
.find(|c: char| !(c.is_ascii_alphanumeric() || c == '_'))
|
||||
.unwrap_or(rest.len());
|
||||
names.push(&rest[..end]);
|
||||
}
|
||||
}
|
||||
names
|
||||
}
|
||||
|
||||
/// `text` with every name it declares at its top level, and every use of one, prefixed by
|
||||
/// `prefix`. Comments are rewritten too, which is harmless.
|
||||
pub fn prefixed(text: &str, prefix: &str) -> String {
|
||||
let names = declared(text);
|
||||
let mut out = String::with_capacity(text.len() * 2);
|
||||
let mut word = String::new();
|
||||
let flush = |word: &mut String, out: &mut String| {
|
||||
if names.contains(&word.as_str()) {
|
||||
out.push_str(prefix);
|
||||
}
|
||||
out.push_str(word);
|
||||
word.clear();
|
||||
};
|
||||
for c in text.chars() {
|
||||
if c.is_ascii_alphanumeric() || c == '_' {
|
||||
word.push(c);
|
||||
} else {
|
||||
flush(&mut word, &mut out);
|
||||
out.push(c);
|
||||
}
|
||||
}
|
||||
flush(&mut word, &mut out);
|
||||
out
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn prefixes_top_level_names_and_their_uses_only() {
|
||||
let text = "struct S { a: f32, }\n\
|
||||
@group(0) @binding(0) var<uniform> g: S;\n\
|
||||
@group(1) @binding(2) var<storage, read> list: array<u32>;\n\
|
||||
override N: u32 = 1u;\n\
|
||||
const K: f32 = 2.0;\n\
|
||||
@fragment fn f(x: f32) -> @location(0) vec4<f32> {\n \
|
||||
var a = g.a * K;\n \
|
||||
return vec4(a + f32(list[N]) + x);\n\
|
||||
}\n";
|
||||
let out = prefixed(text, "p_");
|
||||
assert_eq!(
|
||||
out,
|
||||
"struct p_S { a: f32, }\n\
|
||||
@group(0) @binding(0) var<uniform> p_g: p_S;\n\
|
||||
@group(1) @binding(2) var<storage, read> p_list: array<u32>;\n\
|
||||
override p_N: u32 = 1u;\n\
|
||||
const p_K: f32 = 2.0;\n\
|
||||
@fragment fn p_f(x: f32) -> @location(0) vec4<f32> {\n \
|
||||
var a = p_g.a * p_K;\n \
|
||||
return vec4(a + f32(p_list[p_N]) + x);\n\
|
||||
}\n"
|
||||
);
|
||||
// Every top-level declaration of terrain.wgsl is found.
|
||||
let names = declared(TERRAIN);
|
||||
for name in [
|
||||
"Globals",
|
||||
"globals",
|
||||
"sprites_7",
|
||||
"SPRITE_SPLIT",
|
||||
"block_slots",
|
||||
"fs_sky",
|
||||
] {
|
||||
assert!(names.contains(&name), "{name}");
|
||||
}
|
||||
assert!(!names.contains(&"out"));
|
||||
}
|
||||
}
|
||||
@@ -4,7 +4,13 @@ mod game;
|
||||
|
||||
use horizon_client::{crash, logging};
|
||||
|
||||
/// The mod API level this game serves, kept in the program for the launcher
|
||||
/// to read without running it (`horizon_mods::api_level::MARK`). `main`
|
||||
/// reads it, so the linker keeps it.
|
||||
static MOD_API_LEVEL: [u8; 27] = horizon_mods::api_level::MARK;
|
||||
|
||||
fn main() {
|
||||
std::hint::black_box(&MOD_API_LEVEL);
|
||||
horizon_client::telemetry::mark_start();
|
||||
let args: Vec<String> = std::env::args().skip(1).collect();
|
||||
let game_args = args.iter().take_while(|a| *a != "--dedicated");
|
||||
|
||||
@@ -164,21 +164,21 @@ pub fn fetch_index() -> Result<Index, String> {
|
||||
|
||||
/// Installs `m` into the game folder `dir` (where `options.txt` is), for a
|
||||
/// player whose extras were `e`: its newest version for this game that
|
||||
/// wasn't taken down, checked against the index (size, SHA-256, signature,
|
||||
/// manifest), as `horizon-mods/<id>.hmod`, turned on, with the extra's
|
||||
/// settings in its storage unless the mod has its own already.
|
||||
/// wasn't taken down and that this Horizon's mod API level runs, checked
|
||||
/// against the index (size, SHA-256, signature, manifest), as
|
||||
/// `horizon-mods/<id>.hmod`, turned on, with the extra's settings in its
|
||||
/// storage unless the mod has its own already.
|
||||
pub fn install(index: &Index, m: &Moved, e: &Extras, dir: &Path) -> Result<(), String> {
|
||||
let project = index
|
||||
.project(m.id)
|
||||
.ok_or_else(|| format!("{} isn't in Horizon's registry yet", m.id))?;
|
||||
let version = project
|
||||
.versions
|
||||
.iter()
|
||||
.find(|v| {
|
||||
v.game == horizon_core::version::VERSION_ID
|
||||
&& index.revoked(&project.id, &v.file.sha256).is_none()
|
||||
})
|
||||
.ok_or_else(|| format!("{} has no version for this game", m.id))?;
|
||||
let version = index
|
||||
.installable(
|
||||
project,
|
||||
horizon_core::version::VERSION_ID,
|
||||
horizon_mods::api_level::LEVEL,
|
||||
)
|
||||
.ok_or_else(|| format!("{} has no version this Horizon can run", m.id))?;
|
||||
let mods = dir.join(crate::mod_list::DIR);
|
||||
fs::create_dir_all(&mods).map_err(|e| format!("{}: {e}", mods.display()))?;
|
||||
let target = mods.join(format!("{}.hmod", m.id));
|
||||
|
||||
Generated
+24
@@ -401,6 +401,8 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "ed5909b6e89a2db4456e54cd5f673791d7eca6732202bbf2a9cc504fe2f9b84a"
|
||||
dependencies = [
|
||||
"foldhash",
|
||||
"serde",
|
||||
"serde_core",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
@@ -442,6 +444,7 @@ dependencies = [
|
||||
"serde_json",
|
||||
"sha2",
|
||||
"toml",
|
||||
"wasmparser",
|
||||
"zip",
|
||||
]
|
||||
|
||||
@@ -649,6 +652,8 @@ checksum = "cc4e190f5d26ca7051642629da2c52fc03bde85a03197c99408dcd291734c855"
|
||||
dependencies = [
|
||||
"equivalent",
|
||||
"hashbrown",
|
||||
"serde",
|
||||
"serde_core",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
@@ -921,6 +926,12 @@ version = "1.2.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49"
|
||||
|
||||
[[package]]
|
||||
name = "semver"
|
||||
version = "1.0.28"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "8a7852d02fc848982e0c167ef163aaff9cd91dc640ba85e263cb1ce46fae51cd"
|
||||
|
||||
[[package]]
|
||||
name = "serde"
|
||||
version = "1.0.229"
|
||||
@@ -1326,6 +1337,19 @@ dependencies = [
|
||||
"wit-bindgen",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "wasmparser"
|
||||
version = "0.254.2"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "c5ff8685b587722894b6f25958fc608d315b93b8d23647bfb567664e7006d757"
|
||||
dependencies = [
|
||||
"bitflags",
|
||||
"hashbrown",
|
||||
"indexmap",
|
||||
"semver",
|
||||
"serde",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "webpki-roots"
|
||||
version = "0.26.11"
|
||||
|
||||
@@ -0,0 +1,31 @@
|
||||
# /online lists the players and their dimension; /mined counts the acting player's blocks.
|
||||
|
||||
[[step]]
|
||||
join = "Alex"
|
||||
expect.commands = ["online", "mined"]
|
||||
|
||||
[[step]]
|
||||
join = "Steve"
|
||||
as = "Steve"
|
||||
player = { dimension = "minecraft:the_nether" }
|
||||
command = "online"
|
||||
expect.feedback = "Alex (overworld), Steve (the_nether)"
|
||||
|
||||
[[step]]
|
||||
as = "Alex"
|
||||
break = { x = 1, y = 63, z = 0, state = "minecraft:stone" }
|
||||
|
||||
[[step]]
|
||||
as = "Alex"
|
||||
break = { x = 2, y = 63, z = 0, state = "minecraft:dirt" }
|
||||
|
||||
# A step's command comes before its break and place.
|
||||
[[step]]
|
||||
as = "Alex"
|
||||
command = "mined"
|
||||
expect.feedback = "You broke 2 block(s)"
|
||||
|
||||
[[step]]
|
||||
as = "Steve"
|
||||
command = "mined"
|
||||
expect.feedback = "You broke 0 block(s)"
|
||||
@@ -0,0 +1,21 @@
|
||||
# Joins are greeted; a newcomer is announced once, even after a reload (storage).
|
||||
|
||||
[[step]]
|
||||
join = "Alex"
|
||||
expect.told = ["Alex: Welcome, Alex! 0 other player(s) online."]
|
||||
expect.broadcast = ["Alex is here for the first time"]
|
||||
|
||||
[[step]]
|
||||
join = "Steve"
|
||||
expect.told = ["Steve: Welcome, Steve! 1 other player(s) online."]
|
||||
expect.broadcast = ["Steve is here for the first time"]
|
||||
|
||||
[[step]]
|
||||
leave = "Alex"
|
||||
expect.told = []
|
||||
|
||||
[[step]]
|
||||
reload = true
|
||||
join = "Alex"
|
||||
expect.told = ["Alex: Welcome, Alex! 1 other player(s) online."]
|
||||
expect.broadcast = []
|
||||
@@ -17,20 +17,27 @@ wasmtime = { version = "48.0.7", default-features = false, features = ["runtime"
|
||||
# Turns a mod's core module into a component (cargo horizon-mod build, the tests).
|
||||
wit-component = { version = "0.254", optional = true }
|
||||
wit-parser = { version = "0.254", optional = true }
|
||||
# The functions a mod imports, for its API level (src/api_level.rs): the game and the registry index.
|
||||
wasmparser = { version = "0.254", optional = true }
|
||||
# The registry index's checks (feature `index`): SHA-256, and minisign signatures (no dependencies of its own).
|
||||
sha2 = { version = "0.10", optional = true }
|
||||
minisign-verify = { version = "0.3", optional = true }
|
||||
# A shader pack's check (kind `shader`): the one the game runs before it loads a pack.
|
||||
horizon-shader-api = { path = "../horizon-shader-api", optional = true }
|
||||
|
||||
[dev-dependencies]
|
||||
# A component made for a newer Horizon, from the WIT alone (tests/sandbox.rs).
|
||||
wit-component = { version = "0.254", features = ["dummy-module"] }
|
||||
wit-parser = "0.254"
|
||||
|
||||
[features]
|
||||
# Loads and runs mods (the game's `mods` feature); without it only manifests,
|
||||
# content and packaging. Off by default so builds that don't run mods (the
|
||||
# game's tests and probes) skip wasmtime and cranelift.
|
||||
runtime = ["dep:wasmtime"]
|
||||
runtime = ["dep:wasmtime", "dep:wasmparser"]
|
||||
pack = ["dep:wit-component", "dep:wit-parser"]
|
||||
# The mod registry's index (docs/api/mod-index.md): the launcher, the registry server and its CI.
|
||||
index = ["dep:sha2", "dep:minisign-verify", "dep:horizon-shader-api"]
|
||||
index = ["dep:sha2", "dep:minisign-verify", "dep:horizon-shader-api", "dep:wasmparser"]
|
||||
|
||||
# Runs real mods: `cargo test -p horizon-mods --features runtime,pack`.
|
||||
[[test]]
|
||||
|
||||
@@ -0,0 +1,189 @@
|
||||
//! Mod API levels: which of the WIT contract's functions a Horizon has
|
||||
//! (`docs/api/stability.md`). Every function the game offers mods has the
|
||||
//! level it arrived at; a Horizon serves every level up to its [`LEVEL`].
|
||||
//! A mod needs the level of the newest function it imports, so a mod that
|
||||
//! calls a function this Horizon doesn't have is refused with "update
|
||||
//! Horizon" instead of a linking error, and the registry lists each
|
||||
//! version's level so the launcher can tell before it installs.
|
||||
|
||||
/// The newest level this Horizon serves.
|
||||
pub const LEVEL: u32 = 1;
|
||||
|
||||
/// Every function the game offers mods, as `interface.function`, with its
|
||||
/// level. Level 0 is the contract of Horizon 0.2.67 to 0.2.69. A new
|
||||
/// function takes the next level and raises [`LEVEL`] (the `api_reference`
|
||||
/// test fails until it is listed here).
|
||||
pub const FUNCTIONS: [(&str, u32); 32] = [
|
||||
("log.write", 0),
|
||||
("game.get-player", 0),
|
||||
("game.get-clock", 0),
|
||||
("chat.show", 0),
|
||||
("hud.set-panel", 0),
|
||||
("hud.clear", 0),
|
||||
("storage.get", 0),
|
||||
("storage.set", 0),
|
||||
("storage.delete", 0),
|
||||
("command.run", 0),
|
||||
("ui.open-screen", 0),
|
||||
("ui.close-screen", 0),
|
||||
("ui.set-settings", 0),
|
||||
("input.claim-items", 0),
|
||||
("input.register-key", 0),
|
||||
("input.held", 0),
|
||||
("input.poll", 0),
|
||||
("input.claim-wheel", 0),
|
||||
("input.mapping", 0),
|
||||
("input.clicks-per-second", 0),
|
||||
("render.set-hud", 0),
|
||||
("render.gui-size", 0),
|
||||
("render.shake", 0),
|
||||
("render.set-corner", 0),
|
||||
("render.clear-corner", 0),
|
||||
("render.text-width", 0),
|
||||
("render.frame-stats", 0),
|
||||
("render.set-zoom", 0),
|
||||
("render.set-minimap", 1),
|
||||
("players.online", 1),
|
||||
("players.tell", 1),
|
||||
("players.broadcast", 1),
|
||||
];
|
||||
|
||||
/// What the game's program carries so the launcher can read its level
|
||||
/// without running it: `horizon-mod-api-level:0001;` (four digits). A
|
||||
/// program from before the mark serves level 0.
|
||||
pub const MARK: [u8; 27] = {
|
||||
let mut mark = *b"horizon-mod-api-level:0000;";
|
||||
let mut level = LEVEL;
|
||||
let mut i = 25;
|
||||
while level > 0 {
|
||||
mark[i] = b'0' + (level % 10) as u8;
|
||||
level /= 10;
|
||||
i -= 1;
|
||||
}
|
||||
mark
|
||||
};
|
||||
|
||||
/// The level a program's bytes carry in their [`MARK`], if any.
|
||||
pub fn read_mark(program: &[u8]) -> Option<u32> {
|
||||
let prefix = &MARK[..22];
|
||||
program
|
||||
.windows(MARK.len())
|
||||
.filter(|w| w.starts_with(prefix) && w[26] == b';')
|
||||
.find_map(|w| std::str::from_utf8(&w[22..26]).ok()?.parse().ok())
|
||||
}
|
||||
|
||||
/// A function's level; None for one this Horizon doesn't have.
|
||||
pub fn level_of(function: &str) -> Option<u32> {
|
||||
FUNCTIONS
|
||||
.iter()
|
||||
.find(|(name, _)| *name == function)
|
||||
.map(|&(_, level)| level)
|
||||
}
|
||||
|
||||
/// The level a mod needs, from the functions it imports (as [`imports`]
|
||||
/// names them): its newest function's. A function this Horizon doesn't
|
||||
/// know comes from a newer one, so it needs more than [`LEVEL`]; that
|
||||
/// function is returned with it, for the message.
|
||||
pub fn needed<'a>(imports: impl IntoIterator<Item = &'a str>) -> (u32, Option<&'a str>) {
|
||||
let mut needed = (0, None);
|
||||
for name in imports {
|
||||
match level_of(name) {
|
||||
Some(level) if level > needed.0 => needed = (level, Some(name)),
|
||||
Some(_) => {}
|
||||
None => return (LEVEL + 1, Some(name)),
|
||||
}
|
||||
}
|
||||
needed
|
||||
}
|
||||
|
||||
/// Why this Horizon can't run a mod that needs `level`, or None when it can.
|
||||
pub fn too_new(level: u32, function: Option<&str>) -> Option<String> {
|
||||
(level > LEVEL).then(|| {
|
||||
let uses = function.map_or(String::new(), |f| format!(" (it uses {f})"));
|
||||
format!("made for a newer Horizon{uses}: update Horizon to run it")
|
||||
})
|
||||
}
|
||||
|
||||
/// The functions a mod's component imports from Horizon (`horizon:mods/*`),
|
||||
/// as `interface.function`, in the component's order.
|
||||
#[cfg(any(feature = "runtime", feature = "index"))]
|
||||
pub fn imports(wasm: &[u8]) -> Result<Vec<String>, String> {
|
||||
use wasmparser::{
|
||||
Parser, Payload, Validator, WasmFeatures, component_types::ComponentEntityType,
|
||||
};
|
||||
let types = Validator::new_with_features(WasmFeatures::all())
|
||||
.validate_all(wasm)
|
||||
.map_err(|e| format!("not a component: {e}"))?;
|
||||
let types = types.as_ref();
|
||||
let mut out = Vec::new();
|
||||
for payload in Parser::new(0).parse_all(wasm) {
|
||||
let Payload::ComponentImportSection(section) = payload.map_err(|e| e.to_string())? else {
|
||||
continue;
|
||||
};
|
||||
for import in section {
|
||||
let name = import.map_err(|e| e.to_string())?.name.name;
|
||||
// `horizon:mods/render@0.1.0` → `render`.
|
||||
let Some(interface) = name.strip_prefix("horizon:mods/") else {
|
||||
continue;
|
||||
};
|
||||
let interface = interface.split('@').next().unwrap_or(interface);
|
||||
let Some(item) = types.component_item_for_import(name) else {
|
||||
continue;
|
||||
};
|
||||
if let ComponentEntityType::Instance(id) = item.ty {
|
||||
for (function, export) in &types[id].exports {
|
||||
if matches!(export.ty, ComponentEntityType::Func(_)) {
|
||||
out.push(format!("{interface}.{function}"));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
Ok(out)
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn levels_are_listed_once_and_up_to_this_horizons() {
|
||||
for (i, (name, level)) in FUNCTIONS.iter().enumerate() {
|
||||
assert!(*level <= LEVEL, "{name}");
|
||||
assert!(
|
||||
FUNCTIONS[..i].iter().all(|(other, _)| other != name),
|
||||
"{name} twice"
|
||||
);
|
||||
}
|
||||
assert!(FUNCTIONS.iter().any(|&(_, level)| level == LEVEL));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn the_mark_carries_the_level() {
|
||||
assert_eq!(read_mark(&MARK), Some(LEVEL));
|
||||
let mut program = b"\0\x7fELF horizon-mod-api-level: horizon-mod-api-level:".to_vec();
|
||||
program.extend_from_slice(&MARK);
|
||||
program.extend_from_slice(b"\0rest");
|
||||
assert_eq!(read_mark(&program), Some(LEVEL));
|
||||
assert_eq!(read_mark(b"horizon-mod-api-level:12;"), None);
|
||||
assert_eq!(read_mark(b"no mark"), None);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_mod_needs_its_newest_function() {
|
||||
assert_eq!(needed(["log.write", "hud.set-panel"]), (0, None));
|
||||
assert_eq!(
|
||||
needed(["log.write", "render.set-minimap", "hud.clear"]),
|
||||
(1, Some("render.set-minimap"))
|
||||
);
|
||||
assert_eq!(
|
||||
needed(["render.set-minimap", "render.set-sky"]),
|
||||
(LEVEL + 1, Some("render.set-sky"))
|
||||
);
|
||||
assert_eq!(too_new(LEVEL, None), None);
|
||||
assert_eq!(
|
||||
too_new(LEVEL + 1, Some("render.set-sky")).as_deref(),
|
||||
Some("made for a newer Horizon (it uses render.set-sky): update Horizon to run it")
|
||||
);
|
||||
}
|
||||
}
|
||||
@@ -138,6 +138,11 @@ pub struct Version {
|
||||
pub side: Option<Side>,
|
||||
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||||
pub capabilities: Vec<Capability>,
|
||||
/// The mod API level a mod's code needs ([`crate::api_level`]), read
|
||||
/// from its file; none for content and other kinds, and in indexes
|
||||
/// built before levels.
|
||||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||||
pub api_level: Option<u32>,
|
||||
/// The Minecraft version it is for.
|
||||
pub game: String,
|
||||
/// A modpack's mods, as its manifest lists them.
|
||||
@@ -317,6 +322,21 @@ impl Index {
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// A project's newest version for Minecraft `game` that wasn't taken
|
||||
/// down and that a Horizon serving mod API `level` can run (an unknown
|
||||
/// level counts as runnable: the game still checks when it starts it).
|
||||
pub fn installable<'a>(
|
||||
&self,
|
||||
project: &'a Project,
|
||||
game: &str,
|
||||
level: u32,
|
||||
) -> Option<&'a Version> {
|
||||
project.versions.iter().find(|v| {
|
||||
v.game == game
|
||||
&& v.api_level.is_none_or(|l| l <= level)
|
||||
&& self.revoked(&project.id, &v.file.sha256).is_none()
|
||||
})
|
||||
}
|
||||
pub fn project(&self, id: &str) -> Option<&Project> {
|
||||
self.projects.iter().find(|p| p.id == id)
|
||||
}
|
||||
@@ -472,6 +492,8 @@ pub struct Facts {
|
||||
pub side: Option<Side>,
|
||||
/// In the manifest's order.
|
||||
pub capabilities: Vec<Capability>,
|
||||
/// The mod API level a mod's code needs, from the functions it imports.
|
||||
pub api_level: Option<u32>,
|
||||
/// The Minecraft version, when the file names one (a modpack does).
|
||||
pub game: Option<String>,
|
||||
pub requires: Vec<Requirement>,
|
||||
@@ -488,6 +510,7 @@ impl Facts {
|
||||
|| self.api != version.api
|
||||
|| self.side != version.side
|
||||
|| caps != listed
|
||||
|| version.api_level.is_some() && self.api_level != version.api_level
|
||||
|| self.game.as_ref().is_some_and(|g| *g != version.game)
|
||||
|| self.requires != version.requires;
|
||||
if !differs {
|
||||
@@ -522,9 +545,17 @@ impl Facts {
|
||||
pub fn inspect(kind: &Kind, path: &Path) -> Result<Facts, String> {
|
||||
match kind {
|
||||
Kind::Mod => {
|
||||
let m = Package::read(path)?.manifest;
|
||||
let Package { manifest: m, wasm } = Package::read(path)?;
|
||||
crate::Content::read(path, &m)?;
|
||||
let api_level = match wasm {
|
||||
Some(wasm) => {
|
||||
let functions = crate::api_level::imports(&wasm)?;
|
||||
Some(crate::api_level::needed(functions.iter().map(String::as_str)).0)
|
||||
}
|
||||
None => None,
|
||||
};
|
||||
Ok(Facts {
|
||||
api_level,
|
||||
capabilities: m.capabilities,
|
||||
id: Some(m.id),
|
||||
version: Some(m.version),
|
||||
|
||||
@@ -283,6 +283,7 @@ fn version(entry: &Entry, v: &EntryVersion, src: &Sources) -> Result<Version, St
|
||||
api: facts.api,
|
||||
side: facts.side,
|
||||
capabilities: facts.capabilities,
|
||||
api_level: facts.api_level,
|
||||
game: v.game.clone(),
|
||||
requires: facts.requires,
|
||||
file: File {
|
||||
|
||||
@@ -76,6 +76,15 @@ fn a_changed_file_key_or_manifest_is_refused() {
|
||||
let e = check(&more_caps, "coords_hud", &hmod).unwrap_err();
|
||||
assert!(e.contains("isn't what the index lists"), "{e}");
|
||||
|
||||
let mut other_level = index.clone();
|
||||
other_level.projects[0].versions[0].api_level = Some(1);
|
||||
let e = check(&other_level, "coords_hud", &hmod).unwrap_err();
|
||||
assert!(e.contains("isn't what the index lists"), "{e}");
|
||||
// An index built before levels lists none: the file still passes.
|
||||
let mut no_level = index.clone();
|
||||
no_level.projects[0].versions[0].api_level = None;
|
||||
assert_eq!(check(&no_level, "coords_hud", &hmod), Ok(Trust::Verified));
|
||||
|
||||
let mut revoked = index.clone();
|
||||
revoked.revoked.push(Revoked {
|
||||
id: "coords_hud".into(),
|
||||
@@ -167,6 +176,30 @@ fn resource_packs_need_a_pack_mcmeta() {
|
||||
std::fs::remove_dir_all(&dir).unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn the_newest_version_this_horizon_runs_is_installed() {
|
||||
let mut index = sample();
|
||||
let mut newer = index.projects[0].versions[0].clone();
|
||||
newer.version = "0.2.0".into();
|
||||
newer.file.sha256 = "2".repeat(64);
|
||||
newer.api_level = Some(crate::api_level::LEVEL + 1);
|
||||
index.projects[0].versions.insert(0, newer);
|
||||
let p = index.project("coords_hud").unwrap();
|
||||
let pick = |level| {
|
||||
index
|
||||
.installable(p, "26.3", level)
|
||||
.map(|v| v.version.as_str())
|
||||
};
|
||||
assert_eq!(pick(crate::api_level::LEVEL), Some("0.1.0"));
|
||||
assert_eq!(pick(crate::api_level::LEVEL + 1), Some("0.2.0"));
|
||||
assert_eq!(index.installable(p, "26.4", crate::api_level::LEVEL), None);
|
||||
// No level listed: runnable as far as the index knows.
|
||||
index.projects[0].versions[0].api_level = None;
|
||||
let p = index.project("coords_hud").unwrap();
|
||||
let v = index.installable(p, "26.3", 0).unwrap();
|
||||
assert_eq!(v.version, "0.2.0");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn shader_packs_pass_the_game_s_own_check() {
|
||||
let manifest = "schema = 1\nid = \"glow\"\nname = \"Glow\"\nversion = \"1.0.0\"\napi = \"0.1\"\n\
|
||||
|
||||
@@ -5,6 +5,7 @@
|
||||
//!
|
||||
//! Nothing here runs unless a mod is installed and turned on: an empty
|
||||
//! [`Mods`] makes no engine and every hook returns at once.
|
||||
pub mod api_level;
|
||||
pub mod content;
|
||||
#[cfg(feature = "index")]
|
||||
pub mod index;
|
||||
|
||||
@@ -424,6 +424,12 @@ impl Mods {
|
||||
.map(|(name, _)| name.to_string())
|
||||
.collect();
|
||||
m.check_imports(imports.iter().map(String::as_str))?;
|
||||
// A function this Horizon doesn't have: say so, not wasmtime's linking error.
|
||||
let functions = crate::api_level::imports(wasm)?;
|
||||
let (level, function) = crate::api_level::needed(functions.iter().map(String::as_str));
|
||||
if let Some(why) = crate::api_level::too_new(level, function) {
|
||||
return Err(why);
|
||||
}
|
||||
let data_dir = path
|
||||
.parent()
|
||||
.unwrap_or(Path::new("."))
|
||||
|
||||
@@ -2,10 +2,14 @@
|
||||
//!
|
||||
//! [`TestGame`] loads one `.hmod` from a scratch copy (its `storage` lives and
|
||||
//! dies with the run) into the same sandbox the game uses, and plays the game's
|
||||
//! part: the snapshot, ticks, frames, chat lines and commands. [`Script`] is a
|
||||
//! part: the snapshot, ticks, frames, chat lines and commands, and for a
|
||||
//! server mod the players joining, leaving, chatting and breaking or placing
|
||||
//! blocks. [`Script`] is a
|
||||
//! test written in TOML, `tests/<name>.toml` in the mod's folder: steps, each
|
||||
//! saying what happens and what the mod must have shown by then.
|
||||
use crate::{Clock, Corner, Mods, Output, Panel, Player, Snapshot, Status};
|
||||
use crate::{
|
||||
BlockPos, Clock, Corner, GameMode, Mods, Output, Panel, Player, ServerPlayer, Snapshot, Status,
|
||||
};
|
||||
use serde::Deserialize;
|
||||
use std::{
|
||||
path::{Path, PathBuf},
|
||||
@@ -20,6 +24,10 @@ pub struct TestGame {
|
||||
/// What the mod reads with `game-read`; ticks move the clock as the game does.
|
||||
pub player: Option<Player>,
|
||||
pub clock: Option<Clock>,
|
||||
/// The players on the server, for a server mod, in join order.
|
||||
pub players: Vec<ServerPlayer>,
|
||||
/// Every name that joined, for their id.
|
||||
names: Vec<String>,
|
||||
tick: u64,
|
||||
}
|
||||
|
||||
@@ -60,6 +68,8 @@ impl TestGame {
|
||||
game_time: 0,
|
||||
day_time: 0,
|
||||
}),
|
||||
players: Vec::new(),
|
||||
names: Vec::new(),
|
||||
tick: 0,
|
||||
};
|
||||
copy_mod(hmod, ©)?;
|
||||
@@ -87,11 +97,16 @@ impl TestGame {
|
||||
self.mods.set_snapshot(Snapshot {
|
||||
player: self.player.clone(),
|
||||
clock: self.clock,
|
||||
players: self.players.clone(),
|
||||
// The GUI of a 1280 x 720 window at scale 3, as the trial run's.
|
||||
gui_size: (427.0, 240.0),
|
||||
..Snapshot::default()
|
||||
});
|
||||
}
|
||||
/// Whether the mod is a server mod.
|
||||
pub fn server(&self) -> bool {
|
||||
self.mods.runs_server()
|
||||
}
|
||||
|
||||
/// `n` game ticks; each moves the clock one tick on, as the game does.
|
||||
pub fn tick(&mut self, n: u64) {
|
||||
@@ -103,6 +118,7 @@ impl TestGame {
|
||||
}
|
||||
self.snapshot();
|
||||
self.mods.tick(self.tick);
|
||||
self.mods.server_tick(self.tick);
|
||||
}
|
||||
}
|
||||
/// `n` frames, 1/60 s apart.
|
||||
@@ -124,13 +140,76 @@ impl TestGame {
|
||||
self.mods.command(line)
|
||||
}
|
||||
|
||||
/// A player named `name` joins the server, standing where a script starts
|
||||
/// in survival. Their id is `00000000-0000-4000-8000-000000000001` for
|
||||
/// the first name that joined, `...0002` for the second, and so on.
|
||||
pub fn join(&mut self, name: &str) -> ServerPlayer {
|
||||
let n = match self.names.iter().position(|n| n == name) {
|
||||
Some(i) => i + 1,
|
||||
None => {
|
||||
self.names.push(name.to_owned());
|
||||
self.names.len()
|
||||
}
|
||||
};
|
||||
let p = default_player();
|
||||
let player = ServerPlayer {
|
||||
id: format!("00000000-0000-4000-8000-{n:012x}"),
|
||||
name: name.to_owned(),
|
||||
x: p.x,
|
||||
y: p.y,
|
||||
z: p.z,
|
||||
dimension: p.dimension,
|
||||
game_mode: GameMode::Survival,
|
||||
health: p.health,
|
||||
};
|
||||
self.players.push(player.clone());
|
||||
self.snapshot();
|
||||
self.mods.player_joined(&player);
|
||||
player
|
||||
}
|
||||
/// The player named `name` leaves; false when no such player is on.
|
||||
pub fn leave(&mut self, name: &str) -> bool {
|
||||
let Some(i) = self.players.iter().position(|p| p.name == name) else {
|
||||
return false;
|
||||
};
|
||||
let player = self.players.remove(i);
|
||||
self.snapshot();
|
||||
self.mods.player_left(&player);
|
||||
true
|
||||
}
|
||||
/// A chat message `player` sends, for a server mod.
|
||||
pub fn player_chat(&mut self, player: &ServerPlayer, line: &str) {
|
||||
self.snapshot();
|
||||
self.mods.player_chat(player, line);
|
||||
}
|
||||
/// `/line` typed by `player`, for a server mod; false when the mod owns
|
||||
/// no such command.
|
||||
pub fn player_command(&mut self, player: &ServerPlayer, line: &str) -> bool {
|
||||
self.snapshot();
|
||||
self.mods.server_command(player, line)
|
||||
}
|
||||
/// `player` breaks (or places) `state` at `pos`.
|
||||
pub fn block(&mut self, player: &ServerPlayer, pos: BlockPos, state: &str, placed: bool) {
|
||||
self.snapshot();
|
||||
if placed {
|
||||
self.mods.block_placed(player, pos, state);
|
||||
} else {
|
||||
self.mods.block_broken(player, pos, state);
|
||||
}
|
||||
}
|
||||
|
||||
/// The scratch copy the mod runs from; its `storage` is beside it.
|
||||
pub fn hmod(&self) -> &Path {
|
||||
&self.hmod
|
||||
}
|
||||
/// The commands the mod registered.
|
||||
pub fn commands(&self) -> Vec<String> {
|
||||
self.mods.commands().map(str::to_owned).collect()
|
||||
let server = self.mods.server_commands();
|
||||
self.mods
|
||||
.commands()
|
||||
.chain(server)
|
||||
.map(str::to_owned)
|
||||
.collect()
|
||||
}
|
||||
pub fn panel(&self) -> Option<&Panel> {
|
||||
self.mods.panels().next()
|
||||
@@ -166,7 +245,7 @@ fn copy_mod(from: &Path, to: &Path) -> Result<(), String> {
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// A test in TOML: where the player starts, then steps run in order.
|
||||
/// A test in TOML: where a client mod's player starts, then steps run in order.
|
||||
#[derive(Debug, Default, Deserialize)]
|
||||
#[serde(deny_unknown_fields, rename_all = "kebab-case")]
|
||||
pub struct Script {
|
||||
@@ -178,9 +257,11 @@ pub struct Script {
|
||||
pub steps: Vec<Step>,
|
||||
}
|
||||
|
||||
/// Fields of the player to change; the others keep their values.
|
||||
/// Fields of the player to change; the others keep their values. A server
|
||||
/// mod's players have no `yaw`, `pitch` or `food`, and a client mod's player
|
||||
/// no `game-mode`.
|
||||
#[derive(Debug, Default, Deserialize)]
|
||||
#[serde(deny_unknown_fields)]
|
||||
#[serde(deny_unknown_fields, rename_all = "kebab-case")]
|
||||
pub struct PlayerSet {
|
||||
x: Option<f64>,
|
||||
y: Option<f64>,
|
||||
@@ -190,6 +271,37 @@ pub struct PlayerSet {
|
||||
health: Option<f32>,
|
||||
food: Option<u32>,
|
||||
dimension: Option<String>,
|
||||
game_mode: Option<Mode>,
|
||||
}
|
||||
|
||||
/// `players.game-mode` as a script spells it.
|
||||
#[derive(Clone, Copy, Debug, Deserialize)]
|
||||
#[serde(rename_all = "lowercase")]
|
||||
enum Mode {
|
||||
Survival,
|
||||
Creative,
|
||||
Adventure,
|
||||
Spectator,
|
||||
}
|
||||
impl From<Mode> for GameMode {
|
||||
fn from(m: Mode) -> GameMode {
|
||||
match m {
|
||||
Mode::Survival => GameMode::Survival,
|
||||
Mode::Creative => GameMode::Creative,
|
||||
Mode::Adventure => GameMode::Adventure,
|
||||
Mode::Spectator => GameMode::Spectator,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// A block a player breaks or places.
|
||||
#[derive(Debug, Deserialize)]
|
||||
#[serde(deny_unknown_fields)]
|
||||
pub struct BlockSet {
|
||||
x: i32,
|
||||
y: i32,
|
||||
z: i32,
|
||||
state: String,
|
||||
}
|
||||
|
||||
#[derive(Debug, Default, Deserialize)]
|
||||
@@ -200,8 +312,11 @@ pub struct ClockSet {
|
||||
}
|
||||
|
||||
/// One step. Its parts happen in this order: `reload`, `title-screen`,
|
||||
/// `player`, `clock`, `ticks`, `frames`, `chat`, `command`; then `expect` is
|
||||
/// checked against what the mod showed during the step.
|
||||
/// `join`, `player`, `clock`, `ticks`, `frames`, `chat`, `command`, `break`,
|
||||
/// `place`, `leave`; then `expect` is checked against what the mod showed
|
||||
/// during the step. For a server mod, `player`, `chat`, `command`, `break`
|
||||
/// and `place` are the doing of the player named by `as`, or of the first
|
||||
/// player on.
|
||||
#[derive(Debug, Default, Deserialize)]
|
||||
#[serde(deny_unknown_fields, rename_all = "kebab-case")]
|
||||
pub struct Step {
|
||||
@@ -218,6 +333,14 @@ pub struct Step {
|
||||
frames: u64,
|
||||
chat: Option<String>,
|
||||
command: Option<String>,
|
||||
/// Server mods: a player joins, leaves, breaks or places a block.
|
||||
join: Option<String>,
|
||||
leave: Option<String>,
|
||||
#[serde(rename = "as")]
|
||||
actor: Option<String>,
|
||||
#[serde(rename = "break")]
|
||||
broken: Option<BlockSet>,
|
||||
place: Option<BlockSet>,
|
||||
#[serde(default)]
|
||||
expect: Expect,
|
||||
}
|
||||
@@ -233,6 +356,10 @@ pub struct Expect {
|
||||
/// The command's feedback, and its red error.
|
||||
feedback: Option<String>,
|
||||
error: Option<String>,
|
||||
/// Server mods: every `players.tell` as `"Name: text"`, and every
|
||||
/// `players.broadcast`, in order.
|
||||
told: Option<Vec<String>>,
|
||||
broadcast: Option<Vec<String>>,
|
||||
/// The panel's lines (`[]`: no panel) and its corner.
|
||||
panel: Option<Vec<String>>,
|
||||
corner: Option<String>,
|
||||
@@ -276,6 +403,17 @@ impl PlayerSet {
|
||||
p.dimension.clone_from(d);
|
||||
}
|
||||
}
|
||||
fn apply_server(&self, p: &mut ServerPlayer) {
|
||||
let set = |to: &mut f64, v: Option<f64>| *to = v.unwrap_or(*to);
|
||||
set(&mut p.x, self.x);
|
||||
set(&mut p.y, self.y);
|
||||
set(&mut p.z, self.z);
|
||||
p.health = self.health.unwrap_or(p.health);
|
||||
p.game_mode = self.game_mode.map_or(p.game_mode, GameMode::from);
|
||||
if let Some(d) = &self.dimension {
|
||||
p.dimension.clone_from(d);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl ClockSet {
|
||||
@@ -304,6 +442,17 @@ impl Step {
|
||||
if let Some(line) = &self.command {
|
||||
parts.push(format!("/{line}"));
|
||||
}
|
||||
if let Some(name) = &self.join {
|
||||
parts.insert(0, format!("{name} joins"));
|
||||
}
|
||||
for (what, b) in [("breaks", &self.broken), ("places", &self.place)] {
|
||||
if let Some(b) = b {
|
||||
parts.push(format!("{what} {} at {} {} {}", b.state, b.x, b.y, b.z));
|
||||
}
|
||||
}
|
||||
if let Some(name) = &self.leave {
|
||||
parts.push(format!("{name} leaves"));
|
||||
}
|
||||
if parts.is_empty() {
|
||||
parts.push("checks".into());
|
||||
}
|
||||
@@ -318,8 +467,35 @@ impl Step {
|
||||
game.player = None;
|
||||
game.clock = None;
|
||||
}
|
||||
if let Some(name) = &self.join {
|
||||
game.join(name);
|
||||
}
|
||||
let server = game.server();
|
||||
let actor = |game: &TestGame| match &self.actor {
|
||||
Some(name) => game
|
||||
.players
|
||||
.iter()
|
||||
.position(|p| p.name == *name)
|
||||
.ok_or_else(|| format!("{name} is not on the server")),
|
||||
None => (!game.players.is_empty())
|
||||
.then_some(0)
|
||||
.ok_or_else(|| "no player is on the server: add join = \"Name\"".to_string()),
|
||||
};
|
||||
let acts = self.player.is_some()
|
||||
|| self.chat.is_some()
|
||||
|| self.command.is_some()
|
||||
|| self.broken.is_some()
|
||||
|| self.place.is_some();
|
||||
let actor = if server && acts {
|
||||
Some(actor(game)?)
|
||||
} else {
|
||||
None
|
||||
};
|
||||
if let Some(set) = &self.player {
|
||||
set.apply(game.player.get_or_insert_with(default_player));
|
||||
match actor {
|
||||
Some(i) => set.apply_server(&mut game.players[i]),
|
||||
None => set.apply(game.player.get_or_insert_with(default_player)),
|
||||
}
|
||||
}
|
||||
if let Some(set) = &self.clock {
|
||||
set.apply(game.clock.get_or_insert(Clock {
|
||||
@@ -329,10 +505,32 @@ impl Step {
|
||||
}
|
||||
game.tick(self.ticks);
|
||||
game.frames(self.frames);
|
||||
let who = actor.map(|i| game.players[i].clone());
|
||||
if let Some(line) = &self.chat {
|
||||
game.chat(line);
|
||||
match &who {
|
||||
Some(p) => game.player_chat(p, line),
|
||||
None => game.chat(line),
|
||||
}
|
||||
}
|
||||
let owned = self.command.as_ref().map(|line| match &who {
|
||||
Some(p) => game.player_command(p, line),
|
||||
None => game.command(line),
|
||||
});
|
||||
for (b, placed) in [(&self.broken, false), (&self.place, true)] {
|
||||
if let (Some(b), Some(p)) = (b, &who) {
|
||||
let pos = BlockPos {
|
||||
x: b.x,
|
||||
y: b.y,
|
||||
z: b.z,
|
||||
};
|
||||
game.block(p, pos, &b.state, placed);
|
||||
}
|
||||
}
|
||||
if let Some(name) = &self.leave
|
||||
&& !game.leave(name)
|
||||
{
|
||||
return Err(format!("{name} is not on the server"));
|
||||
}
|
||||
let owned = self.command.as_ref().map(|line| game.command(line));
|
||||
let out = game.drain();
|
||||
let stopped = out.iter().find_map(|o| match o {
|
||||
Output::Stopped { reason, .. } => Some(reason.as_str()),
|
||||
@@ -372,10 +570,38 @@ impl Step {
|
||||
}
|
||||
let feedback = |error: bool| {
|
||||
out.iter().rev().find_map(|o| match o {
|
||||
Output::Feedback { text, error: e } if *e == error => Some(text.clone()),
|
||||
Output::Feedback { text, error: e } | Output::Reply { text, error: e, .. }
|
||||
if *e == error =>
|
||||
{
|
||||
Some(text.clone())
|
||||
}
|
||||
_ => None,
|
||||
})
|
||||
};
|
||||
if let Some(want) = &e.told {
|
||||
let name = |id: &str| {
|
||||
let p = game.players.iter().find(|p| p.id == id);
|
||||
p.map_or(id.to_owned(), |p| p.name.clone())
|
||||
};
|
||||
let got: Vec<String> = out
|
||||
.iter()
|
||||
.filter_map(|o| match o {
|
||||
Output::Tell { player, text, .. } => Some(format!("{}: {text}", name(player))),
|
||||
_ => None,
|
||||
})
|
||||
.collect();
|
||||
same("told", want, &got)?;
|
||||
}
|
||||
if let Some(want) = &e.broadcast {
|
||||
let got: Vec<String> = out
|
||||
.iter()
|
||||
.filter_map(|o| match o {
|
||||
Output::Broadcast { text, .. } => Some(text.clone()),
|
||||
_ => None,
|
||||
})
|
||||
.collect();
|
||||
same("broadcast", want, &got)?;
|
||||
}
|
||||
if let Some(want) = &e.feedback {
|
||||
same("feedback", &Some(want.clone()), &feedback(false))?;
|
||||
}
|
||||
|
||||
@@ -302,3 +302,38 @@ fn every_capability_with_an_interface_is_in_the_contract() {
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Every function the game offers (an interface some world imports and none
|
||||
/// exports) has an API level, and the levels list nothing else.
|
||||
#[test]
|
||||
fn every_function_has_an_api_level() {
|
||||
let mut resolve = Resolve::default();
|
||||
let package = resolve.push_file(root().join(WIT)).unwrap();
|
||||
let package = &resolve.packages[package];
|
||||
let exported: Vec<_> = package
|
||||
.worlds
|
||||
.values()
|
||||
.flat_map(|&w| resolve.worlds[w].exports.values())
|
||||
.filter_map(|item| match item {
|
||||
WorldItem::Interface { id, .. } => Some(*id),
|
||||
_ => None,
|
||||
})
|
||||
.collect();
|
||||
let mut offered = Vec::new();
|
||||
for (name, &id) in &package.interfaces {
|
||||
if !exported.contains(&id) {
|
||||
for function in resolve.interfaces[id].functions.keys() {
|
||||
offered.push(format!("{name}.{function}"));
|
||||
}
|
||||
}
|
||||
}
|
||||
for f in &offered {
|
||||
assert!(
|
||||
horizon_mods::api_level::level_of(f).is_some(),
|
||||
"{f} has no level in crates/horizon-mods/src/api_level.rs: add it at the next level"
|
||||
);
|
||||
}
|
||||
for (f, _) in horizon_mods::api_level::FUNCTIONS {
|
||||
assert!(offered.iter().any(|o| o == f), "{f} isn't in the WIT");
|
||||
}
|
||||
}
|
||||
|
||||
@@ -29,6 +29,7 @@
|
||||
"hud",
|
||||
"chat"
|
||||
],
|
||||
"api_level": 0,
|
||||
"game": "26.3",
|
||||
"file": {
|
||||
"name": "coords_hud-0.1.0.hmod",
|
||||
|
||||
@@ -197,6 +197,65 @@ fn undeclared_capabilities_are_refused() {
|
||||
assert_eq!(mods.entries()[0].status, refused);
|
||||
}
|
||||
|
||||
/// A mod calling a function this Horizon doesn't have is refused with
|
||||
/// "update Horizon", not a linking error; the test mods' levels are read
|
||||
/// from the functions they import.
|
||||
#[test]
|
||||
fn a_mod_for_a_newer_horizon_is_refused() {
|
||||
use horizon_mods::api_level::{LEVEL, imports, needed};
|
||||
use wit_parser::{ManglingAndAbi, Resolve};
|
||||
let root = Path::new(env!("CARGO_MANIFEST_DIR")).join("../..");
|
||||
let wit = std::fs::read_to_string(root.join("crates/horizon-mod-sdk/wit/horizon.wit"))
|
||||
.unwrap()
|
||||
.replace(
|
||||
" set-minimap: func(minimap: option<minimap>);",
|
||||
" set-minimap: func(minimap: option<minimap>);\n set-sky: func(on: bool);",
|
||||
);
|
||||
let mut resolve = Resolve::default();
|
||||
let package = resolve.push_str("horizon.wit", &wit).unwrap();
|
||||
let world = resolve
|
||||
.select_world(&[package], Some("horizon-ui-mod"))
|
||||
.unwrap();
|
||||
let mut module = wit_component::dummy_module(&resolve, world, ManglingAndAbi::Standard32);
|
||||
wit_component::embed_component_metadata(
|
||||
&mut module,
|
||||
&resolve,
|
||||
world,
|
||||
wit_component::StringEncoding::UTF8,
|
||||
)
|
||||
.unwrap();
|
||||
let wasm = wit_component::ComponentEncoder::default()
|
||||
.module(&module)
|
||||
.unwrap()
|
||||
.encode()
|
||||
.unwrap();
|
||||
let functions = imports(&wasm).unwrap();
|
||||
assert!(functions.iter().any(|f| f == "render.set-sky"));
|
||||
let dir = mods_dir().join("too_new");
|
||||
std::fs::create_dir_all(&dir).unwrap();
|
||||
let manifest = r#"
|
||||
id = "too_new"
|
||||
name = "Too New"
|
||||
version = "0.1.0"
|
||||
api = "0.1"
|
||||
capabilities = ["game-read", "chat", "hud", "storage", "command", "ui", "render", "input"]
|
||||
experimental = ["ui", "render", "input"]
|
||||
"#;
|
||||
std::fs::write(dir.join("horizon-mod.toml"), manifest).unwrap();
|
||||
std::fs::write(dir.join("mod.wasm"), wasm).unwrap();
|
||||
let mods = Mods::load(&[dir], |_| true, |_| false);
|
||||
let refused = "made for a newer Horizon (it uses render.set-sky): update Horizon to run it";
|
||||
assert_eq!(mods.entries()[0].status, Status::Failed(refused.into()));
|
||||
|
||||
let level = |file: &str| {
|
||||
let wasm = Package::read(&mods_dir().join(file)).unwrap().wasm.unwrap();
|
||||
needed(imports(&wasm).unwrap().iter().map(String::as_str)).0
|
||||
};
|
||||
assert_eq!(level("coords_hud.hmod"), 0);
|
||||
// The UI guest shows a minimap (`render.set-minimap`).
|
||||
assert_eq!(level("horizon_mods_test_ui_guest.hmod"), LEVEL);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn vanilla_commands_win() {
|
||||
let mods = Mods::load(
|
||||
@@ -735,22 +794,23 @@ capabilities = ["registries"]
|
||||
assert!(!mods.is_running());
|
||||
}
|
||||
|
||||
/// `cargo horizon-mod test` on the example: its own `tests/*.toml` pass.
|
||||
/// `cargo horizon-mod test` on the examples: their own `tests/*.toml` pass.
|
||||
#[test]
|
||||
fn the_examples_test_scripts_pass() {
|
||||
let tests =
|
||||
Path::new(env!("CARGO_MANIFEST_DIR")).join("../horizon-mod-sdk/examples/coords-hud/tests");
|
||||
let examples = Path::new(env!("CARGO_MANIFEST_DIR")).join("../horizon-mod-sdk/examples");
|
||||
let mut ran = 0;
|
||||
for entry in std::fs::read_dir(tests).unwrap() {
|
||||
let path = entry.unwrap().path();
|
||||
let script = Script::parse(&std::fs::read_to_string(&path).unwrap()).unwrap();
|
||||
let mut game = TestGame::load(&mods_dir().join("coords_hud.hmod")).unwrap();
|
||||
script
|
||||
.run(&mut game)
|
||||
.unwrap_or_else(|e| panic!("{}: {e}", path.display()));
|
||||
ran += 1;
|
||||
for (example, hmod) in [("coords-hud", "coords_hud"), ("welcome", "welcome")] {
|
||||
for entry in std::fs::read_dir(examples.join(example).join("tests")).unwrap() {
|
||||
let path = entry.unwrap().path();
|
||||
let script = Script::parse(&std::fs::read_to_string(&path).unwrap()).unwrap();
|
||||
let mut game = TestGame::load(&mods_dir().join(format!("{hmod}.hmod"))).unwrap();
|
||||
script
|
||||
.run(&mut game)
|
||||
.unwrap_or_else(|e| panic!("{}: {e}", path.display()));
|
||||
ran += 1;
|
||||
}
|
||||
}
|
||||
assert_eq!(ran, 2);
|
||||
assert_eq!(ran, 4);
|
||||
}
|
||||
|
||||
#[test]
|
||||
@@ -774,6 +834,13 @@ fn a_test_script_says_which_step_failed_and_why() {
|
||||
Script::parse("[[step]]\ntick = 1").is_err(),
|
||||
"a typo is an error"
|
||||
);
|
||||
|
||||
let mut game = TestGame::load(&mods_dir().join("welcome.hmod")).unwrap();
|
||||
let script = "[[step]]\njoin = \"Alex\"\n\n[[step]]\nas = \"Steve\"\ncommand = \"mined\"";
|
||||
assert_eq!(
|
||||
Script::parse(script).unwrap().run(&mut game).unwrap_err(),
|
||||
"step 2 (/mined): Steve is not on the server"
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
||||
@@ -828,9 +828,9 @@ pub fn carry(
|
||||
// Additions to other sets and pools, as files the game merges.
|
||||
let modifier = serde_json::from_slice::<Value>(&bytes).ok();
|
||||
let types = &mut report.worldgen_types;
|
||||
if let Some((kind, mut added)) = modifier.and_then(|v| {
|
||||
crate::legacy_structure_mods::lithostitched::modifier(&v, loaded, types)
|
||||
}) {
|
||||
if let Some((kind, mut added)) =
|
||||
modifier.and_then(|v| crate::lithostitched::modifier(&v, loaded, types))
|
||||
{
|
||||
crate::processors::carry(
|
||||
kind,
|
||||
&mut added,
|
||||
|
||||
@@ -157,6 +157,7 @@ mod tests {
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[ignore = "modular compat is crate::lithostitched's now (its tests)"]
|
||||
fn modular_compat_runs_its_list_only_with_its_mod() {
|
||||
let mut data = ProcessorData::default();
|
||||
let swap = json!({"processor_type": "minecraft:rule", "rules": []});
|
||||
|
||||
@@ -1,503 +0,0 @@
|
||||
//! Lithostitched: its jigsaw structure, its worldgen modifiers and its
|
||||
//! processors.
|
||||
use super::ctov;
|
||||
use crate::processors::{ProcessorData, carry_all, processors, referenced};
|
||||
use crate::worldgen::{ENHANCED_TERRAIN, Upgrade, start_checks};
|
||||
use serde_json::{Value, json};
|
||||
use std::collections::BTreeMap;
|
||||
|
||||
/// A `structure` file of Lithostitched's jigsaw type as vanilla's, with the
|
||||
/// start rules it shares with the other libraries' jigsaws (`worldgen`'s
|
||||
/// `start_checks`). `None` for any other file.
|
||||
pub(crate) fn upgrade(
|
||||
kind: &str,
|
||||
v: &mut Value,
|
||||
lost: &mut BTreeMap<String, usize>,
|
||||
) -> Option<bool> {
|
||||
if kind != "structure" || v["type"] != "lithostitched:jigsaw" {
|
||||
return None;
|
||||
}
|
||||
start_checks(v, "lowest", lost, false);
|
||||
if v.as_object_mut()
|
||||
.and_then(|o| o.remove(ENHANCED_TERRAIN))
|
||||
.is_some()
|
||||
{
|
||||
*lost.entry(ENHANCED_TERRAIN.into()).or_default() += 1;
|
||||
}
|
||||
v["type"] = "minecraft:jigsaw".into();
|
||||
Some(true)
|
||||
}
|
||||
|
||||
/// A lithostitched worldgen modifier
|
||||
/// (`data/<ns>/lithostitched/worldgen_modifier/`) that adds to structure
|
||||
/// sets or template pools, as a file the game merges into them (the key
|
||||
/// `horizon:add_to`, `horizon_client::mod_content`): (kind, file). The
|
||||
/// modifier's conditions are checked against `loaded`, the mods ported
|
||||
/// along: a compat addition for a mod that is not would place that mod's
|
||||
/// blocks, which the game does not have. Other modifier types are left out.
|
||||
/// Both are counted in `report`.
|
||||
pub(crate) fn modifier(
|
||||
v: &Value,
|
||||
loaded: &dyn Fn(&str) -> bool,
|
||||
report: &mut Upgrade,
|
||||
) -> Option<(&'static str, Value)> {
|
||||
let t = v["type"].as_str().unwrap_or_default();
|
||||
let mut left = |why: &str| *report.modifiers_left.entry(why.to_owned()).or_default() += 1;
|
||||
let (kind, targets, from, to) = match t {
|
||||
"lithostitched:add_structure_set_entries" => {
|
||||
("structure_set", "structure_sets", "entries", "structures")
|
||||
}
|
||||
"lithostitched:add_template_pool_elements" => {
|
||||
("template_pool", "template_pools", "elements", "elements")
|
||||
}
|
||||
_ => {
|
||||
left(t);
|
||||
return None;
|
||||
}
|
||||
};
|
||||
if !conditions_hold(v, loaded) {
|
||||
left("conditions");
|
||||
return None;
|
||||
}
|
||||
let targets: Option<Vec<&str>> = match &v[targets] {
|
||||
Value::String(s) => Some(vec![s.as_str()]),
|
||||
Value::Array(a) => a.iter().map(Value::as_str).collect(),
|
||||
_ => None,
|
||||
};
|
||||
let Some(targets) = targets.filter(|t| !t.is_empty() && t.iter().all(|t| !t.starts_with('#')))
|
||||
else {
|
||||
left("target");
|
||||
return None;
|
||||
};
|
||||
let entries = v[from].as_array().cloned().unwrap_or_default();
|
||||
for target in &targets {
|
||||
*report.added_to.entry((*target).to_owned()).or_default() += entries.len();
|
||||
}
|
||||
Some((
|
||||
kind,
|
||||
serde_json::json!({"horizon:add_to": targets, to: entries}),
|
||||
))
|
||||
}
|
||||
|
||||
/// Whether a modifier's load conditions hold: lithostitched's `predicate`,
|
||||
/// and the loader's conditions (NeoForge's, else Fabric's). A condition
|
||||
/// type not known here does not hold.
|
||||
fn conditions_hold(v: &Value, loaded: &dyn Fn(&str) -> bool) -> bool {
|
||||
let all = |list: &Value, test: &dyn Fn(&Value) -> bool| {
|
||||
list.as_array().is_some_and(|a| a.iter().all(test))
|
||||
};
|
||||
fn predicate(p: &Value, loaded: &dyn Fn(&str) -> bool) -> bool {
|
||||
let test = |q: &Value| predicate(q, loaded);
|
||||
let list = &p["predicates"];
|
||||
match p["type"]
|
||||
.as_str()
|
||||
.map(|t| t.trim_start_matches("lithostitched:"))
|
||||
{
|
||||
Some("true") => true,
|
||||
Some("mod_loaded") => p["mod_id"].as_str().is_some_and(loaded),
|
||||
Some("not") => !predicate(&p["predicate"], loaded),
|
||||
Some("all_of") => list.as_array().is_some_and(|a| a.iter().all(test)),
|
||||
Some("any_of") => list.as_array().is_some_and(|a| a.iter().any(test)),
|
||||
_ => false,
|
||||
}
|
||||
}
|
||||
fn neoforge(c: &Value, loaded: &dyn Fn(&str) -> bool) -> bool {
|
||||
let test = |q: &Value| neoforge(q, loaded);
|
||||
match c["type"].as_str() {
|
||||
Some("neoforge:true") => true,
|
||||
Some("neoforge:mod_loaded") => c["modid"].as_str().is_some_and(loaded),
|
||||
Some("neoforge:not") => !neoforge(&c["value"], loaded),
|
||||
Some("neoforge:and") => c["values"].as_array().is_some_and(|a| a.iter().all(test)),
|
||||
Some("neoforge:or") => c["values"].as_array().is_some_and(|a| a.iter().any(test)),
|
||||
_ => false,
|
||||
}
|
||||
}
|
||||
fn fabric(c: &Value, loaded: &dyn Fn(&str) -> bool) -> bool {
|
||||
let test = |q: &Value| fabric(q, loaded);
|
||||
let mods = || {
|
||||
c["values"]
|
||||
.as_array()
|
||||
.into_iter()
|
||||
.flatten()
|
||||
.map(Value::as_str)
|
||||
};
|
||||
match c["condition"].as_str() {
|
||||
Some("fabric:true") => true,
|
||||
Some("fabric:all_mods_loaded") => mods().all(|m| m.is_some_and(loaded)),
|
||||
Some("fabric:any_mods_loaded") => mods().any(|m| m.is_some_and(loaded)),
|
||||
Some("fabric:not") => !fabric(&c["value"], loaded),
|
||||
Some("fabric:and") => c["values"].as_array().is_some_and(|a| a.iter().all(test)),
|
||||
Some("fabric:or") => c["values"].as_array().is_some_and(|a| a.iter().any(test)),
|
||||
_ => false,
|
||||
}
|
||||
}
|
||||
let litho = v.get("predicate").is_none_or(|p| predicate(p, loaded));
|
||||
let loader = match (
|
||||
v.get("neoforge:conditions"),
|
||||
v.get("fabric:load_conditions"),
|
||||
) {
|
||||
(Some(c), _) => all(c, &|c| neoforge(c, loaded)),
|
||||
// One condition or a list of them.
|
||||
(None, Some(c)) if c.is_array() => all(c, &|c| fabric(c, loaded)),
|
||||
(None, Some(c)) => fabric(c, loaded),
|
||||
(None, None) => true,
|
||||
};
|
||||
litho && loader
|
||||
}
|
||||
|
||||
/// The data form of one of Lithostitched's processors: the processors to put
|
||||
/// in its place, or `None` when it has none (or is not Lithostitched's).
|
||||
pub(crate) fn processor(
|
||||
kind: &str,
|
||||
p: &Value,
|
||||
data: &ProcessorData,
|
||||
carried: &mut BTreeMap<String, usize>,
|
||||
) -> Option<Vec<Value>> {
|
||||
match kind {
|
||||
"lithostitched:apply_random" => apply_random(p, data, carried).map(|p| vec![p]),
|
||||
"lithostitched:condition" => condition(p, data, carried).map(|p| vec![p]),
|
||||
"lithostitched:block_swap" => {
|
||||
// The same map; the game's swap keeps the properties both have.
|
||||
p["blocks"].as_object()?;
|
||||
Some(vec![
|
||||
json!({"processor_type": "horizon:block_swap", "blocks": p["blocks"]}),
|
||||
])
|
||||
}
|
||||
"lithostitched:set_block" => {
|
||||
// A simple or weighted state provider, the block entity left as
|
||||
// it is.
|
||||
let provider = p["state_provider"]["type"].as_str()?;
|
||||
let modifier = p["block_entity_modifier"]["type"].as_str();
|
||||
let plain =
|
||||
modifier.is_none_or(|m| m.trim_start_matches("minecraft:") == "passthrough");
|
||||
if !plain
|
||||
|| !matches!(
|
||||
provider,
|
||||
"minecraft:simple_state_provider" | "minecraft:weighted_state_provider"
|
||||
)
|
||||
{
|
||||
return None;
|
||||
}
|
||||
let mut out = p.clone();
|
||||
out["processor_type"] = "horizon:set_block".into();
|
||||
if let Some(o) = out.as_object_mut() {
|
||||
o.remove("block_entity_modifier");
|
||||
}
|
||||
Some(vec![out])
|
||||
}
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
|
||||
/// The references (Lithostitched's, and CTOV's compat processors) in a
|
||||
/// processor list written in; whether any was.
|
||||
pub(crate) fn expand_references(
|
||||
list: Vec<Value>,
|
||||
data: &ProcessorData,
|
||||
carried: &mut BTreeMap<String, usize>,
|
||||
) -> (Vec<Value>, bool) {
|
||||
references(list, data, carried, 0)
|
||||
}
|
||||
|
||||
/// A processor list inside a carried processor: an id stays (the game reads
|
||||
/// that file, carried on its own); an inline one is carried here.
|
||||
fn nested(list: &Value, data: &ProcessorData, carried: &mut BTreeMap<String, usize>) -> Value {
|
||||
let mut list = list.clone();
|
||||
if let Some(ps) = processors(&mut list) {
|
||||
*ps = carry_all(std::mem::take(ps), data, carried).0;
|
||||
}
|
||||
list
|
||||
}
|
||||
|
||||
/// Lithostitched's `apply_random` as `horizon:apply_random`: its weighted
|
||||
/// lists, or its set of lists at weight 1. A tag is not carried.
|
||||
fn apply_random(
|
||||
p: &Value,
|
||||
data: &ProcessorData,
|
||||
carried: &mut BTreeMap<String, usize>,
|
||||
) -> Option<Value> {
|
||||
let lists = &p["processor_lists"];
|
||||
let weighted = lists.as_array().is_some_and(|a| {
|
||||
a.iter()
|
||||
.all(|e| e.get("weight").is_some() && e.get("data").is_some())
|
||||
});
|
||||
let entries: Vec<(Value, Value)> = if weighted {
|
||||
lists
|
||||
.as_array()?
|
||||
.iter()
|
||||
.map(|e| (e["weight"].clone(), e["data"].clone()))
|
||||
.collect()
|
||||
} else {
|
||||
match lists {
|
||||
Value::String(id) if !id.starts_with('#') => vec![(1.into(), lists.clone())],
|
||||
Value::Array(a) if a.iter().any(|x| x.get("processor_type").is_some()) => {
|
||||
vec![(1.into(), lists.clone())]
|
||||
}
|
||||
Value::Array(a)
|
||||
if a.iter()
|
||||
.all(|x| x.as_str().is_some_and(|s| !s.starts_with('#')) || x.is_object()) =>
|
||||
{
|
||||
a.iter().map(|x| (1.into(), x.clone())).collect()
|
||||
}
|
||||
Value::Object(_) => vec![(1.into(), lists.clone())],
|
||||
_ => return None,
|
||||
}
|
||||
};
|
||||
let lists: Vec<Value> = entries
|
||||
.into_iter()
|
||||
.map(|(weight, list)| json!({"weight": weight, "data": nested(&list, data, carried)}))
|
||||
.collect();
|
||||
let mut out = json!({"processor_type": "horizon:apply_random", "processor_lists": lists});
|
||||
if let Some(mode) = p.get("mode") {
|
||||
out["mode"] = mode.clone();
|
||||
}
|
||||
Some(out)
|
||||
}
|
||||
|
||||
/// Lithostitched's `condition` as `horizon:condition`, when the game runs
|
||||
/// every condition in it (true, all_of, any_of, not, random_chance,
|
||||
/// matching_blocks with plain property values); else it stays Java.
|
||||
fn condition(
|
||||
p: &Value,
|
||||
data: &ProcessorData,
|
||||
carried: &mut BTreeMap<String, usize>,
|
||||
) -> Option<Value> {
|
||||
fn runs(c: &Value) -> bool {
|
||||
if let Some(all) = c.as_array() {
|
||||
return all.iter().all(runs);
|
||||
}
|
||||
let kind = c["type"].as_str().unwrap_or_default();
|
||||
match kind.strip_prefix("lithostitched:").unwrap_or(kind) {
|
||||
"true" | "random_chance" => true,
|
||||
"all_of" | "any_of" => c["conditions"]
|
||||
.as_array()
|
||||
.is_some_and(|a| a.iter().all(runs)),
|
||||
"not" => runs(&c["condition"]),
|
||||
"matching_blocks" => c.get("properties").is_none_or(|p| {
|
||||
p.as_object()
|
||||
.is_some_and(|o| o.values().all(Value::is_string))
|
||||
}),
|
||||
_ => false,
|
||||
}
|
||||
}
|
||||
if !runs(&p["if_true"]) {
|
||||
return None;
|
||||
}
|
||||
// One processor or a list of them.
|
||||
let mut branch = |key: &str| -> Value {
|
||||
let list = match p.get(key) {
|
||||
None => Vec::new(),
|
||||
Some(Value::Array(a)) => a.clone(),
|
||||
Some(one) => vec![one.clone()],
|
||||
};
|
||||
carry_all(list, data, carried).0.into()
|
||||
};
|
||||
let (then, otherwise) = (branch("then"), branch("else"));
|
||||
let mut out = json!({"processor_type": "horizon:condition", "if_true": p["if_true"],
|
||||
"then": then, "else": otherwise});
|
||||
if let Some(mode) = p.get("random_mode") {
|
||||
out["random_mode"] = mode.clone();
|
||||
}
|
||||
Some(out)
|
||||
}
|
||||
|
||||
/// Lithostitched's references in a list, each replaced by the processors of
|
||||
/// the lists it names, in order (references in them too, to a depth of 8).
|
||||
/// One naming a tag or a list the mod does not have stays, to be dropped.
|
||||
/// Whether any was replaced.
|
||||
fn references(
|
||||
list: Vec<Value>,
|
||||
data: &ProcessorData,
|
||||
carried: &mut BTreeMap<String, usize>,
|
||||
depth: usize,
|
||||
) -> (Vec<Value>, bool) {
|
||||
let mut out = Vec::with_capacity(list.len());
|
||||
let mut changed = false;
|
||||
for p in list {
|
||||
if let Some(inner) = ctov::modular_compat(&p, data, carried, depth) {
|
||||
changed = true;
|
||||
out.extend(references(inner, data, carried, depth + 1).0);
|
||||
continue;
|
||||
}
|
||||
let named = (p["processor_type"] == "lithostitched:reference" && depth < 8)
|
||||
.then(|| referenced(&p["processor_lists"], data))
|
||||
.flatten();
|
||||
match named {
|
||||
Some(inner) => {
|
||||
*carried.entry("lithostitched:reference".into()).or_default() += 1;
|
||||
out.extend(references(inner, data, carried, depth + 1).0);
|
||||
changed = true;
|
||||
}
|
||||
None => out.push(p),
|
||||
}
|
||||
}
|
||||
(out, changed)
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use crate::legacy_structure_mods::data;
|
||||
use crate::processors::carry;
|
||||
|
||||
#[test]
|
||||
fn modifiers_add_to_sets_and_pools() {
|
||||
let mut report = Upgrade::default();
|
||||
let only_fd = |m: &str| m == "farmersdelight";
|
||||
let set = json!({"type": "lithostitched:add_structure_set_entries",
|
||||
"structure_sets": "minecraft:villages",
|
||||
"entries": [{"structure": "x:village", "weight": 4}]});
|
||||
let (kind, added) = modifier(&set, &only_fd, &mut report).unwrap();
|
||||
assert_eq!(kind, "structure_set");
|
||||
assert_eq!(
|
||||
added,
|
||||
json!({"horizon:add_to": ["minecraft:villages"],
|
||||
"structures": [{"structure": "x:village", "weight": 4}]})
|
||||
);
|
||||
// A compat addition holds only when its mod is ported along.
|
||||
let pool = |modid: &str| {
|
||||
json!({"type": "lithostitched:add_template_pool_elements",
|
||||
"neoforge:conditions": [{"type": "neoforge:mod_loaded", "modid": modid}],
|
||||
"fabric:load_conditions": {"condition": "fabric:all_mods_loaded", "values": ["other"]},
|
||||
"template_pools": ["x:houses", "y:houses"],
|
||||
"elements": [{"weight": 5, "element": {"element_type": "minecraft:single_pool_element",
|
||||
"location": "x:fd_farm", "projection": "rigid", "processors": "minecraft:empty"}}]})
|
||||
};
|
||||
let (kind, added) = modifier(&pool("farmersdelight"), &only_fd, &mut report).unwrap();
|
||||
assert_eq!(kind, "template_pool");
|
||||
assert_eq!(added["horizon:add_to"], json!(["x:houses", "y:houses"]));
|
||||
assert_eq!(added["elements"][0]["weight"], 5);
|
||||
assert!(modifier(&pool("create"), &only_fd, &mut report).is_none());
|
||||
// Fabric's conditions when there are no NeoForge ones; lithostitched's own.
|
||||
let fabric = json!({"type": "lithostitched:add_structure_set_entries",
|
||||
"fabric:load_conditions": [{"condition": "fabric:not",
|
||||
"value": {"condition": "fabric:any_mods_loaded", "values": ["create"]}}],
|
||||
"predicate": {"type": "lithostitched:all_of", "predicates": [
|
||||
{"type": "lithostitched:mod_loaded", "mod_id": "farmersdelight"},
|
||||
{"type": "lithostitched:true"}]},
|
||||
"structure_sets": "minecraft:villages", "entries": []});
|
||||
assert!(modifier(&fabric, &only_fd, &mut report).is_some());
|
||||
let tagged = json!({"type": "lithostitched:add_structure_set_entries",
|
||||
"structure_sets": "#x:sets", "entries": []});
|
||||
assert!(modifier(&tagged, &only_fd, &mut report).is_none());
|
||||
let features = json!({"type": "lithostitched:add_features"});
|
||||
assert!(modifier(&features, &only_fd, &mut report).is_none());
|
||||
assert_eq!(
|
||||
report.added_to,
|
||||
BTreeMap::from([
|
||||
("minecraft:villages".into(), 1),
|
||||
("x:houses".into(), 1),
|
||||
("y:houses".into(), 1),
|
||||
])
|
||||
);
|
||||
assert_eq!(
|
||||
report.modifiers_left,
|
||||
BTreeMap::from([
|
||||
("conditions".into(), 1),
|
||||
("lithostitched:add_features".into(), 1),
|
||||
("target".into(), 1),
|
||||
])
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn lithostitched_block_swaps_become_the_games() {
|
||||
let mut list = json!({"processors": [
|
||||
{"processor_type": "lithostitched:block_swap",
|
||||
"blocks": {"minecraft:cobblestone": "minecraft:mossy_cobblestone"}},
|
||||
{"processor_type": "lithostitched:block_swap", "blocks": []}]});
|
||||
let mut carried = BTreeMap::new();
|
||||
assert!(carry("processor_list", &mut list, &data(), &mut carried));
|
||||
let p = list["processors"].as_array().unwrap();
|
||||
assert_eq!(
|
||||
p[0],
|
||||
json!({"processor_type": "horizon:block_swap",
|
||||
"blocks": {"minecraft:cobblestone": "minecraft:mossy_cobblestone"}})
|
||||
);
|
||||
// A map that is not one stays Java (dropped later).
|
||||
assert_eq!(p[1]["processor_type"], "lithostitched:block_swap");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn lithostitched_references_are_written_in() {
|
||||
let mut data = data();
|
||||
let gravity = json!({"processor_type": "minecraft:gravity", "heightmap": "WORLD_SURFACE_WG", "offset": 0});
|
||||
data.lists
|
||||
.insert("v:road".into(), json!({"processors": [gravity.clone()]}));
|
||||
data.lists.insert(
|
||||
"v:house".into(),
|
||||
json!({"processors": [
|
||||
{"processor_type": "lithostitched:reference", "processor_lists": "v:road"},
|
||||
{"processor_type": "lithostitched:block_swap", "blocks": {"minecraft:dirt": "minecraft:grass_block"}}]}),
|
||||
);
|
||||
let mut list = json!({"processors": [
|
||||
{"processor_type": "lithostitched:reference", "processor_lists": ["v:house", "v:road"]},
|
||||
{"processor_type": "lithostitched:reference", "processor_lists": "#v:roads"},
|
||||
{"processor_type": "lithostitched:reference", "processor_lists": ["v:nowhere"]}]});
|
||||
let mut carried = BTreeMap::new();
|
||||
assert!(carry("processor_list", &mut list, &data, &mut carried));
|
||||
let p = list["processors"].as_array().unwrap();
|
||||
// House (its own reference to road first, then its swap), then road;
|
||||
// the swap inside is carried too.
|
||||
assert_eq!(p[0], gravity);
|
||||
assert_eq!(p[1]["processor_type"], "horizon:block_swap");
|
||||
assert_eq!(p[2], gravity);
|
||||
// A tag or a list the mod lacks stays, to be dropped.
|
||||
assert_eq!(p[3]["processor_lists"], "#v:roads");
|
||||
assert_eq!(p[4]["processor_lists"], json!(["v:nowhere"]));
|
||||
assert_eq!(carried["lithostitched:reference"], 2);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn lithostitched_random_and_condition_become_the_games() {
|
||||
let mut data = data();
|
||||
let swap = json!({"processor_type": "lithostitched:block_swap",
|
||||
"blocks": {"minecraft:dirt": "minecraft:grass_block"}});
|
||||
data.lists
|
||||
.insert("v:green".into(), json!({"processors": [swap.clone()]}));
|
||||
let mut list = json!({"processors": [
|
||||
{"processor_type": "lithostitched:apply_random", "mode": "per_piece", "processor_lists": [
|
||||
{"weight": 3, "data": "minecraft:empty"},
|
||||
{"weight": 1, "data": {"processors": [
|
||||
{"processor_type": "lithostitched:reference", "processor_lists": "v:green"},
|
||||
{"processor_type": "v:java"}]}}]},
|
||||
{"processor_type": "lithostitched:apply_random", "mode": "per_block",
|
||||
"processor_lists": ["v:green", "v:red"]},
|
||||
{"processor_type": "lithostitched:apply_random", "mode": "per_block",
|
||||
"processor_lists": "#v:colours"},
|
||||
{"processor_type": "lithostitched:condition",
|
||||
"if_true": [{"type": "lithostitched:matching_blocks", "blocks": "minecraft:cobblestone"}],
|
||||
"then": swap, "else": {"processor_type": "lithostitched:set_block", "state_provider":
|
||||
{"type": "minecraft:simple_state_provider", "state": {"Name": "minecraft:stone"}}}},
|
||||
{"processor_type": "lithostitched:condition",
|
||||
"if_true": {"type": "lithostitched:matching_biomes", "biomes": "#c:is_cold"},
|
||||
"then": []}]});
|
||||
let mut carried = BTreeMap::new();
|
||||
assert!(carry("processor_list", &mut list, &data, &mut carried));
|
||||
let p = list["processors"].as_array().unwrap();
|
||||
let green = json!({"processor_type": "horizon:block_swap",
|
||||
"blocks": {"minecraft:dirt": "minecraft:grass_block"}});
|
||||
// Inline lists are carried; Java left in them is dropped later.
|
||||
assert_eq!(
|
||||
p[0],
|
||||
json!({"processor_type": "horizon:apply_random", "mode": "per_piece", "processor_lists": [
|
||||
{"weight": 3, "data": "minecraft:empty"},
|
||||
{"weight": 1, "data": {"processors": [green.clone(), {"processor_type": "v:java"}]}}]})
|
||||
);
|
||||
assert_eq!(
|
||||
p[1]["processor_lists"],
|
||||
json!([{"weight": 1, "data": "v:green"}, {"weight": 1, "data": "v:red"}])
|
||||
);
|
||||
assert_eq!(p[2]["processor_type"], "lithostitched:apply_random");
|
||||
assert_eq!(
|
||||
p[3],
|
||||
json!({"processor_type": "horizon:condition",
|
||||
"if_true": [{"type": "lithostitched:matching_blocks", "blocks": "minecraft:cobblestone"}],
|
||||
"then": [green], "else": [{"processor_type": "horizon:set_block", "state_provider":
|
||||
{"type": "minecraft:simple_state_provider", "state": {"Name": "minecraft:stone"}}}]})
|
||||
);
|
||||
assert_eq!(p[4]["processor_type"], "lithostitched:condition");
|
||||
assert_eq!(carried["lithostitched:apply_random"], 2);
|
||||
assert_eq!(carried["lithostitched:condition"], 1);
|
||||
}
|
||||
}
|
||||
@@ -13,10 +13,11 @@
|
||||
//! The general code reaches them only through the `pub(crate)` entry points
|
||||
//! of these three modules. Nothing in them is used by another mod's
|
||||
//! conversion.
|
||||
#[allow(dead_code)] // its modular compat is `crate::lithostitched`'s now; the rest goes with C1
|
||||
pub(crate) mod ctov;
|
||||
pub(crate) mod lithostitched;
|
||||
|
||||
#[cfg(test)]
|
||||
#[allow(dead_code)] // the old Lithostitched tests used it
|
||||
fn data() -> crate::processors::ProcessorData {
|
||||
let mut d = crate::processors::ProcessorData::default();
|
||||
d.spawners.insert(
|
||||
|
||||
@@ -14,6 +14,7 @@ pub mod import;
|
||||
pub mod inventory;
|
||||
pub mod jar;
|
||||
pub(crate) mod legacy_structure_mods;
|
||||
mod lithostitched;
|
||||
pub mod modrinth;
|
||||
pub mod oracle;
|
||||
pub mod pipeline;
|
||||
|
||||
@@ -0,0 +1,434 @@
|
||||
//! Lithostitched's worldgen, carried as the game reads it (clean room:
|
||||
//! `cleanroom/structures/spec-lithostitched.md`; CTOV's processor:
|
||||
//! `spec-ctov.md` §4).
|
||||
//!
|
||||
//! - `lithostitched:jigsaw` structures become vanilla's jigsaw. Lithostitched
|
||||
//! lays jigsaws out its own way (OPEN-L5): Horizon keeps vanilla's layouts.
|
||||
//! - Its processors (`block_swap`, `reference`, `apply_random`, `condition`,
|
||||
//! `set_block`, `discard_input`) are the game's own types
|
||||
//! (`horizon_world`'s `structure::processor`): they are carried as written,
|
||||
//! the processors nested in them carried in turn. CTOV's
|
||||
//! `ctov:modular_compat` (a reference that runs only when its mod is loaded)
|
||||
//! becomes a `reference` when the mod is ported along, else nothing.
|
||||
//! - `add_template_pool_elements` modifiers become `horizon:add_to` pool files
|
||||
//! (`docs/mods.md`), when their load conditions pass. Lithostitched's own
|
||||
//! pool elements (`limited`, `guaranteed`, `delegating`) place their
|
||||
//! `delegate`; what they add to it is counted as lost.
|
||||
use crate::{processors::ProcessorData, worldgen::Upgrade};
|
||||
use serde_json::{Value, json};
|
||||
use std::collections::BTreeMap;
|
||||
|
||||
const JIGSAW: &str = "lithostitched:jigsaw";
|
||||
/// Vanilla's JigsawStructure.MAX_DEPTH.
|
||||
const MAX_SIZE: i64 = 20;
|
||||
const MODULAR_COMPAT: &str = "ctov:modular_compat";
|
||||
/// The processor types the game reads.
|
||||
const PROCESSORS: [&str; 6] = [
|
||||
"lithostitched:block_swap",
|
||||
"lithostitched:reference",
|
||||
"lithostitched:apply_random",
|
||||
"lithostitched:condition",
|
||||
"lithostitched:set_block",
|
||||
"lithostitched:discard_input",
|
||||
];
|
||||
|
||||
fn count(map: &mut BTreeMap<String, usize>, name: &str) {
|
||||
*map.entry(name.to_owned()).or_default() += 1;
|
||||
}
|
||||
|
||||
/// A `lithostitched:jigsaw` structure as vanilla's jigsaw: `Some(true)`, else
|
||||
/// `None`.
|
||||
pub(crate) fn upgrade(
|
||||
kind: &str,
|
||||
v: &mut Value,
|
||||
lost: &mut BTreeMap<String, usize>,
|
||||
) -> Option<bool> {
|
||||
if kind != "structure" || v["type"] != JIGSAW {
|
||||
return None;
|
||||
}
|
||||
v["type"] = "minecraft:jigsaw".into();
|
||||
// `size` may be an int provider (sampled per start): its largest value.
|
||||
let size = match &v["size"] {
|
||||
Value::Null => None,
|
||||
Value::Number(n) => n.as_i64(),
|
||||
provider => {
|
||||
count(lost, "lithostitched:jigsaw size provider");
|
||||
["max_inclusive", "value"]
|
||||
.iter()
|
||||
.find_map(|k| provider[k].as_i64())
|
||||
}
|
||||
};
|
||||
if let Some(size) = size {
|
||||
if size > MAX_SIZE {
|
||||
count(lost, "lithostitched:jigsaw size over 20");
|
||||
}
|
||||
v["size"] = size.clamp(0, MAX_SIZE).into();
|
||||
}
|
||||
let o = v.as_object_mut()?;
|
||||
match o.remove("start_projection") {
|
||||
Some(Value::String(heightmap)) if heightmap != "floor" && heightmap != "ceiling" => {
|
||||
o.entry("project_start_to_heightmap")
|
||||
.or_insert(heightmap.into());
|
||||
}
|
||||
Some(_) => count(lost, "lithostitched:jigsaw start_projection"),
|
||||
None => {}
|
||||
}
|
||||
if o.remove("fixed_rotation").is_some_and(|f| f == true) {
|
||||
count(lost, "lithostitched:jigsaw fixed_rotation");
|
||||
}
|
||||
Some(true)
|
||||
}
|
||||
|
||||
/// Lithostitched's pool elements as the element they wrap; whether `element`
|
||||
/// was one.
|
||||
pub(crate) fn upgrade_pool_element(
|
||||
element: &mut Value,
|
||||
lost: &mut BTreeMap<String, usize>,
|
||||
) -> bool {
|
||||
let Some(kind) = element["element_type"].as_str() else {
|
||||
return false;
|
||||
};
|
||||
match kind {
|
||||
"lithostitched:limited" | "lithostitched:guaranteed" | "lithostitched:delegating" => {
|
||||
count(lost, kind);
|
||||
let delegate = element["delegate"].take();
|
||||
*element = delegate;
|
||||
// A delegate wrapping another (only `delegating` allows it).
|
||||
upgrade_pool_element(element, lost);
|
||||
true
|
||||
}
|
||||
_ => false,
|
||||
}
|
||||
}
|
||||
|
||||
/// The ids a modifier targets: an id or a list of ids (`None` for tags and
|
||||
/// Lithostitched's object forms).
|
||||
fn ids(v: &Value) -> Option<Vec<String>> {
|
||||
let id = |v: &Value| {
|
||||
v.as_str()
|
||||
.filter(|s| !s.starts_with('#'))
|
||||
.map(str::to_owned)
|
||||
};
|
||||
match v {
|
||||
Value::Array(a) => a.iter().map(id).collect(),
|
||||
other => Some(vec![id(other)?]),
|
||||
}
|
||||
}
|
||||
|
||||
/// NeoForge's load conditions (`neoforge:conditions`): all must pass.
|
||||
fn conditions_pass(v: &Value, loaded: &dyn Fn(&str) -> bool) -> bool {
|
||||
fn pass(c: &Value, loaded: &dyn Fn(&str) -> bool) -> bool {
|
||||
let all = |key: &str| {
|
||||
c[key]
|
||||
.as_array()
|
||||
.into_iter()
|
||||
.flatten()
|
||||
.all(|c| pass(c, loaded))
|
||||
};
|
||||
match c["type"].as_str() {
|
||||
Some("neoforge:mod_loaded") => c["modid"].as_str().is_some_and(loaded),
|
||||
Some("neoforge:true") => true,
|
||||
Some("neoforge:not") => !pass(&c["value"], loaded),
|
||||
Some("neoforge:and") => all("values"),
|
||||
Some("neoforge:or") => {
|
||||
(c["values"].as_array().into_iter().flatten()).any(|c| pass(c, loaded))
|
||||
}
|
||||
_ => false,
|
||||
}
|
||||
}
|
||||
(v["neoforge:conditions"].as_array().into_iter().flatten()).all(|c| pass(c, loaded))
|
||||
}
|
||||
|
||||
/// A worldgen modifier as a file the game merges: `("template_pool", file)`
|
||||
/// for `add_template_pool_elements`; the others are counted in
|
||||
/// `report.modifiers_left`.
|
||||
pub(crate) fn modifier(
|
||||
v: &Value,
|
||||
loaded: &dyn Fn(&str) -> bool,
|
||||
report: &mut Upgrade,
|
||||
) -> Option<(&'static str, Value)> {
|
||||
let kind = v["type"].as_str().unwrap_or("no type");
|
||||
if !conditions_pass(v, loaded) {
|
||||
count(&mut report.modifiers_left, "conditions");
|
||||
return None;
|
||||
}
|
||||
if kind != "lithostitched:add_template_pool_elements" {
|
||||
count(&mut report.modifiers_left, kind);
|
||||
return None;
|
||||
}
|
||||
let (Some(targets), Some(elements)) = (ids(&v["template_pools"]), v["elements"].as_array())
|
||||
else {
|
||||
count(&mut report.modifiers_left, "target");
|
||||
return None;
|
||||
};
|
||||
for target in &targets {
|
||||
*report.added_to.entry(target.clone()).or_default() += elements.len();
|
||||
}
|
||||
Some((
|
||||
"template_pool",
|
||||
json!({"horizon:add_to": targets, "elements": elements}),
|
||||
))
|
||||
}
|
||||
|
||||
/// Whether the game reads a Lithostitched processor as it is: one of its
|
||||
/// types, with no processor list named by tag (the game has no processor
|
||||
/// list tags) and a state provider it runs.
|
||||
pub(crate) fn game_reads(p: &Value) -> bool {
|
||||
let Some(kind) = p["processor_type"]
|
||||
.as_str()
|
||||
.filter(|t| PROCESSORS.contains(t))
|
||||
else {
|
||||
return false;
|
||||
};
|
||||
let tag = |v: &Value| v.as_str().is_some_and(|s| s.starts_with('#'));
|
||||
match kind {
|
||||
"lithostitched:reference" => match &p["processor_lists"] {
|
||||
Value::Array(a) => !a.iter().any(tag),
|
||||
other => other.is_string() && !tag(other),
|
||||
},
|
||||
"lithostitched:apply_random" => p["processor_lists"]
|
||||
.as_array()
|
||||
.is_some_and(|a| a.iter().all(|e| !tag(e) && !tag(&e["data"]))),
|
||||
"lithostitched:set_block" => matches!(
|
||||
p["state_provider"]["type"].as_str(),
|
||||
Some("minecraft:simple_state_provider" | "minecraft:weighted_state_provider")
|
||||
),
|
||||
"lithostitched:block_swap" => p["blocks"].is_object(),
|
||||
"lithostitched:condition" => !p["if_true"].is_null(),
|
||||
_ => true,
|
||||
}
|
||||
}
|
||||
|
||||
/// The processor lists inside a Lithostitched processor, for the general
|
||||
/// code that walks lists (`then`, `else`, `apply_random`'s inline data).
|
||||
pub(crate) fn inner_lists(p: &mut Value) -> Vec<&mut Value> {
|
||||
match p["processor_type"].as_str() {
|
||||
Some("lithostitched:apply_random") => (p["processor_lists"].as_array_mut().into_iter())
|
||||
.flatten()
|
||||
.filter_map(|e| e.get_mut("data").filter(|d| !d.is_string()))
|
||||
.collect(),
|
||||
Some("lithostitched:condition") => (p.as_object_mut().into_iter())
|
||||
.flat_map(|o| o.iter_mut())
|
||||
.filter(|(k, _)| *k == "then" || *k == "else")
|
||||
.map(|(_, v)| v)
|
||||
.collect(),
|
||||
_ => Vec::new(),
|
||||
}
|
||||
}
|
||||
|
||||
/// A Lithostitched processor with the processors nested in it carried
|
||||
/// (`Some`, when one of them changed); `None` for any other processor.
|
||||
pub(crate) fn processor(
|
||||
kind: &str,
|
||||
p: &Value,
|
||||
data: &ProcessorData,
|
||||
carried: &mut BTreeMap<String, usize>,
|
||||
) -> Option<Vec<Value>> {
|
||||
if !PROCESSORS.contains(&kind) {
|
||||
return None;
|
||||
}
|
||||
let mut out = p.clone();
|
||||
let mut changed = false;
|
||||
for list in inner_lists(&mut out) {
|
||||
// One processor alone is a list of one.
|
||||
if list.get("processor_type").is_some() {
|
||||
*list = Value::Array(vec![list.take()]);
|
||||
changed = true;
|
||||
}
|
||||
if let Some(processors) = crate::processors::processors(list) {
|
||||
let (inner, inner_changed) =
|
||||
crate::processors::carry_all(std::mem::take(processors), data, carried);
|
||||
*processors = inner;
|
||||
changed |= inner_changed;
|
||||
}
|
||||
}
|
||||
changed.then(|| vec![out])
|
||||
}
|
||||
|
||||
/// The list with CTOV's modular compat processors written as the game's
|
||||
/// `reference` (its mod is ported along) or taken out; whether any was.
|
||||
pub(crate) fn expand_references(
|
||||
list: Vec<Value>,
|
||||
data: &ProcessorData,
|
||||
carried: &mut BTreeMap<String, usize>,
|
||||
) -> (Vec<Value>, bool) {
|
||||
let mut changed = false;
|
||||
let mut out = Vec::with_capacity(list.len());
|
||||
for p in list {
|
||||
if p["processor_type"] != MODULAR_COMPAT {
|
||||
out.push(p);
|
||||
continue;
|
||||
}
|
||||
changed = true;
|
||||
count(carried, MODULAR_COMPAT);
|
||||
let loaded = p["modid"]
|
||||
.as_str()
|
||||
.is_some_and(|m| data.compat_loaded.contains(m));
|
||||
if loaded {
|
||||
out.push(json!({"processor_type": "lithostitched:reference",
|
||||
"processor_lists": p["reference"].clone()}));
|
||||
}
|
||||
}
|
||||
(out, changed)
|
||||
}
|
||||
|
||||
/// Notes which mods CTOV's modular compat processors name are `loaded`.
|
||||
pub(crate) fn mark_loaded(data: &mut ProcessorData, loaded: &dyn Fn(&str) -> bool) {
|
||||
fn visit(v: &Value, out: &mut Vec<String>) {
|
||||
match v {
|
||||
Value::Object(o) => {
|
||||
if o.get("processor_type").and_then(Value::as_str) == Some(MODULAR_COMPAT)
|
||||
&& let Some(m) = o.get("modid").and_then(Value::as_str)
|
||||
{
|
||||
out.push(m.to_owned());
|
||||
}
|
||||
o.values().for_each(|v| visit(v, out));
|
||||
}
|
||||
Value::Array(a) => a.iter().for_each(|v| visit(v, out)),
|
||||
_ => {}
|
||||
}
|
||||
}
|
||||
let mut named = Vec::new();
|
||||
data.lists.values().for_each(|l| visit(l, &mut named));
|
||||
data.compat_loaded
|
||||
.extend(named.into_iter().filter(|m| loaded(m)));
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use crate::worldgen::upgrade as upgrade_file;
|
||||
|
||||
#[test]
|
||||
fn jigsaws_become_vanillas() {
|
||||
let mut lost = BTreeMap::new();
|
||||
let mut s = json!({"type": JIGSAW, "size": {"type": "uniform", "min_inclusive": 3,
|
||||
"max_inclusive": 40}, "start_projection": "WORLD_SURFACE_WG", "fixed_rotation": true});
|
||||
assert_eq!(upgrade("structure", &mut s, &mut lost), Some(true));
|
||||
assert_eq!(
|
||||
s,
|
||||
json!({"type": "minecraft:jigsaw", "size": 20,
|
||||
"project_start_to_heightmap": "WORLD_SURFACE_WG"})
|
||||
);
|
||||
assert_eq!(lost.len(), 3);
|
||||
assert_eq!(
|
||||
upgrade(
|
||||
"structure",
|
||||
&mut json!({"type": "minecraft:jigsaw"}),
|
||||
&mut lost
|
||||
),
|
||||
None
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn wrapped_elements_place_their_delegate() {
|
||||
let mut lost = BTreeMap::new();
|
||||
let delegate = json!({"element_type": "minecraft:single_pool_element", "location": "a:b",
|
||||
"projection": "rigid", "processors": "minecraft:empty"});
|
||||
let mut e =
|
||||
json!({"element_type": "lithostitched:limited", "limit": 1, "delegate": delegate});
|
||||
assert!(upgrade_pool_element(&mut e, &mut lost));
|
||||
assert_eq!(e, delegate);
|
||||
assert_eq!(lost["lithostitched:limited"], 1);
|
||||
assert!(!upgrade_pool_element(&mut e, &mut lost));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn modifiers_add_to_pools_when_their_mods_are_loaded() {
|
||||
let mut report = Upgrade::default();
|
||||
let loaded = |m: &str| m == "waystones";
|
||||
let add = |modid: &str, pools: Value| {
|
||||
json!({"type": "lithostitched:add_template_pool_elements", "template_pools": pools,
|
||||
"elements": [{"weight": 2, "element": {"element_type": "minecraft:empty_pool_element"}}],
|
||||
"neoforge:conditions": [{"type": "neoforge:mod_loaded", "modid": modid}]})
|
||||
};
|
||||
let (kind, file) = modifier(
|
||||
&add("waystones", json!("ctov:village/plains/house")),
|
||||
&loaded,
|
||||
&mut report,
|
||||
)
|
||||
.unwrap();
|
||||
assert_eq!(kind, "template_pool");
|
||||
assert_eq!(file["horizon:add_to"], json!(["ctov:village/plains/house"]));
|
||||
assert_eq!(file["elements"][0]["weight"], 2);
|
||||
assert_eq!(report.added_to["ctov:village/plains/house"], 1);
|
||||
assert!(modifier(&add("sawmill", json!("a:b")), &loaded, &mut report).is_none());
|
||||
assert!(modifier(&add("waystones", json!("#a:pools")), &loaded, &mut report).is_none());
|
||||
let aliases = json!({"type": "lithostitched:set_pool_aliases"});
|
||||
assert!(modifier(&aliases, &loaded, &mut report).is_none());
|
||||
assert_eq!(
|
||||
report.modifiers_left,
|
||||
BTreeMap::from([
|
||||
("conditions".into(), 1),
|
||||
("lithostitched:set_pool_aliases".into(), 1),
|
||||
("target".into(), 1),
|
||||
])
|
||||
);
|
||||
}
|
||||
|
||||
/// A CTOV list (spec-ctov §4): references, a condition with a single
|
||||
/// processor and a nested condition, a random list holding the compat
|
||||
/// hook, and processors the game cannot read.
|
||||
#[test]
|
||||
fn processors_stay_lithostitcheds_with_their_insides_carried() {
|
||||
let hook = json!({"processor_type": MODULAR_COMPAT, "modid": "natures_spirit",
|
||||
"reference": "ctov:village/mesa/house_wisteria"});
|
||||
let list = json!({"processors": [
|
||||
{"processor_type": "lithostitched:reference", "processor_lists": ["ctov:village/mesa/house"]},
|
||||
{"processor_type": "lithostitched:condition", "random_mode": "per_block",
|
||||
"if_true": {"type": "lithostitched:matching_blocks", "blocks": "minecraft:water",
|
||||
"match_type": "location"},
|
||||
"then": {"processor_type": "lithostitched:set_block", "state_provider": {
|
||||
"type": "minecraft:simple_state_provider", "state": {"Name": "minecraft:spruce_planks"}}},
|
||||
"else": [{"processor_type": "somemod:java_processor"}]},
|
||||
{"processor_type": "lithostitched:apply_random", "mode": "per_piece", "processor_lists": [
|
||||
{"weight": 1, "data": "minecraft:empty"},
|
||||
{"weight": 1, "data": {"processors": [hook]}}]},
|
||||
{"processor_type": "lithostitched:reference", "processor_lists": "#ctov:palettes"},
|
||||
{"processor_type": "lithostitched:set_block", "state_provider": {
|
||||
"type": "minecraft:noise_provider"}}]});
|
||||
for (loaded, wisteria) in [
|
||||
(false, json!([])),
|
||||
(
|
||||
true,
|
||||
json!([{"processor_type":
|
||||
"lithostitched:reference", "processor_lists": "ctov:village/mesa/house_wisteria"}]),
|
||||
),
|
||||
] {
|
||||
let mut data = ProcessorData::default();
|
||||
data.lists
|
||||
.insert("ctov:village/mesa/house".into(), list.clone());
|
||||
mark_loaded(&mut data, &|m| loaded && m == "natures_spirit");
|
||||
let mut v = list.clone();
|
||||
let mut report = Upgrade::default();
|
||||
crate::processors::carry(
|
||||
"processor_list",
|
||||
&mut v,
|
||||
&data,
|
||||
&mut report.processors_carried,
|
||||
);
|
||||
upgrade_file("processor_list", &mut v, &mut report, &BTreeMap::new());
|
||||
let p = &v["processors"];
|
||||
assert_eq!(p.as_array().unwrap().len(), 3, "{p}");
|
||||
assert_eq!(p[0], list["processors"][0]);
|
||||
// One processor is a list of one; the Java one is taken out.
|
||||
assert_eq!(
|
||||
p[1]["then"][0]["state_provider"]["state"]["id"],
|
||||
"minecraft:spruce_planks"
|
||||
);
|
||||
assert_eq!(p[1]["else"], json!([]));
|
||||
assert_eq!(p[2]["processor_lists"][0]["data"], "minecraft:empty");
|
||||
assert_eq!(p[2]["processor_lists"][1]["data"]["processors"], wisteria);
|
||||
assert_eq!(report.processors_carried[MODULAR_COMPAT], 1);
|
||||
assert_eq!(
|
||||
report.processors_dropped,
|
||||
BTreeMap::from([
|
||||
("lithostitched:reference".into(), 1),
|
||||
("lithostitched:set_block".into(), 1),
|
||||
("somemod:java_processor".into(), 1),
|
||||
])
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -10,13 +10,13 @@
|
||||
//! - Repurposed Structures' mineshaft sky view becomes the game's
|
||||
//! `horizon:mineshaft_sky_view`.
|
||||
//!
|
||||
//! The processors of YUNG's mods, Lithostitched and Choice Theorem's Overhauled
|
||||
//! Village are carried by `legacy_structure_mods`, called from [`carry`].
|
||||
//! Lithostitched's processors and Choice Theorem's Overhauled Village's
|
||||
//! compat hook are carried by `crate::lithostitched`, called from [`carry`].
|
||||
//!
|
||||
//! What is not here is taken out of its list later and counted
|
||||
//! (`worldgen::upgrade`). The entity NBT is written in 26.3's shape (an
|
||||
//! `equipment` map, not 1.21.1's `HandItems` and `ArmorItems`).
|
||||
use crate::legacy_structure_mods::{ctov, lithostitched};
|
||||
use crate::lithostitched;
|
||||
use serde_json::{Value, json};
|
||||
use std::{
|
||||
collections::{BTreeMap, BTreeSet},
|
||||
@@ -42,7 +42,7 @@ pub struct ProcessorData {
|
||||
impl ProcessorData {
|
||||
/// Notes which mods its compat processors name are `loaded`.
|
||||
pub fn mark_loaded(&mut self, loaded: &dyn Fn(&str) -> bool) {
|
||||
ctov::mark_loaded(self, loaded);
|
||||
lithostitched::mark_loaded(self, loaded);
|
||||
}
|
||||
|
||||
pub fn read<R: Read + Seek>(zip: &mut zip::ZipArchive<R>) -> Self {
|
||||
@@ -177,8 +177,7 @@ fn carry_at(
|
||||
let mut out = Vec::with_capacity(expanded.len());
|
||||
for p in expanded {
|
||||
let kind = p["processor_type"].as_str().unwrap_or_default().to_owned();
|
||||
// Lithostitched's processors are carried apart from this code
|
||||
// (`legacy_structure_mods`).
|
||||
// Lithostitched's processors stay theirs, with what they hold carried.
|
||||
let replacement = lithostitched::processor(&kind, &p, data, carried).or_else(|| {
|
||||
match pillar_type(&kind) {
|
||||
Some(to) => Some(vec![pillar(&p, to, data, carried, depth)]),
|
||||
|
||||
@@ -15,10 +15,10 @@
|
||||
//! closely.
|
||||
//!
|
||||
//! YUNG's API's files are carried as written ([`crate::yung`]).
|
||||
//! Lithostitched's and CTOV's worldgen files are converted by
|
||||
//! `legacy_structure_mods`, called from [`upgrade`], [`crate::carry`] and the
|
||||
//! processors.
|
||||
use crate::{legacy_structure_mods::lithostitched, yung};
|
||||
//! Lithostitched's jigsaws, elements, modifiers and processors are carried by
|
||||
//! [`crate::lithostitched`]; the entries CTOV adds to vanilla's structure sets
|
||||
//! by `legacy_structure_mods`, called from [`crate::carry`].
|
||||
use crate::{lithostitched, yung};
|
||||
use serde_json::Value;
|
||||
use std::{
|
||||
collections::{BTreeMap, BTreeSet},
|
||||
@@ -191,28 +191,19 @@ fn drop_java_processors(list: &mut Value, dropped: &mut BTreeMap<String, usize>)
|
||||
let before = processors.len();
|
||||
processors.retain(|p| {
|
||||
let t = p["processor_type"].as_str().unwrap_or_default();
|
||||
let java = !t.starts_with("minecraft:") && !t.starts_with("horizon:");
|
||||
let java = !t.starts_with("minecraft:")
|
||||
&& !t.starts_with("horizon:")
|
||||
&& !lithostitched::game_reads(p);
|
||||
if java {
|
||||
*dropped.entry(t.to_owned()).or_default() += 1;
|
||||
}
|
||||
!java
|
||||
});
|
||||
let mut changed = processors.len() != before;
|
||||
// The inline lists inside the game's apply_random and condition.
|
||||
// The inline lists inside Lithostitched's apply_random and condition.
|
||||
for p in processors.iter_mut() {
|
||||
let inner: Vec<&mut Value> = match p["processor_type"].as_str() {
|
||||
Some("horizon:apply_random") => p["processor_lists"]
|
||||
.as_array_mut()
|
||||
.into_iter()
|
||||
.flatten()
|
||||
.map(|e| &mut e["data"])
|
||||
.collect(),
|
||||
Some("horizon:condition") => {
|
||||
let o = p.as_object_mut().into_iter().flat_map(|o| o.iter_mut());
|
||||
o.filter(|(k, _)| *k == "then" || *k == "else")
|
||||
.map(|(_, v)| v)
|
||||
.collect()
|
||||
}
|
||||
Some(t) if t.starts_with("lithostitched:") => lithostitched::inner_lists(p),
|
||||
Some("horizon:pillar" | "horizon:bottom_pillar") => {
|
||||
p.get_mut("pillar_processor_list").into_iter().collect()
|
||||
}
|
||||
@@ -398,7 +389,9 @@ fn upgrade_types(
|
||||
}
|
||||
}
|
||||
for element in elements {
|
||||
if yung::upgrade_pool_element(element, lost) {
|
||||
if yung::upgrade_pool_element(element, lost)
|
||||
|| lithostitched::upgrade_pool_element(element, lost)
|
||||
{
|
||||
changed = true;
|
||||
continue;
|
||||
}
|
||||
|
||||
@@ -21,7 +21,7 @@ use horizon_core::{
|
||||
use serde_json::Value;
|
||||
use std::{collections::BTreeSet, sync::Arc};
|
||||
|
||||
mod lithostitched;
|
||||
mod litho;
|
||||
mod pillars;
|
||||
mod sea_level;
|
||||
|
||||
@@ -238,6 +238,23 @@ impl Modifier {
|
||||
)
|
||||
}
|
||||
}
|
||||
impl Modifier {
|
||||
/// RuleBlockEntityModifier.apply: the block entity the output gets.
|
||||
fn apply(&self, nbt: Option<&Compound>, random: &mut impl ProcessorRandom) -> Option<Compound> {
|
||||
match self {
|
||||
Self::Passthrough => nbt.cloned(),
|
||||
Self::Clear => Some(Compound::new()),
|
||||
Self::AppendLoot(table) => {
|
||||
let mut nbt = nbt.cloned().unwrap_or_default();
|
||||
nbt.insert("LootTable".into(), Tag::String(table.as_str().into()));
|
||||
nbt.insert("LootTableSeed".into(), Tag::Long(random.long()));
|
||||
Some(nbt)
|
||||
}
|
||||
Self::AppendStatic(data) => Some(edited(nbt, &[], data)),
|
||||
Self::Edit { remove, data } => Some(edited(nbt, remove, data)),
|
||||
}
|
||||
}
|
||||
}
|
||||
/// A block entity with `remove`'s keys taken out and `data` merged in
|
||||
/// (append_static is the one with nothing to remove).
|
||||
fn edited(nbt: Option<&Compound>, remove: &[String], data: &Compound) -> Compound {
|
||||
@@ -292,17 +309,21 @@ pub enum Processor {
|
||||
SpawnerMobs(Box<SpawnerMobs>),
|
||||
Pick(Box<Pick>),
|
||||
CountCap(Box<CountCap>),
|
||||
/// `horizon:block_swap` (Lithostitched's `block_swap`): blocks by name
|
||||
/// become others, keeping the properties both have.
|
||||
/// `lithostitched:block_swap`: blocks by name become others, keeping
|
||||
/// the properties both have (a block the game lacks is left alone).
|
||||
BlockSwap(std::collections::BTreeMap<String, String>),
|
||||
/// `horizon:apply_random` (Lithostitched's `apply_random`): a processor
|
||||
/// list drawn by weight runs on the block.
|
||||
ApplyRandom(Box<lithostitched::ApplyRandom>),
|
||||
/// `horizon:condition` (Lithostitched's `condition`): `then` or `else`
|
||||
/// `lithostitched:apply_random`: a processor list drawn by weight runs
|
||||
/// on the block.
|
||||
ApplyRandom(Box<litho::ApplyRandom>),
|
||||
/// `lithostitched:reference`: the named lists run on the block in turn.
|
||||
Reference(Vec<ProcessorList>),
|
||||
/// `lithostitched:discard_input`: the world's block stays.
|
||||
DiscardInput,
|
||||
/// `lithostitched:condition`: `then` or `else`
|
||||
/// runs on the block, by a test of it.
|
||||
Condition(Box<lithostitched::Conditional>),
|
||||
/// `horizon:set_block` (Lithostitched's `set_block`).
|
||||
SetBlock(Box<lithostitched::SetBlock>),
|
||||
Condition(Box<litho::Conditional>),
|
||||
/// `lithostitched:set_block`: the block from a state provider.
|
||||
SetBlock(Box<litho::SetBlock>),
|
||||
/// `horizon:pillar` (Repurposed Structures' and Moog's pillars): a
|
||||
/// trigger block starts a column down to the ground.
|
||||
Pillar(Box<pillars::Pillar>),
|
||||
@@ -786,7 +807,7 @@ impl Processor {
|
||||
})?))
|
||||
}
|
||||
"horizon:pick" => Self::Pick(Box::new(Pick::decode(value, state)?)),
|
||||
"horizon:block_swap" => Self::BlockSwap(
|
||||
"lithostitched:block_swap" => Self::BlockSwap(
|
||||
value["blocks"]
|
||||
.as_object()
|
||||
.ok_or(DecodeError::Field("blocks"))?
|
||||
@@ -801,12 +822,16 @@ impl Processor {
|
||||
.collect::<Result<_, DecodeError>>()?,
|
||||
),
|
||||
"horizon:count_cap" => Self::CountCap(Box::new(CountCap::decode(value, state)?)),
|
||||
"horizon:apply_random" => Self::ApplyRandom(Box::new(
|
||||
lithostitched::ApplyRandom::decode(value, resources, bindings)?,
|
||||
"lithostitched:apply_random" => Self::ApplyRandom(Box::new(
|
||||
litho::ApplyRandom::decode(value, resources, bindings)?,
|
||||
)),
|
||||
"horizon:set_block" => {
|
||||
Self::SetBlock(Box::new(lithostitched::SetBlock::decode(value, state)?))
|
||||
"lithostitched:set_block" => {
|
||||
Self::SetBlock(Box::new(litho::SetBlock::decode(value, state)?))
|
||||
}
|
||||
"lithostitched:reference" => {
|
||||
Self::Reference(litho::reference(value, resources, bindings)?)
|
||||
}
|
||||
"lithostitched:discard_input" => Self::DiscardInput,
|
||||
"horizon:pillar" => Self::Pillar(Box::new(pillars::Pillar::decode(
|
||||
value, resources, bindings, state,
|
||||
)?)),
|
||||
@@ -834,7 +859,7 @@ impl Processor {
|
||||
"horizon:keep_world_block" => {
|
||||
Self::KeepWorldBlock(Box::new(sea_level::KeepWorldBlock::decode(value)?))
|
||||
}
|
||||
"horizon:condition" => Self::Condition(Box::new(lithostitched::Conditional::decode(
|
||||
"lithostitched:condition" => Self::Condition(Box::new(litho::Conditional::decode(
|
||||
value, resources, bindings,
|
||||
)?)),
|
||||
_ => return Err(DecodeError::Field("structure processor type")),
|
||||
@@ -1115,24 +1140,10 @@ fn process_block<W: PlacementContext>(
|
||||
if !position_ok {
|
||||
continue;
|
||||
}
|
||||
let nbt = match &rule.modifier {
|
||||
Modifier::Passthrough => info.nbt.clone(),
|
||||
Modifier::Clear => Some(Compound::new()),
|
||||
Modifier::AppendLoot(table) => {
|
||||
let mut nbt = info.nbt.clone().unwrap_or_default();
|
||||
nbt.insert("LootTable".into(), Tag::String(table.as_str().into()));
|
||||
nbt.insert("LootTableSeed".into(), Tag::Long(random.next_long()));
|
||||
Some(nbt)
|
||||
}
|
||||
Modifier::AppendStatic(data) => Some(edited(info.nbt.as_ref(), &[], data)),
|
||||
Modifier::Edit { remove, data } => {
|
||||
Some(edited(info.nbt.as_ref(), remove, data))
|
||||
}
|
||||
};
|
||||
return Ok(Some(BlockInfo {
|
||||
pos: info.pos,
|
||||
state: rule.output,
|
||||
nbt,
|
||||
nbt: rule.modifier.apply(info.nbt.as_ref(), &mut random),
|
||||
}));
|
||||
}
|
||||
Some(info)
|
||||
@@ -1165,8 +1176,7 @@ fn process_block<W: PlacementContext>(
|
||||
false => Some(info),
|
||||
},
|
||||
Processor::ApplyRandom(apply) => {
|
||||
let seed = world.world_seed()?;
|
||||
let mut random = apply.random.create(seed, position, reference, info.pos);
|
||||
let mut random = apply.draws.random(world.world_seed()?, position, info.pos);
|
||||
match apply.pick(&mut random) {
|
||||
Some(list) => {
|
||||
return process_list(
|
||||
@@ -1176,21 +1186,34 @@ fn process_block<W: PlacementContext>(
|
||||
None => Some(info),
|
||||
}
|
||||
}
|
||||
Processor::Reference(lists) => {
|
||||
let mut current = info;
|
||||
for list in lists {
|
||||
match process_list(
|
||||
list, world, resources, position, reference, relative, current, settings,
|
||||
)? {
|
||||
Some(next) => current = next,
|
||||
None => return Ok(None),
|
||||
}
|
||||
}
|
||||
Some(current)
|
||||
}
|
||||
Processor::DiscardInput => None,
|
||||
Processor::SetBlock(set) => {
|
||||
let seed = world.world_seed()?;
|
||||
let state = set.state(seed, position, reference, info.pos);
|
||||
let state = match set.preserves() {
|
||||
let mut random = set.draws.random(world.world_seed()?, position, info.pos);
|
||||
let state = set.state(&mut random);
|
||||
let state = match set.preserve {
|
||||
true => registry
|
||||
.state(state)
|
||||
.and_then(|s| with_properties_of(registry, &s.name, info.state))
|
||||
.unwrap_or(state),
|
||||
false => state,
|
||||
};
|
||||
Some(BlockInfo { state, ..info })
|
||||
let nbt = set.modifier.apply(info.nbt.as_ref(), &mut random);
|
||||
Some(BlockInfo { state, nbt, ..info })
|
||||
}
|
||||
Processor::Condition(c) => {
|
||||
let seed = world.world_seed()?;
|
||||
let mut random = c.random.create(seed, position, reference, info.pos);
|
||||
let mut random = c.draws.random(world.world_seed()?, position, info.pos);
|
||||
let location = world.block_state(info.pos)?;
|
||||
let passed = c
|
||||
.condition
|
||||
|
||||
@@ -0,0 +1,841 @@
|
||||
//! Lithostitched's processors (spec-lithostitched §5), read as its data
|
||||
//! writes them: `lithostitched:block_swap` (in `processor.rs`), `reference`,
|
||||
//! `apply_random`, `condition`, `set_block` and `discard_input`.
|
||||
//!
|
||||
//! The draws of `random_chance`, `apply_random` and `set_block` follow
|
||||
//! Lithostitched's `random_mode` (per block or per piece), but its seeding is
|
||||
//! not known (OPEN-L6): a positional random of the world seed, the block's or
|
||||
//! the piece's position and the processor itself, so the shares match while
|
||||
//! the blocks chosen do not.
|
||||
use super::{BlockStateId, DecodeError, Modifier, ProcessorList, ProcessorRandom};
|
||||
use crate::worldgen::{block_feature::FeatureBlockBindings, structure::StructureResources};
|
||||
use horizon_core::{
|
||||
position::BlockPos,
|
||||
random::{LegacyRandom, position_seed},
|
||||
};
|
||||
use serde_json::Value;
|
||||
use std::collections::BTreeSet;
|
||||
|
||||
/// `random_mode` (`condition`, `set_block`) or `mode` (`apply_random`).
|
||||
#[derive(Clone, Copy, Debug)]
|
||||
pub(super) struct Draws {
|
||||
per_piece: bool,
|
||||
/// The processor's own salt, so two processors on a block draw apart.
|
||||
salt: i64,
|
||||
}
|
||||
impl Draws {
|
||||
fn decode(mode: Option<&Value>, processor: &Value) -> Result<Self, DecodeError> {
|
||||
let per_piece = match mode.and_then(Value::as_str) {
|
||||
None | Some("per_block") => false,
|
||||
Some("per_piece") => true,
|
||||
_ => return Err(DecodeError::Field("random_mode")),
|
||||
};
|
||||
// FNV-1a over the processor's JSON: the same in every run.
|
||||
let salt = (processor.to_string().bytes()).fold(0xcbf2_9ce4_8422_2325_u64, |h, b| {
|
||||
(h ^ u64::from(b)).wrapping_mul(0x0100_0000_01b3)
|
||||
}) as i64;
|
||||
Ok(Self { per_piece, salt })
|
||||
}
|
||||
/// The random for the block at `pos` of the piece at `piece`.
|
||||
pub(super) fn random(self, world_seed: i64, piece: [i32; 3], pos: [i32; 3]) -> LegacyRandom {
|
||||
let [x, y, z] = if self.per_piece { piece } else { pos };
|
||||
LegacyRandom::new(world_seed ^ self.salt ^ position_seed(BlockPos::new(x, y, z)))
|
||||
}
|
||||
}
|
||||
|
||||
/// A processor or a list of them (`then`, `else`, `apply_random`'s data):
|
||||
/// a list holder (`ProcessorList::decode`), or one processor object.
|
||||
fn processors(
|
||||
value: &Value,
|
||||
resources: &StructureResources,
|
||||
bindings: &FeatureBlockBindings<'_>,
|
||||
) -> Result<ProcessorList, DecodeError> {
|
||||
let one = value.get("processor_type").is_some();
|
||||
let holder = if one {
|
||||
Value::Array(vec![value.clone()])
|
||||
} else {
|
||||
value.clone()
|
||||
};
|
||||
ProcessorList::decode(&holder.to_string(), resources, bindings)
|
||||
}
|
||||
|
||||
/// `reference`: the named lists, run in turn on the block.
|
||||
pub(super) fn reference(
|
||||
value: &Value,
|
||||
resources: &StructureResources,
|
||||
bindings: &FeatureBlockBindings<'_>,
|
||||
) -> Result<Vec<ProcessorList>, DecodeError> {
|
||||
let names = match &value["processor_lists"] {
|
||||
Value::Array(a) => a.clone(),
|
||||
other => vec![other.clone()],
|
||||
};
|
||||
(names.iter())
|
||||
.map(|name| match name.as_str() {
|
||||
Some(n) if n.starts_with('#') => Err(DecodeError::Field("processor list tag")),
|
||||
Some(_) => ProcessorList::decode(&name.to_string(), resources, bindings),
|
||||
None => Err(DecodeError::Field("processor_lists")),
|
||||
})
|
||||
.collect()
|
||||
}
|
||||
|
||||
/// `apply_random`: one list drawn by weight runs on the block.
|
||||
#[derive(Clone, Debug)]
|
||||
pub struct ApplyRandom {
|
||||
pub(super) draws: Draws,
|
||||
lists: Vec<(i32, ProcessorList)>,
|
||||
total: i32,
|
||||
}
|
||||
impl ApplyRandom {
|
||||
pub(super) fn decode(
|
||||
value: &Value,
|
||||
resources: &StructureResources,
|
||||
bindings: &FeatureBlockBindings<'_>,
|
||||
) -> Result<Self, DecodeError> {
|
||||
let entries = value["processor_lists"]
|
||||
.as_array()
|
||||
.ok_or(DecodeError::Field("apply_random processor_lists"))?;
|
||||
let lists = (entries.iter())
|
||||
.map(|e| match e.get("data") {
|
||||
Some(data) => {
|
||||
let weight = e["weight"]
|
||||
.as_i64()
|
||||
.unwrap_or(1)
|
||||
.clamp(0, i64::from(i32::MAX));
|
||||
Ok((weight as i32, processors(data, resources, bindings)?))
|
||||
}
|
||||
None => Ok((1, processors(e, resources, bindings)?)),
|
||||
})
|
||||
.collect::<Result<Vec<_>, DecodeError>>()?;
|
||||
let total = lists
|
||||
.iter()
|
||||
.map(|(w, _)| *w)
|
||||
.fold(0i32, i32::saturating_add);
|
||||
Ok(Self {
|
||||
draws: Draws::decode(value.get("mode"), value)?,
|
||||
lists,
|
||||
total,
|
||||
})
|
||||
}
|
||||
/// The list drawn: one bounded draw over the total weight.
|
||||
pub(super) fn pick(&self, random: &mut impl ProcessorRandom) -> Option<&ProcessorList> {
|
||||
if self.total <= 0 {
|
||||
return None;
|
||||
}
|
||||
let mut at = random.int(self.total);
|
||||
for (weight, list) in &self.lists {
|
||||
at -= weight;
|
||||
if at < 0 {
|
||||
return Some(list);
|
||||
}
|
||||
}
|
||||
None
|
||||
}
|
||||
}
|
||||
|
||||
/// Lithostitched's processor conditions.
|
||||
#[derive(Clone, Debug)]
|
||||
pub(super) enum Condition {
|
||||
True,
|
||||
AllOf(Vec<Condition>),
|
||||
AnyOf(Vec<Condition>),
|
||||
Not(Box<Condition>),
|
||||
Chance(f32),
|
||||
/// `matching_blocks`: the template's block (`input`) or the world's
|
||||
/// (`location`) is one of `blocks`, with `properties`.
|
||||
Matching {
|
||||
blocks: BTreeSet<String>,
|
||||
properties: Vec<(String, String)>,
|
||||
location: bool,
|
||||
},
|
||||
}
|
||||
impl Condition {
|
||||
/// One condition, or a list of them that must all pass (`if_true`).
|
||||
pub(super) fn decode(
|
||||
value: &Value,
|
||||
bindings: &FeatureBlockBindings<'_>,
|
||||
) -> Result<Self, DecodeError> {
|
||||
let list = |v: &Value| -> Result<Vec<Self>, DecodeError> {
|
||||
(v.as_array().ok_or(DecodeError::Field("conditions"))?.iter())
|
||||
.map(|c| Self::decode(c, bindings))
|
||||
.collect()
|
||||
};
|
||||
if value.is_array() {
|
||||
return Ok(Self::AllOf(list(value)?));
|
||||
}
|
||||
let kind = value["type"].as_str().unwrap_or_default();
|
||||
Ok(match crate::worldgen::tags::identifier(kind)?.as_str() {
|
||||
"lithostitched:true" => Self::True,
|
||||
"lithostitched:all_of" => Self::AllOf(list(&value["conditions"])?),
|
||||
"lithostitched:any_of" => Self::AnyOf(list(&value["conditions"])?),
|
||||
"lithostitched:not" => {
|
||||
Self::Not(Box::new(Self::decode(&value["condition"], bindings)?))
|
||||
}
|
||||
"lithostitched:random_chance" => Self::Chance(
|
||||
value["chance"]
|
||||
.as_f64()
|
||||
.ok_or(DecodeError::Field("random_chance chance"))? as f32,
|
||||
),
|
||||
"lithostitched:matching_blocks" => Self::Matching {
|
||||
blocks: blocks(&value["blocks"], bindings)?,
|
||||
properties: (value
|
||||
.get("properties")
|
||||
.and_then(Value::as_object)
|
||||
.into_iter())
|
||||
.flatten()
|
||||
.map(|(k, v)| {
|
||||
(
|
||||
k.clone(),
|
||||
v.as_str().map_or_else(|| v.to_string(), str::to_owned),
|
||||
)
|
||||
})
|
||||
.collect(),
|
||||
location: match value.get("match_type").and_then(Value::as_str) {
|
||||
None | Some("input") => false,
|
||||
Some("location") => true,
|
||||
_ => return Err(DecodeError::Field("matching_blocks match_type")),
|
||||
},
|
||||
},
|
||||
_ => return Err(DecodeError::Field("lithostitched condition type")),
|
||||
})
|
||||
}
|
||||
pub(super) fn test(
|
||||
&self,
|
||||
input: BlockStateId,
|
||||
location: BlockStateId,
|
||||
registry: &crate::registry::BlockRegistry,
|
||||
random: &mut impl ProcessorRandom,
|
||||
) -> bool {
|
||||
match self {
|
||||
Self::True => true,
|
||||
Self::AllOf(all) => all
|
||||
.iter()
|
||||
.all(|c| c.test(input, location, registry, random)),
|
||||
Self::AnyOf(any) => any
|
||||
.iter()
|
||||
.any(|c| c.test(input, location, registry, random)),
|
||||
Self::Not(c) => !c.test(input, location, registry, random),
|
||||
Self::Chance(chance) => random.float() < *chance,
|
||||
Self::Matching {
|
||||
blocks,
|
||||
properties,
|
||||
location: at_location,
|
||||
} => {
|
||||
let Some(state) = registry.state(if *at_location { location } else { input })
|
||||
else {
|
||||
return false;
|
||||
};
|
||||
blocks.contains(&state.name)
|
||||
&& (properties.iter()).all(|(k, v)| state.properties.get(k) == Some(v))
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
/// A block set (an id, a list, `#tag`) by block name. Blocks the game does
|
||||
/// not have are left out: no template block can be one.
|
||||
fn blocks(
|
||||
value: &Value,
|
||||
bindings: &FeatureBlockBindings<'_>,
|
||||
) -> Result<BTreeSet<String>, DecodeError> {
|
||||
let names: Vec<&str> = match value {
|
||||
Value::String(s) => vec![s.as_str()],
|
||||
Value::Array(a) => a.iter().filter_map(Value::as_str).collect(),
|
||||
_ => return Err(DecodeError::Field("matching_blocks blocks")),
|
||||
};
|
||||
let registry = bindings.registry();
|
||||
let mut out = BTreeSet::new();
|
||||
for name in names {
|
||||
match name.strip_prefix('#') {
|
||||
Some(tag) => {
|
||||
let tag = crate::worldgen::tags::identifier(tag)?;
|
||||
let states = bindings.tags.get(&tag).into_iter().flat_map(|s| s.iter());
|
||||
out.extend(states.filter_map(|s| Some(registry.state(*s)?.name.clone())));
|
||||
}
|
||||
None => {
|
||||
out.insert(crate::worldgen::tags::identifier(name)?.to_string());
|
||||
}
|
||||
}
|
||||
}
|
||||
Ok(out)
|
||||
}
|
||||
|
||||
/// `condition`: `then` when the conditions pass, else `else` (none: the
|
||||
/// block as it is).
|
||||
#[derive(Clone, Debug)]
|
||||
pub struct Conditional {
|
||||
pub(super) draws: Draws,
|
||||
pub(super) condition: Condition,
|
||||
pub(super) then: ProcessorList,
|
||||
pub(super) otherwise: ProcessorList,
|
||||
}
|
||||
impl Conditional {
|
||||
pub(super) fn decode(
|
||||
value: &Value,
|
||||
resources: &StructureResources,
|
||||
bindings: &FeatureBlockBindings<'_>,
|
||||
) -> Result<Self, DecodeError> {
|
||||
let branch = |key| match value.get(key) {
|
||||
Some(v) => processors(v, resources, bindings),
|
||||
None => Ok(ProcessorList(Vec::new())),
|
||||
};
|
||||
Ok(Self {
|
||||
draws: Draws::decode(value.get("random_mode"), value)?,
|
||||
condition: Condition::decode(&value["if_true"], bindings)?,
|
||||
then: branch("then")?,
|
||||
otherwise: branch("else")?,
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
/// `set_block`: the block from a state provider (simple or weighted).
|
||||
#[derive(Clone, Debug)]
|
||||
pub struct SetBlock {
|
||||
pub(super) draws: Draws,
|
||||
states: Vec<(i32, BlockStateId)>,
|
||||
total: i32,
|
||||
/// `preserve_state` (true by default): the template block's properties
|
||||
/// the new block has too are kept.
|
||||
pub(super) preserve: bool,
|
||||
pub(super) modifier: Modifier,
|
||||
}
|
||||
impl SetBlock {
|
||||
pub(super) fn decode(
|
||||
value: &Value,
|
||||
state: impl Fn(&Value) -> Result<BlockStateId, DecodeError>,
|
||||
) -> Result<Self, DecodeError> {
|
||||
let provider = &value["state_provider"];
|
||||
let kind = provider["type"].as_str().unwrap_or_default();
|
||||
let states = match crate::worldgen::tags::identifier(kind)?.as_str() {
|
||||
"minecraft:simple_state_provider" => vec![(1, state(&provider["state"])?)],
|
||||
"minecraft:weighted_state_provider" => (provider["entries"].as_array().into_iter())
|
||||
.flatten()
|
||||
.map(|e| {
|
||||
Ok((
|
||||
e["weight"].as_i64().unwrap_or(1).clamp(0, 1 << 30) as i32,
|
||||
state(&e["data"])?,
|
||||
))
|
||||
})
|
||||
.collect::<Result<_, DecodeError>>()?,
|
||||
_ => return Err(DecodeError::Field("set_block state_provider")),
|
||||
};
|
||||
let total = states.iter().map(|(w, _)| *w).sum();
|
||||
if total <= 0 {
|
||||
return Err(DecodeError::Field("set_block state_provider"));
|
||||
}
|
||||
Ok(Self {
|
||||
draws: Draws::decode(value.get("random_mode"), value)?,
|
||||
states,
|
||||
total,
|
||||
preserve: value
|
||||
.get("preserve_state")
|
||||
.and_then(Value::as_bool)
|
||||
.unwrap_or(true),
|
||||
modifier: Modifier::decode(value.get("block_entity_modifier"))?,
|
||||
})
|
||||
}
|
||||
/// The provider's state: WeightedList.getRandom, one bounded draw.
|
||||
pub(super) fn state(&self, random: &mut impl ProcessorRandom) -> BlockStateId {
|
||||
let mut at = random.int(self.total);
|
||||
for (weight, state) in &self.states {
|
||||
at -= weight;
|
||||
if at < 0 {
|
||||
return *state;
|
||||
}
|
||||
}
|
||||
self.states[0].1
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::super::{BlockInfo, PlaceSettings, ProcessorList, process_list};
|
||||
use crate::{
|
||||
heightmap::HeightmapType,
|
||||
nbt::{JavaString, Tag},
|
||||
registry::{BlockRegistry, BlockStateId},
|
||||
worldgen::{
|
||||
anchor::WorldGenerationContext,
|
||||
block_feature::FeatureBlockBindings,
|
||||
placement::{PlacementContext, PlacementQueryError},
|
||||
structure::{
|
||||
Rotation, StateTransforms, StructureResources, template::parse_state_string,
|
||||
},
|
||||
},
|
||||
};
|
||||
use serde_json::{Value, json};
|
||||
use std::collections::{BTreeMap, BTreeSet};
|
||||
|
||||
/// Every combination of `properties`' values, the first one the default.
|
||||
fn states(name: &str, properties: &[(&str, &[&str])]) -> Vec<Value> {
|
||||
let mut out = vec![serde_json::Map::new()];
|
||||
for (key, values) in properties {
|
||||
out = (out.iter())
|
||||
.flat_map(|o| {
|
||||
values.iter().map(move |v| {
|
||||
let mut o = o.clone();
|
||||
o.insert((*key).into(), (*v).into());
|
||||
o
|
||||
})
|
||||
})
|
||||
.collect();
|
||||
}
|
||||
(out.into_iter())
|
||||
.map(|p| json!([name, name.ends_with("air"), false, "", {"id": name, "properties": p}]))
|
||||
.collect()
|
||||
}
|
||||
|
||||
/// A registry of the blocks CTOV's lists and the probe pack use.
|
||||
fn registry() -> &'static BlockRegistry {
|
||||
let ages: Vec<String> = (0..8).map(|a| a.to_string()).collect();
|
||||
let ages: Vec<&str> = ages.iter().map(String::as_str).collect();
|
||||
let levels: Vec<String> = (0..16).map(|a| a.to_string()).collect();
|
||||
let levels: Vec<&str> = levels.iter().map(String::as_str).collect();
|
||||
let water = [("level", &levels[..])];
|
||||
let stairs: &[(&str, &[&str])] =
|
||||
&[("facing", &["north", "east"]), ("half", &["bottom", "top"])];
|
||||
let blocks: Vec<(&str, &[(&str, &[&str])])> = vec![
|
||||
("minecraft:air", &[]),
|
||||
("minecraft:cave_air", &[]),
|
||||
("minecraft:void_air", &[]),
|
||||
("minecraft:lava", &water),
|
||||
("minecraft:cobblestone", &[]),
|
||||
("minecraft:blackstone", &[]),
|
||||
("minecraft:deepslate", &[]),
|
||||
("minecraft:water", &water),
|
||||
("minecraft:spruce_planks", &[]),
|
||||
("minecraft:chest", &[]),
|
||||
("minecraft:oak_log", &[("axis", &["y", "x"])]),
|
||||
("minecraft:stripped_cherry_log", &[("axis", &["y", "x"])]),
|
||||
("minecraft:oak_stairs", stairs),
|
||||
("minecraft:warped_stairs", stairs),
|
||||
];
|
||||
let wheat = [("age", &ages[..])];
|
||||
let beetroots = [("age", &ages[..4])];
|
||||
let mut rows = Vec::new();
|
||||
let mut defaults = BTreeMap::new();
|
||||
let crops: [(&str, &[(&str, &[&str])]); 3] = [
|
||||
("minecraft:wheat", &wheat),
|
||||
("minecraft:carrots", &wheat),
|
||||
("minecraft:beetroots", &beetroots),
|
||||
];
|
||||
for (name, properties) in blocks.into_iter().chain(crops) {
|
||||
defaults.insert(name, rows.len());
|
||||
rows.extend(states(name, properties));
|
||||
}
|
||||
let facts = json!({"states": rows, "defaults": defaults});
|
||||
let registry = BlockRegistry::from_facts_json(facts.to_string().as_bytes()).unwrap();
|
||||
Box::leak(Box::new(registry))
|
||||
}
|
||||
|
||||
/// The world a piece is placed in: one block everywhere.
|
||||
struct World {
|
||||
seed: i64,
|
||||
block: BlockStateId,
|
||||
}
|
||||
impl PlacementContext for World {
|
||||
fn world_seed(&mut self) -> Result<i64, PlacementQueryError> {
|
||||
Ok(self.seed)
|
||||
}
|
||||
fn block_state(&mut self, _: [i32; 3]) -> Result<BlockStateId, PlacementQueryError> {
|
||||
Ok(self.block)
|
||||
}
|
||||
fn generation(&self) -> WorldGenerationContext {
|
||||
WorldGenerationContext::new(-64, 384, 63)
|
||||
}
|
||||
fn min_y(&mut self) -> Result<i32, PlacementQueryError> {
|
||||
Ok(-64)
|
||||
}
|
||||
fn height(&mut self, _: HeightmapType, _: i32, _: i32) -> Result<i32, PlacementQueryError> {
|
||||
Err(PlacementQueryError::Unavailable)
|
||||
}
|
||||
}
|
||||
|
||||
struct Lists {
|
||||
registry: &'static BlockRegistry,
|
||||
resources: StructureResources,
|
||||
}
|
||||
impl Lists {
|
||||
fn new(lists: &[(&str, Value)]) -> Self {
|
||||
let registry = registry();
|
||||
let lists = (lists.iter())
|
||||
.map(|(id, list)| ((*id).to_owned(), list.to_string()))
|
||||
.collect();
|
||||
let resources = StructureResources::new(
|
||||
registry,
|
||||
StateTransforms::default(),
|
||||
std::path::Path::new("/nonexistent"),
|
||||
lists,
|
||||
&BTreeMap::new(),
|
||||
);
|
||||
Self {
|
||||
registry,
|
||||
resources,
|
||||
}
|
||||
}
|
||||
fn id(&self, state: &str) -> BlockStateId {
|
||||
parse_state_string(self.registry, state).unwrap()
|
||||
}
|
||||
fn decode(&self, processors: Value) -> Result<ProcessorList, crate::worldgen::DecodeError> {
|
||||
let bindings = FeatureBlockBindings::new(self.registry, BTreeSet::new()).unwrap();
|
||||
ProcessorList::decode(&processors.to_string(), &self.resources, &bindings)
|
||||
}
|
||||
/// The block the list makes of template block `state` at `pos` of the
|
||||
/// piece at `piece`, in a world of `world`: None when it is not placed.
|
||||
fn run(
|
||||
&self,
|
||||
list: &ProcessorList,
|
||||
world: (i64, &str),
|
||||
piece: [i32; 3],
|
||||
pos: [i32; 3],
|
||||
state: &str,
|
||||
) -> Option<BlockInfo> {
|
||||
let mut world = World {
|
||||
seed: world.0,
|
||||
block: self.id(world.1),
|
||||
};
|
||||
let info = BlockInfo {
|
||||
pos,
|
||||
state: self.id(state),
|
||||
nbt: None,
|
||||
};
|
||||
let mut settings = PlaceSettings::new(Rotation::None);
|
||||
process_list(
|
||||
list,
|
||||
&mut world,
|
||||
&self.resources,
|
||||
piece,
|
||||
piece,
|
||||
[0; 3],
|
||||
info,
|
||||
&mut settings,
|
||||
)
|
||||
.unwrap()
|
||||
}
|
||||
fn name(&self, info: Option<BlockInfo>) -> String {
|
||||
match info {
|
||||
None => "none".into(),
|
||||
Some(info) => {
|
||||
let s = self.registry.state(info.state).unwrap();
|
||||
let props: Vec<String> = s
|
||||
.properties
|
||||
.iter()
|
||||
.map(|(k, v)| format!("{k}={v}"))
|
||||
.collect();
|
||||
match props.is_empty() {
|
||||
true => s.name.clone(),
|
||||
false => format!("{}[{}]", s.name, props.join(",")),
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
/// `name(run(...))` for one template block in an air world of seed 0.
|
||||
fn out(&self, list: &ProcessorList, state: &str) -> String {
|
||||
self.name(self.run(list, (0, "minecraft:air"), [0; 3], [0; 3], state))
|
||||
}
|
||||
}
|
||||
|
||||
fn swap(blocks: Value) -> Value {
|
||||
json!({"processor_type": "lithostitched:block_swap", "blocks": blocks})
|
||||
}
|
||||
fn set_block(provider: Value) -> Value {
|
||||
json!({"processor_type": "lithostitched:set_block", "state_provider": provider})
|
||||
}
|
||||
fn simple(name: &str) -> Value {
|
||||
json!({"type": "minecraft:simple_state_provider", "state": {"id": name}})
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn block_swap_keeps_the_properties_the_new_block_can_have() {
|
||||
let t = Lists::new(&[]);
|
||||
let list = t
|
||||
.decode(json!([swap(json!({
|
||||
"minecraft:wheat": "minecraft:carrots",
|
||||
"oak_stairs": "minecraft:warped_stairs",
|
||||
"minecraft:cobblestone": "natures_spirit:missing"}))]))
|
||||
.unwrap();
|
||||
assert_eq!(
|
||||
t.out(&list, "minecraft:wheat[age=7]"),
|
||||
"minecraft:carrots[age=7]"
|
||||
);
|
||||
assert_eq!(
|
||||
t.out(&list, "minecraft:oak_stairs[facing=east,half=top]"),
|
||||
"minecraft:warped_stairs[facing=east,half=top]"
|
||||
);
|
||||
// A block the game lacks leaves the template's; others pass.
|
||||
assert_eq!(
|
||||
t.out(&list, "minecraft:cobblestone"),
|
||||
"minecraft:cobblestone"
|
||||
);
|
||||
assert_eq!(
|
||||
t.out(&list, "minecraft:oak_log[axis=x]"),
|
||||
"minecraft:oak_log[axis=x]"
|
||||
);
|
||||
// Beetroots' age stops at 3: ripe wheat gives the default (spec-ctov §4).
|
||||
let beet = t
|
||||
.decode(json!([swap(
|
||||
json!({"minecraft:wheat": "minecraft:beetroots"})
|
||||
)]))
|
||||
.unwrap();
|
||||
assert_eq!(
|
||||
t.out(&beet, "minecraft:wheat[age=7]"),
|
||||
"minecraft:beetroots[age=0]"
|
||||
);
|
||||
assert_eq!(
|
||||
t.out(&beet, "minecraft:wheat[age=2]"),
|
||||
"minecraft:beetroots[age=2]"
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn references_run_the_named_lists_in_turn() {
|
||||
let t = Lists::new(&[
|
||||
(
|
||||
"t:logs",
|
||||
json!({"processors": [swap(json!({"minecraft:oak_log": "minecraft:stripped_cherry_log"}))]}),
|
||||
),
|
||||
(
|
||||
"t:stone",
|
||||
json!([swap(
|
||||
json!({"minecraft:stripped_cherry_log": "minecraft:cobblestone"})
|
||||
)]),
|
||||
),
|
||||
(
|
||||
"t:discard",
|
||||
json!([{"processor_type": "lithostitched:discard_input"}]),
|
||||
),
|
||||
]);
|
||||
let reference = |lists: Value| json!([{"processor_type": "lithostitched:reference", "processor_lists": lists}]);
|
||||
let one = t.decode(reference(json!("t:logs"))).unwrap();
|
||||
assert_eq!(
|
||||
t.out(&one, "minecraft:oak_log[axis=x]"),
|
||||
"minecraft:stripped_cherry_log[axis=x]"
|
||||
);
|
||||
let both = t.decode(reference(json!(["t:logs", "t:stone"]))).unwrap();
|
||||
assert_eq!(t.out(&both, "minecraft:oak_log"), "minecraft:cobblestone");
|
||||
let reversed = t.decode(reference(json!(["t:stone", "t:logs"]))).unwrap();
|
||||
assert_eq!(
|
||||
t.out(&reversed, "minecraft:oak_log"),
|
||||
"minecraft:stripped_cherry_log[axis=y]"
|
||||
);
|
||||
// discard_input: the template block is not placed, and the lists after it do not run.
|
||||
let discard = t.decode(reference(json!(["t:discard", "t:logs"]))).unwrap();
|
||||
assert_eq!(t.out(&discard, "minecraft:oak_log"), "none");
|
||||
// The game has no processor list tags; unknown lists are errors.
|
||||
assert!(t.decode(reference(json!(["#t:palettes"]))).is_err());
|
||||
assert!(t.decode(reference(json!("t:missing"))).is_err());
|
||||
}
|
||||
|
||||
/// The probe pack's nested condition (spec-lithostitched §7.3): template
|
||||
/// cobblestone becomes blackstone or deepslate, half each.
|
||||
#[test]
|
||||
fn conditions_run_then_or_else() {
|
||||
let t = Lists::new(&[]);
|
||||
let inner = json!({"processor_type": "lithostitched:condition", "random_mode": "per_block",
|
||||
"if_true": {"type": "lithostitched:random_chance", "chance": 0.5},
|
||||
"then": set_block(simple("minecraft:blackstone")),
|
||||
"else": [set_block(simple("minecraft:deepslate"))]});
|
||||
let list = t
|
||||
.decode(json!([{"processor_type": "lithostitched:condition",
|
||||
"if_true": [{"type": "lithostitched:matching_blocks", "blocks": "minecraft:cobblestone"}],
|
||||
"then": [inner]}]))
|
||||
.unwrap();
|
||||
let mut counts = BTreeMap::<String, u32>::new();
|
||||
for i in 0..4000 {
|
||||
let out = t.run(
|
||||
&list,
|
||||
(1234, "minecraft:air"),
|
||||
[0; 3],
|
||||
[i % 64, i / 64, 7],
|
||||
"minecraft:cobblestone",
|
||||
);
|
||||
*counts.entry(t.name(out)).or_default() += 1;
|
||||
}
|
||||
assert_eq!(counts.len(), 2, "{counts:?}");
|
||||
assert!(
|
||||
(1850..2150).contains(&counts["minecraft:blackstone"]),
|
||||
"{counts:?}"
|
||||
);
|
||||
// Not cobblestone, and no `else`: the block as it is.
|
||||
assert_eq!(
|
||||
t.out(&list, "minecraft:oak_log"),
|
||||
"minecraft:oak_log[axis=y]"
|
||||
);
|
||||
|
||||
// `location` tests the world's block, with properties on the input.
|
||||
let water = t
|
||||
.decode(
|
||||
json!([{"processor_type": "lithostitched:condition", "random_mode": "per_piece",
|
||||
"if_true": {"type": "lithostitched:matching_blocks", "blocks": ["minecraft:water"],
|
||||
"match_type": "location"},
|
||||
"then": set_block(simple("minecraft:spruce_planks"))}]),
|
||||
)
|
||||
.unwrap();
|
||||
let at = |world| {
|
||||
t.name(t.run(
|
||||
&water,
|
||||
(0, world),
|
||||
[0; 3],
|
||||
[1, 2, 3],
|
||||
"minecraft:cobblestone",
|
||||
))
|
||||
};
|
||||
assert_eq!(at("minecraft:water"), "minecraft:spruce_planks");
|
||||
assert_eq!(at("minecraft:air"), "minecraft:cobblestone");
|
||||
let ripe = t
|
||||
.decode(json!([{"processor_type": "lithostitched:condition",
|
||||
"if_true": {"type": "lithostitched:all_of", "conditions": [
|
||||
{"type": "lithostitched:true"},
|
||||
{"type": "lithostitched:matching_blocks", "blocks": "minecraft:wheat", "properties": {"age": "7"}},
|
||||
{"type": "lithostitched:not", "condition": {"type": "lithostitched:any_of", "conditions": [
|
||||
{"type": "lithostitched:random_chance", "chance": 0.0},
|
||||
{"type": "lithostitched:matching_blocks", "blocks": "minecraft:water", "match_type": "location"}]}}]},
|
||||
"then": swap(json!({"minecraft:wheat": "minecraft:carrots"}))}]))
|
||||
.unwrap();
|
||||
assert_eq!(
|
||||
t.out(&ripe, "minecraft:wheat[age=7]"),
|
||||
"minecraft:carrots[age=7]"
|
||||
);
|
||||
assert_eq!(
|
||||
t.out(&ripe, "minecraft:wheat[age=6]"),
|
||||
"minecraft:wheat[age=6]"
|
||||
);
|
||||
let bad = json!([{"processor_type": "lithostitched:condition", "random_mode": "per_chunk",
|
||||
"if_true": {"type": "lithostitched:true"}}]);
|
||||
assert!(t.decode(bad).is_err());
|
||||
}
|
||||
|
||||
/// `apply_random` (spec-lithostitched §7.3: crimson 1 : birch 3, one
|
||||
/// choice per piece): here blackstone 1 : deepslate 3.
|
||||
#[test]
|
||||
fn apply_random_draws_per_piece_or_per_block() {
|
||||
let t = Lists::new(&[(
|
||||
"t:deepslate",
|
||||
json!([swap(
|
||||
json!({"minecraft:cobblestone": "minecraft:deepslate"})
|
||||
)]),
|
||||
)]);
|
||||
let random = |mode: &str| {
|
||||
t.decode(json!([{"processor_type": "lithostitched:apply_random", "mode": mode,
|
||||
"processor_lists": [
|
||||
{"weight": 1, "data": [swap(json!({"minecraft:cobblestone": "minecraft:blackstone"}))]},
|
||||
{"weight": 3, "data": "t:deepslate"}]}]))
|
||||
.unwrap()
|
||||
};
|
||||
let (per_piece, per_block) = (random("per_piece"), random("per_block"));
|
||||
let outcomes = |list: &ProcessorList, seed: i64, piece: [i32; 3]| -> Vec<String> {
|
||||
(0..20)
|
||||
.map(|i| {
|
||||
let pos = [piece[0] + i, piece[1], piece[2] + 3 * i];
|
||||
t.name(t.run(
|
||||
list,
|
||||
(seed, "minecraft:air"),
|
||||
piece,
|
||||
pos,
|
||||
"minecraft:cobblestone",
|
||||
))
|
||||
})
|
||||
.collect()
|
||||
};
|
||||
let mut blackstone_pieces = 0;
|
||||
for p in 0..400 {
|
||||
let piece = [16 * p, 70, -40 * p];
|
||||
let blocks = outcomes(&per_piece, 1234, piece);
|
||||
assert!(blocks.iter().all(|b| *b == blocks[0]), "{blocks:?}");
|
||||
blackstone_pieces += u32::from(blocks[0] == "minecraft:blackstone");
|
||||
// The same piece and seed give the same blocks.
|
||||
assert_eq!(outcomes(&per_piece, 1234, piece), blocks);
|
||||
}
|
||||
assert!(
|
||||
(70..130).contains(&blackstone_pieces),
|
||||
"{blackstone_pieces}"
|
||||
);
|
||||
// Per block, one piece mixes both.
|
||||
let mixed: BTreeSet<String> = (0..10)
|
||||
.flat_map(|p| outcomes(&per_block, 1234, [p, 0, 0]))
|
||||
.collect();
|
||||
assert_eq!(mixed.len(), 2, "{mixed:?}");
|
||||
// A plain list: every entry weight 1. An entry list holding nothing is a no-op.
|
||||
let plain = t
|
||||
.decode(
|
||||
json!([{"processor_type": "lithostitched:apply_random", "mode": "per_block",
|
||||
"processor_lists": ["t:deepslate", []]}]),
|
||||
)
|
||||
.unwrap();
|
||||
let seen: BTreeSet<String> = (0..10)
|
||||
.flat_map(|p| outcomes(&plain, 9, [p, 0, 0]))
|
||||
.collect();
|
||||
assert_eq!(
|
||||
seen,
|
||||
BTreeSet::from(["minecraft:cobblestone".into(), "minecraft:deepslate".into()])
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn set_block_runs_its_provider() {
|
||||
let t = Lists::new(&[]);
|
||||
let stairs = "minecraft:oak_stairs[facing=east,half=top]";
|
||||
let warped = |preserve: Value| {
|
||||
let mut p = set_block(simple("minecraft:warped_stairs"));
|
||||
if !preserve.is_null() {
|
||||
p["preserve_state"] = preserve;
|
||||
}
|
||||
t.decode(json!([p])).unwrap()
|
||||
};
|
||||
// preserve_state (true by default) keeps the properties both blocks have.
|
||||
assert_eq!(
|
||||
t.out(&warped(Value::Null), stairs),
|
||||
"minecraft:warped_stairs[facing=east,half=top]"
|
||||
);
|
||||
assert_eq!(
|
||||
t.out(&warped(json!(false)), stairs),
|
||||
"minecraft:warped_stairs[facing=north,half=bottom]"
|
||||
);
|
||||
|
||||
let weighted = t
|
||||
.decode(json!([set_block(
|
||||
json!({"type": "minecraft:weighted_state_provider", "entries": [
|
||||
{"weight": 1, "data": {"id": "minecraft:blackstone"}},
|
||||
{"weight": 3, "data": {"id": "minecraft:deepslate"}}]})
|
||||
)]))
|
||||
.unwrap();
|
||||
let blackstone = (0..2000)
|
||||
.filter(|i| {
|
||||
let out = t.run(
|
||||
&weighted,
|
||||
(42, "minecraft:air"),
|
||||
[0; 3],
|
||||
[*i, 0, -*i],
|
||||
"minecraft:cobblestone",
|
||||
);
|
||||
t.name(out) == "minecraft:blackstone"
|
||||
})
|
||||
.count();
|
||||
assert!((420..580).contains(&blackstone), "{blackstone}");
|
||||
|
||||
// block_entity_modifier gives the output its block entity.
|
||||
let mut loot = set_block(simple("minecraft:chest"));
|
||||
loot["block_entity_modifier"] =
|
||||
json!({"type": "minecraft:append_loot", "loot_table": "t:chests/house"});
|
||||
let out = t
|
||||
.run(
|
||||
&t.decode(json!([loot])).unwrap(),
|
||||
(0, "minecraft:air"),
|
||||
[0; 3],
|
||||
[0; 3],
|
||||
"minecraft:air",
|
||||
)
|
||||
.unwrap();
|
||||
let table = out
|
||||
.nbt
|
||||
.as_ref()
|
||||
.and_then(|n| n.get(&JavaString::from("LootTable")));
|
||||
assert_eq!(table, Some(&Tag::String("t:chests/house".into())));
|
||||
|
||||
// Providers the game does not run are refused.
|
||||
assert!(
|
||||
t.decode(json!([set_block(
|
||||
json!({"type": "minecraft:noise_provider"})
|
||||
)]))
|
||||
.is_err()
|
||||
);
|
||||
}
|
||||
}
|
||||
@@ -1,434 +0,0 @@
|
||||
//! Lithostitched's processors that pick processors, carried as data
|
||||
//! (`horizon:apply_random` and `horizon:condition`): one runs a processor
|
||||
//! list drawn by weight, the other one list or another by a test of the
|
||||
//! block. Both draw from Lithostitched's RandomSettings: a random seeded from
|
||||
//! the world seed and a name, at the block, the piece or the structure.
|
||||
//! `horizon:set_block` is its `set_block`, which the conditions mostly run.
|
||||
use super::{Processor, ProcessorList};
|
||||
use crate::{
|
||||
registry::{BlockRegistry, BlockStateId},
|
||||
worldgen::{DecodeError, block_feature::FeatureBlockBindings, structure::StructureResources},
|
||||
};
|
||||
use horizon_core::{
|
||||
position::BlockPos,
|
||||
random::{LegacyRandom, PositionalRandom, RandomSource},
|
||||
};
|
||||
use serde_json::Value;
|
||||
use std::{collections::BTreeSet, sync::Arc};
|
||||
|
||||
/// RandomSettings: where the random is taken, and the name salting it.
|
||||
#[derive(Clone, Debug, PartialEq)]
|
||||
pub struct RandomSettings {
|
||||
mode: Mode,
|
||||
/// ResourceLocation.hashCode of the name (`lithostitched:default`).
|
||||
salt: i32,
|
||||
}
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
enum Mode {
|
||||
Block,
|
||||
Piece,
|
||||
Structure,
|
||||
}
|
||||
impl RandomSettings {
|
||||
/// A mode alone, or `{"mode": ..., "name": ...}`; per block when unset.
|
||||
fn decode(v: Option<&Value>) -> Result<Self, DecodeError> {
|
||||
let mode = Mode::decode;
|
||||
let (mode, name) = match v {
|
||||
None => (Mode::Block, "lithostitched:default"),
|
||||
Some(Value::String(m)) => (mode(Some(m))?, "lithostitched:default"),
|
||||
Some(o) => (
|
||||
mode(o["mode"].as_str())?,
|
||||
o["name"]
|
||||
.as_str()
|
||||
.ok_or(DecodeError::Field("random name"))?,
|
||||
),
|
||||
};
|
||||
let (namespace, path) = name.split_once(':').unwrap_or(("minecraft", name));
|
||||
Ok(Self {
|
||||
mode,
|
||||
salt: java_hash(namespace)
|
||||
.wrapping_mul(31)
|
||||
.wrapping_add(java_hash(path)),
|
||||
})
|
||||
}
|
||||
/// RandomSource.create(seed + hash).forkPositional().at(the chosen
|
||||
/// position): the piece's position, the structure's pivot or the block.
|
||||
pub(super) fn create(
|
||||
&self,
|
||||
seed: i64,
|
||||
piece: [i32; 3],
|
||||
pivot: [i32; 3],
|
||||
block: [i32; 3],
|
||||
) -> LegacyRandom {
|
||||
let [x, y, z] = self.mode.select(piece, pivot, block);
|
||||
LegacyRandom::new(seed.wrapping_add(i64::from(self.salt)))
|
||||
.fork_positional()
|
||||
.at(BlockPos::new(x, y, z))
|
||||
}
|
||||
}
|
||||
impl Mode {
|
||||
fn decode(m: Option<&str>) -> Result<Self, DecodeError> {
|
||||
match m {
|
||||
None | Some("per_block") => Ok(Self::Block),
|
||||
Some("per_piece") => Ok(Self::Piece),
|
||||
Some("per_structure") => Ok(Self::Structure),
|
||||
_ => Err(DecodeError::Field("random mode")),
|
||||
}
|
||||
}
|
||||
fn select(self, piece: [i32; 3], pivot: [i32; 3], block: [i32; 3]) -> [i32; 3] {
|
||||
match self {
|
||||
Self::Block => block,
|
||||
Self::Piece => piece,
|
||||
Self::Structure => pivot,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// SetBlockProcessor with a simple or weighted state provider and no block
|
||||
/// entity change: the block becomes the state, keeping the properties it
|
||||
/// shares with the old one unless `preserve_state` is off.
|
||||
#[derive(Clone, Debug)]
|
||||
pub struct SetBlock {
|
||||
/// The states and their weights; one state alone is a simple provider,
|
||||
/// which draws nothing.
|
||||
states: Vec<(BlockStateId, i32)>,
|
||||
weighted: bool,
|
||||
preserve: bool,
|
||||
mode: Mode,
|
||||
}
|
||||
impl SetBlock {
|
||||
pub(super) fn decode(
|
||||
v: &Value,
|
||||
state: impl Fn(&Value) -> Result<BlockStateId, DecodeError>,
|
||||
) -> Result<Self, DecodeError> {
|
||||
let provider = &v["state_provider"];
|
||||
let (states, weighted) = match provider["type"].as_str() {
|
||||
Some("minecraft:simple_state_provider") => {
|
||||
(vec![(state(&provider["state"])?, 1)], false)
|
||||
}
|
||||
Some("minecraft:weighted_state_provider") => (
|
||||
provider["entries"]
|
||||
.as_array()
|
||||
.ok_or(DecodeError::Field("set_block entries"))?
|
||||
.iter()
|
||||
.map(|e| {
|
||||
let weight = e["weight"]
|
||||
.as_i64()
|
||||
.ok_or(DecodeError::Field("set_block weight"))?;
|
||||
Ok((state(&e["data"])?, weight as i32))
|
||||
})
|
||||
.collect::<Result<_, DecodeError>>()?,
|
||||
true,
|
||||
),
|
||||
_ => return Err(DecodeError::Field("set_block state_provider")),
|
||||
};
|
||||
if states.is_empty() {
|
||||
return Err(DecodeError::Field("set_block entries"));
|
||||
}
|
||||
Ok(Self {
|
||||
states,
|
||||
weighted,
|
||||
preserve: v["preserve_state"].as_bool().unwrap_or(true),
|
||||
mode: Mode::decode(v["random_mode"].as_str())?,
|
||||
})
|
||||
}
|
||||
/// The state to set, before `preserve`: drawn with
|
||||
/// RandomSource.create(seed).forkPositional().at(the chosen position).
|
||||
pub(super) fn state(
|
||||
&self,
|
||||
seed: i64,
|
||||
piece: [i32; 3],
|
||||
pivot: [i32; 3],
|
||||
block: [i32; 3],
|
||||
) -> BlockStateId {
|
||||
if !self.weighted {
|
||||
return self.states[0].0;
|
||||
}
|
||||
let [x, y, z] = self.mode.select(piece, pivot, block);
|
||||
let mut random = LegacyRandom::new(seed)
|
||||
.fork_positional()
|
||||
.at(BlockPos::new(x, y, z));
|
||||
let total: i32 = self.states.iter().map(|s| s.1).sum();
|
||||
let mut value = random.next_int_bound(total.max(1)).unwrap_or(0);
|
||||
for (state, weight) in &self.states {
|
||||
if value < *weight {
|
||||
return *state;
|
||||
}
|
||||
value -= weight;
|
||||
}
|
||||
self.states[0].0
|
||||
}
|
||||
pub(super) fn preserves(&self) -> bool {
|
||||
self.preserve
|
||||
}
|
||||
}
|
||||
|
||||
/// String.hashCode over UTF-16 units.
|
||||
fn java_hash(s: &str) -> i32 {
|
||||
s.encode_utf16()
|
||||
.fold(0i32, |h, c| h.wrapping_mul(31).wrapping_add(i32::from(c)))
|
||||
}
|
||||
|
||||
fn list(
|
||||
v: &Value,
|
||||
resources: &StructureResources,
|
||||
bindings: &FeatureBlockBindings<'_>,
|
||||
) -> Result<ProcessorList, DecodeError> {
|
||||
ProcessorList::decode(&v.to_string(), resources, bindings)
|
||||
}
|
||||
|
||||
/// ApplyRandomStructureProcessor: a weighted list of processor lists, one
|
||||
/// drawn per block with `nextInt(total)`.
|
||||
#[derive(Clone, Debug)]
|
||||
pub struct ApplyRandom {
|
||||
pub(super) random: RandomSettings,
|
||||
lists: Vec<(ProcessorList, i32)>,
|
||||
total: i32,
|
||||
}
|
||||
impl ApplyRandom {
|
||||
pub(super) fn decode(
|
||||
v: &Value,
|
||||
resources: &StructureResources,
|
||||
bindings: &FeatureBlockBindings<'_>,
|
||||
) -> Result<Self, DecodeError> {
|
||||
let lists = v["processor_lists"]
|
||||
.as_array()
|
||||
.ok_or(DecodeError::Field("apply_random processor_lists"))?
|
||||
.iter()
|
||||
.map(|e| {
|
||||
let weight = e["weight"]
|
||||
.as_i64()
|
||||
.ok_or(DecodeError::Field("apply_random weight"))?;
|
||||
Ok((list(&e["data"], resources, bindings)?, weight as i32))
|
||||
})
|
||||
.collect::<Result<Vec<_>, DecodeError>>()?;
|
||||
Ok(Self {
|
||||
random: RandomSettings::decode(v.get("mode"))?,
|
||||
total: lists.iter().map(|l| l.1).sum(),
|
||||
lists,
|
||||
})
|
||||
}
|
||||
/// WeightedList.getRandom: none when the weights add up to 0.
|
||||
pub(super) fn pick(&self, random: &mut impl RandomSource) -> Option<&ProcessorList> {
|
||||
if self.total <= 0 {
|
||||
return None;
|
||||
}
|
||||
let mut value = random.next_int_bound(self.total).unwrap_or(0);
|
||||
for (list, weight) in &self.lists {
|
||||
if value < *weight {
|
||||
return Some(list);
|
||||
}
|
||||
value -= weight;
|
||||
}
|
||||
None
|
||||
}
|
||||
}
|
||||
|
||||
/// ConditionProcessor: `then` when the condition holds for the block, else
|
||||
/// `else`.
|
||||
#[derive(Clone, Debug)]
|
||||
pub struct Conditional {
|
||||
pub(super) random: RandomSettings,
|
||||
pub(super) condition: Condition,
|
||||
pub(super) then: ProcessorList,
|
||||
pub(super) otherwise: ProcessorList,
|
||||
}
|
||||
impl Conditional {
|
||||
pub(super) fn decode(
|
||||
v: &Value,
|
||||
resources: &StructureResources,
|
||||
bindings: &FeatureBlockBindings<'_>,
|
||||
) -> Result<Self, DecodeError> {
|
||||
// A processor alone or a list of them.
|
||||
let processors = |key: &str| -> Result<ProcessorList, DecodeError> {
|
||||
match v.get(key) {
|
||||
None => Ok(ProcessorList::default()),
|
||||
Some(Value::Object(p)) if p.contains_key("processor_type") => Ok(ProcessorList(
|
||||
vec![Processor::decode(&v[key], resources, bindings)?],
|
||||
)),
|
||||
Some(other) => list(other, resources, bindings),
|
||||
}
|
||||
};
|
||||
Ok(Self {
|
||||
random: RandomSettings::decode(v.get("random_mode"))?,
|
||||
condition: Condition::decode(&v["if_true"], bindings)?,
|
||||
then: processors("then")?,
|
||||
otherwise: processors("else")?,
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
/// Lithostitched's processor conditions the game runs.
|
||||
#[derive(Clone, Debug)]
|
||||
pub(super) enum Condition {
|
||||
True,
|
||||
AllOf(Vec<Condition>),
|
||||
AnyOf(Vec<Condition>),
|
||||
Not(Box<Condition>),
|
||||
RandomChance(f32),
|
||||
/// The block placed (`input`) or the one in the world (`location`) is
|
||||
/// one of these, with these property values.
|
||||
MatchingBlocks {
|
||||
blocks: Arc<BTreeSet<BlockStateId>>,
|
||||
properties: Vec<(String, String)>,
|
||||
location: bool,
|
||||
},
|
||||
}
|
||||
impl Condition {
|
||||
fn decode(v: &Value, bindings: &FeatureBlockBindings<'_>) -> Result<Self, DecodeError> {
|
||||
let all = |a: &Value| -> Result<Vec<Condition>, DecodeError> {
|
||||
a.as_array()
|
||||
.ok_or(DecodeError::Field("processor conditions"))?
|
||||
.iter()
|
||||
.map(|c| Self::decode(c, bindings))
|
||||
.collect()
|
||||
};
|
||||
if v.is_array() {
|
||||
return Ok(Self::AllOf(all(v)?));
|
||||
}
|
||||
let kind = v["type"].as_str().unwrap_or_default();
|
||||
Ok(match kind.strip_prefix("lithostitched:").unwrap_or(kind) {
|
||||
"true" => Self::True,
|
||||
"all_of" => Self::AllOf(all(&v["conditions"])?),
|
||||
"any_of" => Self::AnyOf(all(&v["conditions"])?),
|
||||
"not" => Self::Not(Box::new(Self::decode(&v["condition"], bindings)?)),
|
||||
"random_chance" => Self::RandomChance(super::float(v, "chance")?),
|
||||
"matching_blocks" => Self::MatchingBlocks {
|
||||
blocks: super::holder_set(&v["blocks"], bindings)?,
|
||||
properties: match v.get("properties") {
|
||||
None => Vec::new(),
|
||||
Some(p) => p
|
||||
.as_object()
|
||||
.ok_or(DecodeError::Field("matching_blocks properties"))?
|
||||
.iter()
|
||||
.map(|(k, x)| {
|
||||
let x = x
|
||||
.as_str()
|
||||
.ok_or(DecodeError::Field("matching_blocks property"))?;
|
||||
Ok((k.clone(), x.to_owned()))
|
||||
})
|
||||
.collect::<Result<_, DecodeError>>()?,
|
||||
},
|
||||
location: match v["match_type"].as_str() {
|
||||
None | Some("input") => false,
|
||||
Some("location") => true,
|
||||
_ => return Err(DecodeError::Field("matching_blocks match_type")),
|
||||
},
|
||||
},
|
||||
_ => return Err(DecodeError::Field("processor condition type")),
|
||||
})
|
||||
}
|
||||
/// ProcessorCondition.test with the block placed and the one there.
|
||||
pub(super) fn test(
|
||||
&self,
|
||||
input: BlockStateId,
|
||||
location: BlockStateId,
|
||||
registry: &BlockRegistry,
|
||||
random: &mut impl RandomSource,
|
||||
) -> bool {
|
||||
match self {
|
||||
Self::True => true,
|
||||
Self::AllOf(all) => all
|
||||
.iter()
|
||||
.all(|c| c.test(input, location, registry, random)),
|
||||
Self::AnyOf(any) => any
|
||||
.iter()
|
||||
.any(|c| c.test(input, location, registry, random)),
|
||||
Self::Not(c) => !c.test(input, location, registry, random),
|
||||
Self::RandomChance(chance) => random.next_float() < *chance,
|
||||
Self::MatchingBlocks {
|
||||
blocks,
|
||||
properties,
|
||||
location: at_location,
|
||||
} => {
|
||||
let state = if *at_location { location } else { input };
|
||||
blocks.contains(&state)
|
||||
&& properties.iter().all(|(k, x)| {
|
||||
registry
|
||||
.state(state)
|
||||
.and_then(|s| s.properties.get(k))
|
||||
.is_some_and(|v| v == x)
|
||||
})
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn random_settings_salt_and_position() {
|
||||
// ResourceLocation.hashCode: 31 * namespace + path.
|
||||
let default = RandomSettings::decode(Some(&"per_piece".into())).unwrap();
|
||||
assert_eq!(
|
||||
default.salt,
|
||||
java_hash("lithostitched")
|
||||
.wrapping_mul(31)
|
||||
.wrapping_add(java_hash("default"))
|
||||
);
|
||||
assert_eq!(java_hash("default"), 1544803905);
|
||||
let (seed, piece, pivot, block) = (12345, [16, 64, -32], [8, 70, 8], [17, 65, -30]);
|
||||
let mut ours = default.create(seed, piece, pivot, block);
|
||||
let mut theirs = LegacyRandom::new(seed + i64::from(default.salt))
|
||||
.fork_positional()
|
||||
.at(BlockPos::new(16, 64, -32));
|
||||
assert_eq!(ours.next_long(), theirs.next_long());
|
||||
let named: Value = serde_json::json!({"mode": "per_structure", "name": "v:roof"});
|
||||
let named = RandomSettings::decode(Some(&named)).unwrap();
|
||||
assert_eq!(named.mode, Mode::Structure);
|
||||
assert_eq!(
|
||||
named.salt,
|
||||
java_hash("v")
|
||||
.wrapping_mul(31)
|
||||
.wrapping_add(java_hash("roof"))
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn apply_random_draws_by_weight() {
|
||||
let apply = ApplyRandom {
|
||||
random: RandomSettings {
|
||||
mode: Mode::Block,
|
||||
salt: 0,
|
||||
},
|
||||
lists: vec![
|
||||
(ProcessorList(vec![Processor::Nop]), 3),
|
||||
(ProcessorList::default(), 1),
|
||||
],
|
||||
total: 4,
|
||||
};
|
||||
let mut ours = LegacyRandom::new(9);
|
||||
let mut theirs = LegacyRandom::new(9);
|
||||
for _ in 0..32 {
|
||||
let draw = theirs.next_int_bound(4).unwrap();
|
||||
let picked = apply.pick(&mut ours).unwrap();
|
||||
assert_eq!(picked.0.len(), usize::from(draw < 3));
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn set_block_draws_from_the_unsalted_seed() {
|
||||
let (a, b) = (BlockStateId(1), BlockStateId(2));
|
||||
let set = SetBlock::decode(
|
||||
&serde_json::json!({"state_provider": {"type": "minecraft:weighted_state_provider",
|
||||
"entries": [{"weight": 1, "data": 1}, {"weight": 2, "data": 2}]},
|
||||
"random_mode": "per_piece"}),
|
||||
|v| Ok(BlockStateId(v.as_u64().unwrap() as u32)),
|
||||
)
|
||||
.unwrap();
|
||||
assert!(set.preserves());
|
||||
for x in 0..16 {
|
||||
let mut java = LegacyRandom::new(77)
|
||||
.fork_positional()
|
||||
.at(BlockPos::new(x, 5, 3));
|
||||
let want = if java.next_int_bound(3).unwrap() < 1 {
|
||||
a
|
||||
} else {
|
||||
b
|
||||
};
|
||||
assert_eq!(set.state(77, [x, 5, 3], [0; 3], [9, 9, 9]), want);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -21,7 +21,7 @@ Level: preview ([stability.md](stability.md)). Schema 1.
|
||||
"license": "MIT", "source": "https://github.com/...", "icon": "https://...png", "key": "RWT...",
|
||||
"versions": [{
|
||||
"version": "0.1.0", "published": "2026-10-24", "changelog": "",
|
||||
"api": "0.1", "side": "client", "capabilities": ["game-read", "hud", "chat"], "game": "26.3",
|
||||
"api": "0.1", "side": "client", "capabilities": ["game-read", "hud", "chat"], "api_level": 0, "game": "26.3",
|
||||
"file": { "name": "coords_hud-0.1.0.hmod", "url": "https://github.com/ludovic111/horizon-mods/releases/download/...",
|
||||
"size": 438, "sha256": "e113...", "signature": "untrusted comment: ...\n...\ntrusted comment: ...\n...\n" }
|
||||
}]
|
||||
@@ -43,6 +43,7 @@ Level: preview ([stability.md](stability.md)). Schema 1.
|
||||
| `versions` | Newest first, at least one. |
|
||||
| `api` | A mod's API line (its manifest's `api`); a modpack's manifest format (`1`). |
|
||||
| `side`, `capabilities` | A mod's, read from its manifest by CI, never typed by hand. |
|
||||
| `api_level` | The mod API level a mod's code needs ([stability.md](stability.md#mod-api-levels)): its newest imported function's, read from the file by CI. Absent for content-only mods and in indexes built before levels. Installers take the newest version whose level the running game serves. |
|
||||
| `game` | The Minecraft version it is for. |
|
||||
| `requires` | A modpack's mods: `{ id, version, sha256 }`, each a version in this index with that hash. |
|
||||
| `file` | A plain name with the kind's extension (`.hmod`, `.hpack`, `.zip`), an `https://` URL, the size (at most 64 MiB), the lowercase hex SHA-256, and the `.minisig` text when the project has a key. |
|
||||
@@ -57,7 +58,8 @@ changing what one means, makes schema 2.
|
||||
|
||||
1. Its size and SHA-256 are the ones the entry lists, and it isn't revoked.
|
||||
2. With a project key: its signature verifies with that key (minisign's prehashed and legacy signatures both).
|
||||
3. What the file says matches the entry: a mod's `horizon-mod.toml` (id, version, API, side, capabilities) and its
|
||||
3. What the file says matches the entry: a mod's `horizon-mod.toml` (id, version, API, side, capabilities), its API
|
||||
level when the entry lists one, and its
|
||||
content's fence ([mods.md](../mods.md#content-mods-api-02)); a modpack's manifest (id, version, format, game,
|
||||
mods); a resource pack's `pack.mcmeta`; a shader pack's `horizon_shader_api::check` and manifest (id, version,
|
||||
shader API).
|
||||
|
||||
@@ -34,6 +34,22 @@ Not breaking: a new function, interface, capability, command, endpoint, tool or
|
||||
argument or JSON field (readers must ignore fields they don't know); a new WIT function or type (mods built earlier
|
||||
don't import it); faster, or fixing behaviour to what the reference already says.
|
||||
|
||||
### Mod API levels
|
||||
|
||||
A new WIT function doesn't break older mods, but a mod that calls it can't run on a Horizon from before it. So every
|
||||
function the game offers mods has an **API level**, the one it arrived at (`crates/horizon-mods/src/api_level.rs`):
|
||||
level 0 is the contract of Horizon 0.2.67 to 0.2.69, level 1 adds `render.set-minimap` and server mods' `players`. A mod needs the level of
|
||||
the newest function it imports (a component imports only the functions it calls). The level is read from the file,
|
||||
never declared:
|
||||
|
||||
- the game refuses a mod that needs a function it doesn't have, with "made for a newer Horizon (it uses
|
||||
render.set-minimap): update Horizon to run it", instead of a linking error;
|
||||
- the registry's CI writes each mod version's level into the index (`api_level`), and installers take the newest
|
||||
version the running game can run.
|
||||
|
||||
A pull request that adds a function lists it in `api_level.rs` at the next level and raises `LEVEL`; the
|
||||
`api_reference` test fails until it does.
|
||||
|
||||
## Stability levels
|
||||
|
||||
Every part of an API has one level, shown in its reference and its surface page.
|
||||
|
||||
+16
-15
@@ -504,21 +504,22 @@ Two cases the oracle fills in:
|
||||
mod. Better Dungeons' small dungeons keep one chest and each other one with a fifth's
|
||||
chance, two at most (the game's `horizon:count_cap`, counted per placement as the mod's
|
||||
DungeonContext is): 12 chests in five small dungeons at seed 1234 become 6.
|
||||
Lithostitched's `block_swap` (137 lists, all in ChoiceTheorem's Overhauled Village) is the
|
||||
game's `horizon:block_swap`: the same map, with Block.withPropertiesOf's properties kept;
|
||||
a target block the game does not have (most of them are Nature's Spirit's and Croptopia's)
|
||||
leaves the block as it is, as the mod does. Lithostitched's `reference` (CTOV builds most
|
||||
of its lists from others) has the referenced lists' processors written in its place; its
|
||||
`apply_random`, `condition` and `set_block` are the game's `horizon:apply_random`,
|
||||
`horizon:condition` and `horizon:set_block`, with Lithostitched's random (the world seed
|
||||
plus the name's hash, at the block, piece or structure). In a CTOV plains village at seed
|
||||
1234 the farms now grow carrots, potatoes and beetroot besides wheat, and 1,655
|
||||
cobblestone blocks become paths, grass, mossy cobblestone and planks. No Lithostitched processor is
|
||||
dropped now (130 before). CTOV's compat hooks for other mods inside them (its
|
||||
`modular_compat`, 142 copies) run a list of their own only when the mod they name is
|
||||
loaded: carry writes that list in when the mod is ported along and takes the hook out (a
|
||||
no-op, as in the mod) when it is not. In ATM10 all 142 name Nature's Spirit, which the
|
||||
pack does not have.
|
||||
Lithostitched's processors (all in ChoiceTheorem's Overhauled Village in ATM10) are the
|
||||
game's own types, read as the mod writes them. `block_swap` keeps the properties the new
|
||||
block can have: a farm's ripe wheat becomes ripe carrots, but beetroot, whose age stops at
|
||||
3, keeps its default; a target block the game does not have (most are Nature's Spirit's and
|
||||
Croptopia's) leaves the block as it is. `reference` runs the lists it names, `condition`
|
||||
tests the template's block or the world's, `apply_random` and `set_block` draw per block or
|
||||
per piece as the data says. Lithostitched's own random is not known yet, so the shares of a
|
||||
random choice are the Java pack's but the blocks chosen differ. Lists named by tag and state
|
||||
providers other than simple and weighted ones are dropped and counted (ATM10 has none).
|
||||
CTOV's compat hooks for other mods (its `modular_compat`, 30 of them in 17 lists) become a
|
||||
`reference` when the mod they name is ported along, and are taken out (a no-op, as in the
|
||||
mod) when it is not. In ATM10 they all name Nature's Spirit, which the pack does not have.
|
||||
In Java, Lithostitched also lays out every jigsaw structure its own way (villages,
|
||||
outposts, trial chambers; CTOV's villages are `lithostitched:jigsaw`, carried as vanilla's
|
||||
jigsaw). Horizon keeps vanilla's layouts, so with Lithostitched in a pack, structure layouts
|
||||
differ from the Java pack's for the same seed (their positions do not).
|
||||
The processors that build outside their template are carried too: Repurposed's and
|
||||
Moog's pillar processors become the game's `horizon:pillar` (a column from a placeholder
|
||||
block down to the ground, with the processor list they run on each of its blocks written
|
||||
|
||||
+19
-1
@@ -251,7 +251,8 @@ key> --signature <file>.minisig`.
|
||||
`cargo horizon-mod test` builds the mod, then runs each `tests/<name>.toml` in
|
||||
the sandbox the game uses, with no game and no window: the test plays the
|
||||
game's part (the player and the clock the mod reads, ticks, frames, chat lines,
|
||||
commands) and checks what the mod showed. A script fails at its first wrong
|
||||
commands; for a server mod, players joining, chatting, typing commands,
|
||||
breaking and placing blocks and leaving) and checks what the mod showed. A script fails at its first wrong
|
||||
step, with what it expected and what it got; the command fails if any script
|
||||
does. `--debug` builds without optimizing, `--hmod <file>` tests a `.hmod`
|
||||
already built, and a name runs only the scripts whose path holds it. Each
|
||||
@@ -288,6 +289,16 @@ A step's parts happen in this order:
|
||||
| `ticks = n`, `frames = n` | that many ticks (the game's tick counter and the clock move on), then frames 1/60 s apart |
|
||||
| `chat = "<Steve> hi"` | a chat line the player receives |
|
||||
| `command = "where north"` | the player types `/where north`; a command the mod doesn't own fails the step |
|
||||
| `break = { x = 1, y = 63, z = 0, state = "minecraft:stone" }`, `place = { ... }` | server mods: the player breaks or places that block |
|
||||
| `leave = "Alex"` | server mods: that player leaves |
|
||||
|
||||
A server mod starts with nobody on: `join = "Alex"` (after `reload` and `title-screen`) brings a
|
||||
player in at the defaults, in survival, with the id
|
||||
`00000000-0000-4000-8000-000000000001` for the first name that joined, `...2`
|
||||
for the second, the same id when a name joins again. `player`, `chat`,
|
||||
`command`, `break` and `place` are then that player's doing: the one named by
|
||||
`as = "Steve"`, or the first one on. `player` takes `game-mode` there, and the
|
||||
script's own `[player]` and `[clock]` are a client mod's.
|
||||
|
||||
Then `expect` checks what the mod did during the step; a key left out is not
|
||||
checked:
|
||||
@@ -298,6 +309,7 @@ checked:
|
||||
| `chat = ["..."]` | every chat line it showed, in order (`[]`: none) |
|
||||
| `feedback = "..."`, `error = "..."` | the command's answer, shown plain or in red |
|
||||
| `panel = ["..."]`, `corner = "top-left"` | its HUD panel's lines (`[]`: no panel) and corner |
|
||||
| `told = ["Alex: Welcome!"]`, `broadcast = ["..."]` | server mods: every `players.tell` (as `name: text`) and `players.broadcast`, in order |
|
||||
| `stopped = "panic"` | the mod was turned off, for a reason holding this text; without it, a mod that traps, panics or overruns fails the test |
|
||||
|
||||
Unknown keys are errors, so a typo never passes silently. The same runner is
|
||||
@@ -533,6 +545,12 @@ so the same rustc and `Cargo.lock` give the same file.
|
||||
release cycle, so existing mods keep working while authors move.
|
||||
- The manifest's `api` names the line it needs (`0.1`); the game refuses a
|
||||
line it does not serve with a clear message.
|
||||
- Within a line, each function has an API level, the one it arrived at
|
||||
([stability](api/stability.md#mod-api-levels)). A mod needs the level of
|
||||
the newest function it calls, read from its file: an older Horizon refuses
|
||||
it with "made for a newer Horizon: update Horizon", and the registry lists
|
||||
the level so installers take a version the game can run.
|
||||
`cargo horizon-mod check` prints it ("needs mod API level 1 or newer").
|
||||
- Horizon follows Minecraft releases; the mod API does not have to. Vanilla
|
||||
concepts mods see (dimensions, block and item ids) are the game's own ids,
|
||||
so a version port changes the data, not the API.
|
||||
|
||||
Generated
+16
@@ -2586,6 +2586,8 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "ed5909b6e89a2db4456e54cd5f673791d7eca6732202bbf2a9cc504fe2f9b84a"
|
||||
dependencies = [
|
||||
"foldhash 0.2.0",
|
||||
"serde",
|
||||
"serde_core",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
@@ -2734,6 +2736,7 @@ dependencies = [
|
||||
"serde_json",
|
||||
"sha2 0.10.9",
|
||||
"toml 1.1.8+spec-1.1.0",
|
||||
"wasmparser",
|
||||
"zip",
|
||||
]
|
||||
|
||||
@@ -6604,6 +6607,19 @@ dependencies = [
|
||||
"web-sys",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "wasmparser"
|
||||
version = "0.254.2"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "c5ff8685b587722894b6f25958fc608d315b93b8d23647bfb567664e7006d757"
|
||||
dependencies = [
|
||||
"bitflags 2.13.2",
|
||||
"hashbrown 0.17.1",
|
||||
"indexmap",
|
||||
"semver",
|
||||
"serde",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "wayland-backend"
|
||||
version = "0.3.17"
|
||||
|
||||
@@ -422,6 +422,37 @@ pub fn version_dir(tag: &str) -> PathBuf {
|
||||
|
||||
const COMPLETE: &str = ".installed";
|
||||
|
||||
/// The mod API level of the game players run: the selected version's, else the newest installed
|
||||
/// one's. None with no version installed: the launcher doesn't know yet which game will run mods.
|
||||
pub fn game_mod_api_level() -> Option<u32> {
|
||||
let installed = installed();
|
||||
let tag = Settings::load()
|
||||
.selected
|
||||
.filter(|s| installed.contains(s))
|
||||
.or_else(|| installed.into_iter().next())?;
|
||||
Some(mod_api_level(&tag))
|
||||
}
|
||||
|
||||
/// A game version's mod API level, read once from the mark its program carries
|
||||
/// (`horizon_mods::api_level::MARK`). A program from before the mark serves level 0, the
|
||||
/// contract of Horizon 0.2.67 and 0.2.68.
|
||||
pub fn mod_api_level(tag: &str) -> u32 {
|
||||
static LEVELS: Mutex<Vec<(String, u32)>> = Mutex::new(Vec::new());
|
||||
let mut levels = LEVELS.lock().unwrap_or_else(|e| e.into_inner());
|
||||
if let Some(&(_, level)) = levels.iter().find(|(t, _)| t == tag) {
|
||||
return level;
|
||||
}
|
||||
let level = program_mod_api_level(&version_dir(tag).join(CLIENT));
|
||||
levels.push((tag.to_owned(), level));
|
||||
level
|
||||
}
|
||||
|
||||
/// The mod API level in the game program at `path`: its mark's, else 0.
|
||||
fn program_mod_api_level(path: &Path) -> u32 {
|
||||
let program = fs::read(path).unwrap_or_default();
|
||||
horizon_mods::api_level::read_mark(&program).unwrap_or(0)
|
||||
}
|
||||
|
||||
/// Installed versions, newest tag first.
|
||||
pub fn installed() -> Vec<String> {
|
||||
installed_in(&versions_dir())
|
||||
@@ -2557,6 +2588,24 @@ mod tests {
|
||||
use super::*;
|
||||
use std::cmp::Ordering::*;
|
||||
|
||||
/// The game program's mod API level is its mark's; a program from before the mark (0.2.68
|
||||
/// and older) or none at all serves level 0.
|
||||
#[test]
|
||||
fn a_game_program_says_its_mod_api_level() {
|
||||
let dir = std::env::temp_dir().join(format!("horizon-api-level-{}", std::process::id()));
|
||||
fs::create_dir_all(&dir).unwrap();
|
||||
let marked = dir.join("marked");
|
||||
let mut program = b"\x7fELF code code".to_vec();
|
||||
program.extend_from_slice(b"horizon-mod-api-level:0007;");
|
||||
fs::write(&marked, &program).unwrap();
|
||||
let old = dir.join("old");
|
||||
fs::write(&old, b"\x7fELF code without a mark").unwrap();
|
||||
assert_eq!(program_mod_api_level(&marked), 7);
|
||||
assert_eq!(program_mod_api_level(&old), 0);
|
||||
assert_eq!(program_mod_api_level(&dir.join("missing")), 0);
|
||||
fs::remove_dir_all(&dir).unwrap();
|
||||
}
|
||||
|
||||
/// A preparation that reuses the imported game files still reads the assets from the
|
||||
/// launcher that has them: a Prism Launcher instance's are in the launcher root, linked into
|
||||
/// the official layout (jan.sonki on Discord: silent, grey title screen since 0.2.48).
|
||||
|
||||
@@ -168,7 +168,14 @@ fn project_of(p: &index::Project) -> Option<Project> {
|
||||
})
|
||||
}
|
||||
|
||||
fn version_of(index: &Index, p: &index::Project, v: &index::Version) -> Version {
|
||||
/// Version `v` of `p` as the browser shows it; blocked when taken down, or when it needs a newer
|
||||
/// mod API level than `level`, the game's.
|
||||
fn version_of(
|
||||
index: &Index,
|
||||
p: &index::Project,
|
||||
v: &index::Version,
|
||||
level: Option<u32>,
|
||||
) -> Version {
|
||||
Version {
|
||||
id: v.version.clone(),
|
||||
number: v.version.clone(),
|
||||
@@ -187,7 +194,8 @@ fn version_of(index: &Index, p: &index::Project, v: &index::Version) -> Version
|
||||
required: v.requires.iter().map(|r| r.id.clone()).collect(),
|
||||
blocked: index
|
||||
.revoked(&p.id, &v.file.sha256)
|
||||
.map(|r| format!("taken down: {}", r.reason)),
|
||||
.map(|r| format!("taken down: {}", r.reason))
|
||||
.or_else(|| needs_newer(v, level).then(|| NEEDS_NEWER.to_string())),
|
||||
}
|
||||
}
|
||||
|
||||
@@ -254,9 +262,10 @@ impl Source for Registry {
|
||||
let p = index
|
||||
.project(&project.id)
|
||||
.ok_or_else(|| format!("{} isn't in Horizon's registry.", project.title))?;
|
||||
let level = crate::backend::game_mod_api_level();
|
||||
Ok(p.versions
|
||||
.iter()
|
||||
.map(|v| version_of(&index, p, v))
|
||||
.map(|v| version_of(&index, p, v, level))
|
||||
.collect())
|
||||
}
|
||||
|
||||
@@ -378,20 +387,24 @@ fn relative(kind: Kind, id: &str, file_name: &str) -> Result<String, String> {
|
||||
}
|
||||
}
|
||||
|
||||
/// Installs a registry project into the game folder `home`: its newest version for this game,
|
||||
/// downloaded into `mod-browser/downloads/`, checked against the index, then moved into place.
|
||||
/// A mod is `horizon-mods/<id>.hmod`, turned on in `horizon-mods.txt`.
|
||||
/// Installs a registry project into the game folder `home`: its newest version for this game that
|
||||
/// the game the player runs can load, downloaded into `mod-browser/downloads/`, checked against
|
||||
/// the index, then moved into place. A mod is `horizon-mods/<id>.hmod`, turned on in
|
||||
/// `horizon-mods.txt`.
|
||||
pub fn install(
|
||||
project: &Project,
|
||||
home: &Path,
|
||||
progress: &dyn Fn(&str, f32),
|
||||
) -> Result<Vec<installed::Entry>, String> {
|
||||
install_from(&*index()?, local(), project, home, progress)
|
||||
let level = crate::backend::game_mod_api_level();
|
||||
install_from(&*index()?, local(), level, project, home, progress)
|
||||
}
|
||||
|
||||
/// [`install`] from `index`, for a game serving mod API `level`.
|
||||
fn install_from(
|
||||
index: &Index,
|
||||
local: bool,
|
||||
level: Option<u32>,
|
||||
project: &Project,
|
||||
home: &Path,
|
||||
progress: &dyn Fn(&str, f32),
|
||||
@@ -399,27 +412,41 @@ fn install_from(
|
||||
let p = index
|
||||
.project(&project.id)
|
||||
.ok_or_else(|| format!("{} isn't in Horizon's registry.", project.title))?;
|
||||
let v = newest(index, p)?;
|
||||
let v = newest(index, p, level)?;
|
||||
install_version(index, local, p, v, home, progress).map(|e| vec![e])
|
||||
}
|
||||
|
||||
/// A project's newest version for this game that wasn't taken down.
|
||||
fn newest<'a>(index: &Index, p: &'a index::Project) -> Result<&'a index::Version, String> {
|
||||
let mut taken_down = None;
|
||||
/// A project's newest version for this game that wasn't taken down and that a game serving mod
|
||||
/// API `level` runs (any, when the level isn't known).
|
||||
fn newest<'a>(
|
||||
index: &Index,
|
||||
p: &'a index::Project,
|
||||
level: Option<u32>,
|
||||
) -> Result<&'a index::Version, String> {
|
||||
let (mut taken_down, mut too_new) = (None, false);
|
||||
for v in p.versions.iter().filter(|v| v.game == GAME) {
|
||||
match index.revoked(&p.id, &v.file.sha256) {
|
||||
None => return Ok(v),
|
||||
Some(r) => {
|
||||
taken_down.get_or_insert(r);
|
||||
}
|
||||
if let Some(r) = index.revoked(&p.id, &v.file.sha256) {
|
||||
taken_down.get_or_insert(r);
|
||||
} else if needs_newer(v, level) {
|
||||
too_new = true;
|
||||
} else {
|
||||
return Ok(v);
|
||||
}
|
||||
}
|
||||
Err(match taken_down {
|
||||
_ if too_new => format!("{} {NEEDS_NEWER}: update it first.", p.name),
|
||||
Some(r) => format!("{} was taken down: {}", p.name, r.reason),
|
||||
None => format!("{} has no version for {GAME} to install.", p.name),
|
||||
})
|
||||
}
|
||||
|
||||
const NEEDS_NEWER: &str = "needs a newer Horizon than the game you play";
|
||||
|
||||
/// Whether version `v` calls mod API functions a game serving `level` doesn't have.
|
||||
fn needs_newer(v: &index::Version, level: Option<u32>) -> bool {
|
||||
matches!((v.api_level, level), (Some(needed), Some(level)) if needed > level)
|
||||
}
|
||||
|
||||
/// Installs version `v` of the registry's mod, resource pack or shader pack `p` into the game
|
||||
/// folder `home`.
|
||||
fn install_version(
|
||||
@@ -462,7 +489,7 @@ fn install_version(
|
||||
return Err(format!("{relative} is already there: move it away first."));
|
||||
}
|
||||
let line = format!("{} {}", p.name, v.version);
|
||||
let file = &version_of(index, p, v).files[0];
|
||||
let file = &version_of(index, p, v, None).files[0];
|
||||
let staging = home.join("mod-browser/downloads");
|
||||
let path = fetch(file, &staging, local, &|f| progress(&line, f))?;
|
||||
let trust = index::check_file(index, p, v, &path).inspect_err(|_| {
|
||||
|
||||
@@ -84,7 +84,7 @@ fn install_in(
|
||||
if p.kind != idx::Kind::Modpack {
|
||||
return Err(format!("{} is a {}, not a modpack.", p.name, p.kind.name()));
|
||||
}
|
||||
let v = newest(index, p)?;
|
||||
let v = newest(index, p, None)?;
|
||||
let work = dir.join(&p.id);
|
||||
let fresh = !work.exists();
|
||||
let result = install_version_in(index, local, p, v, &work, progress);
|
||||
|
||||
@@ -59,7 +59,7 @@ fn installs_checked_turns_on_and_removes() {
|
||||
let index = sample();
|
||||
let home = scratch("install");
|
||||
let p = hud(&index);
|
||||
let done = install_from(&index, true, &p, &home, &|_, _| {}).unwrap();
|
||||
let done = install_from(&index, true, None, &p, &home, &|_, _| {}).unwrap();
|
||||
assert_eq!(done[0].file, "horizon-mods/coords_hud.hmod");
|
||||
assert_eq!(done[0].verdict.as_deref(), Some("Verified"));
|
||||
assert!(done[0].checksum.starts_with("SHA-256:e1135345"));
|
||||
@@ -73,7 +73,7 @@ fn installs_checked_turns_on_and_removes() {
|
||||
0
|
||||
);
|
||||
// Installed already: nothing to do.
|
||||
let again = install_from(&index, true, &p, &home, &|_, _| {}).unwrap();
|
||||
let again = install_from(&index, true, None, &p, &home, &|_, _| {}).unwrap();
|
||||
assert_eq!(again, done);
|
||||
|
||||
let mut revoked = index.clone();
|
||||
@@ -102,7 +102,7 @@ fn installs_a_shader_pack_into_shaderpacks() {
|
||||
let home = scratch("shader");
|
||||
let p = project_of(index.project("glow").unwrap()).unwrap();
|
||||
assert_eq!(p.support(), super::super::Support::Works);
|
||||
let done = install_from(&index, true, &p, &home, &|_, _| {}).unwrap();
|
||||
let done = install_from(&index, true, None, &p, &home, &|_, _| {}).unwrap();
|
||||
assert_eq!(done[0].file, "shaderpacks/glow-1.0.0.hshader");
|
||||
assert_eq!(done[0].kind, Kind::Shader);
|
||||
assert!(home.join("shaderpacks/glow-1.0.0.hshader").is_file());
|
||||
@@ -123,7 +123,7 @@ fn installs_a_shader_pack_into_shaderpacks() {
|
||||
assert!(!home.join("shaderpacks/glow-1.0.0.hshader").exists());
|
||||
// A file of the same name the registry didn't put there is left alone.
|
||||
fs::write(home.join("shaderpacks/glow-1.0.0.hshader"), b"mine").unwrap();
|
||||
let e = install_from(&index, true, &p, &home, &|_, _| {}).unwrap_err();
|
||||
let e = install_from(&index, true, None, &p, &home, &|_, _| {}).unwrap_err();
|
||||
assert_eq!(
|
||||
e,
|
||||
"shaderpacks/glow-1.0.0.hshader is already there: move it away first."
|
||||
@@ -140,15 +140,15 @@ fn refuses_a_changed_file_a_taken_id_and_local_files_from_the_real_registry() {
|
||||
let mut tampered = index.clone();
|
||||
let cozy = tampered.projects[1].versions[0].file.url.clone();
|
||||
tampered.projects[0].versions[0].file.url = cozy;
|
||||
let e = install_from(&tampered, true, &p, &home, &|_, _| {}).unwrap_err();
|
||||
let e = install_from(&tampered, true, None, &p, &home, &|_, _| {}).unwrap_err();
|
||||
assert!(e.contains("larger than its source says"), "{e}");
|
||||
assert!(!home.join("horizon-mods").exists());
|
||||
|
||||
let e = install_from(&index, false, &p, &home, &|_, _| {}).unwrap_err();
|
||||
let e = install_from(&index, false, None, &p, &home, &|_, _| {}).unwrap_err();
|
||||
assert!(e.contains("file servers"), "{e}");
|
||||
|
||||
fs::create_dir_all(home.join("horizon-mods/coords_hud")).unwrap();
|
||||
let e = install_from(&index, true, &p, &home, &|_, _| {}).unwrap_err();
|
||||
let e = install_from(&index, true, None, &p, &home, &|_, _| {}).unwrap_err();
|
||||
assert!(e.contains("already in horizon-mods"), "{e}");
|
||||
|
||||
let mut taken_down = index.clone();
|
||||
@@ -158,7 +158,7 @@ fn refuses_a_changed_file_a_taken_id_and_local_files_from_the_real_registry() {
|
||||
reason: "Test.".into(),
|
||||
date: String::new(),
|
||||
});
|
||||
let e = install_from(&taken_down, true, &p, &home, &|_, _| {}).unwrap_err();
|
||||
let e = install_from(&taken_down, true, None, &p, &home, &|_, _| {}).unwrap_err();
|
||||
assert_eq!(e, "Coordinates HUD was taken down: Test.");
|
||||
fs::remove_dir_all(&home).unwrap();
|
||||
}
|
||||
@@ -175,7 +175,7 @@ fn registry_versions_run_when_made_for_this_game() {
|
||||
let versions: Vec<Version> = p
|
||||
.versions
|
||||
.iter()
|
||||
.map(|x| version_of(&index, p, x))
|
||||
.map(|x| version_of(&index, p, x, None))
|
||||
.collect();
|
||||
assert_eq!(pick(Kind::Mod, &versions, false).unwrap().number, "0.1.0");
|
||||
}
|
||||
@@ -198,3 +198,21 @@ fn owner_links_only_take_github_logins() {
|
||||
assert!(!github_login(bad), "{bad}");
|
||||
}
|
||||
}
|
||||
|
||||
/// A version that calls mod API functions the game doesn't have is marked and skipped.
|
||||
#[test]
|
||||
fn versions_for_a_newer_horizon_are_not_installed() {
|
||||
let mut index = sample();
|
||||
index.projects[0].versions[0].api_level = Some(1);
|
||||
let p = index.project("coords_hud").unwrap();
|
||||
let e = newest(&index, p, Some(0)).unwrap_err();
|
||||
assert_eq!(
|
||||
e,
|
||||
"Coordinates HUD needs a newer Horizon than the game you play: update it first."
|
||||
);
|
||||
assert!(newest(&index, p, Some(1)).is_ok());
|
||||
assert!(newest(&index, p, None).is_ok());
|
||||
let v = version_of(&index, p, &p.versions[0], Some(0));
|
||||
assert_eq!(v.blocked.as_deref(), Some(NEEDS_NEWER));
|
||||
assert_eq!(version_of(&index, p, &p.versions[0], Some(1)).blocked, None);
|
||||
}
|
||||
|
||||
@@ -55,6 +55,12 @@ KNOWN = {
|
||||
"Better Dungeons' own structure types (spec-betterdungeons §5, §6; OPEN-B14, B15) are not "
|
||||
'implemented yet',
|
||||
},
|
||||
'ctov': {
|
||||
r'^ctov:': "Lithostitched's random is not known (spec-lithostitched OPEN-L6): per-block road and palette "
|
||||
'choices match by share, not by block; and decoration (grass, trees) differs where the village '
|
||||
'changed the terrain',
|
||||
r'^minecraft:village_plains$': 'decoration (grass, trees) differs where the village changed the terrain',
|
||||
},
|
||||
}
|
||||
|
||||
|
||||
|
||||
Reference in New Issue
Block a user