238 lines
8.7 KiB
Java
238 lines
8.7 KiB
Java
/*
|
|
* This file is part of Applied Energistics 2.
|
|
* Copyright (c) 2013 - 2014, AlgorithmX2, All rights reserved.
|
|
*
|
|
* Applied Energistics 2 is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU Lesser General Public License as published by
|
|
* the Free Software Foundation, either version 3 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* Applied Energistics 2 is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public License
|
|
* along with Applied Energistics 2. If not, see <http://www.gnu.org/licenses/lgpl>.
|
|
*/
|
|
|
|
package appeng.me.cache;
|
|
|
|
import java.util.HashMap;
|
|
import java.util.LinkedList;
|
|
import java.util.List;
|
|
|
|
import appeng.api.networking.IGrid;
|
|
import appeng.api.networking.IGridHost;
|
|
import appeng.api.networking.IGridNode;
|
|
import appeng.api.networking.IGridStorage;
|
|
import appeng.api.networking.events.MENetworkBootingStatusChange;
|
|
import appeng.api.networking.events.MENetworkEventSubscribe;
|
|
import appeng.api.networking.spatial.ISpatialCache;
|
|
import appeng.api.util.DimensionalCoord;
|
|
import appeng.api.util.IReadOnlyCollection;
|
|
import appeng.core.AEConfig;
|
|
import appeng.me.cluster.implementations.SpatialPylonCluster;
|
|
import appeng.tile.spatial.TileSpatialIOPort;
|
|
import appeng.tile.spatial.TileSpatialPylon;
|
|
|
|
public class SpatialPylonCache implements ISpatialCache {
|
|
private final IGrid myGrid;
|
|
private long powerRequired = 0;
|
|
private double efficiency = 0.0;
|
|
private DimensionalCoord captureMin;
|
|
private DimensionalCoord captureMax;
|
|
private boolean isValid = false;
|
|
private List<TileSpatialIOPort> ioPorts = new LinkedList<TileSpatialIOPort>();
|
|
private HashMap<SpatialPylonCluster, SpatialPylonCluster> clusters
|
|
= new HashMap<SpatialPylonCluster, SpatialPylonCluster>();
|
|
|
|
public SpatialPylonCache(final IGrid g) {
|
|
this.myGrid = g;
|
|
}
|
|
|
|
@MENetworkEventSubscribe
|
|
public void bootingRender(final MENetworkBootingStatusChange c) {
|
|
this.reset(this.myGrid);
|
|
}
|
|
|
|
private void reset(final IGrid grid) {
|
|
this.clusters = new HashMap<SpatialPylonCluster, SpatialPylonCluster>();
|
|
this.ioPorts = new LinkedList<TileSpatialIOPort>();
|
|
|
|
for (final IGridNode gm : grid.getMachines(TileSpatialIOPort.class)) {
|
|
this.ioPorts.add((TileSpatialIOPort) gm.getMachine());
|
|
}
|
|
|
|
final IReadOnlyCollection<IGridNode> set
|
|
= grid.getMachines(TileSpatialPylon.class);
|
|
for (final IGridNode gm : set) {
|
|
if (gm.meetsChannelRequirements()) {
|
|
final SpatialPylonCluster c
|
|
= ((TileSpatialPylon) gm.getMachine()).getCluster();
|
|
if (c != null) {
|
|
this.clusters.put(c, c);
|
|
}
|
|
}
|
|
}
|
|
|
|
this.captureMax = null;
|
|
this.captureMin = null;
|
|
this.isValid = true;
|
|
|
|
int pylonBlocks = 0;
|
|
for (final SpatialPylonCluster cl : this.clusters.values()) {
|
|
if (this.captureMax == null) {
|
|
this.captureMax = cl.getMax().copy();
|
|
}
|
|
if (this.captureMin == null) {
|
|
this.captureMin = cl.getMin().copy();
|
|
}
|
|
|
|
pylonBlocks += cl.tileCount();
|
|
|
|
this.captureMin.x = Math.min(this.captureMin.x, cl.getMin().x);
|
|
this.captureMin.y = Math.min(this.captureMin.y, cl.getMin().y);
|
|
this.captureMin.z = Math.min(this.captureMin.z, cl.getMin().z);
|
|
|
|
this.captureMax.x = Math.max(this.captureMax.x, cl.getMax().x);
|
|
this.captureMax.y = Math.max(this.captureMax.y, cl.getMax().y);
|
|
this.captureMax.z = Math.max(this.captureMax.z, cl.getMax().z);
|
|
}
|
|
|
|
double maxPower = 0;
|
|
double minPower = 0;
|
|
if (this.hasRegion()) {
|
|
this.isValid = this.captureMax.x - this.captureMin.x > 1
|
|
&& this.captureMax.y - this.captureMin.y > 1
|
|
&& this.captureMax.z - this.captureMin.z > 1;
|
|
|
|
for (final SpatialPylonCluster cl : this.clusters.values()) {
|
|
switch (cl.getCurrentAxis()) {
|
|
case X:
|
|
|
|
this.isValid = this.isValid
|
|
&& ((this.captureMax.y == cl.getMin().y
|
|
|| this.captureMin.y == cl.getMax().y)
|
|
|| (this.captureMax.z == cl.getMin().z
|
|
|| this.captureMin.z == cl.getMax().z))
|
|
&& ((this.captureMax.y == cl.getMax().y
|
|
|| this.captureMin.y == cl.getMin().y)
|
|
|| (this.captureMax.z == cl.getMax().z
|
|
|| this.captureMin.z == cl.getMin().z));
|
|
|
|
break;
|
|
case Y:
|
|
|
|
this.isValid = this.isValid
|
|
&& ((this.captureMax.x == cl.getMin().x
|
|
|| this.captureMin.x == cl.getMax().x)
|
|
|| (this.captureMax.z == cl.getMin().z
|
|
|| this.captureMin.z == cl.getMax().z))
|
|
&& ((this.captureMax.x == cl.getMax().x
|
|
|| this.captureMin.x == cl.getMin().x)
|
|
|| (this.captureMax.z == cl.getMax().z
|
|
|| this.captureMin.z == cl.getMin().z));
|
|
|
|
break;
|
|
case Z:
|
|
|
|
this.isValid = this.isValid
|
|
&& ((this.captureMax.y == cl.getMin().y
|
|
|| this.captureMin.y == cl.getMax().y)
|
|
|| (this.captureMax.x == cl.getMin().x
|
|
|| this.captureMin.x == cl.getMax().x))
|
|
&& ((this.captureMax.y == cl.getMax().y
|
|
|| this.captureMin.y == cl.getMin().y)
|
|
|| (this.captureMax.x == cl.getMax().x
|
|
|| this.captureMin.x == cl.getMin().x));
|
|
|
|
break;
|
|
case UNFORMED:
|
|
this.isValid = false;
|
|
break;
|
|
}
|
|
}
|
|
|
|
final int reqX = this.captureMax.x - this.captureMin.x;
|
|
final int reqY = this.captureMax.y - this.captureMin.y;
|
|
final int reqZ = this.captureMax.z - this.captureMin.z;
|
|
final int requirePylonBlocks
|
|
= Math.max(6, ((reqX * reqZ + reqX * reqY + reqY * reqZ) * 3) / 8);
|
|
|
|
this.efficiency = (double) pylonBlocks / (double) requirePylonBlocks;
|
|
|
|
if (this.efficiency > 1.0) {
|
|
this.efficiency = 1.0;
|
|
}
|
|
if (this.efficiency < 0.0) {
|
|
this.efficiency = 0.0;
|
|
}
|
|
|
|
minPower = (double) reqX * (double) reqY * reqZ
|
|
* AEConfig.instance.spatialPowerMultiplier;
|
|
maxPower = Math.pow(minPower, AEConfig.instance.spatialPowerExponent);
|
|
}
|
|
|
|
final double affective_efficiency = Math.pow(this.efficiency, 0.25);
|
|
this.powerRequired = (long
|
|
) (affective_efficiency * minPower + (1.0 - affective_efficiency) * maxPower);
|
|
|
|
for (final SpatialPylonCluster cl : this.clusters.values()) {
|
|
final boolean myWasValid = cl.isValid();
|
|
cl.setValid(this.isValid);
|
|
if (myWasValid != this.isValid) {
|
|
cl.updateStatus(false);
|
|
}
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public boolean hasRegion() {
|
|
return this.captureMin != null;
|
|
}
|
|
|
|
@Override
|
|
public boolean isValidRegion() {
|
|
return this.hasRegion() && this.isValid;
|
|
}
|
|
|
|
@Override
|
|
public DimensionalCoord getMin() {
|
|
return this.captureMin;
|
|
}
|
|
|
|
@Override
|
|
public DimensionalCoord getMax() {
|
|
return this.captureMax;
|
|
}
|
|
|
|
@Override
|
|
public long requiredPower() {
|
|
return this.powerRequired;
|
|
}
|
|
|
|
@Override
|
|
public float currentEfficiency() {
|
|
return (float) this.efficiency * 100;
|
|
}
|
|
|
|
@Override
|
|
public void onUpdateTick() {}
|
|
|
|
@Override
|
|
public void removeNode(final IGridNode node, final IGridHost machine) {}
|
|
|
|
@Override
|
|
public void addNode(final IGridNode node, final IGridHost machine) {}
|
|
|
|
@Override
|
|
public void onSplit(final IGridStorage storageB) {}
|
|
|
|
@Override
|
|
public void onJoin(final IGridStorage storageB) {}
|
|
|
|
@Override
|
|
public void populateGridStorage(final IGridStorage storage) {}
|
|
}
|