public GUIRiver(GUIManager gm)
{
this.gm = gm;
menuWidth = gm.menuWidth;
rightMenuOffset = gm.rightOffset;
topOffset = gm.topOffset;
buttonHeight = gm.smallButtonHeight;
sideOffset = 10;
scaleY = gm.scaleY;
visibleArea = gm.visibleArea;
rg = gm.cm.riverGenerator;
rg.riverGui = this;
riverFlags = new List<bool>();
//width = 15;
//areaEffect = 1;
//depth = 0.2f;
defaultRiver = new RiverInfo(rg);
defaultRiver.SetDefaultValues();
selectedRiver = defaultRiver;
}
public void GenerateRiver()
{
// Creates a new river. Skip if river has already been created.
if (River != null)
{
return;
}
River = new RiverGenerator();
}
public void AssignFunctions(TerrainGenerator terrainGenerator, FilterGenerator filterGenerator,
RiverGenerator riverGenerator, ErosionGenerator erosionGenerator)
{
tg = terrainGenerator;
fg = filterGenerator;
rg = riverGenerator;
eg = erosionGenerator;
lt = tg.localTerrain;
UpdateLayers();
}
public void AssignFunctions(RiverGenerator rg)
{
this.rg = rg;
lc = rg.localCoordinates;
//globalRiverC = rg.globalRiverC;
lt = rg.lt;
fmc = rg.fmc;
ftm = rg.ftm;
fd = rg.fd;
}
public void AssignFunctions(GlobalCoordinates globalTerrainC, TerrainGenerator terrainGenerator,
FilterGenerator filterGenerator, RiverGenerator riverGenerator, ErosionGenerator erosionGenerator)
{
this.globalTerrainC = globalTerrainC;
tg = terrainGenerator;
fg = filterGenerator;
rg = riverGenerator;
eg = erosionGenerator;
lm.AssignFunctions(tg, fg, rg, eg);
}
/// <summary>
/// The actual world generation process
/// </summary>
protected override void DoOperation()
{
// Generate empty world object
var world = new World(this.WorldDimensions, this.Seed);
this.SignalNextStage("Generating height map..", 0.0);
var heightMap = new HeightMap(this.WorldDimensions, this.Seed, this.Parameters);
this.SignalNextStage("Generating temperature map..", 0.25);
var temperatureMap = new TemperatureMap(this.WorldDimensions, this.Seed, this.Parameters, heightMap);
this.SignalNextStage("Generating drainage map..", 0.30);
var drainageMap = new DrainageMap(this.WorldDimensions, this.Seed, this.Parameters, heightMap);
this.SignalNextStage("Generating rainfall map..", 0.45);
var rainfallMap = new RainfallMap(this.WorldDimensions, this.Seed, this.Parameters, heightMap);
// Generate rivers, readjust rainfall map and rebuild levels
this.SignalNextStage("Generating biomes..", 0.60);
var biomeMapper = new BiomeMapper(this.WorldDimensions, this.Seed, heightMap, rainfallMap, drainageMap, temperatureMap);
this.SignalNextStage("Generating rivers..", 0.70);
var riverGenerator = new RiverGenerator(this.WorldDimensions, this.Seed, heightMap, temperatureMap, rainfallMap, biomeMapper.TerrainTypes);
riverGenerator.GenerateRivers();
this.SignalNextStage("Placing resources..", 0.75);
var resourceGenerator = new ResourceGenerator(this.WorldDimensions, this.Seed, biomeMapper.TerrainTypes, this.Parameters);
this.SignalNextStage("Storing data..", 0.80);
world.DetailedMap.Temperature = temperatureMap.TemperatureTiles;
world.DetailedMap.Drainage = drainageMap.DrainageTiles;
world.DetailedMap.Rainfall = rainfallMap.RainfallTiles;
world.DetailedMap.Terrain = biomeMapper.TerrainTypes;
world.DetailedMap.RiverTileInfo = riverGenerator.RiverTileInfo;
world.DetailedMap.Resources = resourceGenerator.Resources;
this.SignalNextStage("Updating terrain tiles..", 0.85);
world.UpdateTiles();
this.SignalNextStage("Finding start continent..", 0.90);
world.DiscoverInitialContinent();
this.SignalNextStage("Building overview map..", 1.0);
world.BuildOverview();
// Signal that world generation has finished
this.SignalFinished(world);
}
public void AssignFunctions(RiverGenerator rg)
{
this.rg = rg;
fd = rg.fd;
ftm = rg.ftm;
fmc = rg.fmc;
frd = rg.frd;
errorRiver = new RiverInfo(rg);
errorRiver.errorMessage = "-";
terrainWidth = rg.lt.terrainWidth;
terrainHeight = rg.lt.terrainHeight;
}
public RiverInfo(RiverGenerator rg)
{
riverPath = new List<Vertex>();
//reachTop = false;
//reachRight = false;
//reachBot = false;
//reachLeft = false;
fd = rg.fd;
frp = rg.frp;
ftm = rg.ftm;
fmc = rg.fmc;
reachedSides = new List<Direction>();
shape = RiverShape.atan;
lowestPoint = new Vertex(666, 666, 666);
globalRiverC = new GlobalCoordinates(100);
}
public void GenerateMap()
{
if (!Application.isPlaying)
{
return;
}
float[,] noiseMap = NoiseGenerator.GenerateNoise(mapChunkSize, mapChunkSize, seed, noiseScale, octaves, persistance, lacunarity, offset);
Color[] colorMap = new Color[mapChunkSize * mapChunkSize];
TileTerrain[] terrainMap = new TileTerrain[(mapChunkSize - 1) * (mapChunkSize - 1)];
for (int x = 0; x < mapChunkSize; x++)
{
for (int y = 0; y < mapChunkSize; y++)
{
if (useFallOff)
{
noiseMap[x, y] = Mathf.Clamp01(noiseMap[x, y] - fallOffMap[x, y]);
}
float currentHeight = noiseMap[x, y];
for (int i = 0; i < TerrainSettingsManager.Instance.regions.Length; i++)
{
if (currentHeight <= TerrainSettingsManager.Instance.regions[i].height && currentHeight <= 1)
{
colorMap[y * mapChunkSize + x] = TerrainSettingsManager.Instance.regions[i].color;
if (x < (mapChunkSize - 1) && y < (mapChunkSize - 1))
{
terrainMap[y * (mapChunkSize - 1) + x] = TerrainSettingsManager.Instance.regions[i].type;
}
break;
}
}
}
}
RiverReturn river = RiverGenerator.GenerateRivers(noiseMap);
int t;
for (t = 0; t < river.riverPoints.Length; t++)
{
int x = (int)river.riverPoints[t].x;
int y = (int)river.riverPoints[t].y;
//Instantiate(GameObject.CreatePrimitive(PrimitiveType.Cube), new Vector3(y,5,x), Quaternion.identity);
colorMap[y * mapChunkSize + x] = TerrainSettingsManager.Instance.regions[9].color;
terrainMap[y * (mapChunkSize - 1) + x] = TerrainSettingsManager.Instance.regions[9].type;
}
MapDisplay mapDisplay = FindObjectOfType <MapDisplay>();
if (drawmode == DrawMode.noiseMap)
{
mapDisplay.DrawTexture(TextureGenerator.NoiseTextureFromHeightMap(noiseMap));
}
else if (drawmode == DrawMode.ColorMap)
{
mapDisplay.DrawTexture(TextureGenerator.TextureFromColorMap(colorMap, mapChunkSize, mapChunkSize));
}
else if (drawmode == DrawMode.Mesh)
{
map.Initialize(noiseMap, meshHeightMultiplier, meshHeightCurve, levelOfDetail, terrainMap);
map.BuildMesh();
GameTile[] tiles = map.GenerateGameTiles();
map.ApplyTexture(TextureGenerator.TextureFromColorMap(colorMap, mapChunkSize, mapChunkSize));
fogofwar.Initialize(map.Vertices, map.Triangles, map.Uvs, noiseMap.GetLength(0), noiseMap.GetLength(1));
TerrainFeaturePlacer.Instance.PlaceFeatures();
player.Instantiate(map.GetNearestTile(tiles[((mapChunkSize - 1) * (mapChunkSize - 1)) / 2], TileTerrain.Land, TileFeatures.Village, 30));
fogofwar.ClearFog(player.Tile, 3);
}
else if (drawmode == DrawMode.FallOffMap)
{
mapDisplay.DrawTexture(TextureGenerator.NoiseTextureFromHeightMap(FallOffGenerator.GenerateFallOffMap(mapChunkSize)));
}
}
void Start()
{
// Initialise main Class object
terrain = new TerrainGenerator();
// Calling the constructor (Unity's C# does not allow conventional constructors)
terrain.initialise(patchSize, patchMatrixSize);
// Updating end-point of main mesh
endPoint = new Vector3(terrain.terrainSize - 1, 0, terrain.terrainSize - 1);
// Generate fractal Diamond-Square turbulence
terrain.applyDiamondSquare(diSqStrength);
// Initialise procedural texture variables
terrain.applyProceduralTex(true, sandColor, sandLimit, sandStrength, sandCoverage, true, grassColor, grassStrength, true, snowColor, snowLimit, snowStrength, snowCoverage, true, rockColor, slopeLimit, slopeStrength, noiseTexValue);
// Build mesh
terrain.build();
// erosionManager has to be created when
erosionManager = new ErosionManager(terrain);
erosionManager.initHydraulicMaps();
filterManager = new FilterManager(terrain);
//riverGenerator has to be after filterManager!
riverGenerator = new RiverGenerator(terrain);
//doesn't work well with on-fly generation
riverGenerator.ftm.PerserveMountains(5, 30, 20);
}
private void Update()
{
Animator anim = GetComponentInChildren <Animator>();
GameController gc = GameController.GetInstance();
RiverGenerator rg = gc.riverGenerator;
Creature cr = GetComponent <Creature>();
// apply acceleration
velocity += Vector3.ClampMagnitude(GetAcceleration(), maxAcceleration) * Time.deltaTime;
// apply water resistance
Vector3 waterSpeed = rg.GetWaterSpeedAt(transform.position);
velocity += (waterSpeed - velocity) * waterResistance * Time.deltaTime;
// enforce max velocity relative to water speed
velocity = Vector3.ClampMagnitude(velocity - waterSpeed, maxSpeed) + waterSpeed;
velocity.Scale(new Vector3(1, 0, 1));
// Apply gravity when dead
if (cr.IsDead() && (anim.GetCurrentAnimatorStateInfo(0).IsName("Dead")))
{
velocity += Vector3.down * beaverSinkSpeed * Time.deltaTime;
}
// move according to velocity
transform.position += velocity * Time.deltaTime;
// calculate the beaver's rotation and animation blending
if (!cr.IsDead())
{
Vector3 oldRotation = transform.rotation.eulerAngles;
Quaternion desiredRotation = transform.rotation;
// figure out where the beaver wants to look
if (target != null && lookAtBoatVSDirectionBlending != null)
{
float distanceToTarget = Vector3.Distance(target.position, transform.position);
// Use more precise distance if target collider is available
if (targetCollider != null)
{
distanceToTarget = Vector3.Distance(targetCollider.ClosestPoint(transform.position), transform.position);
}
// blend between looking to boat and looking forwards depending on distance
float lookAtTarget = lookAtBoatVSDirectionBlending.Evaluate(distanceToTarget);
desiredRotation = Quaternion.Lerp(
Quaternion.LookRotation(velocity - waterSpeed, Vector3.up),
Quaternion.LookRotation(target.position - transform.position, Vector3.up),
lookAtTarget
);
}
// "Lerp" the beaver towards the desired rotation over time
transform.rotation = Quaternion.Lerp(transform.rotation, desiredRotation, rotationLerp * Time.deltaTime);
// Set the beavers apparent curvature depending on rotation change
float rotationChange = Mathf.DeltaAngle(oldRotation.y, transform.rotation.eulerAngles.y) / Time.deltaTime;
anim.SetFloat("Blend", rotationChange / fullTurnAngle);
// determine if attacking
if (attackTimer == 0f && !anim.GetCurrentAnimatorStateInfo(0).IsName("Attack"))
{
// look for attackable objects
SphereCollider attackSphere = attackPoint.GetComponent <SphereCollider>();
Collider[] attackResult = Physics.OverlapSphere(attackPoint.transform.position, attackSphere.radius, LayerMask.GetMask(attackLayerMask));
foreach (Collider col in attackResult)
{
DestructibleObject d = col.gameObject.GetComponentInParent <DestructibleObject>();
if (d != null && d.objectMaterial == DestructibleObject.DestructibleObjectMaterial.WOOD)
{
// attack!
objectAttacking = d;
anim.SetTrigger("Attack");
attackTimer = attackCooldown;
}
}
}
}
// Update timers
attackTimer -= Mathf.Min(Time.deltaTime, attackTimer);
}
private void generateRivers(){
RiverGenerator riverGenerator = new RiverGenerator ();
List<Vector2> p = new List<Vector2> ();
p.Add (new Vector2 (1,1));
p.Add (new Vector2 (1,2));
p.Add (new Vector2 (2,1));
p.Add (new Vector2 (2,2));
p.Add (new Vector2 (3,1));
p.Add (new Vector2 (3,2));
p.Add (new Vector2 (4,1));
p.Add (new Vector2 (4,2));
riverGenerator.generate (p);
}
public FunctionRiverPlanner(RiverGenerator rg)
{
this.rg = rg;
vertices = rg.vertices;
terrainSize = rg.terrainSize;
}
public void AssignFunctions(RiverGenerator rg)
{
this.rg = rg;
lt = rg.lt;
ftm = rg.ftm;
}
/// <summary>
/// Generates the world.
/// Initiates a <see cref="TerrainGenerator"/> & generates the base Terrain <see cref="TerrainGenerator.GenerateBaseTerrain"/>
/// Then Initiates a <see cref="KingdomsGenerator"/> that generates all the kingdoms, as well as claiming all their territory
/// Then generates terrain details using <see cref="TerrainGenerator.GenerateWorldDetailTerrain"/>
/// Finally, generates all settlements using <see cref="KingdomsGenerator.GenerateAllKingdomSettlements"/>
///
/// TODO - Add dungeon generation, add settlement details generation (roads + paths)
/// </summary>
/// <returns></returns>
public void GenerateWorld(WorldManager wm)
{
//Set Random init state based on seed
Random.InitState(Seed);
MiscMaths.SetRandomSeed(Seed);
//Initiate empty world and generate base terrain
World = new World();
wm.SetWorld(World);
//Create a default RNG to be used by the generators (Not thread safe)
MainGenerator = new GenerationRandom(Seed);
//Generation starts
TerrainGenerator = new TerrainGenerator(this, World);
RiverGenerator = new RiverGenerator(this);
LakeGenerator = new LakeGenerator(this);
Debug.BeginDeepProfile("chunk_base_gen");
TerrainGenerator.GenerateChunkBases();//Generate the chunk bases, these only define if they are land or sea.
//Generates fine terrain details: rivers, lakes, (todo - marshes, more variety to forrests?)
TerrainGenerator.GenerateTerrainDetails();
Debug.EndDeepProfile("chunk_base_gen");
//TODO - check if this is still required (probably not)
ChunkGenerator = new ChunkGenerator(this);
Debug.BeginDeepProfile("kingdom_set_gen");
//We then generate empty kingdoms based on these empty chunks
KingdomsGenerator kingGen = new KingdomsGenerator(World, this);
//We also generate the all empty settlements for the world.
kingGen.GenerateEmptyKingdomsFromBaseChunks(4);
//Generates all settlement chunks
PreGeneratedChunks = kingGen.GenerateSettlements();
Debug.EndDeepProfile("kingdom_set_gen");
Debug.BeginDeepProfile("chunk_struct_gen");
//Generate chunk structures (bandit camps, etc)
StructureGenerator = new ChunkStructureGenerator(this);
StructureGenerator.GenerateStructureShells();
//Iterate all chunks generated for chunk structures, add them to the PreGeneratedChunks
foreach (KeyValuePair <Vec2i, ChunkData> kvp in StructureGenerator.GenerateAllStructures())
{
PreGeneratedChunks.Add(kvp.Key, kvp.Value);
}
Debug.EndDeepProfile("chunk_struct_gen");
Debug.BeginDeepProfile("terrain_map_gen");
//Create a simple map based on the terrain of the world
GenerateTerrainMap(TerrainGenerator.ChunkBases);
Debug.EndDeepProfile("terrain_map_gen");
}
void Start()
{
guiManager = GameObject.Find("GUI").GetComponent<GUIManager>();
terrainWidth = 100;
terrainHeight = terrainWidth;
try
{
GUIterrainPlannerMenu tpMenu = GameObject.Find("TerrainPlanner").GetComponent<GUIterrainPlannerMenu>();
patchSize = tpMenu.patch.patchSize;
}
catch (Exception e)
{
Debug.Log("TerrainPlanner not found");
patchSize = 64;
}
cameraMovement camera = transform.GetComponent<cameraMovement>();
camera.ChangePosition(new Vector3(0, 100, 0));
camera.ChangeRotation(new Vector3(90, 0, 0));
scaleTerrainY = 12;
int quadrantSize = Math.Max(terrainWidth, terrainHeight);
layerManager = new LayerManager();
globalTerrain = new GlobalTerrain(quadrantSize);
localTerrain = new LocalTerrain(terrainWidth, terrainHeight, 30, globalTerrain, layerManager);
filterGenerator = new FilterGenerator(quadrantSize, localTerrain);
functionMathCalculator = new FunctionMathCalculator();
functionDebugger = new FunctionDebugger();
functionRiverDigger = new FunctionRiverDigger();
functionRiverPlanner = new FunctionRiverPlanner();
functionTerrainManager = new FunctionTerrainManager();
terrainGenerator = new TerrainGenerator(patchSize);
riverGenerator = new RiverGenerator(localTerrain);
erosionGenerator = new ErosionGenerator(localTerrain);
gridManager = new GridManager(new Vector3(0,0,0), patchSize, patchSize);
AssignFunctions();
terrainGenerator.initialize(scaleTerrainY);
localTerrain.UpdateVisibleTerrain(new Vector3(0, 0, 0), false);
}
// Launches the generation of the specified water body (or all of them if index = -1).
public void RecalculateWaterBodies(int index = -1)
{
// Reset all roads, since roads will have to be recalculated after any water body change.
foreach (RoadGenerator thread in roadThreads.Values)
thread.Abort ();
roadThreads.Clear ();
if (roadsCoroutine != null) {
StopCoroutine (roadsCoroutine);
roadsCoroutine = null;
}
for (int i = ((index < 0) ? 0 : index); i < ((index < 0) ? waterBodiesDefinitionData.Count : (index + 1)); i++) {
if (waterBodiesThreads.ContainsKey (i)) // If thread for this water body is running, substitute it.
waterBodiesThreads[i].Abort ();
Vector3 origin = waterBodiesDefinitionData [i];
WaterBodyGenerator thread;
if (origin.y >= 0f)
thread = new OceanGenerator (new Vector2 (origin.x, origin.z), origin.y);
else
thread = new RiverGenerator (new Vector2 (origin.x, origin.z));
thread.Start ();
waterBodiesThreads[i] = thread;
}
// If the coroutine is already launch, no change is needed, since it will check for all currently running threads.
if (waterBodiesCoroutine == null)
waterBodiesCoroutine = StartCoroutine (WaitForWaterBodyThreads());
}
public FunctionMathCalculator(RiverGenerator rg)
{
this.rg = rg;
vertices = rg.vertices;
terrainSize = rg.terrainSize;
}
override public void OnStateEnter(Animator animator, AnimatorStateInfo animatorStateInfo, int layerIndex)
{
RiverGenerator riverGenerator = GameController.GetInstance().riverGenerator;
riverGenerator.RepopulateBuffer(templates, uniqueTemplates, Random.Range(minTemplates, maxTemplates), uniqueChance);
}
public void AssignFunctions(GlobalTerrain globalTerrain, LocalTerrain localTerrain,
FilterGenerator filterGenerator, FunctionMathCalculator functionMathCalculator,
RiverGenerator riverGenerator, GridManager gridManager, GUIManager guiManager,
ErosionGenerator erosionGenerator)
{
this.globalTerrain = globalTerrain;
this.localTerrain = localTerrain;
this.filterGenerator = filterGenerator;
this.riverGenerator = riverGenerator;
this.erosionGenerator = erosionGenerator;
fmc = functionMathCalculator;
gm = gridManager;
rt.AssignFunctions(fmc);
ds.AssignFunctions(localTerrain);
this.guiManager = guiManager;
message = guiManager.message;
}
