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 VirtualKeyCharMsg(CVirtualKeyCharMsg *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 */