qd_trigger_element.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_TRIGGER_ELEMENT_H
#define QDENGINE_QDCORE_QD_TRIGGER_ELEMENT_H

#include "qdengine/parser/xml_fwd.h"
#include "qdengine/qdcore/qd_named_object.h"
#include "qdengine/qdcore/qd_named_object_reference.h"

namespace Common {
class WriteStream;
}

namespace QDEngine {

class qdTriggerElement;
class qdTriggerLink;

typedef qdTriggerElement *qdTriggerElementPtr;
typedef qdTriggerElement const *qdTriggerElementConstPtr;


class qdTriggerLink {
public:
    enum LinkStatus {
        LINK_INACTIVE,

        LINK_ACTIVE,

        LINK_DONE
    };

    qdTriggerLink(qdTriggerElementPtr p, int tp = 0);
    qdTriggerLink();
    ~qdTriggerLink() { }

    LinkStatus status() const {
        return _status;
    }
    void set_status(LinkStatus st) {
        _status = st;
    }

    int type() const {
        return _type;
    }
    void set_type(int _t) {
        _type = _t;
    }

    qdTriggerElementPtr const &element() const {
        return _element;
    }
    void set_element(qdTriggerElementPtr const &el) {
        _element = el;
    }

    int element_ID() const {
        return _element_ID;
    }

    bool set_element_ID(int id) {
        if (!_element) {
            _element_ID = id;
            return true;
        }
        return false;
    }

    bool operator == (qdTriggerElementConstPtr e) const {
        return (_element == e);
    }

    void activate();
    void deactivate();

    void toggle_auto_restart(bool state) {
        _auto_restart = state;
    }
    bool auto_restart() const {
        return _auto_restart;
    }

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

    Common::String toString();

private:
    int _type;
    qdTriggerElementPtr _element;
    int _element_ID;

    LinkStatus _status;

    bool _auto_restart;

};

typedef Std::vector<qdTriggerLink> qdTriggerLinkList;

class qdTriggerElement {
public:
    qdTriggerElement();
    qdTriggerElement(qdNamedObject *p);
    ~qdTriggerElement();

    enum {
        ROOT_ID = -1,
        INVALID_ID = -2
    };

    enum ElementStatus {
        TRIGGER_EL_INACTIVE,
        TRIGGER_EL_WAITING,
        TRIGGER_EL_WORKING,
        TRIGGER_EL_DONE
    };


    qdTriggerLink *find_child_link(qdTriggerElementConstPtr ptrChild);
    qdTriggerLink *find_child_link(int child_id);

    qdTriggerLink *find_parent_link(qdTriggerElementConstPtr ptrParent);
    qdTriggerLink *find_parent_link(int parent_id);

    bool is_active() const {
        return _is_active;
    }
    void make_active(bool v) {
        _is_active = v;
    }


    bool debug_set_active();

    bool debug_set_done();

    bool debug_set_inactive();

    bool check_external_conditions(int link_type);
    bool check_internal_conditions();

    ElementStatus status() const {
        return _status;
    }
    void set_status(ElementStatus st);
//  void set_status(ElementStatus st){ _status = st; }

    int ID() const {
        return _ID;
    }
    void set_id(int id) {
        _ID = id;
    }

    qdNamedObject *object() const {
        return _object;
    }
    bool add_object_trigger_reference();
    bool clear_object_trigger_references();

    bool retrieve_object(const qdNamedObjectReference &ref);
    bool retrieve_link_elements(qdTriggerChain *p);

    qdTriggerLinkList &parents()  {
        return _parents;
    }
    qdTriggerLinkList &children() {
        return _children;
    }

    const qdTriggerLinkList &parents()  const {
        return _parents;
    }
    const qdTriggerLinkList &children() const {
        return _children;
    }

    bool is_parent(qdTriggerElementConstPtr p);
    bool is_child(qdTriggerElementConstPtr p);

    bool add_parent(qdTriggerElementPtr p, int link_type = 0);
    bool add_child(qdTriggerElementPtr p, int link_type = 0, bool auto_restart = false);

    bool remove_parent(qdTriggerElementPtr p);
    bool remove_child(qdTriggerElementPtr p);

    bool set_child_link_status(qdTriggerElementConstPtr child, qdTriggerLink::LinkStatus st);
    bool set_parent_link_status(qdTriggerElementConstPtr parent, qdTriggerLink::LinkStatus st);

    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 quant(float dt);

    void reset();
    void deactivate(const qdNamedObject *ignore_object = NULL);

private:

    enum ElementStatusSpecial {
        TRIGGER_EL_INACTIVE_ALL,
        TRIGGER_EL_DONE_ALL
    };

    int _ID;

    ElementStatus _status;

    bool _is_active;

    qdNamedObject *_object;

    qdTriggerLinkList _parents;
    qdTriggerLinkList _children;

    bool load_links_script(const xml::tag *p, bool load_parents);

    bool activate_links(qdTriggerElementPtr child);
    bool deactivate_links(qdTriggerElementPtr child);

    bool deactivate_link(qdTriggerElementPtr child);
    bool conditions_quant(int link_type);
    void start();
};

typedef Std::vector<qdTriggerElementPtr> qdTriggerElementList;

} // namespace QDEngine

#endif // QDENGINE_QDCORE_QD_TRIGGER_ELEMENT_H