integration/luprex/core/cpp/world-core.cpp

#include "world.hpp"
#include "idalloc.hpp"
#include "animqueue.hpp"
#include "gui.hpp"
#include "traceback.hpp"
#include "pprint.hpp"
#include <iostream>

void World::store_global_pointer(lua_State *L, World *v) {
    lua_pushstring(L, "world");
    lua_pushlightuserdata(L, v);
    lua_rawset(L, LUA_REGISTRYINDEX);
}

World *World::fetch_global_pointer(lua_State *L) {
    lua_pushstring(L, "world");
    lua_rawget(L, LUA_REGISTRYINDEX);
    World *result = (World *)lua_touserdata(L, -1);
    if (result == nullptr) {
        luaL_error(L, "No world pointer stored.");
    }
    lua_pop(L, 1);
    return result;
}

World::~World() {
}

World::World(util::WorldType wt) {
    // Master world model by default.
    world_type_ = wt;

    // Initialize the ID allocator in master mode.
    if (wt == util::WORLD_TYPE_MASTER || wt == util::WORLD_TYPE_STANDALONE) {
        id_global_pool_.init_master();
    } else {
        id_global_pool_.init_synch();
    }

    // Prepare to manipulate the lua state.
    LuaVar world, globtab;
    LuaStack LS(state(), world, globtab);

    // Put the world pointer into the lua registry.
    World::store_global_pointer(state(), this);

    // Clear the global GUI pointer.
    Gui::store_global_pointer(state(), nullptr);

    // Clear the lthread state.
    clear_lthread_state();

    // Set the tabletype of the registry.
    LS.settabletype(LuaRegistry, LUA_TT_REGISTRY);

    // Set the tabletype of the global environment.
    LS.getglobaltable(globtab);
    LS.settabletype(globtab, LUA_TT_GLOBALENV);

    // Create the tangibles table in the registry.
    LS.rawset(LuaRegistry, "tangibles", LuaNewTable);

    // Create the globaldb in the registry.
    LS.rawset(LuaRegistry, "globaldb", LuaNewTable);

    // Initialize the SourceDB.  At this stage, the sourcedb is
    // empty, so it's just populating the lua builtins.
    source_db_.init(state());
    std::string srcerrs = source_db_.rebuild();

    // There shouldn't be any lua errors in the sourceDB at this
    // point, since there's no lua code in the sourceDB.
    assert(srcerrs == "");

    LS.result();
    assert (stack_is_clear());
}

Tangible::Tangible(World *w, int64_t id) : world_(w), anim_queue_(w->world_type_), id_player_pool_(&w->id_global_pool_) {
    plane_item_.set_id(id);
    plane_item_.track(&w->plane_map_);
}

void Tangible::update_plane_item() {
    const AnimStep &aqback = anim_queue_.back();
    plane_item_.set_pos(aqback.plane(), aqback.xyz().x, aqback.xyz().y, aqback.xyz().z);
}

void Tangible::serialize(StreamBuffer *sb) {
    anim_queue_.serialize(sb);
    id_player_pool_.serialize(sb);
    print_buffer_.serialize(sb);
}

void Tangible::deserialize(StreamBuffer *sb) {
    anim_queue_.deserialize(sb);
    id_player_pool_.deserialize(sb);
    print_buffer_.deserialize(sb);
    update_plane_item();
}

Tangible *World::tangible_get(int64_t id) {
    auto iter = tangibles_.find(id);
    if (iter == tangibles_.end()) {
        return nullptr;
    } else {
        return iter->second.get();
    }
}

const Tangible *World::tangible_get(int64_t id) const {
    auto iter = tangibles_.find(id);
    if (iter == tangibles_.end()) {
        return nullptr;
    } else {
        return iter->second.get();
    }
}

World::TanVector World::tangible_get_all(const IdVector &ids) const {
    TanVector result(ids.size());
    for (int i = 0; i < int(ids.size()); i++) {
        result[i] = tangible_get(ids[i]);
    }
    return result;
}

