예제 #1
0
  private void tryToCatchBlockOnFire(
      World par1World, int par2, int par3, int par4, int par5, Random par6Random, int par7) {
    if (oldFire) {
      tryToCatchBlockOnFire_old(par1World, par2, par3, par4, par5, par6Random);
      return;
    }
    int i = abilityToCatchFire[par1World.getBlockId(par2, par3, par4)];

    if (par6Random.nextInt(par5) < i) {
      boolean flag = par1World.getBlockId(par2, par3, par4) == Block.tnt.blockID;

      if (par6Random.nextInt(par7 + 10) < 5 && !par1World.canLightningStrikeAt(par2, par3, par4)) {
        int j = par7 + par6Random.nextInt(5) / 4;

        if (j > 15) {
          j = 15;
        }

        par1World.setBlock(par2, par3, par4, blockID, j, 3);
      } else {
        par1World.setBlockToAir(par2, par3, par4);
      }

      if (flag) {
        Block.tnt.onBlockDestroyedByPlayer(par1World, par2, par3, par4, 1);
      }
    }
  }
예제 #2
0
 /** Checks if this entity is either in water or on an open air block in rain (used in wolves). */
 public boolean isWet() {
   return inWater
       || worldObj.canLightningStrikeAt(
           MathHelper.floor_double(posX),
           MathHelper.floor_double(posY),
           MathHelper.floor_double(posZ));
 }
예제 #3
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) {
   if (par1World.canLightningStrikeAt(par2, par3 + 1, par4)
       && !par1World.doesBlockHaveSolidTopSurface(par2, par3 - 1, par4)
       && par5Random.nextInt(15) == 1) {
     double var6 = (double) ((float) par2 + par5Random.nextFloat());
     double var8 = (double) par3 - 0.05D;
     double var10 = (double) ((float) par4 + par5Random.nextFloat());
     par1World.spawnParticle("dripWater", var6, var8, var10, 0.0D, 0.0D, 0.0D);
   }
 }
예제 #4
0
 private void tryToCatchBlockOnFire_old(World world, int i, int j, int k, int l, Random random) {
   int i1 = abilityToCatchFire[world.getBlockId(i, j, k)];
   if (random.nextInt(l) < i1) {
     boolean flag = world.getBlockId(i, j, k) == Block.tnt.blockID;
     if (random.nextInt(2) == 0 && !world.canLightningStrikeAt(i, j, k)) {
       world.setBlock(i, j, k, blockID);
     } else {
       world.setBlockToAir(i, j, k);
     }
     if (flag) {
       Block.tnt.onBlockDestroyedByPlayer(world, i, j, k, 0);
     }
   }
 }
예제 #5
0
  /** Ticks the block if it's been scheduled */
  public void updateTick(World par1World, int par2, int par3, int par4, Random par5Random) {
    if (isWaterNearby(par1World, par2, par3, par4)
        || par1World.canLightningStrikeAt(par2, par3 + 1, par4)) {
      par1World.setBlockMetadataWithNotify(par2, par3, par4, 7);
    } else {
      int i = par1World.getBlockMetadata(par2, par3, par4);

      if (i > 0) {
        par1World.setBlockMetadataWithNotify(par2, par3, par4, i - 1);
      } else if (!isCropsNearby(par1World, par2, par3, par4)) {
        par1World.setBlockWithNotify(par2, par3, par4, Block.dirt.blockID);
      }
    }
  }
예제 #6
0
 public void updateTickOld(World world, int i, int j, int k, Random random) {
   boolean flag = world.getBlockId(i, j - 1, k) == Block.netherrack.blockID;
   if (!flag
       && world.isRaining()
       && (world.canLightningStrikeAt(i, j, k)
           || world.canLightningStrikeAt(i - 1, j, k)
           || world.canLightningStrikeAt(i + 1, j, k)
           || world.canLightningStrikeAt(i, j, k - 1)
           || world.canLightningStrikeAt(i, j, k + 1))) {
     world.setBlockToAir(i, j, k);
     return;
   }
   int l = world.getBlockMetadata(i, j, k);
   if (l < 15) {
     world.setBlockMetadataWithNotify(i, j, k, l + 1, 3);
     world.scheduleBlockUpdate(i, j, k, blockID, tickRate(world));
   }
   if (!flag && !canNeighborBurn(world, i, j, k)) {
     if (!world.isBlockOpaqueCube(i, j - 1, k) || l > 3) {
       world.setBlockToAir(i, j, k);
     }
     return;
   }
   if (!flag && !canBlockCatchFire(world, i, j - 1, k) && l == 15 && random.nextInt(4) == 0) {
     world.setBlockToAir(i, j, k);
     return;
   }
   if (l % 2 == 0 && l > 2) {
     tryToCatchBlockOnFire_old(world, i + 1, j, k, 300, random);
     tryToCatchBlockOnFire_old(world, i - 1, j, k, 300, random);
     tryToCatchBlockOnFire_old(world, i, j - 1, k, 250, random);
     tryToCatchBlockOnFire_old(world, i, j + 1, k, 250, random);
     tryToCatchBlockOnFire_old(world, i, j, k - 1, 300, random);
     tryToCatchBlockOnFire_old(world, i, j, k + 1, 300, random);
     for (int i1 = i - 1; i1 <= i + 1; i1++) {
       for (int j1 = k - 1; j1 <= k + 1; j1++) {
         for (int k1 = j - 1; k1 <= j + 4; k1++) {
           if (i1 == i && k1 == j && j1 == k) {
             continue;
           }
           int l1 = 100;
           if (k1 > j + 1) {
             l1 += (k1 - (j + 1)) * 100;
           }
           int i2 = getChanceOfNeighborsEncouragingFire(world, i1, k1, j1);
           if (i2 > 0
               && random.nextInt(l1) <= i2
               && (!world.isRaining() || !world.canLightningStrikeAt(i1, k1, j1))
               && !world.canLightningStrikeAt(i1 - 1, k1, k)
               && !world.canLightningStrikeAt(i1 + 1, k1, j1)
               && !world.canLightningStrikeAt(i1, k1, j1 - 1)
               && !world.canLightningStrikeAt(i1, k1, j1 + 1)) {
             world.setBlock(i1, k1, j1, blockID);
           }
         }
       }
     }
   }
   if (l == 15 && !infiniteBurn) {
     tryToCatchBlockOnFire_old(world, i + 1, j, k, 1, random);
     tryToCatchBlockOnFire_old(world, i - 1, j, k, 1, random);
     tryToCatchBlockOnFire_old(world, i, j - 1, k, 1, random);
     tryToCatchBlockOnFire_old(world, i, j + 1, k, 1, random);
     tryToCatchBlockOnFire_old(world, i, j, k - 1, 1, random);
     tryToCatchBlockOnFire_old(world, i, j, k + 1, 1, random);
   }
 }
