Initial commit

devtools/create_hugo/README

@@ -0,0 +1,6 @@
+This tool creates hugo.dat.
+This file contains all the hardcoded strings, logic, fonts, and bitmaps and
+is used by the engine depending on the version of the game started.
+
+In order to work properly, the content of the DATA sub-directory has to be
+copy next to the executable.

devtools/create_hugo/create_hugo.h

@@ -0,0 +1,551 @@
+/* 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 3 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, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifndef CREATE_HUGO_H
+#define CREATE_HUGO_H
+
+#define ARRAYSIZE(x) ((int)(sizeof(x) / sizeof(x[0])))
+
+#define DATAALIGNMENT 4
+
+#define HUGO_DAT_VER_MAJ 0  // 1 byte
+#define HUGO_DAT_VER_MIN 42 // 1 byte
+
+typedef unsigned char  uint8;
+typedef unsigned char  byte;
+typedef unsigned short uint16;
+typedef signed   short int16;
+
+// Structure to define an EXIT or other collision-activated hotspot
+struct hotspot_t {
+	int        screenIndex;                         // Screen in which hotspot appears
+	int        x1, y1, x2, y2;                      // Bounding box of hotspot
+	uint16     actIndex;                            // Index of the action list to carry out if a 'hit'
+	int16      viewx, viewy, direction;             // Used in auto-route mode
+};
+
+struct target_t {                                   // Secondary target for action
+	uint16 nounIndex;                               // Index of the noun
+	uint16 verbIndex;                               // Index of the verb
+};
+
+#define MAX_TARGET     12                           // Max # secondary "MakeUseOf" targets
+
+struct uses_t {                                     // Define uses of certain objects
+	int16    objid;                                 // Primary object
+	uint16   dataIndex;                             // Index of the string if no secondary object matches
+	target_t targets[MAX_TARGET];                   // List of secondary targets
+};
+
+// Following is structure of verbs and nouns for 'background' objects
+// These are objects that appear in the various screens, but nothing
+//  interesting ever happens with them.  Rather than just be dumb and say
+// "don't understand" we produce an interesting msg to keep user sane.
+struct background_t {
+	uint16 verbIndex;                               // Index of the verb
+	uint16 nounIndex;                               // Index of the noun
+	int    commentIndex;                            // Index of comment produced on match
+	bool   matchFl;                                 // TRUE if noun must match when present
+	byte   roomState;                               // "State" of room. Comments might differ.
+	byte   bonusIndex;                              // Index of bonus score (0 = no bonus)
+};
+
+typedef background_t *objectList_t;
+
+struct cmd {
+	uint16 verbIndex;                               // Index of the verb
+	uint16 reqIndex;                                // Index of the list of required objects
+	uint16 textDataNoCarryIndex;                    // Index of the string if any of above not carried
+	byte   reqstate;                                // required state for verb to be done
+	byte   newstate;                                // new states if verb done
+	uint16 textDataWrongIndex;                      // Index of the string if wrong state
+	uint16 textDataDoneIndex;                       // Index of the string if verb done
+	uint16 actIndex;                                // Index of the action list if verb done
+};
+
+struct seq_t {                                      // Linked list of images
+	byte   *imagePtr;                               // ptr to image
+	uint16  bytesPerLine8;                          // bytes per line (8 bits)
+	uint16  lines;                                  // lines
+	uint16  x1, x2, y1, y2;                         // Offsets from x,y: data bounding box
+	seq_t  *nextSeqPtr;                             // ptr to next record
+};
+
+struct seqList_t {
+	uint16 imageNbr;                                // Number of images in sequence
+	seq_t *seqPtr;                                  // Ptr to sequence structure
+};
+
+#define MAX_SEQUENCES  4                            // Number of sequences of images in object
+struct object_t {
+	uint16     nounIndex;                           // String identifying object
+	uint16     dataIndex;                           // String describing the object
+	uint16     *stateDataIndex;                     // Added by Strangerke to handle the LOOK_S state-dependant descriptions
+	path_t     pathType;                            // Describe path object follows
+	int        vxPath, vyPath;                      // Velocity (e.g. for CHASE)
+	uint16     actIndex;                            // Action list to do on collision with hero
+	byte       seqNumb;                             // Number of sequences in list
+	seq_t     *currImagePtr;                        // Sequence image currently in use
+	seqList_t  seqList[MAX_SEQUENCES];              // Array of sequence structure ptrs and lengths
+	cycle_t    cycling;                             // Whether cycling, forward or backward
+	byte       cycleNumb;                           // No. of times to cycle
+	byte       frameInterval;                       // Interval (in ticks) between frames
+	byte       frameTimer;                          // Decrementing timer for above
+	char       radius;                              // Defines sphere of influence by hero
+	byte       screenIndex;                         // Screen in which object resides
+	int        x, y;                                // Current coordinates of object
+	int        oldx, oldy;                          // Previous coordinates of object
+	char       vx, vy;                              // Velocity
+	byte       objValue;                            // Value of object
+	int        genericCmd;                          // Bit mask of 'generic' commands for object
+	uint16     cmdIndex;                            // ptr to list of cmd structures for verbs
+	bool       carriedFl;                           // TRUE if object being carried
+	byte       state;                               // state referenced in cmd list
+	bool       verbOnlyFl;                          // TRUE if verb-only cmds allowed e.g. sit,look
+	byte       priority;                            // Whether object fore, background or floating
+	int16      viewx, viewy;                        // Position to view object from (or 0 or -1)
+	int16      direction;                           // Direction to view object from
+	byte       curSeqNumb;                          // Save which seq number currently in use
+	byte       curImageNumb;                        // Save which image of sequence currently in use
+	char       oldvx;                               // Previous vx (used in wandering)
+	char       oldvy;                               // Previous vy
+};
+
+struct act0 {                                       // Type 0 - Schedule
+	byte     actType;                               // The type of action
+	int      timer;                                 // Time to set off the action
+	uint16   actIndex;                              // Index of an action list
+};
+
+struct act1 {                                       // Type 1 - Start an object
+	byte     actType;                               // The type of action
+	int      timer;                                 // Time to set off the action
+	int      objNumb;                               // The object number
+	int      cycleNumb;                             // Number of times to cycle
+	cycle_t  cycle;                                 // Direction to start cycling
+};
+
+struct act2 {                                       // Type 2 - Initialize an object coords
+	byte     actType;                               // The type of action
+	int      timer;                                 // Time to set off the action
+	int      objNumb;                               // The object number
+	int      x, y;                                  // Coordinates
+};
+
+struct act3 {                                       // Type 3 - Prompt user for text
+	byte     actType;                               // The type of action
+	int      timer;                                 // Time to set off the action
+	uint16   promptIndex;                           // index of prompt string
+	int     *responsePtr;                           // Array of indexes to valid response
+	// string(s) (terminate list with -1)
+	uint16   actPassIndex;                          // Index of the action list if success
+	uint16   actFailIndex;                          // Index of the action list if failure
+	bool     encoded;                               // (HUGO 1 DOS ONLY) Whether response is encoded or not
+};
+
+struct act4 {                                       // Type 4 - Set new background color
+	byte     actType;                               // The type of action
+	int      timer;                                 // Time to set off the action
+	long     newBkgColor;                           // New color
+};
+
+struct act5 {                                       // Type 5 - Initialize an object velocity
+	byte     actType;                               // The type of action
+	int      timer;                                 // Time to set off the action
+	int      objNumb;                               // The object number
+	int      vx, vy;                                // velocity
+};
+
+struct act6 {                                       // Type 6 - Initialize an object carrying
+	byte     actType;                               // The type of action
+	int      timer;                                 // Time to set off the action
+	int      objNumb;                               // The object number
+	bool     carriedFl;                             // carrying
+};
+
+struct act7 {                                       // Type 7 - Initialize an object to hero's coords
+	byte     actType;                               // The type of action
+	int      timer;                                 // Time to set off the action
+	int      objNumb;                               // The object number
+};
+
+struct act8 {                                       // Type 8 - switch to new screen
+	byte     actType;                               // The type of action
+	int      timer;                                 // Time to set off the action
+	int      screenIndex;                           // The new screen number
+};
+
+struct act9 {                                       // Type 9 - Initialize an object state
+	byte     actType;                               // The type of action
+	int      timer;                                 // Time to set off the action
+	int      objNumb;                               // The object number
+	byte     newState;                              // New state
+};
+
+struct act10 {                                      // Type 10 - Initialize an object path type
+	byte     actType;                               // The type of action
+	int      timer;                                 // Time to set off the action
+	int      objNumb;                               // The object number
+	int      newPathType;                           // New path type
+	char     vxPath, vyPath;                        // Max delta velocities e.g. for CHASE
+};
+
+struct act11 {                                      // Type 11 - Conditional on object's state
+	byte     actType;                               // The type of action
+	int      timer;                                 // Time to set off the action
+	int      objNumb;                               // The object number
+	byte     stateReq;                              // Required state
+	uint16   actPassIndex;                          // Index of the action list if success
+	uint16   actFailIndex;                          // Index of the action list if failure
+};
+
+struct act12 {                                      // Type 12 - Simple text box
+	byte     actType;                               // The type of action
+	int      timer;                                 // Time to set off the action
+	int      stringIndex;                           // Index (enum) of string in strings.dat
+};
+
+struct act13 {                                      // Type 13 - Swap first object image with second
+	byte     actType;                               // The type of action
+	int      timer;                                 // Time to set off the action
+	int      obj1;                                  // Index of first object
+	int      obj2;                                  // 2nd
+};
+
+struct act14 {                                      // Type 14 - Conditional on current screen
+	byte     actType;                               // The type of action
+	int      timer;                                 // Time to set off the action
+	int      objNumb;                               // The required object
+	int      screenReq;                             // The required screen number
+	uint16   actPassIndex;                          // Index of the action list if success
+	uint16   actFailIndex;                          // Index of the action list if failure
+};
+
+struct act15 {                                      // Type 15 - Home in on an object
+	byte     actType;                               // The type of action
+	int      timer;                                 // Time to set off the action
+	int      obj1;                                  // The object number homing in
+	int      obj2;                                  // The object number to home in on
+	char     vx, vy;                                // Max delta velocities
+};
+// Note: Don't set a sequence at time 0 of a new screen, it causes
+// problems clearing the boundary bits of the object!  t>0 is safe
+struct act16 {                                      // Type 16 - Set curr_seq_p to seq
+	byte     actType;                               // The type of action
+	int      timer;                                 // Time to set off the action
+	int      objNumb;                               // The object number
+	int      seqIndex;                              // The index of seq array to set to
+};
+
+struct act17 {                                      // Type 17 - SET obj individual state bits
+	byte     actType;                               // The type of action
+	int      timer;                                 // Time to set off the action
+	int      objNumb;                               // The object number
+	int      stateMask;                             // The mask to OR with current obj state
+};
+
+struct act18 {                                      // Type 18 - CLEAR obj individual state bits
+	byte     actType;                               // The type of action
+	int      timer;                                 // Time to set off the action
+	int      objNumb;                               // The object number
+	int      stateMask;                             // The mask to ~AND with current obj state
+};
+
+struct act19 {                                      // Type 19 - TEST obj individual state bits
+	byte     actType;                               // The type of action
+	int      timer;                                 // Time to set off the action
+	int      objNumb;                               // The object number
+	int      stateMask;                             // The mask to AND with current obj state
+	uint16   actPassIndex;                          // Index of the action list (all bits set)
+	uint16   actFailIndex;                          // Index of the action list (not all set)
+};
+
+struct act20 {                                      // Type 20 - Remove all events with this type of action
+	byte     actType;                               // The type of action
+	int      timer;                                 // Time to set off the action
+	byte     actTypeDel;                            // The action type to remove
+};
+
+struct act21 {                                      // Type 21 - Gameover.  Disable hero & commands
+	byte     actType;                               // The type of action
+	int      timer;                                 // Time to set off the action
+};
+
+struct act22 {                                      // Type 22 - Initialize an object to hero's coords
+	byte     actType;                               // The type of action
+	int      timer;                                 // Time to set off the action
+	int      objNumb;                               // The object number
+};
+
+struct act23 {                                      // Type 23 - Exit game back to DOS
+	byte     actType;                               // The type of action
+	int      timer;                                 // Time to set off the action
+};
+
+struct act24 {                                      // Type 24 - Get bonus score
+	byte     actType;                               // The type of action
+	int      timer;                                 // Time to set off the action
+	int      pointIndex;                            // Index into points array
+};
+
+struct act25 {                                      // Type 25 - Conditional on bounding box
+	byte     actType;                               // The type of action
+	int      timer;                                 // Time to set off the action
+	int      objNumb;                               // The required object number
+	int      x1, y1, x2, y2;                        // The bounding box
+	uint16   actPassIndex;                          // Index of the action list if success
+	uint16   actFailIndex;                          // Index of the action list if failure
+};
+
+struct act26 {                                      // Type 26 - Play a sound
+	byte     actType;                               // The type of action
+	int      timer;                                 // Time to set off the action
+	int16    soundIndex;                            // Sound index in data file
+};
+
+struct act27 {                                      // Type 27 - Add object's value to score
+	byte     actType;                               // The type of action
+	int      timer;                                 // Time to set off the action
+	int      objNumb;                               // object number
+};
+
+struct act28 {                                      // Type 28 - Subtract object's value from score
+	byte     actType;                               // The type of action
+	int      timer;                                 // Time to set off the action
+	int      objNumb;                               // object number
+};
+
+struct act29 {                                      // Type 29 - Conditional on object carried
+	byte     actType;                               // The type of action
+	int      timer;                                 // Time to set off the action
+	int      objNumb;                               // The required object number
+	uint16   actPassIndex;                          // Index of the action list if success
+	uint16   actFailIndex;                          // Index of the action list if failure
+};
+
+struct act30 {                                      // Type 30 - Start special maze processing
+	byte     actType;                               // The type of action
+	int      timer;                                 // Time to set off the action
+	byte     mazeSize;                              // Size of (square) maze
+	int      x1, y1, x2, y2;                        // Bounding box of maze
+	int      x3, x4;                                // Extra x points for perspective correction
+	byte     firstScreenIndex;                      // First (top left) screen of maze
+};
+
+struct act31 {                                      // Type 31 - Exit special maze processing
+	byte     actType;                               // The type of action
+	int      timer;                                 // Time to set off the action
+};
+
+struct act32 {                                      // Type 32 - Init fbg field of object
+	byte     actType;                               // The type of action
+	int      timer;                                 // Time to set off the action
+	int      objNumb;                               // The object number
+	byte     priority;                              // Value of foreground/background field
+};
+
+struct act33 {                                      // Type 33 - Init screen field of object
+	byte     actType;                               // The type of action
+	int      timer;                                 // Time to set off the action
+	int      objNumb;                               // The object number
+	int      screenIndex;                           // Screen number
+};
+
+struct act34 {                                      // Type 34 - Global Schedule
+	byte     actType;                               // The type of action
+	int      timer;                                 // Time to set off the action
+	uint16   actIndex;                              // Index of an action list
+};
+
+struct act35 {                                      // Type 35 - Remappe palette
+	byte     actType;                               // The type of action
+	int      timer;                                 // Time to set off the action
+	int16    oldColorIndex;                         // Old color index, 0..15
+	int16    newColorIndex;                         // New color index, 0..15
+};
+
+struct act36 {                                      // Type 36 - Conditional on noun mentioned
+	byte     actType;                               // The type of action
+	int      timer;                                 // Time to set off the action
+	uint16   nounIndex;                             // The required noun (list)
+	uint16   actPassIndex;                          // Index of the action list if success
+	uint16   actFailIndex;                          // Index of the action list if failure
+};
+
+struct act37 {                                      // Type 37 - Set new screen state
+	byte     actType;                               // The type of action
+	int      timer;                                 // Time to set off the action
+	int      screenIndex;                           // The screen number
+	byte     newState;                              // The new state
+};
+
+struct act38 {                                      // Type 38 - Position lips
+	byte     actType;                               // The type of action
+	int      timer;                                 // Time to set off the action
+	int      lipsObjNumb;                           // The LIPS object
+	int      objNumb;                               // The object to speak
+	byte     dxLips;                                // Relative offset of x
+	byte     dyLips;                                // Relative offset of y
+};
+
+struct act39 {                                      // Type 39 - Init story mode
+	byte     actType;                               // The type of action
+	int      timer;                                 // Time to set off the action
+	bool     storyModeFl;                           // New state of story_mode flag
+};
+
+struct act40 {                                      // Type 40 - Unsolicited text box
+	byte     actType;                               // The type of action
+	int      timer;                                 // Time to set off the action
+	int      stringIndex;                           // Index (enum) of string in strings.dat
+};
+
+struct act41 {                                      // Type 41 - Conditional on bonus scored
+	byte     actType;                               // The type of action
+	int      timer;                                 // Time to set off the action
+	int      BonusIndex;                            // Index into bonus list
+	uint16   actPassIndex;                          // Index of the action list if scored for the first time
+	uint16   actFailIndex;                          // Index of the action list if already scored
+};
+
+struct act42 {                                      // Type 42 - Text box with "take" string
+	byte     actType;                               // The type of action
+	int      timer;                                 // Time to set off the action
+	int      objNumb;                               // The object taken
+};
+
+struct act43 {                                      // Type 43 - Prompt user for Yes or No
+	byte     actType;                               // The type of action
+	int      timer;                                 // Time to set off the action
+	int      prompt;                                // Index of prompt string
+	uint16   actYesIndex;                           // Index of the action list if YES
+	uint16   actNoIndex;                            // Index of the action list if NO
+};
+
+struct act44 {                                      // Type 44 - Stop any route in progress
+	byte     actType;                               // The type of action
+	int      timer;                                 // Time to set off the action
+};
+
+struct act45 {                                      // Type 45 - Conditional on route in progress
+	byte     actType;                               // The type of action
+	int      timer;                                 // Time to set off the action
+	int      routeIndex;                            // Must be >= current status.rindex
+	uint16   actPassIndex;                          // Index of the action list if en-route
+	uint16   actFailIndex;                          // Index of the action list if not
+};
+
+struct act46 {                                      // Type 46 - Init status.jumpexit
+	byte     actType;                               // The type of action
+	int      timer;                                 // Time to set off the action
+	bool     jumpExitFl;                            // New state of jumpexit flag
+};
+
+struct act47 {                                      // Type 47 - Init viewx,viewy,dir
+	byte     actType;                               // The type of action
+	int      timer;                                 // Time to set off the action
+	int      objNumb;                               // The object
+	int16    viewx;                                 // object.viewx
+	int16    viewy;                                 // object.viewy
+	int16    direction;                             // object.dir
+};
+
+struct act48 {                                      // Type 48 - Set curr_seq_p to frame n
+	byte     actType;                               // The type of action
+	int      timer;                                 // Time to set off the action
+	int      objNumb;                               // The object number
+	int      seqIndex;                              // The index of seq array to set to
+	int      frameIndex;                            // The index of frame to set to
+};
+
+struct act49 {                                      // Added by Strangerke - Type 79 - Play a sound (DOS way)
+	byte     actType;                               // The type of action
+	int      timer;                                 // Time to set off the action
+	uint16   songIndex;                             // Song index in string array
+};
+
+union act {
+	act0     a0;
+	act1     a1;
+	act2     a2;
+	act3     a3;
+	act4     a4;
+	act5     a5;
+	act6     a6;
+	act7     a7;
+	act8     a8;
+	act9     a9;
+	act10    a10;
+	act11    a11;
+	act12    a12;
+	act13    a13;
+	act14    a14;
+	act15    a15;
+	act16    a16;
+	act17    a17;
+	act18    a18;
+	act19    a19;
+	act20    a20;
+	act21    a21;
+	act22    a22;
+	act23    a23;
+	act24    a24;
+	act25    a25;
+	act26    a26;
+	act27    a27;
+	act28    a28;
+	act29    a29;
+	act30    a30;
+	act31    a31;
+	act32    a32;
+	act33    a33;
+	act34    a34;
+	act35    a35;
+	act36    a36;
+	act37    a37;
+	act38    a38;
+	act39    a39;
+	act40    a40;
+	act41    a41;
+	act42    a42;
+	act43    a43;
+	act44    a44;
+	act45    a45;
+	act46    a46;
+	act47    a47;
+	act48    a48;
+	act49    a49;
+};
+
+typedef void       *actListPtr;                     // Ptr to a list of actions
+typedef actListPtr *actList;                        // A list of actions
+
+void writeTextArray(FILE *outFile, const char *textData[], int nbrText);
+void writeUint16Array(FILE *outFile, const uint16 *uint16Array[], int nbrElem);
+void writeHotspot(FILE *outFile, const hotspot_t hotspots[], int nbrElem);
+void writeUseArray(FILE *outFile, const uses_t uses[], int nbrElem);
+void writeBackgroundArray(FILE *outFile, const background_t background[], int nbrElem);
+void writeCmdArray(FILE *outFile, const cmd *cmdList[], int nbrElem);
+void writeScreenActs(FILE *outFile, const uint16 *screenActs[], int nbrElem);
+void writeObjectArray(FILE *outFile, const object_t objects[], int nbrElem);
+void writeActListArray(FILE *outFile, const actList actListArr[], int nbrElem);
+
+#endif // CREATE_HUGO_H

devtools/create_hugo/module.mk

@@ -0,0 +1,10 @@
+MODULE := devtools/create_hugo
+
+MODULE_OBJS := \
+	create_hugo.o
+
+# Set the name of the executable
+TOOL_EXECUTABLE := create_hugo
+
+# Include common rules
+include $(srcdir)/rules.mk

devtools/create_hugo/staticdisplay.h

@@ -0,0 +1,89 @@
+/* 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 3 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, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+/*
+ * This code is based on original Hugo Trilogy source code
+ *
+ * Copyright (c) 1989-1995 David P. Gray
+ *
+ */
+
+#ifndef STATICDISPLAY_H
+#define STATICDISPLAY_H
+
+#define SIZE_PAL_ARRAY 3*16
+
+#if 1
+// Color table of standard 16 VGA colors
+// Values from "Programmers guide to EGA/VGA cards" Ferraro, p303
+#define V1 168                                      // Low intensity value
+#define V2 255                                      // High intensity value
+#define V3 87                                       // Special for Brown/Gray
+#define V4 32                                       // De-saturate hi intensity
+
+
+byte _palette[SIZE_PAL_ARRAY] = {
+	0,   0,   0,                                    // BLACK
+	0,   0,   V1,                                   // BLUE
+	0,   V1,  0,                                    // GREEN
+	0,   V1,  V1,                                   // CYAN
+	V1,  0,   0,                                    // RED
+	V1,  0,   V1,                                   // MAGENTA
+	V1,  V3,  0,                                    // BROWN
+	V1,  V1,  V1,                                   // WHITE (LIGHT GRAY)
+	V3,  V3,  V3,                                   // GRAY  (DARK GRAY)
+	V4,  V4,  V2,                                   // LIGHTBLUE
+	V4,  V2,  V4,                                   // LIGHTGREEN
+	V4,  V2,  V2,                                   // LIGHTCYAN
+	V2,  V4,  V4,                                   // LIGHTRED
+	V2,  V4,  V2,                                   // LIGHTMAGENTA
+	V2,  V2,  V4,                                   // YELLOW
+	V2,  V2,  V2                                    // BRIGHTWHITE
+};
+#else
+// Original paletter found in original exe.
+// Currently disabled, because the result is quite ugly!
+// Color table of nearest standard 16 colors in system static palette
+#define C1 191                                      // Low intensity value
+#define C2 255                                      // High intensity value
+#define C3 127                                      // Special for Brown/Gray
+byte _palette[SIZE_PAL_ARRAY] = {
+	0,   0,   0,                                    // BLACK
+	0,   0,   C1,                                   // BLUE
+	0,   C1,  0,                                    // GREEN
+	0,   C1,  C1,                                   // CYAN
+	C1,  0,   0,                                    // RED
+	C1,  0,   C1,                                   // MAGENTA
+	C3,  C3,  0,                                    // BROWN
+	C1,  C1,  C1,                                   // WHITE (LIGHT GRAY)
+	C3,  C3,  C3,                                   // GRAY  (DARK GRAY)
+	0,   0,   C2,                                   // LIGHTBLUE
+	0,   C2,  0,                                    // LIGHTGREEN
+	0,   C2,  C2,                                   // LIGHTCYAN
+	C2,  0,   0,                                    // LIGHTRED
+	C2,  0,   C2,                                   // LIGHTMAGENTA
+	C2,  C2,  0,                                    // YELLOW
+	C2,  C2,  C2                                    // BRIGHTWHITE
+};
+#endif
+
+
+#endif

