507 lines
18 KiB
Rust
507 lines
18 KiB
Rust
//! Per-state gameplay facts exported from vanilla's own block-state accessors
|
|
//! (`gameplay-facts.json`), indexed by registry state ID.
|
|
mod decode;
|
|
use crate::Result;
|
|
use horizon_world::{
|
|
level::{Behaviours, GameplayStateSource},
|
|
registry::{BlockRegistry, BlockStateId},
|
|
};
|
|
use serde_json::Value;
|
|
use std::{
|
|
collections::HashMap,
|
|
fs::{self, File},
|
|
io::BufReader,
|
|
path::Path,
|
|
sync::Arc,
|
|
};
|
|
|
|
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
|
|
pub enum RenderShape {
|
|
Model,
|
|
Invisible,
|
|
Animated,
|
|
}
|
|
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
|
|
pub enum Fluid {
|
|
None,
|
|
Water,
|
|
Lava,
|
|
}
|
|
#[derive(Clone, Debug)]
|
|
pub struct Sounds {
|
|
pub volume: f32,
|
|
pub pitch: f32,
|
|
pub break_sound: Arc<str>,
|
|
pub step: Arc<str>,
|
|
pub place: Arc<str>,
|
|
pub hit: Arc<str>,
|
|
pub fall: Arc<str>,
|
|
}
|
|
#[derive(Clone, Debug)]
|
|
pub struct StateFacts {
|
|
pub name: Arc<str>,
|
|
pub emission: u8,
|
|
pub dampening: u8,
|
|
pub skylight_down: bool,
|
|
pub shape_occlusion: bool,
|
|
pub can_occlude: bool,
|
|
pub solid_render: bool,
|
|
pub hardness: f32,
|
|
pub requires_tool: bool,
|
|
pub replaceable: bool,
|
|
pub random_ticks: bool,
|
|
pub block_entity: bool,
|
|
pub render_shape: RenderShape,
|
|
pub full_collision: bool,
|
|
pub friction: f32,
|
|
pub explosion_resistance: f32,
|
|
pub item: Arc<str>,
|
|
pub sounds: Sounds,
|
|
pub fluid: Fluid,
|
|
/// Fluid amount 1..=8 (8 = source/falling surface), 0 when there is no fluid.
|
|
pub fluid_level: u8,
|
|
pub fluid_falling: bool,
|
|
pub waterlogged: bool,
|
|
/// `hasOffsetFunction`: the model is jittered per column.
|
|
pub random_offset: bool,
|
|
/// Whether the outline, not just the model, follows BlockState.getOffset.
|
|
pub outline_offset: bool,
|
|
/// `BlockState.isSolid()` (legacy solidity; fluid surfaces read it).
|
|
pub legacy_solid: bool,
|
|
/// `isFaceSturdy(.., SupportType.FULL)` by Direction ordinal.
|
|
pub sturdy_full: u8,
|
|
/// The block's class chain (`TransparentBlock`, `LeavesBlock`, ...), most specific first.
|
|
pub classes: Arc<[Arc<str>]>,
|
|
/// `getShape` (the outline used for picking) as boxes in block space,
|
|
/// without the random offset; and its edges as LevelRenderer draws them.
|
|
pub outline: Arc<[[f64; 6]]>,
|
|
pub outline_edges: Arc<[[f64; 6]]>,
|
|
/// `getMapColor(..).id` (0 = NONE).
|
|
pub map_color: u8,
|
|
}
|
|
/// `MapColor.col` by id.
|
|
pub const MAP_COLORS: [u32; 62] = [
|
|
0, 8368696, 16247203, 13092807, 16711680, 10526975, 10987431, 31744, 16777215, 10791096,
|
|
9923917, 7368816, 4210943, 9402184, 16776437, 14188339, 11685080, 6724056, 15066419, 8375321,
|
|
15892389, 5000268, 10066329, 5013401, 8339378, 3361970, 6704179, 6717235, 10040115, 1644825,
|
|
16445005, 6085589, 4882687, 55610, 8476209, 7340544, 13742497, 10441252, 9787244, 7367818,
|
|
12223780, 6780213, 10505550, 3746083, 8874850, 5725276, 8014168, 4996700, 4993571, 5001770,
|
|
9321518, 2430480, 12398641, 9715553, 6035741, 1474182, 3837580, 5647422, 1356933, 6579300,
|
|
14200723, 8365974,
|
|
];
|
|
/// The 12 edges of the unit cube (outline data predating the export).
|
|
pub fn cube_edges() -> Vec<[f64; 6]> {
|
|
let mut edges = Vec::new();
|
|
for a in 0..3 {
|
|
for (u, v) in [(0., 0.), (1., 0.), (0., 1.), (1., 1.)] {
|
|
let mut from = [0.0f64; 3];
|
|
let (b, c) = ((a + 1) % 3, (a + 2) % 3);
|
|
from[b] = u;
|
|
from[c] = v;
|
|
let mut to = from;
|
|
to[a] = 1.0;
|
|
edges.push([from[0], from[1], from[2], to[0], to[1], to[2]]);
|
|
}
|
|
}
|
|
edges
|
|
}
|
|
impl StateFacts {
|
|
pub fn has_class(&self, name: &str) -> bool {
|
|
self.classes.iter().any(|c| &**c == name)
|
|
}
|
|
}
|
|
/// Compact, owned behaviour inputs retained until the normal behaviour startup stage.
|
|
/// No borrowed gameplay JSON or process-wide cache survives the fact loader.
|
|
pub struct GameplayProjection {
|
|
flags: u16,
|
|
emission: u64,
|
|
dampening: u64,
|
|
hardness: f64,
|
|
push: Arc<str>,
|
|
volume: f64,
|
|
pitch: f64,
|
|
place: Arc<str>,
|
|
break_sound: Arc<str>,
|
|
fall: Arc<str>,
|
|
}
|
|
|
|
impl GameplayProjection {
|
|
fn from_entry(entry: &decode::Entry<'_>, strings: &mut HashMap<String, Arc<str>>) -> Self {
|
|
fn intern(strings: &mut HashMap<String, Arc<str>>, value: &str) -> Arc<str> {
|
|
if let Some(existing) = strings.get(value) {
|
|
return Arc::clone(existing);
|
|
}
|
|
let value_arc: Arc<str> = Arc::from(value);
|
|
strings.insert(value.to_owned(), Arc::clone(&value_arc));
|
|
value_arc
|
|
}
|
|
const FLAGS: [&str; 11] = [
|
|
"replaceable",
|
|
"random_ticks",
|
|
"solid_render",
|
|
"liquid",
|
|
"block_entity",
|
|
"ignited_by_lava",
|
|
"can_occlude",
|
|
"full_collision",
|
|
"skylight_down",
|
|
"requires_tool",
|
|
"shape_occlusion",
|
|
];
|
|
Self {
|
|
flags: FLAGS.iter().enumerate().fold(0, |flags, (i, name)| {
|
|
flags | ((u16::from(entry.flag(name))) << i)
|
|
}),
|
|
emission: entry.unsigned("emission"),
|
|
dampening: entry.unsigned("dampening"),
|
|
hardness: entry.number("hardness"),
|
|
push: intern(strings, entry.text("push")),
|
|
volume: entry.sound_number("volume"),
|
|
pitch: entry.sound_number("pitch"),
|
|
place: intern(strings, entry.sound_id("place")),
|
|
break_sound: intern(strings, entry.sound_id("break")),
|
|
fall: intern(strings, entry.sound_id("fall")),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl GameplayStateSource for GameplayProjection {
|
|
fn flag(&self, name: &str) -> bool {
|
|
const FLAGS: [&str; 11] = [
|
|
"replaceable",
|
|
"random_ticks",
|
|
"solid_render",
|
|
"liquid",
|
|
"block_entity",
|
|
"ignited_by_lava",
|
|
"can_occlude",
|
|
"full_collision",
|
|
"skylight_down",
|
|
"requires_tool",
|
|
"shape_occlusion",
|
|
];
|
|
FLAGS
|
|
.iter()
|
|
.position(|field| *field == name)
|
|
.is_some_and(|index| self.flags & (1 << index) != 0)
|
|
}
|
|
fn unsigned(&self, name: &str) -> u64 {
|
|
match name {
|
|
"emission" => self.emission,
|
|
"dampening" => self.dampening,
|
|
_ => 0,
|
|
}
|
|
}
|
|
fn number(&self, name: &str) -> f64 {
|
|
if name == "hardness" {
|
|
self.hardness
|
|
} else {
|
|
0.0
|
|
}
|
|
}
|
|
fn text(&self, name: &str) -> &str {
|
|
if name == "push" { &self.push } else { "" }
|
|
}
|
|
fn sound_number(&self, name: &str) -> f64 {
|
|
match name {
|
|
"volume" => self.volume,
|
|
"pitch" => self.pitch,
|
|
_ => 1.0,
|
|
}
|
|
}
|
|
fn sound_id(&self, name: &str) -> &str {
|
|
match name {
|
|
"place" => &self.place,
|
|
"break" => &self.break_sound,
|
|
"fall" => &self.fall,
|
|
_ => "",
|
|
}
|
|
}
|
|
}
|
|
|
|
pub struct BlockFacts {
|
|
pub states: Vec<StateFacts>,
|
|
pub air: BlockStateId,
|
|
}
|
|
impl BlockFacts {
|
|
pub fn load(root: &Path, registry: &BlockRegistry) -> Result<Self> {
|
|
let behaviours: Value = serde_json::from_reader(BufReader::new(File::open(
|
|
root.join("block-behaviours.json"),
|
|
)?))?;
|
|
Self::load_with_behaviour_json(root, registry, &behaviours)
|
|
}
|
|
|
|
/// Load both tables from one resource root, sharing each JSON decode.
|
|
/// No data is cached across calls: changes to prepared packs or mods are read again.
|
|
pub fn load_pair(root: &Path, registry: &BlockRegistry) -> Result<(Self, Behaviours)> {
|
|
let behaviours: Value = serde_json::from_reader(BufReader::new(File::open(
|
|
root.join("block-behaviours.json"),
|
|
)?))?;
|
|
Self::load_with_behaviours(root, registry, &behaviours)
|
|
}
|
|
|
|
/// Decode state facts once, retaining only the small owned fields needed later.
|
|
pub fn load_with_projection(
|
|
root: &Path,
|
|
registry: &BlockRegistry,
|
|
behaviours: &Value,
|
|
) -> Result<(Self, Vec<GameplayProjection>)> {
|
|
Self::load_with_callback(root, registry, behaviours, |entries| {
|
|
let mut strings = HashMap::new();
|
|
Ok(entries
|
|
.iter()
|
|
.map(|entry| GameplayProjection::from_entry(entry, &mut strings))
|
|
.collect())
|
|
})
|
|
}
|
|
|
|
pub fn load_with_behaviour_json(
|
|
root: &Path,
|
|
registry: &BlockRegistry,
|
|
behaviours: &Value,
|
|
) -> Result<Self> {
|
|
Ok(Self::load_with_callback(root, registry, behaviours, |_| Ok(()))?.0)
|
|
}
|
|
|
|
/// Build both tables from the same behaviour document and gameplay decoder.
|
|
pub fn load_with_behaviours(
|
|
root: &Path,
|
|
registry: &BlockRegistry,
|
|
behaviours: &Value,
|
|
) -> Result<(Self, Behaviours)> {
|
|
Self::load_with_callback(root, registry, behaviours, |entries| {
|
|
Ok(Behaviours::load_with_gameplay(
|
|
registry, root, behaviours, entries,
|
|
)?)
|
|
})
|
|
}
|
|
|
|
fn load_with_callback<T>(
|
|
root: &Path,
|
|
registry: &BlockRegistry,
|
|
behaviours: &Value,
|
|
callback: impl FnOnce(&[decode::Entry<'_>]) -> Result<T>,
|
|
) -> Result<(Self, T)> {
|
|
let bytes = fs::read(root.join("gameplay-facts.json"))?;
|
|
serde_json::from_slice::<decode::Validate>(&bytes)?;
|
|
let raw: decode::Gameplay<'_> = serde_json::from_slice(&bytes)?;
|
|
let entries = raw
|
|
.states
|
|
.0
|
|
.as_ref()
|
|
.ok_or("missing gameplay state facts")?;
|
|
if entries.len() != registry.len() {
|
|
return Err("gameplay facts do not match the block registry".into());
|
|
}
|
|
// Class chains and per-state behaviour flags exported from the actual block objects.
|
|
let behaviour_states = behaviours["states"]
|
|
.as_array()
|
|
.filter(|s| s.len() == registry.len())
|
|
.ok_or("block behaviour facts do not match the block registry")?;
|
|
let mut class_names: HashMap<String, Arc<str>> = HashMap::new();
|
|
let classes: HashMap<&str, Arc<[Arc<str>]>> = behaviours["blocks"]
|
|
.as_array()
|
|
.ok_or("missing block behaviour classes")?
|
|
.iter()
|
|
.filter_map(|b| {
|
|
let chain = b["class"]
|
|
.as_array()?
|
|
.iter()
|
|
.filter_map(Value::as_str)
|
|
.map(|c| {
|
|
class_names
|
|
.entry(c.to_owned())
|
|
.or_insert_with(|| Arc::from(c))
|
|
.clone()
|
|
});
|
|
Some((b["name"].as_str()?, chain.collect()))
|
|
})
|
|
.collect();
|
|
let mut names: HashMap<String, Arc<str>> = HashMap::new();
|
|
let mut intern = |s: &str| -> Arc<str> {
|
|
if let Some(name) = names.get(s) {
|
|
return name.clone();
|
|
}
|
|
let name: Arc<str> = Arc::from(s);
|
|
names.insert(s.to_owned(), name.clone());
|
|
name
|
|
};
|
|
let mut shapes = decode::Shapes::default();
|
|
let mut states = Vec::with_capacity(entries.len());
|
|
for (index, entry) in entries.iter().enumerate() {
|
|
let id = BlockStateId(index as u32);
|
|
if entry.id != Some(index as u64) {
|
|
return Err("gameplay facts are not in registry order".into());
|
|
}
|
|
let state = registry.state(id).ok_or("missing registry state")?;
|
|
let sound = &entry.sound;
|
|
let prop = |k: &str| state.properties.get(k).map(String::as_str);
|
|
let (fluid, fluid_level, fluid_falling) = match state.name.as_str() {
|
|
"minecraft:water" | "minecraft:lava" => {
|
|
let level: u8 = prop("level").and_then(|v| v.parse().ok()).unwrap_or(0);
|
|
let kind = if state.name == "minecraft:water" {
|
|
Fluid::Water
|
|
} else {
|
|
Fluid::Lava
|
|
};
|
|
// LiquidBlock: level 0 is the source; 1..7 flowing; >=8 falling.
|
|
if level == 0 {
|
|
(kind, 8, false)
|
|
} else if level >= 8 {
|
|
(kind, 8, true)
|
|
} else {
|
|
(kind, 8 - level, false)
|
|
}
|
|
}
|
|
"minecraft:bubble_column"
|
|
| "minecraft:kelp"
|
|
| "minecraft:kelp_plant"
|
|
| "minecraft:seagrass"
|
|
| "minecraft:tall_seagrass" => (Fluid::Water, 8, false),
|
|
_ if prop("waterlogged") == Some("true") => (Fluid::Water, 8, false),
|
|
_ => (Fluid::None, 0, false),
|
|
};
|
|
let air = matches!(
|
|
state.name.as_str(),
|
|
"minecraft:air" | "minecraft:cave_air" | "minecraft:void_air"
|
|
);
|
|
let cube = move || {
|
|
if air {
|
|
Vec::new()
|
|
} else {
|
|
vec![[0.0, 0.0, 0.0, 1.0, 1.0, 1.0]]
|
|
}
|
|
};
|
|
let edges = move || if air { Vec::new() } else { cube_edges() };
|
|
let outline = shapes.intern(entry.outline, cube)?;
|
|
let outline_edges = shapes.intern(entry.outline_edges, edges)?;
|
|
// The export holds MapColor.col; ids are positions in MAP_COLORS.
|
|
let col = entry.map_color.unwrap_or(0) as u32;
|
|
let map_color = if col == 0 {
|
|
0
|
|
} else {
|
|
MAP_COLORS.iter().position(|c| *c == col).unwrap_or(0) as u8
|
|
};
|
|
states.push(StateFacts {
|
|
map_color,
|
|
outline,
|
|
outline_edges,
|
|
name: intern(&state.name),
|
|
emission: entry.emission.as_f64().unwrap_or(0.0) as u8,
|
|
dampening: entry.dampening.as_f64().unwrap_or(0.0) as u8,
|
|
skylight_down: entry.skylight_down,
|
|
shape_occlusion: entry.shape_occlusion,
|
|
can_occlude: entry.can_occlude,
|
|
solid_render: entry.solid_render,
|
|
hardness: entry.hardness.as_f64().unwrap_or(0.0) as f32,
|
|
requires_tool: entry.requires_tool,
|
|
replaceable: entry.replaceable,
|
|
random_ticks: entry.random_ticks,
|
|
block_entity: entry.block_entity,
|
|
render_shape: match entry.render_shape.as_deref() {
|
|
Some("INVISIBLE") => RenderShape::Invisible,
|
|
Some("ENTITYBLOCK_ANIMATED") => RenderShape::Animated,
|
|
_ => RenderShape::Model,
|
|
},
|
|
full_collision: entry.full_collision,
|
|
friction: entry.friction as f32,
|
|
explosion_resistance: entry.explosion_resistance as f32,
|
|
item: intern(entry.item.as_deref().unwrap_or("minecraft:air")),
|
|
sounds: Sounds {
|
|
volume: sound.volume as f32,
|
|
pitch: sound.pitch as f32,
|
|
break_sound: intern(sound.r#break.id.as_deref().unwrap_or("")),
|
|
step: intern(sound.step.id.as_deref().unwrap_or("")),
|
|
place: intern(sound.place.id.as_deref().unwrap_or("")),
|
|
hit: intern(sound.hit.id.as_deref().unwrap_or("")),
|
|
fall: intern(sound.fall.id.as_deref().unwrap_or("")),
|
|
},
|
|
fluid,
|
|
fluid_level,
|
|
fluid_falling,
|
|
waterlogged: prop("waterlogged") == Some("true"),
|
|
random_offset: entry.offset,
|
|
outline_offset: entry.outline_offset.unwrap_or(entry.offset),
|
|
legacy_solid: behaviour_states[index][1].as_u64().unwrap_or(0) & 1 != 0,
|
|
sturdy_full: (behaviour_states[index][0].as_u64().unwrap_or(0) & 63) as u8,
|
|
classes: classes
|
|
.get(state.name.as_str())
|
|
.cloned()
|
|
.ok_or("missing block behaviour class chain")?,
|
|
});
|
|
}
|
|
let extra = callback(entries)?;
|
|
Ok((
|
|
Self {
|
|
states,
|
|
air: registry
|
|
.default_state("minecraft:air")
|
|
.ok_or("missing air")?,
|
|
},
|
|
extra,
|
|
))
|
|
}
|
|
pub fn get(&self, id: BlockStateId) -> &StateFacts {
|
|
&self.states[id.0 as usize]
|
|
}
|
|
pub fn is_air(&self, id: BlockStateId) -> bool {
|
|
matches!(
|
|
&*self.states[id.0 as usize].name,
|
|
"minecraft:air" | "minecraft:cave_air" | "minecraft:void_air"
|
|
)
|
|
}
|
|
}
|
|
|
|
impl GameplayStateSource for decode::Entry<'_> {
|
|
fn flag(&self, name: &str) -> bool {
|
|
match name {
|
|
"replaceable" => self.replaceable,
|
|
"random_ticks" => self.random_ticks,
|
|
"solid_render" => self.solid_render,
|
|
"liquid" => self.liquid,
|
|
"block_entity" => self.block_entity,
|
|
"ignited_by_lava" => self.ignited_by_lava,
|
|
"can_occlude" => self.can_occlude,
|
|
"full_collision" => self.full_collision,
|
|
"skylight_down" => self.skylight_down,
|
|
"requires_tool" => self.requires_tool,
|
|
"shape_occlusion" => self.shape_occlusion,
|
|
_ => false,
|
|
}
|
|
}
|
|
fn unsigned(&self, name: &str) -> u64 {
|
|
match name {
|
|
"emission" => self.emission.as_u64().unwrap_or(0),
|
|
"dampening" => self.dampening.as_u64().unwrap_or(0),
|
|
_ => 0,
|
|
}
|
|
}
|
|
fn number(&self, name: &str) -> f64 {
|
|
match name {
|
|
"hardness" => self.hardness.as_f64().unwrap_or(0.0),
|
|
_ => 0.0,
|
|
}
|
|
}
|
|
fn text(&self, name: &str) -> &str {
|
|
match name {
|
|
"push" => self.push.as_deref().unwrap_or(""),
|
|
_ => "",
|
|
}
|
|
}
|
|
fn sound_number(&self, name: &str) -> f64 {
|
|
match name {
|
|
"volume" => self.sound.volume,
|
|
"pitch" => self.sound.pitch,
|
|
_ => 1.0,
|
|
}
|
|
}
|
|
fn sound_id(&self, name: &str) -> &str {
|
|
match name {
|
|
"place" => self.sound.place.id.as_deref().unwrap_or(""),
|
|
"break" => self.sound.r#break.id.as_deref().unwrap_or(""),
|
|
"fall" => self.sound.fall.id.as_deref().unwrap_or(""),
|
|
_ => "",
|
|
}
|
|
}
|
|
}
|