structs.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_STRUCTS_H
#define QUEEN_STRUCTS_H
 
#include "queen/defs.h"
#include "common/endian.h"
 
namespace Queen {
 
struct Box {
    int16 x1, y1, x2, y2;
 
    Box()
        : x1(0), y1(0), x2(0), y2(0) {
    }
 
    Box(int16 xx1, int16 yy1, int16 xx2, int16 yy2)
        : x1(xx1), y1(yy1), x2(xx2), y2(yy2) {
    }
 
    void readFromBE(byte *&ptr) {
        x1 = (int16)READ_BE_UINT16(ptr); ptr += 2;
        y1 = (int16)READ_BE_UINT16(ptr); ptr += 2;
        x2 = (int16)READ_BE_UINT16(ptr); ptr += 2;
        y2 = (int16)READ_BE_UINT16(ptr); ptr += 2;
    }
 
    void writeToBE(byte *&ptr) {
        WRITE_BE_UINT16(ptr, x1); ptr += 2;
        WRITE_BE_UINT16(ptr, y1); ptr += 2;
        WRITE_BE_UINT16(ptr, x2); ptr += 2;
        WRITE_BE_UINT16(ptr, y2); ptr += 2;
    }
 
    int16 xDiff() const {
        return x2 - x1;
    }
 
    int16 yDiff() const {
        return y2 - y1;
    }
 
    bool intersects(int16 x, int16 y, uint16 w, uint16 h) const {
        return (x + w > x1) && (y + h > y1) && (x <= x2) && (y <= y2);
    }
 
    bool contains(int16 x, int16 y) const {
        return (x >= x1) && (x <= x2) && (y >= y1) && (y <= y2);
    }
 
    bool operator==(const Box &b) const {
        return (x1 == b.x1) && (x2 == b.x2) && (y1 == b.y1) && (y2 == b.y2);
    }
};
 
 
struct Area {
    int16 mapNeighbors;
    Box box;
    uint16 bottomScaleFactor, topScaleFactor;
    uint16 object;
 
    Area()
        : mapNeighbors(0), bottomScaleFactor(0), topScaleFactor(0), object(0) {
    }
 
    void readFromBE(byte *&ptr) {
        mapNeighbors = (int16)READ_BE_UINT16(ptr); ptr += 2;
        box.readFromBE(ptr);
        bottomScaleFactor = READ_BE_UINT16(ptr); ptr += 2;
        topScaleFactor = READ_BE_UINT16(ptr); ptr += 2;
        object = READ_BE_UINT16(ptr); ptr += 2;
    }
 
    void writeToBE(byte *&ptr) {
        WRITE_BE_UINT16(ptr, mapNeighbors); ptr += 2;
        box.writeToBE(ptr);
        WRITE_BE_UINT16(ptr, bottomScaleFactor); ptr += 2;
        WRITE_BE_UINT16(ptr, topScaleFactor); ptr += 2;
        WRITE_BE_UINT16(ptr, object); ptr += 2;
    }
 
    uint16 calcScale(int16 y) const {
        uint16 dy = box.yDiff();
        int16 ds = scaleDiff();
        uint16 scale = 0;
 
        if (dy) // Prevent division-by-zero
            scale = ((((y - box.y1) * 100) / dy) * ds) / 100 + bottomScaleFactor;
 
        if (scale == 0)
            scale = 100;
 
        return scale;
    }
 
    int16 scaleDiff() const {
        return (int16)(topScaleFactor - bottomScaleFactor);
    }
};
 
 
struct WalkOffData {
    int16 entryObj;
    uint16 x, y;
 
    void readFromBE(byte *&ptr) {
        entryObj = (int16)READ_BE_UINT16(ptr); ptr += 2;
        x = READ_BE_UINT16(ptr); ptr += 2;
        y = READ_BE_UINT16(ptr); ptr += 2;
    }
 
    void writeToBE(byte *&ptr) {
        WRITE_BE_UINT16(ptr, entryObj); ptr += 2;
        WRITE_BE_UINT16(ptr, x); ptr += 2;
        WRITE_BE_UINT16(ptr, y); ptr += 2;
    }
};
 
 
struct GraphicData {
    uint16 x, y;
 
    int16 firstFrame, lastFrame;
    uint16 speed;
 
    void readFromBE(byte *&ptr) {
        x = READ_BE_UINT16(ptr); ptr += 2;
        y = READ_BE_UINT16(ptr); ptr += 2;
        firstFrame = (int16)READ_BE_UINT16(ptr); ptr += 2;
        lastFrame = (int16)READ_BE_UINT16(ptr); ptr += 2;
        speed = READ_BE_UINT16(ptr); ptr += 2;
    }
};
 
 
struct ObjectData {
    int16 name;
    uint16 x, y;
    uint16 description;
    int16 entryObj;
    uint16 room;
    uint16 state;
 
