qd_game_object_state.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 QDENGINE_QDCORE_QD_GAME_OBJECT_STATE_H
#define QDENGINE_QDCORE_QD_GAME_OBJECT_STATE_H
 
#include "qdengine/parser/xml_fwd.h"
#include "qdengine/qdcore/qd_contour.h"
#include "qdengine/qdcore/qd_sound_info.h"
#include "qdengine/qdcore/qd_animation_info.h"
#include "qdengine/qdcore/qd_animation_set_info.h"
#include "qdengine/qdcore/qd_conditional_object.h"
#include "qdengine/qdcore/qd_named_object.h"
#include "qdengine/qdcore/qd_coords_animation.h"
#include "qdengine/qdcore/qd_camera_mode.h"
#include "qdengine/qdcore/qd_sound_handle.h"
#include "qdengine/qdcore/qd_screen_text.h"
#include "qdengine/qdcore/qd_grid_zone.h"
#include "qdengine/system/sound/snd_sound.h"
 
namespace QDEngine {
 
class qdScreenTransform {
public:
    qdScreenTransform(float angle = 0.f, const Vect2f &scale = Vect2f(1.f, 1.f)) : _angle(angle), _scale(scale) { }
 
    bool operator == (const qdScreenTransform &trans) const;
    bool operator != (const qdScreenTransform &trans) const {
        return !(*this == trans);
    }
    bool operator()() const {
        return _angle != 0.f || _scale.x != 1.f || _scale.y != 1.f;
    }
 
    qdScreenTransform operator *(float value) const {
        return qdScreenTransform(_angle *value, _scale *value);
    }
 
    qdScreenTransform &operator += (const qdScreenTransform &trans) {
        _angle += trans._angle;
        _scale += trans._scale;
 
        return *this;
    }
 
    bool change(float dt, const qdScreenTransform &target_trans, const qdScreenTransform &speed);
 
    float angle() const {
        return _angle;
    }
    void set_angle(float angle) {
        _angle = angle;
    }
 
    const Vect2f &scale() const {
        return _scale;
    }
    void set_scale(const Vect2f &scale) {
        _scale = scale;
    }
    bool has_scale() const {
        return fabs(_scale.x - 1.f) > FLT_EPS || fabs(_scale.y - 1.f) > FLT_EPS;
    }
 
private:
 
    float _angle;
    Vect2f _scale;
 
};
 
class qdGameObjectState : public qdConditionalObject {
public:
    enum {
        QD_OBJ_STATE_FLAG_HIDDEN            = 0x01,
        QD_OBJ_STATE_FLAG_NOT_IN_TRIGGERS  = 0x02,
        QD_OBJ_STATE_FLAG_RESTORE_PREV_STATE        = 0x04,
        QD_OBJ_STATE_FLAG_HIDE_OBJECT           = 0x08,
        QD_OBJ_STATE_FLAG_GLOBAL_OWNER          = 0x10,
        QD_OBJ_STATE_FLAG_INVENTORY         = 0x20,
        QD_OBJ_STATE_FLAG_MOVE_TO_INVENTORY     = 0x40,
        QD_OBJ_STATE_FLAG_MOVE_TO_INVENTORY_FAILED  = 0x80,
        QD_OBJ_STATE_FLAG_HAS_BOUND         = 0x100,
        QD_OBJ_STATE_FLAG_ACTIVATION_TIMER      = 0x200,
        QD_OBJ_STATE_FLAG_ACTIVATION_TIMER_END      = 0x400,
 
        QD_OBJ_STATE_FLAG_DIALOG_PHRASE         = 0x800,
 
        QD_OBJ_STATE_FLAG_SOUND_SYNC            = 0x1000,
 
        QD_OBJ_STATE_FLAG_ENABLE_INTERRUPT      = 0x2000,
 
        QD_OBJ_STATE_FLAG_WAS_ACTIVATED         = 0x4000,
 
