com.sk89q.worldedit.BlockVector2D Java Examples

@Override
public void apply(Map<String, Tag> tags, Polygonal2DRegion region) {
	List<BlockVector2D> points = region.getPoints();
	int minY = region.getMinimumY();
	int maxY = region.getMaximumY();
	
	List<ListTag> pointList = Lists.newArrayList();
	for (BlockVector2D vector : points) {
		List<IntTag> vectorList = Lists.newArrayList();
		vectorList.add(new IntTag(vector.getBlockX()));
		vectorList.add(new IntTag(vector.getBlockZ()));
		
		ListTag vectorListTag = new ListTag(IntTag.class, vectorList);
		pointList.add(vectorListTag);
	}
	
	ListTag pointListTag = new ListTag(ListTag.class, pointList);
	
	tags.put("points", pointListTag);
	tags.put("minY", new IntTag(minY));
	tags.put("maxY", new IntTag(maxY));
}
 

@Override
public <T> T[] toArray(T[] array) {
    int size = size();
    if (array == null || array.length < size) {
        array = (T[]) new BlockVector2D[size];
    }
    int index = 0;
    for (int i = 0; i < size; i++) {
        index = set.nextSetBit(index);
        int x = MathMan.unpairSearchCoordsX(index);
        int y = MathMan.unpairSearchCoordsY(index);
        array[i] = (T) new BlockVector2D(x, y);
        index++;
    }
    return array;
}
 

@SuppressWarnings("unchecked")
@Override
public Polygonal2DRegion asRegion(Element container) {
	Element pointsElement = container.element("points");
	Element minYElement = container.element("minY");
	Element maxYElement = container.element("maxY");
	
	List<Element> pointElementList = pointsElement.elements("point");
	List<BlockVector2D> points = Lists.newArrayList();
	
	for (Element pointElement : pointElementList) {
		int x = Integer.parseInt(pointElement.elementText("x"));
		int z = Integer.parseInt(pointElement.elementText("z"));
		
		BlockVector2D point = new BlockVector2D(x, z);
		points.add(point);
	}
	
	int minY = Integer.parseInt(minYElement.getText());
	int maxY = Integer.parseInt(maxYElement.getText());
	
	return new Polygonal2DRegion((World)null, points, minY, maxY);
}
 

@Override
public void apply(Element applyTo, Polygonal2DRegion region) {
	List<BlockVector2D> points = region.getPoints();
	int minY = region.getMinimumY();
	int maxY = region.getMaximumY();
	
	Element pointsElement = applyTo.addElement("points");
	for (BlockVector2D point : points) {
		Element pointElement = pointsElement.addElement("point");
		
		pointElement.addElement("x").addText(String.valueOf(point.getBlockX()));
		pointElement.addElement("z").addText(String.valueOf(point.getBlockZ()));
	}
	
	applyTo.addElement("minY").addText(String.valueOf(minY));
	applyTo.addElement("maxY").addText(String.valueOf(maxY));
}
 

@Override
public Set<Vector2D> getChunks() {
    final Set<Vector2D> chunks = new HashSet<Vector2D>();

    final Vector min = getMinimumPoint();
    final Vector max = getMaximumPoint();
    final int centerY = getCenter().getBlockY();

    for (int x = min.getBlockX(); x <= max.getBlockX(); ++x) {
        for (int z = min.getBlockZ(); z <= max.getBlockZ(); ++z) {
            if (!contains(new BlockVector(x, centerY, z))) {
                continue;
            }

            chunks.add(new BlockVector2D(
                    x >> ChunkStore.CHUNK_SHIFTS,
                    z >> ChunkStore.CHUNK_SHIFTS
            ));
        }
    }

    return chunks;
}
 

