cutaway.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 QUEEN_CUTAWAY_H
#define QUEEN_CUTAWAY_H
 
#include "common/util.h"
#include "queen/structs.h"
 
namespace Queen {
 
class QueenEngine;
 
class Cutaway {
public:
 
    static void run(const char *filename, char *nextFilename, QueenEngine *vm);
 
    enum {
        PREVIOUS_ROOM = 0,
        CURRENT_ROOM = 0,
        OBJECT_ROOMFADE = -1,
        PERSON_JOE = -1,
        OBJECT_JOE = 0,
        MAX_PERSON_COUNT = 6,
        CUTAWAY_BANK = 8,
        MAX_BANK_NAME_COUNT = 5,
        MAX_FILENAME_LENGTH = 12,
        MAX_FILENAME_SIZE = (MAX_FILENAME_LENGTH + 1),
        MAX_PERSON_FACE_COUNT = 13,
        MAX_STRING_LENGTH = 255,
        MAX_STRING_SIZE = (MAX_STRING_LENGTH + 1),
        LEFT = 1,
        RIGHT = 2,
        FRONT = 3,
        BACK = 4
    };
 
    enum ObjectType {
        OBJECT_TYPE_ANIMATION               = 0,
        OBJECT_TYPE_PERSON                  = 1,
        OBJECT_TYPE_NO_ANIMATION            = 2,
        OBJECT_TYPE_TEXT_SPEAK              = 3,
        OBJECT_TYPE_TEXT_DISPLAY_AND_SPEAK  = 4,
        OBJECT_TYPE_TEXT_DISPLAY            = 5
    };
 
private:
    struct CutawayObject {
        int16 objectNumber;    // 0 = JOE, -1 = MESSAGE
        int16 moveToX;
        int16 moveToY;
        int16 bank;             // 0 = PBOB, 13 = Joe Bank, else BANK NAMEstr()
        int16 animList;
        int16 execute;          // 1 Yes, 0 No
        int16 limitBobX1;
        int16 limitBobY1;
        int16 limitBobX2;
        int16 limitBobY2;
        int16 specialMove;
        int16 animType;        // 0 - Packet, 1 - Amal, 2 - Unpack
        int16 fromObject;
        int16 bobStartX;
        int16 bobStartY;
        int16 room;
        int16 scale;
        // Variables derived from the variables above
        int song;
 
        int person[MAX_PERSON_COUNT];
 
        int personCount;
    };
 
    struct CutawayAnim {
        int16 object;
        int16 unpackFrame;          // Frame to unpack
        int16 speed;
        int16 bank;
        int16 mx;
        int16 my;
        int16 cx;
        int16 cy;
        int16 scale;
        int16 currentFrame;  // Index to Current Frame
        int16 originalFrame;  // Index to Original Object Frame
        int16 song;
        bool flip;      // set this if unpackFrame is negative
    };
 
    struct ObjectDataBackup {
        int index;
        int16 name;
        int16 image;
    };
 
    struct PersonFace {
      int16 index;
      int16 image;
    };
 
    QueenEngine *_vm;
 
    byte *_fileData;
 
    int16 _comPanel;
 
    byte *_gameStatePtr;
 
    byte *_objectData;
 
    uint16 _nextSentenceOff;
 
    bool _roomFade;
 
    int16 _cutawayObjectCount;
 
    bool _anotherCutaway;
 
    int _initialRoom;
 
    int _temporaryRoom;
 
    int _finalRoom;
 
    char _bankNames[MAX_BANK_NAME_COUNT][MAX_FILENAME_SIZE];
 
    char _basename[MAX_FILENAME_SIZE];
 
    char _talkFile[MAX_FILENAME_SIZE];
 
    int16 _talkTo;
 
    ObjectDataBackup _personData[MAX_PERSON_COUNT];
 
    int _personDataCount;
 
    PersonFace _personFace[MAX_PERSON_FACE_COUNT];
 
    int _personFaceCount;
 
    int16 _lastSong;
 
    int16 _songBeforeComic;
 
    int16 _currentImage;
 
    Cutaway(const char *filename, QueenEngine *vm);
    ~Cutaway();
 
    void run(char *nextFilename);
 
    void load(const char *filename);
 
    void loadStrings(uint16 offset);
 
    const byte *turnOnPeople(const byte *ptr, CutawayObject &object);
 
    void limitBob(CutawayObject &object);
 
    void changeRooms(CutawayObject &object);
 
    ObjectType getObjectType(CutawayObject &object);
 
    const byte *handleAnimation(const byte *ptr, CutawayObject &object);
 
    void handlePersonRecord(int index, CutawayObject &object, const char *sentence);
 
    void handleText(int index, ObjectType type, CutawayObject &object, const char *sentence);
 
    void restorePersonData();
 
    void stop();
 
    void updateGameState();
 
    void talk(char *nextFilename);
 
    const byte *getCutawayAnim(const byte *ptr, int header, CutawayAnim &anim);
 
    int makeComplexAnimation(int16 currentImage, CutawayAnim *objAnim, int frameCount);
 
    static const byte *getCutawayObject(const byte *ptr, CutawayObject &object);
 
    void dumpCutawayObject(int index, CutawayObject &object);
 
    int countSpaces(ObjectType type, const char *segment);
 
    int scale(CutawayObject &object);
 
    static void dumpCutawayAnim(CutawayAnim &anim);
 
    bool inRange(int16 x, int16 l, int16 h) const { return (x <= h && x >= l); }
};
 
} // End of namespace Queen
 
#endif