public void updateWindStrength()
{
if (windUpdate)
{
//Findet das Feld aus dem der Wind auf dieses Feld weht.
isTile tile = neighbours[playingField.getWindDirection()];
if (tile != null)
{
windstrength = tile.getWindSpread();
}
else
{
windstrength = playingField.getWindStrength();
}
//Die Windstärke wurde geupdated.
windUpdate = false;
}
}
public void GenerateRectangleMap()
{
Random.InitState(seed);
//Speichert den Typen jedes Feld bevor es finaliesiert wird.
int[,] tempField = new int[xSize, ySize];
//Generiere ein Starttyp für jedes Feld.
for (int x = 0; x < xSize; x++)
{
for (int y = 0; y < ySize; y++)
{
//Generiere eine zufällige Zahl zwischen 0 und 10.
float randomChance = Random.Range(0f, 10f);
//80% Chance das es ein Groundfeld wird.
if (randomChance < 8f)
{
tempField[x, y] = 0;
}
//10% Chance für ein Wasserfeld
else if (randomChance < 9f)
{
tempField[x, y] = 1;
}
//10% chance für ein Gebirgsfeld
else
{
tempField[x, y] = 2;
}
}
}
//Im Augenblick sind Gebirge und Wasser nur seltsam sporadisch verteilt,
//hier wird das Resultat noch ein bischen verändert.
for (int i = 0; i < 3; i++)
{
for (int x = 0; x < xSize; x++)
{
for (int y = 0; y < ySize; y++)
{
int countMountain = 0;
int countWater = 0;
int[,] neighbourCoords;
//Das Nachzählen der Feldertypen um dieses Feld, wenn ihr einen besseren Weg als diesen kennt, nennt ihn mir bitte!
//Jede Reihe braucht andere Koordianten für ihre Nachbarn (weil 6eckig statt viereckig)
if (y % 2 == 1)
{
neighbourCoords = unevenNeighbourCoords;
}
else
{
neighbourCoords = evenNeighbourCoords;
}
for (int j = 0; j < 6; j++)
{
if (x + neighbourCoords[j, 0] >= 0 && x + neighbourCoords[j, 0] < xSize &&
y + neighbourCoords[j, 1] >= 0 && y + neighbourCoords[j, 1] < ySize)
{
if (tempField[x + neighbourCoords[j, 0], y + neighbourCoords[j, 1]] == 2)
{
countMountain++;
}
else if (tempField[x + neighbourCoords[j, 0], y + neighbourCoords[j, 1]] == 1)
{
countWater++;
}
}
}
//Ein GroundFeld das neben 3 oder mehr Wasserfeldern ist, kann sich selbst in ein Wassfeld verwandeln.
//Ist es neben 1 oder 2 Gebirgsfeldern, kann es sich auch in ein Gebirgsfeld verwandeln
if (tempField[x, y] == 0)
{
//Chance sich in ein Wasserfeld zu verwandeln.
if (countWater >= 2)
{
float chance = Random.Range(0f, 1f);
if (chance <= 0.1 + 0.05 * countWater)
{
tempField[x, y] = 1;
}
}
//Chance sich in ein Gebirgsfeld zu verwandeln.
if (countMountain == 2 || countMountain == 1)
{
float chance = Random.Range(0f, 1f);
if (chance <= 0.15 * countMountain)
{
tempField[x, y] = 2;
}
}
}
//Gebirgsfelder können sich in Groundfelder verwandeln, wenn sie 2 oder mehr Wasserfelder berühren.
else if (tempField[x, y] == 2)
{
//Chance sich in ein Groundfeld zu verwandeln.
if (countWater >= 2)
{
float chance = Random.Range(0f, 1f);
if (chance <= 0.2 + 0.075 * countWater)
{
tempField[x, y] = 0;
}
}
}
}
}
}
//Die ausgewürfelten Feldertypen werden jetzt in richtige Felder verwandelt.
felder = new isTile[xSize * ySize];
for (int y = 0; y < ySize; y++)
{
for (int x = 0; x < xSize; x++)
{
Vector2 size = new Vector2(0.866f, 0.747f);
Vector2 position2d;
position2d = new Vector2(x - xSize / 2, y - ySize / 2);
if (y % 2 == 1)
{
position2d.x += 0.5f;
}
Vector3 position = new Vector3(this.transform.position.x + position2d.x * size.x, this.transform.position.y + position2d.y * size.y, 1);
switch (tempField[x, y])
{
case 1:
WaterTile tempWater = Instantiate(waterTilePrefab, position, Quaternion.identity);
felder[y * xSize + x] = tempWater;
tempWater.setWaterStrength((int)Random.Range(WaterTile.minimumWaterStrength, WaterTile.maximumWaterStrength));
tempWater.setPlayingField(this);
break;
case 2:
MountainTile tempMountain = Instantiate(mountainTilePrefab, position, Quaternion.identity);
tempMountain.setPlayingField(this);
felder[y * xSize + x] = tempMountain;
break;
case 0:
default:
GroundTile tempGround = Instantiate(groundTilePrefab, position, Quaternion.identity);
tempGround.setPlayingField(this);
tempGround.setNutrientValue((int)Random.Range(GroundTile.minimumNutrientValue, GroundTile.maximumNutrientValue));
felder[y * xSize + x] = tempGround;
break;
}
}
}
//Jetzt sind alle Felder erstellt, und allen Feldern können jetzt ihre Nachbarn gegeben werden.
for (int i = 0; i < felder.Length; i++)
{
//
int tempX = i % xSize;
int tempY = (i - i % xSize) / xSize;
isTile[] neighbours = new isTile[6];
int[,] neighbourCoords;
if (tempY % 2 == 1)
{
neighbourCoords = unevenNeighbourCoords;
}
else
{
neighbourCoords = evenNeighbourCoords;
}
for (int j = 0; j < 6; j++)
{
int tempX2 = tempX + neighbourCoords[j, 0];
int tempY2 = tempY + neighbourCoords[j, 1];
int tempListPosition = tempY2 * xSize + tempX2;
if (tempListPosition >= 0 && tempListPosition < felder.Length)
{
neighbours[j] = felder[tempListPosition];
}
else
{
neighbours[j] = null;
}
}
}
//Die Erstellung von allen Feldern ist jetzt abgeschlossen.
//Nun folgt das setzen der weiteren Weltbedingten Resourcen wie Licht.
windStrength = (int)Random.Range(minimumWindStrength, maximumWindStrength);
lightStrength = (int)Random.Range(minimumLightStrength, maximumLightStrength);
windDirection = Mathf.FloorToInt(Random.Range(0f, 5.99f));
}
