writeByte(fp, (uint8)(value >> 24));

writeByte(fp, (uint8)((value >> 16) & 0xFF));

writeByte(fp, (uint8)((value >> 8) & 0xFF));

writeByte(fp, (uint8)(value & 0xFF));

FILE *outFile;

int i;

int nbrElem, nbrSubElem;

outFile = fopen("hugo.dat", "wb");

// Write header

fwrite("HUGO", 4, 1, outFile);

writeByte(outFile, HUGO_DAT_VER_MAJ);

writeByte(outFile, HUGO_DAT_VER_MIN);

// game versions/variantes

writeUint16BE(outFile, NUM_VARIANTE);

// Write palette

writeUint16BE(outFile, SIZE_PAL_ARRAY);

for (i = 0; i < SIZE_PAL_ARRAY; i++) {

writeByte(outFile, _palette[i]);

}

// Write textData

// textData_1w

nbrElem = sizeof(textData_1w) / sizeof(char *);

writeTextArray(outFile, textData_1w, nbrElem);

// textData_2w

nbrElem = sizeof(textData_2w) / sizeof(char *);

writeTextArray(outFile, textData_2w, nbrElem);

// textData_3w

nbrElem = sizeof(textData_3w) / sizeof(char *);

writeTextArray(outFile, textData_3w, nbrElem);

// textData_1d

nbrElem = sizeof(textData_1d) / sizeof(char *);

writeTextArray(outFile, textData_1d, nbrElem);

// textData_2d

nbrElem = sizeof(textData_2d) / sizeof(char *);

writeTextArray(outFile, textData_2d, nbrElem);

// textData_3d

nbrElem = sizeof(textData_3d) / sizeof(char *);

writeTextArray(outFile, textData_3d, nbrElem);

// Write string_t_Data

// string_t_Data_1w

nbrElem = sizeof(string_t_Data_1w) / sizeof(char *);

writeTextArray(outFile, string_t_Data_1w, nbrElem);

// string_t_Data_2w

nbrElem = sizeof(string_t_Data_2w) / sizeof(char *);

writeTextArray(outFile, string_t_Data_2w, nbrElem);

// string_t_Data_3w

nbrElem = sizeof(string_t_Data_3w) / sizeof(char *);

writeTextArray(outFile, string_t_Data_3w, nbrElem);

// string_t_Data_1d

nbrElem = sizeof(string_t_Data_1d) / sizeof(char *);

writeTextArray(outFile, string_t_Data_1d, nbrElem);

// string_t_Data_2d

nbrElem = sizeof(string_t_Data_2d) / sizeof(char *);

writeTextArray(outFile, string_t_Data_2d, nbrElem);

// string_t_Data_3d

nbrElem = sizeof(string_t_Data_3d) / sizeof(char *);

writeTextArray(outFile, string_t_Data_3d, nbrElem);

// arrayNouns_1w

nbrElem = sizeof(arrayNouns_1w) / sizeof(char **);

writeUint16BE(outFile, nbrElem);

for (int j = 0; j < nbrElem; j++) {

for (nbrSubElem = 1; strcmp(arrayNouns_1w[j][nbrSubElem], ""); nbrSubElem++)

;

nbrSubElem++;

writeTextArray(outFile, arrayNouns_1w[j], nbrSubElem);

}

// arrayNouns_2w

nbrElem = sizeof(arrayNouns_2w) / sizeof(char **);

writeUint16BE(outFile, nbrElem);

for (int j = 0; j < nbrElem; j++) {

for (nbrSubElem = 1; strcmp(arrayNouns_2w[j][nbrSubElem], ""); nbrSubElem++)

;

nbrSubElem++;

writeTextArray(outFile, arrayNouns_2w[j], nbrSubElem);

}

// arrayNouns_3w

nbrElem = sizeof(arrayNouns_3w) / sizeof(char **);

writeUint16BE(outFile, nbrElem);

for (int j = 0; j < nbrElem; j++) {

for (nbrSubElem = 1; strcmp(arrayNouns_3w[j][nbrSubElem], ""); nbrSubElem++)

;

nbrSubElem++;

writeTextArray(outFile, arrayNouns_3w[j], nbrSubElem);

}

// arrayNouns_1d

nbrElem = sizeof(arrayNouns_1d) / sizeof(char **);

writeUint16BE(outFile, nbrElem);

for (int j = 0; j < nbrElem; j++) {

for (nbrSubElem = 1; strcmp(arrayNouns_1d[j][nbrSubElem], ""); nbrSubElem++)

;

nbrSubElem++;

writeTextArray(outFile, arrayNouns_1d[j], nbrSubElem);

}

