Examples with WorldProviderAsteroids micdoodle8.mods.galacticraft.planets.asteroids.dimension.WorldProviderAsteroids used on opensource projects

Example 11 with WorldProviderAsteroids

use of micdoodle8.mods.galacticraft.planets.asteroids.dimension.WorldProviderAsteroids in project Galacticraft by micdoodle8.

the class ChunkProviderAsteroids method generateChunk.

@Override
public Chunk generateChunk(int par1, int par2) {
    ChunkPrimer primer = new ChunkPrimer();
    // long time1 = System.nanoTime();
    this.rand.setSeed(par1 * 341873128712L + par2 * 132897987541L);
    // final Block[] ids = new Block[65536];
    // final byte[] meta = new byte[65536];
    this.generateTerrain(par1, par2, primer, false);
    if (this.world.provider instanceof WorldProviderAsteroids && ((WorldProviderAsteroids) this.world.provider).checkHasAsteroids()) {
        this.dungeonGenerator.generate(this.world, par1, par2, primer);
    }
    // long time2 = System.nanoTime();
    final Chunk var4 = new Chunk(this.world, primer, par1, par2);
    final byte[] biomesArray = var4.getBiomeArray();
    final byte b = (byte) Biome.getIdForBiome(BiomeAdaptive.biomeDefault);
    for (int i = 0; i < biomesArray.length; ++i) {
        biomesArray[i] = b;
    }
    // long time3 = System.nanoTime();
    this.generateSkylightMap(var4, par1, par2);
    // }
    return var4;
}

Example 12 with WorldProviderAsteroids

use of micdoodle8.mods.galacticraft.planets.asteroids.dimension.WorldProviderAsteroids in project Galacticraft by micdoodle8.

the class ChunkProviderAsteroids method generateAsteroid.

