Nothing sets this or uses it, yet.
Signed-off-by: Ian Jackson <ijackson@chiark.greenend.org.uk>
let mut pos = pos.unwrap_or(DEFAULT_POS_START);
let mut z = gs.max_z.clone_mut();
for piece_i in count {
- let p = info.load(piece_i as usize)?;
+ let PieceSpecLoaded { p, occultable } = info.load(piece_i as usize)?;
+ let _ = occultable; // xxx
let face = face.unwrap_or_default();
if p.nfaces() <= face.into() {
throw!(SpecError::FaceNotFound);
let mut pieces: Vec<Prep> = items.into_iter().map(|it| {
let spec = ItemSpec { lib: it.0, item: it.1.itemname };
(||{
- let p = spec.clone().load().context("load")?;
+ let loaded = spec.clone().load().context("load")?;
+ let p = loaded.p; // xxx show occulted version too
let mut uos = vec![];
p.add_ui_operations(&mut uos, &GPiece::dummy()).context("add uos")?;
let uos = uos.into_iter().map(|uo| uo.opname).collect::<Vec<_>>();
pub p: &'a dyn PieceTrait,
}
+#[derive(Debug)]
+pub struct PieceSpecLoaded {
+ pub p: Box<dyn PieceTrait>,
+ pub occultable: Option<(OccultIlkName, Box<dyn OccultedPieceTrait>)>,
+}
+
#[typetag::serde(tag="type")]
pub trait PieceSpec: Debug {
fn count(&self) -> usize { 1 }
- fn load(&self, i: usize) -> Result<Box<dyn PieceTrait>, SpecError>;
+ fn load(&self, i: usize) -> Result<PieceSpecLoaded, SpecError>;
}
// ========== implementations ==========
#[typetag::serde]
impl PieceSpec for piece_specs::Hand {
#[throws(SpecError)]
- fn load(&self, _: usize) -> Box<dyn PieceTrait> {
+ fn load(&self, _: usize) -> PieceSpecLoaded {
let common = SimpleCommon {
itemname: None,
faces: index_vec![ColourSpec(self.colour.clone())],
shape,
"magic-hand",
&common)?;
- Box::new(Hand {
+ let p = Box::new(Hand {
shape,
- }) as Box<dyn PieceTrait>
+ }) as Box<dyn PieceTrait>;
+ PieceSpecLoaded { p, occultable: None }
}
}
#[typetag::serde(tag="type")]
pub trait SimplePieceSpec: Debug {
fn load_raw(&self) -> Result<(SimpleShape, &SimpleCommon), SpecError>;
- fn load(&self) -> Result<Box<dyn PieceTrait>, SpecError> {
- Ok(Box::new(self.load_raw()?.0))
+ #[throws(SpecError)]
+ fn load(&self) -> PieceSpecLoaded {
+ PieceSpecLoaded { p: Box::new(self.load_raw()?.0), occultable: None }
}
}
#[typetag::serde]
impl PieceSpec for piece_specs::Disc {
#[throws(SpecError)]
- fn load(&self, _: usize) -> Box<dyn PieceTrait> { SimplePieceSpec::load(self)? }
+ fn load(&self, _: usize) -> PieceSpecLoaded { SimplePieceSpec::load(self)? }
}
impl piece_specs::Square {
#[typetag::serde]
impl PieceSpec for piece_specs::Square {
#[throws(SpecError)]
- fn load(&self, _: usize) -> Box<dyn PieceTrait> { SimplePieceSpec::load(self)? }
+ fn load(&self, _: usize) -> PieceSpecLoaded { SimplePieceSpec::load(self)? }
}
impl ItemSpec {
#[throws(SpecError)]
- pub fn load(&self) -> Box<dyn PieceTrait> {
+ pub fn load(&self) -> PieceSpecLoaded {
let lib = libs_lookup(&self.lib)?;
let idata = lib.items.get(&self.item)
.ok_or(SpE::LibraryItemNotFound(self.item.clone()))?;
}
impl Contents {
- fn load1(&self, idata: &ItemData, name: &str)
- -> Result<Box<dyn PieceTrait>,SpecError> {
+ #[throws(SpecError)]
+ fn load1(&self, idata: &ItemData, name: &str) -> PieceSpecLoaded {
let svg_path = format!("{}/{}.usvg", self.dirname, &name);
let svg_data = fs::read_to_string(&svg_path)
.map_err(|e| if e.kind() == ErrorKind::NotFound {
let it = Item { faces, descs, svgs, outline, desc_hidden,
itemname: name.to_string() };
- Ok(Box::new(it))
+ let p = Box::new(it);
+ PieceSpecLoaded { p, occultable: None }
}
#[throws(MgmtError)]
e@ Err(_) => e?,
Ok(r) => r,
};
- let f0bbox = loaded.bbox_approx()?;
+ let f0bbox = loaded.p.bbox_approx()?;
let ier = ItemEnquiryData {
itemname: k.clone(),
f0bbox,
- f0desc: loaded.describe_html(&GPiece::dummy())?,
+ f0desc: loaded.p.describe_html(&GPiece::dummy())?,
};
out.push(ier);
}
#[typetag::serde(name="Lib")]
impl PieceSpec for ItemSpec {
- fn load(&self, _: usize) -> Result<Box<dyn PieceTrait>, SpecError> {
+ fn load(&self, _: usize) -> Result<PieceSpecLoaded, SpecError> {
self.load()
}
}
#[typetag::serde(name="LibList")]
impl PieceSpec for MultiSpec {
fn count(&self) -> usize { self.items.len() }
- fn load(&self, i: usize) -> Result<Box<dyn PieceTrait>,SpecError> {
+ fn load(&self, i: usize) -> Result<PieceSpecLoaded, SpecError> {
let item = self.items.get(i).ok_or_else(
|| SpE::InternalError(format!("item {:?} from {:?}", i, &self))
)?;