graphics.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_GRAPHICS_H
#define QUEEN_GRAPHICS_H
 
#include "common/util.h"
#include "queen/structs.h"
 
namespace Queen {
 
struct BobSlot {
    bool active;
    int16 x, y;
    Box box;
    bool xflip;
    uint16 scale;
    uint16 frameNum;
    int frameDir;
 
    bool animating;
    struct {
        int16 speed, speedBak;
 
        struct {
            const AnimFrame *buffer;
            const AnimFrame *curPos;
        } string;
 
        struct {
            bool rebound;
            uint16 firstFrame, lastFrame;
        } normal;
 
    } anim;
 
    bool moving;
    int16 speed;
    bool xmajor;
    int8 xdir, ydir;
    int16 endx, endy;
    uint16 dx, dy;
    uint16 total;
 
    void curPos(int16 xx, int16 yy);
    void move(int16 dstx, int16 dsty, int16 spd);
    void moveOneStep();
    void animOneStep();
 
    void animString(const AnimFrame *animBuf);
    void animNormal(uint16 firstFrame, uint16 lastFrame, uint16 speed, bool rebound, bool xflip);
 
    void scaleWalkSpeed(uint16 ms);
 
    void clear();
    void clear(const Box *defaultBox);
};
 
class QueenEngine;
 
class Graphics {
public:
 
    Graphics(QueenEngine *vm);
    ~Graphics();
 
    void unpackControlBank();
 
    void setupArrows();
 
    void setupMouseCursor();
 
    void drawBob(const BobSlot *bs, const BobFrame *bf, const Box *box, int16 x, int16 y);
 
    void drawInventoryItem(uint32 frameNum, uint16 x, uint16 y);
 
    void pasteBob(uint16 objNum, uint16 image);
 
    void shrinkFrame(const BobFrame *bf, uint16 percentage);
 
    void sortBobs();
 
    void drawBobs();
 
    void clearBobs();
 
    void stopBobs();
 
    BobSlot *bob(int index);
 
    void clearBob(int index) { bob(index)->clear(&_defaultBox); }
 
    void setBobText(const BobSlot *bob, const char *text, int textX, int textY, int color, int flags);
 
    void handleParallax(uint16 roomNum);
 
    void setupNewRoom(const char *room, uint16 roomNum, int16 *furniture, uint16 furnitureCount);
 
    void setBobCutawayAnim(uint16 bobNum, bool xflip, const AnimFrame *af, uint8 frameCount);
    void fillAnimBuffer(const char *anim, AnimFrame *af);
    uint16 countAnimFrames(const char *anim);
    void setupObjectAnim(const GraphicData *gd, uint16 firstImage, uint16 bobNum, bool visible);
    uint16 setupPersonAnim(const ActorData *ad, const char *anim, uint16 curImage);
    void resetPersonAnim(uint16 bobNum);
    void erasePersonAnim(uint16 bobNum);
    void eraseAllAnims();
 
    uint16 refreshObject(uint16 obj);
 
    void setupRoomFurniture(int16 *furniture, uint16 furnitureCount);
    void setupRoomObjects();
 
    uint16 setupPerson(uint16 noun, uint16 curImage);
    uint16 allocPerson(uint16 noun, uint16 curImage);
 
    uint16 personFrames(uint16 bobNum) const { return _personFrames[bobNum]; }
    void clearPersonFrames() { memset(_personFrames, 0, sizeof(_personFrames)); }
    uint16 numFrames() const { return _numFrames; }
    uint16 numStaticFurniture() const { return _numFurnitureStatic; }
    uint16 numAnimatedFurniture() const { return _numFurnitureAnimated; }
    uint16 numFurnitureFrames() const { return _numFurnitureStatic + _numFurnitureAnimatedLen; }
 
    void putCameraOnBob(int bobNum) { _cameraBob = bobNum; }
 
    void update(uint16 room);
 
    enum {
        ARROW_BOB_UP        =  62,
        ARROW_BOB_DOWN      =  63,
        MAX_BOBS_NUMBER     =  64,
        MAX_STRING_LENGTH   = 255,
        MAX_STRING_SIZE     = (MAX_STRING_LENGTH + 1),
        BOB_SHRINK_BUF_SIZE = 60000
    };
 
 
private:
 
    BobSlot _bobs[MAX_BOBS_NUMBER];
 
    BobSlot *_sortedBobs[MAX_BOBS_NUMBER];
 
    uint16 _sortedBobsCount;
 
    BobFrame _shrinkBuffer;
 
    AnimFrame _newAnim[17][30];
 
    AnimFrame _cutAnim[21][30];
 
    uint16 _personFrames[4];
 
    uint16 _numFurnitureAnimated;
 
    uint16 _numFurnitureStatic;
 
    uint16 _numFurnitureAnimatedLen;
 
    uint16 _numFrames;
 
    int _cameraBob;
 
    QueenEngine *_vm;
 
    const Box _defaultBox;
    const Box _gameScreenBox;
    const Box _fullScreenBox;
};
 
class BamScene {
public:
 
    BamScene(QueenEngine *vm);
 
    void playSfx();
    void prepareAnimation();
    void updateCarAnimation();
    void updateFightAnimation();
 
    void saveState(byte *&ptr);
    void loadState(uint32 ver, byte *&ptr);
 
    enum {
        BOB_OBJ1 = 5,
        BOB_OBJ2 = 6,
        BOB_FX   = 7
    };
 
    enum {
        F_STOP     = 0,
        F_PLAY     = 1,
        F_REQ_STOP = 2
    };
 
    uint16 _flag, _index;
 
private:
 
    struct BamDataObj {
        int16 x, y;
        int16 frame;
    };
 
    struct BamDataBlock {
        BamDataObj obj1; // truck / Frank
        BamDataObj obj2; // Rico  / robot
        BamDataObj fx;
        int16 sfx;
    };
 
    BobSlot *_obj1;
    BobSlot *_obj2;
    BobSlot *_objfx;
    bool _screenShaked;
    const BamDataBlock *_fightData;
    uint16 _lastSoundIndex;
 
    QueenEngine *_vm;
 
    static const BamDataBlock _carData[];
    static const BamDataBlock _fight1Data[];
    static const BamDataBlock _fight2Data[];
    static const BamDataBlock _fight3Data[];
    static const BamDataBlock _fight4Data[];
};
 
} // End of namespace Queen
 
#endif