// arrayNouns_2d

nbrElem = sizeof(arrayNouns_2d) / sizeof(char **);

writeUint16BE(outFile, nbrElem);

for (int j = 0; j < nbrElem; j++) {

for (nbrSubElem = 1; strcmp(arrayNouns_2d[j][nbrSubElem], ""); nbrSubElem++)

;

nbrSubElem++;

writeTextArray(outFile, arrayNouns_2d[j], nbrSubElem);

}

// arrayNouns_3d

nbrElem = sizeof(arrayNouns_3d) / sizeof(char **);

writeUint16BE(outFile, nbrElem);

for (int j = 0; j < nbrElem; j++) {

for (nbrSubElem = 1; strcmp(arrayNouns_3d[j][nbrSubElem], ""); nbrSubElem++)

;

nbrSubElem++;

writeTextArray(outFile, arrayNouns_3d[j], nbrSubElem);

}

// arrayVerbs_1w

nbrElem = sizeof(arrayVerbs_1w) / sizeof(char **);

writeUint16BE(outFile, nbrElem);

for (int j = 0; j < nbrElem; j++) {

for (nbrSubElem = 1; strcmp(arrayVerbs_1w[j][nbrSubElem], ""); nbrSubElem++)

;

nbrSubElem++;

writeTextArray(outFile, arrayVerbs_1w[j], nbrSubElem);

}

// arrayVerbs_2w

nbrElem = sizeof(arrayVerbs_2w) / sizeof(char **);

writeUint16BE(outFile, nbrElem);

for (int j = 0; j < nbrElem; j++) {

for (nbrSubElem = 1; strcmp(arrayVerbs_2w[j][nbrSubElem], ""); nbrSubElem++)

;

nbrSubElem++;

writeTextArray(outFile, arrayVerbs_2w[j], nbrSubElem);

}

// arrayVerbs_3w

nbrElem = sizeof(arrayVerbs_3w) / sizeof(char **);

writeUint16BE(outFile, nbrElem);

for (int j = 0; j < nbrElem; j++) {

for (nbrSubElem = 1; strcmp(arrayVerbs_3w[j][nbrSubElem], ""); nbrSubElem++)

;

nbrSubElem++;

writeTextArray(outFile, arrayVerbs_3w[j], nbrSubElem);

}

// arrayVerbs_1d

nbrElem = sizeof(arrayVerbs_1d) / sizeof(char **);

writeUint16BE(outFile, nbrElem);

for (int j = 0; j < nbrElem; j++) {

for (nbrSubElem = 1; strcmp(arrayVerbs_1d[j][nbrSubElem], ""); nbrSubElem++)

;

nbrSubElem++;

writeTextArray(outFile, arrayVerbs_1d[j], nbrSubElem);

}

// arrayVerbs_2d

nbrElem = sizeof(arrayVerbs_2d) / sizeof(char **);

writeUint16BE(outFile, nbrElem);

for (int j = 0; j < nbrElem; j++) {

for (nbrSubElem = 1; strcmp(arrayVerbs_2d[j][nbrSubElem], ""); nbrSubElem++)

;

nbrSubElem++;

writeTextArray(outFile, arrayVerbs_2d[j], nbrSubElem);

}

// arrayVerbs_3d

nbrElem = sizeof(arrayVerbs_3d) / sizeof(char **);

writeUint16BE(outFile, nbrElem);

for (int j = 0; j < nbrElem; j++) {

for (nbrSubElem = 1; strcmp(arrayVerbs_3d[j][nbrSubElem], ""); nbrSubElem++)

;

nbrSubElem++;

writeTextArray(outFile, arrayVerbs_3d[j], nbrSubElem);

}

// Write screenNames

// screenNames_1w

nbrElem = sizeof(screenNames_1w) / sizeof(char *);

writeTextArray(outFile, screenNames_1w, nbrElem);

// screenNames_2w

nbrElem = sizeof(screenNames_2w) / sizeof(char *);

writeTextArray(outFile, screenNames_2w, nbrElem);

// screenNames_3w

nbrElem = sizeof(screenNames_3w) / sizeof(char *);

writeTextArray(outFile, screenNames_3w, nbrElem);

// screenNames_1d

nbrElem = sizeof(screenNames_1d) / sizeof(char *);

writeTextArray(outFile, screenNames_1d, nbrElem);

// screenNames_2d

nbrElem = sizeof(screenNames_2d) / sizeof(char *);

