Add chunk generator (#27)

* Update git ignore

* Add ChunkGenratorFlat(without test)

* Add densityMapGenerator and BlockGenerator Methods.

* commit before merge

* Add biomes

* Add genlayer

* Fix code style errors

* Format the code

* Finish the basic function of ChunkGeneratorFlat

* Testing overworld generator

* Basic function of flat generator

* Basic test of overworld generator

* modified to use new chunk storage

* Fix some bugs in Overworld generator

* Update ChunkGeneratorOverworld

Author: jstzwj

.gitignore

@@ -260,3 +260,6 @@ paket-files/
 __pycache__/
 *.pyc
 *.txt
+
+# vscode
+.vscode/

src/MineCase.Algorithm/MathHelper.cs

@@ -0,0 +1,24 @@
+using System;
+using System.Collections.Generic;
+
+namespace MineCase.Algorithm
+{
+    public class MathHelper
+    {
+        public static float DenormalizeClamp(float min, float max, float value)
+        {
+            if (value < 0)
+            {
+                return min;
+            }
+            else if (value > 1)
+            {
+                return max;
+            }
+            else
+            {
+                return min + (max - min) * value;
+            }
+        }
+    }
+}

src/MineCase.Algorithm/Noise/OctavedNoise.cs

@@ -46,7 +46,7 @@ public void Noise(float[,,] noise, Vector3 offset, Vector3 scale)
 
             for (int i = 0; i < _octaves; i++)
             {
-                _innerNoise.AddNoise(noise, offset * frequency, scale * frequency, (float)amplitude);
+                _innerNoise.AddNoise(noise, Vector3.Multiply(offset, scale) * frequency, scale * frequency, (float)amplitude);
                 maxValue += amplitude;
                 amplitude *= _persistence;
                 frequency *= 2;

src/MineCase.Algorithm/Noise/PerlinNoise.cs

@@ -233,4 +233,4 @@ public static float Grad(int hash, float x, float y, float z)
         public static float Lerp(float a, float b, float x) =>
             a + x * (b - a);
     }
-}
+}

src/MineCase.Server.Grains/MineCase.Server.Grains.csproj

@@ -14,9 +14,11 @@
     <PackageReference Include="Microsoft.Orleans.Core" Version="2.0.0-preview2-20170724" />
     <PackageReference Include="StyleCop.Analyzers" Version="1.1.0-beta004" PrivateAssets="All" />
     <PackageReference Include="Newtonsoft.Json" Version="10.0.3" />
+    <PackageReference Include="System.Numerics.Vectors" Version="4.4.0" />
   </ItemGroup>
 
   <ItemGroup>
+    <ProjectReference Include="..\MineCase.Algorithm\MineCase.Algorithm.csproj" />
     <ProjectReference Include="..\MineCase.Protocol\MineCase.Protocol.csproj" />
     <ProjectReference Include="..\MineCase.Server.Interfaces\MineCase.Server.Interfaces.csproj" />
   </ItemGroup>

src/MineCase.Server.Grains/Network/Play/ClientPlayPacketGenerator.cs

@@ -124,56 +124,8 @@ public Task SendChatMessage(Chat jsonData, Byte position)
             });
         }
 
