integration/luprex/core/cpp/lpxclient.cpp

#include "lpxclient.hpp"

#include "drivenengine.hpp"
#include "world.hpp"
#include "luaconsole.hpp"
#include "invocation.hpp"
#include "util.hpp"
#include <memory>

class LpxClient : public DrivenEngine {
public:
    using StringVec = LuaConsole::StringVec;
    UniqueWorld world_;
    int64_t actor_id_;
    InvocationQueue unack_;
    UniqueChannel channel_;
    LuaConsole console_;
    Gui gui_;
    int64_t gui_place_;

public:
    virtual void event_init(int argc, char *argv[]) {
        // Create the world model.
        world_.reset(new World(util::WORLD_TYPE_C_SYNC));

        // This is a temporary actor that will be used only until the server sends
        // us the first difference transmission.  We do this only to establish
        // the invariant that there's always an actor.  When the first difference
        // transmission arrives, this actor may be deleted, or it may just be
        // ignored, at the server's discretion.
        actor_id_ = world_->create_login_actor();

        // Establish a connection to the server.
        channel_ = new_outgoing_channel("localhost:8085");
    }

    void do_lua(const std::string &lua) {
        stdostream() << "Lua: " << lua << std::endl;
    }

    void do_command(const util::StringVec &words) {
        stdostream() << "Command: ";
        for (const std::string &word : words) {
            stdostream() << word << " ";
        }
        stdostream() << std::endl;
    }

    void console_process(const std::string &line) {
        console_.add(line);
        int action = console_.action();
        if (action == LuaConsole::DO_LUA) {
            do_lua(console_.lua_expression());
            console_.clear();
        } else if (action == LuaConsole::DO_COMMAND) {
            do_command(console_.words());
            console_.clear();
        } else if (action == LuaConsole::DO_SYNTAX) {
            stdostream() << console_.syntax() << std::endl;
            console_.clear();
        }
    }

    virtual void event_update() {
        // Check for keyboard input on stdin.
        while (true) {
            std::string line = get_stdio_channel()->in()->readline();
            if (line == "") break;
            console_process(line);
            get_stdio_channel()->out()->write_bytes(console_.get_prompt());
        }

        // Check for communication from server..
        if (channel_ != nullptr) {
            if (channel_->closed()) {
                stdostream() << "Server closed connection " << channel_->error() << std::endl;
                channel_.reset();
                // stop_driver();
            } else {
                // Implement reception of messages.
            }
        }
    }
};

UniqueDrivenEngine make_LpxClient() {
    return UniqueDrivenEngine(new LpxClient);
}