ITimedNode.h

Go to the documentation of this file.

#pragma once

#include "tree/TreeNode.h"
#include <stdlib.h>

namespace ai {

#define NOTSTARTED -1
#define TIMERNODE_CLASS(NodeName) \
    NodeName(const std::string& name, const std::string& parameters, const ConditionPtr& condition) : \
        ITimedNode(name, parameters, condition) { \
        _type = AI_STRINGIFY(NodeName); \
    } \
    virtual ~NodeName() { \
    } \
    \
    NODE_FACTORY(NodeName)

class ITimedNode : public TreeNode {
protected:
    int64_t _timerMillis;
    int64_t _millis;
public:
    ITimedNode(const std::string& name, const std::string& parameters, const ConditionPtr& condition) :
            TreeNode(name, parameters, condition), _timerMillis(NOTSTARTED) {
        if (!parameters.empty()) {
            _millis = ::atol(parameters.c_str());
        } else {
            _millis = 1000L;
        }
    }
    virtual ~ITimedNode() {}

    TreeNodeStatus execute(const AIPtr& entity, int64_t deltaMillis) override {
        const TreeNodeStatus result = TreeNode::execute(entity, deltaMillis);
        if (result == CANNOTEXECUTE)
            return CANNOTEXECUTE;

        if (_timerMillis == NOTSTARTED) {
            _timerMillis = _millis;
            const TreeNodeStatus status = executeStart(entity, deltaMillis);
            if (status == FINISHED)
                _timerMillis = NOTSTARTED;
            return state(entity, status);
        }

        if (_timerMillis - deltaMillis > 0) {
            _timerMillis -= deltaMillis;
            const TreeNodeStatus status = executeRunning(entity, deltaMillis);
            if (status == FINISHED)
                _timerMillis = NOTSTARTED;
            return state(entity, status);
        }

        _timerMillis = NOTSTARTED;
        return state(entity, executeExpired(entity, deltaMillis));
    }

    virtual TreeNodeStatus executeStart(const AIPtr& /*entity*/, int64_t /*deltaMillis*/) {
        return RUNNING;
    }

    virtual TreeNodeStatus executeRunning(const AIPtr& /*entity*/, int64_t /*deltaMillis*/) {
        return RUNNING;
    }

    virtual TreeNodeStatus executeExpired(const AIPtr& /*entity*/, int64_t /*deltaMillis*/) {
        return FINISHED;
    }
};

#undef NOTSTARTED

}