Examples with MinechemChemicalType minechem.item.MinechemChemicalType used on opensource projects

Example 1 with MinechemChemicalType

use of minechem.item.MinechemChemicalType in project Minechem by iopleke.

the class MinechemUtil method getChemical.

public static MinechemChemicalType getChemical(Block block) {
    MinechemChemicalType chemical = null;
    if (block instanceof IFluidBlock) {
        Fluid fluid = ((IFluidBlock) block).getFluid();
        chemical = getChemical(fluid);
    } else if (block == Blocks.water || block == Blocks.flowing_water) {
        chemical = MoleculeEnum.water;
    }
    return chemical;
}

Example 2 with MinechemChemicalType

use of minechem.item.MinechemChemicalType in project Minechem by iopleke.

the class RadiationHandler method decayElement.

private int decayElement(ItemStack element, RadiationInfo radiationInfo, long currentTime, World world, IInventory inventory, double x, double y, double z) {
    if (element.stackSize == 0) {
        radiationInfo.decayStarted += currentTime - radiationInfo.lastDecayUpdate;
        radiationInfo.lastDecayUpdate = currentTime;
        RadiationInfo.setRadiationInfo(radiationInfo, element);
        return 0;
    }
    radiationInfo.lastDecayUpdate = currentTime;
    long lifeTime = currentTime - radiationInfo.decayStarted - radiationInfo.radioactivity.getLife();
    if (lifeTime > 0) {
        int damage = radiationInfo.radioactivity.getDamage() * element.stackSize;
        Item item = element.getItem();
        if (item == MinechemItemsRegistration.element) {
            radiationInfo = ElementItem.decay(element, world);
        } else if (item == MinechemItemsRegistration.molecule) {
            radiationInfo = RadiationMoleculeHandler.getInstance().handleRadiationMolecule(world, element, inventory, x, y, z);
        } else if (item instanceof MinechemBucketItem) {
            MinechemChemicalType type = ((MinechemBucketItem) item).chemical;
            if (type instanceof ElementEnum) {
                element.func_150996_a(MinechemBucketHandler.getInstance().buckets.get(FluidHelper.elementsBlocks.get(FluidHelper.elements.get(ElementEnum.getByID(((ElementEnum) type).atomicNumber())))));
                radiationInfo = ElementItem.initiateRadioactivity(element, world);
            } else {
                radiationInfo = RadiationMoleculeHandler.getInstance().handleRadiationMoleculeBucket(world, element, inventory, x, y, z);
            }
        }
        RadiationInfo.setRadiationInfo(radiationInfo, element);
        return damage;
    }
    RadiationInfo.setRadiationInfo(radiationInfo, element);
    return 0;
}

Example 3 with MinechemChemicalType

use of minechem.item.MinechemChemicalType in project Minechem by iopleke.

the class FluidChemicalDispenser method dispense.

