diff --git a/crates/horizon-client/src/command/args.rs b/crates/horizon-client/src/command/args.rs index ccced67a7..d9528d3f2 100644 --- a/crates/horizon-client/src/command/args.rs +++ b/crates/horizon-client/src/command/args.rs @@ -551,6 +551,14 @@ impl Selector { pub fn single(&self) -> bool { self.limit <= 1 } + /// `EntitySelectorParser.setWorldLimited`: a selector with a spatial + /// constraint (`distance` or a position) reaches the level the command + /// runs in only; an unbounded one reaches every loaded level. + pub fn world_limited(&self) -> bool { + self.distance.is_some() + || self.pos.iter().any(Option::is_some) + || self.delta.iter().any(Option::is_some) + } } #[derive(Clone, Debug, PartialEq)] pub struct BlockInput { diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs index db49087b2..a154c7a18 100644 --- a/crates/horizon-client/src/game.rs +++ b/crates/horizon-client/src/game.rs @@ -9598,7 +9598,7 @@ impl Game<'_> { velocity, on_ground, ); - self.creatures.projectiles.push(arrow); + self.add_projectile(arrow); self.player_projectile_shot(); let pitch = 1.0 / (self.world.random.next_float() * 0.4 + 1.2) + power * 0.5; self.audio diff --git a/crates/horizon-client/src/game/commands.rs b/crates/horizon-client/src/game/commands.rs index 22041c3b2..f79480428 100644 --- a/crates/horizon-client/src/game/commands.rs +++ b/crates/horizon-client/src/game/commands.rs @@ -42,9 +42,10 @@ pub(super) enum Target { Guest(u32), Mob(u32), Item(u32), - Orb(usize), - /// By index in `creatures.projectiles`. - Projectile(usize), + /// An experience orb, by its entity id. + Orb(u32), + /// A projectile, by its entity id. + Projectile(u32), Stand(u32), Frame(u32), Painting(u32), @@ -340,14 +341,16 @@ impl Game<'_> { .iter() .find(|i| i.id == id) .map(|i| [i.position.x, i.position.y, i.position.z]), - Target::Orb(i) => self + Target::Orb(id) => self .orbs - .get(i) + .iter() + .find(|o| o.id == id) .map(|o| [o.position.x, o.position.y, o.position.z]), - Target::Projectile(i) => self + Target::Projectile(id) => self .creatures .projectiles - .get(i) + .iter() + .find(|a| a.id == id) .map(|a| [a.position.x, a.position.y, a.position.z]), Target::Stand(id) => self .armor_stands @@ -399,10 +402,11 @@ impl Game<'_> { }), Target::Item(_) => "minecraft:item".into(), Target::Orb(_) => "minecraft:experience_orb".into(), - Target::Projectile(i) => self + Target::Projectile(id) => self .creatures .projectiles - .get(i) + .iter() + .find(|p| p.id == id) .map_or_else(String::new, |p| p.kind.id().into()), Target::Stand(_) => "minecraft:armor_stand".into(), Target::Frame(id) => { @@ -512,51 +516,72 @@ impl Game<'_> { s.pos[2].unwrap_or(p[2]), ] }; - let mut candidates: Vec = Vec::new(); + let mut source_candidates: Vec = Vec::new(); match (s.kind, self.command_source) { // @s: the executing entity (none for a server source). - ('s', Some(source)) => candidates.extend(source.entity), - ('s', None) => candidates.extend(self.source_entity()), + ('s', Some(source)) => source_candidates.extend(source.entity), + ('s', None) => source_candidates.extend(self.source_entity()), // A guest in place is among the players, in join order. _ if self.player.is_some() && self.lan_acting.is_none() => { - candidates.push(Target::Player); + source_candidates.push(Target::Player); } _ => {} } if s.kind != 's' { - use horizon_client::projectiles::ProjectileKind as K; - candidates.extend(self.player_candidates(s)); - candidates.extend( - self.mobs - .iter() - .filter(|m| m.death_time == 0) - .map(|m| Target::Mob(m.id)), - ); - candidates.extend(self.dropped.iter().map(|i| Target::Item(i.id))); - candidates.extend((0..self.orbs.len()).map(Target::Orb)); - candidates.extend( - self.creatures - .projectiles - .iter() - .enumerate() - // The kinds /data can write (entity_nbt). - .filter(|(_, p)| { - p.arrow.is_some() - || matches!(p.kind, K::LargeFireball { .. } | K::SmallFireball) - }) - .map(|(i, _)| Target::Projectile(i)), - ); - candidates.extend(self.armor_stands.iter().map(|a| Target::Stand(a.id))); - candidates.extend(self.item_frames.iter().map(|f| Target::Frame(f.id))); - 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))); + source_candidates.extend(self.player_candidates(s)); } + let source_dim = self.dim; + // A selector with a spatial constraint reaches the level the command + // runs in only; an unbounded one reaches every loaded level + // (EntitySelector.findEntities). + let dims = if s.world_limited() { + vec![source_dim] + } else { + self.loaded_dims() + }; + let mut out: Vec<(Target, f64)> = Vec::new(); + for dim in dims { + let back = self.enter_command_level(dim); + let mut candidates = Vec::new(); + if dim == source_dim { + candidates.append(&mut source_candidates); + } + if s.kind != 's' { + candidates.extend(self.level_candidates()); + } + out.extend(self.select_in_level(candidates, s, origin)); + if let Some(back) = back { + self.enter_command_level(back); + } + } + match s.sort { + Sort::Nearest => out.sort_by(|a, b| a.1.total_cmp(&b.1)), + Sort::Furthest => out.sort_by(|a, b| b.1.total_cmp(&a.1)), + Sort::Random => { + for i in (1..out.len()).rev() { + let j = self.world.random.next_int_bound(i as i32 + 1).unwrap_or(0) as usize; + out.swap(i, j); + } + } + Sort::Arbitrary => {} + } + out.into_iter() + .take(s.limit.max(1)) + .map(|(t, _)| t) + .collect() + } + /// The candidates of the level in place that pass the selector + /// (EntitySelector.getPredicate). + fn select_in_level( + &mut self, + candidates: Vec, + s: &Selector, + origin: [f64; 3], + ) -> Vec<(Target, f64)> { let level = self.experience.level; let creative = self.creative; let passing = self.selector_extra_filter(&candidates, s); - let mut out: Vec<(Target, f64)> = candidates + candidates .into_iter() .filter_map(|t| { let p = self.target_position(t)?; @@ -628,23 +653,95 @@ impl Game<'_> { } Some((t, d2)) }) - .collect(); - match s.sort { - Sort::Nearest => out.sort_by(|a, b| a.1.total_cmp(&b.1)), - Sort::Furthest => out.sort_by(|a, b| b.1.total_cmp(&a.1)), - Sort::Random => { - for i in (1..out.len()).rev() { - let j = self.world.random.next_int_bound(i as i32 + 1).unwrap_or(0) as usize; - out.swap(i, j); - } - } - Sort::Arbitrary => {} - } - out.into_iter() - .take(s.limit.max(1)) - .map(|(t, _)| t) .collect() } + /// The entities of the level in place a selector can find. + fn level_candidates(&self) -> Vec { + use horizon_client::projectiles::ProjectileKind as K; + let mut candidates = Vec::new(); + candidates.extend( + self.mobs + .iter() + .filter(|m| m.death_time == 0) + .map(|m| Target::Mob(m.id)), + ); + candidates.extend(self.dropped.iter().map(|i| Target::Item(i.id))); + candidates.extend(self.orbs.iter().map(|o| Target::Orb(o.id))); + candidates.extend( + self.creatures + .projectiles + .iter() + // The kinds /data can write (entity_nbt). + .filter(|p| { + p.arrow.is_some() + || matches!(p.kind, K::LargeFireball { .. } | K::SmallFireball) + }) + .map(|p| Target::Projectile(p.id)), + ); + candidates.extend(self.armor_stands.iter().map(|a| Target::Stand(a.id))); + candidates.extend(self.item_frames.iter().map(|f| Target::Frame(f.id))); + 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))); + candidates + } + /// The loaded levels, in the order the server holds them: the + /// overworld, the nether, the end (MinecraftServer.getAllLevels). + fn loaded_dims(&self) -> Vec { + let mut dims = vec![self.dim]; + dims.extend(self.levels.parked_dims()); + dims.sort_by_key(|d| match d { + Dim::Overworld => 0, + Dim::Nether => 1, + Dim::End => 2, + }); + dims + } + /// Whether the level in place holds the entity a target names. + fn level_holds(&self, t: Target) -> bool { + match t { + // A player is in no level of its own. + Target::Player | Target::Guest(_) => true, + Target::Mob(id) => self.mobs.iter().any(|m| m.id == id), + Target::Item(id) => self.dropped.iter().any(|i| i.id == id), + Target::Orb(id) => self.orbs.iter().any(|o| o.id == id), + Target::Projectile(id) => self.creatures.projectiles.iter().any(|p| p.id == id), + Target::Stand(id) => self.armor_stands.iter().any(|a| a.id == id), + Target::Frame(id) => self.item_frames.iter().any(|f| f.id == id), + Target::Painting(id) => self.paintings.iter().any(|p| p.id == id), + Target::Boat(id) => self.boats.iter().any(|b| b.id == id), + Target::Cart(id) => self.carts.iter().any(|c| c.id == id), + Target::Other(id) => self.others.iter().any(|o| o.id == id), + } + } + /// Run `f` with the level that holds the entity a target names in place + /// (the entity ids are unique across the loaded levels) and put the + /// level back afterwards. `f` does not run when no level holds the + /// entity. + pub(in crate::game) fn in_target_level( + &mut self, + t: Target, + f: impl FnOnce(&mut Self) -> R, + ) -> Option { + if self.level_holds(t) { + return Some(f(self)); + } + for dim in self.levels.parked_dims() { + let back = self.enter_command_level(dim); + if self.level_holds(t) { + let r = f(self); + if let Some(back) = back { + self.enter_command_level(back); + } + return Some(r); + } + if let Some(back) = back { + self.enter_command_level(back); + } + } + None + } fn entity_tag_matches(&self, tag: &str, ty: &str) -> bool { let path = self.options.resources.join(format!( "data/minecraft/tags/entity_type/{}.json", @@ -1104,6 +1201,10 @@ impl Game<'_> { Ok(targets.len() as i32) } fn teleport_to(&mut self, t: Target, pos: [f64; 3], rotation: Option<[f32; 2]>) { + // An entity in another level is teleported in the level that holds it. + let _ = self.in_target_level(t, |g| g.teleport_to_in_level(t, pos, rotation)); + } + fn teleport_to_in_level(&mut self, t: Target, pos: [f64; 3], rotation: Option<[f32; 2]>) { let v = Vec3::new(pos[0], pos[1], pos[2]); match t { Target::Guest(_) => { @@ -1152,14 +1253,14 @@ impl Game<'_> { i.previous = v; } } - Target::Orb(i) => { - if let Some(o) = self.orbs.get_mut(i) { + Target::Orb(id) => { + if let Some(o) = self.orbs.iter_mut().find(|o| o.id == id) { o.position = v; o.previous = v; } } - Target::Projectile(i) => { - if let Some(a) = self.creatures.projectiles.get_mut(i) { + Target::Projectile(id) => { + if let Some(a) = self.creatures.projectiles.iter_mut().find(|a| a.id == id) { a.position = v; a.previous = v; } @@ -1558,6 +1659,10 @@ impl Game<'_> { Ok(duration.unwrap_or(-1)) } fn kill_target(&mut self, t: Target) { + // An entity in another level is killed in the level that holds it. + let _ = self.in_target_level(t, |g| g.kill_target_in_level(t)); + } + fn kill_target_in_level(&mut self, t: Target) { match t { Target::Guest(_) => { self.for_player(t, |g| g.kill_target(Target::Player)); @@ -1577,16 +1682,13 @@ impl Game<'_> { } } Target::Item(id) => self.dropped.retain(|i| i.id != id), - Target::Orb(i) => { - if i < self.orbs.len() { - self.orbs[i].age = u32::MAX / 2; + Target::Orb(id) => { + if let Some(o) = self.orbs.iter_mut().find(|o| o.id == id) { + o.age = u32::MAX / 2; } } - // cmd_kill goes from the highest index down. - Target::Projectile(i) => { - if i < self.creatures.projectiles.len() { - self.creatures.projectiles.remove(i); - } + Target::Projectile(id) => { + self.creatures.projectiles.retain(|p| p.id != id); } Target::Stand(id) => self.armor_stands.retain(|a| a.id != id), Target::Frame(id) => self.item_frames.retain(|f| f.id != id), @@ -1595,6 +1697,8 @@ impl Game<'_> { Target::Cart(id) => self.carts.retain(|c| c.id != id), Target::Other(id) => self.others.retain(|o| o.id != id), } + // The orbs marked for removal are gone (Entity.kill removes them). + self.orbs.retain(|o| o.age < u32::MAX / 2); } fn cmd_kill(&mut self, ctx: &Context) -> R { let targets = if ctx.get("targets").is_some() { @@ -1602,19 +1706,18 @@ impl Game<'_> { } else { vec![self.implied_player()] }; - let names: Vec = targets.iter().map(|&t| self.target_name(t)).collect(); - // Remove indexed entities from the back so earlier indices stay valid. - let mut ordered = targets.clone(); - ordered.sort_by_key(|t| { - std::cmp::Reverse(match t { - Target::Orb(i) | Target::Projectile(i) => *i, - _ => 0, - }) - }); - for t in ordered { + let mut names: Vec = Vec::new(); + for &t in &targets { + // The name of an entity in another level is read there. + let name = match self.in_target_level(t, |g| g.target_name(t)) { + Some(name) => name, + None => self.target_name(t), + }; + names.push(name); + } + for &t in &targets { self.kill_target(t); } - self.orbs.retain(|o| o.age < u32::MAX / 2); let message = if targets.len() == 1 { Text::translate("commands.kill.success.single", &[names[0].clone()]) } else { diff --git a/crates/horizon-client/src/game/commands/data.rs b/crates/horizon-client/src/game/commands/data.rs index ac16c5e7c..6dc5b6a75 100644 --- a/crates/horizon-client/src/game/commands/data.rs +++ b/crates/horizon-client/src/game/commands/data.rs @@ -31,8 +31,13 @@ fn set_key(tag: &mut Tag, key: &str, value: Tag) { impl Game<'_> { // ---- entity data --------------------------------------------------- - /// `NbtPredicate.getEntityTagToCompare`: the entity as saved. + /// `NbtPredicate.getEntityTagToCompare`: the entity as saved. An entity + /// in another level is read in the level that holds it. pub(in crate::game) fn entity_nbt(&mut self, t: Target) -> Option { + self.in_target_level(t, |g| g.entity_nbt_in_level(t)) + .flatten() + } + fn entity_nbt_in_level(&mut self, t: Target) -> Option { let player_uuid = self.level.player_uuid; Some(match t { Target::Guest(_) => { @@ -113,9 +118,11 @@ impl Game<'_> { 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::Projectile(i) => { - let p = self.creatures.projectiles.get(i)?; + Target::Orb(id) => { + entity_nbt::orb_to_nbt(self.orbs.iter().find(|o| o.id == id)?, random_uuid()) + } + Target::Projectile(id) => { + let p = self.creatures.projectiles.iter().find(|p| p.id == id)?; let owner = if p.owner == Some(horizon_client::mobs::Who::Player) { player_uuid } else { @@ -397,6 +404,19 @@ impl Game<'_> { } pub(super) fn cmd_data(&mut self, id: &str, ctx: &Context) -> R { let target = self.data_ref(ctx, 0)?; + // An entity in another level is read and written in the level that + // holds it. + if let DataRef::Entity(t) = &target { + let t = *t; + let target = target.clone(); + return match self.in_target_level(t, |g| g.cmd_data_in(id, ctx, target)) { + Some(r) => r, + None => Err(err("argument.entity.notfound.entity", &[])), + }; + } + self.cmd_data_in(id, ctx, target) + } + fn cmd_data_in(&mut self, id: &str, ctx: &Context, target: DataRef) -> R { match id { "data.merge" => { let Some(Arg::Str(nbt)) = ctx.get("nbt") else { diff --git a/crates/horizon-client/src/game/creatures.rs b/crates/horizon-client/src/game/creatures.rs index e895cb7f7..a5fb497d7 100644 --- a/crates/horizon-client/src/game/creatures.rs +++ b/crates/horizon-client/src/game/creatures.rs @@ -892,6 +892,15 @@ impl Game<'_> { self.spawn_item(d, at, [0.0, 0.2, 0.0], 10); } } + /// Adds a projectile, giving it an id from the entity counter + /// (`Entity.id`, the same counter as the rest) when it has none. + pub(super) fn add_projectile(&mut self, mut p: horizon_client::projectiles::Projectile) { + if p.id == 0 { + self.next_entity += 1; + p.id = self.next_entity; + } + self.creatures.projectiles.push(p); + } pub(super) fn handle_mob_events(&mut self, events: Vec) -> Result<()> { for e in events { match e { @@ -1078,7 +1087,7 @@ impl Game<'_> { self.next_entity += 1; p.id = self.next_entity; let (owner, at) = (p.owner, [p.position.x, p.position.y, p.position.z]); - self.creatures.projectiles.push(p); + self.add_projectile(p); self.projectile_event("minecraft:projectile_shoot", owner, at); } MobEvent::Spawn(mut m) => { @@ -2160,7 +2169,7 @@ impl Game<'_> { } } if keep { - self.creatures.projectiles.push(arrow); + self.add_projectile(arrow); } } /// `TargetBlock.onProjectileHit`: a target block takes its power from @@ -3162,7 +3171,7 @@ impl Game<'_> { velocity, on_ground, ); - self.creatures.projectiles.push(proj); + self.add_projectile(proj); self.player_projectile_shot(); // ItemStack.use's applyAfterUseComponentSideEffects: the pearl's // second is the `use_cooldown` component, as for any thrown item. diff --git a/crates/horizon-client/src/game/crossbow.rs b/crates/horizon-client/src/game/crossbow.rs index bc49c4b90..d66610183 100644 --- a/crates/horizon-client/src/game/crossbow.rs +++ b/crates/horizon-client/src/game/crossbow.rs @@ -222,7 +222,7 @@ impl Game<'_> { a.pierce = pierce; } arrow.shoot(&mut self.world.random, dir.to_array(), power, 1.0); - self.creatures.projectiles.push(arrow); + self.add_projectile(arrow); } self.player_projectile_shot(); let pitch = if index == 0 { diff --git a/crates/horizon-client/src/game/dispenser.rs b/crates/horizon-client/src/game/dispenser.rs index 61725c6ab..670750f63 100644 --- a/crates/horizon-client/src/game/dispenser.rs +++ b/crates/horizon-client/src/game/dispenser.rs @@ -1034,7 +1034,7 @@ impl Game<'_> { a.pickup = horizon_client::arrows::Pickup::Allowed; } shot.shoot(&mut own, dir, power, uncertainty); - self.creatures.projectiles.push(shot); + self.add_projectile(shot); } } } diff --git a/crates/horizon-client/src/game/levels.rs b/crates/horizon-client/src/game/levels.rs index 29bf6d511..d41485e2d 100644 --- a/crates/horizon-client/src/game/levels.rs +++ b/crates/horizon-client/src/game/levels.rs @@ -120,6 +120,10 @@ impl Levels { .iter_mut() .map(|(d, p)| (*d, &mut p.world.chunks)) } + /// The levels that are not in place, by dimension. + pub(super) fn parked_dims(&self) -> Vec { + self.parked.keys().copied().collect() + } } impl Game<'_> { diff --git a/crates/horizon-client/src/game/persist.rs b/crates/horizon-client/src/game/persist.rs index b5e650e70..09622cf18 100644 --- a/crates/horizon-client/src/game/persist.rs +++ b/crates/horizon-client/src/game/persist.rs @@ -193,12 +193,12 @@ impl Game<'_> { if let Some(a) = p.arrow.as_mut() { a.last_state = in_block.and_then(|t| self.state_from_nbt(&t)); } - self.creatures.projectiles.push(p); + self.add_projectile(p); } } "minecraft:fireball" | "minecraft:small_fireball" => { if let Some(p) = entity_nbt::fireball_from_nbt(&tag, player_uuid) { - self.creatures.projectiles.push(p); + self.add_projectile(p); } } "minecraft:falling_block" => { diff --git a/crates/horizon-client/src/game/remote_projectiles.rs b/crates/horizon-client/src/game/remote_projectiles.rs index 897999c6b..52210cf3d 100644 --- a/crates/horizon-client/src/game/remote_projectiles.rs +++ b/crates/horizon-client/src/game/remote_projectiles.rs @@ -166,7 +166,7 @@ impl Game<'_> { p.velocity = velocity; p.yaw = yaw; p.pitch = pitch; - self.creatures.projectiles.push(p); + self.add_projectile(p); } } true diff --git a/crates/horizon-client/src/game/wind.rs b/crates/horizon-client/src/game/wind.rs index fb24102ba..63ac2641d 100644 --- a/crates/horizon-client/src/game/wind.rs +++ b/crates/horizon-client/src/game/wind.rs @@ -68,7 +68,7 @@ impl Game<'_> { velocity, on_ground, ); - self.creatures.projectiles.push(proj); + self.add_projectile(proj); let pitch = 0.4 / (self.world.random.next_float() * 0.4 + 0.8); self.audio .play("minecraft:entity.wind_charge.throw", Some(eye), 0.5, pitch); diff --git a/tools/command_exec_corpus.py b/tools/command_exec_corpus.py index d8f925ef0..c3f579772 100644 --- a/tools/command_exec_corpus.py +++ b/tools/command_exec_corpus.py @@ -533,13 +533,21 @@ def execute(): def levels(): """A nether portal round trip: on the way back the Overworld's entities (the - pig left by `entities`) are found and a summon names what it summoned.""" + pig left by `entities`) are found and a summon names what it summoned. An + unbounded selector also reaches the level the player is not in, while a + bounded one does not.""" return [ *setup('/fill 2 231 12 5 236 12 minecraft:obsidian', '/fill 3 232 12 4 235 12 minecraft:nether_portal[axis=x]', - '/tp @s 3.5 232 12.5 0 0'), + '/tp @s 3.5 232 12.5 0 0', + # A cow in the Overworld, in a chunk that stays loaded while the + # player is in the nether. + '/forceload add 0 0', + '/summon minecraft:cow 10.5 210 4.5 {NoAI:1b,NoGravity:1b,Tags:["remote_cow"]}'), {'op': 'portal'}, {'op': 'settle'}, cmd('/execute if dimension minecraft:the_nether run say through the portal'), + cmd('/data get entity @e[tag=remote_cow,limit=1] Pos'), + cmd('/data get entity @e[tag=remote_cow,distance=..128,limit=1] Pos'), {'op': 'portal'}, {'op': 'settle'}, cmd('/execute if dimension minecraft:overworld run say back through the portal'),