Logo Search packages:      
Sourcecode: scummvm version File versions

create_hugo.h

/* 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$
 * $Id$
 *
 */

#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
00042 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
};

00049 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

00056 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.
00066 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;

00077 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
};

00088 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
};

00096 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
00102 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
};

00136 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
};

00142 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
};

00150 struct act2 {                                       // Type 2 - Initialise 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
};

00157 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
};

00168 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
};

00174 struct act5 {                                       // Type 5 - Initialise 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
};

00181 struct act6 {                                       // Type 6 - Initialise 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
};

00188 struct act7 {                                       // Type 7 - Initialise 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
};

00194 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
};

00200 struct act9 {                                       // Type 9 - Initialise 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
};

00207 struct act10 {                                      // Type 10 - Initialise 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
};

00215 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
};

00224 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
};

00230 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
};

00237 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
};

00246 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
00255 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
};

00262 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
};

00269 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
};

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

00285 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
};

00291 struct act21 {                                      // Type 21 - Gameover.  Disable hero & commands
      byte     actType;                               // The type of action
      int      timer;                                 // Time to set off the action
};

00296 struct act22 {                                      // Type 22 - Initialise 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
};

00302 struct act23 {                                      // Type 23 - Exit game back to DOS
      byte     actType;                               // The type of action
      int      timer;                                 // Time to set off the action
};

00307 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
};

00313 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
};

00322 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
};

00328 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
};

00334 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
};

00340 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
};

00348 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
};

00357 struct act31 {                                      // Type 31 - Exit special maze processing
      byte     actType;                               // The type of action
      int      timer;                                 // Time to set off the action
};

00362 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
};

00369 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
};

00376 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
};

00382 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
};

00389 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
};

00397 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
};

00404 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
};

00413 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
};

00419 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
};

00425 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
};

00433 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
};

00439 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
};

00447 struct act44 {                                      // Type 44 - Stop any route in progress
      byte     actType;                               // The type of action
      int      timer;                                 // Time to set off the action
};

00452 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
};

00460 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
};

00466 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
};

00475 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
};

00483 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
};

00489 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

Generated by  Doxygen 1.6.0   Back to index