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 "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::ReadStream &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::ReadStream &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::ReadStream &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;
    int32 _posterizeAlpha;
};

class SpecialEffectObject final : public GraphicObject {
public:
    static constexpr const char *kClassName = "CObjetoGraficoMuare";
    SpecialEffectObject(Room *room, Common::ReadStream &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::ReadStream &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;
    bool _isNewlySelected = false,
        _wasSelected = false;
};

class PhysicalObject : public ShapeObject {
public:
    PhysicalObject(Room *room, Common::ReadStream &stream);
    const char *typeName() const override;
};

class MenuButton : public PhysicalObject {
public:
    static constexpr const char *kClassName = "CBotonMenu";
    MenuButton(Room *room, Common::ReadStream &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::ReadStream &stream);

    const char *typeName() const override;
};

class OptionsMenuButton final : public MenuButton {
public:
    static constexpr const char *kClassName = "CBotonMenuOpciones";
    OptionsMenuButton(Room *room, Common::ReadStream &stream);

    void update() override;
    void trigger() override;
    const char *typeName() const override;
};

class MainMenuButton final : public MenuButton {
public:
    static constexpr const char *kClassName = "CBotonMenuPrincipal";
    MainMenuButton(Room *room, Common::ReadStream &stream);

    void update() override;
    void trigger() override;
    const char *typeName() const override;
};

class PushButton final : public PhysicalObject {
public:
    static constexpr const char *kClassName = "CPushButton";
    PushButton(Room *room, Common::ReadStream &stream);

    const char *typeName() const override;

private:
    bool _alwaysVisible;
    Graphic _graphic1, _graphic2;
    int32 _actionId;
};

class EditBox final : public PhysicalObject {
public:
    static constexpr const char *kClassName = "CEditBox";
    EditBox(Room *room, Common::ReadStream &stream);

    const char *typeName() const override;

private:
    int32 i1;
    Common::Point p1;
    Common::String _labelId;
    bool b1;
    int32 i3, i4, i5,
        _fontId;
};

class CheckBox : public PhysicalObject {
public:
    static constexpr const char *kClassName = "CCheckBox";
    CheckBox(Room *room, Common::ReadStream &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 final : public ObjectBase {
public:
    static constexpr const char *kClassName = "CSlideButton";
    SlideButton(Room *room, Common::ReadStream &stream);
    ~SlideButton() override {}

    inline float &value() { return _value; }

    void draw() override;
    void update() override;
    void loadResources() override;
    void freeResources() override;
    const char *typeName() const override;

private:
    bool isMouseOver() const;

    float _value = 0;
    int32 _valueId;
    Common::Point _minPos, _maxPos;
    Graphic
        _graphicIdle,
        _graphicHovered,
        _graphicClicked;
};

class CheckBoxAutoAdjustNoise final : public CheckBox {
public:
    static constexpr const char *kClassName = "CCheckBoxAutoAjustarRuido";
    CheckBoxAutoAdjustNoise(Room *room, Common::ReadStream &stream);

    const char *typeName() const override;
};

class IRCWindow final : public ObjectBase {
public:
    static constexpr const char *kClassName = "CVentanaIRC";
    IRCWindow(Room *room, Common::ReadStream &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::ReadStream &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::ReadStream &stream);

    const char *typeName() const override;
};

class Item : public GraphicObject { //-V690
public:
    static constexpr const char *kClassName = "CObjetoInventario";
    Item(Room *room, Common::ReadStream &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::ReadStream &stream);
    virtual ~ITriggerableObject() {}

    inline Direction interactionDirection() const { return _interactionDirection; }
    inline Common::Point interactionPoint() const { return _interactionPoint; }

    virtual void trigger(const char *action) = 0;

protected:
    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::ReadStream &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::ReadStream &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::ReadStream &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);
    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::ReadStream &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::ReadStream &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::ReadStream &stream);
    ~FloorColor() override {}

    void update() override;
    void drawDebug() override;
    Shape *shape() override;
    const char *typeName() const override;

private:
    FloorColorShape _shape;
};

}

#endif // ALCACHOFA_OBJECTS_H