unit uHCAnnexHelpers;

{$ifdef FPC}
{$mode objfpc}{H+}
{$endif}
{$ASSERTIONS ON}
{$POINTERMATH ON}

interface

uses
  Classes, uHCDefines, uHCTypeDefs, uHCAnnexDefs;

type

  { IHCBSStringsHelper }
  IHCBSStringsHelper = interface
    ['{4A34429D-734E-434D-835E-4655C934AD73}']
    // ALE 20210207 utility functions
    // ALE 20210207 convert incoming BSSTRINGS to current structure format
  end;

  { THCBSStringsHelper }
  THCBSStringsHelper = class(TInterfacedObject, IHCBSStringsHelper)
  private
    fPAnnexData: PHCAnnexes_disk;
    fPHCannex_id_to_disk_id: THCannex_id_to_disk_id;
    fVerInterface: LongWord;
    fVerSaveGame: LongWord;
  public
    constructor Create(
      pPAnnexData: PHCAnnexes_disk;
      pPHCannex_id_to_disk_id: THCannex_id_to_disk_id;
      pVerInterface: LongWord;
      pVerSaveGame: LongWord);
    destructor Destroy; override;
    // ALE 20160520 Utility functions
    //function HCAnnexShift(pAnnexID: ID): NativeInt;
    //function HCIsDisk(pAnnexID: ID): Boolean;
    //function HCdisk_id_to_annex_offset(pAnnexID: ID): NativeInt;
    // ALE 20160520 Pull out annex data for a particular platform
  end;

  { IHCAnnexHelper }

  IHCAnnexHelper = interface
    ['{0A3F6AB0-CECB-4BA6-92A6-87B3C70BFB85}']
    // ALE 20160520 Utility functions
    function HCAnnexShift(pAnnexID: ID): NativeInt;
    function HCIsDisk(pAnnexID: ID): Boolean;
    function HCdisk_id_to_annex_offset(pAnnexID: ID): NativeInt;
    // ALE 20160520 Pull out annex data for a particular platform
    function HCGetAnnexA1(pAnnexID: ID): PHCAnnexA1_disk;
    function HCGetAnnexA2(pAnnexID: ID): PHCAnnexA2_disk;
    function HCGetAnnexB1(pAnnexID: ID): PHCAnnexB1_disk;
    function HCGetAnnexC1(pAnnexID: ID): PHCAnnexC1_disk;
    function HCGetAnnexD1(pAnnexID: ID): PHCAnnexD1_disk;
    function HCGetAnnexE1(pAnnexID: ID): PHCAnnexE1_disk;
    function HCGetAnnexF1(pAnnexID: ID): PHCAnnexF1_disk;
    function HCGetAnnexG1(pAnnexID: ID): PHCAnnexG1_disk;
    function HCGetAnnexG2(pAnnexID: ID): PHCAnnexG2_disk;
    function HCGetAnnexI1(pAnnexID: ID): PHCAnnexI1_disk;
    function HCGetAnnexJ1(pAnnexID: ID): PHCAnnexJ1_disk;
    function HCGetAnnexM1(pAnnexID: ID): PHCAnnexM1_disk;
    function HCGetAnnexP1(pAnnexID: ID): PHCAnnexP1_disk;
    function HCGetAnnexY1(pAnnexID: ID): PHCAnnexY1_disk;
    function HCGetAnnexZ1(pAnnexID: ID): PHCAnnexZ1_disk;
    function HCGetAnnexZ2(pAnnexID: ID): PHCAnnexZ2_disk;
   end;

  { THCAnnexHelper }

  THCAnnexHelper = class(TInterfacedObject, IHCAnnexHelper)
  private
    fPAnnexData: PHCAnnexes_disk;
    fPHCannex_id_to_disk_id: THCannex_id_to_disk_id;
    fVerInterface: LongWord;
    fVerSaveGame: LongWord;
  public
    constructor Create(
      pPAnnexData: PHCAnnexes_disk;
      pPHCannex_id_to_disk_id: THCannex_id_to_disk_id;
      pVerInterface: LongWord;
      pVerSaveGame: LongWord);
    destructor Destroy; override;
    // ALE 20160520 Utility functions
    function HCAnnexShift(pAnnexID: ID): NativeInt;
    function HCIsDisk(pAnnexID: ID): Boolean;
    function HCdisk_id_to_annex_offset(pAnnexID: ID): NativeInt;
    // ALE 20160520 Pull out annex data for a particular platform
    function HCGetAnnexA1(pAnnexID: ID): PHCAnnexA1_disk;
    function HCGetAnnexA2(pAnnexID: ID): PHCAnnexA2_disk;
    function HCGetAnnexB1(pAnnexID: ID): PHCAnnexB1_disk;
    function HCGetAnnexC1(pAnnexID: ID): PHCAnnexC1_disk;
    function HCGetAnnexD1(pAnnexID: ID): PHCAnnexD1_disk;
    function HCGetAnnexE1(pAnnexID: ID): PHCAnnexE1_disk;
    function HCGetAnnexF1(pAnnexID: ID): PHCAnnexF1_disk;
    function HCGetAnnexG1(pAnnexID: ID): PHCAnnexG1_disk;
    function HCGetAnnexG2(pAnnexID: ID): PHCAnnexG2_disk;
    function HCGetAnnexI1(pAnnexID: ID): PHCAnnexI1_disk;
    function HCGetAnnexJ1(pAnnexID: ID): PHCAnnexJ1_disk;
    function HCGetAnnexM1(pAnnexID: ID): PHCAnnexM1_disk;
    function HCGetAnnexP1(pAnnexID: ID): PHCAnnexP1_disk;
    function HCGetAnnexY1(pAnnexID: ID): PHCAnnexY1_disk;
    function HCGetAnnexZ1(pAnnexID: ID): PHCAnnexZ1_disk;
    function HCGetAnnexZ2(pAnnexID: ID): PHCAnnexZ2_disk;
 end;

 { IHCAnnexMemHelper }

  IHCAnnexMemHelper = interface
    ['{FFD8FFD0-5939-4196-A803-FED9744975DE}']
    // ALE 20160520 Utility functions
    function HCAnnexShift(pAnnexID: ID): NativeInt;
    function HCIsDisk(pAnnexID: ID): Boolean;
    function HCdisk_id_to_annex_offset(pAnnexID: ID): NativeInt;
    // ALE 20160520 Pull out annex data for a particular platform
    function HCGetAnnexMemA1(pAnnexID: ID): PHCAnnexA1_mem;
    function HCGetAnnexMemA2(pAnnexID: ID): PHCAnnexA2_mem;
    function HCGetAnnexMemB1(pAnnexID: ID): PHCAnnexB1_mem;
    function HCGetAnnexMemC1(pAnnexID: ID): PHCAnnexC1_mem;
    function HCGetAnnexMemD1(pAnnexID: ID): PHCAnnexD1_mem;
    function HCGetAnnexMemE1(pAnnexID: ID): PHCAnnexE1_mem;
    function HCGetAnnexMemF1(pAnnexID: ID): PHCAnnexF1_mem;
    function HCGetAnnexMemG1(pAnnexID: ID): PHCAnnexG1_mem;
    function HCGetAnnexMemG2(pAnnexID: ID): PHCAnnexG2_mem;
    function HCGetAnnexMemI1(pAnnexID: ID): PHCAnnexI1_mem;
    function HCGetAnnexMemJ1(pAnnexID: ID): PHCAnnexJ1_mem;
    function HCGetAnnexMemM1(pAnnexID: ID): PHCAnnexM1_mem;
    function HCGetAnnexMemP1(pAnnexID: ID): PHCAnnexP1_mem;
    function HCGetAnnexMemY1(pAnnexID: ID): PHCAnnexY1_mem;
    function HCGetAnnexMemZ1(pAnnexID: ID): PHCAnnexZ1_mem;
    function HCGetAnnexMemZ2(pAnnexID: ID): PHCAnnexZ2_mem;
  end;

  { THCAnnexMemHelper }

  THCAnnexMemHelper = class(TInterfacedObject, IHCAnnexMemHelper)
  private
    fPAnnexData: PHCAnnexes_mem;
    fPHCannex_id_to_disk_id: THCannex_id_to_disk_id;
  public
    constructor Create(
      pPAnnexData: PHCAnnexes_mem;
      pPHCannex_id_to_disk_id: THCannex_id_to_disk_id
      // ALE 20250221 only for 2025.006+ so don't need this compatibility
      //  pVerInterface: LongWord;
      //  pVerSaveGame: LongWord
      );
    destructor Destroy; override;
    // ALE 20160520 Utility functions
    function HCAnnexShift(pAnnexID: ID): NativeInt;
    function HCIsDisk(pAnnexID: ID): Boolean;
    function HCdisk_id_to_annex_offset(pAnnexID: ID): NativeInt;
    // ALE 20160520 Pull out annex data for a particular platform
    function HCGetAnnexMemA1(pAnnexID: ID): PHCAnnexA1_mem;
    function HCGetAnnexMemA2(pAnnexID: ID): PHCAnnexA2_mem;
    function HCGetAnnexMemB1(pAnnexID: ID): PHCAnnexB1_mem;
    function HCGetAnnexMemC1(pAnnexID: ID): PHCAnnexC1_mem;
    function HCGetAnnexMemD1(pAnnexID: ID): PHCAnnexD1_mem;
    function HCGetAnnexMemE1(pAnnexID: ID): PHCAnnexE1_mem;
    function HCGetAnnexMemF1(pAnnexID: ID): PHCAnnexF1_mem;
    function HCGetAnnexMemG1(pAnnexID: ID): PHCAnnexG1_mem;
    function HCGetAnnexMemG2(pAnnexID: ID): PHCAnnexG2_mem;
    function HCGetAnnexMemI1(pAnnexID: ID): PHCAnnexI1_mem;
    function HCGetAnnexMemJ1(pAnnexID: ID): PHCAnnexJ1_mem;
    function HCGetAnnexMemM1(pAnnexID: ID): PHCAnnexM1_mem;
    function HCGetAnnexMemP1(pAnnexID: ID): PHCAnnexP1_mem;
    function HCGetAnnexMemY1(pAnnexID: ID): PHCAnnexY1_mem;
    function HCGetAnnexMemZ1(pAnnexID: ID): PHCAnnexZ1_mem;
    function HCGetAnnexMemZ2(pAnnexID: ID): PHCAnnexZ2_mem;
  end;

