Merge worktree-agent-afae8fa7e3c2bed72

This commit is contained in:
Ludovic Marie
2026-10-10 09:55:55 +02:00
37 changed files with 3234 additions and 411 deletions
@@ -0,0 +1,433 @@
//! Replays the render states of the vanilla entity-animation oracle through
//! Horizon's `mobs::anim::setup` and writes every part's pose.
//!
//! cargo run --profile fast -p horizon-client --example entity_anim_fixture -- \
//! RESOURCES VANILLA.jsonl OUT.jsonl
use horizon_client::mobs::{
Mob, MobData, MobTypes, Part, Species, allay,
anim::{self, Poses, State},
aquatic, body_anim as b_anim, equine, guardian,
keyframes::AnimationState,
shulker, species, tame,
};
use horizon_core::geometry::Vec3;
use serde_json::{Value, json};
use std::{collections::BTreeMap, fs, path::PathBuf, sync::Arc};
fn walk(part: &Part, path: &str, poses: &Poses, out: &mut BTreeMap<String, Value>) {
let p = poses.pose(part);
let mut polys = 0;
let mut sum = 0.0f64;
for polygon in &part.polygons {
polys += 1;
for v in polygon.vertices {
sum += f64::from(v[0])
+ 2.0 * f64::from(v[1])
+ 3.0 * f64::from(v[2])
+ 5.0 * f64::from(v[3])
+ 7.0 * f64::from(v[4]);
}
}
let visible = !poses.is_hidden(part) && !poses.skips(part);
let mut row: Vec<Value> = p.iter().map(|&x| json!(x)).collect();
row.push(json!(u8::from(visible)));
row.push(json!(polys));
row.push(json!(sum));
out.insert(path.to_owned(), Value::Array(row));
for c in &part.children {
let child = if path.is_empty() {
c.name.clone()
} else {
format!("{path}/{}", c.name)
};
walk(c, &child, poses, out);
}
}
/// The entity-side values behind the render-state fields the case sets, for
/// the species whose Horizon animation reads them from the `Mob`.
fn entity_state(mob: &mut Mob, species: Species, case: &Value) {
let flag = |k: &str| case[k].as_bool().unwrap_or(false);
let num = |k: &str| case[k].as_f64().unwrap_or(0.0) as f32;
match species {
Species::Sheep => mob.extra.anim_ticks = num("eatTick") as i32,
Species::Guardian | Species::ElderGuardian => {
mob.anim.v[guardian::TAIL] = num("tailAnimation");
mob.anim.vo[guardian::TAIL] = num("tailAnimation");
mob.anim.v[guardian::SPIKES] = num("spikesAnimation");
mob.anim.vo[guardian::SPIKES] = num("spikesAnimation");
}
Species::Shulker => {
mob.anim.v[shulker::PEEK] = num("peekAmount");
mob.anim.vo[shulker::PEEK] = num("peekAmount");
}
Species::Zombie
| Species::Husk
| Species::Drowned
| Species::ZombieVillager
| Species::ZombifiedPiglin
| Species::Giant
| Species::Skeleton
| Species::Stray
| Species::Bogged
| Species::WitherSkeleton
| Species::Parched => {
mob.ai.aggressive = flag("isAggressive");
mob.extra.crouching = flag("isCrouching");
mob.extra.passenger = flag("isPassenger");
if flag("isHoldingBow") {
mob.extra.main_hand = Some("minecraft:bow".into());
}
}
Species::IronGolem => {
mob.extra.anim_ticks = num("attackTicksRemaining") as i32;
mob.extra.counter = num("offerFlowerTick") as i32;
}
Species::Hoglin | Species::Zoglin => {
mob.extra.anim_ticks = num("attackAnimationRemainingTicks") as i32;
}
Species::Ravager => {
mob.extra.counter2 = num("stunnedTicksRemaining") as i32;
mob.extra.counter = num("attackTicksRemaining") as i32;
let roar = num("roarAnimation");
if roar > 0.0 {
mob.extra.anim_ticks = (20.0 - roar * 20.0) as i32;
}
}
Species::Vex => mob.extra.flag = flag("isCharging"),
Species::Squid | Species::GlowSquid => {
mob.anim.v[aquatic::TENTACLE_ANGLE] = num("tentacleAngle");
mob.anim.vo[aquatic::TENTACLE_ANGLE] = num("tentacleAngle");
}
Species::Dolphin => {
if flag("isMoving") {
mob.velocity.x = 0.1;
}
}
Species::Cod | Species::Salmon | Species::TropicalFish | Species::Tadpole => {
mob.fluids.in_water = flag("isInWater");
}
Species::Allay => {
mob.extra.flag = flag("isDancing");
mob.extra.ints[4] = if flag("isSpinning") { 10 } else { 20 };
mob.anim.v[allay::SPIN] = num("spinningProgress") * 15.0;
mob.anim.vo[allay::SPIN] = num("spinningProgress") * 15.0;
mob.anim.v[allay::HOLD] = num("holdingAnimationProgress") * 5.0;
mob.anim.vo[allay::HOLD] = num("holdingAnimationProgress") * 5.0;
}
Species::Horse
| Species::Donkey
| Species::Mule
| Species::ZombieHorse
| Species::SkeletonHorse => {
for (slot, key) in [
(equine::EAT, "eatAnimation"),
(equine::STAND, "standAnimation"),
(equine::MOUTH, "feedingAnimation"),
] {
mob.anim.v[slot] = num(key);
mob.anim.vo[slot] = num(key);
}
mob.fluids.in_water = flag("isInWater");
mob.extra.chested = flag("hasChest");
}
Species::Camel => {
for (i, k) in [
"sitAnimationState",
"sitPoseAnimationState",
"sitUpAnimationState",
"idleAnimationState",
"dashAnimationState",
]
.into_iter()
.enumerate()
{
mob.anim.states[i].started = case[k].as_f64().map(|v| v as f32);
}
mob.extra.anim_ticks = num("jumpCooldown") as i32;
}
Species::Chicken => {
mob.anim.flap = num("flap");
mob.anim.flap_o = num("flap");
mob.anim.flap_speed = num("flapSpeed");
mob.anim.flap_speed_o = num("flapSpeed");
}
Species::Wolf => {
mob.extra.sitting = flag("isSitting");
mob.extra.anger = if flag("isAngry") { 100 } else { 0 };
mob.anim.v[tame::SHAKE] = num("shakeAnim");
mob.anim.vo[tame::SHAKE] = num("shakeAnim");
mob.anim.v[tame::INTEREST] = num("interest");
mob.anim.vo[tame::INTEREST] = num("interest");
}
Species::Creaking => {
mob.extra.flag2 = !flag("canMove");
for (i, k) in [
"attackAnimationState",
"invulnerabilityAnimationState",
"deathAnimationState",
]
.into_iter()
.enumerate()
{
mob.anim.states[i].started = case[k].as_f64().map(|v| v as f32);
}
}
Species::Witch if flag("isHoldingItem") => {
mob.extra.main_hand = Some("minecraft:potion".into());
}
_ => {}
}
}
fn main() -> horizon_client::Result<()> {
let args: Vec<String> = std::env::args().skip(1).collect();
let root = PathBuf::from(&args[0]);
let types = MobTypes::load(&root)?;
let animations = MobData::load_animations(&root);
let mut out = String::new();
for line in fs::read_to_string(&args[1])?.lines() {
let v: Value = serde_json::from_str(line)?;
let layer = v["layer"]
.as_str()
.unwrap_or_default()
.trim_start_matches("minecraft:");
let baby = layer.contains("_baby#");
let adult = layer.replace("_baby#", "#");
// Variant layers (sizes, hatless villagers, climate cows...) animate
// like their base model.
let mut base = adult.clone();
for cut in ["_no_hat", "_small", "_medium", "_large"] {
base = base.replace(cut, "");
}
let base = base.trim_start_matches("cold_").trim_start_matches("warm_");
let Some(def) = species::ALL.iter().find(|d| {
d.model == layer
|| (baby && d.model == adult)
|| d.model == base
|| d.model.trim_end_matches("#main") == base.trim_end_matches("#main")
}) else {
out.push_str(&format!("{}\n", json!({"skip": "no species"})));
continue;
};
let Some(kind) = types.types.get(&format!("minecraft:{}", def.name)) else {
out.push_str(&format!("{}\n", json!({"skip": "no type"})));
continue;
};
let kind = Arc::new(kind.clone());
let model = kind
.layer(layer)
.cloned()
.unwrap_or_else(|| kind.model.clone());
let mut mob = Mob::new(7, kind, Vec3::new(0.0, 64.0, 0.0), 0.0);
mob.extra.main_hand = None;
let case = &v["case"];
let f = |k: &str| case[k].as_f64().unwrap_or(0.0) as f32;
if baby {
mob.extra.age = -24000;
}
mob.age = f("ageInTicks") as u32;
let state = State {
pos: f("walkAnimationPos"),
speed: f("walkAnimationSpeed"),
age: f("ageInTicks"),
y_rot: f("yRot"),
x_rot: f("xRot"),
swing: f("swingAnimation"),
baby,
partial: 0.0,
};
let mut poses = Poses::new(&model);
entity_state(&mut mob, def.species, case);
let flag = |k: &str| case[k].as_bool().unwrap_or(false);
let num = |k: &str| case[k].as_f64().unwrap_or(0.0) as f32;
let started = |k: &str| AnimationState {
started: case[k].as_f64().map(|v| v as f32),
};
let (p, s) = (&mut poses, &state);
match def.species {
Species::Goat => b_anim::goat(
p,
s,
&b_anim::Goat {
left_horn: flag("hasLeftHorn"),
right_horn: flag("hasRightHorn"),
ramming_x_head_rot: num("rammingXHeadRot"),
},
),
Species::PolarBear => b_anim::polar_bear(p, s, num("standScale")),
Species::Panda => b_anim::panda(
p,
s,
&b_anim::Panda {
unhappy: flag("isUnhappy"),
sneezing: flag("isSneezing"),
sneeze_time: num("sneezeTime") as i32,
eating: flag("isEating"),
scared: flag("isScared"),
sit_amount: num("sitAmount"),
lie_on_back_amount: num("lieOnBackAmount"),
roll_amount: num("rollAmount"),
},
),
Species::Llama | Species::TraderLlama => b_anim::llama(p, s, flag("hasChest")),
Species::Turtle => b_anim::turtle(
p,
s,
&b_anim::Turtle {
on_land: flag("isOnLand"),
laying_egg: flag("isLayingEgg"),
has_egg: flag("hasEgg"),
},
),
Species::Strider => b_anim::strider(p, s, flag("isRidden")),
Species::SnowGolem => b_anim::snow_golem(p, s),
Species::Silverfish => b_anim::silverfish(p, s),
Species::Endermite => b_anim::endermite(p, s),
Species::Parrot => b_anim::parrot(
p,
s,
match case["pose"].as_str() {
Some("FLYING") => b_anim::ParrotPose::Flying,
Some("ON_SHOULDER") => b_anim::ParrotPose::OnShoulder,
Some("SITTING") => b_anim::ParrotPose::Sitting,
Some("PARTY") => b_anim::ParrotPose::Party,
_ => b_anim::ParrotPose::Standing,
},
num("flapAngle"),
),
Species::Bee => b_anim::bee(
p,
s,
&b_anim::Bee {
has_stinger: flag("hasStinger"),
on_ground: flag("isOnGround"),
angry: flag("isAngry"),
roll_amount: num("rollAmount"),
},
),
Species::Bat => b_anim::bat(
p,
s,
flag("isResting"),
&started("flyAnimationState"),
&started("restAnimationState"),
&animations,
),
Species::Armadillo => b_anim::armadillo(
p,
s,
&b_anim::Armadillo {
hiding_in_shell: flag("isHidingInShell"),
roll_out: started("rollOutAnimationState"),
roll_up: started("rollUpAnimationState"),
peek: started("peekAnimationState"),
},
&animations,
),
Species::Axolotl => b_anim::axolotl(
p,
s,
&b_anim::Axolotl {
playing_dead: num("playingDeadFactor"),
in_water: num("inWaterFactor"),
on_ground: num("onGroundFactor"),
moving: num("movingFactor"),
swim: started("swimAnimation"),
walk: started("walkAnimationState"),
idle_on_ground: started("idleOnGroundAnimationState"),
idle_underwater_on_ground: started("idleUnderWaterOnGroundAnimationState"),
idle_underwater: started("idleUnderWaterAnimationState"),
play_dead: started("playDeadAnimationState"),
},
&animations,
),
Species::Frog => b_anim::frog(
p,
s,
&b_anim::Frog {
swimming: flag("isSwimming"),
jump: started("jumpAnimationState"),
croak: started("croakAnimationState"),
tongue: started("tongueAnimationState"),
swim_idle: started("swimIdleAnimationState"),
},
&animations,
),
Species::Rabbit => b_anim::rabbit(
p,
s,
&started("hopAnimationState"),
&started("idleHeadTiltAnimationState"),
&animations,
),
Species::Fox => b_anim::fox(
p,
s,
&b_anim::Fox {
crouching: flag("isCrouching"),
sleeping: flag("isSleeping"),
sitting: flag("isSitting"),
pouncing: flag("isPouncing"),
faceplanted: flag("isFaceplanted"),
head_roll_angle: num("headRollAngle"),
crouch_amount: num("crouchAmount"),
leg_motion_pos: 0.67,
},
&animations,
),
Species::Cat | Species::Ocelot => horizon_client::mobs::tame::feline(
p,
s,
&horizon_client::mobs::tame::Feline {
crouching: flag("isCrouching"),
sprinting: flag("isSprinting"),
sitting: flag("isSitting"),
lie_down: num("lieDownAmount"),
lie_down_tail: num("lieDownAmountTail"),
relax_one: num("relaxStateOneAmount"),
},
),
Species::Piglin | Species::PiglinBrute => {
use horizon_client::mobs::piglin::{PiglinPose, piglin_pose};
let pose = match case["armPose"].as_str() {
Some("DANCING") => PiglinPose::Dancing,
Some("ATTACKING_WITH_MELEE_WEAPON") => PiglinPose::MeleeWeapon,
Some("CROSSBOW_HOLD") => PiglinPose::CrossbowHold,
Some("CROSSBOW_CHARGE") => PiglinPose::CrossbowCharge,
Some("ADMIRING_ITEM") => PiglinPose::AdmiringItem,
_ => PiglinPose::Default,
};
piglin_pose(
p,
s,
pose,
num("maxCrossbowChageDuration"),
num("ticksUsingItem"),
);
}
Species::Evoker | Species::Pillager | Species::Vindicator => {
use horizon_client::mobs::illager::{ArmPose, anim_pose};
let pose = match case["armPose"].as_str() {
Some("CROSSED") => ArmPose::Crossed,
Some("ATTACKING") => ArmPose::Attacking,
Some("SPELLCASTING") => ArmPose::Spellcasting,
Some("BOW_AND_ARROW") => ArmPose::BowAndArrow,
Some("CROSSBOW_HOLD") => ArmPose::CrossbowHold,
Some("CROSSBOW_CHARGE") => ArmPose::CrossbowCharge,
Some("CELEBRATING") => ArmPose::Celebrating,
_ => ArmPose::Neutral,
};
mob.extra.passenger = flag("isRiding");
mob.extra.using_item = num("ticksUsingItem") as i32;
anim_pose(&mob, s, p, pose);
}
_ => anim::setup(&mob, s, p, &animations),
}
let mut parts = BTreeMap::new();
walk(&model, "", &poses, &mut parts);
out.push_str(&format!("{}\n", json!({"parts": parts})));
}
fs::write(&args[2], out)?;
Ok(())
}
@@ -0,0 +1,72 @@
//! Environment attributes for differential tests against vanilla
//! (tools/test_environment_render_parity.py): reads "dimension ticks rain
//! thunder biome" lines and prints the sampled sky state as JSON lines.
//!
//! usage: environment_fixture RESOURCES INPUT OUTPUT
use horizon_client::{
biome::Biomes,
environment::{Environment, apply_weather},
};
use std::{collections::HashMap, fmt::Write as _, fs, path::Path};
fn main() -> horizon_client::Result<()> {
let args: Vec<String> = std::env::args().collect();
let root = Path::new(
args.get(1)
.ok_or("usage: environment_fixture RESOURCES INPUT OUTPUT")?,
);
let input = fs::read_to_string(args.get(2).ok_or("missing INPUT")?)?;
let biomes = Biomes::load(root)?;
let mut environments: HashMap<String, Environment> = HashMap::new();
let mut out = String::new();
for line in input.lines() {
let f: Vec<&str> = line.split(' ').collect();
let dimension = f[0];
let environment =
match environments.entry(dimension.to_owned()) {
std::collections::hash_map::Entry::Occupied(e) => e.into_mut(),
std::collections::hash_map::Entry::Vacant(e) => e.insert(
Environment::load_dimension(root, dimension, dimension == "overworld")?,
),
};
let info = biomes.get(biomes.id(&format!("minecraft:{}", f[4])));
let mut sky = environment.sample(f[1].parse()?, info.sky, info.fog);
if dimension == "overworld" {
apply_weather(&mut sky, f[2].parse()?, f[3].parse()?);
}
let v3 = |c: [f32; 3]| format!("[{:?},{:?},{:?}]", c[0], c[1], c[2]);
let v4 = |c: [f32; 4]| format!("[{:?},{:?},{:?},{:?}]", c[0], c[1], c[2], c[3]);
let mut row = format!("{{\"case\":\"{line}\"");
let mut put = |name: &str, value: String| {
let _ = write!(row, ",\"minecraft:{name}\":{value}");
};
put("visual/sky_color", v3(sky.sky_color));
put("visual/fog_color", v3(sky.fog_color));
put("visual/cloud_color", v4(sky.cloud_color));
put("visual/sunrise_sunset_color", v4(sky.sunrise_color));
put(
"visual/sky_light_factor",
format!("{:?}", sky.sky_light_factor),
);
put("visual/sky_light_color", v3(sky.sky_light_color));
put("visual/block_light_tint", v3(sky.block_light_tint));
put("visual/ambient_light_color", v3(sky.ambient_light_color));
put("visual/sun_angle", format!("{:?}", sky.sun_angle));
put("visual/moon_angle", format!("{:?}", sky.moon_angle));
put("visual/star_angle", format!("{:?}", sky.star_angle));
put(
"visual/star_brightness",
format!("{:?}", sky.star_brightness),
);
put(
"gameplay/sky_light_level",
format!("{:?}", sky.sky_light_level * 15.0),
);
put("visual/fog_start_distance", format!("{:?}", sky.fog_start));
put("visual/fog_end_distance", format!("{:?}", sky.fog_end));
out.push_str(&row);
out.push_str("}\n");
}
fs::write(args.get(3).ok_or("missing OUTPUT")?, out)?;
Ok(())
}
+5 -11
View File
@@ -32,8 +32,9 @@ pub struct BiomeInfo {
pub foliage: u32,
pub dry_foliage: u32,
pub water: u32,
pub sky: u32,
pub fog: u32,
pub sky: Option<u32>,
/// The biome's own fog colour attribute; otherwise the dimension's applies.
pub fog: Option<u32>,
pub water_fog: u32,
}
pub struct Biomes {
@@ -77,13 +78,6 @@ impl Biomes {
let grass = colormap(root, "grass")?;
let foliage = colormap(root, "foliage")?;
let dry = colormap(root, "dry_foliage")?;
let dimension: Value = serde_json::from_slice(&fs::read(
root.join("data/minecraft/dimension_type/overworld.json"),
)?)?;
let default_fog =
color(&dimension["attributes"]["minecraft:visual/fog_color"]).unwrap_or(0xC0D8FF);
let default_sky =
color(&dimension["attributes"]["minecraft:visual/sky_color"]).unwrap_or(0x78A7FF);
let mut list = Vec::new();
let mut names: Vec<_> = fs::read_dir(root.join("data/minecraft/worldgen/biome"))?
.filter_map(|e| e.ok())
@@ -151,8 +145,8 @@ impl Biomes {
dry_foliage: color(&effects["dry_foliage_color"])
.unwrap_or_else(|| sample(&dry, temperature, downfall, 0x5D4930)),
water: color(&effects["water_color"]).unwrap_or(0x3F76E4),
sky: color(&attributes["minecraft:visual/sky_color"]).unwrap_or(default_sky),
fog: color(&attributes["minecraft:visual/fog_color"]).unwrap_or(default_fog),
sky: color(&attributes["minecraft:visual/sky_color"]),
fog: color(&attributes["minecraft:visual/fog_color"]),
water_fog: color(&attributes["minecraft:visual/water_fog_color"])
.unwrap_or(0x050533),
name,
+21 -10
View File
@@ -229,7 +229,7 @@ impl Environment {
self.base.get(name).copied().unwrap_or([0.0, 0.0, 0.0, 1.0])
}
/// Sky state for a time of day, with the biome's sky and fog colours as base values.
pub fn sample(&self, ticks: i64, biome_sky: u32, biome_fog: u32) -> Sky {
pub fn sample(&self, ticks: i64, biome_sky: Option<u32>, biome_fog: Option<u32>) -> Sky {
let rgb = |c: u32| {
[
(c >> 16 & 255) as f32 / 255.0,
@@ -260,8 +260,14 @@ impl Environment {
.map_or(0.0, |t| t.sample(ticks, self.period)[0])
};
Sky {
sky_color: three(v("minecraft:visual/sky_color", rgb(biome_sky))),
fog_color: three(v("minecraft:visual/fog_color", rgb(biome_fog))),
sky_color: three(v(
"minecraft:visual/sky_color",
biome_sky.map_or_else(|| self.base("minecraft:visual/sky_color"), rgb),
)),
fog_color: three(v(
"minecraft:visual/fog_color",
biome_fog.map_or_else(|| self.base("minecraft:visual/fog_color"), rgb),
)),
sky_light_factor: scalar("minecraft:visual/sky_light_factor"),
sky_light_color: three(v(
"minecraft:visual/sky_light_color",
@@ -279,7 +285,10 @@ impl Environment {
.map_or([0.0; 4], |t| t.sample(ticks, self.period)),
cloud_color: v(
"minecraft:visual/cloud_color",
self.base("minecraft:visual/cloud_color"),
self.base
.get("minecraft:visual/cloud_color")
.copied()
.unwrap_or([0.0; 4]),
),
sky_light_level: scalar("minecraft:gameplay/sky_light_level") / 15.0,
fog_start: self
@@ -304,24 +313,26 @@ pub fn apply_weather(sky: &mut Sky, rain: f32, thunder: f32) {
std::array::from_fn(|i| a[i] + (b[i] - a[i]) * t)
};
let lerp = |t: f32, a: f32, b: f32| a + (b - a) * t;
let night = [0.48, 0.48, 1.0];
// Vanilla stores these colours as 8-bit ARGB (`ARGB.colorFromFloat` floors).
let q = |v: f32| (v * 255.0).floor() / 255.0;
let night = [q(0.48), q(0.48), 1.0];
// (level, sky gray (brightness, factor), fog multiplier, cloud gray, alpha, sunrise multiplier)
let layers = [
(
rain - thunder,
(0.6, 0.75),
[0.5, 0.5, 0.6],
[q(0.5), q(0.5), q(0.6)],
(0.24, 0.5),
0.3125,
[0.5, 0.5, 0.6],
[q(0.5), q(0.5), q(0.6)],
),
(
thunder,
(0.24, 0.94),
[0.25, 0.25, 0.3],
[q(0.25), q(0.25), q(0.3)],
(0.095, 0.94),
0.527_343_75,
[0.25, 0.25, 0.3],
[q(0.25), q(0.25), q(0.3)],
),
];
for (level, (sb, sf), fog, (cb, cf), alpha, sunrise) in layers {
@@ -347,7 +358,7 @@ pub fn apply_weather(sky: &mut Sky, rain: f32, thunder: f32) {
sky.sky_light_color = lerp3(
level,
sky.sky_light_color,
lerp3(alpha, sky.sky_light_color, night),
lerp3(q(alpha), sky.sky_light_color, night),
);
sky.sky_light_factor = lerp(
level,
+22
View File
@@ -68,8 +68,30 @@ pub struct FogState {
pub water_vision_time: i32,
/// `AtmosphericFogEnvironment.rainFogMultiplier`.
pub rain_fog_multiplier: f32,
/// `LightmapRenderStateExtractor.blockLightFlicker`.
pub block_light_flicker: f32,
flicker_seed: u64,
}
impl FogState {
fn next_float(&mut self) -> f32 {
// splitmix64: the vanilla source is unseeded `RandomSource.create()`.
self.flicker_seed = self.flicker_seed.wrapping_add(0x9E37_79B9_7F4A_7C15);
let mut z = self.flicker_seed;
z = (z ^ (z >> 30)).wrapping_mul(0xBF58_476D_1CE4_E5B9);
z = (z ^ (z >> 27)).wrapping_mul(0x94D0_49BB_1331_11EB);
((z ^ (z >> 31)) >> 40) as f32 / (1u32 << 24) as f32
}
/// `LightmapRenderStateExtractor.tick`: the torch light flickers.
pub fn tick_flicker(&mut self) {
let (a, b, c, d) = (
self.next_float(),
self.next_float(),
self.next_float(),
self.next_float(),
);
self.block_light_flicker += (a - b) * c * d * 0.1;
self.block_light_flicker *= 0.9;
}
/// `LocalPlayer.aiStep`: water vision ramps up while the eye is in water.
pub fn tick(&mut self, eye_in_water: bool) {
self.water_vision_time = if eye_in_water {
+42 -30
View File
@@ -34,6 +34,7 @@ mod game_mode;
mod ghasts;
mod golems;
mod growth;
mod health_hud;
mod jukebox;
mod lan;
mod lan_actions;
@@ -564,6 +565,7 @@ struct Game<'a> {
fps_frames: u64,
fps_at: Instant,
ticks: u64,
health_hud: health_hud::HealthHud,
error: Option<String>,
message: Option<(String, Instant)>,
save: Arc<SaveDir>,
@@ -3088,7 +3090,7 @@ impl Game<'_> {
let atlas = &self.res.atlas;
if !self.creative
&& !spectator
&& let Some(p) = &self.player
&& let Some(p) = &mut self.player
{
// Experience bar and hearts/food (Gui.renderPlayerHealth).
let saddled_mount = mounted
@@ -3124,33 +3126,37 @@ impl Game<'_> {
}
batch.text(atlas, &text, x, y, rgba(128, 255, 32, 255), false);
}
let health = p.health.health().ceil() as i32;
let top = h - 39.0;
for i in 0..10 {
let x = w / 2.0 - 91.0 + i as f32 * 8.0;
let y = if health <= 4 {
top + ((self.ticks + i as u64 * 7) % 3) as f32 - 1.0
} else {
top
};
batch.sprite(atlas, "gui/sprites/hud/heart/container", x, y);
let v = health - i * 2;
if v >= 2 {
batch.sprite(atlas, "gui/sprites/hud/heart/full", x, y);
} else if v == 1 {
batch.sprite(atlas, "gui/sprites/hud/heart/half", x, y);
}
}
let food = p.health.food.food;
for i in (0..10).filter(|_| !mounted) {
let x = w / 2.0 + 91.0 - i as f32 * 8.0 - 9.0;
batch.sprite(atlas, "gui/sprites/hud/food_empty", x, top);
let v = food - i * 2;
if v >= 2 {
batch.sprite(atlas, "gui/sprites/hud/food_full", x, top);
} else if v == 1 {
batch.sprite(atlas, "gui/sprites/hud/food_half", x, top);
}
let effects = &self.potions.effects;
let kind = if effects.get("poison").is_some() {
health_hud::HeartKind::Poisoned
} else if effects.get("wither").is_some() {
health_hud::HeartKind::Withered
} else {
health_hud::HeartKind::Normal
};
let inputs = health_hud::HealthInputs {
tick: self.ticks,
health: p.health.health(),
max_health: p.attribute("minecraft:max_health").unwrap_or(20.0) as f32,
absorption: p.health.absorption(),
armor: p
.attribute("minecraft:armor")
.or_else(|_| p.attribute("armor"))
.unwrap_or(0.0) as i32,
food: p.health.food.food,
saturation: p.health.food.saturation,
kind,
regeneration: effects.get("regeneration").is_some(),
hunger: effects.get("hunger").is_some(),
hardcore: self.level.hardcore,
damage_cooldown: p.health.hurt.cooldown > 0,
show_food: !mounted,
};
for (name, x, y) in
self.health_hud
.layout(&inputs, w as i32, h as i32, std::time::Instant::now())
{
batch.sprite(atlas, &name, x as f32, y as f32);
}
}
if self.debug {
@@ -4647,10 +4653,13 @@ impl Game<'_> {
return 11;
}
if self.dim == Dim::End {
let sky = self.res.end_environment.sample(self.world.day_time, 0, 0);
let sky = self
.res
.end_environment
.sample(self.world.day_time, None, None);
return (15.0 - 15.0 * sky.sky_light_level).round() as i32;
}
let mut sky = self.res.environment.sample(self.world.day_time, 0, 0);
let mut sky = self.res.environment.sample(self.world.day_time, None, None);
let (rain, thunder) = self.world.weather.levels(1.0);
horizon_client::environment::apply_weather(&mut sky, rain, thunder);
// Level.updateSkyBrightness: darkening from the sky light level.
@@ -7481,6 +7490,8 @@ impl Game<'_> {
game_time: self.world.game_time as f32,
ticks: self.ticks,
darkness: self.darkness_lighting(alpha as f32),
night_vision: self.night_vision_intensity(),
block_flicker: self.res.fog.state.block_light_flicker,
};
self.renderer.as_mut().ok_or("renderer")?.render(&frame)
}
@@ -8402,6 +8413,7 @@ pub fn run() -> Result<()> {
screen: Screen::Playing,
window: None,
renderer: None,
health_hud: health_hud::HealthHud::default(),
started: now,
previous: now,
last_input: now,
@@ -0,0 +1,226 @@
//! `Hud.extractPlayerHealth`: armour, hearts, food. The layout is computed as
//! a list of sprites so it can be tested without drawing.
use std::time::Instant;
/// `java.util.Random`, for the HUD's per-tick jitter.
pub(super) struct JavaRandom(i64);
impl JavaRandom {
pub fn new(seed: i64) -> Self {
Self((seed ^ 0x5_DEEC_E66D) & ((1 << 48) - 1))
}
fn next(&mut self, bits: u32) -> i32 {
self.0 = (self.0.wrapping_mul(0x5_DEEC_E66D).wrapping_add(0xB)) & ((1 << 48) - 1);
(self.0 >> (48 - bits)) as i32
}
pub fn next_int(&mut self, bound: i32) -> i32 {
let mut r = self.next(31);
let m = bound - 1;
if bound & m == 0 {
return ((i64::from(bound) * i64::from(r)) >> 31) as i32;
}
let mut u = r;
loop {
r = u % bound;
if u.wrapping_sub(r).wrapping_add(m) >= 0 {
return r;
}
u = self.next(31);
}
}
}
#[derive(Clone, Copy, PartialEq, Eq, Debug)]
pub(super) enum HeartKind {
Normal,
Poisoned,
Withered,
Absorbing,
}
impl HeartKind {
fn prefix(self) -> &'static str {
match self {
Self::Normal => "",
Self::Poisoned => "poisoned_",
Self::Withered => "withered_",
Self::Absorbing => "absorbing_",
}
}
}
/// State kept between frames (`Hud.lastHealth`, `displayHealth`, ...).
pub(super) struct HealthHud {
last_health: i32,
display_health: i32,
last_health_time: Instant,
health_blink_time: i64,
}
impl Default for HealthHud {
fn default() -> Self {
Self {
last_health: 0,
display_health: 0,
last_health_time: Instant::now(),
health_blink_time: 0,
}
}
}
pub(super) struct HealthInputs {
pub tick: u64,
pub health: f32,
pub max_health: f32,
pub absorption: f32,
pub armor: i32,
pub food: i32,
pub saturation: f32,
pub kind: HeartKind,
pub regeneration: bool,
pub hunger: bool,
pub hardcore: bool,
/// `damageCooldownTime > 0`.
pub damage_cooldown: bool,
/// A mount with its own hearts replaces the food bar.
pub show_food: bool,
}
fn heart_sprite(kind: HeartKind, hardcore: bool, half: bool, blink: bool) -> String {
let (hc, h) = (
if hardcore { "hardcore_" } else { "" },
if half { "half" } else { "full" },
);
let b = if blink { "_blinking" } else { "" };
format!("gui/sprites/hud/heart/{}{hc}{h}{b}", kind.prefix())
}
impl HealthHud {
/// Sprites (name, x, y) in draw order for a screen of `w` x `h` GUI pixels.
pub fn layout(
&mut self,
i: &HealthInputs,
w: i32,
h: i32,
now: Instant,
) -> Vec<(String, i32, i32)> {
let mut out = Vec::new();
let tick = i64::try_from(i.tick).unwrap_or(i64::MAX);
let current = i.health.ceil() as i32;
let blink = self.health_blink_time > tick && (self.health_blink_time - tick) / 3 % 2 == 1;
if current < self.last_health && i.damage_cooldown {
self.last_health_time = now;
self.health_blink_time = tick + 20;
} else if current > self.last_health && i.damage_cooldown {
self.last_health_time = now;
self.health_blink_time = tick + 10;
}
if now.duration_since(self.last_health_time).as_millis() > 1000 {
self.display_health = current;
self.last_health_time = now;
}
self.last_health = current;
let old = self.display_health;
let mut random = JavaRandom::new(i64::from((i.tick as i32).wrapping_mul(312_871)));
let (x_left, x_right, y_base) = (w / 2 - 91, w / 2 + 91, h - 39);
let max_health = i.max_health.max(old.max(current) as f32);
let absorption = i.absorption.ceil() as i32;
let rows = ((max_health + absorption as f32) / 2.0 / 10.0).ceil() as i32;
let row_height = (10 - (rows - 2)).max(3);
let offset_index = if i.regeneration {
(i.tick as i32).rem_euclid((max_health + 5.0).ceil() as i32)
} else {
-1
};
if i.armor > 0 {
let y = y_base - (rows - 1) * row_height - 10;
for n in 0..10 {
let name = match (n * 2 + 1).cmp(&i.armor) {
std::cmp::Ordering::Less => "armor_full",
std::cmp::Ordering::Equal => "armor_half",
std::cmp::Ordering::Greater => "armor_empty",
};
out.push((format!("gui/sprites/hud/{name}"), x_left + n * 8, y));
}
}
let containers = (max_health / 2.0).ceil() as i32;
let absorb_containers = (absorption as f32 / 2.0).ceil() as i32;
let container = |hardcore: bool, blink: bool| {
format!(
"gui/sprites/hud/heart/container{}{}",
if hardcore { "_hardcore" } else { "" },
if blink { "_blinking" } else { "" }
)
};
for c in (0..containers + absorb_containers).rev() {
let (row, column) = (c / 10, c % 10);
let x = x_left + column * 8;
let mut y = y_base - row * row_height;
if current + absorption <= 4 {
y += random.next_int(2);
}
if c < containers && c == offset_index {
y -= 2;
}
out.push((container(i.hardcore, blink), x, y));
let halves = c * 2;
if c >= containers {
let ah = halves - containers * 2;
if ah < absorption {
let kind = if i.kind == HeartKind::Withered {
i.kind
} else {
HeartKind::Absorbing
};
out.push((
heart_sprite(kind, i.hardcore, ah + 1 == absorption, false),
x,
y,
));
}
}
if blink && halves < old {
out.push((
heart_sprite(i.kind, i.hardcore, halves + 1 == old, true),
x,
y,
));
}
if halves < current {
out.push((
heart_sprite(i.kind, i.hardcore, halves + 1 == current, false),
x,
y,
));
}
}
if i.show_food {
let suffix = if i.hunger { "_hunger" } else { "" };
for n in 0..10 {
let mut y = y_base;
if i.saturation <= 0.0 && (i.tick as i32).rem_euclid(i.food * 3 + 1) == 0 {
y += random.next_int(3) - 1;
}
let x = x_right - n * 8 - 9;
out.push((format!("gui/sprites/hud/food_empty{suffix}"), x, y));
if n * 2 + 1 < i.food {
out.push((format!("gui/sprites/hud/food_full{suffix}"), x, y));
}
if n * 2 + 1 == i.food {
out.push((format!("gui/sprites/hud/food_half{suffix}"), x, y));
}
}
}
out
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn java_random_matches_reference() {
// new Random(42).nextInt(10) sequence: 0, 3, 8, 4, 0.
let mut r = JavaRandom::new(42);
let v: Vec<i32> = (0..5).map(|_| r.next_int(10)).collect();
assert_eq!(v, [0, 3, 8, 4, 0]);
}
}
@@ -172,6 +172,7 @@ impl Game<'_> {
lightmap_brightness(if self.dim == Dim::Nether { 0.1 } else { 0.0 }, raw)
}
pub(super) fn tick_particles(&mut self) {
self.res.fog.state.tick_flicker();
let eye = self.eye_position();
if let Some(e) = eye {
let brightness = self.eye_brightness(e);
+23
View File
@@ -1094,6 +1094,29 @@ impl Game<'_> {
(modifier, pulse.max(0.0))
}
/// `LightmapRenderStateExtractor`: the night vision effect's intensity
/// (`GameRenderer.nightVisionScale`), or conduit power's water vision.
pub(super) fn night_vision_intensity(&self) -> f32 {
use horizon_client::fog::FogType;
if let Some(e) = self.potions.effects.get("night_vision") {
// MobEffectInstance.endsWithin(200); -1 is infinite.
return if e.duration < 0 || e.duration > 200 {
1.0
} else {
0.7 + (e.duration as f32 * std::f32::consts::PI * 0.2).sin() * 0.3
};
}
if self.potions.effects.get("conduit_power").is_some()
&& let Some(eye) = self.eye_position()
{
let in_water =
horizon_client::fog::fog_type(&self.world, &self.res.facts, eye, self.forward())
== FogType::Water;
return self.res.fog.state.water_vision(in_water);
}
0.0
}
/// `Warden.applyDarknessAround` / `MobEffectUtil.addEffectToPlayersAround`.
pub(super) fn apply_darkness(&mut self, at: [f64; 3], radius: f64) {
if self.creative || self.spectator() {
+18 -3
View File
@@ -80,6 +80,10 @@ pub struct Frame<'a> {
/// The darkness effect on the lightmap: the brightness it takes off the
/// gamma option and the pulsing scale subtracted from the light.
pub darkness: (f32, f32),
/// Night vision (or conduit water vision) intensity on the lightmap.
pub night_vision: f32,
/// Torch flicker added to the block light factor of 1.4.
pub block_flicker: f32,
}
pub struct Renderer {
instance: wgpu::Instance,
@@ -1082,7 +1086,14 @@ impl Renderer {
* bob
* Mat4::look_to_rh(Vec3::ZERO, forward, Vec3::Y)
}
fn update_lightmap(&self, sky: &Sky, darkness: f32, gamma: f32) {
fn update_lightmap(
&self,
sky: &Sky,
darkness: f32,
gamma: f32,
night_vision: f32,
flicker: f32,
) {
// lightmap.fsh: per (block, sky) level.
let brightness = |level: f32| level / (4.0 - 3.0 * level);
let mut pixels = [0u8; 16 * 16 * 4];
@@ -1090,9 +1101,11 @@ impl Renderer {
for b in 0..16 {
let block_level = b as f32 / 15.0;
let sky_level = s as f32 / 15.0;
let block_brightness = brightness(block_level) * 1.4;
let block_brightness = brightness(block_level) * (1.4 + flicker);
let sky_brightness = brightness(sky_level) * sky.sky_light_factor;
let mut color = Vec3::from(sky.ambient_light_color);
// NightVisionColor defaults to 0x999999.
let mut color =
Vec3::from(sky.ambient_light_color).max(Vec3::splat(0.6 * night_vision));
color += Vec3::from(sky.sky_light_color) * sky_brightness;
let parabolic = (2.0 * block_level - 1.0).powi(2);
let block_color = Vec3::from(sky.block_light_tint).lerp(Vec3::ONE, 0.9 * parabolic);
@@ -1198,6 +1211,8 @@ impl Renderer {
&frame.sky,
frame.darkness.1,
(self.gamma - frame.darkness.0).max(0.0),
frame.night_vision,
frame.block_flicker,
);
let view_proj = self.view_projection(frame);
let aspect = self.config.width as f32 / self.config.height.max(1) as f32;
+1
View File
@@ -9,6 +9,7 @@ pub mod ai;
pub mod allay;
pub mod anim;
pub mod aquatic;
pub mod body_anim;
pub mod brain;
pub mod breeze;
pub mod camel;
+10 -8
View File
@@ -8,6 +8,7 @@ use super::{
goals::{Cx, Goal, LookAtPlayer, MOVE, Panic, RandomLookAround, Stroll, goal_clone},
nav::NavKind,
};
use horizon_core::geometry::trig::Mth;
// Allay state: `main_hand` the held item, `ints[1]` how many it carries,
// `tame` a liked player, `point` the wanted item (set by the game),
@@ -15,8 +16,8 @@ use super::{
// pickup cooldown, `flag` dancing with `ints[4]` the dance clock,
// `egg_time` the duplication cooldown. AnimState slots: holding (0),
// spinning (1).
const HOLD: usize = 0;
const SPIN: usize = 1;
pub const HOLD: usize = 0;
pub const SPIN: usize = 1;
pub fn register(m: &mut Mob) {
m.ai.mov.kind = MoveKind::Flying {
@@ -151,22 +152,22 @@ pub fn anim(m: &Mob, s: &State, p: &mut Poses) {
use std::f32::consts::PI;
let (speed, pos) = (s.speed, s.pos);
let flap_speed = (s.age * 20.0).to_radians() + pos;
let flap = flap_speed.cos() * PI * 0.15 + speed;
let flap = flap_speed.mcos() * PI * 0.15 + speed;
let idle_bob = (s.age * 9.0).to_radians();
let flying = (speed / 0.3).min(1.0);
let idle = 1.0 - flying;
let hold = m.anim.lerp(HOLD, s.partial) / 5.0;
if m.extra.flag {
let dance = (s.age * 8.0).to_radians() + speed;
let freq = dance.cos() * 16f32.to_radians();
let freq = dance.mcos() * 16f32.to_radians();
let spin = m.anim.lerp(SPIN, s.partial) / 15.0;
let spinning = (m.extra.ints[4] as f32 % 55.0) < 15.0;
if spinning {
p.yrot("root", PI * 4.0 * spin);
}
p.zrot("root", freq * (1.0 - spin));
p.yrot("head", dance.cos() * 30f32.to_radians() * (1.0 - spin));
p.zrot("head", dance.cos() * 14f32.to_radians() * (1.0 - spin));
p.yrot("head", dance.mcos() * 30f32.to_radians() * (1.0 - spin));
p.zrot("head", dance.mcos() * 14f32.to_radians() * (1.0 - spin));
} else {
p.xrot("head", s.x_rot.to_radians());
p.yrot("head", s.y_rot.to_radians());
@@ -177,11 +178,12 @@ pub fn anim(m: &Mob, s: &State, p: &mut Poses) {
p.yrot("left_wing", PI / 4.0 - flap);
p.xrot("body", flying * PI / 4.0);
let arm_x = hold * (-PI / 3.0 + (-1.134_464 + PI / 3.0) * flying);
p.get("root")[1] += idle_bob.cos() * 0.25 * idle;
// `(float) Math.cos`: the exact function, not `Mth.cos`.
p.get("root")[1] += (f64::from(idle_bob).cos() as f32) * 0.25 * idle;
p.xrot("right_arm", arm_x);
p.xrot("left_arm", arm_x);
let arm_bob = idle * (1.0 - hold);
let amount = 0.436_332_32 - (idle_bob + PI * 1.5).cos() * PI * 0.075 * arm_bob;
let amount = 0.436_332_32 - (idle_bob + PI * 1.5).mcos() * PI * 0.075 * arm_bob;
p.zrot("left_arm", -amount);
p.zrot("right_arm", amount);
p.yrot("right_arm", 0.279_252_68 * hold);
+231 -145
View File
@@ -2,6 +2,7 @@
//! (quadrupeds, humanoids, creepers, spiders, chickens...) applied to a map of
//! part poses before the model is drawn.
use super::{Mob, Part, keyframes::AnimationState, living::wrap};
use horizon_core::geometry::trig::Mth;
use std::collections::HashMap;
use std::f32::consts::PI;
@@ -102,6 +103,10 @@ impl AnimState {
pub struct Poses {
map: HashMap<String, [f32; 9]>,
dummy: [f32; 9],
/// Parts with `skipDraw` set: their own cubes are not drawn, children are.
skipped: std::collections::HashSet<String>,
/// Parts with `visible` cleared: neither they nor their children draw.
hidden: std::collections::HashSet<String>,
}
impl Poses {
pub fn new(model: &Part) -> Self {
@@ -116,6 +121,8 @@ impl Poses {
Self {
map,
dummy: [0.0; 9],
skipped: Default::default(),
hidden: Default::default(),
}
}
pub fn get(&mut self, name: &str) -> &mut [f32; 9] {
@@ -127,6 +134,12 @@ impl Poses {
pub fn pose(&self, part: &Part) -> [f32; 9] {
self.map.get(&part.name).copied().unwrap_or(part.pose)
}
pub fn skip_draw(&mut self, name: &str) {
self.skipped.insert(name.to_owned());
}
pub fn skips(&self, part: &Part) -> bool {
self.skipped.contains(&part.name)
}
pub fn has(&self, name: &str) -> bool {
self.map.contains_key(name)
}
@@ -139,14 +152,17 @@ impl Poses {
pub fn zrot(&mut self, n: &str, v: f32) {
self.get(n)[5] = v;
}
/// `ModelPart.visible = v`; a hidden part and its children do not draw.
pub fn visible(&mut self, n: &str, v: bool) {
if !v {
let p = self.get(n);
p[6] = 0.0;
p[7] = 0.0;
p[8] = 0.0;
if v {
self.hidden.remove(n);
} else if self.map.contains_key(n) {
self.hidden.insert(n.to_owned());
}
}
pub fn is_hidden(&self, part: &Part) -> bool {
self.hidden.contains(&part.name)
}
}
/// The LivingEntityRenderState values setupAnim reads.
#[derive(Clone, Copy, Debug)]
@@ -198,18 +214,18 @@ fn head(p: &mut Poses, s: &State) {
pub(super) fn quadruped(p: &mut Poses, s: &State) {
head(p, s);
let (pos, sp) = (s.pos, s.speed);
p.xrot("right_hind_leg", (pos * 0.6662).cos() * 1.4 * sp);
p.xrot("left_hind_leg", (pos * 0.6662 + PI).cos() * 1.4 * sp);
p.xrot("right_front_leg", (pos * 0.6662 + PI).cos() * 1.4 * sp);
p.xrot("left_front_leg", (pos * 0.6662).cos() * 1.4 * sp);
p.xrot("right_hind_leg", (pos * 0.6662).mcos() * 1.4 * sp);
p.xrot("left_hind_leg", (pos * 0.6662 + PI).mcos() * 1.4 * sp);
p.xrot("right_front_leg", (pos * 0.6662 + PI).mcos() * 1.4 * sp);
p.xrot("left_front_leg", (pos * 0.6662).mcos() * 1.4 * sp);
}
/// AnimationUtils.bobModelPart
fn bob(p: &mut Poses, n: &str, age: f32, scale: f32) {
let q = p.get(n);
q[5] += scale * ((age * 0.09).cos() * 0.05 + 0.05);
q[3] += scale * ((age * 0.067).sin() * 0.05);
q[5] += scale * ((age * 0.09).mcos() * 0.05 + 0.05);
q[3] += scale * ((age * 0.067).msin() * 0.05);
}
#[derive(Clone, Copy, PartialEq, Eq)]
#[derive(Clone, Copy, PartialEq, Eq, Debug)]
pub enum ArmPose {
Empty,
Item,
@@ -217,118 +233,196 @@ pub enum ArmPose {
CrossbowHold,
CrossbowCharge,
}
/// HumanoidModel.setupAnim holding an item or not (piglins).
pub fn humanoid_item(p: &mut Poses, s: &State, holding: bool) {
let right = if holding {
ArmPose::Item
} else {
ArmPose::Empty
};
humanoid(p, s, right, ArmPose::Empty, None, holding);
/// HumanoidModel.setupAnim for piglins: `PiglinModel` poses the arms itself.
pub fn humanoid_item(p: &mut Poses, s: &State, _holding: bool) {
humanoid(p, s, &Hum::new(ArmPose::Empty, ArmPose::Empty));
}
/// HumanoidModel.setupAnim with empty hands (endermen).
pub fn humanoid_pub(p: &mut Poses, s: &State, _m: &Mob) {
humanoid(p, s, ArmPose::Empty, ArmPose::Empty, None, false);
humanoid(p, s, &Hum::new(ArmPose::Empty, ArmPose::Empty));
}
/// HumanoidModel.setupAnim up to (and including) the attack animation hook.
fn humanoid(
p: &mut Poses,
s: &State,
right: ArmPose,
left: ArmPose,
zombie: Option<bool>,
holding: bool,
) {
/// `AnimationUtils.swingWeaponDown` with the right arm as the main arm.
pub(super) fn swing_weapon_down(p: &mut Poses, swing: f32, age: f32) {
let attack2 = (swing * PI).msin();
let attack = ((1.0 - (1.0 - swing) * (1.0 - swing)) * PI).msin();
p.zrot("right_arm", 0.0);
p.zrot("left_arm", 0.0);
p.yrot("right_arm", PI / 20.0);
p.yrot("left_arm", -PI / 20.0);
p.xrot("right_arm", -1.884_955_8 + (age * 0.09).mcos() * 0.15);
p.xrot("left_arm", -0.0 + (age * 0.19).mcos() * 0.5);
p.get("right_arm")[3] += attack2 * 2.2 - attack * 0.4;
p.get("left_arm")[3] += attack2 * 1.2 - attack * 0.4;
bob(p, "right_arm", age, 1.0);
bob(p, "left_arm", age, -1.0);
}
/// What `HumanoidModel.setupAnim` reads besides the walk and head inputs.
#[derive(Clone, Copy, Debug)]
pub struct Hum {
pub right: ArmPose,
pub left: ArmPose,
pub crouching: bool,
pub passenger: bool,
/// `Some(aggressive)` for `ZombieModel`-style `animateZombieArms`.
pub zombie: Option<bool>,
/// The main hand holds something (`getMainHandItemStack() != EMPTY`).
pub holding: bool,
/// `maxCrossbowChargeDuration`, `ticksUsingItem`.
pub charge: (f32, f32),
/// `PiglinModel.setupAttackAnimation`: swing a held weapon down.
pub weapon_swing: bool,
}
impl Hum {
pub fn new(right: ArmPose, left: ArmPose) -> Self {
Self {
right,
left,
crouching: false,
passenger: false,
zombie: None,
holding: false,
charge: (0.0, 0.0),
weapon_swing: false,
}
}
}
impl ArmPose {
fn two_handed(self) -> bool {
matches!(self, Self::Bow | Self::CrossbowHold | Self::CrossbowCharge)
}
fn affects_offhand(self) -> bool {
self.two_handed()
}
}
/// `AnimationUtils.animateCrossbowHold`.
fn crossbow_hold(p: &mut Poses, hx: f32, hy: f32, in_right: bool) {
let (hold, shoot) = if in_right {
("right_arm", "left_arm")
} else {
("left_arm", "right_arm")
};
p.yrot(hold, if in_right { -0.3 } else { 0.3 } + hy);
p.yrot(shoot, if in_right { 0.6 } else { -0.6 } + hy);
p.xrot(hold, -PI / 2.0 + hx + 0.1);
p.xrot(shoot, -1.5 + hx);
}
/// `AnimationUtils.animateCrossbowCharge`.
fn crossbow_charge(p: &mut Poses, max: f32, ticks: f32, in_right: bool) {
let (hold, pull) = if in_right {
("right_arm", "left_arm")
} else {
("left_arm", "right_arm")
};
p.yrot(hold, if in_right { -0.8 } else { 0.8 });
p.xrot(hold, -0.970_796_35);
p.xrot(pull, -0.970_796_35);
let use_ticks = ticks.clamp(0.0, max);
let alpha = use_ticks / max;
let lerp = |a: f32, p0: f32, p1: f32| p0 + a * (p1 - p0);
p.yrot(
pull,
lerp(alpha, 0.4, 0.85) * if in_right { 1.0 } else { -1.0 },
);
let x = lerp(alpha, p.get(pull)[3], -PI / 2.0);
p.xrot(pull, x);
}
/// `HumanoidModel.poseRightArm` / `poseLeftArm`.
fn pose_arm(p: &mut Poses, pose: ArmPose, right: bool, h: &Hum) {
let arm = if right { "right_arm" } else { "left_arm" };
let (hx, hy) = (p.get("head")[3], p.get("head")[4]);
match pose {
ArmPose::Empty => p.yrot(arm, 0.0),
ArmPose::Item => {
let x = p.get(arm)[3];
p.xrot(arm, x * 0.5 - PI / 10.0);
p.yrot(arm, 0.0);
}
ArmPose::Bow => {
p.yrot("right_arm", -0.1 + hy - if right { 0.0 } else { 0.4 });
p.yrot("left_arm", 0.1 + hy + if right { 0.4 } else { 0.0 });
p.xrot("right_arm", -PI / 2.0 + hx);
p.xrot("left_arm", -PI / 2.0 + hx);
}
ArmPose::CrossbowHold => crossbow_hold(p, hx, hy, right),
ArmPose::CrossbowCharge => crossbow_charge(p, h.charge.0, h.charge.1, right),
}
}
/// `HumanoidModel.setupAnim` (and `ZombieModel.setupAttackAnimation`).
pub(super) fn humanoid(p: &mut Poses, s: &State, h: &Hum) {
head(p, s);
let (pos, sp) = (s.pos, s.speed);
p.xrot("right_arm", (pos * 0.6662 + PI).cos() * 2.0 * sp * 0.5);
p.xrot("left_arm", (pos * 0.6662).cos() * 2.0 * sp * 0.5);
p.xrot("right_leg", (pos * 0.6662).cos() * 1.4 * sp);
p.xrot("left_leg", (pos * 0.6662 + PI).cos() * 1.4 * sp);
p.xrot("right_arm", (pos * 0.6662 + PI).mcos() * 2.0 * sp * 0.5);
p.xrot("left_arm", (pos * 0.6662).mcos() * 2.0 * sp * 0.5);
p.xrot("right_leg", (pos * 0.6662).mcos() * 1.4 * sp);
p.xrot("left_leg", (pos * 0.6662 + PI).mcos() * 1.4 * sp);
p.yrot("right_leg", 0.005);
p.yrot("left_leg", -0.005);
p.zrot("right_leg", 0.005);
p.zrot("left_leg", -0.005);
let (hx, hy) = (p.get("head")[3], p.get("head")[4]);
for (arm, pose) in [("right_arm", right), ("left_arm", left)] {
match pose {
ArmPose::Empty => p.yrot(arm, 0.0),
ArmPose::Item => {
let x = p.get(arm)[3];
p.xrot(arm, x * 0.5 - PI / 10.0);
p.yrot(arm, 0.0);
}
ArmPose::Bow => {
let right_main = arm == "right_arm";
p.yrot("right_arm", -0.1 + hy - if right_main { 0.0 } else { 0.4 });
p.yrot("left_arm", 0.1 + hy + if right_main { 0.4 } else { 0.0 });
p.xrot("right_arm", -PI / 2.0 + hx);
p.xrot("left_arm", -PI / 2.0 + hx);
}
ArmPose::CrossbowHold => {
let r = arm == "right_arm";
let (hold, shoot) = if r {
("right_arm", "left_arm")
} else {
("left_arm", "right_arm")
};
p.yrot(hold, if r { -0.3 } else { 0.3 } + hy);
p.yrot(shoot, if r { 0.6 } else { -0.6 } + hy);
p.xrot(hold, -PI / 2.0 + hx + 0.1);
p.xrot(shoot, -1.5 + hx);
}
ArmPose::CrossbowCharge => {
let r = arm == "right_arm";
let (hold, pull) = if r {
("right_arm", "left_arm")
} else {
("left_arm", "right_arm")
};
p.yrot(hold, if r { -0.8 } else { 0.8 });
p.xrot(hold, -0.970_796_35);
p.xrot(pull, -0.970_796_35);
p.yrot(pull, 0.6 * if r { 1.0 } else { -1.0 });
p.xrot(pull, -PI / 2.0);
}
if h.passenger {
p.get("right_arm")[3] += -PI / 5.0;
p.get("left_arm")[3] += -PI / 5.0;
p.xrot("right_leg", -1.413_716_7);
p.yrot("right_leg", PI / 10.0);
p.zrot("right_leg", 0.078_539_82);
p.xrot("left_leg", -1.413_716_7);
p.yrot("left_leg", -PI / 10.0);
p.zrot("left_leg", -0.078_539_82);
}
// The main arm is the right one: the off-hand pose goes first unless it
// needs both hands.
if h.left.two_handed() {
pose_arm(p, h.right, true, h);
if !h.right.affects_offhand() {
pose_arm(p, h.left, false, h);
}
} else {
pose_arm(p, h.left, false, h);
if !h.left.affects_offhand() {
pose_arm(p, h.right, true, h);
}
}
// setupAttackAnimation (WHACK swing with the right arm).
let hx = p.get("head")[3];
let swing = s.swing;
if swing > 0.0 {
let body_y = (swing.sqrt() * PI * 2.0).sin() * 0.2;
if swing > 0.0 && h.weapon_swing {
swing_weapon_down(p, swing, s.age);
} else if swing > 0.0 {
let body_y = (swing.sqrt() * PI * 2.0).msin() * 0.2;
p.yrot("body", body_y);
let age_scale = if s.baby { 0.5 } else { 1.0 };
{
let r = p.get("right_arm");
r[2] = body_y.sin() * 5.0 * age_scale;
r[0] = -body_y.cos() * 5.0 * age_scale;
r[2] = body_y.msin() * 5.0 * age_scale;
r[0] = -body_y.mcos() * 5.0 * age_scale;
}
{
let l = p.get("left_arm");
l[2] = -body_y.sin() * 5.0 * age_scale;
l[0] = body_y.cos() * 5.0 * age_scale;
l[2] = -body_y.msin() * 5.0 * age_scale;
l[0] = body_y.mcos() * 5.0 * age_scale;
}
p.get("right_arm")[4] += body_y;
p.get("left_arm")[4] += body_y;
p.get("left_arm")[3] += body_y;
// Ease.outQuart
let eased = 1.0 - (1.0 - swing).powi(4);
let aa = (eased * PI).sin();
let bb = (swing * PI).sin() * -(hx - 0.7) * 0.75;
let aa = (eased * PI).msin();
let bb = (swing * PI).msin() * -(hx - 0.7) * 0.75;
let r = p.get("right_arm");
r[3] -= aa * 1.2 + bb;
r[4] += body_y * 2.0;
r[5] += (swing * PI).sin() * -0.4;
r[5] += (swing * PI).msin() * -0.4;
}
if let Some(aggressive) = zombie {
if let Some(aggressive) = h.zombie {
// AnimationUtils.animateZombieArms
let raise = !s.baby || !holding;
let raise = !s.baby || !h.holding;
let drop = if raise {
-PI / if aggressive { 1.5 } else { 2.25 }
} else {
0.0
};
let ym = if raise { 1.0 } else { -1.0 } * (swing * PI).sin();
let xm = ((1.0 - (1.0 - swing) * (1.0 - swing)) * PI).sin();
let ym = if raise { 1.0 } else { -1.0 } * (swing * PI).msin();
let xm = ((1.0 - (1.0 - swing) * (1.0 - swing)) * PI).msin();
let x = drop + ym * 1.2 - xm * 0.4;
let y = 0.1 - ym * 0.6;
p.xrot("right_arm", x);
@@ -338,6 +432,17 @@ fn humanoid(
p.yrot("left_arm", if raise { y } else { -y });
p.zrot("left_arm", 0.0);
}
if h.crouching {
p.xrot("body", 0.5);
p.get("right_arm")[3] += 0.4;
p.get("left_arm")[3] += 0.4;
p.get("right_leg")[2] += 4.0;
p.get("left_leg")[2] += 4.0;
p.get("head")[1] += 4.2;
p.get("body")[1] += 3.2;
p.get("left_arm")[1] += 3.2;
p.get("right_arm")[1] += 3.2;
}
bob(p, "right_arm", s.age, 1.0);
bob(p, "left_arm", s.age, -1.0);
}
@@ -348,6 +453,9 @@ pub fn setup(
p: &mut Poses,
w_anims: &HashMap<String, super::keyframes::Animation>,
) {
if super::body_anim::anim(m, s, p, w_anims) {
return;
}
match m.kind.anim {
Anim::Camel => super::camel::anim(m, s, p, w_anims),
Anim::Breeze => super::breeze::anim(m, s, p, w_anims),
@@ -377,7 +485,7 @@ pub fn setup(
};
let angle = if t > 4 && t <= 36 {
let f = ((t - 4) as f32 - partial) / 32.0;
PI / 5.0 + 0.219_911_49 * (f * 28.7).sin()
PI / 5.0 + 0.219_911_49 * (f * 28.7).msin()
} else if t > 0 {
PI / 5.0
} else {
@@ -391,9 +499,9 @@ pub fn setup(
let flap = m.anim.flap_o + (m.anim.flap - m.anim.flap_o) * s.partial;
let flap_speed =
m.anim.flap_speed_o + (m.anim.flap_speed - m.anim.flap_speed_o) * s.partial;
let angle = (flap.sin() + 1.0) * flap_speed;
p.xrot("right_leg", (s.pos * 0.6662).cos() * 1.4 * s.speed);
p.xrot("left_leg", (s.pos * 0.6662 + PI).cos() * 1.4 * s.speed);
let angle = (flap.msin() + 1.0) * flap_speed;
p.xrot("right_leg", (s.pos * 0.6662).mcos() * 1.4 * s.speed);
p.xrot("left_leg", (s.pos * 0.6662 + PI).mcos() * 1.4 * s.speed);
p.zrot("right_wing", angle);
p.zrot("left_wing", -angle);
if !s.baby {
@@ -405,57 +513,35 @@ pub fn setup(
| Anim::ZombieVillager
| Anim::ZombifiedPiglin
| Anim::Humanoid { zombie_arms: true } => {
let holding = m.extra.main_hand.is_some();
let right = if holding {
ArmPose::Item
} else {
ArmPose::Empty
};
humanoid(p, s, right, ArmPose::Empty, Some(m.ai.aggressive), holding);
let mut h = Hum::new(ArmPose::Empty, ArmPose::Empty);
h.zombie = Some(m.ai.aggressive);
h.holding = m.extra.main_hand.is_some();
h.crouching = m.extra.crouching;
h.passenger = m.extra.passenger;
humanoid(p, s, &h);
if m.kind.anim == Anim::ZombifiedPiglin {
super::piglin::ears(p, s);
}
}
Anim::Skeleton | Anim::Humanoid { zombie_arms: false } => {
let bow = m.extra.main_hand.as_deref() == Some("minecraft:bow");
let player = matches!(m.kind.anim, Anim::Humanoid { .. });
let right = if bow && m.ai.aggressive {
ArmPose::Bow
} else if m.extra.main_hand.is_some() {
} else if player && m.extra.main_hand.is_some() {
ArmPose::Item
} else {
ArmPose::Empty
};
humanoid(
p,
s,
right,
ArmPose::Empty,
None,
m.extra.main_hand.is_some(),
);
if m.extra.passenger {
// HumanoidModel.setupAnim: riding.
p.get("right_arm")[3] -= PI / 5.0;
p.get("left_arm")[3] -= PI / 5.0;
for (leg, side) in [("right_leg", 1.0), ("left_leg", -1.0)] {
p.xrot(leg, -1.413_716_7);
p.yrot(leg, side * PI / 10.0);
p.zrot(leg, side * 0.078_539_82);
}
}
if m.extra.crouching {
p.xrot("body", 0.5);
p.get("right_arm")[3] += 0.4;
p.get("left_arm")[3] += 0.4;
p.get("right_leg")[2] += 4.0;
p.get("left_leg")[2] += 4.0;
p.get("head")[1] += 4.2;
p.get("body")[1] += 3.2;
p.get("left_arm")[1] += 3.2;
p.get("right_arm")[1] += 3.2;
}
let mut h = Hum::new(right, ArmPose::Empty);
h.crouching = m.extra.crouching;
h.passenger = m.extra.passenger;
humanoid(p, s, &h);
if m.ai.aggressive && !bow {
// SkeletonModel melee pose.
let sw = s.swing;
let s2 = (sw * PI).sin();
let s1 = ((1.0 - (1.0 - sw) * (1.0 - sw)) * PI).sin();
let s2 = (sw * PI).msin();
let s1 = ((1.0 - (1.0 - sw) * (1.0 - sw)) * PI).msin();
p.zrot("right_arm", 0.0);
p.zrot("left_arm", 0.0);
p.yrot("right_arm", -(0.1 - s2 * 0.6));
@@ -483,37 +569,37 @@ pub fn setup(
// DonkeyModel: the chests show once fitted.
if !m.extra.chested {
for part in ["left_chest", "right_chest"] {
if p.has(part) {
let v = p.get(part);
v[6] = 0.0;
v[7] = 0.0;
v[8] = 0.0;
}
p.visible(part, false);
}
}
}
Anim::Hoglin => super::piglin::hoglin_anim(m, s, p),
Anim::Blaze => super::nether::blaze_anim(s, p),
Anim::Ghast => super::nether::ghast_anim(s, p),
Anim::Feline if m.species() == super::Species::Cat => super::tame::cat_anim(m, s, p),
Anim::Feline => super::tame::cat_anim(m, s, p),
Anim::Enderman => super::enderman::anim(m, s, p),
Anim::Slime | Anim::MagmaCube => super::cube::anim(m, s, p),
Anim::Creeper => {
head(p, s);
p.xrot("right_hind_leg", (s.pos * 0.6662).cos() * 1.4 * s.speed);
p.xrot("left_hind_leg", (s.pos * 0.6662 + PI).cos() * 1.4 * s.speed);
// CreeperModel binds its fields to the opposite-side parts, so the
// left formulas drive the right parts and the reverse.
p.xrot("left_hind_leg", (s.pos * 0.6662).mcos() * 1.4 * s.speed);
p.xrot(
"right_front_leg",
(s.pos * 0.6662 + PI).cos() * 1.4 * s.speed,
"right_hind_leg",
(s.pos * 0.6662 + PI).mcos() * 1.4 * s.speed,
);
p.xrot("left_front_leg", (s.pos * 0.6662).cos() * 1.4 * s.speed);
p.xrot(
"left_front_leg",
(s.pos * 0.6662 + PI).mcos() * 1.4 * s.speed,
);
p.xrot("right_front_leg", (s.pos * 0.6662).mcos() * 1.4 * s.speed);
}
Anim::Spider => {
head(p, s);
let pos = s.pos * 0.6662;
let sp = s.speed;
let swing = |o: f32| -((pos * 2.0 + o).cos() * 0.4) * sp;
let step = |o: f32| ((pos + o).sin() * 0.4).abs() * sp;
let swing = |o: f32| -((pos * 2.0 + o).mcos() * 0.4) * sp;
let step = |o: f32| ((pos + o).msin() * 0.4).abs() * sp;
let legs = [
("hind", 0.0f32, 0.0f32),
("middle_hind", PI, PI),
+16 -15
View File
@@ -12,12 +12,13 @@ use super::{
nav::NavKind,
};
use crate::blocks::Fluid;
use horizon_core::geometry::trig::Mth;
use horizon_core::{geometry::Vec3, random::RandomSource};
use std::f32::consts::PI;
// Squid animation slots in AnimState.v.
const TENTACLE_MOVEMENT: usize = 0;
const TENTACLE_ANGLE: usize = 1;
pub const TENTACLE_ANGLE: usize = 1;
const X_BODY_ROT: usize = 2;
const Z_BODY_ROT: usize = 3;
const TENTACLE_SPEED: usize = 4;
@@ -229,7 +230,7 @@ fn squid_ai_step(m: &mut Mob) {
if m.fluids.in_water {
if v[TENTACLE_MOVEMENT] < PI {
let scale = v[TENTACLE_MOVEMENT] / PI;
v[TENTACLE_ANGLE] = (scale * scale * PI).sin() * PI * 0.25;
v[TENTACLE_ANGLE] = (scale * scale * PI).msin() * PI * 0.25;
if scale > 0.75 {
let mv = m.extra.vector;
m.velocity = Vec3::new(mv[0], mv[1], mv[2]);
@@ -250,7 +251,7 @@ fn squid_ai_step(m: &mut Mob) {
v[Z_BODY_ROT] += PI * v[ROTATE_SPEED] * 1.5;
v[X_BODY_ROT] += (-(horizontal.atan2(mv.y) as f32).to_degrees() - v[X_BODY_ROT]) * 0.1;
} else {
v[TENTACLE_ANGLE] = v[TENTACLE_MOVEMENT].sin().abs() * PI * 0.25;
v[TENTACLE_ANGLE] = v[TENTACLE_MOVEMENT].msin().abs() * PI * 0.25;
let yd = m.velocity.y - m.kind.gravity;
m.velocity = Vec3::new(0.0, yd * 0.98, 0.0);
let v = &mut m.anim.v;
@@ -339,9 +340,9 @@ impl Goal for SquidRandomMovement {
let angle = m.random.next_float() * PI * 2.0;
let y = -0.1 + m.random.next_float() * 0.2;
m.extra.vector = [
f64::from(angle.cos() * 0.2),
f64::from(angle.mcos() * 0.2),
f64::from(y),
f64::from(angle.sin() * 0.2),
f64::from(angle.msin() * 0.2),
];
}
}
@@ -496,23 +497,23 @@ pub fn anim(m: &Mob, s: &State, p: &mut Poses) {
p.xrot(&format!("tentacle{i}"), angle);
}
}
S::Cod => p.yrot("tail_fin", -amp * 0.45 * (0.6 * s.age).sin()),
S::Cod => p.yrot("tail_fin", -amp * 0.45 * (0.6 * s.age).msin()),
// TadpoleModel: a stronger tail swing out of water.
S::Tadpole => {
let a = if m.fluids.in_water { 1.0 } else { 1.5 };
p.yrot("tail", -a * 0.25 * (0.3 * s.age).sin())
p.yrot("tail", -a * 0.25 * (0.3 * s.age).msin())
}
S::TropicalFish => p.yrot("tail", -amp * 0.45 * (0.6 * s.age).sin()),
S::TropicalFish => p.yrot("tail", -amp * 0.45 * (0.6 * s.age).msin()),
S::Salmon => {
let (a, k) = if m.fluids.in_water {
(1.0, 1.0)
} else {
(1.3, 1.7)
};
p.yrot("body_back", -a * 0.25 * (k * 0.6 * s.age).sin());
p.yrot("body_back", -a * 0.25 * (k * 0.6 * s.age).msin());
}
S::Pufferfish => {
let fin = 0.2 - 0.4 * (s.age * 0.2).sin();
let fin = 0.2 - 0.4 * (s.age * 0.2).msin();
if p.has("right_blue_fin") {
p.zrot("right_blue_fin", -fin);
p.zrot("left_blue_fin", fin);
@@ -526,9 +527,9 @@ pub fn anim(m: &Mob, s: &State, p: &mut Poses) {
p.yrot("body", s.y_rot.to_radians());
let moving = m.velocity.x * m.velocity.x + m.velocity.z * m.velocity.z > 1.0e-7;
if moving {
p.get("body")[3] += -0.05 - 0.05 * (s.age * 0.3).cos();
p.xrot("tail", -0.1 * (s.age * 0.3).cos());
p.xrot("tail_fin", -0.2 * (s.age * 0.3).cos());
p.get("body")[3] += -0.05 - 0.05 * (s.age * 0.3).mcos();
p.xrot("tail", -0.1 * (s.age * 0.3).mcos());
p.xrot("tail_fin", -0.2 * (s.age * 0.3).mcos());
}
}
_ => {}
@@ -565,7 +566,7 @@ pub fn rotations(m: &Mob, alpha: f32, body: f32) -> Option<glam::Mat4> {
(1.0, 1.0)
};
let mut t = glam::Mat4::from_rotation_y((180.0 - body).to_radians())
* glam::Mat4::from_rotation_y((a * 4.3 * (k * 0.6 * age).sin()).to_radians());
* glam::Mat4::from_rotation_y((a * 4.3 * (k * 0.6 * age).msin()).to_radians());
if !m.fluids.in_water {
let off = if m.species() == S::Cod {
glam::Vec3::new(0.1, 0.1, -0.1)
@@ -577,7 +578,7 @@ pub fn rotations(m: &Mob, alpha: f32, body: f32) -> Option<glam::Mat4> {
Some(t)
}
S::Pufferfish => Some(
glam::Mat4::from_translation(glam::Vec3::new(0.0, (age * 0.05).cos() * 0.08, 0.0))
glam::Mat4::from_translation(glam::Vec3::new(0.0, (age * 0.05).mcos() * 0.08, 0.0))
* glam::Mat4::from_rotation_y((180.0 - body).to_radians()),
),
_ => None,
File diff suppressed because it is too large Load Diff
+2 -1
View File
@@ -8,6 +8,7 @@ use super::{
Tempt, goal_clone,
},
};
use horizon_core::geometry::trig::Mth;
use horizon_core::random::RandomSource;
use std::collections::HashMap;
@@ -179,7 +180,7 @@ pub fn dash(m: &mut Mob, amount: f32, events: &mut Vec<MobEvent>) {
return;
}
let yaw = m.yaw.to_radians();
let (dx, dz) = (f64::from(-yaw.sin()), f64::from(yaw.cos()));
let (dx, dz) = (f64::from(-yaw.msin()), f64::from(yaw.mcos()));
let speed = m.movement_speed();
let a = f64::from(amount);
m.velocity.x += dx * 22.2222 * a * speed;
+8
View File
@@ -68,6 +68,14 @@ impl MobData {
data.entity_tags = crate::items::load_tags(root, "entity_type").unwrap_or_default();
data
}
/// Only the keyframe animation definitions of `mob-data.json`.
pub fn load_animations(root: &Path) -> HashMap<String, Animation> {
fs::read(root.join("mob-data.json"))
.ok()
.and_then(|b| serde_json::from_slice::<Value>(&b).ok())
.map(|v| Self::from_json(&v).animations)
.unwrap_or_default()
}
pub fn entity_has(&self, tag: &str, entity: &str) -> bool {
self.entity_tags
.get(tag)
+24 -11
View File
@@ -9,6 +9,7 @@ use super::{
Tempt, goal_clone,
},
};
use horizon_core::geometry::trig::Mth;
use horizon_core::random::RandomSource;
use std::f32::consts::PI;
@@ -24,9 +25,9 @@ pub const COLORS: [&str; 7] = [
pub const MARKINGS: [&str; 5] = ["", "white", "whitefield", "whitedots", "blackdots"];
// AnimState slots.
const EAT: usize = 0;
const STAND: usize = 1;
const MOUTH: usize = 2;
pub const EAT: usize = 0;
pub const STAND: usize = 1;
pub const MOUTH: usize = 2;
/// What a rider asks of its mount this tick.
#[derive(Clone, Copy, Debug, Default)]
@@ -180,7 +181,7 @@ fn boost_factor(m: &mut Mob) -> f32 {
m.extra.counter2 = 0;
return 1.0;
}
1.0 + 1.15 * (m.extra.counter as f32 / m.extra.counter2 as f32 * PI).sin()
1.0 + 1.15 * (m.extra.counter as f32 / m.extra.counter2 as f32 * PI).msin()
}
/// `AbstractHorse.MountPanicGoal`: only without a rider.
#[derive(Clone, Debug)]
@@ -381,7 +382,7 @@ pub fn ridden_step(m: &mut Mob) {
let impulse = m.extra.vector[0] as f32 * r.jump;
m.velocity.y = f64::from(impulse);
if forward > 0.0 {
let (s, c) = (m.yaw.to_radians().sin(), m.yaw.to_radians().cos());
let (s, c) = (m.yaw.to_radians().msin(), m.yaw.to_radians().mcos());
m.velocity.x += f64::from(-0.4 * s * r.jump);
m.velocity.z += f64::from(0.4 * c * r.jump);
}
@@ -506,19 +507,19 @@ pub fn anim(m: &Mob, s: &State, p: &mut Poses) {
let mut head_x = s.x_rot.to_radians();
let (speed, pos) = (s.speed, s.pos);
if speed > 0.2 {
head_x += (pos * 0.8).cos() * 0.15 * speed;
head_x += (pos * 0.8).mcos() * 0.15 * speed;
}
let eating = m.anim.lerp(EAT, s.partial);
let standing = m.anim.lerp(STAND, s.partial);
let istand = 1.0 - standing;
let feeding = m.anim.lerp(MOUTH, s.partial);
let in_water = if m.fluids.in_water { 0.2 } else { 1.0 };
let leg1 = (in_water * pos * 0.6662 + PI).cos();
let leg1 = (in_water * pos * 0.6662 + PI).mcos();
let leg_x = leg1 * 0.8 * speed;
let base = (1.0 - standing.max(eating)) * (PI / 6.0 + head_x + feeding * s.age.sin() * 0.05);
let base = (1.0 - standing.max(eating)) * (PI / 6.0 + head_x + feeding * s.age.msin() * 0.05);
p.xrot(
"head_parts",
standing * (PI / 12.0 + head_x) + eating * (2.181_661_6 + s.age.sin() * 0.05) + base,
standing * (PI / 12.0 + head_x) + eating * (2.181_661_6 + s.age.msin() * 0.05) + base,
);
p.yrot(
"head_parts",
@@ -551,7 +552,7 @@ pub fn anim(m: &Mob, s: &State, p: &mut Poses) {
rf[2] = z;
}
let stand = stand_angle * standing;
let bob = (s.age * 0.6 + PI).cos();
let bob = (s.age * 0.6 + PI).mcos();
let rleg = (stand_x_off + bob) * standing + leg_x * istand;
let lleg = (stand_x_off - bob) * standing - leg_x * istand;
p.xrot("left_hind_leg", stand - leg1 * 0.5 * speed * istand);
@@ -560,9 +561,10 @@ pub fn anim(m: &Mob, s: &State, p: &mut Poses) {
p.xrot("right_front_leg", lleg);
if baby && donkey {
let lerp = |t: f32, a: f32, b: f32| a + (b - a) * t;
// BabyDonkeyModel lerps the right leg from the left leg's new height.
let y = lerp(standing, p.get("left_hind_leg")[1], -0.3);
p.get("left_hind_leg")[1] = y;
p.get("right_hind_leg")[1] = y;
p.get("right_hind_leg")[1] = lerp(standing, y, -0.3);
}
let age = if baby { 0.5 } else { 1.0 };
p.xrot("tail", tail_off + PI / 6.0 + speed * 0.75);
@@ -572,4 +574,15 @@ pub fn anim(m: &Mob, s: &State, p: &mut Poses) {
t[2] += speed * 2.0 * age;
}
p.yrot("tail", 0.0);
if baby && donkey {
// BabyDonkeyModel overrides the state's pitch with -30 degrees and
// sets the head parts again.
let head_x = -30.0f32 * horizon_core::geometry::trig::DEG_TO_RAD;
let base =
(1.0 - standing.max(eating)) * (PI / 6.0 + head_x + feeding * s.age.msin() * 0.05);
p.xrot(
"head_parts",
standing * (PI / 12.0 + head_x) + eating * (PI / 2.0 + s.age.msin() * 0.05) + base,
);
}
}
+11 -10
View File
@@ -12,15 +12,16 @@ use super::{
nav::NavKind,
path::PathType,
};
use horizon_core::geometry::trig::Mth;
use horizon_core::{geometry::Vec3, random::RandomSource};
use std::f32::consts::PI;
// Guardian state: `flag` an active beam target (DATA_ID_ATTACK_TARGET),
// `flag2` moving (DATA_ID_MOVING), `counter2` the client attack time.
// AnimState slots: tail animation, its speed, spikes animation.
const TAIL: usize = 0;
pub const TAIL: usize = 0;
const TAIL_SPEED: usize = 1;
const SPIKES: usize = 2;
pub const SPIKES: usize = 2;
const EYE_X: usize = 3;
const EYE_Y: usize = 4;
@@ -166,8 +167,8 @@ pub fn move_control(m: &mut Mob) {
let t = f64::from(m.age as i32 + m.id as i32);
let push = (t * 0.5).sin() * 0.05;
let (cos, sin) = (
f64::from(m.yaw.to_radians().cos()),
f64::from(m.yaw.to_radians().sin()),
f64::from(m.yaw.to_radians().mcos()),
f64::from(m.yaw.to_radians().msin()),
);
let y_push = (t * 0.75).sin() * 0.05;
m.velocity = m.velocity.add_vector(Vec3::new(
@@ -277,7 +278,7 @@ pub fn ai_step(m: &mut Mob, w: &MobWorld, events: &mut Vec<MobEvent>) {
m.anim.v[EYE_Y] = if look[1] - m.eye_y() > 0.0 { 0.0 } else { 1.0 };
let yaw = m.head_yaw.to_radians();
let pitch = m.head_pitch.to_radians();
let view = [-yaw.sin() * pitch.cos(), yaw.cos() * pitch.cos()];
let view = [-yaw.msin() * pitch.mcos(), yaw.mcos() * pitch.mcos()];
let d = [m.position.x - look[0], m.position.z - look[2]];
let len = (d[0] * d[0] + d[1] * d[1]).sqrt().max(1e-9);
let (dx, dz) = ((d[0] / len) as f32, (d[1] / len) as f32);
@@ -365,7 +366,7 @@ pub fn beam_geometry(
128u32.saturating_sub((cs * 64.0) as u32),
);
let color = 0xFF00_0000 | (b.min(255) << 16) | (g.min(255) << 8) | r.min(255);
let at = |a: f32, radius: f32| (a.cos() * radius, a.sin() * radius);
let at = |a: f32, radius: f32| (a.mcos() * radius, a.msin() * radius);
let quarter = std::f32::consts::FRAC_PI_4;
let (wx, wz) = at(rot + PI, 0.2);
let (ex, ez) = at(rot, 0.2);
@@ -432,7 +433,7 @@ pub fn anim(m: &Mob, s: &State, p: &mut Poses) {
8.0, -8.0, 0.0, 0.0, -8.0, -8.0, 8.0, 8.0, 8.0, -8.0, 0.0, 0.0,
];
for i in 0..12 {
let offset = 1.0 + (s.age * 1.5 + i as f32).cos() * 0.01 - withdrawal;
let offset = 1.0 + (s.age * 1.5 + i as f32).mcos() * 0.01 - withdrawal;
let part = p.get(&format!("spike{i}"));
part[0] = X[i] * offset;
part[1] = 16.0 + Y[i] * offset;
@@ -442,7 +443,7 @@ pub fn anim(m: &Mob, s: &State, p: &mut Poses) {
e[0] = m.anim.v[EYE_X];
e[1] = m.anim.v[EYE_Y];
let tail = m.anim.lerp(TAIL, s.partial);
p.yrot("tail0", tail.sin() * PI * 0.05);
p.yrot("tail1", tail.sin() * PI * 0.1);
p.yrot("tail2", tail.sin() * PI * 0.15);
p.yrot("tail0", tail.msin() * PI * 0.05);
p.yrot("tail1", tail.msin() * PI * 0.1);
p.yrot("tail2", tail.msin() * PI * 0.15);
}
+65 -37
View File
@@ -9,6 +9,7 @@ use super::{
},
};
use crate::projectiles::{Projectile, ProjectileKind};
use horizon_core::geometry::trig::Mth;
use horizon_core::{geometry::Vec3, random::RandomSource};
use std::f32::consts::PI;
@@ -306,8 +307,8 @@ fn cast_fangs(m: &mut Mob, cx: &mut Cx) {
for i in 0..5 {
let a = angle + i as f32 * PI * 0.4;
place(
x + f64::from(a.cos()) * 1.5,
z + f64::from(a.sin()) * 1.5,
x + f64::from(a.mcos()) * 1.5,
z + f64::from(a.msin()) * 1.5,
a,
0,
);
@@ -315,8 +316,8 @@ fn cast_fangs(m: &mut Mob, cx: &mut Cx) {
for i in 0..8 {
let a = angle + i as f32 * PI * 2.0 / 8.0 + PI * 2.0 / 5.0;
place(
x + f64::from(a.cos()) * 2.5,
z + f64::from(a.sin()) * 2.5,
x + f64::from(a.mcos()) * 2.5,
z + f64::from(a.msin()) * 2.5,
a,
3,
);
@@ -325,8 +326,8 @@ fn cast_fangs(m: &mut Mob, cx: &mut Cx) {
for i in 0..16 {
let reach = 1.25 * f64::from(i + 1);
place(
x + f64::from(angle.cos()) * reach,
z + f64::from(angle.sin()) * reach,
x + f64::from(angle.mcos()) * reach,
z + f64::from(angle.msin()) * reach,
angle,
i,
);
@@ -535,8 +536,9 @@ fn shoot_crossbow(m: &mut Mob, who: Who, cx: &mut Cx) {
pitch,
));
}
#[derive(Clone, Copy, PartialEq, Eq)]
enum ArmPose {
#[derive(Clone, Copy, PartialEq, Eq, Debug)]
pub enum ArmPose {
BowAndArrow,
Spellcasting,
Crossed,
Celebrating,
@@ -589,39 +591,55 @@ pub fn shows_item(m: &Mob) -> bool {
}
}
fn hide(p: &mut Poses, part: &str) {
if p.has(part) {
let v = p.get(part);
v[6] = 0.0;
v[7] = 0.0;
v[8] = 0.0;
}
p.visible(part, false);
}
/// `IllagerModel.setupAnim`.
pub fn anim(m: &Mob, s: &State, p: &mut Poses) {
let (hy, hx) = (s.y_rot.to_radians(), s.x_rot.to_radians());
p.yrot("head", hy);
p.xrot("head", hx);
let (pos, sp) = (s.pos, s.speed);
p.xrot("right_arm", (pos * 0.6662 + PI).cos() * 2.0 * sp * 0.5);
p.yrot("right_arm", 0.0);
p.zrot("right_arm", 0.0);
p.xrot("left_arm", (pos * 0.6662).cos() * 2.0 * sp * 0.5);
p.yrot("left_arm", 0.0);
p.zrot("left_arm", 0.0);
p.xrot("right_leg", (pos * 0.6662).cos() * 1.4 * sp * 0.5);
p.xrot("left_leg", (pos * 0.6662 + PI).cos() * 1.4 * sp * 0.5);
anim_pose(m, s, p, arm_pose(m));
}
/// `IllagerModel.setupAnim` for a given arm pose.
pub fn anim_pose(m: &Mob, s: &State, p: &mut Poses, pose: ArmPose) {
// IllagerModel hides the hat; the illusioner's renderer shows it.
if m.species() != Species::Illusioner {
hide(p, "hat");
}
let pose = arm_pose(m);
let (hy, hx) = (s.y_rot.to_radians(), s.x_rot.to_radians());
p.yrot("head", hy);
p.xrot("head", hx);
let (pos, sp) = (s.pos, s.speed);
if m.extra.passenger {
for arm in ["right_arm", "left_arm"] {
p.xrot(arm, -PI / 5.0);
p.yrot(arm, 0.0);
p.zrot(arm, 0.0);
}
p.xrot("right_leg", -1.413_716_7);
p.yrot("right_leg", PI / 10.0);
p.zrot("right_leg", 0.078_539_82);
p.xrot("left_leg", -1.413_716_7);
p.yrot("left_leg", -PI / 10.0);
p.zrot("left_leg", -0.078_539_82);
} else {
p.xrot("right_arm", (pos * 0.6662 + PI).mcos() * 2.0 * sp * 0.5);
p.yrot("right_arm", 0.0);
p.zrot("right_arm", 0.0);
p.xrot("left_arm", (pos * 0.6662).mcos() * 2.0 * sp * 0.5);
p.yrot("left_arm", 0.0);
p.zrot("left_arm", 0.0);
p.xrot("right_leg", (pos * 0.6662).mcos() * 1.4 * sp * 0.5);
p.yrot("right_leg", 0.0);
p.zrot("right_leg", 0.0);
p.xrot("left_leg", (pos * 0.6662 + PI).mcos() * 1.4 * sp * 0.5);
p.yrot("left_leg", 0.0);
p.zrot("left_leg", 0.0);
}
match pose {
ArmPose::Attacking => {
if m.extra.main_hand.is_none() {
// animateZombieArms + bobArms
let swing = s.swing;
let a = (swing * PI).sin();
let b = ((1.0 - (1.0 - swing) * (1.0 - swing)) * PI).sin();
let a = (swing * PI).msin();
let b = ((1.0 - (1.0 - swing) * (1.0 - swing)) * PI).msin();
p.zrot("right_arm", 0.0);
p.zrot("left_arm", 0.0);
p.yrot("right_arm", -(0.1 - a * 0.6));
@@ -632,22 +650,25 @@ pub fn anim(m: &Mob, s: &State, p: &mut Poses) {
} else {
// swingWeaponDown (right-handed).
let swing = s.swing;
let a2 = (swing * PI).sin();
let a = ((1.0 - (1.0 - swing) * (1.0 - swing)) * PI).sin();
let a2 = (swing * PI).msin();
let a = ((1.0 - (1.0 - swing) * (1.0 - swing)) * PI).msin();
p.zrot("right_arm", 0.0);
p.zrot("left_arm", 0.0);
p.yrot("right_arm", PI / 20.0);
p.yrot("left_arm", -PI / 20.0);
p.xrot(
"right_arm",
-1.884_955_8 + (s.age * 0.09).cos() * 0.15 + (a2 * 2.2 - a * 0.4),
-1.884_955_8 + (s.age * 0.09).mcos() * 0.15 + (a2 * 2.2 - a * 0.4),
);
p.xrot(
"left_arm",
-0.0 + (s.age * 0.19).mcos() * 0.5 + (a2 * 1.2 - a * 0.4),
);
p.xrot("left_arm", (s.age * 0.19).cos() * 0.5);
}
let bob = |p: &mut Poses, part: &str, sign: f32| {
let v = p.get(part);
v[5] += sign * ((s.age * 0.09).cos() * 0.05 + 0.05);
v[3] += sign * (s.age * 0.067).sin() * 0.05;
v[5] += sign * ((s.age * 0.09).mcos() * 0.05 + 0.05);
v[3] += sign * (s.age * 0.067).msin() * 0.05;
};
bob(p, "right_arm", 1.0);
bob(p, "left_arm", -1.0);
@@ -681,7 +702,7 @@ pub fn anim(m: &Mob, s: &State, p: &mut Poses) {
let v = p.get(arm);
v[2] = 0.0;
v[0] = x;
v[3] = (s.age * 0.6662).cos() * 0.25;
v[3] = (s.age * 0.6662).mcos() * 0.25;
v[4] = 0.0;
v[5] = z_rot;
}
@@ -694,11 +715,18 @@ pub fn anim(m: &Mob, s: &State, p: &mut Poses) {
let v = p.get(arm);
v[2] = 0.0;
v[0] = x;
v[3] = (s.age * 0.6662).cos() * 0.05;
v[3] = (s.age * 0.6662).mcos() * 0.05;
v[4] = 0.0;
v[5] = z_rot;
}
}
ArmPose::BowAndArrow => {
p.yrot("right_arm", -0.1 + hy);
p.xrot("right_arm", -PI / 2.0 + hx);
p.xrot("left_arm", -0.942_477_9 + hx);
p.yrot("left_arm", hy - 0.4);
p.zrot("left_arm", PI / 2.0);
}
ArmPose::Crossed | ArmPose::Neutral => {}
}
if pose == ArmPose::Crossed {
+12 -11
View File
@@ -10,6 +10,7 @@ use super::{
},
};
use crate::projectiles::{Projectile, ProjectileKind};
use horizon_core::geometry::trig::Mth;
use horizon_core::{
geometry::{Aabb, Vec3},
random::RandomSource,
@@ -181,25 +182,25 @@ pub fn blaze_anim(s: &State, p: &mut Poses) {
let mut angle = age * PI * -0.1;
for i in 0..4 {
let part = p.get(&format!("part{i}"));
part[1] = -2.0 + ((i * 2) as f32 + age).mul_add(0.25, 0.0).cos();
part[0] = angle.cos() * 9.0;
part[2] = angle.sin() * 9.0;
part[1] = -2.0 + ((i * 2) as f32 + age).mul_add(0.25, 0.0).mcos();
part[0] = angle.mcos() * 9.0;
part[2] = angle.msin() * 9.0;
angle += PI / 2.0;
}
angle = PI / 4.0 + age * PI * 0.03;
for i in 4..8 {
let part = p.get(&format!("part{i}"));
part[1] = 2.0 + (((i * 2) as f32 + age) * 0.25).cos();
part[0] = angle.cos() * 7.0;
part[2] = angle.sin() * 7.0;
part[1] = 2.0 + (((i * 2) as f32 + age) * 0.25).mcos();
part[0] = angle.mcos() * 7.0;
part[2] = angle.msin() * 7.0;
angle += PI / 2.0;
}
angle = 0.471_238_94 + age * PI * -0.05;
for i in 8..12 {
let part = p.get(&format!("part{i}"));
part[1] = 11.0 + ((i as f32 * 1.5 + age) * 0.5).cos();
part[0] = angle.cos() * 5.0;
part[2] = angle.sin() * 5.0;
part[1] = 11.0 + ((i as f32 * 1.5 + age) * 0.5).mcos();
part[0] = angle.mcos() * 5.0;
part[2] = angle.msin() * 5.0;
angle += PI / 2.0;
}
p.yrot("head", s.y_rot.to_radians());
@@ -365,7 +366,7 @@ impl Goal for GhastShoot {
}
if self.charge == 20 {
let yaw = m.yaw.to_radians();
let view = [-f64::from(yaw.sin()), f64::from(yaw.cos())];
let view = [-f64::from(yaw.msin()), f64::from(yaw.mcos())];
let half = f64::from(m.height()) * 0.5;
let ty = (t.bounds.min_position().y + t.bounds.max_position().y) * 0.5;
let dir = [
@@ -404,7 +405,7 @@ pub fn ghast_anim(s: &State, p: &mut Poses) {
for i in 0..9 {
let name = format!("tentacle{i}");
if p.has(&name) {
p.xrot(&name, 0.2 * (s.age * 0.3 + i as f32).sin() + 0.4);
p.xrot(&name, 0.2 * (s.age * 0.3 + i as f32).msin() + 0.4);
}
}
}
+10 -9
View File
@@ -5,6 +5,7 @@ use super::{
control::MoveKind,
goals::{Cx, Goal, MOVE, TARGET, goal_clone, reduced},
};
use horizon_core::geometry::trig::Mth;
use horizon_core::{geometry::Vec3, random::RandomSource};
/// Phantom state in `Extra`: `flag` swooping, `home` the anchor,
@@ -151,9 +152,9 @@ impl CircleAroundAnchor {
]);
self.angle += self.clockwise * 15.0f32.to_radians();
m.extra.vector = [
f64::from(a[0]) + f64::from(self.distance * self.angle.cos()),
f64::from(a[0]) + f64::from(self.distance * self.angle.mcos()),
f64::from(a[1]) + f64::from(-4.0 + self.height),
f64::from(a[2]) + f64::from(self.distance * self.angle.sin()),
f64::from(a[2]) + f64::from(self.distance * self.angle.msin()),
];
}
}
@@ -319,9 +320,9 @@ pub fn move_control(m: &mut Mob) {
let x_rot = -((-dy).atan2(sd) as f32).to_degrees();
m.head_pitch = x_rot;
let move_angle = (m.yaw + 90.0).to_radians();
let tx = f64::from(speed * move_angle.cos()) * (dx / sd2).abs();
let tz = f64::from(speed * move_angle.sin()) * (dz / sd2).abs();
let ty = f64::from(speed * x_rot.to_radians().sin()) * (dy / sd2).abs();
let tx = f64::from(speed * move_angle.mcos()) * (dx / sd2).abs();
let tz = f64::from(speed * move_angle.msin()) * (dz / sd2).abs();
let ty = f64::from(speed * x_rot.to_radians().msin()) * (dy / sd2).abs();
let v = m.velocity;
m.velocity = Vec3::new(
v.x + (tx - v.x) * 0.2,
@@ -336,20 +337,20 @@ pub fn move_control(m: &mut Mob) {
/// `PhantomModel.setupAnim` (flap time offset by the id).
pub fn anim(m: &Mob, s: &super::anim::State, p: &mut super::anim::Poses) {
let flap = (m.id as f32 * 3.0 + s.age) * 7.448_451_f32.to_radians();
let wing = flap.cos() * 16.0f32.to_radians();
let wing = flap.mcos() * 16.0f32.to_radians();
p.zrot("left_wing_base", wing);
p.zrot("left_wing_tip", wing);
p.zrot("right_wing_base", -wing);
p.zrot("right_wing_tip", -wing);
let tail = -(5.0 + (flap * 2.0).cos() * 5.0f32).to_radians();
let tail = -(5.0 + (flap * 2.0).mcos() * 5.0f32).to_radians();
p.xrot("tail_base", tail);
p.xrot("tail_tip", tail);
}
/// The flap sound when a wingbeat begins (`Phantom.isFlapping`).
pub fn flap_sound(m: &Mob, events: &mut Vec<MobEvent>) {
let t = m.id as f32 * 3.0 + m.age as f32;
let a = (t * 7.448_451_f32.to_radians() + std::f32::consts::PI).cos();
let b = ((t + 1.0) * 7.448_451_f32.to_radians() + std::f32::consts::PI).cos();
let a = (t * 7.448_451_f32.to_radians() + std::f32::consts::PI).mcos();
let b = ((t + 1.0) * 7.448_451_f32.to_radians() + std::f32::consts::PI).mcos();
if a > 0.0 && b <= 0.0 {
events.push(MobEvent::Sound(
"entity.phantom.flap",
+95 -30
View File
@@ -9,6 +9,7 @@ use super::{
NearestTarget, Prey, RandomLookAround, Stroll, goal_clone,
},
};
use horizon_core::geometry::trig::Mth;
use horizon_core::random::RandomSource;
use std::f32::consts::PI;
@@ -251,48 +252,112 @@ pub fn hoglin_hurt_target(m: &mut Mob, who: Who, cx: &mut Cx) {
};
cx.events.push(MobEvent::Sound(sound, m.center(), 1.0, 1.0));
}
/// `AbstractPiglinModel.setupAnim`: the ears flap around their default angle
/// (30 degrees for adults, 5 for babies).
pub fn ears(p: &mut Poses, s: &State) {
use horizon_core::geometry::trig::DEG_TO_RAD;
let default = if s.baby { 5.0 } else { 30.0 } * DEG_TO_RAD;
let freq = s.age * 0.1 + s.pos * 0.5;
let amp = 0.08 + s.speed * 0.4;
p.zrot("left_ear", -default - (freq * 1.2).mcos() * amp);
p.zrot("right_ear", default + freq.mcos() * amp);
}
/// Piglins' and brutes' ears flap (`AbstractPiglinModel`), arms follow the
/// arm pose (`PiglinModel`).
pub fn piglin_anim(m: &Mob, s: &State, p: &mut Poses) {
super::anim::humanoid_item(p, s, m.extra.main_hand.is_some());
let default = PI / 6.0;
let freq = s.age * 0.1 + s.pos * 0.5;
let amp = 0.08 + s.speed * 0.4;
p.zrot("left_ear", -default - (freq * 1.2).cos() * amp);
p.zrot("right_ear", default + freq.cos() * amp);
let (hy, hx) = (s.y_rot.to_radians(), s.x_rot.to_radians());
if m.extra.using_item > 0 {
// ADMIRING_ITEM: head down at the left hand.
p.xrot("head", 0.5);
p.yrot("head", 0.0);
p.yrot("left_arm", 0.5);
p.xrot("left_arm", -0.9);
let pose = if m.extra.using_item > 0 {
PiglinPose::AdmiringItem
} else if m.extra.flag {
p.yrot("right_arm", -0.8);
p.xrot("right_arm", -0.970_796_35);
let a = (m.extra.using_item as f32).clamp(0.0, 25.0) / 25.0;
p.yrot("left_arm", 0.4 + 0.45 * a);
p.xrot("left_arm", -0.970_796_35 + (-PI / 2.0 + 0.970_796_35) * a);
PiglinPose::CrossbowCharge
} else if m.extra.main_hand.as_deref() == Some("minecraft:crossbow") && m.ai.aggressive {
p.yrot("right_arm", -0.3 + hy);
p.yrot("left_arm", 0.6 + hy);
p.xrot("right_arm", -PI / 2.0 + hx + 0.1);
p.xrot("left_arm", -1.5 + hx);
} else if m.ai.aggressive && m.extra.main_hand.is_some() && s.swing == 0.0 {
p.xrot("right_arm", -1.8);
PiglinPose::CrossbowHold
} else if m.ai.aggressive && m.extra.main_hand.is_some() {
PiglinPose::MeleeWeapon
} else {
PiglinPose::Default
};
piglin_pose(p, s, pose, 25.0, m.extra.using_item as f32);
}
/// `PiglinArmPose`.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum PiglinPose {
Default,
Dancing,
MeleeWeapon,
CrossbowHold,
CrossbowCharge,
AdmiringItem,
}
/// `PiglinModel.setupAnim` for a piglin facing right-handed.
pub fn piglin_pose(p: &mut Poses, s: &State, pose: PiglinPose, max_charge: f32, ticks: f32) {
use super::anim::{ArmPose, Hum, humanoid};
let mut h = Hum::new(ArmPose::Empty, ArmPose::Empty);
h.weapon_swing = pose == PiglinPose::MeleeWeapon;
h.charge = (max_charge, ticks);
humanoid(p, s, &h);
ears(p, s);
let (hy, hx) = (s.y_rot.to_radians(), s.x_rot.to_radians());
let rad = |v: f64| v as f32;
let deg = horizon_core::geometry::trig::DEG_TO_RAD;
match pose {
PiglinPose::Dancing => {
let dance = s.age / 60.0;
p.zrot(
"right_ear",
rad(std::f64::consts::PI / 6.0) + deg * (dance * 30.0).msin() * 10.0,
);
p.zrot(
"left_ear",
rad(-std::f64::consts::PI / 6.0) - deg * (dance * 30.0).mcos() * 10.0,
);
p.get("head")[0] += (dance * 10.0).msin();
p.get("head")[1] += (dance * 40.0).msin() + 0.4;
let z = deg * (70.0 + (dance * 40.0).mcos() * 10.0);
p.zrot("right_arm", z);
p.zrot("left_arm", -z);
p.get("right_arm")[1] += (dance * 40.0).msin() * 0.5 - 0.5;
p.get("left_arm")[1] += (dance * 40.0).msin() * 0.5 + 0.5;
p.get("body")[1] += (dance * 40.0).msin() * 0.35;
}
PiglinPose::MeleeWeapon if s.swing == 0.0 => p.xrot("right_arm", -1.8),
PiglinPose::CrossbowHold => {
p.yrot("right_arm", -0.3 + hy);
p.yrot("left_arm", 0.6 + hy);
p.xrot("right_arm", -PI / 2.0 + hx + 0.1);
p.xrot("left_arm", -1.5 + hx);
}
PiglinPose::CrossbowCharge => {
p.yrot("right_arm", -0.8);
p.xrot("right_arm", -0.970_796_35);
p.xrot("left_arm", -0.970_796_35);
let alpha = ticks.clamp(0.0, max_charge) / max_charge;
p.yrot("left_arm", 0.4 + alpha * (0.85 - 0.4));
let x = -0.970_796_35 + alpha * (-PI / 2.0 - -0.970_796_35);
p.xrot("left_arm", x);
}
PiglinPose::AdmiringItem => {
p.xrot("head", 0.5);
p.yrot("head", 0.0);
p.yrot("left_arm", 0.5);
p.xrot("left_arm", -0.9);
}
_ => {}
}
}
/// `HoglinModel.setupAnim`.
pub fn hoglin_anim(m: &Mob, s: &State, p: &mut Poses) {
let (pos, sp) = (s.pos, s.speed);
p.zrot("right_ear", -PI * 2.0 / 9.0 - sp * pos.sin());
p.zrot("left_ear", PI * 2.0 / 9.0 + sp * pos.sin());
p.zrot("right_ear", -PI * 2.0 / 9.0 - sp * pos.msin());
p.zrot("left_ear", PI * 2.0 / 9.0 + sp * pos.msin());
p.yrot("head", s.y_rot.to_radians());
let remaining = m.extra.anim_ticks as f32;
let f = 1.0 - (10.0 - 2.0 * remaining).abs() / 10.0;
p.xrot("head", 0.872_664_63 + (-PI / 9.0 - 0.872_664_63) * f);
p.xrot("right_front_leg", pos.cos() * 1.2 * sp);
p.xrot("left_front_leg", (pos + PI).cos() * 1.2 * sp);
p.xrot("right_hind_leg", (pos + PI).cos() * 1.2 * sp);
p.xrot("left_hind_leg", pos.cos() * 1.2 * sp);
if s.baby {
p.get("head")[1] += f * 2.5;
}
p.xrot("right_front_leg", pos.mcos() * 1.2 * sp);
p.xrot("left_front_leg", (pos + PI).mcos() * 1.2 * sp);
p.xrot("right_hind_leg", (pos + PI).mcos() * 1.2 * sp);
p.xrot("left_hind_leg", pos.mcos() * 1.2 * sp);
}
+14 -12
View File
@@ -7,6 +7,7 @@ use super::{
goals::{Float, HurtByTarget, LookAtPlayer, MeleeAttack, NearestTarget, Stroll},
path::PathType,
};
use horizon_core::geometry::trig::Mth;
use horizon_core::random::RandomSource;
use std::f32::consts::PI;
@@ -135,9 +136,9 @@ pub fn ai_step(m: &mut Mob, w: &MobWorld, events: &mut Vec<MobEvent>) {
events.push(MobEvent::Particles {
kind: "entity_effect",
at: [
m.position.x - width * f64::from(yaw.sin()),
m.position.x - width * f64::from(yaw.msin()),
m.position.y + f64::from(m.height()) - 0.3,
m.position.z + width * f64::from(yaw.cos()),
m.position.z + width * f64::from(yaw.mcos()),
],
count: 0,
});
@@ -226,34 +227,35 @@ pub fn anim(m: &Mob, s: &State, p: &mut Poses) {
let neck_x_rot = p.get("neck")[3];
let neck = p.get("neck");
neck[2] = -6.5 + head;
neck[1] = -7.0 - head * neck_x_rot.sin();
neck[1] = -7.0 - head * neck_x_rot.msin();
let mouth = if attack > 5.0 {
((-4.0 + attack) / 4.0).sin() * PI * 0.4
((-4.0 + attack) / 4.0).msin() * PI * 0.4
} else {
PI / 20.0 * (PI * attack / 10.0).sin()
PI / 20.0 * (PI * attack / 10.0).msin()
};
p.xrot("mouth", mouth);
} else {
let is_stunned = stunned > 0.0;
let x_rot: f32 = if is_stunned { 0.219_911_49 } else { 0.0 };
let neck = p.get("neck");
let y_offset = -neck[3].msin();
neck[0] = 0.0;
neck[1] = -7.0 + x_rot.sin();
neck[1] = -7.0 - y_offset;
neck[2] = 5.5;
neck[3] = x_rot;
p.xrot("mouth", PI * if is_stunned { 0.05 } else { 0.01 });
if is_stunned {
p.get("neck")[0] = ((stunned / 40.0) * 10.0).sin() * 3.0;
p.get("neck")[0] = ((f64::from(stunned) / 40.0) * 10.0).sin() as f32 * 3.0;
} else if m.extra.anim_ticks > 0 {
let roar = (20.0 - m.extra.anim_ticks as f32 + s.partial) / 20.0;
p.xrot("mouth", PI / 2.0 * (roar * PI * 0.25).sin());
p.xrot("mouth", PI / 2.0 * (roar * PI * 0.25).msin());
}
}
p.xrot("head", s.x_rot.to_radians());
p.yrot("head", s.y_rot.to_radians());
let (pos, leg) = (s.pos, 0.4 * s.speed);
p.xrot("right_hind_leg", (pos * 0.6662).cos() * leg);
p.xrot("left_hind_leg", (pos * 0.6662 + PI).cos() * leg);
p.xrot("right_front_leg", (pos * 0.6662 + PI).cos() * leg);
p.xrot("left_front_leg", (pos * 0.6662).cos() * leg);
p.xrot("right_hind_leg", (pos * 0.6662).mcos() * leg);
p.xrot("left_hind_leg", (pos * 0.6662 + PI).mcos() * leg);
p.xrot("right_front_leg", (pos * 0.6662 + PI).mcos() * leg);
p.xrot("left_front_leg", (pos * 0.6662).mcos() * leg);
}
+4 -3
View File
@@ -8,6 +8,7 @@ use super::{
living::wrap,
};
use crate::mesher::Vertex;
use horizon_core::geometry::trig::Mth;
use std::f32::consts::PI;
/// A texture lookup into the shared atlas (name without namespace -> uv rect).
@@ -743,7 +744,7 @@ fn species_scale(m: &Mob, alpha: f32) -> glam::Mat4 {
let s = ((m.previous_swell as f32 + (m.swell - m.previous_swell) as f32 * alpha)
/ 28.0)
.clamp(0.0, 1.0);
let wobble = 1.0 + (s * 100.0).sin() * s * 0.01;
let wobble = 1.0 + (s * 100.0).msin() * s * 0.01;
let s4 = s * s * s * s;
let xz = (1.0 + s4 * 0.4) * wobble;
let y = (1.0 + s4 * 0.1) / wobble;
@@ -775,10 +776,10 @@ pub fn draw(
p[3],
))
* glam::Mat4::from_scale(glam::Vec3::new(p[6], p[7], p[8]));
if p[6] == 0.0 && p[7] == 0.0 && p[8] == 0.0 {
if poses.is_hidden(part) || p[6] == 0.0 && p[7] == 0.0 && p[8] == 0.0 {
return;
}
for poly in &part.polygons {
for poly in part.polygons.iter().filter(|_| !poses.skips(part)) {
for v in poly.vertices {
let pos = m.transform_point3(glam::Vec3::new(v[0], v[1], v[2]) / 16.0);
out.push(Vertex {
+5 -4
View File
@@ -11,6 +11,7 @@ use super::{
},
};
use crate::projectiles::{Projectile, ProjectileWorld, STEPS};
use horizon_core::geometry::trig::Mth;
use horizon_core::{
geometry::{Aabb, Vec3},
random::RandomSource,
@@ -20,7 +21,7 @@ use std::f32::consts::PI;
// Shulker state: `variant3` the attach face (3D data value), `counter` the
// raw peek (0..100), `color` the shell colour (16 none). AnimState slot 0
// the current peek amount.
const PEEK: usize = 0;
pub const PEEK: usize = 0;
pub const NO_COLOR: u8 = 16;
pub fn register(m: &mut Mob) {
@@ -335,14 +336,14 @@ pub fn rotations(m: &Mob) -> glam::Mat4 {
pub fn anim(m: &Mob, s: &State, p: &mut Poses) {
let peek = m.anim.lerp(PEEK, s.partial);
let bs = (0.5 + peek) * PI;
let q = -1.0 + bs.sin();
let q = -1.0 + bs.msin();
let extra = if bs > PI {
(s.age * 0.1).sin() * 0.7
(s.age * 0.1).msin() * 0.7
} else {
0.0
};
let lid = p.get("lid");
lid[1] = 16.0 + bs.sin() * 8.0 + extra;
lid[1] = 16.0 + bs.msin() * 8.0 + extra;
lid[4] = if peek > 0.3 {
q * q * q * q * PI * 0.125
} else {
@@ -1302,6 +1302,9 @@ impl Def {
Species::Hoglin => &["hoglin_baby"],
Species::Zoglin => &["zoglin_baby"],
Species::Strider => &["strider_baby"],
Species::Camel => &["camel_baby"],
Species::ZombieHorse => &["zombie_horse_baby"],
Species::SkeletonHorse => &["skeleton_horse_baby"],
_ => &[],
};
v.extend_from_slice(extra);
+73 -37
View File
@@ -10,6 +10,7 @@ use super::{
reduced,
},
};
use horizon_core::geometry::trig::Mth;
use horizon_core::{
geometry::{Aabb, Vec3},
random::RandomSource,
@@ -54,8 +55,8 @@ pub fn wolf_variant_for(biome: &str, has_tag: &dyn Fn(&str) -> bool) -> u8 {
pub const RED: u8 = 14;
// AnimState slots: begging interest and the shake animation.
const INTEREST: usize = 0;
const SHAKE: usize = 1;
pub const INTEREST: usize = 0;
pub const SHAKE: usize = 1;
pub fn register(m: &mut Mob) {
m.extra.color = RED;
@@ -537,7 +538,7 @@ pub fn ai_step(m: &mut Mob, w: &MobWorld, events: &mut Vec<MobEvent>) {
m.anim.vo[SHAKE] = 0.0;
}
if m.anim.v[SHAKE] > 0.4 {
let count = (((m.anim.v[SHAKE] - 0.4) * PI).sin() * 7.0) as u32;
let count = (((m.anim.v[SHAKE] - 0.4) * PI).msin() * 7.0) as u32;
if count > 0 {
events.push(MobEvent::Particles {
kind: "splash",
@@ -576,7 +577,7 @@ fn tail_angle(m: &Mob) -> f32 {
/// `WolfRenderState.getBodyRollAngle`.
fn body_roll(shake: f32, offset: f32) -> f32 {
let p = ((shake + offset) / 1.8).clamp(0.0, 1.0);
(p * PI).sin() * (p * PI * 11.0).sin() * 0.15 * PI
(p * PI).msin() * (p * PI * 11.0).msin() * 0.15 * PI
}
/// `WolfModel.setupAnim` with the adult and baby overrides.
pub fn anim(m: &Mob, s: &State, p: &mut Poses) {
@@ -585,7 +586,7 @@ pub fn anim(m: &Mob, s: &State, p: &mut Poses) {
if angry(m) {
p.yrot("tail", 0.0);
} else {
p.yrot("tail", (pos * 0.6662).cos() * 1.4 * speed);
p.yrot("tail", (pos * 0.6662).mcos() * 1.4 * speed);
}
if m.extra.sitting {
let age = if baby { 0.5 } else { 1.0 };
@@ -615,10 +616,10 @@ pub fn anim(m: &Mob, s: &State, p: &mut Poses) {
p.yrot("upper_body", 0.0);
}
} else {
p.xrot("right_hind_leg", (pos * 0.6662).cos() * 1.4 * speed);
p.xrot("left_hind_leg", (pos * 0.6662 + PI).cos() * 1.4 * speed);
p.xrot("right_front_leg", (pos * 0.6662 + PI).cos() * 1.4 * speed);
p.xrot("left_front_leg", (pos * 0.6662).cos() * 1.4 * speed);
p.xrot("right_hind_leg", (pos * 0.6662).mcos() * 1.4 * speed);
p.xrot("left_hind_leg", (pos * 0.6662 + PI).mcos() * 1.4 * speed);
p.xrot("right_front_leg", (pos * 0.6662 + PI).mcos() * 1.4 * speed);
p.xrot("left_front_leg", (pos * 0.6662).mcos() * 1.4 * speed);
}
// shakeOffWater
let shake = m.anim.lerp(SHAKE, s.partial);
@@ -946,26 +947,39 @@ pub fn cat_rotations(m: &Mob, partial: f32) -> glam::Mat4 {
glam::Mat4::from_translation(glam::Vec3::new(0.4 * lie, 0.15 * lie, 0.1 * lie))
* glam::Mat4::from_rotation_z((90.0 * lie).to_radians())
}
/// `Mth.rotLerp`: degrees-wrapping, applied by the feline models to radians.
fn rot_lerp(t: f32, from: f32, to: f32) -> f32 {
let mut d = (to - from) % (PI * 2.0);
if d < -PI {
d += PI * 2.0;
}
if d >= PI {
d -= PI * 2.0;
}
from + t * d
from + t * super::living::wrap(to - from)
}
/// `AdultFelineModel` / `BabyFelineModel.setupAnim` for cats.
/// `FelineRenderState` values the feline models read.
#[derive(Clone, Copy, Debug, Default)]
pub struct Feline {
pub crouching: bool,
pub sprinting: bool,
pub sitting: bool,
pub lie_down: f32,
pub lie_down_tail: f32,
pub relax_one: f32,
}
/// `AdultFelineModel` / `BabyFelineModel.setupAnim` for cats and ocelots.
pub fn cat_anim(m: &Mob, s: &State, p: &mut Poses) {
let baby = m.is_baby();
let age = if baby { 0.5 } else { 1.0 };
let wanted = m.ai.mov.has_wanted();
let speed_mod = m.ai.mov.speed_modifier;
// Cat.customServerAiStep: crouch while stalking, sprint while dashing.
let crouching = wanted && (speed_mod - 0.6).abs() < 1e-6;
let sprinting = wanted && (speed_mod - 1.33).abs() < 1e-6;
let sitting = cat_sitting(m);
let st = Feline {
crouching: wanted && (speed_mod - 0.6).abs() < 1e-6,
sprinting: wanted && (speed_mod - 1.33).abs() < 1e-6,
sitting: cat_sitting(m),
lie_down: m.anim.lerp(LIE, s.partial),
lie_down_tail: m.anim.lerp(LIE_TAIL, s.partial),
relax_one: m.anim.lerp(RELAX, s.partial),
};
feline(p, s, &st);
}
pub fn feline(p: &mut Poses, s: &State, st: &Feline) {
let baby = s.baby;
let age = if baby { 0.5 } else { 1.0 };
let (crouching, sprinting, sitting) = (st.crouching, st.sprinting, st.sitting);
let add = |p: &mut Poses, part: &str, x: f32, y: f32, z: f32| {
let v = p.get(part);
v[0] += x;
@@ -994,18 +1008,18 @@ pub fn cat_anim(m: &Mob, s: &State, p: &mut Poses) {
p.xrot("body", PI / 2.0);
}
if sprinting {
p.xrot("left_hind_leg", (pos * 0.6662).cos() * sp);
p.xrot("right_hind_leg", (pos * 0.6662 + 0.3).cos() * sp);
p.xrot("left_front_leg", (pos * 0.6662 + PI + 0.3).cos() * sp);
p.xrot("right_front_leg", (pos * 0.6662 + PI).cos() * sp);
p.xrot("tail2", 1.727_876_1 + PI / 10.0 * pos.cos() * sp);
p.xrot("left_hind_leg", (pos * 0.6662).mcos() * sp);
p.xrot("right_hind_leg", (pos * 0.6662 + 0.3).mcos() * sp);
p.xrot("left_front_leg", (pos * 0.6662 + PI + 0.3).mcos() * sp);
p.xrot("right_front_leg", (pos * 0.6662 + PI).mcos() * sp);
p.xrot("tail2", 1.727_876_1 + PI / 10.0 * pos.mcos() * sp);
} else {
p.xrot("left_hind_leg", (pos * 0.6662).cos() * sp);
p.xrot("right_hind_leg", (pos * 0.6662 + PI).cos() * sp);
p.xrot("left_front_leg", (pos * 0.6662 + PI).cos() * sp);
p.xrot("right_front_leg", (pos * 0.6662).cos() * sp);
p.xrot("left_hind_leg", (pos * 0.6662).mcos() * sp);
p.xrot("right_hind_leg", (pos * 0.6662 + PI).mcos() * sp);
p.xrot("left_front_leg", (pos * 0.6662 + PI).mcos() * sp);
p.xrot("right_front_leg", (pos * 0.6662).mcos() * sp);
let swing = if crouching { 0.471_238_94 } else { PI / 4.0 };
p.xrot("tail2", 1.727_876_1 + swing * pos.cos() * sp);
p.xrot("tail2", 1.727_876_1 + swing * pos.mcos() * sp);
}
} else if baby {
let x = p.get("body")[3] - 0.436_332_32;
@@ -1034,9 +1048,31 @@ pub fn cat_anim(m: &Mob, s: &State, p: &mut Poses) {
p.xrot("right_hind_leg", -PI / 2.0);
add(p, "right_hind_leg", 0.0, 3.0 * age, -4.0 * age);
}
let lie = m.anim.lerp(LIE, s.partial);
let lie_tail = m.anim.lerp(LIE_TAIL, s.partial);
if lie > 0.0 && !baby {
let lie = st.lie_down;
let lie_tail = st.lie_down_tail;
if lie > 0.0 && baby {
add(p, "body", 1.0, 0.0, 0.0);
let hx = p.get("head")[3];
p.xrot("head", rot_lerp(lie, hx, PI / 18.0));
let hz = p.get("head")[5];
p.zrot("head", rot_lerp(lie, hz, -PI * 5.0 / 12.0));
add(p, "head", 1.5, 0.75, -0.5);
p.xrot("right_front_leg", -PI / 4.0);
add(p, "right_front_leg", 3.5, -0.5, 0.0);
p.xrot("left_front_leg", -PI / 2.0);
add(p, "left_front_leg", 1.5, -1.0, -2.0);
p.xrot("right_hind_leg", PI * 2.0 / 9.0);
p.yrot("right_hind_leg", PI / 9.0);
p.zrot("right_hind_leg", -PI / 9.0);
add(p, "right_hind_leg", 2.5, -0.25, 0.5);
add(p, "left_hind_leg", 1.5, 0.0, -1.0);
let t = p.get("tail1");
let (tx, ty, tz) = (t[3], t[4], t[5]);
p.xrot("tail1", tx + rot_lerp(lie_tail, tx, -PI / 6.0));
p.yrot("tail1", ty + rot_lerp(lie_tail, ty, 0.0));
p.zrot("tail1", tz + rot_lerp(lie_tail, tz, -PI / 18.0));
add(p, "tail1", 1.0, 0.5, -0.25);
} else if lie > 0.0 {
let (hz, hy) = (p.get("head")[5], p.get("head")[4]);
p.zrot("head", rot_lerp(lie, hz, -1.270_796_3));
p.yrot("head", rot_lerp(lie, hy, 1.270_796_3));
@@ -1052,7 +1088,7 @@ pub fn cat_anim(m: &Mob, s: &State, p: &mut Poses) {
p.xrot("tail1", rot_lerp(lie_tail, t1, 0.8));
p.xrot("tail2", rot_lerp(lie_tail, t2, -0.4));
}
let relax = m.anim.lerp(RELAX, s.partial);
let relax = st.relax_one;
if relax > 0.0 {
let hx = p.get("head")[3];
p.xrot("head", rot_lerp(relax, hx, -0.581_776_44));
+26 -6
View File
@@ -9,6 +9,7 @@ use super::{
Cx, Float, Goal, HurtByTarget, LookAtPlayer, MOVE, NearestTarget, goal_clone, reduced,
},
};
use horizon_core::geometry::trig::Mth;
use horizon_core::{geometry::Vec3, random::RandomSource};
use std::f32::consts::PI;
@@ -225,19 +226,38 @@ pub fn ai_step(m: &mut Mob, w: &super::MobWorld) {
pub fn anim(m: &Mob, s: &State, p: &mut Poses) {
p.yrot("head", s.y_rot.to_radians());
p.xrot("head", s.x_rot.to_radians());
let bob = (s.age * 5.5).to_radians().cos() * 0.1;
let bob = (s.age * 5.5 * horizon_core::geometry::trig::DEG_TO_RAD).mcos() * 0.1;
p.zrot("right_arm", PI / 5.0 + bob);
p.zrot("left_arm", -(PI / 5.0 + bob));
if m.extra.flag {
p.xrot("body", 0.0);
// Holding the sword in the right hand.
p.xrot("right_arm", PI * 7.0 / 6.0);
p.yrot("right_arm", PI / 12.0);
p.zrot("right_arm", -0.471_238_88 - bob);
// setArmsCharging
let (right, left) = (m.extra.main_hand.is_some(), m.extra.off_hand.is_some());
if !right && !left {
p.xrot("right_arm", -1.221_730_5);
p.yrot("right_arm", PI / 12.0);
p.zrot("right_arm", -0.471_238_88 - bob);
p.xrot("left_arm", -1.221_730_5);
p.yrot("left_arm", -PI / 12.0);
p.zrot("left_arm", 0.471_238_88 + bob);
} else {
let sword = (std::f64::consts::PI * 7.0 / 6.0) as f32;
if right {
p.xrot("right_arm", sword);
p.yrot("right_arm", PI / 12.0);
p.zrot("right_arm", -0.471_238_88 - bob);
}
if left {
p.xrot("left_arm", sword);
p.yrot("left_arm", -PI / 12.0);
p.zrot("left_arm", 0.471_238_88 + bob);
}
}
} else {
p.xrot("body", PI / 20.0);
}
let wing = 1.099_557_4 + (s.age * 45.836_624).to_radians().cos() * 16.2_f32.to_radians();
let deg = horizon_core::geometry::trig::DEG_TO_RAD;
let wing = 1.099_557_4 + (s.age * 45.836_624 * deg).mcos() * deg * 16.2;
p.yrot("left_wing", wing);
p.yrot("right_wing", -wing);
p.xrot("left_wing", 0.471_238_88);
+4 -3
View File
@@ -13,6 +13,7 @@ use super::{
},
};
use crate::items::ItemStack;
use horizon_core::geometry::trig::Mth;
use horizon_core::random::RandomSource;
use std::{collections::HashMap, f32::consts::PI};
@@ -604,16 +605,16 @@ pub fn anim(m: &Mob, s: &State, p: &mut Poses) {
p.yrot("head", if awake { s.y_rot.to_radians() } else { 0.0 });
p.xrot("head", if awake { s.x_rot.to_radians() } else { 0.0 });
if m.extra.ints[0] > 0 {
p.zrot("head", 0.3 * (0.45 * s.age).sin());
p.zrot("head", 0.3 * (0.45 * s.age).msin());
p.xrot("head", 0.4);
} else {
p.zrot("head", 0.0);
}
let leg = (s.pos * 0.6662).cos() * 1.4 * s.speed * 0.5;
let leg = (s.pos * 0.6662).mcos() * 1.4 * s.speed * 0.5;
p.xrot("right_leg", leg);
p.xrot(
"left_leg",
(s.pos * 0.6662 + PI).cos() * 1.4 * s.speed * 0.5,
(s.pos * 0.6662 + PI).mcos() * 1.4 * s.speed * 0.5,
);
p.yrot("right_leg", 0.0);
p.yrot("left_leg", 0.0);
+6 -10
View File
@@ -9,6 +9,7 @@ use super::{
},
};
use crate::projectiles::{Projectile, ProjectileKind};
use horizon_core::geometry::trig::Mth;
use horizon_core::{geometry::Vec3, random::RandomSource};
pub fn register(m: &mut Mob) {
@@ -258,20 +259,15 @@ pub fn ai_step(m: &mut Mob, cx_events: &mut Vec<MobEvent>, target_far: bool) {
pub fn anim(m: &Mob, s: &State, p: &mut Poses) {
p.yrot("head", s.y_rot.to_radians());
p.xrot("head", s.x_rot.to_radians());
p.xrot("right_leg", (s.pos * 0.6662).cos() * 1.4 * s.speed * 0.5);
p.xrot("right_leg", (s.pos * 0.6662).mcos() * 1.4 * s.speed * 0.5);
p.xrot(
"left_leg",
(s.pos * 0.6662 + std::f32::consts::PI).cos() * 1.4 * s.speed * 0.5,
(s.pos * 0.6662 + std::f32::consts::PI).mcos() * 1.4 * s.speed * 0.5,
);
let speed = 0.01 * (m.id % 10) as f32;
p.xrot(
"nose",
(s.age * speed).sin() * 4.5 * std::f32::consts::PI / 180.0,
);
p.zrot(
"nose",
(s.age * speed).cos() * 2.5 * std::f32::consts::PI / 180.0,
);
let deg = horizon_core::geometry::trig::DEG_TO_RAD;
p.xrot("nose", (s.age * speed).msin() * 4.5 * deg);
p.zrot("nose", (s.age * speed).mcos() * 2.5 * deg);
if m.extra.main_hand.is_some() {
let n = p.get("nose");
n[0] = 0.0;
+6 -5
View File
@@ -13,6 +13,7 @@ use super::{
nav::NavKind,
};
use crate::projectiles::{Projectile, ProjectileKind};
use horizon_core::geometry::trig::Mth;
use horizon_core::{geometry::Vec3, random::RandomSource};
// Wither state: `counter` the invulnerable ticks, `counter2` the block
@@ -102,9 +103,9 @@ fn head_pos(m: &Mob, i: usize) -> [f64; 3] {
}
let a = (m.body_yaw + 180.0 * (i as f32 - 1.0)).to_radians();
[
m.position.x + f64::from(a.cos()) * 1.3,
m.position.x + f64::from(a.mcos()) * 1.3,
m.position.y + 2.2,
m.position.z + f64::from(a.sin()) * 1.3,
m.position.z + f64::from(a.msin()) * 1.3,
]
}
/// `performRangedAttack`: a skull from a head toward a point.
@@ -348,13 +349,13 @@ pub fn anim(m: &Mob, s: &State, p: &mut Poses) {
p.yrot(head, (y - body).to_radians());
p.xrot(head, x.to_radians());
}
let anim = (s.age * 0.1).cos();
let anim = (s.age * 0.1).mcos();
let rib = (0.065 + 0.05 * anim) * std::f32::consts::PI;
p.xrot("ribcage", rib);
let tail = p.get("tail");
tail[0] = -2.0;
tail[1] = 6.9 + rib.cos() * 10.0;
tail[2] = -0.5 + rib.sin() * 10.0;
tail[1] = 6.9 + rib.mcos() * 10.0;
tail[2] = -0.5 + rib.msin() * 10.0;
p.xrot("tail", (0.265 + 0.1 * anim) * std::f32::consts::PI);
p.yrot("center_head", s.y_rot.to_radians());
p.xrot("center_head", s.x_rot.to_radians());
+14
View File
@@ -23,6 +23,20 @@ pub fn cos(angle: f64) -> f32 {
sine_table()[((angle * SCALE + 16384.0) as i64 & 65535) as usize]
}
/// `Mth.sin` / `Mth.cos` on a float, as the models call them.
pub trait Mth {
fn msin(self) -> f32;
fn mcos(self) -> f32;
}
impl Mth for f32 {
fn msin(self) -> f32 {
sin(f64::from(self))
}
fn mcos(self) -> f32 {
cos(f64::from(self))
}
}
#[cfg(test)]
mod tests {
use super::*;
@@ -0,0 +1,196 @@
package dev.horizonlab.parity;
import com.google.gson.*;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.nio.charset.StandardCharsets;
import java.nio.file.*;
import java.util.*;
import net.minecraft.SharedConstants;
import net.minecraft.client.model.EntityModel;
import net.minecraft.client.model.geom.LayerDefinitions;
import net.minecraft.client.model.geom.ModelLayerLocation;
import net.minecraft.client.model.geom.ModelPart;
import net.minecraft.client.renderer.entity.state.EntityRenderState;
import net.minecraft.server.Bootstrap;
/**
* Original oracle for the client's entity model animation: bakes each vanilla model layer, builds
* its own render state class with the given walk/age/head/attack values plus optional extra
* fields, runs the real setupAnim and writes every part's pose.
*
* Input lines: "layer-key ModelClass|case-json" where case-json is an object of state field
* name to value. Output lines: {layer, case, parts:{path:[x,y,z,xRot,yRot,zRot,xScale,yScale,zScale,visible]}}.
*/
public final class VanillaEntityAnimOracle {
private static Field cubes;
private static Field children;
@SuppressWarnings("unchecked")
private static void dump(String path, ModelPart part, JsonObject out) throws Exception {
var pose = new JsonArray();
for (float f : new float[] {part.x, part.y, part.z, part.xRot, part.yRot, part.zRot, part.xScale, part.yScale, part.zScale})
pose.add(f);
pose.add(part.visible && !part.skipDraw ? 1 : 0);
int polys = 0;
double sum = 0;
for (ModelPart.Cube cube : (List<ModelPart.Cube>) cubes.get(part)) {
for (ModelPart.Polygon polygon : cube.polygons) {
polys++;
for (ModelPart.Vertex v : polygon.vertices()) {
float u = Float.isFinite(v.u()) ? v.u() : 0.0F, w = Float.isFinite(v.v()) ? v.v() : 0.0F;
sum += v.x() + 2.0 * v.y() + 3.0 * v.z() + 5.0 * u + 7.0 * w;
}
}
}
pose.add(polys);
pose.add(sum);
out.add(path, pose);
for (var entry : ((Map<String, ModelPart>) children.get(part)).entrySet())
dump(path.isEmpty() ? entry.getKey() : path + "/" + entry.getKey(), entry.getValue(), out);
}
private static Class<?> findClass(String simple) throws Exception {
for (String pkg : new String[] {"net.minecraft.client.model"}) {
// Search subpackages by trying every known class location through the jar index.
for (String name : CLASS_NAMES) {
if (name.endsWith("." + simple) || name.equals(simple)) return Class.forName(name);
}
}
throw new ClassNotFoundException(simple);
}
private static final List<String> CLASS_NAMES = new ArrayList<>();
private static Class<?> raw(java.lang.reflect.Type t, Map<java.lang.reflect.TypeVariable<?>, java.lang.reflect.Type> env) {
if (t instanceof Class<?> c) return c;
if (t instanceof java.lang.reflect.ParameterizedType p) return raw(p.getRawType(), env);
if (t instanceof java.lang.reflect.TypeVariable<?> v) {
var bound = env.get(v);
return raw(bound != null ? bound : v.getBounds()[0], env);
}
throw new IllegalArgumentException("cannot resolve " + t);
}
/** The render state class: the model's `S`, resolved through its generic superclasses. */
private static Class<?> stateClass(Class<?> model) {
var env = new HashMap<java.lang.reflect.TypeVariable<?>, java.lang.reflect.Type>();
Class<?> current = model;
for (var v : current.getTypeParameters()) env.put(v, raw(v.getBounds()[0], env));
while (current != net.minecraft.client.model.Model.class) {
var sup = current.getGenericSuperclass();
if (sup instanceof java.lang.reflect.ParameterizedType p) {
var params = ((Class<?>) p.getRawType()).getTypeParameters();
for (int i = 0; i < params.length; i++) env.put(params[i], raw(p.getActualTypeArguments()[i], env));
current = (Class<?>) p.getRawType();
} else {
current = (Class<?>) sup;
}
}
return raw(net.minecraft.client.model.Model.class.getTypeParameters()[0], env);
}
private static Field field(Class<?> type, String name) {
for (Class<?> c = type; c != null; c = c.getSuperclass()) {
try {
return c.getDeclaredField(name);
} catch (NoSuchFieldException e) {
}
}
return null;
}
private static void set(Object state, String name, JsonElement value) throws Exception {
boolean optional = name.startsWith("?") || Set.of("walkAnimationPos", "walkAnimationSpeed", "yRot", "xRot", "isBaby", "swingAnimation", "ageScale", "ageInTicks", "entityId", "yHeadRot", "yBodyRot", "eatTick", "flapOffset", "interest").contains(name);
if (name.startsWith("?")) name = name.substring(1);
Field f = field(state.getClass(), name);
if (f == null && optional) return;
if (f == null) throw new IllegalArgumentException("no field " + name + " on " + state.getClass());
f.setAccessible(true);
Class<?> t = f.getType();
if (t == float.class) f.setFloat(state, value.getAsFloat());
else if (t == int.class) f.setInt(state, value.getAsInt());
else if (t == double.class) f.setDouble(state, value.getAsDouble());
else if (t == boolean.class) f.setBoolean(state, value.getAsBoolean());
else if (t.isEnum()) {
for (Object c : t.getEnumConstants()) if (((Enum<?>) c).name().equals(value.getAsString())) f.set(state, c);
} else if (t.getSimpleName().equals("AnimationState")) {
// value = age in ticks since start (negative = stopped)
var a = (net.minecraft.world.entity.AnimationState) f.get(state);
a.stop();
if (value.getAsJsonPrimitive().isNumber()) a.start(value.getAsInt());
} else throw new IllegalArgumentException("unsupported type " + t + " for " + name);
}
/** Render-state values vanilla derives from entity state; the case gives the entity-side input. */
private static void hooks(EntityRenderState state, JsonObject kase) {
if (state instanceof net.minecraft.client.renderer.entity.state.SheepRenderState sheep && kase.has("eatTick")) {
// Sheep.getHeadEatPositionScale / getHeadEatAngleScale at partial tick 0.
int t = kase.get("eatTick").getAsInt();
float a = 0.0F;
sheep.headEatPositionScale = t <= 0 ? 0.0F : t >= 4 && t <= 36 ? 1.0F : t < 4 ? (t - a) / 4.0F : -(t - 40 - a) / 4.0F;
if (t > 4 && t <= 36) {
float scale = (t - 4 - a) / 32.0F;
sheep.headEatAngleScale = (float) (Math.PI / 5) + 0.21991149F * net.minecraft.util.Mth.sin(scale * 28.7F);
} else {
sheep.headEatAngleScale = t > 0 ? (float) (Math.PI / 5) : sheep.xRot * (float) (Math.PI / 180.0);
}
}
if (state instanceof net.minecraft.client.renderer.entity.state.WolfRenderState wolf && kase.has("interest"))
wolf.headRollAngle = kase.get("interest").getAsFloat() * 0.15F * (float) Math.PI;
if (state instanceof net.minecraft.client.renderer.entity.state.PhantomRenderState phantom && kase.has("flapOffset"))
phantom.flapTime = kase.get("flapOffset").getAsFloat() + phantom.ageInTicks;
}
public static void main(String[] args) throws Exception {
SharedConstants.tryDetectVersion();
Bootstrap.bootStrap();
cubes = ModelPart.class.getDeclaredField("cubes");
cubes.setAccessible(true);
children = ModelPart.class.getDeclaredField("children");
children.setAccessible(true);
try (var zip = new java.util.zip.ZipFile(args[2])) {
zip.stream().map(e -> e.getName()).filter(n -> n.startsWith("net/minecraft/client/model/") && n.endsWith(".class"))
.forEach(n -> CLASS_NAMES.add(n.substring(0, n.length() - 6).replace('/', '.')));
}
var roots = LayerDefinitions.createRoots();
var byName = new HashMap<String, ModelLayerLocation>();
for (var key : roots.keySet()) byName.put(key.toString(), key);
var gson = new Gson();
var out = new StringBuilder();
for (String line : Files.readAllLines(Path.of(args[0]))) {
if (line.isBlank()) continue;
var halves = line.split("\\|", 2);
var head = halves[0].split(" ");
var layer = head[0];
var kase = JsonParser.parseString(halves[1]).getAsJsonObject();
var result = new JsonObject();
result.addProperty("layer", layer);
result.add("case", kase);
try {
var location = byName.get(layer);
if (location == null) throw new IllegalArgumentException("no layer " + layer);
var cls = findClass(head[1]);
var baked = roots.get(location).bakeRoot();
var model = (net.minecraft.client.model.Model<EntityRenderState>) cls.getConstructor(ModelPart.class).newInstance(baked);
var type = stateClass(cls);
var state = (EntityRenderState) type.getDeclaredConstructor().newInstance();
state.getClass();
for (var entry : kase.entrySet()) set(state, entry.getKey(), entry.getValue());
hooks(state, kase);
if (state instanceof net.minecraft.client.renderer.entity.state.ArmedEntityRenderState armed && armed.swingAnimation > 0)
armed.currentSwing = new net.minecraft.world.entity.LivingEntity.SwingDescription(net.minecraft.world.InteractionHand.MAIN_HAND, net.minecraft.world.item.component.SwingAnimation.DEFAULT, 6);
model.setupAnim(state);
var parts = new JsonObject();
dump("", baked, parts);
result.add("parts", parts);
} catch (Throwable error) {
var cause = error.getCause() != null ? error.getCause() : error;
result.addProperty("error", cause.toString());
}
out.append(gson.toJson(result)).append('\n');
}
Files.writeString(Path.of(args[1]), out.toString(), StandardCharsets.UTF_8);
}
}
@@ -0,0 +1,98 @@
package dev.horizonlab.parity;
import java.io.PrintWriter;
import java.nio.charset.StandardCharsets;
import java.nio.file.*;
import java.util.*;
import net.minecraft.SharedConstants;
import net.minecraft.core.*;
import net.minecraft.core.registries.BuiltInRegistries;
import net.minecraft.core.registries.Registries;
import net.minecraft.resources.Identifier;
import net.minecraft.resources.RegistryDataLoader;
import net.minecraft.resources.ResourceKey;
import net.minecraft.server.Bootstrap;
import net.minecraft.server.RegistryLayer;
import net.minecraft.server.packs.PackType;
import net.minecraft.server.packs.repository.ServerPacksSource;
import net.minecraft.server.packs.resources.MultiPackResourceManager;
import net.minecraft.tags.TagLoader;
import net.minecraft.world.attribute.*;
import net.minecraft.world.clock.*;
import net.minecraft.world.level.biome.Biome;
import net.minecraft.world.level.dimension.DimensionType;
import net.minecraft.world.phys.Vec3;
import org.joml.Vector3fc;
import org.joml.Vector4fc;
/**
* Original oracle: builds the vanilla EnvironmentAttributeSystem (dimension
* layer, biome layer for one fixed biome, dimension timelines, weather layers)
* from the vanilla data pack and prints every visual/gameplay attribute for
* fixture lines "dimension ticks rain thunder biome".
*/
public final class VanillaEnvironmentOracle {
private static String fmt(Object v) {
if (v instanceof Vector3fc c) return String.format("[%s,%s,%s]", c.x(), c.y(), c.z());
if (v instanceof Vector4fc c) return String.format("[%s,%s,%s,%s]", c.x(), c.y(), c.z(), c.w());
if (v instanceof Float f) return f.toString();
if (v instanceof Boolean b) return b.toString();
if (v instanceof Enum<?> e) return "\"" + e.name() + "\"";
return null;
}
@SuppressWarnings({"unchecked", "rawtypes"})
private static void addBiome(EnvironmentAttributeSystem.Builder b, EnvironmentAttribute attr, Biome biome) {
b.addPositionalLayer(attr, (base, pos, w) -> biome.getAttributes().applyModifier(attr, base));
}
public static void main(String[] args) throws Exception {
SharedConstants.tryDetectVersion();
Bootstrap.bootStrap();
Path in = Path.of(args[0]), out = Path.of(args[1]);
var repo = ServerPacksSource.createVanillaTrustedRepository();
repo.reload();
repo.setSelected(List.of("vanilla"));
var resources = new MultiPackResourceManager(PackType.SERVER_DATA, repo.openAllSelected());
var layers = RegistryLayer.createRegistryAccess();
var staticTags = TagLoader.loadTagsForExistingRegistries(resources, layers.getLayer(RegistryLayer.STATIC));
var context = TagLoader.buildUpdatedLookups(layers.getAccessForLoading(RegistryLayer.WORLD), staticTags);
RegistryAccess.Frozen world = RegistryDataLoader.load(resources, context, RegistryDataLoader.WORLD_REGISTRIES, Runnable::run).join();
staticTags.forEach(Registry.PendingTags::apply);
var dimensions = world.lookupOrThrow(Registries.DIMENSION_TYPE);
var biomes = world.lookupOrThrow(Registries.BIOME);
try (var w = new PrintWriter(Files.newBufferedWriter(out, StandardCharsets.UTF_8))) {
for (String line : Files.readAllLines(in, StandardCharsets.UTF_8)) {
String[] f = line.split(" ");
DimensionType dim = dimensions.getOrThrow(ResourceKey.create(Registries.DIMENSION_TYPE, Identifier.withDefaultNamespace(f[0]))).value();
long ticks = Long.parseLong(f[1]);
float rain = Float.parseFloat(f[2]), thunder = Float.parseFloat(f[3]);
Biome biome = biomes.getOrThrow(ResourceKey.create(Registries.BIOME, Identifier.withDefaultNamespace(f[4]))).value();
ClockManager clocks = h -> new ClockInstance() {
public long totalTicks() { return ticks; }
public float partialTick() { return 0.0F; }
public float rate() { return 1.0F; }
public boolean isPaused() { return false; }
};
var b = EnvironmentAttributeSystem.builder();
b.addConstantLayer(dim.attributes());
for (EnvironmentAttribute<?> attr : biome.getAttributes().keySet()) addBiome(b, attr, biome);
dim.timelines().forEach(t -> b.addTimelineLayer(t, clocks));
if (dim.hasSkyLight() && !dim.hasCeiling()) {
WeatherAttributes.addBuiltinLayers(b, new WeatherAttributes.WeatherAccess() {
public float rainLevel() { return rain; }
public float thunderLevel() { return thunder; }
});
}
var system = b.build();
StringBuilder sb = new StringBuilder("{\"case\":\"" + line + "\"");
for (var entry : BuiltInRegistries.ENVIRONMENT_ATTRIBUTE.entrySet()) {
EnvironmentAttribute<?> attr = entry.getValue();
String s = fmt(system.getValue(attr, Vec3.ZERO));
if (s != null) sb.append(",\"").append(entry.getKey().identifier()).append("\":").append(s);
}
w.println(sb.append("}"));
}
}
}
}
+296
View File
@@ -0,0 +1,296 @@
#!/usr/bin/env python3
"""Compare entity model geometry and setupAnim poses with the vanilla 26.3 client.
The Java oracle bakes each vanilla model layer, builds the model's own render
state class with the generated walk/age/head/attack inputs (plus per-species
state fields), runs the real `setupAnim` and writes every part's pose.
`examples/entity_anim_fixture` replays the same inputs through Horizon's
`mobs::anim::setup` and the loaded model tree; the two must agree on every part
pose and on the baked polygon count and vertex sums.
test_entity_model_parity.py [--filter SUBSTRING] [--detail LAYER] [--tolerance EPS]
"""
import argparse
import json
import math
import os
from pathlib import Path
import random
import re
import subprocess
import sys
try:
from . import lab, test_rust_parity as base, test_model_baking_parity as baking
except ImportError:
import lab, test_rust_parity as base, test_model_baking_parity as baking
CLIENT = lab.LOCAL / 'minecraft' / '26.3' / 'sources' / 'client' / 'net' / 'minecraft' / 'client'
# Models that no renderer builds with a plain `new Model(context.bakeLayer(CONSTANT))`.
EXTRAS = [
('minecraft:zombie#main', 'ZombieModel'), ('minecraft:zombie_baby#main', 'BabyZombieModel'),
('minecraft:husk#main', 'ZombieModel'), ('minecraft:husk_baby#main', 'BabyZombieModel'),
('minecraft:zombie_villager#main', 'ZombieVillagerModel'),
('minecraft:zombie_villager_baby#main', 'BabyZombieVillagerModel'),
('minecraft:zombified_piglin#main', 'AdultZombifiedPiglinModel'),
('minecraft:zombified_piglin_baby#main', 'BabyZombifiedPiglinModel'),
('minecraft:skeleton#main', 'SkeletonModel'), ('minecraft:stray#main', 'SkeletonModel'),
('minecraft:wither_skeleton#main', 'SkeletonModel'),
('minecraft:spider#main', 'SpiderModel'), ('minecraft:cave_spider#main', 'SpiderModel'),
('minecraft:enderman#main', 'EndermanModel'), ('minecraft:endermite#main', 'EndermiteModel'),
('minecraft:piglin#main', 'AdultPiglinModel'), ('minecraft:piglin_brute#main', 'AdultPiglinModel'),
('minecraft:piglin_baby#main', 'BabyPiglinModel'),
('minecraft:hoglin#main', 'HoglinModel'), ('minecraft:zoglin#main', 'HoglinModel'),
('minecraft:hoglin_baby#main', 'BabyHoglinModel'), ('minecraft:zoglin_baby#main', 'BabyHoglinModel'),
('minecraft:guardian#main', 'GuardianModel'), ('minecraft:elder_guardian#main', 'GuardianModel'),
('minecraft:evoker#main', 'IllagerModel'), ('minecraft:illusioner#main', 'IllagerModel'),
('minecraft:pillager#main', 'IllagerModel'), ('minecraft:vindicator#main', 'IllagerModel'),
('minecraft:llama#main', 'LlamaModel'), ('minecraft:trader_llama#main', 'LlamaModel'),
('minecraft:llama_baby#main', 'BabyLlamaModel'), ('minecraft:trader_llama_baby#main', 'BabyLlamaModel'),
('minecraft:donkey#main', 'DonkeyModel'), ('minecraft:mule#main', 'DonkeyModel'),
('minecraft:donkey_baby#main', 'BabyDonkeyModel'), ('minecraft:mule_baby#main', 'BabyDonkeyModel'),
('minecraft:skeleton_horse#main', 'HorseModel'), ('minecraft:zombie_horse#main', 'HorseModel'),
('minecraft:skeleton_horse_baby#main', 'BabyHorseModel'), ('minecraft:zombie_horse_baby#main', 'BabyHorseModel'),
('minecraft:cave_spider#main', 'SpiderModel'),
('minecraft:stray#main', 'SkeletonModel'),
]
# Layers a renderer reuses for another entity under a different constant.
SKIP_LAYERS = re.compile(r'(banner|bell|book|skull|head|chest|shulker_box|boat|cushion|conduit|leash|arrow|trident|'
r'shield|elytra|spin_attack|ears|cape|decorated_pot|minecart|wind_charge|evoker_fangs|'
r'llama_spit|shulker_bullet|bee_stinger|end_crystal|armor_stand|copper_golem|#(helmet|chestplate|leggings|'
r'boots|outer|armor|decor|saddle|collar|wool|wool_undercoat|eyes|wind|inner|pattern|tendrils|'
r'heart|bioluminescent|pulsating_spots|water_patch|flag|cage|shell)$)')
def layer_constant(name):
"""minecraft:cow_baby#main -> constant COW_BABY (the main layer of a model)."""
return name.split(':')[1].split('#')[0].upper()
def renderer_pairs():
pairs = {}
pattern = re.compile(r'new (\w+)\(\s*(?:context|this\.context|\w*)\.bakeLayer\(ModelLayers\.(\w+)\)')
for path in sorted((CLIENT / 'renderer').rglob('*.java')):
for match in pattern.finditer(path.read_text()):
pairs[match.group(2)] = match.group(1)
return pairs
def layers(models):
chosen = {}
pairs = renderer_pairs()
for key in models:
if not key.endswith('#main') or SKIP_LAYERS.search(key):
continue
constant = layer_constant(key)
if constant in pairs:
chosen[key] = pairs[constant]
for key, cls in EXTRAS:
if key in models:
chosen[key] = cls
return chosen
def cases(layer):
rng = random.Random(0x414e494d + sum(map(ord, layer)))
baby = '_baby#' in layer
base_cases = [
(0.0, 0.0, 0.0, 0.0, 0.0, 0.0),
(1.0, 0.5, 10.0, 0.0, 0.0, 0.0),
(3.7, 0.6, 57.3, 20.0, -15.0, 0.0),
(12.25, 1.0, 123.5, -35.0, 40.0, 0.0),
(7.5, 0.3, 33.3, 5.0, 5.0, 0.35),
(2.0, 0.0, 77.7, 45.0, -60.0, 0.8),
]
for _ in range(14):
base_cases.append((rng.uniform(0, 30), rng.uniform(0, 1), rng.uniform(0, 400),
rng.uniform(-50, 50), rng.uniform(-70, 70),
rng.choice([0.0, rng.uniform(0.01, 0.99)])))
cases_out = []
for pos, speed, age, y, x, attack in base_cases:
cases_out.append({'walkAnimationPos': pos, 'walkAnimationSpeed': speed, 'ageInTicks': age,
'yRot': y, 'xRot': x, 'swingAnimation': attack, 'isBaby': baby, 'ageScale': 0.5 if baby else 1.0,
'entityId': 7, 'yHeadRot': y, 'yBodyRot': 0.0})
name = layer.split(':')[1].split('#')[0].removesuffix('_baby')
cases_out = [{**c, **DEFAULTS.get(name, {})} for c in cases_out]
yield from cases_out
yield from species_cases(layer, cases_out)
T, F = True, False
FOX = [{'isCrouching': T, 'crouchAmount': 0.8}, {'isSleeping': T}, {'isSitting': T}, {'isPouncing': T, 'crouchAmount': 0.6},
{'isFaceplanted': T}, {'headRollAngle': 0.3}, {'isCrouching': T, 'isPouncing': T, 'crouchAmount': 0.4}]
ILLAGER = [{'armPose': pose, 'maxCrossbowChargeDuration': 25, 'ticksUsingItem': 10.0}
for pose in ['NEUTRAL', 'CROSSED', 'ATTACKING', 'SPELLCASTING', 'BOW_AND_ARROW', 'CROSSBOW_HOLD',
'CROSSBOW_CHARGE', 'CELEBRATING']] + [{'isRiding': T, 'armPose': 'CROSSED'}]
FELINE = [{'isCrouching': T}, {'isSprinting': T}, {'isSitting': T}, {'lieDownAmount': 0.7, 'lieDownAmountTail': 0.5},
{'relaxStateOneAmount': 0.6}, {'isSitting': T, 'lieDownAmount': 1.0, 'lieDownAmountTail': 0.2}]
ZOMBIE = [{'isAggressive': T}, {'isCrouching': T}, {'isPassenger': T}, {'isAggressive': T, 'isPassenger': T, 'isCrouching': T}]
SKELETON = ZOMBIE + [{'isAggressive': T, 'isHoldingBow': T, 'rightArmPose': 'BOW_AND_ARROW'}, {'isHoldingBow': T},
{'isAggressive': T, 'isHoldingBow': T, 'rightArmPose': 'BOW_AND_ARROW', 'isCrouching': T}]
PIGLIN = [{'armPose': pose, 'maxCrossbowChageDuration': 25.0, 'ticksUsingItem': 12.0}
for pose in ['DEFAULT', 'DANCING', 'ATTACKING_WITH_MELEE_WEAPON', 'CROSSBOW_HOLD', 'CROSSBOW_CHARGE', 'ADMIRING_ITEM']]
EQUINE = [{'eatAnimation': 0.6}, {'standAnimation': 0.5}, {'eatAnimation': 0.3, 'standAnimation': 0.4, 'feedingAnimation': 0.7},
{'isInWater': T}, {'standAnimation': 1.0, 'eatAnimation': 1.0}]
WATER = [{'isInWater': T}, {'isInWater': F}]
SPECIES = {
'horse': EQUINE, 'donkey': EQUINE + [{'hasChest': T}], 'mule': EQUINE + [{'hasChest': T}], 'zombie_horse': EQUINE, 'skeleton_horse': EQUINE,
'iron_golem': [{'attackTicksRemaining': 7.0}, {'offerFlowerTick': 30}, {'attackTicksRemaining': 0.0, 'offerFlowerTick': 0}],
'hoglin': [{'attackAnimationRemainingTicks': t} for t in (3, 7, 10)],
'zoglin': [{'attackAnimationRemainingTicks': t} for t in (3, 7, 10)],
'ravager': [{'stunnedTicksRemaining': 20.0}, {'attackTicksRemaining': 8.0}, {'attackTicksRemaining': 3.0},
{'roarAnimation': 0.5}],
'vex': [{'isCharging': T}, {'isCharging': F}],
'squid': [{'tentacleAngle': 0.7}], 'glow_squid': [{'tentacleAngle': 1.2}],
'dolphin': [{'isMoving': T}, {'isMoving': F}],
'cod': WATER, 'salmon': WATER, 'tropical_fish_small': WATER,
'allay': [{'isDancing': T, 'isSpinning': T, 'spinningProgress': 0.6}, {'isDancing': T, 'isSpinning': F, 'spinningProgress': 0.2},
{'holdingAnimationProgress': 0.8}, {'holdingAnimationProgress': 1.0}],
'camel': [{'sitAnimationState': 2}, {'sitPoseAnimationState': 3}, {'sitUpAnimationState': 1}, {'idleAnimationState': 4},
{'dashAnimationState': 2}, {'jumpCooldown': 20.0}],
'chicken': [{'flap': 2.0, 'flapSpeed': 0.7}, {'flap': 5.3, 'flapSpeed': 1.0}],
'wolf': [{'isSitting': T}, {'isAngry': T, 'tailAngle': 1.5393804}, {'shakeAnim': 0.9}, {'interest': 0.6},
{'isSitting': T, 'shakeAnim': 0.5, 'interest': 0.3}],
'zombie': ZOMBIE, 'husk': ZOMBIE, 'drowned': ZOMBIE, 'zombie_villager': ZOMBIE, 'zombified_piglin': ZOMBIE, 'giant': ZOMBIE,
'skeleton': SKELETON, 'stray': SKELETON, 'wither_skeleton': SKELETON, 'bogged': SKELETON,
'piglin': PIGLIN, 'piglin_brute': PIGLIN,
'cat': FELINE, 'ocelot': FELINE,
'creaking': [{'canMove': F}, {'attackAnimationState': 2}, {'invulnerabilityAnimationState': 3}, {'deathAnimationState': 1}],
'evoker': ILLAGER, 'pillager': ILLAGER, 'vindicator': ILLAGER,
'sheep': [{'eatTick': t} for t in (2, 10, 36, 39)],
'guardian': [{'tailAnimation': 4.0, 'spikesAnimation': 0.3}, {'tailAnimation': 0.0, 'spikesAnimation': 0.0}],
'elder_guardian': [{'tailAnimation': 4.0, 'spikesAnimation': 0.3}],
'shulker': [{'peekAmount': v} for v in (0.0, 0.2, 0.5, 1.0)],
'witch': [{'isHoldingItem': T}, {'isHoldingItem': F}],
'goat': [{'hasLeftHorn': T, 'hasRightHorn': T}, {'hasLeftHorn': F, 'hasRightHorn': T, 'rammingXHeadRot': 0.6},
{'hasLeftHorn': T, 'hasRightHorn': F}],
'polar_bear': [{'standScale': 0.0}, {'standScale': 0.5}, {'standScale': 1.0}],
'panda': [{'isUnhappy': T}, {'isSneezing': T, 'sneezeTime': 5}, {'isSneezing': T, 'sneezeTime': 16},
{'sitAmount': 0.6, 'isEating': T}, {'sitAmount': 1.0, 'isScared': T}, {'sitAmount': 0.3},
{'lieOnBackAmount': 0.5}, {'rollAmount': 0.7}],
'llama': [{'hasChest': T}, {'hasChest': F}],
'trader_llama': [{'hasChest': T}, {'hasChest': F}],
'turtle': [{'isOnLand': T}, {'isOnLand': T, 'isLayingEgg': T}, {'isOnLand': F, 'hasEgg': T}, {'isOnLand': T, 'hasEgg': T}],
'strider': [{'isRidden': T}, {'isRidden': F}],
'parrot': [{'pose': pose, 'flapAngle': 0.4} for pose in ['STANDING', 'FLYING', 'ON_SHOULDER', 'SITTING', 'PARTY']],
'bee': [{'hasStinger': T}, {'hasStinger': F, 'isOnGround': T}, {'isAngry': T}, {'rollAmount': 0.6, 'isAngry': T},
{'isOnGround': T, 'hasStinger': T}],
'bat': [{'isResting': T, 'restAnimationState': 3}, {'flyAnimationState': 2}, {'isResting': F, 'flyAnimationState': 0}],
'armadillo': [{'isHidingInShell': T}, {'isHidingInShell': T, 'rollUpAnimationState': 2},
{'rollOutAnimationState': 4}, {'peekAnimationState': 1}],
'axolotl': [{'playingDeadFactor': 0.0, 'inWaterFactor': 1.0, 'onGroundFactor': 0.0, 'movingFactor': 1.0},
{'inWaterFactor': 1.0, 'movingFactor': 0.0}, {'onGroundFactor': 1.0, 'movingFactor': 1.0},
{'onGroundFactor': 1.0, 'movingFactor': 0.0}, {'inWaterFactor': 0.5, 'onGroundFactor': 0.5, 'movingFactor': 0.5},
{'playingDeadFactor': 1.0, 'inWaterFactor': 1.0},
{'walkAnimationState': 1}, {'swimAnimation': 2}, {'idleOnGroundAnimationState': 3},
{'idleUnderWaterAnimationState': 2}, {'idleUnderWaterOnGroundAnimationState': 1}, {'playDeadAnimationState': 4}],
'frog': [{'isSwimming': T}, {'isSwimming': F}, {'jumpAnimationState': 2}, {'croakAnimationState': 1},
{'tongueAnimationState': 3}, {'swimIdleAnimationState': 2, 'isSwimming': T}],
'rabbit': [{'hopAnimationState': 2}, {'idleHeadTiltAnimationState': 1}],
'fox': FOX,
}
# Render-state defaults that are not zero/false in vanilla.
DEFAULTS = {'creaking': {'canMove': T}, 'wolf': {'tailAngle': 0.6283185307179586}, 'axolotl': {'inWaterFactor': 1.0}, 'bee': {'hasStinger': T}, 'sheep': {'eatTick': 0},
'goat': {'hasLeftHorn': T, 'hasRightHorn': T}, 'parrot': {'pose': 'STANDING'},
'phantom': {'flapOffset': 21.0}, 'guardian': {'tailAnimation': 1.3, 'spikesAnimation': 1.0},
'elder_guardian': {'tailAnimation': 1.3, 'spikesAnimation': 1.0}}
def species_cases(layer, base_cases):
name = layer.split(':')[1].split('#')[0].removesuffix('_baby')
for extra in SPECIES.get(name, []):
for index in (2, 3, 6):
yield {**base_cases[index], **extra}
def main():
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument('--filter', default='')
parser.add_argument('--detail', default='')
parser.add_argument('--tolerance', type=float, default=5e-7)
args = parser.parse_args()
lock, jars, _ = base.verify_artifacts()
libraries = baking.client_libraries()
build = lab.LOCAL / 'rust-entity-model-parity'; build.mkdir(parents=True, exist_ok=True)
resources = lab.LOCAL / 'horizon-client' / '26.3'
models = json.loads((resources / 'entity-models.json').read_text())
chosen = {k: v for k, v in layers(models).items() if args.filter in k}
extra_cases = json.loads((Path(__file__).with_suffix('.cases.json')).read_text()) \
if Path(__file__).with_suffix('.cases.json').exists() else {}
lines = []
for layer, cls in sorted(chosen.items()):
for case in cases(layer):
lines.append(f'{layer} {cls}|{json.dumps(case)}')
for case in extra_cases.get(layer.split(':')[1].split('#')[0], []):
lines.append(f'{layer} {cls}|{json.dumps(case)}')
inputs = build / 'inputs.txt'; inputs.write_text('\n'.join(lines) + '\n')
classes = build / 'classes'; classes.mkdir(exist_ok=True)
oracle = lab.ROOT / 'mods/horizon/src/test/java/dev/horizonlab/parity/VanillaEntityAnimOracle.java'
dependencies = os.pathsep.join(map(str, [jars['client'], *libraries]))
def run(command, name):
with (build / (name + '.log')).open('w') as log:
result = subprocess.run(list(map(str, command)), cwd=lab.ROOT, timeout=3600, stdout=log, stderr=subprocess.STDOUT)
if result.returncode:
print((build / (name + '.log')).read_text()[-4000:]); sys.exit(f'{name} failed')
run(['javac', '--release', lock['minecraft']['java_major'], '-proc:none', '-cp', dependencies, '-d', classes, oracle], 'compile-java')
run(['java', '-Xmx1G', '-cp', str(classes) + os.pathsep + dependencies, 'dev.horizonlab.parity.VanillaEntityAnimOracle',
inputs, build / 'vanilla.jsonl', jars['client']], 'vanilla')
run(['cargo', 'run', '--quiet', '--profile', 'fast', '-p', 'horizon-client', '--example', 'entity_anim_fixture', '--',
resources, build / 'vanilla.jsonl', build / 'rust.jsonl'], 'rust')
vanilla = [json.loads(l) for l in (build / 'vanilla.jsonl').read_text().splitlines()]
rust = [json.loads(l) for l in (build / 'rust.jsonl').read_text().splitlines()]
assert len(vanilla) == len(rust), (len(vanilla), len(rust))
errors, skipped, mismatched, checked = {}, set(), {}, 0
for v, r in zip(vanilla, rust):
layer = v['layer']
if 'error' in v:
errors[layer] = v['error']; continue
if 'skip' in r:
skipped.add(layer); continue
checked += 1
bad = []
for path, expected in v['parts'].items():
got = r['parts'].get(path)
if got is None:
bad.append((path, 'missing in Horizon')); continue
names = ['x', 'y', 'z', 'xRot', 'yRot', 'zRot', 'xScale', 'yScale', 'zScale', 'visible', 'polys', 'vsum']
for i, (a, b) in enumerate(zip(expected, got)):
if i == 11 and abs(a - b) <= 1e-3 * max(1, abs(a)):
continue
if i == 9:
a, b = bool(a), bool(b)
if a != b:
bad.append((path, f'visible {a} != {b}'))
continue
if abs(a - b) > args.tolerance * (1.0 + abs(a)):
bad.append((path, f'{names[i]} {a!r} != {b!r}'))
for path in r['parts']:
if path not in v['parts']:
bad.append((path, 'extra in Horizon'))
if bad:
mismatched.setdefault(layer, []).append((v['case'], bad))
print(f'{checked} cases compared over {len(chosen) - len(skipped) - len(errors)} layers')
if errors:
print('oracle errors:'); [print(' ', k, v) for k, v in sorted(errors.items())]
if skipped:
print('layers without a Horizon species:', ', '.join(sorted(skipped)))
for layer, items in sorted(mismatched.items()):
parts = {}
for case, bad in items:
for path, why in bad:
parts.setdefault(path, (why, case))
total = sum(1 for x in vanilla if x['layer'] == layer)
print(f'MISMATCH {layer}: {len(items)}/{total} cases, {len(parts)} parts')
detailed = args.detail == layer
for path, (why, case) in list(parts.items())[:(10 ** 6 if detailed else 4)]:
print(f' {path or "<root>"}: {why}' + (f' case={json.dumps(case)}' if detailed else ''))
if mismatched or errors:
sys.exit(f'{len(mismatched)} layers differ from vanilla')
print('entity model parity ok')
if __name__ == '__main__':
main()
+97
View File
@@ -0,0 +1,97 @@
#!/usr/bin/env python3
"""Compare Horizon's environment attributes with the vanilla 26.3 attribute system.
The Java oracle builds vanilla's `EnvironmentAttributeSystem` from the data pack
(dimension attributes, one biome's attributes, the dimension timelines and the
weather layers) and prints every visual/gameplay attribute for a grid of
dimensions, world times, rain/thunder levels and biomes.
`examples/environment_fixture` samples the same cases through Horizon's
`Environment::sample` + `apply_weather`; every attribute Horizon computes must
agree with vanilla.
test_environment_render_parity.py [--tolerance EPS]
"""
import argparse
import json
import os
from pathlib import Path
import subprocess
import sys
try:
from . import lab, test_rust_parity as base, test_model_baking_parity as baking
except ImportError:
import lab, test_rust_parity as base, test_model_baking_parity as baking
def cases(resources):
biomes = sorted(p.stem for p in (resources / 'data/minecraft/worldgen/biome').glob('*.json'))
out = []
for dim in ['overworld', 'the_nether', 'the_end']:
for ticks in list(range(0, 48000, 250)) + [23999, 24001, 1234567]:
for rain, thunder in [(0, 0), (0.5, 0), (1, 0), (1, 1), (0.7, 0.3)] if dim == 'overworld' else [(0, 0)]:
out.append(f'{dim} {ticks} {rain} {thunder} plains')
own = {'the_nether': {'nether_wastes', 'soul_sand_valley', 'crimson_forest', 'warped_forest', 'basalt_deltas'},
'the_end': {'the_end', 'small_end_islands', 'end_midlands', 'end_highlands', 'end_barrens'}}
for dim in ['overworld', 'the_nether', 'the_end']:
for biome in biomes:
if dim in own and biome not in own[dim]:
continue
if dim == 'overworld' and any(biome in b for b in own.values()):
continue
for ticks in (0, 6000, 12500, 18000):
for rain, thunder in [(0, 0), (1, 0.4)] if dim == 'overworld' else [(0, 0)]:
out.append(f'{dim} {ticks} {rain} {thunder} {biome}')
return out
def main():
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument('--tolerance', type=float, default=2e-5)
args = parser.parse_args()
lock, jars, libraries = base.verify_artifacts()
build = lab.LOCAL / 'rust-environment-parity'; build.mkdir(parents=True, exist_ok=True)
resources = lab.LOCAL / 'horizon-client' / '26.3'
inputs = build / 'inputs.txt'; inputs.write_text('\n'.join(cases(resources)) + '\n')
classes = build / 'classes'; classes.mkdir(exist_ok=True)
oracle = lab.ROOT / 'mods/horizon/src/test/java/dev/horizonlab/parity/VanillaEnvironmentOracle.java'
deps = os.pathsep.join(map(str, libraries))
def run(command, name):
with (build / (name + '.log')).open('w') as log:
result = subprocess.run(list(map(str, command)), cwd=lab.ROOT, timeout=3600, stdout=log, stderr=subprocess.STDOUT)
if result.returncode:
print((build / (name + '.log')).read_text()[-4000:]); sys.exit(f'{name} failed')
run(['javac', '--release', lock['minecraft']['java_major'], '-proc:none', '-sourcepath', lab.ROOT / 'mods/horizon/src/test/java',
'-cp', str(jars['server']) + os.pathsep + deps, '-d', classes, oracle], 'compile-java')
run(['java', '-Xmx1G', '-cp', os.pathsep.join([str(classes), str(jars['server']), deps]),
'dev.horizonlab.parity.VanillaEnvironmentOracle', inputs, build / 'vanilla.jsonl'], 'vanilla')
run(['cargo', 'run', '--quiet', '--profile', 'fast', '-p', 'horizon-client', '--example', 'environment_fixture', '--',
resources, inputs, build / 'rust.jsonl'], 'rust')
vanilla = [json.loads(l) for l in (build / 'vanilla.jsonl').read_text().splitlines()]
rust = [json.loads(l) for l in (build / 'rust.jsonl').read_text().splitlines()]
assert len(vanilla) == len(rust), (len(vanilla), len(rust))
bad = {}
uncovered = set()
for v, r in zip(vanilla, rust):
for key, expected in v.items():
if key == 'case':
continue
if key not in r:
uncovered.add(key); continue
got = r[key]
pairs = zip(expected, got) if isinstance(expected, list) else [(expected, got)]
if any(abs(a - b) > args.tolerance * (1 + abs(a)) for a, b in pairs):
bad.setdefault(key, []).append((v['case'], expected, got))
print(f'{len(vanilla)} cases compared')
for key, items in sorted(bad.items()):
print(f'MISMATCH {key}: {len(items)} cases, e.g. {items[0]}')
if uncovered:
print('attributes Horizon does not model:', ', '.join(sorted(uncovered)))
if bad:
sys.exit(f'{len(bad)} attributes differ from vanilla')
print('environment parity ok')
if __name__ == '__main__':
main()