writeTextArray(outFile, screenNames_2d, nbrElem);

// screenNames_3d

nbrElem = sizeof(screenNames_3d) / sizeof(char *);

writeTextArray(outFile, screenNames_3d, nbrElem);

// Write textEngine

writeTextArray(outFile, textEngine, NUM_ENGINE_TEXT);

// Write textIntro

writeTextArray(outFile, textIntro_dummy, NUM_INTRO_TEXT_DUMMY);

writeTextArray(outFile, textIntro_dummy, NUM_INTRO_TEXT_DUMMY);

writeTextArray(outFile, textIntro_v3, NUM_INTRO_TEXT_V3);

writeTextArray(outFile, textIntro_dummy, NUM_INTRO_TEXT_DUMMY);

writeTextArray(outFile, textIntro_dummy, NUM_INTRO_TEXT_DUMMY);

writeTextArray(outFile, textIntro_v3, NUM_INTRO_TEXT_V3);

// Write textMouse

writeTextArray(outFile, textMouse, NUM_MOUSE_TEXT);

// Write textParser

writeTextArray(outFile, textParser, NUM_PARSER_TEXT);

// Write textUtil

writeTextArray(outFile, textUtil_v1w, NUM_UTIL_TEXT);

writeTextArray(outFile, textUtil_v1w, NUM_UTIL_TEXT);

writeTextArray(outFile, textUtil_v1w, NUM_UTIL_TEXT);

writeTextArray(outFile, textUtil_v1d, NUM_UTIL_TEXT);

writeTextArray(outFile, textUtil_v1d, NUM_UTIL_TEXT);

writeTextArray(outFile, textUtil_v1d, NUM_UTIL_TEXT);

// Write x_intro and y_intro

writeUint16BE(outFile, NUM_INTRO_TICK_DUMMY);

for (i = 0; i < NUM_INTRO_TICK_DUMMY; i++) {

writeByte(outFile, x_intro_dummy[i]);

writeByte(outFile, y_intro_dummy[i]);

}

writeUint16BE(outFile, NUM_INTRO_TICK_DUMMY);

for (i = 0; i < NUM_INTRO_TICK_DUMMY; i++) {

writeByte(outFile, x_intro_dummy[i]);

writeByte(outFile, y_intro_dummy[i]);

}

writeUint16BE(outFile, NUM_INTRO_TICK_V3);

for (i = 0; i < NUM_INTRO_TICK_V3; i++) {

writeByte(outFile, x_intro_v3[i]);

writeByte(outFile, y_intro_v3[i]);

}

writeUint16BE(outFile, NUM_INTRO_TICK_V1D);

for (i = 0; i < NUM_INTRO_TICK_V1D; i++) {

writeByte(outFile, x_intro_v1d[i]);

writeByte(outFile, y_intro_v1d[i]);

}

writeUint16BE(outFile, NUM_INTRO_TICK_DUMMY);

for (i = 0; i < NUM_INTRO_TICK_DUMMY; i++) {

writeByte(outFile, x_intro_dummy[i]);

writeByte(outFile, y_intro_dummy[i]);

}

writeUint16BE(outFile, NUM_INTRO_TICK_V3);

for (i = 0; i < NUM_INTRO_TICK_V3; i++) {

writeByte(outFile, x_intro_v3[i]);

writeByte(outFile, y_intro_v3[i]);

}

nbrElem = sizeof(logo_intro_v1d) / sizeof(byte);

writeUint16BE(outFile, nbrElem);

for (i = 0; i < nbrElem; i++) {

writeByte(outFile, logo_intro_v1d[i]);

}

// arrayReqs_1w

nbrElem = sizeof(arrayReqs_1w) / sizeof(uint16 *);

writeUint16Array(outFile, arrayReqs_1w, nbrElem);

// arrayReqs_2w

nbrElem = sizeof(arrayReqs_2w) / sizeof(uint16 *);

writeUint16Array(outFile, arrayReqs_2w, nbrElem);

// arrayReqs_3w

nbrElem = sizeof(arrayReqs_3w) / sizeof(uint16 *);

writeUint16Array(outFile, arrayReqs_3w, nbrElem);

// arrayReqs_1d

nbrElem = sizeof(arrayReqs_1d) / sizeof(uint16 *);

writeUint16Array(outFile, arrayReqs_1d, nbrElem);

// arrayReqs_2d

nbrElem = sizeof(arrayReqs_2d) / sizeof(uint16 *);

writeUint16Array(outFile, arrayReqs_2d, nbrElem);

// arrayReqs_3d