function HCAnnexShift(pAnnexID: ID): ushort; deprecated 'Use IHCAnnexHelper.HCAnnexShift instead';
function HCIsDisk(pAnnexID: ID): Boolean; deprecated 'Use IHCAnnexHelper.HCAnnexShift instead';
function HCdisk_id_to_annex_offset(pAnnexID: ID; pPAnnexData: PHCAnnexes_disk): NativeInt; deprecated 'Use IHCAnnexHelper.HCdisk_id_to_annex_offset instead';
function HCGetAnnexA1(pAnnexID: ID; pPAnnexData: PHCAnnexes_disk; verInterface: LongWord; verSaveGame: LongWord; pPHCannex_id_to_disk_id: THCannex_id_to_disk_id): PHCAnnexA1_disk; overload; deprecated 'Use IHCAnnexHelper.HCGetAnnexA1 instead';
function HCGetAnnexA1(pAnnexID: ID; pPAnnexData: PHCAnnexes_disk): PHCAnnexA1_disk; overload; deprecated 'Use IHCAnnexHelper.HCGetAnnexA1 instead';
function HCGetAnnexA1(pAnnexID: ID; pPAnnexData: PHCAnnexes_disk; pPHCannex_id_to_disk_id: THCannex_id_to_disk_id): PHCAnnexA1_disk; overload; deprecated 'Use IHCAnnexHelper.HCGetAnnexA1 instead';
function HCGetAnnexA2(pAnnexID: ID; pPAnnexData: PHCAnnexes_disk; verSaveGame: LongWord): PHCAnnexA2_disk; overload; deprecated 'Use IHCAnnexHelper.HCGetAnnexA2 instead';
function HCGetAnnexA2(pAnnexID: ID; pPAnnexData: PHCAnnexes_disk): PHCAnnexA2_disk; overload; deprecated 'Use IHCAnnexHelper.HCGetAnnexA2 instead';
function HCGetAnnexA2(pAnnexID: ID; pPAnnexData: PHCAnnexes_disk; pPHCannex_id_to_disk_id: THCannex_id_to_disk_id): PHCAnnexA2_disk; overload; deprecated 'Use IHCAnnexHelper.HCGetAnnexA2 instead';
function HCGetAnnexB1(pAnnexID: ID; pPAnnexData: PHCAnnexes_disk; verSaveGame: LongWord): PHCAnnexB1_disk; overload; deprecated 'Use IHCAnnexHelper.HCGetAnnexB1 instead';
function HCGetAnnexB1(pAnnexID: ID; pPAnnexData: PHCAnnexes_disk): PHCAnnexB1_disk; overload; deprecated 'Use IHCAnnexHelper.HCGetAnnexB1 instead';
function HCGetAnnexB1(pAnnexID: ID; pPAnnexData: PHCAnnexes_disk; pPHCannex_id_to_disk_id: THCannex_id_to_disk_id): PHCAnnexB1_disk; overload; deprecated 'Use IHCAnnexHelper.HCGetAnnexB1 instead';
function HCGetAnnexC1(pAnnexID: ID; pPAnnexData: PHCAnnexes_disk; verSaveGame: LongWord): PHCAnnexC1_disk; overload; deprecated 'Use IHCAnnexHelper.HCGetAnnexC1 instead';
function HCGetAnnexC1(pAnnexID: ID; pPAnnexData: PHCAnnexes_disk): PHCAnnexC1_disk; overload; deprecated 'Use IHCAnnexHelper.HCGetAnnexC1 instead';
function HCGetAnnexC1(pAnnexID: ID; pPAnnexData: PHCAnnexes_disk; pPHCannex_id_to_disk_id: THCannex_id_to_disk_id): PHCAnnexC1_disk; overload; deprecated 'Use IHCAnnexHelper.HCGetAnnexC1 instead';
function HCGetAnnexD1(pAnnexID: ID; pPAnnexData: PHCAnnexes_disk; verSaveGame: LongWord): PHCAnnexD1_disk; overload; deprecated 'Use IHCAnnexHelper.HCGetAnnexD1 instead';
function HCGetAnnexD1(pAnnexID: ID; pPAnnexData: PHCAnnexes_disk): PHCAnnexD1_disk; overload; deprecated 'Use IHCAnnexHelper.HCGetAnnexD1 instead';
function HCGetAnnexD1(pAnnexID: ID; pPAnnexData: PHCAnnexes_disk; pPHCannex_id_to_disk_id: THCannex_id_to_disk_id): PHCAnnexD1_disk; overload; deprecated 'Use IHCAnnexHelper.HCGetAnnexD1 instead';
function HCGetAnnexE1(pAnnexID: ID; pPAnnexData: PHCAnnexes_disk; verSaveGame: LongWord): PHCAnnexE1_disk; overload; deprecated 'Use IHCAnnexHelper.HCGetAnnexE1 instead';
function HCGetAnnexE1(pAnnexID: ID; pPAnnexData: PHCAnnexes_disk): PHCAnnexE1_disk; overload; deprecated 'Use IHCAnnexHelper.HCGetAnnexE1 instead';
function HCGetAnnexE1(pAnnexID: ID; pPAnnexData: PHCAnnexes_disk; pPHCannex_id_to_disk_id: THCannex_id_to_disk_id): PHCAnnexE1_disk; overload; deprecated 'Use IHCAnnexHelper.HCGetAnnexE1 instead';
function HCGetAnnexF1(pAnnexID: ID; pPAnnexData: PHCAnnexes_disk; verSaveGame: LongWord): PHCAnnexF1_disk; overload; deprecated 'Use IHCAnnexHelper.HCGetAnnexF1 instead';
function HCGetAnnexF1(pAnnexID: ID; pPAnnexData: PHCAnnexes_disk): PHCAnnexF1_disk; overload; deprecated 'Use IHCAnnexHelper.HCGetAnnexF1 instead';
function HCGetAnnexF1(pAnnexID: ID; pPAnnexData: PHCAnnexes_disk; pPHCannex_id_to_disk_id: THCannex_id_to_disk_id): PHCAnnexF1_disk; overload; deprecated 'Use IHCAnnexHelper.HCGetAnnexF1 instead';
function HCGetAnnexG1(pAnnexID: ID; pPAnnexData: PHCAnnexes_disk; verSaveGame: LongWord): PHCAnnexG1_disk; overload; deprecated 'Use IHCAnnexHelper.HCGetAnnexG1 instead';
function HCGetAnnexG1(pAnnexID: ID; pPAnnexData: PHCAnnexes_disk): PHCAnnexG1_disk; overload; deprecated 'Use IHCAnnexHelper.HCGetAnnexG1 instead';
function HCGetAnnexG1(pAnnexID: ID; pPAnnexData: PHCAnnexes_disk; pPHCannex_id_to_disk_id: THCannex_id_to_disk_id): PHCAnnexG1_disk; overload; deprecated 'Use IHCAnnexHelper.HCGetAnnexG1 instead';
function HCGetAnnexG2(pAnnexID: ID; pPAnnexData: PHCAnnexes_disk; verSaveGame: LongWord): PHCAnnexG2_disk; overload; deprecated 'Use IHCAnnexHelper.HCGetAnnexG2 instead';
function HCGetAnnexG2(pAnnexID: ID; pPAnnexData: PHCAnnexes_disk): PHCAnnexG2_disk; overload; deprecated 'Use IHCAnnexHelper.HCGetAnnexG2 instead';
function HCGetAnnexG2(pAnnexID: ID; pPAnnexData: PHCAnnexes_disk; pPHCannex_id_to_disk_id: THCannex_id_to_disk_id): PHCAnnexG2_disk; overload; deprecated 'Use IHCAnnexHelper.HCGetAnnexG2 instead';
function HCGetAnnexI1(pAnnexID: ID; pPAnnexData: PHCAnnexes_disk; verSaveGame: LongWord): PHCAnnexI1_disk; overload; deprecated 'Use IHCAnnexHelper.HCGetAnnexI1 instead';
function HCGetAnnexI1(pAnnexID: ID; pPAnnexData: PHCAnnexes_disk): PHCAnnexI1_disk; overload; deprecated 'Use IHCAnnexHelper.HCGetAnnexI1 instead';
function HCGetAnnexI1(pAnnexID: ID; pPAnnexData: PHCAnnexes_disk; pPHCannex_id_to_disk_id: THCannex_id_to_disk_id): PHCAnnexI1_disk; overload; deprecated 'Use IHCAnnexHelper.HCGetAnnexI1 instead';
function HCGetAnnexJ1(pAnnexID: ID; pPAnnexData: PHCAnnexes_disk; verSaveGame: LongWord): PHCAnnexJ1_disk; overload; deprecated 'Use IHCAnnexHelper.HCGetAnnexJ1 instead';
function HCGetAnnexJ1(pAnnexID: ID; pPAnnexData: PHCAnnexes_disk): PHCAnnexJ1_disk; overload; deprecated 'Use IHCAnnexHelper.HCGetAnnexJ1 instead';
function HCGetAnnexJ1(pAnnexID: ID; pPAnnexData: PHCAnnexes_disk; pPHCannex_id_to_disk_id: THCannex_id_to_disk_id): PHCAnnexJ1_disk; overload; deprecated 'Use IHCAnnexHelper.HCGetAnnexJ1 instead';
function HCGetAnnexM1(pAnnexID: ID; pPAnnexData: PHCAnnexes_disk; verSaveGame: LongWord): PHCAnnexM1_disk; overload; deprecated 'Use IHCAnnexHelper.HCGetAnnexM1 instead';
function HCGetAnnexM1(pAnnexID: ID; pPAnnexData: PHCAnnexes_disk): PHCAnnexM1_disk; overload; deprecated 'Use IHCAnnexHelper.HCGetAnnexM1 instead';
function HCGetAnnexM1(pAnnexID: ID; pPAnnexData: PHCAnnexes_disk; pPHCannex_id_to_disk_id: THCannex_id_to_disk_id): PHCAnnexM1_disk; overload; deprecated 'Use IHCAnnexHelper.HCGetAnnexM1 instead';
function HCGetAnnexP1(pAnnexID: ID; pPAnnexData: PHCAnnexes_disk; verSaveGame: LongWord): PHCAnnexP1_disk; overload; deprecated 'Use IHCAnnexHelper.HCGetAnnexP1 instead';
function HCGetAnnexP1(pAnnexID: ID; pPAnnexData: PHCAnnexes_disk): PHCAnnexP1_disk; overload; deprecated 'Use IHCAnnexHelper.HCGetAnnexP1 instead';
function HCGetAnnexP1(pAnnexID: ID; pPAnnexData: PHCAnnexes_disk; pPHCannex_id_to_disk_id: THCannex_id_to_disk_id): PHCAnnexP1_disk; overload; deprecated 'Use IHCAnnexHelper.HCGetAnnexP1 instead';
function HCGetAnnexY1(pAnnexID: ID; pPAnnexData: PHCAnnexes_disk; verSaveGame: LongWord): PHCAnnexY1_disk; overload; deprecated 'Use IHCAnnexHelper.HCGetAnnexY1 instead';
function HCGetAnnexY1(pAnnexID: ID; pPAnnexData: PHCAnnexes_disk): PHCAnnexY1_disk; overload; deprecated 'Use IHCAnnexHelper.HCGetAnnexY1 instead';
function HCGetAnnexY1(pAnnexID: ID; pPAnnexData: PHCAnnexes_disk; pPHCannex_id_to_disk_id: THCannex_id_to_disk_id): PHCAnnexY1_disk; overload; deprecated 'Use IHCAnnexHelper.HCGetAnnexY1 instead';
function HCGetAnnexZ1(pAnnexID: ID; pPAnnexData: PHCAnnexes_disk; verSaveGame: LongWord): PHCAnnexZ1_disk; overload; deprecated 'Use IHCAnnexHelper.HCGetAnnexZ1 instead';
function HCGetAnnexZ1(pAnnexID: ID; pPAnnexData: PHCAnnexes_disk): PHCAnnexZ1_disk; overload; deprecated 'Use IHCAnnexHelper.HCGetAnnexZ1 instead';
function HCGetAnnexZ1(pAnnexID: ID; pPAnnexData: PHCAnnexes_disk; pPHCannex_id_to_disk_id: THCannex_id_to_disk_id): PHCAnnexZ1_disk; overload; deprecated 'Use IHCAnnexHelper.HCGetAnnexZ1 instead';
function HCGetAnnexZ2(pAnnexID: ID; pPAnnexData: PHCAnnexes_disk; verSaveGame: LongWord): PHCAnnexZ2_disk; overload; deprecated 'Use IHCAnnexHelper.HCGetAnnexZ2 instead';
function HCGetAnnexZ2(pAnnexID: ID; pPAnnexData: PHCAnnexes_disk): PHCAnnexZ2_disk; overload; deprecated 'Use IHCAnnexHelper.HCGetAnnexZ2 instead';
function HCGetAnnexZ2(pAnnexID: ID; pPAnnexData: PHCAnnexes_disk; pPHCannex_id_to_disk_id: THCannex_id_to_disk_id): PHCAnnexZ2_disk; overload; deprecated 'Use IHCAnnexHelper.HCGetAnnexZ2 instead';

implementation


{*** Take a Annex ID and spit back the associated annex flag ***
 ***  ex. HCAnnexShift(2047) = SHIP_FLAG                     ***}
function HCAnnexShift(pAnnexID: ID): ushort;
var
  HCAnnexHelper: IHCAnnexHelper;
begin
  HCAnnexHelper := THCAnnexHelper.Create(nil, nil, 0, 0);
  result := HCAnnexHelper.HCAnnexShift(pAnnexID);
end;

{*** Is this a disk id or a memory/annex id?       ***}
{***  IS_DISK(annex_id)     ((annex_id) & 0x0800)  ***}
function HCIsDisk(pAnnexID: ID): Boolean;
var
  HCAnnexHelper: IHCAnnexHelper;
