motor.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 TWP_MOTOR_H
#define TWP_MOTOR_H

#include "math/vector2d.h"
#include "twp/camera.h"
#include "twp/util.h"
#include "twp/lip.h"

namespace Twp {

template<typename T>
struct Tween {
public:
    Tween(T f, T t, float d, InterpolationMethod im)
        : frm(f), to(t), delta(t - f), duration(d), value(f), easing_f(easing(im.kind)), swing(im.swing), loop(im.loop) {
    }

    bool running() {
        if (swing || loop) {
            return true;
        }
        return elapsed < duration;
    }

    void update(float el) {
        if (enabled && running()) {
            elapsed += el;
            float f = CLIP(elapsed / duration, 0.0f, 1.0f);
            if (!dir_forward)
                f = 1.0f - f;
            if ((elapsed > duration) && (swing || loop)) {
                elapsed = elapsed - duration;
                if (swing)
                    dir_forward = !dir_forward;
            }
            if (easing_f.func) {
                f = easing_f.func(f);
                value = frm + delta * f;
            }
        } else {
            value = to;
        }
    }

    T current() const { return value; }

public:
    T frm, to, delta;
    float elapsed = 0.f;
    float duration = 0.f; // duration in ms
    T value;
    EasingFunc_t easing_f;
    bool enabled = true;
    bool dir_forward = true;
    bool swing = false;
    bool loop = false;
};

class Motor {
public:
    virtual ~Motor() {}
    virtual void disable() {
        _enabled = false;
    }
    virtual bool isEnabled() const { return _enabled; }
    void update(float elapsed);

protected:
    virtual void onUpdate(float elapsed) = 0;

protected:
    bool _enabled = true;
};

class Object;
class OffsetTo : public Motor {
public:
    virtual ~OffsetTo();
    OffsetTo(float duration, Common::SharedPtr<Object> obj, const Math::Vector2d &pos, InterpolationMethod im);

private:
    virtual void onUpdate(float elasped) override;

private:
    Common::SharedPtr<Object> _obj;
    Tween<Math::Vector2d> _tween;
};

class MoveTo : public Motor {
public:
    virtual ~MoveTo();
    MoveTo(float duration, Common::SharedPtr<Object> obj, const Math::Vector2d &pos, InterpolationMethod im);

private:
    virtual void onUpdate(float elasped) override;

private:
    Common::SharedPtr<Object> _obj;
    Tween<Math::Vector2d> _tween;
};

class AlphaTo : public Motor {
public:
    virtual ~AlphaTo();
    AlphaTo(float duration, Common::SharedPtr<Object> obj, float to, InterpolationMethod im);

private:
    virtual void onUpdate(float elasped) override;

private:
    Common::SharedPtr<Object> _obj;
    Tween<float> _tween;
};

class Node;
class RotateTo : public Motor {
public:
    virtual ~RotateTo();
    RotateTo(float duration, Node *obj, float to, InterpolationMethod im);

private:
    virtual void onUpdate(float elasped) override;

private:
    Node *_node = nullptr;
    Tween<float> _tween;
};

class RoomRotateTo : public Motor {
public:
    virtual ~RoomRotateTo();
    RoomRotateTo(Common::SharedPtr<Room> room, float to);

private:
    virtual void onUpdate(float elasped) override;

private:
    Common::SharedPtr<Room> _room;
    Tween<float> _tween;
};

class ScaleTo : public Motor {
public:
    virtual ~ScaleTo();
    ScaleTo(float duration, Node *node, float to, InterpolationMethod im);

private:
    virtual void onUpdate(float elasped) override;

private:
    Node *_node = nullptr;
    Tween<float> _tween;
};

class Shake : public Motor {
public:
    virtual ~Shake();
    Shake(Node *node, float amount);

private:
    virtual void onUpdate(float elasped) override;

private:
    Node *_node = nullptr;
    float _amount = 0.f;
    float _shakeTime = 0.f;
    float _elapsed = 0.f;
};

class OverlayTo : public Motor {
public:
    virtual ~OverlayTo();
    OverlayTo(float duration, Common::SharedPtr<Room> room, const Color &to);

    virtual void onUpdate(float elapsed) override;

private:
    Common::SharedPtr<Room> _room;
    Color _to;
    Tween<Color> _tween;
};

class ReachAnim : public Motor {
public:
    virtual ~ReachAnim();
    ReachAnim(Common::SharedPtr<Object> actor, Common::SharedPtr<Object> obj);

    virtual void onUpdate(float elasped) override;

private:
    void playReachAnim();

private:
    Common::SharedPtr<Object> _actor;
    Common::SharedPtr<Object> _obj;
    int _state = 0;
    float _elapsed = 0.f;
};

enum WalkToState {
    kWalking,
    kArrived,
    kReach
};

class WalkTo : public Motor {
public:
    WalkTo(Common::SharedPtr<Object> obj, const Math::Vector2d &dest, int facing = 0);
    void disable() override;

    const Common::Array<Math::Vector2d> &getPath() const { return _path; }

private:
    void actorArrived();
    void onUpdate(float elapsed) override;

private:
    Common::SharedPtr<Object> _obj;
    Common::Array<Math::Vector2d> _path;
    int _facing = 0;
    float _wsd;
    WalkToState _state = kWalking;
};

class TextNode;

class TalkingBase : public Motor {
protected:
    TalkingBase(Common::SharedPtr<Object> actor, float duration);

public:
    virtual ~TalkingBase() {}

protected:
    Common::String talkieKey();
    int onTalkieId(int id);
    int loadActorSpeech(const Common::String &name);
    void setDuration(const Common::String &text);
    float getTalkSpeed() const;

protected:
    Common::SharedPtr<Object> _actor;
    float _duration = 0.f;
    float _elapsed = 0.f;
};

// Creates a talking animation for a specified object.
class Talking : public TalkingBase {
public:
    Talking(Common::SharedPtr<Object> obj, const Common::StringArray &texts, const Color &color);
    virtual ~Talking() {}

    void append(const Common::StringArray &texts, const Color &color);

    virtual void onUpdate(float elapsed) override;
    virtual void disable() override;

private:
    void say(const Common::String &text);

private:
    Common::SharedPtr<TextNode> _node;
    Lip _lip;
    Color _color;
    Common::StringArray _texts;
};

class SayLineAt : public TalkingBase {
public:
    SayLineAt(const Math::Vector2d &pos, const Color &color, Common::SharedPtr<Object> actor, float duration, const Common::String &text);
    virtual ~SayLineAt() {}

    virtual void onUpdate(float elapsed) override;
    virtual void disable() override;

private:
    void say(const Common::String &text);

private:
    const Math::Vector2d _pos;
    Color _color;
    Common::String _text;
    Common::SharedPtr<TextNode> _node;
};

class Jiggle : public Motor {
public:
    Jiggle(Node *node, float amount);
    virtual ~Jiggle();

private:
    virtual void onUpdate(float elapsed) override;

private:
    Node *_node = nullptr;
    float _amount = 0.f;
    float _jiggleTime = 0.f;
};

class MoveCursorTo : public Motor {
public:
    MoveCursorTo(const Math::Vector2d &pos, float time);
    virtual ~MoveCursorTo() {}

private:
    virtual void onUpdate(float elapsed) override;

private:
    Tween<Math::Vector2d> _tween;
    Math::Vector2d _pos;
};

} // namespace Twp

#endif