current/DataAccess/Access_OniArchive.pas

unit Access_OniArchive;
interface

uses DataAccess, Classes;

type
{
  THeader = packed record
    Ident:      array[0..$13] of Byte;
    Files:      LongWord;
    NamedFiles: LongWord;
    Extensions: LongWord;
    DataAddr:   LongWord;
    DataSize:   LongWord;
    NamesAddr:  LongWord;
    NamesSize:  LongWord;
    Ident2:     array[0..$F] of Byte;
  end;
  TFilesMap = array of packed record
    Extension: array[0..$3] of Char;
    DataAddr:  LongWord;
    NameAddr:  LongWord;
    FileSize:  LongWord;
    FileType:  LongWord;
  end;

  TFileInfo = packed record
    ID:      Integer;
    FileName: String;
    FileNameHex: String;
    Extension: String[4];
    Name:    String;
    Size:    LongWord;
    FileType: LongWord;
    DatAddr: LongWord;
    opened:  Boolean;
  end;
  TFiles = array of TFileInfo;

  TNamedFilesMap = array of packed record
    FileNumber: LongWord;
    blubb:      LongWord;
  end;
  TExtensionsMap = array of packed record
    Ident:     array[0..$7] of Byte;
    Extension: array[0..$3] of Char;
    ExtCount:  LongWord;
  end;
}

  TAccess_OniArchive = class(TDataAccess)
  private
{    Fdat_file:     TFileStream;
    Fraw_file:     TFileStream;
    Fsep_file:     TFileStream;
    Fdat_header:   THeader;
    Fdat_filesmap: TFilesMap;
    Fdat_files:    TFiles;
    Fdat_namedfilesmap: TNamedFilesMap;
    Fdat_extensionsmap: TExtensionsMap;
    FUnloadWhenUnused: Boolean;
    FDatOpened:    Boolean;
    FRawOpened:    Boolean;
    FSepOpened:    Boolean;
  protected
  public
    property UnloadWhenUnused: Boolean Read FUnloadWhenUnused Write FUnloadWhenUnused;

    constructor Create(DatFilename: String; var Result: Boolean); override;
    procedure Close; override;

    function GetFileInfo(fileid: Integer): TFileInfo; override;
    function GetFilesList(ext: String; pattern: String;
      NoEmptyFiles: Boolean; sort: TSortType): TStringArray; override;
    function GetFilesCount: LongWord; override;
    function GetExtensionsList: TStringArray; override;
    function GetExtendedExtensionsList: TExtensionsMap; override;

    function LoadDatFile(fileid: LongWord): Tdata; override;
    procedure UpdateDatFile(fileid: LongWord; Data: Tdata); override;
    procedure LoadDatFilePart(fileid, offset, size: LongWord; target: Pointer); override;
    procedure UpdateDatFilePart(fileid, offset, size: LongWord; target: Pointer); override;

    procedure LoadRawOffset(loc_sep: Boolean; raw_addr, size: LongWord; target: Pointer);
    function GetRawList(fileid: LongWord): TRawList; override;
    procedure LoadRawFile(fileid, dat_offset: LongWord; target: Pointer); override;
    procedure UpdateRawFile(fileid, dat_offset: LongWord; size: LongWord;
      target: Pointer); override;
    procedure LoadRawFilePart(fileid, dat_offset: LongWord;
      offset, size: LongWord; target: Pointer); override;
    procedure UpdateRawFilePart(fileid, dat_offset: LongWord;
      offset, size: LongWord; target: Pointer); override;
    function AppendRawFile(loc_sep: Boolean; size: LongWord; target: Pointer): LongWord;
      override;//Returns new Address
  published
}  end;

implementation


(*
================================================================================
                      Implementation of  TOniDataDat
*)

