mirror/OpenMW
1
0
Fork 0
mirror of https://gitlab.com/OpenMW/openmw.git synced 2025-01-27 12:35:46 +00:00
Code Issues Projects Releases Wiki Activity
OpenMW/apps/openmw/mwworld/esmstore.cpp

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

824 lines
30 KiB
C++
Raw Normal View History

move ESMStore to MWWorld
2012-10-01 19:17:04 +04:00
#include "esmstore.hpp"
Use stable sort+unique to collect RefIDs for ESMStore records counting The idea is to avoid std::map lookup for each CellRef. Instead generate a sequence of added and removed RefNums into a vector then order them by RefNum using a stable sort that preserves relative order of elements with the same RefNum. RefIDs are stored in a different vector to avoid std::string move ctor calls when swapping elements while sorting. Reversed iteration over added and removed RefNums for each unique RefNum is an equivalent to what map-based algorithm produces. The main benefit from sorting a vector is a data locality that means less cache misses for each access. Reduces ESMStore::countRecords perf cycles by 25%.
2021-04-06 23:59:58 +02:00
#include <algorithm>
Load LuaScriptsCfg from both *.omwscripts and *.omwaddon files.
2021-09-26 15:21:46 +02:00
#include <fstream>
gets rid of the macros, we use a tuple instead, with a mechanism to assign an index to each type. so the tuple is only defined in the cpp, but we can still have template functions in the header that can ge tthe index with the type
2022-09-03 11:08:23 +02:00
#include <tuple>
Main program now stores ESM data in memory
2010-05-17 17:35:42 +02:00
Use new logging system for game itself
2018-08-14 23:05:43 +04:00
#include <components/debug/debuglog.hpp>
move most of the files from esm to esm3, keep common code in esm; this is make space for a future with esm4 esm typo esm typo
2022-01-22 15:58:41 +01:00
#include <components/esm3/esmreader.hpp>
#include <components/esm3/esmwriter.hpp>
Load LuaScriptsCfg from both *.omwscripts and *.omwaddon files.
2021-09-26 15:21:46 +02:00
#include <components/loadinglistener/loadinglistener.hpp>
#include <components/lua/configuration.hpp>
Use stable sort+unique to collect RefIDs for ESMStore records counting The idea is to avoid std::map lookup for each CellRef. Instead generate a sequence of added and removed RefNums into a vector then order them by RefNum using a stable sort that preserves relative order of elements with the same RefNum. RefIDs are stored in a different vector to avoid std::string move ctor calls when swapping elements while sorting. Reversed iteration over added and removed RefNums for each unique RefNum is an equivalent to what map-based algorithm produces. The main benefit from sorting a vector is a data locality that means less cache misses for each access. Reduces ESMStore::countRecords perf cycles by 25%.
2021-04-06 23:59:58 +02:00
#include <components/misc/algorithm.hpp>
Limit the number of simultaneously open not actively used content files Use LRU cache for ESMReaders. When cache capacity is reached close least recently used ESMReader. Remember the file name if a reader was open. Once the reader requested again open the file if there is stored name for it. Put released ESMReader to the back of the free items list. Close ESMReader's from the front of the free items list. Cached item can be used only by one client at the same time. If the same item is requested twice exception is thrown. This should never happen in practice. If this happens need to fix the client logic. It's allowed to go over the capacity limit when requesting different readers. Ideally this should never happen but there will be system error anyway signalizing about too many open files. Need to fix client logic in this case. All places that were using a vector of ESMReaders now using the cache. Cache is local for each use case and there is no need for a thread safety.
2022-06-01 22:53:18 +02:00
#include <components/esm3/readerscache.hpp>
Show groundcover loading progress
2022-06-03 18:59:08 +02:00
#include <components/esmloader/load.hpp>
Added records for ESM4s the throw std:: logic error ensures at compile time that there is no collision static_assert doesn't work because the function can be called at run time
2022-07-22 21:16:36 +02:00
#include <components/esm4/common.hpp>
Remove some unused code, include cleanup
2015-01-25 01:53:20 +01:00
Mutate base records when adding/removing spells
2020-07-28 08:33:28 +02:00
#include "../mwmechanics/spelllist.hpp"
implement additem/removeitem for non-unique actors
2020-07-26 11:07:18 +02:00
namespace
{
Use stable sort+unique to collect RefIDs for ESMStore records counting The idea is to avoid std::map lookup for each CellRef. Instead generate a sequence of added and removed RefNums into a vector then order them by RefNum using a stable sort that preserves relative order of elements with the same RefNum. RefIDs are stored in a different vector to avoid std::string move ctor calls when swapping elements while sorting. Reversed iteration over added and removed RefNums for each unique RefNum is an equivalent to what map-based algorithm produces. The main benefit from sorting a vector is a data locality that means less cache misses for each access. Reduces ESMStore::countRecords perf cycles by 25%.
2021-04-06 23:59:58 +02:00
struct Ref
{
ESM::RefNum mRefNum;
std::size_t mRefID;
Ref(ESM::RefNum refNum, std::size_t refID) : mRefNum(refNum), mRefID(refID) {}
};
constexpr std::size_t deletedRefID = std::numeric_limits<std::size_t>::max();
Limit the number of simultaneously open not actively used content files Use LRU cache for ESMReaders. When cache capacity is reached close least recently used ESMReader. Remember the file name if a reader was open. Once the reader requested again open the file if there is stored name for it. Put released ESMReader to the back of the free items list. Close ESMReader's from the front of the free items list. Cached item can be used only by one client at the same time. If the same item is requested twice exception is thrown. This should never happen in practice. If this happens need to fix the client logic. It's allowed to go over the capacity limit when requesting different readers. Ideally this should never happen but there will be system error anyway signalizing about too many open files. Need to fix client logic in this case. All places that were using a vector of ESMReaders now using the cache. Cache is local for each use case and there is no need for a thread safety.
2022-06-01 22:53:18 +02:00
void readRefs(const ESM::Cell& cell, std::vector<Ref>& refs, std::vector<std::string>& refIDs, ESM::ReadersCache& readers)
implement additem/removeitem for non-unique actors
2020-07-26 11:07:18 +02:00
{
restores countRecords optimisations (#3210) With this PR we restore @elsid 's optimisations of countRecords we have unintentionally discarded in PR #3197. In addition, we give it a more appropriate name and add comments concerning its peculiar background.
2021-11-02 13:46:41 +00:00
// TODO: we have many similar copies of this code.
implement additem/removeitem for non-unique actors
2020-07-26 11:07:18 +02:00
for (size_t i = 0; i < cell.mContextList.size(); i++)
{
Limit the number of simultaneously open not actively used content files Use LRU cache for ESMReaders. When cache capacity is reached close least recently used ESMReader. Remember the file name if a reader was open. Once the reader requested again open the file if there is stored name for it. Put released ESMReader to the back of the free items list. Close ESMReader's from the front of the free items list. Cached item can be used only by one client at the same time. If the same item is requested twice exception is thrown. This should never happen in practice. If this happens need to fix the client logic. It's allowed to go over the capacity limit when requesting different readers. Ideally this should never happen but there will be system error anyway signalizing about too many open files. Need to fix client logic in this case. All places that were using a vector of ESMReaders now using the cache. Cache is local for each use case and there is no need for a thread safety.
2022-06-01 22:53:18 +02:00
const std::size_t index = static_cast<std::size_t>(cell.mContextList[i].index);
const ESM::ReadersCache::BusyItem reader = readers.get(index);
cell.restore(*reader, i);
implement additem/removeitem for non-unique actors
2020-07-26 11:07:18 +02:00
ESM::CellRef ref;
Initial support of generated RefNums with negative mContentFile.
2021-01-22 15:48:37 +01:00
ref.mRefNum.unset();
implement additem/removeitem for non-unique actors
2020-07-26 11:07:18 +02:00
bool deleted = false;
Limit the number of simultaneously open not actively used content files Use LRU cache for ESMReaders. When cache capacity is reached close least recently used ESMReader. Remember the file name if a reader was open. Once the reader requested again open the file if there is stored name for it. Put released ESMReader to the back of the free items list. Close ESMReader's from the front of the free items list. Cached item can be used only by one client at the same time. If the same item is requested twice exception is thrown. This should never happen in practice. If this happens need to fix the client logic. It's allowed to go over the capacity limit when requesting different readers. Ideally this should never happen but there will be system error anyway signalizing about too many open files. Need to fix client logic in this case. All places that were using a vector of ESMReaders now using the cache. Cache is local for each use case and there is no need for a thread safety.
2022-06-01 22:53:18 +02:00
while (cell.getNextRef(*reader, ref, deleted))
implement additem/removeitem for non-unique actors
2020-07-26 11:07:18 +02:00
{
if(deleted)
Use stable sort+unique to collect RefIDs for ESMStore records counting The idea is to avoid std::map lookup for each CellRef. Instead generate a sequence of added and removed RefNums into a vector then order them by RefNum using a stable sort that preserves relative order of elements with the same RefNum. RefIDs are stored in a different vector to avoid std::string move ctor calls when swapping elements while sorting. Reversed iteration over added and removed RefNums for each unique RefNum is an equivalent to what map-based algorithm produces. The main benefit from sorting a vector is a data locality that means less cache misses for each access. Reduces ESMStore::countRecords perf cycles by 25%.
2021-04-06 23:59:58 +02:00
refs.emplace_back(ref.mRefNum, deletedRefID);
implement additem/removeitem for non-unique actors
2020-07-26 11:07:18 +02:00
else if (std::find(cell.mMovedRefs.begin(), cell.mMovedRefs.end(), ref.mRefNum) == cell.mMovedRefs.end())
{
Use stable sort+unique to collect RefIDs for ESMStore records counting The idea is to avoid std::map lookup for each CellRef. Instead generate a sequence of added and removed RefNums into a vector then order them by RefNum using a stable sort that preserves relative order of elements with the same RefNum. RefIDs are stored in a different vector to avoid std::string move ctor calls when swapping elements while sorting. Reversed iteration over added and removed RefNums for each unique RefNum is an equivalent to what map-based algorithm produces. The main benefit from sorting a vector is a data locality that means less cache misses for each access. Reduces ESMStore::countRecords perf cycles by 25%.
2021-04-06 23:59:58 +02:00
refs.emplace_back(ref.mRefNum, refIDs.size());
refIDs.push_back(std::move(ref.mRefID));
implement additem/removeitem for non-unique actors
2020-07-26 11:07:18 +02:00
}
}
}
Use stable sort+unique to collect RefIDs for ESMStore records counting The idea is to avoid std::map lookup for each CellRef. Instead generate a sequence of added and removed RefNums into a vector then order them by RefNum using a stable sort that preserves relative order of elements with the same RefNum. RefIDs are stored in a different vector to avoid std::string move ctor calls when swapping elements while sorting. Reversed iteration over added and removed RefNums for each unique RefNum is an equivalent to what map-based algorithm produces. The main benefit from sorting a vector is a data locality that means less cache misses for each access. Reduces ESMStore::countRecords perf cycles by 25%.
2021-04-06 23:59:58 +02:00
for(const auto& [value, deleted] : cell.mLeasedRefs)
implement additem/removeitem for non-unique actors
2020-07-26 11:07:18 +02:00
{
if(deleted)
Use stable sort+unique to collect RefIDs for ESMStore records counting The idea is to avoid std::map lookup for each CellRef. Instead generate a sequence of added and removed RefNums into a vector then order them by RefNum using a stable sort that preserves relative order of elements with the same RefNum. RefIDs are stored in a different vector to avoid std::string move ctor calls when swapping elements while sorting. Reversed iteration over added and removed RefNums for each unique RefNum is an equivalent to what map-based algorithm produces. The main benefit from sorting a vector is a data locality that means less cache misses for each access. Reduces ESMStore::countRecords perf cycles by 25%.
2021-04-06 23:59:58 +02:00
refs.emplace_back(value.mRefNum, deletedRefID);
implement additem/removeitem for non-unique actors
2020-07-26 11:07:18 +02:00
else
{
Use stable sort+unique to collect RefIDs for ESMStore records counting The idea is to avoid std::map lookup for each CellRef. Instead generate a sequence of added and removed RefNums into a vector then order them by RefNum using a stable sort that preserves relative order of elements with the same RefNum. RefIDs are stored in a different vector to avoid std::string move ctor calls when swapping elements while sorting. Reversed iteration over added and removed RefNums for each unique RefNum is an equivalent to what map-based algorithm produces. The main benefit from sorting a vector is a data locality that means less cache misses for each access. Reduces ESMStore::countRecords perf cycles by 25%.
2021-04-06 23:59:58 +02:00
refs.emplace_back(value.mRefNum, refIDs.size());
refIDs.push_back(value.mRefID);
implement additem/removeitem for non-unique actors
2020-07-26 11:07:18 +02:00
}
}
}
Also run NPC validation for modified base records
2021-03-23 21:07:57 +01:00
Replace empty NPC class with fallback
2022-06-06 10:59:26 +02:00
const std::string& getDefaultClass(const MWWorld::Store<ESM::Class>& classes)
Also run NPC validation for modified base records
2021-03-23 21:07:57 +01:00
{
auto it = classes.begin();
if (it != classes.end())
Replace empty NPC class with fallback
2022-06-06 10:59:26 +02:00
return it->mId;
throw std::runtime_error("List of NPC classes is empty!");
}
std::vector<ESM::NPC> getNPCsToReplace(const MWWorld::Store<ESM::Faction>& factions, const MWWorld::Store<ESM::Class>& classes, const std::unordered_map<std::string, ESM::NPC, Misc::StringUtils::CiHash, Misc::StringUtils::CiEqual>& npcs)
{
// Cache first class from store - we will use it if current class is not found
const std::string& defaultCls = getDefaultClass(classes);
Also run NPC validation for modified base records
2021-03-23 21:07:57 +01:00
// Validate NPCs for non-existing class and faction.
// We will replace invalid entries by fixed ones
std::vector<ESM::NPC> npcsToReplace;
Use const references when possible in for loops No need for useless copies.
2021-05-15 19:50:01 +02:00
for (const auto& npcIter : npcs)
Also run NPC validation for modified base records
2021-03-23 21:07:57 +01:00
{
Clean up MSVC warnings
2021-04-17 10:53:47 +04:00
ESM::NPC npc = npcIter.second;
Also run NPC validation for modified base records
2021-03-23 21:07:57 +01:00
bool changed = false;
Replace empty NPC class with fallback
2022-06-06 10:59:26 +02:00
const std::string& npcFaction = npc.mFaction;
Also run NPC validation for modified base records
2021-03-23 21:07:57 +01:00
if (!npcFaction.empty())
{
const ESM::Faction *fact = factions.search(npcFaction);
if (!fact)
{
Log(Debug::Verbose) << "NPC '" << npc.mId << "' (" << npc.mName << ") has nonexistent faction '" << npc.mFaction << "', ignoring it.";
npc.mFaction.clear();
npc.mNpdt.mRank = 0;
changed = true;
}
}
Replace empty NPC class with fallback
2022-06-06 10:59:26 +02:00
const std::string& npcClass = npc.mClass;
const ESM::Class *cls = classes.search(npcClass);
if (!cls)
Also run NPC validation for modified base records
2021-03-23 21:07:57 +01:00
{
Replace empty NPC class with fallback
2022-06-06 10:59:26 +02:00
Log(Debug::Verbose) << "NPC '" << npc.mId << "' (" << npc.mName << ") has nonexistent class '" << npc.mClass << "', using '" << defaultCls << "' class as replacement.";
npc.mClass = defaultCls;
changed = true;
Also run NPC validation for modified base records
2021-03-23 21:07:57 +01:00
}
if (changed)
npcsToReplace.push_back(npc);
}
return npcsToReplace;
}
Improve save cleaning
2021-07-12 20:51:13 +02:00
// Custom enchanted items can reference scripts that no longer exist, this doesn't necessarily mean the base item no longer exists however.
// So instead of removing the item altogether, we're only removing the script.
refactors MWWorld::Store maps (#3197) With this PR we clean up `MWWorld::Store` maps according to the approach of PR #3184.
2021-10-30 17:27:57 +00:00
template<class MapT>
void removeMissingScripts(const MWWorld::Store<ESM::Script>& scripts, MapT& items)
Improve save cleaning
2021-07-12 20:51:13 +02:00
{
for(auto& [id, item] : items)
{
if(!item.mScript.empty() && !scripts.search(item.mScript))
{
item.mScript.clear();
Log(Debug::Verbose) << "Item '" << id << "' (" << item.mName << ") has nonexistent script '" << item.mScript << "', ignoring it.";
}
}
}
Very convincing experiment, by associatingg a compiletime index to the esm record, it becomes possible to automate the loop that creates them it will also be possible to associate AT COMPILETIME the RecNameInt to the esm type, which in the same manner will automatically populate mESM3RecordToStore
2022-07-23 16:41:42 +02:00
Linux compilation
2022-07-23 18:45:30 +02:00
implement additem/removeitem for non-unique actors
2020-07-26 11:07:18 +02:00
}
Very convincing experiment, by associatingg a compiletime index to the esm record, it becomes possible to automate the loop that creates them it will also be possible to associate AT COMPILETIME the RecNameInt to the esm type, which in the same manner will automatically populate mESM3RecordToStore
2022-07-23 16:41:42 +02:00
template <auto Start, auto End, auto Inc, class F>
constexpr void constexpr_for(F&& f)
{
if constexpr (Start < End)
{
f(std::integral_constant<decltype(Start), Start>());
constexpr_for<Start + Inc, End, Inc>(f);
}
}
Store refactor: Now way easier to create new stores, a good chunk of it is automated, only simple macros are used now The case of indexedStores remains an issue, because they can't be stored with the rest because they don't inherit of store base
2022-07-03 18:11:20 +02:00
move ESMStore to MWWorld
2012-10-01 19:17:04 +04:00
namespace MWWorld
Main program now stores ESM data in memory
2010-05-17 17:35:42 +02:00
{
mids and mStaticIds moved to mStoreImp renamed recordid to storeid
2022-07-20 19:28:06 +02:00
using IDMap = std::unordered_map<std::string, int, Misc::StringUtils::CiHash, Misc::StringUtils::CiEqual>;
ESMStore: no longer necessary to include the type definitions in the header For now there still needs to declare all the getters, but a macro may make that easier, or an different method entierly
2022-07-03 11:47:46 +02:00
struct ESMStoreImp
{
gets rid of the macros, we use a tuple instead, with a mechanism to assign an index to each type. so the tuple is only defined in the cpp, but we can still have template functions in the header that can ge tthe index with the type
2022-09-03 11:08:23 +02:00
std::tuple <
Store<ESM::Activator>,
Store<ESM::Potion>,
Store<ESM::Apparatus>,
Store<ESM::Armor>,
Store<ESM::BodyPart>,
Store<ESM::Book>,
Store<ESM::BirthSign>,
Store<ESM::Class>,
Store<ESM::Clothing>,
Store<ESM::Container>,
Store<ESM::Creature>,
Store<ESM::Dialogue>,
Store<ESM::Door>,
Store<ESM::Enchantment>,
Store<ESM::Faction>,
Store<ESM::Global>,
Store<ESM::Ingredient>,
Store<ESM::CreatureLevList>,
Store<ESM::ItemLevList>,
Store<ESM::Light>,
Store<ESM::Lockpick>,
Store<ESM::Miscellaneous>,
Store<ESM::NPC>,
Store<ESM::Probe>,
Store<ESM::Race>,
Store<ESM::Region>,
Store<ESM::Repair>,
Store<ESM::SoundGenerator>,
Store<ESM::Sound>,
Store<ESM::Spell>,
Store<ESM::StartScript>,
Store<ESM::Static>,
Store<ESM::Weapon>,
Store<ESM::GameSetting>,
Store<ESM::Script>,
// Lists that need special rules
Store<ESM::Cell>,
Store<ESM::Land>,
Store<ESM::LandTexture>,
Store<ESM::Pathgrid>,
Store<ESM::MagicEffect>,
Store<ESM::Skill>,
// Special entry which is hardcoded and not loaded from an ESM
Store<ESM::Attribute >> mStores;
Store refactor: Now way easier to create new stores, a good chunk of it is automated, only simple macros are used now The case of indexedStores remains an issue, because they can't be stored with the rest because they don't inherit of store base
2022-07-03 18:11:20 +02:00
rename StoreBase =>DynamicStore, and create new class Storebase all stores inherit from base class StoreBase.Storebase is just an empty interface class
2022-09-02 23:46:37 +02:00
std::map<ESM::RecNameInts, DynamicStore*> mRecNameToStore;
std::unordered_map<const DynamicStore*, ESM::RecNameInts> mStoreToRecName;
Store refactor: Now way easier to create new stores, a good chunk of it is automated, only simple macros are used now The case of indexedStores remains an issue, because they can't be stored with the rest because they don't inherit of store base
2022-07-03 18:11:20 +02:00
mids and mStaticIds moved to mStoreImp renamed recordid to storeid
2022-07-20 19:28:06 +02:00
// Lookup of all IDs. Makes looking up references faster. Just
// maps the id name to the record type.
IDMap mIds;
IDMap mStaticIds;
ESM Store: removed a lot of declarations that became useless the default implementation of the template<> get() threw a reuntime error, when it is a compile time issue now all the implementations are in the cpp file
2022-07-03 13:17:55 +02:00
template<typename T>
Fixed naming convention problems removed 2 macros. - One is replaced by the underlying code - The second one ise replaced by a template function removed tabulation used as indentation used getWritable instead of a const_cast used for( val : cont) loop removed useless getId function
2022-07-19 17:58:21 +02:00
static const T* esm3StoreInsert(ESMStore& stores, const T &toInsert)
ESM Store: removed a lot of declarations that became useless the default implementation of the template<> get() threw a reuntime error, when it is a compile time issue now all the implementations are in the cpp file
2022-07-03 13:17:55 +02:00
{
const std::string id = "$dynamic" + std::to_string(stores.mDynamicCount++);
Fixed naming convention problems removed 2 macros. - One is replaced by the underlying code - The second one ise replaced by a template function removed tabulation used as indentation used getWritable instead of a const_cast used for( val : cont) loop removed useless getId function
2022-07-19 17:58:21 +02:00
Store<T> &store = stores.getWritable<T>();
ESM Store: removed a lot of declarations that became useless the default implementation of the template<> get() threw a reuntime error, when it is a compile time issue now all the implementations are in the cpp file
2022-07-03 13:17:55 +02:00
if (store.search(id) != nullptr)
{
const std::string msg = "Try to override existing record '" + id + "'";
throw std::runtime_error(msg);
}
T record = toInsert;
record.mId = id;
T *ptr = store.insert(record);
Rename member to be clearer and more generic
2022-09-02 23:39:38 +02:00
auto esm3RecordType_find = stores.mStoreImp->mStoreToRecName.find(&stores.get<T>());
Store refactor: Now way easier to create new stores, a good chunk of it is automated, only simple macros are used now The case of indexedStores remains an issue, because they can't be stored with the rest because they don't inherit of store base
2022-07-03 18:11:20 +02:00
Rename member to be clearer and more generic
2022-09-02 23:39:38 +02:00
if (esm3RecordType_find != stores.mStoreImp->mStoreToRecName.end())
Store refactor: Now way easier to create new stores, a good chunk of it is automated, only simple macros are used now The case of indexedStores remains an issue, because they can't be stored with the rest because they don't inherit of store base
2022-07-03 18:11:20 +02:00
{
mids and mStaticIds moved to mStoreImp renamed recordid to storeid
2022-07-20 19:28:06 +02:00
stores.mStoreImp->mIds[ptr->mId] = esm3RecordType_find->second;
ESM Store: removed a lot of declarations that became useless the default implementation of the template<> get() threw a reuntime error, when it is a compile time issue now all the implementations are in the cpp file
2022-07-03 13:17:55 +02:00
}
return ptr;
}
ESM Store: no more automatic function implementation that suppose a mId member All the ESM3 store will continue to work the same, used a macro to quickly define the different functions
2022-07-03 13:46:12 +02:00
template <class T>
Fixed naming convention problems removed 2 macros. - One is replaced by the underlying code - The second one ise replaced by a template function removed tabulation used as indentation used getWritable instead of a const_cast used for( val : cont) loop removed useless getId function
2022-07-19 17:58:21 +02:00
static const T * esm3overrideRecord(ESMStore& stores, const T &x) {
Store<T> &store = stores.getWritable<T>();
ESM Store: no more automatic function implementation that suppose a mId member All the ESM3 store will continue to work the same, used a macro to quickly define the different functions
2022-07-03 13:46:12 +02:00
T *ptr = store.insert(x);
Rename member to be clearer and more generic
2022-09-02 23:39:38 +02:00
auto esm3RecordType_find = stores.mStoreImp->mStoreToRecName.find(&stores.get<T>());
if (esm3RecordType_find != stores.mStoreImp->mStoreToRecName.end())
Store refactor: Now way easier to create new stores, a good chunk of it is automated, only simple macros are used now The case of indexedStores remains an issue, because they can't be stored with the rest because they don't inherit of store base
2022-07-03 18:11:20 +02:00
{
mids and mStaticIds moved to mStoreImp renamed recordid to storeid
2022-07-20 19:28:06 +02:00
stores.mStoreImp->mIds[ptr->mId] = esm3RecordType_find->second;
ESM Store: no more automatic function implementation that suppose a mId member All the ESM3 store will continue to work the same, used a macro to quickly define the different functions
2022-07-03 13:46:12 +02:00
}
return ptr;
}
template <class T>
Fixed naming convention problems removed 2 macros. - One is replaced by the underlying code - The second one ise replaced by a template function removed tabulation used as indentation used getWritable instead of a const_cast used for( val : cont) loop removed useless getId function
2022-07-19 17:58:21 +02:00
static const T *esm3insertStatic(ESMStore& stores, const T &x)
ESM Store: no more automatic function implementation that suppose a mId member All the ESM3 store will continue to work the same, used a macro to quickly define the different functions
2022-07-03 13:46:12 +02:00
{
const std::string id = "$dynamic" + std::to_string(stores.mDynamicCount++);
Fixed naming convention problems removed 2 macros. - One is replaced by the underlying code - The second one ise replaced by a template function removed tabulation used as indentation used getWritable instead of a const_cast used for( val : cont) loop removed useless getId function
2022-07-19 17:58:21 +02:00
Store<T> &store = stores.getWritable<T>();
ESM Store: no more automatic function implementation that suppose a mId member All the ESM3 store will continue to work the same, used a macro to quickly define the different functions
2022-07-03 13:46:12 +02:00
if (store.search(id) != nullptr)
{
const std::string msg = "Try to override existing record '" + id + "'";
throw std::runtime_error(msg);
}
T record = x;
T *ptr = store.insertStatic(record);
Rename member to be clearer and more generic
2022-09-02 23:39:38 +02:00
auto esm3RecordType_find = stores.mStoreImp->mStoreToRecName.find(&stores.get<T>());
if (esm3RecordType_find != stores.mStoreImp->mStoreToRecName.end())
Store refactor: Now way easier to create new stores, a good chunk of it is automated, only simple macros are used now The case of indexedStores remains an issue, because they can't be stored with the rest because they don't inherit of store base
2022-07-03 18:11:20 +02:00
{
mids and mStaticIds moved to mStoreImp renamed recordid to storeid
2022-07-20 19:28:06 +02:00
stores.mStoreImp->mIds[ptr->mId] = esm3RecordType_find->second;
ESM Store: no more automatic function implementation that suppose a mId member All the ESM3 store will continue to work the same, used a macro to quickly define the different functions
2022-07-03 13:46:12 +02:00
}
return ptr;
}
Store refactor: Now way easier to create new stores, a good chunk of it is automated, only simple macros are used now The case of indexedStores remains an issue, because they can't be stored with the rest because they don't inherit of store base
2022-07-03 18:11:20 +02:00
gets rid of the macros, we use a tuple instead, with a mechanism to assign an index to each type. so the tuple is only defined in the cpp, but we can still have template functions in the header that can ge tthe index with the type
2022-09-03 11:08:23 +02:00
template<typename T>
static int AssignStoreToIndex(ESMStore& stores, Store<T>& store)
Store refactor: Now way easier to create new stores, a good chunk of it is automated, only simple macros are used now The case of indexedStores remains an issue, because they can't be stored with the rest because they don't inherit of store base
2022-07-03 18:11:20 +02:00
{
gets rid of the macros, we use a tuple instead, with a mechanism to assign an index to each type. so the tuple is only defined in the cpp, but we can still have template functions in the header that can ge tthe index with the type
2022-09-03 11:08:23 +02:00
const int storeIndex = ESMStore::getTypeIndex<T>();
assert(ESMStore::getTypeIndex<T>() == storeIndex);
oups
2022-09-03 12:09:12 +02:00
const std::size_t index_t(storeIndex);
linux compile
2022-09-03 11:47:38 +02:00
if (stores.mStores.size() <= index_t)
stores.mStores.resize(index_t + 1);
Fixed naming convention problems removed 2 macros. - One is replaced by the underlying code - The second one ise replaced by a template function removed tabulation used as indentation used getWritable instead of a const_cast used for( val : cont) loop removed useless getId function
2022-07-19 17:58:21 +02:00
gets rid of the macros, we use a tuple instead, with a mechanism to assign an index to each type. so the tuple is only defined in the cpp, but we can still have template functions in the header that can ge tthe index with the type
2022-09-03 11:08:23 +02:00
assert(&store == &std::get<Store<T>>(stores.mStoreImp->mStores));
stores.mStores[storeIndex] = &store;
rename StoreBase =>DynamicStore, and create new class Storebase all stores inherit from base class StoreBase.Storebase is just an empty interface class
2022-09-02 23:46:37 +02:00
if constexpr (std::is_convertible<Store<T>*, DynamicStore*>::value)
Very convincing experiment, by associatingg a compiletime index to the esm record, it becomes possible to automate the loop that creates them it will also be possible to associate AT COMPILETIME the RecNameInt to the esm type, which in the same manner will automatically populate mESM3RecordToStore
2022-07-23 16:41:42 +02:00
{
gets rid of the macros, we use a tuple instead, with a mechanism to assign an index to each type. so the tuple is only defined in the cpp, but we can still have template functions in the header that can ge tthe index with the type
2022-09-03 11:08:23 +02:00
stores.mDynamicStores.push_back(&store);
removes recname type, we use what is already included in ESM types
2022-09-02 23:36:41 +02:00
constexpr ESM::RecNameInts recName = T::sRecordId;
Binds at compile time esm struct and RecNameInts to automatically populate mESM3RecordToStore fewer possible mistakes now, one macro takes all the information to create all the stores and maps from RecName to Store
2022-07-24 12:37:27 +02:00
if constexpr (recName != ESM::REC_INTERNAL_PLAYER)
{
gets rid of the macros, we use a tuple instead, with a mechanism to assign an index to each type. so the tuple is only defined in the cpp, but we can still have template functions in the header that can ge tthe index with the type
2022-09-03 11:08:23 +02:00
stores.mStoreImp->mRecNameToStore[recName] = &store;
Binds at compile time esm struct and RecNameInts to automatically populate mESM3RecordToStore fewer possible mistakes now, one macro takes all the information to create all the stores and maps from RecName to Store
2022-07-24 12:37:27 +02:00
}
}
gets rid of the macros, we use a tuple instead, with a mechanism to assign an index to each type. so the tuple is only defined in the cpp, but we can still have template functions in the header that can ge tthe index with the type
2022-09-03 11:08:23 +02:00
return 0;
}
ESMStoreImp(ESMStore& store)
{
Binds at compile time esm struct and RecNameInts to automatically populate mESM3RecordToStore fewer possible mistakes now, one macro takes all the information to create all the stores and maps from RecName to Store
2022-07-24 12:37:27 +02:00
}
void SetupAfterStoresCreation(ESMStore& store)
{
Rename member to be clearer and more generic
2022-09-02 23:39:38 +02:00
for (const auto& recordStorePair : mRecNameToStore)
Binds at compile time esm struct and RecNameInts to automatically populate mESM3RecordToStore fewer possible mistakes now, one macro takes all the information to create all the stores and maps from RecName to Store
2022-07-24 12:37:27 +02:00
{
rename StoreBase =>DynamicStore, and create new class Storebase all stores inherit from base class StoreBase.Storebase is just an empty interface class
2022-09-02 23:46:37 +02:00
const DynamicStore* storePtr = recordStorePair.second;
Rename member to be clearer and more generic
2022-09-02 23:39:38 +02:00
mStoreToRecName[storePtr] = recordStorePair.first;
Very convincing experiment, by associatingg a compiletime index to the esm record, it becomes possible to automate the loop that creates them it will also be possible to associate AT COMPILETIME the RecNameInt to the esm type, which in the same manner will automatically populate mESM3RecordToStore
2022-07-23 16:41:42 +02:00
}
Store refactor: Now way easier to create new stores, a good chunk of it is automated, only simple macros are used now The case of indexedStores remains an issue, because they can't be stored with the rest because they don't inherit of store base
2022-07-03 18:11:20 +02:00
}
ESMStore: no longer necessary to include the type definitions in the header For now there still needs to declare all the getters, but a macro may make that easier, or an different method entierly
2022-07-03 11:47:46 +02:00
};
Store refactor: Now way easier to create new stores, a good chunk of it is automated, only simple macros are used now The case of indexedStores remains an issue, because they can't be stored with the rest because they don't inherit of store base
2022-07-03 18:11:20 +02:00
mids and mStaticIds moved to mStoreImp renamed recordid to storeid
2022-07-20 19:28:06 +02:00
int ESMStore::find(const std::string& id) const
{
IDMap::const_iterator it = mStoreImp->mIds.find(id);
if (it == mStoreImp->mIds.end()) {
return 0;
}
return it->second;
}
int ESMStore::findStatic(const std::string& id) const
{
IDMap::const_iterator it = mStoreImp-> mStaticIds.find(id);
if (it == mStoreImp->mStaticIds.end()) {
return 0;
}
return it->second;
}
ESMStore: no longer necessary to include the type definitions in the header For now there still needs to declare all the getters, but a macro may make that easier, or an different method entierly
2022-07-03 11:47:46 +02:00
ESMStore::ESMStore()
{
Binds at compile time esm struct and RecNameInts to automatically populate mESM3RecordToStore fewer possible mistakes now, one macro takes all the information to create all the stores and maps from RecName to Store
2022-07-24 12:37:27 +02:00
mStoreImp = std::make_unique<ESMStoreImp>(*this);
gets rid of the macros, we use a tuple instead, with a mechanism to assign an index to each type. so the tuple is only defined in the cpp, but we can still have template functions in the header that can ge tthe index with the type
2022-09-03 11:08:23 +02:00
std::apply([this](auto& ...x){std::make_tuple(ESMStoreImp::AssignStoreToIndex(*this, x)...);} , mStoreImp->mStores);
ESMStore: no longer necessary to include the type definitions in the header For now there still needs to declare all the getters, but a macro may make that easier, or an different method entierly
2022-07-03 11:47:46 +02:00
mDynamicCount = 0;
Binds at compile time esm struct and RecNameInts to automatically populate mESM3RecordToStore fewer possible mistakes now, one macro takes all the information to create all the stores and maps from RecName to Store
2022-07-24 12:37:27 +02:00
mStoreImp->SetupAfterStoresCreation(*this);
Store refactor: Now way easier to create new stores, a good chunk of it is automated, only simple macros are used now The case of indexedStores remains an issue, because they can't be stored with the rest because they don't inherit of store base
2022-07-03 18:11:20 +02:00
getWritable<ESM::Pathgrid>().setCells(getWritable<ESM::Cell>());
ESMStore: no longer necessary to include the type definitions in the header For now there still needs to declare all the getters, but a macro may make that easier, or an different method entierly
2022-07-03 11:47:46 +02:00
}
ESMStore::~ESMStore()
{
}
Store: moved all the template specialization to its own heaper file, included where it's needed in the esm store a function is defined in the cpp file to not rely on the knowledge of store.hpp in the header file
2022-07-03 14:40:37 +02:00
void ESMStore::clearDynamic()
{
gets rid of the macros, we use a tuple instead, with a mechanism to assign an index to each type. so the tuple is only defined in the cpp, but we can still have template functions in the header that can ge tthe index with the type
2022-09-03 11:08:23 +02:00
for (const auto& store : mDynamicStores)
Fixed naming convention problems removed 2 macros. - One is replaced by the underlying code - The second one ise replaced by a template function removed tabulation used as indentation used getWritable instead of a const_cast used for( val : cont) loop removed useless getId function
2022-07-19 17:58:21 +02:00
store->clearDynamic();
Store: moved all the template specialization to its own heaper file, included where it's needed in the esm store a function is defined in the cpp file to not rely on the knowledge of store.hpp in the header file
2022-07-03 14:40:37 +02:00
movePlayerRecord();
}
just replace esmstore, inconsistent
2012-11-05 18:09:14 +04:00
static bool isCacheableRecord(int id)
{
if (id == ESM::REC_ACTI || id == ESM::REC_ALCH || id == ESM::REC_APPA || id == ESM::REC_ARMO ||
id == ESM::REC_BOOK || id == ESM::REC_CLOT || id == ESM::REC_CONT || id == ESM::REC_CREA ||
id == ESM::REC_DOOR || id == ESM::REC_INGR || id == ESM::REC_LEVC || id == ESM::REC_LEVI ||
id == ESM::REC_LIGH || id == ESM::REC_LOCK || id == ESM::REC_MISC || id == ESM::REC_NPC_ ||
Add support for placing BodyParts in a cell (Bug #3118)
2016-01-02 00:49:53 +01:00
id == ESM::REC_PROB || id == ESM::REC_REPA || id == ESM::REC_STAT || id == ESM::REC_WEAP ||
id == ESM::REC_BODY)
just replace esmstore, inconsistent
2012-11-05 18:09:14 +04:00
{
return true;
}
return false;
}
Implement ignored records
2022-04-16 16:28:39 +02:00
void ESMStore::load(ESM::ESMReader &esm, Loading::Listener* listener, ESM::Dialogue*& dialogue)
Main program now stores ESM data in memory
2010-05-17 17:35:42 +02:00
{
Show groundcover loading progress
2022-06-03 18:59:08 +02:00
if (listener != nullptr)
listener->setProgressRange(::EsmLoader::fileProgress);
Refactored loading screen - Add loading progress for data files, global map, terrain - Refactored and improved cell loading progress
2013-08-27 15:48:13 +02:00
Do not assert() for invalid land data in plugins (Bug #3037) The resizing of LTEX store to the correct number of plugins was done in the load() method, but the load method won't be called if a plugin contains LAND records but doesn't contain LTEX records. For such plugins the Store<ESM::LandTexture>::search() function would then fail an assertion.
2015-11-27 21:40:36 +01:00
// Land texture loading needs to use a separate internal store for each plugin.
refactors parentFileIndices (#3211) This PR aims to start addressing `ESM` design issues that have silenced errors we incorporated into groundcover `ESM` loading approaches. - We move the resolution of `parentFileIndices` from `ESMStore` to `ESMReader` as suggested in a `TODO` comment. - We improve a highly misleading comment which downplayed the significance of `parentFileIndices`. - We document important preconditions. - We move a user facing error message to the highest level and improve its context. - We remove an inappropriate `setGlobalReaderList` method. We now pass this reader list into the method that requires it. - We remove a thoroughly pointless optimisation of `Store<ESM::LandTexture>`'s construction that has unnecessarily depended on `getGlobalReaderList`. There should be no functional changes for `master`, but this PR should remove an issue blocking PR #3208.
2021-11-03 08:02:06 +00:00
// We set the number of plugins here so we can properly verify if valid plugin
// indices are being passed to the LandTexture Store retrieval methods.
Store refactor: Now way easier to create new stores, a good chunk of it is automated, only simple macros are used now The case of indexedStores remains an issue, because they can't be stored with the rest because they don't inherit of store base
2022-07-03 18:11:20 +02:00
getWritable<ESM::LandTexture>().resize(esm.getIndex()+1);
- Add some updated files missing from last commit. - Move plugin dependency test from esmreader.cpp to esmstpre.cpp; fixes crash in omwlauncher.
2012-11-25 17:19:29 +01:00
read info records
2010-08-06 15:19:39 +02:00
// Loop through all records
while(esm.hasMoreRecs())
Main program now stores ESM data in memory
2010-05-17 17:35:42 +02:00
{
move ESMStore to MWWorld
2012-10-01 19:17:04 +04:00
ESM::NAME n = esm.getRecName();
read info records
2010-08-06 15:19:39 +02:00
esm.getRecHeader();
Implement ignored records
2022-04-16 16:28:39 +02:00
if (esm.getRecordFlags() & ESM::FLAG_Ignored)
{
esm.skipRecord();
continue;
}
Main program now stores ESM data in memory
2010-05-17 17:35:42 +02:00
read info records
2010-08-06 15:19:39 +02:00
// Look up the record type.
Fixes a bug with es3overrideRecord, esm3InsertStatic and esm3StoreInsert This also comes with a change to the mapping from esm3 record name to Store to be more direct with a pointer and the creation of a map from store pointer to esm3 record type
2022-07-20 19:04:31 +02:00
ESM::RecNameInts recName = static_cast<ESM::RecNameInts>(n.toInt());
Rename member to be clearer and more generic
2022-09-02 23:39:38 +02:00
const auto& it = mStoreImp->mRecNameToStore.find(recName);
just replace esmstore, inconsistent
2012-11-05 18:09:14 +04:00
Rename member to be clearer and more generic
2022-09-02 23:39:38 +02:00
if (it == mStoreImp->mRecNameToStore.end()) {
Fixes a bug with es3overrideRecord, esm3InsertStatic and esm3StoreInsert This also comes with a change to the mapping from esm3 record name to Store to be more direct with a pointer and the creation of a map from store pointer to esm3 record type
2022-07-20 19:04:31 +02:00
if (recName == ESM::REC_INFO) {
Merge DialInfo objects by subrecord instead of overwriting the object Fixes #1360
2014-05-31 00:36:37 +02:00
if (dialogue)
{
dialogue->readInfo(esm, esm.getIndex() != 0);
}
else
{
Use new logging system for game itself
2018-08-14 23:05:43 +04:00
Log(Debug::Error) << "Error: info record without dialog";
read info records
2010-08-06 15:19:39 +02:00
esm.skipRecord();
}
Do not use union to access FIXED_STRING<4> as int https://en.cppreference.com/w/cpp/language/union: > It's undefined behavior to read from the member of the union that wasn't most recently written.
2021-10-17 02:52:22 +02:00
} else if (n.toInt() == ESM::REC_MGEF) {
Store refactor: Now way easier to create new stores, a good chunk of it is automated, only simple macros are used now The case of indexedStores remains an issue, because they can't be stored with the rest because they don't inherit of store base
2022-07-03 18:11:20 +02:00
getWritable<ESM::MagicEffect>().load (esm);
Do not use union to access FIXED_STRING<4> as int https://en.cppreference.com/w/cpp/language/union: > It's undefined behavior to read from the member of the union that wasn't most recently written.
2021-10-17 02:52:22 +02:00
} else if (n.toInt() == ESM::REC_SKIL) {
Store refactor: Now way easier to create new stores, a good chunk of it is automated, only simple macros are used now The case of indexedStores remains an issue, because they can't be stored with the rest because they don't inherit of store base
2022-07-03 18:11:20 +02:00
getWritable<ESM::Skill>().load (esm);
add project file to content file list when running OpenMW from OpenCS
2014-09-13 20:48:24 +02:00
}
Do not use union to access FIXED_STRING<4> as int https://en.cppreference.com/w/cpp/language/union: > It's undefined behavior to read from the member of the union that wasn't most recently written.
2021-10-17 02:52:22 +02:00
else if (n.toInt() == ESM::REC_FILT || n.toInt() == ESM::REC_DBGP)
add project file to content file list when running OpenMW from OpenCS
2014-09-13 20:48:24 +02:00
{
// ignore project file only records
esm.skipRecord();
}
Load LuaScriptsCfg from both *.omwscripts and *.omwaddon files.
2021-09-26 15:21:46 +02:00
else if (n.toInt() == ESM::REC_LUAL)
{
ESM::LuaScriptsCfg cfg;
cfg.load(esm);
Lua scripts configuration in omwaddon
2022-05-20 21:47:13 +02:00
cfg.adjustRefNums(esm);
Load LuaScriptsCfg from both *.omwscripts and *.omwaddon files.
2021-09-26 15:21:46 +02:00
mLuaContent.push_back(std::move(cfg));
}
add project file to content file list when running OpenMW from OpenCS
2014-09-13 20:48:24 +02:00
else {
Reduce a bit the code bloat in hot paths/small functions There is no need to bloat hot/small functions with a ton of function calls and involving locales for simple error messages.
2021-06-10 12:55:18 +02:00
throw std::runtime_error("Unknown record: " + n.toString());
read info records
2010-08-06 15:19:39 +02:00
}
just replace esmstore, inconsistent
2012-11-05 18:09:14 +04:00
} else {
Fixes a bug with es3overrideRecord, esm3InsertStatic and esm3StoreInsert This also comes with a change to the mapping from esm3 record name to Store to be more direct with a pointer and the creation of a map from store pointer to esm3 record type
2022-07-20 19:04:31 +02:00
RecordId id = it->second->load(esm);
Load/read methods in MWWorld::Store return a pair (record ID, deleted flag)
2015-07-12 15:20:22 +03:00
if (id.mIsDeleted)
Remove NAME handling from MWWorld::ESMStore
2015-07-08 21:26:20 +03:00
{
Fixes a bug with es3overrideRecord, esm3InsertStatic and esm3StoreInsert This also comes with a change to the mapping from esm3 record name to Store to be more direct with a pointer and the creation of a map from store pointer to esm3 record type
2022-07-20 19:04:31 +02:00
it->second->eraseStatic(id.mId);
Remove NAME handling from MWWorld::ESMStore
2015-07-08 21:26:20 +03:00
continue;
Recognize DELE subrecords at the end of the record (Fixes #1414)
2014-06-07 19:21:37 +02:00
}
Do not use union to access FIXED_STRING<4> as int https://en.cppreference.com/w/cpp/language/union: > It's undefined behavior to read from the member of the union that wasn't most recently written.
2021-10-17 02:52:22 +02:00
if (n.toInt() == ESM::REC_DIAL) {
Store refactor: Now way easier to create new stores, a good chunk of it is automated, only simple macros are used now The case of indexedStores remains an issue, because they can't be stored with the rest because they don't inherit of store base
2022-07-03 18:11:20 +02:00
dialogue = const_cast<ESM::Dialogue*>(getWritable<ESM::Dialogue>().find(id.mId));
just replace esmstore, inconsistent
2012-11-05 18:09:14 +04:00
} else {
Replace zeroes and nulls by nullptrs
2020-11-13 11:39:47 +04:00
dialogue = nullptr;
just replace esmstore, inconsistent
2012-11-05 18:09:14 +04:00
}
read info records
2010-08-06 15:19:39 +02:00
}
Show groundcover loading progress
2022-06-03 18:59:08 +02:00
if (listener != nullptr)
listener->setProgress(::EsmLoader::fileProgress * esm.getFileOffset() / esm.getFileSize());
Main program now stores ESM data in memory
2010-05-17 17:35:42 +02:00
}
}
move ESMStore to MWWorld
2012-10-01 19:17:04 +04:00
gets rid of the macros, we use a tuple instead, with a mechanism to assign an index to each type. so the tuple is only defined in the cpp, but we can still have template functions in the header that can ge tthe index with the type
2022-09-03 11:08:23 +02:00
static int sTypeIndexCounter = 0;
int& ESMStore::getTypeIndexCounter()
{
return sTypeIndexCounter;
}
Load LuaScriptsCfg from both *.omwscripts and *.omwaddon files.
2021-09-26 15:21:46 +02:00
ESM::LuaScriptsCfg ESMStore::getLuaScriptsCfg() const
{
ESM::LuaScriptsCfg cfg;
for (const LuaContent& c : mLuaContent)
{
if (std::holds_alternative<std::string>(c))
{
// *.omwscripts are intentionally reloaded every time when `getLuaScriptsCfg` is called.
// It is important for the `reloadlua` console command.
try
{
auto file = std::ifstream(std::get<std::string>(c));
std::string fileContent(std::istreambuf_iterator<char>(file), {});
LuaUtil::parseOMWScripts(cfg, fileContent);
}
catch (std::exception& e) { Log(Debug::Error) << e.what(); }
}
else
{
const ESM::LuaScriptsCfg& addition = std::get<ESM::LuaScriptsCfg>(c);
cfg.mScripts.insert(cfg.mScripts.end(), addition.mScripts.begin(), addition.mScripts.end());
}
}
return cfg;
}
Limit the number of simultaneously open not actively used content files Use LRU cache for ESMReaders. When cache capacity is reached close least recently used ESMReader. Remember the file name if a reader was open. Once the reader requested again open the file if there is stored name for it. Put released ESMReader to the back of the free items list. Close ESMReader's from the front of the free items list. Cached item can be used only by one client at the same time. If the same item is requested twice exception is thrown. This should never happen in practice. If this happens need to fix the client logic. It's allowed to go over the capacity limit when requesting different readers. Ideally this should never happen but there will be system error anyway signalizing about too many open files. Need to fix client logic in this case. All places that were using a vector of ESMReaders now using the cache. Cache is local for each use case and there is no need for a thread safety.
2022-06-01 22:53:18 +02:00
void ESMStore::setUp()
just replace esmstore, inconsistent
2012-11-05 18:09:14 +04:00
{
mids and mStaticIds moved to mStoreImp renamed recordid to storeid
2022-07-20 19:28:06 +02:00
mStoreImp->mIds.clear();
ESMStore: fill mIds in setUp()
2015-12-11 15:55:45 +01:00
rename StoreBase =>DynamicStore, and create new class Storebase all stores inherit from base class StoreBase.Storebase is just an empty interface class
2022-09-02 23:46:37 +02:00
std::map<ESM::RecNameInts, DynamicStore*>::iterator storeIt = mStoreImp->mRecNameToStore.begin();
Rename member to be clearer and more generic
2022-09-02 23:39:38 +02:00
for (; storeIt != mStoreImp->mRecNameToStore.end(); ++storeIt) {
Fixes a bug with es3overrideRecord, esm3InsertStatic and esm3StoreInsert This also comes with a change to the mapping from esm3 record name to Store to be more direct with a pointer and the creation of a map from store pointer to esm3 record type
2022-07-20 19:04:31 +02:00
storeIt->second->setUp();
Minor fix
2015-12-11 16:59:13 +01:00
ESMStore: fill mIds in setUp()
2015-12-11 15:55:45 +01:00
if (isCacheableRecord(storeIt->first))
{
std::vector<std::string> identifiers;
Fixes a bug with es3overrideRecord, esm3InsertStatic and esm3StoreInsert This also comes with a change to the mapping from esm3 record name to Store to be more direct with a pointer and the creation of a map from store pointer to esm3 record type
2022-07-20 19:04:31 +02:00
storeIt->second->listIdentifier(identifiers);
ESMStore: fill mIds in setUp()
2015-12-11 15:55:45 +01:00
for (std::vector<std::string>::const_iterator record = identifiers.begin(); record != identifiers.end(); ++record)
mids and mStaticIds moved to mStoreImp renamed recordid to storeid
2022-07-20 19:28:06 +02:00
mStoreImp->mIds[*record] = storeIt->first;
ESMStore: fill mIds in setUp()
2015-12-11 15:55:45 +01:00
}
just replace esmstore, inconsistent
2012-11-05 18:09:14 +04:00
}
terrainbased objectpaging Signed-off-by: Bret Curtis <psi29a@gmail.com>
2019-06-13 13:37:00 +00:00
mids and mStaticIds moved to mStoreImp renamed recordid to storeid
2022-07-20 19:28:06 +02:00
if (mStoreImp->mStaticIds.empty())
for (const auto& [k, v] : mStoreImp->mIds)
mStoreImp->mStaticIds.emplace(Misc::StringUtils::lowerCase(k), v);
terrainbased objectpaging Signed-off-by: Bret Curtis <psi29a@gmail.com>
2019-06-13 13:37:00 +00:00
Store refactor: Now way easier to create new stores, a good chunk of it is automated, only simple macros are used now The case of indexedStores remains an issue, because they can't be stored with the rest because they don't inherit of store base
2022-07-03 18:11:20 +02:00
getWritable<ESM::Skill>().setUp();
getWritable<ESM::MagicEffect>().setUp();;
getWritable<ESM::Attribute>().setUp();
getWritable<ESM::Dialogue>().setUp();
Limit the number of simultaneously open not actively used content files Use LRU cache for ESMReaders. When cache capacity is reached close least recently used ESMReader. Remember the file name if a reader was open. Once the reader requested again open the file if there is stored name for it. Put released ESMReader to the back of the free items list. Close ESMReader's from the front of the free items list. Cached item can be used only by one client at the same time. If the same item is requested twice exception is thrown. This should never happen in practice. If this happens need to fix the client logic. It's allowed to go over the capacity limit when requesting different readers. Ideally this should never happen but there will be system error anyway signalizing about too many open files. Need to fix client logic in this case. All places that were using a vector of ESMReaders now using the cache. Cache is local for each use case and there is no need for a thread safety.
2022-06-01 22:53:18 +02:00
}
Add NPC validation to esmstore (bug #2772)
2018-06-09 20:47:17 +04:00
Limit the number of simultaneously open not actively used content files Use LRU cache for ESMReaders. When cache capacity is reached close least recently used ESMReader. Remember the file name if a reader was open. Once the reader requested again open the file if there is stored name for it. Put released ESMReader to the back of the free items list. Close ESMReader's from the front of the free items list. Cached item can be used only by one client at the same time. If the same item is requested twice exception is thrown. This should never happen in practice. If this happens need to fix the client logic. It's allowed to go over the capacity limit when requesting different readers. Ideally this should never happen but there will be system error anyway signalizing about too many open files. Need to fix client logic in this case. All places that were using a vector of ESMReaders now using the cache. Cache is local for each use case and there is no need for a thread safety.
2022-06-01 22:53:18 +02:00
void ESMStore::validateRecords(ESM::ReadersCache& readers)
{
validate();
countAllCellRefs(readers);
implement additem/removeitem for non-unique actors
2020-07-26 11:07:18 +02:00
}
Limit the number of simultaneously open not actively used content files Use LRU cache for ESMReaders. When cache capacity is reached close least recently used ESMReader. Remember the file name if a reader was open. Once the reader requested again open the file if there is stored name for it. Put released ESMReader to the back of the free items list. Close ESMReader's from the front of the free items list. Cached item can be used only by one client at the same time. If the same item is requested twice exception is thrown. This should never happen in practice. If this happens need to fix the client logic. It's allowed to go over the capacity limit when requesting different readers. Ideally this should never happen but there will be system error anyway signalizing about too many open files. Need to fix client logic in this case. All places that were using a vector of ESMReaders now using the cache. Cache is local for each use case and there is no need for a thread safety.
2022-06-01 22:53:18 +02:00
void ESMStore::countAllCellRefs(ESM::ReadersCache& readers)
implement additem/removeitem for non-unique actors
2020-07-26 11:07:18 +02:00
{
restores countRecords optimisations (#3210) With this PR we restore @elsid 's optimisations of countRecords we have unintentionally discarded in PR #3197. In addition, we give it a more appropriate name and add comments concerning its peculiar background.
2021-11-02 13:46:41 +00:00
// TODO: We currently need to read entire files here again.
// We should consider consolidating or deferring this reading.
implement additem/removeitem for non-unique actors
2020-07-26 11:07:18 +02:00
if(!mRefCount.empty())
return;
Use stable sort+unique to collect RefIDs for ESMStore records counting The idea is to avoid std::map lookup for each CellRef. Instead generate a sequence of added and removed RefNums into a vector then order them by RefNum using a stable sort that preserves relative order of elements with the same RefNum. RefIDs are stored in a different vector to avoid std::string move ctor calls when swapping elements while sorting. Reversed iteration over added and removed RefNums for each unique RefNum is an equivalent to what map-based algorithm produces. The main benefit from sorting a vector is a data locality that means less cache misses for each access. Reduces ESMStore::countRecords perf cycles by 25%.
2021-04-06 23:59:58 +02:00
std::vector<Ref> refs;
std::vector<std::string> refIDs;
Store refactor: Now way easier to create new stores, a good chunk of it is automated, only simple macros are used now The case of indexedStores remains an issue, because they can't be stored with the rest because they don't inherit of store base
2022-07-03 18:11:20 +02:00
Store<ESM::Cell> Cells = getWritable < ESM::Cell>();
for(auto it = Cells.intBegin(); it != Cells.intEnd(); ++it)
Use stable sort+unique to collect RefIDs for ESMStore records counting The idea is to avoid std::map lookup for each CellRef. Instead generate a sequence of added and removed RefNums into a vector then order them by RefNum using a stable sort that preserves relative order of elements with the same RefNum. RefIDs are stored in a different vector to avoid std::string move ctor calls when swapping elements while sorting. Reversed iteration over added and removed RefNums for each unique RefNum is an equivalent to what map-based algorithm produces. The main benefit from sorting a vector is a data locality that means less cache misses for each access. Reduces ESMStore::countRecords perf cycles by 25%.
2021-04-06 23:59:58 +02:00
readRefs(*it, refs, refIDs, readers);
Store refactor: Now way easier to create new stores, a good chunk of it is automated, only simple macros are used now The case of indexedStores remains an issue, because they can't be stored with the rest because they don't inherit of store base
2022-07-03 18:11:20 +02:00
for(auto it = Cells.extBegin(); it != Cells.extEnd(); ++it)
Use stable sort+unique to collect RefIDs for ESMStore records counting The idea is to avoid std::map lookup for each CellRef. Instead generate a sequence of added and removed RefNums into a vector then order them by RefNum using a stable sort that preserves relative order of elements with the same RefNum. RefIDs are stored in a different vector to avoid std::string move ctor calls when swapping elements while sorting. Reversed iteration over added and removed RefNums for each unique RefNum is an equivalent to what map-based algorithm produces. The main benefit from sorting a vector is a data locality that means less cache misses for each access. Reduces ESMStore::countRecords perf cycles by 25%.
2021-04-06 23:59:58 +02:00
readRefs(*it, refs, refIDs, readers);
const auto lessByRefNum = [] (const Ref& l, const Ref& r) { return l.mRefNum < r.mRefNum; };
std::stable_sort(refs.begin(), refs.end(), lessByRefNum);
const auto equalByRefNum = [] (const Ref& l, const Ref& r) { return l.mRefNum == r.mRefNum; };
const auto incrementRefCount = [&] (const Ref& value)
{
if (value.mRefID != deletedRefID)
{
std::string& refId = refIDs[value.mRefID];
restores countRecords optimisations (#3210) With this PR we restore @elsid 's optimisations of countRecords we have unintentionally discarded in PR #3197. In addition, we give it a more appropriate name and add comments concerning its peculiar background.
2021-11-02 13:46:41 +00:00
// We manually lower case IDs here for the time being to improve performance.
Misc::StringUtils::lowerCaseInPlace(refId);
Use stable sort+unique to collect RefIDs for ESMStore records counting The idea is to avoid std::map lookup for each CellRef. Instead generate a sequence of added and removed RefNums into a vector then order them by RefNum using a stable sort that preserves relative order of elements with the same RefNum. RefIDs are stored in a different vector to avoid std::string move ctor calls when swapping elements while sorting. Reversed iteration over added and removed RefNums for each unique RefNum is an equivalent to what map-based algorithm produces. The main benefit from sorting a vector is a data locality that means less cache misses for each access. Reduces ESMStore::countRecords perf cycles by 25%.
2021-04-06 23:59:58 +02:00
++mRefCount[std::move(refId)];
}
};
Misc::forEachUnique(refs.rbegin(), refs.rend(), equalByRefNum, incrementRefCount);
implement additem/removeitem for non-unique actors
2020-07-26 11:07:18 +02:00
}
Allow string_view lookups in MWWorld::Store and get some use out of that
2022-06-13 18:21:29 +02:00
int ESMStore::getRefCount(std::string_view id) const
implement additem/removeitem for non-unique actors
2020-07-26 11:07:18 +02:00
{
restores countRecords optimisations (#3210) With this PR we restore @elsid 's optimisations of countRecords we have unintentionally discarded in PR #3197. In addition, we give it a more appropriate name and add comments concerning its peculiar background.
2021-11-02 13:46:41 +00:00
const std::string lowerId = Misc::StringUtils::lowerCase(id);
auto it = mRefCount.find(lowerId);
implement additem/removeitem for non-unique actors
2020-07-26 11:07:18 +02:00
if(it == mRefCount.end())
return 0;
return it->second;
Add NPC validation to esmstore (bug #2772)
2018-06-09 20:47:17 +04:00
}
void ESMStore::validate()
{
Fixed naming convention problems removed 2 macros. - One is replaced by the underlying code - The second one ise replaced by a template function removed tabulation used as indentation used getWritable instead of a const_cast used for( val : cont) loop removed useless getId function
2022-07-19 17:58:21 +02:00
auto& npcs = getWritable<ESM::NPC>();
std::vector<ESM::NPC> npcsToReplace = getNPCsToReplace(getWritable<ESM::Faction>(), getWritable<ESM::Class>(), npcs.mStatic);
Add NPC validation to esmstore (bug #2772)
2018-06-09 20:47:17 +04:00
Add spell effect argument validation (bug #4927)
2019-03-31 18:54:12 +03:00
for (const ESM::NPC &npc : npcsToReplace)
Add NPC validation to esmstore (bug #2772)
2018-06-09 20:47:17 +04:00
{
Fixed naming convention problems removed 2 macros. - One is replaced by the underlying code - The second one ise replaced by a template function removed tabulation used as indentation used getWritable instead of a const_cast used for( val : cont) loop removed useless getId function
2022-07-19 17:58:21 +02:00
npcs.eraseStatic(npc.mId);
npcs.insertStatic(npc);
Add NPC validation to esmstore (bug #2772)
2018-06-09 20:47:17 +04:00
}
Add spell effect argument validation (bug #4927)
2019-03-31 18:54:12 +03:00
// Validate spell effects for invalid arguments
std::vector<ESM::Spell> spellsToReplace;
Store refactor: Now way easier to create new stores, a good chunk of it is automated, only simple macros are used now The case of indexedStores remains an issue, because they can't be stored with the rest because they don't inherit of store base
2022-07-03 18:11:20 +02:00
auto& Spells = getWritable<ESM::Spell>();
for (ESM::Spell spell : Spells)
Add spell effect argument validation (bug #4927)
2019-03-31 18:54:12 +03:00
{
if (spell.mEffects.mList.empty())
continue;
bool changed = false;
Erase effects with invalid indices from spells (bug #5050)
2019-05-31 11:23:58 +03:00
auto iter = spell.mEffects.mList.begin();
while (iter != spell.mEffects.mList.end())
Add spell effect argument validation (bug #4927)
2019-03-31 18:54:12 +03:00
{
Store refactor: Now way easier to create new stores, a good chunk of it is automated, only simple macros are used now The case of indexedStores remains an issue, because they can't be stored with the rest because they don't inherit of store base
2022-07-03 18:11:20 +02:00
const ESM::MagicEffect* mgef = getWritable<ESM::MagicEffect>().search(iter->mEffectID);
Erase effects with invalid indices from spells (bug #5050)
2019-05-31 11:23:58 +03:00
if (!mgef)
{
Fix typos in invalid spell effect warnings, clarify them
2019-10-17 23:45:27 +03:00
Log(Debug::Verbose) << "Spell '" << spell.mId << "' has an invalid effect (index " << iter->mEffectID << ") present. Dropping the effect.";
Erase effects with invalid indices from spells (bug #5050)
2019-05-31 11:23:58 +03:00
iter = spell.mEffects.mList.erase(iter);
changed = true;
Add spell effect argument validation (bug #4927)
2019-03-31 18:54:12 +03:00
continue;
Erase effects with invalid indices from spells (bug #5050)
2019-05-31 11:23:58 +03:00
}
Add spell effect argument validation (bug #4927)
2019-03-31 18:54:12 +03:00
if (mgef->mData.mFlags & ESM::MagicEffect::TargetSkill)
{
Erase effects with invalid indices from spells (bug #5050)
2019-05-31 11:23:58 +03:00
if (iter->mAttribute != -1)
Add spell effect argument validation (bug #4927)
2019-03-31 18:54:12 +03:00
{
Erase effects with invalid indices from spells (bug #5050)
2019-05-31 11:23:58 +03:00
iter->mAttribute = -1;
Log(Debug::Verbose) << ESM::MagicEffect::effectIdToString(iter->mEffectID) <<
Fix typos in invalid spell effect warnings, clarify them
2019-10-17 23:45:27 +03:00
" effect of spell '" << spell.mId << "' has an attribute argument present. Dropping the argument.";
Add spell effect argument validation (bug #4927)
2019-03-31 18:54:12 +03:00
changed = true;
}
}
else if (mgef->mData.mFlags & ESM::MagicEffect::TargetAttribute)
{
Erase effects with invalid indices from spells (bug #5050)
2019-05-31 11:23:58 +03:00
if (iter->mSkill != -1)
Add spell effect argument validation (bug #4927)
2019-03-31 18:54:12 +03:00
{
Erase effects with invalid indices from spells (bug #5050)
2019-05-31 11:23:58 +03:00
iter->mSkill = -1;
Log(Debug::Verbose) << ESM::MagicEffect::effectIdToString(iter->mEffectID) <<
Fix typos in invalid spell effect warnings, clarify them
2019-10-17 23:45:27 +03:00
" effect of spell '" << spell.mId << "' has a skill argument present. Dropping the argument.";
Add spell effect argument validation (bug #4927)
2019-03-31 18:54:12 +03:00
changed = true;
}
}
Erase effects with invalid indices from spells (bug #5050)
2019-05-31 11:23:58 +03:00
else if (iter->mSkill != -1 || iter->mAttribute != -1)
Add spell effect argument validation (bug #4927)
2019-03-31 18:54:12 +03:00
{
Erase effects with invalid indices from spells (bug #5050)
2019-05-31 11:23:58 +03:00
iter->mSkill = -1;
iter->mAttribute = -1;
Log(Debug::Verbose) << ESM::MagicEffect::effectIdToString(iter->mEffectID) <<
Fix typos in invalid spell effect warnings, clarify them
2019-10-17 23:45:27 +03:00
" effect of spell '" << spell.mId << "' has argument(s) present. Dropping the argument(s).";
Add spell effect argument validation (bug #4927)
2019-03-31 18:54:12 +03:00
changed = true;
}
Erase effects with invalid indices from spells (bug #5050)
2019-05-31 11:23:58 +03:00
++iter;
Add spell effect argument validation (bug #4927)
2019-03-31 18:54:12 +03:00
}
if (changed)
spellsToReplace.emplace_back(spell);
}
for (const ESM::Spell &spell : spellsToReplace)
{
Store refactor: Now way easier to create new stores, a good chunk of it is automated, only simple macros are used now The case of indexedStores remains an issue, because they can't be stored with the rest because they don't inherit of store base
2022-07-03 18:11:20 +02:00
Spells.eraseStatic(spell.mId);
Spells.insertStatic(spell);
Add spell effect argument validation (bug #4927)
2019-03-31 18:54:12 +03:00
}
just replace esmstore, inconsistent
2012-11-05 18:09:14 +04:00
}
ESMStore: no longer necessary to include the type definitions in the header For now there still needs to declare all the getters, but a macro may make that easier, or an different method entierly
2022-07-03 11:47:46 +02:00
void ESMStore::movePlayerRecord()
{
Fixed naming convention problems removed 2 macros. - One is replaced by the underlying code - The second one ise replaced by a template function removed tabulation used as indentation used getWritable instead of a const_cast used for( val : cont) loop removed useless getId function
2022-07-19 17:58:21 +02:00
auto& npcs = getWritable<ESM::NPC>();
auto player = npcs.find("player");
npcs.insert(*player);
ESMStore: no longer necessary to include the type definitions in the header For now there still needs to declare all the getters, but a macro may make that easier, or an different method entierly
2022-07-03 11:47:46 +02:00
}
Also run NPC validation for modified base records
2021-03-23 21:07:57 +01:00
void ESMStore::validateDynamic()
{
Fixed naming convention problems removed 2 macros. - One is replaced by the underlying code - The second one ise replaced by a template function removed tabulation used as indentation used getWritable instead of a const_cast used for( val : cont) loop removed useless getId function
2022-07-19 17:58:21 +02:00
auto& npcs = getWritable<ESM::NPC>();
Store refactor: Now way easier to create new stores, a good chunk of it is automated, only simple macros are used now The case of indexedStores remains an issue, because they can't be stored with the rest because they don't inherit of store base
2022-07-03 18:11:20 +02:00
auto& scripts = getWritable<ESM::Script>();
Fixed naming convention problems removed 2 macros. - One is replaced by the underlying code - The second one ise replaced by a template function removed tabulation used as indentation used getWritable instead of a const_cast used for( val : cont) loop removed useless getId function
2022-07-19 17:58:21 +02:00
std::vector<ESM::NPC> npcsToReplace = getNPCsToReplace(getWritable<ESM::Faction>(), getWritable<ESM::Class>(), npcs.mDynamic);
Also run NPC validation for modified base records
2021-03-23 21:07:57 +01:00
for (const ESM::NPC &npc : npcsToReplace)
Fixed naming convention problems removed 2 macros. - One is replaced by the underlying code - The second one ise replaced by a template function removed tabulation used as indentation used getWritable instead of a const_cast used for( val : cont) loop removed useless getId function
2022-07-19 17:58:21 +02:00
npcs.insert(npc);
Improve save cleaning
2021-07-12 20:51:13 +02:00
Store refactor: Now way easier to create new stores, a good chunk of it is automated, only simple macros are used now The case of indexedStores remains an issue, because they can't be stored with the rest because they don't inherit of store base
2022-07-03 18:11:20 +02:00
removeMissingScripts(scripts, getWritable<ESM::Armor>().mDynamic);
removeMissingScripts(scripts, getWritable<ESM::Book>().mDynamic);
removeMissingScripts(scripts, getWritable<ESM::Clothing>().mDynamic);
removeMissingScripts(scripts, getWritable<ESM::Weapon>().mDynamic);
Improve save cleaning
2021-07-12 20:51:13 +02:00
Store refactor: Now way easier to create new stores, a good chunk of it is automated, only simple macros are used now The case of indexedStores remains an issue, because they can't be stored with the rest because they don't inherit of store base
2022-07-03 18:11:20 +02:00
removeMissingObjects(getWritable<ESM::CreatureLevList>());
removeMissingObjects(getWritable<ESM::ItemLevList>());
Improve save cleaning
2021-07-12 20:51:13 +02:00
}
// Leveled lists can be modified by scripts. This removes items that no longer exist (presumably because the plugin was removed) from modified lists
template<class T>
void ESMStore::removeMissingObjects(Store<T>& store)
{
Workaround clang and actually erase from the vector
2021-07-13 21:18:24 +02:00
for(auto& entry : store.mDynamic)
Improve save cleaning
2021-07-12 20:51:13 +02:00
{
Workaround clang and actually erase from the vector
2021-07-13 21:18:24 +02:00
auto first = std::remove_if(entry.second.mList.begin(), entry.second.mList.end(), [&] (const auto& item)
Improve save cleaning
2021-07-12 20:51:13 +02:00
{
if(!find(item.mId))
{
Workaround clang and actually erase from the vector
2021-07-13 21:18:24 +02:00
Log(Debug::Verbose) << "Leveled list '" << entry.first << "' has nonexistent object '" << item.mId << "', ignoring it.";
Improve save cleaning
2021-07-12 20:51:13 +02:00
return true;
}
return false;
});
Workaround clang and actually erase from the vector
2021-07-13 21:18:24 +02:00
entry.second.mList.erase(first, entry.second.mList.end());
Improve save cleaning
2021-07-12 20:51:13 +02:00
}
Also run NPC validation for modified base records
2021-03-23 21:07:57 +01:00
}
save and load dynamic records
2013-12-07 13:17:28 +01:00
int ESMStore::countSavedGameRecords() const
{
Fixes #1234: Store dynamic record counter in savegame to prevent name clashes
2014-05-11 00:32:22 +02:00
return 1 // DYNA (dynamic name counter)
Store refactor: Now way easier to create new stores, a good chunk of it is automated, only simple macros are used now The case of indexedStores remains an issue, because they can't be stored with the rest because they don't inherit of store base
2022-07-03 18:11:20 +02:00
+ get<ESM::Potion>().getDynamicSize()
+ get<ESM::Armor>().getDynamicSize()
+ get<ESM::Book>().getDynamicSize()
+ get<ESM::Class>().getDynamicSize()
+ get<ESM::Clothing>().getDynamicSize()
+ get<ESM::Enchantment>().getDynamicSize()
+ get<ESM::NPC>().getDynamicSize()
+ get<ESM::Spell>().getDynamicSize()
+ get<ESM::Weapon>().getDynamicSize()
+ get<ESM::CreatureLevList>().getDynamicSize()
+ get<ESM::ItemLevList>().getDynamicSize()
+ get<ESM::Creature>().getDynamicSize()
+ get<ESM::Container>().getDynamicSize();
save and load dynamic records
2013-12-07 13:17:28 +01:00
}
Fixes #1172: Added basic loading/saving progress bar The progress is not particularly accurate. It simply uses the current / total number of records written/read as indication. Cell records are currently the largest by far, but there is a good chance that could be optimized using a change tracking system.
2014-04-28 11:29:57 +02:00
void ESMStore::write (ESM::ESMWriter& writer, Loading::Listener& progress) const
save and load dynamic records
2013-12-07 13:17:28 +01:00
{
Fixes #1234: Store dynamic record counter in savegame to prevent name clashes
2014-05-11 00:32:22 +02:00
writer.startRecord(ESM::REC_DYNA);
writer.startSubRecord("COUN");
writer.writeT(mDynamicCount);
writer.endRecord("COUN");
writer.endRecord(ESM::REC_DYNA);
Store refactor: Now way easier to create new stores, a good chunk of it is automated, only simple macros are used now The case of indexedStores remains an issue, because they can't be stored with the rest because they don't inherit of store base
2022-07-03 18:11:20 +02:00
get<ESM::Potion>().write (writer, progress);
get<ESM::Armor>().write (writer, progress);
get<ESM::Book>().write (writer, progress);
get<ESM::Class>().write (writer, progress);
get<ESM::Clothing>().write (writer, progress);
get<ESM::Enchantment>().write (writer, progress);
get<ESM::NPC>().write (writer, progress);
get<ESM::Spell>().write (writer, progress);
get<ESM::Weapon>().write (writer, progress);
get<ESM::CreatureLevList>().write (writer, progress);
get<ESM::ItemLevList>().write (writer, progress);
get<ESM::Creature>().write (writer, progress);
get<ESM::Container>().write (writer, progress);
save and load dynamic records
2013-12-07 13:17:28 +01:00
}
Fixes a bug with es3overrideRecord, esm3InsertStatic and esm3StoreInsert This also comes with a change to the mapping from esm3 record name to Store to be more direct with a pointer and the creation of a map from store pointer to esm3 record type
2022-07-20 19:04:31 +02:00
bool ESMStore::readRecord (ESM::ESMReader& reader, uint32_t type_id)
save and load dynamic records
2013-12-07 13:17:28 +01:00
{
Fixes a bug with es3overrideRecord, esm3InsertStatic and esm3StoreInsert This also comes with a change to the mapping from esm3 record name to Store to be more direct with a pointer and the creation of a map from store pointer to esm3 record type
2022-07-20 19:04:31 +02:00
ESM::RecNameInts type = (ESM::RecNameInts)type_id;
save and load dynamic records
2013-12-07 13:17:28 +01:00
switch (type)
{
case ESM::REC_ALCH:
case ESM::REC_ARMO:
case ESM::REC_BOOK:
case ESM::REC_CLAS:
case ESM::REC_CLOT:
case ESM::REC_ENCH:
case ESM::REC_SPEL:
case ESM::REC_WEAP:
Implement leveled list script functions (Fixes #1546)
2014-12-17 01:05:32 +01:00
case ESM::REC_LEVI:
case ESM::REC_LEVC:
Rename member to be clearer and more generic
2022-09-02 23:39:38 +02:00
mStoreImp->mRecNameToStore[type]->read (reader);
Disallow inserting containers, creatures, and npcs from the save game not present in content files
2021-03-22 22:29:10 +01:00
return true;
case ESM::REC_NPC_:
Mutate base records when editing AI settings (#2798)
2020-06-02 21:59:37 +02:00
case ESM::REC_CREA:
Save and load container records; fixes #5668
2020-10-29 13:55:24 +01:00
case ESM::REC_CONT:
Rename member to be clearer and more generic
2022-09-02 23:39:38 +02:00
mStoreImp->mRecNameToStore[type]->read (reader, true);
save and load dynamic records
2013-12-07 13:17:28 +01:00
return true;
Fixes #1234: Store dynamic record counter in savegame to prevent name clashes
2014-05-11 00:32:22 +02:00
case ESM::REC_DYNA:
reader.getSubNameIs("COUN");
reader.getHT(mDynamicCount);
return true;
save and load dynamic records
2013-12-07 13:17:28 +01:00
default:
return false;
}
}
Mutate base records when editing AI settings (#2798)
2020-06-02 21:59:37 +02:00
void ESMStore::checkPlayer()
{
setUp();
Store refactor: Now way easier to create new stores, a good chunk of it is automated, only simple macros are used now The case of indexedStores remains an issue, because they can't be stored with the rest because they don't inherit of store base
2022-07-03 18:11:20 +02:00
const ESM::NPC *player = get<ESM::NPC>().find ("player");
Mutate base records when editing AI settings (#2798)
2020-06-02 21:59:37 +02:00
Store refactor: Now way easier to create new stores, a good chunk of it is automated, only simple macros are used now The case of indexedStores remains an issue, because they can't be stored with the rest because they don't inherit of store base
2022-07-03 18:11:20 +02:00
if (!get<ESM::Race>().find (player->mRace) ||
!get<ESM::Class>().find (player->mClass))
Mutate base records when editing AI settings (#2798)
2020-06-02 21:59:37 +02:00
throw std::runtime_error ("Invalid player record (race or class unavailable");
}
refactors MWWorld::Store maps (#3197) With this PR we clean up `MWWorld::Store` maps according to the approach of PR #3184.
2021-10-30 17:27:57 +00:00
std::pair<std::shared_ptr<MWMechanics::SpellList>, bool> ESMStore::getSpellList(const std::string& id) const
Mutate base records when adding/removing spells
2020-07-28 08:33:28 +02:00
{
auto result = mSpellListCache.find(id);
std::shared_ptr<MWMechanics::SpellList> ptr;
if (result != mSpellListCache.end())
ptr = result->second.lock();
if (!ptr)
{
int type = find(id);
ptr = std::make_shared<MWMechanics::SpellList>(id, type);
if (result != mSpellListCache.end())
result->second = ptr;
else
mSpellListCache.insert({id, ptr});
return {ptr, false};
}
return {ptr, true};
}
ESMStore: no longer necessary to include the type definitions in the header For now there still needs to declare all the getters, but a macro may make that easier, or an different method entierly
2022-07-03 11:47:46 +02:00
template <>
const ESM::Cell *ESMStore::insert<ESM::Cell>(const ESM::Cell &cell) {
Store refactor: Now way easier to create new stores, a good chunk of it is automated, only simple macros are used now The case of indexedStores remains an issue, because they can't be stored with the rest because they don't inherit of store base
2022-07-03 18:11:20 +02:00
return getWritable<ESM::Cell>().insert(cell);
ESMStore: no longer necessary to include the type definitions in the header For now there still needs to declare all the getters, but a macro may make that easier, or an different method entierly
2022-07-03 11:47:46 +02:00
}
template <>
const ESM::NPC *ESMStore::insert<ESM::NPC>(const ESM::NPC &npc)
{
const std::string id = "$dynamic" + std::to_string(mDynamicCount++);
Fixed naming convention problems removed 2 macros. - One is replaced by the underlying code - The second one ise replaced by a template function removed tabulation used as indentation used getWritable instead of a const_cast used for( val : cont) loop removed useless getId function
2022-07-19 17:58:21 +02:00
auto& npcs = getWritable<ESM::NPC>();
ESMStore: no longer necessary to include the type definitions in the header For now there still needs to declare all the getters, but a macro may make that easier, or an different method entierly
2022-07-03 11:47:46 +02:00
if (Misc::StringUtils::ciEqual(npc.mId, "player"))
{
Fixed naming convention problems removed 2 macros. - One is replaced by the underlying code - The second one ise replaced by a template function removed tabulation used as indentation used getWritable instead of a const_cast used for( val : cont) loop removed useless getId function
2022-07-19 17:58:21 +02:00
return npcs.insert(npc);
ESMStore: no longer necessary to include the type definitions in the header For now there still needs to declare all the getters, but a macro may make that easier, or an different method entierly
2022-07-03 11:47:46 +02:00
}
Fixed naming convention problems removed 2 macros. - One is replaced by the underlying code - The second one ise replaced by a template function removed tabulation used as indentation used getWritable instead of a const_cast used for( val : cont) loop removed useless getId function
2022-07-19 17:58:21 +02:00
else if (npcs.search(id) != nullptr)
ESMStore: no longer necessary to include the type definitions in the header For now there still needs to declare all the getters, but a macro may make that easier, or an different method entierly
2022-07-03 11:47:46 +02:00
{
const std::string msg = "Try to override existing record '" + id + "'";
throw std::runtime_error(msg);
}
ESM::NPC record = npc;
record.mId = id;
Fixed naming convention problems removed 2 macros. - One is replaced by the underlying code - The second one ise replaced by a template function removed tabulation used as indentation used getWritable instead of a const_cast used for( val : cont) loop removed useless getId function
2022-07-19 17:58:21 +02:00
ESM::NPC *ptr = npcs.insert(record);
mids and mStaticIds moved to mStoreImp renamed recordid to storeid
2022-07-20 19:28:06 +02:00
mStoreImp->mIds[ptr->mId] = ESM::REC_NPC_;
ESMStore: no longer necessary to include the type definitions in the header For now there still needs to declare all the getters, but a macro may make that easier, or an different method entierly
2022-07-03 11:47:46 +02:00
return ptr;
}
Removed macro that didn't serve any real purpose Renamed member that didn't respect the naming convention
2022-08-01 19:03:07 +02:00
template<> const ESM::Book* ESMStore::insert<ESM::Book>(const ESM::Book &toInsert) { return ESMStoreImp::esm3StoreInsert(*this, toInsert);}
template<> const ESM::Armor* ESMStore::insert<ESM::Armor>(const ESM::Armor &toInsert) { return ESMStoreImp::esm3StoreInsert(*this, toInsert);}
template<> const ESM::Class* ESMStore::insert<ESM::Class>(const ESM::Class &toInsert) { return ESMStoreImp::esm3StoreInsert(*this, toInsert);}
template<> const ESM::Enchantment* ESMStore::insert<ESM::Enchantment>(const ESM::Enchantment &toInsert) { return ESMStoreImp::esm3StoreInsert(*this, toInsert);}
template<> const ESM::Potion* ESMStore::insert<ESM::Potion>(const ESM::Potion &toInsert) { return ESMStoreImp::esm3StoreInsert(*this, toInsert);}
template<> const ESM::Weapon* ESMStore::insert<ESM::Weapon>(const ESM::Weapon &toInsert) { return ESMStoreImp::esm3StoreInsert(*this, toInsert);}
template<> const ESM::Clothing* ESMStore::insert<ESM::Clothing>(const ESM::Clothing &toInsert) { return ESMStoreImp::esm3StoreInsert(*this, toInsert);}
template<> const ESM::Spell* ESMStore::insert<ESM::Spell>(const ESM::Spell &toInsert) { return ESMStoreImp::esm3StoreInsert(*this, toInsert);}
template<> const ESM::GameSetting* ESMStore::insertStatic<ESM::GameSetting>(const ESM::GameSetting &toInsert) { return ESMStoreImp::esm3insertStatic(*this, toInsert); }
template<> const ESM::Static* ESMStore::insertStatic<ESM::Static>(const ESM::Static &toInsert) { return ESMStoreImp::esm3insertStatic(*this, toInsert); }
template<> const ESM::Door* ESMStore::insertStatic<ESM::Door>(const ESM::Door &toInsert) { return ESMStoreImp::esm3insertStatic(*this, toInsert); }
template<> const ESM::Global* ESMStore::insertStatic<ESM::Global>(const ESM::Global &toInsert) { return ESMStoreImp::esm3insertStatic(*this, toInsert); }
template<> const ESM::NPC* ESMStore::insertStatic<ESM::NPC>(const ESM::NPC &toInsert) { return ESMStoreImp::esm3insertStatic(*this, toInsert); }
template<> const ESM::Container* ESMStore::overrideRecord<ESM::Container>(const ESM::Container &toInsert) { return ESMStoreImp::esm3overrideRecord(*this, toInsert); }
template<> const ESM::Creature* ESMStore::overrideRecord<ESM::Creature>(const ESM::Creature &toInsert) { return ESMStoreImp::esm3overrideRecord(*this, toInsert); }
template<> const ESM::CreatureLevList* ESMStore::overrideRecord<ESM::CreatureLevList>(const ESM::CreatureLevList &toInsert) { return ESMStoreImp::esm3overrideRecord(*this, toInsert); }
template<> const ESM::Door* ESMStore::overrideRecord<ESM::Door>(const ESM::Door &toInsert) { return ESMStoreImp::esm3overrideRecord(*this, toInsert); }
template<> const ESM::ItemLevList* ESMStore::overrideRecord<ESM::ItemLevList>(const ESM::ItemLevList &toInsert) { return ESMStoreImp::esm3overrideRecord(*this, toInsert); }
template<> const ESM::NPC* ESMStore::overrideRecord<ESM::NPC>(const ESM::NPC &toInsert) { return ESMStoreImp::esm3overrideRecord(*this, toInsert); }
move ESMStore to MWWorld
2012-10-01 19:17:04 +04:00
} // end namespace
Reference in New Issue Copy Permalink