Java Code Examples for cn.nukkit.level.Level#chunkHash()

@Override
public boolean loadChunk(int x, int z, boolean create) {
    long index = Level.chunkHash(x, z);
    if (this.chunks.containsKey(index)) {
        return true;
    }

    this.level.timings.syncChunkLoadDataTimer.startTiming();
    Chunk chunk = this.readChunk(x, z);
    if (chunk == null && create) {
        chunk = Chunk.getEmptyChunk(x, z, this);
    }
    this.level.timings.syncChunkLoadDataTimer.stopTiming();
    if (chunk != null) {
        this.chunks.put(index, chunk);
        return true;
    }

    return false;
}
 

protected BaseRegionLoader loadRegion(int x, int z) {
    BaseRegionLoader tmp = lastRegion;
    if (tmp != null && x == tmp.getX() && z == tmp.getZ()) {
        return tmp;
    }
    long index = Level.chunkHash(x, z);
    BaseRegionLoader region = this.regions.get(index);
    if (region == null) {
        try {
            region = new RegionLoader(this, x, z);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
        this.regions.put(index, region);
        return lastRegion = region;
    } else {
        return lastRegion = region;
    }
}
 

@Override
public void setChunk(int chunkX, int chunkZ, FullChunk chunk) {
    if (!(chunk instanceof Chunk)) {
        throw new ChunkException("Invalid Chunk class");
    }
    chunk.setProvider(this);

    chunk.setX(chunkX);
    chunk.setZ(chunkZ);
    long index = Level.chunkHash(chunkX, chunkZ);

    if (this.chunks.containsKey(index) && !this.chunks.get(index).equals(chunk)) {
        this.unloadChunk(chunkX, chunkZ, false);
    }

    this.chunks.put(index, (Chunk) chunk);
}
 

@Override
public void setChunk(int chunkX, int chunkZ, FullChunk chunk) {
    if (!(chunk instanceof Chunk)) {
        throw new ChunkException("Invalid Chunk class");
    }
    chunk.setProvider(this);
    int regionX = chunkX >> 5;
    int regionZ = chunkZ >> 5;
    this.loadRegion(regionX, regionZ);
    chunk.setX(chunkX);
    chunk.setZ(chunkZ);
    long index = Level.chunkHash(chunkX, chunkZ);
    if (this.chunks.containsKey(index) && !this.chunks.get(index).equals(chunk)) {
        this.unloadChunk(chunkX, chunkZ, false);
    }
    this.chunks.put(index, (Chunk) chunk);
}
 

protected synchronized BaseRegionLoader loadRegion(int x, int z) {
    BaseRegionLoader tmp = lastRegion.get();
    if (tmp != null && x == tmp.getX() && z == tmp.getZ()) {
        return tmp;
    }
    long index = Level.chunkHash(x, z);
    synchronized (regions) {
        BaseRegionLoader region = this.regions.get(index);
        if (region == null) {
            try {
                region = new RegionLoader(this, x, z);
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
            this.regions.put(index, region);
        }
        lastRegion.set(region);
        return region;
    }
}
 

@Override
public boolean loadChunk(int x, int z, boolean create) {
    long index = Level.chunkHash(x, z);
    if (this.chunks.containsKey(index)) {
        return true;
    }
    int regionX = x >> 5;
    int regionZ = z >> 5;
    this.loadRegion(regionX, regionZ);
    Chunk chunk;
    try {
        chunk = this.getRegion(regionX, regionZ).readChunk(x & 0x1f, z & 0x1f);
    } catch (IOException e) {
        throw new RuntimeException(e);
    }
    if (chunk == null && create) {
        chunk = this.getEmptyChunk(x, z);
    }
    if (chunk != null) {
        this.chunks.put(index, chunk);
        return true;
    }
    return false;
}
 

@Override
public BaseFullChunk getChunk(int chunkX, int chunkZ, boolean create) {
    BaseFullChunk tmp = lastChunk;
    if (tmp != null && tmp.getX() == chunkX && tmp.getZ() == chunkZ) {
        return tmp;
    }
    long index = Level.chunkHash(chunkX, chunkZ);
    lastChunk = tmp = chunks.get(index);
    if (tmp != null) {
        return tmp;
    } else {
        tmp = this.loadChunk(index, chunkX, chunkZ, create);
        lastChunk = tmp;
        return tmp;
    }
}
 

protected BaseRegionLoader loadRegion(int x, int z) {
    BaseRegionLoader tmp = lastRegion.get();
    if (tmp != null && x == tmp.getX() && z == tmp.getZ()) {
        return tmp;
    }
    long index = Level.chunkHash(x, z);
    synchronized (regions) {
        BaseRegionLoader region = this.regions.get(index);
        if (region == null) {
            region = new RegionLoader(this, x, z);
            this.regions.put(index, region);
        }
        lastRegion.set(region);
        return region;
    }
}
 

@Override
public boolean unloadChunk(int X, int Z, boolean safe) {
    long index = Level.chunkHash(X, Z);
    BaseFullChunk chunk = this.chunks.get(index);
    if (chunk != null && chunk.unload(false, safe)) {
        lastChunk = null;
        this.chunks.remove(index, chunk);
        return true;
    }
    return false;
}
 

@Override
public boolean unloadChunk(int X, int Z, boolean safe) {
    long index = Level.chunkHash(X, Z);
    synchronized (chunks) {
        BaseFullChunk chunk = this.chunks.get(index);
        if (chunk != null && chunk.unload(false, safe)) {
            lastChunk.set(null);
            this.chunks.remove(index, chunk);
            return true;
        }
    }
    return false;
}
 

@Override
public boolean unloadChunk(int x, int z, boolean safe) {
    long index = Level.chunkHash(x, z);
    Chunk chunk = this.chunks.containsKey(index) ? this.chunks.get(index) : null;
    if (chunk != null && chunk.unload(false, safe)) {
        this.chunks.remove(index);
        return true;
    }

    return false;
}
 

protected BaseRegionLoader loadRegion(int x, int z) {
    BaseRegionLoader tmp = lastRegion;
    if (tmp != null && x == tmp.getX() && z == tmp.getZ()) {
        return tmp;
    }
    long index = Level.chunkHash(x, z);
    BaseRegionLoader region = this.regions.get(index);
    if (region == null) {
        region = new RegionLoader(this, x, z);
        this.regions.put(index, region);
        return lastRegion = region;
    } else {
        return lastRegion = region;
    }
}
 

@Override
public Chunk getChunk(int x, int z, boolean create) {
    long index = Level.chunkHash(x, z);
    if (this.chunks.containsKey(index)) {
        return this.chunks.get(index);
    } else {
        this.loadChunk(x, z, create);
        return this.chunks.containsKey(index) ? this.chunks.get(index) : null;
    }
}
 

@Override
public boolean loadChunk(int chunkX, int chunkZ, boolean create) {
    long index = Level.chunkHash(chunkX, chunkZ);
    if (this.chunks.containsKey(index)) {
        return true;
    }
    return loadChunk(index, chunkX, chunkZ, create) != null;
}
 

@Override
public boolean unloadChunk(int x, int z, boolean safe) {
    long index = Level.chunkHash(x, z);
    Chunk chunk = this.chunks.containsKey(index) ? this.chunks.get(index) : null;
    if (chunk != null && chunk.unload(false, safe)) {
        this.chunks.remove(index);
        return true;
    }
    return false;
}
 

@Override
public Chunk getChunk(int x, int z, boolean create) {
    long index = Level.chunkHash(x, z);
    if (this.chunks.containsKey(index)) {
        return this.chunks.get(index);
    } else {
        this.loadChunk(x, z, create);
        return this.chunks.containsKey(index) ? this.chunks.get(index) : null;
    }
}
 

@Override
public void setPosition(int x, int z) {
    this.x = x;
    this.z = z;
    this.hash = Level.chunkHash(x, z);
}
 

protected RegionLoader getRegion(int x, int z) {
    long index = Level.chunkHash(x, z);
    return this.regions.containsKey(index) ? this.regions.get(index) : null;
}
 

public final void setZ(int z) {
    this.z = z;
    this.hash = Level.chunkHash(getX(), z);
}
 

public BaseRegionLoader getRegion(int x, int z) {
    long index = Level.chunkHash(x, z);
    return this.regions.get(index);
}