Rework graf karto to fit the client/server structure

1 files changed, 206 insertions, 0 deletions

diff --git a/src/client/map/mod.rs b/src/client/map/mod.rs
new file mode 100644
index 0000000..eaab72f
--- /dev/null
+++ b/src/client/map/mod.rs
@@ -0,0 +1,206 @@
+//! The map is a visual interpretation of all the items that make up the world.
+//!
+//! It's the main structure that the client uses to interact with the world, since
+//! the world contains all the
+
+pub mod icon_mark;
+pub mod icon_texture_manager;
+pub mod mappable;
+pub mod room_mark;
+pub mod wall_mark;
+
+pub use icon_mark::*;
+pub use mappable::Mappable;
+pub use room_mark::*;
+pub use wall_mark::*;
+
+use crate::client::Transform;
+use crate::stable_vec::StableVec;
+use crate::world::{Room, Wall, World};
+use icon_texture_manager::IconTextureManager;
+use raylib::drawing::RaylibDrawHandle;
+use raylib::{RaylibHandle, RaylibThread};
+use std::rc::Rc;
+
+/// The map containing all map elements that are seen on the screen.
+pub struct Map {
+    rooms: StableVec<RoomMark>,
+    walls: StableVec<WallMark>,
+    icons: StableVec<IconMark>,
+    used_ids: StableVec<()>,
+    icon_renderer: Rc<IconTextureManager>,
+}
+
+impl Map {
+    /// Create a new, empty map/world.
+    pub fn new(rl: &mut RaylibHandle, rlt: &RaylibThread) -> Self {
+        Self {
+            rooms: StableVec::new(),
+            walls: StableVec::new(),
+            icons: StableVec::new(),
+            used_ids: StableVec::new(),
+            icon_renderer: Rc::new(IconTextureManager::new(rl, rlt)),
+        }
+    }
+
+    pub fn add_room(&mut self, id: usize, room: Room) -> bool {
+        if self.used_ids.try_insert(id, ()).is_ok() {
+            self.rooms
+                .try_insert(id, RoomMark::from_room(room))
+                .unwrap();
+            true
+        } else {
+            error!("Unable to add room. Id already in use.");
+            false
+        }
+    }
+
+    /// Add a wall with a specific id. May fail if there already is an entity with that id.
+    pub fn add_wall(&mut self, id: usize, wall: Wall) -> bool {
+        if self.used_ids.try_insert(id, ()).is_ok() {
+            /* Check for intersections with any wall that was arleady created so the wall ends can be
+             * rendered properly.
+             */
+            let mut start_intersects = false;
+            let mut end_intersects = false;
+            for (_, wall) in self.walls.iter() {
+                if wall.shape().contains_collinear(wall.shape().start) {
+                    start_intersects = true;
+                }
+                if wall.shape().contains_collinear(wall.shape().end) {
+                    end_intersects = true;
+                }
+
+                // Currently, additional intersections can be ignored, since it is just a yes-no-question
+                if start_intersects && end_intersects {
+                    break;
+                }
+            }
+
+            self.walls
+                .try_insert(
+                    id,
+                    WallMark::from_wall(wall, start_intersects, end_intersects),
+                )
+                .unwrap();
+            true
+        } else {
+            error!("Unable to add wall. Id already in use.");
+            false
+        }
+    }
+
+    /// Add an icon with a specific id. May fail if there already is an entity with that id.
+    pub fn add_icon(&mut self, id: usize, icon: IconMark) -> bool {
+        if self.used_ids.try_insert(id, ()).is_ok() {
+            self.icons.try_insert(id, icon).unwrap();
+            true
+        } else {
+            error!("Unable to add icon. Id already in use.");
+            false
+        }
+    }
+
+    /// Draw all elements of the map to the screen. This should be called after the background of the
+    /// map has already been drawn.
+    pub fn draw(&self, rld: &mut RaylibDrawHandle, transform: &Transform) {
+        for (_, element) in self.elements() {
+            element.draw(rld, transform);
+        }
+    }
+
+    /// Get the icon-renderer that is currently used to render the icons.
+    pub fn icon_renderer(&self) -> Rc<IconTextureManager> {
+        self.icon_renderer.clone()
+    }
+
+    /// Remove item with the id, if it exists. Returns `true` if an item existed, `false` otherwise.
+    pub fn remove(&mut self, id: usize) -> bool {
+        if self.used_ids.remove(id).is_none() {
+            return false;
+        }
+
+        if self.rooms.remove(id).is_some()
+            || self.walls.remove(id).is_some()
+            || self.icons.remove(id).is_some()
+        {
+            true
+        } else {
+            panic!(
+                "Id {} was still registered, eventhough there was no such entity.",
+                id
+            );
+        }
+    }
+
+    /// Iterator over all elements as objects when an operation needs to go over all elements of the
+    /// map.
+    pub fn elements(&self) -> impl Iterator<Item = (usize, &dyn Mappable)> {
+        self.rooms
+            .iter()
+            .map(|(id, p)| (*id, p as &dyn Mappable))
+            .chain(self.walls.iter().map(|(id, w)| (*id, w as &dyn Mappable)))
+            .chain(self.icons.iter().map(|(id, i)| (*id, i as &dyn Mappable)))
+    }
+
+    /// Iterator over all elements, but the individual elements can be mutated. It is however
+    /// impossible to add or remove elements in this way. For that, use the dedicated functions.
+    pub fn elements_mut(&mut self) -> impl Iterator<Item = (usize, &mut dyn Mappable)> {
+        self.rooms
+            .id_iter_mut()
+            .map(|(id, p)| (id, p as &mut dyn Mappable))
+            .chain(
+                self.walls
+                    .id_iter_mut()
+                    .map(|(id, w)| (id, w as &mut dyn Mappable)),
+            )
+            .chain(
+                self.icons
+                    .id_iter_mut()
+                    .map(|(id, i)| (id, i as &mut dyn Mappable)),
+            )
+    }
+
+    /// Get the rooms of this map.
+    pub fn rooms(&self) -> &StableVec<RoomMark> {
+        &self.rooms
+    }
+
+    /// Get the walls of this map.
+    pub fn walls(&self) -> &StableVec<WallMark> {
+        &self.walls
+    }
+
+    /// Get the icons of this map.
+    pub fn icons(&self) -> &StableVec<IconMark> {
+        &self.icons
+    }
+
+    /// Replace the internal map data with the data of the world provided.
+    /// (Load and replace)
+    pub fn set_data(&mut self, world: World) {
+        // Remove all data.
+        self.icons.clear();
+        self.rooms.clear();
+        self.walls.clear();
+
+        // Add all data from the map data.
+        self.add_data(world);
+    }
+
+    /// Add the data provided to the current data on the map. All elements will
+    /// remain, with the additional elements being pushed also. This must be
+    /// used with caution, since the ids of the items will remain unchanged, and
+    /// items with the same id will therefore be ignored and not added.
+    pub fn add_data(&mut self, world: World) {
+        for (id, i) in world.icons().iter() {
+            self.add_icon(*id, IconMark::from_icon(*i, self.icon_renderer.clone()));
+        }
+        for (id, r) in world.rooms().iter() {
+            self.add_room(*id, r.clone());
+        }
+        for (id, w) in world.walls().iter() {
+            self.add_wall(*id, w.clone());
+        }
+    }
+}