com.sk89q.worldedit.regions.Polygonal2DRegion 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));
}
 

@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 boolean selectPrimary(Vector position, SelectorLimits limits) {
    if (position.equals(pos1)) {
        return false;
    }

    pos1 = position.toBlockVector();
    region = new Polygonal2DRegion(region.getWorld());
    region.addPoint(position);
    region.expandY(position.getBlockY());

    return true;
}
 

private String getRegionTypeName(Region region) {
	String regionType = null;
	if (region instanceof CuboidRegion) {
		regionType = i18n.getString(Messages.Command.CUBOID);
	} else if (region instanceof CylinderRegion) {
		regionType = i18n.getString(Messages.Command.CYLINDRICAL);
	} else if (region instanceof Polygonal2DRegion) {
		regionType = i18n.getString(Messages.Command.POLYGONAL);
	}
	
	return regionType;
}
 

@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 Polygonal2DRegion getRegion() throws IncompleteRegionException {
    if (!isDefined()) {
        throw new IncompleteRegionException();
    }

    return region;
}
 

private void registerShapeProcessors() {
    shapeProcessors.put(CuboidRegion.class, new CuboidProcessor(plugin));
    shapeProcessors.put(Polygonal2DRegion.class, new Polygonal2DProcessor(plugin));
    shapeProcessors.put(EllipsoidRegion.class, new EllipsoidProcessor(plugin));
    shapeProcessors.put(CylinderRegion.class, new CylinderProcessor(plugin));
    shapeProcessors.put(ConvexPolyhedralRegion.class, new ConvexPolyhedralProcessor(plugin));

    if (plugin.getCompatibilityHelper().isUsingFawe()) {
        shapeProcessors.put(FawePolyhedralProcessor.getRegionClass(), new FawePolyhedralProcessor(plugin));
    }
}
 

private static Region adapt(ProtectedRegion region) {
    if (region instanceof ProtectedCuboidRegion) {
        return new CuboidRegion(region.getMinimumPoint(), region.getMaximumPoint());
    }
    if (region instanceof GlobalProtectedRegion) {
        return RegionWrapper.GLOBAL();
    }
    if (region instanceof ProtectedPolygonalRegion) {
        ProtectedPolygonalRegion casted = (ProtectedPolygonalRegion) region;
        BlockVector max = region.getMaximumPoint();
        BlockVector min = region.getMinimumPoint();
        return new Polygonal2DRegion(null, casted.getPoints(), min.getBlockY(), max.getBlockY());
    }
    return new AdaptedRegion(region);
}
 

@NotNull
@Override
public List<Vector3d> getPolygonalPoints() {
    if (region instanceof Polygonal2DRegion) {
        Polygonal2DRegion polygonalRegion = (Polygonal2DRegion) region;

        return polygonalRegion.getPoints().stream()
                .map(vec -> new Vector3d(vec.getX(), 0, vec.getZ()))
                .collect(Collectors.toList());
    }
    throw new UnsupportedOperationException();
}
 

@NotNull
@Override
public List<Vector3d> getPolygonalPoints() {
    if (region instanceof Polygonal2DRegion) {
        Polygonal2DRegion polygonalRegion = (Polygonal2DRegion) region;

        return polygonalRegion.getPoints().stream()
                .map(vec -> new Vector3d(vec.getX(), 0, vec.getZ()))
                .collect(Collectors.toList());
    }
    throw new UnsupportedOperationException();
}
 

@Override
public void processSelection(SelectionPoints selection, Polygonal2DRegion region, RegionAdapter regionAdapter, GlobalSelectionConfig config) {
    double minY = regionAdapter.getMinimumPoint().getY();
    int height = region.getHeight();

    List<Vector3d> bottomCorners = new ArrayList<>();

    for (Vector3d vec2d : regionAdapter.getPolygonalPoints()) {
        bottomCorners.add(vec2d.add(0.5, minY, 0.5));
    }

    createLinesFromBottom(selection, bottomCorners, height, config);
}
 

public Polygonal2DRegionSelector(Polygonal2DRegion region) {
    this.region = region;
}
 

@Override
public Polygonal2DRegion getIncompleteRegion() {
    return region;
}
 

@Override
public void clear() {
    pos1 = null;
    region = new Polygonal2DRegion(region.getWorld());
}
 

public Polygonal2DProcessor(WorldEditSelectionVisualizer plugin) {
    super(Polygonal2DRegion.class, plugin);
}
 

/**
 * 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);
}
 

/**
 * Create a new selector with the given world.
 *
 * @param world the world
 */
public Polygonal2DRegionSelector(@Nullable World world) {
    region = new Polygonal2DRegion(world);
}