Data Archive Test 2 | C# Online Compiler

Data Archive Test 2 by RaisinBrain

using System;
using System.IO;
using System.IO.Compression;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Globalization;
using System.Reflection;
using Newtonsoft.Json;
					
public class Program
{
	static List<string> words = new List<string>() {
		"month", 		"freckle", "rock", "arrow",	
		"exclude", 		"sailor", "safari", "pastel",	
		"staircase", 	"distinct", "disappoint", "pollution",	
		"isolation", 	"card", "mathematics", "executive",	
		"lineage", 		"title", "licence", "torch",	
		"mastermind", 	"word", "priority", "feminine",	
		"aspect", 		"cart", "lounge", "obligation",	
		"father", 		"cutting", "painter", "swing",	
		"burial", 		"suitcase", "paralyzed", "convulsion",
		"asset", 		"lackey", "rough", "waiter",
		"handlebar", 	"mustache", "like", "maam", 
		"mum", 			"doctor", "magic", "box", 
		"toy", 			"shelf", "money", "leggings", 
		"hairband", 	"water", "bottle", "mouse",
		"pad", 			"planet", "glass", "tissue", 
		"paper", 		"wallet", "storage", "leaf", 
		"severance", 	"show", "television",
		"radio", 		"puppet", "giggle", "laugh", 
		"emote", 		"chair", "airplane", "heart", 
		"arrow", 		"swim", "rainbow", "cheese", 
		"pizza", 		"hamburger", "barn", "silo", 
		"ranch",		"computer", "station", "police", 
		"steal", 		"theft", "handler", "jar", 
		"cash", 		"coins", "cook", "chef", 
		"chief", 		"detective", "inspector", "fire", 
		"murder", 		"time", "clock", "tea", 
		"kettle", 		"baby", "parent", "child", 
		"birthday", 	"holiday", "celebrate", "cake", 
		"people", 		"family", "anniversary", "wedding", 
		"engagement", 	"shower", "bride", "groom",
		"maid", 		"honor", "best", "smosh", 
		"words", 		"cards", "board", "bored", 
		"irish", 		"accent", "funny", "humour", 
		"friend", 		"culture", "pop", "push", 
		"pull", 		"peel", "peek", "dock", 
		"one", 			"two", "talk", "breakup", 
		"fiance", 		"wife", "husband", "duck", 
		"cube", 		"listen", "hourglass", "hour", 
		"day", 			"minute", "second", "random", 
		"pack", 		"blueprint", "structure", "format"
	};
	
	public static void Main() {
		
		List<string> wordsPacks = words.Distinct().ToList();
		List<string> wordsBlueprints = words.Distinct().ToList();
		
		//DataAsset asset = new("", 10f);
		
		//DataArchive<Label, DataAsset>.Add(asset);
		//DataArchive<Label, DataAsset>.Load();
		
		//Logger.WriteLine();
		
		//string val = Serializer.ToJson(typeof(DataAsset), asset);
		
		//Logger.WriteColumn(val);

		//var obj = Serializer.FromJson(typeof(DataAsset), val);
		
		//string val2 = Serializer.ToJson(typeof(DataAsset), asset);
		
		//Logger.WriteColumn(val2);
		
		Random rand = new();
		
		int count = rand.Next(1, 4);
		
		//BiotaAssetPack pack = new("AssetPack", "pack");
		//BiotaAssetFile[] assets = new BiotaAssetFile[count];
		//string[] jsons_simple = new string[count];
		//string[] jsons_formatted = new string[count];
		//string[] jsonsCompressed_simple = new string[count];
		//string[] jsonsCompressed_formatted = new string[count];
		
		//int mag = 0;
		
		for (int a = 0; a < count; a++) {
			
			int nameIndex = rand.Next(0, wordsPacks.Count);
			string name = wordsPacks[nameIndex];
			wordsPacks.RemoveAt(nameIndex);
			
			PackBlueprint pack = new(name);
		
			int blueprintCount = rand.Next(2, 3);
			
			for (int b = 0; b < blueprintCount; b++) {
			
				nameIndex = rand.Next(0, wordsBlueprints.Count);
				string blueprintName = wordsBlueprints[nameIndex];
				wordsBlueprints.RemoveAt(nameIndex);
				
				DataBlueprint blueprint = new(blueprintName);
				blueprint.bulbs = new();
			
				int xSize = rand.Next(2, 32);
				int ySize = rand.Next(2, 32);
				int zSize = rand.Next(2, 32);
			
				int blocks = xSize * ySize * zSize;
				
				for (int v = 0; v < blocks; v++) {
					string blockID = "";
					int solid = rand.Next(0, 2);
					blockID += solid.ToString();
					if (solid == 1)
						blockID += '-' + rand.Next(1, 256).ToString();
					blueprint.bulbs.Add(blockID);
				}
				
				AssetArchive<DataBlueprint>.Add(blueprintName, blueprint);
				
				pack.datas.Add(blueprint);
			}
			
			AssetArchive<PackBlueprint>.Add(name, pack);
				
			//jsons_simple[a] = Serializer.ToJson(assetsRaw[a],false);
			//jsons_formatted[a] = Serializer.ToJson(assetsRaw[a], false);
			//jsonsCompressed_simple[a] = Serializer.CompressString(jsons_simple[a]);
			//jsonsCompressed_formatted[a] = Serializer.CompressString(jsons_formatted[a]);
		}
		
		var biotaPacks = ArchiveCache.Get(1).GetContents();
		string[] packContentArray = new string[biotaPacks.Length];
		
		for (int i = 0; i < biotaPacks.Length; i++) {
				
			biotaPacks[i].Write("", out string packContents, out string packDestination);
			packContentArray[i] = packContents;
			
			float rawSize = (float)packContents.ToByteArray().Length / 1000f;
		
			Logger.Header($"The '{biotaPacks[i].packName}' Pack had {biotaPacks[i].files.Length} Files : Size {rawSize} kb");
			Logger.WriteLine();
			Logger.WriteLine();
			Logger.WriteLine(packContents);
			Logger.WriteLine("End");
		}
		
		for (int i = 0; i < packContentArray.Length; i++) {
			
			string packContents = packContentArray[i];
			string compressedContents = Serializer.CompressString(packContents);
			
			float rawSize = (float)packContents.ToByteArray().Length / 1000f;
			
			float compressedSize = (float)compressedContents.ToByteArray().Length / 1000f;
			
			Logger.Header($"Compressed '{biotaPacks[i].packName}' : Size {compressedSize} kb : Reduction of {MathF.Floor((rawSize - compressedSize) / rawSize * 100f)}%");
			Logger.WriteLine();
			Logger.WriteLine();
			Logger.WriteLine(compressedContents);
			Logger.WriteLine("End");
		}
		
		
		//string compressedContents = Serializer.CompressString(packContents);
		
		//Logger.WriteColumn();
		//Logger.Header($"Compressed : Size {(float)compressedContents.ToByteArray().Length / 1000f} kb");
		//Logger.Write(compressedContents);
		
		
		//string assetsToJson_Decompressed_formatted = Serializer.DecompressString(assetsToJson_Compressed_formatted); // done
		
		//string assetsToJson_simple = Serializer.ToJson<DataAsset[]>(assetsRaw, false);
		//string assetsToJson_formatted = Serializer.ToJson<DataAsset[]>(assetsRaw, true);
		//string jsonsToJson_simple = Serializer.ToJson<string[]>(jsons_simple, false);
		//string jsonsToJson_formatted = Serializer.ToJson<string[]>(jsons_formatted, true);
		//string jsonsCompressedToJson_simple = Serializer.ToJson<string[]>(jsonsCompressed_simple, false);
		//string jsonsCompressedToJson_formatted = Serializer.ToJson<string[]>(jsonsCompressed_formatted, true);
		
		//string assetsToJson_Compressed_simple = Serializer.CompressString(assetsToJson_simple);
		//string assetsToJson_Compressed_formatted = Serializer.CompressString(assetsToJson_formatted);
		//string jsonsToJson_Compressed_simple = Serializer.CompressString(jsonsToJson_simple);
		//string jsonsToJson_Compressed_formatted = Serializer.CompressString(jsonsToJson_formatted);
		//string jsonsCompressedToJson_Compressed_simple = Serializer.CompressString(jsonsCompressedToJson_simple);
		//string jsonsCompressedToJson_Compressed_formatted = Serializer.CompressString(jsonsCompressedToJson_formatted);
		
		//string assetsToJson_Decompressed_simple = Serializer.DecompressString(assetsToJson_Compressed_simple); // done
		//string assetsToJson_Decompressed_formatted = Serializer.DecompressString(assetsToJson_Compressed_formatted); // done
		//string jsonsToJson_Decompressed_simple = Serializer.DecompressString(jsonsToJson_Compressed_simple);
		//string jsonsToJson_Decompressed_formatted = Serializer.DecompressString(jsonsToJson_Compressed_formatted);
		//string jsonsCompressedToJson_Decompressed_simple = Serializer.DecompressString(jsonsCompressedToJson_Compressed_simple);
		//string jsonsCompressedToJson_Decompressed_formatted = Serializer.DecompressString(jsonsCompressedToJson_Compressed_formatted);
		
		//string[] jsonsToJson_Jsons_simple = Serializer.FromJson<string[]>(jsonsToJson_Decompressed_simple);
		//string[] jsonsToJson_Jsons_formatted = Serializer.FromJson<string[]>(jsonsToJson_Decompressed_formatted);
		//string[] jsonsCompressedToJson_CompressedJsons_simple = Serializer.FromJson<string[]>(jsonsCompressedToJson_Decompressed_simple);
		//string[] jsonsCompressedToJson_CompressedJsons_formatted = Serializer.FromJson<string[]>(jsonsCompressedToJson_Decompressed_formatted);
		
		//DataAsset[] jsonsToJson_Assets_simple = new DataAsset[count];
		//DataAsset[] jsonsToJson_Assets_formatted = new DataAsset[count];
		//DataAsset[] jsonsCompressedToJson_Assets_simple = new DataAsset[count];
		//DataAsset[] jsonsCompressedToJson_Assets_formatted = new DataAsset[count];
		//string[] jsonsCompressedToJson_Jsons_simple = new string[count];
		//string[] jsonsCompressedToJson_Jsons_formatted = new string[count];
		//for (int a = 0; a < count; a++) {
			//jsonsToJson_Assets_simple[a] = Serializer.FromJson<DataAsset>(jsonsToJson_Jsons_simple[a]);
			//jsonsToJson_Assets_formatted[a] = Serializer.FromJson<DataAsset>(jsonsToJson_Jsons_formatted[a]);
			//jsonsCompressedToJson_Jsons_simple[a] = Serializer.DecompressString(jsonsCompressedToJson_CompressedJsons_simple[a]);
			//jsonsCompressedToJson_Jsons_formatted[a] = Serializer.DecompressString(jsonsCompressedToJson_CompressedJsons_formatted[a]);
			//jsonsCompressedToJson_Assets_simple[a] = Serializer.FromJson<DataAsset>(jsonsCompressedToJson_Jsons_simple[a]);
			//jsonsCompressedToJson_Assets_formatted[a] = Serializer.FromJson<DataAsset>(jsonsCompressedToJson_Jsons_formatted[a]);
		//}
		
		//string assetArrayToJson_simple = assetsToJson_Decompressed_simple;
		//string assetArrayToJson_formatted = assetsToJson_Decompressed_formatted;
		//string jsonArrayToJson_simple = Serializer.ToJson<DataAsset[]>(jsonsToJson_Assets_simple, false);
		//string jsonArrayToJson_formatted = Serializer.ToJson<DataAsset[]>(jsonsToJson_Assets_formatted, true);
		//string compressedJsonArrayToJson_simple = Serializer.ToJson<DataAsset[]>(jsonsCompressedToJson_Assets_simple, false);
		//string compressedJsonArrayToJson_formatted = Serializer.ToJson<DataAsset[]>(jsonsCompressedToJson_Assets_formatted, true);
		
		//Logger.NewColumn();
		//Logger.Header($"Asset Array {mag}");
		//Logger.Write(jsonsToJson_formatted);
		
		//Logger.NewColumn();
		//Logger.Header("Asset Array -> Json");
		//Logger.Write(assetsToJson);
		//Logger.WriteLine();
		//Logger.Header($"Compressed Simple {Serializer.FileSize(assetsToJson_Compressed_simple)}");
		//Logger.Write(assetsToJson_Compressed_simple);
		//Logger.WriteLine();
		//Logger.Header($"Compressed Formatted {Serializer.FileSize(assetsToJson_Compressed_formatted)}");
		//Logger.Write(assetsToJson_Compressed_formatted);
		//Logger.WriteLine();
		//Logger.Header("Decompressed");
		//Logger.Write(assetsToJson_Decompressed);
		//Logger.WriteLine();
		//Logger.Header("Json -> Asset Array");
		//Logger.Write(assetArrayToJson_formatted);
		
		//Logger.NewColumn();
		//Logger.Header("Asset Array -> Json Array -> Json");
		//Logger.Write(jsonsToJson);
		//Logger.WriteLine();
		//Logger.Header($"Compressed Simple {Serializer.FileSize(jsonsToJson_Compressed_simple)}");
		//Logger.Write(jsonsToJson_Compressed_simple);
		//Logger.WriteLine();
		//Logger.Header($"Compressed Formatted {Serializer.FileSize(jsonsToJson_Compressed_formatted)}");
		//Logger.Write(jsonsToJson_Compressed_formatted);
		//Logger.WriteLine();
		//Logger.Header("Decompressed");
		//Logger.Write(jsonsToJson_Decompressed);
		//Logger.WriteLine();
		//Logger.Header("Json -> Json Array -> Asset Array");
		//Logger.Write(jsonArrayToJson_formatted);
		
		/*
		Logger.NewColumn();
		Logger.Header("Asset Array -> Json Array -> Compressed Array -> Json");
		//Logger.Write(jsonsCompressedToJson);
		Logger.WriteLine();
		Logger.Header($"Compressed Simple {Serializer.FileSize(jsonsCompressedToJson_Compressed_simple)}");
		Logger.Write(jsonsCompressedToJson_Compressed_simple);
		Logger.WriteLine();
		Logger.Header($"Compressed Formatted {Serializer.FileSize(jsonsCompressedToJson_Compressed_formatted)}");
		Logger.Write(jsonsCompressedToJson_Compressed_formatted);
		//Logger.WriteLine();
		//Logger.Header("Decompressed");
		//Logger.Write(jsonsCompressedToJson_Decompressed);
		Logger.WriteLine();
		Logger.Header("Json -> Compressed Array -> Json Array -> Asset Array");
		Logger.Write(compressedJsonArrayToJson_formatted);
		*/
		
		Logger.Read();
	}
}
    public static class ArchiveCache {

        private static Dictionary<Type, ISecureArchive> archives;
        private static List<Type> types;

        public static int Count => archives.Count;


        public static ISecureArchive Get(int index)
            => archives[types[index]];

        public static void RegisterArchive(Type t, ISecureArchive archive) {
            archives.Add(t, archive);
            types.Add(t);
        }

        static ArchiveCache() {
            archives = new();
            types = new();
        }

    }

    public interface ISecureArchive {
        bool isRootArchive { get; }
        BiotaAssetPack[] GetContents();
    }

