From fabcff5a65d273d4255c1af942eb4e365b6db54d Mon Sep 17 00:00:00 2001
From: Michael Huebner <michael.huebner@ptspaper.de>
Date: Tue, 25 Mar 2025 13:51:08 +0100
Subject: [PATCH] Continue fixing (part 2)

---
 src/board.rs |  36 ++--
 src/game.rs  | 497 +++++++++++++++++++++++++--------------------------
 2 files changed, 257 insertions(+), 276 deletions(-)

diff --git a/src/board.rs b/src/board.rs
index 9737611..06fbb50 100644
--- a/src/board.rs
+++ b/src/board.rs
@@ -1,4 +1,4 @@
-use std::sync::{Arc, Mutex};
+use std::sync::Arc;
 
 use anyhow::Result;
 use engine::prelude::{
@@ -14,7 +14,7 @@ pub struct BoardSlot {
     pub y: usize,
     pub z: usize,
 
-    state: Mutex<BoardSlotState>,
+    state: BoardSlotState,
     pub position: Vector2<f32>,
     pub slot_marker: Option<Entity>,
 }
@@ -49,7 +49,7 @@ impl BoardSlot {
             y,
             z,
 
-            state: Mutex::new(BoardSlotState::default()),
+            state: BoardSlotState::default(),
             position,
             slot_marker: Some(world.add_entity(marker)?),
         })
@@ -61,7 +61,7 @@ impl BoardSlot {
             y,
             z,
 
-            state: Mutex::new(BoardSlotState::Invalid),
+            state: BoardSlotState::Invalid,
             position: vec2(0.0, 0.0),
             slot_marker: None,
         }
@@ -106,30 +106,30 @@ impl BoardSlot {
     }
 
     pub fn state(&self) -> BoardSlotState {
-        *self.state.lock().unwrap()
+        self.state
     }
 
