/* ScummVM - Graphic Adventure Engine
 *
 * ScummVM is the legal property of its developers, whose names
 * are too numerous to list here. Please refer to the COPYRIGHT
 * file distributed with this source distribution.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.

 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.

 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 *
 * $URL: https://scummvm.svn.sourceforge.net/svnroot/scummvm/scummvm/tags/release-1-2-1/tools/create_hugo/create_hugo.cpp $
 * $Id: create_hugo.cpp 52696 2010-09-12 22:54:37Z strangerke $
 *
 * This is a utility for storing all the hardcoded data of Hugo in a separate
 * data file, used by the game engine
 */

// HACK to allow building with the SDL backend on MinGW
// see bug #1800764 "TOOLS: MinGW tools building broken"
#ifdef main
#undef main
#endif // main

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include "common/scummsys.h"
#include "common/events.h"

#include "enums.h"

#include "create_hugo.h"
#include "staticdata.h"
#include "staticdisplay.h"
#include "staticengine.h"
#include "staticintro.h"
#include "staticmouse.h"
#include "staticparser.h"
#include "staticschedule.h"
#include "staticutil.h"
#include "staticfont.h"

static void writeByte(FILE *fp, uint8 b) {
	fwrite(&b, 1, 1, fp);
}

static void writeUint16BE(FILE *fp, uint16 value) {
	writeByte(fp, (uint8)(value >> 8));
	writeByte(fp, (uint8)(value & 0xFF));
}

void writeSint16BE(FILE *fp, int16 value) {
	writeUint16BE(fp, (uint16)value);
}

static void writeUint32BE(FILE *fp, uint32 value) {
	writeByte(fp, (uint8)(value >> 24));
	writeByte(fp, (uint8)((value >> 16) & 0xFF));
	writeByte(fp, (uint8)((value >> 8) & 0xFF));
	writeByte(fp, (uint8)(value & 0xFF));
}

void writeSint32BE(FILE *fp, int32 value) {
	writeUint32BE(fp, (uint16)value);
}

int main(int argc, char *argv[]) {
	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 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 palette
	writeUint16BE(outFile, SIZE_PAL_ARRAY);
	for (i = 0; i < SIZE_PAL_ARRAY; i++) {
		writeByte(outFile, _palette[i]);
	}

	// Write textEngine
	writeTextArray(outFile, textEngine, NUM_ENGINE_TEXT);

	// Write textIntro
	writeTextArray(outFile, textIntro, NUM_INTRO_TEXT);

	// Write x_intro and y_intro
	writeUint16BE(outFile, NUM_INTRO_TICK);
	for (i = 0; i < NUM_INTRO_TICK; i++) {
		writeByte(outFile, x_intro[i]);
		writeByte(outFile, y_intro[i]);
	}

	// Write textMouse
	writeTextArray(outFile, textMouse, NUM_MOUSE_TEXT);

	// Write textParser
	writeTextArray(outFile, textParser, NUM_PARSER_TEXT);

	// Write textSchedule
	writeTextArray(outFile, textSchedule, NUM_SCHEDULE_TEXT);

	// Write textUtil
	writeTextArray(outFile, textUtil, NUM_UTIL_TEXT);

	// 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);

	// 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);

	// 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);
	}

	// 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]);

	// 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);

	// 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);

	// 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);

	// 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);

	writeByte(outFile, NUM_TUNES_1w);
	writeByte(outFile, SILENCE_1w);
	writeByte(outFile, TEST_SOUND_1w);

	writeByte(outFile, NUM_TUNES_2w);
	writeByte(outFile, SILENCE_2w);
	writeByte(outFile, TEST_SOUND_2w);

	writeByte(outFile, NUM_TUNES_3w);
	writeByte(outFile, SILENCE_3w);
	writeByte(outFile, TEST_SOUND_3w);

	writeByte(outFile, NUM_TUNES_1d);
	writeByte(outFile, SILENCE_1d);
	writeByte(outFile, TEST_SOUND_1d);

	writeByte(outFile, NUM_TUNES_2d);
	writeByte(outFile, SILENCE_2d);
	writeByte(outFile, TEST_SOUND_2d);

	writeByte(outFile, NUM_TUNES_3d);
	writeByte(outFile, SILENCE_3d);
	writeByte(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);

	// Save LASTOBJ
	writeUint16BE(outFile, LASTOBJ_1w);
	writeUint16BE(outFile, LASTOBJ_2w);
	writeUint16BE(outFile, LASTOBJ_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, LASTOBJ_3d);

	// Maze ALnewscr
	writeUint16BE(outFile, 0);
	writeUint16BE(outFile, kALnewscr_2w);
	writeUint16BE(outFile, 0);
	writeUint16BE(outFile, 0);
	writeUint16BE(outFile, kALnewscr_2d);
	writeUint16BE(outFile, 0);

	// The following fonts info have been added to avoid temporarly the .FON 
	// used in the DOS version
	// font5
	nbrElem = sizeof(font5) / sizeof(byte);
	writeUint16BE(outFile, nbrElem);

	for (int j = 0; j < nbrElem; j++)
		writeByte(outFile, font5[j]);

	// font6
	nbrElem = sizeof(font6) / sizeof(byte);
	writeUint16BE(outFile, nbrElem);

	for (int j = 0; j < nbrElem; j++)
		writeByte(outFile, font6[j]);

	// font8
	nbrElem = sizeof(font8) / sizeof(byte);
	writeUint16BE(outFile, nbrElem);

	for (int j = 0; j < nbrElem; j++)
		writeByte(outFile, font8[j]);

	fclose(outFile);
	return 0;
}

