qd_game_object_animated.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_ANIMATED_H
#define QDENGINE_QDCORE_QD_GAME_OBJECT_ANIMATED_H

#include "qdengine/parser/xml_fwd.h"
#include "qdengine/qdcore/qd_animation.h"
#include "qdengine/qdcore/qd_coords_animation.h"
#include "qdengine/qdcore/qd_game_object.h"
#include "qdengine/qdcore/qd_game_object_state.h"

namespace QDEngine {


class qdGameObjectAnimated : public qdGameObject {
public:
    enum StateStatus {
        STATE_INACTIVE,
        STATE_QUEUED,
        STATE_ACTIVE,
        STATE_DONE
    };

    qdGameObjectAnimated();
    qdGameObjectAnimated(const qdGameObjectAnimated &obj);
    ~qdGameObjectAnimated();

    qdGameObjectAnimated &operator = (const qdGameObjectAnimated &obj);

    int named_object_type() const {
        return QD_NAMED_OBJECT_ANIMATED_OBJ;
    }

    virtual const Vect3f &bound(bool perspective_correction = true) const;

    bool auto_bound();
    virtual float radius() const;
    void set_bound(const Vect3f &b);
    bool has_bound() const {
        if (check_flag(QD_OBJ_HAS_BOUND_FLAG)) return true;
        if (_cur_state != -1 && _states[_cur_state]->has_bound()) return true;
        return false;
    }
    void draw_bound() const;
    void draw_bound(Vect3f r, Vect3f const &bound, int const color) const;
    bool inters_with_bound(Vect3f bnd, Vect3f cen, bool perspective_correction = true) const;

    int cur_state() const {
        return _cur_state;
    }
    void set_cur_state(int st) {
        _cur_state = st;
    }
    int max_state() const {
        return _states.size();
    }
    int get_state_index(const qdGameObjectState *p) const;

    void set_states_owner();

    bool is_state_active(const char *state_name) const;
    bool was_state_active(const char *state_name) const;

    bool is_state_active(const qdGameObjectState *p) const {
        if (_cur_state != -1 && _states[_cur_state] == p)
            return true;

        return false;
    }

    bool was_state_previous(const char *state_name) const;
    bool was_state_previous(const qdGameObjectState *p) const {
        return (_last_state == p);
    }

    bool was_state_active(const qdGameObjectState *p) const {
        return p->check_flag(qdGameObjectState::QD_OBJ_STATE_FLAG_WAS_ACTIVATED);
    }

    bool is_state_waiting(const qdGameObjectState *p) const {
        if (_queued_state == p) return true;
        return false;
    }

    bool is_state_waiting(const char *state_name) const;

    const qdGameObjectStateVector &state_vector() const {
        return _states;
    }

    virtual bool can_change_state(const qdGameObjectState *state = NULL) const;

    qdGameObjectState *get_state(const char *state_name);
    qdGameObjectState *get_state(int state_index);
    qdGameObjectState *get_cur_state() {
        return get_state(cur_state());
    }

    const qdGameObjectState *get_state(const char *state_name) const;
    const qdGameObjectState *get_state(int state_index) const;
    const qdGameObjectState *get_cur_state() const {
        return get_state(cur_state());
    }

    void set_queued_state(qdGameObjectState *st) {
        _queued_state = st;
    }

    qdGameObjectState *queued_state() {
        return _queued_state;
    }
    const qdGameObjectState *queued_state() const {
        return _queued_state;
    }

    void merge_states(qdGameObjectAnimated *p);
    void split_states(qdGameObjectAnimated *p);

    StateStatus state_status(const qdGameObjectState *p) const;

    bool add_state(qdGameObjectState *p);
    bool insert_state(int iBefore, qdGameObjectState *p);
    qdGameObjectState *remove_state(int state_num);
    bool remove_state(qdGameObjectState *p);

    virtual void set_state(int st);
    virtual void set_state(qdGameObjectState *p);
    void restore_state();

    bool has_camera_mode() const;
    const qdCameraMode &camera_mode() const;

    int num_directions() const;

    const Vect3f &default_R() const {
        return _default_r;
    }
    void set_default_pos(const Vect3f &r) {
        _default_r = r;
    }

    void set_default_state();
    virtual qdGameObjectState *get_default_state();
    virtual const qdGameObjectState *get_default_state() const;

    qdGameObjectState *get_inventory_state();
    qdGameObjectState *get_mouse_state();
    qdGameObjectState *get_mouse_hover_state();

    bool update_screen_pos();

    // Animation
    qdAnimation *get_animation() {
        return &_animation;
    }
    const qdAnimation *get_animation() const {
        return &_animation;
    }

    void set_animation(qdAnimation *p, const qdAnimationInfo *inf = NULL);
    void set_animation_info(qdAnimationInfo *inf);
    Vect2s screen_size() const {
        return Vect2s(_animation.size_x(), _animation.size_y());
    }

    void set_screen_rotation(float target_angle, float speed);
    float screen_rotation() const;