begin
  HCAnnexHelper := THCAnnexHelper.Create(nil, nil, 0, 0);
  result := HCAnnexHelper.HCIsDisk(pAnnexID);
end;

// ALE 20151002 Pull back the index into the listing of disk records
//  i.e. 2048 = 0 before moving to 4096 items/annex
function HCdisk_id_to_annex_offset(pAnnexID: ID; pPAnnexData: PHCAnnexes_disk): NativeInt;
var
  HCAnnexHelper: IHCAnnexHelper;
begin
  HCAnnexHelper := THCAnnexHelper.Create(pPAnnexData, nil, 0, 0);
  result := HCAnnexHelper.HCdisk_id_to_annex_offset(pAnnexID);
end;

{*** Return a disk annex structure when fed an AnnexID ***}
function HCGetAnnexA1(pAnnexID: ID; pPAnnexData: PHCAnnexes_disk; verInterface: LongWord; verSaveGame: LongWord; pPHCannex_id_to_disk_id: THCannex_id_to_disk_id): PHCAnnexA1_disk;
var
  HCAnnexHelper: IHCAnnexHelper;
begin
  HCAnnexHelper := THCAnnexHelper.Create(pPAnnexData, pPHCannex_id_to_disk_id, verInterface, verSaveGame);
  result := HCAnnexHelper.HCGetAnnexA1(pAnnexID);
end;

function HCGetAnnexA1(pAnnexID: ID; pPAnnexData: PHCAnnexes_disk): PHCAnnexA1_disk;
var
  HCAnnexHelper: IHCAnnexHelper;
begin
  HCAnnexHelper := THCAnnexHelper.Create(pPAnnexData, nil, 0, 0);
  result := HCAnnexHelper.HCGetAnnexA1(pAnnexID);
end;

function HCGetAnnexA1(pAnnexID: ID; pPAnnexData: PHCAnnexes_disk; pPHCannex_id_to_disk_id: THCannex_id_to_disk_id): PHCAnnexA1_disk;
var
  HCAnnexHelper: IHCAnnexHelper;
begin
  HCAnnexHelper := THCAnnexHelper.Create(pPAnnexData, pPHCannex_id_to_disk_id, 0, 0);
  result := HCAnnexHelper.HCGetAnnexA1(pAnnexID);
end;

function HCGetAnnexA2(pAnnexID: ID; pPAnnexData: PHCAnnexes_disk; verSaveGame: LongWord): PHCAnnexA2_disk;
var
  HCAnnexHelper: IHCAnnexHelper;
begin
  HCAnnexHelper := THCAnnexHelper.Create(pPAnnexData, nil, 0, verSaveGame);
  result := HCAnnexHelper.HCGetAnnexA2(pAnnexID);
end;

function HCGetAnnexA2(pAnnexID: ID; pPAnnexData: PHCAnnexes_disk): PHCAnnexA2_disk;
var
  HCAnnexHelper: IHCAnnexHelper;
begin
  HCAnnexHelper := THCAnnexHelper.Create(pPAnnexData, nil, 0, 0);
  result := HCAnnexHelper.HCGetAnnexA2(pAnnexID);
end;

function HCGetAnnexA2(pAnnexID: ID; pPAnnexData: PHCAnnexes_disk; pPHCannex_id_to_disk_id: THCannex_id_to_disk_id): PHCAnnexA2_disk;
var
  HCAnnexHelper: IHCAnnexHelper;
begin
  HCAnnexHelper := THCAnnexHelper.Create(pPAnnexData, pPHCannex_id_to_disk_id, 0, 0);
  result := HCAnnexHelper.HCGetAnnexA2(pAnnexID);
end;

function HCGetAnnexB1(pAnnexID: ID; pPAnnexData: PHCAnnexes_disk; verSaveGame: LongWord): PHCAnnexB1_disk;
var
  HCAnnexHelper: IHCAnnexHelper;
begin
  HCAnnexHelper := THCAnnexHelper.Create(pPAnnexData, nil, 0, verSaveGame);
  result := HCAnnexHelper.HCGetAnnexB1(pAnnexID);
end;

function HCGetAnnexB1(pAnnexID: ID; pPAnnexData: PHCAnnexes_disk): PHCAnnexB1_disk;
var
  HCAnnexHelper: IHCAnnexHelper;
begin
  HCAnnexHelper := THCAnnexHelper.Create(pPAnnexData, nil, 0, 0);
  result := HCAnnexHelper.HCGetAnnexB1(pAnnexID);
end;

function HCGetAnnexB1(pAnnexID: ID; pPAnnexData: PHCAnnexes_disk; pPHCannex_id_to_disk_id: THCannex_id_to_disk_id): PHCAnnexB1_disk;
var
  HCAnnexHelper: IHCAnnexHelper;
begin
  HCAnnexHelper := THCAnnexHelper.Create(pPAnnexData, pPHCannex_id_to_disk_id, 0, 0);
  result := HCAnnexHelper.HCGetAnnexB1(pAnnexID);
end;

function HCGetAnnexC1(pAnnexID: ID; pPAnnexData: PHCAnnexes_disk; verSaveGame: LongWord): PHCAnnexC1_disk;
var
  HCAnnexHelper: IHCAnnexHelper;
begin
  HCAnnexHelper := THCAnnexHelper.Create(pPAnnexData, nil, 0, verSaveGame);
  result := HCAnnexHelper.HCGetAnnexC1(pAnnexID);
end;

function HCGetAnnexC1(pAnnexID: ID; pPAnnexData: PHCAnnexes_disk): PHCAnnexC1_disk;
var
  HCAnnexHelper: IHCAnnexHelper;
begin
  HCAnnexHelper := THCAnnexHelper.Create(pPAnnexData, nil, 0, 0);
  result := HCAnnexHelper.HCGetAnnexC1(pAnnexID);
end;

function HCGetAnnexC1(pAnnexID: ID; pPAnnexData: PHCAnnexes_disk; pPHCannex_id_to_disk_id: THCannex_id_to_disk_id): PHCAnnexC1_disk;
var
  HCAnnexHelper: IHCAnnexHelper;
begin
  HCAnnexHelper := THCAnnexHelper.Create(pPAnnexData, pPHCannex_id_to_disk_id, 0, 0);
  result := HCAnnexHelper.HCGetAnnexC1(pAnnexID);
end;

function HCGetAnnexD1(pAnnexID: ID; pPAnnexData: PHCAnnexes_disk; verSaveGame: LongWord): PHCAnnexD1_disk;
var
  HCAnnexHelper: IHCAnnexHelper;
begin
  HCAnnexHelper := THCAnnexHelper.Create(pPAnnexData, nil, 0, verSaveGame);
  result := HCAnnexHelper.HCGetAnnexD1(pAnnexID);
end;

function HCGetAnnexD1(pAnnexID: ID; pPAnnexData: PHCAnnexes_disk): PHCAnnexD1_disk;
var
  HCAnnexHelper: IHCAnnexHelper;
begin
  HCAnnexHelper := THCAnnexHelper.Create(pPAnnexData, nil, 0, 0);
  result := HCAnnexHelper.HCGetAnnexD1(pAnnexID);
end;

function HCGetAnnexD1(pAnnexID: ID; pPAnnexData: PHCAnnexes_disk; pPHCannex_id_to_disk_id: THCannex_id_to_disk_id): PHCAnnexD1_disk;
var
  HCAnnexHelper: IHCAnnexHelper;
begin
  HCAnnexHelper := THCAnnexHelper.Create(pPAnnexData, pPHCannex_id_to_disk_id, 0, 0);
  result := HCAnnexHelper.HCGetAnnexD1(pAnnexID);
end;

function HCGetAnnexE1(pAnnexID: ID; pPAnnexData: PHCAnnexes_disk; verSaveGame: LongWord): PHCAnnexE1_disk;
var
  HCAnnexHelper: IHCAnnexHelper;
begin
  HCAnnexHelper := THCAnnexHelper.Create(pPAnnexData, nil, 0, verSaveGame);
  result := HCAnnexHelper.HCGetAnnexE1(pAnnexID);
end;

function HCGetAnnexE1(pAnnexID: ID; pPAnnexData: PHCAnnexes_disk): PHCAnnexE1_disk;
var
  HCAnnexHelper: IHCAnnexHelper;
begin
  HCAnnexHelper := THCAnnexHelper.Create(pPAnnexData, nil, 0, 0);
  result := HCAnnexHelper.HCGetAnnexE1(pAnnexID);
end;

function HCGetAnnexE1(pAnnexID: ID; pPAnnexData: PHCAnnexes_disk; pPHCannex_id_to_disk_id: THCannex_id_to_disk_id): PHCAnnexE1_disk;
var
  HCAnnexHelper: IHCAnnexHelper;
begin
  HCAnnexHelper := THCAnnexHelper.Create(pPAnnexData, pPHCannex_id_to_disk_id, 0, 0);
  result := HCAnnexHelper.HCGetAnnexE1(pAnnexID);
end;

function HCGetAnnexF1(pAnnexID: ID; pPAnnexData: PHCAnnexes_disk; verSaveGame: LongWord): PHCAnnexF1_disk;
var
  HCAnnexHelper: IHCAnnexHelper;
begin
  HCAnnexHelper := THCAnnexHelper.Create(pPAnnexData, nil, 0, verSaveGame);
  result := HCAnnexHelper.HCGetAnnexF1(pAnnexID);
end;

function HCGetAnnexF1(pAnnexID: ID; pPAnnexData: PHCAnnexes_disk): PHCAnnexF1_disk;
var
  HCAnnexHelper: IHCAnnexHelper;
begin
  HCAnnexHelper := THCAnnexHelper.Create(pPAnnexData, nil, 0, 0);
  result := HCAnnexHelper.HCGetAnnexF1(pAnnexID);
end;

function HCGetAnnexF1(pAnnexID: ID; pPAnnexData: PHCAnnexes_disk; pPHCannex_id_to_disk_id: THCannex_id_to_disk_id): PHCAnnexF1_disk;
var
  HCAnnexHelper: IHCAnnexHelper;
begin
  HCAnnexHelper := THCAnnexHelper.Create(pPAnnexData, pPHCannex_id_to_disk_id, 0, 0);
  result := HCAnnexHelper.HCGetAnnexF1(pAnnexID);
end;

function HCGetAnnexG1(pAnnexID: ID; pPAnnexData: PHCAnnexes_disk; verSaveGame: LongWord): PHCAnnexG1_disk;
var
  HCAnnexHelper: IHCAnnexHelper;
begin
  HCAnnexHelper := THCAnnexHelper.Create(pPAnnexData, nil, 0, verSaveGame);
  result := HCAnnexHelper.HCGetAnnexG1(pAnnexID);
end;

function HCGetAnnexG1(pAnnexID: ID; pPAnnexData: PHCAnnexes_disk): PHCAnnexG1_disk;
var
  HCAnnexHelper: IHCAnnexHelper;
begin
  HCAnnexHelper := THCAnnexHelper.Create(pPAnnexData, nil, 0, 0);
  result := HCAnnexHelper.HCGetAnnexG1(pAnnexID);
end;

function HCGetAnnexG1(pAnnexID: ID; pPAnnexData: PHCAnnexes_disk; pPHCannex_id_to_disk_id: THCannex_id_to_disk_id): PHCAnnexG1_disk;
var
  HCAnnexHelper: IHCAnnexHelper;
begin
  HCAnnexHelper := THCAnnexHelper.Create(pPAnnexData, pPHCannex_id_to_disk_id, 0, 0);
  result := HCAnnexHelper.HCGetAnnexG1(pAnnexID);
end;

function HCGetAnnexG2(pAnnexID: ID; pPAnnexData: PHCAnnexes_disk; verSaveGame: LongWord): PHCAnnexG2_disk;
var
  HCAnnexHelper: IHCAnnexHelper;
begin
  HCAnnexHelper := THCAnnexHelper.Create(pPAnnexData, nil, 0, verSaveGame);
  result := HCAnnexHelper.HCGetAnnexG2(pAnnexID);