@Override
public boolean selectSecondary(Vector position, SelectorLimits limits) {
    if (region.size() > 0) {
        final List<BlockVector2D> points = region.getPoints();

        final BlockVector2D lastPoint = points.get(region.size() - 1);
        if (lastPoint.getBlockX() == position.getBlockX() && lastPoint.getBlockZ() == position.getBlockZ()) {
            return false;
        }

        Optional<Integer> vertexLimit = limits.getPolygonVertexLimit();

        if (vertexLimit.isPresent() && points.size() > vertexLimit.get()) {
            return false;
        }
    }

    region.addPoint(position);
    region.expandY(position.getBlockY());

    return true;
}
 

@Override
public Polygonal2DRegion asRegion(Map<String, Tag> tags) {
	ListTag pointsListTag = (ListTag) tags.get("points");
	List<Tag> pointList = pointsListTag.getValue();
	List<BlockVector2D> points = Lists.newArrayList();
	
	for (Tag vectorTag : pointList) {
		if (!(vectorTag instanceof ListTag)) {
			continue;
		}
		
		ListTag vectorListTag = (ListTag) vectorTag;
		int x = vectorListTag.getInt(0);
		int z = vectorListTag.getInt(1);
		
		BlockVector2D vector = new BlockVector2D(x, z);
		points.add(vector);
	}
	
	int minY = (int) tags.get("minY").getValue();
	int maxY = (int) tags.get("maxY").getValue();
	
	Polygonal2DRegion region = new Polygonal2DRegion();
	for (BlockVector2D point : points) {
		region.addPoint(point);
	}
	
	region.setMaximumY(maxY);
	region.setMinimumY(minY);
	return region;
}
 

@Override
public void calculateRegions() {
    for (Claim claim : claims) {
        org.bukkit.Location bot = claim.getGreaterBoundaryCorner();
        if (world.equals(bot.getWorld())) {
            org.bukkit.Location top = claim.getGreaterBoundaryCorner();
            BlockVector2D pos1 = new BlockVector2D(bot.getBlockX(), bot.getBlockZ());
            BlockVector2D pos2 = new BlockVector2D(top.getBlockX(), top.getBlockZ());
            add(pos1, pos2);
        }
    }
}
 

@Override
public List<org.bukkit.util.Vector> getRegionPoints(ProtectedRegion region) {
	List<org.bukkit.util.Vector> result = new ArrayList<>();
	for (BlockVector2D point : region.getPoints()) {
		result.add(new org.bukkit.util.Vector(point.getX(), 0,point.getZ()));
	}
	return result;
}
 

@Override
public List<Vector> getRegionPoints(ProtectedRegion region) {
	List<Vector> result = new ArrayList<>();
	for (BlockVector2D point : region.getPoints()) {
		result.add(new Vector(point.getX(), 0,point.getZ()));
	}
	return result;
}
 

@Override
public List<org.bukkit.util.Vector> getRegionPoints(ProtectedRegion region) {
	List<org.bukkit.util.Vector> result = new ArrayList<>();
	for (BlockVector2D point : region.getPoints()) {
		result.add(new org.bukkit.util.Vector(point.getX(), 0,point.getZ()));
	}
	return result;
}
 

@Override
public List<org.bukkit.util.Vector> getRegionPoints(ProtectedRegion region) {
	List<org.bukkit.util.Vector> result = new ArrayList<>();
	for (BlockVector2D point : region.getPoints()) {
		result.add(new org.bukkit.util.Vector(point.getX(), 0,point.getZ()));
	}
	return result;
}
 

/**
 * Create a new selector.
 *
 * @param oldSelector the old selector
 */
