com.github.skittishSloth.openSkies.maps.MapGenerator.java Source code

Introduction

Here is the source code for com.github.skittishSloth.openSkies.maps.MapGenerator.java

Source

/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */
package com.github.skittishSloth.openSkies.maps;

import com.badlogic.gdx.graphics.Color;
import com.badlogic.gdx.graphics.Pixmap;
import com.badlogic.gdx.graphics.Texture;
import com.github.skittishSloth.openSkies.maps.terrains.Latitude;
import com.github.skittishSloth.openSkies.maps.terrains.MapData;
import com.github.skittishSloth.openSkies.maps.terrains.TerrainParameters;
import com.github.skittishSloth.openSkies.maps.terrains.TerrainTile;
import com.github.skittishSloth.openSkies.maps.terrains.TileData;
import com.github.skittishSloth.openSkies.maps.generation.perlin.PerlinNoiseGenerator;
import java.util.Random;

/**
 *
 * @author mcory01
 */
public class MapGenerator {

    public MapGenerator() {
        terrainParameters = new TerrainParameters();
    }

    public MapGenerator(final TerrainParameters terrainParameters) {
        this.terrainParameters = terrainParameters;
    }

    public Texture generateTexture(final int width, final int height, final int tileSize) {
        final TerrainTile[][] tiles = generateTiles(width, height);

        final Pixmap pm = new Pixmap(width * tileSize, height * tileSize, Pixmap.Format.RGBA8888);
        for (int x = 0; x < width; ++x) {
            for (int y = 0; y < height; ++y) {
                final TerrainTile tile = tiles[x][y];
                final Color c = tile.getTemperatureColor();
                pm.setColor(c);
                pm.fillRectangle(x * tileSize, y * tileSize, tileSize, tileSize);
            }
        }
        final Texture res = new Texture(pm);
        pm.dispose();
        return res;
    }

    public Texture generateElevationTexture(final TerrainTile[][] tiles, final int width, final int height,
            final int tileSize) {
        final Pixmap pm = new Pixmap(width * tileSize, height * tileSize, Pixmap.Format.RGBA8888);
        for (int x = 0; x < width; ++x) {
            for (int y = 0; y < height; ++y) {
                final TerrainTile tile = tiles[x][y];
                final Color c = tile.getElevationColor();
                pm.setColor(c);
                pm.fillRectangle(x * tileSize, y * tileSize, tileSize, tileSize);
            }
        }
        final Texture res = new Texture(pm);
        pm.dispose();
        return res;
    }

    public Texture generateRawElevationTexture(final TerrainTile[][] tiles, final int width, final int height,
            final int tileSize) {
        final Pixmap pm = new Pixmap(width * tileSize, height * tileSize, Pixmap.Format.RGBA8888);
        for (int x = 0; x < width; ++x) {
            for (int y = 0; y < height; ++y) {
                final TerrainTile tile = tiles[x][y];
                final Color c = tile.getRawElevationColor();
                pm.setColor(c);
                pm.fillRectangle(x * tileSize, y * tileSize, tileSize, tileSize);
            }
        }
        final Texture res = new Texture(pm);
        pm.dispose();
        return res;
    }

    public Texture generateTemperatureTexture(final TerrainTile[][] tiles, final int width, final int height,
            final int tileSize) {
        final Pixmap pm = new Pixmap(width * tileSize, height * tileSize, Pixmap.Format.RGBA8888);
        for (int x = 0; x < width; ++x) {
            for (int y = 0; y < height; ++y) {
                final TerrainTile tile = tiles[x][y];
                final Color c = tile.getTemperatureColor();
                pm.setColor(c);
                pm.fillRectangle(x * tileSize, y * tileSize, tileSize, tileSize);
            }
        }
        final Texture res = new Texture(pm);
        pm.dispose();
        return res;
    }

    public Texture generateRainfallTexture(final TerrainTile[][] tiles, final int width, final int height,
            final int tileSize) {
        final Pixmap pm = new Pixmap(width * tileSize, height * tileSize, Pixmap.Format.RGBA8888);
        for (int x = 0; x < width; ++x) {
            for (int y = 0; y < height; ++y) {
                final TerrainTile tile = tiles[x][y];
                final Color c = tile.getRainfallColor();
                pm.setColor(c);
                pm.fillRectangle(x * tileSize, y * tileSize, tileSize, tileSize);
            }
        }
        final Texture res = new Texture(pm);
        pm.dispose();
        return res;
    }

