Files
ashlar/apps/openmw/mwlua/contentbindings.cpp
T

566 lines
26 KiB
C++

#include "contentbindings.hpp"
#include <components/esm3/loadacti.hpp>
#include <components/esm3/loadalch.hpp>
#include <components/esm3/loadappa.hpp>
#include <components/esm3/loadbook.hpp>
#include <components/esm3/loadclas.hpp>
#include <components/esm3/loaddoor.hpp>
#include <components/esm3/loadench.hpp>
#include <components/esm3/loadfact.hpp>
#include <components/esm3/loadingr.hpp>
#include <components/esm3/loadlevlist.hpp>
#include <components/esm3/loadligh.hpp>
#include <components/esm3/loadlock.hpp>
#include <components/esm3/loadmisc.hpp>
#include <components/esm3/loadprob.hpp>
#include <components/esm3/loadrace.hpp>
#include <components/esm3/loadrepa.hpp>
#include <components/esm3/loadsoun.hpp>
#include <components/esm3/loadspel.hpp>
#include <components/esm3/loadstat.hpp>
#include <components/fallback/fallback.hpp>
#include <components/lua/util.hpp>
#include "classbindings.hpp"
#include "context.hpp"
#include "factionbindings.hpp"
#include "magictypebindings.hpp"
#include "racebindings.hpp"
#include "soundbindings.hpp"
#include "stats.hpp"
#include "types/modelproperty.hpp"
#include "types/types.hpp"
#include "weatherbindings.hpp"
#include "../mwbase/environment.hpp"
#include "../mwworld/esmstore.hpp"
#include "../mwworld/weather.hpp"
namespace
{
template <class T>
struct MutableStore
{
MWWorld::Store<T>& mStore;
};
template <>
struct MutableStore<MWWorld::Weather>
{
MWWorld::WeatherStore& mStore;
};
template <class T>
using TableToRecord = T (*)(const sol::table&);
ESM::RefId validateId(std::string_view value)
{
if (value.empty())
throw std::runtime_error("ID cannot be empty");
if (auto id = ESM::StringRefId::deserializeExisting(value))
return *id;
// Check if this ID would be interpreted as something other than a StringRefId
ESM::RefId id = ESM::RefId::deserializeText(value);
if (!id.empty())
throw std::runtime_error("Non-string ID not allowed");
return ESM::RefId::stringRefId(value);
}
}
namespace sol
{
template <class T>
struct is_automagical<MutableStore<T>> : std::false_type
{
};
template <class T>
struct is_automagical<MWLua::MutableRecord<T>> : std::false_type
{
};
}
namespace MWLua
{
namespace
{
template <class LuaType, class Record, class Mapper = LuaType (*)(const Record*, sol::this_state)>
void addESMVariantStore(
sol::state_view& lua, MWWorld::Store<Record>& store, std::string_view name, Mapper mapper, auto&& newIndex)
{
using Store = MutableStore<Record>;
sol::usertype<Store> storeT = lua.new_usertype<Store>(name);
storeT[sol::meta_function::length] = [](const Store& self) { return self.mStore.getSize(); };
storeT[sol::meta_function::index] = sol::overload(
[=](const Store& self, size_t index, sol::this_state state) -> LuaType {
if (index == 0 || index > self.mStore.getSize())
return mapper(nullptr, state);
const Record* rec = self.mStore.at(LuaUtil::fromLuaIndex(index));
return mapper(rec, state);
},
[=](const Store& self, std::string_view id, sol::this_state state) -> LuaType {
const Record* rec = self.mStore.search(ESM::RefId::deserializeText(id));
return mapper(rec, state);
});
storeT[sol::meta_function::new_index] = std::move(newIndex);
storeT[sol::meta_function::ipairs] = lua["ipairsForArray"].template get<sol::function>();
storeT[sol::meta_function::pairs] = [=](const Store& self) {
return sol::as_function(
[&, index = std::size_t(0)](
sol::this_state state) mutable -> std::pair<std::optional<ESM::RefId>, LuaType> {
if (index >= self.mStore.getSize())
return { {}, mapper(nullptr, state) };
const Record* rec = self.mStore.at(index++);
return { rec->mId, mapper(rec, state) };
});
};
}
sol::table initGameSettingBindings(sol::state_view& lua, MWWorld::Store<ESM::GameSetting>& store)
{
addESMVariantStore<sol::object>(
lua, store, "GameSettingsContentStore",
[](const ESM::GameSetting* gmst, sol::this_state state) -> sol::object {
if (gmst == nullptr)
return sol::nil;
if (gmst->mValue.getType() == ESM::VT_String)
return sol::make_object(state, gmst->mValue.getString());
else if (gmst->mValue.getType() == ESM::VT_None)
return sol::make_object(state, std::string_view{});
else if (gmst->mValue.getType() == ESM::VT_Int)
return sol::make_object(state, gmst->mValue.getInteger());
return sol::make_object(state, gmst->mValue.getFloat());
},
[](MutableStore<ESM::GameSetting>& self, std::string_view idString, const sol::object& obj) {
ESM::RefId id = validateId(idString);
if (obj == sol::nil)
{
self.mStore.eraseStatic(id);
return;
}
bool preferFloat = false;
ESM::GameSetting gmst;
if (auto* found = self.mStore.search(id))
{
gmst = *found;
preferFloat = gmst.mValue.getType() == ESM::VT_Float;
}
else
{
gmst.blank();
gmst.mId = id;
preferFloat = id.startsWith("f");
}
if (obj.is<std::string_view>())
{
gmst.mValue.setType(ESM::VT_String);
gmst.mValue.setString(obj.as<std::string>());
}
else
{
const double value = LuaUtil::cast<double>(obj);
const int32_t intV = static_cast<int32_t>(value);
const float floatV = static_cast<float>(value);
if (intV == value && (!preferFloat || floatV != value))
{
gmst.mValue.setType(ESM::VT_Int);
gmst.mValue.setInteger(intV);
}
else
{
gmst.mValue.setType(ESM::VT_Float);
gmst.mValue.setFloat(floatV);
}
}
self.mStore.insertStatic(gmst);
});
sol::table api(lua, sol::create);
api["records"] = MutableStore<ESM::GameSetting>{ store };
api["getFallbacks"] = [](sol::this_state state) {
sol::table out(state, sol::create);
for (auto& [key, value] : Fallback::Map::getIntFallbackMap())
out[key] = sol::make_object(state, value);
for (auto& [key, value] : Fallback::Map::getFloatFallbackMap())
out[key] = sol::make_object(state, value);
for (auto& [key, value] : Fallback::Map::getNonNumericFallbackMap())
out[key] = sol::make_object(state, value);
return out;
};
return LuaUtil::makeReadOnly(api);
}
sol::table initGlobalVariableBindings(sol::state_view& lua, MWWorld::Store<ESM::Global>& store)
{
addESMVariantStore<std::optional<float>>(
lua, store, "GlobalsContentStore",
[](const ESM::Global* global, sol::this_state) -> std::optional<float> {
if (global == nullptr)
return {};
return global->mValue.getFloat();
},
[](MutableStore<ESM::Global>& self, std::string_view idString, const sol::object& obj) {
ESM::RefId id = validateId(idString);
if (obj == sol::nil)
{
self.mStore.eraseStatic(id);
return;
}
float value = LuaUtil::cast<float>(obj);
bool preferFloat = false;
ESM::Global global;
if (auto* found = self.mStore.search(id))
{
global = *found;
preferFloat = global.mValue.getType() == ESM::VT_Float;
}
else
{
global.blank();
global.mId = id;
}
int32_t intV = static_cast<int32_t>(value);
if (intV == value && !preferFloat)
{
global.mValue.setType(ESM::VT_Long);
global.mValue.setInteger(intV);
}
else
{
global.mValue.setType(ESM::VT_Float);
global.mValue.setFloat(value);
}
self.mStore.insertStatic(global);
});
sol::table api(lua, sol::create);
api["records"] = MutableStore<ESM::Global>{ store };
return LuaUtil::makeReadOnly(api);
}
template <class T>
void addRecordStoreBindings(sol::state_view& lua, TableToRecord<T> parseRecord)
{
using Store = MutableStore<T>;
sol::usertype<Store> storeT = lua.new_usertype<Store>(std::string(T::getRecordType()) + "sContentStore");
storeT[sol::meta_function::length] = [](const Store& self) { return self.mStore.getSize(); };
storeT[sol::meta_function::ipairs] = lua["ipairsForArray"].template get<sol::function>();
storeT[sol::meta_function::pairs] = lua["ipairsForArray"].template get<sol::function>();
storeT[sol::meta_function::index] = sol::overload(
[](const Store& self, size_t index) -> std::optional<MutableRecord<T>> {
if (index == 0 || index > self.mStore.getSize())
return {};
return MutableRecord<T>{ self.mStore, self.mStore.at(LuaUtil::fromLuaIndex(index))->mId };
},
[](const Store& self, std::string_view id) -> std::optional<MutableRecord<T>> {
const auto* record = self.mStore.search(ESM::RefId::deserializeText(id));
if (record == nullptr)
return {};
return MutableRecord<T>{ self.mStore, record->mId };
});
storeT[sol::meta_function::new_index] = sol::overload(
[](Store& self, std::string_view idString, const MutableRecord<T>& otherRecord) {
ESM::RefId id = validateId(idString);
T record = otherRecord.find();
record.mId = id;
self.mStore.insertStatic(record);
},
[parseRecord](Store& self, std::string_view idString, sol::lua_table table) {
ESM::RefId id = validateId(idString);
T record = parseRecord(table);
record.mId = id;
self.mStore.insertStatic(record);
},
[](Store& self, std::string_view idString, const sol::nil_t&) {
self.mStore.eraseStatic(validateId(idString));
});
}
sol::table initActivatorBindings(sol::state_view& lua, MWWorld::Store<ESM::Activator>& store)
{
addRecordStoreBindings<ESM::Activator>(lua, &MWLua::tableToActivator);
addMutableActivatorType(lua);
sol::table api(lua, sol::create);
api["records"] = MutableStore<ESM::Activator>{ store };
return LuaUtil::makeReadOnly(api);
}
sol::table initApparatusBindings(sol::state_view& lua, MWWorld::Store<ESM::Apparatus>& store)
{
addRecordStoreBindings<ESM::Apparatus>(lua, &MWLua::tableToApparatus);
addMutableApparatusType(lua);
sol::table api(lua, sol::create);
api["records"] = MutableStore<ESM::Apparatus>{ store };
api["TYPE"] = makeApparatusTypeTable(lua);
return LuaUtil::makeReadOnly(api);
}
sol::table initAttributeBindings(sol::state_view& lua, MWWorld::Store<ESM::Attribute>& store)
{
addRecordStoreBindings<ESM::Attribute>(lua, &MWLua::tableToAttribute);
addMutableAttributeType(lua);
sol::table api(lua, sol::create);
api["records"] = MutableStore<ESM::Attribute>{ store };
return LuaUtil::makeReadOnly(api);
}
sol::table initBookBindings(sol::state_view& lua, MWWorld::Store<ESM::Book>& store)
{
addRecordStoreBindings<ESM::Book>(lua, &MWLua::tableToBook);
addMutableBookType(lua);
sol::table api(lua, sol::create);
api["records"] = MutableStore<ESM::Book>{ store };
return LuaUtil::makeReadOnly(api);
}
sol::table initClassBindings(sol::state_view& lua, MWWorld::Store<ESM::Class>& store)
{
addRecordStoreBindings<ESM::Class>(lua, &MWLua::tableToClass);
addMutableClassType(lua);
sol::table api(lua, sol::create);
api["records"] = MutableStore<ESM::Class>{ store };
return LuaUtil::makeReadOnly(api);
}
sol::table initDoorBindings(sol::state_view& lua, MWWorld::Store<ESM::Door>& store)
{
addRecordStoreBindings<ESM::Door>(lua, &MWLua::tableToDoor);
addMutableDoorType(lua);
sol::table api(lua, sol::create);
api["records"] = MutableStore<ESM::Door>{ store };
return LuaUtil::makeReadOnly(api);
}
sol::table initEnchantmentBindings(sol::state_view& lua, MWWorld::Store<ESM::Enchantment>& store)
{
addRecordStoreBindings<ESM::Enchantment>(lua, &MWLua::tableToEnchantment);
addMutableEnchantmentType(lua);
sol::table api(lua, sol::create);
api["records"] = MutableStore<ESM::Enchantment>{ store };
api["TYPE"]
= LuaUtil::makeStrictReadOnly(LuaUtil::tableFromPairs<std::string_view, ESM::Enchantment::Type>(lua,
{
{ "CastOnce", ESM::Enchantment::Type::CastOnce },
{ "CastOnStrike", ESM::Enchantment::Type::WhenStrikes },
{ "CastOnUse", ESM::Enchantment::Type::WhenUsed },
{ "ConstantEffect", ESM::Enchantment::Type::ConstantEffect },
}));
return LuaUtil::makeReadOnly(api);
}
sol::table initFactionBindings(sol::state_view& lua, MWWorld::Store<ESM::Faction>& store)
{
addRecordStoreBindings<ESM::Faction>(lua, &MWLua::tableToFaction);
addMutableFactionType(lua);
sol::table api(lua, sol::create);
api["records"] = MutableStore<ESM::Faction>{ store };
return LuaUtil::makeReadOnly(api);
}
sol::table initIngredientBindings(sol::state_view& lua, MWWorld::Store<ESM::Ingredient>& store)
{
addRecordStoreBindings<ESM::Ingredient>(lua, &MWLua::tableToIngredient);
addMutableIngredientType(lua);
sol::table api(lua, sol::create);
api["records"] = MutableStore<ESM::Ingredient>{ store };
return LuaUtil::makeReadOnly(api);
}
sol::table initLevCreatureBindings(sol::state_view& lua, MWWorld::Store<ESM::CreatureLevList>& store)
{
addRecordStoreBindings<ESM::CreatureLevList>(lua, &MWLua::tableToCreatureLevList);
addMutableCreatureLevListType(lua);
sol::table api(lua, sol::create);
api["records"] = MutableStore<ESM::CreatureLevList>{ store };
return LuaUtil::makeReadOnly(api);
}
sol::table initLevItemBindings(sol::state_view& lua, MWWorld::Store<ESM::ItemLevList>& store)
{
addRecordStoreBindings<ESM::ItemLevList>(lua, &MWLua::tableToItemLevList);
addMutableItemLevListType(lua);
sol::table api(lua, sol::create);
api["records"] = MutableStore<ESM::ItemLevList>{ store };
return LuaUtil::makeReadOnly(api);
}
sol::table initLightBindings(sol::state_view& lua, MWWorld::Store<ESM::Light>& store)
{
addRecordStoreBindings<ESM::Light>(lua, &MWLua::tableToLight);
addMutableLightType(lua);
sol::table api(lua, sol::create);
api["records"] = MutableStore<ESM::Light>{ store };
return LuaUtil::makeReadOnly(api);
}
sol::table initLockpickBindings(sol::state_view& lua, MWWorld::Store<ESM::Lockpick>& store)
{
addRecordStoreBindings<ESM::Lockpick>(lua, &MWLua::tableToLockpick);
addMutableLockpickType(lua);
sol::table api(lua, sol::create);
api["records"] = MutableStore<ESM::Lockpick>{ store };
return LuaUtil::makeReadOnly(api);
}
sol::table initMagicEffectBindings(sol::state_view& lua, MWWorld::Store<ESM::MagicEffect>& store)
{
addRecordStoreBindings<ESM::MagicEffect>(lua, &MWLua::tableToMagicEffect);
addMutableMagicEffectType(lua);
sol::table api(lua, sol::create);
api["records"] = MutableStore<ESM::MagicEffect>{ store };
// We can't get rid of the GMST table engine side because mwscript needs it, so intead of copying it into a
// Lua file we've got this hidden function to generate it
api["_getGMSTs"] = [](sol::this_state state) {
sol::table gmsts(state, sol::create);
for (int i = 0; i < ESM::MagicEffect::Length; ++i)
{
const ESM::RefId effect = ESM::MagicEffect::indexToRefId(i);
const std::string_view gmst = ESM::MagicEffect::refIdToGmstString(effect);
gmsts[effect] = gmst;
}
return gmsts;
};
return LuaUtil::makeReadOnly(api);
}
sol::table initMiscBindings(sol::state_view& lua, MWWorld::Store<ESM::Miscellaneous>& store)
{
addRecordStoreBindings<ESM::Miscellaneous>(lua, &MWLua::tableToMisc);
addMutableMiscType(lua);
sol::table api(lua, sol::create);
api["records"] = MutableStore<ESM::Miscellaneous>{ store };
return LuaUtil::makeReadOnly(api);
}
sol::table initPotionBindings(sol::state_view& lua, MWWorld::Store<ESM::Potion>& store)
{
addRecordStoreBindings<ESM::Potion>(lua, &MWLua::tableToPotion);
addMutablePotionType(lua);
sol::table api(lua, sol::create);
api["records"] = MutableStore<ESM::Potion>{ store };
return LuaUtil::makeReadOnly(api);
}
sol::table initProbeBindings(sol::state_view& lua, MWWorld::Store<ESM::Probe>& store)
{
addRecordStoreBindings<ESM::Probe>(lua, &MWLua::tableToProbe);
addMutableProbeType(lua);
sol::table api(lua, sol::create);
api["records"] = MutableStore<ESM::Probe>{ store };
return LuaUtil::makeReadOnly(api);
}
sol::table initRaceBindings(sol::state_view& lua, MWWorld::Store<ESM::Race>& store)
{
addRecordStoreBindings<ESM::Race>(lua, &MWLua::tableToRace);
addMutableRaceType(lua);
sol::table api(lua, sol::create);
api["records"] = MutableStore<ESM::Race>{ store };
return LuaUtil::makeReadOnly(api);
}
sol::table initRepairBindings(sol::state_view& lua, MWWorld::Store<ESM::Repair>& store)
{
addRecordStoreBindings<ESM::Repair>(lua, &MWLua::tableToRepair);
addMutableRepairType(lua);
sol::table api(lua, sol::create);
api["records"] = MutableStore<ESM::Repair>{ store };
return LuaUtil::makeReadOnly(api);
}
sol::table initSkillBindings(sol::state_view& lua, MWWorld::Store<ESM::Skill>& store)
{
addRecordStoreBindings<ESM::Skill>(lua, &MWLua::tableToSkill);
addMutableSkillType(lua);
sol::table api(lua, sol::create);
api["records"] = MutableStore<ESM::Skill>{ store };
return LuaUtil::makeReadOnly(api);
}
sol::table initSpellBindings(sol::state_view& lua, MWWorld::Store<ESM::Spell>& store)
{
addRecordStoreBindings<ESM::Spell>(lua, &MWLua::tableToSpell);
addMutableSpellType(lua);
sol::table api(lua, sol::create);
api["records"] = MutableStore<ESM::Spell>{ store };
api["TYPE"]
= LuaUtil::makeStrictReadOnly(LuaUtil::tableFromPairs<std::string_view, ESM::Spell::SpellType>(lua,
{
{ "Spell", ESM::Spell::ST_Spell },
{ "Ability", ESM::Spell::ST_Ability },
{ "Blight", ESM::Spell::ST_Blight },
{ "Disease", ESM::Spell::ST_Disease },
{ "Curse", ESM::Spell::ST_Curse },
{ "Power", ESM::Spell::ST_Power },
}));
return LuaUtil::makeReadOnly(api);
}
sol::table initStaticBindings(sol::state_view& lua, MWWorld::Store<ESM::Static>& store)
{
addRecordStoreBindings<ESM::Static>(lua, &MWLua::tableToStatic);
addMutableStaticType(lua);
sol::table api(lua, sol::create);
api["records"] = MutableStore<ESM::Static>{ store };
return LuaUtil::makeReadOnly(api);
}
sol::table initSoundBindings(sol::state_view& lua, MWWorld::Store<ESM::Sound>& store)
{
addRecordStoreBindings<ESM::Sound>(lua, &MWLua::tableToSound);
addMutableSoundType(lua);
sol::table api(lua, sol::create);
api["records"] = MutableStore<ESM::Sound>{ store };
return LuaUtil::makeReadOnly(api);
}
sol::table initWeatherBindings(sol::state_view& lua, MWWorld::WeatherStore& store)
{
addRecordStoreBindings<MWWorld::Weather>(lua, &MWLua::tableToWeather);
addMutableWeatherType(lua);
sol::table api(lua, sol::create);
api["records"] = MutableStore<MWWorld::Weather>{ store };
return LuaUtil::makeReadOnly(api);
}
}
sol::table initContentPackage(const Context& context)
{
auto lua = context.sol();
sol::table api(lua, sol::create);
MWWorld::ESMStore& esmStore = *MWBase::Environment::get().getESMStore();
api["activators"] = initActivatorBindings(lua, esmStore.getWritable<ESM::Activator>());
api["apparatuses"] = initApparatusBindings(lua, esmStore.getWritable<ESM::Apparatus>());
api["attributes"] = initAttributeBindings(lua, esmStore.getWritable<ESM::Attribute>());
api["books"] = initBookBindings(lua, esmStore.getWritable<ESM::Book>());
api["classes"] = initClassBindings(lua, esmStore.getWritable<ESM::Class>());
api["doors"] = initDoorBindings(lua, esmStore.getWritable<ESM::Door>());
api["enchantments"] = initEnchantmentBindings(lua, esmStore.getWritable<ESM::Enchantment>());
api["factions"] = initFactionBindings(lua, esmStore.getWritable<ESM::Faction>());
api["gameSettings"] = initGameSettingBindings(lua, esmStore.getWritable<ESM::GameSetting>());
api["globals"] = initGlobalVariableBindings(lua, esmStore.getWritable<ESM::Global>());
api["ingredients"] = initIngredientBindings(lua, esmStore.getWritable<ESM::Ingredient>());
api["levelledCreatures"] = initLevCreatureBindings(lua, esmStore.getWritable<ESM::CreatureLevList>());
api["levelledItems"] = initLevItemBindings(lua, esmStore.getWritable<ESM::ItemLevList>());
api["lights"] = initLightBindings(lua, esmStore.getWritable<ESM::Light>());
api["lockpicks"] = initLockpickBindings(lua, esmStore.getWritable<ESM::Lockpick>());
api["magicEffects"] = initMagicEffectBindings(lua, esmStore.getWritable<ESM::MagicEffect>());
api["miscs"] = initMiscBindings(lua, esmStore.getWritable<ESM::Miscellaneous>());
api["potions"] = initPotionBindings(lua, esmStore.getWritable<ESM::Potion>());
api["probes"] = initProbeBindings(lua, esmStore.getWritable<ESM::Probe>());
api["races"] = initRaceBindings(lua, esmStore.getWritable<ESM::Race>());
api["repairs"] = initRepairBindings(lua, esmStore.getWritable<ESM::Repair>());
api["skills"] = initSkillBindings(lua, esmStore.getWritable<ESM::Skill>());
api["spells"] = initSpellBindings(lua, esmStore.getWritable<ESM::Spell>());
api["statics"] = initStaticBindings(lua, esmStore.getWritable<ESM::Static>());
api["sounds"] = initSoundBindings(lua, esmStore.getWritable<ESM::Sound>());
api["weathers"] = initWeatherBindings(lua, MWBase::Environment::get().getWorld()->getAllWeather());
api["RANGE"] = LuaUtil::makeStrictReadOnly(LuaUtil::tableFromPairs<std::string_view, ESM::RangeType>(lua,
{
{ "Self", ESM::RT_Self },
{ "Touch", ESM::RT_Touch },
{ "Target", ESM::RT_Target },
}));
return LuaUtil::makeReadOnly(api);
}
}