Example #1
0
        private int CreateRiver(HexCell origin)
        {
            int          length    = 1;
            HexCell      cell      = origin;
            HexDirection direction = HexDirection.NE;

            while (!cell.IsUnderwater)
            {
                int minNeighborElevation = int.MaxValue;
                flowDirections.Clear();
                for (HexDirection d = HexDirection.NE; d <= HexDirection.NW; d++)
                {
                    HexCell neighbor = cell.GetNeighbor(d);
                    if (!neighbor)
                    {
                        continue;
                    }

                    if (neighbor.Elevation < minNeighborElevation)
                    {
                        minNeighborElevation = neighbor.Elevation;
                    }

                    if (neighbor == origin || neighbor.HasIncomingRiver)
                    {
                        continue;
                    }

                    int delta = neighbor.Elevation - cell.Elevation;
                    if (delta > 0)
                    {
                        continue;
                    }

                    if (neighbor.HasOutgoingRiver)
                    {
                        cell.SetOutgoingRiver(d);
                        return(length);
                    }

                    if (delta < 0)
                    {
                        flowDirections.Add(d);
                        flowDirections.Add(d);
                        flowDirections.Add(d);
                    }
                    if (length == 1 ||
                        (d != direction.Next2() && d != direction.Previous2()))
                    {
                        flowDirections.Add(d);
                    }

                    flowDirections.Add(d);
                }

                if (flowDirections.Count == 0)
                {
                    if (length == 1)
                    {
                        return(0);
                    }

                    if (minNeighborElevation >= cell.Elevation)
                    {
                        cell.WaterLevel = minNeighborElevation;
                        if (minNeighborElevation >= cell.Elevation &&
                            Random.value < extraLakeProbability)
                        {
                            cell.WaterLevel = cell.Elevation;
                            cell.Elevation -= 1;
                        }
                    }
                    break;
                }

                direction = flowDirections[Random.Range(0, flowDirections.Count)];
                cell.SetOutgoingRiver(direction);
                length += 1;

                if (minNeighborElevation >= cell.Elevation)
                {
                    cell.WaterLevel = cell.Elevation;
                    cell.Elevation -= 1;
                }

                cell = cell.GetNeighbor(direction);
            }
            return(length);
        }
 void EditCell(HexCell cell)
 {
     if (cell)
     {
         if (activeTerrainTypeIndex >= 0)
         {
             cell.TerrainTypeIndex = activeTerrainTypeIndex;
         }
         if (applyElevation)
         {
             cell.Elevation = activeElevation;
         }
         if (applyWaterLevel)
         {
             cell.WaterLevel = activeWaterLevel;
         }
         if (riverMode == OptionalToggle.No)
         {
             cell.RemoveRiver();
         }
         if (roadMode == OptionalToggle.No)
         {
             cell.RemoveRoads();
         }
         if (applyUrbanLevel)
         {
             cell.UrbanLevel = activeUrbanLevel;
         }
         if (applyFarmLevel)
         {
             cell.FarmLevel = activeFarmLevel;
         }
         if (applyPlantLevel)
         {
             cell.PlantLevel = activePlantLevel;
         }
         if (walledMode != OptionalToggle.Ignore)
         {
             cell.Walled = walledMode == OptionalToggle.Yes;
         }
         if (applySpecialIndex)
         {
             cell.SpecialIndex = activeSpecialIndex;
         }
         if (isDrag)
         {
             HexCell otherCell = cell.GetNeighbor(dragDirection.Opposite());
             if (otherCell)
             {
                 if (riverMode == OptionalToggle.Yes)
                 {
                     otherCell.SetOutgoingRiver(dragDirection);
                 }
                 if (roadMode == OptionalToggle.Yes)
                 {
                     otherCell.AddRoad(dragDirection);
                 }
             }
         }
     }
 }