Merge main into fix/furnace-on-server

lan_actions.rs: clear the old body's potions (main), then respawn with
the tick context (this branch). hub.rs: keep main's effect and chunk
tracking reset before this branch's vanilla respawn sequence.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
Ludovic Marie
2026-10-17 05:35:16 +02:00
92 changed files with 6219 additions and 716 deletions
+1 -1
View File
@@ -83,7 +83,7 @@ jobs:
- name: The harnesses this change can affect
env:
PARITY_HOSTS: ''
run: python3 tools/parity.py --changed ${{ github.event.pull_request.base.sha }} --timeout 1500
run: python3 tools/parity.py --changed ${{ github.event.pull_request.base.sha }} --timeout 2400 # world_spawn takes ~1480 s on a busy runner
- name: Logs of the failed harnesses
if: failure()
uses: actions/upload-artifact@v4
@@ -88,6 +88,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
seed: 0,
max_players: 8,
dedicated: false,
integrated: false,
},
);
let mut next_entity = 100u32;
@@ -0,0 +1,271 @@
//! The Horizon side of a mod port's harness (tools/mod_port_harness.py,
//! docs/modpacks.md): builds the content root for carried-over mods and
//! writes what Horizon makes of every block state, drop, recipe and tag the
//! NeoForge oracle exported.
//!
//! cargo run -p horizon-client --example mod_port_probe -- PREPARED WORK OUT.json [MOD...]
//!
//! WORK is a `horizon-port-pack` work folder: `oracle/facts.json` and
//! `mods/<id>/carry/`. The root is built in `WORK/horizon-root`.
use horizon_client::{
Result,
assets::Assets,
blocks::BlockFacts,
crafting::{Recipe, Recipes},
items::{ItemStack, Items},
mod_content::{self, ContentMod},
stations::StationRecipes,
};
use horizon_core::{geometry::Axis, random::LegacyRandom};
use horizon_world::chunk::BlockState;
use serde_json::{Map, Value, json};
use std::{collections::BTreeMap, fs, path::Path};
fn boxes(list: impl IntoIterator<Item = [f64; 6]>) -> Value {
let mut v: Vec<[f64; 6]> = list.into_iter().collect();
v.sort_by(|a, b| a.partial_cmp(b).unwrap_or(std::cmp::Ordering::Equal));
json!(v)
}
fn sound(s: &horizon_client::blocks::Sounds) -> Value {
json!({"volume": s.volume, "pitch": s.pitch, "break": &*s.break_sound, "step": &*s.step,
"place": &*s.place, "hit": &*s.hit, "fall": &*s.fall})
}
fn tool(name: &str) -> Option<ItemStack> {
match name {
"hand" => None,
"silk_touch_pickaxe" => {
let mut pick = ItemStack::new("minecraft:diamond_pickaxe", 1);
pick.enchant("minecraft:silk_touch", 1);
Some(pick)
}
other => Some(ItemStack::new(&format!("minecraft:{other}"), 1)),
}
}
fn main() -> Result<()> {
let args: Vec<String> = std::env::args().skip(1).collect();
let [base, work, out, wanted @ ..] = args.as_slice() else {
return Err("usage: mod_port_probe PREPARED WORK OUT.json [MOD...]".into());
};
let (base, work) = (Path::new(base), Path::new(work));
let oracle: Value = serde_json::from_slice(&fs::read(work.join("oracle/facts.json"))?)?;
let mut mods = Vec::new();
for entry in fs::read_dir(work.join("mods"))?.flatten() {
let id = entry.file_name().to_string_lossy().into_owned();
let dir = entry.path().join("carry");
if !(wanted.is_empty() || wanted.contains(&id)) || !dir.is_dir() {
continue;
}
let package = horizon_mods::Package::read(&dir)?;
let content = horizon_mods::Content::read(&dir, &package.manifest)?;
mods.push(ContentMod {
id: package.manifest.id.clone(),
content,
});
}
mods.sort_by(|a, b| a.id.cmp(&b.id));
let root = work.join("horizon-root");
let began = std::time::Instant::now();
let step = |what: &str| {
let what = what.to_owned();
move |e: Box<dyn std::error::Error>| format!("{what}: {e}")
};
mod_content::build(base, &mods, &root).map_err(step("content root"))?;
let built = began.elapsed().as_secs_f64();
let assets = Assets::load(&root).map_err(step("assets"))?;
let registry = assets.registry;
let facts = BlockFacts::load(&root, registry).map_err(step("block facts"))?;
let items = Items::load(&root, registry, &facts).map_err(step("items"))?;
let recipes = Recipes::load(&root, &items).map_err(step("recipes"))?;
let stations = StationRecipes::load(&root, &items);
let collisions =
horizon_client::collisions::load(&root, registry).map_err(step("collisions"))?;
let loaded = began.elapsed().as_secs_f64() - built;
let ours = |id: &str| {
id.split_once(':')
.is_some_and(|(ns, _)| mods.iter().any(|m| m.id == ns))
};
let tools: Vec<String> = serde_json::from_value(oracle["tools"].clone())?;
let mut blocks = Map::new();
for (name, block) in oracle["blocks"].as_object().ok_or("oracle: no blocks")? {
if !ours(name) {
continue;
}
let Some(default) = registry.default_state(name) else {
blocks.insert(name.clone(), Value::Null);
continue;
};
let mut states = Map::new();
for (key, o) in block["states"].as_object().into_iter().flatten() {
let properties: BTreeMap<String, String> = key
.split(',')
.filter(|p| !p.is_empty())
.filter_map(|p| p.split_once('='))
.map(|(k, v)| (k.to_owned(), v.to_owned()))
.collect();
let descriptor = BlockState {
name: name.clone(),
properties,
};
let Some(id) = registry.id(&descriptor) else {
states.insert(key.clone(), Value::Null);
continue;
};
let f = facts.get(id);
let collision = collisions
.cached_shapes()
.cached_shape(id)
.ok()
.flatten()
.map(|s| {
boxes(s.boxes().iter().map(|b| {
[
b.min(Axis::X),
b.min(Axis::Y),
b.min(Axis::Z),
b.max(Axis::X),
b.max(Axis::Y),
b.max(Axis::Z),
]
}))
});
let mut row = json!({
"hardness": f.hardness,
"explosion_resistance": f.explosion_resistance,
"emission": f.emission,
"requires_tool": f.requires_tool,
"friction": f.friction,
"map_color_id": f.map_color,
"can_occlude": f.can_occlude,
"sound": sound(&f.sounds),
"outline": boxes(f.outline.iter().copied()),
"collision": collision,
"classes": f.classes.iter().map(|c| &**c).collect::<Vec<_>>(),
});
if o.get("drops").is_some() {
let mut drops = Map::new();
for t in &tools {
let mut random = LegacyRandom::new(0);
let held = tool(t);
let mut counts: BTreeMap<String, u32> = BTreeMap::new();
for s in items.block_drops(registry, id, held.as_ref(), &mut random) {
*counts.entry(s.item.to_string()).or_default() += s.count;
}
drops.insert(t.clone(), json!(counts));
}
row["drops"] = Value::Object(drops);
}
states.insert(key.clone(), row);
}
let item = facts.get(default).item.to_string();
blocks.insert(
name.clone(),
json!({"states": states, "item": item, "item_known": items.items.contains_key(&*item)}),
);
}
// Vanilla's sounds, by block: the harness maps the oracle's version's
// sound events to this one's through them.
let mut vanilla_sounds = Map::new();
for name in oracle["blocks"]
.as_object()
.into_iter()
.flatten()
.map(|(k, _)| k)
{
if let Some(id) = name
.starts_with("minecraft:")
.then(|| registry.default_state(name))
.flatten()
{
vanilla_sounds.insert(name.clone(), sound(&facts.get(id).sounds));
}
}
let mut item_rows = Map::new();
for name in oracle["items"]
.as_object()
.into_iter()
.flatten()
.map(|(k, _)| k)
{
item_rows.insert(
name.clone(),
match items.items.get(name.as_str()) {
Some(i) => json!({"max_stack_size": i.max_stack, "block": i.block.map(|b| b.0)}),
None => Value::Null,
},
);
}
let sorted = |list: &[String]| {
let mut v = list.to_vec();
v.sort();
v.dedup();
v
};
let mut recipe_rows = Map::new();
for (name, recipe) in &recipes.crafting {
if !ours(name) {
continue;
}
let row = match recipe {
Recipe::Shaped { cells, result, .. } => json!({
"result": result.item.as_deref(), "count": result.count,
"ingredients": cells.iter().flatten().map(|i| sorted(&i.1)).collect::<Vec<_>>()}),
Recipe::Shapeless {
ingredients,
result,
} => json!({
"result": result.item.as_deref(), "count": result.count,
"ingredients": ingredients.iter().map(|i| sorted(&i.1)).collect::<Vec<_>>()}),
Recipe::Special(_) => json!({"special": true}),
};
recipe_rows.insert(name.clone(), row);
}
for c in recipes.cooking.iter().filter(|c| ours(&c.id)) {
recipe_rows.insert(
c.id.clone(),
json!({"result": &*c.result.item, "count": c.result.count,
"ingredients": [sorted(&c.ingredient.1)]}),
);
}
for s in stations.stonecutting.iter().filter(|s| ours(&s.id)) {
recipe_rows.insert(
s.id.clone(),
json!({"result": &*s.result.item, "count": s.result.count,
"ingredients": [sorted(&s.input.1)]}),
);
}
let mut block_tags = Map::new();
for (tag, members) in &items.block_tags {
let mut ids: Vec<&String> = members.iter().filter(|m| ours(m)).collect();
if !ids.is_empty() {
ids.sort();
block_tags.insert(tag.clone(), json!(ids));
}
}
let report = json!({
"states": registry.len(),
"build_seconds": built,
"load_seconds": loaded,
"blocks": blocks,
"items": item_rows,
"recipes": recipe_rows,
"block_tags": block_tags,
"vanilla_sounds": vanilla_sounds,
});
fs::write(out, serde_json::to_vec(&report)?)?;
println!(
"{out}: {} blocks, {} items, {} recipes; root built in {built:.2} s, loaded in {loaded:.2} s",
blocks.len(),
item_rows.len(),
recipe_rows.len()
);
Ok(())
}
+1 -1
View File
@@ -245,7 +245,7 @@ impl Assets {
material_states,
sprite_size: sprites.size,
sprite_minimum_size: sprites.minimum_size,
texture_layers: u32::try_from(sprites.layers.len())?,
texture_layers: u32::try_from(sprites.count())?,
pixels: sprites.pixels,
model_catalog: models.catalog,
model_library,
+26
View File
@@ -199,6 +199,14 @@ pub fn dye_rgb(name: &str) -> u32 {
pub fn layers(stack: &ItemStack) -> &[BannerLayer] {
stack.data().map_or(&[], |d| &d.banner_patterns)
}
/// The ominous banner's component patch hides its pattern tooltip.
pub fn tooltip_layers(stack: &ItemStack) -> &[BannerLayer] {
if stack.data().is_some_and(|d| d.ominous_banner) {
&[]
} else {
layers(stack)
}
}
/// `LoomMenu.setupResultSlot`: one banner with the pattern added in the dye colour.
pub fn loom_result(banner: &ItemStack, dye: &str, pattern: &str) -> ItemStack {
let mut result = ItemStack {
@@ -302,6 +310,24 @@ mod tests {
}
assert!(has_max_layers(&banner));
}
#[test]
fn ominous_banner_hides_tooltip_layers_but_keeps_its_patterns() {
let mut banner = crate::mobs::raider::ominous_banner();
(banner.damage, banner.extra) = crate::item_data::decode_components(
crate::item_data::encode_components(&banner).as_ref(),
);
assert_eq!(
layers(&banner).len(),
crate::item_data::OMINOUS_LAYERS.len()
);
assert!(tooltip_layers(&banner).is_empty());
banner.data_mut().custom_name = Some("Captain's Standard".into());
assert!(tooltip_layers(&banner).is_empty());
banner.data_mut().ominous_banner = false;
assert_eq!(tooltip_layers(&banner), layers(&banner));
assert!(!tooltip_layers(&banner).is_empty());
}
#[test]
fn layers_round_trip_through_nbt() {
let l = vec![
@@ -876,7 +876,7 @@ impl BlockEntityRenderer {
.as_vec3();
let base = Mat4::from_translation(origin);
let packed = scene.world.light(pos[0], pos[1], pos[2]);
self.render_one(scene, *pos, kind, base, packed, lights, out);
self.render_one(scene, *pos, kind, base, packed, lights, false, out);
}
}
/// One block entity at `pos` drawn under `base` with the given packed light
@@ -892,12 +892,39 @@ impl BlockEntityRenderer {
) {
let kind = self.kind(state);
let lights = diffuse_lights(scene.nether);
self.render_one(scene, pos, kind, base, packed, lights, out);
self.render_one(scene, pos, kind, base, packed, lights, false, out);
}
/// Whether this block state has a block-entity renderer here.
pub fn renders(&self, state: u32) -> bool {
!matches!(self.kind(state), Kind::None)
}
/// BannerRenderer submits the support and animated flag once for crumbling.
pub fn render_banner_breaking(
&self,
scene: &Scene,
pos: [i32; 3],
state: u32,
out: &mut Vec<Vertex>,
) {
if !matches!(self.kind(state), Kind::Banner { .. }) {
return;
}
let origin = (DVec3::new(f64::from(pos[0]), f64::from(pos[1]), f64::from(pos[2]))
- scene.camera)
.as_vec3();
let start = out.len();
self.render_one(
scene,
pos,
self.kind(state),
Mat4::from_translation(origin),
0xff,
diffuse_lights(scene.nether),
true,
out,
);
crate::breaking::entity_geometry(&mut out[start..], origin);
}
/// `ChestRenderer.extractRenderState`'s openness for the chest of `state`
/// at `pos`: `ChestBlock.combine` (`DoubleBlockCombiner.combineWithNeigbour`)
/// pairs a double half with its neighbour only when that is the same
@@ -970,7 +997,7 @@ impl BlockEntityRenderer {
let kind = self.kind(state);
if !matches!(kind, Kind::None) {
let lights = diffuse_lights(scene.nether);
self.render_one(scene, [i32::MAX; 3], kind, base, packed, lights, out);
self.render_one(scene, [i32::MAX; 3], kind, base, packed, lights, false, out);
}
}
#[allow(clippy::too_many_arguments)]
@@ -982,11 +1009,24 @@ impl BlockEntityRenderer {
base: Mat4,
packed: u8,
lights: (Vec3, Vec3),
crumbling: bool,
out: &mut Vec<Vertex>,
) {
let sprite = |name: &str| scene.sprites.get(name).copied();
let paint = |name: &str, tint: u32, packed: u8| {
sprite(name).map(|s| Paint {
let rect = if crumbling {
Some(Rect {
u0: 0.0,
v0: 0.0,
u1: 1.0,
v1: 1.0,
w: 16,
h: 16,
})
} else {
sprite(name)
};
rect.map(|s| Paint {
sprite: s,
tint,
light: vertex_light(packed),
@@ -1145,6 +1185,10 @@ impl BlockEntityRenderer {
draw_part(main, "root", m, &none, paint, out);
draw_part(flag, "root", m, &wave, paint, out);
}
// Pattern passes must not multiply the crumbling decal.
if crumbling {
return;
}
// BannerRenderer.submitPatterns: the base pattern layer in the dye colour,
// then up to 16 pattern layers in order.
if let Some(paint) = paint("entity/banner/base", *color, packed) {
@@ -1673,6 +1717,109 @@ fn portal_cube(m: Mat4, faces: &[Direction], layer: u32, out: &mut Vec<Vertex>)
#[cfg(test)]
mod tests {
use super::*;
#[test]
#[ignore = "requires prepared models/textures in HORIZON_TEST_RESOURCES"]
fn banner_particle_and_breaking_use_exported_models() -> crate::Result<()> {
use crate::{models::catalog::StateModels, sprites::Sprites};
use horizon_world::{DATA_VERSION, chunk::BlockState, nbt::Tag};
let root = std::path::PathBuf::from(
std::env::var_os("HORIZON_TEST_RESOURCES").expect("HORIZON_TEST_RESOURCES"),
);
let names = ["white_banner", "white_wall_banner"];
let mut facts: std::collections::BTreeMap<String, Value> =
serde_json::from_slice(&std::fs::read(root.join("model-states.json"))?)?;
let states = names.map(|name| {
let name = format!("minecraft:{name}");
let first = facts[&name]["states"][0].clone();
facts.get_mut(&name).unwrap()["states"] = serde_json::json!([first.clone()]);
BlockState {
name,
properties: serde_json::from_value(first).unwrap(),
}
.to_nbt()
});
let registry = BlockRegistry::from_nbt(&Tag::compound([
("DataVersion", Tag::Int(DATA_VERSION)),
("states", Tag::List(states.into())),
(
"defaults",
Tag::compound([
("minecraft:white_banner", Tag::Int(0)),
("minecraft:white_wall_banner", Tag::Int(1)),
]),
),
]))?;
let mut sprites = Sprites::default();
let catalog = StateModels::from_facts(&root, &registry, &names, &mut sprites, &facts)?;
for id in 0..2 {
let models = catalog.collect(
BlockStateId(id),
horizon_core::position::BlockPos::default(),
)?;
assert!(models.iter().all(|(_, model)| model.faces.is_empty()));
assert_eq!(
models[0].1.particle,
Some(sprites.layers["minecraft:block/oak_planks"])
);
}
let all: Value = serde_json::from_slice(&std::fs::read(root.join("entity-models.json"))?)?;
let renderer = BlockEntityRenderer::new(
MODELS
.iter()
.filter_map(|(key, layer)| all.get(*layer).map(|v| (*key, ModelPart::parse(v))))
.collect(),
&registry,
);
let world = World::new(BlockStateId(0), 1);
let base_sprites = HashMap::from([(
"entity/banner/banner_base".to_owned(),
Rect {
u0: 0.0,
v0: 0.0,
u1: 1.0,
v1: 1.0,
w: 16,
h: 16,
},
)]);
let mut scene = Scene {
camera: DVec3::ZERO,
orientation: Quat::IDENTITY,
anim: &|_| BlockAnim::default(),
texts: None,
partial: 0.5,
game_time: 0,
max_y: 320,
world: &world,
sprites: &base_sprites,
nether: false,
lid: &|_| 0.0,
sign: &|_| None,
banner: &|_| Vec::new(),
glyph: &|_| (None, 0.0),
};
for state in 0..2 {
let mut base = Vec::new();
renderer.render_block(&scene, [0; 3], state, Mat4::IDENTITY, 0xff, &mut base);
let mut cracks = Vec::new();
renderer.render_banner_breaking(&scene, [0; 3], state, &mut cracks);
assert!(!cracks.is_empty());
assert_eq!(
base.iter().map(|v| v.pos).collect::<Vec<_>>(),
cracks.iter().map(|v| v.pos).collect::<Vec<_>>()
);
assert!(cracks.iter().all(|v| v.layer == 11
&& v.color == u32::MAX
&& v.uv.iter().all(|u| u.is_finite())));
scene.game_time = 20;
let mut animated = Vec::new();
renderer.render_banner_breaking(&scene, [0; 3], state, &mut animated);
assert!(cracks.iter().zip(&animated).any(|(a, b)| a.pos != b.pos));
scene.game_time = 0;
}
Ok(())
}
#[test]
fn classifies_vanilla_block_names() {
let props = |pairs: &'static [(&'static str, &'static str)]| {
+48
View File
@@ -41,6 +41,35 @@ pub fn geometry(model: &BakedModel, origin: glam::Vec3, translucent: bool, out:
}
}
/// Project a block entity's transformed quads onto the same destroy-stage pass.
pub fn entity_geometry(vertices: &mut [Vertex], origin: glam::Vec3) {
for quad in vertices.as_chunks_mut::<4>().0 {
let positions = [0, 1, 2].map(|i| glam::Vec3::from(quad[i].pos));
let normal = (positions[1] - positions[0]).cross(positions[2] - positions[0]);
let mut facing = Direction::North;
let mut best = f32::from_bits(1);
for (direction, dot) in [
(Direction::Down, -normal.y),
(Direction::Up, normal.y),
(Direction::North, -normal.z),
(Direction::South, normal.z),
(Direction::West, -normal.x),
(Direction::East, normal.x),
] {
if dot > best {
facing = direction;
best = dot;
}
}
for vertex in quad {
vertex.uv = decal_uv((glam::Vec3::from(vertex.pos) - origin).to_array(), facing);
vertex.layer = 11;
vertex.color = 0xffff_ffff;
vertex.light = 240 | (240 << 8);
}
}
}
#[cfg(test)]
mod tests {
use super::*;
@@ -49,6 +78,7 @@ mod tests {
fn slab_top() -> BakedModel {
BakedModel {
ambient_occlusion: true,
particle: None,
cube: None,
faces: vec![BakedFace {
layer: 0,
@@ -86,6 +116,24 @@ mod tests {
assert_eq!(v.color, 0xffff_ffff);
}
}
#[test]
fn entity_overlay_uses_block_local_projected_uvs() {
let origin = glam::Vec3::new(12.0, -3.0, 8.0);
let mut expected = Vec::new();
geometry(&slab_top(), origin, false, &mut expected);
let mut actual = expected.clone();
for vertex in &mut actual {
vertex.uv = [0.0; 2];
vertex.layer = 0;
vertex.color = 0;
}
entity_geometry(&mut actual, origin);
assert_eq!(
bytemuck::cast_slice::<_, u8>(&actual),
bytemuck::cast_slice::<_, u8>(&expected)
);
}
#[test]
fn small_faces_use_projected_not_stretched_uvs() {
let a = decal_uv([0.0, 0.0, 0.0], Direction::North);
+1 -1
View File
@@ -28,7 +28,7 @@ use std::{fs, io, path::Path, sync::Arc};
pub fn load<'r>(root: &Path, registry: &'r BlockRegistry) -> Result<BlockCollisionRegistry<'r>> {
let data = nbt::read_named(
&fs::read(root.join("cached-collision.nbt"))?,
Limits::default(),
Limits::tables(),
)?
.0
.tag;
+2
View File
@@ -132,6 +132,8 @@ impl Crafter {
pub struct Banner {
pub layers: Vec<crate::banner::BannerLayer>,
pub name: Option<String>,
/// Components not consumed by BannerBlockEntity's implicit fields.
pub components: horizon_world::nbt::Compound,
}
/// `CreakingHeartBlockEntity` (the logic is in `game/creaking.rs`).
#[derive(Clone, Debug, Default)]
+39
View File
@@ -74,6 +74,10 @@ pub struct DebugCharts {
pub bandwidth: SampleLogger,
/// `MinecraftServer.smoothedTickTimeMillis`.
pub smoothed_tick_ms: f32,
/// Connection's smoothed packets per second, sent then received.
pub packet_rates: [f32; 2],
packet_totals: [i64; 2],
packet_tick: u8,
previous_tick: Option<Instant>,
bytes_seen: Option<i64>,
}
@@ -113,6 +117,9 @@ impl DebugCharts {
self.previous_tick = None;
self.bytes_seen = None;
self.smoothed_tick_ms = 0.0;
self.packet_rates = [0.0; 2];
self.packet_totals = [0; 2];
self.packet_tick = 0;
}
/// One integrated server tick that started at `started` and ran its
/// tick method for `method` (`MinecraftServer.logFullTickTime` and
@@ -136,6 +143,17 @@ impl DebugCharts {
}
self.bytes_seen = Some(total);
}
/// `Connection.tickSecond`: sampled on the first tick, then every 20 ticks.
pub fn log_packets(&mut self, totals: [i64; 2]) {
if self.packet_tick == 0 {
for (i, total) in totals.into_iter().enumerate() {
let count = (total - self.packet_totals[i]).max(0) as f32;
self.packet_rates[i] = count + 0.75 * (self.packet_rates[i] - count);
}
self.packet_totals = totals;
}
self.packet_tick = (self.packet_tick + 1) % 20;
}
/// The charts along the bottom of the screen (`extractRenderState`):
/// frame times left and tick times right, or bandwidth left (remote
/// servers only) and ping right. `mspt` is the level's milliseconds
@@ -524,6 +542,27 @@ mod tests {
assert!(draws.contains(&fill(361, 174, 365, 178, 0xFF0A_141E)));
}
#[test]
fn packet_rates_follow_connection_smoothing_and_reset_between_worlds() {
let mut charts = DebugCharts::default();
charts.log_packets([80, 400]);
assert_eq!(charts.packet_rates, [20.0, 100.0]);
for _ in 1..20 {
charts.log_packets([180, 800]);
}
assert_eq!(charts.packet_rates, [20.0, 100.0]);
charts.log_packets([180, 800]);
assert_eq!(charts.packet_rates, [40.0, 175.0]);
for _ in 0..20 {
charts.log_packets([180, 800]);
}
assert_eq!(charts.packet_rates, [30.0, 131.25]);
charts.reset();
assert_eq!(charts.packet_rates, [0.0, 0.0]);
charts.log_packets([4, 8]);
assert_eq!(charts.packet_rates, [1.0, 2.0]);
}
#[test]
fn ticks_and_bandwidth_log_their_differences() {
let mut c = DebugCharts::default();
+41
View File
@@ -68,6 +68,14 @@ impl EffectInstance {
}
changed
}
/// `MobEffectInstance.tickClient`: a client counts its effects down
/// (the server removes them).
pub fn tick_client(&mut self) {
if self.infinite() || self.duration > 0 {
self.tick_down();
self.downgrade();
}
}
fn tick_down(&mut self) {
if let Some(h) = self.hidden.as_mut() {
h.tick_down();
@@ -170,6 +178,39 @@ impl PlayerEffects {
pub fn clear(&mut self) {
self.list.clear();
}
/// The effects of a saved player (`Player.active_effects`: id,
/// duration, amplifier, ambient, visible).
pub fn from_saved(saved: &[(String, i32, i32, bool, bool)]) -> Self {
let mut effects = Self::default();
for (id, duration, amplifier, ambient, _) in saved {
if let Some(def) = brewing::effect(id) {
let mut e = EffectInstance::new(def.id, *duration, *amplifier);
e.ambient = *ambient;
effects.add(e);
}
}
effects
}
/// `Player.active_effects` for the save.
pub fn saved(&self) -> Vec<(String, i32, i32, bool, bool)> {
self.list
.iter()
.map(|e| {
(
format!("minecraft:{}", e.id),
e.duration,
e.amplifier,
e.ambient,
e.visible,
)
})
.collect()
}
/// ClientboundUpdateMobEffectPacket's flags without blending: ambient,
/// particles visible and the icon shown (always, for these effects).
pub fn flags(e: &EffectInstance) -> i8 {
i8::from(e.ambient) | i8::from(e.visible) << 1 | 4
}
/// `LivingEntity.tickEffects` (server part) with the omens' effect ticks:
/// `omen` answers `BadOmenMobEffect` (every tick) and `RaidOmenMobEffect`
/// (on its last tick). Returns the actions to apply, in order, and
+16 -2
View File
@@ -68,6 +68,7 @@ impl Corner {
#[derive(Clone, Debug, PartialEq)]
pub struct Extras {
pub fullbright: bool,
pub zoom: bool,
/// A vanilla key name (`key.keyboard.z`).
pub zoom_key: String,
@@ -108,6 +109,7 @@ pub struct Extras {
impl Default for Extras {
fn default() -> Self {
Self {
fullbright: false,
zoom: false,
zoom_key: "key.keyboard.z".into(),
zoom_level: 4,
@@ -155,6 +157,7 @@ impl Extras {
_ => d,
};
match key.trim() {
"fullbright" => e.fullbright = flag(e.fullbright),
"zoom" => e.zoom = flag(e.zoom),
"zoomKey" if value.starts_with("key.") => e.zoom_key = value.to_owned(),
"zoomLevel" => {
@@ -198,7 +201,8 @@ impl Extras {
}
pub fn serialize(&self) -> String {
format!(
"zoom:{}\nzoomKey:{}\nzoomLevel:{}\nzoomSmooth:{}\nzoomSensitivity:{}\nfps:{}\nfpsCorner:{}\nfpsLows:{}\nkeystrokes:{}\nkeystrokesCorner:{}\nkeystrokesCps:{}\nminimap:{}\nminimapCorner:{}\nminimapSize:{}\nminimapShape:{}\nminimapZoom:{}\nminimapRotate:{}\nautoReconnect:{}\nmouseTweaks:{}\nmouseTweaksWheel:{}\nsort:{}\nsortKey:{}\n",
"fullbright:{}\nzoom:{}\nzoomKey:{}\nzoomLevel:{}\nzoomSmooth:{}\nzoomSensitivity:{}\nfps:{}\nfpsCorner:{}\nfpsLows:{}\nkeystrokes:{}\nkeystrokesCorner:{}\nkeystrokesCps:{}\nminimap:{}\nminimapCorner:{}\nminimapSize:{}\nminimapShape:{}\nminimapZoom:{}\nminimapRotate:{}\nautoReconnect:{}\nmouseTweaks:{}\nmouseTweaksWheel:{}\nsort:{}\nsortKey:{}\n",
bool_text(self.fullbright),
bool_text(self.zoom),
self.zoom_key,
self.zoom_level,
@@ -418,6 +422,7 @@ impl Cps {
/// The settings the Extras page shows, one per row.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Item {
Fullbright,
Zoom,
ZoomKey,
ZoomLevel,
@@ -445,6 +450,8 @@ pub enum Item {
pub fn rows() -> Vec<Result<Item, &'static str>> {
use Item::*;
vec![
Err("Lighting"),
Ok(Fullbright),
Err("Zoom"),
Ok(Zoom),
Ok(ZoomKey),
@@ -493,6 +500,7 @@ fn next<T: Copy + PartialEq>(all: &[T], current: T, back: bool) -> T {
impl Item {
pub fn caption(self) -> &'static str {
match self {
Item::Fullbright => "Fullbright",
Item::Zoom => "Zoom",
Item::ZoomKey => "Zoom key",
Item::ZoomLevel => "Starting zoom",
@@ -518,6 +526,7 @@ impl Item {
/// What the row says under its caption.
pub fn description(self) -> &'static str {
match self {
Item::Fullbright => "Show blocks and entities at full light, even in dark areas.",
Item::Zoom => "Hold the zoom key to zoom; the wheel changes it while held.",
Item::ZoomKey => "Click, then press a key. Escape unbinds it.",
Item::ZoomLevel => "The zoom the key starts at.",
@@ -556,7 +565,7 @@ impl Item {
pub fn cost(self) -> Option<crate::graphics_style::Cost> {
use crate::graphics_style::Cost;
match self {
Item::Zoom | Item::Fps | Item::Keystrokes => Some(Cost::None),
Item::Fullbright | Item::Zoom | Item::Fps | Item::Keystrokes => Some(Cost::None),
Item::Minimap => Some(Cost::Low),
Item::AutoReconnect | Item::MouseTweaks | Item::Sort => Some(Cost::None),
_ => None,
@@ -565,6 +574,7 @@ impl Item {
/// On/off items and their value.
pub fn switch(self, e: &Extras) -> Option<bool> {
Some(match self {
Item::Fullbright => e.fullbright,
Item::Zoom => e.zoom,
Item::ZoomSmooth => e.zoom_smooth,
Item::ZoomSensitivity => e.zoom_sensitivity,
@@ -606,6 +616,7 @@ impl Item {
/// A click (`back` for the right button). The zoom key binds instead.
pub fn cycle(self, e: &mut Extras, back: bool) {
match self {
Item::Fullbright => e.fullbright = !e.fullbright,
Item::Zoom => e.zoom = !e.zoom,
Item::ZoomSmooth => e.zoom_smooth = !e.zoom_smooth,
Item::ZoomSensitivity => e.zoom_sensitivity = !e.zoom_sensitivity,
@@ -651,11 +662,14 @@ mod tests {
#[test]
fn everything_is_off_by_default_and_round_trips() {
let d = Extras::default();
assert!(!d.fullbright);
assert!(!d.zoom && !d.fps && !d.keystrokes && !d.minimap && !d.auto_reconnect);
assert!(!d.mouse_tweaks && !d.sort);
assert_eq!(Extras::parse(""), d);
assert_eq!(Extras::parse(&d.serialize()), d);
let mut e = d.clone();
Item::Fullbright.cycle(&mut e, false);
assert_eq!(Item::Fullbright.switch(&e), Some(true));
e.zoom = true;
e.zoom_key = "key.keyboard.c".into();
e.zoom_level = 6;
+55 -33
View File
@@ -1087,6 +1087,8 @@ struct Game<'a> {
lan: Option<lan::LanHost>,
/// Single player's server thread, which `remote` is connected to.
integrated: Option<integrated::Integrated>,
/// This game is that server thread's (game/integrated.rs).
serving: Option<integrated::Serving>,
/// The open world is shared behind an invite code (game/friends.rs).
friends: Option<friends::Sharing>,
world_options: Option<lan_screen::WorldOptions>,
@@ -1447,9 +1449,13 @@ impl Game<'_> {
.iter()
.flat_map(|(_, m)| m.faces.iter())
.find(|f| f.quad.facing == horizon_assets::model::Direction::Up)
.or_else(|| models.iter().flat_map(|(_, m)| m.faces.iter()).next())?;
let name = self.pack.layer_names.get(&face.layer)?.clone();
let tint = if face.quad.tint_index >= 0 {
.or_else(|| models.iter().flat_map(|(_, m)| m.faces.iter()).next());
// Entity-rendered blocks may have a particle texture without any faces.
let layer = face
.map(|face| face.layer)
.or_else(|| models.iter().find_map(|(_, model)| model.particle))?;
let name = self.pack.layer_names.get(&layer)?.clone();
let tint = if face.is_some_and(|face| face.quad.tint_index >= 0) {
let n = &self.res.facts.get(state).name;
if n.contains("leaves") || n.contains("vine") {
0x48B518
@@ -1777,6 +1783,12 @@ impl Game<'_> {
});
self.process_level_events()
}
fn attack_block(&mut self, pos: [i32; 3]) -> Result<()> {
self.with_level(|b, level, ticks| {
b.attack_block(level, ticks, BlockPos::new(pos[0], pos[1], pos[2]));
});
self.process_level_events()
}
/// Track which chunks are ticking (Ticks needs chunk load/unload).
fn sync_tick_chunks(&mut self) {
if !self.tick_chunks.synchronize(&self.world.chunks) {
@@ -2885,6 +2897,7 @@ impl Game<'_> {
return Ok(());
}
if self.mining.as_ref().is_none_or(|m| m.pos != hit.pos) {
self.attack_block(hit.pos)?;
self.mining = Some(Mining {
pos: hit.pos,
progress: 0.0,
@@ -3634,8 +3647,8 @@ impl Game<'_> {
}
/// `Minecraft.pause`: a single-player game with a pausing screen open.
fn pauses_game(&self) -> bool {
(self.remote.is_none() || self.integrated.is_some())
&& self.lan.is_none()
self.has_singleplayer_server()
&& !self.is_published()
&& self.title.is_none()
&& (matches!(
self.screen,
@@ -4336,14 +4349,7 @@ impl Game<'_> {
} else {
("Crafting", 97.0)
};
batch.text(
atlas,
title,
ox + tx,
oy + if self.craft_size == 3 { 6.0 } else { 8.0 },
grey,
false,
);
batch.text(atlas, title, ox + tx, oy + 6.0, grey, false);
if self.craft_size == 3 {
batch.text(atlas, "Inventory", ox + 8.0, oy + 72.0, grey, false);
}
@@ -5579,6 +5585,20 @@ impl Game<'_> {
.block_entity_render
.render(&scene, visible, &mut out);
}
if let Some(mining) = &self.mining
&& mining.progress > 0.0
&& self.atlas.sprites.contains_key(&format!(
"block/destroy_stage_{}",
((mining.progress * 10.0) as u32).min(9)
))
{
let state = self
.world
.block(mining.pos[0], mining.pos[1], mining.pos[2]);
self.res
.block_entity_render
.render_banner_breaking(&scene, mining.pos, state.0, &mut out);
}
}
// Experience orbs (ExperienceOrbRenderer): pulsing billboards from a 4x4 icon sheet.
if let Some(r) = self
@@ -8064,7 +8084,7 @@ impl Game<'_> {
self.creative_screen.search_focused.elapsed().as_millis(),
);
}
let mut hovered: Option<String> = None;
let mut hovered: Option<ItemStack> = None;
if tab.inventory {
self.draw_player_preview(
batch,
@@ -8114,7 +8134,7 @@ impl Game<'_> {
&& self.cursor.1 < y + 16.0
{
batch.fill(&self.atlas, x, y, 16.0, 16.0, rgba(255, 255, 255, 128));
hovered = Some(stack.item.to_string());
hovered = Some(stack.clone());
}
}
}
@@ -8129,7 +8149,7 @@ impl Game<'_> {
&& self.cursor.1 >= y
&& self.cursor.1 < y + 16.0
{
hovered = Some(stack.item.to_string());
hovered = Some(stack);
}
}
let scrollable = self.creative_screen.rows(&self.pack.names) > 5;
@@ -8165,8 +8185,8 @@ impl Game<'_> {
} else if self.carried.is_none()
&& let Some(item) = hovered
{
let name = self.pack.names.item(&item);
self.tooltip(batch, &name, self.cursor.0, self.cursor.1);
let lines = self.stack_tooltip(&item);
self.draw_tooltip_lines(batch, &lines, self.cursor.0, self.cursor.1);
}
self.draw_inventory_effects(batch, (ox, oy), Creative::WIDTH as i32);
}
@@ -8310,21 +8330,7 @@ impl Game<'_> {
self.ender_items = items.clone();
}
level.ender_items = self.ender_items.clone();
level.active_effects = self
.potions
.effects
.list
.iter()
.map(|e| {
(
format!("minecraft:{}", e.id),
e.duration,
e.amplifier,
e.ambient,
e.visible,
)
})
.collect();
level.active_effects = self.potions.effects.saved();
}
fn save_game(&mut self) -> Result<()> {
self.save_game_with(true)
@@ -9363,6 +9369,21 @@ impl ApplicationHandler for Game<'_> {
}
WindowEvent::MouseInput { state, button, .. } => {
let pressed = state == ElementState::Pressed;
if matches!(self.screen, Screen::Inventory | Screen::Creative)
&& let Some(key) = self
.settings
.keys
.container_mouse_key(button, self.creative)
{
if pressed && self.carried.is_none() {
self.inventory_hotkey(key);
}
// Neither edge of a bound button is an ordinary slot click.
return Ok(());
}
if pressed && self.sort_mouse_press(button) {
return Ok(());
}
match self.screen {
Screen::Playing => {
if pressed && !self.captured {
@@ -10086,6 +10107,7 @@ impl<'a> Game<'a> {
remote: None,
lan: None,
integrated: None,
serving: None,
world_options: None,
options_to_world_options: false,
command_block_screen: None,
+4 -1
View File
@@ -460,7 +460,10 @@ impl Game<'_> {
json!({
"screen": self.screen_label(),
"menu": self.title.as_ref().map(|_| self.title_value()),
"world": (self.title.is_none()).then(|| self.level.name.clone()),
"world": (self.title.is_none()).then(|| match &self.integrated {
Some(server) => server.world_name.clone(),
None => self.level.name.clone(),
}),
"dimension": self.dim.id(),
"gamemode": format!("{:?}", self.mode).to_lowercase(),
"time": { "day_time": self.world.day_time, "day": self.world.day_time.div_euclid(24000), "time_of_day": self.world.day_time.rem_euclid(24000) },
+6
View File
@@ -425,6 +425,12 @@ impl Game<'_> {
capture.push(text);
return;
}
// Connected to a server (single player's own included), the chat on
// screen is the connection's: the game's own messages join it.
if self.remote.is_some() {
self.chat_line(text.plain());
return;
}
let focused = self.screen == Screen::Chat;
let heard = self.mods.mods.is_running().then(|| text.plain());
self.ui.chat.add(
@@ -758,18 +758,25 @@ impl Game<'_> {
.and_then(|l| l.local_addr())
.map_or(25564, |a| i32::from(a.port())),
};
if let Some(lan) = &self.lan {
return Err(err(
"commands.publish.alreadyPublished.lan",
&[&lan.settings.port],
));
let published = if self.serving() {
self.published_port()
} else {
self.lan.as_ref().map(|l| l.settings.port)
};
if let Some(port) = published {
return Err(err("commands.publish.alreadyPublished.lan", &[&port]));
}
let settings = super::super::lan::LanSettings {
port: port as u16,
guest_commands: allow,
force_game_mode: false,
};
if self.lan_start(settings).is_err() {
let started = if self.serving() {
self.publish(settings).is_ok()
} else {
self.lan_start(settings).is_ok()
};
if !started {
return Err(err("commands.publish.failed", &[]));
}
let port_text = port.to_string();
@@ -785,6 +792,13 @@ impl Game<'_> {
Ok(port)
}
pub(super) fn cmd_unpublish(&mut self) -> R<i32> {
if self.serving() {
if !self.unpublish() {
return Err(err("commands.unpublish.notPublished", &[]));
}
self.feedback(Text::translate("commands.unpublish.success", &[]));
return Ok(1);
}
if self.lan.is_none() {
return Err(err("commands.unpublish.notPublished", &[]));
}
+29 -13
View File
@@ -29,7 +29,7 @@ const HELP: &[&str] = &[
"chat TEXT send a chat line or /command as if typed",
"type TEXT type into the open chat box (key enter tap sends)",
"chat-log [N] the newest N chat messages (default 10)",
"options [PAGE] open the options (video sound controls keybinds mouse chat accessibility language font packs graphics graphics-advanced)",
"options [PAGE] open the options (video sound controls keybinds mouse chat accessibility language font packs mods graphics graphics-advanced)",
"stats [reset] frame-time summary since the last reset",
"bench SECONDS reset stats, wait, then reply with the summary",
"fly X1 Y1 Z1 X2 Y2 Z2 SECONDS [PITCH [raw]] fly the camera along a line at constant speed, then reply with the frame summary (raw: every frame time too)",
@@ -462,8 +462,10 @@ impl Game<'_> {
"language" => Page::Language,
"font" => Page::Font,
"packs" => Page::Packs,
"mods" => Page::Mods,
"graphics" => Page::Graphics,
"graphics-advanced" => Page::GraphicsAdvanced,
"extras" => Page::Extras,
other => return Err(format!("unknown options page {other}").into()),
};
if self.screen == Screen::Playing && self.title.is_none() {
@@ -475,7 +477,10 @@ impl Game<'_> {
}
"chat-log" => {
let n = words.get(1).map_or(Ok(10), |n| n.parse())?;
Ok(Some(json!({ "chat": self.ui.chat.recent_lines(n) })))
let lines = self
.remote_chat(n)
.unwrap_or_else(|| self.ui.chat.recent_lines(n));
Ok(Some(json!({ "chat": lines })))
}
"stats" => {
let summary = self.frame_stats.summary();
@@ -549,18 +554,20 @@ impl Game<'_> {
self.leave_server(None)?;
ok()
}
"save" => {
"save" | "save-all" => {
self.require_world()?;
self.save_game()?;
ok()
}
"save-all" => {
// Like `save-all flush`: also rewrite chunks that were not modified
// (the save round-trip harness compares them with vanilla's files).
self.require_world()?;
let keys: Vec<_> = self.world.chunks.keys().copied().collect();
self.world.modified.extend(keys);
self.save_game()?;
// `save-all` is like `save-all flush`: it also rewrites chunks
// that were not modified (the save round-trip harness compares
// them with vanilla's files).
let all = words[0] == "save-all";
// Single player's world is its server thread's.
if let Some(server) = &self.integrated {
server
.call(move |g| g.control_save(all).map_err(|e| e.to_string()))
.ok_or("the integrated server stopped")??;
} else {
self.control_save(all)?;
}
ok()
}
"dragon-hurt" => {
@@ -581,6 +588,15 @@ impl Game<'_> {
}
}
/// `horizon-ctl save` and `save-all`.
fn control_save(&mut self, all: bool) -> Result<()> {
if all {
let keys: Vec<_> = self.world.chunks.keys().copied().collect();
self.world.modified.extend(keys);
}
self.save_game()
}
fn require_world(&self) -> Result<()> {
if self.title.is_some() {
return Err("no world open; use: open WORLD [SEED] [creative]".into());
+31 -16
View File
@@ -38,7 +38,7 @@ impl DebugHost for Host<'_, '_> {
// the menu as it always has (key_pressed).
let g = &mut *self.game;
if without_menu && g.screen == Screen::Playing {
g.pause_menu = !(g.remote.is_none() && g.lan.is_none());
g.pause_menu = !(g.has_singleplayer_server() && !g.is_published());
g.screen = Screen::Paused;
g.capture(false);
g.mining = None;
@@ -194,15 +194,17 @@ impl Game<'_> {
}
return;
};
let received = r
.session
.counters
.lock()
.unwrap()
.as_ref()
.map(|c| c.bytes_in.load(std::sync::atomic::Ordering::Relaxed));
if let Some(total) = received {
self.debug_charts.log_bandwidth(total);
let received = r.session.counters.lock().unwrap().as_ref().map(|c| {
let order = std::sync::atomic::Ordering::Relaxed;
[
c.bytes_in.load(order),
c.sent.load(order),
c.received.load(order),
]
});
if let Some([bytes, sent, received]) = received {
self.debug_charts.log_bandwidth(bytes);
self.debug_charts.log_packets([sent, received]);
}
if shown {
use horizon_protocol::packets::{play::Serverbound, status::Ping};
@@ -403,8 +405,9 @@ impl Game<'_> {
],
);
}
// tps: DebugEntryTps for the integrated server (it counts no packets).
if self.player.is_some() && self.remote.is_none() {
// tps: DebugEntryTps for local and remote connections.
if self.player.is_some() {
let [tx, rx] = self.debug_charts.packet_rates.map(|n| n.round() as i64);
let (target, status) = if self.clock.sprinting() {
("-".to_owned(), " (sprinting)")
} else if self.clock.stepping() {
@@ -417,10 +420,22 @@ impl Game<'_> {
} else {
(format!("{:.1}", 1000.0 / self.clock.rate()), "")
};
d.line(format!(
"Integrated server @ {:.1}/{target} ms{status}, 0 tx, 0 rx",
self.debug_charts.smoothed_tick_ms
));
if self.remote.is_none() || self.integrated.is_some() {
let tick_ms = self
.integrated
.as_ref()
.map_or(self.debug_charts.smoothed_tick_ms, |server| {
server.smoothed_tick_ms()
});
d.line(format!(
"Integrated server @ {tick_ms:.1}/{target} ms{status}, {tx} tx, {rx} rx",
));
} else if let Some(remote) = &self.remote {
d.line(format!(
"\"{}\" server{status}, {tx} tx, {rx} rx",
remote.brand
));
}
}
let (left, right) = d.columns(&self.debug_chart_lines());
let atlas = &self.atlas;
@@ -463,6 +463,7 @@ impl Game<'_> {
seed: self.level.seed,
max_players: props.max_players.max(0) as usize,
dedicated: true,
integrated: false,
};
let settings = LanSettings {
port,
+5 -1
View File
@@ -58,8 +58,12 @@ impl Game<'_> {
pub(super) fn extras_scroll(&mut self, steps: f32) -> bool {
self.settings.extras.zoom && self.extras.zoom.scroll(steps)
}
/// Mouse buttons while playing, for the keystroke overlay.
/// Mouse buttons while playing, for zoom and the keystroke overlay.
pub(super) fn extras_mouse(&mut self, button: MouseButton, pressed: bool) {
let e = &self.settings.extras;
if e.zoom && e.zoom_key == keybinds::mouse_name(button) {
self.extras.zoom.key(pressed, false, true, e.zoom_level);
}
let i = match button {
MouseButton::Left => 0,
MouseButton::Right => 1,
+4 -1
View File
@@ -409,7 +409,10 @@ impl HandWorld for GameHands<'_, '_> {
fn within_border(&mut self, _: [i32; 3]) -> bool {
true
}
fn attack_block(&mut self, _: [i32; 3]) {}
fn attack_block(&mut self, pos: [i32; 3]) {
let result = self.game.attack_block(pos);
self.keep(result);
}
fn destroy_progress(&mut self, pos: [i32; 3]) -> f32 {
self.game.destroy_progress(pos)
}
+300 -23
View File
@@ -2,6 +2,10 @@
//! its own "Server thread", as vanilla's does, and the window joins it as a
//! player through memory, so a world tick never holds up a frame.
//!
//! The window asks its server for what only the server knows (Open to LAN,
//! the world's options) with [`Integrated::call`], as vanilla's client calls
//! into its `IntegratedServer`.
//!
//! Opt-in for now (`--server-thread` or `HORIZON_SERVER_THREAD=1`): the
//! player joins as a network player, and the server side of a network player
//! does not do everything single player does yet. Worlds whose player is
@@ -15,7 +19,7 @@ use horizon_client::{
Result,
audio::Audio,
hud::HudAtlas,
lan::{MAX_PLAYERS, NetConfig, hub::HubConfig},
lan::{Lan, MAX_PLAYERS, NetConfig, hub::HubConfig},
save::Level,
settings::Settings,
title::WorldOptions,
@@ -23,11 +27,12 @@ use horizon_client::{
use horizon_protocol::connection::Pipe;
use horizon_protocol::{crypto::offline_uuid, text::translatable};
use std::{
net::TcpListener,
path::Path,
sync::{
Arc,
atomic::{AtomicBool, Ordering},
mpsc::{Sender, channel},
atomic::{AtomicBool, AtomicU16, AtomicU32, Ordering},
mpsc::{Receiver, Sender, channel, sync_channel},
},
thread::JoinHandle,
time::{Duration, Instant},
@@ -39,18 +44,49 @@ struct Flags {
/// `Minecraft.pause`: a single-player pause screen is open.
paused: AtomicBool,
stop: AtomicBool,
/// `IntegratedServer.getPort`: the port it is open to the LAN on, 0
/// while it is not.
published: AtomicU16,
smoothed_tick_ms: AtomicU32,
}
/// Work the window hands its server thread (`MinecraftServer.execute`).
type Task = Box<dyn FnOnce(&mut Game<'_>) + Send>;
/// The window's handle on its server thread.
pub(super) struct Integrated {
flags: Arc<Flags>,
thread: Option<JoinHandle<()>>,
tasks: Sender<Task>,
/// The world's name (`level.dat`'s `LevelName`), for the pause menu.
pub world_name: String,
}
impl Integrated {
pub fn smoothed_tick_ms(&self) -> f32 {
f32::from_bits(self.flags.smoothed_tick_ms.load(Ordering::Relaxed))
}
/// `IntegratedServer.tickServer` skips the world while the game is paused.
pub fn set_paused(&self, paused: bool) {
self.flags.paused.store(paused, Ordering::Relaxed);
}
/// `IntegratedServer.getPort` while `isPublished`.
pub fn published(&self) -> Option<u16> {
Some(self.flags.published.load(Ordering::Relaxed)).filter(|&p| p != 0)
}
/// `executeBlocking`: run `f` on the server thread between two ticks and
/// wait for its answer; `None` once the server has stopped.
pub fn call<T: Send + 'static>(
&self,
f: impl FnOnce(&mut Game<'_>) -> T + Send + 'static,
) -> Option<T> {
let (tx, rx) = sync_channel(1);
self.tasks
.send(Box::new(move |g| {
let _ = tx.send(f(g));
}))
.ok()?;
rx.recv_timeout(Duration::from_secs(10)).ok()
}
/// `IntegratedServer.halt(true)`: returns once the world is saved and let go.
pub fn stop(mut self) {
self.halt();
@@ -68,6 +104,25 @@ impl Drop for Integrated {
}
}
/// The server thread's side of the window's handle (`Game::serving`).
pub(super) struct Serving {
flags: Arc<Flags>,
tasks: Receiver<Task>,
/// The window's profile.
owner: u128,
/// Open to LAN or closed from inside a player's command, while the hub
/// is out of its place: applied after the tick.
pending: Option<Publish>,
}
enum Publish {
Open(TcpListener, LanSettings),
Close,
}
/// What the server thread hands the window once the world is open: its end
/// of the connection and the world's name, or why it failed.
type Ready = std::result::Result<(Pipe, String), String>;
/// The world to open and the player who owns it.
struct Launch {
folder: String,
@@ -75,8 +130,11 @@ struct Launch {
seed: Option<i64>,
creative: bool,
create: Option<WorldOptions>,
/// The window's profile: the only one let in, and the world's player.
/// The window's profile: the only one let in until the world is open to
/// the LAN, and the world's player.
owner: u128,
/// Its name, for the LAN's MOTD.
player: String,
}
/// Whether this world opens on a server thread: asked for, and its player
@@ -88,6 +146,19 @@ pub(super) fn wanted(options: &Options, world: &Path) -> bool {
}
impl Game<'_> {
/// `Minecraft.hasSingleplayerServer`: a world of this window's own, run
/// in the frame or on its server thread.
pub(super) fn has_singleplayer_server(&self) -> bool {
self.remote.is_none() || self.integrated.is_some()
}
/// `IntegratedServer.isPublished`: the world is open to the network.
pub(super) fn is_published(&self) -> bool {
self.lan.is_some()
|| self
.integrated
.as_ref()
.is_some_and(|s| s.published().is_some())
}
/// `Minecraft.doWorldLoad`: start the server thread on the world, wait
/// until it can be joined, then join it through memory.
pub(super) fn open_integrated(
@@ -110,6 +181,7 @@ impl Game<'_> {
create: create.cloned(),
// An offline-mode server names its players by their offline profile.
owner: offline_uuid(&player),
player: player.clone(),
};
let mut options = self.options.clone();
// A server without a console: no local player, no window, no control socket.
@@ -127,6 +199,7 @@ impl Game<'_> {
let (res, pack, settings) = (self.res.clone(), self.pack.clone(), self.settings.clone());
let flags = Arc::new(Flags::default());
let (ready_tx, ready) = channel();
let (tasks, server_tasks) = channel();
let server_flags = flags.clone();
let thread = std::thread::Builder::new()
.name("Server thread".into())
@@ -137,7 +210,8 @@ impl Game<'_> {
options,
settings,
launch,
&server_flags,
server_flags,
server_tasks,
&ready_tx,
);
if let Err(e) = result {
@@ -145,12 +219,17 @@ impl Game<'_> {
let _ = ready_tx.send(Err(e.to_string()));
}
})?;
let handle = Integrated {
let mut handle = Integrated {
flags,
thread: Some(thread),
tasks,
world_name: String::new(),
};
let pipe = match ready.recv() {
Ok(Ok(pipe)) => pipe,
Ok(Ok((pipe, world_name))) => {
handle.world_name = world_name;
pipe
}
Ok(Err(e)) => return Err(e.into()),
Err(_) => return Err("the integrated server stopped".into()),
};
@@ -164,8 +243,9 @@ impl Game<'_> {
fn run_integrated(
&mut self,
launch: Launch,
flags: &Flags,
ready: &Sender<std::result::Result<Pipe, String>>,
flags: Arc<Flags>,
tasks: Receiver<Task>,
ready: &Sender<Ready>,
) -> Result<()> {
self.open_world(
&launch.folder,
@@ -178,7 +258,8 @@ impl Game<'_> {
let view_distance = self.settings.render_distance.clamp(2, 32);
let config = HubConfig {
default_game_mode: self.level.mode(),
guest_commands: true,
// Only the owner until it is opened to the LAN.
guest_commands: false,
force_game_mode: false,
hardcore: self.level.hardcore,
view_distance,
@@ -188,23 +269,28 @@ impl Game<'_> {
max_players: MAX_PLAYERS,
// No player of its own: the hub runs without a host.
dedicated: true,
integrated: true,
};
let owner = launch.owner;
let published = flags.clone();
let net = NetConfig {
// No network until it is opened to the LAN.
// No network until it is opened to the LAN; the memory connection
// is not compressed (`Connection.isMemoryConnection`).
listen: false,
// A memory connection is not compressed (`Connection.isMemoryConnection`).
compression_threshold: -1,
enable_status: false,
announce: false,
gate: Some(Arc::new(move |_, uuid, _| {
(uuid != owner).then(|| translatable("multiplayer.disconnect.not_whitelisted", &[]))
(uuid != owner && published.published.load(Ordering::Relaxed) == 0)
.then(|| translatable("multiplayer.disconnect.not_whitelisted", &[]))
})),
..NetConfig::lan(0, self.level.name.clone(), MAX_PLAYERS)
// IntegratedServer.initServer: the MOTD names the owner and the world.
..NetConfig::lan(
0,
format!("{} - {}", launch.player, self.level.name),
MAX_PLAYERS,
)
};
let settings = LanSettings {
port: 0,
guest_commands: true,
guest_commands: false,
force_game_mode: false,
};
self.lan_host(settings, net, config, None)?;
@@ -223,18 +309,32 @@ impl Game<'_> {
});
host.hub.lan.connect_local()?
};
let _ = ready.send(Ok(pipe));
self.serving = Some(Serving {
flags: flags.clone(),
tasks,
owner,
pending: None,
});
let _ = ready.send(Ok((pipe, self.level.name.clone())));
self.settle_spawn()?;
let mut next = Instant::now();
while !flags.stop.load(Ordering::Relaxed) {
self.run_tasks();
self.update_dedicated_streaming();
self.update_world();
if flags.paused.load(Ordering::Relaxed) {
// Only the connections run.
self.tick_lan();
} else {
let started = Instant::now();
self.tick()?;
self.debug_charts.log_tick(started, started.elapsed());
flags.smoothed_tick_ms.store(
self.debug_charts.smoothed_tick_ms.to_bits(),
Ordering::Relaxed,
);
}
self.apply_publish();
let rate = self.clock.rate().max(1.0);
next += Duration::from_secs_f64(1.0 / f64::from(rate));
let now = Instant::now();
@@ -250,6 +350,10 @@ impl Game<'_> {
/// `MinecraftServer.stopServer`: the players are saved and sent away,
/// then the world is saved.
fn stop_integrated(&mut self) -> Result<()> {
// IntegratedServer.stopServer: teardownPublishedState.
if let Some(s) = self.serving.take() {
s.flags.published.store(0, Ordering::Relaxed);
}
if let Some(mut host) = self.lan.take() {
for g in &host.hub.guests {
self.save_guest(&host, g);
@@ -272,18 +376,191 @@ impl Game<'_> {
}
}
/// What the world options screen shows of an integrated server.
#[derive(Clone, Copy, Debug)]
pub(super) struct ServerOptions {
pub default_mode: i32,
/// The owner's own game mode.
pub personal_mode: i32,
pub cheats: bool,
pub difficulty: u8,
pub hardcore: bool,
pub difficulty_locked: bool,
pub port: Option<u16>,
pub guest_commands: bool,
pub force: bool,
}
/// The server thread's side.
impl Game<'_> {
/// Whether this game is an integrated server's.
pub(super) fn serving(&self) -> bool {
self.serving.is_some()
}
/// The window's requests, between two ticks.
fn run_tasks(&mut self) {
let tasks: Vec<Task> = match &self.serving {
Some(s) => s.tasks.try_iter().collect(),
None => return,
};
for task in tasks {
task(self);
self.apply_publish();
}
}
/// `IntegratedServer.getPort` while published.
pub(super) fn published_port(&self) -> Option<u16> {
let s = self.serving.as_ref()?;
Some(s.flags.published.load(Ordering::Relaxed)).filter(|&p| p != 0)
}
/// `IntegratedServer.publishServer`: listen on `settings.port` (0 picks
/// one) and announce the world. The socket is bound at once so a busy
/// port fails here; the hub starts listening once it is at hand.
pub(super) fn publish(&mut self, settings: LanSettings) -> std::result::Result<u16, String> {
let Some(s) = self.serving.as_mut() else {
return Err("not an integrated server".into());
};
if s.flags.published.load(Ordering::Relaxed) != 0 {
return Err("already published".into());
}
let listener = Lan::bind(None, settings.port).map_err(|e| e.to_string())?;
let port = listener.local_addr().map_err(|e| e.to_string())?.port();
log::info!("Published LAN server on port {port}");
s.flags.published.store(port, Ordering::Relaxed);
s.pending = Some(Publish::Open(listener, LanSettings { port, ..settings }));
self.apply_publish();
Ok(port)
}
/// `IntegratedServer.unpublishServer`: stop listening and send every
/// player but the owner away. False when it was not published.
pub(super) fn unpublish(&mut self) -> bool {
let Some(s) = self.serving.as_mut() else {
return false;
};
if s.flags.published.swap(0, Ordering::Relaxed) == 0 {
return false;
}
s.pending = Some(Publish::Close);
self.apply_publish();
true
}
/// Publish or unpublish for real, once the hub is in its place (a
/// player's `/publish` runs while it is out).
fn apply_publish(&mut self) {
if self.lan.is_none() {
return;
}
let Some(s) = self.serving.as_mut() else {
return;
};
let (Some(pending), owner) = (s.pending.take(), s.owner) else {
return;
};
let allow_commands = self.allow_commands();
let Some(host) = self.lan.as_mut() else {
return;
};
match pending {
Publish::Open(listener, settings) => {
if let Err(e) = host.hub.lan.listen_on(listener, true) {
log::error!("Horizon: Open to LAN: {e}");
}
host.settings = settings;
host.hub.config.force_game_mode = settings.force_game_mode;
// IntegratedServer.setGuestCommandAccess, then updatePermissions.
host.hub.config.guest_commands = settings.guest_commands && allow_commands;
host.hub.resend_commands();
}
Publish::Close => {
host.hub.lan.stop_listening();
log::info!(
"Unpublishing integrated server (was on port {})",
host.settings.port
);
let others: Vec<u32> = host
.hub
.guests
.iter()
.filter(|g| g.uuid != owner)
.map(|g| g.conn)
.collect();
for conn in others {
host.hub.kick(
conn,
translatable("multiplayer.disconnect.server_shutdown", &[]),
);
}
}
}
}
/// The world options screen's state, read on the server.
pub(super) fn server_options(&self) -> ServerOptions {
let owner = self.serving.as_ref().map(|s| s.owner);
let host = self.lan.as_ref();
let personal_mode = host
.and_then(|h| h.hub.guests.iter().find(|g| Some(g.uuid) == owner))
.map_or(self.level.mode(), |g| g.game_mode);
let published = self.published_port();
ServerOptions {
default_mode: self.level.mode(),
personal_mode,
cheats: self.allow_commands(),
difficulty: self.ui.difficulty,
hardcore: self.level.hardcore,
difficulty_locked: self.level.difficulty_locked,
port: published,
guest_commands: published.is_some() && host.is_some_and(|h| h.settings.guest_commands),
force: published.is_none() || host.is_some_and(|h| h.settings.force_game_mode),
}
}
/// `IntegratedServer.setPersonalGameType`: the owner's game mode.
pub(super) fn set_owner_mode(&mut self, mode: i32) {
let Some(owner) = self.serving.as_ref().map(|s| s.owner) else {
return;
};
if let Some(host) = self.lan.as_mut()
&& let Some(conn) = host
.hub
.guests
.iter()
.find(|g| g.uuid == owner)
.map(|g| g.conn)
{
host.hub.set_game_mode(conn, mode);
}
}
/// `IntegratedServer.setWorldAllowCommands`: the owner is an operator
/// while the world allows commands; everyone's level is sent again.
pub(super) fn owner_allow_commands(&mut self, allow: bool) {
let Some(owner) = self.serving.as_ref().map(|s| s.owner) else {
return;
};
let published = self.published_port().is_some();
if let Some(host) = self.lan.as_mut() {
host.hub.ops.insert(owner, if allow { 4 } else { 0 });
if published {
host.hub.config.guest_commands = allow && host.settings.guest_commands;
}
host.hub.resend_commands();
}
}
}
/// The server thread: a game of its own over the shared resources.
#[allow(clippy::too_many_arguments)]
fn serve(
res: &Arc<Resources>,
pack: PackResources,
options: Options,
settings: Settings,
launch: Launch,
flags: &Flags,
ready: &Sender<std::result::Result<Pipe, String>>,
flags: Arc<Flags>,
tasks: Receiver<Task>,
ready: &Sender<Ready>,
) -> Result<()> {
let atlas = HudAtlas::build(&options.resources)?;
// It draws nothing: only the font, which books and chat measure with.
let atlas = HudAtlas::fonts(&options.resources)?;
let audio = Audio::silent(&options.resources);
let mut server = Game::new(res, pack, atlas, options, settings, audio)?;
server.run_integrated(launch, flags, ready)
server.run_integrated(launch, flags, tasks, ready)
}
+88 -34
View File
@@ -31,7 +31,7 @@ use std::{
static SYNC: OnceLock<std::result::Result<Arc<SyncData>, String>> = OnceLock::new();
/// The settings of the open world (WorldOptionsScreen's multiplayer section).
#[derive(Clone, Debug)]
#[derive(Clone, Copy, Debug)]
pub struct LanSettings {
pub port: u16,
pub guest_commands: bool,
@@ -316,6 +316,15 @@ impl Game<'_> {
if words[0] != "lan" {
return Ok(None);
}
if let Some(server) = &self.integrated
&& words.get(1) == Some(&"status")
{
// The hub is the server thread's.
let status = server
.call(|g| g.lan_status())
.ok_or("the integrated server stopped")?;
return Ok(Some(status));
}
match words.get(1).copied() {
Some("open") => {
if self.title.is_some() {
@@ -337,43 +346,58 @@ impl Game<'_> {
self.lan_close(true);
Ok(Some(json!({ "ok": true })))
}
Some("status") => Ok(Some(match &self.lan {
Some(h) => json!({
"open": true,
"host": h.host_name,
"port": h.settings.port,
"guests": h.hub.guests.iter().map(|g| json!({
"name": g.name,
"position": g.position,
"placed": g.placed,
"loaded": g.loaded,
"game_mode": g.game_mode,
"sneaking": g.sneaking,
"health": g.health,
// FoodData: food level, saturation and exhaustion.
"food": [
f64::from(g.food),
f64::from(g.saturation),
g.motion.as_ref().map_or(0.0, |m| f64::from(m.health.food.exhaustion)),
],
"chunks": g.sent_chunks.len(),
"tracked": g.tracker.len(),
// The armour the host draws on this guest, head to feet.
"model_armor": h.models.get(&g.conn).map(|m| {
[&m.extra.head, &m.extra.chest, &m.extra.legs, &m.extra.feet]
.map(|s| s.as_deref())
}),
})).collect::<Vec<_>>(),
}),
None => json!({ "open": false }),
})),
Some("status") => Ok(Some(self.lan_status())),
_ => Err("lan open|close|status".into()),
}
}
/// `horizon-ctl lan status`.
fn lan_status(&self) -> serde_json::Value {
use serde_json::json;
match &self.lan {
Some(h) if !self.serving() || self.published_port().is_some() => json!({
"open": true,
"host": h.host_name,
"port": h.settings.port,
"guests": h.hub.guests.iter().map(|g| json!({
"name": g.name,
"position": g.position,
"placed": g.placed,
"loaded": g.loaded,
"game_mode": g.game_mode,
"sneaking": g.sneaking,
"health": g.health,
// FoodData: food level, saturation and exhaustion.
"food": [
f64::from(g.food),
f64::from(g.saturation),
g.motion.as_ref().map_or(0.0, |m| f64::from(m.health.food.exhaustion)),
],
"chunks": g.sent_chunks.len(),
"tracked": g.tracker.len(),
// The armour the host draws on this guest, head to feet.
"model_armor": h.models.get(&g.conn).map(|m| {
[&m.extra.head, &m.extra.chest, &m.extra.legs, &m.extra.feet]
.map(|s| s.as_deref())
}),
})).collect::<Vec<_>>(),
}),
_ => json!({ "open": false }),
}
}
pub(super) fn lan_open(&mut self, settings: LanSettings) -> Result<()> {
self.lan_start(settings)?;
let port = self.lan.as_ref().map_or(0, |l| l.settings.port);
let port = if let Some(server) = &self.integrated {
// ShareToLanScreen: IntegratedServer.publishServer.
server
.call(move |g| g.publish(settings))
.ok_or("the integrated server stopped")??
} else if self.serving() {
return self.publish(settings).map(drop).map_err(Into::into);
} else {
self.lan_start(settings)?;
self.lan.as_ref().map_or(0, |l| l.settings.port)
};
self.system_message(Text::translate(
"menu.multiplayerOptions.publish.started.lan",
&[Text::literal(port.to_string())],
@@ -408,6 +432,7 @@ impl Game<'_> {
seed: self.level.seed,
max_players: MAX_PLAYERS,
dedicated: false,
integrated: false,
};
let net = NetConfig::lan(settings.port, motd, MAX_PLAYERS);
self.lan_host(settings, net, config, Some(host_uuid))
@@ -484,6 +509,22 @@ impl Game<'_> {
/// IntegratedServer.unpublishServer: the guests are sent away.
pub(super) fn lan_close(&mut self, announce: bool) {
if self.integrated.is_some() || self.serving() {
let closed = match &self.integrated {
Some(server) => server.call(|g| g.unpublish()).unwrap_or(false),
None => self.unpublish(),
};
if closed {
self.friends_lan_closed();
}
if closed && announce && self.integrated.is_some() {
self.system_message(Text::translate(
"menu.multiplayerOptions.publish.stopped",
&[],
));
}
return;
}
self.friends_lan_closed();
let Some(mut host) = self.lan.take() else {
return;
@@ -541,16 +582,29 @@ impl Game<'_> {
/// New command access and game mode forcing settings of the open world.
pub(super) fn lan_apply_settings(&mut self, guest_commands: bool, force: bool) {
if let Some(server) = &self.integrated {
server.call(move |g| g.lan_apply_settings(guest_commands, force));
return;
}
// An integrated server gives guests commands only where the world
// allows them (IntegratedServer.getCustomPermissionLevel).
let effective = guest_commands && (!self.serving() || self.allow_commands());
if let Some(host) = self.lan.as_mut() {
host.settings.guest_commands = guest_commands;
host.settings.force_game_mode = force;
host.hub.config.guest_commands = guest_commands;
host.hub.config.guest_commands = effective;
host.hub.config.force_game_mode = force;
host.hub.resend_commands();
}
}
pub(super) fn lan_port(&self) -> Option<u16> {
if let Some(server) = &self.integrated {
return server.published();
}
if self.serving() {
return self.published_port();
}
self.lan.as_ref().map(|h| h.settings.port)
}
+53 -5
View File
@@ -44,6 +44,8 @@ pub(super) struct GuestPlay {
pub(super) merchant: Option<super::lan_trading::GuestMerchant>,
/// The inventory menu and the crafting table the guest crafts in.
pub(super) crafting: super::lan_crafting::GuestCrafting,
/// What the guest's body was given for its effects and enchantments.
potions: super::potions::BodyPotions,
}
struct ItemRules<'a>(&'a horizon_client::items::Items);
@@ -93,7 +95,11 @@ impl Game<'_> {
let mut play = host.play.remove(&conn).unwrap_or_default();
let g = &mut host.hub.guests[i];
// The guest's body.
let mut motion = g.motion.take()?;
let Some(mut motion) = g.motion.take() else {
host.play.insert(conn, play);
return None;
};
self.potions.swap_player(&mut g.effects, &mut play.potions);
motion.position = Vec3::new(g.position[0], g.position[1], g.position[2]);
motion.ground.on_ground = g.on_ground;
motion.yaw = g.yaw;
@@ -189,6 +195,7 @@ impl Game<'_> {
}
let g = &mut host.hub.guests[i];
std::mem::swap(&mut self.ender_items, &mut g.ender_items);
self.potions.swap_player(&mut g.effects, &mut play.potions);
if let Some(key) = host_ender {
self.world
.block_entities
@@ -679,6 +686,31 @@ impl Game<'_> {
);
return;
}
// An integrated server runs every player's commands at their own
// permission level (`CommandSourceStack.permissions`).
if host.hub.config.integrated {
let Some(level) = host.hub.guest(conn).map(|g| g.permission) else {
return;
};
let command = command.trim_start_matches('/').to_owned();
let lines = self.as_guest(host, conn, |g| {
let console = std::mem::replace(&mut g.ui.registries.permission, level);
g.chat_capture = Some(Vec::new());
g.run_command(&command);
g.ui.registries.permission = console;
g.chat_capture.take().unwrap_or_default()
});
for line in lines.unwrap_or_default() {
host.hub.send_to(
conn,
&C::SystemChat(play::SystemChat {
content: horizon_client::lan::data::component_nbt(&line.component()),
overlay: false,
}),
);
}
return;
}
// A LAN world follows its Allow Commands; a dedicated server leaves
// it to the ops list (the guest's permission level).
let allowed = self.options.dedicated.is_some() || self.allow_commands();
@@ -774,6 +806,10 @@ impl Game<'_> {
g.saturation = 5.0;
g.sent_health = None;
g.motion = None;
// A new body: nothing given to the old one carries over.
if let Some(play) = host.play.get_mut(&conn) {
play.potions = Default::default();
}
let ctx = TickCtx {
world: &mut self.world,
host: None,
@@ -878,12 +914,17 @@ impl Game<'_> {
g.moves_from_ground
};
if g.spectator() {
// Spectators' effects still run (LivingEntity.baseTick).
if !g.effects.list.is_empty() {
self.as_guest(host, conn, |game| game.tick_mob_effects());
}
return;
}
let in_wall = !g.sleeping && self.in_wall(g.position, g.eye_height());
let at = g.position;
let sounds = self.as_guest(host, conn, |game| {
let (rules, health) = (game.world.health_rules, &game.motion.health);
let (rules, motion) = (game.world.health_rules, game.motion);
let health = &motion.health;
let Some(player) = game.player.as_mut() else {
return Vec::new();
};
@@ -921,9 +962,16 @@ impl Game<'_> {
let _ = w.tick_environment_damage();
let _ = w.apply_fire_contact();
let _ = w.server_hazards_tick(in_wall);
let _ = w.player.peaceful_regeneration(rules);
let _ = w.player.food_tick(health, rules);
std::mem::take(&mut w.player.events)
let mut events = std::mem::take(&mut w.player.events);
// LivingEntity.baseTick ends with tickEffects.
game.tick_mob_effects();
let Some(player) = game.player.as_mut() else {
return Vec::new();
};
let _ = player.peaceful_regeneration(rules);
let _ = player.food_tick(health, rules);
events.append(&mut player.events);
events
.into_iter()
.filter_map(|e| match e {
MotionEvent::HurtSound(sound) => Some(sound),
+68 -18
View File
@@ -7,6 +7,7 @@
use super::{
Game, Screen,
game_rules_screen::{Exit, RulesScreen},
integrated::ServerOptions,
lan::LanSettings,
};
use horizon_client::{
@@ -50,7 +51,7 @@ enum View {
Restrictions,
GameRules,
}
#[derive(Clone, PartialEq)]
#[derive(Clone, Copy, PartialEq)]
struct Snapshot {
default_mode: i32,
personal_mode: i32,
@@ -406,28 +407,32 @@ impl Restrictions {
impl Game<'_> {
pub(super) fn open_world_options(&mut self) {
let hint = horizon_client::lan::available_port();
let lan = self.lan.is_some();
let mut port = EditBox::new(0.0, 0.0, 150.0, 20.0);
port.max_length = 5;
let (guest_commands, force) = self.lan.as_ref().map_or((false, true), |h| {
(h.settings.guest_commands, h.settings.force_game_mode)
});
if let Some(p) = self.lan_port() {
// The world is the server thread's when there is one.
let state = match &self.integrated {
Some(server) => match server.call(|g| g.server_options()) {
Some(state) => state,
None => return,
},
None => self.local_server_options(),
};
if let Some(p) = state.port {
port.set_value(&p.to_string());
}
let mut options = WorldOptions {
default_mode: self.level.mode(),
personal_mode: self.mode_id(),
cheats: self.allow_commands(),
difficulty: self.ui.difficulty,
lan,
default_mode: state.default_mode,
personal_mode: state.personal_mode,
cheats: state.cheats,
difficulty: state.difficulty,
lan: state.port.is_some(),
port,
hint,
guest_commands,
force,
hardcore: self.level.hardcore,
difficulty_locked: self.level.difficulty_locked,
locked: self.level.difficulty_locked || self.level.hardcore,
guest_commands: state.guest_commands,
force: state.force,
hardcore: state.hardcore,
difficulty_locked: state.difficulty_locked,
locked: state.difficulty_locked || state.hardcore,
scroll: 0.0,
view: View::Options,
rules: None,
@@ -808,7 +813,7 @@ impl Game<'_> {
fn apply_and_close_world_options(&mut self, o: WorldOptions) {
let wanted = o.snapshot();
let before = o.initial.clone();
let before = o.initial;
self.world_options = Some(o);
self.apply_world_options(&before, &wanted);
self.close_world_options();
@@ -891,7 +896,47 @@ impl Game<'_> {
}
}
/// The world options of a world run in the frame.
fn local_server_options(&self) -> ServerOptions {
let (guest_commands, force) = self.lan.as_ref().map_or((false, true), |h| {
(h.settings.guest_commands, h.settings.force_game_mode)
});
ServerOptions {
default_mode: self.level.mode(),
personal_mode: self.mode_id(),
cheats: self.allow_commands(),
difficulty: self.ui.difficulty,
hardcore: self.level.hardcore,
difficulty_locked: self.level.difficulty_locked,
port: self.lan_port(),
guest_commands,
force,
}
}
fn apply_world_options(&mut self, before: &Snapshot, wanted: &Snapshot) {
if let Some(server) = &self.integrated {
// The server applies them; the window tells what came of
// Open to LAN (ShareToLanScreen's messages).
let (b, w) = (*before, *wanted);
server.call(move |g| g.apply_world_options(&b, &w));
if w.lan != b.lan || (w.lan && w.port != b.port) {
match (w.lan, self.lan_port()) {
(true, Some(port)) => self.system_message(Text::translate(
"menu.multiplayerOptions.publish.started.lan",
&[Text::literal(port.to_string())],
)),
(true, None) => {
self.system_message(Text::translate("commands.publish.failed", &[]));
}
(false, _) => self.system_message(Text::translate(
"menu.multiplayerOptions.publish.stopped",
&[],
)),
}
}
return;
}
if wanted.difficulty != before.difficulty {
let name = DIFFICULTIES[usize::from(wanted.difficulty) & 3];
self.as_console(|g| g.run_command(&format!("difficulty {name}")));
@@ -904,10 +949,15 @@ impl Game<'_> {
self.set_default_game_mode(wanted.default_mode);
}
if wanted.personal_mode != before.personal_mode {
self.set_mode_id(wanted.personal_mode);
if self.serving() {
self.set_owner_mode(wanted.personal_mode);
} else {
self.set_mode_id(wanted.personal_mode);
}
}
if wanted.cheats != before.cheats {
self.set_allow_commands(wanted.cheats);
self.owner_allow_commands(wanted.cheats);
}
let settings_changed =
wanted.guest_commands != before.guest_commands || wanted.force != before.force;
+4 -8
View File
@@ -186,16 +186,11 @@ impl Game<'_> {
}
/// Mouse buttons pressed while a key is being bound.
pub(super) fn options_waiting_for_key(&self) -> bool {
self.ui.options.selected_key.is_some() && self.ui.options.page() == Page::KeyBinds
self.ui.options.selected_key.is_some()
}
pub(super) fn options_bind_mouse(&mut self, button: MouseButton) -> Result<()> {
if let Some(name) = self.ui.options.selected_key.take() {
self.settings
.keys
.set(name, &horizon_client::keybinds::mouse_name(button));
self.handle_option_events(vec![Event::Changed])?;
}
Ok(())
let events = self.ui.options.bind_mouse(&mut self.settings, button);
self.handle_option_events(events)
}
pub(super) fn handle_option_events(&mut self, events: Vec<Event>) -> Result<()> {
for e in events {
@@ -244,6 +239,7 @@ impl Game<'_> {
let s = &self.settings;
if let Some(r) = self.renderer.as_mut() {
r.gamma = s.gamma;
r.fullbright = s.extras.fullbright;
r.set_present_mode(s.vsync, s.horizon.present_mode);
r.animated_textures = s.horizon.animated_textures;
r.set_mipmap_levels(s.mipmap_levels.max(0) as u32);
+61 -7
View File
@@ -427,7 +427,7 @@ impl Game<'_> {
}
/// `extractEntityInInventoryFollowsMouse`: the player in the box
/// `[x0, x1) x [y0, y1)`, `size` pixels per block, turned toward the
/// cursor; drawn as depth-sorted, back-face-culled quads.
/// cursor; drawn with a depth buffer and back-face culling.
#[allow(clippy::too_many_arguments)]
pub(super) fn draw_player_preview(
&self,
@@ -495,9 +495,9 @@ impl Game<'_> {
let quads = player_preview_quads(verts, gui, fire, &atlas.sprites);
let start = batch.vertices.len();
for (_, p, uv, color) in quads {
batch.quad(p, uv, color);
batch.quad_3d(p, uv, color);
}
batch.clip_since(start, x0, y0, x1, y1);
batch.depth_since(start, [x0, y0, x1, y1]);
}
/// The survival inventory's player box (`InventoryScreen`).
pub(super) fn draw_inventory_player(&self, batch: &mut HudBatch, ox: f32, oy: f32) {
@@ -570,7 +570,7 @@ fn player_preview_quads(
gui: glam::Mat4,
fire: Option<(f32, f32)>,
sprites: &std::collections::HashMap<String, horizon_client::hud::Rect>,
) -> Vec<(f32, [[f32; 2]; 4], [[f32; 2]; 4], u32)> {
) -> Vec<(f32, [[f32; 3]; 4], [[f32; 2]; 4], u32)> {
let flame_start = verts.len();
if let Some((width, height)) = fire {
horizon_client::fire_render::flames(
@@ -584,7 +584,7 @@ fn player_preview_quads(
&mut verts,
);
}
let mut quads: Vec<(f32, [[f32; 2]; 4], [[f32; 2]; 4], u32)> = Vec::new();
let mut quads: Vec<(f32, [[f32; 3]; 4], [[f32; 2]; 4], u32)> = Vec::new();
for (index, q) in verts.as_chunks::<4>().0.iter().enumerate() {
let p: [glam::Vec3; 4] =
std::array::from_fn(|i| gui.transform_point3(glam::Vec3::from_array(q[i].pos)));
@@ -606,12 +606,12 @@ fn player_preview_quads(
let depth = p.iter().map(|v| v.z).sum::<f32>() / 4.0;
quads.push((
depth,
p.map(|v| [v.x, v.y]),
p.map(|v| v.to_array()),
std::array::from_fn(|i| q[i].uv),
color,
));
}
// Far (low z) first: the viewer is on the +z side.
// Keep far-to-near order for translucent faces; opaque overlap uses depth.
quads.sort_by(|a, b| a.0.total_cmp(&b.0));
quads
}
@@ -619,6 +619,60 @@ fn player_preview_quads(
#[cfg(test)]
mod preview_tests {
use super::*;
#[test]
fn preview_keeps_crossing_faces_depth_and_clips_without_dropping_faces() {
use horizon_client::{
hud::{Blend, HudBatch},
mesher::Vertex,
};
let face = |z: [f32; 4]| {
[[-2.0, -1.0], [-2.0, 1.0], [2.0, 1.0], [2.0, -1.0]]
.into_iter()
.zip(z)
.map(|([x, y], z)| Vertex {
pos: [x, y, z],
uv: [0.0; 2],
layer: 0,
color: u32::MAX,
light: 0,
normal: [0; 4],
})
};
// A shield and arm can intersect: neither average depth orders both ends.
let verts = face([1.0, 1.0, -1.0, -1.0]).chain(face([0.0; 4])).collect();
let quads = player_preview_quads(verts, glam::Mat4::IDENTITY, None, &Default::default());
assert_eq!(quads.len(), 2);
let mut batch = HudBatch::new([320, 240]);
for (_, p, uv, color) in quads {
batch.quad_3d(p, uv, color);
}
// Its centre is outside this scissor; the visible part must still be drawn.
batch.depth_since(0, [1.0, 0.0, 2.0, 1.0]);
assert_eq!(batch.vertices.len(), 12);
let shield = &batch.vertices[..6];
let arm = &batch.vertices[6..];
assert!(shield[0].depth < arm[0].depth);
assert!(shield[2].depth > arm[2].depth);
assert_eq!(batch.runs(), vec![(0..12, Blend::Depth([1, 0, 1, 1]))]);
}
#[test]
#[ignore = "requires prepared model data in HORIZON_TEST_RESOURCES"]
fn player_render_transform_uses_vanilla_avatar_scale() {
let root = std::path::PathBuf::from(
std::env::var_os("HORIZON_TEST_RESOURCES").expect("HORIZON_TEST_RESOURCES"),
);
let mut m = Mob::new(1, player_type(&root).unwrap(), Vec3::ZERO, 0.0);
for (id, expected) in [("minecraft:player", 0.9375), ("minecraft:zombie", 1.0)] {
Arc::make_mut(&mut m.kind).id = id.into();
let transform =
horizon_client::mobs::render::base_transform_at(&m, 1.0, glam::Mat4::IDENTITY);
for axis in [glam::Vec3::X, glam::Vec3::Y, glam::Vec3::Z] {
assert!((transform.transform_vector3(axis).length() - expected).abs() < 1e-6);
}
}
}
#[test]
fn burning_inventory_preview_keeps_visible_fullbright_flames() {
let rect = |u0| horizon_client::hud::Rect {
+40 -9
View File
@@ -49,6 +49,14 @@ impl Game<'_> {
});
}
}
/// What a player's body was last given for its effects and enchantments:
/// a guest keeps their own while the host's are in `PotionState`.
#[derive(Default)]
pub(super) struct BodyPotions {
applied: Vec<(&'static str, &'static str, f64, &'static str)>,
protection_for: Option<Vec<Option<ItemStack>>>,
enchant_modifiers: Vec<(String, String, f64, String)>,
}
/// Effects, thrown potions and the attribute modifiers last applied.
#[derive(Default)]
pub(super) struct PotionState {
@@ -63,6 +71,14 @@ pub(super) struct PotionState {
}
impl PotionState {
/// Trade the player's own state (effects and what their body was given)
/// with a guest's, around `as_guest`. Potions in flight stay.
pub(super) fn swap_player(&mut self, effects: &mut PlayerEffects, body: &mut BodyPotions) {
std::mem::swap(&mut self.effects, effects);
std::mem::swap(&mut self.applied, &mut body.applied);
std::mem::swap(&mut self.protection_for, &mut body.protection_for);
std::mem::swap(&mut self.enchant_modifiers, &mut body.enchant_modifiers);
}
/// Thrown potions in flight as (entity type, position, motion), for the
/// dispenser parity fixture.
pub(super) fn thrown_entities(&self) -> Vec<(&'static str, Vec3, Vec3)> {
@@ -274,8 +290,16 @@ impl Game<'_> {
}
}
}
/// `LivingEntity.tickEffects`, attribute modifiers and the status flags.
/// The local player's effects (`tick_mob_effects`), then the potions
/// in flight, which a server without a local player still has.
pub(super) fn tick_effects(&mut self) {
self.tick_mob_effects();
self.tick_thrown_potions();
}
/// `LivingEntity.tickEffects` (server side) for `self.player`, the local
/// player or a guest acting (`as_guest`), then its attribute modifiers
/// and status flags.
pub(super) fn tick_mob_effects(&mut self) {
let Some(player) = self.player.as_ref() else {
return;
};
@@ -294,6 +318,20 @@ impl Game<'_> {
for action in actions {
self.apply_effect_action(action);
}
self.apply_effect_status();
}
/// A client's own effects (`LivingEntity.tickEffects` on the client,
/// `MobEffectInstance.tickClient`): they count down, and the server
/// removes them. Their modifiers and flags move the predicted player.
pub(super) fn tick_client_effects(&mut self) {
for e in &mut self.potions.effects.list {
e.tick_client();
}
self.apply_effect_status();
}
/// The effects' attribute modifiers, armor protection and status flags
/// on `self.player`.
fn apply_effect_status(&mut self) {
let modifiers = self.potions.effects.modifiers();
if modifiers != self.potions.applied
&& let Some(p) = self.player.as_mut()
@@ -346,7 +384,6 @@ impl Game<'_> {
status.protection = std::mem::take(&mut p.status.protection);
p.status = status;
}
self.tick_thrown_potions();
}
fn tick_thrown_potions(&mut self) {
let mut thrown = std::mem::take(&mut self.potions.thrown);
@@ -606,13 +643,7 @@ impl Game<'_> {
/// Effects saved in level.dat (`Player.active_effects`).
pub(super) fn restore_effects(&mut self) {
self.potions = PotionState::default();
for (id, duration, amplifier, ambient, _) in self.level.active_effects.clone() {
if let Some(def) = brewing::effect(&id) {
let mut e = EffectInstance::new(def.id, duration, amplifier);
e.ambient = ambient;
self.potions.effects.add(e);
}
}
self.potions.effects = PlayerEffects::from_saved(&self.level.active_effects);
}
pub(super) fn effects_json(&self) -> serde_json::Value {
serde_json::json!({
+52 -1
View File
@@ -68,6 +68,7 @@ struct Lerp {
pub(super) struct Remote {
pub session: Session,
pub brand: String,
builtin: Arc<Builtin>,
lang: Arc<Language>,
registries: Arc<Dynamic>,
@@ -251,6 +252,7 @@ impl Game<'_> {
self.apply_settings();
self.remote = Some(Remote {
session,
brand: "unknown".into(),
builtin: Arc::new(builtin),
lang,
registries: Arc::new(Dynamic::default()),
@@ -380,6 +382,31 @@ impl Game<'_> {
.unwrap_or("minecraft:air"),
)
}
/// A mob effect's network id as the effect (`brewing::EFFECTS` id).
fn remote_effect_id(&self, effect: i32) -> Option<&'static str> {
let r = self.remote.as_ref()?;
let name = r.builtin.get("minecraft:mob_effect")?.name(effect)?;
horizon_client::brewing::effect(name).map(|d| d.id)
}
/// ClientPacketListener.handleUpdateMobEffect for the player itself
/// (`LivingEntity.forceAddEffect`): the effect replaces any of its kind.
/// Other entities' effects are not shown.
fn remote_effect(&mut self, p: &play::UpdateMobEffect) {
if !self.remote.as_ref().is_some_and(|r| r.entity_id == p.id) {
return;
}
let Some(id) = self.remote_effect_id(p.effect) else {
return;
};
let mut e = horizon_client::effects::EffectInstance::new(id, p.duration, p.amplifier);
e.ambient = p.flags & 1 != 0;
e.visible = p.flags & 2 != 0;
let list = &mut self.potions.effects.list;
match list.iter_mut().find(|x| x.id == id) {
Some(existing) => *existing = e,
None => list.push(e),
}
}
fn item_id(&self, name: &str) -> i32 {
let r = self.remote.as_ref().expect("remote");
r.builtin
@@ -415,7 +442,7 @@ impl Game<'_> {
}
Some(stack)
}
fn chat_line(&mut self, text: String) {
pub(super) fn chat_line(&mut self, text: String) {
log::info!("[chat] {text}");
if let Some(r) = self.remote.as_mut() {
r.chat.push((text, Instant::now()));
@@ -456,6 +483,11 @@ impl Game<'_> {
r.status = format!("Joined as {name}; loading terrain...");
}
}
Event::Brand(brand) => {
if let Some(remote) = &mut self.remote {
remote.brand = brand;
}
}
Event::Reconfigured(registries) => self.set_registries(registries),
Event::DecodeError(e) => {
if let Some(r) = self.remote.as_mut() {
@@ -820,6 +852,8 @@ impl Game<'_> {
));
}
C::Respawn(p) => {
// A new player, without effects: the server sends them again.
self.potions.effects.clear();
self.enter_remote_dimension(&p.spawn, true);
self.screen = Screen::Playing;
if let Some(r) = self.remote.as_mut() {
@@ -1120,6 +1154,14 @@ impl Game<'_> {
}
}
C::EntityEvent(p) => {
// EntityEvent.PERMISSION_LEVEL_ALL..OWNERS (24..=28) for this
// player: LocalPlayer.setPermissionLevel, which the commands
// the chat offers and checks follow.
if (24..=28).contains(&p.event)
&& self.remote.as_ref().is_some_and(|r| r.entity_id == p.id)
{
self.ui.registries.permission = (p.event - 24) as u8;
}
if p.event == 1
&& let Some(m) = self.mobs.iter_mut().find(|m| m.id == p.id as u32)
&& m.species() == horizon_client::mobs::Species::Rabbit
@@ -1134,6 +1176,14 @@ impl Game<'_> {
}
}
C::Animate(p) if p.action == 0 => {}
C::UpdateMobEffect(p) => self.remote_effect(&p),
C::RemoveMobEffect(p) => {
if self.remote.as_ref().is_some_and(|r| r.entity_id == p.id)
&& let Some(id) = self.remote_effect_id(p.effect)
{
self.potions.effects.list.retain(|e| e.id != id);
}
}
C::SetHealth(p) => {
if let Some(r) = self.remote.as_mut() {
r.health = (p.health, p.food, p.saturation);
@@ -1803,6 +1853,7 @@ impl Game<'_> {
self.tick_block_entity_anims();
self.tick_hand();
self.tick_particles();
self.tick_client_effects();
let ghast_collisions = self.happy_ghast_player_collisions();
let Some(player) = self.player.as_mut() else {
return Ok(());
+7 -10
View File
@@ -60,17 +60,14 @@ impl Game<'_> {
&& horizon_client::ui_theme::horizon()
}
fn pause_labels(&self) -> (String, &'static str) {
let world = if self.remote.is_some() {
"Multiplayer".to_owned()
if let Some(server) = &self.integrated {
return (server.world_name.clone(), "Save and quit");
}
if self.remote.is_some() {
("Multiplayer".to_owned(), "Disconnect")
} else {
self.level.name.clone()
};
let quit = if self.remote.is_some() {
"Disconnect"
} else {
"Save and quit"
};
(world, quit)
(self.level.name.clone(), "Save and quit")
}
}
pub(super) fn draw_pause_menu(&mut self, batch: &mut HudBatch) {
if horizon_client::ui_theme::horizon() {
+77 -6
View File
@@ -6,6 +6,7 @@
use super::{Game, GameLevel, Screen, dispenser::new_item_motion, storage::is_shulker_box};
use horizon_client::{
containers::{Banner, BlockEntity},
item_data,
items::ItemStack,
};
use horizon_core::position::BlockPos;
@@ -15,6 +16,7 @@ use horizon_world::{
LevelEvent,
removal::{self, PreRemove},
},
nbt::{JavaString, Tag},
registry::BlockStateId,
};
use std::collections::HashMap;
@@ -80,14 +82,37 @@ impl Pending {
stack.data_mut().pot_decorations = Some(Box::new(sides));
}
if stack.item.ends_with("_banner")
&& let Some(Banner { layers, name }) = self.banner.remove(&pos)
&& let Some(Banner {
layers,
name,
components,
}) = self.banner.remove(&pos)
{
let data = stack.data_mut();
data.banner_patterns = layers;
if name.is_some() {
data.custom_name = name;
let mut patch = match item_data::encode_components(stack) {
Some(Tag::Compound(c)) => c,
_ => Default::default(),
};
// The remaining components in the banner loot table's copy_components.
for key in [
"minecraft:item_name",
"minecraft:rarity",
"minecraft:tooltip_display",
] {
if let Some(value) = components.get(&JavaString::from(key)) {
patch.insert(key.into(), value.clone());
}
}
stack.tidy();
patch.insert(
"minecraft:banner_patterns".into(),
horizon_client::banner::layers_to_nbt(&layers),
);
if let Some(name) = name {
patch.insert(
"minecraft:custom_name".into(),
Tag::String(name.as_str().into()),
);
}
(stack.damage, stack.extra) = item_data::decode_components(Some(&Tag::Compound(patch)));
}
}
/// Remember a decorated pot's sherds from its saved block entity.
@@ -553,3 +578,49 @@ impl Game<'_> {
}
}
}
#[cfg(test)]
mod tests {
use super::*;
use horizon_client::{block_entity_item, item_data, mobs::raider, save};
use horizon_world::nbt::Tag;
#[test]
fn ominous_banner_survives_placement_save_and_drop() {
let original = raider::ominous_banner();
let Tag::Compound(components) = item_data::encode_components(&original).unwrap() else {
panic!("banner components");
};
for block in ["minecraft:white_banner", "minecraft:white_wall_banner"] {
let pos = (1, 64, 2);
let fresh = BlockEntity::for_block(block).unwrap();
let fresh = save::encode_block_entity(pos, &fresh, block);
let placed = block_entity_item::place(&fresh, &components, false);
let (_, placed) = save::decode_block_entity(&placed).unwrap();
let saved = save::encode_block_entity(pos, &placed, block);
let (_, loaded) = save::decode_block_entity(&saved).unwrap();
let BlockEntity::Banner(banner) = &loaded else {
panic!("placed banner");
};
assert_eq!(banner.layers.len(), item_data::OMINOUS_LAYERS.len());
let mut pending = Pending::default();
pending.record([pos.0, pos.1, pos.2], &loaded, block, None);
let mut dropped = ItemStack::new("minecraft:white_banner", 1);
pending.attach([pos.0, pos.1, pos.2], &mut dropped);
assert!(dropped.data().unwrap().ominous_banner);
assert!(horizon_client::banner::tooltip_layers(&dropped).is_empty());
assert_eq!(
horizon_client::item_tooltip::name_line(&dropped, &|_| None),
"Ominous Banner"
);
assert_eq!(
horizon_client::item_tooltip::rarity(&dropped, "common"),
"uncommon"
);
assert_eq!(
item_data::encode_components(&dropped),
Some(Tag::Compound(components.clone()))
);
}
}
}
+5 -13
View File
@@ -1860,18 +1860,10 @@ impl Game<'_> {
pub(super) fn stack_tooltip(&self, stack: &ItemStack) -> Vec<(String, u32)> {
let e: &Enchantments = &self.res.stations.enchantments;
let props = e.props(&stack.item);
let mut rarity = props.map_or("common", |p| p.rarity.as_str());
// The ominous banner's rarity component.
if stack.data().is_some_and(|d| d.ominous_banner) {
rarity = "uncommon";
}
if !stack.enchantments().is_empty() {
rarity = match rarity {
"common" | "uncommon" => "rare",
"rare" => "epic",
r => r,
};
}
let rarity = horizon_client::item_tooltip::rarity(
stack,
props.map_or("common", |p| p.rarity.as_str()),
);
let color = match rarity {
"uncommon" => rgba(255, 255, 85, 255),
"rare" => rgba(85, 255, 255, 255),
@@ -1952,7 +1944,7 @@ impl Game<'_> {
));
}
// BannerPatternLayers.addToTooltip: up to six layer names.
for layer in horizon_client::banner::layers(stack).iter().take(6) {
for layer in horizon_client::banner::tooltip_layers(stack).iter().take(6) {
let key = self.res.stations.banners.layer_key(layer);
lines.push((self.translate(&key, &key), rgba(170, 170, 170, 255)));
}
+7 -14
View File
@@ -6,6 +6,7 @@ use horizon_client::{
hud::HudBatch,
hud_layout,
hud_overlays::HeldName,
item_tooltip,
text::{self, Text},
};
@@ -24,22 +25,14 @@ impl Game<'_> {
fn held_name(&self) -> Option<HeldName> {
let stack = self.inventory.get(self.selected)?.as_ref()?;
let custom = stack.custom_name();
// ItemStack.getRarity: enchanting raises common and uncommon to rare
// and rare to epic.
let mut rarity = self.item_rarity(&stack.item);
if !stack.enchantments().is_empty() {
rarity = match rarity.as_str() {
"common" | "uncommon" => "rare".into(),
"rare" => "epic".into(),
_ => rarity,
};
}
let default_rarity = self.item_rarity(&stack.item);
let rarity = item_tooltip::rarity(stack, &default_rarity);
Some(HeldName {
item: stack.item.to_string(),
hover_name: Text::literal(
custom.map_or_else(|| self.pack.names.item(&stack.item), str::to_owned),
),
rarity_color: match rarity.as_str() {
hover_name: Text::literal(item_tooltip::name_line(stack, &|key| {
self.pack.names.get(key).map(str::to_owned)
})),
rarity_color: match rarity {
"uncommon" => text::YELLOW,
"rare" => text::AQUA,
"epic" => text::LIGHT_PURPLE,
+8 -2
View File
@@ -28,7 +28,7 @@ use horizon_client::{
menu::Input,
stations::hover_name,
};
use winit::keyboard::KeyCode;
use winit::{event::MouseButton, keyboard::KeyCode};
/// A sort button's side in GUI pixels.
const SORT_BUTTON: f32 = 9.0;
@@ -377,8 +377,14 @@ impl Game<'_> {
/// The sort key: sorts the part under the cursor (the container when
/// the cursor is over no slot).
pub(super) fn sort_key_press(&mut self, key: KeyCode) -> bool {
keybinds::key_name(key).is_some_and(|name| self.sort_input(name))
}
pub(super) fn sort_mouse_press(&mut self, button: MouseButton) -> bool {
self.sort_input(&keybinds::mouse_name(button))
}
fn sort_input(&mut self, name: &str) -> bool {
let e = &self.settings.extras;
if !e.sort || keybinds::key_code(&e.sort_key) != Some(key) || self.recipe_search_focused() {
if !e.sort || e.sort_key != name || self.recipe_search_focused() {
return false;
}
let buttons = self.sort_buttons();
+207 -113
View File
@@ -290,7 +290,13 @@ pub struct Renderer {
group: wgpu::BindGroup,
globals: wgpu::Buffer,
lightmap: wgpu::Texture,
sprite_texture: wgpu::Texture,
/// The block sprites, [`SPRITE_SPLIT`] layers per array (the first is
/// `sprites` in terrain.wgsl, the others `sprites_1`...).
sprite_textures: Vec<wgpu::Texture>,
/// A 1-layer array bound where a pack needs fewer arrays.
sprite_unused: wgpu::TextureView,
/// Layers per sprite array ([`SPRITE_SPLIT`] but in tests).
sprite_split: u32,
mip_levels: u32,
/// The mipmap levels sampled (the Mipmap Levels option), at most `mip_levels - 1`.
mipmaps: u32,
@@ -348,12 +354,87 @@ pub struct Renderer {
pub screenshot_result: Option<std::result::Result<[u32; 2], String>>,
/// Brightness option (lightmap gamma), 0..1.
pub gamma: f32,
/// Optional full-light lightmap (Horizon Extras).
pub fullbright: bool,
/// Advance animated block textures (Horizon setting; vanilla always does).
pub animated_textures: bool,
present_modes: Vec<wgpu::PresentMode>,
}
/// Every layer's mip levels, layer major (`first` is the first layer's
/// index into `settings`), made by `MipmapGenerator`.
/// Block sprite layers per texture array: the smallest
/// `max_texture_array_layers` of the GPUs Horizon runs on. Mods add sprites
/// past it into more arrays (terrain.wgsl's `sprite`).
pub(crate) const SPRITE_SPLIT: u32 = 2048;
/// [`SPRITE_SPLIT`], or a smaller split from `HORIZON_SPRITE_SPLIT` (dev
/// only: vanilla's sprites drawn from several arrays must look the same).
fn sprite_split() -> u32 {
std::env::var("HORIZON_SPRITE_SPLIT")
.ok()
.and_then(|v| v.parse().ok())
.filter(|&n| (1..=SPRITE_SPLIT).contains(&n))
.unwrap_or(SPRITE_SPLIT)
}
/// Sprite arrays terrain.wgsl binds (`sprites`, `sprites_1`...).
const SPRITE_ARRAYS: u32 = 4;
/// The views of terrain.wgsl's sprite arrays, the unused ones a 1-layer
/// stand-in.
fn sprite_views(
textures: &[wgpu::Texture],
unused: &wgpu::TextureView,
mips: Option<u32>,
) -> Vec<wgpu::TextureView> {
(0..SPRITE_ARRAYS as usize)
.map(|i| match textures.get(i) {
Some(t) => t.create_view(&wgpu::TextureViewDescriptor {
dimension: Some(wgpu::TextureViewDimension::D2Array),
mip_level_count: mips,
..Default::default()
}),
None => unused.clone(),
})
.collect()
}
/// terrain.wgsl's group 0.
#[allow(clippy::too_many_arguments)]
fn terrain_group(
device: &wgpu::Device,
label: &str,
layout: &wgpu::BindGroupLayout,
globals: &wgpu::Buffer,
sprites: &[wgpu::TextureView],
sprite_sampler: &wgpu::Sampler,
lightmap: &wgpu::TextureView,
lightmap_sampler: &wgpu::Sampler,
) -> wgpu::BindGroup {
let view = |binding, view| wgpu::BindGroupEntry {
binding,
resource: wgpu::BindingResource::TextureView(view),
};
device.create_bind_group(&wgpu::BindGroupDescriptor {
label: Some(label),
layout,
entries: &[
wgpu::BindGroupEntry {
binding: 0,
resource: globals.as_entire_binding(),
},
view(1, &sprites[0]),
wgpu::BindGroupEntry {
binding: 2,
resource: wgpu::BindingResource::Sampler(sprite_sampler),
},
view(3, lightmap),
wgpu::BindGroupEntry {
binding: 4,
resource: wgpu::BindingResource::Sampler(lightmap_sampler),
},
view(5, &sprites[1]),
view(6, &sprites[2]),
view(7, &sprites[3]),
],
})
}
fn mip_chain(
pixels: &[u8],
size: u32,
@@ -494,10 +575,19 @@ impl Renderer {
),
);
let limits = adapter.limits();
if limits.max_texture_array_layers < layers {
let split = sprite_split();
if layers > split * SPRITE_ARRAYS {
return Err(format!(
"GPU supports {} texture layers; {layers} required",
limits.max_texture_array_layers
"{layers} block textures; Horizon draws at most {}",
split * SPRITE_ARRAYS
)
.into());
}
if limits.max_texture_array_layers < layers.min(split) {
return Err(format!(
"GPU supports {} texture layers; {} required",
limits.max_texture_array_layers,
layers.min(split)
)
.into());
}
@@ -565,6 +655,19 @@ impl Renderer {
count: None,
};
let vf = wgpu::ShaderStages::VERTEX_FRAGMENT;
let sprite_array = wgpu::BindingType::Texture {
sample_type: wgpu::TextureSampleType::Float { filterable: true },
view_dimension: wgpu::TextureViewDimension::D2Array,
multisampled: false,
};
let sprite_arrays = layers.div_ceil(split).max(1);
if sprite_arrays > 1 {
log::info!("Horizon: {layers} block textures in {sprite_arrays} arrays");
}
let sprite_constants = [
("SPRITE_ARRAYS", f64::from(sprite_arrays)),
("SPRITE_SPLIT", f64::from(split)),
];
let bindings = device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
label: Some("Horizon terrain bindings"),
entries: &[
@@ -605,6 +708,9 @@ impl Renderer {
vf,
wgpu::BindingType::Sampler(wgpu::SamplerBindingType::Filtering),
),
entry(5, vf, sprite_array),
entry(6, vf, sprite_array),
entry(7, vf, sprite_array),
],
});
let layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
@@ -677,7 +783,10 @@ impl Renderer {
fragment: Some(wgpu::FragmentState {
module: &shader,
entry_point: Some(fragment),
compilation_options: Default::default(),
compilation_options: wgpu::PipelineCompilationOptions {
constants: &sprite_constants,
..Default::default()
},
targets: &[Some(wgpu::ColorTargetState {
format: config.format.remove_srgb_suffix(),
blend,
@@ -784,30 +893,62 @@ impl Renderer {
usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST,
mapped_at_creation: false,
});
let (mips, mip_levels) = mip_chain(sprite_pixels, sprite_size, sprite_mips, 0, layers);
let sprite_texture = device.create_texture_with_data(
&queue,
&wgpu::TextureDescriptor {
label: Some("Block sprites"),
let layer_bytes = (sprite_size * sprite_size * 4) as usize;
let mut mip_levels = 1;
let sprite_textures: Vec<wgpu::Texture> = (0..sprite_arrays)
.map(|array| {
let first = array * split;
let count = layers.saturating_sub(first).clamp(1, split);
let start = (first as usize * layer_bytes).min(sprite_pixels.len());
let (mips, levels) = mip_chain(
&sprite_pixels[start..],
sprite_size,
sprite_mips,
first,
count,
);
mip_levels = levels;
device.create_texture_with_data(
&queue,
&wgpu::TextureDescriptor {
label: Some("Block sprites"),
size: wgpu::Extent3d {
width: sprite_size,
height: sprite_size,
depth_or_array_layers: count,
},
mip_level_count: levels,
sample_count: 1,
dimension: wgpu::TextureDimension::D2,
format: wgpu::TextureFormat::Rgba8Unorm,
usage: wgpu::TextureUsages::TEXTURE_BINDING | wgpu::TextureUsages::COPY_DST,
view_formats: &[],
},
wgpu::util::TextureDataOrder::LayerMajor,
&mips,
)
})
.collect();
let sprite_unused = device
.create_texture(&wgpu::TextureDescriptor {
label: Some("Block sprites (unused)"),
size: wgpu::Extent3d {
width: sprite_size,
height: sprite_size,
depth_or_array_layers: layers,
width: 1,
height: 1,
depth_or_array_layers: 1,
},
mip_level_count: mip_levels,
mip_level_count: 1,
sample_count: 1,
dimension: wgpu::TextureDimension::D2,
format: wgpu::TextureFormat::Rgba8Unorm,
usage: wgpu::TextureUsages::TEXTURE_BINDING | wgpu::TextureUsages::COPY_DST,
usage: wgpu::TextureUsages::TEXTURE_BINDING,
view_formats: &[],
},
wgpu::util::TextureDataOrder::LayerMajor,
&mips,
);
let sprite_view = sprite_texture.create_view(&wgpu::TextureViewDescriptor {
dimension: Some(wgpu::TextureViewDimension::D2Array),
..Default::default()
});
})
.create_view(&wgpu::TextureViewDescriptor {
dimension: Some(wgpu::TextureViewDimension::D2Array),
..Default::default()
});
let sprite_views = sprite_views(&sprite_textures, &sprite_unused, None);
let sprite_sampler = device.create_sampler(&wgpu::SamplerDescriptor {
label: Some("Block sprites"),
address_mode_u: wgpu::AddressMode::Repeat,
@@ -838,58 +979,26 @@ impl Renderer {
min_filter: wgpu::FilterMode::Linear,
..Default::default()
});
let group = device.create_bind_group(&wgpu::BindGroupDescriptor {
label: Some("Horizon terrain resources"),
layout: &bindings,
entries: &[
wgpu::BindGroupEntry {
binding: 0,
resource: globals.as_entire_binding(),
},
wgpu::BindGroupEntry {
binding: 1,
resource: wgpu::BindingResource::TextureView(&sprite_view),
},
wgpu::BindGroupEntry {
binding: 2,
resource: wgpu::BindingResource::Sampler(&sprite_sampler),
},
wgpu::BindGroupEntry {
binding: 3,
resource: wgpu::BindingResource::TextureView(&lightmap_view),
},
wgpu::BindGroupEntry {
binding: 4,
resource: wgpu::BindingResource::Sampler(&lightmap_sampler),
},
],
});
let crosshair_group = device.create_bind_group(&wgpu::BindGroupDescriptor {
label: Some("Debug crosshair resources"),
layout: &bindings,
entries: &[
wgpu::BindGroupEntry {
binding: 0,
resource: crosshair_globals.as_entire_binding(),
},
wgpu::BindGroupEntry {
binding: 1,
resource: wgpu::BindingResource::TextureView(&sprite_view),
},
wgpu::BindGroupEntry {
binding: 2,
resource: wgpu::BindingResource::Sampler(&sprite_sampler),
},
wgpu::BindGroupEntry {
binding: 3,
resource: wgpu::BindingResource::TextureView(&lightmap_view),
},
wgpu::BindGroupEntry {
binding: 4,
resource: wgpu::BindingResource::Sampler(&lightmap_sampler),
},
],
});
let group = terrain_group(
&device,
"Horizon terrain resources",
&bindings,
&globals,
&sprite_views,
&sprite_sampler,
&lightmap_view,
&lightmap_sampler,
);
let crosshair_group = terrain_group(
&device,
"Debug crosshair resources",
&bindings,
&crosshair_globals,
&sprite_views,
&sprite_sampler,
&lightmap_view,
&lightmap_sampler,
);
let index_quads = 1 << 16;
let indices = Self::quad_indices(&device, index_quads);
let instance_capacity = 4096;
@@ -1575,7 +1684,9 @@ impl Renderer {
group,
globals,
lightmap,
sprite_texture,
sprite_textures,
sprite_unused,
sprite_split: split,
mip_levels,
mipmaps: mip_levels - 1,
terrain_layout: bindings,
@@ -1616,6 +1727,7 @@ impl Renderer {
screenshot: None,
screenshot_result: None,
gamma: 0.5,
fullbright: false,
animated_textures: true,
present_modes,
})
@@ -1864,7 +1976,7 @@ impl Renderer {
pub fn set_mipmap_levels(&mut self, levels: u32) {
let levels = sprite_mipmap_limit(
levels,
self.sprite_texture.width(),
self.sprite_textures[0].width(),
self.sprite_minimum_size,
self.mip_levels,
);
@@ -1872,39 +1984,17 @@ impl Renderer {
return;
}
self.mipmaps = levels;
let sprite_view = self
.sprite_texture
.create_view(&wgpu::TextureViewDescriptor {
dimension: Some(wgpu::TextureViewDimension::D2Array),
mip_level_count: Some(levels + 1),
..Default::default()
});
self.group = self.device.create_bind_group(&wgpu::BindGroupDescriptor {
label: Some("Horizon terrain resources"),
layout: &self.terrain_layout,
entries: &[
wgpu::BindGroupEntry {
binding: 0,
resource: self.globals.as_entire_binding(),
},
wgpu::BindGroupEntry {
binding: 1,
resource: wgpu::BindingResource::TextureView(&sprite_view),
},
wgpu::BindGroupEntry {
binding: 2,
resource: wgpu::BindingResource::Sampler(&self.sprite_sampler),
},
wgpu::BindGroupEntry {
binding: 3,
resource: wgpu::BindingResource::TextureView(&self.lightmap_view),
},
wgpu::BindGroupEntry {
binding: 4,
resource: wgpu::BindingResource::Sampler(&self.lightmap_sampler),
},
],
});
let views = sprite_views(&self.sprite_textures, &self.sprite_unused, Some(levels + 1));
self.group = terrain_group(
&self.device,
"Horizon terrain resources",
&self.terrain_layout,
&self.globals,
&views,
&self.sprite_sampler,
&self.lightmap_view,
&self.lightmap_sampler,
);
}
pub fn view_projection(&self, frame: &Frame) -> Mat4 {
self.projection(
@@ -1972,6 +2062,9 @@ impl Renderer {
pixels[i + 3] = 255;
}
}
if self.fullbright {
pixels.fill(255);
}
// The lightmap changes with the time of day, flicker and effects,
// not every frame: upload only what differs from the texture.
if pixels == self.lightmap_pixels && self.lightmap_uploaded {
@@ -2001,12 +2094,12 @@ impl Renderer {
self.uploads.texture(
encoder,
wgpu::TexelCopyTextureInfo {
texture: &self.sprite_texture,
texture: &self.sprite_textures[(layer / self.sprite_split) as usize],
mip_level: level,
origin: wgpu::Origin3d {
x: 0,
y: 0,
z: layer,
z: layer % self.sprite_split,
},
aspect: wgpu::TextureAspect::All,
},
@@ -2217,7 +2310,7 @@ impl Renderer {
visible.clear();
self.sections.visible(
camera,
frame.distance,
(frame.distance / 16.0) as i32,
&view,
|k| !culling || reachable.contains(k),
&mut visible,
@@ -2776,6 +2869,7 @@ impl Renderer {
&mut self.uploads,
&mut encoder,
&view_target,
&self.depth,
frame.hud,
[self.config.width, self.config.height],
);
+30 -28
View File
@@ -3,7 +3,7 @@
//! the render distance rejects all of its sections with one test, and the
//! sections that remain are reached by index rather than by hashing keys.
use super::{Frustum, SectionKey};
use crate::fast_hash::FxHashMap;
use crate::{fast_hash::FxHashMap, streaming::in_view_distance};
use glam::{DVec3, Vec3};
/// One chunk column's resident sections.
@@ -149,26 +149,28 @@ fn origin(key: SectionKey, camera: DVec3) -> DVec3 {
) - camera
}
/// Whether the section at `key` is drawn: within `distance` blocks of the
/// camera horizontally (plus a section and a half), and partly inside the
/// frustum. `None` when it is not, else its squared centre distance and origin.
fn in_view(
key: SectionKey,
camera: DVec3,
distance: f32,
frustum: &Frustum,
) -> Option<(f64, Vec3)> {
let origin = origin(key, camera);
let center = origin + DVec3::splat(8.0);
let horizontal = (center.x * center.x + center.z * center.z).sqrt();
if horizontal > f64::from(distance) + 24.0 {
/// The camera's chunk column.
fn camera_column(camera: DVec3) -> (i32, i32) {
(
(camera.x.floor() as i32) >> 4,
(camera.z.floor() as i32) >> 4,
)
}
/// Whether the section at `key` is drawn: its column within the render
/// distance of the camera's (`SectionOcclusionGraph.isInViewDistance`), and
/// partly inside the frustum. `None` when it is not, else its squared centre
/// distance and origin.
fn in_view(key: SectionKey, camera: DVec3, radius: i32, frustum: &Frustum) -> Option<(f64, Vec3)> {
if !in_view_distance(camera_column(camera), radius, key.0, key.2) {
return None;
}
let origin = origin(key, camera);
let min = origin.as_vec3();
if !frustum.intersects(min, min + Vec3::splat(16.0)) {
return None;
}
Some((center.length_squared(), min))
Some(((origin + DVec3::splat(8.0)).length_squared(), min))
}
impl<T> Resident<T> {
@@ -178,22 +180,22 @@ impl<T> Resident<T> {
/// Columns are tested first, with the same distance test (it depends
/// only on x and z) and a box spanning their sections: every section box
/// lies inside it and the frustum test rounds monotonically, so a column
/// the frustum rejects holds no section it would accept.
/// the frustum rejects holds no section it would accept. `radius` is the
/// render distance in chunks.
pub fn visible(
&self,
camera: DVec3,
distance: f32,
radius: i32,
frustum: &Frustum,
reachable: impl Fn(SectionKey) -> bool,
out: &mut Vec<Visible>,
) {
let from = camera_column(camera);
for column in &self.columns {
let low = origin((column.x, column.low, column.z), camera);
let center = low + DVec3::splat(8.0);
if (center.x * center.x + center.z * center.z).sqrt() > f64::from(distance) + 24.0 {
if !in_view_distance(from, radius, column.x, column.z) {
continue;
}
let min = low.as_vec3();
let min = origin((column.x, column.low, column.z), camera).as_vec3();
let top = origin((column.x, column.high, column.z), camera).as_vec3();
if !frustum.intersects(min, top + Vec3::splat(16.0)) {
continue;
@@ -203,7 +205,7 @@ impl<T> Resident<T> {
if !reachable(key) {
continue;
}
if let Some((d, o)) = in_view(key, camera, distance, frustum) {
if let Some((d, o)) = in_view(key, camera, radius, frustum) {
out.push(Visible {
distance: d.to_bits(),
key,
@@ -243,20 +245,20 @@ mod tests {
(DVec3::new(8.0, 64.0, 8.0), 45.0, 89.0),
];
for (camera, yaw, pitch) in cameras {
for distance in [32.0, 96.0, 160.0] {
for radius in [2, 6, 10] {
let projection = super::super::world_projection(70.0, 16.0 / 9.0, 512.0);
let view = crate::camera::view_matrix(yaw, pitch);
let frustum = Frustum {
planes: super::super::frustum(projection * view),
};
let mut fast = Vec::new();
r.visible(camera, distance, &frustum, reachable, &mut fast);
r.visible(camera, radius, &frustum, reachable, &mut fast);
let mut slow: Vec<(SectionKey, f64, [f32; 3])> = r
.items
.iter()
.filter(|(k, _)| reachable(*k))
.filter_map(|(k, _)| {
in_view(*k, camera, distance, &frustum).map(|(d, o)| (*k, d, o.to_array()))
in_view(*k, camera, radius, &frustum).map(|(d, o)| (*k, d, o.to_array()))
})
.collect();
slow.sort_unstable_by(|a, b| a.1.total_cmp(&b.1).then(a.0.cmp(&b.0)));
@@ -268,7 +270,7 @@ mod tests {
})
.collect();
assert!(!slow.is_empty());
assert_eq!(fast, slow, "{camera} {yaw} {pitch} {distance}");
assert_eq!(fast, slow, "{camera} {yaw} {pitch} {radius}");
}
}
}
@@ -356,7 +358,7 @@ mod tests {
let t = Instant::now();
keys.clear();
keys.extend(map.keys().filter_map(|&k| {
in_view(k, camera, 512.0, &frustum).map(|(d, o)| (k, d, o.to_array()))
in_view(k, camera, 32, &frustum).map(|(d, o)| (k, d, o.to_array()))
}));
keys.sort_unstable_by(|a, b| a.1.total_cmp(&b.1));
for (k, _, _) in &keys {
@@ -365,7 +367,7 @@ mod tests {
old = old.min(t.elapsed());
let t = Instant::now();
list.clear();
r.visible(camera, 512.0, &frustum, |_| true, &mut list);
r.visible(camera, 32, &frustum, |_| true, &mut list);
for v in &list {
sum += i64::from(r.get(v.slot)[1] + r.get(v.slot)[0]);
}
+254 -61
View File
@@ -139,19 +139,74 @@ impl HudAtlas {
(g.rect, g.advance)
}
pub fn build(root: &Path) -> Result<Self> {
Self::pack(
root,
&[
"gui",
"item",
"block",
"font",
"environment",
"misc",
"painting",
"entity",
"particle",
"mob_effect",
"map",
],
true,
)
}
/// Empty slots written at run time: map textures (game/maps.rs), the
/// minimap, downloaded skins, world icons and the Horizon menu text.
fn slots(images: &mut Vec<PackedImage>) {
for i in 0..MAP_SLOTS {
images.push((format!("horizon/map{i}"), 128, 128, vec![0; 128 * 128 * 4]));
}
// The minimap extra's image (game/extras.rs).
images.push((
MINIMAP_SPRITE.into(),
crate::minimap::SIZE as u32,
crate::minimap::SIZE as u32,
vec![0; crate::minimap::SIZE * crate::minimap::SIZE * 4],
));
// Downloaded skins (game/scoreboard.rs).
for i in 0..SKIN_SLOTS {
images.push((format!("horizon/skin{i}"), 64, 64, vec![0; 64 * 64 * 4]));
}
for i in 0..WORLD_ICON_SLOTS {
images.push((
format!("horizon/world-icon{i}"),
64,
64,
vec![0; 64 * 64 * 4],
));
}
// Horizon-style menu text and corner masks (ui_theme), rasterized at run time.
images.push((
"horizon/ui-text".into(),
2048,
1024,
vec![0; 2048 * 1024 * 4],
));
}
/// Only the font's metrics, for a game that draws nothing (the
/// integrated server): text measures as with the full atlas, without
/// holding its textures. The pixels are dropped once the glyph widths are
/// read, since nothing uploads them.
pub fn fonts(root: &Path) -> Result<Self> {
let mut atlas = Self::pack(root, &["font"], false)?;
atlas.pixels = Vec::new();
Ok(atlas)
}
/// Pack the textures under these folders of `textures/`, and for the
/// `full` atlas the generated sprites and the run-time slots too.
fn pack(root: &Path, folders: &[&str], full: bool) -> Result<Self> {
let textures = root.join("assets/minecraft/textures");
let mut files = Vec::new();
walk(&textures.join("gui"), &mut files);
walk(&textures.join("item"), &mut files);
walk(&textures.join("block"), &mut files);
walk(&textures.join("font"), &mut files);
walk(&textures.join("environment"), &mut files);
walk(&textures.join("misc"), &mut files);
walk(&textures.join("painting"), &mut files);
walk(&textures.join("entity"), &mut files);
walk(&textures.join("particle"), &mut files);
walk(&textures.join("mob_effect"), &mut files);
walk(&textures.join("map"), &mut files);
for folder in folders {
walk(&textures.join(folder), &mut files);
}
files.retain(|p| {
let s = p.to_string_lossy();
!s.contains("title/background") && !s.contains("realms") && !s.contains("presets")
@@ -187,7 +242,9 @@ impl HudAtlas {
.flat_map(|h| h.join().unwrap_or_default())
.collect()
});
images.extend(atlas_sprites(root, &images));
if full {
images.extend(atlas_sprites(root, &images));
}
// The title screen's "JAVA EDITION" banner reads "RUST EDITION".
if let Some(edition) = images
.iter_mut()
@@ -198,36 +255,9 @@ impl HudAtlas {
edition.3 = pixels;
}
images.push(("horizon/white".into(), 4, 4, vec![255; 64]));
// Map textures (game/maps.rs) are written into these slots at run time.
for i in 0..MAP_SLOTS {
images.push((format!("horizon/map{i}"), 128, 128, vec![0; 128 * 128 * 4]));
if full {
Self::slots(&mut images);
}
// The minimap extra's image (game/extras.rs).
images.push((
MINIMAP_SPRITE.into(),
crate::minimap::SIZE as u32,
crate::minimap::SIZE as u32,
vec![0; crate::minimap::SIZE * crate::minimap::SIZE * 4],
));
// Downloaded skins (game/scoreboard.rs) likewise.
for i in 0..SKIN_SLOTS {
images.push((format!("horizon/skin{i}"), 64, 64, vec![0; 64 * 64 * 4]));
}
for i in 0..WORLD_ICON_SLOTS {
images.push((
format!("horizon/world-icon{i}"),
64,
64,
vec![0; 64 * 64 * 4],
));
}
// Horizon-style menu text and corner masks (ui_theme), rasterized at run time.
images.push((
"horizon/ui-text".into(),
2048,
1024,
vec![0; 2048 * 1024 * 4],
));
images.sort_by(|a, b| b.2.cmp(&a.2).then(b.1.cmp(&a.1)));
let width = 4096u32;
let mut placements = Vec::with_capacity(images.len());
@@ -319,6 +349,7 @@ pub struct HudVertex {
pub pos: [f32; 2],
pub uv: [f32; 2],
pub color: u32,
pub depth: f32,
}
/// The GUI Scale option (0 = auto).
pub static GUI_SCALE: std::sync::atomic::AtomicU32 = std::sync::atomic::AtomicU32::new(0);
@@ -330,10 +361,10 @@ pub struct HudBatch {
pub height: f32,
/// Glyph pixels to upload into the atlas before drawing.
pub patches: Vec<crate::font::Patch>,
/// Vertex ranges drawn with another blend than alpha blending, in order.
/// Vertex ranges with another blend or depth/scissor state, in order.
pub blends: Vec<(std::ops::Range<u32>, Blend)>,
}
/// How a run of HUD vertices blends with what is under it.
/// How a run of HUD vertices blends and tests depth.
#[derive(Clone, Copy, PartialEq, Eq, Debug)]
pub enum Blend {
/// `BlendFunction.TRANSLUCENT`.
@@ -342,6 +373,8 @@ pub enum Blend {
Invert,
/// `BlendFunction.ADDITIVE` (`RenderPipelines.GUI_TEXT_HIGHLIGHT`).
Additive,
/// Alpha blending with an isolated depth buffer and a pixel scissor.
Depth([u32; 4]),
}
pub fn rgba(r: u8, g: u8, b: u8, a: u8) -> u32 {
u32::from(a) << 24 | u32::from(b) << 16 | u32::from(g) << 8 | u32::from(r)
@@ -430,9 +463,44 @@ impl HudBatch {
pos: p[i],
uv: uv[i],
color,
depth: 0.0,
});
}
}
pub fn quad_3d(&mut self, p: [[f32; 3]; 4], uv: [[f32; 2]; 4], color: u32) {
for i in [0, 1, 2, 0, 2, 3] {
self.vertices.push(HudVertex {
pos: [p[i][0], p[i][1]],
uv: uv[i],
color,
depth: p[i][2],
});
}
}
/// Keep per-vertex depth for an orthographic GUI model, with +z toward the viewer.
pub fn depth_since(&mut self, start: usize, clip: [f32; 4]) {
let vertices = &mut self.vertices[start..];
if vertices.is_empty() {
return;
}
let min = vertices
.iter()
.map(|v| v.depth)
.fold(f32::INFINITY, f32::min);
let max = vertices
.iter()
.map(|v| v.depth)
.fold(f32::NEG_INFINITY, f32::max);
for v in vertices {
v.depth = (max - v.depth) / (max - min).max(f32::EPSILON);
}
let [x0, y0, x1, y1] = clip.map(|v| (v * self.scale).max(0.0) as u32);
// Separate previews clear depth independently, even if their scissors match.
self.blends.push((
start as u32..self.vertices.len() as u32,
Blend::Depth([x0, y0, x1.saturating_sub(x0), y1.saturating_sub(y0)]),
));
}
pub fn rect_uv(&mut self, x: f32, y: f32, w: f32, h: f32, r: Rect, color: u32) {
self.quad(
[[x, y], [x + w, y], [x + w, y + h], [x, y + h]],
@@ -569,6 +637,7 @@ impl HudBatch {
pos: p[i],
uv,
color: c[i],
depth: 0.0,
});
}
}
@@ -729,6 +798,7 @@ pub struct HudRenderer {
/// `RenderPipelines.CROSSHAIR`.
invert_pipeline: wgpu::RenderPipeline,
additive_pipeline: wgpu::RenderPipeline,
depth_pipeline: wgpu::RenderPipeline,
group: wgpu::BindGroup,
uniform: wgpu::Buffer,
buffer: wgpu::Buffer,
@@ -808,8 +878,8 @@ impl HudRenderer {
bind_group_layouts: &[Some(&layout)],
..Default::default()
});
let attributes = wgpu::vertex_attr_array![0=>Float32x2,1=>Float32x2,2=>Unorm8x4];
let create = |label, blend, fragment_entry| {
let attributes = wgpu::vertex_attr_array![0=>Float32x2,1=>Float32x2,2=>Unorm8x4,3=>Float32];
let create = |label, blend, fragment_entry, depth: bool| {
device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
label: Some(label),
layout: Some(&pipeline_layout),
@@ -824,7 +894,13 @@ impl HudRenderer {
})],
},
primitive: Default::default(),
depth_stencil: None,
depth_stencil: depth.then_some(wgpu::DepthStencilState {
format: wgpu::TextureFormat::Depth32Float,
depth_write_enabled: Some(true),
depth_compare: Some(wgpu::CompareFunction::LessEqual),
stencil: Default::default(),
bias: Default::default(),
}),
multisample: Default::default(),
fragment: Some(wgpu::FragmentState {
module: &shader,
@@ -840,7 +916,13 @@ impl HudRenderer {
cache: None,
})
};
let pipeline = create("HUD", wgpu::BlendState::ALPHA_BLENDING, "fs_main");
let pipeline = create("HUD", wgpu::BlendState::ALPHA_BLENDING, "fs_main", false);
let depth_pipeline = create(
"HUD model",
wgpu::BlendState::ALPHA_BLENDING,
"fs_main",
true,
);
// BlendFunction.INVERT: ONE_MINUS_DST_COLOR, ONE_MINUS_SRC_COLOR,
// ONE, ZERO.
let invert_pipeline = create(
@@ -858,6 +940,7 @@ impl HudRenderer {
},
},
"fs_crosshair",
false,
);
// BlendFunction.ADDITIVE: ONE, ONE.
let add = wgpu::BlendComponent {
@@ -872,6 +955,7 @@ impl HudRenderer {
alpha: add,
},
"fs_main",
false,
);
let capacity = 1 << 16;
let buffer = device.create_buffer(&wgpu::BufferDescriptor {
@@ -886,6 +970,7 @@ impl HudRenderer {
pipeline,
invert_pipeline,
additive_pipeline,
depth_pipeline,
group,
uniform,
buffer,
@@ -935,6 +1020,7 @@ impl HudRenderer {
uploads: &mut crate::gfx::upload::Uploads,
encoder: &mut wgpu::CommandEncoder,
target: &wgpu::TextureView,
depth: &wgpu::TextureView,
batch: &HudBatch,
size: [u32; 2],
) {
@@ -965,7 +1051,7 @@ impl HudRenderer {
);
}
}
if batch.vertices.is_empty() {
if batch.vertices.is_empty() || size.contains(&0) {
return;
}
let count = batch.vertices.len() as u64;
@@ -1001,20 +1087,55 @@ impl HudRenderer {
store: wgpu::StoreOp::Store,
},
})];
let mut pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
label: Some("HUD"),
color_attachments: &attachments,
..Default::default()
});
pass.set_bind_group(0, &self.group, &[]);
pass.set_vertex_buffer(0, self.buffer.slice(..));
for (range, blend) in batch.runs() {
pass.set_pipeline(match blend {
Blend::Alpha => &self.pipeline,
Blend::Invert => &self.invert_pipeline,
Blend::Additive => &self.additive_pipeline,
let runs = batch.runs();
let mut at = 0;
while at < runs.len() {
let clip = match runs[at].1 {
Blend::Depth(clip) => Some(clip),
_ => None,
};
let end = if clip.is_some() {
at + 1
} else {
runs[at..]
.iter()
.position(|(_, b)| matches!(b, Blend::Depth(_)))
.map_or(runs.len(), |n| at + n)
};
let mut pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
label: Some("HUD"),
color_attachments: &attachments,
depth_stencil_attachment: clip.map(|_| wgpu::RenderPassDepthStencilAttachment {
view: depth,
depth_ops: Some(wgpu::Operations {
load: wgpu::LoadOp::Clear(1.0),
store: wgpu::StoreOp::Discard,
}),
stencil_ops: None,
}),
..Default::default()
});
pass.draw(range, 0..1);
pass.set_bind_group(0, &self.group, &[]);
pass.set_vertex_buffer(0, self.buffer.slice(..));
if let Some([x, y, w, h]) = clip {
let (x, y) = (x.min(size[0]), y.min(size[1]));
let (w, h) = (w.min(size[0] - x), h.min(size[1] - y));
if w == 0 || h == 0 {
at = end;
continue;
}
pass.set_scissor_rect(x, y, w, h);
}
for (range, blend) in &runs[at..end] {
pass.set_pipeline(match blend {
Blend::Alpha => &self.pipeline,
Blend::Invert => &self.invert_pipeline,
Blend::Additive => &self.additive_pipeline,
Blend::Depth(_) => &self.depth_pipeline,
});
pass.draw(range.clone(), 0..1);
}
at = end;
}
}
}
@@ -1023,6 +1144,43 @@ impl HudRenderer {
mod tests {
use super::*;
#[test]
fn the_fonts_only_atlas_measures_text_like_the_full_one() {
// A synthetic default font: two 8x8 glyphs, 3 and 5 pixels wide.
let root = std::env::temp_dir().join(format!("horizon-fonts-atlas-{}", std::process::id()));
let font = root.join("assets/minecraft/font");
let textures = root.join("assets/minecraft/textures/font");
fs::create_dir_all(&font).unwrap();
fs::create_dir_all(&textures).unwrap();
fs::write(
font.join("default.json"),
r#"{"providers":[{"type":"bitmap","file":"minecraft:font/test.png","ascent":7,"chars":["ab"]}]}"#,
)
.unwrap();
let mut pixels = vec![0u8; 16 * 8 * 4];
for y in 0..8 {
for x in (0..3).chain(8..13) {
pixels[(y * 16 + x) * 4 + 3] = 255;
}
}
let mut encoder =
png::Encoder::new(fs::File::create(textures.join("test.png")).unwrap(), 16, 8);
encoder.set_color(png::ColorType::Rgba);
encoder.set_depth(png::BitDepth::Eight);
encoder
.write_header()
.unwrap()
.write_image_data(&pixels)
.unwrap();
let full = HudAtlas::build(&root).unwrap();
let fonts = HudAtlas::fonts(&root).unwrap();
let _ = fs::remove_dir_all(&root);
assert!(fonts.pixels.is_empty());
let width = full.font.width("abba");
assert!(width > 0.0);
assert_eq!(fonts.font.width("abba"), width);
}
#[test]
fn effect_icons_are_painted_from_the_mob_effect_directory() {
use crate::{effects::EffectInstance, hud_layout, hud_overlays, inventory_effects};
@@ -1092,6 +1250,41 @@ mod tests {
fs::remove_dir_all(root).unwrap();
}
#[test]
fn gui_models_keep_separate_depth_runs_between_overlay_draws() {
let mut batch = HudBatch::new([640, 480]);
batch.scale = 2.0;
let p = [
[0.0, 0.0, 2.0],
[0.0, 1.0, 2.0],
[1.0, 1.0, 2.0],
[1.0, 0.0, 2.0],
];
let uv = [[0.0; 2]; 4];
batch.quad([[0.0; 2]; 4], uv, u32::MAX);
for _ in 0..2 {
let start = batch.vertices.len();
batch.quad_3d(p, uv, u32::MAX);
batch.depth_since(start, [1.0, 2.0, 4.0, 6.0]);
}
batch.quad([[0.0; 2]; 4], uv, u32::MAX);
assert_eq!(
batch.runs(),
vec![
(0..6, Blend::Alpha),
(6..12, Blend::Depth([2, 4, 6, 8])),
(12..18, Blend::Depth([2, 4, 6, 8])),
(18..24, Blend::Alpha),
]
);
assert!(
batch
.vertices
.iter()
.all(|v| v.depth.is_finite() && (0.0..=1.0).contains(&v.depth))
);
}
#[test]
fn hud_shader_validates_both_fragment_entries() {
let module = naga::front::wgsl::parse_str(include_str!("hud.wgsl")).unwrap();
+2 -2
View File
@@ -7,10 +7,10 @@ struct Out {
@location(0) uv: vec2<f32>,
@location(1) color: vec4<f32>,
}
@vertex fn vs_main(@location(0) pos: vec2<f32>, @location(1) uv: vec2<f32>, @location(2) color: vec4<f32>) -> Out {
@vertex fn vs_main(@location(0) pos: vec2<f32>, @location(1) uv: vec2<f32>, @location(2) color: vec4<f32>, @location(3) depth: f32) -> Out {
let pixels = pos * hud.size.z;
var out: Out;
out.clip = vec4(pixels.x / hud.size.x * 2.0 - 1.0, 1.0 - pixels.y / hud.size.y * 2.0, 0.0, 1.0);
out.clip = vec4(pixels.x / hud.size.x * 2.0 - 1.0, 1.0 - pixels.y / hud.size.y * 2.0, depth, 1.0);
out.uv = uv;
out.color = color;
return out;
+42
View File
@@ -102,6 +102,10 @@ pub fn name_line(stack: &ItemStack, translate: &dyn Fn(&str) -> Option<String>)
if let Some(name) = stack.custom_name() {
return name.to_owned();
}
if stack.data().is_some_and(|d| d.ominous_banner) {
return translate("block.minecraft.ominous_banner")
.unwrap_or_else(|| "Ominous Banner".to_owned());
}
let key = if is_potion_item(&stack.item) {
Some(crate::brewing::potion_name_key(&stack.item, stack.potion()))
} else if let Some(pattern) = path.strip_suffix("_armor_trim_smithing_template") {
@@ -120,6 +124,24 @@ pub fn name_line(stack: &ItemStack, translate: &dyn Fn(&str) -> Option<String>)
.unwrap_or_else(|| path.replace('_', " "))
}
/// ItemStack.getRarity: the ominous banner override, then the enchantment upgrade.
pub fn rarity<'a>(stack: &ItemStack, default: &'a str) -> &'a str {
let rarity = if stack.data().is_some_and(|d| d.ominous_banner) {
"uncommon"
} else {
default
};
if stack.enchantments().is_empty() {
rarity
} else {
match rarity {
"common" | "uncommon" => "rare",
"rare" => "epic",
r => r,
}
}
}
/// The lines of `stack` below its name that its components give, in
/// `ItemStack.addDetailsToTooltip` order.
pub fn detail_lines(
@@ -292,6 +314,26 @@ pub fn lines(
mod tests {
use super::*;
#[test]
fn ominous_banner_name_and_rarity_use_the_stack() {
let translate = |key: &str| match key {
"block.minecraft.ominous_banner" => Some("Ominous Banner".to_owned()),
"block.minecraft.white_banner" => Some("White Banner".to_owned()),
_ => None,
};
let mut banner = crate::mobs::raider::ominous_banner();
assert_eq!(name_line(&banner, &translate), "Ominous Banner");
assert_eq!(name_line(&banner, &|_| None), "Ominous Banner");
assert_eq!(rarity(&banner, "common"), "uncommon");
banner.data_mut().custom_name = Some("Captain's Standard".into());
assert_eq!(name_line(&banner, &translate), "Captain's Standard");
banner.enchant("minecraft:unbreaking", 1);
assert_eq!(rarity(&banner, "common"), "rare");
let plain = ItemStack::new("minecraft:white_banner", 1);
assert_eq!(name_line(&plain, &translate), "White Banner");
assert_eq!(rarity(&plain, "common"), "common");
}
#[test]
fn container_lines_list_five_stacks_then_how_many_more() {
let mut chest = ItemStack::new("minecraft:chest", 1);
+14 -6
View File
@@ -274,16 +274,20 @@ pub(crate) fn load_tags(root: &Path, kind: &str) -> Result<HashMap<String, HashS
}
/// Every tag's contents in `TagLoader.tryBuildTag` order (a `LinkedHashSet`).
pub(crate) fn load_tag_lists(root: &Path, kind: &str) -> Result<HashMap<String, Vec<String>>> {
let dir = root.join(format!("data/minecraft/tags/{kind}"));
let mut raw: HashMap<String, Vec<String>> = HashMap::new();
fn walk(dir: &Path, base: &Path, raw: &mut HashMap<String, Vec<String>>) -> Result<()> {
fn walk(
dir: &Path,
base: &Path,
namespace: &str,
raw: &mut HashMap<String, Vec<String>>,
) -> Result<()> {
for entry in fs::read_dir(dir)?.flatten() {
let p = entry.path();
if p.is_dir() {
walk(&p, base, raw)?;
walk(&p, base, namespace, raw)?;
} else if p.extension().is_some_and(|e| e == "json") {
let name = format!(
"minecraft:{}",
"{namespace}:{}",
p.strip_prefix(base)?
.with_extension("")
.to_string_lossy()
@@ -301,8 +305,12 @@ pub(crate) fn load_tag_lists(root: &Path, kind: &str) -> Result<HashMap<String,
}
Ok(())
}
if dir.exists() {
walk(&dir, &dir, &mut raw)?;
// Vanilla's tags; with content mods also the convention (`c`) tags and the mods' own.
for namespace in crate::mod_content::tag_namespaces(root) {
let dir = root.join(format!("data/{namespace}/tags/{kind}"));
if dir.exists() {
walk(&dir, &dir, &namespace, &mut raw)?;
}
}
fn resolve(name: &str, raw: &HashMap<String, Vec<String>>, out: &mut Vec<String>, depth: u32) {
if depth > 32 {
+49
View File
@@ -373,11 +373,60 @@ impl KeyBinds {
}
Some(Err(button))
}
/// `AbstractContainerScreen.checkHotbarMouseClicked`: off hand, then hotbar.
pub fn container_mouse_key(&self, button: MouseButton, creative: bool) -> Option<KeyCode> {
let name = mouse_name(button);
if matches!(button, MouseButton::Left | MouseButton::Right)
|| (creative && self.get("key.pickItem") == name)
{
return None;
}
std::iter::once("key.swapOffhand")
.chain(
MAPPINGS
.iter()
.map(|m| m.0)
.filter(|n| n.starts_with("key.hotbar.")),
)
.find(|mapping| self.get(mapping) == name)
.and_then(|mapping| key_code(Self::default_of(mapping)))
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn container_mouse_hotkeys_follow_slot_bindings_and_pick_item_priority() {
for button in [MouseButton::Back, MouseButton::Forward, MouseButton::Middle] {
for (mapping, default, _) in MAPPINGS.iter().filter(|m| m.0.starts_with("key.hotbar."))
{
let mut keys = KeyBinds::default();
keys.set(mapping, &mouse_name(button));
assert_eq!(keys.container_mouse_key(button, false), key_code(default));
assert_eq!(
keys.container_mouse_key(button, true),
if button == MouseButton::Middle {
None
} else {
key_code(default)
}
);
}
}
let mut keys = KeyBinds::default();
keys.set("key.hotbar.1", "key.mouse.4");
keys.set("key.swapOffhand", "key.mouse.4");
assert_eq!(
keys.container_mouse_key(MouseButton::Back, false),
Some(KeyCode::KeyF)
);
keys.set("key.hotbar.2", "key.mouse.left");
assert_eq!(keys.container_mouse_key(MouseButton::Left, false), None);
assert_eq!(keys.container_mouse_key(MouseButton::Right, false), None);
assert_eq!(keys.container_mouse_key(MouseButton::Forward, false), None);
}
#[test]
fn rebinding_translates_to_defaults() {
let mut k = KeyBinds::default();
+2 -1
View File
@@ -361,8 +361,9 @@ fn login_and_configure(
name: &str,
) -> Result<Option<Parts>, String> {
let e = |e: horizon_protocol::Error| e.to_string();
// ServerLoginPacketListenerImpl: memory connections are not compressed.
let threshold = shared.config.compression_threshold;
if threshold >= 0 {
if threshold >= 0 && !c.is_memory() {
c.send(&login::Clientbound::Compression(login::Compression { threshold }).encode())
.map_err(e)?;
c.set_compression(threshold);
+18
View File
@@ -18,6 +18,16 @@ pub const CREATIVE: i32 = 1;
pub const ADVENTURE: i32 = 2;
pub const SPECTATOR: i32 = 3;
/// An effect as last sent in ClientboundUpdateMobEffectPacket.
#[derive(Clone, Debug, PartialEq)]
pub struct SentEffect {
pub id: &'static str,
pub amplifier: i32,
pub flags: i8,
pub duration: i32,
pub tick_count: i32,
}
pub struct Guest {
pub conn: u32,
/// The client's address (IP bans, `list`).
@@ -92,6 +102,12 @@ pub struct Guest {
pub xp_level: i32,
pub xp_progress: f32,
pub xp_total: i32,
/// Active status effects (`LivingEntity.activeEffects`).
pub effects: crate::effects::PlayerEffects,
/// What the client was told of each effect: id, amplifier, flags, and
/// the duration and `effects.tick_count` at the time, so a duration that
/// only counted down is not sent again (`ServerPlayer.onEffectUpdated`).
pub sent_effects: Vec<SentEffect>,
/// What the client believes the inventory menu holds (for change detection).
pub menu_sent: Vec<Option<ItemStack>>,
pub menu_state: i32,
@@ -176,6 +192,8 @@ impl Guest {
xp_level: 0,
xp_progress: 0.0,
xp_total: 0,
effects: Default::default(),
sent_effects: Vec::new(),
menu_sent: vec![None; 46],
menu_state: 0,
sent_health: None,
+123 -4
View File
@@ -9,9 +9,13 @@ use super::{
chunks::ChunkEncoder,
data::SyncData,
entity::EntityState,
guest::{Guest, stack_to_network},
guest::{Guest, SentEffect, stack_to_network},
};
use crate::{
effects::{EffectInstance, PlayerEffects},
items::ItemStack,
world::World,
};
use crate::{items::ItemStack, world::World};
use horizon_protocol::ids::play::clientbound as ids;
use horizon_protocol::{
entity_data::{Value, serializer},
@@ -44,6 +48,10 @@ pub struct HubConfig {
pub max_players: usize,
/// A dedicated server: operators from `ops`, the dedicated-only commands.
pub dedicated: bool,
/// An integrated server (`dedicated` too, since it has no host player):
/// the owner's level from `ops`, the others' from Allow Commands and
/// the guests' command access, and the integrated-only commands.
pub integrated: bool,
}
/// The host player as the other players see them.
@@ -441,7 +449,11 @@ impl Hub {
/// (IntegratedServer.setGuestCommandAccess); a dedicated server its
/// operators' level (`ops`).
fn default_permission(&self, uuid: u128) -> u8 {
if self.config.dedicated {
if self.config.integrated {
// IntegratedServer.getProfilePermissions / getCustomPermissionLevel.
let guests = if self.config.guest_commands { 2 } else { 0 };
self.ops.get(&uuid).copied().unwrap_or(guests)
} else if self.config.dedicated {
self.ops.get(&uuid).copied().unwrap_or(0)
} else if self.config.guest_commands {
2
@@ -553,11 +565,106 @@ impl Hub {
}));
g.center_sent = Some((cx, cz));
g.placed_at = self.ticks;
self.send_active_effects(i);
// ServerPlayer.sendPostEffects and initInventoryMenu.
self.guests[i].send(&raw(ids::POST_EFFECTS, vec![0]));
self.send_inventory(i);
}
/// ClientboundUpdateMobEffectPacket for one of the guest's effects.
fn send_effect(&mut self, i: usize, e: &EffectInstance, blend: bool) -> Option<SentEffect> {
let effect = self
.sync
.id("minecraft:mob_effect", &format!("minecraft:{}", e.id))?;
let flags = PlayerEffects::flags(e);
let g = &self.guests[i];
g.send(&C::UpdateMobEffect(play::UpdateMobEffect {
id: g.entity_id,
effect,
amplifier: e.amplifier,
duration: e.duration,
flags: flags | if blend { 8 } else { 0 },
}));
Some(SentEffect {
id: e.id,
amplifier: e.amplifier,
flags,
duration: e.duration,
tick_count: g.effects.tick_count,
})
}
/// PlayerList.sendActivePlayerEffects: every effect, unblended, when the
/// player is placed (or respawns).
pub fn send_active_effects(&mut self, i: usize) {
let effects = self.guests[i].effects.list.clone();
let sent = effects
.iter()
.filter_map(|e| self.send_effect(i, e, false))
.collect();
self.guests[i].sent_effects = sent;
}
/// ServerPlayer.onEffectAdded (blended), onEffectUpdated and
/// onEffectsRemoved, from what changed since the client was told: an
/// effect that only counted down is not sent again, except at every
/// 600 ticks left (`LivingEntity.tickEffects`).
fn sync_effects(&mut self, i: usize) {
let g = &self.guests[i];
if g.effects.list.is_empty() && g.sent_effects.is_empty() {
return;
}
let now = g.effects.tick_count;
let mut sent = Vec::with_capacity(g.effects.list.len());
let mut changes = Vec::new();
for e in &g.effects.list {
match g.sent_effects.iter().find(|s| s.id == e.id) {
None => changes.push((e.clone(), true)),
Some(s) => {
let ticked = now.wrapping_sub(s.tick_count);
let expected = if s.duration == -1 {
-1
} else {
s.duration - ticked
};
let refresh = ticked > 0 && e.duration > 0 && e.duration % 600 == 0;
if s.amplifier != e.amplifier
|| s.flags != PlayerEffects::flags(e)
|| e.duration != expected
|| refresh
{
changes.push((e.clone(), false));
} else {
sent.push(s.clone());
}
}
}
}
let removed: Vec<&'static str> = g
.sent_effects
.iter()
.filter(|s| g.effects.get(s.id).is_none())
.map(|s| s.id)
.collect();
for id in removed {
let Some(effect) = self
.sync
.id("minecraft:mob_effect", &format!("minecraft:{id}"))
else {
continue;
};
let g = &self.guests[i];
g.send(&C::RemoveMobEffect(play::RemoveMobEffect {
id: g.entity_id,
effect,
}));
}
for (e, added) in changes {
sent.extend(self.send_effect(i, &e, added));
}
self.guests[i].sent_effects = sent;
}
/// PlayerList.sendPlayerPermissionLevel: the op level as an entity event
/// (24 + level), then the commands that level may use.
fn send_permission_level(&self, i: usize) {
@@ -583,7 +690,10 @@ impl Hub {
fn send_commands(&self, i: usize) {
let g = &self.guests[i];
let packet = match &self.sync.commands {
Some(tree) => tree.packet(g.permission, self.config.dedicated, &self.sync.builtin),
Some(tree) => {
let dedicated = self.config.dedicated && !self.config.integrated;
tree.packet(g.permission, dedicated, &self.sync.builtin)
}
None => play::Commands {
nodes: vec![play::CommandNode {
kind: 0,
@@ -794,6 +904,7 @@ impl Hub {
for i in 0..self.guests.len() {
if self.guests[i].placed {
self.sync_player_state(i);
self.sync_effects(i);
}
}
let latencies: Vec<_> = self
@@ -1591,6 +1702,14 @@ impl Hub {
spawn: info,
keep: 0,
}));
// The respawned player is a new one, without effects; so is the
// client's (ClientPacketListener.handleRespawn).
g.effects = Default::default();
g.sent_effects.clear();
g.center = None;
g.sent_chunks.clear();
g.chunk_queue.clear();
g.tracker.clear();
self.teleport(i, None);
let spawn = self.default_spawn(ctx.spawn);
let g = &mut self.guests[i];
+75 -38
View File
@@ -310,6 +310,8 @@ pub struct Lan {
events: Receiver<NetEvent>,
pub port: u16,
listener: Option<JoinHandle<()>>,
/// Stops the accept loop alone: local connections stay.
listener_stop: Arc<AtomicBool>,
/// The multicast announcement (LanServerPinger); absent when the socket failed.
_pinger: Option<discovery::Pinger>,
}
@@ -325,26 +327,8 @@ impl Lan {
}
/// ServerConnectionListener.startTcpServerListener with a configuration.
pub fn start_with(sync: Arc<data::SyncData>, config: NetConfig) -> io::Result<Self> {
let listener = if config.listen {
let bind = config
.bind
.unwrap_or(std::net::IpAddr::V4(std::net::Ipv4Addr::UNSPECIFIED));
let listener = TcpListener::bind((bind, config.port))?;
listener.set_nonblocking(true)?;
Some(listener)
} else {
None
};
let port = match &listener {
Some(l) => l.local_addr()?.port(),
None => 0,
};
let _pinger = if config.announce && listener.is_some() {
discovery::Pinger::start(config.motd.clone(), port).ok()
} else {
None
};
let (tx, events) = channel();
let (listen, port, announce) = (config.listen, config.port, config.announce);
let shared = Arc::new(Shared {
sync,
events: tx,
@@ -357,21 +341,77 @@ impl Lan {
random: Mutex::new(crate::server::java_properties::now_millis() as u64 | 1),
config,
});
let accept_shared = shared.clone();
let listener = listener
.map(|listener| {
std::thread::Builder::new()
.name("horizon-lan-accept".into())
.spawn(move || accept_loop(listener, accept_shared))
})
.transpose()?;
Ok(Self {
let mut lan = Self {
shared,
events,
port,
listener,
_pinger,
})
port: 0,
listener: None,
listener_stop: Arc::new(AtomicBool::new(false)),
_pinger: None,
};
if listen {
lan.listen(port, announce)?;
}
Ok(lan)
}
/// Start accepting connections on `port` (0 picks a free one), and
/// announce the world on the local network when `announce`
/// (`IntegratedServer.publishServer`'s LanServerPinger). Returns the port.
pub fn listen(&mut self, port: u16, announce: bool) -> io::Result<u16> {
if self.listener.is_some() {
return Err(io::Error::new(
io::ErrorKind::AlreadyExists,
"already listening",
));
}
let listener = Self::bind(self.shared.config.bind, port)?;
self.listen_on(listener, announce)
}
/// The socket [`Lan::listen`] accepts on, bound ahead so that a failure
/// can be reported before the hub is at hand.
pub fn bind(address: Option<std::net::IpAddr>, port: u16) -> io::Result<TcpListener> {
let bind = address.unwrap_or(std::net::IpAddr::V4(std::net::Ipv4Addr::UNSPECIFIED));
let listener = TcpListener::bind((bind, port))?;
listener.set_nonblocking(true)?;
Ok(listener)
}
/// [`Lan::listen`] on a socket already bound.
pub fn listen_on(&mut self, listener: TcpListener, announce: bool) -> io::Result<u16> {
if self.listener.is_some() {
return Err(io::Error::new(
io::ErrorKind::AlreadyExists,
"already listening",
));
}
let port = listener.local_addr()?.port();
let stop = Arc::new(AtomicBool::new(false));
let (accept_shared, accept_stop) = (self.shared.clone(), stop.clone());
let thread = std::thread::Builder::new()
.name("horizon-lan-accept".into())
.spawn(move || accept_loop(listener, accept_shared, &accept_stop))?;
self._pinger = if announce {
discovery::Pinger::start(self.shared.motd(), port).ok()
} else {
None
};
self.listener = Some(thread);
self.listener_stop = stop;
self.port = port;
Ok(port)
}
/// Stop accepting connections and announcing; connections already in
/// (the local one included) stay.
pub fn stop_listening(&mut self) {
self.listener_stop.store(true, Ordering::Relaxed);
if let Some(t) = self.listener.take() {
let _ = t.join();
}
self._pinger = None;
self.port = 0;
}
/// Whether connections from the network are accepted.
pub fn listening(&self) -> bool {
self.listener.is_some()
}
/// `Connection.connectToLocalServer`: a connection through memory, its
/// server end served on its own thread like an accepted socket.
@@ -402,10 +442,7 @@ impl Lan {
}
pub fn stop(&mut self) {
self.shared.stop.store(true, Ordering::Relaxed);
if let Some(t) = self.listener.take() {
let _ = t.join();
}
self._pinger = None;
self.stop_listening();
}
}
impl Drop for Lan {
@@ -414,8 +451,8 @@ impl Drop for Lan {
}
}
fn accept_loop(listener: TcpListener, shared: Arc<Shared>) {
while !shared.stop.load(Ordering::Relaxed) {
fn accept_loop(listener: TcpListener, shared: Arc<Shared>, stop: &AtomicBool) {
while !shared.stop.load(Ordering::Relaxed) && !stop.load(Ordering::Relaxed) {
match listener.accept() {
Ok((stream, addr)) => {
let shared = shared.clone();
@@ -66,6 +66,7 @@ pub fn apply(guest: &mut Guest, level: &Level) {
guest.xp_level = level.xp_level;
guest.xp_progress = level.xp_progress;
guest.xp_total = level.xp_total;
guest.effects = crate::effects::PlayerEffects::from_saved(&level.active_effects);
guest.game_mode = level.mode();
guest.selected = (level.selected_slot.max(0) as usize).min(8);
guest.saved = level.player_extra.clone();
@@ -119,6 +120,7 @@ pub fn store(guest: &Guest, level: &mut Level) {
level.xp_level = guest.xp_level;
level.xp_progress = guest.xp_progress;
level.xp_total = guest.xp_total;
level.active_effects = guest.effects.saved();
level.game_mode = guest.game_mode;
level.creative = guest.game_mode == 1;
level.selected_slot = guest.selected as i32;
+1
View File
@@ -132,6 +132,7 @@ pub mod particles;
pub mod patrol;
pub mod perf_overlay;
pub mod pick_item;
pub mod poi_sections;
pub mod pose;
pub mod post;
pub mod projectiles;
+1 -1
View File
@@ -71,7 +71,7 @@ impl LightTables {
};
let data = nbt::read_named(
&std::fs::read(root.join("occlusion.nbt"))?,
Limits::default(),
Limits::tables(),
)?
.0
.tag;
+4
View File
@@ -847,6 +847,10 @@ fn red_overlay(m: &Mob) -> bool {
m.hurt_time > 0 || (m.death_time > 0 && !super::creaking::tearing_down(m))
}
fn species_scale(m: &Mob, alpha: f32) -> glam::Mat4 {
if m.kind.id == "minecraft:player" {
// AvatarRenderer.scale, shared by the inventory and world renderer.
return glam::Mat4::from_scale(glam::Vec3::splat(0.9375));
}
match m.species() {
Species::Wither => {
glam::Mat4::from_scale(glam::Vec3::splat(super::wither::scale(m, alpha)))
@@ -924,8 +924,35 @@ fn tickets(m: &Mob, w: &MobWorld, p: [i32; 3]) -> usize {
}
n
}
/// The POIs of chunk `(qx, qz)` from `y0` to `y1` (within the world), in
/// scan order: y, then z, then x. Only the indexed POI blocks of the sections
/// are visited (`PoiManager.getInChunk`).
fn chunk_pois(
w: &MobWorld,
(qx, qz): (i32, i32),
y0: i32,
y1: i32,
mut visit: impl FnMut(Poi, [i32; 3]),
) {
let Some(chunk) = w.world.chunks.get(&(qx, qz)) else {
return;
};
let kind = |state: u32| poi_of_state(w, horizon_world::registry::BlockStateId(state));
let min = crate::chunk::MIN_Y;
for s in (y0 - min) >> 4..=(y1 - min) >> 4 {
let section = &chunk.sections[s as usize];
for &(i, poi) in w.world.pois.get((qx, s, qz), section, kind).iter() {
let i = i32::from(i);
let y = min + s * 16 + (i >> 8);
if (y0..=y1).contains(&y) {
visit(poi, [qx * 16 + (i & 15), y, qz * 16 + (i >> 4 & 15)]);
}
}
}
}
/// `PoiManager.getInRange` with `HAS_SPACE`, nearest first (`distSqr` to the
/// block, ties in scan order), filtered by `accept`.
/// block, ties in scan order: chunk by chunk, z then x, and y, z, x within),
/// filtered by `accept`.
fn pois_in_range(
m: &Mob,
w: &MobWorld,
@@ -940,62 +967,24 @@ fn pois_in_range(
let chunks = radius.div_euclid(16) + 1;
let y0 = (c[1] - radius).max(crate::chunk::MIN_Y);
let y1 = (c[1] + radius).min(crate::chunk::MIN_Y + crate::chunk::HEIGHT - 1);
// Sections whose palette holds no POI state are skipped whole, as
// PoiManager only visits sections with records: the same positions in
// the same order, without reading and naming every block of the sphere.
let kind = |state: u32| poi_of_state(w, horizon_world::registry::BlockStateId(state));
for qz in cz - chunks..=cz + chunks {
for qx in cx - chunks..=cx + chunks {
let Some(chunk) = w.world.chunks.get(&(qx, qz)) else {
continue;
};
let holds: Vec<bool> = chunk
.sections
.iter()
.map(|s| s.blocks.maybe_has(|v| kind(v).is_some()))
.collect();
for y in y0..=y1 {
if !holds[((y - crate::chunk::MIN_Y) >> 4) as usize] {
continue;
chunk_pois(w, (qx, qz), y0, y1, |poi, p| {
if (p[0] - c[0]).abs() > radius
|| (p[2] - c[2]).abs() > radius
|| dist_sqr(p, c) > r2
|| !poi_matches(m, f, poi)
|| tickets(m, w, p) >= poi.max_tickets()
{
return;
}
for z in qz * 16..qz * 16 + 16 {
for x in qx * 16..qx * 16 + 16 {
if (x - c[0]).abs() > radius || (z - c[2]).abs() > radius {
continue;
}
let d = i64::from(x - c[0]).pow(2)
+ i64::from(y - c[1]).pow(2)
+ i64::from(z - c[2]).pow(2);
if d > r2 {
continue;
}
let state = chunk.block(x & 15, y, z & 15);
if w.facts.is_air(state) {
continue;
}
let Some(poi) = kind(state.0) else {
continue;
};
if !poi_matches(m, f, poi) {
continue;
}
let p = [x, y, z];
if tickets(m, w, p) >= poi.max_tickets() {
continue;
}
if accept(p) {
found.push((poi, p));
}
}
if accept(p) {
found.push((poi, p));
}
}
});
}
}
found.sort_by_key(|(_, p)| {
i64::from(p[0] - c[0]).pow(2)
+ i64::from(p[1] - c[1]).pow(2)
+ i64::from(p[2] - c[2]).pow(2)
});
found.sort_by_key(|&(_, p)| dist_sqr(p, c));
found
}
/// `PoiManager.exists(pos, predicate)`.
@@ -3389,26 +3378,23 @@ fn dist_sqr(a: [i32; 3], b: [i32; 3]) -> i64 {
manhattan_sq(a, b)
}
/// Every bed head within `radius` (`PoiManager.getInRange(HOME, ..., ANY)`),
/// in scan order.
/// in the order of a scan of the cube: y, then z, then x.
fn homes_in_range(m: &Mob, w: &MobWorld, radius: i32) -> Vec<[i32; 3]> {
let c = block_of(m.position);
let r2 = i64::from(radius) * i64::from(radius);
let mut out = Vec::new();
let y0 = (c[1] - radius).max(crate::chunk::MIN_Y);
let y1 = (c[1] + radius).min(crate::chunk::MIN_Y + crate::chunk::HEIGHT - 1);
for y in y0..=y1 {
for z in c[2] - radius..=c[2] + radius {
for x in c[0] - radius..=c[0] + radius {
let p = [x, y, z];
if dist_sqr(p, c) <= r2
&& w.world.loaded(x, z)
&& poi_at(w, x, y, z) == Some(Poi::Home)
{
for qz in (c[2] - radius) >> 4..=(c[2] + radius) >> 4 {
for qx in (c[0] - radius) >> 4..=(c[0] + radius) >> 4 {
chunk_pois(w, (qx, qz), y0, y1, |poi, p| {
if poi == Poi::Home && dist_sqr(p, c) <= r2 {
out.push(p);
}
}
});
}
}
out.sort_unstable_by_key(|p| (p[1], p[2], p[0]));
out
}
/// `MoveToSkySeeingSpot.hasNoBlocksAbove`.
+100 -2
View File
@@ -314,6 +314,22 @@ impl<'a> Plan<'a> {
});
}
}
if next > MAX_STATES {
let mut by_mod: BTreeMap<&str, u32> = BTreeMap::new();
for b in &blocks {
*by_mod
.entry(&b.decl.id[..b.decl.id.find(':').unwrap_or(0)])
.or_default() += b.rename.states.len() as u32;
}
let list: Vec<String> = by_mod.iter().map(|(m, n)| format!("{m} {n}")).collect();
return Err(format!(
"{next} block states, more than the {MAX_STATES} chunks can hold ({} in the game; \
the mods: {})",
names.len(),
list.join(", ")
)
.into());
}
// Block items copy the template block's item.
let gameplay = read_json(&base.join("gameplay-facts.json"))?;
let rows = match gameplay.get("states") {
@@ -628,6 +644,9 @@ const NBT_TABLES: [&str; 6] = [
/// In a root built here: the content mods' ids, the namespaces loaders
/// read besides `minecraft`.
const MARKER: &str = "horizon-mod-content.json";
/// Block states a world can hold: chunk sections store a state in 16 bits
/// (crate::chunk). Mods past it are refused, not wrapped onto other blocks.
pub const MAX_STATES: u32 = 1 << 16;
/// The content mods' namespaces in a root built by [`build`]; none in any
/// other root, so vanilla's loaders read exactly what they did.
@@ -638,6 +657,19 @@ pub fn namespaces(root: &Path) -> Vec<String> {
.unwrap_or_default()
}
/// The namespaces whose tags loaders read in `root`: `minecraft`, and in a
/// root built by [`build`] the convention tags (`c`, shared between mods as
/// on NeoForge and Fabric) and the content mods' own.
pub fn tag_namespaces(root: &Path) -> Vec<String> {
let mods = namespaces(root);
let mut out = vec!["minecraft".to_owned()];
if !mods.is_empty() {
out.push("c".to_owned());
out.extend(mods);
}
out
}
/// Bundles of block tag files (tag id → the tag file's text).
const TAG_BUNDLES: [&str; 2] = ["block-tags.json", "worldgen/block_tags.json"];
@@ -735,8 +767,67 @@ fn merge_tag(text: Option<&str>, more: &[J], what: &str) -> Result<String> {
Ok(serde_json::to_string_pretty(&doc)?)
}
/// The block and item ids and tags a content root has, for tag entries.
struct Known {
blocks: std::collections::BTreeSet<String>,
items: std::collections::BTreeSet<String>,
/// `data/<ns>/tags/<kind>/<path>.json` files the mods add.
tag_files: std::collections::BTreeSet<String>,
}
impl Known {
fn new(base: &Path, plan: &Plan, tags: &BTreeMap<String, Vec<J>>) -> Result<Self> {
let mut blocks: std::collections::BTreeSet<String> =
plan.defaults.keys().cloned().collect();
blocks.extend(plan.blocks.iter().map(|b| b.decl.id.clone()));
let mut items = std::collections::BTreeSet::new();
if let J::Obj(o) = read_json(&base.join("items.json"))? {
items.extend(o.into_iter().map(|(k, _)| k));
}
items.extend(plan.items.iter().map(|i| i.rename.to.clone()));
Ok(Known {
blocks,
items,
tag_files: tags.keys().cloned().collect(),
})
}
/// Whether tag `file` keeps entry `v`: a known id or an existing tag,
/// for block and item tags (other registries are kept as they are).
fn keeps(&self, file: &str, v: &J) -> bool {
let id = match v {
J::Str(s) => s.as_str(),
J::Obj(_) => match v.get("id") {
Some(J::Str(s)) => s.as_str(),
_ => return true,
},
_ => return true,
};
let Some(kind) = file
.strip_prefix("data/")
.and_then(|r| r.split_once("/tags/"))
.and_then(|(_, rest)| Some(rest.split_once('/')?.0))
else {
return true;
};
let ids = match kind {
"block" => &self.blocks,
"item" => &self.items,
_ => return true,
};
match id.strip_prefix('#') {
Some(tag) => {
let (tns, path) = tag.split_once(':').unwrap_or(("minecraft", tag));
let rel = format!("data/{tns}/tags/{kind}/{path}.json");
self.tag_files.contains(&rel) || tns == "minecraft"
}
None => ids.contains(id),
}
}
}
/// Builds the content root for `mods` over `base` in `out`.
pub fn build(base: &Path, mods: &[ContentMod], out: &Path) -> Result<()> {
// The overlay links to the base: a relative base would leave them dangling.
let base = &std::path::absolute(base)?;
let plan = Plan::new(base, mods)?;
let overlay = Overlay::new(base, out)?;
for name in JSON_TABLES {
@@ -754,11 +845,11 @@ pub fn build(base: &Path, mods: &[ContentMod], out: &Path) -> Result<()> {
if !path.exists() {
continue;
}
let (mut named, _) = nbt::read_named(&fs::read(&path)?, Limits::default())
let (mut named, _) = nbt::read_named(&fs::read(&path)?, Limits::tables())
.map_err(|e| format!("{name}: {e}"))?;
plan.nbt(&mut named.tag);
let bytes =
nbt::write_named(&named, Limits::default()).map_err(|e| format!("{name}: {e}"))?;
nbt::write_named(&named, Limits::tables()).map_err(|e| format!("{name}: {e}"))?;
overlay.write(name, &bytes)?;
}
// Mod files, and every tag addition gathered per tag file.
@@ -788,6 +879,13 @@ pub fn build(base: &Path, mods: &[ContentMod], out: &Path) -> Result<()> {
}
}
}
// A tag naming an id nobody registers fails as a whole in vanilla, and
// carried-over mods name blocks left out or other mods' ids: such
// entries are dropped instead, so the rest of the tag holds.
let known = Known::new(base, &plan, &tags)?;
for (file, values) in &mut tags {
values.retain(|v| known.keeps(file, v));
}
let mut bundles: Vec<(&str, J)> = Vec::new();
for name in TAG_BUNDLES {
if base.join(name).exists() {
+44 -4
View File
@@ -56,7 +56,7 @@ fn prepared() -> Option<PathBuf> {
/// A content mod folder: a full block, a door and an item-less glass from
/// templates, an item, a vanilla tag addition and a language file.
fn ruby_mod(dir: &Path) -> ContentMod {
let files: [(&str, &str); 7] = [
let files: [(&str, &str); 8] = [
(
"horizon-mod.toml",
"id = \"ruby\"\nname = \"Ruby\"\nversion = \"0.1.0\"\napi = \"0.2\"\nside = \"both\"\ncapabilities = [\"registries\"]\n",
@@ -78,9 +78,15 @@ fn ruby_mod(dir: &Path) -> ContentMod {
"data/ruby/horizon/item/ruby.json",
r#"{"template": "minecraft:diamond", "max_stack_size": 16, "rarity": "rare"}"#,
),
// Carried-over tags name blocks left out and other mods' ids too.
(
"data/minecraft/tags/block/mineable/pickaxe.json",
r#"{"values": ["ruby:ruby_block"]}"#,
r##"{"values": ["ruby:ruby_block", "ruby:left_out", "othermod:thing",
{"id": "othermod:optional", "required": false}, "#c:storage_blocks/ruby"]}"##,
),
(
"data/c/tags/item/gems/ruby.json",
r#"{"values": ["ruby:ruby", "othermod:ruby"]}"#,
),
(
"assets/ruby/lang/en_us.json",
@@ -110,7 +116,10 @@ fn content_root_loads_with_every_table() {
let scratch = std::env::temp_dir().join(format!("horizon-mod-content-{}", std::process::id()));
let _ = fs::remove_dir_all(&scratch);
let m = ruby_mod(&scratch.join("ruby"));
let root = resource_root(&base, std::slice::from_ref(&m), &scratch.join("cache")).unwrap();
// The base as a relative path (cargo runs tests in the crate's folder):
// the overlay's links still resolve.
let relative = Path::new("../../.local/horizon-client/26.3");
let root = resource_root(relative, std::slice::from_ref(&m), &scratch.join("cache")).unwrap();
assert_ne!(root, base);
let vanilla = Assets::load(&base).unwrap();
@@ -169,7 +178,12 @@ fn content_root_loads_with_every_table() {
let gem = &items.items["ruby:ruby"];
assert_eq!(gem.max_stack, 16);
assert!(!items.items.contains_key("ruby:ruby_glass"));
assert!(items.block_tags["minecraft:mineable/pickaxe"].contains("ruby:ruby_block"));
let pickaxe = &items.block_tags["minecraft:mineable/pickaxe"];
assert!(pickaxe.contains("ruby:ruby_block"));
assert!(!pickaxe.contains("ruby:left_out") && !pickaxe.contains("othermod:thing"));
assert!(pickaxe.contains("minecraft:stone"));
// Convention tags load, with the ids nobody registers dropped.
assert_eq!(items.item_tag_order["c:gems/ruby"], ["ruby:ruby"]);
crate::collisions::load(&root, new).unwrap();
crate::models::load_visibility(&root, new).unwrap();
@@ -206,6 +220,32 @@ fn refuses_unknown_templates_and_vanilla_ids() {
fs::remove_dir_all(&scratch).unwrap();
}
#[test]
fn refuses_more_states_than_chunks_hold() {
let Some(base) = prepared() else {
return;
};
let scratch = std::env::temp_dir().join(format!("horizon-mod-states-{}", std::process::id()));
let _ = fs::remove_dir_all(&scratch);
let mut m = ruby_mod(&scratch.join("ruby"));
// Redstone wire has 1296 states: 40 copies pass any game's 65536.
let mut wire = m.content.blocks[0].clone();
wire.template = "minecraft:redstone_wire".into();
for i in 0..40 {
let mut b = wire.clone();
b.id = format!("ruby:wire_{i}");
m.content.blocks.push(b);
}
let e = build(&base, std::slice::from_ref(&m), &scratch.join("out")).unwrap_err();
assert!(
e.to_string()
.contains("more than the 65536 chunks can hold"),
"{e}"
);
assert!(e.to_string().contains("the mods: ruby "), "{e}");
fs::remove_dir_all(&scratch).unwrap();
}
#[test]
fn no_content_keeps_the_base_root() {
let base = Path::new("/nonexistent/base");
+1 -1
View File
@@ -120,7 +120,7 @@ pub fn load_visibility(
nbt::{self, Limits},
};
use std::{collections::BTreeMap, fs};
let data = nbt::read_named(&fs::read(root.join("occlusion.nbt"))?, Limits::default())?
let data = nbt::read_named(&fs::read(root.join("occlusion.nbt"))?, Limits::tables())?
.0
.tag;
let occlusion = CachedCollisionRegistry::from_nbt(&data, registry)?;
@@ -34,6 +34,8 @@ pub struct BakedFace {
}
pub struct BakedModel {
pub ambient_occlusion: bool,
/// The model's particle slot also exists for models without block faces.
pub particle: Option<u32>,
pub faces: Vec<BakedFace>,
pub cube: Option<[super::cube::CubeStyle; 6]>,
}
@@ -190,6 +192,10 @@ impl StateModels {
let mut baked = BTreeMap::new();
for (name, turns, lock) in variants {
let model = library.resolve(&name)?;
let particle = model
.material("particle")?
.map(|material| sprites.insert(root, &material.sprite))
.transpose()?;
let faces: Vec<BakedFace> =
bake_block_model(&model, BlockModelTransform::new(turns, lock))?
.into_iter()
@@ -209,6 +215,7 @@ impl StateModels {
(name, turns, lock),
BakedModel {
ambient_occlusion: model.ambient_occlusion,
particle,
faces,
cube,
},
+1 -1
View File
@@ -63,7 +63,7 @@ impl MotionResources {
)?)?)?);
let data = nbt::read_named(
&fs::read(root.join("movement-properties.nbt"))?,
Limits::default(),
Limits::tables(),
)?
.0
.tag;
+42 -2
View File
@@ -29,6 +29,8 @@ use std::{
pub enum Event {
/// Progress text for the connecting screen.
Status(String),
/// The server's `minecraft:brand` custom payload.
Brand(String),
/// Configuration finished: the play state begins with these registries.
Joined {
registries: Arc<Dynamic>,
@@ -374,7 +376,7 @@ fn run(
.map_err(e)?;
let (mut reader, writer) = c.split();
*shared_writer.lock().unwrap() = Some(writer);
let registries = configure(&mut reader, shared_writer, lang)?;
let registries = configure(&mut reader, shared_writer, lang, send)?;
let _ = send.send(Event::Joined {
registries: Arc::new(registries),
uuid: profile.uuid,
@@ -413,10 +415,13 @@ fn run(
}
play::Clientbound::StartConfiguration(_) => {
reply(play::Serverbound::ConfigurationAcknowledged(Empty));
let registries = configure(&mut reader, shared_writer, lang)?;
let registries = configure(&mut reader, shared_writer, lang, send)?;
let _ = send.send(Event::Reconfigured(Arc::new(registries)));
}
play::Clientbound::Disconnect(d) => return Ok(plain(&d.reason, lang)),
play::Clientbound::CustomPayload(p) if p.channel == "minecraft:brand" => {
receive_brand(&p, send);
}
other => {
if send.send(Event::Packet(Box::new(other))).is_err() {
return Ok("Disconnected".into());
@@ -432,6 +437,7 @@ fn configure(
reader: &mut ConnReader,
writer: &Mutex<Option<ConnWriter>>,
lang: &Language,
send: &Sender<Event>,
) -> Result<Dynamic, String> {
let mut registries = Dynamic::default();
let reply = |p: cfg::Serverbound| -> Result<(), String> {
@@ -444,6 +450,7 @@ fn configure(
let (id, payload) = reader.recv().map_err(|e| e.to_string())?;
match cfg::Clientbound::decode(id, &payload).map_err(|e| e.to_string())? {
cfg::Clientbound::KeepAlive(k) => reply(cfg::Serverbound::KeepAlive(k))?,
cfg::Clientbound::CustomPayload(p) => receive_brand(&p, send),
cfg::Clientbound::Ping(p) => reply(cfg::Serverbound::Pong(p))?,
// Know no packs: the server then sends every registry entry in full.
cfg::Clientbound::SelectKnownPacks(_) => {
@@ -477,6 +484,14 @@ fn configure(
}
}
fn receive_brand(payload: &cfg::CustomPayload, send: &Sender<Event>) {
if payload.channel == "minecraft:brand"
&& let Ok(brand) = horizon_protocol::buf::Reader::new(&payload.data).string(32767)
{
let _ = send.send(Event::Brand(brand));
}
}
/// The minecraft:brand payload: a string naming the client.
fn brand() -> Vec<u8> {
let mut w = horizon_protocol::buf::Writer::new();
@@ -565,3 +580,28 @@ pub fn ping(address: &str, timeout: Duration) -> Result<(serde_json::Value, u128
let _ = c.recv().map_err(e)?;
Ok((json, start.elapsed().as_millis()))
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn server_brand_payload_is_decoded_and_invalid_or_unrelated_payloads_are_ignored() {
let (send, events) = channel();
let mut writer = horizon_protocol::buf::Writer::new();
writer.string("vanilla");
let mut payload = cfg::CustomPayload {
channel: "minecraft:brand".into(),
data: writer.data,
};
receive_brand(&payload, &send);
assert!(matches!(events.try_recv(), Ok(Event::Brand(brand)) if brand == "vanilla"));
payload.channel = "example:other".into();
receive_brand(&payload, &send);
assert!(events.try_recv().is_err());
payload.channel = "minecraft:brand".into();
payload.data = vec![0xff];
receive_brand(&payload, &send);
assert!(events.try_recv().is_err());
}
}
+9 -2
View File
@@ -587,9 +587,16 @@ impl OptionsUi {
}
return events;
}
// A click anywhere stops waiting for an extra's key.
// Rebinding consumes the click before sidebar or widget actions.
if matches!(self.selected_key, Some(extras::ZOOM_KEY | extras::SORT_KEY)) {
self.selected_key = None;
return self.bind_mouse(
s,
if right {
winit::event::MouseButton::Right
} else {
winit::event::MouseButton::Left
},
);
}
match self.horizon_target(s, atlas, x, y) {
Some(Target::Nav(i)) => {
+319 -13
View File
@@ -708,12 +708,14 @@ pub enum Page {
Language,
Font,
Packs,
Mods,
/// Horizon's graphics settings (`graphics_ui`).
Graphics,
GraphicsAdvanced,
/// Horizon's controller settings and button binds.
Controller,
PadBinds,
Extras,
}
#[derive(Clone, Debug, PartialEq)]
enum Act {
@@ -721,6 +723,7 @@ enum Act {
Push(Page),
Done,
Cycle(Opt),
Extra(crate::extras::Item),
Key(&'static str),
ResetKey(&'static str),
ResetKeys,
@@ -730,6 +733,7 @@ enum Act {
ResetPadKeys,
/// Back to Horizon's own menus (Horizon only, see `list_rows`).
HorizonMenus,
ToggleMod(usize),
}
enum WKind {
Button {
@@ -971,9 +975,11 @@ impl OptionsUi {
Page::Language => "options.language.title",
Page::Font => "options.font.title",
Page::Packs => "resourcePack.title",
Page::Mods => "Mods",
Page::Graphics | Page::GraphicsAdvanced => "options.videoTitle",
Page::Controller => "Controller Settings",
Page::PadBinds => "Controller Binds",
Page::Extras => "Horizon Extras",
}
}
fn scrollbar_x(&self, width: f32) -> f32 {
@@ -986,6 +992,22 @@ impl OptionsUi {
}
fn list_rows(&self, s: &Settings) -> Vec<Row> {
match self.page() {
Page::Extras => crate::extras::rows()
.into_iter()
.map(|row| match row {
Err(header) => Row::Header(header),
Ok(item) => {
let value = format!("{}: {}", item.caption(), item.value(&s.extras));
let label =
if item.key_name().is_some() && self.selected_key == item.key_name() {
Text::literal(format!("> {value} <")).with_color(text::YELLOW)
} else {
Text::literal(value)
};
Row::Buttons(button(0.0, 0.0, 310.0, label, Act::Extra(item)), None)
}
})
.collect(),
Page::Video => {
// Horizon's graphics screens, Simple and Advanced.
let mut rows = vec![Row::Buttons(
@@ -1161,6 +1183,36 @@ impl OptionsUi {
Opt::AutoJump,
]),
Page::Font => pairs(&[Opt::ForceUnicode, Opt::JapaneseGlyphs]),
Page::Mods => {
if s.mods.installed.is_empty() {
return vec![Row::Header(
"No mods: put .hmod files in the horizon-mods folder",
)];
}
s.mods
.installed
.iter()
.enumerate()
.map(|(i, installed)| {
let mut label = Text::literal(format!("{}: ", installed.title))
.append(on_off(s.mods.is_on(i)));
if installed.problem.is_some() {
label = label.append(" (Stopped)");
} else if installed.dev {
label = label.append(" (Dev)");
}
let widget = button(0.0, 0.0, 310.0, label, Act::ToggleMod(i));
Row::Buttons(
if installed.dev || installed.id.is_empty() {
inactive(widget)
} else {
widget
},
None,
)
})
.collect()
}
_ => {
let _ = s;
Vec::new()
@@ -1206,8 +1258,8 @@ impl OptionsUi {
("options.chat", Some(Page::Chat)),
("options.resourcepack", Some(Page::Packs)),
("options.accessibility", Some(Page::Accessibility)),
("options.telemetry", None),
("options.credits_and_attribution", None),
("Mods...", Some(Page::Mods)),
("Horizon Extras...", Some(Page::Extras)),
];
let gy = (61.0 + 30.0f32).min(h - 33.0 - 120.0);
for (i, (key, page)) in entries.iter().enumerate() {
@@ -1631,6 +1683,13 @@ impl OptionsUi {
let hover = ui::hovered(cursor, wd.x, wd.y, wd.w, wd.h)
&& (!wd.list || cursor.1 >= top && cursor.1 < bottom);
if hover {
if let WKind::Button {
act: Act::Extra(item),
..
} = &wd.kind
{
tooltip = Some(atlas.font.split(&Text::literal(item.description()), 170.0));
}
let key = match &wd.kind {
WKind::Button {
act: Act::Cycle(opt),
@@ -1650,6 +1709,21 @@ impl OptionsUi {
if let Some(key) = key.filter(|key| lang::has(key)) {
tooltip = Some(atlas.font.split(&tr(&key), 170.0));
}
if let WKind::Button {
act: Act::ToggleMod(i),
..
} = &wd.kind
&& let Some(installed) = s.mods.installed.get(*i)
{
let description = installed
.problem
.as_deref()
.unwrap_or(&installed.description);
tooltip = Some(atlas.font.split(
&Text::literal(format!("{}\n{description}", installed.title)),
170.0,
));
}
}
match &wd.kind {
WKind::Button { label, active, act } => {
@@ -1876,15 +1950,13 @@ impl OptionsUi {
return events;
}
// Key Binds: a mouse button pressed while waiting binds it.
if let Some(name) = self.selected_key.take() {
if self.selected_key.is_some() {
let button = if right {
"key.mouse.right"
winit::event::MouseButton::Right
} else {
"key.mouse.left"
winit::event::MouseButton::Left
};
s.keys.set(name, button);
events.push(Event::Changed);
return events;
return self.bind_mouse(s, button);
}
// AbstractWidget accepts only the primary button. Rebinding above
// accepts other mouse buttons, but is not a widget activation.
@@ -1919,6 +1991,14 @@ impl OptionsUi {
}
events.push(Event::Changed);
}
Act::Extra(item) => {
if let Some(name) = item.key_name() {
self.selected_key = Some(name);
} else {
item.cycle(&mut s.extras, right);
events.push(Event::Changed);
}
}
Act::Key(name) => self.selected_key = Some(name),
Act::ResetKey(name) => {
s.keys.set(name, KeyBinds::default_of(name));
@@ -1944,6 +2024,10 @@ impl OptionsUi {
crate::ui_theme::save_preferences(&dir);
}
}
Act::ToggleMod(i) => {
s.mods.toggle(i);
events.push(Event::Changed);
}
Act::None => {}
}
}
@@ -2126,6 +2210,23 @@ impl OptionsUi {
}
false
}
fn bind_key(&mut self, s: &mut Settings, value: String) -> Vec<Event> {
let Some(name) = self.selected_key.take() else {
return Vec::new();
};
if !s.extras.set_key(name, value.clone()) {
s.keys.set(name, &value);
}
vec![Event::Changed]
}
/// Mouse bindings use the same settings and persistence as keyboard bindings.
pub fn bind_mouse(
&mut self,
s: &mut Settings,
button: winit::event::MouseButton,
) -> Vec<Event> {
self.bind_key(s, keybinds::mouse_name(button))
}
/// Keys while the options are open. Returns events; `handled` false lets
/// Escape fall through.
pub fn key(
@@ -2160,7 +2261,7 @@ impl OptionsUi {
}
return vec![Event::Changed];
}
if let Some(name) = self.selected_key.take() {
if self.selected_key.is_some() {
// KeyBindsScreen.keyPressed: Escape unbinds.
let value = if key == K::Escape {
"key.keyboard.unknown".to_owned()
@@ -2169,10 +2270,7 @@ impl OptionsUi {
.unwrap_or("key.keyboard.unknown")
.to_owned()
};
if !s.extras.set_key(name, value.clone()) {
s.keys.set(name, &value);
}
return vec![Event::Changed];
return self.bind_key(s, value);
}
if key == K::Escape {
return self.back(s);
@@ -2201,6 +2299,88 @@ mod tests {
HudAtlas::build(std::path::Path::new("/nonexistent/horizon-test-assets")).unwrap()
}
#[test]
fn classic_mods_page_toggles_mods_and_keeps_dev_and_invalid_entries_inactive() {
let atlas = atlas();
let mut s = Settings::default();
let mut ui = OptionsUi::default();
let size = (480.0, 240.0);
assert!(ui.layout(&s, size.0, size.1).0.iter().any(|w| {
matches!(
w.kind,
WKind::Button {
active: true,
act: Act::Push(Page::Mods),
..
}
)
}));
ui.show(Page::Mods);
let empty = ui.layout(&s, size.0, size.1).0;
assert!(empty.iter().any(|w| {
matches!(&w.kind, WKind::Text { text, .. } if text.plain().contains(".hmod"))
}));
for (id, dev) in [("normal", false), ("dev", true), ("", false)] {
s.mods.installed.push(crate::mod_list::Installed {
id: id.into(),
title: id.into(),
description: "May show HUD panels.".into(),
problem: id.is_empty().then(|| "Invalid package".into()),
dev,
});
}
let (widgets, ..) = ui.layout(&s, size.0, size.1);
let rows: Vec<_> = widgets
.iter()
.filter(|w| {
matches!(
w.kind,
WKind::Button {
act: Act::ToggleMod(_),
..
}
)
})
.collect();
assert_eq!(rows.len(), 3);
for (i, row) in rows.iter().enumerate() {
let events = ui.click(
&mut s,
&atlas,
row.x + 1.0,
row.y + 1.0,
size,
[480, 240],
false,
false,
);
if i == 0 {
assert!(events.contains(&Event::Changed));
assert!(events.contains(&Event::ButtonClick));
} else {
assert!(events.is_empty());
}
}
assert!(s.mods.is_on(0));
assert!(s.mods.is_on(1));
assert!(!s.mods.is_on(2));
assert_eq!(s.mods.serialize(), "mod.normal:true\n");
let row = rows[0];
ui.click(
&mut s,
&atlas,
row.x + 1.0,
row.y + 1.0,
size,
[480, 240],
false,
false,
);
assert!(!s.mods.is_on(0));
assert!(!ui.back(&mut s).contains(&Event::Close));
assert_eq!(ui.page(), Page::Main);
}
#[test]
fn option_tooltip_keys_follow_value_dependent_descriptions() {
let mut s = Settings::default();
@@ -2316,6 +2496,83 @@ mod tests {
}
}
#[test]
fn classic_extras_entry_edits_shared_settings_and_returns_without_changing_style() {
let previous_style = style();
set_style(MenuStyle::Classic);
let atlas = atlas();
let mut s = Settings::default();
let mut ui = OptionsUi::default();
let size = (480.0, 480.0);
let click = |ui: &mut OptionsUi, s: &mut Settings, act: Act| {
let (widgets, _, _, _) = ui.layout(s, size.0, size.1);
let widget = widgets
.iter()
.find(
|w| matches!(&w.kind, WKind::Button { act: a, active: true, .. } if *a == act),
)
.unwrap();
ui.click(
s,
&atlas,
widget.x + 1.0,
widget.y + 1.0,
size,
[960, 960],
false,
false,
)
};
assert_eq!(
click(&mut ui, &mut s, Act::Push(Page::Extras)),
vec![Event::ButtonClick]
);
assert_eq!(ui.page(), Page::Extras);
let (widgets, _, _, _) = ui.layout(&s, size.0, size.1);
assert_eq!(
widgets
.iter()
.filter(|w| matches!(
w.kind,
WKind::Button {
act: Act::Extra(_),
..
}
))
.count(),
crate::extras::rows().iter().filter(|r| r.is_ok()).count()
);
assert_eq!(
click(&mut ui, &mut s, Act::Extra(crate::extras::Item::Zoom)),
vec![Event::ButtonClick, Event::Changed]
);
assert!(s.extras.zoom);
assert_eq!(
click(&mut ui, &mut s, Act::Extra(crate::extras::Item::ZoomKey)),
vec![Event::ButtonClick]
);
assert_eq!(ui.selected_key, Some(crate::extras::ZOOM_KEY));
assert_eq!(
ui.key(&mut s, &atlas, winit::keyboard::KeyCode::KeyC, None),
vec![Event::Changed]
);
assert_eq!(s.extras.zoom_key, "key.keyboard.c");
assert_eq!(
crate::extras::Extras::parse(&s.extras.serialize()),
s.extras
);
ui.scroll(&s, size, -1000.0);
let (_, top, bottom, content) = ui.layout(&s, size.0, size.1);
assert_eq!(ui.scroll, content - (bottom - top));
assert_eq!(
ui.key(&mut s, &atlas, winit::keyboard::KeyCode::Escape, None),
vec![Event::Changed]
);
assert_eq!(ui.page(), Page::Main);
assert_eq!(style(), MenuStyle::Classic);
set_style(previous_style);
}
#[test]
fn classic_graphics_presets_set_the_distances() {
let atlas = atlas();
@@ -2831,6 +3088,55 @@ mod tests {
}
}
#[test]
fn extras_and_vanilla_bindings_accept_mouse_buttons() {
use crate::extras::{Extras, SORT_KEY, ZOOM_KEY};
use winit::event::MouseButton;
for button in [
MouseButton::Left,
MouseButton::Right,
MouseButton::Middle,
MouseButton::Back,
MouseButton::Forward,
] {
for name in [SORT_KEY, ZOOM_KEY, "key.jump"] {
let mut ui = OptionsUi::default();
let mut s = Settings::default();
ui.selected_key = Some(name);
assert_eq!(ui.bind_mouse(&mut s, button), vec![Event::Changed]);
assert_eq!(ui.selected_key, None);
let value = keybinds::mouse_name(button);
match name {
SORT_KEY => assert_eq!(s.extras.sort_key, value),
ZOOM_KEY => assert_eq!(s.extras.zoom_key, value),
_ => assert_eq!(s.keys.get(name), value),
}
assert_eq!(Extras::parse(&s.extras.serialize()), s.extras);
if name != "key.jump" {
assert_eq!(s.keys, Settings::default().keys);
}
assert!(ui.bind_mouse(&mut s, button).is_empty());
}
}
}
#[test]
fn horizon_extra_mouse_binding_consumes_the_click() {
let atlas = atlas();
let mut s = Settings::default();
let mut ui = OptionsUi::default();
for (right, expected) in [(false, "key.mouse.left"), (true, "key.mouse.right")] {
ui.selected_key = Some(crate::extras::SORT_KEY);
assert_eq!(
ui.click_horizon(&mut s, &atlas, 2.0, 2.0, [960, 480], false, right),
vec![Event::Changed]
);
assert_eq!(s.extras.sort_key, expected);
assert_eq!(ui.selected_key, None);
assert_eq!(ui.section, 0);
}
}
#[test]
fn key_rebinding_takes_precedence_over_scrollbar_dragging() {
let atlas = atlas();
+134
View File
@@ -0,0 +1,134 @@
//! The points of interest of each resident section (`PoiSection`), so a
//! search visits the few POI blocks of the sections in range instead of
//! reading every block of them.
//!
//! Vanilla keeps its records up to date from `onBlockStateChange`; here a
//! section's list is rebuilt from its blocks after any edit. Resident
//! sections are immutable behind `Arc` and edited through `Arc::make_mut`, so
//! a weak reference tells an edited or replaced section from the one the list
//! was built from (see `random_tick_sections`), without keeping its blocks.
use crate::{chunk::Section, fast_hash::FxHashMap};
use std::sync::{Arc, Mutex, Weak};
/// A section's POIs: the block index in the section (`y << 8 | z << 4 | x`)
/// and its kind, in ascending index order.
pub type SectionPois<T> = Arc<[(u16, T)]>;
struct Cached<T> {
section: Weak<Section>,
pois: SectionPois<T>,
}
/// Cached POI lists by section, `(chunk x, section index, chunk z)`.
pub struct PoiSections<T> {
sections: Mutex<Lists<T>>,
}
struct Lists<T> {
by_section: FxHashMap<(i32, i32, i32), Cached<T>>,
/// Size above which lists of sections no longer resident are dropped.
prune_at: usize,
}
const MIN_PRUNE: usize = 4096;
impl<T> Default for PoiSections<T> {
fn default() -> Self {
Self {
sections: Mutex::new(Lists {
by_section: FxHashMap::default(),
prune_at: MIN_PRUNE,
}),
}
}
}
impl<T: Copy> PoiSections<T> {
/// The POIs of `section`, whose block states `kind` classifies. `kind`
/// must give the same answer for a state on every call.
pub fn get(
&self,
key: (i32, i32, i32),
section: &Arc<Section>,
mut kind: impl FnMut(u32) -> Option<T>,
) -> SectionPois<T> {
let mut lists = self.sections.lock().unwrap_or_else(|e| e.into_inner());
if let Some(cached) = lists.by_section.get(&key)
&& cached.section.as_ptr() == Arc::as_ptr(section)
{
return cached.pois.clone();
}
let pois: SectionPois<T> = if section.blocks.maybe_has(|v| kind(v).is_some()) {
let mut states = [0u16; 4096];
section.unpack(&mut states);
states
.iter()
.enumerate()
.filter_map(|(i, &state)| kind(u32::from(state)).map(|poi| (i as u16, poi)))
.collect()
} else {
Arc::from([])
};
if lists.by_section.len() >= lists.prune_at {
lists.by_section.retain(|_, c| c.section.strong_count() > 0);
lists.prune_at = (lists.by_section.len() * 2).max(MIN_PRUNE);
}
lists.by_section.insert(
key,
Cached {
section: Arc::downgrade(section),
pois: pois.clone(),
},
);
pois
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::chunk::{Chunk, MIN_Y};
#[test]
fn lists_follow_edits_and_replacement() {
let index = PoiSections::<u8>::default();
let kind = |v: u32| (v == 5 || v == 6).then_some(v as u8);
let mut chunk = Arc::new(Chunk::empty(0, 0));
assert!(index.get((0, 0, 0), &chunk.sections[0], kind).is_empty());
Arc::make_mut(&mut chunk).set(3, MIN_Y + 2, 1, 6);
Arc::make_mut(&mut chunk).set(0, MIN_Y, 0, 5);
let found = index.get((0, 0, 0), &chunk.sections[0], kind);
assert_eq!(&*found, &[(0, 5), (2 << 8 | 1 << 4 | 3, 6)]);
// Unchanged: the cached list, not a rescan.
let again = index.get((0, 0, 0), &chunk.sections[0], |_| panic!("rescanned"));
assert!(Arc::ptr_eq(&found, &again));
// An edit in place (no other owner) still invalidates the list.
Arc::make_mut(&mut chunk).set(0, MIN_Y, 0, 1);
assert_eq!(
&*index.get((0, 0, 0), &chunk.sections[0], kind),
&[(2 << 8 | 1 << 4 | 3, 6)]
);
// So does replacing the section, or the chunk.
Arc::make_mut(&mut chunk).sections[0] = Arc::new(Section::default());
assert!(index.get((0, 0, 0), &chunk.sections[0], kind).is_empty());
let mut other = Chunk::empty(0, 0);
other.set(1, MIN_Y, 1, 5);
chunk = Arc::new(other);
assert_eq!(
&*index.get((0, 0, 0), &chunk.sections[0], kind),
&[(1 << 4 | 1, 5)]
);
// An unused palette entry alone yields no POI.
Arc::make_mut(&mut chunk).set(1, MIN_Y, 1, 2);
assert!(index.get((0, 0, 0), &chunk.sections[0], kind).is_empty());
}
#[test]
fn unloaded_sections_are_dropped() {
let index = PoiSections::<u8>::default();
let kind = |v: u32| (v == 5).then_some(5);
let kept = Arc::new(Section::default());
index.get((0, 0, 0), &kept, kind);
for i in 0..MIN_PRUNE as i32 {
index.get((1, i, 0), &Arc::new(Section::default()), kind);
}
let lists = index.sections.lock().unwrap();
assert!(lists.by_section.len() <= 2);
assert!(lists.by_section.contains_key(&(0, 0, 0)));
}
}
+27 -1
View File
@@ -449,13 +449,17 @@ pub fn encode_block_entity(
block: &str,
) -> Tag {
use crate::containers::BlockEntity;
let components = match e {
BlockEntity::Banner(b) => b.components.clone(),
_ => Compound::new(),
};
let mut entries = vec![
("id", string(&block_entity_id(e, block))),
("x", Tag::Int(p.0)),
("y", Tag::Int(p.1)),
("z", Tag::Int(p.2)),
("keepPacked", Tag::Byte(0)),
("components", Tag::Compound(Compound::new())),
("components", Tag::Compound(components)),
];
match e {
BlockEntity::Chest(items) => entries.push(("Items", encode_items(items))),
@@ -583,6 +587,10 @@ pub fn decode_block_entity(tag: &Tag) -> Option<((i32, i32, i32), crate::contain
BlockEntity::Banner(crate::containers::Banner {
layers: crate::banner::layers_from_nbt(tag.get("patterns")),
name: text(tag.get("CustomName")),
components: match tag.get("components") {
Some(Tag::Compound(c)) => c.clone(),
_ => Compound::new(),
},
}),
));
}
@@ -2361,6 +2369,7 @@ impl Level {
"Inventory",
"EnderItems",
"equipment",
"active_effects",
"Pos",
"respawn",
"recipeBook",
@@ -2984,6 +2993,7 @@ mod tests {
let banner = crate::containers::Banner {
layers: vec![crate::banner::BannerLayer::new("minecraft:creeper", "lime")],
name: Some("Flag".into()),
components: [("minecraft:rarity".into(), string("uncommon"))].into(),
};
let tag = encode_block_entity(
(1, 2, 3),
@@ -2997,6 +3007,7 @@ mod tests {
};
assert_eq!(back.layers, banner.layers);
assert_eq!(back.name, banner.name);
assert_eq!(back.components, banner.components);
}
use super::*;
@@ -3191,4 +3202,19 @@ mod tests {
assert!(dir.join("data/minecraft/world_gen_settings.dat").exists());
let _ = fs::remove_dir_all(&dir);
}
#[test]
fn effects_that_ended_are_not_saved_again() {
// A player loaded with an effect that has since run out: the loaded
// compound still holds it, but the save writes only what is active.
let mut level = Level {
active_effects: vec![("minecraft:speed".into(), 200, 1, false, true)],
..Level::default()
};
let loaded = level.player_tag();
assert!(loaded.get("active_effects").is_some());
level.player_extra = Some(loaded);
level.active_effects.clear();
assert!(level.player_tag().get("active_effects").is_none());
}
}
+103 -33
View File
@@ -82,6 +82,10 @@ pub struct Sprites {
/// Each layer's frames at the texture's own resolution (square), and the
/// frame shown first.
native: Vec<(u32, Arc<Vec<Vec<u8>>>, usize)>,
/// Still textures by their pixels and mip settings: mods copy vanilla's
/// textures under their own names, and one layer serves them all (the
/// GPU's array may hold as few as 2048).
still: std::collections::HashMap<(Vec<u8>, u32, [u32; 2], [bool; 4]), u32>,
}
/// Edge length of vanilla's block textures: the smallest array layer.
pub const SPRITE_SIZE: u32 = 16;
@@ -104,6 +108,10 @@ fn resample(frame: &[u8], from: u32, to: u32) -> Vec<u8> {
out
}
impl Sprites {
/// How many array layers the textures take.
pub fn count(&self) -> usize {
self.native.len()
}
/// Lay every layer out at one size: the largest texture's (resource packs
/// may ship 32x, 64x... textures, like vanilla's stitched atlas), rounded
/// up to a power of two and limited to [`MAX_ARRAY_BYTES`]. Smaller
@@ -152,7 +160,7 @@ impl Sprites {
}
})
.collect();
let layer = u32::try_from(self.layers.len())?;
let layer = u32::try_from(self.native.len())?;
self.opaque.push(true);
self.translucent.push(false);
self.mips.push(crate::mipmap::Settings::default());
@@ -209,7 +217,7 @@ impl Sprites {
};
pixels.extend(rgba);
}
let layer = u32::try_from(self.layers.len())?;
let layer = u32::try_from(self.native.len())?;
let columns = info.width / width;
let count = columns * (info.height / height);
// Layers are square; a frame of another shape is nearest-resampled to
@@ -230,6 +238,46 @@ impl Sprites {
}
frames.push(frame);
}
let settings = crate::mipmap::Settings {
native_size: side,
strategy: texture_section(metadata.as_ref())
.as_ref()
.and_then(|t| t["mipmap_strategy"].as_str())
.and_then(crate::mipmap::Strategy::parse)
.unwrap_or_default(),
alpha_cutoff_bias: texture_section(metadata.as_ref())
.as_ref()
.and_then(|t| t["alpha_cutoff_bias"].as_f64())
.unwrap_or(0.0) as f32,
has_transparent: pixels.as_chunks::<4>().0.iter().any(|p| p[3] == 0),
item: name
.split_once(':')
.is_some_and(|(_, p)| p.starts_with("item/")),
};
let opaque = pixels.as_chunks::<4>().0.iter().all(|p| p[3] == 255);
let translucent = pixels
.as_chunks::<4>()
.0
.iter()
.any(|p| p[3] != 0 && p[3] != 255);
let still = (animation.is_none() && frames.len() == 1).then(|| {
(
frames[0].clone(),
side,
[
settings.strategy as u32,
settings.alpha_cutoff_bias.to_bits(),
],
[settings.has_transparent, settings.item, opaque, translucent],
)
});
if let Some(&same) = still.as_ref().and_then(|k| self.still.get(k)) {
self.layers.insert(name.to_owned(), same);
return Ok(same);
}
if let Some(key) = still {
self.still.insert(key, layer);
}
let frames = Arc::new(frames);
let mut initial = 0;
if let Some(clip) = animation
@@ -245,43 +293,25 @@ impl Sprites {
clip: Arc::new(clip),
});
}
// SpriteContents: TextureMetadataSection's mipmap strategy and alpha
// cutoff bias, and the whole image's NativeImage.computeTransparency.
let texture = metadata
.as_ref()
.and_then(|v| v.get("texture"))
.and_then(|v| serde_json::from_str::<serde_json::Value>(v.get()).ok());
self.mips.push(crate::mipmap::Settings {
native_size: side,
strategy: texture
.as_ref()
.and_then(|t| t["mipmap_strategy"].as_str())
.and_then(crate::mipmap::Strategy::parse)
.unwrap_or_default(),
alpha_cutoff_bias: texture
.as_ref()
.and_then(|t| t["alpha_cutoff_bias"].as_f64())
.unwrap_or(0.0) as f32,
has_transparent: pixels.as_chunks::<4>().0.iter().any(|p| p[3] == 0),
item: name
.split_once(':')
.is_some_and(|(_, p)| p.starts_with("item/")),
});
self.opaque
.push(pixels.as_chunks::<4>().0.iter().all(|p| p[3] == 255));
self.translucent.push(
pixels
.as_chunks::<4>()
.0
.iter()
.any(|p| p[3] != 0 && p[3] != 255),
);
self.mips.push(settings);
self.opaque.push(opaque);
self.translucent.push(translucent);
self.layers.insert(name.to_owned(), layer);
self.native.push((side, frames, initial));
Ok(layer)
}
}
/// SpriteContents: the `.mcmeta` `texture` section (TextureMetadataSection's
/// mipmap strategy and alpha cutoff bias).
fn texture_section(
metadata: Option<&BTreeMap<String, Box<serde_json::value::RawValue>>>,
) -> Option<serde_json::Value> {
metadata
.and_then(|v| v.get("texture"))
.and_then(|v| serde_json::from_str(v.get()).ok())
}
#[cfg(test)]
pub(crate) fn test_animation(size: u32, layer: u32) -> SpriteAnimation {
test_clip(size, layer, r#"{"frametime":1,"frames":[0,1]}"#)
@@ -305,6 +335,46 @@ pub(crate) fn test_clip(size: u32, layer: u32, metadata: &str) -> SpriteAnimatio
mod tests {
use super::*;
#[test]
fn identical_still_textures_share_a_layer() {
let root =
std::env::temp_dir().join(format!("horizon-sprite-share-{}", std::process::id()));
let directory = root.join("assets/a/textures/block");
fs::create_dir_all(&directory).unwrap();
let write = |name: &str, red: u8| {
let mut encoder =
png::Encoder::new(File::create(directory.join(name)).unwrap(), 16, 16);
encoder.set_color(png::ColorType::Rgba);
encoder.set_depth(png::BitDepth::Eight);
let pixels: Vec<u8> = (0..256).flat_map(|i| [red, i as u8, 0, 255]).collect();
encoder
.write_header()
.unwrap()
.write_image_data(&pixels)
.unwrap();
};
write("one.png", 10);
write("copy.png", 10);
write("other.png", 20);
let mut sprites = Sprites::default();
let one = sprites.insert(&root, "a:block/one").unwrap();
let copy = sprites.insert(&root, "a:block/copy").unwrap();
let other = sprites.insert(&root, "a:block/other").unwrap();
// The same pixels as an item sprite mip differently: a layer of its own.
fs::create_dir_all(root.join("assets/a/textures/item")).unwrap();
fs::copy(
directory.join("one.png"),
root.join("assets/a/textures/item/one.png"),
)
.unwrap();
let item = sprites.insert(&root, "a:item/one").unwrap();
fs::remove_dir_all(&root).unwrap();
assert_eq!((one, copy, other, item), (0, 0, 1, 2));
assert_eq!((sprites.count(), sprites.layers.len()), (3, 4));
assert_eq!((sprites.opaque.len(), sprites.mips.len()), (3, 3));
sprites.finish();
assert_eq!(sprites.pixels.len(), 3 * 16 * 16 * 4);
}
#[test]
fn a_32px_only_atlas_does_not_add_an_extra_mipmap() {
let mut sprites = Sprites {
native: vec![
+17 -10
View File
@@ -481,23 +481,30 @@ fn ingredient(v: &Value, items: &Items) -> Ingredient {
}
impl StationRecipes {
pub fn load(root: &Path, items: &Items) -> Self {
let mut files: Vec<_> = fs::read_dir(root.join("data/minecraft/recipe"))
.into_iter()
.flatten()
.flatten()
.map(|e| e.path())
.filter(|p| p.extension().is_some_and(|e| e == "json"))
.collect();
files.sort();
// Vanilla's recipes, then the content mods' (docs/modpacks.md).
let mut files = Vec::new();
let namespaces =
std::iter::once("minecraft".to_owned()).chain(crate::mod_content::namespaces(root));
for namespace in namespaces {
let mut more: Vec<_> = fs::read_dir(root.join(format!("data/{namespace}/recipe")))
.into_iter()
.flatten()
.flatten()
.map(|e| e.path())
.filter(|p| p.extension().is_some_and(|e| e == "json"))
.collect();
more.sort();
files.extend(more.into_iter().map(|p| (namespace.clone(), p)));
}
let mut smithing = Vec::new();
let mut stonecutting = Vec::new();
for p in files {
for (namespace, p) in files {
let Ok(bytes) = fs::read(&p) else { continue };
let Ok(v) = serde_json::from_slice::<Value>(&bytes) else {
continue;
};
let id = format!(
"minecraft:{}",
"{namespace}:{}",
p.file_stem().and_then(|s| s.to_str()).unwrap_or("")
);
match v["type"].as_str().unwrap_or("") {
+43 -6
View File
@@ -968,7 +968,8 @@ impl Streaming {
return (uploads, removed);
}
// Meshing once the column and its neighbours are lit, and the column
// is within the render distance. Sections set aside past it come back
// is within the render distance (`in_view_distance`, the columns
// vanilla draws). Sections set aside past it come back
// when the player moves: a column that loads with its light gets no
// other request (#228).
let area = (self.center, self.radius, self.forced.len());
@@ -981,7 +982,7 @@ impl Streaming {
forced: &self.forced,
};
self.waiting.retain(|&(x, sy, z)| {
let back = ranges.in_main_range(x, z, 0);
let back = ranges.in_view(x, z);
if back {
world.dirty_sections.insert((x, sy, z));
}
@@ -996,7 +997,7 @@ impl Streaming {
world.dirty_sections.remove(&(x, sy, z));
continue;
}
if !self.in_main_range(x, z, 0) {
if !self.ranges().in_view(x, z) {
world.dirty_sections.remove(&(x, sy, z));
self.waiting.insert((x, sy, z));
continue;
@@ -1204,9 +1205,15 @@ impl Streaming {
fn in_range(&self, x: i32, z: i32, margin: i32) -> bool {
self.ranges().in_range(x, z, margin)
}
fn in_main_range(&self, x: i32, z: i32, margin: i32) -> bool {
self.ranges().in_main_range(x, z, margin)
}
}
/// `ChunkTrackingView.isInViewDistance`: whether the column (x, z) is drawn
/// at this render distance around `center`, the camera's column
/// (`SectionOcclusionGraph.isInViewDistance`). Each axis gets a column of
/// slack, so this reaches past the circle of `radius` columns.
pub fn in_view_distance(center: (i32, i32), radius: i32, x: i32, z: i32) -> bool {
let gap = |d: i32| i64::from((d.abs() - 1).max(0));
let (dx, dz) = (gap(x - center.0), gap(z - center.1));
dx * dx + dz * dz < i64::from(radius) * i64::from(radius)
}
/// The areas kept loaded: circles around the player and `extra`, and forced chunks.
struct Ranges<'a> {
@@ -1271,6 +1278,11 @@ impl Ranges<'_> {
dx * dx + dz * dz <= r * r
})
}
/// The columns meshed for drawing: those vanilla draws around the
/// player (`in_view_distance`), and forced ones.
fn in_view(&self, x: i32, z: i32) -> bool {
in_view_distance(self.center, self.radius, x, z) || self.forced.contains(&(x, z))
}
fn in_main_range(&self, x: i32, z: i32, margin: i32) -> bool {
let r = i64::from(self.radius + margin);
let (dx, dz) = (i64::from(x - self.center.0), i64::from(z - self.center.1));
@@ -1306,6 +1318,31 @@ impl Drop for Streaming {
mod tests {
use super::*;
#[test]
fn view_distance_is_vanillas_shape() {
// ChunkTrackingView.isInViewDistance at render distance 12: a column
// of slack on each axis, so 533 columns rather than the 441 of a
// circle of radius 12.
let count = |r: i32| {
(-40..=40)
.flat_map(|x| (-40..=40).map(move |z| (x, z)))
.filter(|&(x, z)| in_view_distance((5, -7), r, x + 5, z - 7))
.count()
};
assert_eq!(count(12), 533);
assert_eq!(count(2), 25);
for (x, z, inside) in [(12, 0, true), (13, 0, false), (9, 9, true), (10, 9, false)] {
assert_eq!(in_view_distance((0, 0), 12, x, z), inside, "({x}, {z})");
assert_eq!(
in_view_distance((0, 0), 12, -z, -x),
inside,
"({}, {})",
-z,
-x
);
}
}
struct GenerationFixture {
world: World,
center: (i32, i32),
+25 -2
View File
@@ -27,6 +27,29 @@ struct Globals {
@group(0) @binding(2) var sprite_sampler: sampler;
@group(0) @binding(3) var lightmap: texture_2d<f32>;
@group(0) @binding(4) var lightmap_sampler: sampler;
// Layers past the first array's SPRITE_SPLIT (2048, gfx.rs): mods' sprites.
@group(0) @binding(5) var sprites_1: texture_2d_array<f32>;
@group(0) @binding(6) var sprites_2: texture_2d_array<f32>;
@group(0) @binding(7) var sprites_3: texture_2d_array<f32>;
// How many sprite arrays hold layers (a pipeline constant): 1 for vanilla,
// which then samples exactly as before.
override SPRITE_ARRAYS: u32 = 1u;
override SPRITE_SPLIT: u32 = 2048u;
fn sprite(uv: vec2<f32>, layer: u32) -> vec4<f32> {
if SPRITE_ARRAYS == 1u {
return textureSample(sprites, sprite_sampler, uv, i32(layer));
}
// The array is chosen per fragment: sample with the derivatives taken here.
let dx = dpdx(uv);
let dy = dpdy(uv);
let l = i32(layer % SPRITE_SPLIT);
switch layer / SPRITE_SPLIT {
case 0u: { return textureSampleGrad(sprites, sprite_sampler, uv, l, dx, dy); }
case 1u: { return textureSampleGrad(sprites_1, sprite_sampler, uv, l, dx, dy); }
case 2u: { return textureSampleGrad(sprites_2, sprite_sampler, uv, l, dx, dy); }
default: { return textureSampleGrad(sprites_3, sprite_sampler, uv, l, dx, dy); }
}
}
struct TerrainOut {
@builtin(position) clip: vec4<f32>,
@@ -67,12 +90,12 @@ fn apply_fog(color: vec4<f32>, spherical: f32, cylindrical: f32) -> vec4<f32> {
}
@fragment fn fs_solid(in: TerrainOut) -> @location(0) vec4<f32> {
// Bit 15 of the layer marks opaque leaves (forceOpaque): no alpha cutout.
let color = textureSample(sprites, sprite_sampler, in.uv, i32(in.layer & 0x7fffu)) * in.color;
let color = sprite(in.uv, in.layer & 0x7fffu) * in.color;
if color.a < 0.5 && (in.layer & 0x8000u) == 0u { discard; }
return apply_fog(vec4(color.rgb, 1.0), in.spherical, in.cylindrical);
}
@fragment fn fs_translucent(in: TerrainOut) -> @location(0) vec4<f32> {
let color = textureSample(sprites, sprite_sampler, in.uv, i32(in.layer & 0x7fffu)) * in.color;
let color = sprite(in.uv, in.layer & 0x7fffu) * in.color;
if color.a < 0.01 { discard; }
return apply_fog(color, in.spherical, in.cylindrical);
}
+1
View File
@@ -690,6 +690,7 @@ impl<'a> Ui<'a> {
pos: p[i],
uv: [cu, cv],
color: c[i],
depth: 0.0,
});
}
}
+3
View File
@@ -46,6 +46,8 @@ pub struct World {
/// Every block position written since the log was last drained, kept
/// only while the world is open to the network (see `lan`).
pub block_log: Option<Vec<(i32, i32, i32)>>,
/// The villager POIs of each section (`PoiManager`'s sections).
pub pois: crate::poi_sections::PoiSections<crate::mobs::villager_brain::Poi>,
}
/// ServerLevel weather state (advanceWeatherCycle).
#[derive(Clone, Copy, Debug, Default)]
@@ -130,6 +132,7 @@ impl World {
day_time: 1000,
weather: Weather::default(),
block_log: None,
pois: Default::default(),
}
}
/// A controlled blockstate scene for the native scene probes: material
+1
View File
@@ -241,6 +241,7 @@ fn server(resources: &Path) -> Server {
view_distance: 3,
simulation_distance: 3,
dedicated: false,
integrated: false,
dimension: "minecraft:overworld".into(),
seed: 1234,
max_players: 8,
+10 -6
View File
@@ -4,7 +4,7 @@
//!
//! Content is data, not code: nothing here runs in the sandbox. What a mod
//! may add is fenced instead. Its own namespace, plus additions to vanilla
//! tags. Paths are plain, files and totals are capped, and vanilla ids
//! tags and to the convention tags (`c`, which NeoForge and Fabric mods share). Paths are plain, files and totals are capped, and vanilla ids
//! cannot be redefined.
use crate::manifest::{Capability, MANIFEST, Manifest};
use serde::Deserialize;
@@ -242,12 +242,13 @@ impl Content {
parts.next().unwrap_or(""),
);
let own = namespace == id;
// Vanilla's own files stay vanilla's; a mod may only add to its tags.
let allowed =
own || (top == "data" && namespace == "minecraft" && rest.starts_with("tags/"));
// Vanilla's own files stay vanilla's; a mod may only add to its
// tags, and to the convention tags mods share.
let shared = matches!(namespace, "minecraft" | "c");
let allowed = own || (top == "data" && shared && rest.starts_with("tags/"));
if !allowed {
return Err(format!(
"{name}: a mod adds files in its own namespace ({top}/{id}/) or to vanilla tags"
"{name}: a mod adds files in its own namespace ({top}/{id}/) or to vanilla and convention (c) tags"
));
}
let Some(decl) = (own && top == "data")
@@ -417,10 +418,11 @@ capabilities = ["registries"]
("data/ruby/horizon/item/ruby.json", ITEM),
("data/ruby/recipe/ruby_block.json", b"{}"),
("data/minecraft/tags/block/mineable/pickaxe.json", b"{}"),
("data/c/tags/item/gems/ruby.json", b"{}"),
("assets/ruby/textures/block/ruby_block.png", b"png"),
];
let content = hmod("ok", MANIFEST_TEXT, files).unwrap();
assert_eq!(content.files.len(), 5);
assert_eq!(content.files.len(), 6);
assert_eq!(
content.blocks,
[Block {
@@ -471,6 +473,8 @@ capabilities = ["registries"]
"vanilla-recipe",
&[("data/minecraft/recipe/stone.json", b"{}")],
);
refused("convention-recipe", &[("data/c/recipe/stone.json", b"{}")]);
refused("convention-asset", &[("assets/c/lang/en_us.json", b"{}")]);
let e = refused(
"modded-template",
&[(
+358 -35
View File
@@ -3,7 +3,7 @@
//! upgraded from 1.21.1 to 26.3, item models get their `items/` client
//! definitions, and each blockstate gets a vanilla template guessed from its
//! properties until the oracle's facts replace the guess.
use crate::jar::JarInfo;
use crate::{jar::JarInfo, oracle::Facts};
use serde::Serialize;
use serde_json::{Value, json};
use std::{
@@ -20,14 +20,26 @@ pub struct Report {
/// data other than tags), kept in `outside/` for review.
pub outside: Vec<String>,
pub recipes_upgraded: usize,
pub loot_tables_upgraded: usize,
/// Worldgen and structure files (`data/<id>/worldgen/`, `structure/`).
pub worldgen: usize,
/// Recipes left as they were: custom types, NeoForge conditions.
pub recipes_kept: Vec<String>,
pub item_definitions_added: usize,
/// Declared blocks and their guessed templates.
/// Templates and properties came from the NeoForge oracle's facts, not
/// from guesses.
pub oracle: bool,
/// Declared blocks and their templates.
pub blocks: BTreeMap<String, String>,
/// Blockstates whose properties match no template.
pub blocks_unknown: Vec<String>,
/// What a declared block's template does not reproduce (oracle only).
pub differences: BTreeMap<String, Vec<String>>,
/// Blocks left out, and why.
pub blocks_unknown: BTreeMap<String, String>,
pub items: usize,
/// Items left out, and why (oracle only).
pub items_unknown: BTreeMap<String, String>,
/// Convention (`c:`) tags the recipes use, filled in from the oracle.
pub convention_tags: usize,
}
/// Vanilla blocks by their sorted property names.
@@ -42,6 +54,7 @@ const TEMPLATES: &[(&str, &str)] = &[
"minecraft:oak_trapdoor",
),
("east,north,south,waterlogged,west", "minecraft:oak_fence"),
("east,north,south,waterlogged,west", "minecraft:glass_pane"),
(
"east,north,south,up,waterlogged,west",
"minecraft:cobblestone_wall",
@@ -58,9 +71,24 @@ const TEMPLATES: &[(&str, &str)] = &[
("stage", "minecraft:oak_sapling"),
];
pub fn template(properties: &BTreeSet<String>) -> Option<&'static str> {
let key = properties.iter().cloned().collect::<Vec<_>>().join(",");
TEMPLATES.iter().find(|(k, _)| *k == key).map(|(_, t)| *t)
/// A guess without the oracle: the template whose properties include the
/// blockstate's with the fewest left over (a blockstate may leave out what
/// its models ignore, such as `powered` or `waterlogged`), the block's name
/// breaking ties (`_pane`, `_gate`, `_trapdoor`).
pub fn template(name: &str, properties: &BTreeSet<String>) -> Option<&'static str> {
let fits = TEMPLATES.iter().filter_map(|(k, t)| {
let have: BTreeSet<&str> = k.split(',').filter(|p| !p.is_empty()).collect();
properties
.iter()
.all(|p| have.contains(p.as_str()))
.then(|| (have.len() - properties.len(), *t))
});
let hint = |t: &str| {
let kind = t.rsplit('_').next().unwrap_or(t);
!name.ends_with(&format!("_{kind}"))
};
fits.min_by_key(|&(extra, t)| (extra, hint(t)))
.map(|(_, t)| t)
}
/// The property names a blockstate file uses.
@@ -165,7 +193,92 @@ pub fn upgrade_recipe(recipe: &mut Value) -> bool {
true
}
/// Where a jar entry goes: `Some(true)` inside the content mod, `Some(false)`
/// A 1.21.1 loot table in 26.3's shape, in place: `conditions` lists become
/// one `condition` (`all_of` for several), `functions` become `modifier`,
/// and conditions and functions name their kind in `type`. A tool match on
/// silk touch alone, or on shears alone, becomes 26.3's
/// `minecraft:tool/can_silk_touch` or `minecraft:tool/can_shear`.
pub fn upgrade_loot(v: &mut Value) {
match v {
Value::Array(a) => a.iter_mut().for_each(upgrade_loot),
Value::Object(o) => {
if let Some(Value::Array(mut list)) = o.remove("conditions") {
list.iter_mut().for_each(upgrade_condition);
let one = match <[Value; 1]>::try_from(list) {
Ok([c]) => c,
Err(list) => json!({"type": "minecraft:all_of", "terms": list}),
};
o.insert("condition".to_owned(), one);
}
if let Some(Value::Array(mut list)) = o.remove("functions") {
for f in &mut list {
rename_kind(f, "function");
upgrade_loot(f);
}
o.insert("modifier".to_owned(), Value::Array(list));
}
for (k, x) in o.iter_mut() {
if k != "condition" && k != "modifier" {
upgrade_loot(x);
}
}
}
_ => {}
}
}
/// `{"<key>": kind, ...}` as `{"type": kind, ...}`.
fn rename_kind(v: &mut Value, key: &str) {
if let Some(o) = v.as_object_mut()
&& !o.contains_key("type")
&& let Some(kind) = o.remove(key)
{
o.insert("type".to_owned(), kind);
}
}
/// One 1.21.1 loot condition in 26.3's shape.
fn upgrade_condition(c: &mut Value) {
rename_kind(c, "condition");
if let Some(term) = c.get_mut("term") {
upgrade_condition(term);
}
if let Some(Value::Array(terms)) = c.get_mut("terms") {
terms.iter_mut().for_each(upgrade_condition);
}
if c["type"] == "minecraft:match_tool"
&& let Some(named) = named_tool_condition(&c["predicate"])
{
*c = json!(named);
}
}
/// 26.3's named tool conditions for the 1.21.1 predicates they replace.
fn named_tool_condition(predicate: &Value) -> Option<&'static str> {
let keys: Vec<&str> = predicate.as_object()?.keys().map(String::as_str).collect();
match keys.as_slice() {
["predicates"] => {
let list = predicate["predicates"]["minecraft:enchantments"].as_array()?;
let [e] = list.as_slice() else {
return None;
};
let silk = e["enchantments"] == "minecraft:silk_touch"
&& e["levels"]["min"].as_u64().unwrap_or(1) <= 1
&& e["levels"].get("max").is_none()
&& predicate["predicates"].as_object()?.len() == 1;
silk.then_some("minecraft:tool/can_silk_touch")
}
["items"] => {
let items = &predicate["items"];
let shears = items == "minecraft:shears" || *items == json!(["minecraft:shears"]);
shears.then_some("minecraft:tool/can_shear")
}
_ => None,
}
}
/// Where a jar entry goes: `Some(true)` inside the content mod (its own
/// namespace, additions to vanilla and convention tags), `Some(false)`
/// to `outside/`, `None` not carried (code, metadata).
fn place(name: &str, id: &str) -> Option<bool> {
let mut parts = name.splitn(3, '/');
@@ -173,10 +286,21 @@ fn place(name: &str, id: &str) -> Option<bool> {
if !(root == "assets" || root == "data") || rest.is_empty() || name.ends_with('/') {
return None;
}
Some(ns == id || (root == "data" && ns == "minecraft" && rest.starts_with("tags/")))
let shared_tags =
root == "data" && (ns == "minecraft" || ns == "c") && rest.starts_with("tags/");
Some(ns == id || shared_tags)
}
pub fn carry(jar: &Path, info: &JarInfo, out: &Path) -> Result<Report, String> {
/// Carries `jar` over into `out/carry/`. With the oracle's `facts`, blocks
/// and items are the ones the mod registers, with the templates and numbers
/// the facts give; `allowed` says which vanilla blocks the game has.
pub fn carry(
jar: &Path,
info: &JarInfo,
out: &Path,
facts: Option<&Facts>,
allowed: &dyn Fn(&str) -> bool,
) -> Result<Report, String> {
let id = &info.mod_id;
if id.is_empty()
|| id.len() > 64
@@ -196,6 +320,7 @@ pub fn carry(jar: &Path, info: &JarInfo, out: &Path) -> Result<Report, String> {
let mut report = Report::default();
let mut blockstates: BTreeMap<String, Value> = BTreeMap::new();
let mut item_models = BTreeSet::new();
let mut convention = BTreeSet::new();
for i in 0..zip.len() {
let mut entry = zip.by_index(i).map_err(|e| e.to_string())?;
let name = entry.name().to_owned();
@@ -218,11 +343,17 @@ pub fn carry(jar: &Path, info: &JarInfo, out: &Path) -> Result<Report, String> {
};
if keep {
let rel = name.split_once(&format!("/{id}/")).map_or("", |(_, r)| r);
if name.starts_with("data/")
&& (rel.starts_with("worldgen/") || rel.starts_with("structure/"))
{
report.worldgen += 1;
}
if let Some(file) = rel
.strip_prefix("recipe/")
.filter(|_| name.starts_with("data/"))
{
if let Ok(mut recipe) = serde_json::from_slice::<Value>(&bytes) {
tags_used(&recipe, &mut convention);
if upgrade_recipe(&mut recipe) {
report.recipes_upgraded += 1;
bytes = serde_json::to_vec_pretty(&recipe).unwrap_or(bytes);
@@ -230,6 +361,15 @@ pub fn carry(jar: &Path, info: &JarInfo, out: &Path) -> Result<Report, String> {
report.recipes_kept.push(file.to_owned());
}
}
} else if rel.starts_with("loot_table/") && name.starts_with("data/") {
if let Ok(mut table) = serde_json::from_slice::<Value>(&bytes) {
let before = table.clone();
upgrade_loot(&mut table);
if table != before {
report.loot_tables_upgraded += 1;
bytes = serde_json::to_vec_pretty(&table).unwrap_or(bytes);
}
}
} else if let Some(b) = rel
.strip_prefix("blockstates/")
.and_then(|b| b.strip_suffix(".json"))
@@ -257,25 +397,116 @@ pub fn carry(jar: &Path, info: &JarInfo, out: &Path) -> Result<Report, String> {
}
}
let decl = inside.join(format!("data/{id}/horizon"));
for (b, state) in &blockstates {
match template(&properties(state)) {
Some(t) => {
write(
&decl.join(format!("block/{b}.json")),
json!({"template": t}).to_string().as_bytes(),
)?;
report.blocks.insert(b.clone(), t.to_owned());
let write_decl = |kind: &str, name: &str, v: &Value| {
let text = serde_json::to_vec_pretty(v).unwrap_or_default();
write(&decl.join(format!("{kind}/{name}.json")), &text)
};
if let Some(facts) = facts {
report.oracle = true;
let prefix = format!("{id}:");
let mut declared = BTreeSet::new();
for (full, block) in facts.blocks.range(prefix.clone()..) {
let Some(b) = full.strip_prefix(&prefix) else {
break;
};
let Some(choice) = facts.template(full, allowed) else {
let props: Vec<&str> = block.properties.keys().map(String::as_str).collect();
let why = format!(
"no vanilla {} with properties [{}]",
block.vanilla_class().rsplit('.').next().unwrap_or(""),
props.join(", ")
);
report.blocks_unknown.insert(b.to_owned(), why);
continue;
};
let mut v = json!({"template": choice.template, "properties": choice.properties});
if block.item == "minecraft:air" {
v["item"] = json!(false);
} else if block.item != *full {
v["item"] = json!(false);
report
.differences
.entry(b.to_owned())
.or_default()
.push(format!("its item is {}", block.item));
} else {
declared.insert(full.clone());
}
write_decl("block", b, &v)?;
report.blocks.insert(b.to_owned(), choice.template);
if !choice.differences.is_empty() {
report
.differences
.entry(b.to_owned())
.or_default()
.extend(choice.differences);
}
None => report.blocks_unknown.push(b.clone()),
}
}
for m in item_models.iter().filter(|m| !blockstates.contains_key(*m)) {
let item = json!({"template": "minecraft:stick"});
write(
&decl.join(format!("item/{m}.json")),
item.to_string().as_bytes(),
)?;
report.items += 1;
for (full, item) in facts.items.range(prefix.clone()..) {
let Some(name) = full.strip_prefix(&prefix) else {
break;
};
if declared.contains(full) {
continue;
}
if item
.block
.as_ref()
.is_some_and(|b| facts.blocks.contains_key(b))
&& report.blocks_unknown.contains_key(name)
{
report
.items_unknown
.insert(name.to_owned(), "its block is left out".into());
continue;
}
match facts.item(full) {
Ok((v, differences)) => {
write_decl("item", name, &v)?;
report.items += 1;
if !differences.is_empty() {
report.differences.insert(name.to_owned(), differences);
}
}
Err(e) => {
report.items_unknown.insert(name.to_owned(), e);
}
}
}
// Convention tags are NeoForge's and the pack's: the recipes get the
// members the oracle saw, those of vanilla and of this mod.
for tag in &convention {
let Some(path) = tag.strip_prefix("c:") else {
continue;
};
let file = inside.join(format!("data/c/tags/item/{path}.json"));
if file.exists() {
continue;
}
if let Some(members) = facts.tag_members("item", tag, id) {
let v = json!({"values": members});
write(&file, &serde_json::to_vec_pretty(&v).unwrap_or_default())?;
report.convention_tags += 1;
}
}
} else {
for (b, state) in &blockstates {
match template(b, &properties(state)) {
Some(t) => {
write_decl("block", b, &json!({"template": t}))?;
report.blocks.insert(b.clone(), t.to_owned());
}
None => {
let props: Vec<String> = properties(state).into_iter().collect();
let why = format!("no template for properties [{}]", props.join(", "));
report.blocks_unknown.insert(b.clone(), why);
}
}
}
for m in item_models.iter().filter(|m| !blockstates.contains_key(*m)) {
write_decl("item", m, &json!({"template": "minecraft:stick"}))?;
report.items += 1;
}
}
let q = |s: &str| toml::Value::String(s.to_owned()).to_string();
let name = if info.name.is_empty() { id } else { &info.name };
@@ -299,6 +530,30 @@ pub fn carry(jar: &Path, info: &JarInfo, out: &Path) -> Result<Report, String> {
Ok(report)
}
/// The tags a recipe's ingredients name (`#ns:path` or `{"tag": ...}`).
fn tags_used(v: &Value, out: &mut BTreeSet<String>) {
match v {
Value::String(s) => {
if let Some(t) = s.strip_prefix('#') {
out.insert(t.to_owned());
}
}
Value::Array(a) => a.iter().for_each(|x| tags_used(x, out)),
Value::Object(o) => {
for (k, x) in o {
match (k.as_str(), x) {
("tag", Value::String(t)) => {
out.insert(t.clone());
}
("result", _) => {}
_ => tags_used(x, out),
}
}
}
_ => {}
}
}
fn write(path: &Path, bytes: &[u8]) -> Result<(), String> {
if let Some(dir) = path.parent() {
fs::create_dir_all(dir).map_err(|e| format!("{}: {e}", dir.display()))?;
@@ -325,21 +580,86 @@ mod tests {
assert!(!upgrade_recipe(&mut tag_list));
}
#[test]
fn upgrades_loot_tables() {
let mut slab = json!({"type": "minecraft:block", "pools": [{"rolls": 1.0, "entries": [{
"type": "minecraft:item", "name": "m:slab",
"functions": [{"function": "minecraft:set_count", "count": 2.0, "add": false,
"conditions": [{"condition": "minecraft:block_state_property", "block": "m:slab",
"properties": {"type": "double"}}]},
{"function": "minecraft:explosion_decay"}]}]}]});
upgrade_loot(&mut slab);
assert_eq!(
slab["pools"][0]["entries"][0]["modifier"][0],
json!({"type": "minecraft:set_count", "count": 2.0, "add": false,
"condition": {"type": "minecraft:block_state_property", "block": "m:slab",
"properties": {"type": "double"}}})
);
let silk = json!({"condition": "minecraft:match_tool", "predicate": {"predicates": {
"minecraft:enchantments": [{"enchantments": "minecraft:silk_touch", "levels": {"min": 1}}]}}});
let shears = json!({"condition": "minecraft:match_tool", "predicate": {"items": "minecraft:shears"}});
let mut glass = json!({"pools": [{"conditions": [silk.clone()], "entries": []},
{"conditions": [{"condition": "minecraft:any_of", "terms": [silk, shears]},
{"condition": "minecraft:survives_explosion"}], "entries": []}]});
upgrade_loot(&mut glass);
assert_eq!(
glass["pools"][0]["condition"],
"minecraft:tool/can_silk_touch"
);
assert_eq!(
glass["pools"][1]["condition"],
json!({"type": "minecraft:all_of", "terms": [
{"type": "minecraft:any_of", "terms": ["minecraft:tool/can_silk_touch", "minecraft:tool/can_shear"]},
{"type": "minecraft:survives_explosion"}]})
);
// A loot table already in 26.3's shape stays as it is.
let mut new = glass.clone();
upgrade_loot(&mut new);
assert_eq!(new, glass);
}
#[test]
fn templates_from_blockstate_properties() {
let door =
json!({"variants": {"facing=east,half=lower,hinge=left,open=false,powered=false": {}}});
assert_eq!(template(&properties(&door)), Some("minecraft:oak_door"));
assert_eq!(
template("gem_door", &properties(&door)),
Some("minecraft:oak_door")
);
// Models that ignore `powered`: still a door.
let door = json!({"variants": {"facing=east,half=lower,hinge=left,open=false": {}}});
assert_eq!(
template("gem_door", &properties(&door)),
Some("minecraft:oak_door")
);
let trapdoor = json!({"variants": {"facing=east,half=top,open=false": {}}});
assert_eq!(
template("gem_trapdoor", &properties(&trapdoor)),
Some("minecraft:oak_trapdoor")
);
let sides = json!({"multipart": [{"when": {"north": "true"}}, {"when": {"east": "true"}},
{"when": {"south": "true"}}, {"when": {"west": "true"}}]});
assert_eq!(
template("gem_pane", &properties(&sides)),
Some("minecraft:glass_pane")
);
assert_eq!(
template("gem_fence", &properties(&sides)),
Some("minecraft:oak_fence")
);
let fence = json!({"multipart": [{"apply": {}}, {"when": {"north": "true"}, "apply": {}},
{"when": {"east": "true"}}, {"when": {"south": "true"}}, {"when": {"west": "true"}},
{"when": {"OR": [{"waterlogged": "true"}]}}]});
assert_eq!(template(&properties(&fence)), Some("minecraft:oak_fence"));
assert_eq!(
template(&properties(&json!({"variants": {"": {}}}))),
template("gem_fence", &properties(&fence)),
Some("minecraft:oak_fence")
);
assert_eq!(
template("gem_block", &properties(&json!({"variants": {"": {}}}))),
Some("minecraft:stone")
);
let odd = json!({"variants": {"charge=1,mode=fast": {}}});
assert_eq!(template(&properties(&odd)), None);
assert_eq!(template("gem_core", &properties(&odd)), None);
}
/// A small NeoForge jar carried over is a content mod Horizon loads.
@@ -411,14 +731,17 @@ mod tests {
);
assert_eq!(info.census.classes, 1);
let out = dir.join("work/mods/gem");
let report = carry(&jar, &info, &out).unwrap();
assert_eq!(report.copied, 11);
assert_eq!(report.outside, ["data/c/tags/item/gems.json"]);
let report = carry(&jar, &info, &out, None, &|_| true).unwrap();
assert_eq!(report.copied, 12);
assert!(report.outside.is_empty());
assert_eq!((report.recipes_upgraded, report.recipes_kept.len()), (1, 1));
assert_eq!(report.item_definitions_added, 2);
assert_eq!(report.blocks["gem_door"], "minecraft:oak_door");
assert_eq!(report.blocks["gem_block"], "minecraft:stone");
assert_eq!(report.blocks_unknown, ["gem_core"]);
assert_eq!(
report.blocks_unknown.keys().collect::<Vec<_>>(),
["gem_core"]
);
assert_eq!(report.items, 1);
let carried = out.join("carry");
assert!(!carried.join("com").exists());
+88 -2
View File
@@ -1,5 +1,6 @@
//! Step 1, import: a Modrinth `.mrpack`, a CurseForge zip, or an instance
//! folder (Prism / MultiMC, or a plain `mods/` folder) to `pack.json`.
//! Step 1, import: a Modrinth `.mrpack`, a CurseForge zip, an instance
//! folder (Prism / MultiMC, or a plain `mods/` folder), or a Crash Assistant
//! `modlist.json` (the list packs such as ATM10 publish) to `pack.json`.
use serde::{Deserialize, Serialize};
use serde_json::Value;
use std::{
@@ -37,6 +38,13 @@ pub struct PackFile {
/// CurseForge project and file ids.
#[serde(default, skip_serializing_if = "Option::is_none")]
pub curseforge: Option<(u64, u64)>,
/// The mod id, name and version a mod list states (`modlist.json`).
#[serde(default, skip_serializing_if = "Option::is_none")]
pub mod_id: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub version: Option<String>,
/// The jar on disk (instances only).
#[serde(default, skip_serializing_if = "Option::is_none")]
pub jar: Option<PathBuf>,
@@ -63,6 +71,12 @@ pub fn import(path: &Path) -> Result<Pack, String> {
if path.is_dir() {
return instance(path);
}
if path.extension().is_some_and(|e| e == "json") {
let text = fs::read_to_string(path).map_err(|e| format!("{}: {e}", path.display()))?;
let list: Value = serde_json::from_str(text.trim_start_matches('\u{feff}'))
.map_err(|e| format!("{}: {e}", path.display()))?;
return modlist(&list);
}
let file = fs::File::open(path).map_err(|e| format!("{}: {e}", path.display()))?;
let mut zip = zip::ZipArchive::new(file).map_err(|e| format!("{}: {e}", path.display()))?;
if let Some(index) = read_json(&mut zip, "modrinth.index.json")? {
@@ -186,6 +200,54 @@ pub fn curseforge(manifest: &Value, names: &[String]) -> Pack {
}
}
/// Crash Assistant's `config/crash_assistant/modlist.json`: jar name → mod
/// id, name, version and Modrinth SHA-1, with the loader as an entry of its
/// own. NeoForge `21.1.x` runs Minecraft 1.21.1.
pub fn modlist(list: &Value) -> Result<Pack, String> {
let entries = list.as_object().ok_or("modlist.json: not an object")?;
let mut pack = Pack {
name: "modlist".into(),
format: "modlist".into(),
..Pack::default()
};
for (key, e) in entries {
let jar = e["jarName"].as_str().unwrap_or(key);
if jar.ends_with("(modloader)") {
let version = str_of(e, "version");
let (loader, v) = version.split_once('-').unwrap_or(("", &version));
pack.loader = loader.to_owned();
pack.loader_version = v.to_owned();
if loader == "neoforge" {
let mut parts = v.split('.');
if let (Some(a), Some(b)) = (parts.next(), parts.next()) {
pack.minecraft = if b == "0" {
format!("1.{a}")
} else {
format!("1.{a}.{b}")
};
}
}
continue;
}
let folder = if jar.ends_with(".zip") {
"datapacks"
} else {
"mods"
};
let text = |k: &str| e[k].as_str().filter(|v| !v.is_empty()).map(str::to_owned);
pack.files.push(PackFile {
path: format!("{folder}/{jar}"),
sha1: text("modrinthHash"),
mod_id: text("modId"),
name: text("name"),
version: text("version"),
..PackFile::default()
});
}
pack.files.sort_by(|a, b| a.path.cmp(&b.path));
Ok(pack)
}
/// A Prism / MultiMC instance (`mmc-pack.json`), a game folder, or a
/// folder of jars: the jars on disk, hashed.
fn instance(dir: &Path) -> Result<Pack, String> {
@@ -319,6 +381,30 @@ mod tests {
);
}
#[test]
fn reads_a_crash_assistant_mod_list() {
let list = serde_json::json!({
"neoforge-21.1.259 (modloader)": {"jarName": "neoforge-21.1.259 (modloader)",
"modId": "neoforge", "version": "neoforge-21.1.259"},
"mcw-doors-1.1.2.jar": {"jarName": "mcw-doors-1.1.2.jar", "modId": "mcwdoors",
"modrinthHash": "0123456789abcdef0123456789abcdef01234567"},
"sawmill.zip": {"jarName": "sawmill.zip"}
});
let pack = modlist(&list).unwrap();
assert_eq!(
(
pack.minecraft.as_str(),
pack.loader.as_str(),
pack.loader_version.as_str()
),
("1.21.1", "neoforge", "21.1.259")
);
let paths: Vec<&str> = pack.files.iter().map(|f| f.path.as_str()).collect();
assert_eq!(paths, ["datapacks/sawmill.zip", "mods/mcw-doors-1.1.2.jar"]);
assert!(pack.files[1].sha1.is_some());
assert_eq!(pack.files[1].mod_id.as_deref(), Some("mcwdoors"));
}
#[test]
fn reads_a_curseforge_manifest() {
let manifest = json!({"name": "CF", "overrides": "overrides",
+7 -3
View File
@@ -78,6 +78,7 @@ pub fn build(pack: &Pack, cache: &Cache, work: &Path) -> Vec<Record> {
.as_ref()
.map(|i| i.mod_id.clone())
.filter(|k| !k.is_empty())
.or_else(|| f.mod_id.clone())
.or_else(|| Some(p("slug")).filter(|s| !s.is_empty()))
.unwrap_or(stem);
let (client, server) = match project {
@@ -97,7 +98,9 @@ pub fn build(pack: &Pack, cache: &Cache, work: &Path) -> Vec<Record> {
.as_ref()
.map(|i| i.name.clone())
.filter(|n| !n.is_empty())
.unwrap_or_else(|| p("title"));
.or_else(|| Some(p("title")).filter(|t| !t.is_empty()))
.or_else(|| f.name.clone())
.unwrap_or_default();
let (class, tier, confidence) =
match known.get(&[key.as_str(), p("slug").as_str(), name.as_str()]) {
Some((c, t)) => (c.clone(), t.clone(), "known".to_owned()),
@@ -123,8 +126,9 @@ pub fn build(pack: &Pack, cache: &Cache, work: &Path) -> Vec<Record> {
.versions
.get(sha1)
.and_then(|v| v["version_number"].as_str())
.unwrap_or("")
.to_owned()
.map(str::to_owned)
.or_else(|| f.version.clone())
.unwrap_or_default()
}),
path: f.path.clone(),
class,
+16
View File
@@ -50,6 +50,12 @@ pub fn read(path: &Path) -> Result<JarInfo, String> {
} else {
JarInfo::default()
};
// `version = "${file.jarVersion}"` is filled in from the manifest at load.
if info.version.starts_with("${") {
info.version = text(&mut zip, "META-INF/MANIFEST.MF")
.and_then(|m| manifest_value(&m, "Implementation-Version"))
.unwrap_or_default();
}
let names: Vec<String> = zip.file_names().map(str::to_owned).collect();
info.census = census(&names);
if info.mod_id.is_empty() {
@@ -61,6 +67,16 @@ pub fn read(path: &Path) -> Result<JarInfo, String> {
Ok(info)
}
/// A main-section attribute of `META-INF/MANIFEST.MF`.
fn manifest_value(manifest: &str, key: &str) -> Option<String> {
manifest
.lines()
.take_while(|l| !l.trim().is_empty())
.find_map(|l| l.strip_prefix(key)?.strip_prefix(':'))
.map(|v| v.trim().to_owned())
.filter(|v| !v.is_empty())
}
/// `[[mods]]` (the first one is the jar's mod), the top-level `license`, and
/// `[[dependencies.<id>]]` with `type = "required"` (or the older
/// `mandatory = true`).
+78 -7
View File
@@ -6,8 +6,15 @@
//! `<work>/modrinth.json`), the jars in the instance or `<work>/jars/`,
//! classes, tiers and dependency layers in `<work>/inventory.json` and
//! `inventory.csv`.
//! - `carry <work> [<mod id>...]`: the content mods' data and assets into
//! `<work>/mods/<id>/carry/`, a folder mod for local use.
//! - `carry <work> [--resources <prepared>] [<mod id>...]`: the content
//! mods' data and assets into `<work>/mods/<id>/carry/`, a folder mod for
//! local use. With the NeoForge oracle's `<work>/oracle/facts.json`
//! (`tools/neoforge_oracle.py`), blocks and items come from its facts;
//! `--resources` limits templates to the blocks Horizon's tables have.
//!
//! - `report <work>`: the coverage report, per mod ported, partial, not yet
//! or not needed with the reason, in `<work>/coverage.json` and
//! `coverage.md`.
//!
//! The work folder belongs to the user: jars and carried-over files stay
//! there and are never uploaded or committed.
@@ -17,10 +24,12 @@ mod import;
mod inventory;
mod jar;
mod modrinth;
mod oracle;
mod report;
use std::{fs, path::Path, process::ExitCode};
const USAGE: &str = "usage: horizon-port-pack import <pack> <work> | inventory <work> [--offline] | carry <work> [<mod id>...]";
const USAGE: &str = "usage: horizon-port-pack import <pack> <work> | inventory <work> [--offline] | carry <work> [--resources <prepared>] [<mod id>...] | report <work>";
fn main() -> ExitCode {
let args: Vec<String> = std::env::args().skip(1).collect();
@@ -32,7 +41,20 @@ fn main() -> ExitCode {
Some("inventory") => {
path(1).and_then(|w| inventory(w, args.iter().any(|a| a == "--offline")))
}
Some("carry") => path(1).and_then(|w| carry(w, &args[2..])),
Some("carry") => path(1).and_then(|w| {
let mut rest = args[2..].to_vec();
let resources = match rest.iter().position(|a| a == "--resources") {
Some(i) if i + 1 < rest.len() => {
let r = rest.remove(i + 1);
rest.remove(i);
Some(std::path::PathBuf::from(r))
}
Some(_) => return Err(USAGE.to_owned()),
None => None,
};
carry(w, resources.as_deref(), &rest)
}),
Some("report") => path(1).and_then(report),
_ => Err(USAGE.to_owned()),
};
match result {
@@ -54,6 +76,22 @@ fn read_json<T: serde::de::DeserializeOwned>(path: &Path) -> Result<T, String> {
serde_json::from_str(&text).map_err(|e| format!("{}: {e}", path.display()))
}
fn report(work: &Path) -> Result<(), String> {
let pack: import::Pack = read_json(&work.join("pack.json"))?;
let records: Vec<inventory::Record> = read_json(&work.join("inventory.json"))?;
let rows = report::build(&records, work);
write_json(&work.join("coverage.json"), &rows)?;
let title = format!(
"{} ({} {}, Minecraft {})",
pack.name, pack.loader, pack.loader_version, pack.minecraft
);
fs::write(work.join("coverage.md"), report::markdown(&title, &rows))
.map_err(|e| format!("coverage.md: {e}"))?;
println!("{title}: {} files: {:?}", rows.len(), report::counts(&rows));
println!("{}", work.join("coverage.md").display());
Ok(())
}
fn import(pack: &Path, work: &Path) -> Result<(), String> {
let pack = import::import(pack)?;
fs::create_dir_all(work).map_err(|e| format!("{}: {e}", work.display()))?;
@@ -107,8 +145,31 @@ fn inventory(work: &Path, offline: bool) -> Result<(), String> {
Ok(())
}
fn carry(work: &Path, only: &[String]) -> Result<(), String> {
/// The vanilla blocks a prepared resource root has (`facts.json`'s defaults).
fn vanilla_blocks(resources: &Path) -> Result<std::collections::BTreeSet<String>, String> {
let facts: serde_json::Value = read_json(&resources.join("facts.json"))?;
let defaults = facts["defaults"]
.as_object()
.ok_or("facts.json: no defaults")?;
Ok(defaults.keys().cloned().collect())
}
fn carry(work: &Path, resources: Option<&Path>, only: &[String]) -> Result<(), String> {
let records: Vec<inventory::Record> = read_json(&work.join("inventory.json"))?;
let facts_path = work.join("oracle/facts.json");
let facts = if facts_path.exists() {
let f = oracle::Facts::read(&facts_path)?;
println!(
"oracle facts: {} blocks, {} items",
f.blocks.len(),
f.items.len()
);
Some(f)
} else {
None
};
let vanilla = resources.map(vanilla_blocks).transpose()?;
let allowed = |b: &str| vanilla.as_ref().is_none_or(|v| v.contains(b));
let mut done = 0;
for r in &records {
let chosen = if only.is_empty() {
@@ -125,19 +186,29 @@ fn carry(work: &Path, only: &[String]) -> Result<(), String> {
if !chosen {
continue;
}
match carry::carry(jar, info, &work.join("mods").join(&r.key)) {
match carry::carry(
jar,
info,
&work.join("mods").join(&r.key),
facts.as_ref(),
&allowed,
) {
Ok(report) => {
done += 1;
println!(
"{}: {} files, {} recipes upgraded ({} kept), {} item definitions added, {} blocks ({} without a template), {} items, {} outside",
"{}: {} files, {} recipes upgraded ({} kept), {} loot tables upgraded, {} item definitions added, {} blocks ({} left out, {} with differences), {} items ({} left out), {} convention tags, {} outside",
r.key,
report.copied,
report.recipes_upgraded,
report.recipes_kept.len(),
report.loot_tables_upgraded,
report.item_definitions_added,
report.blocks.len(),
report.blocks_unknown.len(),
report.differences.len(),
report.items,
report.items_unknown.len(),
report.convention_tags,
report.outside.len()
);
}
+384
View File
@@ -0,0 +1,384 @@
//! The NeoForge oracle's facts (`tools/neoforge_oracle.py export`, in
//! `<work>/oracle/facts.json`): every block, item, recipe and tag the pack's
//! mods register, read from the running game, and the vanilla blocks beside
//! them. Carry-over uses them in place of guesses: a block's template is the
//! vanilla block of the same class and states whose shapes and sounds match
//! best, and the declared properties are the mod's own numbers.
use serde::Deserialize;
use serde_json::{Map, Value, json};
use std::{
collections::{BTreeMap, BTreeSet},
path::Path,
};
#[derive(Debug, Deserialize)]
pub struct Facts {
pub blocks: BTreeMap<String, Block>,
pub items: BTreeMap<String, Item>,
#[serde(default)]
pub tags: Tags,
}
#[derive(Debug, Default, Deserialize)]
pub struct Tags {
#[serde(default)]
pub block: BTreeMap<String, Vec<String>>,
#[serde(default)]
pub item: BTreeMap<String, Vec<String>>,
}
#[derive(Debug, Deserialize)]
pub struct Block {
/// The class and its superclasses, most derived first.
pub class: Vec<String>,
pub properties: BTreeMap<String, Vec<String>>,
pub default: String,
pub item: String,
pub explosion_resistance: f32,
pub friction: f32,
pub speed_factor: f32,
pub jump_factor: f32,
#[serde(default)]
pub block_set_type: Option<SetType>,
#[serde(default)]
pub wood_type: Option<String>,
pub states: BTreeMap<String, State>,
}
#[derive(Debug, Deserialize)]
pub struct SetType {
pub name: String,
pub can_open_by_hand: bool,
}
#[derive(Debug, Deserialize)]
pub struct State {
pub hardness: f32,
pub emission: u8,
pub requires_tool: bool,
pub map_color_id: u8,
pub sound: Value,
pub outline: Value,
pub collision: Value,
}
#[derive(Debug, Deserialize)]
pub struct Item {
pub class: String,
pub max_stack_size: u8,
pub rarity: String,
#[serde(default)]
pub block: Option<String>,
#[serde(default)]
pub food: Option<Value>,
}
const VANILLA_PACKAGE: &str = "net.minecraft.";
/// A state key with its properties sorted, so keys compare across blocks.
pub fn state_key(key: &str) -> String {
let mut parts: Vec<&str> = key.split(',').filter(|p| !p.is_empty()).collect();
parts.sort_unstable();
parts.join(",")
}
impl Block {
/// The first vanilla class in the chain.
pub fn vanilla_class(&self) -> &str {
self.class
.iter()
.find(|c| c.starts_with(VANILLA_PACKAGE))
.map_or("", String::as_str)
}
/// Its own class is a mod class: behaviour code the template may not have.
pub fn custom_class(&self) -> bool {
self.class
.first()
.is_some_and(|c| !c.starts_with(VANILLA_PACKAGE))
}
fn default_state(&self) -> Option<&State> {
self.states
.get(&self.default)
.or_else(|| self.states.values().next())
}
fn same_states(&self, other: &Block) -> bool {
self.properties.len() == other.properties.len()
&& self.properties.iter().all(|(k, v)| {
other.properties.get(k).is_some_and(|w| {
v.iter().collect::<BTreeSet<_>>() == w.iter().collect::<BTreeSet<_>>()
})
})
}
fn by_key(&self) -> BTreeMap<String, &State> {
self.states.iter().map(|(k, s)| (state_key(k), s)).collect()
}
}
/// The template carry-over gives a mod block.
#[derive(Debug, Clone, PartialEq)]
pub struct Choice {
pub template: String,
/// `data/<mod>/horizon/block/<name>.json`'s `properties`.
pub properties: Map<String, Value>,
/// What the template does not reproduce, for the report.
pub differences: Vec<String>,
}
impl Facts {
pub fn read(path: &Path) -> Result<Facts, String> {
let bytes = std::fs::read(path).map_err(|e| format!("{}: {e}", path.display()))?;
serde_json::from_slice(&bytes).map_err(|e| format!("{}: {e}", path.display()))
}
/// The vanilla block that best stands in for `id`: the same vanilla
/// class and states, then the most states with the same outline and
/// collision, then the same sounds, set type, wood type and hardness.
/// `None` when no vanilla block has its class and states.
pub fn template(&self, id: &str, allowed: &dyn Fn(&str) -> bool) -> Option<Choice> {
let block = self.blocks.get(id)?;
let class = block.vanilla_class();
let own = block.by_key();
let ours = block.default_state()?;
let mut best: Option<(i64, &str, &Block)> = None;
for (name, v) in &self.blocks {
if !name.starts_with("minecraft:")
|| v.vanilla_class() != class
|| v.custom_class()
|| !block.same_states(v)
|| !allowed(name)
{
continue;
}
let theirs = v.by_key();
let shapes = own
.iter()
.filter(|(k, s)| {
theirs
.get(*k)
.is_some_and(|t| t.outline == s.outline && t.collision == s.collision)
})
.count() as i64;
let Some(td) = v.default_state() else {
continue;
};
let same_set = match (&block.block_set_type, &v.block_set_type) {
(Some(a), Some(b)) => {
(a.name == b.name) as i64 * 2
+ (a.can_open_by_hand == b.can_open_by_hand) as i64 * 8
}
_ => 0,
};
let score = shapes * 1000
+ (td.sound == ours.sound) as i64 * 100
+ same_set * 10
+ (block.wood_type.is_some() && block.wood_type == v.wood_type) as i64 * 20
+ (td.hardness == ours.hardness) as i64 * 5
+ (td.map_color_id == ours.map_color_id) as i64;
if best.is_none_or(|(s, n, _)| score > s || (score == s && name.as_str() < n)) {
best = Some((score, name, v));
}
}
let (_, template, t) = best?;
Some(self.choice(block, template, t, allowed))
}
fn choice(
&self,
block: &Block,
template: &str,
t: &Block,
allowed: &dyn Fn(&str) -> bool,
) -> Choice {
let (ours, theirs) = (block.default_state(), t.default_state());
let mut properties = Map::new();
let mut differences = Vec::new();
if let Some(s) = ours {
properties.insert("hardness".into(), json!(s.hardness));
properties.insert(
"explosion_resistance".into(),
json!(block.explosion_resistance),
);
properties.insert("light".into(), json!(s.emission));
properties.insert("requires_tool".into(), json!(s.requires_tool));
properties.insert("friction".into(), json!(block.friction));
properties.insert("map_color".into(), json!(s.map_color_id));
if theirs.is_none_or(|t| t.sound != s.sound) {
match self.sound_block(&s.sound, allowed) {
Some(b) => {
properties.insert("sounds".into(), json!(b));
}
None => differences.push("sounds: no vanilla block has them".into()),
}
}
}
if (block.speed_factor, block.jump_factor) != (t.speed_factor, t.jump_factor) {
differences.push(format!(
"speed and jump factors {} {} (template {} {})",
block.speed_factor, block.jump_factor, t.speed_factor, t.jump_factor
));
}
let theirs = t.by_key();
let mut shapes = 0;
let mut varying = BTreeSet::new();
let first = ours.map(|s| (s.hardness, s.emission, s.requires_tool, s.map_color_id));
for (k, s) in block.by_key() {
let Some(v) = theirs.get(&k) else {
continue;
};
if v.outline != s.outline || v.collision != s.collision {
shapes += 1;
}
if Some((s.hardness, s.emission, s.requires_tool, s.map_color_id)) != first {
varying.insert("per-state hardness, light or map colour");
}
}
if shapes > 0 {
differences.push(format!(
"shapes differ from {template} in {shapes} of {} states",
block.states.len()
));
}
differences.extend(varying.into_iter().map(str::to_owned));
if block.custom_class() {
differences.push(format!(
"class {} (behaviour beyond {})",
block.class[0],
block.vanilla_class()
));
}
Choice {
template: template.to_owned(),
properties,
differences,
}
}
/// A vanilla block whose default state has these sounds.
fn sound_block(&self, sound: &Value, allowed: &dyn Fn(&str) -> bool) -> Option<&str> {
self.blocks
.iter()
.filter(|(n, _)| n.starts_with("minecraft:") && allowed(n))
.find(|(_, b)| b.default_state().is_some_and(|s| &s.sound == sound))
.map(|(n, _)| n.as_str())
}
/// An item declaration for a mod item that is not a declared block's:
/// a vanilla template item with its stack size and rarity, and what it
/// does not reproduce.
pub fn item(&self, id: &str) -> Result<(Value, Vec<String>), String> {
let item = self.items.get(id).ok_or("not in the oracle")?;
if item.block.is_some() {
return Err("a block item without a block".into());
}
let mut differences = Vec::new();
if !item.class.starts_with(VANILLA_PACKAGE) {
differences.push(format!("class {} (behaviour beyond Item)", item.class));
}
if item.food.is_some() {
return Err("food (no food template yet)".into());
}
let mut decl = json!({"template": "minecraft:stick"});
if item.max_stack_size != 64 {
decl["max_stack_size"] = json!(item.max_stack_size);
}
if item.rarity != "common" {
decl["rarity"] = json!(item.rarity);
}
Ok((decl, differences))
}
/// A tag's members the content mod may name: vanilla's and its own.
pub fn tag_members(&self, kind: &str, tag: &str, own: &str) -> Option<Vec<String>> {
let map = if kind == "block" {
&self.tags.block
} else {
&self.tags.item
};
let members = map.get(tag)?;
Some(
members
.iter()
.filter(|m| {
m.split_once(':')
.is_some_and(|(ns, _)| ns == "minecraft" || ns == own)
})
.cloned()
.collect(),
)
}
}
#[cfg(test)]
mod tests {
use super::*;
fn state(hardness: f32, sound: &str, outline: Value) -> Value {
json!({"hardness": hardness, "emission": 0, "requires_tool": false, "map_color_id": 13,
"sound": {"break": sound}, "outline": outline, "collision": outline})
}
fn block(class: &[&str], props: Value, states: Value) -> Value {
let default = states
.as_object()
.unwrap()
.keys()
.next()
.unwrap()
.to_owned();
json!({"class": class, "properties": props, "default": default, "item": "x",
"explosion_resistance": 3.0, "friction": 0.6, "speed_factor": 1.0,
"jump_factor": 1.0, "states": states})
}
#[test]
fn templates_follow_class_shapes_and_sounds() {
let cube = json!([[0, 0, 0, 1, 1, 1]]);
let low = json!([[0, 0, 0, 1, 0.9375, 1]]);
let block_class = ["net.minecraft.world.level.block.Block"];
let path = ["net.minecraft.world.level.block.DirtPathBlock"];
let facts: Facts = serde_json::from_value(json!({
"blocks": {
"minecraft:stone": block(&block_class, json!({}), json!({"": state(1.5, "stone", cube.clone())})),
"minecraft:oak_planks": block(&block_class, json!({}), json!({"": state(2.0, "wood", cube.clone())})),
"minecraft:dirt_path": block(&path, json!({}), json!({"": state(0.65, "grass", low.clone())})),
"m:wood_tile": block(&["m.Tile", block_class[0]], json!({}), json!({"": state(2.5, "wood", cube.clone())})),
"m:path": block(&["m.Path", block_class[0]], json!({}), json!({"": state(1.0, "stone", low.clone())})),
"m:gadget": block(&["m.Gadget", block_class[0]], json!({"mode": ["a", "b"]}),
json!({"mode=a": state(1.0, "stone", cube.clone()), "mode=b": state(1.0, "stone", cube)})),
},
"items": {}
}))
.unwrap();
let any = |_: &str| true;
let tile = facts.template("m:wood_tile", &any).unwrap();
assert_eq!(tile.template, "minecraft:oak_planks");
assert_eq!(tile.properties["hardness"], json!(2.5));
assert!(!tile.properties.contains_key("sounds"));
assert_eq!(
tile.differences,
["class m.Tile (behaviour beyond net.minecraft.world.level.block.Block)"]
);
// A plain Block is never templated on a DirtPathBlock: shapes differ, and say so.
let path = facts.template("m:path", &any).unwrap();
assert_eq!(path.template, "minecraft:stone");
assert!(
path.differences[0].starts_with("shapes differ"),
"{:?}",
path.differences
);
assert_eq!(facts.template("m:gadget", &any), None);
let tile = facts
.template("m:wood_tile", &|n: &str| n != "minecraft:oak_planks")
.unwrap();
assert_eq!(tile.template, "minecraft:stone");
assert_eq!(tile.differences[0], "sounds: no vanilla block has them");
}
#[test]
fn state_keys_sort() {
assert_eq!(
state_key("half=lower,facing=north"),
"facing=north,half=lower"
);
assert_eq!(state_key(""), "");
}
}
+428
View File
@@ -0,0 +1,428 @@
//! Step 7, the coverage report: per mod, ported, partial, not yet or not
//! needed, with the reason, and the totals by class, tier and licence
//! (`coverage.json`, `coverage.md`). It reads what the other steps wrote:
//! the inventory, each mod's `carry-report.json` and its harness result
//! (`tools/mod_port_harness.py`).
use crate::inventory::Record;
use serde::{Deserialize, Serialize};
use serde_json::Value;
use std::{collections::BTreeMap, fmt::Write, path::Path};
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)]
#[serde(rename_all = "kebab-case")]
pub enum Status {
Ported,
Partial,
NotYet,
NotNeeded,
}
impl Status {
pub const ALL: [Status; 4] = [
Status::Ported,
Status::Partial,
Status::NotYet,
Status::NotNeeded,
];
pub fn label(self) -> &'static str {
match self {
Status::Ported => "ported",
Status::Partial => "partial",
Status::NotYet => "not yet",
Status::NotNeeded => "not needed",
}
}
}
#[derive(Debug, Serialize, Deserialize)]
pub struct Row {
pub key: String,
pub name: String,
pub class: String,
pub tier: String,
pub license: String,
/// `permissive`, `copyleft`, `all-rights-reserved`, `restricted`
/// (non-commercial or no-derivatives), `custom` or `unknown`.
pub license_kind: String,
pub status: Status,
pub reason: String,
}
/// The licence family of an SPDX id or a `mods.toml` licence text.
pub fn license_kind(license: &str) -> &'static str {
let l = license.to_ascii_lowercase();
if l.is_empty() || l.starts_with("unknown") {
"unknown"
} else if l.contains("-nc") || l.contains("-nd") || l.contains("noncommercial") {
"restricted"
} else if l.contains("all-rights-reserved") || l.contains("all rights reserved") || l == "arr" {
"all-rights-reserved"
} else if ["gpl", "mpl", "eupl", "general public"]
.iter()
.any(|k| l.contains(k))
{
"copyleft"
} else if [
"mit",
"apache",
"bsd",
"cc0",
"cc-by",
"unlicense",
"isc",
"zlib",
]
.iter()
.any(|k| l.contains(k))
{
"permissive"
} else {
"custom"
}
}
/// What still blocks a mod of this tier that has not been carried over.
fn not_yet(tier: &str) -> &'static str {
match tier {
"data" => "data tier: carry-over only, no agent; its jar is not in the work folder",
"logic" => {
"needs mod API 0.3: behaviour callbacks (use, place, break, ticks) and server events"
}
"machines" => "needs mod API 0.4: block entities, menus, capabilities and mod networking",
"deep" => {
"needs mod API 0.5: entities, custom renderers and models, dimensions, new vanilla hooks"
}
"client" => "needs the client interfaces (keys, target, inventory-read, ui, render)",
_ => "not classified",
}
}
fn not_needed(class: &str) -> &'static str {
match class {
"library" => "library: its API maps to Horizon's mod API and SDK",
"performance" => "performance mod: Horizon's engine is the replacement",
"other" => "pack tooling or an engine feature, folded into the pipeline or the engine",
"client-ui" => "built into Horizon",
_ => "nothing to port",
}
}
/// A carried-over mod: ported when its harness passes with nothing left
/// out and nothing the templates miss; else partial, with what is missing.
fn carried(work: &Path, key: &str) -> Option<(Status, String)> {
let dir = work.join("mods").join(key);
let carry: Value =
serde_json::from_slice(&std::fs::read(dir.join("carry-report.json")).ok()?).ok()?;
let count = |k: &str| carry[k].as_object().map_or(0, |o| o.len());
let (blocks, items) = (count("blocks"), carry["items"].as_u64().unwrap_or(0));
let (left_blocks, left_items) = (count("blocks_unknown"), count("items_unknown"));
// A class of its own is code the facts cannot show; anything else the
// template misses (shapes, sounds) the harness also reports.
let mut differences = 0;
let mut own_code = 0;
for list in carry["differences"]
.as_object()
.into_iter()
.flatten()
.map(|(_, v)| v)
{
let notes: Vec<&str> = list
.as_array()
.into_iter()
.flatten()
.filter_map(Value::as_str)
.collect();
if notes.iter().any(|n| n.starts_with("class ")) {
own_code += 1;
}
if notes.iter().any(|n| !n.starts_with("class ")) {
differences += 1;
}
}
let mut gaps = Vec::new();
if left_blocks > 0 {
gaps.push(format!(
"{left_blocks} blocks left out (no vanilla template)"
));
}
if left_items > 0 {
gaps.push(format!("{left_items} items left out"));
}
if differences > 0 {
gaps.push(format!(
"{differences} blocks or items differ from their templates"
));
}
let harness: Option<Value> = std::fs::read(dir.join("harness/result.json"))
.ok()
.and_then(|b| serde_json::from_slice(&b).ok());
let mut checked = 0;
match &harness {
Some(h) => {
for (name, c) in h["checks"].as_object().into_iter().flatten() {
let (p, f) = (
c["passed"].as_u64().unwrap_or(0),
c["failed"].as_u64().unwrap_or(0),
);
checked += p + f;
if f > 0 {
gaps.push(format!("{name} {p}/{}", p + f));
}
}
}
None => gaps.push("harness not run".into()),
}
let worldgen = carry["worldgen"].as_u64().unwrap_or(0);
if blocks == 0 && items == 0 && checked == 0 {
let what = if worldgen > 0 {
format!("{worldgen} worldgen files carried, not compared yet")
} else {
"nothing registered to compare".into()
};
return Some((Status::Partial, what));
}
let mut summary = format!("{blocks} blocks, {items} items");
if own_code > 0 {
let _ = write!(
summary,
" ({own_code} with code of their own, not compared)"
);
}
if gaps.is_empty() {
Some((Status::Ported, format!("{summary}; harness green")))
} else {
Some((Status::Partial, format!("{summary}; {}", gaps.join("; "))))
}
}
pub fn build(records: &[Record], work: &Path) -> Vec<Row> {
let mut rows: Vec<Row> = records
.iter()
.map(|r| {
let (status, reason) = if r.class == "unknown" {
let why =
"unclassified: its jar (mods.toml, file census) or a reviewed row decides";
(Status::NotYet, why.to_owned())
} else if r.tier == "none" || matches!(r.class.as_str(), "library" | "performance") {
(Status::NotNeeded, not_needed(&r.class).to_owned())
} else if let Some(c) = carried(work, &r.key) {
c
} else {
let mut why = not_yet(&r.tier).to_owned();
if r.tier == "data" && r.jar.is_some() {
why = "data tier: carry-over not run yet".into();
}
if r.class == "integration" {
why = format!("after the mods it joins are ported; {why}");
}
(Status::NotYet, why)
};
Row {
key: r.key.clone(),
name: r.name.clone(),
class: r.class.clone(),
tier: r.tier.clone(),
license: r.license.clone(),
license_kind: license_kind(&r.license).to_owned(),
status,
reason,
}
})
.collect();
// A mod waits on its dependencies that are not ported.
let status: BTreeMap<String, Status> = rows.iter().map(|r| (r.key.clone(), r.status)).collect();
for (row, r) in rows.iter_mut().zip(records) {
if row.status == Status::NotNeeded {
continue;
}
let waiting: Vec<&str> = r
.depends
.iter()
.filter(|d| status.get(*d) == Some(&Status::NotYet))
.map(String::as_str)
.collect();
if !waiting.is_empty() {
let _ = write!(row.reason, "; waits on {}", waiting.join(", "));
}
}
rows
}
/// Rows counted by `field` and status.
fn table(rows: &[Row], title: &str, field: fn(&Row) -> &str) -> String {
let mut counts: BTreeMap<&str, [usize; 4]> = BTreeMap::new();
for r in rows {
let i = Status::ALL.iter().position(|s| *s == r.status).unwrap_or(0);
counts.entry(field(r)).or_default()[i] += 1;
}
let mut out = format!(
"| {title} | ported | partial | not yet | not needed | all |\n|---|---:|---:|---:|---:|---:|\n"
);
let mut totals = [0usize; 4];
for (k, c) in &counts {
let all: usize = c.iter().sum();
let _ = writeln!(
out,
"| {k} | {} | {} | {} | {} | {all} |",
c[0], c[1], c[2], c[3]
);
for (t, n) in totals.iter_mut().zip(c) {
*t += n;
}
}
let all: usize = totals.iter().sum();
let _ = writeln!(
out,
"| **all** | **{}** | **{}** | **{}** | **{}** | **{all}** |",
totals[0], totals[1], totals[2], totals[3]
);
out
}
pub fn markdown(pack: &str, rows: &[Row]) -> String {
let mut out = format!("# Coverage: {pack}\n\n");
out += &table(rows, "class", |r| &r.class);
out += "\n";
out += &table(rows, "tier", |r| &r.tier);
out += "\n";
out += &table(rows, "licence", |r| &r.license_kind);
out += "\nPorts stay local. Only permissive or copyleft ports could ever be published, and only after Ludovic asks the authors.\n\n";
out += "| mod | class | tier | licence | status | why |\n|---|---|---|---|---|---|\n";
let mut sorted: Vec<&Row> = rows.iter().collect();
sorted.sort_by(|a, b| (a.status, &a.key).cmp(&(b.status, &b.key)));
for r in sorted {
let _ = writeln!(
out,
"| {} | {} | {} | {} | {} | {} |",
r.key,
r.class,
r.tier,
r.license.replace('|', "/"),
r.status.label(),
r.reason.replace('|', "/")
);
}
out
}
pub fn counts(rows: &[Row]) -> Vec<(&'static str, usize)> {
Status::ALL
.iter()
.map(|s| (s.label(), rows.iter().filter(|r| r.status == *s).count()))
.collect()
}
#[cfg(test)]
mod tests {
use super::*;
fn record(key: &str, class: &str, tier: &str, depends: &[&str]) -> Record {
Record {
key: key.into(),
class: class.into(),
tier: tier.into(),
license: "MIT".into(),
depends: depends.iter().map(|d| (*d).to_owned()).collect(),
..Record::default()
}
}
#[test]
fn statuses_and_reasons() {
let work = std::env::temp_dir().join(format!("horizon-report-{}", std::process::id()));
let _ = std::fs::remove_dir_all(&work);
let write = |key: &str, carry: Value, harness: Option<Value>| {
let dir = work.join("mods").join(key);
std::fs::create_dir_all(dir.join("harness")).unwrap();
std::fs::write(dir.join("carry-report.json"), carry.to_string()).unwrap();
if let Some(h) = harness {
std::fs::write(dir.join("harness/result.json"), h.to_string()).unwrap();
}
};
let green = serde_json::json!({"checks": {"blocks": {"passed": 3, "failed": 0}}});
write(
"doors",
serde_json::json!({"blocks": {"a": "minecraft:oak_door"}, "items": 0,
"differences": {"a": ["class m.Door (behaviour beyond DoorBlock)"]}}),
Some(green),
);
write(
"paths",
serde_json::json!({"blocks": {"a": "minecraft:stone"}, "items": 1,
"blocks_unknown": {"b": "no vanilla Block"}}),
Some(serde_json::json!({"checks": {"shapes": {"passed": 1, "failed": 2}}})),
);
let records = [
record("doors", "content", "data", &[]),
record("paths", "content", "data", &[]),
record("lib", "library", "none", &[]),
record("machine", "content", "machines", &["lib"]),
record("addon", "integration", "logic", &["machine"]),
record("mystery", "unknown", "none", &[]),
];
let rows = build(&records, &work);
let by: BTreeMap<&str, &Row> = rows.iter().map(|r| (r.key.as_str(), r)).collect();
assert_eq!(by["doors"].status, Status::Ported);
assert!(
by["doors"].reason.contains("1 with code of their own"),
"{}",
by["doors"].reason
);
assert_eq!(by["paths"].status, Status::Partial);
assert!(
by["paths"].reason.contains("1 blocks left out"),
"{}",
by["paths"].reason
);
assert!(
by["paths"].reason.contains("shapes 1/3"),
"{}",
by["paths"].reason
);
assert_eq!(by["lib"].status, Status::NotNeeded);
assert_eq!(by["machine"].status, Status::NotYet);
assert!(by["machine"].reason.contains("0.4"));
assert!(by["addon"].reason.starts_with("after the mods it joins"));
assert!(
by["addon"].reason.ends_with("waits on machine"),
"{}",
by["addon"].reason
);
assert_eq!(by["mystery"].status, Status::NotYet);
assert_eq!(
counts(&rows),
[
("ported", 1),
("partial", 1),
("not yet", 3),
("not needed", 1)
]
);
let md = markdown("test", &rows);
assert!(
md.contains("| **all** | **1** | **1** | **3** | **1** | **6** |"),
"{md}"
);
std::fs::remove_dir_all(&work).unwrap();
}
#[test]
fn licence_families() {
assert_eq!(license_kind("MIT"), "permissive");
assert_eq!(license_kind("CC0-1.0"), "permissive");
assert_eq!(license_kind("LGPL-3.0-only"), "copyleft");
assert_eq!(
license_kind("GNU Lesser General Public License v3.0"),
"copyleft"
);
assert_eq!(
license_kind("LicenseRef-All-Rights-Reserved"),
"all-rights-reserved"
);
assert_eq!(license_kind("CC-BY-NC-SA-4.0"), "restricted");
assert_eq!(license_kind("LicenseRef-Stardust-Labs-License"), "custom");
assert_eq!(
license_kind("unknown (read mods.toml at import)"),
"unknown"
);
}
}
@@ -227,6 +227,10 @@ impl Connection {
},
})
}
/// `Connection.isMemoryConnection`: through a [`Pipe`] rather than a socket.
pub fn is_memory(&self) -> bool {
matches!(self.reader.stream, Stream::Memory(_))
}
/// ClientboundLoginCompressionPacket: negative thresholds disable compression.
pub fn set_compression(&mut self, threshold: i32) {
let t = usize::try_from(threshold).ok();
@@ -355,6 +359,8 @@ mod tests {
big.extend(std::iter::repeat_n(3u8, 1000));
c.send(&big).unwrap();
assert_eq!(c.recv().unwrap(), (9, vec![1, 2]));
assert_eq!(c.reader.counters.sent.load(Ordering::Relaxed), 1);
assert_eq!(c.reader.counters.received.load(Ordering::Relaxed), 1);
server.join().unwrap();
assert!(c.recv().is_err());
}
@@ -513,6 +513,22 @@ impl Behaviours {
sim.game_event_state(pos, "minecraft:block_change", next);
}
/// The state change of `RedStoneOreBlock.attack` when mining begins.
pub fn attack_block<L: LevelAccess + ?Sized>(
&self,
level: &mut L,
ticks: &mut Ticks,
pos: BlockPos,
) {
let mut sim = self.sim(level, ticks);
let state = sim.state(pos);
if self.data(state).chain.contains(&Class::RedStoneOre)
&& !self.table.bool(state, self.props.lit)
{
sim.set_block_and_update(pos, self.table.set_bool(state, self.props.lit, true));
}
}
/// `BlockState.useWithoutItem` for a right-click on `pos` (hit face and
/// absolute hit location as in `BlockHitResult`).
pub fn use_without_item<L: LevelAccess + ?Sized>(
+21
View File
@@ -634,6 +634,27 @@ impl World<'_> {
}
}
#[test]
fn mining_lights_redstone_ore_until_its_random_tick() {
let mut w = world!();
let pos = BlockPos::new(0, 1, 0);
for ore in ["redstone_ore", "deepslate_redstone_ore"] {
let unlit = w.id(ore, &[("lit", "false")]);
let lit = w.id(ore, &[("lit", "true")]);
w.put(pos, unlit);
w.b().attack_block(&mut w.level, &mut w.ticks, pos);
assert_eq!(w.get(pos), lit);
w.b().attack_block(&mut w.level, &mut w.ticks, pos);
assert_eq!(w.get(pos), lit);
w.b().random_tick(&mut w.level, &mut w.ticks, pos);
assert_eq!(w.get(pos), unlit);
}
let stone = w.id("stone", &[]);
w.put(pos, stone);
w.b().attack_block(&mut w.level, &mut w.ticks, pos);
assert_eq!(w.get(pos), stone);
}
#[test]
fn placement_orients_blocks() {
let mut w = world!();
+12
View File
@@ -97,6 +97,18 @@ impl Default for Limits {
}
}
}
impl Limits {
/// The prepared per-state block tables (`cached-collision.nbt`,
/// `block-properties.nbt`, ...): trusted files with a row per block
/// state, which content mods' states grow past the default caps.
pub fn tables() -> Self {
Self {
max_bytes: 1 << 28,
max_nodes: 16_000_000,
max_depth: 512,
}
}
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct Error {
+80 -2
View File
@@ -51,7 +51,7 @@ use std::{
collections::{BTreeMap, BTreeSet, HashMap},
fs, io,
path::Path,
sync::{Arc, Mutex},
sync::{Arc, Mutex, OnceLock},
};
#[derive(Debug)]
@@ -184,7 +184,13 @@ pub struct GeneratorData {
/// Block shape-update behaviour (`block-behaviours.json` next to the
/// worldgen directory) for template placement's neighbor updates.
pub(super) behaviours: Option<Arc<crate::level::Behaviours>>,
/// Concentric ring positions by seed and dimension generator (see
/// `rings_for`), most recent last.
ring_cache: Mutex<Vec<RingCacheEntry>>,
}
type RingCacheEntry = ((i64, String), Arc<OnceLock<super::structure::start::Rings>>);
/// Generators whose ring positions are kept: the dimensions of a few worlds.
const RING_CACHE_LIMIT: usize = 8;
type Bundle = BTreeMap<String, String>;
fn read_bundle(dir: &Path, name: &str) -> Result<Bundle, GeneratorError> {
let path = dir.join(format!("{name}.json"));
@@ -458,8 +464,30 @@ impl GeneratorData {
block_tags,
biome_tags,
feature_resources,
ring_cache: Mutex::new(Vec::new()),
}))
}
/// The concentric ring positions (strongholds) of the generator for
/// `seed` and the dimension `generator` definition, shared by every
/// generator built for them. They depend on nothing else, so returning
/// to a dimension, which builds its generator again, finds them done.
pub(super) fn rings_for(
&self,
seed: i64,
generator: &Value,
) -> Arc<OnceLock<super::structure::start::Rings>> {
let key = (seed, generator.to_string());
let mut cache = self.ring_cache.lock().unwrap_or_else(|e| e.into_inner());
let rings = match cache.iter().position(|(k, _)| *k == key) {
Some(i) => cache.remove(i).1,
None => Arc::new(OnceLock::new()),
};
if cache.len() >= RING_CACHE_LIMIT {
cache.remove(0);
}
cache.push((key, rings.clone()));
rings
}
pub fn registry(&self) -> &'static BlockRegistry {
self.registry
}
@@ -821,8 +849,9 @@ where
.into_iter()
.filter_map(|name| pipeline.data.biome_id(name))
.collect();
let rings = pipeline.data.rings_for(seed, generator);
pipeline.structures =
super::generator_structures::StructureState::new(&pipeline.data, &possible)?;
super::generator_structures::StructureState::new(&pipeline.data, &possible, rings)?;
}
Ok(pipeline)
}
@@ -1906,6 +1935,55 @@ impl GeneratorWorker {
mod tests {
use super::*;
/// Generators of one seed and dimension share their ring positions;
/// another seed or generator gets its own, and old entries go.
#[test]
fn ring_positions_are_shared_by_seed_and_dimension() {
let root = std::env::var_os("HORIZON_RESOURCES")
.map(std::path::PathBuf::from)
.unwrap_or_else(|| {
Path::new(env!("CARGO_MANIFEST_DIR")).join("../../.local/horizon-client/26.3")
});
if !root.join("worldgen/world_presets.json").exists() {
eprintln!("skipping: no worldgen bundle at {}", root.display());
return;
}
let registry: &'static BlockRegistry = Box::leak(Box::new(
crate::level::data::load_registry(&root).expect("registry"),
));
let data = GeneratorData::load(&root.join("worldgen"), registry).expect("worldgen data");
let first = OverworldGenerator::new(data.clone(), 1234).expect("generator");
let again = OverworldGenerator::new(data.clone(), 1234).expect("generator");
{
let cache = data.ring_cache.lock().unwrap();
assert_eq!(cache.len(), 1);
// The cache's handle and the two generators'.
assert_eq!(Arc::strong_count(&cache[0].1), 3);
}
drop((first, again));
let a = data.rings_for(1, &serde_json::json!({ "settings": "a" }));
assert!(Arc::ptr_eq(
&a,
&data.rings_for(1, &serde_json::json!({ "settings": "a" }))
));
assert!(!Arc::ptr_eq(
&a,
&data.rings_for(2, &serde_json::json!({ "settings": "a" }))
));
assert!(!Arc::ptr_eq(
&a,
&data.rings_for(1, &serde_json::json!({ "settings": "b" }))
));
for seed in 10..10 + RING_CACHE_LIMIT as i64 {
data.rings_for(seed, &serde_json::json!({ "settings": "a" }));
}
assert_eq!(data.ring_cache.lock().unwrap().len(), RING_CACHE_LIMIT);
assert!(!Arc::ptr_eq(
&a,
&data.rings_for(1, &serde_json::json!({ "settings": "a" }))
));
}
#[test]
fn parameter_reports_quantize_like_vanilla() {
let report = r#"{"biomes":[{"biome":"minecraft:plains","parameters":{
@@ -103,14 +103,12 @@ impl BlockBehavior {
return Ok(None);
}
let read = |name: &str| -> Result<Tag, GeneratorError> {
let limits = Limits {
max_bytes: 1 << 28,
..Limits::default()
};
Ok(nbt::read_named(&fs::read(dir.join(name))?, limits)
.map_err(|e| resource(format!("{name}: {e:?}")))?
.0
.tag)
Ok(
nbt::read_named(&fs::read(dir.join(name))?, Limits::tables())
.map_err(|e| resource(format!("{name}: {e:?}")))?
.0
.tag,
)
};
let json = |name: &str| -> Result<Value, GeneratorError> {
Ok(serde_json::from_str(&fs::read_to_string(dir.join(name))?)?)
@@ -31,8 +31,9 @@ pub(super) struct StructureState {
/// Structure indices of each decoration step, in registry order.
pub(super) by_step: Vec<Vec<usize>>,
starts: Mutex<HashMap<(i32, i32), Starts>>,
/// Concentric ring positions, computed on first use.
rings: OnceLock<Rings>,
/// Concentric ring positions, computed on first use and shared with
/// later generators of the same seed and dimension.
rings: Arc<OnceLock<Rings>>,
/// Their biome searches while they are computed.
ring_work: OnceLock<RingWork>,
}
@@ -131,6 +132,7 @@ impl StructureState {
pub(super) fn new(
data: &Arc<GeneratorData>,
possible_biomes: &BTreeSet<BiomeId>,
rings: Arc<OnceLock<Rings>>,
) -> Result<Option<Self>, GeneratorError> {
let (Some(resources), Some(raw)) = (&data.structures, &data.structure_resources) else {
return Ok(None);
@@ -166,7 +168,7 @@ impl StructureState {
possible_sets,
by_step,
starts: Mutex::new(HashMap::new()),
rings: OnceLock::new(),
rings,
ring_work: OnceLock::new(),
}))
}
+6 -1
View File
@@ -1,6 +1,6 @@
# Horizon extras
Optional conveniences built into the client: zoom, a minimap, an FPS counter, a
Optional conveniences built into the client: fullbright, zoom, a minimap, an FPS counter, a
keystroke overlay, auto-reconnect, Mouse Tweaks-style inventory controls and
inventory sorting. **Every one is off by default**: a fresh
install looks and behaves exactly like vanilla 26.3, and turning an extra off
@@ -36,6 +36,11 @@ Horizon category in Controls, and adding one would put a non-vanilla mapping int
## The extras
### Fullbright (`fullbright`, default off)
- Displays blocks and entities with a fully bright lightmap, including in dark caves.
- Turning it off restores the normal lightmap using the current brightness,
time of day and effects. The brightness slider keeps its normal range.
### Zoom (`zoom`, default off)
- Hold the zoom key (default **Z**, unused by every vanilla 26.3 key mapping; C
is `key.saveToolbarActivator`) to zoom. The key does nothing while zoom is off.
+146 -18
View File
@@ -237,6 +237,11 @@ How the game loads them, without touching vanilla's path:
- Loaders that read only `data/minecraft/` (recipes, loot, tags) read every namespace, as
vanilla does. With no mods there is only `minecraft`, so nothing changes.
- The overlay is cached like the resource-pack overlay and rebuilt when a mod file changes.
- **Limits.** Chunk sections store a block state in 16 bits: vanilla 26.3 has 35,723 states,
so mods may add 29,813. Past that the content root is refused with the states per mod
(Macaw's Doors, Fences, Paths and Trapdoors alone add 36,154: not all four fit). Block
sprites fill texture arrays of 2048 layers, four at most (8,192; vanilla takes 1,250,
identical textures share a layer). Wider state ids are the next step for big packs.
- Not in 0.2: multiplayer registry sync (single player and the integrated server first), worlds
opened without a mod they used (vanilla turns unknown blocks into air; we will ask first),
vanilla ids redefined by a mod (refused).
@@ -262,12 +267,14 @@ inspected:
└── coverage.json, coverage.md
```
**Status.** `import`, `inventory` and `carry` run today:
**Status.** `import`, `inventory`, `carry` and `report` run today:
```
cargo run -p horizon-port-pack -- import ~/Downloads/pack.mrpack ~/.horizon/ports/pack
cargo run -p horizon-port-pack -- inventory ~/.horizon/ports/pack # --offline reuses modrinth.json
cargo run -p horizon-port-pack -- carry ~/.horizon/ports/pack # content mods with a jar, or name them
# --resources <prepared root>: only templates Horizon's tables have
cargo run -p horizon-port-pack -- report ~/.horizon/ports/pack # coverage.json and coverage.md
```
`inventory` reads metadata only: Modrinth answers by file hash, and the jars only if the user's
@@ -277,14 +284,26 @@ classes come from the reviewed table, Modrinth categories and sides; with jars,
only): content 54, library 33, client-ui 26, performance 25, other 14, unknown 2, server-only 1;
40 rows matched the reviewed ATM10 table; three dependency layers (93 / 57 / 5).
`carry` copies a jar's `assets/<id>/`, `data/<id>/` and `data/minecraft/tags/` into
`mods/<id>/carry/`, a folder content mod (API 0.2) the game loads with `--dev-mod`, and keeps
what a content mod may not hold (other namespaces such as `c` tags, vanilla data) in `outside/`.
No class file is copied. It upgrades vanilla-type recipes from 1.21.1 ingredients to 26.3's,
adds the `items/` definitions 1.21.4 introduced, and declares each block from a vanilla template
guessed from its blockstate properties (stone for none, a door for `facing, half, hinge, open,
powered`, ...); blocks with an unknown property set, custom recipe types and NeoForge
conditions are listed in `carry-report.json` for the oracle step.
`carry` copies a jar's `assets/<id>/`, `data/<id>/`, `data/minecraft/tags/` and `data/c/tags/`
into `mods/<id>/carry/`, a folder content mod (API 0.2) the game loads with `--dev-mod`, and
keeps what a content mod may not hold (other namespaces, vanilla data) in `outside/`. No class
file is copied. It upgrades from 1.21.1 to 26.3: vanilla-type recipes (ingredients), loot tables
(`conditions` lists become one `condition`, `functions` become `modifier`, kinds move to `type`,
tool matches on silk touch or shears become `minecraft:tool/can_silk_touch` and
`minecraft:tool/can_shear`), and the `items/` definitions 1.21.4 introduced.
Blocks and items come from the NeoForge oracle when `<work>/oracle/facts.json` exists (step 6):
every block the mod registers gets the vanilla template of the same vanilla class and states
whose shapes, sounds, set type and wood type match best, with the mod's own hardness, blast
resistance, light, tool need, friction, map colour and sounds as overrides. `--resources
<prepared>` limits templates to blocks Horizon's tables have. `carry-report.json` lists, per
block, what the template does not reproduce (other shapes, sounds no vanilla block has, a class
of its own), and the blocks left out: those whose vanilla class has no vanilla block with the
same states (Macaw's garage doors, multi-part gates). Recipes get the convention tags they use
(`c:dyes/red`), filled from the oracle with vanilla's and the mod's own members. Without the
oracle, templates are guessed from the blockstate's properties: the template whose properties
include them with the fewest left over (models often ignore `powered` or `waterlogged`), the
block's name breaking ties (`_pane`, `_gate`, `_trapdoor`).
### 1. Import
@@ -294,6 +313,7 @@ conditions are listed in `carry-report.json` for the oracle step.
| CurseForge zip | `manifest.json`: `minecraft.version`, `modLoaders[]`, `files[]` (`projectID`, `fileID`, `required`), `overrides` | the user's installed instance (CurseForge app `minecraftinstance.json` + `mods/`). CurseForge's API needs a key, so we take what the user already downloaded |
| Prism / MultiMC instance | `mmc-pack.json` components (`net.minecraft`, `net.neoforged`, `net.fabricmc.fabric-loader`), `instance.cfg`, `.minecraft/mods/*.jar`, packwiz `.pw.toml` files if present | the instance folder |
| packwiz | `pack.toml`, `index.toml`, `mods/*.pw.toml` | as listed |
| Crash Assistant `modlist.json` | jar name → mod id, name, version, Modrinth SHA-1; the loader entry (NeoForge `21.1.x` is Minecraft 1.21.1). Packs such as ATM10 publish it in their repository | metadata only; jars put in `<work>/jars/` |
`pack.json` holds the Minecraft version, the loader and its version, each file with its hashes
and side, and the overrides (configs, KubeJS scripts, datapacks).
@@ -386,8 +406,51 @@ A **harness per mod**, generated from the tier:
| deep | entity scenarios (spawn, tick N, positions and states, drops), and render captures where the look is the point, compared as images with a tolerance |
The comparison skips vanilla 1.21.1-versus-26.3 differences: it normalises ids and components
through the step-4 upgrader and compares only the mod's own ids and effects. The harness format
is `tools/parity.py`'s, so the same runner, local or CI, runs vanilla and mod harnesses.
through the step-4 upgrader and compares only the mod's own ids and effects.
**Status: the data-tier harness runs.**
```
python3 tools/neoforge_oracle.py export --jars <mods> --deps <their libraries> --out <work>/oracle/facts.json
cargo run -p horizon-port-pack -- carry <work> --resources .local/horizon-client/26.3
python3 tools/mod_port_harness.py --work <work> # or --jars/--deps to export first
```
- `tools/neoforge_oracle.py` installs a NeoForge server (21.1.259, ATM10's) under
`.local/neoforge-oracle/`, builds the exporter mod in `mods/horizon/src/neoforge-oracle/` (our code, dev
only), starts the server headless with the jars and writes, for every block of the mods'
namespaces and every vanilla block: the class chain, states, per-state hardness, light, tool
need, map colour, sounds, outline and collision shapes; drops for hand, diamond tools, shears
and silk touch; placement on a floor and a wall; BlockSetType and WoodType. Then items (class,
stack size, rarity, food), recipes (type, result, count, resolved ingredients) and tags. One run
with the seven mods below takes about 30 s.
- `crates/horizon-client/examples/mod_port_probe.rs` builds the content root from the carried
mods and dumps what Horizon's loaders make of the same blocks, drops, recipes and tags.
- `tools/mod_port_harness.py` compares them per mod (blocks, properties, sounds, shapes, drops,
placement against the template's in the oracle, vanilla tags, recipes, items) and writes
`<work>/mods/<id>/harness/result.json`. It maps 1.21.1 sound events to 26.3's through the
vanilla blocks both versions have (`block.metal.*` became `block.iron.*`) and ignores vanilla
items 1.21.1 did not have (pale oak in `#minecraft:logs`).
The oracle needs the mods' jars, so it is not a `tools/parity.py` harness: it runs where the
user's jars are, and its facts and results stay in the work folder. The first real mods
(ATM10's own jars from Modrinth, all MIT; checks passed / compared):
| mod | blocks | properties | sounds | shapes | drops | placement | tags | recipes | items |
|---|---:|---:|---:|---:|---:|---:|---:|---:|---:|
| Macaw's Trapdoors 1.1.5 | 179/179 | 11456/11456 | 11456/11456 | 11456/11456 | 10024/10024 | 358/358 | 534/534 | 191/191 | 191/191 |
| Macaw's Doors 1.1.5 | 239/245 | 15296/15296 | 15296/15296 | 12352/15296 | 13384/13384 | 478/478 | 941/941 | 257/257 | 251/257 |
| Macaw's Fences and Walls 1.2.1 | 150/180 | 4800/4800 | 4800/4800 | 4032/4800 | 33600/33600 | 300/300 | 432/432 | 222/222 | 150/180 |
| Macaw's Paths and Pavings 1.1.1 | 234/315 | 4602/4602 | 4602/4602 | 4472/4602 | 6734/6734 | 468/468 | 416/416 | 315/315 | 234/315 |
| Glassential-renewed 3.4.7 | 105/114 | 5177/5177 | 5177/5177 | 4727/5177 | 6447/6447 | 210/210 | 105/105 | 143/143 | 106/115 |
| Factory Blocks 1.4.0 | 42/49 | 42/42 | 0/42 | 42/42 | 294/294 | 84/84 | 42/42 | 1/1 | 42/49 |
| Cloud Glass 1.1.0 | 16/16 | 16/16 | 16/16 | 0/16 | 112/112 | 32/32 | – | 31/31 | 16/16 |
What fails is what API 0.2 cannot express yet: shapes of their own (Japanese doors, hedges,
paths a sixteenth high, glass without collision), sound events of the mod's own
(`factory_blocks:metal_sound`), and blocks whose vanilla class has no vanilla block with the
same states (garage doors, double gates, engraved and facing paths, fans). Every drop, recipe
and tag of the declared blocks matches.
### 7. Coverage report
@@ -402,16 +465,46 @@ is `tools/parity.py`'s, so the same runner, local or CI, runs vanilla and mod ha
Plus the licence summary (how many ports could be published) and, for a pack, "playable?":
whether every required content mod is ported or partial with its blocks and items present.
For ATM10 today: 125 of 495 are not needed. The other 370 are not yet ported; 68 of them are
data tier, so they need registries and carry-over but no agent.
`horizon-port-pack report <work>` writes the per-mod rows and the class, tier and licence totals from the inventory, each mod's `carry-report.json`
and its harness result. A data-tier mod is **ported** when its harness is green and nothing was
left out (blocks with a class of their own are counted and named, since facts cannot show
their extra code); **partial** with the failing checks, the blocks left out and what the
templates miss; **not yet** with the API tier it waits for, or the dependency; **not needed**
for libraries, performance mods, pack tooling and what Horizon has built in. Unclassified mods
(the 20 CurseForge-only rows the reviewed table only guesses) count as not yet.
**ATM10, measured** (`import` of ATM10's `modlist.json` from its repository on 2026-10-16, 496
files; `inventory`; `carry` and the harness on the eight mods we downloaded; `report`):
| class | ported | partial | not yet | not needed | all |
|---|---:|---:|---:|---:|---:|
| content | 1 | 7 | 268 | 0 | 276 |
| library | 0 | 0 | 0 | 77 | 77 |
| integration | 0 | 0 | 40 | 3 | 43 |
| client-ui | 0 | 0 | 27 | 2 | 29 |
| other | 0 | 0 | 1 | 23 | 24 |
| unknown | 0 | 0 | 20 | 0 | 20 |
| performance | 0 | 0 | 0 | 16 | 16 |
| server-only | 0 | 0 | 11 | 0 | 11 |
| **all** | **1** | **7** | **367** | **121** | **496** |
By tier, the 367 not yet: data 57 (carry-over and the harness, no agent: their jars were not
downloaded), logic 66 (API 0.3), machines 97 (0.4), deep 92 (0.5), client 35, unclassified 20.
Ported: Macaw's Trapdoors. Partial: Macaw's Doors, Fences and Walls, Paths and Pavings,
Glassential, Factory Blocks, Cloud Glass (see the harness table) and MVS, whose 784 worldgen
files are carried but not yet read by the game. Of the 8, 7 are MIT and one LGPL; nothing is
published.
## Measuring "10x"
`tools/perf_bench.py` already measures Horizon against vanilla and vanilla with performance
mods on the same machine, world and camera path ([benchmark.md](benchmark.md)). It gains
`--game pack --pack <file or instance>`: the pack on its own loader (NeoForge 21.1.259 for
ATM10), launched with the pack's recommended JVM arguments, driven by the same dev-only bench
mod, ported to that loader.
mods on the same machine, world and camera path ([benchmark.md](benchmark.md)). With
`--game neoforge --mod-jars <dir> --deps <dir>` it runs the mods on their own loader (NeoForge
21.1.259 for ATM10, installed under `.local/neoforge-oracle`, `-Xmx2G` like the launcher),
driven by the same steps through a dev-only NeoForge port of the bench mod
(`mods/horizon/src/neoforge-bench`). `--game horizon --port-work <work>` loads a work folder's
carried-over mods into Horizon. A whole pack (`--pack`, its recommended JVM arguments) is next.
| Metric | How | Horizon side |
|---|---|---|
@@ -434,6 +527,37 @@ confidence interval. Other ratios are reported as they come out. Caveat (in ever
the pack runs Minecraft 1.21.1 and Horizon runs 26.3, so the vanilla parts differ by a few
versions.
### Measured: six ported mods against the same mods on NeoForge
Cloud Glass, Factory Blocks, Glassential, Macaw's Fences, Paths and Trapdoors (Doors left out:
with Trapdoors it passes the block states chunks hold, see Limits), carried over and loaded as
dev mods in Horizon, against their jars plus Architectury and Fusion on NeoForge 21.1.259.
Mac mini M4 Pro, 1280x720, seed 1234, the four flight scenes, 2 games per row, 2026-10-17.
Means; FPS is the mean of the four scenes. "Title" is start to title screen, "world" start to
a fresh world drawn around the spawn, "scene load" a teleport to every chunk drawn.
| RD | game | title s | world s | scene load s | FPS | RSS steady / peak MB | load avg |
|---|---|---:|---:|---:|---:|---:|---:|
| 8 | Horizon + 6 mods | 9.8 | 16.2 | 4.0 | 122 | 2,644 / 2,771 | 32 |
| 8 | NeoForge + 6 mods | 19.5 | 50.0 | 30.2 | 72 | 2,325 / 2,592 | 56 |
| 8 | Horizon | 5.0 | 11.0 | 4.0 | 124 | 1,559 / 1,629 | 51 |
| 8 | NeoForge | 12.8 | 36.1 | 21.9 | 104 | 2,334 / 2,558 | 30 |
| 16 | Horizon + 6 mods | 10.8 | 27.0 | 11.3 | 90 | 2,925 / 3,032 | 40 |
| 16 | NeoForge + 6 mods | 26.4 | 82.5 | 64.3 | 25 | 3,016 / 3,519 | 45 |
| 16 | Horizon | 3.5 | 10.0 | 7.4 | 119 | 1,732 / 1,871 | 56 |
| 16 | NeoForge | 16.9 | 73.7 | 43.2 | 36 | 2,748 / 3,425 | 48 |
Same content, Horizon against NeoForge: the world is ready 3.1x sooner at 8 chunks and 3.1x at
16, the title screen 2.0x and 2.4x sooner, and the flights run 1.7x and 3.6x the frames. RAM is
not lower: Horizon's steady RSS grows 1.1 GB with the mods (61,816 block states against
vanilla's 35,723; the per-state tables are the next thing to measure), while the JVM stays
inside its 2 GB heap. Caveats, so none of this is a "10x" claim yet: other sessions and CI
runners kept the machine's load average between 30 and 56 on 14 threads, so the confidence
intervals are as wide as the means (`perf_bench.py --table`); Horizon's frames are paced near
the display's 144 Hz at 8 chunks; Horizon's title time includes building the content overlay on
a first start (about 5 s, cached afterwards); and the pack runs 1.21.1 against Horizon's 26.3.
A quiet rerun with more games is the next measurement.
## The working version for 2026-10-23
In scope (each is a PR or a small stack):
@@ -459,7 +583,11 @@ In scope (each is a PR or a small stack):
6. **Measured:** load time, RAM and FPS of that pack on NeoForge 1.21.1 against Horizon, with
the full ATM10 on NeoForge as the reference row.
Out of scope for that date, and next in order: worldgen carry-over (the 30 or so structure and biome mods),
Out of scope for that date, and next in order: worldgen carry-over (the 30 or so structure and biome mods;
the first one looked at, Moog's Voyager Structures, declares all 130 structures and 116 structure
sets with MoogsStructureLib's own `generic_jigsaw_structure` and `advanced_random_spread` types and
NeoForge's `c:` biome tags, so its carry needs a mapping to vanilla's jigsaw and random spread
types plus the oracle's biome tags, not only bundle merging),
behaviour callbacks and server events (0.3), block entities, menus, capabilities and net
(0.4), the first agent-ported logic-tier mod as the pilot of step 5, then machines. Porting all
of ATM10 is a campaign. Each step publishes its coverage number; we make no claim beyond what
+6 -3
View File
@@ -277,12 +277,15 @@ blocks and items by declaring them in `data/<id>/horizon/block/*.json` and
```
The fence: files go in the mod's own namespace (`assets/<id>/`,
`data/<id>/`), plus additions to vanilla tags (`data/minecraft/tags/`).
`data/<id>/`), plus additions to vanilla tags (`data/minecraft/tags/`) and
to the convention tags NeoForge and Fabric mods share (`data/c/tags/`).
Templates and `sounds` name vanilla blocks; unknown keys are refused. Paths
use vanilla's resource characters, at most 65,536 files, 16 MiB each and
512 MiB in all. A mod whose content is refused stays off, with the reason on
its row. The game reading this content into its block and item tables comes
next (docs/modpacks.md).
its row. The game reads this content into its block and item tables
(`horizon_client::mod_content`, docs/modpacks.md). A tag entry naming an id
nobody registers (a block a port left out, another mod's item) is dropped,
so the rest of the tag still loads; vanilla would drop the whole tag.
## Versions and compatibility
@@ -0,0 +1,275 @@
package dev.horizonlab.neoforgebench;
import com.google.gson.JsonArray;
import com.google.gson.JsonObject;
import com.google.gson.JsonParser;
import com.mojang.blaze3d.platform.GlUtil;
import java.io.IOException;
import java.io.UncheckedIOException;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.StandardOpenOption;
import java.util.ArrayList;
import java.util.List;
import net.minecraft.client.Minecraft;
import net.minecraft.client.gui.screens.TitleScreen;
import net.minecraft.client.player.LocalPlayer;
import net.minecraft.world.Difficulty;
import net.minecraft.world.level.GameRules;
import net.minecraft.world.level.GameType;
import net.minecraft.world.level.LevelSettings;
import net.minecraft.world.level.WorldDataConfiguration;
import net.minecraft.world.level.levelgen.WorldOptions;
import net.minecraft.world.level.levelgen.presets.WorldPresets;
import net.minecraft.world.phys.Vec3;
import net.neoforged.api.distmarker.Dist;
import net.neoforged.fml.common.Mod;
import net.neoforged.neoforge.client.event.RenderFrameEvent;
import net.neoforged.neoforge.common.NeoForge;
/**
* Dev-only benchmark driver for a NeoForge 1.21.1 client (tools/perf_bench.py
* --game neoforge): the steps of mods/horizon/src/bench's VanillaBench, on
* NeoForge's events. From the title screen it creates a fresh creative world
* with the script's seed, waits for the spawn area, then per scene teleports,
* waits for the chunks, settles and flies a straight line at constant speed,
* recording every frame time. Events go to horizon.bench.out as JSON lines;
* the game quits after the last scene. Never shipped.
*/
@Mod(value = "horizon_bench", dist = Dist.CLIENT)
public final class NeoForgeBench {
private enum Phase { TITLE, WORLD, TELEPORT, LOAD, SETTLE, FLY, DONE }
private final JsonObject script;
private final Path out;
private final List<JsonObject> scenes = new ArrayList<>();
private Phase phase = Phase.TITLE;
private int scene = -1;
private long phaseStart;
private long lastFrame;
private long readyCheck;
private int lastLoaded = -1;
private long lastChange;
private final List<Float> frames = new ArrayList<>();
public NeoForgeBench() {
String scriptPath = System.getProperty("horizon.bench.script");
String outPath = System.getProperty("horizon.bench.out");
if (scriptPath == null || outPath == null) {
script = null;
out = null;
return;
}
try {
script = JsonParser.parseString(Files.readString(Path.of(scriptPath))).getAsJsonObject();
} catch (IOException e) {
throw new UncheckedIOException(e);
}
out = Path.of(outPath);
for (var element : script.getAsJsonArray("scenes")) scenes.add(element.getAsJsonObject());
NeoForge.EVENT_BUS.addListener(RenderFrameEvent.Pre.class, e -> step(Minecraft.getInstance()));
event("init");
}
private void step(Minecraft mc) {
long now = System.nanoTime();
float frameMs = lastFrame == 0 ? 0 : (now - lastFrame) / 1e6f;
lastFrame = now;
double elapsed = (now - phaseStart) / 1e9;
if (phase != Phase.TITLE && phase != Phase.DONE && elapsed > script.get("timeout").getAsDouble()
&& phase != Phase.FLY && phase != Phase.SETTLE) {
JsonObject e = new JsonObject();
e.addProperty("phase", phase.name());
event("timeout", e);
finish(mc);
return;
}
switch (phase) {
case TITLE -> {
if (mc.screen instanceof TitleScreen && mc.getOverlay() == null) {
event("title", renderer(mc));
LevelSettings settings = new LevelSettings(script.get("world").getAsString(), GameType.CREATIVE,
false, Difficulty.NORMAL, true, new GameRules(), WorldDataConfiguration.DEFAULT);
WorldOptions options = new WorldOptions(script.get("seed").getAsLong(), true, false);
enter(Phase.WORLD, now);
mc.createWorldOpenFlows().createFreshLevel(script.get("world").getAsString(), settings, options,
WorldPresets::createNormalWorldDimensions, mc.screen);
}
}
case WORLD -> {
if (ready(mc, null, now)) {
JsonObject e = new JsonObject();
e.addProperty("ready_epoch_ms", epochMs(lastChange));
e.addProperty("chunks", lastLoaded);
event("world", e);
mc.player.connection.sendCommand("weather clear");
next(mc, now);
}
}
case TELEPORT -> {
JsonObject s = scenes.get(scene);
Vec3 from = vec(s.getAsJsonArray("from"));
LocalPlayer player = mc.player;
player.connection.sendCommand("time set 6000");
player.connection.sendCommand(String.format(java.util.Locale.ROOT, "tp @s %.3f %.3f %.3f %.3f %.3f",
from.x, from.y, from.z, yaw(s), s.get("pitch").getAsFloat()));
event("teleport", named(s));
enter(Phase.LOAD, now);
}
case LOAD -> {
JsonObject s = scenes.get(scene);
Vec3 from = vec(s.getAsJsonArray("from"));
if (mc.player != null && mc.player.position().distanceToSqr(from) < 1024.0) place(mc, s, 0);
if (ready(mc, from, now)) {
JsonObject e = named(s);
e.addProperty("load_ms", (lastChange - phaseStart) / 1e6);
e.addProperty("chunks", lastLoaded);
event("loaded", e);
enter(Phase.SETTLE, now);
}
}
case SETTLE -> {
place(mc, scenes.get(scene), 0);
if (elapsed >= script.get("settle").getAsDouble()) {
frames.clear();
event("fly", named(scenes.get(scene)));
enter(Phase.FLY, now);
}
}
case FLY -> {
frames.add(frameMs);
double t = Math.min(1.0, elapsed / script.get("seconds").getAsDouble());
place(mc, scenes.get(scene), t);
if (t >= 1.0) {
JsonObject e = named(scenes.get(scene));
JsonArray times = new JsonArray();
frames.forEach(times::add);
e.add("frame_ms", times);
e.addProperty("chunks", mc.level.getChunkSource().getLoadedChunksCount());
event("flown", e);
next(mc, now);
}
}
case DONE -> { }
}
}
private void next(Minecraft mc, long now) {
scene++;
if (scene >= scenes.size()) {
finish(mc);
} else {
enter(Phase.TELEPORT, now);
}
}
private void finish(Minecraft mc) {
phase = Phase.DONE;
event("done");
mc.stop();
}
private void enter(Phase next, long now) {
phase = next;
phaseStart = now;
lastLoaded = -1;
lastChange = now;
}
/** As VanillaBench.ready: spawned (near {@code at}), no screen, every chunk around, nothing to compile, 1 s stable. */
private boolean ready(Minecraft mc, Vec3 at, long now) {
if (now - readyCheck < 10_000_000L) return false;
readyCheck = now;
if (mc.level == null || mc.player == null || mc.screen != null || mc.getOverlay() != null
|| (at != null && mc.player.position().distanceToSqr(at) > 4.0)) {
lastChange = now;
lastLoaded = -1;
return false;
}
int loaded = mc.level.getChunkSource().getLoadedChunksCount();
if (loaded != lastLoaded || !mc.levelRenderer.hasRenderedAllSections() || !chunksAround(mc)) {
lastLoaded = loaded;
lastChange = now;
return false;
}
return now - lastChange >= 1_000_000_000L;
}
private static boolean chunksAround(Minecraft mc) {
int r = Math.max(1, mc.options.getEffectiveRenderDistance() - 1);
var center = mc.player.chunkPosition();
var chunks = mc.level.getChunkSource();
for (int dx = -r; dx <= r; dx++) {
for (int dz = -r; dz <= r; dz++) {
if (dx * dx + dz * dz <= r * r && !chunks.hasChunk(center.x + dx, center.z + dz)) return false;
}
}
return true;
}
private static void place(Minecraft mc, JsonObject s, double t) {
LocalPlayer player = mc.player;
if (player == null) return;
Vec3 a = vec(s.getAsJsonArray("from")), b = vec(s.getAsJsonArray("to"));
Vec3 at = a.add(b.subtract(a).scale(t));
player.setPos(at.x, at.y, at.z);
player.setYRot(yaw(s));
player.setXRot(s.get("pitch").getAsFloat());
player.setOldPosAndRot();
player.setDeltaMovement(Vec3.ZERO);
player.fallDistance = 0;
if (!player.getAbilities().flying) {
player.getAbilities().flying = true;
player.onUpdateAbilities();
}
}
private static float yaw(JsonObject s) {
Vec3 a = vec(s.getAsJsonArray("from")), b = vec(s.getAsJsonArray("to"));
return (float) Math.toDegrees(Math.atan2(-(b.x - a.x), b.z - a.z));
}
private static Vec3 vec(JsonArray a) {
return new Vec3(a.get(0).getAsDouble(), a.get(1).getAsDouble(), a.get(2).getAsDouble());
}
private static JsonObject named(JsonObject s) {
JsonObject e = new JsonObject();
e.addProperty("scene", s.get("name").getAsString());
return e;
}
private static JsonObject renderer(Minecraft mc) {
JsonObject e = new JsonObject();
e.addProperty("gpu", GlUtil.getRenderer());
e.addProperty("vendor", GlUtil.getVendor());
e.addProperty("backend", "OpenGL");
e.addProperty("driver", GlUtil.getOpenGLVersion());
JsonArray size = new JsonArray();
size.add(mc.getWindow().getWidth());
size.add(mc.getWindow().getHeight());
e.add("size", size);
e.addProperty("render_distance", mc.options.renderDistance().get());
e.addProperty("simulation_distance", mc.options.simulationDistance().get());
return e;
}
private static long epochMs(long nanos) {
return System.currentTimeMillis() - (System.nanoTime() - nanos) / 1_000_000L;
}
private void event(String name) {
event(name, new JsonObject());
}
private void event(String name, JsonObject e) {
e.addProperty("event", name);
e.addProperty("epoch_ms", System.currentTimeMillis());
try {
Files.writeString(out, e + "\n", StandardCharsets.UTF_8, StandardOpenOption.CREATE, StandardOpenOption.APPEND);
} catch (IOException error) {
throw new UncheckedIOException(error);
}
}
}
@@ -0,0 +1,11 @@
# Dev-only: the benchmark driver for a NeoForge client (tools/perf_bench.py --game neoforge).
# Built and run by tools/perf_bench.py; never shipped.
modLoader = "javafml"
loaderVersion = "[4,)"
license = "MIT"
[[mods]]
modId = "horizon_bench"
version = "1"
displayName = "Horizon benchmark driver (dev only)"
description = "Flies the client along tools/perf_bench.py's paths and records frame times."
@@ -0,0 +1,426 @@
package dev.horizonlab.neoforge;
import com.google.gson.stream.JsonWriter;
import java.io.IOException;
import java.io.Writer;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;
import java.util.TreeSet;
import net.minecraft.core.BlockPos;
import net.minecraft.core.Direction;
import net.minecraft.core.registries.BuiltInRegistries;
import net.minecraft.core.registries.Registries;
import net.minecraft.resources.ResourceLocation;
import net.minecraft.server.MinecraftServer;
import net.minecraft.server.level.ServerLevel;
import net.minecraft.sounds.SoundEvent;
import net.minecraft.world.InteractionHand;
import net.minecraft.world.item.BlockItem;
import net.minecraft.world.item.Item;
import net.minecraft.world.item.ItemStack;
import net.minecraft.world.item.Items;
import net.minecraft.world.item.context.BlockPlaceContext;
import net.minecraft.world.item.crafting.Ingredient;
import net.minecraft.world.item.crafting.RecipeHolder;
import net.minecraft.world.item.enchantment.Enchantments;
import net.minecraft.world.level.EmptyBlockGetter;
import net.minecraft.world.level.block.Block;
import net.minecraft.world.level.block.Blocks;
import net.minecraft.world.level.block.SoundType;
import net.minecraft.world.level.block.state.BlockState;
import net.minecraft.world.level.block.state.properties.Property;
import net.minecraft.world.level.storage.loot.LootParams;
import net.minecraft.world.level.storage.loot.parameters.LootContextParams;
import net.minecraft.world.phys.AABB;
import net.minecraft.world.phys.BlockHitResult;
import net.minecraft.world.phys.Vec3;
import net.minecraft.world.phys.shapes.VoxelShape;
import net.neoforged.bus.api.IEventBus;
import net.neoforged.fml.common.Mod;
import net.neoforged.neoforge.common.NeoForge;
import net.neoforged.neoforge.event.server.ServerStartedEvent;
/**
* Dev-only oracle for Horizon's mod ports (docs/modpacks.md): once the server has started,
* writes every block, item, recipe and tag of the namespaces named in {@code
* horizon.oracle.namespaces} (plus the vanilla blocks, so templates can be compared) to {@code
* horizon.oracle.out}, then stops the server. Never shipped to players.
*/
@Mod("horizon_oracle")
public final class FactsExporter {
private static final BlockPos FLOOR = new BlockPos(0, 99, 0);
public FactsExporter(IEventBus modBus) {
NeoForge.EVENT_BUS.addListener(this::started);
}
private void started(ServerStartedEvent event) {
MinecraftServer server = event.getServer();
Path out = Path.of(System.getProperty("horizon.oracle.out", "horizon-oracle.json"));
Set<String> namespaces =
new TreeSet<>(Arrays.asList(System.getProperty("horizon.oracle.namespaces", "").split(",")));
namespaces.remove("");
try (Writer w = Files.newBufferedWriter(out, StandardCharsets.UTF_8);
JsonWriter json = new JsonWriter(w)) {
new Export(server, namespaces, json).run();
} catch (Throwable e) {
e.printStackTrace();
System.exit(3);
}
System.out.println("horizon-oracle: wrote " + out);
server.halt(false);
}
private static final class Export {
final MinecraftServer server;
final ServerLevel level;
final Set<String> namespaces;
final JsonWriter json;
final List<ItemStack> tools = new ArrayList<>();
final List<String> toolNames = new ArrayList<>();
Export(MinecraftServer server, Set<String> namespaces, JsonWriter json) {
this.server = server;
this.level = server.overworld();
this.namespaces = namespaces;
this.json = json;
tool("hand", ItemStack.EMPTY);
tool("diamond_pickaxe", new ItemStack(Items.DIAMOND_PICKAXE));
tool("diamond_axe", new ItemStack(Items.DIAMOND_AXE));
tool("diamond_shovel", new ItemStack(Items.DIAMOND_SHOVEL));
tool("diamond_hoe", new ItemStack(Items.DIAMOND_HOE));
tool("shears", new ItemStack(Items.SHEARS));
ItemStack silk = new ItemStack(Items.DIAMOND_PICKAXE);
silk.enchant(
server.registryAccess()
.registryOrThrow(Registries.ENCHANTMENT)
.getHolderOrThrow(Enchantments.SILK_TOUCH),
1);
tool("silk_touch_pickaxe", silk);
}
void tool(String name, ItemStack stack) {
toolNames.add(name);
tools.add(stack);
}
boolean ours(ResourceLocation id) {
return namespaces.contains(id.getNamespace());
}
void run() throws IOException {
json.beginObject();
json.name("schema").value(1);
json.name("minecraft").value(net.minecraft.SharedConstants.getCurrentVersion().getName());
json.name("namespaces");
json.beginArray();
for (String n : namespaces) json.value(n);
json.endArray();
json.name("tools");
json.beginArray();
for (String n : toolNames) json.value(n);
json.endArray();
blocks();
// Vanilla's items, so harnesses can tell later versions' additions apart.
json.name("vanilla_items");
json.beginArray();
for (Item item : BuiltInRegistries.ITEM) {
ResourceLocation id = BuiltInRegistries.ITEM.getKey(item);
if (id.getNamespace().equals("minecraft")) json.value(id.toString());
}
json.endArray();
items();
recipes();
tags();
json.endObject();
}
void blocks() throws IOException {
level.setBlock(FLOOR, Blocks.STONE.defaultBlockState(), 3);
json.name("blocks");
json.beginObject();
for (Block block : BuiltInRegistries.BLOCK) {
ResourceLocation id = BuiltInRegistries.BLOCK.getKey(block);
boolean mod = ours(id);
if (!mod && !id.getNamespace().equals("minecraft")) continue;
json.name(id.toString());
json.beginObject();
json.name("class");
json.beginArray();
for (Class<?> c = block.getClass(); c != null && c != Object.class; c = c.getSuperclass()) {
json.value(c.getName());
}
json.endArray();
BlockState def = block.defaultBlockState();
json.name("properties");
json.beginObject();
for (Property<?> p : block.getStateDefinition().getProperties()) {
json.name(p.getName());
json.beginArray();
for (Object v : p.getPossibleValues()) json.value(name(p, v));
json.endArray();
}
json.endObject();
json.name("default").value(stateKey(def));
json.name("item").value(BuiltInRegistries.ITEM.getKey(block.asItem()).toString());
json.name("explosion_resistance").value(block.getExplosionResistance());
json.name("friction").value(block.getFriction());
json.name("speed_factor").value(block.getSpeedFactor());
json.name("jump_factor").value(block.getJumpFactor());
blockSetType(block);
json.name("states");
json.beginObject();
for (BlockState state : block.getStateDefinition().getPossibleStates()) {
json.name(stateKey(state));
json.beginObject();
json.name("hardness").value(state.getDestroySpeed(EmptyBlockGetter.INSTANCE, BlockPos.ZERO));
json.name("emission").value(state.getLightEmission());
json.name("requires_tool").value(state.requiresCorrectToolForDrops());
json.name("can_occlude").value(state.canOcclude());
json.name("replaceable").value(state.canBeReplaced());
json.name("random_ticks").value(state.isRandomlyTicking());
var color = state.getMapColor(EmptyBlockGetter.INSTANCE, BlockPos.ZERO);
json.name("map_color").value(color.col);
json.name("map_color_id").value(color.id);
sound(state.getSoundType(level, FLOOR.above(), null));
json.name("outline");
boxes(state.getShape(EmptyBlockGetter.INSTANCE, BlockPos.ZERO));
json.name("collision");
boxes(state.getCollisionShape(EmptyBlockGetter.INSTANCE, BlockPos.ZERO));
if (mod && lootSample(block, state)) drops(state);
json.endObject();
}
json.endObject();
if (block.asItem() instanceof BlockItem bi) placement(bi);
json.endObject();
}
json.endObject();
}
/** Every state of a small block; else the default and each one-property change from it. */
boolean lootSample(Block block, BlockState state) {
if (block.getStateDefinition().getPossibleStates().size() <= 32) return true;
BlockState def = block.defaultBlockState();
int differ = 0;
for (Property<?> p : block.getStateDefinition().getProperties()) {
if (!state.getValue(p).equals(def.getValue(p))) differ++;
}
return differ <= 1;
}
void drops(BlockState state) throws IOException {
json.name("drops");
json.beginObject();
for (int i = 0; i < tools.size(); i++) {
LootParams.Builder params =
new LootParams.Builder(level)
.withParameter(LootContextParams.ORIGIN, Vec3.atCenterOf(FLOOR.above()))
.withParameter(LootContextParams.TOOL, tools.get(i).copy());
Map<String, Integer> counts = new TreeMap<>();
for (ItemStack s : state.getDrops(params)) {
counts.merge(BuiltInRegistries.ITEM.getKey(s.getItem()).toString(), s.getCount(), Integer::sum);
}
json.name(toolNames.get(i));
json.beginObject();
for (Map.Entry<String, Integer> e : counts.entrySet()) json.name(e.getKey()).value(e.getValue());
json.endObject();
}
json.endObject();
}
void placement(BlockItem item) throws IOException {
BlockPos at = FLOOR.above();
level.setBlock(at, Blocks.AIR.defaultBlockState(), 3);
json.name("placement");
json.beginObject();
for (Direction face : new Direction[] {Direction.UP, Direction.NORTH}) {
BlockPos clicked = face == Direction.UP ? FLOOR : at.relative(face.getOpposite());
level.setBlock(clicked, Blocks.STONE.defaultBlockState(), 3);
Vec3 hit = Vec3.atCenterOf(clicked).add(Vec3.atLowerCornerOf(face.getNormal()).scale(0.5));
// A player-less context (the constructor is protected, hence the subclass).
BlockPlaceContext ctx =
new BlockPlaceContext(
level, null, InteractionHand.MAIN_HAND, new ItemStack(item),
new BlockHitResult(hit, face, clicked, false)) {};
BlockState placed = null;
try {
placed = item.getBlock().getStateForPlacement(ctx);
} catch (RuntimeException e) {
// Needs a player: recorded as no placement.
}
json.name(face.getName()).value(placed == null ? null : stateKey(placed));
if (face != Direction.UP) level.setBlock(clicked, Blocks.AIR.defaultBlockState(), 3);
}
json.endObject();
}
/** The BlockSetType (doors, trapdoors, buttons, plates) and WoodType (fence gates) a block keeps. */
void blockSetType(Block block) throws IOException {
String setType = null, woodType = null;
Boolean byHand = null;
for (Class<?> c = block.getClass(); c != null && c != Object.class; c = c.getSuperclass()) {
for (var f : c.getDeclaredFields()) {
try {
if (f.getType() == net.minecraft.world.level.block.state.properties.BlockSetType.class && setType == null) {
f.setAccessible(true);
var t = (net.minecraft.world.level.block.state.properties.BlockSetType) f.get(block);
if (t != null) {
setType = t.name();
byHand = t.canOpenByHand();
}
} else if (f.getType() == net.minecraft.world.level.block.state.properties.WoodType.class && woodType == null) {
f.setAccessible(true);
var t = (net.minecraft.world.level.block.state.properties.WoodType) f.get(block);
if (t != null) woodType = t.name();
}
} catch (ReflectiveOperationException | RuntimeException e) {
// Not readable: left out.
}
}
}
if (setType != null) {
json.name("block_set_type");
json.beginObject();
json.name("name").value(setType);
json.name("can_open_by_hand").value(byHand);
json.endObject();
}
if (woodType != null) json.name("wood_type").value(woodType);
}
void sound(SoundType s) throws IOException {
json.name("sound");
json.beginObject();
json.name("volume").value(s.getVolume());
json.name("pitch").value(s.getPitch());
event("break", s.getBreakSound());
event("step", s.getStepSound());
event("place", s.getPlaceSound());
event("hit", s.getHitSound());
event("fall", s.getFallSound());
json.endObject();
}
void event(String name, SoundEvent e) throws IOException {
json.name(name).value(e.getLocation().toString());
}
void boxes(VoxelShape shape) throws IOException {
json.beginArray();
for (AABB b : shape.toAabbs()) {
json.beginArray();
json.value(b.minX).value(b.minY).value(b.minZ).value(b.maxX).value(b.maxY).value(b.maxZ);
json.endArray();
}
json.endArray();
}
void items() throws IOException {
json.name("items");
json.beginObject();
for (Item item : BuiltInRegistries.ITEM) {
ResourceLocation id = BuiltInRegistries.ITEM.getKey(item);
if (!ours(id)) continue;
ItemStack stack = new ItemStack(item);
json.name(id.toString());
json.beginObject();
json.name("class").value(item.getClass().getName());
json.name("max_stack_size").value(stack.getMaxStackSize());
json.name("rarity").value(stack.getRarity().getSerializedName());
if (item instanceof BlockItem bi) {
json.name("block").value(BuiltInRegistries.BLOCK.getKey(bi.getBlock()).toString());
}
var food = stack.get(net.minecraft.core.component.DataComponents.FOOD);
if (food != null) {
json.name("food");
json.beginObject();
json.name("nutrition").value(food.nutrition());
json.name("saturation").value(food.saturation());
json.endObject();
}
json.endObject();
}
json.endObject();
}
void recipes() throws IOException {
json.name("recipes");
json.beginObject();
for (RecipeHolder<?> holder : server.getRecipeManager().getRecipes()) {
if (!ours(holder.id())) continue;
var recipe = holder.value();
json.name(holder.id().toString());
json.beginObject();
json.name("type").value(BuiltInRegistries.RECIPE_TYPE.getKey(recipe.getType()).toString());
json.name("serializer").value(BuiltInRegistries.RECIPE_SERIALIZER.getKey(recipe.getSerializer()).toString());
ItemStack result = recipe.getResultItem(server.registryAccess());
json.name("result").value(BuiltInRegistries.ITEM.getKey(result.getItem()).toString());
json.name("count").value(result.getCount());
json.name("ingredients");
json.beginArray();
for (Ingredient ing : recipe.getIngredients()) {
Set<String> ids = new TreeSet<>();
for (ItemStack s : ing.getItems()) ids.add(BuiltInRegistries.ITEM.getKey(s.getItem()).toString());
json.beginArray();
for (String i : ids) json.value(i);
json.endArray();
}
json.endArray();
json.endObject();
}
json.endObject();
}
/** Tags that hold one of our ids, with only those members; and every `c` tag, whole. */
void tags() throws IOException {
json.name("tags");
json.beginObject();
for (String kind : new String[] {"block", "item"}) {
json.name(kind);
json.beginObject();
Map<String, Set<String>> out = new TreeMap<>();
var registry = kind.equals("block") ? BuiltInRegistries.BLOCK : BuiltInRegistries.ITEM;
registry.getTags().forEach(pair -> {
String tag = pair.getFirst().location().toString();
boolean convention = pair.getFirst().location().getNamespace().equals("c");
Set<String> members = new LinkedHashSet<>();
for (var holder : pair.getSecond()) {
ResourceLocation id = holder.unwrapKey().orElseThrow().location();
if (convention || ours(id) || ours(pair.getFirst().location())) members.add(id.toString());
}
if (!members.isEmpty()) out.put(tag, new TreeSet<>(members));
});
for (var e : out.entrySet()) {
json.name(e.getKey());
json.beginArray();
for (String m : e.getValue()) json.value(m);
json.endArray();
}
json.endObject();
}
json.endObject();
}
static String stateKey(BlockState state) {
StringBuilder b = new StringBuilder();
for (Property<?> p : state.getProperties()) {
if (b.length() > 0) b.append(',');
b.append(p.getName()).append('=').append(name(p, state.getValue(p)));
}
return b.toString();
}
@SuppressWarnings({"unchecked", "rawtypes"})
static String name(Property p, Object v) {
return p.getName((Comparable) v);
}
}
}
@@ -0,0 +1,11 @@
# Dev-only: the NeoForge oracle for Horizon's mod-port harnesses (docs/modpacks.md).
# Built and run by tools/neoforge_oracle.py; never shipped.
modLoader = "javafml"
loaderVersion = "[4,)"
license = "Apache-2.0"
[[mods]]
modId = "horizon_oracle"
version = "1"
displayName = "Horizon oracle (dev only)"
description = "Exports block, item, recipe and tag facts for Horizon's parity harnesses."
+217
View File
@@ -0,0 +1,217 @@
#!/usr/bin/env python3
"""Per-mod parity harness for ported mods (docs/modpacks.md, "The Java oracle and per-mod harnesses").
mod_port_harness.py --work WORK [--resources PREPARED] [--jars DIR --deps DIR] [MOD ...]
WORK is a `horizon-port-pack` work folder whose mods were carried over. With --jars the NeoForge
oracle (tools/neoforge_oracle.py, dev-only) first exports WORK/oracle/facts.json. The Horizon side
is crates/horizon-client/examples/mod_port_probe.rs: the content root built from WORK/mods/*/carry
and what the game's loaders make of it. For every block and item the mod registers, compared:
- blocks: declared in Horizon at all; per state hardness, explosion resistance, light, tool need,
friction, map colour, sounds, outline and collision shapes;
- drops: the loot of each sampled state for hand, diamond tools, shears and silk touch;
- placement: the state the block takes when placed, against its template's in the same oracle
(Horizon places the template as vanilla does, which the vanilla harnesses check);
- tags: the vanilla block tags (tool and mining tags) holding the mod's blocks;
- recipes: each recipe's result, count and ingredients;
- items: present, and their stack size.
Each mod is probed on its own, against vanilla. Writes WORK/mods/<id>/harness/{horizon,result}.json
per mod and prints a table. Jars, facts and results stay
in WORK, outside the repository.
"""
import argparse
import json
import math
import subprocess
import sys
from pathlib import Path
ROOT = Path(__file__).resolve().parents[1]
CHECKS = ['blocks', 'properties', 'sounds', 'shapes', 'drops', 'placement', 'tags', 'recipes', 'items']
EXAMPLES = 8
def key(k):
return ','.join(sorted(p for p in k.split(',') if p))
def cells(boxes, grid=32):
out = set()
for b in boxes:
lo = [math.floor(round(v * grid, 6)) for v in b[:3]]
hi = [math.ceil(round(v * grid, 6)) for v in b[3:]]
for x in range(lo[0], hi[0]):
for y in range(lo[1], hi[1]):
for z in range(lo[2], hi[2]):
out.add((x, y, z))
return out
def same_shape(a, b):
if a is None or b is None:
return a == b
sa, sb = sorted(map(tuple, a)), sorted(map(tuple, b))
if sa == sb:
return True
return cells(a) == cells(b)
class Check:
def __init__(self):
self.passed = 0
self.failed = 0
self.examples = []
def record(self, ok, what):
if ok:
self.passed += 1
else:
self.failed += 1
if len(self.examples) < EXAMPLES:
self.examples.append(what)
def json(self):
return {'passed': self.passed, 'failed': self.failed, 'examples': self.examples}
def sound_upgrades(oracle, horizon):
"""The oracle version's vanilla sound sets → this version's, through the vanilla blocks both have."""
out = {}
for name, hs in horizon.get('vanilla_sounds', {}).items():
ob = oracle['blocks'].get(name)
if ob:
os_ = ob['states'].get(ob['default']) or next(iter(ob['states'].values()))
out.setdefault(json.dumps(os_['sound'], sort_keys=True), []).append(hs)
return out
def compare_mod(mod, oracle, horizon, carry, upgrades, old_items):
checks = {c: Check() for c in CHECKS}
prefix = mod + ':'
templates = {prefix + b: t for b, t in carry.get('blocks', {}).items()}
vanilla_tags = {t: set(m) for t, m in oracle['tags']['block'].items() if t.startswith('minecraft:')}
for name, ob in oracle['blocks'].items():
if not name.startswith(prefix):
continue
hb = horizon['blocks'].get(name)
checks['blocks'].record(hb is not None, f'{name}: not in Horizon ({carry.get("blocks_unknown", {}).get(name[len(prefix):], "left out")})')
if hb is None:
continue
for k, os_ in ob['states'].items():
hs = hb['states'].get(k)
if hs is None:
checks['properties'].record(False, f'{name}[{k}]: no such state in Horizon')
continue
props = [('hardness', os_['hardness'], hs['hardness']),
('explosion_resistance', ob['explosion_resistance'], hs['explosion_resistance']),
('emission', os_['emission'], hs['emission']),
('requires_tool', os_['requires_tool'], hs['requires_tool']),
('friction', ob['friction'], hs['friction']),
('map_color', os_['map_color_id'], hs['map_color_id'])]
bad = [f'{p} {o} vs {h}' for p, o, h in props
if (abs(o - h) > 1e-6 if isinstance(o, float) else o != h)]
checks['properties'].record(not bad, f'{name}[{k}]: ' + '; '.join(bad))
upgraded = upgrades.get(json.dumps(os_['sound'], sort_keys=True), [])
checks['sounds'].record(os_['sound'] == hs['sound'] or hs['sound'] in upgraded,
f'{name}[{k}]: {os_["sound"]["break"]} vs {hs["sound"]["break"]}')
shapes_ok = same_shape(os_['outline'], hs['outline']) and same_shape(os_['collision'], hs['collision'])
checks['shapes'].record(shapes_ok, f'{name}[{k}]: outline {os_["outline"]} vs {hs["outline"]}')
for tool, odrops in os_.get('drops', {}).items():
hdrops = (hs.get('drops') or {}).get(tool)
checks['drops'].record(odrops == hdrops, f'{name}[{k}] {tool}: {odrops} vs {hdrops}')
# Placement: the mod block against its template, both in the oracle.
template = templates.get(name)
ot = oracle['blocks'].get(template) if template else None
if ot and 'placement' in ob:
for face, placed in ob['placement'].items():
theirs = ot.get('placement', {}).get(face)
checks['placement'].record(
placed is not None and theirs is not None and key(placed) == key(theirs),
f'{name} on {face}: {placed} vs {template} {theirs}')
for tag, members in vanilla_tags.items():
if name in members:
checks['tags'].record(name in horizon['block_tags'].get(tag, []), f'{name}: not in #{tag}')
for rid, orec in oracle['recipes'].items():
if not rid.startswith(prefix):
continue
hrec = horizon['recipes'].get(rid)
if hrec is None:
checks['recipes'].record(False, f'{rid} ({orec["type"]}): not loaded')
continue
# Vanilla items added after the oracle's version (pale oak in a log tag) are not the mod's.
newer = lambda i: i.startswith('minecraft:') and old_items and i not in old_items
oing = sorted(sorted(i) for i in orec['ingredients'] if i)
hing = sorted(sorted(x for x in i if not newer(x)) for i in hrec.get('ingredients', []) if i)
ok = (orec['result'], orec['count']) == (hrec.get('result'), hrec.get('count')) and oing == hing
why = f'{rid}: {orec["result"]} x{orec["count"]} vs {hrec.get("result")} x{hrec.get("count")}'
if oing != hing:
missing = [i for i in oing if i not in hing][:2]
why += f'; ingredients differ, e.g. oracle {missing}'
checks['recipes'].record(ok, why)
for iid, oi in oracle['items'].items():
if not iid.startswith(prefix):
continue
hi = horizon['items'].get(iid)
checks['items'].record(hi is not None and hi['max_stack_size'] == oi['max_stack_size'],
f'{iid}: {"missing" if hi is None else "stack " + str(hi["max_stack_size"])}')
result = {c: v.json() for c, v in checks.items()}
failed = sum(v.failed for v in checks.values())
total = sum(v.passed + v.failed for v in checks.values())
return {'mod': mod, 'passed': failed == 0 and total > 0, 'checks': result,
'blocks_with_differences': len(carry.get('differences', {}))}
def main():
parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
parser.add_argument('--work', required=True)
parser.add_argument('--resources', default=str(ROOT / '.local/horizon-client/26.3'))
parser.add_argument('--jars', help='export the oracle facts from these jars first')
parser.add_argument('--deps')
parser.add_argument('mods', nargs='*')
args = parser.parse_args()
work = Path(args.work).resolve()
facts = work / 'oracle' / 'facts.json'
if args.jars:
facts.parent.mkdir(parents=True, exist_ok=True)
command = [sys.executable, str(ROOT / 'tools/neoforge_oracle.py'), 'export', '--jars', args.jars, '--out', str(facts)]
if args.deps:
command += ['--deps', args.deps]
subprocess.run(command, check=True)
if not facts.exists():
sys.exit(f'{facts}: no oracle facts (run with --jars, or tools/neoforge_oracle.py export)')
subprocess.run(['cargo', 'build', '--release', '-q', '-p', 'horizon-client', '--example', 'mod_port_probe'],
cwd=ROOT, check=True)
metadata = json.loads(subprocess.check_output(['cargo', 'metadata', '--no-deps', '--format-version', '1'],
cwd=ROOT, text=True))
probe = Path(metadata['target_directory']) / 'release/examples/mod_port_probe'
oracle = json.loads(facts.read_text())
old_items = set(oracle.get('vanilla_items', []))
mods = args.mods or sorted(p.name for p in (work / 'mods').iterdir() if (p / 'carry').is_dir())
rows = []
for mod in mods:
# One mod at a time: each against vanilla, as a player adding it would load it (and a pack's
# sum may pass the block states a world holds, which the probe would refuse).
out = work / 'mods' / mod / 'harness' / 'horizon.json'
out.parent.mkdir(parents=True, exist_ok=True)
subprocess.run([str(probe), args.resources, str(work), str(out), mod], check=True)
horizon = json.loads(out.read_text())
carry_report = work / 'mods' / mod / 'carry-report.json'
carry = json.loads(carry_report.read_text()) if carry_report.exists() else {}
rows.append(compare_mod(mod, oracle, horizon, carry, sound_upgrades(oracle, horizon), old_items))
print(f'{"mod":<16} {"result":<7} ' + ' '.join(f'{c:>12}' for c in CHECKS))
for result in rows:
mod = result['mod']
(work / 'mods' / mod / 'harness').mkdir(parents=True, exist_ok=True)
(work / 'mods' / mod / 'harness' / 'result.json').write_text(json.dumps(result, indent=1))
cols = []
for c in CHECKS:
r = result['checks'][c]
n = r['passed'] + r['failed']
cols.append(f'{r["passed"]}/{n}' if n else '-')
print(f'{mod:<16} {"pass" if result["passed"] else "FAIL":<7} ' + ' '.join(f'{c:>12}' for c in cols))
if __name__ == '__main__':
main()
+242
View File
@@ -0,0 +1,242 @@
#!/usr/bin/env python3
"""Dev-only NeoForge oracle for Horizon's mod-port harnesses (docs/modpacks.md).
neoforge_oracle.py export --jars DIR [--deps DIR] [--namespaces a,b] --out FACTS.json
installs a NeoForge server under .local/neoforge-oracle (once), builds the exporter mod in
mods/horizon/src/neoforge-oracle, starts the server headless with the given mod jars, and writes every
block, item, recipe and tag of the mods' namespaces (and the vanilla blocks, for templates) to
FACTS.json. The jars are the user's own; nothing here is shipped or committed.
"""
import argparse
import json
import os
import shutil
import subprocess
import sys
import time
import urllib.request
import zipfile
from pathlib import Path
ROOT = Path(__file__).resolve().parents[1]
LOCAL = ROOT / '.local' / 'neoforge-oracle'
SOURCE = ROOT / 'mods' / 'horizon' / 'src' / 'neoforge-oracle'
# ATM10 8.x: Minecraft 1.21.1 on NeoForge 21.1.259 (docs/modpacks.md).
NEOFORGE = os.environ.get('HORIZON_NEOFORGE', '21.1.259')
MAVEN = 'https://maven.neoforged.net/releases/net/neoforged/neoforge'
def install():
"""The NeoForge server, installed once per version."""
home = LOCAL / NEOFORGE
args = home / f'libraries/net/neoforged/neoforge/{NEOFORGE}/unix_args.txt'
if args.exists():
return home
home.mkdir(parents=True, exist_ok=True)
installer = LOCAL / f'neoforge-{NEOFORGE}-installer.jar'
if not installer.exists():
url = f'{MAVEN}/{NEOFORGE}/neoforge-{NEOFORGE}-installer.jar'
with urllib.request.urlopen(url, timeout=120) as r:
installer.write_bytes(r.read())
with (LOCAL / f'install-{NEOFORGE}.log').open('w') as log:
subprocess.run(['java', '-jar', str(installer), '--installServer', str(home)],
cwd=LOCAL, stdout=log, stderr=subprocess.STDOUT, check=True)
return home
def client():
"""The NeoForge client (tools/perf_bench.py --game neoforge), installed once per version: the installer's
own files, then the vanilla libraries its version inherits, fetched as the launcher does (sha1-checked)."""
sys.path.insert(0, str(ROOT / 'tools'))
import hashlib
import lab
home = LOCAL / f'client-{NEOFORGE}'
profile = home / 'versions' / f'neoforge-{NEOFORGE}' / f'neoforge-{NEOFORGE}.json'
if not profile.exists():
install() # the installer jar
home.mkdir(parents=True, exist_ok=True)
(home / 'launcher_profiles.json').write_text('{"profiles":{}}')
with (LOCAL / f'install-client-{NEOFORGE}.log').open('w') as log:
subprocess.run(['java', '-jar', str(LOCAL / f'neoforge-{NEOFORGE}-installer.jar'), '--installClient',
str(home)], cwd=LOCAL, stdout=log, stderr=subprocess.STDOUT, check=True)
neo = json.loads(profile.read_text())
base = json.loads((home / 'versions' / neo['inheritsFrom'] / f'{neo["inheritsFrom"]}.json').read_text())
jars = []
for manifest in (neo, base):
names = {library['name'] for library in manifest['libraries']}
for library in manifest['libraries']:
artifact = library.get('downloads', {}).get('artifact')
if not artifact or not lab.library_allowed(library) or not lab.native_library_matches(library, None, names):
continue
path = home / 'libraries' / artifact['path']
if not path.exists():
with urllib.request.urlopen(artifact['url'], timeout=120) as r:
data = r.read()
if hashlib.sha1(data).hexdigest() != artifact['sha1']:
sys.exit(f'{artifact["url"]}: sha1 mismatch')
path.parent.mkdir(parents=True, exist_ok=True)
path.write_bytes(data)
if path not in jars:
jars.append(path)
return home, neo, base, jars
def client_command(java, heap, game_dir, natives, assets, jvm=(), game=()):
"""The command the launcher would run for the NeoForge client profile, with no account."""
home, neo, base, jars = client()
import lab
values = {'library_directory': str(home / 'libraries'), 'classpath_separator': os.pathsep,
'version_name': f'neoforge-{NEOFORGE}', 'natives_directory': str(natives),
'launcher_name': 'horizon-bench', 'launcher_version': '1'}
expand = lambda s: s.replace('${', '{').format(**values)
command = [str(java), f'-Xmx{heap}']
for argument in base['arguments']['jvm']:
if isinstance(argument, dict):
if lab.library_allowed(argument):
command += [argument['value']] if isinstance(argument['value'], str) else argument['value']
elif argument == '${classpath}':
# Every library; not the vanilla jar, which NeoForge's patched client replaces.
command.append(os.pathsep.join(map(str, jars)))
else:
command.append(expand(argument))
command += [expand(a) for a in neo['arguments']['jvm']]
command += [*jvm, neo['mainClass']]
command += ['--username', 'Bench', '--uuid', '00000000000000000000000000000000', '--accessToken', '0',
'--version', f'neoforge-{NEOFORGE}', '--gameDir', str(game_dir), '--assetsDir', str(assets),
'--assetIndex', base['assetIndex']['id'], '--userType', 'msa', '--versionType', 'release',
*neo['arguments']['game'], *game]
return home, command
def build_bench(home):
"""The NeoForge benchmark driver (mods/horizon/src/neoforge-bench), against the client."""
return build(home, ROOT / 'mods/horizon/src/neoforge-bench', 'horizon-bench-neoforge.jar', client_classpath(home))
def client_classpath(home):
libs = home / 'libraries'
first = [libs / f'net/neoforged/neoforge/{NEOFORGE}/neoforge-{NEOFORGE}-client.jar',
libs / f'net/neoforged/neoforge/{NEOFORGE}/neoforge-{NEOFORGE}-universal.jar']
rest = sorted(p for p in libs.rglob('*.jar') if p not in first and 'slim' not in p.name
and 'extra' not in p.name and not p.name.endswith('-unpacked.jar'))
return os.pathsep.join(map(str, first + rest))
def classpath(home):
libs = home / 'libraries'
first = [libs / f'net/neoforged/neoforge/{NEOFORGE}/neoforge-{NEOFORGE}-server.jar',
libs / f'net/neoforged/neoforge/{NEOFORGE}/neoforge-{NEOFORGE}-universal.jar']
rest = sorted(p for p in libs.rglob('*.jar') if p not in first and 'slim' not in p.name
and 'extra' not in p.name and not p.name.endswith('-unpacked.jar'))
return os.pathsep.join(map(str, first + rest))
def build(home, source=SOURCE, name='horizon-oracle.jar', cp=None):
"""A dev-only mod jar (by default the exporter), rebuilt when its sources change."""
out = LOCAL / 'build'
jar = out / name
sources = sorted((source / 'java').rglob('*.java'))
resources = sorted(p for p in (source / 'resources').rglob('*') if p.is_file())
newest = max(p.stat().st_mtime for p in sources + resources)
if jar.exists() and jar.stat().st_mtime > newest:
return jar
classes = out / f'classes-{Path(name).stem}'
shutil.rmtree(classes, ignore_errors=True)
classes.mkdir(parents=True)
javac = subprocess.run(['javac', '--release', '21', '-proc:none', '-nowarn', '-cp', cp or classpath(home),
'-d', str(classes), *map(str, sources)], capture_output=True, text=True)
if javac.returncode:
sys.exit(f'{name} does not compile:\n{javac.stdout}{javac.stderr}')
with zipfile.ZipFile(jar, 'w', zipfile.ZIP_DEFLATED) as z:
for p in sorted(classes.rglob('*.class')):
z.write(p, p.relative_to(classes).as_posix())
for p in resources:
z.write(p, p.relative_to(source / 'resources').as_posix())
return jar
SERVER_PROPERTIES = """level-type=minecraft\\:flat
online-mode=false
server-port=0
spawn-protection=0
view-distance=2
simulation-distance=2
generate-structures=false
spawn-monsters=false
spawn-animals=false
"""
def instance(name, jars, extra=()):
"""A server folder with `jars` (and the exporter) in mods/."""
home = install()
run = LOCAL / 'runs' / name
shutil.rmtree(run, ignore_errors=True)
(run / 'mods').mkdir(parents=True)
(run / 'libraries').symlink_to(home / 'libraries')
(run / 'eula.txt').write_text('eula=true\n')
(run / 'server.properties').write_text(SERVER_PROPERTIES)
for jar in [*jars, *extra]:
(run / 'mods' / Path(jar).name).symlink_to(Path(jar).resolve())
return home, run
def start(home, run, props, log_name='server.log', timeout=900):
"""Runs the server to its end; returns (seconds, the log)."""
args = home / f'libraries/net/neoforged/neoforge/{NEOFORGE}/unix_args.txt'
command = ['java', '-Xmx4G', *[f'-D{k}={v}' for k, v in props.items()], f'@{args}', 'nogui']
began = time.monotonic()
with (run / log_name).open('w') as log:
subprocess.run(command, cwd=run, stdin=subprocess.DEVNULL, stdout=log,
stderr=subprocess.STDOUT, timeout=timeout)
return time.monotonic() - began, (run / log_name).read_text(errors='replace')
def mod_ids(jar):
"""The mod ids a jar declares (its neoforge.mods.toml)."""
import tomllib
with zipfile.ZipFile(jar) as z:
for name in ('META-INF/neoforge.mods.toml', 'META-INF/mods.toml'):
if name in z.namelist():
try:
toml = tomllib.loads(z.read(name).decode('utf-8', 'replace'))
except tomllib.TOMLDecodeError:
return []
return [m.get('modId', '') for m in toml.get('mods', [])]
return []
def export(args):
jars = sorted(Path(args.jars).glob('*.jar'))
deps = sorted(Path(args.deps).glob('*.jar')) if args.deps else []
namespaces = args.namespaces or ','.join(i for j in jars for i in mod_ids(j))
home = install()
exporter = build(home)
home, run = instance('export', jars, [*deps, exporter])
out = Path(args.out).resolve()
out.unlink(missing_ok=True)
seconds, log = start(home, run, {'horizon.oracle.out': out, 'horizon.oracle.namespaces': namespaces})
if not out.exists():
tail = '\n'.join(log.splitlines()[-40:])
sys.exit(f'the oracle wrote nothing; the end of {run / "server.log"}:\n{tail}')
facts = json.loads(out.read_text())
mods = sum(1 for b in facts['blocks'] if not b.startswith('minecraft:'))
print(f'{out}: {mods} mod blocks, {len(facts["items"])} items, {len(facts["recipes"])} recipes '
f'({namespaces}); server ran {seconds:.1f} s')
def main():
parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
sub = parser.add_subparsers(dest='command', required=True)
e = sub.add_parser('export', help='write the facts of the mods in --jars')
e.add_argument('--jars', required=True, help='the mods to export')
e.add_argument('--deps', help='their required libraries (loaded, not exported)')
e.add_argument('--namespaces', help='comma-separated; default: the jars\' mod ids')
e.add_argument('--out', required=True)
args = parser.parse_args()
{'export': export}[args.command](args)
if __name__ == '__main__':
main()
+93 -6
View File
@@ -13,6 +13,11 @@ for every game. RSS is sampled from outside the process for every game too.
python3 tools/perf_bench.py --game vanilla-mods --label mods-m4
python3 tools/perf_bench.py --table horizon-m4 vanilla-m4 mods-m4
A ported mod pack against the same mods on their own loader (docs/modpacks.md, "Measured"):
python3 tools/perf_bench.py --game horizon --port-work WORK --label pack-horizon
python3 tools/perf_bench.py --game neoforge --mod-jars JARS --deps DEPS --label pack-neoforge
Games:
horizon target/release/horizon-client, driven over its control socket
vanilla your own 26.3 client.jar + Fabric Loader + a dev-only driver
@@ -20,6 +25,13 @@ Games:
is redistributed
vanilla-mods the same + Sodium, Lithium, FerriteCore and ImmediatelyFast
(pinned in packs/mods.lock.json)
neoforge Minecraft 1.21.1 on NeoForge (dev-only, tools/neoforge_oracle.py
installs it under .local/neoforge-oracle) + a driver mod
(mods/horizon/src/neoforge-bench) + the jars of --mod-jars and
--deps, the user's own; 26.3 options it does not know are ignored
--port-work loads the mods a horizon-port-pack work folder carried over into
Horizon as dev mods.
Results: benchmarks/perf/<label>-rd<N>.json, one benchmark report per render
distance (docs/benchmark-report.md), over --repeats games. Games run with no
@@ -105,6 +117,8 @@ OPTIONS = {
LAUNCHER_JVM = ["-XX:+UnlockExperimentalVMOptions", "-XX:+UseG1GC", "-XX:G1NewSizePercent=20",
"-XX:G1ReservePercent=20", "-XX:MaxGCPauseMillis=50", "-XX:G1HeapRegionSize=32M"]
PERF_MODS = ["sodium", "lithium", "ferrite-core", "immediatelyfast"]
# Minecraft 1.21.1's data version, for the NeoForge client's options.txt (it ignores 26.3's newer keys).
NEOFORGE_DATA_VERSION = "3955"
# The benchmark report format, version 1 (docs/benchmark-report.md). crates/horizon-bench is the
@@ -211,9 +225,10 @@ def nvidia_memory_mb(pid):
return None
def write_options(game_dir, distance):
def write_options(game_dir, distance, version=None):
game_dir.mkdir(parents=True, exist_ok=True)
text = "".join(f"{k}:{v.format(distance=distance)}\n" for k, v in OPTIONS.items())
options = dict(OPTIONS, version=version) if version else OPTIONS
text = "".join(f"{k}:{v.format(distance=distance)}\n" for k, v in options.items())
(game_dir / "options.txt").write_text(text)
return text
@@ -324,6 +339,8 @@ def run_horizon(args, distance):
"--control-socket", str(sock), "--no-pause", "--weather", "clear", "--time", "6000"]
if args.offscreen:
command.append("--offscreen")
for carry in dev_mods(args):
command += ["--dev-mod", str(carry)]
env = dict(os.environ, HORIZON_NO_AUDIO="1")
log = (WORK / f"horizon-rd{distance}.log").open("w")
started = time.time()
@@ -376,6 +393,13 @@ def run_horizon(args, distance):
return result
def dev_mods(args):
"""The carried-over mods of a horizon-port-pack work folder (docs/modpacks.md), loaded as dev mods."""
if not args.port_work:
return []
return sorted(p for p in (Path(args.port_work) / "mods").glob("*/carry") if (p / "horizon-mod.toml").exists())
# Vanilla -------------------------------------------------------------------
def vanilla_manifest():
@@ -491,6 +515,11 @@ def run_vanilla(args, distance):
libs = [p for p in (os.environ.get("NIX_LD_LIBRARY_PATH", ""), "/run/opengl-driver/lib") if p]
env["LD_LIBRARY_PATH"] = ":".join(libs + [env.get("LD_LIBRARY_PATH", "")]).strip(":")
log = (WORK / f"{args.game}-rd{distance}.log").open("w")
return driven(args, distance, command, game_dir, env, log, events, options, loaded_mods)
def driven(args, distance, command, game_dir, env, log, events, options, loaded_mods):
"""Runs a Java client whose driver mod writes `events`, and reads its results."""
started = time.time()
proc = subprocess.Popen(command, cwd=game_dir, env=env, stdout=log, stderr=subprocess.STDOUT)
sampler = Sampler(proc.pid)
@@ -508,7 +537,7 @@ def run_vanilla(args, distance):
lines = [json.loads(l) for l in events.read_text().splitlines()] if events.exists() else []
by = lambda name: [e for e in lines if e["event"] == name]
if not by("done") or by("timeout"):
raise RuntimeError(f"vanilla run failed: {lines[-1:] if lines else 'no events'}; see {log.name}")
raise RuntimeError(f"{args.game} run failed: {lines[-1:] if lines else 'no events'}; see {log.name}")
title, world = by("title")[0], by("world")[0]
result = {
"options_txt": options, "mods": loaded_mods, "heap": args.heap,
@@ -532,6 +561,55 @@ def run_vanilla(args, distance):
return result
# NeoForge ------------------------------------------------------------------
def run_neoforge(args, distance):
"""A NeoForge 1.21.1 client (dev-only, tools/neoforge_oracle.py) with the driver mod and --mod-jars:
the mods a ported pack replaces, on the loader the pack runs on."""
import neoforge_oracle
home = neoforge_oracle.client()[0]
mod = neoforge_oracle.build_bench(home)
game_dir = WORK / args.game
shutil.rmtree(game_dir, ignore_errors=True)
options = write_options(game_dir, distance, version=NEOFORGE_DATA_VERSION)
mods = game_dir / "mods"
mods.mkdir()
shutil.copy(mod, mods)
loaded_mods = ["horizon-bench"]
for folder in filter(None, (args.mod_jars, args.deps)):
for jar in sorted(Path(folder).glob("*.jar")):
shutil.copy(jar, mods)
loaded_mods.append(jar.name)
natives = WORK / "natives-neoforge"
script = WORK / "script.json"
script.write_text(json.dumps({
"world": WORLD, "seed": SEED, "settle": args.settle, "seconds": args.seconds, "timeout": args.timeout,
"scenes": [{"name": n, "from": a, "to": b, "pitch": p} for n, a, b, p in scene_list(args)],
}))
events = WORK / f"{args.game}-rd{distance}.events.jsonl"
events.unlink(missing_ok=True)
assets = WORK / "assets"
(assets / "indexes").mkdir(parents=True, exist_ok=True)
java = Path(os.environ["JAVA_HOME"]) / "bin/java" if os.environ.get("JAVA_HOME") else "java"
_, command = neoforge_oracle.client_command(
java, args.heap, game_dir, natives, assets,
jvm=[*LAUNCHER_JVM, f"-Dhorizon.bench.script={script}", f"-Dhorizon.bench.out={events}"],
game=["--width", str(args.width), "--height", str(args.height)])
natives.mkdir(parents=True, exist_ok=True)
extract_natives(neoforge_oracle.client()[3], natives)
env = dict(os.environ, ALSOFT_DRIVERS="null")
for attempt in (1, 2):
log = (WORK / f"{args.game}-rd{distance}.log").open("w")
try:
return driven(args, distance, command, game_dir, env, log, events, options, loaded_mods)
except RuntimeError:
# FML sometimes reads config/fml.toml while creating it on a first start, and crashes before
# the title screen; a crash once the driver started is a real failure.
if attempt == 2 or events.exists():
raise
shutil.rmtree(game_dir / "crash-reports", ignore_errors=True)
def stop(proc):
try:
proc.wait(timeout=60)
@@ -654,7 +732,7 @@ def table(labels):
def main():
p = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
p.add_argument("--game", choices=["horizon", "vanilla", "vanilla-mods"], default="horizon")
p.add_argument("--game", choices=["horizon", "vanilla", "vanilla-mods", "neoforge"], default="horizon")
p.add_argument("--label", help="result name (default <game>-<host>)")
p.add_argument("--distances", default="8,16,32")
p.add_argument("--scenes", help="comma-separated subset of " + ",".join(s[0] for s in SCENES))
@@ -669,6 +747,9 @@ def main():
p.add_argument("--resources", default=str(ROOT / ".local/horizon-client/26.3"))
p.add_argument("--build", default=str(ROOT / "target/release"))
p.add_argument("--repeats", type=int, default=3, help="games per render distance; the report gives means and 95%% CIs")
p.add_argument("--port-work", help="horizon: also load the mods carried over in this horizon-port-pack work folder")
p.add_argument("--mod-jars", help="neoforge: the mod jars to load (the user's own; never committed)")
p.add_argument("--deps", help="neoforge: their required libraries")
p.add_argument("--table", nargs="+", metavar="LABEL", help="print markdown tables of saved runs, and exit")
args = p.parse_args()
if args.table:
@@ -676,7 +757,7 @@ def main():
return
args.label = args.label or f"{args.game}-{platform.node().split('.')[0]}"
WORK.mkdir(parents=True, exist_ok=True)
run = run_horizon if args.game == "horizon" else run_vanilla
run = {"horizon": run_horizon, "neoforge": run_neoforge}.get(args.game, run_vanilla)
for d in [int(x) for x in args.distances.split(",")]:
runs = []
for _ in range(args.repeats):
@@ -696,7 +777,13 @@ def app(args):
capture_output=True, text=True).stdout.strip() or None
manifest = (ROOT / "crates/horizon-client/Cargo.toml").read_text()
version = next(l.split('"')[1] for l in manifest.splitlines() if l.startswith("version"))
return {"name": "horizon-client", "version": version, "commit": commit}
mods = [{"name": p.parent.name, "version": "carried"} for p in dev_mods(args)]
return {"name": "horizon-client", "version": version, "commit": commit, **({"mods": mods} if mods else {})}
if args.game == "neoforge":
import neoforge_oracle
jars = [j.name for f in filter(None, (args.mod_jars, args.deps)) for j in sorted(Path(f).glob("*.jar"))]
return {"name": "minecraft", "version": "1.21.1",
"mods": [{"name": "neoforge", "version": neoforge_oracle.NEOFORGE}] + [{"name": j} for j in jars]}
lock = json.loads((ROOT / "packs/mods.lock.json").read_text())
mods = [{"name": "fabric-loader", "version": lock["fabric_loader"]}]
if args.game == "vanilla-mods":