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, &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, &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, &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, &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, &CYCLONE);
assert_eq!(s.compute_total_cost().0.get_total(), 405);

impl<'l> Schematic<'l>

pub fn deserialize_base64(data: &str) -> Result<Schematic<'l>, R64Error>

deserializes a schematic from base64

let string = "bXNjaAF4nGNgZmBmZmDJS8xNZeBOyslPzlYAkwzcKanFyUWZBSWZ+XkMDAxsOYlJqTnFDEzRsYwMfAWJlTn5iSm6RfmlJalFQGlGEGJkZWSYxQAAcBkUPA==";
let s = Schematic::deserialize_base64(string).unwrap();
assert!(s.get(1, 1).unwrap().unwrap().block.name() == "payload-router");

pub fn serialize_base64(&self) -> Result<String, W64Error>

serialize a schematic to base64

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<'_>

fn render(&self) -> Image<Vec<u8>, 3>

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

let mut s = Schematic::new(2, 3);
s.put(0, 0, &DISTRIBUTOR);
s.put(0, 2, &ROUTER);
s.put(1, 2, &COPPER_WALL);
let output /*: Image */ = s.render();

impl<'l> Serializable for Schematic<'l>

type ReadError = ReadError

type WriteError = WriteError

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

deserialize self from a binary buffer

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

transform self into a binary buffer