objects.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 ALCACHOFA_OBJECTS_H
#define ALCACHOFA_OBJECTS_H
 
#include "alcachofa/shape.h"
#include "alcachofa/graphics.h"
#include "alcachofa/menu.h"
 
#include "common/serializer.h"
 
namespace Alcachofa {
 
class Room;
class Process;
struct Task;
 
class ObjectBase {
public:
    static constexpr const char *kClassName = "CObjetoBase";
    ObjectBase(Room *room, const char *name);
    ObjectBase(Room *room, Common::SeekableReadStream &stream);
    virtual ~ObjectBase() {}
 
    inline const Common::String &name() const { return _name; }
    inline Room *&room() { return _room; }
    inline Room *room() const { return _room; }
    inline bool isEnabled() const { return _isEnabled; }
 
    virtual void toggle(bool isEnabled);
    virtual void draw();
    virtual void drawDebug();
    virtual void update();
    virtual void loadResources();
    virtual void freeResources();
    virtual void syncGame(Common::Serializer &serializer);
    virtual Graphic *graphic();
    virtual Shape *shape();
    virtual const char *typeName() const;
 
private:
    Common::String _name;
    bool _isEnabled = true;
    Room *_room = nullptr;
};
 
class PointObject : public ObjectBase {
public:
    static constexpr const char *kClassName = "CObjetoPunto";
    PointObject(Room *room, Common::SeekableReadStream &stream);
 
    inline Common::Point &position() { return _pos; }
    inline Common::Point position() const { return _pos; }
    const char *typeName() const override;
 
private:
    Common::Point _pos;
};
 
enum class GraphicObjectType : byte
{
    Normal,
    NormalPosterize, // the posterization is not actually applied in the original engine
    Effect
};
 
class GraphicObject : public ObjectBase {
public:
    static constexpr const char *kClassName = "CObjetoGrafico";
    GraphicObject(Room *room, Common::SeekableReadStream &stream);
    ~GraphicObject() override {}
 
    void draw() override;
    void drawDebug() override;
    void loadResources() override;
    void freeResources() override;
    void syncGame(Common::Serializer &serializer) override;
    Graphic *graphic() override;
    const char *typeName() const override;
 
    Task *animate(Process &process);
 
protected:
    GraphicObject(Room *room, const char *name);
 
    Graphic _graphic;
    GraphicObjectType _type = GraphicObjectType::Normal;
    int32 _posterizeAlpha = 100;
};
 
class SpecialEffectObject final : public GraphicObject {
public:
    static constexpr const char *kClassName = "CObjetoGraficoMuare";
    SpecialEffectObject(Room *room, Common::SeekableReadStream &stream);
 
    void draw() override;
    const char *typeName() const override;
 
private:
    static constexpr const float kShiftSpeed = 1 / 256.0f;
    Common::Point _topLeft, _bottomRight;
    Math::Vector2d _texShift;
};
 
class ShapeObject : public ObjectBase {
public:
    ShapeObject(Room *room, Common::SeekableReadStream &stream);
    ~ShapeObject() override {}
 
    inline int8 order() const { return _order; }
    inline bool isNewlySelected() const { return _isNewlySelected; }
    inline bool wasSelected() const { return _wasSelected; }
 
    void update() override;
    void syncGame(Common::Serializer &serializer) override;
    Shape *shape() override;
    virtual CursorType cursorType() const;
    virtual void onHoverStart();
    virtual void onHoverEnd();
    virtual void onHoverUpdate();
    virtual void onClick();
    const char *typeName() const override;
    void markSelected();
 
protected:
    void updateSelection();
 
