unit factory (not units factory)

Author: =

assets/bundles/bundle.properties

@@ -41,6 +41,8 @@ block.sw-light.description = A shrapnel energy turret.
 
 block.sw-submarine-factory.name = Submarine Factory
 block.sw-submarine-factory.description = A unit factory that makes submarines.
+block.sw-crafter-factory.name = Crafter Factory
+block.sw-crafter-factory.description = A unit factory that can only make units if it outnumbers them.
 
 block.sw-core-scaffold.name = Core Scaffold
 block.sw-core-scaffold.description = A core slightly better than shard, the root of the Tech Tree.
@@ -71,6 +73,4 @@ stat.sw-heat-use = Heat used/Second
 stat.sw-heat-tresh = Heat Transfer Threshold
 
 ## vanilla doesn't have one
-ability.spawndeath = Spawns unit after death
-
-planet.sw-orion.name = Orion
+ability.spawndeath = Spawns unit after death

assets/sprites/blocks/units/crafter-factory-top.png

@@ -26,10 +26,12 @@
 import sw.world.blocks.heat.HeatRadiator;
 import sw.world.blocks.production.MultiCrafter;
 import sw.world.blocks.production.StackCrafter;
+import sw.world.blocks.units.SingleUnitFactory;
 import sw.world.consumers.ConsumeHeat;
 import sw.world.recipes.GenericRecipe;
 
 import static mindustry.type.ItemStack.with;
