public static CNS_File Read(byte[] rawBytes)
{
List <byte> bytes = rawBytes.ToList();
//Validation
if (BitConverter.ToInt32(rawBytes, 0) != CNS_SIGNATURE)
{
throw new InvalidDataException("CNS_SIGNATURE not found at offset 0x0. Parse failed.");
}
int count = BitConverter.ToInt32(rawBytes, 8);
int offset = BitConverter.ToInt32(rawBytes, 16);
//Parse file
CNS_File cnsFile = new CNS_File()
{
CnsEntries = new List <CNS_Entry>()
};
cnsFile.Version = BitConverter.ToUInt16(rawBytes, 6);
//Unknown values
cnsFile.UnknownValues = BitConverter_Ex.ToUInt16Array(rawBytes, 20, 4);
//Entries
for (int i = 0; i < count; i++)
{
cnsFile.CnsEntries.Add(CNS_Entry.Read(rawBytes, bytes, offset));
offset += 180;
}
return(cnsFile);
}
} //Size 4
public static UnkSkeletonData Read(byte[] rawBytes, int offset)
{
UnkSkeletonData data = new UnkSkeletonData();
data.Values = BitConverter_Ex.ToUInt16Array(rawBytes, offset + 0, 4);
return(data);
}
public byte[] SaveToBytes()
{
SortEntries();
List <byte> bytes = new List <byte>();
//Header
bytes.AddRange(BitConverter.GetBytes(CNS_SIGNATURE)); //0
bytes.AddRange(BitConverter.GetBytes((UInt16)65534)); //4
bytes.AddRange(BitConverter.GetBytes(Version)); //6
bytes.AddRange(BitConverter.GetBytes(CnsEntries.Count)); //8
bytes.AddRange(BitConverter.GetBytes(20)); //12
bytes.AddRange(BitConverter.GetBytes(28)); //16
//Unknown values
Assertion.AssertArraySize(UnknownValues, 4, "CNS", "UnknownValues");
bytes.AddRange(BitConverter_Ex.GetBytes(UnknownValues));
//Entries
for (int i = 0; i < CnsEntries.Count; i++)
{
bytes.AddRange(CNS_Entry.Write(CnsEntries[i]));
}
return(bytes.ToArray());
}
public static List <byte> Write(CNS_Entry cnsEntry)
{
List <byte> bytes = new List <byte>();
//Code
if (cnsEntry.Str_00.Length > 8)
{
throw new Exception(String.Format("Dual_Code = {0} exceeds the maximum allowed length of 8. Load failed.", cnsEntry.Str_00));
}
bytes.AddRange(Encoding.ASCII.GetBytes(cnsEntry.Str_00));
bytes.AddRange(new byte[8 - cnsEntry.Str_00.Length]);
//Validate arrays
Assertion.AssertArraySize(cnsEntry.I_10, 33, "CnsEntry", "I_10");
Assertion.AssertArraySize(cnsEntry.I_76, 33, "CnsEntry", "I_76");
Assertion.AssertArraySize(cnsEntry.I_146, 7, "CnsEntry", "I_146");
Assertion.AssertArraySize(cnsEntry.I_162, 7, "CnsEntry", "I_162");
//Remaining values
bytes.AddRange(BitConverter.GetBytes(ushort.Parse(cnsEntry.Index)));
bytes.AddRange(BitConverter_Ex.GetBytes(cnsEntry.I_10));
bytes.AddRange(BitConverter_Ex.GetBytes(cnsEntry.I_76));
bytes.AddRange(BitConverter.GetBytes(cnsEntry.I_142));
bytes.AddRange(BitConverter.GetBytes(cnsEntry.I_144));
bytes.AddRange(BitConverter_Ex.GetBytes(cnsEntry.I_146));
bytes.AddRange(BitConverter.GetBytes(cnsEntry.I_160));
bytes.AddRange(BitConverter_Ex.GetBytes(cnsEntry.I_162));
bytes.AddRange(BitConverter.GetBytes(cnsEntry.I_176));
bytes.AddRange(BitConverter.GetBytes(cnsEntry.I_178));
return(bytes);
}
List <Type_5> GetType5(short count, int offset, List <Type_5> Type5, int idx)
{
if (Type5 == null)
{
Type5 = new List <Type_5>();
}
for (int i = 0; i < count; i++)
{
Type5.Add(new Type_5()
{
Idx = idx,
I_00 = BitConverter.ToUInt16(rawBytes, offset + 0),
I_02 = (ushort)(BitConverter.ToUInt16(rawBytes, offset + 2) - BitConverter.ToUInt16(rawBytes, offset + 0)),
I_04 = BitConverter.ToUInt16(rawBytes, offset + 4),
I_06 = BitConverter.ToUInt16(rawBytes, offset + 6),
I_08 = BitConverter.ToUInt16(rawBytes, offset + 8),
I_10 = BitConverter.ToUInt16(rawBytes, offset + 10),
I_12 = BitConverter.ToUInt16(rawBytes, offset + 12),
I_14 = BitConverter.ToUInt16(rawBytes, offset + 14),
I_16 = BitConverter_Ex.ToInt32Array(rawBytes, offset + 16, 12)
});
offset += 64;
}
return(Type5);
}
private void WriteEffect(IBD_Effect effect)
{
bytes.AddRange(BitConverter.GetBytes(effect.I_00));
bytes.AddRange(BitConverter.GetBytes(effect.I_04));
bytes.AddRange(BitConverter.GetBytes(effect.I_08));
bytes.AddRange(BitConverter.GetBytes(effect.F_12));
Assertion.AssertArraySize(effect.F_16, 6, "Effect", "Ability_Values");
bytes.AddRange(BitConverter_Ex.GetBytes(effect.F_16));
bytes.AddRange(BitConverter.GetBytes(effect.I_40));
bytes.AddRange(BitConverter.GetBytes(effect.I_44));
Assertion.AssertArraySize(effect.F_48, 6, "Effect", "Multipliers");
bytes.AddRange(BitConverter_Ex.GetBytes(effect.F_48));
Assertion.AssertArraySize(effect.I_72, 6, "Effect", "I_72");
bytes.AddRange(BitConverter_Ex.GetBytes(effect.I_72));
bytes.AddRange(BitConverter.GetBytes(effect.F_96));
bytes.AddRange(BitConverter.GetBytes(effect.F_100));
bytes.AddRange(BitConverter.GetBytes(effect.F_104));
bytes.AddRange(BitConverter.GetBytes(effect.F_108));
bytes.AddRange(BitConverter.GetBytes(effect.F_112));
bytes.AddRange(BitConverter.GetBytes(effect.F_116));
bytes.AddRange(BitConverter.GetBytes(effect.F_120));
bytes.AddRange(BitConverter.GetBytes(effect.F_124));
bytes.AddRange(BitConverter.GetBytes(effect.F_128));
bytes.AddRange(BitConverter.GetBytes(effect.F_132));
bytes.AddRange(BitConverter.GetBytes(effect.F_136));
bytes.AddRange(BitConverter.GetBytes(effect.F_140));
bytes.AddRange(BitConverter.GetBytes(effect.F_144));
bytes.AddRange(BitConverter.GetBytes(effect.F_148));
bytes.AddRange(BitConverter.GetBytes(effect.F_152));
Assertion.AssertArraySize(effect.F_156, 17, "Effect", "F_156");
bytes.AddRange(BitConverter_Ex.GetBytes(effect.F_156));
}
public static Unknown_Indexes Read(byte[] rawBytes, int offset)
{
return(new Unknown_Indexes()
{
Indexes = BitConverter_Ex.ToInt32Array(rawBytes, offset, FPF_File.UnknownIndexListCount).ToList()
});
}
public void ParseBas()
{
int count = BitConverter.ToInt32(rawBytes, 8);
int offset = BitConverter.ToInt32(rawBytes, 12);
if (count > 0)
{
basFile.Entries = new List <BAS_Entry>();
for (int i = 0; i < count; i++)
{
basFile.Entries.Add(new BAS_Entry());
basFile.Entries[i].I_00 = BitConverter.ToUInt32(rawBytes, offset + 0);
int subEntryCount = BitConverter.ToInt32(rawBytes, offset + 4);
int subEntryOffset = BitConverter.ToInt32(rawBytes, offset + 8);
if (subEntryCount > 0)
{
basFile.Entries[i].SubEntries = new List <BAS_SubEntry>();
for (int a = 0; a < subEntryCount; a++)
{
basFile.Entries[i].SubEntries.Add(new BAS_SubEntry()
{
Name = Utils.GetString(rawBytes.ToList(), subEntryOffset, 8),
I_08 = BitConverter_Ex.ToBooleanFromInt32(rawBytes, subEntryOffset + 8),
I_12 = (BAS_SubEntry.ActivationConditionTarget)BitConverter.ToInt32(rawBytes, subEntryOffset + 12),
I_16 = (BAS_SubEntry.ActivationConditionTarget)BitConverter.ToInt32(rawBytes, subEntryOffset + 16),
I_20 = (BAS_SubEntry.ActivationConditionTarget)BitConverter.ToInt32(rawBytes, subEntryOffset + 20),
I_24 = BitConverter.ToInt32(rawBytes, subEntryOffset + 24),
I_28 = BitConverter.ToInt32(rawBytes, subEntryOffset + 28),
I_32 = BitConverter.ToInt32(rawBytes, subEntryOffset + 32),
I_36 = BitConverter.ToInt32(rawBytes, subEntryOffset + 36),
I_40 = BitConverter.ToInt32(rawBytes, subEntryOffset + 40),
I_44 = BitConverter.ToInt32(rawBytes, subEntryOffset + 44),
I_48 = BitConverter.ToInt32(rawBytes, subEntryOffset + 48),
I_52 = BitConverter.ToInt32(rawBytes, subEntryOffset + 52),
I_56 = BitConverter.ToInt32(rawBytes, subEntryOffset + 56),
I_60 = BitConverter.ToInt32(rawBytes, subEntryOffset + 60),
I_64 = BitConverter.ToInt32(rawBytes, subEntryOffset + 64),
F_68 = BitConverter.ToSingle(rawBytes, subEntryOffset + 68),
F_72 = BitConverter.ToSingle(rawBytes, subEntryOffset + 72),
F_76 = BitConverter.ToSingle(rawBytes, subEntryOffset + 76),
F_80 = BitConverter.ToSingle(rawBytes, subEntryOffset + 80),
});
subEntryOffset += 84;
}
}
offset += 12;
}
}
}
public List <byte> Write()
{
if (Values.Length != 4)
{
throw new InvalidDataException("UnkSkeletonData > Values must have 4 values.");
}
List <byte> bytes = new List <byte>();
bytes.AddRange(BitConverter_Ex.GetBytes(Values));
return(bytes);
}
public List <byte> Write()
{
List <byte> bytes = new List <byte>();
bytes.AddRange(BitConverter_Ex.GetBytes(Indexes.ToArray()));
if (bytes.Count != FPF_File.UnknownIndexListCount * 4)
{
throw new InvalidDataException("UnknownIndexes is an invalid size.");
}
return(bytes);
}
private void WriteUnk3(List <Unk3> unk3, int offsetToFill, int relativeOffset)
{
if (unk3 != null)
{
bytes = Utils.ReplaceRange(bytes, BitConverter.GetBytes(bytes.Count() - relativeOffset), offsetToFill);
for (int i = 0; i < unk3.Count(); i++)
{
Assertion.AssertArraySize(unk3[i].I_00, 6, "Unk3", "values");
bytes.AddRange(BitConverter_Ex.GetBytes(unk3[i].I_00));
}
}
}
//Skeleton
private void ParseSkeleton(int offset)
{
//Init
boneCount = BitConverter.ToInt16(rawBytes, offset);
int unk1Offset = BitConverter.ToInt32(rawBytes, offset + 20) + offset;
int unk2Offset = BitConverter.ToInt32(rawBytes, offset + 24) + offset;
//Skeleton init
eanFile.Skeleton = new ESK_Skeleton()
{
I_02 = BitConverter.ToInt16(rawBytes, offset + 2),
I_28 = BitConverter_Ex.ToInt32Array(rawBytes, offset + 28, 2),
Unk1 = ESK_Unk1.Read(rawBytes, unk1Offset),
UseUnk2 = (unk2Offset != 0) ? true : false,
ESKBones = new ObservableCollection <ESK_Bone>()
};
//Setting the offsets for the initial loop to use
int[] offsets = GetBoneOffset(0, offset);
int boneIndexOffset = offsets[0];
int nameOffset = offsets[1];
int skinningMatrixOffset = offsets[2];
int transformMatrixOffset = offsets[3];
while (true)
{
int idx = eanFile.Skeleton.ESKBones.Count;
eanFile.Skeleton.ESKBones.Add(ESK_Bone.Read(bytes, rawBytes, offsets));
if (BitConverter.ToInt16(rawBytes, boneIndexOffset + 2) != -1)
{
eanFile.Skeleton.ESKBones[idx].ESK_Bones = ParseChildrenBones(BitConverter.ToInt16(rawBytes, boneIndexOffset + 2), offset);
}
//Loop management
if (BitConverter.ToInt16(rawBytes, boneIndexOffset + 4) != -1)
{
//There is a sibling
offsets = GetBoneOffset(BitConverter.ToInt16(rawBytes, boneIndexOffset + 4), offset);
boneIndexOffset = offsets[0];
nameOffset = offsets[1];
skinningMatrixOffset = offsets[2];
//transformMatrixOffset = offsets[3];
}
else
{
//There is no sibling. End loop.
break;
}
}
}
public static CNS_Entry Read(byte[] rawBytes, List <byte> bytes, int offset)
{
return(new CNS_Entry()
{
Str_00 = Utils.GetString(bytes, offset),
Index = BitConverter.ToUInt16(rawBytes, offset + 8).ToString(),
I_10 = BitConverter_Ex.ToUInt16Array(rawBytes, offset + 10, 33),
I_76 = BitConverter_Ex.ToUInt16Array(rawBytes, offset + 76, 33),
I_142 = BitConverter.ToUInt16(rawBytes, offset + 142),
I_144 = BitConverter.ToUInt16(rawBytes, offset + 144),
I_146 = BitConverter_Ex.ToUInt16Array(rawBytes, offset + 146, 7),
I_160 = BitConverter.ToUInt16(rawBytes, offset + 160),
I_162 = BitConverter_Ex.ToUInt16Array(rawBytes, offset + 162, 7),
I_176 = BitConverter.ToUInt16(rawBytes, offset + 176),
I_178 = BitConverter.ToUInt16(rawBytes, offset + 178),
});
}
private int ParseSection2(int currentOffset)
{
while (EndOfSectionCheck(currentOffset) == false)
{
int _pos = tsd_File.Events.Count();
int addedOffset = 0;
tsd_File.Events.Add(new TSD_Event());
tsd_File.Events[_pos].Index = BitConverter.ToInt32(rawBytes, currentOffset + 0).ToString();
tsd_File.Events[_pos].I_04 = BitConverter.ToInt32(rawBytes, currentOffset + 4);
addedOffset += 12;
int stringSize = BitConverter.ToInt32(rawBytes, currentOffset + addedOffset - 4);
tsd_File.Events[_pos].Str1 = StringEx.GetString(rawBytes, currentOffset + addedOffset, false, StringEx.EncodingType.UTF8, BitConverter.ToInt32(rawBytes, currentOffset + addedOffset - 4), false);
addedOffset += stringSize + 4;
stringSize = BitConverter.ToInt32(rawBytes, currentOffset + addedOffset - 4);
tsd_File.Events[_pos].Str2 = StringEx.GetString(rawBytes, currentOffset + addedOffset, false, StringEx.EncodingType.UTF8, BitConverter.ToInt32(rawBytes, currentOffset + addedOffset - 4), false);
addedOffset += stringSize + 4;
stringSize = BitConverter.ToInt32(rawBytes, currentOffset + addedOffset - 4);
tsd_File.Events[_pos].Str3 = StringEx.GetString(rawBytes, currentOffset + addedOffset, false, StringEx.EncodingType.UTF8, BitConverter.ToInt32(rawBytes, currentOffset + addedOffset - 4), false);
addedOffset += stringSize + 4;
stringSize = BitConverter.ToInt32(rawBytes, currentOffset + addedOffset - 4);
tsd_File.Events[_pos].Str4 = StringEx.GetString(rawBytes, currentOffset + addedOffset, false, StringEx.EncodingType.UTF8, BitConverter.ToInt32(rawBytes, currentOffset + addedOffset - 4), false);
addedOffset += stringSize + 4;
stringSize = BitConverter.ToInt32(rawBytes, currentOffset + addedOffset - 4);
string args = StringEx.GetString(rawBytes, currentOffset + addedOffset, false, StringEx.EncodingType.UTF8, BitConverter.ToInt32(rawBytes, currentOffset + addedOffset - 4), false);
tsd_File.Events[_pos].Arguments = EventArguments.Read(args);
addedOffset += stringSize + 4;
//Read TNL ID array
int count = BitConverter.ToInt32(rawBytes, currentOffset + addedOffset - 4);
List <int> tnlIds = BitConverter_Ex.ToInt32Array(rawBytes, currentOffset + addedOffset, count).ToList();
addedOffset += (4 * count);
tsd_File.Events[_pos].TNL_IDs = ArrayConvert.ConvertToStringList(tnlIds);
currentOffset += addedOffset;
}
return(currentOffset);
}
private List <Unk3> ParseUnk3(int offset, int count)
{
if (count > 0)
{
List <Unk3> unk3 = new List <Unk3>();
for (int i = 0; i < count; i++)
{
unk3.Add(new Unk3()
{
I_00 = BitConverter_Ex.ToInt16Array(rawBytes, offset, 6)
});
offset += 12;
}
return(unk3);
}
else
{
return(null);
}
}
private List <IBD_Effect> ParseEffect(int offset)
{
List <IBD_Effect> effects = new List <IBD_Effect>();
for (int i = 0; i < 3; i++)
{
effects.Add(new IBD_Effect()
{
I_00 = BitConverter.ToInt32(rawBytes, offset + 0),
I_04 = BitConverter.ToInt32(rawBytes, offset + 4),
I_08 = BitConverter.ToInt32(rawBytes, offset + 8),
F_12 = BitConverter.ToSingle(rawBytes, offset + 12),
F_16 = BitConverter_Ex.ToFloat32Array(rawBytes, offset + 16, 6),
I_40 = BitConverter.ToInt32(rawBytes, offset + 40),
I_44 = BitConverter.ToInt32(rawBytes, offset + 44),
F_48 = BitConverter_Ex.ToFloat32Array(rawBytes, offset + 48, 6),
I_72 = BitConverter_Ex.ToInt32Array(rawBytes, offset + 72, 6),
F_96 = BitConverter.ToSingle(rawBytes, offset + 96),
F_100 = BitConverter.ToSingle(rawBytes, offset + 100),
F_104 = BitConverter.ToSingle(rawBytes, offset + 104),
F_108 = BitConverter.ToSingle(rawBytes, offset + 108),
F_112 = BitConverter.ToSingle(rawBytes, offset + 112),
F_116 = BitConverter.ToSingle(rawBytes, offset + 116),
F_120 = BitConverter.ToSingle(rawBytes, offset + 120),
F_124 = BitConverter.ToSingle(rawBytes, offset + 124),
F_128 = BitConverter.ToSingle(rawBytes, offset + 128),
F_132 = BitConverter.ToSingle(rawBytes, offset + 132),
F_136 = BitConverter.ToSingle(rawBytes, offset + 136),
F_140 = BitConverter.ToSingle(rawBytes, offset + 140),
F_144 = BitConverter.ToSingle(rawBytes, offset + 144),
F_148 = BitConverter.ToSingle(rawBytes, offset + 148),
F_152 = BitConverter.ToSingle(rawBytes, offset + 152),
F_156 = BitConverter_Ex.ToFloat32Array(rawBytes, offset + 156, 17)
});
offset += 224;
}
return(effects);
}
private void WriteFile()
{
//Section 1
bytes.Add(1);
for (int i = 0; i < tsd_File.Triggers.Count(); i++)
{
bytes.AddRange(BitConverter.GetBytes(int.Parse(tsd_File.Triggers[i].Index)));
bytes.AddRange(BitConverter.GetBytes(tsd_File.Triggers[i].I_04));
bytes.AddRange(BitConverter.GetBytes(tsd_File.Triggers[i].I_08));
bytes.AddRange(BitConverter.GetBytes(tsd_File.Triggers[i].I_12));
bytes.AddRange(BitConverter.GetBytes(int.Parse(tsd_File.Triggers[i].I_16)));
bytes.AddRange(BitConverter.GetBytes(tsd_File.Triggers[i].I_20));
bytes.AddRange(BitConverter.GetBytes(int.Parse(tsd_File.Triggers[i].I_24)));
bytes.AddRange(BitConverter.GetBytes(tsd_File.Triggers[i].I_28));
bytes.AddRange(BitConverter.GetBytes(Encoding.UTF8.GetByteCount(tsd_File.Triggers[i].Condition)));
bytes.AddRange(Encoding.UTF8.GetBytes(tsd_File.Triggers[i].Condition));
}
//Section 2
bytes.AddRange(BitConverter.GetBytes(magicNumber));
bytes.Add(2);
for (int i = 0; i < tsd_File.Events.Count(); i++)
{
bytes.AddRange(BitConverter.GetBytes(int.Parse(tsd_File.Events[i].Index)));
bytes.AddRange(BitConverter.GetBytes(tsd_File.Events[i].I_04));
bytes.AddRange(BitConverter.GetBytes(Encoding.UTF8.GetByteCount(tsd_File.Events[i].Str1)));
bytes.AddRange(Encoding.UTF8.GetBytes(tsd_File.Events[i].Str1));
bytes.AddRange(BitConverter.GetBytes(Encoding.UTF8.GetByteCount(tsd_File.Events[i].Str2)));
bytes.AddRange(Encoding.UTF8.GetBytes(tsd_File.Events[i].Str2));
bytes.AddRange(BitConverter.GetBytes(Encoding.UTF8.GetByteCount(tsd_File.Events[i].Str3)));
bytes.AddRange(Encoding.UTF8.GetBytes(tsd_File.Events[i].Str3));
bytes.AddRange(BitConverter.GetBytes(Encoding.UTF8.GetByteCount(tsd_File.Events[i].Str4)));
bytes.AddRange(Encoding.UTF8.GetBytes(tsd_File.Events[i].Str4));
string args = tsd_File.Events[i].Arguments.Write();
bytes.AddRange(BitConverter.GetBytes(Encoding.UTF8.GetByteCount(args)));
bytes.AddRange(Encoding.UTF8.GetBytes(args));
bytes.AddRange(BitConverter.GetBytes(tsd_File.Events[i].TNL_IDs.Count()));
List <int> tnlIds = ArrayConvert.ConvertToInt32List(tsd_File.Events[i].TNL_IDs);
bytes.AddRange(BitConverter_Ex.GetBytes(tnlIds.ToArray()));
}
//Section 3
bytes.AddRange(BitConverter.GetBytes(magicNumber));
bytes.Add(3);
for (int i = 0; i < tsd_File.Globals.Count(); i++)
{
bytes.AddRange(BitConverter.GetBytes(Encoding.UTF8.GetByteCount(tsd_File.Globals[i].Index)));
bytes.AddRange(Encoding.UTF8.GetBytes(tsd_File.Globals[i].Index));
bytes.AddRange(BitConverter.GetBytes(tsd_File.Globals[i].Type));
bytes.AddRange(BitConverter.GetBytes(Encoding.UTF8.GetByteCount(tsd_File.Globals[i].Str)));
bytes.AddRange(Encoding.UTF8.GetBytes(tsd_File.Globals[i].Str));
}
//Section 4
bytes.AddRange(BitConverter.GetBytes(magicNumber));
bytes.Add(4);
for (int i = 0; i < tsd_File.Constants.Count(); i++)
{
bytes.AddRange(BitConverter.GetBytes(Encoding.UTF8.GetByteCount(tsd_File.Constants[i].Index)));
bytes.AddRange(Encoding.UTF8.GetBytes(tsd_File.Constants[i].Index));
bytes.AddRange(BitConverter.GetBytes(tsd_File.Constants[i].Type));
bytes.AddRange(BitConverter.GetBytes(Encoding.UTF8.GetByteCount(tsd_File.Constants[i].Str)));
bytes.AddRange(Encoding.UTF8.GetBytes(tsd_File.Constants[i].Str));
}
//Section 5
bytes.AddRange(BitConverter.GetBytes(magicNumber));
bytes.Add(5);
for (int i = 0; i < tsd_File.Zones.Count(); i++)
{
bytes.AddRange(BitConverter.GetBytes(int.Parse(tsd_File.Zones[i].Index)));
bytes.AddRange(BitConverter.GetBytes(tsd_File.Zones[i].I_04));
bytes.AddRange(BitConverter.GetBytes(Encoding.UTF8.GetByteCount(tsd_File.Zones[i].Str)));
bytes.AddRange(Encoding.UTF8.GetBytes(tsd_File.Zones[i].Str));
}
}
private void Parse()
{
//counts
int partsetCount = BitConverter.ToInt16(rawBytes, 12);
int partcolorsCount = BitConverter.ToInt16(rawBytes, 14);
int bodyCount = BitConverter.ToInt16(rawBytes, 16);
//offsets
int partsetOffset = BitConverter.ToInt32(rawBytes, 24);
int partcolorsOffset = BitConverter.ToInt32(rawBytes, 28);
int bodyOffset = BitConverter.ToInt32(rawBytes, 32);
int skeleton2Offset = BitConverter.ToInt32(rawBytes, 36);
int skeleton1Offset = BitConverter.ToInt32(rawBytes, 40);
//Header
byte[] _I_44 = rawBytes.GetRange(44, 4);
bcsFile.Race = _I_44[0];
bcsFile.Sex = Convert.ToBoolean(_I_44[1]);
bcsFile.F_48 = BitConverter_Ex.ToFloat32Array(rawBytes, 48, 7);
//PartSets
int actualIndex = 0;
if (partsetCount > 0)
{
bcsFile.PartSets = new List <PartSet>();
for (int i = 0; i < partsetCount; i++)
{
int thisPartsetOffset = BitConverter.ToInt32(rawBytes, partsetOffset);
if (thisPartsetOffset != 0)
{
bcsFile.PartSets.Add(new PartSet()
{
Index = i.ToString()
});
if (BitConverter.ToInt32(rawBytes, thisPartsetOffset + 20) != 10)
{
throw new Exception(string.Format("Part count mismatch on PartSet {0} (Expected 10, but found {1})\nThis BCS file cannot be parsed.", i, BitConverter.ToInt32(rawBytes, thisPartsetOffset + 20)));
}
int tableOffset = thisPartsetOffset + BitConverter.ToInt32(rawBytes, thisPartsetOffset + 24);
bcsFile.PartSets[actualIndex].FaceBase = ParsePart(BitConverter.ToInt32(rawBytes, tableOffset + 0), thisPartsetOffset);
bcsFile.PartSets[actualIndex].FaceForehead = ParsePart(BitConverter.ToInt32(rawBytes, tableOffset + 4), thisPartsetOffset);
bcsFile.PartSets[actualIndex].FaceEye = ParsePart(BitConverter.ToInt32(rawBytes, tableOffset + 8), thisPartsetOffset);
bcsFile.PartSets[actualIndex].FaceNose = ParsePart(BitConverter.ToInt32(rawBytes, tableOffset + 12), thisPartsetOffset);
bcsFile.PartSets[actualIndex].FaceEar = ParsePart(BitConverter.ToInt32(rawBytes, tableOffset + 16), thisPartsetOffset);
bcsFile.PartSets[actualIndex].Hair = ParsePart(BitConverter.ToInt32(rawBytes, tableOffset + 20), thisPartsetOffset);
bcsFile.PartSets[actualIndex].Bust = ParsePart(BitConverter.ToInt32(rawBytes, tableOffset + 24), thisPartsetOffset);
bcsFile.PartSets[actualIndex].Pants = ParsePart(BitConverter.ToInt32(rawBytes, tableOffset + 28), thisPartsetOffset);
bcsFile.PartSets[actualIndex].Rist = ParsePart(BitConverter.ToInt32(rawBytes, tableOffset + 32), thisPartsetOffset);
bcsFile.PartSets[actualIndex].Boots = ParsePart(BitConverter.ToInt32(rawBytes, tableOffset + 36), thisPartsetOffset);
actualIndex++;
}
partsetOffset += 4;
}
}
//PartColors
if (partcolorsCount > 0)
{
bcsFile.Part_Colors = new List <PartColor>();
for (int i = 0; i < partcolorsCount; i++)
{
int thisPartColorOffset = BitConverter.ToInt32(rawBytes, partcolorsOffset);
if (thisPartColorOffset != 0)
{
bcsFile.Part_Colors.Add(new PartColor()
{
Index = i.ToString(),
Str_00 = Utils.GetString(bytes, BitConverter.ToInt32(rawBytes, thisPartColorOffset + 0) + thisPartColorOffset),
_Colors = ParseColors(BitConverter.ToInt32(rawBytes, thisPartColorOffset + 12) + thisPartColorOffset, BitConverter.ToInt16(rawBytes, thisPartColorOffset + 10))
});
}
partcolorsOffset += 4;
}
}
//BodyScales
if (bodyCount > 0)
{
bcsFile.Bodies = new List <Body>();
for (int i = 0; i < bodyCount; i++)
{
int thisBodyScaleOffset = BitConverter.ToInt32(rawBytes, bodyOffset);
if (thisBodyScaleOffset != 0)
{
bcsFile.Bodies.Add(ParseBody(thisBodyScaleOffset, i));
}
bodyOffset += 4;
}
}
if (skeleton1Offset != 0)
{
bcsFile.SkeletonData1 = ParseSkeleton(BitConverter.ToInt32(rawBytes, skeleton1Offset));
}
if (skeleton2Offset != 0)
{
bcsFile.SkeletonData2 = ParseSkeleton(BitConverter.ToInt32(rawBytes, skeleton2Offset));
}
}
private void WriteDem()
{
//init
int unkValueCount = (demFile.DEM_UnkValues != null) ? demFile.DEM_UnkValues.Count : 0;
int section2Count = (demFile.Section2Entries != null) ? demFile.Section2Entries.Count : 0;
int actorCount = (demFile.Settings.Characters != null) ? demFile.Settings.Characters.Count : 0;
int charaOffsetPos = 0;
//Header
bytes.AddRange(BitConverter.GetBytes(DEM_File.DEM_SIGNATURE)); //Signature
bytes.AddRange(BitConverter.GetBytes((ushort)65534)); //Endianess
bytes.AddRange(BitConverter.GetBytes((ushort)64)); //Header size
bytes.AddRange(BitConverter.GetBytes(demFile.I_08)); //Version?
bytes.AddRange(BitConverter.GetBytes(section2Count)); //Count
bytes.AddRange(BitConverter.GetBytes(unkValueCount)); //UnkValues Count
bytes.AddRange(new byte[12]); //Padding
bytes.AddRange(BitConverter.GetBytes((UInt64)64)); //Offset to name
bytes.AddRange(BitConverter.GetBytes((UInt64)0)); //Offset to Section 2 (fill in later)
bytes.AddRange(BitConverter.GetBytes((UInt64)80)); //Offset to DemoSettings
bytes.AddRange(BitConverter.GetBytes((UInt64)0)); //File size (fill in later)
//Name
Assertion.AssertStringSize(demFile.Name, 16, "DEM", "Name");
bytes.AddRange(Utils.GetStringBytes(demFile.Name, 16));
//DemoSettings
stringInfo.Add(new StringWriter.StringInfo()
{
StringToWrite = demFile.Settings.Str_00, Offset = bytes.Count, RelativeOffset = 0
});
bytes.AddRange(new byte[8]); //0
stringInfo.Add(new StringWriter.StringInfo()
{
StringToWrite = demFile.Settings.Str_08, Offset = bytes.Count, RelativeOffset = 0
});
bytes.AddRange(new byte[8]); //8
stringInfo.Add(new StringWriter.StringInfo()
{
StringToWrite = demFile.Settings.Str_16, Offset = bytes.Count, RelativeOffset = 0
});
bytes.AddRange(new byte[8]); //16
stringInfo.Add(new StringWriter.StringInfo()
{
StringToWrite = demFile.Settings.Str_24, Offset = bytes.Count, RelativeOffset = 0
});
bytes.AddRange(new byte[8]); //24
stringInfo.Add(new StringWriter.StringInfo()
{
StringToWrite = demFile.Settings.Str_32, Offset = bytes.Count, RelativeOffset = 0
});
bytes.AddRange(new byte[8]); //32
stringInfo.Add(new StringWriter.StringInfo()
{
StringToWrite = demFile.Settings.Str_40, Offset = bytes.Count, RelativeOffset = 0
});
bytes.AddRange(new byte[8]); //40
stringInfo.Add(new StringWriter.StringInfo()
{
StringToWrite = demFile.Settings.Str_48, Offset = bytes.Count, RelativeOffset = 0
});
bytes.AddRange(new byte[8]); //48
stringInfo.Add(new StringWriter.StringInfo()
{
StringToWrite = demFile.Settings.Str_56, Offset = bytes.Count, RelativeOffset = 0
});
bytes.AddRange(new byte[8]); //56
stringInfo.Add(new StringWriter.StringInfo()
{
StringToWrite = demFile.Settings.Str_64, Offset = bytes.Count, RelativeOffset = 0
});
bytes.AddRange(new byte[8]); //64
stringInfo.Add(new StringWriter.StringInfo()
{
StringToWrite = demFile.Settings.Str_72, Offset = bytes.Count, RelativeOffset = 0
});
bytes.AddRange(new byte[8]); //72
stringInfo.Add(new StringWriter.StringInfo()
{
StringToWrite = demFile.Settings.Str_80, Offset = bytes.Count, RelativeOffset = 0
});
bytes.AddRange(new byte[8]); //80
stringInfo.Add(new StringWriter.StringInfo()
{
StringToWrite = demFile.Settings.Str_88, Offset = bytes.Count, RelativeOffset = 0
});
bytes.AddRange(new byte[8]); //88
stringInfo.Add(new StringWriter.StringInfo()
{
StringToWrite = demFile.Settings.Str_96, Offset = bytes.Count, RelativeOffset = 0
});
bytes.AddRange(new byte[8]); //96
stringInfo.Add(new StringWriter.StringInfo()
{
StringToWrite = demFile.Settings.Str_104, Offset = bytes.Count, RelativeOffset = 0
});
bytes.AddRange(new byte[12]); //104
bytes.AddRange(BitConverter.GetBytes(actorCount));
charaOffsetPos = bytes.Count;
bytes.AddRange(BitConverter.GetBytes(208)); //Offset to actors, fill in later
bytes.AddRange(new byte[4]);
//Actors/charactors
if (actorCount > 0)
{
bytes = Utils.ReplaceRange(bytes, BitConverter.GetBytes(bytes.Count), charaOffsetPos);
for (int i = 0; i < actorCount; i++)
{
stringInfo.Add(new StringWriter.StringInfo()
{
StringToWrite = demFile.Settings.Characters[i].Str_00, Offset = bytes.Count, RelativeOffset = 0
});
bytes.AddRange(new byte[8]); //0
bytes.AddRange(BitConverter.GetBytes(demFile.Settings.Characters[i].I_08)); //8
bytes.AddRange(new byte[4]); //12
stringInfo.Add(new StringWriter.StringInfo()
{
StringToWrite = demFile.Settings.Characters[i].Str_16, Offset = bytes.Count, RelativeOffset = 0
});
bytes.AddRange(new byte[48]); //16
}
}
//Pad the file (it must be in 16-byte blocks before string section starts)
FilePad();
//Write strings
bytes = StringWriter.WritePointerStrings(stringInfo, bytes);
//Pad the file (it must be in 16-byte blocks before Section2 starts)
bytes.Add(0);
FilePad();
//Section2
bytes = Utils.ReplaceRange(bytes, BitConverter.GetBytes(bytes.Count), 40); //Filling in header offset
List <int> section2Offsets = new List <int>();
//Section2 main entries
for (int i = 0; i < section2Count; i++)
{
bytes.AddRange(BitConverter.GetBytes(demFile.Section2Entries[i].I_00));
bytes.AddRange(BitConverter.GetBytes((demFile.Section2Entries[i].SubEntries != null) ? demFile.Section2Entries[i].SubEntries.Count : 0));
section2Offsets.Add(bytes.Count);
bytes.AddRange(new byte[24]);
}
//Section2 subentries
for (int i = 0; i < section2Count; i++)
{
bytes = Utils.ReplaceRange(bytes, BitConverter.GetBytes(bytes.Count), section2Offsets[i]);
int subEntryCount = (demFile.Section2Entries[i].SubEntries != null) ? demFile.Section2Entries[i].SubEntries.Count : 0;
demFile.Section2Entries[i].SubEntries = demFile.Section2Entries[i].SubEntries.OrderBy(o => o.I_00).ToList();
for (int a = 0; a < subEntryCount; a++)
{
bytes.AddRange(BitConverter.GetBytes(demFile.Section2Entries[i].SubEntries[a].I_00));
//Type
int[] type = demFile.Section2Entries[i].SubEntries[a].GetDemoType();
bytes.AddRange(BitConverter.GetBytes((ushort)type[0])); //Type1
bytes.AddRange(BitConverter.GetBytes((ushort)type[1])); //Type2
bytes.AddRange(new byte[4]); //Padding
demFile.Section2Entries[i].SubEntries[a].ValueCount = type[2];
bytes.AddRange(BitConverter.GetBytes(type[2])); //Count
demFile.Section2Entries[i].SubEntries[a].PointerOffset = bytes.Count;
bytes.AddRange(new byte[16]); //Offset and padding
}
}
//Types (pointer list)
for (int i = 0; i < section2Count; i++)
{
int subEntryCount = (demFile.Section2Entries[i].SubEntries != null) ? demFile.Section2Entries[i].SubEntries.Count : 0;
for (int a = 0; a < subEntryCount; a++)
{
if (demFile.Section2Entries[i].SubEntries[a].ValueCount > 0)
{
bytes = Utils.ReplaceRange(bytes, BitConverter.GetBytes(bytes.Count), demFile.Section2Entries[i].SubEntries[a].PointerOffset);
}
for (int z = 0; z < demFile.Section2Entries[i].SubEntries[a].ValueCount; z++)
{
demFile.Section2Entries[i].SubEntries[a].ValueOffsets.Add(bytes.Count);
bytes.AddRange(new byte[8]);
}
}
}
//Types (values)
for (int i = 0; i < section2Count; i++)
{
int subEntryCount = (demFile.Section2Entries[i].SubEntries != null) ? demFile.Section2Entries[i].SubEntries.Count : 0;
for (int a = 0; a < subEntryCount; a++)
{
DEM_Type.DemoDataTypes type = demFile.Section2Entries[i].SubEntries[a].GetDemoDataType();
switch (type)
{
case DEM_Type.DemoDataTypes.Type0_1_6:
bytes = demFile.Section2Entries[i].SubEntries[a].Type0_1_6.Write(bytes, demFile.Section2Entries[i].SubEntries[a].ValueOffsets);
break;
case DEM_Type.DemoDataTypes.FadeInOut:
bytes = demFile.Section2Entries[i].SubEntries[a].Type0_2_7.Write(bytes, demFile.Section2Entries[i].SubEntries[a].ValueOffsets);
break;
case DEM_Type.DemoDataTypes.Type0_3_8:
bytes = demFile.Section2Entries[i].SubEntries[a].Type0_3_8.Write(bytes, demFile.Section2Entries[i].SubEntries[a].ValueOffsets);
break;
case DEM_Type.DemoDataTypes.Type0_16_1:
bytes = demFile.Section2Entries[i].SubEntries[a].Type0_16_1.Write(bytes, demFile.Section2Entries[i].SubEntries[a].ValueOffsets);
break;
case DEM_Type.DemoDataTypes.Type0_19_1:
bytes = demFile.Section2Entries[i].SubEntries[a].Type0_19_1.Write(bytes, demFile.Section2Entries[i].SubEntries[a].ValueOffsets);
break;
case DEM_Type.DemoDataTypes.Type0_20_2:
bytes = demFile.Section2Entries[i].SubEntries[a].Type0_20_2.Write(bytes, demFile.Section2Entries[i].SubEntries[a].ValueOffsets);
break;
case DEM_Type.DemoDataTypes.Type0_21_2:
bytes = demFile.Section2Entries[i].SubEntries[a].Type0_21_2.Write(bytes, demFile.Section2Entries[i].SubEntries[a].ValueOffsets);
break;
case DEM_Type.DemoDataTypes.Type1_1_5:
bytes = demFile.Section2Entries[i].SubEntries[a].Type1_1_5.Write(bytes, demFile.Section2Entries[i].SubEntries[a].ValueOffsets);
break;
case DEM_Type.DemoDataTypes.Type1_1_9:
bytes = demFile.Section2Entries[i].SubEntries[a].Type1_1_9.Write(bytes, demFile.Section2Entries[i].SubEntries[a].ValueOffsets);
break;
case DEM_Type.DemoDataTypes.Type1_2_3:
bytes = demFile.Section2Entries[i].SubEntries[a].Type1_2_3.Write(bytes, demFile.Section2Entries[i].SubEntries[a].ValueOffsets);
break;
case DEM_Type.DemoDataTypes.Type1_2_5:
bytes = demFile.Section2Entries[i].SubEntries[a].Type1_2_5.Write(bytes, demFile.Section2Entries[i].SubEntries[a].ValueOffsets);
break;
case DEM_Type.DemoDataTypes.Transformation:
bytes = demFile.Section2Entries[i].SubEntries[a].Type1_4_2.Write(bytes, demFile.Section2Entries[i].SubEntries[a].ValueOffsets);
break;
case DEM_Type.DemoDataTypes.Type1_6_4:
bytes = demFile.Section2Entries[i].SubEntries[a].Type1_6_4.Write(bytes, demFile.Section2Entries[i].SubEntries[a].ValueOffsets);
break;
case DEM_Type.DemoDataTypes.Type1_7_1:
bytes = demFile.Section2Entries[i].SubEntries[a].Type1_7_1.Write(bytes, demFile.Section2Entries[i].SubEntries[a].ValueOffsets);
break;
case DEM_Type.DemoDataTypes.Type1_8_6:
bytes = demFile.Section2Entries[i].SubEntries[a].Type1_8_6.Write(bytes, demFile.Section2Entries[i].SubEntries[a].ValueOffsets);
break;
case DEM_Type.DemoDataTypes.Type1_11_2:
bytes = demFile.Section2Entries[i].SubEntries[a].Type1_11_2.Write(bytes, demFile.Section2Entries[i].SubEntries[a].ValueOffsets);
break;
case DEM_Type.DemoDataTypes.Type1_12_2:
bytes = demFile.Section2Entries[i].SubEntries[a].Type1_12_2.Write(bytes, demFile.Section2Entries[i].SubEntries[a].ValueOffsets);
break;
case DEM_Type.DemoDataTypes.Type1_13_10:
bytes = demFile.Section2Entries[i].SubEntries[a].Type1_13_10.Write(bytes, demFile.Section2Entries[i].SubEntries[a].ValueOffsets);
break;
case DEM_Type.DemoDataTypes.Type1_14_1:
bytes = demFile.Section2Entries[i].SubEntries[a].Type1_14_1.Write(bytes, demFile.Section2Entries[i].SubEntries[a].ValueOffsets);
break;
case DEM_Type.DemoDataTypes.Type1_16_2:
bytes = demFile.Section2Entries[i].SubEntries[a].Type1_16_2.Write(bytes, demFile.Section2Entries[i].SubEntries[a].ValueOffsets);
break;
case DEM_Type.DemoDataTypes.Type1_20_12:
bytes = demFile.Section2Entries[i].SubEntries[a].Type1_20_12.Write(bytes, demFile.Section2Entries[i].SubEntries[a].ValueOffsets);
break;
case DEM_Type.DemoDataTypes.Type1_26_2:
bytes = demFile.Section2Entries[i].SubEntries[a].Type1_26_2.Write(bytes, demFile.Section2Entries[i].SubEntries[a].ValueOffsets);
break;
case DEM_Type.DemoDataTypes.Type1_27_2:
bytes = demFile.Section2Entries[i].SubEntries[a].Type1_27_2.Write(bytes, demFile.Section2Entries[i].SubEntries[a].ValueOffsets);
break;
case DEM_Type.DemoDataTypes.AnimationSmall:
bytes = demFile.Section2Entries[i].SubEntries[a].Type1_0_9.Write(bytes, demFile.Section2Entries[i].SubEntries[a].ValueOffsets);
break;
case DEM_Type.DemoDataTypes.Animation:
bytes = demFile.Section2Entries[i].SubEntries[a].Type1_0_10.Write(bytes, demFile.Section2Entries[i].SubEntries[a].ValueOffsets);
break;
case DEM_Type.DemoDataTypes.ActorVisibility:
bytes = demFile.Section2Entries[i].SubEntries[a].Type1_3_2.Write(bytes, demFile.Section2Entries[i].SubEntries[a].ValueOffsets);
break;
case DEM_Type.DemoDataTypes.ActorDamage:
bytes = demFile.Section2Entries[i].SubEntries[a].Type1_9_5.Write(bytes, demFile.Section2Entries[i].SubEntries[a].ValueOffsets);
break;
case DEM_Type.DemoDataTypes.Type1_10_8:
bytes = demFile.Section2Entries[i].SubEntries[a].Type1_10_8.Write(bytes, demFile.Section2Entries[i].SubEntries[a].ValueOffsets);
break;
case DEM_Type.DemoDataTypes.Type1_17_6:
bytes = demFile.Section2Entries[i].SubEntries[a].Type1_17_6.Write(bytes, demFile.Section2Entries[i].SubEntries[a].ValueOffsets);
break;
case DEM_Type.DemoDataTypes.Type1_19_3:
bytes = demFile.Section2Entries[i].SubEntries[a].Type1_19_3.Write(bytes, demFile.Section2Entries[i].SubEntries[a].ValueOffsets);
break;
case DEM_Type.DemoDataTypes.Type2_6_3:
bytes = demFile.Section2Entries[i].SubEntries[a].Type2_6_3.Write(bytes, demFile.Section2Entries[i].SubEntries[a].ValueOffsets);
break;
case DEM_Type.DemoDataTypes.Type2_7_5:
bytes = demFile.Section2Entries[i].SubEntries[a].Type2_7_5.Write(bytes, demFile.Section2Entries[i].SubEntries[a].ValueOffsets);
break;
case DEM_Type.DemoDataTypes.Type2_9_2:
bytes = demFile.Section2Entries[i].SubEntries[a].Type2_9_2.Write(bytes, demFile.Section2Entries[i].SubEntries[a].ValueOffsets);
break;
case DEM_Type.DemoDataTypes.Type2_10_2:
bytes = demFile.Section2Entries[i].SubEntries[a].Type2_10_2.Write(bytes, demFile.Section2Entries[i].SubEntries[a].ValueOffsets);
break;
case DEM_Type.DemoDataTypes.Type2_11_1:
bytes = demFile.Section2Entries[i].SubEntries[a].Type2_11_1.Write(bytes, demFile.Section2Entries[i].SubEntries[a].ValueOffsets);
break;
case DEM_Type.DemoDataTypes.Type3_0_1:
bytes = demFile.Section2Entries[i].SubEntries[a].Type3_0_1.Write(bytes, demFile.Section2Entries[i].SubEntries[a].ValueOffsets);
break;
case DEM_Type.DemoDataTypes.Type3_1_1:
bytes = demFile.Section2Entries[i].SubEntries[a].Type3_1_1.Write(bytes, demFile.Section2Entries[i].SubEntries[a].ValueOffsets);
break;
case DEM_Type.DemoDataTypes.Camera:
bytes = demFile.Section2Entries[i].SubEntries[a].Type2_0_1.Write(bytes, demFile.Section2Entries[i].SubEntries[a].ValueOffsets);
break;
case DEM_Type.DemoDataTypes.Type2_7_8:
bytes = demFile.Section2Entries[i].SubEntries[a].Type2_7_8.Write(bytes, demFile.Section2Entries[i].SubEntries[a].ValueOffsets);
break;
case DEM_Type.DemoDataTypes.Type3_2_1:
bytes = demFile.Section2Entries[i].SubEntries[a].Type3_2_1.Write(bytes, demFile.Section2Entries[i].SubEntries[a].ValueOffsets);
break;
case DEM_Type.DemoDataTypes.Type3_3_1:
bytes = demFile.Section2Entries[i].SubEntries[a].Type3_3_1.Write(bytes, demFile.Section2Entries[i].SubEntries[a].ValueOffsets);
break;
case DEM_Type.DemoDataTypes.Type3_4_2:
bytes = demFile.Section2Entries[i].SubEntries[a].Type3_4_2.Write(bytes, demFile.Section2Entries[i].SubEntries[a].ValueOffsets);
break;
case DEM_Type.DemoDataTypes.Effect:
bytes = demFile.Section2Entries[i].SubEntries[a].Type4_0_12.Write(bytes, demFile.Section2Entries[i].SubEntries[a].ValueOffsets);
break;
case DEM_Type.DemoDataTypes.ScreenEffect:
bytes = demFile.Section2Entries[i].SubEntries[a].Type4_1_8.Write(bytes, demFile.Section2Entries[i].SubEntries[a].ValueOffsets);
break;
case DEM_Type.DemoDataTypes.Type4_2_3:
bytes = demFile.Section2Entries[i].SubEntries[a].Type4_2_3.Write(bytes, demFile.Section2Entries[i].SubEntries[a].ValueOffsets);
break;
case DEM_Type.DemoDataTypes.Type4_3_5:
bytes = demFile.Section2Entries[i].SubEntries[a].Type4_3_5.Write(bytes, demFile.Section2Entries[i].SubEntries[a].ValueOffsets);
break;
case DEM_Type.DemoDataTypes.Type4_4_1:
bytes = demFile.Section2Entries[i].SubEntries[a].Type4_4_1.Write(bytes, demFile.Section2Entries[i].SubEntries[a].ValueOffsets);
break;
case DEM_Type.DemoDataTypes.Sound:
bytes = demFile.Section2Entries[i].SubEntries[a].Type5_0_3.Write(bytes, demFile.Section2Entries[i].SubEntries[a].ValueOffsets);
break;
case DEM_Type.DemoDataTypes.Music:
bytes = demFile.Section2Entries[i].SubEntries[a].Type5_2_3.Write(bytes, demFile.Section2Entries[i].SubEntries[a].ValueOffsets);
break;
case DEM_Type.DemoDataTypes.Type5_0_2:
bytes = demFile.Section2Entries[i].SubEntries[a].Type5_0_2.Write(bytes, demFile.Section2Entries[i].SubEntries[a].ValueOffsets);
break;
case DEM_Type.DemoDataTypes.Type5_1_2:
bytes = demFile.Section2Entries[i].SubEntries[a].Type5_1_2.Write(bytes, demFile.Section2Entries[i].SubEntries[a].ValueOffsets);
break;
case DEM_Type.DemoDataTypes.Type5_3_2:
bytes = demFile.Section2Entries[i].SubEntries[a].Type5_3_2.Write(bytes, demFile.Section2Entries[i].SubEntries[a].ValueOffsets);
break;
case DEM_Type.DemoDataTypes.Type5_4_3:
bytes = demFile.Section2Entries[i].SubEntries[a].Type5_4_3.Write(bytes, demFile.Section2Entries[i].SubEntries[a].ValueOffsets);
break;
case DEM_Type.DemoDataTypes.Type6_0_1:
bytes = demFile.Section2Entries[i].SubEntries[a].Type6_0_1.Write(bytes, demFile.Section2Entries[i].SubEntries[a].ValueOffsets);
break;
case DEM_Type.DemoDataTypes.DistanceFocus:
bytes = demFile.Section2Entries[i].SubEntries[a].Type6_16_6.Write(bytes, demFile.Section2Entries[i].SubEntries[a].ValueOffsets);
break;
case DEM_Type.DemoDataTypes.SpmControl:
bytes = demFile.Section2Entries[i].SubEntries[a].Type6_17_19.Write(bytes, demFile.Section2Entries[i].SubEntries[a].ValueOffsets);
break;
case DEM_Type.DemoDataTypes.Type6_18_7:
bytes = demFile.Section2Entries[i].SubEntries[a].Type6_18_7.Write(bytes, demFile.Section2Entries[i].SubEntries[a].ValueOffsets);
break;
case DEM_Type.DemoDataTypes.Type6_19_15:
bytes = demFile.Section2Entries[i].SubEntries[a].Type6_19_15.Write(bytes, demFile.Section2Entries[i].SubEntries[a].ValueOffsets);
break;
case DEM_Type.DemoDataTypes.Type6_20_2:
bytes = demFile.Section2Entries[i].SubEntries[a].Type6_20_2.Write(bytes, demFile.Section2Entries[i].SubEntries[a].ValueOffsets);
break;
case DEM_Type.DemoDataTypes.Type7_0_5:
bytes = demFile.Section2Entries[i].SubEntries[a].Type7_0_5.Write(bytes, demFile.Section2Entries[i].SubEntries[a].ValueOffsets);
break;
case DEM_Type.DemoDataTypes.YearDisplay:
bytes = demFile.Section2Entries[i].SubEntries[a].Type9_0_2.Write(bytes, demFile.Section2Entries[i].SubEntries[a].ValueOffsets);
break;
case DEM_Type.DemoDataTypes.Type9_1_5:
bytes = demFile.Section2Entries[i].SubEntries[a].Type9_1_5.Write(bytes, demFile.Section2Entries[i].SubEntries[a].ValueOffsets);
break;
case DEM_Type.DemoDataTypes.Type0_16_0:
case DEM_Type.DemoDataTypes.Type0_17_0:
case DEM_Type.DemoDataTypes.Type9_8_0:
//No values
break;
default:
throw new Exception(String.Format("Unrecognized DEM_Type: {0}", type));
}
}
}
//Pad file before UnkValues
bytes.Add(0);
FilePad();
bytes = Utils.ReplaceRange(bytes, BitConverter.GetBytes(bytes.Count), 56);
//UnkValues
for (int i = 0; i < unkValueCount; i++)
{
Assertion.AssertArraySize(demFile.DEM_UnkValues[i].Values, 40, "DEM_UnknownValues", "uint16s");
bytes.AddRange(BitConverter_Ex.GetBytes(demFile.DEM_UnkValues[i].Values));
}
}
private void Parse()
{
ecfFile.I_12 = BitConverter.ToUInt16(rawBytes, 12);
if (totalMainEntries > 0)
{
ecfFile.Entries = new List <ECF_Entry>();
for (int i = 0; i < totalMainEntries; i++)
{
ecfFile.Entries.Add(new ECF_Entry());
ecfFile.Entries[i].I_52 = (PlayMode)BitConverter.ToInt16(rawBytes, mainEntryOffset + 52);
ecfFile.Entries[i].F_00 = BitConverter.ToSingle(rawBytes, mainEntryOffset + 0);
ecfFile.Entries[i].F_04 = BitConverter.ToSingle(rawBytes, mainEntryOffset + 4);
ecfFile.Entries[i].F_08 = BitConverter.ToSingle(rawBytes, mainEntryOffset + 8);
ecfFile.Entries[i].F_12 = BitConverter.ToSingle(rawBytes, mainEntryOffset + 12);
ecfFile.Entries[i].F_16 = BitConverter.ToSingle(rawBytes, mainEntryOffset + 16);
ecfFile.Entries[i].F_20 = BitConverter.ToSingle(rawBytes, mainEntryOffset + 20);
ecfFile.Entries[i].F_24 = BitConverter.ToSingle(rawBytes, mainEntryOffset + 24);
ecfFile.Entries[i].F_28 = BitConverter.ToSingle(rawBytes, mainEntryOffset + 28);
ecfFile.Entries[i].F_32 = BitConverter.ToSingle(rawBytes, mainEntryOffset + 32);
ecfFile.Entries[i].F_36 = BitConverter.ToSingle(rawBytes, mainEntryOffset + 36);
ecfFile.Entries[i].F_40 = BitConverter.ToSingle(rawBytes, mainEntryOffset + 40);
ecfFile.Entries[i].F_44 = BitConverter.ToSingle(rawBytes, mainEntryOffset + 44);
ecfFile.Entries[i].F_48 = BitConverter.ToSingle(rawBytes, mainEntryOffset + 48);
ecfFile.Entries[i].I_54 = BitConverter.ToUInt16(rawBytes, mainEntryOffset + 54);
ecfFile.Entries[i].I_56 = BitConverter.ToUInt16(rawBytes, mainEntryOffset + 56);
ecfFile.Entries[i].I_58 = BitConverter.ToUInt16(rawBytes, mainEntryOffset + 58);
ecfFile.Entries[i].I_60 = BitConverter.ToUInt16(rawBytes, mainEntryOffset + 60);
ecfFile.Entries[i].I_62 = BitConverter.ToUInt16(rawBytes, mainEntryOffset + 62);
ecfFile.Entries[i].I_64 = new UInt16[14];
for (int a = 0; a < 28; a += 2)
{
ecfFile.Entries[i].I_64[a / 2] = BitConverter.ToUInt16(rawBytes, mainEntryOffset + 64 + a);
}
ecfFile.Entries[i].I_96 = BitConverter.ToUInt16(rawBytes, mainEntryOffset + 96);
//Type0 data
int Type0_Offset = BitConverter.ToInt32(rawBytes, mainEntryOffset + 100) + 96 + mainEntryOffset;
int Type0_Count = BitConverter.ToInt16(rawBytes, mainEntryOffset + 98);
if (Type0_Count > 0)
{
ecfFile.Entries[i].Type0 = new List <Type0>();
for (int a = 0; a < Type0_Count; a++)
{
int startOffset = BitConverter.ToInt32(rawBytes, Type0_Offset + 8) + Type0_Offset;
int floatOffset = BitConverter.ToInt32(rawBytes, Type0_Offset + 12) + Type0_Offset;
ecfFile.Entries[i].Type0.Add(new Type0()
{
I_00 = (ECF.Type0.Parameter)rawBytes[Type0_Offset + 0],
I_01_a = Type0.GetComponent((ECF.Type0.Parameter)rawBytes[Type0_Offset + 0], Int4Converter.ToInt4(rawBytes[Type0_Offset + 1])[0]),
I_01_b = BitConverter_Ex.ToBoolean(Int4Converter.ToInt4(rawBytes[Type0_Offset + 1])[1]),
I_02 = (rawBytes[Type0_Offset + 2] == 0)? false : true,
I_03 = rawBytes[Type0_Offset + 3],
I_04 = BitConverter.ToUInt16(rawBytes, Type0_Offset + 4),
Keyframes = ParseKeyframes(BitConverter.ToInt16(rawBytes, Type0_Offset + 6), startOffset, floatOffset)
});
Type0_Offset += 16;
}
}
//Unk_Str
int Str_Offset = BitConverter.ToInt32(rawBytes, mainEntryOffset + 92) + mainEntryOffset;
if (Str_Offset != 0)
{
ecfFile.Entries[i].Unk_Str = Utils.GetString(bytes, Str_Offset);
}
else
{
ecfFile.Entries[i].Unk_Str = String.Empty;
}
mainEntryOffset += 104;
}
}
}
private void ParseDem()
{
//Validation
if (BitConverter.ToInt16(rawBytes, 6) == 32)
{
throw new Exception("Xenoverse 1 DEM format not supported.");
}
if (BitConverter.ToInt16(rawBytes, 6) != 64 || BitConverter.ToInt32(rawBytes, 0) != DEM_File.DEM_SIGNATURE)
{
throw new Exception("DEM header validation failed.");
}
//Header
demFile.I_08 = BitConverter.ToInt32(rawBytes, 8);
int unkValuesCount = BitConverter.ToInt32(rawBytes, 16);
int unkValuesOffset = BitConverter.ToInt32(rawBytes, 56);
int nameOffset = BitConverter.ToInt32(rawBytes, 32);
int defineOffset = BitConverter.ToInt32(rawBytes, 48);
int section2Count = BitConverter.ToInt32(rawBytes, 12);
int section2Offset = BitConverter.ToInt32(rawBytes, 40);
//Name
demFile.Name = Utils.GetString(bytes, nameOffset, 16);
//Define Section
demFile.Settings = new DemoSettings()
{
Str_00 = Utils.GetString(bytes, BitConverter.ToInt32(rawBytes, defineOffset + 0)),
Str_08 = Utils.GetString(bytes, BitConverter.ToInt32(rawBytes, defineOffset + 8)),
Str_16 = Utils.GetString(bytes, BitConverter.ToInt32(rawBytes, defineOffset + 16)),
Str_24 = Utils.GetString(bytes, BitConverter.ToInt32(rawBytes, defineOffset + 24)),
Str_32 = Utils.GetString(bytes, BitConverter.ToInt32(rawBytes, defineOffset + 32)),
Str_40 = Utils.GetString(bytes, BitConverter.ToInt32(rawBytes, defineOffset + 40)),
Str_48 = Utils.GetString(bytes, BitConverter.ToInt32(rawBytes, defineOffset + 48)),
Str_56 = Utils.GetString(bytes, BitConverter.ToInt32(rawBytes, defineOffset + 56)),
Str_64 = Utils.GetString(bytes, BitConverter.ToInt32(rawBytes, defineOffset + 64)),
Str_72 = Utils.GetString(bytes, BitConverter.ToInt32(rawBytes, defineOffset + 72)),
Str_80 = Utils.GetString(bytes, BitConverter.ToInt32(rawBytes, defineOffset + 80)),
Str_88 = Utils.GetString(bytes, BitConverter.ToInt32(rawBytes, defineOffset + 88)),
Str_96 = Utils.GetString(bytes, BitConverter.ToInt32(rawBytes, defineOffset + 96)),
Str_104 = Utils.GetString(bytes, BitConverter.ToInt32(rawBytes, defineOffset + 104)),
Characters = ParseCharacters(BitConverter.ToInt32(rawBytes, defineOffset + 120), BitConverter.ToInt32(rawBytes, defineOffset + 116))
};
//Section 2
demFile.Section2Entries = new List <Section2Entry>();
for (int i = 0; i < section2Count; i++)
{
demFile.Section2Entries.Add(new Section2Entry()
{
I_00 = BitConverter.ToInt32(rawBytes, section2Offset + 0),
SubEntries = ParseSection2SubEntry(BitConverter.ToInt32(rawBytes, section2Offset + 8), BitConverter.ToInt32(rawBytes, section2Offset + 4))
});
section2Offset += 32;
}
//UnkValues
if (unkValuesCount > 0)
{
demFile.DEM_UnkValues = new List <DEM_UnknownValues>();
for (int i = 0; i < unkValuesCount; i++)
{
demFile.DEM_UnkValues.Add(new DEM_UnknownValues()
{
Values = BitConverter_Ex.ToUInt16Array(rawBytes, unkValuesOffset, 40)
});
unkValuesOffset += 80;
}
}
}
private void WriteBac()
{
SortEntries();
int count = (bacFile.BacEntries != null) ? bacFile.BacEntries.Count() : 0;
List <int> BacEntryOffsets = new List <int>();
List <List <int> > TypeOffsets = new List <List <int> >();
//Header
bytes.AddRange(BitConverter.GetBytes(count));
bytes.AddRange(new byte[4]);
bytes.AddRange(BitConverter.GetBytes(96));
bytes.AddRange(BitConverter_Ex.GetBytes(bacFile.I_20));
bytes.AddRange(BitConverter_Ex.GetBytes(bacFile.F_32));
bytes.AddRange(BitConverter_Ex.GetBytes(bacFile.I_80));
//Bac_Entries
for (int i = 0; i < count; i++)
{
if (bacFile.BacEntries[i].TypeDummy == null)
{
bacFile.BacEntries[i].TypeDummy = new List <int>();
}
bytes.AddRange(BitConverter.GetBytes((uint)bacFile.BacEntries[i].Flag));
bytes.AddRange(BitConverter.GetBytes((short)GetSubEntryCount(bacFile.BacEntries[i])));
bytes.AddRange(BitConverter.GetBytes((short)0));
BacEntryOffsets.Add(bytes.Count());
bytes.AddRange(new byte[8]);
}
//Bac_SubEntries
for (int i = 0; i < count; i++)
{
TypeOffsets.Add(new List <int>());
int subEntryCount = GetSubEntryCount(bacFile.BacEntries[i]);
int[] types = GetSubEntryTypes(bacFile.BacEntries[i]);
if (subEntryCount > 0)
{
bytes = Utils.ReplaceRange(bytes, BitConverter.GetBytes(bytes.Count()), BacEntryOffsets[i]);
for (int a = 0; a < subEntryCount; a++)
{
bytes.AddRange(BitConverter.GetBytes((short)types[a]));
bytes.AddRange(BitConverter.GetBytes((short)GetTypeCount(bacFile.BacEntries[i], types[a])));
bytes.AddRange(new byte[4]);
TypeOffsets[i].Add(bytes.Count());
bytes.AddRange(new byte[8]);
}
}
}
//Bac Types
for (int i = 0; i < count; i++)
{
int subEntryCount = GetSubEntryCount(bacFile.BacEntries[i]);
int[] types = GetSubEntryTypes(bacFile.BacEntries[i]);
for (int a = 0; a < subEntryCount; a++)
{
if (bacFile.BacEntries[i].TypeDummy.IndexOf(types[a]) == -1)
{
bytes = Utils.ReplaceRange(bytes, BitConverter.GetBytes(bytes.Count()), TypeOffsets[i][a]);
switch (types[a])
{
case 0:
bytes.AddRange(BAC_Type0.Write(bacFile.BacEntries[i].Type0));
break;
case 1:
bytes.AddRange(BAC_Type1.Write(bacFile.BacEntries[i].Type1));
break;
case 2:
bytes.AddRange(BAC_Type2.Write(bacFile.BacEntries[i].Type2));
break;
case 3:
bytes.AddRange(BAC_Type3.Write(bacFile.BacEntries[i].Type3));
break;
case 4:
bytes.AddRange(BAC_Type4.Write(bacFile.BacEntries[i].Type4));
break;
case 5:
bytes.AddRange(BAC_Type5.Write(bacFile.BacEntries[i].Type5));
break;
case 6:
bytes.AddRange(BAC_Type6.Write(bacFile.BacEntries[i].Type6));
break;
case 7:
bytes.AddRange(BAC_Type7.Write(bacFile.BacEntries[i].Type7));
break;
case 8:
bytes.AddRange(BAC_Type8.Write(bacFile.BacEntries[i].Type8));
break;
case 9:
bytes.AddRange(BAC_Type9.Write(bacFile.BacEntries[i].Type9));
break;
case 10:
bytes.AddRange(BAC_Type10.Write(bacFile.BacEntries[i].Type10));
break;
case 11:
bytes.AddRange(BAC_Type11.Write(bacFile.BacEntries[i].Type11));
break;
case 12:
bytes.AddRange(BAC_Type12.Write(bacFile.BacEntries[i].Type12));
break;
case 13:
bytes.AddRange(BAC_Type13.Write(bacFile.BacEntries[i].Type13));
break;
case 14:
bytes.AddRange(BAC_Type14.Write(bacFile.BacEntries[i].Type14));
break;
case 15:
bytes.AddRange(BAC_Type15.Write(bacFile.BacEntries[i].Type15));
break;
case 16:
bytes.AddRange(BAC_Type16.Write(bacFile.BacEntries[i].Type16));
break;
case 17:
bytes.AddRange(BAC_Type17.Write(bacFile.BacEntries[i].Type17));
break;
case 18:
bytes.AddRange(BAC_Type18.Write(bacFile.BacEntries[i].Type18));
break;
case 19:
bytes.AddRange(BAC_Type19.Write(bacFile.BacEntries[i].Type19));
break;
case 20:
bytes.AddRange(BAC_Type20.Write(bacFile.BacEntries[i].Type20));
break;
case 21:
bytes.AddRange(BAC_Type21.Write(bacFile.BacEntries[i].Type21));
break;
case 22:
bytes.AddRange(BAC_Type22.Write(bacFile.BacEntries[i].Type22));
break;
case 23:
bytes.AddRange(BAC_Type23.Write(bacFile.BacEntries[i].Type23));
break;
case 24:
bytes.AddRange(BAC_Type24.Write(bacFile.BacEntries[i].Type24));
break;
case 25:
bytes.AddRange(BAC_Type25.Write(bacFile.BacEntries[i].Type25));
break;
case 26:
bytes.AddRange(BAC_Type26.Write(bacFile.BacEntries[i].Type26));
break;
case 27:
bytes.AddRange(BAC_Type27.Write(bacFile.BacEntries[i].Type27));
break;
}
}
}
}
}
private void WriteSkeleton(ESK_Skeleton skeleton, int offsetToReplace)
{
List <ESK_BoneNonHierarchal> bones = eskFile.Skeleton.GetNonHierarchalBoneList();
bytes = Utils.ReplaceRange(bytes, BitConverter.GetBytes(bytes.Count()), offsetToReplace);
int startOffset = bytes.Count();
int count = (bones != null) ? bones.Count() : 0;
bytes.AddRange(BitConverter.GetBytes((short)count));
bytes.AddRange(BitConverter.GetBytes(skeleton.I_02));
bytes.AddRange(new byte[24]);
bytes.AddRange(BitConverter_Ex.GetBytes(skeleton.I_28));
if (count > 0)
{
//Writing Index List
bytes = Utils.ReplaceRange(bytes, BitConverter.GetBytes(bytes.Count() - startOffset), startOffset + 4);
for (int i = 0; i < count; i++)
{
bytes.AddRange(BitConverter.GetBytes(bones[i].Index1));
bytes.AddRange(BitConverter.GetBytes(bones[i].Index2));
bytes.AddRange(BitConverter.GetBytes(bones[i].Index3));
bytes.AddRange(BitConverter.GetBytes(bones[i].Index4));
}
//Writing Name Table and List
bytes = Utils.ReplaceRange(bytes, BitConverter.GetBytes(bytes.Count() - startOffset), startOffset + 8);
List <StringWriter.StringInfo> stringInfo = new List <StringWriter.StringInfo>();
for (int i = 0; i < count; i++)
{
stringInfo.Add(new StringWriter.StringInfo()
{
StringToWrite = bones[i].Name,
Offset = bytes.Count(),
RelativeOffset = startOffset
});
bytes.AddRange(new byte[4]);
}
for (int i = 0; i < count; i++)
{
bytes = Utils.ReplaceRange(bytes, BitConverter.GetBytes(bytes.Count() - stringInfo[i].RelativeOffset), stringInfo[i].Offset);
bytes.AddRange(Encoding.ASCII.GetBytes(stringInfo[i].StringToWrite));
bytes.Add(0);
}
//Writing RelativeTransform
StartNewLine();
bytes = Utils.ReplaceRange(bytes, BitConverter.GetBytes(bytes.Count() - startOffset), startOffset + 12);
for (int i = 0; i < count; i++)
{
bytes.AddRange(BitConverter.GetBytes(bones[i].RelativeTransform.F_00));
bytes.AddRange(BitConverter.GetBytes(bones[i].RelativeTransform.F_04));
bytes.AddRange(BitConverter.GetBytes(bones[i].RelativeTransform.F_08));
bytes.AddRange(BitConverter.GetBytes(bones[i].RelativeTransform.F_12));
bytes.AddRange(BitConverter.GetBytes(bones[i].RelativeTransform.F_16));
bytes.AddRange(BitConverter.GetBytes(bones[i].RelativeTransform.F_20));
bytes.AddRange(BitConverter.GetBytes(bones[i].RelativeTransform.F_24));
bytes.AddRange(BitConverter.GetBytes(bones[i].RelativeTransform.F_28));
bytes.AddRange(BitConverter.GetBytes(bones[i].RelativeTransform.F_32));
bytes.AddRange(BitConverter.GetBytes(bones[i].RelativeTransform.F_36));
bytes.AddRange(BitConverter.GetBytes(bones[i].RelativeTransform.F_40));
bytes.AddRange(BitConverter.GetBytes(bones[i].RelativeTransform.F_44));
}
//Writing AbsoluteTransform (esk only)
StartNewLine();
bytes = Utils.ReplaceRange(bytes, BitConverter.GetBytes(bytes.Count() - startOffset), startOffset + 16);
for (int i = 0; i < count; i++)
{
bytes.AddRange(BitConverter.GetBytes(bones[i].AbsoluteTransform.F_00));
bytes.AddRange(BitConverter.GetBytes(bones[i].AbsoluteTransform.F_04));
bytes.AddRange(BitConverter.GetBytes(bones[i].AbsoluteTransform.F_08));
bytes.AddRange(BitConverter.GetBytes(bones[i].AbsoluteTransform.F_12));
bytes.AddRange(BitConverter.GetBytes(bones[i].AbsoluteTransform.F_16));
bytes.AddRange(BitConverter.GetBytes(bones[i].AbsoluteTransform.F_20));
bytes.AddRange(BitConverter.GetBytes(bones[i].AbsoluteTransform.F_24));
bytes.AddRange(BitConverter.GetBytes(bones[i].AbsoluteTransform.F_28));
bytes.AddRange(BitConverter.GetBytes(bones[i].AbsoluteTransform.F_32));
bytes.AddRange(BitConverter.GetBytes(bones[i].AbsoluteTransform.F_36));
bytes.AddRange(BitConverter.GetBytes(bones[i].AbsoluteTransform.F_40));
bytes.AddRange(BitConverter.GetBytes(bones[i].AbsoluteTransform.F_44));
bytes.AddRange(BitConverter.GetBytes(bones[i].AbsoluteTransform.F_48));
bytes.AddRange(BitConverter.GetBytes(bones[i].AbsoluteTransform.F_52));
bytes.AddRange(BitConverter.GetBytes(bones[i].AbsoluteTransform.F_56));
bytes.AddRange(BitConverter.GetBytes(bones[i].AbsoluteTransform.F_60));
}
//Writing Unk1
if (skeleton.Unk1 != null)
{
bytes = Utils.ReplaceRange(bytes, BitConverter.GetBytes(bytes.Count() - startOffset), startOffset + 20);
bytes.AddRange(BitConverter.GetBytes(skeleton.Unk1.I_00));
bytes.AddRange(BitConverter.GetBytes(skeleton.Unk1.I_04));
bytes.AddRange(BitConverter.GetBytes(skeleton.Unk1.I_08));
bytes.AddRange(BitConverter.GetBytes(skeleton.Unk1.I_12));
bytes.AddRange(BitConverter.GetBytes(skeleton.Unk1.I_16));
bytes.AddRange(BitConverter.GetBytes(skeleton.Unk1.I_20));
bytes.AddRange(BitConverter.GetBytes(skeleton.Unk1.I_24));
bytes.AddRange(BitConverter.GetBytes(skeleton.Unk1.I_28));
bytes.AddRange(BitConverter.GetBytes(skeleton.Unk1.I_32));
bytes.AddRange(BitConverter.GetBytes(skeleton.Unk1.I_36));
bytes.AddRange(BitConverter.GetBytes(skeleton.Unk1.I_40));
bytes.AddRange(BitConverter.GetBytes(skeleton.Unk1.I_44));
bytes.AddRange(BitConverter.GetBytes(skeleton.Unk1.I_48));
bytes.AddRange(BitConverter.GetBytes(skeleton.Unk1.I_52));
bytes.AddRange(BitConverter.GetBytes(skeleton.Unk1.I_56));
bytes.AddRange(BitConverter.GetBytes(skeleton.Unk1.I_60));
bytes.AddRange(BitConverter.GetBytes(skeleton.Unk1.I_64));
bytes.AddRange(BitConverter.GetBytes(skeleton.Unk1.I_68));
bytes.AddRange(BitConverter.GetBytes(skeleton.Unk1.I_72));
bytes.AddRange(BitConverter.GetBytes(skeleton.Unk1.I_76));
bytes.AddRange(BitConverter.GetBytes(skeleton.Unk1.I_80));
bytes.AddRange(BitConverter.GetBytes(skeleton.Unk1.I_84));
bytes.AddRange(BitConverter.GetBytes(skeleton.Unk1.I_88));
bytes.AddRange(BitConverter.GetBytes(skeleton.Unk1.I_92));
bytes.AddRange(BitConverter.GetBytes(skeleton.Unk1.I_96));
bytes.AddRange(BitConverter.GetBytes(skeleton.Unk1.I_100));
bytes.AddRange(BitConverter.GetBytes(skeleton.Unk1.I_104));
bytes.AddRange(BitConverter.GetBytes(skeleton.Unk1.I_108));
bytes.AddRange(BitConverter.GetBytes(skeleton.Unk1.I_112));
bytes.AddRange(BitConverter.GetBytes(skeleton.Unk1.I_116));
bytes.AddRange(BitConverter.GetBytes(skeleton.Unk1.I_120));
}
//Writing Unk2
if (skeleton.UseUnk2 == true && count > 0)
{
bytes = Utils.ReplaceRange(bytes, BitConverter.GetBytes(bytes.Count() - startOffset), startOffset + 24);
for (int i = 0; i < count; i++)
{
bytes.AddRange(BitConverter.GetBytes(281470681743360));
}
}
}
}
void ParseCharacters()
{
int offset = chara1Offset;
for (int i = 0; i < chara1Count; i++)
{
qxd_File.Characters1.Add(new Quest_Characters()
{
Index = BitConverter.ToInt32(rawBytes, offset).ToString(),
CharaShortName = StringEx.GetString(bytes, offset + 4, false, StringEx.EncodingType.ASCII, 3),
I_08 = BitConverter.ToInt32(rawBytes, offset + 8),
I_12 = BitConverter.ToInt32(rawBytes, offset + 12),
I_16 = BitConverter.ToInt32(rawBytes, offset + 16),
F_20 = BitConverter.ToSingle(rawBytes, offset + 20),
F_24 = BitConverter.ToSingle(rawBytes, offset + 24),
F_28 = BitConverter.ToSingle(rawBytes, offset + 28),
F_32 = BitConverter.ToSingle(rawBytes, offset + 32),
F_36 = BitConverter.ToSingle(rawBytes, offset + 36),
F_40 = BitConverter.ToSingle(rawBytes, offset + 40),
F_44 = BitConverter.ToSingle(rawBytes, offset + 44),
F_48 = BitConverter.ToSingle(rawBytes, offset + 48),
F_52 = BitConverter.ToSingle(rawBytes, offset + 52),
F_56 = BitConverter.ToSingle(rawBytes, offset + 56),
F_60 = BitConverter.ToSingle(rawBytes, offset + 60),
F_64 = BitConverter.ToSingle(rawBytes, offset + 64),
F_68 = BitConverter.ToSingle(rawBytes, offset + 68),
F_72 = BitConverter.ToSingle(rawBytes, offset + 72),
F_76 = BitConverter.ToSingle(rawBytes, offset + 76),
F_80 = BitConverter.ToSingle(rawBytes, offset + 80),
I_84 = BitConverter.ToInt32(rawBytes, offset + 84).ToString(),
_Skills = new Skills
{
I_00 = BitConverter.ToUInt16(rawBytes, offset + 88).ToString(),
I_02 = BitConverter.ToUInt16(rawBytes, offset + 90).ToString(),
I_04 = BitConverter.ToUInt16(rawBytes, offset + 92).ToString(),
I_06 = BitConverter.ToUInt16(rawBytes, offset + 94).ToString(),
I_08 = BitConverter.ToUInt16(rawBytes, offset + 96).ToString(),
I_10 = BitConverter.ToUInt16(rawBytes, offset + 98).ToString(),
I_12 = BitConverter.ToUInt16(rawBytes, offset + 100).ToString(),
I_14 = BitConverter.ToUInt16(rawBytes, offset + 102).ToString(),
I_16 = BitConverter.ToUInt16(rawBytes, offset + 104).ToString(),
},
I_106 = BitConverter_Ex.ToInt16Array(rawBytes, offset + 106, 7),
I_120 = BitConverter.ToInt16(rawBytes, offset + 120),
I_122 = BitConverter.ToUInt16(rawBytes, offset + 122).ToString()
});
offset += 124;
}
offset = chara2Offset;
for (int i = 0; i < chara2Count; i++)
{
qxd_File.Characters2.Add(new Quest_Characters()
{
Index = BitConverter.ToInt32(rawBytes, offset).ToString(),
CharaShortName = StringEx.GetString(bytes, offset + 4, false, StringEx.EncodingType.ASCII),
I_08 = BitConverter.ToInt32(rawBytes, offset + 8),
I_12 = BitConverter.ToInt32(rawBytes, offset + 12),
I_16 = BitConverter.ToInt32(rawBytes, offset + 16),
F_20 = BitConverter.ToSingle(rawBytes, offset + 20),
F_24 = BitConverter.ToSingle(rawBytes, offset + 24),
F_28 = BitConverter.ToSingle(rawBytes, offset + 28),
F_32 = BitConverter.ToSingle(rawBytes, offset + 32),
F_36 = BitConverter.ToSingle(rawBytes, offset + 36),
F_40 = BitConverter.ToSingle(rawBytes, offset + 40),
F_44 = BitConverter.ToSingle(rawBytes, offset + 44),
F_48 = BitConverter.ToSingle(rawBytes, offset + 48),
F_52 = BitConverter.ToSingle(rawBytes, offset + 52),
F_56 = BitConverter.ToSingle(rawBytes, offset + 56),
F_60 = BitConverter.ToSingle(rawBytes, offset + 60),
F_64 = BitConverter.ToSingle(rawBytes, offset + 64),
F_68 = BitConverter.ToSingle(rawBytes, offset + 68),
F_72 = BitConverter.ToSingle(rawBytes, offset + 72),
F_76 = BitConverter.ToSingle(rawBytes, offset + 76),
F_80 = BitConverter.ToSingle(rawBytes, offset + 80),
I_84 = BitConverter.ToInt32(rawBytes, offset + 84).ToString(),
_Skills = new Skills
{
I_00 = BitConverter.ToUInt16(rawBytes, offset + 88).ToString(),
I_02 = BitConverter.ToUInt16(rawBytes, offset + 90).ToString(),
I_04 = BitConverter.ToUInt16(rawBytes, offset + 92).ToString(),
I_06 = BitConverter.ToUInt16(rawBytes, offset + 94).ToString(),
I_08 = BitConverter.ToUInt16(rawBytes, offset + 96).ToString(),
I_10 = BitConverter.ToUInt16(rawBytes, offset + 98).ToString(),
I_12 = BitConverter.ToUInt16(rawBytes, offset + 100).ToString(),
I_14 = BitConverter.ToUInt16(rawBytes, offset + 102).ToString(),
I_16 = BitConverter.ToUInt16(rawBytes, offset + 104).ToString(),
},
I_106 = BitConverter_Ex.ToInt16Array(rawBytes, offset + 106, 7),
I_120 = BitConverter.ToInt16(rawBytes, offset + 120),
I_122 = BitConverter.ToUInt16(rawBytes, offset + 122).ToString()
});
offset += 124;
}
}
private void ParseBac()
{
int offset = BitConverter.ToInt32(rawBytes, 16);
int count = BitConverter.ToInt32(rawBytes, 8);
bacFile.I_20 = BitConverter_Ex.ToInt32Array(rawBytes, 20, 3);
bacFile.F_32 = BitConverter_Ex.ToFloat32Array(rawBytes, 32, 12);
bacFile.I_80 = BitConverter_Ex.ToInt32Array(rawBytes, 80, 4);
bacFile.BacEntries = AsyncObservableCollection <BAC_Entry> .Create();
for (int i = 0; i < count; i++)
{
int typeListOffset = BitConverter.ToInt32(rawBytes, offset + 8);
int typeListCount = BitConverter.ToInt16(rawBytes, offset + 4);
bacFile.BacEntries.Add(new BAC_Entry()
{
Flag = (BAC_Entry.Flags)BitConverter.ToUInt32(rawBytes, offset + 0),
Index = i.ToString()
});
for (int a = 0; a < typeListCount; a++)
{
int thisType = BitConverter.ToInt16(rawBytes, typeListOffset + 0);
int thisTypeCount = BitConverter.ToInt16(rawBytes, typeListOffset + 2);
int thisTypeOffset = BitConverter.ToInt32(rawBytes, typeListOffset + 8);
if (thisTypeOffset != 0)
{
switch (thisType)
{
case 0:
bacFile.BacEntries[i].Type0 = BAC_Type0.Read(rawBytes, bytes, thisTypeOffset, thisTypeCount);
break;
case 1:
bacFile.BacEntries[i].Type1 = BAC_Type1.Read(rawBytes, bytes, thisTypeOffset, thisTypeCount);
break;
case 2:
bacFile.BacEntries[i].Type2 = BAC_Type2.Read(rawBytes, bytes, thisTypeOffset, thisTypeCount);
break;
case 3:
bacFile.BacEntries[i].Type3 = BAC_Type3.Read(rawBytes, bytes, thisTypeOffset, thisTypeCount);
break;
case 4:
bacFile.BacEntries[i].Type4 = BAC_Type4.Read(rawBytes, bytes, thisTypeOffset, thisTypeCount);
break;
case 5:
bacFile.BacEntries[i].Type5 = BAC_Type5.Read(rawBytes, bytes, thisTypeOffset, thisTypeCount);
break;
case 6:
bacFile.BacEntries[i].Type6 = BAC_Type6.Read(rawBytes, bytes, thisTypeOffset, thisTypeCount);
break;
case 7:
bacFile.BacEntries[i].Type7 = BAC_Type7.Read(rawBytes, bytes, thisTypeOffset, thisTypeCount);
break;
case 8:
bacFile.BacEntries[i].Type8 = BAC_Type8.Read(rawBytes, bytes, thisTypeOffset, thisTypeCount);
break;
case 9:
bacFile.BacEntries[i].Type9 = BAC_Type9.Read(rawBytes, bytes, thisTypeOffset, thisTypeCount);
break;
case 10:
bacFile.BacEntries[i].Type10 = BAC_Type10.Read(rawBytes, bytes, thisTypeOffset, thisTypeCount);
break;
case 11:
bacFile.BacEntries[i].Type11 = BAC_Type11.Read(rawBytes, bytes, thisTypeOffset, thisTypeCount);
break;
case 12:
bacFile.BacEntries[i].Type12 = BAC_Type12.Read(rawBytes, bytes, thisTypeOffset, thisTypeCount);
break;
case 13:
bacFile.BacEntries[i].Type13 = BAC_Type13.Read(rawBytes, bytes, thisTypeOffset, thisTypeCount);
break;
case 14:
bacFile.BacEntries[i].Type14 = BAC_Type14.Read(rawBytes, bytes, thisTypeOffset, thisTypeCount);
break;
case 15:
bacFile.BacEntries[i].Type15 = BAC_Type15.Read(rawBytes, bytes, thisTypeOffset, thisTypeCount);
break;
case 16:
bacFile.BacEntries[i].Type16 = BAC_Type16.Read(rawBytes, bytes, thisTypeOffset, thisTypeCount);
break;
case 17:
bacFile.BacEntries[i].Type17 = BAC_Type17.Read(rawBytes, bytes, thisTypeOffset, thisTypeCount, IsType17Small(thisTypeOffset, thisTypeCount, i));
break;
case 18:
bacFile.BacEntries[i].Type18 = BAC_Type18.Read(rawBytes, bytes, thisTypeOffset, thisTypeCount);
break;
case 19:
bacFile.BacEntries[i].Type19 = BAC_Type19.Read(rawBytes, bytes, thisTypeOffset, thisTypeCount);
break;
case 20:
bacFile.BacEntries[i].Type20 = BAC_Type20.Read(rawBytes, bytes, thisTypeOffset, thisTypeCount);
break;
case 21:
bacFile.BacEntries[i].Type21 = BAC_Type21.Read(rawBytes, bytes, thisTypeOffset, thisTypeCount);
break;
case 22:
bacFile.BacEntries[i].Type22 = BAC_Type22.Read(rawBytes, bytes, thisTypeOffset, thisTypeCount);
break;
case 23:
bacFile.BacEntries[i].Type23 = BAC_Type23.Read(rawBytes, bytes, thisTypeOffset, thisTypeCount);
break;
case 24:
bacFile.BacEntries[i].Type24 = BAC_Type24.Read(rawBytes, bytes, thisTypeOffset, thisTypeCount);
break;
case 25:
bacFile.BacEntries[i].Type25 = BAC_Type25.Read(rawBytes, bytes, thisTypeOffset, thisTypeCount);
break;
case 26:
bacFile.BacEntries[i].Type26 = BAC_Type26.Read(rawBytes, bytes, thisTypeOffset, thisTypeCount);
break;
case 27:
bacFile.BacEntries[i].Type27 = BAC_Type27.Read(rawBytes, bytes, thisTypeOffset, thisTypeCount);
break;
default:
throw new InvalidDataException(String.Format("Parse failed. Unknown BacType encountered ({0})\nOffset: {1}\nCount: {2}.", thisType, thisTypeOffset, thisTypeCount));
}
}
else
{
if (bacFile.BacEntries[i].TypeDummy == null)
{
bacFile.BacEntries[i].TypeDummy = new List <int>();
}
bacFile.BacEntries[i].TypeDummy.Add(thisType);
}
typeListOffset += 16;
}
offset += 16;
}
}
private void Write()
{
//Header
int I_18 = (bcsFile.SkeletonData2 != null) ? 1 : 0;
byte[] _i_44 = { bcsFile.Race, Convert.ToByte(bcsFile.Sex), 0, 0 };
bytes.AddRange(BitConverter.GetBytes((short)PartSetCount));
bytes.AddRange(BitConverter.GetBytes((short)PartColorCount));
bytes.AddRange(BitConverter.GetBytes((short)BodyCount));
bytes.AddRange(BitConverter.GetBytes((short)I_18));
bytes.AddRange(new byte[24]);
bytes.AddRange(_i_44);
Assertion.AssertArraySize(bcsFile.F_48, 7, "BCS", "F_48");
bytes.AddRange(BitConverter_Ex.GetBytes(bcsFile.F_48));
//PartSet Table
if (bcsFile.PartSets != null)
{
bytes = Utils.ReplaceRange(bytes, BitConverter.GetBytes(bytes.Count()), 24);
for (int i = 0; i < PartSetCount; i++)
{
for (int a = 0; a < bcsFile.PartSets.Count; a++)
{
if (int.Parse(bcsFile.PartSets[a].Index) == i)
{
PartSetTable.Add(bytes.Count());
bytes.AddRange(new byte[4]);
break;
}
else if (a == bcsFile.PartSets.Count() - 1)
{
//Null entry
bytes.AddRange(new byte[4]);
break;
}
}
}
}
//PartColor Table
if (bcsFile.Part_Colors != null)
{
bytes = Utils.ReplaceRange(bytes, BitConverter.GetBytes(bytes.Count()), 28);
for (int i = 0; i < PartColorCount; i++)
{
for (int a = 0; a < bcsFile.Part_Colors.Count(); a++)
{
if (int.Parse(bcsFile.Part_Colors[a].Index) == i)
{
PartColorTable.Add(bytes.Count());
bytes.AddRange(new byte[4]);
break;
}
else if (a == bcsFile.Part_Colors.Count() - 1)
{
//Null entry
bytes.AddRange(new byte[4]);
break;
}
}
}
}
//Body Table
if (bcsFile.Bodies != null)
{
bytes = Utils.ReplaceRange(bytes, BitConverter.GetBytes(bytes.Count()), 32);
for (int i = 0; i < BodyCount; i++)
{
for (int a = 0; a < bcsFile.Bodies.Count(); a++)
{
if (int.Parse(bcsFile.Bodies[a].Index) == i)
{
BodyTable.Add(bytes.Count());
bytes.AddRange(new byte[4]);
break;
}
else if (a == bcsFile.Bodies.Count() - 1)
{
//Null entry
bytes.AddRange(new byte[4]);
break;
}
}
}
}
//Skeleton1 Table
if (bcsFile.SkeletonData1 != null)
{
bytes = Utils.ReplaceRange(bytes, BitConverter.GetBytes(bytes.Count()), 40);
Skeleton1Table = bytes.Count();
bytes.AddRange(new byte[4]);
}
//Skeleton2 Table
if (bcsFile.SkeletonData2 != null)
{
bytes = Utils.ReplaceRange(bytes, BitConverter.GetBytes(bytes.Count()), 36);
Skeleton2Table = bytes.Count();
bytes.AddRange(new byte[4]);
}
//PartSets
if (bcsFile.PartSets != null)
{
for (int i = 0; i < bcsFile.PartSets.Count(); i++)
{
bytes = Utils.ReplaceRange(bytes, BitConverter.GetBytes(bytes.Count()), PartSetTable[i]);
int PartSetStart = bytes.Count();
bytes.AddRange(new byte[20]);
bytes.AddRange(BitConverter.GetBytes(10));
bytes.AddRange(BitConverter.GetBytes(32));
bytes.AddRange(new byte[4]);
int[] PartSetSubTable = new int[10] {
bytes.Count() + 0, bytes.Count() + 4, bytes.Count() + 8, bytes.Count() + 12, bytes.Count() + 16, bytes.Count() + 20, bytes.Count() + 24, bytes.Count() + 28, bytes.Count() + 32, bytes.Count() + 36
};
bytes.AddRange(new byte[40]);
//Parts
WritePart(bcsFile.PartSets[i].FaceBase, PartSetSubTable[0], PartSetStart);
WritePart(bcsFile.PartSets[i].FaceForehead, PartSetSubTable[1], PartSetStart);
WritePart(bcsFile.PartSets[i].FaceEye, PartSetSubTable[2], PartSetStart);
WritePart(bcsFile.PartSets[i].FaceNose, PartSetSubTable[3], PartSetStart);
WritePart(bcsFile.PartSets[i].FaceEar, PartSetSubTable[4], PartSetStart);
WritePart(bcsFile.PartSets[i].Hair, PartSetSubTable[5], PartSetStart);
WritePart(bcsFile.PartSets[i].Bust, PartSetSubTable[6], PartSetStart);
WritePart(bcsFile.PartSets[i].Pants, PartSetSubTable[7], PartSetStart);
WritePart(bcsFile.PartSets[i].Rist, PartSetSubTable[8], PartSetStart);
WritePart(bcsFile.PartSets[i].Boots, PartSetSubTable[9], PartSetStart);
}
}
//PartColors
if (bcsFile.Part_Colors != null)
{
List <int> PartColorOffsets = new List <int>();
for (int i = 0; i < bcsFile.Part_Colors.Count(); i++)
{
bytes = Utils.ReplaceRange(bytes, BitConverter.GetBytes(bytes.Count()), PartColorTable[i]);
int PartColorStart = bytes.Count();
int colorCount = (bcsFile.Part_Colors[i]._Colors != null) ? bcsFile.Part_Colors[i]._Colors.Count() : 0;
stringInfo.Add(new StringWriter.StringInfo()
{
Offset = bytes.Count(),
RelativeOffset = PartColorStart,
StringToWrite = bcsFile.Part_Colors[i].Str_00
});
bytes.AddRange(new byte[10]);
bytes.AddRange(BitConverter.GetBytes((short)colorCount));
PartColorOffsets.Add(bytes.Count());
bytes.AddRange(new byte[4]);
}
for (int i = 0; i < bcsFile.Part_Colors.Count(); i++)
{
if (bcsFile.Part_Colors[i]._Colors != null)
{
bytes = Utils.ReplaceRange(bytes, BitConverter.GetBytes(bytes.Count() - PartColorOffsets[i] + 12), PartColorOffsets[i]);
for (int a = 0; a < bcsFile.Part_Colors[i]._Colors.Count(); a++)
{
bytes.AddRange(BitConverter.GetBytes(bcsFile.Part_Colors[i]._Colors[a].F_00));
bytes.AddRange(BitConverter.GetBytes(bcsFile.Part_Colors[i]._Colors[a].F_04));
bytes.AddRange(BitConverter.GetBytes(bcsFile.Part_Colors[i]._Colors[a].F_08));
bytes.AddRange(BitConverter.GetBytes(bcsFile.Part_Colors[i]._Colors[a].F_12));
bytes.AddRange(BitConverter.GetBytes(bcsFile.Part_Colors[i]._Colors[a].F_16));
bytes.AddRange(BitConverter.GetBytes(bcsFile.Part_Colors[i]._Colors[a].F_20));
bytes.AddRange(BitConverter.GetBytes(bcsFile.Part_Colors[i]._Colors[a].F_24));
bytes.AddRange(BitConverter.GetBytes(bcsFile.Part_Colors[i]._Colors[a].F_28));
bytes.AddRange(BitConverter.GetBytes(bcsFile.Part_Colors[i]._Colors[a].F_32));
bytes.AddRange(BitConverter.GetBytes(bcsFile.Part_Colors[i]._Colors[a].F_36));
bytes.AddRange(BitConverter.GetBytes(bcsFile.Part_Colors[i]._Colors[a].F_40));
bytes.AddRange(BitConverter.GetBytes(bcsFile.Part_Colors[i]._Colors[a].F_44));
bytes.AddRange(BitConverter.GetBytes(bcsFile.Part_Colors[i]._Colors[a].F_48));
bytes.AddRange(BitConverter.GetBytes(bcsFile.Part_Colors[i]._Colors[a].F_52));
bytes.AddRange(BitConverter.GetBytes(bcsFile.Part_Colors[i]._Colors[a].F_56));
bytes.AddRange(BitConverter.GetBytes(bcsFile.Part_Colors[i]._Colors[a].F_60));
bytes.AddRange(BitConverter.GetBytes(bcsFile.Part_Colors[i]._Colors[a].F_64));
bytes.AddRange(BitConverter.GetBytes(bcsFile.Part_Colors[i]._Colors[a].F_68));
bytes.AddRange(BitConverter.GetBytes(bcsFile.Part_Colors[i]._Colors[a].F_72));
bytes.AddRange(BitConverter.GetBytes(bcsFile.Part_Colors[i]._Colors[a].F_76));
}
}
}
}
//Bodies
if (bcsFile.Bodies != null)
{
List <int> BodyOffsets = new List <int>();
for (int i = 0; i < bcsFile.Bodies.Count(); i++)
{
bytes = Utils.ReplaceRange(bytes, BitConverter.GetBytes(bytes.Count()), BodyTable[i]);
int bodyScalesCount = (bcsFile.Bodies[i].BodyScales != null) ? bcsFile.Bodies[i].BodyScales.Count() : 0;
bytes.AddRange(new byte[2]);
bytes.AddRange(BitConverter.GetBytes((short)bodyScalesCount));
BodyOffsets.Add(bytes.Count());
bytes.AddRange(new byte[4]);
}
for (int i = 0; i < bcsFile.Bodies.Count(); i++)
{
if (bcsFile.Bodies[i].BodyScales != null)
{
bytes = Utils.ReplaceRange(bytes, BitConverter.GetBytes(bytes.Count() - BodyOffsets[i] + 4), BodyOffsets[i]);
for (int a = 0; a < bcsFile.Bodies[i].BodyScales.Count(); a++)
{
bytes.AddRange(BitConverter.GetBytes(bcsFile.Bodies[i].BodyScales[a].F_00));
bytes.AddRange(BitConverter.GetBytes(bcsFile.Bodies[i].BodyScales[a].F_04));
bytes.AddRange(BitConverter.GetBytes(bcsFile.Bodies[i].BodyScales[a].F_08)); stringInfo.Add(new StringWriter.StringInfo()
{
Offset = bytes.Count(),
RelativeOffset = bytes.Count() - 12,
StringToWrite = bcsFile.Bodies[i].BodyScales[a].Str_12
});
bytes.AddRange(new byte[4]);
}
}
}
}
//Skeleton1
WriteSkeleton(bcsFile.SkeletonData1, Skeleton1Table);
//Skeleton2
WriteSkeleton(bcsFile.SkeletonData2, Skeleton2Table);
//Strings
bytes = StringWriter.WritePointerStrings(stringInfo, bytes);
}
private void ParseBsa()
{
int count = BitConverter.ToInt16(rawBytes, 18);
int offset = BitConverter.ToInt32(rawBytes, 20);
bsaFile.I_08 = BitConverter.ToInt64(rawBytes, 8);
bsaFile.I_16 = BitConverter.ToInt16(rawBytes, 16);
bsaFile.BSA_Entries = new List <BSA_Entry>();
for (int i = 0; i < count; i++)
{
int entryOffset = BitConverter.ToInt32(rawBytes, offset);
if (entryOffset != 0)
{
bsaFile.BSA_Entries.Add(new BSA_Entry()
{
Index = i.ToString(),
I_00 = BitConverter.ToInt32(rawBytes, entryOffset + 0),
I_16_a = Int4Converter.ToInt4(rawBytes[entryOffset + 16])[0],
I_16_b = Int4Converter.ToInt4(rawBytes[entryOffset + 16])[1],
I_17 = rawBytes[entryOffset + 17],
I_18 = BitConverter.ToInt32(rawBytes, entryOffset + 18),
I_22 = BitConverter.ToUInt16(rawBytes, entryOffset + 22),
I_24 = BitConverter.ToUInt16(rawBytes, entryOffset + 24),
Expires = BitConverter.ToUInt16(rawBytes, entryOffset + 26),
ImpactProjectile = BitConverter.ToUInt16(rawBytes, entryOffset + 28),
ImpactEnemy = BitConverter.ToUInt16(rawBytes, entryOffset + 30),
ImpactGround = BitConverter.ToUInt16(rawBytes, entryOffset + 32),
I_40 = BitConverter_Ex.ToInt32Array(rawBytes, entryOffset + 40, 3)
});
int thisEntry = bsaFile.BSA_Entries.Count() - 1;
int Unk1Count = BitConverter.ToInt16(rawBytes, entryOffset + 4);
int Unk2Count = BitConverter.ToInt16(rawBytes, entryOffset + 6);
if (Unk1Count != 0 || Unk2Count != 0)
{
bsaFile.BSA_Entries[thisEntry].SubEntries = new BSA_SubEntries()
{
CollisionEntries = ParseUnk1(BitConverter.ToInt16(rawBytes, entryOffset + 8) + entryOffset, BitConverter.ToInt16(rawBytes, entryOffset + 4)),
ExpirationEntries = ParseUnk2(BitConverter.ToInt16(rawBytes, entryOffset + 12) + entryOffset, BitConverter.ToInt16(rawBytes, entryOffset + 6))
};
}
//Types
int typesOffset = BitConverter.ToInt16(rawBytes, entryOffset + 36) + entryOffset;
int typesCount = BitConverter.ToInt16(rawBytes, entryOffset + 34);
if (typesCount > 0)
{
for (int a = 0; a < typesCount; a++)
{
int type = BitConverter.ToInt16(rawBytes, typesOffset + 0);
int hdrOffset = BitConverter.ToInt32(rawBytes, typesOffset + 8) + typesOffset;
int dataOffset = BitConverter.ToInt32(rawBytes, typesOffset + 12) + typesOffset;
switch (type)
{
case 0:
bsaFile.BSA_Entries[thisEntry].Type0 = ParseType0(hdrOffset, dataOffset, BitConverter.ToInt16(rawBytes, typesOffset + 6));
break;
case 1:
bsaFile.BSA_Entries[thisEntry].Type1 = ParseType1(hdrOffset, dataOffset, BitConverter.ToInt16(rawBytes, typesOffset + 6));
break;
case 2:
bsaFile.BSA_Entries[thisEntry].Type2 = ParseType2(hdrOffset, dataOffset, BitConverter.ToInt16(rawBytes, typesOffset + 6));
break;
case 3:
bsaFile.BSA_Entries[thisEntry].Type3 = ParseType3(hdrOffset, dataOffset, BitConverter.ToInt16(rawBytes, typesOffset + 6));
break;
case 4:
bsaFile.BSA_Entries[thisEntry].Type4 = ParseType4(hdrOffset, dataOffset, BitConverter.ToInt16(rawBytes, typesOffset + 6));
break;
case 6:
bsaFile.BSA_Entries[thisEntry].Type6 = ParseType6(hdrOffset, dataOffset, BitConverter.ToInt16(rawBytes, typesOffset + 6));
break;
case 7:
bsaFile.BSA_Entries[thisEntry].Type7 = ParseType7(hdrOffset, dataOffset, BitConverter.ToInt16(rawBytes, typesOffset + 6));
break;
case 8:
bsaFile.BSA_Entries[thisEntry].Type8 = ParseType8(hdrOffset, dataOffset, BitConverter.ToInt16(rawBytes, typesOffset + 6));
break;
default:
Console.WriteLine(String.Format("Undefined BSA Type encountered: {0}, at offset: {1}", type, typesOffset));
Console.ReadLine();
break;
}
typesOffset += 16;
}
}
}
offset += 4;
}
}
private ParticleEffect ParseEffect(int mainEntryOffset)
{
ParticleEffect newEffect = ParticleEffect.GetNew((parserMode == ParserMode.Tool) ? true : false);
//Flags and Offsets for extra data
int FLAG_36 = rawBytes[mainEntryOffset + 36];
int FLAG_37 = rawBytes[mainEntryOffset + 37];
int Type0_Count = BitConverter.ToInt16(rawBytes, mainEntryOffset + 138);
int Type0_Offset = BitConverter.ToInt32(rawBytes, mainEntryOffset + 140) + 136 + mainEntryOffset;
int Type1_Count = BitConverter.ToInt16(rawBytes, mainEntryOffset + 144);
int Type1_Offset = BitConverter.ToInt32(rawBytes, mainEntryOffset + 148) + mainEntryOffset;
//Main Entry values
newEffect.Component_Type = ParticleEffect.GetComponentType(new int[2] {
FLAG_36, FLAG_37
});
newEffect.Name = Utils.GetString(rawBytes.ToList(), mainEntryOffset, 32);
BitArray compositeBits_I_32 = new BitArray(new byte[1] {
rawBytes[mainEntryOffset + 32]
});
BitArray compositeBits_I_33 = new BitArray(new byte[1] {
rawBytes[mainEntryOffset + 33]
});
BitArray compositeBits_I_34 = new BitArray(new byte[1] {
rawBytes[mainEntryOffset + 34]
});
newEffect.I_32_0 = compositeBits_I_32[0];
newEffect.I_32_1 = compositeBits_I_32[1];
newEffect.I_32_2 = compositeBits_I_32[2];
newEffect.I_32_3 = compositeBits_I_32[3];
newEffect.I_32_4 = compositeBits_I_32[4];
newEffect.I_32_5 = compositeBits_I_32[5];
newEffect.I_32_6 = compositeBits_I_32[6];
newEffect.I_32_7 = compositeBits_I_32[7];
newEffect.I_33_0 = compositeBits_I_33[0];
newEffect.I_33_1 = compositeBits_I_33[1];
newEffect.I_33_2 = compositeBits_I_33[2];
newEffect.I_33_3 = compositeBits_I_33[3];
newEffect.I_33_4 = compositeBits_I_33[4];
newEffect.I_33_5 = compositeBits_I_33[5];
newEffect.I_33_6 = compositeBits_I_33[6];
newEffect.I_33_7 = compositeBits_I_33[7];
newEffect.I_34_0 = compositeBits_I_34[0];
newEffect.I_34_1 = compositeBits_I_34[1];
newEffect.I_34_2 = compositeBits_I_34[2];
newEffect.I_34_3 = compositeBits_I_34[3];
newEffect.I_34_4 = compositeBits_I_34[4];
newEffect.I_34_5 = compositeBits_I_34[5];
newEffect.I_34_6 = compositeBits_I_34[6];
newEffect.I_34_7 = compositeBits_I_34[7];
newEffect.I_35 = (ParticleEffect.AutoOrientationType)rawBytes[mainEntryOffset + 35];
newEffect.I_38 = BitConverter.ToInt16(rawBytes, mainEntryOffset + 38);
newEffect.I_40 = BitConverter.ToInt16(rawBytes, mainEntryOffset + 40);
newEffect.I_42 = BitConverter.ToUInt16(rawBytes, mainEntryOffset + 42);
newEffect.I_44 = rawBytes[mainEntryOffset + 44];
newEffect.I_45 = rawBytes[mainEntryOffset + 45];
newEffect.I_46 = rawBytes[mainEntryOffset + 46];
newEffect.I_47 = rawBytes[mainEntryOffset + 47];
newEffect.I_48 = BitConverter.ToUInt16(rawBytes, mainEntryOffset + 48);
newEffect.I_50 = BitConverter.ToUInt16(rawBytes, mainEntryOffset + 50);
newEffect.I_52 = BitConverter.ToUInt16(rawBytes, mainEntryOffset + 52);
newEffect.I_54 = BitConverter.ToUInt16(rawBytes, mainEntryOffset + 54);
newEffect.I_56 = BitConverter.ToUInt16(rawBytes, mainEntryOffset + 56);
newEffect.I_58 = BitConverter.ToUInt16(rawBytes, mainEntryOffset + 58);
newEffect.I_60 = BitConverter.ToUInt16(rawBytes, mainEntryOffset + 60);
newEffect.I_62 = BitConverter.ToUInt16(rawBytes, mainEntryOffset + 62);
newEffect.F_64 = BitConverter.ToSingle(rawBytes, mainEntryOffset + 64);
newEffect.F_68 = BitConverter.ToSingle(rawBytes, mainEntryOffset + 68);
newEffect.F_72 = BitConverter.ToSingle(rawBytes, mainEntryOffset + 72);
newEffect.F_76 = BitConverter.ToSingle(rawBytes, mainEntryOffset + 76);
newEffect.F_80 = BitConverter.ToSingle(rawBytes, mainEntryOffset + 80);
newEffect.F_84 = BitConverter.ToSingle(rawBytes, mainEntryOffset + 84);
newEffect.F_88 = BitConverter.ToSingle(rawBytes, mainEntryOffset + 88);
newEffect.F_92 = BitConverter.ToSingle(rawBytes, mainEntryOffset + 92);
newEffect.F_96 = BitConverter.ToSingle(rawBytes, mainEntryOffset + 96);
newEffect.F_100 = BitConverter.ToSingle(rawBytes, mainEntryOffset + 100);
newEffect.F_104 = BitConverter.ToSingle(rawBytes, mainEntryOffset + 104);
newEffect.F_108 = BitConverter.ToSingle(rawBytes, mainEntryOffset + 108);
newEffect.F_112 = BitConverter.ToSingle(rawBytes, mainEntryOffset + 112);
newEffect.F_116 = BitConverter.ToSingle(rawBytes, mainEntryOffset + 116);
newEffect.F_120 = BitConverter.ToSingle(rawBytes, mainEntryOffset + 120);
newEffect.F_124 = BitConverter.ToSingle(rawBytes, mainEntryOffset + 124);
newEffect.F_128 = BitConverter.ToSingle(rawBytes, mainEntryOffset + 128);
newEffect.F_132 = BitConverter.ToSingle(rawBytes, mainEntryOffset + 132);
newEffect.I_136 = BitConverter.ToUInt16(rawBytes, mainEntryOffset + 136);
if (Type0_Count > 0 || Type1_Count > 0)
{
//Type0
if (Type0_Count > 0)
{
newEffect.Type_0 = new ObservableCollection <Type0>();
for (int a = 0; a < Type0_Count; a++)
{
int idx = newEffect.Type_0.Count();
newEffect.Type_0.Add(new Type0()
{
I_01_b = BitConverter_Ex.ToBoolean(Int4Converter.ToInt4(rawBytes[Type0_Offset + 1])[1]),
I_02 = BitConverter_Ex.ToBoolean(rawBytes, Type0_Offset + 2),
I_03 = rawBytes[Type0_Offset + 3],
F_04 = BitConverter.ToSingle(rawBytes, Type0_Offset + 4),
I_08 = BitConverter.ToInt16(rawBytes, Type0_Offset + 8),
Keyframes = ParseKeyframes <Type0_Keyframe>(BitConverter.ToInt16(rawBytes, Type0_Offset + 10), BitConverter.ToInt32(rawBytes, Type0_Offset + 12) + Type0_Offset)
});
newEffect.Type_0[idx].SetParameters(rawBytes[Type0_Offset + 0], Int4Converter.ToInt4(rawBytes[Type0_Offset + 1])[0], newEffect.IsScale2Enabled());
Type0_Offset += 16;
}
}
//Type1
if (Type1_Count > 0)
{
newEffect.Type_1 = new ObservableCollection <Type1_Header>();
for (int a = 0; a < Type1_Count; a++)
{
int entryCount = BitConverter.ToInt16(rawBytes, Type1_Offset + 2);
int entryOffset = BitConverter.ToInt32(rawBytes, Type1_Offset + 4) + Type1_Offset;
newEffect.Type_1.Add(new Type1_Header());
newEffect.Type_1[a].I_00 = rawBytes[Type1_Offset];
newEffect.Type_1[a].I_01 = rawBytes[Type1_Offset + 1];
newEffect.Type_1[a].Entries = new ObservableCollection <Type0>();
for (int d = 0; d < entryCount; d++)
{
int subEntryCount = BitConverter.ToInt16(rawBytes, entryOffset + 10);
newEffect.Type_1[a].Entries.Add(new Type0());
newEffect.Type_1[a].Entries[d].SetParameters(rawBytes[entryOffset + 0], Int4Converter.ToInt4(rawBytes[entryOffset + 1])[0], newEffect.IsScale2Enabled());
newEffect.Type_1[a].Entries[d].I_01_b = BitConverter_Ex.ToBoolean(Int4Converter.ToInt4(rawBytes[entryOffset + 1])[1]);
newEffect.Type_1[a].Entries[d].I_02 = BitConverter_Ex.ToBoolean(rawBytes, entryOffset + 2);
newEffect.Type_1[a].Entries[d].I_03 = rawBytes[entryOffset + 3];
newEffect.Type_1[a].Entries[d].F_04 = BitConverter.ToSingle(rawBytes, entryOffset + 4);
newEffect.Type_1[a].Entries[d].I_08 = BitConverter.ToInt16(rawBytes, entryOffset + 8);
newEffect.Type_1[a].Entries[d].Keyframes = ParseKeyframes <Type0_Keyframe>(BitConverter.ToInt16(rawBytes, entryOffset + 10), BitConverter.ToInt32(rawBytes, entryOffset + 12) + entryOffset);
entryOffset += 16;
}
Type1_Offset += 8;
}
}
}
//Extra Parts
//If no extra parts exist, this code wont execute
if (FLAG_37 != 0)
{
switch (FLAG_37)
{
case 1:
switch (FLAG_36)
{
case 0:
newEffect.FloatPart_00_01 = ParseFloatPart8 <FloatPart_0_1>(mainEntryOffset + 160);
break;
case 1:
newEffect.FloatPart_01_01 = ParseFloatPart4 <FloatPart_1_1>(mainEntryOffset + 160);
break;
case 2:
newEffect.FloatPart_02_01 = ParseFloatPart_2_1(mainEntryOffset + 160);
break;
case 3:
newEffect.FloatPart_03_01 = ParseFloatPart_3_1(mainEntryOffset + 160);
break;
}
break;
case 2:
switch (FLAG_36)
{
case 0:
newEffect.Type_Texture = ParseTexturePart(mainEntryOffset + 160, mainEntryOffset, textureEntryOffset);
newEffect.FloatPart_00_02 = ParseFloatPart4 <FloatPart_0_2>(mainEntryOffset + 160 + 112);
break;
case 1:
newEffect.Type_Texture = ParseTexturePart(mainEntryOffset + 160, mainEntryOffset, textureEntryOffset);
break;
case 2:
newEffect.Type_Texture = ParseTexturePart(mainEntryOffset + 160, mainEntryOffset, textureEntryOffset);
newEffect.FloatPart_02_02 = ParseFloatPart8 <FloatPart_2_2>(mainEntryOffset + 160 + 112);
break;
case 3:
newEffect.Type_Texture = ParseTexturePart(mainEntryOffset + 160, mainEntryOffset, textureEntryOffset);
newEffect.Type_Struct3 = ParseStruct3(mainEntryOffset + 160 + 112, mainEntryOffset);
break;
case 4:
newEffect.Type_Texture = ParseTexturePart(mainEntryOffset + 160, mainEntryOffset, textureEntryOffset);
newEffect.Type_Model = ParseModelStruct(mainEntryOffset + 160 + 112, mainEntryOffset);
break;
case 5:
newEffect.Type_Texture = ParseTexturePart(mainEntryOffset + 160, mainEntryOffset, textureEntryOffset);
newEffect.Type_Struct5 = ParseStruct5(mainEntryOffset + 160 + 112, mainEntryOffset);
break;
}
break;
}
}
return(newEffect);
}
public void WriteBai()
{
List <int> EntryOffsets = new List <int>();
int count = (baiFile.Entries != null) ? baiFile.Entries.Count() : 0;
bytes.AddRange(BitConverter.GetBytes(count));
bytes.AddRange(BitConverter.GetBytes(16));
if (baiFile.Entries != null)
{
for (int i = 0; i < baiFile.Entries.Count(); i++)
{
int subEntryCount = (baiFile.Entries[i].SubEntries != null) ? baiFile.Entries[i].SubEntries.Count() : 0;
bytes.AddRange(BitConverter.GetBytes(baiFile.Entries[i].I_00));
bytes.AddRange(BitConverter.GetBytes(baiFile.Entries[i].I_04));
bytes.AddRange(BitConverter.GetBytes(baiFile.Entries[i].I_08));
bytes.AddRange(BitConverter.GetBytes(baiFile.Entries[i].I_12));
bytes.AddRange(BitConverter.GetBytes(subEntryCount));
EntryOffsets.Add(bytes.Count());
bytes.AddRange(new byte[4]);
}
for (int i = 0; i < baiFile.Entries.Count(); i++)
{
bytes = Utils.ReplaceRange(bytes, BitConverter.GetBytes(bytes.Count()), EntryOffsets[i]);
if (baiFile.Entries[i].SubEntries != null)
{
for (int a = 0; a < baiFile.Entries[i].SubEntries.Count(); a++)
{
//Name Str
if (baiFile.Entries[i].SubEntries[a].Name.Count() > 8)
{
Console.WriteLine(String.Format("The name \"{0}\" exceeds the maximum length of 8!", baiFile.Entries[i].SubEntries[a].Name));
Utils.WaitForInputThenQuit();
}
bytes.AddRange(Encoding.ASCII.GetBytes(baiFile.Entries[i].SubEntries[a].Name));
int remainingSpace = 8 - baiFile.Entries[i].SubEntries[a].Name.Count();
for (int z = 0; z < remainingSpace; z++)
{
bytes.Add(0);
}
//Data
bytes.AddRange(BitConverter_Ex.GetBytes_Bool32(baiFile.Entries[i].SubEntries[a].I_08));
bytes.AddRange(BitConverter.GetBytes((int)baiFile.Entries[i].SubEntries[a].I_12));
bytes.AddRange(BitConverter.GetBytes((int)baiFile.Entries[i].SubEntries[a].I_16));
bytes.AddRange(BitConverter.GetBytes((int)baiFile.Entries[i].SubEntries[a].I_20));
bytes.AddRange(BitConverter.GetBytes(baiFile.Entries[i].SubEntries[a].I_24));
bytes.AddRange(BitConverter.GetBytes(baiFile.Entries[i].SubEntries[a].I_28));
bytes.AddRange(BitConverter.GetBytes(baiFile.Entries[i].SubEntries[a].I_32));
bytes.AddRange(BitConverter.GetBytes(baiFile.Entries[i].SubEntries[a].I_36));
bytes.AddRange(BitConverter.GetBytes(baiFile.Entries[i].SubEntries[a].I_40));
bytes.AddRange(BitConverter.GetBytes(baiFile.Entries[i].SubEntries[a].I_44));
bytes.AddRange(BitConverter.GetBytes(baiFile.Entries[i].SubEntries[a].I_48));
bytes.AddRange(BitConverter.GetBytes(baiFile.Entries[i].SubEntries[a].I_52));
bytes.AddRange(BitConverter.GetBytes(baiFile.Entries[i].SubEntries[a].I_56));
bytes.AddRange(BitConverter.GetBytes(baiFile.Entries[i].SubEntries[a].I_60));
bytes.AddRange(BitConverter.GetBytes(baiFile.Entries[i].SubEntries[a].I_64));
bytes.AddRange(BitConverter.GetBytes(baiFile.Entries[i].SubEntries[a].F_68));
bytes.AddRange(BitConverter.GetBytes(baiFile.Entries[i].SubEntries[a].F_72));
bytes.AddRange(BitConverter.GetBytes(baiFile.Entries[i].SubEntries[a].F_76));
bytes.AddRange(BitConverter.GetBytes(baiFile.Entries[i].SubEntries[a].F_80));
}
}
}
}
}
void ParseQuestData()
{
int offset = questsOffset;
for (int i = 0; i < questsCount; i++)
{
//counts & offsets
int msgEntryCount = BitConverter.ToInt32(rawBytes, offset + 32);
int equipRewardCount = BitConverter.ToInt32(rawBytes, offset + 160);
int skillRewardCount = BitConverter.ToInt32(rawBytes, offset + 168);
int unk1count = BitConverter.ToInt32(rawBytes, offset + 88);
int unk2Count = BitConverter.ToInt32(rawBytes, offset + 96);
int charaUnlockCount = BitConverter.ToInt32(rawBytes, offset + 176);
int stagePortraitCount = BitConverter.ToInt32(rawBytes, offset + 184);
int qedFileCount = BitConverter.ToInt32(rawBytes, offset + 112);
int msgEntryOffset = BitConverter.ToInt32(rawBytes, offset + 36);
int equipRewardOffset = BitConverter.ToInt32(rawBytes, offset + 164);
int skillRewardOffset = BitConverter.ToInt32(rawBytes, offset + 172);
int unk1Offset = BitConverter.ToInt32(rawBytes, offset + 92);
int unk2Offset = BitConverter.ToInt32(rawBytes, offset + 100);
int charaUnlockOffset = BitConverter.ToInt32(rawBytes, offset + 180);
int stagePortraitOffset = BitConverter.ToInt32(rawBytes, offset + 188);
int qedFileOffset = BitConverter.ToInt32(rawBytes, offset + 116);
qxd_File.Quests.Add(new Quest_Data());
qxd_File.Quests[i].Name = StringEx.GetString(bytes, offset, false, StringEx.EncodingType.ASCII, 16);
qxd_File.Quests[i].Index = BitConverter.ToInt32(rawBytes, offset + 16).ToString();
qxd_File.Quests[i].I_20 = BitConverter.ToInt32(rawBytes, offset + 20);
qxd_File.Quests[i].I_24 = BitConverter.ToInt32(rawBytes, offset + 24);
qxd_File.Quests[i].I_28 = BitConverter.ToInt32(rawBytes, offset + 28);
qxd_File.Quests[i].I_40 = BitConverter.ToInt16(rawBytes, offset + 40);
qxd_File.Quests[i].I_42 = BitConverter.ToInt16(rawBytes, offset + 42);
qxd_File.Quests[i].I_44 = BitConverter.ToInt16(rawBytes, offset + 44);
qxd_File.Quests[i].I_46 = BitConverter.ToInt16(rawBytes, offset + 46);
qxd_File.Quests[i].I_64 = BitConverter.ToInt32(rawBytes, offset + 64);
qxd_File.Quests[i].I_104 = BitConverter.ToInt16(rawBytes, offset + 104);
qxd_File.Quests[i].I_106 = BitConverter.ToInt16(rawBytes, offset + 106);
qxd_File.Quests[i].I_108 = BitConverter.ToInt16(rawBytes, offset + 108);
qxd_File.Quests[i].I_110 = BitConverter.ToInt16(rawBytes, offset + 110);
qxd_File.Quests[i].I_120 = BitConverter.ToInt32(rawBytes, offset + 120);
qxd_File.Quests[i].I_124 = BitConverter.ToInt32(rawBytes, offset + 124);
qxd_File.Quests[i].I_128 = BitConverter.ToInt32(rawBytes, offset + 128);
qxd_File.Quests[i].I_132 = BitConverter.ToInt32(rawBytes, offset + 132);
qxd_File.Quests[i].I_136 = BitConverter.ToInt32(rawBytes, offset + 136);
qxd_File.Quests[i].I_140 = BitConverter.ToInt32(rawBytes, offset + 140);
qxd_File.Quests[i].I_144 = BitConverter.ToInt32(rawBytes, offset + 144);
qxd_File.Quests[i].I_148 = BitConverter.ToInt32(rawBytes, offset + 148);
qxd_File.Quests[i].I_152 = BitConverter.ToInt32(rawBytes, offset + 152);
qxd_File.Quests[i].I_156 = BitConverter.ToInt32(rawBytes, offset + 156);
qxd_File.Quests[i].I_192 = BitConverter.ToInt32(rawBytes, offset + 192);
qxd_File.Quests[i].I_248 = BitConverter.ToInt32(rawBytes, offset + 248);
qxd_File.Quests[i].I_252 = BitConverter.ToInt32(rawBytes, offset + 252);
qxd_File.Quests[i].I_256 = (QxdUpdate)BitConverter.ToInt32(rawBytes, offset + 256);
qxd_File.Quests[i].I_260 = (QxdDlc)BitConverter.ToInt32(rawBytes, offset + 260);
qxd_File.Quests[i].I_264 = BitConverter.ToInt32(rawBytes, offset + 264);
qxd_File.Quests[i].I_268 = BitConverter.ToInt16(rawBytes, offset + 268);
qxd_File.Quests[i].I_270 = BitConverter.ToInt16(rawBytes, offset + 270);
qxd_File.Quests[i].I_272 = BitConverter.ToInt16(rawBytes, offset + 272);
qxd_File.Quests[i].I_274 = BitConverter.ToInt16(rawBytes, offset + 274);
qxd_File.Quests[i].F_276 = BitConverter.ToSingle(rawBytes, offset + 276);
qxd_File.Quests[i].I_280 = BitConverter.ToInt32(rawBytes, offset + 280);
qxd_File.Quests[i].I_48 = BitConverter_Ex.ToInt32Array(rawBytes, offset + 48, 4);
qxd_File.Quests[i].I_68 = BitConverter_Ex.ToInt32Array(rawBytes, offset + 68, 5);
qxd_File.Quests[i].I_232 = BitConverter_Ex.ToInt16Array(rawBytes, offset + 232, 8);
if (unk1count > 0)
{
int tempOffset = unk1Offset;
qxd_File.Quests[i].UnknownNum1 = new List <UnkNum1>();
for (int a = 0; a < unk1count; a++)
{
qxd_File.Quests[i].UnknownNum1.Add(new UnkNum1()
{
I_00 = BitConverter_Ex.ToInt16Array(rawBytes, tempOffset, 16)
});
tempOffset += 32;
}
}
if (unk2Count > 0)
{
int tempOffset = unk2Offset;
qxd_File.Quests[i].UnknownNum2 = new List <UnkNum2>();
for (int a = 0; a < unk2Count; a++)
{
qxd_File.Quests[i].UnknownNum2.Add(new UnkNum2()
{
I_00 = BitConverter_Ex.ToInt16Array(rawBytes, tempOffset, 16)
});
tempOffset += 32;
}
}
if (equipRewardCount > 0)
{
qxd_File.Quests[i].EquipReward = new List <EquipmentReward>();
int equipOffset = equipRewardOffset;
for (int b = 0; b < equipRewardCount; b++)
{
qxd_File.Quests[i].EquipReward.Add(new EquipmentReward()
{
I_00 = (QxdItemType)BitConverter.ToInt32(rawBytes, equipOffset),
I_04 = BitConverter.ToInt32(rawBytes, equipOffset + 4),
I_08 = BitConverter.ToInt32(rawBytes, equipOffset + 8),
I_12 = BitConverter.ToInt32(rawBytes, equipOffset + 12),
I_16 = BitConverter.ToInt32(rawBytes, equipOffset + 16),
I_20 = BitConverter.ToInt16(rawBytes, equipOffset + 20),
F_24 = BitConverter.ToSingle(rawBytes, equipOffset + 24),
I_28 = BitConverter.ToInt32(rawBytes, equipOffset + 28)
});
equipOffset += 32;
}
}
if (skillRewardCount > 0)
{
qxd_File.Quests[i].Skill_Reward = new List <SkillReward>();
int skillOffset = skillRewardOffset;
for (int b = 0; b < skillRewardCount; b++)
{
qxd_File.Quests[i].Skill_Reward.Add(new SkillReward()
{
I_00 = (QxdSkillType)BitConverter.ToInt32(rawBytes, skillOffset + 0),
I_04 = BitConverter.ToInt32(rawBytes, skillOffset + 4),
I_08 = BitConverter.ToInt32(rawBytes, skillOffset + 8),
I_12 = BitConverter.ToInt32(rawBytes, skillOffset + 12),
F_16 = BitConverter.ToSingle(rawBytes, skillOffset + 16)
});
skillOffset += 20;
}
}
if (charaUnlockCount > 0)
{
qxd_File.Quests[i].Chara_Unlock = new List <CharaUnlock>();
int charaOffset = charaUnlockOffset;
for (int b = 0; b < charaUnlockCount; b++)
{
qxd_File.Quests[i].Chara_Unlock.Add(new CharaUnlock()
{
ShortName = StringEx.GetString(bytes, charaOffset, false, StringEx.EncodingType.ASCII, 3),
CostumeIndex = BitConverter.ToInt16(rawBytes, charaOffset + 4),
I_06 = BitConverter.ToInt16(rawBytes, charaOffset + 6)
});
charaOffset += 8;
}
}
int portraitOffset = 196;
qxd_File.Quests[i].EnemyPortraitDisplay = new List <EnemyPortrait>();
for (int b = 0; b < 6; b++)
{
qxd_File.Quests[i].EnemyPortraitDisplay.Add(new EnemyPortrait());
qxd_File.Quests[i].EnemyPortraitDisplay[b].CharaID = BitConverter.ToInt16(rawBytes, offset + portraitOffset);
qxd_File.Quests[i].EnemyPortraitDisplay[b].CostumeIndex = BitConverter.ToInt16(rawBytes, offset + portraitOffset + 2);
qxd_File.Quests[i].EnemyPortraitDisplay[b].State = BitConverter.ToInt16(rawBytes, offset + portraitOffset + 4);
portraitOffset += 6;
}
if (stagePortraitCount > 0)
{
qxd_File.Quests[i].StageDisplay = new List <short>();
for (int j = 0; j < 32; j += 2)
{
qxd_File.Quests[i].StageDisplay.Add(BitConverter.ToInt16(rawBytes, stagePortraitOffset + j));
}
}
if (msgEntryCount > 0)
{
qxd_File.Quests[i].MsgFiles = new List <string>();
int msgOffset = msgEntryOffset;
for (int j = 0; j < msgEntryCount; j++)
{
qxd_File.Quests[i].MsgFiles.Add(StringEx.GetString(bytes, msgOffset, false, StringEx.EncodingType.ASCII, 32));
msgOffset += 32;
}
}
if (qedFileCount > 0)
{
qxd_File.Quests[i].QedFiles = new List <string>();
int qedOffset = qedFileOffset;
for (int j = 0; j < qedFileCount; j++)
{
qxd_File.Quests[i].QedFiles.Add(StringEx.GetString(bytes, qedOffset, false, StringEx.EncodingType.ASCII, 32));
qedOffset += 32;
}
}
offset += 284;
}
}