use std::hash::Hash;
use crate::voxel::{DefaultTerrainVoxel, VoxelType};
use bevy::prelude::*;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[non_exhaustive]
pub enum ContainerExchangeError {
InvalidRequest,
InvalidContainer,
InsufficientItems,
CapacityExceeded,
}
pub(crate) fn normalize_quantities<I: ItemType>(
quantities: &[(I, u32)],
) -> Result<Vec<(I, u32)>, ContainerExchangeError> {
let mut normalized: Vec<(I, u32)> = Vec::new();
for &(item, count) in quantities {
if count == 0 {
continue;
}
if item == I::default() || item.is_empty() {
return Err(ContainerExchangeError::InvalidRequest);
}
if let Some((_, total)) = normalized
.iter_mut()
.find(|(existing, _)| *existing == item)
{
*total = total
.checked_add(count)
.ok_or(ContainerExchangeError::InvalidRequest)?;
} else {
normalized.push((item, count));
}
}
Ok(normalized)
}
pub trait Container<I: ItemType> {
fn add(&mut self, item: I, count: u32) -> u32;
fn remove(&mut self, item: I, count: u32) -> u32;
fn count_of(&self, item: I) -> u32;
fn capacity(&self) -> usize;
fn is_full(&self) -> bool;
fn iter_slots(&self) -> impl Iterator<Item = Option<&InventorySlot<I>>>;
fn slot_at(&self, index: usize) -> Option<&InventorySlot<I>>;
fn try_exchange_atomic(
&mut self,
_remove: &[(I, u32)],
_add: &[(I, u32)],
) -> Option<Result<(), ContainerExchangeError>> {
None
}
}
pub trait ItemType: Copy + Clone + Default + Send + Sync + PartialEq + Eq + Hash + 'static {
fn name(&self) -> &'static str;
fn color(&self) -> [f32; 4];
fn to_byte(&self) -> u8;
fn from_byte(b: u8) -> Self;
fn is_empty(&self) -> bool {
false
}
fn tool_level(&self) -> u8 {
0
}
fn tool_speed(&self) -> f32 {
1.0
}
}
#[derive(Debug, Clone, PartialEq)]
pub struct InventorySlot<I: ItemType> {
pub item: I,
pub count: u32,
}
#[derive(Resource, Debug, Clone)]
pub struct Inventory<I: ItemType> {
pub slots: Vec<Option<InventorySlot<I>>>,
pub capacity: usize,
}
impl<I: ItemType> Inventory<I> {
pub(crate) fn validate_integrity(&self) -> Result<(), ContainerExchangeError> {
if self.capacity != self.slots.len() {
return Err(ContainerExchangeError::InvalidContainer);
}
let quantities: Vec<_> = self
.slots
.iter()
.flatten()
.map(|slot| (slot.item, slot.count))
.collect();
if quantities.iter().any(|(_, count)| *count == 0) {
return Err(ContainerExchangeError::InvalidContainer);
}
normalize_quantities(&quantities)
.map(|_| ())
.map_err(|_| ContainerExchangeError::InvalidContainer)
}
fn exchange_atomic(
&mut self,
remove: &[(I, u32)],
add: &[(I, u32)],
) -> Result<(), ContainerExchangeError> {
let remove = normalize_quantities(remove)?;
let add = normalize_quantities(add)?;
self.validate_integrity()?;
if remove
.iter()
.any(|&(item, count)| self.count_of(item) < count)
{
return Err(ContainerExchangeError::InsufficientItems);
}
let mut staged = Self {
slots: self.slots.clone(),
capacity: self.capacity,
};
for (item, count) in remove {
if staged.remove(item, count) != count {
return Err(ContainerExchangeError::InsufficientItems);
}
}
for (item, count) in add {
if staged.add(item, count) != 0 {
return Err(ContainerExchangeError::CapacityExceeded);
}
}
self.slots = staged.slots;
Ok(())
}
pub fn new(capacity: usize) -> Self {
Self {
slots: vec![None; capacity],
capacity,
}
}
pub fn add(&mut self, item: I, count: u32) -> u32 {
if count == 0 {
return 0;
}
if item == I::default() || item.is_empty() || self.validate_integrity().is_err() {
return count;
}
let accepted = count.min(u32::MAX - self.count_of(item));
let mut remaining = accepted;
for slot in self.slots.iter_mut().flatten() {
if remaining == 0 {
break;
}
if slot.item == item {
slot.count += remaining;
remaining = 0;
}
}
if remaining > 0 {
for slot in self.slots.iter_mut() {
if remaining == 0 {
break;
}
if slot.is_none() {
*slot = Some(InventorySlot {
item,
count: remaining,
});
remaining = 0;
}
}
}
(count - accepted) + remaining
}
pub fn remove(&mut self, item: I, count: u32) -> u32 {
let mut to_remove = count;
let mut removed = 0u32;
for slot in self.slots.iter_mut() {
if to_remove == 0 {
break;
}
if let Some(s) = slot {
if s.item == item {
let take = s.count.min(to_remove);
s.count -= take;
to_remove -= take;
removed += take;
if s.count == 0 {
*slot = None;
}
}
}
}
removed
}
pub fn count_of(&self, item: I) -> u32 {
self.slots
.iter()
.flatten()
.filter(|s| s.item == item)
.fold(0u32, |total, slot| total.saturating_add(slot.count))
}
pub fn is_full(&self) -> bool {
self.slots.iter().all(|s| s.is_some())
}
}
impl<I: ItemType> Default for Inventory<I> {
fn default() -> Self {
Self::new(36)
}
}
impl<I: ItemType> Container<I> for Inventory<I> {
fn try_exchange_atomic(
&mut self,
remove: &[(I, u32)],
add: &[(I, u32)],
) -> Option<Result<(), ContainerExchangeError>> {
Some(self.exchange_atomic(remove, add))
}
fn add(&mut self, item: I, count: u32) -> u32 {
Inventory::add(self, item, count)
}
fn remove(&mut self, item: I, count: u32) -> u32 {
Inventory::remove(self, item, count)
}
fn count_of(&self, item: I) -> u32 {
Inventory::count_of(self, item)
}
fn capacity(&self) -> usize {
self.capacity
}
fn is_full(&self) -> bool {
Inventory::is_full(self)
}
fn iter_slots(&self) -> impl Iterator<Item = Option<&InventorySlot<I>>> {
self.slots.iter().map(|s| s.as_ref())
}
fn slot_at(&self, index: usize) -> Option<&InventorySlot<I>> {
self.slots.get(index).and_then(|s| s.as_ref())
}
}
#[derive(Component)]
pub struct ContainerComponent<I: ItemType>(pub Inventory<I>);
impl<I: ItemType> ContainerComponent<I> {
pub fn new(capacity: usize) -> Self {
Self(Inventory::new(capacity))
}
}
impl<I: ItemType> Container<I> for ContainerComponent<I> {
fn try_exchange_atomic(
&mut self,
remove: &[(I, u32)],
add: &[(I, u32)],
) -> Option<Result<(), ContainerExchangeError>> {
Container::try_exchange_atomic(&mut self.0, remove, add)
}
fn add(&mut self, item: I, count: u32) -> u32 {
self.0.add(item, count)
}
fn remove(&mut self, item: I, count: u32) -> u32 {
self.0.remove(item, count)
}
fn count_of(&self, item: I) -> u32 {
self.0.count_of(item)
}
fn capacity(&self) -> usize {
self.0.capacity
}
fn is_full(&self) -> bool {
self.0.is_full()
}
fn iter_slots(&self) -> impl Iterator<Item = Option<&InventorySlot<I>>> {
self.0.slots.iter().map(|s| s.as_ref())
}
fn slot_at(&self, index: usize) -> Option<&InventorySlot<I>> {
self.0.slots.get(index).and_then(|s| s.as_ref())
}
}
#[derive(Component, Default)]
pub struct PrimaryContainer;
#[derive(Message, Debug, Clone)]
pub struct ItemPickedUp<I: ItemType> {
pub item: I,
pub count: u32,
}
#[derive(
Debug, Clone, Copy, PartialEq, Eq, Hash, Default, serde::Serialize, serde::Deserialize,
)]
pub enum DefaultItem {
#[default]
Empty,
Dirt,
Sand,
Wood,
Gravel,
Snow,
CoalOre,
IronOre,
Cobblestone,
Sandstone,
Planks,
Brick,
Coal,
IronIngot,
Log,
Snowball,
RockFragment,
Crystal,
RareMineral,
WoodenPickaxe,
StonePickaxe,
IronPickaxe,
IronOreItem,
}
impl ItemType for DefaultItem {
fn name(&self) -> &'static str {
match self {
DefaultItem::Empty => "Empty",
DefaultItem::Dirt => "Dirt",
DefaultItem::Sand => "Sand",
DefaultItem::Wood => "Wood",
DefaultItem::Gravel => "Gravel",
DefaultItem::Snow => "Snow",
DefaultItem::CoalOre => "Coal Ore",
DefaultItem::IronOre => "Iron Ore",
DefaultItem::IronOreItem => "Iron Ore",
DefaultItem::Cobblestone => "Cobblestone",
DefaultItem::Sandstone => "Sandstone",
DefaultItem::Planks => "Planks",
DefaultItem::Brick => "Brick",
DefaultItem::Coal => "Coal",
DefaultItem::IronIngot => "Iron Ingot",
DefaultItem::Log => "Log",
DefaultItem::Snowball => "Snowball",
DefaultItem::RockFragment => "Rock Fragment",
DefaultItem::Crystal => "Crystal",
DefaultItem::RareMineral => "Rare Mineral",
DefaultItem::WoodenPickaxe => "Wooden Pickaxe",
DefaultItem::StonePickaxe => "Stone Pickaxe",
DefaultItem::IronPickaxe => "Iron Pickaxe",
}
}
fn color(&self) -> [f32; 4] {
match self {
DefaultItem::Empty => [0.0, 0.0, 0.0, 0.0],
DefaultItem::Dirt
| DefaultItem::Sand
| DefaultItem::Wood
| DefaultItem::Gravel
| DefaultItem::Snow
| DefaultItem::CoalOre
| DefaultItem::IronOre
| DefaultItem::IronOreItem
| DefaultItem::Cobblestone
| DefaultItem::Sandstone
| DefaultItem::Planks
| DefaultItem::Brick => DefaultTerrainVoxel::from_byte(self.to_byte()).color(),
DefaultItem::Coal => [0.15, 0.15, 0.15, 1.0],
DefaultItem::IronIngot => [0.75, 0.65, 0.55, 1.0],
DefaultItem::Log => [0.40, 0.28, 0.12, 1.0],
DefaultItem::Snowball => [0.92, 0.95, 1.00, 1.0],
DefaultItem::RockFragment => [0.35, 0.30, 0.28, 1.0],
DefaultItem::Crystal => [0.40, 0.50, 0.80, 1.0],
DefaultItem::RareMineral => [0.20, 0.85, 0.60, 1.0],
DefaultItem::WoodenPickaxe => [0.55, 0.35, 0.20, 1.0],
DefaultItem::StonePickaxe => [0.50, 0.50, 0.50, 1.0],
DefaultItem::IronPickaxe => [0.70, 0.75, 0.80, 1.0],
}
}
fn to_byte(&self) -> u8 {
match self {
DefaultItem::Empty => 0,
DefaultItem::Dirt => 2,
DefaultItem::Sand => 4,
DefaultItem::Wood => 5,
DefaultItem::Gravel => 7,
DefaultItem::Snow => 8,
DefaultItem::CoalOre => 10,
DefaultItem::IronOre => 11,
DefaultItem::IronOreItem => 11, DefaultItem::Cobblestone => 12,
DefaultItem::Sandstone => 13,
DefaultItem::Planks => 14,
DefaultItem::Brick => 15,
DefaultItem::Coal => 16,
DefaultItem::IronIngot => 17,
DefaultItem::Log => 18,
DefaultItem::Snowball => 19,
DefaultItem::RockFragment => 20,
DefaultItem::Crystal => 21,
DefaultItem::RareMineral => 22,
DefaultItem::WoodenPickaxe => 23,
DefaultItem::StonePickaxe => 24,
DefaultItem::IronPickaxe => 25,
}
}
fn from_byte(b: u8) -> Self {
match b {
2 => DefaultItem::Dirt,
4 => DefaultItem::Sand,
5 => DefaultItem::Wood,
7 => DefaultItem::Gravel,
8 => DefaultItem::Snow,
10 => DefaultItem::CoalOre,
11 => DefaultItem::IronOre,
12 => DefaultItem::Cobblestone,
13 => DefaultItem::Sandstone,
14 => DefaultItem::Planks,
15 => DefaultItem::Brick,
16 => DefaultItem::Coal,
17 => DefaultItem::IronIngot,
18 => DefaultItem::Log,
19 => DefaultItem::Snowball,
20 => DefaultItem::RockFragment,
21 => DefaultItem::Crystal,
22 => DefaultItem::RareMineral,
23 => DefaultItem::WoodenPickaxe,
24 => DefaultItem::StonePickaxe,
25 => DefaultItem::IronPickaxe,
_ => DefaultItem::Empty,
}
}
fn is_empty(&self) -> bool {
matches!(self, DefaultItem::Empty)
}
fn tool_level(&self) -> u8 {
match self {
DefaultItem::WoodenPickaxe => 1,
DefaultItem::StonePickaxe => 1,
DefaultItem::IronPickaxe => 2,
_ => 0,
}
}
fn tool_speed(&self) -> f32 {
match self {
DefaultItem::WoodenPickaxe => 1.0,
DefaultItem::StonePickaxe => 2.0,
DefaultItem::IronPickaxe => 4.0,
_ => 1.0,
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_inventory_add_and_count() {
let mut inv = Inventory::<DefaultItem>::new(9);
let leftover = inv.add(DefaultItem::IronOre, 5);
assert_eq!(leftover, 0);
assert_eq!(inv.count_of(DefaultItem::IronOre), 5);
}
#[test]
fn test_inventory_add_stacks_same_type() {
let mut inv = Inventory::<DefaultItem>::new(9);
inv.add(DefaultItem::Crystal, 3);
inv.add(DefaultItem::Crystal, 7);
assert_eq!(inv.count_of(DefaultItem::Crystal), 10);
let filled = inv.slots.iter().filter(|s| s.is_some()).count();
assert_eq!(filled, 1);
}
#[test]
fn test_inventory_remove() {
let mut inv = Inventory::<DefaultItem>::new(9);
inv.add(DefaultItem::RockFragment, 10);
let removed = inv.remove(DefaultItem::RockFragment, 4);
assert_eq!(removed, 4);
assert_eq!(inv.count_of(DefaultItem::RockFragment), 6);
}
#[test]
fn test_inventory_remove_more_than_held_returns_actual() {
let mut inv = Inventory::<DefaultItem>::new(9);
inv.add(DefaultItem::RareMineral, 3);
let removed = inv.remove(DefaultItem::RareMineral, 10);
assert_eq!(removed, 3);
assert_eq!(inv.count_of(DefaultItem::RareMineral), 0);
}
#[test]
fn test_inventory_remove_clears_slot() {
let mut inv = Inventory::<DefaultItem>::new(9);
inv.add(DefaultItem::IronOre, 2);
inv.remove(DefaultItem::IronOre, 2);
assert!(inv.slots[0].is_none());
}
#[test]
fn test_inventory_full() {
let mut inv = Inventory::<DefaultItem>::new(2);
inv.add(DefaultItem::IronOre, 1);
inv.add(DefaultItem::Crystal, 1);
assert!(inv.is_full());
let leftover = inv.add(DefaultItem::RockFragment, 5);
assert_eq!(leftover, 5);
}
#[test]
fn container_trait_add_and_count() {
let mut inv = Inventory::<DefaultItem>::new(9);
let leftover = Container::add(&mut inv, DefaultItem::IronOre, 5);
assert_eq!(leftover, 0);
assert_eq!(Container::count_of(&inv, DefaultItem::IronOre), 5);
}
#[test]
fn container_slot_at_out_of_bounds_returns_none() {
let inv = Inventory::<DefaultItem>::new(9);
assert!(Container::slot_at(&inv, 100).is_none());
}
#[test]
fn container_iter_slots_yields_capacity_items() {
let inv = Inventory::<DefaultItem>::new(9);
assert_eq!(Container::iter_slots(&inv).count(), 9);
}
#[test]
fn container_component_delegates_correctly() {
let mut cc = ContainerComponent::<DefaultItem>::new(9);
cc.add(DefaultItem::Crystal, 3);
assert_eq!(cc.count_of(DefaultItem::Crystal), 3);
assert_eq!(cc.0.count_of(DefaultItem::Crystal), 3);
}
#[test]
fn container_component_slot_at_oob_no_panic() {
let cc = ContainerComponent::<DefaultItem>::new(9);
assert!(cc.slot_at(100).is_none());
}
fn stack(item: DefaultItem, count: u32) -> Option<InventorySlot<DefaultItem>> {
Some(InventorySlot { item, count })
}
#[test]
fn exchange_normalizes_duplicates_and_uses_freed_capacity() {
let mut inv = Inventory::new(1);
inv.add(DefaultItem::IronOre, 4);
assert_eq!(
inv.try_exchange_atomic(
&[(DefaultItem::IronOre, 2), (DefaultItem::IronOre, 2)],
&[(DefaultItem::Crystal, 1), (DefaultItem::Crystal, 2)],
),
Some(Ok(()))
);
assert_eq!(inv.slots, vec![stack(DefaultItem::Crystal, 3)]);
assert_eq!(inv.capacity, 1);
}
#[test]
fn exchange_failure_preserves_exact_sparse_layout() {
let original = Inventory {
capacity: 4,
slots: vec![
stack(DefaultItem::IronOre, 2),
None,
stack(DefaultItem::IronOre, 1),
stack(DefaultItem::Crystal, 7),
],
};
let requests = [
(
vec![(DefaultItem::IronOre, 2), (DefaultItem::IronOre, 2)],
vec![],
ContainerExchangeError::InsufficientItems,
),
(
vec![(DefaultItem::IronOre, 1)],
vec![(DefaultItem::Wood, 1), (DefaultItem::Sand, 1)],
ContainerExchangeError::CapacityExceeded,
),
(
vec![(DefaultItem::IronOre, 1)],
vec![(DefaultItem::Crystal, u32::MAX)],
ContainerExchangeError::CapacityExceeded,
),
(
vec![(DefaultItem::IronOre, u32::MAX), (DefaultItem::IronOre, 1)],
vec![],
ContainerExchangeError::InvalidRequest,
),
(
vec![],
vec![(DefaultItem::Crystal, u32::MAX), (DefaultItem::Crystal, 1)],
ContainerExchangeError::InvalidRequest,
),
(
vec![(DefaultItem::Empty, 1)],
vec![],
ContainerExchangeError::InvalidRequest,
),
(
vec![],
vec![(DefaultItem::Empty, 1)],
ContainerExchangeError::InvalidRequest,
),
];
for (remove, add, error) in requests {
let mut inv = original.clone();
assert_eq!(inv.try_exchange_atomic(&remove, &add), Some(Err(error)));
assert_eq!(inv.slots, original.slots);
assert_eq!(inv.capacity, original.capacity);
}
}
#[test]
fn exchange_same_input_outputs_and_existing_duplicate_stacks() {
let mut inv = Inventory {
capacity: 4,
slots: vec![
stack(DefaultItem::IronOre, 2),
None,
stack(DefaultItem::IronOre, 3),
stack(DefaultItem::Crystal, 4),
],
};
assert_eq!(
inv.try_exchange_atomic(
&[(DefaultItem::IronOre, 4)],
&[
(DefaultItem::IronOre, 2),
(DefaultItem::Crystal, 1),
(DefaultItem::IronOre, 3)
],
),
Some(Ok(()))
);
assert_eq!(
inv.slots,
vec![
None,
None,
stack(DefaultItem::IronOre, 6),
stack(DefaultItem::Crystal, 5)
]
);
}
#[test]
fn add_bounds_aggregate_headroom_and_returns_every_leftover() {
let mut inv = Inventory {
capacity: 3,
slots: vec![
stack(DefaultItem::Crystal, u32::MAX - 10),
None,
stack(DefaultItem::Crystal, 5),
],
};
assert_eq!(inv.add(DefaultItem::Crystal, 8), 3);
assert_eq!(inv.count_of(DefaultItem::Crystal), u32::MAX);
assert_eq!(inv.slots[0], stack(DefaultItem::Crystal, u32::MAX - 5));
assert_eq!(inv.slots[2], stack(DefaultItem::Crystal, 5));
assert!(inv.slots[1].is_none());
let before = inv.slots.clone();
assert_eq!(inv.add(DefaultItem::Crystal, u32::MAX), u32::MAX);
assert_eq!(inv.slots, before);
let mut full = Inventory::new(1);
full.add(DefaultItem::IronOre, 1);
assert_eq!(full.add(DefaultItem::Crystal, u32::MAX), u32::MAX);
}
#[test]
fn malformed_sources_reject_exchange_and_add_without_mutation() {
let invalid = [
Inventory {
capacity: 2,
slots: vec![None],
},
Inventory {
capacity: 0,
slots: vec![None],
},
Inventory {
capacity: 1,
slots: vec![stack(DefaultItem::IronOre, 0)],
},
Inventory {
capacity: 1,
slots: vec![stack(DefaultItem::Empty, 1)],
},
Inventory {
capacity: 2,
slots: vec![
stack(DefaultItem::IronOre, u32::MAX),
stack(DefaultItem::IronOre, 1),
],
},
];
for mut inv in invalid {
let before = inv.slots.clone();
let capacity = inv.capacity;
assert_eq!(
inv.validate_integrity(),
Err(ContainerExchangeError::InvalidContainer)
);
assert_eq!(
inv.try_exchange_atomic(&[], &[]),
Some(Err(ContainerExchangeError::InvalidContainer))
);
assert_eq!(inv.add(DefaultItem::Crystal, 5), 5);
assert_eq!(inv.slots, before);
assert_eq!(inv.capacity, capacity);
}
}
#[test]
fn count_of_defensively_saturates_invalid_totals() {
let inv = Inventory {
capacity: 3,
slots: vec![
stack(DefaultItem::Crystal, u32::MAX),
stack(DefaultItem::Crystal, u32::MAX),
stack(DefaultItem::IronOre, 3),
],
};
assert_eq!(inv.count_of(DefaultItem::Crystal), u32::MAX);
assert_eq!(inv.count_of(DefaultItem::IronOre), 3);
}
#[test]
fn empty_lists_zero_quantities_and_zero_capacity_are_valid() {
let mut inv = Inventory::<DefaultItem>::new(0);
assert_eq!(inv.validate_integrity(), Ok(()));
assert_eq!(inv.try_exchange_atomic(&[], &[]), Some(Ok(())));
assert_eq!(
inv.try_exchange_atomic(&[(DefaultItem::Empty, 0)], &[(DefaultItem::Empty, 0)]),
Some(Ok(()))
);
assert_eq!(inv.add(DefaultItem::Empty, 0), 0);
assert_eq!(inv.add(DefaultItem::Empty, 1), 1);
assert_eq!(inv.add(DefaultItem::Crystal, 1), 1);
assert!(inv.slots.is_empty());
}
#[test]
fn normalization_uses_equality_not_serialized_bytes_and_keeps_order() {
assert_eq!(
DefaultItem::IronOre.to_byte(),
DefaultItem::IronOreItem.to_byte()
);
assert_ne!(DefaultItem::IronOre, DefaultItem::IronOreItem);
assert_eq!(
normalize_quantities(&[
(DefaultItem::Empty, 0),
(DefaultItem::IronOreItem, 1),
(DefaultItem::Crystal, 0),
(DefaultItem::IronOre, 2),
(DefaultItem::IronOreItem, 3),
(DefaultItem::Crystal, 5),
]),
Ok(vec![
(DefaultItem::IronOreItem, 4),
(DefaultItem::IronOre, 2),
(DefaultItem::Crystal, 5)
])
);
}
#[derive(Clone, Copy, Default, PartialEq, Eq, Hash)]
enum MinimalItem {
#[default]
DefaultSentinel,
OtherSentinel,
Live,
}
impl ItemType for MinimalItem {
fn name(&self) -> &'static str {
"minimal"
}
fn color(&self) -> [f32; 4] {
[1.0; 4]
}
fn to_byte(&self) -> u8 {
1
}
fn from_byte(_: u8) -> Self {
Self::default()
}
fn is_empty(&self) -> bool {
*self == Self::OtherSentinel
}
}
#[test]
fn exchange_requires_no_new_item_bounds_and_rejects_both_sentinels() {
let mut inv = Inventory::<MinimalItem>::new(1);
assert_eq!(inv.add(MinimalItem::DefaultSentinel, 1), 1);
assert_eq!(inv.add(MinimalItem::OtherSentinel, 1), 1);
assert_eq!(
inv.try_exchange_atomic(&[], &[(MinimalItem::Live, 1)]),
Some(Ok(()))
);
for sentinel in [MinimalItem::DefaultSentinel, MinimalItem::OtherSentinel] {
assert_eq!(
inv.try_exchange_atomic(&[(sentinel, 1)], &[]),
Some(Err(ContainerExchangeError::InvalidRequest))
);
assert_eq!(
inv.try_exchange_atomic(&[], &[(sentinel, 1)]),
Some(Err(ContainerExchangeError::InvalidRequest))
);
assert_eq!(
inv.try_exchange_atomic(&[(sentinel, 0)], &[(sentinel, 0)]),
Some(Ok(()))
);
let invalid = Inventory {
capacity: 1,
slots: vec![Some(InventorySlot {
item: sentinel,
count: 1,
})],
};
assert_eq!(
invalid.validate_integrity(),
Err(ContainerExchangeError::InvalidContainer)
);
}
assert_eq!(inv.count_of(MinimalItem::Live), 1);
}
#[test]
fn component_atomic_exchange_matches_inventory_success_and_failure() {
let mut inv = Inventory::new(1);
inv.add(DefaultItem::IronOre, 4);
let mut component = ContainerComponent(inv.clone());
for (remove, add) in [
(
vec![(DefaultItem::IronOre, 4)],
vec![(DefaultItem::Crystal, 3)],
),
(vec![], vec![(DefaultItem::Wood, 1)]),
(vec![(DefaultItem::Crystal, 4)], vec![]),
(vec![], vec![(DefaultItem::Empty, 1)]),
] {
assert_eq!(
component.try_exchange_atomic(&remove, &add),
inv.try_exchange_atomic(&remove, &add)
);
assert_eq!(component.0.slots, inv.slots);
assert_eq!(component.capacity(), inv.capacity);
}
component.0.capacity = 2;
let before = component.0.slots.clone();
assert_eq!(
component.try_exchange_atomic(&[], &[]),
Some(Err(ContainerExchangeError::InvalidContainer))
);
assert_eq!(component.0.slots, before);
}
}