nbrElem = sizeof(arrayReqs_3d) / sizeof(uint16 *);

writeUint16Array(outFile, arrayReqs_3d, nbrElem);

// catchall_1w

nbrElem = sizeof(catchall_1w) / sizeof(background_t);

writeBackgroundArray(outFile, catchall_1w, nbrElem);

// catchall_2w

nbrElem = sizeof(catchall_2w) / sizeof(background_t);

writeBackgroundArray(outFile, catchall_2w, nbrElem);

// catchall_3w

nbrElem = sizeof(catchall_3w) / sizeof(background_t);

writeBackgroundArray(outFile, catchall_3w, nbrElem);

// catchall_1d

nbrElem = sizeof(catchall_1d) / sizeof(background_t);

writeBackgroundArray(outFile, catchall_1d, nbrElem);

// catchall_2d

nbrElem = sizeof(catchall_2d) / sizeof(background_t);

writeBackgroundArray(outFile, catchall_2d, nbrElem);

// catchall_3d

nbrElem = sizeof(catchall_3d) / sizeof(background_t);

writeBackgroundArray(outFile, catchall_3d, nbrElem);

// backgroundList_1w

nbrElem = sizeof(backgroundList_1w) / sizeof(background_t *);

writeUint16BE(outFile, nbrElem);

for (int j = 0; j < nbrElem; j++) {

nbrSubElem = 1;

for (int k = 0; backgroundList_1w[j][k].verbIndex != 0; k++)

nbrSubElem ++;

writeBackgroundArray(outFile, backgroundList_1w[j], nbrSubElem);

}

// backgroundList_2w

nbrElem = sizeof(backgroundList_2w) / sizeof(background_t *);

writeUint16BE(outFile, nbrElem);

for (int j = 0; j < nbrElem; j++) {

nbrSubElem = 1;

for (int k = 0; backgroundList_2w[j][k].verbIndex != 0; k++)

nbrSubElem ++;

writeBackgroundArray(outFile, backgroundList_2w[j], nbrSubElem);

}

// backgroundList_3w

nbrElem = sizeof(backgroundList_3w) / sizeof(background_t *);

writeUint16BE(outFile, nbrElem);

for (int j = 0; j < nbrElem; j++) {

nbrSubElem = 1;

for (int k = 0; backgroundList_3w[j][k].verbIndex != 0; k++)

nbrSubElem ++;

writeBackgroundArray(outFile, backgroundList_3w[j], nbrSubElem);

}

// backgroundList_1d

nbrElem = sizeof(backgroundList_1d) / sizeof(background_t *);

writeUint16BE(outFile, nbrElem);

for (int j = 0; j < nbrElem; j++) {

nbrSubElem = 1;

for (int k = 0; backgroundList_1d[j][k].verbIndex != 0; k++)

nbrSubElem ++;

writeBackgroundArray(outFile, backgroundList_1d[j], nbrSubElem);

}

// backgroundList_2d

nbrElem = sizeof(backgroundList_2d) / sizeof(background_t *);

writeUint16BE(outFile, nbrElem);

for (int j = 0; j < nbrElem; j++) {

nbrSubElem = 1;

for (int k = 0; backgroundList_2d[j][k].verbIndex != 0; k++)

nbrSubElem ++;

writeBackgroundArray(outFile, backgroundList_2d[j], nbrSubElem);

}

// backgroundList_3d

nbrElem = sizeof(backgroundList_3d) / sizeof(background_t *);

writeUint16BE(outFile, nbrElem);

for (int j = 0; j < nbrElem; j++) {

nbrSubElem = 1;

for (int k = 0; backgroundList_3d[j][k].verbIndex != 0; k++)

nbrSubElem ++;

writeBackgroundArray(outFile, backgroundList_3d[j], nbrSubElem);

}

// cmdList_1w

nbrElem = sizeof(cmdList_1w) / sizeof(cmd **);

writeCmdArray(outFile, cmdList_1w, nbrElem);

// cmdList_2w

nbrElem = sizeof(cmdList_2w) / sizeof(cmd **);

writeCmdArray(outFile, cmdList_2w, nbrElem);

// cmdList_3w

nbrElem = sizeof(cmdList_3w) / sizeof(cmd **);

writeCmdArray(outFile, cmdList_3w, nbrElem);

// cmdList_1d

nbrElem = sizeof(cmdList_1d) / sizeof(cmd **);

writeCmdArray(outFile, cmdList_1d, nbrElem);

// cmdList_2d

nbrElem = sizeof(cmdList_2d) / sizeof(cmd **);

