ICondition.h

Go to the documentation of this file.

#pragma once

#include <string>
#include <vector>
#include <sstream>
#include <memory>

#include "common/MemoryAllocator.h"
#include "common/Thread.h"

#include "AIFactories.h"

namespace ai {

class AI;
typedef std::shared_ptr<AI> AIPtr;

#define CONDITION_CLASS(ConditionName) \
    explicit ConditionName(const std::string& parameters = "") : \
        ::ai::ICondition(#ConditionName, parameters) { \
    } \
public: \
    virtual ~ConditionName() { \
    }

#define CONDITION_FACTORY_NO_IMPL(ConditionName) \
public: \
    class Factory: public ::ai::IConditionFactory { \
    public: \
        ::ai::ConditionPtr create (const ::ai::ConditionFactoryContext *ctx) const override; \
    }; \
    static const Factory& getFactory() { \
        static Factory FACTORY; \
        return FACTORY; \
    }

#define CONDITION_FACTORY(ConditionName) \
public: \
    class Factory: public ::ai::IConditionFactory { \
    public: \
        ::ai::ConditionPtr create (const ::ai::ConditionFactoryContext *ctx) const override { \
            return std::make_shared<ConditionName>(ctx->parameters); \
        } \
    }; \
    static const Factory& getFactory() { \
        static Factory FACTORY; \
        return FACTORY; \
    }

#define CONDITION_FACTORY_SINGLETON \
public: \
    class Factory: public ::ai::IConditionFactory { \
        ::ai::ConditionPtr create (const ::ai::ConditionFactoryContext */*ctx*/) const { \
            return get(); \
        } \
    }; \
    static const Factory& getFactory() { \
        static Factory FACTORY; \
        return FACTORY; \
    }

#define CONDITION_CLASS_SINGLETON(ConditionName) \
private: \
    CONDITION_CLASS(ConditionName) \
public: \
    static ConditionPtr& get() { \
        AI_THREAD_LOCAL ConditionName* c = nullptr; \
        if (c == nullptr) { c = new ConditionName; } \
        AI_THREAD_LOCAL ConditionPtr _instance(c); \
        return _instance; \
    } \
    CONDITION_FACTORY_SINGLETON

#define CONDITION_PRINT_SUBCONDITIONS_GETCONDITIONNAMEWITHVALUE \
    void getConditionNameWithValue(std::stringstream& s, const ::ai::AIPtr& entity) override { \
        bool first = true; \
        s << "("; \
        for (::ai::ConditionsConstIter i = _conditions.begin(); i != _conditions.end(); ++i) { \
            if (!first) { \
                s << ","; \
            } \
            s << (*i)->getNameWithConditions(entity); \
            first = false; \
        } \
        s << ")"; \
    }

class ICondition;
typedef std::shared_ptr<ICondition> ConditionPtr;
typedef std::vector<ConditionPtr> Conditions;
typedef Conditions::iterator ConditionsIter;
typedef Conditions::const_iterator ConditionsConstIter;

class ICondition : public MemObject {
protected:
    static int getNextId() {
        static int _nextId = 0;
        const int id = _nextId++;
        return id;
    }

    int _id;
    const std::string _name;
    const std::string _parameters;

    virtual void getConditionNameWithValue(std::stringstream& s, const AIPtr& entity) {
        (void)entity;
        s << "{" << _parameters << "}";
    }
public:
    ICondition(const std::string& name, const std::string& parameters) :
            _id(getNextId()), _name(name), _parameters(parameters) {
    }

    virtual ~ICondition() {
    }

    virtual bool evaluate(const AIPtr& entity) = 0;

    const std::string& getName() const;

    const std::string& getParameters() const;

    inline std::string getNameWithConditions(const AIPtr& entity) {
        std::stringstream s;
        s << getName();
        getConditionNameWithValue(s, entity);
        s << "[";
        s << (evaluate(entity) ? "1" : "0");
        s << "]";
        return s.str();
    }
};

inline const std::string& ICondition::getName() const {
    return _name;
}

inline const std::string& ICondition::getParameters() const {
    return _parameters;
}

}