private static JsonModel DuplicateOverlap(JsonModel jsonModel)
{
var elements = jsonModel.elements;
var obj = new object();
Current.WriteLine(Environment.NewLine + "- Compressing Model:");
Current.SetProgressBar();
int current = 0;
int total = elements.Length;
#region Delect Overlap
for (int i = 0; i < total; i++)
{
elements[i] = jsonModel.GetFaceElement(elements[i]);
lock (obj)
{
current++;
Current.DrawProgressBar(current * 100 / total);
Current.Write(" " + current + " elements have been disposed of.(total : " + total + " )");
}
}
#endregion
Current.Write("");
return(jsonModel);
}
private static void Schematic2BlockCollection(string file)
{
#region Initialization
var nbt = new NbtFile();
nbt.LoadFromFile(file);
var root = nbt.RootTag; //Read File
bcl = new BlockCollection();
bcl.SetWidth(root.Get <NbtShort>("Width").ShortValue); //Get Width
bcl.SetHeight(root.Get <NbtShort>("Height").ShortValue);
bcl.SetLength(root.Get <NbtShort>("Length").ShortValue);
bcl.Comments = "Created by S2J"; //Set Comment
var blocks = root.Get <NbtByteArray>("Blocks").ByteArrayValue; //Initialize Blocks
var datas = root.Get <NbtByteArray>("Data").ByteArrayValue; //Initialize Datas
bcl.level = new BlockCollection.Block[bcl.GetWidth(), bcl.GetHeight(), bcl.GetLength()];
#endregion
var obj = new object();
Current.WriteLine(Environment.NewLine + "- Reading Schematic:");
Current.SetProgressBar();
int current = 0;
int total = bcl.GetWidth();
#region Read Schematic
Parallel.For(0, bcl.GetWidth(), x =>
{
for (int y = 0; y < bcl.GetHeight(); y++)
{
for (int z = 0; z < bcl.GetLength(); z++)
{
var block = new BlockCollection.Block();
var index = y * bcl.GetWidth() * bcl.GetLength() + z * bcl.GetWidth() + x;
if (blocks[index] != 0)
{
var blockInfo = res.GetBlockInfo(blocks[index].ToString(), datas[index].ToString(), version);
if (blockInfo != null)
{
block.SetCoordinate(x, y, z);
block.SetInfo(blockInfo);
bcl.blocks.Add(block);
bcl.level[x, y, z] = block;
}
}
}
}
lock (obj) //Update Progress
{
current++;
Current.DrawProgressBar(current * 100 / total);
}
});
#endregion
}
private static JsonModel JsonModel(string directoryPath)
{
var obj = new object();
Current.WriteLine(Environment.NewLine + "- Generating Model:");
Current.SetProgressBar();
int current = 0;
int total = bcl.blocks.Count;
var jsonModel = new JsonModel();
jsonModel.__comment = bcl.Comments;
var elements = new List <JsonModel.Element>();
jsonModel.textures = new Dictionary <string, string>();
foreach (var block in bcl.blocks)
{
if (block.GetBlockInfo().Id == "$empty")
{
var e = new JsonModel.Element()
{
faces = new Dictionary <string, JsonModel.Element.Face>()
{
{ "North", null },
{ "East", null },
{ "South", null },
{ "West", null },
{ "Up", null },
{ "Down", null }
},
from = new float[] { (float)block.GetCoordinate().X, (float)block.GetCoordinate().Y, (float)block.GetCoordinate().Z },
to = new float[] { (float)block.GetCoordinate().X + 1, (float)block.GetCoordinate().Y + 1, (float)block.GetCoordinate().Z + 1 }
};
elements.Add(e);
}
else
{
var l = block.GetSimpleElements(directoryPath, bcl, res);
foreach (var e in l)
{
var index = block.GetBlockInfo().Id + "_" + block.GetBlockInfo().Data;
elements.Add(e.ToJsonElment(index));
if (!jsonModel.textures.Keys.Contains(index))
{
jsonModel.textures.Add(index, PathConverter(e.texture.Path));
}
}
}
current++;
Current.DrawProgressBar(current * 100 / total);
}
jsonModel.elements = elements.ToArray();
return(jsonModel);
}
private static JsonModel ScaleModel(JsonModel jsonModel)
{
var elements = jsonModel.elements;
if (!unlimit)
{
var max = elements.Select(element => element.to.Max()).Concat(new float[] { 0 }).Max();
var changedAmount = (max - 32.0f) / max;
if (changedAmount > 0)
{
var obj = new Object();
Current.WriteLine("");
Current.WriteLine("- Scaling:");
Current.SetProgressBar();
int current = 0;
int total = elements.Length;
Parallel.ForEach(elements, element =>
{
for (var i = 0; i < 3; i++)
{
element.from[i] = Math.Max(element.from[i] - changedAmount * element.from[i], 0);
if (element.from[i] > 32)
{
element.from[i] = 32;
}
}
for (var i = 0; i < 3; i++)
{
element.to[i] = Math.Max(element.to[i] - changedAmount * element.to[i], 0);
if (element.to[i] > 32)
{
element.to[i] = 32;
}
}
lock (obj) //Update Progress
{
current++;
Current.DrawProgressBar(current * 100 / total);
}
});
}
}
return(jsonModel);
}
public void KeepSurface()
{
Current.WriteLine(Environment.NewLine + "- Delect Unseeable:");
Current.SetProgressBar();
faces.RemoveAll(face => face == null);
var _element = elements.ToList();
var _delect = new HashSet <Face>();
var _taggedFaces = new HashSet <int>();
var total = faces.Count;
for (int i = 0; i < faces.Count; i++)
{
//Update Progress
Current.DrawProgressBar((i + 1) * 100 / total);
if (_taggedFaces.Contains(i))
{
continue;
}
var connectFaces = Adjacency(i);
var maxH = connectFaces.Max(index => faces[index].from[1]);
var isIn = connectFaces.AsEnumerable().Where(index => faces[index].from[1] == maxH).Any(index => faces[index].facing == "Down");
foreach (var faceI in connectFaces)
{
if (isIn)
{
_delect.Add(faces[faceI]);
}
_taggedFaces.Add(faceI);
}
}
foreach (var face in _delect)
{
face.parentElement.faces.Remove(face.facing);
faces.Remove(face);
}
elements = _element.ToArray();
}
private static BlockCollection FillFlow(BlockCollection blocks, Vector3 origin, SimpleBlockInfo fill_block, bool reverse = false)
{
Current.WriteLine(Environment.NewLine + "- Filling Flow...");
var m = blocks.level[blocks.GetWidth() / 2, blocks.GetHeight() / 2, blocks.GetLength() / 2];
var close = new List <int[]>();
var newb = res.GetBlockInfo(fill_block.Id, fill_block.Data, version);
if (newb == null)
{
newb = new BlockInfo(); newb.Id = "$empty";
} //Get Fill Material
if (origin.X < 0 || origin.X >= blocks.GetWidth() || origin.Y < 0 || origin.Y >= blocks.GetHeight() || origin.Z < 0 || origin.Z >= blocks.GetLength())
{
origin.X = blocks.GetWidth() / 2; origin.Y = blocks.GetHeight() / 2; origin.Z = blocks.GetLength() / 2;
}
close.Add(new int[] { (int)origin.X, (int)origin.Y, (int)origin.Z }); //Set Finding Origin
var flowed = new bool[blocks.GetWidth(), blocks.GetHeight(), blocks.GetLength()]; //Tag: flowed
var _blocks = new List <BlockCollection.Block>();
foreach (var b in blocks.blocks)
{
_blocks.Add(b);
}
while (close.Count() > 0) //Flowing
{
var c = new { x = close[close.Count - 1][0], y = close[close.Count - 1][1], z = close[close.Count - 1][2] };
close.RemoveAt(close.Count - 1);
if (blocks.level[c.x, c.y, c.z] == m)
{
var block = new BlockCollection.Block();
block.SetCoordinate(c.x, c.y, c.z);
block.SetInfo(newb);
blocks.blocks.Add(block);
blocks.level[c.x, c.y, c.z] = block;
flowed[c.x, c.y, c.z] = true;
if (c.x - 1 >= 0)
{
close.Add(new int[] { c.x - 1, c.y, c.z });
}
if (c.x + 1 < blocks.GetWidth())
{
close.Add(new int[] { c.x + 1, c.y, c.z });
}
if (c.y - 1 >= 0)
{
close.Add(new int[] { c.x, c.y - 1, c.z });
}
if (c.y + 1 < blocks.GetHeight())
{
close.Add(new int[] { c.x, c.y + 1, c.z });
}
if (c.z - 1 >= 0)
{
close.Add(new int[] { c.x, c.y, c.z - 1 });
}
if (c.z + 1 < blocks.GetLength())
{
close.Add(new int[] { c.x, c.y, c.z + 1 });
}
}
}
if (reverse)
{
Current.WriteLine(Environment.NewLine + "- Reversing Filling Flow...");
Current.SetProgressBar();
int current = 0;
int total = bcl.GetWidth() * bcl.GetHeight() * bcl.GetLength(); //Fill Empty Regions
for (int x = 0; x < blocks.GetWidth(); x++)
{
for (int y = 0; y < blocks.GetHeight(); y++)
{
for (int z = 0; z < blocks.GetLength(); z++)
{
if (!flowed[x, y, z] && blocks.level[x, y, z] == null)
{
var block = new BlockCollection.Block();
block.SetCoordinate(x, y, z);
block.SetInfo(newb);
_blocks.Add(block);
blocks.level[x, y, z] = block;
}
//Update Progress
current++;
Current.DrawProgressBar(current * 100 / total);
Current.Write(" " + current + " blocks have been scanned.(total : " + total + " )");
}
}
}
blocks.blocks = _blocks;
}
return(blocks);
}
private static BlockCollection Hollow(BlockCollection blocks)
{
Current.WriteLine(Environment.NewLine + "- Filling Hollow:");
Current.SetProgressBar();
int current = 0;
int total = bcl.GetWidth() * bcl.GetHeight() * bcl.GetLength();
var close = new int[blocks.GetWidth(), blocks.GetHeight(), blocks.GetLength()]; //Get Inside Blocks
for (int x = 0; x < blocks.GetWidth(); x++)
{
for (int y = 0; y < blocks.GetHeight(); y++)
{
for (int z = 0; z < blocks.GetLength(); z++)
{
var curb = blocks.level[x, y, z];
if (curb != null)
{
for (int dx = -1; dx <= 1; dx++)
{
for (int dy = -1; dy <= 1; dy++)
{
for (int dz = -1; dz <= 1; dz++)
{
if (dx != 0 || dy != 0 || dz != 0)
{
int cx = x + dx; int cy = y + dy; int cz = z + dz;
if (cx > 0 && cx < (blocks.GetWidth() - 1) && cy > 0 && cy < (blocks.GetHeight() - 1) && cz > 0 && cz < (blocks.GetLength() - 1))
{
close[cx, cy, cz]++;
}
}
}
}
}
}
//Update Progress
current++;
Current.DrawProgressBar(current * 100 / total);
Current.Write(" " + current + " blocks have been scanned.(total : " + total + " )");
}
}
}
current = 0;
Current.WriteLine("");
for (int x = 1; x < blocks.GetWidth() - 1; x++) //Remove Inside Blocks
{
for (int y = 1; y < blocks.GetHeight() - 1; y++)
{
for (int z = 1; z < blocks.GetLength() - 1; z++)
{
if (close[x, y, z] >= 26)
{
var block = blocks.level[x, y, z];
if (block != null)
{
blocks.blocks.Remove(block);
blocks.level[x, y, z] = null;
}
}
//Update Progress
current++;
Current.DrawProgressBar(current * 100 / total);
Current.Write(" " + current + " blocks have been disposed of.(total : " + total + " )");
}
}
}
return(blocks);
}
private static void NBT2BlockCollection(string file)
{
#region Initialization
var nbt = new NbtFile();
nbt.LoadFromFile(file);
var root = nbt.RootTag; //Read File
bcl = new BlockCollection();
bcl.SetWidth(root.Get <NbtList>("size")[0].IntValue); //Get Width
bcl.SetHeight(root.Get <NbtList>("size")[1].IntValue);
bcl.SetLength(root.Get <NbtList>("size")[2].IntValue);
bcl.Comments = "Created by S2J"; //Set Comment
var p = root.Get <NbtList>("palette");
var palettes = new List <NbtCompound>();
foreach (NbtCompound _p in p)
{
palettes.Add(_p);
}
var blocks = root.Get <NbtList>("blocks");
bcl.level = new BlockCollection.Block[bcl.GetWidth(), bcl.GetHeight(), bcl.GetLength()];
#endregion
Current.WriteLine(Environment.NewLine + "- Reading NBT:");
Current.SetProgressBar();
int current = 0;
int total = bcl.GetWidth() * bcl.GetHeight() * bcl.GetLength();
#region Read NBT
foreach (NbtCompound b in blocks)
{
var index = b.Get <NbtInt>("state").IntValue;
var _p = b.Get <NbtList>("pos");
var pos = new Vector3()
{
X = _p[0].IntValue, Y = _p[1].IntValue, Z = _p[2].IntValue
};
var state = palettes[index];
if (state != null && state.Get <NbtString>("Name") != null)
{
var block = new BlockCollection.Block();
#region Id & Data
var id = state.Get <NbtString>("Name").StringValue;
var datas = new List <string>();
if (state.Get <NbtCompound>("Properties") != null)
{
foreach (var _s in state.Get <NbtCompound>("Properties"))
{
datas.Add(_s.Name + ":" + _s.StringValue);
}
}
var data = string.Join(",", datas.ToArray());
#endregion
//MessageBox.Show(id + " " + data);
if (id != "minecraft:air" && id != "minecraft:void_air" && id != "minecraft:cave_air")
{
var blockInfo = res.GetBlockInfo(id, data, version);
if (blockInfo != null)
{
block.SetCoordinate((int)pos.X, (int)pos.Y, (int)pos.Z);
block.SetInfo(blockInfo);
bcl.blocks.Add(block);
bcl.level[(int)pos.X, (int)pos.Y, (int)pos.Z] = block;
}
}
}
//Update Progress
current++;
Current.DrawProgressBar(current * 100 / total);
}
#endregion
}
