feat: ✨ inventory panel

src/lib.rs

@@ -1,7 +1,7 @@
 use bevy::{
     app::{App, PluginGroup, Startup, Update},
     diagnostic::FrameTimeDiagnosticsPlugin,
-    prelude::IntoSystemConfigs,
+    prelude::{ImagePlugin, IntoSystemConfigs, Resource},
     utils::default,
     window::{Window, WindowPlugin, WindowTheme},
     DefaultPlugins,
@@ -9,12 +9,14 @@ use bevy::{
 use camera::UserCamera;
 use market::Market;
 use player::Player;
+use player_inventory::PlayerInventory;
 use ui::{FPSText, FishCounterText, KeybindingsText, MoneyText};
 use water::Water;
 
 mod camera;
 mod market;
 mod player;
+mod player_inventory;
 mod ui;
 mod water;
 
@@ -23,17 +25,26 @@ pub const CAMERA_DECAY_RATE: f32 = 3.0;
 pub const INTERACTION_AREA_RADIUS: f32 = 100.0;
 pub const FISH_PRICE: usize = 15;
 
+#[derive(Debug, Resource)]
+pub struct PlayerGUIStatus {
+    looking_inventory: bool,
+}
+
 pub fn start_game() {
     App::new()
-        .add_plugins(DefaultPlugins.set(WindowPlugin {
+        .add_plugins(
-            primary_window: Some(Window {
+            DefaultPlugins
-                title: "Fisher ~Tahinli".to_owned(),
+                .set(WindowPlugin {
-                // present_mode: PresentMode::Immediate, //Vsync off
+                    primary_window: Some(Window {
-                window_theme: Some(WindowTheme::Dark),
+                        title: "Fisher ~Tahinli".to_owned(),
-                ..default()
+                        // present_mode: PresentMode::Immediate, //Vsync off
-            }),
+                        window_theme: Some(WindowTheme::Dark),
-            ..default()
+                        ..default()
-        }))
+                    }),
+                    ..default()
+                })
+                .set(ImagePlugin::default_nearest()),
+        )
         .add_plugins(FrameTimeDiagnosticsPlugin)
         .add_systems(
             Startup,
@@ -42,6 +53,7 @@ pub fn start_game() {
                 UserCamera::setup,
                 Water::setup,
                 Market::setup,
+                PlayerInventory::setup,
                 Player::setup,
                 FishCounterText::setup,
                 MoneyText::setup,
@@ -53,6 +65,7 @@ pub fn start_game() {
             (
                 FPSText::update,
                 UserCamera::update,
+                PlayerInventory::toggle,
                 Player::r#move.before(FishCounterText::update),
                 Water::fishing,
                 Market::sell.chain().before(MoneyText::update),
@@ -60,5 +73,8 @@ pub fn start_game() {
                 MoneyText::update,
             ),
         )
+        .insert_resource(PlayerGUIStatus {
+            looking_inventory: false,
+        })
         .run();
 }

src/market.rs

@@ -1,6 +1,8 @@
 use bevy::prelude::*;
 
-use crate::{player::Player, FISH_PRICE, INTERACTION_AREA_RADIUS};
+use crate::{
+    player::Player, player_inventory::PlayerInventory, FISH_PRICE, INTERACTION_AREA_RADIUS,
+};
 
 #[derive(Debug, Component)]
 pub struct Market;
@@ -18,12 +20,12 @@ impl Market {
 
     pub fn sell(
         player_transform_query: Query<&Transform, With<Player>>,
-        mut player_query: Query<&mut Player, With<Player>>,
+        mut player_inventory_query: Query<&mut PlayerInventory, With<PlayerInventory>>,
         market_query: Query<&Transform, With<Market>>,
         keyboard: Res<ButtonInput<KeyCode>>,
     ) {
         let player_transform = player_transform_query.get_single().unwrap();
-        let mut player = player_query.get_single_mut().unwrap();
+        let mut player_inventory = player_inventory_query.get_single_mut().unwrap();
 
         for market_query in &market_query {
             let distance = player_transform
@@ -32,8 +34,8 @@ impl Market {
 
             if distance < INTERACTION_AREA_RADIUS {
                 if keyboard.just_pressed(KeyCode::KeyE) {
-                    player.money = player.fish_count * FISH_PRICE;
+                    player_inventory.money += player_inventory.fish * FISH_PRICE;
-                    player.fish_count = 0;
+                    player_inventory.fish = 0;
                 }
             }
         }

src/player.rs

@@ -1,12 +1,9 @@
 use bevy::prelude::*;
 
-use crate::CHARACTER_SPEED;
+use crate::{PlayerGUIStatus, CHARACTER_SPEED};
 
 #[derive(Debug, Component)]
-pub struct Player {
+pub struct Player;
-    pub fish_count: usize,
-    pub money: usize,
-}
 
 impl Player {
     pub fn setup(mut commands: Commands, asset_server: Res<AssetServer>) {
@@ -14,10 +11,7 @@ impl Player {
         commands.spawn((
             Sprite::from_image(image),
             Transform::from_xyz(0.0, 0.0, 0.0),
-            Player {
+            Player,
-                fish_count: 0,
-                money: 0,
-            },
         ));
     }
 
@@ -25,21 +19,24 @@ impl Player {
         time: Res<Time>,
         mut player_query: Query<&mut Transform, With<Player>>,
         keyboard_input: Res<ButtonInput<KeyCode>>,
+        player_gui_status: Res<PlayerGUIStatus>,
     ) {
-        let mut player = player_query.get_single_mut().unwrap();
+        if !player_gui_status.looking_inventory {
+            let mut player = player_query.get_single_mut().unwrap();
 
-        let translation = CHARACTER_SPEED * time.delta_secs();
+            let translation = CHARACTER_SPEED * time.delta_secs();
-        if keyboard_input.pressed(KeyCode::KeyW) {
+            if keyboard_input.pressed(KeyCode::KeyW) {
-            player.translation.y += translation;
+                player.translation.y += translation;
-        }
+            }
-        if keyboard_input.pressed(KeyCode::KeyS) {
+            if keyboard_input.pressed(KeyCode::KeyS) {
-            player.translation.y -= translation;
+                player.translation.y -= translation;
-        }
+            }
-        if keyboard_input.pressed(KeyCode::KeyA) {
+            if keyboard_input.pressed(KeyCode::KeyA) {
-            player.translation.x -= translation;
+                player.translation.x -= translation;
-        }
+            }
-        if keyboard_input.pressed(KeyCode::KeyD) {
+            if keyboard_input.pressed(KeyCode::KeyD) {
-            player.translation.x += translation;
+                player.translation.x += translation;
+            }
         }
     }
 }

src/player_inventory.rs

@@ -0,0 +1,58 @@
+use bevy::prelude::*;
+
+use crate::{player::Player, PlayerGUIStatus};
+
+#[derive(Debug, Default, Component)]
+pub struct PlayerInventory {
+    pub money: usize,
+    pub fish: usize,
+}
+
+impl PlayerInventory {
+    pub fn setup(mut commands: Commands, asset_server: Res<AssetServer>) {
+        let image = asset_server.load::<Image>("inventory.png");
+        let sprite = Sprite::from_image(image);
+        commands.spawn((
+            sprite.clone(),
+            Transform::from_scale(Vec3 {
+                x: 20.0,
+                y: 20.0,
+                z: 0.0,
+            }),
+            Visibility::Hidden,
+            PlayerInventory::default(),
+        ));
+    }
+
+    pub fn toggle(
+        mut player_inventory_transform_query: Query<
+            &mut Transform,
+            (With<PlayerInventory>, Without<Player>),
+        >,
+        mut player_inventory_query: Query<&mut PlayerInventory, With<PlayerInventory>>,
+        player_transform_query: Query<&Transform, With<Player>>,
+        mut player_inventory_visibility_query: Query<&mut Visibility, With<PlayerInventory>>,
+        keyboard: Res<ButtonInput<KeyCode>>,
+        mut player_gui_status: ResMut<PlayerGUIStatus>,
+    ) {
+        let mut player_inventory_visibility =
+            player_inventory_visibility_query.get_single_mut().unwrap();
+
+        if keyboard.just_pressed(KeyCode::Tab) && player_gui_status.looking_inventory == false {
+            let mut player_inventory_transform =
+                player_inventory_transform_query.get_single_mut().unwrap();
+            let player_inventory = player_inventory_query.get_single_mut().unwrap();
+            let player_position = player_transform_query.get_single().unwrap();
+
+            let new_inventory_position = player_position.translation.truncate().extend(2.0);
+            player_inventory_transform.translation = new_inventory_position;
+            player_gui_status.looking_inventory = true;
+            player_inventory_visibility.toggle_visible_hidden();
+            println!("{:#?}", player_inventory);
+        } else if keyboard.just_pressed(KeyCode::Tab) && player_gui_status.looking_inventory == true
+        {
+            player_gui_status.looking_inventory = false;
+            player_inventory_visibility.toggle_visible_hidden();
+        }
+    }
+}

src/ui.rs

@@ -5,7 +5,7 @@ use bevy::{
     prelude::*,
 };
 
-use crate::player::Player;
+use crate::{player::Player, player_inventory::PlayerInventory};
 
 const FISH_COUNTER_OFFSET: Vec3 = Vec3::new(50.0, 50.0, 1.0);
 static FISH_COUNT: LazyLock<Arc<RwLock<usize>>> = LazyLock::new(|| Arc::new(RwLock::new(0)));
@@ -61,20 +61,20 @@ impl FishCounterText {
         >,
         mut fish_counter_text_query: Query<&mut Text2d, With<FishCounterText>>,
         player_transform_query: Query<&Transform, (With<Player>, Without<FishCounterText>)>,
-        player_query: Query<&Player, With<Player>>,
+        player_inventory_query: Query<&PlayerInventory, With<PlayerInventory>>,
     ) {
         let mut fish_counter_text_transform =
             fish_counter_text_transform_query.get_single_mut().unwrap();
         let mut fish_counter_text = fish_counter_text_query.get_single_mut().unwrap();
-        let player = player_query.get_single().unwrap();
+        let player_inventory = player_inventory_query.get_single().unwrap();
 
         let player_position = player_transform_query.get_single().unwrap();
         let mut new_fish_counter_text_position = player_position.translation.truncate().extend(0.0);
         new_fish_counter_text_position += FISH_COUNTER_OFFSET;
         fish_counter_text_transform.translation = new_fish_counter_text_position;
-        if *FISH_COUNT.read().unwrap() != player.fish_count {
+        if *FISH_COUNT.read().unwrap() != player_inventory.fish {
-            *FISH_COUNT.write().unwrap() = player.fish_count;
+            *FISH_COUNT.write().unwrap() = player_inventory.fish;
-            *fish_counter_text = format!("Fish Count = {}", player.fish_count).into();
+            *fish_counter_text = format!("Fish Count = {}", player_inventory.fish).into();
         }
     }
 }
@@ -112,14 +112,14 @@ impl MoneyText {
 
     pub fn update(
         mut money_text_query: Query<&mut Text, With<MoneyText>>,
-        player_query: Query<&Player, With<Player>>,
+        player_inventory_query: Query<&PlayerInventory, With<PlayerInventory>>,
     ) {
         let mut fish_counter_text = money_text_query.get_single_mut().unwrap();
-        let player = player_query.get_single().unwrap();
+        let player_inventory = player_inventory_query.get_single().unwrap();
 
-        if *MONEY.read().unwrap() != player.fish_count {
+        if *MONEY.read().unwrap() != player_inventory.fish {
-            *MONEY.write().unwrap() = player.fish_count;
+            *MONEY.write().unwrap() = player_inventory.fish;
-            *fish_counter_text = format!("Money = {}", player.money).into();
+            *fish_counter_text = format!("Money = {}", player_inventory.money).into();
         }
     }
 }

src/water.rs

@@ -1,6 +1,6 @@
 use bevy::prelude::*;
 
-use crate::{player::Player, INTERACTION_AREA_RADIUS};
+use crate::{player::Player, player_inventory::PlayerInventory, INTERACTION_AREA_RADIUS};
 
 #[derive(Debug, Component)]
 pub struct Water;
@@ -15,12 +15,12 @@ impl Water {
 
     pub fn fishing(
         player_transform_query: Query<&Transform, With<Player>>,
-        mut player_query: Query<&mut Player, With<Player>>,
+        mut player_inventory_query: Query<&mut PlayerInventory, With<PlayerInventory>>,
         water_query: Query<&Transform, With<Water>>,
         keyboard: Res<ButtonInput<KeyCode>>,
     ) {
         let player_transform = player_transform_query.get_single().unwrap();
-        let mut player = player_query.get_single_mut().unwrap();
+        let mut player_inventory = player_inventory_query.get_single_mut().unwrap();
 
         for water_query in &water_query {
             let distance = player_transform
@@ -29,7 +29,7 @@ impl Water {
 
             if distance < INTERACTION_AREA_RADIUS {
                 if keyboard.just_pressed(KeyCode::KeyE) {
-                    player.fish_count += 1;
+                    player_inventory.fish += 1;
                 }
             }
         }