use bevy::prelude::*;
use crate::chunk::Chunk;
#[cfg(feature = "items")]
use crate::items::inventory::{ContainerComponent, PrimaryContainer};
#[cfg(feature = "items")]
use crate::items::{HotbarState, ItemType};
#[cfg(feature = "items")]
use crate::player::effects::AppliedEffectModifiers;
use crate::voxel::VoxelType;
use super::{ChunkManager, ChunkModified};
#[derive(Resource, Debug, Clone)]
pub struct MiningConfig {
pub break_time: f32,
}
impl Default for MiningConfig {
fn default() -> Self {
Self { break_time: 1.5 }
}
}
#[derive(Resource, Debug)]
pub struct MiningState {
pub target: Option<(IVec3, (usize, usize, usize))>,
pub elapsed: f32,
pub progress: f32,
pub(crate) effective_break_time: f32,
}
impl Default for MiningState {
fn default() -> Self {
Self {
target: None,
elapsed: 0.0,
progress: 0.0,
effective_break_time: 1.0,
}
}
}
#[cfg_attr(
feature = "items",
doc = "[`MiningInputPlugin`] keeps this resource up to date via `hotbar_to_tool_system`. Game code that calls [`tick_mining`] directly can read or override it as needed."
)]
#[cfg_attr(
not(feature = "items"),
doc = "Game code that calls [`tick_mining`] directly can read or override this resource as needed. The automatic input adapter requires the `items` feature."
)]
#[derive(Resource, Debug, Clone)]
pub struct ToolStats {
pub tool_level: u8,
pub tool_speed: f32,
}
impl ToolStats {
pub fn reset(&mut self) {
self.tool_level = 0;
self.tool_speed = 1.0;
}
}
impl Default for ToolStats {
fn default() -> Self {
Self {
tool_level: 0,
tool_speed: 1.0,
}
}
}
#[derive(Message, Debug, Clone)]
pub struct VoxelBroken {
pub chunk_coord: IVec3,
pub local: (usize, usize, usize),
pub world_pos: Vec3,
pub voxel_byte: u8,
}
#[derive(Message, Debug, Clone)]
pub struct MiningProgress {
pub progress: f32,
pub world_pos: Vec3,
}
fn break_voxel<V: VoxelType>(
world_voxel: IVec3,
manager: &ChunkManager,
chunks: &mut Query<&mut Chunk<V>>,
broken: &mut MessageWriter<VoxelBroken>,
modified: &mut MessageWriter<ChunkModified>,
) {
use crate::chunk::CHUNK_SIZE;
let cs = CHUNK_SIZE as i32;
let chunk_coord = IVec3::new(
world_voxel.x.div_euclid(cs),
world_voxel.y.div_euclid(cs),
world_voxel.z.div_euclid(cs),
);
let local = (
world_voxel.x.rem_euclid(cs) as usize,
world_voxel.y.rem_euclid(cs) as usize,
world_voxel.z.rem_euclid(cs) as usize,
);
let Some(entity) = manager.get_entity(chunk_coord) else {
return;
};
let Ok(mut chunk) = chunks.get_mut(entity) else {
return;
};
let voxel = chunk.get(local.0, local.1, local.2);
if !voxel.is_solid() {
return;
}
let voxel_byte = voxel.to_byte();
chunk.set(local.0, local.1, local.2, V::air());
drop(chunk);
let wp = voxel_world_pos(chunk_coord, local);
broken.write(VoxelBroken {
chunk_coord,
local,
world_pos: wp,
voxel_byte,
});
modified.write(ChunkModified(chunk_coord));
notify_border_neighbors(chunk_coord, local, modified);
}
fn quad_offsets(face_normal: Vec3, hit_point: Vec3, voxel_center: Vec3) -> [IVec3; 3] {
let sign = |coord: f32, center: f32| -> i32 { if coord >= center { 1 } else { -1 } };
let (du, dv) = if face_normal.x.abs() > 0.5 {
(
IVec3::new(0, sign(hit_point.y, voxel_center.y), 0),
IVec3::new(0, 0, sign(hit_point.z, voxel_center.z)),
)
} else if face_normal.y.abs() > 0.5 {
(
IVec3::new(sign(hit_point.x, voxel_center.x), 0, 0),
IVec3::new(0, 0, sign(hit_point.z, voxel_center.z)),
)
} else {
(
IVec3::new(sign(hit_point.x, voxel_center.x), 0, 0),
IVec3::new(0, sign(hit_point.y, voxel_center.y), 0),
)
};
[du, dv, du + dv]
}
fn notify_border_neighbors(
chunk_coord: IVec3,
local: (usize, usize, usize),
modified: &mut MessageWriter<ChunkModified>,
) {
use crate::chunk::CHUNK_SIZE;
let (x, y, z) = local;
let offsets: [(usize, IVec3); 6] = [
(x, IVec3::NEG_X),
(CHUNK_SIZE - 1 - x, IVec3::X),
(y, IVec3::NEG_Y),
(CHUNK_SIZE - 1 - y, IVec3::Y),
(z, IVec3::NEG_Z),
(CHUNK_SIZE - 1 - z, IVec3::Z),
];
for (dist, dir) in offsets {
if dist == 0 {
modified.write(ChunkModified(chunk_coord + dir));
}
}
}
fn voxel_world_pos(chunk_coord: IVec3, local: (usize, usize, usize)) -> Vec3 {
let chunk_origin = chunk_coord.as_vec3() * crate::chunk::CHUNK_SIZE as f32;
chunk_origin
+ Vec3::new(
local.0 as f32 + 0.5,
local.1 as f32 + 0.5,
local.2 as f32 + 0.5,
)
}
#[allow(clippy::too_many_arguments)]
pub fn tick_mining<V: VoxelType>(
target_chunk: IVec3,
target_local: (usize, usize, usize),
delta_secs: f32,
state: &mut MiningState,
config: &MiningConfig,
manager: &ChunkManager,
chunks: &mut Query<&mut Chunk<V>>,
broken: &mut MessageWriter<VoxelBroken>,
progress_writer: &mut MessageWriter<MiningProgress>,
modified: &mut MessageWriter<ChunkModified>,
) {
if state.target != Some((target_chunk, target_local)) {
let hardness = manager
.get_entity(target_chunk)
.and_then(|e| chunks.get(e).ok())
.map(|chunk| {
let (x, y, z) = target_local;
chunk.get(x, y, z).hardness()
})
.unwrap_or(1.0);
state.effective_break_time = if hardness > 0.0 {
config.break_time * hardness
} else {
f32::MAX
};
state.elapsed = 0.0;
state.progress = 0.0;
state.target = Some((target_chunk, target_local));
}
state.elapsed += delta_secs;
state.progress = (state.elapsed / state.effective_break_time).min(1.0);
let world_pos = voxel_world_pos(target_chunk, target_local);
progress_writer.write(MiningProgress {
progress: state.progress,
world_pos,
});
if state.progress >= 1.0 && state.effective_break_time < f32::MAX {
let mut voxel_byte = V::air().to_byte();
if let Some(entity) = manager.get_entity(target_chunk) {
if let Ok(mut chunk) = chunks.get_mut(entity) {
let (x, y, z) = target_local;
voxel_byte = chunk.get(x, y, z).to_byte();
chunk.set(x, y, z, V::air());
}
}
broken.write(VoxelBroken {
chunk_coord: target_chunk,
local: target_local,
world_pos,
voxel_byte,
});
modified.write(ChunkModified(target_chunk));
notify_border_neighbors(target_chunk, target_local, modified);
state.target = None;
state.elapsed = 0.0;
state.progress = 0.0;
}
}
pub fn stop_mining(state: &mut MiningState) {
state.target = None;
state.elapsed = 0.0;
state.progress = 0.0;
}
pub struct MiningPlugin;
impl Plugin for MiningPlugin {
fn build(&self, app: &mut App) {
app.init_resource::<MiningConfig>();
app.init_resource::<MiningState>();
app.add_message::<VoxelBroken>();
app.add_message::<MiningProgress>();
}
}
#[cfg(feature = "items")]
pub struct MiningInputPlugin<V: VoxelType, I: ItemType> {
_m: std::marker::PhantomData<(V, I)>,
}
#[cfg(feature = "items")]
impl<V: VoxelType, I: ItemType> MiningInputPlugin<V, I> {
pub fn new() -> Self {
Self {
_m: std::marker::PhantomData,
}
}
}
#[cfg(feature = "items")]
impl<V: VoxelType, I: ItemType> Default for MiningInputPlugin<V, I> {
fn default() -> Self {
Self::new()
}
}
#[cfg(feature = "items")]
impl<V: VoxelType, I: ItemType> Plugin for MiningInputPlugin<V, I> {
fn build(&self, app: &mut App) {
app.init_resource::<ToolStats>();
app.add_systems(
Update,
(hotbar_to_tool_system::<I>, mining_input_system::<V>).chain(),
);
}
}
#[cfg(feature = "items")]
pub fn hotbar_to_tool_system<I: ItemType>(
hotbar: Res<HotbarState>,
container_query: Query<&ContainerComponent<I>, With<PrimaryContainer>>,
mut tool_stats: ResMut<ToolStats>,
applied: Option<Res<AppliedEffectModifiers>>,
) {
let Ok(container) = container_query.single() else {
tool_stats.reset();
return;
};
let active_slot = hotbar.selected;
if let Some(slot) = container.0.slots.get(active_slot).and_then(|s| s.as_ref()) {
tool_stats.tool_level = slot.item.tool_level();
tool_stats.tool_speed = slot.item.tool_speed()
* applied
.as_deref()
.map(|a| a.0.mining_speed_mult)
.unwrap_or(1.0);
} else {
tool_stats.reset();
}
}
#[cfg_attr(feature = "items", doc = "System added by [`MiningInputPlugin`].")]
#[cfg_attr(
not(feature = "items"),
doc = "Mining input system; its automatic plugin adapter requires the `items` feature."
)]
#[cfg_attr(
feature = "items",
doc = "Added automatically by [`MiningInputPlugin`] — do not add this system manually when using that plugin."
)]
#[cfg_attr(
not(feature = "items"),
doc = "Without the `items` feature, add this system explicitly and initialize or supply [`ToolStats`] from game-owned code."
)]
pub fn mining_input_system<V: VoxelType>(
buttons: Res<ButtonInput<MouseButton>>,
camera_q: Query<&GlobalTransform, With<Camera3d>>,
manager: Res<ChunkManager>,
mut chunks: Query<&mut crate::chunk::Chunk<V>>,
mut state: ResMut<MiningState>,
config: Res<MiningConfig>,
tool_stats: Res<ToolStats>,
mut broken: MessageWriter<VoxelBroken>,
mut progress: MessageWriter<MiningProgress>,
mut modified: MessageWriter<ChunkModified>,
time: Res<Time>,
) {
if !buttons.pressed(MouseButton::Left) {
stop_mining(&mut state);
return;
}
let Ok(cam_tf) = camera_q.single() else {
return;
};
let origin = cam_tf.translation();
let direction = cam_tf.forward().as_vec3();
let mut lens = chunks.transmute_lens::<&crate::chunk::Chunk<V>>();
let Some(hit) = super::raycast::raycast(origin, direction, 6.0, &manager, &lens.query()) else {
stop_mining(&mut state);
return;
};
let voxel_mining_level = lens
.query()
.get(
manager
.get_entity(hit.chunk_coord)
.unwrap_or(Entity::PLACEHOLDER),
)
.map(|chunk| {
let (x, y, z) = hit.local;
chunk.get(x, y, z).mining_level()
})
.unwrap_or(0);
if tool_stats.tool_level < voxel_mining_level {
stop_mining(&mut state);
return;
}
let effective_delta = time.delta_secs() * tool_stats.tool_speed;
let was_mining = state.target.is_some();
tick_mining(
hit.chunk_coord,
hit.local,
effective_delta,
&mut state,
&config,
&manager,
&mut chunks,
&mut broken,
&mut progress,
&mut modified,
);
if was_mining && state.target.is_none() {
use crate::chunk::CHUNK_SIZE;
let cs = CHUNK_SIZE as i32;
let vx = hit.chunk_coord.x * cs + hit.local.0 as i32;
let vy = hit.chunk_coord.y * cs + hit.local.1 as i32;
let vz = hit.chunk_coord.z * cs + hit.local.2 as i32;
let primary = IVec3::new(vx, vy, vz);
let center = Vec3::new(vx as f32 + 0.5, vy as f32 + 0.5, vz as f32 + 0.5);
let hit_pt = origin + hit.distance * direction.normalize();
for offset in quad_offsets(hit.face_normal, hit_pt, center) {
break_voxel(
primary + offset,
&manager,
&mut chunks,
&mut broken,
&mut modified,
);
}
}
}
#[cfg(test)]
mod tests {
use super::*;
fn default_config() -> MiningConfig {
MiningConfig { break_time: 1.5 }
}
#[test]
fn stop_mining_resets_state() {
let mut state = MiningState {
target: Some((IVec3::ZERO, (1, 2, 3))),
elapsed: 0.8,
progress: 0.5,
effective_break_time: 1.0,
};
stop_mining(&mut state);
assert!(state.target.is_none());
assert_eq!(state.elapsed, 0.0);
assert_eq!(state.progress, 0.0);
}
#[test]
fn test_mining_progress_accumulates() {
let config = default_config();
let mut state = MiningState::default();
let target = (IVec3::ZERO, (0usize, 0usize, 0usize));
if state.target != Some(target) {
state.elapsed = 0.0;
state.progress = 0.0;
state.target = Some(target);
}
state.elapsed += 0.3;
state.progress = (state.elapsed / config.break_time).min(1.0);
assert!((state.elapsed - 0.3).abs() < f32::EPSILON);
state.elapsed += 0.4;
state.progress = (state.elapsed / config.break_time).min(1.0);
assert!((state.elapsed - 0.7).abs() < f32::EPSILON);
assert!(state.progress > 0.0 && state.progress < 1.0);
}
#[test]
fn test_mining_resets_on_target_change() {
let config = default_config();
let mut state = MiningState::default();
let target_a = (IVec3::ZERO, (0usize, 0usize, 0usize));
let target_b = (IVec3::ONE, (1usize, 1usize, 1usize));
state.target = Some(target_a);
state.elapsed += 0.5;
state.progress = (state.elapsed / config.break_time).min(1.0);
assert!(state.elapsed > 0.0);
if state.target != Some(target_b) {
state.elapsed = 0.0;
state.progress = 0.0;
state.target = Some(target_b);
}
assert_eq!(state.elapsed, 0.0);
assert_eq!(state.progress, 0.0);
assert_eq!(state.target, Some(target_b));
}
#[test]
fn test_mining_completes_at_break_time() {
let config = default_config();
let mut state = MiningState::default();
let target = (IVec3::ZERO, (0usize, 0usize, 0usize));
state.target = Some(target);
let mut completed = false;
let tick = 0.5_f32;
for _ in 0..10 {
state.elapsed += tick;
state.progress = (state.elapsed / config.break_time).min(1.0);
if state.progress >= 1.0 {
completed = true;
break;
}
}
assert!(completed, "mining should complete within 10 ticks of 0.5s");
assert_eq!(state.progress, 1.0);
}
#[test]
fn progress_is_clamped_to_one() {
let config = default_config();
let mut state = MiningState::default();
state.elapsed = 99.0;
state.progress = (state.elapsed / config.break_time).min(1.0);
assert_eq!(state.progress, 1.0);
}
fn compute_effective_break_time(break_time: f32, hardness: f32) -> f32 {
if hardness > 0.0 {
break_time * hardness
} else {
f32::MAX
}
}
fn gated_effective_delta(
delta: f32,
tool_level: u8,
tool_speed: f32,
voxel_mining_level: u8,
) -> Option<f32> {
if tool_level < voxel_mining_level {
None
} else {
Some(delta * tool_speed)
}
}
#[test]
fn hardness_zero_is_unbreakable() {
let config = default_config();
let hardness = 0.0;
let effective = compute_effective_break_time(config.break_time, hardness);
assert_eq!(effective, f32::MAX);
let mut state = MiningState {
target: Some((IVec3::ZERO, (0, 0, 0))),
elapsed: 0.0,
progress: 0.0,
effective_break_time: effective,
};
for _ in 0..1_000 {
state.elapsed += 10.0;
state.progress = (state.elapsed / state.effective_break_time).min(1.0);
}
assert!(state.progress < 1.0);
assert!(state.progress < f32::EPSILON * 1_000.0);
assert_eq!(state.effective_break_time, f32::MAX);
}
#[test]
fn hardness_scales_break_time() {
let break_time = 1.5_f32;
let hardness = 3.0_f32;
let effective = compute_effective_break_time(break_time, hardness);
assert!((effective - 4.5).abs() < f32::EPSILON);
}
#[test]
fn tool_level_below_mining_level_blocks_progress() {
let delta = gated_effective_delta(0.1, 1, 1.0, 2);
assert!(
delta.is_none(),
"tool_level=1 must not mine voxel with mining_level=2"
);
let mut state = MiningState {
target: Some((IVec3::ZERO, (0, 0, 0))),
elapsed: 0.4,
progress: 0.2,
effective_break_time: 1.5,
};
stop_mining(&mut state);
assert!(state.target.is_none());
assert_eq!(state.elapsed, 0.0);
assert_eq!(state.progress, 0.0);
}
#[test]
fn tool_level_meets_requirement_progresses() {
let config = default_config();
let delta = gated_effective_delta(0.1, 1, 1.0, 1)
.expect("tool_level=1 must satisfy mining_level=1 gate");
assert!((delta - 0.1).abs() < f32::EPSILON);
let hardness = 1.0_f32;
let effective = compute_effective_break_time(config.break_time, hardness);
let mut state = MiningState {
target: Some((IVec3::ZERO, (0, 0, 0))),
elapsed: 0.0,
progress: 0.0,
effective_break_time: effective,
};
for _ in 0..3 {
state.elapsed += delta;
state.progress = (state.elapsed / state.effective_break_time).min(1.0);
}
assert!(state.progress > 0.0);
assert!(state.progress < 1.0);
}
#[test]
fn tool_speed_scales_delta() {
let break_time = 1.5_f32;
let hardness = 1.0_f32;
let tool_speed = 2.0_f32;
let frame_delta = 0.1_f32;
let effective_delta = gated_effective_delta(frame_delta, 0, tool_speed, 0)
.expect("level-0 voxel is breakable by bare hands");
assert!(
(effective_delta - 0.2).abs() < f32::EPSILON,
"tool_speed=2.0 must double the per-call delta"
);
let effective_break_time = compute_effective_break_time(break_time, hardness);
let mut state = MiningState {
target: Some((IVec3::ZERO, (0, 0, 0))),
elapsed: 0.0,
progress: 0.0,
effective_break_time,
};
let frames_for_half_time = (0.75 / frame_delta).ceil() as usize;
for _ in 0..frames_for_half_time {
state.elapsed += effective_delta;
state.progress = (state.elapsed / state.effective_break_time).min(1.0);
}
assert!(
state.progress >= 1.0,
"tool_speed=2.0 must reach progress=1.0 at ~half the nominal break time \
(expected >=1.0, got {})",
state.progress
);
}
}