        QD_OBJ_STATE_FLAG_DISABLE_WALK_INTERRUPT    = 0x8000,
        QD_OBJ_STATE_FLAG_MOUSE_STATE           = 0x10000,
        QD_OBJ_STATE_FLAG_MOUSE_HOVER_STATE     = 0x20000,
        QD_OBJ_STATE_FLAG_STAY_IN_INVENTORY     = 0x40000,
        QD_OBJ_STATE_FLAG_FORCED_LOAD           = 0x80000,
        QD_OBJ_STATE_FLAG_ENABLE_SKIP           = 0x100000,
        QD_OBJ_STATE_FLAG_MOVE_TO_ZONE          = 0x200000,
        QD_OBJ_STATE_FLAG_MOVE_ON_OBJECT        = 0x400000,
        QD_OBJ_STATE_FLAG_ACTIVATE_PERSONAGE        = 0x800000,
        QD_OBJ_STATE_FLAG_AUTO_LOAD                 = 0x1000000,
        QD_OBJ_STATE_FLAG_AUTO_SAVE                 = 0x2000000,
        QD_OBJ_STATE_FLAG_FADE_IN                   = 0x4000000,
        QD_OBJ_STATE_FLAG_FADE_OUT                  = 0x8000000,
    };
 
    enum StateType {
        STATE_STATIC,
        STATE_WALK,
        STATE_MASK
    };
 
    enum {
        CURSOR_UNASSIGNED = -1
    };
 
    qdGameObjectState(StateType tp);
    qdGameObjectState(const qdGameObjectState &st);
    virtual ~qdGameObjectState();
 
    virtual qdGameObjectState &operator = (const qdGameObjectState &st);
 
    int named_object_type() const {
        return QD_NAMED_OBJECT_OBJ_STATE;
    }
 
    qdCoordsAnimation *coords_animation() {
        return &_coords_animation;
    }
    const qdCoordsAnimation *coords_animation() const {
        return &_coords_animation;
    }
 
    virtual bool load_script(const xml::tag *p) = 0;
    virtual bool save_script(Common::WriteStream &fh, int indent = 0) const = 0;
 
    bool init();
 
    bool load_data(Common::SeekableReadStream &fh, int save_version);
    bool save_data(Common::WriteStream &fh) const;
 
    virtual bool register_resources();
    virtual bool unregister_resources();
    virtual bool load_resources();
    virtual bool free_resources();
 
    bool check_conditions();
 
    const Vect2s &center_offset() const {
        return _center_offset;
    }
    void set_center_offset(const Vect2s offs) {
        _center_offset = offs;
    }
 
    void quant(float dt);
 
    qdGameObjectState *prev_state() {
        return _prev_state;
    }
    void set_prev_state(qdGameObjectState *p) {
        _prev_state = p;
    }
 
    StateType state_type() const {
        return _state_type;
    }
 
    int mouse_cursor_ID() const {
        return _mouse_cursor_id;
    }
 
    void set_mouse_cursor_ID(int id) {
        _mouse_cursor_id = id;
    }
    bool has_mouse_cursor_ID() const {
        return _mouse_cursor_id != CURSOR_UNASSIGNED;
    }
 
    const char *sound_name() const {
        return _sound_info.name();
    }
    void set_sound_name(const char *p) {
        _sound_info.set_name(p);
    }
    qdSound *sound() const;
    bool has_sound() const {
        if (sound_name()) return true;
        else return false;
    }
    const qdSoundHandle *sound_handle() const {
        return &_sound_handle;
    }
    bool play_sound();
    bool stop_sound() const;
    bool set_sound_frequency(float frequency_coeff) const;
    bool is_sound_finished() const;
    bool is_sound_playing() const;
 
    void set_sound_flag(int fl) {
        _sound_info.set_flag(fl);
    }
    void drop_sound_flag(int fl) {
        _sound_info.drop_flag(fl);
    }
    bool check_sound_flag(int fl) const {
        return _sound_info.check_flag(fl);
    }
 
    virtual bool is_state_empty() const;
 
    bool is_active() const;
    bool is_default() const;
 
    float activation_delay() const {
        return _activation_delay;
    }
    void set_activation_delay(float tm) {
        _activation_delay = tm;
    }
    void set_activation_timer() {
        _activation_timer = _activation_delay;
    }
 
    void start() {
        _cur_time = 0.0f;
        _is_sound_started = false;
    }
 
    float cur_time() const {
        return _cur_time;
    }
    float work_time() const;
    void set_work_time(float tm) {
        _work_time = tm;
    }
 
    bool need_to_walk() const {
        if (!_coords_animation.is_empty()
                && _coords_animation.check_flag(QD_COORDS_ANM_OBJECT_START_FLAG))
            return true;
        else
            return false;
    }
 
