6734879ff7
Formats the overnight parity work, fixes the lints it introduced, and updates the LAN bot test and mob AI probe for fields added on the other side of the merges (the bot test also set a field that never existed). Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
1872 lines
68 KiB
Rust
1872 lines
68 KiB
Rust
//! Argument types (Brigadier's and Minecraft's `ArgumentType`s): parsing with
|
|
//! the vanilla error messages and completion suggestions.
|
|
use super::{CmdResult, CommandError, Context, Reader, SuggestionsBuilder};
|
|
use std::collections::BTreeMap;
|
|
|
|
/// Registry contents and source state used to validate and complete arguments.
|
|
#[derive(Clone, Debug, Default)]
|
|
pub struct Registries {
|
|
/// Permission level of the command source.
|
|
pub permission: u8,
|
|
pub items: Vec<String>,
|
|
pub item_tags: Vec<String>,
|
|
/// Block id -> (property, allowed values).
|
|
pub blocks: BTreeMap<String, Vec<(String, Vec<String>)>>,
|
|
pub block_tags: Vec<String>,
|
|
/// Entity types that `summon` can create.
|
|
pub summonable: Vec<String>,
|
|
/// Every entity type (selector `type=`).
|
|
pub entity_types: Vec<String>,
|
|
pub effects: Vec<String>,
|
|
pub enchantments: Vec<String>,
|
|
pub structures: Vec<String>,
|
|
pub biomes: Vec<String>,
|
|
pub dimensions: Vec<String>,
|
|
pub clocks: Vec<String>,
|
|
pub timelines: Vec<String>,
|
|
pub time_markers: Vec<String>,
|
|
pub advancements: Vec<String>,
|
|
/// Game rule name -> integer-valued.
|
|
pub game_rules: Vec<(String, bool)>,
|
|
pub players: Vec<String>,
|
|
/// Scoreboard objective names, team names and tracked score holders.
|
|
pub objectives: Vec<String>,
|
|
pub teams: Vec<String>,
|
|
pub tracked: Vec<String>,
|
|
/// Loaded datapack functions (`ns:path`) and function tags (`ns:path`).
|
|
pub functions: Vec<String>,
|
|
/// `/data ... storage` ids.
|
|
pub storages: Vec<String>,
|
|
/// Boss bar ids and datapack predicate ids.
|
|
pub bossbars: Vec<String>,
|
|
pub predicates: Vec<String>,
|
|
pub item_modifiers: Vec<String>,
|
|
pub schedules: Vec<String>,
|
|
pub stopwatches: Vec<String>,
|
|
pub recipes: Vec<String>,
|
|
pub sounds: Vec<String>,
|
|
pub damage_types: Vec<String>,
|
|
pub attributes: Vec<String>,
|
|
pub loot_tables: Vec<String>,
|
|
pub templates: Vec<String>,
|
|
pub random_sequences: Vec<String>,
|
|
pub datapacks_enabled: Vec<String>,
|
|
pub datapacks_disabled: Vec<String>,
|
|
pub function_tags: Vec<String>,
|
|
/// The block the source is looking at (relevant coordinates).
|
|
pub target_block: Option<[i32; 3]>,
|
|
/// Every registry's element and tag ids (`minecraft:item` -> ...), as
|
|
/// the server's registry access and reloadable registries hold them.
|
|
pub by_registry: BTreeMap<String, RegistryIds>,
|
|
/// Blocks whose default state has a block entity.
|
|
pub block_entities: std::collections::BTreeSet<String>,
|
|
/// Block tag -> member blocks.
|
|
pub block_tag_members: BTreeMap<String, Vec<String>>,
|
|
/// Data component types with a codec (not transient).
|
|
pub persistent_components: Vec<String>,
|
|
/// Recipes `/recipe` can give (not special).
|
|
pub learnable_recipes: Vec<String>,
|
|
/// Advancement id -> criterion names.
|
|
pub advancement_criteria: BTreeMap<String, Vec<String>>,
|
|
/// World clock -> time markers shown in commands.
|
|
pub clock_time_markers: BTreeMap<String, Vec<String>>,
|
|
/// Trigger objectives the source may use (`/trigger` suggestions).
|
|
pub trigger_objectives: Vec<String>,
|
|
/// Objectives with the `trigger` criterion -> holder -> whether its score is locked.
|
|
pub trigger_scores: BTreeMap<String, BTreeMap<String, bool>>,
|
|
}
|
|
/// The ids and tag ids of one registry.
|
|
#[derive(Clone, Debug, Default)]
|
|
pub struct RegistryIds {
|
|
pub ids: Vec<String>,
|
|
pub tags: Vec<String>,
|
|
}
|
|
const EMPTY: &[String] = &[];
|
|
impl Registries {
|
|
/// The element ids of a registry (sorted).
|
|
pub fn ids(&self, registry: &str) -> &[String] {
|
|
if let Some(r) = self.by_registry.get(registry) {
|
|
return &r.ids;
|
|
}
|
|
match registry {
|
|
"minecraft:item" => &self.items,
|
|
"minecraft:entity_type" => &self.entity_types,
|
|
"minecraft:mob_effect" => &self.effects,
|
|
"minecraft:enchantment" => &self.enchantments,
|
|
"minecraft:worldgen/structure" => &self.structures,
|
|
"minecraft:worldgen/biome" => &self.biomes,
|
|
"minecraft:world_clock" => &self.clocks,
|
|
"minecraft:timeline" => &self.timelines,
|
|
"minecraft:attribute" => &self.attributes,
|
|
"minecraft:damage_type" => &self.damage_types,
|
|
"minecraft:sound_event" => &self.sounds,
|
|
"minecraft:predicate" => &self.predicates,
|
|
"minecraft:item_modifier" => &self.item_modifiers,
|
|
"minecraft:loot_table" => &self.loot_tables,
|
|
"minecraft:recipe" => &self.recipes,
|
|
"minecraft:advancement" => &self.advancements,
|
|
_ => EMPTY,
|
|
}
|
|
}
|
|
/// The tag ids of a registry (sorted).
|
|
pub fn tags(&self, registry: &str) -> &[String] {
|
|
if let Some(r) = self.by_registry.get(registry) {
|
|
return &r.tags;
|
|
}
|
|
match registry {
|
|
"minecraft:item" => &self.item_tags,
|
|
"minecraft:block" => &self.block_tags,
|
|
_ => EMPTY,
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
|
|
pub enum Resource {
|
|
EntityType,
|
|
Effect,
|
|
Enchantment,
|
|
Structure,
|
|
Biome,
|
|
Clock,
|
|
Timeline,
|
|
}
|
|
impl Resource {
|
|
pub fn registry(self) -> &'static str {
|
|
match self {
|
|
Resource::EntityType => "minecraft:entity_type",
|
|
Resource::Effect => "minecraft:mob_effect",
|
|
Resource::Enchantment => "minecraft:enchantment",
|
|
Resource::Structure => "minecraft:worldgen/structure",
|
|
Resource::Biome => "minecraft:worldgen/biome",
|
|
Resource::Clock => "minecraft:world_clock",
|
|
Resource::Timeline => "minecraft:timeline",
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Clone, Debug)]
|
|
pub enum ArgType {
|
|
Bool,
|
|
Integer {
|
|
min: i32,
|
|
max: i32,
|
|
},
|
|
Float {
|
|
min: f32,
|
|
max: f32,
|
|
},
|
|
Double {
|
|
min: f64,
|
|
max: f64,
|
|
},
|
|
Word,
|
|
Str,
|
|
Greedy,
|
|
Entity {
|
|
single: bool,
|
|
players: bool,
|
|
},
|
|
BlockPos,
|
|
Vec3 {
|
|
center: bool,
|
|
},
|
|
Rotation,
|
|
Angle,
|
|
Item,
|
|
ItemPredicate,
|
|
BlockState,
|
|
BlockPredicate,
|
|
Resource(Resource),
|
|
/// A plain identifier; suggestions come from the named list.
|
|
Id(&'static str),
|
|
/// ResourceArgument over a registry (the element must exist).
|
|
Res(&'static str),
|
|
/// ResourceKeyArgument (checked when the command runs).
|
|
ResKey(&'static str),
|
|
/// ResourceOrTagArgument (elements and tags must exist).
|
|
ResOrTag(&'static str),
|
|
/// ResourceOrTagKeyArgument.
|
|
ResOrTagKey(&'static str),
|
|
/// StringRepresentableArgument-like: one of the names, with the error key.
|
|
StrEnum(&'static [&'static str], &'static str),
|
|
/// HexColorArgument.
|
|
HexColor,
|
|
/// UuidArgument.
|
|
Uuid,
|
|
/// GameProfileArgument.
|
|
GameProfile,
|
|
Time {
|
|
min: i32,
|
|
},
|
|
GameMode,
|
|
Message,
|
|
Dimension,
|
|
Anchor,
|
|
/// SwizzleArgument: a set of `x`, `y` and `z` (kept as text).
|
|
Swizzle,
|
|
/// ComponentArgument: an SNBT/JSON text component (kept as JSON text).
|
|
Component,
|
|
/// StyleArgument: an SNBT style map.
|
|
Style,
|
|
/// CompoundTagArgument (kept as SNBT text).
|
|
Nbt,
|
|
/// ScoreHolderArgument.
|
|
ScoreHolder {
|
|
multiple: bool,
|
|
},
|
|
/// ObjectiveArgument (checked when the command runs).
|
|
Objective,
|
|
/// TeamArgument (checked when the command runs).
|
|
Team,
|
|
/// ObjectiveCriteriaArgument.
|
|
Criteria,
|
|
/// ScoreboardSlotArgument.
|
|
ScoreboardSlot,
|
|
/// OperationArgument.
|
|
Operation,
|
|
/// TeamColorArgument.
|
|
TeamColor,
|
|
/// RangeArgument.Ints (`1`, `1..`, `..5`, `1..5`).
|
|
IntRange,
|
|
FloatRange,
|
|
/// NbtPathArgument (kept as text).
|
|
NbtPath,
|
|
/// NbtTagArgument: any SNBT value (kept as text).
|
|
NbtTag,
|
|
/// Vec2Argument: `x z` with `~` relative parts.
|
|
Vec2,
|
|
/// ColumnPosArgument: block `x z`.
|
|
ColumnPos,
|
|
/// ParticleArgument: a particle id and its options (kept as text).
|
|
Particle,
|
|
/// One of a fixed set of words.
|
|
Enum(&'static [&'static str]),
|
|
/// A (possibly quoted) name suggested from a registry list.
|
|
Name(&'static str),
|
|
/// FunctionArgument: `ns:path`, or `#ns:path` for a function tag.
|
|
Function,
|
|
/// SlotsArgument: a slot name or a wildcard group (`container.*`).
|
|
Slots,
|
|
/// SlotArgument: one slot (`container.5`, `weapon.mainhand`).
|
|
Slot,
|
|
/// SlotSourceArgument: a slot range name, or a slot source id or inline value.
|
|
SlotSource,
|
|
/// ResourceOrIdArgument over a registry: an id or an inline SNBT value.
|
|
ResourceOrId(&'static str),
|
|
}
|
|
|
|
/// SlotRanges.SLOTS: every slot range name and its size, in vanilla order.
|
|
pub fn slot_ranges() -> Vec<(String, usize)> {
|
|
let mut v: Vec<(String, usize)> = Vec::new();
|
|
let range = |v: &mut Vec<(String, usize)>, prefix: &str, n: usize| {
|
|
for i in 0..n {
|
|
v.push((format!("{prefix}{i}"), 1));
|
|
}
|
|
v.push((format!("{prefix}*"), n));
|
|
};
|
|
v.push(("contents".into(), 1));
|
|
range(&mut v, "container.", 54);
|
|
range(&mut v, "hotbar.", 9);
|
|
range(&mut v, "inventory.", 27);
|
|
range(&mut v, "enderchest.", 27);
|
|
range(&mut v, "mob.inventory.", 8);
|
|
range(&mut v, "horse.", 15);
|
|
for (name, n) in [
|
|
("weapon", 1),
|
|
("weapon.mainhand", 1),
|
|
("weapon.offhand", 1),
|
|
("weapon.*", 2),
|
|
("armor.head", 1),
|
|
("armor.chest", 1),
|
|
("armor.legs", 1),
|
|
("armor.feet", 1),
|
|
("armor.body", 1),
|
|
("armor.*", 5),
|
|
("saddle", 1),
|
|
("horse.chest", 1),
|
|
("player.cursor", 1),
|
|
] {
|
|
v.push((name.to_owned(), n));
|
|
}
|
|
range(&mut v, "player.crafting.", 4);
|
|
v
|
|
}
|
|
/// Single-slot names (SlotRanges.singleSlotNames).
|
|
pub fn slot_names() -> Vec<String> {
|
|
slot_ranges()
|
|
.into_iter()
|
|
.filter(|(_, n)| *n == 1)
|
|
.map(|(s, _)| s)
|
|
.collect()
|
|
}
|
|
pub fn integer(min: i32) -> ArgType {
|
|
ArgType::Integer { min, max: i32::MAX }
|
|
}
|
|
|
|
#[derive(Clone, Copy, Debug, PartialEq)]
|
|
pub struct Coord {
|
|
pub relative: bool,
|
|
pub value: f64,
|
|
}
|
|
impl Coord {
|
|
pub fn get(self, base: f64) -> f64 {
|
|
if self.relative {
|
|
base + self.value
|
|
} else {
|
|
self.value
|
|
}
|
|
}
|
|
}
|
|
#[derive(Clone, Debug, PartialEq)]
|
|
pub enum Coordinates {
|
|
World([Coord; 3]),
|
|
Local([f64; 3]),
|
|
}
|
|
impl Coordinates {
|
|
/// WorldCoordinates/LocalCoordinates.getPosition from the source position
|
|
/// (feet) and rotation (yaw, pitch in degrees).
|
|
pub fn position(&self, pos: [f64; 3], rot: [f32; 2]) -> [f64; 3] {
|
|
match self {
|
|
Coordinates::World(c) => [c[0].get(pos[0]), c[1].get(pos[1]), c[2].get(pos[2])],
|
|
Coordinates::Local([left, up, forwards]) => {
|
|
let d = std::f32::consts::PI / 180.0;
|
|
let (yaw, pitch) = (rot[0], rot[1]);
|
|
let cos_y = ((yaw + 90.0) * d).cos();
|
|
let sin_y = ((yaw + 90.0) * d).sin();
|
|
let cos_p = (-pitch * d).cos();
|
|
let sin_p = (-pitch * d).sin();
|
|
let cos_p2 = ((-pitch + 90.0) * d).cos();
|
|
let sin_p2 = ((-pitch + 90.0) * d).sin();
|
|
let f = [
|
|
f64::from(cos_y * cos_p),
|
|
f64::from(sin_p),
|
|
f64::from(sin_y * cos_p),
|
|
];
|
|
let u = [
|
|
f64::from(cos_y * cos_p2),
|
|
f64::from(sin_p2),
|
|
f64::from(sin_y * cos_p2),
|
|
];
|
|
// left = -(forward x up)
|
|
let l = [
|
|
-(f[1] * u[2] - f[2] * u[1]),
|
|
-(f[2] * u[0] - f[0] * u[2]),
|
|
-(f[0] * u[1] - f[1] * u[0]),
|
|
];
|
|
[
|
|
pos[0] + f[0] * forwards + u[0] * up + l[0] * left,
|
|
pos[1] + f[1] * forwards + u[1] * up + l[1] * left,
|
|
pos[2] + f[2] * forwards + u[2] * up + l[2] * left,
|
|
]
|
|
}
|
|
}
|
|
}
|
|
pub fn block(&self, pos: [f64; 3], rot: [f32; 2]) -> [i32; 3] {
|
|
let p = self.position(pos, rot);
|
|
[
|
|
p[0].floor() as i32,
|
|
p[1].floor() as i32,
|
|
p[2].floor() as i32,
|
|
]
|
|
}
|
|
/// RotationArgument: (yaw, pitch) from the source rotation.
|
|
pub fn rotation(&self, rot: [f32; 2]) -> [f32; 2] {
|
|
match self {
|
|
Coordinates::World(c) => [
|
|
c[0].get(f64::from(rot[0])) as f32,
|
|
c[1].get(f64::from(rot[1])) as f32,
|
|
],
|
|
Coordinates::Local(_) => rot,
|
|
}
|
|
}
|
|
}
|
|
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
|
|
pub enum Sort {
|
|
#[default]
|
|
Arbitrary,
|
|
Nearest,
|
|
Furthest,
|
|
Random,
|
|
}
|
|
pub type DoubleRange = (Option<f64>, Option<f64>);
|
|
pub type IntRange = (Option<i32>, Option<i32>);
|
|
/// A parsed entity selector (EntitySelector) or player name.
|
|
#[derive(Clone, Debug, Default, PartialEq)]
|
|
pub struct Selector {
|
|
pub player_name: Option<String>,
|
|
/// The entity UUID when the argument was one.
|
|
pub uuid: Option<u128>,
|
|
/// 'p', 'a', 'r', 's', 'e', 'n'.
|
|
pub kind: char,
|
|
pub limit: usize,
|
|
pub sort: Sort,
|
|
pub include_entities: bool,
|
|
pub types: Vec<(String, bool)>,
|
|
pub names: Vec<(String, bool)>,
|
|
pub tags: Vec<(String, bool)>,
|
|
pub gamemodes: Vec<(String, bool)>,
|
|
pub distance: Option<DoubleRange>,
|
|
pub level: Option<IntRange>,
|
|
pub x_rotation: Option<DoubleRange>,
|
|
pub y_rotation: Option<DoubleRange>,
|
|
pub pos: [Option<f64>; 3],
|
|
pub delta: [Option<f64>; 3],
|
|
/// `scores={objective=range,...}`.
|
|
pub scores: Vec<(String, IntRange)>,
|
|
/// `team=` (an empty name matches entities without a team).
|
|
pub teams: Vec<(String, bool)>,
|
|
/// `nbt=` compounds (SNBT text).
|
|
pub nbt: Vec<(String, bool)>,
|
|
/// `advancements={id=true|{criterion=true}}`.
|
|
pub advancements: Vec<(String, AdvCondition)>,
|
|
/// `predicate=` ids.
|
|
pub predicates: Vec<(String, bool)>,
|
|
}
|
|
/// An `advancements=` entry: all done or not, or per-criterion states.
|
|
#[derive(Clone, Debug, PartialEq)]
|
|
pub enum AdvCondition {
|
|
Done(bool),
|
|
Criteria(Vec<(String, bool)>),
|
|
}
|
|
/// A `ScoreHolderArgument` value.
|
|
#[derive(Clone, Debug, PartialEq)]
|
|
pub enum ScoreHolderArg {
|
|
Wildcard,
|
|
Name(String),
|
|
Selector(Selector),
|
|
}
|
|
impl Selector {
|
|
pub fn is_self(&self) -> bool {
|
|
self.kind == 's'
|
|
}
|
|
pub fn single(&self) -> bool {
|
|
self.limit <= 1
|
|
}
|
|
}
|
|
#[derive(Clone, Debug, PartialEq)]
|
|
pub struct BlockInput {
|
|
pub id: String,
|
|
pub properties: Vec<(String, String)>,
|
|
/// `#tag` for block predicates.
|
|
pub tag: bool,
|
|
pub nbt: Option<String>,
|
|
}
|
|
#[derive(Clone, Debug, PartialEq)]
|
|
pub struct ItemInput {
|
|
pub id: String,
|
|
pub tag: bool,
|
|
pub any: bool,
|
|
pub components: Option<String>,
|
|
}
|
|
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
|
|
pub enum GameMode {
|
|
Survival,
|
|
Creative,
|
|
Adventure,
|
|
Spectator,
|
|
}
|
|
impl GameMode {
|
|
pub const ALL: [GameMode; 4] = [
|
|
GameMode::Survival,
|
|
GameMode::Creative,
|
|
GameMode::Adventure,
|
|
GameMode::Spectator,
|
|
];
|
|
pub fn name(self) -> &'static str {
|
|
match self {
|
|
GameMode::Survival => "survival",
|
|
GameMode::Creative => "creative",
|
|
GameMode::Adventure => "adventure",
|
|
GameMode::Spectator => "spectator",
|
|
}
|
|
}
|
|
pub fn from_name(s: &str) -> Option<Self> {
|
|
Self::ALL.into_iter().find(|m| m.name() == s)
|
|
}
|
|
}
|
|
#[derive(Clone, Debug, PartialEq)]
|
|
pub enum Arg {
|
|
Bool(bool),
|
|
Int(i32),
|
|
Float(f32),
|
|
Double(f64),
|
|
Str(String),
|
|
Entity(Selector),
|
|
Coords(Coordinates),
|
|
Angle(Coord),
|
|
Item(ItemInput),
|
|
Block(BlockInput),
|
|
Resource(String),
|
|
GameMode(GameMode),
|
|
/// `eyes` (true) or `feet`.
|
|
Anchor(bool),
|
|
ScoreHolder(ScoreHolderArg),
|
|
IntRange(IntRange),
|
|
DoubleRange(DoubleRange),
|
|
}
|
|
|
|
pub fn is_id_char(c: char) -> bool {
|
|
c.is_ascii_lowercase() || c.is_ascii_digit() || matches!(c, '_' | '-' | '.' | ':' | '/')
|
|
}
|
|
/// Identifier.read: the longest run of identifier characters, normalised to
|
|
/// the `minecraft` namespace (an empty path is valid).
|
|
pub fn read_id(reader: &mut Reader) -> CmdResult<String> {
|
|
read_identifier(reader)
|
|
}
|
|
/// Identifier.read.
|
|
pub fn read_identifier(reader: &mut Reader) -> CmdResult<String> {
|
|
let start = reader.cursor;
|
|
while reader.can_read() && is_id_char(reader.peek()) {
|
|
reader.skip();
|
|
}
|
|
let raw = &reader.string[start..reader.cursor];
|
|
match parse_identifier(raw) {
|
|
Some(id) => Ok(id),
|
|
None => {
|
|
reader.cursor = start;
|
|
Err(CommandError::tr_at("argument.id.invalid", &[], reader))
|
|
}
|
|
}
|
|
}
|
|
/// Identifier.parse: `ns:path` or `path`, validated.
|
|
pub fn parse_identifier(raw: &str) -> Option<String> {
|
|
let (ns, path) = match raw.split_once(':') {
|
|
Some(("", path)) => ("minecraft", path),
|
|
Some((ns, path)) => (ns, path),
|
|
None => ("minecraft", raw),
|
|
};
|
|
let ns_ok = ns != ".."
|
|
&& ns
|
|
.chars()
|
|
.all(|c| c.is_ascii_lowercase() || c.is_ascii_digit() || matches!(c, '_' | '.' | '-'));
|
|
let path_ok = path.chars().all(|c| {
|
|
c.is_ascii_lowercase() || c.is_ascii_digit() || matches!(c, '_' | '.' | '-' | '/')
|
|
});
|
|
(ns_ok && path_ok).then(|| format!("{ns}:{path}"))
|
|
}
|
|
pub fn normalize(id: &str) -> String {
|
|
match id.split_once(':') {
|
|
Some(("", path)) => format!("minecraft:{path}"),
|
|
Some(_) => id.to_owned(),
|
|
None => format!("minecraft:{id}"),
|
|
}
|
|
}
|
|
/// SharedSuggestionProvider.matchesSubStr: `input` is a prefix of
|
|
/// `candidate` or of a part after a `.`, `_` or `/`.
|
|
pub fn matches_sub_str(input: &str, candidate: &str) -> bool {
|
|
let mut index = 0;
|
|
loop {
|
|
if candidate[index..].starts_with(input) {
|
|
return true;
|
|
}
|
|
match candidate[index..].find(['.', '_', '/']) {
|
|
Some(i) => index += i + 1,
|
|
None => return false,
|
|
}
|
|
}
|
|
}
|
|
/// SharedSuggestionProvider.filterResources (no prefix).
|
|
pub fn resource_matches(contents: &str, id: &str) -> bool {
|
|
if contents.contains(':') {
|
|
matches_sub_str(contents, id)
|
|
} else {
|
|
let (ns, path) = id.split_once(':').unwrap_or(("minecraft", id));
|
|
matches_sub_str(contents, ns) || matches_sub_str(contents, path)
|
|
}
|
|
}
|
|
/// SharedSuggestionProvider.suggestResource (with an optional prefix such as `#`).
|
|
pub fn suggest_resources<'a>(
|
|
builder: &mut SuggestionsBuilder,
|
|
ids: impl IntoIterator<Item = &'a String>,
|
|
prefix: &str,
|
|
) {
|
|
let contents = builder.remaining_lower();
|
|
if prefix.is_empty() {
|
|
for id in ids {
|
|
if resource_matches(&contents, id) {
|
|
builder.suggest(id.clone());
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
if contents.is_empty() {
|
|
for id in ids {
|
|
builder.suggest(format!("{prefix}{id}"));
|
|
}
|
|
return;
|
|
}
|
|
let common = contents
|
|
.chars()
|
|
.zip(prefix.chars())
|
|
.take_while(|(a, b)| a == b)
|
|
.map(|(a, _)| a.len_utf8())
|
|
.sum::<usize>();
|
|
if common == 0 {
|
|
return;
|
|
}
|
|
let stripped = &contents[common..];
|
|
for id in ids {
|
|
if resource_matches(stripped, id) {
|
|
builder.suggest(format!("{prefix}{id}"));
|
|
}
|
|
}
|
|
}
|
|
/// MinMaxBounds.Bounds.fromReader: `a`, `a..`, `..b` or `a..b`, each part
|
|
/// converted by `convert` (errors rewound to the start).
|
|
fn read_bounds<T: Copy>(
|
|
reader: &mut Reader,
|
|
convert: impl Fn(&str) -> Option<T>,
|
|
invalid: &str,
|
|
) -> CmdResult<(Option<T>, Option<T>)> {
|
|
if !reader.can_read() {
|
|
return Err(CommandError::tr_at("argument.range.empty", &[], reader));
|
|
}
|
|
let start = reader.cursor;
|
|
let number = |reader: &mut Reader| -> CmdResult<Option<T>> {
|
|
let s = reader.cursor;
|
|
while reader.can_read() {
|
|
let c = reader.peek();
|
|
let allowed = c.is_ascii_digit()
|
|
|| c == '-'
|
|
|| (c == '.' && !(reader.can_read_n(2) && reader.peek_at(1) == '.'));
|
|
if !allowed {
|
|
break;
|
|
}
|
|
reader.skip();
|
|
}
|
|
let text = &reader.string[s..reader.cursor];
|
|
if text.is_empty() {
|
|
return Ok(None);
|
|
}
|
|
match convert(text) {
|
|
Some(v) => Ok(Some(v)),
|
|
None => Err(CommandError::tr_at(invalid, &[&text], reader)),
|
|
}
|
|
};
|
|
let result = (|| {
|
|
let min = number(reader)?;
|
|
let max = if reader.can_read_n(2) && reader.peek() == '.' && reader.peek_at(1) == '.' {
|
|
reader.skip();
|
|
reader.skip();
|
|
number(reader)?
|
|
} else {
|
|
min
|
|
};
|
|
if min.is_none() && max.is_none() {
|
|
return Err(CommandError::tr_at("argument.range.empty", &[], reader));
|
|
}
|
|
Ok((min, max))
|
|
})();
|
|
result.map_err(|mut e| {
|
|
reader.cursor = start;
|
|
e.cursor = start;
|
|
e
|
|
})
|
|
}
|
|
/// MinMaxBounds.Ints.fromReader.
|
|
pub fn read_int_bounds(reader: &mut Reader) -> CmdResult<IntRange> {
|
|
let start = reader.cursor;
|
|
let b = read_bounds(reader, java_parse_int, "parsing.int.invalid")?;
|
|
if let (Some(l), Some(h)) = b
|
|
&& l > h
|
|
{
|
|
reader.cursor = start;
|
|
return Err(CommandError::tr_at("argument.range.swapped", &[], reader));
|
|
}
|
|
Ok(b)
|
|
}
|
|
/// MinMaxBounds.Doubles.fromReader.
|
|
pub fn read_double_bounds(reader: &mut Reader) -> CmdResult<DoubleRange> {
|
|
let start = reader.cursor;
|
|
let b = read_bounds(reader, java_parse_double, "parsing.double.invalid")?;
|
|
if let (Some(l), Some(h)) = b
|
|
&& l > h
|
|
{
|
|
reader.cursor = start;
|
|
return Err(CommandError::tr_at("argument.range.swapped", &[], reader));
|
|
}
|
|
Ok(b)
|
|
}
|
|
/// MinMaxBounds.FloatDegrees.fromReader (no swap check).
|
|
pub fn read_float_bounds(reader: &mut Reader) -> CmdResult<(Option<f32>, Option<f32>)> {
|
|
read_bounds(
|
|
reader,
|
|
|s| java_parse_double(s).map(|v| v as f32),
|
|
"parsing.float.invalid",
|
|
)
|
|
}
|
|
/// Integer.parseInt over number characters.
|
|
pub fn java_parse_int(s: &str) -> Option<i32> {
|
|
let digits = s.strip_prefix(['-', '+']).unwrap_or(s);
|
|
if digits.is_empty() || !digits.chars().all(|c| c.is_ascii_digit()) {
|
|
return None;
|
|
}
|
|
s.parse().ok()
|
|
}
|
|
/// Long.parseLong.
|
|
pub fn java_parse_long(s: &str) -> Option<i64> {
|
|
let digits = s.strip_prefix(['-', '+']).unwrap_or(s);
|
|
if digits.is_empty() || !digits.chars().all(|c| c.is_ascii_digit()) {
|
|
return None;
|
|
}
|
|
s.parse().ok()
|
|
}
|
|
/// Double.parseDouble over the characters StringReader reads as a number.
|
|
pub fn java_parse_double(s: &str) -> Option<f64> {
|
|
let t = s.trim_matches(|c: char| c <= ' ');
|
|
let body = t.strip_prefix(['-', '+']).unwrap_or(t);
|
|
if body.is_empty() || body == "." {
|
|
return None;
|
|
}
|
|
let body = body.strip_suffix(['d', 'D', 'f', 'F']).unwrap_or(body);
|
|
if body == "NaN" || body == "Infinity" {
|
|
return t.parse::<f64>().ok().or(Some(if t.starts_with('-') {
|
|
f64::NEG_INFINITY
|
|
} else if body == "NaN" {
|
|
f64::NAN
|
|
} else {
|
|
f64::INFINITY
|
|
}));
|
|
}
|
|
let mut chars = body.chars().peekable();
|
|
let mut digits = 0;
|
|
while chars.peek().is_some_and(char::is_ascii_digit) {
|
|
chars.next();
|
|
digits += 1;
|
|
}
|
|
if chars.peek() == Some(&'.') {
|
|
chars.next();
|
|
while chars.peek().is_some_and(char::is_ascii_digit) {
|
|
chars.next();
|
|
digits += 1;
|
|
}
|
|
}
|
|
if digits == 0 {
|
|
return None;
|
|
}
|
|
if matches!(chars.peek(), Some('e' | 'E')) {
|
|
chars.next();
|
|
if matches!(chars.peek(), Some('+' | '-')) {
|
|
chars.next();
|
|
}
|
|
let mut exp = 0;
|
|
while chars.peek().is_some_and(char::is_ascii_digit) {
|
|
chars.next();
|
|
exp += 1;
|
|
}
|
|
if exp == 0 {
|
|
return None;
|
|
}
|
|
}
|
|
if chars.next().is_some() {
|
|
return None;
|
|
}
|
|
let clean: String = t
|
|
.trim_end_matches(['d', 'D', 'f', 'F'])
|
|
.trim_start_matches('+')
|
|
.to_owned();
|
|
clean.parse::<f64>().ok()
|
|
}
|
|
fn parse_coord_int(reader: &mut Reader) -> CmdResult<Coord> {
|
|
if reader.can_read() && reader.peek() == '^' {
|
|
return Err(CommandError::tr_at("argument.pos.mixed", &[], reader));
|
|
}
|
|
if !reader.can_read() {
|
|
return Err(CommandError::tr_at("argument.pos.missing.int", &[], reader));
|
|
}
|
|
let relative = reader.peek() == '~';
|
|
if relative {
|
|
reader.skip();
|
|
}
|
|
let value = if reader.can_read() && reader.peek() != ' ' {
|
|
if relative {
|
|
reader.read_double()?
|
|
} else {
|
|
f64::from(reader.read_int()?)
|
|
}
|
|
} else {
|
|
0.0
|
|
};
|
|
Ok(Coord { relative, value })
|
|
}
|
|
fn parse_coord_double(reader: &mut Reader, center: bool) -> CmdResult<Coord> {
|
|
if reader.can_read() && reader.peek() == '^' {
|
|
return Err(CommandError::tr_at("argument.pos.mixed", &[], reader));
|
|
}
|
|
if !reader.can_read() {
|
|
return Err(CommandError::tr_at(
|
|
"argument.pos.missing.double",
|
|
&[],
|
|
reader,
|
|
));
|
|
}
|
|
let relative = reader.peek() == '~';
|
|
if relative {
|
|
reader.skip();
|
|
}
|
|
let start = reader.cursor;
|
|
let mut value = if reader.can_read() && reader.peek() != ' ' {
|
|
reader.read_double()?
|
|
} else {
|
|
0.0
|
|
};
|
|
let number = &reader.string[start..reader.cursor];
|
|
if relative && number.is_empty() {
|
|
return Ok(Coord {
|
|
relative,
|
|
value: 0.0,
|
|
});
|
|
}
|
|
if !number.contains('.') && !relative && center {
|
|
value += 0.5;
|
|
}
|
|
Ok(Coord { relative, value })
|
|
}
|
|
fn parse_local(reader: &mut Reader) -> CmdResult<Coordinates> {
|
|
let start = reader.cursor;
|
|
let mut v = [0.0; 3];
|
|
for (i, slot) in v.iter_mut().enumerate() {
|
|
if i > 0 {
|
|
if !reader.can_read() || reader.peek() != ' ' {
|
|
reader.cursor = start;
|
|
return Err(CommandError::tr_at(
|
|
"argument.pos3d.incomplete",
|
|
&[],
|
|
reader,
|
|
));
|
|
}
|
|
reader.skip();
|
|
}
|
|
if !reader.can_read() || reader.peek() != '^' {
|
|
reader.cursor = start;
|
|
return Err(CommandError::tr_at("argument.pos.mixed", &[], reader));
|
|
}
|
|
reader.skip();
|
|
*slot = if reader.can_read() && reader.peek() != ' ' {
|
|
reader.read_double()?
|
|
} else {
|
|
0.0
|
|
};
|
|
}
|
|
Ok(Coordinates::Local(v))
|
|
}
|
|
fn parse_world(reader: &mut Reader, block: bool, center: bool) -> CmdResult<Coordinates> {
|
|
let start = reader.cursor;
|
|
let mut c = [Coord {
|
|
relative: false,
|
|
value: 0.0,
|
|
}; 3];
|
|
for (i, slot) in c.iter_mut().enumerate() {
|
|
if i > 0 {
|
|
if !reader.can_read() || reader.peek() != ' ' {
|
|
reader.cursor = start;
|
|
return Err(CommandError::tr_at(
|
|
"argument.pos3d.incomplete",
|
|
&[],
|
|
reader,
|
|
));
|
|
}
|
|
reader.skip();
|
|
}
|
|
*slot = if block {
|
|
parse_coord_int(reader)?
|
|
} else {
|
|
parse_coord_double(reader, center && i != 1)?
|
|
};
|
|
}
|
|
Ok(Coordinates::World(c))
|
|
}
|
|
/// String.split(" "): trailing empty strings are dropped.
|
|
fn java_split(s: &str) -> Vec<&str> {
|
|
let mut parts: Vec<&str> = s.split(' ').collect();
|
|
while parts.len() > 1 && parts.last() == Some(&"") {
|
|
parts.pop();
|
|
}
|
|
if parts == [""] && !s.is_empty() {
|
|
parts.clear();
|
|
}
|
|
parts
|
|
}
|
|
/// SharedSuggestionProvider.suggestCoordinates / suggest2DCoordinates: the
|
|
/// candidates `ty` parses completely.
|
|
fn suggest_coordinates(
|
|
builder: &mut SuggestionsBuilder,
|
|
reg: &Registries,
|
|
ty: &ArgType,
|
|
relevant: bool,
|
|
) {
|
|
let remaining = builder.remaining().to_owned();
|
|
let three = matches!(ty, ArgType::BlockPos | ArgType::Vec3 { .. });
|
|
let coords: [String; 3] = if remaining.starts_with('^') {
|
|
["^".into(), "^".into(), "^".into()]
|
|
} else if let (true, Some(t)) = (relevant, reg.target_block) {
|
|
[t[0].to_string(), t[1].to_string(), t[2].to_string()]
|
|
} else {
|
|
["~".into(), "~".into(), "~".into()]
|
|
};
|
|
let valid = |text: &str| {
|
|
let mut r = Reader::new(text);
|
|
ty.parse(&mut r, reg).is_ok()
|
|
};
|
|
let mut result: Vec<String> = Vec::new();
|
|
let [x, y, z] = &coords;
|
|
if remaining.is_empty() {
|
|
let full = if three {
|
|
format!("{x} {y} {z}")
|
|
} else {
|
|
format!("{x} {z}")
|
|
};
|
|
if valid(&full) {
|
|
result.push(x.clone());
|
|
if three {
|
|
result.push(format!("{x} {y}"));
|
|
}
|
|
result.push(full);
|
|
}
|
|
} else {
|
|
let fields = java_split(&remaining);
|
|
match (fields.len(), three) {
|
|
(1, true) => {
|
|
let full = format!("{} {y} {z}", fields[0]);
|
|
if valid(&full) {
|
|
result.push(format!("{} {y}", fields[0]));
|
|
result.push(full);
|
|
}
|
|
}
|
|
(2, true) => {
|
|
let full = format!("{} {} {z}", fields[0], fields[1]);
|
|
if valid(&full) {
|
|
result.push(full);
|
|
}
|
|
}
|
|
(1, false) => {
|
|
let full = format!("{} {z}", fields[0]);
|
|
if valid(&full) {
|
|
result.push(full);
|
|
}
|
|
}
|
|
_ => {}
|
|
}
|
|
}
|
|
builder.suggest_matching(result.iter().map(String::as_str));
|
|
}
|
|
|
|
pub const OPERATIONS: [&str; 9] = ["=", "+=", "-=", "*=", "/=", "%=", "<", ">", "><"];
|
|
/// NbtPathArgument.parse (validation; the path is kept as text).
|
|
fn parse_nbt_path(reader: &mut Reader) -> CmdResult<()> {
|
|
let invalid = |r: &Reader| CommandError::tr_at("arguments.nbtpath.node.invalid", &[], r);
|
|
let object_node = |reader: &mut Reader, name: &str| -> CmdResult<()> {
|
|
if name.is_empty() {
|
|
return Err(invalid(reader));
|
|
}
|
|
if reader.can_read() && reader.peek() == '{' {
|
|
super::snbt::parse_compound_argument(reader)?;
|
|
}
|
|
Ok(())
|
|
};
|
|
let mut first = true;
|
|
while reader.can_read() && reader.peek() != ' ' {
|
|
match reader.peek() {
|
|
'"' | '\'' => {
|
|
let name = reader.read_string()?;
|
|
object_node(reader, &name)?;
|
|
}
|
|
'[' => {
|
|
reader.skip();
|
|
if !reader.can_read() {
|
|
// StringReader.peek past the end (StringIndexOutOfBoundsException).
|
|
let len = reader.string.encode_utf16().count();
|
|
let message = format!("Index {len} out of bounds for length {len}");
|
|
return Err(CommandError::tr_at(
|
|
"command.exception",
|
|
&[&message],
|
|
reader,
|
|
));
|
|
}
|
|
match reader.peek() {
|
|
'{' => {
|
|
super::snbt::parse_compound_argument(reader)?;
|
|
reader.expect(']')?;
|
|
}
|
|
']' => reader.skip(),
|
|
_ => {
|
|
reader.read_int()?;
|
|
reader.expect(']')?;
|
|
}
|
|
}
|
|
}
|
|
'{' => {
|
|
if !first {
|
|
return Err(invalid(reader));
|
|
}
|
|
super::snbt::parse_compound_argument(reader)?;
|
|
}
|
|
_ => {
|
|
let s = reader.cursor;
|
|
while reader.can_read()
|
|
&& !matches!(
|
|
reader.peek(),
|
|
' ' | '"' | '\'' | '[' | ']' | '.' | '{' | '}'
|
|
)
|
|
{
|
|
reader.skip();
|
|
}
|
|
if reader.cursor == s {
|
|
return Err(invalid(reader));
|
|
}
|
|
let name = reader.string[s..reader.cursor].to_owned();
|
|
object_node(reader, &name)?;
|
|
}
|
|
}
|
|
first = false;
|
|
if reader.can_read() {
|
|
let next = reader.peek();
|
|
if next != ' ' && next != '[' && next != '{' {
|
|
reader.expect('.')?;
|
|
}
|
|
}
|
|
}
|
|
Ok(())
|
|
}
|
|
/// The required fields of each particle type's options codec (declaration order).
|
|
fn particle_fields(id: &str) -> &'static [&'static str] {
|
|
match id.trim_start_matches("minecraft:") {
|
|
"block" | "block_marker" | "falling_dust" | "dust_pillar" | "block_crumble" => {
|
|
&["block_state"]
|
|
}
|
|
"geyser" | "geyser_plume" => &["water_blocks"],
|
|
"geyser_base" | "geyser_poof" => &["water_blocks", "burst_impulse_base"],
|
|
"dust" => &["color", "scale"],
|
|
"dust_color_transition" => &["from_color", "to_color", "scale"],
|
|
"entity_effect" | "tinted_leaves" | "flash" => &["color"],
|
|
"sculk_charge" => &["roll"],
|
|
"item" => &["item"],
|
|
"vibration" => &["destination", "arrival_in_ticks"],
|
|
"trail" => &["target", "color", "duration"],
|
|
"shriek" => &["delay"],
|
|
_ => &[],
|
|
}
|
|
}
|
|
/// The particle type's codec over the options (MapCodec field errors, newest first).
|
|
fn particle_options(id: &str, t: &horizon_world::nbt::Tag) -> Result<(), String> {
|
|
use super::codec::{get, no_key, not_map, snbt};
|
|
let horizon_world::nbt::Tag::Compound(map) = t else {
|
|
return Err(not_map(t));
|
|
};
|
|
let missing: Vec<String> = particle_fields(id)
|
|
.iter()
|
|
.rev()
|
|
.filter(|f| get(map, f).is_none())
|
|
.map(|f| no_key(f, t))
|
|
.collect();
|
|
if !missing.is_empty() {
|
|
return Err(missing.join("; "));
|
|
}
|
|
if particle_fields(id) == ["block_state"]
|
|
&& let Some(state) = get(map, "block_state")
|
|
&& !matches!(state, horizon_world::nbt::Tag::String(_))
|
|
{
|
|
// withAlternative(BlockState.CODEC, the block id codec).
|
|
let first = match state {
|
|
horizon_world::nbt::Tag::Compound(_) => {
|
|
super::codec::either("Not a string".into(), no_key("id", state))
|
|
}
|
|
_ => not_map(state),
|
|
};
|
|
let _ = snbt;
|
|
return Err(super::codec::either(first, "Not a string".into()));
|
|
}
|
|
Ok(())
|
|
}
|
|
/// TimeArgument units.
|
|
fn time_unit(unit: &str) -> Option<i32> {
|
|
match unit {
|
|
"" | "t" => Some(1),
|
|
"s" => Some(20),
|
|
"d" => Some(24000),
|
|
_ => None,
|
|
}
|
|
}
|
|
|
|
impl ArgType {
|
|
pub fn parse(&self, reader: &mut Reader, reg: &Registries) -> CmdResult<Arg> {
|
|
let start = reader.cursor;
|
|
Ok(match self {
|
|
ArgType::Bool => Arg::Bool(reader.read_boolean()?),
|
|
ArgType::Integer { min, max } => {
|
|
let v = reader.read_int()?;
|
|
if v < *min {
|
|
reader.cursor = start;
|
|
return Err(CommandError::tr_at(
|
|
"argument.integer.low",
|
|
&[min, &v],
|
|
reader,
|
|
));
|
|
}
|
|
if v > *max {
|
|
reader.cursor = start;
|
|
return Err(CommandError::tr_at(
|
|
"argument.integer.big",
|
|
&[max, &v],
|
|
reader,
|
|
));
|
|
}
|
|
Arg::Int(v)
|
|
}
|
|
ArgType::Float { min, max } => {
|
|
let v = reader.read_float()?;
|
|
if v < *min {
|
|
reader.cursor = start;
|
|
return Err(CommandError::tr_at(
|
|
"argument.float.low",
|
|
&[&crate::snbt::java_float(*min), &crate::snbt::java_float(v)],
|
|
reader,
|
|
));
|
|
}
|
|
if v > *max {
|
|
reader.cursor = start;
|
|
return Err(CommandError::tr_at(
|
|
"argument.float.big",
|
|
&[&crate::snbt::java_float(*max), &crate::snbt::java_float(v)],
|
|
reader,
|
|
));
|
|
}
|
|
Arg::Float(v)
|
|
}
|
|
ArgType::Double { min, max } => {
|
|
let v = reader.read_double()?;
|
|
if v < *min {
|
|
reader.cursor = start;
|
|
return Err(CommandError::tr_at(
|
|
"argument.double.low",
|
|
&[
|
|
&crate::snbt::java_double(*min),
|
|
&crate::snbt::java_double(v),
|
|
],
|
|
reader,
|
|
));
|
|
}
|
|
if v > *max {
|
|
reader.cursor = start;
|
|
return Err(CommandError::tr_at(
|
|
"argument.double.big",
|
|
&[
|
|
&crate::snbt::java_double(*max),
|
|
&crate::snbt::java_double(v),
|
|
],
|
|
reader,
|
|
));
|
|
}
|
|
Arg::Double(v)
|
|
}
|
|
ArgType::Word => Arg::Str(reader.read_unquoted_string().to_owned()),
|
|
ArgType::Str => Arg::Str(reader.read_string()?),
|
|
ArgType::Greedy => {
|
|
let s = reader.remaining().to_owned();
|
|
reader.cursor = reader.string.len();
|
|
Arg::Str(s)
|
|
}
|
|
ArgType::Message => {
|
|
// MessageArgument.Message.parseText.
|
|
let len = reader.remaining().encode_utf16().count();
|
|
if len > 256 {
|
|
return Err(CommandError::tr("argument.message.too_long", &[&len, &256]));
|
|
}
|
|
let s = reader.remaining().to_owned();
|
|
if reg.permission >= 2 {
|
|
while reader.can_read() {
|
|
if reader.peek() == '@' {
|
|
let at = reader.cursor;
|
|
if let Err(e) = super::selector::parse(reader, reg, true) {
|
|
let key = e.key.as_str();
|
|
if key != "argument.entity.selector.missing"
|
|
&& key != "argument.entity.selector.unknown"
|
|
{
|
|
return Err(e);
|
|
}
|
|
reader.cursor = at + 1;
|
|
}
|
|
} else {
|
|
reader.skip();
|
|
}
|
|
}
|
|
}
|
|
reader.cursor = reader.string.len();
|
|
Arg::Str(s)
|
|
}
|
|
ArgType::Entity { single, players } => {
|
|
let s = super::selector::parse(reader, reg, reg.permission >= 2)?;
|
|
// Vanilla rewinds to the very start of the input for these.
|
|
if s.limit > 1 && *single {
|
|
reader.cursor = 0;
|
|
let key = if *players {
|
|
"argument.player.toomany"
|
|
} else {
|
|
"argument.entity.toomany"
|
|
};
|
|
return Err(CommandError::tr_at(key, &[], reader));
|
|
}
|
|
if s.include_entities && *players && !s.is_self() {
|
|
reader.cursor = 0;
|
|
return Err(CommandError::tr_at("argument.player.entities", &[], reader));
|
|
}
|
|
Arg::Entity(s)
|
|
}
|
|
ArgType::BlockPos => {
|
|
if reader.can_read() && reader.peek() == '^' {
|
|
Arg::Coords(parse_local(reader)?)
|
|
} else {
|
|
Arg::Coords(parse_world(reader, true, false)?)
|
|
}
|
|
}
|
|
ArgType::Vec3 { center } => {
|
|
if reader.can_read() && reader.peek() == '^' {
|
|
Arg::Coords(parse_local(reader)?)
|
|
} else {
|
|
Arg::Coords(parse_world(reader, false, *center)?)
|
|
}
|
|
}
|
|
ArgType::Rotation => {
|
|
if !reader.can_read() {
|
|
return Err(CommandError::tr_at(
|
|
"argument.rotation.incomplete",
|
|
&[],
|
|
reader,
|
|
));
|
|
}
|
|
let yaw = parse_coord_double(reader, false)?;
|
|
if !reader.can_read() || reader.peek() != ' ' {
|
|
reader.cursor = start;
|
|
return Err(CommandError::tr_at(
|
|
"argument.rotation.incomplete",
|
|
&[],
|
|
reader,
|
|
));
|
|
}
|
|
reader.skip();
|
|
let pitch = parse_coord_double(reader, false)?;
|
|
Arg::Coords(Coordinates::World([
|
|
yaw,
|
|
pitch,
|
|
Coord {
|
|
relative: true,
|
|
value: 0.0,
|
|
},
|
|
]))
|
|
}
|
|
ArgType::Angle => {
|
|
if !reader.can_read() {
|
|
return Err(CommandError::tr_at(
|
|
"argument.angle.incomplete",
|
|
&[],
|
|
reader,
|
|
));
|
|
}
|
|
let relative = reader.peek() == '~';
|
|
if relative {
|
|
reader.skip();
|
|
}
|
|
let value = if reader.can_read() && reader.peek() != ' ' {
|
|
f64::from(reader.read_float()?)
|
|
} else {
|
|
0.0
|
|
};
|
|
if value.is_nan() || value.is_infinite() {
|
|
return Err(CommandError::tr_at("argument.angle.invalid", &[], reader));
|
|
}
|
|
Arg::Angle(Coord { relative, value })
|
|
}
|
|
ArgType::Item => Arg::Item(super::item::parse_stack(reader, reg)?),
|
|
ArgType::ItemPredicate => Arg::Item(super::item::parse_predicate(reader, reg)?),
|
|
ArgType::BlockState => Arg::Block(super::block::parse(reader, reg, false)?),
|
|
ArgType::BlockPredicate => Arg::Block(super::block::parse(reader, reg, true)?),
|
|
ArgType::Resource(kind) => {
|
|
// ResourceArgument: the element must exist.
|
|
let id = read_identifier(reader)?;
|
|
let registry = kind.registry();
|
|
if !reg.ids(registry).contains(&id) {
|
|
return Err(CommandError::tr_at(
|
|
"argument.resource.not_found",
|
|
&[&id, ®istry],
|
|
reader,
|
|
));
|
|
}
|
|
Arg::Resource(id)
|
|
}
|
|
ArgType::Res(registry) => {
|
|
let id = read_identifier(reader)?;
|
|
if !reg.ids(registry).contains(&id) {
|
|
return Err(CommandError::tr_at(
|
|
"argument.resource.not_found",
|
|
&[&id, registry],
|
|
reader,
|
|
));
|
|
}
|
|
Arg::Resource(id)
|
|
}
|
|
ArgType::ResKey(_) => Arg::Resource(read_identifier(reader)?),
|
|
ArgType::ResOrTag(registry) | ArgType::ResOrTagKey(registry) => {
|
|
let key_only = matches!(self, ArgType::ResOrTagKey(_));
|
|
if reader.can_read() && reader.peek() == '#' {
|
|
let cursor = reader.cursor;
|
|
reader.skip();
|
|
let id = match read_identifier(reader) {
|
|
Ok(id) => id,
|
|
Err(e) => {
|
|
reader.cursor = cursor;
|
|
return Err(e);
|
|
}
|
|
};
|
|
if !key_only && !reg.tags(registry).contains(&id) {
|
|
let e = CommandError::tr_at(
|
|
"argument.resource_tag.not_found",
|
|
&[&id, registry],
|
|
reader,
|
|
);
|
|
reader.cursor = cursor;
|
|
return Err(e);
|
|
}
|
|
Arg::Resource(format!("#{id}"))
|
|
} else {
|
|
let id = read_identifier(reader)?;
|
|
if !key_only && !reg.ids(registry).contains(&id) {
|
|
return Err(CommandError::tr_at(
|
|
"argument.resource.not_found",
|
|
&[&id, registry],
|
|
reader,
|
|
));
|
|
}
|
|
Arg::Resource(id)
|
|
}
|
|
}
|
|
ArgType::StrEnum(values, key) => {
|
|
// StringRepresentableArgument (the error follows the word).
|
|
let name = reader.read_unquoted_string();
|
|
if !values.contains(&name) {
|
|
return Err(CommandError::tr_at(key, &[&name], reader));
|
|
}
|
|
Arg::Str(name.to_owned())
|
|
}
|
|
ArgType::HexColor => {
|
|
let text = reader.read_unquoted_string();
|
|
if !matches!(text.len(), 3 | 6) {
|
|
return Err(CommandError::tr_at(
|
|
"argument.hexcolor.invalid",
|
|
&[&text],
|
|
reader,
|
|
));
|
|
}
|
|
// Integer.parseInt(s, begin, end, 16) per channel: a bad digit
|
|
// escapes Brigadier as a dispatcher parse exception.
|
|
let width = text.len() / 3;
|
|
for chunk in text.as_bytes().chunks(width) {
|
|
let c = std::str::from_utf8(chunk).unwrap_or("");
|
|
let signed = c.len() > 1 && (c.starts_with('+') || c.starts_with('-'));
|
|
let digits = if signed { &c[1..] } else { c };
|
|
if let Some(i) = digits.find(|ch: char| !ch.is_ascii_hexdigit()) {
|
|
let index = i + usize::from(signed);
|
|
let message = format!("Error at index {index} in: \"{c}\"");
|
|
return Err(CommandError::tr_at(
|
|
"command.exception",
|
|
&[&message],
|
|
reader,
|
|
));
|
|
}
|
|
}
|
|
let v = i64::from_str_radix(text, 16).unwrap_or(0);
|
|
let rgb = if text.len() == 3 {
|
|
let d = |i: u32| ((v >> (8 - 4 * i)) & 15) * 17;
|
|
(d(0) << 16) | (d(1) << 8) | d(2)
|
|
} else {
|
|
v
|
|
};
|
|
Arg::Int(rgb as i32)
|
|
}
|
|
ArgType::Uuid => {
|
|
// UuidArgument: the longest run of [-A-Fa-f0-9] must be a UUID.
|
|
let rest = reader.remaining();
|
|
let run: usize = rest
|
|
.chars()
|
|
.take_while(|c| c.is_ascii_hexdigit() || *c == '-')
|
|
.map(char::len_utf8)
|
|
.sum();
|
|
match (run > 0)
|
|
.then(|| super::selector::java_uuid(&rest[..run]))
|
|
.flatten()
|
|
{
|
|
Some(_) => {
|
|
let text = rest[..run].to_owned();
|
|
reader.cursor += run;
|
|
Arg::Str(text)
|
|
}
|
|
None => return Err(CommandError::tr_at("argument.uuid.invalid", &[], reader)),
|
|
}
|
|
}
|
|
ArgType::GameProfile => {
|
|
if reader.can_read() && reader.peek() == '@' {
|
|
let s = super::selector::parse(reader, reg, reg.permission >= 2)?;
|
|
if s.include_entities {
|
|
return Err(CommandError::tr_at("argument.player.entities", &[], reader));
|
|
}
|
|
Arg::Entity(s)
|
|
} else {
|
|
while reader.can_read() && reader.peek() != ' ' {
|
|
reader.skip();
|
|
}
|
|
Arg::Str(reader.string[start..reader.cursor].to_owned())
|
|
}
|
|
}
|
|
ArgType::Id(_) => Arg::Resource(read_id(reader)?),
|
|
// DimensionArgument: checked when the command runs.
|
|
ArgType::Dimension => Arg::Resource(read_id(reader)?),
|
|
ArgType::Time { min } => {
|
|
let v = reader.read_float()?;
|
|
let unit = reader.read_unquoted_string();
|
|
let Some(m) = time_unit(unit) else {
|
|
return Err(CommandError::tr_at(
|
|
"argument.time.invalid_unit",
|
|
&[],
|
|
reader,
|
|
));
|
|
};
|
|
// Math.round(float): floor(x + 0.5).
|
|
let ticks = (v * m as f32 + 0.5).floor() as i32;
|
|
if ticks < *min {
|
|
return Err(CommandError::tr_at(
|
|
"argument.time.tick_count_too_low",
|
|
&[min, &ticks],
|
|
reader,
|
|
));
|
|
}
|
|
Arg::Int(ticks)
|
|
}
|
|
ArgType::GameMode => {
|
|
let name = reader.read_unquoted_string();
|
|
match GameMode::from_name(name) {
|
|
Some(m) => Arg::GameMode(m),
|
|
None => {
|
|
return Err(CommandError::tr_at(
|
|
"argument.gamemode.invalid",
|
|
&[&name],
|
|
reader,
|
|
));
|
|
}
|
|
}
|
|
}
|
|
ArgType::Nbt => {
|
|
super::snbt::parse_compound_argument(reader)?;
|
|
Arg::Str(reader.string[start..reader.cursor].to_owned())
|
|
}
|
|
ArgType::Component | ArgType::Style => {
|
|
// ParserBasedArgument.withCodec: SNBT, then the codec (errors at the start).
|
|
let tag = super::snbt::parse_tag_argument(reader)?;
|
|
let (decoded, key) = if matches!(self, ArgType::Style) {
|
|
(
|
|
super::component::decode_style(&tag),
|
|
"argument.style.invalid",
|
|
)
|
|
} else {
|
|
(super::component::decode(&tag), "argument.component.invalid")
|
|
};
|
|
if let Err(m) = decoded {
|
|
reader.cursor = start;
|
|
return Err(CommandError::tr_at(key, &[&m], reader));
|
|
}
|
|
let text = &reader.string[start..reader.cursor];
|
|
match crate::component::parse_snbt(text) {
|
|
Ok((v, _)) => Arg::Str(v.to_string()),
|
|
Err(_) => Arg::Str(text.to_owned()),
|
|
}
|
|
}
|
|
ArgType::Swizzle => {
|
|
let mut axes = String::new();
|
|
while reader.can_read() && reader.peek() != ' ' {
|
|
let c = reader.read();
|
|
if !matches!(c, 'x' | 'y' | 'z') || axes.contains(c) {
|
|
return Err(CommandError::tr_at(
|
|
"arguments.swizzle.invalid",
|
|
&[],
|
|
reader,
|
|
));
|
|
}
|
|
axes.push(c);
|
|
}
|
|
Arg::Str(axes)
|
|
}
|
|
ArgType::ScoreHolder { multiple } => {
|
|
if reader.can_read() && reader.peek() == '@' {
|
|
let sel = super::selector::parse(reader, reg, reg.permission >= 2)?;
|
|
if !*multiple && sel.limit > 1 {
|
|
return Err(CommandError::tr_at("argument.entity.toomany", &[], reader));
|
|
}
|
|
Arg::ScoreHolder(ScoreHolderArg::Selector(sel))
|
|
} else {
|
|
while reader.can_read() && reader.peek() != ' ' {
|
|
reader.skip();
|
|
}
|
|
let text = &reader.string[start..reader.cursor];
|
|
if text == "*" {
|
|
Arg::ScoreHolder(ScoreHolderArg::Wildcard)
|
|
} else {
|
|
Arg::ScoreHolder(ScoreHolderArg::Name(text.to_owned()))
|
|
}
|
|
}
|
|
}
|
|
ArgType::Objective | ArgType::Team => {
|
|
Arg::Str(reader.read_unquoted_string().to_owned())
|
|
}
|
|
ArgType::Criteria => {
|
|
while reader.can_read() && reader.peek() != ' ' {
|
|
reader.skip();
|
|
}
|
|
let id = &reader.string[start..reader.cursor];
|
|
if !crate::scoreboard::criteria_exists(id, reg) {
|
|
reader.cursor = start;
|
|
return Err(CommandError::tr_at(
|
|
"argument.criteria.invalid",
|
|
&[&id],
|
|
reader,
|
|
));
|
|
}
|
|
Arg::Str(id.to_owned())
|
|
}
|
|
ArgType::ScoreboardSlot => {
|
|
let name = reader.read_unquoted_string();
|
|
if !crate::scoreboard::display_slot_valid(name) {
|
|
return Err(CommandError::tr_at(
|
|
"argument.scoreboardDisplaySlot.invalid",
|
|
&[&name],
|
|
reader,
|
|
));
|
|
}
|
|
Arg::Str(name.to_owned())
|
|
}
|
|
ArgType::Operation => {
|
|
if !reader.can_read() {
|
|
return Err(CommandError::tr_at(
|
|
"arguments.operation.invalid",
|
|
&[],
|
|
reader,
|
|
));
|
|
}
|
|
while reader.can_read() && reader.peek() != ' ' {
|
|
reader.skip();
|
|
}
|
|
let op = &reader.string[start..reader.cursor];
|
|
if !OPERATIONS.contains(&op) {
|
|
return Err(CommandError::tr("arguments.operation.invalid", &[]));
|
|
}
|
|
Arg::Str(op.to_owned())
|
|
}
|
|
ArgType::TeamColor => {
|
|
let name = reader.read_unquoted_string();
|
|
if crate::scoreboard::team_color_rgb(name).is_none() {
|
|
return Err(CommandError::tr_at(
|
|
"argument.color.invalid",
|
|
&[&name],
|
|
reader,
|
|
));
|
|
}
|
|
Arg::Str(name.to_owned())
|
|
}
|
|
ArgType::IntRange => Arg::IntRange(read_int_bounds(reader)?),
|
|
ArgType::FloatRange => Arg::DoubleRange(read_double_bounds(reader)?),
|
|
ArgType::Name(_) => Arg::Str(reader.read_string()?),
|
|
ArgType::Vec2 | ArgType::ColumnPos => {
|
|
let block = matches!(self, ArgType::ColumnPos);
|
|
let one = |reader: &mut Reader| {
|
|
if block {
|
|
parse_coord_int(reader)
|
|
} else {
|
|
parse_coord_double(reader, false)
|
|
}
|
|
};
|
|
let x = one(reader)?;
|
|
if !reader.can_read() || reader.peek() != ' ' {
|
|
reader.cursor = start;
|
|
return Err(CommandError::tr_at(
|
|
"argument.pos2d.incomplete",
|
|
&[],
|
|
reader,
|
|
));
|
|
}
|
|
reader.skip();
|
|
let z = one(reader)?;
|
|
Arg::Coords(Coordinates::World([
|
|
x,
|
|
Coord {
|
|
relative: true,
|
|
value: 0.0,
|
|
},
|
|
z,
|
|
]))
|
|
}
|
|
ArgType::Particle => {
|
|
// ParticleArgument.readParticle: the type, then SNBT options
|
|
// decoded by the type's codec (errors without context).
|
|
let id = read_identifier(reader)?;
|
|
let known = reg.ids("minecraft:particle_type");
|
|
let exists = if known.is_empty() {
|
|
crate::particles::ParticleType::from_name(&id).is_some()
|
|
} else {
|
|
known.contains(&id)
|
|
};
|
|
if !exists {
|
|
return Err(CommandError::tr_at("particle.notFound", &[&id], reader));
|
|
}
|
|
let options = if reader.can_read() && reader.peek() == '{' {
|
|
super::snbt::parse_tag_argument(reader)?
|
|
} else {
|
|
horizon_world::nbt::Tag::Compound(Default::default())
|
|
};
|
|
if let Err(m) = particle_options(&id, &options) {
|
|
return Err(CommandError::tr("particle.invalidOptions", &[&m]));
|
|
}
|
|
Arg::Str(reader.string[start..reader.cursor].to_owned())
|
|
}
|
|
ArgType::Enum(words) => {
|
|
let word = reader.read_unquoted_string();
|
|
if !words.contains(&word) {
|
|
reader.cursor = start;
|
|
return Err(CommandError::tr_at("command.unknown.argument", &[], reader));
|
|
}
|
|
Arg::Str(word.to_owned())
|
|
}
|
|
ArgType::Function => {
|
|
let tag = reader.can_read() && reader.peek() == '#';
|
|
if tag {
|
|
reader.skip();
|
|
}
|
|
let id = read_id(reader)?;
|
|
Arg::Resource(if tag { format!("#{id}") } else { id })
|
|
}
|
|
ArgType::Slots | ArgType::Slot => {
|
|
// SlotRanges.read (the error is reported after the name).
|
|
while reader.can_read() && reader.peek() != ' ' {
|
|
reader.skip();
|
|
}
|
|
let word = &reader.string[start..reader.cursor];
|
|
let Some((_, size)) = slot_ranges().into_iter().find(|(n, _)| n == word) else {
|
|
return Err(CommandError::tr_at("slot.unknown", &[&word], reader));
|
|
};
|
|
if matches!(self, ArgType::Slot) && size != 1 {
|
|
return Err(CommandError::tr_at(
|
|
"slot.only_single_allowed",
|
|
&[&word],
|
|
reader,
|
|
));
|
|
}
|
|
Arg::Str(word.to_owned())
|
|
}
|
|
ArgType::SlotSource => {
|
|
// SlotSourceArgument: a slot range name, else a slot source id or inline value.
|
|
while reader.can_read() && reader.peek() != ' ' {
|
|
reader.skip();
|
|
}
|
|
let word = &reader.string[start..reader.cursor];
|
|
if slot_ranges().iter().any(|(n, _)| n == word) {
|
|
Arg::Str(word.to_owned())
|
|
} else {
|
|
reader.cursor = start;
|
|
super::codec::resource_or_id(reader, reg, "minecraft:slot_source")?;
|
|
Arg::Str(reader.string[start..reader.cursor].to_owned())
|
|
}
|
|
}
|
|
ArgType::ResourceOrId(registry) => {
|
|
super::codec::resource_or_id(reader, reg, registry)?;
|
|
Arg::Resource(reader.string[start..reader.cursor].to_owned())
|
|
}
|
|
ArgType::NbtPath => {
|
|
parse_nbt_path(reader)?;
|
|
Arg::Str(reader.string[start..reader.cursor].to_owned())
|
|
}
|
|
ArgType::NbtTag => {
|
|
super::snbt::parse_tag_argument(reader)?;
|
|
Arg::Str(reader.string[start..reader.cursor].to_owned())
|
|
}
|
|
ArgType::Anchor => {
|
|
let name = reader.read_unquoted_string();
|
|
match name {
|
|
"eyes" => Arg::Anchor(true),
|
|
"feet" => Arg::Anchor(false),
|
|
_ => {
|
|
reader.cursor = start;
|
|
return Err(CommandError::tr_at(
|
|
"argument.anchor.invalid",
|
|
&[&name],
|
|
reader,
|
|
));
|
|
}
|
|
}
|
|
}
|
|
})
|
|
}
|
|
pub fn suggest(
|
|
&self,
|
|
builder: &mut SuggestionsBuilder,
|
|
reg: &Registries,
|
|
context: &Context,
|
|
_name: &str,
|
|
) {
|
|
let _ = context;
|
|
match self {
|
|
ArgType::Bool => builder.suggest_matching(["true", "false"]),
|
|
ArgType::Entity { .. } => {
|
|
let players = reg.players.clone();
|
|
super::selector::suggest(builder, reg, &|b| {
|
|
b.suggest_matching(players.iter().map(String::as_str))
|
|
});
|
|
}
|
|
ArgType::BlockPos => suggest_coordinates(builder, reg, self, true),
|
|
ArgType::Vec3 { .. } => suggest_coordinates(builder, reg, self, false),
|
|
// RotationArgument and AngleArgument have no suggestions.
|
|
ArgType::Rotation | ArgType::Angle => {}
|
|
ArgType::Item => super::item::suggest_stack(builder, reg),
|
|
ArgType::ItemPredicate => super::item::suggest_predicate(builder, reg),
|
|
ArgType::BlockState => super::block::suggest(builder, reg, false),
|
|
ArgType::BlockPredicate => super::block::suggest(builder, reg, true),
|
|
ArgType::Resource(kind) => suggest_resources(builder, reg.ids(kind.registry()), ""),
|
|
ArgType::Res(registry) | ArgType::ResKey(registry) => {
|
|
// RecipeCommand filters its keys to learnable recipes.
|
|
if *registry == "minecraft:recipe" && !reg.learnable_recipes.is_empty() {
|
|
suggest_resources(builder, ®.learnable_recipes, "")
|
|
} else {
|
|
suggest_resources(builder, reg.ids(registry), "")
|
|
}
|
|
}
|
|
ArgType::ResOrTag(registry) | ArgType::ResOrTagKey(registry) => {
|
|
suggest_resources(builder, reg.tags(registry), "#");
|
|
suggest_resources(builder, reg.ids(registry), "");
|
|
}
|
|
ArgType::StrEnum(values, _) => builder.suggest_matching(values.iter().copied()),
|
|
ArgType::HexColor => builder.suggest_matching(["F00", "FF0000"]),
|
|
ArgType::GameProfile => {
|
|
let players = reg.players.clone();
|
|
super::selector::suggest(builder, reg, &|b| {
|
|
b.suggest_matching(players.iter().map(String::as_str))
|
|
});
|
|
}
|
|
ArgType::Id(list) => {
|
|
let values = match *list {
|
|
"storages" => reg.storages.clone(),
|
|
"bossbars" => reg.bossbars.clone(),
|
|
"schedules" => reg.schedules.clone(),
|
|
"stopwatches" => reg.stopwatches.clone(),
|
|
"recipes" => reg.recipes.clone(),
|
|
"sounds" => reg.sounds.clone(),
|
|
"damage_types" => reg.damage_types.clone(),
|
|
"attributes" => reg.attributes.clone(),
|
|
"loot_tables" => reg.loot_tables.clone(),
|
|
"templates" => reg.templates.clone(),
|
|
"random_sequences" => reg.random_sequences.clone(),
|
|
"predicates" => reg.predicates.clone(),
|
|
"item_modifiers" => reg.item_modifiers.clone(),
|
|
"time_markers" => reg.time_markers.clone(),
|
|
"advancements" => reg.advancements.clone(),
|
|
_ => Vec::new(),
|
|
};
|
|
suggest_resources(builder, &values, "");
|
|
}
|
|
ArgType::Dimension => {
|
|
let dims = reg.dimensions.clone();
|
|
suggest_resources(builder, &dims, "");
|
|
}
|
|
ArgType::Time { .. } => {
|
|
let mut r = Reader::new(builder.remaining());
|
|
if r.read_float().is_ok() {
|
|
let mut b = builder.offset(builder.start + r.cursor);
|
|
b.suggest_matching(["d", "s", "t", ""]);
|
|
builder.out.extend(b.out);
|
|
}
|
|
}
|
|
ArgType::GameMode => builder.suggest_matching(GameMode::ALL.map(GameMode::name)),
|
|
ArgType::ScoreHolder { .. } => {
|
|
// ScoreHolderArgument.SUGGEST_SCORE_HOLDERS.
|
|
let players = reg.players.clone();
|
|
super::selector::suggest(builder, reg, &|b| {
|
|
b.suggest_matching(players.iter().map(String::as_str))
|
|
});
|
|
}
|
|
ArgType::Objective => {
|
|
builder.suggest_matching(reg.objectives.iter().map(String::as_str))
|
|
}
|
|
ArgType::Team => builder.suggest_matching(reg.teams.iter().map(String::as_str)),
|
|
ArgType::Criteria => {
|
|
let mut ids: Vec<String> = crate::scoreboard::CUSTOM_CRITERIA
|
|
.iter()
|
|
.map(|s| (*s).to_owned())
|
|
.collect();
|
|
for c in crate::scoreboard::team_colors() {
|
|
ids.push(format!("teamkill.{c}"));
|
|
ids.push(format!("killedByTeam.{c}"));
|
|
}
|
|
let stat = |ty: &str, key: &str| crate::scoreboard::stat_criteria(ty, key);
|
|
ids.extend(reg.blocks.keys().map(|b| stat("mined", b)));
|
|
for ty in ["crafted", "used", "broken", "picked_up", "dropped"] {
|
|
ids.extend(reg.items.iter().map(|i| stat(ty, i)));
|
|
}
|
|
for ty in ["killed", "killed_by"] {
|
|
ids.extend(reg.entity_types.iter().map(|e| stat(ty, e)));
|
|
}
|
|
ids.extend(
|
|
crate::scoreboard::CUSTOM_STATS
|
|
.iter()
|
|
.map(|c| stat("custom", &format!("minecraft:{c}"))),
|
|
);
|
|
builder.suggest_matching(ids.iter().map(String::as_str));
|
|
}
|
|
ArgType::ScoreboardSlot => {
|
|
let slots = crate::scoreboard::display_slots();
|
|
builder.suggest_matching(slots.iter().map(String::as_str));
|
|
}
|
|
ArgType::Operation => builder.suggest_matching(OPERATIONS),
|
|
ArgType::Enum(words) => builder.suggest_matching(words.iter().copied()),
|
|
ArgType::Particle => {
|
|
let known = reg.ids("minecraft:particle_type");
|
|
if known.is_empty() {
|
|
let names: Vec<String> = crate::particles::ParticleType::ALL
|
|
.iter()
|
|
.map(|t| format!("minecraft:{}", t.name()))
|
|
.collect();
|
|
suggest_resources(builder, &names, "");
|
|
} else {
|
|
suggest_resources(builder, known, "");
|
|
}
|
|
}
|
|
ArgType::Vec2 => suggest_coordinates(builder, reg, self, false),
|
|
ArgType::ColumnPos => suggest_coordinates(builder, reg, self, true),
|
|
ArgType::Name(list) => {
|
|
let names = match *list {
|
|
"datapacks_enabled" => reg.datapacks_enabled.clone(),
|
|
_ => reg.datapacks_disabled.clone(),
|
|
};
|
|
builder.suggest_matching(names.iter().map(String::as_str));
|
|
}
|
|
// FunctionArgument has no suggestions of its own (nodes add SUGGEST_FUNCTION).
|
|
ArgType::Function => {}
|
|
ArgType::Slots | ArgType::Slot => {
|
|
let names: Vec<String> = if matches!(self, ArgType::Slots) {
|
|
slot_ranges().into_iter().map(|(n, _)| n).collect()
|
|
} else {
|
|
slot_names()
|
|
};
|
|
builder.suggest_matching(names.iter().map(String::as_str));
|
|
}
|
|
ArgType::SlotSource => {
|
|
let mut sub = builder.offset(builder.start);
|
|
let names: Vec<String> = slot_ranges().into_iter().map(|(n, _)| n).collect();
|
|
sub.suggest_matching(names.iter().map(String::as_str));
|
|
builder.add(sub);
|
|
suggest_resources(builder, reg.ids("minecraft:slot_source"), "");
|
|
}
|
|
ArgType::ResourceOrId(registry) => suggest_resources(builder, reg.ids(registry), ""),
|
|
ArgType::TeamColor => builder.suggest_matching(crate::scoreboard::team_colors()),
|
|
ArgType::Anchor => builder.suggest_matching(["eyes", "feet"]),
|
|
ArgType::Component | ArgType::Style | ArgType::NbtTag => super::snbt::suggest(builder),
|
|
ArgType::Swizzle | ArgType::Message | ArgType::Nbt => {}
|
|
_ => {}
|
|
}
|
|
}
|
|
}
|