writeCmdArray(outFile, cmdList_2d, nbrElem);

// cmdList_3d

nbrElem = sizeof(cmdList_3d) / sizeof(cmd **);

writeCmdArray(outFile, cmdList_3d, nbrElem);

// hotspots_1w

nbrElem = sizeof(hotspots_1w) / sizeof(hotspot_t);

writeHotspot(outFile, hotspots_1w, nbrElem);

// hotspots_2w

nbrElem = sizeof(hotspots_2w) / sizeof(hotspot_t);

writeHotspot(outFile, hotspots_2w, nbrElem);

// hotspots_3w

nbrElem = sizeof(hotspots_3w) / sizeof(hotspot_t);

writeHotspot(outFile, hotspots_3w, nbrElem);

// hotspots_1d

nbrElem = sizeof(hotspots_1d) / sizeof(hotspot_t);

writeHotspot(outFile, hotspots_1d, nbrElem);

// hotspots_2d

nbrElem = sizeof(hotspots_2d) / sizeof(hotspot_t);

writeHotspot(outFile, hotspots_2d, nbrElem);

// hotspots_3d

nbrElem = sizeof(hotspots_3d) / sizeof(hotspot_t);

writeHotspot(outFile, hotspots_3d, nbrElem);

// invent_1w

nbrElem = sizeof(invent_1w) / sizeof(int16);

writeUint16BE(outFile, nbrElem);

for (int j = 0; j < nbrElem; j++)

writeSint16BE(outFile, invent_1w[j]);

// invent_2w

nbrElem = sizeof(invent_2w) / sizeof(int16);

writeUint16BE(outFile, nbrElem);

for (int j = 0; j < nbrElem; j++)

writeSint16BE(outFile, invent_2w[j]);

// invent_3w

nbrElem = sizeof(invent_3w) / sizeof(int16);

writeUint16BE(outFile, nbrElem);

for (int j = 0; j < nbrElem; j++)

writeSint16BE(outFile, invent_3w[j]);

// invent_1d

nbrElem = sizeof(invent_1d) / sizeof(int16);

writeUint16BE(outFile, nbrElem);

for (int j = 0; j < nbrElem; j++)

writeSint16BE(outFile, invent_1d[j]);

// invent_2d

nbrElem = sizeof(invent_2d) / sizeof(int16);

writeUint16BE(outFile, nbrElem);

for (int j = 0; j < nbrElem; j++)

writeSint16BE(outFile, invent_2d[j]);

// invent_3d

nbrElem = sizeof(invent_3d) / sizeof(int16);

writeUint16BE(outFile, nbrElem);

for (int j = 0; j < nbrElem; j++)

writeSint16BE(outFile, invent_3d[j]);

// uses_1w

nbrElem = sizeof(uses_1w) / sizeof(uses_t);

writeUseArray(outFile, uses_1w, nbrElem);

// uses_2w

nbrElem = sizeof(uses_2w) / sizeof(uses_t);

writeUseArray(outFile, uses_2w, nbrElem);

// uses_3w

nbrElem = sizeof(uses_3w) / sizeof(uses_t);

writeUseArray(outFile, uses_3w, nbrElem);

// uses_1d

nbrElem = sizeof(uses_1d) / sizeof(uses_t);

writeUseArray(outFile, uses_1d, nbrElem);

// uses_2d

nbrElem = sizeof(uses_2d) / sizeof(uses_t);

writeUseArray(outFile, uses_2d, nbrElem);

// uses_3d

nbrElem = sizeof(uses_3d) / sizeof(uses_t);

writeUseArray(outFile, uses_3d, nbrElem);

// objects_1w

nbrElem = sizeof(objects_1w) / sizeof(object_t);

writeObjectArray(outFile, objects_1w, nbrElem);

// objects_2w

nbrElem = sizeof(objects_2w) / sizeof(object_t);

writeObjectArray(outFile, objects_2w, nbrElem);

// objects_3w

nbrElem = sizeof(objects_3w) / sizeof(object_t);

writeObjectArray(outFile, objects_3w, nbrElem);

// objects_1d

nbrElem = sizeof(objects_1d) / sizeof(object_t);

writeObjectArray(outFile, objects_1d, nbrElem);

// objects_2d

nbrElem = sizeof(objects_2d) / sizeof(object_t);

writeObjectArray(outFile, objects_2d, nbrElem);

// objects_3d

nbrElem = sizeof(objects_3d) / sizeof(object_t);

writeObjectArray(outFile, objects_3d, nbrElem);

// Save LASTOBJ

