tiny_ecs 0.17.0

/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

//! # Tiny ECS
//!
//! The intention of this crate is that a basic ECS is provided, where
//! you will be required to exercise a little additional control. This is
//! somewhat due to some limitations, and also due to trying to maintain
//! as little overhead as possible - this means no unneccesary copies/clones.
//!
//! Where most other ECS crates provide a mechanism for inserting "systems"
//! in to the ECS to run against entities, this one leaves it out - you can
//! think of it as a "system for entity/components". You will need to create
//! external systems; these can be a function, a loop, or anything else.
//!
//! The basis of this ECS is the use of `bitmasks`. Each entity ID is in
//! practice an internal index number in to an array which contains bitmasks.
//! The bitmasks themselves keep track of what components the entity has.
//! For the most part, bitmasks are handled for you, and some helper methods
//! are available to hide their use, but there are also methods to get the
//! bitmask for any ID if you are inclined to do some manual management.
//!
//! **Note:** defaults to bitmask of `u64` size (so 64 components). If you
//! need a smaller mask the feature `bitmask_max_32` can be enabled for
//! mask of `u32` size.
//!
//! **Attention:** borrows of `ComponentMap` are checked at runtime.
//!
//! # Examples
//!
//! ## Init with a capacity
//!
//! This is good to do if you know the size required
//! as it will prevent many reallocs/moves as data is added. This affects
//! both the entity and component map allocs (they will be equal in length).
//!
//! ```
//! use tiny_ecs::Entities;
//!
//! let mut entities = Entities::new(Some(1000), Some(24));
//! ```
//!
//! ## Demonstrating use
//!
//! ```
//! use tiny_ecs::Entities;
//!
//! // These are the "components" we will use
//! struct Vector1 {
//!     x: i32,
//! }
//! struct Vector2 {
//!     x: i32,
//!     y: i32,
//! }
//! struct Vector3 {
//!     x: i32,
//!     y: i32,
//!     z: i32,
//! }
//!
//! // Initialize the Entity collection
//! let mut entities = Entities::new(Some(3), Some(3));
//!
//! // Creating an entity uses the builder pattern.
//! // Be sure to return the ID if you need to track it
//! let entity_1 = entities.new_entity()
//!                        .with_part(Vector1 { x: 42 })
//!                        .with_part(Vector3 { x: 3, y: 10, z: -12 })
//!                        .return_entity_id();
//! assert!(entity_1 == 0);
//!
//! // Do note however, that you can keep adding parts to this entity
//! // via the builder pattern until you choose to create another entity
//!
//! // To add another entity you need to create one
//! entities.new_entity()
//!         .with_part(Vector2 { x: 66, y: 6 })
//!         .with_part(Vector1 { x: 6 });
//!```
//!
//! ## Access an entities part of type `<T>`
//! ```
//! # use tiny_ecs::{Entities, ComponentMap};
//! # struct Vector3 {x: i32, y: i32, z: i32 }
//! # let mut entities = Entities::new(Some(3), Some(3));
//! # let entity_1 = entities.new_entity()
//! #                         .with_part(Vector3 { x: 3, y: 10, z: -12 })
//! #                         .return_entity_id();
//! // To get access to a part belonging to an entity you need
//! // first to get the component map created for the part type
//! // You need to 'anchor' this with a let or the ref is
//! // dropped before you can use it
//! let mut components = entities
//!     .borrow_mut::<Vector3>()
//!     .unwrap();
//! // You can then use the part by getting a reference
//! let mut part = components.get_part_mut(entity_1).unwrap();
//! assert_eq!(part.z, -12);
//! ```
//!
//! ## Check if `Entity` contains a part type + remove part
//! ```
//! # use tiny_ecs::Entities;
//! # struct Vector1 {x: i32 }
//! # let mut entities = Entities::new(Some(3), Some(3));
//! let entity_1 = entities.new_entity()
//!                        .with_part(Vector1 { x: 3 })
//!                        .return_entity_id();
//! // You can check if an entity contains a part with the type signature
//! if entities.entity_contains::<Vector1>(entity_1) {
//!     assert!(entities.rm_part::<Vector1>(entity_1).is_ok());
//! }
//! assert_eq!(entities.entity_contains::<Vector1>(entity_1), false);
//! ```
//!
//! ## A system that uses an `get_mut()`
//! ```
//! # use tiny_ecs::{Entities, ComponentMap};
//! # struct Vector1 {x: i32 }
//! # let mut entities = Entities::new(Some(3), Some(3));
//! # entities.new_entity().with_part(Vector1 { x: 3 });
//!
//! // Make a system of some form that takes a `ComponentMap<T>` arg
//! fn some_system(mut components: &mut ComponentMap<Vector1>) {
//!     // You can then iterate over the components directly
//!     for (k, v) in components.get_mut() {
//!         v.x += 1;
//!         assert!(v.x > k as i32);
//!     }
//! }
//! # let mut components = entities.borrow_mut::<Vector1>().unwrap();
//! some_system(&mut components);
//! ```
//!
//! ## Get components for an entity ID list
//! ```
//! # use tiny_ecs::{Entities, ComponentMap};
//! # struct Vector1 {x: i32 }
//! # let mut entities = Entities::new(Some(3), Some(3));
//! # entities.new_entity().with_part(Vector1 { x: 3 });
//!
//! // A system that fetches the components for only the entities you are require
//! fn second_system(active: &[usize], mut v1_map: &mut ComponentMap<Vector1>) {
//!     for id in active {
//!         if let Ok(part) = v1_map.get_part_mut(*id) {
//!             part.x = 42;
//!         }
//!     }
//! }
//! # let mut components = entities.borrow_mut::<Vector1>().unwrap();
//! second_system(&[0, 1, 2], &mut components);
//! ```
//!
//! ## A more complex system using ComponentMaps directly
//! ```
//! # use tiny_ecs::{Entities, ComponentMap};
//! # struct Vector1 {x: i32 }
//! # struct Vector2 {x: i32, y: i32 }
//! # let mut entities = Entities::new(Some(3), Some(3));
//! # entities.new_entity().with_part(Vector1 { x: 3 })
//! # .with_part(Vector2 { x: 3, y: 3 });
//!
//! // Or a system handles the `Entities` container directly
//! fn other_system(active_ents: &[usize], entities: &mut Entities) {
//!     // You can mutably borrow multiple part types at once
//!     let mut v1_components = entities
//!         .borrow_mut::<Vector1>()
//!         .unwrap();
//!
//!     let mut v2_components = entities
//!         .borrow_mut::<Vector2>()
//!         .unwrap();
//!
//!     // But not have a mutable borrow and immutable borrow to the same
//!     // Fails at runtime!
//!     // let v2_components = entities.borrow::<Vector2>().unwrap();
//!     // But you can have multiple immutable references to the same part
//!     for id in active_ents {
//!         if entities.entity_contains::<Vector1>(*id) &&
//!            entities.entity_contains::<Vector2>(*id) {
//!             let v1_part = v1_components.get_part_mut(*id).unwrap();
//!             let v2_part = v2_components.get_part_mut(*id).unwrap();
//!             v1_part.x = 42;
//!             assert_ne!(v1_part.x, 43);
//!             assert_eq!(v1_part.x, 42);
//!         }
//!     }
//! }
//! other_system(&[0, 1, 2], &mut entities);
//! ```