-        public Task ChunkData(Dimension dimension, int chunkX, int chunkZ, ChunkColumn chunkColumn)
+        public Task ChunkData(Dimension dimension, int chunkX, int chunkZ, ChunkColumnStorage chunkColumn)
         {
-            ulong[] CompactBlockIds(Block[] blocks)
-            {
-                var result = new ulong[16 * 16 * 16 * 13 / 64];
-                int byteIndex = 0;
-                int bitIndex = 0;
-                foreach (var block in blocks)
-                {
-                    ulong id = (block.Id << 4) | (block.MetaValue & 0b1111);
-                    var availBits = 64 - bitIndex;
-                    var bitsToWrite = Math.Min(13, availBits);
-                    var shiftBits = 13 - bitsToWrite;
-                    result[byteIndex] |= id << bitIndex;
-                    bitIndex += bitsToWrite;
-                    if (bitIndex == 64)
-                    {
-                        byteIndex++;
-                        bitIndex = 0;
-                    }
-
-                    if (shiftBits > 0)
-                    {
-                        bitsToWrite = shiftBits;
-                        result[byteIndex] = id >> (13 - shiftBits);
-                        bitIndex += bitsToWrite;
-                    }
-
-                    if (bitIndex == 64)
-                    {
-                        byteIndex++;
-                        bitIndex = 0;
-                    }
-                }
-
-                return result;
-            }
-
-            Protocol.Play.ChunkSection ToChunkSection(World.ChunkSection chunkSection)
-            {
-                return new Protocol.Play.ChunkSection
-                {
-                    BitsPerBlock = chunkSection.BitsPerBlock,
-                    PaletteLength = 0,
-                    BlockLight = CompactBy2(chunkSection.Blocks.Select(o => o.BlockLight).ToArray()),
-                    SkyLight = dimension == Dimension.Overworld ? CompactBy2(chunkSection.Blocks.Select(o => o.SkyLight).ToArray()) : null,
-                    DataArray = CompactBlockIds(chunkSection.Blocks)
-                };
-            }
-
             return Sink.SendPacket(new ChunkData
             {
                 ChunkX = chunkX,
@@ -182,19 +134,19 @@ Protocol.Play.ChunkSection ToChunkSection(World.ChunkSection chunkSection)
                 Biomes = chunkColumn.Biomes,
                 PrimaryBitMask = chunkColumn.SectionBitMask,
                 NumberOfBlockEntities = 0,
-                Data = (from s in chunkColumn.Sections select ToChunkSection(s)).ToArray()
+                Data = (from c in chunkColumn.Sections
+                        where c != null
+                        select new Protocol.Play.ChunkSection
+                        {
+                            PaletteLength = 0,
+                            BitsPerBlock = c.BitsPerBlock,
+                            SkyLight = c.SkyLight.Storage,
+                            BlockLight = c.BlockLight.Storage,
+                            DataArray = c.Data.Storage
+                        }).ToArray()
             });
         }
 
-        private static byte[] CompactBy2(byte[] source)
-        {
-            if (source.Length % 2 != 0) throw new ArgumentException("source array's length must be even.");
-            var result = new byte[source.Length / 2];
-            for (int i = 0; i < result.Length; i++)
-                result[i] = (byte)(source[i * 2] | (source[i * 2 + 1] << 4));
-            return result;
-        }
-
         public Task SendPacket(uint packetId, byte[] data)
         {
             return Sink.SendPacket(packetId, data.AsImmutable());

src/MineCase.Server.Grains/User/UserGrain.cs

@@ -86,6 +86,9 @@ public async Task JoinGame()
             _sendKeepAliveTimer = RegisterTimer(OnSendKeepAliveRequests, null, TimeSpan.Zero, TimeSpan.FromSeconds(5));
 
             // _worldTimeSyncTimer = RegisterTimer(OnSyncWorldTime, null, TimeSpan.Zero, )
+
+            // 设置出生点
+            await _player.SetPosition(0, 200, 0, false);
         }
 
         private async Task SendTimeUpdate()

src/MineCase.Server.Grains/World/ChunkColumnGrain.cs

@@ -3,6 +3,7 @@
 using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
+using MineCase.Server.World.Generation;
 using Orleans;
 
 namespace MineCase.Server.World
@@ -13,53 +14,85 @@ internal class ChunkColumnGrain : Grain, IChunkColumn
         private int _chunkX;
         private int _chunkZ;
 