writeUint16BE(outFile, LASTOBJ_1w);

writeUint16BE(outFile, LASTOBJ_2w);

writeUint16BE(outFile, LASTOBJ_3w);

writeUint16BE(outFile, LASTOBJ_1d); //(not set in original, as Hugo1 DOS doesn't use a DAT file to pack the screens)

writeUint16BE(outFile, LASTOBJ_2d);

writeUint16BE(outFile, LASTOBJ_3d);

// points_1w

nbrElem = sizeof(points_1w) / sizeof(byte);

writeUint16BE(outFile, nbrElem);

for (int j = 0; j < nbrElem; j++)

writeByte(outFile, points_1w[j]);

// points_2w

nbrElem = sizeof(points_2w) / sizeof(byte);

writeUint16BE(outFile, nbrElem);

for (int j = 0; j < nbrElem; j++)

writeByte(outFile, points_2w[j]);

// points_3w

nbrElem = sizeof(points_3w) / sizeof(byte);

writeUint16BE(outFile, nbrElem);

for (int j = 0; j < nbrElem; j++)

writeByte(outFile, points_3w[j]);

// points_1d

nbrElem = sizeof(points_1d) / sizeof(byte);

writeUint16BE(outFile, nbrElem);

for (int j = 0; j < nbrElem; j++)

writeByte(outFile, points_1d[j]);

// points_2d

nbrElem = sizeof(points_2d) / sizeof(byte);

writeUint16BE(outFile, nbrElem);

for (int j = 0; j < nbrElem; j++)

writeByte(outFile, points_2d[j]);

// points_3d

nbrElem = sizeof(points_3d) / sizeof(byte);

writeUint16BE(outFile, nbrElem);

for (int j = 0; j < nbrElem; j++)

writeByte(outFile, points_3d[j]);

// screenActs_1w

nbrElem = sizeof(screenActs_1w) / sizeof(uint16 *);

writeScreenActs(outFile, screenActs_1w, nbrElem);

// screenActs_2w

nbrElem = sizeof(screenActs_2w) / sizeof(uint16 *);

writeScreenActs(outFile, screenActs_2w, nbrElem);

// screenActs_3w

nbrElem = sizeof(screenActs_3w) / sizeof(uint16 *);

writeScreenActs(outFile, screenActs_3w, nbrElem);

// screenActs_1d

nbrElem = sizeof(screenActs_1d) / sizeof(uint16 *);

writeScreenActs(outFile, screenActs_1d, nbrElem);

// screenActs_2d

nbrElem = sizeof(screenActs_2d) / sizeof(uint16 *);

writeScreenActs(outFile, screenActs_2d, nbrElem);

// screenActs_3d

nbrElem = sizeof(screenActs_3d) / sizeof(uint16 *);

writeScreenActs(outFile, screenActs_3d, nbrElem);

// actlistArr_1w

nbrElem = sizeof(actListArr_1w) / sizeof(actList);

writeActListArray(outFile, actListArr_1w, nbrElem);

// actlistArr_2w

nbrElem = sizeof(actListArr_2w) / sizeof(actList);

writeActListArray(outFile, actListArr_2w, nbrElem);

// actlistArr_3w

nbrElem = sizeof(actListArr_3w) / sizeof(actList);

writeActListArray(outFile, actListArr_3w, nbrElem);

// actlistArr_1d

nbrElem = sizeof(actListArr_1d) / sizeof(actList);

writeActListArray(outFile, actListArr_1d, nbrElem);

// actlistArr_2d

nbrElem = sizeof(actListArr_2d) / sizeof(actList);

writeActListArray(outFile, actListArr_2d, nbrElem);

// actlistArr_3d

nbrElem = sizeof(actListArr_3d) / sizeof(actList);

writeActListArray(outFile, actListArr_3d, nbrElem);

// Maze ALnewscr

writeUint16BE(outFile, 0);

writeUint16BE(outFile, kALnewscr_2w);

writeUint16BE(outFile, 0);

writeUint16BE(outFile, 0);

writeUint16BE(outFile, kALnewscr_2d);

writeUint16BE(outFile, 0);

writeSByte(outFile, NUM_TUNES_1w);

writeSByte(outFile, SILENCE_1w);

writeSByte(outFile, TEST_SOUND_1w);

writeSByte(outFile, NUM_TUNES_2w);

writeSByte(outFile, SILENCE_2w);

writeSByte(outFile, TEST_SOUND_2w);

writeSByte(outFile, NUM_TUNES_3w);

writeSByte(outFile, SILENCE_3w);