    virtual qdGameObjectState *clone() const = 0;
 
    virtual float adjust_direction_angle(float angle) const {
        return angle;
    }
 
    const Vect3f start_pos() const {
        if (!_coords_animation.is_empty()) {
            return _coords_animation.get_point(0)->dest_pos();
        } else
            return Vect3f(0, 0, 0);
    }
    float start_direction_angle() const {
        if (!_coords_animation.is_empty()) {
            return _coords_animation.get_point(0)->direction_angle();
        } else
            return -1.0f;
    }
 
    int reference_count() const {
        return _reference_count;
    }
    void inc_reference_count() {
        _reference_count++;
    }
    void dec_reference_count() {
        if (_reference_count) _reference_count--;
    }
 
    bool has_text() const {
        return (!_text_ID.empty() || !_short_text_ID.empty());
    }
    const char *text() const {
        if (has_full_text()) return full_text();
        else return short_text();
    }
    const char *full_text() const;
    const char *short_text() const;
 
    bool has_full_text() const {
        return !_text_ID.empty();
    }
    bool has_short_text() const {
        return !_short_text_ID.empty();
    }
    const char *full_text_ID() const {
        return _text_ID.c_str();
    }
 
    void set_full_text_ID(const char *p) {
        if (p) _text_ID = p;
        else _text_ID.clear();
    }
    const char *short_text_ID() const {
        return _short_text_ID.c_str();
    }
 
    void set_short_text_ID(const char *p) {
        if (p) _short_text_ID = p;
        else _short_text_ID.clear();
    }
 
    bool has_bound() const {
        return check_flag(QD_OBJ_STATE_FLAG_HAS_BOUND);
    }
    const Vect3f &bound() const {
        return _bound;
    }
    float radius() const {
        return _radius;
    }
    void set_bound(const Vect3f &b);
    virtual bool auto_bound() {
        return false;
    }
 
    void set_camera_mode(const qdCameraMode &mode) {
        _camera_mode = mode;
    }
    const qdCameraMode &camera_mode() const {
        return _camera_mode;
    }
    bool has_camera_mode() const {
        return _camera_mode.camera_mode() != qdCameraMode::MODE_UNASSIGNED;
    }
 
    float rnd_move_radius() const {
        return _rnd_move_radius;
    }
    void set_rnd_move_radius(float radius) {
        _rnd_move_radius = radius;
    }
 
    float rnd_move_speed() const {
        return _rnd_move_speed;
    }
    void set_rnd_move_speed(float speed) {
        _rnd_move_speed = speed;
    }
 
    qdConditionalObject::trigger_start_mode trigger_start();
    bool trigger_can_start() const;
 
    bool forced_load() const {
        return check_flag(QD_OBJ_STATE_FLAG_FORCED_LOAD);
    }
 
    float text_delay() const {
        return _text_delay;
    }
    bool has_text_delay() const {
        return _text_delay > FLT_EPS;
    }
    void set_text_delay(float delay) {
        _text_delay = delay;
    }
 
    float sound_delay() const {
        return _sound_delay;
    }
    bool has_sound_delay() const {
        return _sound_delay > FLT_EPS;
    }
    void set_sound_delay(float delay) {
        _sound_delay = delay;
    }
 
    int autosave_slot() const {
        return _autosave_slot;
    }
    void set_autosave_slot(int slot) {
        _autosave_slot = slot;
    }
 
    float fade_time() const {
        return _fade_time;
    }
    void set_fade_time(float time) {
        _fade_time = time;
    }
 
    uint32 shadow_color() const {
        return _shadow_color;
    }
    int shadow_alpha() const {
        return _shadow_alpha;
    }
 
    void set_shadow(uint32 color, int alpha) {
        _shadow_color = color;
        _shadow_alpha = alpha;
    }
 
    const qdScreenTextFormat &text_format(bool topic_mode = false) const {
        if (_text_format.is_global_depend()) {
            return (topic_mode && check_flag(QD_OBJ_STATE_FLAG_DIALOG_PHRASE)) ?
                   qdScreenTextFormat::global_topic_format() : qdScreenTextFormat::global_text_format();
        }
        return _text_format;
    }
    void set_text_format(const qdScreenTextFormat &text_format) {
        _text_format = text_format;
    }
 
    bool has_transform() const {
        return _transform() || _transform_speed();
    }
 
