private void checkForHarden(World world, int i, int j, int k) {
   Material material = blockMaterial;
   Material material1 = Material.water;
   if (material == Material.water) {
     material1 = Material.lava;
   }
   boolean flag = false;
   if (flag || world.getBlockMaterial(i, j, k - 1) == material1) {
     flag = true;
   }
   if (flag || world.getBlockMaterial(i, j, k + 1) == material1) {
     flag = true;
   }
   if (flag || world.getBlockMaterial(i - 1, j, k) == material1) {
     flag = true;
   }
   if (flag || world.getBlockMaterial(i + 1, j, k) == material1) {
     flag = true;
   }
   if (flag || world.getBlockMaterial(i, j + 1, k) == material1) {
     flag = true;
   }
   if (flag) {
     if (material == Material.lava) {
       world.setBlockWithNotify(i, j, k, Block.obsidian.blockID);
     } else {
       world.setBlockWithNotify(i, j, k, Block.cobblestone.blockID);
     }
   }
 }
  /** Dispense the specified stack, play the dispense sound and spawn particles. */
  public ItemStack dispenseStack(IBlockSource par1IBlockSource, ItemStack par2ItemStack) {
    EnumFacing var3 = EnumFacing.func_82600_a(par1IBlockSource.func_82620_h());
    World var4 = par1IBlockSource.getWorld();
    double var5 = par1IBlockSource.getX() + (double) ((float) var3.func_82601_c() * 1.125F);
    double var7 = par1IBlockSource.getY();
    double var9 = par1IBlockSource.getZ() + (double) ((float) var3.func_82599_e() * 1.125F);
    int var11 = par1IBlockSource.getXInt() + var3.func_82601_c();
    int var12 = par1IBlockSource.getYInt();
    int var13 = par1IBlockSource.getZInt() + var3.func_82599_e();
    Material var14 = var4.getBlockMaterial(var11, var12, var13);
    double var15;

    if (Material.water.equals(var14)) {
      var15 = 1.0D;
    } else {
      if (!Material.air.equals(var14)
          || !Material.water.equals(var4.getBlockMaterial(var11, var12 - 1, var13))) {
        return this.defaultItemDispenseBehavior.dispense(par1IBlockSource, par2ItemStack);
      }

      var15 = 0.0D;
    }

    EntityBoat var17 = new EntityBoat(var4, var5, var7 + var15, var9);
    var4.spawnEntityInWorld(var17);
    par2ItemStack.splitStack(1);
    return par2ItemStack;
  }
Exemple #3
0
 /** Returns whether or not the specified creature type can spawn at the specified location. */
 public static boolean canCreatureTypeSpawnAtLocation(
     EnumCreatureType par0EnumCreatureType, World par1World, int par2, int par3, int par4) {
   if (par0EnumCreatureType.getCreatureMaterial() == Material.water) {
     return par1World.getBlockMaterial(par2, par3, par4).isLiquid()
         && !par1World.isBlockNormalCube(par2, par3 + 1, par4);
   } else {
     int i = par1World.getBlockId(par2, par3 - 1, par4);
     return Block.isNormalCube(i)
         && i != Block.bedrock.blockID
         && !par1World.isBlockNormalCube(par2, par3, par4)
         && !par1World.getBlockMaterial(par2, par3, par4).isLiquid()
         && !par1World.isBlockNormalCube(par2, par3 + 1, par4);
   }
 }
Exemple #4
0
  /** Attempts to place the liquid contained inside the bucket. */
  public boolean tryPlaceContainedLiquid(
      World par1World, double par2, double par4, double par6, int par8, int par9, int par10) {
    if (this.isFull <= 0) {
      return false;
    } else if (!par1World.isAirBlock(par8, par9, par10)
        && par1World.getBlockMaterial(par8, par9, par10).isSolid()) {
      return false;
    } else {
      if (par1World.provider.isHellWorld && this.isFull == Block.waterMoving.blockID) {
        par1World.playSoundEffect(
            par2 + 0.5D,
            par4 + 0.5D,
            par6 + 0.5D,
            "random.fizz",
            0.5F,
            2.6F + (par1World.rand.nextFloat() - par1World.rand.nextFloat()) * 0.8F);

        for (int var11 = 0; var11 < 8; ++var11) {
          par1World.spawnParticle(
              "largesmoke",
              (double) par8 + Math.random(),
              (double) par9 + Math.random(),
              (double) par10 + Math.random(),
              0.0D,
              0.0D,
              0.0D);
        }
      } else {
        par1World.setBlock(par8, par9, par10, this.isFull, 0, 3);
      }

      return true;
    }
  }
 public ItemStack onItemRightClick(ItemStack itemstack, World world, EntityPlayer entityplayer) {
   MovingObjectPosition movingobjectposition = func_40402_a(world, entityplayer, true);
   if (movingobjectposition == null) {
     return itemstack;
   }
   if (movingobjectposition.typeOfHit == EnumMovingObjectType.TILE) {
     int i = movingobjectposition.blockX;
     int j = movingobjectposition.blockY;
     int k = movingobjectposition.blockZ;
     if (!world.canMineBlock(entityplayer, i, j, k)) {
       return itemstack;
     }
     if (!entityplayer.canPlayerEdit(i, j, k)) {
       return itemstack;
     }
     if (world.getBlockMaterial(i, j, k) == Material.water) {
       itemstack.stackSize--;
       if (itemstack.stackSize <= 0) {
         return new ItemStack(Item.potion);
       }
       if (!entityplayer.inventory.addItemStackToInventory(new ItemStack(Item.potion))) {
         entityplayer.dropPlayerItem(new ItemStack(Item.potion.shiftedIndex, 1, 0));
       }
     }
   }
   return itemstack;
 }
