private void trySpawnSticks(World world, BlockPos pos, Random random) {
   int x = pos.getX();
   int y = pos.getY();
   int z = pos.getZ();
   y++;
   if (!world.isAirBlock(new BlockPos(x, y, z))) {
     return;
   }
   y++;
   if (!BlockTools.isTopValidAndSolid(world, pos)) {
     return;
   }
   for (int i = 0; i < 15; i++) {
     if (!world.isAirBlock(new BlockPos(x, y, z))) {
       if (isLeafBlock(world.getBlockState(new BlockPos(x, y, z)).getBlock())) {
         world.setBlockState(
             pos.up(),
             ModBlocks.sticksBlock
                 .getDefaultState()
                 .withProperty(
                     GenericBlock.FACING_HORIZ, EnumFacing.getHorizontal(random.nextInt(4))),
             3);
         SticksTE sticksTE = (SticksTE) world.getTileEntity(pos.up());
         sticksTE.setSticks(random.nextInt(6) + 1);
       }
       return;
     }
     y++;
   }
 }
  private void setDefaultDirection(World world, int x, int y, int z) {

    if (!world.isRemote) {
      Block block1 = world.getBlock(x, y, z - 1);
      Block block2 = world.getBlock(x, y, z + 1);
      Block block3 = world.getBlock(x - 1, y, z);
      Block block4 = world.getBlock(x + 1, y, z);

      byte b = 3;

      if (block1.func_149730_j() && !block2.func_149730_j()) {
        b = 3;
      }
      if (block2.func_149730_j() && !block1.func_149730_j()) {
        b = 2;
      }
      if (block3.func_149730_j() && !block4.func_149730_j()) {
        b = 5;
      }
      if (block4.func_149730_j() && !block3.func_149730_j()) {
        b = 4;
      }

      world.setBlockMetadataWithNotify(x, y, z, b, 2);
    }
  }
Beispiel #3
0
  private void direction(World world, int x, int y, int z) {
    if (!world.isRemote) {
      Block direction = world.getBlock(x, y, z - 1);
      Block direction1 = world.getBlock(x, y, z + 1);
      Block direction2 = world.getBlock(x - 1, y, z);
      Block direction3 = world.getBlock(x + 1, y, z);
      byte byte0 = 3;

      if (direction.func_149730_j() && direction.func_149730_j()) {
        byte0 = 3;
      }

      if (direction1.func_149730_j() && direction1.func_149730_j()) {
        byte0 = 2;
      }

      if (direction2.func_149730_j() && direction2.func_149730_j()) {
        byte0 = 5;
      }

      if (direction3.func_149730_j() && direction3.func_149730_j()) {
        byte0 = 4;
      }

      world.setBlockMetadataWithNotify(x, y, z, byte0, 2);
    }
  }
