Overdrive system

core/src/io/anuke/mindustry/content/fx/BlockFx.java

@@ -19,7 +19,7 @@ public class BlockFx extends FxList implements ContentList{
     public static Effect reactorsmoke, nuclearsmoke, nuclearcloud, redgeneratespark, generatespark, fuelburn, plasticburn,
     pulverize, pulverizeRed, pulverizeRedder, pulverizeSmall, pulverizeMedium, producesmoke, smeltsmoke, formsmoke, blastsmoke,
     lava, dooropen, doorclose, dooropenlarge, doorcloselarge, purify, purifyoil, purifystone, generate, mine, mineBig, mineHuge,
-    smelt, teleportActivate, teleport, teleportOut, ripple, bubble, commandSend, healBlock, healBlockFull, healWaveMend, overdriveWave;
+    smelt, teleportActivate, teleport, teleportOut, ripple, bubble, commandSend, healBlock, healBlockFull, healWaveMend, overdriveWave, overdriveBlockFull;
 
     @Override
     public void load(){
@@ -312,5 +312,12 @@ public class BlockFx extends FxList implements ContentList{
             Fill.square(e.x, e.y, e.rotation * tilesize);
             Draw.color();
         });
+
+        overdriveBlockFull = new Effect(60, e -> {
+            Draw.color(e.color);
+            Draw.alpha(e.fslope() * 0.5f);
+            Fill.square(e.x, e.y, e.rotation * tilesize);
+            Draw.color();
+        });
     }
 }

core/src/io/anuke/mindustry/entities/TileEntity.java

