469 lines
14 KiB
C++
469 lines
14 KiB
C++
|
|
#include "world.hpp"
|
|
#include "idalloc.hpp"
|
|
#include "animqueue.hpp"
|
|
#include "gui.hpp"
|
|
#include "traceback.hpp"
|
|
#include <iostream>
|
|
|
|
Tangible::Tangible(World *w, int64_t id) : world_(w), id_player_pool_(&w->id_global_pool_) {
|
|
plane_item_.set_id(id);
|
|
w->plane_map_.track(&plane_item_);
|
|
}
|
|
|
|
World::~World() {
|
|
}
|
|
|
|
World::World() {
|
|
// Initialize the ID allocator in master mode.
|
|
id_global_pool_.init_master(10);
|
|
|
|
// Prepare to manipulate the lua state.
|
|
LuaVar world;
|
|
LuaStack LS(state(), world);
|
|
|
|
// 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);
|
|
|
|
// Create the tangibles table in the registry.
|
|
LS.rawset(LuaRegistry, "tangibles", LuaNewTable);
|
|
|
|
// Initialize the SourceDB
|
|
source_db_.init(state());
|
|
source_db_.rebuild();
|
|
|
|
LS.result();
|
|
assert (lua_gettop(state()) == 0);
|
|
}
|
|
|
|
void Tangible::update_plane_item() {
|
|
util::XYZ xyz = anim_queue_.get_xyz();
|
|
std::string plane = anim_queue_.get_plane();
|
|
plane_item_.set_pos(plane, xyz.x, xyz.y, 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();
|
|
}
|
|
|
|
void Tangible::be_a_player() {
|
|
if (!id_player_pool_.fifo_enabled()) {
|
|
id_player_pool_.enable_fifo();
|
|
|
|
anim_queue_.add(world_->id_global_pool_.get_one(), "");
|
|
anim_queue_.set_graphic("player");
|
|
|
|
LuaVar classtab, mt, place, tangibles;
|
|
LuaStack LS(world_->state(), classtab, mt, place, tangibles);
|
|
|
|
LS.makeclass(classtab, "player");
|
|
LS.rawget(tangibles, LuaRegistry, "tangibles");
|
|
LS.rawget(place, tangibles, id());
|
|
LS.getmetatable(mt, place);
|
|
LS.rawset(mt, "__index", classtab);
|
|
LS.result();
|
|
}
|
|
}
|
|
|
|
void World::init_standalone() {
|
|
// Load the lua source from disk then rebuild the environment.
|
|
source_db_.update();
|
|
source_db_.rebuild();
|
|
|
|
// Run unit tests.
|
|
source_db_.run_unittests();
|
|
|
|
// Create the player tangible.
|
|
Tangible *player = tangible_make(state(), 1, false);
|
|
player->be_a_player();
|
|
}
|
|
|
|
Tangible *World::tangible_get(int64_t id) {
|
|
auto iter = tangibles_.find(id);
|
|
if (iter == tangibles_.end()) {
|
|
return nullptr;
|
|
} else {
|
|
return iter->second.get();
|
|
}
|
|
}
|
|
|
|
Tangible *World::tangible_get(lua_State *L, int idx) {
|
|
Tangible *result = nullptr;
|
|
int top = lua_gettop(L);
|
|
if (lua_istable(L, idx)) {
|
|
lua_getmetatable(L, idx);
|
|
if (lua_istable(L, -1)) {
|
|
lua_pushstring(L, "id");
|
|
lua_rawget(L, -2);
|
|
lua_Number id = lua_tonumber(L, -1);
|
|
result = tangible_get(int64_t(id));
|
|
}
|
|
}
|
|
lua_settop(L, top);
|
|
if (result == nullptr) {
|
|
luaL_error(L, "parameter is not a tangible");
|
|
}
|
|
return result;
|
|
}
|
|
|
|
std::vector<int64_t> World::get_near(int64_t player_id, float radius) {
|
|
Tangible *player = tangible_get(player_id);
|
|
|
|
// Find out where's the center of the world.
|
|
std::string plane = player->anim_queue_.get_plane();
|
|
util::XYZ xyz = player->anim_queue_.get_xyz();
|
|
|
|
return plane_map_.scan_radius(plane, xyz.x, xyz.y, radius, player_id);
|
|
}
|
|
|
|
Tangible *World::tangible_make(lua_State *L, int64_t id, bool 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));
|
|
|
|
// Create the tangible's database and metatable.
|
|
LS.set(database, LuaNewTable);
|
|
LS.set(metatab, LuaNewTable);
|
|
LS.setmetatable(database, metatab);
|
|
|
|
// 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::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;
|
|
}
|
|
|
|
void World::update_gui(int64_t actor_id, int64_t place_id, Gui *gui) {
|
|
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();
|
|
}
|
|
|
|
void World::invoke_plan(int64_t actor_id, int64_t place_id, const std::string &action, const GuiResult &gres) {
|
|
// 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 an ID batch for the thread, and take one for the thread itself.
|
|
Tangible *tactor = tangible_get(actor_id);
|
|
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, guires;
|
|
LuaStack LS(L, actor, place, func, tangibles, mt, index, actions, thread, threads, message, guires);
|
|
|
|
// 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 GuiResult into a lua table.
|
|
LS.newtable(guires);
|
|
for (const auto &p : gres) {
|
|
LS.rawset(guires, 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, guires.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);
|
|
}
|
|
|
|
void World::run_scheduled_threads(int64_t clk) {
|
|
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 == 0) {
|
|
// 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();
|
|
}
|
|
|
|
void World::serialize(StreamBuffer *sb) {
|
|
int64_t wc0 = sb->write_count();
|
|
lua_snap_.serialize(sb);
|
|
id_global_pool_.serialize(sb);
|
|
thread_sched_.serialize(sb);
|
|
sb->write_size(tangibles_.size());
|
|
for (const auto &p : tangibles_) {
|
|
sb->write_int64(p.first);
|
|
p.second->serialize(sb);
|
|
}
|
|
int64_t wc1 = sb->write_count();
|
|
std::cerr << "World serialized to " << wc1-wc0 << " bytes." << std::endl;
|
|
}
|
|
|
|
void World::deserialize(StreamBuffer *sb) {
|
|
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_size();
|
|
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;
|
|
}
|
|
}
|
|
}
|
|
|
|
void World::snapshot() {
|
|
snapshot_.clear();
|
|
serialize(&snapshot_);
|
|
}
|
|
|
|
void World::rollback() {
|
|
assert(!snapshot_.at_eof());
|
|
deserialize(&snapshot_);
|
|
}
|
|
|
|
LuaDefine(tangible_xyz, "c") {
|
|
LuaArg tanobj;
|
|
LuaRet X, Y, Z;
|
|
LuaStack LS(L, tanobj, X, Y, Z);
|
|
World *w = World::fetch_global_pointer(L);
|
|
Tangible *tan = w->tangible_get(L, tanobj.index());
|
|
util::XYZ xyz = tan->anim_queue_.get_xyz();
|
|
LS.set(X, xyz.x);
|
|
LS.set(Y, xyz.y);
|
|
LS.set(Z, xyz.z);
|
|
return LS.result();
|
|
}
|
|
|
|
LuaDefine(tangible_plane, "c") {
|
|
LuaArg tanobj;
|
|
LuaRet plane;
|
|
LuaStack LS(L, tanobj, plane);
|
|
World *w = World::fetch_global_pointer(L);
|
|
Tangible *tan = w->tangible_get(L, tanobj.index());
|
|
LS.set(plane, tan->anim_queue_.get_plane());
|
|
return LS.result();
|
|
}
|
|
|
|
LuaDefine(tangible_animate, "c") {
|
|
LuaArg tanobj, config;
|
|
LuaStack LS(L, tanobj, config);
|
|
World *w = World::fetch_global_pointer(L);
|
|
Tangible *tan = w->tangible_get(L, tanobj.index());
|
|
int64_t id = w->id_global_pool_.alloc_id_for_thread(L);
|
|
tan->anim_queue_.add(id, L, config.index());
|
|
tan->update_plane_item();
|
|
return LS.result();
|
|
}
|
|
|
|
LuaDefine(tangible_make, "c") {
|
|
World::fetch_global_pointer(L)->tangible_make(L, 0, true);
|
|
return 1;
|
|
}
|
|
|
|
LuaDefine(world_wait, "f") {
|
|
if ((lua_gettop(L) != 1) || (lua_type(L, -1) != LUA_TNUMBER)) {
|
|
luaL_error(L, "Argument to wait must be a number.");
|
|
}
|
|
return lua_yield(L, 1);
|
|
}
|
|
|
|
LuaDefine(world_getregistry, "f") {
|
|
lua_pushvalue(L, LUA_REGISTRYINDEX);
|
|
return 1;
|
|
}
|