use std::collections::HashMap;
use std::marker::PhantomData;
use bevy::prelude::*;
use crate::world::VoxelBroken;
use super::inventory::{ContainerComponent, ItemPickedUp, ItemType, PrimaryContainer};
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct DropTableEntry<I: ItemType> {
pub item: I,
pub min_count: u32,
pub max_count: u32,
pub chance: f32,
}
impl<I: ItemType> DropTableEntry<I> {
pub fn new(item: I, min_count: u32, max_count: u32) -> Self {
Self::with_chance(item, min_count, max_count, 1.0)
}
pub fn with_chance(item: I, min_count: u32, max_count: u32, chance: f32) -> Self {
Self {
item,
min_count: min_count.min(max_count),
max_count: min_count.max(max_count),
chance: chance.clamp(0.0, 1.0),
}
}
}
#[derive(Resource, Debug, Clone)]
pub struct DropTable<I: ItemType> {
entries: HashMap<u8, Vec<DropTableEntry<I>>>,
}
impl<I: ItemType> DropTable<I> {
pub fn new() -> Self {
Self {
entries: HashMap::new(),
}
}
pub fn register(&mut self, voxel_byte: u8, item: I, min: u32, max: u32) {
self.replace_entries(voxel_byte, [DropTableEntry::new(item, min, max)]);
}
pub fn register_with_chance(
&mut self,
voxel_byte: u8,
item: I,
min: u32,
max: u32,
chance: f32,
) {
self.replace_entries(
voxel_byte,
[DropTableEntry::with_chance(item, min, max, chance)],
);
}
pub fn add_entry(&mut self, voxel_byte: u8, entry: DropTableEntry<I>) {
self.entries.entry(voxel_byte).or_default().push(entry);
}
pub fn replace_entries(
&mut self,
voxel_byte: u8,
entries: impl IntoIterator<Item = DropTableEntry<I>>,
) {
self.entries
.insert(voxel_byte, entries.into_iter().collect());
}
pub fn iter_entries(&self) -> impl Iterator<Item = (u8, I, u32, u32)> + '_ {
self.iter_drop_entries()
.map(|(voxel_byte, entry)| (voxel_byte, entry.item, entry.min_count, entry.max_count))
}
pub fn iter_drop_entries(&self) -> impl Iterator<Item = (u8, &DropTableEntry<I>)> + '_ {
self.entries
.iter()
.flat_map(|(&voxel_byte, entries)| entries.iter().map(move |entry| (voxel_byte, entry)))
}
pub fn get_drop(&self, voxel_byte: u8, seed: u64) -> Option<(I, u32)> {
self.get_drops(voxel_byte, seed).into_iter().next()
}
pub fn get_drops(&self, voxel_byte: u8, seed: u64) -> Vec<(I, u32)> {
if let Some(entries) = self.entries.get(&voxel_byte) {
return entries
.iter()
.enumerate()
.filter_map(|(index, entry)| entry.roll(seed, index as u64))
.collect();
}
let item = I::from_byte(voxel_byte);
if !item.is_empty() {
vec![(item, 1)]
} else {
Vec::new()
}
}
}
impl<I: ItemType> DropTableEntry<I> {
fn roll(&self, seed: u64, salt: u64) -> Option<(I, u32)> {
if self.item.is_empty() || self.max_count == 0 || self.chance <= 0.0 {
return None;
}
let chance_roll = unit_interval(seed, salt);
if chance_roll > self.chance {
return None;
}
let count = if self.min_count == self.max_count {
self.min_count
} else {
let range = (self.max_count - self.min_count + 1) as u64;
self.min_count + (lcg(seed, salt.wrapping_add(1)) % range) as u32
};
(count > 0).then_some((self.item, count))
}
}
fn lcg(seed: u64, salt: u64) -> u64 {
seed.wrapping_add(salt.wrapping_mul(0x9E37_79B9_7F4A_7C15))
.wrapping_mul(6364136223846793005)
.wrapping_add(1442695040888963407)
}
fn unit_interval(seed: u64, salt: u64) -> f32 {
let value = lcg(seed, salt) >> 40;
value as f32 / ((1u64 << 24) - 1) as f32
}
impl<I: ItemType> Default for DropTable<I> {
fn default() -> Self {
Self::new()
}
}
#[derive(Resource, Debug, Clone)]
pub struct MagnetConfig {
pub radius: f32,
pub force: f32,
}
impl Default for MagnetConfig {
fn default() -> Self {
Self {
radius: 4.0,
force: 8.0,
}
}
}
#[derive(Component, Debug, Clone)]
pub struct DroppedItem<I: ItemType> {
pub item: I,
pub count: u32,
pub velocity: Vec3,
pub lifetime: f32,
}
#[derive(Component, Default)]
pub struct ItemCollector;
fn spawn_drops_system<I: ItemType>(
mut broken_reader: MessageReader<VoxelBroken>,
drop_table: Res<DropTable<I>>,
mut commands: Commands,
) {
for event in broken_reader.read() {
let seed = {
let x = event.world_pos.x.to_bits() as u64;
let y = event.world_pos.y.to_bits() as u64;
let z = event.world_pos.z.to_bits() as u64;
x.wrapping_mul(1000003)
.wrapping_add(y.wrapping_mul(1000033))
.wrapping_add(z)
};
for (item, count) in drop_table.get_drops(event.voxel_byte, seed) {
commands.spawn((
DroppedItem {
item,
count,
velocity: Vec3::new(0.0, 2.0, 0.0),
lifetime: 60.0,
},
Transform::from_translation(event.world_pos),
));
}
}
}
fn magnet_system<I: ItemType>(
time: Res<Time>,
config: Res<MagnetConfig>,
collector_query: Query<&Transform, (With<ItemCollector>, Without<DroppedItem<I>>)>,
mut item_query: Query<(Entity, &mut DroppedItem<I>, Option<&mut Transform>)>,
mut container_query: Query<&mut ContainerComponent<I>, With<PrimaryContainer>>,
mut pickup_writer: MessageWriter<ItemPickedUp<I>>,
mut commands: Commands,
) {
let Ok(collector_transform) = collector_query.single() else {
return;
};
let collector_pos = collector_transform.translation;
let dt = time.delta_secs();
for (entity, mut dropped, transform_opt) in item_query.iter_mut() {
dropped.lifetime -= dt;
if dropped.lifetime <= 0.0 {
commands.entity(entity).despawn();
continue;
}
let Some(mut transform) = transform_opt else {
continue;
};
let item_pos = transform.translation;
let diff = collector_pos - item_pos;
let dist = diff.length();
if dist < 0.5 {
let Ok(mut container) = container_query.single_mut() else {
continue;
};
let added = dropped.count - container.0.add(dropped.item, dropped.count);
if added == 0 {
continue;
}
dropped.count -= added;
pickup_writer.write(ItemPickedUp {
item: dropped.item,
count: added,
});
if dropped.count == 0 {
commands.entity(entity).despawn();
}
continue;
} else if dist < config.radius {
let dir = diff / dist;
dropped.velocity += dir * config.force * dt;
}
transform.translation += dropped.velocity * dt;
}
}
pub struct DropsPlugin<I: ItemType> {
_marker: PhantomData<I>,
}
impl<I: ItemType> DropsPlugin<I> {
pub fn new() -> Self {
Self {
_marker: PhantomData,
}
}
}
impl<I: ItemType> Default for DropsPlugin<I> {
fn default() -> Self {
Self::new()
}
}
impl<I: ItemType> Plugin for DropsPlugin<I> {
fn build(&self, app: &mut App) {
app.init_resource::<DropTable<I>>();
app.init_resource::<MagnetConfig>();
app.add_message::<ItemPickedUp<I>>();
app.add_systems(Update, spawn_drops_system::<I>);
app.add_systems(Update, magnet_system::<I>);
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::items::DefaultItem;
#[test]
fn broken_voxel_spawns_one_mapped_drop_at_world_position() {
let mut app = App::new();
app.init_resource::<Time>()
.add_message::<VoxelBroken>()
.add_plugins(DropsPlugin::<DefaultItem>::new());
app.world_mut()
.resource_mut::<DropTable<DefaultItem>>()
.register(1, DefaultItem::RockFragment, 1, 1);
let position = Vec3::new(18.5, -12.5, 36.5);
app.world_mut().write_message(VoxelBroken {
chunk_coord: IVec3::new(1, -1, 2),
local: (2, 3, 4),
world_pos: position,
voxel_byte: 1,
});
app.update();
let world = app.world_mut();
let mut query = world.query::<(&DroppedItem<DefaultItem>, Option<&Transform>)>();
let drops: Vec<_> = query.iter(world).collect();
assert_eq!(drops.len(), 1);
assert_eq!(drops[0].0.item, DefaultItem::RockFragment);
assert_eq!(drops[0].0.count, 1);
assert_eq!(
drops[0]
.1
.expect("spawned drop must have a world position")
.translation,
position
);
}
#[test]
fn nearby_drop_moves_and_is_collected_once_without_attracting_distant_drop() {
let mut app = App::new();
app.init_resource::<Time>()
.add_message::<VoxelBroken>()
.add_plugins(DropsPlugin::<DefaultItem>::new());
let player = app
.world_mut()
.spawn((
Transform::default(),
ItemCollector,
PrimaryContainer,
ContainerComponent::<DefaultItem>::new(9),
))
.id();
let spawn_drop = |world: &mut World, position| {
world
.spawn((
DroppedItem {
item: DefaultItem::RockFragment,
count: 1,
velocity: Vec3::ZERO,
lifetime: 60.0,
},
Transform::from_translation(position),
))
.id()
};
let nearby = spawn_drop(app.world_mut(), Vec3::new(2.0, 0.0, 0.0));
let distant_position = Vec3::new(8.0, 0.0, 0.0);
let distant = spawn_drop(app.world_mut(), distant_position);
app.world_mut()
.resource_mut::<Time>()
.advance_by(std::time::Duration::from_millis(100));
app.update();
assert!(
app.world()
.get::<Transform>(nearby)
.unwrap()
.translation
.length()
< 2.0,
"nearby drop must move toward the collector"
);
let mut pickups = Vec::new();
for _ in 0..30 {
app.world_mut()
.resource_mut::<Time>()
.advance_by(std::time::Duration::from_millis(100));
app.update();
pickups.extend(
app.world_mut()
.resource_mut::<Messages<ItemPickedUp<DefaultItem>>>()
.drain(),
);
}
assert!(app.world().get_entity(nearby).is_err());
assert_eq!(
app.world()
.get::<ContainerComponent<DefaultItem>>(player)
.unwrap()
.0
.count_of(DefaultItem::RockFragment),
1
);
assert_eq!(pickups.len(), 1);
assert_eq!(pickups[0].item, DefaultItem::RockFragment);
assert_eq!(pickups[0].count, 1);
assert_eq!(
app.world().get::<Transform>(distant).unwrap().translation,
distant_position
);
assert_eq!(
app.world()
.get::<DroppedItem<DefaultItem>>(distant)
.unwrap()
.velocity,
Vec3::ZERO
);
}
#[test]
fn partial_pickup_retains_remainder_until_inventory_has_room() {
let mut app = App::new();
app.init_resource::<Time>()
.add_message::<VoxelBroken>()
.add_plugins(DropsPlugin::<DefaultItem>::new());
let item = DefaultItem::RockFragment;
let mut container = ContainerComponent::<DefaultItem>::new(1);
assert_eq!(container.0.add(item, u32::MAX - 1), 0);
let player = app
.world_mut()
.spawn((
Transform::default(),
ItemCollector,
PrimaryContainer,
container,
))
.id();
let drop = app
.world_mut()
.spawn((
DroppedItem {
item,
count: 3,
velocity: Vec3::ZERO,
lifetime: 60.0,
},
Transform::from_xyz(0.25, 0.0, 0.0),
))
.id();
for expected_pickup in [1, 0, 2] {
if expected_pickup == 2 {
assert_eq!(
app.world_mut()
.get_mut::<ContainerComponent<DefaultItem>>(player)
.unwrap()
.0
.remove(item, 2),
2
);
}
app.update();
assert_eq!(
app.world()
.get::<ContainerComponent<DefaultItem>>(player)
.unwrap()
.0
.count_of(item),
u32::MAX
);
if expected_pickup == 2 {
assert!(app.world().get_entity(drop).is_err());
} else {
let retained = app
.world()
.get::<DroppedItem<DefaultItem>>(drop)
.expect("partial pickup must preserve the remainder");
assert_eq!(retained.item, item);
assert_eq!(retained.count, 2);
}
let pickups: Vec<_> = app
.world_mut()
.resource_mut::<Messages<ItemPickedUp<DefaultItem>>>()
.drain()
.collect();
if expected_pickup == 0 {
assert!(pickups.is_empty());
} else {
assert_eq!(pickups.len(), 1);
assert_eq!(pickups[0].item, item);
assert_eq!(pickups[0].count, expected_pickup);
}
}
}
#[test]
fn full_inventory_retains_drop_without_reporting_pickup() {
let mut app = App::new();
app.init_resource::<Time>()
.add_message::<VoxelBroken>()
.add_plugins(DropsPlugin::<DefaultItem>::new());
let mut container = ContainerComponent::<DefaultItem>::new(1);
assert_eq!(container.0.add(DefaultItem::IronOre, 1), 0);
let player = app
.world_mut()
.spawn((
Transform::default(),
ItemCollector,
PrimaryContainer,
container,
))
.id();
let drop = app
.world_mut()
.spawn((
DroppedItem {
item: DefaultItem::RockFragment,
count: 3,
velocity: Vec3::ZERO,
lifetime: 60.0,
},
Transform::from_xyz(0.25, 0.0, 0.0),
))
.id();
for _ in 0..3 {
app.world_mut()
.resource_mut::<Time>()
.advance_by(std::time::Duration::from_millis(100));
app.update();
let retained = app
.world()
.get::<DroppedItem<DefaultItem>>(drop)
.expect("full inventory must retain the unaccepted drop");
assert_eq!(retained.item, DefaultItem::RockFragment);
assert_eq!(retained.count, 3);
let inventory = &app
.world()
.get::<ContainerComponent<DefaultItem>>(player)
.unwrap()
.0;
assert_eq!(inventory.count_of(DefaultItem::IronOre), 1);
assert_eq!(inventory.count_of(DefaultItem::RockFragment), 0);
assert_eq!(
app.world_mut()
.resource_mut::<Messages<ItemPickedUp<DefaultItem>>>()
.drain()
.count(),
0
);
}
}
#[test]
fn test_drop_table_get_drop() {
let mut table = DropTable::<DefaultItem>::new();
table.register(1, DefaultItem::RockFragment, 1, 3);
let result = table.get_drop(1, 0);
assert!(result.is_some());
let (item, count) = result.unwrap();
assert_eq!(item, DefaultItem::RockFragment);
assert!((1..=3).contains(&count));
}
#[test]
fn test_drop_table_no_entry_returns_none() {
let table = DropTable::<DefaultItem>::new();
assert!(table.get_drop(99, 42).is_none());
}
#[test]
fn test_drop_table_fixed_count() {
let mut table = DropTable::<DefaultItem>::new();
table.register(2, DefaultItem::IronOre, 5, 5);
let (_, count) = table.get_drop(2, 12345).unwrap();
assert_eq!(count, 5);
}
#[test]
fn test_drop_table_identity_fallback_with_other_entries() {
let mut table = DropTable::<DefaultItem>::new();
table.register(2, DefaultItem::Dirt, 1, 1);
let (item, count) = table.get_drop(11, 0).unwrap();
assert_eq!(item, DefaultItem::IronOre);
assert_eq!(count, 1);
}
#[test]
fn drop_table_supports_multiple_runtime_entries() {
let mut table = DropTable::<DefaultItem>::new();
table.add_entry(3, DropTableEntry::new(DefaultItem::Cobblestone, 1, 1));
table.add_entry(3, DropTableEntry::new(DefaultItem::Coal, 2, 2));
let drops = table.get_drops(3, 123);
assert_eq!(drops.len(), 2);
assert_eq!(drops[0], (DefaultItem::Cobblestone, 1));
assert_eq!(drops[1], (DefaultItem::Coal, 2));
}
#[test]
fn register_preserves_single_entry_replacement_behavior() {
let mut table = DropTable::<DefaultItem>::new();
table.add_entry(3, DropTableEntry::new(DefaultItem::Cobblestone, 1, 1));
table.add_entry(3, DropTableEntry::new(DefaultItem::Coal, 1, 1));
table.register(3, DefaultItem::IronOre, 1, 1);
let drops = table.get_drops(3, 0);
assert_eq!(drops, vec![(DefaultItem::IronOre, 1)]);
}
#[test]
fn drop_table_entry_chance_can_disable_a_drop() {
let mut table = DropTable::<DefaultItem>::new();
table.add_entry(
3,
DropTableEntry::with_chance(DefaultItem::Cobblestone, 1, 1, 0.0),
);
table.add_entry(3, DropTableEntry::with_chance(DefaultItem::Coal, 1, 1, 1.0));
let drops = table.get_drops(3, 0);
assert_eq!(drops, vec![(DefaultItem::Coal, 1)]);
}
#[test]
fn iter_drop_entries_includes_chance_metadata() {
let mut table = DropTable::<DefaultItem>::new();
table.register_with_chance(3, DefaultItem::Cobblestone, 1, 2, 0.25);
let entries: Vec<_> = table.iter_drop_entries().collect();
assert_eq!(entries.len(), 1);
assert_eq!(entries[0].0, 3);
assert_eq!(entries[0].1.item, DefaultItem::Cobblestone);
assert_eq!(entries[0].1.min_count, 1);
assert_eq!(entries[0].1.max_count, 2);
assert_eq!(entries[0].1.chance, 0.25);
}
}