end;

function HCGetAnnexG2(pAnnexID: ID; pPAnnexData: PHCAnnexes_disk): PHCAnnexG2_disk;
var
  HCAnnexHelper: IHCAnnexHelper;
begin
  HCAnnexHelper := THCAnnexHelper.Create(pPAnnexData, nil, 0, 0);
  result := HCAnnexHelper.HCGetAnnexG2(pAnnexID);
end;

function HCGetAnnexG2(pAnnexID: ID; pPAnnexData: PHCAnnexes_disk; pPHCannex_id_to_disk_id: THCannex_id_to_disk_id): PHCAnnexG2_disk;
var
  HCAnnexHelper: IHCAnnexHelper;
begin
  HCAnnexHelper := THCAnnexHelper.Create(pPAnnexData, pPHCannex_id_to_disk_id, 0, 0);
  result := HCAnnexHelper.HCGetAnnexG2(pAnnexID);
end;

function HCGetAnnexI1(pAnnexID: ID; pPAnnexData: PHCAnnexes_disk; verSaveGame: LongWord): PHCAnnexI1_disk;
var
  HCAnnexHelper: IHCAnnexHelper;
begin
  HCAnnexHelper := THCAnnexHelper.Create(pPAnnexData, nil, 0, verSaveGame);
  result := HCAnnexHelper.HCGetAnnexI1(pAnnexID);
end;

function HCGetAnnexI1(pAnnexID: ID; pPAnnexData: PHCAnnexes_disk): PHCAnnexI1_disk;
var
  HCAnnexHelper: IHCAnnexHelper;
begin
  HCAnnexHelper := THCAnnexHelper.Create(pPAnnexData, nil, 0, 0);
  result := HCAnnexHelper.HCGetAnnexI1(pAnnexID);
end;

function HCGetAnnexI1(pAnnexID: ID; pPAnnexData: PHCAnnexes_disk; pPHCannex_id_to_disk_id: THCannex_id_to_disk_id): PHCAnnexI1_disk;
var
  HCAnnexHelper: IHCAnnexHelper;
begin
  HCAnnexHelper := THCAnnexHelper.Create(pPAnnexData, pPHCannex_id_to_disk_id, 0, 0);
  result := HCAnnexHelper.HCGetAnnexI1(pAnnexID);
end;

function HCGetAnnexJ1(pAnnexID: ID; pPAnnexData: PHCAnnexes_disk; verSaveGame: LongWord): PHCAnnexJ1_disk;
var
  HCAnnexHelper: IHCAnnexHelper;
begin
  HCAnnexHelper := THCAnnexHelper.Create(pPAnnexData, nil, 0, verSaveGame);
  result := HCAnnexHelper.HCGetAnnexJ1(pAnnexID);
end;

function HCGetAnnexJ1(pAnnexID: ID; pPAnnexData: PHCAnnexes_disk): PHCAnnexJ1_disk;
var
  HCAnnexHelper: IHCAnnexHelper;
begin
  HCAnnexHelper := THCAnnexHelper.Create(pPAnnexData, nil, 0, 0);
  result := HCAnnexHelper.HCGetAnnexJ1(pAnnexID);
end;

function HCGetAnnexJ1(pAnnexID: ID; pPAnnexData: PHCAnnexes_disk; pPHCannex_id_to_disk_id: THCannex_id_to_disk_id): PHCAnnexJ1_disk;
var
  HCAnnexHelper: IHCAnnexHelper;
begin
  HCAnnexHelper := THCAnnexHelper.Create(pPAnnexData, pPHCannex_id_to_disk_id, 0, 0);
  result := HCAnnexHelper.HCGetAnnexJ1(pAnnexID);
end;

function HCGetAnnexM1(pAnnexID: ID; pPAnnexData: PHCAnnexes_disk; verSaveGame: LongWord): PHCAnnexM1_disk;
var
  HCAnnexHelper: IHCAnnexHelper;
begin
  HCAnnexHelper := THCAnnexHelper.Create(pPAnnexData, nil, 0, verSaveGame);
  result := HCAnnexHelper.HCGetAnnexM1(pAnnexID);
end;

function HCGetAnnexM1(pAnnexID: ID; pPAnnexData: PHCAnnexes_disk): PHCAnnexM1_disk;
var
  HCAnnexHelper: IHCAnnexHelper;
begin
  HCAnnexHelper := THCAnnexHelper.Create(pPAnnexData, nil, 0, 0);
  result := HCAnnexHelper.HCGetAnnexM1(pAnnexID);
end;

function HCGetAnnexM1(pAnnexID: ID; pPAnnexData: PHCAnnexes_disk; pPHCannex_id_to_disk_id: THCannex_id_to_disk_id): PHCAnnexM1_disk;
var
  HCAnnexHelper: IHCAnnexHelper;
begin
  HCAnnexHelper := THCAnnexHelper.Create(pPAnnexData, pPHCannex_id_to_disk_id, 0, 0);
  result := HCAnnexHelper.HCGetAnnexM1(pAnnexID);
end;

function HCGetAnnexP1(pAnnexID: ID; pPAnnexData: PHCAnnexes_disk; verSaveGame: LongWord): PHCAnnexP1_disk;
var
  HCAnnexHelper: IHCAnnexHelper;
begin
  HCAnnexHelper := THCAnnexHelper.Create(pPAnnexData, nil, 0, verSaveGame);
  result := HCAnnexHelper.HCGetAnnexP1(pAnnexID);
end;

function HCGetAnnexP1(pAnnexID: ID; pPAnnexData: PHCAnnexes_disk): PHCAnnexP1_disk;
var
  HCAnnexHelper: IHCAnnexHelper;
begin
  HCAnnexHelper := THCAnnexHelper.Create(pPAnnexData, nil, 0, 0);
  result := HCAnnexHelper.HCGetAnnexP1(pAnnexID);
end;

function HCGetAnnexP1(pAnnexID: ID; pPAnnexData: PHCAnnexes_disk; pPHCannex_id_to_disk_id: THCannex_id_to_disk_id): PHCAnnexP1_disk;
var
  HCAnnexHelper: IHCAnnexHelper;
begin
  HCAnnexHelper := THCAnnexHelper.Create(pPAnnexData, pPHCannex_id_to_disk_id, 0, 0);
  result := HCAnnexHelper.HCGetAnnexP1(pAnnexID);
end;

function HCGetAnnexY1(pAnnexID: ID; pPAnnexData: PHCAnnexes_disk; verSaveGame: LongWord): PHCAnnexY1_disk;
var
  HCAnnexHelper: IHCAnnexHelper;
begin
  HCAnnexHelper := THCAnnexHelper.Create(pPAnnexData, nil, 0, verSaveGame);
  result := HCAnnexHelper.HCGetAnnexY1(pAnnexID);
end;

function HCGetAnnexY1(pAnnexID: ID; pPAnnexData: PHCAnnexes_disk): PHCAnnexY1_disk;
var
  HCAnnexHelper: IHCAnnexHelper;
begin
  HCAnnexHelper := THCAnnexHelper.Create(pPAnnexData, nil, 0, 0);
  result := HCAnnexHelper.HCGetAnnexY1(pAnnexID);
end;

function HCGetAnnexY1(pAnnexID: ID; pPAnnexData: PHCAnnexes_disk; pPHCannex_id_to_disk_id: THCannex_id_to_disk_id): PHCAnnexY1_disk;
var
  HCAnnexHelper: IHCAnnexHelper;
begin
  HCAnnexHelper := THCAnnexHelper.Create(pPAnnexData, pPHCannex_id_to_disk_id, 0, 0);
  result := HCAnnexHelper.HCGetAnnexY1(pAnnexID);
end;

function HCGetAnnexZ1(pAnnexID: ID; pPAnnexData: PHCAnnexes_disk; verSaveGame: LongWord): PHCAnnexZ1_disk;
var
  HCAnnexHelper: IHCAnnexHelper;
begin
  HCAnnexHelper := THCAnnexHelper.Create(pPAnnexData, nil, 0, verSaveGame);
  result := HCAnnexHelper.HCGetAnnexZ1(pAnnexID);
end;

function HCGetAnnexZ1(pAnnexID: ID; pPAnnexData: PHCAnnexes_disk): PHCAnnexZ1_disk;
var
  HCAnnexHelper: IHCAnnexHelper;
begin
  HCAnnexHelper := THCAnnexHelper.Create(pPAnnexData, nil, 0, 0);
  result := HCAnnexHelper.HCGetAnnexZ1(pAnnexID);
end;

function HCGetAnnexZ1(pAnnexID: ID; pPAnnexData: PHCAnnexes_disk; pPHCannex_id_to_disk_id: THCannex_id_to_disk_id): PHCAnnexZ1_disk;
var
  HCAnnexHelper: IHCAnnexHelper;
begin
  HCAnnexHelper := THCAnnexHelper.Create(pPAnnexData, pPHCannex_id_to_disk_id, 0, 0);
  result := HCAnnexHelper.HCGetAnnexZ1(pAnnexID);
end;

function HCGetAnnexZ2(pAnnexID: ID; pPAnnexData: PHCAnnexes_disk; verSaveGame: LongWord): PHCAnnexZ2_disk;
var
  HCAnnexHelper: IHCAnnexHelper;
begin
  HCAnnexHelper := THCAnnexHelper.Create(pPAnnexData, nil, 0, verSaveGame);
  result := HCAnnexHelper.HCGetAnnexZ2(pAnnexID);
end;

function HCGetAnnexZ2(pAnnexID: ID; pPAnnexData: PHCAnnexes_disk): PHCAnnexZ2_disk;
var
  HCAnnexHelper: IHCAnnexHelper;
begin
  HCAnnexHelper := THCAnnexHelper.Create(pPAnnexData, nil, 0, 0);
  result := HCAnnexHelper.HCGetAnnexZ2(pAnnexID);
end;

function HCGetAnnexZ2(pAnnexID: ID; pPAnnexData: PHCAnnexes_disk; pPHCannex_id_to_disk_id: THCannex_id_to_disk_id): PHCAnnexZ2_disk;
var
  HCAnnexHelper: IHCAnnexHelper;
begin
  HCAnnexHelper := THCAnnexHelper.Create(pPAnnexData, pPHCannex_id_to_disk_id, 0, 0);
  result := HCAnnexHelper.HCGetAnnexZ2(pAnnexID);
end;

function HCGetAnnexMemA1(pAnnexID: ID; pPAnnexData: PHCAnnexes_mem; pPHCannex_id_to_disk_id: THCannex_id_to_disk_id): PHCAnnexA1_mem;
var
  HCAnnexMemHelper: IHCAnnexMemHelper;
begin
  HCAnnexMemHelper := THCAnnexMemHelper.Create(pPAnnexData, pPHCannex_id_to_disk_id);
  result := HCAnnexMemHelper.HCGetAnnexMemA1(pAnnexID);
end;

function HCGetAnnexMemA2(pAnnexID: ID; pPAnnexData: PHCAnnexes_mem; pPHCannex_id_to_disk_id: THCannex_id_to_disk_id): PHCAnnexA2_mem;
var
  HCAnnexMemHelper: IHCAnnexMemHelper;
begin
  HCAnnexMemHelper := THCAnnexMemHelper.Create(pPAnnexData, pPHCannex_id_to_disk_id);
  result := HCAnnexMemHelper.HCGetAnnexMemA2(pAnnexID);
end;

function HCGetAnnexMemB1(pAnnexID: ID; pPAnnexData: PHCAnnexes_mem; pPHCannex_id_to_disk_id: THCannex_id_to_disk_id): PHCAnnexB1_mem;
var
  HCAnnexMemHelper: IHCAnnexMemHelper;
begin
  HCAnnexMemHelper := THCAnnexMemHelper.Create(pPAnnexData, pPHCannex_id_to_disk_id);
  result := HCAnnexMemHelper.HCGetAnnexMemB1(pAnnexID);
end;

function HCGetAnnexMemC1(pAnnexID: ID; pPAnnexData: PHCAnnexes_mem; pPHCannex_id_to_disk_id: THCannex_id_to_disk_id): PHCAnnexC1_mem;
var
  HCAnnexMemHelper: IHCAnnexMemHelper;
