Пример #1
0
  @Override
  public Chunk provideChunk(int chunkX, int chunkZ) {
    rand.setSeed(chunkX * 341873128712L + chunkZ * 132897987541L);

    biomesForGeneration =
        worldObj
            .getBiomeProvider()
            .loadBlockGeneratorData(biomesForGeneration, chunkX * 16, chunkZ * 16, 16, 16);

    ChunkPrimer primer = new ChunkPrimer();

    setBlocksInChunk(primer);

    caveGenerator.generate(worldObj, chunkX, chunkZ, primer);

    if (CavelandConfig.generateRiver) {
      ravineGenerator.generate(worldObj, chunkX, chunkZ, primer);
    }

    replaceBiomeBlocks(chunkX, chunkZ, primer);

    Chunk chunk = new Chunk(worldObj, primer, chunkX, chunkZ);
    byte[] biomeArray = chunk.getBiomeArray();

    for (int i = 0; i < biomeArray.length; ++i) {
      biomeArray[i] = (byte) Biome.getIdForBiome(biomesForGeneration[i]);
    }

    chunk.resetRelightChecks();

    return chunk;
  }
  @Override
  public Chunk provideChunk(int par1, int par2) {
    this.rand.setSeed(par1 * 341873128712L + par2 * 132897987541L);
    final Block[] ids = new Block[32768 * 2];
    final byte[] meta = new byte[32768 * 2];
    this.generateTerrain(par1, par2, ids, meta);
    this.createCraters(par1, par2, ids, meta);
    this.biomesForGeneration =
        this.worldObj
            .getWorldChunkManager()
            .loadBlockGeneratorData(this.biomesForGeneration, par1 * 16, par2 * 16, 16, 16);
    this.replaceBlocksForBiome(par1, par2, ids, meta, this.biomesForGeneration);

    if (this.worldGenerators == null) {
      this.worldGenerators = this.getWorldGenerators();
    }

    for (MapGenBaseMeta generator : this.worldGenerators) {
      generator.generate(this, this.worldObj, par1, par2, ids, meta);
    }

    this.onChunkProvide(par1, par2, ids, meta);

    final Chunk var4 = new Chunk(this.worldObj, ids, meta, par1, par2);
    final byte[] var5 = var4.getBiomeArray();

    for (int var6 = 0; var6 < var5.length; ++var6) {
      var5[var6] = (byte) this.biomesForGeneration[var6].biomeID;
    }

    var4.generateSkylightMap();
    return var4;
  }
  public Chunk provideChunk(int i, int j) {
    field_913_j.setSeed((long) i * 0x4f9939f508L + (long) j * 0x1ef1565bd5L);
    byte abyte0[] = new byte[32768];
    field_4179_v =
        worldObj_16
            .getWorldChunkManager()
            .loadBlockGeneratorData(field_4179_v, i * 16, j * 16, 16, 16);
    double ad[] = BWG4WorldChunkManager.temperature;
    generateTerrain(i, j, abyte0, field_4179_v, ad);
    replaceBlocksForBiome(i, j, abyte0, field_4179_v);
    field_902_u.generate(this, worldObj_16, i, j, abyte0);

    if (mapFeaturesEnabled) {
      strongholdGenerator.generate(this, worldObj_16, i, j, abyte0);
    }

    Chunk chunk = new Chunk(worldObj_16, abyte0, i, j);
    byte abyte1[] = chunk.getBiomeArray();

    for (int k = 0; k < abyte1.length; k++) {
      abyte1[k] = (byte) field_4179_v[k].biomeID;
    }

    chunk.generateSkylightMap();
    return chunk;
  }
 public Chunk provideChunk(int par1, int par2) {
   this.rand.setSeed(par1 * 341873128712L + par2 * 132897987541L);
   byte[] var3 = new byte[32768];
   generateTerrain(par1, par2, var3);
   this.biomesForGeneration =
       this.worldObj
           .getWorldChunkManager()
           .loadBlockGeneratorData(this.biomesForGeneration, par1 * 16, par2 * 16, 16, 16);
   replaceBlocksForBiome(par1, par2, var3, this.biomesForGeneration);
   this.caveGenerator.generate(this, this.worldObj, par1, par2, var3);
   this.ravineGenerator.generate(this, this.worldObj, par1, par2, var3);
   if (this.mapFeaturesEnabled) {
     this.mineshaftGenerator.generate(this, this.worldObj, par1, par2, var3);
     this.villageGenerator.generate(this, this.worldObj, par1, par2, var3);
     this.strongholdGenerator.generate(this, this.worldObj, par1, par2, var3);
     this.scatteredFeatureGenerator.generate(this, this.worldObj, par1, par2, var3);
   }
   Chunk var4 = new Chunk(this.worldObj, var3, par1, par2);
   byte[] var5 = var4.getBiomeArray();
   for (int var6 = 0; var6 < var5.length; var6++) {
     var5[var6] = ((byte) this.biomesForGeneration[var6].biomeID);
   }
   var4.generateSkylightMap();
   return var4;
 }
