com.sk89q.worldedit.extent.AbstractDelegateExtent Java Examples

@Subscribe
public void wrapForLogging(EditSessionEvent event) {
    event.setExtent(new AbstractDelegateExtent(event.getExtent()) {

        @Override
        public <T extends BlockStateHolder<T>> boolean setBlock(BlockVector3 pos, T block) throws WorldEditException {
            if (block.getBlockType().getMaterial().isAir()) {
                World world = Bukkit.getWorld(event.getWorld().getName());

                if (world != null) {
                    Location l = new Location(world, pos.getBlockX(), pos.getBlockY(), pos.getBlockZ());

                    if (BlockStorage.hasBlockInfo(l)) {
                        BlockStorage.clearBlockInfo(l);
                    }
                }
            }
            
            return getExtent().setBlock(pos, block);
        }

    });
}
 

public boolean cancel() {
    ExtentTraverser traverser = new ExtentTraverser(this.extent);
    NullExtent nullExtent = new NullExtent(world, BBC.WORLDEDIT_CANCEL_REASON_MANUAL);
    while (traverser != null) {
        ExtentTraverser next = traverser.next();
        Extent get = traverser.get();
        if (get instanceof AbstractDelegateExtent && !(get instanceof NullExtent)) {
            traverser.setNext(nullExtent);
        }
        traverser = next;
    }
    bypassHistory = nullExtent;
    this.extent = nullExtent;
    bypassAll = nullExtent;
    dequeue();
    queue.clear();
    return true;
}
 

public ExtentTraverser<T> next() {
    try {
        if (root instanceof AbstractDelegateExtent) {
            Field field = AbstractDelegateExtent.class.getDeclaredField("extent");
            field.setAccessible(true);
            T value = (T) field.get(root);
            if (value == null) {
                return null;
            }
            return new ExtentTraverser<>(value, this);
        }
        return null;
    } catch (Throwable e) {
        e.printStackTrace();
        return null;
    }
}
 

@Override
public AbstractDelegateExtent getExtent(int x, int y, int z) {
    if (index == extentsArray.length) {
        index = 0;
    }
    return extentsArray[index];
}
 

public @Nullable ResettableExtent getTransform() {
    ExtentTraverser<AbstractDelegateExtent> traverser = new ExtentTraverser(this.extent).find(ResettableExtent.class);
    if (traverser != null) {
        return (ResettableExtent) traverser.get();
    }
    return null;
}
 

public void addTransform(ResettableExtent transform) {
    wrapped = true;
    if (transform == null) {
        ExtentTraverser<AbstractDelegateExtent> traverser = new ExtentTraverser(this.extent).find(ResettableExtent.class);
        AbstractDelegateExtent next = extent;
        while (traverser != null && traverser.get() instanceof ResettableExtent) {
            traverser = traverser.next();
            next = traverser.get();
        }
        this.extent = next;
        return;
    } else {
        this.extent = transform.setExtent(extent);
    }
}
 

@Deprecated
private AbstractDelegateExtent wrapExtent(final AbstractDelegateExtent extent, final EventBus eventBus, EditSessionEvent event, final Stage stage) {
    event = event.clone(stage);
    event.setExtent(extent);
    eventBus.post(event);
    if (event.isCancelled()) {
        return new NullExtent(extent, BBC.WORLDEDIT_CANCEL_REASON_MANUAL);
    }
    final Extent toReturn = event.getExtent();
    if (!(toReturn instanceof AbstractDelegateExtent)) {
        Fawe.debug("Extent " + toReturn + " must be AbstractDelegateExtent");
        return extent;
    }
    if (toReturn != extent) {
        String className = toReturn.getClass().getName().toLowerCase();
        for (String allowed : Settings.IMP.EXTENT.ALLOWED_PLUGINS) {
            if (className.contains(allowed.toLowerCase())) {
                this.wrapped = true;
                return (AbstractDelegateExtent) toReturn;
            }
        }
        if (Settings.IMP.EXTENT.DEBUG) {
            Fawe.debug("&cPotentially unsafe extent blocked: " + toReturn.getClass().getName());
            Fawe.debug("&8 - &7For area restrictions, it is recommended to use the FaweAPI");
            Fawe.debug("&8 - &7For block logging, it is recommended to use use BlocksHub");
            Fawe.debug("&8 - &7To allow this plugin add it to the FAWE `allowed-plugins` list");
            Fawe.debug("&8 - &7To hide this message set `debug` to false in the FAWE config.yml");
            if (toReturn.getClass().getName().contains("CoreProtect")) {
                Fawe.debug("Note on CoreProtect: ");
                Fawe.debug(" - If you disable CP's WE logger (CP config) and this still shows, please update CP");
                Fawe.debug(" - Use BlocksHub and set `debug` false in the FAWE config");
            }
        }
    }
    return extent;
}
 

