-version = "3.0.8"

- let edgify = |skip, mut to: Image<&mut [u8], 4>| {

- to.overlay(edge.borrow());

- base.borrow_mut(),

- edgify(5, base.borrow_mut());

- edgify(rot.rotated(false).count(), base.borrow_mut());

- .overlay_at(img.as_ref(), offset, offset);

-use super::{BlockLogic, Rotation, State};

-use crate::data::{renderer::*, DataRead, ReadError};

- "duo" => ItemTurret::new(1, true, cost!(Copper: 35));

- "scatter" => ItemTurret::new(2, true, cost!(Copper: 85, Lead: 45));

- "scorch" => ItemTurret::new(1, true, cost!(Copper: 25, Graphite: 22));

- "hail" => ItemTurret::new(1, true, cost!(Copper: 40, Graphite: 17));

- "wave" => Turret::new(2, true, cost!(Copper: 25, Lead: 75, Metaglass: 45));

- "tsunami" => Turret::new(3, true, cost!(Lead: 400, Metaglass: 100, Titanium: 250, Thorium: 100));

- "lancer" => Turret::new(2, true, cost!(Copper: 60, Lead: 70, Titanium: 30, Silicon: 60));

- "arc" => Turret::new(1, true, cost!(Copper: 50, Lead: 50));

- "parallax" => TractorBeamTurret::new(2, true, cost!(Graphite: 30, Titanium: 90, Silicon: 120));

- "swarmer" => ItemTurret::new(2, true, cost!(Graphite: 35, Titanium: 35, Silicon: 30, Plastanium: 45));

- "salvo" => ItemTurret::new(2, true, cost!(Copper: 100, Graphite: 80, Titanium: 50));

- "segment" => PointDefenseTurret::new(2, true, cost!(Titanium: 40, Thorium: 80, Silicon: 130, PhaseFabric: 40));

- "fuse" => ItemTurret::new(3, true, cost!(Copper: 225, Graphite: 225, Thorium: 100));

- "ripple" => ItemTurret::new(3, true, cost!(Copper: 150, Graphite: 135, Titanium: 60));

- "cyclone" => ItemTurret::new(3, true, cost!(Copper: 200, Titanium: 125, Plastanium: 80));

- "foreshadow" => ItemTurret::new(4, true, cost!(Copper: 1000, Metaglass: 600, Silicon: 600, Plastanium: 200, SurgeAlloy: 300));

- "spectre" => ItemTurret::new(4, true, cost!(Copper: 900, Graphite: 300, Thorium: 250, Plastanium: 175, SurgeAlloy: 250));

- "meltdown" => Turret::new(4, true, cost!(Copper: 1200, Lead: 350, Graphite: 300, Silicon: 325, SurgeAlloy: 325));

- "breach" => ItemTurret::new(3, true, cost!(Beryllium: 150, Silicon: 150, Graphite: 250));

- "diffuse" => ItemTurret::new(3, true, cost!(Beryllium: 150, Silicon: 200, Graphite: 200, Tungsten: 50));

- "sublimate" => ContinousTurret::new(3, true, cost!(Tungsten: 150, Silicon: 200, Oxide: 40, Beryllium: 400));

- "titan" => ItemTurret::new(4, true, cost!(Tungsten: 250, Silicon: 300, Thorium: 400));

- "disperse" => ItemTurret::new(4, true, cost!(Thorium: 50, Oxide: 150, Silicon: 200, Beryllium: 350));

- "afflict" => Turret::new(4, true, cost!(SurgeAlloy: 100, Silicon: 200, Graphite: 250, Oxide: 40));

- "lustre" => ContinousTurret::new(4, true, cost!(Silicon: 250, Graphite: 200, Oxide: 50, Carbide: 90));

- "scathe" => ItemTurret::new(4, true, cost!(Oxide: 200, SurgeAlloy: 400, Silicon: 800, Carbide: 500, PhaseFabric: 300));

- "malign" => Turret::new(5, true, cost!(Carbide: 400, Beryllium: 2000, Silicon: 800, Graphite: 800, PhaseFabric: 300));

- "smite" => ItemTurret::new(5, true, cost!(Oxide: 200, SurgeAlloy: 400, Silicon: 800, Carbide: 500, PhaseFabric: 300));

-fn draw_turret(

- me: &impl BlockLogic,

- name: &str,

- _: Option<&State>,

- _: Option<&RenderingContext>,

- _: Rotation,

- s: Scale,

-) -> ImageHolder<4> {

- let size = me.get_size();

- let mut base = match name {

- "breach" | "diffuse" | "sublimate" | "titan" | "disperse" | "afflict" | "lustre"

- | "scathe" | "malign" | "smite" => load!(s -> match size {

- 3 => "reinforced-block-3",

- 4 => "reinforced-block-4",

- 5 => "reinforced-block-5",

- }),

- _ => load!(s -> match size {

- 1 => "block-1",

- 2 => "block-2",

- 3 => "block-3",

- 4 => "block-4",

- }),

- };

- base.overlay(&load!(from name which is ["duo" | "scatter" | "scorch" | "hail" | "wave" | "tsunami" | "lancer" | "arc" | "parallax" | "swarmer" | "salvo" | "segment" | "fuse" | "ripple" | "cyclone" | "foreshadow" | "spectre" | "meltdown" | "breach" | "diffuse" | "sublimate" | "titan" | "disperse" | "afflict" | "lustre" | "scathe" | "malign" | "smite"], s));

- base

-}

-

-make_simple!(Turret, draw_turret, |_, _, _, buff: &mut DataRead| {

- read_turret(buff)

-});

-make_simple!(

- PointDefenseTurret,

- draw_turret,

- |_, _, _, buff: &mut DataRead| read_point_defense_turret(buff)

-);

-make_simple!(

- ContinousTurret,

- draw_turret,

- |_, _, _, buff: &mut DataRead| { read_continous_turret(buff) }

-);

-make_simple!(

- TractorBeamTurret,

- draw_turret,

- |_, _, _, buff: &mut DataRead| { read_tractor_beam_turret(buff) }

-);

-make_simple!(ItemTurret, draw_turret, |_, _, _, buff: &mut DataRead| {

- read_item_turret(buff)

-});

- RepairTurret,

- |_, n, _, _, _, scl| {

- match n {

- "repair-turret" => {

- let mut bot = load!("block-2", scl);

- bot.overlay(&load!("repair-turret", scl));

- bot

- }

- _ => {

- let mut bot = load!("repair-point-base", scl);

- bot.overlay(&load!("repair-point", scl));

- bot

- }

- }

- },

- |_, _, _, buff: &mut DataRead| {

- "repair-point" => RepairTurret::new(1, true, cost!(Copper: 30, Lead: 30, Silicon: 20));

- "repair-turret" => RepairTurret::new(2, true, cost!(Thorium: 80, Silicon: 90, Plastanium: 60));

- tile.image(

- ctx.as_ref(),

- tile.get_rotation().unwrap_or(Rotation::Up),

- Scale::Full,

- )

- .borrow(),

- tile.floor(scale).borrow(),

- tile.ore(scale).borrow(),

- tile.build_image(ctx.as_ref(), scale).borrow(),

- floor.as_mut().overlay_at(top.as_ref(), 0, 0);

- fn overlay_at(&mut self, with: W, x: u32, y: u32) -> &mut Self;

- fn repeated(self, x: u32, y: u32) -> Self::Output;

- fn overlay_at(&mut self, with: Image<&[u8], 3>, x: u32, y: u32) -> &mut Self {

- fn overlay_at(&mut self, with: Image<&[u8], 4>, x: u32, y: u32) -> &mut Self {

- fn overlay_at(&mut self, with: Image<&[u8], 4>, x: u32, y: u32) -> &mut Self {

- fn repeated(self, x: u32, y: u32) -> Self::Output {

- a.overlay_at(self.copy(), x * self.width(), y * self.height());

- type With<'a> = Image<&'a [u8], 4>;

- fn overlay(&mut self, with: Image<&[u8], 4>) -> &mut Self {

-impl<'a> Overlay<&'a ImageHolder<4>> for ImageHolder<4> {

- fn overlay_at(&mut self, with: &'a ImageHolder<4>, x: u32, y: u32) -> &mut Self {

- self.borrow_mut().overlay_at(with.borrow(), x, y);

- self.borrow_mut().overlay(with.borrow());