begin
  HCAnnexMemHelper := THCAnnexMemHelper.Create(pPAnnexData, pPHCannex_id_to_disk_id);
  result := HCAnnexMemHelper.HCGetAnnexMemC1(pAnnexID);
end;

function HCGetAnnexMemD1(pAnnexID: ID; pPAnnexData: PHCAnnexes_mem; pPHCannex_id_to_disk_id: THCannex_id_to_disk_id): PHCAnnexD1_mem;
var
  HCAnnexMemHelper: IHCAnnexMemHelper;
begin
  HCAnnexMemHelper := THCAnnexMemHelper.Create(pPAnnexData, pPHCannex_id_to_disk_id);
  result := HCAnnexMemHelper.HCGetAnnexMemD1(pAnnexID);
end;

function HCGetAnnexMemE1(pAnnexID: ID; pPAnnexData: PHCAnnexes_mem; pPHCannex_id_to_disk_id: THCannex_id_to_disk_id): PHCAnnexE1_mem;
var
  HCAnnexMemHelper: IHCAnnexMemHelper;
begin
  HCAnnexMemHelper := THCAnnexMemHelper.Create(pPAnnexData, pPHCannex_id_to_disk_id);
  result := HCAnnexMemHelper.HCGetAnnexMemE1(pAnnexID);
end;

function HCGetAnnexMemF1(pAnnexID: ID; pPAnnexData: PHCAnnexes_mem; pPHCannex_id_to_disk_id: THCannex_id_to_disk_id): PHCAnnexF1_mem;
var
  HCAnnexMemHelper: IHCAnnexMemHelper;
begin
  HCAnnexMemHelper := THCAnnexMemHelper.Create(pPAnnexData, pPHCannex_id_to_disk_id);
  result := HCAnnexMemHelper.HCGetAnnexMemF1(pAnnexID);
end;

function HCGetAnnexMemG1(pAnnexID: ID; pPAnnexData: PHCAnnexes_mem; pPHCannex_id_to_disk_id: THCannex_id_to_disk_id): PHCAnnexG1_mem;
var
  HCAnnexMemHelper: IHCAnnexMemHelper;
begin
  HCAnnexMemHelper := THCAnnexMemHelper.Create(pPAnnexData, pPHCannex_id_to_disk_id);
  result := HCAnnexMemHelper.HCGetAnnexMemG1(pAnnexID);
end;

function HCGetAnnexMemG2(pAnnexID: ID; pPAnnexData: PHCAnnexes_mem; pPHCannex_id_to_disk_id: THCannex_id_to_disk_id): PHCAnnexG2_mem;
var
  HCAnnexMemHelper: IHCAnnexMemHelper;
begin
  HCAnnexMemHelper := THCAnnexMemHelper.Create(pPAnnexData, pPHCannex_id_to_disk_id);
  result := HCAnnexMemHelper.HCGetAnnexMemG2(pAnnexID);
end;

function HCGetAnnexMemI1(pAnnexID: ID; pPAnnexData: PHCAnnexes_mem; pPHCannex_id_to_disk_id: THCannex_id_to_disk_id): PHCAnnexI1_mem;
var
  HCAnnexMemHelper: IHCAnnexMemHelper;
begin
  HCAnnexMemHelper := THCAnnexMemHelper.Create(pPAnnexData, pPHCannex_id_to_disk_id);
  result := HCAnnexMemHelper.HCGetAnnexMemI1(pAnnexID);
end;

function HCGetAnnexMemJ1(pAnnexID: ID; pPAnnexData: PHCAnnexes_mem; pPHCannex_id_to_disk_id: THCannex_id_to_disk_id): PHCAnnexJ1_mem;
var
  HCAnnexMemHelper: IHCAnnexMemHelper;
begin
  HCAnnexMemHelper := THCAnnexMemHelper.Create(pPAnnexData, pPHCannex_id_to_disk_id);
  result := HCAnnexMemHelper.HCGetAnnexMemJ1(pAnnexID);
end;

function HCGetAnnexMemM1(pAnnexID: ID; pPAnnexData: PHCAnnexes_mem; pPHCannex_id_to_disk_id: THCannex_id_to_disk_id): PHCAnnexM1_mem;
var
  HCAnnexMemHelper: IHCAnnexMemHelper;
begin
  HCAnnexMemHelper := THCAnnexMemHelper.Create(pPAnnexData, pPHCannex_id_to_disk_id);
  result := HCAnnexMemHelper.HCGetAnnexMemM1(pAnnexID);
end;

function HCGetAnnexMemP1(pAnnexID: ID; pPAnnexData: PHCAnnexes_mem; pPHCannex_id_to_disk_id: THCannex_id_to_disk_id): PHCAnnexP1_mem;
var
  HCAnnexMemHelper: IHCAnnexMemHelper;
begin
  HCAnnexMemHelper := THCAnnexMemHelper.Create(pPAnnexData, pPHCannex_id_to_disk_id);
  result := HCAnnexMemHelper.HCGetAnnexMemP1(pAnnexID);
end;

function HCGetAnnexMemY1(pAnnexID: ID; pPAnnexData: PHCAnnexes_mem; pPHCannex_id_to_disk_id: THCannex_id_to_disk_id): PHCAnnexY1_mem;
var
  HCAnnexMemHelper: IHCAnnexMemHelper;
begin
  HCAnnexMemHelper := THCAnnexMemHelper.Create(pPAnnexData, pPHCannex_id_to_disk_id);
  result := HCAnnexMemHelper.HCGetAnnexMemY1(pAnnexID);
end;

function HCGetAnnexMemZ1(pAnnexID: ID; pPAnnexData: PHCAnnexes_mem; pPHCannex_id_to_disk_id: THCannex_id_to_disk_id): PHCAnnexZ1_mem;
var
  HCAnnexMemHelper: IHCAnnexMemHelper;
begin
  HCAnnexMemHelper := THCAnnexMemHelper.Create(pPAnnexData, pPHCannex_id_to_disk_id);
  result := HCAnnexMemHelper.HCGetAnnexMemZ1(pAnnexID);
end;

function HCGetAnnexMemZ2(pAnnexID: ID; pPAnnexData: PHCAnnexes_mem; pPHCannex_id_to_disk_id: THCannex_id_to_disk_id): PHCAnnexZ2_mem;
var
  HCAnnexMemHelper: IHCAnnexMemHelper;
begin
  HCAnnexMemHelper := THCAnnexMemHelper.Create(pPAnnexData, pPHCannex_id_to_disk_id);
  result := HCAnnexMemHelper.HCGetAnnexMemZ2(pAnnexID);
end;

{ THCBSStringsHelper }

constructor THCBSStringsHelper.Create(pPAnnexData: PHCAnnexes_disk;
  pPHCannex_id_to_disk_id: THCannex_id_to_disk_id; pVerInterface: LongWord;
  pVerSaveGame: LongWord);
begin
  inherited Create;
end;

destructor THCBSStringsHelper.Destroy;
begin
  inherited Destroy;
end;

{ THCAnnexHelper }

constructor THCAnnexHelper.Create(pPAnnexData: PHCAnnexes_disk;
  pPHCannex_id_to_disk_id: THCannex_id_to_disk_id; pVerInterface: LongWord;
  pVerSaveGame: LongWord);
begin
  inherited Create;

  fPAnnexData:=pPAnnexData;
  fPHCannex_id_to_disk_id:=pPHCannex_id_to_disk_id;
  fVerInterface:=pVerInterface;
  fVerSaveGame:=pVerSaveGame;
end;

destructor THCAnnexHelper.Destroy;
begin
  inherited Destroy;
end;

constructor THCAnnexMemHelper.Create(pPAnnexData: PHCAnnexes_mem;
  pPHCannex_id_to_disk_id: THCannex_id_to_disk_id);
begin
  inherited Create;

  fPAnnexData:=pPAnnexData;
  fPHCannex_id_to_disk_id:=pPHCannex_id_to_disk_id;
end;

destructor THCAnnexMemHelper.Destroy;
begin
  inherited Destroy;
end;

function THCAnnexMemHelper.HCAnnexShift(pAnnexID: ID): NativeInt;
begin
  result := pAnnexID Shr 12; // ALE 20150820 tells us top 4 bits tell us which annex we are from
end;

function THCAnnexMemHelper.HCIsDisk(pAnnexID: ID): Boolean;
begin
  result := True;
end;

function THCAnnexMemHelper.HCdisk_id_to_annex_offset(pAnnexID: ID): NativeInt;
var
  index: NativeInt;
  annex: NativeInt;
  i: NativeInt;
begin
  if (NOT HCIsDisk(pAnnexID)) then
    index:=INVALID_OFFSET
  else
  begin
    // ALE 20151003 with 4096 items per annex we introduce the concept of
    //  gaps in ID numbers.  So we can't find the right entry purely by index.
    index:=INVALID_OFFSET;
    annex:=HCAnnexShift(pAnnexID);
    i:=0;
    while ((index = INVALID_OFFSET) AND (i < fPAnnexData^.AnnexMemRecCount[annex])) do
    begin
      case  annex of
        SHIP_FLAG:
	  if (pAnnexID = fPAnnexData^.PA1_MEM_PTR_LIST[i].disk.DiskId) then
	    index := i;
        SUB_FLAG:
	  if (pAnnexID = fPAnnexData^.PA2_MEM_PTR_LIST[i].disk.DiskId) then
	    index := i;
        PLANE_FLAG:
	  if (pAnnexID = fPAnnexData^.PB1_MEM_PTR_LIST[i].disk.DiskId) then
	    index := i;
        GUN_FLAG:
	  if (pAnnexID = fPAnnexData^.PC1_MEM_PTR_LIST[i].disk.DiskId) then
	    index := i;
        MISSILE_FLAG:
	  if (pAnnexID = fPAnnexData^.PD1_MEM_PTR_LIST[i].disk.DiskId) then
	    index := i;
        ASW_FLAG:
	  if (pAnnexID = fPAnnexData^.PE1_MEM_PTR_LIST[i].disk.DiskId) then
	    index := i;
        TORP_FLAG:
	  if (pAnnexID = fPAnnexData^.PF1_MEM_PTR_LIST[i].disk.DiskId) then
	    index := i;
        ATOG_FLAG:
	  if (pAnnexID = fPAnnexData^.PG1_MEM_PTR_LIST[i].disk.DiskId) then
	    index := i;
        ECM_FLAG:
	  if (pAnnexID = fPAnnexData^.PG2_MEM_PTR_LIST[i].disk.DiskId) then
	    index := i;
        NUKE_FLAG:
	  if (pAnnexID = fPAnnexData^.PI1_MEM_PTR_LIST[i].disk.DiskId) then
	    index := i;
        RADAR_FLAG:
	  if (pAnnexID = fPAnnexData^.PJ1_MEM_PTR_LIST[i].disk.DiskId) then
	    index := i;
        SONAR_FLAG:
	  if (pAnnexID = fPAnnexData^.PM1_MEM_PTR_LIST[i].disk.DiskId) then
	    index := i;
        BASE_FLAG:
	  if (pAnnexID = fPAnnexData^.PP1_MEM_PTR_LIST[i].disk.DiskId) then
	    index := i;
        LOADOUT_FLAG:
	  if (pAnnexID = fPAnnexData^.PY1_MEM_PTR_LIST[i].disk.DiskId) then
	    index := i;
        MOUNT_FLAG:
	  if (pAnnexID = fPAnnexData^.PZ1_MEM_PTR_LIST[i].disk.DiskId) then
	    index := i;
        MULTI_FLAG:
	  if (pAnnexID = fPAnnexData^.PZ2_MEM_PTR_LIST[i].disk.DiskId) then
	    index := i;
      end;  // case
      Inc(i);
    end;
  end;
  result:=index;
end;

// Take a Annex ID and spit back the associated annex flag
//  ex. HCAnnexShift(2047) = SHIP_FLAG
function THCAnnexHelper.HCAnnexShift(pAnnexID: ID): NativeInt;
begin
  result := pAnnexID Shr 12; // ALE 20150820 tells us top 4 bits tell us which annex we are from
