Unit assembler progress

core/src/mindustry/world/blocks/defense/BuildTurret.java

@@ -47,6 +47,7 @@ public class BuildTurret extends BaseTurret{
         //this is super hacky, but since blocks are initialized before units it does not run into init/concurrent modification issues
         unitType = new UnitType("turret-unit-" + name){{
             hidden = true;
+            internal = true;
             speed = 0f;
             hitSize = 0f;
             health = 1;

core/src/mindustry/world/blocks/distribution/Duct.java

@@ -124,6 +124,11 @@ public class Duct extends Block implements Autotiler{
             Draw.reset();
         }
 
+        @Override
+        public void payloadDraw(){
+            Draw.rect(fullIcon, x, y);
+        }
+
         protected void drawAt(float x, float y, int bits, float rotation, SliceMode slice){
             Draw.z(Layer.blockUnder);
             Draw.rect(sliced(botRegions[bits], slice), x, y, rotation);

core/src/mindustry/world/blocks/units/UnitAssembler.java

@@ -1,14 +1,21 @@
 package mindustry.world.blocks.units;
 
+import arc.*;
+import arc.graphics.g2d.*;
+import arc.math.*;
 import arc.math.geom.*;
 import arc.struct.*;
 import arc.util.*;
 import arc.util.io.*;
 import mindustry.content.*;
+import mindustry.entities.*;
+import mindustry.entities.units.*;
 import mindustry.gen.*;
 import mindustry.graphics.*;
 import mindustry.type.*;
+import mindustry.ui.*;
 import mindustry.world.blocks.payloads.*;
+import mindustry.world.consumers.*;
 
 import static mindustry.Vars.*;
 
@@ -20,13 +27,13 @@ import static mindustry.Vars.*;
  * 3.
  * */
 public class UnitAssembler extends PayloadBlock{
-    public int areaSize = 10;
+    public int areaSize = 11;
     public UnitType droneType;
     public int dronesCreated = 4;
 
     //TODO should be different for every tier.
     public Seq<BlockStack> requirements = new Seq<>();
-    public UnitType output = UnitTypes.vanquish;
+    public UnitType output;
 
     public UnitAssembler(String name){
         super(name);
@@ -48,21 +55,62 @@ public class UnitAssembler extends PayloadBlock{
         Tmp.r1.x += Geometry.d4x(rotation) * len;
         Tmp.r1.y += Geometry.d4y(rotation) * len;
 
-        //TODO better visuals here?
+        //TODO better visuals here? dashLine looks bad
         Drawf.dashRect(valid ? Pal.accent : Pal.remove, Tmp.r1);
     }
 
+    @Override
+    public void setBars(){
+        super.setBars();
+
+        //TODO progress bar
+        //bars.add("progress", (UnitAssemblerBuild e) -> new Bar("bar.progress", Pal.ammo, e::fraction));
+
+        bars.add("units", (UnitAssemblerBuild e) ->
+            new Bar(() ->
+            Core.bundle.format("bar.unitcap",
+                Fonts.getUnicodeStr(output.name),
+                e.team.data().countType(output),
+                Units.getStringCap(e.team)
+            ),
+            () -> Pal.power,
+            () -> (float)e.team.data().countType(output) / Units.getCap(e.team)
+        ));
+    }
+
+    @Override
+    public void drawRequestRegion(BuildPlan plan, Eachable<BuildPlan> list){
+        Draw.rect(region, plan.drawx(), plan.drawy());
+        //Draw.rect(outRegion, plan.drawx(), plan.drawy(), plan.rotation * 90);
+        Draw.rect(topRegion, plan.drawx(), plan.drawy());
+    }
+
+    @Override
+    public void init(){
+        consumes.add(new ConsumePayloads(requirements, (UnitAssemblerBuild build) -> build.blocks));
+
+        super.init();
+    }
+
     public class UnitAssemblerBuild extends PayloadBlockBuild<BuildPayload>{
         public Seq<Unit> units = new Seq<>();
+        public BlockSeq blocks = new BlockSeq();
 
-        //TODO how should payloads be stored? counts of blocks? intmap? references?
-        //public Seq<BuildPayload> payloads = new Seq<>();
+        //TODO progress
+        //TODO how should payloads be stored exactly? counts of blocks? intmap? references?
+
+        public Vec2 getUnitSpawn(){
+            float len = tilesize * (areaSize + size)/2f;
+            float unitX = x + Geometry.d4x(rotation) * len, unitY = y + Geometry.d4y(rotation) * len;
+            return Tmp.v4.set(unitX, unitY);
+        }
 
         @Override
         public void updateTile(){
             units.removeAll(u -> !u.isAdded() || u.dead);
 
-            if(consValid() && units.size < dronesCreated){
+            //units annoying, disabled for now
+            if(false && efficiency() > 0 && units.size < dronesCreated){
                 //TODO build animation? distribute spawning?
                 var unit = droneType.create(team);
                 if(unit instanceof BuildingTetherc bt){
@@ -76,29 +124,88 @@ public class UnitAssembler extends PayloadBlock{
                 units.add(unit);
             }
 
+            //TODO units should move stuff into position
+
+            //TODO check if area is occupied
+
+            Vec2 spawn = getUnitSpawn();
+
+            //check if all requirements are met
+            if(consValid() & Units.canCreate(team, output)){
+
+                //TODO ???? should this even be part of a trigger
+                consume();
+
+                //TODO actually just goes poof
+                var unit = output.create(team);
+                unit.set(spawn.x + Mathf.range(0.001f), spawn.y + Mathf.range(0.001f));
+                unit.rotation = 90f;
+                unit.add();
+
+                Fx.spawn.at(unit);
+
+                blocks.clear();
+            }
+
             //TODO drones need to indicate that they are in position and actually play an animation
         }
 
+        @Override
+        public void draw(){
+            Draw.rect(region, x, y);
+            //Draw.rect(outRegion, x, y, rotdeg());
+
+            Draw.z(Layer.blockOver);
+
+            //payRotation = rotdeg();
+            //drawPayload();
+
+            Draw.z(Layer.blockOver + 0.1f);
+
+            Draw.rect(topRegion, x, y);
+
+            Vec2 spawn = getUnitSpawn();
+
+            //TODO which layer?
+            Draw.z(Layer.power - 1f);
+
+            Draw.mixcol(Pal.accent, 1f);
+            Draw.alpha(0.4f + Mathf.absin(10f, 0.2f));
+            Draw.rect(output.fullIcon, spawn.x, spawn.y);
+            Draw.reset();
+        }
+
         @Override
         public void handlePayload(Building source, Payload payload){
             //super.handlePayload(source, payload);
 
+            blocks.add(((BuildPayload)payload).block());
+
             //payloads.add((BuildPayload)payload);
         }
 
         @Override
         public boolean acceptPayload(Building source, Payload payload){
-            return payload instanceof BuildPayload bp && requirements.contains(b -> b.block == bp.block());
+            return payload instanceof BuildPayload bp && requirements.contains(b -> b.block == bp.block() && blocks.get(bp.block()) < b.amount);
         }
 
         @Override
         public void write(Writes write){
             super.write(write);
+
+            //blocks.write(write);
+
+            //TODO save:
+            //- unit IDs
+            //- progress
+            //- payloads in position (should they have positions?)
         }
 
         @Override
         public void read(Reads read, byte revision){
             super.read(read, revision);
+
+            //blocks.read(read);
         }
     }
 }