public void placeObject(int xx, int yy, int zz, WorldGeneratorObject object) { final Vector3 transformed = transform(xx, yy, zz); if (object.canPlaceObject( position.getWorld(), transformed.getFloorX(), transformed.getFloorY(), transformed.getFloorZ())) { object.placeObject( position.getWorld(), transformed.getFloorX(), transformed.getFloorY(), transformed.getFloorZ()); } }
public void setBlockMaterial(int xx, int yy, int zz, BlockMaterial material, short data) { final Vector3 transformed = transform(xx, yy, zz); position .getWorld() .setBlockMaterial( transformed.getFloorX(), transformed.getFloorY(), transformed.getFloorZ(), material, data, null); if (material instanceof Directional) { final Directional directional = (Directional) material; final Block block = position.getWorld().getBlock(transformed); final BlockFace face = directional.getFacing(block); if (face != BlockFace.BOTTOM && face != BlockFace.TOP) { directional.setFacing( block, BlockFace.fromYaw(face.getDirection().getYaw() + rotation.getYaw())); } } else if (material instanceof Attachable) { final Attachable attachable = (Attachable) material; final Block block = position.getWorld().getBlock(transformed); final BlockFace face = attachable.getAttachedFace(block); if (face != BlockFace.BOTTOM && face != BlockFace.TOP) { attachable.setAttachedFace( block, BlockFace.fromYaw(face.getDirection().getYaw() + rotation.getYaw()), null); } } }
public BlockMaterial getBlockMaterial(int xx, int yy, int zz) { final Vector3 transformed = transform(xx, yy, zz); return position .getWorld() .getBlockMaterial( transformed.getFloorX(), transformed.getFloorY(), transformed.getFloorZ()); }
@Override public boolean commitCuboid(CuboidBlockMaterialBuffer buffer, Cause<?> cause) { Vector3 base = buffer.getBase(); int x = base.getFloorX(); int y = base.getFloorY(); int z = base.getFloorZ(); SpoutChunk[][][] chunks = getChunks(x, y, z, buffer); return commitCuboid(chunks, buffer, cause); }
private static byte getOffsetHash(Vector3 offset) { offset = offset.normalize(); offset = offset.round(); int x = offset.getFloorX(); int y = offset.getFloorY(); int z = offset.getFloorZ(); x += 1; y += 1; z += 1; return (byte) (x | y << 2 | z << 4); }
@Override public void queueChunkForGeneration(final Vector3 chunk) { final int rx = (chunk.getFloorX() >> Region.CHUNKS.BITS); final int ry = (chunk.getFloorY() >> Region.CHUNKS.BITS); final int rz = (chunk.getFloorZ() >> Region.CHUNKS.BITS); SpoutRegion region = getRegion(rx, ry, rz, LoadOption.NO_LOAD); if (region != null) { region.queueChunkForGeneration(chunk); } else { Spout.getScheduler() .scheduleSyncDelayedTask( this, new Runnable() { @Override public void run() { SpoutRegion region = getRegion(rx, ry, rz, LoadOption.LOAD_GEN); region.queueChunkForGeneration(chunk); } }); } }
private SpoutChunk[][][] getChunks(int x, int y, int z, CuboidBlockMaterialBuffer buffer) { Vector3 size = buffer.getSize(); int startX = x; int startY = y; int startZ = z; int endX = x + size.getFloorX(); int endY = y + size.getFloorY(); int endZ = z + size.getFloorZ(); Chunk start = getChunkFromBlock(startX, startY, startZ); Chunk end = getChunkFromBlock(endX - 1, endY - 1, endZ - 1); int chunkStartX = start.getX(); int chunkStartY = start.getY(); int chunkStartZ = start.getZ(); int chunkEndX = end.getX(); int chunkEndY = end.getY(); int chunkEndZ = end.getZ(); int chunkSizeX = chunkEndX - chunkStartX + 1; int chunkSizeY = chunkEndY - chunkStartY + 1; int chunkSizeZ = chunkEndZ - chunkStartZ + 1; SpoutChunk[][][] chunks = new SpoutChunk[chunkSizeX][chunkSizeY][chunkSizeZ]; for (int dx = chunkStartX; dx <= chunkEndX; dx++) { for (int dy = chunkStartY; dy <= chunkEndY; dy++) { for (int dz = chunkStartZ; dz <= chunkEndZ; dz++) { SpoutChunk chunk = getChunk(dx, dy, dz, LoadOption.LOAD_GEN); if (chunk == null) { throw new IllegalStateException("Null chunk loaded with LoadOption.LOAD_GEN"); } chunks[dx - chunkStartX][dy - chunkStartY][dz - chunkStartZ] = chunk; } } } return chunks; }
protected boolean commitCuboid( SpoutChunk[][][] chunks, CuboidBlockMaterialBuffer buffer, Cause<?> cause) { Vector3 base = buffer.getBase(); int x = base.getFloorX(); int y = base.getFloorY(); int z = base.getFloorZ(); lockChunks(chunks); try { for (int dx = 0; dx < chunks.length; dx++) { SpoutChunk[][] subArray1 = chunks[dx]; for (int dy = 0; dy < subArray1.length; dy++) { SpoutChunk[] subArray2 = subArray1[dy]; for (int dz = 0; dz < subArray2.length; dz++) { if (!subArray2[dz].testCuboid(x, y, z, buffer)) { return false; } } } } // set for (int dx = 0; dx < chunks.length; dx++) { SpoutChunk[][] subArray1 = chunks[dx]; for (int dy = 0; dy < subArray1.length; dy++) { SpoutChunk[] subArray2 = subArray1[dy]; for (int dz = 0; dz < subArray2.length; dz++) { subArray2[dz].setCuboid(x, y, z, buffer, cause); } } } return true; } finally { unlockChunks(chunks); } }
/** * Updates the list of chunks around the player. * * @param force Forces the update * @return True if the list was changed */ public boolean updateNearbyChunkMeshes(boolean force) { if (world == null) { world = client.getDefaultWorld(); if (world != null) System.out.println("World updated to " + world.getName() + "-" + world.getUID()); } if (world == null) { try { Thread.sleep(5); } catch (InterruptedException e) { } return false; } int chunkViewDistance = client.getActivePlayer().getViewDistance() / 16; Point currentPos = client.getActivePlayer().getTransform().getPosition(); int currentChunkX = currentPos.getChunkX(); int currentChunkY = currentPos.getChunkY(); int currentChunkZ = currentPos.getChunkZ(); if (currentChunkX == lastChunkX && currentChunkY == lastChunkY && currentChunkZ == lastChunkZ && !force && !firstUpdate) { return false; } // just add all visible chunks if (chunkRenderers.size() == 0 || force) { chunkRenderers.clear(); int cubeMinX = currentChunkX - chunkViewDistance; int cubeMinY = currentChunkY - chunkViewDistance; int cubeMinZ = currentChunkZ - chunkViewDistance; int cubeMaxX = currentChunkX + chunkViewDistance; int cubeMaxY = currentChunkY + chunkViewDistance; int cubeMaxZ = currentChunkZ + chunkViewDistance; Vector3 batchMin = ChunkMeshBatch.getBatchCoordinates(new Vector3(cubeMinX, cubeMinY, cubeMinZ)); Vector3 batchMax = ChunkMeshBatch.getBatchCoordinates(new Vector3(cubeMaxX, cubeMaxY, cubeMaxZ)); for (int x = batchMin.getFloorX(); x <= batchMax.getFloorX(); x++) { for (int y = batchMin.getFloorY(); y <= batchMax.getFloorY(); y++) { for (int z = batchMin.getFloorZ(); z <= batchMax.getFloorZ(); z++) { Vector3 chunkCoords = ChunkMeshBatch.getChunkCoordinates(new Vector3(x, y, z)); ChunkMeshBatch batch = new ChunkMeshBatch( material, world, chunkCoords.getFloorX(), chunkCoords.getFloorY(), chunkCoords.getFloorZ()); addChunkMeshBatch(batch); batch.update(); System.out.println(batch); } } } } else { Cube oldView = new Cube( new Point( world, lastChunkX - chunkViewDistance, lastChunkY - chunkViewDistance, lastChunkZ - chunkViewDistance), chunkViewDistance * 2); Cube newView = new Cube( new Point( world, currentChunkX - chunkViewDistance, currentChunkY - chunkViewDistance, currentChunkZ - chunkViewDistance), chunkViewDistance * 2); Vector3 min = oldView.getBase().min(newView.getBase()); Vector3 max = oldView.getBase().add(oldView.getSize()).max(newView.getBase().add(newView.getSize())); // Shared area Vector3 ignoreMin = oldView.getBase().max(newView.getBase()); Vector3 ignoreMax = oldView.getBase().add(oldView.getSize()).min(newView.getBase().add(newView.getSize())); Cuboid ignore = new Cuboid(new Point(ignoreMin, world), ignoreMax.subtract(ignoreMin)); for (int x = min.getFloorX(); x < max.getFloorX(); x++) { for (int y = min.getFloorY(); y < max.getFloorY(); y++) { for (int z = min.getFloorZ(); z < max.getFloorZ(); z++) { Vector3 vec = new Vector3(x, y, z); if (ignore.contains(vec)) { continue; } Vector3 pos = ChunkMeshBatch.getChunkCoordinates(vec); if (oldView.contains(vec)) { ChunkMeshBatch c = chunkRenderersByPosition.get(pos.getFloorX(), pos.getFloorY(), pos.getFloorZ()); removeChunkMeshBatch(c); continue; } if (newView.contains(vec)) { ChunkMeshBatch c = new ChunkMeshBatch( material, world, pos.getFloorX(), pos.getFloorY(), pos.getFloorZ()); addChunkMeshBatch(c); c.update(); } } } } } firstUpdate = false; lastChunkX = currentChunkX; lastChunkY = currentChunkY; lastChunkZ = currentChunkZ; return true; }
@Override public SpoutChunk getChunkFromBlock(Vector3 position, LoadOption loadopt) { return this.getChunkFromBlock( position.getFloorX(), position.getFloorY(), position.getFloorZ(), loadopt); }
@Override public void getCuboid(CuboidBlockMaterialBuffer buffer) { Vector3 base = buffer.getBase(); getCuboid(base.getFloorX(), base.getFloorY(), base.getFloorZ(), buffer); }
@Override public void setCuboid(CuboidBlockMaterialBuffer buffer, Cause<?> cause) { Vector3 base = buffer.getBase(); setCuboid(base.getFloorX(), base.getFloorY(), base.getFloorZ(), buffer, cause); }
public void offsetPosition(Vector3 offset) { offsetPosition(offset.getFloorX(), offset.getFloorY(), offset.getFloorZ()); }
@Override protected void generateTerrain( CuboidShortBuffer blockData, int x, int y, int z, BiomeManager biomes, long seed) { if (y >= HEIGHT) { return; } final Vector3 size = blockData.getSize(); final int sizeX = size.getFloorX(); final int sizeY = MathHelper.clamp(size.getFloorY(), 0, HEIGHT); final int sizeZ = size.getFloorZ(); ELEVATION.setSeed((int) seed * 23); ROUGHNESS.setSeed((int) seed * 29); DETAIL.setSeed((int) seed * 17); TURBULENCE.setSeed((int) seed * 53); final Random random = WorldGeneratorUtils.getRandom(seed, x, y, z, 6516); final double[][][] noise = WorldGeneratorUtils.fastNoise(FINAL, sizeX, sizeY, sizeZ, 4, x, y, z); final BiomeSelector selector = getSelector(); final TIntPairObjectHashMap<NormalBiome> biomeCache = new TIntPairObjectHashMap<NormalBiome>(); for (int xx = 0; xx < sizeX; xx++) { for (int zz = 0; zz < sizeZ; zz++) { float maxSum = 0; float minSum = 0; byte count = 0; for (int sx = -SMOOTH_SIZE; sx <= SMOOTH_SIZE; sx++) { for (int sz = -SMOOTH_SIZE; sz <= SMOOTH_SIZE; sz++) { final NormalBiome adjacent; if (xx + sx < 0 || zz + sz < 0 || xx + sx >= sizeX || zz + sz >= sizeZ) { if (biomeCache.containsKey(x + xx + sx, z + zz + sz)) { adjacent = biomeCache.get(x + xx + sx, z + zz + sz); } else { adjacent = (NormalBiome) selector.pickBiome(x + xx + sx, y, z + zz + sz, seed); biomeCache.put(x + xx + sx, z + zz + sz, adjacent); } } else { adjacent = (NormalBiome) biomes.getBiome(xx + sx, y, zz + sz); } minSum += adjacent.getMin(); maxSum += adjacent.getMax(); count++; } } final double minElevation = minSum / count; final double smoothHeight = (maxSum / count - minElevation) / 2d; for (int yy = 0; yy < sizeY; yy++) { double noiseValue = noise[xx][yy][zz] - 1 / smoothHeight * (y + yy - smoothHeight - minElevation); if (noiseValue >= 0) { blockData.set(x + xx, y + yy, z + zz, VanillaMaterials.STONE.getId()); } else { if (y + yy <= SEA_LEVEL) { if (y + yy == SEA_LEVEL && ((NormalBiome) biomes.getBiome(xx, 0, zz)).getClimate() == Climate.COLD) { blockData.set(x + xx, y + yy, z + zz, VanillaMaterials.ICE.getId()); } else { blockData.set(x + xx, y + yy, z + zz, VanillaMaterials.WATER.getId()); } } else { blockData.set(x + xx, y + yy, z + zz, VanillaMaterials.AIR.getId()); } } } if (y == 0) { final byte bedrockDepth = (byte) (random.nextInt(BEDROCK_DEPTH) + 1); for (byte yy = 0; yy < bedrockDepth; yy++) { blockData.set(x + xx, yy, z + zz, VanillaMaterials.BEDROCK.getId()); } } } } }