public class AssetArchive<T> : ISecureArchive
	where T : ArchivableAsset {
	
        public bool isRootArchive { get => typeof(IFileRoot).IsAssignableFrom(typeof(T)); }
	
		private static AssetArchive<T> archive;
		private List<string> legend;
		private Dictionary<string, T> cache;
		
		static AssetArchive() {
			archive = new();
			archive.cache = new();
			archive.legend = new();

            ArchiveCache.RegisterArchive(typeof(T), archive);
		}
		
		public static T Lookup(string name) {
			if (archive.legend.Contains(name)) {
				return archive.cache[name];
			}
			
			return null;
		}
		
		public static void Add(string name, T obj) {
			archive.legend.Add(name);
			archive.cache.Add(name, obj);
		}
	
        public BiotaAssetPack[] GetContents() {
            if (!isRootArchive) return new BiotaAssetPack[0];
            else {

                List<BiotaAssetPack> packs = new();
				
                if (archive != null) {

                    for (int i = 0; i < archive.legend.Count; i++) {
						var data = archive.cache[archive.legend[i]];
                        packs.Add(((IFileRoot)data).WrapPack());
                    }
                }

                return packs.ToArray();
            }
        }
}

    [Serializable]
    public class PackBlueprint : ArchivableAsset, IFileRoot {

        public string zipExtension { get => "packdef"; }
        public override string extension { get => "pdef"; }
		
		public string packName;
		[JsonIgnore] public List<DataBlueprint> datas;
		
		public PackBlueprint(string name) : base() {
			packName = name;
			this.datas = new();
		}
		
        public BiotaAssetPack WrapPack() {
            List<BiotaAssetFile> files = new() { Wrap<PackBlueprint>(packName) };

            for (int i = 0; i < datas.Count; i++) {
                if (datas[i] == null) continue;
				
                string assetName = datas[i].dataName;
                var assetFile = datas[i].Wrap<DataBlueprint>(assetName);

                files.Add(assetFile);
            }

            // TO-DO : TextureMap lookups

            return new(packName, zipExtension) {
                files = files.ToArray()
                //,textures = null
            };
        }
	}
	
    [Serializable]
    public class DataBlueprint : ArchivableAsset {

        [JsonIgnore] public override string extension { get => "ddef"; }
		
		public string dataName;
		public List<string> bulbs;
		
		public DataBlueprint(string name) : base() {
			dataName = name;
			this.bulbs = new();
		}
	}
	
    public interface IArchivable {
        string extension { get; }
    }

    public abstract class ArchivableAsset : IArchivable {
        public abstract string extension { get; }

        public ArchivableAsset() { }

        public BiotaAssetFile Wrap<T>(string assetName)
            where T : ArchivableAsset {
            BiotaAssetFile file = new();
            file.name = assetName;
            file.extension = extension;
            file.contents = Serializer.ToJson((T)this, false);
            return file;
        }
    }

    public interface IFileRoot {
        string zipExtension { get; }

        BiotaAssetPack WrapPack();
    }

    public class BiotaAssetPack {

        public string packName;
        public string packExtension;
        public BiotaAssetFile[] files;

        public BiotaAssetPack() : this("", "") { }
        public BiotaAssetPack(string packName, string packExtension) {
            this.packName = packName;
            this.packExtension = packExtension;
            files = new BiotaAssetFile[0];
        }

        public void Write(string directory, out string fileContents, out string fileDestination) {
            fileContents = Serialize(this);
            fileDestination = Path.Combine(directory, packName + '.' + packExtension);
			
        }
        
        private static string Serialize(BiotaAssetPack assetPack) {
            if (assetPack == null) return "";

            assetPack.files ??= new BiotaAssetFile[0];

            BiotaAssetFile packFile = new BiotaAssetFile() { 
                name = assetPack.packName, 
                extension = assetPack.packExtension,
                contents = "" 
            };

            List<BiotaAssetFile> files = assetPack.files.ToList();
            files.Insert(0, packFile);

            return Serializer.ToJson(files.ToArray(), true);
        }


        public void Read(string compressed) {
            string fileContents = Serializer.DecompressString(compressed);
            Deserialize(fileContents);
        }
		

        public void Deserialize(string fileContent) {
            BiotaAssetFile[] jsonFiles = Serializer.FromJson<BiotaAssetFile[]>(fileContent);
            jsonFiles ??= new BiotaAssetFile[0];

            List<BiotaAssetFile> fileList = jsonFiles.ToList();
            BiotaAssetFile rootFile;

            if (fileList.Count > 0) {
                rootFile = fileList[0];
                fileList.RemoveAt(0);

            } else rootFile = new();

            packName = rootFile.name;
            packExtension = rootFile.extension;
            files = fileList.ToArray();
        }
        

    }

    [Serializable]
    public class BiotaAssetFile {
        public string name;
        public string extension;
        public string contents;
    }

