pet_control.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 TITANIC_PET_CONTROL_H
#define TITANIC_PET_CONTROL_H
 
#include "titanic/core/game_object.h"
#include "titanic/core/node_item.h"
#include "titanic/core/room_item.h"
#include "titanic/messages/messages.h"
#include "titanic/messages/mouse_messages.h"
#include "titanic/pet_control/pet_conversations.h"
#include "titanic/pet_control/pet_frame.h"
#include "titanic/pet_control/pet_inventory.h"
#include "titanic/pet_control/pet_translation.h"
#include "titanic/pet_control/pet_starfield.h"
#include "titanic/pet_control/pet_real_life.h"
#include "titanic/pet_control/pet_remote.h"
#include "titanic/pet_control/pet_rooms.h"
#include "titanic/support/strings.h"
#include "titanic/room_flags.h"
 
namespace Titanic {
 
enum SummonResult { SUMMON_CANT = 0, SUMMON_PRESENT = 1, SUMMON_CAN = 2 };
 
class CPetControl : public CGameObject {
    DECLARE_MESSAGE_MAP;
    struct PetEventInfo {
        int _id;
        CPetSection *_target;
        PetEventInfo() : _id(0), _target(nullptr) {}
    };
private:
    int _inputLockCount;
    int _areaLockCount;
    int _areaChangeType;
    CPetSection *_sections[7];
    CPetConversations _conversations;
    CPetInventory _inventory;
    CPetStarfield _starfield;
    CPetRemote _remote;
    CPetRooms _rooms;
    CPetRealLife _realLife;
    CPetTranslation _translation;
    CPetFrame _frame;
    CString _activeNPCName;
    CString _remoteTargetName;
    CRoomItem *_hiddenRoom;
    Rect _drawBounds;
    PetEventInfo _timers[2];
private:
    bool isValid();
 
    void loadAreas(SimpleFile *file, int param);
 
    void saveAreas(SimpleFile *file, int indent);
 
    void loaded();
 
    bool containsPt(const Common::Point &pt) const;
 
    bool isBotInView(const CString &name) const;
 
    CGameObject *findBot(const CString &name, CTreeItem *root);
 
    void setTimerPersisent(int id, bool flag);
protected:
    bool MouseButtonDownMsg(CMouseButtonDownMsg *msg);
    bool MouseDragStartMsg(CMouseDragStartMsg *msg);
    bool MouseDragMoveMsg(CMouseDragMoveMsg *msg);
    bool MouseDragEndMsg(CMouseDragEndMsg *msg);
    bool MouseButtonUpMsg(CMouseButtonUpMsg *msg);
    bool MouseDoubleClickMsg(CMouseDoubleClickMsg *msg);
    bool MouseWheelMsg(CMouseWheelMsg *msg);
    bool KeyCharMsg(CKeyCharMsg *msg);
    bool ActionMsg(CActionMsg *msg);
    bool TimerMsg(CTimerMsg *msg);
public:
    PetArea _currentArea;
    CTreeItem *_activeNPC;
    CGameObject *_remoteTarget;
public:
    CLASSDEF;
    CPetControl();
 
    void save(SimpleFile *file, int indent) override;
 
    void load(SimpleFile *file) override;
 
    void draw(CScreenManager *screenManager) override;
 
    Rect getBounds() const override;
 
    void reset();
 
    void postLoad();
 
    void enterNode(CNodeItem *node);
 
    void enterRoom(CRoomItem *room);
 
    void resetRemoteTarget();
 
    void setRemoteTarget(CGameObject *item);
 
    PetArea setArea(PetArea newSection, bool forceChange = false);
 
    void hideCursor();
 
    void showCursor();
 
    void highlightGlyph(int id);
 
 
    CGameObject *getHiddenObject(const CString &name);
 
    CRoomItem *getHiddenRoom();
 
    void drawSquares(CScreenManager *screenManager, int count);
 
    bool contains(const Point &pt) const {
        return _drawBounds.contains(pt);
    }
 
    CGameObject *dragEnd(const Point &pt) const;
 
    bool checkDragEnd(CGameObject *item) const;
 
    void displayMessage(StringId stringId, int param = 0) const;
 
    void displayMessage(const CString &str, int param = 0) const;
 
    void addTranslation(StringId id1, StringId id2);
 
    void clearTranslation();
 
    CGameObject *getFirstObject() const;
 
    CGameObject *getNextObject(CGameObject *prior) const;
 
    void addToInventory(CGameObject *item);
 
    void removeFromInventory(CGameObject *item, CTreeItem *newParent,
        bool refreshUI = true, bool sendMsg = true);
 
    void removeFromInventory(CGameObject *item, bool refreshUI = true, bool sendMsg = true);
 