public boolean insert(T extent) {
    try {
        Field field = AbstractDelegateExtent.class.getDeclaredField("extent");
        field.setAccessible(true);
        field.set(extent, field.get(root));
        field.set(root, extent);
        return true;
    } catch (Throwable e) {
        e.printStackTrace();
        return false;
    }
}
 

public boolean setNext(T next) {
    try {
        Field field = AbstractDelegateExtent.class.getDeclaredField("extent");
        ReflectionUtils.setFailsafeFieldValue(field, root, next);
        return true;
    } catch (Throwable e) {
        e.printStackTrace();
        return false;
    }
}
 

public void cancelEditSafe(Extent parent, BBC reason) throws FaweException {
    try {
        final Field field = AbstractDelegateExtent.class.getDeclaredField("extent");
        field.setAccessible(true);
        Object currentExtent = field.get(parent);
        if (!(currentExtent instanceof NullExtent)) {
            field.set(parent, new NullExtent((Extent) field.get(parent), reason));
        }
    } catch (final Exception e) {
        MainUtil.handleError(e);
    }
    throw new FaweException(reason);
}
 

@Override
public AbstractDelegateExtent getExtent(int x, int y, int z) {
    int index = (x + y + z) % extentsArray.length;
    if (index < 0) {
        index += extentsArray.length;
    }
    return extentsArray[index];
}
 

@Override
public ResettableExtent setExtent(Extent extent) {
    if (collection == null) {
        collection = RandomCollection.of(weights, random);
        extents = new LinkedHashSet<>(weights.keySet());
    }
    for (AbstractDelegateExtent current : extents) {
        if (current instanceof ResettableExtent) {
            ((ResettableExtent) current).setExtent(extent);
        }
    }
    return this;
}
 

@Nullable
@Override
public Entity createEntity(Location location, BaseEntity entity) {
    Entity created = null;
    for (AbstractDelegateExtent extent : extents) created = extent.createEntity(location, entity);
    return created;
}
 

public ResettableExtent setExtent(Extent extent) {
    checkNotNull(extent);
    Extent next = getExtent();
    if (!(next instanceof NullExtent) && !(next instanceof World) && next instanceof ResettableExtent) {
        ((ResettableExtent) next).setExtent(extent);
    } else {
        new ExtentTraverser(this).setNext(new AbstractDelegateExtent(extent));
    }
    return this;
}
 

private void readObject(java.io.ObjectInputStream stream) throws IOException, ClassNotFoundException {
    stream.defaultReadObject();
    if (stream.readBoolean()) {
        try {
            Field field = AbstractDelegateExtent.class.getDeclaredField("extent");
            ReflectionUtils.setFailsafeFieldValue(field, this, stream.readObject());
        } catch (Throwable e) {
            e.printStackTrace();
        }
    }
}
 

@Override
public AbstractDelegateExtent getWorldEditFlag(World world, Extent extent, com.sk89q.worldedit.entity.Player player)
{
	return new WorldEditFlagHandler(world, extent, player);
}
 

@Override
public AbstractDelegateExtent getWorldEditFlag(World world, Extent extent, com.sk89q.worldedit.entity.Player player)
{
	return new WorldEditFlagHandler(world, extent, player);
}
 

@Override
public boolean setBlock(int x, int y, int z, BaseBlock block) throws WorldEditException {
    boolean result = false;
    for (AbstractDelegateExtent extent : extents) result |= extent.setBlock(x, y, z, block);
    return result;
}
 

@Override
public boolean setBlock(Vector location, BaseBlock block) throws WorldEditException {
    boolean result = false;
    for (AbstractDelegateExtent extent : extents) result |= extent.setBlock(location, block);
    return result;
}
 

@Override
public boolean setBiome(Vector2D position, BaseBiome biome) {
    boolean result = false;
    for (AbstractDelegateExtent extent : extents) result |= extent.setBiome(position, biome);
    return result;
}
 

public void setExtent(AbstractDelegateExtent extent) {
    this.extent = extent;
    new ExtentTraverser(this).setNext(extent);
}
 

@Override
public AbstractDelegateExtent getExtent(int x, int y, int z) {
    return collection.next(x, y, z);
}
 

public ProcessedWEExtent(final Extent parent, FaweLimit limit) {
    super(parent);
    this.limit = limit;
    this.extent = (AbstractDelegateExtent) parent;
}
 

@Override
public AbstractDelegateExtent getExtent(int x, int z) {
    return getExtent(x, 0, z);
}
 

@Override
public AbstractDelegateExtent getExtent(int x, int z) {
    return getExtent(x, 0, z);
}
 

@Override
public AbstractDelegateExtent getExtent(int x, int z) {
    return collection.next(x, 0, z);
}
 

public abstract AbstractDelegateExtent getExtent(int x, int z); 

public abstract AbstractDelegateExtent getExtent(int x, int y, int z); 

public AbstractDelegateExtent getWorldEditFlag(World world, Extent extent, com.sk89q.worldedit.entity.Player player);