Explorer, treasure and abandoned camp maps work (#147)
Vanilla 26.3 has a MapItem per explorer map (buried_treasure_map, abandoned_camp_map, woodland_mansion_map...) and treats any stack with a map_id as a map. Its ExplorationMapFunction finds the nearest structure of the tag, makes an unlimited tracking map centred on it, draws the biome preview (MapItem.renderBiomePreviewMap) and adds the target decoration (MAP_DECORATIONS, drawn by tickCarriedBy). Horizon only recognised filled_map, turned trade maps into filled_map, cleared every decoration but the player's each tick, and chest loot only flagged the map as found: the treasure maps of shipwrecks and underwater ruins and the maps of 26.3's abandoned camps had no map id, no target and no picture. - map_id: any stack with the component. - tick_maps: the item's map_decorations (red X, mansion, camp...) are drawn as addDecoration places them (off the map only when unlimited). - render_biome_preview: vanilla's water outline picture from the noise biomes at sea level (new generator query noise_biomes, fuzzed through BiomeManager's zoom) and #water_on_map_outlines. - Chest loot (rolled with the chunk here) keeps the function's search in minecraft:custom_data; opening the chest runs it from the chest (vanilla runs it when the chest is unpacked on first open), else reaching the inventory runs it from the player. Nothing found drops the item, as the tables' filtered map_id check does. - Trades keep their map item. Fixes #147 Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
@@ -21,6 +21,7 @@ fn stack(spec: &str) -> LootStack {
|
||||
enchantments: Vec::new(),
|
||||
potion: None,
|
||||
map: false,
|
||||
exploration: None,
|
||||
ominous_amplifier: None,
|
||||
};
|
||||
for e in parts {
|
||||
|
||||
@@ -1895,6 +1895,12 @@ impl Game<'_> {
|
||||
// ShulkerBoxBlock.canOpen: the lid has no room; nothing opens.
|
||||
} else if let Some(entity) = BlockEntity::for_block(&name) {
|
||||
self.world.block_entities.entry(key).or_insert(entity);
|
||||
let centre = [
|
||||
f64::from(key.0) + 0.5,
|
||||
f64::from(key.1) + 0.5,
|
||||
f64::from(key.2) + 0.5,
|
||||
];
|
||||
self.resolve_container_maps(key, centre);
|
||||
self.container = Some(key);
|
||||
self.container_opener_event(key, true);
|
||||
self.post_block_game_event(
|
||||
|
||||
@@ -2861,6 +2861,7 @@ fn to_loot(stack: &ItemStack) -> horizon_world::loot::LootStack {
|
||||
.collect(),
|
||||
potion: None,
|
||||
map: false,
|
||||
exploration: None,
|
||||
ominous_amplifier: None,
|
||||
}
|
||||
}
|
||||
|
||||
@@ -138,12 +138,116 @@ fn packed_rgba(packed: u8) -> [u8; 4] {
|
||||
let ch = |s: u32| ((col >> s & 255) * modifier / 255) as u8;
|
||||
[ch(16), ch(8), ch(0), 255]
|
||||
}
|
||||
/// `has(DataComponents.MAP_ID)`: filled maps and the explorer map items
|
||||
/// (`buried_treasure_map`, `woodland_mansion_map`, ..., all `MapItem`s).
|
||||
pub(super) fn map_id(stack: &ItemStack) -> Option<i32> {
|
||||
if &*stack.item != "minecraft:filled_map" {
|
||||
return None;
|
||||
}
|
||||
stack.data().and_then(|d| d.map_id)
|
||||
}
|
||||
/// `MapDecorationTypes`: the sprite of a decoration type that a
|
||||
/// `minecraft:map_decorations` entry can name.
|
||||
fn decoration_sprite(id: &str) -> Option<&'static str> {
|
||||
Some(match id.strip_prefix("minecraft:").unwrap_or(id) {
|
||||
"player" => "map/decorations/player",
|
||||
"frame" => "map/decorations/frame",
|
||||
"red_marker" => "map/decorations/red_marker",
|
||||
"blue_marker" => "map/decorations/blue_marker",
|
||||
"target_x" => "map/decorations/target_x",
|
||||
"target_point" => "map/decorations/target_point",
|
||||
"player_off_map" => "map/decorations/player_off_map",
|
||||
"player_off_limits" => "map/decorations/player_off_limits",
|
||||
"mansion" => "map/decorations/woodland_mansion",
|
||||
"monument" => "map/decorations/ocean_monument",
|
||||
"red_x" => "map/decorations/red_x",
|
||||
"village_desert" => "map/decorations/desert_village",
|
||||
"village_plains" => "map/decorations/plains_village",
|
||||
"village_savanna" => "map/decorations/savanna_village",
|
||||
"village_snowy" => "map/decorations/snowy_village",
|
||||
"village_taiga" => "map/decorations/taiga_village",
|
||||
"jungle_temple" => "map/decorations/jungle_temple",
|
||||
"swamp_hut" => "map/decorations/swamp_hut",
|
||||
"trial_chambers" => "map/decorations/trial_chambers",
|
||||
"abandoned_camp" => "map/decorations/abandoned_camp",
|
||||
"ancient_city" => "map/decorations/ancient_city",
|
||||
"desert_pyramid" => "map/decorations/desert_pyramid",
|
||||
"mineshaft" => "map/decorations/mineshaft",
|
||||
"ocean_ruin_warm" => "map/decorations/warm_ocean_ruins",
|
||||
_ => return None,
|
||||
})
|
||||
}
|
||||
/// `minecraft:map_decorations` of a map item: (sprite, x, z, rotation), in
|
||||
/// the component's order.
|
||||
fn static_decorations(stack: &ItemStack) -> Vec<(&'static str, f64, f64, f32)> {
|
||||
let Some(Tag::Compound(entries)) = stack.data().and_then(|d| {
|
||||
d.other
|
||||
.iter()
|
||||
.find(|(k, _)| k == "minecraft:map_decorations")
|
||||
.map(|(_, t)| t)
|
||||
}) else {
|
||||
return Vec::new();
|
||||
};
|
||||
let number = |t: Option<&Tag>| match t {
|
||||
Some(Tag::Double(b)) => Some(f64::from_bits(*b)),
|
||||
Some(Tag::Float(b)) => Some(f64::from(f32::from_bits(*b))),
|
||||
Some(Tag::Int(v)) => Some(f64::from(*v)),
|
||||
_ => None,
|
||||
};
|
||||
entries
|
||||
.values()
|
||||
.filter_map(|e| {
|
||||
let sprite = match e.get("type") {
|
||||
Some(Tag::String(s)) => decoration_sprite(&s.to_string_lossy())?,
|
||||
_ => return None,
|
||||
};
|
||||
Some((
|
||||
sprite,
|
||||
number(e.get("x"))?,
|
||||
number(e.get("z"))?,
|
||||
number(e.get("rotation")).unwrap_or(0.0) as f32,
|
||||
))
|
||||
})
|
||||
.collect()
|
||||
}
|
||||
/// `MapItemSavedData.addTargetDecoration`: the `"+"` entry of
|
||||
/// `minecraft:map_decorations`, rotation 180.
|
||||
fn target_decoration(decoration: &str, at: [i32; 3]) -> Tag {
|
||||
Tag::compound([(
|
||||
"+",
|
||||
Tag::compound([
|
||||
("type", Tag::String(decoration.into())),
|
||||
("x", Tag::Double(f64::from(at[0]).to_bits())),
|
||||
("z", Tag::Double(f64::from(at[2]).to_bits())),
|
||||
("rotation", Tag::Float(180.0f32.to_bits())),
|
||||
]),
|
||||
)])
|
||||
}
|
||||
/// `MapItemSavedData.clampMapCoordinate`.
|
||||
fn clamp_map_coordinate(d: f32) -> i8 {
|
||||
if d <= -63.0 {
|
||||
-128
|
||||
} else if d >= 63.0 {
|
||||
127
|
||||
} else {
|
||||
(d * 2.0 + 0.5) as i8
|
||||
}
|
||||
}
|
||||
/// `MapItemSavedData.calculateRotation`: spinning in the Nether.
|
||||
fn decoration_rotation(nether: bool, game_time: i64, y_rot: f64) -> u8 {
|
||||
if nether {
|
||||
let s = (game_time / 10) as i32;
|
||||
(s.wrapping_mul(s)
|
||||
.wrapping_mul(34_187_121)
|
||||
.wrapping_add(s.wrapping_mul(121))
|
||||
>> 15
|
||||
& 15) as u8
|
||||
} else {
|
||||
let adjusted = if y_rot < 0.0 {
|
||||
y_rot - 8.0
|
||||
} else {
|
||||
y_rot + 8.0
|
||||
};
|
||||
((adjusted * 16.0 / 360.0) as i32 & 15) as u8
|
||||
}
|
||||
}
|
||||
impl Game<'_> {
|
||||
fn dimension_id(&self) -> &'static str {
|
||||
match self.dim {
|
||||
@@ -199,6 +303,161 @@ impl Game<'_> {
|
||||
self.maps.data.insert(id, data);
|
||||
let last = self.maps.last_id.unwrap_or(-1).max(id);
|
||||
self.maps.last_id = Some(last);
|
||||
self.render_biome_preview(id);
|
||||
}
|
||||
}
|
||||
/// `ExplorationMapFunction.run` for an item a generated chest still holds
|
||||
/// unsearched (`structure_blocks::take_pending_map`): the nearest
|
||||
/// structure of the tag around `origin`, a new map centred on it with its
|
||||
/// biome preview and target decoration. False when nothing is found: the
|
||||
/// loot table's `filtered` map_id check would have discarded the item.
|
||||
pub(super) fn resolve_pending_map(&mut self, item: &mut ItemStack, origin: [f64; 3]) -> bool {
|
||||
let Some(map) = horizon_client::structure_blocks::take_pending_map(item) else {
|
||||
return true;
|
||||
};
|
||||
let names = self.structure_tag(&map.destination);
|
||||
let from = origin.map(|v| v.floor() as i32);
|
||||
let found = self
|
||||
.end
|
||||
.locator()
|
||||
.filter(|_| !names.is_empty())
|
||||
.and_then(|t| t.locate(&names, from, map.search_radius));
|
||||
let Some((_, at)) = found else {
|
||||
return false;
|
||||
};
|
||||
let mut data = MapData::fresh(
|
||||
f64::from(at[0]),
|
||||
f64::from(at[2]),
|
||||
map.zoom,
|
||||
self.dimension_id(),
|
||||
);
|
||||
data.unlimited = true;
|
||||
let id = self.new_map_id(data);
|
||||
self.render_biome_preview(id);
|
||||
let d = item.data_mut();
|
||||
d.map_id = Some(id);
|
||||
d.other.retain(|(k, _)| k != "minecraft:map_decorations");
|
||||
d.other.push((
|
||||
"minecraft:map_decorations".into(),
|
||||
target_decoration(&map.decoration, at),
|
||||
));
|
||||
true
|
||||
}
|
||||
/// The unsearched exploration maps of a container being opened
|
||||
/// (`RandomizableContainer.unpackLootTable` runs the function then).
|
||||
pub(super) fn resolve_container_maps(&mut self, key: (i32, i32, i32), origin: [f64; 3]) {
|
||||
use horizon_client::containers::BlockEntity;
|
||||
let Some(BlockEntity::Chest(slots)) = self.world.block_entities.get(&key) else {
|
||||
return;
|
||||
};
|
||||
let pending: Vec<usize> = slots
|
||||
.iter()
|
||||
.enumerate()
|
||||
.filter(|(_, s)| {
|
||||
s.as_ref()
|
||||
.is_some_and(horizon_client::structure_blocks::has_pending_map)
|
||||
})
|
||||
.map(|(i, _)| i)
|
||||
.collect();
|
||||
for i in pending {
|
||||
let Some(BlockEntity::Chest(slots)) = self.world.block_entities.get_mut(&key) else {
|
||||
return;
|
||||
};
|
||||
let Some(mut item) = slots[i].take() else {
|
||||
continue;
|
||||
};
|
||||
let keep = self.resolve_pending_map(&mut item, origin);
|
||||
if let Some(BlockEntity::Chest(slots)) = self.world.block_entities.get_mut(&key) {
|
||||
slots[i] = keep.then_some(item);
|
||||
}
|
||||
}
|
||||
}
|
||||
/// `MapItem.renderBiomePreviewMap`: the map's biomes at sea level, water
|
||||
/// outlines (`#water_on_map_outlines`) drawn in orange and brown.
|
||||
pub(super) fn render_biome_preview(&mut self, id: i32) {
|
||||
let Some(terrain) = self.end.locator() else {
|
||||
return;
|
||||
};
|
||||
let dim = self.dimension_id();
|
||||
let zoom = self.streaming.biome_zoom;
|
||||
let watery_biomes: std::collections::HashSet<String> = self
|
||||
.tag_entries("worldgen/biome", "minecraft:water_on_map_outlines")
|
||||
.into_iter()
|
||||
.collect();
|
||||
let Some(m) = self.maps.data.get(&id) else {
|
||||
return;
|
||||
};
|
||||
if m.dimension != dim {
|
||||
return;
|
||||
}
|
||||
let scale = 1i32 << m.scale;
|
||||
let start_x = m.center[0] / scale - 64;
|
||||
let start_z = m.center[1] / scale - 64;
|
||||
let sea_level = 63;
|
||||
let quarts: Vec<[i32; 3]> = (0..128)
|
||||
.flat_map(|row| {
|
||||
(0..128).map(move |column| {
|
||||
zoom.quart_at_block(horizon_core::position::BlockPos::new(
|
||||
(start_x + column) * scale,
|
||||
sea_level,
|
||||
(start_z + row) * scale,
|
||||
))
|
||||
})
|
||||
})
|
||||
.collect();
|
||||
let watery: Vec<bool> = terrain
|
||||
.noise_biomes(&quarts)
|
||||
.into_iter()
|
||||
.map(|b| b.is_some_and(|b| watery_biomes.contains(&b)))
|
||||
.collect();
|
||||
let is_watery = |x: i32, z: i32| watery[(z * 128 + x) as usize];
|
||||
// MapColor ids and MapColor.Brightness ids.
|
||||
const ORANGE: u8 = 15;
|
||||
const BROWN: u8 = 26;
|
||||
const LOW: u8 = 0;
|
||||
const NORMAL: u8 = 1;
|
||||
const HIGH: u8 = 2;
|
||||
const LOWEST: u8 = 3;
|
||||
let Some(m) = self.maps.data.get_mut(&id) else {
|
||||
return;
|
||||
};
|
||||
for mx in 1..127 {
|
||||
for mz in 1..127 {
|
||||
let mut water_count = 0;
|
||||
for dx in -1..2 {
|
||||
for dz in -1..2 {
|
||||
if (dx != 0 || dz != 0) && is_watery(mx + dx, mz + dz) {
|
||||
water_count += 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
let mut brightness = LOWEST;
|
||||
let mut color = 0;
|
||||
if is_watery(mx, mz) {
|
||||
color = ORANGE;
|
||||
if water_count > 7 && mz % 2 == 0 {
|
||||
let sin = horizon_core::geometry::trig::sin(f64::from(mz as f32 + 0.0));
|
||||
match (mx + (sin * 7.0) as i32) / 8 % 5 {
|
||||
0 | 4 => brightness = LOW,
|
||||
1 | 3 => brightness = NORMAL,
|
||||
2 => brightness = HIGH,
|
||||
_ => {}
|
||||
}
|
||||
} else if water_count > 7 {
|
||||
color = 0;
|
||||
} else if water_count > 5 {
|
||||
brightness = NORMAL;
|
||||
} else if water_count > 1 {
|
||||
brightness = LOW;
|
||||
}
|
||||
} else if water_count > 0 {
|
||||
color = BROWN;
|
||||
brightness = if water_count > 3 { NORMAL } else { LOWEST };
|
||||
}
|
||||
if color != 0 {
|
||||
m.update_color(mx, mz, color << 2 | brightness);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
/// Registers `data` under a free map id.
|
||||
@@ -250,20 +509,33 @@ impl Game<'_> {
|
||||
let Some(p) = self.player.as_ref().map(|p| p.position) else {
|
||||
return;
|
||||
};
|
||||
// A generated exploration map that reached the inventory unsearched
|
||||
// (moved out of its chest by a hopper): searched from here.
|
||||
for i in 0..self.inventory.len() {
|
||||
if self.inventory[i]
|
||||
.as_ref()
|
||||
.is_some_and(horizon_client::structure_blocks::has_pending_map)
|
||||
&& let Some(mut item) = self.inventory[i].take()
|
||||
{
|
||||
let keep = self.resolve_pending_map(&mut item, [p.x, p.y, p.z]);
|
||||
self.inventory[i] = keep.then_some(item);
|
||||
}
|
||||
}
|
||||
let held: Vec<i32> = [Some(self.selected), Some(super::shield::OFFHAND_SLOT)]
|
||||
.into_iter()
|
||||
.flatten()
|
||||
.filter_map(|i| self.stack_in(i).and_then(map_id))
|
||||
.collect();
|
||||
let carried: Vec<i32> = self
|
||||
let carried: Vec<(i32, Vec<(&'static str, f64, f64, f32)>)> = self
|
||||
.inventory
|
||||
.iter()
|
||||
.chain(std::iter::once(&self.offhand))
|
||||
.flatten()
|
||||
.filter_map(map_id)
|
||||
.filter_map(|s| Some((map_id(s)?, static_decorations(s))))
|
||||
.collect();
|
||||
let (yaw, dim) = (self.yaw, self.dimension_id());
|
||||
for id in carried {
|
||||
let (nether, game_time) = (self.dim == super::Dim::Nether, self.world.game_time);
|
||||
for (id, targets) in carried {
|
||||
let Some(m) = self.map(id) else { continue };
|
||||
// tickCarriedBy: the player marker while tracking in this dimension.
|
||||
m.decorations.clear();
|
||||
@@ -302,6 +574,26 @@ impl Game<'_> {
|
||||
});
|
||||
}
|
||||
}
|
||||
// The item's MAP_DECORATIONS (an explorer map's target), added
|
||||
// after the players as addDecoration would.
|
||||
let s = (1 << m.scale) as f32;
|
||||
for (sprite, x, z, rotation) in targets {
|
||||
let dx = (x - f64::from(m.center[0])) as f32 / s;
|
||||
let dz = (z - f64::from(m.center[1])) as f32 / s;
|
||||
let inside = (-63.0..=63.0).contains(&dx) && (-63.0..=63.0).contains(&dz);
|
||||
if !inside && !m.unlimited {
|
||||
continue;
|
||||
}
|
||||
let d = Decoration {
|
||||
sprite,
|
||||
x: clamp_map_coordinate(dx),
|
||||
y: clamp_map_coordinate(dz),
|
||||
rot: decoration_rotation(nether, game_time, f64::from(rotation)),
|
||||
};
|
||||
if !m.decorations.contains(&d) {
|
||||
m.decorations.push(d);
|
||||
}
|
||||
}
|
||||
}
|
||||
for id in held {
|
||||
self.update_map(id);
|
||||
@@ -663,3 +955,56 @@ impl Game<'_> {
|
||||
true
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn every_target_decoration_type_has_its_sprite() {
|
||||
// MapDecorationTypes: (name, asset).
|
||||
for (name, asset) in [
|
||||
("mansion", "woodland_mansion"),
|
||||
("monument", "ocean_monument"),
|
||||
("red_x", "red_x"),
|
||||
("village_desert", "desert_village"),
|
||||
("village_plains", "plains_village"),
|
||||
("village_savanna", "savanna_village"),
|
||||
("village_snowy", "snowy_village"),
|
||||
("village_taiga", "taiga_village"),
|
||||
("jungle_temple", "jungle_temple"),
|
||||
("swamp_hut", "swamp_hut"),
|
||||
("trial_chambers", "trial_chambers"),
|
||||
("abandoned_camp", "abandoned_camp"),
|
||||
("ancient_city", "ancient_city"),
|
||||
("desert_pyramid", "desert_pyramid"),
|
||||
("mineshaft", "mineshaft"),
|
||||
("ocean_ruin_warm", "warm_ocean_ruins"),
|
||||
] {
|
||||
assert_eq!(
|
||||
decoration_sprite(&format!("minecraft:{name}")),
|
||||
Some(format!("map/decorations/{asset}").as_str()),
|
||||
"{name}"
|
||||
);
|
||||
}
|
||||
assert_eq!(decoration_sprite("minecraft:nothing"), None);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn target_decorations_read_back_with_vanilla_rotation() {
|
||||
let mut stack = ItemStack::new("minecraft:buried_treasure_map", 1);
|
||||
stack.data_mut().map_id = Some(3);
|
||||
stack.data_mut().other.push((
|
||||
"minecraft:map_decorations".into(),
|
||||
target_decoration("minecraft:red_x", [120, 40, -300]),
|
||||
));
|
||||
assert_eq!(map_id(&stack), Some(3));
|
||||
let found = static_decorations(&stack);
|
||||
assert_eq!(found, vec![("map/decorations/red_x", 120.0, -300.0, 180.0)]);
|
||||
// calculateRotation(180): (byte) (188 * 16 / 360) = 8.
|
||||
assert_eq!(decoration_rotation(false, 0, 180.0), 8);
|
||||
assert_eq!(decoration_rotation(false, 0, -90.0), 12);
|
||||
assert_eq!(clamp_map_coordinate(-70.0), -128);
|
||||
assert_eq!(clamp_map_coordinate(10.25), 21);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -89,8 +89,8 @@ impl merchant::MapMaker for GameMaps<'_> {
|
||||
self.made
|
||||
.borrow_mut()
|
||||
.push((id, at, map.zoom, map.decoration.clone()));
|
||||
// The trade's own map item (woodland_mansion_map, ...) keeps its id.
|
||||
let mut out = stack;
|
||||
out.item = std::sync::Arc::from("minecraft:filled_map");
|
||||
let d = out.data_mut();
|
||||
d.map_id = Some(id);
|
||||
d.other.push((
|
||||
|
||||
@@ -643,13 +643,7 @@ pub trait MapMaker {
|
||||
) -> ItemStack;
|
||||
}
|
||||
/// An `exploration_map` function's settings.
|
||||
pub struct ExplorationMap {
|
||||
pub destination: String,
|
||||
pub decoration: String,
|
||||
pub zoom: u8,
|
||||
pub search_radius: i32,
|
||||
pub skip_existing_chunks: bool,
|
||||
}
|
||||
pub use horizon_world::loot::ExplorationMap;
|
||||
fn int_provider<R: RandomSource>(v: &Value, random: &mut R) -> i32 {
|
||||
match v {
|
||||
Value::Number(n) => n.as_i64().unwrap_or(0) as i32,
|
||||
@@ -953,20 +947,7 @@ impl Trades {
|
||||
let Some(maps) = ctx.maps else {
|
||||
return Some((stack, 0));
|
||||
};
|
||||
let map = ExplorationMap {
|
||||
destination: m["destination"]
|
||||
.as_str()
|
||||
.unwrap_or("#minecraft:on_treasure_maps")
|
||||
.trim_start_matches('#')
|
||||
.to_owned(),
|
||||
decoration: m["decoration"]
|
||||
.as_str()
|
||||
.unwrap_or("minecraft:mansion")
|
||||
.to_owned(),
|
||||
zoom: m["zoom"].as_u64().unwrap_or(2) as u8,
|
||||
search_radius: m["search_radius"].as_i64().unwrap_or(50) as i32,
|
||||
skip_existing_chunks: m["skip_existing_chunks"].as_bool().unwrap_or(true),
|
||||
};
|
||||
let map = ExplorationMap::from_json(m);
|
||||
Some((maps.exploration_map(stack, &map, ctx.origin), 0))
|
||||
}
|
||||
_ => Some((stack, 0)),
|
||||
|
||||
@@ -301,6 +301,7 @@ fn loot_stack(item: &str, count: i32) -> LootStack {
|
||||
enchantments: Vec::new(),
|
||||
potion: None,
|
||||
map: false,
|
||||
exploration: None,
|
||||
ominous_amplifier: None,
|
||||
}
|
||||
}
|
||||
|
||||
@@ -12,6 +12,81 @@ use std::{
|
||||
sync::{Arc, OnceLock},
|
||||
};
|
||||
|
||||
/// The `custom_data` key holding an exploration map's search until the game
|
||||
/// runs it (vanilla runs `ExplorationMapFunction` when the chest is unpacked,
|
||||
/// on first open; here loot is rolled with the chunk).
|
||||
const PENDING_MAP: &str = "horizon:exploration_map";
|
||||
const CUSTOM_DATA: &str = "minecraft:custom_data";
|
||||
|
||||
/// A generated chest's item, with its exploration map search kept in
|
||||
/// `minecraft:custom_data` (which vanilla loads as is).
|
||||
fn loot_item(s: &horizon_world::loot::LootStack) -> ItemStack {
|
||||
let mut item = ItemStack {
|
||||
item: Arc::from(s.item.as_str()),
|
||||
count: s.count.max(0) as u32,
|
||||
damage: s.damage.max(0) as u32,
|
||||
extra: None,
|
||||
};
|
||||
if let Some(map) = &s.exploration {
|
||||
let search = Tag::compound([
|
||||
("destination", Tag::String(map.destination.as_str().into())),
|
||||
("decoration", Tag::String(map.decoration.as_str().into())),
|
||||
("zoom", Tag::Byte(map.zoom as i8)),
|
||||
("search_radius", Tag::Int(map.search_radius)),
|
||||
(
|
||||
"skip_existing_chunks",
|
||||
Tag::Byte(i8::from(map.skip_existing_chunks)),
|
||||
),
|
||||
]);
|
||||
item.data_mut()
|
||||
.other
|
||||
.push((CUSTOM_DATA.into(), Tag::compound([(PENDING_MAP, search)])));
|
||||
}
|
||||
item
|
||||
}
|
||||
|
||||
/// The exploration map search an item still waits for, removed from it.
|
||||
pub fn take_pending_map(item: &mut ItemStack) -> Option<horizon_world::loot::ExplorationMap> {
|
||||
let data = item.extra.as_deref_mut()?;
|
||||
let i = data
|
||||
.other
|
||||
.iter()
|
||||
.position(|(k, t)| k == CUSTOM_DATA && t.get(PENDING_MAP).is_some())?;
|
||||
let (_, mut custom) = data.other.remove(i);
|
||||
let search = match &mut custom {
|
||||
Tag::Compound(c) => c.remove(&JavaString::from(PENDING_MAP))?,
|
||||
_ => return None,
|
||||
};
|
||||
if matches!(&custom, Tag::Compound(c) if !c.is_empty()) {
|
||||
data.other.insert(i, (CUSTOM_DATA.into(), custom));
|
||||
}
|
||||
let text = |k: &str| match search.get(k) {
|
||||
Some(Tag::String(s)) => Some(s.to_string_lossy()),
|
||||
_ => None,
|
||||
};
|
||||
let int = |k: &str| match search.get(k) {
|
||||
Some(Tag::Int(v)) => Some(*v),
|
||||
Some(Tag::Byte(v)) => Some(i32::from(*v)),
|
||||
_ => None,
|
||||
};
|
||||
Some(horizon_world::loot::ExplorationMap {
|
||||
destination: text("destination")?,
|
||||
decoration: text("decoration")?,
|
||||
zoom: int("zoom").unwrap_or(2).clamp(0, 4) as u8,
|
||||
search_radius: int("search_radius").unwrap_or(50),
|
||||
skip_existing_chunks: int("skip_existing_chunks").unwrap_or(1) != 0,
|
||||
})
|
||||
}
|
||||
|
||||
/// Whether an item still waits for its exploration map search.
|
||||
pub fn has_pending_map(item: &ItemStack) -> bool {
|
||||
item.data().is_some_and(|d| {
|
||||
d.other
|
||||
.iter()
|
||||
.any(|(k, t)| k == CUSTOM_DATA && t.get(PENDING_MAP).is_some())
|
||||
})
|
||||
}
|
||||
|
||||
/// Loot data of the resource root, loaded once per process.
|
||||
pub fn loot_data(root: &Path) -> Option<Arc<LootData>> {
|
||||
static LOOT: OnceLock<Option<Arc<LootData>>> = OnceLock::new();
|
||||
@@ -64,12 +139,7 @@ pub fn block_entities(
|
||||
.zip(loot.fill(&table, seed, 27, Some(biome)))
|
||||
{
|
||||
*slot = stack.map(|s| {
|
||||
let mut item = ItemStack {
|
||||
item: Arc::from(s.item.as_str()),
|
||||
count: s.count.max(0) as u32,
|
||||
damage: s.damage.max(0) as u32,
|
||||
extra: None,
|
||||
};
|
||||
let mut item = loot_item(&s);
|
||||
// An ominous bottle's level (the default, 0, is no component).
|
||||
if let Some(level) = s.ominous_amplifier.filter(|l| *l > 0) {
|
||||
item.data_mut().ominous_amplifier = Some(level.clamp(0, 4) as u8);
|
||||
@@ -114,17 +184,71 @@ pub fn unpack_entity_loot(
|
||||
let slots: Vec<Option<ItemStack>> = loot
|
||||
.fill(&table, seed, 27, Some(biome))
|
||||
.into_iter()
|
||||
.map(|s| {
|
||||
s.map(|s| ItemStack {
|
||||
item: Arc::from(s.item.as_str()),
|
||||
count: s.count.max(0) as u32,
|
||||
damage: s.damage.max(0) as u32,
|
||||
extra: None,
|
||||
})
|
||||
})
|
||||
.map(|s| s.map(|s| loot_item(&s)))
|
||||
.collect();
|
||||
nbt.remove(&JavaString::from("LootTable"));
|
||||
nbt.remove(&JavaString::from("LootTableSeed"));
|
||||
nbt.insert("Items".into(), crate::save::encode_items(&slots));
|
||||
nbt
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use horizon_world::loot::{ExplorationMap, LootStack};
|
||||
|
||||
#[test]
|
||||
fn exploration_maps_wait_in_custom_data_until_searched() {
|
||||
let mut stack = LootStack {
|
||||
item: "minecraft:buried_treasure_map".into(),
|
||||
count: 1,
|
||||
damage: 0,
|
||||
enchantments: Vec::new(),
|
||||
potion: None,
|
||||
map: true,
|
||||
exploration: Some(Box::new(ExplorationMap::from_json(&serde_json::json!({
|
||||
"decoration": "minecraft:red_x",
|
||||
"destination": "#minecraft:on_treasure_maps",
|
||||
"skip_existing_chunks": false,
|
||||
"zoom": 1
|
||||
})))),
|
||||
ominous_amplifier: None,
|
||||
};
|
||||
let mut item = loot_item(&stack);
|
||||
assert!(has_pending_map(&item));
|
||||
// The rest of custom_data stays.
|
||||
if let Some(Tag::Compound(c)) = item
|
||||
.data_mut()
|
||||
.other
|
||||
.iter_mut()
|
||||
.find(|(k, _)| k == CUSTOM_DATA)
|
||||
.map(|(_, t)| t)
|
||||
{
|
||||
c.insert("note".into(), Tag::Int(7));
|
||||
}
|
||||
let map = take_pending_map(&mut item).unwrap();
|
||||
assert_eq!(
|
||||
map,
|
||||
ExplorationMap {
|
||||
destination: "minecraft:on_treasure_maps".into(),
|
||||
decoration: "minecraft:red_x".into(),
|
||||
zoom: 1,
|
||||
search_radius: 50,
|
||||
skip_existing_chunks: false,
|
||||
}
|
||||
);
|
||||
assert!(!has_pending_map(&item));
|
||||
assert!(take_pending_map(&mut item).is_none());
|
||||
let custom = &item.data().unwrap().other;
|
||||
assert_eq!(custom.len(), 1);
|
||||
assert_eq!(custom[0].1.get("note"), Some(&Tag::Int(7)));
|
||||
// Only the search: the component goes away with it.
|
||||
stack.item = "minecraft:abandoned_camp_map".into();
|
||||
let mut item = loot_item(&stack);
|
||||
take_pending_map(&mut item).unwrap();
|
||||
assert!(item.data().unwrap().other.is_empty());
|
||||
// A plain item has nothing pending.
|
||||
stack.exploration = None;
|
||||
assert!(!has_pending_map(&loot_item(&stack)));
|
||||
}
|
||||
}
|
||||
|
||||
@@ -117,6 +117,13 @@ impl VanillaTerrain {
|
||||
let worker = worker.get_or_insert_with(|| self.generator.worker());
|
||||
worker.find_closest_biome(search)
|
||||
}
|
||||
/// `BiomeSource.getNoiseBiome` at quart positions, for places that may not
|
||||
/// be generated yet (`MapItem.renderBiomePreviewMap`).
|
||||
pub fn noise_biomes(&self, quarts: &[[i32; 3]]) -> Vec<Option<String>> {
|
||||
let mut worker = self.query.lock().unwrap_or_else(|e| e.into_inner());
|
||||
let worker = worker.get_or_insert_with(|| self.generator.worker());
|
||||
worker.noise_biomes(quarts)
|
||||
}
|
||||
/// `/place jigsaw`: `JigsawPlacement.addPieces`.
|
||||
pub fn jigsaw_pieces(
|
||||
&self,
|
||||
|
||||
@@ -26,9 +26,43 @@ pub struct LootStack {
|
||||
pub potion: Option<String>,
|
||||
/// Set by exploration_map (the map_id component of a found map).
|
||||
pub map: bool,
|
||||
/// The search an exploration_map function asked for, left to the game
|
||||
/// (it needs the level's structures and maps).
|
||||
pub exploration: Option<Box<ExplorationMap>>,
|
||||
/// Set by set_ominous_bottle_amplifier.
|
||||
pub ominous_amplifier: Option<i32>,
|
||||
}
|
||||
/// `ExplorationMapFunction`'s settings.
|
||||
#[derive(Clone, Debug, PartialEq, Eq)]
|
||||
pub struct ExplorationMap {
|
||||
/// A structure tag, without `#`.
|
||||
pub destination: String,
|
||||
pub decoration: String,
|
||||
pub zoom: u8,
|
||||
pub search_radius: i32,
|
||||
pub skip_existing_chunks: bool,
|
||||
}
|
||||
impl ExplorationMap {
|
||||
/// The function's fields with their codec defaults (`DEFAULT_DESTINATION`
|
||||
/// on_treasure_maps, `DEFAULT_DECORATION` mansion, zoom 2, radius 50,
|
||||
/// skipping known structures).
|
||||
pub fn from_json(f: &Value) -> Self {
|
||||
Self {
|
||||
destination: f["destination"]
|
||||
.as_str()
|
||||
.unwrap_or("#minecraft:on_treasure_maps")
|
||||
.trim_start_matches('#')
|
||||
.to_owned(),
|
||||
decoration: f["decoration"]
|
||||
.as_str()
|
||||
.unwrap_or("minecraft:mansion")
|
||||
.to_owned(),
|
||||
zoom: f["zoom"].as_u64().unwrap_or(2) as u8,
|
||||
search_radius: f["search_radius"].as_i64().unwrap_or(50) as i32,
|
||||
skip_existing_chunks: f["skip_existing_chunks"].as_bool().unwrap_or(true),
|
||||
}
|
||||
}
|
||||
}
|
||||
impl LootStack {
|
||||
fn new(item: &str) -> Self {
|
||||
Self {
|
||||
@@ -38,6 +72,7 @@ impl LootStack {
|
||||
enchantments: Vec::new(),
|
||||
potion: None,
|
||||
map: false,
|
||||
exploration: None,
|
||||
ominous_amplifier: None,
|
||||
}
|
||||
}
|
||||
@@ -1045,8 +1080,15 @@ impl<R: RandomSource> Context<'_, R> {
|
||||
}
|
||||
}
|
||||
// ExplorationMapFunction needs an origin; with one, the map is
|
||||
// taken as found (the structure search itself is not run).
|
||||
"minecraft:exploration_map" => stack.map = self.biome.is_some(),
|
||||
// taken as found here and the game runs the structure search
|
||||
// (it drops the map when nothing is found, as the filtered
|
||||
// map_id check after it would).
|
||||
"minecraft:exploration_map" => {
|
||||
stack.map = self.biome.is_some();
|
||||
if stack.map {
|
||||
stack.exploration = Some(Box::new(ExplorationMap::from_json(f)));
|
||||
}
|
||||
}
|
||||
"minecraft:filtered" => {
|
||||
let pass = self.item_matches(&f["item_filter"], &stack);
|
||||
let branch = if pass { &f["on_pass"] } else { &f["on_fail"] };
|
||||
|
||||
@@ -1403,6 +1403,8 @@ trait SeededPipeline: Send + Sync {
|
||||
worker: &mut WorkerState,
|
||||
search: &BiomeSearch<'_>,
|
||||
) -> Option<(String, [i32; 3])>;
|
||||
/// `BiomeSource.getNoiseBiome` at each quart position (unloaded chunks).
|
||||
fn noise_biomes(&self, worker: &mut WorkerState, quarts: &[[i32; 3]]) -> Vec<Option<String>>;
|
||||
fn jigsaw_pieces(
|
||||
&self,
|
||||
worker: &mut WorkerState,
|
||||
@@ -1562,6 +1564,21 @@ where
|
||||
}
|
||||
None
|
||||
}
|
||||
fn noise_biomes(&self, worker: &mut WorkerState, quarts: &[[i32; 3]]) -> Vec<Option<String>> {
|
||||
let mut resolver = self.source.resolver(
|
||||
&self.climate,
|
||||
self.router.get(RouterField::Erosion).as_ref(),
|
||||
);
|
||||
quarts
|
||||
.iter()
|
||||
.map(|&quart| {
|
||||
resolver
|
||||
.sample(&mut worker.carver_context, quart)
|
||||
.ok()
|
||||
.map(str::to_owned)
|
||||
})
|
||||
.collect()
|
||||
}
|
||||
fn jigsaw_pieces(
|
||||
&self,
|
||||
worker: &mut WorkerState,
|
||||
@@ -1841,6 +1858,9 @@ impl GeneratorWorker {
|
||||
}
|
||||
/// `BiomeSource.findClosestBiome3d`: the first sampled position whose
|
||||
/// noise biome passes `allowed`, spiralling out from the origin.
|
||||
pub fn noise_biomes(&mut self, quarts: &[[i32; 3]]) -> Vec<Option<String>> {
|
||||
self.pipeline.noise_biomes(&mut self.state, quarts)
|
||||
}
|
||||
pub fn find_closest_biome(&mut self, search: &BiomeSearch<'_>) -> Option<(String, [i32; 3])> {
|
||||
self.pipeline.find_closest_biome(&mut self.state, search)
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user