173a55e608
93 pub items (78 functions and methods, 14 constants, 1 struct) in horizon-client, horizon-world, horizon-core, horizon-friends and horizon-server-files had no caller anywhere in the repository: not in the crate, the other crates, the examples, the tests or the binaries. rustc can't flag them because horizon-client and the others are libraries, where a pub item counts as used. The imports and the private helpers only they used go with them (title.rs date_string, goals.rs flag_index). Also drops the #[allow(dead_code)]/#[allow(unused)] items that only hid dead code: chat_debug_fill, merchant_title and Goals::locked_by had no caller, and four stubs (_keep, _unused, _rule_kind, const _) existed only to keep an import used. LightTables::from_parts is used by its tests, so it is #[cfg(test)] instead of allowed. Protocol id tables and entity data serializer ids stay: they mirror vanilla's registries in full. The launcher's three unused items are left for a launcher PR. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
558 lines
20 KiB
Rust
558 lines
20 KiB
Rust
//! The vanilla command tree (Commands.java registrations) for the commands
|
|
//! Horizon implements. Leaves carry command ids that the game executes;
|
|
//! mode keywords are read back from the parsed literals.
|
|
use super::{
|
|
Dispatcher,
|
|
args::{ArgType, Resource, integer},
|
|
};
|
|
use crate::gamerules::{RULES, Value};
|
|
|
|
/// Permission levels (Commands.LEVEL_*).
|
|
pub const ALL: u8 = 0;
|
|
pub const GAMEMASTERS: u8 = 2;
|
|
|
|
pub const PLAYERS: ArgType = ArgType::Entity {
|
|
single: false,
|
|
players: true,
|
|
};
|
|
pub const PLAYER: ArgType = ArgType::Entity {
|
|
single: true,
|
|
players: true,
|
|
};
|
|
pub const ENTITIES: ArgType = ArgType::Entity {
|
|
single: false,
|
|
players: false,
|
|
};
|
|
pub const ENTITY: ArgType = ArgType::Entity {
|
|
single: true,
|
|
players: false,
|
|
};
|
|
|
|
pub const DIFFICULTIES: [&str; 4] = ["peaceful", "easy", "normal", "hard"];
|
|
|
|
pub fn build() -> Dispatcher {
|
|
build_with(true)
|
|
}
|
|
/// The tree Commands registers; `dev` adds the commands vanilla only
|
|
/// registers in development builds (raid, warden_spawn_tracker).
|
|
pub fn build_with(dev: bool) -> Dispatcher {
|
|
let mut d = registered(dev);
|
|
apply_vanilla_order(&mut d);
|
|
d
|
|
}
|
|
/// The tree in the order Horizon's code registers it, before
|
|
/// [`vanilla_order`](super::vanilla_order) puts children in vanilla's order
|
|
/// (tools/generate_command_order.py compares the two).
|
|
pub fn registered(dev: bool) -> Dispatcher {
|
|
let mut d = Dispatcher::new();
|
|
let root = 0;
|
|
|
|
advancement(&mut d, root);
|
|
|
|
// help [<command>]
|
|
let help = d.literal(root, "help");
|
|
d.executes(help, "help");
|
|
let c = d.argument(help, "command", ArgType::Greedy);
|
|
d.executes(c, "help");
|
|
|
|
// gamemode <gamemode> [<target>]
|
|
let gm = d.literal(root, "gamemode");
|
|
d.requires(gm, GAMEMASTERS);
|
|
let mode = d.argument(gm, "gamemode", ArgType::GameMode);
|
|
d.executes(mode, "gamemode");
|
|
let t = d.argument(mode, "target", PLAYERS);
|
|
d.executes(t, "gamemode");
|
|
|
|
let dgm = d.literal(root, "defaultgamemode");
|
|
d.requires(dgm, GAMEMASTERS);
|
|
let mode = d.argument(dgm, "gamemode", ArgType::GameMode);
|
|
d.executes(mode, "defaultgamemode");
|
|
|
|
// give <targets> <item> [<count>]
|
|
let give = d.literal(root, "give");
|
|
d.requires(give, GAMEMASTERS);
|
|
let targets = d.argument(give, "targets", PLAYERS);
|
|
let item = d.argument(targets, "item", ArgType::Item);
|
|
d.executes(item, "give");
|
|
let count = d.argument(item, "count", integer(1));
|
|
d.executes(count, "give");
|
|
|
|
// teleport / tp
|
|
let tp = d.literal(root, "teleport");
|
|
d.requires(tp, GAMEMASTERS);
|
|
let loc = d.argument(tp, "location", ArgType::Vec3 { center: true });
|
|
d.executes(loc, "teleport.location");
|
|
let dest = d.argument(tp, "destination", ENTITY);
|
|
d.executes(dest, "teleport.destination");
|
|
let targets = d.argument(tp, "targets", ENTITIES);
|
|
let loc = d.argument(targets, "location", ArgType::Vec3 { center: true });
|
|
d.executes(loc, "teleport.targets.location");
|
|
let rot = d.argument(loc, "rotation", ArgType::Rotation);
|
|
d.executes(rot, "teleport.targets.location");
|
|
let facing = d.literal(loc, "facing");
|
|
let fe = d.literal(facing, "entity");
|
|
let fent = d.argument(fe, "facingEntity", ENTITY);
|
|
d.executes(fent, "teleport.targets.location");
|
|
let anchor = d.argument(fent, "facingAnchor", ArgType::Anchor);
|
|
d.executes(anchor, "teleport.targets.location");
|
|
let floc = d.argument(facing, "facingLocation", ArgType::Vec3 { center: true });
|
|
d.executes(floc, "teleport.targets.location");
|
|
let dest = d.argument(targets, "destination", ENTITY);
|
|
d.executes(dest, "teleport.targets.destination");
|
|
let alias = d.literal(root, "tp");
|
|
d.requires(alias, GAMEMASTERS);
|
|
d.redirect(alias, tp);
|
|
|
|
// time: clock nodes for the dimension's default clock, plus `of <clock>`.
|
|
let time = d.literal(root, "time");
|
|
d.requires(time, GAMEMASTERS);
|
|
clock_nodes(&mut d, time);
|
|
let query = d.literal(time, "query");
|
|
let gt = d.literal(query, "gametime");
|
|
d.executes(gt, "time.query.gametime");
|
|
let of = d.literal(time, "of");
|
|
let clock = d.argument(of, "clock", ArgType::Resource(Resource::Clock));
|
|
clock_nodes(&mut d, clock);
|
|
|
|
// weather (clear|rain|thunder) [<duration>]
|
|
let weather = d.literal(root, "weather");
|
|
d.requires(weather, GAMEMASTERS);
|
|
for kind in ["clear", "rain", "thunder"] {
|
|
let k = d.literal(weather, kind);
|
|
d.executes(k, "weather");
|
|
let dur = d.argument(k, "duration", ArgType::Time { min: 1 });
|
|
d.executes(dur, "weather");
|
|
}
|
|
|
|
if dev {
|
|
// raid start <omenlvl> | stop | check | sound <type> | spawnleader | setomen <level> | glow
|
|
let raid = d.literal(root, "raid");
|
|
d.requires(raid, 3);
|
|
let start = d.literal(raid, "start");
|
|
let level = d.argument(start, "omenlvl", integer(0));
|
|
d.executes(level, "raid.start");
|
|
for (name, id) in [
|
|
("stop", "raid.stop"),
|
|
("check", "raid.check"),
|
|
("spawnleader", "raid.spawnleader"),
|
|
("glow", "raid.glow"),
|
|
] {
|
|
let n = d.literal(raid, name);
|
|
d.executes(n, id);
|
|
}
|
|
let sound = d.literal(raid, "sound");
|
|
let kind = d.argument(sound, "type", ArgType::Greedy);
|
|
d.executes(kind, "raid.sound");
|
|
let setomen = d.literal(raid, "setomen");
|
|
let level = d.argument(setomen, "level", integer(0));
|
|
d.executes(level, "raid.setomen");
|
|
}
|
|
|
|
// kill [<targets>]
|
|
let kill = d.literal(root, "kill");
|
|
d.requires(kill, GAMEMASTERS);
|
|
d.executes(kill, "kill");
|
|
let t = d.argument(kill, "targets", ENTITIES);
|
|
d.executes(t, "kill");
|
|
|
|
// effect clear [<targets> [<effect>]] | give <targets> <effect> [<seconds>|infinite [<amplifier> [<hideParticles>]]]
|
|
let effect = d.literal(root, "effect");
|
|
d.requires(effect, GAMEMASTERS);
|
|
let clear = d.literal(effect, "clear");
|
|
d.executes(clear, "effect.clear");
|
|
let t = d.argument(clear, "targets", ENTITIES);
|
|
d.executes(t, "effect.clear");
|
|
let e = d.argument(t, "effect", ArgType::Resource(Resource::Effect));
|
|
d.executes(e, "effect.clear");
|
|
let give = d.literal(effect, "give");
|
|
let t = d.argument(give, "targets", ENTITIES);
|
|
let e = d.argument(t, "effect", ArgType::Resource(Resource::Effect));
|
|
d.executes(e, "effect.give");
|
|
let seconds = d.argument(
|
|
e,
|
|
"seconds",
|
|
ArgType::Integer {
|
|
min: 1,
|
|
max: 1_000_000,
|
|
},
|
|
);
|
|
let infinite = d.literal(e, "infinite");
|
|
for duration in [seconds, infinite] {
|
|
d.executes(duration, "effect.give");
|
|
let amp = d.argument(duration, "amplifier", ArgType::Integer { min: 0, max: 255 });
|
|
d.executes(amp, "effect.give");
|
|
let hide = d.argument(amp, "hideParticles", ArgType::Bool);
|
|
d.executes(hide, "effect.give");
|
|
}
|
|
|
|
// enchant <targets> <enchantment> [<level>]
|
|
let enchant = d.literal(root, "enchant");
|
|
d.requires(enchant, GAMEMASTERS);
|
|
let t = d.argument(enchant, "targets", ENTITIES);
|
|
let e = d.argument(t, "enchantment", ArgType::Resource(Resource::Enchantment));
|
|
d.executes(e, "enchant");
|
|
let level = d.argument(e, "level", integer(0));
|
|
d.executes(level, "enchant");
|
|
|
|
// summon <entity> [<pos>] [<nbt>]
|
|
let summon = d.literal(root, "summon");
|
|
d.requires(summon, GAMEMASTERS);
|
|
let e = d.argument(summon, "entity", ArgType::Resource(Resource::EntityType));
|
|
d.suggests(e, super::Suggests::SummonableEntities);
|
|
d.executes(e, "summon");
|
|
let pos = d.argument(e, "pos", ArgType::Vec3 { center: true });
|
|
d.executes(pos, "summon");
|
|
let nbt = d.argument(pos, "nbt", ArgType::Nbt);
|
|
d.executes(nbt, "summon");
|
|
|
|
// setblock <pos> <block> [destroy|keep|replace|strict]
|
|
let sb = d.literal(root, "setblock");
|
|
d.requires(sb, GAMEMASTERS);
|
|
let pos = d.argument(sb, "pos", ArgType::BlockPos);
|
|
let block = d.argument(pos, "block", ArgType::BlockState);
|
|
d.executes(block, "setblock");
|
|
for m in ["destroy", "keep", "replace", "strict"] {
|
|
let l = d.literal(block, m);
|
|
d.executes(l, "setblock");
|
|
}
|
|
|
|
// fill <from> <to> <block> [modes]
|
|
let fill = d.literal(root, "fill");
|
|
d.requires(fill, GAMEMASTERS);
|
|
let from = d.argument(fill, "from", ArgType::BlockPos);
|
|
let to = d.argument(from, "to", ArgType::BlockPos);
|
|
let block = d.argument(to, "block", ArgType::BlockState);
|
|
fill_modes(&mut d, block);
|
|
let replace = d.literal(block, "replace");
|
|
d.executes(replace, "fill");
|
|
let filter = d.argument(replace, "filter", ArgType::BlockPredicate);
|
|
fill_modes(&mut d, filter);
|
|
let keep = d.literal(block, "keep");
|
|
d.executes(keep, "fill");
|
|
|
|
// clone [from <dim>] <begin> <end> [to <dim>] <destination> [strict] [mask] [mode]
|
|
let clone = d.literal(root, "clone");
|
|
d.requires(clone, GAMEMASTERS);
|
|
clone_begin(&mut d, clone);
|
|
let from = d.literal(clone, "from");
|
|
let dim = d.argument(from, "sourceDimension", ArgType::Dimension);
|
|
clone_begin(&mut d, dim);
|
|
|
|
// experience / xp
|
|
let xp = d.literal(root, "experience");
|
|
d.requires(xp, GAMEMASTERS);
|
|
for (op, min) in [("add", i32::MIN), ("set", 0)] {
|
|
let o = d.literal(xp, op);
|
|
let t = d.argument(o, "target", PLAYERS);
|
|
let amount = d.argument(t, "amount", integer(min));
|
|
d.executes(amount, "experience");
|
|
for unit in ["points", "levels"] {
|
|
let u = d.literal(amount, unit);
|
|
d.executes(u, "experience");
|
|
}
|
|
}
|
|
let q = d.literal(xp, "query");
|
|
let t = d.argument(q, "target", PLAYER);
|
|
for unit in ["points", "levels"] {
|
|
let u = d.literal(t, unit);
|
|
d.executes(u, "experience");
|
|
}
|
|
let alias = d.literal(root, "xp");
|
|
d.requires(alias, GAMEMASTERS);
|
|
d.redirect(alias, xp);
|
|
|
|
// gamerule <rule> [<value>] (short and namespaced names)
|
|
let gr = d.literal(root, "gamerule");
|
|
d.requires(gr, GAMEMASTERS);
|
|
for rule in RULES {
|
|
for name in [rule.name.to_owned(), format!("minecraft:{}", rule.name)] {
|
|
let r = d.literal(gr, &name);
|
|
d.executes(r, "gamerule");
|
|
let ty = match rule.default {
|
|
Value::Bool(_) => ArgType::Bool,
|
|
Value::Int(_) => ArgType::Integer {
|
|
min: rule.min,
|
|
max: rule.max,
|
|
},
|
|
};
|
|
let v = d.argument(r, "value", ty);
|
|
d.executes(v, "gamerule");
|
|
}
|
|
}
|
|
|
|
// difficulty [<difficulty>]
|
|
let diff = d.literal(root, "difficulty");
|
|
d.requires(diff, GAMEMASTERS);
|
|
d.executes(diff, "difficulty");
|
|
for name in DIFFICULTIES {
|
|
let l = d.literal(diff, name);
|
|
d.executes(l, "difficulty");
|
|
}
|
|
|
|
// seed and version: everyone in the integrated server.
|
|
let seed = d.literal(root, "seed");
|
|
d.executes(seed, "seed");
|
|
let version = d.literal(root, "version");
|
|
d.executes(version, "version");
|
|
|
|
// spawnpoint [<targets>] [<pos>] [<rotation>]
|
|
let sp = d.literal(root, "spawnpoint");
|
|
d.requires(sp, GAMEMASTERS);
|
|
d.executes(sp, "spawnpoint");
|
|
let t = d.argument(sp, "targets", PLAYERS);
|
|
d.executes(t, "spawnpoint");
|
|
let pos = d.argument(t, "pos", ArgType::BlockPos);
|
|
d.executes(pos, "spawnpoint");
|
|
let rot = d.argument(pos, "rotation", ArgType::Rotation);
|
|
d.executes(rot, "spawnpoint");
|
|
|
|
// setworldspawn [<pos>] [<rotation>]
|
|
let ws = d.literal(root, "setworldspawn");
|
|
d.requires(ws, GAMEMASTERS);
|
|
d.executes(ws, "setworldspawn");
|
|
let pos = d.argument(ws, "pos", ArgType::BlockPos);
|
|
d.executes(pos, "setworldspawn");
|
|
let rot = d.argument(pos, "rotation", ArgType::Rotation);
|
|
d.executes(rot, "setworldspawn");
|
|
|
|
// clear [<targets>] [<item>] [<maxCount>]
|
|
let clear = d.literal(root, "clear");
|
|
d.requires(clear, GAMEMASTERS);
|
|
d.executes(clear, "clear");
|
|
let t = d.argument(clear, "targets", PLAYERS);
|
|
d.executes(t, "clear");
|
|
let item = d.argument(t, "item", ArgType::ItemPredicate);
|
|
d.executes(item, "clear");
|
|
let max = d.argument(item, "maxCount", integer(0));
|
|
d.executes(max, "clear");
|
|
|
|
// locate (structure|biome) <...>
|
|
let locate = d.literal(root, "locate");
|
|
d.requires(locate, GAMEMASTERS);
|
|
let s = d.literal(locate, "structure");
|
|
let a = d.argument(
|
|
s,
|
|
"structure",
|
|
ArgType::ResOrTagKey("minecraft:worldgen/structure"),
|
|
);
|
|
d.executes(a, "locate.structure");
|
|
let b = d.literal(locate, "biome");
|
|
let a = d.argument(b, "biome", ArgType::ResOrTag("minecraft:worldgen/biome"));
|
|
d.executes(a, "locate.biome");
|
|
let p = d.literal(locate, "poi");
|
|
let a = d.argument(
|
|
p,
|
|
"poi",
|
|
ArgType::ResOrTag("minecraft:point_of_interest_type"),
|
|
);
|
|
d.executes(a, "locate.poi");
|
|
|
|
if dev {
|
|
// warden_spawn_tracker (clear | set <warning_level>)
|
|
let tracker = d.literal(root, "warden_spawn_tracker");
|
|
d.requires(tracker, GAMEMASTERS);
|
|
let clear = d.literal(tracker, "clear");
|
|
d.executes(clear, "warden_spawn_tracker.clear");
|
|
let set = d.literal(tracker, "set");
|
|
let level = d.argument(set, "warning_level", ArgType::Integer { min: 0, max: 4 });
|
|
d.executes(level, "warden_spawn_tracker.set");
|
|
}
|
|
|
|
// say / me / msg / list
|
|
let say = d.literal(root, "say");
|
|
d.requires(say, GAMEMASTERS);
|
|
let m = d.argument(say, "message", ArgType::Message);
|
|
d.executes(m, "say");
|
|
let me = d.literal(root, "me");
|
|
let m = d.argument(me, "action", ArgType::Message);
|
|
d.executes(m, "me");
|
|
let msg = d.literal(root, "msg");
|
|
let t = d.argument(msg, "targets", PLAYERS);
|
|
let m = d.argument(t, "message", ArgType::Message);
|
|
d.executes(m, "msg");
|
|
for alias in ["tell", "w"] {
|
|
let a = d.literal(root, alias);
|
|
d.redirect(a, msg);
|
|
}
|
|
let list = d.literal(root, "list");
|
|
d.executes(list, "list");
|
|
let uuids = d.literal(list, "uuids");
|
|
d.executes(uuids, "list");
|
|
|
|
// tellraw <targets> <message>
|
|
let tellraw = d.literal(root, "tellraw");
|
|
d.requires(tellraw, GAMEMASTERS);
|
|
let t = d.argument(tellraw, "targets", PLAYERS);
|
|
let m = d.argument(t, "message", ArgType::Component);
|
|
d.executes(m, "tellraw");
|
|
|
|
// title <targets> clear|reset|title|subtitle|actionbar <title>|times <in> <stay> <out>
|
|
let title = d.literal(root, "title");
|
|
d.requires(title, GAMEMASTERS);
|
|
let t = d.argument(title, "targets", PLAYERS);
|
|
for mode in ["clear", "reset"] {
|
|
let l = d.literal(t, mode);
|
|
d.executes(l, "title");
|
|
}
|
|
for mode in ["title", "subtitle", "actionbar"] {
|
|
let l = d.literal(t, mode);
|
|
let c = d.argument(l, "title", ArgType::Component);
|
|
d.executes(c, "title");
|
|
}
|
|
let times = d.literal(t, "times");
|
|
let fade_in = d.argument(times, "fadeIn", ArgType::Time { min: 0 });
|
|
let stay = d.argument(fade_in, "stay", ArgType::Time { min: 0 });
|
|
let fade_out = d.argument(stay, "fadeOut", ArgType::Time { min: 0 });
|
|
d.executes(fade_out, "title");
|
|
|
|
super::tree_scoreboard::register(&mut d, root);
|
|
super::tree_data::register(&mut d, root);
|
|
super::tree_execute::register(&mut d, root);
|
|
super::tree_misc::register(&mut d, root);
|
|
super::tree_world::register(&mut d, root);
|
|
super::tree_extra::register(&mut d, root);
|
|
d
|
|
}
|
|
|
|
/// AdvancementCommands: grant|revoke <targets> only|from|until|through
|
|
/// <advancement> | everything; `only` takes an optional criterion.
|
|
fn advancement(d: &mut Dispatcher, root: usize) {
|
|
let adv = d.literal(root, "advancement");
|
|
d.requires(adv, GAMEMASTERS);
|
|
for action in ["grant", "revoke"] {
|
|
let a = d.literal(adv, action);
|
|
let t = d.argument(a, "targets", PLAYERS);
|
|
for mode in ["only", "from", "until", "through"] {
|
|
let m = d.literal(t, mode);
|
|
let id = d.argument(m, "advancement", ArgType::ResKey("minecraft:advancement"));
|
|
d.executes(id, "advancement");
|
|
if mode == "only" {
|
|
let c = d.argument(id, "criterion", ArgType::Greedy);
|
|
d.suggests(c, super::Suggests::AdvancementCriteria);
|
|
d.executes(c, "advancement");
|
|
}
|
|
}
|
|
let e = d.literal(t, "everything");
|
|
d.executes(e, "advancement");
|
|
}
|
|
}
|
|
|
|
/// TimeCommand.addClockNodes.
|
|
fn clock_nodes(d: &mut Dispatcher, node: usize) {
|
|
let set = d.literal(node, "set");
|
|
let t = d.argument(set, "time", ArgType::Time { min: 0 });
|
|
d.executes(t, "time.set");
|
|
let marker = d.argument(set, "timemarker", ArgType::Id("time_markers"));
|
|
d.suggests(marker, super::Suggests::TimeMarkers);
|
|
d.executes(marker, "time.set.marker");
|
|
let add = d.literal(node, "add");
|
|
let t = d.argument(add, "time", ArgType::Time { min: i32::MIN });
|
|
d.executes(t, "time.add");
|
|
let pause = d.literal(node, "pause");
|
|
d.executes(pause, "time.pause");
|
|
let resume = d.literal(node, "resume");
|
|
d.executes(resume, "time.resume");
|
|
let rate = d.literal(node, "rate");
|
|
let r = d.argument(
|
|
rate,
|
|
"rate",
|
|
ArgType::Float {
|
|
min: 1.0e-5,
|
|
max: 1000.0,
|
|
},
|
|
);
|
|
d.executes(r, "time.rate");
|
|
let query = d.literal(node, "query");
|
|
let time = d.literal(query, "time");
|
|
d.executes(time, "time.query.time");
|
|
let tl = d.argument(query, "timeline", ArgType::Resource(Resource::Timeline));
|
|
d.executes(tl, "time.query.timeline");
|
|
let rep = d.literal(tl, "repetition");
|
|
d.executes(rep, "time.query.repetition");
|
|
}
|
|
/// FillCommand.wrapWithMode.
|
|
fn fill_modes(d: &mut Dispatcher, node: usize) {
|
|
d.executes(node, "fill");
|
|
for m in ["outline", "hollow", "destroy", "strict"] {
|
|
let l = d.literal(node, m);
|
|
d.executes(l, "fill");
|
|
}
|
|
}
|
|
fn clone_begin(d: &mut Dispatcher, node: usize) {
|
|
let begin = d.argument(node, "begin", ArgType::BlockPos);
|
|
let end = d.argument(begin, "end", ArgType::BlockPos);
|
|
clone_destination(d, end);
|
|
let to = d.literal(end, "to");
|
|
let dim = d.argument(to, "targetDimension", ArgType::Dimension);
|
|
clone_destination(d, dim);
|
|
}
|
|
fn clone_destination(d: &mut Dispatcher, node: usize) {
|
|
let dest = d.argument(node, "destination", ArgType::BlockPos);
|
|
clone_mask(d, dest);
|
|
let strict = d.literal(dest, "strict");
|
|
clone_mask(d, strict);
|
|
}
|
|
fn clone_mask(d: &mut Dispatcher, node: usize) {
|
|
d.executes(node, "clone");
|
|
for m in ["replace", "masked"] {
|
|
let l = d.literal(node, m);
|
|
clone_mode(d, l);
|
|
}
|
|
let filtered = d.literal(node, "filtered");
|
|
let filter = d.argument(filtered, "filter", ArgType::BlockPredicate);
|
|
clone_mode(d, filter);
|
|
}
|
|
fn clone_mode(d: &mut Dispatcher, node: usize) {
|
|
d.executes(node, "clone");
|
|
for m in ["force", "move", "normal"] {
|
|
let l = d.literal(node, m);
|
|
d.executes(l, "clone");
|
|
}
|
|
}
|
|
/// 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)
|
|
}
|
|
/// The tree of a release integrated server (no development commands).
|
|
pub fn release_dispatcher() -> &'static Dispatcher {
|
|
static TREE: std::sync::OnceLock<Dispatcher> = std::sync::OnceLock::new();
|
|
TREE.get_or_init(|| build_with(false))
|
|
}
|