refactoring triangulation algorithm

Assets/rootgen-unitycsharp/Runtime/Camera/HexGridCamera.cs

@@ -419,12 +419,12 @@ float cellOuterRadius
             HexagonPoint.GetOuterToInnerRadius(cellOuterRadius) * 2f;
 
         float xMax =
-            (grid.CellCountX - 0.5f) * innerDiameter;
+            (grid.WidthInCells - 0.5f) * innerDiameter;
 
         position.x = Mathf.Clamp(position.x, 0f, xMax);
 
         float zMax =
-            (grid.CellCountZ - 1) * (1.5f * cellOuterRadius);
+            (grid.HeightInCells - 1) * (1.5f * cellOuterRadius);
 
         position.z = Mathf.Clamp(position.z, 0f, zMax);
 
@@ -439,7 +439,7 @@ float cellOuterRadius
         float innerDiameter = 
             HexagonPoint.GetOuterToInnerRadius(cellOuterRadius) * 2f;
 
-        float width = grid.CellCountX * innerDiameter;
+        float width = grid.WidthInCells * innerDiameter;
 
         while (position.x < 0f) {
             position.x += width;
@@ -450,7 +450,7 @@ float cellOuterRadius
         }
 
         float zMax =
-            (grid.CellCountZ - 1) * (1.5f * cellOuterRadius);
+            (grid.HeightInCells - 1) * (1.5f * cellOuterRadius);
 
         position.z = Mathf.Clamp(position.z, 0f, zMax);
 

Assets/rootgen-unitycsharp/Runtime/Collections/FeatureContainer.cs