-    pub fn set_state(&self, state: BoardSlotState) {
-        *self.state.lock().unwrap() = state;
+    pub fn set_state(&mut self, state: BoardSlotState) {
+        self.state = state;
     }
 
     pub fn valid(&self) -> bool {
-        *self.state.lock().unwrap() != BoardSlotState::Invalid
+        self.state != BoardSlotState::Invalid
     }
 
     pub fn is_empty(&self) -> bool {
-        *self.state.lock().unwrap() == BoardSlotState::Empty
+        self.state == BoardSlotState::Empty
     }
 
     pub fn white(&self) -> bool {
-        match *self.state.lock().unwrap() {
+        match self.state {
             BoardSlotState::White(_) => true,
             _ => false,
         }
     }
 
     pub fn black(&self) -> bool {
-        match *self.state.lock().unwrap() {
+        match self.state {
             BoardSlotState::Black(_) => true,
             _ => false,
         }
@@ -277,13 +277,13 @@ impl Board {
         &mut self.slots
     }
 
-    pub fn close_to_marker(&mut self, position: Vector2<f32>) -> Option<&mut BoardSlot> {
+    pub fn close_to_marker(&self, position: Vector2<f32>) -> Option<&BoardSlot> {
         const DISTANCE: f32 = 1.25;
 
-        for outer in self.slots.iter_mut() {
-            for inner in outer.iter_mut() {
-                for slot in inner.iter_mut() {
-                    if *slot.state.lock().unwrap() != BoardSlotState::Invalid {
+        for outer in self.slots.iter() {
+            for inner in outer.iter() {
+                for slot in inner.iter() {
+                    if slot.state != BoardSlotState::Invalid {
                         if (slot.position - position).magnitude() <= DISTANCE {
                             return Some(slot);
                         }
@@ -349,9 +349,7 @@ impl Board {
 
                 _ => unreachable!(),
             } {
-                let neighbour_state = neighbour.state.lock().unwrap();
-
-                match *neighbour_state {
+                match neighbour.state {
                     BoardSlotState::Empty => {
                         neighbours.push(neighbour);
                     }
diff --git a/src/game.rs b/src/game.rs
index 296b0dd..10c1772 100644
--- a/src/game.rs
+++ b/src/game.rs
@@ -244,13 +244,6 @@ impl MillGame {
         sun_light.set_position(vec3(0.0, 0.0, 100.0))?;
         sun_light.set_power(10000000000.0)?;
 
-        let scene = world.resources.get_mut::<Scene>();
-        scene.add_light(sun_light)?;
-
-        let view = scene.view_mut();
-        view.camera_mut().set_center(board.center());
-        view.update_buffer()?;
-
         let white_stones = Self::init_nine_stones(world, Color::White)?
             .into_iter()
             .enumerate()
@@ -283,29 +276,38 @@ impl MillGame {
             .try_into()
             .unwrap_or_else(|_: Vec<Stone>| unreachable!("create array from vec from an array"));
 
-        let mut camera_control = TopDownCameraControl::new(&mut scene)?;
+        let scene = world.resources.get_mut::<Scene>();
+        scene.add_light(sun_light)?;
+
+        let view = scene.view_mut();
+        view.camera_mut().set_center(board.center());
+        view.update_buffer()?;
+
+        let mut camera_control = TopDownCameraControl::new(view)?;
         camera_control.set_zoom_levels(
             (3..60).into_iter().rev().map(|z| z as f32).collect(),
             5,
-            &mut scene,
+            view,
         )?;
 
         world.resources.insert(camera_control);
 
-        let gui = GuiBuilder::new(
-            engine.gui_handler(),
-            &AssetPath::from((
-                engine.settings().resource_base_path.as_str(),
-                "mainmenu.xml",
-            )),
-        )?;
+        let path = AssetPath::from((
+            world
+                .resources
+                .get::<EngineSettings>()
+                .resource_base_path
+                .as_str(),
+            "mainmenu.xml",
+        ));
+        let gui = GuiBuilder::new(world, &path)?;
 
         let grid: Arc<Grid> = gui.element("grid")?;
         let white_player_label: Arc<Label> = gui.element("white_player_label")?;
         let black_player_label: Arc<Label> = gui.element("black_player_label")?;
         let start_button: Arc<Button> = gui.element("start")?;
 
-        gui.enable(world.resources.get_mut::<GuiHandler>())?;
+        gui.enable(world)?;
 
         start_button.set_callback({
             let weak_grid = Arc::downgrade(&grid);
@@ -323,7 +325,7 @@ impl MillGame {
                 me.state = GameState::Placing;
                 me.current_player = PlayerColor::Black;
 
-                me.finish_turn();
+                me.finish_turn(world);
                 me.last_turn_timing = now;
 
                 Ok(())
@@ -346,7 +348,7 @@ impl MillGame {
             mouse_y: 0,
 
             turn_finished: false,
-            turn_states: TurnState::default(),
+            turn_states: Vec::new(),
 
             selected_field: None,
 
@@ -363,28 +365,31 @@ impl MillGame {
         Ok(())
     }
 
-    pub fn finish_turn(&mut self) {
+    pub fn finish_turn(&mut self, world: &World) {
         Self::log(
             &format!("{:?} finished turn", self.current_player),
             LogSeverity::Debug,
         );
 
-        self.last_turn_timing = self.engine.time();
+        self.last_turn_timing = world.now();
         self.turn_finished = true;
         self.selected_field = None;
     }
 
-    fn print_game_state(&self, severity: LogSeverity, log_state: bool) -> Result<()> {
-        let current_turn_state = TurnState::new(self)?;
+    fn print_game_state(
+        &mut self,
+        world: &World,
+        severity: LogSeverity,
+        log_state: bool,
+    ) -> Result<()> {
+        let current_turn_state = TurnState::new(world, self)?;
 
         if log_state {
             current_turn_state.log(severity);
         }
 
-        let mut turn_states = self.turn_states.lock().unwrap();
-
-        if !turn_states.is_empty() {
-            let (new_diff, old_diff) = current_turn_state.diff(turn_states.last().unwrap());
+        if !self.turn_states.is_empty() {
+            let (new_diff, old_diff) = current_turn_state.diff(self.turn_states.last().unwrap());
 
             // verity that last turn actually something happened
             debug_assert!(!new_diff.is_empty());
@@ -396,136 +401,127 @@ impl MillGame {
             new_diff.log(severity);
         }
 
-        turn_states.push(current_turn_state);
+        self.turn_states.push(current_turn_state);
 
         Ok(())
     }
 
-    fn next_game_step(&self) -> Result<()> {
-        {
-            let mut state = self.state.lock().unwrap();
+    fn next_game_step(&mut self, world: &World) -> Result<()> {
+        Self::log(
+            &format!(
+                " =========================== NEW TURN ({:?}) ===========================",
+                self.state
+            ),
+            LogSeverity::Basic,
+        );
 
-            Self::log(
-                &format!(
-                    " =========================== NEW TURN ({:?}) ===========================",
-                    state
-                ),
-                LogSeverity::Basic,
-            );
+        self.print_game_state(world, LogSeverity::Basic, false)?;
 
-            self.print_game_state(LogSeverity::Basic, false)?;
-
-            match *state {
-                GameState::Placing => {
-                    // check if all stones are placed
-                    if !self
-                        .black_stones
-                        .lock()
-                        .unwrap()
-                        .iter()
-                        .any(|stones| stones.state == StoneState::ReadyToBePlaced)
-                        && !self
-                            .white_stones
-                            .lock()
-                            .unwrap()
-                            .iter()
-                            .any(|stones| stones.state == StoneState::ReadyToBePlaced)
-                    {
-                        Self::log("change state to Main", LogSeverity::Debug);
-                        *state = GameState::Main;
-                    }
-
-                    self.current_player.lock().unwrap().swap();
-                }
-                GameState::Removing => {
-                    // check if all stones are placed, then decide whether main or placing is next state
-                    if !self
-                        .black_stones
-                        .lock()
-                        .unwrap()
-                        .iter()
-                        .any(|stones| stones.state == StoneState::ReadyToBePlaced)
-                        && !self
-                            .white_stones
-                            .lock()
-                            .unwrap()
-                            .iter()
-                            .any(|stones| stones.state == StoneState::ReadyToBePlaced)
-                    {
-                        Self::log("change state to Main", LogSeverity::Debug);
-                        *state = GameState::Main;
-                    } else {
-                        Self::log("change state to Placing", LogSeverity::Debug);
-                        *state = GameState::Placing;
-                    }
-
-                    self.current_player.lock().unwrap().swap();
-                }
-                GameState::Main => {
-                    // check if each player has enough stones to play
-                    if self
+        match self.state {
+            GameState::Placing => {
+                // check if all stones are placed
+                if !self
+                    .black_stones
+                    .iter()
+                    .any(|stones| stones.state == StoneState::ReadyToBePlaced)
+                    && !self
                         .white_stones
-                        .lock()
-                        .unwrap()
                         .iter()
-                        .filter(|stone| stone.state != StoneState::Dead)
-                        .collect::<Vec<&Stone>>()
-                        .len()
-                        <= 3
-                    {
-                        *state = GameState::Won(PlayerColor::Black);
-                        return Ok(());
-                    }
-
-                    if self
-                        .black_stones
-                        .lock()
-                        .unwrap()
-                        .iter()
-                        .filter(|stone| stone.state != StoneState::Dead)
-                        .collect::<Vec<&Stone>>()
-                        .len()
-                        <= 3
-                    {
-                        *state = GameState::Won(PlayerColor::White);
-                        return Ok(());
-                    }
-
-                    self.current_player.lock().unwrap().swap();
+                        .any(|stones| stones.state == StoneState::ReadyToBePlaced)
+                {
+                    Self::log("change state to Main", LogSeverity::Debug);
+                    self.state = GameState::Main;
                 }
-                GameState::Waiting => unreachable!(),
-                GameState::Won(_) => (),
+
+                self.current_player.swap();
             }
+            GameState::Removing => {
+                // check if all stones are placed, then decide whether main or placing is next state
+                if !self
+                    .black_stones
+                    .iter()
+                    .any(|stones| stones.state == StoneState::ReadyToBePlaced)
+                    && !self
+                        .white_stones
+                        .iter()
+                        .any(|stones| stones.state == StoneState::ReadyToBePlaced)
+                {
+                    Self::log("change state to Main", LogSeverity::Debug);
+                    self.state = GameState::Main;
+                } else {
+                    Self::log("change state to Placing", LogSeverity::Debug);
+                    self.state = GameState::Placing;
+                }
+
+                self.current_player.swap();
+            }
+            GameState::Main => {
+                // check if each player has enough stones to play
+                if self
+                    .white_stones
+                    .iter()
+                    .filter(|stone| stone.state != StoneState::Dead)
+                    .collect::<Vec<&Stone>>()
+                    .len()
+                    <= 3
+                {
+                    self.state = GameState::Won(PlayerColor::Black);
+                    return Ok(());
+                }
+
+                if self
+                    .black_stones
+                    .iter()
+                    .filter(|stone| stone.state != StoneState::Dead)
+                    .collect::<Vec<&Stone>>()
+                    .len()
+                    <= 3
+                {
+                    self.state = GameState::Won(PlayerColor::White);
+                    return Ok(());
+                }
+
+                self.current_player.swap();
+            }
+            GameState::Waiting => unreachable!(),
+            GameState::Won(_) => (),
         }
 
-        let player = *self.current_player.lock().unwrap();
+        Self::log(
+            &format!("current player {:?}", self.current_player),
+            LogSeverity::Debug,
+        );
 
-        Self::log(&format!("current player {:?}", player), LogSeverity::Debug);
+        let mut resources = world.resources.multi_mut();
+        let gui_handler = resources.get::<GuiHandler>();
+        let simple_ai = resources.get::<SimpleAI>();
 
-        match player {
+        match self.current_player {
             PlayerColor::White => {
                 self.black_player_label
-                    .set_background(Color::try_from("#9b9292")?)?;
-                self.white_player_label.set_background(Color::Yellow)?;
+                    .set_background(gui_handler, Color::try_from("#9b9292")?)?;
+                self.white_player_label
+                    .set_background(gui_handler, Color::Yellow)?;
             }
             PlayerColor::Black => {
                 self.white_player_label
-                    .set_background(Color::try_from("#9b9292")?)?;
-                self.black_player_label.set_background(Color::Yellow)?;
+                    .set_background(gui_handler, Color::try_from("#9b9292")?)?;
+                self.black_player_label
+                    .set_background(gui_handler, Color::Yellow)?;
             }
         }
 
-        if player == self.simple_ai.player_color {
+        if self.current_player == simple_ai.player_color {
             Self::log("current player is AI", LogSeverity::Debug);
 
-            self.simple_ai.step(
-                &mut self.stones(self.simple_ai.player_color),
-                self.board.lock().unwrap().slots(),
+            simple_ai.step(
+                &mut self.stones(simple_ai.player_color),
+                self.board.slots_mut(),
                 &mut *self.scene.lock().unwrap(),
-                &mut *self.state.lock().unwrap(),
+                &mut self.state,
             )?;
 
-            self.finish_turn();
+            self.finish_turn(world);
         }
 
         Self::log("leave next_game_step", LogSeverity::Debug);
@@ -601,12 +597,12 @@ impl MillGame {
         (x, y, z): (usize, usize, usize),
         board: &mut [[[BoardSlot; 3]; 3]; 3],
         player_color: PlayerColor,
-        scene: &mut Scene,
+        world: &mut World,
         state: &mut GameState,
     ) -> Result<MillState> {
         Self::log("place_stone", LogSeverity::Debug);
 
-        let slot = &board[x][y][z];
+        let slot = &mut board[x][y][z];
 
         match player_color {
             PlayerColor::White => {
@@ -637,7 +633,7 @@ impl MillGame {
 
         stone.state = StoneState::Placed;
 
-        let entity = scene.entity_mut(stone.stone)?;
+        let entity = world.entity_mut(stone.stone)?;
 
         let location = entity.get_component_mut::<Location>()?;
         location.set_position(slot.position.extend(0.0));
@@ -659,7 +655,7 @@ impl MillGame {
     pub fn move_stone(
         (x, y, z): (usize, usize, usize),
         (tx, ty, tz): (usize, usize, usize),
-        scene: &mut Scene,
+        world: &mut World,
         board: &mut [[[BoardSlot; 3]; 3]; 3],
         state: &mut GameState,
     ) -> Result<Option<MillState>> {
@@ -668,8 +664,8 @@ impl MillGame {
             LogSeverity::Debug,
         );
 
-        let slot = &board[x][y][z];
-        let neighbour = &board[tx][ty][tz];
+        let slot = &mut board[x][y][z];
+        let neighbour = &mut board[tx][ty][tz];
 
         if neighbour.state() != BoardSlotState::Empty
             || !Self::is_neighbour((x, y, z), (tx, ty, tz))
@@ -681,7 +677,7 @@ impl MillGame {
         neighbour.set_state(slot.state());
         slot.set_state(BoardSlotState::Empty);
 
-        scene
+        world
             .entity_mut(match neighbour.state() {
                 BoardSlotState::Black(e) => {
                     Self::log(
@@ -730,7 +726,7 @@ impl MillGame {
         Ok(Some(millstate))
     }
 
-    pub fn remove_stone(stone: &mut Stone, slot: &mut BoardSlot, scene: &mut Scene) -> Result<()> {
+    pub fn remove_stone(stone: &mut Stone, slot: &mut BoardSlot, world: &mut World) -> Result<()> {
         Self::log("remove_stone", LogSeverity::Debug);
 
         let entity = match slot.state() {
@@ -761,7 +757,7 @@ impl MillGame {
             _ => unreachable!(),
         };
 
-        scene.remove_entity(entity)?;
+        world.remove_entity(entity);
 
         assert_ne!(stone.state, StoneState::Dead);
         stone.state = StoneState::Dead;
@@ -831,30 +827,21 @@ impl MillGame {
         MillState::None
     }
 
-    fn check_mouse_click<F>(&self, f: F) -> Result<()>
+    fn check_mouse_click<F>(&mut self, scene: &Scene, f: F) -> Result<()>
     where
-        F: FnOnce(
-            &Self,
-            (usize, usize, usize),
-            &mut [[[BoardSlot; 3]; 3]; 3],
-            &mut Scene,
-        ) -> Result<()>,
+        F: FnOnce(&Self, (usize, usize, usize), &mut [[[BoardSlot; 3]; 3]; 3]) -> Result<()>,
     {
         Self::log("check_mouse_click", LogSeverity::Debug);
 
-        self.scene.lock().unwrap().on_scene(|scene| {
-            if let Some(world_space) = scene.screen_space_to_world(self.mouse_x, self.mouse_y)? {
-                let mut board = self.board.lock().unwrap();
+        if let Some(world_space) = scene.screen_space_to_world(self.mouse_x, self.mouse_y)? {
+            if let Some(slot) = self.board.close_to_marker(world_space.truncate()) {
+                Self::log("click is close to marker", LogSeverity::Debug);
 
-                if let Some(slot) = board.close_to_marker(world_space.truncate()) {
-                    Self::log("click is close to marker", LogSeverity::Debug);
-
-                    f(self, (slot.x, slot.y, slot.z), board.slots(), scene)?;
-                }
+                f(self, (slot.x, slot.y, slot.z), self.board.slots_mut())?;
             }
+        }
 
-            Ok(())
-        })
+        Ok(())
     }
 
     fn is_neighbour((x, y, z): (usize, usize, usize), (tx, ty, tz): (usize, usize, usize)) -> bool {
@@ -904,7 +891,7 @@ impl MillGame {
         if me.turn_finished {
             if (me.last_turn_timing + Self::TURN_WAIT_TIME) < now {
                 me.turn_finished = false;
-                me.next_game_step()?;
+                me.next_game_step(world)?;
             }
         }
 
@@ -919,28 +906,28 @@ impl EventConsumer for MillGame {
                 self.mouse_x = x;
                 self.mouse_y = y;
 
-                self.camera_controls.lock().unwrap().mouse_move(
-                    x,
-                    y,
-                    &mut *self.scene.lock().unwrap(),
-                )?;
+                let mut resources = world.resources.multi_mut();
+                let camera_controls = resources.get::<TopDownCameraControl>();
+                let scene = resources.get::<Scene>();
+
+                camera_controls.mouse_move(x, y, scene.view_mut())?;
             }
-            EngineEvent::MouseButtonDown(button) => {
-                match button {
-                    MouseButton::Left => {
-                        let mut state = self.state.lock().unwrap();
-                        Self::log(
-                            &format!("User click at state {:?}", state),
-                            LogSeverity::Debug,
-                        );
+            EngineEvent::MouseButtonDown(button) => match button {
+                MouseButton::Left => {
+                    Self::log(
+                        &format!("User click at state {:?}", self.state),
+                        LogSeverity::Debug,
+                    );
 
-                        match *state {
-                            GameState::Placing => {
-                                self.check_mouse_click(|me, (x, y, z), board, scene| {
-                                    let current_player = *me.current_player.lock().unwrap();
+                    match self.state {
+                        GameState::Placing => {
+                            let mut resources = world.resources.multi_mut();
 
+                            self.check_mouse_click(
+                                resources.get::<Scene>(),
+                                |me, (x, y, z), board| {
                                     if let Some(placable) = me
-                                        .stones(current_player)
+                                        .stones(me.current_player)
                                         .iter_mut()
                                         .find(|stone| stone.state == StoneState::ReadyToBePlaced)
                                     {
@@ -949,12 +936,12 @@ impl EventConsumer for MillGame {
                                                 placable,
                                                 (x, y, z),
                                                 board,
-                                                current_player,
-                                                scene,
-                                                &mut *state,
+                                                me.current_player,
+                                                world,
+                                                &mut self.state,
                                             )? == MillState::None
                                             {
-                                                me.finish_turn();
+                                                me.finish_turn(world);
                                             }
                                         } else {
                                             Self::log(
@@ -969,28 +956,32 @@ impl EventConsumer for MillGame {
                                     }
 
                                     Ok(())
-                                })?;
-                            }
-                            GameState::Removing => {
-                                self.check_mouse_click(|me, (x, y, z), board, scene| {
+                                },
+                            )?;
+                        }
+                        GameState::Removing => {
+                            let mut resources = world.resources.multi_mut();
+
+                            self.check_mouse_click(
+                                resources.get::<Scene>(),
+                                |me, (x, y, z), board| {
                                     let slot = &mut board[x][y][z];
 
                                     Self::log(
                                         &format!(
                                             "state {:?} - player {:?}",
                                             slot.state(),
-                                            *me.current_player.lock().unwrap()
+                                            me.current_player
                                         ),
                                         LogSeverity::Debug,
                                     );
 
-                                    if match (slot.state(), *me.current_player.lock().unwrap()) {
+                                    if match (slot.state(), me.current_player) {
                                         (BoardSlotState::Black(_), PlayerColor::White) => true,
                                         (BoardSlotState::White(_), PlayerColor::Black) => true,
                                         _ => false,
                                     } {
-                                        let mut stones =
-                                            self.stones(me.current_player.lock().unwrap().other());
+                                        let mut stones = self.stones(me.current_player.other());
 
                                         let stone = stones
                                             .iter_mut()
@@ -1004,97 +995,89 @@ impl EventConsumer for MillGame {
                                             })
                                             .unwrap();
 
-                                        Self::remove_stone(stone, slot, scene)?;
+                                        Self::remove_stone(stone, slot, world)?;
 
-                                        me.finish_turn();
+                                        me.finish_turn(world);
                                     }
 
                                     Ok(())
-                                })?;
-                            }
-                            GameState::Main => {
-                                self.check_mouse_click(|me, (tx, ty, tz), board, scene| {
-                                    let mut selected_slot = me.selected_field.lock().unwrap();
+                                },
+                            )?;
+                        }
+                        GameState::Main => {
+                            let mut resources = world.resources.multi_mut();
 
-                                    match *selected_slot {
-                                        Some((x, y, z)) => {
-                                            if Self::is_neighbour((x, y, z), (tx, ty, tz)) {
-                                                if let Some(millstate)
-                                                    = Self::move_stone((x,y,z), (tx,ty,tz), scene, board, &mut state)?  {
-                                                    if let MillState::None = millstate {
-                                                        *selected_slot = None;
-                                                        drop(selected_slot);
-
-                                                        self.finish_turn();
-                                                    }
+                            self.check_mouse_click(resources.get::<Scene>() , |me, (tx, ty, tz), board| {
+                                match me.selected_field {
+                                    Some((x, y, z)) => {
+                                        if Self::is_neighbour((x, y, z), (tx, ty, tz)) {
+                                            if let Some(millstate)
+                                                = Self::move_stone((x,y,z), (tx,ty,tz), world, board, &mut self.state)?  {
+                                                if let MillState::None = millstate {
+                                                    me.selected_field = None;
+                                                    self.finish_turn(world);
                                                 }
                                             }
                                         }
-                                        None => {
-                                            let slot = &board[tx][ty][tz];
-
-                                            match (
-                                                slot.state(),
-                                                *me.current_player.lock().unwrap(),
-                                            ) {
-                                                (BoardSlotState::Black(_), PlayerColor::Black)
-                                                | (BoardSlotState::White(_), PlayerColor::White) => {
-                                                    Self::log(
-                                                        &format!("Selected ({:?})", (tx, ty, tz)),
-                                                        LogSeverity::Basic,
-                                                    );
-
-                                                    *selected_slot = Some((tx, ty, tz));
-                                                }
-
-                                                _ => (),
-                                            }
-                                        }
                                     }
+                                    None => {
+                                        let slot = &board[tx][ty][tz];
 
-                                    Ok(())
-                                })?;
-                            }
-                            GameState::Waiting | GameState::Won(_) => (),
-                        }
-                    }
-                    MouseButton::Middle => self.camera_controls.lock().unwrap().hold(),
-                    MouseButton::Right => {
-                        let mut selected_slot = self.selected_field.lock().unwrap();
+                                        match (
+                                            slot.state(),
+                                            me.current_player,
+                                        ) {
+                                            (BoardSlotState::Black(_), PlayerColor::Black)
+                                            | (BoardSlotState::White(_), PlayerColor::White) => {
+                                                Self::log(
+                                                    &format!("Selected ({:?})", (tx, ty, tz)),
+                                                    LogSeverity::Basic,
+                                                );
 
-                        if selected_slot.is_some() {
-                            Self::log(
-                                &format!("Released selection ({:?})", selected_slot.unwrap()),
-                                LogSeverity::Basic,
-                            );
-                            *selected_slot = None;
+                                                    me.selected_field = Some((tx, ty, tz));
+                                            }
+
+                                            _ => (),
+                                        }
+                                    }
+                                }
+
+                                Ok(())
+                            })?;
                         }
+                        GameState::Waiting | GameState::Won(_) => (),
                     }
-                    MouseButton::Forward => (),
-                    MouseButton::Backward => (),
                 }
-            }
+                MouseButton::Middle => world.resources.get_mut::<TopDownCameraControl>().hold(),
+                MouseButton::Right => {
+                    if self.selected_field.is_some() {
+                        Self::log(
+                            &format!("Released selection ({:?})", self.selected_field.unwrap()),
+                            LogSeverity::Basic,
+                        );
+
+                        self.selected_field = None;
+                    }
+                }
+                MouseButton::Forward => (),
+                MouseButton::Backward => (),
+            },
             EngineEvent::MouseButtonUp(button) => match button {
                 MouseButton::Left => (),
-                MouseButton::Middle => self.camera_controls.lock().unwrap().release(),
+                MouseButton::Middle => world.resources.get_mut::<TopDownCameraControl>().release(),
                 MouseButton::Right => (),
                 MouseButton::Forward => (),
                 MouseButton::Backward => (),
             },
-            EngineEvent::MouseWheel(_x, y, direction) => self
-                .camera_controls
-                .lock()
-                .unwrap()
-                .scroll_wheel(y, direction, &mut *self.scene.lock().unwrap())?,
+            EngineEvent::MouseWheel(_x, y, direction) => {
+                let mut resources = world.resources.multi_mut();
+                let camera_controls = resources.get::<TopDownCameraControl>();
+                let scene = resources.get::<Scene>();
 
-            EngineEvent::KeyDown(_) => (),
-            EngineEvent::KeyUp(_) => (),
-            EngineEvent::ButtonDown(_) => (),
-            EngineEvent::ButtonUp(_) => (),
-            EngineEvent::ControllerAxis(_) => (),
-            EngineEvent::ControllerAdded(_) => (),
-            EngineEvent::ControllerRemoved(_) => (),
-            EngineEvent::FileDrop(_) => (),
+                camera_controls.scroll_wheel(y, direction, scene.view_mut())?;
+            }
+
+            _ => (),
         }
 
         Ok(())