From de6bca424f04a55f28f7b5a64bbe03eca9354353 Mon Sep 17 00:00:00 2001
From: Anuken <arnukren@gmail.com>
Date: Sat, 17 Nov 2018 13:04:34 -0500
Subject: [PATCH] Re-added hacky power graph fix

---
 .../world/blocks/power/PowerGraph.java        | 68 +++++++++++++------
 1 file changed, 46 insertions(+), 22 deletions(-)

diff --git a/core/src/io/anuke/mindustry/world/blocks/power/PowerGraph.java b/core/src/io/anuke/mindustry/world/blocks/power/PowerGraph.java
index b0c90960eb..490391b3d6 100644
--- a/core/src/io/anuke/mindustry/world/blocks/power/PowerGraph.java
+++ b/core/src/io/anuke/mindustry/world/blocks/power/PowerGraph.java
@@ -5,7 +5,6 @@ import com.badlogic.gdx.utils.IntSet;
 import com.badlogic.gdx.utils.ObjectSet;
 import com.badlogic.gdx.utils.Queue;
 import io.anuke.mindustry.world.Tile;
-import io.anuke.ucore.core.Timers;
 
 import static io.anuke.mindustry.Vars.threads;
 
@@ -38,38 +37,63 @@ public class PowerGraph{
 
         lastFrameUpdated = threads.getFrameID();
 
-        float totalInput = 0f;
+        boolean charge = false;
 
+        float totalInput = 0f;
+        float bufferInput = 0f;
         for(Tile producer : producers){
-            totalInput += producer.entity.power.amount;
+            if(producer.block().consumesPower){
+                bufferInput += producer.entity.power.amount;
+            }else{
+                totalInput += producer.entity.power.amount;
+            }
         }
 
-        for(Tile producer : producers){
-            float accumulator = producer.entity.power.amount;
-
-            if(accumulator <= 0.0001f) continue;
-
-            float toEach = accumulator / consumers.size;
-            float outputs = 0f;
-
-            for(Tile tile : consumers){
-                outputs += Math.min(tile.block().powerCapacity - tile.entity.power.amount, toEach) / toEach;
+        float maxOutput = 0f;
+        float bufferOutput = 0f;
+        for(Tile consumer : consumers){
+            if(consumer.block().outputsPower){
+                bufferOutput += consumer.block().powerCapacity - consumer.entity.power.amount;
+            }else{
+                maxOutput += consumer.block().powerCapacity - consumer.entity.power.amount;
             }
+        }
 
-            float finalEach = toEach / outputs * Timers.delta();
-            float buffer = 0f;
+        if(maxOutput < totalInput){
+            charge = true;
+        }
 
-            if(Float.isNaN(finalEach) || Float.isInfinite(finalEach)){
+        if(totalInput + bufferInput <= 0.0001f || maxOutput + bufferOutput <= 0.0001f){
+            return;
+        }
+
+        float bufferUsed;
+        if(charge){
+            bufferUsed = Math.min((totalInput - maxOutput) / bufferOutput, 1f);
+        }else{
+            bufferUsed = Math.min((maxOutput - totalInput) / bufferInput, 1f);
+        }
+
+        float inputUsed = charge ? Math.min((maxOutput + bufferOutput) / totalInput, 1f) : 1f;
+        for(Tile producer : producers){
+            if(producer.block().consumesPower){
+                if(!charge){
+                    producer.entity.power.amount -= producer.entity.power.amount * bufferUsed;
+                }
                 continue;
             }
+            producer.entity.power.amount -= producer.entity.power.amount * inputUsed;
+        }
 
-            for(Tile tile : consumers){
-                float used = Math.min(tile.block().powerCapacity - tile.entity.power.amount, finalEach) * accumulator / totalInput;
-                buffer += used;
-                tile.entity.power.amount += used;
+        float outputSatisfied = charge ? 1f : Math.min((totalInput + bufferInput) / maxOutput, 1f);
+        for(Tile consumer : consumers){
+            if(consumer.block().outputsPower){
+                if(charge){
+                    consumer.entity.power.amount += (consumer.block().powerCapacity - consumer.entity.power.amount) * bufferUsed;
+                }
+                continue;
             }
-
-            producer.entity.power.amount -= buffer;
+            consumer.entity.power.amount += (consumer.block().powerCapacity - consumer.entity.power.amount) * outputSatisfied;
         }
     }