public static class Serializer {
	
		public static int FileSize(string input) {
            byte[] bytes = UnicodeEncoding.UTF8.GetBytes(input);
			return bytes.Length;
		}
	
        public static string CompressString(string input) {
            byte[] bytes = UnicodeEncoding.UTF8.GetBytes(input);
            var resultBytes = CompressBytes(bytes);

            return Convert.ToBase64String(resultBytes);
        }

        public static string DecompressString(string input) {
            byte[] bytes = Convert.FromBase64String(input);
            var resultBytes = DecompressBytes(bytes);
				
			var chars = UnicodeEncoding.UTF8.GetChars(resultBytes);
            return new(chars);
        }

        public static byte[] CompressBytes(byte[] input) {
            using (var source = new MemoryStream(input))
            using (var result = new MemoryStream()) {
                using (var Compress = new GZipStream(result, CompressionMode.Compress)) {
                    source.CopyTo(Compress);
                }
                return result.ToArray();
            }
        }

        public static byte[] DecompressBytes(byte[] input) {
            using (var source = new MemoryStream(input))
            using (var result = new MemoryStream()) {
                using (var Decompress = new GZipStream(source, CompressionMode.Decompress)) {
                    Decompress.CopyTo(result);
                }
                return result.ToArray();
            }
        }
	

        public static string ToSingleString(this byte[] bytes)
            => UnicodeEncoding.UTF8.GetChars(bytes).ToString();

    public static byte[] ToByteArray(this string input) 
        => UnicodeEncoding.UTF8.GetBytes(input);
	
	public static string ToJson<T>(T value, bool format = true)
		=> ToJson(typeof(T), value, format ? Formatting.Indented : Formatting.None);

	public static string ToJson(Type t, object value, Formatting formatting = Formatting.Indented) {
		JsonSerializer jsonSerializer = JsonSerializer.CreateDefault(new());
		jsonSerializer.Formatting = formatting;

		StringBuilder sb = new StringBuilder(256);
		StringWriter sw = new StringWriter(sb, CultureInfo.InvariantCulture);

		using (JsonTextWriter jsonWriter = new JsonTextWriter(sw)) {

			jsonWriter.Formatting = jsonSerializer.Formatting;
			jsonSerializer.Serialize(jsonWriter, value, t);
		}

		return sw.ToString();
	}
	
	public static T FromJson<T>(string value)
		=> (T)FromJson(typeof(T), value);
	
	public static object FromJson(Type t, string value) {
		JsonSerializer jsonSerializer = JsonSerializer.CreateDefault();
		jsonSerializer.CheckAdditionalContent = false;

		using (JsonTextReader reader = new JsonTextReader(new StringReader(value)) { SupportMultipleContent = false }) {
			return jsonSerializer.Deserialize(reader, t);
		}
	}	
}

public interface IIdentifier { string Read(); }
public struct Label : IIdentifier { public string label; public string Read() => label; }

public interface IArchivable<T> 
	where T : IIdentifier 
	{ T GetID(); }

public abstract class ArchivableAsset<T> : IArchivable<T>
	where T : IIdentifier 
	{ public abstract T GetID(); public abstract string GetValue(); }

[Serializable]
public class DataAsset : ArchivableAsset<Label> { 
	
	[JsonProperty] private Label label;
	[JsonProperty] private string[] values;
	
	public DataAsset() { }
	
	public DataAsset(Label label, params string[] values) {
		this.label = label;	
		this.values = values;
	}
	
	public DataAsset(string label, params string[] values) {
		this.label = new() {
			label = label
		};		
		this.values = values;
	}
	
	public override Label GetID() {
		return label;
	}
	
	public override string GetValue()
		=> values[0];
}

public static class DataArchive<Tid, Tobj>
	where Tid : IIdentifier
	where Tobj : ArchivableAsset<Tid> {
	
	static DataArchive() {
		Type t = typeof(Tobj);
		Logger.WriteLine($"Created an Archive for {t.Name}.");	
		saved = new();
		ids = new();
	}
	
	private static Dictionary<string, Tobj> saved;
	private static List<string> ids;
	
	public static void Add(Tobj obj) {
		string id = obj.GetID().Read();
		saved.Add(id, obj);
		ids.Add(id);
	}
	
	public static Tobj[] Load() {
		
		Tobj[] array = new Tobj[saved.Count];
		
		for (int i = 0; i < saved.Count; i++) {
			array[i] = saved[ids[i]];
		}
			
		return array;
	}
}

public static class DataStreamer {

	static DataStreamer() {
		
		var assemblies = AppDomain.CurrentDomain.GetAssemblies();
		List<Type> dataFileTypes = new();

		var dataArchive = typeof(DataArchive<,>);
		var loadMethod = dataArchive.GetMethod("Load", 2, BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, new Type[0]);
		
		var target = typeof(ArchivableAsset<>);
		var valueMethod = target.GetMethod("GetValue", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
		var idMethod = target.GetMethod("GetID", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);

		foreach (var assembly in assemblies) {
			dataFileTypes.AddRange(
				assembly.GetTypes()
				.Where((x) => { 
					if (!x.IsGenericType) return false;
					
					var genericType = x.GetGenericTypeDefinition();
					
					if (genericType != null) {
						if (target.IsAssignableFrom(genericType)) {
							Console.WriteLine(genericType.Name);
							return true;
						}
						return false;
					}
					return false;
				})
			);
		}	
		
		for (int i = 0; i < dataFileTypes.Count; i++) {
		
			Type[] generics = dataFileTypes[i].GenericTypeArguments;
			if (generics == null) Console.WriteLine("Null generic arguments");
			Type idType = generics.Length > 0 ? generics[0] : null;
			string genericName = generics.Length > 0 ? generics[0].Name : "";
			
			Logger.WriteLine($"DataStreamer - Located ArchivableAsset of the type {dataFileTypes[i].Name}, implementing the IIdentifier type '{genericName}'");
			
			var properLoadMethod = loadMethod.MakeGenericMethod(idType,dataFileTypes[i]);
			var properIdMethod = idMethod.MakeGenericMethod(idType);
			var savedInArchive = (Array)properLoadMethod.Invoke(null, new object[0]);
			
			for (int j = 0; j < savedInArchive.Length; j++) {
				var archiveEntry = savedInArchive.GetValue(j);
				
				float value = (float)valueMethod.Invoke(archiveEntry, new object[0]);
				IIdentifier id = (IIdentifier)properIdMethod.Invoke(archiveEntry, new object[0]);
				
				Logger.WriteLine($"\tThe {dataFileTypes[i].Name} instance named {id.Read()} has a value of {value}.");
			}
		}
	}
	
	public static void Stream() {
			
	}
	
}

public static class Logger {
	
	static int _width = 96;
	static int _height = 1024;
	
	public static int Width => _width;
	public static int Height => _height;
	public static int Spacing = 1;
	public static int Padding = 2;
	
	public class Column {
	
		public readonly int width;
		public int height;
		public List<List<char>> logs;
	
		int xStart { get => padClamp; }
		int xMax { get => width - padClamp; }
		int colMax { get => column.width - padClamp; }
		
		int padClamp { get => Math.Clamp(Padding, 0, (int)Math.Round((double)width * 0.5)); }
		
		int yAdvance { get => 1 + Math.Max(Spacing, 0); }
		
		readonly List<char> emptyLineList;
		
		public int x { get; private set; }
		public int y { get; private set; }
		public int realY { get; private set; }
		
		public bool complete { get; private set; }
		
		public Column(int width, int height) {
			
			this.width = width;
			this.height = height;
			
			Reset();
			
			emptyLineList = new();
			foreach(var ch in emptyLine)
				emptyLineList.Add(ch);
			
			logs = new();
			NewLine();
		}
		
		void Reset() {
			x = xStart;
			y = 0;
			realY = 0;
		}
		
		public void Clear() {
			Reset();
			
			complete = false;
			
			logs.Clear();
			NewLine();
		}
		
		public bool Down() {
			AdvanceY();
			
			UpdateLogs();
			
			complete = ReachedEnd();
			
			return complete;
		}
		
		void NewLine() {
			var newLine = new List<char>();
			newLine.AddRange(emptyLineList);
			logs.Add(newLine);
		}
		
		void UpdateLogs() {
			while (realY >= logs.Count - 1) {
				NewLine();
			}
		}
		
		void AdvanceY() {
			x = xStart;
			y++;
			realY += yAdvance;
		}
		