Beispiel #4
0
  @Override
  public ActionResult<ItemStack> onItemRightClick(
      ItemStack itemStackIn, World worldIn, EntityPlayer playerIn, EnumHand hand) {

    if (!playerIn.capabilities.isCreativeMode) {
      itemStackIn.damageItem(1, playerIn);
      if (itemStackIn.getItemDamage() == 0) {
        itemStackIn = new ItemStack(ModItems.staff);
      }
    }

    worldIn.playSound(
        (EntityPlayer) null,
        playerIn.posX,
        playerIn.posY,
        playerIn.posZ,
        SoundEvents.ENTITY_SNOWBALL_THROW,
        SoundCategory.NEUTRAL,
        0.5F,
        0.4F / (itemRand.nextFloat() * 0.4F + 0.8F));

    if (!worldIn.isRemote) {
      EntityLargeSnowBall snowball = new EntityLargeSnowBall(worldIn, playerIn);
      snowball.setHeadingFromThrower(
          playerIn, playerIn.rotationPitch, playerIn.rotationYaw, 0.0F, 1.5F, 1.0F);
      worldIn.spawnEntityInWorld(snowball);
    }

    return new ActionResult(EnumActionResult.SUCCESS, itemStackIn);
  }
 public void generateStructures(World world, Random rand, BlockPos position, int radius) {
   for (int i = 0; radius >= 0 && i < 3; ++i) {
     int j = radius + rand.nextInt(2);
     int k = (radius + rand.nextInt(2));
     int l = radius + rand.nextInt(2);
     float f = (float) (j + k + l) * 0.333F + 0.5F;
     for (BlockPos blockpos :
         BlockPos.getAllInBox(position.add(-j, -k, -l), position.add(j, k, l))) {
       if (blockpos.distanceSq(position) <= (double) (f * f)
           && world.isAirBlock(blockpos)
           && world
               .getBlockState(blockpos.down())
               .getBlock()
               .getUnlocalizedName()
               .contains("frozen")) {
         int chance = rand.nextInt(100);
         if (chance < 4) {
           int chance2 = rand.nextInt(20);
           System.out.println(chance2);
           switch (chance2) {
             default:
               generateGoldPile(world, rand, blockpos);
               break;
             case 1:
               generateArchNS(world, rand, blockpos);
               break;
             case 2:
               generateArchEW(world, rand, blockpos);
               break;
           }
         }
       }
     }
   }
 }
 public static void unpath(World world, int i, int j, int k) {
   List<ChunkCoordinates> blocks = Lists.newLinkedList();
   List<ChunkCoordinates> notify = Lists.newLinkedList();
   blocks.add(new ChunkCoordinates(i, j, k));
   while (blocks.size() > 0) {
     ChunkCoordinates coords = blocks.remove(0);
     depolarize(world, coords.posX + 1, coords.posY, coords.posZ, blocks);
     depolarize(world, coords.posX, coords.posY + 1, coords.posZ, blocks);
     depolarize(world, coords.posX, coords.posY, coords.posZ + 1, blocks);
     depolarize(world, coords.posX - 1, coords.posY, coords.posZ, blocks);
     depolarize(world, coords.posX, coords.posY - 1, coords.posZ, blocks);
     depolarize(world, coords.posX, coords.posY, coords.posZ - 1, blocks);
     notify.add(coords);
   }
   for (ChunkCoordinates coords : notify) {
     if (world.blockExists(coords.posX, coords.posY, coords.posZ)) {
       world.markBlockForUpdate(coords.posX, coords.posY, coords.posZ);
       world.notifyBlocksOfNeighborChange(
           coords.posX,
           coords.posY,
           coords.posZ,
           world.getBlock(coords.posX, coords.posY, coords.posZ));
     }
   }
 }
  private void controlLoop(World w, int x, int y, int z) {
    ArenaCellEntity ace;

    if (!(w.getBlock(x, y, z) instanceof ArenaCellBlock) || w.getTileEntity(x, y, z) == null)
      return;
    ace = (ArenaCellEntity) w.getTileEntity(x, y, z);

    if (ace.passed) return;

    ace.passed = true;
    aaCounter += 1;

    if (ace.gameUsable) {
      aCounter += 1;

      if (ace.XOwnership == 1) t1T += 1;
      else if (ace.XOwnership == 2) t2T += 1;
      else nT += 1;
    }

    /*if (!ace.gameUsable)
    aInit = false;*/

    controlLoop(w, x, y, z + 1);
    controlLoop(w, x, y, z - 1);

    controlLoop(w, x + 1, y, z);
    controlLoop(w, x - 1, y, z);
  }
 @Override
 public boolean onBlockActivated(
     World world,
     int x,
     int y,
     int z,
     EntityPlayer player,
     int par6,
     float par7,
     float par8,
     float par9) {
   TileEntity tileEntity = world.getTileEntity(x, y, z);
   if (tileEntity != null && tileEntity instanceof TileVendor) {
     TileVendor tileVendor = (TileVendor) world.getTileEntity(x, y, z);
     EntityPlayer playerTest = world.getPlayerEntityByName(tileVendor.playerName);
     if (playerTest == null || !tileVendor.isUseableByPlayer(playerTest)) {
       tileVendor.inUse = false;
     }
     ;
     if (tileVendor.inUse && !player.getDisplayName().contentEquals(tileVendor.playerName)) {
       if (!world.isRemote) {
         player.addChatMessage(
             new ChatComponentText(StatCollector.translateToLocal("chat.warning.inuse")));
       }
       return true;
     } else {
       player.openGui(UniversalCoins.instance, 0, world, x, y, z);
       tileVendor.playerName = player.getDisplayName();
       tileVendor.inUse = true;
       tileVendor.updateCoinsForPurchase();
       return true;
     }
   }
   return false;
 }
 public ItemStack getItemStackWithData(World world, int x, int y, int z) {
   ItemStack stack = new ItemStack(world.getBlock(x, y, z), 1, 0);
   TileEntity tentity = world.getTileEntity(x, y, z);
   if (tentity instanceof TileVendorBlock) {
     TileVendorBlock te = (TileVendorBlock) tentity;
     NBTTagList itemList = new NBTTagList();
     NBTTagCompound tagCompound = new NBTTagCompound();
     for (int i = 0; i < te.getSizeInventory(); i++) {
       ItemStack invStack = te.getStackInSlot(i);
       if (invStack != null) {
         NBTTagCompound tag = new NBTTagCompound();
         tag.setByte("Slot", (byte) i);
         invStack.writeToNBT(tag);
         itemList.appendTag(tag);
       }
     }
     tagCompound.setTag("Inventory", itemList);
     tagCompound.setInteger("CoinSum", te.coinSum);
     tagCompound.setInteger("UserCoinSum", te.userCoinSum);
     tagCompound.setInteger("ItemPrice", te.itemPrice);
     tagCompound.setString("BlockOwner", te.blockOwner);
     tagCompound.setBoolean("Infinite", te.infiniteMode);
     stack.setTagCompound(tagCompound);
     return stack;
   } else return stack;
 }
  /**
   * Lets the block know when one of its neighbor changes. Doesn't know which neighbor changed
   * (coordinates passed are their own) Args: x, y, z, neighbor blockID
   */
  @Override
  public void onNeighborBlockChange(World par1World, int x, int y, int z, int neighborBlockID) {
    super.onNeighborBlockChange(par1World, x, y, z, neighborBlockID);

    if (par1World.getBlockId(x, y, z) == this.blockID) {
      this.setNotStationary(par1World, x, y, z);
    } else if (neighborBlockID == Block.fire.blockID
        || neighborBlockID == Block.lavaMoving.blockID
        || neighborBlockID == Block.lavaStill.blockID) {
      par1World.setBlockWithNotify(x, y, z, Block.fire.blockID);
      par1World.playSoundEffect(
          (double) ((float) x + 0.5F),
          (double) ((float) y + 0.5F),
          (double) ((float) z + 0.5F),
          "random.fizz",
          0.5F,
          2.6F + (par1World.rand.nextFloat() - par1World.rand.nextFloat()) * 0.8F);
      par1World.spawnParticle(
          "largesmoke",
          (double) x + Math.random(),
          (double) y + 1.2D,
          (double) z + Math.random(),
          0.0D,
          0.0D,
          0.0D);
    }
  }
  @Override
  public void onBlockPlacedBy(
      World world, int x, int y, int z, EntityLivingBase entity, ItemStack stack) {
    if (world.isRemote) return;
    if (stack.hasTagCompound()) {
      TileEntity te = world.getTileEntity(x, y, z);
      if (te instanceof TileVendorBlock) {
        TileVendorBlock tentity = (TileVendorBlock) te;
        NBTTagCompound tagCompound = stack.getTagCompound();
        if (tagCompound == null) {
          return;
        }
        NBTTagList tagList = tagCompound.getTagList("Inventory", Constants.NBT.TAG_COMPOUND);
        for (int i = 0; i < tagList.tagCount(); i++) {
          NBTTagCompound tag = (NBTTagCompound) tagList.getCompoundTagAt(i);
          byte slot = tag.getByte("Slot");
          if (slot >= 0 && slot < tentity.getSizeInventory()) {
            tentity.setInventorySlotContents(slot, ItemStack.loadItemStackFromNBT(tag));
          }
        }
        tentity.coinSum = tagCompound.getInteger("CoinSum");
        tentity.userCoinSum = tagCompound.getInteger("UserCoinSum");
        tentity.itemPrice = tagCompound.getInteger("ItemPrice");
        tentity.blockOwner = tagCompound.getString("BlockOwner");
        tentity.infiniteMode = tagCompound.getBoolean("Infinite");
      }
      world.markBlockForUpdate(x, y, z);

    } else {
      // item has no owner so we'll set one and get out of here
      ((TileVendorBlock) world.getTileEntity(x, y, z)).blockOwner = entity.getCommandSenderName();
    }
    int meta = stack.getItemDamage();
    world.setBlockMetadataWithNotify(x, y, z, meta, 2);
  }
  @Override
  public void onBlockAdded(World par1World, int x, int y, int z) {
    super.onBlockAdded(par1World, x, y, z);

    for (byte i = 0; i < 6; i++) {
      Vector3 neighborPosition = new Vector3(x, y, z);
      neighborPosition.modifyPositionFromSide(ForgeDirection.getOrientation(i));

      int neighborBlockID =
          par1World.getBlockId(
              neighborPosition.intX(), neighborPosition.intY(), neighborPosition.intZ());

      if (neighborBlockID == Block.fire.blockID
          || neighborBlockID == Block.lavaMoving.blockID
          || neighborBlockID == Block.lavaStill.blockID) {
        par1World.setBlockWithNotify(x, y, z, Block.fire.blockID);
        par1World.playSoundEffect(
            (double) ((float) x + 0.5F),
            (double) ((float) y + 0.5F),
            (double) ((float) z + 0.5F),
            "random.fizz",
            0.5F,
            2.6F + (par1World.rand.nextFloat() - par1World.rand.nextFloat()) * 0.8F);
        par1World.spawnParticle(
            "largesmoke",
            (double) x + Math.random(),
            (double) y + 1.2D,
            (double) z + Math.random(),
            0.0D,
            0.0D,
            0.0D);
        return;
      }
    }
  }
  /** Returns a list of all Tile Entities matching the class given within the bounding box */
  public static <T extends TileEntity> List<T> getTileEntitiesWithinAABB(
      World world, Class<T> clazz, AxisAlignedBB aabb) {
    List<T> list = new ArrayList<T>();
    int minX = MathHelper.floor_double(aabb.minX - World.MAX_ENTITY_RADIUS);
    int maxX = MathHelper.floor_double(aabb.maxX + World.MAX_ENTITY_RADIUS);
    int minY = MathHelper.floor_double(aabb.minY - World.MAX_ENTITY_RADIUS);
    int maxY = MathHelper.floor_double(aabb.maxY + World.MAX_ENTITY_RADIUS);
    int minZ = MathHelper.floor_double(aabb.minZ - World.MAX_ENTITY_RADIUS);
    int maxZ = MathHelper.floor_double(aabb.maxZ + World.MAX_ENTITY_RADIUS);
    if (!world.checkChunksExist(minX, minY, minZ, maxX, maxY, maxZ)) {
      return list;
    }
    for (int i = minX; i <= maxX; ++i) {
      for (int j = minY; j <= maxY; ++j) {
        for (int k = minZ; k <= maxZ; ++k) {
          TileEntity te = world.getTileEntity(i, j, k);
          if (te != null && clazz.isAssignableFrom(te.getClass())) {
            list.add((T) te);
          }
        }
      }
    }

    return list;
  }
  public ItemStack onItemRightClick(ItemStack itemStackIn, World worldIn, EntityPlayer playerIn) {
    if (playerIn.isSneaking()) {
      if (!playerIn.capabilities.isCreativeMode) {
        --itemStackIn.stackSize;
      }

      worldIn.playSoundAtEntity(
          playerIn, "random.bow", 0.5F, 0.4F / (itemRand.nextFloat() * 0.4F + 0.8F));

      if (!worldIn.isRemote) {
        // EntityEnchantedEbonheart

        worldIn.spawnEntityInWorld(new EntityEnchantedEbonheart(worldIn, playerIn));

        // EntityEnchantedEbonheart entityenchantedebonheart = new EntityEnchantedEbonheart(worldIn,
        // playerIn);
        // entityenchantedebonheart.setHeadingFromThrower(playerIn, playerIn.rotationPitch,
        // playerIn.rotationYaw, -20.0F, 0.7F, 1.0F);
        // worldIn.spawnEntityInWorld(entityenchantedebonheart);

        // EntityExpBottle entityexpbottle = new EntityExpBottle(worldIn, playerIn);
        // entityexpbottle.func_184538_a(playerIn, playerIn.rotationPitch, playerIn.rotationYaw,
        // -20.0F, 0.7F, 1.0F);
        // worldIn.spawnEntityInWorld(entityexpbottle);
      }

      playerIn.triggerAchievement(StatList.objectUseStats[Item.getIdFromItem(this)]);
      return itemStackIn;
    }
    return itemStackIn;
  }
  @Override
  public int onBlockPlaced(
      World par1World,
      int par2,
      int par3,
      int par4,
      int par5,
      float par6,
      float par7,
      float par8,
      int par9) {
    int j1 = par9;

    if ((j1 == 0 || par5 == 0)
        && par1World.isSideSolid(par2, par3, par4 + 1, ForgeDirection.NORTH)) {
      j1 = 0;
    }

    if ((j1 == 0 || par5 == 1)
        && par1World.isSideSolid(par2, par3, par4 - 1, ForgeDirection.SOUTH)) {
      j1 = 1;
    }

    if ((j1 == 0 || par5 == 2)
        && par1World.isSideSolid(par2 + 1, par3, par4, ForgeDirection.WEST)) {
      j1 = 2;
    }

    if ((j1 == 0 || par5 == 3)
        && par1World.isSideSolid(par2 - 1, par3, par4, ForgeDirection.EAST)) {
      j1 = 3;
    }

    return j1;
  }
  public void onTickInGame() {
    world = FMLCommonHandler.instance().getMinecraftServerInstance().worldServerForDimension(0);
    if (world != null) {
      if (!dataRead) {
        WorldSaveToKHandler.readData();
        this.dataRead = true;
      }

      if (td.tdd == 0 && !ConfigFileToK.GuildSpawning && dataRead) {
        if (x.xLocation == 0 && x.yLocation == 0 && x.zLocation == 0) {
          WorldGenGuild wgg =
              new WorldGenGuild(
                  world,
                  world.getWorldInfo().getSpawnX(),
                  world.getWorldInfo().getSpawnZ(),
                  world.getWorldInfo().getSpawnY());
          wgg.CreateGuild();
          spawnGuildMembers(
              world.getWorldInfo().getSpawnX(),
              world.getWorldInfo().getSpawnY(),
              world.getWorldInfo().getSpawnZ());
        } else {
          WorldGenGuild wgg = new WorldGenGuild(world, x.xLocation, x.zLocation, x.yLocation);
          wgg.CreateGuild();
          spawnGuildMembers(x.xLocation, x.yLocation, x.zLocation);
        }
        td.tdd = 1;
        WorldSaveToKHandler.writeData();
      }
    }
  }
 @Override
 public void handle(NetHandler handler, Packet131MapData mapData) {
   ByteArrayDataInput in = ByteStreams.newDataInput(mapData.itemData);
   EntityPlayer player = handler.getPlayer();
   World world = player.worldObj;
   int x;
   int y;
   int z;
   switch (mapData.uniqueID) { // this is your PACKET_ID from above
     case EXPORTER_GUI:
       x = in.readInt();
       y = in.readInt();
       z = in.readInt();
       if (QBEBlockType.NonSolids.EXPORTER.matches(world, x, y, z)) {
         TileEntityExporter eb = (TileEntityExporter) world.getBlockTileEntity(x, y, z);
         eb.xSize = in.readInt();
         eb.ySize = in.readInt();
         eb.zSize = in.readInt();
       }
       break;
     case INTERFACE_GUI_SAVE:
       x = in.readInt();
       y = in.readInt();
       z = in.readInt();
       int dimX = in.readInt();
       int dimY = in.readInt();
       int dimZ = in.readInt();
   }
 }
  @Override
  public void addCollisionBoxesToList(World world, int x, int y, int z, List list) {
    int meta = world.getBlockMetadata(x, y, z);
    int dir = meta & 3;
    TEBloomery te = (TEBloomery) world.getTileEntity(x, y, z);
    if (te.isFlipped) dir = flipDir(dir);
    float f = 0.125F;

    if (!BlockEarlyBloomery.isOpen(meta)) {
      if (dir == 0)
        list.add(new Object[] {AxisAlignedBB.getBoundingBox(0.0F, 0.0F, 0.0f, 1.0f, 1.0F, f)});
      else if (dir == 1)
        list.add(
            new Object[] {AxisAlignedBB.getBoundingBox(1.0f - f, 0.0F, 0.0F, 1.0F, 1.0F, 1.0f)});
      else if (dir == 2)
        list.add(
            new Object[] {AxisAlignedBB.getBoundingBox(0.0f, 0.0F, 1.0f - f, 1.0F, 1.0F, 1.0F)});
      else if (dir == 3)
        list.add(new Object[] {AxisAlignedBB.getBoundingBox(0.0F, 0.0F, 0.0F, f, 1.0F, 1.0F)});
    } else {
      if (dir == 0) {
        list.add(new Object[] {AxisAlignedBB.getBoundingBox(0.0F, 0.0F, 0.0f, f, 1.0F, 0.5F)});
        list.add(new Object[] {AxisAlignedBB.getBoundingBox(1 - f, 0.0F, 0.0f, 1, 1.0F, 0.5F)});
      } else if (dir == 1) {
        list.add(new Object[] {AxisAlignedBB.getBoundingBox(0.5F, 0.0F, 0, 1.0F, 1.0F, f)});
        list.add(new Object[] {AxisAlignedBB.getBoundingBox(0.5F, 0.0F, 1 - f, 1.0F, 1.0F, 1)});
      } else if (dir == 2) {
        list.add(new Object[] {AxisAlignedBB.getBoundingBox(0.0F, 0.0F, 0.5f, f, 1.0F, 1.0F)});
        list.add(new Object[] {AxisAlignedBB.getBoundingBox(1 - f, 0.0F, 0.5f, 1, 1.0F, 1.0F)});
      } else if (dir == 3) {
        list.add(new Object[] {AxisAlignedBB.getBoundingBox(0.0F, 0.0F, 0.0F, 0.5F, 1.0F, f)});
        list.add(new Object[] {AxisAlignedBB.getBoundingBox(0.0F, 0.0F, 1 - f, 0.5F, 1.0F, 1.0)});
      }
    }
  }
  @Override
  public boolean onBlockActivated(
      World worldIn,
      int x,
      int y,
      int z,
      EntityPlayer player,
      int side,
      float subX,
      float subY,
      float subZ) {
    // Play the block break sound and spawn the block break particle effects
    worldIn.playAuxSFXAtEntity(
        player,
        2001,
        x,
        y,
        z,
        Block.getIdFromBlock(this) + (worldIn.getBlockMetadata(x, y, z) << 12));

    if (!worldIn.isRemote) {
      ItemStack itemStack =
          LootSpawns.RubbleMilitaryLoot.getOneItem(
              worldIn.rand); // Get a random item from the loot list
      dropBlockAsItem(worldIn, x, y, z, itemStack); // Drop it in the world

      worldIn.setBlockToAir(x, y, z); // Set this block to air
    }

    return true;
  }
  @Override
  public boolean onBlockActivated(
      World world,
      int x,
      int y,
      int z,
      EntityPlayer entityplayer,
      int par6,
      float par7,
      float par8,
      float par9) {
    if (!canBlockStay(world, x, y, z)) {
      world.setBlockToAir(x, y, z);
      world.spawnEntityInWorld(new EntityItem(world, x, y, z, new ItemStack(this, 1)));
    } else if ((TEBloomery) world.getTileEntity(x, y, z) != null) {
      TEBloomery te = (TEBloomery) world.getTileEntity(x, y, z);
      ItemStack is = entityplayer.getCurrentEquippedItem();

      if (is != null
          && (is.getItem() == TFCItems.FireStarter || is.getItem() == TFCItems.FlintSteel)) {
        if (te.canLight()) entityplayer.getCurrentEquippedItem().damageItem(1, entityplayer);
      } else {
        world.playAuxSFXAtEntity(entityplayer, 1003, x, y, z, 0);
        if (isOpen(world.getBlockMetadata(x, y, z)))
          world.setBlockMetadataWithNotify(x, y, z, world.getBlockMetadata(x, y, z) - 8, 3);
        else world.setBlockMetadataWithNotify(x, y, z, world.getBlockMetadata(x, y, z) + 8, 3);
      }
    }
    return true;
  }
  private void cleanTeamLoop(World w, int x, int y, int z, int team) {
    ArenaCellEntity ace;

    if (!(w.getBlock(x, y, z) instanceof ArenaCellBlock) || w.getTileEntity(x, y, z) == null)
      return;
    ace = (ArenaCellEntity) w.getTileEntity(x, y, z);

    if (ace.passed) return;

    if (ace.ownership == team) {
      w.spawnEntityInWorld(new EntityItem(w, x, y, z, ace.getStack()));
      ace.stackIn = null;
      ace.ownership = 0;
      ace.XOwnership = 0;
    }

    ace.gameUsable = false;
    ace.passed = true;

    w.markBlockForUpdate(x, y, z);

    cleanTeamLoop(w, x, y, z + 1, team);
    cleanTeamLoop(w, x, y, z - 1, team);

    cleanTeamLoop(w, x + 1, y, z, team);
    cleanTeamLoop(w, x - 1, y, z, team);
  }
  @Override
  public boolean canBlockStay(World world, int x, int y, int z) {
    if (world.isAirBlock(x, y, z)) return true;

    if (world.getTileEntity(x, y, z) instanceof TEBloomery) // Prevent ClassCastException
    {
      boolean flipped = false;
      int dir = world.getBlockMetadata(x, y, z) & 3;
      TEBloomery te = (TEBloomery) world.getTileEntity(x, y, z);

      if (te != null) flipped = te.isFlipped;

      if (checkStack(world, x, y, z, dir)) {
        if (checkVertical(world, x, y, z, flipped)) {
          if (checkHorizontal(world, x, y, z, flipped)) return true;
        } else if (te != null && !flipped) {
          this.tryFlip(world, x, y, z);
          flipped = te.isFlipped;
          if (checkVertical(world, x, y, z, flipped)) {
            if (checkHorizontal(world, x, y, z, flipped)) return true;
          }
        }
      }
    }
    return false;
  }
 public void generateGoldPile(World world, Random rand, BlockPos position) {
   int height = 1 + new Random().nextInt(7);
   int chance = rand.nextInt(100);
   if (chance < 20) {
     world.setBlockState(
         position,
         Blocks.CHEST
             .getDefaultState()
             .withProperty(BlockChest.FACING, EnumFacing.HORIZONTALS[new Random().nextInt(3)]),
         3);
     if (world.getBlockState(position).getBlock() instanceof BlockChest) {
       TileEntity tileentity1 = world.getTileEntity(position);
       if (tileentity1 instanceof TileEntityChest
           && !((TileEntityChest) tileentity1).isInvalid()) {
         ((TileEntityChest) tileentity1)
             .setLootTable(WorldGenIceDragonCave.ICEDRAGON_CHEST, new Random().nextLong());
       }
     }
   } else {
     world.setBlockState(
         position,
         ModBlocks.silverPile.getDefaultState().withProperty(BlockGoldPile.LAYERS, height),
         3);
   }
 }
  @Override
  public IMessage onMessage(PacketKurosawaAttack message, MessageContext ctx) {
    EntityPlayer player = ctx.getServerHandler().playerEntity;
    Kurosawa item = (Kurosawa) player.getHeldItem().getItem();

    if (!item.getCooldown()) {
      World world = player.worldObj;
      EntityLivingBase target = (EntityLivingBase) world.getEntityByID(message.targetID);
      Vec3 targetPos = target.getPositionVector();
      Vec3 attackerPos = player.getPositionVector();

      Vec3 distance = targetPos.subtractReverse(attackerPos).normalize();
      distance = new Vec3(distance.xCoord * 3, distance.yCoord * 3, distance.zCoord * 3);

      player.setPositionAndRotation(
          target.posX - distance.xCoord,
          target.posY - distance.yCoord,
          target.posZ - distance.zCoord,
          player.rotationYaw + 180,
          player.rotationPitch);
      player.setRotationYawHead(player.rotationYawHead + 180);
      player.cameraPitch += 180;
      player.setPositionAndUpdate(
          target.posX - distance.xCoord,
          target.posY - distance.yCoord,
          target.posZ - distance.zCoord);
      target.attackEntityFrom(DamageSource.causePlayerDamage(player), 44);
      item.setCooldown();
    }
    return null;
  }
  @Override
  public boolean onBlockStartBreak(ItemStack stack, int x, int y, int z, EntityPlayer player) {
    NBTTagCompound tags = stack.getTagCompound().getCompoundTag("InfiTool");
    World world = player.worldObj;
    int bID = player.worldObj.getBlockId(x, y, z);
    int meta = world.getBlockMetadata(x, y, z);
    Block block = Block.blocksList[bID];
    if (block == null || bID < 1) return false;
    int hlvl = MinecraftForge.getBlockHarvestLevel(block, meta, getHarvestType());
    int shlvl = MinecraftForge.getBlockHarvestLevel(block, meta, getSecondHarvestType());

    if (hlvl <= tags.getInteger("HarvestLevel") && shlvl <= tags.getInteger("HarvestLevel2")) {
      boolean cancelHarvest = false;
      for (ActiveToolMod mod : TConstructRegistry.activeModifiers) {
        if (mod.beforeBlockBreak(this, stack, x, y, z, player)) cancelHarvest = true;
      }

      return cancelHarvest;
    } else {
      if (!player.capabilities.isCreativeMode) onBlockDestroyed(stack, world, bID, x, y, z, player);
      world.setBlockToAir(x, y, z);
      if (!world.isRemote) world.playAuxSFX(2001, x, y, z, bID + (meta << 12));
      return true;
    }
  }
  public void breakBlock(World world, int x, int y, int z, Block p_149749_5_, int meta) {
    System.out.println("Breaking with " + x + ":" + y + ":" + z);
    if (meta == 0) x--;
    if (meta == 1) {
      x--;
      z--;
    }
    if (meta == 2) z--;
    if (meta == 3) {
      x++;
      z--;
    }
    if (meta == 4) x++;
    if (meta == 5) {
      x++;
      z++;
    }
    if (meta == 6) z++;
    if (meta == 7) {
      x--;
      z++;
    }

    System.out.println("Breaking " + x + ":" + y + ":" + z + ":" + world.getBlock(x, y, z));
    world.getBlock(x, y, z).breakBlock(world, x, y, z, world.getBlock(x, y, z), 0);
  }