@Override
public ItemStack dispense(IBlockSource blockSource, ItemStack itemStack) {
    EnumFacing enumfacing = BlockDispenser.func_149937_b(blockSource.getBlockMetadata());
    World world = blockSource.getWorld();
    int x = blockSource.getXInt() + enumfacing.getFrontOffsetX();
    int y = blockSource.getYInt() + enumfacing.getFrontOffsetY();
    int z = blockSource.getZInt() + enumfacing.getFrontOffsetZ();
    TileEntity inventoryTile = blockSource.getBlockTileEntity();
    if (itemStack.getItem() instanceof ElementItem && itemStack.getItemDamage() != 0) {
        Block frontBlock = world.getBlock(x, y, z);
        MinechemChemicalType chemical = MinechemUtil.getChemical(frontBlock);
        if (chemical != null && MinechemUtil.canDrain(world, frontBlock, x, y, z)) {
            ItemStack stack = MinechemUtil.createItemStack(chemical, 8);
            if (stack != null) {
                if (itemStack.stackSize >= 8) {
                    itemStack.stackSize -= 8;
                } else {
                    if (inventoryTile instanceof IInventory) {
                        int needs = 8 - itemStack.stackSize;
                        IInventory inventory = (IInventory) inventoryTile;
                        Set<ItemStack> otherTubes = MinechemUtil.findItemStacks(inventory, MinechemItemsRegistration.element, 0);
                        int free = 0;
                        otherTubes.remove(itemStack);
                        for (ItemStack emptyStack : otherTubes) {
                            free += emptyStack.stackSize;
                        }
                        if (free < needs) {
                            return itemStack;
                        }
                        itemStack.stackSize = 0;
                        for (ItemStack emptyStack : otherTubes) {
                            if (emptyStack.stackSize >= needs) {
                                emptyStack.stackSize -= needs;
                                needs = 0;
                            } else {
                                needs -= emptyStack.stackSize;
                                emptyStack.stackSize = 0;
                            }
                            if (emptyStack.stackSize <= 0) {
                                MinechemUtil.removeStackInInventory(inventory, emptyStack);
                            }
                            if (needs == 0) {
                                break;
                            }
                        }
                    }
                }
                TileEntity tile = world.getTileEntity(x, y, z);
                if (tile instanceof RadiationFluidTileEntity && ((RadiationFluidTileEntity) tile).info != null) {
                    RadiationInfo.setRadiationInfo(((RadiationFluidTileEntity) tile).info, stack);
                }
                world.setBlockToAir(x, y, z);
                if (inventoryTile instanceof IInventory) {
                    stack = MinechemUtil.addItemToInventory((IInventory) inventoryTile, stack);
                }
                MinechemUtil.throwItemStack(world, stack, x, y, z);
            }
        }
    } else {
        IInventory inventory;
        Block block;
        if (inventoryTile instanceof IInventory) {
            inventory = (IInventory) inventoryTile;
        } else {
            return itemStack;
        }
        if (itemStack.getItem() instanceof ElementItem) {
            ElementEnum element = ElementItem.getElement(itemStack);
            block = FluidHelper.elementsBlocks.get(FluidHelper.elements.get(element));
        } else if (itemStack.getItem() instanceof MoleculeItem) {
            MoleculeEnum molecule = MoleculeEnum.getById(itemStack.getItemDamage());
            block = FluidHelper.moleculeBlocks.get(FluidHelper.molecules.get(molecule));
        } else {
            return itemStack;
        }
        if (!world.isAirBlock(x, y, z) && !world.getBlock(x, y, z).getMaterial().isSolid()) {
            world.func_147480_a(x, y, z, true);
            world.setBlockToAir(x, y, z);
        }
        if (world.isAirBlock(x, y, z)) {
            RadiationInfo radioactivity = ElementItem.getRadiationInfo(itemStack, world);
            long worldtime = world.getTotalWorldTime();
            long leftTime = radioactivity.radioactivity.getLife() - (worldtime - radioactivity.decayStarted);
            if (itemStack.stackSize >= 8) {
                itemStack.stackSize -= 8;
            } else {
                int needs = 8 - itemStack.stackSize;
                itemStack.stackSize = 0;
                Set<ItemStack> otherItemsStacks = MinechemUtil.findItemStacks(inventory, itemStack.getItem(), itemStack.getItemDamage());
                otherItemsStacks.remove(itemStack);
                int free = 0;
                for (ItemStack stack : otherItemsStacks) {
                    free += stack.stackSize;
                }
                if (free < needs) {
                    return itemStack;
                }
                for (ItemStack stack : otherItemsStacks) {
                    RadiationInfo anotherRadiation = ElementItem.getRadiationInfo(stack, world);
                    long anotherLeft = anotherRadiation.radioactivity.getLife() - (worldtime - anotherRadiation.decayStarted);
                    if (anotherLeft < leftTime) {
                        radioactivity = anotherRadiation;
                        leftTime = anotherLeft;
                    }
                    if (stack.stackSize >= needs) {
                        stack.stackSize -= needs;
                        needs = 0;
                    } else {
                        needs -= stack.stackSize;
                        stack.stackSize = 0;
                    }
                    if (stack.stackSize <= 0) {
                        MinechemUtil.removeStackInInventory(inventory, stack);
                    }
                    if (needs == 0) {
                        break;
                    }
                }
            }
            ItemStack empties = MinechemUtil.addItemToInventory(inventory, new ItemStack(MinechemItemsRegistration.element, 8, 0));
            MinechemUtil.throwItemStack(world, empties, x, y, z);
            world.setBlock(x, y, z, block, 0, 3);
            TileEntity tile = world.getTileEntity(x, y, z);
            if (radioactivity.isRadioactive() && tile instanceof RadiationFluidTileEntity) {
                ((RadiationFluidTileEntity) tile).info = radioactivity;
            }
        }
        return itemStack;
    // Block block = null;
    // RadiationEnum radioactivity = null;
    // if (itemStack.getItem() instanceof ElementItem)
    // {
    // ElementEnum element = ElementItem.getElement(itemStack);
    // block = FluidHelper.elementsBlocks.get(FluidHelper.elements.get(element));
    // radioactivity = element.radioactivity();
    // } else if (itemStack.getItem() instanceof MoleculeItem)
    // {
    // MoleculeEnum molecule = MoleculeEnum.getById(itemStack.getItemDamage());
    // block = FluidHelper.moleculeBlocks.get(FluidHelper.molecules.get(molecule));
    // radioactivity = molecule.radioactivity();
    // }
    // 
    // if (!world.isAirBlock(x, y, z) && !world.getBlock(x, y, z).getMaterial().isSolid())
    // {
    // world.func_147480_a(x, y, z, true);
    // world.setBlockToAir(x, y, z);
    // }
    // 
    // if (world.isAirBlock(x, y, z) && block != null)
    // {
    // world.setBlock(x, y, z, block, 0, 3);
    // --itemStack.stackSize;
    // TileEntity tile = world.getTileEntity(x, y, z);
    // if (radioactivity != RadiationEnum.stable && tile instanceof RadiationFluidTileEntity)
    // {
    // ((RadiationFluidTileEntity) tile).info = ElementItem.getRadiationInfo(itemStack, world);
    // }
    // ItemStack elementStack = new ItemStack(MinechemItemsRegistration.element, 1, ElementEnum.heaviestMass);
    // TileEntity inventoryTile = blockSource.getBlockTileEntity();
    // if (inventoryTile instanceof IInventory)
    // {
    // elementStack = MinechemUtil.addItemToInventory((IInventory) inventoryTile, elementStack);
    // }
    // MinechemUtil.throwItemStack(world, elementStack, x, y, z);
    // }
    }
    return itemStack;
}