    const qdScreenTransform &transform() const {
        return _transform;
    }
    void set_transform(const qdScreenTransform &tr) {
        _transform = tr;
    }
    const qdScreenTransform &transform_speed() const {
        return _transform_speed;
    }
    void set_transform_speed(const qdScreenTransform &tr_speed) {
        _transform_speed = tr_speed;
    }
 
    static Common::String flag2str(int fl, bool truncate = false, bool icon = false);
 
protected:
 
    bool load_script_body(const xml::tag *p);
    bool save_script_body(Common::WriteStream &fh, int indent = 0) const;
 
    virtual bool need_sound_restart() const;
 
private:
 
    StateType _state_type;
 
    Vect2s _center_offset;
    Vect3f _bound;
    float _radius;
 
    qdCoordsAnimation _coords_animation;
 
    float _activation_delay;
    float _activation_timer;
 
 
    float _work_time;
    float _cur_time;
 
    qdSoundInfo _sound_info;
    qdSoundHandle _sound_handle;
    float _sound_delay;
    bool _is_sound_started;
 
    float _text_delay;
    bool _is_text_shown;
 
    int _mouse_cursor_id;
 
    Common::String _text_ID;
    Common::String _short_text_ID;
 
    qdCameraMode _camera_mode;
 
    float _rnd_move_radius;
    float _rnd_move_speed;
 
    int _autosave_slot;
 
    float _fade_time;
 
    uint32 _shadow_color;
    int _shadow_alpha;
 
    qdScreenTransform _transform;
    qdScreenTransform _transform_speed;
 
    qdScreenTextFormat _text_format;
 
 
    int _reference_count;
 
    qdGameObjectState *_prev_state;
 
};
 
typedef Std::vector<qdGameObjectState *> qdGameObjectStateVector;
 
class qdGameObjectStateStatic : public qdGameObjectState {
public:
    qdGameObjectStateStatic();
    qdGameObjectStateStatic(const qdGameObjectStateStatic &st);
    ~qdGameObjectStateStatic();
 
    qdGameObjectState &operator = (const qdGameObjectState &st);
    qdGameObjectStateStatic &operator = (const qdGameObjectStateStatic &st);
 
    qdAnimation *animation() {
        return _animation_info.animation();
    }
    const qdAnimation *animation() const {
        return _animation_info.animation();
    }
    qdAnimationInfo *animation_info() {
        return &_animation_info;
    }
 
    bool load_script(const xml::tag *p);
    bool save_script(Common::WriteStream &fh, int indent = 0) const;
 
    bool register_resources();
    bool unregister_resources();
    bool load_resources();
    bool free_resources();
 
    bool is_state_empty() const;
 
    qdGameObjectState *clone() const {
        return new qdGameObjectStateStatic(*this);
    }
 
    bool auto_bound();
 
private:
    qdAnimationInfo _animation_info;
};
 
class qdGameObjectStateWalk : public qdGameObjectState {
public:
    qdGameObjectStateWalk();
    qdGameObjectStateWalk(const qdGameObjectStateWalk &st);
    ~qdGameObjectStateWalk();
 
    qdGameObjectState &operator = (const qdGameObjectState &st);
    qdGameObjectStateWalk &operator = (const qdGameObjectStateWalk &st);
 
    enum movement_type_t {
        MOVEMENT_LEFT,
        MOVEMENT_UP,
        MOVEMENT_RIGHT,
        MOVEMENT_DOWN,
        MOVEMENT_HORIZONTAL,
        MOVEMENT_VERTICAL,
        MOVEMENT_FOUR_DIRS,
        MOVEMENT_EIGHT_DIRS,
        MOVEMENT_SMOOTH,
 
        MOVEMENT_UP_LEFT,
        MOVEMENT_UP_RIGHT,
        MOVEMENT_DOWN_RIGHT,
        MOVEMENT_DOWN_LEFT
    };
 
    enum OffsetType {
        OFFSET_STATIC = 0,
        OFFSET_WALK,
        OFFSET_START,
        OFFSET_END
    };
 
    qdAnimationSet *animation_set() const;
 
    qdAnimation *animation(float direction_angle);
    qdAnimation *static_animation(float direction_angle);
 
    qdAnimationInfo *animation_info(float direction_angle);
    qdAnimationInfo *static_animation_info(float direction_angle);
 