Exemple #6
0
 public ItemStack onItemRightClick(ItemStack itemstack, World world, EntityPlayer entityplayer) {
   MovingObjectPosition movingobjectposition = func_40402_a(world, entityplayer, true);
   if (movingobjectposition == null) {
     return itemstack;
   }
   if (movingobjectposition.typeOfHit == EnumMovingObjectType.TILE) {
     int i = movingobjectposition.blockX;
     int j = movingobjectposition.blockY;
     int k = movingobjectposition.blockZ;
     if (!world.canMineBlock(entityplayer, i, j, k)) {
       return itemstack;
     }
     if (!entityplayer.func_35190_e(i, j, k)) {
       return itemstack;
     }
     if (world.getBlockMaterial(i, j, k) == Material.water
         && world.getBlockMetadata(i, j, k) == 0
         && world.isAirBlock(i, j + 1, k)) {
       world.setBlockWithNotify(i, j + 1, k, Block.waterlily.blockID);
       if (!entityplayer.capabilities.depleteBuckets) {
         itemstack.stackSize--;
       }
     }
   }
   return itemstack;
 }
 public void onNeighborBlockChange(World world, int i, int j, int k, int l) {
   super.onNeighborBlockChange(world, i, j, k, l);
   Material material = world.getBlockMaterial(i, j + 1, k);
   if (material.isSolid()) {
     world.setBlockWithNotify(i, j, k, Block.dirt.blockID);
   }
 }
  /**
   * 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
   */
  public void onNeighborBlockChange(World par1World, int par2, int par3, int par4, int par5) {
    super.onNeighborBlockChange(par1World, par2, par3, par4, par5);
    Material material = par1World.getBlockMaterial(par2, par3 + 1, par4);

    if (material.isSolid()) {
      par1World.setBlockWithNotify(par2, par3, par4, Block.dirt.blockID);
    }
  }
 /**
  * Checks to see if its valid to put this block at the specified coordinates. Args: world, x, y, z
  */
 @Override
 public boolean canPlaceBlockAt(World par1World, int par2, int par3, int par4) {
   if (!par1World.getBlockMaterial(par2, par3 - 1, par4).isSolid()) {
     return false;
   } else {
     return super.canPlaceBlockAt(par1World, par2, par3, par4);
   }
 }
Exemple #10
0
 public boolean canPlaceBlockAt(World world, int i, int j, int k) {
   if (world.getBlockId(i, j - 1, k) == blockID) {
     return false;
   }
   if (!world.getBlockMaterial(i, j - 1, k).isSolid()) {
     return false;
   } else {
     return super.canPlaceBlockAt(world, i, j, k);
   }
 }
 private boolean liquidCanDisplaceBlock(World world, int i, int j, int k) {
   Material material = world.getBlockMaterial(i, j, k);
   if (material == blockMaterial) {
     return false;
   }
   if (material == Material.lava) {
     return false;
   } else {
     return !blockBlocksFlow(world, i, j, k);
   }
 }
Exemple #12
0
  /**
   * Forces lava to check to see if it is colliding with water, and then decide what it should
   * harden to.
   */
  private void checkForHarden(World par1World, int par2, int par3, int par4) {
    if (par1World.getBlockId(par2, par3, par4) == this.blockID) {
      if (this.blockMaterial == Material.lava) {
        boolean var5 = false;

        if (var5 || par1World.getBlockMaterial(par2, par3, par4 - 1) == Material.water) {
          var5 = true;
        }

        if (var5 || par1World.getBlockMaterial(par2, par3, par4 + 1) == Material.water) {
          var5 = true;
        }

        if (var5 || par1World.getBlockMaterial(par2 - 1, par3, par4) == Material.water) {
          var5 = true;
        }

        if (var5 || par1World.getBlockMaterial(par2 + 1, par3, par4) == Material.water) {
          var5 = true;
        }

        if (var5 || par1World.getBlockMaterial(par2, par3 + 1, par4) == Material.water) {
          var5 = true;
        }

        if (var5) {
          int var6 = par1World.getBlockMetadata(par2, par3, par4);

          if (var6 == 0) {
            par1World.setBlockWithNotify(par2, par3, par4, Block.obsidian.blockID);
          } else if (var6 <= 4) {
            par1World.setBlockWithNotify(par2, par3, par4, Block.cobblestone.blockID);
          }

          this.triggerLavaMixEffects(par1World, par2, par3, par4);
        }
      }
    }
  }
  /** returns true if there's water nearby (x-4 to x+4, y to y+1, k-4 to k+4) */
  private boolean isWaterNearby(World par1World, int par2, int par3, int par4) {
    for (int i = par2 - 4; i <= par2 + 4; i++) {
      for (int j = par3; j <= par3 + 1; j++) {
        for (int k = par4 - 4; k <= par4 + 4; k++) {
          if (par1World.getBlockMaterial(i, j, k) == Material.water) {
            return true;
          }
        }
      }
    }

    return false;
  }
  private boolean isWaterNearby(World world, int i, int j, int k) {
    for (int l = i - 4; l <= i + 4; l++) {
      for (int i1 = j; i1 <= j + 1; i1++) {
        for (int j1 = k - 4; j1 <= k + 4; j1++) {
          if (world.getBlockMaterial(l, i1, j1) == Material.water) {
            return true;
          }
        }
      }
    }

    return false;
  }
