Zone.h

Go to the documentation of this file.

#pragma once

#include "ICharacter.h"
#include "group/GroupMgr.h"
#include "common/Thread.h"
#include "common/ThreadPool.h"
#include "common/Types.h"
#include "common/ExecutionTime.h"
#include <unordered_map>
#include <vector>
#include <memory>

namespace ai {

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

class Zone {
public:
    typedef std::unordered_map<CharacterId, AIPtr> AIMap;
    typedef std::vector<AIPtr> AIScheduleList;
    typedef std::vector<CharacterId> CharacterIdList;
    typedef AIMap::const_iterator AIMapConstIter;
    typedef AIMap::iterator AIMapIter;

protected:
    const std::string _name;
    AIMap _ais;
    AIScheduleList _scheduledAdd;
    AIScheduleList _scheduledRemove;
    CharacterIdList _scheduledDestroy;
    bool _debug;
    ReadWriteLock _lock {"zone"};
    ReadWriteLock _scheduleLock {"zone-schedulelock"};
    ai::GroupMgr _groupManager;
    mutable ThreadPool _threadPool;

    bool doAddAI(const AIPtr& ai);
    bool doRemoveAI(const AIPtr& ai);
    bool doDestroyAI(const CharacterId& id);

public:
    Zone(const std::string& name, int threadCount = std::min(1u, std::thread::hardware_concurrency())) :
            _name(name), _debug(false), _threadPool(threadCount) {
    }

    virtual ~Zone() {}

    void update(int64_t dt);

    bool addAI(const AIPtr& ai);

    template<class Collection>
    bool addAIs(const Collection& ais) {
        if (ais.empty()) {
            return false;
        }
        ScopedWriteLock scopedLock(_scheduleLock);
        _scheduledAdd.insert(_scheduledAdd.end(), ais.begin(), ais.end());
        return true;
    }

    bool removeAI(const AIPtr& ai);

    template<class Collection>
    bool removeAIs(const Collection& ais) {
        if (ais.empty()) {
            return false;
        }
        ScopedWriteLock scopedLock(_scheduleLock);
        _scheduledRemove.insert(_scheduledRemove.end(), ais.begin(), ais.end());
        return true;
    }

    bool destroyAI(const CharacterId& id);

    const std::string& getName() const;

    void setDebug(bool debug);
    bool isDebug () const;

    GroupMgr& getGroupMgr();

    const GroupMgr& getGroupMgr() const;

    inline AIPtr getAI(CharacterId id) const {
        ScopedReadLock scopedLock(_lock);
        auto i = _ais.find(id);
        if (i == _ais.end()) {
            return AIPtr();
        }
        const AIPtr& ai = i->second;
        return ai;
    }

    template<typename Func>
    inline bool executeAsync(CharacterId id, const Func& func) const {
        const AIPtr& ai = getAI(id);
        if (!ai) {
            return false;
        }
        executeAsync(ai, func);
        return true;
    }

    template<typename Func>
    inline auto executeAsync(const AIPtr& ai, const Func& func) const
        -> std::future<typename std::result_of<Func(const AIPtr&)>::type> {
        return _threadPool.enqueue(func, ai);
    }

    template<typename Func>
    inline auto execute(const AIPtr& ai, const Func& func) const
        -> typename std::result_of<Func(const AIPtr&)>::type {
        return func(ai);
    }

    template<typename Func>
    inline auto execute(const AIPtr& ai, Func& func)
        -> typename std::result_of<Func(const AIPtr&)>::type {
        return func(ai);
    }

    template<typename Func>
    inline auto execute(CharacterId id, const Func& func) const
        -> typename std::result_of<Func(const AIPtr&)>::type {
        return execute(getAI(id), func);
    }

    template<typename Func>
    inline auto execute(CharacterId id, Func& func)
        -> typename std::result_of<Func(const AIPtr&)>::type {
        return execute(getAI(id), func);
    }

    template<typename Func>
    void executeParallel(Func& func) {
        std::vector<std::future<void> > results;
        _lock.lockRead();
        AIMap copy(_ais);
        _lock.unlockRead();
        for (auto i = copy.begin(); i != copy.end(); ++i) {
            const AIPtr& ai = i->second;
            results.emplace_back(executeAsync(ai, func));
        }
        for (auto & result: results) {
            result.wait();
        }
    }

