oup/current/Code_DataStructures.pas

unit Code_DataStructures;

interface

uses SysUtils, Classes, Data, Dialogs, StrUtils;

type
  Tstructure_entry = record
    Name:     String;
    offset:   LongWord;
    datatype: Word;  // 1..4  : Integer[1..4] dec
    // 5..8  : Integer[1..4] hex
    // 9     : float
    // 10    : bitset
    // 11    : raw-addr
    // 12    : dat-file-ID
    // 13..16: Signed Integer[1..4]
    // 17    : level-ID
    // 100..300: dat-file-name[0..200]
    // 1000..9999: Unused data[0-8999]
    // 10000+: string[0+]
    description: String;
  end;

  TStructDefSub = record
    SubName: String;
    SubDesc: String;
    Entries: array of TStructure_entry;
  end;

  TStructDef = record
    Data:   Boolean;
    Global: array of TStructure_entry;
    Subs:   array of TStructDefSub;
  end;
  THandler = function(fileid: LongWord): TRawList;

  TRawListHandlers = record
    Ext:     String[4];
    needed:  Boolean;
    Handler: THandler;
  end;

var
  RawListHandlers: array of TRawListHandlers;
  Raws: String;


function LoadStructureDefinition(fileid: LongWord): TStructDef;
function GetDataType(typeid: Word): String;
function GetTypeDataLength(datatype: Word): Word;

implementation

uses Code_Functions, Code_OniDataClass, Forms;


function GetTypeDataLength(datatype: Word): Word;
begin
  case datatype of
    1..4:
      Result := datatype;
    5..8:
      Result := datatype - 4;
    9:
      Result := 4;
    10:
      Result := 1;
    11:
      Result := 4;
    12:
      Result := 4;
    13..16:
      Result := datatype - 12;
    17:
      Result := 4;
    100..300:
      Result := datatype - 100;
    1000..9999:
      Result := datatype - 1000;
    10000..65535:
      Result := datatype - 10000;
  end;
end;


function GetDataType(typeid: Word): String;
begin
  case typeid of
    1..4:
      Result := 'Int' + IntToStr(typeid * 8);
    5..8:
      Result := 'Int' + IntToStr((typeid - 4) * 8);
    9:
      Result := 'Float';
    10:
      Result := 'BitSet';
    11:
      Result := 'Raw-Address';
    12:
      Result := '.dat-file-ID';
    13..16:
      Result := 'SignedInt' + IntToStr((typeid - 12) * 8);
    17:
      Result := 'LevelID';
    100..300:
      Result := '.dat-file-name(' + IntToStr(typeid - 100) + ')';
    1000..9999:
      Result := 'Unused(' + IntToStr(typeid - 1000) + ')';
    10000..65535:
      Result := 'String(' + IntToStr(typeid - 10000) + ')';
  end;
end;


function AGDB(fileid: LongWord): TRawList;
var
  link:  LongWord;
  links: LongWord;
  i:     LongWord;
begin
  if not OniDataConnection.OSisMac then
  begin
    OniDataConnection.LoadDatFilePart(fileid, $1C, 4, @links);
    links := links * 2;
    SetLength(Result, links);
    for i := 0 to links - 1 do
    begin
      Result[i].src_offset := $20 + i * 4;
      OniDataConnection.LoadDatFilePart(fileid, $20 + i * 4, 4, @link);
      Result[i].raw_addr := link;
      Result[i].raw_size := 0{????????????????????????????????};
      Result[i].loc_sep  := False;
    end;
  end;
end;


function AKVA(fileid: LongWord): TRawList;
var
  link:  LongWord;
  links: LongWord;
  i:     LongWord;
begin
  if not OniDataConnection.OSisMac then
  begin
    OniDataConnection.LoadDatFilePart(fileid, $1C, 4, @links);
    SetLength(Result, links);
    for i := 0 to links - 1 do
    begin
      Result[i].src_offset := $20 + i * $74 + $24;
      OniDataConnection.LoadDatFilePart(fileid, $20 + i * $74 + $24, 4, @link);
      Result[i].raw_addr := link;
      OniDataConnection.LoadDatFilePart(fileid, $20 + i * $74 + $28, 4, @link);
      Result[i].raw_size := link;
      Result[i].loc_sep  := False;
    end;
  end;
end;


function BINA(fileid: LongWord): TRawList;
var
  link:     LongWord;
  datasize: LongWord;
begin
  OniDataConnection.LoadDatFilePart(fileid, $0C, 4, @link);
  OniDataConnection.LoadDatFilePart(fileid, $08, 4, @datasize);
  SetLength(Result, 1);
  Result[0].src_offset := $0C;
  Result[0].raw_addr   := link;
  Result[0].raw_size   := datasize;
  Result[0].loc_sep    := OniDataConnection.OSisMac;
end;


function OSBD(fileid: LongWord): TRawList;
var
  link:     LongWord;
  datasize: LongWord;
begin
  OniDataConnection.LoadDatFilePart(fileid, $08, 4, @datasize);
  OniDataConnection.LoadDatFilePart(fileid, $0C, 4, @link);
  SetLength(Result, 1);
  Result[0].src_offset := $0C;
  Result[0].raw_addr   := link;
  Result[0].raw_size   := datasize;
  Result[0].loc_sep    := OniDataConnection.OSisMac;