    int16 image;
 
    void readFromBE(byte *&ptr) {
        name = (int16)READ_BE_UINT16(ptr); ptr += 2;
        x = READ_BE_UINT16(ptr); ptr += 2;
        y = READ_BE_UINT16(ptr); ptr += 2;
        description = READ_BE_UINT16(ptr); ptr += 2;
        entryObj = (int16)READ_BE_UINT16(ptr); ptr += 2;
        room = READ_BE_UINT16(ptr); ptr += 2;
        state = READ_BE_UINT16(ptr); ptr += 2;
        image = (int16)READ_BE_UINT16(ptr); ptr += 2;
    }
 
    void writeToBE(byte *&ptr) {
        WRITE_BE_UINT16(ptr, name); ptr += 2;
        WRITE_BE_UINT16(ptr, x); ptr += 2;
        WRITE_BE_UINT16(ptr, y); ptr += 2;
        WRITE_BE_UINT16(ptr, description); ptr += 2;
        WRITE_BE_UINT16(ptr, entryObj); ptr += 2;
        WRITE_BE_UINT16(ptr, room); ptr += 2;
        WRITE_BE_UINT16(ptr, state); ptr += 2;
        WRITE_BE_UINT16(ptr, image); ptr += 2;
    }
};
 
 
struct ObjectDescription {
    uint16 object;
 
    uint16 type;
    uint16 lastDescription;
    uint16 lastSeenNumber;
 
    void readFromBE(byte *&ptr) {
        object = READ_BE_UINT16(ptr); ptr += 2;
        type = READ_BE_UINT16(ptr); ptr += 2;
        lastDescription = READ_BE_UINT16(ptr); ptr += 2;
        lastSeenNumber = READ_BE_UINT16(ptr); ptr += 2;
    }
 
    void writeToBE(byte *&ptr) {
        WRITE_BE_UINT16(ptr, object); ptr += 2;
        WRITE_BE_UINT16(ptr, type); ptr += 2;
        WRITE_BE_UINT16(ptr, lastDescription); ptr += 2;
        WRITE_BE_UINT16(ptr, lastSeenNumber); ptr += 2;
    }
};
 
 
struct ItemData {
    int16 name;
    uint16 description;
    uint16 state;
    uint16 frame;
    int16 sfxDescription;
 
    void readFromBE(byte *&ptr) {
        name = (int16)READ_BE_UINT16(ptr); ptr += 2;
        description = READ_BE_UINT16(ptr); ptr += 2;
        state = READ_BE_UINT16(ptr); ptr += 2;
        frame = READ_BE_UINT16(ptr); ptr += 2;
        sfxDescription = (int16)READ_BE_UINT16(ptr); ptr += 2;
    }
 
    void writeToBE(byte *&ptr) {
        WRITE_BE_UINT16(ptr, name); ptr += 2;
        WRITE_BE_UINT16(ptr, description); ptr += 2;
        WRITE_BE_UINT16(ptr, state); ptr += 2;
        WRITE_BE_UINT16(ptr, frame); ptr += 2;
        WRITE_BE_UINT16(ptr, sfxDescription); ptr += 2;
    }
};
 
 
struct ActorData {
    int16 room;
    int16 bobNum;
    uint16 name;
    int16 gsSlot, gsValue;
    uint16 color;
    uint16 bobFrameStanding;
    uint16 x, y;
    uint16 anim;
    uint16 bankNum;
    uint16 file;
 
    void readFromBE(byte *&ptr) {
        room = (int16)READ_BE_UINT16(ptr); ptr += 2;
        bobNum = (int16)READ_BE_UINT16(ptr); ptr += 2;
        name = READ_BE_UINT16(ptr); ptr += 2;
        gsSlot = (int16)READ_BE_UINT16(ptr); ptr += 2;
        gsValue = (int16)READ_BE_UINT16(ptr); ptr += 2;
        color = READ_BE_UINT16(ptr); ptr += 2;
        bobFrameStanding = READ_BE_UINT16(ptr); ptr += 2;
        x = READ_BE_UINT16(ptr); ptr += 2;
        y = READ_BE_UINT16(ptr); ptr += 2;
        anim = READ_BE_UINT16(ptr); ptr += 2;
        bankNum = READ_BE_UINT16(ptr); ptr += 2;
        file = READ_BE_UINT16(ptr); ptr += 2;
        // Fix the actor data (see queen.c - l.1518-1519). When there is no
        // valid actor file, we must load the data from the objects room bank.
        // This bank has number 15 (not 10 as in the data files).
        if (file == 0) {
            bankNum = 15;
        }
    }
};
 
 
struct CmdListData {
    Verb verb;
    int16 nounObj1;
    int16 nounObj2;
    int16 song;
    bool setAreas;
    bool setObjects;
    bool setItems;
    bool setConditions;
    int16 imageOrder;
    int16 specialSection;
 
