prime_forge/
lost_realm.rs

1use std::{cell::RefCell, rc::Rc, time::Duration};
2
3use crate::{arcane_weft::ArcaneWeft, forged_object::TraitBundle, forged_trait::ForgedTrait};
4
5use super::{
6    destiny_rift::{DestinyRift, DestinyRiftManager},
7    eonforge::EonForge,
8    forged_object::ForgedObject,
9    soul_thread::{SoulThread, SoulThreadManager},
10};
11
12pub struct LostRealm {
13    forged_objects: Rc<RefCell<Vec<ForgedObject>>>,
14    pub eonforge: Rc<RefCell<EonForge>>,
15    destiny_rift_manager: Rc<RefCell<DestinyRiftManager>>,
16    soul_threads_manager: Rc<RefCell<SoulThreadManager>>,
17}
18
19impl LostRealm {
20    pub fn new() -> LostRealm {
21        LostRealm {
22            forged_objects: Rc::new(RefCell::new(Vec::new())),
23            eonforge: Rc::new(RefCell::new(EonForge::new())),
24            destiny_rift_manager: Rc::new(RefCell::new(DestinyRiftManager::new())),
25            soul_threads_manager: Rc::new(RefCell::new(SoulThreadManager::new())),
26        }
27    }
28
29    fn add_object(&self, object: ForgedObject) {
30        unsafe {
31            let ptr = self.forged_objects.as_ptr();
32            let mut_ref = &mut *ptr;
33            mut_ref.push(object);
34        }
35    }
36
37    pub fn start(&self) {
38        self.eonforge.borrow_mut().start();
39        for object in self.forged_objects.borrow_mut().iter() {
40            let mut_ptr = unsafe {
41                let ptr = self as *const LostRealm;
42                std::mem::transmute::<*const LostRealm, &mut LostRealm>(ptr)
43            };
44            object.start(mut_ptr);
45        }
46    }
47
48    pub fn update(&self) {
49        for object in self.forged_objects.borrow_mut().iter() {
50            let mut_ptr = unsafe {
51                let ptr = self as *const LostRealm;
52                std::mem::transmute::<*const LostRealm, &mut LostRealm>(ptr)
53            };
54            object.update(mut_ptr, self.eonforge.borrow().get_delta_time());
55        }
56        self.destiny_rift_manager.borrow_mut().remove_event();
57        self.soul_threads_manager
58            .borrow_mut()
59            .update(self.eonforge.borrow().get_delta_time());
60    }
61
62    pub fn debug_update(&self) {
63        loop {
64            let dt = std::time::Duration::from_millis(1000 / 60);
65
66            self.eonforge.borrow_mut().update(dt.as_secs_f32());
67            self.update();
68
69            std::thread::sleep(dt);
70        }
71    }
72
73    //// Soul thread functions
74    /// alias for adding a coroutine
75    pub fn add_soul_thread(&self, thread: SoulThread) {
76        self.soul_threads_manager.borrow_mut().add_thread(thread);
77    }
78
79    pub fn stop_all_soul_threads(&self) {
80        self.soul_threads_manager.borrow_mut().stop_all();
81    }
82
83    pub fn stop_soul_thread_by_name(&self, name: &str) {
84        self.soul_threads_manager.borrow_mut().stop_by_name(name);
85    }
86
87    //// Destiny rift functions
88    /// alias for adding event
89    pub fn add_destiny_rift_event(&self, event: impl DestinyRift + 'static) {
90        self.destiny_rift_manager
91            .borrow_mut()
92            .add_event(Box::new(event));
93    }
94
95    pub fn consume_destiny_rift_event<T: 'static + DestinyRift>(&self) -> Option<&T> {
96        let mut borrow_mut = self.destiny_rift_manager.borrow_mut();
97        let rc = borrow_mut.consume_event();
98        if let Some(rc) = rc {
99            let rc = unsafe {
100                let ptr = rc as *const T;
101                &*ptr
102            };
103            Some(rc)
104        } else {
105            None
106        }
107    }
108
109    /// Arcane Weft functions
110    /// alias for plugging
111    pub fn arcane_weft_craft(&self, arcane_weft: impl ArcaneWeft) {
112        let mut_self = unsafe {
113            let ptr = self as *const LostRealm;
114            std::mem::transmute::<*const LostRealm, &mut LostRealm>(ptr)
115        };
116        arcane_weft.craft(mut_self);
117    }
118
119    /// Forged Object functions
120    /// alias for adding object
121    pub fn forge_new_object_mut(
122        &self,
123        name: &str,
124        traits: impl TraitBundle,
125    ) -> Option<&mut ForgedObject> {
126        let mut forged_object = ForgedObject::new(name.to_string());
127        traits.craft_trait_bundle(&mut forged_object);
128        self.add_object(forged_object);
129        self.get_mut_forged_object(name)
130    }
131
132    pub fn forge_new_object(&self, name: &str, traits: impl TraitBundle) -> Option<&ForgedObject> {
133        let mut forged_object = ForgedObject::new(name.to_string());
134        traits.craft_trait_bundle(&mut forged_object);
135        self.add_object(forged_object);
136        self.get_forged_object(name)
137    }
138
139    pub fn get_forged_object(&self, name: &str) -> Option<&ForgedObject> {
140        let borrow = unsafe {
141            let ptr = self.forged_objects.as_ptr();
142            &*ptr
143        };
144        let rc = borrow.iter().find(|object| object.name == name);
145        if let Some(rc) = rc {
146            let rc = unsafe {
147                let ptr = rc as *const ForgedObject;
148                &*ptr
149            };
150            Some(rc)
151        } else {
152            None
153        }
154    }
155
156    pub fn get_mut_forged_object(&self, name: &str) -> Option<&mut ForgedObject> {
157        let mut borrow_mut = self.forged_objects.borrow_mut();
158        let rc = borrow_mut.iter_mut().find(|object| object.name == name);
159        if let Some(rc) = rc {
160            let rc = unsafe {
161                let ptr = rc as *const ForgedObject;
162                &mut *(ptr as *mut ForgedObject)
163            };
164            Some(rc)
165        } else {
166            None
167        }
168    }
169
170    pub fn get_forged_object_by_trait<T: 'static + ForgedTrait>(&self) -> Option<&ForgedObject> {
171        let borrow = self.forged_objects.borrow();
172        let rc = borrow.iter().find(|object| object.get_trait::<T>().is_ok());
173        if let Some(rc) = rc {
174            let rc = unsafe {
175                let ptr = rc as *const ForgedObject;
176                &*ptr
177            };
178            Some(rc)
179        } else {
180            None
181        }
182    }
183
184    pub fn get_trait_by_type<T: 'static + ForgedTrait>(&self) -> Option<&T> {
185        let borrow = self.forged_objects.borrow();
186        let rc = borrow
187            .iter()
188            .find(|object| object.get_trait::<T>().is_ok())
189            .and_then(|object| object.get_trait::<T>().ok());
190        if let Some(rc) = rc {
191            let rc = unsafe {
192                let ptr = rc as *const T;
193                &*ptr
194            };
195            Some(rc)
196        } else {
197            None
198        }
199    }
200    pub fn get_mut_trait_by_type<T: 'static + ForgedTrait>(&self) -> Option<&mut T> {
201        let mut borrow_mut = self.forged_objects.borrow_mut();
202        let rc = borrow_mut
203            .iter_mut()
204            .find(|object| object.get_trait::<T>().is_ok())
205            .and_then(|object| object.get_trait_mut::<T>().ok());
206        if let Some(rc) = rc {
207            let rc = unsafe {
208                let ptr = rc as *const T;
209                &mut *(ptr as *mut T)
210            };
211            Some(rc)
212        } else {
213            None
214        }
215    }
216
217    pub fn destroy_forged_object(&self, name: &str) -> Option<ForgedObject> {
218        let index = self
219            .forged_objects
220            .borrow()
221            .iter()
222            .position(|object| object.name == name);
223        if let Some(index) = index {
224            Some(self.forged_objects.borrow_mut().remove(index))
225        } else {
226            None
227        }
228    }
229
230    pub fn destroy_forged_object_by_ref(
231        &self,
232        forged_object: &ForgedObject,
233    ) -> Option<ForgedObject> {
234        let index = self
235            .forged_objects
236            .borrow()
237            .iter()
238            .position(|object| object.id == forged_object.id);
239        if let Some(index) = index {
240            Some(self.forged_objects.borrow_mut().remove(index))
241        } else {
242            None
243        }
244    }
245
246    pub fn get_parent_forged_object(&self, trait_: &impl ForgedTrait) -> Option<&ForgedObject> {
247        let father_id = trait_.get_father();
248        if let Some(id) = father_id {
249            let borrow = self.forged_objects.borrow();
250            let rc = borrow
251                .iter()
252                .find(|object| object.id == uuid::Uuid::parse_str(id.as_str()).unwrap());
253            if let Some(rc) = rc {
254                let rc = unsafe {
255                    let ptr = rc as *const ForgedObject;
256                    &*ptr
257                };
258                Some(rc)
259            } else {
260                None
261            }
262        } else {
263            None
264        }
265    }
266
267    pub fn get_mut_parent_forged_object(
268        &self,
269        trait_: &impl ForgedTrait,
270    ) -> Option<&mut ForgedObject> {
271        let father_id = trait_.get_father();
272        if let Some(id) = father_id {
273            let mut borrow_mut = self.forged_objects.borrow_mut();
274            let rc = borrow_mut
275                .iter_mut()
276                .find(|object| object.id == uuid::Uuid::parse_str(id.as_str()).unwrap());
277            if let Some(rc) = rc {
278                let rc = unsafe {
279                    let ptr = rc as *const ForgedObject;
280                    &mut *(ptr as *mut ForgedObject)
281                };
282                Some(rc)
283            } else {
284                None
285            }
286        } else {
287            None
288        }
289    }
290
291    pub fn get_all_forged_objects_by_trait<T: 'static + ForgedTrait>(&self) -> Vec<&ForgedObject> {
292        let borrow = self.forged_objects.borrow();
293        let rc = borrow
294            .iter()
295            .filter(|object| object.get_trait::<T>().is_ok())
296            .map(|object| unsafe {
297                let ptr = object as *const ForgedObject;
298                &*ptr
299            })
300            .collect();
301        rc
302    }
303
304    pub fn get_all_trait_by_type<T: 'static + ForgedTrait>(&self) -> Vec<&T> {
305        let borrow = self.forged_objects.borrow();
306        let rc = borrow
307            .iter()
308            .filter(|object| object.get_trait::<T>().is_ok())
309            .map(|object| object.get_trait::<T>().unwrap())
310            .map(|trait_| unsafe {
311                let ptr = trait_ as *const T;
312                &*ptr
313            })
314            .collect();
315        rc
316    }
317
318    pub fn get_mut_all_forged_objects_by_trait<T: 'static + ForgedTrait>(
319        &self,
320    ) -> Vec<&mut ForgedObject> {
321        let mut borrow_mut = self.forged_objects.borrow_mut();
322        let rc = borrow_mut
323            .iter_mut()
324            .filter(|object| object.get_trait::<T>().is_ok())
325            .map(|object| unsafe {
326                let ptr = object as *const ForgedObject;
327                &mut *(ptr as *mut ForgedObject)
328            })
329            .collect();
330        rc
331    }
332
333    pub fn get_mut_all_trait_by_type<T: 'static + ForgedTrait>(&self) -> Vec<&mut T> {
334        let mut borrow_mut = self.forged_objects.borrow_mut();
335        let rc = borrow_mut
336            .iter_mut()
337            .filter(|object| object.get_trait::<T>().is_ok())
338            .map(|object| object.get_trait_mut::<T>().unwrap())
339            .map(|trait_| unsafe {
340                let ptr = trait_ as *const T;
341                &mut *(ptr as *mut T)
342            })
343            .collect();
344        rc
345    }
346
347    // EonForge
348    pub fn get_delta_time(&self) -> f32 {
349        self.eonforge.borrow().get_delta_time()
350    }
351
352    pub fn get_time_elapsed(&self) -> Duration {
353        self.eonforge.borrow().get_time_elapsed_since_start()
354    }
355}
prime_forge/lost_realm.rs

prime_forge/
lost_realm.rs