    const Vect2i &center_offset(int direction_index, OffsetType offset_type = OFFSET_WALK) const;
    const Vect2i &center_offset(float direction_angle, OffsetType offset_type = OFFSET_WALK) const;
    void set_center_offset(int direction_index, const Vect2i &offs, OffsetType offset_type = OFFSET_WALK);
 
    float walk_sound_frequency(int direction_index) const;
    float walk_sound_frequency(float direction_angle) const;
    void set_walk_sound_frequency(int direction_index, float freq);
 
    bool update_sound_frequency(float direction_angle) const;
 
    qdAnimationSetInfo *animation_set_info() {
        return &_animation_set_info;
    }
 
    float adjust_direction_angle(float angle) const;
 
    float direction_angle() const {
        return _direction_angle;
    }
    void set_direction_angle(float ang) {
        _direction_angle = ang;
    }
 
    bool load_script(const xml::tag *p);
    bool save_script(Common::WriteStream &fh, int indent = 0) const;
 
    bool register_resources();
    bool unregister_resources();
    bool load_resources();
    bool free_resources();
 
    bool is_state_empty() const;
 
    qdGameObjectState *clone() const {
        return new qdGameObjectStateWalk(*this);
    }
 
    bool auto_bound();
 
    float acceleration() const {
        return _acceleration;
    }
    void set_acceleration(float acc) {
        _acceleration = acc;
    }
 
    float max_speed() const {
        return _max_speed;
    }
    void set_max_speed(float max_sp) {
        _max_speed = max_sp;
    }
 
    void set_movement_type(movement_type_t type) {
        _movement_type = type;
    }
    movement_type_t movement_type() const {
        return _movement_type;
    }
 
protected:
 
    bool need_sound_restart() const;
 
private:
 
    float _direction_angle;
    qdAnimationSetInfo _animation_set_info;
 
    float _acceleration;
 
    float _max_speed;
 
    movement_type_t _movement_type;
 
    Std::vector<Vect2i> _center_offsets;
    Std::vector<Vect2i> _static_center_offsets;
    Std::vector<Vect2i> _start_center_offsets;
    Std::vector<Vect2i> _stop_center_offsets;
 
    Std::vector<float> _walk_sound_frequency;
};
 
class qdGameObjectStateMask : public qdGameObjectState, public qdContour {
public:
    qdGameObjectStateMask();
    qdGameObjectStateMask(const qdGameObjectStateMask &st);
    ~qdGameObjectStateMask();
 
    qdGameObjectState &operator = (const qdGameObjectState &st);
    qdGameObjectStateMask &operator = (const qdGameObjectStateMask &st);
 
    const char *parent_name() const {
        return _parent_name.c_str();
    }
    void set_parent_name(const char *p) {
        _parent_name = p;
        _parent = 0;
    }
 
    qdGameObject *parent();
    const qdGameObject *parent() const;
 
    bool hit(int x, int y) const;
    bool draw_mask(uint32 color) const;
 
    bool can_be_closed() const {
        return (contour_size() > 2);
    }
 
    bool load_script(const xml::tag *p);
    bool save_script(Common::WriteStream &fh, int indent = 0) const;
 
    bool is_state_empty() const;
 
    bool load_resources();
 
    qdGameObjectState *clone() const {
        return new qdGameObjectStateMask(*this);
    }
 
private:
 
    Common::String _parent_name;
 
    qdGameObject *_parent;
};
 
#ifdef __QD_DEBUG_ENABLE__
inline bool qdbg_is_object_state(const qdNamedObject *obj, const char *scene_name, const char *object_name, const char *state_name) {
    if (dynamic_cast<const qdGameObjectState *>(obj)) {
        if (obj->name() && !strcmp(state_name, obj->name())) {
            if (!object_name || (obj->owner() && obj->owner()->name() && !strcmp(object_name, obj->owner()->name()))) {
                if (!scene_name || (obj->owner()->owner() && obj->owner()->owner()->name() && !strcmp(obj->owner()->owner()->name(), scene_name)))
                    return true;
            }
        }
    }
    return false;
}
#else
inline bool qdbg_is_object_state(const qdNamedObject *obj, const char *scene_name, const char *object_name, const char *state_name) {
    return false;
}
#endif
 
} // namespace QDEngine
 
#endif // QDENGINE_QDCORE_QD_GAME_OBJECT_STATE_H