scummvm/engines/twp/object.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_OBJECT_H
#define TWP_OBJECT_H

#include "common/array.h"
#include "common/rect.h"
#include "common/str.h"
#include "math/vector2d.h"
#include "twp/squirrel/squirrel.h"
#include "twp/ids.h"
#include "twp/gfx.h"
#include "twp/util.h"
#include "twp/objectanimation.h"

#define STAND_ANIMNAME "stand"
#define HEAD_ANIMNAME "head"
#define WALK_ANIMNAME "walk"
#define REACH_ANIMNAME "reach"

namespace Twp {

enum ObjectType {
	otNone,
	otProp,
	otSpot,
	otTrigger
};

enum Direction {
	dNone = 0,
	dRight = 1,
	dLeft = 2,
	dFront = 4,
	dBack = 8
};

enum class Facing {
	FACE_RIGHT = 1,
	FACE_LEFT = 2,
	FACE_FRONT = 4,
	FACE_BACK = 8
};

enum class UseFlag {
	ufNone,
	ufUseWith,
	ufUseOn,
	ufUseIn,
	ufGiveTo
};

class Trigger {
public:
	virtual ~Trigger() {}
	virtual void trig() = 0;
};

struct VerbId {
	int id = VERB_WALKTO;
};

class Object;
struct Sentence {
	VerbId verb;
	Common::SharedPtr<Object> noun1;
	Common::SharedPtr<Object> noun2;
	bool enabled = false;
};

class Anim;
class Room;
class Motor;
class Node;
class Layer;
class Blink;
class TextNode;

struct TalkingState {
	Common::SharedPtr<Object> _obj;
	Color _color;

	void say(const Common::StringArray &texts, Common::SharedPtr<Object> obj);
};

struct LockFacing {
	Facing key;
	Facing value;
};

struct ObjectIcons {
	int fps = 0;
	Common::StringArray icons;
};

class Object {
public:
	Object();
	Object(HSQOBJECT o, const Common::String &key);
	~Object();

	static Common::SharedPtr<Object> createActor();

	Common::String getName() const;
	int getId() const;

	// Changes the `state` of an object, although this can just be a internal state,
	//
	// it is typically used to change the object's image as it moves from it's current state to another.
	// Behind the scenes, states as just simple ints. State0, State1, etc.
	// Symbols like `CLOSED` and `OPEN` and just pre-defined to be 0 or 1.
	// State 0 is assumed to be the natural state of the object, which is why `OPEN` is 1 and `CLOSED` is 0 and not the other way around.
	// This can be a little confusing at first.
	// If the state of an object has multiple frames, then the animation is played when changing state, such has opening the clock.
	// `GONE` is a unique in that setting an object to `GONE` both sets its graphical state to 1, and makes it untouchable.
	// Once an object is set to `GONE`, if you want to make it visible and touchable again, you have to set both:
	//
	// .. code-block:: Squirrel
	// objectState(coin, HERE)
	// objectTouchable(coin, YES)
	void setState(int state, bool instant = false);
	int getState() const { return _state; }

	bool isTouchable();
	void setTouchable(bool value);

	void play(int state, bool loop = false, bool instant = false);
	// Plays an animation specified by the `state`.
	void play(const Common::String &state, bool loop = false, bool instant = false);

	void showLayer(const Common::String &layer, bool visible);
	Facing getFacing() const;
	void lockFacing(int facing);
	void lockFacing(Facing left, Facing right, Facing front, Facing back);
	void resetLockFacing();
	void trig(const Common::String &name);

	void setPop(int count);
	int getPop() const { return _popCount; }
	float popScale() const;
	float getScale();

	int defaultVerbId();
	void setFacing(Facing facing);

	Math::Vector2d getUsePos();
	Facing getDoorFacing();

	void setIcon(int fps, const Common::StringArray &icons);
	void setIcon(const Common::String &icon);
	Common::String getIcon();
	ObjectIcons getIcons() const;
	bool inInventory();
	void removeInventory(Common::SharedPtr<Object> obj);

	int getFlags();
	UseFlag useFlag();

	bool contains(const Math::Vector2d &pos);
	static void setRoom(Common::SharedPtr<Object> object, Common::SharedPtr<Room> room);
	void stopObjectMotors();
	void dependentOn(Common::SharedPtr<Object> dependentObj, int state);

	Common::String getAnimName(const Common::String &key);
	void setHeadIndex(int head);
	void setAnimationNames(const Common::String &head, const Common::String &stand, const Common::String &walk, const Common::String &reach);
	Common::String getReachAnim();