Exemple #15
0
  /**
   * Returns a boolean array indicating which flow directions are optimal based on each direction's
   * calculated flow cost. Each array index corresponds to one of the four cardinal directions. A
   * value of true indicates the direction is optimal.
   */
  private boolean[] getOptimalFlowDirections(World par1World, int par2, int par3, int par4) {
    int var5;
    int var6;

    for (var5 = 0; var5 < 4; ++var5) {
      this.flowCost[var5] = 1000;
      var6 = par2;
      int var8 = par4;

      if (var5 == 0) {
        var6 = par2 - 1;
      }

      if (var5 == 1) {
        ++var6;
      }

      if (var5 == 2) {
        var8 = par4 - 1;
      }

      if (var5 == 3) {
        ++var8;
      }

      if (!this.blockBlocksFlow(par1World, var6, par3, var8)
          && (par1World.getBlockMaterial(var6, par3, var8) != this.blockMaterial
              || par1World.getBlockMetadata(var6, par3, var8) != 0)) {
        if (this.blockBlocksFlow(par1World, var6, par3 - 1, var8)) {
          this.flowCost[var5] = this.calculateFlowCost(par1World, var6, par3, var8, 1, var5);
        } else {
          this.flowCost[var5] = 0;
        }
      }
    }

    var5 = this.flowCost[0];

    for (var6 = 1; var6 < 4; ++var6) {
      if (this.flowCost[var6] < var5) {
        var5 = this.flowCost[var6];
      }
    }

    for (var6 = 0; var6 < 4; ++var6) {
      this.isOptimalFlowDirection[var6] = this.flowCost[var6] == var5;
    }

    return this.isOptimalFlowDirection;
  }
Exemple #16
0
  /**
   * calculateFlowCost(World world, int x, int y, int z, int accumulatedCost, int
   * previousDirectionOfFlow) - Used to determine the path of least resistance, this method returns
   * the lowest possible flow cost for the direction of flow indicated. Each necessary horizontal
   * flow adds to the flow cost.
   */
  private int calculateFlowCost(World par1World, int par2, int par3, int par4, int par5, int par6) {
    int var7 = 1000;

    for (int var8 = 0; var8 < 4; ++var8) {
      if ((var8 != 0 || par6 != 1)
          && (var8 != 1 || par6 != 0)
          && (var8 != 2 || par6 != 3)
          && (var8 != 3 || par6 != 2)) {
        int var9 = par2;
        int var11 = par4;

        if (var8 == 0) {
          var9 = par2 - 1;
        }

        if (var8 == 1) {
          ++var9;
        }

        if (var8 == 2) {
          var11 = par4 - 1;
        }

        if (var8 == 3) {
          ++var11;
        }

        if (!this.blockBlocksFlow(par1World, var9, par3, var11)
            && (par1World.getBlockMaterial(var9, par3, var11) != this.blockMaterial
                || par1World.getBlockMetadata(var9, par3, var11) != 0)) {
          if (!this.blockBlocksFlow(par1World, var9, par3 - 1, var11)) {
            return par5;
          }

          if (par5 < 4) {
            int var12 = this.calculateFlowCost(par1World, var9, par3, var11, par5 + 1, var8);

            if (var12 < var7) {
              var7 = var12;
            }
          }
        }
      }
    }

    return var7;
  }
  private boolean[] getOptimalFlowDirections(World world, int i, int j, int k) {
    for (int l = 0; l < 4; l++) {
      flowCost[l] = 1000;
      int j1 = i;
      int i2 = j;
      int j2 = k;
      if (l == 0) {
        j1--;
      }
      if (l == 1) {
        j1++;
      }
      if (l == 2) {
        j2--;
      }
      if (l == 3) {
        j2++;
      }
      if (blockBlocksFlow(world, j1, i2, j2)
          || world.getBlockMaterial(j1, i2, j2) == blockMaterial
              && world.getBlockMetadata(j1, i2, j2) == 0) {
        continue;
      }
      if (!blockBlocksFlow(world, j1, i2 - 1, j2)) {
        flowCost[l] = 0;
      } else {
        flowCost[l] = calculateFlowCost(world, j1, i2, j2, 1, l);
      }
    }

    int i1 = flowCost[0];
    for (int k1 = 1; k1 < 4; k1++) {
      if (flowCost[k1] < i1) {
        i1 = flowCost[k1];
      }
    }

    for (int l1 = 0; l1 < 4; l1++) {
      isOptimalFlowDirection[l1] = flowCost[l1] == i1;
    }

    return isOptimalFlowDirection;
  }
  private int calculateFlowCost(World world, int i, int j, int k, int l, int i1) {
    int j1 = 1000;
    for (int k1 = 0; k1 < 4; k1++) {
      if (k1 == 0 && i1 == 1 || k1 == 1 && i1 == 0 || k1 == 2 && i1 == 3 || k1 == 3 && i1 == 2) {
        continue;
      }
      int l1 = i;
      int i2 = j;
      int j2 = k;
      if (k1 == 0) {
        l1--;
      }
      if (k1 == 1) {
        l1++;
      }
      if (k1 == 2) {
        j2--;
      }
      if (k1 == 3) {
        j2++;
      }
      if (blockBlocksFlow(world, l1, i2, j2)
          || world.getBlockMaterial(l1, i2, j2) == blockMaterial
              && world.getBlockMetadata(l1, i2, j2) == 0) {
        continue;
      }
      if (!blockBlocksFlow(world, l1, i2 - 1, j2)) {
        return l;
      }
      if (l >= 4) {
        continue;
      }
      int k2 = calculateFlowCost(world, l1, i2, j2, l + 1, k1);
      if (k2 < j1) {
        j1 = k2;
      }
    }

    return j1;
  }