    // original inconsistency: base class has member that is read by the sub classes
    int8 _order = 0;
private:
    Shape _shape;
    CursorType _cursorType = CursorType::Point;
    bool _isNewlySelected = false,
        _wasSelected = false;
};
 
class PhysicalObject : public ShapeObject {
public:
    static constexpr const char *kClassName = "CObjetoFisico";
    PhysicalObject(Room *room, Common::SeekableReadStream &stream);
    const char *typeName() const override;
};
 
class ButtonV1 : public PhysicalObject {
public:
    static constexpr const char *kClassName = "CBoton";
    ButtonV1(Room *room, Common::SeekableReadStream &stream);
 
    void loadResources() override;
    void draw() override;
    void update() override;
    void onHoverUpdate() override;
    void onClick() override;
    const char *typeName() const override;
 
private:
    MenuV1 &menu();
 
    MainMenuAction _action = {};
    Common::String _graphicName;
    ObjectBase *_graphicObject = nullptr;
    bool _isHovered = false;
};
 
class MenuButton : public PhysicalObject {
public:
    static constexpr const char *kClassName = "CBotonMenu";
    MenuButton(Room *room, Common::SeekableReadStream &stream);
    ~MenuButton() override {}
 
    inline int32 actionId() const { return _actionId; }
    inline bool &isInteractable() { return _isInteractable; }
 
    void draw() override;
    void update() override;
    void loadResources() override;
    void freeResources() override;
    void onHoverUpdate() override;
    void onClick() override;
    virtual void trigger();
    const char *typeName() const override;
 
private:
    bool
        _isInteractable = true,
        _isClicked = false,
        _triggerNextFrame = false;
    int32 _actionId;
    Graphic
        _graphicNormal,
        _graphicHovered,
        _graphicClicked,
        _graphicDisabled;
    FakeLock _interactionLock;
};
 
// some of the UI elements are only used for the multiplayer menus
// so are currently not needed
 
class InternetMenuButton final : public MenuButton {
public:
    static constexpr const char *kClassName = "CBotonMenuInternet";
    InternetMenuButton(Room *room, Common::SeekableReadStream &stream);
 
    const char *typeName() const override;
};
 
class OptionsMenuButton : public MenuButton {
public:
    static constexpr const char *kClassName = "CBotonMenuOpciones";
    OptionsMenuButton(Room *room, Common::SeekableReadStream &stream);
 
    void update() override;
    void trigger() override;
    const char *typeName() const override;
};
 
class OptionsMenuButtonV2 : public OptionsMenuButton {
public:
    OptionsMenuButtonV2(Room *room, Common::SeekableReadStream &stream);
 
    void update() override;
    void trigger() override;
};
 
class MainMenuButton : public MenuButton {
public:
    static constexpr const char *kClassName = "CBotonMenuPrincipal";
    MainMenuButton(Room *room, Common::SeekableReadStream &stream);
 
    void update() override;
    void trigger() override;
    const char *typeName() const override;
protected:
    virtual MainMenuAction action() const;
};
 
class MainMenuButtonV2 final : public MainMenuButton {
public:
    MainMenuButtonV2(Room *room, Common::SeekableReadStream &stream);
 
protected:
    MainMenuAction action() const override;
};
 
// this is a variant of a CheckBox only used in V2
class PushButton : public PhysicalObject {
public:
    static constexpr const char *kClassName = "CPushButton";
    PushButton(Room *room, Common::SeekableReadStream &stream);
 
    inline bool &isChecked() { return _isChecked; }
 
    void draw() override;
    void update() override;
    void loadResources() override;
    void freeResources() override;
    void onHoverUpdate() override;
    void onClick() override;
    virtual void trigger();
    const char *typeName() const override;
 
private:
    bool _isChecked = false;
    Graphic _graphicHovered, _graphicChecked;
    int32 _actionId = -1;
    uint32 _clickTime = 0;
};
 
class EditBox : public PhysicalObject {
public:
    static constexpr const char *kClassName = "CEditBox";
    EditBox(Room *room, Common::SeekableReadStream &stream);
 