void writeTextArray(FILE *outFile, const char *textArray[], int nbrText) {
	int len, len1, pad;
	uint8 padBuf[DATAALIGNMENT];

	for (int i = 0; i < DATAALIGNMENT; i++)
		padBuf[i] = 0;

	writeUint16BE(outFile, nbrText);
	len = DATAALIGNMENT - 2;
	for (int i = 0; i < nbrText; i++) {
		len1 = strlen(textArray[i]) + 1;
		pad = DATAALIGNMENT - (len1 + 2) % DATAALIGNMENT;
		len += 2 + len1 + pad;
	}
	writeUint16BE(outFile, len);

	fwrite(padBuf, DATAALIGNMENT - 2, 1, outFile); // padding
	for (int i = 0; i < nbrText; i++) {
		len = strlen(textArray[i]) + 1;
		pad = DATAALIGNMENT - (len + 2) % DATAALIGNMENT;

		writeUint16BE(outFile, len + pad + 2);
		fwrite(textArray[i], len, 1, outFile);
		fwrite(padBuf, pad, 1, outFile);
	}
}

void writeUint16Array(FILE *outFile, const uint16 *uint16Array[], int nbrElem) {
	int nbrSubElem;

	writeUint16BE(outFile, nbrElem);

	for (int j = 0; j < nbrElem; j++) {
		for (nbrSubElem = 1; uint16Array[j][nbrSubElem] != 0; nbrSubElem++)
			;
		nbrSubElem++;
		writeUint16BE(outFile, nbrSubElem);

		for (int i = 0; i < nbrSubElem; i++) {
			writeUint16BE(outFile, uint16Array[j][i]);
		}
	}
}

void writeHotspot(FILE *outFile, const hotspot_t hotspots[], int nbrElem) {
	writeUint16BE(outFile, nbrElem);

	for (int j = 0; j < nbrElem; j++) {
		writeSint16BE(outFile, hotspots[j].screenIndex);
		writeSint16BE(outFile, hotspots[j].x1);
		writeSint16BE(outFile, hotspots[j].y1);
		writeSint16BE(outFile, hotspots[j].x2);
		writeSint16BE(outFile, hotspots[j].y2);
		writeUint16BE(outFile, hotspots[j].actIndex);
		writeSint16BE(outFile, hotspots[j].viewx);
		writeSint16BE(outFile, hotspots[j].viewy);
		writeSint16BE(outFile, hotspots[j].direction);
	}
}

