public List <PropHeader> ReadHeadersTillNone()
{
List <PropHeader> ret = new List <PropHeader>();
bool run = true;
while (run)
{
PropHeader p = new PropHeader();
if (readerpos > memory.Length)
{
//nothing else to interpret.
run = false;
continue;
}
p.name = BitConverter.ToInt32(memory, readerpos);
if (!pcc.isName(p.name))
{
run = false;
}
else
{
if (pcc.getNameEntry(p.name) != "None")
{
p.type = BitConverter.ToInt32(memory, readerpos + 8);
if (!pcc.isName(p.type) || getType(pcc.getNameEntry(p.type)) == -1)
{
run = false;
}
else
{
p.size = BitConverter.ToInt32(memory, readerpos + 16);
p.index = BitConverter.ToInt32(memory, readerpos + 20);
p.offset = readerpos;
ret.Add(p);
readerpos += p.size + 24;
if (getType(pcc.getNameEntry(p.type)) == BOOL_PROPERTY)//Boolbyte
{
readerpos++;
}
if (getType(pcc.getNameEntry(p.type)) == STRUCT_PROPERTY || //StructName
getType(pcc.getNameEntry(p.type)) == BYTE_PROPERTY) //byteprop
{
readerpos += 8;
}
}
}
else
{
p.type = p.name;
p.size = 0;
p.index = 0;
p.offset = readerpos;
ret.Add(p);
readerpos += 8;
run = false;
}
}
}
return(ret);
}
public TreeNode GenerateNode(PropHeader p)
{
string s = p.offset.ToString("X4") + " : ";
s += "Name: \"" + pcc.GetName(p.name) + "\" ";
s += "Type: \"" + pcc.GetName(p.type) + "\" ";
s += "Size: " + p.size.ToString() + " Value: ";
switch (isType(pcc.GetName(p.type)))
{
case 1:
int idx = BitConverter.ToInt32(memory, p.offset + 24);
s += idx.ToString();
break;
case 3:
idx = BitConverter.ToInt32(memory, p.offset + 24);
s += idx.ToString() + " ";
if (idx == 0)
s += "None";
else
s += pcc.GetClass(idx);
break;
case 8:
int count = BitConverter.ToInt32(memory, p.offset + 24);
s += "\"";
for (int i = 0; i < count - 1; i++)
s += (char)memory[p.offset + 28 + i];
s += "\"";
break;
case 5:
byte val = memory[p.offset + 24];
s += (val == 1).ToString();
break;
case 2:
float f = BitConverter.ToSingle(memory, p.offset + 24);
s += f.ToString() + "f";
break;
case 0:
case 4:
idx = BitConverter.ToInt32(memory, p.offset + 24);
s += "\"" + pcc.GetName(idx) + "\"";
break;
case 6:
idx = BitConverter.ToInt32(memory, p.offset + 24);
s += "\"" + pcc.GetName(idx) + "\"";
break;
case 7:
idx = BitConverter.ToInt32(memory, p.offset + 24);
s += idx.ToString() + "(count)";
break;
case 9:
idx = BitConverter.ToInt32(memory, p.offset + 24);
s += "#" + idx.ToString();
break;
}
TreeNode ret = new TreeNode(s);
ret.Name = p.offset.ToString();
return ret;
}
public List <PropHeader> ReadHeadersTillNone()
{
List <PropHeader> ret = new List <PropHeader>();
bool run = true;
while (run)
{
PropHeader p = new PropHeader();
p.name = BitConverter.ToInt32(memory, readerpos);
if (!pcc.isName(p.name))
{
run = false;
}
else
{
if (pcc.getNameEntry(p.name) != "None")
{
p.type = BitConverter.ToInt32(memory, readerpos + 8);
if (!pcc.isName(p.type) || getType(pcc.getNameEntry(p.type)) == -1 || BitConverter.ToInt32(memory, readerpos + 4) != 0)
{
run = false;
}
else
{
p.size = BitConverter.ToInt32(memory, readerpos + 16);
p.index = BitConverter.ToInt32(memory, readerpos + 20);
p.offset = readerpos;
ret.Add(p);
readerpos += p.size + 24;
if (getType(pcc.getNameEntry(p.type)) == BOOL_PROPERTY)
{
readerpos += 4;
}
if (getType(pcc.getNameEntry(p.type)) == STRUCT_PROPERTY)
{
readerpos += 8;
}
}
}
else
{
p.type = p.name;
p.size = 0;
p.index = 0;
p.offset = readerpos;
ret.Add(p);
readerpos += 8;
run = false;
}
}
}
return(ret);
}
public List <PropHeader> ReadHeadersTillNone()
{
List <PropHeader> ret = new List <PropHeader>();
bool run = true;
while (run)
{
PropHeader p = new PropHeader();
p.name = BitConverter.ToInt32(memory, readerpos);
if (!pcc.isName(p.name))
{
run = false;
}
else
{
if (pcc.GetName(p.name) != "None")
{
p.type = BitConverter.ToInt32(memory, readerpos + 8);
if (!pcc.isName(p.type) || isType(pcc.GetName(p.type)) == -1)
{
run = false;
}
else
{
p.size = BitConverter.ToInt32(memory, readerpos + 16);
p.index = BitConverter.ToInt32(memory, readerpos + 20);
p.offset = readerpos;
ret.Add(p);
readerpos += p.size + 24;
if (isType(pcc.GetName(p.type)) == 5)//Boolbyte
{
readerpos += 4;
}
if (isType(pcc.GetName(p.type)) == 0)//StructName
{
readerpos += 8;
}
}
}
else
{
p.type = p.name;
p.size = 0;
p.index = 0;
p.offset = readerpos;
ret.Add(p);
readerpos += 8;
run = false;
}
}
}
return(ret);
}
public List<PropHeader> ReadHeadersTillNone()
{
List<PropHeader> ret = new List<PropHeader>();
bool run = true;
while (run)
{
PropHeader p = new PropHeader();
p.name = BitConverter.ToInt32(memory, readerpos);
if (!pcc.isName(p.name))
run = false;
else
{
if (pcc.GetName(p.name) != "None")
{
p.type = BitConverter.ToInt32(memory, readerpos + 8);
if (!pcc.isName(p.type) || isType(pcc.GetName(p.type)) == -1)
run = false;
else
{
p.size = BitConverter.ToInt32(memory, readerpos + 16);
p.index = BitConverter.ToInt32(memory, readerpos + 20);
p.offset = readerpos;
ret.Add(p);
readerpos += p.size + 24;
if (isType(pcc.GetName(p.type)) == 5)//Boolbyte
readerpos+=4;
if (isType(pcc.GetName(p.type)) == 0)//StructName
readerpos += 8;
}
}
else
{
p.type = p.name;
p.size = 0;
p.index = 0;
p.offset = readerpos;
ret.Add(p);
readerpos += 8;
run = false;
}
}
}
return ret;
}
public TreeNode GenerateNode(PropHeader p)
{
string s = p.offset.ToString("X4") + " : ";
s += "Name: \"" + pcc.getNameEntry(p.name) + "\" ";
s += "Type: \"" + pcc.getNameEntry(p.type) + "\" ";
s += "Size: " + p.size.ToString() + " Value: ";
int propertyType = getType(pcc.getNameEntry(p.type));
int idx;
switch (propertyType)
{
case INT_PROPERTY:
idx = BitConverter.ToInt32(memory, p.offset + 24);
s += idx.ToString();
break;
case OBJECT_PROPERTY:
idx = BitConverter.ToInt32(memory, p.offset + 24);
s += idx.ToString() + " (" + pcc.getObjectName(idx) + ")";
break;
case STRING_PROPERTY:
int count = BitConverter.ToInt32(memory, p.offset + 24);
s += "\"";
for (int i = 0; i < count - 1; i++)
{
s += (char)memory[p.offset + 28 + i];
}
s += "\"";
break;
case BOOL_PROPERTY:
byte val = memory[p.offset + 24];
s += (val == 1).ToString();
break;
case FLOAT_PROPERTY:
float f = BitConverter.ToSingle(memory, p.offset + 24);
s += f.ToString() + "f";
break;
case STRUCT_PROPERTY:
case NAME_PROPERTY:
idx = BitConverter.ToInt32(memory, p.offset + 24);
s += "\"" + pcc.getNameEntry(idx) + "\"";
break;
case BYTE_PROPERTY:
idx = BitConverter.ToInt32(memory, p.offset + 24);
s += "\"" + pcc.getNameEntry(idx) + "\"";
break;
case ARRAY_PROPERTY:
idx = BitConverter.ToInt32(memory, p.offset + 24);
s += idx.ToString() + "(count)";
break;
case STRINGREF_PROPERTY:
idx = BitConverter.ToInt32(memory, p.offset + 24);
s += "#" + idx.ToString() + ": ";
s += tlkset == null ? "(.tlk not loaded)" : tlkset.findDataById(idx);
break;
}
TreeNode ret = new TreeNode(s);
ret.Tag = propertyType;
ret.Name = p.offset.ToString();
return(ret);
}
public TreeNode GenerateNode(PropHeader p)
{
string s = p.offset.ToString("X4") + " : ";
s += "Name: \"" + pcc.getNameEntry(p.name) + "\" ";
s += "Type: \"" + pcc.getNameEntry(p.type) + "\" ";
s += "Size: " + p.size.ToString() + " Value: ";
switch (isType(pcc.getNameEntry(p.type)))
{
case 1:
case 3:
int idx = BitConverter.ToInt32(memory, p.offset + 24);
s += idx.ToString();
break;
case 8:
int count = BitConverter.ToInt32(memory, p.offset + 24);
s += "\"";
for (int i = 0; i < count * -1 - 1; i++)
s += (char)memory[p.offset + 28 + i * 2];
s += "\"";
break;
case 5:
byte val = memory[p.offset + 24];
s += (val == 1).ToString();
break;
case 2:
float f = BitConverter.ToSingle(memory, p.offset + 24);
s += f.ToString() + "f";
break;
case 0:
case 4:
idx = BitConverter.ToInt32(memory, p.offset + 24);
s += "\"" + pcc.getNameEntry(idx) + "\"";
break;
case 6:
idx = BitConverter.ToInt32(memory, p.offset + 24);
int idx2 = BitConverter.ToInt32(memory, p.offset + 32);
s += "\"" + pcc.getNameEntry(idx) + "\",\"" + pcc.getNameEntry(idx2) + "\"";
break;
case 7:
idx = BitConverter.ToInt32(memory, p.offset + 24);
s += idx.ToString() + "(count)";
break;
case 9:
idx = BitConverter.ToInt32(memory, p.offset + 24);
s += "#" + idx.ToString() + ": ";
s += talkFile.findDataById(idx);
break;
}
TreeNode ret = new TreeNode(s);
ret.Name = p.offset.ToString();
return ret;
}
public List <PropHeader> ReadHeadersTillNone()
{
List <PropHeader> ret = new List <PropHeader>();
bool run = true;
while (run)
{
PropHeader p = new PropHeader();
if (readerpos > memory.Length || readerpos < 0)
{
//nothing else to interpret.
run = false;
continue;
}
p.name = BitConverter.ToInt32(memory, readerpos);
if (readerpos == 4 && pcc.isName(p.name) && pcc.getNameEntry(p.name) == className)
{
//It's a primitive component header
//Debug.WriteLine("Primitive Header " + pcc.Names[p.name]);
readerpos += 12;
continue;
}
if (!pcc.isName(p.name))
{
run = false;
}
else
{
if (pcc.getNameEntry(p.name) != "None")
{
p.type = BitConverter.ToInt32(memory, readerpos + 8);
if (!pcc.isName(p.type) || getType(pcc.getNameEntry(p.type)) == nodeType.Unknown)
{
run = false;
}
else
{
p.size = BitConverter.ToInt32(memory, readerpos + 16);
p.index = BitConverter.ToInt32(memory, readerpos + 20);
p.offset = readerpos;
ret.Add(p);
readerpos += p.size + 24;
if (getType(pcc.getNameEntry(p.type)) == nodeType.BoolProperty)//Boolbyte
{
readerpos++;
}
if (getType(pcc.getNameEntry(p.type)) == nodeType.StructProperty || //StructName
getType(pcc.getNameEntry(p.type)) == nodeType.ByteProperty) //byteprop
{
readerpos += 8;
}
}
}
else
{
p.type = p.name;
p.size = 0;
p.index = 0;
p.offset = readerpos;
ret.Add(p);
readerpos += 8;
run = false;
}
}
}
return(ret);
}
public TreeNode GenerateNode(PropHeader p)
{
string s = p.offset.ToString("X4") + ": ";
s += "Name: \"" + pcc.getNameEntry(p.name) + "\" ";
s += "Type: \"" + pcc.getNameEntry(p.type) + "\" ";
s += "Size: " + p.size.ToString() + " Value: ";
nodeType propertyType = getType(pcc.getNameEntry(p.type));
int idx;
byte val;
switch (propertyType)
{
case nodeType.IntProperty:
idx = BitConverter.ToInt32(memory, p.offset + 24);
s += idx.ToString();
break;
case nodeType.ObjectProperty:
idx = BitConverter.ToInt32(memory, p.offset + 24);
s += idx.ToString() + " (" + pcc.getObjectName(idx) + ")";
break;
case nodeType.StrProperty:
int count = BitConverter.ToInt32(memory, p.offset + 24);
s += "\"";
for (int i = 0; i < count * -1 - 1; i++)
{
s += (char)memory[p.offset + 28 + i * 2];
}
s += "\"";
break;
case nodeType.BoolProperty:
val = memory[p.offset + 24];
s += (val == 1).ToString();
break;
case nodeType.FloatProperty:
float f = BitConverter.ToSingle(memory, p.offset + 24);
s += f.ToString("0.0######");
break;
case nodeType.NameProperty:
idx = BitConverter.ToInt32(memory, p.offset + 24);
s += "\"" + pcc.getNameEntry(idx) + "\"_" + BitConverter.ToInt32(memory, p.offset + 28);
break;
case nodeType.StructProperty:
idx = BitConverter.ToInt32(memory, p.offset + 24);
s += "\"" + pcc.getNameEntry(idx) + "\"";
break;
case nodeType.ByteProperty:
if (p.size == 1)
{
val = memory[p.offset + 32];
s += val.ToString();
}
else
{
idx = BitConverter.ToInt32(memory, p.offset + 24);
int idx2 = BitConverter.ToInt32(memory, p.offset + 32);
s += "\"" + pcc.getNameEntry(idx) + "\",\"" + pcc.getNameEntry(idx2) + "\"";
}
break;
case nodeType.ArrayProperty:
idx = BitConverter.ToInt32(memory, p.offset + 24);
s += idx.ToString() + "(count)";
break;
case nodeType.StringRefProperty:
idx = BitConverter.ToInt32(memory, p.offset + 24);
s += "#" + idx.ToString() + ": ";
s += TalkFiles.tlkList.Count == 0 ? "(.tlk not loaded)" : TalkFiles.findDataById(idx);
break;
}
TreeNode ret = new TreeNode(s);
ret.Tag = propertyType;
ret.Name = p.offset.ToString();
return(ret);
}
public TreeNode GenerateNode(PropHeader p)
{
string s = p.offset.ToString("X4") + " : ";
s += "Name: \"" + pcc.GetName(p.name) + "\" ";
s += "Type: \"" + pcc.GetName(p.type) + "\" ";
s += "Size: " + p.size.ToString() + " Value: ";
switch (isType(pcc.GetName(p.type)))
{
case 1:
case 3:
int idx = BitConverter.ToInt32(memory, p.offset + 24);
s += idx.ToString();
break;
case 8:
int count = BitConverter.ToInt32(memory, p.offset + 24);
s += "\"";
for (int i = 0; i < count - 1; i++)
{
s += (char)memory[p.offset + 28 + i * 1];
}
s += "\"";
break;
case 5:
byte val = memory[p.offset + 24];
s += (val == 1).ToString();
break;
case 2:
float f = BitConverter.ToSingle(memory, p.offset + 24);
s += f.ToString() + "f";
break;
case 0:
case 4:
idx = BitConverter.ToInt32(memory, p.offset + 24);
s += "\"" + pcc.GetName(idx) + "\"";
break;
case 6:
idx = BitConverter.ToInt32(memory, p.offset + 24);
s += "\"" + pcc.GetName(idx) + "\"";
break;
case 7:
idx = BitConverter.ToInt32(memory, p.offset + 24);
s += idx.ToString() + "(count)";
break;
case 9:
idx = BitConverter.ToInt32(memory, p.offset + 24);
s += "#" + idx.ToString();
break;
}
TreeNode ret = new TreeNode(s);
ret.Name = p.offset.ToString();
return(ret);
}
public List<PropHeader> ReadHeadersTillNone()
{
List<PropHeader> ret = new List<PropHeader>();
bool run = true;
while (run)
{
PropHeader p = new PropHeader();
p.name = BitConverter.ToInt32(PropMemory, PropReadPos);
int test = BitConverter.ToInt32(PropMemory, PropReadPos + 4);
if (!pcc.isName(p.name) || test != 0)
run = false;
else
{
string namename = pcc.GetName(p.name);
if (pcc.GetName(p.name) != "None")
{
p.type = BitConverter.ToInt32(PropMemory, PropReadPos + 8);
int test2 = BitConverter.ToInt32(PropMemory, PropReadPos + 12);
int test3 = BitConverter.ToInt32(PropMemory, PropReadPos + 20);
if (!pcc.isName(p.type) || isType(pcc.GetName(p.type)) == -1 || test2 != 0 || test3 != 0)
run = false;
else
{
p.size = BitConverter.ToInt32(PropMemory, PropReadPos + 16);
p.index = BitConverter.ToInt32(PropMemory, PropReadPos + 20);
p.offset = PropReadPos;
ret.Add(p);
PropReadPos += p.size + 24;
if (isType(pcc.GetName(p.type)) == 5)//Boolbyte
PropReadPos++;
if (isType(pcc.GetName(p.type)) == 0 ||//StructName
isType(pcc.GetName(p.type)) == 6)//byteprop
PropReadPos += 8;
}
}
else
{
p.type = p.name;
p.size = 0;
p.index = 0;
p.offset = PropReadPos;
ret.Add(p);
PropReadPos += 8;
run = false;
}
}
}
return ret;
}
public TreeNode GenerateNode(PropHeader p)
{
string s = p.offset.ToString("X4") + " : ";
s += "Name: \"" + pcc.getNameEntry(p.name) + "\" ";
s += "Type: \"" + pcc.getNameEntry(p.type) + "\" ";
s += "Size: " + p.size.ToString() + " Value: ";
int idx = -1;
switch (isType(pcc.getNameEntry(p.type)))
{
case 3:
idx = BitConverter.ToInt32(memory, p.offset + 24);
s += idx.ToString() + " ";
if (idx == 0)
{
s += "None";
}
else
{
s += pcc.GetClass(idx);
}
break;
case 1:
idx = BitConverter.ToInt32(memory, p.offset + 24);
s += idx.ToString();
break;
case 8:
int count = BitConverter.ToInt32(memory, p.offset + 24);
s += "\"";
if (GameVersion == 1)
{
for (int i = 0; i < count - 1; i++)
{
s += (char)memory[p.offset + 28 + i];
}
}
else
{
for (int i = 0; i < count * -1 - 1; i++)
{
s += (char)memory[p.offset + 28 + i * 2];
}
}
s += "\"";
break;
case 5:
byte val = memory[p.offset + 24];
s += (val == 1).ToString();
break;
case 2:
float f = BitConverter.ToSingle(memory, p.offset + 24);
s += f.ToString() + "f";
break;
case 0:
case 4:
idx = BitConverter.ToInt32(memory, p.offset + 24);
s += "\"" + pcc.getNameEntry(idx) + "\"";
break;
case 6:
idx = BitConverter.ToInt32(memory, p.offset + 24);
if (GameVersion == 3)
{
int idx2 = BitConverter.ToInt32(memory, p.offset + 32);
s += "\"" + pcc.getNameEntry(idx) + "\",\"" + pcc.getNameEntry(idx2) + "\"";
}
else if (GameVersion == 2)
{
s += "\"" + pcc.GetName(idx) + "\"";
}
break;
case 7:
idx = BitConverter.ToInt32(memory, p.offset + 24);
s += idx.ToString() + "(count)";
break;
case 9:
idx = BitConverter.ToInt32(memory, p.offset + 24);
if (GameVersion == 3)
{
s += "#" + idx.ToString() + ": ";
s += talkFile.findDataById(idx);
}
else if (GameVersion == 2)
{
s += "#" + idx.ToString();
}
break;
}
TreeNode ret = new TreeNode(s);
ret.Name = p.offset.ToString();
return(ret);
}
public TreeNode GenerateNode(PropHeader p)
{
string s = p.offset.ToString("X4") + " : ";
s += "Name: \"" + pcc.GetName(p.name) + "\" ";
s += "Type: \"" + pcc.GetName(p.type) + "\" ";
s += "Size: " + p.size + " Value: ";
switch (isType(pcc.GetName(p.type)))
{
case 1:
case 3:
int idx = BitConverter.ToInt32(PropMemory, p.offset + 24);
s += idx.ToString();
break;
case 8:
int count = BitConverter.ToInt32(PropMemory, p.offset + 24);
s += "\"";
for (int i = 0; i < count * -1 - 1; i++)
s += (char)PropMemory[p.offset + 28 + i * 2];
s += "\"";
break;
case 5:
byte val = PropMemory[p.offset + 24];
s += (val == 1).ToString();
break;
case 2:
float f = BitConverter.ToSingle(PropMemory, p.offset + 24);
s += f + "f";
break;
case 0:
case 4:
idx = BitConverter.ToInt32(PropMemory, p.offset + 24);
s += "\"" + pcc.GetName(idx) + "\"";
break;
case 6:
if (p.size == 8)
{
idx = BitConverter.ToInt32(PropMemory, p.offset + 24);
int idx2 = BitConverter.ToInt32(PropMemory, p.offset + 32);
s += "\"" + pcc.GetName(idx) + "\",\"" + pcc.GetName(idx2) + "\"";
}
else
{
s += PropMemory[p.offset + 32].ToString();
}
break;
case 7:
idx = BitConverter.ToInt32(PropMemory, p.offset + 24);
s += idx + "(count)";
break;
case 9:
idx = BitConverter.ToInt32(PropMemory, p.offset + 24);
s += "#" + idx ;
break;
}
TreeNode ret = new TreeNode(s);
ret.Name = p.offset.ToString();
return ret;
}
