Struct mindus::Schematic

pub struct Schematic<'l> {
    pub width: usize,
    pub height: usize,
    pub tags: HashMap<String, String>,
    pub blocks: Array2D<Option<Placement<'l>>>,
}

a schematic.

Fields

width: usize

height: usize

tags: HashMap<String, String>

blocks: Array2D<Option<Placement<'l>>>

schems can have holes, so Option is used.

Implementations

impl<'l> Schematic<'l>

pub fn new(width: usize, height: usize) -> Self

create a new schematic, panicking if too big

let s = Schematic::new(5, 5);

pub fn try_new(width: usize, height: usize) -> Result<Self, NewError>

create a new schematic, erroring if too big

assert!(Schematic::try_new(500, 500).is_err() == true);

pub fn get( &self, x: usize, y: usize ) -> Result<Option<&Placement<'l>>, PosError>

gets a block

let mut s = Schematic::new(5, 5);
assert!(s.get(0, 0).unwrap().is_none());
s.put(0, 0, &mindus::block::turrets::DUO);
assert!(s.get(0, 0).unwrap().is_some());

pub fn get_mut( &mut self, x: usize, y: usize ) -> Result<Option<&mut Placement<'l>>, PosError>

gets a block, mutably

pub fn put(&mut self, x: usize, y: usize, block: &'l Block) -> &mut Self

put a block in (same as Schematic::set, but less arguments and builder-ness). panics!!!

let mut s = Schematic::new(5, 5);
s.put(0, 0, &mindus::block::distribution::ROUTER);
assert!(s.get(0, 0).unwrap().is_some() == true);

pub fn set( &mut self, x: usize, y: usize, block: &'l Block, data: DynData, rot: Rotation ) -> Result<(), PlaceError>

set a block

let mut s = Schematic::new(5, 5);
s.set(0, 0, &mindus::block::distribution::ROUTER, DynData::Empty, Rotation::Right);
assert!(s.get(0, 0).unwrap().is_some() == true);

pub fn take( &mut self, x: usize, y: usize ) -> Result<Option<Placement<'l>>, PosError>

take out a block

let mut s = Schematic::new(5, 5);
s.put(0, 0, &mindus::block::turrets::DUO);
assert!(s.get(0, 0).unwrap().is_some() == true);
assert!(s.take(0, 0).unwrap().is_some() == true);
assert!(s.get(0, 0).unwrap().is_none() == true);

pub fn block_iter(&self) -> impl Iterator<Item = (GridPos, &Placement<'_>)>

iterate over all the blocks

pub fn compute_total_cost(&self) -> (ItemStorage, bool)

see how much this schematic costs. returns (cost, is_sandbox)

let mut s = Schematic::new(5, 5);
s.put(1, 1, &mindus::block::turrets::CYCLONE);
assert_eq!(s.compute_total_cost().0.get_total(), 405);

Trait Implementations

impl<'l> Clone for Schematic<'l>

fn clone(&self) -> Schematic<'l>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'l> Debug for Schematic<'l>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'l> PartialEq<Schematic<'l>> for Schematic<'l>

fn eq(&self, rhs: &Schematic<'l>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Renderable for Schematic<'_>

unsafe fn render(&self) -> RgbImage

creates a picture of a schematic. Bridges and node connections are not drawn.

use mindus::*;
let mut s = Schematic::new(2, 3);
s.put(0, 0, &block::distribution::DISTRIBUTOR);
s.put(0, 2, &block::distribution::ROUTER);
s.put(1, 2, &block::walls::COPPER_WALL);
// warm up the images for the first time
unsafe { warmup(); }
// this is now safe, because we have warmed up
let output /*: RgbImage */ = unsafe { s.render() };

Safety

UB if called before warmup

impl<'l> Serializer<Schematic<'l>> for SchematicSerializer<'l>

type ReadError = ReadError

type WriteError = WriteError

fn deserialize( &mut self, buff: &mut DataRead<'_> ) -> Result<Schematic<'l>, Self::ReadError>

fn serialize( &mut self, buff: &mut DataWrite<'_>, data: &Schematic<'_> ) -> Result<(), Self::WriteError>