void writeUseArray(FILE *outFile, const uses_t uses[], int nbrElem) {
	int nbrSubElem;
	writeUint16BE(outFile, nbrElem);

	for (int j = 0; j < nbrElem; j++) {
		writeSint16BE(outFile, uses[j].objid);
		writeUint16BE(outFile, uses[j].dataIndex);

		nbrSubElem = sizeof(uses_1w[j].targets) / sizeof(target_t);
		writeUint16BE(outFile, nbrSubElem);
		for (int k = 0; k < nbrSubElem; k++) {
			writeUint16BE(outFile, uses[j].targets[k].nounIndex);
			writeUint16BE(outFile, uses[j].targets[k].verbIndex);
		}
	}
}

void writeBackgroundArray(FILE *outFile, const background_t background[], int nbrElem) {
	writeUint16BE(outFile, nbrElem);

	for (int j = 0; j < nbrElem; j++) {
		writeUint16BE(outFile, background[j].verbIndex);
		writeUint16BE(outFile, background[j].nounIndex);
		writeSint16BE(outFile, background[j].commentIndex);
		writeByte(outFile, (background[j].matchFl) ? 1 : 0);
		writeByte(outFile, background[j].roomState);
		writeByte(outFile, background[j].bonusIndex);
	}
}

void writeCmdArray(FILE *outFile, const cmd *cmdList[], int nbrElem) {
	int nbrSubElem;

	writeUint16BE(outFile, nbrElem);
	for (int i = 0; i < nbrElem; i++) {
		nbrSubElem = 1;
		for (int j = 0; cmdList[i][j].verbIndex != 0; j++)
			nbrSubElem ++;
		writeUint16BE(outFile, nbrSubElem);
		for (int j = 0; j < nbrSubElem; j++) {
			writeUint16BE(outFile, cmdList[i][j].verbIndex);
			writeUint16BE(outFile, cmdList[i][j].reqIndex);
			writeUint16BE(outFile, cmdList[i][j].textDataNoCarryIndex);
			writeByte(outFile, cmdList[i][j].reqstate);
			writeByte(outFile, cmdList[i][j].newstate);
			writeUint16BE(outFile, cmdList[i][j].textDataWrongIndex);
			writeUint16BE(outFile, cmdList[i][j].textDataDoneIndex);
			writeUint16BE(outFile, cmdList[i][j].actIndex);
		}
	}
}

void writeScreenActs(FILE *outFile, const uint16 *screenActs[], int nbrElem) {
	int nbrSubElem;

	writeUint16BE(outFile, nbrElem);
	for (int i = 0; i < nbrElem; i++) {
		if (screenActs[i] == 0)
			writeUint16BE(outFile, 0);
		else {
			nbrSubElem = 1;
			for (int j = 0; screenActs[i][j] != 0; j++)
				nbrSubElem ++;
			writeUint16BE(outFile, nbrSubElem);
			for (int j = 0; j < nbrSubElem; j++)
				writeUint16BE(outFile, screenActs[i][j]);
		}
	}
}