end;


function SNDD(fileid: LongWord): TRawList;
var
  link:     LongWord;
  datasize: LongWord;
begin
  SetLength(Result, 1);
  if not OniDataConnection.OSisMac then
  begin
    OniDataConnection.LoadDatFilePart(fileid, $40, 4, @datasize);
    OniDataConnection.LoadDatFilePart(fileid, $44, 4, @link);
    Result[0].src_offset := $44;
  end
  else
  begin
    OniDataConnection.LoadDatFilePart(fileid, $10, 4, @datasize);
    OniDataConnection.LoadDatFilePart(fileid, $14, 4, @link);
    Result[0].src_offset := $14;
  end;
  Result[0].raw_addr := link;
  Result[0].raw_size := datasize;
  Result[0].loc_sep  := False;
end;


function SUBT(fileid: LongWord): TRawList;
var
  baselink, lastlink: LongWord;
  links: LongWord;
  j, k:  LongWord;
  Data:  Tdata;
begin
  OniDataConnection.LoadDatFilePart(fileid, $18, 4, @baselink);
  OniDataConnection.LoadDatFilePart(fileid, $1C, 4, @links);
  if links > 0 then
  begin
    OniDataConnection.LoadDatFilePart(fileid, $20 + (links - 1) * 4, 4, @lastlink);
    SetLength(Data, lastlink + 1024);
    TOniDataDat(OniDataConnection).LoadRawOffset(False,
      baselink, lastlink + 1024, Data);
    //      OniDataConnection.LoadRawFile(fileid,$1C,baselink,lastlink+1024,False,@data[0]);
    k := 0;
    for j := 0 to 1024 do
    begin
      if (Data[lastlink + j] = $00) or (j = 1024) then
      begin
        if j < 1024 then
        begin
          if k = 0 then
          begin
            k := 1;
          end
          else
          begin
            SetLength(Result, 1);
            Result[0].src_offset := $18;
            Result[0].raw_addr   := baselink;
            Result[0].raw_size   := lastlink + j;
            Break;
          end;
        end;
      end;
    end;
  end;
end;


function TRAM(fileid: LongWord): TRawList;
var
  i:      Integer;
  link:   LongWord;
  frames: Word;
  tempb:  Byte;
  tempw:  Word;
  templ:  LongWord;
  Data:   Tdata;
  offset: Word;
  frame_count: Byte;
begin
  SetLength(Result, 13);
  OniDataConnection.LoadDatFilePart(fileid, $16C, 2, @frames);
  {y-pos}
  OniDataConnection.LoadDatFilePart(fileid, $0C, 4, @link);
  Result[0].src_offset := $0C;
  Result[0].raw_addr   := link;
  Result[0].raw_size   := frames * 4;
  {x-z-pos}
  OniDataConnection.LoadDatFilePart(fileid, $10, 4, @link);
  Result[1].src_offset := $10;
  Result[1].raw_addr   := link;
  Result[1].raw_size   := frames * 8;
  {attacks}
  OniDataConnection.LoadDatFilePart(fileid, $182, 1, @tempb);
  OniDataConnection.LoadDatFilePart(fileid, $14, 4, @link);
  Result[2].src_offset := $14;
  Result[2].raw_addr   := link;
  Result[2].raw_size   := tempb * 32;
  {damage}
  OniDataConnection.LoadDatFilePart(fileid, $183, 1, @tempb);
  OniDataConnection.LoadDatFilePart(fileid, $18, 4, @link);
  Result[3].src_offset := $18;
  Result[3].raw_addr   := link;
  Result[3].raw_size   := tempb * 8;
  {motionblur}
  OniDataConnection.LoadDatFilePart(fileid, $184, 1, @tempb);
  OniDataConnection.LoadDatFilePart(fileid, $1C, 4, @link);
  Result[4].src_offset := $1C;
  Result[4].raw_addr   := link;
  Result[4].raw_size   := tempb * 8;
  {shortcut}
  OniDataConnection.LoadDatFilePart(fileid, $185, 1, @tempb);
  OniDataConnection.LoadDatFilePart(fileid, $20, 4, @link);
  Result[5].src_offset := $20;
  Result[5].raw_addr   := link;
  Result[5].raw_size   := tempb * 8;
  {throw}
  OniDataConnection.LoadDatFilePart(fileid, $24, 4, @link);
  Result[6].src_offset := $24;
  Result[6].raw_addr   := link;
  if link > 0 then
    Result[6].raw_size := 24
  else
    Result[6].raw_size := 0;
  {footstep}
  OniDataConnection.LoadDatFilePart(fileid, $186, 1, @tempb);
  OniDataConnection.LoadDatFilePart(fileid, $28, 4, @link);
  Result[7].src_offset := $28;
  Result[7].raw_addr   := link;
  Result[7].raw_size   := tempb * 4;
  {particle}
  OniDataConnection.LoadDatFilePart(fileid, $187, 1, @tempb);
  OniDataConnection.LoadDatFilePart(fileid, $2C, 4, @link);
  Result[8].src_offset := $2C;
  Result[8].raw_addr   := link;
  Result[8].raw_size   := tempb * 24;
  {position}
  OniDataConnection.LoadDatFilePart(fileid, $30, 4, @link);
  Result[9].src_offset := $30;
  Result[9].raw_addr   := link;
  Result[9].raw_size   := frames * 8;
  {particle}
  OniDataConnection.LoadDatFilePart(fileid, $154, 2, @tempw);
  OniDataConnection.LoadDatFilePart(fileid, $38, 4, @link);
  Result[11].src_offset := $38;
  Result[11].raw_addr   := link;
  Result[11].raw_size   := tempw * 34;
  {extent}
  OniDataConnection.LoadDatFilePart(fileid, $138, 4, @templ);
  OniDataConnection.LoadDatFilePart(fileid, $13C, 4, @link);
  Result[12].src_offset := $13C;
  Result[12].raw_addr   := link;
  Result[12].raw_size   := templ * 12;

  OniDataConnection.LoadDatFilePart(fileid, $34, 4, @link);
  if link > 0 then
  begin
    OniDataConnection.LoadDatFilePart(fileid, $160, 2, @tempw);
    frame_count := 0;
    i := 0;
    SetLength(Data, $FFFF);
    TOniDataDat(OniDataConnection).LoadRawOffset(False, link, $FFFF, Data);
    offset := Data[$24] + Data[$25] * 256;
    while (offset + i < Length(Data)) and (frame_count < frames - 1) do
    begin
      Inc(i, tempw);
      frame_count := frame_count + Data[offset + i];
      Inc(i);
    end;
    if offset + i < Length(Data) then
    begin
      Inc(i, tempw);
      Result[10].raw_size := offset + i;
    end
    else
    begin
      Result[10].raw_size := 0;
    end;
  end;
  Result[10].src_offset := $34;
  Result[10].raw_addr   := link;
