protected final int getRelativeIndex(int x, int y, int z) { if (!relativeRegion.encompasses(x, y, z)) { throw new IllegalArgumentException(String.format("Out of bounds: (%d, %d, %d) for region %s", x, y, z, relativeRegion.toString())); } return x - relativeRegion.minX() + relativeRegion.sizeX() * (y - relativeRegion.minY() + relativeRegion.sizeY() * (z - relativeRegion.minZ())); }
private void reviewRelevantChunks(Vector3i distance) { Vector3i extents = new Vector3i(distance.x / 2, distance.y / 2, distance.z / 2); Region3i retainRegion = Region3i.createFromCenterExtents(center, extents); Iterator<Vector3i> iter = relevantChunks.iterator(); while (iter.hasNext()) { Vector3i pos = iter.next(); if (!retainRegion.encompasses(pos)) { sendChunkIrrelevant(pos); iter.remove(); } } }
/** * Returns a 3D representation of the workd, a region in this case. With the borders added to it. * @param region The region to be expanded with the borders. * @return The 3D world representation with the additional space added to it in the 3 dimensions. */ public Region3i expandTo3D(Region3i region) { return Region3i.createFromMinMax(new Vector3i(region.minX() - sides, region.minY() - bottom, region.minZ() - sides), new Vector3i(region.maxX() + sides, region.maxY() + top, region.maxZ() + sides)); }
/** * @param other * @return The region that is encompassed by both this and other. If they * do not overlap then the empty region is returned */ public Region3i intersect(Region3i other) { Vector3i intersectMin = min(); intersectMin.max(other.min()); Vector3i intersectMax = max(); intersectMax.min(other.max()); return createFromMinMax(intersectMin, intersectMax); }
@Override public byte getValueAt(Vector3i pos) { if (!relevantRegion.encompasses(pos)) { return UNAVAILABLE; } return lightData.get(pos); }
@Test public void testCreateRegionWithMinAndSize() { List<Vector3i> mins = Arrays.asList(new Vector3i(), new Vector3i(1, 1, 1), new Vector3i(3, 4, 5)); List<Vector3i> size = Arrays.asList(new Vector3i(1, 1, 1), new Vector3i(3, 3, 3), new Vector3i(8, 5, 2)); List<Vector3i> expectedMax = Arrays.asList(new Vector3i(), new Vector3i(3, 3, 3), new Vector3i(10, 8, 6)); for (int i = 0; i < mins.size(); ++i) { Region3i region = Region3i.createFromMinAndSize(mins.get(i), size.get(i)); assertEquals(mins.get(i), region.min()); assertEquals(size.get(i), region.size()); assertEquals(expectedMax.get(i), region.max()); assertFalse(region.isEmpty()); } }
/** * Returns a 2D representation of the world (top view) with the given borders added to the size of the original region. * @param region The original region to be used. * @return The 2D representation with the additional space added to it. */ public Rect2i expandTo2D(Region3i region) { return Rect2i.createFromMinAndMax(region.minX() - getSides(), region.minZ() - getSides(), region.maxX() + getSides(), region.maxZ() + getSides()); }
@ReceiveEvent public void openDoor(OpenDoorEvent event, EntityRef player) { EntityRef entity = event.getDoorEntity(); DoorComponent door = entity.getComponent(DoorComponent.class); Side newSide = door.openSide; BlockRegionComponent regionComp = entity.getComponent(BlockRegionComponent.class); Block bottomBlock = door.bottomBlockFamily.getBlockForPlacement(regionComp.region.min(), newSide, Side.TOP); worldProvider.setBlock(regionComp.region.min(), bottomBlock); Block topBlock = door.topBlockFamily.getBlockForPlacement(regionComp.region.max(), newSide, Side.TOP); worldProvider.setBlock(regionComp.region.max(), topBlock); if (door.openSound != null) { entity.send(new PlaySoundEvent(door.openSound, 1f)); } door.isOpen = true; } }
private boolean makeChunkAvailable(final Chunk chunk) { for (Vector3i pos : Region3i.createFromCenterExtents(chunk.getPosition(), 1)) { if (chunkCache.get(pos) == null) { return false; } } lightMerger.beginMerge(chunk, chunk); return true; }
@Override public ChunkViewCore getSubviewAroundChunk(Vector3i chunkPos) { Region3i region = Region3i.createFromCenterExtents(chunkPos, ChunkConstants.LOCAL_REGION_EXTENTS); if (getChunk(chunkPos) != null) { return createWorldView(region, new Vector3i(-region.min().x, -region.min().y, -region.min().z)); } return null; }
/** * @throws IllegalArgumentException if not within bounds */ protected void checkWorldCoords(int x, int y, int z) { if (!worldRegion.encompasses(x, y, z)) { String text = "Out of bounds: (%d, %d, %d) for region %s"; String msg = String.format(text, x, y, z, worldRegion.toString()); throw new IllegalArgumentException(msg); } }
/** * @param offset * @return A copy of the region offset by the given value */ public Region3i move(BaseVector3i offset) { Vector3i newMin = min(); newMin.add(offset); return Region3i.createFromMinAndSize(newMin, size); }
@Test public void testCumulativeBorderCalculation() { WorldBuilder worldBuilder = new WorldBuilder(context.get(WorldGeneratorPluginLibrary.class)); worldBuilder.setSeed(12); worldBuilder.addProvider(new Facet1Provider()); worldBuilder.addProvider(new Facet2Provider()); worldBuilder.addProvider(new Facet3Provider()); World world = worldBuilder.build(); Region3i regionToGenerate = Region3i.createFromCenterExtents(new Vector3i(), 1); Region regionData = world.getWorldData(regionToGenerate); Facet3 facet3 = regionData.getFacet(Facet3.class); assertEquals(regionToGenerate, facet3.getWorldRegion()); Facet1 facet1 = regionData.getFacet(Facet1.class); assertEquals(Region3i.createFromMinAndSize(new Vector3i(-2, -1, -2), new Vector3i(5, 3, 5)), facet1.getWorldRegion()); Facet2 facet2 = regionData.getFacet(Facet2.class); assertEquals(Region3i.createFromMinAndSize(new Vector3i(-4, -1, -4), new Vector3i(9, 3, 9)), facet2.getWorldRegion()); }
@ReceiveEvent(components = {LocationComponent.class}) public void onStartSelectionAtEntity(SetBlockSelectionStartingPointEvent event, EntityRef entity) { LocationComponent locationComponent = entity.getComponent(LocationComponent.class); if (null == locationComponent) { // entity isn't LocationComponent, which shouldn't ever be the case return; } BlockSelectionComponent blockSelectionComponent = event.getBlockSelectionComponent(); if (null == blockSelectionComponent) { // event did not provide a BlockSelection component to modify return; } Vector3f worldPosition = locationComponent.getWorldPosition(); Vector3i startPosition = new Vector3i(worldPosition.x, worldPosition.y, worldPosition.z); blockSelectionComponent.startPosition = startPosition; Vector3i endPosition = startPosition; blockSelectionComponent.currentSelection = Region3i.createBounded(startPosition, endPosition); }
private Region createRegion(ImmutableVector2i chunkPos) { int vertChunks = 4; // 4 chunks high (relevant for trees, etc) int minX = chunkPos.getX() * TILE_SIZE_X; int minZ = chunkPos.getY() * TILE_SIZE_Y; int height = vertChunks * ChunkConstants.SIZE_Y; Region3i area3d = Region3i.createFromMinAndSize(new Vector3i(minX, 0, minZ), new Vector3i(TILE_SIZE_X, height, TILE_SIZE_Y)); World world = worldGenerator.getWorld(); Region region = world.getWorldData(area3d); return region; }
@Test public void testNonTouchingIntersect() { Region3i region1 = Region3i.createFromMinMax(new Vector3i(), new Vector3i(32, 32, 32)); Region3i region2 = Region3i.createFromMinMax(new Vector3i(103, 103, 103), new Vector3i(170, 170, 170)); assertEquals(Region3i.empty(), region1.intersect(region2)); }
@Override public void propagateBetween(LitChunk chunk, LitChunk adjChunk, Side side, boolean propagateExternal) { IndexProvider indexProvider = createIndexProvider(side); Region3i edgeRegion = ChunkMath.getEdgeRegion(Region3i.createFromMinAndSize(Vector3i.zero(), ChunkConstants.CHUNK_SIZE), side); int edgeSize = edgeRegion.size().x * edgeRegion.size().y * edgeRegion.size().z; int[] depth = new int[edgeSize]; propagateSide(chunk, adjChunk, side, indexProvider, edgeRegion, depth); propagateDepth(adjChunk, side, propagateExternal, indexProvider, edgeRegion, depth); }