	bool isWalking();
	void stopWalking();
	static void blinkRate(Common::SharedPtr<Object>, float min, float max);
	void setCostume(const Common::String &name, const Common::String &sheet);
	void stand();

	void update(float elapsedSec);

	void setAlphaTo(Common::SharedPtr<Motor> alphaTo);
	void setRotateTo(Common::SharedPtr<Motor> rotateTo);
	void setMoveTo(Common::SharedPtr<Motor> moveTo);
	void setReach(Common::SharedPtr<Motor> reach);
	Common::SharedPtr<Motor> getWalkTo() { return _walkTo; }
	Common::SharedPtr<Motor> getReach() { return _reach; }
	static void walk(Common::SharedPtr<Object> obj, const Math::Vector2d &pos, int facing = 0);
	static void walk(Common::SharedPtr<Object> actor, Common::SharedPtr<Object> obj);

	void setTalking(Common::SharedPtr<Motor> talking);
	void setShakeTo(Common::SharedPtr<Motor> shakeTo);
	void setScaleTo(Common::SharedPtr<Motor> scaleTo);

	Common::SharedPtr<Motor> getTalking() { return _talking; }
	void stopTalking();
	static void say(Common::SharedPtr<Object> obj, const Common::StringArray &texts, const Color &color);

	static void pickupObject(Common::SharedPtr<Object> actor, Common::SharedPtr<Object> obj);

	static void execVerb(Common::SharedPtr<Object> obj);
	void turn(Facing facing);
	static void turn(Common::SharedPtr<Object> actor, Common::SharedPtr<Object> obj);
	void jiggle(float amount);

	void inventoryScrollUp();
	void inventoryScrollDown();

private:
	Common::String suffix() const;
	// Plays an animation specified by the state
	bool playCore(const Common::String &state, bool loop = false, bool instant = false);

public:
	HSQOBJECT _table;
	Common::String _name;
	Common::String _parent;
	Common::String _sheet; // Spritesheet to use when a sprite is displayed in the room: "raw" means raw texture, empty string means use room texture
	Common::String _key;   // key used to identify this object by script
	Common::String _costumeName, _costumeSheet;
	int _state = -1;
	Math::Vector2d _usePos; // use position
	Direction _useDir = dNone;
	Common::Rect _hotspot;
	ObjectType _objType = otNone;
	Common::SharedPtr<Room> _room;
	Common::Array<ObjectAnimation> _anims;
	bool _temporary = false;
	Common::SharedPtr<Node> _node;
	Common::SharedPtr<TextNode> _sayNode;
	Common::SharedPtr<Anim> _nodeAnim;
	Common::SharedPtr<Layer> _layer;
	Common::StringArray _hiddenLayers;
	Common::String _animName;
	int _animFlags = 0;
	bool _animLoop = false;
	Common::Array<LockFacing> _facingMap;
	Facing _facing = Facing::FACE_FRONT;
	int _facingLockValue = 0;
	float _fps = 0.f;
	Common::HashMap<int, Common::SharedPtr<Trigger> > _triggers;
	Math::Vector2d _talkOffset;
	Math::Vector2d _walkSpeed;
	bool _triggerActive = false;
	bool _useWalkboxes = false;
	float _volume = 1.f;
	Color _talkColor;
	Common::HashMap<Common::String, Common::String> _animNames;
	bool _lit = false;
	Common::SharedPtr<Object> _owner;
	Common::Array<Common::SharedPtr<Object> > _inventory;
	int _inventoryOffset = 0;
	int _iconIndex = 0;
	float _iconElapsed = 0.f;
	HSQOBJECT _enter, _leave;
	int _dependentState = 0;
	Common::SharedPtr<Object> _dependentObj;
	float _popElapsed = 0.f;
	int _popCount = 0;
	Sentence _exec;
	int _sound = 0;
	bool _jiggle = false;

private:
	Common::SharedPtr<Motor> _alphaTo;
	Common::SharedPtr<Motor> _rotateTo;
	Common::SharedPtr<Motor> _moveTo;
	Common::SharedPtr<Motor> _walkTo;
	Common::SharedPtr<Motor> _reach;
	Common::SharedPtr<Motor> _talking;
	Common::SharedPtr<Blink> _blink;
	Common::SharedPtr<Motor> _turnTo;
	Common::SharedPtr<Motor> _shakeTo;
	Common::SharedPtr<Motor> _jiggleTo;
	Common::SharedPtr<Motor> _scaleTo;
	TalkingState _talkingState;
};

} // namespace Twp

#endif