Exemple #19
0
  /**
   * Called whenever this item is equipped and the right mouse button is pressed. Args: itemStack,
   * world, entityPlayer
   */
  public ItemStack onItemRightClick(
      ItemStack par1ItemStack, World par2World, EntityPlayer par3EntityPlayer) {
    MovingObjectPosition var4 =
        this.getMovingObjectPositionFromPlayer(par2World, par3EntityPlayer, true);

    if (var4 == null) {
      return par1ItemStack;
    } else {
      if (var4.typeOfHit == EnumMovingObjectType.TILE) {
        int var5 = var4.blockX;
        int var6 = var4.blockY;
        int var7 = var4.blockZ;

        if (!par2World.canMineBlock(par3EntityPlayer, var5, var6, var7)) {
          return par1ItemStack;
        }

        if (!par3EntityPlayer.canPlayerEdit(var5, var6, var7)) {
          return par1ItemStack;
        }

        if (par2World.getBlockMaterial(var5, var6, var7) == Material.water) {
          --par1ItemStack.stackSize;

          if (par1ItemStack.stackSize <= 0) {
            return new ItemStack(Item.potion);
          }

          if (!par3EntityPlayer.inventory.addItemStackToInventory(new ItemStack(Item.potion))) {
            par3EntityPlayer.dropPlayerItem(new ItemStack(Item.potion.shiftedIndex, 1, 0));
          }
        }
      }

      return par1ItemStack;
    }
  }
Exemple #20
0
 /**
  * Returns the amount of fluid decay at the coordinates, or -1 if the block at the coordinates is
  * not the same material as the fluid.
  */
 protected int getFlowDecay(World par1World, int par2, int par3, int par4) {
   return par1World.getBlockMaterial(par2, par3, par4) == this.blockMaterial
       ? par1World.getBlockMetadata(par2, par3, par4)
       : -1;
 }
Exemple #21
0
  /** The main spawning algorithm, spawns three random creatures of types in the subclass array */
  public static final int performSpawning(World par0World, boolean par1, boolean par2) {
    if (!par1 && !par2) {
      return 0;
    } else {
      eligibleChunksForSpawning.clear();
      int var3;
      int var6;

      for (var3 = 0; var3 < par0World.playerEntities.size(); ++var3) {
        EntityPlayer var4 = (EntityPlayer) par0World.playerEntities.get(var3);
        int var5 = MathHelper.floor_double(var4.posX / 16.0D);
        var6 = MathHelper.floor_double(var4.posZ / 16.0D);
        byte var7 = 8;

        for (int var8 = -var7; var8 <= var7; ++var8) {
          for (int var9 = -var7; var9 <= var7; ++var9) {
            boolean var10 = var8 == -var7 || var8 == var7 || var9 == -var7 || var9 == var7;
            ChunkCoordIntPair var11 = new ChunkCoordIntPair(var8 + var5, var9 + var6);

            if (!var10) {
              eligibleChunksForSpawning.put(var11, Boolean.valueOf(false));
            } else if (!eligibleChunksForSpawning.containsKey(var11)) {
              eligibleChunksForSpawning.put(var11, Boolean.valueOf(true));
            }
          }
        }
      }

      var3 = 0;
      ChunkCoordinates var31 = par0World.getSpawnPoint();
      EnumCreatureType[] var32 = EnumCreatureType.values();
      var6 = var32.length;

      for (int var33 = 0; var33 < var6; ++var33) {
        EnumCreatureType var34 = var32[var33];

        if ((!var34.getPeacefulCreature() || par2)
            && (var34.getPeacefulCreature() || par1)
            && par0World.countEntities(var34.getCreatureClass())
                <= var34.getMaxNumberOfCreature() * eligibleChunksForSpawning.size() / 256) {
          Iterator var35 = eligibleChunksForSpawning.keySet().iterator();
          label108:
          while (var35.hasNext()) {
            ChunkCoordIntPair var37 = (ChunkCoordIntPair) var35.next();

            if (!((Boolean) eligibleChunksForSpawning.get(var37)).booleanValue()) {
              ChunkPosition var36 =
                  getRandomSpawningPointInChunk(par0World, var37.chunkXPos, var37.chunkZPos);
              int var12 = var36.x;
              int var13 = var36.y;
              int var14 = var36.z;

              if (!par0World.isBlockNormalCube(var12, var13, var14)
                  && par0World.getBlockMaterial(var12, var13, var14)
                      == var34.getCreatureMaterial()) {
                int var15 = 0;
                int var16 = 0;

                while (var16 < 3) {
                  int var17 = var12;
                  int var18 = var13;
                  int var19 = var14;
                  byte var20 = 6;
                  SpawnListEntry var21 = null;
                  int var22 = 0;

                  while (true) {
                    if (var22 < 4) {
                      label101:
                      {
                        var17 += par0World.rand.nextInt(var20) - par0World.rand.nextInt(var20);
                        var18 += par0World.rand.nextInt(1) - par0World.rand.nextInt(1);
                        var19 += par0World.rand.nextInt(var20) - par0World.rand.nextInt(var20);

                        if (canCreatureTypeSpawnAtLocation(var34, par0World, var17, var18, var19)) {
                          float var23 = (float) var17 + 0.5F;
                          float var24 = (float) var18;
                          float var25 = (float) var19 + 0.5F;

                          if (par0World.getClosestPlayer(
                                  (double) var23, (double) var24, (double) var25, 24.0D)
                              == null) {
                            float var26 = var23 - (float) var31.posX;
                            float var27 = var24 - (float) var31.posY;
                            float var28 = var25 - (float) var31.posZ;
                            float var29 = var26 * var26 + var27 * var27 + var28 * var28;

                            if (var29 >= 576.0F) {
                              if (var21 == null) {
                                var21 = par0World.getRandomMob(var34, var17, var18, var19);

                                if (var21 == null) {
                                  break label101;
                                }
                              }

                              EntityLiving var38;

                              try {
                                var38 =
                                    (EntityLiving)
                                        var21
                                            .entityClass
                                            .getConstructor(new Class[] {World.class})
                                            .newInstance(new Object[] {par0World});
                              } catch (Exception var30) {
                                var30.printStackTrace();
                                return var3;
                              }

                              var38.setLocationAndAngles(
                                  (double) var23,
                                  (double) var24,
                                  (double) var25,
                                  par0World.rand.nextFloat() * 360.0F,
                                  0.0F);

                              if (var38.getCanSpawnHere()) {
                                ++var15;
                                par0World.spawnEntityInWorld(var38);
                                creatureSpecificInit(var38, par0World, var23, var24, var25);

                                if (var15 >= var38.getMaxSpawnedInChunk()) {
                                  continue label108;
                                }
                              }

                              var3 += var15;
                            }
                          }
                        }

                        ++var22;
                        continue;
                      }
                    }

                    ++var16;
                    break;
                  }
                }
              }
            }
          }
        }
      }

      return var3;
    }
  }
