protected override void OnRequest(IWorld world, Rectangle range)
{
for (int j = range.Left; j < range.Right; j += Const.GRID)
{
int mat = PerlinNoiseGenerator.RandomProp(1001, j / Const.GRID, 20) % 20;
for (int i = 1; i <= 3; ++i)
{
if (
mat < 1 ||
mat < 2 && PerlinNoiseGenerator.Random(1002, j / Const.GRID * 123 + i * 45) % 2 == 0)
{
AddObject("Stair", world, new Point(j, range.Bottom - i * Const.GRID));
}
else
{
AddObject("Floor", world, new Point(j, range.Bottom - i * Const.GRID));
}
}
RunChild2(world, new Rectangle(j, range.Bottom - 4 * Const.GRID, Const.GRID, Const.GRID), PerlinNoiseGenerator.Random(23335, j / Const.GRID));
}
for (int j = range.Left, k; j < range.Right; j = k)
{
Tuple <int, int> pair = PerlinNoiseGenerator.RandomSplit(34567, j / Const.GRID, 8);
k = Math.Min(pair.Item2 * Const.GRID, range.Right);
Rectangle subRange = new Rectangle(j, world.Boundary.Top, k - j, world.Boundary.Height - 5 * Const.GRID);
RunChild(world, subRange, PerlinNoiseGenerator.Random(23335, pair.Item1));
}
}
protected override void OnRequest(IWorld world, Rectangle range)
{
for (int j = range.Left; j < range.Right; j += Const.GRID)
{
int mat = PerlinNoiseGenerator.RandomProp(1001, j / Const.GRID, 20) % 20;
int i = PerlinNoiseGenerator.RandomProp(8765, j / Const.GRID, 4) % 5 + 2;
int k = PerlinNoiseGenerator.RandomProp(8765, j / Const.GRID, 4) % 2 - 1;
if (j == range.Left || j == range.Right - Const.GRID)
{
k = 0;
}
if (mat == 4 || mat == 5 || mat == 6)
{
AddObject("Brick", world, new Point(j + k * Const.GRID, range.Bottom - i * Const.GRID));
}
else if (mat == 7)
{
AddObject("Question", world, new Point(j + k * Const.GRID, range.Bottom - i * Const.GRID));
}
else if (mat < 2 || mat < 4 && PerlinNoiseGenerator.Random(8766, range.Left / Const.GRID + i) % 2 != 0)
{
AddObject("Stair", world, new Point(j + k * Const.GRID, range.Bottom - i * Const.GRID));
}
else
{
AddObject("Floor", world, new Point(j + k * Const.GRID, range.Bottom - i * Const.GRID));
}
RunChild2(world, new Rectangle(j, range.Bottom - (i + 1) * Const.GRID, Const.GRID, Const.GRID), PerlinNoiseGenerator.Random(23335, j / Const.GRID));
}
}
public void GenerateTerrain()
{
//Load in the heightMap from the resources folder
tex = LoadPNG("Assets/Resources/heightMap.png");
//used in height map
int iTotalVertices = (width + 1) * (height + 1);
_vertices = new Vector3[iTotalVertices];
_normals = new Vector3[iTotalVertices];
_uvs = new Vector2[iTotalVertices];
numIndicies = height * width * 6;
_triangles = new int[numIndicies];
//Noise map
vertices = new Vector3[width * height];
normals = new Vector3[width * height];
uvs = new Vector2[width * height];
//Generate the noise map
noiseMap = PerlinNoiseGenerator.GenerateNoise(width, height, scale, seed);
//Create new texture for the mesh
meshTex = new Texture2D(width, height);
Generate();
}
public static HeightMap GenerateHeightMap(float[,] heightMap, int width, int height, HeightMapSettings settings, Vector2 center)
{
float[,] values = PerlinNoiseGenerator.GenPerlinNoise(heightMap, width, height, settings, center);
AnimationCurve heightCurve_threadsafe = new AnimationCurve(settings.heightCurve.keys);
float minVal = float.MaxValue;
float maxVal = float.MinValue;
for (int x = 0; x < width; x++)
{
for (int y = 0; y < height; y++)
{
values[x, y] *= heightCurve_threadsafe.Evaluate(values[x, y]) * settings.heightMultiplier;
if (values[x, y] > maxVal)
{
maxVal = values[x, y];
}
else if (values[x, y] < minVal)
{
minVal = values[x, y];
}
}
}
return(new HeightMap(values, minVal, maxVal));
}
void ThreadFunction()
{
Debug.Log("Thread running...");
m_NoiseGenerator = new PerlinNoiseGenerator(2048, 2048);
m_NoiseGenerator.GenerateHeightmap(m_octave, m_persistence);
m_NoiseGenerator.ForceZeroBorder(8, 1.1f);
}
protected override void OnRequest(IWorld world, Rectangle range)
{
int val = PerlinNoiseGenerator.Random(3902, (range.Left * 1100 + range.Top * 2367) / Const.GRID) % 40;
if (val < 5)
{
AddObject("Goomba", world, range.Location);
}
else if (val < 7)
{
AddObject("GreenKoopa", world, range.Location);
}
else if (val < 9)
{
AddObject("RedKoopa", world, range.Location);
}
else if (val < 11)
{
AddObject("Beetle", world, range.Location);
}
else if (val < 12)
{
AddObject("Thwomp", world, range.Location);
}
}
protected override void OnRequest(IWorld world, Rectangle range)
{
int m1 = PerlinNoiseGenerator.Random(3333, range.Left / Const.GRID) % 4 + 2;
int m2 = PerlinNoiseGenerator.Random(3333, range.Left / Const.GRID) % 4 + 2;
base.OnRequest(world, new Rectangle(range.X + m1 * Const.GRID, range.Y, range.Width - (m1 + m2) * Const.GRID, range.Height));
}
protected override void OnRequest(IWorld world, Rectangle range)
{
// note: top / buttom are locked
while (world.Boundary.Left > range.Left - Const.GRID)
{
Tuple <int, int> pair = PerlinNoiseGenerator.RandomSplit(23333, world.Boundary.Left / Const.GRID - 1, 32);
Rectangle subRange = new Rectangle(
pair.Item1 * Const.GRID,
world.Boundary.Top,
world.Boundary.Left - pair.Item1 * Const.GRID,
world.Boundary.Height);
RunChild(world, subRange, PerlinNoiseGenerator.Random(23334, pair.Item1));
world.Extend(subRange.Width, 0, 0, 0);
}
while (world.Boundary.Right < range.Right + Const.GRID)
{
Tuple <int, int> pair = PerlinNoiseGenerator.RandomSplit(23333, world.Boundary.Right / Const.GRID, 16);
Rectangle subRange = new Rectangle(
world.Boundary.Right,
world.Boundary.Top,
pair.Item2 * Const.GRID - world.Boundary.Right,
world.Boundary.Height);
RunChild(world, subRange, PerlinNoiseGenerator.Random(23334, pair.Item1));
world.Extend(0, subRange.Width, 0, 0);
}
}
protected override void OnRequest(IWorld world, Rectangle range)
{
int val = PerlinNoiseGenerator.Random(3902, (range.Left * 1100 + range.Top * 2367) / Const.GRID) % 20;
if (val < 1)
{
AddObject("Bush", world, range.Location);
}
else if (val < 2)
{
AddObject("LeftTriangle", world, range.Location);
}
else if (val < 3)
{
AddObject("RightTriangle", world, range.Location);
}
else if (val < 4)
{
AddObject("Arc", world, range.Location);
}
else if (val < 5)
{
AddObject("Rectangle", world, range.Location);
}
}
public Perlin(IListener <IGameObject> scoreListener, IListener <ISoundable> soundListener) : base(scoreListener, soundListener)
{
perlinNoiseGenerator = new PerlinNoiseGenerator(5120);
noiseConverter = new NoiseConverter();
noiseConverter.SetSize(40, 16);
terrian = new Terrian(scoreListener, soundListener, noiseConverter);
noiseConverter.NewData();
}
void Start()
{
manager = World.Active.GetOrCreateManager <EntityManager>();
PerlinNoiseGenerator perlin = new PerlinNoiseGenerator();
heightmap = perlin.GenerateHeightMap();
ChunkGenerator(chunckBase);
}
public Color Sample(Vector3 pos) {
Color res = new Color();
res.r = PerlinNoiseGenerator.OctaveNoise(pos, channel1PerlinPeriod,perlinOctaves);
res.g = WorleyNoiseGenerator.OctaveNoise(pos, channel2WorleyPeriod, 1);
res.b = WorleyNoiseGenerator.OctaveNoise(pos, channel3WorleyPeriod, 1);
res.a = WorleyNoiseGenerator.OctaveNoise(pos, channel4WorleyPeriod, 1);
return res;
}
public override void OnInspectorGUI()
{
DrawDefaultInspector();
if (GUILayout.Button("Generate"))
{
PerlinNoiseGenerator generator = (PerlinNoiseGenerator)target;
generator.Generate();
}
}
private static NoiseGenerator[] CreateOctaves(Random random, int octaves)
{
var array = new NoiseGenerator[octaves];
for (var i = 0; i < octaves; i++)
{
array[i] = new PerlinNoiseGenerator(random);
}
return(array);
}
private void backgroundWorker_DoWork(object sender, DoWorkEventArgs e)
{
PerlinNoiseSettings[] settings = new PerlinNoiseSettings[this.layers.Items.Count];
for (int i = 0; i < this.layers.Items.Count; i++)
{
settings[i] = PerlinNoiseSettings.Parse((string)this.layers.Items[i]);
}
this.start = DateTime.Now;
this.full = PerlinNoiseGenerator.GetImage(settings, (int)this.resolution.Value, (int)this.threads.Value, (int)this.seed.Value);
this.end = DateTime.Now;
}
/// <summary>
/// 依据柏林噪声算法赋值方块高度
/// </summary>
private int GetPerlinY(Transform _blockTrans)
{
float xSample = (_blockTrans.localPosition.x + GetSeedX) / m_relief;
float zSample = (_blockTrans.localPosition.z + GetSeedZ) / m_relief;
//float noise = Mathf.PerlinNoise( xSample, zSample );
float noise = (float)PerlinNoiseGenerator.PerlinNoise(xSample, zSample);
float y = GetMapHeight * noise;
y = Mathf.Round(y); //取整
return((int)y);
//_blockTrans.localPosition += Vector3.up * y;
}
void Start()
{
manager = World.Active.GetOrCreateManager <EntityManager>();
PerlinNoiseGenerator perlin = new PerlinNoiseGenerator();
heightmap = perlin.GenerateHeightMap();
//创建一个碰撞池
colPool = new ColliderPool(boxCollider, transform);
ChunckGenerator(chunckBase);
}
public override void OnInspectorGUI()
{
base.OnInspectorGUI();
PerlinNoiseGenerator generator = (PerlinNoiseGenerator)target;
if (GUILayout.Button("Randomise Seed"))
{
generator.RandomiseSeed();
}
if (GUILayout.Button("Save new Perlin Noise Generator"))
{
generator.CreateNewPerlinNoiseTexture();
}
}
public IActionResult Index()
{
mapRepository.GetMap(TempData.Peek("SelectedMap").ToString(), User.Identity.Name);
var map = mapRepository.Map;
var FloatArray = new float[map.Size, map.Size];
FloatArray = PerlinNoiseGenerator.GenerateMap(map.Size, map.Seed);
if (map.MapType == 1)
{
FloatArray = IslandMaskGenerator.ApplyIslandMask(map.Size, FloatArray);
}
var IntegerArray = new int[map.Size, map.Size];
for (var y = 0; y < map.Size; y++)
{
for (var x = 0; x < map.Size; x++)
{
IntegerArray[x, y] = (int)(FloatArray[x, y] * 256);
}
}
var width = map.Size;
var height = map.Size;
var ColorArray = new Color[map.Size, map.Size];
for (var y = 0; y < height; y++)
{
for (var x = 0; x < width; x++)
{
var HeightValue = IntegerArray[x, y];
var color = TileColorSelector.SelectTileColor(HeightValue, map.GroundType);
ColorArray[x, y] = color;
}
}
var model = new WorldMapViewModel
{
MapName = map.Name,
Size = map.Size,
HeightValues = IntegerArray,
TileSize = 40,
TileColors = ColorArray
};
return(View(model));
}
protected override void OnRequest(IWorld world, Rectangle range)
{
int val = PerlinNoiseGenerator.Random(3902, (range.Left * 1100 + range.Top * 2367) / Const.GRID) % 20;
if (val < 1)
{
AddObject("Brick", world, range.Location);
}
else if (val < 2)
{
AddObject("Stair", world, range.Location);
}
else if (val < 3)
{
AddObject("Question", world, range.Location);
}
}
static Unit CreateUnit(
PlanetConfig cfg,
Vector2Int localIdx,
GeoRange rect,
Unit parentUnit,
int zoomLevel)
{
//var unit = new GameObject().AddComponent<Unit>();
//unit.name = localIdx.ToString();
//unit.transform.parent = parentGo;
var unit = new Unit
{
Parent = parentUnit,
cfg = cfg,
ZoomLevel = zoomLevel
};
if (parentUnit == null)
{
unit.dataStart = localIdx;
}
else
{
unit.dataStart = parentUnit.dataStart * PlanetConfig.UnitSize + localIdx;
}
unit.LocalIndex = localIdx;
if (zoomLevel == 0)
{
//unit.Surface = SurfaceArea.Load();
if (unit.Surface == null)
{
unit.Surface = new SurfaceArea(rect);
unit.Surface.Points = PerlinNoiseGenerator.CreatePlanetSurfacePoints(cfg);
//unit.Surface.Save();
}
}
else
{
unit.Surface = new SurfaceArea(rect);
}
return(unit);
}
public List <IntVector2> chunkList; // a list that stores the coordinates of every chunk
void Awake()
{
noise = new PerlinNoiseGenerator(UnityEngine.Random.Range(1000000, 10000000));
chunkList = new List <IntVector2>();
numSideBlocks = noise.chunkSize / noise.blockSize;
chunkGrid = new int[numSideBlocks, numSideBlocks];
minX = -noise.chunkSize / noise.blockSize / 2;
maxX = noise.chunkSize / noise.blockSize / 2;
minY = -noise.chunkSize / noise.blockSize / 4;
maxY = noise.chunkSize / noise.blockSize / 4;
minZ = -noise.chunkSize / noise.blockSize / 2;
maxZ = noise.chunkSize / noise.blockSize / 2;
spawnDistance = noise.chunkSize * 2;
despawnDistance = noise.chunkSize * 3;
//CreateChunks();
}
private void InitializeMap()
{
SpriteRenderer sr = GetComponent <SpriteRenderer>();
terrainMapNoiseSeed = Random.Range(-99999, 99999);
moistureMapNoiseSeed = Random.Range(-99999, 99999);
terrainNoiseGenerator = new PerlinNoiseGenerator(terrainMapNoiseSeed);
moistureNoiseGenreator = new PerlinNoiseGenerator(moistureMapNoiseSeed);
moistureNoiseGenreator.octaves = 10;
moistureNoiseGenreator.lacunarity = 1.2f;
moistureNoiseGenreator.persistance = 0.3f;
moistureNoiseGenreator.scale = 75;
float[,] terrainNoiseMap = terrainNoiseGenerator.GenerateNoiseMap(true, mapSize.x, mapSize.y);
float[,] moistureNoiseMap = moistureNoiseGenreator.GenerateNoiseMap(false, mapSize.x, mapSize.y);
sr.sprite = GenerateIslandTerrain(terrainNoiseMap, moistureNoiseMap);
//sr.sprite = GenerateSpriteFromNoiseMap(terrainNoiseMap);
}
public void GenerateNoiseTexture()
{
PerlinNoiseGenerator gen = new PerlinNoiseGenerator();
gen.OctaveCount = 7;
gen.Persistence = .55f;
gen.Interpolation = InterpolationAlgorithms.CosineInterpolation;
perlinNoise = gen.GeneratePerlinNoise(512, 512);
CustomGradientColorFilter filter = new CustomGradientColorFilter();
Texture2DTransformer transformer = new Texture2DTransformer(graphics.GraphicsDevice);
filter.AddColorPoint(0.0f, 0.40f, Color.Blue);
filter.AddColorPoint(0.4f, 0.50f, Color.Yellow);
filter.AddColorPoint(0.50f, 0.70f, Color.Green);
filter.AddColorPoint(0.70f, 0.90f, Color.SaddleBrown);
filter.AddColorPoint(0.90f, 1.00f, Color.White);
noiseTexture = transformer.Transform(filter.Filter(perlinNoise));
}
protected override void OnRequest(IWorld world, Rectangle range)
{
int baseH = range.Height / Const.GRID - 6 - PerlinNoiseGenerator.Random(12321, range.Left / Const.GRID) % 6;
for (int j = range.Left; j < range.Right; j += Const.GRID)
{
int mat = PerlinNoiseGenerator.RandomProp(1001, j / Const.GRID, 20) % 20;
int height = Math.Min(
baseH,
Math.Min(3 + (j - range.Left) / Const.GRID, 3 + (range.Right - Const.GRID - j) / Const.GRID));
for (int i = 1; i <= height; ++i)
{
if (
mat < 1 ||
mat < 2 && PerlinNoiseGenerator.Random(1002, j / Const.GRID) % 2 == 0 ||
mat < 4 && i > 3)
{
AddObject("Stair", world, new Point(j, range.Bottom - i * Const.GRID));
}
else
{
AddObject("Stair", world, new Point(j, range.Bottom - i * Const.GRID));
}
}
RunChild2(world, new Rectangle(j, range.Bottom - (height + 1) * Const.GRID, Const.GRID, Const.GRID), PerlinNoiseGenerator.Random(23335, j / Const.GRID));
}
for (int j = range.Left, k; j < range.Right; j = k)
{
Tuple <int, int> pair = PerlinNoiseGenerator.RandomSplit(34567, j / Const.GRID, 8);
k = Math.Min(pair.Item2 * Const.GRID, range.Right);
Rectangle subRange = new Rectangle(j, world.Boundary.Top, k - j, world.Boundary.Height - (3 + baseH) * Const.GRID);
RunChild(world, subRange, PerlinNoiseGenerator.Random(23335, pair.Item1));
}
}
void Start()
{
// Get Entity Manager.
manager = World.DefaultGameObjectInjectionWorld.EntityManager;
// Create block archetype.
BlockArchetype = manager.CreateArchetype(
typeof(Translation),
typeof(LocalToWorld)
);
// Convert prefab to entity.
var settings = GameObjectConversionSettings.FromWorld(World.DefaultGameObjectInjectionWorld, null);
prefab = GameObjectConversionUtility.ConvertGameObjectHierarchy(BlockPrefab, settings);
// Generate height map from PerlinNoiseGenerator.
noiseGenerator = GetComponent <PerlinNoiseGenerator>();
Minecraft.GameSettings.Heightmap = noiseGenerator.GenerateHeightMap();
// Generate the world
ChunkGenerator(ChunkBase);
}
public void GenerateMap()
{
// Generate the noise map
float[,] heightMap = PerlinNoiseGenerator.GenerateNoiseMap(mapWidth, mapHeight, noiseScale, octaves, persistance, lacunarity, seed, offset);
// Draw the terrain
MapDisplay display = FindObjectOfType <MapDisplay>();
if (drawMode == DrawMode.ColorMap)
{
Color[] colorMap = CreateColorMap(heightMap);
display.DrawColorMap(colorMap, mapWidth, mapHeight);
}
else if (drawMode == DrawMode.NoiseMap)
{
display.DrawNoiseMap(heightMap);
}
else if (drawMode == DrawMode.Mesh)
{
Color[] colorMap = CreateColorMap(heightMap);
display.DrawMesh(heightMap, colorMap, mapWidth, mapHeight);
}
}
public float Noise(Vector3 pos)
{
return(channel1WorleyPercent * WorleyNoiseGenerator.OctaveNoise(pos, channel1WorleyPeriod, worleyOcataves)
+ (1 - channel1WorleyPercent) * PerlinNoiseGenerator.OctaveNoise(pos, channel1PerlinPeriod, perlinOctaves));
}
private void Generate()
{
#region HeightMap
if (heightMap)
{
MeshFilter _meshFilter = GetComponent <MeshFilter>();
Mesh _mesh = new Mesh();
_meshFilter.mesh = _mesh;
float xRatio = _tex.width / rows;
float yRatio = _tex.height / columns;
Color[] _colours = new Color[(rows + 1) * (columns + 1)];
int x = 0, z = 0;
for (int i = 0; i < _vertices.Length; ++i)
{
Color pix = _tex.GetPixel((int)(x * xRatio), (int)(z * yRatio));
float zVal = minTerrainHeight + maxTerrainHeight * pix.grayscale;
_vertices[i].Set(x, zVal, z);
++x;
if (x % (columns + 1) == 0)
{
x = 0;
++z;
}
if (zVal > (maxTerrainHeight / 2f))
{
_colours[i].a = 1f;
_colours[i].r = 1f;
_colours[i].g = 1f;
_colours[i].b = 1f;
}
else if (zVal > (maxTerrainHeight / 3f))
{
_colours[i].a = 1f;
_colours[i].r = 0f;
_colours[i].g = 1f;
_colours[i].b = 0f;
}
else
{
_colours[i].a = 1f;
_colours[i].r = 0f;
_colours[i].g = 0f;
_colours[i].b = 1f;
}
}
int numIndicies = columns * rows * 6;
int[] triangles = new int[numIndicies];
for (int ti = 0, vi = 0; vi < (columns * (rows + 1)); ++vi, ti += 6)
{
triangles[ti] = vi;
triangles[ti + 3] = triangles[ti + 2] = vi + 1;
triangles[ti + 4] = triangles[ti + 1] = vi + columns + 1;
triangles[ti + 5] = vi + columns + 2;
if (vi != 0 && (vi + 2) % (columns + 1) == 0)
{
++vi;
}
}
_mesh.vertices = _vertices;
_mesh.triangles = triangles;
_mesh.colors = _colours;
_mesh.RecalculateNormals();
}
#endregion
else
{
MeshFilter _meshFilter = GetComponent <MeshFilter>();
Mesh _mesh = new Mesh();
_meshFilter.mesh = _mesh;
float[,] noiseMap = PerlinNoiseGenerator.GenerateNoise(rows, columns, 25.2f, 250);
//int x = 0, z = 0;
int vertexIndex = 0;
for (int y = 0; y < columns; ++y)
{
for (int x = 0; x < rows; ++x)
{
_vertices[vertexIndex].Set(x, noiseMap[y, x], y);
//if (x == 20)
//{
// x = 0;
// ++z;
//}
//++x;
++vertexIndex;
}
}
int numIndicies = columns * rows * 6;
int[] triangles = new int[numIndicies];
for (int ti = 0, vi = 0; vi < (columns * (rows + 1)); ++vi, ti += 6)
{
triangles[ti] = vi;
triangles[ti + 3] = triangles[ti + 2] = vi + 1;
triangles[ti + 4] = triangles[ti + 1] = vi + columns + 1;
triangles[ti + 5] = vi + columns + 2;
if (vi != 0 && (vi + 2) % (columns + 1) == 0)
{
++vi;
}
}
_mesh.vertices = _vertices;
_mesh.triangles = triangles;
//_mesh.colors = _colours;
_mesh.RecalculateNormals();
}
}
/// <summary>
/// Generates an array filled with Perlin Noise.
/// </summary>
public float[,] GenerateNoiseMap(int MapWidth, int MapHeight, int Seed,
int Octaves, float NoiseScale, float Persistance, float Lacunarity, Vector2 Offset, Vector2 Offset_Random)
{
return(PerlinNoiseGenerator.GenerationNoiseMap(
MapWidth, MapHeight, Seed, Octaves, NoiseScale, Persistance, Lacunarity, Offset, Offset_Random));
}
