Add enchanting, anvil, grindstone, smithing, stonecutter and brewing stand menus
Workstation menus follow the vanilla screens: slot layouts, sprites, the enchanting table's seeded offers with clues and galactic names, anvil rename/repair/combine costs, grindstone disenchanting with experience, smithing upgrades and trims, stonecutter recipe buttons, and the brewing stand block entity with data-driven recipes. Item tooltips show rarity, enchantments, potion effects and trims; enchanted items glint. horizon-ctl gains menu commands (use, click-slot, click-gui, type, xp, ...). Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
@@ -0,0 +1,432 @@
|
||||
//! Potions and the brewing stand: the `Potions` / `MobEffects` registries (code
|
||||
//! in vanilla, ported as tables), data-driven `minecraft:brewing` recipes from
|
||||
//! `data/minecraft/recipe/brewing`, potion colours and tooltips, and
|
||||
//! `BrewingStandBlockEntity.serverTick`.
|
||||
use crate::{
|
||||
containers::Providers,
|
||||
items::{ItemStack, Items},
|
||||
};
|
||||
use serde_json::Value;
|
||||
use std::{collections::HashSet, fs, path::Path, sync::Arc};
|
||||
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
|
||||
pub enum Category {
|
||||
Beneficial,
|
||||
Harmful,
|
||||
Neutral,
|
||||
}
|
||||
/// A `MobEffect`: id (without namespace), colour, category, instantaneous.
|
||||
#[derive(Clone, Copy, Debug)]
|
||||
pub struct EffectDef {
|
||||
pub id: &'static str,
|
||||
pub color: u32,
|
||||
pub category: Category,
|
||||
pub instant: bool,
|
||||
}
|
||||
const fn fx(id: &'static str, color: u32, category: Category) -> EffectDef {
|
||||
EffectDef { id, color, category, instant: false }
|
||||
}
|
||||
use Category::{Beneficial as B, Harmful as H, Neutral as N};
|
||||
/// `MobEffects` in registration order.
|
||||
pub const EFFECTS: &[EffectDef] = &[
|
||||
fx("speed", 3402751, B),
|
||||
fx("slowness", 9154528, H),
|
||||
fx("haste", 14270531, B),
|
||||
fx("mining_fatigue", 4866583, H),
|
||||
fx("strength", 16762624, B),
|
||||
EffectDef { id: "instant_health", color: 16262179, category: B, instant: true },
|
||||
EffectDef { id: "instant_damage", color: 11101546, category: H, instant: true },
|
||||
fx("jump_boost", 16646020, B),
|
||||
fx("nausea", 5578058, H),
|
||||
fx("regeneration", 13458603, B),
|
||||
fx("resistance", 9520880, B),
|
||||
fx("fire_resistance", 16750848, B),
|
||||
fx("water_breathing", 10017472, B),
|
||||
fx("invisibility", 16185078, B),
|
||||
fx("blindness", 2039587, H),
|
||||
fx("night_vision", 12779366, B),
|
||||
fx("hunger", 5797459, H),
|
||||
fx("weakness", 4738376, H),
|
||||
fx("poison", 8889187, H),
|
||||
fx("wither", 7561558, H),
|
||||
fx("health_boost", 16284963, B),
|
||||
fx("absorption", 2445989, B),
|
||||
EffectDef { id: "saturation", color: 16262179, category: B, instant: true },
|
||||
fx("glowing", 9740385, N),
|
||||
fx("levitation", 13565951, H),
|
||||
fx("luck", 5882118, B),
|
||||
fx("unluck", 12624973, H),
|
||||
fx("slow_falling", 15978425, B),
|
||||
fx("conduit_power", 1950417, B),
|
||||
fx("dolphins_grace", 8954814, B),
|
||||
fx("bad_omen", 745784, N),
|
||||
fx("hero_of_the_village", 4521796, B),
|
||||
fx("darkness", 2696993, H),
|
||||
fx("trial_omen", 1484454, N),
|
||||
fx("raid_omen", 14565464, N),
|
||||
fx("wind_charged", 12438015, H),
|
||||
fx("weaving", 7891290, H),
|
||||
fx("oozing", 10092451, H),
|
||||
fx("infested", 9214860, H),
|
||||
fx("breath_of_the_nautilus", 65518, B),
|
||||
];
|
||||
pub fn effect(id: &str) -> Option<&'static EffectDef> {
|
||||
let id = id.trim_start_matches("minecraft:");
|
||||
EFFECTS.iter().find(|e| e.id == id)
|
||||
}
|
||||
/// A `Potion`: id, name suffix (`item.minecraft.potion.effect.<name>`) and
|
||||
/// effects as (effect, duration ticks, amplifier).
|
||||
#[derive(Clone, Copy, Debug)]
|
||||
pub struct PotionDef {
|
||||
pub id: &'static str,
|
||||
pub name: &'static str,
|
||||
pub effects: &'static [(&'static str, i32, i32)],
|
||||
}
|
||||
const fn p(id: &'static str, name: &'static str, effects: &'static [(&'static str, i32, i32)]) -> PotionDef {
|
||||
PotionDef { id, name, effects }
|
||||
}
|
||||
/// `Potions` in registration order.
|
||||
pub const POTIONS: &[PotionDef] = &[
|
||||
p("water", "water", &[]),
|
||||
p("mundane", "mundane", &[]),
|
||||
p("thick", "thick", &[]),
|
||||
p("awkward", "awkward", &[]),
|
||||
p("night_vision", "night_vision", &[("night_vision", 3600, 0)]),
|
||||
p("long_night_vision", "night_vision", &[("night_vision", 9600, 0)]),
|
||||
p("invisibility", "invisibility", &[("invisibility", 3600, 0)]),
|
||||
p("long_invisibility", "invisibility", &[("invisibility", 9600, 0)]),
|
||||
p("leaping", "leaping", &[("jump_boost", 3600, 0)]),
|
||||
p("long_leaping", "leaping", &[("jump_boost", 9600, 0)]),
|
||||
p("strong_leaping", "leaping", &[("jump_boost", 1800, 1)]),
|
||||
p("fire_resistance", "fire_resistance", &[("fire_resistance", 3600, 0)]),
|
||||
p("long_fire_resistance", "fire_resistance", &[("fire_resistance", 9600, 0)]),
|
||||
p("swiftness", "swiftness", &[("speed", 3600, 0)]),
|
||||
p("long_swiftness", "swiftness", &[("speed", 9600, 0)]),
|
||||
p("strong_swiftness", "swiftness", &[("speed", 1800, 1)]),
|
||||
p("slowness", "slowness", &[("slowness", 1800, 0)]),
|
||||
p("long_slowness", "slowness", &[("slowness", 4800, 0)]),
|
||||
p("strong_slowness", "slowness", &[("slowness", 400, 3)]),
|
||||
p("turtle_master", "turtle_master", &[("slowness", 400, 3), ("resistance", 400, 2)]),
|
||||
p("long_turtle_master", "turtle_master", &[("slowness", 800, 3), ("resistance", 800, 2)]),
|
||||
p("strong_turtle_master", "turtle_master", &[("slowness", 400, 5), ("resistance", 400, 3)]),
|
||||
p("water_breathing", "water_breathing", &[("water_breathing", 3600, 0)]),
|
||||
p("long_water_breathing", "water_breathing", &[("water_breathing", 9600, 0)]),
|
||||
p("healing", "healing", &[("instant_health", 1, 0)]),
|
||||
p("strong_healing", "healing", &[("instant_health", 1, 1)]),
|
||||
p("harming", "harming", &[("instant_damage", 1, 0)]),
|
||||
p("strong_harming", "harming", &[("instant_damage", 1, 1)]),
|
||||
p("poison", "poison", &[("poison", 900, 0)]),
|
||||
p("long_poison", "poison", &[("poison", 1800, 0)]),
|
||||
p("strong_poison", "poison", &[("poison", 432, 1)]),
|
||||
p("regeneration", "regeneration", &[("regeneration", 900, 0)]),
|
||||
p("long_regeneration", "regeneration", &[("regeneration", 1800, 0)]),
|
||||
p("strong_regeneration", "regeneration", &[("regeneration", 450, 1)]),
|
||||
p("strength", "strength", &[("strength", 3600, 0)]),
|
||||
p("long_strength", "strength", &[("strength", 9600, 0)]),
|
||||
p("strong_strength", "strength", &[("strength", 1800, 1)]),
|
||||
p("weakness", "weakness", &[("weakness", 1800, 0)]),
|
||||
p("long_weakness", "weakness", &[("weakness", 4800, 0)]),
|
||||
p("luck", "luck", &[("luck", 6000, 0)]),
|
||||
p("slow_falling", "slow_falling", &[("slow_falling", 1800, 0)]),
|
||||
p("long_slow_falling", "slow_falling", &[("slow_falling", 4800, 0)]),
|
||||
p("wind_charged", "wind_charged", &[("wind_charged", 3600, 0)]),
|
||||
p("weaving", "weaving", &[("weaving", 3600, 0)]),
|
||||
p("oozing", "oozing", &[("oozing", 3600, 0)]),
|
||||
p("infested", "infested", &[("infested", 3600, 0)]),
|
||||
];
|
||||
pub fn potion(id: &str) -> Option<&'static PotionDef> {
|
||||
let id = id.trim_start_matches("minecraft:");
|
||||
POTIONS.iter().find(|p| p.id == id)
|
||||
}
|
||||
/// `PotionContents.BASE_POTION_COLOR` (ARGB -13083194) as RGB.
|
||||
pub const BASE_POTION_COLOR: u32 = 0x385DC6;
|
||||
/// `PotionContents.getColor`: amplifier-weighted mix of visible effect colours.
|
||||
pub fn potion_color(id: Option<&str>) -> u32 {
|
||||
let Some(def) = id.and_then(potion) else { return BASE_POTION_COLOR };
|
||||
let (mut r, mut g, mut b, mut total) = (0u32, 0u32, 0u32, 0u32);
|
||||
for (e, _, amp) in def.effects {
|
||||
let Some(e) = effect(e) else { continue };
|
||||
let w = *amp as u32 + 1;
|
||||
r += w * (e.color >> 16 & 255);
|
||||
g += w * (e.color >> 8 & 255);
|
||||
b += w * (e.color & 255);
|
||||
total += w;
|
||||
}
|
||||
if total == 0 { BASE_POTION_COLOR } else { (r / total) << 16 | (g / total) << 8 | b / total }
|
||||
}
|
||||
/// `MobEffectUtil.formatDuration` at 20 TPS: m:ss or h:mm:ss.
|
||||
pub fn format_duration(ticks: i32) -> String {
|
||||
let secs = ticks / 20;
|
||||
let (h, m, s) = (secs / 3600, secs / 60 % 60, secs % 60);
|
||||
if h > 0 { format!("{h}:{m:02}:{s:02}") } else { format!("{m}:{s:02}") }
|
||||
}
|
||||
/// `item.minecraft.potion.effect.<name>` style translation key for a potion item.
|
||||
pub fn potion_name_key(item: &str, potion: Option<&str>) -> String {
|
||||
let prefix = item.trim_start_matches("minecraft:");
|
||||
let suffix = potion.and_then(self::potion).map_or("empty", |p| p.name);
|
||||
format!("item.minecraft.{prefix}.effect.{suffix}")
|
||||
}
|
||||
/// Roman amplifier suffix (`potion.potency.N`) and duration lines of a potion.
|
||||
pub fn tooltip(potion: Option<&str>, scale: f32, translate: &dyn Fn(&str) -> Option<String>) -> Vec<(String, Category)> {
|
||||
let Some(def) = potion.and_then(self::potion) else { return vec![] };
|
||||
if def.effects.is_empty() {
|
||||
return vec![(translate("effect.none").unwrap_or_else(|| "No Effects".into()), Category::Neutral)];
|
||||
}
|
||||
def.effects
|
||||
.iter()
|
||||
.map(|(e, duration, amp)| {
|
||||
let mut line = translate(&format!("effect.minecraft.{e}")).unwrap_or_else(|| (*e).to_owned());
|
||||
if *amp > 0 {
|
||||
line.push(' ');
|
||||
line.push_str(&translate(&format!("potion.potency.{amp}")).unwrap_or_else(|| crate::enchant::level_name(*amp as u32 + 1)));
|
||||
}
|
||||
let instant = effect(e).is_some_and(|d| d.instant);
|
||||
let scaled = (*duration as f32 * scale) as i32;
|
||||
if !instant && scaled > 20 {
|
||||
line = format!("{line} ({})", format_duration(scaled));
|
||||
}
|
||||
(line, effect(e).map_or(Category::Neutral, |d| d.category))
|
||||
})
|
||||
.collect()
|
||||
}
|
||||
|
||||
/// A `PotionIngredient`: item ids plus an optional potion filter.
|
||||
#[derive(Clone, Debug)]
|
||||
pub struct PotionIngredient {
|
||||
pub items: HashSet<String>,
|
||||
pub potions: Option<HashSet<String>>,
|
||||
}
|
||||
impl PotionIngredient {
|
||||
fn parse(v: &Value, items: &Items) -> Self {
|
||||
let mut set = HashSet::new();
|
||||
let add = |s: &str, set: &mut HashSet<String>| match s.strip_prefix('#') {
|
||||
Some(tag) => set.extend(items.item_tags.get(tag).into_iter().flatten().cloned()),
|
||||
None => {
|
||||
set.insert(s.to_owned());
|
||||
}
|
||||
};
|
||||
match &v["item"] {
|
||||
Value::String(s) => add(s, &mut set),
|
||||
Value::Array(a) => a.iter().filter_map(Value::as_str).for_each(|s| add(s, &mut set)),
|
||||
_ => {}
|
||||
}
|
||||
let potions = match &v["potion_contents"]["potions"] {
|
||||
Value::String(s) => Some([s.clone()].into_iter().collect()),
|
||||
Value::Array(a) => Some(a.iter().filter_map(|x| x.as_str().map(str::to_owned)).collect()),
|
||||
_ => None,
|
||||
};
|
||||
Self { items: set, potions }
|
||||
}
|
||||
pub fn test(&self, stack: &ItemStack) -> bool {
|
||||
self.items.contains(&*stack.item) && self.potions.as_ref().is_none_or(|p| stack.potion().is_some_and(|x| p.contains(x)))
|
||||
}
|
||||
}
|
||||
#[derive(Clone, Debug)]
|
||||
pub struct BrewingRecipe {
|
||||
pub id: String,
|
||||
pub input: PotionIngredient,
|
||||
pub reagent: PotionIngredient,
|
||||
pub output: ItemStack,
|
||||
}
|
||||
pub struct Brewing {
|
||||
pub recipes: Vec<BrewingRecipe>,
|
||||
/// `RecipePropertySet.BREWING_REAGENTS`.
|
||||
pub reagents: HashSet<String>,
|
||||
/// Items accepted in the bottle slots (`PotionIngredient.isPotionInput`).
|
||||
pub inputs: HashSet<String>,
|
||||
}
|
||||
impl Brewing {
|
||||
pub fn load(root: &Path, items: &Items) -> Self {
|
||||
let mut files: Vec<_> = fs::read_dir(root.join("data/minecraft/recipe/brewing")).into_iter().flatten().flatten().map(|e| e.path()).collect();
|
||||
files.sort();
|
||||
let mut recipes = Vec::new();
|
||||
for p in files {
|
||||
let Ok(bytes) = fs::read(&p) else { continue };
|
||||
let Ok(v) = serde_json::from_slice::<Value>(&bytes) else { continue };
|
||||
if v["type"] != "minecraft:brewing" {
|
||||
continue;
|
||||
}
|
||||
let mut output = ItemStack::new(v["output"]["id"].as_str().unwrap_or("minecraft:potion"), v["output"]["count"].as_u64().unwrap_or(1) as u32);
|
||||
if let Some(potion) = v["output"]["components"]["minecraft:potion_contents"]["potion"].as_str() {
|
||||
output = output.with_potion(potion);
|
||||
}
|
||||
recipes.push(BrewingRecipe {
|
||||
id: format!("minecraft:brewing/{}", p.file_stem().and_then(|s| s.to_str()).unwrap_or("")),
|
||||
input: PotionIngredient::parse(&v["input"], items),
|
||||
reagent: PotionIngredient::parse(&v["reagent"], items),
|
||||
output,
|
||||
});
|
||||
}
|
||||
let reagents = recipes.iter().flat_map(|r| r.reagent.items.iter().cloned()).collect();
|
||||
let inputs = recipes.iter().flat_map(|r| r.input.items.iter().cloned()).chain(std::iter::once("minecraft:glass_bottle".to_owned())).collect();
|
||||
Self { recipes, reagents, inputs }
|
||||
}
|
||||
pub fn find(&self, input: &ItemStack, reagent: &ItemStack) -> Option<&BrewingRecipe> {
|
||||
self.recipes.iter().find(|r| r.input.test(input) && r.reagent.test(reagent))
|
||||
}
|
||||
pub fn is_reagent(&self, stack: &ItemStack) -> bool {
|
||||
self.reagents.contains(&*stack.item)
|
||||
}
|
||||
pub fn is_bottle(&self, stack: &ItemStack) -> bool {
|
||||
self.inputs.contains(&*stack.item)
|
||||
}
|
||||
}
|
||||
|
||||
/// `BrewingStandBlockEntity` state. Slots: 0-2 bottles, 3 ingredient, 4 fuel.
|
||||
#[derive(Clone, Debug, Default)]
|
||||
pub struct BrewingStand {
|
||||
pub items: [Option<ItemStack>; 5],
|
||||
pub brew_time: i32,
|
||||
pub total_brew_time: i32,
|
||||
pub fuel: i32,
|
||||
pub total_fuel: i32,
|
||||
pub speed: f32,
|
||||
pub ingredient: Option<Arc<str>>,
|
||||
pub last_bottles: Option<[bool; 3]>,
|
||||
}
|
||||
/// What a brewing tick asks the world to do.
|
||||
#[derive(Clone, Debug, Default, PartialEq)]
|
||||
pub struct BrewTick {
|
||||
/// New `has_bottle_0..2` block state values.
|
||||
pub bottles: Option<[bool; 3]>,
|
||||
/// Level event 1035 (brew sound).
|
||||
pub brewed: bool,
|
||||
/// Remainders dropped at the stand.
|
||||
pub drops: Vec<ItemStack>,
|
||||
}
|
||||
impl BrewingStand {
|
||||
pub fn new() -> Self {
|
||||
Self { total_brew_time: 400, total_fuel: 20, speed: 1.0, ..Default::default() }
|
||||
}
|
||||
fn brewable(&self, brewing: &Brewing) -> bool {
|
||||
let Some(ingredient) = &self.items[3] else { return false };
|
||||
if !brewing.is_reagent(ingredient) {
|
||||
return false;
|
||||
}
|
||||
self.items[..3].iter().flatten().any(|b| brewing.find(b, ingredient).is_some())
|
||||
}
|
||||
/// `BrewingStandBlockEntity.serverTick`.
|
||||
pub fn tick(&mut self, brewing: &Brewing, items: &Items, providers: &Providers) -> BrewTick {
|
||||
let mut out = BrewTick::default();
|
||||
if self.fuel <= 0
|
||||
&& let Some(fuel) = self.items[4].as_mut()
|
||||
&& let Some((uses, speed)) = brewing_fuel(items, fuel)
|
||||
{
|
||||
self.fuel = providers.int_value(&uses);
|
||||
self.total_fuel = self.fuel;
|
||||
self.speed = providers.float_value(&speed, 1.0);
|
||||
let remainder = items.get(&fuel.item).and_then(|i| i.remainder.clone());
|
||||
fuel.count -= 1;
|
||||
if fuel.count == 0 {
|
||||
self.items[4] = remainder.map(|r| ItemStack::new(&r, 1));
|
||||
} else if let Some(r) = remainder {
|
||||
out.drops.push(ItemStack::new(&r, 1));
|
||||
}
|
||||
}
|
||||
let brewable = self.brewable(brewing);
|
||||
if self.brew_time > 0 {
|
||||
self.brew_time -= 1;
|
||||
let same = self.items[3].as_ref().map(|s| s.item.clone()) == self.ingredient;
|
||||
if self.brew_time == 0 && brewable {
|
||||
self.brew(brewing, items, &mut out);
|
||||
} else if !brewable || !same {
|
||||
self.brew_time = 0;
|
||||
}
|
||||
} else if brewable && self.fuel > 0 {
|
||||
let speed = if self.speed > 0.0 { self.speed } else { 1.0 };
|
||||
self.fuel -= 1;
|
||||
self.brew_time = (400.0 / speed).ceil() as i32;
|
||||
self.total_brew_time = self.brew_time;
|
||||
self.ingredient = self.items[3].as_ref().map(|s| s.item.clone());
|
||||
}
|
||||
let bottles = [self.items[0].is_some(), self.items[1].is_some(), self.items[2].is_some()];
|
||||
if self.last_bottles != Some(bottles) {
|
||||
self.last_bottles = Some(bottles);
|
||||
out.bottles = Some(bottles);
|
||||
}
|
||||
out
|
||||
}
|
||||
fn brew(&mut self, brewing: &Brewing, items: &Items, out: &mut BrewTick) {
|
||||
let Some(ingredient) = self.items[3].clone() else { return };
|
||||
for slot in 0..3 {
|
||||
if let Some(input) = &self.items[slot]
|
||||
&& let Some(r) = brewing.find(input, &ingredient)
|
||||
{
|
||||
self.items[slot] = Some(r.output.clone());
|
||||
}
|
||||
}
|
||||
let remainder = items.get(&ingredient.item).and_then(|i| i.remainder.clone());
|
||||
if let Some(i) = self.items[3].as_mut() {
|
||||
i.count -= 1;
|
||||
if i.count == 0 {
|
||||
self.items[3] = remainder.map(|r| ItemStack::new(&r, 1));
|
||||
} else if let Some(r) = remainder {
|
||||
out.drops.push(ItemStack::new(&r, 1));
|
||||
}
|
||||
}
|
||||
out.brewed = true;
|
||||
}
|
||||
}
|
||||
/// The `minecraft:brewing_fuel` providers of an item: (uses, speed_multiplier).
|
||||
pub fn brewing_fuel(items: &Items, stack: &ItemStack) -> Option<(Value, Value)> {
|
||||
items.get(&stack.item).and_then(|i| i.brewing_fuel.clone())
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn potion_colours_and_names() {
|
||||
// Swiftness: speed colour 3402751 = 0x33EBFF.
|
||||
assert_eq!(potion_color(Some("minecraft:swiftness")), 0x33EBFF);
|
||||
assert_eq!(potion_color(Some("minecraft:water")), BASE_POTION_COLOR);
|
||||
// Turtle master mixes slowness x4 and resistance x3.
|
||||
let (s, r) = (9154528u32, 9520880u32);
|
||||
let mix = |sh: u32| ((s >> sh & 255) * 4 + (r >> sh & 255) * 3) / 7;
|
||||
assert_eq!(potion_color(Some("minecraft:turtle_master")), mix(16) << 16 | mix(8) << 8 | mix(0));
|
||||
assert_eq!(potion_name_key("minecraft:splash_potion", Some("minecraft:long_swiftness")), "item.minecraft.splash_potion.effect.swiftness");
|
||||
assert_eq!(format_duration(9600), "8:00");
|
||||
assert_eq!(format_duration(450), "0:22");
|
||||
let t = tooltip(Some("minecraft:strong_poison"), 1.0, &|_| None);
|
||||
assert_eq!(t[0].0, "poison II (0:21)");
|
||||
assert_eq!(POTIONS.len(), 46);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn brewing_stand_brews_after_400_ticks() {
|
||||
let mut item_tags = std::collections::HashMap::new();
|
||||
item_tags.insert("x".into(), HashSet::new());
|
||||
let items = Items::for_tests(item_tags);
|
||||
let recipe = BrewingRecipe {
|
||||
id: "awkward".into(),
|
||||
input: PotionIngredient { items: ["minecraft:potion".to_owned()].into_iter().collect(), potions: Some(["minecraft:water".to_owned()].into_iter().collect()) },
|
||||
reagent: PotionIngredient { items: ["minecraft:nether_wart".to_owned()].into_iter().collect(), potions: None },
|
||||
output: ItemStack::new("minecraft:potion", 1).with_potion("minecraft:awkward"),
|
||||
};
|
||||
let brewing = Brewing { reagents: ["minecraft:nether_wart".to_owned()].into_iter().collect(), inputs: HashSet::new(), recipes: vec![recipe] };
|
||||
let providers = Providers::empty();
|
||||
let mut stand = BrewingStand::new();
|
||||
stand.fuel = 1;
|
||||
stand.items[0] = Some(ItemStack::new("minecraft:potion", 1).with_potion("minecraft:water"));
|
||||
stand.items[2] = Some(ItemStack::new("minecraft:potion", 1).with_potion("minecraft:awkward"));
|
||||
stand.items[3] = Some(ItemStack::new("minecraft:nether_wart", 2));
|
||||
let first = stand.tick(&brewing, &items, &providers);
|
||||
assert_eq!(first.bottles, Some([true, false, true]));
|
||||
assert_eq!((stand.brew_time, stand.fuel), (400, 0));
|
||||
let mut brewed_at = 0;
|
||||
for t in 1..=400 {
|
||||
if stand.tick(&brewing, &items, &providers).brewed {
|
||||
brewed_at = t;
|
||||
}
|
||||
}
|
||||
assert_eq!(brewed_at, 400);
|
||||
assert_eq!(stand.items[0].as_ref().unwrap().potion(), Some("minecraft:awkward"));
|
||||
// The awkward potion had no recipe and stays.
|
||||
assert_eq!(stand.items[2].as_ref().unwrap().potion(), Some("minecraft:awkward"));
|
||||
assert_eq!(stand.items[3].as_ref().unwrap().count, 1);
|
||||
// No fuel left: nothing more brews.
|
||||
stand.tick(&brewing, &items, &providers);
|
||||
assert_eq!(stand.brew_time, 0);
|
||||
}
|
||||
}
|
||||
@@ -49,6 +49,7 @@ pub struct Furnace {
|
||||
pub enum BlockEntity {
|
||||
Chest(Vec<Option<ItemStack>>),
|
||||
Furnace(Furnace),
|
||||
Brewing(Box<crate::brewing::BrewingStand>),
|
||||
}
|
||||
impl BlockEntity {
|
||||
pub fn for_block(name: &str) -> Option<Self> {
|
||||
@@ -63,6 +64,9 @@ impl BlockEntity {
|
||||
speed: 1.0,
|
||||
}));
|
||||
}
|
||||
if name == "minecraft:brewing_stand" {
|
||||
return Some(Self::Brewing(Box::new(crate::brewing::BrewingStand::new())));
|
||||
}
|
||||
matches!(
|
||||
name,
|
||||
"minecraft:chest" | "minecraft:trapped_chest" | "minecraft:barrel"
|
||||
@@ -72,6 +76,7 @@ impl BlockEntity {
|
||||
pub fn id(&self) -> &'static str {
|
||||
match self {
|
||||
Self::Chest(_) => "minecraft:chest",
|
||||
Self::Brewing(_) => "minecraft:brewing_stand",
|
||||
Self::Furnace(f) => match f.kind {
|
||||
FurnaceKind::Furnace => "minecraft:furnace",
|
||||
FurnaceKind::BlastFurnace => "minecraft:blast_furnace",
|
||||
@@ -83,12 +88,14 @@ impl BlockEntity {
|
||||
match self {
|
||||
Self::Chest(items) => items.iter().flatten().cloned().collect(),
|
||||
Self::Furnace(f) => f.items.iter().flatten().cloned().collect(),
|
||||
Self::Brewing(b) => b.items.iter().flatten().cloned().collect(),
|
||||
}
|
||||
}
|
||||
pub fn slots_mut(&mut self) -> &mut [Option<ItemStack>] {
|
||||
match self {
|
||||
Self::Chest(items) => items,
|
||||
Self::Furnace(f) => &mut f.items,
|
||||
Self::Brewing(b) => &mut b.items,
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -148,6 +155,18 @@ impl Providers {
|
||||
_ => 0.0,
|
||||
}
|
||||
}
|
||||
/// A plain `context_int_provider` value or reference (no context conditions).
|
||||
pub fn int_value(&self, v: &Value) -> i32 {
|
||||
self.eval(v, false, &self.ints, 0) as i32
|
||||
}
|
||||
/// A plain `context_float_provider` value or reference; `default` when absent.
|
||||
pub fn float_value(&self, v: &Value, default: f32) -> f32 {
|
||||
if v.is_null() { default } else { self.eval(v, false, &self.floats, 0) as f32 }
|
||||
}
|
||||
#[cfg(test)]
|
||||
pub fn empty() -> Self {
|
||||
Self { ints: HashMap::new(), floats: HashMap::new() }
|
||||
}
|
||||
pub fn burn_time(&self, items: &Items, stack: &ItemStack, fast: bool) -> i32 {
|
||||
items
|
||||
.get(&stack.item)
|
||||
|
||||
@@ -1,6 +1,8 @@
|
||||
//! The playable game loop: streaming world, player simulation at 20 ticks/s,
|
||||
//! block interaction, inventory and HUD.
|
||||
mod control;
|
||||
mod station_control;
|
||||
mod stations;
|
||||
use horizon_client::{
|
||||
Result,
|
||||
assets::Assets,
|
||||
@@ -287,6 +289,8 @@ pub struct Resources {
|
||||
player_arm: Option<horizon_client::mobs::Part>,
|
||||
/// firstperson_righthand display transforms per item: (rotation, translation, scale).
|
||||
displays: HashMap<String, Option<([f32; 3], [f32; 3], [f32; 3])>>,
|
||||
/// Enchantments, workstation recipes and brewing (game/stations.rs).
|
||||
stations: horizon_client::stations::StationData,
|
||||
}
|
||||
struct Game<'a> {
|
||||
res: &'a mut Resources,
|
||||
@@ -310,6 +314,8 @@ struct Game<'a> {
|
||||
craft_size: usize,
|
||||
/// Open container block entity, if any.
|
||||
container: Option<(i32, i32, i32)>,
|
||||
/// Open workstation menu (enchanting table, anvil, ...).
|
||||
station: Option<stations::Station>,
|
||||
scratch_slot: Option<ItemStack>,
|
||||
mining: Option<Mining>,
|
||||
destroy_delay: u32,
|
||||
@@ -486,8 +492,7 @@ impl Game<'_> {
|
||||
let order: Vec<usize> = std::iter::once(self.selected).chain((0..36).filter(|&i| i != self.selected)).collect();
|
||||
for &i in &order {
|
||||
if let Some(slot) = &mut self.inventory[i]
|
||||
&& slot.item == stack.item
|
||||
&& slot.damage == stack.damage
|
||||
&& slot.same_item_same_components(&stack)
|
||||
&& slot.count < max
|
||||
{
|
||||
let moved = (max - slot.count).min(stack.count);
|
||||
@@ -828,6 +833,8 @@ impl Game<'_> {
|
||||
if let Some(sound) = sound {
|
||||
self.audio.play(sound, Some([f64::from(key.0) + 0.5, f64::from(key.1) + 0.5, f64::from(key.2) + 0.5]), 0.5, 1.0);
|
||||
}
|
||||
} else if self.open_station(pos, &name) {
|
||||
// Workstation menus: game/stations.rs.
|
||||
} else {
|
||||
self.message = Some((format!("{} is not available yet", name.trim_start_matches("minecraft:").replace('_', " ")), Instant::now()));
|
||||
return;
|
||||
@@ -1392,6 +1399,7 @@ impl Game<'_> {
|
||||
self.bob.1 += (target - self.bob.1) * 0.4;
|
||||
}
|
||||
self.tick_block_entities()?;
|
||||
self.tick_brewing_stands()?;
|
||||
let facts = &self.res.facts;
|
||||
let world = &self.world;
|
||||
self.particles.retain_mut(|p| p.tick(world, |id| facts.states[id as usize].full_collision));
|
||||
@@ -1536,6 +1544,7 @@ impl Game<'_> {
|
||||
}
|
||||
None => batch.fill(atlas, x + 2.0, y + 2.0, 12.0, 12.0, rgba(200, 0, 200, 255)),
|
||||
}
|
||||
self.draw_glint(batch, stack, x, y);
|
||||
if stack.count > 1 {
|
||||
let text = stack.count.to_string();
|
||||
let w = HudBatch::text_width(atlas, &text);
|
||||
@@ -1726,10 +1735,14 @@ impl Game<'_> {
|
||||
}
|
||||
/// 300.. are the open container's slots.
|
||||
fn slots(&self) -> Vec<usize> {
|
||||
if let Some(v) = self.station_slots() {
|
||||
return v;
|
||||
}
|
||||
let mut v: Vec<usize> = (0..36).collect();
|
||||
match self.container_kind() {
|
||||
Some(BlockEntity::Chest(items)) => v.extend((0..items.len()).map(|i| 300 + i)),
|
||||
Some(BlockEntity::Furnace(_)) => v.extend(300..303),
|
||||
Some(BlockEntity::Brewing(_)) => v.extend(300..305),
|
||||
None => {
|
||||
v.extend((0..self.craft_size * self.craft_size).map(|i| 100 + i));
|
||||
v.push(200);
|
||||
@@ -1742,6 +1755,9 @@ impl Game<'_> {
|
||||
}
|
||||
/// InventoryMenu / CraftingMenu slot layouts.
|
||||
fn slot_position(&self, i: usize) -> (f32, f32) {
|
||||
if let Some(p) = self.station_slot_position(i) {
|
||||
return p;
|
||||
}
|
||||
let table = self.craft_size == 3;
|
||||
// ContainerScreen (3 rows) shifts the player inventory down by one pixel.
|
||||
let shift = if matches!(self.container_kind(), Some(BlockEntity::Chest(_))) { 1.0 } else { 0.0 };
|
||||
@@ -1773,6 +1789,9 @@ impl Game<'_> {
|
||||
})
|
||||
}
|
||||
fn slot_mut(&mut self, i: usize) -> &mut Option<ItemStack> {
|
||||
if i >= stations::INPUT {
|
||||
return self.station_slot_mut(i);
|
||||
}
|
||||
if (500..504).contains(&i) {
|
||||
return &mut self.armor[i - 500];
|
||||
}
|
||||
@@ -1795,6 +1814,9 @@ impl Game<'_> {
|
||||
self.res.recipes.craft(&grid, n)
|
||||
}
|
||||
fn draw_inventory(&mut self, batch: &mut HudBatch) {
|
||||
if self.draw_station(batch) {
|
||||
return;
|
||||
}
|
||||
let (ox, oy) = self.inventory_origin(batch);
|
||||
{
|
||||
let atlas = &self.res.atlas;
|
||||
@@ -1841,6 +1863,7 @@ impl Game<'_> {
|
||||
part(batch, "gui/sprites/container/furnace/burn_progress", 0.0, 0.0, w, 16.0, ox + 79.0, oy + 34.0);
|
||||
}
|
||||
}
|
||||
Some(BlockEntity::Brewing(_)) => {}
|
||||
None => {
|
||||
let texture = if self.craft_size == 3 { "gui/container/crafting_table" } else { "gui/container/inventory" };
|
||||
part(batch, texture, 0.0, 0.0, 176.0, 166.0, ox, oy);
|
||||
@@ -1870,8 +1893,10 @@ impl Game<'_> {
|
||||
if let Some(stack) = self.carried.clone() {
|
||||
self.draw_item(batch, &stack, self.cursor.0 - 8.0, self.cursor.1 - 8.0);
|
||||
}
|
||||
self.draw_slot_tooltip(batch);
|
||||
}
|
||||
fn close_container(&mut self) {
|
||||
self.close_station();
|
||||
let mut returned: Vec<ItemStack> = self.carried.take().into_iter().collect();
|
||||
returned.extend(self.craft_grid.iter_mut().filter_map(Option::take));
|
||||
for stack in returned {
|
||||
@@ -1892,6 +1917,9 @@ impl Game<'_> {
|
||||
}
|
||||
}
|
||||
fn click_inventory(&mut self, right: bool) {
|
||||
if self.station_click(right) {
|
||||
return;
|
||||
}
|
||||
let Some(size) = self.renderer.as_ref().map(|r| [r.config.width, r.config.height]) else { return };
|
||||
let batch = HudBatch::new(size);
|
||||
let Some(slot) = self.slot_at(&batch, self.cursor.0, self.cursor.1) else { return };
|
||||
@@ -1957,8 +1985,7 @@ impl Game<'_> {
|
||||
let mut stack = stack;
|
||||
for i in range.clone() {
|
||||
if let Some(s) = &mut self.inventory[i]
|
||||
&& s.item == stack.item
|
||||
&& s.damage == stack.damage
|
||||
&& s.same_item_same_components(&stack)
|
||||
{
|
||||
let moved = max(&self.res.items, s).saturating_sub(s.count).min(stack.count);
|
||||
s.count += moved;
|
||||
@@ -2004,7 +2031,7 @@ impl Game<'_> {
|
||||
(Some(one), (c.count > 0).then_some(c))
|
||||
}
|
||||
(Some(c), None) => (Some(c), None),
|
||||
(Some(mut c), Some(mut s)) if c.item == s.item && c.damage == s.damage => {
|
||||
(Some(mut c), Some(mut s)) if c.same_item_same_components(&s) => {
|
||||
let room = max(items, &s).saturating_sub(s.count);
|
||||
let moved = if right { 1.min(room).min(c.count) } else { room.min(c.count) };
|
||||
s.count += moved;
|
||||
@@ -4426,6 +4453,9 @@ impl ApplicationHandler for Game<'_> {
|
||||
let rows = self.creative_screen.rows(&self.res.names).saturating_sub(5).max(1) as f32;
|
||||
self.creative_screen.scroll = (self.creative_screen.scroll - d.signum() / rows).clamp(0.0, 1.0);
|
||||
}
|
||||
if self.screen == Screen::Inventory && d != 0.0 {
|
||||
self.station_scroll(d);
|
||||
}
|
||||
if self.screen == Screen::Playing && d != 0.0 {
|
||||
self.selected = (self.selected as i32 - d.signum() as i32).rem_euclid(9) as usize;
|
||||
}
|
||||
@@ -4520,6 +4550,14 @@ impl ApplicationHandler for Game<'_> {
|
||||
}
|
||||
self.creative_screen.scroll = 0.0;
|
||||
}
|
||||
WindowEvent::KeyboardInput { event, .. }
|
||||
if self.station_typing() && event.state == ElementState::Pressed
|
||||
&& !matches!(event.physical_key, PhysicalKey::Code(KeyCode::Escape)) =>
|
||||
{
|
||||
// The anvil rename box takes every key but Escape (AnvilScreen.keyPressed).
|
||||
let backspace = event.physical_key == PhysicalKey::Code(KeyCode::Backspace);
|
||||
self.station_text(event.text.as_deref(), backspace);
|
||||
}
|
||||
WindowEvent::KeyboardInput { event, .. } if self.title.is_some() => {
|
||||
if event.state == ElementState::Pressed
|
||||
&& let Some(title) = self.title.as_mut()
|
||||
@@ -4684,7 +4722,9 @@ pub fn run() -> Result<()> {
|
||||
let audio = Audio::new(&root);
|
||||
let world = World::new(facts.air, 0);
|
||||
let creative = options.creative;
|
||||
let stations = horizon_client::stations::StationData::load(&root, &items);
|
||||
let mut resources = Resources {
|
||||
stations,
|
||||
assets,
|
||||
facts,
|
||||
items,
|
||||
@@ -4738,6 +4778,7 @@ pub fn run() -> Result<()> {
|
||||
craft_grid: vec![None; 9],
|
||||
craft_size: 2,
|
||||
container: None,
|
||||
station: None,
|
||||
scratch_slot: None,
|
||||
mining: None,
|
||||
destroy_delay: 0,
|
||||
|
||||
@@ -65,7 +65,7 @@ impl Game<'_> {
|
||||
};
|
||||
let ok = || Ok(Some(json!({ "ok": true })));
|
||||
match words[0] {
|
||||
"help" => Ok(Some(json!({ "commands": HELP }))),
|
||||
"help" => Ok(Some(json!({ "commands": HELP.iter().chain(super::station_control::HELP).collect::<Vec<_>>() }))),
|
||||
"status" => Ok(Some(self.control_status())),
|
||||
"key" => {
|
||||
let key = key_code(arg(1)?).ok_or_else(|| format!("unknown key {}", words[1]))?;
|
||||
@@ -253,7 +253,10 @@ impl Game<'_> {
|
||||
event_loop.exit();
|
||||
ok()
|
||||
}
|
||||
other => Err(format!("unknown command {other}; try help").into()),
|
||||
other => match self.station_command(&words)? {
|
||||
Some(value) => Ok(Some(value)),
|
||||
None => Err(format!("unknown command {other}; try help").into()),
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -0,0 +1,150 @@
|
||||
//! Control-socket commands for menus and item components, so scripts can
|
||||
//! drive the workstation screens (`horizon-ctl click-slot 600`, ...).
|
||||
use super::{Game, Screen};
|
||||
use horizon_client::{Result, items::ItemStack};
|
||||
use serde_json::{Value, json};
|
||||
|
||||
pub(super) const HELP: &[&str] = &[
|
||||
"xp LEVELS add (or remove) experience levels",
|
||||
"setblock X Y Z BLOCK place a block's default state (with its block entity)",
|
||||
"use X Y Z open the block's menu as if right-clicked",
|
||||
"click-slot ID [right] [shift] click a menu slot (0-35 inventory, 300+ container, 600+ station, 650 result)",
|
||||
"click-gui X Y [right] [shift] click at GUI pixel X Y relative to the menu's top-left corner",
|
||||
"type TEXT | type-back type into the anvil name box / delete one character",
|
||||
"enchant ID LEVEL enchant the held item (books store the enchantment)",
|
||||
"potion ITEM POTION give a potion item (potion, splash_potion, lingering_potion, tipped_arrow)",
|
||||
"menu JSON dump of the open menu, carried stack and inventory",
|
||||
"close close the open menu",
|
||||
];
|
||||
fn id(name: &str) -> String {
|
||||
if name.contains(':') { name.to_owned() } else { format!("minecraft:{name}") }
|
||||
}
|
||||
fn stack_json(s: &ItemStack) -> Value {
|
||||
json!({
|
||||
"item": &*s.item,
|
||||
"count": s.count,
|
||||
"damage": s.damage,
|
||||
"enchantments": s.enchantments().iter().map(|(e, l)| json!([&**e, l])).collect::<Vec<_>>(),
|
||||
"stored_enchantments": s.stored_enchantments().iter().map(|(e, l)| json!([&**e, l])).collect::<Vec<_>>(),
|
||||
"repair_cost": s.repair_cost(),
|
||||
"custom_name": s.custom_name(),
|
||||
"potion": s.potion(),
|
||||
"trim": s.data().and_then(|d| d.trim.as_ref()).map(|(m, p)| json!([&**m, &**p])),
|
||||
})
|
||||
}
|
||||
|
||||
impl Game<'_> {
|
||||
fn click_at(&mut self, x: f32, y: f32, right: bool, shift: bool) {
|
||||
use winit::keyboard::KeyCode;
|
||||
let saved = self.cursor;
|
||||
self.cursor = (x, y);
|
||||
let had_shift = self.keys.contains(&KeyCode::ShiftLeft);
|
||||
if shift {
|
||||
self.keys.insert(KeyCode::ShiftLeft);
|
||||
}
|
||||
self.click_inventory(right);
|
||||
if shift && !had_shift {
|
||||
self.keys.remove(&KeyCode::ShiftLeft);
|
||||
}
|
||||
let _ = saved;
|
||||
}
|
||||
fn gui_origin(&self) -> Result<(f32, f32)> {
|
||||
let size = self.renderer.as_ref().map(|r| [r.config.width, r.config.height]).ok_or("no renderer yet")?;
|
||||
Ok(self.inventory_origin(&horizon_client::hud::HudBatch::new(size)))
|
||||
}
|
||||
/// Commands not known to control.rs; None when unknown here too.
|
||||
pub(super) fn station_command(&mut self, words: &[&str]) -> Result<Option<Value>> {
|
||||
let arg = |i: usize| words.get(i).copied().ok_or_else(|| format!("{} needs more arguments", words[0]));
|
||||
let flag = |name: &str| words.iter().skip(1).any(|w| *w == name);
|
||||
let ok = || Ok(Some(json!({ "ok": true })));
|
||||
match words.first().copied().unwrap_or("") {
|
||||
"xp" => {
|
||||
let n: i32 = arg(1)?.parse()?;
|
||||
self.give_levels(n);
|
||||
Ok(Some(json!({ "ok": true, "level": self.experience.level })))
|
||||
}
|
||||
"setblock" => {
|
||||
let pos = [arg(1)?.parse()?, arg(2)?.parse()?, arg(3)?.parse()?];
|
||||
let name = id(arg(4)?);
|
||||
if !self.set_state_named(pos, &name, &[])? {
|
||||
return Err(format!("cannot place {name}").into());
|
||||
}
|
||||
if let Some(entity) = horizon_client::containers::BlockEntity::for_block(&name) {
|
||||
self.world.block_entities.insert((pos[0], pos[1], pos[2]), entity);
|
||||
}
|
||||
self.world.modified.insert((pos[0] >> 4, pos[2] >> 4));
|
||||
ok()
|
||||
}
|
||||
"use" => {
|
||||
let pos = [arg(1)?.parse()?, arg(2)?.parse()?, arg(3)?.parse()?];
|
||||
self.open_menu(pos);
|
||||
Ok(Some(json!({ "ok": true, "station": self.station.as_ref().map(|s| format!("{:?}", s.kind)) })))
|
||||
}
|
||||
"click-slot" => {
|
||||
let slot: usize = arg(1)?.parse()?;
|
||||
let (ox, oy) = self.gui_origin()?;
|
||||
let (sx, sy) = self.slot_position(slot);
|
||||
self.click_at(ox + sx + 8.0, oy + sy + 8.0, flag("right"), flag("shift"));
|
||||
ok()
|
||||
}
|
||||
"click-gui" => {
|
||||
let (x, y): (f32, f32) = (arg(1)?.parse()?, arg(2)?.parse()?);
|
||||
let (ox, oy) = self.gui_origin()?;
|
||||
self.click_at(ox + x, oy + y, flag("right"), flag("shift"));
|
||||
ok()
|
||||
}
|
||||
"type" => {
|
||||
let text = words[1..].join(" ");
|
||||
self.station_text(Some(&text), false);
|
||||
ok()
|
||||
}
|
||||
"type-back" => {
|
||||
self.station_text(None, true);
|
||||
ok()
|
||||
}
|
||||
"enchant" => {
|
||||
let e = id(arg(1)?);
|
||||
let level: u32 = arg(2)?.parse()?;
|
||||
if self.res.stations.enchantments.get(&e).is_none() {
|
||||
return Err(format!("unknown enchantment {e}").into());
|
||||
}
|
||||
let held = self.inventory[self.selected].as_mut().ok_or("no held item")?;
|
||||
held.enchant(&e, level);
|
||||
self.apply_equipment();
|
||||
ok()
|
||||
}
|
||||
"potion" => {
|
||||
let stack = ItemStack::new(&id(arg(1)?), 1).with_potion(&id(arg(2)?));
|
||||
let rest = self.give(stack);
|
||||
Ok(Some(json!({ "ok": rest.is_none() })))
|
||||
}
|
||||
"menu" => {
|
||||
let slots: Vec<Value> = self
|
||||
.slots()
|
||||
.into_iter()
|
||||
.filter_map(|i| {
|
||||
let s = if i == 200 { self.craft_result() } else { self.slot_mut(i).clone() };
|
||||
s.map(|s| json!({ "slot": i, "stack": stack_json(&s) }))
|
||||
})
|
||||
.collect();
|
||||
Ok(Some(json!({
|
||||
"screen": if self.screen == Screen::Inventory { "inventory" } else { "other" },
|
||||
"station": self.station.as_ref().map(|s| format!("{:?}", s.kind)),
|
||||
"name": self.station.as_ref().map(|s| s.name.clone()),
|
||||
"info": self.station_info(),
|
||||
"carried": self.carried.as_ref().map(stack_json),
|
||||
"level": self.experience.level,
|
||||
"xp_seed": self.level.xp_seed,
|
||||
"slots": slots,
|
||||
})))
|
||||
}
|
||||
"close" => {
|
||||
self.close_container();
|
||||
self.screen = Screen::Playing;
|
||||
self.capture(true);
|
||||
ok()
|
||||
}
|
||||
_ => Ok(None),
|
||||
}
|
||||
}
|
||||
}
|
||||
File diff suppressed because it is too large
Load Diff
@@ -33,6 +33,8 @@ pub struct ItemInfo {
|
||||
pub attack_speed: f32,
|
||||
/// `cooking_fuel`: burn-time and speed-multiplier provider references.
|
||||
pub fuel: Option<(Value, Value)>,
|
||||
/// `brewing_fuel`: uses and speed-multiplier provider references.
|
||||
pub brewing_fuel: Option<(Value, Value)>,
|
||||
/// Item left behind after crafting/fuel use (e.g. bucket).
|
||||
pub remainder: Option<String>,
|
||||
/// `equippable.slot` (head, chest, legs, feet, ...).
|
||||
@@ -178,6 +180,7 @@ impl Items {
|
||||
})
|
||||
.collect(),
|
||||
fuel: c.get("minecraft:cooking_fuel").map(|f| (f["burn_time"].clone(), f["speed_multiplier"].clone())),
|
||||
brewing_fuel: c.get("minecraft:brewing_fuel").map(|f| (f["uses"].clone(), f["speed_multiplier"].clone())),
|
||||
remainder: c["minecraft:use_remainder"]["id"].as_str().or(c["minecraft:crafting_remainder"]["id"].as_str()).or(c["minecraft:crafting_remainder"].as_str()).map(str::to_owned),
|
||||
attack_damage: modifier("minecraft:attack_damage"),
|
||||
attack_speed: modifier("minecraft:attack_speed"),
|
||||
|
||||
@@ -6,6 +6,7 @@ pub mod attribute_updates;
|
||||
pub mod audio;
|
||||
pub mod biome;
|
||||
pub mod blocks;
|
||||
pub mod brewing;
|
||||
pub mod chunk;
|
||||
pub mod clock;
|
||||
pub mod containers;
|
||||
|
||||
@@ -107,6 +107,14 @@ fn encode_block_entity(p: (i32, i32, i32), e: &crate::containers::BlockEntity) -
|
||||
entries.push(("cooking_time_spent", Tag::Short(f.cooking_timer as i16)));
|
||||
entries.push(("cooking_total_time", Tag::Short(f.cooking_total as i16)));
|
||||
}
|
||||
BlockEntity::Brewing(b) => {
|
||||
entries.push(("Items", encode_items(&b.items)));
|
||||
entries.push(("BrewTime", Tag::Int(b.brew_time)));
|
||||
entries.push(("total_brew_time", Tag::Int(b.total_brew_time)));
|
||||
entries.push(("Fuel", Tag::Int(b.fuel)));
|
||||
entries.push(("total_fuel", Tag::Int(b.total_fuel)));
|
||||
entries.push(("speed_multiplier", Tag::Float(b.speed.to_bits())));
|
||||
}
|
||||
}
|
||||
Tag::compound(entries)
|
||||
}
|
||||
@@ -131,6 +139,21 @@ fn decode_block_entity(tag: &Tag) -> Option<((i32, i32, i32), crate::containers:
|
||||
f.cooking_timer = int("cooking_time_spent").unwrap_or(0);
|
||||
f.cooking_total = int("cooking_total_time").unwrap_or(200);
|
||||
}
|
||||
BlockEntity::Brewing(b) => {
|
||||
let items = decode_items(tag.get("Items"), 5);
|
||||
b.items = [items[0].clone(), items[1].clone(), items[2].clone(), items[3].clone(), items[4].clone()];
|
||||
b.brew_time = int("BrewTime").unwrap_or(0);
|
||||
b.total_brew_time = int("total_brew_time").unwrap_or(400);
|
||||
if b.brew_time > 0 {
|
||||
b.ingredient = b.items[3].as_ref().map(|s| s.item.clone());
|
||||
}
|
||||
b.fuel = int("Fuel").unwrap_or(0);
|
||||
b.total_fuel = int("total_fuel").unwrap_or(20);
|
||||
b.speed = match tag.get("speed_multiplier") {
|
||||
Some(Tag::Float(f)) => f32::from_bits(*f),
|
||||
_ => 1.0,
|
||||
};
|
||||
}
|
||||
}
|
||||
Some((pos, entity))
|
||||
}
|
||||
|
||||
@@ -12,6 +12,18 @@ use horizon_core::random::{LegacyRandom, RandomSource};
|
||||
use serde_json::Value;
|
||||
use std::{collections::HashSet, fs, path::Path, sync::Arc};
|
||||
|
||||
/// Everything the workstation menus read, loaded once with the resources.
|
||||
pub struct StationData {
|
||||
pub enchantments: Enchantments,
|
||||
pub recipes: StationRecipes,
|
||||
pub brewing: crate::brewing::Brewing,
|
||||
}
|
||||
impl StationData {
|
||||
pub fn load(root: &Path, items: &Items) -> Self {
|
||||
Self { enchantments: Enchantments::load(root), recipes: StationRecipes::load(root, items), brewing: crate::brewing::Brewing::load(root, items) }
|
||||
}
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------- enchanting
|
||||
|
||||
/// `EnchantingTableBlock.BOOKSHELF_OFFSETS`: the 5x5 ring two blocks out, two high.
|
||||
|
||||
Reference in New Issue
Block a user