@@ -223,7 +223,7 @@ float cellOuterRadius
         if  (
             nearCell.HasWalls != farCell.HasWalls &&
             !nearCell.IsUnderwater && !farCell.IsUnderwater &&
-            nearCell.GetEdgeType(farCell) != EdgeType.Cliff
+            nearCell.GetEdgeType(farCell) != ElevationEdgeType.Cliff
         ) {
             AddWallSegment(
                 near.vertex1,
@@ -422,10 +422,10 @@ float cellOuterRadius
         }
 
         bool hasLeftWall = !leftCell.IsUnderwater &&
-                            pivotCell.GetEdgeType(leftCell) != EdgeType.Cliff;
+                            pivotCell.GetEdgeType(leftCell) != ElevationEdgeType.Cliff;
 
         bool hasRightWall = !rightCell.IsUnderwater &&
-                            pivotCell.GetEdgeType(rightCell) != EdgeType.Cliff;
+                            pivotCell.GetEdgeType(rightCell) != ElevationEdgeType.Cliff;
 
         if (hasLeftWall) {
             if (hasRightWall) {

Assets/rootgen-unitycsharp/Runtime/Core/CellData.cs

@@ -0,0 +1,12 @@
+using UnityEngine;
+
+public struct CellData {
+    public HexCoordinates Coordinates { get; set; }
+    public int Index { get; set; }
+    public int ColumnIndex { get; set; }
+    public CellShaderData CellShaderData { get; set; }
+    public bool IsExplorable { get; set; }
+    public Vector3 WorldPosition { get; set; }
+    public HexGridChunk HexGridChunk { get; set; }
+
+}

Assets/rootgen-unitycsharp/Runtime/Core/HexAdjacencyGraph.cs

@@ -0,0 +1,198 @@
+using QuikGraph;
+using System.Collections.Generic;
+
+public class HexAdjacencyGraph : AdjacencyGraph<HexCell, HexEdge> {
+
+/// <summary>
+///     Returns true if the given cell in the graph has a river.
+/// </summary>
+/// <param name="cell">
+///     The cell which is the subject of the query.
+/// </param>
+/// <returns>
+///     A boolean value representing whether the query cell has a river.
+/// </returns>
+    public bool CellHasRiver(HexCell cell) {
+        IEnumerable<HexEdge> edges;
+
+        if (TryGetOutEdges(cell, out edges)) {
+            foreach(HexEdge edge in edges) {
+                if (edge.HasRiver)
+                    return true;
+            }
+        }
+
+        return false;
+    }
+
+/// <summary>
+///     Returns true if the given cell in the graph has a road.
+/// </summary>
+/// <param name="cell">
+///     The cell which is the subject of the query.
+/// </param>
+/// <returns>
+///     A boolean value representing whether the query cell has a road.
+/// </returns>
+    public bool CellHasRoad(HexCell cell) {
+        IEnumerable<HexEdge> edges;
+
+        if (TryGetOutEdges(cell, out edges)) {
+            foreach(HexEdge edge in edges) {
+                if (edge.HasRoad)
+                    return true;
+            }
+        }
+
+        return false;
+    }
+
+/// <summary>
+///     Returns true if the given cell in the graph contains
+///     the termination of a river.
+/// </summary>
+/// <param name="cell">
+///     The cell which is the subject of the query.
+/// </param>
+/// <returns>
+///     A boolean value representing whether the query cell
+///     contains the termination of a river.
+/// </returns>
+    public bool CellHasRiverTerminus(
+        HexCell cell
+    ) {
+        IEnumerable<HexEdge> edges;
+
+        if (TryGetOutEdges(cell, out edges)) {
+            int count = 0;
+            foreach(HexEdge edge in edges) {
+                if (edge.HasRiver)
+                    count++;
+
+                if (count > 2) {
+                    return true;
+                }
+            }
+        }
+
+        return false;
+    }
+
+    public bool CellHasIncomingRiver(
+        HexCell cell
+    ) {
+        IEnumerable<HexEdge> edges;
+
+        if (TryGetOutEdges(cell, out edges)) {
+            foreach(HexEdge edge in edges) {
+                if (edge.HasRoad)
+                    return true;
+            }
+        }
+
+        return false;
+    }
+
+    public IEnumerable<HexEdge> TryGetOutEdgesInDirection(
+        HexCell cell,
+        HexDirection direction
+    ) {
+        IEnumerable<HexEdge> edges;
+        List<HexEdge> result = new List<HexEdge>();
+
+        if (!TryGetOutEdges(cell, out edges)) {
+
+            foreach(HexEdge edge in edges) {
+                if (edge.Direction == direction)
+                    result.Add(edge);
+            }
+        }
+        else {
+            throw new System.ArgumentException(
+                "HexCell did not exist in graph or had no out edges."
+            );
+        }
+
+        return result;
+    }
+
+    public HexEdge GetHexDirectionOppositeEdge(
+        HexEdge edge
+    ) {
+        IEnumerable<HexEdge> edges;
+
+        if (!TryGetOutEdges(edge.Source, out edges)) {
+            foreach(HexEdge currentEdge in edges) {
+                if (currentEdge.Direction == edge.Direction.Opposite()) {
+                    return currentEdge;
+                }
+            }
+        }
+
+        return null;
+    }
+
+    public HexEdge GetHexDirectionNextEdge(
+        HexEdge edge
+    ) {
+        IEnumerable<HexEdge> edges;
+
+        if (!TryGetOutEdges(edge.Source, out edges)) {
+            foreach(HexEdge currentEdge in edges) {
+                if (currentEdge.Direction == edge.Direction.Next()) {
+                    return currentEdge;
+                }
+            }
+        }
+
+        return null;
+    }
+
+    public HexEdge GetHexDirectionPreviousEdge(
+        HexEdge edge
+    ) {
+        IEnumerable<HexEdge> edges;
+
+        if (!TryGetOutEdges(edge.Source, out edges)) {
+            foreach(HexEdge currentEdge in edges) {
+                if (currentEdge.Direction == edge.Direction.Previous()) {
+                    return currentEdge;
+                }
+            }
+        }
+
+        return null;
+    }
+
+    public HexEdge GetHexDirectionNext2Edge(
+        HexEdge edge
+    ) {
+        IEnumerable<HexEdge> edges;
+
+        if (!TryGetOutEdges(edge.Source, out edges)) {
+            foreach(HexEdge currentEdge in edges) {
+                if (currentEdge.Direction == edge.Direction.Next2()) {
+                    return currentEdge;
+                }
+            }
+        }
+
+        return null;
+    }
+
+    public HexEdge GetHexDirectionPrevious2Edge(
+        HexEdge edge
+    ) {
+        IEnumerable<HexEdge> edges;
+
+        if (!TryGetOutEdges(edge.Source, out edges)) {
+            foreach(HexEdge currentEdge in edges) {
+                if (currentEdge.Direction == edge.Direction.Previous2()) {
+                    return currentEdge;
+                }
+            }
+        }
+
+        return null;
+    }
+}