Exemple #22
0
  /** A randomly called display update to be able to add particles or other items for display */
  public void randomDisplayTick(World par1World, int par2, int par3, int par4, Random par5Random) {
    int var6;

    if (this.blockMaterial == Material.water) {
      if (par5Random.nextInt(10) == 0) {
        var6 = par1World.getBlockMetadata(par2, par3, par4);

        if (var6 <= 0 || var6 >= 8) {
          par1World.spawnParticle(
              "suspended",
              (double) ((float) par2 + par5Random.nextFloat()),
              (double) ((float) par3 + par5Random.nextFloat()),
              (double) ((float) par4 + par5Random.nextFloat()),
              0.0D,
              0.0D,
              0.0D);
        }
      }

      for (var6 = 0; var6 < 0; ++var6) {
        int var7 = par5Random.nextInt(4);
        int var8 = par2;
        int var9 = par4;

        if (var7 == 0) {
          var8 = par2 - 1;
        }

        if (var7 == 1) {
          ++var8;
        }

        if (var7 == 2) {
          var9 = par4 - 1;
        }

        if (var7 == 3) {
          ++var9;
        }

        if (par1World.getBlockMaterial(var8, par3, var9) == Material.air
            && (par1World.getBlockMaterial(var8, par3 - 1, var9).blocksMovement()
                || par1World.getBlockMaterial(var8, par3 - 1, var9).isLiquid())) {
          float var10 = 0.0625F;
          double var11 = (double) ((float) par2 + par5Random.nextFloat());
          double var13 = (double) ((float) par3 + par5Random.nextFloat());
          double var15 = (double) ((float) par4 + par5Random.nextFloat());

          if (var7 == 0) {
            var11 = (double) ((float) par2 - var10);
          }

          if (var7 == 1) {
            var11 = (double) ((float) (par2 + 1) + var10);
          }

          if (var7 == 2) {
            var15 = (double) ((float) par4 - var10);
          }

          if (var7 == 3) {
            var15 = (double) ((float) (par4 + 1) + var10);
          }

          double var17 = 0.0D;
          double var19 = 0.0D;

          if (var7 == 0) {
            var17 = (double) (-var10);
          }

          if (var7 == 1) {
            var17 = (double) var10;
          }

          if (var7 == 2) {
            var19 = (double) (-var10);
          }

          if (var7 == 3) {
            var19 = (double) var10;
          }

          par1World.spawnParticle("splash", var11, var13, var15, var17, 0.0D, var19);
        }
      }
    }

    if (this.blockMaterial == Material.water && par5Random.nextInt(64) == 0) {
      var6 = par1World.getBlockMetadata(par2, par3, par4);

      if (var6 > 0 && var6 < 8) {
        par1World.playSound(
            (double) ((float) par2 + 0.5F),
            (double) ((float) par3 + 0.5F),
            (double) ((float) par4 + 0.5F),
            "liquid.water",
            par5Random.nextFloat() * 0.25F + 0.75F,
            par5Random.nextFloat() * 1.0F + 0.5F);
      }
    }

    double var21;
    double var23;
    double var22;

    if (this.blockMaterial == Material.lava
        && par1World.getBlockMaterial(par2, par3 + 1, par4) == Material.air
        && !par1World.isBlockOpaqueCube(par2, par3 + 1, par4)) {
      if (par5Random.nextInt(100) == 0) {
        var21 = (double) ((float) par2 + par5Random.nextFloat());
        var22 = (double) par3 + this.maxY;
        var23 = (double) ((float) par4 + par5Random.nextFloat());
        par1World.spawnParticle("lava", var21, var22, var23, 0.0D, 0.0D, 0.0D);
        par1World.playSound(
            var21,
            var22,
            var23,
            "liquid.lavapop",
            0.2F + par5Random.nextFloat() * 0.2F,
            0.9F + par5Random.nextFloat() * 0.15F);
      }

      if (par5Random.nextInt(200) == 0) {
        par1World.playSound(
            (double) par2,
            (double) par3,
            (double) par4,
            "liquid.lava",
            0.2F + par5Random.nextFloat() * 0.2F,
            0.9F + par5Random.nextFloat() * 0.15F);
      }
    }

    if (par5Random.nextInt(10) == 0
        && par1World.doesBlockHaveSolidTopSurface(par2, par3 - 1, par4)
        && !par1World.getBlockMaterial(par2, par3 - 2, par4).blocksMovement()) {
      var21 = (double) ((float) par2 + par5Random.nextFloat());
      var22 = (double) par3 - 1.05D;
      var23 = (double) ((float) par4 + par5Random.nextFloat());

      if (this.blockMaterial == Material.water) {
        par1World.spawnParticle("dripWater", var21, var22, var23, 0.0D, 0.0D, 0.0D);
      } else {
        par1World.spawnParticle("dripLava", var21, var22, var23, 0.0D, 0.0D, 0.0D);
      }
    }
  }
 public boolean canBlockStay(World world, int i, int j, int k) {
   return world.getBlockMaterial(i, j - 1, k).isSolid();
 }
