Minor cleanup / Tick reset fix
This commit is contained in:
@@ -141,7 +141,6 @@ public class EditorTile extends Tile{
|
||||
|
||||
if(block.hasBuilding()){
|
||||
build = entityprov.get().init(this, team, false, rotation);
|
||||
build.cons = new ConsumeModule(build);
|
||||
if(block.hasItems) build.items = new ItemModule();
|
||||
if(block.hasLiquids) build.liquids(new LiquidModule());
|
||||
if(block.hasPower) build.power(new PowerModule());
|
||||
|
||||
@@ -62,7 +62,6 @@ abstract class BuildingComp implements Posc, Teamc, Healthc, Buildingc, Timerc,
|
||||
transient Tile tile;
|
||||
transient Block block;
|
||||
transient Seq<Building> proximity = new Seq<>(6);
|
||||
transient boolean updateFlow;
|
||||
transient byte cdump;
|
||||
transient int rotation;
|
||||
transient float payloadRotation;
|
||||
@@ -70,15 +69,20 @@ abstract class BuildingComp implements Posc, Teamc, Healthc, Buildingc, Timerc,
|
||||
transient float enabledControlTime;
|
||||
transient String lastAccessed;
|
||||
transient boolean wasDamaged; //used only by the indexer
|
||||
transient float visualLiquid;
|
||||
|
||||
@Nullable PowerModule power;
|
||||
@Nullable ItemModule items;
|
||||
@Nullable LiquidModule liquids;
|
||||
@Nullable ConsumeModule cons;
|
||||
|
||||
/** @deprecated use building methods instead, this is just a proxy! */
|
||||
@Deprecated
|
||||
ConsumeModule cons = new ConsumeModule(self());
|
||||
|
||||
public transient float healSuppressionTime = -1f;
|
||||
public transient float lastHealTime = -120f * 10f;
|
||||
|
||||
private transient boolean consValid, consOptionalValid;
|
||||
private transient float timeScale = 1f, timeScaleDuration;
|
||||
private transient float dumpAccum;
|
||||
|
||||
@@ -127,7 +131,6 @@ abstract class BuildingComp implements Posc, Teamc, Healthc, Buildingc, Timerc,
|
||||
maxHealth(block.health);
|
||||
timer(new Interval(block.timers));
|
||||
|
||||
cons = new ConsumeModule(self());
|
||||
if(block.hasItems) items = new ItemModule();
|
||||
if(block.hasLiquids) liquids = new LiquidModule();
|
||||
if(block.hasPower){
|
||||
@@ -166,7 +169,7 @@ abstract class BuildingComp implements Posc, Teamc, Healthc, Buildingc, Timerc,
|
||||
if(items != null) items.write(write);
|
||||
if(power != null) power.write(write);
|
||||
if(liquids != null) liquids.write(write);
|
||||
if(cons != null) cons.write(write);
|
||||
write.bool(consValid);
|
||||
}
|
||||
|
||||
public final void readBase(Reads read){
|
||||
@@ -200,11 +203,11 @@ abstract class BuildingComp implements Posc, Teamc, Healthc, Buildingc, Timerc,
|
||||
if((moduleBits & 1) != 0) (items == null ? new ItemModule() : items).read(read, legacy);
|
||||
if((moduleBits & 2) != 0) (power == null ? new PowerModule() : power).read(read, legacy);
|
||||
if((moduleBits & 4) != 0) (liquids == null ? new LiquidModule() : liquids).read(read, legacy);
|
||||
if((moduleBits & 8) != 0) (cons == null ? new ConsumeModule(self()) : cons).read(read, legacy);
|
||||
if((moduleBits & 8) != 0) consValid = read.bool();
|
||||
}
|
||||
|
||||
public int moduleBitmask(){
|
||||
return (items != null ? 1 : 0) | (power != null ? 2 : 0) | (liquids != null ? 4 : 0) | (cons != null ? 8 : 0);
|
||||
return (items != null ? 1 : 0) | (power != null ? 2 : 0) | (liquids != null ? 4 : 0) | 8;
|
||||
}
|
||||
|
||||
public void writeAll(Writes write){
|
||||
@@ -435,11 +438,21 @@ abstract class BuildingComp implements Posc, Teamc, Healthc, Buildingc, Timerc,
|
||||
}
|
||||
|
||||
public boolean consValid(){
|
||||
return cons.valid();
|
||||
return consValid && enabled && shouldConsume();
|
||||
}
|
||||
|
||||
public boolean consOptionalValid(){
|
||||
return consValid() && consOptionalValid;
|
||||
}
|
||||
|
||||
public void consume(){
|
||||
cons.trigger();
|
||||
for(Consume cons : block.consumes.all){
|
||||
cons.trigger(self());
|
||||
}
|
||||
}
|
||||
|
||||
public boolean canConsume(){
|
||||
return consValid && enabled;
|
||||
}
|
||||
|
||||
/** Scaled delta. */
|
||||
@@ -483,7 +496,19 @@ abstract class BuildingComp implements Posc, Teamc, Healthc, Buildingc, Timerc,
|
||||
}
|
||||
|
||||
public BlockStatus status(){
|
||||
return cons.status();
|
||||
if(enabledControlTime > 0 && !enabled){
|
||||
return BlockStatus.logicDisable;
|
||||
}
|
||||
|
||||
if(!shouldConsume()){
|
||||
return BlockStatus.noOutput;
|
||||
}
|
||||
|
||||
if(!consValid() || !productionValid()){
|
||||
return BlockStatus.noInput;
|
||||
}
|
||||
|
||||
return BlockStatus.active;
|
||||
}
|
||||
|
||||
/** Call when nothing is happening to the entity. This increments the internal sleep timer. */
|
||||
@@ -1084,7 +1109,9 @@ abstract class BuildingComp implements Posc, Teamc, Healthc, Buildingc, Timerc,
|
||||
|
||||
public void drawLight(){
|
||||
if(block.hasLiquids && block.drawLiquidLight && liquids.current().lightColor.a > 0.001f){
|
||||
drawLiquidLight(liquids.current(), liquids.smoothAmount());
|
||||
//yes, I am updating in draw()... but this is purely visual anyway, better have it here than in update() where it wastes time
|
||||
visualLiquid = Mathf.lerpDelta(visualLiquid, liquids.currentAmount(), 0.07f);
|
||||
drawLiquidLight(liquids.current(), visualLiquid);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1554,6 +1581,37 @@ abstract class BuildingComp implements Posc, Teamc, Healthc, Buildingc, Timerc,
|
||||
}
|
||||
}
|
||||
|
||||
public void updateConsumption(){
|
||||
//everything is valid when cheating
|
||||
if(cheating()){
|
||||
consValid = consOptionalValid = true;
|
||||
return;
|
||||
}
|
||||
|
||||
boolean prevValid = consValid();
|
||||
consValid = true;
|
||||
consOptionalValid = true;
|
||||
boolean docons = shouldConsume() && productionValid();
|
||||
|
||||
for(Consume cons : block.consumes.all){
|
||||
if(cons.isOptional()) continue;
|
||||
|
||||
if(docons && cons.isUpdate() && prevValid && cons.valid(self())){
|
||||
cons.update(self());
|
||||
}
|
||||
|
||||
consValid &= cons.valid(self());
|
||||
}
|
||||
|
||||
for(Consume cons : block.consumes.optionals){
|
||||
if(docons && cons.isUpdate() && prevValid && cons.valid(self())){
|
||||
cons.update(self());
|
||||
}
|
||||
|
||||
consOptionalValid &= cons.valid(self());
|
||||
}
|
||||
}
|
||||
|
||||
public void updateTile(){
|
||||
|
||||
}
|
||||
@@ -1708,7 +1766,7 @@ abstract class BuildingComp implements Posc, Teamc, Healthc, Buildingc, Timerc,
|
||||
afterDestroyed();
|
||||
}
|
||||
|
||||
//TODO awful method and should be benchmarked
|
||||
//TODO atrocious method and should be squished
|
||||
@Final
|
||||
@Override
|
||||
public void update(){
|
||||
@@ -1748,30 +1806,17 @@ abstract class BuildingComp implements Posc, Teamc, Healthc, Buildingc, Timerc,
|
||||
}
|
||||
|
||||
//TODO consume module is not necessary for every building, e.g. conveyors should not have it - perhaps it should be nullable?
|
||||
if(cons != null){
|
||||
cons.update();
|
||||
}
|
||||
updateConsumption();
|
||||
|
||||
//TODO just handle per-block instead
|
||||
if(enabled || !block.noUpdateDisabled){
|
||||
updateTile();
|
||||
}
|
||||
|
||||
//TODO unnecessary updates for everything below
|
||||
if(items != null){
|
||||
items.update(updateFlow);
|
||||
}
|
||||
|
||||
if(liquids != null){
|
||||
liquids.update(updateFlow);
|
||||
}
|
||||
|
||||
//TODO power graph should be separate entity
|
||||
if(power != null){
|
||||
power.graph.update();
|
||||
}
|
||||
|
||||
updateFlow = false;
|
||||
}
|
||||
|
||||
@Override
|
||||
|
||||
@@ -75,7 +75,8 @@ public abstract class LegacySaveVersion extends LegacyRegionSaveVersion{
|
||||
if(tile.build.items != null) tile.build.items.read(Reads.get(stream), true);
|
||||
if(tile.build.power != null) tile.build.power.read(Reads.get(stream), true);
|
||||
if(tile.build.liquids != null) tile.build.liquids.read(Reads.get(stream), true);
|
||||
if(tile.build.cons != null) tile.build.cons.read(Reads.get(stream), true);
|
||||
//skip cons.valid boolean, it's not very important here
|
||||
stream.readByte();
|
||||
|
||||
//read only from subclasses!
|
||||
tile.build.read(Reads.get(in), version);
|
||||
|
||||
@@ -37,10 +37,11 @@ public class PlacementFragment extends Fragment{
|
||||
boolean[] categoryEmpty = new boolean[Category.all.length];
|
||||
ObjectMap<Category,Block> selectedBlocks = new ObjectMap<>();
|
||||
ObjectFloatMap<Category> scrollPositions = new ObjectFloatMap<>();
|
||||
Block menuHoverBlock;
|
||||
Displayable hover;
|
||||
Object lastDisplayState;
|
||||
Team lastTeam;
|
||||
@Nullable Block menuHoverBlock;
|
||||
@Nullable Displayable hover;
|
||||
@Nullable Building lastFlowBuild, nextFlowBuild;
|
||||
@Nullable Object lastDisplayState;
|
||||
@Nullable Team lastTeam;
|
||||
boolean wasHovered;
|
||||
Table blockTable, toggler, topTable, blockCatTable, commandTable;
|
||||
Stack mainStack;
|
||||
@@ -83,6 +84,21 @@ public class PlacementFragment extends Fragment{
|
||||
Events.on(ResetEvent.class, event -> {
|
||||
selectedBlocks.clear();
|
||||
});
|
||||
|
||||
Events.run(Trigger.update, () -> {
|
||||
//disable flow updating on previous building so it doesn't waste CPU
|
||||
if(lastFlowBuild != null && lastFlowBuild != nextFlowBuild){
|
||||
if(lastFlowBuild.items != null) lastFlowBuild.flowItems().stopFlow();
|
||||
if(lastFlowBuild.liquids != null) lastFlowBuild.liquids.stopFlow();
|
||||
}
|
||||
|
||||
lastFlowBuild = nextFlowBuild;
|
||||
|
||||
if(nextFlowBuild != null){
|
||||
if(nextFlowBuild.items != null) nextFlowBuild.flowItems().updateFlow();
|
||||
if(nextFlowBuild.liquids != null) nextFlowBuild.liquids.updateFlow();
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
public Displayable hover(){
|
||||
@@ -549,8 +565,7 @@ public class PlacementFragment extends Fragment{
|
||||
if(hoverTile != null){
|
||||
//if the tile has a building, display it
|
||||
if(hoverTile.build != null && hoverTile.build.displayable()){
|
||||
hoverTile.build.updateFlow = true;
|
||||
return hoverTile.build;
|
||||
return nextFlowBuild = hoverTile.build;
|
||||
}
|
||||
|
||||
//if the tile has a drop, display the drop
|
||||
|
||||
@@ -28,9 +28,8 @@ public class CachedTile extends Tile{
|
||||
|
||||
if(block.hasBuilding()){
|
||||
Building n = entityprov.get();
|
||||
n.cons(new ConsumeModule(build));
|
||||
n.tile(this);
|
||||
n.block(block);
|
||||
n.block = block;
|
||||
if(block.hasItems) n.items = new ItemModule();
|
||||
if(block.hasLiquids) n.liquids(new LiquidModule());
|
||||
if(block.hasPower) n.power(new PowerModule());
|
||||
|
||||
@@ -82,9 +82,9 @@ public class MendProjector extends Block{
|
||||
heat = Mathf.lerpDelta(heat, consValid() && canHeal ? 1f : 0f, 0.08f);
|
||||
charge += heat * delta();
|
||||
|
||||
phaseHeat = Mathf.lerpDelta(phaseHeat, Mathf.num(cons.optionalValid()), 0.1f);
|
||||
phaseHeat = Mathf.lerpDelta(phaseHeat, Mathf.num(consOptionalValid()), 0.1f);
|
||||
|
||||
if(cons.optionalValid() && timer(timerUse, useTime) && efficiency() > 0 && canHeal){
|
||||
if(consOptionalValid() && timer(timerUse, useTime) && efficiency() > 0 && canHeal){
|
||||
consume();
|
||||
}
|
||||
|
||||
|
||||
@@ -102,7 +102,7 @@ public class OverdriveProjector extends Block{
|
||||
charge += heat * Time.delta;
|
||||
|
||||
if(hasBoost){
|
||||
phaseHeat = Mathf.lerpDelta(phaseHeat, Mathf.num(cons.optionalValid()), 0.1f);
|
||||
phaseHeat = Mathf.lerpDelta(phaseHeat, Mathf.num(consOptionalValid()), 0.1f);
|
||||
}
|
||||
|
||||
if(charge >= reload){
|
||||
|
||||
@@ -122,12 +122,12 @@ public class RegenProjector extends Block{
|
||||
}
|
||||
|
||||
if(consValid()){
|
||||
if(cons.optionalValid() && (optionalTimer += Time.delta) >= optionalUseTime){
|
||||
cons.trigger();
|
||||
if(consOptionalValid() && (optionalTimer += Time.delta) >= optionalUseTime){
|
||||
consume();
|
||||
optionalUseTime = 0f;
|
||||
}
|
||||
|
||||
float healAmount = (cons.optionalValid() ? optionalMultiplier : 1f) * healPercent;
|
||||
float healAmount = (consOptionalValid() ? optionalMultiplier : 1f) * healPercent;
|
||||
|
||||
//use Math.max to prevent stacking
|
||||
for(var build : targets){
|
||||
|
||||
@@ -48,7 +48,7 @@ public class ContinuousTurret extends Turret{
|
||||
@Override
|
||||
public boolean hasAmmo(){
|
||||
//TODO update ammo in unit so it corresponds to liquids
|
||||
return cons.canConsume();
|
||||
return canConsume();
|
||||
}
|
||||
|
||||
@Override
|
||||
@@ -109,7 +109,7 @@ public class ContinuousTurret extends Turret{
|
||||
return;
|
||||
}
|
||||
|
||||
if(cons.canConsume() && !charging && shootWarmup >= minWarmup){
|
||||
if(canConsume() && !charging && shootWarmup >= minWarmup){
|
||||
shoot(peekAmmo());
|
||||
}
|
||||
}
|
||||
|
||||
@@ -337,7 +337,7 @@ public class Turret extends ReloadTurret{
|
||||
public void updateTile(){
|
||||
if(!validateTarget()) target = null;
|
||||
|
||||
float warmupTarget = isShooting() && cons.canConsume() ? 1f : 0f;
|
||||
float warmupTarget = isShooting() && canConsume() ? 1f : 0f;
|
||||
if(linearWarmup){
|
||||
shootWarmup = Mathf.approachDelta(shootWarmup, warmupTarget, shootWarmupSpeed);
|
||||
}else{
|
||||
@@ -474,7 +474,7 @@ public class Turret extends ReloadTurret{
|
||||
/** @return whether the turret has ammo. */
|
||||
public boolean hasAmmo(){
|
||||
//used for "side-ammo" like gas in some turrets
|
||||
if(!cons.canConsume()) return false;
|
||||
if(!canConsume()) return false;
|
||||
|
||||
//skip first entry if it has less than the required amount of ammo
|
||||
if(ammo.size >= 2 && ammo.peek().amount < ammoPerShot && ammo.get(ammo.size - 2).amount >= ammoPerShot){
|
||||
|
||||
@@ -56,7 +56,7 @@ public class PayloadVoid extends PayloadBlock{
|
||||
@Override
|
||||
public void updateTile(){
|
||||
super.updateTile();
|
||||
if(moveInPayload(false) && cons.valid()){
|
||||
if(moveInPayload(false) && consValid()){
|
||||
payload = null;
|
||||
incinerateEffect.at(this);
|
||||
incinerateSound.at(this);
|
||||
|
||||
@@ -251,7 +251,7 @@ public class BeamDrill extends Block{
|
||||
|
||||
float multiplier = 1f;
|
||||
|
||||
if(cons.optionalValid()){
|
||||
if(consOptionalValid()){
|
||||
boostWarmup = Mathf.lerpDelta(boostWarmup, 1f, 0.1f);
|
||||
multiplier *= optionalBoostIntensity;
|
||||
}else{
|
||||
|
||||
@@ -277,7 +277,7 @@ public class Drill extends Block{
|
||||
|
||||
float speed = 1f;
|
||||
|
||||
if(cons.optionalValid()){
|
||||
if(consOptionalValid()){
|
||||
speed = liquidBoostIntensity;
|
||||
}
|
||||
|
||||
|
||||
@@ -288,7 +288,7 @@ public class GenericCrafter extends Block{
|
||||
|
||||
@Override
|
||||
public boolean shouldAmbientSound(){
|
||||
return cons.valid();
|
||||
return consValid();
|
||||
}
|
||||
|
||||
@Override
|
||||
|
||||
@@ -46,7 +46,7 @@ public class LiquidConverter extends GenericCrafter{
|
||||
public void updateTile(){
|
||||
ConsumeLiquid cl = consumes.get(ConsumeType.liquid);
|
||||
|
||||
if(cons.valid()){
|
||||
if(consValid()){
|
||||
if(Mathf.chanceDelta(updateEffectChance)){
|
||||
updateEffect.at(x + Mathf.range(size * 4f), y + Mathf.range(size * 4));
|
||||
}
|
||||
@@ -65,7 +65,7 @@ public class LiquidConverter extends GenericCrafter{
|
||||
}
|
||||
}else{
|
||||
//warmup is still 1 even if not consuming
|
||||
warmup = Mathf.lerp(warmup, cons.canConsume() ? 1f : 0f, 0.02f);
|
||||
warmup = Mathf.lerp(warmup, canConsume() ? 1f : 0f, 0.02f);
|
||||
}
|
||||
|
||||
dumpLiquid(outputLiquid.liquid);
|
||||
|
||||
@@ -56,7 +56,7 @@ public class Separator extends Block{
|
||||
|
||||
@Override
|
||||
public boolean shouldAmbientSound(){
|
||||
return cons.valid();
|
||||
return consValid();
|
||||
}
|
||||
|
||||
@Override
|
||||
|
||||
@@ -121,7 +121,7 @@ public class SolidPump extends Pump{
|
||||
public void updateTile(){
|
||||
float fraction = Math.max(validTiles + boost + (attribute == null ? 0 : attribute.env()), 0);
|
||||
|
||||
if(cons.valid() && typeLiquid() < liquidCapacity - 0.001f){
|
||||
if(consValid() && typeLiquid() < liquidCapacity - 0.001f){
|
||||
float maxPump = Math.min(liquidCapacity - typeLiquid(), pumpAmount * delta() * fraction * efficiency());
|
||||
liquids.add(result, maxPump);
|
||||
lastPump = maxPump / Time.delta;
|
||||
|
||||
@@ -24,11 +24,6 @@ public class ItemVoid extends Block{
|
||||
return flowItems;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void updateTile(){
|
||||
flowItems.update(updateFlow);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void handleItem(Building source, Item item){
|
||||
flowItems.handleFlow(item, 1);
|
||||
|
||||
@@ -210,7 +210,7 @@ public class RepairPoint extends Block{
|
||||
|
||||
@Override
|
||||
public BlockStatus status(){
|
||||
return Mathf.equal(efficiency(), 0f, 0.01f) ? BlockStatus.noInput : cons.status();
|
||||
return Mathf.equal(efficiency(), 0f, 0.01f) ? BlockStatus.noInput : super.status();
|
||||
}
|
||||
|
||||
@Override
|
||||
|
||||
@@ -2,89 +2,49 @@ package mindustry.world.modules;
|
||||
|
||||
import arc.util.io.*;
|
||||
import mindustry.gen.*;
|
||||
import mindustry.world.consumers.*;
|
||||
import mindustry.world.meta.*;
|
||||
|
||||
/** @deprecated why is it a module? literally two booleans, why did I think it was a good idea? yay, more pointers???
|
||||
* the braindead java "make everything a separate class" mentality
|
||||
* */
|
||||
@Deprecated
|
||||
public class ConsumeModule extends BlockModule{
|
||||
private boolean valid, optionalValid;
|
||||
private final Building entity;
|
||||
private final Building build;
|
||||
|
||||
public ConsumeModule(Building entity){
|
||||
this.entity = entity;
|
||||
public ConsumeModule(Building build){
|
||||
this.build = build;
|
||||
}
|
||||
|
||||
public BlockStatus status(){
|
||||
if(entity.enabledControlTime > 0 && !entity.enabled){
|
||||
return BlockStatus.logicDisable;
|
||||
}
|
||||
|
||||
if(!entity.shouldConsume()){
|
||||
return BlockStatus.noOutput;
|
||||
}
|
||||
|
||||
if(!valid || !entity.productionValid()){
|
||||
return BlockStatus.noInput;
|
||||
}
|
||||
|
||||
return BlockStatus.active;
|
||||
return build.status();
|
||||
}
|
||||
|
||||
public void update(){
|
||||
//everything is valid when cheating
|
||||
if(entity.cheating()){
|
||||
valid = optionalValid = true;
|
||||
return;
|
||||
}
|
||||
|
||||
boolean prevValid = valid();
|
||||
valid = true;
|
||||
optionalValid = true;
|
||||
boolean docons = entity.shouldConsume() && entity.productionValid();
|
||||
|
||||
for(Consume cons : entity.block.consumes.all){
|
||||
if(cons.isOptional()) continue;
|
||||
|
||||
if(docons && cons.isUpdate() && prevValid && cons.valid(entity)){
|
||||
cons.update(entity);
|
||||
}
|
||||
|
||||
valid &= cons.valid(entity);
|
||||
}
|
||||
|
||||
for(Consume cons : entity.block.consumes.optionals){
|
||||
if(docons && cons.isUpdate() && prevValid && cons.valid(entity)){
|
||||
cons.update(entity);
|
||||
}
|
||||
|
||||
optionalValid &= cons.valid(entity);
|
||||
}
|
||||
build.updateConsumption();
|
||||
}
|
||||
|
||||
public void trigger(){
|
||||
for(Consume cons : entity.block.consumes.all){
|
||||
cons.trigger(entity);
|
||||
}
|
||||
build.consume();
|
||||
}
|
||||
|
||||
public boolean valid(){
|
||||
return valid && entity.shouldConsume() && entity.enabled;
|
||||
return build.consValid();
|
||||
}
|
||||
|
||||
public boolean canConsume(){
|
||||
return valid && entity.enabled;
|
||||
return build.canConsume();
|
||||
}
|
||||
|
||||
public boolean optionalValid(){
|
||||
return valid() && optionalValid && entity.enabled;
|
||||
return build.consOptionalValid();
|
||||
}
|
||||
|
||||
//hahahahahahahahahaha
|
||||
@Override
|
||||
public void write(Writes write){
|
||||
write.bool(valid);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void read(Reads read){
|
||||
valid = read.bool();
|
||||
}
|
||||
}
|
||||
|
||||
@@ -39,51 +39,51 @@ public class ItemModule extends BlockModule{
|
||||
System.arraycopy(other.items, 0, items, 0, items.length);
|
||||
}
|
||||
|
||||
public void update(boolean showFlow){
|
||||
if(showFlow){
|
||||
//update the flow at 30fps at most
|
||||
if(flowTimer.get(1, pollScl)){
|
||||
public void updateFlow(){
|
||||
//update the flow at N fps at most
|
||||
if(flowTimer.get(1, pollScl)){
|
||||
|
||||
if(flow == null){
|
||||
if(cacheFlow == null || cacheFlow.length != items.length){
|
||||
cacheFlow = new WindowedMean[items.length];
|
||||
for(int i = 0; i < items.length; i++){
|
||||
cacheFlow[i] = new WindowedMean(windowSize);
|
||||
}
|
||||
cacheSums = new float[items.length];
|
||||
displayFlow = new float[items.length];
|
||||
}else{
|
||||
for(int i = 0; i < items.length; i++){
|
||||
cacheFlow[i].reset();
|
||||
}
|
||||
Arrays.fill(cacheSums, 0);
|
||||
cacheBits.clear();
|
||||
if(flow == null){
|
||||
if(cacheFlow == null || cacheFlow.length != items.length){
|
||||
cacheFlow = new WindowedMean[items.length];
|
||||
for(int i = 0; i < items.length; i++){
|
||||
cacheFlow[i] = new WindowedMean(windowSize);
|
||||
}
|
||||
|
||||
Arrays.fill(displayFlow, -1);
|
||||
|
||||
flow = cacheFlow;
|
||||
cacheSums = new float[items.length];
|
||||
displayFlow = new float[items.length];
|
||||
}else{
|
||||
for(int i = 0; i < items.length; i++){
|
||||
cacheFlow[i].reset();
|
||||
}
|
||||
Arrays.fill(cacheSums, 0);
|
||||
cacheBits.clear();
|
||||
}
|
||||
|
||||
boolean updateFlow = flowTimer.get(30);
|
||||
Arrays.fill(displayFlow, -1);
|
||||
|
||||
for(int i = 0; i < items.length; i++){
|
||||
flow[i].add(cacheSums[i]);
|
||||
if(cacheSums[i] > 0){
|
||||
cacheBits.set(i);
|
||||
}
|
||||
cacheSums[i] = 0;
|
||||
flow = cacheFlow;
|
||||
}
|
||||
|
||||
if(updateFlow){
|
||||
displayFlow[i] = flow[i].hasEnoughData() ? flow[i].mean() / pollScl : -1;
|
||||
}
|
||||
boolean updateFlow = flowTimer.get(30);
|
||||
|
||||
for(int i = 0; i < items.length; i++){
|
||||
flow[i].add(cacheSums[i]);
|
||||
if(cacheSums[i] > 0){
|
||||
cacheBits.set(i);
|
||||
}
|
||||
cacheSums[i] = 0;
|
||||
|
||||
if(updateFlow){
|
||||
displayFlow[i] = flow[i].hasEnoughData() ? flow[i].mean() / pollScl : -1;
|
||||
}
|
||||
}
|
||||
}else{
|
||||
flow = null;
|
||||
}
|
||||
}
|
||||
|
||||
public void stopFlow(){
|
||||
flow = null;
|
||||
}
|
||||
|
||||
public int length(){
|
||||
return items.length;
|
||||
}
|
||||
|
||||
@@ -22,57 +22,53 @@ public class LiquidModule extends BlockModule{
|
||||
|
||||
private float[] liquids = new float[content.liquids().size];
|
||||
private Liquid current = content.liquid(0);
|
||||
private float total, smoothLiquid;
|
||||
private float total;
|
||||
|
||||
private @Nullable WindowedMean[] flow;
|
||||
|
||||
public void update(boolean showFlow){
|
||||
smoothLiquid = Mathf.lerpDelta(smoothLiquid, currentAmount(), 0.1f);
|
||||
|
||||
if(showFlow){
|
||||
|
||||
if(flowTimer.get(1, pollScl)){
|
||||
|
||||
if(flow == null){
|
||||
if(cacheFlow == null || cacheFlow.length != liquids.length){
|
||||
cacheFlow = new WindowedMean[liquids.length];
|
||||
for(int i = 0; i < liquids.length; i++){
|
||||
cacheFlow[i] = new WindowedMean(windowSize);
|
||||
}
|
||||
cacheSums = new float[liquids.length];
|
||||
displayFlow = new float[liquids.length];
|
||||
}else{
|
||||
for(int i = 0; i < liquids.length; i++){
|
||||
cacheFlow[i].reset();
|
||||
}
|
||||
Arrays.fill(cacheSums, 0);
|
||||
cacheBits.clear();
|
||||
public void updateFlow(){
|
||||
if(flowTimer.get(1, pollScl)){
|
||||
if(flow == null){
|
||||
if(cacheFlow == null || cacheFlow.length != liquids.length){
|
||||
cacheFlow = new WindowedMean[liquids.length];
|
||||
for(int i = 0; i < liquids.length; i++){
|
||||
cacheFlow[i] = new WindowedMean(windowSize);
|
||||
}
|
||||
|
||||
Arrays.fill(displayFlow, -1);
|
||||
|
||||
flow = cacheFlow;
|
||||
cacheSums = new float[liquids.length];
|
||||
displayFlow = new float[liquids.length];
|
||||
}else{
|
||||
for(int i = 0; i < liquids.length; i++){
|
||||
cacheFlow[i].reset();
|
||||
}
|
||||
Arrays.fill(cacheSums, 0);
|
||||
cacheBits.clear();
|
||||
}
|
||||
|
||||
boolean updateFlow = flowTimer.get(30);
|
||||
Arrays.fill(displayFlow, -1);
|
||||
|
||||
for(int i = 0; i < liquids.length; i++){
|
||||
flow[i].add(cacheSums[i]);
|
||||
if(cacheSums[i] > 0){
|
||||
cacheBits.set(i);
|
||||
}
|
||||
cacheSums[i] = 0;
|
||||
flow = cacheFlow;
|
||||
}
|
||||
|
||||
if(updateFlow){
|
||||
displayFlow[i] = flow[i].hasEnoughData() ? flow[i].mean() / pollScl : -1;
|
||||
}
|
||||
boolean updateFlow = flowTimer.get(30);
|
||||
|
||||
for(int i = 0; i < liquids.length; i++){
|
||||
flow[i].add(cacheSums[i]);
|
||||
if(cacheSums[i] > 0){
|
||||
cacheBits.set(i);
|
||||
}
|
||||
cacheSums[i] = 0;
|
||||
|
||||
if(updateFlow){
|
||||
displayFlow[i] = flow[i].hasEnoughData() ? flow[i].mean() / pollScl : -1;
|
||||
}
|
||||
}
|
||||
}else{
|
||||
flow = null;
|
||||
}
|
||||
}
|
||||
|
||||
public void stopFlow(){
|
||||
flow = null;
|
||||
}
|
||||
|
||||
/** @return current liquid's flow rate in u/s; any value < 0 means 'not ready'. */
|
||||
public float getFlowRate(Liquid liquid){
|
||||
return flow == null ? -1f : displayFlow[liquid.id] * 60;
|
||||
@@ -82,10 +78,6 @@ public class LiquidModule extends BlockModule{
|
||||
return flow != null && cacheBits.get(liquid.id);
|
||||
}
|
||||
|
||||
public float smoothAmount(){
|
||||
return smoothLiquid;
|
||||
}
|
||||
|
||||
/**
|
||||
* @deprecated There is no good reason to check the total amount of liquids of a block.
|
||||
* Use of this method is almost certainly a bug; currentAmount() is probably what you want instead.
|
||||
|
||||
Reference in New Issue
Block a user