TechReborn/src/main/java/techreborn/partSystem/parts/CablePart.java

322 lines
7.4 KiB
Java
Raw Normal View History

2015-04-20 22:02:25 +02:00
package techreborn.partSystem.parts;
import ic2.api.energy.event.EnergyTileLoadEvent;
import ic2.api.energy.event.EnergyTileUnloadEvent;
import ic2.api.energy.tile.IEnergyConductor;
import ic2.api.energy.tile.IEnergyTile;
import ic2.core.IC2;
import net.minecraft.entity.Entity;
import net.minecraft.init.Blocks;
import net.minecraft.item.ItemStack;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.world.World;
import net.minecraftforge.common.MinecraftForge;
import net.minecraftforge.common.util.ForgeDirection;
2015-04-20 22:28:54 +02:00
import techreborn.lib.Functions;
import techreborn.lib.vecmath.Vecs3d;
import techreborn.lib.vecmath.Vecs3dCube;
import techreborn.partSystem.ModPart;
import techreborn.partSystem.ModPartUtils;
import techreborn.partSystem.QLib.ModLib2QLib;
import uk.co.qmunity.lib.client.render.RenderHelper;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
public class CablePart extends ModPart implements IEnergyConductor {
public static Vecs3dCube[] boundingBoxes = new Vecs3dCube[14];
public static float center = 0.6F;
public static float offset = 0.10F;
public Map<ForgeDirection, TileEntity> connectedSides;
public int ticks = 0;
protected ForgeDirection[] dirs = ForgeDirection.values();
private boolean[] connections = new boolean[6];
public boolean addedToEnergyNet = false;
2015-04-24 15:20:09 +02:00
public static void refreshBounding()
{
float centerFirst = center - offset;
double w = 0.2D / 2;
2015-04-24 15:20:09 +02:00
boundingBoxes[6] = new Vecs3dCube(centerFirst - w - 0.03, centerFirst
- w - 0.08, centerFirst - w - 0.03, centerFirst + w + 0.08,
centerFirst + w + 0.04, centerFirst + w + 0.08);
2015-04-24 15:20:09 +02:00
boundingBoxes[6] = new Vecs3dCube(centerFirst - w, centerFirst - w,
centerFirst - w, centerFirst + w, centerFirst + w, centerFirst
+ w);
int i = 0;
2015-04-24 15:20:09 +02:00
for (ForgeDirection dir : ForgeDirection.VALID_DIRECTIONS)
{
double xMin1 = (dir.offsetX < 0 ? 0.0
: (dir.offsetX == 0 ? centerFirst - w : centerFirst + w));
double xMax1 = (dir.offsetX > 0 ? 1.0
: (dir.offsetX == 0 ? centerFirst + w : centerFirst - w));
double yMin1 = (dir.offsetY < 0 ? 0.0
: (dir.offsetY == 0 ? centerFirst - w : centerFirst + w));
double yMax1 = (dir.offsetY > 0 ? 1.0
: (dir.offsetY == 0 ? centerFirst + w : centerFirst - w));
double zMin1 = (dir.offsetZ < 0 ? 0.0
: (dir.offsetZ == 0 ? centerFirst - w : centerFirst + w));
double zMax1 = (dir.offsetZ > 0 ? 1.0
: (dir.offsetZ == 0 ? centerFirst + w : centerFirst - w));
boundingBoxes[i] = new Vecs3dCube(xMin1, yMin1, zMin1, xMax1,
yMax1, zMax1);
i++;
}
}
@Override
2015-04-24 15:20:09 +02:00
public void addCollisionBoxesToList(List<Vecs3dCube> boxes, Entity entity)
{
if (world != null || location != null)
{
checkConnectedSides();
2015-04-24 15:20:09 +02:00
} else
{
connectedSides = new HashMap<ForgeDirection, TileEntity>();
}
2015-04-24 15:20:09 +02:00
for (ForgeDirection dir : ForgeDirection.VALID_DIRECTIONS)
{
if (connectedSides.containsKey(dir))
boxes.add(boundingBoxes[Functions.getIntDirFromDirection(dir)]);
}
boxes.add(boundingBoxes[6]);
}
@Override
2015-04-24 15:20:09 +02:00
public List<Vecs3dCube> getSelectionBoxes()
{
List<Vecs3dCube> vec3dCubeList = new ArrayList<Vecs3dCube>();
checkConnectedSides();
2015-04-24 15:20:09 +02:00
for (ForgeDirection dir : ForgeDirection.VALID_DIRECTIONS)
{
if (connectedSides.containsKey(dir))
2015-04-24 15:20:09 +02:00
vec3dCubeList.add(boundingBoxes[Functions
.getIntDirFromDirection(dir)]);
}
vec3dCubeList.add(boundingBoxes[6]);
return vec3dCubeList;
}
@Override
2015-04-24 15:20:09 +02:00
public List<Vecs3dCube> getOcclusionBoxes()
{
checkConnectedSides();
List<Vecs3dCube> vecs3dCubesList = new ArrayList<Vecs3dCube>();
2015-04-24 15:20:09 +02:00
for (ForgeDirection dir : ForgeDirection.VALID_DIRECTIONS)
{
if (connectedSides.containsKey(dir))
2015-04-24 15:20:09 +02:00
vecs3dCubesList.add(boundingBoxes[Functions
.getIntDirFromDirection(dir)]);
}
return vecs3dCubesList;
}
@Override
2015-04-24 15:20:09 +02:00
public void renderDynamic(Vecs3d translation, double delta)
{
}
2015-04-23 21:49:30 +02:00
@Override
public boolean renderStatic(Vecs3d translation, RenderHelper renderer, int pass) {
renderer.setOverrideTexture(Blocks.coal_block.getIcon(0, 0));
renderer.renderBox(ModLib2QLib.convert(boundingBoxes[6]));
if(connectedSides != null){
for (ForgeDirection dir : ForgeDirection.VALID_DIRECTIONS) {
if (connectedSides.containsKey(dir))
renderer.renderBox(ModLib2QLib.convert(boundingBoxes[Functions.getIntDirFromDirection(dir)]));
}
}
return true;
}
@Override
2015-04-24 15:20:09 +02:00
public void writeToNBT(NBTTagCompound tag)
{
}
@Override
2015-04-24 15:20:09 +02:00
public void readFromNBT(NBTTagCompound tag)
{
}
@Override
2015-04-24 15:20:09 +02:00
public String getName()
{
return "Cable";
}
@Override
2015-04-24 15:20:09 +02:00
public String getItemTextureName()
{
return "network:networkCable";
}
@Override
2015-04-24 15:20:09 +02:00
public void tick()
{
if (ticks == 0)
{
checkConnectedSides();
ticks += 1;
2015-04-24 15:20:09 +02:00
} else if (ticks == 40)
{
ticks = 0;
2015-04-24 15:20:09 +02:00
} else
{
ticks += 1;
}
2015-04-24 15:20:09 +02:00
if (IC2.platform.isSimulating())
{
MinecraftForge.EVENT_BUS.post(new EnergyTileLoadEvent(this));
this.addedToEnergyNet = true;
checkConnectedSides();
}
}
@Override
2015-04-24 15:20:09 +02:00
public void nearByChange()
{
checkConnectedSides();
}
@Override
public void onAdded() {
checkConnections(world, getX(), getY(), getZ());
}
@Override
2015-04-24 15:20:09 +02:00
public void onRemoved()
{
if (IC2.platform.isSimulating() && this.addedToEnergyNet)
{
MinecraftForge.EVENT_BUS.post(new EnergyTileUnloadEvent(this));
this.addedToEnergyNet = false;
}
}
@Override
2015-04-24 15:20:09 +02:00
public ItemStack getItem()
{
return new ItemStack(ModPartUtils.getItemForPart(getName()));
}
2015-04-24 15:20:09 +02:00
public boolean shouldConnectTo(TileEntity entity, ForgeDirection dir)
{
if (entity == null)
{
return false;
2015-04-24 15:20:09 +02:00
} else if (entity instanceof IEnergyTile)
{
return true;
2015-04-24 15:20:09 +02:00
} else
{
return ModPartUtils.hasPart(entity.getWorldObj(), entity.xCoord,
entity.yCoord, entity.zCoord, this.getName());
}
}
2015-04-24 15:20:09 +02:00
public void checkConnectedSides()
{
refreshBounding();
connectedSides = new HashMap<ForgeDirection, TileEntity>();
2015-04-24 15:20:09 +02:00
for (ForgeDirection dir : ForgeDirection.VALID_DIRECTIONS)
{
int d = Functions.getIntDirFromDirection(dir);
2015-04-24 15:20:09 +02:00
if (world == null)
{
return;
}
2015-04-24 15:20:09 +02:00
TileEntity te = world.getTileEntity(getX() + dir.offsetX, getY()
+ dir.offsetY, getZ() + dir.offsetZ);
if (shouldConnectTo(te, dir))
{
// TODO if (ModPartUtils.checkOcclusion(getWorld(), getX(),
// getY(), getZ(), boundingBoxes[d])) {
connectedSides.put(dir, te);
// }
}
}
checkConnections(world, getX(), getY(), getZ());
getWorld().markBlockForUpdate(getX(), getY(), getZ());
}
2015-04-24 15:20:09 +02:00
public void checkConnections(World world, int x, int y, int z)
{
for (int i = 0; i < 6; i++)
{
ForgeDirection dir = dirs[i];
int dx = x + dir.offsetX;
int dy = y + dir.offsetY;
int dz = z + dir.offsetZ;
2015-04-24 15:20:09 +02:00
connections[i] = shouldConnectTo(world.getTileEntity(dx, dy, dz),
dir);
world.func_147479_m(dx, dy, dz);
}
world.func_147479_m(x, y, z);
}
@Override
2015-04-24 15:20:09 +02:00
public double getConductionLoss()
{
return 0D;
}
@Override
2015-04-24 15:20:09 +02:00
public double getInsulationEnergyAbsorption()
{
return 256;
}
@Override
2015-04-24 15:20:09 +02:00
public double getInsulationBreakdownEnergy()
{
return 2048;
}
@Override
2015-04-24 15:20:09 +02:00
public double getConductorBreakdownEnergy()
{
return 2048;
}
@Override
2015-04-24 15:20:09 +02:00
public void removeInsulation()
{
}
@Override
2015-04-24 15:20:09 +02:00
public void removeConductor()
{
}
@Override
2015-04-24 15:20:09 +02:00
public boolean acceptsEnergyFrom(TileEntity tileEntity,
ForgeDirection forgeDirection)
{
return true;
}
@Override
2015-04-24 15:20:09 +02:00
public boolean emitsEnergyTo(TileEntity tileEntity,
ForgeDirection forgeDirection)
{
return true;
}
}