Merge pull request #232 from ludovic111/fix/explorer-maps-147

Explorer, treasure and abandoned camp maps work (#147)
This commit is contained in:
Ludovic Marie
2026-10-15 01:13:24 +02:00
committed by GitHub
11 changed files with 572 additions and 44 deletions
@@ -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 {
+6
View File
@@ -1896,6 +1896,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,
}
}
+351 -6
View File
@@ -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);
}
}
+1 -1
View File
@@ -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((
+2 -21
View File
@@ -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)),
+1
View File
@@ -301,6 +301,7 @@ fn loot_stack(item: &str, count: i32) -> LootStack {
enchantments: Vec::new(),
potion: None,
map: false,
exploration: None,
ominous_amplifier: None,
}
}
+138 -14
View File
@@ -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)));
}
}
+7
View File
@@ -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,
+44 -2
View File
@@ -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)
}