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

#include "world.hpp"
#include "idalloc.hpp"
#include "animqueue.hpp"
#include "gui.hpp"
#include "traceback.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);

    // 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());
    source_db_.rebuild(true);

    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);
}

void Tangible::deserialize(StreamBuffer *sb) {
    anim_queue_.deserialize(sb);
    id_player_pool_.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);
    }

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

    // Allocate an ID if we don't already have one.
    if (id == 0) id = id_global_pool_.alloc_id_for_thread(L);

    // Create the C++ part of the structure.
    std::unique_ptr<Tangible> &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.clearmetatable(database);
    LS.cleartable(database);
    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")) {
        return IdVector();
    }
    
    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 std::move(result);
}

int64_t World::create_login_actor() {
    Tangible *tan = tangible_make(state(), 0, "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();
    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();
    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);
    int status = traceback_pcall(L, 2, 0);
    Gui::store_global_pointer(L, nullptr);
    if (status != 0) {
        gui->clear();
        std::cerr << lua_tostring(L, -1);
        LS.result();
        return;
    }

    // And we're done.
    LS.result();
    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;
    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_plan(int64_t actor_id, int64_t place_id, const std::string &action, const InvocationData &idata) {
    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 batch for the thread, and take one for the thread itself.
    int64_t id_batch = tactor->id_player_pool_.get_batch();
    int64_t tid = id_batch++;

    // Set up for Lua manipulation.
    lua_State *L = state();
    LuaVar actor, place, func, tangibles, mt, index, actions, thread, threads, message, invdata;
    LuaStack LS(L, actor, place, func, tangibles, mt, index, actions, thread, threads, 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 : idata) {
        LS.rawset(invdata, p.first, p.second);
    }

    // Create a new thread, set up function and parameters.
    lua_State *CO = LS.newthread(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);

    // Store the thread into place's thread table.
    LS.rawget(threads, mt, "threads");
    if (!LS.istable(threads)) {
        LS.result();
        return;
    }
    LS.rawset(threads, tid, thread);
    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, thread;
    LuaStack LS(L, tangibles, place, mt, threads, 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(thread, threads, sched.thread_id());
        if (!LS.isthread(thread)) {
            continue;
        }

        // Resume the coroutine.
        lua_State *CO = LS.ckthread(thread);
        int top = lua_gettop(CO);
        int status = lua_resume(CO, nullptr, (top > 0) ? (top - 1) : 0);

        // Three possible outcomes: finished, yielded, or errored.
        if (status == LUA_YIELD) {
            // When the wait statement yields, it yields the desired timestamp.
            if ((lua_gettop(CO) != 1) || (!lua_isnumber(CO, 1))) {
                std::cerr << "Thread yielded incorrectly.  Killing it." << std::endl;
                LS.rawset(threads, sched.thread_id(), LuaNil);
            } else {
                lua_Number delay = lua_tonumber(CO, 1);
                lua_settop(CO, 0);
                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;
            }
        } 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());
}

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();
        std::unique_ptr<Tangible> &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() {
    snapshot_.clear();
    serialize(&snapshot_);
}

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