		bool ReachedEnd() => realY >= height;
		
		
		public bool Write(string text, out string remaining) {
			remaining = text;
			
			if (complete) return complete;
			
			if (x + 1 >= colMax) {
				AdvanceY();
			}
			
			UpdateLogs();
			
			if (ReachedEnd()) {
				complete = true;
				return complete;
			}
			
			List<string> chunks = new();
			bool wasSpace = false;
			string chunk = "";
			for (int i = 0; i < text.Length; i++) {
				if (text[i] == ' ') {
					if (wasSpace)
						chunk += ' ';
					else {
						chunks.Add(chunk);
						chunk = " ";
						wasSpace = true;
					}
				
				} else {
					if (wasSpace) {
						if (chunk.Length > 1) {
							chunks.Add(chunk);
							chunk = "";
						}
						chunk = "";
						wasSpace = false;
					}
					chunk += text[i];
				}
			}
			
			if (!wasSpace || chunk.Length > 1) chunks.Add(chunk);
			
			for (int p = 0; p < chunks.Count; p++) {
				string stem = p == chunks.Count - 1 ? "" : " ";
				
				WriteWord(chunks[p] + stem, remaining, out remaining);
					
				if (complete) return complete;
			}
			
			return complete;
		}
		
		private void WriteWord(string text, string all, out string remaining) {
			
			remaining = all;
				
			if (x + text.Length > colMax) {
				AdvanceY();
			}

			if (ReachedEnd()) {
				complete = true;
				return;
			}

			for (int i = 0; i < text.Length; i++) {
				char ch = text[i];

				if (ch == '\n') {
					AdvanceY();

				} else if (ch == '\t') {
					for (int t = 0; t < 4; t++) {
						x++;	

						if (x >= xMax) {
							AdvanceY();
						}
					}

				} else {

					if (x >= xMax) {
						AdvanceY();
					}
					
					UpdateLogs();

					logs[realY][x] = ch;

					x++;

					if (x >= xMax) {
						AdvanceY();
					}
				}

				remaining = remaining.Prim();

				if (ReachedEnd()) {
					complete = true;
					return;
				}
			}
		}
	}
	
	static string emptyLine;
	
	static (int width, int height) column;
	static Column writer;
	static List<List<char>> final; 
	
	static string headingLine;
	static readonly string dottedLine = "- --- -";
	static bool started;
	
	static Logger() {
		final = new List<List<char>>();
		cols = new();
		
		SetupColumn();
	}
	
	public static void Header(string header, bool centered = true) {
		NextColumn();
		WriteLine();
		int headerLength = header.Length;
		
		string offset = "";
		
		if(centered) {
			int half = (int)MathF.Round((float)column.width * 0.5f - (float)headerLength * 0.5f - 2);
			
			for (int i = 0; i < half; i++) 
				offset += " ";
		}
		
		WriteLine($"{offset}{header}");
		
		Write(headingLine);
	}
	
	static void SetupColumn() {
		column = (_width, _height);
			
		emptyLine = "";
		headingLine = "";
		for (int i = 0, l = 0; i < column.width; i++, l = (l + 1) % dottedLine.Length) {
			emptyLine += ' ';
			
			if (i < Padding || i >= column.width - Padding) { }
			else
				headingLine += dottedLine[l];
		}
		
		writer = new(column.width, column.height);
		
		started = false;
	}
	
	static List<(int, int)> cols;
	
	
	public static void WriteRandom(string stem = "", int words = -1) {
		var rand = new Random();
		
		if (words <= 0)
			words = rand.Next(12, 64);
		
		int available = words;
		
		string text = $"\t{stem} : \n\t";
		
		const int commaChance_OneIn = 6;
		
		while (available > 0) {
			int sentenceLength = rand.Next(3, 16);
			
			if (sentenceLength > available) sentenceLength = available;
			available -= sentenceLength;
			
			for (int s = 0; s < sentenceLength; s++) {
				int letters = rand.Next(2, 8);
				
				bool firstWord = s == 0;
				bool lastWord = s == sentenceLength - 1;
				
				for (int l = 0; l < letters; l++) {
					int start, end;

					if (firstWord && l == 0) {
						start = 65;
						end = 90;
					} else {
						start = 97;
						end = 122;
					}

					char letter = (char)rand.Next(start, end + 1);
					
					text += letter;
				}
					
				if (!lastWord
					&& rand.Next(0, commaChance_OneIn) == 1) {
					text += ',';
				}
				
				if (!lastWord)
					text += ' '; 
			}
			
			text += ". ";	
		}
		
		WriteLine();
		Write(text);
	}
	
	public static void WriteLine(string text = "") {
		Write(text);
		NextLine();
	}
	
	public static void Write(string text) {
		text ??= "";
		if (text == "") return;
		started = true;
		if (writer.Write(text, out string remaining)) {
			NextColumn();
			writer.Write(remaining, out string _);
		}
	}
	
	public static void NextLine() {
		if (writer.Down()) {
			NextColumn();	
		}
	}
	
	public static void NextColumn() {
		NextColumn(_width, _height);
	}
	
	public static void NextColumnWithWidth(int width) {
		NextColumn(width, _height);
	}
	
	public static void NextColumnWithHeight(int height) {
		NextColumn(_width, height);
	}
	
	public static void NextColumn(int width, int height) {
		if (!started) return;
		
		CommitWriterToFinal();
		
		_width = width;
		_height = height;
		
		padded = false;
		
		if (writer.y != 0)
			cols.Add(column);
		
		SetupColumn();
	}
	
	static void AddLineToLog(int i) {
		var newLine = new List<char>();

		for (int ci = 0; ci < cols.Count; ci++) {
            int cWidth = cols[ci].Item1;
            int cHeight = cols[ci].Item2;

            char space = cHeight < column.height ? '-' : ' ';
            char divider = cHeight < column.height ? '-' : '|';

            char priorDivider = '|';
            bool isPriorCol = ci == cols.Count - 1;

            if (i > cHeight) {
                space = ' ';
                divider = ' ';
            }

            if (ci == 0) newLine.Add(divider);

            for (int cx = 0; cx < cWidth; cx++)
                newLine.Add(space);

            newLine.Add(isPriorCol ? priorDivider : divider);
        }
		
        final.Add(newLine);
	}
	
	static void AddPreviousUnderline() {
		if (final.Count <= column.height) final.Add(new());
				
		List<char> fullLine = new();

        fullLine.AddRange(final[column.height]);

        int start = fullLine.Count;
        int lx = 0;

        for (int ci = 0; ci < cols.Count; ci++) {
            for (int cx = 0; cx <= cols[ci].Item1; cx++) {
                if (lx >= start) fullLine.Add(' ');
                lx++;
            }
        }

        fullLine.Add('-');

        for (int x = 0; x < column.width; x++)
            fullLine.Add('-');

        fullLine.Add('-');

        final[column.height] = fullLine;
        final.Add(new List<char>());
	}
	
	static void CommitWriterToFinal(bool drawSeparator = true) {
	
		int y = writer.realY;
		
		if (y == 0) return;
		
		if (y < column.height)
			column.height = y;
		
		for (int i = 0; i < column.height; i++) {
			if (final.Count <= i) AddLineToLog(i);
			
			if (cols.Count == 0) final[i].Add('|');
			
			int currentLineLength = final[i].Count;
			int idealLineLength = 0;
			
			foreach(var col in cols) idealLineLength += col.Item1 + 1;
			
			if (currentLineLength < idealLineLength) {
				int mark = idealLineLength;
				
				for (int l = currentLineLength; l < idealLineLength; l++) {
					final[i].Add(' ');
				}
				
				final[i].Add('|');
			}
			
			if (cols.Count > 0) {
				if (i == cols[cols.Count - 1].Item2) {
					final[i][final[i].Count - 1] = '|';	
				}
			}

			string str = i < y
				? new string(writer.logs[i].ToArray())
				: emptyLine;

			final[i].AddRange(str);

			if (drawSeparator) final[i].Add('|');
		}
		
		var underline = new List<char>();
		for (int i = 0; i < column.width; i++) 
			underline.Add('-');
				
		if (cols.Count > 0) {
			var prevHeight = cols[cols.Count - 1].Item2;
			
			if (column.height != prevHeight)
				underline.Add('|');
			else underline.Add('-');
			
			if (column.height <= prevHeight) {
				int underIndex = Math.Min(final.Count, column.height);
				final[underIndex].AddRange(underline);
				
			} else if (column.height > prevHeight) 
				AddPreviousUnderline();
				
		} else {
			underline.Insert(0, '|');
			underline.Add('|');
			final.Add(underline);
		}
	}
	
	static bool padded = false;
	
	public static void Read() {
		
		if (final.Count == 0) return;
		
		int size = final[0].Count;
			
		if (writer.y > 0) size += column.width + 1;
		if (padded) size++;
		
		CommitWriterToFinal(true);
		
		char[] topLine = new char[0];
		char[] bottomLine = new char[0];
		
		if (final.Count > 0) {
			topLine = new char[size];
			
			for (int i = 0; i < size; i++) 
				topLine[i] = '-';
		}
		
		string _topLine = new string(topLine);
		
		Console.WriteLine(_topLine);
		
		for (int i = 0; i < final.Count; i++) {
			var str = final[i].ToArray();
			var _str = new string(str);
			
			Console.WriteLine(_str);
		}
	}
	