use std::any::{Any, TypeId};
use std::cell::{Ref, RefCell, RefMut};
use std::collections::HashMap;
use std::error::Error;
use std::fmt;
use std::fmt::{Debug, Display};
use std::ops::{Deref, DerefMut};

use vec_map;
use vec_map::VecMap;

#[cfg(feature = "bitmask_max_32")]
type BITMASK = u32;
#[cfg(not(feature = "bitmask_max_32"))]
type BITMASK = u64;

#[cfg(feature = "bitmask_max_32")]
const BITMASK_MAX: u32 = 32;
#[cfg(not(feature = "bitmask_max_32"))]
const BITMASK_MAX: u64 = 64;

// Bitmask used to fill the initial mask list, and replace deleted entities
pub const EMPTY: BITMASK = 0;

pub enum ECSError {
    Borrow,
    BorrowMut,
    Downcast,
    DowncastMut,
    PtrRef,
    PtrMut,
    NoComponentMap,
    NoComponentForEntity,
}

impl Debug for ECSError {
    #[inline]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        Display::fmt(self.description(), f)
    }
}

impl Display for ECSError {
    #[inline]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        Display::fmt(self.description(), f)
    }
}

impl Error for ECSError {
    fn description(&self) -> &str {
        match self {
            ECSError::Borrow => "already borrowed",
            ECSError::BorrowMut => "already mutably borrowed",
            ECSError::Downcast => "could not downcast to ref",
            ECSError::DowncastMut => "could not downcast to mut ref",
            ECSError::PtrRef => "failed to convert pointer to ref",
            ECSError::PtrMut => "failed to convert pointer to mut",
            ECSError::NoComponentMap => "no part map for part type",
            ECSError::NoComponentForEntity => "part map does not contain part for entity",
        }
    }
}