void writeObjectArray(FILE *outFile, const object_t objects[], int nbrElem) {
	int nbrSubElem;

	writeUint16BE(outFile, nbrElem);
	for (int i = 0; i < nbrElem; i++) {
		writeUint16BE(outFile, objects[i].nounIndex);
		writeUint16BE(outFile, objects[i].dataIndex);
		if (objects[i].stateDataIndex == NULL)
			writeUint16BE(outFile, 0);
		else {
			nbrSubElem = 1;
			for (int j = 0; objects[i].stateDataIndex[j] != 0; j++)
				nbrSubElem ++;
			writeUint16BE(outFile, nbrSubElem);
			for (int j = 0; j < nbrSubElem; j++)
				writeUint16BE(outFile, objects[i].stateDataIndex[j]);
		}
		writeSint16BE(outFile, objects[i].pathType);
		writeSint16BE(outFile, objects[i].vxPath);
		writeSint16BE(outFile, objects[i].vyPath);
		writeUint16BE(outFile, objects[i].actIndex);
		writeByte(outFile, objects[i].seqNumb);
// curr_seq_p is skipped: always equal to zero during initialization
		for (int j = 0; j < objects[i].seqNumb; j++)
			writeUint16BE(outFile, objects[i].seqList[j].imageNbr);
// seq_list[].seq_p is always null during initialization, thus skipped
		writeByte(outFile, objects[i].cycling);
		writeByte(outFile, objects[i].cycleNumb);
		writeByte(outFile, objects[i].frameInterval);
		writeByte(outFile, objects[i].frameTimer);
		writeByte(outFile, objects[i].radius);
		writeByte(outFile, objects[i].screenIndex);
		writeSint16BE(outFile, objects[i].x);
		writeSint16BE(outFile, objects[i].y);
		writeSint16BE(outFile, objects[i].oldx);
		writeSint16BE(outFile, objects[i].oldy);
		writeByte(outFile, objects[i].vx);
		writeByte(outFile, objects[i].vy);
		writeByte(outFile, objects[i].objValue);
		writeSint16BE(outFile, objects[i].genericCmd);
		writeUint16BE(outFile, objects[i].cmdIndex);
		writeByte(outFile, (objects[i].carriedFl) ? 1 : 0);
		writeByte(outFile, objects[i].state);
		writeByte(outFile, (objects[i].verbOnlyFl) ? 1 : 0);
		writeByte(outFile, objects[i].priority);
		writeSint16BE(outFile, objects[i].viewx);
		writeSint16BE(outFile, objects[i].viewy);
		writeSint16BE(outFile, objects[i].direction);
		writeByte(outFile, objects[i].curSeqNumb);
		writeByte(outFile, objects[i].curImageNumb);
		writeByte(outFile, objects[i].oldvx);
		writeByte(outFile, objects[i].oldvy);
	}
}

