Merge branch 'parity/hud' into parity-base

This commit is contained in:
Ludovic Marie
2026-10-12 16:43:50 +02:00
53 changed files with 6563 additions and 424 deletions
@@ -61,6 +61,7 @@ fn parser_id(ty: &ArgType) -> String {
_ => "minecraft:template_rotation".into(),
},
ArgType::HexColor => "minecraft:hex_color".into(),
ArgType::ResourceSelector(_) => "minecraft:resource_selector".into(),
ArgType::Uuid => "minecraft:uuid".into(),
ArgType::GameProfile => "minecraft:game_profile".into(),
ArgType::Style => "minecraft:style".into(),
@@ -120,7 +121,8 @@ fn tree(d: &Dispatcher, node: usize) -> Value {
}
children.insert(child.name().to_owned(), v);
}
let mut v = json!({"children": children});
let order: Vec<&str> = n.children.iter().map(|&c| d.nodes[c].name()).collect();
let mut v = json!({"children": children, "order": order});
if n.command.is_some() {
v["executable"] = json!(true);
}
+3 -1
View File
@@ -57,7 +57,9 @@ impl BossBar {
hover: Some(Box::new(Text::literal(self.id.clone()))),
..Style::default()
};
bracketed(comp_text(&self.name).with_style(&style))
// ComponentUtils.wrapInSquareBrackets(name).withStyle(...): the
// brackets take the colour too.
bracketed(comp_text(&self.name)).with_style(&style)
}
/// The filled fraction of the bar (`BossEvent.getProgress`).
pub fn progress(&self) -> f32 {
+136 -1
View File
@@ -83,6 +83,73 @@ pub struct RegistryIds {
}
const EMPTY: &[String] = &[];
impl Registries {
/// Fill what the game did not build itself from vanilla's exported
/// registries (`command-registries.json`, written by
/// `VanillaCommandParseOracle registries`): built-in registries such as
/// mob effects, data component types and dialogs, block entities and tag
/// members. Registries that data packs reload stay with the game.
pub fn fill_from_export(&mut self, r: &serde_json::Value) {
fn strings(v: &serde_json::Value) -> Vec<String> {
v.as_array()
.map(|a| {
a.iter()
.filter_map(|x| x.as_str().map(str::to_owned))
.collect()
})
.unwrap_or_default()
}
let fill = |field: &mut Vec<String>, key: &str| {
if field.is_empty() {
*field = strings(&r[key]);
}
};
fill(&mut self.effects, "effects");
fill(&mut self.enchantments, "enchantments");
fill(&mut self.attributes, "attributes");
fill(&mut self.damage_types, "damage_types");
fill(&mut self.templates, "templates");
fill(&mut self.persistent_components, "persistent_components");
fill(&mut self.learnable_recipes, "learnable_recipes");
const RELOADED: [&str; 5] = [
"minecraft:advancement",
"minecraft:recipe",
"minecraft:loot_table",
"minecraft:predicate",
"minecraft:item_modifier",
];
for (name, entry) in r["by_registry"].as_object().into_iter().flatten() {
if RELOADED.contains(&name.as_str()) || self.by_registry.contains_key(name) {
continue;
}
self.by_registry.insert(
name.clone(),
RegistryIds {
ids: strings(&entry["ids"]),
tags: strings(&entry["tags"]),
},
);
}
if self.block_entities.is_empty() {
self.block_entities = strings(&r["block_entities"]).into_iter().collect();
}
if self.block_tag_members.is_empty() {
for (tag, members) in r["block_tag_members"].as_object().into_iter().flatten() {
self.block_tag_members.insert(tag.clone(), strings(members));
}
}
if self.clock_time_markers.is_empty() {
for (clock, markers) in r["clock_time_markers"].as_object().into_iter().flatten() {
self.clock_time_markers
.insert(clock.clone(), strings(markers));
}
}
if self.advancement_criteria.is_empty() {
for (id, criteria) in r["advancement_criteria"].as_object().into_iter().flatten() {
self.advancement_criteria
.insert(id.clone(), strings(criteria));
}
}
}
/// The element ids of a registry (sorted).
pub fn ids(&self, registry: &str) -> &[String] {
if let Some(r) = self.by_registry.get(registry) {
@@ -254,6 +321,47 @@ pub enum ArgType {
SlotSource,
/// ResourceOrIdArgument over a registry: an id or an inline SNBT value.
ResourceOrId(&'static str),
/// ResourceSelectorArgument: a `*`/`?` pattern over a registry's ids.
ResourceSelector(&'static str),
}
/// FilenameUtils.wildcardMatch (case-sensitive) of `*` and `?` patterns.
pub fn wildcard_match(text: &str, pattern: &str) -> bool {
let t: Vec<char> = text.chars().collect();
let p: Vec<char> = pattern.chars().collect();
let (mut ti, mut pi) = (0, 0);
let (mut star, mut mark) = (None, 0);
while ti < t.len() {
if pi < p.len() && (p[pi] == '?' || p[pi] == t[ti]) {
ti += 1;
pi += 1;
} else if pi < p.len() && p[pi] == '*' {
star = Some(pi);
mark = ti;
pi += 1;
} else if let Some(s) = star {
pi = s + 1;
mark += 1;
ti = mark;
} else {
return false;
}
}
while pi < p.len() && p[pi] == '*' {
pi += 1;
}
pi == p.len()
}
/// ResourceSelectorArgument: the registry ids a pattern selects.
pub fn select_resources<'a>(ids: &'a [String], pattern: &str) -> Vec<&'a String> {
let pattern = if pattern.contains(':') {
pattern.to_owned()
} else {
format!("minecraft:{pattern}")
};
ids.iter()
.filter(|id| wildcard_match(id, &pattern))
.collect()
}
/// SlotRanges.SLOTS: every slot range name and its size, in vanilla order.
@@ -1348,6 +1456,29 @@ impl ArgType {
}
Arg::Str(name.to_owned())
}
ArgType::ResourceSelector(registry) => {
let start = reader.cursor;
while reader.can_read() && {
let c = reader.peek();
is_id_char(c) || c == '*' || c == '?'
} {
reader.skip();
}
let raw = reader.string[start..reader.cursor].to_owned();
let pattern = if raw.contains(':') {
raw
} else {
format!("minecraft:{raw}")
};
if select_resources(reg.ids(registry), &pattern).is_empty() {
return Err(CommandError::tr_at(
"argument.resource_selector.not_found",
&[&pattern, registry],
reader,
));
}
Arg::Str(pattern)
}
ArgType::HexColor => {
let text = reader.read_unquoted_string();
if !matches!(text.len(), 3 | 6) {
@@ -1579,7 +1710,8 @@ impl ArgType {
if block {
parse_coord_int(reader)
} else {
parse_coord_double(reader, false)
// Vec2Argument.vec2(): integers are centred on the block.
parse_coord_double(reader, true)
}
};
let x = one(reader)?;
@@ -1741,6 +1873,9 @@ impl ArgType {
}
ArgType::StrEnum(values, _) => builder.suggest_matching(values.iter().copied()),
ArgType::HexColor => builder.suggest_matching(["F00", "FF0000"]),
ArgType::ResourceSelector(registry) => {
suggest_resources(builder, reg.ids(registry), "")
}
ArgType::GameProfile => {
let players = reg.players.clone();
super::selector::suggest(builder, reg, &|b| {
+29 -5
View File
@@ -77,11 +77,23 @@ fn require(map: &Compound, t: &Tag, keys: &[&str]) -> Result<(), String> {
Err(missing.join("; "))
}
}
/// The required fields of each context number provider type, in the
/// order DataFixerUpper reports them missing (the reverse of the record's).
fn provider_fields(id: &str, map: &Compound, t: &Tag) -> Result<(), String> {
match id {
"minecraft:uniform" => require(map, t, &["max", "min"]),
"minecraft:constant" => require(map, t, &["value"]),
"minecraft:binomial" => require(map, t, &["n", "p"]),
match id.trim_start_matches("minecraft:") {
"uniform" => require(map, t, &["max", "min"]),
"constant" => require(map, t, &["value"]),
"binomial" => require(map, t, &["p", "n"]),
"add" | "mul" | "avg" | "max" | "min" | "length" => require(map, t, &["inputs"]),
"sub" | "div" | "mod" | "floor_div" | "floor_mod" => require(map, t, &["right", "left"]),
"pow" => require(map, t, &["exponent", "base"]),
"abs" | "negate" | "from_float" | "from_int" | "floor" | "ceil" | "round" | "sqrt"
| "sin" | "cos" | "truncate" => require(map, t, &["input"]),
"conditional" => require(map, t, &["on_true", "condition"]),
"number_dispatcher" => require(map, t, &["cases"]),
"weighted_list" => require(map, t, &["distribution"]),
"enchantment_level" => require(map, t, &["amount"]),
"score" => require(map, t, &["score", "target"]),
_ => Ok(()),
}
}
@@ -130,7 +142,19 @@ pub fn decode(registry: &str, t: &Tag, reg: &Registries) -> Result<(), String> {
"minecraft:slot_source" => element_or_list(t, &|x| {
dispatch(x, reg, "minecraft:slot_source_type", &|_, _, _| Ok(()))
}),
"minecraft:dialog" => dispatch(t, reg, "minecraft:dialog_type", &|_, _, _| Ok(())),
// Dialog types: CommonDialogData's title, then each type's own.
"minecraft:dialog" => dispatch(t, reg, "minecraft:dialog_type", &|id, map, t| {
let own: &[&str] = match id {
"minecraft:confirmation" => &["yes", "no"],
"minecraft:multi_action" => &["actions"],
"minecraft:dialog_list" => &["dialogs"],
_ => &[],
};
let keys: Vec<&str> = std::iter::once("title")
.chain(own.iter().copied())
.collect();
require(map, t, &keys)
}),
"minecraft:worldgen/feature" | "minecraft:loot_table" => match t {
Tag::Compound(_) => Ok(()),
_ => Err(not_map(t)),
+1
View File
@@ -18,6 +18,7 @@ pub mod tree_misc;
pub mod tree_scoreboard;
pub mod tree_world;
pub mod vanilla;
mod vanilla_order;
use crate::text::Text;
pub use args::{Arg, ArgType, Registries};
@@ -1,7 +1,6 @@
//! Commands Horizon parses but does not run (multiplayer, profiling and
//! server-only features): `/dialog`, `/kick`, `/posteffect`, `/fetchprofile`,
//! `/spectate`, `/publish`, `/unpublish`, `/waypoint`, `/debug`, `/jfr` and
//! the `/test` root.
//! Commands of the hosted game rather than the world: `/dialog`, `/kick`,
//! `/posteffect`, `/fetchprofile`, `/spectate`, `/publish`, `/unpublish`,
//! `/waypoint`, `/debug`, `/jfr` and `/test`.
use super::{
Dispatcher,
args::ArgType,
@@ -126,7 +125,84 @@ pub fn register(d: &mut Dispatcher, root: usize) {
d.executes(l, "jfr");
}
// TestCommand (game tests; only its root is modelled)
// TestCommand (release build: no export subcommands)
let test = d.literal(root, "test");
d.requires(test, GAMEMASTERS);
let tests = ArgType::ResourceSelector("minecraft:test_instance");
let int0 = ArgType::Integer {
min: 0,
max: i32::MAX,
};
let int = ArgType::Integer {
min: i32::MIN,
max: i32::MAX,
};
// numberOfTimes [untilFailed [rotationSteps [testsPerRow]]], or only
// the first two.
let retry = |d: &mut Dispatcher, node: usize, id: &'static str, build_info: bool| {
let n = d.argument(node, "numberOfTimes", int0.clone());
d.executes(n, id);
let u = d.argument(n, "untilFailed", ArgType::Bool);
d.executes(u, id);
if build_info {
let r = d.argument(u, "rotationSteps", int.clone());
d.executes(r, id);
let t = d.argument(r, "testsPerRow", int.clone());
d.executes(t, id);
}
};
let run = d.literal(test, "run");
let t = d.argument(run, "tests", tests.clone());
d.executes(t, "test.run");
retry(d, t, "test.run", true);
let multiple = d.literal(test, "runmultiple");
let t = d.argument(multiple, "tests", tests.clone());
d.executes(t, "test.run");
let a = d.argument(t, "amount", int.clone());
d.executes(a, "test.run");
for name in ["runthese", "runclosest", "runthat"] {
let l = d.literal(test, name);
d.executes(l, "test.run.found");
retry(d, l, "test.run.found", false);
}
let failed = d.literal(test, "runfailed");
d.executes(failed, "test.run.found");
let only = d.argument(failed, "onlyRequiredTests", ArgType::Bool);
d.executes(only, "test.run.found");
retry(d, only, "test.run.found", true);
retry(d, failed, "test.run.found", true);
let verify = d.literal(test, "verify");
let t = d.argument(verify, "tests", tests.clone());
d.executes(t, "test.verify");
let locate = d.literal(test, "locate");
let t = d.argument(locate, "tests", tests);
d.executes(t, "test.locate");
for name in [
"resetclosest",
"resetthese",
"resetthat",
"clearthat",
"clearthese",
] {
let l = d.literal(test, name);
d.executes(l, "test.clear");
}
let all = d.literal(test, "clearall");
d.executes(all, "test.clear");
let r = d.argument(all, "radius", int.clone());
d.executes(r, "test.clear");
let stop = d.literal(test, "stop");
d.executes(stop, "test.stop");
let pos = d.literal(test, "pos");
d.executes(pos, "test.pos");
let var = d.argument(pos, "var", ArgType::Word);
d.executes(var, "test.pos");
let create = d.literal(test, "create");
let id = d.argument(create, "id", ArgType::Id("none"));
d.executes(id, "test.create");
let w = d.argument(id, "width", int.clone());
d.executes(w, "test.create");
let h = d.argument(w, "height", int.clone());
let depth = d.argument(h, "depth", int);
d.executes(depth, "test.create");
}
@@ -403,6 +403,7 @@ pub fn build_with(dev: bool) -> Dispatcher {
super::tree_misc::register(&mut d, root);
super::tree_world::register(&mut d, root);
super::tree_extra::register(&mut d, root);
apply_vanilla_order(&mut d);
d
}
@@ -506,6 +507,42 @@ pub fn game_modes() -> [&'static str; 4] {
GameMode::ALL.map(GameMode::name)
}
/// The shared vanilla tree.
/// Reorder node children as vanilla registers them (Brigadier keeps
/// children in registration order; smart usage lists them that way).
fn apply_vanilla_order(d: &mut Dispatcher) {
for (path, order) in super::vanilla_order::ORDER {
let mut node = Some(0usize);
for name in path.split(' ').filter(|n| !n.is_empty()) {
node = node.and_then(|n| {
d.nodes[n]
.children
.iter()
.copied()
.find(|&c| d.nodes[c].name() == name)
});
}
let Some(n) = node else { continue };
let mut children = d.nodes[n].children.clone();
let rank = |c: usize| {
order
.iter()
.position(|o| *o == d.nodes[c].name())
.unwrap_or(order.len())
};
children.sort_by_key(|&c| rank(c));
d.nodes[n].children = children;
}
}
/// The tree the game runs: a release integrated server's, or with
/// `HORIZON_DEV_COMMANDS` set the development one
/// (SharedConstants.DEBUG_DEV_COMMANDS).
pub fn game_dispatcher() -> &'static Dispatcher {
if std::env::var_os("HORIZON_DEV_COMMANDS").is_some() {
dispatcher()
} else {
release_dispatcher()
}
}
pub fn dispatcher() -> &'static Dispatcher {
static TREE: std::sync::OnceLock<Dispatcher> = std::sync::OnceLock::new();
TREE.get_or_init(build)
@@ -0,0 +1,234 @@
//! The order of node children in vanilla's command tree, for the nodes
//! where Horizon's tree registers them differently (path of node names
//! from the root, children in vanilla's order). Generated by
//! tools/generate_command_order.py; do not edit by hand.
pub const ORDER: &[(&str, &[&str])] = &[
(
"",
&[
"advancement",
"attribute",
"execute",
"bossbar",
"clear",
"clone",
"compute",
"damage",
"data",
"datapack",
"debug",
"defaultgamemode",
"dialog",
"difficulty",
"effect",
"me",
"enchant",
"experience",
"xp",
"fill",
"fillbiome",
"forceload",
"function",
"gamemode",
"gamerule",
"give",
"help",
"item",
"kick",
"kill",
"list",
"locate",
"loot",
"msg",
"tell",
"w",
"swing",
"particle",
"place",
"playsound",
"posteffect",
"random",
"reload",
"recipe",
"fetchprofile",
"return",
"ride",
"rotate",
"say",
"schedule",
"scoreboard",
"seed",
"version",
"setblock",
"spawnpoint",
"setworldspawn",
"spectate",
"spreadplayers",
"stopsound",
"stopwatch",
"summon",
"tag",
"team",
"teammsg",
"tm",
"teleport",
"tp",
"tellraw",
"test",
"tick",
"time",
"title",
"trigger",
"waypoint",
"weather",
"worldborder",
"jfr",
"publish",
"unpublish",
],
),
(
"execute",
&[
"run",
"if",
"unless",
"as",
"at",
"store",
"positioned",
"rotated",
"facing",
"align",
"anchored",
"in",
"summon",
"on",
],
),
(
"execute if",
&[
"block",
"biome",
"loaded",
"dimension",
"score",
"blocks",
"entity",
"predicate",
"function",
"stopwatch",
"data",
"items",
"slots",
],
),
(
"execute unless",
&[
"block",
"biome",
"loaded",
"dimension",
"score",
"blocks",
"entity",
"predicate",
"function",
"stopwatch",
"data",
"items",
"slots",
],
),
("execute facing", &["entity", "pos"]),
("datapack", &["enable", "disable", "list", "create"]),
(
"datapack enable name",
&["after", "before", "last", "first"],
),
("item", &["replace", "fill", "override", "modify"]),
("item replace entity target slots", &["from", "with"]),
("item fill entity target slots", &["from", "with"]),
("item override entity target slots", &["from", "with"]),
(
"loot replace entity entities slot",
&["fish", "loot", "kill", "mine", "count"],
),
(
"loot replace entity entities slot fish loot_table pos",
&["tool", "mainhand", "offhand"],
),
(
"loot replace entity entities slot mine pos",
&["tool", "mainhand", "offhand"],
),
(
"loot replace entity entities slot count fish loot_table pos",
&["tool", "mainhand", "offhand"],
),
(
"loot replace entity entities slot count mine pos",
&["tool", "mainhand", "offhand"],
),
(
"loot replace block targetPos slot",
&["fish", "loot", "kill", "mine", "count"],
),
(
"loot replace block targetPos slot fish loot_table pos",
&["tool", "mainhand", "offhand"],
),
(
"loot replace block targetPos slot mine pos",
&["tool", "mainhand", "offhand"],
),
(
"loot replace block targetPos slot count fish loot_table pos",
&["tool", "mainhand", "offhand"],
),
(
"loot replace block targetPos slot count mine pos",
&["tool", "mainhand", "offhand"],
),
(
"loot insert targetPos fish loot_table pos",
&["tool", "mainhand", "offhand"],
),
(
"loot insert targetPos mine pos",
&["tool", "mainhand", "offhand"],
),
(
"loot give players fish loot_table pos",
&["tool", "mainhand", "offhand"],
),
(
"loot give players mine pos",
&["tool", "mainhand", "offhand"],
),
(
"loot spawn targetPos fish loot_table pos",
&["tool", "mainhand", "offhand"],
),
(
"loot spawn targetPos mine pos",
&["tool", "mainhand", "offhand"],
),
(
"scoreboard players",
&[
"list",
"set",
"get",
"add",
"remove",
"reset",
"enable",
"display",
"operation",
],
),
];
+19 -5
View File
@@ -172,6 +172,14 @@ fn object_style(o: &serde_json::Map<String, Value>) -> Style {
/// `ComponentSerialization.CODEC` decoding into text. `selector` components
/// are resolved by `resolve` (ComponentUtils.updateForEntity).
pub fn to_text(v: &Value, resolve: &mut dyn FnMut(&str) -> Text) -> Text {
to_text_with(v, resolve, &mut |_| None)
}
/// `to_text` with a hook resolving other contents (`nbt`) from the object.
pub fn to_text_with(
v: &Value,
resolve: &mut dyn FnMut(&str) -> Text,
contents: &mut dyn FnMut(&serde_json::Map<String, Value>) -> Option<Text>,
) -> Text {
match v {
Value::String(s) => Text::literal(s.clone()),
Value::Number(n) => Text::literal(n.to_string()),
@@ -181,7 +189,7 @@ pub fn to_text(v: &Value, resolve: &mut dyn FnMut(&str) -> Text) -> Text {
let Some((first, rest)) = list.split_first() else {
return Text::empty();
};
let mut base = to_text(first, resolve);
let mut base = to_text_with(first, resolve, contents);
// The siblings take the first component's own style, even when
// its text is empty.
let style = match first {
@@ -193,13 +201,15 @@ pub fn to_text(v: &Value, resolve: &mut dyn FnMut(&str) -> Text) -> Text {
.unwrap_or_default(),
};
for sibling in rest {
base.push(to_text(sibling, resolve).with_style(&style));
base.push(to_text_with(sibling, resolve, contents).with_style(&style));
}
base
}
Value::Object(o) => {
let style = object_style(o);
let content = if let Some(t) = o.get("text") {
let content = if let Some(t) = contents(o) {
t
} else if let Some(t) = o.get("text") {
match t {
Value::String(s) => Text::literal(s.clone()),
other => Text::literal(other.to_string()),
@@ -208,7 +218,11 @@ pub fn to_text(v: &Value, resolve: &mut dyn FnMut(&str) -> Text) -> Text {
let args: Vec<Text> = o
.get("with")
.and_then(Value::as_array)
.map(|a| a.iter().map(|x| to_text(x, resolve)).collect())
.map(|a| {
a.iter()
.map(|x| to_text_with(x, resolve, contents))
.collect()
})
.unwrap_or_default();
let translated = Text::translate(key, &args);
match o.get("fallback").and_then(Value::as_str) {
@@ -229,7 +243,7 @@ pub fn to_text(v: &Value, resolve: &mut dyn FnMut(&str) -> Text) -> Text {
.into_iter()
.flatten()
{
out.push(to_text(extra, resolve).with_style(&style));
out.push(to_text_with(extra, resolve, contents).with_style(&style));
}
out
}
+9
View File
@@ -67,6 +67,15 @@ fn walk(root: &Path, dir: &Path, out: &mut Vec<String>) {
}
}
}
impl DataPack {
/// The built-in `vanilla` pack: the game's own data directory.
pub fn builtin(root: &Path) -> Self {
DataPack {
id: "vanilla".into(),
source: Source::Dir(root.to_path_buf()),
}
}
}
/// The packs in `<world>/datapacks`, sorted by name.
pub fn discover(world: &Path) -> Vec<DataPack> {
let Ok(entries) = std::fs::read_dir(world.join("datapacks")) else {
+19
View File
@@ -1120,6 +1120,25 @@ pub fn armor_stand_to_nbt(a: &ArmorStand, uuid: [i32; 4], raw: Option<&Tag>) ->
{
put(&mut tag, "Health", Tag::Float(20f32.to_bits()));
}
// LivingEntity.addAdditionalSaveData and ArmorStand's own fields.
if let Tag::Compound(map) = &mut tag {
for (key, value) in [
("HurtTime", Tag::Short(0)),
("DeathTime", Tag::Short(0)),
("AbsorptionAmount", Tag::Float(0)),
("FallFlying", Tag::Byte(0)),
("current_impulse_context_reset_grace_time", Tag::Int(0)),
("attributes", Tag::List(Vec::new())),
(
"Brain",
Tag::compound([("memories", Tag::Compound(Compound::new()))]),
),
("DisabledSlots", Tag::Int(0)),
("Pose", Tag::Compound(Compound::new())),
] {
map.entry(key.into()).or_insert(value);
}
}
tag
}
pub fn armor_stand_from_nbt(tag: &Tag, id: u32) -> Option<ArmorStand> {
+153
View File
@@ -0,0 +1,153 @@
//! Iteration order of fastutil's `Object2ObjectOpenHashMap<String, _>` (open
//! addressing with linear probing, backward-shift deletion and rehashing at
//! the load factor), for the vanilla collections whose order commands show:
//! the scoreboard's objectives and teams.
/// The keys of an open hash map in their table slots.
#[derive(Clone, Debug, PartialEq)]
pub struct OpenOrder {
keys: Vec<Option<String>>,
size: usize,
min_n: usize,
load: f32,
}
impl Default for OpenOrder {
/// `new Object2ObjectOpenHashMap<>()`: 16 expected entries, load 0.75.
fn default() -> Self {
Self::new(16, 0.75)
}
}
/// `String.hashCode`.
fn java_hash(s: &str) -> i32 {
s.encode_utf16()
.fold(0i32, |h, c| h.wrapping_mul(31).wrapping_add(i32::from(c)))
}
/// `HashCommon.mix`.
fn mix(x: i32) -> usize {
let h = (x as u32).wrapping_mul(0x9E37_79B9);
(h ^ (h >> 16)) as usize
}
/// `HashCommon.arraySize`.
fn array_size(expected: usize, f: f32) -> usize {
let wanted = (expected as f64 / f64::from(f)).ceil() as usize;
wanted.max(2).next_power_of_two()
}
impl OpenOrder {
pub fn new(expected: usize, load: f32) -> Self {
let n = array_size(expected, load);
Self {
keys: vec![None; n],
size: 0,
min_n: n,
load,
}
}
fn max_fill(&self) -> usize {
((self.keys.len() as f64 * f64::from(self.load)).ceil() as usize).min(self.keys.len() - 1)
}
fn slot(&self, key: &str) -> usize {
mix(java_hash(key)) & (self.keys.len() - 1)
}
pub fn insert(&mut self, key: &str) {
let mask = self.keys.len() - 1;
let mut pos = self.slot(key);
while let Some(k) = &self.keys[pos] {
if k == key {
return;
}
pos = (pos + 1) & mask;
}
self.keys[pos] = Some(key.to_owned());
self.size += 1;
if self.size >= self.max_fill() {
self.rehash(array_size(self.size + 1, self.load));
}
}
pub fn remove(&mut self, key: &str) {
let mask = self.keys.len() - 1;
let mut pos = self.slot(key);
loop {
match &self.keys[pos] {
None => return,
Some(k) if k == key => break,
Some(_) => pos = (pos + 1) & mask,
}
}
self.size -= 1;
self.shift_keys(pos);
let n = self.keys.len();
if n > self.min_n && self.size < self.max_fill() / 4 && n > 16 {
self.rehash(n / 2);
}
}
fn shift_keys(&mut self, mut pos: usize) {
let mask = self.keys.len() - 1;
loop {
let last = pos;
pos = (last + 1) & mask;
loop {
let Some(curr) = self.keys[pos].clone() else {
self.keys[last] = None;
return;
};
let slot = self.slot(&curr);
let stop = if last <= pos {
last >= slot || slot > pos
} else {
last >= slot && slot > pos
};
if stop {
self.keys[last] = Some(curr);
break;
}
pos = (pos + 1) & mask;
}
}
}
fn rehash(&mut self, new_n: usize) {
let old = std::mem::replace(&mut self.keys, vec![None; new_n]);
let mask = new_n - 1;
for key in old.into_iter().rev().flatten() {
let mut pos = mix(java_hash(&key)) & mask;
while self.keys[pos].is_some() {
pos = (pos + 1) & mask;
}
self.keys[pos] = Some(key);
}
}
/// The iteration order (`keySet().iterator()`: from the last slot down).
pub fn keys(&self) -> impl Iterator<Item = &str> {
self.keys.iter().rev().flatten().map(String::as_str)
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn hash_and_order() {
assert_eq!(
java_hash("harness"),
"harness"
.chars()
.fold(0i32, |h, c| h.wrapping_mul(31).wrapping_add(c as i32))
);
let mut o = OpenOrder::new(16, 0.5);
for k in ["harness", "harness_h"] {
o.insert(k);
}
let keys: Vec<&str> = o.keys().collect();
assert_eq!(keys.len(), 2);
o.remove("harness");
assert_eq!(o.keys().collect::<Vec<_>>(), vec!["harness_h"]);
for i in 0..40 {
o.insert(&format!("k{i}"));
}
assert_eq!(o.keys().count(), 41);
for i in 0..40 {
o.remove(&format!("k{i}"));
}
assert_eq!(o.keys().collect::<Vec<_>>(), vec!["harness_h"]);
}
}
+17 -2
View File
@@ -15,6 +15,7 @@ mod breezes;
mod cartography;
mod chat;
mod combat;
mod command_harness;
mod commands;
mod control;
mod creaking;
@@ -683,6 +684,8 @@ struct Game<'a> {
map_frame_model: frames::FrameModel,
glow_map_frame_model: frames::FrameModel,
armor_stands: Vec<horizon_client::entities::ArmorStand>,
/// Entities of types Horizon does not simulate.
others: Vec<commands::OtherEntity>,
armor_stand_assets: armor_stands::ArmorStandAssets,
boats: Vec<boats::Boat>,
boat_models: boats::BoatModels,
@@ -742,7 +745,9 @@ struct Game<'a> {
lan_events: Vec<(i32, [i32; 3], i32, Option<u32>)>,
lan_acting: Option<u32>,
/// Command feedback to forward to a guest.
chat_capture: Option<Vec<String>>,
chat_capture: Option<Vec<horizon_client::text::Text>>,
/// State of `/spectate`, `/posteffect`, `/debug`, `/waypoint` and friends.
cmds: commands::extra::CommandExtras,
/// Allow Cheats: whether guests may be given commands.
cheats: bool,
ui: chat::UiState,
@@ -2512,6 +2517,8 @@ impl Game<'_> {
}
self.apply_totem();
self.update_totem_ready();
self.tick_command_extras();
let camera_eye = self.camera_eye_height();
if self.riding.is_some() && self.player.is_some() {
let playing = self.screen == Screen::Playing;
let held = |k| playing && self.keys.contains(&k);
@@ -2609,7 +2616,7 @@ impl Game<'_> {
}
let feet = [player.position.x, player.position.y, player.position.z];
self.previous_eye = self.eye;
self.eye += (player.dimensions.eye_height - self.eye) * 0.5;
self.eye += (camera_eye.unwrap_or(player.dimensions.eye_height) - self.eye) * 0.5;
let crouching = player.pose == horizon_client::pose::Pose::Crouching;
self.tick_avatar(before, riding);
self.record_combat(&events);
@@ -8084,6 +8091,7 @@ pub fn run() -> Result<()> {
map_frame_model: frames::bake_frame(&root, "item_frame_map"),
glow_map_frame_model: frames::bake_frame(&root, "glow_item_frame_map"),
armor_stands: Vec::new(),
others: Vec::new(),
armor_stand_assets: armor_stands::ArmorStandAssets::load(&root),
boats: Vec::new(),
boat_models: boats::BoatModels::load(&root),
@@ -8127,6 +8135,7 @@ pub fn run() -> Result<()> {
lan_events: Vec::new(),
lan_acting: None,
chat_capture: None,
cmds: Default::default(),
cheats: true,
ui: Default::default(),
combat: Default::default(),
@@ -8173,6 +8182,12 @@ pub fn run() -> Result<()> {
}
None => game.title = Some(Title::new(std::env::current_dir()?.join("saves"))),
}
if let (Some(script), Some(output)) = (
std::env::var_os("HORIZON_COMMAND_SCRIPT"),
std::env::var_os("HORIZON_COMMAND_OUTPUT"),
) {
return game.run_command_harness(script.as_ref(), output.as_ref());
}
EventLoop::new()?.run_app(&mut game)?;
if let Some(path) = &game.options.report {
let report = serde_json::json!({
@@ -168,6 +168,12 @@ fn now_text() -> String {
rem % 60
)
}
impl Game<'_> {
/// `ItemPredicate.test` (the `item_filter` of a filtered item modifier).
pub(super) fn loot_item_filter(&self, predicate: &Value, s: &ItemStack) -> bool {
adv::item(predicate, &item_view(s), &View(self))
}
}
pub(super) fn item_view(s: &ItemStack) -> ItemView {
ItemView {
id: s.item.to_string(),
@@ -505,6 +511,17 @@ impl Game<'_> {
return;
}
self.check_inventory_trigger();
// ServerPlayer.tick: PlayerTrigger.TICK every tick.
let me = self.player_entity();
self.trigger("minecraft:tick", |c, w| {
let ctx = adv::Entities {
this: Some(&me),
origin: me.position,
tool: None,
block_pos: None,
};
adv::conditions(&c["player"], &ctx, w)
});
if self.ticks.is_multiple_of(20) {
let me = self.player_entity();
self.trigger("minecraft:location", |c, w| {
+17 -4
View File
@@ -286,7 +286,11 @@ impl Game<'_> {
reg.structures = list("data/minecraft/worldgen/structure");
reg.biomes = list("data/minecraft/worldgen/biome");
reg.clocks = list("data/minecraft/world_clock");
reg.dimensions = vec!["minecraft:overworld".into(), "minecraft:the_nether".into()];
reg.dimensions = vec![
"minecraft:overworld".into(),
"minecraft:the_nether".into(),
"minecraft:the_end".into(),
];
reg.players = vec![PLAYER_NAME.into()];
// Timelines of the overworld clock and their time markers.
self.ui.markers.clear();
@@ -324,6 +328,15 @@ impl Game<'_> {
);
}
}
// Vanilla's built-in registries (mob effects, components, dialogs...).
for dir in [&self.options.resources, &self.ui.vanilla_root] {
if let Ok(bytes) = std::fs::read(dir.join("command-registries.json"))
&& let Ok(v) = serde_json::from_slice::<serde_json::Value>(&bytes)
{
self.ui.registries.fill_from_export(&v);
break;
}
}
let reg = &mut self.ui.registries;
reg.timelines = self.ui.timelines.keys().cloned().collect();
reg.time_markers = self
@@ -368,7 +381,7 @@ impl Game<'_> {
/// A chat message from the game (ChatComponent.addServerSystemMessage).
pub(super) fn system_message(&mut self, text: Text) {
if let Some(capture) = self.chat_capture.as_mut() {
capture.push(text.plain());
capture.push(text);
return;
}
let focused = self.screen == Screen::Chat;
@@ -397,7 +410,7 @@ impl Game<'_> {
return;
};
let atlas = &self.res.atlas;
let d = vanilla::dispatcher();
let d = vanilla::game_dispatcher();
if screen.suggestion_key(atlas, d, &self.ui.registries, key, shift) {
self.ui.chat_screen = Some(screen);
return;
@@ -515,7 +528,7 @@ impl Game<'_> {
screen.draw(
batch,
&self.res.atlas,
vanilla::dispatcher(),
vanilla::game_dispatcher(),
&self.ui.registries,
self.cursor,
bg,
@@ -0,0 +1,137 @@
//! Headless command runner for `tools/test_command_exec_parity.py`: with
//! `HORIZON_COMMAND_SCRIPT` and `HORIZON_COMMAND_OUTPUT` set, the opened world
//! runs without a window. Each script line is a JSON operation: `cmd` runs a
//! command as the player (Commands.performPrefixedCommand) and records every
//! system message it produced, as styled spans, with the results reported to
//! the player's `CommandResultCallback`; `tick` advances the game; `settle`
//! waits until the terrain around the player is loaded.
use super::Game;
use horizon_client::{Result, text::Text};
use serde_json::{Value, json};
use std::{
path::Path,
time::{Duration, Instant},
};
/// A message as `[text, style]` runs with adjacent equal styles merged; the
/// style lists colour, bold, italic, underlined, strikethrough, obfuscated
/// and the suggested command.
pub(super) fn spans(text: &Text) -> Value {
let mut out: Vec<(String, Value)> = Vec::new();
for span in &text.spans {
if span.text.is_empty() {
continue;
}
let s = &span.style;
let style = json!([
s.color,
s.bold == Some(true),
s.italic == Some(true),
s.underlined == Some(true),
s.strikethrough == Some(true),
s.obfuscated == Some(true),
]);
match out.last_mut() {
Some((t, last)) if *last == style => t.push_str(&span.text),
_ => out.push((span.text.clone(), style)),
}
}
Value::Array(out.into_iter().map(|(t, s)| json!([t, s])).collect())
}
impl Game<'_> {
/// Load terrain until the player stands in lit chunks.
fn harness_settle(&mut self, deadline: Instant) -> Result<()> {
loop {
self.update_world();
self.spawn_player()?;
if let Some(p) = &self.player {
let (cx, cz) = (
(p.position.x.floor() as i32) >> 4,
(p.position.z.floor() as i32) >> 4,
);
if (-1..=1).all(|dz| (-1..=1).all(|dx| self.streaming.is_lit(cx + dx, cz + dz))) {
return Ok(());
}
}
if std::env::var_os("HORIZON_HARNESS_DEBUG").is_some() {
eprintln!(
"settle: player {:?} center {:?} chunks {} pending {}",
self.player.as_ref().map(|p| p.position),
self.streaming.center,
self.world.chunks.len(),
self.streaming.pending()
);
}
if Instant::now() > deadline {
return Err("command harness: terrain did not load".into());
}
std::thread::sleep(Duration::from_millis(2));
}
}
pub(super) fn run_command_harness(&mut self, script: &Path, output: &Path) -> Result<()> {
let deadline = Instant::now()
+ Duration::from_secs(
std::env::var("HORIZON_HARNESS_TIMEOUT")
.ok()
.and_then(|v| v.parse().ok())
.unwrap_or(600),
);
self.harness_settle(deadline)?;
let mut out = String::new();
for line in std::fs::read_to_string(script)?.lines() {
if line.trim().is_empty() {
continue;
}
let op: Value = serde_json::from_str(line)?;
match op["op"].as_str().unwrap_or("") {
"cmd" => {
let command = op["cmd"].as_str().unwrap_or("");
self.chat_capture = Some(Vec::new());
self.cmds.results = Some(Vec::new());
self.run_command(command.strip_prefix('/').unwrap_or(command));
let messages = self.chat_capture.take().unwrap_or_default();
let results = self.cmds.results.take().unwrap_or_default();
if op["record"].as_bool() != Some(false) {
let record = json!({
"cmd": command,
"messages": messages.iter().map(spans).collect::<Vec<_>>(),
"results": results.iter().map(|(s, v)| json!([s, v])).collect::<Vec<_>>(),
});
out.push_str(&record.to_string());
out.push('\n');
}
}
"tick" => {
self.chat_capture = Some(Vec::new());
// The oracle's player has no client moving it: hold the
// player where commands put it while the game ticks.
let held = self.player.as_ref().map(|p| p.position);
for _ in 0..op["n"].as_u64().unwrap_or(1) {
self.update_world();
self.tick()?;
if let (Some(p), Some(at)) = (self.player.as_mut(), held) {
p.position = at;
p.velocity = horizon_core::geometry::Vec3::new(0.0, 0.0, 0.0);
p.fall_distance = 0.0;
}
}
let messages = self.chat_capture.take().unwrap_or_default();
if op["record"].as_bool() == Some(true) {
let record = json!({
"cmd": "#tick",
"messages": messages.iter().map(spans).collect::<Vec<_>>(),
"results": [],
});
out.push_str(&record.to_string());
out.push('\n');
}
}
"settle" => self.harness_settle(deadline)?,
other => return Err(format!("command harness: unknown op {other}").into()),
}
}
std::fs::write(output, out)?;
Ok(())
}
}
+557 -89
View File
@@ -1,8 +1,10 @@
//! Command execution (the `execute` side of each vanilla command class):
//! entity selectors resolved against the game, vanilla feedback and errors.
mod compute;
mod data;
mod effects;
pub(super) mod execute;
pub(super) mod extra;
mod items;
mod misc;
mod place;
@@ -40,6 +42,19 @@ pub(super) enum Target {
Painting(u32),
Boat(u32),
Cart(u32),
/// An entity of a type Horizon does not simulate (markers, displays,
/// interactions...): kept as its saved data at a position.
Other(u32),
}
/// An entity of a type Horizon does not simulate: its compound lives in the
/// entity memory (`persist.raw`), its position and rotation here.
#[derive(Clone, Debug)]
pub(in crate::game) struct OtherEntity {
pub id: u32,
pub kind: String,
pub position: Vec3,
pub yaw: f32,
pub pitch: f32,
}
pub(super) fn err(key: &str, args: &[&dyn std::fmt::Display]) -> CommandError {
CommandError::tr(key, args)
@@ -63,7 +78,7 @@ fn format_double(v: f64) -> String {
impl Game<'_> {
/// Commands.performCommand for a line without its slash.
pub(super) fn run_command(&mut self, command: &str) {
let d = vanilla::dispatcher();
let d = vanilla::game_dispatcher();
let parse = d.parse(command, &self.ui.registries);
let result = match parse.executable() {
Err(e) => {
@@ -84,6 +99,10 @@ impl Game<'_> {
self.command_failure(e.message);
}
}
// InventoryChangeTrigger fires as slots change, not on the next tick.
if self.player.is_some() {
self.check_inventory_trigger();
}
}
fn syntax_failure(&mut self, e: &CommandError, command: &str) {
self.command_failure(e.message.clone());
@@ -169,7 +188,8 @@ impl Game<'_> {
.ok_or_else(|| err("argument.pos.missing.int", &[]))?;
// BlockPos.containing(getPosition)
let p = self.resolve_coords(&c).map(|v| v.floor() as i32);
if !self.world.chunks.contains_key(&(p[0] >> 4, p[2] >> 4)) {
let elsewhere = self.command_source.is_some_and(|s| s.elsewhere);
if elsewhere || !self.world.chunks.contains_key(&(p[0] >> 4, p[2] >> 4)) {
return Err(err("argument.pos.unloaded", &[]));
}
if p[1] < horizon_client::chunk::MIN_Y
@@ -242,6 +262,11 @@ impl Game<'_> {
.iter()
.find(|c| c.id == id)
.map(|c| [c.position.x, c.position.y, c.position.z]),
Target::Other(id) => self
.others
.iter()
.find(|o| o.id == id)
.map(|o| [o.position.x, o.position.y, o.position.z]),
}
}
pub(super) fn target_type(&self, t: Target) -> String {
@@ -276,12 +301,21 @@ impl Game<'_> {
.iter()
.find(|c| c.id == id)
.map_or_else(|| "minecraft:minecart".into(), |c| c.kind.id().into()),
Target::Other(id) => self
.others
.iter()
.find(|o| o.id == id)
.map_or_else(String::new, |o| o.kind.clone()),
}
}
/// Entity.getDisplayName.
pub(super) fn target_name(&self, t: Target) -> Text {
match t {
Target::Player => Text::literal(PLAYER_NAME),
Target::Player => match self.score.board.players_team(PLAYER_NAME) {
// PlayerTeam.formatNameForTeam.
Some(team) => team.formatted_name(Text::literal(PLAYER_NAME)),
None => Text::literal(PLAYER_NAME),
},
Target::Item(id) => {
let item = self
.dropped
@@ -305,6 +339,21 @@ impl Game<'_> {
Text::literal(name.unwrap_or_default())
}
other => {
// Entity.getDisplayName: the CustomName component, else the type.
let custom = match other {
Target::Stand(id)
| Target::Frame(id)
| Target::Painting(id)
| Target::Boat(id)
| Target::Cart(id)
| Target::Other(id) => self.persist_raw(id).and_then(|r| r.get("CustomName")),
_ => None,
};
if let Some(c) = custom {
return horizon_client::scoreboard::comp_text(
&horizon_client::scoreboard::tag_to_json(c),
);
}
let ty = self.target_type(other);
Text::translate(&format!("entity.{}", ty.replace(':', ".")), &[])
}
@@ -349,6 +398,7 @@ impl Game<'_> {
candidates.extend(self.paintings.iter().map(|p| Target::Painting(p.id)));
candidates.extend(self.boats.iter().map(|b| Target::Boat(b.id)));
candidates.extend(self.carts.iter().map(|c| Target::Cart(c.id)));
candidates.extend(self.others.iter().map(|o| Target::Other(o.id)));
}
let level = self.experience.level;
let creative = self.creative;
@@ -535,7 +585,23 @@ impl Game<'_> {
"clear" => self.cmd_clear(ctx),
"item" => self.cmd_item(ctx),
"item.modify" => self.cmd_item_modify(ctx),
"spectate" => self.cmd_spectate(ctx),
id if id.starts_with("waypoint.") => self.cmd_waypoint(id, ctx),
id if id.starts_with("dialog.") => self.cmd_dialog(id, ctx),
id if id.starts_with("posteffect.") => self.cmd_posteffect(id, ctx),
"kick" => self.cmd_kick(ctx),
"fetchprofile" => self.cmd_fetchprofile(ctx),
"publish" => self.cmd_publish(ctx),
"unpublish" => self.cmd_unpublish(),
"debug" => self.cmd_debug(ctx),
"jfr" => self.cmd_jfr(ctx),
"version" => self.cmd_version(),
id if id.starts_with("test.") => self.cmd_test(id, ctx),
"compute" => self.cmd_compute(ctx),
"place" => self.cmd_place(ctx),
"place.feature" | "place.jigsaw" | "place.structure" => {
self.cmd_place_generated(id, ctx)
}
"recipe.give" | "recipe.take" => self.cmd_recipe(id, ctx),
"damage" => self.cmd_damage(ctx),
"rotate" => self.cmd_rotate(ctx),
@@ -543,7 +609,18 @@ impl Game<'_> {
"playsound" => self.cmd_playsound(ctx),
"stopsound" => self.cmd_stopsound(ctx),
"particle" => self.cmd_particle(ctx),
id if id.starts_with("attribute.") => self.cmd_attribute(id, ctx),
id if id.starts_with("attribute.") => {
let result = self.cmd_attribute(id, ctx);
// AttributeInstance.setDirty: the entity reacts when it ticks.
if result.is_ok()
&& matches!(ctx.get("attribute"), Some(Arg::Resource(a)) if a == "minecraft:waypoint_transmit_range")
&& !id.ends_with("get")
&& let Ok(t) = self.entities(ctx, "target", false)
{
self.cmds.waypoint_dirty.push(t[0]);
}
result
}
"ride.mount" | "ride.dismount" => self.cmd_ride(id, ctx),
"spreadplayers" => self.cmd_spreadplayers(ctx),
id if id.starts_with("forceload.") => self.cmd_forceload(id, ctx),
@@ -569,6 +646,7 @@ impl Game<'_> {
self.cmd_scoreboard(id, ctx)
}
"locate.structure" | "locate.biome" => self.cmd_locate(id, ctx),
"locate.poi" => self.cmd_locate_poi(ctx),
"warden_spawn_tracker.clear" | "warden_spawn_tracker.set" => {
let level = Self::int(ctx, "warning_level");
self.cmd_warden_spawn_tracker(level);
@@ -581,7 +659,7 @@ impl Game<'_> {
"commands.list.nameAndId",
&[
Text::literal(PLAYER_NAME),
Text::literal("00000000-0000-0000-0000-000000000000"),
Text::literal(self.player_uuid_string()),
],
)
} else {
@@ -597,7 +675,7 @@ impl Game<'_> {
}
}
fn cmd_help(&mut self, ctx: &Context) -> R<i32> {
let d = vanilla::dispatcher();
let d = vanilla::game_dispatcher();
let level = self.ui.registries.permission;
match ctx.get("command") {
None => {
@@ -653,16 +731,23 @@ impl Game<'_> {
}
count += 1;
let mode_name = Text::translate(&format!("gameMode.{}", mode.name()), &[]);
if ctx.get("target").is_none() {
// GameModeCommand.logGamemodeChange: the source's own entity.
let own = match self.command_source {
None => true,
Some(s) => s.entity == Some(t),
};
if own {
self.feedback(Text::translate(
"commands.gamemode.success.self",
&[mode_name],
));
} else {
self.system_message(Text::translate(
"gameMode.changed",
std::slice::from_ref(&mode_name),
));
if self.ui.rules.bool("send_command_feedback") {
self.system_message(Text::translate(
"gameMode.changed",
std::slice::from_ref(&mode_name),
));
}
self.feedback(Text::translate(
"commands.gamemode.success.other",
&[Text::literal(PLAYER_NAME), mode_name],
@@ -685,6 +770,57 @@ impl Game<'_> {
.append("]")
.with_color(color)
}
/// `ItemStack.getDisplayName`: the hover name (custom name in italics,
/// a written book's title, a potion's effect name...) in brackets, in the
/// rarity colour unless the stack is empty.
pub(super) fn stack_display_name(&self, s: &ItemStack) -> Text {
let item = &*s.item;
let empty = item == "minecraft:air" || s.count == 0;
let custom = s.custom_name();
let hover = if let Some(c) = custom {
Text::literal(c).italic()
} else if let Some(title) = s
.data()
.and_then(|d| d.written.as_ref())
.map(|w| w.title.clone())
.filter(|t| !t.trim().is_empty())
{
Text::literal(title)
} else if matches!(
item,
"minecraft:potion"
| "minecraft:splash_potion"
| "minecraft:lingering_potion"
| "minecraft:tipped_arrow"
) && s.potion().is_some()
{
Text::translate(
&horizon_client::brewing::potion_name_key(item, s.potion()),
&[],
)
} else {
Text::literal(self.res.names.item(item))
};
let wrapped = Text::translate("chat.square_brackets", &[hover]);
if empty {
return wrapped;
}
let mut rarity = self.item_rarity(item);
if !s.enchantments().is_empty() {
rarity = match rarity.as_str() {
"rare" => "epic".into(),
"epic" => rarity,
_ => "rare".into(),
};
}
let color = match rarity.as_str() {
"uncommon" => text::YELLOW,
"rare" => text::AQUA,
"epic" => text::LIGHT_PURPLE,
_ => text::WHITE,
};
wrapped.with_color(color)
}
pub(super) fn item_rarity(&self, item: &str) -> String {
static RARITY: std::sync::OnceLock<std::collections::HashMap<String, String>> =
std::sync::OnceLock::new();
@@ -731,7 +867,9 @@ impl Game<'_> {
],
)));
}
for _ in &targets {
// An air stack is empty: nothing is given (but the message still is).
let empty = id == "minecraft:air";
for _ in targets.iter().filter(|_| !empty) {
let mut remaining = count;
while remaining > 0 {
let size = remaining.min(max_stack);
@@ -755,7 +893,12 @@ impl Game<'_> {
}
}
}
let name = self.item_display_name(&id);
let name = self.stack_display_name(&ItemStack {
item: id.as_str().into(),
count: count.max(1) as u32,
damage,
extra: extra.clone(),
});
let message = if targets.len() == 1 {
Text::translate(
"commands.give.success.single",
@@ -848,6 +991,15 @@ impl Game<'_> {
}
}
}
Target::Other(id) => {
if let Some(o) = self.others.iter_mut().find(|o| o.id == id) {
o.position = v;
if let Some([yaw, pitch]) = rotation {
o.yaw = yaw;
o.pitch = pitch;
}
}
}
// Wall-mounted entities do not move.
Target::Frame(_) | Target::Painting(_) => {}
}
@@ -1117,7 +1269,7 @@ impl Game<'_> {
w.raining = raining;
w.thundering = thundering;
self.feedback(Text::translate(key, &[]));
Ok(duration.unwrap_or(0))
Ok(duration.unwrap_or(-1))
}
fn kill_target(&mut self, t: Target) {
match t {
@@ -1151,6 +1303,7 @@ impl Game<'_> {
Target::Painting(id) => self.paintings.retain(|p| p.id != id),
Target::Boat(id) => self.boats.retain(|b| b.id != id),
Target::Cart(id) => self.carts.retain(|c| c.id != id),
Target::Other(id) => self.others.retain(|o| o.id != id),
}
}
fn cmd_kill(&mut self, ctx: &Context) -> R<i32> {
@@ -1185,6 +1338,13 @@ impl Game<'_> {
let Some(Arg::Resource(kind)) = ctx.get("entity").cloned() else {
return Ok(0);
};
// ResourceArgument.getSummonableEntityType.
if matches!(
kind.as_str(),
"minecraft:player" | "minecraft:fishing_bobber"
) {
return Err(err("entity.not_summonable", &[&kind]));
}
let pos = self
.position_arg(ctx, "pos")
.unwrap_or(self.source_position());
@@ -1355,12 +1515,14 @@ impl Game<'_> {
return Err(err("commands.setblock.failed", &[]));
}
if ctx.has("destroy") && current != self.world.air {
let creative = self.creative;
self.creative = false;
let _ = self.break_block(pos);
self.creative = creative;
self.destroy_block_dropping(pos)?;
}
if !self.place_state(pos, state, ctx.has("strict"))? {
let placed = self.place_state(pos, state, ctx.has("strict"))?;
let loaded = match &b.nbt {
Some(nbt) => self.load_block_entity_nbt(pos, nbt),
None => false,
};
if !placed && !loaded {
return Err(err("commands.setblock.failed", &[]));
}
self.feedback(Text::tr(
@@ -1369,6 +1531,64 @@ impl Game<'_> {
));
Ok(1)
}
/// `Level.destroyBlock(pos, true)`: the block's drops without a tool or
/// breaker (its loot table, contents of a container), then air.
pub(super) fn destroy_block_dropping(&mut self, pos: [i32; 3]) -> R<()> {
let state = self.world.block(pos[0], pos[1], pos[2]);
self.destroy_particles(pos, state);
self.jukebox_removed(pos);
if let Some(entity) = self.world.block_entities.remove(&(pos[0], pos[1], pos[2])) {
let name = self.res.facts.get(state).name.clone();
self.release_contents(pos, entity, &name);
}
let drops = self.res.items.block_drops_in(
self.res.assets.registry,
state,
None,
&mut self.world.random,
Some((&mut self.rand_sequences, self.level.seed)),
);
for d in drops {
if &*d.item != "minecraft:air" {
self.pop_resource(pos, d);
}
}
let air = self.world.air;
self.place_state(pos, air, false)?;
Ok(())
}
/// The block entity part of `BlockInput.place`: load the block entity
/// from the argument's tag; true when its saved data changed.
pub(super) fn load_block_entity_nbt(&mut self, pos: [i32; 3], nbt: &str) -> bool {
use horizon_world::nbt::Tag;
let key = (pos[0], pos[1], pos[2]);
let Some(e) = self.world.block_entities.get(&key) else {
return false;
};
let name = self.data_block_name(pos);
let before = horizon_client::save::encode_block_entity(key, e, &name);
let Ok((mut tag, _)) = horizon_world::nbt::parse_snbt(nbt) else {
return false;
};
if let Tag::Compound(c) = &mut tag {
for k in ["id", "x", "y", "z"] {
if let Some(v) = before.get(k) {
c.insert(k.into(), v.clone());
}
}
}
let Some((_, new)) = horizon_client::save::decode_block_entity(&tag) else {
return false;
};
let after = horizon_client::save::encode_block_entity(key, &new, &name);
if after == before {
return false;
}
self.world.block_entities.insert(key, new);
let state = self.world.block(pos[0], pos[1], pos[2]);
let _ = self.world.set(pos[0], pos[1], pos[2], state);
true
}
fn cmd_fill(&mut self, ctx: &Context) -> R<i32> {
let a = self.block_pos_arg(ctx, "from")?;
let b = self.block_pos_arg(ctx, "to")?;
@@ -1418,10 +1638,7 @@ impl Game<'_> {
|| z == max[2];
let mut affected = false;
if destroy && current != air {
let creative = self.creative;
self.creative = false;
let _ = self.break_block([x, y, z]);
self.creative = creative;
self.destroy_block_dropping([x, y, z])?;
affected = true;
}
let target = if (outline || hollow) && !edge {
@@ -1497,21 +1714,29 @@ impl Game<'_> {
dest[2] + z - min[2],
],
s,
self.world.block_entities.get(&(x, y, z)).cloned(),
));
}
}
}
if moving {
for (from, _, _) in &copies {
for (from, _, _, _) in &copies {
self.place_state(*from, air, true)?;
}
}
let strict = ctx.has("strict");
// CloneCommands.clone sets every destination to a barrier first, so
// each copied state but a barrier counts as placed.
let barrier = self.res.assets.registry.default_state("minecraft:barrier");
let mut count = 0;
for (_, to, s) in copies {
if self.place_state(to, s, strict)? {
for (_, to, s, entity) in copies {
self.place_state(to, s, strict)?;
if Some(s) != barrier {
count += 1;
}
if let Some(e) = entity {
self.world.block_entities.insert((to[0], to[1], to[2]), e);
}
}
if count == 0 {
return Err(err("commands.clone.failed", &[]));
@@ -1758,7 +1983,7 @@ impl Game<'_> {
if self.ui.difficulty == i {
return Err(CommandError::new(Text::translate(
"commands.difficulty.failure",
&[Text::literal(DIFFICULTIES[i as usize])],
&[name(i)],
)));
}
self.ui.difficulty = i;
@@ -1808,7 +2033,7 @@ impl Game<'_> {
dim,
];
let key = if targets.len() == 1 {
args.push(Text::literal(PLAYER_NAME));
args.push(self.target_name(targets[0]));
"commands.spawnpoint.success.single"
} else {
args.push(Text::literal(targets.len().to_string()));
@@ -1828,9 +2053,6 @@ impl Game<'_> {
p[2].floor() as i32,
]
};
if self.dim != Dim::Overworld {
return Err(err("commands.setworldspawn.failure.not_overworld", &[]));
}
let rot = match ctx.get("rotation") {
Some(Arg::Coords(c)) => c.rotation(self.source_rotation()),
_ => [0.0, 0.0],
@@ -1865,6 +2087,89 @@ impl Game<'_> {
}
predicate.id == item
}
/// `ItemPredicateArgument`: the item test and its `[...]` component
/// tests (presence, `=` equality, `!` negation, `|` alternatives).
pub(super) fn stack_matches(&self, predicate: &ItemInput, stack: &ItemStack) -> bool {
if !self.item_matches(predicate, &stack.item) {
return false;
}
let Some(tests) = predicate.components.as_deref() else {
return true;
};
let inner = tests
.trim()
.strip_prefix('[')
.and_then(|t| t.strip_suffix(']'))
.unwrap_or("");
let components = match horizon_client::item_data::encode_components(stack) {
Some(horizon_world::nbt::Tag::Compound(c)) => c,
_ => Default::default(),
};
let test = |term: &str| -> bool {
let term = term.trim();
let (negated, term) = match term.strip_prefix('!') {
Some(t) => (true, t.trim()),
None => (false, term),
};
let split = term.find(['=', '~']).unwrap_or(term.len());
let id = term[..split].trim();
let id = if id.contains(':') {
id.to_owned()
} else {
format!("minecraft:{id}")
};
let present = components.get(&id.as_str().into());
let result = match term[split..].chars().next() {
Some('=') => {
let value = horizon_world::nbt::parse_snbt(term[split + 1..].trim())
.ok()
.map(|(t, _)| t);
match (present, value) {
(Some(have), Some(want)) => {
horizon_client::nbt_path::compare_nbt(&want, Some(have))
&& horizon_client::nbt_path::compare_nbt(have, Some(&want))
}
_ => false,
}
}
Some('~') => {
// Sub-predicates: `count` and component predicates.
let value = horizon_world::nbt::parse_snbt(term[split + 1..].trim())
.ok()
.map(|(t, _)| t);
match (id.as_str(), value) {
("minecraft:count", Some(v)) => {
let n = i64::from(stack.count);
match &v {
horizon_world::nbt::Tag::Compound(_) => {
let get = |k: &str| match v.get(k) {
Some(horizon_world::nbt::Tag::Int(i)) => {
Some(i64::from(*i))
}
_ => None,
};
get("min").is_none_or(|m| n >= m)
&& get("max").is_none_or(|m| n <= m)
}
horizon_world::nbt::Tag::Int(i) => n == i64::from(*i),
_ => false,
}
}
(_, Some(v)) => present.is_some_and(|have| {
horizon_client::nbt_path::compare_nbt(&v, Some(have))
}),
_ => false,
}
}
_ => present.is_some(),
};
result != negated
};
split_top_level(inner, ',')
.iter()
.filter(|t| !t.trim().is_empty())
.all(|term| split_top_level(term, '|').iter().any(|alt| test(alt)))
}
fn cmd_clear(&mut self, ctx: &Context) -> R<i32> {
let targets = if ctx.get("targets").is_some() {
self.entities(ctx, "targets", true)?
@@ -1885,19 +2190,30 @@ impl Game<'_> {
// Inventory.clearOrCountMatchingItems: main, armor, crafting grid, carried.
let mut removed = 0i32;
let mut budget = if max < 0 { i32::MAX } else { max };
let all = |g: &Self| -> Vec<Option<ItemStack>> {
let mut v: Vec<Option<ItemStack>> = g.inventory.clone();
v.extend(g.armor.iter().cloned());
v.extend(g.craft_grid.iter().cloned());
v.push(g.carried.clone());
v
};
let matching: Vec<bool> = all(self)
.iter()
.map(|s| {
s.as_ref()
.is_some_and(|s| self.stack_matches(&predicate, s))
})
.collect();
let mut slots: Vec<&mut Option<ItemStack>> = Vec::new();
slots.extend(self.inventory.iter_mut());
slots.extend(self.armor.iter_mut());
slots.extend(self.craft_grid.iter_mut());
slots.push(&mut self.carried);
for slot in slots {
for (slot, matches) in slots.into_iter().zip(matching) {
if !matches {
continue;
}
let Some(stack) = slot.as_mut() else { continue };
if !(predicate.any || predicate.tag || predicate.id == *stack.item) && !predicate.tag {
continue;
}
if predicate.tag {
continue;
}
let take = if counting {
stack.count as i32
} else {
@@ -1915,35 +2231,6 @@ impl Game<'_> {
}
}
}
if predicate.tag {
// Tag predicates: match against item tags.
let pred = predicate.clone();
let mut budget = if max < 0 { i32::MAX } else { max };
let items: Vec<(usize, String, u32)> = self
.inventory
.iter()
.enumerate()
.filter_map(|(i, s)| s.as_ref().map(|s| (i, s.item.to_string(), s.count)))
.collect();
for (i, item, count) in items {
if !self.item_matches(&pred, &item) {
continue;
}
let take = if counting {
count as i32
} else {
(count as i32).min(budget)
};
removed += take;
if !counting && let Some(s) = self.inventory[i].as_mut() {
budget -= take;
s.count -= take as u32;
if s.count == 0 {
self.inventory[i] = None;
}
}
}
}
if removed == 0 {
return Err(if targets.len() == 1 {
CommandError::new(Text::translate(
@@ -1964,35 +2251,179 @@ impl Game<'_> {
));
Ok(removed)
}
/// `PoiTypes`: the point of interest type of a block state.
fn poi_type(&self, state: horizon_world::registry::BlockStateId) -> Option<&'static str> {
let s = self.res.assets.registry.state(state)?;
let name = s.name.strip_prefix("minecraft:")?;
Some(match name {
"blast_furnace" => "minecraft:armorer",
"smoker" => "minecraft:butcher",
"cartography_table" => "minecraft:cartographer",
"brewing_stand" => "minecraft:cleric",
"composter" => "minecraft:farmer",
"barrel" => "minecraft:fisherman",
"fletching_table" => "minecraft:fletcher",
"cauldron" | "lava_cauldron" | "water_cauldron" | "powder_snow_cauldron" => {
"minecraft:leatherworker"
}
"lectern" => "minecraft:librarian",
"stonecutter" => "minecraft:mason",
"loom" => "minecraft:shepherd",
"smithing_table" => "minecraft:toolsmith",
"grindstone" => "minecraft:weaponsmith",
"bell" => "minecraft:meeting",
"beehive" => "minecraft:beehive",
"bee_nest" => "minecraft:bee_nest",
"nether_portal" => "minecraft:nether_portal",
"lodestone" => "minecraft:lodestone",
"test_instance_block" => "minecraft:test_instance",
n if n.ends_with("_bed") => {
if s.properties.get("part").map(String::as_str) != Some("head") {
return None;
}
"minecraft:home"
}
n if n.ends_with("lightning_rod") => "minecraft:lightning_rod",
_ => return None,
})
}
/// `LocateCommand.locatePoi`: `PoiManager.findClosestWithType` within
/// 256 blocks of the source, over the loaded chunks.
fn cmd_locate_poi(&mut self, ctx: &Context) -> R<i32> {
let Some(Arg::Resource(poi)) = ctx.get("poi").cloned() else {
return Ok(0);
};
let wanted: Vec<String> = match poi.strip_prefix('#') {
Some(tag) => self.tag_entries("point_of_interest_type", tag),
None => vec![poi.clone()],
};
let from = self.source_position().map(|v| v.floor() as i32);
const RANGE: i32 = 256;
let mut cache: std::collections::HashMap<u16, Option<&'static str>> =
std::collections::HashMap::new();
let mut best: Option<(i64, [i32; 3], &'static str)> = None;
let (cx0, cz0) = ((from[0] - RANGE) >> 4, (from[2] - RANGE) >> 4);
let (cx1, cz1) = ((from[0] + RANGE) >> 4, (from[2] + RANGE) >> 4);
for cx in cx0..=cx1 {
for cz in cz0..=cz1 {
let Some(chunk) = self.world.chunks.get(&(cx, cz)) else {
continue;
};
for (i, section) in chunk.sections.iter().enumerate() {
let mut wanted_state = |v: u32| {
let state = v as u16;
cache
.entry(state)
.or_insert_with(|| {
self.poi_type(horizon_world::registry::BlockStateId(u32::from(
state,
)))
.filter(|t| wanted.iter().any(|w| w == t))
})
.is_some()
};
if !section.blocks.maybe_has(&mut wanted_state) {
continue;
}
let base_y = horizon_client::chunk::MIN_Y + 16 * i as i32;
for j in 0..4096 {
let state = section.get(j);
let Some(kind) = cache.get(&state).copied().flatten() else {
continue;
};
let p = [
cx * 16 + (j & 15) as i32,
base_y + (j >> 8) as i32,
cz * 16 + ((j >> 4) & 15) as i32,
];
let d = [p[0] - from[0], p[1] - from[1], p[2] - from[2]]
.map(|d| i64::from(d) * i64::from(d))
.iter()
.sum::<i64>();
if d <= i64::from(RANGE * RANGE) && best.is_none_or(|(b, _, _)| d < b) {
best = Some((d, p, kind));
}
}
}
}
}
let Some((_, p, kind)) = best else {
return Err(CommandError::new(Text::tr(
"commands.locate.poi.not_found",
&[&poi],
)));
};
let coords = Text::translate(
"chat.coordinates",
&[
Text::literal(p[0].to_string()),
Text::literal("~"),
Text::literal(p[2].to_string()),
],
);
let link = Text::literal("[")
.append(coords)
.append("]")
.with_style(&Style {
color: Some(text::GREEN),
suggest: Some(format!("/tp @s {} ~ {}", p[0], p[2])),
..Style::default()
});
let (dx, dz) = (p[0] - from[0], p[2] - from[2]);
let distance = ((dx * dx + dz * dz) as f32).sqrt().floor() as i32;
let shown = if poi.starts_with('#') {
format!("{poi} ({kind})")
} else {
poi
};
self.feedback(Text::translate(
"commands.locate.poi.success",
&[
Text::literal(shown),
link,
Text::literal(distance.to_string()),
],
));
Ok(distance)
}
fn cmd_locate(&mut self, id: &str, ctx: &Context) -> R<i32> {
let origin = self.source_position();
if id == "locate.biome" {
let Some(Arg::Resource(biome)) = ctx.get("biome").cloned() else {
return Ok(0);
};
// Search loaded chunks around the player (BiomeSource.findClosestBiome3d
// samples a 6400-block radius; Horizon searches what is generated).
let (px, pz) = (origin[0].floor() as i32, origin[2].floor() as i32);
let mut best: Option<([i32; 3], f64)> = None;
for (&(cx, cz), chunk) in &self.world.chunks {
for (dx, dz) in [(0, 0), (8, 8)] {
let (x, z) = (cx * 16 + dx, cz * 16 + dz);
let y = origin[1].floor() as i32;
let b = self.res.biomes.get(chunk.biome(x, y, z));
if b.name == biome {
let d = f64::from((x - px).pow(2) + (z - pz).pow(2));
if best.is_none_or(|(_, bd)| d < bd) {
best = Some(([x, y, z], d));
}
}
}
}
let Some((p, d2)) = best else {
// LocateCommand.locateBiome: BiomeSource.findClosestBiome3d with
// a 6400-block radius, 32-block columns and 64-block layers.
let from = origin.map(|v| v.floor() as i32);
let allowed = |name: &str| self.biome_matches(&biome, name);
let search = horizon_world::worldgen::generator::BiomeSearch {
allowed: &allowed,
origin: from,
radius: 6400,
horizontal: 32,
vertical: 64,
min_y: horizon_client::chunk::MIN_Y,
max_y: horizon_client::chunk::MIN_Y + horizon_client::chunk::HEIGHT - 1,
};
let found = self
.end
.locator()
.and_then(|t| t.find_closest_biome(&search));
let Some((name, p)) = found else {
return Err(CommandError::new(Text::tr(
"commands.locate.biome.not_found",
&[&biome],
)));
};
let d2 = [p[0] - from[0], p[1] - from[1], p[2] - from[2]]
.map(|d| f64::from(d) * f64::from(d))
.iter()
.sum::<f64>();
let shown = if biome.starts_with('#') {
format!("{biome} ({name})")
} else {
biome.clone()
};
let coords = Text::tr("chat.coordinates", &[&p[0], &p[1], &p[2]]);
let link = Text::literal("[")
.append(coords)
@@ -2002,11 +2433,11 @@ impl Game<'_> {
suggest: Some(format!("/tp @s {} {} {}", p[0], p[1], p[2])),
..Style::default()
});
let distance = d2.sqrt().floor() as i32;
self.system_message(Text::translate(
let distance = (d2 as f32).sqrt().floor() as i32;
self.feedback(Text::translate(
"commands.locate.biome.success",
&[
Text::literal(biome),
Text::literal(shown),
link,
Text::literal(distance.to_string()),
],
@@ -2064,6 +2495,10 @@ impl Game<'_> {
}
/// The structures of a `worldgen/structure` tag, nested tags expanded.
pub(super) fn structure_tag(&self, tag: &str) -> Vec<String> {
self.tag_entries("worldgen/structure", tag)
}
/// The entries of a data pack tag of `registry`, nested tags expanded.
pub(super) fn tag_entries(&self, registry: &str, tag: &str) -> Vec<String> {
let mut out = Vec::new();
let mut pending = vec![tag.to_owned()];
let mut seen = std::collections::HashSet::new();
@@ -2075,7 +2510,7 @@ impl Game<'_> {
let file = self
.options
.resources
.join(format!("data/{ns}/tags/worldgen/structure/{path}.json"));
.join(format!("data/{ns}/tags/{registry}/{path}.json"));
let Ok(v) = std::fs::read(file)
.map_err(|_| ())
.and_then(|b| serde_json::from_slice::<serde_json::Value>(&b).map_err(|_| ()))
@@ -2126,6 +2561,9 @@ impl Game<'_> {
.italic()
}
};
if let Some(capture) = self.chat_capture.as_mut() {
capture.push(line.clone());
}
let focused = self.screen == Screen::Chat;
self.ui
.chat
@@ -2165,3 +2603,33 @@ impl Game<'_> {
out
}
}
/// Split at a separator outside brackets, braces and quotes.
fn split_top_level(s: &str, sep: char) -> Vec<&str> {
let mut out = Vec::new();
let (mut depth, mut quote, mut escaped, mut start) = (0i32, None::<char>, false, 0);
for (i, ch) in s.char_indices() {
if let Some(q) = quote {
if escaped {
escaped = false;
} else if ch == '\\' {
escaped = true;
} else if ch == q {
quote = None;
}
continue;
}
match ch {
'"' | '\'' => quote = Some(ch),
'[' | '{' => depth += 1,
']' | '}' => depth -= 1,
c if c == sep && depth == 0 => {
out.push(&s[start..i]);
start = i + ch.len_utf8();
}
_ => {}
}
}
out.push(&s[start..]);
out
}
@@ -0,0 +1,542 @@
//! `/compute` (ComputeCommand): context number providers
//! (`context_int_provider`, `context_float_provider`) evaluated in a loot
//! context of the source, optionally with a block or a target entity.
use super::{Arg, Context, Game, R, Target, err};
use horizon_client::{command::CommandError, text::Text};
use horizon_core::random::RandomSource;
use serde_json::Value;
/// The loot context parameters of `LootContextSources`.
#[derive(Clone, Copy, Default)]
pub(in crate::game) struct ComputeContext {
/// `BLOCK_STATE` (`compute block <pos>`).
pub block: Option<[i32; 3]>,
/// `TARGET_ENTITY` (`compute entity <target>`).
pub target: Option<Target>,
}
/// An ArithmeticException's message.
type Arith = String;
fn java_float(v: f32) -> String {
horizon_client::snbt::java_float(v)
}
impl Game<'_> {
/// A provider argument: its registry id (None when inline) and value.
pub(in crate::game) fn provider_arg(
&self,
ctx: &Context,
registry: &str,
) -> R<(Option<String>, Value)> {
let raw = match ctx.get("provider") {
Some(Arg::Resource(s) | Arg::Str(s)) => s.clone(),
_ => return Err(err("command.failed", &[])),
};
let first = raw.trim_start().chars().next().unwrap_or(' ');
if first == '{' || first == '[' || first == '-' || first.is_ascii_digit() || first == '"' {
let (tag, _) = horizon_world::nbt::parse_snbt(&raw)
.map_err(|e| err("argument.nbt.invalid", &[&e]))?;
return Ok((None, horizon_client::scoreboard::tag_to_json(&tag)));
}
let id = if raw.contains(':') {
raw
} else {
format!("minecraft:{raw}")
};
let value = self
.provider_file(registry, &id)
.ok_or_else(|| err("argument.resource_or_id.no_such_element", &[&id, &registry]))?;
Ok((Some(id), value))
}
/// A registered provider's definition.
fn provider_file(&self, registry: &str, id: &str) -> Option<Value> {
let (ns, path) = id.split_once(':').unwrap_or(("minecraft", id));
let dir = registry.trim_start_matches("minecraft:");
let file = self
.options
.resources
.join(format!("data/{ns}/{dir}/{path}.json"));
serde_json::from_slice(&std::fs::read(file).ok()?).ok()
}
/// The compute context the command's source literal selects.
pub(in crate::game) fn compute_context(&mut self, ctx: &Context) -> R<ComputeContext> {
let mut c = ComputeContext::default();
if ctx.literals.iter().any(|l| l == "block") && ctx.get("computePos").is_some() {
c.block = Some(self.block_pos_arg(ctx, "computePos")?);
}
if ctx.get("computeTarget").is_some() {
let t = self.entities(ctx, "computeTarget", false)?;
if t.len() > 1 {
return Err(err("argument.entity.toomany", &[]));
}
c.target = t.first().copied();
}
Ok(c)
}
/// `ComputeCommand.computeAsInt` / `computeAsFloat`.
pub(super) fn cmd_compute(&mut self, ctx: &Context) -> R<i32> {
let integer = ctx.literals.iter().any(|l| l == "integer");
let registry = if integer {
"minecraft:context_int_provider"
} else {
"minecraft:context_float_provider"
};
let (id, provider) = self.provider_arg(ctx, registry)?;
let c = self.compute_context(ctx)?;
let invalid = |value: String| -> CommandError {
match &id {
Some(id) => CommandError::new(Text::translate(
"command.compute.result.named.invalid",
&[Text::literal(id.clone()), Text::literal(value)],
)),
None => CommandError::new(Text::translate(
"command.compute.result.unnamed.invalid",
&[Text::literal(value)],
)),
}
};
let exact = |result: i32| match &id {
Some(id) => Text::translate(
"command.compute.result.named.exact",
&[Text::literal(id.clone()), Text::literal(result.to_string())],
),
None => Text::translate(
"command.compute.result.unnamed.exact",
&[Text::literal(result.to_string())],
),
};
if integer {
let result = self.provider_int(&provider, &c, 0).map_err(invalid)?;
self.feedback(exact(result));
return Ok(result);
}
let scale = match ctx.get("scale") {
Some(Arg::Float(s)) => *s,
_ => 1.0,
};
let original = self.provider_float(&provider, &c, 0).map_err(invalid)?;
if !original.is_finite() {
return Err(invalid(java_float(original)));
}
// Mth.floor(original * scale)
let result = (original * scale).floor() as i32;
if result as f32 == original {
self.feedback(exact(result));
} else {
let original_text = Text::literal(java_float(original));
let message = match &id {
Some(id) => Text::translate(
"command.compute.result.named.rounded",
&[
Text::literal(id.clone()),
original_text,
Text::literal(result.to_string()),
],
),
None => Text::translate(
"command.compute.result.unnamed.rounded",
&[original_text, Text::literal(result.to_string())],
),
};
self.feedback(message);
}
Ok(result)
}
// ---- evaluation ---------------------------------------------------------------
/// `ContextIntProvider.getIntUnsafe`.
pub(in crate::game) fn provider_int(
&mut self,
v: &Value,
c: &ComputeContext,
depth: u32,
) -> Result<i32, Arith> {
if depth > 64 {
return Ok(0);
}
let d = depth + 1;
match v {
Value::Number(n) => Ok(n
.as_i64()
.map_or_else(|| n.as_f64().unwrap_or(0.0) as i32, |i| i as i32)),
Value::Bool(b) => Ok(i32::from(*b)),
Value::String(id) => match self.provider_file("minecraft:context_int_provider", id) {
Some(def) => self.provider_int(&def, c, d),
None => Ok(0),
},
Value::Object(o) => {
let ty = o
.get("type")
.and_then(Value::as_str)
.unwrap_or("")
.trim_start_matches("minecraft:")
.to_owned();
let inputs = |g: &mut Self| -> Result<Vec<i32>, Arith> {
let list: Vec<Value> = match o.get("inputs") {
Some(Value::Array(a)) => a.clone(),
Some(other) => vec![other.clone()],
None => Vec::new(),
};
list.iter().map(|x| g.provider_int(x, c, d)).collect()
};
let field = |g: &mut Self, k: &str| -> Result<i32, Arith> {
match o.get(k) {
Some(x) => g.provider_int(x, c, d),
None => Ok(0),
}
};
let overflow = || "integer overflow".to_owned();
let long_to_int = |v: i64| -> Result<i32, Arith> {
i32::try_from(v)
.map_err(|_| format!("Value {v} can't be safely converted to int"))
};
Ok(match ty.as_str() {
"constant" => field(self, "value")?,
"add" => long_to_int(inputs(self)?.iter().map(|&x| i64::from(x)).sum())?,
"mul" => long_to_int(
inputs(self)?
.iter()
.fold(1i64, |a, &x| a.wrapping_mul(i64::from(x))),
)?,
"avg" => {
let xs = inputs(self)?;
if xs.is_empty() {
return Err("/ by zero".into());
}
let sum: i64 = xs.iter().map(|&x| i64::from(x)).sum();
long_to_int(sum / xs.len() as i64)?
}
"max" => inputs(self)?.into_iter().fold(i32::MIN, i32::max),
"min" => inputs(self)?.into_iter().fold(i32::MAX, i32::min),
"sub" => {
let (a, b) = (field(self, "left")?, field(self, "right")?);
a.checked_sub(b).ok_or_else(overflow)?
}
"div" | "mod" | "floor_div" | "floor_mod" => {
let (a, b) = (field(self, "left")?, field(self, "right")?);
if b == 0 {
return Err("/ by zero".into());
}
match ty.as_str() {
"div" => a.wrapping_div(b),
"mod" => a.wrapping_rem(b),
"floor_mod" => {
a.rem_euclid(b) + if b < 0 && a.rem_euclid(b) != 0 { b } else { 0 }
}
_ => {
if a == i32::MIN && b == -1 {
return Err(overflow());
}
a.div_euclid(b) - if b < 0 && a.rem_euclid(b) != 0 { 1 } else { 0 }
}
}
}
"pow" => {
let (base, exp) = (field(self, "base")?, field(self, "exponent")?);
if base == 0 && exp == 0 {
return Err("Result of 0 to the power of 0 is undefined".into());
}
if exp < 0 {
return Err("Negative exponent".into());
}
base.checked_pow(exp as u32).ok_or_else(overflow)?
}
// Math.absExact's message.
"abs" => field(self, "input")?.checked_abs().ok_or_else(|| {
"Overflow to represent absolute value of Integer.MIN_VALUE".to_owned()
})?,
"negate" => field(self, "input")?.checked_neg().ok_or_else(overflow)?,
"from_float" => {
let f = match o.get("input") {
Some(x) => self.provider_float(x, c, d)?,
None => 0.0,
};
if !f.is_finite() {
return Err(format!(
"Value {} can't be safely converted to int",
java_float(f)
));
}
long_to_int(f as i64)?
}
"uniform" => {
let (lo, hi) = (field(self, "min")?, field(self, "max")?);
if lo >= hi {
lo
} else {
self.world.random.next_int_bound(hi - lo + 1).unwrap_or(0) + lo
}
}
"binomial" => {
let n = field(self, "n")?;
let p = match o.get("p") {
Some(x) => self.provider_float(x, c, d)?,
None => 0.0,
};
(0..n.max(0))
.filter(|_| self.world.random.next_float() < p)
.count() as i32
}
"conditional" | "number_dispatcher" | "weighted_list" => {
match self.provider_select(o, c)? {
Some(x) => self.provider_int(&x, c, d)?,
None => 0,
}
}
_ => 0,
})
}
_ => Ok(0),
}
}
/// `ContextFloatProvider.getFloatUnsafe`.
pub(in crate::game) fn provider_float(
&mut self,
v: &Value,
c: &ComputeContext,
depth: u32,
) -> Result<f32, Arith> {
if depth > 64 {
return Ok(0.0);
}
let d = depth + 1;
match v {
Value::Number(n) => Ok(n.as_f64().unwrap_or(0.0) as f32),
Value::String(id) => match self.provider_file("minecraft:context_float_provider", id) {
Some(def) => self.provider_float(&def, c, d),
None => Ok(0.0),
},
Value::Object(o) => {
let ty = o
.get("type")
.and_then(Value::as_str)
.unwrap_or("")
.trim_start_matches("minecraft:")
.to_owned();
let inputs = |g: &mut Self| -> Result<Vec<f32>, Arith> {
let list: Vec<Value> = match o.get("inputs") {
Some(Value::Array(a)) => a.clone(),
Some(other) => vec![other.clone()],
None => Vec::new(),
};
list.iter().map(|x| g.provider_float(x, c, d)).collect()
};
let field = |g: &mut Self, k: &str| -> Result<f32, Arith> {
match o.get(k) {
Some(x) => g.provider_float(x, c, d),
None => Ok(0.0),
}
};
Ok(match ty.as_str() {
"constant" => field(self, "value")?,
"add" => inputs(self)?.iter().fold(0.0f32, |a, &x| a + x),
"mul" => inputs(self)?.iter().fold(1.0f32, |a, &x| a * x),
"avg" => {
let xs = inputs(self)?;
xs.iter().fold(0.0f32, |a, &x| a + x) / xs.len() as f32
}
"length" => inputs(self)?.iter().fold(0.0f32, |a, &x| a + x * x).sqrt(),
"max" => inputs(self)?.into_iter().fold(-f32::MAX, f32::max),
"min" => inputs(self)?.into_iter().fold(f32::MAX, f32::min),
"sub" => field(self, "left")? - field(self, "right")?,
"div" => field(self, "left")? / field(self, "right")?,
"mod" => {
let right = field(self, "right")?;
if right == 0.0 {
f32::NAN
} else {
field(self, "left")? % right
}
}
"pow" => {
let (base, exp) = (field(self, "base")?, field(self, "exponent")?);
if base == 0.0 && exp == 0.0 {
f32::NAN
} else {
f64::from(base).powf(f64::from(exp)) as f32
}
}
"abs" => field(self, "input")?.abs(),
"negate" => -field(self, "input")?,
"floor" => field(self, "input")?.floor(),
// Mth.ceil returns an int.
"ceil" => field(self, "input")?.ceil() as i32 as f32,
// Math.round(float): floor(x + 0.5) as int.
"round" => (field(self, "input")? + 0.5).floor() as i32 as f32,
"truncate" => field(self, "input")?.trunc(),
"sqrt" => field(self, "input")?.sqrt(),
"sin" => horizon_core::geometry::trig::sin(f64::from(field(self, "input")?)),
"cos" => horizon_core::geometry::trig::cos(f64::from(field(self, "input")?)),
"from_int" => match o.get("input") {
Some(x) => self.provider_int(x, c, d)? as f32,
None => 0.0,
},
"uniform" => {
let (lo, hi) = (field(self, "min")?, field(self, "max")?);
if lo >= hi {
lo
} else {
self.world.random.next_float() * (hi - lo) + lo
}
}
"conditional" | "number_dispatcher" | "weighted_list" => {
match self.provider_select(o, c)? {
Some(x) => self.provider_float(&x, c, d)?,
None => 0.0,
}
}
_ => 0.0,
})
}
_ => Ok(0.0),
}
}
/// The branch a conditional, dispatcher or weighted list provider picks.
fn provider_select(
&mut self,
o: &serde_json::Map<String, Value>,
c: &ComputeContext,
) -> Result<Option<Value>, Arith> {
match o
.get("type")
.and_then(Value::as_str)
.map(|t| t.trim_start_matches("minecraft:"))
{
Some("conditional") => {
let holds = o
.get("condition")
.is_some_and(|x| self.compute_condition(x, c));
Ok(if holds {
o.get("on_true").cloned()
} else {
Some(o.get("on_false").cloned().unwrap_or(Value::from(0)))
})
}
Some("number_dispatcher") => {
for case in o
.get("cases")
.and_then(Value::as_array)
.into_iter()
.flatten()
{
if case
.get("condition")
.is_some_and(|x| self.compute_condition(x, c))
{
return Ok(case.get("value").cloned());
}
}
Ok(Some(o.get("default").cloned().unwrap_or(Value::from(0))))
}
_ => {
// WeightedList.getRandomOrThrow.
let list: Vec<(Value, i32)> = o
.get("distribution")
.and_then(Value::as_array)
.into_iter()
.flatten()
.map(|e| {
(
e.get("data").cloned().unwrap_or(Value::Null),
e.get("weight").and_then(Value::as_i64).unwrap_or(1) as i32,
)
})
.collect();
let total: i32 = list.iter().map(|(_, w)| *w).sum();
if total <= 0 {
return Ok(None);
}
let mut pick = self.world.random.next_int_bound(total).unwrap_or(0);
for (v, w) in list {
pick -= w;
if pick < 0 {
return Ok(Some(v));
}
}
Ok(None)
}
}
}
/// A loot condition in the compute context: references, the logical
/// combinators and `match_block` on the context's block state.
fn compute_condition(&mut self, cond: &Value, c: &ComputeContext) -> bool {
match cond {
Value::String(id) => match self.provider_file("minecraft:predicate", id) {
Some(def) => self.compute_condition(&def, c),
None => false,
},
Value::Array(list) => list.iter().all(|x| self.compute_condition(x, c)),
Value::Object(o) => {
let ty = o
.get("type")
.or_else(|| o.get("condition"))
.and_then(Value::as_str)
.unwrap_or("")
.trim_start_matches("minecraft:");
match ty {
"inverted" => !o.get("term").is_some_and(|x| self.compute_condition(x, c)),
"all_of" => o
.get("terms")
.and_then(Value::as_array)
.into_iter()
.flatten()
.all(|x| self.compute_condition(x, c)),
"any_of" => o
.get("terms")
.and_then(Value::as_array)
.into_iter()
.flatten()
.any(|x| self.compute_condition(x, c)),
"match_block" | "block_state_property" => {
let Some(p) = c.block else {
return false;
};
let state = self.world.block(p[0], p[1], p[2]);
let Some(s) = self.res.assets.registry.state(state) else {
return false;
};
let name = s.name.to_string();
let blocks_ok = match o.get("blocks").or_else(|| o.get("block")) {
Some(Value::String(b)) => match b.strip_prefix('#') {
Some(tag) => self
.res
.items
.block_tags
.get(tag.trim_start_matches("minecraft:"))
.is_some_and(|set| {
set.contains(&*name)
|| set.contains(name.trim_start_matches("minecraft:"))
}),
None => *b == name,
},
Some(Value::Array(list)) => {
list.iter().any(|b| b.as_str() == Some(&name))
}
_ => true,
};
let props_ok = o
.get("state")
.or_else(|| o.get("properties"))
.and_then(Value::as_object)
.into_iter()
.flatten()
.all(|(k, v)| s.properties.get(k).map(String::as_str) == v.as_str());
blocks_ok && props_ok
}
"random_chance" => {
let chance = o.get("chance").and_then(Value::as_f64).unwrap_or(0.0) as f32;
self.world.random.next_float() < chance
}
_ => {
let source = self.command_source.unwrap_or_else(|| self.player_source());
let view = source.entity.map(|t| self.entity_view_of(t));
self.conditions_hold(cond, view.as_ref(), source.pos)
}
}
}
_ => false,
}
}
}
+72 -18
View File
@@ -42,6 +42,21 @@ impl Game<'_> {
if let Some(u) = player_uuid {
set_key(&mut tag, "UUID", Tag::IntArray(u.to_vec()));
}
// NbtPredicate.getEntityTagToCompare: a player's held stack.
let selected = self.level.selected_slot;
let held = match tag.get("Inventory") {
Some(Tag::List(items)) => items
.iter()
.find(|i| matches!(i.get("Slot"), Some(Tag::Byte(b)) if i32::from(*b) == selected))
.cloned(),
_ => None,
};
if let Some(mut stack) = held {
if let Tag::Compound(c) = &mut stack {
c.remove(&"Slot".into());
}
set_key(&mut tag, "SelectedItem", stack);
}
tag
}
Target::Mob(id) => {
@@ -87,6 +102,11 @@ impl Game<'_> {
let c = self.carts.iter().find(|c| c.id == id)?;
c.to_nbt(uuid, self.persist.raw.get(&id))
}
Target::Other(id) => {
let uuid = self.uuid_for(id);
let o = self.others.iter().find(|o| o.id == id)?.clone();
self.other_to_nbt(&o, uuid)
}
Target::Orb(i) => entity_nbt::orb_to_nbt(self.orbs.get(i)?, random_uuid()),
Target::Arrow(i) => {
let a = self.arrows.get(i)?;
@@ -166,7 +186,8 @@ impl Game<'_> {
| Target::Frame(id)
| Target::Painting(id)
| Target::Boat(id)
| Target::Cart(id) => Some(self.persist.raw.entry(id).or_insert_with(empty)),
| Target::Cart(id)
| Target::Other(id) => Some(self.persist.raw.entry(id).or_insert_with(empty)),
_ => None,
}
}
@@ -226,9 +247,16 @@ impl Game<'_> {
}
pub(in crate::game) fn data_of(&mut self, r: &DataRef) -> R<Tag> {
match r {
DataRef::Entity(t) => self
.entity_nbt(*t)
.ok_or_else(|| err("argument.entity.notfound.entity", &[])),
// EntityDataAccessor.getData: Entity.saveWithoutId.
DataRef::Entity(t) => {
let mut tag = self
.entity_nbt(*t)
.ok_or_else(|| err("argument.entity.notfound.entity", &[]))?;
if let Tag::Compound(c) = &mut tag {
c.remove(&"id".into());
}
Ok(tag)
}
DataRef::Block(p) => {
let key = (p[0], p[1], p[2]);
let name = self.data_block_name(*p);
@@ -237,7 +265,12 @@ impl Game<'_> {
.block_entities
.get(&key)
.ok_or_else(|| err("commands.data.block.invalid", &[]))?;
Ok(save::encode_block_entity(key, e, &name))
// BlockEntity.saveWithFullMetadata: no chunk-only keepPacked.
let mut tag = save::encode_block_entity(key, e, &name);
if let Tag::Compound(c) = &mut tag {
c.remove(&"keepPacked".into());
}
Ok(tag)
}
DataRef::Storage(id) => Ok(self.score.storage.get(id)),
}
@@ -626,10 +659,11 @@ impl Game<'_> {
};
self.world.loaded_entities.push((key, vec![tag]));
self.spawn_loaded_entities();
let id = self.next_entity;
if id == before {
if self.next_entity == before {
return None;
}
// The root of the stack is the first entity spawned.
let id = before + 1;
if self.mobs.iter().any(|m| m.id == id) {
Some(Target::Mob(id))
} else if self.dropped.iter().any(|e| e.id == id) {
@@ -644,6 +678,8 @@ impl Game<'_> {
Some(Target::Boat(id))
} else if self.carts.iter().any(|c| c.id == id) {
Some(Target::Cart(id))
} else if self.others.iter().any(|o| o.id == id) {
Some(Target::Other(id))
} else {
None
}
@@ -660,18 +696,36 @@ impl Game<'_> {
return Err(err("argument.nbt.expected.compound", &[]));
}
set_key(&mut tag, "id", Tag::String(kind.into()));
let p = pos.map(|v| Tag::Double(v.to_bits()));
set_key(&mut tag, "Pos", Tag::List(p.to_vec()));
if tag.get("Rotation").is_none() {
set_key(
&mut tag,
"Rotation",
Tag::List(vec![
Tag::Float(0.0f32.to_bits()),
Tag::Float(0.0f32.to_bits()),
]),
);
// EntityType.loadEntityRecursive snaps every entity of the stack,
// passengers included, to the position.
fn place(tag: &mut Tag, pos: [f64; 3]) {
let p = pos.map(|v| Tag::Double(v.to_bits()));
set_key(tag, "Pos", Tag::List(p.to_vec()));
// Entity.load: an absent Fire reads as 0 (until the entity moves).
if tag.get("Fire").is_none() {
set_key(tag, "Fire", Tag::Short(0));
}
if tag.get("Rotation").is_none() {
set_key(
tag,
"Rotation",
Tag::List(vec![
Tag::Float(0.0f32.to_bits()),
Tag::Float(0.0f32.to_bits()),
]),
);
}
if let Tag::Compound(c) = tag
&& let Some(Tag::List(riders)) = c.get_mut(&"Passengers".into())
{
for r in riders {
if matches!(r, Tag::Compound(_)) {
place(r, pos);
}
}
}
}
place(&mut tag, pos);
Ok(self.spawn_entity_from_nbt(tag))
}
}
@@ -23,6 +23,9 @@ pub(in crate::game) struct Source {
pub silent: bool,
/// Index of the newest `store` in `ExecState::stores`.
pub store: Option<u32>,
/// `execute in` another dimension than the one Horizon has loaded: none
/// of its chunks are loaded.
pub elsewhere: bool,
}
/// Where `execute store` writes.
@@ -70,6 +73,7 @@ impl Game<'_> {
eyes: false,
silent: false,
store: None,
elsewhere: false,
}
}
/// The server as a source (function ticks and schedules): the world spawn.
@@ -81,6 +85,7 @@ impl Game<'_> {
eyes: false,
silent: true,
store: None,
elsewhere: false,
}
}
pub(super) fn target_rotation(&self, t: Target) -> [f32; 2] {
@@ -106,6 +111,11 @@ impl Game<'_> {
.iter()
.find(|c| c.id == id)
.map_or([0.0; 2], |c| [c.yaw, 0.0]),
Target::Other(id) => self
.others
.iter()
.find(|o| o.id == id)
.map_or([0.0; 2], |o| [o.yaw, o.pitch]),
_ => [0.0; 2],
}
}
@@ -147,7 +157,7 @@ impl Game<'_> {
/// Run one command line with `source` (no error reporting): the entry
/// for functions and `execute run`.
pub(in crate::game) fn execute_line(&mut self, line: &str, source: Source) -> R<i32> {
let d = vanilla::dispatcher();
let d = vanilla::game_dispatcher();
let parse = d.parse(line, &self.ui.registries);
let (ctx, _) = parse.executable()?;
let ctx = ctx.clone();
@@ -189,6 +199,12 @@ impl Game<'_> {
}
/// `CommandResultCallback`s of a source's `store` chain, oldest first.
fn deliver(&mut self, store: Option<u32>, success: bool, value: i32) {
// The outermost source's own CommandResultCallback (harness record).
if self.exec.function_depth == 0
&& let Some(results) = self.cmds.results.as_mut()
{
results.push((success, value));
}
let mut chain = Vec::new();
let mut at = store;
while let Some(i) = at {
@@ -235,6 +251,10 @@ impl Game<'_> {
pub(in crate::game) fn run_execute(&mut self, ctx: &Context) -> R<i32> {
let mut sources = vec![self.command_source.unwrap_or_else(|| self.player_source())];
let mut c = ctx;
// A fork modifier (as, at, positioned as, rotated as, facing entity,
// on, a non-terminal if/unless) makes later errors silent
// (CommandSourceStack.handleError with `forked`).
let mut forked = false;
loop {
let word = c
.literals
@@ -257,7 +277,8 @@ impl Game<'_> {
for s in sources {
match self.with_source(s, |g| g.run_chain(command, last)) {
Ok(n) => total += n,
// Forked executions report failures and carry on.
Err(_) if forked => {}
// Several sources: report each failure and carry on.
Err(e) if many => self.command_failure(e.message),
Err(e) => failure = Some(e),
}
@@ -275,6 +296,7 @@ impl Game<'_> {
if c.child.is_none() {
return self.run_conditional_terminal(c, sources, want);
}
forked = true;
let mut kept = Vec::new();
for s in sources {
let (keep, _) = self.with_source(s, |g| g.condition(c, want))?;
@@ -285,6 +307,12 @@ impl Game<'_> {
sources = kept;
}
_ => {
forked |= match word {
"as" | "at" | "on" => true,
"positioned" | "rotated" => c.has("as"),
"facing" => c.has("entity"),
_ => false,
};
let mut next = Vec::new();
for s in sources {
next.extend(self.with_source(s, |g| g.modify(word, c, s))?);
@@ -407,6 +435,7 @@ impl Game<'_> {
Some(Source {
pos: self.target_position(t)?,
rot: self.target_rotation(t),
elsewhere: false,
..s
})
})
@@ -497,14 +526,21 @@ impl Game<'_> {
..s
}],
"in" => {
// Horizon keeps one dimension loaded; others cannot be a source.
// Horizon keeps one dimension loaded: in another one, no
// chunk is loaded (as in vanilla without a player there).
let Some(Arg::Resource(dim)) = c.get("dimension") else {
return Ok(vec![s]);
};
if dim != self.dim.id() {
if !matches!(
dim.as_str(),
"minecraft:overworld" | "minecraft:the_nether" | "minecraft:the_end"
) {
return Err(err("argument.dimension.invalid", &[dim]));
}
vec![s]
vec![Source {
elsewhere: dim != self.dim.id(),
..s
}]
}
"summon" => {
let Some(Arg::Resource(kind)) = c.get("entity").cloned() else {
File diff suppressed because it is too large Load Diff
+264 -20
View File
@@ -7,6 +7,7 @@ use horizon_client::{
scoreboard_cmd::{Holder, Tracker},
text::Text,
};
use horizon_world::nbt::Tag;
/// One addressable slot.
#[derive(Clone, Debug, PartialEq)]
@@ -290,7 +291,7 @@ impl Game<'_> {
}
}
fn stack_name(&self, s: &ItemStack) -> Text {
self.item_display_name(&s.item)
self.stack_display_name(s)
}
fn item_from_input(&self, ctx: &Context) -> R<Option<ItemStack>> {
let Some(Arg::Item(ItemInput { id, components, .. })) = ctx.get("item").cloned() else {
@@ -351,12 +352,12 @@ impl Game<'_> {
},
Value::Object(_) => {
let mut stack = stack?;
if !m["conditions"].is_null()
&& !self.conditions_hold(&m["conditions"], this, origin)
// 26.3 item modifiers: a single `condition`, dispatched on `type`.
if !m["condition"].is_null() && !self.conditions_hold(&m["condition"], this, origin)
{
return Some(stack);
}
match m["function"].as_str().unwrap_or("") {
match m["type"].as_str().unwrap_or("") {
"minecraft:sequence" => {
#[allow(clippy::manual_try_fold)]
return m["functions"]
@@ -408,9 +409,19 @@ impl Game<'_> {
}
}
"minecraft:set_name" => {
let t = horizon_client::packs::component(&m["name"]);
stack.extra.get_or_insert_with(Default::default).custom_name =
Some(t.plain());
if m["name"].is_null() {
return Some(stack);
}
if m["target"].as_str() == Some("item_name") {
let name = horizon_client::scoreboard::json_to_tag(&m["name"]);
edit_components(&mut stack, |c| {
c.insert("minecraft:item_name".into(), name);
});
} else {
let t = horizon_client::packs::component(&m["name"]);
stack.extra.get_or_insert_with(Default::default).custom_name =
Some(t.plain());
}
}
"minecraft:set_enchantments" => {
let add = m["add"].as_bool() == Some(true);
@@ -440,6 +451,129 @@ impl Game<'_> {
Some(p.into());
}
}
"minecraft:set_lore" => {
let lines: Vec<Tag> = m["lore"]
.as_array()
.into_iter()
.flatten()
.map(horizon_client::scoreboard::json_to_tag)
.collect();
edit_components(&mut stack, |c| {
let old: Vec<Tag> = match c.get(&"minecraft:lore".into()) {
Some(Tag::List(l)) => l.clone(),
_ => Vec::new(),
};
let new = list_operation(m, old, lines);
c.insert("minecraft:lore".into(), Tag::List(new));
});
}
"minecraft:set_custom_data" => {
let tag = match &m["tag"] {
Value::String(snbt) => horizon_world::nbt::parse_snbt(snbt)
.map(|(t, _)| t)
.unwrap_or(Tag::Compound(Default::default())),
v => horizon_client::scoreboard::json_to_tag(v),
};
edit_components(&mut stack, |c| {
let mut data = match c.get(&"minecraft:custom_data".into()) {
Some(t @ Tag::Compound(_)) => t.clone(),
_ => Tag::Compound(Default::default()),
};
merge_compound(&mut data, &tag);
c.insert("minecraft:custom_data".into(), data);
});
}
"minecraft:set_components" => {
let patch = m["components"].clone();
edit_components(&mut stack, |c| {
for (k, v) in patch.as_object().into_iter().flatten() {
let (remove, key) = match k.strip_prefix('!') {
Some(rest) => (true, rest),
None => (false, k.as_str()),
};
let key = if key.contains(':') {
key.to_owned()
} else {
format!("minecraft:{key}")
};
if remove {
c.remove(&key.as_str().into());
} else {
c.insert(
key.as_str().into(),
horizon_client::scoreboard::json_to_tag(v),
);
}
}
});
}
"minecraft:toggle_tooltips" => {
let toggles = m["toggles"].clone();
edit_components(&mut stack, |c| {
let mut hidden: Vec<String> = c
.get(&"minecraft:tooltip_display".into())
.and_then(|d| d.get("hidden_components"))
.and_then(|l| match l {
Tag::List(l) => Some(
l.iter()
.filter_map(|t| match t {
Tag::String(s) => Some(s.to_string_lossy()),
_ => None,
})
.collect(),
),
_ => None,
})
.unwrap_or_default();
let hide_tooltip = c
.get(&"minecraft:tooltip_display".into())
.and_then(|d| d.get("hide_tooltip"))
.cloned();
for (k, shown) in toggles.as_object().into_iter().flatten() {
let key = if k.contains(':') {
k.clone()
} else {
format!("minecraft:{k}")
};
hidden.retain(|h| *h != key);
if shown.as_bool() == Some(false) {
hidden.push(key);
}
}
let mut display: Vec<(&str, Tag)> = Vec::new();
if let Some(h) = hide_tooltip {
display.push(("hide_tooltip", h));
}
if !hidden.is_empty() {
display.push((
"hidden_components",
Tag::List(
hidden
.iter()
.map(|h| Tag::String(h.as_str().into()))
.collect(),
),
));
}
c.insert("minecraft:tooltip_display".into(), Tag::compound(display));
});
}
"minecraft:filtered" => {
let pass = self.loot_item_filter(&m["item_filter"], &stack);
let branch = if pass { &m["on_pass"] } else { &m["on_fail"] };
if branch.is_null() {
return Some(stack);
}
return self.apply_item_modifier(
branch,
Some(stack),
rng,
this,
origin,
depth + 1,
);
}
"minecraft:discard" => stack.count = 0,
_ => {}
}
(stack.count > 0).then_some(stack)
@@ -447,6 +581,38 @@ impl Game<'_> {
_ => stack,
}
}
/// `ItemStack.getMaxStackSize`: the max_stack_size component, else the
/// item's.
pub(super) fn stack_max_size(&self, s: &ItemStack) -> u32 {
if let Some(Tag::Int(n)) = s.data().and_then(|d| d.other("minecraft:max_stack_size")) {
return (*n).clamp(1, 99) as u32;
}
self.res.items.get(&s.item).map_or(64, |i| i.max_stack)
}
/// `ResourceOrIdArgument.getItemModifier`: an inline modifier (SNBT) or
/// a registered one.
pub(super) fn item_modifier_arg(&mut self, ctx: &Context, name: &str) -> R<serde_json::Value> {
let raw = match ctx.get(name) {
Some(Arg::Resource(s) | Arg::Str(s)) => s.clone(),
_ => return Err(err("command.failed", &[])),
};
if raw.starts_with('{') || raw.starts_with('[') {
let (tag, _) = horizon_world::nbt::parse_snbt(&raw)
.map_err(|e| err("argument.nbt.invalid", &[&e]))?;
return Ok(horizon_client::scoreboard::tag_to_json(&tag));
}
let id = if raw.contains(':') {
raw
} else {
format!("minecraft:{raw}")
};
self.fns
.store
.item_modifiers
.get(&id)
.cloned()
.ok_or_else(|| err("argument.item_modifier.unknown", &[&id]))
}
/// `/item modify (entity|block) <target> <slot> <modifier>`.
pub(super) fn cmd_item_modify(&mut self, ctx: &Context) -> R<i32> {
self.ensure_datapacks();
@@ -454,17 +620,7 @@ impl Game<'_> {
let Some(Arg::Str(slot_name)) = ctx.get("slot").cloned() else {
return Ok(0);
};
let Some(Arg::Str(id)) = ctx.get("modifier").cloned() else {
return Ok(0);
};
let id = if id.contains(':') {
id
} else {
format!("minecraft:{id}")
};
let Some(modifier) = self.fns.store.item_modifiers.get(&id).cloned() else {
return Err(err("argument.item_modifier.unknown", &[&id]));
};
let modifier = self.item_modifier_arg(ctx, "modifier")?;
let source = self.command_source.unwrap_or_else(|| self.player_source());
let view = source.entity.map(|t| self.entity_view_of(t));
let seed = std::time::SystemTime::now()
@@ -501,7 +657,14 @@ impl Game<'_> {
source.pos,
0,
);
if new.as_ref() != Some(&current) && self.slot_set(slot, new) {
// CountingModifier: every slot set counts, changed or not;
// ItemStack.limitSize to the (new) max stack size.
let new = new.map(|mut s| {
let max = self.stack_max_size(&s);
s.count = s.count.min(max);
s
});
if self.slot_set(slot, new) {
changed += 1;
}
}
@@ -582,6 +745,28 @@ impl Game<'_> {
_ => err("commands.item.source.no_such_slot", &[&source_slots]),
});
}
// ItemCommands.applyModifier on each source stack.
if ctx.get("modifier").is_some() {
let modifier = self.item_modifier_arg(ctx, "modifier")?;
let source = self.command_source.unwrap_or_else(|| self.player_source());
let view = source.entity.map(|t| self.entity_view_of(t));
let mut rng = horizon_core::random::LegacyRandom::new(0);
found = found
.into_iter()
.map(|s| {
s.and_then(|s| {
self.apply_item_modifier(
&modifier,
Some(s),
&mut rng,
view.as_ref(),
source.pos,
0,
)
})
})
.collect();
}
// A source with nothing in the slot contributes air.
(found, None)
};
@@ -706,7 +891,7 @@ impl Game<'_> {
if let Some(stack) = self.slot_get(&s)
&& predicate
.as_ref()
.is_some_and(|p| self.item_matches(p, &stack.item))
.is_some_and(|p| self.stack_matches(p, &stack))
{
count += stack.count as i32;
}
@@ -715,3 +900,62 @@ impl Game<'_> {
Ok((count > 0, count))
}
}
/// Edit a stack's components as their saved compound.
fn edit_components(stack: &mut ItemStack, f: impl FnOnce(&mut horizon_world::nbt::Compound)) {
let mut c = match horizon_client::item_data::encode_components(stack) {
Some(Tag::Compound(c)) => c,
_ => horizon_world::nbt::Compound::new(),
};
f(&mut c);
let tag = Tag::Compound(c);
let (damage, extra) = horizon_client::item_data::decode_components(Some(&tag));
stack.damage = damage;
stack.extra = extra;
stack.tidy();
}
/// `CompoundTag.merge`: nested compounds merge, other values replace.
fn merge_compound(into: &mut Tag, from: &Tag) {
let (Tag::Compound(a), Tag::Compound(b)) = (into, from) else {
return;
};
for (k, v) in b {
match (a.get_mut(k), v) {
(Some(existing @ Tag::Compound(_)), Tag::Compound(_)) => merge_compound(existing, v),
_ => {
a.insert(k.clone(), v.clone());
}
}
}
}
/// `ListOperation.apply` (`mode`: replace_all, replace_section, insert,
/// append) with a 256-entry limit.
fn list_operation(m: &serde_json::Value, old: Vec<Tag>, new: Vec<Tag>) -> Vec<Tag> {
let offset = m["offset"].as_u64().unwrap_or(0) as usize;
let mut out = match m["mode"].as_str().unwrap_or("") {
"replace_all" => new,
"insert" => {
let at = offset.min(old.len());
let mut out = old[..at].to_vec();
out.extend(new);
out.extend_from_slice(&old[at..]);
out
}
"replace_section" => {
let at = offset.min(old.len());
let size = m["size"].as_u64().map_or(new.len(), |s| s as usize);
let mut out = old[..at].to_vec();
out.extend(new);
let end = (at + size).min(old.len());
out.extend_from_slice(&old[end..]);
out
}
_ => {
let mut out = old;
out.extend(new);
out
}
};
out.truncate(256);
out
}
+119 -10
View File
@@ -70,20 +70,129 @@ impl Game<'_> {
}
None
}
/// `BlockPosArgument.getLoadedBlockPos(pos)`, or the source's block.
fn place_pos(&self, ctx: &Context, name: &str) -> R<[i32; 3]> {
if ctx.get(name).is_some() {
return self.block_pos_arg(ctx, name);
}
Ok(self.source_position().map(|v| v.floor() as i32))
}
/// `PlaceCommand.checkLoaded`: every chunk of the inclusive range.
fn place_check_loaded(&self, min: [i32; 2], max: [i32; 2]) -> R<()> {
let elsewhere = self.command_source.is_some_and(|s| s.elsewhere);
for cx in min[0]..=max[0] {
for cz in min[1]..=max[1] {
if elsewhere || !self.world.chunks.contains_key(&(cx, cz)) {
return Err(err("argument.pos.unloaded", &[]));
}
}
}
Ok(())
}
/// `PlaceCommand.placeFeature`, `placeJigsaw` and `placeStructure`.
pub(super) fn cmd_place_generated(&mut self, id: &str, ctx: &Context) -> R<i32> {
match id {
"place.feature" => {
let raw = match ctx.get("feature") {
Some(Arg::Resource(s) | Arg::Str(s)) => s.clone(),
_ => return Ok(0),
};
let pos = self.place_pos(ctx, "pos")?;
let (cx, cz) = (pos[0] >> 4, pos[2] >> 4);
self.place_check_loaded([cx - 1, cz - 1], [cx + 1, cz + 1])?;
// Inline features are not built by the live feature registry.
if raw.starts_with('{') {
return Err(err("command.failed", &[]));
}
let name = if raw.contains(':') {
raw
} else {
format!("minecraft:{raw}")
};
let at = horizon_core::position::BlockPos::new(pos[0], pos[1], pos[2]);
let placed = self
.with_level(|b, level, ticks| b.place_feature(level, ticks, &name, at))
.ok_or_else(|| err("command.failed", &[]))?;
self.process_level_events()
.map_err(|_| err("command.failed", &[]))?;
if !placed {
return Err(err("commands.place.feature.failed", &[]));
}
self.feedback(Text::translate(
"commands.place.feature.success",
&[Text::literal(name), num(pos[0]), num(pos[1]), num(pos[2])],
));
Ok(1)
}
"place.jigsaw" => {
let Some(Arg::Resource(pool)) = ctx.get("pool").cloned() else {
return Ok(0);
};
if !self
.ui
.registries
.ids("minecraft:worldgen/template_pool")
.contains(&pool)
{
return Err(err("commands.place.jigsaw.invalid", &[&pool]));
}
let target = match ctx.get("target") {
Some(Arg::Resource(s) | Arg::Str(s)) => s.clone(),
_ => return Ok(0),
};
let max_depth = match ctx.get("max_depth") {
Some(Arg::Int(n)) => *n,
_ => return Ok(0),
};
let pos = self.place_pos(ctx, "position")?;
self.place_check_loaded([pos[0] >> 4, pos[2] >> 4], [pos[0] >> 4, pos[2] >> 4])?;
let terrain = self
.end
.locator()
.ok_or_else(|| err("command.failed", &[]))?;
let query = horizon_world::worldgen::generator::JigsawQuery {
pool: &pool,
target: &target,
max_depth,
position: pos,
};
let placed = self.with_level(|b, level, ticks| {
b.place_jigsaw(level, ticks, pos, || terrain.jigsaw_pieces(&query))
});
self.process_level_events()
.map_err(|_| err("command.failed", &[]))?;
if !placed {
return Err(err("commands.place.jigsaw.failed", &[]));
}
self.feedback(Text::translate(
"commands.place.jigsaw.success",
&[num(pos[0]), num(pos[1]), num(pos[2])],
));
Ok(1)
}
_ => {
let Some(Arg::Resource(structure)) = ctx.get("structure").cloned() else {
return Ok(0);
};
if !self
.ui
.registries
.ids("minecraft:worldgen/structure")
.contains(&structure)
{
return Err(err("commands.place.structure.invalid", &[&structure]));
}
self.place_pos(ctx, "pos")?;
// Structure.generate is not wired to the live level.
Err(err("command.failed", &[]))
}
}
}
pub(super) fn cmd_place(&mut self, ctx: &Context) -> R<i32> {
let Some(Arg::Resource(id)) = ctx.get("template").cloned() else {
return Ok(0);
};
let pos = if ctx.get("pos").is_some() {
self.block_pos_arg(ctx, "pos")?
} else {
let p = self.source_position();
[
p[0].floor() as i32,
p[1].floor() as i32,
p[2].floor() as i32,
]
};
let pos = self.place_pos(ctx, "pos")?;
let rotation = match ctx.get("rotation") {
Some(Arg::Str(r)) => Rotation::from_name(r).unwrap_or(Rotation::None),
_ => Rotation::None,
@@ -2,6 +2,7 @@
use super::{Arg, Context, Game, R, Target, err, items::Owner};
use horizon_client::{
chunk::{HEIGHT, MIN_Y},
command::CommandError,
items::ItemStack,
scoreboard_cmd::{Holder, Tracker},
text::Text,
@@ -146,18 +147,14 @@ impl Game<'_> {
// ---- /fillbiome ----------------------------------------------------------------
pub(super) fn cmd_fillbiome(&mut self, ctx: &Context) -> R<i32> {
let (Some(Arg::Resource(biome)), from, to) = (
ctx.get("biome").cloned(),
self.coords(ctx, "from"),
self.coords(ctx, "to"),
) else {
let Some(Arg::Resource(biome)) = ctx.get("biome").cloned() else {
return Ok(0);
};
let (Some(from), Some(to)) = (from, to) else {
return Ok(0);
};
let (src_pos, src_rot) = (self.source_position(), self.source_rotation());
let (a, b) = (from.block(src_pos, src_rot), to.block(src_pos, src_rot));
// BlockPosArgument.getLoadedBlockPos on both corners first.
let (a, b) = (
self.block_pos_arg(ctx, "from")?,
self.block_pos_arg(ctx, "to")?,
);
// Quantize to biome cells (`QuartPos`), then work with the box.
let q = |v: i32| (v >> 2) << 2;
let lo = [
@@ -433,11 +430,20 @@ impl Game<'_> {
fn tool_stack(&mut self, ctx: &Context) -> R<Option<ItemStack>> {
if let Some(Arg::Item(p)) = ctx.get("tool") {
let (damage, extra) = match p
.components
.as_deref()
.map(horizon_client::item_data::command_components)
{
Some(Ok(tag)) => horizon_client::item_data::decode_components(Some(&tag)),
Some(Err(e)) => return Err(CommandError::new(Text::literal(e))),
None => (0, None),
};
return Ok(Some(ItemStack {
item: p.id.as_str().into(),
count: 1,
damage: 0,
extra: None,
damage,
extra,
}));
}
let entity = self
@@ -461,19 +467,41 @@ impl Game<'_> {
let Some(Arg::Resource(table)) = ctx.get("loot_table").cloned() else {
return Ok(0);
};
if !self.res.items.has_loot_table(&table) {
return Err(err("argument.resource_or_id.failed_to_parse", &[&table]));
}
let held = if id == "loot.fish" {
self.tool_stack(ctx)?
} else {
None
};
let drops =
self.res
// An inline table (ResourceOrIdArgument): no random sequence.
if table.starts_with('{') {
let (tag, _) = horizon_world::nbt::parse_snbt(&table)
.map_err(|e| err("argument.nbt.invalid", &[&e]))?;
let json = horizon_client::scoreboard::tag_to_json(&tag);
let drops = self
.res
.items
.loot_table(&table, false, held.as_ref(), &mut self.world.random);
(drops, None)
.inline_loot_table(&json, &mut self.world.random);
(drops, None)
} else {
if !self.res.items.has_loot_table(&table) {
return Err(err("argument.resource_or_id.failed_to_parse", &[&table]));
}
let held = if id == "loot.fish" {
self.tool_stack(ctx)?
} else {
None
};
let drops = match self.res.items.loot_sequence(&table) {
Some(seq) => {
let random = self.rand_sequences.get(&seq, self.level.seed);
self.res
.items
.loot_table(&table, false, held.as_ref(), random)
}
None => self.res.items.loot_table(
&table,
false,
held.as_ref(),
&mut self.world.random,
),
};
(drops, None)
}
}
"loot.kill" => {
let targets = self.entities(ctx, "target", false)?;
@@ -493,12 +521,20 @@ impl Game<'_> {
None | Some(Some(Target::Player))
);
let held = self.slot_get(&super::items::Slot::Inv(self.selected));
let drops = self.res.items.entity_drops(
&ty,
by_player,
held.as_ref(),
&mut self.world.random,
);
let drops = match self.res.items.loot_sequence(&table) {
Some(seq) => {
let random = self.rand_sequences.get(&seq, self.level.seed);
self.res
.items
.entity_drops(&ty, by_player, held.as_ref(), random)
}
None => self.res.items.entity_drops(
&ty,
by_player,
held.as_ref(),
&mut self.world.random,
),
};
(drops, Some(table))
}
_ => {
@@ -511,12 +547,23 @@ impl Game<'_> {
return Err(err("commands.drop.no_loot_table.block", &[&name]));
}
let tool = self.tool_stack(ctx)?;
let drops = self.res.items.block_drops(
self.res.assets.registry,
state,
tool.as_ref(),
&mut self.world.random,
);
let drops = match self.res.items.loot_sequence(&table) {
Some(seq) => {
let random = self.rand_sequences.get(&seq, self.level.seed);
self.res.items.block_drops(
self.res.assets.registry,
state,
tool.as_ref(),
random,
)
}
None => self.res.items.block_drops(
self.res.assets.registry,
state,
tool.as_ref(),
&mut self.world.random,
),
};
(drops, Some(table))
}
};
@@ -11,6 +11,37 @@ impl Game<'_> {
};
let value: serde_json::Value =
serde_json::from_str(json).map_err(|e| err("argument.component.invalid", &[&e]))?;
// NbtContents.resolve: the path's values in the entity, block or
// storage data, rich-styled (or plain, or interpreted), ", "-joined.
let nbt_values = std::cell::RefCell::new(Vec::new());
{
let mut collect = |o: &serde_json::Map<String, serde_json::Value>| {
if o.contains_key("nbt") {
nbt_values.borrow_mut().push(o.clone());
}
};
fn walk(
v: &serde_json::Value,
f: &mut dyn FnMut(&serde_json::Map<String, serde_json::Value>),
) {
match v {
serde_json::Value::Object(o) => {
f(o);
for (_, x) in o {
walk(x, f);
}
}
serde_json::Value::Array(a) => a.iter().for_each(|x| walk(x, f)),
_ => {}
}
}
walk(&value, &mut collect);
}
let mut resolved: Vec<(serde_json::Map<String, serde_json::Value>, Text)> = Vec::new();
for o in nbt_values.into_inner() {
let t = self.resolve_nbt_component(&o);
resolved.push((o, t));
}
let mut resolve = |raw: &str| -> Text {
let mut reader = horizon_client::command::Reader::new(raw);
let entities = horizon_client::command::args::ArgType::Entity {
@@ -30,7 +61,79 @@ impl Game<'_> {
}
out
};
Ok(horizon_client::component::to_text(&value, &mut resolve))
Ok(horizon_client::component::to_text_with(
&value,
&mut resolve,
&mut |o| {
resolved
.iter()
.find(|(k, _)| k == o)
.map(|(_, t)| t.clone())
},
))
}
/// The text of an `nbt` component.
fn resolve_nbt_component(&mut self, o: &serde_json::Map<String, serde_json::Value>) -> Text {
use horizon_world::nbt::Tag;
let path = o.get("nbt").and_then(|v| v.as_str()).unwrap_or("");
let mut sources: Vec<Tag> = Vec::new();
if let Some(sel) = o.get("entity").and_then(|v| v.as_str()) {
let mut reader = horizon_client::command::Reader::new(sel);
let ty = horizon_client::command::args::ArgType::Entity {
single: false,
players: false,
};
if let Ok(Arg::Entity(s)) = ty.parse(&mut reader, &self.ui.registries) {
for t in self.select(&s) {
if let Ok(tag) = self.data_of(&super::data::DataRef::Entity(t)) {
sources.push(tag);
}
}
}
} else if let Some(id) = o.get("storage").and_then(|v| v.as_str()) {
let id = if id.contains(':') {
id.to_owned()
} else {
format!("minecraft:{id}")
};
sources.push(self.score.storage.get(&id));
} else if let Some(pos) = o.get("block").and_then(|v| v.as_str()) {
let p: Vec<i32> = pos
.split_whitespace()
.filter_map(|v| v.parse().ok())
.collect();
if let [x, y, z] = p[..]
&& let Ok(tag) = self.data_of(&super::data::DataRef::Block([x, y, z]))
{
sources.push(tag);
}
}
let Ok(compiled) = horizon_client::nbt_path::NbtPath::parse(path) else {
return Text::empty();
};
let plain = o.get("plain").and_then(|v| v.as_bool()) == Some(true);
let interpret = o.get("interpret").and_then(|v| v.as_bool()) == Some(true);
let mut out = Text::empty();
let mut first = true;
for data in &sources {
for tag in compiled.get(data).unwrap_or_default() {
if !first {
out.push(Text::literal(", "));
}
first = false;
let piece = if interpret {
horizon_client::scoreboard::comp_text(&horizon_client::scoreboard::tag_to_json(
&tag,
))
} else if plain {
Text::literal(horizon_client::snbt::pretty(&tag).plain())
} else {
horizon_client::snbt::pretty(&tag)
};
out.push(piece);
}
}
out
}
fn player_targets(&mut self, ctx: &Context) -> R<usize> {
// Only the local player can receive messages and titles.
@@ -31,7 +31,41 @@ impl Game<'_> {
// ---- /recipe -----------------------------------------------------------
/// Every `minecraft:` recipe that `/recipe` can give (non-special ones).
/// `Recipe.display().size()`.
fn recipe_display_count(&self, id: &str) -> i32 {
let path = self.options.resources.join(format!(
"data/minecraft/recipe/{}.json",
id.trim_start_matches("minecraft:")
));
let Some(v) = std::fs::read(path)
.ok()
.and_then(|b| serde_json::from_slice::<serde_json::Value>(&b).ok())
else {
return 1;
};
if v["type"].as_str() != Some("minecraft:crafting_transmute") {
return 1;
}
// TransmuteRecipe: material_count defaults to exactly 1; open
// bounds are 1 and 8.
let (min, max) = match &v["material_count"] {
serde_json::Value::Null => (1, 1),
serde_json::Value::Number(n) => {
let n = n.as_i64().unwrap_or(1);
(n, n)
}
b => (
b["min"].as_i64().unwrap_or(1),
b["max"].as_i64().unwrap_or(8),
),
};
(max - min + 1).max(0) as i32
}
pub(super) fn learnable_recipes(&self) -> Vec<String> {
// RecipeManager's learnable (non-special) recipes, as exported.
if !self.ui.registries.learnable_recipes.is_empty() {
return self.ui.registries.learnable_recipes.clone();
}
let dir = self.options.resources.join("data/minecraft/recipe");
let mut out = Vec::new();
let Ok(entries) = std::fs::read_dir(&dir) else {
@@ -72,14 +106,27 @@ impl Game<'_> {
let mut tracker = Tracker::default();
for &t in &targets {
let h = holder(self.target_name(t));
// ServerRecipeBook.addRecipes/removeRecipes count recipe book
// displays (a transmute recipe has one per material count).
let mut n = 0;
let mut unlocked = Vec::new();
for r in &recipes {
let changed = if give {
self.adv.recipes.insert(r.clone())
} else {
self.adv.recipes.remove(r)
};
n += i32::from(changed);
if changed {
n += self.recipe_display_count(r);
if give {
unlocked.push(r.clone());
}
}
}
for r in unlocked {
self.trigger("minecraft:recipe_unlocked", |c, _| {
c["recipes"].as_str() == Some(r.as_str())
});
}
tracker.track(&h, n);
}
@@ -254,6 +301,8 @@ impl Game<'_> {
m.ai.swing_time = -1;
}
}
// An armor stand is a LivingEntity: it swings (invisibly).
Target::Stand(_) => {}
_ => continue,
}
let h = holder(self.target_name(t));
@@ -490,6 +539,27 @@ impl Game<'_> {
Some(Arg::Int(c)) => *c,
_ => 0,
};
// ParticleCommand.sendParticles: the viewers it reached, each within
// 32 blocks (512 with `force`) of the particle's block centre.
let viewers = if ctx.get("viewers").is_some() {
self.entities(ctx, "viewers", true)?
} else {
vec![Target::Player]
};
let limit = if ctx.has("force") { 512.0 } else { 32.0 };
let reached = viewers
.iter()
.filter(|&&t| {
self.target_position(t).is_some_and(|p| {
let c = p.map(|v| v.floor() + 0.5);
(c[0] - pos[0]).powi(2) + (c[1] - pos[1]).powi(2) + (c[2] - pos[2]).powi(2)
< limit * limit
})
})
.count() as i32;
if reached == 0 {
return Err(err("commands.particle.failed", &[]));
}
// `ServerLevel.sendParticles`: no count means one particle with the delta as velocity.
if count <= 0 {
self.particles.create(&options, pos, delta);
@@ -513,7 +583,7 @@ impl Game<'_> {
"commands.particle.success",
&[Text::literal(name.to_owned())],
));
Ok(count.max(1))
Ok(reached)
}
// ---- /attribute ---------------------------------------------------------------------
@@ -623,9 +693,13 @@ impl Game<'_> {
.has_modifier(Some(key), &modifier_id)
.unwrap_or(false)
{
return Err(err(
return Err(text_error(
"commands.attribute.failed.modifier_already_present",
&[&modifier_id, &description.plain(), &name.plain()],
&[
Text::literal(modifier_id.clone()),
description.clone(),
name.clone(),
],
));
}
let op = ctx
@@ -648,9 +722,13 @@ impl Game<'_> {
.has_modifier(Some(key), &modifier_id)
.unwrap_or(false)
{
return Err(err(
return Err(text_error(
"commands.attribute.failed.no_modifier",
&[&description.plain(), &name.plain(), &modifier_id],
&[
description.clone(),
name.clone(),
Text::literal(modifier_id.clone()),
],
));
}
let _ =
@@ -678,9 +756,13 @@ impl Game<'_> {
.ok()
.flatten();
let Some(v) = found else {
return Err(err(
return Err(text_error(
"commands.attribute.failed.no_modifier",
&[&description.plain(), &name.plain(), &modifier_id],
&[
description.clone(),
name.clone(),
Text::literal(modifier_id.clone()),
],
));
};
self.feedback(Text::translate(
@@ -696,6 +778,26 @@ impl Game<'_> {
}
}
}
Target::Mob(_) | Target::Stand(_)
if !(matches!(target, Target::Mob(_))
&& matches!(
short.as_str(),
"max_health" | "movement_speed" | "attack_damage"
)) =>
{
let op = ctx
.literals
.last()
.cloned()
.unwrap_or_else(|| "add_value".into());
self.generic_attribute(
target,
id,
&attribute,
(&name, &description),
(value_arg, scale, &modifier_id, &op),
)
}
Target::Mob(mob_id) => {
let Some(m) = self.mobs.iter_mut().find(|m| m.id == mob_id) else {
return Ok(0);
@@ -755,16 +857,177 @@ impl Game<'_> {
));
Ok(1)
}
_ => Err(err(
_ => Err(text_error(
"commands.attribute.failed.no_modifier",
&[&description.plain(), &name.plain(), &modifier_id],
&[
description.clone(),
name.clone(),
Text::literal(modifier_id.clone()),
],
)),
}
}
_ => Err(err("commands.attribute.failed.entity", &[&name.plain()])),
_ => Err(text_error(
"commands.attribute.failed.entity",
std::slice::from_ref(&name),
)),
}
}
/// The attribute map of a living entity whose attributes Horizon does
/// not model, created from its type's defaults on first use.
pub(in crate::game) fn generic_attributes(
&mut self,
t: Target,
) -> Option<&mut horizon_world::attributes::entity::EntityAttributes> {
if !self.cmds.attributes.contains_key(&t) {
let ty = self.target_type(t);
let map = self.motion.attributes.create(&ty)?;
self.cmds.attributes.insert(t, map);
}
self.cmds.attributes.get_mut(&t)
}
/// AttributeCommand on a living entity through its generic attribute map.
fn generic_attribute(
&mut self,
target: Target,
id: &str,
attribute: &str,
(name, description): (&Text, &Text),
(value_arg, scale, modifier_id, op): (f64, f64, &str, &str),
) -> R<i32> {
use horizon_world::attributes::{Modifier, Operation};
let no_attribute = || {
text_error(
"commands.attribute.failed.no_attribute",
&[name.clone(), description.clone()],
)
};
let no_modifier = || {
text_error(
"commands.attribute.failed.no_modifier",
&[
description.clone(),
name.clone(),
Text::literal(modifier_id),
],
)
};
let catalog = self.motion.attributes.clone();
let key = catalog.id(attribute).ok_or_else(no_attribute)?;
let map = self.generic_attributes(target).ok_or_else(no_attribute)?;
if !map.has(key) {
return Err(no_attribute());
}
let (message, args, result) = match id {
"attribute.get" | "attribute.base.get" => {
let v = if id == "attribute.get" {
map.value(key).map_err(|_| no_attribute())?
} else {
map.base_value(key).map_err(|_| no_attribute())?
};
let k = if id == "attribute.get" {
"commands.attribute.value.get.success"
} else {
"commands.attribute.base_value.get.success"
};
(
k,
vec![description.clone(), name.clone(), java_double_text(v)],
(v * scale) as i32,
)
}
"attribute.base.set" => {
map.edit(key, |a, o| {
let _ = a.set_base_value(value_arg, o);
});
(
"commands.attribute.base_value.set.success",
vec![
description.clone(),
name.clone(),
java_double_text(value_arg),
],
1,
)
}
"attribute.base.reset" => {
map.reset_base(key);
let v = map.base_value(key).unwrap_or(0.0);
(
"commands.attribute.base_value.reset.success",
vec![description.clone(), name.clone(), java_double_text(v)],
1,
)
}
"attribute.modifier.add" => {
if map.has_modifier(key, modifier_id) {
return Err(text_error(
"commands.attribute.failed.modifier_already_present",
&[
Text::literal(modifier_id),
description.clone(),
name.clone(),
],
));
}
let operation = match op {
"add_multiplied_base" => Operation::AddMultipliedBase,
"add_multiplied_total" => Operation::AddMultipliedTotal,
_ => Operation::AddValue,
};
let m =
Modifier::new(modifier_id, value_arg, operation).map_err(|_| no_attribute())?;
map.edit(key, |a, o| {
let _ = a.add_permanent(m, o);
});
(
"commands.attribute.modifier.add.success",
vec![
Text::literal(modifier_id),
description.clone(),
name.clone(),
],
1,
)
}
"attribute.modifier.remove" => {
if !map.has_modifier(key, modifier_id) {
return Err(no_modifier());
}
map.edit(key, |a, o| {
let _ = a.remove(modifier_id, o);
});
(
"commands.attribute.modifier.remove.success",
vec![
Text::literal(modifier_id),
description.clone(),
name.clone(),
],
1,
)
}
_ => {
let v = map
.modifier_value(key, modifier_id)
.map_err(|_| no_modifier())?;
(
"commands.attribute.modifier.value.get.success",
vec![
Text::literal(modifier_id),
description.clone(),
name.clone(),
java_double_text(v),
],
(v * scale) as i32,
)
}
};
self.feedback(Text::translate(message, &args));
Ok(result)
}
// ---- /ride ----------------------------------------------------------------------------
pub(super) fn cmd_ride(&mut self, id: &str, ctx: &Context) -> R<i32> {
@@ -864,145 +1127,232 @@ impl Game<'_> {
if targets.is_empty() {
return Err(err("argument.entity.notfound.entity", &[]));
}
// Units: each entity, or each team together with `respectTeams`.
let mut units: Vec<Vec<Target>> = Vec::new();
let mut teams: Vec<(String, usize)> = Vec::new();
for &t in &targets {
let team = if respect {
self.holder_name(t)
.and_then(|h| self.score.board.players_team(&h).map(|x| x.name.clone()))
} else {
None
};
match team {
Some(name) => match teams.iter().find(|(n, _)| *n == name) {
Some((_, i)) => units[*i].push(t),
None => {
teams.push((name, units.len()));
units.push(vec![t]);
}
},
None => units.push(vec![t]),
// SpreadPlayersCommand: one position per entity, or per team (every
// non-player and team-less player sharing one) with respectTeams.
let team_of = |g: &mut Self, t: Target| -> Option<String> {
if t != Target::Player {
return None;
}
g.holder_name(t)
.and_then(|h| g.score.board.players_team(&h).map(|x| x.name.clone()))
};
let count = if respect {
let mut seen: Vec<Option<String>> = Vec::new();
for &t in &targets {
let team = team_of(self, t);
if !seen.contains(&team) {
seen.push(team);
}
}
seen.len()
} else {
targets.len()
};
let centre_f = [centre[0] as f32, centre[2] as f32];
let (cx, cz) = (f64::from(centre_f[0]), f64::from(centre_f[1]));
let (min_x, max_x) = (cx - range, cx + range);
let (min_z, max_z) = (cz - range, cz + range);
// Mth.nextDouble.
let next = |g: &mut Self, lo: f64, hi: f64| {
if lo >= hi {
lo
} else {
g.world.random.next_double() * (hi - lo) + lo
}
};
let mut points: Vec<[f64; 2]> = Vec::with_capacity(count);
for _ in 0..count {
let x = next(self, min_x, max_x);
let z = next(self, min_z, max_z);
points.push([x, z]);
}
let (min_x, max_x) = (centre[0] - range, centre[0] + range);
let (min_z, max_z) = (centre[2] - range, centre[2] + range);
let mut points: Vec<[f64; 2]> = units
.iter()
.map(|_| {
let r = &mut self.world.random;
[
min_x + r.next_double() * (max_x - min_x),
min_z + r.next_double() * (max_z - min_z),
]
})
.collect();
let n = points.len();
let mut ok = false;
for _ in 0..10_000 {
let mut moved = false;
let mut crowded = 0;
for i in 0..n {
let mut push = [0.0, 0.0];
let mut near = 0;
for j in 0..n {
let mut collisions = true;
let mut min_distance = f64::from(f32::MAX);
let mut iteration = 0;
while iteration < 10_000 && collisions {
collisions = false;
min_distance = f64::from(f32::MAX);
for i in 0..points.len() {
let mut neighbours = 0;
let mut avg = [0.0f64, 0.0f64];
for j in 0..points.len() {
if i == j {
continue;
}
let (dx, dz) = (points[j][0] - points[i][0], points[j][1] - points[i][1]);
let d = (dx * dx + dz * dz).sqrt();
if d < spread {
near += 1;
if d > 1.0e-6 {
push[0] -= dx / d;
push[1] -= dz / d;
} else {
let r = &mut self.world.random;
push[0] += r.next_double() - 0.5;
push[1] += r.next_double() - 0.5;
}
let (dx, dz) = (points[i][0] - points[j][0], points[i][1] - points[j][1]);
let dist = (dx * dx + dz * dz).sqrt();
min_distance = min_distance.min(dist);
if dist < spread {
neighbours += 1;
avg[0] += points[j][0] - points[i][0];
avg[1] += points[j][1] - points[i][1];
}
}
if near > 0 {
crowded += 1;
let len = (push[0] * push[0] + push[1] * push[1]).sqrt().max(1.0e-6);
points[i][0] += push[0] / len;
points[i][1] += push[1] / len;
moved = true;
if neighbours > 0 {
avg[0] /= f64::from(neighbours);
avg[1] /= f64::from(neighbours);
let length = (avg[0] * avg[0] + avg[1] * avg[1]).sqrt();
if length > 0.0 {
points[i][0] -= avg[0] / length;
points[i][1] -= avg[1] / length;
} else {
points[i][0] = next(self, min_x, max_x);
points[i][1] = next(self, min_z, max_z);
}
collisions = true;
}
let p = &mut points[i];
let before = *p;
p[0] = if p[0] < min_x {
min_x
} else if p[0] > max_x {
max_x
} else {
p[0]
};
p[1] = if p[1] < min_z {
min_z
} else if p[1] > max_z {
max_z
} else {
p[1]
};
if before != *p {
collisions = true;
}
let before = points[i];
points[i][0] = points[i][0].clamp(min_x, max_x);
points[i][1] = points[i][1].clamp(min_z, max_z);
moved |= before != points[i];
}
if !moved || crowded == 0 {
ok = true;
break;
if !collisions {
for i in 0..points.len() {
if !self.spread_safe(points[i], max_y) {
points[i][0] = next(self, min_x, max_x);
points[i][1] = next(self, min_z, max_z);
collisions = true;
}
}
}
iteration += 1;
}
if !ok {
let key = if teams.is_empty() {
"commands.spreadplayers.failed.entities"
} else {
if min_distance == f64::from(f32::MAX) {
min_distance = 0.0;
}
let float = |v: f32| Text::literal(horizon_client::snbt::java_float(v));
if iteration >= 10_000 {
let key = if respect {
"commands.spreadplayers.failed.teams"
} else {
"commands.spreadplayers.failed.entities"
};
return Err(err(
return Err(text_error(
key,
&[
&n,
&format!("{:.2}", centre[0]),
&format!("{:.2}", centre[2]),
&format!("{:.2}", spread),
num(points.len()),
float(centre_f[0]),
float(centre_f[1]),
Text::literal(format!("{min_distance:.2}")),
],
));
}
// Stand each unit on the ground under `max_y`.
// setPlayerPositions.
let mut total = 0.0;
for (unit, p) in units.iter().zip(&points) {
let (bx, bz) = (p[0].floor() as i32, p[1].floor() as i32);
let mut y = None;
for yy in (horizon_client::chunk::MIN_Y
..max_y.min(horizon_client::chunk::MIN_Y + horizon_client::chunk::HEIGHT))
.rev()
{
let solid = |dy: i32| {
self.res
.facts
.get(self.world.block(bx, yy + dy, bz))
.full_collision
};
if solid(-1) && !solid(0) && !solid(1) {
y = Some(yy);
break;
let mut index = 0;
let mut team_points: Vec<(Option<String>, usize)> = Vec::new();
for &t in &targets {
let i = if respect {
let team = team_of(self, t);
match team_points.iter().find(|(k, _)| *k == team) {
Some((_, i)) => *i,
None => {
team_points.push((team, index));
index += 1;
index - 1
}
}
}
let y = y.unwrap_or(max_y);
for &t in unit {
self.teleport_to(
t,
[f64::from(bx) + 0.5, f64::from(y), f64::from(bz) + 0.5],
None,
);
}
let (dx, dz) = (p[0] - centre[0], p[1] - centre[2]);
total += (dx * dx + dz * dz).sqrt();
} else {
index += 1;
index - 1
};
let p = points[i];
let y = self.spread_spawn_y(p, max_y);
self.teleport_to(
t,
[p[0].floor() + 0.5, f64::from(y), p[1].floor() + 0.5],
None,
);
let closest = points
.iter()
.enumerate()
.filter(|(j, _)| *j != i)
.map(|(_, q)| ((p[0] - q[0]).powi(2) + (p[1] - q[1]).powi(2)).sqrt())
.fold(f64::MAX, f64::min);
total += closest;
}
let average = if n == 0 { 0.0 } else { total / n as f64 };
let key = if teams.is_empty() {
"commands.spreadplayers.success.entities"
let average = if targets.len() < 2 {
0.0
} else {
total / targets.len() as f64
};
let key = if respect {
"commands.spreadplayers.success.teams"
} else {
"commands.spreadplayers.success.entities"
};
self.feedback(Text::translate(
key,
&[
num(n),
Text::literal(format!("{:.2}", centre[0])),
Text::literal(format!("{:.2}", centre[2])),
num(points.len()),
float(centre_f[0]),
float(centre_f[1]),
Text::literal(format!("{average:.2}")),
],
));
Ok(n as i32)
Ok(points.len() as i32)
}
/// `SpreadPlayersCommand.Position.getSpawnY`.
fn spread_spawn_y(&self, p: [f64; 2], max_y: i32) -> i32 {
let (x, z) = (p[0].floor() as i32, p[1].floor() as i32);
let air = |y: i32| {
let name: &str = &self.res.facts.get(self.world.block(x, y, z)).name;
matches!(
name,
"minecraft:air" | "minecraft:cave_air" | "minecraft:void_air"
)
};
let mut y = max_y + 1;
let mut air2 = air(y);
y -= 1;
let mut air1 = air(y);
while y > horizon_client::chunk::MIN_Y {
y -= 1;
let current = air(y);
if !current && air1 && air2 {
return y + 1;
}
air2 = air1;
air1 = current;
}
max_y + 1
}
/// `SpreadPlayersCommand.Position.isSafe`.
fn spread_safe(&self, p: [f64; 2], max_y: i32) -> bool {
let y = self.spread_spawn_y(p, max_y) - 1;
let (x, z) = (p[0].floor() as i32, p[1].floor() as i32);
let name = self.res.facts.get(self.world.block(x, y, z)).name.clone();
let liquid = matches!(&*name, "minecraft:water" | "minecraft:lava");
let teleportable = self
.res
.items
.block_tags
.get("entities_can_teleport_to")
.or_else(|| {
self.res
.items
.block_tags
.get("minecraft:entities_can_teleport_to")
})
.is_some_and(|set| {
set.contains(&*name) || set.contains(name.trim_start_matches("minecraft:"))
});
y < max_y && !liquid && teleportable
}
}
+2 -1
View File
@@ -818,11 +818,12 @@ impl Game<'_> {
let old = self.world.block(pos[0], pos[1], pos[2]);
self.destroy_particles(pos, old);
if drop {
let drops = self.res.items.block_drops(
let drops = self.res.items.block_drops_in(
self.res.assets.registry,
old,
None,
&mut self.world.random,
Some((&mut self.rand_sequences, self.level.seed)),
);
for d in drops {
self.pop_resource(pos, d);
+2 -1
View File
@@ -391,11 +391,12 @@ impl Game<'_> {
let name = self.res.facts.get(state).name.clone();
let is_tnt = &*name == "minecraft:tnt";
if !is_tnt {
let drops = self.res.items.block_drops(
let drops = self.res.items.block_drops_in(
self.res.assets.registry,
state,
None,
&mut self.world.random,
Some((&mut self.rand_sequences, self.level.seed)),
);
for stack in drops {
if &*stack.item == "minecraft:air" || stack.count == 0 {
+113 -61
View File
@@ -94,11 +94,17 @@ impl Game<'_> {
}
}
fn rebuild_store(&mut self) {
let packs: Vec<&DataPack> = self
.fns
.enabled
.iter()
.filter_map(|id| self.fns.packs.iter().find(|p| &p.id == id))
// The built-in pack first (lowest priority), unless disabled.
let vanilla = DataPack::builtin(&self.options.resources);
let packs: Vec<&DataPack> = (!self.cmds.vanilla_disabled)
.then_some(&vanilla)
.into_iter()
.chain(
self.fns
.enabled
.iter()
.filter_map(|id| self.fns.packs.iter().find(|p| &p.id == id)),
)
.collect();
let store = DataStore::load(&packs);
for (id, e) in &store.errors {
@@ -298,9 +304,10 @@ impl Game<'_> {
pub(in crate::game) fn functions_named(&mut self, name: &str) -> R<Vec<Function>> {
self.ensure_datapacks();
match name.strip_prefix('#') {
// ServerFunctionLibrary.getTag: an unknown tag is empty.
Some(tag) => {
if !self.fns.store.function_tags.contains_key(tag) {
return Err(err("arguments.function.tag.unknown", &[&tag]));
return Ok(Vec::new());
}
Ok(self
.fns
@@ -347,7 +354,8 @@ impl Game<'_> {
};
let functions = self.functions_named(&name)?;
if functions.is_empty() {
return Err(err("commands.function.scheduled.no_functions", &[&name]));
let id = name.trim_start_matches('#');
return Err(err("commands.function.scheduled.no_functions", &[&id]));
}
let args = if ctx.has("with") {
let r = self.data_ref_named(ctx, 0, "source")?;
@@ -470,12 +478,8 @@ impl Game<'_> {
let replace = !ctx.has("append");
let tick_time = self.world.game_time + i64::from(time);
let schedule_id = match name.strip_prefix('#') {
Some(tag) => {
if !self.fns.store.function_tags.contains_key(tag) {
return Err(err("arguments.function.tag.unknown", &[&tag]));
}
name.clone()
}
// An unknown tag is empty, and scheduling it is allowed.
Some(_) => name.clone(),
None => {
let Some(f) = self.fns.store.functions.get(&name) else {
return Err(err("arguments.function.unknown", &[&name]));
@@ -519,11 +523,14 @@ impl Game<'_> {
self.sync_function_registries();
Ok((tick_time.rem_euclid(i64::from(i32::MAX))) as i32)
}
/// ReloadCommand: the message, then the (asynchronous) reload; returns 0.
pub(super) fn cmd_reload(&mut self) -> R<i32> {
self.reload_datapacks(true);
self.feedback(Text::translate("commands.reload.success", &[]));
Ok(1)
self.reload_datapacks(true);
Ok(0)
}
/// `PackLocationInfo.createChatLink`: the id decorated with its source
/// (`pack.nameAndSource`, grey) in brackets, green when enabled.
fn pack_link(&self, id: &str, enabled: bool) -> Text {
let hint = if enabled { "disable" } else { "enable" };
let style = text::Style {
@@ -541,7 +548,27 @@ impl Game<'_> {
hover: Some(Box::new(Text::literal(format!("{id}\n{description}")))),
..style
};
bracketed(Text::literal(id).with_style(&style))
let source = if id == "vanilla" {
"pack.source.builtin"
} else if FEATURE_PACKS.iter().any(|(p, _)| *p == id) {
"pack.source.feature"
} else {
"pack.source.world"
};
let name = Text::translate(
"pack.nameAndSource",
&[Text::literal(id), Text::translate(source, &[])],
)
.with_color(text::GRAY);
bracketed(name).with_style(&style)
}
/// The selected packs, lowest priority first.
fn selected_packs(&self) -> Vec<String> {
let vanilla = (!self.cmds.vanilla_disabled).then(|| "vanilla".to_owned());
vanilla
.into_iter()
.chain(self.fns.enabled.iter().cloned())
.collect()
}
pub(super) fn cmd_datapack(&mut self, id: &str, ctx: &Context) -> R<i32> {
self.ensure_datapacks();
@@ -549,34 +576,37 @@ impl Game<'_> {
Some(Arg::Str(n)) => Some(n.clone()),
_ => None,
};
let enabled_ids: Vec<String> = std::iter::once("vanilla".to_owned())
.chain(self.fns.enabled.iter().cloned())
.collect();
let available: Vec<String> = self
.fns
.packs
.iter()
.map(|p| p.id.clone())
.filter(|p| !enabled_ids.contains(p))
let selected = self.selected_packs();
// Feature packs need features this world lacks: never available.
let available: Vec<String> = std::iter::once("vanilla".to_owned())
.chain(self.fns.packs.iter().map(|p| p.id.clone()))
.filter(|p| !selected.contains(p))
.collect();
let known = |g: &Self, n: &str| {
n == "vanilla"
|| FEATURE_PACKS.iter().any(|(p, _)| *p == n)
|| g.fns.packs.iter().any(|p| p.id == n)
};
match id {
"datapack.list" => {
let want_enabled = ctx.has("enabled") || (!ctx.has("available"));
let want_available = ctx.has("available") || (!ctx.has("enabled"));
let mut total = 0;
if want_enabled {
let links: Vec<Text> = enabled_ids
.iter()
.map(|p| self.pack_link(p, true))
.collect();
total += links.len();
self.feedback(Text::translate(
"commands.datapack.list.enabled.success",
&[
Text::literal(links.len().to_string()),
horizon_client::scoreboard_cmd::format_list(links),
],
));
if selected.is_empty() {
self.feedback(Text::translate("commands.datapack.list.enabled.none", &[]));
} else {
let links: Vec<Text> =
selected.iter().map(|p| self.pack_link(p, true)).collect();
total += links.len();
self.feedback(Text::translate(
"commands.datapack.list.enabled.success",
&[
Text::literal(links.len().to_string()),
horizon_client::scoreboard_cmd::format_list(links),
],
));
}
}
if want_available {
if available.is_empty() {
@@ -601,57 +631,71 @@ impl Game<'_> {
}
"datapack.enable" => {
let name = name.unwrap_or_default();
if !self.fns.packs.iter().any(|p| p.id == name) && name != "vanilla" {
if !known(self, &name) {
return Err(err("commands.datapack.unknown", &[&name]));
}
if enabled_ids.contains(&name) {
if selected.contains(&name) {
return Err(err("commands.datapack.enable.failed", &[&name]));
}
let existing = match ctx.get("existing") {
Some(Arg::Str(e)) => Some(e.clone()),
_ => None,
};
let position = if ctx.has("first") {
0
} else if let Some(e) = &existing {
let Some(i) = self.fns.enabled.iter().position(|p| p == e) else {
return Err(err("commands.datapack.unknown", &[e]));
};
if ctx.has("before") { i } else { i + 1 }
if let Some((_, flag)) = FEATURE_PACKS.iter().find(|(p, _)| *p == name) {
return Err(err(
"commands.datapack.enable.failed.no_flags",
&[&name, flag],
));
}
if name == "vanilla" {
self.cmds.vanilla_disabled = false;
} else {
self.fns.enabled.len()
};
self.fns.enabled.insert(position, name.clone());
let existing = match ctx.get("existing") {
Some(Arg::Str(e)) => Some(e.clone()),
_ => None,
};
let position = if ctx.has("first") {
0
} else if let Some(e) = &existing {
let Some(i) = self.fns.enabled.iter().position(|p| p == e) else {
return Err(err("commands.datapack.unknown", &[e]));
};
if ctx.has("before") { i } else { i + 1 }
} else {
self.fns.enabled.len()
};
self.fns.enabled.insert(position, name.clone());
}
self.feedback(Text::translate(
"commands.datapack.modify.enable",
&[self.pack_link(&name, true)],
));
self.apply_pack_change();
Ok(self.fns.enabled.len() as i32)
Ok(self.selected_packs().len() as i32)
}
_ => {
let name = name.unwrap_or_default();
if !self.fns.packs.iter().any(|p| p.id == name) && name != "vanilla" {
if !known(self, &name) {
return Err(err("commands.datapack.unknown", &[&name]));
}
let Some(i) = self.fns.enabled.iter().position(|p| p == &name) else {
if !selected.contains(&name) {
return Err(err("commands.datapack.disable.failed", &[&name]));
};
self.fns.enabled.remove(i);
}
if name == "vanilla" {
self.cmds.vanilla_disabled = true;
} else {
self.fns.enabled.retain(|p| p != &name);
}
self.feedback(Text::translate(
"commands.datapack.modify.disable",
&[self.pack_link(&name, false)],
&[self.pack_link(&name, true)],
));
self.apply_pack_change();
Ok(self.fns.enabled.len() as i32)
Ok(self.selected_packs().len() as i32)
}
}
}
/// `ReloadCommand.reloadPacks`: no message of its own.
fn apply_pack_change(&mut self) {
self.save_datapack_settings();
self.rebuild_store();
self.fns.load_pending = true;
self.feedback(Text::translate("commands.reload.success", &[]));
}
// ---- predicates -------------------------------------------------------------------
@@ -667,3 +711,11 @@ impl Game<'_> {
Ok(self.conditions_hold(&json, view.as_ref(), source.pos))
}
}
/// The built-in feature packs and the feature flag each needs (none of them
/// enabled in a world created without experiments).
const FEATURE_PACKS: &[(&str, &str)] = &[
("minecart_improvements", "minecraft:minecart_improvements"),
("redstone_experiments", "minecraft:redstone_experiments"),
("trade_rebalance", "minecraft:trade_rebalance"),
];
@@ -33,6 +33,11 @@ impl Game<'_> {
let was_spectator = self.spectator();
self.mode = mode;
self.creative = mode == GameMode::Creative;
// GameType.updatePlayerAbilities applies at once.
if let Some(p) = self.player.as_mut() {
p.invulnerable = mode == GameMode::Creative || mode == GameMode::Spectator;
p.may_fly = p.invulnerable;
}
if mode == GameMode::Spectator {
self.mining = None;
self.using = None;
+10 -4
View File
@@ -332,6 +332,16 @@ impl Game<'_> {
}
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);
self.system_message(Text::translate(
"menu.multiplayerOptions.publish.started.lan",
&[Text::literal(port.to_string())],
));
Ok(())
}
/// IntegratedServer.publishServer without the screen's announcement.
pub(super) fn lan_start(&mut self, settings: LanSettings) -> Result<()> {
if self.lan.is_some() || self.remote.is_some() || self.title.is_some() {
return Err("already open".into());
}
@@ -407,10 +417,6 @@ impl Game<'_> {
mob_state: HashMap::new(),
});
self.audio.capture = Some(Vec::new());
self.system_message(Text::translate(
"menu.multiplayerOptions.publish.started.lan",
&[Text::literal(port.to_string())],
));
Ok(())
}
@@ -525,7 +525,12 @@ impl Game<'_> {
let lines = self.as_guest(host, conn, |g| {
g.chat_capture = Some(Vec::new());
g.run_command(&command);
g.chat_capture.take().unwrap_or_default()
g.chat_capture
.take()
.unwrap_or_default()
.iter()
.map(horizon_client::text::Text::plain)
.collect::<Vec<String>>()
});
for line in lines.unwrap_or_default() {
host.hub.send_to(
@@ -551,7 +556,7 @@ impl Game<'_> {
};
let skip = usize::from(text.starts_with('/'));
let command = &text[skip..];
let d = vanilla::dispatcher();
let d = vanilla::game_dispatcher();
let level = std::mem::replace(&mut self.ui.registries.permission, permission);
let parse = d.parse(command, &self.ui.registries);
let ((start, end), suggestions) = d.suggestions(&parse, command.len(), &self.ui.registries);
+1 -1
View File
@@ -241,7 +241,7 @@ impl Game<'_> {
}
if o.parsed_port().is_none() {
let t = Text::translate(
"lanServer.port.invalid.new",
"lanServer.port.invalid",
&[Text::literal("1024"), Text::literal("65535")],
);
let first = t.clone();
+83
View File
@@ -284,6 +284,9 @@ impl Game<'_> {
_ if self.res.mob_types.contains_key(&kind) => {
self.load_mob(tag, None);
}
_ if !kind.is_empty() && entity_nbt::position(&tag).is_some() => {
self.load_other(tag, &kind);
}
_ => self.persist.unknown.entry(key).or_default().push(tag),
}
}
@@ -356,6 +359,62 @@ impl Game<'_> {
}
Some(id)
}
/// An entity of a type Horizon does not simulate, kept as its compound.
fn load_other(&mut self, tag: Tag, kind: &str) -> Option<u32> {
let position = entity_nbt::position(&tag)?;
let rotation = match tag.get("Rotation") {
Some(Tag::List(l)) => {
let f = |i: usize| match l.get(i) {
Some(Tag::Float(v)) => f32::from_bits(*v),
_ => 0.0,
};
[f(0), f(1)]
}
_ => [0.0, 0.0],
};
self.next_entity += 1;
let id = self.next_entity;
let uuid = entity_nbt::uuid(&tag);
self.remember(id, uuid, tag);
self.others.push(super::commands::OtherEntity {
id,
kind: kind.to_owned(),
position,
yaw: rotation[0],
pitch: rotation[1],
});
Some(id)
}
/// The compound of an entity Horizon does not simulate, with its current
/// position, rotation and UUID.
pub(super) fn other_to_nbt(&self, o: &super::commands::OtherEntity, uuid: [i32; 4]) -> Tag {
let mut tag = self
.persist
.raw
.get(&o.id)
.cloned()
.unwrap_or_else(|| Tag::Compound(Default::default()));
if let Tag::Compound(c) = &mut tag {
c.insert("id".into(), Tag::String(o.kind.as_str().into()));
c.insert(
"Pos".into(),
Tag::List(
[o.position.x, o.position.y, o.position.z]
.map(|v| Tag::Double(v.to_bits()))
.to_vec(),
),
);
c.insert(
"Rotation".into(),
Tag::List(vec![
Tag::Float(o.yaw.to_bits()),
Tag::Float(o.pitch.to_bits()),
]),
);
c.insert("UUID".into(), Tag::IntArray(uuid.to_vec()));
}
tag
}
/// The root of a stack of riders (`Entity.getRootVehicle`).
fn mob_root(&self, mut i: usize) -> usize {
for _ in 0..8 {
@@ -393,6 +452,10 @@ impl Game<'_> {
}
tag
}
/// The compound an entity was loaded with (and commands have edited).
pub(super) fn persist_raw(&self, id: u32) -> Option<&Tag> {
self.persist.raw.get(&id)
}
fn remember(&mut self, id: u32, uuid: Option<[i32; 4]>, tag: Tag) {
if let Some(u) = uuid {
self.persist.uuids.insert(id, u);
@@ -627,6 +690,18 @@ impl Game<'_> {
out.entry(chunk_of(at)).or_default().push(tag);
}
}
for o in &self.others {
if keys.contains(&chunk_of(o.position)) {
let uuid = self
.persist
.uuids
.get(&o.id)
.copied()
.unwrap_or_else(random_uuid);
let tag = self.other_to_nbt(o, uuid);
out.entry(chunk_of(o.position)).or_default().push(tag);
}
}
for key in keys {
let unknown = if remove {
self.persist.unknown.remove(key)
@@ -659,6 +734,13 @@ impl Game<'_> {
}
keep
});
self.others.retain(|o| {
let keep = !gone(o.position);
if !keep {
removed.push(o.id);
}
keep
});
self.armor_stands.retain(|a| {
let keep = !gone(a.position);
if !keep {
@@ -733,6 +815,7 @@ impl Game<'_> {
.chain(self.armor_stands.iter().map(|e| e.id))
.chain(self.item_frames.iter().map(|e| e.id))
.chain(self.paintings.iter().map(|e| e.id))
.chain(self.others.iter().map(|e| e.id))
.collect();
self.persist.uuids.retain(|id, _| alive.contains(id));
self.persist.raw.retain(|id, _| alive.contains(id));
+9 -2
View File
@@ -167,9 +167,16 @@ impl Game<'_> {
/// `Entity.getTags` (the `Tags` list of the saved entity).
pub(super) fn tags_of(&self, t: Target) -> Vec<String> {
let raw = match t {
Target::Mob(id) | Target::Item(id) => self.persist.raw.get(&id),
Target::Mob(id)
| Target::Item(id)
| Target::Stand(id)
| Target::Frame(id)
| Target::Painting(id)
| Target::Boat(id)
| Target::Cart(id)
| Target::Other(id) => self.persist.raw.get(&id),
Target::Player => self.level.player_extra.as_ref(),
_ => None,
Target::Orb(_) | Target::Arrow(_) => None,
};
match raw.and_then(|r| r.get("Tags")) {
Some(Tag::List(l)) => l
+69 -1
View File
@@ -56,6 +56,48 @@ pub struct StackData {
pub stew_effects: Vec<(Arc<str>, i32)>,
/// `minecraft:map_post_processing`: 0 lock, 1 scale.
pub map_post_processing: Option<u8>,
/// Components Horizon does not model (lore, custom data, item name,
/// max stack size...), kept as their saved values in key order.
pub other: Vec<(String, Tag)>,
}
/// The components `components_tag` writes from modelled fields.
const MODELLED: &[&str] = &[
"minecraft:banner_patterns",
"minecraft:base_color",
"minecraft:bundle_contents",
"minecraft:charged_projectiles",
"minecraft:container",
"minecraft:custom_name",
"minecraft:damage",
"minecraft:dyed_color",
"minecraft:enchantments",
"minecraft:firework_explosion",
"minecraft:fireworks",
"minecraft:map_id",
"minecraft:map_post_processing",
"minecraft:ominous_bottle_amplifier",
"minecraft:pot_decorations",
"minecraft:potion_contents",
"minecraft:repair_cost",
"minecraft:stored_enchantments",
"minecraft:suspicious_stew_effects",
"minecraft:trim",
"minecraft:writable_book_content",
"minecraft:written_book_content",
];
impl StackData {
/// An unmodelled component's saved value.
pub fn other(&self, id: &str) -> Option<&Tag> {
self.other.iter().find(|(k, _)| k == id).map(|(_, v)| v)
}
/// Set (or with None remove) an unmodelled component.
pub fn set_other(&mut self, id: &str, value: Option<Tag>) {
self.other.retain(|(k, _)| k != id);
if let Some(v) = value {
self.other.push((id.to_owned(), v));
self.other.sort_by(|a, b| a.0.cmp(&b.0));
}
}
}
/// `Raid.getBannerComponentPatch`: the ominous banner's pattern layers.
pub const OMINOUS_LAYERS: [(&str, &str); 8] = [
@@ -596,7 +638,17 @@ pub fn components_tag(damage: u32, data: Option<&StackData>) -> Option<Tag> {
entries.push(("minecraft:container", Tag::List(slots)));
}
}
(!entries.is_empty()).then(|| Tag::compound(entries))
let mut out: horizon_world::nbt::Compound = entries
.into_iter()
.map(|(k, v)| (JavaString::from(k), v))
.collect();
if let Some(d) = data {
for (k, v) in &d.other {
out.entry(JavaString::from(k.as_str()))
.or_insert_with(|| v.clone());
}
}
(!out.is_empty()).then_some(Tag::Compound(out))
}
/// Damage and extra components from a stack's `components` compound.
pub fn decode_components(components: Option<&Tag>) -> (u32, Option<Box<StackData>>) {
@@ -729,7 +781,23 @@ pub fn decode_components(components: Option<&Tag>) -> (u32, Option<Box<StackData
Arc::from(t.get("pattern").and_then(string)?.as_str()),
))
}),
other: Vec::new(),
};
let mut data = data;
if let Tag::Compound(map) = c {
for (k, v) in map {
let key = k.to_string_lossy();
let ominous_part = data.ominous_banner
&& matches!(
key.as_str(),
"minecraft:item_name" | "minecraft:rarity" | "minecraft:tooltip_display"
);
if !MODELLED.contains(&key.as_str()) && !ominous_part {
data.other.push((key, v.clone()));
}
}
data.other.sort_by(|a, b| a.0.cmp(&b.0));
}
(damage, (!data.is_empty()).then(|| Box::new(data)))
}
+61 -17
View File
@@ -2,7 +2,7 @@
//! tool mining rules and block loot tables (`LootTable`/`LootPool` semantics
//! for the condition, entry and modifier types used by block drops).
use crate::{Result, blocks::BlockFacts};
use horizon_core::random::{LegacyRandom, RandomSource};
use horizon_core::random::RandomSource;
use horizon_world::registry::{BlockRegistry, BlockStateId};
use serde_json::Value;
use std::{
@@ -526,6 +526,22 @@ impl Items {
pub fn has_loot_table(&self, id: &str) -> bool {
self.loot.contains_key(id)
}
/// `LootTable.getRandomItems` of an inline table.
pub fn inline_loot_table<R: RandomSource>(
&self,
table: &Value,
random: &mut R,
) -> Vec<ItemStack> {
let empty = BTreeMap::new();
let ctx = LootContext {
items: self,
block: "",
properties: &empty,
held: None,
killed_by_player: false,
};
ctx.evaluate(table, random)
}
/// The server random sequence the block's loot table draws from.
pub fn block_loot_sequence(
&self,
@@ -541,12 +557,24 @@ impl Items {
.or_else(|| self.loot_sequence(&format!("minecraft:blocks/{standing}")))
}
/// Evaluate the block's loot table for a player break without explosions.
pub fn block_drops(
pub fn block_drops<R: RandomSource>(
&self,
registry: &BlockRegistry,
state: BlockStateId,
held: Option<&ItemStack>,
random: &mut impl RandomSource,
random: &mut R,
) -> Vec<ItemStack> {
self.block_drops_in(registry, state, held, random, None)
}
/// `block_drops` drawing from the table's random sequence when it has one
/// (`sequences`: the world's sequences and seed), as BlockState.getDrops.
pub fn block_drops_in<R: RandomSource>(
&self,
registry: &BlockRegistry,
state: BlockStateId,
held: Option<&ItemStack>,
random: &mut R,
sequences: Option<(&mut crate::random_sequences::RandomSequences, i64)>,
) -> Vec<ItemStack> {
let Some(block) = registry.state(state) else {
return vec![];
@@ -564,6 +592,21 @@ impl Items {
let Some(table) = table else {
return vec![];
};
// LootTable.getRandomItems draws from the table's random sequence.
if let (Some(seq), Some(sequences)) = (
table.get("random_sequence").and_then(Value::as_str),
sequences,
) {
let random = sequences.0.get(seq, sequences.1);
let ctx = LootContext {
items: self,
block: &block.name,
properties: &block.properties,
held,
killed_by_player: false,
};
return ctx.evaluate(table, random);
}
let ctx = LootContext {
items: self,
block: &block.name,
@@ -575,12 +618,12 @@ impl Items {
}
/// Evaluate an entity's loot table (`minecraft:entities/<name>`).
/// Evaluate any loot table by id (e.g. `minecraft:gameplay/chicken_lay`).
pub fn loot_table(
pub fn loot_table<R: RandomSource>(
&self,
id: &str,
killed_by_player: bool,
held: Option<&ItemStack>,
random: &mut LegacyRandom,
random: &mut R,
) -> Vec<ItemStack> {
let Some(table) = self.loot.get(id) else {
return vec![];
@@ -623,12 +666,12 @@ impl Items {
};
ctx.evaluate(table, random)
}
pub fn entity_drops(
pub fn entity_drops<R: RandomSource>(
&self,
entity: &str,
killed_by_player: bool,
held: Option<&ItemStack>,
random: &mut LegacyRandom,
random: &mut R,
) -> Vec<ItemStack> {
let name = entity.trim_start_matches("minecraft:");
let Some(table) = self.loot.get(&format!("minecraft:entities/{name}")) else {
@@ -646,7 +689,7 @@ impl Items {
}
}
impl LootContext<'_> {
fn evaluate(&self, table: &Value, random: &mut impl RandomSource) -> Vec<ItemStack> {
fn evaluate<R: RandomSource>(&self, table: &Value, random: &mut R) -> Vec<ItemStack> {
let ctx = self;
let mut out = Vec::new();
for pool in table["pools"].as_array().into_iter().flatten() {
@@ -686,7 +729,7 @@ impl LootContext<'_> {
fn enchantment_level(&self, id: &str) -> u32 {
self.held.map_or(0, |h| h.enchantment_level(id))
}
fn number(&self, v: &Value, random: &mut impl RandomSource) -> f32 {
fn number<R: RandomSource>(&self, v: &Value, random: &mut R) -> f32 {
match v {
Value::Number(n) => n.as_f64().unwrap_or(0.0) as f32,
Value::Object(o) => match o
@@ -717,7 +760,7 @@ impl LootContext<'_> {
_ => 1.0,
}
}
fn int_number(&self, v: &Value, random: &mut impl RandomSource) -> i32 {
fn int_number<R: RandomSource>(&self, v: &Value, random: &mut R) -> i32 {
if let Value::Object(o) = v
&& o.get("type")
.and_then(Value::as_str)
@@ -734,7 +777,7 @@ impl LootContext<'_> {
}
self.number(v, random).round() as i32
}
fn condition(&self, c: &Value, random: &mut impl RandomSource) -> bool {
fn condition<R: RandomSource>(&self, c: &Value, random: &mut R) -> bool {
let (kind, c) = match c {
Value::String(s) => (s.as_str(), &Value::Null),
Value::Object(o) => (o.get("type").and_then(Value::as_str).unwrap_or(""), c),
@@ -843,7 +886,7 @@ impl LootContext<'_> {
_ => true,
}
}
fn conditions(&self, o: &Value, random: &mut impl RandomSource) -> bool {
fn conditions<R: RandomSource>(&self, o: &Value, random: &mut R) -> bool {
if let Some(c) = o.get("condition")
&& !self.condition(c, random)
{
@@ -856,10 +899,10 @@ impl LootContext<'_> {
.all(|c| self.condition(c, random))
}
/// Expand entries; returns whether an entry succeeded (for alternatives).
fn expand(
fn expand<R: RandomSource>(
&self,
e: &Value,
random: &mut impl RandomSource,
random: &mut R,
out: &mut Vec<(i32, ItemStack, Value)>,
) -> bool {
if !self.conditions(e, random) {
@@ -917,10 +960,10 @@ impl LootContext<'_> {
_ => false,
}
}
fn choose(
fn choose<R: RandomSource>(
&self,
entries: &[Value],
random: &mut impl RandomSource,
random: &mut R,
produced: &mut Vec<ItemStack>,
) {
let mut candidates = Vec::new();
@@ -949,7 +992,7 @@ impl LootContext<'_> {
self.modifiers(&modifiers, &mut stack, random);
produced.push(stack);
}
fn modifiers(&self, m: &Value, stack: &mut ItemStack, random: &mut impl RandomSource) {
fn modifiers<R: RandomSource>(&self, m: &Value, stack: &mut ItemStack, random: &mut R) {
let list: Vec<&Value> = match m {
Value::Array(a) => a.iter().collect(),
Value::Object(_) => vec![m],
@@ -1029,6 +1072,7 @@ impl LootContext<'_> {
#[cfg(test)]
mod tests {
use super::*;
use horizon_core::random::LegacyRandom;
use serde_json::json;
fn ctx<'a>(
+32
View File
@@ -39,6 +39,30 @@ impl ResourceSource for std::path::PathBuf {
}
}
/// DeprecatedTranslationsInfo.applyToMap: drop removed keys, then move each
/// renamed key's text to its new key (a missing old key removes the new one).
pub fn apply_deprecated(map: &mut HashMap<String, String>, json: &[u8]) {
let Ok(info) = serde_json::from_slice::<serde_json::Value>(json) else {
return;
};
for key in info["removed"].as_array().into_iter().flatten() {
if let Some(k) = key.as_str() {
map.remove(k);
}
}
for (from, to) in info["renamed"].as_object().into_iter().flatten() {
let Some(to) = to.as_str() else { continue };
match map.remove(from) {
Some(value) => {
map.insert(to.to_owned(), value);
}
None => {
map.remove(to);
}
}
}
}
impl Language {
pub fn from_map(code: &str, map: HashMap<String, String>) -> Self {
Self {
@@ -64,6 +88,14 @@ impl Language {
}
}
}
// DeprecatedTranslationsInfo.loadFromDefaultResource().applyToMap: the
// game's own deprecated.json, not a resource pack's.
if let Some(bytes) = sources
.iter()
.find_map(|s| s.read("assets/minecraft/lang/deprecated.json"))
{
apply_deprecated(&mut map, &bytes);
}
Self {
code: code.to_owned(),
map,
+1
View File
@@ -39,6 +39,7 @@ pub mod enchant;
pub mod entities;
pub mod entity_nbt;
pub mod environment;
pub mod fastutil_order;
pub mod fog;
pub mod font;
pub mod gamerules;
+21 -3
View File
@@ -1846,8 +1846,16 @@ impl Level {
}),
),
];
// Vanilla writes `equipment` even when empty and omits an empty effect list.
entries.push(("equipment", Tag::compound(equipment)));
// LivingEntity.addAdditionalSaveData omits empty equipment and an empty
// effect list. PlayerEquipment.isEmpty also counts the selected hotbar
// item, which the codec never writes: holding one saves `equipment: {}`.
let holding = self
.inventory
.iter()
.any(|(slot, _, count, _)| i32::from(*slot) == self.selected_slot && *count > 0);
if holding || !equipment.is_empty() {
entries.push(("equipment", Tag::compound(equipment)));
}
if self.active_effects.is_empty() {
entries.retain(|(key, _)| *key != "active_effects");
}
@@ -1943,7 +1951,17 @@ impl Level {
map.remove(&JavaString::from(key));
}
}
let uuid = *self.player_uuid.get_or_insert_with(random_uuid);
// A new world's player has the offline profile id of its name
// (UUIDUtil.createOfflinePlayerUUID), as in an offline single-player game.
let uuid = *self.player_uuid.get_or_insert_with(|| {
let u = horizon_protocol::crypto::offline_uuid("Player");
[
(u >> 96) as u32 as i32,
(u >> 64) as u32 as i32,
(u >> 32) as u32 as i32,
u as u32 as i32,
]
});
// A new world's first spawn point is its world spawn.
if self.world_spawn.is_none() {
self.world_spawn = self.spawn.map(|s| {
+42 -3
View File
@@ -578,8 +578,12 @@ impl ScoreEntry {
#[derive(Clone, Debug, Default, PartialEq)]
pub struct Scoreboard {
/// In creation order.
/// In the iteration order of vanilla's objectivesByName map.
pub objectives: Vec<Objective>,
/// `objectivesByName` (`Object2ObjectOpenHashMap(16, 0.5)`) and
/// `teamsByName` key orders.
objective_order: Option<crate::fastutil_order::OpenOrder>,
team_order: crate::fastutil_order::OpenOrder,
pub scores: BTreeMap<String, BTreeMap<String, Score>>,
pub display: BTreeMap<String, String>,
pub teams: Vec<Team>,
@@ -612,15 +616,45 @@ impl Scoreboard {
display_auto_update,
number_format,
});
self.objective_order
.get_or_insert_with(|| crate::fastutil_order::OpenOrder::new(16, 0.5))
.insert(name);
self.sort_objectives();
true
}
/// Objectives and teams in vanilla's hash map iteration order.
fn sort_objectives(&mut self) {
let order = self
.objective_order
.get_or_insert_with(|| crate::fastutil_order::OpenOrder::new(16, 0.5));
for o in &self.objectives {
order.insert(&o.name);
}
let rank: BTreeMap<&str, usize> = order.keys().enumerate().map(|(i, k)| (k, i)).collect();
self.objectives
.sort_by_key(|o| rank.get(o.name.as_str()).copied().unwrap_or(usize::MAX));
for t in &self.teams {
self.team_order.insert(&t.name);
}
let rank: BTreeMap<&str, usize> = self
.team_order
.keys()
.enumerate()
.map(|(i, k)| (k, i))
.collect();
self.teams
.sort_by_key(|t| rank.get(t.name.as_str()).copied().unwrap_or(usize::MAX));
}
pub fn remove_objective(&mut self, name: &str) {
self.objectives.retain(|o| o.name != name);
if let Some(order) = self.objective_order.as_mut() {
order.remove(name);
}
self.display.retain(|_, o| o != name);
// Scoreboard.removeObjective: holders left without scores stay tracked.
for s in self.scores.values_mut() {
s.remove(name);
}
self.scores.retain(|_, s| !s.is_empty());
}
pub fn display_objective(&self, slot: &str) -> Option<&Objective> {
self.objective(self.display.get(slot)?)
@@ -739,12 +773,15 @@ impl Scoreboard {
pub fn add_team(&mut self, name: &str) -> &mut Team {
if self.team(name).is_none() {
self.teams.push(Team::new(name));
self.team_order.insert(name);
self.sort_objectives();
}
self.team_mut(name).expect("just added")
}
pub fn remove_team(&mut self, name: &str) {
self.team_of.retain(|_, t| t != name);
self.teams.retain(|t| t.name != name);
self.team_order.remove(name);
}
pub fn players_team(&self, player: &str) -> Option<&Team> {
self.team(self.team_of.get(player)?)
@@ -1046,7 +1083,9 @@ mod tests {
sb.set_display_objective("sidebar", Some("kills"));
sb.remove_objective("kills");
assert!(sb.display_objective("sidebar").is_none());
assert!(sb.tracked().is_empty());
// Scoreboard.removeObjective keeps the holder, now without scores.
assert_eq!(sb.tracked(), vec!["Steve".to_owned()]);
assert!(sb.holder_scores("Steve").is_empty());
}
#[test]
+3 -2
View File
@@ -908,7 +908,8 @@ fn team(id: &str, ctx: &Context, env: &mut dyn Env) -> CmdResult<i32> {
let mut tracker = Tracker::default();
for m in &members {
let joined = env.sb_mut().add_to_team(&m.name, &name);
tracker.track(m, i32::from(joined));
// The message reads the display name after the change.
tracker.track(&env.named(&m.name), i32::from(joined));
}
let shown = formatted(env, &name);
tracker.send(
@@ -934,7 +935,7 @@ fn team(id: &str, ctx: &Context, env: &mut dyn Env) -> CmdResult<i32> {
let mut tracker = Tracker::default();
for m in &members {
let left = env.sb_mut().remove_from_team(&m.name);
tracker.track(m, i32::from(left));
tracker.track(&env.named(&m.name), i32::from(left));
}
tracker.send(
env,
+86 -1
View File
@@ -328,7 +328,7 @@ impl Pretty {
"\n"
};
let n = c.len();
for (i, (k, v)) in c.iter().enumerate() {
for (i, (k, v)) in java_hash_order(c).into_iter().enumerate() {
self.lit(&entry, None);
let key = string_of(k);
if !key.is_empty()
@@ -357,6 +357,91 @@ impl Pretty {
}
}
}
/// The iteration order of the `HashMap<String, Tag>` a `CompoundTag` holds,
/// for a map that grew to its size by insertion: buckets by
/// `HashMap.hash(String.hashCode())`, keys sharing a bucket in key order.
pub fn java_hash_order(
c: &horizon_world::nbt::Compound,
) -> Vec<(&horizon_world::nbt::JavaString, &Tag)> {
let mut capacity = 16usize;
while c.len() > capacity * 3 / 4 {
capacity *= 2;
}
let bucket = |k: &horizon_world::nbt::JavaString| {
let h = string_of(k)
.encode_utf16()
.fold(0u32, |h, ch| h.wrapping_mul(31).wrapping_add(u32::from(ch)));
((h ^ (h >> 16)) as usize) & (capacity - 1)
};
// Keys sharing a bucket iterate in insertion order: the order vanilla's
// savers write them, as far as it is known here.
const WRITE_ORDER: &[&str] = &[
// ItemStack.CODEC.
"id",
"count",
"components",
// Entity.saveWithoutId.
"Pos",
"Motion",
"Rotation",
"fall_distance",
"Fire",
"Air",
"OnGround",
"Invulnerable",
"PortalCooldown",
"UUID",
"CustomName",
"CustomNameVisible",
"Silent",
"NoGravity",
"Glowing",
"TicksFrozen",
"HasVisualFire",
"Tags",
"data",
"Passengers",
// LivingEntity.addAdditionalSaveData.
"Health",
"HurtTime",
"DeathTime",
"AbsorptionAmount",
"current_impulse_context_reset_grace_time",
"current_explosion_impact_pos",
"attributes",
"active_effects",
"FallFlying",
"sleeping_pos",
"Brain",
"equipment",
// ArmorStand.
"Invisible",
"Small",
"ShowArms",
"DisabledSlots",
"NoBasePlate",
"Marker",
"Pose",
];
// BlockEntity.saveMetadata writes the position after the entity's data.
const AFTER: &[&str] = &["x", "y", "z"];
let rank = |k: &horizon_world::nbt::JavaString| {
let k = string_of(k);
WRITE_ORDER
.iter()
.position(|w| *w == k)
.or_else(|| {
AFTER
.iter()
.position(|w| *w == k)
.map(|i| WRITE_ORDER.len() + 1 + i)
})
.unwrap_or(WRITE_ORDER.len())
};
let mut entries: Vec<_> = c.iter().collect();
entries.sort_by_key(|(k, _)| (bucket(k), rank(k)));
entries
}
/// `NbtUtils.toPrettyComponent`: the coloured, unindented form.
pub fn pretty(tag: &Tag) -> Text {
pretty_indented(tag, "")
+18
View File
@@ -91,6 +91,24 @@ impl VanillaTerrain {
) -> Option<(String, [i32; 3])> {
self.generator.worker().locate(names, from, radius)
}
/// `/locate biome`: `BiomeSource.findClosestBiome3d`.
pub fn find_closest_biome(
&self,
search: &horizon_world::worldgen::generator::BiomeSearch<'_>,
) -> Option<(String, [i32; 3])> {
let mut worker = self.query.lock().unwrap_or_else(|e| e.into_inner());
let worker = worker.get_or_insert_with(|| self.generator.worker());
worker.find_closest_biome(search)
}
/// `/place jigsaw`: `JigsawPlacement.addPieces`.
pub fn jigsaw_pieces(
&self,
query: &horizon_world::worldgen::generator::JigsawQuery<'_>,
) -> Option<horizon_world::worldgen::generator::JigsawPieces> {
let mut worker = self.query.lock().unwrap_or_else(|e| e.into_inner());
let worker = worker.get_or_insert_with(|| self.generator.worker());
worker.jigsaw_pieces(query)
}
/// Concentric ring positions of a structure set (strongholds), once known.
pub fn ring_positions(&self, set: &str) -> Option<Vec<ChunkPos>> {
self.generator.ring_positions(set)
+2 -2
View File
@@ -1,7 +1,7 @@
//! The world border (`WorldBorder`): its size lerp, centre, damage and
//! warning settings, and how far a point is from its edge.
pub const MAX_SIZE: f64 = 5.999_997e7;
pub const MAX_SIZE: f64 = 5.999_996_8e7;
pub const MAX_CENTER: f64 = 2.999_998_4e7;
#[derive(Clone, Debug, PartialEq)]
@@ -19,7 +19,7 @@ impl Default for WorldBorder {
fn default() -> Self {
Self {
center: [0.0, 0.0],
size: 5.999_997e7,
size: MAX_SIZE,
lerp: None,
damage_per_block: 0.2,
safe_zone: 5.0,
@@ -105,6 +105,18 @@ fn next_int_between<R: RandomSource>(random: &mut R, min: i32, max: i32) -> i32
}
impl Behaviours {
/// `/place feature`: `ConfiguredFeature.place` at `pos` with the level
/// random. `None` when the feature is unknown or cannot run.
pub fn place_feature<L: LevelAccess + ?Sized>(
&self,
level: &mut L,
ticks: &mut Ticks,
name: &str,
pos: BlockPos,
) -> Option<bool> {
self.live_features()?.configured(name)?;
Some(self.sim(level, ticks).place_configured_feature(name, pos))
}
/// `BoneMealItem.useOn` for a player clicking `pos` on `face`. Returns
/// whether bone meal was used (the caller then shrinks the stack unless
/// the player is in creative mode). Reports level event 1505 (growth
+47
View File
@@ -21,6 +21,53 @@ impl Behaviours {
pub fn live_features(&self) -> Option<&Arc<LiveFeatures>> {
self.growth.features.get()
}
/// `JigsawPlacement.generateJigsaw`: `assemble` builds the pieces (from
/// the generation context's own random), then each piece is placed into
/// the level with the level random, an unbounded box and `reference` as
/// the origin. Returns whether pieces were assembled.
pub fn place_jigsaw<L: LevelAccess + ?Sized>(
&self,
level: &mut L,
ticks: &mut super::Ticks,
reference: [i32; 3],
assemble: impl FnOnce() -> Option<crate::worldgen::generator::JigsawPieces>,
) -> bool {
let Some(features) = self.live_features() else {
return false;
};
let Some(jigsaw) = assemble() else {
return false;
};
let mut sim = self.sim(level, ticks);
let mut random = sim.random().clone();
{
let mut world = LevelFeatureWorld {
sim: &mut sim,
features,
};
let unbounded =
crate::worldgen::structure::BoundingBox::new([i32::MIN; 3], [i32::MAX; 3]);
for piece in &jigsaw.pieces {
let mut place_feature =
|w: &mut LevelFeatureWorld<'_, '_, L>,
r: &mut horizon_core::random::LegacyRandom,
name: &str,
p: [i32; 3]| { Ok(features.place_placed(name, w, r, p)) };
if let Err(e) = piece.place(
&mut world,
&jigsaw.resources,
&mut random,
unbounded,
reference,
&mut place_feature,
) {
eprintln!("Horizon: placing a jigsaw piece failed: {e}");
}
}
}
*sim.random() = random;
true
}
}
/// The four (state, position) pairs of a 2x2 sapling square.
@@ -1370,6 +1370,16 @@ trait SeededPipeline: Send + Sync {
from: [i32; 3],
radius: i32,
) -> Option<(String, [i32; 3])>;
fn find_closest_biome(
&self,
worker: &mut WorkerState,
search: &BiomeSearch<'_>,
) -> Option<(String, [i32; 3])>;
fn jigsaw_pieces(
&self,
worker: &mut WorkerState,
query: &JigsawQuery<'_>,
) -> Option<JigsawPieces>;
}
impl<R: RandomSource + 'static> SeededPipeline for Pipeline<R>
where
@@ -1470,6 +1480,162 @@ where
radius,
)
}
fn find_closest_biome(
&self,
worker: &mut WorkerState,
search: &BiomeSearch<'_>,
) -> Option<(String, [i32; 3])> {
// BiomeSource.findClosestBiome3d.
let candidates: BTreeSet<&str> = self
.source
.possible_biomes()
.into_iter()
.filter(|name| (search.allowed)(name))
.collect();
if candidates.is_empty() {
return None;
}
let mut resolver = self.source.resolver(
&self.climate,
self.router.get(RouterField::Erosion).as_ref(),
);
let ys = out_from_origin(
search.origin[1],
search.min_y + 1,
search.max_y + 1,
search.vertical,
);
let radius = search.radius.div_euclid(search.horizontal);
for [sx, sz] in spiral_around(radius) {
let x = search.origin[0].wrapping_add(sx.wrapping_mul(search.horizontal));
let z = search.origin[2].wrapping_add(sz.wrapping_mul(search.horizontal));
for &y in &ys {
let quart = [x >> 2, y >> 2, z >> 2];
let Ok(name) = resolver.sample(&mut worker.carver_context, quart) else {
continue;
};
if candidates.contains(name) {
return Some((name.to_owned(), [x, y, z]));
}
}
}
None
}
fn jigsaw_pieces(
&self,
worker: &mut WorkerState,
query: &JigsawQuery<'_>,
) -> Option<JigsawPieces> {
// JigsawPlacement.generateJigsaw: addPieces with no heightmap
// projection, MaxDistance(128), no aliases, no padding and
// waterlogging applied. The pieces draw from the GenerationContext's
// random, seeded from the level seed and the position's chunk, not
// from the level random.
let structures = self.structures.as_ref()?;
let mut random = horizon_core::random::WorldgenRandom::new(LegacyRandom::new(0));
random.set_large_feature_seed(self.seed, query.position[0] >> 4, query.position[2] >> 4);
let aliases = BTreeMap::new();
let config = super::structure::jigsaw::JigsawConfig {
start_pool: query.pool,
start_jigsaw: Some(query.target),
max_depth: query.max_depth,
use_expansion_hack: false,
project_to: None,
max_distance: [128, 128],
aliases: &aliases,
padding: [0, 0],
waterlogging: true,
};
let (_, pieces) = super::structure::jigsaw::assemble(
&config,
&mut StructureQueries {
pipeline: self,
worker,
valid: BTreeSet::new(),
},
&structures.registry.pools,
&structures.resources,
&structures.bindings,
&mut random,
query.position,
)?;
Some(JigsawPieces {
pieces,
resources: structures.resources.clone(),
})
}
}
/// A `JigsawPlacement.generateJigsaw` request (`/place jigsaw`).
pub struct JigsawQuery<'a> {
pub pool: &'a str,
pub target: &'a str,
pub max_depth: i32,
pub position: [i32; 3],
}
/// The assembled pieces of a jigsaw and the templates they place.
pub struct JigsawPieces {
pub pieces: Vec<super::structure::jigsaw::PoolPiece>,
pub resources: Arc<super::structure::StructureResources>,
}
/// A `findClosestBiome3d` query.
pub struct BiomeSearch<'a> {
pub allowed: &'a dyn Fn(&str) -> bool,
pub origin: [i32; 3],
pub radius: i32,
pub horizontal: i32,
pub vertical: i32,
/// `level.getMinY()` and `level.getMaxY()`.
pub min_y: i32,
pub max_y: i32,
}
/// `Mth.outFromOrigin(origin, lower, upper, step)`.
pub fn out_from_origin(origin: i32, lower: i32, upper: i32, step: i32) -> Vec<i32> {
let center = origin.clamp(lower, upper);
let mut out = Vec::new();
let mut cursor = center;
loop {
let distance = (center - cursor).abs();
if !(center - distance >= lower || center + distance <= upper) {
return out;
}
out.push(cursor);
let negative = cursor <= center;
let can_move_positive = center + distance + step <= upper;
let mut next = center + distance + step;
if !negative || !can_move_positive {
let attempt = center - distance - if negative { step } else { 0 };
if attempt >= lower {
next = attempt;
}
}
cursor = next;
}
}
/// `BlockPos.spiralAround(ZERO, radius, EAST, SOUTH)` as (x, z) offsets.
pub fn spiral_around(radius: i32) -> impl Iterator<Item = [i32; 2]> {
const DIRS: [[i32; 2]; 4] = [[1, 0], [0, 1], [-1, 0], [0, -1]];
let legs = 4 * radius;
let (mut leg, mut leg_size, mut leg_index) = (-1i32, 0i32, 0i32);
let mut last = [0, 1];
std::iter::from_fn(move || {
let d = DIRS[((leg + 4) % 4) as usize];
let cursor = [last[0] + d[0], last[1] + d[1]];
last = cursor;
if leg_index >= leg_size {
if leg >= legs {
return None;
}
leg += 1;
leg_index = 0;
leg_size = leg / 2 + 1;
}
leg_index += 1;
Some(cursor)
})
}
/// Counters from one FEATURES pass.
@@ -1622,6 +1788,16 @@ impl GeneratorWorker {
) -> Option<(String, [i32; 3])> {
self.pipeline.locate(&mut self.state, names, from, radius)
}
/// `BiomeSource.findClosestBiome3d`: the first sampled position whose
/// noise biome passes `allowed`, spiralling out from the origin.
pub fn find_closest_biome(&mut self, search: &BiomeSearch<'_>) -> Option<(String, [i32; 3])> {
self.pipeline.find_closest_biome(&mut self.state, search)
}
/// `JigsawPlacement.addPieces` for `/place jigsaw`, drawing from the
/// generation context's random (level seed and the position's chunk).
pub fn jigsaw_pieces(&mut self, query: &JigsawQuery<'_>) -> Option<JigsawPieces> {
self.pipeline.jigsaw_pieces(&mut self.state, query)
}
/// STRUCTURE_STARTS: the structure starts owned by a chunk (cached).
pub fn structure_starts(
&mut self,
@@ -0,0 +1,387 @@
package dev.horizonlab.parity;
import com.google.gson.Gson;
import com.google.gson.JsonArray;
import com.google.gson.JsonObject;
import com.google.gson.JsonParser;
import com.mojang.authlib.GameProfile;
import com.mojang.authlib.services.ServicesKeySet;
import com.mojang.serialization.Lifecycle;
import io.netty.channel.embedded.EmbeddedChannel;
import java.io.IOException;
import java.net.Proxy;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.ArrayList;
import java.util.List;
import java.util.Optional;
import java.util.UUID;
import java.util.function.BooleanSupplier;
import net.minecraft.SharedConstants;
import net.minecraft.SystemReport;
import net.minecraft.commands.Commands;
import net.minecraft.core.MappedRegistry;
import net.minecraft.core.Registry;
import net.minecraft.core.UUIDUtil;
import net.minecraft.core.registries.Registries;
import net.minecraft.network.Connection;
import net.minecraft.network.chat.ChatType;
import net.minecraft.network.chat.Component;
import net.minecraft.network.chat.OutgoingChatMessage;
import net.minecraft.network.chat.Style;
import net.minecraft.network.chat.ClickEvent;
import net.minecraft.network.protocol.PacketFlow;
import net.minecraft.server.Bootstrap;
import net.minecraft.server.MinecraftServer;
import net.minecraft.server.Services;
import net.minecraft.server.WorldLoader;
import net.minecraft.server.WorldStem;
import net.minecraft.server.level.ClientInformation;
import net.minecraft.server.level.ServerLevel;
import net.minecraft.server.level.ServerPlayer;
import net.minecraft.server.level.progress.LoggingLevelLoadListener;
import net.minecraft.server.network.CommonListenerCookie;
import net.minecraft.server.notifications.EmptyNotificationService;
import net.minecraft.server.notifications.NotificationManager;
import net.minecraft.server.packs.repository.PackRepository;
import net.minecraft.server.packs.repository.ServerPacksSource;
import net.minecraft.server.permissions.LevelBasedPermissionSet;
import net.minecraft.server.permissions.PermissionSet;
import net.minecraft.server.players.NameAndId;
import net.minecraft.server.players.PlayerList;
import net.minecraft.server.players.ProfileResolver;
import net.minecraft.server.players.UserNameToIdResolver;
import net.minecraft.util.Util;
import net.minecraft.util.datafix.DataFixers;
import net.minecraft.util.debugchart.LocalSampleLogger;
import net.minecraft.util.debugchart.SampleLogger;
import net.minecraft.world.level.GameType;
import net.minecraft.world.level.LevelSettings;
import net.minecraft.world.level.WorldDataConfiguration;
import net.minecraft.world.level.dimension.LevelStem;
import net.minecraft.world.level.gamerules.GameRules;
import net.minecraft.world.level.levelgen.WorldDimensions;
import net.minecraft.world.level.levelgen.WorldGenSettings;
import net.minecraft.world.level.levelgen.WorldOptions;
import net.minecraft.world.level.levelgen.presets.WorldPresets;
import net.minecraft.world.level.storage.LevelDataAndDimensions;
import net.minecraft.world.level.storage.LevelStorageSource;
import net.minecraft.world.level.storage.PrimaryLevelData;
/**
* Runs command scripts through vanilla's real command implementations on a
* stand-in integrated server (a real MinecraftServer with a generated world
* and one single-player owner), recording every system and chat message the
* player receives as styled spans together with the results reported to the
* player's CommandResultCallback. Shared by tools/test_command_exec_parity.py.
*
* VanillaCommandExecOracle <universe> <script.jsonl> <out.jsonl> <seed>
*/
public final class VanillaCommandExecOracle {
static final List<JsonArray> messages = new ArrayList<>();
static final class Resolver implements ProfileResolver, UserNameToIdResolver {
@Override public Optional<GameProfile> fetchByName(String name) { return Optional.empty(); }
@Override public Optional<GameProfile> fetchById(UUID id) { return Optional.empty(); }
@Override public void add(NameAndId nameAndId) {}
@Override public Optional<NameAndId> get(String name) { return Optional.empty(); }
@Override public Optional<NameAndId> get(UUID id) { return Optional.empty(); }
@Override public void resolveOfflineUsers(boolean value) {}
@Override public void save() {}
}
static final class Server extends MinecraftServer {
final Path script;
final Path output;
final LocalSampleLogger sampleLogger = new LocalSampleLogger(4);
boolean ran;
static Server create(Thread thread, LevelStorageSource.LevelStorageAccess access, PackRepository packs, long seed, Path script, Path output) throws Exception {
packs.reload();
WorldDataConfiguration config = WorldDataConfiguration.DEFAULT;
LevelSettings settings = new LevelSettings("Harness", GameType.SURVIVAL, LevelSettings.DifficultySettings.DEFAULT, true, config);
WorldLoader.PackConfig packConfig = new WorldLoader.PackConfig(packs, config, false, true);
WorldLoader.InitConfig init = new WorldLoader.InitConfig(packConfig, Commands.CommandSelection.INTEGRATED, LevelBasedPermissionSet.OWNER);
WorldOptions options = new WorldOptions(seed, true, false);
WorldStem stem = Util.<WorldStem>blockUntilDone(executor -> WorldLoader.load(init, context -> {
Registry<LevelStem> noDatapackDimensions = new MappedRegistry<>(Registries.LEVEL_STEM, Lifecycle.stable()).freeze();
WorldDimensions dimensions = context.datapackWorldRegistries().lookupOrThrow(Registries.WORLD_PRESET)
.getOrThrow(WorldPresets.NORMAL).value().createWorldDimensions();
WorldDimensions.Complete complete = dimensions.bake(noDatapackDimensions);
PrimaryLevelData data = new PrimaryLevelData(settings, complete.specialWorldProperty(), complete.lifecycle());
return new WorldLoader.DataLoadOutput<>(
new LevelDataAndDimensions.WorldDataAndGenSettings(data, new WorldGenSettings(options, dimensions)),
complete.dimensionsRegistryAccess());
}, WorldStem::new, Util.backgroundExecutor(), executor)).get();
return new Server(thread, access, packs, stem, script, output);
}
Server(Thread thread, LevelStorageSource.LevelStorageAccess access, PackRepository packs, WorldStem stem, Path script, Path output) {
super(thread, access, packs, stem, Optional.of(new GameRules(WorldDataConfiguration.DEFAULT.enabledFeatures())), Proxy.NO_PROXY,
DataFixers.getDataFixer(), new Services(null, ServicesKeySet.EMPTY, null, new Resolver(), new Resolver()),
LoggingLevelLoadListener.forDedicatedServer(), false, new NotificationManager());
this.script = script;
this.output = output;
}
@Override protected boolean initServer() {
this.setPlayerList(new PlayerList(this, this.registries(), this.playerDataStorage, new EmptyNotificationService()) {});
this.loadLevel();
return true;
}
@Override protected void tickServer(BooleanSupplier haveTime) {
if (ran) {
return;
}
ran = true;
try {
runScript();
} catch (Throwable t) {
t.printStackTrace();
Runtime.getRuntime().halt(2);
}
System.out.flush();
Runtime.getRuntime().halt(0);
}
ServerPlayer player;
void runScript() throws IOException {
ServerLevel level = this.overworld();
GameProfile profile = new GameProfile(UUIDUtil.createOfflinePlayerUUID("Player"), "Player");
CommonListenerCookie cookie = CommonListenerCookie.createInitial(profile, false);
player = new ServerPlayer(this, level, profile, ClientInformation.createDefault()) {
@Override public void sendSystemMessage(Component message, boolean overlay) {
if (!overlay) {
messages.add(spans(message));
}
}
@Override public void sendChatMessage(OutgoingChatMessage message, boolean filtered, ChatType.Bound chatType) {
messages.add(spans(chatType.decorate(message.content())));
}
};
Connection connection = new Connection(PacketFlow.SERVERBOUND);
new EmbeddedChannel(connection);
this.getPlayerList().placeNewPlayer(connection, player, cookie);
settle();
StringBuilder out = new StringBuilder();
Gson gson = new Gson();
for (String line : Files.readAllLines(script, StandardCharsets.UTF_8)) {
if (line.isBlank()) {
continue;
}
JsonObject op = JsonParser.parseString(line).getAsJsonObject();
switch (op.get("op").getAsString()) {
case "cmd" -> {
String command = op.get("cmd").getAsString();
messages.clear();
List<JsonArray> results = new ArrayList<>();
var source = player.createCommandSourceStack().withCallback((success, value) -> {
JsonArray r = new JsonArray();
r.add(success);
r.add(value);
results.add(r);
});
this.getCommands().performPrefixedCommand(source, command);
if (!op.has("record") || op.get("record").getAsBoolean()) {
JsonObject record = new JsonObject();
record.addProperty("cmd", command);
JsonArray m = new JsonArray();
messages.forEach(m::add);
record.add("messages", m);
JsonArray r = new JsonArray();
results.forEach(r::add);
record.add("results", r);
out.append(gson.toJson(record)).append('\n');
}
}
case "tick" -> {
int n = op.has("n") ? op.get("n").getAsInt() : 1;
messages.clear();
// Answers computed off-thread (profile lookups) reach the
// server's task queue before the next tick.
// (Other queued tasks may be pending already, so give
// the stub resolvers a fixed moment rather than
// waiting for the queue to fill.)
if (op.has("record")) {
try { Thread.sleep(300); } catch (InterruptedException e) { throw new RuntimeException(e); }
}
for (int i = 0; i < n; i++) {
tick();
}
if (op.has("record") && op.get("record").getAsBoolean()) {
JsonObject record = new JsonObject();
record.addProperty("cmd", "#tick");
JsonArray m = new JsonArray();
messages.forEach(m::add);
record.add("messages", m);
record.add("results", new JsonArray());
out.append(gson.toJson(record)).append('\n');
}
}
case "settle" -> settle();
default -> throw new IllegalArgumentException(line);
}
}
Files.writeString(output, out.toString(), StandardCharsets.UTF_8);
}
/** One iteration of MinecraftServer.runServer: the delayed tick profiler start, then the tick. */
void tick() {
try {
var delay = MinecraftServer.class.getDeclaredField("debugCommandProfilerDelayStart");
delay.setAccessible(true);
if (delay.getBoolean(this)) {
delay.setBoolean(this, false);
Class<?> profilerClass = Class.forName("net.minecraft.server.MinecraftServer$TimeProfiler");
var ctor = profilerClass.getDeclaredConstructor(long.class, int.class);
ctor.setAccessible(true);
var field = MinecraftServer.class.getDeclaredField("debugCommandProfiler");
field.setAccessible(true);
field.set(this, ctor.newInstance(Util.getNanos(), this.getTickCount()));
}
} catch (ReflectiveOperationException e) {
throw new RuntimeException(e);
}
drain();
super.tickServer(() -> false);
// The player's network listener ticks it each server tick
// (ServerGamePacketListenerImpl.tickPlayer); this one has no
// listening connection. Its movement is the client's, so of
// that tick only apply changed attributes (waypoint range...).
if (player != null) {
try {
var refresh = net.minecraft.world.entity.LivingEntity.class.getDeclaredMethod("refreshDirtyAttributes");
refresh.setAccessible(true);
refresh.invoke(player);
} catch (ReflectiveOperationException e) {
throw new RuntimeException(e);
}
}
drain();
}
/** The server's and every level's chunk task queues (runServer's waits run them). */
void drain() {
boolean more = true;
while (more) {
more = false;
this.runAllTasks();
for (ServerLevel level : this.getAllLevels()) {
while (level.getChunkSource().pollTask()) {
more = true;
}
}
}
}
/** Force-load the chunks around the player (Horizon waits for its streamed terrain). */
void settle() {
ServerLevel level = player.level();
int cx = player.chunkPosition().x(), cz = player.chunkPosition().z();
for (int dz = -2; dz <= 2; dz++) {
for (int dx = -2; dx <= 2; dx++) {
// An entity-ticking ticket that, unlike setChunkForced,
// is not a force-load /forceload would report.
level.getChunkSource().addTicket(
new net.minecraft.server.level.Ticket(net.minecraft.server.level.TicketType.DRAGON, net.minecraft.server.level.ChunkMap.FORCED_TICKET_LEVEL),
new net.minecraft.world.level.ChunkPos(cx + dx, cz + dz));
level.getChunk(cx + dx, cz + dz);
}
}
// Entity sections become visible once their (asynchronous) load
// finished and the chunk entity-ticks.
for (int i = 0; i < 400; i++) {
tick();
boolean ready = true;
for (int dz = -2; dz <= 2 && ready; dz++) {
for (int dx = -2; dx <= 2 && ready; dx++) {
ready = level.areEntitiesActuallyLoadedAndTicking(new net.minecraft.world.level.ChunkPos(cx + dx, cz + dz));
}
}
if (ready && i >= 5) {
return;
}
try { Thread.sleep(5); } catch (InterruptedException e) { throw new RuntimeException(e); }
}
throw new IllegalStateException("entities around the player did not load");
}
static JsonArray spans(Component message) {
JsonArray out = new JsonArray();
message.visit((style, text) -> {
if (text.isEmpty()) {
return Optional.empty();
}
JsonArray key = styleKey(style);
if (!out.isEmpty()) {
JsonArray last = out.get(out.size() - 1).getAsJsonArray();
if (last.get(1).equals(key)) {
last.set(0, new com.google.gson.JsonPrimitive(last.get(0).getAsString() + text));
return Optional.empty();
}
}
JsonArray span = new JsonArray();
span.add(text);
span.add(key);
out.add(span);
return Optional.empty();
}, Style.EMPTY);
return out;
}
static JsonArray styleKey(Style style) {
JsonArray key = new JsonArray();
if (style.getColor() == null) {
key.add(com.google.gson.JsonNull.INSTANCE);
} else {
key.add(style.getColor().getValue() & 0xFFFFFF);
}
key.add(style.isBold());
key.add(style.isItalic());
key.add(style.isUnderlined());
key.add(style.isStrikethrough());
key.add(style.isObfuscated());
return key;
}
@Override public LevelBasedPermissionSet getProfilePermissions(NameAndId nameAndId) { return LevelBasedPermissionSet.OWNER; }
@Override protected SampleLogger getTickTimeLogger() { return sampleLogger; }
@Override public boolean isTickTimeLoggingEnabled() { return false; }
@Override public SystemReport fillServerSystemReport(SystemReport report) { return report; }
@Override public boolean isHardcore() { return false; }
@Override public LevelBasedPermissionSet operatorUserPermissions() { return LevelBasedPermissionSet.GAMEMASTER; }
@Override public PermissionSet getFunctionCompilationPermissions() { return LevelBasedPermissionSet.GAMEMASTER; }
@Override public boolean shouldRconBroadcast() { return true; }
@Override public boolean isDedicatedServer() { return false; }
@Override public int getRateLimitPacketsPerSecond() { return 0; }
@Override public int getCommandSpamThresholdSeconds() { return 0; }
@Override public int getChatSpamThresholdSeconds() { return 0; }
@Override public boolean useNativeTransport() { return false; }
@Override public boolean isPublished() { return false; }
@Override public boolean shouldInformAdmins() { return true; }
@Override public boolean isSingleplayerOwner(NameAndId nameAndId) { return nameAndId.name().equalsIgnoreCase("Player"); }
@Override public int getMaxPlayers() { return 8; }
}
public static void main(String[] args) throws Exception {
SharedConstants.tryDetectVersion();
Bootstrap.bootStrap();
Path universe = Path.of(args[0]);
Path script = Path.of(args[1]).toAbsolutePath();
Path output = Path.of(args[2]).toAbsolutePath();
long seed = Long.parseLong(args[3]);
Files.createDirectories(universe);
LevelStorageSource.LevelStorageAccess access = LevelStorageSource.createDefault(universe).createAccess("harness");
PackRepository packs = ServerPacksSource.createPackRepository(access);
MinecraftServer.spin(thread -> {
try {
return Server.create(thread, access, packs, seed, script, output);
} catch (Exception e) {
throw new RuntimeException(e);
}
});
}
}
+929
View File
@@ -0,0 +1,929 @@
"""Command scripts for tools/test_command_exec_parity.py.
Each group is a list of operations: `cmd` runs a command as the player and
records its messages and results (`record: false` runs setup silently),
`tick` advances the game and `settle` loads the terrain around the player.
Everything happens high above the terrain (y 200 and up, where both worlds
are air) after the world's entities are removed, so the results do not
depend on world generation.
"""
def cmd(command, record=True):
op = {'op': 'cmd', 'cmd': command}
if not record:
op['record'] = False
return op
def setup(*commands):
return [cmd(c, False) for c in commands]
BASE = (0, 200, 0)
def group_setup():
return [
*setup('/gamerule spawn_mobs false', '/gamerule mob_drops false', '/gamerule entity_drops false',
'/gamerule advance_time false', '/gamerule advance_weather false', '/gamerule spawn_wandering_traders false',
'/gamerule spawn_patrols false', '/gamerule spawn_phantoms false', '/gamerule spawn_wardens false',
'/gamerule show_advancement_messages false', '/gamemode creative', '/tp @s 8.5 230 8.5 0 0'),
{'op': 'settle'},
*setup('/kill @e[type=!player]'),
{'op': 'tick', 'n': 25},
*setup('/kill @e[type=!player]'),
{'op': 'tick', 'n': 25},
*setup('/fill 0 200 0 15 228 15 air', '/time set 1000', '/weather clear', '/difficulty normal', '/clear @s'),
]
def client_commands():
return [
cmd('/version'),
cmd('/spectate'),
cmd('/spectate @s'),
cmd('/gamemode spectator'),
cmd('/spectate'),
cmd('/spectate @s'),
cmd('/spectate @s @s'),
cmd('/gamemode creative'),
cmd('/posteffect list @s'),
cmd('/posteffect remove @s minecraft:blur'),
cmd('/posteffect clear @s'),
cmd('/posteffect add @s minecraft:blur'),
cmd('/posteffect add @s minecraft:blur'),
cmd('/posteffect add @a minecraft:invert'),
cmd('/posteffect list @s'),
cmd('/posteffect remove @s minecraft:blur'),
cmd('/posteffect remove @p minecraft:blur'),
cmd('/posteffect list @p'),
cmd('/posteffect clear @s'),
cmd('/posteffect clear @s'),
cmd('/waypoint list'),
cmd('/waypoint modify @s color red'),
cmd('/waypoint modify @s color dark_aqua'),
cmd('/waypoint modify @s color hex 12ab3f'),
cmd('/waypoint modify @s color hex F0A'),
cmd('/waypoint list'),
cmd('/waypoint modify @s color reset'),
cmd('/waypoint modify @s style set minecraft:bowtie'),
cmd('/waypoint modify @s style reset'),
cmd('/waypoint list'),
cmd('/dialog show @s minecraft:server_links'),
cmd('/dialog show @a minecraft:quick_actions'),
cmd('/dialog show @s {type:"minecraft:notice",title:"Hello"}'),
cmd('/dialog clear @s'),
cmd('/dialog clear @a'),
cmd('/kick @s'),
cmd('/kick @s Go away'),
cmd('/kick Player'),
cmd('/fetchprofile name Notch'),
{'op': 'tick', 'n': 5, 'record': True},
cmd('/fetchprofile id 069a79f4-44e9-4726-a5be-fca90e38aaf5'),
{'op': 'tick', 'n': 5, 'record': True},
cmd('/unpublish'),
cmd('/debug stop'),
cmd('/debug start'),
cmd('/debug start'),
cmd('/debug stop'),
cmd('/debug stop'),
cmd('/jfr stop'),
]
def game_state():
return [
cmd('/gamemode survival'),
cmd('/gamemode survival'),
cmd('/gamemode adventure @s'),
cmd('/gamemode creative @a'),
cmd('/defaultgamemode survival'),
cmd('/defaultgamemode creative'),
cmd('/difficulty'),
cmd('/difficulty hard'),
cmd('/difficulty hard'),
cmd('/difficulty normal'),
cmd('/seed'),
cmd('/time set 1000'),
cmd('/time query daytime'),
cmd('/time set noon'),
cmd('/time set night'),
cmd('/time add 100'),
cmd('/time set 1000'),
cmd('/weather rain'),
cmd('/weather thunder 600'),
cmd('/weather clear 1d'),
cmd('/gamerule keep_inventory'),
cmd('/gamerule keep_inventory true'),
cmd('/gamerule keep_inventory'),
cmd('/gamerule keep_inventory false'),
cmd('/gamerule random_tick_speed 5'),
cmd('/gamerule random_tick_speed'),
cmd('/gamerule random_tick_speed 3'),
cmd('/list'),
cmd('/say Hello world'),
cmd('/me waves'),
cmd('/msg @s secret'),
cmd('/tellraw @s {"text":"raw","color":"gold","bold":true}'),
cmd('/tellraw @s ["a",{"text":"b","italic":true},{"translate":"block.minecraft.stone"}]'),
cmd('/title @s title "Hi"'),
cmd('/title @s subtitle "Sub"'),
cmd('/title @s actionbar "Bar"'),
cmd('/title @s times 10 20 30'),
cmd('/title @s clear'),
cmd('/title @s reset'),
cmd('/help gamemode'),
cmd('/random value 5..5'),
cmd('/random roll 7..7'),
cmd('/tick query'),
cmd('/stopwatch create harness:a'),
cmd('/stopwatch create harness:a'),
cmd('/stopwatch query harness:b'),
]
def player_state():
return [
*setup('/gamemode survival'),
cmd('/experience add @s 10'),
cmd('/experience add @s 3 levels'),
cmd('/experience query @s levels'),
cmd('/experience query @s points'),
cmd('/experience set @s 0 levels'),
cmd('/xp set @s 5 points'),
cmd('/experience query @s points'),
cmd('/effect give @s minecraft:speed 30 1'),
cmd('/effect give @s minecraft:speed 10 0'),
cmd('/effect give @s minecraft:night_vision infinite 0 true'),
cmd('/effect clear @s minecraft:speed'),
cmd('/effect clear @s minecraft:speed'),
cmd('/effect clear @s'),
cmd('/effect clear @s'),
cmd('/give @s minecraft:diamond 3'),
cmd('/give @s minecraft:diamond_sword[minecraft:custom_name="Blade"]'),
cmd('/give @s minecraft:stone 130'),
cmd('/clear @s minecraft:diamond 0'),
cmd('/clear @s minecraft:stone 0'),
cmd('/clear @s minecraft:stone 64'),
cmd('/clear @s minecraft:stone 0'),
cmd('/item replace entity @s weapon.mainhand with minecraft:iron_pickaxe'),
cmd('/enchant @s minecraft:efficiency 3'),
cmd('/enchant @s minecraft:sharpness'),
cmd('/enchant @s minecraft:efficiency 9'),
cmd('/item replace entity @s armor.head with minecraft:golden_helmet'),
cmd('/clear @s minecraft:golden_helmet 0'),
cmd('/item modify entity @s weapon.mainhand {type:"minecraft:set_count",count:1}'),
cmd('/clear @s'),
cmd('/clear @s'),
cmd('/attribute @s minecraft:max_health get'),
cmd('/attribute @s minecraft:max_health base get'),
cmd('/attribute @s minecraft:max_health base set 30'),
cmd('/attribute @s minecraft:max_health modifier add harness:extra 4 add_value'),
cmd('/attribute @s minecraft:max_health modifier value get harness:extra'),
cmd('/attribute @s minecraft:max_health get'),
cmd('/attribute @s minecraft:max_health modifier remove harness:extra'),
cmd('/attribute @s minecraft:max_health base reset'),
cmd('/spawnpoint @s 8 230 8'),
cmd('/setworldspawn 8 230 8'),
cmd('/tp @s 8.5 230 8.5'),
cmd('/tp @s ~1 ~ ~'),
cmd('/teleport @s 8.5 230 8.5 90 0'),
cmd('/rotate @s 45 10'),
cmd('/damage @s 2'),
cmd('/damage @s 1 minecraft:magic'),
*setup('/gamemode creative'),
]
def world_blocks():
return [
cmd('/setblock 2 205 2 minecraft:stone'),
cmd('/setblock 2 205 2 minecraft:stone'),
cmd('/setblock 2 205 2 minecraft:oak_stairs[facing=east]'),
cmd('/execute if block 2 205 2 minecraft:oak_stairs[facing=east]'),
cmd('/execute if block 2 205 2 minecraft:stone'),
cmd('/execute unless block 2 205 2 minecraft:stone'),
cmd('/fill 0 201 0 4 203 4 minecraft:glass'),
cmd('/fill 0 201 0 4 203 4 minecraft:glass'),
cmd('/fill 0 201 0 4 203 4 minecraft:stone hollow'),
cmd('/fill 0 201 0 4 203 4 minecraft:dirt replace minecraft:stone'),
cmd('/fill 0 201 0 4 203 4 minecraft:air destroy'),
cmd('/execute if blocks 0 201 0 4 203 4 0 210 0 all'),
cmd('/setblock 3 206 3 minecraft:chest'),
cmd('/item replace block 3 206 3 container.0 with minecraft:apple 5'),
cmd('/data get block 3 206 3 Items[0].count'),
cmd('/data merge block 3 206 3 {CustomName:"Box"}'),
cmd('/clone 0 205 0 4 207 4 6 205 6'),
cmd('/clone 0 205 0 4 207 4 6 205 6 masked'),
cmd('/execute if blocks 0 205 0 4 207 4 6 205 6 all'),
cmd('/setblock 3 206 3 minecraft:air'),
cmd('/fill 0 200 0 15 228 15 air'),
cmd('/execute if block 0 300 0 air'),
cmd('/setblock 0 400 0 stone'),
cmd('/worldborder get'),
cmd('/worldborder set 1000'),
cmd('/worldborder set 1000'),
cmd('/worldborder center 10 20'),
cmd('/worldborder center 10 20'),
cmd('/worldborder damage amount 0.5'),
cmd('/worldborder damage buffer 3'),
cmd('/worldborder warning distance 10'),
cmd('/worldborder warning time 20'),
cmd('/worldborder add 100'),
cmd('/worldborder get'),
cmd('/worldborder set 59999968'),
cmd('/worldborder center 0 0'),
]
def entities():
return [
cmd('/summon minecraft:pig 4.5 210 4.5 {NoAI:1b,NoGravity:1b,Tags:["a","h"]}'),
cmd('/summon minecraft:cow 6.5 210 4.5 {NoAI:1b,NoGravity:1b,CustomName:"Daisy",Tags:["h"]}'),
cmd('/summon minecraft:armor_stand 8.5 210 4.5 {NoGravity:1b}'),
cmd('/execute if entity @e[tag=h,type=minecraft:pig]'),
cmd('/execute if entity @e[tag=h,type=minecraft:sheep]'),
cmd('/tag @e[tag=h,type=minecraft:pig] list'),
cmd('/tag @e[tag=h,type=minecraft:cow] add b'),
cmd('/tag @e[tag=h,type=minecraft:cow] add b'),
cmd('/tag @e[tag=b] list'),
cmd('/tag @e[tag=b] remove b'),
cmd('/data get entity @e[tag=h,type=minecraft:pig,limit=1] Tags'),
cmd('/data get entity @e[tag=h,type=minecraft:cow,limit=1] CustomName'),
cmd('/data merge entity @e[tag=h,type=minecraft:pig,limit=1] {Tags:["a","c"]}'),
cmd('/attribute @e[tag=h,type=minecraft:pig,limit=1] minecraft:movement_speed base get'),
cmd('/effect give @e[tag=h] minecraft:glowing 10'),
cmd('/damage @e[tag=h,type=minecraft:cow,limit=1] 1'),
cmd('/ride @s mount @e[tag=h,type=minecraft:pig,limit=1]'),
cmd('/ride @s dismount'),
cmd('/ride @s dismount'),
cmd('/spectate @e[tag=h,type=minecraft:pig,limit=1]'),
cmd('/gamemode spectator'),
cmd('/spectate @e[tag=h,type=minecraft:pig,limit=1]'),
cmd('/spectate'),
cmd('/gamemode creative'),
cmd('/waypoint modify @e[tag=h,type=minecraft:pig,limit=1] color red'),
cmd('/waypoint modify @e[type=minecraft:armor_stand,limit=1] color red'),
cmd('/fetchprofile entity @e[tag=h,type=minecraft:pig,limit=1]'),
cmd('/kill @e[tag=h,type=minecraft:pig]'),
cmd('/kill @e[tag=h,type=minecraft:pig]'),
cmd('/execute as @e[tag=h] run say mob'),
cmd('/execute store result score @s harness_score run data get entity @s SelectedItemSlot'),
cmd('/kill @e[tag=h]'),
*setup('/kill @e[type=minecraft:armor_stand]'),
{'op': 'tick', 'n': 25},
cmd('/execute if entity @e[tag=h]'),
]
def scores():
return [
cmd('/scoreboard objectives add harness dummy'),
cmd('/scoreboard objectives add harness dummy'),
cmd('/scoreboard objectives add harness_h health "Health"'),
cmd('/scoreboard objectives list'),
cmd('/scoreboard players set @s harness 5'),
cmd('/scoreboard players add @s harness 3'),
cmd('/scoreboard players remove @s harness 1'),
cmd('/scoreboard players get @s harness'),
cmd('/scoreboard players set fake harness 9'),
cmd('/scoreboard players operation @s harness += fake harness'),
cmd('/scoreboard players get @s harness'),
cmd('/scoreboard players list'),
cmd('/scoreboard players list @s'),
cmd('/scoreboard players reset fake harness'),
cmd('/scoreboard players get fake harness'),
cmd('/scoreboard objectives setdisplay list harness'),
cmd('/scoreboard objectives setdisplay sidebar harness'),
cmd('/scoreboard objectives modify harness displayname "Shown"'),
cmd('/scoreboard objectives modify harness rendertype hearts'),
cmd('/execute store result score @s harness run scoreboard players get @s harness'),
cmd('/execute if score @s harness matches 15'),
cmd('/team add red_team'),
cmd('/team add red_team'),
cmd('/team modify red_team color red'),
cmd('/team modify red_team prefix "[R] "'),
cmd('/team join red_team @s'),
cmd('/team list'),
cmd('/team list red_team'),
cmd('/waypoint list'),
cmd('/team leave @s'),
cmd('/team remove red_team'),
cmd('/scoreboard objectives remove harness'),
cmd('/scoreboard objectives remove harness_h'),
cmd('/bossbar add harness:bar "Bar"'),
cmd('/bossbar add harness:bar "Bar"'),
cmd('/bossbar set harness:bar value 30'),
cmd('/bossbar set harness:bar max 60'),
cmd('/bossbar set harness:bar color red'),
cmd('/bossbar set harness:bar style notched_10'),
cmd('/bossbar set harness:bar players @s'),
cmd('/bossbar get harness:bar value'),
cmd('/bossbar get harness:bar players'),
cmd('/bossbar list'),
cmd('/bossbar remove harness:bar'),
cmd('/bossbar remove harness:bar'),
]
def execute():
return [
*setup('/scoreboard objectives add exec dummy', '/scoreboard players set @s exec 4', '/scoreboard players set fake exec 9'),
cmd('/execute as @s run say hi'),
cmd('/execute as @s at @s run tp @s ~ ~ ~'),
cmd('/execute positioned 4 210 4 run setblock ~ ~ ~ minecraft:stone'),
cmd('/execute positioned 4 210 4 if block ~ ~ ~ minecraft:stone'),
cmd('/execute positioned as @s run tp @s ~ ~ ~'),
cmd('/execute align xyz run summon minecraft:armor_stand ~ ~-20 ~ {NoGravity:1b,Tags:["ex"],UUID:[I;1,2,3,4]}'),
cmd('/execute if entity @e[tag=ex]'),
cmd('/execute as @e[tag=ex] run data get entity @s Pos'),
cmd('/data get entity @e[tag=ex,limit=1]'),
cmd('/data get entity @e[tag=ex,limit=1] Pose'),
cmd('/execute anchored eyes run tp @s ^ ^ ^'),
cmd('/execute rotated 90 0 run tp @s ~ ~ ~ ~ ~'),
cmd('/execute rotated as @e[tag=ex,limit=1] run tp @s ~ ~ ~ ~ ~'),
cmd('/execute facing 0 230 0 run tp @s ~ ~ ~ ~ ~'),
cmd('/execute facing entity @e[tag=ex,limit=1] feet run tp @s ~ ~ ~ ~ ~'),
cmd('/execute in minecraft:the_nether run setblock 0 200 0 minecraft:stone'),
cmd('/execute in minecraft:the_end if block 0 64 0 minecraft:air'),
cmd('/execute in minecraft:the_end run say elsewhere'),
cmd('/execute in minecraft:nowhere run say nowhere'),
cmd('/execute in minecraft:overworld run setblock 5 210 5 minecraft:dirt'),
cmd('/execute if dimension minecraft:overworld'),
cmd('/execute if dimension minecraft:the_end'),
cmd('/execute if loaded 8 230 8'),
cmd('/execute if loaded 100000 230 100000'),
cmd('/execute if score @s exec matches 4'),
cmd('/execute if score @s exec < fake exec'),
cmd('/execute if score @s exec = fake exec'),
cmd('/execute unless score @s exec matches 1..3'),
cmd('/execute if score nobody exec matches 1'),
cmd('/execute if data entity @s Inventory'),
cmd('/execute if data entity @e[tag=ex,limit=1] Tags[0]'),
cmd('/execute if data block 4 210 4 Items'),
cmd('/execute if data storage harness:s value'),
cmd('/execute if predicate minecraft:tool/can_shear'),
cmd('/execute if predicate {condition:"minecraft:random_chance",chance:1.0}'),
cmd('/execute if predicate {condition:"minecraft:entity_properties",entity:"this",predicate:{type:"minecraft:player"}}'),
cmd('/execute if items entity @s weapon.mainhand minecraft:air'),
cmd('/execute if items entity @s container.* *'),
cmd('/execute store result score @s exec run data get entity @s SelectedItemSlot'),
cmd('/execute store success score @s exec run setblock 4 210 4 minecraft:stone'),
cmd('/scoreboard players get @s exec'),
cmd('/execute store result storage harness:s value int 2 run scoreboard players get fake exec'),
cmd('/data get storage harness:s value'),
cmd('/execute store result entity @e[tag=ex,limit=1] Rotation[0] float 1 run scoreboard players get fake exec'),
cmd('/data get entity @e[tag=ex,limit=1] Rotation'),
cmd('/execute store result block 4 210 4 x int 1 run scoreboard players get fake exec'),
cmd('/execute summon minecraft:armor_stand run tag @s add summoned'),
cmd('/execute if entity @e[tag=summoned]'),
cmd('/execute as @e[tag=ex] on passengers run say passenger'),
cmd('/execute on vehicle run say vehicle'),
cmd('/execute as @e[tag=ex] run return 3'),
cmd('/execute if entity @s run return fail'),
cmd('/return 7'),
cmd('/return fail'),
cmd('/return run scoreboard players get fake exec'),
cmd('/execute if biome 8 230 8 #minecraft:is_overworld'),
cmd('/execute if block 8 0 8 #minecraft:base_stone_overworld'),
cmd('/execute as @a run tellraw @s "each"'),
*setup('/kill @e[type=minecraft:armor_stand]', '/setblock 4 210 4 minecraft:air', '/setblock 5 210 5 minecraft:air',
'/scoreboard objectives remove exec', '/tp @s 8.5 230 8.5 0 0'),
{'op': 'tick', 'n': 25},
]
def items_and_loot():
return [
*setup('/clear @s', '/gamemode survival'),
cmd('/item modify entity @s weapon.mainhand {type:"minecraft:set_count",count:3}'),
cmd('/item replace entity @s weapon.mainhand with minecraft:stone 10'),
cmd('/item modify entity @s weapon.mainhand {type:"minecraft:set_count",count:3}'),
cmd('/clear @s minecraft:stone 0'),
cmd('/item modify entity @s weapon.mainhand {type:"minecraft:set_count",count:5,add:true}'),
cmd('/clear @s minecraft:stone 0'),
cmd('/item modify entity @s weapon.mainhand {type:"minecraft:limit_count",limit:{max:4}}'),
cmd('/clear @s minecraft:stone 0'),
cmd('/item modify entity @s weapon.mainhand {type:"minecraft:set_name",name:"Rock"}'),
cmd('/data get entity @s SelectedItem'),
cmd('/item modify entity @s weapon.mainhand {type:"minecraft:set_name",name:{text:"Item",color:"red"},target:"item_name"}'),
cmd('/item modify entity @s weapon.mainhand {type:"minecraft:set_lore",lore:["one","two"],mode:"replace_all"}'),
cmd('/item modify entity @s weapon.mainhand [{type:"minecraft:set_count",count:2},{type:"minecraft:set_custom_data",tag:{a:1b}}]'),
cmd('/data get entity @s SelectedItem'),
cmd('/item modify entity @s weapon.mainhand {type:"minecraft:set_components",components:{"minecraft:max_stack_size":16}}'),
cmd('/item modify entity @s weapon.mainhand {type:"minecraft:filtered",item_filter:{items:"minecraft:dirt"},on_pass:{type:"minecraft:set_count",count:1}}'),
cmd('/clear @s minecraft:stone 0'),
cmd('/item replace entity @s weapon.mainhand with minecraft:diamond_sword'),
cmd('/item modify entity @s weapon.mainhand {type:"minecraft:set_damage",damage:0.5}'),
cmd('/data get entity @s SelectedItem.components'),
cmd('/item modify entity @s weapon.mainhand {type:"minecraft:set_enchantments",enchantments:{"minecraft:sharpness":3}}'),
cmd('/data get entity @s SelectedItem.components."minecraft:enchantments"'),
cmd('/item modify entity @s weapon.mainhand {type:"minecraft:set_enchantments",enchantments:{"minecraft:sharpness":1},add:true}'),
cmd('/data get entity @s SelectedItem.components."minecraft:enchantments"'),
cmd('/item modify entity @s weapon.mainhand {type:"minecraft:toggle_tooltips",toggles:{"minecraft:enchantments":false}}'),
cmd('/item modify entity @s armor.head {type:"minecraft:set_count",count:1}'),
cmd('/item modify entity @s weapon.offhand {type:"minecraft:set_count",count:1}'),
cmd('/item modify entity @s hotbar.* {type:"minecraft:set_count",count:1}'),
cmd('/item modify entity @s weapon.mainhand minecraft:nonexistent'),
cmd('/item replace entity @s hotbar.1 from entity @s weapon.mainhand'),
cmd('/item replace entity @s hotbar.2 from entity @s weapon.mainhand {type:"minecraft:set_count",count:1}'),
cmd('/clear @s minecraft:diamond_sword 0'),
cmd('/setblock 3 206 3 minecraft:barrel'),
cmd('/item replace block 3 206 3 container.4 with minecraft:emerald 7'),
cmd('/item modify block 3 206 3 container.4 {type:"minecraft:set_count",count:2}'),
cmd('/item modify block 3 206 3 container.5 {type:"minecraft:set_count",count:2}'),
cmd('/item modify block 3 206 3 container.99 {type:"minecraft:set_count",count:2}'),
cmd('/item modify block 3 207 3 container.0 {type:"minecraft:set_count",count:2}'),
cmd('/data get block 3 206 3 Items'),
cmd('/data get block 3 206 3'),
cmd('/item replace entity @s hotbar.3 from block 3 206 3 container.4'),
cmd('/item replace block 3 206 3 container.0 from entity @s hotbar.3'),
cmd('/data get block 3 206 3 Items'),
cmd('/loot give @s loot minecraft:blocks/stone'),
cmd('/loot give @s loot minecraft:blocks/dirt'),
cmd('/loot insert 3 206 3 loot minecraft:blocks/oak_planks'),
cmd('/loot replace block 3 206 3 container.8 loot minecraft:blocks/cobblestone'),
cmd('/loot replace entity @s hotbar.5 loot minecraft:blocks/glass'),
cmd('/loot spawn 3 210 3 loot minecraft:blocks/stone'),
cmd('/loot give @s loot {pools:[{rolls:1,entries:[{type:"minecraft:item",name:"minecraft:apple",functions:[{type:"minecraft:set_count",count:4}]}]}]}'),
cmd('/setblock 2 205 2 minecraft:stone'),
cmd('/loot give @s mine 2 205 2'),
cmd('/loot give @s mine 2 205 2 mainhand'),
cmd('/loot give @s mine 2 205 2 minecraft:diamond_pickaxe[minecraft:enchantments={"minecraft:silk_touch":1}]'),
cmd('/data get block 3 206 3 Items'),
cmd('/clear @s minecraft:cobblestone 0'),
cmd('/clear @s minecraft:apple 0'),
cmd('/give @s minecraft:written_book[minecraft:written_book_content={title:"T",author:"A",pages:["p"]}]'),
cmd('/give @s minecraft:potion[minecraft:potion_contents={potion:"minecraft:swiftness"}] 2'),
cmd('/give @s minecraft:air'),
cmd('/give @s minecraft:stone 6401'),
cmd('/clear @s #minecraft:logs'),
cmd('/clear @s *[minecraft:custom_data]'),
cmd('/clear @s'),
*setup('/setblock 3 206 3 minecraft:air', '/setblock 2 205 2 minecraft:air', '/kill @e[type=minecraft:item]', '/gamemode creative'),
]
def world_misc():
return [
cmd('/setblock 1 210 1 minecraft:stone keep'),
cmd('/setblock 1 210 1 minecraft:dirt keep'),
cmd('/setblock 1 210 1 minecraft:dirt destroy'),
cmd('/setblock 1 210 1 minecraft:sand strict'),
cmd('/setblock 1 210 1 minecraft:air replace'),
cmd('/fill 0 210 0 2 212 2 minecraft:stone outline'),
cmd('/fill 0 210 0 2 212 2 minecraft:glass keep'),
cmd('/fill 0 210 0 2 212 2 minecraft:dirt replace #minecraft:base_stone_overworld'),
cmd('/fill 0 210 0 2 212 2 minecraft:air strict'),
cmd('/fill 0 210 0 100 300 100 minecraft:stone'),
cmd('/setblock 0 211 0 minecraft:oak_sign{front_text:{messages:["a","b","c","d"]}}'),
cmd('/data get block 0 211 0 front_text.messages'),
cmd('/clone 0 211 0 0 211 0 1 211 1 replace move'),
cmd('/clone 1 211 1 1 211 1 0 211 0 filtered minecraft:oak_sign'),
cmd('/clone 0 211 0 0 211 0 0 211 0'),
cmd('/clone 0 211 0 0 211 0 0 212 0 replace force'),
cmd('/clone from minecraft:overworld 0 211 0 0 211 0 to minecraft:overworld 2 211 2'),
cmd('/fill 0 210 0 2 212 2 minecraft:air'),
cmd('/fillbiome 0 200 0 15 215 15 minecraft:desert'),
cmd('/execute if biome 4 205 4 minecraft:desert'),
cmd('/fillbiome 0 200 0 15 215 15 minecraft:plains replace minecraft:desert'),
cmd('/fillbiome 0 200 0 15 215 15 minecraft:plains replace minecraft:desert'),
cmd('/fillbiome 0 0 0 1000 300 1000 minecraft:plains'),
cmd('/forceload query'),
cmd('/forceload add 0 0'),
cmd('/forceload add 0 0'),
cmd('/forceload query 0 0'),
cmd('/forceload query 40 40'),
cmd('/forceload add 32 32 47 47'),
cmd('/forceload query'),
cmd('/forceload remove 32 32'),
cmd('/forceload remove all'),
cmd('/forceload query'),
cmd('/forceload add 0 0 1000 1000'),
cmd('/particle minecraft:flame 4 210 4'),
cmd('/particle minecraft:flame 4 300 4'),
cmd('/particle minecraft:flame 4 300 4 0 0 0 0 1 force'),
cmd('/particle minecraft:flame 4 300 4 0 0 0 0 1 force @e[type=minecraft:pig]'),
cmd('/particle minecraft:dust{color:[1.0,0.0,0.0],scale:1.0} 4 210 4 0 0 0 0 5 force @s'),
cmd('/particle minecraft:block{block_state:"minecraft:stone"} 4 210 4 1 1 1 0.1 10 normal @a'),
cmd('/playsound minecraft:block.note_block.harp master @s'),
cmd('/playsound minecraft:block.note_block.harp record @s 4 210 4 1 2 0'),
cmd('/playsound minecraft:block.note_block.harp master @a 1000 210 1000'),
cmd('/stopsound @s'),
cmd('/stopsound @s master'),
cmd('/stopsound @s * minecraft:block.note_block.harp'),
cmd('/stopsound @s music minecraft:music.game'),
cmd('/swing @s'),
cmd('/swing @s offhand'),
cmd('/swing @e[type=minecraft:pig]'),
cmd('/summon minecraft:armor_stand 4.5 210 4.5 {NoGravity:1b,Tags:["w"],CustomName:{text:"Stand",color:"blue"}}'),
cmd('/swing @e[tag=w]'),
cmd('/summon minecraft:lightning_bolt 4.5 300 4.5'),
cmd('/summon minecraft:pig 4.5 210 4.5 {NoAI:1b,Invulnerable:1b,Tags:["w"],Passengers:[{id:"minecraft:chicken",NoAI:1b,Tags:["w"]}]}'),
cmd('/summon minecraft:pig 4.5 400 4.5'),
cmd('/summon minecraft:pig 30000000 210 4.5'),
cmd('/summon minecraft:player'),
cmd('/summon minecraft:marker 4.5 210 4.5 {Tags:["w","mk"]}'),
cmd('/gamemode spectator'),
cmd('/spectate @e[tag=mk,limit=1]'),
cmd('/spectate @e[type=minecraft:armor_stand,tag=w,limit=1]'),
cmd('/spectate @e[type=minecraft:pig,tag=w,limit=1] @s'),
cmd('/spectate @e[type=minecraft:chicken,tag=w,limit=1] Player'),
cmd('/spectate'),
cmd('/spectate @e[tag=nothing,limit=1]'),
cmd('/gamemode creative'),
# The waypoint manager is a HashSet of entities (identity hash order),
# so at most one transmitter at a time. Range changes take effect when
# the entity ticks.
cmd('/attribute @s minecraft:waypoint_transmit_range base set 0'),
cmd('/waypoint list'),
{'op': 'tick', 'n': 1},
cmd('/waypoint list'),
cmd('/attribute @e[type=minecraft:pig,tag=w,limit=1] minecraft:waypoint_transmit_range base set 100'),
cmd('/attribute @e[type=minecraft:pig,tag=w,limit=1] minecraft:waypoint_transmit_range get'),
cmd('/waypoint list'),
{'op': 'tick', 'n': 1},
cmd('/waypoint list'),
cmd('/waypoint modify @e[type=minecraft:pig,tag=w,limit=1] color gold'),
cmd('/waypoint modify @e[tag=mk,limit=1] color gold'),
cmd('/waypoint list'),
cmd('/waypoint modify @e[tag=w] color gold'),
cmd('/attribute @e[type=minecraft:armor_stand,tag=w,limit=1] minecraft:max_health get'),
cmd('/attribute @e[type=minecraft:armor_stand,tag=w,limit=1] minecraft:scale modifier add harness:big 1 add_multiplied_base'),
cmd('/attribute @e[type=minecraft:armor_stand,tag=w,limit=1] minecraft:scale get'),
cmd('/attribute @e[type=minecraft:armor_stand,tag=w,limit=1] minecraft:scale modifier add harness:big 1 add_value'),
cmd('/attribute @e[type=minecraft:armor_stand,tag=w,limit=1] minecraft:scale modifier value get harness:big'),
cmd('/attribute @e[type=minecraft:armor_stand,tag=w,limit=1] minecraft:scale modifier remove harness:big'),
cmd('/attribute @e[type=minecraft:armor_stand,tag=w,limit=1] minecraft:scale modifier remove harness:big'),
cmd('/attribute @e[type=minecraft:armor_stand,tag=w,limit=1] minecraft:attack_damage get'),
cmd('/attribute @e[tag=mk,limit=1] minecraft:scale get'),
cmd('/attribute @e[type=minecraft:pig,tag=w,limit=1] minecraft:waypoint_transmit_range base set 0'),
{'op': 'tick', 'n': 1},
cmd('/waypoint list'),
cmd('/waypoint modify @e[type=minecraft:pig,tag=w,limit=1] style set minecraft:bowtie'),
cmd('/waypoint list'),
{'op': 'tick', 'n': 1},
cmd('/waypoint list'),
cmd('/kill @e[type=minecraft:pig,tag=w]'),
{'op': 'tick', 'n': 1},
cmd('/waypoint list'),
{'op': 'tick', 'n': 25},
cmd('/waypoint list'),
cmd('/attribute @s minecraft:waypoint_transmit_range base reset'),
{'op': 'tick', 'n': 1},
cmd('/waypoint list'),
cmd('/dialog show @s minecraft:custom_options'),
cmd('/dialog show @s minecraft:nonexistent'),
cmd('/dialog show @s {type:"minecraft:confirmation",title:"Sure?",yes:{label:"Yes"},no:{label:"No"}}'),
cmd('/dialog show @s {type:"minecraft:notice"}'),
cmd('/dialog show @e[tag=w] minecraft:server_links'),
cmd('/dialog clear @e[tag=w]'),
cmd('/dialog clear @s'),
cmd('/spreadplayers 8 8 0 1 false @s'),
cmd('/spreadplayers 8 8 5 1 false @s'),
cmd('/spreadplayers 8 8 0 1 under 100 false @s'),
cmd('/kill @e[tag=w]'),
cmd('/tp @s 8.5 230 8.5 0 0'),
cmd('/teleport @s 8.5 230 8.5 facing 0 230 0'),
cmd('/teleport @s 8.5 230 8.5 facing entity @s'),
cmd('/tp @s 30000000 230 0'),
cmd('/tp 8.5 230 8.5'),
cmd('/rotate @s facing 0 230 0'),
cmd('/rotate @s ~10 ~'),
cmd('/tp @s 8.5 230 8.5 0 0'),
cmd('/locate biome minecraft:plains'),
cmd('/locate biome #minecraft:is_ocean'),
cmd('/locate structure minecraft:village_plains'),
cmd('/locate structure #minecraft:village'),
cmd('/locate structure minecraft:end_city'),
cmd('/locate poi minecraft:meeting'),
cmd('/place template minecraft:nonexistent 4 210 4'),
cmd('/place feature minecraft:oak 4 210 4'),
cmd('/place jigsaw minecraft:village/plains/town_centers minecraft:bottom 1 4 210 4'),
cmd('/place structure minecraft:nonexistent'),
*setup('/kill @e[type=!minecraft:player]', '/fill 0 200 0 15 228 15 air', '/forceload remove all', '/tp @s 8.5 230 8.5 0 0'),
{'op': 'tick', 'n': 25},
]
def progression():
return [
*setup('/gamemode survival', '/experience set @s 0 levels', '/experience set @s 0 points'),
cmd('/advancement grant @s only minecraft:story/mine_stone'),
cmd('/advancement grant @s only minecraft:story/mine_stone'),
cmd('/advancement revoke @s only minecraft:story/mine_stone'),
cmd('/advancement revoke @s only minecraft:story/mine_stone'),
cmd('/advancement grant @s only minecraft:story/upgrade_tools minecraft:stone_pickaxe'),
cmd('/advancement grant @s only minecraft:story/upgrade_tools minecraft:stone_pickaxe'),
cmd('/advancement grant @s only minecraft:story/upgrade_tools minecraft:nonexistent'),
cmd('/advancement revoke @s only minecraft:story/upgrade_tools minecraft:stone_pickaxe'),
cmd('/advancement grant @s until minecraft:story/smelt_iron'),
cmd('/advancement grant @s from minecraft:story/root'),
cmd('/advancement revoke @s through minecraft:story/iron_tools'),
cmd('/advancement grant @s everything'),
cmd('/advancement grant @s everything'),
cmd('/experience query @s levels'),
cmd('/experience query @s points'),
cmd('/advancement revoke @s everything'),
cmd('/advancement revoke @s everything'),
cmd('/advancement grant @s only minecraft:nonexistent'),
cmd('/recipe give @s minecraft:oak_planks'),
cmd('/recipe give @s minecraft:oak_planks'),
cmd('/recipe take @s minecraft:oak_planks'),
cmd('/recipe take @s minecraft:oak_planks'),
cmd('/recipe give @s *'),
cmd('/recipe give @s *'),
cmd('/recipe take @s *'),
cmd('/recipe take @s *'),
cmd('/experience add @s -5 levels'),
cmd('/experience add @s 1000'),
cmd('/experience query @s levels'),
cmd('/experience set @s 100 points'),
cmd('/experience set @s 1000 points'),
cmd('/experience add @e[type=!minecraft:player] 1'),
*setup('/gamemode creative'),
]
def functions_and_packs():
return [
cmd('/function minecraft:nonexistent'),
cmd('/function #minecraft:load'),
cmd('/function #minecraft:tick'),
cmd('/debug function minecraft:nonexistent'),
cmd('/schedule function minecraft:nonexistent 10'),
cmd('/schedule clear minecraft:nonexistent'),
cmd('/datapack list'),
cmd('/datapack list available'),
cmd('/datapack list enabled'),
cmd('/datapack enable vanilla'),
# Disabling vanilla reloads without its data; enable it again before
# anything observes the empty registries.
cmd('/datapack disable vanilla'),
{'op': 'tick', 'n': 20},
cmd('/datapack list enabled'),
cmd('/datapack enable vanilla'),
{'op': 'tick', 'n': 20},
cmd('/datapack list'),
cmd('/datapack enable "file/missing"'),
cmd('/datapack enable trade_rebalance'),
cmd('/datapack disable trade_rebalance'),
cmd('/reload'),
{'op': 'tick', 'n': 5, 'record': True},
]
def ticking():
return [
cmd('/tick query'),
cmd('/tick rate 40'),
cmd('/tick query'),
cmd('/tick rate 20'),
cmd('/tick freeze'),
cmd('/tick query'),
cmd('/tick freeze'),
cmd('/tick step'),
cmd('/tick step 5'),
cmd('/tick step stop'),
cmd('/tick step stop'),
cmd('/tick unfreeze'),
cmd('/tick unfreeze'),
cmd('/tick step'),
cmd('/tick sprint stop'),
cmd('/tick rate 1'),
cmd('/tick rate 20'),
cmd('/stopwatch create harness:t'),
cmd('/stopwatch restart harness:t'),
cmd('/stopwatch restart harness:missing'),
cmd('/stopwatch remove harness:t'),
cmd('/stopwatch remove harness:t'),
cmd('/stopwatch remove harness:a'),
cmd('/random value 1..100 harness:seq'),
cmd('/random value 1..100 harness:seq'),
cmd('/random roll 1..6 harness:dice'),
cmd('/random reset harness:seq'),
cmd('/random value 1..100 harness:seq'),
cmd('/random reset harness:seq 42'),
cmd('/random value 1..100 harness:seq'),
cmd('/random reset harness:seq 42 false false'),
cmd('/random value 1..100 harness:seq'),
cmd('/random reset *'),
cmd('/random value 1..100 harness:seq'),
cmd('/random roll 1..2147483647 harness:big'),
cmd('/random value -2147483648..2147483647 harness:big'),
cmd('/time query day'),
cmd('/time set 0'),
cmd('/time set day'),
cmd('/time set midnight'),
cmd('/time set sunset'),
cmd('/time add -500'),
cmd('/time set 1000'),
]
def compute():
return [
cmd('/compute default integer 5'),
cmd('/compute default integer {type:"minecraft:add",left:2,right:3}'),
cmd('/compute default integer {type:"minecraft:add",inputs:[2,3,4]}'),
cmd('/compute default integer {type:"minecraft:add",inputs:[2147483647,1]}'),
cmd('/compute default integer {type:"minecraft:mul",inputs:[6,7]}'),
cmd('/compute default integer {type:"minecraft:avg",inputs:[1,2,4]}'),
cmd('/compute default integer {type:"minecraft:div",left:7,right:2}'),
cmd('/compute default integer {type:"minecraft:div",left:7,right:0}'),
cmd('/compute default integer {type:"minecraft:mod",left:-7,right:3}'),
cmd('/compute default integer {type:"minecraft:floor_mod",left:-7,right:3}'),
cmd('/compute default integer {type:"minecraft:floor_div",left:-7,right:2}'),
cmd('/compute default integer {type:"minecraft:sub",left:-2147483648,right:1}'),
cmd('/compute default integer {type:"minecraft:pow",left:2,right:10}'),
cmd('/compute default integer {type:"minecraft:pow",base:2,exponent:10}'),
cmd('/compute default integer {type:"minecraft:pow",base:0,exponent:0}'),
cmd('/compute default integer {type:"minecraft:pow",base:2,exponent:40}'),
cmd('/compute default integer {type:"minecraft:max",values:[1,9,4]}'),
cmd('/compute default integer {type:"minecraft:max",inputs:[1,9,4]}'),
cmd('/compute default integer {type:"minecraft:min",inputs:[1,9,4]}'),
cmd('/compute default integer {type:"minecraft:abs",input:-4}'),
cmd('/compute default integer {type:"minecraft:abs",input:-2147483648}'),
cmd('/compute default integer {type:"minecraft:negate",input:4}'),
cmd('/compute default integer {type:"minecraft:from_float",input:2.7}'),
cmd('/compute default integer {type:"minecraft:from_float",input:-2.7}'),
cmd('/compute default integer {type:"minecraft:from_float",input:{type:"minecraft:div",left:1,right:0}}'),
cmd('/compute default integer {type:"minecraft:uniform",min:3,max:3}'),
cmd('/compute default integer {type:"minecraft:conditional",condition:{type:"minecraft:inverted",term:{type:"minecraft:match_block",blocks:"minecraft:stone"}},on_true:5}'),
cmd('/compute default integer {type:"minecraft:nope"}'),
cmd('/compute default integer minecraft:brewing/uses_default'),
cmd('/compute default integer minecraft:cooking/time_coal'),
cmd('/compute default integer minecraft:cooking/fast_burn_time_reduction_factor'),
cmd('/compute default integer minecraft:nonexistent'),
cmd('/compute default float 2.5'),
cmd('/compute default float 2.5 2'),
cmd('/compute default float 3'),
cmd('/compute default float -0.5'),
cmd('/compute default float 1e30'),
cmd('/compute default float {type:"minecraft:div",left:1,right:0}'),
cmd('/compute default float {type:"minecraft:mod",left:1,right:0}'),
cmd('/compute default float {type:"minecraft:sqrt",value:2}'),
cmd('/compute default float {type:"minecraft:sqrt",input:2}'),
cmd('/compute default float {type:"minecraft:sqrt",input:2} 1000'),
cmd('/compute default float {type:"minecraft:sqrt",input:-1}'),
cmd('/compute default float {type:"minecraft:mul",left:1.5,right:4}'),
cmd('/compute default float {type:"minecraft:mul",inputs:[1.5,4]}'),
cmd('/compute default float {type:"minecraft:sub",left:1.5,right:4}'),
cmd('/compute default float {type:"minecraft:floor",input:-1.5}'),
cmd('/compute default float {type:"minecraft:ceil",input:-1.5}'),
cmd('/compute default float {type:"minecraft:round",input:2.5}'),
cmd('/compute default float {type:"minecraft:round",input:-2.5}'),
cmd('/compute default float {type:"minecraft:truncate",input:-2.7}'),
cmd('/compute default float {type:"minecraft:from_int",input:3}'),
cmd('/compute default float {type:"minecraft:avg",inputs:[1,2]}'),
cmd('/compute default float {type:"minecraft:length",inputs:[3,4]}'),
cmd('/compute default float {type:"minecraft:pow",base:2,exponent:0.5} 100'),
cmd('/compute default float {type:"minecraft:sin",input:1} 1000'),
cmd('/compute default float {type:"minecraft:cos",input:1} 1000'),
cmd('/compute default float {type:"minecraft:abs",input:-3.25}'),
cmd('/compute default float {type:"minecraft:negate",input:3.25}'),
cmd('/compute default float {type:"minecraft:max",inputs:[]}'),
cmd('/compute default float minecraft:brewing/speed_default'),
cmd('/compute default float minecraft:cooking/speed_default 100'),
cmd('/compute block 8 229 8 float minecraft:cooking/speed_default'),
*setup('/setblock 8 229 8 minecraft:smoker'),
cmd('/compute block 8 229 8 float minecraft:cooking/speed_default'),
cmd('/compute block 8 229 8 integer minecraft:cooking/time_coal'),
*setup('/setblock 8 229 8 minecraft:composter[level=0]'),
cmd('/compute block 8 229 8 integer minecraft:compostable/low'),
*setup('/setblock 8 229 8 minecraft:air'),
cmd('/compute entity @s integer {type:"minecraft:add",inputs:[1,1]}'),
cmd('/compute entity @e[type=minecraft:pig,limit=1] integer 1'),
cmd('/compute block 8 400 8 integer 1'),
cmd('/compute block 100000 64 100000 integer 1'),
cmd('/execute store result score @s cmp run compute default integer 5'),
]
def social():
return [
*setup('/scoreboard objectives add trig trigger', '/scoreboard objectives add plain dummy'),
cmd('/trigger trig'),
cmd('/scoreboard players enable @s trig'),
cmd('/scoreboard players enable @s trig'),
cmd('/scoreboard players enable @s plain'),
cmd('/trigger trig'),
cmd('/trigger trig'),
cmd('/scoreboard players enable @s trig'),
cmd('/trigger trig add 5'),
cmd('/scoreboard players enable @s trig'),
cmd('/trigger trig set 3'),
cmd('/scoreboard players get @s trig'),
cmd('/trigger plain'),
cmd('/scoreboard players display name @s trig "Shown"'),
cmd('/scoreboard players display numberformat @s trig styled {color:"red"}'),
cmd('/scoreboard players display numberformat @s trig fixed "X"'),
cmd('/scoreboard players display numberformat @s trig blank'),
cmd('/scoreboard players display numberformat @s trig'),
cmd('/scoreboard objectives modify trig numberformat fixed "Y"'),
cmd('/scoreboard objectives modify trig displayautoupdate true'),
cmd('/scoreboard objectives setdisplay sidebar'),
cmd('/scoreboard objectives setdisplay sidebar.team.red trig'),
cmd('/scoreboard players operation @s trig = @s trig'),
cmd('/scoreboard players operation @s trig /= @s plain'),
cmd('/scoreboard players operation @s trig >< @s plain'),
cmd('/scoreboard players list'),
cmd('/scoreboard players reset @s'),
cmd('/scoreboard players list @s'),
cmd('/teammsg hello'),
cmd('/team add blue "Blue Team"'),
cmd('/team join blue'),
cmd('/teammsg hello team'),
cmd('/tm short'),
cmd('/team modify blue friendlyFire false'),
cmd('/team modify blue friendlyFire false'),
cmd('/team modify blue seeFriendlyInvisibles false'),
cmd('/team modify blue nametagVisibility hideForOtherTeams'),
cmd('/team modify blue deathMessageVisibility never'),
cmd('/team modify blue collisionRule pushOwnTeam'),
cmd('/team modify blue suffix " [B]"'),
cmd('/team modify blue displayName "Blues"'),
cmd('/team modify blue color reset'),
cmd('/team list blue'),
cmd('/team empty blue'),
cmd('/team empty blue'),
cmd('/team join blue fake1 fake2'),
cmd('/team list blue'),
cmd('/team leave fake1'),
cmd('/team remove blue'),
cmd('/team list'),
cmd('/msg @s'),
cmd('/tell Player hi'),
cmd('/w @a hi all'),
cmd('/me'),
cmd('/say @s says'),
cmd('/tellraw @s {"selector":"@s"}'),
cmd('/tellraw @s {"score":{"name":"@s","objective":"trig"}}'),
cmd('/tellraw @s {"nbt":"SelectedItemSlot","entity":"@s"}'),
cmd('/tellraw @s {"nbt":"Inventory","entity":"@s","plain":true}'),
cmd('/tellraw @s {"nbt":"value","storage":"harness:s","color":"red"}'),
cmd('/tellraw @s {"nbt":"nothing","entity":"@s"}'),
cmd('/tellraw @s {"text":"click","click_event":{"action":"run_command","command":"/say x"},"underlined":true}'),
cmd('/title @s title {"selector":"@s"}'),
cmd('/list uuids'),
cmd('/help'),
cmd('/help execute'),
cmd('/help scoreboard players'),
cmd('/help nonexistent'),
*setup('/scoreboard objectives remove trig', '/scoreboard objectives remove plain'),
]
def test_command():
# Horizon has no game test runner: `/test run|runmultiple|verify` of an
# existing instance and `/test create` are not compared.
return [
cmd('/test clearall'),
cmd('/test stop'),
cmd('/test pos'),
cmd('/test locate minecraft:always_pass'),
cmd('/test runclosest'),
cmd('/test resetclosest'),
cmd('/test runfailed'),
cmd('/test clearthese'),
cmd('/test runthese'),
cmd('/test runthat 2 true'),
cmd('/test runfailed true'),
cmd('/test resetthese'),
cmd('/test resetthat'),
cmd('/test clearthat'),
cmd('/test clearall 10'),
cmd('/test pos myPos'),
cmd('/test locate *'),
cmd('/test run minecraft:nothing*'),
cmd('/test locate nothing'),
*setup('/summon minecraft:marker 8 230 8 {Tags:["tp"]}'),
cmd('/execute as @e[tag=tp] run test pos'),
cmd('/execute positioned 0 230 0 run test pos'),
cmd('/execute as @e[tag=tp] run kill @e[tag=nothing]'),
cmd('/execute as @e[tag=tp] at @s run kill @e[tag=nothing]'),
cmd('/execute positioned 1 2 3 run kill @e[tag=nothing]'),
*setup('/kill @e[tag=tp]'),
]
def groups():
return [
('setup', group_setup()),
('client commands', client_commands()),
('game state', game_state()),
('player state', player_state()),
('blocks and border', world_blocks()),
('entities', entities()),
('scores, teams and bossbars', scores()),
('execute', execute()),
('items and loot', items_and_loot()),
('world', world_misc()),
('progression', progression()),
('functions and packs', functions_and_packs()),
('ticking and random', ticking()),
('compute', compute()),
('social and scoreboard', social()),
('test', test_command()),
]
+62
View File
@@ -0,0 +1,62 @@
#!/usr/bin/env python3
"""Generate crates/horizon-client/src/command/vanilla_order.rs: the order of
the children of each node of vanilla's command tree where Horizon's tree
registers them in a different order. Brigadier keeps children in
registration order, and /help (smart usage) lists them that way.
python3 tools/test_command_parse_parity.py # exports .local/command-parse-parity/tree.json
command_parse_fixture tree rust_tree.json # Horizon's tree with child order
generate_command_order.py VANILLA_TREE RUST_TREE
"""
import argparse
import json
from pathlib import Path
ROOT = Path(__file__).resolve().parents[1]
def main():
parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
parser.add_argument("vanilla", type=Path)
parser.add_argument("rust", type=Path)
parser.add_argument("--out", type=Path, default=ROOT / "crates/horizon-client/src/command/vanilla_order.rs")
args = parser.parse_args()
vanilla = json.loads(args.vanilla.read_text())
rust = json.loads(args.rust.read_text())
rows = []
def walk(v, r, path):
names = list(v.get("children", {}))
# GameRuleCommand registers the rules in a Reference2ObjectOpenHashMap's
# (identity hash) order, which changes from run to run.
if path == ["gamerule"]:
return
order = r.get("order", [])
shared = [n for n in names if n in order]
if shared != [n for n in order if n in names]:
rows.append((" ".join(path), shared))
for n in names:
if n in r.get("children", {}):
walk(v["children"][n], r["children"][n], path + [n])
walk(vanilla, rust, [])
if not rows or rows[0][0] != "":
raise SystemExit("expected the root's order to differ")
lines = [
"//! The order of node children in vanilla's command tree, for the nodes",
"//! where Horizon's tree registers them differently (path of node names",
"//! from the root, children in vanilla's order). Generated by",
"//! tools/generate_command_order.py; do not edit by hand.",
"",
"pub const ORDER: &[(&str, &[&str])] = &[",
]
for path, names in rows:
joined = ", ".join(f'"{n}"' for n in names)
lines.append(f' ("{path}", &[{joined}]),')
lines += ["];", ""]
args.out.write_text("\n".join(lines))
print(f"wrote {len(rows)} nodes to {args.out}")
if __name__ == "__main__":
main()
+18
View File
@@ -394,6 +394,23 @@ def main():
subprocess.run(['java', '-Xmx1G', '-cp', str(classes) + os.pathsep + dependencies,
'dev.horizonlab.parity.VanillaMobDataExporter', str(mob_data), str(jars['client'])],
check=True, stdout=log, stderr=subprocess.STDOUT, timeout=3600)
# Vanilla's built-in registries for in-game command parsing (mob effects,
# data component types, dialogs, block entity and tag members).
command_registries = root / 'command-registries.json'
command_oracle = oracle.with_name('VanillaCommandParseOracle.java')
command_sources = base.source_hashes([command_oracle])
if not (previous.get('command_registries_exporters_sha256') == command_sources and command_registries.exists()
and previous.get('server_sha256') == origin['server_sha256']):
export = lab.LOCAL / 'command-registries'; classes = export / 'classes'; classes.mkdir(parents=True, exist_ok=True)
dependencies = os.pathsep.join(map(str, [jars['server'], *libraries]))
with (root / 'command-registries-export.log').open('w') as log:
subprocess.run(['javac', '--release', str(lock['minecraft']['java_major']), '-proc:none',
'-cp', dependencies, '-d', str(classes), str(command_oracle)],
check=True, stdout=log, stderr=subprocess.STDOUT, timeout=3600)
subprocess.run(['java', '-Xmx1G', '-cp', str(classes) + os.pathsep + dependencies,
'dev.horizonlab.parity.VanillaCommandParseOracle', 'registries', str(export)],
check=True, stdout=log, stderr=subprocess.STDOUT, timeout=3600)
command_registries.write_bytes((export / 'registries.json').read_bytes())
creative = root / 'creative-tabs.json'
creative_oracle = oracle.with_name('VanillaCreativeTabsExporter.java')
creative_sources = base.source_hashes([creative_oracle])
@@ -425,6 +442,7 @@ def main():
'mob_data_exporters_sha256': mob_sources,
'entity_types_exporters_sha256': entity_types_sources,
'behaviour_exporters_sha256': behaviour_sources,
'command_registries_exporters_sha256': command_sources,
'model_states_sha256': lab.digest(model_states, 'sha256'), 'data_version': version['world_version'],
'facts_sha256': lab.digest(facts, 'sha256'),
'block_tags_sha256': lab.digest(root / 'block-tags.json', 'sha256'), 'resource_files': count})
+164
View File
@@ -0,0 +1,164 @@
#!/usr/bin/env python3
"""Compare Horizon's command execution with vanilla's real command implementations.
Java (VanillaCommandExecOracle) starts a stand-in integrated server: a real
MinecraftServer with a generated world, Commands.CommandSelection.INTEGRATED
and one single-player owner named Player. Rust runs the same script through
the Horizon client headless (HORIZON_COMMAND_SCRIPT). Both run each command as
the player through Commands.performPrefixedCommand and record every system or
chat message the player receives (text and resolved style: colour, bold,
italic, underlined, strikethrough, obfuscated) together with the results the
command reported to the player's CommandResultCallback. World, entity and item
changes are observed through probe commands whose feedback reports them
(execute if, clear with a zero count, data get, scoreboard queries...).
Messages that depend on time or a random UUID are compared after masking.
"""
import argparse
import json
import os
from pathlib import Path
import platform
import re
import shutil
import subprocess
import sys
try:
from . import lab, test_rust_parity as base
from . import command_exec_corpus as corpus_module
except ImportError:
import lab
import test_rust_parity as base
import command_exec_corpus as corpus_module
SEED = 1
def main():
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument('--prepare', action='store_true')
parser.add_argument('--limit', type=int, default=40, help='print at most this many mismatches')
parser.add_argument('--allow-gaps', action='store_true', help='report mismatches without failing')
parser.add_argument('--only', help='run only corpus groups whose name contains this')
args = parser.parse_args()
build = lab.LOCAL / 'command-exec-parity'
build.mkdir(parents=True, exist_ok=True)
report_path = build / 'report.json'
report_path.unlink(missing_ok=True)
if args.prepare:
lab.prepare()
lock, jars, libraries = base.verify_artifacts()
oracle = lab.ROOT / 'mods/horizon/src/test/java/dev/horizonlab/parity/VanillaCommandExecOracle.java'
classes = build / 'classes'
classes.mkdir(exist_ok=True)
dependency_path = os.pathsep.join(map(str, libraries))
def run(command, name, **kw):
with (build / (name + '.log')).open('w', encoding='utf-8') as log:
result = subprocess.run(list(map(str, command)), stdout=log, stderr=subprocess.STDOUT, **kw)
if result.returncode:
tail = (build / (name + '.log')).read_text(errors='replace')[-3000:]
sys.exit(f'{name} failed ({result.returncode}):\n{tail}')
groups = corpus_module.groups()
if args.only:
groups = [g for g in groups if args.only in g[0] or g[0] == 'setup']
script = []
for _, lines in groups:
script.extend(lines)
script_path = build / 'script.jsonl'
script_path.write_text(''.join(json.dumps(op, ensure_ascii=False) + '\n' for op in script), encoding='utf-8')
run(['javac', '--release', lock['minecraft']['java_major'], '-proc:none', '-cp', str(jars['server']) + os.pathsep + dependency_path, '-d', classes, oracle], 'compile-java')
vanilla_dir = build / 'vanilla'
shutil.rmtree(vanilla_dir, ignore_errors=True)
vanilla_dir.mkdir()
run(['java', '-Xmx3G', '-Duser.timezone=UTC', '-cp', os.pathsep.join([str(classes), str(jars['server']), dependency_path]),
'dev.horizonlab.parity.VanillaCommandExecOracle', vanilla_dir / 'universe', script_path, build / 'vanilla.jsonl', SEED], 'java', cwd=vanilla_dir)
run(['cargo', 'build', '--release', '-p', 'horizon-client', '--bin', 'horizon-client'], 'compile-rust', cwd=lab.ROOT)
metadata = json.loads(subprocess.check_output(['cargo', 'metadata', '--no-deps', '--format-version', '1'], cwd=lab.ROOT, text=True))
binary = Path(metadata['target_directory']) / 'release' / ('horizon-client.exe' if os.name == 'nt' else 'horizon-client')
rust_dir = build / 'rust'
shutil.rmtree(rust_dir, ignore_errors=True)
rust_dir.mkdir()
env = dict(os.environ, HORIZON_NO_AUDIO='1', HORIZON_COMMAND_SCRIPT=str(script_path), HORIZON_COMMAND_OUTPUT=str(build / 'rust.jsonl'))
run([binary, '--resources', lab.LOCAL / 'horizon-client/26.3', '--world', 'harness', '--seed', SEED, '--radius', 4], 'rust', cwd=rust_dir, env=env)
vanilla = [json.loads(l) for l in (build / 'vanilla.jsonl').open(encoding='utf-8')]
rust = [json.loads(l) for l in (build / 'rust.jsonl').open(encoding='utf-8')]
if len(vanilla) != len(rust):
sys.exit(f'record count differs: vanilla {len(vanilla)} rust {len(rust)}')
commands_by_group = []
index = 0
for name, lines in groups:
n = sum(1 for op in lines if (op['op'] == 'cmd' and op.get('record', True)) or (op['op'] == 'tick' and op.get('record')))
commands_by_group.append((name, index, index + n))
index += n
mismatches = []
for v, r in zip(vanilla, rust):
assert v['cmd'] == r['cmd'], (v['cmd'], r['cmd'])
kind = compare(v, r)
if kind:
mismatches.append({'kind': kind, 'cmd': v['cmd'], 'vanilla': v, 'rust': r})
(build / 'mismatches.jsonl').write_text(''.join(json.dumps(m, ensure_ascii=False) + '\n' for m in mismatches), encoding='utf-8')
summary = []
bad = {m['cmd'] for m in mismatches}
for name, lo, hi in commands_by_group:
failed = sum(1 for rec in vanilla[lo:hi] if rec['cmd'] in bad)
summary.append({'group': name, 'commands': hi - lo, 'mismatches': failed})
print(f'{name}: {hi - lo - failed}/{hi - lo} commands match', flush=True)
for m in mismatches[:args.limit]:
print(m['kind'], repr(m['cmd']))
print(' vanilla', render(m['vanilla'])[:400])
print(' rust ', render(m['rust'])[:400])
total = len(vanilla)
print(f'total: {total - len(mismatches)}/{total} commands match', flush=True)
report = {'schema': 1, 'minecraft': lock['minecraft']['version'], 'platform': platform.platform(), 'seed': SEED,
'commands': total, 'mismatches': len(mismatches), 'groups': summary,
'scope': 'Feedback and failure messages (text and resolved style), chat lines, and CommandResultCallback results of commands run by the single-player owner of an integrated server; world, entity and item effects through probe commands.'}
lab.write_json(report_path, report)
if mismatches and not args.allow_gaps:
sys.exit(f'{len(mismatches)} command execution mismatches; see {build}')
print(f'Command execution parity report: {report_path}')
MASKS = [
(re.compile(r'debug-trace-\d{4}-\d\d-\d\d_\d\d\.\d\d\.\d\d\.txt'), 'debug-trace-<time>.txt'),
(re.compile(r'after [0-9.]+ second\(s\) and \d+ tick\(s\) \([0-9.,NaInfity]+ tick\(s\) per second\)'), 'after <time>'),
(re.compile(r'Average time per tick: [0-9.]+ms'), 'Average time per tick: <ms>'),
(re.compile(r'P50: [0-9.]+ms P95: [0-9.]+ms P99: [0-9.]+ms'), 'P50: <ms> P95: <ms> P99: <ms>'),
(re.compile(r'debug/client-[0-9_.-]+\.(jfr|json)'), 'debug/client-<time>'),
]
GAMERULES = re.compile(r'/gamerule \(([^)]*)\)')
def masked(record):
text = json.dumps(record['messages'], ensure_ascii=False)
# GameRuleCommand registers the rules in identity-hash order, different
# in every JVM: compare /help's gamerule alternatives as a set.
text = GAMERULES.sub(lambda m: '/gamerule (' + '|'.join(sorted(m.group(1).split('|'))) + ')', text)
for pattern, replacement in MASKS:
text = pattern.sub(replacement, text)
return text
def compare(v, r):
if masked(v) != masked(r):
return 'messages'
if v['results'] != r['results']:
if v['cmd'].startswith('/debug stop'):
return None
return 'results'
return None
def render(record):
lines = [''.join(span[0] for span in m) for m in record['messages']]
return json.dumps({'messages': lines, 'styles': [[span[1] for span in m] for m in record['messages']], 'results': record['results']}, ensure_ascii=False)
if __name__ == '__main__':
main()