/// Immutable reference container for `ComponentMap`
#[derive(Debug)]
pub struct MapRef<'a, T> {
    _borrow: Ref<'a, dyn Any>,
    value:   &'a ComponentMap<T>,
}

impl<'a, T: 'static> MapRef<'a, T> {
    fn new(value: &'a RefCell<Box<dyn Any>>) -> Result<MapRef<'a, T>, ECSError> {
        let v = (unsafe { value.as_ptr().as_ref().ok_or(ECSError::PtrRef)? })
            .downcast_ref::<ComponentMap<T>>()
            .ok_or(ECSError::Downcast)?;

        Ok(MapRef {
            value:   v,
            _borrow: value.try_borrow().or(Err(ECSError::Borrow))?,
        })
    }
}

impl<'a, T> Deref for MapRef<'a, T> {
    type Target = ComponentMap<T>;

    #[inline]
    fn deref(&self) -> &ComponentMap<T> {
        self.value
    }
}

/// Mutbale reference container for `ComponentMap`
#[derive(Debug)]
pub struct MapRefMut<'a, T> {
    _borrow: RefMut<'a, dyn Any>,
    value:   &'a mut ComponentMap<T>,
}

impl<'a, T: 'static> MapRefMut<'a, T> {
    fn new(value: &'a RefCell<Box<dyn Any>>) -> Result<MapRefMut<'a, T>, ECSError> {
        let v = (unsafe { value.as_ptr().as_mut().ok_or(ECSError::PtrMut)? })
            .downcast_mut::<ComponentMap<T>>()
            .ok_or(ECSError::DowncastMut)?;

        Ok(MapRefMut {
            value:   v,
            _borrow: value.try_borrow_mut().or(Err(ECSError::BorrowMut))?,
        })
    }
}

impl<'a, T> Deref for MapRefMut<'a, T> {
    type Target = ComponentMap<T>;

    #[inline]
    fn deref(&self) -> &ComponentMap<T> {
        self.value
    }
}

impl<'a, T> DerefMut for MapRefMut<'a, T> {
    #[inline]
    fn deref_mut(&mut self) -> &mut ComponentMap<T> {
        self.value
    }
}

/// `ComponentMap` is a container type for the components used by entities
#[derive(Debug)]
pub struct ComponentMap<T> {
    map: VecMap<T>,
}

impl<T> ComponentMap<T> {
    #[inline(always)]
    fn new(init_size: usize) -> ComponentMap<T> {
        ComponentMap {
            map: VecMap::with_capacity(init_size),
        }
    }

    #[inline(always)]
    fn insert(&mut self, id: usize, part: T) {
        self.map.insert(id, part);
    }

    #[inline(always)]
    fn remove(&mut self, id: usize) {
        self.map.remove(id);
    }

    /// Getting a reference to an entity part requires the entity ID
    #[inline(always)]
    pub fn get_part_ref(&self, id: usize) -> Result<&T, ECSError> {
        if let Some(part) = self.map.get(id) {
            return Ok(part);
        }
        Err(ECSError::NoComponentForEntity)
    }

