lotus_engine 0.2.3

Lotus is a game engine with the main focus of being easy-to-use and straight forward on developing 2D games.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107

use std::{any::{Any, TypeId}, collections::HashSet, ops::{Deref, DerefMut}};
use atomic_refcell::{AtomicRef, AtomicRefCell, AtomicRefMut};
use uuid::Uuid;

/// The Component trait to annotate which structs are.
pub trait Component: Any + Send + Sync {
   fn as_any(&self) -> &dyn Any;

   fn as_any_mut(&mut self) -> &mut dyn Any;
}

/// Struct to represent the actual borrowing state of the entities components.
pub struct ComponentBorrowState {
   pub immutable_borrows: HashSet<(TypeId, Uuid)>,
   pub mutable_borrows: HashSet<(TypeId, Uuid)>
}

impl ComponentBorrowState {
   pub fn new() -> Self {
      return Self {
         immutable_borrows: HashSet::new(),
         mutable_borrows: HashSet::new()
      };
   }

   pub fn try_borrow_immutable(&mut self, type_id: TypeId, entity_id: Uuid) -> bool {
      let key: (TypeId, Uuid) = (type_id, entity_id);
      
      if self.mutable_borrows.contains(&key) {
         return false;
      } else {
         self.immutable_borrows.insert(key);
         return true;
      }
   }

   pub fn try_borrow_mutable(&mut self, type_id: TypeId, entity_id: Uuid) -> bool {
      let key: (TypeId, Uuid) = (type_id, entity_id);

      if self.immutable_borrows.contains(&key) || self.mutable_borrows.contains(&key) {
         return false;
      } else {
         self.mutable_borrows.insert(key);
         return true;
      }
   }

   pub fn release_immutable(&mut self, type_id: TypeId, entity_id: Uuid) {
      self.immutable_borrows.remove(&(type_id, entity_id));
   }

   pub fn release_mutable(&mut self, type_id: TypeId, entity_id: Uuid) {
      self.mutable_borrows.remove(&(type_id, entity_id));
   }
}

/// Struct to represent the immutable reference of a component.
pub struct ComponentRef<'a, T: Component + 'static> {
   pub(crate) inner: AtomicRef<'a, Box<dyn Component>>,
   pub(crate) type_id: TypeId,
   pub entity_id: Uuid,
   pub(crate) component_borrow_state: &'a AtomicRefCell<ComponentBorrowState>,
   pub(crate) phantom_data: std::marker::PhantomData<T>
}

impl<'a, T: Component + 'static> Deref for ComponentRef<'a, T> {
   type Target = T;

   fn deref(&self) -> &T {
      return self.inner.as_any().downcast_ref::<T>().unwrap();
   }
}

impl<'a, T: Component + 'static> Drop for ComponentRef<'a, T> {
   fn drop(&mut self) {
      self.component_borrow_state.borrow_mut().release_immutable(self.type_id, self.entity_id);
   }
}

/// Struct to represent a mutable reference of a component.
pub struct ComponentRefMut<'a, T: Component + 'static> {
   pub(crate) inner: AtomicRefMut<'a, Box<dyn Component>>,
   pub(crate) type_id: TypeId,
   pub entity_id: Uuid,
   pub(crate) component_borrow_state: &'a AtomicRefCell<ComponentBorrowState>,
   pub(crate) phantom_data: std::marker::PhantomData<T>
}

impl<'a, T: Component + 'static> Deref for ComponentRefMut<'a, T> {
   type Target = T;

   fn deref(&self) -> &T {
      return self.inner.as_any().downcast_ref::<T>().unwrap();
   }
}

impl<'a, T: Component + 'static> DerefMut for ComponentRefMut<'a, T> {
   fn deref_mut(&mut self) -> &mut T {
      return self.inner.as_any_mut().downcast_mut::<T>().unwrap();
   }
}

impl<'a, T: Component + 'static> Drop for ComponentRefMut<'a, T> {
   fn drop(&mut self) {
      self.component_borrow_state.borrow_mut().release_mutable(self.type_id, self.entity_id);
   }
}