-        public Task<ChunkColumn> GetState()
+        private ChunkColumnStorage _state;
+
+        public Task<ChunkColumnStorage> GetState() => Task.FromResult(_state);
+        /*
+        var generator = GrainFactory.GetGrain<IChunkGeneratorOverworld>(1);
+        GeneratorSettings settings = new GeneratorSettings
+        {
+            Seed = 1,
+        };
+        ChunkColumn chunkColumn = await generator.Generate(_chunkX, _chunkZ, settings);
+        return chunkColumn;
+        */
+
+        /*
+        var blocks = new Block[16 * 16 * 16];
+        var index = 0;
+        for (int y = 0; y < 16; y++)
         {
-            var blocks = new Block[16 * 16 * 16];
-            var index = 0;
-            for (int y = 0; y < 16; y++)
+            for (int x = 0; x < 16; x++)
             {
-                for (int x = 0; x < 16; x++)
+                for (int z = 0; z < 16; z++)
                 {
-                    for (int z = 0; z < 16; z++)
-                    {
-                        if (y == 0)
-                            blocks[index] = new Block { Id = 1, SkyLight = 0xF };
-                        else
-                            blocks[index] = new Block { Id = 0, SkyLight = 0xF };
-                        index++;
-                    }
+                    if (y == 0)
+                        blocks[index] = new Block { Id = 1, SkyLight = 0xF };
+                    else
+                        blocks[index] = new Block { Id = 0, SkyLight = 0xF };
+                    index++;
                 }
             }
+        }
 
-            return Task.FromResult(new ChunkColumn
+        return Task.FromResult(new ChunkColumn
+        {
+            Biomes = Enumerable.Repeat<byte>(0, 256).ToArray(),
+            SectionBitMask = 0b1111_1111_1111_1111,
+            Sections = new[]
             {
-                Biomes = Enumerable.Repeat<byte>(0, 256).ToArray(),
-                SectionBitMask = 0b1111_1111_1111_1111,
-                Sections = new[]
+                new ChunkSection
                 {
-                    new ChunkSection
-                    {
-                        BitsPerBlock = 13,
-                        Blocks = blocks
-                    }
-                }.Concat(Enumerable.Repeat(
-                    new ChunkSection
-                    {
-                        BitsPerBlock = 13,
-                        Blocks = Enumerable.Repeat(new Block { Id = 0, SkyLight = 0xF }, 16 * 16 * 16).ToArray()
-                    }, 15)).ToArray()
-            });
-        }
+                    BitsPerBlock = 13,
+                    Blocks = blocks
+                }
+            }.Concat(Enumerable.Repeat(
+                new ChunkSection
+                {
+                    BitsPerBlock = 13,
+                    Blocks = Enumerable.Repeat(new Block { Id = 0, SkyLight = 0xF }, 16 * 16 * 16).ToArray()
+                }, 15)).ToArray()
+        });
+        */
 
-        public override Task OnActivateAsync()
+        public override async Task OnActivateAsync()
         {
             var key = this.GetWorldAndChunkPosition();
             _world = GrainFactory.GetGrain<IWorld>(key.worldKey);
             _chunkX = key.x;
             _chunkZ = key.z;
 
-            return base.OnActivateAsync();
+            await EnsureChunkGenerated();
+        }
+
+        private async Task EnsureChunkGenerated()
+        {
+            /*
+            var generator = GrainFactory.GetGrain<IChunkGeneratorFlat>(1);
+            GeneratorSettings settings = new GeneratorSettings
+            {
+                FlatGeneratorInfo = new FlatGeneratorInfo
+                {
+                    FlatBlockId = new BlockState?[] { BlockStates.Stone(), BlockStates.Dirt(), BlockStates.Grass() }
+                }
+            };
+            _state = await generator.Generate(_chunkX, _chunkZ, settings);
+            */
+            var generator = GrainFactory.GetGrain<IChunkGeneratorOverworld>(1);
+            GeneratorSettings settings = new GeneratorSettings
+            {
+            };
+            _state = await generator.Generate(_chunkX, _chunkZ, settings);
         }
     }
 }

src/MineCase.Server.Grains/World/Generation/BiomeGeneratorGrain.cs