Tangible *World::tangible_get(const LuaStack &LS, LuaSlot tab) {
    int64_t id = tangible_id(LS, tab);
    if (id == 0) {
        luaL_error(LS.state(), "parameter is not a tangible");
    }
    Tangible *result = tangible_get(id);
    if (result == nullptr) {
        luaL_error(LS.state(), "parameter is not a tangible");
    }
    return result;
}

int64_t World::tangible_id(const LuaStack &LS, LuaSlot tab) {
    int64_t id = 0;
    if (LS.istable(tab) && LS.gettabletype(tab) == LUA_TT_TANGIBLE) {
        lua_State *L = LS.state();
        if (lua_getmetatable(L, tab.index())) {
            lua_pushstring(L, "id");
            lua_rawget(L, -2);
            if (lua_type(L, -1) == LUA_TNUMBER) {
                id = lua_tointeger(L, -1);
            }
            lua_pop(L, 2);
        }
    }
    return id;
}

Tangible *World::tangible_make(lua_State *L, int64_t id, const std::string &plane, bool pushdb) {
    // Get a state if we don't already have one.
    if (L == nullptr) {
        L = state();
        assert(!pushdb);
    }
    assert(id != 0);

    LuaVar tangibles, metatab;
    LuaRet database;
    LuaStack LS(L, tangibles, database, metatab);

    // Create the C++ part of the structure.
    UniqueTangible &t = tangibles_[id];
    assert (t == nullptr);
    t.reset(new Tangible(this, id));

    // Set up initial animation state.
    t->anim_queue_.clear(plane);
    t->update_plane_item();
    
    // Create the tangible's database and metatable.
    LS.set(database, LuaNewTable);
    LS.set(metatab, LuaNewTable);
    LS.setmetatable(database, metatab);

    // Mark the tangible using the tabletype field.
    LS.settabletype(database, LUA_TT_TANGIBLE);
    LS.settabletype(metatab, LUA_TT_TANGIBLEMETA);

    // Store the database into the tangibles table.
    LS.rawget(tangibles, LuaRegistry, "tangibles");
    LS.rawset(tangibles, id, database);

    // Populate the database and metatable with initial stuff.
    LS.rawset(database, "inventory", LuaNewTable);
    LS.rawset(metatab, "id", id);
    LS.rawset(metatab, "threads", LuaNewTable);
    // LS.rawset(metatab, "__metatable", LuaNil);

    LS.result();
    if (!pushdb) lua_pop(L, 1);
    return t.get();
}

void World::tangible_delete(int64_t id) {
    lua_State *L = state();
    LuaVar tangibles, database;
    LuaStack LS(L, tangibles, database);

    // Fetch the C++ side of the tangible.
    auto iter = tangibles_.find(id);
    if (iter == tangibles_.end()) {
        LS.result();
        return; // Nothing to delete.
    }

    // Fetch the lua side of the tangible.
    LS.rawget(tangibles, LuaRegistry, "tangibles");
    LS.rawget(database, tangibles, id);
    assert(LS.istable(database));
    
    // Clear out the database.
    LS.cleartable(database, true);
    LS.settabletype(database, LUA_TT_DEADTANGIBLE);

    // Remove the lua portion from the tangibles table.
    LS.rawset(tangibles, id, LuaNil);

    // Remove the C++ portion from the tangibles table.
    tangibles_.erase(iter);
    LS.result();
}

util::IdVector World::get_near_unsorted(int64_t player_id, float radius, bool exclude_nowhere) const {
    const Tangible *player = tangible_get(player_id);
    if (player == nullptr) {
        return IdVector();
    }

    // Find out where's the center of the world.
    const AnimStep &aqback = player->anim_queue_.back();
    if (exclude_nowhere && (aqback.plane() == "nowhere")) {
        IdVector idv;
        idv.push_back(player_id);
        return idv;
    }
    
    return plane_map_.scan_radius(aqback.plane(), aqback.xyz().x, aqback.xyz().y, radius, player_id);
}

util::IdVector World::get_near(int64_t player_id, float radius, bool exclude_nowhere) const {
    util::IdVector v = get_near_unsorted(player_id, radius, exclude_nowhere);
    std::sort(v.begin(), v.end());
    return v;
}

