df14adbfba
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
614 lines
21 KiB
Rust
614 lines
21 KiB
Rust
//! 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;
|
|
}
|
|
match (
|
|
r.checked_div(total),
|
|
g.checked_div(total),
|
|
b.checked_div(total),
|
|
) {
|
|
(Some(r), Some(g), Some(b)) => (r << 16) | (g << 8) | b,
|
|
_ => BASE_POTION_COLOR,
|
|
}
|
|
}
|
|
/// `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);
|
|
}
|
|
}
|