Server.h

Go to the documentation of this file.

#pragma once

#include "common/Thread.h"
#include "tree/TreeNode.h"
#include <unordered_set>
#include "Network.h"
#include "zone/Zone.h"
#include "AIRegistry.h"
#include "AIStateMessage.h"
#include "AINamesMessage.h"
#include "AIStubTypes.h"
#include "AICharacterDetailsMessage.h"
#include "AICharacterStaticMessage.h"
#include "ProtocolHandlerRegistry.h"
#include "conditions/ConditionParser.h"
#include "tree/TreeNodeParser.h"
#include "tree/TreeNodeImpl.h"

namespace ai {

class AIStateNode;
class AIStateNodeStatic;

class SelectHandler;
class PauseHandler;
class ResetHandler;
class StepHandler;
class ChangeHandler;
class AddNodeHandler;
class DeleteNodeHandler;
class UpdateNodeHandler;
class NopHandler;

class Server: public INetworkListener {
protected:
    typedef std::unordered_set<Zone*> Zones;
    typedef Zones::const_iterator ZoneConstIter;
    typedef Zones::iterator ZoneIter;
    Zones _zones;
    AIRegistry& _aiRegistry;
    Network _network;
    CharacterId _selectedCharacterId;
    int64_t _time;
    SelectHandler *_selectHandler;
    PauseHandler *_pauseHandler;
    ResetHandler *_resetHandler;
    StepHandler *_stepHandler;
    ChangeHandler *_changeHandler;
    AddNodeHandler *_addNodeHandler;
    DeleteNodeHandler *_deleteNodeHandler;
    UpdateNodeHandler *_updateNodeHandler;
    NopHandler _nopHandler;
    std::atomic_bool _pause;
    // the current active debugging zone
    std::atomic<Zone*> _zone;
    ReadWriteLock _lock = {"server"};
    std::vector<std::string> _names;
    uint32_t _broadcastMask = 0u;

    enum EventType {
        EV_SELECTION,
        EV_STEP,
        EV_UPDATESTATICCHRDETAILS,
        EV_NEWCONNECTION,
        EV_ZONEADD,
        EV_ZONEREMOVE,
        EV_PAUSE,
        EV_RESET,
        EV_SETDEBUG,

        EV_MAX
    };

    struct Event {
        union {
            CharacterId characterId;
            int64_t stepMillis;
            Zone* zone;
            Client* newClient;
            bool pauseState;
        } data;
        std::string strData = "";
        EventType type;
    };
    std::vector<Event> _events;

    void resetSelection();

    void addChildren(const TreeNodePtr& node, std::vector<AIStateNodeStatic>& out) const;
    void addChildren(const TreeNodePtr& node, AIStateNode& parent, const AIPtr& ai) const;

    // only call these from the Server::update method
    void broadcastState(const Zone* zone);
    void broadcastCharacterDetails(const Zone* zone);
    void broadcastStaticCharacterDetails(const Zone* zone);

    void onConnect(Client* client) override;
    void onDisconnect(Client* client) override;

    void handleEvents(Zone* zone, bool pauseState);
    void enqueueEvent(const Event& event);
public:
    Server(AIRegistry& aiRegistry, short port = 10001, const std::string& hostname = "0.0.0.0");
    virtual ~Server();

    bool start();

    bool updateNode(const CharacterId& characterId, int32_t nodeId, const std::string& name, const std::string& type, const std::string& condition);

    bool addNode(const CharacterId& characterId, int32_t parentNodeId, const std::string& name, const std::string& type, const std::string& condition);

    bool deleteNode(const CharacterId& characterId, int32_t nodeId);

    void addZone(Zone* zone);

    void removeZone(Zone* zone);

    void setDebug(const std::string& zoneName);

    void reset();

    void select(const ClientId& clientId, const CharacterId& id);

    void pause(const ClientId& clientId, bool pause);

    void step(int64_t stepMillis = 1L);

    void update(int64_t deltaTime);
};

}