    /// Getting a mutable reference to an entity part requires the entity ID
    ///
    /// # Example
    ///
    /// ```
    /// # use tiny_ecs::{Entities, ComponentMap};
    /// #[derive(Debug, PartialEq)]
    /// struct Test1 {}
    ///
    /// # let mut entities = Entities::new(Some(3), Some(3));
    /// # let entity_1 = entities.new_entity()
    /// # .with_part(Test1 {}).return_entity_id();
    /// let components = entities.borrow::<Test1>().unwrap();
    /// let part = components.get_part_ref(entity_1).unwrap();
    /// assert_eq!(part, &Test1 {});
    /// // or
    /// let part = components.get_part_ref(entity_1).unwrap();
    /// assert_eq!(part, &Test1 {});
    /// ```
    #[inline(always)]
    pub fn get_part_mut(&mut self, id: usize) -> Result<&mut T, ECSError> {
        if let Some(part) = self.map.get_mut(id) {
            return Ok(part);
        }
        Err(ECSError::NoComponentForEntity)
    }

    /// Returns a borrow of the inner hashmap of components
    #[inline(always)]
    pub fn get(&self) -> &VecMap<T> {
        &self.map
    }

    /// Returns a mutable borrow of the inner hashmap of components
    #[inline(always)]
    pub fn get_mut(&mut self) -> &mut VecMap<T> {
        &mut self.map
    }
}

/// This is the root of the ECS implementation
#[derive(Debug)]
pub struct Entities {
    entity_masks:     Vec<BITMASK>,
    components:       HashMap<BITMASK, RefCell<Box<dyn Any>>>,
    next_free_entity: usize,
    vacated_slots:    Vec<usize>,
    type_masks:       HashMap<TypeId, BITMASK>,
    next_typemask:    BITMASK,
    current_entity:   usize,
}

impl Default for Entities {
    /// Create a new `Entities` struct with no pre-allocated memory for maps
    fn default() -> Self {
        Entities::new(None, None)
    }
}

impl Entities {
    /// Create a new root entity container.
    ///
    /// - `entity_count` will initialize the entity map and new
    ///   component maps to this size. This is a good thing to do to
    ///   prevent unnecessary (re)allocations if you know the total
    ///   active entity count. Entity removals will free up slots which
    ///   are then reused instead of expanding the map.
    /// - `part_count` is as above, for total part types/kinds, there is
    ///   a maximum of either 32 or 64 individual parts you can add of
    ///   which the index starts at 0 to n-1
    pub fn new(entity_count: Option<usize>, part_count: Option<usize>) -> Entities {
        if let Some(part_count) = part_count {
            if part_count as BITMASK > BITMASK_MAX {
                panic!(
                    "Initial part count too large. Maximum of {} allowed",
                    BITMASK_MAX
                );
            }
        }
        Entities {
            entity_masks:     vec![EMPTY; entity_count.unwrap_or(0)],
            components:       HashMap::with_capacity(part_count.unwrap_or(0)),
            next_free_entity: 0,
            vacated_slots:    Vec::new(),
            type_masks:       HashMap::with_capacity(part_count.unwrap_or(0)),
            next_typemask:    1,
            current_entity:   0,
        }
    }

    /// Find the first `EMPTY` ID number to use
    ///
    /// As entities are only created by actually inserting new components in to
    /// the Entity structure, this should be called to find the first
    /// available entity slot. Slot states are determined by the mask
    /// it holds.
    #[inline]
    pub fn new_entity(&mut self) -> &mut Self {
        if let Some(slot) = self.vacated_slots.pop() {
            self.current_entity = slot;
            return self;
        }
        self.current_entity = self.next_free_entity;
        self.entity_masks.push(EMPTY);
        self.next_free_entity += 1;
        self
    }

    /// Adding a part requires a valid slot along with the initialised data
    /// to use with the entity. Effectively creates the entity if the slot is
    /// currently empty.
    ///
    /// A bitmask is created internally for each data type added (only one per type).
    ///
    /// # Example
    ///
    /// ```
    /// # use tiny_ecs::Entities;
    /// struct Test1 {}
    /// const TEST1: u32 = 1 << 2;
    ///
    /// # let mut entities = Entities::new(Some(3), Some(3));
    /// let entity_1 = entities.new_entity().with_part(Test1 {}).return_entity_id();
    /// assert_eq!(entity_1, 0);
    /// ```
    #[inline]
    pub fn with_part<T: 'static>(&mut self, part: T) -> &mut Self {
        let tid = TypeId::of::<T>();
        if (self.type_masks.len() as BITMASK) >= BITMASK_MAX {
            panic!("Out of bitmasks to assign to component type");
        }
        if !self.type_masks.contains_key(&tid) {
            self.type_masks.insert(tid, self.next_typemask);
            self.next_typemask = self.next_typemask << 1;
        }

