Exemplo n.º 1
0
    public static Scene.hexNum[] GetNoisyEdgesBetweenPointsOffset(Scene.hexNum start, Scene.hexNum end, int level, float range)
    {
        // number of segments = pow(2, level)
        if (level == 0)
        {
            return(GetLineBetweenPointsOffset(start, end));
        }

        int numPoints = (int)Mathf.Pow(2f, level) + 1;                 // include start & end

        Scene.hexNumFloat[] points = new Scene.hexNumFloat[numPoints]; // use Scene.hexAxis to store paired float values, but the syntax is close to Scene.hexNum
        int k1 = (int)Mathf.Pow(2f, level - 1);
        int k2 = (int)Mathf.Pow(2f, level - 2);
        int k3 = (int)Mathf.Pow(2f, level - 3);

        start = OffsetToCubeCoord(start);
        end   = OffsetToCubeCoord(end);

        Scene.hexNumFloat start_f = Scene.HexNumToFloat(start);
        Scene.hexNumFloat end_f   = Scene.HexNumToFloat(end);
        points[0] = start_f;
        points[points.Length - 1] = end_f;

        while (true)
        {
            // level = 1
            Scene.hexNumFloat hexNF_1 = new Scene.hexNumFloat {
                num_x_float = start.num_x,
                num_z_float = end.num_z,
            };
            Scene.hexNumFloat hexNF_2 = new Scene.hexNumFloat {
                num_x_float = end.num_x,
                num_z_float = start.num_z,
            };
            points[k1] = Scene.RandomLerp(hexNF_1, hexNF_2, range);

            if (level == 1)
            {
                break;
            }


            // level = 2
            Scene.hexNumFloat hexNF_3 = Scene.HalfLerp(start_f, hexNF_1);
            Scene.hexNumFloat hexNF_4 = Scene.HalfLerp(start_f, hexNF_2);
            points[k2] = Scene.RandomLerp(hexNF_3, hexNF_4, range);

            Scene.hexNumFloat hexNF_5 = Scene.HalfLerp(end_f, hexNF_2);
            Scene.hexNumFloat hexNF_6 = Scene.HalfLerp(end_f, hexNF_1);
            points[k1 + k2] = Scene.RandomLerp(hexNF_5, hexNF_6, range);

            if (level == 2)
            {
                break;
            }


            // level = 3
            Scene.hexNumFloat hexNF_7 = Scene.HalfLerp(start_f, hexNF_3);
            Scene.hexNumFloat hexNF_8 = Scene.HalfLerp(start_f, hexNF_4);
            points[k3] = Scene.RandomLerp(hexNF_7, hexNF_8, range);

            hexNF_7         = Scene.HalfLerp(hexNF_3, points[k1]);
            hexNF_8         = Scene.HalfLerp(hexNF_4, points[k1]);
            points[k2 + k3] = Scene.RandomLerp(hexNF_7, hexNF_8, range);

            hexNF_7         = Scene.HalfLerp(hexNF_5, points[k1]);
            hexNF_8         = Scene.HalfLerp(hexNF_6, points[k1]);
            points[k1 + k3] = Scene.RandomLerp(hexNF_7, hexNF_8, range);

            hexNF_7 = Scene.HalfLerp(end_f, hexNF_5);
            hexNF_8 = Scene.HalfLerp(end_f, hexNF_6);
            points[k1 + k2 + k3] = Scene.RandomLerp(hexNF_7, hexNF_8, range);
            break;
        }

        Scene.hexNum[] noisyEdge = new Scene.hexNum[0];
        Scene.hexNum[] line;

        Scene.hexNum[] pointsRounded = new Scene.hexNum[points.Length];
        for (int i = 0; i < points.Length; i++)
        {
            pointsRounded[i] = CubeRound(points[i].num_x_float, points[i].num_z_float);
        }

        for (int i = 0; i < points.Length - 1; i++)
        {
            line = GetLineBetweenPointsCube(pointsRounded[i], pointsRounded[i + 1]);
            Utils.Add(ref noisyEdge, pointsRounded[i]);
            if (line != null)
            {
                Utils.Add(ref noisyEdge, line);
            }
        }
        Utils.Add(ref noisyEdge, pointsRounded[points.Length - 1]);

        for (int i = 0; i < noisyEdge.Length; i++)
        {
            noisyEdge[i] = CubeToOffsetCoord(noisyEdge[i]);
            if (noisyEdge[i].num_x < 0)
            {
                noisyEdge[i].num_x = 0;
            }
            if (noisyEdge[i].num_x >= Scene.areaHeight)
            {
                noisyEdge[i].num_x = Scene.areaHeight - 1;
            }
            if (noisyEdge[i].num_z < 0)
            {
                noisyEdge[i].num_z = 0;
            }
            if (noisyEdge[i].num_z >= Scene.areaWidth)
            {
                noisyEdge[i].num_z = Scene.areaWidth - 1;
            }
        }
        return(noisyEdge);
    }