	public static string Prim(this string str)
		=> str.Length > 2 ? str.Substring(1, str.Length - 1) : "";
}

​x
 
using System;
using System.IO;
using System.IO.Compression;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Globalization;
using System.Reflection;
using Newtonsoft.Json;
                    
public class Program
{
    static List<string> words = new List<string>() {
        "month",        "freckle", "rock", "arrow", 
        "exclude",      "sailor", "safari", "pastel",   
        "staircase",    "distinct", "disappoint", "pollution",  
        "isolation",    "card", "mathematics", "executive", 
        "lineage",      "title", "licence", "torch",    
        "mastermind",   "word", "priority", "feminine", 
        "aspect",       "cart", "lounge", "obligation", 
        "father",       "cutting", "painter", "swing",  
        "burial",       "suitcase", "paralyzed", "convulsion",
        "asset",        "lackey", "rough", "waiter",
        "handlebar",    "mustache", "like", "maam", 
        "mum",          "doctor", "magic", "box", 
        "toy",          "shelf", "money", "leggings", 
        "hairband",     "water", "bottle", "mouse",
        "pad",          "planet", "glass", "tissue", 
        "paper",        "wallet", "storage", "leaf", 
        "severance",    "show", "television",
        "radio",        "puppet", "giggle", "laugh", 
        "emote",        "chair", "airplane", "heart", 
        "arrow",        "swim", "rainbow", "cheese", 
        "pizza",        "hamburger", "barn", "silo", 
        "ranch",        "computer", "station", "police", 
        "steal",        "theft", "handler", "jar", 
        "cash",         "coins", "cook", "chef", 
        "chief",        "detective", "inspector", "fire", 
        "murder",       "time", "clock", "tea", 
        "kettle",       "baby", "parent", "child", 
        "birthday",     "holiday", "celebrate", "cake", 
        "people",       "family", "anniversary", "wedding", 
        "engagement",   "shower", "bride", "groom",
        "maid",         "honor", "best", "smosh", 
        "words",        "cards", "board", "bored", 
        "irish",        "accent", "funny", "humour", 
        "friend",       "culture", "pop", "push", 
        "pull",         "peel", "peek", "dock", 
        "one",          "two", "talk", "breakup", 
        "fiance",       "wife", "husband", "duck", 
        "cube",         "listen", "hourglass", "hour", 
        "day",          "minute", "second", "random", 
        "pack",         "blueprint", "structure", "format"
    };
    
    public static void Main() {
        
        List<string> wordsPacks = words.Distinct().ToList();
        List<string> wordsBlueprints = words.Distinct().ToList();
        
        //DataAsset asset = new("", 10f);
        
        //DataArchive<Label, DataAsset>.Add(asset);
        //DataArchive<Label, DataAsset>.Load();
        
        //Logger.WriteLine();
        
        //string val = Serializer.ToJson(typeof(DataAsset), asset);
        
        //Logger.WriteColumn(val);
​
        //var obj = Serializer.FromJson(typeof(DataAsset), val);
        
        //string val2 = Serializer.ToJson(typeof(DataAsset), asset);
        
        //Logger.WriteColumn(val2);
        
        Random rand = new();
        
        int count = rand.Next(1, 4);
        
        //BiotaAssetPack pack = new("AssetPack", "pack");
        //BiotaAssetFile[] assets = new BiotaAssetFile[count];
        //string[] jsons_simple = new string[count];
        //string[] jsons_formatted = new string[count];
        //string[] jsonsCompressed_simple = new string[count];
        //string[] jsonsCompressed_formatted = new string[count];
        
        //int mag = 0;
        
        for (int a = 0; a < count; a++) {
            
            int nameIndex = rand.Next(0, wordsPacks.Count);
            string name = wordsPacks[nameIndex];
            wordsPacks.RemoveAt(nameIndex);
            
            PackBlueprint pack = new(name);
        
            int blueprintCount = rand.Next(2, 3);
            
            for (int b = 0; b < blueprintCount; b++) {
            
                nameIndex = rand.Next(0, wordsBlueprints.Count);
                string blueprintName = wordsBlueprints[nameIndex];
                wordsBlueprints.RemoveAt(nameIndex);
                
                DataBlueprint blueprint = new(blueprintName);
                blueprint.bulbs = new();
            
                int xSize = rand.Next(2, 32);
                int ySize = rand.Next(2, 32);
                int zSize = rand.Next(2, 32);
            
                int blocks = xSize * ySize * zSize;
                
                for (int v = 0; v < blocks; v++) {
                    string blockID = "";
                    int solid = rand.Next(0, 2);
                    blockID += solid.ToString();
                    if (solid == 1)
                        blockID += '-' + rand.Next(1, 256).ToString();
                    blueprint.bulbs.Add(blockID);
                }
                
                AssetArchive<DataBlueprint>.Add(blueprintName, blueprint);
                
                pack.datas.Add(blueprint);
            }
            
            AssetArchive<PackBlueprint>.Add(name, pack);
                
            //jsons_simple[a] = Serializer.ToJson(assetsRaw[a],false);
            //jsons_formatted[a] = Serializer.ToJson(assetsRaw[a], false);
            //jsonsCompressed_simple[a] = Serializer.CompressString(jsons_simple[a]);
            //jsonsCompressed_formatted[a] = Serializer.CompressString(jsons_formatted[a]);
        }
        
        var biotaPacks = ArchiveCache.Get(1).GetContents();
        string[] packContentArray = new string[biotaPacks.Length];
        
        for (int i = 0; i < biotaPacks.Length; i++) {
                
            biotaPacks[i].Write("", out string packContents, out string packDestination);
            packContentArray[i] = packContents;
            
            float rawSize = (float)packContents.ToByteArray().Length / 1000f;
        
            Logger.Header($"The '{biotaPacks[i].packName}' Pack had {biotaPacks[i].files.Length} Files : Size {rawSize} kb");
            Logger.WriteLine();
            Logger.WriteLine();
            Logger.WriteLine(packContents);
            Logger.WriteLine("End");
        }
        
        for (int i = 0; i < packContentArray.Length; i++) {
            
            string packContents = packContentArray[i];
            string compressedContents = Serializer.CompressString(packContents);
            
            float rawSize = (float)packContents.ToByteArray().Length / 1000f;
            
            float compressedSize = (float)compressedContents.ToByteArray().Length / 1000f;
            
            Logger.Header($"Compressed '{biotaPacks[i].packName}' : Size {compressedSize} kb : Reduction of {MathF.Floor((rawSize - compressedSize) / rawSize * 100f)}%");
            Logger.WriteLine();
            Logger.WriteLine();
            Logger.WriteLine(compressedContents);
            Logger.WriteLine("End");
        }
        
        
        //string compressedContents = Serializer.CompressString(packContents);
        
        //Logger.WriteColumn();
        //Logger.Header($"Compressed : Size {(float)compressedContents.ToByteArray().Length / 1000f} kb");
        //Logger.Write(compressedContents);
        
        
        //string assetsToJson_Decompressed_formatted = Serializer.DecompressString(assetsToJson_Compressed_formatted); // done
        
        //string assetsToJson_simple = Serializer.ToJson<DataAsset[]>(assetsRaw, false);
        //string assetsToJson_formatted = Serializer.ToJson<DataAsset[]>(assetsRaw, true);
        //string jsonsToJson_simple = Serializer.ToJson<string[]>(jsons_simple, false);
        //string jsonsToJson_formatted = Serializer.ToJson<string[]>(jsons_formatted, true);
        //string jsonsCompressedToJson_simple = Serializer.ToJson<string[]>(jsonsCompressed_simple, false);
        //string jsonsCompressedToJson_formatted = Serializer.ToJson<string[]>(jsonsCompressed_formatted, true);
        
        //string assetsToJson_Compressed_simple = Serializer.CompressString(assetsToJson_simple);
        //string assetsToJson_Compressed_formatted = Serializer.CompressString(assetsToJson_formatted);
        //string jsonsToJson_Compressed_simple = Serializer.CompressString(jsonsToJson_simple);
        //string jsonsToJson_Compressed_formatted = Serializer.CompressString(jsonsToJson_formatted);
        //string jsonsCompressedToJson_Compressed_simple = Serializer.CompressString(jsonsCompressedToJson_simple);
        //string jsonsCompressedToJson_Compressed_formatted = Serializer.CompressString(jsonsCompressedToJson_formatted);
        
        //string assetsToJson_Decompressed_simple = Serializer.DecompressString(assetsToJson_Compressed_simple); // done
        //string assetsToJson_Decompressed_formatted = Serializer.DecompressString(assetsToJson_Compressed_formatted); // done
        //string jsonsToJson_Decompressed_simple = Serializer.DecompressString(jsonsToJson_Compressed_simple);
        //string jsonsToJson_Decompressed_formatted = Serializer.DecompressString(jsonsToJson_Compressed_formatted);
        //string jsonsCompressedToJson_Decompressed_simple = Serializer.DecompressString(jsonsCompressedToJson_Compressed_simple);
        //string jsonsCompressedToJson_Decompressed_formatted = Serializer.DecompressString(jsonsCompressedToJson_Compressed_formatted);
        
        //string[] jsonsToJson_Jsons_simple = Serializer.FromJson<string[]>(jsonsToJson_Decompressed_simple);
        //string[] jsonsToJson_Jsons_formatted = Serializer.FromJson<string[]>(jsonsToJson_Decompressed_formatted);
        //string[] jsonsCompressedToJson_CompressedJsons_simple = Serializer.FromJson<string[]>(jsonsCompressedToJson_Decompressed_simple);
        //string[] jsonsCompressedToJson_CompressedJsons_formatted = Serializer.FromJson<string[]>(jsonsCompressedToJson_Decompressed_formatted);
        
        //DataAsset[] jsonsToJson_Assets_simple = new DataAsset[count];
        //DataAsset[] jsonsToJson_Assets_formatted = new DataAsset[count];
        //DataAsset[] jsonsCompressedToJson_Assets_simple = new DataAsset[count];
        //DataAsset[] jsonsCompressedToJson_Assets_formatted = new DataAsset[count];
        //string[] jsonsCompressedToJson_Jsons_simple = new string[count];
        //string[] jsonsCompressedToJson_Jsons_formatted = new string[count];
        //for (int a = 0; a < count; a++) {
            //jsonsToJson_Assets_simple[a] = Serializer.FromJson<DataAsset>(jsonsToJson_Jsons_simple[a]);
            //jsonsToJson_Assets_formatted[a] = Serializer.FromJson<DataAsset>(jsonsToJson_Jsons_formatted[a]);
            //jsonsCompressedToJson_Jsons_simple[a] = Serializer.DecompressString(jsonsCompressedToJson_CompressedJsons_simple[a]);
            //jsonsCompressedToJson_Jsons_formatted[a] = Serializer.DecompressString(jsonsCompressedToJson_CompressedJsons_formatted[a]);
            //jsonsCompressedToJson_Assets_simple[a] = Serializer.FromJson<DataAsset>(jsonsCompressedToJson_Jsons_simple[a]);
            //jsonsCompressedToJson_Assets_formatted[a] = Serializer.FromJson<DataAsset>(jsonsCompressedToJson_Jsons_formatted[a]);
        //}
        
        //string assetArrayToJson_simple = assetsToJson_Decompressed_simple;
        //string assetArrayToJson_formatted = assetsToJson_Decompressed_formatted;
        //string jsonArrayToJson_simple = Serializer.ToJson<DataAsset[]>(jsonsToJson_Assets_simple, false);
        //string jsonArrayToJson_formatted = Serializer.ToJson<DataAsset[]>(jsonsToJson_Assets_formatted, true);
        //string compressedJsonArrayToJson_simple = Serializer.ToJson<DataAsset[]>(jsonsCompressedToJson_Assets_simple, false);
        //string compressedJsonArrayToJson_formatted = Serializer.ToJson<DataAsset[]>(jsonsCompressedToJson_Assets_formatted, true);
        
        //Logger.NewColumn();
        //Logger.Header($"Asset Array {mag}");
        //Logger.Write(jsonsToJson_formatted);
        
        //Logger.NewColumn();
        //Logger.Header("Asset Array -> Json");
        //Logger.Write(assetsToJson);
        //Logger.WriteLine();
        //Logger.Header($"Compressed Simple {Serializer.FileSize(assetsToJson_Compressed_simple)}");
        //Logger.Write(assetsToJson_Compressed_simple);
        //Logger.WriteLine();
        //Logger.Header($"Compressed Formatted {Serializer.FileSize(assetsToJson_Compressed_formatted)}");
        //Logger.Write(assetsToJson_Compressed_formatted);
        //Logger.WriteLine();
        //Logger.Header("Decompressed");
        //Logger.Write(assetsToJson_Decompressed);
        //Logger.WriteLine();
        //Logger.Header("Json -> Asset Array");
        //Logger.Write(assetArrayToJson_formatted);
        
        //Logger.NewColumn();
        //Logger.Header("Asset Array -> Json Array -> Json");
        //Logger.Write(jsonsToJson);
        //Logger.WriteLine();
        //Logger.Header($"Compressed Simple {Serializer.FileSize(jsonsToJson_Compressed_simple)}");
        //Logger.Write(jsonsToJson_Compressed_simple);
        //Logger.WriteLine();
        //Logger.Header($"Compressed Formatted {Serializer.FileSize(jsonsToJson_Compressed_formatted)}");
        //Logger.Write(jsonsToJson_Compressed_formatted);
        //Logger.WriteLine();
        //Logger.Header("Decompressed");
        //Logger.Write(jsonsToJson_Decompressed);
        //Logger.WriteLine();
        //Logger.Header("Json -> Json Array -> Asset Array");
        //Logger.Write(jsonArrayToJson_formatted);
        
        /*
        Logger.NewColumn();
        Logger.Header("Asset Array -> Json Array -> Compressed Array -> Json");
        //Logger.Write(jsonsCompressedToJson);
        Logger.WriteLine();
        Logger.Header($"Compressed Simple {Serializer.FileSize(jsonsCompressedToJson_Compressed_simple)}");
        Logger.Write(jsonsCompressedToJson_Compressed_simple);
        Logger.WriteLine();
        Logger.Header($"Compressed Formatted {Serializer.FileSize(jsonsCompressedToJson_Compressed_formatted)}");
        Logger.Write(jsonsCompressedToJson_Compressed_formatted);
        //Logger.WriteLine();
        //Logger.Header("Decompressed");
        //Logger.Write(jsonsCompressedToJson_Decompressed);
        Logger.WriteLine();
        Logger.Header("Json -> Compressed Array -> Json Array -> Asset Array");
        Logger.Write(compressedJsonArrayToJson_formatted);
        */
        
        Logger.Read();
    }
}
    public static class ArchiveCache {
​
        private static Dictionary<Type, ISecureArchive> archives;
        private static List<Type> types;
​
        public static int Count => archives.Count;
​
​
        public static ISecureArchive Get(int index)
            => archives[types[index]];
​
        public static void RegisterArchive(Type t, ISecureArchive archive) {
            archives.Add(t, archive);
            types.Add(t);
        }
​
        static ArchiveCache() {
            archives = new();
            types = new();
        }
​
    }
​
    public interface ISecureArchive {
        bool isRootArchive { get; }
        BiotaAssetPack[] GetContents();
    }
​
public class AssetArchive<T> : ISecureArchive
    where T : ArchivableAsset {
    
        public bool isRootArchive { get => typeof(IFileRoot).IsAssignableFrom(typeof(T)); }
    
        private static AssetArchive<T> archive;
        private List<string> legend;
        private Dictionary<string, T> cache;
        
        static AssetArchive() {
            archive = new();
            archive.cache = new();
            archive.legend = new();
​
            ArchiveCache.RegisterArchive(typeof(T), archive);
        }
        
        public static T Lookup(string name) {
            if (archive.legend.Contains(name)) {
                return archive.cache[name];
            }
            
            return null;
        }
        
        public static void Add(string name, T obj) {
            archive.legend.Add(name);
            archive.cache.Add(name, obj);
        }
    
        public BiotaAssetPack[] GetContents() {
            if (!isRootArchive) return new BiotaAssetPack[0];
            else {
​
                List<BiotaAssetPack> packs = new();
                
                if (archive != null) {
​
                    for (int i = 0; i < archive.legend.Count; i++) {
                        var data = archive.cache[archive.legend[i]];
                        packs.Add(((IFileRoot)data).WrapPack());
                    }
                }
​
                return packs.ToArray();
            }
        }
}
​
    [Serializable]
    public class PackBlueprint : ArchivableAsset, IFileRoot {
​
        public string zipExtension { get => "packdef"; }
        public override string extension { get => "pdef"; }
        
