public void ZipRetrieveLocalSector() { string filename = Path.Combine(TestingUtilities.Config["DataPath"], "LocalSector.zip"); if (!File.Exists(filename)) { ZipStoreLocalSector(); } IStellarMap map; IMapStorage store = MapStorageFactory.GetStorage(MapStorageFactory.ZipStorage); using StreamReader reader = new StreamReader(filename); map = store.Retreive <ProgressionMap>(reader); // now serialize it to json file to inspect filename = Path.Combine(TestingUtilities.Config["DataPath"], "LocalSectorCheck.json"); if (File.Exists(filename)) { File.Delete(filename); } store = MapStorageFactory.GetStorage(MapStorageFactory.JsonStorage); using StreamWriter writer = new StreamWriter(filename); store.Store(map, writer); }
/// <summary> /// Sets a block at the given position. /// </summary> /// <param name="map"></param> /// <param name="x"></param> /// <param name="y"></param> /// <param name="z"></param> /// <param name="blocktype"></param> private static void SetBlock(IMapStorage map, int x, int y, int z, int blocktype) { if (MapUtil.IsValidPos(map, x, y, z)) { map.SetBlock(x, y, z, blocktype); } }
public static void MakeSmallTrees(IMapStorage map, int cx, int cy, int cz, int chunksize, Random rnd, int count) { int chooseTreeType; for (int i = 0; i < count; i++) { int x = cx + rnd.Next(chunksize); int y = cy + rnd.Next(chunksize); int z = cz + rnd.Next(chunksize); if (!MapUtil.IsValidPos(map, x, y, z) || map.GetBlock(x, y, z) != WorldGeneratorTools.TileIdGrass) { continue; } chooseTreeType = rnd.Next(0, 3); switch (chooseTreeType) { case 0: MakeTreeType1(map, x, y, z, rnd); break; case 1: MakeTreeType2(map, x, y, z, rnd); break; case 2: MakeTreeType3(map, x, y, z, rnd); break; } ; } }
/// <summary> /// Creates a cuboid at the given location and using the given sizes. /// </summary> /// <param name="map"></param> /// <param name="x"></param> /// <param name="y"></param> /// <param name="z"></param> /// <param name="sizex"></param> /// <param name="sizey"></param> /// <param name="sizez"></param> /// <param name="blocktype"></param> /// <param name="allowin"></param> /// <param name="chance"></param> /// <param name="rnd"></param> public static void MakeCuboid(IMapStorage map, int x, int y, int z, int sizex, int sizey, int sizez, int blocktype, int[] allowin, double chance, Random rnd) { for (int xx = 0; xx < sizex; xx++) { for (int yy = 0; yy < sizey; yy++) { for (int zz = 0; zz < sizez; zz++) { if (MapUtil.IsValidPos(map, x + xx, y + yy, z + zz)) { int t = map.GetBlock(x + xx, y + yy, z + zz); if (allowin == null) { goto ok; } foreach (int tt in allowin) { if (tt == t) { goto ok; } } continue; ok: if (rnd.NextDouble() < chance) { map.SetBlock(x + xx, y + yy, z + zz, blocktype); } } } } } }
/// <summary> /// Creates some flowers all over the chunk. /// </summary> /// <param name="map"></param> /// <param name="cx"></param> /// <param name="cy"></param> /// <param name="cz"></param> /// <param name="chunksize"></param> /// <param name="rnd"></param> public static void MakeFlowers(IMapStorage map, int cx, int cy, int cz, int chunksize, Random rnd) { for (int i = 0; i < 5; i++) { int x = cx + rnd.Next(chunksize); int y = cy + rnd.Next(chunksize); int z = cz + rnd.Next(chunksize); if (!MapUtil.IsValidPos(map, x, y, z) || map.GetBlock(x, y, z) != WorldGeneratorTools.TileIdGrass) { continue; } int xx; int yy; int zz; int tile = rnd.NextDouble() < 0.75 ? WorldGeneratorTools.TileIdYellowFlower : WorldGeneratorTools.TileIdRedFlower; int count = rnd.Next(50, 80); for (int j = 0; j < count; j++) { xx = x + rnd.Next(-6, 6); yy = y + rnd.Next(-6, 6); zz = z + rnd.Next(-2, 2); if (!MapUtil.IsValidPos(map, xx, yy, zz) || map.GetBlock(xx, yy, zz) != WorldGeneratorTools.TileIdGrass) { continue; } // set the block SetBlock(map, x, y, z, tile); } } }
public void ZipRetrieveSolarSystem() { string filename = Path.Combine(TestingUtilities.Config["DataPath"], "SolarSystem.zip"); if (!File.Exists(filename)) { ZipStoreSolarSystem(); } IStellarMap map; IMapStorage store = MapStorageFactory.GetStorage(MapStorageFactory.ZipStorage); using StreamReader reader = new StreamReader(filename); map = store.Retreive <BaseStellarMap>(reader); #pragma warning disable S125 //// now serialize it to json file to inspect //filename = Path.Combine(TestingUtilities.Config["DataPath"], "SolarSystem from zip.json"); //if (File.Exists(filename)) // File.Delete(filename); //store = MapStorageFactory.GetStorage(MapStorageFactory.JsonStorage); //using StreamWriter writer = new StreamWriter(filename); //store.Store(map, writer); #pragma warning restore S125 IStellarMap generatedMap = SolarSystem.CreateSolSystem(); Assert.IsTrue(BaseStellarMapEqualityComparer.Comparer.Equals(map as BaseStellarMap, generatedMap as BaseStellarMap)); }
public static bool IsValidChunkPos(IMapStorage map, int cx, int cy, int cz, int chunksize) { return(cx >= 0 && cy >= 0 && cz >= 0 && cx < map.MapSizeX / chunksize && cy < map.MapSizeY / chunksize && cz < map.MapSizeZ / chunksize); }
/// <summary> /// Sets a block at the given position, but only if it is empty. /// </summary> /// <param name="map"></param> /// <param name="x"></param> /// <param name="y"></param> /// <param name="z"></param> /// <param name="blocktype"></param> private static void SetBlockIfEmpty(IMapStorage map, int x, int y, int z, int blocktype) { if (MapUtil.IsValidPos(map, x, y, z) && map.GetBlock(x, y, z) == WorldGeneratorTools.TileIdEmpty) { map.SetBlock(x, y, z, blocktype); } }
/// <summary> /// Creates a tree of type #3 at the given location. /// </summary> /// <param name="map"></param> /// <param name="x"></param> /// <param name="y"></param> /// <param name="z"></param> /// <param name="rnd"></param> public static void MakeTreeType3(IMapStorage map, int x, int y, int z, Random rnd) { int treeHeight = rnd.Next(6, 9); int xx = 0; int yy = 0; int dir = 0; for (int i = 0; i < treeHeight; i++) { SetBlock(map, x, y, z + i, WorldGeneratorTools.TileIdTreeTrunk); if (i % 3 == 0 && i > 3) { for (int j = 1; j < 9; j++) { dir += 45; for (int k = 1; k < 2; k++) { int length = dir % 90 == 0 ? k : (int)(k / 2); xx = length * (int)Math.Round(Math.Cos(dir * Math.PI / 180)); yy = length * (int)Math.Round(Math.Sin(dir * Math.PI / 180)); SetBlock(map, x + xx, y + yy, z + i, WorldGeneratorTools.TileIdTreeTrunk); SetBlockIfEmpty(map, x + xx, y + yy, z + i + 1, WorldGeneratorTools.TileIdLeaves); SetBlockIfEmpty(map, x + xx + 1, y + yy, z + i, WorldGeneratorTools.TileIdLeaves); SetBlockIfEmpty(map, x + xx - 1, y + yy, z + i, WorldGeneratorTools.TileIdLeaves); SetBlockIfEmpty(map, x + xx, y + yy + 1, z + i, WorldGeneratorTools.TileIdLeaves); SetBlockIfEmpty(map, x + xx, y + yy - 1, z + i, WorldGeneratorTools.TileIdLeaves); } } } if (i % 3 == 2 && i > 3) { dir = 45; for (int j = 1; j < 9; j++) { dir += 45; for (int k = 1; k < 3; k++) { int length = dir % 90 == 0 ? k : (int)(k / 2); xx = length * (int)Math.Round(Math.Cos(dir * Math.PI / 180)); yy = length * (int)Math.Round(Math.Sin(dir * Math.PI / 180)); SetBlock(map, x + xx, y + yy, z + i, WorldGeneratorTools.TileIdTreeTrunk); SetBlockIfEmpty(map, x + xx, y + yy, z + i + 1, WorldGeneratorTools.TileIdLeaves); SetBlockIfEmpty(map, x + xx + 1, y + yy, z + i, WorldGeneratorTools.TileIdLeaves); SetBlockIfEmpty(map, x + xx - 1, y + yy, z + i, WorldGeneratorTools.TileIdLeaves); SetBlockIfEmpty(map, x + xx, y + yy + 1, z + i, WorldGeneratorTools.TileIdLeaves); SetBlockIfEmpty(map, x + xx, y + yy - 1, z + i, WorldGeneratorTools.TileIdLeaves); } } } SetBlockIfEmpty(map, x, y, z + treeHeight, WorldGeneratorTools.TileIdLeaves); } }
public static int SearchColumn(IMapStorage map, int x, int y, int id, int startH) { for (int h = startH; h > 0; h--) { if (map.GetBlock(x, y, h) == (byte)id) { return(h); } } return(-1); // -1 means 'not found' }
public static int blockheight(IMapStorage map, int tileidempty, int x, int y) { for (int z = map.MapSizeZ - 1; z >= 0; z--) { if (map.GetBlock(x, y, z) != tileidempty) { return(z + 1); } } return(map.MapSizeZ / 2); }
public static void JsonRetrieveLocalSector() { string filename = Path.Combine(dataDir, "LocalSector.json"); IStellarMap map; IMapStorage store = MapStorageFactory.GetStorage(MapStorageFactory.JsonStorage); using StreamReader reader = new StreamReader(filename); map = store.Retreive <ProgressionMap>(reader); Console.WriteLine(map.ToString()); }
public static void RetrieveSolarSystem() { string filename = Path.Combine(dataDir, "SolarSystem.json"); IStellarMap map; IMapStorage store = MapStorageFactory.GetStorage(MapStorageFactory.JsonStorage); using StreamReader reader = new StreamReader(filename); map = store.Retreive <BaseStellarMap>(reader); Console.WriteLine(map.ToString()); }
public static bool IsValidPos(IMapStorage map, int x, int y, int z) { if (x < 0 || y < 0 || z < 0) { return(false); } if (x >= map.MapSizeX || y >= map.MapSizeY || z >= map.MapSizeZ) { return(false); } return(true); }
public void JsonRetrieveSolarSystem() { string filename = Path.Combine(TestingUtilities.Config["DataPath"], "LocalSector.json"); if (!File.Exists(filename)) { JsonStoreLocalSector(); } IStellarMap map; IMapStorage store = MapStorageFactory.GetStorage(MapStorageFactory.JsonStorage); using StreamReader reader = new StreamReader(filename); map = store.Retreive <ProgressionMap>(reader); }
/// <summary> /// Populates a chunk using the default Manic Digger chunk generation algorithm. /// </summary> /// <param name="map"></param> /// <param name="x"></param> /// <param name="y"></param> /// <param name="z"></param> public override void PopulateChunk(IMapStorage map, int x, int y, int z) { x *= this.ChunkSize; y *= this.ChunkSize; z *= this.ChunkSize; if (!EnableBigTrees) { PopulationTools.MakeSmallTrees(map, x, y, z, this.ChunkSize, _rnd, 30); } else { PopulationTools.MakeTrees(map, x, y, z, this.ChunkSize, _rnd); } PopulationTools.MakeCaves(map, x, y, z, this.ChunkSize, _rnd, this.EnableCaves, gravellength, goldorelength, ironorelength, coalorelength, dirtlength, silverlength); }
public void BlockChange(IMapStorage map, int x, int y, int z) { this.map = map; if (IsValidDualPos(x, y, z - 1) && (IsSlideDown(x, y, z, data.BlockIdSand) || IsSlideDown(x, y, z, data.BlockIdGravel))) { BlockMoveDown(x, y, z - 1, 0); BlockChange(map, x, y, z - 1); } else if (IsValidDualPos(x, y, z) && (IsDestroyOfBase(x, y, z, data.BlockIdSand) || IsDestroyOfBase(x, y, z, data.BlockIdGravel))) { BlockMoveDown(x, y, z, GetDepth(x, y, z)); BlockChange(map, x, y, z + 1); } }
public void ZipStoreSolarSystem() { IStellarMap map = SolarSystem.CreateSolSystem(); IMapStorage store = MapStorageFactory.GetStorage(MapStorageFactory.ZipStorage); string filename = Path.Combine(TestingUtilities.Config["DataPath"], "SolarSystem.zip"); if (File.Exists(filename)) { File.Delete(filename); } using StreamWriter writer = new StreamWriter(filename); store.Store(map, writer); }
public static IMapStorage GetStorage(string type) { IMapStorage storage = null; switch (type) { case JsonStorage: storage = new JSonMapStorage(); break; case ZipStorage: storage = new ZipMapStorage(); break; } return(storage); }
/// <summary> /// Creates a tree of type #2 at the given location. /// </summary> /// <param name="map"></param> /// <param name="x"></param> /// <param name="y"></param> /// <param name="z"></param> /// <param name="rnd"></param> public static void MakeTreeType2(IMapStorage map, int x, int y, int z, Random rnd) { int treeHeight = rnd.Next(4, 6); int xx = 0; int yy = 0; int dir = 0; float chanceToAppleTree = 0.1f; for (int i = 0; i < treeHeight; i++) { SetBlock(map, x, y, z + i, WorldGeneratorTools.TileIdTreeTrunk); if (i == treeHeight - 1) { for (int j = 1; j < 9; j++) { dir += 45; for (int k = 1; k < 2; k++) { int length = dir % 90 == 0 ? k : (int)(k / 2); xx = length * (int)Math.Round(Math.Cos(dir * Math.PI / 180)); yy = length * (int)Math.Round(Math.Sin(dir * Math.PI / 180)); SetBlock(map, x + xx, y + yy, z + i, WorldGeneratorTools.TileIdTreeTrunk); if (chanceToAppleTree < rnd.NextDouble()) { SetBlockIfEmpty(map, x + xx, y + yy, z + i + 1, WorldGeneratorTools.TileIdLeaves); SetBlockIfEmpty(map, x + xx + 1, y + yy, z + i, WorldGeneratorTools.TileIdLeaves); SetBlockIfEmpty(map, x + xx - 1, y + yy, z + i, WorldGeneratorTools.TileIdLeaves); SetBlockIfEmpty(map, x + xx, y + yy + 1, z + i, WorldGeneratorTools.TileIdLeaves); SetBlockIfEmpty(map, x + xx, y + yy - 1, z + i, WorldGeneratorTools.TileIdLeaves); } else { float appleChance = 0.4f; int tile; tile = rnd.NextDouble() < appleChance ? WorldGeneratorTools.TileIdApples : WorldGeneratorTools.TileIdLeaves; SetBlockIfEmpty(map, x + xx, y + yy, z + i + 1, tile); tile = rnd.NextDouble() < appleChance ? WorldGeneratorTools.TileIdApples : WorldGeneratorTools.TileIdLeaves; SetBlockIfEmpty(map, x + xx + 1, y + yy, z + i, tile); tile = rnd.NextDouble() < appleChance ? WorldGeneratorTools.TileIdApples : WorldGeneratorTools.TileIdLeaves; SetBlockIfEmpty(map, x + xx - 1, y + yy, z + i, tile); tile = rnd.NextDouble() < appleChance ? WorldGeneratorTools.TileIdApples : WorldGeneratorTools.TileIdLeaves; SetBlockIfEmpty(map, x + xx, y + yy + 1, z + i, tile); tile = rnd.NextDouble() < appleChance ? WorldGeneratorTools.TileIdApples : WorldGeneratorTools.TileIdLeaves; SetBlockIfEmpty(map, x + xx, y + yy - 1, z + i, tile); } } } } } }
void BlockChangeFlood(IMapStorage map, int x, int y, int z) { //water here if (MapUtil.IsValidPos(map, x, y, z) && IsWater(map.GetBlock(x, y, z))) { Flood(new Vector3(x, y, z)); } //water around foreach (var vv in BlocksAroundAll(new Vector3(x, y, z))) { if (MapUtil.IsValidPos(map, (int)vv.X, (int)vv.Y, (int)vv.Z) && IsWater(map.GetBlock((int)vv.X, (int)vv.Y, (int)vv.Z))) { Flood(vv); } } }
public static void StoreSolarSystem() { IStellarMap map = new BaseStellarMap("SolarSystem"); PhysicalSolarSystemCreator.CreateSolarSystem(map); IMapStorage store = MapStorageFactory.GetStorage(MapStorageFactory.JsonStorage); string filename = Path.Combine(dataDir, "SolarSystem.json"); if (File.Exists(filename)) { File.Delete(filename); } using StreamWriter writer = new StreamWriter(filename); store.Store(map, writer); }
public void PopulateChunk(IMapStorage map, int x, int y, int z) { x *= this.ChunkSize; y *= this.ChunkSize; z *= this.ChunkSize; //forests //if (Math.Abs(treenoise.GetValue(x, 0, y)) >= 0.9) double count = treenoise.GetValue(x, 0, y) * 1000; { count = System.Math.Min(count, 300); PopulationTools.MakeSmallTrees(map, x, y, z, this.ChunkSize, _rnd, (int)count); } //random trees PopulationTools.MakeSmallTrees(map, x, y, z, this.ChunkSize, _rnd, treeCount + 10 - (10 - treeCount / 10)); PopulationTools.MakeCaves(map, x, y, z, this.ChunkSize, _rnd, this.EnableCaves, gravellength, goldorelength, ironorelength, coalorelength, dirtlength, silverlength); }
public void JsonRetrieveSolarSystem() { string filename = Path.Combine(TestingUtilities.Config["DataPath"], "SolarSystem.json"); if (!File.Exists(filename)) { JsonStoreSolarSystem(); } IStellarMap map; IMapStorage store = MapStorageFactory.GetStorage(MapStorageFactory.JsonStorage); using StreamReader reader = new StreamReader(filename); map = store.Retreive <BaseStellarMap>(reader); IStellarMap generatedMap = SolarSystem.CreateSolSystem(); Assert.IsTrue(BaseStellarMapEqualityComparer.Comparer.Equals(map as BaseStellarMap, generatedMap as BaseStellarMap)); }
public static void JsonGenerateLocalSector() { ProgressionMap localsector = new ProgressionMap("Local Sector"); LocalSectorMap create = new LocalSectorMap(localsector); create.CreateLocalSector(); IMapStorage store = MapStorageFactory.GetStorage(MapStorageFactory.JsonStorage); string filename = Path.Combine(dataDir, "LocalSector.json"); if (File.Exists(filename)) { File.Delete(filename); } using StreamWriter writer = new StreamWriter(filename); store.Store(localsector, writer); }
public void ZipStoreLocalSector() { ProgressionMap localsector = new ProgressionMap("Local Sector"); LocalSectorMap create = new LocalSectorMap(localsector); create.CreateLocalSector(); IMapStorage store = MapStorageFactory.GetStorage(MapStorageFactory.ZipStorage); string filename = Path.Combine(TestingUtilities.Config["DataPath"], "LocalSector.zip"); if (File.Exists(filename)) { File.Delete(filename); } using StreamWriter writer = new StreamWriter(filename); store.Store(localsector, writer); }
public static int DistanceToBlock(IMapStorage map, Vector3f coord, Vector3f vec, int blockType, bool invert) { coord += .5f; int iterations = 0; while (MapUtil.IsValidPos(map, (int)coord.x, (int)coord.y, (int)coord.h)) { byte blockAtPos = (byte)map.GetBlock((int)coord.x, (int)coord.y, (int)coord.h); if ((blockAtPos == (byte)blockType && !invert) || (blockAtPos != (byte)blockType && invert)) { break; } else { coord += vec; iterations++; } } return(iterations); }
public void BlockChange(IMapStorage map, int x, int y, int z) { this.flooded = new Dictionary <Vector3, Vector3>(); this.map = map; //sponge just built. if (MapUtil.IsValidPos(map, x, y, z) && map.GetBlock(x, y, z) == data.BlockIdSponge) { for (int xx = x - spongerange; xx <= x + spongerange; xx++) { for (int yy = y - spongerange; yy <= y + spongerange; yy++) { for (int zz = z - spongerange; zz <= z + spongerange; zz++) { if (MapUtil.IsValidPos(map, xx, yy, zz) && IsWater(map.GetBlock(xx, yy, zz))) { tosetempty.Add(new Vector3(xx, yy, zz)); } } } } } //maybe sponge destroyed. todo faster test. for (int xx = x - spongerange; xx <= x + spongerange; xx++) { for (int yy = y - spongerange; yy <= y + spongerange; yy++) { for (int zz = z - spongerange; zz <= z + spongerange; zz++) { if (MapUtil.IsValidPos(map, xx, yy, zz) && map.GetBlock(xx, yy, zz) == SpecialBlockId.Empty) { BlockChangeFlood(map, xx, yy, zz); } } } } BlockChangeFlood(map, x, y, z); var v = new Vector3(x, y, z); tosetwater.Sort((a, b) => (v - a.pos).Length.CompareTo((v - b.pos).Length)); }
public void BlockChange(IMapStorage map, int x, int y, int z) { this.flooded = new Dictionary<Vector3, Vector3>(); this.map = map; //sponge just built. if (MapUtil.IsValidPos(map, x, y, z) && map.GetBlock(x, y, z) == data.BlockIdSponge) { for (int xx = x - spongerange; xx <= x + spongerange; xx++) { for (int yy = y - spongerange; yy <= y + spongerange; yy++) { for (int zz = z - spongerange; zz <= z + spongerange; zz++) { if (MapUtil.IsValidPos(map, xx, yy, zz) && data.IsWater[map.GetBlock(xx, yy, zz)]) { tosetempty.Add(new Vector3(xx, yy, zz)); } } } } } //maybe sponge destroyed. todo faster test. for (int xx = x - spongerange; xx <= x + spongerange; xx++) { for (int yy = y - spongerange; yy <= y + spongerange; yy++) { for (int zz = z - spongerange; zz <= z + spongerange; zz++) { if (MapUtil.IsValidPos(map, xx, yy, zz) && map.GetBlock(xx, yy, zz) == 0) { BlockChangeFlood(map, xx, yy, zz); } } } } BlockChangeFlood(map, x, y, z); var v = new Vector3(x, y, z); tosetwater.Sort((a, b) => (v - a).Length.CompareTo((v - b).Length)); }
/// <summary> /// Creates some trees all over the chunk. /// </summary> /// <param name="map"></param> /// <param name="x"></param> /// <param name="y"></param> /// <param name="z"></param> /// <param name="chunksize"></param> /// <param name="rnd"></param> public static void MakeTrees(IMapStorage map, int x, int y, int z, int chunksize, Random rnd) { if (z != 0) { return; } //if (rnd.Next(100) > 30) { return; } var foresterArgs = new fCraft.Forester.ForesterArgs(); if (rnd.Next(100) < 15) { foresterArgs.SHAPE = fCraft.Forester.TreeShape.Procedural; } else { foresterArgs.SHAPE = (fCraft.Forester.TreeShape)rnd.Next(9); foresterArgs.HEIGHT = rnd.Next(5, 10); foresterArgs.TREECOUNT = 3; } fCraft.Forester forester = new fCraft.Forester(foresterArgs); foresterArgs.inMap = map; foresterArgs.outMap = map; forester.Generate(x, y, z, chunksize); }
public static int DistanceToBlock(IMapStorage map, Vector3f coord, Vector3f vec, int blockType, bool invert) { coord += .5f; int iterations = 0; while (MapUtil.IsValidPos(map, (int)coord.x, (int)coord.y, (int)coord.h)) { byte blockAtPos = (byte)map.GetBlock((int)coord.x, (int)coord.y, (int)coord.h); if ((blockAtPos == (byte)blockType && !invert) || (blockAtPos != (byte)blockType && invert)) { break; } else { coord += vec; iterations++; } } return iterations; }
public static bool IsValidPos(IMapStorage map, int x, int y, int z) { if (x < 0 || y < 0 || z < 0) { return false; } if (x >= map.MapSizeX || y >= map.MapSizeY || z >= map.MapSizeZ) { return false; } return true; }
public static int DistanceToBlock(IMapStorage map, Vector3f coord, Vector3f vec, int blockType) { return DistanceToBlock(map, coord, vec, blockType, false); }
public void PopulateChunk(IMapStorage map, int x, int y, int z, int chunksize) { }
public byte[] SaveMap(IMapStorage map) { return GzipCompression.Compress(SaveXml(map)); }
public void SaveMap(IMapStorage map, string filename) { //using (FileStream s = File.OpenWrite("default.minesave")) /* MemoryStream s = new MemoryStream(); { BinaryWriter bw = new BinaryWriter(s); bw.Write((int)0);//format version bw.Write((int)MapSizeZ); bw.Write((int)MapSizeX); bw.Write((int)MapSizeY); for (int z = 0; z < MapSizeZ; z++) { for (int y = 0; y < MapSizeY; y++) { for (int x = 0; x < MapSizeX; x++) { bw.Write((byte)map[x, y, z]); } } } } File.WriteAllBytes("default.minesave", GzipCompression.Compress(s.ToArray())); */ File.WriteAllBytes(filename, GzipCompression.Compress(SaveXml(map))); Console.WriteLine("Game saved successfully."); }
public void PopulateChunk(IMapStorage map, int x, int y, int z, int chunksize) { x *= chunksize; y *= chunksize; z *= chunksize; //if (rnd.NextDouble() >= 0.6) { //return; } //find cave start double curx = x; double cury = y; double curz = z; for (int i = 0; i < 10; i++) { curx = x + rnd.Next(chunksize); cury = y + rnd.Next(chunksize); curz = z + rnd.Next(chunksize); if (map.GetBlock((int)curx, (int)cury, (int)curz) == TileIdStone) { goto ok; } } return; ok: int blocktype = TileIdEmpty; int length = 200; if (rnd.NextDouble() < 0.5) { int oretype = rnd.Next(3); if (oretype == 0) { length = goldorelength; } if (oretype == 1) { length = ironorelength; } if (oretype == 2) { length = coalorelength; } length = rnd.Next(length); blocktype = TileIdGoldOre + oretype; } //map.SetBlock(x, y, z, TileIdLava); int dirx = rnd.NextDouble() < 0.5 ? -1 : 1; int dirz = rnd.NextDouble() < 0.5 ? -1 : 1; double curspeedx = rnd.NextDouble() * dirx; double curspeedy = rnd.NextDouble(); double curspeedz = rnd.NextDouble() * 0.5 * dirz; for (int i = 0; i < length; i++) { if (rnd.NextDouble() < 0.05) { curspeedx = rnd.NextDouble() * dirx; } if (rnd.NextDouble() < 0.05) { curspeedy = rnd.NextDouble(); } if (rnd.NextDouble() < 0.02) { curspeedz = rnd.NextDouble() * 0.5 * dirz; } curx += curspeedx; cury += curspeedy; curz += curspeedz; if (!MapUtil.IsValidPos(map, (int)curx, (int)cury, (int)curz)) { continue; } for (int ii = 0; ii < 3; ii++) { int sizex = rnd.Next(3, 5); int sizey = rnd.Next(3, 5); int sizez = rnd.Next(3, 5); int dx = rnd.Next(-sizex / 1, sizex / 1); int dy = rnd.Next(-sizey / 1, sizey / 1); int dz = rnd.Next(-sizez / 2, sizez / 2); int[] allowin = blocktype == TileIdEmpty ? new int[] { TileIdStone, TileIdDirt, TileIdGrass, TileIdGoldOre, TileIdIronOre, TileIdCoalOre } : new int[] { TileIdStone }; double density = blocktype == TileIdEmpty ? 1 : rnd.NextDouble() * 0.4; MakeCuboid(map, (int)curx - sizex / 2 + dx, (int)cury - sizey / 2 + dy, (int)curz - sizez / 2 + dz, sizex, sizey, sizez, blocktype, allowin, density); } } }
public static bool IsValidChunkPos(IMapStorage map, int cx, int cy, int cz, int chunksize) { return cx >= 0 && cy >= 0 && cz >= 0 && cx < map.MapSizeX / chunksize && cy < map.MapSizeY / chunksize && cz < map.MapSizeZ / chunksize; }
/// <summary> /// Creates caves all over the chunk. /// </summary> /// <param name="map"></param> /// <param name="x"></param> /// <param name="y"></param> /// <param name="z"></param> /// <param name="chunksize"></param> /// <param name="rnd"></param> /// <param name="enableCaves"></param> /// <param name="gravelLength"></param> /// <param name="goldOreLength"></param> /// <param name="ironOreLength"></param> /// <param name="coalOreLength"></param> /// <param name="dirtOreLength"></param> public static void MakeCaves(IMapStorage map, int x, int y, int z, int chunksize, Random rnd, bool enableCaves, int gravelLength, int goldOreLength, int ironOreLength, int coalOreLength, int dirtOreLength, int silverOreLength) { //if (rnd.NextDouble() >= 0.6) { //return; } //find cave start double curx = x; double cury = y; double curz = z; for (int i = 0; i < 2; i++) { curx = x + rnd.Next(chunksize); cury = y + rnd.Next(chunksize); curz = z + rnd.Next(chunksize); if (map.GetBlock((int)curx, (int)cury, (int)curz) == WorldGeneratorTools.TileIdStone) { goto ok; } } return; ok: int blocktype = WorldGeneratorTools.TileIdEmpty; int length = 200; if (rnd.NextDouble() < 0.85) { int oretype = rnd.Next(6); if (oretype == 0) { length = gravelLength; } if (oretype == 1) { length = goldOreLength; } if (oretype == 2) { length = ironOreLength; } if (oretype == 3) { length = coalOreLength; } if (oretype == 4) { length = dirtOreLength; } if (oretype == 5) { length = silverOreLength; } length = rnd.Next(length); blocktype = oretype < 4 ? WorldGeneratorTools.TileIdGravel + oretype : (oretype > 4 ? WorldGeneratorTools.TileIdGravel + oretype + 115 : WorldGeneratorTools.TileIdDirt); } if (blocktype == WorldGeneratorTools.TileIdEmpty && (!enableCaves)) { return; } //map.SetBlock(x, y, z, WorldGeneratorTools.TileIdLava); int dirx = rnd.NextDouble() < 0.5 ? -1 : 1; int dirz = rnd.NextDouble() < 0.5 ? -1 : 1; double curspeedx = rnd.NextDouble() * dirx; double curspeedy = rnd.NextDouble(); double curspeedz = rnd.NextDouble() * 0.5 * dirz; for (int i = 0; i < length; i++) { if (rnd.NextDouble() < 0.06) { curspeedx = rnd.NextDouble() * dirx; } if (rnd.NextDouble() < 0.06) { curspeedy = rnd.NextDouble() * dirx; } if (rnd.NextDouble() < 0.02) { curspeedz = rnd.NextDouble() * 0.5 * dirz; } curx += curspeedx; cury += curspeedy; curz += curspeedz; if (!MapUtil.IsValidPos(map, (int)curx, (int)cury, (int)curz)) { continue; } for (int ii = 0; ii < 3; ii++) { int sizex = rnd.Next(3, 6); int sizey = rnd.Next(3, 6); int sizez = rnd.Next(2, 3); int dx = rnd.Next(-sizex / 2, sizex / 2); int dy = rnd.Next(-sizey / 2, sizey / 2); int dz = rnd.Next(-sizez / 1, sizez / 1); int[] allowin = new int[] { WorldGeneratorTools.TileIdStone }; double density = blocktype == WorldGeneratorTools.TileIdEmpty ? 1 : rnd.NextDouble() * 0.90; if (blocktype == WorldGeneratorTools.TileIdEmpty) { allowin = new int[] { WorldGeneratorTools.TileIdStone, WorldGeneratorTools.TileIdDirt, WorldGeneratorTools.TileIdGrass, WorldGeneratorTools.TileIdGoldOre, WorldGeneratorTools.TileIdIronOre, WorldGeneratorTools.TileIdCoalOre, WorldGeneratorTools.TileIdSilverOre }; } if (blocktype == WorldGeneratorTools.TileIdGravel) { density = 1; allowin = new int[] { WorldGeneratorTools.TileIdDirt, WorldGeneratorTools.TileIdStone, WorldGeneratorTools.TileIdSand, WorldGeneratorTools.TileIdGoldOre, WorldGeneratorTools.TileIdIronOre, WorldGeneratorTools.TileIdCoalOre, WorldGeneratorTools.TileIdSilverOre }; } MakeCuboid(map, (int)curx - sizex / 2 + dx, (int)cury - sizey / 2 + dy, (int)curz - sizez / 2 + dz, sizex, sizey, sizez, blocktype, allowin, density, rnd); } } }
public static void MakeSmallTrees(IMapStorage map, int cx, int cy, int cz, int chunksize, Random rnd, int count) { int chooseTreeType; for (int i = 0; i < count; i++) { int x = cx + rnd.Next(chunksize); int y = cy + rnd.Next(chunksize); int z = cz + rnd.Next(chunksize); if (!MapUtil.IsValidPos(map, x, y, z) || map.GetBlock(x, y, z) != WorldGeneratorTools.TileIdGrass) { continue; } chooseTreeType = rnd.Next(0, 3); switch (chooseTreeType) { case 0: MakeTreeType1(map, x, y, z, rnd); break; case 1: MakeTreeType2(map, x, y, z, rnd); break; case 2: MakeTreeType3(map, x, y, z, rnd); break; }; } }
public void LoadMapArray(IMapStorage map, Stream s) { BinaryReader br = new BinaryReader(s); map.UseMap(new byte[map.MapSizeX, map.MapSizeY, map.MapSizeZ]); for (int z = 0; z < map.MapSizeZ; z++) { for (int y = 0; y < map.MapSizeY; y++) { for (int x = 0; x < map.MapSizeX; x++) { map.SetBlock(x, y, z, br.ReadByte()); } } } //.gui.DrawMap(); Console.WriteLine("Game loaded successfully."); }
public void LoadMapMinecraft(IMapStorage map, string filename) { byte[] serialized = GzipCompression.Decompress(new FileInfo(getfile.GetFile(filename))); fCraft.MapLoaderDAT maploaderdat = new fCraft.MapLoaderDAT(); fCraft.IFMap mymap = new MyFCraftMap() { map = map }; maploaderdat.log = new fCraft.FLogDummy(); maploaderdat.Load(filename, mymap); }
public static int blockheight(IMapStorage map, int tileidempty, int x, int y) { for (int z = map.MapSizeZ - 1; z >= 0; z--) { if (map.GetBlock(x, y, z) != tileidempty) { return z + 1; } } return map.MapSizeZ / 2; }
byte[] SaveXml(IMapStorage map) { StringBuilder b = new StringBuilder(); b.AppendLine(@"<?xml version=""1.0"" encoding=""UTF-8""?>"); b.AppendLine("<ManicDiggerSave>"); b.AppendLine(XmlTool.X("FormatVersion", "1")); b.AppendLine("<MapSize>"); b.AppendLine(XmlTool.X("X", "" + map.MapSizeX)); b.AppendLine(XmlTool.X("Y", "" + map.MapSizeY)); b.AppendLine(XmlTool.X("Z", "" + map.MapSizeZ)); b.AppendLine("</MapSize>"); MemoryStream mapdata = new MemoryStream(); BinaryWriter bw = new BinaryWriter(mapdata); for (int z = 0; z < map.MapSizeZ; z++) { for (int y = 0; y < map.MapSizeY; y++) { for (int x = 0; x < map.MapSizeX; x++) { bw.Write((byte)map.GetBlock(x, y, z)); } } } b.AppendLine(XmlTool.X("MapData", Convert.ToBase64String(mapdata.ToArray()))); //b.AppendLine(X("DefaultSpawn", )); b.AppendLine("</ManicDiggerSave>"); /* <ManicDiggerSave> <SaveFormat>1</SaveFormat> <MapSize> <X>256</X> <Y>256</Y> <Z>64</Z> </MapSize> <MapData>BASE64</MapData> <Players> <Player> <Id>0</Id> <SpawnPoint> <X>5</X> <Y>5</Y> <Z>40</Z> </SpawnPoint> </Player> </Players> </ManicDiggerSave> */ return Encoding.UTF8.GetBytes(b.ToString()); }
/// <summary> /// Populates the chunk at the given position. /// </summary> /// <param name="map">The <see cref="IMapStorage"/> instance containing the map.</param> /// <param name="x">The x-position of the chunk to populate.</param> /// <param name="y">The y-position of the chunk to populate.</param> /// <param name="z">The z-position of the chunk to populate.</param> public override void PopulateChunk(IMapStorage map, int x, int y, int z) { this.UpdateValues(); _default.PopulateChunk(map, x, y, z); }
public static int SearchColumn(IMapStorage map, int x, int y, int id) { return SearchColumn(map, x, y, id, map.MapSizeZ - 1); }
void MakeCuboid(IMapStorage map, int x, int y, int z, int sizex, int sizey, int sizez, int blocktype, int[] allowin, double chance) { for (int xx = 0; xx < sizex; xx++) { for (int yy = 0; yy < sizey; yy++) { for (int zz = 0; zz < sizez; zz++) { if (MapUtil.IsValidPos(map, x + xx, y + yy, z + zz)) { int t = map.GetBlock(x + xx, y + yy, z + zz); if (allowin == null) { goto ok; } foreach (int tt in allowin) { if (tt == t) { goto ok; } } continue; ok: if (rnd.NextDouble() < chance) { map.SetBlock(x + xx, y + yy, z + zz, blocktype); } } } } } }
public static int SearchColumn(IMapStorage map, int x, int y, int id, int startH) { for (int h = startH; h > 0; h--) { if (map.GetBlock(x, y, h) == (byte)id) { return h; } } return -1; // -1 means 'not found' }
public void LoadMap(IMapStorage map, byte[] data) { using (Stream s = new MemoryStream(GzipCompression.Decompress(data))) { StreamReader sr = new StreamReader(s); XmlDocument d = new XmlDocument(); d.Load(sr); int format = int.Parse(XmlTool.XmlVal(d, "/ManicDiggerSave/FormatVersion")); if (format != 1) { throw new Exception("Invalid map format"); } map.MapSizeX = int.Parse(XmlTool.XmlVal(d, "/ManicDiggerSave/MapSize/X")); map.MapSizeY = int.Parse(XmlTool.XmlVal(d, "/ManicDiggerSave/MapSize/Y")); map.MapSizeZ = int.Parse(XmlTool.XmlVal(d, "/ManicDiggerSave/MapSize/Z")); byte[] mapdata = Convert.FromBase64String(XmlTool.XmlVal(d, "/ManicDiggerSave/MapData")); LoadMapArray(map, new MemoryStream(mapdata)); } }
public StateMachineBuilder UsingMapStorage(IMapStorage mapStorage) { StorageHelper.Storage = mapStorage; return(this); }
public void LoadMap(IMapStorage map, string filename) { if ((!File.Exists(filename)) && File.Exists(filename + MinecraftMapSaveExtension)) { filename += MinecraftMapSaveExtension; } if ((!File.Exists(filename)) && File.Exists(filename + XmlSaveExtension)) { filename += XmlSaveExtension; } if (!File.Exists(filename)) { Console.WriteLine(filename + " not found."); } if (filename.EndsWith(MinecraftMapSaveExtension)) { //minecraft map LoadMapMinecraft(map, filename); return; } LoadMap(map, File.ReadAllBytes(filename)); }