private void generateAsteroid(Random rand, int asteroidX, int asteroidY, int asteroidZ, int chunkX, int chunkZ, int size, ChunkPrimer primer, boolean flagDataOnly) {
    SpecialAsteroidBlock core = this.coreHandler.getBlock(rand, size);
    SpecialAsteroidBlock shell = null;
    if (rand.nextInt(ChunkProviderAsteroids.ASTEROID_SHELL_CHANCE) == 0) {
        shell = this.shellHandler.getBlock(rand, size);
    }
    boolean isHollow = false;
    final float hollowSize = rand.nextFloat() * (ChunkProviderAsteroids.MAX_HOLLOW_SIZE - ChunkProviderAsteroids.MIN_HOLLOW_SIZE) + ChunkProviderAsteroids.MIN_HOLLOW_SIZE;
    if (rand.nextInt(ChunkProviderAsteroids.HOLLOW_CHANCE) == 0 && size >= ChunkProviderAsteroids.MIN_RADIUS_FOR_HOLLOW) {
        isHollow = true;
        shell = new SpecialAsteroidBlock(AsteroidBlocks.blockDenseIce, (byte) 0, 1, .15);
    }
    // Add to the list of asteroids for external use
    ((WorldProviderAsteroids) this.world.provider).addAsteroid(asteroidX, asteroidY, asteroidZ, size, isHollow ? -1 : core.index);
    final int xMin = this.clamp(Math.max(chunkX, asteroidX - size - ChunkProviderAsteroids.MAX_ASTEROID_SKEW - 2) - chunkX, 0, 16);
    final int zMin = this.clamp(Math.max(chunkZ, asteroidZ - size - ChunkProviderAsteroids.MAX_ASTEROID_SKEW - 2) - chunkZ, 0, 16);
    final int yMin = asteroidY - size - ChunkProviderAsteroids.MAX_ASTEROID_SKEW - 2;
    final int yMax = asteroidY + size + ChunkProviderAsteroids.MAX_ASTEROID_SKEW + 2;
    final int xMax = this.clamp(Math.min(chunkX + 16, asteroidX + size + ChunkProviderAsteroids.MAX_ASTEROID_SKEW + 2) - chunkX, 0, 16);
    final int zMax = this.clamp(Math.min(chunkZ + 16, asteroidZ + size + ChunkProviderAsteroids.MAX_ASTEROID_SKEW + 2) - chunkZ, 0, 16);
    final int xSize = xMax - xMin;
    final int ySize = yMax - yMin;
    final int zSize = zMax - zMin;
    if (xSize <= 0 || ySize <= 0 || zSize <= 0) {
        return;
    }
    final float noiseOffsetX = this.randFromPoint(asteroidX, asteroidY, asteroidZ) * ChunkProviderAsteroids.NOISE_OFFSET_SIZE + chunkX;
    final float noiseOffsetY = this.randFromPoint(asteroidX * 7, asteroidY * 11, asteroidZ * 13) * ChunkProviderAsteroids.NOISE_OFFSET_SIZE;
    final float noiseOffsetZ = this.randFromPoint(asteroidX * 17, asteroidY * 23, asteroidZ * 29) * ChunkProviderAsteroids.NOISE_OFFSET_SIZE + chunkZ;
    this.setOtherAxisFrequency(1F / (size * 2F / 2F));
    float[] sizeXArray = new float[ySize * zSize];
    float[] sizeZArray = new float[xSize * ySize];
    float[] sizeYArray = new float[xSize * zSize];
    for (int x = 0; x < xSize; x++) {
        int xx = x * zSize;
        float xxx = x + noiseOffsetX;
        for (int z = 0; z < zSize; z++) {
            sizeYArray[xx + z] = this.asteroidSkewY.getNoise(xxx, z + noiseOffsetZ);
        }
    }
    AsteroidData asteroidData = new AsteroidData(isHollow, sizeYArray, xMin, zMin, xMax, zMax, zSize, size, asteroidX, asteroidY, asteroidZ);
    this.largeAsteroids.add(asteroidData);
    this.largeAsteroidsLastChunkX = chunkX;
    this.largeAsteroidsLastChunkZ = chunkZ;
    if (flagDataOnly) {
        return;
    }
    for (int y = 0; y < ySize; y++) {
        int yy = y * zSize;
        float yyy = y + noiseOffsetY;
        for (int z = 0; z < zSize; z++) {
            sizeXArray[yy + z] = this.asteroidSkewX.getNoise(yyy, z + noiseOffsetZ);
        }
    }
    for (int x = 0; x < xSize; x++) {
        int xx = x * ySize;
        float xxx = x + noiseOffsetX;
        for (int y = 0; y < ySize; y++) {
            sizeZArray[xx + y] = this.asteroidSkewZ.getNoise(xxx, y + noiseOffsetY);
        }
    }
    double shellThickness = 0;
    int terrainY = 0;
    int terrainYY = 0;
    IBlockState asteroidShell = null;
    if (shell != null) {
        asteroidShell = shell.block.getStateFromMeta(shell.meta);
        shellThickness = 1.0 - shell.thickness;
    }
    IBlockState asteroidCore = core.block.getStateFromMeta(core.meta);
    IBlockState asteroidRock0 = this.ASTEROID_STONE.getStateFromMeta(this.ASTEROID_STONE_META_0);
    IBlockState asteroidRock1 = this.ASTEROID_STONE.getStateFromMeta(this.ASTEROID_STONE_META_1);
    IBlockState airBlock = Blocks.AIR.getDefaultState();
    IBlockState dirtBlock = this.DIRT.getStateFromMeta(this.DIRT_META);
    IBlockState grassBlock = this.GRASS.getStateFromMeta(this.GRASS_META);
    for (int x = xMax - 1; x >= xMin; x--) {
        int indexXY = (x - xMin) * ySize - yMin;
        int indexXZ = (x - xMin) * zSize - zMin;
        int distanceX = asteroidX - (x + chunkX);
        int indexBaseX = x * ChunkProviderAsteroids.CHUNK_SIZE_Y << 4;
        float xx = x + chunkX;
        for (int z = zMin; z < zMax; z++) {
            if (isHollow) {
                float sizeModY = sizeYArray[indexXZ + z];
                terrainY = this.getTerrainHeightFor(sizeModY, asteroidY, size);
                terrainYY = this.getTerrainHeightFor(sizeModY, asteroidY - 1, size);
            }
            float sizeY = size + sizeYArray[indexXZ + z];
            sizeY *= sizeY;
            int distanceZ = asteroidZ - (z + chunkZ);
            int indexBase = indexBaseX | z * ChunkProviderAsteroids.CHUNK_SIZE_Y;
            float zz = z + chunkZ;
            for (int y = yMin; y < yMax; y++) {
                float dSizeX = distanceX / (size + sizeXArray[(y - yMin) * zSize + z - zMin]);
                float dSizeZ = distanceZ / (size + sizeZArray[indexXY + y]);
                dSizeX *= dSizeX;
                dSizeZ *= dSizeZ;
                int distanceY = asteroidY - y;
                distanceY *= distanceY;
                float distance = dSizeX + distanceY / sizeY + dSizeZ;
                float distanceAbove = distance;
                distance += this.asteroidTurbulance.getNoise(xx, y, zz);
                if (isHollow && distance <= hollowSize) {
                    distanceAbove += this.asteroidTurbulance.getNoise(xx, y + 1, zz);
                    if (distanceAbove <= 1) {
                        if ((y - 1) == terrainYY) {
                            int index = indexBase | (y + 1);
                            primer.setBlockState(x, y + 1, z, this.LIGHT.getStateFromMeta(this.LIGHT_META));
                        // blockArray[index] = this.LIGHT;
                        // metaArray[index] = this.LIGHT_META;
                        }
                    }
                }
                if (distance <= 1) {
                    int index = indexBase | y;
                    if (isHollow && distance <= hollowSize) {
                        if (y == terrainY) {
                            primer.setBlockState(x, y, z, grassBlock);
                        // blockArray[index] = this.GRASS;
                        // metaArray[index] = this.GRASS_META;
                        } else if (y < terrainY) {
                            primer.setBlockState(x, y, z, dirtBlock);
                        // blockArray[index] = this.DIRT;
                        // metaArray[index] = this.DIRT_META;
                        } else {
                            primer.setBlockState(x, y, z, airBlock);
                        // blockArray[index] = Blocks.air;
                        // metaArray[index] = 0;
                        }
                    } else if (distance <= core.thickness) {
                        if (rand.nextBoolean()) {
                            primer.setBlockState(x, y, z, asteroidCore);
                        // blockArray[index] = core.block;
                        // metaArray[index] = core.meta;
                        } else {
                            primer.setBlockState(x, y, z, asteroidRock0);
                        // blockArray[index] = this.ASTEROID_STONE;
                        // metaArray[index] = this.ASTEROID_STONE_META_0;
                        }
                    } else if (shell != null && distance >= shellThickness) {
                        primer.setBlockState(x, y, z, asteroidShell);
                    // blockArray[index] = shell.block;
                    // metaArray[index] = shell.meta;
                    } else {
                        primer.setBlockState(x, y, z, asteroidRock1);
                    // blockArray[index] = this.ASTEROID_STONE;
                    // metaArray[index] = this.ASTEROID_STONE_META_1;
                    }
                }
            }
        }
    }
    if (isHollow) {
        shellThickness = 0;
        if (shell != null) {
            shellThickness = 1.0 - shell.thickness;
        }
        for (int x = xMin; x < xMax; x++) {
            int indexXY = (x - xMin) * ySize - yMin;
            int indexXZ = (x - xMin) * zSize - zMin;
            int distanceX = asteroidX - (x + chunkX);
            distanceX *= distanceX;
            for (int z = zMin; z < zMax; z++) {
                float sizeModY = sizeYArray[indexXZ + z];
                float sizeY = size + sizeYArray[indexXZ + z];
                sizeY *= sizeY;
                int distanceZ = asteroidZ - (z + chunkZ);
                distanceZ *= distanceZ;
                for (int y = yMin; y < yMax; y++) {
                    float sizeX = size + sizeXArray[(y - yMin) * zSize + z - zMin];
                    float sizeZ = size + sizeZArray[indexXY + y];
                    sizeX *= sizeX;
                    sizeZ *= sizeZ;
                    int distanceY = asteroidY - y;
                    distanceY *= distanceY;
                    float distance = distanceX / sizeX + distanceY / sizeY + distanceZ / sizeZ;
                    distance += this.asteroidTurbulance.getNoise(x + chunkX, y, z + chunkZ);
                    if (distance <= 1) {
                        IBlockState state = primer.getBlockState(x, y, z);
                        IBlockState stateAbove = primer.getBlockState(x, y + 1, z);
                        if (Blocks.AIR == stateAbove.getBlock() && (state.getBlock() == ASTEROID_STONE || state.getBlock() == GRASS)) {
                            if (this.rand.nextInt(GLOWSTONE_CHANCE) == 0) {
                                primer.setBlockState(x, y, z, this.LIGHT.getStateFromMeta(this.LIGHT_META));
                            // blockArray[index] = this.LIGHT;
                            // metaArray[index] = this.LIGHT_META;
                            }
                        }
                    }
                }
            }
        }
    }
}