World::Redirects World::fetch_redirects() {
    World::Redirects result = std::move(redirects_);
    redirects_.clear();
    return result;
}

int64_t World::create_login_actor() {
    assert(stack_is_clear());
    int64_t id = id_global_pool_.get_one();
    Tangible *tan = tangible_make(state(), id, "nowhere", true);
    LuaArg database;
    LuaVar classtab, mt;
    LuaStack LS(state(), database, classtab, mt);
    LS.makeclass(classtab, "login");
    LS.getmetatable(mt, database);
    LS.rawset(mt, "__index", classtab);
    LS.result();
    tan->configure_id_pool_for_actor();
    tan->print_buffer_.clear();
    assert(stack_is_clear());
    return tan->id();
}

void World::update_gui(int64_t actor_id, int64_t place_id, Gui *gui) {
    assert(stack_is_clear());
    gui->clear(place_id);
    lua_State *L = state();

    LuaVar actor, place, ugui, func, tangibles, mt, index;
    LuaStack LS(L, actor, place, ugui, func, tangibles, mt, index);

    // Get the actor and place.
    LS.rawget(tangibles, LuaRegistry, "tangibles");
    LS.rawget(actor, tangibles, actor_id);
    LS.rawget(place, tangibles, place_id);
    if (!LS.istable(actor) || !LS.istable(place)) {
        LS.result();
        return;
    }

    // Get the interface closure.
    LS.getmetatable(mt, place);
    if (!LS.istable(mt)) {
        LS.result();
        return;
    }
    LS.rawget(index, mt, "__index");
    if (!LS.istable(index)) {
        LS.result();
        return;
    }
    LS.rawget(func, index, "interface");
    if (!LS.isfunction(func)) {
        LS.result();
        return;
    }

    // Call the interface function.
    lua_pushvalue(L, func.index());
    lua_pushvalue(L, actor.index());
    lua_pushvalue(L, place.index());
    Gui::store_global_pointer(L, gui);
    open_lthread_state(actor_id, place_id, false, false);
    int status = traceback_pcall(L, 2, 0);
    close_lthread_state();
    Gui::store_global_pointer(L, nullptr);
    if (status != 0) {
        gui->clear(0);
        std::cerr << lua_tostring(L, -1);
        LS.result();
        return;
    }

    // And we're done.
    LS.result();
    assert(stack_is_clear());
}

void World::update_source(util::LuaSourcePtr source) {
    assert(stack_is_clear());
    if (source != nullptr) {
        source_db_.update(*source);
        assert(stack_is_clear());
        std::string errs = source_db_.rebuild();
        // I don't have a good place to send the error messages right
        // now.  The engine needs a catch-all place to send errors that
        // occur at unexpected times.
        std::cerr << errs;
    }
    assert(stack_is_clear());
}

void World::run_unittests() {
    assert(stack_is_clear());
    source_db_.run_unittests();
    assert(stack_is_clear());
}

void World::invoke(const Invocation &inv) {
    switch (inv.kind()) {
    case Invocation::KIND_PLAN:
        invoke_plan(inv.actor(), inv.place(), inv.action(), inv.data());
        break;
    case Invocation::KIND_LUA:
        invoke_lua(inv.actor(), inv.place(), inv.action(), inv.data());
        break;
    case Invocation::KIND_FLUSH_PRINTS:
        invoke_flush_prints(inv.actor(), inv.place(), inv.action(), inv.data());
        break;
    default:
        // Do nothing.  Standard behavior for any invalid command is to
        // simply do nothing at all.  Perhaps eventually we may add a flag
        // to the world model to indicate that we've detected an invalid
        // command, to allow us to close the connection to a client that
        // is misbehaving.
        break;
    }
}

void World::invoke_flush_prints(int64_t actor_id, int64_t place_id, const std::string &action, const InvocationData &data) {
    assert(stack_is_clear());
    // Check argument sanity.
    if (actor_id != place_id) {
        return;
    }
    int line = util::strtoint(action, -1);
    if (line < 0) {
        return;
    }
    Tangible *tactor = tangible_get(actor_id);
    if (tactor == nullptr) {
        return;
    }
    tactor->print_buffer_.discard_upto(line);
    assert(stack_is_clear());
}