end;

// Is this a disk id or a memory/annex id?
//  IS_DISK(annex_id)     ((annex_id) & 0x0800)
function THCAnnexHelper.HCIsDisk(pAnnexID: ID): Boolean;
begin
  // ALE 20160521 takes into account 4096 items per annex
  if (fVerSaveGame >= $34803210) then
  begin
    result := True;
  end
  else
  begin
    if (pAnnexID And $0800) <> 0 Then
      result := True
    else
      result := False;
  end;
end;

// ALE 20151002 Pull back the index into the listing of disk records
//  i.e. 2048 = 0 before moving to 4096 items/annex
function THCAnnexHelper.HCdisk_id_to_annex_offset(pAnnexID: ID): NativeInt;
var
  index: NativeInt;
  annex: NativeInt;
  i: NativeInt;
begin
  if (NOT HCIsDisk(pAnnexID)) then
    index:=INVALID_OFFSET
  else
  begin
    // ALE 20151003 with 4096 items per annex we introduce the concept of
    //  gaps in ID numbers.  So we can't find the right entry purely by index.
    index:=INVALID_OFFSET;
    annex:=HCAnnexShift(pAnnexID);
    i:=0;
    while ((index = INVALID_OFFSET) AND (i < fPAnnexData^.AnnexDiskRecCount[annex])) do
    begin
      case  annex of
        SHIP_FLAG:
	  if (pAnnexID = fPAnnexData^.PA1_DISK_PTR_LIST[i].DiskId) then
	    index := i;
        SUB_FLAG:
	  if (pAnnexID = fPAnnexData^.PA2_DISK_PTR_LIST[i].DiskId) then
	    index := i;
        PLANE_FLAG:
	  if (pAnnexID = fPAnnexData^.PB1_DISK_PTR_LIST[i].DiskId) then
	    index := i;
        GUN_FLAG:
	  if (pAnnexID = fPAnnexData^.PC1_DISK_PTR_LIST[i].DiskId) then
	    index := i;
        MISSILE_FLAG:
	  if (pAnnexID = fPAnnexData^.PD1_DISK_PTR_LIST[i].DiskId) then
	    index := i;
        ASW_FLAG:
	  if (pAnnexID = fPAnnexData^.PE1_DISK_PTR_LIST[i].DiskId) then
	    index := i;
        TORP_FLAG:
	  if (pAnnexID = fPAnnexData^.PF1_DISK_PTR_LIST[i].DiskId) then
	    index := i;
        ATOG_FLAG:
	  if (pAnnexID = fPAnnexData^.PG1_DISK_PTR_LIST[i].DiskId) then
	    index := i;
        ECM_FLAG:
	  if (pAnnexID = fPAnnexData^.PG2_DISK_PTR_LIST[i].DiskId) then
	    index := i;
        NUKE_FLAG:
	  if (pAnnexID = fPAnnexData^.PI1_DISK_PTR_LIST[i].DiskId) then
	    index := i;
        RADAR_FLAG:
	  if (pAnnexID = fPAnnexData^.PJ1_DISK_PTR_LIST[i].DiskId) then
	    index := i;
        SONAR_FLAG:
	  if (pAnnexID = fPAnnexData^.PM1_DISK_PTR_LIST[i].DiskId) then
	    index := i;
        BASE_FLAG:
	  if (pAnnexID = fPAnnexData^.PP1_DISK_PTR_LIST[i].DiskId) then
	    index := i;
        LOADOUT_FLAG:
	  if (pAnnexID = fPAnnexData^.PY1_DISK_PTR_LIST[i].DiskId) then
	    index := i;
        MOUNT_FLAG:
	  if (pAnnexID = fPAnnexData^.PZ1_DISK_PTR_LIST[i].DiskId) then
	    index := i;
        MULTI_FLAG:
	  if (pAnnexID = fPAnnexData^.PZ2_DISK_PTR_LIST[i].DiskId) then
	    index := i;
      end;  // case
      Inc(i);
    end;
  end;
  result:=index;
end;


function THCAnnexHelper.HCGetAnnexA1(pAnnexID: ID): PHCAnnexA1_disk;
var
  IdDisk: ID;
  IdAnnexOffset: ID;
begin
  Assert(SHIP_FLAG = HCAnnexShift(pAnnexID), 'HCGetAnnexA1 called with an ID not in the Ship/A1 Annex');
  if (fVerSaveGame >= $34803210) then
  begin
    // ALE 20160509 2015.021+ We have 4096 items per annex
    IdAnnexOffset := HCdisk_id_to_annex_offset(pAnnexId);
    result := PHCAnnexA1_disk(fPAnnexData^.PA1_DISK_PTR_LIST + IdAnnexOffset);
  end
  else if (fVerInterface >= 12) then
  begin
    // ALE 20160509 2015.014+ Annex data available to ExportDLL Interface
    if (True = HCIsDisk(pAnnexID)) then
    begin
      IdAnnexOffset := HCdisk_id_to_annex_offset(pAnnexId);
      result := PHCAnnexA1_disk(fPAnnexData^.PA1_DISK_PTR_LIST + IdAnnexOffset);
    end
    else
    begin
      // ALE 20160509 Memory Annex ID
      IdDisk := fPHCannex_id_to_disk_id(pAnnexID);
      IdAnnexOffset := HCdisk_id_to_annex_offset(IdDisk);
      Assert(IdAnnexOffset < fPAnnexData^.AnnexDiskRecCount[SHIP_FLAG], 'HCGetAnnexA1 Annex ID out of range');
      result := PHCAnnexA1_disk(fPAnnexData^.PA1_DISK_PTR_LIST + IdAnnexOffset);
    end;
  end
  else
  begin
    // ALE 20160509 HC version is too old for this DLL
    Assert(fVerInterface >= 12, 'HC build is too old for this ExportDLL');
    result := nil;
  end;
end;

function THCAnnexMemHelper.HCGetAnnexMemA1(pAnnexID: ID): PHCAnnexA1_mem;
var
  IdDisk: ID;
  IdAnnexOffset: ID;
begin
  Assert(SHIP_FLAG = HCAnnexShift(pAnnexID), 'HCGetAnnexA1 called with an ID not in the Ship/A1 Annex');

  // ALE 20160509 2015.021+ We have 4096 items per annex
  IdAnnexOffset := HCdisk_id_to_annex_offset(pAnnexId);
  result := PHCAnnexA1_mem(fPAnnexData^.PA1_MEM_PTR_LIST + IdAnnexOffset);
end;

function THCAnnexMemHelper.HCGetAnnexMemA2(pAnnexID: ID): PHCAnnexA2_mem;
begin

end;

function THCAnnexMemHelper.HCGetAnnexMemB1(pAnnexID: ID): PHCAnnexB1_mem;
begin

end;

function THCAnnexMemHelper.HCGetAnnexMemC1(pAnnexID: ID): PHCAnnexC1_mem;
begin

end;

function THCAnnexMemHelper.HCGetAnnexMemD1(pAnnexID: ID): PHCAnnexD1_mem;
begin

end;

function THCAnnexMemHelper.HCGetAnnexMemE1(pAnnexID: ID): PHCAnnexE1_mem;
begin

end;

function THCAnnexMemHelper.HCGetAnnexMemF1(pAnnexID: ID): PHCAnnexF1_mem;
begin

end;

function THCAnnexMemHelper.HCGetAnnexMemG1(pAnnexID: ID): PHCAnnexG1_mem;
begin

end;

function THCAnnexMemHelper.HCGetAnnexMemG2(pAnnexID: ID): PHCAnnexG2_mem;
begin

end;

function THCAnnexMemHelper.HCGetAnnexMemI1(pAnnexID: ID): PHCAnnexI1_mem;
begin

end;

function THCAnnexMemHelper.HCGetAnnexMemJ1(pAnnexID: ID): PHCAnnexJ1_mem;
begin

end;

function THCAnnexMemHelper.HCGetAnnexMemM1(pAnnexID: ID): PHCAnnexM1_mem;
begin

end;

function THCAnnexMemHelper.HCGetAnnexMemP1(pAnnexID: ID): PHCAnnexP1_mem;
begin

end;

function THCAnnexMemHelper.HCGetAnnexMemY1(pAnnexID: ID): PHCAnnexY1_mem;
begin

end;

function THCAnnexMemHelper.HCGetAnnexMemZ1(pAnnexID: ID): PHCAnnexZ1_mem;
begin

end;

function THCAnnexMemHelper.HCGetAnnexMemZ2(pAnnexID: ID): PHCAnnexZ2_mem;
begin

end;

function THCAnnexHelper.HCGetAnnexA2(pAnnexID: ID): PHCAnnexA2_disk;
var
  IdDisk: ID;
  IdAnnexOffset: ID;
begin
  Assert(SUB_FLAG = HCAnnexShift(pAnnexID), 'HCGetAnnexA2 called with an ID not in the Submarine/A2 Annex');
  if (fVerSaveGame >= $34803210) then
  begin
    // ALE 20160509 2015.021+ We have 4096 items per annex
    IdAnnexOffset := HCdisk_id_to_annex_offset(pAnnexId);
    result := PHCAnnexA2_disk(fPAnnexData^.PA2_DISK_PTR_LIST + IdAnnexOffset);
  end
  else if (fVerInterface >= 12) then
  begin
    // ALE 20160509 2015.014+ Annex data available to ExportDLL Interface
    if (True = HCIsDisk(pAnnexID)) then
    begin
      IdAnnexOffset := HCdisk_id_to_annex_offset(pAnnexId);
      result := PHCAnnexA2_disk(fPAnnexData^.PA2_DISK_PTR_LIST + IdAnnexOffset);
    end
    else
    begin
      // ALE 20160509 Memory Annex ID
      IdDisk := fPHCannex_id_to_disk_id(pAnnexID);
      IdAnnexOffset := HCdisk_id_to_annex_offset(IdDisk);
      Assert(IdAnnexOffset < fPAnnexData^.AnnexDiskRecCount[SUB_FLAG], 'HCGetAnnexA2 Annex ID out of range');
      result := PHCAnnexA2_disk(fPAnnexData^.PA2_DISK_PTR_LIST + IdAnnexOffset);
    end;
  end
  else
  begin
    // ALE 20160509 HC version is too old for this DLL
    Assert(fVerInterface >= 12, 'HC build is too old for this ExportDLL');
    result := nil;
  end;
end;

function THCAnnexHelper.HCGetAnnexB1(pAnnexID: ID): PHCAnnexB1_disk;
var
  IdDisk: ID;
  IdAnnexOffset: ID;
begin
  Assert(PLANE_FLAG = HCAnnexShift(pAnnexID), 'HCGetAnnexB1 called with an ID not in the Plane/B1 Annex');
  if (fVerSaveGame >= $34803210) then
  begin
    // ALE 20160509 2015.021+ We have 4096 items per annex
    IdAnnexOffset := HCdisk_id_to_annex_offset(pAnnexId);
    result := PHCAnnexB1_disk(fPAnnexData^.PB1_DISK_PTR_LIST + IdAnnexOffset);
  end
  else if (fVerInterface >= 12) then
  begin
    // ALE 20160509 2015.014+ Annex data available to ExportDLL Interface
    if (True = HCIsDisk(pAnnexID)) then
    begin
      IdAnnexOffset := HCdisk_id_to_annex_offset(pAnnexId);
      result := PHCAnnexB1_disk(fPAnnexData^.PB1_DISK_PTR_LIST + IdAnnexOffset);
    end
    else
    begin
      // ALE 20160509 Memory Annex ID
      IdDisk := fPHCannex_id_to_disk_id(pAnnexID);
      IdAnnexOffset := HCdisk_id_to_annex_offset(IdDisk);
      Assert(IdAnnexOffset < fPAnnexData^.AnnexDiskRecCount[PLANE_FLAG], 'HCGetAnnexB1 Annex ID out of range');
      result := PHCAnnexB1_disk(fPAnnexData^.PB1_DISK_PTR_LIST + IdAnnexOffset);
    end;
  end
  else
  begin
    // ALE 20160509 HC version is too old for this DLL
    Assert(fVerInterface >= 12, 'HC build is too old for this ExportDLL');
    result := nil;
  end;
