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