Exemple #24
0
 /**
  * Checks to see if its valid to put this block at the specified coordinates. Args: world, x, y, z
  */
 public boolean canPlaceBlockAt(World par1World, int par2, int par3, int par4) {
   int var5 = par1World.getBlockId(par2, par3 - 1, par4);
   return var5 != 0 && (var5 == Block.leaves.blockID || Block.blocksList[var5].isOpaqueCube())
       ? par1World.getBlockMaterial(par2, par3 - 1, par4).blocksMovement()
       : false;
 }
Exemple #25
0
 /**
  * Can this block stay at this position. Similar to canPlaceBlockAt except gets checked often with
  * plants.
  */
 public boolean canBlockStay(World par1World, int par2, int par3, int par4) {
   return par1World.getBlockMaterial(par2, par3 - 1, par4).isSolid();
 }
Exemple #26
0
  /** Ticks the block if it's been scheduled */
  public void updateTick(World par1World, int par2, int par3, int par4, Random par5Random) {
    int var6 = this.getFlowDecay(par1World, par2, par3, par4);
    byte var7 = 1;

    if (this.blockMaterial == Material.lava && !par1World.provider.isHellWorld) {
      var7 = 2;
    }

    boolean var8 = true;
    int var9 = this.tickRate(par1World);
    int var11;

    if (var6 > 0) {
      byte var10 = -100;
      this.numAdjacentSources = 0;
      int var13 = this.getSmallestFlowDecay(par1World, par2 - 1, par3, par4, var10);
      var13 = this.getSmallestFlowDecay(par1World, par2 + 1, par3, par4, var13);
      var13 = this.getSmallestFlowDecay(par1World, par2, par3, par4 - 1, var13);
      var13 = this.getSmallestFlowDecay(par1World, par2, par3, par4 + 1, var13);
      var11 = var13 + var7;

      if (var11 >= 8 || var13 < 0) {
        var11 = -1;
      }

      if (this.getFlowDecay(par1World, par2, par3 + 1, par4) >= 0) {
        int var12 = this.getFlowDecay(par1World, par2, par3 + 1, par4);

        if (var12 >= 8) {
          var11 = var12;
        } else {
          var11 = var12 + 8;
        }
      }

      if (this.numAdjacentSources >= 2 && this.blockMaterial == Material.water) {
        if (par1World.getBlockMaterial(par2, par3 - 1, par4).isSolid()) {
          var11 = 0;
        } else if (par1World.getBlockMaterial(par2, par3 - 1, par4) == this.blockMaterial
            && par1World.getBlockMetadata(par2, par3 - 1, par4) == 0) {
          var11 = 0;
        }
      }

      if (this.blockMaterial == Material.lava
          && var6 < 8
          && var11 < 8
          && var11 > var6
          && par5Random.nextInt(4) != 0) {
        var9 *= 4;
      }

      if (var11 == var6) {
        if (var8) {
          this.updateFlow(par1World, par2, par3, par4);
        }
      } else {
        var6 = var11;

        if (var11 < 0) {
          par1World.setBlockToAir(par2, par3, par4);
        } else {
          par1World.setBlockMetadata(par2, par3, par4, var11, 2);
          par1World.scheduleBlockUpdate(par2, par3, par4, this.blockID, var9);
          par1World.notifyBlocksOfNeighborChange(par2, par3, par4, this.blockID);
        }
      }
    } else {
      this.updateFlow(par1World, par2, par3, par4);
    }

    if (this.liquidCanDisplaceBlock(par1World, par2, par3 - 1, par4)) {
      if (this.blockMaterial == Material.lava
          && par1World.getBlockMaterial(par2, par3 - 1, par4) == Material.water) {
        par1World.setBlock(par2, par3 - 1, par4, Block.stone.blockID);
        this.triggerLavaMixEffects(par1World, par2, par3 - 1, par4);
        return;
      }

      if (var6 >= 8) {
        this.flowIntoBlock(par1World, par2, par3 - 1, par4, var6);
      } else {
        this.flowIntoBlock(par1World, par2, par3 - 1, par4, var6 + 8);
      }
    } else if (var6 >= 0 && (var6 == 0 || this.blockBlocksFlow(par1World, par2, par3 - 1, par4))) {
      boolean[] var14 = this.getOptimalFlowDirections(par1World, par2, par3, par4);
      var11 = var6 + var7;

      if (var6 >= 8) {
        var11 = 1;
      }

      if (var11 >= 8) {
        return;
      }

      if (var14[0]) {
        this.flowIntoBlock(par1World, par2 - 1, par3, par4, var11);
      }

      if (var14[1]) {
        this.flowIntoBlock(par1World, par2 + 1, par3, par4, var11);
      }

      if (var14[2]) {
        this.flowIntoBlock(par1World, par2, par3, par4 - 1, var11);
      }

      if (var14[3]) {
        this.flowIntoBlock(par1World, par2, par3, par4 + 1, var11);
      }
    }
  }
Exemple #27
0
 /** Returns true if the block at the coordinates can be displaced by the liquid. */
 private boolean liquidCanDisplaceBlock(World par1World, int par2, int par3, int par4) {
   Material var5 = par1World.getBlockMaterial(par2, par3, par4);
   return var5 == this.blockMaterial
       ? false
       : (var5 == Material.lava ? false : !this.blockBlocksFlow(par1World, par2, par3, par4));
 }