end;


function TXMP(fileid: LongWord): TRawList;
var
  link_pc:   LongWord;
  link_mac:  LongWord;
  x, y:      Word;
  storetype: Byte;
  datasize:  LongWord;
begin
  OniDataConnection.LoadDatFilePart(fileid, $8C, SizeOf(x), @x);
  OniDataConnection.LoadDatFilePart(fileid, $8E, SizeOf(y), @y);
  OniDataConnection.LoadDatFilePart(fileid, $90, SizeOf(storetype), @storetype);
  OniDataConnection.LoadDatFilePart(fileid, $9C, 4, @link_pc);
  OniDataConnection.LoadDatFilePart(fileid, $A0, 4, @link_mac);
  case storetype of
    0, 1, 2:
      datasize := x * y * 2;
    8:
      datasize := x * y * 4;
    9:
      datasize := x * y div 2;
  end;
  SetLength(Result, 1);
  if not OniDataConnection.OSisMac then
  begin
    Result[0].src_offset := $9C;
    Result[0].raw_addr   := link_pc;
  end
  else
  begin
    Result[0].src_offset := $A0;
    Result[0].raw_addr   := link_mac;
  end;
  Result[0].raw_size := datasize;
  Result[0].loc_sep  := OniDataConnection.OSisMac;
end;


procedure InsertRawListHandler(ext: String; needed: Boolean; handler: THandler);
begin
  SetLength(RawListHandlers, Length(RawListHandlers) + 1);
  RawListHandlers[High(RawListHandlers)].Ext := ext;
  RawListHandlers[High(RawListHandlers)].needed := needed;
  RawListHandlers[High(RawListHandlers)].handler := handler;
  Raws := Raws + ext;
end;


function LoadStructureDefinition(fileid: LongWord): TStructDef;
var
  i:      LongWord;
  current_type: Byte; //0: Global, 1: Undynamic, 2: Dynamic
  current_base, current_package, current_package_size: LongWord;
  packages: LongWord;
  deffile: Text;
  structentry: TStructure_Entry;
  fields: TStringArray;
  filename: String;
  ext:    String[4];
  temps:  String;
  Data:   TData;