Пример #5
0
  public static S21PacketChunkData.Extracted func_179756_a(
      Chunk p_179756_0_, boolean p_179756_1_, boolean p_179756_2_, int p_179756_3_) {
    ExtendedBlockStorage[] aextendedblockstorage = p_179756_0_.getBlockStorageArray();
    S21PacketChunkData.Extracted s21packetchunkdata$extracted = new S21PacketChunkData.Extracted();
    List<ExtendedBlockStorage> list = Lists.<ExtendedBlockStorage>newArrayList();

    for (int i = 0; i < aextendedblockstorage.length; ++i) {
      ExtendedBlockStorage extendedblockstorage = aextendedblockstorage[i];

      if (extendedblockstorage != null
          && (!p_179756_1_ || !extendedblockstorage.isEmpty())
          && (p_179756_3_ & 1 << i) != 0) {
        s21packetchunkdata$extracted.dataSize |= 1 << i;
        list.add(extendedblockstorage);
      }
    }

    s21packetchunkdata$extracted.data =
        new byte
            [func_180737_a(
                Integer.bitCount(s21packetchunkdata$extracted.dataSize), p_179756_2_, p_179756_1_)];
    int j = 0;

    for (ExtendedBlockStorage extendedblockstorage1 : list) {
      char[] achar = extendedblockstorage1.getData();

      for (char c0 : achar) {
        s21packetchunkdata$extracted.data[j++] = (byte) (c0 & 255);
        s21packetchunkdata$extracted.data[j++] = (byte) (c0 >> 8 & 255);
      }
    }

    for (ExtendedBlockStorage extendedblockstorage2 : list) {
      j =
          func_179757_a(
              extendedblockstorage2.getBlocklightArray().getData(),
              s21packetchunkdata$extracted.data,
              j);
    }

    if (p_179756_2_) {
      for (ExtendedBlockStorage extendedblockstorage3 : list) {
        j =
            func_179757_a(
                extendedblockstorage3.getSkylightArray().getData(),
                s21packetchunkdata$extracted.data,
                j);
      }
    }

    if (p_179756_1_) {
      func_179757_a(p_179756_0_.getBiomeArray(), s21packetchunkdata$extracted.data, j);
    }

    return s21packetchunkdata$extracted;
  }
 @Override
 public void write(ByteBuf out) {
   out.writeInt(worldId);
   out.writeInt(chunk.xPosition);
   out.writeInt(chunk.zPosition);
   out.writeInt(pos.x);
   out.writeShort(pos.y);
   out.writeInt(pos.z);
   out.writeBytes(chunk.getBiomeArray());
 }