        let type_mask = self.type_masks[&tid];
        // add HashMap for these components if there is no map
        // for them already
        let len = self.entity_masks.len();
        self.components
            .entry(type_mask)
            .or_insert_with(|| RefCell::new(Box::new(ComponentMap::<T>::new(len))));

        // This really shouldn't ever fail
        let id = self.current_entity;
        if let Some(col) = self.components.get_mut(&type_mask) {
            col.borrow_mut()
                .downcast_mut::<ComponentMap<T>>()
                .expect("could not downcast to mut ref when inserting new component")
                .insert(id, part);
            // update the entity mask
            let old = self.entity_masks[id];
            self.entity_masks[id] = old | type_mask;
        }
        self
    }

    pub fn return_entity_id(&self) -> usize {
        self.current_entity
    }

    /// Returns the mask of the requested entity enabling you to manually
    /// check composition using bitmasks.
    #[inline]
    pub fn get_entity_mask(&self, id: usize) -> Option<&BITMASK> {
        self.entity_masks.get(id)
    }

    /// Returns the mask associated with the requested type.
    #[inline]
    pub fn get_type_mask<T: 'static>(&self) -> Option<&BITMASK> {
        self.type_masks.get(&TypeId::of::<T>())
    }

    #[inline(always)]
    pub fn entity_contains<T: 'static>(&self, id: usize) -> bool {
        if let Some(entity_mask) = self.entity_masks.get(id) {
            if let Some(type_mask) = self.type_masks.get(&TypeId::of::<T>()) {
                if entity_mask & type_mask == *type_mask {
                    return true;
                }
            }
        }
        false
    }

    /// Remove an entities part. If no components are left after part removal then
    /// the entity is considered deleted and an `EMPTY` (0) mask is inserted in
    /// its place.
    ///
    /// Removal requires the ID of the entity and the components type signature.
    ///
    /// # Example
    ///
    /// ```
    /// # use tiny_ecs::{Entities, EMPTY};
    /// #[derive(Debug, PartialEq)]
    /// struct Test1 {}
    ///
    /// # let mut entities = Entities::new(Some(3), Some(3));
    /// # let entity_1 = entities.new_entity()
    /// # .with_part(Test1 {}).return_entity_id();
    /// assert!(entities.rm_part::<Test1>(entity_1).is_ok());
    /// assert_eq!(*entities.get_entity_mask(entity_1).unwrap(), EMPTY);
    /// ```
    #[inline]
    pub fn rm_part<T: 'static>(&mut self, id: usize) -> Result<(), ECSError> {
        let type_mask = self.type_masks[&TypeId::of::<T>()];
        if let Some(map) = self.components.get_mut(&type_mask) {
            map.borrow_mut()
                .downcast_mut::<ComponentMap<T>>()
                .ok_or(ECSError::DowncastMut)?
                .remove(id);
            self.entity_masks[id] ^= type_mask;
            if self.entity_masks[id] == EMPTY {
                self.vacated_slots.push(id)
            }
            return Ok(());
        }
        Err(ECSError::NoComponentMap)
    }

    /// Get a plain reference to the selected entity part map
    ///
    /// You may have multiple immutable references to the requested `ComponentMap`
    /// **type** but no mutable references if the same **typed** `ComponentMap`
    /// is currently referenced.
    ///
    /// - `Option` is whether or not there is a part of `<T>` for that entity.
    /// - Borrowing (`Ref`) is checked at runtime.
    ///
    /// # Example
    /// ```
    /// # use tiny_ecs::{Entities, ComponentMap};
    /// # struct Test1 { x: u32 }
    /// # let mut entities = Entities::new(Some(3), Some(3));
    /// # let entity_1 = entities.new_entity()
    /// # .with_part(Test1 { x: 666 }).return_entity_id();
    /// let components = entities
    ///     .borrow::<Test1>()
    ///     .unwrap();
    /// let part = components.get_part_ref(entity_1).unwrap();
    /// ```
    #[inline(always)]
    pub fn borrow<T: 'static>(&self) -> Result<MapRef<T>, ECSError> {
        if let Some(type_mask) = self.type_masks.get(&TypeId::of::<T>()) {
            if let Some(components) = self.components.get(&type_mask) {
                return Ok(MapRef::new(components)?);
            }
        }
        Err(ECSError::NoComponentMap)
    }

    /// Get a mutable reference to the selected entity part map
    ///
    /// You may have only one mutable reference to the requested `ComponentMap`
    /// **type** and no immutable references. You can however, have multiple
    /// mutable references to different **types** of `ComponentMap`
    ///
    /// - `Result` covers if the map was able to be borrowed mutably or not.
    /// - Borrowing is checked at runtime.
    ///
    /// # Example
    /// ```
    /// # use tiny_ecs::{Entities, ComponentMap};
    /// # #[derive(Debug, PartialEq)]
    /// # struct Test1 { x: u32 }
    /// # let mut entities = Entities::new(Some(3), Some(3));
    /// # let entity_1 = entities.new_entity()
    /// # .with_part(Test1 { x: 0 }).return_entity_id();
    /// // Because we later need a ref to the same `Type` of map, the mut ref
    /// // will need to be scoped. If the later ref was of a different type,
    /// // eg: Vector2, then it wouldn't need scoping.
    /// {
    ///     let mut components = entities
    ///         .borrow_mut::<Test1>()
    ///         .unwrap();
    ///     for id in 0..5 {
    ///         if let Ok(part) = components.get_part_mut(id) {
    ///             part.x = 42;
    ///         }
    ///     }
    /// }
    ///
    /// // Now get a ref to the modified part
    /// let components = entities.borrow::<Test1>().unwrap();
    /// let part = components.get_part_ref(entity_1).unwrap();
    /// assert_eq!(part.x, 42);
    /// ```
    #[inline(always)]
    pub fn borrow_mut<T: 'static>(&self) -> Result<MapRefMut<T>, ECSError> {
        if let Some(type_mask) = self.type_masks.get(&TypeId::of::<T>()) {
            if let Some(components) = self.components.get(&type_mask) {
                return Ok(MapRefMut::new(components)?);
            }
        }
        Err(ECSError::NoComponentMap)
    }
}

