private void BuildOcean(int seed)
{
int halfMap = mMapSize / 2;
Tile currentTile = null;
PerlinGenerator oceanGen = new PerlinGenerator();
int oceanOctaves = 5;
float[][] oceanNoise = oceanGen.Generate(seed, oceanOctaves, mMapSize);
for (int y = 0; y < mMapSize; y++)
{
for (int x = 0; x < mMapSize; x++)
{
float height = oceanNoise[x][y];
if (height < 0.35f)
{
currentTile = mTiles[(int)eTileType.DeepWater];
}
else
{
currentTile = mTiles[(int)eTileType.ShallowWater];
}
int worldPosX = x - halfMap;
int worldPosY = y - halfMap;
Vector3Int pos = new Vector3Int(worldPosX, worldPosY, 0);
mWaterTileMap.SetTile(pos, currentTile);
}
}
}
public Biome(string name, int priority, float perlinZoom, float spawnChance, int seed)
{
Name = name;
Priority = priority;
Modifiers = new List <BiomeModifier>();
perlinGenerator = new PerlinGenerator(perlinZoom, spawnChance, seed);
}
public void generate()
{
// Initialize Height Map
float[,] heightMap = new float[CityGenerator.mapSize, CityGenerator.mapSize];
//set the size
CityGenerator.terrain.terrainData.size = new Vector3(CityGenerator.terrainSize, (CityGenerator.maxHeight - CityGenerator.minHeight), CityGenerator.terrainSize);
//based on the size we also set the alphamap resolution
CityGenerator.terrain.terrainData.alphamapResolution = CityGenerator.mapSize;
if (CityGenerator.terrainMap == null)
{
//generate random terrain
PerlinGenerator perlin = new PerlinGenerator(CityGenerator.terrainSeed, CityGenerator.terrainOctaves, CityGenerator.terrainPersistance, CityGenerator.terrainZoom, 0, 1);
heightMap = perlin.getValues(CityGenerator.mapSize, CityGenerator.mapSize);
if (CityGeneratorUI.DebugMode)
{
Debug.Log("Random Terrain Generated");
}
}
else
{
//use the given terrain Map
TextureReader g = new TextureReader();
heightMap = g.readTexture(CityGenerator.terrainMap, CityGenerator.mapSize);
}
int w = heightMap.GetLength(0);
int h = heightMap.GetLength(1);
float[,] result = new float[h, w];
for (int i = 0; i < w; i++)
{
for (int j = 0; j < h; j++)
{
result[j, i] = heightMap[i, j];
}
}
heightMap = result;
CityGenerator.terrain.terrainData.SetHeights(0, 0, heightMap);
CityGenerator.terrain.gameObject.transform.position = new Vector3(0, CityGenerator.minHeight, 0);
if (CityGenerator.rWater)
{
// we must assign a new water to the terrain, so that the coordinates are updated
GameObject.DestroyImmediate(GameObject.Find("Water(Clone)"));
CityGenerator.water = GameObject.Instantiate((GameObject)Resources.Load("Water"));
// water is at height 0
CityGenerator.water.transform.position = new Vector3(CityGenerator.terrainSize / 2f, 0, CityGenerator.terrainSize / 2f);
CityGenerator.water.transform.localScale = new Vector3(Mathf.Sqrt(2) * CityGenerator.terrainSize / 2f, 1, Mathf.Sqrt(2) * CityGenerator.terrainSize / 2f);
}
else
{
GameObject.DestroyImmediate(GameObject.Find("Water(Clone)"));
}
}
/// <summary>
/// Returns 2 dimensional perlin noise of the specified size and with the given parameters. See documentation for more information
/// on parameters and recommended values.
/// </summary>
/// <param name="width">The width of the noise</param>
/// <param name="height">The height of the noise</param>
/// <param name="frequency">The frequency of the noise function.A high frequency will make the noise look more random
/// while a low frequency will make the noise look more flat and bland.
/// Default : 1</param>
/// <param name="persistence">The rate at which the frequency decreases for each octave. Increasing this value will make the noise
/// rougher, while decreasing it will make it smoother.
/// Default : 0.5 , Min : 0</param>
/// <param name="octaveCount">The octave count determines how many noise functions are combined. Increasing this value will make
/// the noise look more fractal, decreasing it will make the noise look more simple and stylized.
/// Increasing this value will significantly increase computation time.
/// Default : 6 , Min : 1 , Max : 32</param>
/// <param name="amplitude">The highest value any point in the noise can have. Default : 1</param>
public static float[,] RandPerlinNoise2(int width, int height, float frequency, float persistence, int octaveCount, float amplitude)
{
if (width <= 0 || width > MAX_PERLIN_SIZE || height <= 0 || height > MAX_PERLIN_SIZE)
{
throw new ArgumentException(string.Format("Noise width and height must be between 1 and {0}", MAX_PERLIN_SIZE));
}
if (frequency < 0)
{
throw new ArgumentException("Frequency must be greater than zero");
}
if (persistence < 0)
{
throw new ArgumentException("Persistence must be greater than zero");
}
if (octaveCount <= 0 || octaveCount > MAX_OCTAVE_COUNT)
{
throw new ArgumentException(string.Format("Octave count must be between 1 and {0}", MAX_OCTAVE_COUNT));
}
if (amplitude < 0)
{
throw new ArgumentException("Amplitude can't be less than zero");
}
PerlinGenerator generator = new PerlinGenerator(width, height, frequency, persistence, octaveCount, amplitude);
return(generator.GetPerlinNoise());
}
public float[,] generate()
{
// IF population density map must be generated randomly then we do it
if (CityGenerator.popMapInput == null)
{
if (CityGeneratorUI.DebugMode)
{
Debug.Log("Generating Random Population Density Map...");
}
pg = new PerlinGenerator(CityGenerator.popSeed, CityGenerator.popOctaves, CityGenerator.popPersistance, CityGenerator.popZoom, 0, 1);
fPopMap = pg.getValues(CityGenerator.mapSize, CityGenerator.mapSize);
if (CityGeneratorUI.DebugMode)
{
Debug.Log("Random Population Density Map generated!");
}
}
// ELSE population map should be passed as input by the user
else
{
if (CityGeneratorUI.DebugMode)
{
Debug.Log("Population Density Map generated using existing map");
}
//make a new reader and use it to read the texture
TextureReader g = new TextureReader();
fPopMap = g.readTexture(CityGenerator.popMapInput, CityGenerator.mapSize);
}
findPeaks();
return(fPopMap);
}
public IslandData Generate(WorldGenerator.IslandSize size, int seed, Vector3 position, float[][] moistureNoise, float[][] tempNoise, int numHeightLevels, bool fromTool = false)
{
if (_terrainSplats == null)
{
_terrainSplats = LoadPrototypes();
}
_id = IslandID++;
int realSize = (int)size;
PerlinGenerator islandNoiseGen = new PerlinGenerator();
int octaves = 5;
float[][] noise = islandNoiseGen.Generate(seed, octaves, realSize);
float[,] heights = CreateHeightMap(noise, realSize, numHeightLevels);
Vector3 posWithOffset = new Vector3(position.x - (realSize / 2f), position.y, position.z - (realSize / 2f));
TerrainData tData = ApplyDataToTerrain(ref _currentTerrain, heights, realSize, numHeightLevels, fromTool);
_currentTerrain.transform.position = posWithOffset;
IslandData data = new IslandData(_id, realSize, posWithOffset, ref tData);
//PopulateTiles(ref data, posWithOffset, moistureNoise, tempNoise, heights, realSize, ref tData);
//DebugDrawGrid(posWithOffset, realSize, heights);
PlaceDetails(heights, realSize, ref data, seed);
return(data);
}
void Awake()
{
PrimGenerator primGen = new PrimGenerator();
// generate a map of size 20x20 with no extra walls removed
MapTile[,] tiles1 = primGen.MapGen(maxX, maxY, 0.3f);
PerlinGenerator perlinGen = new PerlinGenerator();
// generates a map of size 20x20 with a large constraint (generates a tightly-packed map)
map = perlinGen.MapGen(maxX, maxY, 5.0f);
GameObject playerAI = Instantiate(player, new Vector3(0, 0, -.5f), Quaternion.identity);
GameObject enemyAI1 = Instantiate(enemy1, new Vector3(0, 0, -.5f), Quaternion.identity);
playerAI.GetComponent <playerScript>().map = map;
//enemy1.GetComponent<enemyScript>().map = tiles3;
walkables = new List <MapTile>();
foreach (MapTile m in map)
{
if (m.Walkable)
{
walkables.Add(m);
}
}
foreach (MapTile m in map)
{
Vector3 pos = new Vector3(m.X + transform.position.x, m.Y + transform.position.y);
int walkableint = walkables.Count;
System.Random rnd = new System.Random();
int rndnum = rnd.Next(0, walkableint - 1);
if (m.IsStart)
{
Instantiate(startTile, pos, Quaternion.identity);
playerAI.transform.position = new Vector3(m.X + transform.position.x, m.Y + transform.position.y, -.5f);
playerAI.GetComponent <playerScript>().xMax = maxX;
playerAI.GetComponent <playerScript>().yMax = maxY;
playerAI.GetComponent <playerScript>().start = m;
}
else if (m.IsGoal)
{
Instantiate(goalTile, pos, Quaternion.identity);
playerAI.GetComponent <playerScript>().goal = m;
}
else if (m.Walkable)
{
Instantiate(yesTile, pos, Quaternion.identity);
if (m == walkables[rndnum])
{
enemyAI1.transform.position = new Vector3(m.X + transform.position.x, m.Y + transform.position.y, -.5f);
}
}
else if (!m.Walkable)
{
Instantiate(noTile, pos, Quaternion.identity);
}
}
}
void Update()
{
if (!Ready && m_started)
{
Texture2D perlin = PerlinGenerator.CreatePerlinTexture(width, height, xOrg, yOrg, scale);
GenerateLevelFromBitmap(ApplyThresholds(perlin));
}
}
public WorldGenerator(int seed = -1)
{
this.seed = (seed != -1 ? seed : System.Environment.TickCount);
Debug.Log("Seed: " + seed);
perlinGenerator = new PerlinGenerator(0.05f, 0, seed);
DimensionRegistry.RegisterDimension(new SurfaceDimension(seed));
World.WorldManager.SetDimension("Surface");
}
void Awake()
{
if (instance == null)
{
instance = this;
}
else if (instance != this)
{
Destroy(gameObject);
}
}
void Awake()
{
prim = new PrimGenerator();
perlin = new PerlinGenerator();
// generate a map of size 30x30 with half of the walls removed after generation
if (primOrPerlin == "Prim" || primOrPerlin == "prim")
tiles = prim.MapGen(dimension, dimension, removOrConstrain);
else
tiles = perlin.MapGen(dimension, dimension, removOrConstrain);
}
public GameObject Generate(WorldGenerator.IslandSize size, int seed, int numHeightLevels)
{
//fake climate data
PerlinGenerator moistureNoiseGen = new PerlinGenerator();
PerlinGenerator tempNoiseGen = new PerlinGenerator();
int octaves = 9; // higher octaves (10+) create large biomes
float[][] moistureNoise = moistureNoiseGen.Generate(seed, octaves, (int)size);
float[][] temperatureNoise = tempNoiseGen.Generate(seed, octaves, (int)size);
// generate island
Generate(size, seed, Vector3.zero, moistureNoise, temperatureNoise, numHeightLevels, true);
return(_currentTerrain);
}
MapTile[,] generateTilesList()
{
MapTile[,] tiles;
if (perlinGenerator)
{
PerlinGenerator perlinGen = new PerlinGenerator();
tiles = perlinGen.MapGen(width, height, perlinConstraint);
}
else
{
PrimGenerator primGen = new PrimGenerator();
tiles = primGen.MapGen(width, height, primeConstraint);
}
return(tiles);
}
private void BuildTerrain(int seed)
{
int halfMap = mMapSize / 2;
Tile currentTile = null;
PerlinGenerator terrainGen = new PerlinGenerator();
int terrainOctaves = 5;
float[][] terrainNoise = terrainGen.Generate(seed, terrainOctaves, mMapSize);
for (int y = 0; y < mMapSize; y++)
{
for (int x = 0; x < mMapSize; x++)
{
float height = terrainNoise[x][y];
if (height < 0.45f)
{
continue; // don't cover up water
}
else if (height < 0.55f)
{
currentTile = mTiles[(int)eTileType.Sand];
}
else if (height < 0.725f)
{
currentTile = mTiles[(int)eTileType.Grass];
}
else if (height < 0.775f)
{
currentTile = mTiles[(int)eTileType.Rock];
}
else if (height < 0.865f)
{
currentTile = mTiles[(int)eTileType.Mountain];
}
else
{
currentTile = mTiles[(int)eTileType.Snow];
}
int worldPosX = x - halfMap;
int worldPosY = y - halfMap;
Vector3Int pos = new Vector3Int(worldPosX, worldPosY, 0);
mTerrainTileMap.SetTile(pos, currentTile);
}
}
}
void createN()
{
PerlinGenerator perlinGen = new PerlinGenerator();
// generates a map of size 100x100 with a medium constraint (generates a more open map)
tiles4 = perlinGen.MapGen(75, 75, 7.5f);
foreach (MapTile a in tiles4)
{
if (a.IsGoal)
{
Instantiate(goalPlane, new Vector3(a.X, 0, a.Y), Quaternion.identity);
}
else if (a.IsStart)
{
Instantiate(startPlane, new Vector3(a.X, 0, a.Y), Quaternion.identity);
Instantiate(pc, new Vector3(a.X, .5f, a.Y), Quaternion.identity);
}
else if (a.Walkable)
{
Instantiate(walkable, new Vector3(a.X, 0, a.Y), Quaternion.identity);
}
else
{
Instantiate(notWalkable, new Vector3(a.X, 1, a.Y), Quaternion.identity);
}
}
foreach (MapTile a in tiles4)
{
if (a.Walkable)
{
int chance = Mathf.RoundToInt(Random.Range(.5f, 500.5f));
if (chance == 1)
{
Instantiate(enemy1, new Vector3(a.X, .5f, a.Y), Quaternion.identity);
}
}
}
}
private void GenerateWorld(int worldSeed)
{
GameObject islGen = (GameObject)Instantiate(_islandGenPrefab, Vector3.zero, Quaternion.identity);
IslandGenerator generator = islGen.GetComponent <IslandGenerator>();
System.Random worldPRNG = new System.Random(worldSeed);
// biome/climate regions
PerlinGenerator moistureNoiseGen = new PerlinGenerator();
PerlinGenerator tempNoiseGen = new PerlinGenerator();
int octaves = 9; // higher octaves (10+) create large biomes
float[][] moistureNoise = moistureNoiseGen.Generate(worldSeed, octaves, MaxWorldSize);
float[][] temperatureNoise = tempNoiseGen.Generate(worldSeed, octaves, MaxWorldSize);
for (int i = 0; i < NumberOfIslands; ++i)
{
MakeNewIsland(generator, worldPRNG.Next(), moistureNoise, temperatureNoise);
}
}
void Start()
{
PrimGenerator primGen = new PrimGenerator();
// generate a map of size 20x20 with no extra walls removed
MapTile[,] tiles1 = primGen.MapGen(20, 20, 0.0f);
// generate a map of size 30x30 with half of the walls removed after generation
MapTile[,] tiles2 = primGen.MapGen(30, 30, 0.5f);
PerlinGenerator perlinGen = new PerlinGenerator();
// generates a map of size 20x20 with a large constraint (generates a tightly-packed map)
MapTile[,] tiles3 = perlinGen.MapGen(20, 20, 5.0f);
// generates a map of size 20x20 with a medium constraint (generates a more open map)
MapTile[,] tiles4 = perlinGen.MapGen(20, 20, 10.0f);
// generates a map of size 20x20 with a small constraint (generates a very open map)
MapTile[,] tiles5 = perlinGen.MapGen(20, 20, 20.0f);
}
//private static int[] colors = { red, green, blue };
public float[,] generate()
{
//set up array
fGrowthMap = new float[CityGenerator.mapSize, CityGenerator.mapSize];
// IF growth rule must be generated randomly then we do it
if (CityGenerator.growthMapInput == null)
{
if (CityGeneratorUI.DebugMode)
{
Debug.Log("Generating Random Growth Rule Map...");
}
pg = new PerlinGenerator(CityGenerator.growthSeed, CityGenerator.growthOctaves, CityGenerator.growthPersistance, CityGenerator.growthZoom, 0, 1);
float[,] perlinNoise = pg.getValues(CityGenerator.mapSize, CityGenerator.mapSize);
float redBound = CityGenerator.growthBasic;
float greenBound = redBound + CityGenerator.growthNewYork;
for (int i = 0; i < CityGenerator.mapSize; i++)
{
for (int j = 0; j < CityGenerator.mapSize; j++)
{
if (perlinNoise[i, j] <= redBound) // we choose red
{
fGrowthMap[i, j] = red;
}
else if (perlinNoise[i, j] <= greenBound) // we choose green
{
fGrowthMap[i, j] = green;
}
else // we choose blue
{
fGrowthMap[i, j] = blue;
}
}
}
if (CityGeneratorUI.DebugMode)
{
Debug.Log("Random Growth Rule Map generated!");
}
}
// ELSE growth rule should be passed as input by the user
else
{
if (CityGeneratorUI.DebugMode)
{
Debug.Log("GrowthRule Map generated using existing map");
}
// IF the map given in input is of the right size, then we are happy
if (CityGenerator.growthMapInput.height == CityGenerator.mapSize && CityGenerator.growthMapInput.width == CityGenerator.mapSize)
{
//the array that will contain all the pixels of the texture
Color[] pixelArray = new Color[CityGenerator.mapSize * CityGenerator.mapSize];
pixelArray = CityGenerator.growthMapInput.GetPixels(0, 0, CityGenerator.mapSize, CityGenerator.mapSize);
for (int i = 0; i < pixelArray.Length; i += CityGenerator.mapSize)
{
for (int j = i; j < i + CityGenerator.mapSize; j++)
{
if (pixelArray[j].r == 1 && pixelArray[j].g == 0 && pixelArray[j].b == 0)
{
fGrowthMap[(j % CityGenerator.mapSize), (i / CityGenerator.mapSize)] = red;
}
if (pixelArray[j].r == 0 && pixelArray[j].g == 1 && pixelArray[j].b == 0)
{
fGrowthMap[(j % CityGenerator.mapSize), (i / CityGenerator.mapSize)] = green;
}
if (pixelArray[j].r == 0 && pixelArray[j].g == 0 && pixelArray[j].b == 1)
{
fGrowthMap[(j % CityGenerator.mapSize), (i / CityGenerator.mapSize)] = blue;
}
}
}
}
// ELSE we show an error
else
{
Debug.LogError("Map must have the same size of the terrain!");
}
}
return(fGrowthMap);
}
public List<Tile>[,] GenerateWorld()
{
PerlinGenerator heightPerlin = new PerlinGenerator(HeightSeed);
PerlinGenerator mountainPerlin = new PerlinGenerator(MountainSeed);
var world = new List<Tile>[MapWidth, MapHeight];
//generate mountains
for (int x = 0; x < MapWidth; x++)
{
for (int y = 0; y < MapHeight; y++)
{
world[x, y] = new List<Tile>();
int height = (int)Math.Round((mountainPerlin.Noise(MountainNoisiness * x / (float)MapWidth, MountainNoisiness * y / (float)MapHeight, 0) + 0.5f) * MountainMaxHeight);
for (int i = 0; i <= height; i++)
{
world[x, y].Add(new Tile() { Type = TileType.mountain, ZPosition = i });
}
}
}
// Generate land
for (int x = 0; x < MapWidth; x++)
{
for (int y = 0; y < MapHeight; y++)
{
int height = BaseLevel + (int)Math.Round((heightPerlin.Noise(TerrainNoisiness * x / (float)MapWidth, TerrainNoisiness * y / (float)MapHeight, 0) + 0.5f) * TerrainMaxHeight);
for (int i = 0; i <= height; i++)
{
if( !world[x,y].Any(tile => tile.ZPosition == i))
world[x, y].Add(new Tile() { Type = (i <= WaterLevel) ? TileType.sand : (i == height ? TileType.grass : TileType.dirt), ZPosition = i });
}
}
}
// Generate water
for (int x = 0; x < MapWidth; x++)
{
for (int y = 0; y < MapHeight; y++)
{
while (world[x, y].OrderBy(tileHeight => tileHeight.ZPosition).Last().ZPosition < WaterLevel)
{
world[x, y].Add(new Tile() { Type = TileType.water, ZPosition = world[x, y].Last().ZPosition + 1 });
}
}
}
// Generate trees
for (int x = 0; x < MapWidth; x++)
{
for (int y = 0; y < MapHeight; y++)
{
if (world[x, y].Last().Type == TileType.grass && _rand.Next(0, TreeProbability) == 0)
{
GenerateTree(x, y, world[x, y].Last().ZPosition, ref world);
}
}
}
// Generate plants
for (int x = 0; x < MapWidth; x++)
{
for (int y = 0; y < MapHeight; y++)
{
var topTile = world[x, y].Where(tile => tile.Type != TileType.leafs).Last();
if (topTile.Type == TileType.grass && _rand.Next(0, PlantProbability) == 0)
{
var tileType = (TileType)_rand.Next((int)TileType.plant1, (int)TileType.bush2 + 1);
world[x, y].Add(new Tile() { Type = tileType, ZPosition = topTile.ZPosition + 1 });
}
if (topTile.Type == TileType.water && _rand.Next(0, PlantProbability) == 0)
{
var tileType = (TileType)_rand.Next((int)TileType.lilypad1, (int)TileType.lilypad2 + 1);
world[x, y].Add(new Tile() { Type = tileType, ZPosition = topTile.ZPosition + 1 });
}
if (topTile.Type == TileType.sand && _rand.Next(0, PlantProbability) == 0)
{
var tileType = (TileType)_rand.Next((int)TileType.cactus, (int)TileType.desertplant2 + 1);
world[x, y].Add(new Tile() { Type = tileType, ZPosition = topTile.ZPosition + 1 });
}
}
}
// Hide hidden tiles
for (int x = 0; x < MapWidth; x++)
{
for (int y = 0; y < MapHeight; y++)
{
foreach (Tile tile in world[x, y])
{
if (IsHidden(x, y, tile.ZPosition, ref world) && Configuration.TileProperties[tile.Type].Transparency == 1.0f)
tile.Visible = false;
else
tile.Visible = true;
}
}
}
return world;
}
public PerlinTerrainModifier(int priority, TileData solidTile, float perlinZoom, float spawnChance, int seed) : base(priority)
{
this.solidTile = solidTile;
perlinGenerator = new PerlinGenerator(perlinZoom, spawnChance, seed);
}
void Start()
{
PrimGenerator primGen = new PrimGenerator();
PerlinGenerator perlinGen = new PerlinGenerator();
switch (choice)
{
case 1:
// generate a map of size 20x20 with no extra walls removed
MapTile[,] tiles1 = primGen.MapGen(20, 20, 0.25f);
for (int i = 0; i < 20; i++)
{
for (int y = 0; y < 20; y++)
{
if (tiles1[i, y].Walkable == true)
{
if (tiles1[i, y].IsStart)
{
Instantiate(start, new Vector3(tiles1[i, y].X, .005f, tiles1[i, y].Y), Quaternion.identity);
}
else if (tiles1[i, y].IsGoal)
{
Instantiate(goal, new Vector3(tiles1[i, y].X, .005f, tiles1[i, y].Y), Quaternion.identity);
}
else
{
Instantiate(floor, new Vector3(tiles1[i, y].X, .005f, tiles1[i, y].Y), Quaternion.identity);
}
}
else
{
Instantiate(wall, new Vector3(tiles1[i, y].X, 1, tiles1[i, y].Y), Quaternion.identity);
}
}
}
break;
case 2:
// generate a map of size 30x30 with half of the walls removed after generation
MapTile[,] tiles2 = primGen.MapGen(30, 30, 0.15f);
for (int i = 0; i < 30; i++)
{
for (int y = 0; y < 30; y++)
{
if (tiles2[i, y].Walkable == true)
{
if (tiles2[i, y].IsStart)
{
Instantiate(start, new Vector3(tiles2[i, y].X, .005f, tiles2[i, y].Y), Quaternion.identity);
}
else if (tiles2[i, y].IsGoal)
{
Instantiate(goal, new Vector3(tiles2[i, y].X, .005f, tiles2[i, y].Y), Quaternion.identity);
}
else
{
Instantiate(floor, new Vector3(tiles2[i, y].X, .005f, tiles2[i, y].Y), Quaternion.identity);
}
}
else
{
Instantiate(wall, new Vector3(tiles2[i, y].X, 1, tiles2[i, y].Y), Quaternion.identity);
}
}
}
break;
case 3:
// generates a map of size 20x20 with a large constraint (generates a tightly-packed map)
MapTile[,] tiles3 = perlinGen.MapGen(20, 20, 5.0f);
for (int i = 0; i < 20; i++)
{
for (int y = 0; y < 20; y++)
{
if (tiles3[i, y].Walkable == true)
{
if (tiles3[i, y].IsStart)
{
Instantiate(start, new Vector3(tiles3[i, y].X, .005f, tiles3[i, y].Y), Quaternion.identity);
}
else if (tiles3[i, y].IsGoal)
{
Instantiate(goal, new Vector3(tiles3[i, y].X, .005f, tiles3[i, y].Y), Quaternion.identity);
}
else
{
Instantiate(floor, new Vector3(tiles3[i, y].X, .005f, tiles3[i, y].Y), Quaternion.identity);
}
}
else
{
Instantiate(wall, new Vector3(tiles3[i, y].X, 1, tiles3[i, y].Y), Quaternion.identity);
}
}
}
break;
case 4:
// generates a map of size 20x20 with a medium constraint (generates a more open map)
MapTile[,] tiles4 = perlinGen.MapGen(20, 20, 10.0f);
for (int i = 0; i < 20; i++)
{
for (int y = 0; y < 20; y++)
{
if (tiles4[i, y].Walkable == true)
{
if (tiles4[i, y].IsStart)
{
Instantiate(start, new Vector3(tiles4[i, y].X, .005f, tiles4[i, y].Y), Quaternion.identity);
}
else if (tiles4[i, y].IsGoal)
{
Instantiate(goal, new Vector3(tiles4[i, y].X, .005f, tiles4[i, y].Y), Quaternion.identity);
}
else
{
Instantiate(floor, new Vector3(tiles4[i, y].X, .005f, tiles4[i, y].Y), Quaternion.identity);
}
}
else
{
Instantiate(wall, new Vector3(tiles4[i, y].X, 1, tiles4[i, y].Y), Quaternion.identity);
}
}
}
break;
case 5:
// generates a map of size 20x20 with a small constraint (generates a very open map)
MapTile[,] tiles5 = perlinGen.MapGen(20, 20, 20.0f);
for (int i = 0; i < 20; i++)
{
for (int y = 0; y < 20; y++)
{
if (tiles5[i, y].Walkable == true)
{
if (tiles5[i, y].IsStart)
{
Instantiate(start, new Vector3(tiles5[i, y].X, .005f, tiles5[i, y].Y), Quaternion.identity);
}
else if (tiles5[i, y].IsGoal)
{
Instantiate(goal, new Vector3(tiles5[i, y].X, .005f, tiles5[i, y].Y), Quaternion.identity);
}
else
{
Instantiate(floor, new Vector3(tiles5[i, y].X, .005f, tiles5[i, y].Y), Quaternion.identity);
}
}
else
{
Instantiate(wall, new Vector3(tiles5[i, y].X, 1, tiles5[i, y].Y), Quaternion.identity);
}
}
}
break;
}
}
MapTile[,] generateMap()
{
//change maze
//remember to change culling rate
//PrimGenerator pGen = new PrimGenerator();
PerlinGenerator pGen = new PerlinGenerator();
MapTile[,] newMap = pGen.MapGen(xSize, ySize, cullingRate);
//draw outside walls
for (int i = -1; i < xSize + 1; i++)
{
(Instantiate(wall, new Vector3(i * 10, 5, -10), Quaternion.identity) as GameObject).transform.parent = transform;;
}
for (int i = -1; i < xSize + 1; i++)
{
(Instantiate(wall, new Vector3(i * 10, 5, ySize * 10), Quaternion.identity) as GameObject).transform.parent = transform;;
}
for (int i = -1; i < ySize + 1; i++)
{
(Instantiate(wall, new Vector3(-10, 5, i * 10), Quaternion.identity) as GameObject).transform.parent = transform;;
}
for (int i = -1; i < ySize + 1; i++)
{
(Instantiate(wall, new Vector3(xSize * 10, 5, i * 10), Quaternion.identity) as GameObject).transform.parent = transform;
}
//make player
GameObject playerAI = Instantiate(player, Vector3.zero, Quaternion.identity);
playerAI.GetComponent <PlayerScript>().map = newMap;
playerAI.GetComponent <PlayerScript>().xSize = xSize;
playerAI.GetComponent <PlayerScript>().ySize = ySize;
playerAI.transform.parent = transform;
//make enemy
spawnEnemy(1, newMap, playerAI);
spawnWanderer(1, newMap, playerAI);
//draw inside
for (int i = 0; i < xSize; i++)
{
for (int j = 0; j < ySize; j++)
{
if (newMap[i, j].Walkable)
{
GameObject newFloor = Instantiate(floor, new Vector3(i * 10, 0, j * 10), Quaternion.identity);
newFloor.transform.parent = transform;
if (newMap[i, j].IsGoal)
{
//goal is green
newFloor.GetComponent <Renderer>().material.color = Color.green;
playerAI.GetComponent <PlayerScript>().goal = new Vector2(i, j);
}
if (newMap[i, j].IsStart)
{
//start is red
newFloor.GetComponent <Renderer>().material.color = Color.red;
playerAI.GetComponent <PlayerScript>().start = new Vector2(i, j);
}
}
else
{
(Instantiate(wall, new Vector3(i * 10, 5, j * 10), Quaternion.identity) as GameObject).transform.parent = transform;
}
}
}
requestGen = false;
return(newMap);
}
private void PlaceDetails(float[,] heights, int size, ref IslandData data, int seed)
{
System.Random prng = new System.Random(seed);
int noiseSeed = prng.Next();
GameObject detailContainer = new GameObject();
detailContainer.name = "Details Container";
detailContainer.transform.SetParent(_currentTerrain.transform);
eBiome currentBiome = eBiome.Forest;
PerlinGenerator detailNoiseGen = new PerlinGenerator();
float[][] noise = detailNoiseGen.Generate(noiseSeed, 3, size);
int detailID = -1;
for (int i = 0; i < size; ++i)
{
for (int j = 0; j < size; ++j)
{
detailID = -1;
bool changeScale = false;
float height = heights[j, i];
if (height > 0f)
{
float value = noise[i][j];
//currentBiome = data.GetTile(i, j).Biome;
// slope
// need to map x/z to terrain space
float y_01 = (float)i / (float)size;
float x_01 = (float)j / (float)size;
// Calculate the steepness of the terrain
float steepness = data.Data.GetSteepness(y_01, x_01);
if (steepness < _maxVegetationSlope)
{
if (value > 0.85f)
{
detailID = (int)eDetailType.Tree;
changeScale = true;
if (value > 0.95f)
{
// TODO set scale modifier here or something
//detail = _detailObjects[(int)DetailType.Tree_Pine_0];
}
else if (value > 0.9f)
{
//detail = _detailObjects[(int)DetailType.Tree_Pine_1];
}
else
{
//detail = _detailObjects[(int)DetailType.Tree_Pine_2];
}
}
else if (value > 0.75f)
{
detailID = (int)eDetailType.Flower;
//detail = _detailObjects[(int)DetailType.Flower_Bud];
}
else if (value > 0.68f)
{
detailID = (int)eDetailType.Grass;
//detail = _detailObjects[(int)DetailType.Grass];
}
else if (value > 0.65f)
{
detailID = (int)eDetailType.Fern;
//detail = _detailObjects[(int)DetailType.Fern];
}
else if (value < 0.025f)
{
detailID = (int)eDetailType.Rock;
//detail = _detailObjects[(int)DetailType.Rock_Medium];
}
//if (detail != null)
if (detailID > -1)
{
//GameObject detail = null;
GameObject detail = GetDetailsForBiome(currentBiome)[detailID];
GameObject detailObj = (GameObject)Instantiate(detail, Vector3.zero, Quaternion.identity);
float angle = prng.Next(359) + 1;
detailObj.transform.Rotate(Vector3.up, angle);
if (changeScale)
{
float scaleFactor = (float)prng.NextDouble() + 0.25f;
detailObj.transform.localScale = new Vector3(scaleFactor, scaleFactor, scaleFactor);
}
detailObj.transform.SetParent(detailContainer.transform);
// need to place a tile here
PlaceTile(i, j, ref data, _currentTerrain.transform.position);
data.AddObjectToTile(detailObj, i, j);
}
}
}
}
}
}
void Awake()
{
perlinGenerator = GetComponent<PerlinGenerator>();
}
public PerlinSurfaceLayerGenerator(IEnumerable <string> blockLayer, float scale, float threshold) : base(blockLayer)
{
scale *= 2.5f;
perlinGen = new PerlinGenerator(1f / scale);
perlinThreshold = threshold;
}
private void BuildBiomes(int seed)
{
int halfMap = mMapSize / 2;
Tile currentTerrtainTile = null;
System.Random rand = new System.Random(seed);
PerlinGenerator moistureGen = new PerlinGenerator();
int moistOctaves = 8;
float[][] moistureNoise = moistureGen.Generate(rand.Next(), moistOctaves, mMapSize);
PerlinGenerator temperatureGen = new PerlinGenerator();
int tempOctaves = 9;
float[][] tempNoise = temperatureGen.Generate(rand.Next(), tempOctaves, mMapSize);
PerlinGenerator vegetationGen = new PerlinGenerator();
int vegOctaves = 1;
float[][] vegNoise = vegetationGen.Generate(rand.Next(), vegOctaves, mMapSize);
for (int y = 0; y < mMapSize; y++)
{
for (int x = 0; x < mMapSize; x++)
{
int worldPosX = x - halfMap;
int worldPosY = y - halfMap;
Vector3Int pos = new Vector3Int(worldPosX, worldPosY, 0);
TileBase existingWaterTile = mWaterTileMap.GetTile(pos);
TileBase existingTerrainTile = mTerrainTileMap.GetTile(pos);
Biome currentBiome = GetBiome(moistureNoise[x][y], tempNoise[x][y]);
// don't modify certain tiles
if ((existingTerrainTile == null && currentBiome.ID != eBiomeID.Tundra) ||
existingTerrainTile == mTiles[(int)eTileType.Rock] ||
existingTerrainTile == mTiles[(int)eTileType.Mountain] ||
existingTerrainTile == mTiles[(int)eTileType.Snow])
{
continue;
}
// tile from biome
currentTerrtainTile = currentBiome.PrimaryTerrainTile;
if (currentBiome.ID == eBiomeID.Tundra)
{
if (existingTerrainTile == null)
{
// over water
if (existingWaterTile == mTiles[(int)eTileType.ShallowWater])
{
currentTerrtainTile = currentBiome.SecondaryTerrainTile;
}
else
{
// deep water
currentTerrtainTile = null;
}
}
}
// vegetation from biome
if (existingTerrainTile != null && vegNoise[x][y] > 1f - currentBiome.VegetationModifier)
{
mPlantTileMap.SetTile(pos, currentBiome.PrimaryTreeTile);
}
mTerrainTileMap.SetTile(pos, currentTerrtainTile);
}
}
}
