| 2 |  |  | 
 
 
 
 
 
 
 
 
 
 
 
 
 | 3 |  | interface | 
 
 
 
 
 
 
 
 
 
 
 
 
 | 4 |  |  | 
 
 
 
 
 
 
 
 
 
 
 | 5 | < | uses TypeDefs, ConnectionManager; | 
 
 
 
 
 
 
 
 
 | 5 | > | uses TypeDefs; | 
 
 
 
 
 
 
 
 
 
 
 | 6 |  |  | 
 
 
 
 
 
 
 
 
 
 
 
 
 | 7 |  | type | 
 
 
 
 
 
 
 
 
 
 
 
 
 | 8 |  | THandler = function(ConnectionID, FileID: Integer): TRawDataList; | 
 
 
 
 
 
 
 
 
 
 
 | 9 | < | TRawListHandlers = record | 
 
 
 
 
 
 
 
 
 | 9 | > | TRawListHandler = record | 
 
 
 
 
 
 
 
 
 
 
 | 10 |  | Ext:     String[4]; | 
 
 
 
 
 
 
 
 
 
 
 
 
 | 11 |  | needed:  Boolean; | 
 
 
 
 
 
 
 
 
 
 
 
 
 | 12 |  | Handler: THandler; | 
 
 
 
 
 
 
 
 
 
 
 
 
 | 13 |  | end; | 
 
 
 
 
 
 
 
 | 14 | + | TRawListHandlers = array of TRawListHandler; | 
 
 
 
 
 
 
 
 
 
 
 
 
 | 15 |  |  | 
 
 
 
 
 
 
 
 
 
 
 
 
 | 16 |  | TRawLists = class | 
 
 
 
 
 
 
 
 
 
 
 
 
 | 17 |  | private | 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 | 25 |  |  | 
 
 
 
 
 
 
 
 
 
 
 
 
 | 26 |  | var | 
 
 
 
 
 
 
 
 
 
 
 
 
 | 27 |  | RawLists: TRawLists; | 
 
 
 
 
 
 
 
 
 
 
 | 28 | < |  | 
 
 
 
 
 
 
 
 
 | 28 | > |  | 
 
 
 
 
 
 
 
 
 
 
 | 29 |  |  | 
 
 
 
 
 
 
 
 
 
 
 
 
 | 30 |  | implementation | 
 
 
 
 
 
 
 
 
 
 
 
 
 | 31 |  |  | 
 
 
 
 
 
 
 
 
 
 
 
 
 | 32 |  | uses | 
 
 
 
 
 
 
 
 
 
 
 | 33 | < | Template; | 
 
 
 
 
 
 
 
 
 | 33 | > | Template, ConnectionManager, Access_OniArchive, Classes, SysUtils; | 
 
 
 
 
 
 
 
 
 
 
 | 34 |  |  | 
 
 
 
 
 
 
 
 
 
 
 
 
 | 35 |  |  | 
 
 
 
 
 
 
 
 
 
 
 
 
 | 36 |  | function AGDB(ConnectionID, FileID: Integer): TRawDataList; | 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 | 39 |  | links: Integer; | 
 
 
 
 
 
 
 
 
 
 
 
 
 | 40 |  | i:     Integer; | 
 
 
 
 
 
 
 
 
 
 
 
 
 | 41 |  | begin | 
 
 
 
 
 
 
 
 
 
 
 | 42 | < | if not connection.OSisMac then | 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 | 42 | > | ConManager.Connection[ConnectionID].LoadDatFilePart(fileid, $1C, 4, @links); | 
 
 
 
 
 | 43 | > | links := links * 2; | 
 
 
 
 
 | 44 | > | SetLength(Result, links); | 
 
 
 
 
 | 45 | > | for i := 0 to links - 1 do | 
 
 
 
 
 
 
 
 
 
 
 | 46 |  | begin | 
 
 
 
 
 
 
 
 
 
 
 | 47 | < | ConManager.Connection[ConnectionID].LoadDatFilePart(fileid, $1C, 4, @links); | 
 
 
 
 
 
 
 
 
 
 
 
 
 | 48 | < | links := links * 2; | 
 
 
 
 
 
 
 
 
 
 
 
 
 | 49 | < | SetLength(Result, links); | 
 
 
 
 
 
 
 
 
 
 
 
 
 | 50 | < | for i := 0 to links - 1 do | 
 
 
 
 
 
 
 
 
 
 
 
 
 | 51 | < | begin | 
 
 
 
 
 
 
 
 
 
 
 
 
 | 48 | < | Result[i].src_offset := $20 + i * 4; | 
 
 
 
 
 
 
 
 
 
 
 
 
 | 49 | < | ConManager.Connection[ConnectionID].LoadDatFilePart(fileid, $20 + i * 4, 4, @link); | 
 
 
 
 
 
 
 
 
 
 
 
 
 | 50 | < | Result[i].raw_addr := link; | 
 
 
 
 
 
 
 
 
 
 
 
 
 | 51 | < | Result[i].raw_size := 32; | 
 
 
 
 
 
 
 
 
 
 
 
 
 | 52 | < | Result[i].loc_sep  := False; | 
 
 
 
 
 
 
 
 
 
 
 
 
 | 53 | < | end; | 
 
 
 
 
 
 
 
 
 | 47 | > | Result[i].SrcOffset := $20 + i * 4; | 
 
 
 
 
 | 48 | > | ConManager.Connection[ConnectionID].LoadDatFilePart(fileid, $20 + i * 4, 4, @link); | 
 
 
 
 
 | 49 | > | Result[i].RawAddr := link; | 
 
 
 
 
 | 50 | > | Result[i].RawSize := 32; | 
 
 
 
 
 | 51 | > | Result[i].LocSep  := False; | 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 | 52 |  | end; | 
 
 
 
 
 
 
 
 
 
 
 
 
 | 53 |  | end; | 
 
 
 
 
 
 
 
 
 
 
 
 
 | 54 |  |  | 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 | 61 |  | links: Integer; | 
 
 
 
 
 
 
 
 
 
 
 
 
 | 62 |  | i:     Integer; | 
 
 
 
 
 
 
 
 
 
 
 
 
 | 63 |  | begin | 
 
 
 
 
 
 
 
 
 
 
 | 64 | < | if not connection.OSisMac then | 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 | 64 | > | ConManager.Connection[ConnectionID].LoadDatFilePart(fileid, $1C, 4, @links); | 
 
 
 
 
 | 65 | > | SetLength(Result, links); | 
 
 
 
 
 | 66 | > | for i := 0 to links - 1 do | 
 
 
 
 
 
 
 
 
 
 
 | 67 |  | begin | 
 
 
 
 
 
 
 
 
 
 
 | 68 | < | ConManager.Connection[ConnectionID].LoadDatFilePart(fileid, $1C, 4, @links); | 
 
 
 
 
 
 
 
 
 
 
 
 
 | 69 | < | SetLength(Result, links); | 
 
 
 
 
 
 
 
 
 
 
 
 
 | 70 | < | for i := 0 to links - 1 do | 
 
 
 
 
 
 
 
 
 
 
 
 
 | 71 | < | begin | 
 
 
 
 
 
 
 
 
 
 
 
 
 | 72 | < | Result[i].src_offset := $20 + i * $74 + $24; | 
 
 
 
 
 
 
 
 
 
 
 
 
 | 73 | < | ConManager.Connection[ConnectionID].LoadDatFilePart(fileid, $20 + i * $74 + $24, 4, @link); | 
 
 
 
 
 
 
 
 
 
 
 
 
 | 74 | < | Result[i].raw_addr := link; | 
 
 
 
 
 
 
 
 
 
 
 
 
 | 75 | < | ConManager.Connection[ConnectionID].LoadDatFilePart(fileid, $20 + i * $74 + $28, 4, @link); | 
 
 
 
 
 
 
 
 
 
 
 
 
 | 76 | < | Result[i].raw_size := link; | 
 
 
 
 
 
 
 
 
 
 
 
 
 | 77 | < | Result[i].loc_sep  := False; | 
 
 
 
 
 
 
 
 
 
 
 
 
 | 78 | < | end; | 
 
 
 
 
 
 
 
 
 | 68 | > | Result[i].SrcOffset := $20 + i * $74 + $24; | 
 
 
 
 
 | 69 | > | ConManager.Connection[ConnectionID].LoadDatFilePart(fileid, $20 + i * $74 + $24, 4, @link); | 
 
 
 
 
 | 70 | > | Result[i].RawAddr := link; | 
 
 
 
 
 | 71 | > | ConManager.Connection[ConnectionID].LoadDatFilePart(fileid, $20 + i * $74 + $28, 4, @link); | 
 
 
 
 
 | 72 | > | Result[i].RawSize := link; | 
 
 
 
 
 | 73 | > | Result[i].LocSep  := False; | 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 | 74 |  | end; | 
 
 
 
 
 
 
 
 
 
 
 
 
 | 75 |  | end; | 
 
 
 
 
 
 
 
 
 
 
 
 
 | 76 |  |  | 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 | 85 |  | ConManager.Connection[ConnectionID].LoadDatFilePart(fileid, $0C, 4, @link); | 
 
 
 
 
 
 
 
 
 
 
 
 
 | 86 |  | ConManager.Connection[ConnectionID].LoadDatFilePart(fileid, $08, 4, @datasize); | 
 
 
 
 
 
 
 
 
 
 
 
 
 | 87 |  | SetLength(Result, 1); | 
 
 
 
 
 
 
 
 
 
 
 | 88 | < | Result[0].src_offset := $0C; | 
 
 
 
 
 
 
 
 
 
 
 
 
 | 89 | < | Result[0].raw_addr   := link; | 
 
 
 
 
 
 
 
 
 
 
 
 
 | 90 | < | Result[0].raw_size   := datasize; | 
 
 
 
 
 
 
 
 
 
 
 
 
 | 91 | < | Result[0].loc_sep    := connection.OSisMac; | 
 
 
 
 
 
 
 
 
 | 88 | > | Result[0].SrcOffset := $0C; | 
 
 
 
 
 | 89 | > | Result[0].RawAddr   := link; | 
 
 
 
 
 | 90 | > | Result[0].RawSize   := datasize; | 
 
 
 
 
 | 91 | > | Result[0].LocSep    := not (ConManager.Connection[ConnectionID].DataOS = DOS_WIN); | 
 
 
 
 
 
 
 
 
 
 
 | 92 |  | end; | 
 
 
 
 
 
 
 
 
 
 
 
 
 | 93 |  |  | 
 
 
 
 
 
 
 
 
 
 
 
 
 | 94 |  |  | 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 | 102 |  | ConManager.Connection[ConnectionID].LoadDatFilePart(fileid, $08, 4, @datasize); | 
 
 
 
 
 
 
 
 
 
 
 
 
 | 103 |  | ConManager.Connection[ConnectionID].LoadDatFilePart(fileid, $0C, 4, @link); | 
 
 
 
 
 
 
 
 
 
 
 
 
 | 104 |  | SetLength(Result, 1); | 
 
 
 
 
 
 
 
 
 
 
 | 105 | < | Result[0].src_offset := $0C; | 
 
 
 
 
 
 
 
 
 
 
 
 
 | 106 | < | Result[0].raw_addr   := link; | 
 
 
 
 
 
 
 
 
 
 
 
 
 | 107 | < | Result[0].raw_size   := datasize; | 
 
 
 
 
 
 
 
 
 
 
 
 
 | 108 | < | Result[0].loc_sep    := connection.OSisMac; | 
 
 
 
 
 
 
 
 
 | 105 | > | Result[0].SrcOffset := $0C; | 
 
 
 
 
 | 106 | > | Result[0].RawAddr   := link; | 
 
 
 
 
 | 107 | > | Result[0].RawSize   := datasize; | 
 
 
 
 
 | 108 | > | Result[0].LocSep     := not (ConManager.Connection[ConnectionID].DataOS = DOS_WIN); | 
 
 
 
 
 
 
 
 
 
 
 | 109 |  | end; | 
 
 
 
 
 
 
 
 
 
 
 
 
 | 110 |  |  | 
 
 
 
 
 
 
 
 
 
 
 
 
 | 111 |  |  | 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 | 117 |  | datasize: Integer; | 
 
 
 
 
 
 
 
 
 
 
 
 
 | 118 |  | begin | 
 
 
 
 
 
 
 
 
 
 
 
 
 | 119 |  | SetLength(Result, 1); | 
 
 
 
 
 
 
 
 
 
 
 | 120 | < | if not connection.OSisMac then | 
 
 
 
 
 
 
 
 
 | 120 | > | if ConManager.Connection[ConnectionID].DataOS = DOS_MAC then | 
 
 
 
 
 
 
 
 
 
 
 | 121 |  | begin | 
 
 
 
 
 
 
 
 
 
 
 | 122 | < | ConManager.Connection[ConnectionID].LoadDatFilePart(fileid, $40, 4, @datasize); | 
 
 
 
 
 
 
 
 
 
 
 
 
 | 123 | < | ConManager.Connection[ConnectionID].LoadDatFilePart(fileid, $44, 4, @link); | 
 
 
 
 
 
 
 
 
 
 
 
 
 | 124 | < | Result[0].src_offset := $44; | 
 
 
 
 
 
 
 
 
 | 122 | > | ConManager.Connection[ConnectionID].LoadDatFilePart(fileid, $10, 4, @datasize); | 
 
 
 
 
 | 123 | > | ConManager.Connection[ConnectionID].LoadDatFilePart(fileid, $14, 4, @link); | 
 
 
 
 
 | 124 | > | Result[0].SrcOffset := $14; | 
 
 
 
 
 
 
 
 
 
 
 | 125 |  | end | 
 
 
 
 
 
 
 
 
 
 
 
 
 | 126 |  | else | 
 
 
 
 
 
 
 
 
 
 
 
 
 | 127 |  | begin | 
 
 
 
 
 
 
 
 
 
 
 | 128 | < | ConManager.Connection[ConnectionID].LoadDatFilePart(fileid, $10, 4, @datasize); | 
 
 
 
 
 
 
 
 
 
 
 
 
 | 129 | < | ConManager.Connection[ConnectionID].LoadDatFilePart(fileid, $14, 4, @link); | 
 
 
 
 
 
 
 
 
 
 
 
 
 | 130 | < | Result[0].src_offset := $14; | 
 
 
 
 
 
 
 
 
 | 128 | > | ConManager.Connection[ConnectionID].LoadDatFilePart(fileid, $40, 4, @datasize); | 
 
 
 
 
 | 129 | > | ConManager.Connection[ConnectionID].LoadDatFilePart(fileid, $44, 4, @link); | 
 
 
 
 
 | 130 | > | Result[0].SrcOffset := $44; | 
 
 
 
 
 
 
 
 
 
 
 | 131 |  | end; | 
 
 
 
 
 
 
 
 
 
 
 | 132 | < | Result[0].raw_addr := link; | 
 
 
 
 
 
 
 
 
 
 
 
 
 | 133 | < | Result[0].raw_size := datasize; | 
 
 
 
 
 
 
 
 
 
 
 
 
 | 134 | < | Result[0].loc_sep  := False; | 
 
 
 
 
 
 
 
 
 | 132 | > | Result[0].RawAddr := link; | 
 
 
 
 
 | 133 | > | Result[0].RawSize := datasize; | 
 
 
 
 
 | 134 | > | Result[0].LocSep  := False; | 
 
 
 
 
 
 
 
 
 
 
 | 135 |  | end; | 
 
 
 
 
 
 
 
 
 
 
 
 
 | 136 |  |  | 
 
 
 
 
 
 
 
 
 
 
 
 
 | 137 |  |  | 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 | 142 |  | baselink, lastlink: Integer; | 
 
 
 
 
 
 
 
 
 
 
 
 
 | 143 |  | links: Integer; | 
 
 
 
 
 
 
 
 
 
 
 
 
 | 144 |  | j, k:  Integer; | 
 
 
 
 
 
 
 
 
 
 
 | 145 | < | Data:  TByteData; | 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 | 145 | > | //  Data:  TByteData; | 
 
 
 
 
 | 146 | > | Data:  TStream; | 
 
 
 
 
 
 
 
 
 
 
 | 147 |  | begin | 
 
 
 
 
 
 
 
 
 
 
 
 
 | 148 |  | ConManager.Connection[ConnectionID].LoadDatFilePart(fileid, $18, 4, @baselink); | 
 
 
 
 
 
 
 
 
 
 
 
 
 | 149 |  | ConManager.Connection[ConnectionID].LoadDatFilePart(fileid, $1C, 4, @links); | 
 
 
 
 
 
 
 
 
 
 
 
 
 | 150 |  | if links > 0 then | 
 
 
 
 
 
 
 
 
 
 
 
 
 | 151 |  | begin | 
 
 
 
 
 
 
 
 
 
 
 
 
 | 152 |  | ConManager.Connection[ConnectionID].LoadDatFilePart(fileid, $20 + (links - 1) * 4, 4, @lastlink); | 
 
 
 
 
 
 
 
 
 
 
 | 153 | < | SetLength(Data, lastlink + 1024); | 
 
 
 
 
 
 
 
 
 
 
 
 
 | 154 | < | TOniDataDat(connection).LoadRawOffset(False, | 
 
 
 
 
 
 
 
 
 
 
 
 
 | 155 | < | baselink, lastlink + 1024, Data); | 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 | 153 | > | //    SetLength(Data, lastlink + 1024); | 
 
 
 
 
 | 154 | > | Data := nil; | 
 
 
 
 
 | 155 | > | TAccess_OniArchive(ConManager.Connection[ConnectionID]).LoadRawOffset( | 
 
 
 
 
 | 156 | > | False, baselink, lastlink + 1024, Data); | 
 
 
 
 
 | 157 | > | //    TOniDataDat(connection).LoadRawOffset(False, baselink, lastlink + 1024, Data); | 
 
 
 
 
 
 
 
 
 
 
 | 158 |  | //      connection.LoadRawFile(fileid,$1C,baselink,lastlink+1024,False,@data[0]); | 
 
 
 
 
 
 
 
 | 159 | + | raise ENotImplemented.Create('RawList.SUBT'); | 
 
 
 
 
 
 
 
 | 160 | + | end; | 
 
 
 
 
 
 
 
 | 161 | + | { | 
 
 
 
 
 
 
 
 
 
 
 
 
 | 162 |  | k := 0; | 
 
 
 
 
 
 
 
 
 
 
 
 
 | 163 |  | for j := 0 to 1024 do | 
 
 
 
 
 
 
 
 
 
 
 
 
 | 164 |  | begin | 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 | 182 |  | end; | 
 
 
 
 
 
 
 
 
 
 
 
 
 | 183 |  | end; | 
 
 
 
 
 
 
 
 
 
 
 
 
 | 184 |  | end; | 
 
 
 
 
 
 
 
 | 185 | + | } | 
 
 
 
 
 
 
 
 
 
 
 
 
 | 186 |  | end; | 
 
 
 
 
 
 
 
 
 
 
 
 
 | 187 |  |  | 
 
 
 
 
 
 
 
 
 
 
 
 
 | 188 |  |  | 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 | 204 |  | ConManager.Connection[ConnectionID].LoadDatFilePart(fileid, $16C, 2, @frames); | 
 
 
 
 
 
 
 
 
 
 
 
 
 | 205 |  | {y-pos} | 
 
 
 
 
 
 
 
 
 
 
 
 
 | 206 |  | ConManager.Connection[ConnectionID].LoadDatFilePart(fileid, $0C, 4, @link); | 
 
 
 
 
 
 
 
 
 
 
 | 207 | < | Result[0].src_offset := $0C; | 
 
 
 
 
 
 
 
 
 
 
 
 
 | 208 | < | Result[0].raw_addr   := link; | 
 
 
 
 
 
 
 
 
 
 
 
 
 | 209 | < | Result[0].raw_size   := frames * 4; | 
 
 
 
 
 
 
 
 
 | 207 | > | Result[0].SrcOffset := $0C; | 
 
 
 
 
 | 208 | > | Result[0].RawAddr   := link; | 
 
 
 
 
 | 209 | > | Result[0].RawSize   := frames * 4; | 
 
 
 
 
 
 
 
 
 
 
 | 210 |  | {x-z-pos} | 
 
 
 
 
 
 
 
 
 
 
 
 
 | 211 |  | ConManager.Connection[ConnectionID].LoadDatFilePart(fileid, $10, 4, @link); | 
 
 
 
 
 
 
 
 
 
 
 | 212 | < | Result[1].src_offset := $10; | 
 
 
 
 
 
 
 
 
 
 
 
 
 | 213 | < | Result[1].raw_addr   := link; | 
 
 
 
 
 
 
 
 
 
 
 
 
 | 214 | < | Result[1].raw_size   := frames * 8; | 
 
 
 
 
 
 
 
 
 | 212 | > | Result[1].SrcOffset := $10; | 
 
 
 
 
 | 213 | > | Result[1].RawAddr   := link; | 
 
 
 
 
 | 214 | > | Result[1].RawSize   := frames * 8; | 
 
 
 
 
 
 
 
 
 
 
 | 215 |  | {attacks} | 
 
 
 
 
 
 
 
 
 
 
 
 
 | 216 |  | ConManager.Connection[ConnectionID].LoadDatFilePart(fileid, $182, 1, @tempb); | 
 
 
 
 
 
 
 
 
 
 
 
 
 | 217 |  | ConManager.Connection[ConnectionID].LoadDatFilePart(fileid, $14, 4, @link); | 
 
 
 
 
 
 
 
 
 
 
 | 218 | < | Result[2].src_offset := $14; | 
 
 
 
 
 
 
 
 
 
 
 
 
 | 219 | < | Result[2].raw_addr   := link; | 
 
 
 
 
 
 
 
 
 
 
 
 
 | 220 | < | Result[2].raw_size   := tempb * 32; | 
 
 
 
 
 
 
 
 
 | 218 | > | Result[2].SrcOffset := $14; | 
 
 
 
 
 | 219 | > | Result[2].RawAddr   := link; | 
 
 
 
 
 | 220 | > | Result[2].RawSize   := tempb * 32; | 
 
 
 
 
 
 
 
 
 
 
 | 221 |  | {damage} | 
 
 
 
 
 
 
 
 
 
 
 
 
 | 222 |  | ConManager.Connection[ConnectionID].LoadDatFilePart(fileid, $183, 1, @tempb); | 
 
 
 
 
 
 
 
 
 
 
 
 
 | 223 |  | ConManager.Connection[ConnectionID].LoadDatFilePart(fileid, $18, 4, @link); | 
 
 
 
 
 
 
 
 
 
 
 | 224 | < | Result[3].src_offset := $18; | 
 
 
 
 
 
 
 
 
 
 
 
 
 | 225 | < | Result[3].raw_addr   := link; | 
 
 
 
 
 
 
 
 
 
 
 
 
 | 226 | < | Result[3].raw_size   := tempb * 8; | 
 
 
 
 
 
 
 
 
 | 224 | > | Result[3].SrcOffset := $18; | 
 
 
 
 
 | 225 | > | Result[3].RawAddr   := link; | 
 
 
 
 
 | 226 | > | Result[3].RawSize   := tempb * 8; | 
 
 
 
 
 
 
 
 
 
 
 | 227 |  | {motionblur} | 
 
 
 
 
 
 
 
 
 
 
 
 
 | 228 |  | ConManager.Connection[ConnectionID].LoadDatFilePart(fileid, $184, 1, @tempb); | 
 
 
 
 
 
 
 
 
 
 
 
 
 | 229 |  | ConManager.Connection[ConnectionID].LoadDatFilePart(fileid, $1C, 4, @link); | 
 
 
 
 
 
 
 
 
 
 
 | 230 | < | Result[4].src_offset := $1C; | 
 
 
 
 
 
 
 
 
 
 
 
 
 | 231 | < | Result[4].raw_addr   := link; | 
 
 
 
 
 
 
 
 
 
 
 
 
 | 232 | < | Result[4].raw_size   := tempb * 8; | 
 
 
 
 
 
 
 
 
 | 230 | > | Result[4].SrcOffset := $1C; | 
 
 
 
 
 | 231 | > | Result[4].RawAddr   := link; | 
 
 
 
 
 | 232 | > | Result[4].RawSize   := tempb * 8; | 
 
 
 
 
 
 
 
 
 
 
 | 233 |  | {shortcut} | 
 
 
 
 
 
 
 
 
 
 
 
 
 | 234 |  | ConManager.Connection[ConnectionID].LoadDatFilePart(fileid, $185, 1, @tempb); | 
 
 
 
 
 
 
 
 
 
 
 
 
 | 235 |  | ConManager.Connection[ConnectionID].LoadDatFilePart(fileid, $20, 4, @link); | 
 
 
 
 
 
 
 
 
 
 
 | 236 | < | Result[5].src_offset := $20; | 
 
 
 
 
 
 
 
 
 
 
 
 
 | 237 | < | Result[5].raw_addr   := link; | 
 
 
 
 
 
 
 
 
 
 
 
 
 | 238 | < | Result[5].raw_size   := tempb * 8; | 
 
 
 
 
 
 
 
 
 | 236 | > | Result[5].SrcOffset := $20; | 
 
 
 
 
 | 237 | > | Result[5].RawAddr   := link; | 
 
 
 
 
 | 238 | > | Result[5].RawSize   := tempb * 8; | 
 
 
 
 
 
 
 
 
 
 
 | 239 |  | {throw} | 
 
 
 
 
 
 
 
 
 
 
 
 
 | 240 |  | ConManager.Connection[ConnectionID].LoadDatFilePart(fileid, $24, 4, @link); | 
 
 
 
 
 
 
 
 
 
 
 | 241 | < | Result[6].src_offset := $24; | 
 
 
 
 
 
 
 
 
 
 
 
 
 | 242 | < | Result[6].raw_addr   := link; | 
 
 
 
 
 
 
 
 
 | 241 | > | Result[6].SrcOffset := $24; | 
 
 
 
 
 | 242 | > | Result[6].RawAddr   := link; | 
 
 
 
 
 
 
 
 
 
 
 | 243 |  | if link > 0 then | 
 
 
 
 
 
 
 
 
 
 
 | 244 | < | Result[6].raw_size := 24 | 
 
 
 
 
 
 
 
 
 | 244 | > | Result[6].RawSize := 24 | 
 
 
 
 
 
 
 
 
 
 
 | 245 |  | else | 
 
 
 
 
 
 
 
 
 
 
 | 246 | < | Result[6].raw_size := 0; | 
 
 
 
 
 
 
 
 
 | 246 | > | Result[6].RawSize := 0; | 
 
 
 
 
 
 
 
 
 
 
 | 247 |  | {footstep} | 
 
 
 
 
 
 
 
 
 
 
 
 
 | 248 |  | ConManager.Connection[ConnectionID].LoadDatFilePart(fileid, $186, 1, @tempb); | 
 
 
 
 
 
 
 
 
 
 
 
 
 | 249 |  | ConManager.Connection[ConnectionID].LoadDatFilePart(fileid, $28, 4, @link); | 
 
 
 
 
 
 
 
 
 
 
 | 250 | < | Result[7].src_offset := $28; | 
 
 
 
 
 
 
 
 
 
 
 
 
 | 251 | < | Result[7].raw_addr   := link; | 
 
 
 
 
 
 
 
 
 
 
 
 
 | 252 | < | Result[7].raw_size   := tempb * 4; | 
 
 
 
 
 
 
 
 
 | 250 | > | Result[7].SrcOffset := $28; | 
 
 
 
 
 | 251 | > | Result[7].RawAddr   := link; | 
 
 
 
 
 | 252 | > | Result[7].RawSize   := tempb * 4; | 
 
 
 
 
 
 
 
 
 
 
 | 253 |  | {particle} | 
 
 
 
 
 
 
 
 
 
 
 
 
 | 254 |  | ConManager.Connection[ConnectionID].LoadDatFilePart(fileid, $187, 1, @tempb); | 
 
 
 
 
 
 
 
 
 
 
 
 
 | 255 |  | ConManager.Connection[ConnectionID].LoadDatFilePart(fileid, $2C, 4, @link); | 
 
 
 
 
 
 
 
 
 
 
 | 256 | < | Result[8].src_offset := $2C; | 
 
 
 
 
 
 
 
 
 
 
 
 
 | 257 | < | Result[8].raw_addr   := link; | 
 
 
 
 
 
 
 
 
 
 
 
 
 | 258 | < | Result[8].raw_size   := tempb * 24; | 
 
 
 
 
 
 
 
 
 | 256 | > | Result[8].SrcOffset := $2C; | 
 
 
 
 
 | 257 | > | Result[8].RawAddr   := link; | 
 
 
 
 
 | 258 | > | Result[8].RawSize   := tempb * 24; | 
 
 
 
 
 
 
 
 
 
 
 | 259 |  | {position} | 
 
 
 
 
 
 
 
 
 
 
 
 
 | 260 |  | ConManager.Connection[ConnectionID].LoadDatFilePart(fileid, $30, 4, @link); | 
 
 
 
 
 
 
 
 
 
 
 | 261 | < | Result[9].src_offset := $30; | 
 
 
 
 
 
 
 
 
 
 
 
 
 | 262 | < | Result[9].raw_addr   := link; | 
 
 
 
 
 
 
 
 
 
 
 
 
 | 263 | < | Result[9].raw_size   := frames * 8; | 
 
 
 
 
 
 
 
 
 | 261 | > | Result[9].SrcOffset := $30; | 
 
 
 
 
 | 262 | > | Result[9].RawAddr   := link; | 
 
 
 
 
 | 263 | > | Result[9].RawSize   := frames * 8; | 
 
 
 
 
 
 
 
 
 
 
 | 264 |  | {particle} | 
 
 
 
 
 
 
 
 
 
 
 
 
 | 265 |  | ConManager.Connection[ConnectionID].LoadDatFilePart(fileid, $154, 2, @tempw); | 
 
 
 
 
 
 
 
 
 
 
 
 
 | 266 |  | ConManager.Connection[ConnectionID].LoadDatFilePart(fileid, $38, 4, @link); | 
 
 
 
 
 
 
 
 
 
 
 | 267 | < | Result[11].src_offset := $38; | 
 
 
 
 
 
 
 
 
 
 
 
 
 | 268 | < | Result[11].raw_addr   := link; | 
 
 
 
 
 
 
 
 
 
 
 
 
 | 269 | < | Result[11].raw_size   := tempw * 34; | 
 
 
 
 
 
 
 
 
 | 267 | > | Result[11].SrcOffset := $38; | 
 
 
 
 
 | 268 | > | Result[11].RawAddr   := link; | 
 
 
 
 
 | 269 | > | Result[11].RawSize   := tempw * 34; | 
 
 
 
 
 
 
 
 
 
 
 | 270 |  | {extent} | 
 
 
 
 
 
 
 
 
 
 
 
 
 | 271 |  | ConManager.Connection[ConnectionID].LoadDatFilePart(fileid, $138, 4, @templ); | 
 
 
 
 
 
 
 
 
 
 
 
 
 | 272 |  | ConManager.Connection[ConnectionID].LoadDatFilePart(fileid, $13C, 4, @link); | 
 
 
 
 
 
 
 
 
 
 
 | 273 | < | Result[12].src_offset := $13C; | 
 
 
 
 
 
 
 
 
 
 
 
 
 | 274 | < | Result[12].raw_addr   := link; | 
 
 
 
 
 
 
 
 
 
 
 
 
 | 275 | < | Result[12].raw_size   := templ * 12; | 
 
 
 
 
 
 
 
 
 | 273 | > | Result[12].SrcOffset := $13C; | 
 
 
 
 
 | 274 | > | Result[12].RawAddr   := link; | 
 
 
 
 
 | 275 | > | Result[12].RawSize   := templ * 12; | 
 
 
 
 
 
 
 
 
 
 
 | 276 |  |  | 
 
 
 
 
 
 
 
 
 
 
 
 
 | 277 |  | ConManager.Connection[ConnectionID].LoadDatFilePart(fileid, $34, 4, @link); | 
 
 
 
 
 
 
 
 
 
 
 
 
 | 278 |  | if link > 0 then | 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 | 281 |  | frame_count := 0; | 
 
 
 
 
 
 
 
 
 
 
 
 
 | 282 |  | i := 0; | 
 
 
 
 
 
 
 
 
 
 
 
 
 | 283 |  | SetLength(Data, $FFFF); | 
 
 
 
 
 
 
 
 
 
 
 | 284 | < | TOniDataDat(connection).LoadRawOffset(False, link, $FFFF, Data); | 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 | 284 | > | TAccess_OniArchive(ConManager.Connection[ConnectionID]).LoadRawOffset( | 
 
 
 
 
 | 285 | > | False, link, $FFFF, Data); | 
 
 
 
 
 
 
 
 
 
 
 | 286 |  | offset := Data[$24] + Data[$25] * 256; | 
 
 
 
 
 
 
 
 
 
 
 
 
 | 287 |  | while (offset + i < Length(Data)) and (frame_count < frames - 1) do | 
 
 
 
 
 
 
 
 
 
 
 
 
 | 288 |  | begin | 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 | 293 |  | if offset + i < Length(Data) then | 
 
 
 
 
 
 
 
 
 
 
 
 
 | 294 |  | begin | 
 
 
 
 
 
 
 
 
 
 
 
 
 | 295 |  | Inc(i, tempw); | 
 
 
 
 
 
 
 
 
 
 
 | 296 | < | Result[10].raw_size := offset + i; | 
 
 
 
 
 
 
 
 
 | 296 | > | Result[10].RawSize := offset + i; | 
 
 
 
 
 
 
 
 
 
 
 | 297 |  | end | 
 
 
 
 
 
 
 
 
 
 
 
 
 | 298 |  | else | 
 
 
 
 
 
 
 
 
 
 
 
 
 | 299 |  | begin | 
 
 
 
 
 
 
 
 
 
 
 | 300 | < | Result[10].raw_size := 0; | 
 
 
 
 
 
 
 
 
 | 300 | > | Result[10].RawSize := 0; | 
 
 
 
 
 
 
 
 
 
 
 | 301 |  | end; | 
 
 
 
 
 
 
 
 
 
 
 
 
 | 302 |  | end; | 
 
 
 
 
 
 
 
 
 
 
 | 303 | < | Result[10].src_offset := $34; | 
 
 
 
 
 
 
 
 
 
 
 
 
 | 304 | < | Result[10].raw_addr   := link; | 
 
 
 
 
 
 
 
 
 | 303 | > | Result[10].SrcOffset := $34; | 
 
 
 
 
 | 304 | > | Result[10].RawAddr   := link; | 
 
 
 
 
 
 
 
 
 
 
 | 305 |  | end; | 
 
 
 
 
 
 
 
 
 
 
 
 
 | 306 |  |  | 
 
 
 
 
 
 
 
 
 
 
 
 
 | 307 |  |  | 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 | 329 |  | datasize := x * y div 2; | 
 
 
 
 
 
 
 
 
 
 
 
 
 | 330 |  | end; | 
 
 
 
 
 
 
 
 
 
 
 
 
 | 331 |  | SetLength(Result, 1); | 
 
 
 
 
 
 
 
 
 
 
 | 332 | < | if not connection.OSisMac then | 
 
 
 
 
 
 
 
 
 | 332 | > | if ConManager.Connection[ConnectionID].DataOS = DOS_WIN then | 
 
 
 
 
 
 
 
 
 
 
 | 333 |  | begin | 
 
 
 
 
 
 
 
 
 
 
 | 334 | < | Result[0].src_offset := $9C; | 
 
 
 
 
 
 
 
 
 
 
 
 
 | 335 | < | Result[0].raw_addr   := link_pc; | 
 
 
 
 
 
 
 
 
 | 334 | > | Result[0].SrcOffset := $9C; | 
 
 
 
 
 | 335 | > | Result[0].RawAddr   := link_pc; | 
 
 
 
 
 
 
 
 
 
 
 | 336 |  | end | 
 
 
 
 
 
 
 
 
 
 
 
 
 | 337 |  | else | 
 
 
 
 
 
 
 
 
 
 
 
 
 | 338 |  | begin | 
 
 
 
 
 
 
 
 
 
 
 | 339 | < | Result[0].src_offset := $A0; | 
 
 
 
 
 
 
 
 
 
 
 
 
 | 340 | < | Result[0].raw_addr   := link_mac; | 
 
 
 
 
 
 
 
 
 | 339 | > | Result[0].SrcOffset := $A0; | 
 
 
 
 
 | 340 | > | Result[0].RawAddr   := link_mac; | 
 
 
 
 
 
 
 
 
 
 
 | 341 |  | end; | 
 
 
 
 
 
 
 
 
 
 
 | 342 | < | Result[0].raw_size := datasize; | 
 
 
 
 
 
 
 
 
 
 
 
 
 | 343 | < | Result[0].loc_sep  := connection.OSisMac; | 
 
 
 
 
 
 
 
 
 | 342 | > | Result[0].RawSize := datasize; | 
 
 
 
 
 | 343 | > | Result[0].LocSep  := not (ConManager.Connection[ConnectionID].DataOS = DOS_WIN); | 
 
 
 
 
 
 
 
 
 
 
 | 344 |  | end; | 
 
 
 
 
 
 
 
 
 
 
 
 
 | 345 |  |  | 
 
 
 
 
 
 
 
 
 
 
 
 
 | 346 |  |  |