writeSByte(outFile, TEST_SOUND_3w);

writeSByte(outFile, NUM_TUNES_1d);

writeSByte(outFile, SILENCE_1d);

writeSByte(outFile, TEST_SOUND_1d);

writeSByte(outFile, NUM_TUNES_2d);

writeSByte(outFile, SILENCE_2d);

writeSByte(outFile, TEST_SOUND_2d);

writeSByte(outFile, NUM_TUNES_3d);

writeSByte(outFile, SILENCE_3d);

writeSByte(outFile, TEST_SOUND_3d);

// def_tunes_1w

nbrElem = sizeof(def_tunes_1w) / sizeof(int16);

writeUint16BE(outFile, nbrElem);

for (int j = 0; j < nbrElem; j++)

writeSint16BE(outFile, def_tunes_1w[j]);

// def_tunes_2w

nbrElem = sizeof(def_tunes_2w) / sizeof(int16);

writeUint16BE(outFile, nbrElem);

for (int j = 0; j < nbrElem; j++)

writeSint16BE(outFile, def_tunes_2w[j]);

// def_tunes_3w

nbrElem = sizeof(def_tunes_3w) / sizeof(int16);

writeUint16BE(outFile, nbrElem);

for (int j = 0; j < nbrElem; j++)

writeSint16BE(outFile, def_tunes_3w[j]);

// def_tunes_1d

nbrElem = sizeof(def_tunes_1d) / sizeof(int16);

writeUint16BE(outFile, nbrElem);

for (int j = 0; j < nbrElem; j++)

writeSint16BE(outFile, def_tunes_1d[j]);

// def_tunes_2d

nbrElem = sizeof(def_tunes_2d) / sizeof(int16);

writeUint16BE(outFile, nbrElem);

for (int j = 0; j < nbrElem; j++)

writeSint16BE(outFile, def_tunes_2d[j]);

// def_tunes_3d

nbrElem = sizeof(def_tunes_3d) / sizeof(int16);

writeUint16BE(outFile, nbrElem);

for (int j = 0; j < nbrElem; j++)

writeSint16BE(outFile, def_tunes_3d[j]);

// Save _screnStates array size

writeUint16BE(outFile, LASTOBJ_1w);

writeUint16BE(outFile, LASTOBJ_2w);

writeUint16BE(outFile, NUM_PICS_3w);

writeUint16BE(outFile, NUM_PICS_1d); //(not set in original, as Hugo1 DOS doesn't use a DAT file to pack the screens)

writeUint16BE(outFile, LASTOBJ_2d);

writeUint16BE(outFile, NUM_PICS_3d);

// Save Look, Take and Drop constants

writeUint16BE(outFile, kVLook_1w);

writeUint16BE(outFile, kVTake_1w);

writeUint16BE(outFile, kVDrop_1w);

writeUint16BE(outFile, kVLook_2w);

writeUint16BE(outFile, kVTake_2w);

writeUint16BE(outFile, kVDrop_2w);

writeUint16BE(outFile, kVLook_3w);

writeUint16BE(outFile, kVTake_3w);

writeUint16BE(outFile, kVDrop_3w);

writeUint16BE(outFile, kVLook_1d);

writeUint16BE(outFile, kVTake_1d);

writeUint16BE(outFile, kVDrop_1d);

writeUint16BE(outFile, kVLook_2d);

writeUint16BE(outFile, kVTake_2d);

writeUint16BE(outFile, kVDrop_2d);

writeUint16BE(outFile, kVLook_3d);

writeUint16BE(outFile, kVTake_3d);

writeUint16BE(outFile, kVDrop_3d);

// DOS Intro music

// Win version do not use it

// H1 Dos doesn't have an intro

// H2 Dos handles the intro song in its scripts

writeUint16BE(outFile, 0);

writeUint16BE(outFile, 0);

writeUint16BE(outFile, 0);

writeUint16BE(outFile, 0);

writeUint16BE(outFile, 0);

writeUint16BE(outFile, kDTsong11_3d);

//bitmap images for menu

writeUint16BE(outFile, 18);

FILE* src_file;

char buf[2];

src_file = fopen("btn_1.bmp", "rb");

if (src_file == nullptr) {

perror("btn_1.bmp");

fclose(outFile);

return -1;

}

fseek(src_file , 0 , SEEK_END);

nbrElem = ftell(src_file);

writeUint16BE(outFile, nbrElem);

rewind(src_file);

for (int j = 0; j < nbrElem; j++) {

fread(buf, 1, 1, src_file);

writeByte(outFile, buf[0]);

}

