/// <summary> /// Writes a the bytecode of a Ndf file into outStream. /// </summary> /// <param name="outStream">The Stream in wich the data has to be written in.</param> /// <param name="ndf">The ndf file which has to be compiled.</param> /// <param name="compressed">Sets wether the bytecode has to be compressed or not.</param> public void Write(Stream outStream, NdfBinary ndf, bool compressed) { uint compressedFlag = compressed ? 128 : 0u; outStream.Write(BitConverter.GetBytes(EugenMagic), 0, 4); outStream.Write(BitConverter.GetBytes((uint)0), 0, 4); outStream.Write(BitConverter.GetBytes(NdfBinMagic), 0, 4); outStream.Write(BitConverter.GetBytes(compressedFlag), 0, 4); var data = GetCompiledContent(ndf); outStream.Write(BitConverter.GetBytes(ndf.Footer.Offset), 0, 8); outStream.Write(BitConverter.GetBytes(NdfbinHeaderSize), 0, 8); outStream.Write(BitConverter.GetBytes(NdfbinHeaderSize + (ulong)data.Length), 0, 8); if (compressed) { outStream.Write(BitConverter.GetBytes(data.Length), 0, 4); //Compressor.Comp(data, outStream); var da = Compressor.Comp(data); outStream.Write(da,0,da.Length); } else outStream.Write(data, 0, data.Length); }
public NdfEditorMainViewModel(NdfBinary ndf) { NdfBinary = ndf; InitializeNdfEditor(); SaveNdfbinCommand = new ActionCommand(SaveNdfbinExecute, () => false); }
public byte[] Write(NdfBinary ndf, bool compressed) { using (var ms = new MemoryStream()) { Write(ms, ndf, compressed); return ms.ToArray(); } }
public AddCollectionItemViewModel(NdfBinary mgr, Window view) { Manager = mgr; View = view; OkCommand = new ActionCommand(OkCommandExecute, () => Type != NdfType.Unset); CancelCommand = new ActionCommand(CancelCommandExecute); _typeSelection.AddRange(NdfTypeManager.GetTypeSelection()); }
protected byte[] GetCompiledContent(NdfBinary ndf) { var footer = new NdfFooter(); const long headerSize = (long)NdfbinHeaderSize; using (var contentStream = new MemoryStream()) { byte[] buffer = RecompileObj(ndf); footer.AddEntry("OBJE", contentStream.Position + headerSize, buffer.Length); contentStream.Write(buffer, 0, buffer.Length); buffer = RecompileTopo(ndf); footer.AddEntry("TOPO", contentStream.Position + headerSize, buffer.Length); contentStream.Write(buffer, 0, buffer.Length); buffer = RecompileChnk(ndf); footer.AddEntry("CHNK", contentStream.Position + headerSize, buffer.Length); contentStream.Write(buffer, 0, buffer.Length); buffer = RecompileClas(ndf); footer.AddEntry("CLAS", contentStream.Position + headerSize, buffer.Length); contentStream.Write(buffer, 0, buffer.Length); buffer = RecompileProp(ndf); footer.AddEntry("PROP", contentStream.Position + headerSize, buffer.Length); contentStream.Write(buffer, 0, buffer.Length); buffer = RecompileStrTable(ndf.Strings); footer.AddEntry("STRG", contentStream.Position + headerSize, buffer.Length); contentStream.Write(buffer, 0, buffer.Length); buffer = RecompileStrTable(ndf.Trans); footer.AddEntry("TRAN", contentStream.Position + headerSize, buffer.Length); contentStream.Write(buffer, 0, buffer.Length); buffer = RecompileUIntList(ndf.Import); footer.AddEntry("IMPR", contentStream.Position + headerSize, buffer.Length); contentStream.Write(buffer, 0, buffer.Length); buffer = RecompileUIntList(ndf.Export); footer.AddEntry("EXPR", contentStream.Position + headerSize, buffer.Length); contentStream.Write(buffer, 0, buffer.Length); buffer = footer.GetBytes(); footer.Offset = (ulong)contentStream.Position + NdfbinHeaderSize; contentStream.Write(buffer, 0, buffer.Length); ndf.Footer = footer; return contentStream.ToArray(); } }
public NdfBinary Read(byte[] data) { var ndf = new NdfBinary(); using (var ms = new MemoryStream(data)) { ndf.Header = ReadHeader(ms); if (ndf.Header.IsCompressedBody) { using (var uncompStream = new MemoryStream()) { ms.Seek(0, SeekOrigin.Begin); var headBuffer = new byte[ndf.Header.HeaderSize]; ms.Read(headBuffer, 0, headBuffer.Length); uncompStream.Write(headBuffer, 0, headBuffer.Length); ms.Seek((long)ndf.Header.HeaderSize, SeekOrigin.Begin); var buffer = new byte[4]; ms.Read(buffer, 0, buffer.Length); uint compressedblocklen = BitConverter.ToUInt32(buffer, 0); var contentBuffer = new byte[(ulong)(data.Length) - ndf.Header.HeaderSize]; ms.Read(contentBuffer, 0, contentBuffer.Length); var da = Compressor.Decomp(contentBuffer); uncompStream.Write(da, 0, da.Length); data = uncompStream.ToArray(); } } } using (var ms = new MemoryStream(data)) { ndf.Footer = ReadFooter(ms, ndf.Header); ndf.Classes = ReadClasses(ms, ndf); ReadProperties(ms, ndf); ndf.Strings = ReadStrings(ms, ndf); ndf.Trans = ReadTrans(ms, ndf); ndf.TopObjects = new HashSet<uint>(ReadUIntList(ms, ndf, "TOPO")); ndf.Import = ReadUIntList(ms, ndf, "IMPR"); ndf.Export = ReadUIntList(ms, ndf, "EXPR"); ndf.Instances = ReadObjects(ms, ndf); } return ndf; }
public ListEditorViewModel(NdfCollection collection, NdfBinary mgr) { if (collection == null) throw new ArgumentNullException("collection"); if (mgr == null) throw new ArgumentNullException("mgr"); _collection = collection; _ndfbinManager = mgr; DetailsCommand = new ActionCommand(DetailsCommandExecute); AddRowCommand = new ActionCommand(AddRowExecute); AddRowOfCommonTypeCommand = new ActionCommand(AddRowOfCommonTypeExecute, AddRowOfCommonTypeCanExecute); DeleteRowCommand = new ActionCommand(DeleteRowExecute, DeleteRowCanExecute); }
public byte[] CreateNdfScript(NdfBinary ndf) { using (var ms = new MemoryStream()) { byte[] buffer = NdfTextEncoding.GetBytes(string.Format("// Handwritten by enohka \n// For real\n\n\n")); ms.Write(buffer, 0, buffer.Length); foreach (NdfObject instance in ndf.Instances.Where(x => x.IsTopObject)) { buffer = instance.GetNdfText(); ms.Write(buffer, 0, buffer.Length); } return ms.ToArray(); } }
protected byte[] RecompileChnk(NdfBinary ndf) { var chnk = new List<byte>(); chnk.AddRange(BitConverter.GetBytes((uint)0)); chnk.AddRange(BitConverter.GetBytes(ndf.Instances.Count)); return chnk.ToArray(); }
public NdfClass(NdfBinary mgr, uint id) { Manager = mgr; Id = id; }
/// <summary> /// Reads the value of a Property inside a object instance. /// </summary> /// <param name="ms"></param> /// <param name="binary"></param> /// <returns>A NdfValueWrapper Instance.</returns> protected NdfValueWrapper ReadValue(Stream ms, NdfBinary binary) { uint contBufferlen; NdfValueWrapper value; var buffer = new byte[4]; ms.Read(buffer, 0, buffer.Length); NdfType type = NdfTypeManager.GetType(buffer); if (type == NdfType.Unknown) throw new InvalidDataException("Unknown datatypes are not supported!"); if (type == NdfType.Reference) { ms.Read(buffer, 0, buffer.Length); type = NdfTypeManager.GetType(buffer); } switch (type) { case NdfType.WideString: case NdfType.List: case NdfType.MapList: case NdfType.Blob: case NdfType.ZipBlob: ms.Read(buffer, 0, buffer.Length); contBufferlen = BitConverter.ToUInt32(buffer, 0); if (type == NdfType.ZipBlob) if (ms.ReadByte() != 1) throw new InvalidDataException("has to be checked."); break; default: contBufferlen = NdfTypeManager.SizeofType(type); break; } switch (type) { case NdfType.MapList: case NdfType.List: NdfCollection lstValue = type == NdfType.List ? new NdfCollection() : new NdfMapList(); for (int i = 0; i < contBufferlen; i++) { CollectionItemValueHolder res; if (type == NdfType.List) res = new CollectionItemValueHolder(ReadValue(ms, binary), binary); else res = new CollectionItemValueHolder( new NdfMap( new MapValueHolder(ReadValue(ms, binary), binary), new MapValueHolder(ReadValue(ms, binary), binary), binary), binary); lstValue.Add(res); } value = lstValue; break; case NdfType.Map: value = new NdfMap( new MapValueHolder(ReadValue(ms, binary), binary), new MapValueHolder(ReadValue(ms, binary), binary), binary); break; default: var contBuffer = new byte[contBufferlen]; ms.Read(contBuffer, 0, contBuffer.Length); value = NdfTypeManager.GetValue(contBuffer, type, binary); break; } return value; }
protected byte[] RecompileClas(NdfBinary ndf) { var clasData = new List<byte>(); foreach (var clas in ndf.Classes.OrderBy(x => x.Id)) { var nameData = Encoding.GetEncoding("ISO-8859-1").GetBytes(clas.Name); clasData.AddRange(BitConverter.GetBytes(nameData.Length)); clasData.AddRange(nameData); } return clasData.ToArray(); }
protected byte[] RecompileProp(NdfBinary ndf) { var propData = new List<byte>(); var props = new List<NdfProperty>(); foreach (var clas in ndf.Classes) props.AddRange(clas.Properties); foreach (var prop in props.OrderBy(x => x.Id)) { var nameData = Encoding.GetEncoding("ISO-8859-1").GetBytes(prop.Name); propData.AddRange(BitConverter.GetBytes(nameData.Length)); propData.AddRange(nameData); propData.AddRange(BitConverter.GetBytes(prop.Class.Id)); } return propData.ToArray(); }
/// <summary> /// Reads a list of UInt32, this is needed for the topobjects, import and export tables. /// </summary> /// <param name="ms"></param> /// <param name="owner"></param> /// <param name="lst"></param> /// <returns></returns> protected List<uint> ReadUIntList(Stream ms, NdfBinary owner, string lst) { var uintList = new List<uint>(); NdfFooterEntry uintEntry = owner.Footer.Entries.Single(x => x.Name == lst); ms.Seek(uintEntry.Offset, SeekOrigin.Begin); var buffer = new byte[4]; while (ms.Position < uintEntry.Offset + uintEntry.Size) { ms.Read(buffer, 0, buffer.Length); uintList.Add(BitConverter.ToUInt32(buffer, 0)); } return uintList; }
/// <summary> /// Reads the Properties dictionary and relates each one to its owning class. /// </summary> /// <param name="ms"></param> /// <param name="owner"></param> protected void ReadProperties(Stream ms, NdfBinary owner) { NdfFooterEntry propEntry = owner.Footer.Entries.Single(x => x.Name == "PROP"); ms.Seek(propEntry.Offset, SeekOrigin.Begin); int i = 0; var buffer = new byte[4]; while (ms.Position < propEntry.Offset + propEntry.Size) { var property = new NdfProperty(i); ms.Read(buffer, 0, buffer.Length); int strLen = BitConverter.ToInt32(buffer, 0); var strBuffer = new byte[strLen]; ms.Read(strBuffer, 0, strBuffer.Length); property.Name = Encoding.GetEncoding("ISO-8859-1").GetString(strBuffer); ms.Read(buffer, 0, buffer.Length); NdfClass cls = owner.Classes.Single(x => x.Id == BitConverter.ToUInt32(buffer, 0)); property.Class = cls; cls.Properties.Add(property); i++; } }
public MapValueHolder(NdfValueWrapper value, NdfBinary manager) : base(value, manager) { }
public void Write(Stream outStrea, NdfBinary ndf, bool compressed) { throw new NotImplementedException(); }
protected byte[] RecompileObj(NdfBinary ndf) { var objectPart = new List<byte>(); byte[] objSep = { 0xAB, 0xAB, 0xAB, 0xAB }; foreach (NdfObject instance in ndf.Instances) { objectPart.AddRange(BitConverter.GetBytes(instance.Class.Id)); foreach (NdfPropertyValue propertyValue in instance.PropertyValues) { if (propertyValue.Type == NdfType.Unset) continue; byte[] valueBytes = propertyValue.Value.GetBytes(); if (propertyValue.Value.Type == NdfType.Unset) continue; objectPart.AddRange(BitConverter.GetBytes(propertyValue.Property.Id)); if (propertyValue.Value.Type == NdfType.ObjectReference || propertyValue.Value.Type == NdfType.TransTableReference) objectPart.AddRange(BitConverter.GetBytes((uint)NdfType.Reference)); objectPart.AddRange(BitConverter.GetBytes((uint)propertyValue.Value.Type)); objectPart.AddRange(valueBytes); } objectPart.AddRange(objSep); } return objectPart.ToArray(); }
/// <summary> /// Reads the Classes dictionary. /// </summary> /// <param name="ms"></param> /// <param name="owner"></param> /// <returns></returns> protected ObservableCollection<NdfClass> ReadClasses(Stream ms, NdfBinary owner) { var classes = new ObservableCollection<NdfClass>(); NdfFooterEntry classEntry = owner.Footer.Entries.Single(x => x.Name == "CLAS"); ms.Seek(classEntry.Offset, SeekOrigin.Begin); uint i = 0; var buffer = new byte[4]; while (ms.Position < classEntry.Offset + classEntry.Size) { var nclass = new NdfClass(owner, i); ms.Read(buffer, 0, buffer.Length); int strLen = BitConverter.ToInt32(buffer, 0); var strBuffer = new byte[strLen]; ms.Read(strBuffer, 0, strBuffer.Length); nclass.Name = Encoding.GetEncoding("ISO-8859-1").GetString(strBuffer); i++; classes.Add(nclass); } return classes; }
/// <summary> /// Reads the amount of instances this file contains. /// </summary> /// <param name="ms"></param> /// <param name="owner"></param> /// <returns></returns> protected uint ReadChunk(Stream ms, NdfBinary owner) { NdfFooterEntry chnk = owner.Footer.Entries.Single(x => x.Name == "CHNK"); ms.Seek(chnk.Offset, SeekOrigin.Begin); var buffer = new byte[4]; ms.Read(buffer, 0, buffer.Length); ms.Read(buffer, 0, buffer.Length); return BitConverter.ToUInt32(buffer, 0); }
public CollectionItemValueHolder(NdfValueWrapper value, NdfBinary manager) { Value = value; Manager = manager; }
/// <summary> /// Reads the string list. /// </summary> /// <param name="ms"></param> /// <param name="owner"></param> /// <returns></returns> protected ObservableCollection<NdfStringReference> ReadStrings(Stream ms, NdfBinary owner) { var strings = new ObservableCollection<NdfStringReference>(); NdfFooterEntry stringEntry = owner.Footer.Entries.Single(x => x.Name == "STRG"); ms.Seek(stringEntry.Offset, SeekOrigin.Begin); int i = 0; var buffer = new byte[4]; while (ms.Position < stringEntry.Offset + stringEntry.Size) { var nstring = new NdfStringReference { Id = i }; ms.Read(buffer, 0, buffer.Length); int strLen = BitConverter.ToInt32(buffer, 0); var strBuffer = new byte[strLen]; ms.Read(strBuffer, 0, strBuffer.Length); nstring.Value = Encoding.GetEncoding("ISO-8859-1").GetString(strBuffer); i++; strings.Add(nstring); } return strings; }
/// <summary> /// Reads the trans list /// </summary> /// <param name="ms"></param> /// <param name="owner"></param> /// <returns></returns> protected ObservableCollection<NdfTranReference> ReadTrans(Stream ms, NdfBinary owner) { var trans = new ObservableCollection<NdfTranReference>(); NdfFooterEntry stringEntry = owner.Footer.Entries.Single(x => x.Name == "TRAN"); ms.Seek(stringEntry.Offset, SeekOrigin.Begin); int i = 0; var buffer = new byte[4]; while (ms.Position < stringEntry.Offset + stringEntry.Size) { var ntran = new NdfTranReference { Id = i }; ms.Read(buffer, 0, buffer.Length); int strLen = BitConverter.ToInt32(buffer, 0); var strBuffer = new byte[strLen]; ms.Read(strBuffer, 0, strBuffer.Length); ntran.Value = Encoding.GetEncoding("ISO-8859-1").GetString(strBuffer); i++; trans.Add(ntran); } // TODO: Trans is actually more a tree than a list, this is still not fully implemented/reversed. return trans; }
/// <summary> /// Reads one object instance. /// </summary> /// <param name="ms"></param> /// <param name="index"></param> /// <param name="owner"></param> /// <returns></returns> protected NdfObject ReadObject(Stream ms, uint index, NdfBinary owner) { var instance = new NdfObject { Id = index }; if (owner.TopObjects.Contains(index)) instance.IsTopObject = true; var buffer = new byte[4]; ms.Read(buffer, 0, buffer.Length); int classId = BitConverter.ToInt32(buffer, 0); if (owner.Classes.Count < classId) throw new InvalidDataException("Object without class found."); NdfClass cls = instance.Class = owner.Classes[classId]; cls.Instances.Add(instance); // Read properties for (; ; ) { ms.Read(buffer, 0, buffer.Length); uint propertyId = BitConverter.ToUInt32(buffer, 0); if (propertyId == 0xABABABAB) break; var propVal = new NdfPropertyValue(instance) { Property = cls.Properties.SingleOrDefault(x => x.Id == propertyId) }; if (propVal.Property == null) // throw new InvalidDataException("Found a value for a property which doens't exist in this class."); foreach (var c in owner.Classes) foreach (var p in c.Properties) if (p.Id == propertyId) { propVal.Property = p; break; } instance.PropertyValues.Add(propVal); NdfValueWrapper res = ReadValue(ms, owner); propVal.Value = res; } owner.AddEmptyProperties(instance); return instance; }
protected byte[] RecompileTopo(NdfBinary ndf) { using (var ms = new MemoryStream()) { List<NdfObject> topInsts = ndf.Instances.Where(x => x.IsTopObject).ToList(); //var writeInsts = new HashSet<NdfObject>(); //foreach (NdfObject inst in topInsts) //{ // if (writeInsts.Contains(inst)) // continue; // writeInsts.Add(inst); // int nextItemId = topInsts.IndexOf(inst) + 1; // if (topInsts.Count > nextItemId && topInsts[nextItemId].Class != inst.Class) // { // IEnumerable<NdfObject> othersOfSameClass = // topInsts.GetRange(nextItemId, topInsts.Count - nextItemId).Where( // x => x.Class == inst.Class && !writeInsts.Contains(x)); // foreach (NdfObject o in othersOfSameClass) // writeInsts.Add(o); // } //} var test = topInsts.OrderBy(x => x.Class.Id); foreach (NdfObject instance in test) { byte[] buffer = BitConverter.GetBytes(instance.Id); ms.Write(buffer, 0, buffer.Length); } return ms.ToArray(); } }
/// <summary> /// Reads the object instances. /// </summary> /// <param name="ms"></param> /// <param name="owner"></param> /// <returns></returns> protected List<NdfObject> ReadObjects(Stream ms, NdfBinary owner) { var objects = new List<NdfObject>(); uint instanceCount = ReadChunk(ms, owner); NdfFooterEntry objEntry = owner.Footer.Entries.Single(x => x.Name == "OBJE"); ms.Seek(objEntry.Offset, SeekOrigin.Begin); for (uint i = 0; i < instanceCount; i++) { long objOffset = ms.Position; NdfObject obj = ReadObject(ms, i, owner); obj.Offset = objOffset; objects.Add(obj); } return objects; }