    void set_screen_scale(const Vect2f &scale, const Vect2f &speed);
    const Vect2f &screen_scale() const;

    bool has_screen_transform() const {
        return _current_transform();
    }

    // Inventory
    int inventory_type() const {
        return _inventory_type;
    }
    void set_inventory_type(int tp) {
        _inventory_type = tp;
    }

    // Logic
    bool hit(int x, int y) const;
    bool mouse_handler(int x, int y, mouseDispatcher::mouseEvent ev);
    void quant(float dt);
    bool handle_state_end();

    // Redraw
    void redraw(int offs_x = 0, int offs_y = 0) const;
    bool need_redraw() const;

    void post_redraw();
    void draw_shadow(int offs_x, int offs_y, uint32 color, int alpha) const;

    bool get_debug_info(Common::String &buf) const;

    void debug_redraw() const;
    void draw_contour(uint32 color) const;
    void draw_grid_zone(const Vect2s sz) const;

    int mouse_cursor_ID() const;

    bool load_script(const xml::tag *p);
    bool save_script(Common::WriteStream &fh, int indent = 0) const;

    bool load_data(Common::SeekableReadStream &fh, int save_version);
    bool save_data(Common::WriteStream &fh) const;

    bool load_resources();
    void free_resources();

    bool init();

    bool is_visible() const;

    const Vect2s &grid_size() const {
        return _grid_size;
    }

    bool init_grid_zone();
    virtual bool toggle_grid_zone(bool make_walkable = false);
    bool save_grid_zone();
    bool restore_grid_zone();
    bool set_grid_zone_attributes(int attr) const;
    bool check_grid_zone_attributes(int attr) const;
    bool drop_grid_zone_attributes(int attr) const;
    bool set_grid_zone_attributes(const Vect2f &r, int attr) const;
    bool check_grid_zone_attributes(const Vect2f &r, int attr) const;
    bool drop_grid_zone_attributes(const Vect2f &r, int attr) const;

    const char *inventory_name() const {
        return _inventory_name.c_str();
    }
    void set_inventory_name(const char *name) {
        if (name)
            _inventory_name = name;
        else
            _inventory_name.clear();
    }
    bool has_inventory_name() const {
        return !_inventory_name.empty();
    }

    const grScreenRegion last_screen_region() const {
        return _last_screen_region;
    }
    virtual grScreenRegion screen_region() const;

    int inventory_cell_index() const {
        return _inventory_cell_index;
    }
    void set_inventory_cell_index(int idx) {
        _inventory_cell_index = idx;
    }

    int last_chg_time() const {
        return _last_chg_time;
    }
    void set_last_chg_time(int time) {
        _last_chg_time = time;
    }
    int idle_time() const;

    int shadow_color() const;
    int shadow_alpha() const;
    void set_shadow(uint32 color, int alpha) {
        _shadow_color = color;
        _shadow_alpha = alpha;
    }
    void clear_shadow() {
        set_shadow(0, QD_NO_SHADOW_ALPHA);
    }

protected:

    bool load_script_body(const xml::tag *p);
    bool save_script_body(Common::WriteStream &fh, int indent = 0) const;

    void set_last_state(qdGameObjectState *p) {
        if (!p || !p->check_flag(qdGameObjectState::QD_OBJ_STATE_FLAG_MOUSE_STATE | qdGameObjectState::QD_OBJ_STATE_FLAG_MOUSE_HOVER_STATE))
            _last_state = p;
    }

    void set_last_inventory_state(qdGameObjectState *p) {
        if (!p || (p->check_flag(qdGameObjectState::QD_OBJ_STATE_FLAG_INVENTORY) && !p->check_flag(qdGameObjectState::QD_OBJ_STATE_FLAG_MOUSE_STATE | qdGameObjectState::QD_OBJ_STATE_FLAG_MOUSE_HOVER_STATE)))
            _last_inventory_state = p;
    }

private:

    int _cur_state;
    qdGameObjectStateVector _states;

    qdGameObjectState *_queued_state;
    qdGameObjectState *_last_inventory_state;

    int _inventory_type;

    qdAnimation _animation;

    Vect3f _bound;
    float _radius;

    Vect3f _default_r;

    Vect3f _grid_r;
    Vect2s _grid_size;

    Common::String _inventory_name;

    qdScreenTransform _current_transform;
    qdScreenTransform _target_transform;
    qdScreenTransform _transform_speed;

    qdScreenTransform _last_transform;

    qdGameObjectState *_last_state;

    int _inventory_cell_index;

    const qdAnimationFrame *_last_frame;
    grScreenRegion _last_screen_region;
    float _last_screen_depth;

    uint32 _lastShadowColor;
    int _lastShadowAlpha;

    int _last_chg_time;

    uint32 _shadow_color;
    int _shadow_alpha;

    void clear_states();
};

} // namespace QDEngine

#endif // QDENGINE_QDCORE_QD_GAME_OBJECT_ANIMATED_H