private uint GetFieldDataOrOffset(GffField f)
{
if (GffComponent.IsSimple(f.Type))
{
var lB = f.Bytes;
if (lB.Length < 4)
{
Array.Resize(ref lB, 4);
}
return(BitConverter.ToUInt32(lB, 0));
}
var br = new LatinBinaryWriter(_gb.FieldDataBlock);
var pos = _gb.FieldDataBlock.Position;
switch (f.Type)
{
case GffType.ResRef:
br.Write((byte)f.Bytes.Length);
break;
case GffType.CExoString:
case GffType.CExoLocString:
case GffType.Void:
br.Write((uint)f.Bytes.Length);
break;
}
br.Write(f.Bytes);
return((uint)pos);
}
private void CreateFrames(GffComponent cpnt)
{
var value = cpnt as GffStruct;
if (value != null)
{
var sf = new GffStructFrame();
_gb.StructArray.Add(sf);
DsaS.Add(sf, value);
}
if (!(cpnt is GffInListStruct || cpnt is GffRootStruct))
{
var ff = new GffFieldFrame();
_gb.FieldArray.Add(ff);
DfaF.Add(ff, cpnt);
}
if (!GffComponent.IsComposite(cpnt.Type))
{
return;
}
var cpsit = cpnt as GffComposite;
if (cpsit == null)
{
return;
}
foreach (var child in cpsit)
{
CreateFrames(child);
}
}
private static void WriteLabel(XmlElement n, GffComponent c)
{
if (!string.IsNullOrEmpty(c.Label))
{
n.SetAttribute(ALabel, c.Label);
}
}
public new void Add(GffComponent field)
{
if (field is GffInListStruct)
{
base.Add(field);
}
else
{
throw new CompositeException(ErrorLabels.AddWrongStructureClassToList);
}
}
private void WriteField(XmlElement n, GffComponent c)
{
var fld = (GffField)c;
n.SetAttribute(AType, Enum.GetName(typeof(GffType), fld.Type));
var data = fld.Value;
if (data != string.Empty)
{
n.AppendChild(Xdoc.CreateTextNode(data));
}
}
private void Write(XmlNode xRoot, GffComponent vChild)
{
XmlElement xChild;
if (vChild is GffStruct)
{
xChild = Xdoc.CreateElement(EStruct);
}
else if (vChild is GffList)
{
xChild = Xdoc.CreateElement(EList);
}
else if (vChild is GffField)
{
xChild = Xdoc.CreateElement(EField);
}
else
{
throw new ComponentException("Type de composant inconnu.");
}
WriteLabel(xChild, vChild);
var child = vChild as GffStruct;
if (child != null)
{
WriteStruct(xChild, child);
}
else if (vChild is GffField)
{
WriteField(xChild, vChild);
}
xRoot.AppendChild(xChild);
var composite = vChild as GffComposite;
if (composite == null)
{
return;
}
var cvChild = composite;
foreach (var vChild2 in cvChild)
{
Write(xChild, vChild2);
}
}
private GffComponent CreateComponent(XmlNode node)
{
GffComponent cpnt = null;
switch (node.Name)
{
case EStruct:
switch (GetStructClass(node))
{
case SclassInField:
cpnt = new GffInFieldStruct(GetLabel(node), GetStructType(node));
break;
case SclassInList:
cpnt = new GffInListStruct(GetStructType(node));
break;
case SclassRoot:
cpnt = new GffRootStruct(GetExtention(node));
break;
}
break;
case EList:
cpnt = new GffList(GetLabel(node));
break;
case EField:
cpnt = new GffField(GetLabel(node), GetFieldType(node), GetFieldValue(node));
break;
}
var composite = cpnt as GffComposite;
if (composite == null)
{
return(cpnt);
}
var cpsit = composite;
foreach (XmlNode child in node.ChildNodes)
{
cpsit.Add(CreateComponent(child));
}
return(cpnt);
}
private GffComponent CreateComponent(uint fIndex)
{
MemoryStream dataStream;
var f = _gbase.FieldArray[(int)fIndex];
var fLblId = f.LabelIndex;
var fLbl = _gbase.LabelArray[(int)fLblId];
// if (fLbl == null) {
// throw new NotImplementedException();
// }
var fType = (GffType)f.Type;
if (GffComponent.IsComposite(fType))
{
if (fType == GffType.Struct)
{
// On va chercher la frame qui lui correspond.
var sIndex = f.DataOrDataOffset;
var s = _gbase.StructArray[(int)sIndex];
var sType = s.Type;
var vs = new GffInFieldStruct(fLbl, sType);
PopulateStruct(vs, GetStructFieldIndices(s));
return(vs);
}
if (fType == GffType.List)
{
var br = new LatinBinaryReader(_gbase.ListIndicesArray)
{
Stream = { Position = f.DataOrDataOffset }
};
var size = (int)br.ReadUInt32();
var vl = new GffList(fLbl);
var structIdList = br.GetUInt32List(size);
foreach (var structId in structIdList)
{
var sFrame = _gbase.StructArray[(int)structId];
var vls = new GffInListStruct(sFrame.Type);
PopulateStruct(vls, GetStructFieldIndices(sFrame));
vl.Add(vls);
}
return(vl);
}
throw new CompositeException(ErrorLabels.UnknownCompositeType);
}
if (GffComponent.IsSimple(fType))
{
dataStream = new MemoryStream(BitConverter.GetBytes(f.DataOrDataOffset));
}
else if (GffComponent.IsLarge(fType))
{
var br = new LatinBinaryReader(_gbase.FieldDataBlock);
var pos = br.Stream.Position;
br.Stream.Position = f.DataOrDataOffset;
var size = 0;
#region Switch de détermination de la taille.
switch (fType)
{
case GffType.Dword64:
size = 8;
break;
case GffType.Int64:
size = sizeof(long);
break;
case GffType.Double:
size = sizeof(double);
break;
case GffType.ResRef:
size = br.ReadByte();
break;
case GffType.CExoString:
case GffType.CExoLocString:
case GffType.Void:
size = (int)br.ReadUInt32();
break;
case GffType.Byte:
break;
case GffType.Char:
break;
case GffType.Word:
break;
case GffType.Short:
break;
case GffType.Dword:
break;
case GffType.Int:
break;
case GffType.Float:
break;
case GffType.Struct:
break;
case GffType.List:
break;
case GffType.Invalid:
break;
default:
throw new FieldException(ErrorLabels.UnknownLargeFieldType);
}
#endregion
dataStream = new MemoryStream(br.ReadBytes(size));
br.Stream.Position = pos;
}
else
{
throw new FieldException(ErrorLabels.UnknownFieldType);
}
return(new GffField(fLbl, fType, dataStream.ToArray()));
}
