scummvm/engines/twp/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