types.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 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 DIRECTOR_TYPES_H
#define DIRECTOR_TYPES_H
 
namespace Director {
 
#define CONTINUATION (0xAC)
 
enum {
    kFewFamesMaxCounter = 19,
};
 
enum {
    kShotColorDiffThreshold = 2,
    kShotPercentPixelThreshold = 1
};
 
#define kQuirksCacheArchive "quirks"
#define kSavedFilesArchive "saved"
 
enum MovieFlag {
    kMovieFlagRemapPalettesWhenNeeded =  (1 << 6),
    kMovieFlagAllowOutdatedLingo    = (1 << 8)
};
 
enum CastType {
    kCastTypeAny = -1,
    kCastTypeNull = 0,
    kCastBitmap = 1,
    kCastFilmLoop = 2,
    kCastText = 3,
    kCastPalette = 4,
    kCastPicture = 5,
    kCastSound = 6,
    kCastButton = 7,
    kCastShape = 8,
    kCastMovie = 9,
    kCastDigitalVideo = 10,
    kCastLingoScript = 11,
    kCastRichText = 12,
    kCastOLE = 13,
    kCastTransition = 14,       // D5
    kCastXtra = 15,
};
 
enum ScriptType {
    kNoneScript = -1,
    kScoreScript = 0,
    kCastScript = 1,
    kMovieScript = 2,
    kEventScript = 3,
    kTestScript = 4,
    kParentScript = 7,
    kMaxScriptType = 7  // Sync with types.cpp:28, array scriptTypes[]
};
 
enum EventHandlerSourceType {
    kNoneHandler = 0,
    kPrimaryHandler = 1,
    kSpriteHandler = 2,
    kCastHandler = 3,
    kFrameHandler = 4,
    kMovieHandler = 5
};
 
enum ScriptFlag {
    kScriptFlagUnused       = (1 << 0x0),
    kScriptFlagFuncsGlobal  = (1 << 0x1),
    kScriptFlagVarsGlobal   = (1 << 0x2),   // Occurs in event scripts (which have no local vars). Correlated with use of alternate global var opcodes.
    kScriptFlagUnk3         = (1 << 0x3),
    kScriptFlagFactoryDef   = (1 << 0x4),
    kScriptFlagUnk5         = (1 << 0x5),
    kScriptFlagUnk6         = (1 << 0x6),
    kScriptFlagUnk7         = (1 << 0x7),
    kScriptFlagHasFactory   = (1 << 0x8),
    kScriptFlagEventScript  = (1 << 0x9),
    kScriptFlagEventScript2 = (1 << 0xa),
    kScriptFlagUnkB         = (1 << 0xb),
    kScriptFlagUnkC         = (1 << 0xc),
    kScriptFlagUnkD         = (1 << 0xd),
    kScriptFlagUnkE         = (1 << 0xe),
    kScriptFlagUnkF         = (1 << 0xf)
};
 
enum ObjectType {
    kNoneObj = 0,
    kFactoryObj = 1 << 0,
    kXObj = 1 << 1,
    kScriptObj = 1 << 2,
    kXtraObj = 1 << 3,
    kAllObj = kFactoryObj | kXObj | kScriptObj | kXtraObj,
    kWindowObj = 1 << 4,
    kCastMemberObj = 1 << 5
};
 
enum ShapeType {
    kShapeRectangle = 1,
    kShapeRoundRect = 2,
    kShapeOval = 3,
    kShapeLine = 4
};
 
enum TextType {
    kTextTypeAdjustToFit,
    kTextTypeScrolling,
    kTextTypeFixed
};
 
enum TextAlignType {
    kTextAlignRight = -1,
    kTextAlignLeft,
    kTextAlignCenter
};
 
enum TextFlag {
    kTextFlagEditable   = (1 << 0),
    kTextFlagAutoTab    = (1 << 1),
    kTextFlagDoNotWrap  = (1 << 2)
};
 
enum ButtonType {
    kTypeButton,
    kTypeCheckBox,
    kTypeRadio
};
 
enum FrameRateType {
    kFrameRateDefault = -1,
    kFrameRateNormal = 0,
    kFrameRateFastest = 1,
    kFrameRateFixed = 2
};
 
enum SpriteType {
    kInactiveSprite                 = 0,    // turns the sprite off
    kBitmapSprite                   = 1,
    kRectangleSprite                = 2,    // QuickDraw
    kRoundedRectangleSprite         = 3,    // QuickDraw
    kOvalSprite                     = 4,    // QuickDraw
    kLineTopBottomSprite            = 5,    // line from top left to bottom right
    kLineBottomTopSprite            = 6,    // line from bottom left to top right
    kTextSprite                     = 7,
    kButtonSprite                   = 8,
    kCheckboxSprite                 = 9,
    kRadioButtonSprite              = 10,
    kPictSprite                     = 11,   // Cast picture
    kOutlinedRectangleSprite        = 12,   // QuickDraw
    kOutlinedRoundedRectangleSprite = 13,   // QuickDraw
    kOutlinedOvalSprite             = 14,   // QuickDraw
    kThickLineSprite                = 15,   // 2pt width line
    kCastMemberSprite               = 16,   // Specified by cast member
    kFilmLoopSprite                 = 17,
    kDirMovieSprite                 = 18
};
 
enum InkType {
    kInkTypeCopy,
    kInkTypeTransparent,
    kInkTypeReverse,
    kInkTypeGhost,
    kInkTypeNotCopy,
    kInkTypeNotTrans,
    kInkTypeNotReverse,
    kInkTypeNotGhost,
    kInkTypeMatte,
    kInkTypeMask,
    //10-31 Not used (Lingo in a Nutshell)
    kInkTypeBlend = 32,
    kInkTypeAddPin,
    kInkTypeAdd,
    kInkTypeSubPin,
    kInkTypeBackgndTrans,
    kInkTypeLight,
    kInkTypeSub,
    kInkTypeDark
};
 
// ID matches up to the fake cast member ID used by EventScript
enum LEvent {
    kEventPrepareMovie = 0, // 0
    kEventStartMovie,
    kEventStepMovie,
    kEventStopMovie,
 
