refactor!: Item changes

- Bump version to 0.3.0
- Moved crate::inventory::item to crate::item
- Made Item.position non-option
- Renamed Item::new_positioned -> Item::new
- Removed old Item::new method
- Changed Inventory.can_fit signature to use item borrow

src/ui/inventory/bundles.rs

@@ -141,8 +141,8 @@ pub fn ui_item_bundle(item: &Item, item_entity: Entity, image: Handle<Image>) ->
             is_hoverable: true,
         },
         Name::new(format!("UiItem ({},{})",
-            item.position.unwrap_or_default().x,
-            item.position.unwrap_or_default().y,
+            item.position.x,
+            item.position.y,
         )),
     )
 }

src/ui/inventory/mod.rs

@@ -5,8 +5,8 @@ use bevy::prelude::*;
 use crate::{
     inventory::{
         Inventory,
-        item::Item,
     },
+    item::Item,
     ui::UiRotateEvent,
 };
 

src/ui/inventory/observers.rs

@@ -62,11 +62,8 @@ pub fn on_item_drag_start(
             error!("UiItem {} is pointing to non-existing Item", e.event_target());
             return;
         };
-        let Some(item_position) = item.position else {
-            return;
-        };
         let slot_position = hovered_slot.0;
-        let diff = slot_position - item_position;
+        let diff = slot_position - item.position;
         commands.entity(e.event_target()).insert(DraggedItem(item.clone(), diff));
     }
 }
@@ -123,15 +120,18 @@ pub fn on_item_drag_drop(
     info!("{actual_position:?}");
     let temp_item = &mut dragged_item.0;
     if actual_position.is_negative_bitmask() == 0 {
-        temp_item.position = Some(actual_position.as_uvec2());
+        temp_item.position = actual_position.as_uvec2();
     }
 
-    let Some((slot_id, _, _)) = slot_id_query.iter().find(|(_, slot_pos, slot_parent_id)| slot_pos.0 == temp_item.position.unwrap() && slot_parent_id == &slot_parent) else {
+    let Some((slot_id, _, _)) = slot_id_query.iter().find(|(_, slot_pos, slot_parent_id)| slot_pos.0 == temp_item.position && slot_parent_id == &slot_parent) else {
         return;
     };
 
     if inventory.can_replace(item_query.as_readonly(), items, *item_entity, temp_item) {
-        let mut item = item_query.get_mut(*item_entity).unwrap();
+        let Ok(mut item) = item_query.get_mut(*item_entity) else {
+            error!("Cannot get item to replace");
+            return;
+        };
         item.position = temp_item.position;
         item.size = temp_item.size;
         item.rotated = temp_item.rotated;

src/ui/inventory/systems.rs

@@ -2,14 +2,21 @@ use bevy::prelude::*;
 
 use crate::{
     inventory::ActiveInventory,
+    item::{
+        Item,
+        ItemImage,
+    },
     player::Player,
     ui::UiRoot,
 };
 
-use super::{*, bundles::*, observers::*};
+use super::{
+    *,
+    bundles::*,
+    observers::*,
+};
 
 const UI_SLOT_ASSET_PATH: &'static str = "sprites/ui/inventory_slot.png";
-const TEMP_ITEM_PATH: &'static str = "sprites/items/choco_bar.png";
 
 pub fn setup_ui_inventory(
     mut commands: Commands,
@@ -18,6 +25,7 @@ pub fn setup_ui_inventory(
     player_query: Query<(), With<Player>>,
     active_inventory_query: Query<Entity, With<ActiveInventory>>,
     item_query: Query<&Item>,
+    item_image_query: Query<&ItemImage>,
     root_query: Query<Entity, With<UiRoot>>,
 ) {
     let Ok(root) = root_query.single() else {
@@ -25,7 +33,6 @@ pub fn setup_ui_inventory(
         return;
     };
     let ui_slot_image: Handle<Image> = asset_server.load(UI_SLOT_ASSET_PATH);
-    let temp_item_image: Handle<Image> = asset_server.load(TEMP_ITEM_PATH);
     let (mut player_inventory_ids, mut active_inventory_ids) = (Vec::new(), Vec::new());
     for (inventory_parent, inventory_entity, inventory, children) in inventory_query.iter().sort::<Entity>() {
         let is_player = match inventory_parent {
@@ -48,10 +55,14 @@ pub fn setup_ui_inventory(
             Some(children) => {
                 children.iter().filter_map(|item_entity| {
                     match item_query.get(item_entity) {
-                        Ok(item) => Some((item, item_entity)),
+                        Ok(item) => {
+                            let item_image = item_image_query.get(item_entity)
+                                .expect("ItemImage is required on Item");
+                            Some((item, item_entity, item_image))
+                        },
                         Err(_) => None,
                     }
-                }).collect::<Vec<(&Item, Entity)>>()
+                }).collect::<Vec<(&Item, Entity, &ItemImage)>>()
             }
             None => Vec::new(),
         };
@@ -62,10 +73,10 @@ pub fn setup_ui_inventory(
                     slot_commands.observe(on_slot_over)
                         .observe(on_slot_out)
                         .observe(on_item_drag_drop);
-                    if let Some((item, entity)) = items.iter()
-                        .find(|(i, _)| i.position.unwrap_or_default() == UVec2::new(x, y)) {
+                    if let Some((item, entity, item_image)) = items.iter()
+                        .find(|(i, _, _)| i.position == UVec2::new(x, y)) {
                         slot_commands.with_children(|commands| {
-                            commands.spawn(ui_item_bundle(item, *entity, temp_item_image.clone()))
+                            commands.spawn(ui_item_bundle(item, *entity, item_image.0.clone()))
                                 .observe(on_item_over)
                                 .observe(on_item_out)
                                 .observe(on_item_drag_start)