{
constructor TOniDataDat.Create(DatFilename: String; var Result: Boolean);
const
  header_ident1_pc: array[0..$13] of Byte =
    ($1F, $27, $DC, $33, $DF, $BC, $03, $00, $31, $33, $52, $56, $40, $00,
    $14, $00, $10, $00, $08, $00);
  header_ident1_mac: array[0..$13] of Byte =
    ($61, $30, $C1, $23, $DF, $BC, $03, $00, $31, $33, $52, $56, $40, $00,
    $14, $00, $10, $00, $08, $00);
  header_ident1_macbeta: array[0..$13] of Byte =
    ($81, $11, $8D, $23, $DF, $BC, $03, $00, $31, $33, $52, $56, $40, $00,
    $14, $00, $10, $00, $08, $00);
  header_ident2: array[0..$F] of Byte =
    ($99, $CF, $40, $00, $90, $4F, $63, $00, $F4, $55, $5F, $00, $90, $4F, $63, $00);
var
  i: LongWord;
  header_pc, header_mac: Boolean;
begin
  FUnloadWhenUnused := True;
  FDatOpened := False;
  FRawOpened := False;
  if not FileExists(DatFilename) then
  begin
    ShowMessage('File doesn''t exist!!!');
    Result := False;
    Exit;
  end;
  FFileName := DatFilename;
  Fdat_file := TFileStream.Create(FFileName, fmOpenRead);
  Fdat_file.Read(Fdat_header, SizeOf(Fdat_header));
  header_pc  := True;
  header_mac := True;
  for i := 0 to High(Fdat_header.Ident) do
  begin
    FLevelInfo.Ident[i] := Fdat_header.Ident[i];
    if Fdat_header.Ident[i] <> header_ident1_pc[i] then
      header_pc := False;
    if Fdat_header.Ident[i] <> header_ident1_mac[i] then
      header_mac := False;
  end;
  if not (header_pc xor header_mac) then
  begin
    Result := False;
    Exit;
  end
  else
  begin
    if (header_pc and not header_mac) then
      Fos_mac := False
    else
      Fos_mac := True;
  end;
  SetLength(Fdat_filesmap, Fdat_header.Files);
  SetLength(Fdat_files, Fdat_header.Files);
  for i := 0 to Fdat_header.Files - 1 do
    Fdat_file.Read(Fdat_filesmap[i], SizeOf(Fdat_filesmap[i]));
  for i := 0 to Fdat_header.Files - 1 do
  begin
    Fdat_files[i].ID := i;
    Fdat_files[i].Extension := Fdat_filesmap[i].Extension;
    Fdat_files[i].Extension := ReverseString(Fdat_files[i].Extension);
    Fdat_files[i].Size      := Fdat_filesmap[i].FileSize;
    Fdat_files[i].FileType  := Fdat_filesmap[i].FileType;
    Fdat_files[i].DatAddr   := Fdat_filesmap[i].DataAddr - 8 + Fdat_header.DataAddr;
    if (Fdat_filesmap[i].FileType and $01) = 0 then
    begin
      Fdat_file.Seek(Fdat_filesmap[i].NameAddr + Fdat_header.NamesAddr, soFromBeginning);
      SetLength(Fdat_files[i].Name, 100);
      Fdat_file.Read(Fdat_files[i].Name[1], 100);
      Fdat_files[i].Name := MidStr(Fdat_files[i].Name, 1 + 4, Pos(
        #0, Fdat_files[i].Name) - 1 - 4);
    end
    else
    begin
      Fdat_files[i].Name := '';
    end;
    Fdat_files[i].FileName    :=
      FormatNumber(i, 5, '0') + '-' + Fdat_files[i].Name + '.' + Fdat_files[i].Extension;
    Fdat_files[i].FileNameHex :=
      IntToHex(i, 4) + '-' + Fdat_files[i].Name + '.' + Fdat_files[i].Extension;
  end;
  Fdat_file.Seek($40 + Fdat_header.Files * $14, soFromBeginning);
  SetLength(Fdat_namedfilesmap, Fdat_header.NamedFiles);
  for i := 0 to Fdat_header.NamedFiles - 1 do
    Fdat_file.Read(Fdat_namedfilesmap[i], SizeOf(Fdat_namedfilesmap[i]));

  Fdat_file.Seek($40 + Fdat_header.Files * $14 + Fdat_header.NamedFiles * $8, soFromBeginning);
  SetLength(Fdat_extensionsmap, Fdat_header.Extensions);
  for i := 0 to Fdat_header.Extensions - 1 do
    Fdat_file.Read(Fdat_extensionsmap[i], SizeOf(Fdat_extensionsmap[i]));

  Fdat_file.Seek(Fdat_files[0].DatAddr + 7, soFromBeginning);
  Fdat_file.Read(FLevelInfo.LevelNumber, 1);
  FLevelInfo.LevelNumber := FLevelInfo.LevelNumber div 2;

  Fdat_file.Free;

  Result   := True;
  FBackend := ODB_Dat;
end;


procedure TOniDataDat.Close;
begin
  if not FUnloadWhenUnused and FDatOpened then
    Fdat_file.Free;
  if not FUnloadWhenUnused and FRawOpened then
    Fraw_file.Free;
  if not FUnloadWhenUnused and FSepOpened then
    Fsep_file.Free;
  Self.Free;
end;


function TOniDataDat.GetFileInfo(fileid: Integer): TFileInfo;
begin
  if fileid = -1 then
  begin
    Result := inherited GetFileInfo(fileid);
    Exit;
  end;
  if fileid < Self.GetFilesCount then
    Result    := Fdat_files[fileid]
  else
    Result.ID := -1;
end;


function TOniDataDat.GetFilesList(ext: String; pattern: String;
  NoEmptyFiles: Boolean; sort: TSortType): TStringArray;
var
  i: LongWord;
  list: TStringList;
  id, name, extension: String;
  fields: TStrings;

  procedure getfields;
  begin
     fields.CommaText := StringReplace(AnsiQuotedStr(list.Strings[i], '"'), ';', '","', [rfReplaceAll]);
    if sort in [stIDAsc, stIDDesc] then
    begin
      id := fields.Strings[0];
      name := fields.Strings[1];
      extension := fields.Strings[2];
    end;
    if sort in [stNameAsc, stNameDesc] then
    begin
      id := fields.Strings[1];
      name := fields.Strings[0];
      extension := fields.Strings[2];
    end;
    if sort in [stExtAsc, stExtDesc] then
    begin
      id := fields.Strings[1];
      name := fields.Strings[2];
      extension := fields.Strings[0];
    end;
  end;

begin
  list := TStringList.Create;
  list.Sorted := True;
  for i := 0 to Fdat_header.Files - 1 do
  begin
    if ((Length(ext) = 0) or (Pos(Fdat_files[i].Extension, ext) > 0)) and
      ((Length(pattern) = 0) or
      (Pos(UpperCase(pattern), UpperCase(Fdat_files[i].Name)) > 0)) then
    begin
      if (NoEmptyFiles = False) or ((Fdat_files[i].FileType and $02) = 0) then
      begin
        if AppSettings.FilenumbersAsHex then
          id := IntToHex(Fdat_files[i].ID, 4)
        else
          id := FormatNumber(Fdat_files[i].ID, 5, '0');
        name := Fdat_files[i].Name;
        extension := Fdat_files[i].Extension;

        case sort of
          stIDAsc, stIDDesc:     list.Add(id + ';' + name + ';' + extension);
          stNameAsc, stNameDesc: list.Add(name + ';' + id + ';' + extension);
          stExtAsc, stExtDesc:   list.Add(extension + ';' + id + ';' + name);
        end;
      end;
    end;
  end;
  SetLength(Result, list.Count);
  if Length(Result) > 0 then
  begin
    fields := TStringList.Create;
    if sort in [stIDAsc, stNameAsc, stExtAsc] then
      for i := 0 to list.Count - 1 do
      begin
        getfields;
        Result[i] := id + '-' + name + '.' + extension;
      end
    else
      for i := list.Count - 1 downto 0 do
      begin
        getfields;
        Result[list.Count - i - 1] := id + '-' + name + '.' + extension;
      end;
    fields.Free;
  end;
  list.Free;
end;


function TOniDataDat.GetFilesCount: LongWord;
begin
  Result := Fdat_header.Files;
end;


function TOniDataDat.GetExtensionsList: TStringArray;
var
  i: LongWord;
begin
  SetLength(Result, Fdat_header.Extensions);
  for i := 0 to Fdat_header.Extensions - 1 do
  begin
    with Fdat_extensionsmap[i] do
    begin
      Result[i] := Extension[3] + Extension[2] + Extension[1] + Extension[0] +
        ' (' + IntToStr(ExtCount) + ')';
    end;
  end;
end;


function TOniDataDat.GetExtendedExtensionsList: TExtensionsMap;
var
  i: LongWord;
begin
  SetLength(Result, Fdat_header.Extensions);
  for i := 0 to Fdat_header.Extensions - 1 do
  begin
    Result[i] := Fdat_extensionsmap[i];
  end;
end;


function TOniDataDat.LoadDatFile(fileid: LongWord): Tdata;
begin
  if fileid < Self.GetFilesCount then
  begin
    if FUnloadWhenUnused or not FDatOpened then
      Fdat_file := TFileStream.Create(FFileName, fmOpenReadWrite);
    Fdat_file.Seek(Fdat_files[fileid].DatAddr, soFromBeginning);
    SetLength(Result, Fdat_files[fileid].Size);
    Fdat_file.Read(Result[0], Fdat_files[fileid].Size);
    if UnloadWhenUnused then
      Fdat_file.Free
    else
      FDatOpened := True;
  end;
end;


procedure TOniDataDat.UpdateDatFile(fileid: LongWord; Data: Tdata);
begin
  if fileid < Self.GetFilesCount then
  begin
    if FUnloadWhenUnused or not FDatOpened then
      Fdat_file := TFileStream.Create(FFileName, fmOpenReadWrite);
    Fdat_file.Seek(Fdat_files[fileid].DatAddr, soFromBeginning);
    Fdat_file.Write(Data[0], Length(Data));
    if UnloadWhenUnused then
      Fdat_file.Free
    else
      FDatOpened := True;
  end;
end;


procedure TOniDataDat.LoadDatFilePart(fileid, offset, size: LongWord; target: Pointer);
begin
  if fileid < Self.GetFilesCount then
  begin
    if FUnloadWhenUnused or not FDatOpened then
      Fdat_file := TFileStream.Create(FFileName, fmOpenReadWrite);
    Fdat_file.Seek(Fdat_files[fileid].DatAddr + offset, soFromBeginning);
    Fdat_file.Read(target^, size);
    if UnloadWhenUnused then
      Fdat_file.Free
    else
      FDatOpened := True;
  end;
end;


procedure TOniDataDat.UpdateDatFilePart(fileid, offset, size: LongWord; target: Pointer);
begin
  if fileid < Self.GetFilesCount then
  begin
    if FUnloadWhenUnused or not FDatOpened then
      Fdat_file := TFileStream.Create(FFileName, fmOpenReadWrite);
    Fdat_file.Seek(Fdat_files[fileid].DatAddr + offset, soFromBeginning);
    Fdat_file.Write(target^, size);
    if UnloadWhenUnused then
      Fdat_file.Free
    else
      FDatOpened := True;
  end;
end;


function TOniDataDat.GetRawList(fileid: LongWord): TRawList;
var
  i: LongWord;
begin
  SetLength(Result, 0);
  for i := 0 to High(RawListHandlers) do
    if UpperCase(RawListHandlers[i].Ext) = UpperCase(Fdat_files[fileid].extension) then
      if RawListHandlers[i].needed then
      begin
        Result := RawListHandlers[i].Handler(Self, fileid);
        Break;
      end
      else
        Break;
end;


procedure TOniDataDat.LoadRawOffset(loc_sep: Boolean; raw_addr, size: LongWord;
  target: Pointer);
begin
  if not loc_sep then
  begin
    if FUnloadWhenUnused or not FRawOpened then
      Fraw_file := TFileStream.Create(AnsiReplaceStr(FFileName, '.dat', '.raw'),
        fmOpenReadWrite);
    if raw_addr <= Fraw_file.Size then
    begin
      Fraw_file.Seek(raw_addr, soFromBeginning);
      Fraw_file.Read(target^, size);
    end;
    if UnloadWhenUnused then
      Fraw_file.Free
    else
      FRawOpened := True;
  end
  else
  begin
    if FUnloadWhenUnused or not FSepOpened then
      Fsep_file := TFileStream.Create(AnsiReplaceStr(FFileName, '.dat', '.sep'),
        fmOpenReadWrite);
    if raw_addr <= Fsep_file.Size then
    begin
      Fsep_file.Seek(raw_addr, soFromBeginning);
      Fsep_file.Read(target^, size);
    end;
    if UnloadWhenUnused then
      Fsep_file.Free
    else
      FSepOpened := True;
  end;
end;


procedure TOniDataDat.LoadRawFile(fileid, dat_offset: LongWord; target: Pointer);
var
  raw_info: TRawInfo;
begin
  if fileid < Self.GetFilesCount then
  begin
    raw_info := Self.GetRawInfo(fileid, dat_offset);
    if not raw_info.loc_sep then
    begin
      if FUnloadWhenUnused or not FRawOpened then
        Fraw_file := TFileStream.Create(AnsiReplaceStr(FFileName, '.dat', '.raw'),
          fmOpenReadWrite);
      Fraw_file.Seek(raw_info.raw_addr, soFromBeginning);
      Fraw_file.Read(target^, raw_info.raw_size);
      if UnloadWhenUnused then
        Fraw_file.Free
      else
        FRawOpened := True;
    end
    else
    begin
      if FUnloadWhenUnused or not FSepOpened then
        Fsep_file := TFileStream.Create(AnsiReplaceStr(FFileName, '.dat', '.sep'),
          fmOpenReadWrite);
      Fsep_file.Seek(raw_info.raw_addr, soFromBeginning);
      Fsep_file.Read(target^, raw_info.raw_size);
      if UnloadWhenUnused then
        Fsep_file.Free
      else
        FSepOpened := True;
    end;
  end;
end;


procedure TOniDataDat.UpdateRawFile(fileid, dat_offset: LongWord;
  size: LongWord; target: Pointer);
var
  raw_info: TRawInfo;
begin
  if fileid < Self.GetFilesCount then
  begin
    raw_info := Self.GetRawInfo(fileid, dat_offset);
    if not raw_info.loc_sep then
    begin
      if FUnloadWhenUnused or not FRawOpened then
        Fraw_file := TFileStream.Create(AnsiReplaceStr(FFileName, '.dat', '.raw'),
          fmOpenReadWrite);
      Fraw_file.Seek(raw_info.raw_addr, soFromBeginning);
      Fraw_file.Write(target^, raw_info.raw_size);
      if UnloadWhenUnused then
        Fraw_file.Free
      else
        FRawOpened := True;
    end
    else
    begin
      if FUnloadWhenUnused or not FSepOpened then
        Fsep_file := TFileStream.Create(AnsiReplaceStr(FFileName, '.dat', '.sep'),
          fmOpenReadWrite);
      Fsep_file.Seek(raw_info.raw_addr, soFromBeginning);
      Fsep_file.Write(target^, raw_info.raw_size);
      if UnloadWhenUnused then
        Fsep_file.Free
      else
        FSepOpened := True;
    end;
  end;
end;


procedure TOniDataDat.LoadRawFilePart(fileid, dat_offset: LongWord;
  offset, size: LongWord; target: Pointer);
var
  raw_info: TRawInfo;
  Data:     Tdata;
  mem:      TMemoryStream;
begin
  if fileid < Self.GetFilesCount then
  begin
    raw_info := Self.GetRawInfo(fileid, dat_offset);
    SetLength(Data, raw_info.raw_size);
    Self.LoadRawFile(fileid, dat_offset, @Data[0]);
    mem := TMemoryStream.Create;
    mem.Write(Data[offset], size);
    mem.Read(target^, size);
    mem.Free;
  end;
end;


procedure TOniDataDat.UpdateRawFilePart(fileid, dat_offset: LongWord;
  offset, size: LongWord; target: Pointer);
var
  raw_info: TRawInfo;
begin
  if fileid < Self.GetFilesCount then
  begin
    raw_info := Self.GetRawInfo(fileid, dat_offset);
    if not raw_info.loc_sep then
    begin
      if FUnloadWhenUnused or not FRawOpened then
        Fraw_file := TFileStream.Create(AnsiReplaceStr(FFileName, '.dat', '.raw'),
          fmOpenReadWrite);
      Fraw_file.Seek(raw_info.raw_addr + offset, soFromBeginning);
      Fraw_file.Write(target^, raw_info.raw_size);
      if UnloadWhenUnused then
        Fraw_file.Free
      else
        FRawOpened := True;
    end
    else
    begin
      if FUnloadWhenUnused or not FSepOpened then
        Fsep_file := TFileStream.Create(AnsiReplaceStr(FFileName, '.dat', '.sep'),
          fmOpenReadWrite);
      Fsep_file.Seek(raw_info.raw_addr + offset, soFromBeginning);
      Fsep_file.Write(target^, raw_info.raw_size);
      if UnloadWhenUnused then
        Fsep_file.Free
      else
        FSepOpened := True;
    end;
  end;
end;


function TOniDataDat.AppendRawFile(loc_sep: Boolean; size: LongWord;
  target: Pointer): LongWord; //Returns new Address
begin
  if not loc_sep then
  begin
    if FUnloadWhenUnused or not FRawOpened then
      Fraw_file := TFileStream.Create(AnsiReplaceStr(FFileName, '.dat', '.raw'),
        fmOpenReadWrite);
    Result := Fraw_file.Size;
    Fraw_file.Seek(0, soFromEnd);
    Fraw_file.Write(target^, size);
    if UnloadWhenUnused then
      Fraw_file.Free
    else
      FRawOpened := True;
  end
  else
  begin
    if FUnloadWhenUnused or not FSepOpened then
      Fsep_file := TFileStream.Create(AnsiReplaceStr(FFileName, '.dat', '.sep'),
        fmOpenReadWrite);
    Result := Fsep_file.Size;
    Fsep_file.Seek(0, soFromEnd);
    Fsep_file.Write(target^, size);
    if UnloadWhenUnused then
      Fsep_file.Free
    else
      FSepOpened := True;
  end;
end;


}


end.
Revision:	93
Committed:	Thu Jan 18 17:15:59 2007 UTC (18 years, 8 months ago) by alloc
Content type:	text/x-pascal
Original Path:	*oup/rewrite/DataAccess/Access_OniArchive.pas*
File size:	18858 byte(s)
Log Message:
#	Content
1	unit Access_OniArchive;
2	interface
3
4	uses DataAccess, Classes;
5
6	type
7	{
8	THeader = packed record
9	Ident: array[0..$13] of Byte;
10	Files: LongWord;
11	NamedFiles: LongWord;
12	Extensions: LongWord;
13	DataAddr: LongWord;
14	DataSize: LongWord;
15	NamesAddr: LongWord;
16	NamesSize: LongWord;
17	Ident2: array[0..$F] of Byte;
18	end;
19	TFilesMap = array of packed record
20	Extension: array[0..$3] of Char;
21	DataAddr: LongWord;
22	NameAddr: LongWord;
23	FileSize: LongWord;
24	FileType: LongWord;
25	end;
26
27	TFileInfo = packed record
28	ID: Integer;
29	FileName: String;
30	FileNameHex: String;
31	Extension: String[4];
32	Name: String;
33	Size: LongWord;
34	FileType: LongWord;
35	DatAddr: LongWord;
36	opened: Boolean;
37	end;
38	TFiles = array of TFileInfo;
39
40	TNamedFilesMap = array of packed record
41	FileNumber: LongWord;
42	blubb: LongWord;
43	end;
44	TExtensionsMap = array of packed record
45	Ident: array[0..$7] of Byte;
46	Extension: array[0..$3] of Char;
47	ExtCount: LongWord;
48	end;
49	}
50
51	TAccess_OniArchive = class(TDataAccess)
52	private
53	{ Fdat_file: TFileStream;
54	Fraw_file: TFileStream;
55	Fsep_file: TFileStream;
56	Fdat_header: THeader;
57	Fdat_filesmap: TFilesMap;
58	Fdat_files: TFiles;
59	Fdat_namedfilesmap: TNamedFilesMap;
60	Fdat_extensionsmap: TExtensionsMap;
61	FUnloadWhenUnused: Boolean;
62	FDatOpened: Boolean;
63	FRawOpened: Boolean;
64	FSepOpened: Boolean;
65	protected
66	public
67	property UnloadWhenUnused: Boolean Read FUnloadWhenUnused Write FUnloadWhenUnused;
68
69	constructor Create(DatFilename: String; var Result: Boolean); override;
70	procedure Close; override;
71
72	function GetFileInfo(fileid: Integer): TFileInfo; override;
73	function GetFilesList(ext: String; pattern: String;
74	NoEmptyFiles: Boolean; sort: TSortType): TStringArray; override;
75	function GetFilesCount: LongWord; override;
76	function GetExtensionsList: TStringArray; override;
77	function GetExtendedExtensionsList: TExtensionsMap; override;
78
79	function LoadDatFile(fileid: LongWord): Tdata; override;
80	procedure UpdateDatFile(fileid: LongWord; Data: Tdata); override;
81	procedure LoadDatFilePart(fileid, offset, size: LongWord; target: Pointer); override;
82	procedure UpdateDatFilePart(fileid, offset, size: LongWord; target: Pointer); override;
83
84	procedure LoadRawOffset(loc_sep: Boolean; raw_addr, size: LongWord; target: Pointer);
85	function GetRawList(fileid: LongWord): TRawList; override;
86	procedure LoadRawFile(fileid, dat_offset: LongWord; target: Pointer); override;
87	procedure UpdateRawFile(fileid, dat_offset: LongWord; size: LongWord;
88	target: Pointer); override;
89	procedure LoadRawFilePart(fileid, dat_offset: LongWord;
90	offset, size: LongWord; target: Pointer); override;
91	procedure UpdateRawFilePart(fileid, dat_offset: LongWord;
92	offset, size: LongWord; target: Pointer); override;
93	function AppendRawFile(loc_sep: Boolean; size: LongWord; target: Pointer): LongWord;
94	override;//Returns new Address
95	published
96	} end;
97
98	implementation
99
100
101	(*
102	================================================================================
103	Implementation of TOniDataDat
104	*)
105
106	{
107	constructor TOniDataDat.Create(DatFilename: String; var Result: Boolean);
108	const
109	header_ident1_pc: array[0..$13] of Byte =
110	($1F, $27, $DC, $33, $DF, $BC, $03, $00, $31, $33, $52, $56, $40, $00,
111	$14, $00, $10, $00, $08, $00);
112	header_ident1_mac: array[0..$13] of Byte =
113	($61, $30, $C1, $23, $DF, $BC, $03, $00, $31, $33, $52, $56, $40, $00,
114	$14, $00, $10, $00, $08, $00);
115	header_ident1_macbeta: array[0..$13] of Byte =
116	($81, $11, $8D, $23, $DF, $BC, $03, $00, $31, $33, $52, $56, $40, $00,
117	$14, $00, $10, $00, $08, $00);
118	header_ident2: array[0..$F] of Byte =
119	($99, $CF, $40, $00, $90, $4F, $63, $00, $F4, $55, $5F, $00, $90, $4F, $63, $00);
120	var
121	i: LongWord;
122	header_pc, header_mac: Boolean;
123	begin
124	FUnloadWhenUnused := True;
125	FDatOpened := False;
126	FRawOpened := False;
127	if not FileExists(DatFilename) then
128	begin
129	ShowMessage('File doesn''t exist!!!');
130	Result := False;
131	Exit;
132	end;
133	FFileName := DatFilename;
134	Fdat_file := TFileStream.Create(FFileName, fmOpenRead);
135	Fdat_file.Read(Fdat_header, SizeOf(Fdat_header));
136	header_pc := True;
137	header_mac := True;
138	for i := 0 to High(Fdat_header.Ident) do
139	begin
140	FLevelInfo.Ident[i] := Fdat_header.Ident[i];
141	if Fdat_header.Ident[i] <> header_ident1_pc[i] then
142	header_pc := False;
143	if Fdat_header.Ident[i] <> header_ident1_mac[i] then
144	header_mac := False;
145	end;
146	if not (header_pc xor header_mac) then
147	begin
148	Result := False;
149	Exit;
150	end
151	else
152	begin
153	if (header_pc and not header_mac) then
154	Fos_mac := False
155	else
156	Fos_mac := True;
157	end;
158	SetLength(Fdat_filesmap, Fdat_header.Files);
159	SetLength(Fdat_files, Fdat_header.Files);
160	for i := 0 to Fdat_header.Files - 1 do
161	Fdat_file.Read(Fdat_filesmap[i], SizeOf(Fdat_filesmap[i]));
162	for i := 0 to Fdat_header.Files - 1 do
163	begin
164	Fdat_files[i].ID := i;
165	Fdat_files[i].Extension := Fdat_filesmap[i].Extension;
166	Fdat_files[i].Extension := ReverseString(Fdat_files[i].Extension);
167	Fdat_files[i].Size := Fdat_filesmap[i].FileSize;
168	Fdat_files[i].FileType := Fdat_filesmap[i].FileType;
169	Fdat_files[i].DatAddr := Fdat_filesmap[i].DataAddr - 8 + Fdat_header.DataAddr;
170	if (Fdat_filesmap[i].FileType and $01) = 0 then
171	begin
172	Fdat_file.Seek(Fdat_filesmap[i].NameAddr + Fdat_header.NamesAddr, soFromBeginning);
173	SetLength(Fdat_files[i].Name, 100);
174	Fdat_file.Read(Fdat_files[i].Name[1], 100);
175	Fdat_files[i].Name := MidStr(Fdat_files[i].Name, 1 + 4, Pos(
176	#0, Fdat_files[i].Name) - 1 - 4);
177	end
178	else
179	begin
180	Fdat_files[i].Name := '';
181	end;
182	Fdat_files[i].FileName :=
183	FormatNumber(i, 5, '0') + '-' + Fdat_files[i].Name + '.' + Fdat_files[i].Extension;
184	Fdat_files[i].FileNameHex :=
185	IntToHex(i, 4) + '-' + Fdat_files[i].Name + '.' + Fdat_files[i].Extension;
186	end;
187	Fdat_file.Seek($40 + Fdat_header.Files * $14, soFromBeginning);
188	SetLength(Fdat_namedfilesmap, Fdat_header.NamedFiles);
189	for i := 0 to Fdat_header.NamedFiles - 1 do
190	Fdat_file.Read(Fdat_namedfilesmap[i], SizeOf(Fdat_namedfilesmap[i]));
191
192	Fdat_file.Seek($40 + Fdat_header.Files * $14 + Fdat_header.NamedFiles * $8, soFromBeginning);
193	SetLength(Fdat_extensionsmap, Fdat_header.Extensions);
194	for i := 0 to Fdat_header.Extensions - 1 do
195	Fdat_file.Read(Fdat_extensionsmap[i], SizeOf(Fdat_extensionsmap[i]));
196
197	Fdat_file.Seek(Fdat_files[0].DatAddr + 7, soFromBeginning);
198	Fdat_file.Read(FLevelInfo.LevelNumber, 1);
199	FLevelInfo.LevelNumber := FLevelInfo.LevelNumber div 2;
200
201	Fdat_file.Free;
202
203	Result := True;
204	FBackend := ODB_Dat;
205	end;
206
207
208
209
210	procedure TOniDataDat.Close;
211	begin
212	if not FUnloadWhenUnused and FDatOpened then
213	Fdat_file.Free;
214	if not FUnloadWhenUnused and FRawOpened then
215	Fraw_file.Free;
216	if not FUnloadWhenUnused and FSepOpened then
217	Fsep_file.Free;
218	Self.Free;
219	end;
220
221
222
223
224	function TOniDataDat.GetFileInfo(fileid: Integer): TFileInfo;
225	begin
226	if fileid = -1 then
227	begin
228	Result := inherited GetFileInfo(fileid);
229	Exit;
230	end;
231	if fileid < Self.GetFilesCount then
232	Result := Fdat_files[fileid]
233	else
234	Result.ID := -1;
235	end;
236
237
238
239
240	function TOniDataDat.GetFilesList(ext: String; pattern: String;
241	NoEmptyFiles: Boolean; sort: TSortType): TStringArray;
242	var
243	i: LongWord;
244	list: TStringList;
245	id, name, extension: String;
246	fields: TStrings;
247
248	procedure getfields;
249	begin
250	fields.CommaText := StringReplace(AnsiQuotedStr(list.Strings[i], '"'), ';', '","', [rfReplaceAll]);
251	if sort in [stIDAsc, stIDDesc] then
252	begin
253	id := fields.Strings[0];
254	name := fields.Strings[1];
255	extension := fields.Strings[2];
256	end;
257	if sort in [stNameAsc, stNameDesc] then
258	begin
259	id := fields.Strings[1];
260	name := fields.Strings[0];
261	extension := fields.Strings[2];
262	end;
263	if sort in [stExtAsc, stExtDesc] then
264	begin
265	id := fields.Strings[1];
266	name := fields.Strings[2];
267	extension := fields.Strings[0];
268	end;
269	end;
270
271	begin
272	list := TStringList.Create;
273	list.Sorted := True;
274	for i := 0 to Fdat_header.Files - 1 do
275	begin
276	if ((Length(ext) = 0) or (Pos(Fdat_files[i].Extension, ext) > 0)) and
277	((Length(pattern) = 0) or
278	(Pos(UpperCase(pattern), UpperCase(Fdat_files[i].Name)) > 0)) then
279	begin
280	if (NoEmptyFiles = False) or ((Fdat_files[i].FileType and $02) = 0) then
281	begin
282	if AppSettings.FilenumbersAsHex then
283	id := IntToHex(Fdat_files[i].ID, 4)
284	else
285	id := FormatNumber(Fdat_files[i].ID, 5, '0');
286	name := Fdat_files[i].Name;
287	extension := Fdat_files[i].Extension;
288
289	case sort of
290	stIDAsc, stIDDesc: list.Add(id + ';' + name + ';' + extension);
291	stNameAsc, stNameDesc: list.Add(name + ';' + id + ';' + extension);
292	stExtAsc, stExtDesc: list.Add(extension + ';' + id + ';' + name);
293	end;
294	end;
295	end;
296	end;
297	SetLength(Result, list.Count);
298	if Length(Result) > 0 then
299	begin
300	fields := TStringList.Create;
301	if sort in [stIDAsc, stNameAsc, stExtAsc] then
302	for i := 0 to list.Count - 1 do
303	begin
304	getfields;
305	Result[i] := id + '-' + name + '.' + extension;
306	end
307	else
308	for i := list.Count - 1 downto 0 do
309	begin
310	getfields;
311	Result[list.Count - i - 1] := id + '-' + name + '.' + extension;
312	end;
313	fields.Free;
314	end;
315	list.Free;
316	end;
317
318
319
320
321	function TOniDataDat.GetFilesCount: LongWord;
322	begin
323	Result := Fdat_header.Files;
324	end;
325
326
327
328
329	function TOniDataDat.GetExtensionsList: TStringArray;
330	var
331	i: LongWord;
332	begin
333	SetLength(Result, Fdat_header.Extensions);
334	for i := 0 to Fdat_header.Extensions - 1 do
335	begin
336	with Fdat_extensionsmap[i] do
337	begin
338	Result[i] := Extension[3] + Extension[2] + Extension[1] + Extension[0] +
339	' (' + IntToStr(ExtCount) + ')';
340	end;
341	end;
342	end;
343
344
345
346
347	function TOniDataDat.GetExtendedExtensionsList: TExtensionsMap;
348	var
349	i: LongWord;
350	begin
351	SetLength(Result, Fdat_header.Extensions);
352	for i := 0 to Fdat_header.Extensions - 1 do
353	begin
354	Result[i] := Fdat_extensionsmap[i];
355	end;
356	end;
357
358
359
360
361	function TOniDataDat.LoadDatFile(fileid: LongWord): Tdata;
362	begin
363	if fileid < Self.GetFilesCount then
364	begin
365	if FUnloadWhenUnused or not FDatOpened then
366	Fdat_file := TFileStream.Create(FFileName, fmOpenReadWrite);
367	Fdat_file.Seek(Fdat_files[fileid].DatAddr, soFromBeginning);
368	SetLength(Result, Fdat_files[fileid].Size);
369	Fdat_file.Read(Result[0], Fdat_files[fileid].Size);
370	if UnloadWhenUnused then
371	Fdat_file.Free
372	else
373	FDatOpened := True;
374	end;
375	end;
376
377
378
379
380	procedure TOniDataDat.UpdateDatFile(fileid: LongWord; Data: Tdata);
381	begin
382	if fileid < Self.GetFilesCount then
383	begin
384	if FUnloadWhenUnused or not FDatOpened then
385	Fdat_file := TFileStream.Create(FFileName, fmOpenReadWrite);
386	Fdat_file.Seek(Fdat_files[fileid].DatAddr, soFromBeginning);
387	Fdat_file.Write(Data[0], Length(Data));
388	if UnloadWhenUnused then
389	Fdat_file.Free
390	else
391	FDatOpened := True;
392	end;
393	end;
394
395
396
397
398	procedure TOniDataDat.LoadDatFilePart(fileid, offset, size: LongWord; target: Pointer);
399	begin
400	if fileid < Self.GetFilesCount then
401	begin
402	if FUnloadWhenUnused or not FDatOpened then
403	Fdat_file := TFileStream.Create(FFileName, fmOpenReadWrite);
404	Fdat_file.Seek(Fdat_files[fileid].DatAddr + offset, soFromBeginning);
405	Fdat_file.Read(target^, size);
406	if UnloadWhenUnused then
407	Fdat_file.Free
408	else
409	FDatOpened := True;
410	end;
411	end;
412
413
414
415
416	procedure TOniDataDat.UpdateDatFilePart(fileid, offset, size: LongWord; target: Pointer);
417	begin
418	if fileid < Self.GetFilesCount then
419	begin
420	if FUnloadWhenUnused or not FDatOpened then
421	Fdat_file := TFileStream.Create(FFileName, fmOpenReadWrite);
422	Fdat_file.Seek(Fdat_files[fileid].DatAddr + offset, soFromBeginning);
423	Fdat_file.Write(target^, size);
424	if UnloadWhenUnused then
425	Fdat_file.Free
426	else
427	FDatOpened := True;
428	end;
429	end;
430
431
432
433
434	function TOniDataDat.GetRawList(fileid: LongWord): TRawList;
435	var
436	i: LongWord;
437	begin
438	SetLength(Result, 0);
439	for i := 0 to High(RawListHandlers) do
440	if UpperCase(RawListHandlers[i].Ext) = UpperCase(Fdat_files[fileid].extension) then
441	if RawListHandlers[i].needed then
442	begin
443	Result := RawListHandlers[i].Handler(Self, fileid);
444	Break;
445	end
446	else
447	Break;
448	end;
449
450
451
452
453	procedure TOniDataDat.LoadRawOffset(loc_sep: Boolean; raw_addr, size: LongWord;
454	target: Pointer);
455	begin
456	if not loc_sep then
457	begin
458	if FUnloadWhenUnused or not FRawOpened then
459	Fraw_file := TFileStream.Create(AnsiReplaceStr(FFileName, '.dat', '.raw'),
460	fmOpenReadWrite);
461	if raw_addr <= Fraw_file.Size then
462	begin
463	Fraw_file.Seek(raw_addr, soFromBeginning);
464	Fraw_file.Read(target^, size);
465	end;
466	if UnloadWhenUnused then
467	Fraw_file.Free
468	else
469	FRawOpened := True;
470	end
471	else
472	begin
473	if FUnloadWhenUnused or not FSepOpened then
474	Fsep_file := TFileStream.Create(AnsiReplaceStr(FFileName, '.dat', '.sep'),
475	fmOpenReadWrite);
476	if raw_addr <= Fsep_file.Size then
477	begin
478	Fsep_file.Seek(raw_addr, soFromBeginning);
479	Fsep_file.Read(target^, size);
480	end;
481	if UnloadWhenUnused then
482	Fsep_file.Free
483	else
484	FSepOpened := True;
485	end;
486	end;
487
488
489
490
491	procedure TOniDataDat.LoadRawFile(fileid, dat_offset: LongWord; target: Pointer);
492	var
493	raw_info: TRawInfo;
494	begin
495	if fileid < Self.GetFilesCount then
496	begin
497	raw_info := Self.GetRawInfo(fileid, dat_offset);
498	if not raw_info.loc_sep then
499	begin
500	if FUnloadWhenUnused or not FRawOpened then
501	Fraw_file := TFileStream.Create(AnsiReplaceStr(FFileName, '.dat', '.raw'),
502	fmOpenReadWrite);
503	Fraw_file.Seek(raw_info.raw_addr, soFromBeginning);
504	Fraw_file.Read(target^, raw_info.raw_size);
505	if UnloadWhenUnused then
506	Fraw_file.Free
507	else
508	FRawOpened := True;
509	end
510	else
511	begin
512	if FUnloadWhenUnused or not FSepOpened then
513	Fsep_file := TFileStream.Create(AnsiReplaceStr(FFileName, '.dat', '.sep'),
514	fmOpenReadWrite);
515	Fsep_file.Seek(raw_info.raw_addr, soFromBeginning);
516	Fsep_file.Read(target^, raw_info.raw_size);
517	if UnloadWhenUnused then
518	Fsep_file.Free
519	else
520	FSepOpened := True;
521	end;
522	end;
523	end;
524
525
526
527
528	procedure TOniDataDat.UpdateRawFile(fileid, dat_offset: LongWord;
529	size: LongWord; target: Pointer);
530	var
531	raw_info: TRawInfo;
532	begin
533	if fileid < Self.GetFilesCount then
534	begin
535	raw_info := Self.GetRawInfo(fileid, dat_offset);
536	if not raw_info.loc_sep then
537	begin
538	if FUnloadWhenUnused or not FRawOpened then
539	Fraw_file := TFileStream.Create(AnsiReplaceStr(FFileName, '.dat', '.raw'),
540	fmOpenReadWrite);
541	Fraw_file.Seek(raw_info.raw_addr, soFromBeginning);
542	Fraw_file.Write(target^, raw_info.raw_size);
543	if UnloadWhenUnused then
544	Fraw_file.Free
545	else
546	FRawOpened := True;
547	end
548	else
549	begin
550	if FUnloadWhenUnused or not FSepOpened then
551	Fsep_file := TFileStream.Create(AnsiReplaceStr(FFileName, '.dat', '.sep'),
552	fmOpenReadWrite);
553	Fsep_file.Seek(raw_info.raw_addr, soFromBeginning);
554	Fsep_file.Write(target^, raw_info.raw_size);
555	if UnloadWhenUnused then
556	Fsep_file.Free
557	else
558	FSepOpened := True;
559	end;
560	end;
561	end;
562
563
564
565
566	procedure TOniDataDat.LoadRawFilePart(fileid, dat_offset: LongWord;
567	offset, size: LongWord; target: Pointer);
568	var
569	raw_info: TRawInfo;
570	Data: Tdata;
571	mem: TMemoryStream;
572	begin
573	if fileid < Self.GetFilesCount then
574	begin
575	raw_info := Self.GetRawInfo(fileid, dat_offset);
576	SetLength(Data, raw_info.raw_size);
577	Self.LoadRawFile(fileid, dat_offset, @Data[0]);
578	mem := TMemoryStream.Create;
579	mem.Write(Data[offset], size);
580	mem.Read(target^, size);
581	mem.Free;
582	end;
583	end;
584
585
586
587
588	procedure TOniDataDat.UpdateRawFilePart(fileid, dat_offset: LongWord;
589	offset, size: LongWord; target: Pointer);
590	var
591	raw_info: TRawInfo;
592	begin
593	if fileid < Self.GetFilesCount then
594	begin
595	raw_info := Self.GetRawInfo(fileid, dat_offset);
596	if not raw_info.loc_sep then
597	begin
598	if FUnloadWhenUnused or not FRawOpened then
599	Fraw_file := TFileStream.Create(AnsiReplaceStr(FFileName, '.dat', '.raw'),
600	fmOpenReadWrite);
601	Fraw_file.Seek(raw_info.raw_addr + offset, soFromBeginning);
602	Fraw_file.Write(target^, raw_info.raw_size);
603	if UnloadWhenUnused then
604	Fraw_file.Free
605	else
606	FRawOpened := True;
607	end
608	else
609	begin
610	if FUnloadWhenUnused or not FSepOpened then
611	Fsep_file := TFileStream.Create(AnsiReplaceStr(FFileName, '.dat', '.sep'),
612	fmOpenReadWrite);
613	Fsep_file.Seek(raw_info.raw_addr + offset, soFromBeginning);
614	Fsep_file.Write(target^, raw_info.raw_size);
615	if UnloadWhenUnused then
616	Fsep_file.Free
617	else
618	FSepOpened := True;
619	end;
620	end;
621	end;
622
623
624
625
626	function TOniDataDat.AppendRawFile(loc_sep: Boolean; size: LongWord;
627	target: Pointer): LongWord; //Returns new Address
628	begin
629	if not loc_sep then
630	begin
631	if FUnloadWhenUnused or not FRawOpened then
632	Fraw_file := TFileStream.Create(AnsiReplaceStr(FFileName, '.dat', '.raw'),
633	fmOpenReadWrite);
634	Result := Fraw_file.Size;
635	Fraw_file.Seek(0, soFromEnd);
636	Fraw_file.Write(target^, size);
637	if UnloadWhenUnused then
638	Fraw_file.Free
639	else
640	FRawOpened := True;
641	end
642	else
643	begin
644	if FUnloadWhenUnused or not FSepOpened then
645	Fsep_file := TFileStream.Create(AnsiReplaceStr(FFileName, '.dat', '.sep'),
646	fmOpenReadWrite);
647	Result := Fsep_file.Size;
648	Fsep_file.Seek(0, soFromEnd);
649	Fsep_file.Write(target^, size);
650	if UnloadWhenUnused then
651	Fsep_file.Free
652	else
653	FSepOpened := True;
654	end;
655	end;
656
657
658	}
659
660
661
662
663	end.