Stowage/noita_entangled_worlds
2
0
Fork 0
mirror of https://github.com/IntQuant/noita_entangled_worlds.git synced 2025-10-19 07:03:16 +00:00
Code Issues Projects Releases Packages Wiki Activity

rename component manager to component buffer as thats what noiter calls it

Browse source
This commit is contained in:
bgkillas 2025-07-24 00:10:23 -04:00
parent 80d15432d9
commit 9d822debff
2 changed files with 22 additions and 22 deletions
Download patch file Download diff file Expand all files Collapse all files

18
noita_api/src/noita/types/component.rs
View file

@ -28,34 +28,34 @@ pub struct ComponentManagerVTable {
#[derive(Debug)] #[derive(Debug)]
pub struct ComponentTypeManager { pub struct ComponentTypeManager {
pub next_id: usize, pub next_id: usize,
pub component_manager_indices: StdMap<StdString, usize>, pub component_buffer_indices: StdMap<StdString, usize>,
} }
impl ComponentTypeManager { impl ComponentTypeManager {
pub fn get<C: Component>(&self, entity_manager: &EntityManager) -> &ComponentManager { pub fn get<C: Component>(&self, entity_manager: &EntityManager) -> &ComponentBuffer {
let index = self let index = self
.component_manager_indices .component_buffer_indices
.get(C::STD_NAME) .get(C::STD_NAME)
.copied() .copied()
.unwrap(); .unwrap();
let mgr = entity_manager.component_managers.get(index).unwrap(); let mgr = entity_manager.component_buffers.get(index).unwrap();
unsafe { mgr.as_ref() }.unwrap() unsafe { mgr.as_ref() }.unwrap()
} }
pub fn get_mut<C: Component>( pub fn get_mut<C: Component>(
&mut self, &mut self,
entity_manager: &mut EntityManager, entity_manager: &mut EntityManager,
) -> &mut ComponentManager { ) -> &mut ComponentBuffer {
let index = self let index = self
.component_manager_indices .component_buffer_indices
.get(C::STD_NAME) .get(C::STD_NAME)
.copied() .copied()
.unwrap(); .unwrap();
let mgr = entity_manager.component_managers.get(index).unwrap(); let mgr = entity_manager.component_buffers.get(index).unwrap();
unsafe { mgr.as_mut() }.unwrap() unsafe { mgr.as_mut() }.unwrap()
} }
} }
#[repr(C)] #[repr(C)]
#[derive(Debug)] #[derive(Debug)]
pub struct ComponentManager { pub struct ComponentBuffer {
pub vtable: &'static ComponentManagerVTable, pub vtable: &'static ComponentManagerVTable,
pub end: usize, pub end: usize,
unk: [isize; 2], unk: [isize; 2],
@ -65,7 +65,7 @@ pub struct ComponentManager {
pub next: StdVec<usize>, pub next: StdVec<usize>,
pub component_list: StdVec<*mut ComponentData>, pub component_list: StdVec<*mut ComponentData>,
} }
impl ComponentManager { impl ComponentBuffer {
pub fn iter_components(&self, entry: usize) -> ComponentIter { pub fn iter_components(&self, entry: usize) -> ComponentIter {
if let Some(off) = self.entity_entry.get(entry) { if let Some(off) = self.entity_entry.get(entry) {
ComponentIter { ComponentIter {

26
noita_api/src/noita/types/entity.rs
View file

@ -1,11 +1,11 @@
use crate::noita::types::component::{ComponentData, ComponentManager}; use crate::noita::types::component::{ComponentBuffer, ComponentData};
use crate::noita::types::{ use crate::noita::types::{
Component, ComponentTypeManager, Inventory2Component, StdMap, StdString, StdVec, Vec2, Component, ComponentTypeManager, Inventory2Component, StdMap, StdString, StdVec, Vec2,
}; };
use std::{mem, slice}; use std::{mem, slice};
impl EntityManager { impl EntityManager {
pub fn set_all_components(&mut self, ent: &mut Entity, enabled: bool) { pub fn set_all_components(&mut self, ent: &mut Entity, enabled: bool) {
self.iter_component_managers_mut().for_each(|c| { self.iter_component_buffers_mut().for_each(|c| {
c.iter_components_mut(ent.entry) c.iter_components_mut(ent.entry)
.for_each(|c| c.enabled = enabled) .for_each(|c| c.enabled = enabled)
}) })
@ -28,7 +28,7 @@ impl EntityManager {
tag: &StdString, tag: &StdString,
enabled: bool, enabled: bool,
) { ) {
self.iter_component_managers_mut().for_each(|c| { self.iter_component_buffers_mut().for_each(|c| {
c.iter_components_mut(ent.entry) c.iter_components_mut(ent.entry)
.filter(|c| c.tags.has_tag(tag_manager, tag)) .filter(|c| c.tags.has_tag(tag_manager, tag))
.for_each(|c| c.enabled = enabled) .for_each(|c| c.enabled = enabled)
@ -134,16 +134,16 @@ impl EntityManager {
.iter_mut() .iter_mut()
.filter_map(|c| unsafe { c.as_mut() }) .filter_map(|c| unsafe { c.as_mut() })
} }
pub fn iter_component_managers(&self) -> impl Iterator<Item = &'static ComponentManager> { pub fn iter_component_buffers(&self) -> impl Iterator<Item = &'static ComponentBuffer> {
self.component_managers self.component_buffers
.as_ref() .as_ref()
.iter() .iter()
.filter_map(|c| unsafe { c.as_ref() }) .filter_map(|c| unsafe { c.as_ref() })
} }
pub fn iter_component_managers_mut( pub fn iter_component_buffers_mut(
&mut self, &mut self,
) -> impl Iterator<Item = &'static mut ComponentManager> { ) -> impl Iterator<Item = &'static mut ComponentBuffer> {
self.component_managers self.component_buffers
.as_mut() .as_mut()
.iter_mut() .iter_mut()
.filter_map(|c| unsafe { c.as_mut() }) .filter_map(|c| unsafe { c.as_mut() })
@ -154,11 +154,11 @@ impl EntityManager {
entry: usize, entry: usize,
) -> impl Iterator<Item = &'static C> { ) -> impl Iterator<Item = &'static C> {
let index = component_type_manager let index = component_type_manager
.component_manager_indices .component_buffer_indices
.get(C::STD_NAME) .get(C::STD_NAME)
.copied() .copied()
.unwrap(); .unwrap();
let mgr = self.component_managers.get(index).unwrap(); let mgr = self.component_buffers.get(index).unwrap();
unsafe { mgr.as_ref() } unsafe { mgr.as_ref() }
.unwrap() .unwrap()
.iter_components(entry) .iter_components(entry)
@ -278,14 +278,14 @@ impl EntityManager {
&self, &self,
entry: usize, entry: usize,
) -> impl Iterator<Item = &'static ComponentData> { ) -> impl Iterator<Item = &'static ComponentData> {
self.iter_component_managers() self.iter_component_buffers()
.flat_map(move |c| c.iter_components(entry)) .flat_map(move |c| c.iter_components(entry))
} }
pub fn iter_all_components_mut( pub fn iter_all_components_mut(
&mut self, &mut self,
entry: usize, entry: usize,
) -> impl Iterator<Item = &'static mut ComponentData> { ) -> impl Iterator<Item = &'static mut ComponentData> {
self.iter_component_managers_mut() self.iter_component_buffers_mut()
.flat_map(move |c| c.iter_components_mut(entry)) .flat_map(move |c| c.iter_components_mut(entry))
} }
pub fn iter_in_radius(&self, pos: Vec2, radius: f32) -> impl Iterator<Item = &'static Entity> { pub fn iter_in_radius(&self, pos: Vec2, radius: f32) -> impl Iterator<Item = &'static Entity> {
@ -660,7 +660,7 @@ pub struct EntityManager {
pub free_ids: StdVec<usize>, pub free_ids: StdVec<usize>,
pub entities: StdVec<*mut Entity>, pub entities: StdVec<*mut Entity>,
pub entity_buckets: StdVec<StdVec<*mut Entity>>, pub entity_buckets: StdVec<StdVec<*mut Entity>>,
pub component_managers: StdVec<*mut ComponentManager>, pub component_buffers: StdVec<*mut ComponentBuffer>,
} }
#[repr(C)] #[repr(C)]
#[derive(Debug)] #[derive(Debug)]