    void invChange(CGameObject *item);
 
    void moveToHiddenRoom(CTreeItem *item);
 
    void setAreaChangeType(int changeType) { _areaChangeType = changeType; }
 
    bool checkNode(const CString &name);
 
    void syncSoundSettings();
 
    void playSound(int soundNum);
 
    int canSummonBot(const CString &name);
 
    void summonBot(const CString &name, int val);
 
    void onSummonBot(const CString &name, int val);
 
    bool dismissBot(const CString &name);
 
    bool isDoorOrBellbotPresent() const;
 
    void startPetTimer(uint timerIndex, uint firstDuration, uint duration, CPetSection *target);
 
    void stopPetTimer(uint timerIndex);
 
    bool isInputLocked() const { return _inputLockCount > 0; }
 
    void incInputLocks() { ++_inputLockCount; }
 
    void decInputLocks() { --_inputLockCount; }
 
    bool isAreaUnlocked() const { return _areaLockCount == 0; }
 
    void incAreaLocks() { ++_areaLockCount; }
 
    void decAreaLocks() {
        _areaLockCount = MAX(_areaLockCount - 1, 0);
    }
 
    bool isSuccUBusActive() const;
 
    /*--- CPetConversations methods ---*/
 
    void setActiveNPC(const CString &name);
 
    void setActiveNPC(CTrueTalkNPC *npc);
 
    void refreshNPC();
 
    void resetActiveNPC();
 
    void convResetNPC() {
        _conversations.resetNPC();
    }
 
    void resetDials0();
 
    void convResetDials(int flag = 1);
 
    void convAddLine(const CString &line) {
        _conversations.addLine(line);
    }
 
    /*--- CPetRooms methods ---*/
 
    void reassignRoom(PassengerClass passClassNum) {
        _rooms.reassignRoom(passClassNum);
    }
 
    bool changeLocationClass(PassengerClass newClassNum) {
        return _rooms.changeLocationClass(newClassNum);
    }
 
    bool isInAssignedRoom() const {
        return _rooms.isAssignedRoom(getRoomFlags());
    }
 
    uint getRoomFlags() const {
        return _rooms.getRoomFlags();
    }
 
    void setRoomsElevatorNum(int elevNum) {
        _rooms.setElevatorNum(elevNum);
    }
 
    int getRoomsElevatorNum() const {
        return _rooms.getElevatorNum();
    }
 
    void setRoomsFloorNum(int floorNum) {
        _rooms.setFloorNum(floorNum);
    }
 
    int getRoomsFloorNum() const {
        return _rooms.getFloorNum();
    }
 
    void setRoomsRoomNum(int roomNum) {
        _rooms.setRoomNum(roomNum);
    }
 
    int getRoomsRoomNum() const {
        return _rooms.getRoomNum();
    }
 
    void setRoomsWellEntry(int entryNum) {
        _rooms.setWellEntry(entryNum);
    }
 
    int getRoomsWellEntry() const {
        return _rooms.getWellEntry();
    }
 
    void setRoomsSublevel(int level) {
        _rooms.setSublevel(level);
    }
 
    int getRoomsSublevel() const {
        return _rooms.getSublevel();
    }
 
    void resetRoomsHighlight() {
        _rooms.resetHighlight();
    }
 
    int getAssignedRoomFlags() const {
        return _rooms.getAssignedRoomFlags();
    }
 
    uint getSpecialRoomFlags(const CString &name) {
        return CRoomFlags::getSpecialRoomFlags(name);
    }
 
    PassengerClass getMailDestClass(const CRoomFlags &roomFlags) const;
 
    bool isSuccUBusDest(uint roomFlags) {
        return CRoomFlags(roomFlags).isSuccUBusDest();
    }
 
    int getAssignedRoomNum() const {
        return _rooms.getAssignedRoomNum();
    }
 
    int getAssignedFloorNum() const {
        return _rooms.getAssignedFloorNum();
    }
 
    int getAssignedElevatorNum() const {
        return _rooms.getAssignedElevatorNum();
    }
 
    void setRoomsElevatorBroken(bool flag) {
        _rooms.setElevatorBroken(flag);
    }
 
    bool isFirstClassSuite() const {
        return CRoomFlags(getRoomFlags()).isFirstClassSuite();
    }
 
    bool isSuccUBusRoom(const CRoomFlags &roomFlags) {
        return roomFlags.isSuccUBusRoomFlags();
    }
 
    void phonographAction(const CString &action) {
        // Original had some code that had no effect
    }
 
    void starsSetButtons(int matchIndex, bool isMarkerClose);
 
    void starsSetReference();
};
 
} // End of namespace Titanic
 
#endif /* TITANIC_PET_CONTROL_H */