        public string packName;
        [JsonIgnore] public List<DataBlueprint> datas;
        
        public PackBlueprint(string name) : base() {
            packName = name;
            this.datas = new();
        }
        
        public BiotaAssetPack WrapPack() {
            List<BiotaAssetFile> files = new() { Wrap<PackBlueprint>(packName) };
​
            for (int i = 0; i < datas.Count; i++) {
                if (datas[i] == null) continue;
                
                string assetName = datas[i].dataName;
                var assetFile = datas[i].Wrap<DataBlueprint>(assetName);
​
                files.Add(assetFile);
            }
​
            // TO-DO : TextureMap lookups
​
            return new(packName, zipExtension) {
                files = files.ToArray()
                //,textures = null
            };
        }
    }
    
    [Serializable]
    public class DataBlueprint : ArchivableAsset {
​
        [JsonIgnore] public override string extension { get => "ddef"; }
        
        public string dataName;
        public List<string> bulbs;
        
        public DataBlueprint(string name) : base() {
            dataName = name;
            this.bulbs = new();
        }
    }
    
    public interface IArchivable {
        string extension { get; }
    }
​
    public abstract class ArchivableAsset : IArchivable {
        public abstract string extension { get; }
​
        public ArchivableAsset() { }
​
        public BiotaAssetFile Wrap<T>(string assetName)
            where T : ArchivableAsset {
            BiotaAssetFile file = new();
            file.name = assetName;
            file.extension = extension;
            file.contents = Serializer.ToJson((T)this, false);
            return file;
        }
    }
​
    public interface IFileRoot {
        string zipExtension { get; }
​
        BiotaAssetPack WrapPack();
    }
​
    public class BiotaAssetPack {
​
        public string packName;
        public string packExtension;
        public BiotaAssetFile[] files;
​
        public BiotaAssetPack() : this("", "") { }
        public BiotaAssetPack(string packName, string packExtension) {
            this.packName = packName;
            this.packExtension = packExtension;
            files = new BiotaAssetFile[0];
        }
​
        public void Write(string directory, out string fileContents, out string fileDestination) {
            fileContents = Serialize(this);
            fileDestination = Path.Combine(directory, packName + '.' + packExtension);
            
        }
        