+import static mindustry.world.blocks.units.UnitFactory.*;
 
 public class SWBlocks {
 	public static Block
@@ -51,6 +53,7 @@ public class SWBlocks {
 		bolt, light, /*thunder,*/
 
     subFactory,
+		crafterFactory,
 
 		coreScaffold;
 
@@ -131,14 +134,15 @@ public static void load() {
 			requirements(Category.crafting, with(Items.titanium, 120, Items.silicon, 50, Items.graphite, 75, SWItems.nickel, 150));
 			size = 3;
 			health = 200;
-			craftTime = 10f;
+			craftTime = 30f;
+			stacks = 6;
 			consumeItem(Items.coal, 1);
 			consumeLiquid(SWLiquids.steam, 0.02f);
       drawer = new DrawMulti(new DrawDefault(), new DrawBlurSpin("-rotator", 1f) {{
 				rotateSpeed = 0.2f;
 				blurThresh = 1.1f;
 			}});
-			outputItems = with(Items.graphite, 1);
+			outputItems = with(Items.graphite, 8);
 		}};
 		rebuilder = new MultiCrafter("rebuilder") {{
 			requirements(Category.crafting, with(
@@ -256,6 +260,19 @@ public static void load() {
 			consumePower(1.5f);
 			plans.add(new UnitPlan(SWUnitTypes.recluse, 60f * 50f, with(Items.silicon, 15, Items.metaglass, 25, SWItems.compound, 20)));
 		}};
+		crafterFactory = new SingleUnitFactory("crafter-factory") {{
+			requirements(Category.units, with(
+							SWItems.compound, 130,
+							Items.titanium, 120,
+							Items.silicon, 150
+			));
+			size = 2;
+			health = 160;
+			consumePower(2f);
+			itemCapacity = 40;
+			unitPlan = new UnitPlan(SWUnitTypes.bakler, 60f * 30f, with(Items.silicon, 20, Items.titanium, 15, SWItems.compound, 10));
+			consumeItems(unitPlan.requirements);
+		}};
 
 //		storage
 		coreScaffold = new CoreBlock("core-scaffold") {{

assets/sprites/blocks/units/crafter-factory.png

@@ -32,12 +32,14 @@ public SWUnitType(String name) {
   @Override
   public void setStats() {
     super.setStats();
-    stats.add(Stat.input, t -> {
-      for (ItemStack stack : recipe.consumeItems) t.add(new ItemImage(stack));
-    });
-    stats.add(Stat.output, t -> {
-      for (ItemStack stack : recipe.outputItems) t.add(new ItemImage(stack));
-    });
+    if (recipe != null) {
+      stats.add(Stat.input, t -> {
+        for (ItemStack stack : recipe.consumeItems) t.add(new ItemImage(stack)).pad(3f);
+      });
+      stats.add(Stat.output, t -> {
+        for (ItemStack stack : recipe.outputItems) t.add(new ItemImage(stack)).pad(3f);
+      });
+    }
   }
 
   @Override

src/sw/content/SWBlocks.java

@@ -0,0 +1,102 @@
+package sw.world.blocks.units;
+
+import arc.Core;
+import arc.Events;
+import arc.graphics.g2d.Draw;
+import arc.graphics.g2d.TextureRegion;
+import arc.math.Mathf;
+import arc.struct.Seq;
+import arc.util.io.Reads;
+import arc.util.io.Writes;
+import mindustry.Vars;
+import mindustry.content.UnitTypes;
+import mindustry.game.EventType.UnitCreateEvent;
+import mindustry.gen.Building;
+import mindustry.gen.Unit;
+import mindustry.graphics.Drawf;
+import mindustry.graphics.Layer;
+import mindustry.type.ItemStack;
+import mindustry.ui.ItemImage;
+import mindustry.world.Block;
+import mindustry.world.blocks.units.UnitFactory.UnitPlan;
+import mindustry.world.meta.Stat;
+
+public class SingleUnitFactory extends Block {
+  public TextureRegion topRegion;
+  public UnitPlan unitPlan = new UnitPlan(UnitTypes.flare, 60f, ItemStack.empty);
+  public int unitCapacity = 1;
+
+  public SingleUnitFactory(String name) {
+    super(name);
+    destructible = update = sync = true;
+  }
+
+  @Override
+  public void setStats() {
+    super.setStats();
+    stats.add(Stat.input, t -> {for (ItemStack stack : unitPlan.requirements) t.add(new ItemImage(stack)).pad(3f);});
+    stats.add(Stat.output, t -> t.image(unitPlan.unit.fullIcon).size(32f).pad(5));
+  }
+
+  @Override
+  public void load() {
+    super.load();
+    topRegion = Core.atlas.find(name + "-top");
+  }
+
+  @Override
+  public TextureRegion[] icons() {
+    return new TextureRegion[]{region, topRegion};
+  }
+
+  public class SingleUnitFactoryBuild extends Building {
+    public float progress, totalProgress, warmup;
+    public boolean canCreate() {
+      Seq<Building> otherFactories = team.data().getBuildings(block);
+      return unitPlan.unit.useUnitCap ? team.data().countType(unitPlan.unit) < team.data().unitCap : team.data().countType(unitPlan.unit) < otherFactories.size * unitCapacity;
+    }
+
+    @Override
+    public void updateTile() {
+      if (efficiency > 0 && canCreate()) {
+        progress += getProgressIncrease(unitPlan.time) * warmup * Vars.state.rules.unitBuildSpeedMultiplier;
+        totalProgress += edelta() * Vars.state.rules.unitBuildSpeedMultiplier;
+        warmup = Mathf.approachDelta(warmup, 1, 0.014f * Vars.state.rules.unitBuildSpeedMultiplier);
+
+        if (progress >= 1f) {
+          progress %= 1f;
+
+          Unit unit = unitPlan.unit.spawn(team, this);
+          Events.fire(new UnitCreateEvent(unit, this));
+        }
+      } else {
+        warmup = Mathf.approachDelta(warmup, 0, 0.014f);
+        progress = Mathf.approachDelta(warmup, 0, 0.014f);
+      }
+    }
+
+    @Override
+    public void draw() {
+      super.draw();
+      Draw.draw(Layer.blockOver, () -> Drawf.construct(this, unitPlan.unit, 0, progress, warmup * Vars.state.rules.unitBuildSpeedMultiplier, totalProgress));
+      Draw.z(Layer.blockOver + 0.01f);
+      Draw.rect(topRegion, x, y, 0);
+    }
+
+    @Override
+    public void write(Writes write) {
+      super.write(write);
+      write.f(progress);
+      write.f(totalProgress);
+      write.f(warmup);
+    }
+
+    @Override
+    public void read(Reads read, byte revision) {
+      super.read(read, revision);
+      progress = read.f();
+      totalProgress = read.f();
+      warmup = read.f();
+    }
+  }
+}