Ejemplo n.º 1
0
        public float LakePressure(OverworldGeneratorV2 generator, int x, int y, float border, float lakeInterval,
                                  float largeBendSize, float mediumBendSize, float smallBendSize)
        {
            if (!this.Config.AllowScenicLakes)
            {
                return(1f);
            }

            double         pX         = x;
            double         pY         = y;
            ISimplexData2D jitterData = SimplexData2D.NewDisk();

            generator.SimplexInstance(1).GetValue(x / 240.0d, y / 240.0d, jitterData);
            pX += jitterData.GetDeltaX() * largeBendSize;
            pY += jitterData.GetDeltaY() * largeBendSize;

            generator.SimplexInstance(0).GetValue(x / 80.0d, y / 80.0d, jitterData);
            pX += jitterData.GetDeltaX() * mediumBendSize;
            pY += jitterData.GetDeltaY() * mediumBendSize;

            generator.SimplexInstance(4).GetValue(x / 30.0d, y / 30.0d, jitterData);
            pX += jitterData.GetDeltaX() * smallBendSize;
            pY += jitterData.GetDeltaY() * smallBendSize;

            VoronoiResult lakeResults = generator.CellularInstance(0).Eval2D(pX / lakeInterval, pY / lakeInterval);

            return((float)(1.0d - lakeResults.InteriorValue));
        }
        public float MinimumDivisor  = 0;//low divisors can produce excessive rates of change

        public override float Added(OverworldGeneratorV2 generator, float x, float y)
        {
            VoronoiResult points = generator.CellularInstance(1).Eval2D(x / PointWavelength, y / PointWavelength);
            float         raise  = (float)(points.InteriorValue);

            raise = 1.0f - raise;
            //raise = TerrainBase.blendedHillHeight(raise, floor);
            return(raise);
        }
Ejemplo n.º 3
0
        //Return the closest point position in the voronoi surface
        public VoronoiResult[] Get(double x, double y)
        {
            Vector2 at = new Vector2((float)x, (float)y);

            VoronoiResult[] results = new VoronoiResult[1];
            for (int i = 0; i < results.Length; i++)
            {
                results[i].distance = float.MaxValue;
            }

            at *= DensityAdjustment;
            at += _offset;

            Vector2I cell = new Vector2I(MathHelper.Floor(at.X), MathHelper.Floor(at.Y));

            ProcessCell(cell, at, results);

            Vector2 cellPos = at - cell;
            Vector2 distMax = new Vector2(new Vector2(1 - cellPos.X, 0).Length(), new Vector2(0, 1 - cellPos.Y).Length());
            Vector2 distMin = new Vector2(new Vector2(cellPos.X, 0).Length(), new Vector2(0, cellPos.Y).Length());

            // Test near cells
            if (distMin.X < results[results.Length - 1].distance)
            {
                ProcessCell(cell - Vector2I.XAxis, at, results);
            }
            if (distMin.Y < results[results.Length - 1].distance)
            {
                ProcessCell(cell - Vector2I.YAxis, at, results);
            }
            if (distMax.X < results[results.Length - 1].distance)
            {
                ProcessCell(cell + Vector2I.XAxis, at, results);
            }
            if (distMax.Y < results[results.Length - 1].distance)
            {
                ProcessCell(cell + Vector2I.YAxis, at, results);
            }

            // Test further cells
            if (distMin.X + distMin.Y < results[results.Length - 1].distance)
            {
                ProcessCell(cell - Vector2I.One, at, results);
            }
            if (distMax.X + distMax.Y < results[results.Length - 1].distance)
            {
                ProcessCell(cell + Vector2I.One, at, results);
            }
            if (distMin.X + distMax.Y < results[results.Length - 1].distance)
            {
                ProcessCell(cell - Vector2I.XAxis + Vector2I.YAxis, at, results);
            }
            if (distMax.X + distMin.Y < results[results.Length - 1].distance)
            {
                ProcessCell(cell + Vector2I.XAxis - Vector2I.YAxis, at, results);
            }

            for (int i = 0; i < results.Length; i++)
            {
                results[i].delta    *= InverseDensityAdjustment;
                results[i].distance *= InverseDensityAdjustment * InverseDensityAdjustment;
            }

            return(results);
        }