LimitedWorldAccessWrapper.java

package net.minecraft.server;


import org.bukkit.event.entity.CreatureSpawnEvent;

import javax.annotation.Nullable;
import java.util.Random;
import java.util.Set;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.stream.Stream;

/**
 * Don't try to solve conflicts here, just generate all delegate methods using IDE
 */
public class LimitedWorldAccessWrapper extends World {

    private final RegionLimitedWorldAccess world;

    LimitedWorldAccessWrapper(RegionLimitedWorldAccess world) {
        super();

        this.world = world;
    }

    public int a() {
        return world.a();
    }

    public int b() {
        return world.b();
    }

    public boolean a(int i, int j) {
        return world.a(i, j);
    }

    @Override
    public IChunkAccess b(int i, int j) {
        return world.b(i, j);
    }

    @Override
    public IBlockData getType(BlockPosition blockposition) {
        return world.getType(blockposition);
    }

    @Override
    public Fluid b(BlockPosition blockposition) {
        return world.b(blockposition);
    }

    @Override
    @Nullable
    public EntityHuman a(double d0, double d1, double d2, double d3, Predicate<Entity> predicate) {
        return world.a(d0, d1, d2, d3, predicate);
    }

    @Override
    public int c() {
        return world.c();
    }

    @Override
    public boolean isEmpty(BlockPosition blockposition) {
        return world.isEmpty(blockposition);
    }

    @Override
    public BiomeBase getBiome(BlockPosition blockposition) {
        return world.getBiome(blockposition);
    }

    @Override
    protected IChunkProvider r() {
        return world.getChunkProvider();
    }

    @Override
    public int getBrightness(EnumSkyBlock enumskyblock, BlockPosition blockposition) {
        return world.getBrightness(enumskyblock, blockposition);
    }

    @Override
    public int getLightLevel(BlockPosition blockposition, int i) {
        return world.getLightLevel(blockposition, i);
    }

    @Override
    public boolean isChunkLoaded(int i, int j, boolean flag) {
        return world.isChunkLoaded(i, j, flag);
    }

    @Override
    public boolean setAir(BlockPosition blockposition, boolean flag) {
        return world.setAir(blockposition, flag);
    }

    @Override
    public boolean e(BlockPosition blockposition) {
        return world.e(blockposition);
    }

    @Override
    @Nullable
    public TileEntity getTileEntity(BlockPosition blockposition) {
        return world.getTileEntity(blockposition);
    }

    @Override
    public boolean setTypeAndData(BlockPosition blockposition, IBlockData iblockdata, int i) {
        return world.setTypeAndData(blockposition, iblockdata, i);
    }

    @Override
    public boolean addEntity(Entity entity) {
        return world.addEntity(entity);
    }

    @Override
    public boolean addEntity(Entity entity, CreatureSpawnEvent.SpawnReason reason) {
        return world.addEntity(entity, reason);
    }

    @Override
    public boolean setAir(BlockPosition blockposition) {
        return world.setAir(blockposition);
    }

    @Override
    public void a(EnumSkyBlock enumskyblock, BlockPosition blockposition, int i) {
        world.a(enumskyblock, blockposition, i);
    }

    @Override
    public WorldBorder getWorldBorder() {
        return world.getWorldBorder();
    }

    @Override
    public boolean a(@Nullable Entity entity, VoxelShape voxelshape) {
        return world.a(entity, voxelshape);
    }

    @Override
    public int a(BlockPosition blockposition, EnumDirection enumdirection) {
        return world.a(blockposition, enumdirection);
    }

    @Override
    public boolean e() {
        return world.e();
    }

    @Override
    @Deprecated
    public World getMinecraftWorld() {
        return world.getMinecraftWorld();
    }

    @Override
    public WorldData getWorldData() {
        return world.getWorldData();
    }

    @Override
    public DifficultyDamageScaler getDamageScaler(BlockPosition blockposition) {
        return world.getDamageScaler(blockposition);
    }

    @Override
    @Nullable
    public PersistentCollection h() {
        return world.h();
    }

    @Override
    public Scoreboard getScoreboard() {
        return null;
    }

    @Override
    public IChunkProvider getChunkProvider() {
        return world.getChunkProvider();
    }

    @Override
    public IDataManager getDataManager() {
        return world.getDataManager();
    }

    @Override
    public long getSeed() {
        return world.getSeed();
    }

    @Override
    public TickList<Block> J() {
        return world.J();
    }

    @Override
    public TickList<FluidType> I() {
        return world.I();
    }

    @Override
    public int getSeaLevel() {
        return world.getSeaLevel();
    }

    @Override
    public Random m() {
        return world.m();
    }

    @Override
    public CraftingManager E() {
        return null;
    }

    @Override
    public TagRegistry F() {
        return null;
    }

    @Override
    public void update(BlockPosition blockposition, Block block) {
        world.update(blockposition, block);
    }

    @Override
    public int a(HeightMap.Type heightmap_type, int i, int j) {
        return world.a(heightmap_type, i, j);
    }

    @Override
    public void a(@Nullable EntityHuman entityhuman, BlockPosition blockposition, SoundEffect soundeffect, SoundCategory soundcategory, float f, float f1) {
        world.a(entityhuman, blockposition, soundeffect, soundcategory, f, f1);
    }

    @Override
    public void addParticle(ParticleParam particleparam, double d0, double d1, double d2, double d3, double d4, double d5) {
        world.addParticle(particleparam, d0, d1, d2, d3, d4, d5);
    }

    @Override
    public BlockPosition getSpawn() {
        return world.getSpawn();
    }