Beispiel #27
0
  public void onBlockPlacedBy(
      World world, int x, int y, int z, EntityLivingBase entity, ItemStack itemstack) {
    int direction =
        MathHelper.floor_double((double) (entity.rotationYaw * 4.0F / 360.0F) + 0.5D) & 3;

    if (direction == 0) {
      world.setBlockMetadataWithNotify(x, y, z, 2, 2);
    }

    if (direction == 1) {
      world.setBlockMetadataWithNotify(x, y, z, 5, 2);
    }

    if (direction == 2) {
      world.setBlockMetadataWithNotify(x, y, z, 3, 2);
    }

    if (direction == 3) {
      world.setBlockMetadataWithNotify(x, y, z, 4, 2);
    }

    /*if (itemstack.hasDisplayName()) {
    	((Crusher_TileEntity) world.getTileEntity(x, y, z)).crusherName(itemstack.getDisplayName());
    }*/
  }
 @Override
 public boolean canPlaceBlockAt(World par1World, int par2, int par3, int par4) {
   return par1World.isSideSolid(par2 - 1, par3, par4, ForgeDirection.EAST)
       || par1World.isSideSolid(par2 + 1, par3, par4, ForgeDirection.WEST)
       || par1World.isSideSolid(par2, par3, par4 - 1, ForgeDirection.SOUTH)
       || par1World.isSideSolid(par2, par3, par4 + 1, ForgeDirection.NORTH);
 }
 @Override
 public boolean generate(World world, Random rand, int var3, int var4, int var5) {
   for (int i = var3; i < var3 + 16; i++) {
     for (int k = var5; k < var5 + 16; k++) {
       for (int j = 255; j >= var4; --j) {
         Block block = world.getBlock(i, j, k);
         int meta = 0;
         if (block == Blocks.sand) {
           meta = 1;
         } else if (block == Blocks.grass) {
           meta = 2;
         } else if (block == Blocks.clay) {
           meta = 3;
         } else if (block == Blocks.dirt) {
           meta = 2;
         } else {
           continue;
         }
         world.setBlock(i, j, k, Ids.blockFrass, meta, 3);
         break;
       }
     }
   }
   return true;
 }
 private int findCaveSpot(World world, BlockPos pos) {
   boolean air = false;
   int x = pos.getX();
   int y = pos.getY();
   int z = pos.getZ();
   while (y > 1 && !air) {
     if (world.isAirBlock(new BlockPos(x, y, z))) {
       air = true;
     }
     y--;
   }
   if (air) {
     while (y > 1 && air) {
       if (!world.isAirBlock(new BlockPos(x, y, z))) {
         air = false;
       } else {
         y--;
       }
     }
     if (!air) {
       return y;
     }
   }
   return -1;
 }