        private static string Serialize(BiotaAssetPack assetPack) {
            if (assetPack == null) return "";
​
            assetPack.files ??= new BiotaAssetFile[0];
​
            BiotaAssetFile packFile = new BiotaAssetFile() { 
                name = assetPack.packName, 
                extension = assetPack.packExtension,
                contents = "" 
            };
​
            List<BiotaAssetFile> files = assetPack.files.ToList();
            files.Insert(0, packFile);
​
            return Serializer.ToJson(files.ToArray(), true);
        }
​
​
        public void Read(string compressed) {
            string fileContents = Serializer.DecompressString(compressed);
            Deserialize(fileContents);
        }
        
​
        public void Deserialize(string fileContent) {
            BiotaAssetFile[] jsonFiles = Serializer.FromJson<BiotaAssetFile[]>(fileContent);
            jsonFiles ??= new BiotaAssetFile[0];
​
            List<BiotaAssetFile> fileList = jsonFiles.ToList();
            BiotaAssetFile rootFile;
​
            if (fileList.Count > 0) {
                rootFile = fileList[0];
                fileList.RemoveAt(0);
​
            } else rootFile = new();
​
            packName = rootFile.name;
            packExtension = rootFile.extension;
            files = fileList.ToArray();
        }
        
​
    }
​
    [Serializable]
    public class BiotaAssetFile {
        public string name;
        public string extension;
        public string contents;
    }
​
public static class Serializer {
    
        public static int FileSize(string input) {
            byte[] bytes = UnicodeEncoding.UTF8.GetBytes(input);
            return bytes.Length;
        }
    
        public static string CompressString(string input) {
            byte[] bytes = UnicodeEncoding.UTF8.GetBytes(input);
            var resultBytes = CompressBytes(bytes);
​
            return Convert.ToBase64String(resultBytes);
        }
​
        public static string DecompressString(string input) {
            byte[] bytes = Convert.FromBase64String(input);
            var resultBytes = DecompressBytes(bytes);
                
            var chars = UnicodeEncoding.UTF8.GetChars(resultBytes);
            return new(chars);
        }
​
        public static byte[] CompressBytes(byte[] input) {
            using (var source = new MemoryStream(input))
            using (var result = new MemoryStream()) {
                using (var Compress = new GZipStream(result, CompressionMode.Compress)) {
                    source.CopyTo(Compress);
                }
                return result.ToArray();
            }
        }
​
        public static byte[] DecompressBytes(byte[] input) {
            using (var source = new MemoryStream(input))
            using (var result = new MemoryStream()) {
                using (var Decompress = new GZipStream(source, CompressionMode.Decompress)) {
                    Decompress.CopyTo(result);
                }
                return result.ToArray();
            }
        }
    
​
        public static string ToSingleString(this byte[] bytes)
            => UnicodeEncoding.UTF8.GetChars(bytes).ToString();
​
    public static byte[] ToByteArray(this string input) 
        => UnicodeEncoding.UTF8.GetBytes(input);
    
    public static string ToJson<T>(T value, bool format = true)
        => ToJson(typeof(T), value, format ? Formatting.Indented : Formatting.None);
​
    public static string ToJson(Type t, object value, Formatting formatting = Formatting.Indented) {
        JsonSerializer jsonSerializer = JsonSerializer.CreateDefault(new());
        jsonSerializer.Formatting = formatting;
​
        StringBuilder sb = new StringBuilder(256);
        StringWriter sw = new StringWriter(sb, CultureInfo.InvariantCulture);
​
        using (JsonTextWriter jsonWriter = new JsonTextWriter(sw)) {
​
            jsonWriter.Formatting = jsonSerializer.Formatting;
            jsonSerializer.Serialize(jsonWriter, value, t);
        }
​
        return sw.ToString();
    }
    
    public static T FromJson<T>(string value)
        => (T)FromJson(typeof(T), value);
    
    public static object FromJson(Type t, string value) {
        JsonSerializer jsonSerializer = JsonSerializer.CreateDefault();
        jsonSerializer.CheckAdditionalContent = false;
​
        using (JsonTextReader reader = new JsonTextReader(new StringReader(value)) { SupportMultipleContent = false }) {
            return jsonSerializer.Deserialize(reader, t);
        }
    }   
}
​
public interface IIdentifier { string Read(); }
public struct Label : IIdentifier { public string label; public string Read() => label; }
​
public interface IArchivable<T> 
    where T : IIdentifier 
    { T GetID(); }
​
public abstract class ArchivableAsset<T> : IArchivable<T>
    where T : IIdentifier 
    { public abstract T GetID(); public abstract string GetValue(); }
​
[Serializable]
public class DataAsset : ArchivableAsset<Label> { 
    
    [JsonProperty] private Label label;
    [JsonProperty] private string[] values;
    
    public DataAsset() { }
    
    public DataAsset(Label label, params string[] values) {
        this.label = label; 
        this.values = values;
    }
    
    public DataAsset(string label, params string[] values) {
        this.label = new() {
            label = label
        };      
        this.values = values;
    }
    
    public override Label GetID() {
        return label;
    }
    