end;

function THCAnnexHelper.HCGetAnnexC1(pAnnexID: ID): PHCAnnexC1_disk;
var
  IdDisk: ID;
  IdAnnexOffset: ID;
begin
  Assert(GUN_FLAG = HCAnnexShift(pAnnexID), 'HCGetAnnexC1 called with an ID not in the Gun/C1 Annex');
  if (fVerSaveGame >= $34803210) then
  begin
    // ALE 20160509 2015.021+ We have 4096 items per annex
    IdAnnexOffset := HCdisk_id_to_annex_offset(pAnnexId);
    result := PHCAnnexC1_disk(fPAnnexData^.PC1_DISK_PTR_LIST + IdAnnexOffset);
  end
  else if (fVerInterface >= 12) then
  begin
    // ALE 20160509 2015.014+ Annex data available to ExportDLL Interface
    if (True = HCIsDisk(pAnnexID)) then
    begin
      IdAnnexOffset := HCdisk_id_to_annex_offset(pAnnexId);
      result := PHCAnnexC1_disk(fPAnnexData^.PC1_DISK_PTR_LIST + IdAnnexOffset);
    end
    else
    begin
      // ALE 20160509 Memory Annex ID
      IdDisk := fPHCannex_id_to_disk_id(pAnnexID);
      IdAnnexOffset := HCdisk_id_to_annex_offset(IdDisk);
      Assert(IdAnnexOffset < fPAnnexData^.AnnexDiskRecCount[GUN_FLAG], 'HCGetAnnexC1 Annex ID out of range');
      result := PHCAnnexC1_disk(fPAnnexData^.PC1_DISK_PTR_LIST + IdAnnexOffset);
    end;
  end
  else
  begin
    // ALE 20160509 HC version is too old for this DLL
    Assert(fVerInterface >= 12, 'HC build is too old for this ExportDLL');
    result := nil;
  end;
end;

function THCAnnexHelper.HCGetAnnexD1(pAnnexID: ID): PHCAnnexD1_disk;
var
  IdDisk: ID;
  IdAnnexOffset: ID;
begin
  Assert(MISSILE_FLAG = HCAnnexShift(pAnnexID), 'HCGetAnnexD1 called with an ID not in the Missile/D1 Annex');
  if (fVerSaveGame >= $34803210) then
  begin
    // ALE 20160509 2015.021+ We have 4096 items per annex
    IdAnnexOffset := HCdisk_id_to_annex_offset(pAnnexId);
    result := PHCAnnexD1_disk(fPAnnexData^.PD1_DISK_PTR_LIST + IdAnnexOffset);
  end
  else if (fVerInterface >= 12) then
  begin
    // ALE 20160509 2015.014+ Annex data available to ExportDLL Interface
    if (True = HCIsDisk(pAnnexID)) then
    begin
      IdAnnexOffset := HCdisk_id_to_annex_offset(pAnnexId);
      result := PHCAnnexD1_disk(fPAnnexData^.PD1_DISK_PTR_LIST + IdAnnexOffset);
    end
    else
    begin
      // ALE 20160509 Memory Annex ID
      IdDisk := fPHCannex_id_to_disk_id(pAnnexID);
      IdAnnexOffset := HCdisk_id_to_annex_offset(IdDisk);
      Assert(IdAnnexOffset < fPAnnexData^.AnnexDiskRecCount[MISSILE_FLAG], 'HCGetAnnexD1 Annex ID out of range');
      result := PHCAnnexD1_disk(fPAnnexData^.PD1_DISK_PTR_LIST + IdAnnexOffset);
    end;
  end
  else
  begin
    // ALE 20160509 HC version is too old for this DLL
    Assert(fVerInterface >= 12, 'HC build is too old for this ExportDLL');
    result := nil;
  end;
end;

function THCAnnexHelper.HCGetAnnexE1(pAnnexID: ID): PHCAnnexE1_disk;
var
  IdDisk: ID;
  IdAnnexOffset: ID;
begin
  Assert(ASW_FLAG = HCAnnexShift(pAnnexID), 'HCGetAnnexE1 called with an ID not in the ASW/E1 Annex');
  if (fVerSaveGame >= $34803210) then
  begin
    // ALE 20160509 2015.021+ We have 4096 items per annex
    IdAnnexOffset := HCdisk_id_to_annex_offset(pAnnexId);
    result := PHCAnnexE1_disk(fPAnnexData^.PE1_DISK_PTR_LIST + IdAnnexOffset);
  end
  else if (fVerInterface >= 12) then
  begin
    // ALE 20160509 2015.014+ Annex data available to ExportDLL Interface
    if (True = HCIsDisk(pAnnexID)) then
    begin
      IdAnnexOffset := HCdisk_id_to_annex_offset(pAnnexId);
      result := PHCAnnexE1_disk(fPAnnexData^.PE1_DISK_PTR_LIST + IdAnnexOffset);
    end
    else
    begin
      // ALE 20160509 Memory Annex ID
      IdDisk := fPHCannex_id_to_disk_id(pAnnexID);
      IdAnnexOffset := HCdisk_id_to_annex_offset(IdDisk);
      Assert(IdAnnexOffset < fPAnnexData^.AnnexDiskRecCount[ASW_FLAG], 'HCGetAnnexE1 Annex ID out of range');
      result := PHCAnnexE1_disk(fPAnnexData^.PE1_DISK_PTR_LIST + IdAnnexOffset);
    end;
  end
  else
  begin
    // ALE 20160509 HC version is too old for this DLL
    Assert(fVerInterface >= 12, 'HC build is too old for this ExportDLL');
    result := nil;
  end;
end;

function THCAnnexHelper.HCGetAnnexF1(pAnnexID: ID): PHCAnnexF1_disk;
var
  IdDisk: ID;
  IdAnnexOffset: ID;
begin
  Assert(TORP_FLAG = HCAnnexShift(pAnnexID), 'HCGetAnnexF1 called with an ID not in the Torpedo/F1 Annex');
  if (fVerSaveGame >= $34803210) then
  begin
    // ALE 20160509 2015.021+ We have 4096 items per annex
    IdAnnexOffset := HCdisk_id_to_annex_offset(pAnnexId);
    result := PHCAnnexF1_disk(fPAnnexData^.PF1_DISK_PTR_LIST + IdAnnexOffset);
  end
  else if (fVerInterface >= 12) then
  begin
    // ALE 20160509 2015.014+ Annex data available to ExportDLL Interface
    if (True = HCIsDisk(pAnnexID)) then
    begin
      IdAnnexOffset := HCdisk_id_to_annex_offset(pAnnexId);
      result := PHCAnnexF1_disk(fPAnnexData^.PF1_DISK_PTR_LIST + IdAnnexOffset);
    end
    else
    begin
      // ALE 20160509 Memory Annex ID
      IdDisk := fPHCannex_id_to_disk_id(pAnnexID);
      IdAnnexOffset := HCdisk_id_to_annex_offset(IdDisk);
      Assert(IdAnnexOffset < fPAnnexData^.AnnexDiskRecCount[TORP_FLAG], 'HCGetAnnexF1 Annex ID out of range');
      result := PHCAnnexF1_disk(fPAnnexData^.PF1_DISK_PTR_LIST + IdAnnexOffset);
    end;
  end
  else
  begin
    // ALE 20160509 HC version is too old for this DLL
    Assert(fVerInterface >= 12, 'HC build is too old for this ExportDLL');
    result := nil;
  end;
end;

function THCAnnexHelper.HCGetAnnexG1(pAnnexID: ID): PHCAnnexG1_disk;
var
  IdDisk: ID;
  IdAnnexOffset: ID;
begin
  Assert(ATOG_FLAG = HCAnnexShift(pAnnexID), 'HCGetAnnexG1 called with an ID not in the Air 2 Ground/G1 Annex');
  if (fVerSaveGame >= $34803210) then
  begin
    // ALE 20160509 2015.021+ We have 4096 items per annex
    IdAnnexOffset := HCdisk_id_to_annex_offset(pAnnexId);
    result := PHCAnnexG1_disk(fPAnnexData^.PG1_DISK_PTR_LIST + IdAnnexOffset);
  end
  else if (fVerInterface >= 12) then
  begin
    // ALE 20160509 2015.014+ Annex data available to ExportDLL Interface
    if (True = HCIsDisk(pAnnexID)) then
    begin
      IdAnnexOffset := HCdisk_id_to_annex_offset(pAnnexId);
      result := PHCAnnexG1_disk(fPAnnexData^.PG1_DISK_PTR_LIST + IdAnnexOffset);
    end
    else
    begin
      // ALE 20160509 Memory Annex ID
      IdDisk := fPHCannex_id_to_disk_id(pAnnexID);
      IdAnnexOffset := HCdisk_id_to_annex_offset(IdDisk);
      Assert(IdAnnexOffset < fPAnnexData^.AnnexDiskRecCount[ATOG_FLAG], 'HCGetAnnexG1 Annex ID out of range');
      result := PHCAnnexG1_disk(fPAnnexData^.PG1_DISK_PTR_LIST + IdAnnexOffset);
    end;
  end
  else
  begin
    // ALE 20160509 HC version is too old for this DLL
    Assert(fVerInterface >= 12, 'HC build is too old for this ExportDLL');
    result := nil;
  end;
end;

function THCAnnexHelper.HCGetAnnexG2(pAnnexID: ID): PHCAnnexG2_disk;
var
  IdDisk: ID;
  IdAnnexOffset: ID;
begin
  Assert(ECM_FLAG = HCAnnexShift(pAnnexID), 'HCGetAnnexG2 called with an ID not in the ECM/G2 Annex');
  if (fVerSaveGame >= $34803210) then
  begin
    // ALE 20160509 2015.021+ We have 4096 items per annex
    IdAnnexOffset := HCdisk_id_to_annex_offset(pAnnexId);
    result := PHCAnnexG2_disk(fPAnnexData^.PG2_DISK_PTR_LIST + IdAnnexOffset);
  end
  else if (fVerInterface >= 12) then
  begin
    // ALE 20160509 2015.014+ Annex data available to ExportDLL Interface
    if (True = HCIsDisk(pAnnexID)) then
    begin
      IdAnnexOffset := HCdisk_id_to_annex_offset(pAnnexId);
      result := PHCAnnexG2_disk(fPAnnexData^.PG2_DISK_PTR_LIST + IdAnnexOffset);
    end
    else
    begin
      // ALE 20160509 Memory Annex ID
      IdDisk := fPHCannex_id_to_disk_id(pAnnexID);
      IdAnnexOffset := HCdisk_id_to_annex_offset(IdDisk);
      Assert(IdAnnexOffset < fPAnnexData^.AnnexDiskRecCount[ECM_FLAG], 'HCGetAnnexG2 Annex ID out of range');
      result := PHCAnnexG2_disk(fPAnnexData^.PG2_DISK_PTR_LIST + IdAnnexOffset);
    end;
  end
  else
  begin
    // ALE 20160509 HC version is too old for this DLL
    Assert(fVerInterface >= 12, 'HC build is too old for this ExportDLL');
    result := nil;
  end;
end;

function THCAnnexHelper.HCGetAnnexI1(pAnnexID: ID): PHCAnnexI1_disk;
var
  IdDisk: ID;
  IdAnnexOffset: ID;
