/// <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;
try
{
NdfObject obj = ReadObject(ms, i, owner);
obj.Offset = objOffset;
objects.Add(obj);
}catch (Exception e)
{
throw e;
}
}
return(objects);
}
/// <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 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 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++;
}
}
/// <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 NdfMap(MapValueHolder key, MapValueHolder value, NdfBinary mgr)
: base(NdfType.Map, value)
{
Key = key;
Manager = mgr;
_typeSelection.AddRange(NdfTypeManager.GetTypeSelection());
}
public NdfMap(MapValueHolder key, MapValueHolder value, NdfBinary mgr)
: base(NdfType.Map, value)
{
Key = key;
Manager = mgr;
_typeSelection.AddRange(NdfTypeManager.GetTypeSelection());
}
public NdfEditorMainViewModel(NdfBinary ndf)
{
NdfBinary = ndf;
InitializeNdfEditor();
SaveNdfbinCommand = new ActionCommand(SaveNdfbinExecute, () => false);
}
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 byte[] Write(NdfBinary ndf, bool compressed)
{
using (var ms = new MemoryStream())
{
Write(ms, ndf, compressed);
return(ms.ToArray());
}
}
protected static NdfObject createNdfObject(NdfBinary data, string str)
{
var classView = data.Classes.Single(x => x.Name.Equals(str));
var inst = classView.Manager.CreateInstanceOf(classView, false);
classView.Instances.Add(inst);
//classView.Instances.Add(new NdfObjectViewModel(inst, data));
return(inst);
}
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 override void buildNdf(NdfBinary data, ref int i)
{
//return;
string name = "";
string ranking = "";
switch (type)
{
case IconType.CV:
name = "TGameDesignAddOn_StartingCommandUnit";
ranking = "StartingCommandUnits";
break;
case IconType.FOB:
name = "TGameDesignAddOn_StartingFOB";
ranking = "StartingFOB";
break;
}
var spawnPoint = createNdfObject(data, name);
/*var nameProperty = getProperty(spawnPoint, "Name");
* nameProperty.Value = getAutoName(data, i++);
* var rankingProperty = getProperty(spawnPoint, "Ranking");
* rankingProperty.Value = getString(data, ranking);
* var guidProperty = getProperty(spawnPoint, "GUID");
* rankingProperty.Value = new NdfGuid(Guid.NewGuid());*/
var allocationProperty = getProperty(spawnPoint, "AllocationPriority");
//NOT RIGHT
allocationProperty.Value = new NdfInt32(priority);
var designItem = createNdfObject(data, "TGameDesignItem");
var list = data.Classes.First().Instances.First().PropertyValues.First().Value as NdfCollection;
var ci = new CollectionItemValueHolder(new NdfObjectReference(designItem.Class, designItem.Id), data);
list.Add(ci);
var positionProperty = getProperty(designItem, "Position");
var hp = position.getPosition();
var p = Geometry.Geometry.convertPoint(hp);
positionProperty.Value = new NdfVector(p);
var rotationProperty = getProperty(designItem, "Rotation");
rotationProperty.Value = new NdfSingle(0f);
var addOnProperty = getProperty(designItem, "AddOn");
addOnProperty.Value = new NdfObjectReference(spawnPoint.Class, spawnPoint.Id);
}
/// <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));
}
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());
}
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());
}
}
public ZoneEditorData(ScenarioFile sf, string path)
{
scenarioFile = sf;
editor = new Editor(this, path);
data = sf.NdfBinary;
foreach (var area in sf.ZoneData.AreaManagers[1])
{
//var nodes=Geometry.getOutline(area.Content);
//var zone = new Outline(nodes);
//zoneOutlines.Add(zone);
zoneNumber++;
var zone = new Zone(editor, area);
scenarioItems.Add(zone);
zones.Add(zone);
editor.addScenarioItem(zone);
Console.WriteLine("name:");
Console.WriteLine(area.Name);
Console.WriteLine("en name");
/*Console.WriteLine("zone\n");
* foreach (var c in area.Content.ClippedAreas)
* {
* Console.Write("vertices=[");
* var scen = area.Content;
* foreach (var v in scen.Vertices.GetRange(c.StartVertex,c.VertexCount))
* {
* Console.WriteLine("{0:G},{1:G},{2:G};", (int)v.X, (int)v.Y, (int)v.Center);
* }
* Console.WriteLine("]");
*
* Console.Write("tri=[");
* foreach (var v in scen.Triangles.GetRange(c.StartTriangle,c.TriangleCount))
* {
* Console.WriteLine("{0},{1},{2};", (int)v.Point1, (int)v.Point2, (int)v.Point3);
* }
* Console.WriteLine("]");
* }*/
}
doZoneProperties();
Application.EnableVisualStyles();
Application.Run(editor);
//Application.SetCompatibleTextRenderingDefault(false);
}
/// <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);
}
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);
}
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());
}
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());
}
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());
}
}
public NdfDatabase(string fileName)
{
string everythingNdfbinPattern = @".*everything.ndfbin";
Regex regex = new Regex(everythingNdfbinPattern, RegexOptions.IgnoreCase);
var ndfbinReader = new NdfbinReader();
var edataManager = new EdataManager(fileName);
edataManager.ParseEdataFile();
var everythingNdfbinRaw = edataManager.Files.Where(t => regex.IsMatch(t.ToString())).First();
everythingNdfbin = ndfbinReader.Read(edataManager.GetRawData(everythingNdfbinRaw));
tShowRoomDeckSerializer = everythingNdfbin.Classes.Where(cls => cls.Name == "TShowRoomDeckSerializer").First();
tUniteAuSolDescriptor = everythingNdfbin.Classes.Where(cls => cls.Name == "TUniteAuSolDescriptor").First();
tUniteDescriptor = everythingNdfbin.Classes.Where(cls => cls.Name == "TUniteDescriptor").First();
tTransportableModuleDescriptor = everythingNdfbin.Classes.Where(cls => cls.Name == "TTransportableModuleDescriptor").First();
tShowRoomDeckRuleManager = everythingNdfbin.Classes.Where(cls => cls.Name == "TShowRoomDeckRuleManager").First();
deckRulesManagerProperties = tShowRoomDeckRuleManager.Instances[0].PropertyValues;
}
protected static NdfFileNameString getString(NdfBinary data, string nameStr)
{
var nameRef = data.Strings.Single(x => x.Value.Equals(nameStr));
return(new NdfFileNameString(nameRef));
}
protected static NdfFileNameString getAutoName(NdfBinary data, int i)
{
var nameStr = string.Format("P0_AutoName_{0}", i);
return(getString(data, nameStr));
}
public static NdfValueWrapper GetValue(byte[] data, NdfType type, NdfBinary mgr)
{
//if (data.Length != SizeofType(type))
// return null;
switch (type)
{
case NdfType.Boolean:
return(new NdfBoolean(BitConverter.ToBoolean(data, 0)));
case NdfType.Int8:
return(new NdfInt8(data[0]));
case NdfType.Int16:
return(new NdfInt16(BitConverter.ToInt16(data, 0)));
case NdfType.UInt16:
return(new NdfUInt16(BitConverter.ToUInt16(data, 0)));
case NdfType.Int32:
return(new NdfInt32(BitConverter.ToInt32(data, 0)));
case NdfType.UInt32:
return(new NdfUInt32(BitConverter.ToUInt32(data, 0)));
case NdfType.Float32:
return(new NdfSingle(BitConverter.ToSingle(data, 0)));
case NdfType.Float64:
return(new NdfDouble(BitConverter.ToDouble(data, 0)));
case NdfType.TableStringFile:
int id = BitConverter.ToInt32(data, 0);
return(new NdfFileNameString(mgr.Strings[id]));
case NdfType.TableString:
int id2 = BitConverter.ToInt32(data, 0);
return(new NdfString(mgr.Strings[id2]));
case NdfType.Color32:
return(new NdfColor32(Color.FromArgb(data[3], data[0], data[1], data[2])));
case NdfType.Color128:
return(new NdfColor128(data));
case NdfType.Vector:
byte[] px = data.Take(4).ToArray();
byte[] py = data.Skip(4).Take(4).ToArray();
byte[] pz = data.Skip(8).ToArray();
return(new NdfVector(new Point3D(BitConverter.ToSingle(px, 0),
BitConverter.ToSingle(py, 0),
BitConverter.ToSingle(pz, 0))));
case NdfType.ObjectReference:
uint instId = BitConverter.ToUInt32(data.Take(4).ToArray(), 0);
uint clsId = BitConverter.ToUInt32(data.Skip(4).ToArray(), 0);
NdfClass cls = null;
// possible deadrefs here
if (clsId <= mgr.Classes.Count)
{
cls = mgr.Classes[(int)clsId];
}
return(new NdfObjectReference(cls, instId, cls == null));
case NdfType.Map:
return(new NdfMap(new MapValueHolder(null, mgr), new MapValueHolder(null, mgr), mgr));
case NdfType.Guid:
return(new NdfGuid(new Guid(data)));
case NdfType.WideString:
return(new NdfWideString(Encoding.Unicode.GetString(data)));
case NdfType.TransTableReference:
int id3 = BitConverter.ToInt32(data, 0);
return(new NdfTrans(mgr.Trans[id3]));
case NdfType.LocalisationHash:
return(new NdfLocalisationHash(data));
case NdfType.List:
return(new NdfCollection());
case NdfType.MapList:
return(new NdfMapList());
case NdfType.Blob:
return(new NdfBlob(data));
case NdfType.ZipBlob:
return(new NdfZipBlob(data));
case NdfType.EugInt2:
return(new NdfEugInt2(BitConverter.ToInt32(data, 0), BitConverter.ToInt32(data, 4)));
case NdfType.EugFloat2:
return(new NdfEugFloat2(BitConverter.ToSingle(data, 0), BitConverter.ToSingle(data, 4)));
case NdfType.TrippleInt:
return(new NdfTrippleInt(BitConverter.ToInt32(data, 0), BitConverter.ToInt32(data, 4), BitConverter.ToInt32(data, 8)));
case NdfType.Hash:
return(new NdfHash(data));
case NdfType.Time64:
return(new NdfTime64(new DateTime(1970, 1, 1).AddSeconds(BitConverter.ToUInt32(data, 0))));
case NdfType.Unset:
return(new NdfNull());
case NdfType.Bob:
return(new NdfTime64(new DateTime(1970, 1, 1).AddSeconds(BitConverter.ToUInt32(data, 0))));
default:
return(null);
}
}
public void Write(Stream outStrea, NdfBinary ndf, bool compressed)
{
throw new NotImplementedException();
}
public static NdfValueWrapper GetValue(byte[] data, NdfType type, NdfBinary mgr)
{
//if (data.Length != SizeofType(type))
// return null;
switch (type)
{
case NdfType.Boolean:
return new NdfBoolean(BitConverter.ToBoolean(data, 0));
case NdfType.Int8:
return new NdfInt8(data[0]);
case NdfType.Int16:
return new NdfInt16(BitConverter.ToInt16(data, 0));
case NdfType.UInt16:
return new NdfUInt16(BitConverter.ToUInt16(data, 0));
case NdfType.Int32:
return new NdfInt32(BitConverter.ToInt32(data, 0));
case NdfType.UInt32:
return new NdfUInt32(BitConverter.ToUInt32(data, 0));
case NdfType.Float32:
return new NdfSingle(BitConverter.ToSingle(data, 0));
case NdfType.Float64:
return new NdfDouble(BitConverter.ToDouble(data, 0));
case NdfType.TableStringFile:
int id = BitConverter.ToInt32(data, 0);
return new NdfFileNameString(mgr.Strings[id]);
case NdfType.TableString:
int id2 = BitConverter.ToInt32(data, 0);
return new NdfString(mgr.Strings[id2]);
case NdfType.Color32:
return new NdfColor32(Color.FromArgb(data[3], data[0], data[1], data[2]));
case NdfType.Color128:
return new NdfColor128(data);
case NdfType.Vector:
byte[] px = data.Take(4).ToArray();
byte[] py = data.Skip(4).Take(4).ToArray();
byte[] pz = data.Skip(8).ToArray();
return new NdfVector(new Point3D(BitConverter.ToSingle(px, 0),
BitConverter.ToSingle(py, 0),
BitConverter.ToSingle(pz, 0)));
case NdfType.ObjectReference:
uint instId = BitConverter.ToUInt32(data.Take(4).ToArray(), 0);
uint clsId = BitConverter.ToUInt32(data.Skip(4).ToArray(), 0);
NdfClass cls = null;
// possible deadrefs here
if (clsId <= mgr.Classes.Count)
cls = mgr.Classes[(int)clsId];
return new NdfObjectReference(cls, instId, cls == null);
case NdfType.Map:
return new NdfMap(new MapValueHolder(null, mgr), new MapValueHolder(null, mgr), mgr);
case NdfType.Guid:
return new NdfGuid(new Guid(data));
case NdfType.WideString:
return new NdfWideString(Encoding.Unicode.GetString(data));
case NdfType.TransTableReference:
int id3 = BitConverter.ToInt32(data, 0);
return new NdfTrans(mgr.Trans[id3]);
case NdfType.LocalisationHash:
return new NdfLocalisationHash(data);
case NdfType.List:
return new NdfCollection();
case NdfType.MapList:
return new NdfMapList();
case NdfType.Blob:
return new NdfBlob(data);
case NdfType.ZipBlob:
return new NdfZipBlob(data);
case NdfType.EugInt2:
return new NdfEugInt2(BitConverter.ToInt32(data, 0), BitConverter.ToInt32(data, 4));
case NdfType.EugFloat2:
return new NdfEugFloat2(BitConverter.ToSingle(data, 0), BitConverter.ToSingle(data, 4));
case NdfType.TrippleInt:
return new NdfTrippleInt(BitConverter.ToInt32(data, 0), BitConverter.ToInt32(data, 4), BitConverter.ToInt32(data, 8));
case NdfType.Hash:
return new NdfHash(data);
case NdfType.Time64:
return new NdfTime64(new DateTime(1970, 1, 1).AddSeconds(BitConverter.ToUInt32(data, 0)));
case NdfType.Unset:
return new NdfNull();
default:
return null;
}
}
public abstract void buildNdf(NdfBinary data, ref int i);