예제 #7
0
  /** Ticks the block if it's been scheduled */
  public void updateTick(World par1World, int par2, int par3, int par4, Random par5Random) {
    if (!par1World.getGameRules().getGameRuleBooleanValue("doFireTick")) {
      return;
    }
    if (oldFire) {
      updateTickOld(par1World, par2, par3, par4, par5Random);
      return;
    }

    boolean flag = par1World.getBlockId(par2, par3 - 1, par4) == Block.netherrack.blockID;

    if ((par1World.provider instanceof WorldProviderEnd)
        && par1World.getBlockId(par2, par3 - 1, par4) == Block.bedrock.blockID) {
      flag = true;
    }

    if (!canPlaceBlockAt(par1World, par2, par3, par4)) {
      par1World.setBlockToAir(par2, par3, par4);
    }

    if (!flag
        && par1World.isRaining()
        && (par1World.canLightningStrikeAt(par2, par3, par4)
            || par1World.canLightningStrikeAt(par2 - 1, par3, par4)
            || par1World.canLightningStrikeAt(par2 + 1, par3, par4)
            || par1World.canLightningStrikeAt(par2, par3, par4 - 1)
            || par1World.canLightningStrikeAt(par2, par3, par4 + 1))) {
      par1World.setBlockToAir(par2, par3, par4);
      return;
    }

    int i = par1World.getBlockMetadata(par2, par3, par4);

    if (i < 15) {
      par1World.setBlockMetadataWithNotify(par2, par3, par4, i + par5Random.nextInt(3) / 2, 4);
    }

    par1World.scheduleBlockUpdate(
        par2, par3, par4, blockID, tickRate(par1World) + par5Random.nextInt(10));

    if (!flag && !canNeighborBurn(par1World, par2, par3, par4)) {
      if (!par1World.doesBlockHaveSolidTopSurface(par2, par3 - 1, par4) || i > 3) {
        par1World.setBlockToAir(par2, par3, par4);
      }

      return;
    }

    if (!flag
        && !canBlockCatchFire(par1World, par2, par3 - 1, par4)
        && i == 15
        && par5Random.nextInt(4) == 0) {
      par1World.setBlockToAir(par2, par3, par4);
      return;
    }

    boolean flag1 = par1World.isBlockHighHumidity(par2, par3, par4);
    byte byte0 = 0;

    if (flag1) {
      byte0 = -50;
    }

    tryToCatchBlockOnFire(par1World, par2 + 1, par3, par4, 300 + byte0, par5Random, i);
    tryToCatchBlockOnFire(par1World, par2 - 1, par3, par4, 300 + byte0, par5Random, i);
    tryToCatchBlockOnFire(par1World, par2, par3 - 1, par4, 250 + byte0, par5Random, i);
    tryToCatchBlockOnFire(par1World, par2, par3 + 1, par4, 250 + byte0, par5Random, i);
    tryToCatchBlockOnFire(par1World, par2, par3, par4 - 1, 300 + byte0, par5Random, i);
    tryToCatchBlockOnFire(par1World, par2, par3, par4 + 1, 300 + byte0, par5Random, i);

    for (int j = par2 - 1; j <= par2 + 1; j++) {
      for (int k = par4 - 1; k <= par4 + 1; k++) {
        for (int l = par3 - 1; l <= par3 + 4; l++) {
          if (j == par2 && l == par3 && k == par4) {
            continue;
          }

          int i1 = 100;

          if (l > par3 + 1) {
            i1 += (l - (par3 + 1)) * 100;
          }

          int j1 = getChanceOfNeighborsEncouragingFire(par1World, j, l, k);

          if (j1 <= 0) {
            continue;
          }

          int k1 = (j1 + 40 + (fixedDamage ? 0 : par1World.difficultySetting * 7)) / (i + 30);

          if (flag1) {
            k1 /= 2;
          }

          if (k1 <= 0
              || par5Random.nextInt(i1) > k1
              || par1World.isRaining() && par1World.canLightningStrikeAt(j, l, k)
              || par1World.canLightningStrikeAt(j - 1, l, par4)
              || par1World.canLightningStrikeAt(j + 1, l, k)
              || par1World.canLightningStrikeAt(j, l, k - 1)
              || par1World.canLightningStrikeAt(j, l, k + 1)) {
            continue;
          }

          int l1 = i + par5Random.nextInt(5) / 4;

          if (l1 > 15) {
            l1 = 15;
          }

          par1World.setBlock(j, l, k, blockID, l1, 3);
        }
      }
    }
  }