Merge branch 'parity/hud' into parity-base
This commit is contained in:
@@ -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);
|
||||
}
|
||||
|
||||
@@ -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 {
|
||||
|
||||
@@ -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| {
|
||||
|
||||
@@ -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)),
|
||||
|
||||
@@ -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",
|
||||
],
|
||||
),
|
||||
];
|
||||
@@ -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
|
||||
}
|
||||
|
||||
@@ -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 {
|
||||
|
||||
@@ -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> {
|
||||
|
||||
@@ -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"]);
|
||||
}
|
||||
}
|
||||
@@ -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| {
|
||||
|
||||
@@ -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(())
|
||||
}
|
||||
}
|
||||
@@ -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, ®istry]))?;
|
||||
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,
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -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
@@ -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(¤t) && 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
|
||||
}
|
||||
|
||||
@@ -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
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -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);
|
||||
|
||||
@@ -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 {
|
||||
|
||||
@@ -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;
|
||||
|
||||
@@ -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);
|
||||
|
||||
@@ -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();
|
||||
|
||||
@@ -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));
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -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)))
|
||||
}
|
||||
|
||||
|
||||
@@ -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>(
|
||||
|
||||
@@ -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,
|
||||
|
||||
@@ -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;
|
||||
|
||||
@@ -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| {
|
||||
|
||||
@@ -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]
|
||||
|
||||
@@ -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,
|
||||
|
||||
@@ -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, "")
|
||||
|
||||
@@ -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)
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -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);
|
||||
}
|
||||
});
|
||||
}
|
||||
}
|
||||
@@ -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()),
|
||||
]
|
||||
@@ -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()
|
||||
@@ -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})
|
||||
|
||||
@@ -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()
|
||||
Reference in New Issue
Block a user