@Override public void onUpdate() { super.onUpdate(); if (worldObj.isRemote && updateDelay > 0) { updateDelay--; if (updateDelay == 0 && clientActive != isActive) { isActive = clientActive; MekanismUtils.updateBlock(worldObj, xCoord, yCoord, zCoord); } } if (!worldObj.isRemote) { if (updateDelay > 0) { updateDelay--; if (updateDelay == 0 && clientActive != isActive) { Mekanism.packetHandler.sendToReceivers( new TileEntityMessage(Coord4D.get(this), getNetworkedData(new ArrayList())), new Range4D(Coord4D.get(this))); } } } }
private void updatePower() { boolean power = worldObj.isBlockIndirectlyGettingPowered(xCoord, yCoord, zCoord); if (redstone != power) { redstone = power; Mekanism.packetHandler.sendToReceivers( new TileEntityMessage(Coord4D.get(this), getNetworkedData(new ArrayList())), new Range4D(Coord4D.get(this))); onPowerChange(); } }
@Override public void setActive(boolean active) { isActive = active; if (clientActive != active && updateDelay == 0) { Mekanism.packetHandler.sendToReceivers( new TileEntityMessage(Coord4D.get(this), getNetworkedData(new ArrayList<Object>())), new Range4D(Coord4D.get(this))); updateDelay = 10; clientActive = active; } }
@Override public void setFacing(short direction) { if (canSetFacing(direction)) { facing = direction; } if (!(facing == clientFacing || worldObj.isRemote)) { Mekanism.packetHandler.sendToReceivers( new TileEntityMessage(Coord4D.get(this), getNetworkedData(new ArrayList())), new Range4D(Coord4D.get(this))); markDirty(); clientFacing = facing; } }
public void loop(TileEntity tileEntity) { iteratedNodes.add(Coord4D.get(tileEntity)); for (EnumFacing side : EnumFacing.VALUES) { Coord4D coord = Coord4D.get(tileEntity).offset(side); if (coord.exists(pointer.getWorld())) { TileEntity tile = coord.getTileEntity(pointer.getWorld()); if (tile != null && isNode(tile) && !iteratedNodes.contains(coord)) { loop(tile); } } } }
@Override public void mouseClicked(int xAxis, int yAxis, int button) { if (xAxis >= xLocation + 1 && xAxis <= xLocation + width - 1 && yAxis >= yLocation + 1 && yAxis <= yLocation + height - 1) { ItemStack stack = mc.thePlayer.inventory.getItemStack(); if (guiObj instanceof GuiMekanism && stack != null && stack.getItem() instanceof ItemGaugeDropper) { TileEntity tile = ((GuiMekanism) guiObj).getTileEntity(); if (tile instanceof ITankManager) { int index = Arrays.asList(((ITankManager) tile).getTanks()).indexOf(infoHandler.getTank()); if (index != -1) { if (button == 0 && Keyboard.isKeyDown(Keyboard.KEY_LSHIFT)) { button = 2; } Mekanism.packetHandler.sendToServer( new DropperUseMessage(Coord4D.get(tile), button, index)); } } } } }
@Override public boolean upgrade(BaseTier upgradeTier) { if (upgradeTier.ordinal() != tier.ordinal() + 1) { return false; } tier = FluidTankTier.values()[upgradeTier.ordinal()]; fluidTank.setCapacity(tier.storage); Mekanism.packetHandler.sendToReceivers( new TileEntityMessage(Coord4D.get(this), getNetworkedData(new ArrayList())), new Range4D(Coord4D.get(this))); markDirty(); return true; }
private static double emit_do( TileEntityElectricBlock emitter, List<ForgeDirection> outputtingSides, double totalToSend, boolean tryAgain) { double remains = totalToSend % outputtingSides.size(); double splitSend = (totalToSend - remains) / outputtingSides.size(); double sent = 0; List<ForgeDirection> toRemove = new ArrayList<ForgeDirection>(); for (ForgeDirection side : outputtingSides) { TileEntity tileEntity = Coord4D.get(emitter).getFromSide(side).getTileEntity(emitter.getWorldObj()); double toSend = splitSend + remains; remains = 0; double prev = sent; sent += emit_do_do(emitter, tileEntity, side, toSend, tryAgain); if (sent - prev == 0) { toRemove.add(side); } } for (ForgeDirection side : toRemove) { outputtingSides.remove(side); } return sent; }
private void doPlenish() { if (usedNodes.size() >= MAX_NODES) { finishedCalc = true; return; } if (activeNodes.isEmpty()) { if (usedNodes.isEmpty()) { Coord4D below = Coord4D.get(this).getFromSide(ForgeDirection.DOWN); if (!canReplace(below, true, true)) { finishedCalc = true; return; } activeNodes.add(below); } else { finishedCalc = true; return; } } Set<Coord4D> toRemove = new HashSet<Coord4D>(); for (Coord4D coord : activeNodes) { if (coord.exists(worldObj)) { if (canReplace(coord, true, false)) { worldObj.setBlock( coord.xCoord, coord.yCoord, coord.zCoord, MekanismUtils.getFlowingBlock(fluidTank.getFluid().getFluid()), 0, 3); setEnergy(getEnergy() - usage.fluidicPlenisherUsage); fluidTank.drain(FluidContainerRegistry.BUCKET_VOLUME, true); } for (ForgeDirection dir : dirs) { Coord4D sideCoord = coord.getFromSide(dir); if (sideCoord.exists(worldObj) && canReplace(sideCoord, true, true)) { activeNodes.add(sideCoord); } } toRemove.add(coord); break; } else { toRemove.add(coord); } } for (Coord4D coord : toRemove) { activeNodes.remove(coord); usedNodes.add(coord); } }
@Override public void validate() { super.validate(); if (worldObj.isRemote) { Mekanism.packetHandler.sendToServer(new DataRequestMessage(Coord4D.get(this))); } }
/** * Whether or not a cable can connect to a specific acceptor. * * @param side - side to check * @param tile - cable TileEntity * @return whether or not the cable can connect to the specific side */ public static boolean canConnectToAcceptor(ForgeDirection side, TileEntity tile) { if (tile == null) { return false; } TileEntity tileEntity = Coord4D.get(tile).getFromSide(side).getTileEntity(tile.getWorldObj()); return isConnectable(tile, tileEntity, side); }
@Override public IHeatTransfer getAdjacent(ForgeDirection side) { if (canConnectHeat(side)) { TileEntity adj = Coord4D.get(this).getFromSide(side).getTileEntity(worldObj); if (adj instanceof IHeatTransfer) { return (IHeatTransfer) adj; } } return null; }
@Override public void onUpdate() { super.onUpdate(); if (worldObj.isRemote) { updateSound(); } if (isFormed()) { getReactor().simulate(); if (!worldObj.isRemote && (getReactor().isBurning() != clientBurning || Math.abs(getReactor().getPlasmaTemp() - clientTemp) > 1000000)) { Mekanism.packetHandler.sendToAllAround( new TileEntityMessage(Coord4D.get(this), getNetworkedData(new ArrayList())), Coord4D.get(this).getTargetPoint(50D)); clientBurning = getReactor().isBurning(); clientTemp = getReactor().getPlasmaTemp(); } } }
@Override public void updateEntity() { if (!worldObj.isRemote && general.destroyDisabledBlocks) { MachineType type = MachineType.get(getBlockType(), getBlockMetadata()); if (type != null && !type.isEnabled()) { Mekanism.logger.info( "[Mekanism] Destroying machine of type '" + type.name + "' at coords " + Coord4D.get(this) + " as according to config."); worldObj.setBlockToAir(xCoord, yCoord, zCoord); return; } } for (ITileComponent component : components) { component.tick(); } onUpdate(); if (!worldObj.isRemote) { openedThisTick.clear(); if (doAutoSync && playersUsing.size() > 0) { for (EntityPlayer player : playersUsing) { Mekanism.packetHandler.sendTo( new TileEntityMessage(Coord4D.get(this), getNetworkedData(new ArrayList())), (EntityPlayerMP) player); } } } ticker++; redstoneLastTick = redstone; }
/** * Gets all the connected energy acceptors, whether IC2-based or BuildCraft-based, surrounding a * specific tile entity. * * @param tileEntity - center tile entity * @return TileEntity[] of connected acceptors */ public static TileEntity[] getConnectedEnergyAcceptors(TileEntity tileEntity) { TileEntity[] acceptors = new TileEntity[] {null, null, null, null, null, null}; for (ForgeDirection orientation : ForgeDirection.VALID_DIRECTIONS) { TileEntity acceptor = Coord4D.get(tileEntity).getFromSide(orientation).getTileEntity(tileEntity.getWorldObj()); if (isEnergyAcceptor(acceptor)) { acceptors[orientation.ordinal()] = acceptor; } } return acceptors; }
/** * Gets all the connected cables around a specific tile entity. * * @param tileEntity - center tile entity * @return TileEntity[] of connected cables */ public static TileEntity[] getConnectedCables(TileEntity tileEntity) { TileEntity[] cables = new TileEntity[] {null, null, null, null, null, null}; for (ForgeDirection orientation : ForgeDirection.VALID_DIRECTIONS) { TileEntity cable = Coord4D.get(tileEntity).getFromSide(orientation).getTileEntity(tileEntity.getWorldObj()); if (isCable(cable)) { cables[orientation.ordinal()] = cable; } } return cables; }
@Override public void mouseClicked(int mouseX, int mouseY, int button) throws IOException { super.mouseClicked(mouseX, mouseY, button); int xAxis = (mouseX - (width - xSize) / 2); int yAxis = (mouseY - (height - ySize) / 2); if (button == 0) { if (xAxis >= 6 && xAxis <= 20 && yAxis >= 6 && yAxis <= 20) { SoundHandler.playSound(SoundEvents.UI_BUTTON_CLICK); Mekanism.packetHandler.sendToServer(new SimpleGuiMessage(Coord4D.get(tileEntity), 1, 10)); } } }
/** * Gets all the connected cables around a specific tile entity. * * @param tileEntity - center tile entity * @return TileEntity[] of connected cables */ public static TileEntity[] getConnectedOutputters(TileEntity tileEntity) { TileEntity[] outputters = new TileEntity[] {null, null, null, null, null, null}; for (ForgeDirection orientation : ForgeDirection.VALID_DIRECTIONS) { TileEntity outputter = Coord4D.get(tileEntity).getFromSide(orientation).getTileEntity(tileEntity.getWorldObj()); if (isOutputter(outputter, orientation)) { outputters[orientation.ordinal()] = outputter; } } return outputters; }
@Override public void mouseClicked(int mouseX, int mouseY, int button) { super.mouseClicked(mouseX, mouseY, button); int xAxis = (mouseX - (width - xSize) / 2); int yAxis = (mouseY - (height - ySize) / 2); if (button == 0) { if (xAxis >= 6 && xAxis <= 20 && yAxis >= 6 && yAxis <= 20) { SoundHandler.playSound("gui.button.press"); MekanismGenerators.packetHandler.sendToServer( new GeneratorsGuiMessage(Coord4D.get(tileEntity), 10)); } } }
/** * Gets the adjacent connections to a TileEntity, from a subset of its sides. * * @param tileEntity - center TileEntity * @param sides - set of sides to check * @return boolean[] of adjacent connections */ public static boolean[] getConnections(TileEntity tileEntity, Set<ForgeDirection> sides) { boolean[] connectable = new boolean[] {false, false, false, false, false, false}; Coord4D coord = Coord4D.get(tileEntity); for (ForgeDirection side : sides) { TileEntity tile = coord.getFromSide(side).getTileEntity(tileEntity.getWorldObj()); connectable[side.ordinal()] |= isEnergyAcceptor(tile) && isConnectable(tileEntity, tile, side); connectable[side.ordinal()] |= isCable(tile); connectable[side.ordinal()] |= isOutputter(tile, side); } return connectable; }
@Override public void setMultiblock(String id) { if (id == null && multiblockUUID != null) { SynchronizedTurbineData.clientRotationMap.remove(multiblockUUID); } super.setMultiblock(id); Coord4D coord = Coord4D.get(this).getFromSide(ForgeDirection.DOWN); TileEntity tile = coord.getTileEntity(worldObj); if (tile instanceof TileEntityTurbineRotor) { ((TileEntityTurbineRotor) tile).updateRotors(); } }
private void activeEmit() { if (fluidTank.getFluid() != null) { TileEntity tileEntity = Coord4D.get(this).offset(EnumFacing.DOWN).getTileEntity(worldObj); if (tileEntity != null && CapabilityUtils.hasCapability( tileEntity, CapabilityFluidHandler.FLUID_HANDLER_CAPABILITY, EnumFacing.UP)) { IFluidHandler handler = CapabilityUtils.getCapability( tileEntity, CapabilityFluidHandler.FLUID_HANDLER_CAPABILITY, EnumFacing.UP); FluidStack toDrain = new FluidStack(fluidTank.getFluid(), Math.min(tier.output, fluidTank.getFluidAmount())); fluidTank.drain(handler.fill(toDrain, true), true); } } }
public int pushUp(FluidStack fluid, boolean doFill) { Coord4D up = Coord4D.get(this).offset(EnumFacing.UP); if (up.getTileEntity(worldObj) instanceof TileEntityFluidTank) { IFluidHandler handler = CapabilityUtils.getCapability( up.getTileEntity(worldObj), CapabilityFluidHandler.FLUID_HANDLER_CAPABILITY, EnumFacing.DOWN); if (PipeUtils.canFill(handler, fluid)) { return handler.fill(fluid, doFill); } } return 0; }
@Override protected void mouseClicked(int x, int y, int button) { super.mouseClicked(x, y, button); if (button == 0) { int xAxis = (x - (width - xSize) / 2); int yAxis = (y - (height - ySize) / 2); if (xAxis > 45 && xAxis < 63 && yAxis > 13 && yAxis < 21) { ArrayList data = new ArrayList(); data.add(0); Mekanism.packetHandler.sendToServer(new TileEntityMessage(Coord4D.get(tileEntity), data)); SoundHandler.playSound("gui.button.press"); } } }
public double getBoost() { int lavaBoost = 0; double netherBoost = 0D; for (ForgeDirection side : ForgeDirection.VALID_DIRECTIONS) { Coord4D coord = Coord4D.get(this).getFromSide(side); if (isLava(coord.xCoord, coord.yCoord, coord.zCoord)) { lavaBoost++; } } if (worldObj.provider.dimensionId == -1) { netherBoost = generators.heatGenerationNether; } return (generators.heatGenerationLava * lavaBoost) + netherBoost; }
public int getCurrentNeeded() { int needed = fluidTank.getCapacity() - fluidTank.getFluidAmount(); Coord4D top = Coord4D.get(this).offset(EnumFacing.UP); TileEntity topTile = top.getTileEntity(worldObj); if (topTile instanceof TileEntityFluidTank) { TileEntityFluidTank topTank = (TileEntityFluidTank) topTile; if (fluidTank.getFluid() != null && topTank.fluidTank.getFluid() != null) { if (fluidTank.getFluid().getFluid() != topTank.fluidTank.getFluid().getFluid()) { return needed; } } needed += topTank.getCurrentNeeded(); } return needed; }
@Override public EnumActionResult onItemUse( ItemStack itemstack, EntityPlayer entityplayer, World world, BlockPos pos, EnumHand hand, EnumFacing side, float posX, float posY, float posZ) { TileEntity tileEntity = world.getTileEntity(pos); if (tileEntity instanceof TileEntityChargepad) { TileEntityChargepad chargepad = (TileEntityChargepad) tileEntity; if (!chargepad.isActive) { if (!world.isRemote) { EntityRobit robit = new EntityRobit(world, pos.getX() + 0.5, pos.getY() + 0.1, pos.getZ() + 0.5); robit.setHome(Coord4D.get(chargepad)); robit.setEnergy(getEnergy(itemstack)); robit.setOwner(entityplayer.getName()); robit.setInventory(getInventory(itemstack)); robit.setCustomNameTag(getName(itemstack)); world.spawnEntityInWorld(robit); } entityplayer.setHeldItem(hand, null); return EnumActionResult.SUCCESS; } } return EnumActionResult.PASS; }
@Override public void onUpdate() { if (worldObj.isRemote) { Mekanism.proxy.registerSound(this); if (updateDelay > 0) { updateDelay--; if (updateDelay == 0 && clientActive != isActive) { isActive = clientActive; MekanismUtils.updateBlock(worldObj, xCoord, yCoord, zCoord); } } } if (!worldObj.isRemote) { if (updateDelay > 0) { updateDelay--; if (updateDelay == 0 && clientActive != isActive) { Mekanism.packetHandler.sendToAll( new TileEntityMessage(Coord4D.get(this), getNetworkedData(new ArrayList()))); } } ChargeUtils.discharge(3, this); if (inventory[0] != null && (injectTank.getGas() == null || injectTank.getStored() < injectTank.getMaxGas())) { injectTank.receive( GasTransmission.removeGas( inventory[0], GasRegistry.getGas("sulfuricAcid"), injectTank.getNeeded()), true); } if (inventory[2] != null && outputTank.getGas() != null) { outputTank.draw(GasTransmission.addGas(inventory[2], outputTank.getGas()), true); } boolean changed = false; if (canOperate() && getEnergy() >= MekanismUtils.getEnergyPerTick(this, ENERGY_USAGE) && injectTank.getStored() >= INJECT_USAGE && MekanismUtils.canFunction(this)) { setActive(true); setEnergy(getEnergy() - MekanismUtils.getEnergyPerTick(this, ENERGY_USAGE)); if (operatingTicks < MekanismUtils.getTicks(this, TICKS_REQUIRED)) { operatingTicks++; injectTank.draw(INJECT_USAGE, true); } else { GasStack stack = RecipeHandler.getItemToGasOutput( inventory[1], true, Recipe.CHEMICAL_DISSOLUTION_CHAMBER.get()); outputTank.receive(stack, true); injectTank.draw(INJECT_USAGE, true); operatingTicks = 0; if (inventory[1].stackSize <= 0) { inventory[1] = null; } markDirty(); } } else { if (prevEnergy >= getEnergy()) { changed = true; setActive(false); } } if (changed && !canOperate()) { operatingTicks = 0; } prevEnergy = getEnergy(); if (outputTank.getGas() != null) { GasStack toSend = new GasStack(outputTank.getGas().getGas(), Math.min(outputTank.getStored(), gasOutput)); TileEntity tileEntity = Coord4D.get(this).getFromSide(MekanismUtils.getRight(facing)).getTileEntity(worldObj); if (tileEntity instanceof IGasHandler) { if (((IGasHandler) tileEntity) .canReceiveGas( MekanismUtils.getRight(facing).getOpposite(), outputTank.getGas().getGas())) { outputTank.draw( ((IGasHandler) tileEntity) .receiveGas(MekanismUtils.getRight(facing).getOpposite(), toSend), true); } } } } }
@Override public void onUpdate() { if (!worldObj.isRemote) { ChargeUtils.discharge(2, this); if (inventory[0] != null) { if (inventory[0].getItem() instanceof IFluidContainerItem && ((IFluidContainerItem) inventory[0].getItem()).getFluid(inventory[0]) != null) { if (((IFluidContainerItem) inventory[0].getItem()) .getFluid(inventory[0]) .getFluid() .canBePlacedInWorld()) { fluidTank.fill(FluidContainerUtils.extractFluid(fluidTank, inventory[0]), true); if (((IFluidContainerItem) inventory[0].getItem()).getFluid(inventory[0]) == null || fluidTank.getFluidAmount() == fluidTank.getCapacity()) { if (inventory[1] == null) { inventory[1] = inventory[0].copy(); inventory[0] = null; markDirty(); } } } } else if (FluidContainerRegistry.isFilledContainer(inventory[0])) { FluidStack itemFluid = FluidContainerRegistry.getFluidForFilledItem(inventory[0]); if ((fluidTank.getFluid() == null && itemFluid.amount <= fluidTank.getCapacity()) || fluidTank.getFluid().amount + itemFluid.amount <= fluidTank.getCapacity()) { if ((fluidTank.getFluid() != null && !fluidTank.getFluid().isFluidEqual(itemFluid)) || !itemFluid.getFluid().canBePlacedInWorld()) { return; } ItemStack containerItem = inventory[0].getItem().getContainerItem(inventory[0]); boolean filled = false; if (containerItem != null) { if (inventory[1] == null || (inventory[1].isItemEqual(containerItem) && inventory[1].stackSize + 1 <= containerItem.getMaxStackSize())) { inventory[0] = null; if (inventory[1] == null) { inventory[1] = containerItem; } else { inventory[1].stackSize++; } filled = true; } } else { inventory[0].stackSize--; if (inventory[0].stackSize == 0) { inventory[0] = null; } filled = true; } if (filled) { fluidTank.fill(itemFluid, true); markDirty(); } } } } if (getEnergy() >= usage.fluidicPlenisherUsage && worldObj.getWorldTime() % 10 == 0 && fluidTank.getFluidAmount() >= FluidContainerRegistry.BUCKET_VOLUME) { if (fluidTank.getFluid().getFluid().canBePlacedInWorld()) { if (!finishedCalc) { doPlenish(); } else { Coord4D below = Coord4D.get(this).getFromSide(ForgeDirection.DOWN); if (canReplace(below, false, false) && getEnergy() >= usage.fluidicPlenisherUsage && fluidTank.getFluidAmount() >= FluidContainerRegistry.BUCKET_VOLUME) { if (fluidTank.getFluid().getFluid().canBePlacedInWorld()) { worldObj.setBlock( below.xCoord, below.yCoord, below.zCoord, MekanismUtils.getFlowingBlock(fluidTank.getFluid().getFluid()), 0, 3); setEnergy(getEnergy() - usage.fluidicPlenisherUsage); fluidTank.drain(FluidContainerRegistry.BUCKET_VOLUME, true); } } } } } } }
@Override public void onUpdate() { if (worldObj.isRemote) { if (updateDelay > 0) { updateDelay--; if (updateDelay == 0 && clientActive != isActive) { isActive = clientActive; MekanismUtils.updateBlock(worldObj, getPos()); } } float targetScale = (float) (fluidTank.getFluid() != null ? fluidTank.getFluid().amount : 0) / fluidTank.getCapacity(); if (Math.abs(prevScale - targetScale) > 0.01) { prevScale = (9 * prevScale + targetScale) / 10; } } else { if (updateDelay > 0) { updateDelay--; if (updateDelay == 0 && clientActive != isActive) { needsPacket = true; } } if (valve > 0) { valve--; if (valve == 0) { valveFluid = null; needsPacket = true; } } if (fluidTank.getFluidAmount() != prevAmount) { MekanismUtils.saveChunk(this); needsPacket = true; } prevAmount = fluidTank.getFluidAmount(); if (inventory[0] != null) { manageInventory(); } if (isActive) { activeEmit(); } int newRedstoneLevel = getRedstoneLevel(); if (newRedstoneLevel != currentRedstoneLevel) { markDirty(); currentRedstoneLevel = newRedstoneLevel; } if (needsPacket) { Mekanism.packetHandler.sendToAllAround( new TileEntityMessage(Coord4D.get(this), getNetworkedData(new ArrayList())), Coord4D.get(this).getTargetPoint(50)); } needsPacket = false; } }