mirror of
https://github.com/HbmMods/Hbm-s-Nuclear-Tech-GIT.git
synced 2026-01-25 10:32:49 +00:00
279 lines
8.3 KiB
Java
279 lines
8.3 KiB
Java
package com.hbm.blocks.generic;
|
|
|
|
import java.util.ArrayList;
|
|
import java.util.HashMap;
|
|
import java.util.Random;
|
|
|
|
import com.hbm.blocks.ModBlocks;
|
|
import com.hbm.inventory.material.MaterialShapes;
|
|
import com.hbm.inventory.material.Mats;
|
|
import com.hbm.inventory.material.Mats.MaterialStack;
|
|
import com.hbm.inventory.material.NTMMaterial;
|
|
import com.hbm.items.machine.ItemScraps;
|
|
import com.hbm.render.icon.RGBMutatorInterpolatedComponentRemap;
|
|
import com.hbm.render.icon.TextureAtlasSpriteMutatable;
|
|
import com.hbm.util.Compat;
|
|
|
|
import cpw.mods.fml.relauncher.Side;
|
|
import cpw.mods.fml.relauncher.SideOnly;
|
|
import net.minecraft.block.BlockContainer;
|
|
import net.minecraft.block.material.Material;
|
|
import net.minecraft.client.renderer.texture.IIconRegister;
|
|
import net.minecraft.client.renderer.texture.TextureMap;
|
|
import net.minecraft.entity.player.EntityPlayer;
|
|
import net.minecraft.item.ItemStack;
|
|
import net.minecraft.nbt.NBTTagCompound;
|
|
import net.minecraft.network.NetworkManager;
|
|
import net.minecraft.network.Packet;
|
|
import net.minecraft.network.play.server.S35PacketUpdateTileEntity;
|
|
import net.minecraft.stats.StatList;
|
|
import net.minecraft.tileentity.TileEntity;
|
|
import net.minecraft.util.AxisAlignedBB;
|
|
import net.minecraft.util.IIcon;
|
|
import net.minecraft.util.MovingObjectPosition;
|
|
import net.minecraft.world.IBlockAccess;
|
|
import net.minecraft.world.World;
|
|
import net.minecraftforge.common.util.ForgeDirection;
|
|
|
|
public class BlockDynamicSlag extends BlockContainer {
|
|
|
|
private HashMap<NTMMaterial, IIcon> iconMap = new HashMap();
|
|
|
|
public BlockDynamicSlag() {
|
|
super(Material.iron);
|
|
this.useNeighborBrightness = true;
|
|
}
|
|
|
|
@Override
|
|
public TileEntity createNewTileEntity(World world, int meta) {
|
|
return new TileEntitySlag();
|
|
}
|
|
|
|
@SideOnly(Side.CLIENT)
|
|
public void registerBlockIcons(IIconRegister reg) {
|
|
super.registerBlockIcons(reg);
|
|
|
|
if(reg instanceof TextureMap) {
|
|
TextureMap map = (TextureMap) reg;
|
|
|
|
for(NTMMaterial mat : Mats.orderedList) {
|
|
if(mat.solidColorLight != mat.solidColorDark) {
|
|
String placeholderName = this.getTextureName() + "-" + mat.names[0];
|
|
TextureAtlasSpriteMutatable mutableIcon = new TextureAtlasSpriteMutatable(placeholderName, new RGBMutatorInterpolatedComponentRemap(0xFFFFFF, 0x505050, mat.solidColorLight, mat.solidColorDark)).setBlockAtlas();
|
|
map.setTextureEntry(placeholderName, mutableIcon);
|
|
iconMap.put(mat, mutableIcon);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
@Override
|
|
@SideOnly(Side.CLIENT)
|
|
public IIcon getIcon(IBlockAccess world, int x, int y, int z, int side) {
|
|
|
|
TileEntitySlag tile = (TileEntitySlag) world.getTileEntity(x, y, z);
|
|
|
|
if(tile != null && tile.mat != null) {
|
|
IIcon override = iconMap.get(tile.mat);
|
|
if(override != null) {
|
|
return override;
|
|
}
|
|
}
|
|
|
|
return this.blockIcon;
|
|
}
|
|
|
|
@Override
|
|
@SideOnly(Side.CLIENT)
|
|
public int colorMultiplier(IBlockAccess world, int x, int y, int z) {
|
|
|
|
TileEntitySlag tile = (TileEntitySlag) world.getTileEntity(x, y, z);
|
|
|
|
if(tile != null && tile.mat != null) {
|
|
if(!iconMap.containsKey(tile.mat)) {
|
|
return tile.mat.moltenColor;
|
|
}
|
|
}
|
|
|
|
return 0xffffff;
|
|
}
|
|
|
|
@Override
|
|
public boolean isOpaqueCube() {
|
|
return false;
|
|
}
|
|
|
|
@Override
|
|
public void setBlockBoundsBasedOnState(IBlockAccess world, int x, int y, int z) {
|
|
TileEntitySlag tile = (TileEntitySlag) world.getTileEntity(x, y, z);
|
|
if(tile != null) {
|
|
this.setBlockBounds(0F, 0F, 0F, 1F, (float) tile.amount / (float) TileEntitySlag.maxAmount, 1F);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public AxisAlignedBB getCollisionBoundingBoxFromPool(World world, int x, int y, int z) {
|
|
TileEntitySlag tile = (TileEntitySlag) world.getTileEntity(x, y, z);
|
|
if(tile != null) {
|
|
this.setBlockBounds(0F, 0F, 0F, 1F, (float) tile.amount / (float) TileEntitySlag.maxAmount, 1F);
|
|
}
|
|
return AxisAlignedBB.getBoundingBox(x + this.minX, y + this.minY, z + this.minZ, x + this.maxX, y + this.maxY, z + this.maxZ);
|
|
}
|
|
|
|
@Override
|
|
public void updateTick(World world, int x, int y, int z, Random rand) {
|
|
|
|
TileEntity s = Compat.getTileStandard(world, x, y, z);
|
|
TileEntity b = Compat.getTileStandard(world, x, y - 1, z);
|
|
|
|
/* Error here, delete the block */
|
|
if(s == null || !(s instanceof TileEntitySlag)) {
|
|
world.setBlockToAir(x, y, z);
|
|
return;
|
|
}
|
|
|
|
TileEntitySlag self = (TileEntitySlag) s;
|
|
|
|
/* Flow down */
|
|
if(world.getBlock(x, y - 1, z).isReplaceable(world, x, y - 1, z)) {
|
|
world.setBlock(x, y - 1, z, ModBlocks.slag);
|
|
TileEntitySlag tile = (TileEntitySlag) Compat.getTileStandard(world, x, y - 1, z);
|
|
tile.mat = self.mat;
|
|
tile.amount = self.amount;
|
|
world.markBlockForUpdate(x, y - 1, z);
|
|
world.setBlockToAir(x, y, z);
|
|
return;
|
|
} else if(b instanceof TileEntitySlag) {
|
|
|
|
TileEntitySlag below = (TileEntitySlag) b;
|
|
|
|
if(below.mat == self.mat && below.amount < TileEntitySlag.maxAmount) {
|
|
int transfer = Math.min(TileEntitySlag.maxAmount - below.amount, self.amount);
|
|
below.amount += transfer;
|
|
self.amount -= transfer;
|
|
|
|
if(self.amount <= 0){
|
|
world.setBlockToAir(x, y, z);
|
|
} else {
|
|
world.markBlockForUpdate(x, y, z);
|
|
}
|
|
|
|
world.markBlockForUpdate(x, y - 1, z);
|
|
world.scheduleBlockUpdate(x, y - 1, z, ModBlocks.slag, 1);
|
|
return;
|
|
}
|
|
}
|
|
|
|
/* Flow sideways, no neighbors */
|
|
ForgeDirection[] sides = new ForgeDirection[] { ForgeDirection.NORTH, ForgeDirection.SOUTH, ForgeDirection.EAST, ForgeDirection.WEST };
|
|
int count = 0;
|
|
for(ForgeDirection dir : sides) {
|
|
int iX = x + dir.offsetX;
|
|
int iZ = z + dir.offsetZ;
|
|
|
|
if(world.getBlock(iX, y, iZ).isReplaceable(world, iX, y, iZ)) {
|
|
count++;
|
|
}
|
|
}
|
|
|
|
if(self.amount >= self.maxAmount / 5 && count > 0) {
|
|
int toSpread = Math.max(self.amount / (count * 2), 1);
|
|
|
|
for(ForgeDirection dir : sides) {
|
|
int iX = x + dir.offsetX;
|
|
int iZ = z + dir.offsetZ;
|
|
|
|
if(world.getBlock(iX, y, iZ).isReplaceable(world, iX, y, iZ)) {
|
|
world.setBlock(iX, y, iZ, ModBlocks.slag);
|
|
TileEntitySlag tile = (TileEntitySlag) Compat.getTileStandard(world, iX, y, iZ);
|
|
world.markBlockForUpdate(iX, y, iZ);
|
|
world.scheduleBlockUpdate(iX, y, iZ, ModBlocks.slag, 1);
|
|
tile.mat = self.mat;
|
|
tile.amount = toSpread;
|
|
self.amount -= toSpread;
|
|
world.markBlockForUpdate(x, y, z);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void onBlockHarvested(World world, int x, int y, int z, int meta, EntityPlayer player) {
|
|
|
|
if(!player.capabilities.isCreativeMode) {
|
|
harvesters.set(player);
|
|
this.dropBlockAsItem(world, x, y, z, meta, 0);
|
|
harvesters.set(null);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void harvestBlock(World world, EntityPlayer player, int x, int y, int z, int meta) {
|
|
player.addStat(StatList.mineBlockStatArray[getIdFromBlock(this)], 1);
|
|
player.addExhaustion(0.025F);
|
|
}
|
|
|
|
@Override
|
|
public ArrayList<ItemStack> getDrops(World world, int x, int y, int z, int metadata, int fortune) {
|
|
ArrayList<ItemStack> ret = new ArrayList<ItemStack>();
|
|
|
|
TileEntitySlag tile = (TileEntitySlag) world.getTileEntity(x, y, z);
|
|
|
|
if(tile != null && tile.mat != null && tile.amount > 0) {
|
|
ret.add(ItemScraps.create(new MaterialStack(tile.mat, tile.amount)));
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
@Override
|
|
public ItemStack getPickBlock(MovingObjectPosition target, World world, int x, int y, int z, EntityPlayer player) {
|
|
|
|
TileEntitySlag tile = (TileEntitySlag) world.getTileEntity(x, y, z);
|
|
|
|
if(tile != null) {
|
|
return ItemScraps.create(new MaterialStack(tile.mat, tile.amount));
|
|
}
|
|
|
|
return super.getPickBlock(target, world, x, y, z, player);
|
|
}
|
|
|
|
public static class TileEntitySlag extends TileEntity {
|
|
|
|
public NTMMaterial mat;
|
|
public int amount;
|
|
public static int maxAmount = MaterialShapes.BLOCK.q(16);
|
|
|
|
@Override
|
|
public boolean canUpdate() {
|
|
return false;
|
|
}
|
|
|
|
@Override
|
|
public Packet getDescriptionPacket() {
|
|
NBTTagCompound nbt = new NBTTagCompound();
|
|
this.writeToNBT(nbt);
|
|
return new S35PacketUpdateTileEntity(this.xCoord, this.yCoord, this.zCoord, 0, nbt);
|
|
}
|
|
|
|
@Override
|
|
public void onDataPacket(NetworkManager net, S35PacketUpdateTileEntity pkt) {
|
|
this.readFromNBT(pkt.func_148857_g());
|
|
}
|
|
|
|
@Override
|
|
public void readFromNBT(NBTTagCompound nbt) {
|
|
super.readFromNBT(nbt);
|
|
this.mat = Mats.matById.get(nbt.getInteger("mat"));
|
|
this.amount = nbt.getInteger("amount");
|
|
}
|
|
|
|
@Override
|
|
public void writeToNBT(NBTTagCompound nbt) {
|
|
super.writeToNBT(nbt);
|
|
if(this.mat != null) nbt.setInteger("mat", this.mat.id);
|
|
nbt.setInteger("amount", this.amount);
|
|
}
|
|
}
|
|
}
|