void writeActListArray(FILE *outFile, const actList actListArr[], int nbrElem) {
	int nbrSubElem, nbrCpt;
	byte subElemType;

	writeUint16BE(outFile, nbrElem);
	for (int i = 0; i < nbrElem; i++) {
		for (nbrSubElem = 0; actListArr[i][nbrSubElem] != NULL; nbrSubElem++)
			;
		writeUint16BE(outFile, nbrSubElem);
		for (int j = 0; j < nbrSubElem; j++) {
			subElemType = ((act *) actListArr[i][j])->a0.actType;
			writeByte(outFile, subElemType);
			switch (subElemType) {
			case ANULL: // -1
				break;
			case ASCHEDULE:          // 0
				writeSint16BE(outFile, ((act *) actListArr[i][j])->a0.timer);
				writeUint16BE(outFile, ((act *) actListArr[i][j])->a0.actIndex);
				break;
			case START_OBJ:          // 1
				writeSint16BE(outFile, ((act *) actListArr[i][j])->a1.timer);
				writeSint16BE(outFile, ((act *) actListArr[i][j])->a1.objNumb);
				writeSint16BE(outFile, ((act *) actListArr[i][j])->a1.cycleNumb);
				writeByte(outFile, ((act *) actListArr[i][j])->a1.cycle);
				break;
			case INIT_OBJXY:         // 2
				writeSint16BE(outFile, ((act *) actListArr[i][j])->a2.timer);
				writeSint16BE(outFile, ((act *) actListArr[i][j])->a2.objNumb);
				writeSint16BE(outFile, ((act *) actListArr[i][j])->a2.x);
				writeSint16BE(outFile, ((act *) actListArr[i][j])->a2.y);
				break;
			case PROMPT:             // 3
				writeSint16BE(outFile, ((act *) actListArr[i][j])->a3.timer);
				writeSint16BE(outFile, ((act *) actListArr[i][j])->a3.promptIndex);
				for (nbrCpt = 0; ((act *) actListArr[i][j])->a3.responsePtr[nbrCpt] != -1; nbrCpt++)
					;
				nbrCpt++;
				writeUint16BE(outFile, nbrCpt);
				for (int k = 0; k < nbrCpt; k++)
					writeSint16BE(outFile, ((act *) actListArr[i][j])->a3.responsePtr[k]);
				writeUint16BE(outFile, ((act *) actListArr[i][j])->a3.actPassIndex);
				writeUint16BE(outFile, ((act *) actListArr[i][j])->a3.actFailIndex);
				writeByte(outFile, (((act *) actListArr[i][j])->a3.encoded) ? 1 : 0);
				break;
			case BKGD_COLOR:         // 4
				writeSint16BE(outFile, ((act *) actListArr[i][j])->a4.timer);
				writeUint32BE(outFile, ((act *) actListArr[i][j])->a4.newBkgColor);
				break;
			case INIT_OBJVXY:        // 5
				writeSint16BE(outFile, ((act *) actListArr[i][j])->a5.timer);
				writeSint16BE(outFile, ((act *) actListArr[i][j])->a5.objNumb);
				writeSint16BE(outFile, ((act *) actListArr[i][j])->a5.vx);
				writeSint16BE(outFile, ((act *) actListArr[i][j])->a5.vy);
				break;
			case INIT_CARRY:         // 6
				writeSint16BE(outFile, ((act *) actListArr[i][j])->a6.timer);
				writeSint16BE(outFile, ((act *) actListArr[i][j])->a6.objNumb);
				writeByte(outFile, (((act *) actListArr[i][j])->a6.carriedFl) ? 1 : 0);
				break;
			case INIT_HF_COORD:      // 7
				writeSint16BE(outFile, ((act *) actListArr[i][j])->a7.timer);
				writeSint16BE(outFile, ((act *) actListArr[i][j])->a7.objNumb);
				break;
			case NEW_SCREEN:         // 8
				writeSint16BE(outFile, ((act *) actListArr[i][j])->a8.timer);
				writeSint16BE(outFile, ((act *) actListArr[i][j])->a8.screenIndex);
				break;
			case INIT_OBJSTATE:      // 9
				writeSint16BE(outFile, ((act *) actListArr[i][j])->a9.timer);
				writeSint16BE(outFile, ((act *) actListArr[i][j])->a9.objNumb);
				writeByte(outFile, ((act *) actListArr[i][j])->a9.newState);
				break;
			case INIT_PATH:          // 10
				writeSint16BE(outFile, ((act *) actListArr[i][j])->a10.timer);
				writeSint16BE(outFile, ((act *) actListArr[i][j])->a10.objNumb);
				writeSint16BE(outFile, ((act *) actListArr[i][j])->a10.newPathType);
				writeByte(outFile, ((act *) actListArr[i][j])->a10.vxPath);
				writeByte(outFile, ((act *) actListArr[i][j])->a10.vyPath);
				break;
			case COND_R:             // 11
				writeSint16BE(outFile, ((act *) actListArr[i][j])->a11.timer);
				writeSint16BE(outFile, ((act *) actListArr[i][j])->a11.objNumb);
				writeByte(outFile, ((act *) actListArr[i][j])->a11.stateReq);
				writeUint16BE(outFile, ((act *) actListArr[i][j])->a11.actPassIndex);
				writeUint16BE(outFile, ((act *) actListArr[i][j])->a11.actFailIndex);
				break;
			case TEXT:               // 12
				writeSint16BE(outFile, ((act *) actListArr[i][j])->a12.timer);
				writeSint16BE(outFile, ((act *) actListArr[i][j])->a12.stringIndex);
				break;
			case SWAP_IMAGES:        // 13
				writeSint16BE(outFile, ((act *) actListArr[i][j])->a13.timer);
				writeSint16BE(outFile, ((act *) actListArr[i][j])->a13.obj1);
				writeSint16BE(outFile, ((act *) actListArr[i][j])->a13.obj2);
				break;
			case COND_SCR:           // 14
				writeSint16BE(outFile, ((act *) actListArr[i][j])->a14.timer);
				writeSint16BE(outFile, ((act *) actListArr[i][j])->a14.objNumb);
				writeSint16BE(outFile, ((act *) actListArr[i][j])->a14.screenReq);
				writeUint16BE(outFile, ((act *) actListArr[i][j])->a14.actPassIndex);
				writeUint16BE(outFile, ((act *) actListArr[i][j])->a14.actFailIndex);
				break;
			case AUTOPILOT:          // 15
				writeSint16BE(outFile, ((act *) actListArr[i][j])->a15.timer);
				writeSint16BE(outFile, ((act *) actListArr[i][j])->a15.obj1);
				writeSint16BE(outFile, ((act *) actListArr[i][j])->a15.obj2);
				writeByte(outFile, ((act *) actListArr[i][j])->a15.vx);
				writeByte(outFile, ((act *) actListArr[i][j])->a15.vy);
				break;
			case INIT_OBJ_SEQ:       // 16
				writeSint16BE(outFile, ((act *) actListArr[i][j])->a16.timer);
				writeSint16BE(outFile, ((act *) actListArr[i][j])->a16.objNumb);
				writeSint16BE(outFile, ((act *) actListArr[i][j])->a16.seqIndex);
				break;
			case SET_STATE_BITS:     // 17
				writeSint16BE(outFile, ((act *) actListArr[i][j])->a17.timer);
				writeSint16BE(outFile, ((act *) actListArr[i][j])->a17.objNumb);
				writeSint16BE(outFile, ((act *) actListArr[i][j])->a17.stateMask);
				break;
			case CLEAR_STATE_BITS:   // 18
				writeSint16BE(outFile, ((act *) actListArr[i][j])->a18.timer);
				writeSint16BE(outFile, ((act *) actListArr[i][j])->a18.objNumb);
				writeSint16BE(outFile, ((act *) actListArr[i][j])->a18.stateMask);
				break;
			case TEST_STATE_BITS:    // 19
				writeSint16BE(outFile, ((act *) actListArr[i][j])->a19.timer);
				writeSint16BE(outFile, ((act *) actListArr[i][j])->a19.objNumb);
				writeSint16BE(outFile, ((act *) actListArr[i][j])->a19.stateMask);
				writeUint16BE(outFile, ((act *) actListArr[i][j])->a19.actPassIndex);
				writeUint16BE(outFile, ((act *) actListArr[i][j])->a19.actFailIndex);
				break;
			case DEL_EVENTS:         // 20
				writeSint16BE(outFile, ((act *) actListArr[i][j])->a20.timer);
				writeByte(outFile, ((act *) actListArr[i][j])->a20.actTypeDel);
				break;
			case GAMEOVER:           // 21
				writeSint16BE(outFile, ((act *) actListArr[i][j])->a21.timer);
				break;
			case INIT_HH_COORD:      // 22
				writeSint16BE(outFile, ((act *) actListArr[i][j])->a22.timer);
				writeSint16BE(outFile, ((act *) actListArr[i][j])->a22.objNumb);
				break;
			case EXIT:               // 23
				writeSint16BE(outFile, ((act *) actListArr[i][j])->a23.timer);
				break;
			case BONUS:              // 24
				writeSint16BE(outFile, ((act *) actListArr[i][j])->a24.timer);
				writeSint16BE(outFile, ((act *) actListArr[i][j])->a24.pointIndex);
				break;
			case COND_BOX:           // 25
				writeSint16BE(outFile, ((act *) actListArr[i][j])->a25.timer);
				writeSint16BE(outFile, ((act *) actListArr[i][j])->a25.objNumb);
				writeSint16BE(outFile, ((act *) actListArr[i][j])->a25.x1);
				writeSint16BE(outFile, ((act *) actListArr[i][j])->a25.y1);
				writeSint16BE(outFile, ((act *) actListArr[i][j])->a25.x2);
				writeSint16BE(outFile, ((act *) actListArr[i][j])->a25.y2);
				writeUint16BE(outFile, ((act *) actListArr[i][j])->a25.actPassIndex);
				writeUint16BE(outFile, ((act *) actListArr[i][j])->a25.actFailIndex);
				break;
			case SOUND:              // 26
				writeSint16BE(outFile, ((act *) actListArr[i][j])->a26.timer);
				writeSint16BE(outFile, ((act *) actListArr[i][j])->a26.soundIndex);
				break;
			case ADD_SCORE:          // 27
				writeSint16BE(outFile, ((act *) actListArr[i][j])->a27.timer);
				writeSint16BE(outFile, ((act *) actListArr[i][j])->a27.objNumb);
				break;
			case SUB_SCORE:          // 28
				writeSint16BE(outFile, ((act *) actListArr[i][j])->a28.timer);
				writeSint16BE(outFile, ((act *) actListArr[i][j])->a28.objNumb);
				break;
			case COND_CARRY:         // 29
				writeSint16BE(outFile, ((act *) actListArr[i][j])->a29.timer);
				writeSint16BE(outFile, ((act *) actListArr[i][j])->a29.objNumb);
				writeUint16BE(outFile, ((act *) actListArr[i][j])->a29.actPassIndex);
				writeUint16BE(outFile, ((act *) actListArr[i][j])->a29.actFailIndex);
				break;
			case INIT_MAZE:          // 30
				writeSint16BE(outFile, ((act *) actListArr[i][j])->a30.timer);
				writeByte(outFile, ((act *) actListArr[i][j])->a30.mazeSize);
				writeSint16BE(outFile, ((act *) actListArr[i][j])->a30.x1);
				writeSint16BE(outFile, ((act *) actListArr[i][j])->a30.y1);
				writeSint16BE(outFile, ((act *) actListArr[i][j])->a30.x2);
				writeSint16BE(outFile, ((act *) actListArr[i][j])->a30.y2);
				writeSint16BE(outFile, ((act *) actListArr[i][j])->a30.x3);
				writeSint16BE(outFile, ((act *) actListArr[i][j])->a30.x4);
				writeByte(outFile, ((act *) actListArr[i][j])->a30.firstScreenIndex);
				break;
			case EXIT_MAZE:          // 31
				writeSint16BE(outFile, ((act *) actListArr[i][j])->a31.timer);
				break;
			case INIT_PRIORITY:      // 32
				writeSint16BE(outFile, ((act *) actListArr[i][j])->a32.timer);
				writeSint16BE(outFile, ((act *) actListArr[i][j])->a32.objNumb);
				writeByte(outFile, ((act *) actListArr[i][j])->a32.priority);
				break;
			case INIT_SCREEN:        // 33
				writeSint16BE(outFile, ((act *) actListArr[i][j])->a33.timer);
				writeSint16BE(outFile, ((act *) actListArr[i][j])->a33.objNumb);
				writeSint16BE(outFile, ((act *) actListArr[i][j])->a33.screenIndex);
				break;
			case AGSCHEDULE:         // 34
				writeSint16BE(outFile, ((act *) actListArr[i][j])->a34.timer);
				writeUint16BE(outFile, ((act *) actListArr[i][j])->a34.actIndex);
				break;
			case REMAPPAL:           // 35
				writeSint16BE(outFile, ((act *) actListArr[i][j])->a35.timer);
				writeSint16BE(outFile, ((act *) actListArr[i][j])->a35.oldColorIndex);
				writeSint16BE(outFile, ((act *) actListArr[i][j])->a35.newColorIndex);
				break;
			case COND_NOUN:          // 36
				writeSint16BE(outFile, ((act *) actListArr[i][j])->a36.timer);
				writeUint16BE(outFile, ((act *) actListArr[i][j])->a36.nounIndex);
				writeUint16BE(outFile, ((act *) actListArr[i][j])->a36.actPassIndex);
				writeUint16BE(outFile, ((act *) actListArr[i][j])->a36.actFailIndex);
				break;
			case SCREEN_STATE:       // 37
				writeSint16BE(outFile, ((act *) actListArr[i][j])->a37.timer);
				writeSint16BE(outFile, ((act *) actListArr[i][j])->a37.screenIndex);
				writeByte(outFile, ((act *) actListArr[i][j])->a37.newState);
				break;
			case INIT_LIPS:          // 38
				writeSint16BE(outFile, ((act *) actListArr[i][j])->a38.timer);
				writeSint16BE(outFile, ((act *) actListArr[i][j])->a38.lipsObjNumb);
				writeSint16BE(outFile, ((act *) actListArr[i][j])->a38.objNumb);
				writeByte(outFile, ((act *) actListArr[i][j])->a38.dxLips);
				writeByte(outFile, ((act *) actListArr[i][j])->a38.dyLips);
				break;
			case INIT_STORY_MODE:    // 39
				writeSint16BE(outFile, ((act *) actListArr[i][j])->a39.timer);
				writeByte(outFile, (((act *) actListArr[i][j])->a39.storyModeFl) ? 1 : 0);
				break;
			case WARN:               // 40
				writeSint16BE(outFile, ((act *) actListArr[i][j])->a40.timer);
				writeSint16BE(outFile, ((act *) actListArr[i][j])->a40.stringIndex);
				break;
			case COND_BONUS:         // 41
				writeSint16BE(outFile, ((act *) actListArr[i][j])->a41.timer);
				writeSint16BE(outFile, ((act *) actListArr[i][j])->a41.BonusIndex);
				writeUint16BE(outFile, ((act *) actListArr[i][j])->a41.actPassIndex);
				writeUint16BE(outFile, ((act *) actListArr[i][j])->a41.actFailIndex);
				break;
			case TEXT_TAKE:          // 42
				writeSint16BE(outFile, ((act *) actListArr[i][j])->a42.timer);
				writeSint16BE(outFile, ((act *) actListArr[i][j])->a42.objNumb);
				break;
			case YESNO:              // 43
				writeSint16BE(outFile, ((act *) actListArr[i][j])->a43.timer);
				writeSint16BE(outFile, ((act *) actListArr[i][j])->a43.prompt);
				writeUint16BE(outFile, ((act *) actListArr[i][j])->a43.actYesIndex);
				writeUint16BE(outFile, ((act *) actListArr[i][j])->a43.actNoIndex);
				break;
			case STOP_ROUTE:         // 44
				writeSint16BE(outFile, ((act *) actListArr[i][j])->a44.timer);
				break;
			case COND_ROUTE:         // 45
				writeSint16BE(outFile, ((act *) actListArr[i][j])->a45.timer);
				writeSint16BE(outFile, ((act *) actListArr[i][j])->a45.routeIndex);
				writeUint16BE(outFile, ((act *) actListArr[i][j])->a45.actPassIndex);
				writeUint16BE(outFile, ((act *) actListArr[i][j])->a45.actFailIndex);
				break;
			case INIT_JUMPEXIT:      // 46
				writeSint16BE(outFile, ((act *) actListArr[i][j])->a46.timer);
				writeByte(outFile, (((act *) actListArr[i][j])->a46.jumpExitFl) ? 1 : 0);
				break;
			case INIT_VIEW:          // 47
				writeSint16BE(outFile, ((act *) actListArr[i][j])->a47.timer);
				writeSint16BE(outFile, ((act *) actListArr[i][j])->a47.objNumb);
				writeSint16BE(outFile, ((act *) actListArr[i][j])->a47.viewx);
				writeSint16BE(outFile, ((act *) actListArr[i][j])->a47.viewy);
				writeSint16BE(outFile, ((act *) actListArr[i][j])->a47.direction);
				break;
			case INIT_OBJ_FRAME:     // 48
				writeSint16BE(outFile, ((act *) actListArr[i][j])->a48.timer);
				writeSint16BE(outFile, ((act *) actListArr[i][j])->a48.objNumb);
				writeSint16BE(outFile, ((act *) actListArr[i][j])->a48.seqIndex);
				writeSint16BE(outFile, ((act *) actListArr[i][j])->a48.frameIndex);
				break;
			case OLD_SONG:           // 49, Added by Strangerke for DOS versions
				writeSint16BE(outFile, ((act *) actListArr[i][j])->a49.timer);
				writeUint16BE(outFile, ((act *) actListArr[i][j])->a49.songIndex);
				break;
			default:
				printf("Unknown action %d", subElemType);
				exit(-1);
			}
		}
	}
}