    const char *typeName() const override;
 
protected:
    int32 i1 = 0;
    Common::Point p1;
    Common::String _labelId;
    bool b1 = false;
    int32 i3 = 0, i4 = 0, i5 = 0,
        _fontId = 0;
};
 
class EditBoxV2 final : public EditBox {
public:
    EditBoxV2(Room *room, Common::SeekableReadStream &stream);
};
 
class EditBoxV3 final : public EditBox {
public:
    EditBoxV3(Room *room, Common::SeekableReadStream &stream);
};
 
class CheckBox : public PhysicalObject {
public:
    static constexpr const char *kClassName = "CCheckBox";
    CheckBox(Room *room, Common::SeekableReadStream &stream);
    ~CheckBox() override {}
 
    inline bool &isChecked() { return _isChecked; }
    inline int32 actionId() const { return _actionId; }
 
    void draw() override;
    void update() override;
    void loadResources() override;
    void freeResources() override;
    void onHoverUpdate() override;
    void onClick() override;
    virtual void trigger();
    const char *typeName() const override;
 
private:
    bool
        _isChecked = false,
        _wasClicked = false;
    Graphic
        _graphicUnchecked,
        _graphicChecked,
        _graphicHovered,
        _graphicClicked;
    int32 _actionId = 0;
    uint32 _clickTime = 0;
};
 
class SlideButton : public ObjectBase {
public:
    static constexpr const char *kClassName = "CSlideButton";
    SlideButton(Room *room, Common::SeekableReadStream &stream);
 
    inline float &value() { return _value; }
 
    void draw() override;
    void update() override;
    void loadResources() override;
    void freeResources() override;
    const char *typeName() const override;
 
protected:
    bool isMouseOver() const;
 
    float _value = 0;
    int32 _valueId = -1;
    Common::Point _minPos, _maxPos;
    Graphic
        _graphicIdle,
        _graphicHovered,
        _graphicClicked;
};
 
class SlideButtonV2 final : public SlideButton {
public:
    SlideButtonV2(Room *room, Common::SeekableReadStream &stream);
};
 
class SlideButtonV3 final : public SlideButton {
public:
    SlideButtonV3(Room *room, Common::SeekableReadStream &stream);
};
 
class CheckBoxAutoAdjustNoise final : public CheckBox {
public:
    static constexpr const char *kClassName = "CCheckBoxAutoAjustarRuido";
    CheckBoxAutoAdjustNoise(Room *room, Common::SeekableReadStream &stream);
 
    const char *typeName() const override;
};
 
class IRCWindow final : public ObjectBase {
public:
    static constexpr const char *kClassName = "CVentanaIRC";
    IRCWindow(Room *room, Common::SeekableReadStream &stream);
 
    const char *typeName() const override;
 
private:
    Common::Point _p1, _p2;
};
 
class MessageBox final : public ObjectBase {
public:
    static constexpr const char *kClassName = "CMessageBox";
    MessageBox(Room *room, Common::SeekableReadStream &stream);
    ~MessageBox() override {}
 
    const char *typeName() const override;
 
private:
    Graphic
        _graph1,
        _graph2,
        _graph3,
        _graph4,
        _graph5;
};
 
class VoiceMeter final : public GraphicObject {
public:
    static constexpr const char *kClassName = "CVuMeter";
    VoiceMeter(Room *room, Common::SeekableReadStream &stream);
 
    const char *typeName() const override;
};
 
class Item : public GraphicObject { //-V690
public:
    static constexpr const char *kClassName = "CObjetoInventario";
    Item(Room *room, Common::SeekableReadStream &stream);
    Item(const Item &other);
    // no copy-assign operator as it is non-sensical, the copy ctor is a special case for item-handling
 
    void draw() override;
    const char *typeName() const override;
    void trigger();
};
 
class ITriggerableObject {
public:
    ITriggerableObject(Common::SeekableReadStream &stream);
    virtual ~ITriggerableObject() {}
 
