use std::collections::HashMap;
use super::entities::Entity;
use super::file::VmfFile;
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
pub struct EntId {
pub hidden: bool,
pub idx: u32,
}
impl VmfFile {
pub fn entity(&self, id: EntId) -> Option<&Entity> {
let list = if id.hidden {
&self.hiddens
} else {
&self.entities
};
list.get(id.idx as usize)
}
pub fn entity_mut(&mut self, id: EntId) -> Option<&mut Entity> {
let list = if id.hidden {
&mut self.hiddens
} else {
&mut self.entities
};
list.get_mut(id.idx as usize)
}
pub fn iter_entities(&self) -> impl Iterator<Item = (EntId, &Entity)> {
let visible = self.entities.iter().enumerate().map(|(i, ent)| {
(
EntId {
hidden: false,
idx: i as u32,
},
ent,
)
});
let hidden = self.hiddens.iter().enumerate().map(|(i, ent)| {
(
EntId {
hidden: true,
idx: i as u32,
},
ent,
)
});
visible.chain(hidden)
}
pub fn iter_entities_mut(&mut self) -> impl Iterator<Item = (EntId, &mut Entity)> {
let visible = self.entities.iter_mut().enumerate().map(|(i, ent)| {
(
EntId {
hidden: false,
idx: i as u32,
},
ent,
)
});
let hidden = self.hiddens.iter_mut().enumerate().map(|(i, ent)| {
(
EntId {
hidden: true,
idx: i as u32,
},
ent,
)
});
visible.chain(hidden)
}
}
#[derive(Debug, Default, Clone)]
pub struct EntityIndex {
names: HashMap<Box<str>, Vec<EntId>>,
}
impl EntityIndex {
pub fn build(vmf: &VmfFile) -> Self {
let mut names: HashMap<Box<str>, Vec<EntId>> = HashMap::new();
for (id, ent) in vmf.iter_entities() {
if let Some(name) = ent.targetname() {
names.entry(name.into()).or_default().push(id);
}
}
Self { names }
}
pub fn by_name(&self, name: &str) -> &[EntId] {
self.names.get(name).map_or(&[], |ids| ids.as_slice())
}
pub fn by_prefix<'a>(&'a self, prefix: &'a str) -> impl Iterator<Item = EntId> + 'a {
self.names
.iter()
.filter(move |(name, _)| name.starts_with(prefix))
.flat_map(|(_, ids)| ids.iter().copied())
}
}