devtools/create_hugo/staticengine.h

@@ -0,0 +1,48 @@
+/* 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 3 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, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+/*
+ * This code is based on original Hugo Trilogy source code
+ *
+ * Copyright (c) 1989-1995 David P. Gray
+ *
+ */
+
+#ifndef STATICENGINE_H
+#define STATICENGINE_H
+
+#define NUM_ENGINE_TEXT 1
+const char *textEngine[NUM_ENGINE_TEXT] = {
+	"Hugo and Penelope say:\n\n"
+	"We hope you liked our adventure and\n"
+	"hope to see you very soon in Hugo's\n"
+	"Mystery Adventure and Hugo's Amazon\n"
+	"Adventure.  They are just like this\n"
+	"game but bigger and better!\n\n"
+	"Call 1-800-2424-PsL now to order the\n"
+	"Hugo Trilogy for Windows for only $36!\n"
+	"(Note: This number is for ORDERS only)\n\n"
+	"It includes all 3 games + the 30-page\n"
+	"answer book.  See Ordering information\n"
+	"for more details and some screenshots."
+};
+
+#endif

devtools/create_hugo/staticfont.h

@@ -0,0 +1,183 @@
+/* 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 3 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, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifndef STATICFONT_H
+#define STATICFONT_H
+
+byte font5[] = {
+	6,   7,   6,   7,   0,   0,   0,   0,   0,   0,   6,   7,   0,   0,   0,   0,   0,   0,   6,   7,
+	0,   0,   0,   0,   0,   0,   6,   7,   0,   0,   0,   0,   0,   0,   6,   7,   0,   0,   0,   0,
+	0,   0,   6,   7,   0,   0,   0,   0,   0,   0,   6,   7,   0,   0,   0,   0,   0,   0,   6,   7,
+	0,   0,   0,   0,   0,   0,   6,   7,   0,   0,   0,   0,   0,   0,   6,   7,   0,   0,   0,   0,
+	0,   0,   6,   7,   0,   0,   0,   0,   0,   0,   6,   7,   0,   0,   0,   0,   0,   0,   6,   7,
+	0,   0,   0,   0,   0,   0,   6,   7,   0,   0,   0,   0,   0,   0,   6,   7,   0,   0,   0,   0,
+	0,   0,   6,   7,   0,   0,   0,   0,   0,   0,   6,   7,   0,   0,   0,   0,   0,   0,   6,   7,
+	0,   0,   0,   0,   0,   0,   6,   7,   0,   0,   0,   0,   0,   0,   6,   7,   0,   0,   0,   0,
+	0,   0,   6,   7,   0,   0,   0,   0,   0,   0,   6,   7,   0,   0,   0,   0,   0,   0,   6,   7,
+	0,   0,   0,   0,   0,   0,   6,   7,   0,   0,   0,   0,   0,   0,   6,   7,   0,   0,   0,   0,
+	0,   0,   6,   7,   0,   0,   0,   0,   0,   0,   6,   7,   0,   0,   0,   0,   0,   0,   6,   7,
+	0,   0,   0,   0,   0,   0,   6,   7,   0,   0,   0,   0,   0,   0,   6,   7,   0,   0,   0,   0,
+	0,   0,   6,   7,   0,   0,   0,   0,   0,   0,   6,   2,   0,   0,   0,   0,   0,   0,   5,   1,
+	128, 128, 128, 0,   128, 2,   3,   160, 160, 3,   3,   160, 0,   160, 5,   3,   64,  224, 64,  224,
+	64,  5,   3,   160, 32,  64,  128, 160, 5,   3,   64,  160, 64,  160, 96,  2,   2,   64,  128, 5,
+	2,   64,  128, 128, 128, 64,  5,   2,   128, 64,  64,  64,  128, 4,   3,   0,   160, 64,  160, 4,
+	3,   0,   64,  224, 64,  5,   2,   0,   0,   0,   64,  128, 3,   3,   0,   0,   224, 5,   1,   0,
+	0,   0,   0,   128, 5,   3,   32,  32,  64,  128, 128, 5,   3,   224, 160, 160, 160, 224, 5,   1,
+	128, 128, 128, 128, 128, 5,   3,   224, 32,  224, 128, 224, 5,   3,   224, 32,  96,  32,  224, 5,
+	3,   160, 160, 224, 32,  32,  5,   3,   224, 128, 224, 32,  224, 5,   3,   224, 128, 224, 160, 224,
+	5,   3,   224, 32,  64,  64,  64,  5,   3,   224, 160, 224, 160, 224, 5,   3,   224, 160, 224, 32,
+	224, 4,   2,   0,   128, 0,   128, 5,   2,   0,   64,  0,   64,  128, 5,   3,   32,  64,  128, 64,
+	32,  4,   3,   0,   224, 0,   224, 5,   3,   128, 64,  32,  64,  128, 5,   3,   192, 32,  64,  0,
+	64,  5,   3,   64,  160, 160, 128, 96,  5,   3,   64,  160, 224, 160, 160, 5,   3,   192, 160, 192,
+	160, 192, 5,   3,   96,  128, 128, 128, 96,  5,   3,   192, 160, 160, 160, 192, 5,   3,   224, 128,
+	192, 128, 224, 5,   3,   224, 128, 192, 128, 128, 5,   3,   224, 128, 160, 160, 224, 5,   3,   160,
+	160, 224, 160, 160, 5,   3,   224, 64,  64,  64,  224, 5,   3,   32,  32,  32,  160, 64,  5,   3,
+	160, 160, 192, 160, 160, 5,   3,   128, 128, 128, 128, 224, 5,   3,   160, 224, 224, 160, 160, 5,
+	3,   160, 224, 224, 224, 160, 5,   3,   64,  160, 160, 160, 64,  5,   3,   192, 160, 192, 128, 128,
+	5,   3,   64,  160, 160, 64,  32,  5,   3,   192, 160, 192, 160, 160, 5,   3,   96,  128, 64,  32,
+	192, 5,   3,   224, 64,  64,  64,  64,  5,   3,   160, 160, 160, 160, 224, 5,   3,   160, 160, 160,
+	64,  64,  5,   3,   160, 160, 224, 224, 160, 5,   3,   160, 160, 64,  160, 160, 5,   3,   160, 160,
+	96,  32,  192, 5,   3,   224, 32,  64,  128, 224, 5,   2,   192, 128, 128, 128, 192, 5,   3,   128,
+	128, 64,  32,  32,  5,   2,   192, 64,  64,  64,  192, 2,   3,   64,  160, 5,   3,   0,   0,   0,
+	0,   224, 2,   2,   128, 64,  5,   3,   64,  160, 224, 160, 160, 5,   3,   192, 160, 192, 160, 192,
+	5,   3,   96,  128, 128, 128, 96,  5,   3,   192, 160, 160, 160, 192, 5,   3,   224, 128, 192, 128,
+	224, 5,   3,   224, 128, 192, 128, 128, 5,   3,   224, 128, 160, 160, 224, 5,   3,   160, 160, 224,
+	160, 160, 5,   3,   224, 64,  64,  64,  224, 5,   3,   32,  32,  32,  160, 64,  5,   3,   160, 160,
+	192, 160, 160, 5,   3,   128, 128, 128, 128, 224, 5,   3,   160, 224, 224, 160, 160, 5,   3,   160,
+	224, 224, 224, 160, 5,   3,   64,  160, 160, 160, 64,  5,   3,   192, 160, 192, 128, 128, 5,   3,
+	64,  160, 160, 64,  32,  5,   3,   192, 160, 192, 160, 160, 5,   3,   96,  128, 64,  32,  192, 5,
+	3,   224, 64,  64,  64,  64,  5,   3,   160, 160, 160, 160, 224, 5,   3,   160, 160, 160, 64,  64,
+	5,   3,   160, 160, 224, 224, 160, 5,   3,   160, 160, 64,  160, 160, 5,   3,   160, 160, 96,  32,
+	192, 5,   3,   224, 32,  64,  128, 224, 5,   3,   96,  64,  192, 64,  96,  5,   1,   128, 128, 0,
+	128, 128, 5,   3,   192, 64,  96,  64,  192, 1,   2,   64,  6,   1,   0,   0,   0,   0,   0,   0
+};
+
+byte font6[] = {
+	11,  11,  7,   6,   4,   12,  12,  24,  216, 112, 48,  7,   8,   0,   35,  99,  255, 96,  32,  0,
+	7,   6,   0,   0,   0,   0,   0,   0,   0,   7,   6,   0,   0,   0,   0,   0,   0,   0,   7,   6,
+	0,   0,   0,   0,   0,   0,   0,   7,   6,   0,   0,   0,   0,   0,   0,   0,   7,   6,   0,   0,
+	0,   0,   0,   0,   0,   7,   6,   0,   0,   0,   0,   0,   0,   0,   7,   6,   0,   0,   0,   0,
+	0,   0,   0,   7,   6,   0,   0,   0,   0,   0,   0,   0,   7,   6,   0,   0,   0,   0,   0,   0,
+	0,   7,   6,   0,   0,   0,   0,   0,   0,   0,   7,   6,   0,   0,   0,   0,   0,   0,   0,   7,
+	6,   0,   0,   0,   0,   0,   0,   0,   7,   6,   0,   0,   0,   0,   0,   0,   0,   7,   6,   0,
+	0,   0,   0,   0,   0,   0,   7,   6,   0,   0,   0,   0,   0,   0,   0,   7,   6,   0,   0,   0,
+	0,   0,   0,   0,   7,   6,   0,   0,   0,   0,   0,   0,   0,   7,   6,   0,   0,   0,   0,   0,
+	0,   0,   7,   6,   0,   0,   0,   0,   0,   0,   0,   7,   6,   0,   0,   0,   0,   0,   0,   0,
+	7,   6,   0,   0,   0,   0,   0,   0,   0,   7,   6,   0,   0,   0,   0,   0,   0,   0,   7,   6,
+	0,   0,   0,   0,   0,   0,   0,   7,   6,   0,   0,   0,   0,   0,   0,   0,   7,   6,   0,   0,
+	0,   0,   0,   0,   0,   7,   6,   0,   0,   0,   0,   0,   0,   0,   7,   6,   0,   0,   0,   0,
+	0,   0,   0,   7,   6,   0,   0,   0,   0,   0,   0,   0,   7,   6,   0,   0,   0,   0,   0,   0,
+	0,   7,   3,   0,   0,   0,   0,   0,   0,   0,   7,   2,   192, 192, 192, 192, 0,   192, 192, 3,
+	7,   102, 102, 204, 5,   5,   80,  248, 80,  248, 80,  7,   6,   48,  124, 208, 120, 44,  248, 48,
+	7,   7,   194, 198, 12,  24,  48,  102, 198, 7,   6,   112, 216, 112, 116, 216, 216, 108, 3,   3,
+	96,  96,  192, 7,   3,   96,  192, 192, 192, 192, 192, 96,  7,   3,   192, 96,  96,  96,  96,  96,
+	192, 5,   5,   0,   0,   80,  32,  80,  6,   6,   0,   48,  48,  252, 48,  48,  8,   3,   0,   0,
+	0,   0,   0,   96,  96,  192, 4,   6,   0,   0,   0,   120, 7,   2,   0,   0,   0,   0,   0,   192,
+	192, 7,   7,   2,   6,   12,  24,  48,  96,  192, 7,   6,   120, 204, 204, 204, 204, 204, 120, 7,
+	4,   96,  224, 96,  96,  96,  96,  240, 7,   6,   120, 204, 12,  56,  96,  192, 252, 7,   6,   120,
+	204, 12,  56,  12,  204, 120, 7,   6,   204, 204, 204, 252, 12,  12,  12,  7,   6,   252, 192, 192,
+	248, 12,  204, 120, 7,   6,   60,  96,  192, 248, 204, 204, 120, 7,   6,   252, 12,  12,  24,  24,
+	48,  48,  7,   6,   120, 204, 204, 120, 204, 204, 120, 7,   6,   120, 204, 204, 124, 12,  24,  48,
+	7,   2,   0,   192, 192, 0,   192, 192, 0,   7,   3,   0,   96,  96,  0,   96,  96,  192, 7,   5,
+	24,  48,  96,  192, 96,  48,  24,  5,   6,   0,   0,   120, 0,   120, 7,   5,   192, 96,  48,  24,
+	48,  96,  192, 7,   6,   120, 204, 12,  24,  48,  0,   48,  7,   6,   120, 204, 204, 220, 216, 192,
+	124, 7,   6,   120, 204, 204, 252, 204, 204, 204, 7,   6,   248, 204, 204, 248, 204, 204, 248, 7,
+	6,   120, 204, 192, 192, 192, 204, 120, 7,   6,   248, 204, 204, 204, 204, 204, 248, 7,   6,   252,
+	192, 192, 248, 192, 192, 252, 7,   6,   252, 192, 192, 248, 192, 192, 192, 7,   6,   120, 204, 192,
+	220, 204, 204, 120, 7,   6,   204, 204, 204, 252, 204, 204, 204, 7,   6,   252, 48,  48,  48,  48,
+	48,  252, 7,   6,   12,  12,  12,  12,  12,  204, 120, 7,   6,   204, 204, 216, 240, 216, 204, 204,
+	7,   6,   192, 192, 192, 192, 192, 192, 252, 7,   8,   195, 231, 255, 219, 219, 195, 195, 7,   8,
+	195, 227, 243, 219, 207, 199, 195, 7,   6,   120, 204, 204, 204, 204, 204, 120, 7,   6,   248, 204,
+	204, 248, 192, 192, 192, 7,   6,   120, 204, 204, 204, 204, 216, 108, 7,   6,   248, 204, 204, 248,
+	240, 216, 204, 7,   6,   120, 204, 192, 120, 12,  204, 120, 7,   6,   252, 48,  48,  48,  48,  48,
+	48,  7,   6,   204, 204, 204, 204, 204, 204, 120, 7,   6,   204, 204, 204, 204, 204, 120, 48,  7,
+	8,   195, 195, 195, 219, 219, 255, 102, 7,   6,   204, 204, 120, 48,  120, 204, 204, 7,   6,   204,
+	204, 204, 120, 48,  48,  48,  7,   6,   252, 12,  24,  48,  96,  192, 252, 7,   4,   240, 192, 192,
+	192, 192, 192, 240, 7,   7,   128, 192, 96,  48,  24,  12,  6,   7,   4,   240, 48,  48,  48,  48,
+	48,  240, 3,   6,   48,  120, 204, 10,  6,   0,   0,   0,   0,   0,   0,   0,   0,   0,   252, 3,
+	3,   192, 192, 96,  7,   6,   0,   0,   120, 204, 204, 220, 108, 7,   6,   192, 192, 248, 204, 204,
+	204, 248, 7,   6,   0,   0,   120, 204, 192, 204, 120, 7,   6,   12,  12,  124, 204, 204, 204, 124,
+	7,   6,   0,   0,   120, 204, 248, 192, 124, 7,   6,   120, 204, 192, 240, 192, 192, 192, 10,  6,
+	0,   0,   124, 204, 204, 220, 108, 12,  204, 120, 7,   6,   192, 192, 216, 236, 204, 204, 204, 7,
+	2,   192, 0,   192, 192, 192, 192, 192, 10,  6,   12,  0,   12,  12,  12,  12,  12,  12,  204, 120,
+	7,   6,   192, 192, 204, 216, 240, 216, 204, 7,   2,   192, 192, 192, 192, 192, 192, 192, 7,   10,
+	0,   0,   0,   0,   219, 128, 238, 192, 204, 192, 204, 192, 204, 192, 7,   6,   0,   0,   248, 204,
+	204, 204, 204, 7,   6,   0,   0,   120, 204, 204, 204, 120, 10,  6,   0,   0,   248, 204, 204, 204,
+	248, 192, 192, 192, 10,  6,   0,   0,   124, 204, 204, 220, 108, 12,  12,  12,  7,   6,   0,   0,
+	248, 204, 192, 192, 192, 7,   6,   0,   0,   124, 192, 120, 12,  248, 7,   4,   96,  96,  240, 96,
+	96,  96,  96,  7,   6,   0,   0,   204, 204, 204, 204, 120, 7,   6,   0,   0,   204, 204, 204, 120,
+	48,  7,   8,   0,   0,   195, 195, 219, 255, 102, 7,   6,   0,   0,   204, 120, 48,  120, 204, 10,
+	6,   0,   0,   204, 204, 204, 204, 124, 12,  204, 120, 7,   6,   0,   0,   252, 24,  48,  96,  252,
+	7,   4,   112, 192, 96,  240, 96,  192, 112, 7,   2,   192, 192, 192, 0,   192, 192, 192, 7,   5,
+	224, 48,  96,  248, 96,  48,  224, 7,   7,   0,   0,   96,  146, 12,  0,   0,   7,   6,   0,   0,
+	0,   0,   0,   0,   0
+};
+
+byte font8[] = {
+	9,   8,   1,   2,   0,   1,   2,   0,   1,   2,   0,   1,   2,   0,   1,   2,   0,   1,   2,   0,
+	1,   2,   0,   1,   2,   0,   1,   2,   0,   1,   2,   0,   1,   2,   0,   1,   2,   0,   1,   2,
+	0,   1,   2,   0,   1,   2,   0,   1,   2,   0,   1,   2,   0,   1,   2,   0,   1,   2,   0,   1,
+	2,   0,   1,   2,   0,   1,   2,   0,   1,   2,   0,   1,   2,   0,   1,   2,   0,   1,   2,   0,
+	1,   2,   0,   1,   2,   0,   1,   2,   0,   1,   2,   0,   1,   2,   0,   1,   3,   0,   7,   7,
+	192, 192, 192, 192, 0,   192, 192, 2,   3,   160, 160, 5,   5,   80,  248, 80,  248, 80,  7,   7,
+	40,  126, 168, 124, 42,  252, 40,  7,   7,   194, 196, 8,   16,  32,  70,  134, 1,   7,   0,   2,
+	2,   64,  128, 7,   3,   96,  192, 192, 192, 192, 192, 96,  7,   3,   192, 96,  96,  96,  96,  96,
+	192, 6,   6,   0,   72,  48,  252, 48,  72,  6,   5,   0,   32,  32,  248, 32,  32,  8,   3,   0,
+	0,   0,   0,   0,   96,  96,  192, 4,   5,   0,   0,   0,   248, 7,   2,   0,   0,   0,   0,   0,
+	192, 192, 7,   7,   2,   4,   8,   16,  32,  64,  128, 7,   6,   120, 204, 204, 204, 204, 204, 120,
+	7,   3,   96,  224, 96,  96,  96,  96,  96,  7,   7,   124, 198, 12,  24,  48,  96,  254, 7,   7,
+	124, 198, 6,   28,  6,   198, 124, 7,   7,   198, 198, 198, 254, 6,   6,   6,   7,   7,   254, 192,
+	192, 252, 6,   198, 124, 7,   7,   124, 198, 192, 252, 198, 198, 124, 7,   7,   254, 6,   6,   12,
+	12,  24,  24,  7,   7,   124, 198, 198, 124, 198, 198, 124, 7,   7,   124, 198, 198, 126, 6,   198,
+	124, 6,   2,   0,   192, 192, 0,   192, 192, 7,   3,   0,   96,  96,  0,   96,  96,  192, 7,   5,
+	24,  48,  96,  192, 96,  48,  24,  5,   5,   0,   0,   248, 0,   248, 7,   5,   192, 96,  48,  24,
+	48,  96,  192, 7,   7,   124, 198, 6,   12,  24,  0,   24,  1,   7,   0,   7,   7,   124, 198, 198,
+	254, 198, 198, 198, 7,   7,   252, 198, 198, 252, 198, 198, 252, 7,   7,   124, 198, 192, 192, 192,
+	198, 124, 7,   7,   252, 198, 198, 198, 198, 198, 252, 7,   7,   254, 192, 192, 248, 192, 192, 254,
+	7,   7,   254, 192, 192, 248, 192, 192, 192, 7,   7,   124, 198, 192, 206, 198, 198, 124, 7,   7,
+	198, 198, 198, 254, 198, 198, 198, 7,   6,   252, 48,  48,  48,  48,  48,  252, 7,   7,   6,   6,
+	6,   6,   6,   198, 124, 7,   7,   198, 198, 204, 248, 204, 198, 198, 7,   7,   192, 192, 192, 192,
+	192, 192, 254, 7,   7,   198, 238, 254, 214, 198, 198, 198, 7,   7,   198, 230, 246, 214, 222, 206,
+	198, 7,   7,   124, 198, 198, 198, 198, 198, 124, 7,   7,   252, 198, 198, 252, 192, 192, 192, 7,
+	7,   124, 198, 198, 198, 198, 204, 118, 7,   7,   252, 198, 198, 252, 204, 198, 198, 7,   7,   126,
+	192, 192, 124, 6,   6,   252, 7,   6,   252, 48,  48,  48,  48,  48,  48,  7,   7,   198, 198, 198,
+	198, 198, 198, 124, 7,   7,   198, 198, 198, 108, 108, 56,  16,  7,   7,   198, 198, 198, 214, 254,
+	238, 198, 7,   7,   198, 198, 108, 56,  108, 198, 198, 7,   7,   204, 204, 204, 120, 48,  48,  48,
+	7,   6,   252, 12,  24,  48,  96,  192, 252, 7,   3,   224, 192, 192, 192, 192, 192, 224, 7,   7,
+	128, 64,  32,  16,  8,   4,   2,   7,   3,   224, 96,  96,  96,  96,  96,  224, 3,   5,   32,  80,
+	136, 8,   7,   0,   0,   0,   0,   0,   0,   0,   254, 2,   2,   128, 64,  7,   7,   0,   0,   124,
+	198, 198, 198, 126, 7,   7,   192, 192, 252, 198, 198, 198, 252, 7,   7,   0,   0,   124, 198, 192,
+	198, 124, 7,   7,   6,   6,   126, 198, 198, 198, 126, 7,   7,   0,   0,   124, 198, 254, 192, 126,
+	7,   6,   120, 204, 192, 240, 192, 192, 192, 8,   7,   0,   0,   124, 198, 198, 126, 6,   124, 7,
+	7,   192, 192, 220, 230, 198, 198, 198, 7,   2,   0,   192, 0,   192, 192, 192, 192, 8,   6,   0,
+	12,  0,   12,  12,  12,  204, 120, 7,   7,   192, 192, 198, 204, 248, 204, 198, 7,   2,   192, 192,
+	192, 192, 192, 192, 192, 7,   7,   0,   0,   252, 214, 214, 214, 198, 7,   7,   0,   0,   220, 230,
+	198, 198, 198, 7,   7,   0,   0,   124, 198, 198, 198, 124, 8,   7,   0,   0,   124, 198, 198, 252,
+	192, 192, 8,   7,   0,   0,   124, 198, 198, 126, 6,   6,   7,   7,   0,   0,   220, 230, 192, 192,
+	192, 7,   7,   0,   0,   126, 192, 124, 6,   252, 7,   7,   96,  248, 96,  96,  96,  102, 60,  7,
+	7,   0,   0,   198, 198, 198, 198, 124, 7,   7,   0,   0,   198, 198, 108, 56,  16,  7,   7,   0,
+	0,   198, 198, 214, 214, 124, 7,   7,   0,   0,   198, 108, 56,  108, 198, 8,   7,   0,   0,   198,
+	198, 198, 126, 6,   252, 7,   6,   0,   0,   252, 24,  48,  96,  252, 7,   4,   48,  96,  96,  192,
+	96,  96,  48,  7,   2,   192, 192, 192, 0,   192, 192, 192, 7,   4,   192, 96,  96,  48,  96,  96,
+	192, 1,   2,   0,   1,   2,   0
+};
+
+#endif //STATICFONT_H

devtools/create_hugo/staticintro.h

@@ -0,0 +1,80 @@
+/* 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 3 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, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+/*
+ * This code is based on original Hugo Trilogy source code
+ *
+ * Copyright (c) 1989-1995 David P. Gray
+ *
+ */
+
+#ifndef STATICINTRO_H
+#define STATICINTRO_H
+
+#define NUM_INTRO_TEXT_DUMMY 1
+#define NUM_INTRO_TEXT_V3 3
+
+// Hugo1 DOS have 11 intro ticks, Hugo3 DOS and Hugo3 have 36
+#define NUM_INTRO_TICK_DUMMY 1
+#define NUM_INTRO_TICK_V1D 11
+#define NUM_INTRO_TICK_V3 36
+
+// We use intro_tick as an index into the following coordinate list for the plane path.
+// This is only used in v3.
+// v1 Dos uses TICKS too, for displaying the texts at a specific pace. x and y arrays
+// are dummy
+const byte x_intro_dummy[] = { 0 };
+
+const byte x_intro_v1d[NUM_INTRO_TICK_V1D] = {
+	0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+	0
+};
+
+const byte x_intro_v3[NUM_INTRO_TICK_V3] = {
+	210, 204, 198, 192, 186, 180, 174, 168, 162, 156,
+	152, 149, 152, 158, 165, 171, 170, 165, 161, 157,
+	150, 144, 138, 134, 133, 134, 138, 144, 146, 142,
+	137, 132, 128, 124, 120, 115
+};
+
+const byte y_intro_dummy[] = { 0 };
+
+const byte y_intro_v1d[NUM_INTRO_TICK_V1D] = {
+	0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+	0
+};
+
+const byte y_intro_v3[NUM_INTRO_TICK_V3] = {
+	61,  61,  61,  61,  61,  61,  61,  61,  61,  61,
+	63,  66,  71,  74,  72,  75,  80,  82,  83,  84,
+	84,  84,  85,  89,  94,  99, 103, 104, 100,  98,
+	100, 103, 106, 109, 111, 112
+};
+
+// Only Hugo 3 uses texts during intro
+const char *textIntro_dummy[NUM_INTRO_TEXT_DUMMY] = {""};
+const char *textIntro_v3[NUM_INTRO_TEXT_V3] = {
+	"Hugo and Penelope are returning\nhome from their vacation at the\ncottage of Great Uncle Horace.",
+	"Suddenly, a freak magnetic storm\ncauses the compass in their light\naircraft to spin wildly!  Unable\nto navigate, Hugo loses all sense\nof direction...",
+	"Finally, hopelessly lost over a\nSouth American Jungle, the plane\nabout to run out of gas, Hugo\nspots a clearing just big enough\nto land it.\n\nWith fingers clenching the controls\nhe shouts:  Hold on Penelope, we're\ngoing down...!"
+};
+
+#endif