    template<typename Func>
    void executeParallel(const Func& func) const {
        std::vector<std::future<void> > results;
        _lock.lockRead();
        AIMap copy(_ais);
        _lock.unlockRead();
        for (auto i = copy.begin(); i != copy.end(); ++i) {
            const AIPtr& ai = i->second;
            results.emplace_back(executeAsync(ai, func));
        }
        for (auto & result: results) {
            result.wait();
        }
    }

    template<typename Func>
    void execute(const Func& func) const {
        _lock.lockRead();
        AIMap copy(_ais);
        _lock.unlockRead();
        for (auto i = copy.begin(); i != copy.end(); ++i) {
            const AIPtr& ai = i->second;
            func(ai);
        }
    }

    template<typename Func>
    void execute(Func& func) {
        _lock.lockRead();
        AIMap copy(_ais);
        _lock.unlockRead();
        for (auto i = copy.begin(); i != copy.end(); ++i) {
            const AIPtr& ai = i->second;
            func(ai);
        }
    }

    inline std::size_t size() const {
        ScopedReadLock scopedLock(_lock);
        return _ais.size();
    }
};

inline void Zone::setDebug (bool debug) {
    _debug = debug;
}

inline bool Zone::isDebug () const {
    return _debug;
}

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

inline GroupMgr& Zone::getGroupMgr() {
    return _groupManager;
}

inline const GroupMgr& Zone::getGroupMgr() const {
    return _groupManager;
}

inline bool Zone::doAddAI(const AIPtr& ai) {
    if (ai == nullptr) {
        return false;
    }
    const CharacterId& id = ai->getCharacter()->getId();
    if (_ais.find(id) != _ais.end()) {
        return false;
    }
    _ais.insert(std::make_pair(id, ai));
    ai->setZone(this);
    return true;
}

inline bool Zone::doRemoveAI(const AIPtr& ai) {
    if (!ai) {
        return false;
    }
    const CharacterId& id = ai->getCharacter()->getId();
    AIMapIter i = _ais.find(id);
    if (i == _ais.end()) {
        return false;
    }
    i->second->setZone(nullptr);
    _groupManager.removeFromAllGroups(i->second);
    _ais.erase(i);
    return true;
}

inline bool Zone::doDestroyAI(const CharacterId& id) {
    AIMapIter i = _ais.find(id);
    if (i == _ais.end()) {
        return false;
    }
    _ais.erase(i);
    return true;
}

inline bool Zone::addAI(const AIPtr& ai) {
    if (!ai) {
        return false;
    }
    ScopedWriteLock scopedLock(_scheduleLock);
    _scheduledAdd.push_back(ai);
    return true;
}

inline bool Zone::destroyAI(const CharacterId& id) {
    ScopedWriteLock scopedLock(_scheduleLock);
    _scheduledDestroy.push_back(id);
    return true;
}

inline bool Zone::removeAI(const AIPtr& ai) {
    if (!ai) {
        return false;
    }
    ScopedWriteLock scopedLock(_scheduleLock);
    _scheduledRemove.push_back(ai);
    return true;
}

inline void Zone::update(int64_t dt) {
    {
        AIScheduleList scheduledRemove;
        AIScheduleList scheduledAdd;
        CharacterIdList scheduledDestroy;
        {
            ScopedWriteLock scopedLock(_scheduleLock);
            scheduledAdd.swap(_scheduledAdd);
            scheduledRemove.swap(_scheduledRemove);
            scheduledDestroy.swap(_scheduledDestroy);
        }
        ScopedWriteLock scopedLock(_lock);
        for (const AIPtr& ai : scheduledAdd) {
            doAddAI(ai);
        }
        scheduledAdd.clear();
        for (const AIPtr& ai : scheduledRemove) {
            doRemoveAI(ai);
        }
        scheduledRemove.clear();
        for (auto id : scheduledDestroy) {
            doDestroyAI(id);
        }
        scheduledDestroy.clear();
    }

    auto func = [&] (const AIPtr& ai) {
        if (ai->isPause()) {
            return;
        }
        ai->update(dt, _debug);
        ai->getBehaviour()->execute(ai, dt);
    };
    executeParallel(func);
    _groupManager.update(dt);
}

}