/*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/
package org.pepsoft.worldpainter;
import org.pepsoft.util.ProgressReceiver;
import org.pepsoft.util.ProgressReceiver.OperationCancelled;
import org.pepsoft.util.undo.UndoManager;
import org.pepsoft.worldpainter.biomeschemes.CustomBiome;
import org.pepsoft.worldpainter.gardenofeden.Garden;
import org.pepsoft.worldpainter.layers.Layer;
import org.pepsoft.worldpainter.layers.exporters.ExporterSettings;
import java.awt.*;
import java.beans.PropertyChangeListener;
import java.io.File;
import java.util.*;
import java.util.List;
/**
*
* @author pepijn
*/
public class RODelegatingDimension extends Dimension {
public RODelegatingDimension(Dimension dimension) {
super(dimension.getMinecraftSeed(), dimension.getTileFactory(), dimension.getDim(), dimension.getMaxHeight());
this.dimension = dimension;
}
@Override
public World2 getWorld() {
return dimension.getWorld();
}
@Override
public int getDim() {
return dimension.getDim();
}
@Override
public String getName() {
return dimension.getName();
}
@Override
public boolean isDirty() {
return dimension.isDirty();
}
@Override
public long getSeed() {
return dimension.getSeed();
}
@Override
public Terrain getSubsurfaceMaterial() {
return dimension.getSubsurfaceMaterial();
}
@Override
public boolean isPopulate() {
return dimension.isPopulate();
}
@Override
public Border getBorder() {
return dimension.getBorder();
}
@Override
public int getBorderLevel() {
return dimension.getBorderLevel();
}
@Override
public int getBorderSize() {
return dimension.getBorderSize();
}
@Override
public boolean isDarkLevel() {
return dimension.isDarkLevel();
}
@Override
public boolean isBedrockWall() {
return dimension.isBedrockWall();
}
@Override
public TileFactory getTileFactory() {
return dimension.getTileFactory();
}
@Override
public int getTileCount() {
return dimension.getTileCount();
}
@Override
public void removeTile(Point coords) {
throw new UnsupportedOperationException();
}
@Override
public void removeTile(int tileX, int tileY) {
throw new UnsupportedOperationException();
}
@Override
public int getIntHeightAt(int x, int y) {
return getIntHeightAt(x, y, -1);
}
@Override
public int getIntHeightAt(int x, int y, int defaultValue) {
return dimension.getIntHeightAt(x, y, defaultValue);
}
@Override
public int getIntHeightAt(Point coords) {
return getIntHeightAt(coords.x, coords.y, -1);
}
@Override
public float getHeightAt(int x, int y) {
return dimension.getHeightAt(x, y);
}
@Override
public float getHeightAt(Point coords) {
return getHeightAt(coords.x, coords.y);
}
@Override
public int getRawHeightAt(int x, int y) {
return dimension.getRawHeightAt(x, y);
}
@Override
public int getRawHeightAt(Point coords) {
return getRawHeightAt(coords.x, coords.y);
}
@Override
public void setRawHeightAt(int x, int y, int rawHeight) {
throw new UnsupportedOperationException();
}
@Override
public void setRawHeightAt(Point coords, int rawHeight) {
throw new UnsupportedOperationException();
}
@Override
public Terrain getTerrainAt(int x, int y) {
return super.getTerrainAt(x, y);
}
@Override
public int getWaterLevelAt(int x, int y) {
return dimension.getWaterLevelAt(x, y);
}
@Override
public int getWaterLevelAt(Point coords) {
return dimension.getWaterLevelAt(coords);
}
@Override
public int getLayerValueAt(Layer layer, int x, int y) {
return dimension.getLayerValueAt(layer, x, y);
}
@Override
public int getLayerValueAt(Layer layer, Point coords) {
return getLayerValueAt(layer, coords.x, coords.y);
}
@Override
public boolean getBitLayerValueAt(Layer layer, int x, int y) {
return dimension.getBitLayerValueAt(layer, x, y);
}
@Override
public int getBitLayerCount(Layer layer, int x, int y, int r) {
return dimension.getBitLayerCount(layer, x, y, r);
}
@Override
public float getDistanceToEdge(Layer layer, int x, int y, float maxDistance) {
return dimension.getDistanceToEdge(layer, x, y, maxDistance);
}
@Override
public void clearLayerData(Layer layer) {
throw new UnsupportedOperationException();
}
@Override
public long getMinecraftSeed() {
return dimension.getMinecraftSeed();
}
@Override
public File getOverlay() {
return dimension.getOverlay();
}
@Override
public void setOverlay(File overlay) {
throw new UnsupportedOperationException();
}
@Override
public int getOverlayOffsetX() {
return dimension.getOverlayOffsetX();
}
@Override
public void setOverlayOffsetX(int overlayOffsetX) {
throw new UnsupportedOperationException();
}
@Override
public int getOverlayOffsetY() {
return dimension.getOverlayOffsetY();
}
@Override
public void setOverlayOffsetY(int overlayOffsetY) {
throw new UnsupportedOperationException();
}
@Override
public float getOverlayScale() {
return dimension.getOverlayScale();
}
@Override
public void setOverlayScale(float overlayScale) {
throw new UnsupportedOperationException();
}
@Override
public float getOverlayTransparency() {
return dimension.getOverlayTransparency();
}
@Override
public void setOverlayTransparency(float overlayTransparency) {
throw new UnsupportedOperationException();
}
@Override
public boolean isGridEnabled() {
return dimension.isGridEnabled();
}
@Override
public void setGridEnabled(boolean gridEnabled) {
throw new UnsupportedOperationException();
}
@Override
public int getGridSize() {
return dimension.getGridSize();
}
@Override
public void setGridSize(int gridSize) {
throw new UnsupportedOperationException();
}
@Override
public boolean isOverlayEnabled() {
return dimension.isOverlayEnabled();
}
@Override
public void setOverlayEnabled(boolean overlayEnabled) {
throw new UnsupportedOperationException();
}
@Override
public int getMaxHeight() {
return dimension.getMaxHeight();
}
@Override
public void setMaxHeight(int maxHeight) {
throw new UnsupportedOperationException();
}
@Override
public int getContourSeparation() {
return dimension.getContourSeparation();
}
@Override
public void setContourSeparation(int contourSeparation) {
throw new UnsupportedOperationException();
}
@Override
public boolean isContoursEnabled() {
return dimension.isContoursEnabled();
}
@Override
public void setContoursEnabled(boolean contoursEnabled) {
throw new UnsupportedOperationException();
}
@Override
public int getTopLayerMinDepth() {
return dimension.getTopLayerMinDepth();
}
@Override
public void setTopLayerMinDepth(int topLayerMinDepth) {
throw new UnsupportedOperationException();
}
@Override
public int getTopLayerVariation() {
return dimension.getTopLayerVariation();
}
@Override
public void setTopLayerVariation(int topLayerVariation) {
throw new UnsupportedOperationException();
}
@Override
public boolean isBottomless() {
return dimension.isBottomless();
}
@Override
public void setBottomless(boolean bottomless) {
throw new UnsupportedOperationException();
}
@Override
public Point getLastViewPosition() {
return dimension.getLastViewPosition();
}
@Override
public void setLastViewPosition(Point lastViewPosition) {
throw new UnsupportedOperationException();
}
@Override
public List<CustomBiome> getCustomBiomes() {
return dimension.getCustomBiomes();
}
@Override
public void setCustomBiomes(List<CustomBiome> customBiomes) {
throw new UnsupportedOperationException();
}
@Override
public Garden getGarden() {
return dimension.getGarden();
}
@Override
public Set<Layer> getAllLayers(boolean applyCombinedLayers) {
return dimension.getAllLayers(applyCombinedLayers);
}
@Override
public boolean containsOneOf(Layer... layers) {
return dimension.containsOneOf(layers);
}
@Override
public Set<Layer> getMinimumLayers() {
return dimension.getMinimumLayers();
}
@Override
public boolean undoChanges() {
throw new UnsupportedOperationException();
}
@Override
public void clearUndo() {
throw new UnsupportedOperationException();
}
@Override
public void clearRedo() {
throw new UnsupportedOperationException();
}
@Override
public Dimension getSnapshot() {
return dimension.getSnapshot();
}
@Override
public int getTopLayerDepth(int x, int y, int z) {
return dimension.getTopLayerDepth(x, y, z);
}
@Override
void ensureAllReadable() {
throw new UnsupportedOperationException();
}
@Override
public void removeDimensionListener(Listener listener) {
// Do nothing
}
@Override
public void removePropertyChangeListener(PropertyChangeListener listener) {
// Do nothing
}
@Override
public void removePropertyChangeListener(String propertyName, PropertyChangeListener listener) {
// Do nothing
}
@Override
public void transform(CoordinateTransform transform, ProgressReceiver progressReceiver) throws OperationCancelled {
super.transform(transform, progressReceiver);
}
@Override
public void heightMapChanged(Tile tile) {
// Do nothing
}
@Override
public void terrainChanged(Tile tile) {
// Do nothing
}
@Override
public void waterLevelChanged(Tile tile) {
// Do nothing
}
@Override
public void seedsChanged(Tile tile) {
// Do nothing
}
@Override
public void layerDataChanged(Tile tile, Set<Layer> changedLayers) {
// Do nothing
}
@Override
public void allBitLayerDataChanged(Tile tile) {
// Do nothing
}
@Override
public void allNonBitlayerDataChanged(Tile tile) {
// Do nothing
}
@Override
public void addDimensionListener(Listener listener) {
// Do nothing
}
@Override
public void addPropertyChangeListener(PropertyChangeListener listener) {
// Do nothing
}
@Override
public void addPropertyChangeListener(String propertyName, PropertyChangeListener listener) {
// Do nothing
}
@Override
public void addTile(Tile tile) {
throw new UnsupportedOperationException();
}
@Override
public void applyTheme(int x, int y) {
throw new UnsupportedOperationException();
}
@Override
public void applyTheme(Point coords) {
throw new UnsupportedOperationException();
}
@Override
public void unregister() {
// Do nothing
}
@Override
public void armSavePoint() {
// Do nothing
}
@Override
public void register(UndoManager undoManager) {
// Do nothing
}
@Override
public boolean isUndoAvailable() {
return false;
}
@Override
public int getHeight() {
return dimension.getHeight();
}
@Override
public int getHighestX() {
return dimension.getHighestX();
}
@Override
public int getHighestY() {
return dimension.getHighestY();
}
@Override
public ExporterSettings getLayerSettings(Layer layer) {
throw new UnsupportedOperationException();
}
@Override
public Map<Layer, ExporterSettings> getAllLayerSettings() {
throw new UnsupportedOperationException();
}
@Override
public int getLowestX() {
return dimension.getLowestX();
}
@Override
public int getLowestY() {
return dimension.getLowestY();
}
@Override
public synchronized int getFloodedCount(int x, int y, int r, boolean lava) {
return dimension.getFloodedCount(x, y, r, lava);
}
@Override
public float getSlope(int x, int y) {
return dimension.getSlope(x, y);
}
@Override
public Tile getTile(int x, int y) {
return getTile(new Point(x, y));
}
@Override
public Tile getTile(Point coords) {
// In theory this is not correct, since the dimension might have gained
// or lost tiles in the mean time. However the expected usage pattern
// of the functionality is such that that should not happen in practice,
// and creating tile snapshots of all tiles when the dimension snapshot
// is created would be a performance hit
RODelegatingTile cachedTile = tileCache.get(coords);
if (cachedTile == null) {
Tile tile = dimension.getTile(coords);
if (tile != null) {
cachedTile = new RODelegatingTile(tile);
tileCache.put(coords, cachedTile);
}
}
return cachedTile;
}
@Override
public Collection<? extends Tile> getTiles() {
Collection<? extends Tile> tiles = dimension.getTiles();
for (Tile tile: tiles) {
Point coords = new Point(tile.getX(), tile.getY());
if (! tileCache.containsKey(coords)) {
RODelegatingTile cachedTile = new RODelegatingTile(tile);
tileCache.put(coords, cachedTile);
}
}
return Collections.unmodifiableCollection(tileCache.values());
}
@Override
public Set<Point> getTileCoords() {
return dimension.getTileCoords();
}
@Override
public int getWidth() {
return dimension.getWidth();
}
@Override
public boolean isEventsInhibited() {
return false;
}
@Override
public void removeTile(Tile tile) {
throw new UnsupportedOperationException();
}
@Override
public void setBedrockWall(boolean bedrockWall) {
throw new UnsupportedOperationException();
}
@Override
public void setBitLayerValueAt(Layer layer, int x, int y, boolean value) {
throw new UnsupportedOperationException();
}
@Override
public void setBorder(Border border) {
throw new UnsupportedOperationException();
}
@Override
public void setBorderLevel(int borderLevel) {
throw new UnsupportedOperationException();
}
@Override
public void setBorderSize(int borderSize) {
throw new UnsupportedOperationException();
}
@Override
public void setDarkLevel(boolean darkLevel) {
throw new UnsupportedOperationException();
}
@Override
public void setDirty(boolean dirty) {
throw new UnsupportedOperationException();
}
@Override
public void setEventsInhibited(boolean eventsInhibited) {
throw new UnsupportedOperationException();
}
@Override
public void setHeightAt(int x, int y, float height) {
throw new UnsupportedOperationException();
}
@Override
public void setHeightAt(Point coords, float height) {
throw new UnsupportedOperationException();
}
@Override
public void setLayerSettings(Layer layer, ExporterSettings settings) {
throw new UnsupportedOperationException();
}
@Override
public void setLayerValueAt(Layer layer, int x, int y, int value) {
throw new UnsupportedOperationException();
}
@Override
public void setMinecraftSeed(long minecraftSeed) {
throw new UnsupportedOperationException();
}
@Override
public void setPopulate(boolean populate) {
throw new UnsupportedOperationException();
}
@Override
public void setSubsurfaceMaterial(Terrain subsurfaceMaterial) {
throw new UnsupportedOperationException();
}
@Override
public void setTerrainAt(int x, int y, Terrain terrain) {
throw new UnsupportedOperationException();
}
@Override
public void setTerrainAt(Point coords, Terrain terrain) {
throw new UnsupportedOperationException();
}
@Override
public void setWaterLevelAt(int x, int y, int waterLevel) {
throw new UnsupportedOperationException();
}
@Override
void setWorld(World2 world) {
throw new UnsupportedOperationException();
}
protected final Dimension dimension;
private final Map<Point, RODelegatingTile> tileCache = new HashMap<>();
private static final long serialVersionUID = 1L;
}