    public Texture generateElevationGrayscaleTexture(final TerrainTile[][] tiles, final int width, final int height,
            final int tileSize) {
        final Pixmap pm = new Pixmap(width * tileSize, height * tileSize, Pixmap.Format.RGBA8888);
        for (int x = 0; x < width; ++x) {
            for (int y = 0; y < height; ++y) {
                final TerrainTile tile = tiles[x][y];
                final Color c = tile.getElevationGrayscale();
                pm.setColor(c);
                pm.fillRectangle(x * tileSize, y * tileSize, tileSize, tileSize);
            }
        }
        final Texture res = new Texture(pm);
        pm.dispose();
        return res;
    }

    public Texture generateLatitudeTexture(final TerrainTile[][] tiles, final int width, final int height,
            final int tileSize) {
        final Pixmap pm = new Pixmap(width * tileSize, height * tileSize, Pixmap.Format.RGBA8888);
        for (int x = 0; x < width; ++x) {
            for (int y = 0; y < height; ++y) {
                final TerrainTile tile = tiles[x][y];
                final Color c = tile.getLatitudeColor();
                pm.setColor(c);
                pm.fillRectangle(x * tileSize, y * tileSize, tileSize, tileSize);
            }
        }
        final Texture res = new Texture(pm);
        pm.dispose();
        return res;
    }

    public Texture generateMineralsTexture(final TerrainTile[][] tiles, final int width, final int height,
            final int tileSize) {
        final Pixmap pm = new Pixmap(width * tileSize, height * tileSize, Pixmap.Format.RGBA8888);
        for (int x = 0; x < width; ++x) {
            for (int y = 0; y < height; ++y) {
                final TerrainTile tile = tiles[x][y];
                final Color c = tile.getMineralColor();
                pm.setColor(c);
                pm.fillRectangle(x * tileSize, y * tileSize, tileSize, tileSize);
            }
        }
        final Texture res = new Texture(pm);
        pm.dispose();
        return res;
    }

    public MapData generateMap(final int width, final int height) {
        final TerrainTile[][] tiles = generateTiles(width, height);
        final MapData res = new MapData(tiles);
        return res;
    }

    public TerrainTile[][] generateTiles(final int width, final int height) {
        final TerrainTile[][] res = new TerrainTile[width][height];

        final int heightSmoothness = terrainParameters.getHeightSmoothness();
        final float[][] landProbability = PerlinNoiseGenerator.generatePerlinNoise(width, height, heightSmoothness);

        final float[][] heightMap = PerlinNoiseGenerator.generatePerlinNoise(width, height, heightSmoothness);

        final int temperatureSmoothness = terrainParameters.getTemperatureSmoothness();
        final float[][] temperatureOffset = PerlinNoiseGenerator.generatePerlinNoise(width, height,
                temperatureSmoothness);

        final int rainfallSmoothness = terrainParameters.getRainfallSmoothness();
        final float[][] rainfallAmount = PerlinNoiseGenerator.generatePerlinNoise(width, height,
                rainfallSmoothness);

        final int mineralSmoothness = terrainParameters.getMineralSmoothness();
        final float[][] mineralAmount = PerlinNoiseGenerator.generatePerlinNoise(width, height, mineralSmoothness);

        final Random random = new Random();
        for (int x = 0; x < width; ++x) {
            for (int y = 0; y < height; ++y) {
                final float elev = heightMap[x][y];
                final float temp = temperatureOffset[x][y];
                final float rainfall = rainfallAmount[x][y];
                final float minerals = mineralAmount[x][y];
                final Latitude lat = terrainParameters.getLatitude(y, height);

                final float landProbVal = landProbability[x][y];
                final float landRand = random.nextFloat();
                final boolean landTile = (landRand <= landProbVal);
                final TileData tileData = new TileData(elev, temp, rainfall, lat, minerals, landTile);
                final TerrainTile tile = terrainParameters.getTile(tileData, x, y);
                res[x][y] = tile;
            }
        }

        return res;
    }

    private final TerrainParameters terrainParameters;
}