Пример #7
0
  /**
   * Will return back a chunk, if it doesn't exist and its not a MP client it will generates all the
   * blocks for the specified chunk from the map seed and chunk seed
   */
  @Override
  public Chunk provideChunk(int par1, int par2) {
    long time = System.currentTimeMillis();
    this.rand.setSeed((long) par1 * 341873128712L + (long) par2 * 132897987541L);
    short[] abyte = new short[32768];
    this.generateTerrain(par1, par2, abyte);
    this.biomesForGeneration =
        this.worldObj
            .getWorldChunkManager()
            .loadBlockGeneratorData(this.biomesForGeneration, par1 * 16, par2 * 16, 16, 16);
    // this.biomesForGeneration = new BiomeGenBase[] {BiomeGenBase.desert};
    this.replaceBlocksForBiome(par1, par2, abyte, this.biomesForGeneration);
    // this.caveGenerator.generate((IChunkProvider)this, this.worldObj, par1, par2, abyte);
    // this.ravineGenerator.generate(this, this.worldObj, par1, par2, abyte);

    if (this.mapFeaturesEnabled) {
      // this.mineshaftGenerator.generate(this, this.worldObj, par1, par2, abyte);
      // this.villageGenerator.generate(this, this.worldObj, par1, par2, abyte);
      // this.strongholdGenerator.generate(this, this.worldObj, par1, par2, abyte);
      // this.scatteredFeatureGenerator.generate(this, this.worldObj, par1, par2, abyte);
    }

    /*short[] ashort = new short[32768];
    int yMax = 32768/256;
    for(int x = 0; x < 16; x++)
    {
    	for(int z = 0; z < 16; z++)
    	{
    		for(int y = 0; y < yMax; y++)
    		{
                int idx = y << 8 | z << 4 | x;
                int ido = x << 11 | z << 7 | y;
                ashort[idx] = abyte[ido];
    		}
    	}
    }*/

    Chunk chunk = new Chunk(this.worldObj, abyte, new byte[32768], par1, par2);
    byte[] abyte1 = chunk.getBiomeArray();

    for (int k = 0; k < abyte1.length; ++k) {
      abyte1[k] = (byte) this.biomesForGeneration[k].biomeID;
    }

    chunk.generateSkylightMap();
    // System.out.println("Providing Chunk: " + (System.currentTimeMillis() - time) + "ms");
    return chunk;
  }
  @Override
  public Chunk provideChunk(int i, int j) {
    this.rand.setSeed(i * 341873128712L + j * 132897987541L);
    byte[] var3 = new byte[32768];
    this.biomesForGeneration =
        this.worldObj
            .getWorldChunkManager()
            .loadBlockGeneratorData(this.biomesForGeneration, i * 16, j * 16, 16, 16);
    this.generateTerrain(i, j, var3, this.biomesForGeneration, this.generatedTemperatures);
    this.replaceBlocksForBiome(i, j, var3, this.biomesForGeneration);
    this.caveGenerator.generate(this, this.worldObj, i, j, var3);
    Chunk var4 = new Chunk(this.worldObj, var3, i, j);
    byte[] var5 = var4.getBiomeArray();

    for (int var6 = 0; var6 < var5.length; ++var6) {
      var5[var6] = (byte) this.biomesForGeneration[var6].biomeID;
    }

    var4.generateSkylightMap();
    return var4;
  }
  @Override
  public Chunk provideChunk(int x, int z) {
    rand.setSeed((long) x * 0x4f9939f508L + (long) z * 0x1ef1565bd5L);
    Block blocks[] = new Block[16 * dimension.heightLimit * 16];
    Arrays.fill(blocks, Blocks.air);
    byte meta[] = new byte[16 * dimension.heightLimit * 16];

    biomesForGeneration =
        worldObj
            .getWorldChunkManager()
            .getBiomesForGeneration(biomesForGeneration, x * 4 - 2, z * 4 - 2, 10, 10);

    for (TerrainLayer layer : dimension.terrainLayers) {
      generateTerrain(x, z, blocks, layer);
    }

    biomesForGeneration =
        worldObj
            .getWorldChunkManager()
            .loadBlockGeneratorData(biomesForGeneration, x * 16, z * 16, 16, 16);
    for (TerrainLayer layer : dimension.terrainLayers) {
      replaceBlocksForBiome(x, z, blocks, meta, biomesForGeneration, layer);
    }
    // caveGenerator.generate(this, worldObj, x, z, ids);
    // ravineGenerator.generate(this, worldObj, x, z, ids);
    Chunk chunk = new Chunk(worldObj, blocks, meta, x, z);

    byte[] biomes = chunk.getBiomeArray();

    for (int k = 0; k < biomes.length; ++k) {
      biomes[k] = (byte) this.biomesForGeneration[k].biomeID;
    }

    chunk.generateSkylightMap();
    if (dimension == Dimension.nether) {
      chunk.resetRelightChecks();
    }
    return chunk;
  }
  /**
   * Will return back a chunk, if it doesn't exist and its not a MP client it will generates all the
   * blocks for the specified chunk from the map seed and chunk seed
   */
  public Chunk provideChunk(int p_73154_1_, int p_73154_2_) {
    this.hellRNG.setSeed((long) p_73154_1_ * 341873128712L + (long) p_73154_2_ * 132897987541L);
    Block[] var3 = new Block[32768];
    this.func_147419_a(p_73154_1_, p_73154_2_, var3);
    this.func_147418_b(p_73154_1_, p_73154_2_, var3);
    this.netherCaveGenerator.func_151539_a(this, this.worldObj, p_73154_1_, p_73154_2_, var3);
    this.genNetherBridge.func_151539_a(this, this.worldObj, p_73154_1_, p_73154_2_, var3);
    Chunk var4 = new Chunk(this.worldObj, var3, p_73154_1_, p_73154_2_);
    BiomeGenBase[] var5 =
        this.worldObj
            .getWorldChunkManager()
            .loadBlockGeneratorData(
                (BiomeGenBase[]) null, p_73154_1_ * 16, p_73154_2_ * 16, 16, 16);
    byte[] var6 = var4.getBiomeArray();

    for (int var7 = 0; var7 < var6.length; ++var7) {
      var6[var7] = (byte) var5[var7].biomeID;
    }

    var4.resetRelightChecks();
    return var4;
  }
  public static S21PacketChunkData.Extracted func_149269_a(
      Chunk p_149269_0_, boolean p_149269_1_, int p_149269_2_) {
    int j = 0;
    ExtendedBlockStorage[] aextendedblockstorage = p_149269_0_.getBlockStorageArray();
    int k = 0;
    S21PacketChunkData.Extracted extracted = new S21PacketChunkData.Extracted();
    byte[] abyte = field_149286_i;

    if (p_149269_1_) {
      p_149269_0_.sendUpdates = true;
    }

    int l;

    for (l = 0; l < aextendedblockstorage.length; ++l) {
      if (aextendedblockstorage[l] != null
          && (!p_149269_1_ || !aextendedblockstorage[l].isEmpty())
          && (p_149269_2_ & 1 << l) != 0) {
        extracted.field_150280_b |= 1 << l;

        if (aextendedblockstorage[l].getBlockMSBArray() != null) {
          extracted.field_150281_c |= 1 << l;
          ++k;
        }
      }
    }

    for (l = 0; l < aextendedblockstorage.length; ++l) {
      if (aextendedblockstorage[l] != null
          && (!p_149269_1_ || !aextendedblockstorage[l].isEmpty())
          && (p_149269_2_ & 1 << l) != 0) {
        byte[] abyte1 = aextendedblockstorage[l].getBlockLSBArray();
        System.arraycopy(abyte1, 0, abyte, j, abyte1.length);
        j += abyte1.length;
      }
    }

    NibbleArray nibblearray;

    for (l = 0; l < aextendedblockstorage.length; ++l) {
      if (aextendedblockstorage[l] != null
          && (!p_149269_1_ || !aextendedblockstorage[l].isEmpty())
          && (p_149269_2_ & 1 << l) != 0) {
        nibblearray = aextendedblockstorage[l].getMetadataArray();
        System.arraycopy(nibblearray.data, 0, abyte, j, nibblearray.data.length);
        j += nibblearray.data.length;
      }
    }

    for (l = 0; l < aextendedblockstorage.length; ++l) {
      if (aextendedblockstorage[l] != null
          && (!p_149269_1_ || !aextendedblockstorage[l].isEmpty())
          && (p_149269_2_ & 1 << l) != 0) {
        nibblearray = aextendedblockstorage[l].getBlocklightArray();
        System.arraycopy(nibblearray.data, 0, abyte, j, nibblearray.data.length);
        j += nibblearray.data.length;
      }
    }

    if (!p_149269_0_.worldObj.provider.hasNoSky) {
      for (l = 0; l < aextendedblockstorage.length; ++l) {
        if (aextendedblockstorage[l] != null
            && (!p_149269_1_ || !aextendedblockstorage[l].isEmpty())
            && (p_149269_2_ & 1 << l) != 0) {
          nibblearray = aextendedblockstorage[l].getSkylightArray();
          System.arraycopy(nibblearray.data, 0, abyte, j, nibblearray.data.length);
          j += nibblearray.data.length;
        }
      }
    }

    if (k > 0) {
      for (l = 0; l < aextendedblockstorage.length; ++l) {
        if (aextendedblockstorage[l] != null
            && (!p_149269_1_ || !aextendedblockstorage[l].isEmpty())
            && aextendedblockstorage[l].getBlockMSBArray() != null
            && (p_149269_2_ & 1 << l) != 0) {
          nibblearray = aextendedblockstorage[l].getBlockMSBArray();
          System.arraycopy(nibblearray.data, 0, abyte, j, nibblearray.data.length);
          j += nibblearray.data.length;
        }
      }
    }

    if (p_149269_1_) {
      byte[] abyte2 = p_149269_0_.getBiomeArray();
      System.arraycopy(abyte2, 0, abyte, j, abyte2.length);
      j += abyte2.length;
    }

    extracted.field_150282_a = new byte[j];
    System.arraycopy(abyte, 0, extracted.field_150282_a, 0, j);
    return extracted;
  }