    public override string GetValue()
        => values[0];
}
​
public static class DataArchive<Tid, Tobj>
    where Tid : IIdentifier
    where Tobj : ArchivableAsset<Tid> {
    
    static DataArchive() {
        Type t = typeof(Tobj);
        Logger.WriteLine($"Created an Archive for {t.Name}.");  
        saved = new();
        ids = new();
    }
    
    private static Dictionary<string, Tobj> saved;
    private static List<string> ids;
    
    public static void Add(Tobj obj) {
        string id = obj.GetID().Read();
        saved.Add(id, obj);
        ids.Add(id);
    }
    
    public static Tobj[] Load() {
        
        Tobj[] array = new Tobj[saved.Count];
        
        for (int i = 0; i < saved.Count; i++) {
            array[i] = saved[ids[i]];
        }
            
        return array;
    }
}
​
public static class DataStreamer {
​
    static DataStreamer() {
        
        var assemblies = AppDomain.CurrentDomain.GetAssemblies();
        List<Type> dataFileTypes = new();
​
        var dataArchive = typeof(DataArchive<,>);
        var loadMethod = dataArchive.GetMethod("Load", 2, BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, new Type[0]);
        
        var target = typeof(ArchivableAsset<>);
        var valueMethod = target.GetMethod("GetValue", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
        var idMethod = target.GetMethod("GetID", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
​
        foreach (var assembly in assemblies) {
            dataFileTypes.AddRange(
                assembly.GetTypes()
                .Where((x) => { 
                    if (!x.IsGenericType) return false;
                    
                    var genericType = x.GetGenericTypeDefinition();
                    
                    if (genericType != null) {
                        if (target.IsAssignableFrom(genericType)) {
                            Console.WriteLine(genericType.Name);
                            return true;
                        }
                        return false;
                    }
                    return false;
                })
            );
        }   
        
        for (int i = 0; i < dataFileTypes.Count; i++) {
        
            Type[] generics = dataFileTypes[i].GenericTypeArguments;
            if (generics == null) Console.WriteLine("Null generic arguments");
            Type idType = generics.Length > 0 ? generics[0] : null;
            string genericName = generics.Length > 0 ? generics[0].Name : "";
            
            Logger.WriteLine($"DataStreamer - Located ArchivableAsset of the type {dataFileTypes[i].Name}, implementing the IIdentifier type '{genericName}'");
            
            var properLoadMethod = loadMethod.MakeGenericMethod(idType,dataFileTypes[i]);
            var properIdMethod = idMethod.MakeGenericMethod(idType);
            var savedInArchive = (Array)properLoadMethod.Invoke(null, new object[0]);
            
            for (int j = 0; j < savedInArchive.Length; j++) {
                var archiveEntry = savedInArchive.GetValue(j);
                
                float value = (float)valueMethod.Invoke(archiveEntry, new object[0]);
                IIdentifier id = (IIdentifier)properIdMethod.Invoke(archiveEntry, new object[0]);
                
                Logger.WriteLine($"\tThe {dataFileTypes[i].Name} instance named {id.Read()} has a value of {value}.");
            }
        }
    }
    
    public static void Stream() {
            
    }
    
}
​
public static class Logger {
    
    static int _width = 96;
    static int _height = 1024;
    
    public static int Width => _width;
    public static int Height => _height;
    public static int Spacing = 1;
    public static int Padding = 2;
    
    public class Column {
    
        public readonly int width;
        public int height;
        public List<List<char>> logs;
    
        int xStart { get => padClamp; }
        int xMax { get => width - padClamp; }
        int colMax { get => column.width - padClamp; }
        
        int padClamp { get => Math.Clamp(Padding, 0, (int)Math.Round((double)width * 0.5)); }
        
        int yAdvance { get => 1 + Math.Max(Spacing, 0); }
        
        readonly List<char> emptyLineList;
        
        public int x { get; private set; }
        public int y { get; private set; }
        public int realY { get; private set; }
        
        public bool complete { get; private set; }
        
        public Column(int width, int height) {
            
            this.width = width;
            this.height = height;
            
            Reset();
            
            emptyLineList = new();
            foreach(var ch in emptyLine)
                emptyLineList.Add(ch);
            
            logs = new();
            NewLine();
        }
        
        void Reset() {
            x = xStart;
            y = 0;
            realY = 0;
        }
        
        public void Clear() {
            Reset();
            
            complete = false;
            
            logs.Clear();
            NewLine();
        }
        
        public bool Down() {
            AdvanceY();
            
            UpdateLogs();
            
            complete = ReachedEnd();
            
            return complete;
        }
        
        void NewLine() {
            var newLine = new List<char>();
            newLine.AddRange(emptyLineList);
            logs.Add(newLine);
        }
        
        void UpdateLogs() {
            while (realY >= logs.Count - 1) {
                NewLine();
            }
        }
        
        void AdvanceY() {
            x = xStart;
            y++;
            realY += yAdvance;
        }
        
        bool ReachedEnd() => realY >= height;
        
        
        public bool Write(string text, out string remaining) {
            remaining = text;
            
            if (complete) return complete;
            
            if (x + 1 >= colMax) {
                AdvanceY();
            }
            
            UpdateLogs();
            
            if (ReachedEnd()) {
                complete = true;
                return complete;
            }
            
            List<string> chunks = new();
            bool wasSpace = false;
            string chunk = "";
            for (int i = 0; i < text.Length; i++) {
                if (text[i] == ' ') {
                    if (wasSpace)
                        chunk += ' ';
                    else {
                        chunks.Add(chunk);
                        chunk = " ";
                        wasSpace = true;
                    }
                
                } else {
                    if (wasSpace) {
                        if (chunk.Length > 1) {
                            chunks.Add(chunk);
                            chunk = "";
                        }
                        chunk = "";
                        wasSpace = false;
                    }
                    chunk += text[i];
                }
            }
            
            if (!wasSpace || chunk.Length > 1) chunks.Add(chunk);
            
            for (int p = 0; p < chunks.Count; p++) {
                string stem = p == chunks.Count - 1 ? "" : " ";
                
                WriteWord(chunks[p] + stem, remaining, out remaining);
                    
                if (complete) return complete;
            }
            
            return complete;
        }
        
        private void WriteWord(string text, string all, out string remaining) {
            
            remaining = all;
                
            if (x + text.Length > colMax) {
                AdvanceY();
            }
​
            if (ReachedEnd()) {
                complete = true;
                return;
            }
​
            for (int i = 0; i < text.Length; i++) {
                char ch = text[i];
​
                if (ch == '\n') {
                    AdvanceY();
​
                } else if (ch == '\t') {
                    for (int t = 0; t < 4; t++) {
                        x++;    
​
                        if (x >= xMax) {
                            AdvanceY();
                        }
                    }
​
                } else {
​
                    if (x >= xMax) {
                        AdvanceY();
                    }
                    
                    UpdateLogs();
​
                    logs[realY][x] = ch;
​
                    x++;
​
                    if (x >= xMax) {
                        AdvanceY();
                    }
                }
​
                remaining = remaining.Prim();
​
                if (ReachedEnd()) {
                    complete = true;
                    return;
                }
            }
        }
    }
    
    static string emptyLine;
    
    static (int width, int height) column;
    static Column writer;
    static List<List<char>> final; 
    
    static string headingLine;
    static readonly string dottedLine = "- --- -";
    static bool started;
    
    static Logger() {
        final = new List<List<char>>();
        cols = new();
        
        SetupColumn();
    }
    
    public static void Header(string header, bool centered = true) {
        NextColumn();
        WriteLine();
        int headerLength = header.Length;
        
        string offset = "";
        
        if(centered) {
            int half = (int)MathF.Round((float)column.width * 0.5f - (float)headerLength * 0.5f - 2);
            
            for (int i = 0; i < half; i++) 
                offset += " ";
        }
        
        WriteLine($"{offset}{header}");
        
        Write(headingLine);
    }
    
    static void SetupColumn() {
        column = (_width, _height);
            
        emptyLine = "";
        headingLine = "";
        for (int i = 0, l = 0; i < column.width; i++, l = (l + 1) % dottedLine.Length) {
            emptyLine += ' ';
            
            if (i < Padding || i >= column.width - Padding) { }
            else
                headingLine += dottedLine[l];
        }
        
        writer = new(column.width, column.height);
        
        started = false;
    }
    
    static List<(int, int)> cols;
    
    
    public static void WriteRandom(string stem = "", int words = -1) {
        var rand = new Random();
        
        if (words <= 0)
            words = rand.Next(12, 64);
        
        int available = words;
        
        string text = $"\t{stem} : \n\t";
        
        const int commaChance_OneIn = 6;
        
        while (available > 0) {
            int sentenceLength = rand.Next(3, 16);
            
            if (sentenceLength > available) sentenceLength = available;
            available -= sentenceLength;
            
            for (int s = 0; s < sentenceLength; s++) {
                int letters = rand.Next(2, 8);
                
                bool firstWord = s == 0;
                bool lastWord = s == sentenceLength - 1;
                
                for (int l = 0; l < letters; l++) {
                    int start, end;
​
                    if (firstWord && l == 0) {
                        start = 65;
                        end = 90;
                    } else {
                        start = 97;
                        end = 122;
                    }
​
                    char letter = (char)rand.Next(start, end + 1);
                    
                    text += letter;
                }
                    
                if (!lastWord
                    && rand.Next(0, commaChance_OneIn) == 1) {
                    text += ',';
                }
                
                if (!lastWord)
                    text += ' '; 
            }
            
            text += ". ";   
        }
        
        WriteLine();
        Write(text);
    }
    
    public static void WriteLine(string text = "") {
        Write(text);
        NextLine();
    }
    
    public static void Write(string text) {
        text ??= "";
        if (text == "") return;
        started = true;
        if (writer.Write(text, out string remaining)) {
            NextColumn();
            writer.Write(remaining, out string _);
        }
    }
    
    public static void NextLine() {
        if (writer.Down()) {
            NextColumn();   
        }
    }
    
    public static void NextColumn() {
        NextColumn(_width, _height);
    }
    
    public static void NextColumnWithWidth(int width) {
        NextColumn(width, _height);
    }
    
    public static void NextColumnWithHeight(int height) {
        NextColumn(_width, height);
    }
    
    public static void NextColumn(int width, int height) {
        if (!started) return;
        
        CommitWriterToFinal();
        
        _width = width;
        _height = height;
        
        padded = false;
        
        if (writer.y != 0)
            cols.Add(column);
        
        SetupColumn();
    }
    
    static void AddLineToLog(int i) {
        var newLine = new List<char>();
​
        for (int ci = 0; ci < cols.Count; ci++) {
            int cWidth = cols[ci].Item1;
            int cHeight = cols[ci].Item2;
​
            char space = cHeight < column.height ? '-' : ' ';
            char divider = cHeight < column.height ? '-' : '|';
​
            char priorDivider = '|';
            bool isPriorCol = ci == cols.Count - 1;
​
            if (i > cHeight) {
                space = ' ';
                divider = ' ';
            }
​
            if (ci == 0) newLine.Add(divider);
​
            for (int cx = 0; cx < cWidth; cx++)
                newLine.Add(space);
​
            newLine.Add(isPriorCol ? priorDivider : divider);
        }
        
        final.Add(newLine);
    }
    
    static void AddPreviousUnderline() {
        if (final.Count <= column.height) final.Add(new());
                
        List<char> fullLine = new();
​
        fullLine.AddRange(final[column.height]);
​
        int start = fullLine.Count;
        int lx = 0;
​
        for (int ci = 0; ci < cols.Count; ci++) {
            for (int cx = 0; cx <= cols[ci].Item1; cx++) {
                if (lx >= start) fullLine.Add(' ');
                lx++;
            }
        }
​
        fullLine.Add('-');
​
        for (int x = 0; x < column.width; x++)
            fullLine.Add('-');
​
        fullLine.Add('-');
​
        final[column.height] = fullLine;
        final.Add(new List<char>());
    }
    
    static void CommitWriterToFinal(bool drawSeparator = true) {
    
        int y = writer.realY;
        
        if (y == 0) return;
        
        if (y < column.height)
            column.height = y;
        
        for (int i = 0; i < column.height; i++) {
            if (final.Count <= i) AddLineToLog(i);
            
            if (cols.Count == 0) final[i].Add('|');
            
            int currentLineLength = final[i].Count;
            int idealLineLength = 0;
            
            foreach(var col in cols) idealLineLength += col.Item1 + 1;
            
            if (currentLineLength < idealLineLength) {
                int mark = idealLineLength;
                
                for (int l = currentLineLength; l < idealLineLength; l++) {
                    final[i].Add(' ');
                }
                
                final[i].Add('|');
            }
            
            if (cols.Count > 0) {
                if (i == cols[cols.Count - 1].Item2) {
                    final[i][final[i].Count - 1] = '|'; 
                }
            }
​
            string str = i < y
                ? new string(writer.logs[i].ToArray())
                : emptyLine;
​
            final[i].AddRange(str);
​
            if (drawSeparator) final[i].Add('|');
        }
        
        var underline = new List<char>();
        for (int i = 0; i < column.width; i++) 
            underline.Add('-');
                
        if (cols.Count > 0) {
            var prevHeight = cols[cols.Count - 1].Item2;
            
            if (column.height != prevHeight)
                underline.Add('|');
            else underline.Add('-');
            
            if (column.height <= prevHeight) {
                int underIndex = Math.Min(final.Count, column.height);
                final[underIndex].AddRange(underline);
                
            } else if (column.height > prevHeight) 
                AddPreviousUnderline();
                
        } else {
            underline.Insert(0, '|');
            underline.Add('|');
            final.Add(underline);
        }
    }
    
    static bool padded = false;
    
    public static void Read() {
        
        if (final.Count == 0) return;
        
        int size = final[0].Count;
            
        if (writer.y > 0) size += column.width + 1;
        if (padded) size++;
        
        CommitWriterToFinal(true);
        
        char[] topLine = new char[0];
        char[] bottomLine = new char[0];
        
        if (final.Count > 0) {
            topLine = new char[size];
            
            for (int i = 0; i < size; i++) 
                topLine[i] = '-';
        }
        
        string _topLine = new string(topLine);
        
        Console.WriteLine(_topLine);
        
        for (int i = 0; i < final.Count; i++) {
            var str = final[i].ToArray();
            var _str = new string(str);
            
            Console.WriteLine(_str);
        }
    }
    
    public static string Prim(this string str)
        => str.Length > 2 ? str.Substring(1, str.Length - 1) : "";
}

Enter the size of the array:

Cached Result
Last Run:	12:52:22 pm
Compile:	0.01s
Execute:	0.05s
Memory:	3.22Mb
CPU:	0.06s

View IL Code