use of org.pepsoft.worldpainter.layers.exporters.FrostExporter.FrostSettings in project WorldPainter by Captain-Chaos.
the class Configuration method readObject.
@SuppressWarnings("deprecation")
private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
in.defaultReadObject();
// Legacy config
if ((border != null) && (border2 == null)) {
border2 = Border.valueOf(border.name());
border = null;
}
if (customMaterials == null) {
customMaterials = new Material[] { Material.DIRT, Material.DIRT, Material.DIRT, Material.DIRT, Material.DIRT };
}
if (minecraftJars == null) {
minecraftJars = new HashMap<>();
minecraft1_9_p3Jar = null;
}
if (uuid == null) {
uuid = UUID.randomUUID();
}
if (undoLevels == 0) {
checkForUpdates = true;
undoEnabled = true;
defaultContoursEnabled = true;
undoLevels = 100;
defaultGridSize = 128;
defaultContourSeparation = 10;
defaultWidth = 5;
defaultHeight = 5;
defaultMaxHeight = DEFAULT_MAX_HEIGHT_2;
}
if (defaultTerrainAndLayerSettings == null) {
defaultTerrainAndLayerSettings = new Dimension(World2.DEFAULT_OCEAN_SEED, TileFactoryFactory.createNoiseTileFactory(new Random().nextLong(), surface, defaultMaxHeight, level, waterLevel, lava, beaches, 20, 1.0), Constants.DIM_NORMAL, defaultMaxHeight);
}
// New legacy mechanism with version number
if (version < 1) {
worldFileBackups = 3;
}
if (version < 2) {
defaultRange = 20;
defaultScale = 1.0;
defaultLightOrigin = LightOrigin.NORTHWEST;
}
if (version < 3) {
String maxRadiusStr = System.getProperty("org.pepsoft.worldpainter.maxRadius");
if ((maxRadiusStr != null) && (!maxRadiusStr.trim().isEmpty())) {
try {
maximumBrushSize = Integer.parseInt(maxRadiusStr);
} catch (NumberFormatException e) {
maximumBrushSize = 300;
}
} else {
maximumBrushSize = 300;
}
}
if (version < 4) {
// Turn on smooth snow for everyone once
FrostSettings frostSettings = (FrostSettings) defaultTerrainAndLayerSettings.getLayerSettings(Frost.INSTANCE);
if (frostSettings != null) {
frostSettings.setMode(FrostSettings.MODE_SMOOTH);
}
}
if (version < 5) {
// Reset the Resource setting preferences once, which might have
// been unintentionally altered due to a bug
defaultTerrainAndLayerSettings.setLayerSettings(Resources.INSTANCE, new ResourcesExporterSettings(defaultMaxHeight));
}
if (version < 6) {
if (!Boolean.FALSE.equals(pingAllowed)) {
eventLog = new LinkedList<>();
}
}
if (version < 7) {
customLayers = new ArrayList<>();
mixedMaterials = new ArrayList<>();
}
if (version < 8) {
// continue to the top of the map
if ((defaultTerrainAndLayerSettings.getTileFactory() instanceof HeightMapTileFactory) && (((HeightMapTileFactory) defaultTerrainAndLayerSettings.getTileFactory()).getTheme() instanceof SimpleTheme)) {
SimpleTheme theme = (SimpleTheme) ((HeightMapTileFactory) defaultTerrainAndLayerSettings.getTileFactory()).getTheme();
// luck; it's not worth migrating them as well
if (theme.getTerrainRanges() != null) {
SortedMap<Integer, Terrain> terrainRanges = theme.getTerrainRanges();
Map<Filter, Layer> layerMap = new HashMap<>();
boolean frostAdded = false;
for (Map.Entry<Integer, Terrain> entry : terrainRanges.entrySet()) {
if (entry.getValue() == Terrain.SNOW) {
if (!frostAdded) {
layerMap.put(new HeightFilter(defaultMaxHeight, entry.getKey(), defaultMaxHeight - 1, theme.isRandomise()), Frost.INSTANCE);
frostAdded = true;
}
entry.setValue(Terrain.ROCK);
}
}
if (!layerMap.isEmpty()) {
theme.setLayerMap(layerMap);
}
}
}
}
if (version < 9) {
// Set default export settings
defaultCreateGoodiesChest = true;
defaultGenerator = Generator.DEFAULT;
defaultMapFeatures = true;
defaultGameType = 0;
}
if (version < 10) {
if (defaultTerrainAndLayerSettings.getSubsurfaceMaterial() == Terrain.STONE) {
defaultTerrainAndLayerSettings.setSubsurfaceMaterial(Terrain.STONE_MIX);
}
}
if (version < 11) {
switch(SystemUtils.getOS()) {
case WINDOWS:
accelerationType = AccelerationType.DIRECT3D;
break;
case MAC:
accelerationType = AccelerationType.DEFAULT;
break;
case LINUX:
accelerationType = AccelerationType.XRENDER;
break;
default:
accelerationType = AccelerationType.DEFAULT;
break;
}
// Previous default; principle of least surprise:
overlayType = OverlayType.SCALE_ON_LOAD;
}
if (version < 12) {
defaultJideLayoutData = null;
jideLayoutData = null;
showCalloutCount = 3;
}
if (version < 13) {
backgroundImageMode = TiledImageViewer.BackgroundImageMode.REPEAT;
backgroundColour = -1;
showBiomes = showBorders = true;
}
if (version < 14) {
if (defaultGameType >= 0) {
defaultGameTypeObj = GameType.values()[defaultGameType];
defaultGameType = -1;
} else {
// Not sure how this could have happened, but it has been
// observed
defaultGameTypeObj = GameType.SURVIVAL;
defaultGameType = -1;
}
}
if (version < 15) {
defaultPlatform = DefaultPlugin.JAVA_ANVIL;
exportDirectories = new HashMap<>();
if (exportDirectory != null) {
exportDirectories.put(DefaultPlugin.JAVA_ANVIL, exportDirectory);
exportDirectories.put(DefaultPlugin.JAVA_MCREGION, exportDirectory);
exportDirectory = null;
}
}
version = CURRENT_VERSION;
// Bug fix: make sure terrain ranges map conforms to surface material setting
TileFactory tileFactory = defaultTerrainAndLayerSettings.getTileFactory();
if ((tileFactory instanceof HeightMapTileFactory) && (((HeightMapTileFactory) tileFactory).getTheme() instanceof SimpleTheme)) {
SortedMap<Integer, Terrain> defaultTerrainRanges = ((SimpleTheme) ((HeightMapTileFactory) tileFactory).getTheme()).getTerrainRanges();
// Find what is probably meant to be the surface material. With the
// default settings this should be -1, but if someone configured a
// default underwater material, try not to change that
int surfaceLevel = defaultTerrainRanges.headMap(waterLevel + 3).lastKey();
defaultTerrainRanges.put(surfaceLevel, surface);
}
}
use of org.pepsoft.worldpainter.layers.exporters.FrostExporter.FrostSettings in project WorldPainter by Captain-Chaos.
the class JavaMapImporter method doImport.
public World2 doImport(ProgressReceiver progressReceiver) throws IOException, ProgressReceiver.OperationCancelled {
long start = System.currentTimeMillis();
logger.info("Importing map from " + levelDatFile.getAbsolutePath());
Level level = Level.load(levelDatFile);
int version = level.getVersion();
if ((version != SUPPORTED_VERSION_1) && (version != SUPPORTED_VERSION_2)) {
throw new UnsupportedOperationException("Level format version " + version + " not supported");
}
String name = level.getName().trim();
int maxHeight = level.getMaxHeight();
World2 world = new World2((version == SUPPORTED_VERSION_1) ? JAVA_MCREGION : JAVA_ANVIL, maxHeight);
world.addHistoryEntry(HistoryEntry.WORLD_IMPORTED_FROM_MINECRAFT_MAP, level.getName(), levelDatFile.getParentFile());
world.setCreateGoodiesChest(false);
world.setName(name);
world.setSpawnPoint(new Point(level.getSpawnX(), level.getSpawnZ()));
world.setImportedFrom(levelDatFile);
world.setMapFeatures(level.isMapFeatures());
if (level.isHardcore()) {
world.setGameType(GameType.HARDCORE);
} else {
world.setGameType(GameType.values()[level.getGameType()]);
}
world.setGenerator(level.getGenerator());
world.setGeneratorOptions(level.getGeneratorOptions());
world.setDifficulty(level.getDifficulty());
if ((version == SUPPORTED_VERSION_2) && (level.getBorderSize() > 0.0)) {
// If the world is version 0x4abd and actually has border settings,
// load them
world.getBorderSettings().setCentreX((int) (level.getBorderCenterX() + 0.5));
world.getBorderSettings().setCentreY((int) (level.getBorderCenterZ() + 0.5));
world.getBorderSettings().setSize((int) (level.getBorderSize() + 0.5));
world.getBorderSettings().setSafeZone((int) (level.getBorderSafeZone() + 0.5));
world.getBorderSettings().setWarningBlocks((int) (level.getBorderWarningBlocks() + 0.5));
world.getBorderSettings().setWarningTime((int) (level.getBorderWarningTime() + 0.5));
world.getBorderSettings().setSizeLerpTarget((int) (level.getBorderSizeLerpTarget() + 0.5));
world.getBorderSettings().setSizeLerpTime((int) level.getBorderSizeLerpTime());
world.getBorderSettings().setDamagePerBlock((int) (level.getBorderDamagePerBlock() + 0.5));
}
File worldDir = levelDatFile.getParentFile();
File regionDir = new File(worldDir, "region");
File netherDir = new File(worldDir, "DIM-1/region");
File endDir = new File(worldDir, "DIM1/region");
int dimCount = 1;
if (netherDir.isDirectory() && dimensionsToImport.contains(DIM_NETHER)) {
dimCount++;
}
if (endDir.isDirectory() && dimensionsToImport.contains(DIM_END)) {
dimCount++;
}
long minecraftSeed = level.getSeed();
tileFactory.setSeed(minecraftSeed);
Dimension dimension = new Dimension(minecraftSeed, tileFactory, DIM_NORMAL, maxHeight);
dimension.setEventsInhibited(true);
try {
dimension.setCoverSteepTerrain(false);
dimension.setSubsurfaceMaterial(Terrain.STONE);
dimension.setBorderLevel(62);
// Turn off smooth snow
FrostSettings frostSettings = new FrostSettings();
frostSettings.setMode(FrostSettings.MODE_FLAT);
dimension.setLayerSettings(Frost.INSTANCE, frostSettings);
ResourcesExporterSettings resourcesSettings = (ResourcesExporterSettings) dimension.getLayerSettings(Resources.INSTANCE);
resourcesSettings.setMinimumLevel(0);
if (version == SUPPORTED_VERSION_1) {
resourcesSettings.setChance(BLK_EMERALD_ORE, 0);
}
Configuration config = Configuration.getInstance();
dimension.setGridEnabled(config.isDefaultGridEnabled());
dimension.setGridSize(config.getDefaultGridSize());
dimension.setContoursEnabled(config.isDefaultContoursEnabled());
dimension.setContourSeparation(config.getDefaultContourSeparation());
String dimWarnings = importDimension(regionDir, dimension, version, (progressReceiver != null) ? new SubProgressReceiver(progressReceiver, 0.0f, 1.0f / dimCount) : null);
if (dimWarnings != null) {
if (warnings == null) {
warnings = dimWarnings;
} else {
warnings = warnings + dimWarnings;
}
}
} finally {
dimension.setEventsInhibited(false);
}
world.addDimension(dimension);
int dimNo = 1;
if (netherDir.isDirectory() && dimensionsToImport.contains(DIM_NETHER)) {
HeightMapTileFactory netherTileFactory = TileFactoryFactory.createNoiseTileFactory(minecraftSeed + 1, Terrain.NETHERRACK, maxHeight, 188, 192, true, false, 20f, 1.0);
SimpleTheme theme = (SimpleTheme) netherTileFactory.getTheme();
SortedMap<Integer, Terrain> terrainRanges = theme.getTerrainRanges();
terrainRanges.clear();
terrainRanges.put(-1, Terrain.NETHERRACK);
theme.setTerrainRanges(terrainRanges);
theme.setLayerMap(null);
dimension = new Dimension(minecraftSeed + 1, netherTileFactory, DIM_NETHER, maxHeight);
dimension.setEventsInhibited(true);
try {
dimension.setCoverSteepTerrain(false);
dimension.setSubsurfaceMaterial(Terrain.NETHERRACK);
ResourcesExporterSettings resourcesSettings = (ResourcesExporterSettings) dimension.getLayerSettings(Resources.INSTANCE);
resourcesSettings.setMinimumLevel(0);
if (version == SUPPORTED_VERSION_1) {
resourcesSettings.setChance(BLK_QUARTZ_ORE, 0);
}
String dimWarnings = importDimension(netherDir, dimension, version, (progressReceiver != null) ? new SubProgressReceiver(progressReceiver, (float) dimNo++ / dimCount, 1.0f / dimCount) : null);
if (dimWarnings != null) {
if (warnings == null) {
warnings = dimWarnings;
} else {
warnings = warnings + dimWarnings;
}
}
} finally {
dimension.setEventsInhibited(false);
}
world.addDimension(dimension);
}
if (endDir.isDirectory() && dimensionsToImport.contains(DIM_END)) {
HeightMapTileFactory endTileFactory = TileFactoryFactory.createNoiseTileFactory(minecraftSeed + 2, Terrain.END_STONE, maxHeight, 32, 0, false, false, 20f, 1.0);
SimpleTheme theme = (SimpleTheme) endTileFactory.getTheme();
SortedMap<Integer, Terrain> terrainRanges = theme.getTerrainRanges();
terrainRanges.clear();
terrainRanges.put(-1, Terrain.END_STONE);
theme.setTerrainRanges(terrainRanges);
theme.setLayerMap(Collections.emptyMap());
dimension = new Dimension(minecraftSeed + 2, endTileFactory, DIM_END, maxHeight);
dimension.setEventsInhibited(true);
try {
dimension.setCoverSteepTerrain(false);
dimension.setSubsurfaceMaterial(Terrain.END_STONE);
String dimWarnings = importDimension(endDir, dimension, version, (progressReceiver != null) ? new SubProgressReceiver(progressReceiver, (float) dimNo / dimCount, 1.0f / dimCount) : null);
if (dimWarnings != null) {
if (warnings == null) {
warnings = dimWarnings;
} else {
warnings = warnings + dimWarnings;
}
}
} finally {
dimension.setEventsInhibited(false);
}
world.addDimension(dimension);
}
// Log an event
Configuration config = Configuration.getInstance();
if (config != null) {
EventVO event = new EventVO(EVENT_KEY_ACTION_IMPORT_MAP).duration(System.currentTimeMillis() - start);
event.setAttribute(EventVO.ATTRIBUTE_TIMESTAMP, new Date(start));
event.setAttribute(ATTRIBUTE_KEY_MAX_HEIGHT, world.getMaxHeight());
event.setAttribute(ATTRIBUTE_KEY_PLATFORM, world.getPlatform().displayName);
event.setAttribute(ATTRIBUTE_KEY_MAP_FEATURES, world.isMapFeatures());
event.setAttribute(ATTRIBUTE_KEY_GAME_TYPE_NAME, world.getGameType().name());
event.setAttribute(ATTRIBUTE_KEY_ALLOW_CHEATS, world.isAllowCheats());
event.setAttribute(ATTRIBUTE_KEY_GENERATOR, world.getGenerator().name());
if (world.getPlatform().equals(JAVA_ANVIL) && (world.getGenerator() == Generator.FLAT)) {
event.setAttribute(ATTRIBUTE_KEY_GENERATOR_OPTIONS, world.getGeneratorOptions());
}
event.setAttribute(ATTRIBUTE_KEY_TILES, dimension.getTiles().size());
config.logEvent(event);
}
return world;
}
use of org.pepsoft.worldpainter.layers.exporters.FrostExporter.FrostSettings in project WorldPainter by Captain-Chaos.
the class DimensionPropertiesEditor method loadSettings.
private void loadSettings() {
int maxHeight = dimension.getMaxHeight() - 1;
// general
((SpinnerNumberModel) spinnerMinSurfaceDepth.getModel()).setMaximum(maxHeight);
spinnerMinSurfaceDepth.setValue(dimension.getTopLayerMinDepth());
((SpinnerNumberModel) spinnerMaxSurfaceDepth.getModel()).setMaximum(maxHeight);
spinnerMaxSurfaceDepth.setValue(dimension.getTopLayerMinDepth() + dimension.getTopLayerVariation());
if (dimension.getBorder() != null) {
switch(dimension.getBorder()) {
case LAVA:
radioButtonLavaBorder.setSelected(true);
radioButtonFixedBorder.setSelected(true);
break;
case WATER:
radioButtonWaterBorder.setSelected(true);
radioButtonFixedBorder.setSelected(true);
break;
case VOID:
radioButtonVoidBorder.setSelected(true);
radioButtonFixedBorder.setSelected(true);
break;
case ENDLESS_LAVA:
radioButtonLavaBorder.setSelected(true);
radioButtonEndlessBorder.setSelected(true);
break;
case ENDLESS_WATER:
radioButtonWaterBorder.setSelected(true);
radioButtonEndlessBorder.setSelected(true);
break;
case ENDLESS_VOID:
radioButtonVoidBorder.setSelected(true);
radioButtonEndlessBorder.setSelected(true);
break;
default:
throw new InternalError();
}
} else {
radioButtonNoBorder.setSelected(true);
}
((SpinnerNumberModel) spinnerBorderLevel.getModel()).setMaximum(maxHeight);
spinnerBorderLevel.setValue(dimension.getBorderLevel());
spinnerBorderSize.setValue(dimension.getBorderSize() * 128);
checkBoxBedrockWall.setSelected(dimension.isBedrockWall());
spinnerMinecraftSeed.setValue(dimension.getMinecraftSeed());
checkBoxBottomless.setSelected(dimension.isBottomless());
checkBoxCoverSteepTerrain.setSelected(dimension.isCoverSteepTerrain());
((SpinnerNumberModel) spinnerCeilingHeight.getModel()).setMaximum(maxHeight + 1);
spinnerCeilingHeight.setValue(dimension.getCeilingHeight());
// Minecraft world border
World2 world = dimension.getWorld();
if (world != null) {
World2.BorderSettings borderSettings = world.getBorderSettings();
spinnerMcBorderCentreX.setValue(borderSettings.getCentreX());
spinnerMcBorderCentreY.setValue(borderSettings.getCentreY());
spinnerMcBorderSize.setValue(borderSettings.getSize());
// spinnerMcBorderBuffer.setValue(borderSettings.getSafeZone());
// spinnerMcBorderDamage.setValue(borderSettings.getDamagePerBlock());
// spinnerMcBorderWarningTime.setValue(borderSettings.getWarningTime());
// spinnerMcBorderWarningDistance.setValue(borderSettings.getWarningBlocks());
} else {
spinnerMcBorderCentreX.setEnabled(false);
spinnerMcBorderCentreY.setEnabled(false);
spinnerMcBorderSize.setEnabled(false);
// spinnerMcBorderBuffer.setEnabled(false);
// spinnerMcBorderDamage.setEnabled(false);
// spinnerMcBorderWarningTime.setEnabled(false);
// spinnerMcBorderWarningDistance.setEnabled(false);
}
List<Terrain> materialList = new ArrayList<>(Arrays.asList(Terrain.VALUES));
for (Iterator<Terrain> i = materialList.iterator(); i.hasNext(); ) {
Terrain terrain = i.next();
if ((terrain.isCustom() && (!terrain.isConfigured())) || (terrain == Terrain.GRASS) || (terrain == Terrain.DESERT) || (terrain == Terrain.RED_DESERT)) {
i.remove();
}
}
comboBoxSubsurfaceMaterial.setModel(new DefaultComboBoxModel(materialList.toArray()));
comboBoxSubsurfaceMaterial.setSelectedItem(dimension.getSubsurfaceMaterial());
// caverns
CavernsSettings cavernsSettings = (CavernsSettings) dimension.getLayerSettings(Caverns.INSTANCE);
if (cavernsSettings == null) {
cavernsSettings = new CavernsSettings();
}
if (cavernsSettings.getCavernsEverywhereLevel() > 0) {
checkBoxCavernsEverywhere.setSelected(true);
sliderCavernsEverywhereLevel.setValue(cavernsSettings.getCavernsEverywhereLevel());
} else {
checkBoxCavernsEverywhere.setSelected(false);
sliderCavernsEverywhereLevel.setValue(8);
}
((SpinnerNumberModel) spinnerCavernsFloodLevel.getModel()).setMaximum(maxHeight);
if (cavernsSettings.getWaterLevel() > 0) {
checkBoxFloodCaverns.setSelected(true);
spinnerCavernsFloodLevel.setValue(cavernsSettings.getWaterLevel());
} else {
checkBoxFloodCaverns.setSelected(false);
spinnerCavernsFloodLevel.setValue(8);
}
checkBoxCavernsFloodWithLava.setSelected(cavernsSettings.isFloodWithLava());
checkBoxCavernsBreakSurface.setSelected(cavernsSettings.isSurfaceBreaking());
checkBoxCavernsRemoveWater.setSelected(!cavernsSettings.isLeaveWater());
((SpinnerNumberModel) spinnerCavernsMinLevel.getModel()).setMaximum(maxHeight);
spinnerCavernsMinLevel.setValue(cavernsSettings.getMinimumLevel());
((SpinnerNumberModel) spinnerCavernsMaxLevel.getModel()).setMaximum(maxHeight);
spinnerCavernsMaxLevel.setValue(Math.min(cavernsSettings.getMaximumLevel(), maxHeight));
// chasms
ChasmsSettings chasmsSettings = (ChasmsSettings) dimension.getLayerSettings(Chasms.INSTANCE);
if (chasmsSettings == null) {
chasmsSettings = new ChasmsSettings();
}
if (chasmsSettings.getChasmsEverywhereLevel() > 0) {
checkBoxChasmsEverywhere.setSelected(true);
sliderChasmsEverywhereLevel.setValue(chasmsSettings.getChasmsEverywhereLevel());
} else {
checkBoxChasmsEverywhere.setSelected(false);
sliderChasmsEverywhereLevel.setValue(8);
}
checkBoxChasmsBreakSurface.setSelected(chasmsSettings.isSurfaceBreaking());
((SpinnerNumberModel) spinnerChasmsMinLevel.getModel()).setMaximum(maxHeight);
spinnerChasmsMinLevel.setValue(chasmsSettings.getMinimumLevel());
((SpinnerNumberModel) spinnerChasmsMaxLevel.getModel()).setMaximum(maxHeight);
spinnerChasmsMaxLevel.setValue(Math.min(chasmsSettings.getMaximumLevel(), maxHeight));
// populate
checkBoxPopulate.setSelected(dimension.isPopulate());
// deciduous
TreeLayerSettings<DeciduousForest> deciduousSettings = (TreeLayerSettings<DeciduousForest>) dimension.getLayerSettings(DeciduousForest.INSTANCE);
if (deciduousSettings == null) {
deciduousSettings = new TreeLayerSettings<>(DeciduousForest.INSTANCE);
}
if (deciduousSettings.getMinimumLevel() > 0) {
checkBoxDeciduousEverywhere.setSelected(true);
sliderDeciduousLevel.setValue(deciduousSettings.getMinimumLevel());
} else {
checkBoxDeciduousEverywhere.setSelected(false);
sliderDeciduousLevel.setValue(8);
}
// pine
TreeLayerSettings<PineForest> pineSettings = (TreeLayerSettings<PineForest>) dimension.getLayerSettings(PineForest.INSTANCE);
if (pineSettings == null) {
pineSettings = new TreeLayerSettings<>(PineForest.INSTANCE);
}
if (pineSettings.getMinimumLevel() > 0) {
checkBoxPineEverywhere.setSelected(true);
sliderPineLevel.setValue(pineSettings.getMinimumLevel());
} else {
checkBoxPineEverywhere.setSelected(false);
sliderPineLevel.setValue(8);
}
// jungle
TreeLayerSettings<Jungle> jungleSettings = (TreeLayerSettings<Jungle>) dimension.getLayerSettings(Jungle.INSTANCE);
if (jungleSettings == null) {
jungleSettings = new TreeLayerSettings<>(Jungle.INSTANCE);
}
if (jungleSettings.getMinimumLevel() > 0) {
checkBoxJungleEverywhere.setSelected(true);
sliderJungleLevel.setValue(jungleSettings.getMinimumLevel());
} else {
checkBoxJungleEverywhere.setSelected(false);
sliderJungleLevel.setValue(8);
}
// swamp
TreeLayerSettings<SwampLand> swampLandSettings = (TreeLayerSettings<SwampLand>) dimension.getLayerSettings(SwampLand.INSTANCE);
if (swampLandSettings == null) {
swampLandSettings = new TreeLayerSettings<>(SwampLand.INSTANCE);
}
if (swampLandSettings.getMinimumLevel() > 0) {
checkBoxSwamplandEverywhere.setSelected(true);
jSlider6.setValue(swampLandSettings.getMinimumLevel());
} else {
checkBoxSwamplandEverywhere.setSelected(false);
jSlider6.setValue(8);
}
// frost
FrostSettings frostSettings = (FrostSettings) dimension.getLayerSettings(Frost.INSTANCE);
if (frostSettings == null) {
frostSettings = new FrostSettings();
}
checkBoxFrostEverywhere.setSelected(frostSettings.isFrostEverywhere());
checkBoxSmoothSnow.setSelected((frostSettings.getMode() == 2) || (frostSettings.getMode() == 3));
checkBoxSnowUnderTrees.setSelected(frostSettings.isSnowUnderTrees());
// resources
ResourcesExporterSettings resourcesSettings = (ResourcesExporterSettings) dimension.getLayerSettings(Resources.INSTANCE);
if (resourcesSettings == null) {
resourcesSettings = new ResourcesExporterSettings(dimension.getMaxHeight());
resourcesSettings.setMinimumLevel(0);
}
jCheckBox8.setSelected(resourcesSettings.isApplyEverywhere());
if (resourcesSettings.isApplyEverywhere()) {
jSlider4.setValue(resourcesSettings.getMinimumLevel());
} else {
jSlider4.setValue(8);
}
spinnerGoldChance.setValue(resourcesSettings.getChance(BLK_GOLD_ORE));
((SpinnerNumberModel) spinnerGoldMinLevel.getModel()).setMaximum(maxHeight);
spinnerGoldMinLevel.setValue(clamp(resourcesSettings.getMinLevel(BLK_GOLD_ORE), maxHeight));
((SpinnerNumberModel) spinnerGoldMaxLevel.getModel()).setMaximum(maxHeight);
spinnerGoldMaxLevel.setValue(clamp(resourcesSettings.getMaxLevel(BLK_GOLD_ORE), maxHeight));
spinnerIronChance.setValue(resourcesSettings.getChance(BLK_IRON_ORE));
((SpinnerNumberModel) spinnerIronMinLevel.getModel()).setMaximum(maxHeight);
spinnerIronMinLevel.setValue(clamp(resourcesSettings.getMinLevel(BLK_IRON_ORE), maxHeight));
((SpinnerNumberModel) spinnerIronMaxLevel.getModel()).setMaximum(maxHeight);
spinnerIronMaxLevel.setValue(clamp(resourcesSettings.getMaxLevel(BLK_IRON_ORE), maxHeight));
spinnerCoalChance.setValue(resourcesSettings.getChance(BLK_COAL));
((SpinnerNumberModel) spinnerCoalMinLevel.getModel()).setMaximum(maxHeight);
spinnerCoalMinLevel.setValue(clamp(resourcesSettings.getMinLevel(BLK_COAL), maxHeight));
((SpinnerNumberModel) spinnerCoalMaxLevel.getModel()).setMaximum(maxHeight);
spinnerCoalMaxLevel.setValue(clamp(resourcesSettings.getMaxLevel(BLK_COAL), maxHeight));
spinnerLapisChance.setValue(resourcesSettings.getChance(BLK_LAPIS_LAZULI_ORE));
((SpinnerNumberModel) spinnerLapisMinLevel.getModel()).setMaximum(maxHeight);
spinnerLapisMinLevel.setValue(clamp(resourcesSettings.getMinLevel(BLK_LAPIS_LAZULI_ORE), maxHeight));
((SpinnerNumberModel) spinnerLapisMaxLevel.getModel()).setMaximum(maxHeight);
spinnerLapisMaxLevel.setValue(clamp(resourcesSettings.getMaxLevel(BLK_LAPIS_LAZULI_ORE), maxHeight));
spinnerDiamondChance.setValue(resourcesSettings.getChance(BLK_DIAMOND_ORE));
((SpinnerNumberModel) spinnerDiamondMinLevel.getModel()).setMaximum(maxHeight);
spinnerDiamondMinLevel.setValue(clamp(resourcesSettings.getMinLevel(BLK_DIAMOND_ORE), maxHeight));
((SpinnerNumberModel) spinnerDiamondMaxLevel.getModel()).setMaximum(maxHeight);
spinnerDiamondMaxLevel.setValue(clamp(resourcesSettings.getMaxLevel(BLK_DIAMOND_ORE), maxHeight));
spinnerRedstoneChance.setValue(resourcesSettings.getChance(BLK_REDSTONE_ORE));
((SpinnerNumberModel) spinnerRedstoneMinLevel.getModel()).setMaximum(maxHeight);
spinnerRedstoneMinLevel.setValue(clamp(resourcesSettings.getMinLevel(BLK_REDSTONE_ORE), maxHeight));
((SpinnerNumberModel) spinnerRedstoneMaxLevel.getModel()).setMaximum(maxHeight);
spinnerRedstoneMaxLevel.setValue(clamp(resourcesSettings.getMaxLevel(BLK_REDSTONE_ORE), maxHeight));
spinnerWaterChance.setValue(resourcesSettings.getChance(BLK_WATER));
((SpinnerNumberModel) spinnerWaterMinLevel.getModel()).setMaximum(maxHeight);
spinnerWaterMinLevel.setValue(clamp(resourcesSettings.getMinLevel(BLK_WATER), maxHeight));
((SpinnerNumberModel) spinnerWaterMaxLevel.getModel()).setMaximum(maxHeight);
spinnerWaterMaxLevel.setValue(clamp(resourcesSettings.getMaxLevel(BLK_WATER), maxHeight));
spinnerLavaChance.setValue(resourcesSettings.getChance(BLK_LAVA));
((SpinnerNumberModel) spinnerLavaMinLevel.getModel()).setMaximum(maxHeight);
spinnerLavaMinLevel.setValue(clamp(resourcesSettings.getMinLevel(BLK_LAVA), maxHeight));
((SpinnerNumberModel) spinnerLavaMaxLevel.getModel()).setMaximum(maxHeight);
spinnerLavaMaxLevel.setValue(clamp(resourcesSettings.getMaxLevel(BLK_LAVA), maxHeight));
spinnerDirtChance.setValue(resourcesSettings.getChance(BLK_DIRT));
((SpinnerNumberModel) spinnerDirtMinLevel.getModel()).setMaximum(maxHeight);
spinnerDirtMinLevel.setValue(clamp(resourcesSettings.getMinLevel(BLK_DIRT), maxHeight));
((SpinnerNumberModel) spinnerDirtMaxLevel.getModel()).setMaximum(maxHeight);
spinnerDirtMaxLevel.setValue(clamp(resourcesSettings.getMaxLevel(BLK_DIRT), maxHeight));
spinnerGravelChance.setValue(resourcesSettings.getChance(BLK_GRAVEL));
((SpinnerNumberModel) spinnerGravelMinLevel.getModel()).setMaximum(maxHeight);
spinnerGravelMinLevel.setValue(clamp(resourcesSettings.getMinLevel(BLK_GRAVEL), maxHeight));
((SpinnerNumberModel) spinnerGravelMaxLevel.getModel()).setMaximum(maxHeight);
spinnerGravelMaxLevel.setValue(clamp(resourcesSettings.getMaxLevel(BLK_GRAVEL), maxHeight));
spinnerEmeraldChance.setValue(resourcesSettings.getChance(BLK_EMERALD_ORE));
((SpinnerNumberModel) spinnerEmeraldMinLevel.getModel()).setMaximum(maxHeight);
spinnerEmeraldMinLevel.setValue(clamp(resourcesSettings.getMinLevel(BLK_EMERALD_ORE), maxHeight));
((SpinnerNumberModel) spinnerEmeraldMaxLevel.getModel()).setMaximum(maxHeight);
spinnerEmeraldMaxLevel.setValue(clamp(resourcesSettings.getMaxLevel(BLK_EMERALD_ORE), maxHeight));
spinnerQuartzChance.setValue(resourcesSettings.getChance(BLK_QUARTZ_ORE));
((SpinnerNumberModel) spinnerQuartzMinLevel.getModel()).setMaximum(maxHeight);
spinnerQuartzMinLevel.setValue(clamp(resourcesSettings.getMinLevel(BLK_QUARTZ_ORE), maxHeight));
((SpinnerNumberModel) spinnerQuartzMaxLevel.getModel()).setMaximum(maxHeight);
spinnerQuartzMaxLevel.setValue(clamp(resourcesSettings.getMaxLevel(BLK_QUARTZ_ORE), maxHeight));
// terrain ranges
if (mode != Mode.EXPORT) {
if ((dimension.getTileFactory() instanceof HeightMapTileFactory) && (((HeightMapTileFactory) dimension.getTileFactory()).getTheme() instanceof SimpleTheme) && (((SimpleTheme) ((HeightMapTileFactory) dimension.getTileFactory()).getTheme()).getTerrainRanges() != null)) {
themeEditor.setTheme((SimpleTheme) ((HeightMapTileFactory) dimension.getTileFactory()).getTheme());
} else {
jTabbedPane1.setEnabledAt(1, false);
}
}
// annotations
AnnotationsSettings annotationsSettings = (AnnotationsSettings) dimension.getLayerSettings(Annotations.INSTANCE);
if (annotationsSettings == null) {
annotationsSettings = new AnnotationsSettings();
}
checkBoxExportAnnotations.setSelected(annotationsSettings.isExport());
// custom layers
if (mode == Mode.EXPORT) {
Set<CustomLayer> customLayers = App.getInstance().getCustomLayers();
// if (! customLayers.isEmpty()) {
customLayersTableModel = new CustomLayersTableModel(customLayers);
tableCustomLayers.setModel(customLayersTableModel);
// } else {
// jTabbedPane1.setEnabledAt(5, false);
// }
}
setControlStates();
}
use of org.pepsoft.worldpainter.layers.exporters.FrostExporter.FrostSettings in project WorldPainter by Captain-Chaos.
the class DimensionPropertiesEditor method saveSettings.
public boolean saveSettings() {
int maxHeight = dimension.getMaxHeight() - 1;
// terrain ranges
if ((mode != Mode.EXPORT) && (!themeEditor.save())) {
jTabbedPane1.setSelectedIndex(1);
return false;
}
// general
int topLayerMinDepth = (Integer) spinnerMinSurfaceDepth.getValue();
dimension.setTopLayerMinDepth(topLayerMinDepth);
dimension.setTopLayerVariation((Integer) spinnerMaxSurfaceDepth.getValue() - topLayerMinDepth);
dimension.setSubsurfaceMaterial((Terrain) comboBoxSubsurfaceMaterial.getSelectedItem());
dimension.setBorder(getSelectedBorder());
dimension.setBorderLevel((Integer) spinnerBorderLevel.getValue());
dimension.setBorderSize((Integer) spinnerBorderSize.getValue() / 128);
dimension.setBedrockWall(checkBoxBedrockWall.isSelected());
long previousSeed = dimension.getMinecraftSeed();
long newSeed = ((Number) spinnerMinecraftSeed.getValue()).longValue();
if (newSeed != previousSeed) {
dimension.setMinecraftSeed(newSeed);
}
dimension.setBottomless(checkBoxBottomless.isSelected());
dimension.setCoverSteepTerrain(checkBoxCoverSteepTerrain.isSelected());
dimension.setCeilingHeight((Integer) spinnerCeilingHeight.getValue());
// Minecraft world border
World2 world = dimension.getWorld();
if (world != null) {
World2.BorderSettings borderSettings = world.getBorderSettings();
borderSettings.setCentreX((Integer) spinnerMcBorderCentreX.getValue());
borderSettings.setCentreY((Integer) spinnerMcBorderCentreY.getValue());
borderSettings.setSize((Integer) spinnerMcBorderSize.getValue());
// borderSettings.setSafeZone((Integer) spinnerMcBorderBuffer.getValue());
// borderSettings.setDamagePerBlock((Float) spinnerMcBorderDamage.getValue());
// borderSettings.setWarningTime((Integer) spinnerMcBorderWarningTime.getValue());
// borderSettings.setWarningBlocks((Integer) spinnerMcBorderWarningDistance.getValue());
}
// caverns
CavernsSettings cavernsSettings = (CavernsSettings) dimension.getLayerSettings(Caverns.INSTANCE);
if (cavernsSettings == null) {
cavernsSettings = new CavernsSettings();
}
if (checkBoxCavernsEverywhere.isSelected()) {
int cavernsEverywhereLevel = sliderCavernsEverywhereLevel.getValue();
cavernsSettings.setCavernsEverywhereLevel(cavernsEverywhereLevel);
} else {
cavernsSettings.setCavernsEverywhereLevel(0);
}
if (checkBoxFloodCaverns.isSelected()) {
cavernsSettings.setWaterLevel((Integer) spinnerCavernsFloodLevel.getValue());
} else {
cavernsSettings.setWaterLevel(0);
}
cavernsSettings.setFloodWithLava(checkBoxCavernsFloodWithLava.isSelected());
cavernsSettings.setSurfaceBreaking(checkBoxCavernsBreakSurface.isSelected());
cavernsSettings.setLeaveWater(!checkBoxCavernsRemoveWater.isSelected());
cavernsSettings.setMinimumLevel((Integer) spinnerCavernsMinLevel.getValue());
int cavernsMaxLevel = (Integer) spinnerCavernsMaxLevel.getValue();
cavernsSettings.setMaximumLevel((cavernsMaxLevel >= maxHeight) ? Integer.MAX_VALUE : cavernsMaxLevel);
dimension.setLayerSettings(Caverns.INSTANCE, cavernsSettings);
// chasms
ChasmsSettings chasmsSettings = (ChasmsSettings) dimension.getLayerSettings(Chasms.INSTANCE);
if (chasmsSettings == null) {
chasmsSettings = new ChasmsSettings();
}
if (checkBoxChasmsEverywhere.isSelected()) {
int chasmsEverywhereLevel = sliderChasmsEverywhereLevel.getValue();
chasmsSettings.setChasmsEverywhereLevel(chasmsEverywhereLevel);
} else {
chasmsSettings.setChasmsEverywhereLevel(0);
}
chasmsSettings.setSurfaceBreaking(checkBoxChasmsBreakSurface.isSelected());
// Other settings copied from Caverns layer
if (checkBoxFloodCaverns.isSelected()) {
chasmsSettings.setWaterLevel((Integer) spinnerCavernsFloodLevel.getValue());
} else {
chasmsSettings.setWaterLevel(0);
}
chasmsSettings.setFloodWithLava(checkBoxCavernsFloodWithLava.isSelected());
chasmsSettings.setLeaveWater(!checkBoxCavernsRemoveWater.isSelected());
chasmsSettings.setMinimumLevel((Integer) spinnerChasmsMinLevel.getValue());
chasmsSettings.setMaximumLevel((Integer) spinnerChasmsMaxLevel.getValue());
dimension.setLayerSettings(Chasms.INSTANCE, chasmsSettings);
// populate
dimension.setPopulate(checkBoxPopulate.isSelected());
// deciduous
TreeLayerSettings<DeciduousForest> deciduousSettings = (TreeLayerSettings<DeciduousForest>) dimension.getLayerSettings(DeciduousForest.INSTANCE);
if (deciduousSettings == null) {
deciduousSettings = new TreeLayerSettings<>(DeciduousForest.INSTANCE);
}
if (checkBoxDeciduousEverywhere.isSelected()) {
int minimumLevel = sliderDeciduousLevel.getValue();
deciduousSettings.setMinimumLevel(minimumLevel);
} else {
deciduousSettings.setMinimumLevel(0);
}
dimension.setLayerSettings(DeciduousForest.INSTANCE, deciduousSettings);
// pine
TreeLayerSettings<PineForest> pineSettings = (TreeLayerSettings<PineForest>) dimension.getLayerSettings(PineForest.INSTANCE);
if (pineSettings == null) {
pineSettings = new TreeLayerSettings<>(PineForest.INSTANCE);
}
if (checkBoxPineEverywhere.isSelected()) {
int minimumLevel = sliderPineLevel.getValue();
pineSettings.setMinimumLevel(minimumLevel);
} else {
pineSettings.setMinimumLevel(0);
}
dimension.setLayerSettings(PineForest.INSTANCE, pineSettings);
// jungle
TreeLayerSettings<Jungle> jungleSettings = (TreeLayerSettings<Jungle>) dimension.getLayerSettings(Jungle.INSTANCE);
if (jungleSettings == null) {
jungleSettings = new TreeLayerSettings<>(Jungle.INSTANCE);
}
if (checkBoxJungleEverywhere.isSelected()) {
int minimumLevel = sliderJungleLevel.getValue();
jungleSettings.setMinimumLevel(minimumLevel);
} else {
jungleSettings.setMinimumLevel(0);
}
dimension.setLayerSettings(Jungle.INSTANCE, jungleSettings);
// swampland
TreeLayerSettings<SwampLand> swampLandSettings = (TreeLayerSettings<SwampLand>) dimension.getLayerSettings(SwampLand.INSTANCE);
if (swampLandSettings == null) {
swampLandSettings = new TreeLayerSettings<>(SwampLand.INSTANCE);
}
if (checkBoxSwamplandEverywhere.isSelected()) {
int minimumLevel = jSlider6.getValue();
swampLandSettings.setMinimumLevel(minimumLevel);
} else {
swampLandSettings.setMinimumLevel(0);
}
dimension.setLayerSettings(SwampLand.INSTANCE, swampLandSettings);
// frost
FrostSettings frostSettings = (FrostSettings) dimension.getLayerSettings(Frost.INSTANCE);
if (frostSettings == null) {
frostSettings = new FrostSettings();
}
frostSettings.setFrostEverywhere(checkBoxFrostEverywhere.isSelected());
if ((!checkBoxSmoothSnow.isSelected()) || (frostSettings.getMode() != 3)) {
frostSettings.setMode(checkBoxSmoothSnow.isSelected() ? 2 : 0);
}
frostSettings.setSnowUnderTrees(checkBoxSnowUnderTrees.isSelected());
dimension.setLayerSettings(Frost.INSTANCE, frostSettings);
// resources
ResourcesExporterSettings resourcesSettings = (ResourcesExporterSettings) dimension.getLayerSettings(Resources.INSTANCE);
if (resourcesSettings == null) {
resourcesSettings = new ResourcesExporterSettings(dimension.getMaxHeight());
}
if (jCheckBox8.isSelected()) {
int minimumLevel = jSlider4.getValue();
resourcesSettings.setMinimumLevel(minimumLevel);
} else {
resourcesSettings.setMinimumLevel(0);
}
resourcesSettings.setChance(BLK_GOLD_ORE, (Integer) spinnerGoldChance.getValue());
resourcesSettings.setMinLevel(BLK_GOLD_ORE, (Integer) spinnerGoldMinLevel.getValue());
resourcesSettings.setMaxLevel(BLK_GOLD_ORE, (Integer) spinnerGoldMaxLevel.getValue());
resourcesSettings.setChance(BLK_IRON_ORE, (Integer) spinnerIronChance.getValue());
resourcesSettings.setMinLevel(BLK_IRON_ORE, (Integer) spinnerIronMinLevel.getValue());
resourcesSettings.setMaxLevel(BLK_IRON_ORE, (Integer) spinnerIronMaxLevel.getValue());
resourcesSettings.setChance(BLK_COAL, (Integer) spinnerCoalChance.getValue());
resourcesSettings.setMinLevel(BLK_COAL, (Integer) spinnerCoalMinLevel.getValue());
resourcesSettings.setMaxLevel(BLK_COAL, (Integer) spinnerCoalMaxLevel.getValue());
resourcesSettings.setChance(BLK_LAPIS_LAZULI_ORE, (Integer) spinnerLapisChance.getValue());
resourcesSettings.setMinLevel(BLK_LAPIS_LAZULI_ORE, (Integer) spinnerLapisMinLevel.getValue());
resourcesSettings.setMaxLevel(BLK_LAPIS_LAZULI_ORE, (Integer) spinnerLapisMaxLevel.getValue());
resourcesSettings.setChance(BLK_DIAMOND_ORE, (Integer) spinnerDiamondChance.getValue());
resourcesSettings.setMinLevel(BLK_DIAMOND_ORE, (Integer) spinnerDiamondMinLevel.getValue());
resourcesSettings.setMaxLevel(BLK_DIAMOND_ORE, (Integer) spinnerDiamondMaxLevel.getValue());
resourcesSettings.setChance(BLK_REDSTONE_ORE, (Integer) spinnerRedstoneChance.getValue());
resourcesSettings.setMinLevel(BLK_REDSTONE_ORE, (Integer) spinnerRedstoneMinLevel.getValue());
resourcesSettings.setMaxLevel(BLK_REDSTONE_ORE, (Integer) spinnerRedstoneMaxLevel.getValue());
resourcesSettings.setChance(BLK_WATER, (Integer) spinnerWaterChance.getValue());
resourcesSettings.setMinLevel(BLK_WATER, (Integer) spinnerWaterMinLevel.getValue());
resourcesSettings.setMaxLevel(BLK_WATER, (Integer) spinnerWaterMaxLevel.getValue());
resourcesSettings.setChance(BLK_LAVA, (Integer) spinnerLavaChance.getValue());
resourcesSettings.setMinLevel(BLK_LAVA, (Integer) spinnerLavaMinLevel.getValue());
resourcesSettings.setMaxLevel(BLK_LAVA, (Integer) spinnerLavaMaxLevel.getValue());
resourcesSettings.setChance(BLK_DIRT, (Integer) spinnerDirtChance.getValue());
resourcesSettings.setMinLevel(BLK_DIRT, (Integer) spinnerDirtMinLevel.getValue());
resourcesSettings.setMaxLevel(BLK_DIRT, (Integer) spinnerDirtMaxLevel.getValue());
resourcesSettings.setChance(BLK_GRAVEL, (Integer) spinnerGravelChance.getValue());
resourcesSettings.setMinLevel(BLK_GRAVEL, (Integer) spinnerGravelMinLevel.getValue());
resourcesSettings.setMaxLevel(BLK_GRAVEL, (Integer) spinnerGravelMaxLevel.getValue());
resourcesSettings.setChance(BLK_EMERALD_ORE, (Integer) spinnerEmeraldChance.getValue());
resourcesSettings.setMinLevel(BLK_EMERALD_ORE, (Integer) spinnerEmeraldMinLevel.getValue());
resourcesSettings.setMaxLevel(BLK_EMERALD_ORE, (Integer) spinnerEmeraldMaxLevel.getValue());
resourcesSettings.setChance(BLK_QUARTZ_ORE, (Integer) spinnerQuartzChance.getValue());
resourcesSettings.setMinLevel(BLK_QUARTZ_ORE, (Integer) spinnerQuartzMinLevel.getValue());
resourcesSettings.setMaxLevel(BLK_QUARTZ_ORE, (Integer) spinnerQuartzMaxLevel.getValue());
dimension.setLayerSettings(Resources.INSTANCE, resourcesSettings);
// annotations
AnnotationsSettings annotationsSettings = (AnnotationsSettings) dimension.getLayerSettings(Annotations.INSTANCE);
if (annotationsSettings == null) {
annotationsSettings = new AnnotationsSettings();
}
annotationsSettings.setExport(checkBoxExportAnnotations.isSelected());
dimension.setLayerSettings(Annotations.INSTANCE, annotationsSettings);
// custom layers
if ((mode == Mode.EXPORT) && (!customLayersTableModel.isPristine())) {
customLayersTableModel.save();
dimension.setDirty(true);
}
return true;
}
Aggregations