    void readFromBE(byte *&ptr) {
        verb = (Verb)READ_BE_UINT16(ptr); ptr += 2;
        nounObj1 = (int16)READ_BE_UINT16(ptr); ptr += 2;
        nounObj2 = (int16)READ_BE_UINT16(ptr); ptr += 2;
        song = (int16)READ_BE_UINT16(ptr); ptr += 2;
        setAreas = READ_BE_UINT16(ptr) != 0; ptr += 2;
        setObjects = READ_BE_UINT16(ptr) != 0; ptr += 2;
        setItems = READ_BE_UINT16(ptr) != 0; ptr += 2;
        setConditions = READ_BE_UINT16(ptr) != 0; ptr += 2;
        imageOrder = (int16)READ_BE_UINT16(ptr); ptr += 2;
        specialSection = (int16)READ_BE_UINT16(ptr); ptr += 2;
    }
 
    bool match(const Verb& v, int16 obj1, int16 obj2) const {
        return verb == v && nounObj1 == obj1 && nounObj2 == obj2;
    }
};
 
 
struct CmdArea {
    int16 id;
    int16 area;
    uint16 room;
 
    void readFromBE(byte *&ptr) {
        id = (int16)READ_BE_UINT16(ptr); ptr += 2;
        area = (int16)READ_BE_UINT16(ptr); ptr += 2;
        room = READ_BE_UINT16(ptr); ptr += 2;
    }
};
 
 
struct CmdObject {
    int16 id;
    int16 dstObj;
    int16 srcObj;
 
    void readFromBE(byte *&ptr) {
        id = (int16)READ_BE_UINT16(ptr); ptr += 2;
        dstObj = (int16)READ_BE_UINT16(ptr); ptr += 2;
        srcObj = (int16)READ_BE_UINT16(ptr); ptr += 2;
    }
};
 
 
struct CmdInventory {
    int16 id;
    int16 dstItem;
    int16 srcItem;
 
    void readFromBE(byte *&ptr) {
        id = (int16)READ_BE_UINT16(ptr); ptr += 2;
        dstItem = (int16)READ_BE_UINT16(ptr); ptr += 2;
        srcItem = (int16)READ_BE_UINT16(ptr); ptr += 2;
    }
};
 
 
struct CmdGameState {
    int16 id;
    int16 gameStateSlot;
    int16 gameStateValue;
    uint16 speakValue;
 
    void readFromBE(byte *&ptr) {
        id = (int16)READ_BE_UINT16(ptr); ptr += 2;
        gameStateSlot = (int16)READ_BE_UINT16(ptr); ptr += 2;
        gameStateValue = (int16)READ_BE_UINT16(ptr); ptr += 2;
        speakValue = READ_BE_UINT16(ptr); ptr += 2;
    }
};
 
 
struct FurnitureData {
    int16 room;
 
    int16 objNum;
 
    void readFromBE(byte *&ptr) {
        room = (int16)READ_BE_UINT16(ptr); ptr += 2;
        objNum = (int16)READ_BE_UINT16(ptr); ptr += 2;
    }
};
 
 
struct GraphicAnim {
    int16 keyFrame;
    int16 frame;
    uint16 speed;
 
    void readFromBE(byte *&ptr) {
        keyFrame = (int16)READ_BE_UINT16(ptr); ptr += 2;
        frame = (int16)READ_BE_UINT16(ptr); ptr += 2;
        speed = READ_BE_UINT16(ptr); ptr += 2;
    }
};
 
 
struct AnimFrame {
    uint16 frame;
    uint16 speed;
};
 
 
struct Person {
    const ActorData *actor;
    const char *name;
    const char *anim;
    uint16 bobFrame;
};
 
 
struct TalkSelected {
    bool hasTalkedTo;
    int16 values[4];
 
    void readFromBE(byte *&ptr) {
        hasTalkedTo = READ_BE_UINT16(ptr) != 0; ptr += 2;
        for (int i = 0; i < 4; i++) {
            values[i] = (int16)READ_BE_UINT16(ptr); ptr += 2;
        }
    }
 
    void writeToBE(byte *&ptr) {
        WRITE_BE_UINT16(ptr, (uint16)hasTalkedTo); ptr += 2;
        for (int i = 0; i < 4; i++) {
            WRITE_BE_UINT16(ptr, values[i]); ptr += 2;
        }
    }
};
 
 
struct BobFrame {
    uint16 width, height;
    uint16 xhotspot, yhotspot;
    uint8 *data;
};
 
 
} // End of namespace Queen
 
#endif