    kEventNew, // 4
    kEventBeginSprite,
    kEventEndSprite,
 
    kEventNone, // 7
    kEventGeneric,
    kEventEnterFrame,
    kEventPrepareFrame,
    kEventIdle,
    kEventStepFrame,
    kEventExitFrame,
    kEventTimeout,
 
    kEventActivateWindow, // 15
    kEventDeactivateWindow,
    kEventMoveWindow,
    kEventResizeWindow,
    kEventOpenWindow,
    kEventCloseWindow,
    kEventZoomWindow,
 
    kEventKeyUp, // 22
    kEventKeyDown,
    kEventMouseUp,
    kEventMouseDown,
    kEventRightMouseUp,
    kEventRightMouseDown,
    kEventMouseEnter,
    kEventMouseLeave,
    kEventMouseUpOutSide,
    kEventMouseWithin,
 
    kEventStartUp, // 32
 
    kEventMenuCallback, // 33
 
    kEventGetBehaviorDescription,
    kEventGetPropertyDescriptionList,
    kEventRunPropertyDialog,
 
    kEventCuePassed,
};
 
enum TransitionType {
    kTransNone,
    kTransWipeRight,
    kTransWipeLeft,
    kTransWipeDown,
    kTransWipeUp,
    kTransCenterOutHorizontal,  // 5
    kTransEdgesInHorizontal,
    kTransCenterOutVertical,
    kTransEdgesInVertical,
    kTransCenterOutSquare,
    kTransEdgesInSquare,        // 10
    kTransPushLeft,
    kTransPushRight,
    kTransPushDown,
    kTransPushUp,
    kTransRevealUp,             // 15
    kTransRevealUpRight,
    kTransRevealRight,
    kTransRevealDownRight,
    kTransRevealDown,
    kTransRevealDownLeft,       // 20
    kTransRevealLeft,
    kTransRevealUpLeft,
    kTransDissolvePixelsFast,
    kTransDissolveBoxyRects,
    kTransDissolveBoxySquares,  // 25
    kTransDissolvePatterns,
    kTransRandomRows,
    kTransRandomColumns,
    kTransCoverDown,
    kTransCoverDownLeft,        // 30
    kTransCoverDownRight,
    kTransCoverLeft,
    kTransCoverRight,
    kTransCoverUp,
    kTransCoverUpLeft,          // 35
    kTransCoverUpRight,
    kTransVenetianBlind,
    kTransCheckerboard,
    kTransStripsBottomBuildLeft,
    kTransStripsBottomBuildRight,   // 40
    kTransStripsLeftBuildDown,
    kTransStripsLeftBuildUp,
    kTransStripsRightBuildDown,
    kTransStripsRightBuildUp,
    kTransStripsTopBuildLeft,       // 45
    kTransStripsTopBuildRight,
    kTransZoomOpen,
    kTransZoomClose,
    kTransVerticalBinds,
    kTransDissolveBitsFast, // 50
    kTransDissolvePixels,
    kTransDissolveBits
};
 
enum RenderMode {
    kRenderModeNormal,
    kRenderForceUpdate
};
 
// TODO: Can there be any more built-in palette types?
enum PaletteType {
    kClutSystemMac = -1,
    kClutRainbow = -2,
    kClutGrayscale = -3,
    kClutPastels = -4,
    kClutVivid = -5,
    kClutNTSC = -6,
    kClutMetallic = -7,
    kClutWeb216 = -8,       // D7
    kClutVGA = -9,          // D7
    kClutSystemWin = -101,
    kClutSystemWinD5 = -102
};
 
enum {
    kNumBuiltinTiles = 8
};
 
enum DirectorCursor {
    kCursorMouseDown,
    kCursorMouseUp
};
 
enum PlayState {
    kPlayNotStarted,
    kPlayLoaded,
    kPlayStarted,
    kPlayStopped,
    kPlayPaused,
    kPlayPausedAfterLoading,
};
 
enum SymbolType {
    VOIDSYM,
    OPCODE,
    CBLTIN, // builtin command
    FBLTIN, // builtin function
    HBLTIN, // builtin handler (can be called as either command or func)
    KBLTIN, // builtin constant
    FBLTIN_LIST, // builtin function w/list override check
    HBLTIN_LIST, // builtin handler w/list override check
    HANDLER // user-defined handler
};
 
enum ChunkType {
    kChunkChar,
    kChunkWord,
    kChunkItem,
    kChunkLine
};
 
enum FileVer {
    kFileVer010 = 0x100,
    kFileVer020 = 0x200,
    kFileVer100 = 0x3ff,
    kFileVer200 = 0x400,
    kFileVer300 = 0x404,
    kFileVer310 = 0x405,
    kFileVer400 = 0x45B,
    kFileVer404 = 0x45D,
    kFileVer500 = 0x4B1,
    kFileVer600 = 0x4C2,
    kFileVer700 = 0x4C8,
    kFileVer800 = 0x582,
    kFileVer850 = 0x6A4,
    kFileVer1000 = 0x73B,
    kFileVer1100 = 0x781,
    kFileVer1150 = 0x782,
    kFileVer1200 = 0x79F
};
 
enum DatumType {
    ARGC,
    ARGCNORET,
    ARRAY,
    CASTREF,
    CASTLIBREF,
    CHUNKREF,
    FIELDREF,
    FLOAT,
    GLOBALREF,
    INT,
    LOCALREF,
    MEDIA,
    MENUREF,
    OBJECT,
    PARRAY,
    PICTUREREF,
    POINT,
    PROPREF,
    RECT,
    SPRITEREF,
    STRING,
    SYMBOL,
    VARREF,
    VOID,
};
 
enum VarType {
    kVarGeneric,
    kVarArgument,
    kVarProperty,
    kVarInstance,
    kVarGlobal,
    kVarLocal
};
 
enum LPPFlag {
    kLPPNone = 0,
    kLPPSimple = 1 << 0,
    kLPPForceD2 = 1 << 1,
    kLPPTrimGarbage = 1 << 2,
};
 
struct CastMemberID {
    int member;
    int castLib;
 