devtools/create_hugo/staticmouse.h

@@ -0,0 +1,39 @@
+/* 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 3 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, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+/*
+ * This code is based on original Hugo Trilogy source code
+ *
+ * Copyright (c) 1989-1995 David P. Gray
+ *
+ */
+
+#ifndef STATICMOUSE_H
+#define STATICMOUSE_H
+
+#define NUM_MOUSE_TEXT 2
+
+const char *textMouse[NUM_MOUSE_TEXT] = {
+	"I don't know how to get there!",
+	"Exit"
+};
+
+#endif

devtools/create_hugo/staticparser.h

@@ -0,0 +1,61 @@
+/* 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 3 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, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+/*
+ * This code is based on original Hugo Trilogy source code
+ *
+ * Copyright (c) 1989-1995 David P. Gray
+ *
+ */
+
+#ifndef STATICPARSER_H
+#define STATICPARSER_H
+
+#define NUM_PARSER_TEXT 25
+const char *textParser[NUM_PARSER_TEXT] = {
+	"You should press ALT+F4 or click on Game/Exit.",
+	"You are in a maze of\ntwisty little paths,\nwhich are all alike!",
+	"There's no point!",
+	"I don't fully understand.",
+	"I don't quite understand.",
+	"Eh?",
+	"You see nothing\nunusual about it.",
+	"You already have it.",
+	"It is of no use to you.",
+	"You don't have it.",
+	"No! You'll be needing it.",
+	"Ok.",
+	"You don't have any!",
+	"There aren't any!",
+	"I don't see any here!",
+	"You're not close enough!",
+	"You are carrying:",
+	"\nPress ESCAPE to continue",
+	"I see nothing special about it",
+	"You don't have it!",
+	"I don't see it anywhere",
+	"Are you sure you want to QUIT?",
+	"Apparently our hero either doesn't\nunderstand what you mean or doesn't\nthink that would be very useful!",
+	"I find that befuddling!",
+	"I don't think that would\naccomplish much, somehow!"
+};
+
+#endif //STATICPARSER_H

devtools/create_hugo/staticutil.h

@@ -0,0 +1,42 @@
+/* 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 3 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, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+/*
+ * This code is based on original Hugo Trilogy source code
+ *
+ * Copyright (c) 1989-1995 David P. Gray
+ *
+ */
+
+#ifndef STATICUTIL_H
+#define STATICUTIL_H
+
+#define NUM_UTIL_TEXT 1
+
+const char *textUtil_v1w[NUM_UTIL_TEXT] = {
+	"I'm afraid all you can do at this point is:\n\n-  Load a saved game (Ctrl+L)\n-  Start a new game (Ctrl+N)\n-  Quit! (Alt+F4)"
+};
+
+const char *textUtil_v1d[NUM_UTIL_TEXT] = {
+	"I'm afraid all you can do\nat this point is restore\na saved game or quit!"
+};
+
+#endif //STATICENGINE_H