@@ -40,9 +40,11 @@ public class TileEntity extends BaseEntity implements TargetTrait, HealthTrait{
     private static final ObjectSet<Tile> tmpTiles = new ObjectSet<>();
     /**This value is only used for debugging.*/
     public static int sleepingEntities = 0;
+
     public Tile tile;
     public Timer timer;
     public float health;
+    public float timeScale = 1f, timeScaleDuration;
 
     public PowerModule power;
     public InventoryModule items;
@@ -85,6 +87,11 @@ public class TileEntity extends BaseEntity implements TargetTrait, HealthTrait{
         return this;
     }
 
+    /**Scaled delta.*/
+    public float delta(){
+        return Timers.delta() * timeScale;
+    }
+
     /**Call when nothing is happening to the entity. This increments the internal sleep timer.*/
     public void sleep(){
         sleepTime += Timers.delta();
@@ -252,6 +259,11 @@ public class TileEntity extends BaseEntity implements TargetTrait, HealthTrait{
                 Effects.effect(Fx.smoke, x + Mathf.range(4), y + Mathf.range(4));
             }
 
+            timeScaleDuration -= Timers.delta();
+            if(timeScaleDuration <= 0f){
+                timeScale = 1f;
+            }
+
             if(health <= 0){
                 onDeath();
             }

core/src/io/anuke/mindustry/world/blocks/defense/OverdriveProjector.java

@@ -2,28 +2,35 @@ package io.anuke.mindustry.world.blocks.defense;
 
 import com.badlogic.gdx.graphics.Color;
 import com.badlogic.gdx.graphics.g2d.TextureRegion;
-import io.anuke.mindustry.content.StatusEffects;
+import com.badlogic.gdx.math.Vector2;
+import com.badlogic.gdx.utils.IntSet;
+import io.anuke.mindustry.content.fx.BlockFx;
 import io.anuke.mindustry.entities.TileEntity;
-import io.anuke.mindustry.entities.Units;
 import io.anuke.mindustry.world.Block;
 import io.anuke.mindustry.world.Tile;
+import io.anuke.ucore.core.Effects;
 import io.anuke.ucore.core.Graphics;
 import io.anuke.ucore.core.Timers;
 import io.anuke.ucore.graphics.Draw;
+import io.anuke.ucore.graphics.Hue;
 import io.anuke.ucore.graphics.Lines;
 import io.anuke.ucore.util.Mathf;
 
+import static io.anuke.mindustry.Vars.tilesize;
+import static io.anuke.mindustry.Vars.world;
+
 public class OverdriveProjector extends Block{
     private static Color color = Color.valueOf("feb380");
     private static Color phase = Color.valueOf("ffd59e");
+    private static IntSet healed = new IntSet();
 
     protected int timerUse = timers ++;
-    protected int timerApply = timers ++;
 
     protected TextureRegion topRegion;
-    protected float reload = 60f;
+    protected float reload = 250f;
-    protected float range = 100f;
+    protected float range = 80f;
-    protected float phaseBoost = 30f;
+    protected float speedBoost = 2f;
+    protected float speedBoostPhase = 0.5f;
     protected float useTime = 300f;
 
     public OverdriveProjector(String name){
@@ -44,28 +51,51 @@ public class OverdriveProjector extends Block{
     @Override
     public void update(Tile tile){
         OverdriveEntity entity = tile.entity();
-
         entity.heat = Mathf.lerpDelta(entity.heat, entity.cons.valid() ? 1f : 0f, 0.08f);
+        entity.charge += entity.heat * Timers.delta();
+
         entity.phaseHeat = Mathf.lerpDelta(entity.phaseHeat, (float)entity.items.get(consumes.item()) / itemCapacity, 0.1f);
 
         if(entity.timer.get(timerUse, useTime) && entity.items.total() > 0){
             entity.items.remove(consumes.item(), 1);
         }
 
-        if(entity.heat > 0.5f && entity.timer.get(timerApply, 10)){
+        if(entity.charge >= reload){
-            float realRange = range + entity.phaseHeat * phaseBoost;
+            float realRange = range + entity.phaseHeat * 20f;
+            float realBoost = speedBoost + entity.phaseHeat*speedBoostPhase;
 
-            Units.getNearby(tile.getTeam(), tile.drawx(), tile.drawy(), realRange, unit -> unit.applyEffect(StatusEffects.overdrive, 1f + entity.phaseHeat));
+            Effects.effect(BlockFx.overdriveWave, Hue.mix(color, phase, entity.phaseHeat), tile.drawx(), tile.drawy(), realRange);
+            entity.charge = 0f;
+
+            Timers.run(10f, () -> {
+                int tileRange = (int)(realRange / tilesize);
+                healed.clear();
+
+                for(int x = -tileRange + tile.x; x <= tileRange + tile.x; x++){
+                    for(int y = -tileRange + tile.y; y <= tileRange + tile.y; y++){
+                        if(Vector2.dst(x, y, tile.x, tile.y) > realRange) continue;
+
+                        Tile other = world.tile(x, y);
+
+                        if(other == null) continue;
+                        other = other.target();
+
+                        if(other.getTeamID() == tile.getTeamID() && !healed.contains(other.packedPosition()) && other.entity != null){
+                            other.entity.timeScaleDuration = Math.max(other.entity.timeScaleDuration, reload + 1f);
+                            other.entity.timeScale = Math.max(other.entity.timeScale, realBoost);
+                            Effects.effect(BlockFx.overdriveBlockFull, Hue.mix(color, phase, entity.phaseHeat), other.drawx(), other.drawy(), other.block().size);
+                            healed.add(other.packedPosition());
+                        }
+                    }
+                }
+            });
         }
     }
 
     @Override
     public void drawSelect(Tile tile){
-        OverdriveEntity entity = tile.entity();
-        float realRange = range + entity.phaseHeat * phaseBoost;
-
         Draw.color(color);
-        Lines.poly(tile.drawx(), tile.drawy(), 300, realRange);
+        Lines.dashCircle(tile.drawx(), tile.drawy() - 1f, range);
         Draw.color();
     }
 
@@ -96,6 +126,7 @@ public class OverdriveProjector extends Block{
 
     class OverdriveEntity extends TileEntity{
         float heat;
+        float charge;
         float phaseHeat;
     }
 }

core/src/io/anuke/mindustry/world/blocks/defense/turrets/Turret.java

@@ -213,7 +213,7 @@ public abstract class Turret extends Block{
                 }
 
                 if(shouldTurn(tile)){
-                    entity.rotation = Angles.moveToward(entity.rotation, targetRot, rotatespeed * Timers.delta());
+                    entity.rotation = Angles.moveToward(entity.rotation, targetRot, rotatespeed * entity.delta());
                 }
 
                 if(Angles.angleDist(entity.rotation, targetRot) < shootCone){
@@ -278,7 +278,7 @@ public abstract class Turret extends Block{
 
             entity.reload = 0f;
         }else{
-            entity.reload += Timers.delta() * peekAmmo(tile).reloadMultiplier;
+            entity.reload += tile.entity.delta() * peekAmmo(tile).reloadMultiplier;
         }
     }
 

core/src/io/anuke/mindustry/world/blocks/distribution/Conveyor.java

@@ -204,7 +204,7 @@ public class Conveyor extends Block{
         entity.carrying += unit.getMass();
 
         if(entity.convey.size * itemSpace < 0.9f){
-            unit.getVelocity().add((tx * speed + centerx) * Timers.delta(), (ty * speed + centery) * Timers.delta());
+            unit.getVelocity().add((tx * speed + centerx) * entity.delta(), (ty * speed + centery) * entity.delta());
         }
     }
 
@@ -231,7 +231,7 @@ public class Conveyor extends Block{
             if(entity.minCarry >= pos.y && entity.minCarry <= nextpos){
                 nextpos = entity.minCarry;
             }
-            float maxmove = Math.min(nextpos - pos.y, speed * Timers.delta());
+            float maxmove = Math.min(nextpos - pos.y, speed * entity.delta());
 
             if(maxmove > minmove){
                 pos.y += maxmove;

core/src/io/anuke/mindustry/world/blocks/distribution/ItemBridge.java

@@ -152,8 +152,8 @@ public class ItemBridge extends Block{
     public void update(Tile tile){
         ItemBridgeEntity entity = tile.entity();
 
-        entity.time += entity.cycleSpeed * Timers.delta();
+        entity.time += entity.cycleSpeed * entity.delta();
-        entity.time2 += (entity.cycleSpeed - 1f) * Timers.delta();
+        entity.time2 += (entity.cycleSpeed - 1f) * entity.delta();
 
         removals.clear();
 

core/src/io/anuke/mindustry/world/blocks/distribution/MassDriver.java

@@ -146,7 +146,7 @@ public class MassDriver extends Block{
         }
 
         if(entity.reload > 0f){
-            entity.reload = Mathf.clamp(entity.reload - Timers.delta() / reloadTime);
+            entity.reload = Mathf.clamp(entity.reload - entity.delta() / reloadTime);
         }
 
         if(!entity.isRecieving){

core/src/io/anuke/mindustry/world/blocks/power/ItemGenerator.java

@@ -84,15 +84,15 @@ public abstract class ItemGenerator extends PowerGenerator{
     public void update(Tile tile){
         ItemGeneratorEntity entity = tile.entity();
 
-        float maxPower = Math.min(powerCapacity - entity.power.amount, powerOutput * Timers.delta()) * entity.efficiency;
+        float maxPower = Math.min(powerCapacity - entity.power.amount, powerOutput * entity.delta()) * entity.efficiency;
         float mfract = maxPower / (powerOutput);
 
         if(entity.generateTime > 0f){
-            entity.generateTime -= 1f / itemDuration * mfract;
+            entity.generateTime -= 1f / itemDuration * mfract * entity.delta();
             entity.power.amount += maxPower;
             entity.generateTime = Mathf.clamp(entity.generateTime);
 
-            if(Mathf.chance(Timers.delta() * 0.06 * Mathf.clamp(entity.explosiveness - 0.25f))){
+            if(Mathf.chance(entity.delta() * 0.06 * Mathf.clamp(entity.explosiveness - 0.25f))){
                 entity.damage(Mathf.random(8f));
                 Effects.effect(explodeEffect, tile.worldx() + Mathf.range(size * tilesize / 2f), tile.worldy() + Mathf.range(size * tilesize / 2f));
             }

core/src/io/anuke/mindustry/world/blocks/power/ItemLiquidGenerator.java

@@ -6,7 +6,6 @@ import io.anuke.mindustry.type.Liquid;
 import io.anuke.mindustry.world.Tile;
 import io.anuke.mindustry.world.consumers.ConsumeLiquidFilter;
 import io.anuke.ucore.core.Effects;
-import io.anuke.ucore.core.Timers;
 import io.anuke.ucore.graphics.Draw;
 import io.anuke.ucore.util.Mathf;
 
@@ -44,26 +43,26 @@ public abstract class ItemLiquidGenerator extends ItemGenerator{
         //liquid takes priority over solids
         if(liquid != null && entity.liquids.get(liquid) >= 0.001f && entity.cons.valid()){
             float powerPerLiquid = getLiquidEfficiency(liquid) * this.powerPerLiquid;
-            float used = Math.min(entity.liquids.get(liquid), maxLiquidGenerate * Timers.delta());
+            float used = Math.min(entity.liquids.get(liquid), maxLiquidGenerate * entity.delta());
             used = Math.min(used, (powerCapacity - entity.power.amount) / powerPerLiquid);
 
             entity.liquids.remove(liquid, used);
             entity.power.amount += used * powerPerLiquid;
 
-            if(used > 0.001f && Mathf.chance(0.05 * Timers.delta())){
+            if(used > 0.001f && Mathf.chance(0.05 * entity.delta())){
                 Effects.effect(generateEffect, tile.drawx() + Mathf.range(3f), tile.drawy() + Mathf.range(3f));
             }
         }else if(entity.cons.valid()){
 
-            float maxPower = Math.min(powerCapacity - entity.power.amount, powerOutput * Timers.delta()) * entity.efficiency;
+            float maxPower = Math.min(powerCapacity - entity.power.amount, powerOutput * entity.delta()) * entity.efficiency;
             float mfract = maxPower / (powerOutput);
 
             if(entity.generateTime > 0f){
-                entity.generateTime -= 1f / itemDuration * mfract;
+                entity.generateTime -= 1f / itemDuration * mfract * entity.delta();
                 entity.power.amount += maxPower;
                 entity.generateTime = Mathf.clamp(entity.generateTime);
 
-                if(Mathf.chance(Timers.delta() * 0.06 * Mathf.clamp(entity.explosiveness - 0.25f))){
+                if(Mathf.chance(entity.delta() * 0.06 * Mathf.clamp(entity.explosiveness - 0.25f))){
                     entity.damage(Mathf.random(8f));
                     Effects.effect(explodeEffect, tile.worldx() + Mathf.range(size * tilesize / 2f), tile.worldy() + Mathf.range(size * tilesize / 2f));
                 }

core/src/io/anuke/mindustry/world/blocks/power/LiquidGenerator.java

@@ -8,7 +8,6 @@ import io.anuke.mindustry.world.blocks.power.ItemGenerator.ItemGeneratorEntity;
 import io.anuke.mindustry.world.consumers.ConsumeLiquidFilter;
 import io.anuke.ucore.core.Effects;
 import io.anuke.ucore.core.Effects.Effect;
-import io.anuke.ucore.core.Timers;
 import io.anuke.ucore.graphics.Draw;
 import io.anuke.ucore.util.Mathf;
 
@@ -51,13 +50,13 @@ public abstract class LiquidGenerator extends PowerGenerator{
 
         if(entity.liquids.get(entity.liquids.current()) >= 0.001f){
             float powerPerLiquid = getEfficiency(entity.liquids.current()) * this.powerPerLiquid;
-            float used = Math.min(entity.liquids.currentAmount(), maxLiquidGenerate * Timers.delta());
+            float used = Math.min(entity.liquids.currentAmount(), maxLiquidGenerate * entity.delta());
             used = Math.min(used, (powerCapacity - entity.power.amount) / powerPerLiquid);
 
             entity.liquids.remove(entity.liquids.current(), used);
             entity.power.amount += used * powerPerLiquid;
 
-            if(used > 0.001f && Mathf.chance(0.05 * Timers.delta())){
+            if(used > 0.001f && Mathf.chance(0.05 * entity.delta())){
                 Effects.effect(generateEffect, tile.drawx() + Mathf.range(3f), tile.drawy() + Mathf.range(3f));
             }
         }

core/src/io/anuke/mindustry/world/blocks/power/NuclearReactor.java

@@ -87,8 +87,8 @@ public class NuclearReactor extends PowerGenerator{
         float fullness = (float) fuel / itemCapacity;
 
         if(fuel > 0){
-            entity.heat += fullness * heating * Math.min(Timers.delta(), 4f);
+            entity.heat += fullness * heating * Math.min(entity.delta(), 4f);
-            entity.power.amount += powerMultiplier * fullness * Timers.delta();
+            entity.power.amount += powerMultiplier * fullness * entity.delta();
             entity.power.amount = Mathf.clamp(entity.power.amount, 0f, powerCapacity);
             if(entity.timer.get(timerFuel, fuelUseTime)){
                 entity.items.remove(consumes.item(), 1);
@@ -100,12 +100,12 @@ public class NuclearReactor extends PowerGenerator{
 
             if(liquid.temperature <= 0.5f){ //is coolant
                 float pow = coolantPower * (liquid.heatCapacity + 0.5f / liquid.temperature); //heat depleted per unit of liquid
-                float maxUsed = Math.min(Math.min(entity.liquids.get(liquid), entity.heat / pow), maxLiquidUse * Timers.delta()); //max that can be cooled in terms of liquid
+                float maxUsed = Math.min(Math.min(entity.liquids.get(liquid), entity.heat / pow), maxLiquidUse * entity.delta()); //max that can be cooled in terms of liquid
                 entity.heat -= maxUsed * pow;
                 entity.liquids.remove(liquid, maxUsed);
             }else{ //is heater
                 float heat = coolantPower * liquid.heatCapacity / 4f; //heat created per unit of liquid
-                float maxUsed = Math.min(Math.min(entity.liquids.get(liquid), (1f - entity.heat) / heat), maxLiquidUse * Timers.delta()); //max liquid used
+                float maxUsed = Math.min(Math.min(entity.liquids.get(liquid), (1f - entity.heat) / heat), maxLiquidUse * entity.delta()); //max liquid used
                 entity.heat += maxUsed * heat;
                 entity.liquids.remove(liquid, maxUsed);
             }
@@ -113,7 +113,7 @@ public class NuclearReactor extends PowerGenerator{
 
         if(entity.heat > smokeThreshold){
             float smoke = 1.0f + (entity.heat - smokeThreshold) / (1f - smokeThreshold); //ranges from 1.0 to 2.0
-            if(Mathf.chance(smoke / 20.0 * Timers.delta())){
+            if(Mathf.chance(smoke / 20.0 * entity.delta())){
                 Effects.effect(BlockFx.reactorsmoke, tile.worldx() + Mathf.range(size * tilesize / 2f),
                         tile.worldy() + Mathf.random(size * tilesize / 2f));
             }

core/src/io/anuke/mindustry/world/blocks/production/Drill.java

@@ -175,7 +175,7 @@ public class Drill extends Block{
             tryDump(tile);
         }
 
-        entity.drillTime += entity.warmup * Timers.delta();
+        entity.drillTime += entity.warmup * entity.delta();
 
         if(entity.items.total() < itemCapacity && entity.dominantItems > 0 && entity.cons.valid()){
 
@@ -186,7 +186,8 @@ public class Drill extends Block{
             }
 
             entity.warmup = Mathf.lerpDelta(entity.warmup, speed, warmupSpeed);
-            entity.progress += Timers.delta() * entity.dominantItems * speed * entity.warmup;
+            entity.progress += entity.delta()
+            * entity.dominantItems * speed * entity.warmup;
 
             if(Mathf.chance(Timers.delta() * updateEffectChance * entity.warmup))
                 Effects.effect(updateEffect, entity.x + Mathf.range(size * 2f), entity.y + Mathf.range(size * 2f));

core/src/io/anuke/mindustry/world/blocks/production/GenericCrafter.java

@@ -83,9 +83,9 @@ public class GenericCrafter extends Block{
 
         if(entity.cons.valid() && tile.entity.items.get(output) < itemCapacity){
 
-            entity.progress += 1f / craftTime * Timers.delta();
+            entity.progress += 1f / craftTime * entity.delta();
-            entity.totalProgress += Timers.delta();
+            entity.totalProgress += entity.delta();
-            entity.warmup = Mathf.lerp(entity.warmup, 1f, 0.02f);
+            entity.warmup = Mathf.lerpDelta(entity.warmup, 1f, 0.02f);
 
             if(Mathf.chance(Timers.delta() * updateEffectChance))
                 Effects.effect(updateEffect, entity.x + Mathf.range(size * 4f), entity.y + Mathf.range(size * 4));

core/src/io/anuke/mindustry/world/blocks/production/LiquidMixer.java

@@ -57,7 +57,7 @@ public class LiquidMixer extends LiquidBlock{
         LiquidMixerEntity entity = tile.entity();
 
         if(tile.entity.cons.valid()){
-            float use = Math.min(consumes.get(ConsumeLiquid.class).used() * Timers.delta(), liquidCapacity - entity.liquids.get(outputLiquid));
+            float use = Math.min(consumes.get(ConsumeLiquid.class).used() * entity.delta(), liquidCapacity - entity.liquids.get(outputLiquid));
             entity.accumulator += use;
             entity.liquids.add(outputLiquid, use);
             for(int i = 0; i < (int) (entity.accumulator / liquidPerItem); i++){

core/src/io/anuke/mindustry/world/blocks/production/PowerCrafter.java

@@ -7,7 +7,6 @@ import io.anuke.mindustry.world.Block;
 import io.anuke.mindustry.world.Tile;
 import io.anuke.mindustry.world.blocks.production.GenericCrafter.GenericCrafterEntity;
 import io.anuke.mindustry.world.meta.BlockStat;
-import io.anuke.ucore.core.Timers;
 
 public class PowerCrafter extends Block{
     protected final int timerDump = timers++;
@@ -66,7 +65,7 @@ public class PowerCrafter extends Block{
 
         if(entity.cons.valid()){
             entity.progress += 1f / craftTime;
-            entity.totalProgress += Timers.delta();
+            entity.totalProgress += entity.delta();
         }
 
         if(entity.progress >= 1f){

core/src/io/anuke/mindustry/world/blocks/production/PowerSmelter.java

@@ -100,7 +100,7 @@ public class PowerSmelter extends PowerBlock{
 
         //heat it up if there's enough power
         if(entity.cons.valid()){
-            entity.heat += 1f / heatUpTime * Timers.delta();
+            entity.heat += 1f / heatUpTime * entity.delta();
             if(Mathf.chance(Timers.delta() * burnEffectChance))
                 Effects.effect(burnEffect, entity.x + Mathf.range(size * 4f), entity.y + Mathf.range(size * 4));
         }else{
@@ -108,7 +108,7 @@ public class PowerSmelter extends PowerBlock{
         }
 
         entity.heat = Mathf.clamp(entity.heat);
-        entity.time += entity.heat * Timers.delta();
+        entity.time += entity.heat * entity.delta();
 
         if(!entity.cons.valid()){
             return;
@@ -124,10 +124,12 @@ public class PowerSmelter extends PowerBlock{
 
         if(entity.items.get(result) >= itemCapacity //output full
                 || entity.heat <= minHeat //not burning
-                || !entity.timer.get(timerCraft, craftTime*baseSmeltSpeed)){ //not yet time
+                || entity.craftTime < craftTime*baseSmeltSpeed){ //not yet time
             return;
         }
 
+        entity.craftTime = 0f;
+
         boolean consumeInputs = true;
 
         if(useFlux){
@@ -206,6 +208,7 @@ public class PowerSmelter extends PowerBlock{
     class PowerSmelterEntity extends TileEntity{
         public float heat;
         public float time;
+        public float craftTime;
 
         @Override
         public void write(DataOutputStream stream) throws IOException{

core/src/io/anuke/mindustry/world/blocks/production/Pump.java

@@ -9,7 +9,6 @@ import io.anuke.mindustry.world.blocks.LiquidBlock;
 import io.anuke.mindustry.world.meta.BlockGroup;
 import io.anuke.mindustry.world.meta.BlockStat;
 import io.anuke.mindustry.world.meta.StatUnit;
-import io.anuke.ucore.core.Timers;
 import io.anuke.ucore.graphics.Draw;
 
 public class Pump extends LiquidBlock{
@@ -95,7 +94,7 @@ public class Pump extends LiquidBlock{
         }
 
         if(tile.entity.cons.valid() && liquidDrop != null){
-            float maxPump = Math.min(liquidCapacity - tile.entity.liquids.total(), tiles * pumpAmount * Timers.delta());
+            float maxPump = Math.min(liquidCapacity - tile.entity.liquids.total(), tiles * pumpAmount * tile.entity.delta());
             tile.entity.liquids.add(liquidDrop, maxPump);
         }
 

core/src/io/anuke/mindustry/world/blocks/production/Separator.java

@@ -12,7 +12,6 @@ import io.anuke.mindustry.world.Tile;
 import io.anuke.mindustry.world.blocks.production.GenericCrafter.GenericCrafterEntity;
 import io.anuke.mindustry.world.meta.BlockStat;
 import io.anuke.mindustry.world.meta.values.ItemFilterValue;
-import io.anuke.ucore.core.Timers;
 import io.anuke.ucore.graphics.Draw;
 import io.anuke.ucore.graphics.Lines;
 import io.anuke.ucore.util.Mathf;
@@ -85,10 +84,10 @@ public class Separator extends Block{
     public void update(Tile tile){
         GenericCrafterEntity entity = tile.entity();
 
-        entity.totalProgress += entity.warmup * Timers.delta();
+        entity.totalProgress += entity.warmup * entity.delta();
 
         if(entity.cons.valid()){
-            entity.progress += 1f / filterTime;
+            entity.progress += 1f / filterTime*entity.delta();
             entity.warmup = Mathf.lerpDelta(entity.warmup, 1f, 0.02f);
         }else{
             entity.warmup = Mathf.lerpDelta(entity.warmup, 0f, 0.02f);

core/src/io/anuke/mindustry/world/blocks/production/Smelter.java

@@ -24,7 +24,6 @@ import static io.anuke.mindustry.Vars.*;
 
 public class Smelter extends Block{
     protected final int timerDump = timers++;
-    protected final int timerCraft = timers++;
 
     protected Item result;
 
@@ -99,10 +98,10 @@ public class Smelter extends Block{
 
         //decrement burntime
         if(entity.burnTime > 0){
-            entity.burnTime -= Timers.delta();
+            entity.burnTime -= entity.delta();
-            entity.heat = Mathf.lerp(entity.heat, 1f, 0.02f);
+            entity.heat = Mathf.lerpDelta(entity.heat, 1f, 0.02f);
         }else{
-            entity.heat = Mathf.lerp(entity.heat, 0f, 0.02f);
+            entity.heat = Mathf.lerpDelta(entity.heat, 0f, 0.02f);
         }
 
         //make sure it has all the items
@@ -118,12 +117,16 @@ public class Smelter extends Block{
             }
         }
 
+        entity.craftTime += entity.delta();
+
         if(entity.items.get(result) >= itemCapacity //output full
                 || entity.burnTime <= 0 //not burning
-                || !entity.timer.get(timerCraft, craftTime*baseSmeltSpeed)){ //not yet time
+                || entity.craftTime < craftTime*baseSmeltSpeed){ //not yet time
             return;
         }
 
+        entity.craftTime = 0f;
+
         boolean consumeInputs = true;
 
         if(useFlux){
@@ -198,5 +201,6 @@ public class Smelter extends Block{
     public class SmelterEntity extends TileEntity{
         public float burnTime;
         public float heat;
+        public float craftTime;
     }
 }

core/src/io/anuke/mindustry/world/blocks/production/SolidPump.java

@@ -77,7 +77,7 @@ public class SolidPump extends Pump{
         }
 
         if(tile.entity.cons.valid() && typeLiquid(tile) < liquidCapacity - 0.001f){
-            float maxPump = Math.min(liquidCapacity - typeLiquid(tile), pumpAmount * Timers.delta() * fraction);
+            float maxPump = Math.min(liquidCapacity - typeLiquid(tile), pumpAmount * entity.delta() * fraction);
             tile.entity.liquids.add(result, maxPump);
             entity.warmup = Mathf.lerpDelta(entity.warmup, 1f, 0.02f);
             if(Mathf.chance(Timers.delta() * updateEffectChance))

core/src/io/anuke/mindustry/world/blocks/storage/CoreBlock.java

@@ -197,8 +197,8 @@ public class CoreBlock extends StorageBlock{
                 return;
             }
             entity.heat = Mathf.lerpDelta(entity.heat, 1f, 0.1f);
-            entity.time += Timers.delta();
+            entity.time += entity.delta();
-            entity.progress += 1f / (entity.currentUnit instanceof Player ? state.mode.respawnTime : droneRespawnDuration) * Timers.delta();
+            entity.progress += 1f / (entity.currentUnit instanceof Player ? state.mode.respawnTime : droneRespawnDuration) * entity.delta();
 
             //instant build for fast testing.
             if(debug){

core/src/io/anuke/mindustry/world/blocks/units/MechFactory.java

@@ -187,9 +187,9 @@ public class MechFactory extends Block{
 
         if(entity.player != null){
             entity.heat = Mathf.lerpDelta(entity.heat, 1f, 0.1f);
-            entity.progress += 1f / buildTime;
+            entity.progress += 1f / buildTime * entity.delta();
 
-            entity.time += 0.5f;
+            entity.time += 0.5f * entity.delta();
 
             if(entity.progress >= 1f){
                 Call.onMechFactoryDone(tile);

core/src/io/anuke/mindustry/world/blocks/units/UnitPad.java

@@ -147,10 +147,10 @@ public class UnitPad extends Block{
     public void update(Tile tile){
         UnitFactoryEntity entity = tile.entity();
 
-        entity.time += Timers.delta() * entity.speedScl;
+        entity.time += entity.delta() * entity.speedScl;
 
         if(tile.isEnemyCheat()){
-            entity.warmup += Timers.delta();
+            entity.warmup += entity.delta();
         }
 
         if(!tile.isEnemyCheat()){
@@ -158,7 +158,7 @@ public class UnitPad extends Block{
 
             if(hasRequirements(entity.items, entity.buildTime / produceTime) && entity.cons.valid()){
 
-                entity.buildTime += Timers.delta();
+                entity.buildTime += entity.delta();
                 entity.speedScl = Mathf.lerpDelta(entity.speedScl, 1f, 0.05f);
             }else{
                 entity.speedScl = Mathf.lerpDelta(entity.speedScl, 0f, 0.05f);
@@ -167,7 +167,7 @@ public class UnitPad extends Block{
         }else if(entity.warmup > produceTime*gracePeriodMultiplier * Vars.state.difficulty.spawnerScaling){
             float speedMultiplier = Math.min(0.1f + (entity.warmup - produceTime * gracePeriodMultiplier * Vars.state.difficulty.spawnerScaling) / speedupTime, maxSpeedup);
             //otherwise, it's an enemy, cheat by not requiring resources
-            entity.buildTime += Timers.delta() * speedMultiplier;
+            entity.buildTime += entity.delta() * speedMultiplier;
             entity.speedScl = Mathf.lerpDelta(entity.speedScl, 1f, 0.05f);
         }else{
             entity.speedScl = Mathf.lerpDelta(entity.speedScl, 0f, 0.05f);

core/src/io/anuke/mindustry/world/consumers/ConsumeLiquid.java

@@ -6,7 +6,6 @@ import io.anuke.mindustry.world.Block;
 import io.anuke.mindustry.world.meta.BlockStat;
 import io.anuke.mindustry.world.meta.BlockStats;
 import io.anuke.mindustry.world.meta.StatUnit;
-import io.anuke.ucore.core.Timers;
 import io.anuke.ucore.scene.ui.layout.Table;
 
 public class ConsumeLiquid extends Consume{
@@ -38,12 +37,12 @@ public class ConsumeLiquid extends Consume{
 
     @Override
     public void update(Block block, TileEntity entity){
-        entity.liquids.remove(liquid, Math.min(use(block), entity.liquids.get(liquid)));
+        entity.liquids.remove(liquid, Math.min(use(block, entity), entity.liquids.get(liquid)));
     }
 
     @Override
     public boolean valid(Block block, TileEntity entity){
-        return entity != null && entity.liquids != null && entity.liquids.get(liquid) >= use(block);
+        return entity != null && entity.liquids != null && entity.liquids.get(liquid) >= use(block, entity);
     }
 
     @Override
@@ -52,7 +51,7 @@ public class ConsumeLiquid extends Consume{
         stats.add(BlockStat.inputLiquid, liquid);
     }
 
-    float use(Block block){
+    float use(Block block, TileEntity entity){
-        return Math.min(use * Timers.delta(), block.liquidCapacity);
+        return Math.min(use * entity.delta(), block.liquidCapacity);
     }
 }

core/src/io/anuke/mindustry/world/consumers/ConsumeLiquidFilter.java

@@ -8,10 +8,10 @@ import io.anuke.mindustry.world.meta.BlockStat;
 import io.anuke.mindustry.world.meta.BlockStats;
 import io.anuke.mindustry.world.meta.StatUnit;
 import io.anuke.mindustry.world.meta.values.LiquidFilterValue;
-import io.anuke.ucore.core.Timers;
 import io.anuke.ucore.function.Predicate;
 import io.anuke.ucore.scene.ui.layout.Table;
-import static io.anuke.mindustry.Vars.*;
+
+import static io.anuke.mindustry.Vars.content;
 
 public class ConsumeLiquidFilter extends Consume{
     private final Predicate<Liquid> filter;
@@ -52,12 +52,12 @@ public class ConsumeLiquidFilter extends Consume{
 
     @Override
     public void update(Block block, TileEntity entity){
-        entity.liquids.remove(entity.liquids.current(), use(block));
+        entity.liquids.remove(entity.liquids.current(), use(block, entity));
     }
 
     @Override
     public boolean valid(Block block, TileEntity entity){
-        return entity.liquids != null && filter.test(entity.liquids.current()) && entity.liquids.currentAmount() >= use(block);
+        return entity.liquids != null && filter.test(entity.liquids.current()) && entity.liquids.currentAmount() >= use(block, entity);
     }
 
     @Override
@@ -71,7 +71,7 @@ public class ConsumeLiquidFilter extends Consume{
         }
     }
 
-    float use(Block block){
+    float use(Block block, TileEntity entity){
-        return Math.min(use * Timers.delta(), block.liquidCapacity);
+        return Math.min(use * entity.delta(), block.liquidCapacity);
     }
 }

core/src/io/anuke/mindustry/world/consumers/ConsumePower.java

@@ -5,7 +5,6 @@ import io.anuke.mindustry.world.Block;
 import io.anuke.mindustry.world.meta.BlockStat;
 import io.anuke.mindustry.world.meta.BlockStats;
 import io.anuke.mindustry.world.meta.StatUnit;
-import io.anuke.ucore.core.Timers;
 import io.anuke.ucore.scene.ui.layout.Table;
 
 public class ConsumePower extends Consume{
@@ -28,13 +27,13 @@ public class ConsumePower extends Consume{
     @Override
     public void update(Block block, TileEntity entity){
         if(entity.power == null) return;
-        entity.power.amount -= Math.min(use(block), entity.power.amount);
+        entity.power.amount -= Math.min(use(block, entity), entity.power.amount);
     }
 
     @Override
     public boolean valid(Block block, TileEntity entity){
         if(entity.power == null) return false;
-        return entity.power.amount >= use(block);
+        return entity.power.amount >= use(block, entity);
     }
 
     @Override
@@ -42,7 +41,7 @@ public class ConsumePower extends Consume{
         stats.add(BlockStat.powerUse, use * 60f, StatUnit.powerSecond);
     }
 
-    protected float use(Block block){
+    protected float use(Block block, TileEntity entity){
-        return Math.min(use * Timers.delta(), block.powerCapacity);
+        return Math.min(use * entity.delta(), block.powerCapacity);
     }
 }