Draw /loot from each table's random sequence, as vanilla
LootTable.getRandomItems uses the table's random_sequence, so /loot results are deterministic per world seed; inline loot tables and tool components now work too. The oracle ticks its player like the network listener does. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
@@ -2,6 +2,7 @@
|
||||
use super::{Arg, Context, Game, R, Target, err, items::Owner};
|
||||
use horizon_client::{
|
||||
chunk::{HEIGHT, MIN_Y},
|
||||
command::CommandError,
|
||||
items::ItemStack,
|
||||
scoreboard_cmd::{Holder, Tracker},
|
||||
text::Text,
|
||||
@@ -433,11 +434,20 @@ impl Game<'_> {
|
||||
|
||||
fn tool_stack(&mut self, ctx: &Context) -> R<Option<ItemStack>> {
|
||||
if let Some(Arg::Item(p)) = ctx.get("tool") {
|
||||
let (damage, extra) = match p
|
||||
.components
|
||||
.as_deref()
|
||||
.map(horizon_client::item_data::command_components)
|
||||
{
|
||||
Some(Ok(tag)) => horizon_client::item_data::decode_components(Some(&tag)),
|
||||
Some(Err(e)) => return Err(CommandError::new(Text::literal(e))),
|
||||
None => (0, None),
|
||||
};
|
||||
return Ok(Some(ItemStack {
|
||||
item: p.id.as_str().into(),
|
||||
count: 1,
|
||||
damage: 0,
|
||||
extra: None,
|
||||
damage,
|
||||
extra,
|
||||
}));
|
||||
}
|
||||
let entity = self
|
||||
@@ -461,19 +471,39 @@ impl Game<'_> {
|
||||
let Some(Arg::Resource(table)) = ctx.get("loot_table").cloned() else {
|
||||
return Ok(0);
|
||||
};
|
||||
if !self.res.items.has_loot_table(&table) {
|
||||
return Err(err("argument.resource_or_id.failed_to_parse", &[&table]));
|
||||
}
|
||||
let held = if id == "loot.fish" {
|
||||
self.tool_stack(ctx)?
|
||||
} else {
|
||||
None
|
||||
};
|
||||
let drops =
|
||||
self.res
|
||||
// An inline table (ResourceOrIdArgument): no random sequence.
|
||||
if table.starts_with('{') {
|
||||
let (tag, _) = horizon_world::nbt::parse_snbt(&table)
|
||||
.map_err(|e| err("argument.nbt.invalid", &[&e]))?;
|
||||
let json = horizon_client::scoreboard::tag_to_json(&tag);
|
||||
let drops = self
|
||||
.res
|
||||
.items
|
||||
.loot_table(&table, false, held.as_ref(), &mut self.world.random);
|
||||
(drops, None)
|
||||
.inline_loot_table(&json, &mut self.world.random);
|
||||
(drops, None)
|
||||
} else {
|
||||
if !self.res.items.has_loot_table(&table) {
|
||||
return Err(err("argument.resource_or_id.failed_to_parse", &[&table]));
|
||||
}
|
||||
let held = if id == "loot.fish" {
|
||||
self.tool_stack(ctx)?
|
||||
} else {
|
||||
None
|
||||
};
|
||||
let drops = match self.res.items.loot_random_sequence(&table) {
|
||||
Some(seq) => {
|
||||
let random = self.rand_sequences.get(&seq, self.level.seed);
|
||||
self.res.items.loot_table(&table, false, held.as_ref(), random)
|
||||
}
|
||||
None => self.res.items.loot_table(
|
||||
&table,
|
||||
false,
|
||||
held.as_ref(),
|
||||
&mut self.world.random,
|
||||
),
|
||||
};
|
||||
(drops, None)
|
||||
}
|
||||
}
|
||||
"loot.kill" => {
|
||||
let targets = self.entities(ctx, "target", false)?;
|
||||
@@ -493,12 +523,20 @@ impl Game<'_> {
|
||||
None | Some(Some(Target::Player))
|
||||
);
|
||||
let held = self.slot_get(&super::items::Slot::Inv(self.selected));
|
||||
let drops = self.res.items.entity_drops(
|
||||
&ty,
|
||||
by_player,
|
||||
held.as_ref(),
|
||||
&mut self.world.random,
|
||||
);
|
||||
let drops = match self.res.items.loot_random_sequence(&table) {
|
||||
Some(seq) => {
|
||||
let random = self.rand_sequences.get(&seq, self.level.seed);
|
||||
self.res
|
||||
.items
|
||||
.entity_drops(&ty, by_player, held.as_ref(), random)
|
||||
}
|
||||
None => self.res.items.entity_drops(
|
||||
&ty,
|
||||
by_player,
|
||||
held.as_ref(),
|
||||
&mut self.world.random,
|
||||
),
|
||||
};
|
||||
(drops, Some(table))
|
||||
}
|
||||
_ => {
|
||||
@@ -511,12 +549,23 @@ impl Game<'_> {
|
||||
return Err(err("commands.drop.no_loot_table.block", &[&name]));
|
||||
}
|
||||
let tool = self.tool_stack(ctx)?;
|
||||
let drops = self.res.items.block_drops(
|
||||
self.res.assets.registry,
|
||||
state,
|
||||
tool.as_ref(),
|
||||
&mut self.world.random,
|
||||
);
|
||||
let drops = match self.res.items.loot_random_sequence(&table) {
|
||||
Some(seq) => {
|
||||
let random = self.rand_sequences.get(&seq, self.level.seed);
|
||||
self.res.items.block_drops(
|
||||
self.res.assets.registry,
|
||||
state,
|
||||
tool.as_ref(),
|
||||
random,
|
||||
)
|
||||
}
|
||||
None => self.res.items.block_drops(
|
||||
self.res.assets.registry,
|
||||
state,
|
||||
tool.as_ref(),
|
||||
&mut self.world.random,
|
||||
),
|
||||
};
|
||||
(drops, Some(table))
|
||||
}
|
||||
};
|
||||
|
||||
@@ -526,13 +526,33 @@ impl Items {
|
||||
pub fn has_loot_table(&self, id: &str) -> bool {
|
||||
self.loot.contains_key(id)
|
||||
}
|
||||
/// A loot table's `random_sequence`.
|
||||
pub fn loot_random_sequence(&self, id: &str) -> Option<String> {
|
||||
self.loot
|
||||
.get(id)?
|
||||
.get("random_sequence")?
|
||||
.as_str()
|
||||
.map(str::to_owned)
|
||||
}
|
||||
/// `LootTable.getRandomItems` of an inline table.
|
||||
pub fn inline_loot_table<R: RandomSource>(&self, table: &Value, random: &mut R) -> Vec<ItemStack> {
|
||||
let empty = BTreeMap::new();
|
||||
let ctx = LootContext {
|
||||
items: self,
|
||||
block: "",
|
||||
properties: &empty,
|
||||
held: None,
|
||||
killed_by_player: false,
|
||||
};
|
||||
ctx.evaluate(table, random)
|
||||
}
|
||||
/// Evaluate the block's loot table for a player break without explosions.
|
||||
pub fn block_drops(
|
||||
pub fn block_drops<R: RandomSource>(
|
||||
&self,
|
||||
registry: &BlockRegistry,
|
||||
state: BlockStateId,
|
||||
held: Option<&ItemStack>,
|
||||
random: &mut LegacyRandom,
|
||||
random: &mut R,
|
||||
) -> Vec<ItemStack> {
|
||||
let Some(block) = registry.state(state) else {
|
||||
return vec![];
|
||||
@@ -561,12 +581,12 @@ impl Items {
|
||||
}
|
||||
/// Evaluate an entity's loot table (`minecraft:entities/<name>`).
|
||||
/// Evaluate any loot table by id (e.g. `minecraft:gameplay/chicken_lay`).
|
||||
pub fn loot_table(
|
||||
pub fn loot_table<R: RandomSource>(
|
||||
&self,
|
||||
id: &str,
|
||||
killed_by_player: bool,
|
||||
held: Option<&ItemStack>,
|
||||
random: &mut LegacyRandom,
|
||||
random: &mut R,
|
||||
) -> Vec<ItemStack> {
|
||||
let Some(table) = self.loot.get(id) else {
|
||||
return vec![];
|
||||
@@ -581,12 +601,12 @@ impl Items {
|
||||
};
|
||||
ctx.evaluate(table, random)
|
||||
}
|
||||
pub fn entity_drops(
|
||||
pub fn entity_drops<R: RandomSource>(
|
||||
&self,
|
||||
entity: &str,
|
||||
killed_by_player: bool,
|
||||
held: Option<&ItemStack>,
|
||||
random: &mut LegacyRandom,
|
||||
random: &mut R,
|
||||
) -> Vec<ItemStack> {
|
||||
let name = entity.trim_start_matches("minecraft:");
|
||||
let Some(table) = self.loot.get(&format!("minecraft:entities/{name}")) else {
|
||||
@@ -604,7 +624,7 @@ impl Items {
|
||||
}
|
||||
}
|
||||
impl LootContext<'_> {
|
||||
fn evaluate(&self, table: &Value, random: &mut LegacyRandom) -> Vec<ItemStack> {
|
||||
fn evaluate<R: RandomSource>(&self, table: &Value, random: &mut R) -> Vec<ItemStack> {
|
||||
let ctx = self;
|
||||
let mut out = Vec::new();
|
||||
for pool in table["pools"].as_array().into_iter().flatten() {
|
||||
@@ -643,7 +663,7 @@ impl LootContext<'_> {
|
||||
fn enchantment_level(&self, id: &str) -> u32 {
|
||||
self.held.map_or(0, |h| h.enchantment_level(id))
|
||||
}
|
||||
fn number(&self, v: &Value, random: &mut LegacyRandom) -> f32 {
|
||||
fn number<R: RandomSource>(&self, v: &Value, random: &mut R) -> f32 {
|
||||
match v {
|
||||
Value::Number(n) => n.as_f64().unwrap_or(0.0) as f32,
|
||||
Value::Object(o) => match o
|
||||
@@ -674,7 +694,7 @@ impl LootContext<'_> {
|
||||
_ => 1.0,
|
||||
}
|
||||
}
|
||||
fn int_number(&self, v: &Value, random: &mut LegacyRandom) -> i32 {
|
||||
fn int_number<R: RandomSource>(&self, v: &Value, random: &mut R) -> i32 {
|
||||
if let Value::Object(o) = v
|
||||
&& o.get("type")
|
||||
.and_then(Value::as_str)
|
||||
@@ -691,7 +711,7 @@ impl LootContext<'_> {
|
||||
}
|
||||
self.number(v, random).round() as i32
|
||||
}
|
||||
fn condition(&self, c: &Value, random: &mut LegacyRandom) -> bool {
|
||||
fn condition<R: RandomSource>(&self, c: &Value, random: &mut R) -> bool {
|
||||
let (kind, c) = match c {
|
||||
Value::String(s) => (s.as_str(), &Value::Null),
|
||||
Value::Object(o) => (o.get("type").and_then(Value::as_str).unwrap_or(""), c),
|
||||
@@ -800,7 +820,7 @@ impl LootContext<'_> {
|
||||
_ => true,
|
||||
}
|
||||
}
|
||||
fn conditions(&self, o: &Value, random: &mut LegacyRandom) -> bool {
|
||||
fn conditions<R: RandomSource>(&self, o: &Value, random: &mut R) -> bool {
|
||||
if let Some(c) = o.get("condition")
|
||||
&& !self.condition(c, random)
|
||||
{
|
||||
@@ -813,10 +833,10 @@ impl LootContext<'_> {
|
||||
.all(|c| self.condition(c, random))
|
||||
}
|
||||
/// Expand entries; returns whether an entry succeeded (for alternatives).
|
||||
fn expand(
|
||||
fn expand<R: RandomSource>(
|
||||
&self,
|
||||
e: &Value,
|
||||
random: &mut LegacyRandom,
|
||||
random: &mut R,
|
||||
out: &mut Vec<(i32, ItemStack, Value)>,
|
||||
) -> bool {
|
||||
if !self.conditions(e, random) {
|
||||
@@ -874,7 +894,7 @@ impl LootContext<'_> {
|
||||
_ => false,
|
||||
}
|
||||
}
|
||||
fn choose(&self, entries: &[Value], random: &mut LegacyRandom, produced: &mut Vec<ItemStack>) {
|
||||
fn choose<R: RandomSource>(&self, entries: &[Value], random: &mut R, produced: &mut Vec<ItemStack>) {
|
||||
let mut candidates = Vec::new();
|
||||
for e in entries {
|
||||
self.expand(e, random, &mut candidates);
|
||||
@@ -901,7 +921,7 @@ impl LootContext<'_> {
|
||||
self.modifiers(&modifiers, &mut stack, random);
|
||||
produced.push(stack);
|
||||
}
|
||||
fn modifiers(&self, m: &Value, stack: &mut ItemStack, random: &mut LegacyRandom) {
|
||||
fn modifiers<R: RandomSource>(&self, m: &Value, stack: &mut ItemStack, random: &mut R) {
|
||||
let list: Vec<&Value> = match m {
|
||||
Value::Array(a) => a.iter().collect(),
|
||||
Value::Object(_) => vec![m],
|
||||
|
||||
@@ -376,8 +376,8 @@ pub fn java_hash_order(
|
||||
// Keys sharing a bucket iterate in insertion order: the order vanilla's
|
||||
// savers write them, as far as it is known here.
|
||||
const WRITE_ORDER: &[&str] = &[
|
||||
// ItemStack.CODEC, block entities.
|
||||
"id", "count", "components", "x", "y", "z",
|
||||
// ItemStack.CODEC.
|
||||
"id", "count", "components",
|
||||
// Entity.saveWithoutId.
|
||||
"Pos", "Motion", "Rotation", "fall_distance", "Fire", "Air", "OnGround",
|
||||
"Invulnerable", "PortalCooldown", "UUID", "CustomName", "CustomNameVisible",
|
||||
@@ -392,11 +392,19 @@ pub fn java_hash_order(
|
||||
"Invisible", "Small", "ShowArms", "DisabledSlots", "NoBasePlate", "Marker",
|
||||
"Pose",
|
||||
];
|
||||
// BlockEntity.saveMetadata writes the position after the entity's data.
|
||||
const AFTER: &[&str] = &["x", "y", "z"];
|
||||
let rank = |k: &horizon_world::nbt::JavaString| {
|
||||
let k = string_of(k);
|
||||
WRITE_ORDER
|
||||
.iter()
|
||||
.position(|w| *w == k)
|
||||
.or_else(|| {
|
||||
AFTER
|
||||
.iter()
|
||||
.position(|w| *w == k)
|
||||
.map(|i| WRITE_ORDER.len() + 1 + i)
|
||||
})
|
||||
.unwrap_or(WRITE_ORDER.len())
|
||||
};
|
||||
let mut entries: Vec<_> = c.iter().collect();
|
||||
|
||||
@@ -244,6 +244,12 @@ public final class VanillaCommandExecOracle {
|
||||
}
|
||||
drain();
|
||||
super.tickServer(() -> false);
|
||||
// The player's network listener ticks it each server tick
|
||||
// (ServerGamePacketListenerImpl.tickPlayer); this one has no
|
||||
// listening connection, so tick the player here.
|
||||
if (player != null) {
|
||||
player.doTick();
|
||||
}
|
||||
drain();
|
||||
}
|
||||
|
||||
|
||||
Reference in New Issue
Block a user