    inline Direction interactionDirection() const { return _interactionDirection; }
    inline Common::Point interactionPoint() const { return _interactionPoint; }
 
    virtual void trigger(const char *action) = 0;
 
protected:
    ITriggerableObject() = default;
    void read(Common::SeekableReadStream &stream);
    void onClick();
 
    Common::Point _interactionPoint;
    Direction _interactionDirection = Direction::Right;
};
 
class InteractableObject : public PhysicalObject, public ITriggerableObject {
public:
    static constexpr const char *kClassName = "CObjetoTipico";
    InteractableObject(Room *room, Common::SeekableReadStream &stream);
    ~InteractableObject() override {}
 
    void drawDebug() override;
    void onClick() override;
    void trigger(const char *action) override;
    void toggle(bool isEnabled) override;
    const char *typeName() const override;
 
private:
    Common::String _relatedObject;
};
 
class Door final : public InteractableObject {
public:
    static constexpr const char *kClassName = "CPuerta";
    Door(Room *room, Common::SeekableReadStream &stream);
 
    inline const Common::String &targetRoom() const { return _targetRoom; }
    inline const Common::String &targetObject() const { return _targetObject; }
    inline Direction characterDirection() const { return _characterDirection; }
 
    CursorType cursorType() const override;
    void onClick() override;
    void trigger(const char *action) override;
    const char *typeName() const override;
 
private:
    Common::String _targetRoom, _targetObject;
    Direction _characterDirection;
    uint32 _lastClickTime = 0;
};
 
class Character : public ShapeObject, public ITriggerableObject {
public:
    static constexpr const char *kClassName = "CPersonaje";
    Character(Room *room, Common::SeekableReadStream &stream);
    ~Character() override {}
 
    void update() override;
    void draw() override;
    void drawDebug() override;
    void loadResources() override;
    void freeResources() override;
    void syncGame(Common::Serializer &serializer) override;
    Graphic *graphic() override;
    void onClick() override;
    void trigger(const char *action) override;
    const char *typeName() const override;
 
    Task *sayText(Process &process, int32 dialogId, const char *dialogSound);
    void resetTalking();
    void talkUsing(ObjectBase *talkObject);
    Task *animate(Process &process, ObjectBase *animateObject);
    Task *lerpLodBias(Process &process, float targetLodBias, int32 durationMs);
    inline float &lodBias() { return _lodBias; }
    inline bool &isSpeaking() { return _isSpeaking; }
 
protected:
    friend struct SayTextTask;
    friend struct AnimateCharacterTask;
    void syncObjectAsString(Common::Serializer &serializer, ObjectBase *&object);
    void updateTalkingAnimation();
 
    Graphic _graphicNormal, _graphicTalking;
 
    bool _isTalking = false; 
    bool _isSpeaking = true; 
    int _curDialogId = -1;
    float _lodBias = 0.0f;
    ObjectBase
        *_curAnimateObject = nullptr,
        *_curTalkingObject = nullptr;
};
 
class WalkingCharacter : public Character {
public:
    static constexpr const char *kClassName = "CPersonajeAnda";
    WalkingCharacter(Room *room, Common::SeekableReadStream &stream);
    ~WalkingCharacter() override {}
 
    inline bool isWalking() const { return _isWalking; }
    inline Common::Point position() const { return _currentPos; }
    inline float stepSizeFactor() const { return _stepSizeFactor; }
 
    void update() override;
    void draw() override;
    void drawDebug() override;
    void loadResources() override;
    void freeResources() override;
    void syncGame(Common::Serializer &serializer) override;
    virtual void walkTo(
        Common::Point target,
        Direction endDirection = Direction::Invalid,
        ITriggerableObject *activateObject = nullptr,
        const char *activateAction = nullptr);
    void stopWalking(Direction direction = Direction::Invalid);
    void setPosition(Common::Point target);
    const char *typeName() const override;
 
    Task *waitForArrival(Process &process);
 
protected:
    virtual void onArrived();
    void updateWalking();
    void updateWalkingAnimation();
 