Exemple #28
0
  public boolean generate(World world, Random random, int i, int j, int k) {
    i -= 8;
    for (k -= 8; j > 0 && world.isAirBlock(i, j, k); j--) {}
    j -= 4;
    boolean aflag[] = new boolean[2048];
    int l = random.nextInt(4) + 4;
    for (int i1 = 0; i1 < l; i1++) {
      double d = random.nextDouble() * 6D + 3D;
      double d1 = random.nextDouble() * 4D + 2D;
      double d2 = random.nextDouble() * 6D + 3D;
      double d3 = random.nextDouble() * (16D - d - 2D) + 1.0D + d / 2D;
      double d4 = random.nextDouble() * (8D - d1 - 4D) + 2D + d1 / 2D;
      double d5 = random.nextDouble() * (16D - d2 - 2D) + 1.0D + d2 / 2D;
      for (int j4 = 1; j4 < 15; j4++) {
        for (int k4 = 1; k4 < 15; k4++) {
          for (int l4 = 1; l4 < 7; l4++) {
            double d6 = ((double) j4 - d3) / (d / 2D);
            double d7 = ((double) l4 - d4) / (d1 / 2D);
            double d8 = ((double) k4 - d5) / (d2 / 2D);
            double d9 = d6 * d6 + d7 * d7 + d8 * d8;
            if (d9 < 1.0D) {
              aflag[(j4 * 16 + k4) * 8 + l4] = true;
            }
          }
        }
      }
    }

    for (int j1 = 0; j1 < 16; j1++) {
      for (int j2 = 0; j2 < 16; j2++) {
        for (int j3 = 0; j3 < 8; j3++) {
          boolean flag =
              !aflag[(j1 * 16 + j2) * 8 + j3]
                  && (j1 < 15 && aflag[((j1 + 1) * 16 + j2) * 8 + j3]
                      || j1 > 0 && aflag[((j1 - 1) * 16 + j2) * 8 + j3]
                      || j2 < 15 && aflag[(j1 * 16 + (j2 + 1)) * 8 + j3]
                      || j2 > 0 && aflag[(j1 * 16 + (j2 - 1)) * 8 + j3]
                      || j3 < 7 && aflag[(j1 * 16 + j2) * 8 + (j3 + 1)]
                      || j3 > 0 && aflag[(j1 * 16 + j2) * 8 + (j3 - 1)]);
          if (!flag) {
            continue;
          }
          Material material = world.getBlockMaterial(i + j1, j + j3, k + j2);
          if (j3 >= 4 && material.getIsLiquid()) {
            return false;
          }
          if (j3 < 4
              && !material.isSolid()
              && world.getBlockId(i + j1, j + j3, k + j2) != field_15005_a) {
            return false;
          }
        }
      }
    }

    for (int k1 = 0; k1 < 16; k1++) {
      for (int k2 = 0; k2 < 16; k2++) {
        for (int k3 = 0; k3 < 8; k3++) {
          if (aflag[(k1 * 16 + k2) * 8 + k3]) {
            world.setBlock(i + k1, j + k3, k + k2, k3 < 4 ? field_15005_a : 0);
          }
        }
      }
    }

    for (int l1 = 0; l1 < 16; l1++) {
      for (int l2 = 0; l2 < 16; l2++) {
        for (int l3 = 4; l3 < 8; l3++) {
          if (aflag[(l1 * 16 + l2) * 8 + l3]
              && world.getBlockId(i + l1, (j + l3) - 1, k + l2) == Block.dirt.blockID
              && world.getSavedLightValue(EnumSkyBlock.Sky, i + l1, j + l3, k + l2) > 0) {
            world.setBlock(i + l1, (j + l3) - 1, k + l2, Block.grass.blockID);
          }
        }
      }
    }

    if (Block.blocksList[field_15005_a].blockMaterial == Material.lava) {
      for (int i2 = 0; i2 < 16; i2++) {
        for (int i3 = 0; i3 < 16; i3++) {
          for (int i4 = 0; i4 < 8; i4++) {
            boolean flag1 =
                !aflag[(i2 * 16 + i3) * 8 + i4]
                    && (i2 < 15 && aflag[((i2 + 1) * 16 + i3) * 8 + i4]
                        || i2 > 0 && aflag[((i2 - 1) * 16 + i3) * 8 + i4]
                        || i3 < 15 && aflag[(i2 * 16 + (i3 + 1)) * 8 + i4]
                        || i3 > 0 && aflag[(i2 * 16 + (i3 - 1)) * 8 + i4]
                        || i4 < 7 && aflag[(i2 * 16 + i3) * 8 + (i4 + 1)]
                        || i4 > 0 && aflag[(i2 * 16 + i3) * 8 + (i4 - 1)]);
            if (flag1
                && (i4 < 4 || random.nextInt(2) != 0)
                && world.getBlockMaterial(i + i2, j + i4, k + i3).isSolid()) {
              world.setBlock(i + i2, j + i4, k + i3, Block.stone.blockID);
            }
          }
        }
      }
    }
    return true;
  }