begin
  SetLength(Result.Global, 0);
  SetLength(Result.Subs, 0);
  Result.Data := False;
  ext      := OniDataConnection.GetFileInfo(fileid).Extension;
  filename := ExtractFilePath(Application.ExeName) + '\StructDefs\' + ext + '.txt';
  if FileExists(filename) then
  begin
    Data := OniDataConnection.LoadDatFile(fileid);
    AssignFile(deffile, filename);
    Reset(deffile);
    current_type := 0;
    Result.Data  := True;
    if not EOF(deffile) then
    begin
      ReadLn(deffile, temps);
      while not EOF(deffile) do
      begin
        ReadLn(deffile, temps);
        if (Length(temps) > 0) and (temps[1] <> '#') then
        begin
          if temps[1] = '*' then
          begin
            fields := Explode(temps, #9);
            case Length(fields) of
              1..2:
              begin
                current_type := 1;
                current_base := 0;
                SetLength(Result.Subs, Length(Result.Subs) + 1);
                Result.Subs[High(Result.Subs)].SubName :=
                  MidStr(fields[0], 2, Length(fields[0]) - 1);
                if Length(fields) = 2 then
                  Result.Subs[High(Result.Subs)].SubDesc := fields[1];
              end;
              3:
              begin
                current_type := 1;
                current_base := HexToLong(fields[2]);
                SetLength(Result.Subs, Length(Result.Subs) + 1);
                Result.Subs[High(Result.Subs)].SubName :=
                  MidStr(fields[0], 2, Length(fields[0]) - 1);
                Result.Subs[High(Result.Subs)].SubDesc := fields[1];
              end;
              6:
              begin
                current_type    := 2;
                current_base    := HexToLong(fields[2]);
                current_package := 0;
                current_package_size := StrToInt(fields[5]);
                if fields[4][1] <> '$' then
                begin
                  case StrToInt(fields[4]) of
                    1:
                      packages := Data[HexToLong(fields[3])];
                    2:
                      packages := Data[HexToLong(fields[3])] + Data[HexToLong(fields[3]) + 1] * 256;
                    4:
                      packages := Data[HexToLong(fields[3])] + Data[HexToLong(fields[3]) + 1] *
                        256 + Data[HexToLong(fields[3]) + 2] * 256 * 256 + Data[HexToLong(fields[3]) + 3] * 256 * 256 * 256;
                  end;
                end
                else
                begin
                  packages := HexToLong(fields[4]);
                end;
                SetLength(Result.Subs, Length(Result.Subs) + packages);
                for current_package := 0 to packages - 1 do
                begin
                  Result.Subs[High(Result.Subs) - packages +
                    current_package + 1].SubName :=
                    MidStr(fields[0], 2, Length(fields[0]) - 1) +
                    '[' + IntToStr(current_package) + ']' + '#' +
                    IntToHex(current_base + current_package * current_package_size, 8) +
                    '#' + IntToHex(current_package_size, 8);
                  Result.Subs[High(Result.Subs) - packages +
                    current_package + 1].SubDesc :=
                    fields[1];
                end;
              end;
            end;
          end
          else
          begin
            fields := Explode(temps, #9);
            if (Length(fields) = 3) or (Length(fields) = 4) then
            begin
              if not AppSettings.HideUnusedData or
                ((StrToInt(fields[2]) < 1000) or (StrToInt(fields[2]) > 9999)) then
              begin
                structentry.Name     := fields[0];
                structentry.datatype := StrToInt(fields[2]);
                if Length(fields) = 4 then
                  structentry.description := fields[3]
                else
                  structentry.description := '';
                if current_type in [0, 1] then
                begin
                  structentry.offset := HexToLong(fields[1]) + current_base;
                  if Length(Result.Subs) = 0 then
                  begin
                    SetLength(Result.Global, Length(Result.Global) + 1);
                    Result.Global[High(Result.Global)] := structentry;
                  end
                  else
                  begin
                    SetLength(Result.Subs[High(Result.Subs)].Entries,
                      Length(Result.Subs[High(Result.Subs)].Entries) + 1);
                    Result.Subs[High(Result.Subs)].Entries[High(
                      Result.Subs[High(Result.Subs)].Entries)] := structentry;
                  end;
                end
                else
                begin
                  for current_package := 0 to packages - 1 do
                  begin
                    structentry.offset :=
                      current_base + current_package * current_package_size + HexToLong(fields[1]);
                    with Result.Subs[High(Result.Subs) - packages + current_package + 1] do
                    begin
                      SetLength(Entries, Length(Entries) + 1);
                      Entries[High(Entries)] := structentry;
                    end;
                  end;
                end;
              end;
            end;
          end;
        end;
      end;
    end;
    CloseFile(deffile);
  end;
end;


begin
  Raws := '';
  //  InsertRawListHandler('AGDB',True,AGDB);
  InsertRawListHandler('AKVA', True, AKVA);
  InsertRawListHandler('BINA', True, BINA);
  InsertRawListHandler('OSBD', True, OSBD);
  InsertRawListHandler('SNDD', True, SNDD);
  InsertRawListHandler('SUBT', True, SUBT);
  InsertRawListHandler('TRAM', True, TRAM);
  InsertRawListHandler('TXMP', True, TXMP);
end.
Revision:	43
Committed:	Mon Dec 18 23:35:30 2006 UTC (18 years, 9 months ago) by alloc
Content type:	text/x-pascal
File size:	17953 byte(s)
Log Message:	DevTree 0.33a.
#	Content
1	unit Code_DataStructures;
2
3	interface
4
5	uses SysUtils, Classes, Data, Dialogs, StrUtils;
6
7	type
8	Tstructure_entry = record
9	Name: String;
10	offset: LongWord;
11	datatype: Word; // 1..4 : Integer[1..4] dec
12	// 5..8 : Integer[1..4] hex
13	// 9 : float
14	// 10 : bitset
15	// 11 : raw-addr
16	// 12 : dat-file-ID
17	// 13..16: Signed Integer[1..4]
18	// 17 : level-ID
19	// 100..300: dat-file-name[0..200]
20	// 1000..9999: Unused data[0-8999]
21	// 10000+: string[0+]
22	description: String;
23	end;
24
25	TStructDefSub = record
26	SubName: String;
27	SubDesc: String;
28	Entries: array of TStructure_entry;
29	end;
30
31	TStructDef = record
32	Data: Boolean;
33	Global: array of TStructure_entry;
34	Subs: array of TStructDefSub;
35	end;
36	THandler = function(fileid: LongWord): TRawList;
37
38	TRawListHandlers = record
39	Ext: String[4];
40	needed: Boolean;
41	Handler: THandler;
42	end;
43
44	var
45	RawListHandlers: array of TRawListHandlers;
46	Raws: String;
47
48
49	function LoadStructureDefinition(fileid: LongWord): TStructDef;
50	function GetDataType(typeid: Word): String;
51	function GetTypeDataLength(datatype: Word): Word;
52
53	implementation
54
55	uses Code_Functions, Code_OniDataClass, Forms;
56
57
58
59
60	function GetTypeDataLength(datatype: Word): Word;
61	begin
62	case datatype of
63	1..4:
64	Result := datatype;
65	5..8:
66	Result := datatype - 4;
67	9:
68	Result := 4;
69	10:
70	Result := 1;
71	11:
72	Result := 4;
73	12:
74	Result := 4;
75	13..16:
76	Result := datatype - 12;
77	17:
78	Result := 4;
79	100..300:
80	Result := datatype - 100;
81	1000..9999:
82	Result := datatype - 1000;
83	10000..65535:
84	Result := datatype - 10000;
85	end;
86	end;
87
88
89
90
91	function GetDataType(typeid: Word): String;
92	begin
93	case typeid of
94	1..4:
95	Result := 'Int' + IntToStr(typeid * 8);
96	5..8:
97	Result := 'Int' + IntToStr((typeid - 4) * 8);
98	9:
99	Result := 'Float';
100	10:
101	Result := 'BitSet';
102	11:
103	Result := 'Raw-Address';
104	12:
105	Result := '.dat-file-ID';
106	13..16:
107	Result := 'SignedInt' + IntToStr((typeid - 12) * 8);
108	17:
109	Result := 'LevelID';
110	100..300:
111	Result := '.dat-file-name(' + IntToStr(typeid - 100) + ')';
112	1000..9999:
113	Result := 'Unused(' + IntToStr(typeid - 1000) + ')';
114	10000..65535:
115	Result := 'String(' + IntToStr(typeid - 10000) + ')';
116	end;
117	end;
118
119
120
121
122	function AGDB(fileid: LongWord): TRawList;
123	var
124	link: LongWord;
125	links: LongWord;
126	i: LongWord;
127	begin
128	if not OniDataConnection.OSisMac then
129	begin
130	OniDataConnection.LoadDatFilePart(fileid, $1C, 4, @links);
131	links := links * 2;
132	SetLength(Result, links);
133	for i := 0 to links - 1 do
134	begin
135	Result[i].src_offset := $20 + i * 4;
136	OniDataConnection.LoadDatFilePart(fileid, $20 + i * 4, 4, @link);
137	Result[i].raw_addr := link;
138	Result[i].raw_size := 0{????????????????????????????????};
139	Result[i].loc_sep := False;
140	end;
141	end;
142	end;
143
144
145
146
147	function AKVA(fileid: LongWord): TRawList;
148	var
149	link: LongWord;
150	links: LongWord;
151	i: LongWord;
152	begin
153	if not OniDataConnection.OSisMac then
154	begin
155	OniDataConnection.LoadDatFilePart(fileid, $1C, 4, @links);
156	SetLength(Result, links);
157	for i := 0 to links - 1 do
158	begin
159	Result[i].src_offset := $20 + i * $74 + $24;
160	OniDataConnection.LoadDatFilePart(fileid, $20 + i * $74 + $24, 4, @link);
161	Result[i].raw_addr := link;
162	OniDataConnection.LoadDatFilePart(fileid, $20 + i * $74 + $28, 4, @link);
163	Result[i].raw_size := link;
164	Result[i].loc_sep := False;
165	end;
166	end;
167	end;
168
169
170
171
172	function BINA(fileid: LongWord): TRawList;
173	var
174	link: LongWord;
175	datasize: LongWord;
176	begin
177	OniDataConnection.LoadDatFilePart(fileid, $0C, 4, @link);
178	OniDataConnection.LoadDatFilePart(fileid, $08, 4, @datasize);
179	SetLength(Result, 1);
180	Result[0].src_offset := $0C;
181	Result[0].raw_addr := link;
182	Result[0].raw_size := datasize;
183	Result[0].loc_sep := OniDataConnection.OSisMac;
184	end;
185
186
187
188
189	function OSBD(fileid: LongWord): TRawList;
190	var
191	link: LongWord;
192	datasize: LongWord;
193	begin
194	OniDataConnection.LoadDatFilePart(fileid, $08, 4, @datasize);
195	OniDataConnection.LoadDatFilePart(fileid, $0C, 4, @link);
196	SetLength(Result, 1);
197	Result[0].src_offset := $0C;
198	Result[0].raw_addr := link;
199	Result[0].raw_size := datasize;
200	Result[0].loc_sep := OniDataConnection.OSisMac;
201	end;
202
203
204
205
206	function SNDD(fileid: LongWord): TRawList;
207	var
208	link: LongWord;
209	datasize: LongWord;
210	begin
211	SetLength(Result, 1);
212	if not OniDataConnection.OSisMac then
213	begin
214	OniDataConnection.LoadDatFilePart(fileid, $40, 4, @datasize);
215	OniDataConnection.LoadDatFilePart(fileid, $44, 4, @link);
216	Result[0].src_offset := $44;
217	end
218	else
219	begin
220	OniDataConnection.LoadDatFilePart(fileid, $10, 4, @datasize);
221	OniDataConnection.LoadDatFilePart(fileid, $14, 4, @link);
222	Result[0].src_offset := $14;
223	end;
224	Result[0].raw_addr := link;
225	Result[0].raw_size := datasize;
226	Result[0].loc_sep := False;
227	end;
228
229
230
231
232	function SUBT(fileid: LongWord): TRawList;
233	var
234	baselink, lastlink: LongWord;
235	links: LongWord;
236	j, k: LongWord;
237	Data: Tdata;
238	begin
239	OniDataConnection.LoadDatFilePart(fileid, $18, 4, @baselink);
240	OniDataConnection.LoadDatFilePart(fileid, $1C, 4, @links);
241	if links > 0 then
242	begin
243	OniDataConnection.LoadDatFilePart(fileid, $20 + (links - 1) * 4, 4, @lastlink);
244	SetLength(Data, lastlink + 1024);
245	TOniDataDat(OniDataConnection).LoadRawOffset(False,
246	baselink, lastlink + 1024, Data);
247	// OniDataConnection.LoadRawFile(fileid,$1C,baselink,lastlink+1024,False,@data[0]);
248	k := 0;
249	for j := 0 to 1024 do
250	begin
251	if (Data[lastlink + j] = $00) or (j = 1024) then
252	begin
253	if j < 1024 then
254	begin
255	if k = 0 then
256	begin
257	k := 1;
258	end
259	else
260	begin
261	SetLength(Result, 1);
262	Result[0].src_offset := $18;
263	Result[0].raw_addr := baselink;
264	Result[0].raw_size := lastlink + j;
265	Break;
266	end;
267	end;
268	end;
269	end;
270	end;
271	end;
272
273
274
275
276	function TRAM(fileid: LongWord): TRawList;
277	var
278	i: Integer;
279	link: LongWord;
280	frames: Word;
281	tempb: Byte;
282	tempw: Word;
283	templ: LongWord;
284	Data: Tdata;
285	offset: Word;
286	frame_count: Byte;
287	begin
288	SetLength(Result, 13);
289	OniDataConnection.LoadDatFilePart(fileid, $16C, 2, @frames);
290	{y-pos}
291	OniDataConnection.LoadDatFilePart(fileid, $0C, 4, @link);
292	Result[0].src_offset := $0C;
293	Result[0].raw_addr := link;
294	Result[0].raw_size := frames * 4;
295	{x-z-pos}
296	OniDataConnection.LoadDatFilePart(fileid, $10, 4, @link);
297	Result[1].src_offset := $10;
298	Result[1].raw_addr := link;
299	Result[1].raw_size := frames * 8;
300	{attacks}
301	OniDataConnection.LoadDatFilePart(fileid, $182, 1, @tempb);
302	OniDataConnection.LoadDatFilePart(fileid, $14, 4, @link);
303	Result[2].src_offset := $14;
304	Result[2].raw_addr := link;
305	Result[2].raw_size := tempb * 32;
306	{damage}
307	OniDataConnection.LoadDatFilePart(fileid, $183, 1, @tempb);
308	OniDataConnection.LoadDatFilePart(fileid, $18, 4, @link);
309	Result[3].src_offset := $18;
310	Result[3].raw_addr := link;
311	Result[3].raw_size := tempb * 8;
312	{motionblur}
313	OniDataConnection.LoadDatFilePart(fileid, $184, 1, @tempb);
314	OniDataConnection.LoadDatFilePart(fileid, $1C, 4, @link);
315	Result[4].src_offset := $1C;
316	Result[4].raw_addr := link;
317	Result[4].raw_size := tempb * 8;
318	{shortcut}
319	OniDataConnection.LoadDatFilePart(fileid, $185, 1, @tempb);
320	OniDataConnection.LoadDatFilePart(fileid, $20, 4, @link);
321	Result[5].src_offset := $20;
322	Result[5].raw_addr := link;
323	Result[5].raw_size := tempb * 8;
324	{throw}
325	OniDataConnection.LoadDatFilePart(fileid, $24, 4, @link);
326	Result[6].src_offset := $24;
327	Result[6].raw_addr := link;
328	if link > 0 then
329	Result[6].raw_size := 24
330	else
331	Result[6].raw_size := 0;
332	{footstep}
333	OniDataConnection.LoadDatFilePart(fileid, $186, 1, @tempb);
334	OniDataConnection.LoadDatFilePart(fileid, $28, 4, @link);
335	Result[7].src_offset := $28;
336	Result[7].raw_addr := link;
337	Result[7].raw_size := tempb * 4;
338	{particle}
339	OniDataConnection.LoadDatFilePart(fileid, $187, 1, @tempb);
340	OniDataConnection.LoadDatFilePart(fileid, $2C, 4, @link);
341	Result[8].src_offset := $2C;
342	Result[8].raw_addr := link;
343	Result[8].raw_size := tempb * 24;
344	{position}
345	OniDataConnection.LoadDatFilePart(fileid, $30, 4, @link);
346	Result[9].src_offset := $30;
347	Result[9].raw_addr := link;
348	Result[9].raw_size := frames * 8;
349	{particle}
350	OniDataConnection.LoadDatFilePart(fileid, $154, 2, @tempw);
351	OniDataConnection.LoadDatFilePart(fileid, $38, 4, @link);
352	Result[11].src_offset := $38;
353	Result[11].raw_addr := link;
354	Result[11].raw_size := tempw * 34;
355	{extent}
356	OniDataConnection.LoadDatFilePart(fileid, $138, 4, @templ);
357	OniDataConnection.LoadDatFilePart(fileid, $13C, 4, @link);
358	Result[12].src_offset := $13C;
359	Result[12].raw_addr := link;
360	Result[12].raw_size := templ * 12;
361
362	OniDataConnection.LoadDatFilePart(fileid, $34, 4, @link);
363	if link > 0 then
364	begin
365	OniDataConnection.LoadDatFilePart(fileid, $160, 2, @tempw);
366	frame_count := 0;
367	i := 0;
368	SetLength(Data, $FFFF);
369	TOniDataDat(OniDataConnection).LoadRawOffset(False, link, $FFFF, Data);
370	offset := Data[$24] + Data[$25] * 256;
371	while (offset + i < Length(Data)) and (frame_count < frames - 1) do
372	begin
373	Inc(i, tempw);
374	frame_count := frame_count + Data[offset + i];
375	Inc(i);
376	end;
377	if offset + i < Length(Data) then
378	begin
379	Inc(i, tempw);
380	Result[10].raw_size := offset + i;
381	end
382	else
383	begin
384	Result[10].raw_size := 0;
385	end;
386	end;
387	Result[10].src_offset := $34;
388	Result[10].raw_addr := link;
389	end;
390
391
392
393
394	function TXMP(fileid: LongWord): TRawList;
395	var
396	link_pc: LongWord;
397	link_mac: LongWord;
398	x, y: Word;
399	storetype: Byte;
400	datasize: LongWord;
401	begin
402	OniDataConnection.LoadDatFilePart(fileid, $8C, SizeOf(x), @x);
403	OniDataConnection.LoadDatFilePart(fileid, $8E, SizeOf(y), @y);
404	OniDataConnection.LoadDatFilePart(fileid, $90, SizeOf(storetype), @storetype);
405	OniDataConnection.LoadDatFilePart(fileid, $9C, 4, @link_pc);
406	OniDataConnection.LoadDatFilePart(fileid, $A0, 4, @link_mac);
407	case storetype of
408	0, 1, 2:
409	datasize := x * y * 2;
410	8:
411	datasize := x * y * 4;
412	9:
413	datasize := x * y div 2;
414	end;
415	SetLength(Result, 1);
416	if not OniDataConnection.OSisMac then
417	begin
418	Result[0].src_offset := $9C;
419	Result[0].raw_addr := link_pc;
420	end
421	else
422	begin
423	Result[0].src_offset := $A0;
424	Result[0].raw_addr := link_mac;
425	end;
426	Result[0].raw_size := datasize;
427	Result[0].loc_sep := OniDataConnection.OSisMac;
428	end;
429
430
431
432
433	procedure InsertRawListHandler(ext: String; needed: Boolean; handler: THandler);
434	begin
435	SetLength(RawListHandlers, Length(RawListHandlers) + 1);
436	RawListHandlers[High(RawListHandlers)].Ext := ext;
437	RawListHandlers[High(RawListHandlers)].needed := needed;
438	RawListHandlers[High(RawListHandlers)].handler := handler;
439	Raws := Raws + ext;
440	end;
441
442
443
444
445	function LoadStructureDefinition(fileid: LongWord): TStructDef;
446	var
447	i: LongWord;
448	current_type: Byte; //0: Global, 1: Undynamic, 2: Dynamic
449	current_base, current_package, current_package_size: LongWord;
450	packages: LongWord;
451	deffile: Text;
452	structentry: TStructure_Entry;
453	fields: TStringArray;
454	filename: String;
455	ext: String[4];
456	temps: String;
457	Data: TData;
458	begin
459	SetLength(Result.Global, 0);
460	SetLength(Result.Subs, 0);
461	Result.Data := False;
462	ext := OniDataConnection.GetFileInfo(fileid).Extension;
463	filename := ExtractFilePath(Application.ExeName) + '\StructDefs\' + ext + '.txt';
464	if FileExists(filename) then
465	begin
466	Data := OniDataConnection.LoadDatFile(fileid);
467	AssignFile(deffile, filename);
468	Reset(deffile);
469	current_type := 0;
470	Result.Data := True;
471	if not EOF(deffile) then
472	begin
473	ReadLn(deffile, temps);
474	while not EOF(deffile) do
475	begin
476	ReadLn(deffile, temps);
477	if (Length(temps) > 0) and (temps[1] <> '#') then
478	begin
479	if temps[1] = '*' then
480	begin
481	fields := Explode(temps, #9);
482	case Length(fields) of
483	1..2:
484	begin
485	current_type := 1;
486	current_base := 0;
487	SetLength(Result.Subs, Length(Result.Subs) + 1);
488	Result.Subs[High(Result.Subs)].SubName :=
489	MidStr(fields[0], 2, Length(fields[0]) - 1);
490	if Length(fields) = 2 then
491	Result.Subs[High(Result.Subs)].SubDesc := fields[1];
492	end;
493	3:
494	begin
495	current_type := 1;
496	current_base := HexToLong(fields[2]);
497	SetLength(Result.Subs, Length(Result.Subs) + 1);
498	Result.Subs[High(Result.Subs)].SubName :=
499	MidStr(fields[0], 2, Length(fields[0]) - 1);
500	Result.Subs[High(Result.Subs)].SubDesc := fields[1];
501	end;
502	6:
503	begin
504	current_type := 2;
505	current_base := HexToLong(fields[2]);
506	current_package := 0;
507	current_package_size := StrToInt(fields[5]);
508	if fields[4][1] <> '$' then
509	begin
510	case StrToInt(fields[4]) of
511	1:
512	packages := Data[HexToLong(fields[3])];
513	2:
514	packages := Data[HexToLong(fields[3])] + Data[HexToLong(fields[3]) + 1] * 256;
515	4:
516	packages := Data[HexToLong(fields[3])] + Data[HexToLong(fields[3]) + 1] *
517	256 + Data[HexToLong(fields[3]) + 2] * 256 * 256 + Data[HexToLong(fields[3]) + 3] * 256 * 256 * 256;
518	end;
519	end
520	else
521	begin
522	packages := HexToLong(fields[4]);
523	end;
524	SetLength(Result.Subs, Length(Result.Subs) + packages);
525	for current_package := 0 to packages - 1 do
526	begin
527	Result.Subs[High(Result.Subs) - packages +
528	current_package + 1].SubName :=
529	MidStr(fields[0], 2, Length(fields[0]) - 1) +
530	'[' + IntToStr(current_package) + ']' + '#' +
531	IntToHex(current_base + current_package * current_package_size, 8) +
532	'#' + IntToHex(current_package_size, 8);
533	Result.Subs[High(Result.Subs) - packages +
534	current_package + 1].SubDesc :=
535	fields[1];
536	end;
537	end;
538	end;
539	end
540	else
541	begin
542	fields := Explode(temps, #9);
543	if (Length(fields) = 3) or (Length(fields) = 4) then
544	begin
545	if not AppSettings.HideUnusedData or
546	((StrToInt(fields[2]) < 1000) or (StrToInt(fields[2]) > 9999)) then
547	begin
548	structentry.Name := fields[0];
549	structentry.datatype := StrToInt(fields[2]);
550	if Length(fields) = 4 then
551	structentry.description := fields[3]
552	else
553	structentry.description := '';
554	if current_type in [0, 1] then
555	begin
556	structentry.offset := HexToLong(fields[1]) + current_base;
557	if Length(Result.Subs) = 0 then
558	begin
559	SetLength(Result.Global, Length(Result.Global) + 1);
560	Result.Global[High(Result.Global)] := structentry;
561	end
562	else
563	begin
564	SetLength(Result.Subs[High(Result.Subs)].Entries,
565	Length(Result.Subs[High(Result.Subs)].Entries) + 1);
566	Result.Subs[High(Result.Subs)].Entries[High(
567	Result.Subs[High(Result.Subs)].Entries)] := structentry;
568	end;
569	end
570	else
571	begin
572	for current_package := 0 to packages - 1 do
573	begin
574	structentry.offset :=
575	current_base + current_package * current_package_size + HexToLong(fields[1]);
576	with Result.Subs[High(Result.Subs) - packages + current_package + 1] do
577	begin
578	SetLength(Entries, Length(Entries) + 1);
579	Entries[High(Entries)] := structentry;
580	end;
581	end;
582	end;
583	end;
584	end;
585	end;
586	end;
587	end;
588	end;
589	CloseFile(deffile);
590	end;
591	end;
592
593
594	begin
595	Raws := '';
596	// InsertRawListHandler('AGDB',True,AGDB);
597	InsertRawListHandler('AKVA', True, AKVA);
598	InsertRawListHandler('BINA', True, BINA);
599	InsertRawListHandler('OSBD', True, OSBD);
600	InsertRawListHandler('SNDD', True, SNDD);
601	InsertRawListHandler('SUBT', True, SUBT);
602	InsertRawListHandler('TRAM', True, TRAM);
603	InsertRawListHandler('TXMP', True, TXMP);
604	end.