Ejemplo n.º 1
0
    private void TriangulateOpenWater(HexDirection direction, HexObject cell, HexObject neighbour, Vector3 center)
    {
        Vector3 c1 = center + HexMetrics.GetFirstWaterCorner(direction);
        Vector3 c2 = center + HexMetrics.GetSecondWaterCorner(direction);

        water.AddTriangle(center, c1, c2);

        if (direction <= HexDirection.SE && neighbour != null)
        {
            Vector3 bridge = HexMetrics.GetWaterBridge(direction);
            Vector3 e1     = c1 + bridge;
            Vector3 e2     = c2 + bridge;

            water.AddQuad(c1, c2, e1, e2);

            if (direction <= HexDirection.E)
            {
                HexObject nextNeighbour = cell.GetNeighbour(direction.Next());
                if (nextNeighbour == null || !nextNeighbour.IsUnderwater)
                {
                    return;
                }
                water.AddTriangle(c2, e2, c2 + HexMetrics.GetWaterBridge(direction.Next()));
            }
        }
    }
Ejemplo n.º 2
0
    private void TriangulateWater(HexDirection direction, HexObject cell, Vector3 center)
    {
        center.y = cell.WaterSurfaceY;

        HexObject neighbour = cell.GetNeighbour(direction);

        if (neighbour != null && !neighbour.IsUnderwater)
        {
            TriangulateWaterShore(direction, cell, neighbour, center);
        }
        else
        {
            TriangulateOpenWater(direction, cell, neighbour, center);
        }
    }
Ejemplo n.º 3
0
    private void TriangulateWaterShore(HexDirection direction, HexObject cell, HexObject neighbour, Vector3 center1)
    {
        EdgeVertices e1 = new EdgeVertices(center1 + HexMetrics.GetFirstWaterCorner(direction), center1 + HexMetrics.GetSecondWaterCorner(direction));

        water.AddTriangle(center1, e1.v1, e1.v2);
        water.AddTriangle(center1, e1.v2, e1.v3);
        water.AddTriangle(center1, e1.v3, e1.v4);
        water.AddTriangle(center1, e1.v4, e1.v5);

        Vector3 center2 = neighbour.Position;

        center2.y = center1.y;
        EdgeVertices e2 = new EdgeVertices(center2 + HexMetrics.GetSecondSolidCorner(direction.Opposite()), center2 + HexMetrics.GetFirstSolidCorner(direction.Opposite()));

        if (cell.HasRiverThroughEdge(direction))
        {
            TriangulateEstuary(e1, e2, cell.IncomingRiver == direction);
        }
        else
        {
            waterShore.AddQuad(e1.v1, e1.v2, e2.v1, e2.v2);
            waterShore.AddQuad(e1.v2, e1.v3, e2.v2, e2.v3);
            waterShore.AddQuad(e1.v3, e1.v4, e2.v3, e2.v4);
            waterShore.AddQuad(e1.v4, e1.v5, e2.v4, e2.v5);
            waterShore.AddQuadUV(0f, 0f, 0f, 1f);
            waterShore.AddQuadUV(0f, 0f, 0f, 1f);
            waterShore.AddQuadUV(0f, 0f, 0f, 1f);
            waterShore.AddQuadUV(0f, 0f, 0f, 1f);
        }

        HexObject nextNeighbor = cell.GetNeighbour(direction.Next());

        if (nextNeighbor != null)
        {
            Vector3 v3 = nextNeighbor.Position + (nextNeighbor.IsUnderwater ? HexMetrics.GetFirstWaterCorner(direction.Previous()) : HexMetrics.GetFirstSolidCorner(direction.Previous()));
            v3.y = center1.y;
            waterShore.AddTriangle(
                e1.v5, e2.v5, v3
                );
            waterShore.AddTriangleUV(
                new Vector2(0f, 0f),
                new Vector2(0f, 1f),
                new Vector2(0f, nextNeighbor.IsUnderwater ? 0f : 1f)
                );
        }
    }
Ejemplo n.º 4
0
    private void UpdateHex(HexObject hex)
    {
        if (hex)
        {
            if (isDragging)
            {
                HexObject otherCell = hex.GetNeighbour(dragDirection.Opposite());

                if (otherCell)
                {
                    if (currentActionMode == ActionMode.BuildRoad)
                    {
                        otherCell.AddRoad(dragDirection); // TODO: Add a cost to this for gameplay
                    }
                }
            }
        }
    }
Ejemplo n.º 5
0
    private void TriangulateConnection(HexDirection direction, HexObject cell, EdgeVertices e1)
    {
        HexObject neighbour = cell.GetNeighbour(direction);

        if (neighbour == null)
        {
            return;
        }

        Vector3 bridge = HexMetrics.GetBridge(direction);

        bridge.y = neighbour.Position.y - cell.Position.y;
        EdgeVertices e2 = new EdgeVertices(e1.v1 + bridge, e1.v5 + bridge);

        if (cell.HasRiverThroughEdge(direction))
        {
            if (!cell.IsUnderwater)
            {
                e2.v3.y = neighbour.StreamBedY;
                if (!neighbour.IsUnderwater)
                {
                    TriangulateRiverQuad(e1.v2, e1.v4, e2.v2, e2.v4, cell.RiverSurfaceY, neighbour.RiverSurfaceY, 0.8f, cell.HasIncomingRiver && cell.IncomingRiver == direction);
                }
                else if (cell.Elevation > neighbour.WaterLevel)
                {
                    TriangulateWaterfallInWater(e1.v2, e1.v4, e2.v2, e2.v4, cell.RiverSurfaceY, neighbour.RiverSurfaceY, neighbour.WaterSurfaceY);
                }
            }
            else if (!neighbour.IsUnderwater && neighbour.Elevation > cell.WaterLevel)
            {
                TriangulateWaterfallInWater(e2.v4, e2.v2, e1.v4, e1.v2, neighbour.RiverSurfaceY, cell.RiverSurfaceY, cell.WaterSurfaceY);
            }
        }

        if (cell.GetEdgeType(direction) == HexEdgeType.Slope)
        {
            TriangulateEdgeTerraces(e1, cell, e2, neighbour, cell.HasRoadThroughEdge(direction));
        }
        else
        {
            TriangulateEdgeStrip(e1, cell.Color, e2, neighbour.Color, cell.HasRoadThroughEdge(direction));
        }

        HexObject next = cell.GetNeighbour(direction.Next());

        if (direction <= HexDirection.E && next != null)
        {
            Vector3 v5 = e1.v5 + HexMetrics.GetBridge(direction.Next());
            v5.y = next.Position.y;

            if (cell.Elevation <= neighbour.Elevation)
            {
                if (cell.Elevation <= next.Elevation)
                {
                    TriangulateCorner(e1.v5, cell, e2.v5, neighbour, v5, next);
                }
                else
                {
                    TriangulateCorner(v5, next, e1.v5, cell, e2.v5, neighbour);
                }
            }
            else if (neighbour.Elevation <= next.Elevation)
            {
                TriangulateCorner(e2.v5, neighbour, v5, next, e1.v5, cell);
            }
            else
            {
                TriangulateCorner(v5, next, e1.v5, cell, e2.v5, neighbour);
            }
        }
    }