예제 #1
0
        private void BuildGraph(Voronoi v)
        {
            Dictionary <Point, Center> pCMap = new Dictionary <Point, Center>();
            List <Point> points = v.SiteCoords();

            // For each point create a center
            foreach (Point p in points)
            {
                Center c = new Center();
                c.loc   = p;
                c.index = centers.Count;
                centers.Add(c);
                pCMap[p] = c;
            }

            // For each center, assign a region
            foreach (Center c in centers)
            {
                v.Region(c.loc);
            }

            List <Edge> libEdges            = v.Edges();
            Dictionary <int, Corner> pCRMap = new Dictionary <int, Corner>();

            // For each edge in the voronoi edges
            foreach (Edge e in libEdges)
            {
                LineSegment  vEdge = e.VoronoiEdge();
                LineSegment  dEdge = e.DelaunayLine();
                DelaunayEdge dE    = new DelaunayEdge();
                dE.index = edges.Count;
                edges.Add(dE);

                // Setup midpoints for viable voronoi edges for noisy edge generation
                if (vEdge.p0 != null && vEdge.p1 != null)
                {
                    dE.midPoint = InterpolatePoint(vEdge.p0, vEdge.p1, 0.5);
                }

                // Create corners for the voronoi vertices of the edge
                dE.v0 = MakeCorner(pCRMap, vEdge.p0);
                dE.v1 = MakeCorner(pCRMap, vEdge.p1);
                dE.d0 = pCMap[dEdge.p0];
                dE.d1 = pCMap[dEdge.p1];

                // Add borders for delaunay edges
                if (dE.d0 != null)
                {
                    dE.d0.borders.Add(dE);
                }
                if (dE.d1 != null)
                {
                    dE.d1.borders.Add(dE);
                }
                if (dE.v0 != null)
                {
                    dE.v0.protrudes.Add(dE);
                }
                if (dE.v1 != null)
                {
                    dE.v1.protrudes.Add(dE);
                }

                if (dE.d0 != null && dE.d1 != null)
                {
                    AddToCenterList(dE.d0.neighbors, dE.d1);
                    AddToCenterList(dE.d1.neighbors, dE.d0);
                }
                if (dE.v0 != null && dE.v1 != null)
                {
                    AddToCornerList(dE.v0.adjacent, dE.v1);
                    AddToCornerList(dE.v1.adjacent, dE.v0);
                }

                if (dE.d0 != null)
                {
                    AddToCornerList(dE.d0.corners, dE.v0);
                    AddToCornerList(dE.d0.corners, dE.v1);
                }
                if (dE.d1 != null)
                {
                    AddToCornerList(dE.d1.corners, dE.v0);
                    AddToCornerList(dE.d1.corners, dE.v1);
                }

                if (dE.v0 != null)
                {
                    AddToCenterList(dE.v0.touches, dE.d0);
                    AddToCenterList(dE.v0.touches, dE.d1);
                }
                if (dE.v1 != null)
                {
                    AddToCenterList(dE.v1.touches, dE.d0);
                    AddToCenterList(dE.v1.touches, dE.d1);
                }
            }
        }
예제 #2
0
        public VoronoiGraph(Voronoi v, int numLloyd, Random r, bool more)
        {
            // MORE_RANDOM adds more height to everything using the random number generator
            this.MORE_RANDOM = more;
            this.r           = r;

            // Angles used for Radial Map Generation
            bumps      = r.Next(5) + 1;
            startAngle = r.NextDouble() * 2 * Math.PI;
            dipAngle   = r.NextDouble() * 2 * Math.PI;
            dipWidth   = r.NextDouble() * 0.5 + 0.2;

            // Gets the bounds
            bounds = v.GetPlotBounds();

            // Applies Lloyd Relaxation to the points (moving the points to the center of the voronoi polygons,
            // then recreating the voronoi graph, makes things look more appealing to the eye)
            for (int i = 0; i < numLloyd; ++i)
            {
                List <Point> points = v.SiteCoords();

                foreach (Point p in points)
                {
                    List <Point> region = v.Region(p);
                    double       x      = 0;
                    double       y      = 0;

                    foreach (Point c in region)
                    {
                        x += c.x;
                        y += c.y;
                    }

                    x  /= region.Count;
                    y  /= region.Count;
                    p.x = x;
                    p.y = y;
                }

                v = new Voronoi(points, v.GetPlotBounds());
            }

            // Generates Simplex noise graph for Simplex Noise map generation
            MakeNoise(r.Next());

            // Sets up the graph
            BuildGraph(v);

            // Fixes the corners because the Lloyd relaxation will have ruined them
            ImproveCorners();

            // Assigns the elevations, determines oceans and land
            AssignCornerElevations();
            AssignOceanCoastAndLand();
            RedistributeElevations(LandCorners());
            AssignPolygonElevations();

            // Calculates the slopes, rivers, and general moisture
            CalculateDownSlopes();
            CreateRivers();
            AssignCornerMoisture();
            RedistributeMoisture(LandCorners());
            AssignPolygonMoisture();

            // Assigns biomes based on height/moisture
            AssignBiomes();

            // Creates noisy edges for each voronoi polygon for a more interesting look (toggleable)
            BuildNoisyEdges();

            // Unused
            pixelCenterMap = new System.Drawing.Bitmap((int)bounds.width, (int)bounds.width);
        }