Example 4 with MinechemChemicalType

use of minechem.item.MinechemChemicalType in project Minechem by iopleke.

the class MinechemFluidBlock method checkToExplode.

private void checkToExplode(World world, int x, int y, int z) {
    MinechemChemicalType type = MinechemUtil.getChemical(this);
    float level = ExplosiveFluidHandler.getInstance().getExplosiveFluid(type);
    if (Float.isNaN(level)) {
        return;
    }
    boolean flag = false;
    for (EnumFacing face : EnumFacing.values()) {
        if (ExplosiveFluidHandler.getInstance().existingFireSource(world.getBlock(x + face.getFrontOffsetX(), y + face.getFrontOffsetY(), z + face.getFrontOffsetZ()))) {
            flag = true;
            break;
        }
    }
    if (!flag) {
        return;
    }
    world.func_147480_a(x, y, z, true);
    world.setBlockToAir(x, y, z);
    world.createExplosion(null, x, y, z, ExplosiveFluidHandler.getInstance().getExplosiveFluid(type), true);
}

Example 5 with MinechemChemicalType

use of minechem.item.MinechemChemicalType in project Minechem by iopleke.

the class MinechemFluidBlock method onBlockDestroyedByExplosion.

@Override
public void onBlockDestroyedByExplosion(World world, int x, int y, int z, Explosion explosion) {
    if (world.isRemote) {
        return;
    }
    MinechemChemicalType type = MinechemUtil.getChemical(this);
    world.func_147480_a(x, y, z, true);
    world.setBlockToAir(x, y, z);
    world.createExplosion(null, x, y, z, ExplosiveFluidHandler.getInstance().getExplosiveFluid(type), true);
}