@@ -0,0 +1,52 @@
+using System;
+using System.IO;
+using System.Threading.Tasks;
+using Microsoft.Extensions.Logging;
+using MineCase.Server.World.Biomes;
+using MineCase.Server.World.Layer;
+using Newtonsoft.Json;
+using Orleans;
+using Orleans.Concurrency;
+using Orleans.Runtime;
+
+namespace MineCase.Server.World.Generation
+{
+    [StatelessWorker]
+    internal class BiomeGeneratorFlatGrain : Grain, IBiomeGenerator
+    {
+        // private GenLayer _genBiomes;
+        // private GenLayer _biomeIndexLayer;
+
+        // private int _seed;
+
+        /*
+        public override Task OnActivateAsync()
+        {
+            _seed = (int)this.GetPrimaryKeyLong();
+            GenLayer[] agenlayer = GenLayer.initializeAllBiomeGenerators(_seed, worldTypeIn, settings);
+            agenlayer = getModdedBiomeGenerators(worldTypeIn, seed, agenlayer);
+            _genBiomes = agenlayer[0];
+            _biomeIndexLayer = agenlayer[1];
+            return Task.CompletedTask;
+        }
+
+        /// <summary>
+        /// Returns an array of biomes for the location input.
+        /// </summary>
+        public void GetBiomesForGeneration(Biome[] biomes, int x, int z, int width, int height)
+        {
+            if (biomes == null || biomes.Length < width * height)
+            {
+                biomes = new Biome[width * height];
+            }
+
+            int[] aint = _genBiomes.getInts(x, z, width, height);
+
+            for (int i = 0; i < width * height; ++i)
+            {
+                biomes[i] = Biome.GetBiome(aint[i]);
+            }
+        }
+        */
+    }
+}

src/MineCase.Server.Grains/World/Generation/ChunkGeneratorFlatGrain.cs

@@ -0,0 +1,54 @@
+using System;
+using System.IO;
+using System.Threading.Tasks;
+using Microsoft.Extensions.Logging;
+using Newtonsoft.Json;
+using Orleans;
+using Orleans.Concurrency;
+using Orleans.Runtime;
+
+namespace MineCase.Server.World.Generation
+{
+    [StatelessWorker]
+    internal class ChunkGeneratorFlatGrain : Grain, IChunkGeneratorFlat
+    {
+        public Task<ChunkColumnStorage> Generate(int x, int z, GeneratorSettings settings)
+        {
+            var chunkColumn = new ChunkColumnStorage();
+            for (int i = 0; i < chunkColumn.Sections.Length; ++i)
+                chunkColumn.Sections[i] = new ChunkSectionStorage(true);
+
+            GenerateChunk(chunkColumn, x, z, settings);
+            PopulateChunk(chunkColumn, x, z, settings);
+            return Task.FromResult(chunkColumn);
+        }
+
+        private void GenerateChunk(ChunkColumnStorage chunk, int x, int z, GeneratorSettings settings)
+        {
+            // 按照flat模式每层的设置给chunk赋值
+            for (int y = 0; y < settings.FlatGeneratorInfo.FlatBlockId.Length; ++y)
+            {
+                var section = chunk.Sections[y / 16];
+                var state = settings.FlatGeneratorInfo.FlatBlockId[y];
+                if (state != null)
+                {
+                    for (int j = 0; j < 16; ++j)
+                    {
+                        for (int k = 0; k < 16; ++k)
+                            section.Data[j, y % 16, k] = new BlockState { Id = state.Value.Id, MetaValue = state.Value.MetaValue };
+                    }
+                }
+
+                for (int i = 0; i < section.SkyLight.Storage.Length; i++)
+                    section.SkyLight.Storage[i] = 0xFF;
+            }
+
+            // todo biomes
+        }
+
+        private void PopulateChunk(ChunkColumnStorage chunk, int x, int z, GeneratorSettings settings)
+        {
+            // TODO generator tree, grass, structures\
+        }
+    }
+}