Exemplo n.º 2
0
    public static Scene.hexNum[] GetTwistedEdgesBetweenPointsOffset(Scene.hexNum start, Scene.hexNum end, float range)
    {
        // twist twice
        Scene.hexNumFloat[] points = new Scene.hexNumFloat[4];
        start = OffsetToCubeCoord(start);
        end   = OffsetToCubeCoord(end);

        Scene.hexNumFloat start_f = Scene.HexNumToFloat(start);
        Scene.hexNumFloat end_f   = Scene.HexNumToFloat(end);
        points[0] = start_f;
        points[points.Length - 1] = end_f;

        Scene.hexNumFloat hexNF_1 = new Scene.hexNumFloat {
            num_x_float = start.num_x,
            num_z_float = end.num_z,
        };
        Scene.hexNumFloat hexNF_2 = new Scene.hexNumFloat {
            num_x_float = end.num_x,
            num_z_float = start.num_z,
        };

        Scene.hexNumFloat hexNF_3 = Scene.Lerp(start_f, hexNF_1, 0.33f);
        Scene.hexNumFloat hexNF_4 = Scene.Lerp(start_f, hexNF_2, 0.33f);
        points[1] = Scene.RandomLerp(hexNF_3, hexNF_4, range);
        hexNF_3   = Scene.Lerp(end_f, hexNF_1, 0.33f);
        hexNF_4   = Scene.Lerp(end_f, hexNF_2, 0.33f);
        points[2] = Scene.RandomLerp(hexNF_3, hexNF_4, range);

        Scene.hexNum[] edge = new Scene.hexNum[0];
        Scene.hexNum[] line;

        Scene.hexNum[] pointsRounded = new Scene.hexNum[points.Length];
        for (int i = 0; i < points.Length; i++)
        {
            pointsRounded[i] = CubeRound(points[i].num_x_float, points[i].num_z_float);
        }

        for (int i = 0; i < points.Length - 1; i++)
        {
            line = GetLineBetweenPointsCube(pointsRounded[i], pointsRounded[i + 1]);
            Utils.Add(ref edge, pointsRounded[i]);
            if (line != null)
            {
                Utils.Add(ref edge, line);
            }
        }
        Utils.Add(ref edge, pointsRounded[points.Length - 1]);

        for (int i = 0; i < edge.Length; i++)
        {
            edge[i] = CubeToOffsetCoord(edge[i]);
            if (edge[i].num_x < 0)
            {
                edge[i].num_x = 0;
            }
            if (edge[i].num_x >= Scene.areaHeight)
            {
                edge[i].num_x = Scene.areaHeight - 1;
            }
            if (edge[i].num_z < 0)
            {
                edge[i].num_z = 0;
            }
            if (edge[i].num_z >= Scene.areaWidth)
            {
                edge[i].num_z = Scene.areaWidth - 1;
            }
        }
        return(edge);
    }