begin
  Assert(NUKE_FLAG = HCAnnexShift(pAnnexID), 'HCGetAnnexI1 called with an ID not in the Nuke/I1 Annex');
  if (fVerSaveGame >= $34803210) then
  begin
    // ALE 20160509 2015.021+ We have 4096 items per annex
    IdAnnexOffset := HCdisk_id_to_annex_offset(pAnnexId);
    result := PHCAnnexI1_disk(fPAnnexData^.PI1_DISK_PTR_LIST + IdAnnexOffset);
  end
  else if (fVerInterface >= 12) then
  begin
    // ALE 20160509 2015.014+ Annex data available to ExportDLL Interface
    if (True = HCIsDisk(pAnnexID)) then
    begin
      IdAnnexOffset := HCdisk_id_to_annex_offset(pAnnexId);
      result := PHCAnnexI1_disk(fPAnnexData^.PI1_DISK_PTR_LIST + IdAnnexOffset);
    end
    else
    begin
      // ALE 20160509 Memory Annex ID
      IdDisk := fPHCannex_id_to_disk_id(pAnnexID);
      IdAnnexOffset := HCdisk_id_to_annex_offset(IdDisk);
      Assert(IdAnnexOffset < fPAnnexData^.AnnexDiskRecCount[NUKE_FLAG], 'HCGetAnnexI1 Annex ID out of range');
      result := PHCAnnexI1_disk(fPAnnexData^.PI1_DISK_PTR_LIST + IdAnnexOffset);
    end;
  end
  else
  begin
    // ALE 20160509 HC version is too old for this DLL
    Assert(fVerInterface >= 12, 'HC build is too old for this ExportDLL');
    result := nil;
  end;
end;

function THCAnnexHelper.HCGetAnnexJ1(pAnnexID: ID): PHCAnnexJ1_disk;
var
  IdDisk: ID;
  IdAnnexOffset: ID;
begin
  Assert(RADAR_FLAG = HCAnnexShift(pAnnexID), 'HCGetAnnexJ1 called with an ID not in the Radar/J1 Annex');
  if (fVerSaveGame >= $34803210) then
  begin
    // ALE 20160509 2015.021+ We have 4096 items per annex
    IdAnnexOffset := HCdisk_id_to_annex_offset(pAnnexId);
    result := PHCAnnexJ1_disk(fPAnnexData^.PJ1_DISK_PTR_LIST + IdAnnexOffset);
  end
  else if (fVerInterface >= 12) then
  begin
    // ALE 20160509 2015.014+ Annex data available to ExportDLL Interface
    if (True = HCIsDisk(pAnnexID)) then
    begin
      IdAnnexOffset := HCdisk_id_to_annex_offset(pAnnexId);
      result := PHCAnnexJ1_disk(fPAnnexData^.PJ1_DISK_PTR_LIST + IdAnnexOffset);
    end
    else
    begin
      // ALE 20160509 Memory Annex ID
      IdDisk := fPHCannex_id_to_disk_id(pAnnexID);
      IdAnnexOffset := HCdisk_id_to_annex_offset(IdDisk);
      Assert(IdAnnexOffset < fPAnnexData^.AnnexDiskRecCount[RADAR_FLAG], 'HCGetAnnexJ1 Annex ID out of range');
      result := PHCAnnexJ1_disk(fPAnnexData^.PJ1_DISK_PTR_LIST + IdAnnexOffset);
    end;
  end
  else
  begin
    // ALE 20160509 HC version is too old for this DLL
    Assert(fVerInterface >= 12, 'HC build is too old for this ExportDLL');
    result := nil;
  end;
end;

function THCAnnexHelper.HCGetAnnexM1(pAnnexID: ID): PHCAnnexM1_disk;
var
  IdDisk: ID;
  IdAnnexOffset: ID;
begin
  Assert(SONAR_FLAG = HCAnnexShift(pAnnexID), 'HCGetAnnexM1 called with an ID not in the Sonar/M1 Annex');
  if (fVerSaveGame >= $34803210) then
  begin
    // ALE 20160509 2015.021+ We have 4096 items per annex
    IdAnnexOffset := HCdisk_id_to_annex_offset(pAnnexId);
    result := PHCAnnexM1_disk(fPAnnexData^.PM1_DISK_PTR_LIST + IdAnnexOffset);
  end
  else if (fVerInterface >= 12) then
  begin
    // ALE 20160509 2015.014+ Annex data available to ExportDLL Interface
    if (True = HCIsDisk(pAnnexID)) then
    begin
      IdAnnexOffset := HCdisk_id_to_annex_offset(pAnnexId);
      result := PHCAnnexM1_disk(fPAnnexData^.PM1_DISK_PTR_LIST + IdAnnexOffset);
    end
    else
    begin
      // ALE 20160509 Memory Annex ID
      IdDisk := fPHCannex_id_to_disk_id(pAnnexID);
      IdAnnexOffset := HCdisk_id_to_annex_offset(IdDisk);
      Assert(IdAnnexOffset < fPAnnexData^.AnnexDiskRecCount[SONAR_FLAG], 'HCGetAnnexM1 Annex ID out of range');
      result := PHCAnnexM1_disk(fPAnnexData^.PM1_DISK_PTR_LIST + IdAnnexOffset);
    end;
  end
  else
  begin
    // ALE 20160509 HC version is too old for this DLL
    Assert(fVerInterface >= 12, 'HC build is too old for this ExportDLL');
    result := nil;
  end;
end;

function THCAnnexHelper.HCGetAnnexP1(pAnnexID: ID): PHCAnnexP1_disk;
var
  IdDisk: ID;
  IdAnnexOffset: ID;
begin
  Assert(BASE_FLAG = HCAnnexShift(pAnnexID), 'HCGetAnnexP1 called with an ID not in the Installations/P1 Annex');
  if (fVerSaveGame >= $34803210) then
  begin
    // ALE 20160509 2015.021+ We have 4096 items per annex
    IdAnnexOffset := HCdisk_id_to_annex_offset(pAnnexId);
    result := PHCAnnexP1_disk(fPAnnexData^.PP1_DISK_PTR_LIST + IdAnnexOffset);
  end
  else if (fVerInterface >= 12) then
  begin
    // ALE 20160509 2015.014+ Annex data available to ExportDLL Interface
    if (True = HCIsDisk(pAnnexID)) then
    begin
      IdAnnexOffset := HCdisk_id_to_annex_offset(pAnnexId);
      result := PHCAnnexP1_disk(fPAnnexData^.PP1_DISK_PTR_LIST + IdAnnexOffset);
    end
    else
    begin
      // ALE 20160509 Memory Annex ID
      IdDisk := fPHCannex_id_to_disk_id(pAnnexID);
      IdAnnexOffset := HCdisk_id_to_annex_offset(IdDisk);
      Assert(IdAnnexOffset < fPAnnexData^.AnnexDiskRecCount[BASE_FLAG], 'HCGetAnnexP1 Annex ID out of range');
      result := PHCAnnexP1_disk(fPAnnexData^.PP1_DISK_PTR_LIST + IdAnnexOffset);
    end;
  end
  else
  begin
    // ALE 20160509 HC version is too old for this DLL
    Assert(fVerInterface >= 12, 'HC build is too old for this ExportDLL');
    result := nil;
  end;
end;

function THCAnnexHelper.HCGetAnnexY1(pAnnexID: ID): PHCAnnexY1_disk;
var
  IdDisk: ID;
  IdAnnexOffset: ID;
begin
  Assert(LOADOUT_FLAG = HCAnnexShift(pAnnexID), 'HCGetAnnexY1 called with an ID not in the Loadouts/Y1 Annex');
  if (fVerSaveGame >= $34803210) then
  begin
    // ALE 20160509 2015.021+ We have 4096 items per annex
    IdAnnexOffset := HCdisk_id_to_annex_offset(pAnnexId);
    result := PHCAnnexY1_disk(fPAnnexData^.PY1_DISK_PTR_LIST + IdAnnexOffset);
  end
  else if (fVerInterface >= 12) then
  begin
    // ALE 20160509 2015.014+ Annex data available to ExportDLL Interface
    if (True = HCIsDisk(pAnnexID)) then
    begin
      IdAnnexOffset := HCdisk_id_to_annex_offset(pAnnexId);
      result := PHCAnnexY1_disk(fPAnnexData^.PY1_DISK_PTR_LIST + IdAnnexOffset);
    end
    else
    begin
      // ALE 20160509 Memory Annex ID
      IdDisk := fPHCannex_id_to_disk_id(pAnnexID);
      IdAnnexOffset := HCdisk_id_to_annex_offset(IdDisk);
      Assert(IdAnnexOffset < fPAnnexData^.AnnexDiskRecCount[LOADOUT_FLAG], 'HCGetAnnexY1 Annex ID out of range');
      result := PHCAnnexY1_disk(fPAnnexData^.PY1_DISK_PTR_LIST + IdAnnexOffset);
    end;
  end
  else
  begin
    // ALE 20160509 HC version is too old for this DLL
    Assert(fVerInterface >= 12, 'HC build is too old for this ExportDLL');
    result := nil;
  end;
end;

function THCAnnexHelper.HCGetAnnexZ1(pAnnexID: ID): PHCAnnexZ1_disk;
var
  IdDisk: ID;
  IdAnnexOffset: ID;
begin
  Assert(MOUNT_FLAG = HCAnnexShift(pAnnexID), 'HCGetAnnexZ1 called with an ID not in the Mounts/Z1 Annex');
  if (fVerSaveGame >= $34803210) then
  begin
    // ALE 20160509 2015.021+ We have 4096 items per annex
    IdAnnexOffset := HCdisk_id_to_annex_offset(pAnnexId);
    result := PHCAnnexZ1_disk(fPAnnexData^.PZ1_DISK_PTR_LIST + IdAnnexOffset);
  end
  else if (fVerInterface >= 12) then
  begin
    // ALE 20160509 2015.014+ Annex data available to ExportDLL Interface
    if (True = HCIsDisk(pAnnexID)) then
    begin
      IdAnnexOffset := HCdisk_id_to_annex_offset(pAnnexId);
      result := PHCAnnexZ1_disk(fPAnnexData^.PZ1_DISK_PTR_LIST + IdAnnexOffset);
    end
    else
    begin
      // ALE 20160509 Memory Annex ID
      IdDisk := fPHCannex_id_to_disk_id(pAnnexID);
      IdAnnexOffset := HCdisk_id_to_annex_offset(IdDisk);
      Assert(IdAnnexOffset < fPAnnexData^.AnnexDiskRecCount[MOUNT_FLAG], 'HCGetAnnexZ1 Annex ID out of range');
      result := PHCAnnexZ1_disk(fPAnnexData^.PZ1_DISK_PTR_LIST + IdAnnexOffset);
    end;
  end
  else
  begin
    // ALE 20160509 HC version is too old for this DLL
    Assert(fVerInterface >= 12, 'HC build is too old for this ExportDLL');
    result := nil;
  end;
end;

function THCAnnexHelper.HCGetAnnexZ2(pAnnexID: ID): PHCAnnexZ2_disk;
var
  IdDisk: ID;
  IdAnnexOffset: ID;
begin
  Assert(MULTI_FLAG = HCAnnexShift(pAnnexID), 'HCGetAnnexZ2 called with an ID not in the MultiMounts/Z2 Annex');
  if (fVerSaveGame >= $34803210) then
  begin
    // ALE 20160509 2015.021+ We have 4096 items per annex
    IdAnnexOffset := HCdisk_id_to_annex_offset(pAnnexId);
    result := PHCAnnexZ2_disk(fPAnnexData^.PZ2_DISK_PTR_LIST + IdAnnexOffset);
  end
  else if (fVerInterface >= 12) then
  begin
    // ALE 20160509 2015.014+ Annex data available to ExportDLL Interface
    if (True = HCIsDisk(pAnnexID)) then
    begin
      IdAnnexOffset := HCdisk_id_to_annex_offset(pAnnexId);
      result := PHCAnnexZ2_disk(fPAnnexData^.PZ2_DISK_PTR_LIST + IdAnnexOffset);
    end
    else
    begin
      // ALE 20160509 Memory Annex ID
      IdDisk := fPHCannex_id_to_disk_id(pAnnexID);
      IdAnnexOffset := HCdisk_id_to_annex_offset(IdDisk);
      Assert(IdAnnexOffset < fPAnnexData^.AnnexDiskRecCount[MULTI_FLAG], 'HCGetAnnexZ2 Annex ID out of range');
      result := PHCAnnexZ2_disk(fPAnnexData^.PZ2_DISK_PTR_LIST + IdAnnexOffset);
    end;
  end
  else
  begin
    // ALE 20160509 HC version is too old for this DLL
    Assert(fVerInterface >= 12, 'HC build is too old for this ExportDLL');
    result := nil;
  end;
end;

end.