diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs index 3b0b27a61..c58dcefe0 100644 --- a/crates/horizon-client/src/game.rs +++ b/crates/horizon-client/src/game.rs @@ -7324,6 +7324,9 @@ impl Game<'_> { owner.is_selected = false; owner.is_carried = false; } + // The hand renderer's copy of the main hand stack. + owner.fishing_cast_with_this_item = + self.main_hand_rod() && self.cast_rod() == Some(&stack); let using = owner.using_this_item && owner.use_item_remaining_ticks > 0; let ticks_used = owner.use_duration as f32 - (owner.use_item_remaining_ticks as f32 - a + 1.0); @@ -8192,18 +8195,19 @@ impl Game<'_> { sky.sky_color = [0.9, 0.9, 1.0]; sky.sky_light_factor = 1.0; } - // DebugRenderer: chunk borders and hitboxes (F3+G, F3+B). - let (debug_lines, debug_lines_on_top) = if self.show_hitboxes || self.show_chunk_borders { + // FishingHookRenderer's line, then DebugRenderer: chunk borders and + // hitboxes (F3+G, F3+B). + let mut lines = self.fishing_line(alpha, size); + let mut on_top = Vec::new(); + if self.show_hitboxes || self.show_chunk_borders { let g = self.debug_gizmos(alpha as f32); - let view = horizon_client::camera::view_matrix(view_yaw, view_pitch); - let at = camera.to_array(); - ( - horizon_client::gizmos::camera_relative(&g.lines, at, view), - horizon_client::gizmos::camera_relative(&g.on_top, at, view), - ) - } else { - (Vec::new(), Vec::new()) - }; + lines.extend(g.lines); + on_top = g.on_top; + } + let view = horizon_client::camera::view_matrix(view_yaw, view_pitch); + let at = camera.to_array(); + let debug_lines = horizon_client::gizmos::camera_relative(&lines, at, view); + let debug_lines_on_top = horizon_client::gizmos::camera_relative(&on_top, at, view); // LevelRenderer.renderHitOutline: the outline shape's edges. let outline = if self.screen == Screen::Playing && !self.spectator() { self.pick() diff --git a/crates/horizon-client/src/game/fishing.rs b/crates/horizon-client/src/game/fishing.rs index 8285dcf72..eb7a54f99 100644 --- a/crates/horizon-client/src/game/fishing.rs +++ b/crates/horizon-client/src/game/fishing.rs @@ -3,10 +3,16 @@ //! `gameplay/fishing` loot) and `FishingHookRenderer` (bobber and line). use super::{Game, view_vector}; use horizon_client::{ - blocks::Fluid, collisions::SceneCollisions, items::ItemStack, mesher::Vertex, + blocks::Fluid, + collisions::SceneCollisions, + gizmos::Line, + items::ItemStack, + mesher::Vertex, + particles::{ParticleOptions, ParticleType}, + pose::Pose, }; use horizon_core::{ - geometry::{Aabb, Vec3}, + geometry::{Aabb, Vec3, trig}, random::RandomSource, }; use std::sync::Arc; @@ -302,7 +308,29 @@ impl Game<'_> { } else if h.time_until_hooked > 0 { h.time_until_hooked -= speed; if h.time_until_hooked > 0 { + // The fish swimming up: a bubble now and then, and a fishing + // particle to each side of its path. h.fish_angle += triangle(&mut self.world.random, 0.0, 9.188) as f32; + let angle = h.fish_angle * (std::f64::consts::PI / 180.0) as f32; + let (sin, cos) = (trig::sin(f64::from(angle)), trig::cos(f64::from(angle))); + let distance = h.time_until_hooked as f32 * 0.1; + let fish = [ + h.position.x + f64::from(sin * distance), + f64::from(h.position.y.floor() as f32 + 1.0), + h.position.z + f64::from(cos * distance), + ]; + if self.water_block(fish) { + if self.world.random.next_float() < 0.15 { + let spread = [f64::from(sin), 0.1, f64::from(cos)]; + let at = [fish[0], fish[1] - f64::from(0.1f32), fish[2]]; + self.send_particles(ParticleType::Bubble, at, spread, 0.0, 1); + } + let (x, z) = (sin * 0.04, cos * 0.04); + for side in [1.0f32, -1.0] { + let spread = [f64::from(z * side), 0.01, f64::from(-x * side)]; + self.send_particles(ParticleType::Fishing, fish, spread, 1.0, 0); + } + } } else { let pitch = 1.0 + (self.world.random.next_float() - self.world.random.next_float()) * 0.4; @@ -312,6 +340,13 @@ impl Game<'_> { 0.25, pitch, ); + // The bite: bubbles and fishing particles around the bobber. + let at = [h.position.x, h.position.y + 0.5, h.position.z]; + let count = (1.0 + SIZE as f32 * 20.0) as u32; + let spread = [SIZE, 0.0, SIZE]; + for kind in [ParticleType::Bubble, ParticleType::Fishing] { + self.send_particles(kind, at, spread, f64::from(0.2f32), count); + } h.nibble = 20 + self.world.random.next_int_bound(21).unwrap_or(0); } } else if h.time_until_lured > 0 { @@ -326,8 +361,19 @@ impl Game<'_> { } let r = &mut self.world.random; if r.next_float() < tease { - // The fish particle draws: angle and distance. - let _ = (r.next_float(), r.next_float()); + // A splash where a fish is teasing the bait. + let angle = (r.next_float() * 360.0) * (std::f64::consts::PI / 180.0) as f32; + let distance = r.next_float() * 35.0 + 25.0; + let fish = [ + h.position.x + f64::from(trig::sin(f64::from(angle)) * distance) * 0.1, + f64::from(h.position.y.floor() as f32 + 1.0), + h.position.z + f64::from(trig::cos(f64::from(angle)) * distance) * 0.1, + ]; + if self.water_block(fish) { + let count = 2 + self.world.random.next_int_bound(2).unwrap_or(0) as u32; + let spread = [f64::from(0.1f32), 0.0, f64::from(0.1f32)]; + self.send_particles(ParticleType::Splash, fish, spread, 0.0, count); + } } if h.time_until_lured <= 0 { h.fish_angle = self.world.random.next_float() * 360.0; @@ -337,6 +383,28 @@ impl Game<'_> { h.time_until_lured = 100 + self.world.random.next_int_bound(501).unwrap_or(0) - h.lure; } } + /// `catchingFish`'s check below a fish: the block under it is water. + fn water_block(&self, fish: [f64; 3]) -> bool { + let state = self.world.block( + fish[0].floor() as i32, + (fish[1] - 1.0).floor() as i32, + fish[2].floor() as i32, + ); + &*self.res.facts.get(state).name == "minecraft:water" + } + /// `ServerLevel.sendParticles` of a simple particle. + fn send_particles( + &mut self, + kind: ParticleType, + at: [f64; 3], + spread: [f64; 3], + speed: f64, + count: u32, + ) { + let options = ParticleOptions::simple(kind); + self.particles + .send_particles(&options, at, spread, speed, count); + } /// `FishingHook.tick`. pub(super) fn tick_fishing(&mut self) { let Some(mut h) = self.hook.take() else { @@ -466,16 +534,45 @@ impl Game<'_> { ); self.hook = Some(h); } - /// FishingHookRenderer: the bobber billboard and the line to the rod. - pub(super) fn fishing_geometry(&self, camera: glam::DVec3, alpha: f64, out: &mut Vec) { - let Some(h) = &self.hook else { return }; - let atlas = &self.res.atlas; + /// `FishingRodCast`: the stack in the arm holding the rod + /// (`FishingHookRenderer.getHoldingArm`) while the hook is out. + pub(super) fn cast_rod(&self) -> Option<&ItemStack> { + self.hook.as_ref()?; + if self.main_hand_rod() { + self.held() + } else { + self.offhand.as_ref() + } + } + pub(super) fn main_hand_rod(&self) -> bool { + self.held() + .is_some_and(|s| &*s.item == "minecraft:fishing_rod") + } + /// The hook's position this frame. + fn hook_position(&self, alpha: f64) -> Option { + let h = self.hook.as_ref()?; let lerp = |a: f64, b: f64| a + (b - a) * alpha; - let p = glam::DVec3::new( + Some(glam::DVec3::new( lerp(h.previous.x, h.position.x), lerp(h.previous.y, h.position.y), lerp(h.previous.z, h.position.z), - ); + )) + } + /// FishingHookRenderer: the bobber, a camera-facing half-block quad + /// centred on the hook. + pub(super) fn fishing_geometry(&self, camera: glam::DVec3, alpha: f64, out: &mut Vec) { + let Some(p) = self.hook_position(alpha) else { + return; + }; + let Some(r) = self + .res + .atlas + .sprites + .get("entity/fishing/fishing_hook") + .copied() + else { + return; + }; let light = self .world .light(p.x.floor() as i32, p.y.floor() as i32, p.z.floor() as i32); @@ -483,52 +580,112 @@ impl Game<'_> { let forward = glam::DVec3::from_array(view_vector(self.yaw, self.pitch)); let right = forward.cross(glam::DVec3::Y).normalize_or_zero(); let up = right.cross(forward).normalize_or_zero(); - let mut quad = |c: [glam::DVec3; 4], uv: [[f32; 2]; 4], color: u32| { - for (v, uv) in c.iter().zip(uv) { - out.push(Vertex { - normal: [0; 4], - pos: (*v - camera).as_vec3().to_array(), - uv, - layer: 0, - color, - light: packed, - }); - } - }; - if let Some(r) = atlas.sprites.get("entity/fishing/fishing_hook").copied() { - let c = p + glam::DVec3::new(0.0, SIZE / 2.0, 0.0); - let s = 0.25; - quad( - [ - c - right * s - up * s, - c + right * s - up * s, - c + right * s + up * s, - c - right * s + up * s, - ], - [[r.u0, r.v1], [r.u1, r.v1], [r.u1, r.v0], [r.u0, r.v0]], - 0xFFFF_FFFF, - ); + let s = 0.25; + let corners = [ + p - right * s - up * s, + p + right * s - up * s, + p + right * s + up * s, + p - right * s + up * s, + ]; + let uv = [[r.u0, r.v1], [r.u1, r.v1], [r.u1, r.v0], [r.u0, r.v0]]; + for (v, uv) in corners.iter().zip(uv) { + out.push(Vertex { + normal: [0; 4], + pos: (*v - camera).as_vec3().to_array(), + uv, + layer: 0, + color: 0xFFFF_FFFF, + light: packed, + }); } - // The line: 16 segments sagging from the rod tip to the bobber. - let Some(eye) = self.eye_position() else { - return; + } + /// FishingHookRenderer: the line, 16 black `lines` segments sagging from + /// a quarter block above the hook to the rod in the player's hand, + /// `width` pixels wide (`Window.getAppropriateLineWidth`). + pub(super) fn fishing_line(&self, alpha: f64, size: [u32; 2]) -> Vec { + let (Some(hook), Some(hand)) = ( + self.hook_position(alpha), + self.rod_hand_position(alpha, size), + ) else { + return Vec::new(); }; - let tip = glam::DVec3::from_array(eye) + forward * 0.6 + right * 0.35 - up * 0.25; - let end = p + glam::DVec3::new(0.0, SIZE * 0.7, 0.0); - let w = atlas.font.white(); - let uv = [[w.u0, w.v1], [w.u1, w.v1], [w.u1, w.v0], [w.u0, w.v0]]; - let point = |t: f64| { - let d = end - tip; - tip + glam::DVec3::new( - d.x * t, - d.y * (t * t + t) * 0.5 + 0.25 * t * (1.0 - t), - d.z * t, + let offset = (hand - (hook + glam::DVec3::new(0.0, 0.25, 0.0))).as_vec3(); + let point = |a: f32| { + let y = offset.y * (a * a + a) * 0.5 + 0.25; + hook + glam::Vec3::new(offset.x * a, y, offset.z * a).as_dvec3() + }; + let width = horizon_client::gfx::outline_width(size[0]); + (0..16) + .map(|i| Line { + start: point(i as f32 / 16.0).to_array(), + end: point((i + 1) as f32 / 16.0).to_array(), + color: 0xFF00_0000, + width, + }) + .collect() + } + /// `FishingHookRenderer.getPlayerHandPos`: on the near plane in first + /// person, beside the body otherwise. + fn rod_hand_position(&self, alpha: f64, size: [u32; 2]) -> Option { + let p = self.player.as_ref()?; + let right_arm = self.main_hand_rod() != self.settings.main_hand_left; + let invert: f32 = if right_arm { 1.0 } else { -1.0 }; + let swing = trig::sin(f64::from( + self.swing.animation(alpha as f32).sqrt() * std::f32::consts::PI, + )); + let feet = self.previous_position.lerp(p.position, alpha); + let eye = glam::DVec3::new(feet.x, feet.y + f64::from(p.dimensions.eye_height), feet.z); + if self.camera_type.first_person() { + let fov = self.settings.fov as i32 as f32; + // Camera.getNearPlane(fov).getPointOnPlane(invert * 0.525, -0.1). + let aspect = f64::from(size[0]) / f64::from(size[1].max(1)); + let height = + (f64::from(fov * (std::f64::consts::PI / 180.0) as f32) / 2.0).tan() * 0.05; + let forward = glam::DVec3::from_array(view_vector(self.yaw, self.pitch)); + let left = -forward.cross(glam::DVec3::Y).normalize_or_zero(); + let up = forward.cross(left).normalize_or_zero(); + let point = forward * 0.05 + up * (height * -0.1) + - left * (height * aspect * f64::from(invert * 0.525)); + let point = point * (960.0 / f64::from(fov)); + // Vec3.yRot(swing * 0.5), then xRot(-swing * 0.7). + let (s, c) = ( + f64::from(trig::sin(f64::from(swing * 0.5))), + f64::from(trig::cos(f64::from(swing * 0.5))), + ); + let point = glam::DVec3::new( + point.x * c + point.z * s, + point.y, + point.z * c - point.x * s, + ); + let (s, c) = ( + f64::from(trig::sin(f64::from(-swing * 0.7))), + f64::from(trig::cos(f64::from(-swing * 0.7))), + ); + let point = glam::DVec3::new( + point.x, + point.y * c + point.z * s, + point.z * c - point.y * s, + ); + Some(eye + point) + } else { + let model = self.player_model.as_ref()?; + let body = + horizon_client::camera::lerp(alpha as f32, model.previous_body_yaw, model.body_yaw); + let angle = f64::from(body * (std::f64::consts::PI / 180.0) as f32); + let (sin, cos) = (f64::from(trig::sin(angle)), f64::from(trig::cos(angle))); + let right = f64::from(invert) * 0.35; + let crouch = if p.pose == Pose::Crouching { + -0.1875 + } else { + 0.0 + }; + Some( + eye + glam::DVec3::new( + -cos * right - sin * 0.8, + crouch - 0.45, + -sin * right + cos * 0.8, + ), ) - }; - for i in 0..16 { - let (a, b) = (point(f64::from(i) / 16.0), point(f64::from(i + 1) / 16.0)); - let side = (b - a).cross(forward).normalize_or_zero() * 0.0125; - quad([a - side, b - side, b + side, a + side], uv, 0xFF00_0000); } } } diff --git a/crates/horizon-client/src/game/item_draw.rs b/crates/horizon-client/src/game/item_draw.rs index c1c46ade9..664455be7 100644 --- a/crates/horizon-client/src/game/item_draw.rs +++ b/crates/horizon-client/src/game/item_draw.rs @@ -222,6 +222,9 @@ impl Game<'_> { owner.use_item_remaining_ticks = duration - ticks as i32; owner.crossbow_charge_duration = Self::charge_ticks(stack).max(1) as i32; } + owner.fishing_cast_with_this_item = stack + .zip(self.cast_rod()) + .is_some_and(|(s, rod)| std::ptr::eq(s, rod)); owner.is_selected = stack.is_some() && self.inventory.get(self.selected).and_then(Option::as_ref) == stack; owner.is_carried = owner.is_selected; diff --git a/crates/horizon-client/src/game/mob_blocks.rs b/crates/horizon-client/src/game/mob_blocks.rs index 1e5942ef1..3506e6c84 100644 --- a/crates/horizon-client/src/game/mob_blocks.rs +++ b/crates/horizon-client/src/game/mob_blocks.rs @@ -282,6 +282,13 @@ impl Game<'_> { mob.body_yaw, &mob.kind.id, ); + // The local player's rod while its hook is out. + owner.fishing_cast_with_this_item = self.cast_rod().is_some() + && self.main_hand_rod() != left + && self + .player_model + .as_ref() + .is_some_and(|p| std::ptr::eq(p, mob)); if !left && mob.extra.using_item > 0 { owner.using_this_item = true; owner.use_duration = 72_000; diff --git a/crates/horizon-client/src/gfx.rs b/crates/horizon-client/src/gfx.rs index 22ed8c661..8b7f26125 100644 --- a/crates/horizon-client/src/gfx.rs +++ b/crates/horizon-client/src/gfx.rs @@ -129,8 +129,9 @@ pub struct Frame<'a> { pub dark_disc: bool, /// The hit block outline as line segments (from, to) in world space. pub outline: Vec<[f64; 6]>, - /// Debug gizmo lines (`gizmos::camera_relative`): depth tested, then - /// drawn over everything. + /// `lines` with a colour and pixel width (`gizmos::camera_relative`): + /// the fishing line and debug gizmos, depth tested, then gizmos drawn + /// over everything. pub debug_lines: &'a [[f32; 8]], pub debug_lines_on_top: &'a [[f32; 8]], pub hud: &'a HudBatch,