tiny_ecs 0.9.5

/* 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,
//! and in some use cases you will need to use `downcast_ref` or `downcast_mut`.
//!
//! 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.
//!
//! # 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 partmaps allocs (they will be equal in size).
//!
//! ```
//! use tiny_ecs::Entities;
//!
//! let mut entities = Entities::new(Some(1000), Some(24));
//! ```
//!
//! **Demonstrating use**
//!
//! ```
//! use std::any::Any;
//! use std::cell::{Ref, RefMut};
//! use std::collections::HashMap;
//! use tiny_ecs::{Entities, PartMap};
//!
//! // 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));
//!
//! // To create an entity you only need to add the first part using
//! // a free slot
//! let entity_1 = entities.get_free_slot().unwrap();
//! entities.add_part(entity_1, Vector1 { x: 42 });
//! // And you can add more parts to it
//! // The entity is only considered newly created if no parts existed before
//! entities.add_part(entity_1,
//!                   Vector3 { x: 3,
//!                             y: 10,
//!                             z: -12 });
//!
//! // To add another entity you need another free slot
//! let entity_2 = entities.get_free_slot().unwrap();
//! entities.add_part(entity_2, Vector2 { x: 66, y: 6 });
//! entities.add_part(entity_2, Vector1 { x: 6 });
//!
//! // To get access to a part belonging to an entity you need
//! // first to get the partmap created for the part type
//! // This requires the part type signature
//! if entities.entity_contains::<Vector3>(entity_1) {
//!     // The return type is Result<Option<T>>
//!     let mut partmap = entities.get_pmap_mut::<Vector3>()
//!                               .expect("Mutable borrow failed")
//!                               .expect("No part found for entity");
//!     // You can then use the part by getting a reference
//!     let mut part: &Vector3 = partmap.get_part_mut(entity_1).unwrap();
//!     assert_eq!(part.z, -12);
//! }
//!
//! // 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));
//! }
//! assert_eq!(entities.entity_contains::<Vector1>(entity_1), false);
//!
//! // Make a system of some form that takes a `RefMut<PartMap>`
//! fn some_system(mut partmap: RefMut<PartMap>) {
//!     // You can then iterate over the parts directly
//!     for (k, v) in partmap.iter_mut() {
//!         let part = v.downcast_mut::<Vector1>().unwrap();
//!         part.x += 1;
//!         assert!(part.x > *k as i32);
//!     }
//! }
//! some_system(entities.get_pmap_mut::<Vector1>()
//!                     .expect("Mutable borrow failed")
//!                     .expect("No part found for entity"));
//!
//! // Or create a system that fetches the parts for only the entities
//! // you are interested in.
//! fn second_system(active: &[u32], mut v1_map: RefMut<PartMap>) {
//!     for id in active {
//!         if let Ok(part) = v1_map.get_part_mut::<Vector1>(*id) {
//!             part.x = 42;
//!         }
//!     }
//! }
//! second_system(&[0, 1, 2],
//!               entities.get_pmap_mut::<Vector1>()
//!                       .expect("Mutable borrow failed")
//!                       .expect("No part found for entity"));
//!
//! // Or a system handles the `Entities` container directly
//! fn other_system(active_ents: &[u32], entities: &mut Entities) {
//!     // You can mutably borrow multiple part types at once
//!     let mut v1_partmap = entities.get_pmap_mut::<Vector1>()
//!                                  .expect("Mutable borrow failed")
//!                                  .expect("No part found for entity");
//!     let mut v2_partmap = entities.get_pmap_mut::<Vector2>()
//!                                  .expect("Mutable borrow failed")
//!                                  .expect("No part found for entity");
//!     // But not have a mutable borrow and immutable borrow to the same
//!     // Fails at runtime!
//!     // let v2_partmap = entities.get_pmap_ref::<Vector2>().unwrap().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: &mut Vector1 = v1_partmap.get_part_mut(*id).unwrap();
//!             let v2_part = v2_partmap.get_part_mut::<Vector2>(*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::{BorrowError, BorrowMutError, Ref, RefCell, RefMut};
use std::collections::hash_map::{Iter, IterMut};
use std::collections::HashMap;

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

/// `PartMap` is a container type for the parts used by entities
pub struct PartMap {
    map: HashMap<u32, Box<Any>>,
}

impl PartMap {
    fn new(init_size: usize) -> PartMap {
        PartMap {
            map: HashMap::with_capacity(init_size),
        }
    }

    fn insert<T: 'static>(&mut self, id: u32, part: T) {
        self.map.insert(id, Box::new(part));
    }

    fn remove(&mut self, id: u32) {
        self.map.remove(&id);
    }

    pub fn get_part_ref<T: 'static>(&self, id: u32) -> Result<&T, &'static str> {
        if let Some(part) = self.map.get(&id) {
            let part = part.downcast_ref::<T>().ok_or("Downcast failed for type")?;
            return Ok(part);
        }
        Err("could find requested entity part")
    }

    /// Getting a reference to an entity part requires the entity ID and
    /// type signature. The type signature is required so that the internal
    /// downcast can be done for you.
    ///
    /// # Example
    ///
    /// ```
    /// # use tiny_ecs::Entities;
    /// #[derive(Debug, PartialEq)]
    /// struct Test1 {}
    ///
    /// # let mut entities = Entities::new(Some(3), Some(3));
    /// # let entity_1 = entities.get_free_slot().unwrap();
    /// # entities.add_part(entity_1, Test1 {});
    /// let partmap = entities.get_pmap_ref::<Test1>()
    ///                       .expect("Borrow failed")
    ///                       .expect("No part found for entity");
    /// let part = partmap.get_part_ref::<Test1>(entity_1).unwrap();
    /// assert_eq!(part, &Test1 {});
    /// // or
    /// let part: &Test1 = partmap.get_part_ref(entity_1).unwrap();
    /// assert_eq!(part, &Test1 {});
    /// ```
    pub fn get_part_mut<T: 'static>(&mut self, id: u32) -> Result<&mut T, &'static str> {
        if let Some(part) = self.map.get_mut(&id) {
            let part = part.downcast_mut::<T>().ok_or("Downcast failed for type")?;
            return Ok(part);
        }
        Err("could find requested entity part")
    }

    /// Returns an immutable iterator over the part map
    ///
    /// # Example
    ///
    /// ```
    /// # use tiny_ecs::Entities;
    /// struct Test1 {
    ///     x: u32,
    /// }
    /// let mut entities = Entities::new(Some(3), Some(3));
    ///
    /// let mut ids = Vec::new();
    /// let id = entities.get_free_slot().unwrap();
    /// entities.add_part(id, Test1 { x: id });
    /// ids.push(id);
    ///
    /// let partmap = entities.get_pmap_ref::<Test1>()
    ///                       .expect("Borrow failed")
    ///                       .expect("No part found for entity");
    /// for (k, v) in partmap.iter_ref() {
    ///     // You must downcast the `Any` type for it to be usable
    ///     let part = v.downcast_ref::<Test1>().unwrap();
    ///     assert!(part.x == *k);
    /// }
    /// ```
    pub fn iter_ref(&self) -> Iter<u32, Box<Any>> {
        return self.map.iter();
    }

    /// Returns a mutable iterator over the part map
    pub fn iter_mut(&mut self) -> IterMut<u32, Box<Any>> {
        return self.map.iter_mut();
    }
}

/// This is the root of the ECS implementation
pub struct Entities {
    entity_masks:     Vec<u32>,
    parts:            HashMap<u32, RefCell<PartMap>>,
    next_free_entity: u32,
    type_masks:       HashMap<TypeId, u32>,
    next_typemask:    u32,
}

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 part 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.
    /// - `part_count` is as above, for total part types/kinds.
    pub fn new(entity_count: Option<usize>, part_count: Option<usize>) -> Entities {
        Entities {
            entity_masks:     vec![EMPTY; entity_count.unwrap_or(0)],
            parts:            HashMap::with_capacity(part_count.unwrap_or(0)),
            next_free_entity: 0,
            type_masks:       HashMap::with_capacity(part_count.unwrap_or(0)),
            next_typemask:    1,
        }
    }

    /// Find the first `EMPTY` ID number to use
    ///
    /// As entities are only created by actually inserting new parts 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.
    pub fn get_free_slot(&mut self) -> Result<u32, &'static str> {
        if self.next_free_entity >= self.entity_masks.len() as u32 {
            self.entity_masks.push(EMPTY);
        }
        for index in 0..=self.next_free_entity {
            if self.entity_masks[index as usize] == EMPTY {
                if index >= self.next_free_entity {
                    self.next_free_entity += 1;
                }
                return Ok(index);
            }
        }
        Err("no free entity slots")
    }

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

    /// Returns the mask associated with the requested type.
    pub fn get_type_mask<T: 'static>(&self) -> Result<u32, &'static str> {
        if let Some(mask) = self.type_masks.get(&TypeId::of::<T>()) {
            return Ok(*mask);
        }
        Err("requested non-existant mask for type")
    }

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

    /// 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.get_free_slot().unwrap();
    /// entities.add_part(entity_1, Test1 {});
    /// ```
    pub fn add_part<T>(&mut self, id: u32, part: T)
    where
        T: Any, {
        let tid = TypeId::of::<T>();
        if !self.type_masks.contains_key(&tid) {
            self.type_masks.insert(tid, self.next_typemask);
            let mask = self.next_typemask << 1;
            self.next_typemask = mask;
        }
        let type_mask = self.type_masks[&tid];
        // add HashMap for these parts if not exist
        self.parts
            .entry(type_mask)
            .or_insert(RefCell::new(PartMap::new(self.entity_masks.len())));

        if let Some(col) = self.parts.get_mut(&type_mask) {
            col.borrow_mut().insert(id, part);
            let old = self.entity_masks[id as usize];
            self.entity_masks[id as usize] = old | type_mask;
        }
    }

    /// Remove an entities part. If no parts are left after part removal then
    /// the entity is considered deleted and an `EMPTY` mask is inserted in
    /// its place.
    ///
    /// Removal requires the ID of the entity and the parts 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.get_free_slot().unwrap();
    /// # entities.add_part(entity_1, Test1 {});
    /// assert!(entities.rm_part::<Test1>(entity_1));
    /// assert_eq!(entities.get_entity_mask(entity_1), EMPTY);
    /// ```
    pub fn rm_part<T: 'static>(&mut self, id: u32) -> bool {
        let type_mask = self.type_masks[&TypeId::of::<T>()];
        if let Some(map) = self.parts.get_mut(&type_mask) {
            map.borrow_mut().remove(id);
            self.entity_masks[id as usize] ^= type_mask;
            return true;
        }
        false
    }

    /// Will remove all parts associated with an entity ID and replace
    /// with an `EMPTY` mask.
    pub fn rm_entity(&mut self, id: u32) {
        for (_, part_map) in &mut self.parts {
            part_map.borrow_mut().remove(id);
        }
        self.entity_masks[id as usize] = EMPTY;
    }

    /// Get a plain reference to the selected entity part map
    ///
    /// You may have multiple immutable references to the requested `PartMap`
    /// **type** but no mutable references if the same **typed** `PartMap`
    /// is currently referenced.
    ///
    /// - `Option` is whether or not there is a part of `<T>` for that entity.
    /// - `Result` covers if the map was able to be borrowed or not.
    /// - Borrowing is checked at runtime.
    ///
    /// # Example
    /// ```
    /// # use tiny_ecs::Entities;
    /// # #[derive(Debug, PartialEq)]
    /// struct Test1 {
    ///     x: u32,
    /// }
    ///
    /// let mut entities = Entities::new(Some(3), Some(3));
    /// // entity_1 is functionally the entity ID
    /// let entity_1 = entities.get_free_slot().unwrap();
    /// # entities.add_part(entity_1, Test1 { x: 666 });
    /// let partmap = entities.get_pmap_ref::<Test1>()
    ///                       .expect("Borrow failed")
    ///                       .expect("No part found for entity");
    /// let part = partmap.get_part_ref::<Test1>(entity_1).unwrap();
    /// ```
    pub fn get_pmap_ref<T>(&self) -> Result<Option<Ref<PartMap>>, BorrowError>
    where
        T: 'static, {
        if let Some(type_mask) = self.type_masks.get(&TypeId::of::<T>()) {
            if let Some(partmap) = self.parts.get(&type_mask) {
                let partmap = partmap.try_borrow()?;
                return Ok(Some(partmap));
            }
        }
        Ok(None)
    }

    /// Get a mutable reference to the selected entity part map
    ///
    /// You may have only one mutable reference to the requested `PartMap`
    /// **type** and no immutable references. You can however, have multiple
    /// mutable references to different **types** of `PartMap`
    ///
    /// - `Option` is whether or not there is a part of `<T>` for that entity.
    /// - `Result` covers if the map was able to be borrowed mutably or not.
    /// - Borrowing is checked at runtime.
    ///
    /// # Example
    /// ```
    /// # use tiny_ecs::Entities;
    /// # #[derive(Debug, PartialEq)]
    /// struct Test1 {
    ///     x: u32,
    /// }
    ///
    /// let mut entities = Entities::new(Some(3), Some(3));
    /// // entity_1 is functionally the entity ID
    /// let entity_1 = entities.get_free_slot().unwrap();
    /// # entities.add_part(entity_1, Test1 { x: 0 });
    ///
    /// // 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 part_map = entities.get_pmap_mut::<Test1>()
    ///                                .expect("Mutable borrow failed")
    ///                                .expect("No part found for entity");
    ///     for id in 0..5 {
    ///         if let Ok(part) = part_map.get_part_mut::<Test1>(id) {
    ///             part.x = 42;
    ///         }
    ///     }
    /// }
    ///
    /// // Now get a ref to the modified part
    /// let partmap = entities.get_pmap_ref::<Test1>().unwrap().unwrap();
    /// let part = partmap.get_part_ref::<Test1>(entity_1).unwrap();
    /// assert_eq!(part.x, 42);
    /// ```
    pub fn get_pmap_mut<T>(&self) -> Result<Option<RefMut<PartMap>>, BorrowMutError>
    where
        T: 'static, {
        if let Some(type_mask) = self.type_masks.get(&TypeId::of::<T>()) {
            if let Some(partmap) = self.parts.get(&type_mask) {
                let partmap = partmap.try_borrow_mut()?;
                return Ok(Some(partmap));
            }
        }
        Ok(None)
    }
}

#[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.get_free_slot().unwrap();
        assert_eq!(entity_1, 0);

        entities.add_part(entity_1, Test1 {});

        let entity_1_mask = entities.get_entity_mask(entity_1);
        // 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.add_part(entity_1, Test3 {});
        assert!(entities.entity_contains::<Test3>(entity_1));

        // should increment entities.next_free_entity
        let e2 = entities.get_free_slot().unwrap();
        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.get_pmap_ref::<Test1>();
            assert_eq!(m.unwrap().is_none(), true);
        }

        let entity_1 = entities.get_free_slot().unwrap();
        entities.add_part(entity_1, Test1 {});
        // Should return the HashMap
        let map = entities.get_pmap_ref::<Test1>();
        assert_eq!(map.unwrap().is_some(), true);

        let map = entities.get_pmap_ref::<Test1>();
        let map = map.unwrap().unwrap();
        assert!(map.get_part_ref::<Test1>(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.get_pmap_mut::<Test1>();
            assert_eq!(m.unwrap().is_none(), true);
        }

        let entity_1 = entities.get_free_slot().unwrap();
        entities.add_part(entity_1, Test1 {});
        // Should return the HashMap
        let map = entities.get_pmap_mut::<Test1>();
        assert_eq!(map.unwrap().is_some(), true);

        let map = entities.get_pmap_mut::<Test1>();
        let mut map = map.unwrap().unwrap();
        assert!(map.get_part_mut::<Test1>(entity_1).is_ok());
    }

    #[test]
    fn partmap_ref_and_mut_diff_parts_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.get_free_slot().unwrap();
        entities.add_part(entity_1, Test1 { x: 66 });
        entities.add_part(entity_1, Test2 { x: 42 });

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

        let mut partmap = entities.get_pmap_mut::<Test2>().unwrap().unwrap();
        let part = partmap.get_part_mut::<Test2>(entity_1).unwrap();
        assert_eq!(part.x, 42);
        part.x = 666;
        assert_ne!(part.x, 42);
    }

    #[test]
    fn partmap_iter_ref() {
        struct Test1 {
            x: u32,
        }

        let mut entities = Entities::new(Some(3), Some(3));
        let mut ids = Vec::new();
        // 1
        let id = entities.get_free_slot().unwrap();
        entities.add_part(id, Test1 { x: id });
        ids.push(id);
        // 2
        let id = entities.get_free_slot().unwrap();
        entities.add_part(id, Test1 { x: id });
        ids.push(id);
        // 3
        let id = entities.get_free_slot().unwrap();
        entities.add_part(id, Test1 { x: id });
        ids.push(id);

        let partmap = entities.get_pmap_ref::<Test1>().unwrap().unwrap();
        for (k, v) in partmap.iter_ref() {
            let part = v.downcast_ref::<Test1>().unwrap();
            assert!(part.x == *k);
        }
    }

    #[test]
    fn partmap_iter_mut() {
        struct Test1 {
            x: u32,
        }

        let mut entities = Entities::new(Some(3), Some(3));
        let mut ids = Vec::new();
        // 1
        let id = entities.get_free_slot().unwrap();
        entities.add_part(id, Test1 { x: id });
        ids.push(id);
        // 2
        let id = entities.get_free_slot().unwrap();
        entities.add_part(id, Test1 { x: id });
        ids.push(id);
        // 3
        let id = entities.get_free_slot().unwrap();
        entities.add_part(id, Test1 { x: id });
        ids.push(id);

        let mut partmap = entities.get_pmap_mut::<Test1>().unwrap().unwrap();
        for (k, v) in partmap.iter_mut() {
            let part = v.downcast_mut::<Test1>().unwrap();
            part.x += 1;
            assert!(part.x > *k);
        }
    }

    #[test]
    fn remove_parts_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.get_free_slot().unwrap();
        entities.add_part(entity_1, Test1 {});
        entities.add_part(entity_1, Test2 { x: 42 });

        // rm and check entity components
        assert!(entities.entity_contains::<Test1>(entity_1));
        assert!(entities.rm_part::<Test1>(entity_1));
        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), type_mask_2);

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

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

        let mut entities = Entities::new(Some(3), Some(3));
        let entity_1 = entities.get_free_slot().unwrap();
        entities.add_part(entity_1, Test1 {});

        entities.rm_entity(entity_1);

        let partmap = entities.get_pmap_ref::<Test1>().unwrap().unwrap();
        assert_eq!(partmap.get_part_ref::<Test1>(entity_1).is_err(), true);
    }
}