public ConvexPolyhedralRegionSelector(RegionSelector oldSelector) {
    checkNotNull(oldSelector);

    if (oldSelector instanceof ConvexPolyhedralRegionSelector) {
        final ConvexPolyhedralRegionSelector convexPolyhedralRegionSelector = (ConvexPolyhedralRegionSelector) oldSelector;

        pos1 = convexPolyhedralRegionSelector.pos1;
        region = new ConvexPolyhedralRegion(convexPolyhedralRegionSelector.region);
    } else {
        final Region oldRegion;
        try {
            oldRegion = oldSelector.getRegion();
        } catch (IncompleteRegionException e) {
            region = new ConvexPolyhedralRegion(oldSelector.getIncompleteRegion().getWorld());
            return;
        }

        final int minY = oldRegion.getMinimumPoint().getBlockY();
        final int maxY = oldRegion.getMaximumPoint().getBlockY();

        region = new ConvexPolyhedralRegion(oldRegion.getWorld());

        for (final BlockVector2D pt : new ArrayList<BlockVector2D>(oldRegion.polygonize(Integer.MAX_VALUE))) {
            region.addVertex(pt.toVector(minY));
            region.addVertex(pt.toVector(maxY));
        }

        learnChanges();
    }
}
 

@Override
public void describeCUI(LocalSession session, Actor player) {
    final List<BlockVector2D> points = region.getPoints();
    for (int id = 0; id < points.size(); id++) {
        session.dispatchCUIEvent(player, new SelectionPoint2DEvent(id, points.get(id), getArea()));
    }

    session.dispatchCUIEvent(player, new SelectionMinMaxEvent(region.getMinimumY(), region.getMaximumY()));
}
 

@Override
public void calculateRegions() {
    ArrayList<Plot> plots = new ArrayList<>(area.getPlots());
    for (Plot plot : plots) {
        Location pos1 = plot.getBottom();
        Location pos2 = plot.getTop();
        add(new BlockVector2D(pos1.getX(), pos1.getZ()), new BlockVector2D(pos2.getX(), pos2.getZ()));
    }
}
 

@Override
public void learnChanges() {
    BlockVector2D pt = region.getPoints().get(0);
    pos1 = new BlockVector(pt.getBlockX(), region.getMinimumPoint().getBlockY(), pt.getBlockZ());
}
 

/**
 * @deprecated cast {@code world} to {@link com.sk89q.worldedit.world.World}
 */
@Deprecated
public Polygonal2DRegionSelector(@Nullable LocalWorld world, List<BlockVector2D> points, int minY, int maxY) {
    this((World) world, points, minY, maxY);
}
 

@Override
public void fixAfterFastMode(Iterable<BlockVector2D> chunks) {
    world.fixAfterFastMode(chunks);
}
 

@Override
public void fixLighting(Iterable<BlockVector2D> chunks) {
    world.fixLighting(chunks);
}
 

@Override
public List<BlockVector2D> polygonize(int maxPoints) {
    return Polygons.polygonizeCylinder(center, radius, maxPoints);
}
 

@Override
default void fixLighting(Iterable<BlockVector2D> chunks) {
}
 

@Override
default void fixAfterFastMode(Iterable<BlockVector2D> chunks) {
}
 

@Override
public void fixLighting(Iterable<BlockVector2D> chunks) {
    parent.fixLighting(chunks);
}
 

@Override
public void fixAfterFastMode(Iterable<BlockVector2D> chunks) {
    parent.fixAfterFastMode(chunks);
}
 

/**
 * Create a new selector.
 *
 * @param world the world
 * @param points a list of points
 * @param minY the minimum Y
 * @param maxY the maximum Y
 */
public Polygonal2DRegionSelector(@Nullable World world, List<BlockVector2D> points, int minY, int maxY) {
    checkNotNull(points);
    
    final BlockVector2D pos2D = points.get(0);
    pos1 = new BlockVector(pos2D.getX(), minY, pos2D.getZ());
    region = new Polygonal2DRegion(world, points, minY, maxY);
}
 

/**
 * Sets the main center point of the region
 *
 * @param center the center point
 */
public void setCenter(Vector2D center) {
    this.center = new BlockVector2D(center);
}
 

@Override
public void fixAfterFastMode(Iterable<BlockVector2D> chunks) {

}