Пример #12
0
  public Chunk getOrCreateChunk(int x, int z) {
    random.setSeed((long) x * 341873128712L + (long) z * 132897987541L);

    Chunk chunk;

    // Get default biome data for chunk
    CustomBiomeGrid biomegrid = new CustomBiomeGrid();
    biomegrid.biome = new BiomeGenBase[256];
    world.getWorldChunkManager().getBiomeGenAt(biomegrid.biome, x << 4, z << 4, 16, 16, false);

    // Try extended block method (1.2+)
    short[][] xbtypes =
        generator.generateExtBlockSections(
            CraftServer.instance().getWorld(world.provider.dimensionId),
            this.random,
            x,
            z,
            biomegrid);
    if (xbtypes != null) {
      chunk = new Chunk(this.world, x, z);

      ExtendedBlockStorage[] csect = chunk.getBlockStorageArray();
      int scnt = Math.min(csect.length, xbtypes.length);

      // Loop through returned sections
      for (int sec = 0; sec < scnt; sec++) {
        if (xbtypes[sec] == null) {
          continue;
        }
        byte[] secBlkID = new byte[4096]; // Allocate blk ID bytes
        byte[] secExtBlkID = (byte[]) null; // Delay getting extended ID nibbles
        short[] bdata = xbtypes[sec];
        // Loop through data, 2 blocks at a time
        for (int i = 0, j = 0; i < bdata.length; i += 2, j++) {
          short b1 = bdata[i];
          short b2 = bdata[i + 1];
          byte extb = (byte) ((b1 >> 8) | ((b2 >> 4) & 0xF0));

          secBlkID[i] = (byte) b1;
          secBlkID[(i + 1)] = (byte) b2;

          if (extb != 0) { // If extended block ID data
            if (secExtBlkID == null) { // Allocate if needed
              secExtBlkID = new byte[2048];
            }
            secExtBlkID[j] = extb;
          }
        }
        // Build chunk section
        csect[sec] = new ExtendedBlockStorage(sec << 4, false); // , secBlkID, secExtBlkID);
      }
    } else { // Else check for byte-per-block section data
      byte[][] btypes =
          generator.generateBlockSections(getWorld(world), this.random, x, z, biomegrid);

      if (btypes != null) {
        chunk = new Chunk(this.world, x, z);

        ExtendedBlockStorage[] csect = chunk.getBlockStorageArray();
        int scnt = Math.min(csect.length, btypes.length);

        for (int sec = 0; sec < scnt; sec++) {
          if (btypes[sec] == null) {
            continue;
          }
          csect[sec] = new ExtendedBlockStorage(sec << 4, false); // , btypes[sec], null);
        }
      } else { // Else, fall back to pre 1.2 method
        @SuppressWarnings("deprecation")
        byte[] types = generator.generate(getWorld(world), this.random, x, z);
        int ydim = types.length / 256;
        int scnt = ydim / 16;

        chunk = new Chunk(this.world, x, z); // Create empty chunk

        ExtendedBlockStorage[] csect = chunk.getBlockStorageArray();

        scnt = Math.min(scnt, csect.length);
        // Loop through sections
        for (int sec = 0; sec < scnt; sec++) {
          ExtendedBlockStorage cs = null; // Add sections when needed
          byte[] csbytes = (byte[]) null;

          for (int cy = 0; cy < 16; cy++) {
            int cyoff = cy | (sec << 4);

            for (int cx = 0; cx < 16; cx++) {
              int cxyoff = (cx * ydim * 16) + cyoff;

              for (int cz = 0; cz < 16; cz++) {
                byte blk = types[cxyoff + (cz * ydim)];

                if (blk != 0) { // If non-empty
                  if (cs == null) { // If no section yet, get one
                    cs = csect[sec] = new ExtendedBlockStorage(sec << 4, true);
                    csbytes = cs.getBlockLSBArray();
                  }
                  csbytes[(cy << 8) | (cz << 4) | cx] = blk;
                }
              }
            }
          }
          // If section built, finish prepping its state
          if (cs != null) {
            cs.getYLocation();
          }
        }
      }
    }
    // Set biome grid
    byte[] biomeIndex = chunk.getBiomeArray();
    for (int i = 0; i < biomeIndex.length; i++) {
      biomeIndex[i] = (byte) (biomegrid.biome[i].biomeID & 0xFF);
    }
    // Initialize lighting
    chunk.generateSkylightMap();

    return chunk;
  }