255 lines
7.6 KiB
C++
255 lines
7.6 KiB
C++
#include "content/Content.hpp"
|
|
#include "items/Inventories.hpp"
|
|
#include "items/ItemStack.hpp"
|
|
#include "logic/BlocksController.hpp"
|
|
#include "world/Level.hpp"
|
|
#include "api_lua.hpp"
|
|
|
|
using namespace scripting;
|
|
|
|
namespace {
|
|
void validate_itemid(itemid_t id) {
|
|
if (id >= indices->items.count()) {
|
|
throw std::runtime_error("invalid item id");
|
|
}
|
|
}
|
|
|
|
Inventory& get_inventory(int64_t id) {
|
|
auto inv = level->inventories->get(id);
|
|
if (inv == nullptr) {
|
|
throw std::runtime_error("inventory not found: " + std::to_string(id));
|
|
}
|
|
return *inv;
|
|
}
|
|
|
|
Inventory& get_inventory(int64_t id, int arg) {
|
|
auto inv = level->inventories->get(id);
|
|
if (inv == nullptr) {
|
|
throw std::runtime_error(
|
|
"inventory not found: " + std::to_string(id) + " argument " +
|
|
std::to_string(arg)
|
|
);
|
|
}
|
|
return *inv;
|
|
}
|
|
|
|
void validate_slotid(int slotid, const Inventory& inv) {
|
|
if (static_cast<size_t>(slotid) >= inv.size()) {
|
|
throw std::runtime_error(
|
|
"slot index is out of range [0..inventory.size(invid)]"
|
|
);
|
|
}
|
|
}
|
|
|
|
using SlotFunc = int(lua::State*, ItemStack&);
|
|
|
|
template <SlotFunc func>
|
|
int wrap_slot(lua::State* L) {
|
|
auto invid = lua::tointeger(L, 1);
|
|
auto slotid = lua::tointeger(L, 2);
|
|
auto& inv = get_inventory(invid);
|
|
validate_slotid(slotid, inv);
|
|
auto& item = inv.getSlot(slotid);
|
|
return func(L, item);
|
|
}
|
|
}
|
|
|
|
static int l_get(lua::State* L, ItemStack& item) {
|
|
lua::pushinteger(L, item.getItemId());
|
|
lua::pushinteger(L, item.getCount());
|
|
return 2;
|
|
}
|
|
|
|
static int l_set(lua::State* L, ItemStack& item) {
|
|
auto itemid = lua::tointeger(L, 3);
|
|
auto count = lua::tointeger(L, 4);
|
|
auto data = lua::tovalue(L, 5);
|
|
if (!data.isObject() && data != nullptr) {
|
|
throw std::runtime_error("invalid data argument type (table expected)");
|
|
}
|
|
item.set(ItemStack(itemid, count, std::move(data)));
|
|
return 0;
|
|
}
|
|
|
|
static int l_set_count(lua::State* L, ItemStack& item) {
|
|
auto count = lua::tointeger(L, 3);
|
|
if (item.getItemId() == ITEM_EMPTY) {
|
|
return 0;
|
|
}
|
|
item.setCount(count);
|
|
return 0;
|
|
}
|
|
|
|
static int l_size(lua::State* L) {
|
|
auto invid = lua::tointeger(L, 1);
|
|
const auto& inv = get_inventory(invid);
|
|
return lua::pushinteger(L, inv.size());
|
|
}
|
|
|
|
static int l_add(lua::State* L) {
|
|
auto invid = lua::tointeger(L, 1);
|
|
auto itemid = lua::tointeger(L, 2);
|
|
auto count = lua::tointeger(L, 3);
|
|
auto data = lua::tovalue(L, 4);
|
|
|
|
validate_itemid(itemid);
|
|
if (!data.isObject() && data != nullptr) {
|
|
throw std::runtime_error("invalid data argument type (table expected)");
|
|
}
|
|
|
|
auto& inv = get_inventory(invid);
|
|
ItemStack item(itemid, count, std::move(data));
|
|
inv.move(item, *indices);
|
|
return lua::pushinteger(L, item.getCount());
|
|
}
|
|
|
|
static int l_get_block(lua::State* L) {
|
|
auto x = lua::tointeger(L, 1);
|
|
auto y = lua::tointeger(L, 2);
|
|
auto z = lua::tointeger(L, 3);
|
|
int64_t id = blocks->createBlockInventory(x, y, z);
|
|
return lua::pushinteger(L, id);
|
|
}
|
|
|
|
static int l_bind_block(lua::State* L) {
|
|
auto id = lua::tointeger(L, 1);
|
|
auto x = lua::tointeger(L, 2);
|
|
auto y = lua::tointeger(L, 3);
|
|
auto z = lua::tointeger(L, 4);
|
|
blocks->bindInventory(id, x, y, z);
|
|
return 0;
|
|
}
|
|
|
|
static int l_unbind_block(lua::State* L) {
|
|
auto x = lua::tointeger(L, 1);
|
|
auto y = lua::tointeger(L, 2);
|
|
auto z = lua::tointeger(L, 3);
|
|
blocks->unbindInventory(x, y, z);
|
|
return 0;
|
|
}
|
|
|
|
static int l_create(lua::State* L) {
|
|
auto invsize = lua::tointeger(L, 1);
|
|
auto inv = level->inventories->create(invsize);
|
|
if (inv == nullptr) {
|
|
return lua::pushinteger(L, 0);
|
|
}
|
|
return lua::pushinteger(L, inv->getId());
|
|
}
|
|
|
|
static int l_remove(lua::State* L) {
|
|
auto invid = lua::tointeger(L, 1);
|
|
level->inventories->remove(invid);
|
|
return 0;
|
|
}
|
|
|
|
static int l_clone(lua::State* L) {
|
|
auto id = lua::tointeger(L, 1);
|
|
auto clone = level->inventories->clone(id);
|
|
if (clone == nullptr) {
|
|
return lua::pushinteger(L, 0);
|
|
}
|
|
return lua::pushinteger(L, clone->getId());
|
|
}
|
|
|
|
static int l_move(lua::State* L) {
|
|
auto invAid = lua::tointeger(L, 1);
|
|
auto slotAid = lua::tointeger(L, 2);
|
|
auto& invA = get_inventory(invAid, 1);
|
|
validate_slotid(slotAid, invA);
|
|
|
|
auto invBid = lua::tointeger(L, 3);
|
|
auto slotBid = lua::isnil(L, 4) ? -1 : lua::tointeger(L, 4);
|
|
auto& invB = get_inventory(invBid, 3);
|
|
auto& slot = invA.getSlot(slotAid);
|
|
if (slotBid == -1) {
|
|
invB.move(slot, *content->getIndices());
|
|
} else {
|
|
invB.move(slot, *content->getIndices(), slotBid, slotBid + 1);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static int l_move_range(lua::State* L) {
|
|
auto invAid = lua::tointeger(L, 1);
|
|
auto slotAid = lua::tointeger(L, 2);
|
|
auto& invA = get_inventory(invAid, 1);
|
|
validate_slotid(slotAid, invA);
|
|
|
|
auto invBid = lua::tointeger(L, 3);
|
|
auto slotBegin = lua::isnoneornil(L, 4) ? -1 : lua::tointeger(L, 4);
|
|
auto slotEnd = lua::isnoneornil(L, 5) ? -1 : lua::tointeger(L, 5) + 1;
|
|
auto& invB = get_inventory(invBid, 3);
|
|
auto& slot = invA.getSlot(slotAid);
|
|
if (slotBegin == -1) {
|
|
invB.move(slot, *content->getIndices());
|
|
} else {
|
|
invB.move(slot, *content->getIndices(), slotBegin, slotEnd);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static int l_find_by_item(lua::State* L) {
|
|
auto invId = lua::tointeger(L, 1);
|
|
auto& inv = get_inventory(invId, 1);
|
|
integer_t blockid = lua::tointeger(L, 2);
|
|
integer_t begin = lua::isnumber(L, 3) ? lua::tointeger(L, 3) : 0;
|
|
integer_t end = lua::isnumber(L, 4) ? lua::tointeger(L, 4) : -1;
|
|
integer_t minCount = lua::isnumber(L, 5) ? lua::tointeger(L, 5) : blockid != 0;
|
|
size_t index = inv.findSlotByItem(blockid, begin, end, minCount);
|
|
if (index == Inventory::npos) {
|
|
return 0;
|
|
}
|
|
return lua::pushinteger(L, index);
|
|
}
|
|
|
|
static int l_get_data(lua::State* L, ItemStack& stack) {
|
|
auto key = lua::require_string(L, 3);
|
|
auto value = stack.getField(key);
|
|
if (value == nullptr) {
|
|
return 0;
|
|
}
|
|
return lua::pushvalue(L, *value);
|
|
}
|
|
|
|
static int l_get_all_data(lua::State* L, ItemStack& stack) {
|
|
return lua::pushvalue(L, stack.getFields());
|
|
}
|
|
|
|
static int l_has_data(lua::State* L, ItemStack& stack) {
|
|
auto key = lua::tostring(L, 3);
|
|
if (key == nullptr) {
|
|
return lua::pushboolean(L, stack.hasFields());
|
|
}
|
|
return lua::pushboolean(L, stack.getField(key) != nullptr);
|
|
}
|
|
|
|
static int l_set_data(lua::State* L, ItemStack& stack) {
|
|
auto key = lua::require_string(L, 3);
|
|
auto value = lua::tovalue(L, 4);
|
|
stack.setField(key, std::move(value));
|
|
return 0;
|
|
}
|
|
|
|
const luaL_Reg inventorylib[] = {
|
|
{"get", lua::wrap<wrap_slot<l_get>>},
|
|
{"set", lua::wrap<wrap_slot<l_set>>},
|
|
{"set_count", lua::wrap<wrap_slot<l_set_count>>},
|
|
{"size", lua::wrap<l_size>},
|
|
{"add", lua::wrap<l_add>},
|
|
{"move", lua::wrap<l_move>},
|
|
{"move_range", lua::wrap<l_move_range>},
|
|
{"find_by_item", lua::wrap<l_find_by_item>},
|
|
{"get_block", lua::wrap<l_get_block>},
|
|
{"bind_block", lua::wrap<l_bind_block>},
|
|
{"unbind_block", lua::wrap<l_unbind_block>},
|
|
{"get_data", lua::wrap<wrap_slot<l_get_data>>},
|
|
{"set_data", lua::wrap<wrap_slot<l_set_data>>},
|
|
{"get_all_data", lua::wrap<wrap_slot<l_get_all_data>>},
|
|
{"has_data", lua::wrap<wrap_slot<l_has_data>>},
|
|
{"create", lua::wrap<l_create>},
|
|
{"remove", lua::wrap<l_remove>},
|
|
{"clone", lua::wrap<l_clone>},
|
|
{NULL, NULL}
|
|
};
|