fclose(src_file);

src_file = fopen("btn_1_off.bmp", "rb");

if (src_file == nullptr) {

perror("btn_1_off.bmp");

fclose(outFile);

return -1;

}

fseek(src_file , 0 , SEEK_END);

nbrElem = ftell(src_file);

writeUint16BE(outFile, nbrElem);

rewind(src_file);

for (int j = 0; j < nbrElem; j++) {

fread(buf, 1, 1, src_file);

writeByte(outFile, buf[0]);

}

fclose(src_file);

src_file = fopen("btn_2.bmp", "rb");

if (src_file == nullptr) {

perror("btn_2.bmp");

fclose(outFile);

return -1;

}

fseek(src_file , 0 , SEEK_END);

nbrElem = ftell(src_file);

writeUint16BE(outFile, nbrElem);

rewind(src_file);

for (int j = 0; j < nbrElem; j++) {

fread(buf, 1, 1, src_file);

writeByte(outFile, buf[0]);

}

fclose(src_file);

src_file = fopen("btn_2_off.bmp", "rb");

if (src_file == nullptr) {

perror("btn_2_off.bmp");

fclose(outFile);

return -1;

}

fseek(src_file , 0 , SEEK_END);

nbrElem = ftell(src_file);

writeUint16BE(outFile, nbrElem);

rewind(src_file);

for (int j = 0; j < nbrElem; j++) {

fread(buf, 1, 1, src_file);

writeByte(outFile, buf[0]);

}

fclose(src_file);

src_file = fopen("btn_3.bmp", "rb");

if (src_file == nullptr) {

perror("btn_3.bmp");

fclose(outFile);

return -1;

}

fseek(src_file , 0 , SEEK_END);

nbrElem = ftell(src_file);

writeUint16BE(outFile, nbrElem);

rewind(src_file);

for (int j = 0; j < nbrElem; j++) {

fread(buf, 1, 1, src_file);

writeByte(outFile, buf[0]);

}

fclose(src_file);

src_file = fopen("btn_3_off.bmp", "rb");

if (src_file == nullptr) {

perror("btn_3_off.bmp");

fclose(outFile);

return -1;

}

fseek(src_file , 0 , SEEK_END);

nbrElem = ftell(src_file);

writeUint16BE(outFile, nbrElem);

rewind(src_file);

for (int j = 0; j < nbrElem; j++) {

fread(buf, 1, 1, src_file);

writeByte(outFile, buf[0]);

}

fclose(src_file);

src_file = fopen("btn_4.bmp", "rb");

if (src_file == nullptr) {

perror("btn_4.bmp");

fclose(outFile);

return -1;

}

fseek(src_file , 0 , SEEK_END);

nbrElem = ftell(src_file);

writeUint16BE(outFile, nbrElem);

rewind(src_file);

for (int j = 0; j < nbrElem; j++) {

fread(buf, 1, 1, src_file);

writeByte(outFile, buf[0]);

}

fclose(src_file);

src_file = fopen("btn_4_off.bmp", "rb");

if (src_file == nullptr) {

perror("btn_4_off.bmp");

fclose(outFile);

return -1;

}

fseek(src_file , 0 , SEEK_END);

nbrElem = ftell(src_file);

writeUint16BE(outFile, nbrElem);

rewind(src_file);

for (int j = 0; j < nbrElem; j++) {

fread(buf, 1, 1, src_file);

writeByte(outFile, buf[0]);

}

fclose(src_file);

src_file = fopen("btn_5.bmp", "rb");

if (src_file == nullptr) {

perror("btn_5.bmp");

fclose(outFile);

return -1;

}

fseek(src_file , 0 , SEEK_END);

nbrElem = ftell(src_file);

writeUint16BE(outFile, nbrElem);

rewind(src_file);

for (int j = 0; j < nbrElem; j++) {

fread(buf, 1, 1, src_file);

writeByte(outFile, buf[0]);

}

fclose(src_file);

src_file = fopen("btn_5_off.bmp", "rb");

if (src_file == nullptr) {

perror("btn_5_off.bmp");

fclose(outFile);

return -1;

}

fseek(src_file , 0 , SEEK_END);

nbrElem = ftell(src_file);

writeUint16BE(outFile, nbrElem);

rewind(src_file);

for (int j = 0; j < nbrElem; j++) {

fread(buf, 1, 1, src_file);

writeByte(outFile, buf[0]);

}

fclose(src_file);

src_file = fopen("btn_6.bmp", "rb");

if (src_file == nullptr) {

perror("btn_6.bmp");