void World::invoke_lua(int64_t actor_id, int64_t place_id, const std::string &action, const InvocationData &data) {
    assert(stack_is_clear());

    // Get the actor and place, which must be the same.
    if (actor_id != place_id) return;
    Tangible *tactor = tangible_get(actor_id);
    if (tactor == nullptr) {
        return;
    }

    lua_State *L = state();
    LuaVar closure;
    LuaStack LS(L, closure);

    // create the compiled closure.
    int status = luaL_loadbuffer(L, action.c_str(), action.size(), "=invoke");
    lua_replace(L, closure.index());
    if (status != LUA_OK) {
        // The closure is actually an error message. Do nothing.
        LS.result();
        return;
    }

    // Call the closure.
    int top = lua_gettop(L);
    lua_pushvalue(L, closure.index());
    open_lthread_state(actor_id, place_id, false, true);
    status = traceback_pcall(L, 0, LUA_MULTRET);
    
    // If there's an error message, print it.
    // Otherwise, pretty-print the results.
    std::ostream *ostream = lthread_print_stream();
    if (status == LUA_OK) {
        for (int i = top + 1; i <= lua_gettop(L); i++) {
            LuaSpecial root(i);
            pprint(LS, root, true, ostream);
            (*ostream) << std::endl;
        }
    } else {
        const char *msg = lua_tostring(L, -1);
        if (msg == NULL) {
            msg = "(error object is not a string)";
        }
        (*ostream) << msg << std::endl;
    }
    close_lthread_state();

    LS.result();
    assert(stack_is_clear());
}

void World::invoke_plan(int64_t actor_id, int64_t place_id, const std::string &action, const InvocationData &data) {
    assert(stack_is_clear());

    // Validate that the action is legal.
    Gui validation_gui;
    update_gui(actor_id, place_id, &validation_gui);
    if (!validation_gui.has_action(action)) {
        return;
    }

    // Get the actor and place.  Make sure both exist.
    Tangible *tactor = tangible_get(actor_id);
    Tangible *tplace = tangible_get(place_id);
    if ((tactor == nullptr) || (tplace == nullptr)) {
        return;
    }

    // Get an ID for the thread.  We always use the player
    // pool in this case.
    int64_t tid = tactor->id_player_pool_.get_one();

    // Set up for Lua manipulation.
    lua_State *L = state();
    LuaVar actor, place, func, tangibles, mt, index, actions, thread, threads, thinfo, message, invdata;
    LuaStack LS(L, actor, place, func, tangibles, mt, index, actions, thread, threads, thinfo, message, invdata);

    // Get the actor and place.
    LS.rawget(tangibles, LuaRegistry, "tangibles");
    LS.rawget(actor, tangibles, actor_id);
    LS.rawget(place, tangibles, place_id);
    if (!LS.istable(actor) || !LS.istable(place)) {
        LS.result();
        return;
    }

    // Get the action closure.
    LS.getmetatable(mt, place);
    if (!LS.istable(mt)) {
        LS.result();
        return;
    }
    LS.rawget(index, mt, "__index");
    if (!LS.istable(index)) {
        LS.result();
        return;
    }
    LS.rawget(actions, index, "action");
    if (!LS.istable(actions)) {
        LS.result();
        return;
    }
    LS.rawget(func, actions, action);
    if (!LS.isfunction(func)) {
        LS.result();
        return;
    }

    // Convert the InvocationData into a lua table.
    LS.newtable(invdata);
    for (const auto &p : data) {
        LS.rawset(invdata, p.first, p.second);
    }

    // Create a new thread, set up function and parameters.
    lua_State *CO = LS.newthread(thread);
    
    // Move function and args to new thread.
    lua_pushvalue(L, func.index());
    lua_pushvalue(L, actor.index());
    lua_pushvalue(L, place.index());
    lua_pushvalue(L, invdata.index());
    lua_xmove(L, CO, 4);

    // Create the thread info table.
    LS.newtable(thinfo);
    LS.rawset(thinfo, "thread", thread);
    LS.rawset(thinfo, "actorid", actor_id);
    LS.rawset(thinfo, "isnew", true);
    LS.rawset(thinfo, "useppool", true);
    
    // Store the thread into place's thread table.
    LS.rawget(threads, mt, "threads");
    if (!LS.istable(threads)) {
        LS.result();
        return;
    }
    LS.rawset(threads, tid, thinfo);
    LS.result();
    
    // Push the thread's ID into the runnable thread queue,
    // then run the thread queue.
    thread_sched_.add(0, tid, place_id);
    run_scheduled_threads(0);
    assert(stack_is_clear());
}

