Struct mindus::Schematic

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

a schematic.

Fields

width: usize

height: usize

tags: HashMap<String, String>

blocks: Array2D<Option<Placement>>

schems can have holes, so Option is used.

Implementations

impl Schematic

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

create a new schematic, panicking if too big

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

pub fn ratios(&self) -> Io

Ratios of this schematic.

assert_eq!(Schematic::deserialize_base64("bXNjaAF4nEWMSw7CMAxEh9REVSqx5hKcCLFISxaR0o9Sg8rtSTpFePPkmWfDwTWQyY8B5z75VdE9wzrkuGicJwA2+T6kFeb+aNDtym2MW8i4LJ/sNWo4dje8ksa31zmXuyv+Y4BTgRD2iIi9M+xM7WrUgnoNhYpQESpCxfKLrUo9FsISLX6vKgwhhCVK+wX5/BtM").unwrap().ratios(),
    ratios![[Coal: 5.25, Lead: 10.5, Sand: 10.5, Water: 180] => [BlastCompound: 5.25, SporePod: 0.75]]);

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>, 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>, PosError>

gets a block, mutably

pub fn put(&mut self, x: usize, y: usize, block: &'static 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: &'static 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>, 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 Schematic

pub fn deserialize_base64(data: &str) -> Result<Schematic, 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 Clone for Schematic

fn clone(&self) -> Schematic

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Schematic

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

Formats the value using the given formatter.

impl PartialEq for Schematic

fn eq(&self, rhs: &Schematic) -> 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 Serializable for Schematic

type ReadError = ReadError

type WriteError = WriteError

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

deserialize self from a binary buffer

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

transform self into a binary buffer