Overflow duct

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

@@ -27,7 +27,6 @@ public class DuctRouter extends Block{
         update = true;
         solid = false;
         hasItems = true;
-        conveyorPlacement = true;
         unloadable = false;
         itemCapacity = 1;
         noUpdateDisabled = true;
@@ -58,6 +57,11 @@ public class DuctRouter extends Block{
         Draw.rect(topRegion, plan.drawx(), plan.drawy(), plan.rotation * 90);
     }
 
+    @Override
+    public boolean rotatedOutput(int x, int y){
+        return false;
+    }
+
     public class DuctRouterBuild extends Building{
         public @Nullable Item sortItem;
 

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

@@ -0,0 +1,137 @@
+package mindustry.world.blocks.distribution;
+
+import arc.graphics.g2d.*;
+import arc.math.*;
+import arc.util.*;
+import mindustry.annotations.Annotations.*;
+import mindustry.entities.units.*;
+import mindustry.gen.*;
+import mindustry.type.*;
+import mindustry.world.*;
+import mindustry.world.meta.*;
+
+public class OverflowDuct extends Block{
+    public float speed = 5f;
+
+    public @Load(value = "@-top") TextureRegion topRegion;
+
+    public OverflowDuct(String name){
+        super(name);
+
+        group = BlockGroup.transportation;
+        update = true;
+        solid = false;
+        hasItems = true;
+        conveyorPlacement = true;
+        unloadable = false;
+        itemCapacity = 1;
+        noUpdateDisabled = true;
+        rotate = true;
+        envEnabled = Env.space | Env.terrestrial | Env.underwater;
+    }
+
+    @Override
+    public void setStats(){
+        super.setStats();
+
+        stats.add(Stat.itemsMoved, 60f / speed, StatUnit.itemsSecond);
+    }
+
+    @Override
+    public TextureRegion[] icons(){
+        return new TextureRegion[]{region, topRegion};
+    }
+
+    @Override
+    public void drawRequestRegion(BuildPlan plan, Eachable<BuildPlan> list){
+        Draw.rect(region, plan.drawx(), plan.drawy());
+        Draw.rect(topRegion, plan.drawx(), plan.drawy(), plan.rotation * 90);
+    }
+
+    @Override
+    public boolean rotatedOutput(int x, int y){
+        return false;
+    }
+
+    public class DuctRouterBuild extends Building{
+        public float progress;
+        public @Nullable Item current;
+
+        @Override
+        public void draw(){
+            Draw.rect(region, x, y);
+            Draw.rect(topRegion, x, y, rotdeg());
+        }
+
+        @Override
+        public void updateTile(){
+            progress += edelta() / speed * 2f;
+
+            if(current != null){
+                if(progress >= (1f - 1f/speed)){
+                    var target = target();
+                    if(target != null){
+                        target.handleItem(this, current);
+                        cdump = (byte)(cdump == 0 ? 2 : 0);
+                        items.remove(current, 1);
+                        current = null;
+                        progress %= (1f - 1f/speed);
+                    }
+                }
+            }else{
+                progress = 0;
+            }
+
+            if(current == null && items.total() > 0){
+                current = items.first();
+            }
+        }
+
+        @Nullable
+        public Building target(){
+            if(current == null) return null;
+
+            Building front = front();
+            if(front != null && front.team == team && front.acceptItem(this, current)){
+                return front;
+            }
+
+            for(int i = -1; i <= 1; i++){
+                int dir = Mathf.mod(rotation + (((i + cdump + 1) % 3) - 1), 4);
+                if(dir == rotation) continue;
+                Building other = nearby(dir);
+                if(other != null && other.team == team && other.acceptItem(this, current)){
+                    return other;
+                }
+            }
+            return null;
+        }
+
+        @Override
+        public boolean acceptItem(Building source, Item item){
+            return current == null && items.total() == 0 &&
+                (Edges.getFacingEdge(source.tile(), tile).relativeTo(tile) == rotation);
+        }
+
+        @Override
+        public int removeStack(Item item, int amount){
+            int removed = super.removeStack(item, amount);
+            if(item == current) current = null;
+            return removed;
+        }
+
+        @Override
+        public void handleStack(Item item, int amount, Teamc source){
+            super.handleStack(item, amount, source);
+            current = item;
+        }
+
+        @Override
+        public void handleItem(Building source, Item item){
+            current = item;
+            progress = -1f;
+            items.add(item, 1);
+            noSleep();
+        }
+    }
+}