void World::run_scheduled_threads(int64_t clk) {
    assert(stack_is_clear());
    lua_State *L = state();
    LuaVar tangibles, place, mt, threads, thinfo, actorid, isnew, useppool, thread;
    LuaStack LS(L, tangibles, place, mt, threads, thinfo, actorid, isnew, useppool, thread);
    LS.rawget(tangibles, LuaRegistry, "tangibles");

    while (thread_sched_.ready(clk)) {
        SchedEntry sched = thread_sched_.pop();
        LS.rawget(place, tangibles, sched.place_id());
        if (!LS.istable(place)) {
            continue;
        }
        LS.getmetatable(mt, place);
        if (!LS.istable(mt)) {
            continue;
        }
        LS.rawget(threads, mt, "threads");
        if (!LS.istable(threads)) {
            continue;
        }
        LS.rawget(thinfo, threads, sched.thread_id());
        if (!LS.istable(thinfo)) {
            continue;
        }
        LS.rawget(actorid, thinfo, "actorid");
        if (!LS.isnumber(actorid)) {
            continue;
        }
        LS.rawget(isnew, thinfo, "isnew");
        if (!LS.isboolean(isnew)) {
            continue;
        }
        LS.rawget(useppool, thinfo, "useppool");
        if (!LS.isboolean(useppool)) {
            continue;
        }
        LS.rawget(thread, thinfo, "thread");
        if (!LS.isthread(thread)) {
            continue;
        }

        // Resume the coroutine.
        lua_State *CO = LS.ckthread(thread);
        open_lthread_state(LS.ckinteger(actorid), sched.place_id(), LS.ckboolean(useppool), true);
        int status = lua_resume(CO, nullptr, LS.ckboolean(isnew) ? 3 : 0);
        close_lthread_state();
        
        // Three possible outcomes: finished, yielded, or errored.
        if (status == LUA_YIELD) {
            // If there's nothing on the stack, infer that tangible.nopredict yielded.
            if (lua_gettop(CO) == 0) {
                std::cerr << "Thread killed self using tangible.nopredict" << std::endl;
                LS.rawset(threads, sched.thread_id(), LuaNil);
            }
            // If there's a single number on the stack, infer that 'wait' yielded.
            else if ((lua_gettop(CO) == 1) && (lua_isnumber(CO, 1))) {
                lua_Number delay = lua_tonumber(CO, 1);
                lua_settop(CO, 0);
                LS.rawset(thinfo, "isnew", false);
                LS.rawset(thinfo, "useppool", false);
                std::cerr << "Thread wait = " << delay << std::endl;
                thread_sched_.add(sched.clock() + int64_t(delay), sched.thread_id(), sched.place_id());
                std::cerr << "Added to schedule." << std::endl;
            }
            // In any other case, generate an error and kill the coroutine.
            else {
                std::cerr << "Thread yielded incorrectly.  Killing it." << std::endl;
                LS.rawset(threads, sched.thread_id(), LuaNil);
            }
        } else if (status == LUA_OK) {
            // Successfully ran to completion.  Remove from thread table.
            std::cerr << "Thread ran to completion." << std::endl;
            LS.rawset(threads, sched.thread_id(), LuaNil);
        } else {
            // Generated an error.  Add a traceback, print, and kill the coroutine.
            traceback_coroutine(CO);
            std::cerr << lua_tostring(CO, -1);
            LS.rawset(threads, sched.thread_id(), LuaNil);
        }
    }
    LS.result();
    assert(stack_is_clear());
}