Exemple #29
0
  /**
   * Called whenever this item is equipped and the right mouse button is pressed. Args: itemStack,
   * world, entityPlayer
   */
  public ItemStack onItemRightClick(
      ItemStack par1ItemStack, World par2World, EntityPlayer par3EntityPlayer) {
    float var4 = 1.0F;
    double var5 =
        par3EntityPlayer.prevPosX
            + (par3EntityPlayer.posX - par3EntityPlayer.prevPosX) * (double) var4;
    double var7 =
        par3EntityPlayer.prevPosY
            + (par3EntityPlayer.posY - par3EntityPlayer.prevPosY) * (double) var4
            + 1.62D
            - (double) par3EntityPlayer.yOffset;
    double var9 =
        par3EntityPlayer.prevPosZ
            + (par3EntityPlayer.posZ - par3EntityPlayer.prevPosZ) * (double) var4;
    boolean var11 = this.isFull == 0;
    MovingObjectPosition var12 =
        this.getMovingObjectPositionFromPlayer(par2World, par3EntityPlayer, var11);

    if (var12 == null) {
      return par1ItemStack;
    } else {
      if (var12.typeOfHit == EnumMovingObjectType.TILE) {
        int var13 = var12.blockX;
        int var14 = var12.blockY;
        int var15 = var12.blockZ;

        if (!par2World.canMineBlock(par3EntityPlayer, var13, var14, var15)) {
          return par1ItemStack;
        }

        if (this.isFull == 0) {
          if (!par3EntityPlayer.canPlayerEdit(var13, var14, var15, var12.sideHit, par1ItemStack)) {
            return par1ItemStack;
          }

          if (par2World.getBlockMaterial(var13, var14, var15) == Material.water
              && par2World.getBlockMetadata(var13, var14, var15) == 0) {
            par2World.setBlockToAir(var13, var14, var15);

            if (par3EntityPlayer.capabilities.isCreativeMode) {
              return par1ItemStack;
            }

            if (--par1ItemStack.stackSize <= 0) {
              return new ItemStack(Item.bucketWater);
            }

            if (!par3EntityPlayer.inventory.addItemStackToInventory(
                new ItemStack(Item.bucketWater))) {
              par3EntityPlayer.dropPlayerItem(new ItemStack(Item.bucketWater.itemID, 1, 0));
            }

            return par1ItemStack;
          }

          if (par2World.getBlockMaterial(var13, var14, var15) == Material.lava
              && par2World.getBlockMetadata(var13, var14, var15) == 0) {
            par2World.setBlockToAir(var13, var14, var15);

            if (par3EntityPlayer.capabilities.isCreativeMode) {
              return par1ItemStack;
            }

            if (--par1ItemStack.stackSize <= 0) {
              return new ItemStack(Item.bucketLava);
            }

            if (!par3EntityPlayer.inventory.addItemStackToInventory(
                new ItemStack(Item.bucketLava))) {
              par3EntityPlayer.dropPlayerItem(new ItemStack(Item.bucketLava.itemID, 1, 0));
            }

            return par1ItemStack;
          }
        } else {
          if (this.isFull < 0) {
            return new ItemStack(Item.bucketEmpty);
          }

          if (var12.sideHit == 0) {
            --var14;
          }

          if (var12.sideHit == 1) {
            ++var14;
          }

          if (var12.sideHit == 2) {
            --var15;
          }

          if (var12.sideHit == 3) {
            ++var15;
          }

          if (var12.sideHit == 4) {
            --var13;
          }

          if (var12.sideHit == 5) {
            ++var13;
          }

          if (!par3EntityPlayer.canPlayerEdit(var13, var14, var15, var12.sideHit, par1ItemStack)) {
            return par1ItemStack;
          }

          if (this.tryPlaceContainedLiquid(par2World, var5, var7, var9, var13, var14, var15)
              && !par3EntityPlayer.capabilities.isCreativeMode) {
            return new ItemStack(Item.bucketEmpty);
          }
        }
      } else if (this.isFull == 0 && var12.entityHit instanceof EntityCow) {
        return new ItemStack(Item.bucketMilk);
      }

      return par1ItemStack;
    }
  }
 public void updateTick(World world, int i, int j, int k, Random random) {
   int l = getFlowDecay(world, i, j, k);
   byte byte0 = 1;
   if (blockMaterial == Material.lava && !world.worldProvider.isHellWorld) {
     byte0 = 2;
   }
   boolean flag = true;
   if (l > 0) {
     int i1 = -100;
     numAdjacentSources = 0;
     i1 = getSmallestFlowDecay(world, i - 1, j, k, i1);
     i1 = getSmallestFlowDecay(world, i + 1, j, k, i1);
     i1 = getSmallestFlowDecay(world, i, j, k - 1, i1);
     i1 = getSmallestFlowDecay(world, i, j, k + 1, i1);
     int j1 = i1 + byte0;
     if (j1 >= 8 || i1 < 0) {
       j1 = -1;
     }
     if (getFlowDecay(world, i, j + 1, k) >= 0) {
       int l1 = getFlowDecay(world, i, j + 1, k);
       if (l1 >= 8) {
         j1 = l1;
       } else {
         j1 = l1 + 8;
       }
     }
     if (numAdjacentSources >= 2 && blockMaterial == Material.water) {
       if (world.getBlockMaterial(i, j - 1, k).isSolid()) {
         j1 = 0;
       } else if (world.getBlockMaterial(i, j - 1, k) == blockMaterial
           && world.getBlockMetadata(i, j, k) == 0) {
         j1 = 0;
       }
     }
     if (blockMaterial == Material.lava && l < 8 && j1 < 8 && j1 > l && random.nextInt(4) != 0) {
       j1 = l;
       flag = false;
     }
     if (j1 != l) {
       l = j1;
       if (l < 0) {
         world.setBlockWithNotify(i, j, k, 0);
       } else {
         world.setBlockMetadataWithNotify(i, j, k, l);
         world.scheduleBlockUpdate(i, j, k, blockID, tickRate());
         world.notifyBlocksOfNeighborChange(i, j, k, blockID);
       }
     } else if (flag) {
       func_30003_j(world, i, j, k);
     }
   } else {
     func_30003_j(world, i, j, k);
   }
   if (liquidCanDisplaceBlock(world, i, j - 1, k)) {
     if (l >= 8) {
       world.setBlockAndMetadataWithNotify(i, j - 1, k, blockID, l);
     } else {
       world.setBlockAndMetadataWithNotify(i, j - 1, k, blockID, l + 8);
     }
   } else if (l >= 0 && (l == 0 || blockBlocksFlow(world, i, j - 1, k))) {
     boolean aflag[] = getOptimalFlowDirections(world, i, j, k);
     int k1 = l + byte0;
     if (l >= 8) {
       k1 = 1;
     }
     if (k1 >= 8) {
       return;
     }
     if (aflag[0]) {
       flowIntoBlock(world, i - 1, j, k, k1);
     }
     if (aflag[1]) {
       flowIntoBlock(world, i + 1, j, k, k1);
     }
     if (aflag[2]) {
       flowIntoBlock(world, i, j, k - 1, k1);
     }
     if (aflag[3]) {
       flowIntoBlock(world, i, j, k + 1, k1);
     }
   }
 }