    CastMemberID() : member(0), castLib(0) {}
    CastMemberID(int memberID, int castLibID)
        : member(memberID), castLib(castLibID) {}
 
    bool operator==(const CastMemberID &c) const {
        return member == c.member && castLib == c.castLib;
    }
    bool operator!=(const CastMemberID &c) const {
        return member != c.member || castLib != c.castLib;
    }
 
    bool isNull() const { return member == 0 && castLib == 0; }
 
    Common::String asString() const;
 
    uint hash() const { return ((castLib & 0xffff) << 16) + (member & 0xffff); }
 
    // Multiplex IDs are basically member + castLib * 0x10000.
    // castLib 1 is equivalent to castLib 0; the range repeats twice, and
    // "the number of (member (65536+1))" returns 1.
    CastMemberID fromMultiplex(int multiplexID) {
        if (multiplexID < 0)
            return CastMemberID(multiplexID, -1);
        int lib = multiplexID >> 16;
        return CastMemberID(multiplexID % 0x10000, lib ? lib : 1);
    }
 
    int toMultiplex() {
        if (castLib <= 1)
            return member;
        return (member % 0x10000) + (castLib << 16);
    }
};
 
enum CompareResult {
    kCompareLess            = 1 << 0,
    kCompareEqual           = 1 << 1,
    kCompareGreater         = 1 << 2,
    kCompareLessEqual       = 1 << 3,
    kCompareGreaterEqual    = 1 << 4,
    kCompareError           = 1 << 5,
};
 
enum DebugDrawModes {
    kDebugDrawCast  = 1 << 0,
    kDebugDrawFrame = 1 << 1,
};
 
struct Datum;
struct PCell;
typedef Common::Array<Datum> DatumArray;
typedef Common::Array<PCell> PropertyArray;
 
const char *scriptType2str(ScriptType scr);
const char *castType2str(CastType type);
const char *spriteType2str(SpriteType type);
const char *inkType2str(InkType type);
const char *symbolType2str(SymbolType type);
const char *leventType2str(LEvent type);
const char *eventHandlerSourceType2str(EventHandlerSourceType type);
Common::String objectType2str(int fl);
Common::String paletteType2str(PaletteType value);
Common::String textAlignType2str(TextAlignType value);
Common::String shapeType2str(ShapeType value);
Common::String textType2str(TextType value);
 
enum CollisionTest {
    kCollisionNo = 0,
    kCollisionYes,
    kCollisionHole,
};
 
} // End of namespace Director
 
namespace Common {
 
template<>
struct Hash<Director::CastMemberID> {
    uint operator()(const Director::CastMemberID &id) const {
        return id.hash();
    }
};
 
template<>
struct Hash<Director::LEvent> {
    uint operator()(const Director::LEvent &event) const {
        return event;
    }
};
 
 
} // End of namespace Common
 
#endif