#[cfg(test)]
mod tests {
    use crate::Entities;

    #[test]
    fn add_entity_and_part_check_contains_and_mask() {
        struct Test1 {}
        struct Test2 {}
        struct Test3 {}

        let mut entities = Entities::new(Some(3), Some(3));
        // Creating a new entity should find the next free slot
        // and then insert a new blank bitmask
        // Return entity number
        let entity_1 = entities.new_entity().with_part(Test1 {}).return_entity_id();
        assert_eq!(entity_1, 0);

        let entity_1_mask = entities.get_entity_mask(entity_1).unwrap();
        // The mask for this entity should have been updated
        let type_mask = entities.get_type_mask::<Test1>().unwrap();
        assert_eq!(entity_1_mask, type_mask);
        assert!(entities.entity_contains::<Test1>(entity_1));
        assert!(!entities.entity_contains::<Test2>(entity_1));

        entities.with_part(Test3 {});
        assert!(entities.entity_contains::<Test3>(entity_1));

        // should increment entities.next_free_entity
        let e2 = entities.new_entity().return_entity_id();
        assert_eq!(e2, 1);
    }

    #[test]
    fn get_part_map_for_type_as_ref() {
        struct Test1 {}

        let mut entities = Entities::new(Some(3), Some(3));
        // Should return None
        {
            let m = entities.borrow::<Test1>();
            assert!(m.is_err());
        }

        let entity_1 = entities.new_entity().with_part(Test1 {}).return_entity_id();
        // Should return the HashMap
        let map = entities.borrow::<Test1>();
        assert!(map.is_ok());

        let map = entities.borrow::<Test1>().unwrap();
        assert!(map.get_part_ref(entity_1).is_ok());
    }