int64_t World::alloc_id_predictable() {
    if (!lthread_use_ppool_) {
        return id_global_pool_.get_one();
    }
    Tangible *t = tangible_get(lthread_actor_id_);
    if (t == nullptr) {
        return id_global_pool_.get_one();
    }
    return t->id_player_pool_.get_one();
}

const PrintBuffer *World::get_printbuffer(int64_t actor_id) {
    Tangible *actor = tangible_get(actor_id);
    if (actor != nullptr) {
        return &actor->print_buffer_;
    }
    return nullptr;
}

void World::clear_lthread_state() {
    lthread_prints_.reset();
    lthread_actor_id_ = 0;
    lthread_place_id_ = 0;
    lthread_use_ppool_ = false;
}

void World::open_lthread_state(int64_t actor, int64_t place, bool ppool, bool prints) {
    lthread_actor_id_ = actor;
    lthread_place_id_ = place;
    lthread_use_ppool_ = ppool;
    if (prints) {
        lthread_prints_.reset(new std::ostringstream);
    } else {
        lthread_prints_.reset();
    }
}

void World::close_lthread_state() {
    // Copy prints from lthread_prints_ stringstream into
    // the appropriate actor's PrintBuffer.  If for some reason
    // there isn't an actor, or if the actor doesn't have a PrintBuffer,
    // send the output to std::cerr.
    if (lthread_prints_ != nullptr) {
        const std::string &output = lthread_prints_->str();
        Tangible *actor = tangible_get(lthread_actor_id_);
        if (actor != nullptr) {
            bool auth = util::world_type_authoritative(world_type_);
            actor->print_buffer_.add_string(output, auth);
        }
    }
    // Now clean up everything.
    clear_lthread_state();
}

std::ostream *World::lthread_print_stream() const {
    if (lthread_prints_ != nullptr) {
        return lthread_prints_.get();
    } else {
        return &std::cerr;
    }
}

void World::serialize(StreamBuffer *sb) {
    assert(stack_is_clear());
    assert(redirects_.empty());
    // int64_t wc0 = sb->total_writes();
    lua_snap_.serialize(sb);
    id_global_pool_.serialize(sb);
    thread_sched_.serialize(sb);
    sb->write_uint32(tangibles_.size());
    for (const auto &p : tangibles_) {
        sb->write_int64(p.first);
        p.second->serialize(sb);
    }
    // int64_t wc1 = sb->total_writes();
    // std::cerr << "World serialized to " << wc1-wc0 << " bytes." << std::endl;
    assert(stack_is_clear());
}

void World::deserialize(StreamBuffer *sb) {
    assert(stack_is_clear());
    redirects_.clear();
    lua_snap_.deserialize(sb);
    id_global_pool_.deserialize(sb);
    thread_sched_.deserialize(sb);
    // Mark all tangibles for deletion by setting ID to zero.
    for (const auto &p : tangibles_) {
        p.second->plane_item_.set_id(0);
    }
    // Deserialize tangibles.
    size_t ntan = sb->read_uint32();
    for (size_t i = 0; i < ntan; i++) {
        int64_t id = sb->read_int64();
        UniqueTangible &t = tangibles_[id];
        if (t == nullptr) {
            t.reset(new Tangible(this, id));
        } else {
            t->plane_item_.set_id(id);
        }
        t->deserialize(sb);
    }
    // Delete tangibles that didn't get deserialized.
    for (auto iter = tangibles_.begin(); iter != tangibles_.end(); ) {
        if (iter->second->plane_item_.id() == 0) {
            tangibles_.erase(iter++);
        } else {
            ++iter;
        }
    }
    assert(stack_is_clear());
}

void World::snapshot() {
    assert(snapshot_.empty());
    serialize(&snapshot_);
    assert(!snapshot_.empty());
}

void World::rollback() {
    assert(!snapshot_.empty());
    deserialize(&snapshot_);
    assert(snapshot_.empty());
}