diff --git a/core/src/utils/typemap.rs b/core/src/utils/typemap.rs
index bd28a66..c04c2c9 100644
--- a/core/src/utils/typemap.rs
+++ b/core/src/utils/typemap.rs
@@ -101,7 +101,7 @@ macro_rules! define_typemap {
             {
                 type Output<'a> = (&'a mut A,);
                 fn get_from_mut<'a>(map: &'a mut HashMap<TypeId, Box<dyn Any>>) -> Option<Self::Output<'a>> {
-                    let ptr_a = { map.get_mut(&TypeId::of::<A>()).map(|v| v as *mut dyn Any) }?;
+                    let ptr_a = { map.get_mut(&TypeId::of::<A>()).map(|v| v.as_mut() as *mut dyn Any) }?;
                     unsafe {
                         let a = (&mut *ptr_a).downcast_mut::<A>()?;
                         Some((a,))
@@ -133,8 +133,8 @@ macro_rules! define_typemap {
                 fn get_from_mut<'a>(map: &'a mut HashMap<TypeId, Box<dyn Any>>) -> Option<Self::Output<'a>> {
                     let ids = [TypeId::of::<A>(), TypeId::of::<B>()];
                     if ids[0] == ids[1] { return None; }
-                    let ptr_a = { map.get_mut(&TypeId::of::<A>()).map(|v| v as *mut dyn Any) }?;
-                    let ptr_b = { map.get_mut(&TypeId::of::<B>()).map(|v| v as *mut dyn Any) }?;
+                    let ptr_a = { map.get_mut(&TypeId::of::<A>()).map(|v| v.as_mut() as *mut dyn Any) }?;
+                    let ptr_b = { map.get_mut(&TypeId::of::<B>()).map(|v| v.as_mut() as *mut dyn Any) }?;
                     unsafe {
                         let a = (&mut *ptr_a).downcast_mut::<A>()?;
                         let b = (&mut *ptr_b).downcast_mut::<B>()?;
@@ -170,9 +170,9 @@ macro_rules! define_typemap {
                 fn get_from_mut<'a>(map: &'a mut HashMap<TypeId, Box<dyn Any>>) -> Option<Self::Output<'a>> {
                     let ids = [TypeId::of::<A>(), TypeId::of::<B>(), TypeId::of::<C>()];
                     if ids[0] == ids[1] || ids[0] == ids[2] || ids[1] == ids[2] { return None; }
-                    let ptr_a = { map.get_mut(&TypeId::of::<A>()).map(|v| v as *mut dyn Any) }?;
-                    let ptr_b = { map.get_mut(&TypeId::of::<B>()).map(|v| v as *mut dyn Any) }?;
-                    let ptr_c = { map.get_mut(&TypeId::of::<C>()).map(|v| v as *mut dyn Any) }?;
+                    let ptr_a = { map.get_mut(&TypeId::of::<A>()).map(|v| v.as_mut() as *mut dyn Any) }?;
+                    let ptr_b = { map.get_mut(&TypeId::of::<B>()).map(|v| v.as_mut() as *mut dyn Any) }?;
+                    let ptr_c = { map.get_mut(&TypeId::of::<C>()).map(|v| v.as_mut() as *mut dyn Any) }?;
                     unsafe {
                         let a = (&mut *ptr_a).downcast_mut::<A>()?;
                         let b = (&mut *ptr_b).downcast_mut::<B>()?;
@@ -212,10 +212,10 @@ macro_rules! define_typemap {
                 fn get_from_mut<'a>(map: &'a mut HashMap<TypeId, Box<dyn Any>>) -> Option<Self::Output<'a>> {
                     let ids = [TypeId::of::<A>(), TypeId::of::<B>(), TypeId::of::<C>(), TypeId::of::<D>()];
                     for i in 0..ids.len() { for j in (i+1)..ids.len() { if ids[i] == ids[j] { return None; } } }
-                    let ptr_a = { map.get_mut(&TypeId::of::<A>()).map(|v| v as *mut dyn Any) }?;
-                    let ptr_b = { map.get_mut(&TypeId::of::<B>()).map(|v| v as *mut dyn Any) }?;
-                    let ptr_c = { map.get_mut(&TypeId::of::<C>()).map(|v| v as *mut dyn Any) }?;
-                    let ptr_d = { map.get_mut(&TypeId::of::<D>()).map(|v| v as *mut dyn Any) }?;
+                    let ptr_a = { map.get_mut(&TypeId::of::<A>()).map(|v| v.as_mut() as *mut dyn Any) }?;
+                    let ptr_b = { map.get_mut(&TypeId::of::<B>()).map(|v| v.as_mut() as *mut dyn Any) }?;
+                    let ptr_c = { map.get_mut(&TypeId::of::<C>()).map(|v| v.as_mut() as *mut dyn Any) }?;
+                    let ptr_d = { map.get_mut(&TypeId::of::<D>()).map(|v| v.as_mut() as *mut dyn Any) }?;
                     unsafe {
                         let a = (&mut *ptr_a).downcast_mut::<A>()?;
                         let b = (&mut *ptr_b).downcast_mut::<B>()?;
@@ -259,11 +259,11 @@ macro_rules! define_typemap {
                 fn get_from_mut<'a>(map: &'a mut HashMap<TypeId, Box<dyn Any>>) -> Option<Self::Output<'a>> {
                     let ids = [TypeId::of::<A>(), TypeId::of::<B>(), TypeId::of::<C>(), TypeId::of::<D>(), TypeId::of::<E>()];
                     for i in 0..ids.len() { for j in (i+1)..ids.len() { if ids[i] == ids[j] { return None; } } }
-                    let ptr_a = { map.get_mut(&TypeId::of::<A>()).map(|v| v as *mut dyn Any) }?;
-                    let ptr_b = { map.get_mut(&TypeId::of::<B>()).map(|v| v as *mut dyn Any) }?;
-                    let ptr_c = { map.get_mut(&TypeId::of::<C>()).map(|v| v as *mut dyn Any) }?;
-                    let ptr_d = { map.get_mut(&TypeId::of::<D>()).map(|v| v as *mut dyn Any) }?;
-                    let ptr_e = { map.get_mut(&TypeId::of::<E>()).map(|v| v as *mut dyn Any) }?;
+                    let ptr_a = { map.get_mut(&TypeId::of::<A>()).map(|v| v.as_mut() as *mut dyn Any) }?;
+                    let ptr_b = { map.get_mut(&TypeId::of::<B>()).map(|v| v.as_mut() as *mut dyn Any) }?;
+                    let ptr_c = { map.get_mut(&TypeId::of::<C>()).map(|v| v.as_mut() as *mut dyn Any) }?;
+                    let ptr_d = { map.get_mut(&TypeId::of::<D>()).map(|v| v.as_mut() as *mut dyn Any) }?;
+                    let ptr_e = { map.get_mut(&TypeId::of::<E>()).map(|v| v.as_mut() as *mut dyn Any) }?;
                     unsafe {
                         let a = (&mut *ptr_a).downcast_mut::<A>()?;
                         let b = (&mut *ptr_b).downcast_mut::<B>()?;
@@ -311,12 +311,12 @@ macro_rules! define_typemap {
                 fn get_from_mut<'a>(map: &'a mut HashMap<TypeId, Box<dyn Any>>) -> Option<Self::Output<'a>> {
                     let ids = [TypeId::of::<A>(), TypeId::of::<B>(), TypeId::of::<C>(), TypeId::of::<D>(), TypeId::of::<E>(), TypeId::of::<F>()];
                     for i in 0..ids.len() { for j in (i+1)..ids.len() { if ids[i] == ids[j] { return None; } } }
-                    let ptr_a = { map.get_mut(&TypeId::of::<A>()).map(|v| v as *mut dyn Any) }?;
-                    let ptr_b = { map.get_mut(&TypeId::of::<B>()).map(|v| v as *mut dyn Any) }?;
-                    let ptr_c = { map.get_mut(&TypeId::of::<C>()).map(|v| v as *mut dyn Any) }?;
-                    let ptr_d = { map.get_mut(&TypeId::of::<D>()).map(|v| v as *mut dyn Any) }?;
-                    let ptr_e = { map.get_mut(&TypeId::of::<E>()).map(|v| v as *mut dyn Any) }?;
-                    let ptr_f = { map.get_mut(&TypeId::of::<F>()).map(|v| v as *mut dyn Any) }?;
+                    let ptr_a = { map.get_mut(&TypeId::of::<A>()).map(|v| v.as_mut() as *mut dyn Any) }?;
+                    let ptr_b = { map.get_mut(&TypeId::of::<B>()).map(|v| v.as_mut() as *mut dyn Any) }?;
+                    let ptr_c = { map.get_mut(&TypeId::of::<C>()).map(|v| v.as_mut() as *mut dyn Any) }?;
+                    let ptr_d = { map.get_mut(&TypeId::of::<D>()).map(|v| v.as_mut() as *mut dyn Any) }?;
+                    let ptr_e = { map.get_mut(&TypeId::of::<E>()).map(|v| v.as_mut() as *mut dyn Any) }?;
+                    let ptr_f = { map.get_mut(&TypeId::of::<F>()).map(|v| v.as_mut() as *mut dyn Any) }?;
                     unsafe {
                         let a = (&mut *ptr_a).downcast_mut::<A>()?;
                         let b = (&mut *ptr_b).downcast_mut::<B>()?;
@@ -368,13 +368,13 @@ macro_rules! define_typemap {
                 fn get_from_mut<'a>(map: &'a mut HashMap<TypeId, Box<dyn Any>>) -> Option<Self::Output<'a>> {
                     let ids = [TypeId::of::<A>(), TypeId::of::<B>(), TypeId::of::<C>(), TypeId::of::<D>(), TypeId::of::<E>(), TypeId::of::<F>(), TypeId::of::<G>()];
                     for i in 0..ids.len() { for j in (i+1)..ids.len() { if ids[i] == ids[j] { return None; } } }
-                    let ptr_a = { map.get_mut(&TypeId::of::<A>()).map(|v| v as *mut dyn Any) }?;
-                    let ptr_b = { map.get_mut(&TypeId::of::<B>()).map(|v| v as *mut dyn Any) }?;
-                    let ptr_c = { map.get_mut(&TypeId::of::<C>()).map(|v| v as *mut dyn Any) }?;
-                    let ptr_d = { map.get_mut(&TypeId::of::<D>()).map(|v| v as *mut dyn Any) }?;
-                    let ptr_e = { map.get_mut(&TypeId::of::<E>()).map(|v| v as *mut dyn Any) }?;
-                    let ptr_f = { map.get_mut(&TypeId::of::<F>()).map(|v| v as *mut dyn Any) }?;
-                    let ptr_g = { map.get_mut(&TypeId::of::<G>()).map(|v| v as *mut dyn Any) }?;
+                    let ptr_a = { map.get_mut(&TypeId::of::<A>()).map(|v| v.as_mut() as *mut dyn Any) }?;
+                    let ptr_b = { map.get_mut(&TypeId::of::<B>()).map(|v| v.as_mut() as *mut dyn Any) }?;
+                    let ptr_c = { map.get_mut(&TypeId::of::<C>()).map(|v| v.as_mut() as *mut dyn Any) }?;
+                    let ptr_d = { map.get_mut(&TypeId::of::<D>()).map(|v| v.as_mut() as *mut dyn Any) }?;
+                    let ptr_e = { map.get_mut(&TypeId::of::<E>()).map(|v| v.as_mut() as *mut dyn Any) }?;
+                    let ptr_f = { map.get_mut(&TypeId::of::<F>()).map(|v| v.as_mut() as *mut dyn Any) }?;
+                    let ptr_g = { map.get_mut(&TypeId::of::<G>()).map(|v| v.as_mut() as *mut dyn Any) }?;
                     unsafe {
                         let a = (&mut *ptr_a).downcast_mut::<A>()?;
                         let b = (&mut *ptr_b).downcast_mut::<B>()?;
@@ -430,14 +430,14 @@ macro_rules! define_typemap {
                 fn get_from_mut<'a>(map: &'a mut HashMap<TypeId, Box<dyn Any>>) -> Option<Self::Output<'a>> {
                     let ids = [TypeId::of::<A>(), TypeId::of::<B>(), TypeId::of::<C>(), TypeId::of::<D>(), TypeId::of::<E>(), TypeId::of::<F>(), TypeId::of::<G>(), TypeId::of::<H>()];
                     for i in 0..ids.len() { for j in (i+1)..ids.len() { if ids[i] == ids[j] { return None; } } }
-                    let ptr_a = { map.get_mut(&TypeId::of::<A>()).map(|v| v as *mut dyn Any) }?;
-                    let ptr_b = { map.get_mut(&TypeId::of::<B>()).map(|v| v as *mut dyn Any) }?;
-                    let ptr_c = { map.get_mut(&TypeId::of::<C>()).map(|v| v as *mut dyn Any) }?;
-                    let ptr_d = { map.get_mut(&TypeId::of::<D>()).map(|v| v as *mut dyn Any) }?;
-                    let ptr_e = { map.get_mut(&TypeId::of::<E>()).map(|v| v as *mut dyn Any) }?;
-                    let ptr_f = { map.get_mut(&TypeId::of::<F>()).map(|v| v as *mut dyn Any) }?;
-                    let ptr_g = { map.get_mut(&TypeId::of::<G>()).map(|v| v as *mut dyn Any) }?;
-                    let ptr_h = { map.get_mut(&TypeId::of::<H>()).map(|v| v as *mut dyn Any) }?;
+                    let ptr_a = { map.get_mut(&TypeId::of::<A>()).map(|v| v.as_mut() as *mut dyn Any) }?;
+                    let ptr_b = { map.get_mut(&TypeId::of::<B>()).map(|v| v.as_mut() as *mut dyn Any) }?;
+                    let ptr_c = { map.get_mut(&TypeId::of::<C>()).map(|v| v.as_mut() as *mut dyn Any) }?;
+                    let ptr_d = { map.get_mut(&TypeId::of::<D>()).map(|v| v.as_mut() as *mut dyn Any) }?;
+                    let ptr_e = { map.get_mut(&TypeId::of::<E>()).map(|v| v.as_mut() as *mut dyn Any) }?;
+                    let ptr_f = { map.get_mut(&TypeId::of::<F>()).map(|v| v.as_mut() as *mut dyn Any) }?;
+                    let ptr_g = { map.get_mut(&TypeId::of::<G>()).map(|v| v.as_mut() as *mut dyn Any) }?;
+                    let ptr_h = { map.get_mut(&TypeId::of::<H>()).map(|v| v.as_mut() as *mut dyn Any) }?;
                     unsafe {
                         let a = (&mut *ptr_a).downcast_mut::<A>()?;
                         let b = (&mut *ptr_b).downcast_mut::<B>()?;
@@ -498,3 +498,47 @@ macro_rules! define_typemap {
 //         Self::new()
 //     }
 // }
+
+#[cfg(test)]
+mod tests {
+    use crate::define_typemap;
+
+    define_typemap!(TestMap,);
+
+    #[test]
+    fn get_test() {
+        let mut tm = TestMap::new();
+        tm.insert::<u32>(42);
+        let v = tm.get::<u32>().expect("value should be present");
+        assert_eq!(*v, 42);
+    }
+
+    #[test]
+    fn get_many_test() {
+        let mut tm = TestMap::new();
+        tm.insert::<u32>(1);
+        tm.insert::<i32>(-2);
+        tm.insert::<f32>(3.5);
+
+        let (a, b, c) = tm
+            .get_many::<(u32, i32, f32)>()
+            .expect("all values should be present");
+        assert_eq!((*a, *b, *c), (1, -2, 3.5));
+    }
+
+    #[test]
+    fn get_many_mut_test() {
+        let mut tm = TestMap::new();
+
+        tm.insert::<i32>(-2);
+        tm.insert::<u32>(1);
+        tm.insert::<f32>(3.5);
+
+        let (a, b, c) = tm
+            .get_many_mut::<(i32, u32, f32)>()
+            .expect("all values should be present");
+        *a = 4;
+        *b = 5;
+        *c = 6.5;
+    }
+}