    #[test]
    fn get_part_map_for_type_as_mut() {
        struct Test1 {}

        let mut entities = Entities::new(Some(3), Some(3));
        // Should return None
        {
            let m = entities.borrow_mut::<Test1>();
            assert!(m.is_err());
        }

        let entity_1 = entities.new_entity().with_part(Test1 {}).return_entity_id();
        // Should return the HashMap

        let map = entities.borrow_mut::<Test1>();
        assert!(map.is_ok());

        let mut map = map.unwrap();
        assert!(map.get_part_mut(entity_1).is_ok());
    }

    #[test]
    fn components_ref_and_mut_diff_components_and_modify() {
        #[derive(Debug, PartialEq)]
        struct Test1 {
            x: u32,
        }

        #[derive(Debug, PartialEq)]
        struct Test2 {
            x: u32,
        }

        let mut entities = Entities::new(Some(3), Some(3));
        let entity_1 = entities
            .new_entity()
            .with_part(Test1 { x: 66 })
            .with_part(Test2 { x: 42 })
            .return_entity_id();

        let components = entities.borrow::<Test1>().unwrap();
        let part = components.get_part_ref(entity_1).unwrap();
        assert_eq!(part, &Test1 { x: 66 });
        assert!(entities.entity_contains::<Test1>(entity_1));

        {
            let mut components = entities.borrow_mut::<Test2>().unwrap();
            let part = components.get_part_mut(entity_1).unwrap();
            assert_eq!(part.x, 42);
            part.x = 666;
            assert_ne!(part.x, 42);
        }
        let mut _p = entities.borrow_mut::<Test2>().unwrap();
        assert!(entities.borrow_mut::<Test2>().is_err());
    }

    #[test]
    fn components_iter_ref() {
        struct Test1 {
            x: usize,
        }

        let mut entities = Entities::new(Some(3), Some(3));
        let mut ids = Vec::new();
        // 1
        let id = entities
            .new_entity()
            .with_part(Test1 { x: 0 })
            .return_entity_id();
        ids.push(id);
        // 2
        let id = entities
            .new_entity()
            .with_part(Test1 { x: 1 })
            .return_entity_id();
        ids.push(id);
        // 3
        let id = entities
            .new_entity()
            .with_part(Test1 { x: 2 })
            .return_entity_id();
        ids.push(id);

        let components = entities.borrow::<Test1>().unwrap();
        for (k, v) in components.get() {
            assert!(v.x == k);
        }
    }

    #[test]
    fn components_get_mut() {
        struct Test1 {
            x: usize,
        }

        let mut entities = Entities::new(Some(3), Some(3));
        let mut ids = Vec::new();
        // 1
        let id = entities
            .new_entity()
            .with_part(Test1 { x: 0 })
            .return_entity_id();
        ids.push(id);
        // 2
        let id = entities
            .new_entity()
            .with_part(Test1 { x: 1 })
            .return_entity_id();
        ids.push(id);
        // 3
        let id = entities
            .new_entity()
            .with_part(Test1 { x: 2 })
            .return_entity_id();
        ids.push(id);

        let mut components = entities.borrow_mut::<Test1>().unwrap();
        for (k, v) in components.get_mut() {
            v.x += 1;
            assert!(v.x > k);
        }
    }

    #[test]
    fn remove_components_then_entity() {
        #[derive(Debug, PartialEq)]
        struct Test1 {}

        #[derive(Debug, PartialEq)]
        struct Test2 {
            x: u32,
        }

        let mut entities = Entities::new(Some(3), Some(3));
        let entity_1 = entities
            .new_entity()
            .with_part(Test1 {})
            .with_part(Test2 { x: 42 })
            .return_entity_id();

        // rm and check entity components
        assert!(entities.entity_contains::<Test1>(entity_1));
        assert!(entities.rm_part::<Test1>(entity_1).is_ok());
        assert!(!entities.entity_contains::<Test1>(entity_1));
        assert!(entities.entity_contains::<Test2>(entity_1));

        // check masks
        let type_mask_2 = entities.get_type_mask::<Test2>().unwrap();
        assert_eq!(entities.get_entity_mask(entity_1).unwrap(), type_mask_2);

        // Removing all components erases the entity
        assert!(entities.rm_part::<Test2>(entity_1).is_ok());
        assert_eq!(*entities.get_entity_mask(entity_1).unwrap(), 0);
    }
}