public static boolean canPlantStay(World world, int x, int y, int z) { Block block = world.getBlock(x, y - 1, z); if (block != ModBlocks.chorus_plant && block != Blocks.end_stone) { if (block.isAir(world, x, y - 1, z)) { int adjecentCount = 0; for (ForgeDirection dir : ForgeDirection.VALID_DIRECTIONS) { Block adjecentBlock = world.getBlock(x + dir.offsetX, y + dir.offsetY, z + dir.offsetZ); if (adjecentBlock == ModBlocks.chorus_plant) adjecentCount++; else if (!adjecentBlock.isAir(world, x + dir.offsetX, y + dir.offsetY, z + dir.offsetZ)) return false; } return adjecentCount == 1; } else return false; } else return true; }
public static int getItemBurnTimeElectrical(ItemStack itemStack) { if(itemStack == null) { return 0; } else { Item item = itemStack.getItem(); if(item instanceof ItemBlock && Block.getBlockFromItem(item) != Blocks.air) { @SuppressWarnings("unused") Block block = Block.getBlockFromItem(item); } if(item == TechnicalItem.Battery1) return 2560; return 0; } }
/** * returns true if this entity is by a ladder, false otherwise */ public boolean isOnLadder() { int i = MathHelper.floor_double(this.posX); int j = MathHelper.floor_double(this.getEntityBoundingBox().minY); int k = MathHelper.floor_double(this.posZ); if (this instanceof EntityPlayer && ((EntityPlayer)this).isSpectator()) { return false; } else { BlockPos blockpos = new BlockPos(i, j, k); IBlockState iblockstate = this.worldObj.getBlockState(blockpos); Block block = iblockstate.getBlock(); return net.minecraftforge.common.ForgeHooks.isLivingOnLadder(iblockstate, worldObj, new BlockPos(i, j, k), this); } }
public static void pushEntity(IBlockState blockState, BlockPos blockPos, IBlockAccess blockAccess, VertexBuffer wrr) { Block block = blockState.getBlock(); int i; int j; if (blockState instanceof BlockStateBase) { BlockStateBase blockstatebase = (BlockStateBase)blockState; i = blockstatebase.getBlockId(); j = blockstatebase.getMetadata(); } else { i = Block.getIdFromBlock(block); j = block.getMetaFromState(blockState); } i = BlockAliases.getMappedBlockId(i, j); int i1 = block.getRenderType(blockState).ordinal(); int k = ((i1 & 65535) << 16) + (i & 65535); int l = j & 65535; wrr.sVertexBuilder.pushEntity(((long)l << 32) + (long)k); }
public EnumActionResult onItemUse(ItemStack stack, EntityPlayer player, World world, BlockPos pos, EnumHand hand, EnumFacing facing, float hitX, float hitY, float hitZ) { if (stack.getItemDamage() == EnumItems.TIMEMEAL.ordinal() && player.canPlayerEdit(pos, facing, stack)) { Block crops = world.getBlockState(pos).getBlock(); if (crops != null && crops instanceof BlockCrops) { if (crops != UCBlocks.cropMerlinia) world.setBlockState(pos, ((BlockCrops)crops).withAge(0), 2); else if (crops == UCBlocks.cropMerlinia) ((Merlinia)crops).merliniaGrowth(world, pos, world.rand.nextInt(1) + 1); else if (crops instanceof BlockNetherWart) ((BlockNetherWart)crops).updateTick(world, pos, world.getBlockState(pos), world.rand); if (!player.capabilities.isCreativeMode && !player.worldObj.isRemote) stack.stackSize--; UCPacketHandler.sendToNearbyPlayers(world, pos, new PacketUCEffect(EnumParticleTypes.VILLAGER_HAPPY, pos.getX() - 0.5D, pos.getY(), pos.getZ() - 0.5D, 6)); return EnumActionResult.SUCCESS; } } return super.onItemUse(stack, player, world, pos, hand, facing, hitX, hitY, hitZ); }
/** * Merge {@link StatBase} object references for similar blocks */ private static void mergeStatBases(StatBase[] statBaseIn, Block p_151180_1_, Block p_151180_2_) { int i = Block.getIdFromBlock(p_151180_1_); int j = Block.getIdFromBlock(p_151180_2_); if (statBaseIn[i] != null && statBaseIn[j] == null) { statBaseIn[j] = statBaseIn[i]; } else { allStats.remove(statBaseIn[i]); objectMineStats.remove(statBaseIn[i]); generalStats.remove(statBaseIn[i]); statBaseIn[i] = statBaseIn[j]; } }
/** * (abstract) Protected helper method to read subclass entity data from NBT. */ public void readEntityFromNBT(NBTTagCompound tagCompund) { super.readEntityFromNBT(tagCompund); IBlockState iblockstate; if (tagCompund.hasKey("carried", 8)) { iblockstate = Block.getBlockFromName(tagCompund.getString("carried")).getStateFromMeta(tagCompund.getShort("carriedData") & 65535); } else { iblockstate = Block.getBlockById(tagCompund.getShort("carried")).getStateFromMeta(tagCompund.getShort("carriedData") & 65535); } this.setHeldBlockState(iblockstate); }
@Override @SideOnly(Side.CLIENT) public boolean shouldSideBeRendered(IBlockAccess p_149646_1_, int p_149646_2_, int p_149646_3_, int p_149646_4_, int p_149646_5_) { Block block = p_149646_1_.getBlock(p_149646_2_, p_149646_3_, p_149646_4_); if (p_149646_1_.getBlockMetadata(p_149646_2_, p_149646_3_, p_149646_4_) != p_149646_1_.getBlockMetadata(p_149646_2_ - Facing.offsetsXForSide[p_149646_5_], p_149646_3_ - Facing.offsetsYForSide[p_149646_5_], p_149646_4_ - Facing.offsetsZForSide[p_149646_5_])) { return true; } if (block == this) { return false; } return true; }
@SuppressWarnings("unchecked") static <T extends Block> StateMetaMapper<T> create(Collection<IProperty<?>> properties) { if (properties.size() == 0) return new EmptyStateMetaMapper<>(); else if (properties.size() == 1) return new SimpleStateMetaMapper(properties.iterator().next()); else return new BitStateMetaMapper<>(properties); }
public void set(int x, int y, int z, IBlockState state) { if (state instanceof net.minecraftforge.common.property.IExtendedBlockState) state = ((net.minecraftforge.common.property.IExtendedBlockState) state).getClean(); IBlockState iblockstate = this.get(x, y, z); Block block = iblockstate.getBlock(); Block block1 = state.getBlock(); if (block != Blocks.AIR) { --this.blockRefCount; if (block.getTickRandomly()) { --this.tickRefCount; } } if (block1 != Blocks.AIR) { ++this.blockRefCount; if (block1.getTickRandomly()) { ++this.tickRefCount; } } this.data.set(x, y, z, state); }
/** * Called when a Block is destroyed using this Item. Return true to trigger the "Use Item" statistic. */ public boolean onBlockDestroyed(ItemStack stack, World worldIn, Block blockIn, BlockPos pos, EntityLivingBase playerIn) { if ((double)blockIn.getBlockHardness(worldIn, pos) != 0.0D) { stack.damageItem(2, playerIn); } return true; }
public void notifyNeighborsRespectDebug(BlockPos pos, Block blockType, boolean p_175722_3_) { if (this.worldInfo.getTerrainType() != WorldType.DEBUG_WORLD) { this.notifyNeighborsOfStateChange(pos, blockType, p_175722_3_); } }
protected ItemTool(float attackDamageIn, float attackSpeedIn, Item.ToolMaterial materialIn, Set<Block> effectiveBlocksIn) { this.efficiencyOnProperMaterial = 4.0F; this.toolMaterial = materialIn; this.effectiveBlocks = effectiveBlocksIn; this.maxStackSize = 1; this.setMaxDamage(materialIn.getMaxUses()); this.efficiencyOnProperMaterial = materialIn.getEfficiencyOnProperMaterial(); this.damageVsEntity = attackDamageIn + materialIn.getDamageVsEntity(); this.attackSpeed = attackSpeedIn; this.setCreativeTab(CreativeTabs.TOOLS); }
/** * Writes the given blockstate to the given tag. * * @param tag The tag to write to * @param state The blockstate to be written */ public static NBTTagCompound writeBlockState(NBTTagCompound tag, IBlockState state) { tag.setString("Name", ((ResourceLocation)Block.REGISTRY.getNameForObject(state.getBlock())).toString()); if (!state.getProperties().isEmpty()) { NBTTagCompound nbttagcompound = new NBTTagCompound(); for (Entry < IProperty<?>, Comparable<? >> entry : state.getProperties().entrySet()) { IProperty<?> iproperty = (IProperty)entry.getKey(); nbttagcompound.setString(iproperty.getName(), getName(iproperty, (Comparable)entry.getValue())); } tag.setTag("Properties", nbttagcompound); } return tag; }
/** * Gets the block type at the location of this entity (client-only). */ public Block getBlockType() { if (this.blockType == null && this.worldObj != null) { this.blockType = this.worldObj.getBlockState(this.pos).getBlock(); } return this.blockType; }
public IceLands(int par1) { super(par1); this.setBiomeName("Icelands"); this.topBlock = (byte)IceMod.IcyOre.blockID; this.fillerBlock = (byte)Block.ice.blockID; this.theBiomeDecorator.bigMushroomsPerChunk = 10; this.theBiomeDecorator.treesPerChunk = 5; this.theBiomeDecorator.clayPerChunk = 3; this.theBiomeDecorator.reedsPerChunk = 1; this.spawnableMonsterList.add(new SpawnListEntry(EntitySnowman.class, 25, 4, 8)); this.spawnableCreatureList.add(new SpawnListEntry(EntityCow.class, 25, 4, 8)); this.spawnableMonsterList.add(new SpawnListEntry(EntityDragon.class, 1, 1, 1)); this.spawnableMonsterList.add(new SpawnListEntry(EntityIronGolem.class, 1, 1, 1)); this.setMinMaxHeight(0.1F, 0.5F); //mnmx this.setTemperatureRainfall(0.7F, 0.2F); }
public static boolean isBlockBlacklisted(Block block) { ResourceLocation loc = Block.REGISTRY.getNameForObject(block); String[] blackList = UniversalRemoteConfiguration.blacklist.blacklist.split(","); for (String entry : blackList) { String[] parts = entry.split(":"); if (loc.toString().equals(entry)) { return true; } // bad entry? if (parts.length != 2) continue; if (parts[1].equals("*") && loc.getResourceDomain().equals(parts[0])) { return true; } } return false; }
public void registerBlockColorHandler(IBlockColor blockColor, Block... blocksIn) { for (Block block : blocksIn) { if (block == null) throw new IllegalArgumentException("Block registered to block color handler cannot be null!"); if (block.getRegistryName() == null) throw new IllegalArgumentException("Block must be registered before assigning color handler."); this.blockColorMap.put(block.delegate, blockColor); } }
/** * Return true to set given position as destination */ protected boolean shouldMoveTo(World worldIn, BlockPos pos) { if (!worldIn.isAirBlock(pos.up())) { return false; } else { IBlockState iblockstate = worldIn.getBlockState(pos); Block block = iblockstate.getBlock(); if (block == Blocks.chest) { TileEntity tileentity = worldIn.getTileEntity(pos); if (tileentity instanceof TileEntityChest && ((TileEntityChest)tileentity).numPlayersUsing < 1) { return true; } } else { if (block == Blocks.lit_furnace) { return true; } if (block == Blocks.bed && iblockstate.getValue(BlockBed.PART) != BlockBed.EnumPartType.HEAD) { return true; } } return false; } }
private void dropContents() { for (int i = 0; i < this.contents.length; ++i) { if (this.contents[i] != null && this.contents[i].stackSize > 0) { if (this.contents[i] != null) { Block.spawnAsEntity(this.worldObj, (new BlockPos(this)).up(), this.contents[i]); } this.contents[i] = null; } } }
public void writeToNBT(NBTTagCompound compound) { super.writeToNBT(compound); compound.setInteger("blockId", Block.getIdFromBlock(this.pistonState.getBlock())); compound.setInteger("blockData", this.pistonState.getBlock().getMetaFromState(this.pistonState)); compound.setInteger("facing", this.pistonFacing.getIndex()); compound.setFloat("progress", this.lastProgress); compound.setBoolean("extending", this.extending); }
@SuppressWarnings("deprecation") @Override public void neighborChanged(IBlockState state, World worldIn, BlockPos pos, Block blockIn, BlockPos fromPos) { super.neighborChanged(state, worldIn, pos, blockIn, fromPos); this.onNeighborChange(worldIn, pos, fromPos); }
public void set(int x, int y, int z, IBlockState state) { IBlockState iblockstate = this.get(x, y, z); Block block = iblockstate.getBlock(); Block block1 = state.getBlock(); if (block != Blocks.air) { --this.blockRefCount; if (block.getTickRandomly()) { --this.tickRefCount; } } if (block1 != Blocks.air) { ++this.blockRefCount; if (block1.getTickRandomly()) { ++this.tickRefCount; } } this.data[y << 8 | z << 4 | x] = (char)Block.BLOCK_STATE_IDS.get(state); }
@SubscribeEvent public void onItemRegistry(RegistryEvent.Register<Item> e) { e.getRegistry().registerAll(Ref.ITEMS.toArray(new Item[0])); for (Block block : Ref.BLOCKS) e.getRegistry().register(new ItemBlock(block).setRegistryName(block.getRegistryName())); }
protected void writeStructureToNBT(NBTTagCompound tagCompound) { super.writeStructureToNBT(tagCompound); tagCompound.setInteger("CA", Block.blockRegistry.getIDForObject(this.cropTypeA)); tagCompound.setInteger("CB", Block.blockRegistry.getIDForObject(this.cropTypeB)); tagCompound.setInteger("CC", Block.blockRegistry.getIDForObject(this.cropTypeC)); tagCompound.setInteger("CD", Block.blockRegistry.getIDForObject(this.cropTypeD)); }
/** Register the block correctly */ public static void registerBlock(IBlockAdvanced regBlock) { Block block = (Block)regBlock; ItemBlock item; // register the block by itself first BLOCKS_TO_REGISTER.add(block.setUnlocalizedName(block.getRegistryName().toString())); // try to get the ItemBlock if(regBlock.getItemClass() != null) { try { Class<?>[] ctorArgClasses = new Class[regBlock.getItemClassArgs().length + 1]; ctorArgClasses[0] = Block.class; // start with the block for (int idx = 1; idx < ctorArgClasses.length; idx++) { ctorArgClasses[idx] = regBlock.getItemClassArgs()[idx - 1].getClass(); } Constructor<? extends ItemBlock> itemCtor = regBlock.getItemClass().getConstructor(ctorArgClasses); item = itemCtor.newInstance(ObjectArrays.concat(regBlock, regBlock.getItemClassArgs())); } catch (Exception e) { Log.logger.error("Unable to register block " + block.getRegistryName()); return; } // register the ItemBlock if there are no errors ITEMS_TO_REGISTER.add(item.setRegistryName(block.getRegistryName())); } }
@Override public boolean isPossibleSecondary(World world, BlockPos pos, EnumFacing side) { if (!InventoryTools.isInventory(world, pos)) { return false; } // @todo config for harvest area AxisAlignedBB box = new AxisAlignedBB(pos.add(-10, -5, -10), pos.add(10, 5, 10)); for (double x = box.minX ; x <= box.maxX ; x++) { for (double y = box.minY ; y <= box.maxY ; y++) { for (double z = box.minZ ; z <= box.maxZ ; z++) { BlockPos p = new BlockPos(x, y, z); IBlockState state = world.getBlockState(p); if (state.getBlock() == Blocks.FARMLAND) { IBlockState cropState = world.getBlockState(p.up()); Block cropBlock = cropState.getBlock(); boolean hasCrops = cropBlock instanceof IPlantable && state.getBlock().canSustainPlant(world.getBlockState(p), world, p, EnumFacing.UP, (IPlantable) cropBlock); if (hasCrops) { return true; } } } } } return false; }
public Block getMergerBlock(boolean isLevelDown) { if(isLevelDown) return getMergerBlockDownLevel(); else return getMergerBlockUpLevel(); }
@Override public boolean canPlaceBlockAt(World world, BlockPos pos) { Block blockDown = world.getBlockState(pos.down()).getBlock(); if(blockDown == Blocks.LIT_FURNACE ||blockDown == Blocks.FURNACE || blockDown == ExSartagineBlock.range_extension){ return true; } return false; }
@Override public float getDestroySpeed(ItemStack stack, IBlockState state) { Block block = state.getBlock(); if (block == Blocks.WEB) { return 15.0F; } else { Material material = state.getMaterial(); return material != Material.PLANTS && material != Material.VINE && material != Material.CORAL && material != Material.LEAVES && material != Material.GOURD ? 1.0F : 1.5F; } }
public ItemSlab(Block block, ContentBlockSlab content) { super(block, content); singleSlab = block; singleSlabCS = (CSBlock) block; this.content = content; }
static int getValueFromBlock(Block block) { if (block == null) { return 0; } if (block == Blocks.EMERALD_BLOCK) { return emeraldValue * 9; } else if (block == Blocks.DIAMOND_BLOCK) { return diamondValue * 9; } else if (block == Blocks.GOLD_BLOCK) { return goldValue * 9; } return 0; }
public static void setBlockEntityId(TileEntity tileEntity) { if (isRenderingWorld && !isShadowPass && uniformBlockEntityId.isDefined()) { Block block = tileEntity.getBlockType(); int i = Block.getIdFromBlock(block); uniformBlockEntityId.setValue(i); } }
@Nonnull private static ItemStack getSilkTouchBlock(Block block, IBlockState state) { Item item = Item.getItemFromBlock(block); if (item == Items.AIR) { return ItemStack.EMPTY; } else { return new ItemStack(item, 1, block.getMetaFromState(state)); } }
public FlawlessRecipe(ItemStack result, Object... inputs) { this.result = result; final List<Object> stackedList = Arrays.stream(inputs).map(obj -> { if (obj instanceof Item) return new ItemStack((Item) obj); else if (obj instanceof Block) return new ItemStack((Block) obj); else return obj; }).collect(Collectors.toList()); neededItems = ImmutableList.copyOf(stackedList); }
public <T extends Comparable<T>, V extends T> IBlockState withProperty(IProperty<T> property, V value) { if (!this.properties.containsKey(property)) { throw new IllegalArgumentException("Cannot set property " + property + " as it does not exist in " + this.block.getBlockState()); } else if (!property.getAllowedValues().contains(value)) { throw new IllegalArgumentException("Cannot set property " + property + " to " + value + " on block " + Block.blockRegistry.getNameForObject(this.block) + ", it is not an allowed value"); } else { return (IBlockState)(this.properties.get(property) == value ? this : (IBlockState)this.propertyValueTable.get(property, value)); } }
@Override public void updateWheelActions(@Nonnull Set<String> actions, @Nonnull EntityPlayer player, World world, @Nullable BlockPos pos) { ItemStack heldItem = player.getHeldItem(EnumHand.MAIN_HAND); if (ItemStackTools.isValid(heldItem)) { actions.add(StandardWheelActions.ID_SEARCH); } if (pos != null) { actions.add(StandardWheelActions.ID_ROTATE); Block block = world.getBlockState(pos).getBlock(); TileEntity te = world.getTileEntity(pos); if (te instanceof IInventory || (te != null && te.hasCapability(CapabilityItemHandler.ITEM_HANDLER_CAPABILITY, null))) { actions.add(StandardWheelActions.ID_DUMP); actions.add(StandardWheelActions.ID_EXTRACT); actions.add(StandardWheelActions.ID_DUMPORES); actions.add(StandardWheelActions.ID_DUMPBLOCKS); actions.add(StandardWheelActions.ID_DUMPSIMILARINV); if (ItemStackTools.isValid(heldItem)) { actions.add(StandardWheelActions.ID_DUMP1); actions.add(StandardWheelActions.ID_DUMPSIMILAR); } } actions.add(StandardWheelActions.ID_PICKTOOL); if (block instanceof IWheelBlockSupport) { ((IWheelBlockSupport) block).updateWheelActions(actions); } } // actions.add("std.dummy0"); // actions.add("std.dummy1"); // actions.add("std.dummy2"); // actions.add("std.dummy3"); // actions.add("std.dummy4"); // actions.add("std.dummy5"); // actions.add("std.dummy7"); // actions.add("std.dummy8"); // actions.add("std.dummy9"); // actions.add("std.dummy10"); }
/** * Gets the Block specified by the given text string. First checks the block registry, then tries by parsing the * string as an integer ID (deprecated). Warns the sender if we matched by parsing the ID. Throws if the block * wasn't found. Returns the block if it was found. */ public static Block getBlockByText(ICommandSender sender, String id) throws NumberInvalidException { ResourceLocation resourcelocation = new ResourceLocation(id); if (!Block.REGISTRY.containsKey(resourcelocation)) { throw new NumberInvalidException("commands.give.block.notFound", new Object[] {resourcelocation}); } else { return (Block)Block.REGISTRY.getObject(resourcelocation); } }
public ItemSlab(Block block, BlockSlab singleSlab, BlockSlab doubleSlab) { super(block); this.singleSlab = singleSlab; this.doubleSlab = doubleSlab; this.setMaxDamage(0); this.setHasSubtypes(true); }
/** * (abstract) Protected helper method to write subclass entity data to NBT. */ public void writeEntityToNBT(NBTTagCompound tagCompound) { tagCompound.setShort("xTile", (short)this.xTile); tagCompound.setShort("yTile", (short)this.yTile); tagCompound.setShort("zTile", (short)this.zTile); ResourceLocation resourcelocation = (ResourceLocation)Block.blockRegistry.getNameForObject(this.inTile); tagCompound.setString("inTile", resourcelocation == null ? "" : resourcelocation.toString()); tagCompound.setByte("shake", (byte)this.shake); tagCompound.setByte("inGround", (byte)(this.inGround ? 1 : 0)); }