    @Override
    public WorldProvider o() {
        return world.o();
    }

    @Override
    public float ah() {
        return world.ah();
    }

    @Override
    public float k(float f) {
        return world.k(f);
    }

    @Override
    public IChunkAccess y(BlockPosition blockposition) {
        return world.y(blockposition);
    }

    @Override
    public EnumDifficulty getDifficulty() {
        return world.getDifficulty();
    }

    @Override
    public boolean z(BlockPosition blockposition) {
        return world.z(blockposition);
    }

    @Override
    public BlockPosition getHighestBlockYAt(HeightMap.Type heightmap$type, BlockPosition blockposition) {
        return world.getHighestBlockYAt(heightmap$type, blockposition);
    }

    @Override
    public float A(BlockPosition blockposition) {
        return world.A(blockposition);
    }

    @Override
    @Nullable
    public EntityHuman findNearbyPlayer(Entity entity, double d0) {
        return world.findNearbyPlayer(entity, d0);
    }

    @Override
    @Nullable
    public EntityHuman b(Entity entity, double d0) {
        return world.b(entity, d0);
    }

    @Override
    @Nullable
    public EntityHuman a(double d0, double d1, double d2, double d3, boolean flag) {
        return world.a(d0, d1, d2, d3, flag);
    }

    @Override
    public boolean a(IBlockData iblockdata, BlockPosition blockposition) {
        return world.a(iblockdata, blockposition);
    }

    @Override
    public boolean a_(@Nullable Entity entity, AxisAlignedBB axisalignedbb) {
        return world.a_(entity, axisalignedbb);
    }

    @Override
    public Stream<VoxelShape> a(VoxelShape voxelshape, VoxelShape voxelshape1, boolean flag) {
        return world.a(voxelshape, voxelshape1, flag);
    }

    @Override
    public Stream<VoxelShape> a(@Nullable Entity entity, AxisAlignedBB axisalignedbb, double d0, double d1, double d2) {
        return world.a(entity, axisalignedbb, d0, d1, d2);
    }

    @Override
    public Stream<VoxelShape> a(@Nullable Entity entity, AxisAlignedBB axisalignedbb, Set<Entity> set, double d0, double d1, double d2) {
        return world.a(entity, axisalignedbb, set, d0, d1, d2);
    }

    @Override
    public Stream<VoxelShape> b(@Nullable Entity entity, AxisAlignedBB axisalignedbb) {
        return world.b(entity, axisalignedbb);
    }

    @Override
    public Stream<VoxelShape> a(@Nullable Entity entity, VoxelShape voxelshape, VoxelShape voxelshape1, Set<Entity> var4) {
        return world.a(entity, voxelshape, voxelshape1, var4);
    }

    @Override
    public boolean i(Entity entity) {
        return world.i(entity);
    }

    @Override
    public boolean a(@Nullable Entity entity, AxisAlignedBB axisalignedbb, Set<Entity> set) {
        return world.a(entity, axisalignedbb, set);
    }

    @Override
    public boolean getCubes(@Nullable Entity entity, AxisAlignedBB axisalignedbb) {
        return world.getCubes(entity, axisalignedbb);
    }

    @Override
    public boolean B(BlockPosition blockposition) {
        return world.B(blockposition);
    }

    @Override
    public boolean containsLiquid(AxisAlignedBB axisalignedbb) {
        return world.containsLiquid(axisalignedbb);
    }

    @Override
    public int getLightLevel(BlockPosition blockposition) {
        return world.getLightLevel(blockposition);
    }

    @Override
    public int d(BlockPosition blockposition, int i) {
        return world.d(blockposition, i);
    }

    @Override
    public boolean isLoaded(BlockPosition blockposition) {
        return world.isLoaded(blockposition);
    }

    @Override
    public boolean b(BlockPosition blockposition, boolean flag) {
        return world.b(blockposition, flag);
    }

    @Override
    public boolean areChunksLoaded(BlockPosition blockposition, int i) {
        return world.areChunksLoaded(blockposition, i);
    }

    @Override
    public boolean areChunksLoaded(BlockPosition blockposition, int i, boolean flag) {
        return world.areChunksLoaded(blockposition, i, flag);
    }

    @Override
    public boolean areChunksLoadedBetween(BlockPosition blockposition, BlockPosition blockposition1) {
        return world.areChunksLoadedBetween(blockposition, blockposition1);
    }

    @Override
    public boolean areChunksLoadedBetween(BlockPosition blockposition, BlockPosition blockposition1, boolean flag) {
        return world.areChunksLoadedBetween(blockposition, blockposition1, flag);
    }

    @Override
    public boolean a(StructureBoundingBox structureboundingbox) {
        return world.a(structureboundingbox);
    }

    @Override
    public boolean a(StructureBoundingBox structureboundingbox, boolean flag) {
        return world.a(structureboundingbox, flag);
    }

    @Override
    public boolean isAreaLoaded(int i, int j, int k, int l, int i1, int j1, boolean flag) {
        return world.isAreaLoaded(i, j, k, l, i1, j1, flag);
    }

    @Override
    public int K() {
        return world.K();
    }

    @Override
    @Nullable
    public <T extends PersistentBase> T a(DimensionManager dimensionmanager, Function<String, T> function, String s) {
        return world.a(dimensionmanager, function, s);
    }

    @Override
    public void a(DimensionManager dimensionmanager, String s, PersistentBase persistentbase) {
        world.a(dimensionmanager, s, persistentbase);
    }

    @Override
    public int a(DimensionManager dimensionmanager, String s) {
        return world.a(dimensionmanager, s);
    }
}