    inline Animation *currentAnimationOf(Common::ScopedPtr<Animation> *const animations) {
        Animation *animation = animations[(int)_direction].get();
        if (animation == nullptr)
            animation = animations[0].get();
        assert(animation != nullptr);
        return animation;
    }
    inline Animation *walkingAnimation() { return currentAnimationOf(_walkingAnimations); }
    inline Animation *talkingAnimation() { return currentAnimationOf(_talkingAnimations); }
 
    Common::ScopedPtr<Animation>
        _walkingAnimations[kDirectionCount],
        _talkingAnimations[kDirectionCount];
 
    int32
        _lastWalkAnimFrame = -1,
        _walkedDistance = 0,
        _curPathPointI = -1;
    float _stepSizeFactor = 0.0f;
    Common::Point
        _sourcePos,
        _currentPos;
    bool _isWalking = false;
    Direction
        _direction = Direction::Right,
        _endWalkingDirection = Direction::Invalid;
    Common::Stack<Common::Point> _pathPoints;
};
 
struct DialogMenuLine {
    int32 _dialogId = -1;
    int32 _yPosition = 0;
    int32 _returnValue = 0;
};
 
class MainCharacter final : public WalkingCharacter {
public:
    static constexpr const char *kClassName = "CPersonajePrincipal";
    MainCharacter(Room *room, Common::SeekableReadStream &stream);
    ~MainCharacter() override;
 
    inline MainCharacterKind kind() const { return _kind; }
    inline ObjectBase *&currentlyUsing() { return _currentlyUsingObject; }
    inline ObjectBase *currentlyUsing() const { return _currentlyUsingObject; }
    inline Color &color() { return _color; }
    inline uint8 &alphaPremultiplier() { return _alphaPremultiplier; }
    inline FakeSemaphore &semaphore() { return _semaphore; }
    bool isBusy() const;
 
    void update() override;
    void draw() override;
    void syncGame(Common::Serializer &serializer) override;
    const char *typeName() const override;
    void walkTo(
        Common::Point target,
        Direction endDirection = Direction::Invalid,
        ITriggerableObject *activateObject = nullptr,
        const char *activateAction = nullptr) override;
    void walkToMouse();
    bool clearTargetIf(const ITriggerableObject *target);
    void clearInventory();
    bool hasItem(const Common::String &name) const;
    void pickup(const Common::String &name, bool putInHand);
    void drop(const Common::String &name);
    void addDialogLine(int32 dialogId);
    void setLastDialogReturnValue(int32 returnValue);
    Task *dialogMenu(Process &process);
    void resetUsingObjectAndDialogMenu();
 
protected:
    void onArrived() override;
 
private:
    friend class Inventory;
    friend struct DialogMenuTask;
    Item *getItemByName(const Common::String &name) const;
    void drawInner();
 
    Common::Array<Item *> _items;
    Common::Array<DialogMenuLine> _dialogLines;
    ObjectBase *_currentlyUsingObject = nullptr;
    MainCharacterKind _kind;
    FakeSemaphore _semaphore;
    ITriggerableObject *_activateObject = nullptr;
    const char *_activateAction = nullptr;
    Color _color = kWhite;
    uint8 _alphaPremultiplier = 255;
};
 
class Background final : public GraphicObject {
public:
    Background(Room *room, const Common::String &animationFileName, int16 scale);
    const char *typeName() const override;
};
 
class FloorColor final : public ObjectBase {
public:
    static constexpr const char *kClassName = "CSueloColor";
    FloorColor(Room *room, Common::SeekableReadStream &stream);
    ~FloorColor() override {}
 
    void update() override;
    void drawDebug() override;
    Shape *shape() override;
    const char *typeName() const override;
 
private:
    FloorColorShape _shape;
};
 
}
 
#endif // ALCACHOFA_OBJECTS_H