ActuallyAdditions/src/main/java/de/ellpeck/actuallyadditions/mod/misc/LaserRelayConnectionHandler.java

259 lines
10 KiB
Java
Raw Normal View History

/*
* This file ("LaserRelayConnectionHandler.java") is part of the Actually Additions Mod for Minecraft.
* It is created and owned by Ellpeck and distributed
* under the Actually Additions License to be found at
2016-01-03 16:05:51 +01:00
* http://ellpeck.de/actaddlicense/
* View the source code at https://github.com/Ellpeck/ActuallyAdditions
*
2016-01-03 16:05:51 +01:00
* © 2016 Ellpeck
*/
2016-01-05 04:47:35 +01:00
package de.ellpeck.actuallyadditions.mod.misc;
import cofh.api.energy.IEnergyReceiver;
2016-01-05 04:47:35 +01:00
import de.ellpeck.actuallyadditions.mod.config.values.ConfigIntValues;
import de.ellpeck.actuallyadditions.mod.tile.TileEntityLaserRelay;
2016-01-08 13:31:58 +01:00
import de.ellpeck.actuallyadditions.mod.util.PosUtil;
2016-01-05 04:47:35 +01:00
import de.ellpeck.actuallyadditions.mod.util.WorldUtil;
import io.netty.util.internal.ConcurrentSet;
2015-10-21 00:22:50 +02:00
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.nbt.NBTTagList;
import net.minecraft.tileentity.TileEntity;
2016-01-08 13:31:58 +01:00
import net.minecraft.util.BlockPos;
2016-01-07 18:20:59 +01:00
import net.minecraft.util.EnumFacing;
import net.minecraft.world.World;
public class LaserRelayConnectionHandler{
private static LaserRelayConnectionHandler instance;
/**
* All of the Networks
*/
public ConcurrentSet<Network> networks = new ConcurrentSet<Network>();
public static LaserRelayConnectionHandler getInstance(){
return instance;
}
2015-11-01 10:34:17 +01:00
public static void setInstance(LaserRelayConnectionHandler handler){
instance = handler;
}
public NBTTagCompound writeNetworkToNBT(Network network){
NBTTagList list = new NBTTagList();
for(ConnectionPair pair : network.connections){
list.appendTag(pair.writeToNBT());
2015-10-21 00:22:50 +02:00
}
NBTTagCompound compound = new NBTTagCompound();
compound.setTag("Network", list);
return compound;
2015-10-21 00:22:50 +02:00
}
public Network readNetworkFromNBT(NBTTagCompound tag){
NBTTagList list = tag.getTagList("Network", 10);
Network network = new Network();
for(int i = 0; i < list.tagCount(); i++){
network.connections.add(ConnectionPair.readFromNBT(list.getCompoundTagAt(i)));
2015-10-21 00:22:50 +02:00
}
return network;
}
/**
2015-10-23 16:54:33 +02:00
* Gets all Connections for a Relay
*/
2016-01-08 13:31:58 +01:00
public ConcurrentSet<ConnectionPair> getConnectionsFor(BlockPos relay){
ConcurrentSet<ConnectionPair> allPairs = new ConcurrentSet<ConnectionPair>();
for(Network aNetwork : this.networks){
for(ConnectionPair pair : aNetwork.connections){
if(pair.contains(relay)){
2015-10-23 16:54:33 +02:00
allPairs.add(pair);
}
}
}
2015-10-23 16:54:33 +02:00
return allPairs;
}
2015-10-21 00:22:50 +02:00
/**
2015-10-23 16:54:33 +02:00
* Removes a Relay from its Network
2015-10-21 00:22:50 +02:00
*/
2016-01-08 13:31:58 +01:00
public void removeRelayFromNetwork(BlockPos relay){
Network network = this.getNetworkFor(relay);
2015-10-23 16:54:33 +02:00
if(network != null){
//Setup new network (so that splitting a network will cause it to break into two)
this.networks.remove(network);
for(ConnectionPair pair : network.connections){
if(!pair.contains(relay)){
this.addConnection(pair.firstRelay, pair.secondRelay);
}
2015-10-23 16:54:33 +02:00
}
2015-10-29 21:03:40 +01:00
//System.out.println("Removing a Relay from the Network!");
2015-10-23 16:54:33 +02:00
}
WorldData.makeDirty();
2015-10-23 16:54:33 +02:00
}
/**
* Gets a Network for a Relay
*/
2016-01-08 13:31:58 +01:00
public Network getNetworkFor(BlockPos relay){
for(Network aNetwork : this.networks){
for(ConnectionPair pair : aNetwork.connections){
2015-10-21 00:22:50 +02:00
if(pair.contains(relay)){
2015-10-23 16:54:33 +02:00
return aNetwork;
2015-10-21 00:22:50 +02:00
}
}
}
2015-10-23 16:54:33 +02:00
return null;
2015-10-21 00:22:50 +02:00
}
/**
* Adds a new connection between two relays
* (Puts it into the correct network!)
*/
2016-01-08 13:31:58 +01:00
public boolean addConnection(BlockPos firstRelay, BlockPos secondRelay){
int distance = (int)PosUtil.toVec(firstRelay).distanceTo(PosUtil.toVec(secondRelay));
if(distance > TileEntityLaserRelay.MAX_DISTANCE || PosUtil.areSamePos(firstRelay, secondRelay)){
return false;
}
Network firstNetwork = this.getNetworkFor(firstRelay);
Network secondNetwork = this.getNetworkFor(secondRelay);
//No Network exists
if(firstNetwork == null && secondNetwork == null){
firstNetwork = new Network();
this.networks.add(firstNetwork);
firstNetwork.connections.add(new ConnectionPair(firstRelay, secondRelay));
}
//The same Network
else if(firstNetwork == secondNetwork){
2015-10-20 18:06:06 +02:00
return false;
}
//Both relays have networks
else if(firstNetwork != null && secondNetwork != null){
this.mergeNetworks(firstNetwork, secondNetwork);
firstNetwork.connections.add(new ConnectionPair(firstRelay, secondRelay));
}
//Only first network exists
else if(firstNetwork != null){
firstNetwork.connections.add(new ConnectionPair(firstRelay, secondRelay));
}
//Only second network exists
else if(secondNetwork != null){
secondNetwork.connections.add(new ConnectionPair(firstRelay, secondRelay));
}
WorldData.makeDirty();
2015-10-29 21:03:40 +01:00
//System.out.println("Connected "+firstRelay.toString()+" to "+secondRelay.toString());
//System.out.println(firstNetwork == null ? secondNetwork.toString() : firstNetwork.toString());
//System.out.println(this.networks);
2015-10-20 18:06:06 +02:00
return true;
}
/**
* Merges two networks together
* (Actually puts everything from the second network into the first one and removes the second one)
*/
public void mergeNetworks(Network firstNetwork, Network secondNetwork){
for(ConnectionPair secondPair : secondNetwork.connections){
firstNetwork.connections.add(secondPair);
}
this.networks.remove(secondNetwork);
WorldData.makeDirty();
2015-10-29 21:03:40 +01:00
//System.out.println("Merged Two Networks!");
}
2016-01-08 13:31:58 +01:00
public int transferEnergyToReceiverInNeed(World world, BlockPos energyGottenFrom, Network network, int maxTransfer, boolean simulate){
int transmitted = 0;
//Go through all of the connections in the network
for(ConnectionPair pair : network.connections){
2016-01-08 13:31:58 +01:00
BlockPos[] relays = new BlockPos[]{pair.firstRelay, pair.secondRelay};
//Go through both relays in the connection
2016-01-08 13:31:58 +01:00
for(BlockPos relay : relays){
if(relay != null){
//Get every side of the relay
for(int i = 0; i <= 5; i++){
2016-01-07 18:20:59 +01:00
EnumFacing side = WorldUtil.getDirectionBySidesInOrder(i);
//Get the Position at the side
2016-01-08 13:31:58 +01:00
BlockPos pos = WorldUtil.getCoordsFromSide(side, relay, 0);
if(!PosUtil.areSamePos(pos, energyGottenFrom)){
TileEntity tile = world.getTileEntity(pos);
if(tile instanceof IEnergyReceiver && !(tile instanceof TileEntityLaserRelay)){
IEnergyReceiver receiver = (IEnergyReceiver)tile;
if(receiver.canConnectEnergy(side.getOpposite())){
//Transfer the energy (with the energy loss!)
int theoreticalReceived = ((IEnergyReceiver)tile).receiveEnergy(side.getOpposite(), maxTransfer-transmitted, true);
//The amount of energy lost during a transfer
int deduct = (int)(theoreticalReceived*((double)ConfigIntValues.LASER_RELAY_LOSS.getValue()/100));
transmitted += ((IEnergyReceiver)tile).receiveEnergy(side.getOpposite(), theoreticalReceived-deduct, simulate);
transmitted += deduct;
//If everything that could be transmitted was transmitted
if(transmitted >= maxTransfer){
return transmitted;
}
}
}
}
}
}
}
}
return transmitted;
}
public static class ConnectionPair{
2016-01-08 13:31:58 +01:00
public BlockPos firstRelay;
public BlockPos secondRelay;
2016-01-08 13:31:58 +01:00
public ConnectionPair(BlockPos firstRelay, BlockPos secondRelay){
this.firstRelay = firstRelay;
this.secondRelay = secondRelay;
}
public static ConnectionPair readFromNBT(NBTTagCompound compound){
if(compound != null){
2016-01-08 13:31:58 +01:00
BlockPos[] pos = new BlockPos[2];
for(int i = 0; i < pos.length; i++){
int anX = compound.getInteger("x"+i);
int aY = compound.getInteger("y"+i);
int aZ = compound.getInteger("z"+i);
2016-01-08 13:31:58 +01:00
pos[i] = new BlockPos(anX, aY, aZ);
}
return new ConnectionPair(pos[0], pos[1]);
2015-10-23 16:54:33 +02:00
}
return null;
2015-10-23 16:54:33 +02:00
}
2016-01-08 13:31:58 +01:00
public boolean contains(BlockPos relay){
return (this.firstRelay != null && PosUtil.areSamePos(firstRelay, relay)) || (this.secondRelay != null && PosUtil.areSamePos(secondRelay, relay));
}
@Override
public String toString(){
return (this.firstRelay == null ? "-" : this.firstRelay.toString())+" | "+(this.secondRelay == null ? "-" : this.secondRelay.toString());
}
2015-10-21 00:22:50 +02:00
public NBTTagCompound writeToNBT(){
NBTTagCompound compound = new NBTTagCompound();
2015-10-21 00:22:50 +02:00
for(int i = 0; i < 2; i++){
2016-01-08 13:31:58 +01:00
BlockPos relay = i == 0 ? this.firstRelay : this.secondRelay;
compound.setInteger("x"+i, relay.getX());
compound.setInteger("y"+i, relay.getY());
compound.setInteger("z"+i, relay.getZ());
2015-10-21 00:22:50 +02:00
}
return compound;
}
}
public static class Network{
public ConcurrentSet<ConnectionPair> connections = new ConcurrentSet<ConnectionPair>();
@Override
public String toString(){
return this.connections.toString();
2015-10-21 00:22:50 +02:00
}
}
}