id
int64 0
755k
| file_name
stringlengths 3
109
| file_path
stringlengths 13
185
| content
stringlengths 31
9.38M
| size
int64 31
9.38M
| language
stringclasses 1
value | extension
stringclasses 11
values | total_lines
int64 1
340k
| avg_line_length
float64 2.18
149k
| max_line_length
int64 7
2.22M
| alphanum_fraction
float64 0
1
| repo_name
stringlengths 6
65
| repo_stars
int64 100
47.3k
| repo_forks
int64 0
12k
| repo_open_issues
int64 0
3.4k
| repo_license
stringclasses 9
values | repo_extraction_date
stringclasses 92
values | exact_duplicates_redpajama
bool 2
classes | near_duplicates_redpajama
bool 2
classes | exact_duplicates_githubcode
bool 2
classes | exact_duplicates_stackv2
bool 1
class | exact_duplicates_stackv1
bool 2
classes | near_duplicates_githubcode
bool 2
classes | near_duplicates_stackv1
bool 2
classes | near_duplicates_stackv2
bool 1
class |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
34,509
|
fogstate.cpp
|
OpenMW_openmw/components/esm3/fogstate.cpp
|
#include "fogstate.hpp"
#include "esmreader.hpp"
#include "esmwriter.hpp"
#include <osgDB/ReadFile>
#include <components/debug/debuglog.hpp>
#include <components/files/memorystream.hpp>
namespace ESM
{
namespace
{
void convertFogOfWar(std::vector<char>& imageData)
{
if (imageData.empty())
{
return;
}
osgDB::ReaderWriter* tgaReader = osgDB::Registry::instance()->getReaderWriterForExtension("tga");
if (!tgaReader)
{
Log(Debug::Error) << "Error: Unable to load fog, can't find a tga ReaderWriter";
return;
}
Files::IMemStream in(imageData.data(), imageData.size());
osgDB::ReaderWriter::ReadResult result = tgaReader->readImage(in);
if (!result.success())
{
Log(Debug::Error) << "Error: Failed to read fog: " << result.message() << " code " << result.status();
return;
}
osgDB::ReaderWriter* pngWriter = osgDB::Registry::instance()->getReaderWriterForExtension("png");
if (!pngWriter)
{
Log(Debug::Error) << "Error: Unable to write fog, can't find a png ReaderWriter";
return;
}
std::ostringstream ostream;
osgDB::ReaderWriter::WriteResult png = pngWriter->writeImage(*result.getImage(), ostream);
if (!png.success())
{
Log(Debug::Error) << "Error: Unable to write fog: " << png.message() << " code " << png.status();
return;
}
std::string str = ostream.str();
imageData = std::vector<char>(str.begin(), str.end());
}
}
void FogState::load(ESMReader& esm)
{
if (esm.isNextSub("BOUN"))
esm.getHT(mBounds.mMinX, mBounds.mMinY, mBounds.mMaxX, mBounds.mMaxY);
esm.getHNOT(mNorthMarkerAngle, "ANGL");
const FormatVersion dataFormat = esm.getFormatVersion();
while (esm.isNextSub("FTEX"))
{
esm.getSubHeader();
FogTexture tex;
esm.getT(tex.mX);
esm.getT(tex.mY);
const std::size_t imageSize = esm.getSubSize() - sizeof(int32_t) * 2;
tex.mImageData.resize(imageSize);
esm.getExact(tex.mImageData.data(), imageSize);
if (dataFormat <= MaxOldFogOfWarFormatVersion)
convertFogOfWar(tex.mImageData);
mFogTextures.push_back(tex);
}
}
void FogState::save(ESMWriter& esm, bool interiorCell) const
{
if (interiorCell)
{
esm.writeHNT("BOUN", mBounds);
esm.writeHNT("ANGL", mNorthMarkerAngle);
}
for (std::vector<FogTexture>::const_iterator it = mFogTextures.begin(); it != mFogTextures.end(); ++it)
{
esm.startSubRecord("FTEX");
esm.writeT(it->mX);
esm.writeT(it->mY);
esm.write(it->mImageData.data(), it->mImageData.size());
esm.endRecord("FTEX");
}
}
}
| 3,154
|
C++
|
.cpp
| 83
| 27.192771
| 118
| 0.552899
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,510
|
magiceffects.cpp
|
OpenMW_openmw/components/esm3/magiceffects.cpp
|
#include "magiceffects.hpp"
#include "esmreader.hpp"
#include "esmwriter.hpp"
namespace ESM
{
void MagicEffects::save(ESMWriter& esm) const
{
for (const auto& [key, params] : mEffects)
{
esm.writeHNT("EFID", key);
esm.writeHNT("BASE", params.first);
esm.writeHNT("MODI", params.second);
}
}
void MagicEffects::load(ESMReader& esm)
{
while (esm.isNextSub("EFID"))
{
int32_t id;
std::pair<int32_t, float> params;
esm.getHT(id);
esm.getHNT(params.first, "BASE");
if (esm.getFormatVersion() <= MaxClearModifiersFormatVersion)
params.second = 0.f;
else
esm.getHNT(params.second, "MODI");
mEffects.emplace(id, params);
}
}
}
| 848
|
C++
|
.cpp
| 30
| 19.633333
| 73
| 0.547355
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,511
|
locals.cpp
|
OpenMW_openmw/components/esm3/locals.cpp
|
#include "locals.hpp"
#include "esmreader.hpp"
#include "esmwriter.hpp"
namespace ESM
{
void Locals::load(ESMReader& esm)
{
while (esm.isNextSub("LOCA"))
{
std::string id = esm.getHString();
Variant value;
value.read(esm, Variant::Format_Local);
mVariables.emplace_back(id, value);
}
}
void Locals::save(ESMWriter& esm) const
{
for (std::vector<std::pair<std::string, Variant>>::const_iterator iter(mVariables.begin());
iter != mVariables.end(); ++iter)
{
esm.writeHNString("LOCA", iter->first);
iter->second.write(esm, Variant::Format_Local);
}
}
}
| 714
|
C++
|
.cpp
| 25
| 21
| 99
| 0.573314
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,512
|
npcstats.cpp
|
OpenMW_openmw/components/esm3/npcstats.cpp
|
#include "npcstats.hpp"
#include "esmreader.hpp"
#include "esmwriter.hpp"
namespace ESM
{
NpcStats::Faction::Faction()
: mExpelled(false)
, mRank(-1)
, mReputation(0)
{
}
void NpcStats::load(ESMReader& esm)
{
while (esm.isNextSub("FACT"))
{
ESM::RefId id = esm.getRefId();
Faction faction;
int32_t expelled = 0;
esm.getHNOT(expelled, "FAEX");
if (expelled)
faction.mExpelled = true;
esm.getHNOT(faction.mRank, "FARA");
esm.getHNOT(faction.mReputation, "FARE");
mFactions.emplace(id, faction);
}
mDisposition = 0;
esm.getHNOT(mDisposition, "DISP");
mCrimeDispositionModifier = 0;
esm.getHNOT(mCrimeDispositionModifier, "DISM");
const bool intFallback = esm.getFormatVersion() <= MaxIntFallbackFormatVersion;
for (auto& skill : mSkills)
skill.load(esm, intFallback);
mIsWerewolf = false;
esm.getHNOT(mIsWerewolf, "WOLF");
mBounty = 0;
esm.getHNOT(mBounty, "BOUN");
mReputation = 0;
esm.getHNOT(mReputation, "REPU");
mWerewolfKills = 0;
esm.getHNOT(mWerewolfKills, "WKIL");
mLevelProgress = 0;
esm.getHNOT(mLevelProgress, "LPRO");
mSkillIncrease.fill(0);
esm.getHNOT(mSkillIncrease, "INCR");
mSpecIncreases.fill(0);
esm.getHNOT(mSpecIncreases, "SPEC");
while (esm.isNextSub("USED"))
mUsedIds.push_back(esm.getRefId());
mTimeToStartDrowning = 0;
esm.getHNOT(mTimeToStartDrowning, "DRTI");
mCrimeId = -1;
esm.getHNOT(mCrimeId, "CRID");
}
void NpcStats::save(ESMWriter& esm) const
{
for (const auto& [id, faction] : mFactions)
{
esm.writeHNRefId("FACT", id);
if (faction.mExpelled)
{
int32_t expelled = 1;
esm.writeHNT("FAEX", expelled);
}
if (faction.mRank >= 0)
esm.writeHNT("FARA", faction.mRank);
if (faction.mReputation)
esm.writeHNT("FARE", faction.mReputation);
}
if (mDisposition)
esm.writeHNT("DISP", mDisposition);
if (mCrimeDispositionModifier)
esm.writeHNT("DISM", mCrimeDispositionModifier);
for (const auto& skill : mSkills)
skill.save(esm);
if (mIsWerewolf)
esm.writeHNT("WOLF", mIsWerewolf);
if (mBounty)
esm.writeHNT("BOUN", mBounty);
if (mReputation)
esm.writeHNT("REPU", mReputation);
if (mWerewolfKills)
esm.writeHNT("WKIL", mWerewolfKills);
if (mLevelProgress)
esm.writeHNT("LPRO", mLevelProgress);
bool saveSkillIncreases = false;
for (int32_t increase : mSkillIncrease)
{
if (increase != 0)
{
saveSkillIncreases = true;
break;
}
}
if (saveSkillIncreases)
esm.writeHNT("INCR", mSkillIncrease);
if (mSpecIncreases[0] != 0 || mSpecIncreases[1] != 0 || mSpecIncreases[2] != 0)
esm.writeHNT("SPEC", mSpecIncreases);
for (const RefId& id : mUsedIds)
esm.writeHNRefId("USED", id);
if (mTimeToStartDrowning)
esm.writeHNT("DRTI", mTimeToStartDrowning);
if (mCrimeId != -1)
esm.writeHNT("CRID", mCrimeId);
}
void NpcStats::blank()
{
mIsWerewolf = false;
mDisposition = 0;
mCrimeDispositionModifier = 0;
mBounty = 0;
mReputation = 0;
mWerewolfKills = 0;
mLevelProgress = 0;
mSkillIncrease.fill(0);
mSpecIncreases.fill(0);
mTimeToStartDrowning = 20;
mCrimeId = -1;
}
}
| 3,956
|
C++
|
.cpp
| 119
| 23.151261
| 87
| 0.557839
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,513
|
creaturelevliststate.cpp
|
OpenMW_openmw/components/esm3/creaturelevliststate.cpp
|
#include "creaturelevliststate.hpp"
#include "esmreader.hpp"
#include "esmwriter.hpp"
namespace ESM
{
void CreatureLevListState::load(ESMReader& esm)
{
ObjectState::load(esm);
mSpawnActorId = -1;
esm.getHNOT(mSpawnActorId, "SPAW");
mSpawn = false;
esm.getHNOT(mSpawn, "RESP");
}
void CreatureLevListState::save(ESMWriter& esm, bool inInventory) const
{
ObjectState::save(esm, inInventory);
if (mSpawnActorId != -1)
esm.writeHNT("SPAW", mSpawnActorId);
if (mSpawn)
esm.writeHNT("RESP", mSpawn);
}
}
| 619
|
C++
|
.cpp
| 22
| 21.636364
| 75
| 0.632653
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| true
| false
| true
| true
| true
| false
|
34,514
|
loadfact.cpp
|
OpenMW_openmw/components/esm3/loadfact.cpp
|
#include "loadfact.hpp"
#include <stdexcept>
#include "esmreader.hpp"
#include "esmwriter.hpp"
namespace ESM
{
int32_t& Faction::FADTstruct::getSkill(size_t index, bool)
{
return mSkills.at(index);
}
int32_t Faction::FADTstruct::getSkill(size_t index, bool) const
{
return mSkills.at(index);
}
void RankData::load(ESMReader& esm)
{
esm.getT(mAttribute1);
esm.getT(mAttribute2);
esm.getT(mPrimarySkill);
esm.getT(mFavouredSkill);
esm.getT(mFactReaction);
}
void RankData::save(ESMWriter& esm) const
{
esm.writeT(mAttribute1);
esm.writeT(mAttribute2);
esm.writeT(mPrimarySkill);
esm.writeT(mFavouredSkill);
esm.writeT(mFactReaction);
}
void Faction::FADTstruct::load(ESMReader& esm)
{
esm.getSubHeader();
esm.getT(mAttribute);
for (auto& rank : mRankData)
rank.load(esm);
esm.getT(mSkills);
esm.getT(mIsHidden);
if (mIsHidden > 1)
esm.fail("Unknown flag!");
}
void Faction::FADTstruct::save(ESMWriter& esm) const
{
esm.startSubRecord("FADT");
esm.writeT(mAttribute);
for (const auto& rank : mRankData)
rank.save(esm);
esm.writeT(mSkills);
esm.writeT(mIsHidden);
esm.endRecord("FADT");
}
void Faction::load(ESMReader& esm, bool& isDeleted)
{
isDeleted = false;
mRecordFlags = esm.getRecordFlags();
mReactions.clear();
for (auto& rank : mRanks)
rank.clear();
size_t rankCounter = 0;
bool hasName = false;
bool hasData = false;
while (esm.hasMoreSubs())
{
esm.getSubName();
switch (esm.retSubName().toInt())
{
case SREC_NAME:
mId = esm.getRefId();
hasName = true;
break;
case fourCC("FNAM"):
mName = esm.getHString();
break;
case fourCC("RNAM"):
if (rankCounter >= mRanks.size())
esm.fail("Rank out of range");
mRanks[rankCounter++] = esm.getHString();
break;
case fourCC("FADT"):
mData.load(esm);
hasData = true;
break;
case fourCC("ANAM"):
{
ESM::RefId faction = esm.getRefId();
int32_t reaction;
esm.getHNT(reaction, "INTV");
// Prefer the lowest reaction in case a faction is listed multiple times
auto it = mReactions.find(faction);
if (it == mReactions.end())
mReactions.emplace(faction, reaction);
else if (it->second > reaction)
it->second = reaction;
break;
}
case SREC_DELE:
esm.skipHSub();
isDeleted = true;
break;
default:
esm.fail("Unknown subrecord");
break;
}
}
if (!hasName)
esm.fail("Missing NAME subrecord");
if (!hasData && !isDeleted)
esm.fail("Missing FADT subrecord");
}
void Faction::save(ESMWriter& esm, bool isDeleted) const
{
esm.writeHNCRefId("NAME", mId);
if (isDeleted)
{
esm.writeHNString("DELE", "", 3);
return;
}
esm.writeHNOCString("FNAM", mName);
for (const auto& rank : mRanks)
{
if (rank.empty())
break;
esm.writeHNString("RNAM", rank, 32);
}
mData.save(esm);
for (auto it = mReactions.begin(); it != mReactions.end(); ++it)
{
esm.writeHNRefId("ANAM", it->first);
esm.writeHNT("INTV", it->second);
}
}
void Faction::blank()
{
mRecordFlags = 0;
mName.clear();
mData.mAttribute.fill(0);
mData.mIsHidden = 0;
for (size_t i = 0; i < mData.mRankData.size(); ++i)
{
mData.mRankData[i].mAttribute1 = mData.mRankData[i].mAttribute2 = 0;
mData.mRankData[i].mPrimarySkill = mData.mRankData[i].mFavouredSkill = 0;
mData.mRankData[i].mFactReaction = 0;
mRanks[i].clear();
}
mData.mSkills.fill(0);
mReactions.clear();
}
}
| 4,680
|
C++
|
.cpp
| 148
| 20.216216
| 92
| 0.499335
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,515
|
loadcont.cpp
|
OpenMW_openmw/components/esm3/loadcont.cpp
|
#include "loadcont.hpp"
#include "components/esm/defs.hpp"
#include "esmreader.hpp"
#include "esmwriter.hpp"
namespace ESM
{
void InventoryList::add(ESMReader& esm)
{
esm.getSubHeader();
ContItem ci;
esm.getT(ci.mCount);
ci.mItem = esm.getMaybeFixedRefIdSize(32);
mList.push_back(ci);
}
void InventoryList::save(ESMWriter& esm) const
{
for (std::vector<ContItem>::const_iterator it = mList.begin(); it != mList.end(); ++it)
{
esm.startSubRecord("NPCO");
esm.writeT(it->mCount);
esm.writeMaybeFixedSizeRefId(it->mItem, 32);
esm.endRecord("NPCO");
}
}
void Container::load(ESMReader& esm, bool& isDeleted)
{
isDeleted = false;
mRecordFlags = esm.getRecordFlags();
mInventory.mList.clear();
bool hasName = false;
bool hasWeight = false;
bool hasFlags = false;
while (esm.hasMoreSubs())
{
esm.getSubName();
switch (esm.retSubName().toInt())
{
case SREC_NAME:
mId = esm.getRefId();
hasName = true;
break;
case fourCC("MODL"):
mModel = esm.getHString();
break;
case fourCC("FNAM"):
mName = esm.getHString();
break;
case fourCC("CNDT"):
esm.getHT(mWeight);
hasWeight = true;
break;
case fourCC("FLAG"):
esm.getHT(mFlags);
if (mFlags & 0xf4)
esm.fail("Unknown flags");
if (!(mFlags & 0x8))
esm.fail("Flag 8 not set");
hasFlags = true;
break;
case fourCC("SCRI"):
mScript = esm.getRefId();
break;
case fourCC("NPCO"):
mInventory.add(esm);
break;
case SREC_DELE:
esm.skipHSub();
isDeleted = true;
break;
default:
esm.fail("Unknown subrecord");
break;
}
}
if (!hasName)
esm.fail("Missing NAME subrecord");
if (!hasWeight && !isDeleted)
esm.fail("Missing CNDT subrecord");
if (!hasFlags && !isDeleted)
esm.fail("Missing FLAG subrecord");
}
void Container::save(ESMWriter& esm, bool isDeleted) const
{
esm.writeHNCRefId("NAME", mId);
if (isDeleted)
{
esm.writeHNString("DELE", "", 3);
return;
}
esm.writeHNCString("MODL", mModel);
esm.writeHNOCString("FNAM", mName);
esm.writeHNT("CNDT", mWeight);
esm.writeHNT("FLAG", mFlags);
esm.writeHNOCRefId("SCRI", mScript);
mInventory.save(esm);
}
void Container::blank()
{
mRecordFlags = 0;
mName.clear();
mModel.clear();
mScript = ESM::RefId();
mWeight = 0;
mFlags = 0x8; // set default flag value
mInventory.mList.clear();
}
}
| 3,356
|
C++
|
.cpp
| 107
| 19.168224
| 95
| 0.47357
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,516
|
loadinfo.cpp
|
OpenMW_openmw/components/esm3/loadinfo.cpp
|
#include "loadinfo.hpp"
#include "esmreader.hpp"
#include "esmwriter.hpp"
#include <components/misc/concepts.hpp>
namespace ESM
{
template <Misc::SameAsWithoutCvref<DialInfo::DATAstruct> T>
void decompose(T&& v, const auto& f)
{
char padding = 0;
f(v.mType, v.mDisposition, v.mRank, v.mGender, v.mPCrank, padding);
}
void DialInfo::load(ESMReader& esm, bool& isDeleted)
{
mId = esm.getHNRefId("INAM");
isDeleted = false;
mQuestStatus = QS_None;
mFactionLess = false;
mPrev = esm.getHNRefId("PNAM");
mNext = esm.getHNRefId("NNAM");
while (esm.hasMoreSubs())
{
esm.getSubName();
switch (esm.retSubName().toInt())
{
case fourCC("DATA"):
esm.getSubComposite(mData);
break;
case fourCC("ONAM"):
mActor = esm.getRefId();
break;
case fourCC("RNAM"):
mRace = esm.getRefId();
break;
case fourCC("CNAM"):
mClass = esm.getRefId();
break;
case fourCC("FNAM"):
{
mFaction = esm.getRefId();
if (mFaction == "FFFF")
{
mFactionLess = true;
}
break;
}
case fourCC("ANAM"):
mCell = esm.getRefId();
break;
case fourCC("DNAM"):
mPcFaction = esm.getRefId();
break;
case fourCC("SNAM"):
mSound = esm.getHString();
break;
case SREC_NAME:
mResponse = esm.getHString();
break;
case fourCC("SCVR"):
{
auto filter = DialogueCondition::load(esm, mId);
if (filter)
mSelects.emplace_back(std::move(*filter));
break;
}
case fourCC("BNAM"):
mResultScript = esm.getHString();
break;
case fourCC("QSTN"):
mQuestStatus = QS_Name;
esm.skipRecord();
break;
case fourCC("QSTF"):
mQuestStatus = QS_Finished;
esm.skipRecord();
break;
case fourCC("QSTR"):
mQuestStatus = QS_Restart;
esm.skipRecord();
break;
case SREC_DELE:
esm.skipHSub();
isDeleted = true;
break;
default:
esm.fail("Unknown subrecord");
break;
}
}
}
void DialInfo::save(ESMWriter& esm, bool isDeleted) const
{
esm.writeHNCRefId("INAM", mId);
esm.writeHNCRefId("PNAM", mPrev);
esm.writeHNCRefId("NNAM", mNext);
if (isDeleted)
{
esm.writeHNString("DELE", "", 3);
return;
}
esm.writeNamedComposite("DATA", mData);
esm.writeHNOCRefId("ONAM", mActor);
esm.writeHNOCRefId("RNAM", mRace);
esm.writeHNOCRefId("CNAM", mClass);
esm.writeHNOCRefId("FNAM", mFaction);
esm.writeHNOCRefId("ANAM", mCell);
esm.writeHNOCRefId("DNAM", mPcFaction);
esm.writeHNOCString("SNAM", mSound);
esm.writeHNOString("NAME", mResponse);
for (const auto& rule : mSelects)
rule.save(esm);
esm.writeHNOString("BNAM", mResultScript);
switch (mQuestStatus)
{
case QS_Name:
esm.writeHNT("QSTN", '\1');
break;
case QS_Finished:
esm.writeHNT("QSTF", '\1');
break;
case QS_Restart:
esm.writeHNT("QSTR", '\1');
break;
default:
break;
}
}
void DialInfo::blank()
{
mData = {};
mSelects.clear();
mPrev = ESM::RefId();
mNext = ESM::RefId();
mActor = ESM::RefId();
mRace = ESM::RefId();
mClass = ESM::RefId();
mFaction = ESM::RefId();
mPcFaction = ESM::RefId();
mCell = ESM::RefId();
mSound.clear();
mResponse.clear();
mResultScript.clear();
mFactionLess = false;
mQuestStatus = QS_None;
}
}
| 4,722
|
C++
|
.cpp
| 146
| 18.684932
| 75
| 0.444298
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,517
|
esmwriter.cpp
|
OpenMW_openmw/components/esm3/esmwriter.cpp
|
#include "esmwriter.hpp"
#include <cassert>
#include <fstream>
#include <stdexcept>
#include <components/debug/debuglog.hpp>
#include <components/esm3/cellid.hpp>
#include <components/misc/notnullptr.hpp>
#include <components/to_utf8/to_utf8.hpp>
#include "formatversion.hpp"
namespace ESM
{
namespace
{
template <bool sizedString>
struct WriteRefId
{
ESMWriter& mWriter;
explicit WriteRefId(ESMWriter& writer)
: mWriter(writer)
{
}
void operator()(EmptyRefId /*v*/) const { mWriter.writeT(RefIdType::Empty); }
void operator()(StringRefId v) const
{
constexpr StringSizeType maxSize = std::numeric_limits<StringSizeType>::max();
if (v.getValue().size() > maxSize)
throw std::runtime_error("RefId string size is too long: \"" + v.getValue().substr(0, 64)
+ "<...>\" (" + std::to_string(v.getValue().size()) + " > " + std::to_string(maxSize) + ")");
if constexpr (sizedString)
{
mWriter.writeT(RefIdType::SizedString);
mWriter.writeT(static_cast<StringSizeType>(v.getValue().size()));
}
else
mWriter.writeT(RefIdType::UnsizedString);
mWriter.write(v.getValue().data(), v.getValue().size());
}
void operator()(FormId v) const
{
mWriter.writeT(RefIdType::FormId);
mWriter.writeT(v);
}
void operator()(GeneratedRefId v) const
{
mWriter.writeT(RefIdType::Generated);
mWriter.writeT(v.getValue());
}
void operator()(IndexRefId v) const
{
mWriter.writeT(RefIdType::Index);
mWriter.writeT(v.getRecordType());
mWriter.writeT(v.getValue());
}
void operator()(ESM3ExteriorCellRefId v) const
{
mWriter.writeT(RefIdType::ESM3ExteriorCell);
mWriter.writeT(v.getX());
mWriter.writeT(v.getY());
}
};
}
ESMWriter::ESMWriter()
: mRecords()
, mStream(nullptr)
, mHeaderPos()
, mEncoder(nullptr)
, mRecordCount(0)
, mCounting(true)
, mHeader()
{
}
unsigned int ESMWriter::getVersion() const
{
return mHeader.mData.version.ui;
}
void ESMWriter::setVersion(unsigned int ver)
{
mHeader.mData.version.ui = ver;
}
void ESMWriter::setType(int type)
{
mHeader.mData.type = type;
}
void ESMWriter::setAuthor(std::string_view auth)
{
mHeader.mData.author = auth;
}
void ESMWriter::setDescription(std::string_view desc)
{
mHeader.mData.desc = desc;
}
void ESMWriter::setRecordCount(int count)
{
mHeader.mData.records = count;
}
void ESMWriter::setFormatVersion(FormatVersion value)
{
mHeader.mFormatVersion = value;
}
void ESMWriter::clearMaster()
{
mHeader.mMaster.clear();
}
void ESMWriter::addMaster(std::string_view name, uint64_t size)
{
Header::MasterData d;
d.name = name;
d.size = size;
mHeader.mMaster.push_back(d);
}
void ESMWriter::save(std::ostream& file)
{
mRecordCount = 0;
mRecords.clear();
mCounting = true;
mStream = &file;
startRecord("TES3", 0);
mHeader.save(*this);
endRecord("TES3");
}
void ESMWriter::close()
{
if (!mRecords.empty())
throw std::runtime_error("Unclosed record remaining");
}
void ESMWriter::startRecord(NAME name, uint32_t flags)
{
mRecordCount++;
writeName(name);
RecordData rec;
rec.name = name;
rec.position = mStream->tellp();
rec.size = 0;
writeT<uint32_t>(0); // Size goes here
writeT<uint32_t>(0); // Unused header?
writeT(flags);
mRecords.push_back(rec);
assert(mRecords.back().size == 0);
}
void ESMWriter::startRecord(uint32_t name, uint32_t flags)
{
startRecord(NAME(name), flags);
}
void ESMWriter::startSubRecord(NAME name)
{
// Sub-record hierarchies are not properly supported in ESMReader. This should be fixed later.
assert(mRecords.size() <= 1);
writeName(name);
RecordData rec;
rec.name = name;
rec.position = mStream->tellp();
rec.size = 0;
writeT<uint32_t>(0); // Size goes here
mRecords.push_back(rec);
assert(mRecords.back().size == 0);
}
void ESMWriter::endRecord(NAME name)
{
RecordData rec = mRecords.back();
assert(rec.name == name);
mRecords.pop_back();
mStream->seekp(rec.position);
mCounting = false;
write(reinterpret_cast<const char*>(&rec.size), sizeof(uint32_t));
mCounting = true;
mStream->seekp(0, std::ios::end);
}
void ESMWriter::endRecord(uint32_t name)
{
endRecord(NAME(name));
}
void ESMWriter::writeHNString(NAME name, std::string_view data)
{
startSubRecord(name);
writeHString(data);
endRecord(name);
}
void ESMWriter::writeHNString(NAME name, std::string_view data, size_t size)
{
assert(data.size() <= size);
startSubRecord(name);
writeHString(data);
if (data.size() < size)
{
for (size_t i = data.size(); i < size; ++i)
write("\0", 1);
}
endRecord(name);
}
void ESMWriter::writeHNRefId(NAME name, RefId value)
{
startSubRecord(name);
writeHRefId(value);
endRecord(name);
}
void ESMWriter::writeHNRefId(NAME name, RefId value, std::size_t size)
{
if (mHeader.mFormatVersion <= MaxStringRefIdFormatVersion)
return writeHNString(name, value.getRefIdString(), size);
writeHNRefId(name, value);
}
void ESMWriter::writeCellId(const ESM::RefId& cellId)
{
if (mHeader.mFormatVersion <= ESM::MaxUseEsmCellIdFormatVersion)
{
ESM::CellId generatedCellid = ESM::CellId::extractFromRefId(cellId);
generatedCellid.save(*this);
}
else
writeHNRefId("NAME", cellId);
}
void ESMWriter::writeMaybeFixedSizeString(const std::string& data, std::size_t size)
{
std::string string;
if (!data.empty())
string = mEncoder ? mEncoder->getLegacyEnc(data) : data;
if (mHeader.mFormatVersion <= MaxLimitedSizeStringsFormatVersion)
{
if (string.size() > size)
throw std::runtime_error("Fixed string data is too long: \"" + string + "\" ("
+ std::to_string(string.size()) + " > " + std::to_string(size) + ")");
string.resize(size);
}
else
{
constexpr StringSizeType maxSize = std::numeric_limits<StringSizeType>::max();
if (string.size() > maxSize)
throw std::runtime_error("String size is too long: \"" + string.substr(0, 64) + "<...>\" ("
+ std::to_string(string.size()) + " > " + std::to_string(maxSize) + ")");
writeT(static_cast<StringSizeType>(string.size()));
}
write(string.c_str(), string.size());
}
void ESMWriter::writeHString(std::string_view data)
{
if (data.empty())
write("\0", 1);
else
{
// Convert to UTF8 and return
const std::string_view string = mEncoder != nullptr ? mEncoder->getLegacyEnc(data) : data;
write(string.data(), string.size());
}
}
void ESMWriter::writeHCString(std::string_view data)
{
writeHString(data);
if (data.size() > 0 && data[data.size() - 1] != '\0')
write("\0", 1);
}
void ESMWriter::writeMaybeFixedSizeRefId(RefId value, std::size_t size)
{
if (mHeader.mFormatVersion <= MaxStringRefIdFormatVersion)
return writeMaybeFixedSizeString(value.getRefIdString(), size);
visit(WriteRefId<true>(*this), value);
}
void ESMWriter::writeHRefId(RefId value)
{
if (mHeader.mFormatVersion <= MaxStringRefIdFormatVersion)
return writeHString(value.getRefIdString());
writeRefId(value);
}
void ESMWriter::writeHCRefId(RefId value)
{
if (mHeader.mFormatVersion <= MaxStringRefIdFormatVersion)
return writeHCString(value.getRefIdString());
writeRefId(value);
}
void ESMWriter::writeRefId(RefId value)
{
visit(WriteRefId<false>(*this), value);
}
void ESMWriter::writeName(NAME name)
{
write(name.mData, NAME::sCapacity);
}
void ESMWriter::write(const char* data, size_t size)
{
if (mCounting && !mRecords.empty())
{
for (std::list<RecordData>::iterator it = mRecords.begin(); it != mRecords.end(); ++it)
it->size += static_cast<uint32_t>(size);
}
mStream->write(data, size);
}
void ESMWriter::writeFormId(const FormId& formId, bool wide, NAME tag)
{
if (wide)
writeHNT(tag, formId, 8);
else
writeHNT(tag, formId.toUint32(), 4);
}
void ESMWriter::setEncoder(ToUTF8::Utf8Encoder* encoder)
{
mEncoder = encoder;
}
}
| 9,728
|
C++
|
.cpp
| 297
| 23.787879
| 117
| 0.569722
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,518
|
spellstate.cpp
|
OpenMW_openmw/components/esm3/spellstate.cpp
|
#include "spellstate.hpp"
#include "esmreader.hpp"
#include "esmwriter.hpp"
namespace ESM
{
void SpellState::load(ESMReader& esm)
{
if (esm.getFormatVersion() <= MaxClearModifiersFormatVersion)
{
while (esm.isNextSub("SPEL"))
{
ESM::RefId id = esm.getRefId();
SpellParams state;
while (esm.isNextSub("INDX"))
{
int32_t index;
esm.getHT(index);
float magnitude;
esm.getHNT(magnitude, "RAND");
state.mEffectRands[index] = magnitude;
}
while (esm.isNextSub("PURG"))
{
int32_t index;
esm.getHT(index);
state.mPurgedEffects.insert(index);
}
mSpellParams[id] = std::move(state);
mSpells.emplace_back(id);
}
}
else
{
while (esm.isNextSub("SPEL"))
mSpells.emplace_back(esm.getRefId());
}
// Obsolete
while (esm.isNextSub("PERM"))
{
ESM::RefId spellId = esm.getRefId();
std::vector<PermanentSpellEffectInfo> permEffectList;
while (true)
{
ESM_Context restorePoint = esm.getContext();
if (!esm.isNextSub("EFID"))
break;
PermanentSpellEffectInfo info;
esm.getHT(info.mId);
if (esm.isNextSub("BASE"))
{
esm.restoreContext(restorePoint);
return;
}
else
esm.getHNT(info.mArg, "ARG_");
esm.getHNT(info.mMagnitude, "MAGN");
permEffectList.push_back(info);
}
mPermanentSpellEffects[spellId] = std::move(permEffectList);
}
// Obsolete
while (esm.isNextSub("CORP"))
{
ESM::RefId id = esm.getRefId();
CorprusStats stats;
esm.getHNT(stats.mWorsenings, "WORS");
stats.mNextWorsening.load(esm);
mCorprusSpells[id] = stats;
}
while (esm.isNextSub("USED"))
{
ESM::RefId id = esm.getRefId();
mUsedPowers[id].load(esm);
}
mSelectedSpell = esm.getHNORefId("SLCT");
}
void SpellState::save(ESMWriter& esm) const
{
for (const ESM::RefId& spell : mSpells)
esm.writeHNRefId("SPEL", spell);
for (auto it = mUsedPowers.begin(); it != mUsedPowers.end(); ++it)
{
esm.writeHNRefId("USED", it->first);
esm.writeHNT("TIME", it->second);
}
if (!mSelectedSpell.empty())
esm.writeHNRefId("SLCT", mSelectedSpell);
}
}
| 2,933
|
C++
|
.cpp
| 89
| 20.067416
| 74
| 0.481219
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,519
|
loadtes3.cpp
|
OpenMW_openmw/components/esm3/loadtes3.cpp
|
#include "loadtes3.hpp"
#include "components/esm/esmcommon.hpp"
#include "esmreader.hpp"
#include "esmwriter.hpp"
namespace ESM
{
void Header::blank()
{
mData.version.ui = VER_130;
mData.type = 0;
mData.author.clear();
mData.desc.clear();
mData.records = 0;
mFormatVersion = CurrentContentFormatVersion;
mMaster.clear();
}
void Header::load(ESMReader& esm)
{
mFormatVersion = DefaultFormatVersion;
esm.getHNOT("FORM", mFormatVersion);
if (esm.isNextSub("HEDR"))
{
esm.getSubHeader();
esm.getT(mData.version.ui);
esm.getT(mData.type);
mData.author = esm.getMaybeFixedStringSize(32);
mData.desc = esm.getMaybeFixedStringSize(256);
esm.getT(mData.records);
}
while (esm.isNextSub("MAST"))
{
MasterData m;
m.name = esm.getHString();
esm.getHNT(m.size, "DATA");
mMaster.push_back(m);
}
esm.getHNOT("GMDT", mGameData.mCurrentHealth, mGameData.mMaximumHealth, mGameData.mHour, mGameData.unknown1,
mGameData.mCurrentCell.mData, mGameData.unknown2, mGameData.mPlayerName.mData);
if (esm.isNextSub("SCRD"))
{
esm.getSubHeader();
mSCRD.resize(esm.getSubSize());
if (!mSCRD.empty())
esm.getExact(mSCRD.data(), mSCRD.size());
}
if (esm.isNextSub("SCRS"))
{
esm.getSubHeader();
mSCRS.resize(esm.getSubSize());
if (!mSCRS.empty())
esm.getExact(mSCRS.data(), mSCRS.size());
}
}
void Header::save(ESMWriter& esm)
{
if (mFormatVersion > DefaultFormatVersion)
esm.writeHNT("FORM", mFormatVersion);
esm.startSubRecord("HEDR");
esm.writeT(mData.version);
esm.writeT(mData.type);
esm.writeMaybeFixedSizeString(mData.author, 32);
esm.writeMaybeFixedSizeString(mData.desc, 256);
esm.writeT(mData.records);
esm.endRecord("HEDR");
for (const Header::MasterData& data : mMaster)
{
esm.writeHNCString("MAST", data.name);
esm.writeHNT("DATA", data.size);
}
}
}
| 2,315
|
C++
|
.cpp
| 71
| 23.394366
| 116
| 0.577698
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,520
|
debugprofile.cpp
|
OpenMW_openmw/components/esm3/debugprofile.cpp
|
#include "debugprofile.hpp"
#include "esmreader.hpp"
#include "esmwriter.hpp"
namespace ESM
{
void DebugProfile::load(ESMReader& esm, bool& isDeleted)
{
isDeleted = false;
mRecordFlags = esm.getRecordFlags();
while (esm.hasMoreSubs())
{
esm.getSubName();
switch (esm.retSubName().toInt())
{
case SREC_NAME:
mId = esm.getRefId();
break;
case fourCC("DESC"):
mDescription = esm.getHString();
break;
case fourCC("SCRP"):
mScriptText = esm.getHString();
break;
case fourCC("FLAG"):
esm.getHT(mFlags);
break;
case SREC_DELE:
esm.skipHSub();
isDeleted = true;
break;
default:
esm.fail("Unknown subrecord");
break;
}
}
}
void DebugProfile::save(ESMWriter& esm, bool isDeleted) const
{
esm.writeHNCRefId("NAME", mId);
if (isDeleted)
{
esm.writeHNString("DELE", "", 3);
return;
}
esm.writeHNCString("DESC", mDescription);
esm.writeHNCString("SCRP", mScriptText);
esm.writeHNT("FLAG", mFlags);
}
void DebugProfile::blank()
{
mDescription.clear();
mScriptText.clear();
mFlags = 0;
}
}
| 1,567
|
C++
|
.cpp
| 55
| 16.709091
| 65
| 0.466401
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,521
|
cellref.cpp
|
OpenMW_openmw/components/esm3/cellref.cpp
|
#include "cellref.hpp"
#include <algorithm>
#include <limits>
#include <components/debug/debuglog.hpp>
#include "esmreader.hpp"
#include "esmwriter.hpp"
namespace
{
constexpr int ZeroLock = std::numeric_limits<int>::max();
}
namespace ESM
{
namespace
{
template <bool load>
void loadIdImpl(ESMReader& esm, bool wideRefNum, CellRef& cellRef)
{
// According to Hrnchamd, this does not belong to the actual ref. Instead, it is a marker indicating that
// the following refs are part of a "temp refs" section. A temp ref is not being tracked by the moved
// references system. Its only purpose is a performance optimization for "immovable" things. We don't need
// this, and it's problematic anyway, because any item can theoretically be moved by a script.
if (esm.isNextSub("NAM0"))
esm.skipHSub();
if constexpr (load)
{
cellRef.blank();
cellRef.mRefNum = esm.getFormId(wideRefNum);
cellRef.mRefID = esm.getHNORefId("NAME");
if (cellRef.mRefID.empty())
Log(Debug::Warning) << "Warning: got CellRef with empty RefId in " << esm.getName() << " 0x"
<< std::hex << esm.getFileOffset();
}
else
{
esm.getFormId(wideRefNum);
esm.skipHNORefId("NAME");
}
}
template <bool load>
void loadDataImpl(ESMReader& esm, bool& isDeleted, CellRef& cellRef)
{
const auto getRefIdOrSkip = [&](ESM::RefId& refId) {
if constexpr (load)
refId = esm.getRefId();
else
esm.skipHRefId();
};
const auto getHStringOrSkip = [&](std::string& value) {
if constexpr (load)
value = esm.getHString();
else
esm.skipHString();
};
const auto getHTOrSkip = [&](auto& value) {
if constexpr (load)
esm.getHT(value);
else
esm.skipHT<std::decay_t<decltype(value)>>();
};
if constexpr (load)
isDeleted = false;
bool isLoaded = false;
while (!isLoaded && esm.hasMoreSubs())
{
esm.getSubName();
switch (esm.retSubName().toInt())
{
case fourCC("UNAM"):
getHTOrSkip(cellRef.mReferenceBlocked);
break;
case fourCC("XSCL"):
getHTOrSkip(cellRef.mScale);
if constexpr (load)
cellRef.mScale = std::clamp(cellRef.mScale, 0.5f, 2.0f);
break;
case fourCC("ANAM"):
getRefIdOrSkip(cellRef.mOwner);
break;
case fourCC("BNAM"):
getHStringOrSkip(cellRef.mGlobalVariable);
break;
case fourCC("XSOL"):
getRefIdOrSkip(cellRef.mSoul);
break;
case fourCC("CNAM"):
getRefIdOrSkip(cellRef.mFaction);
break;
case fourCC("INDX"):
getHTOrSkip(cellRef.mFactionRank);
break;
case fourCC("XCHG"):
getHTOrSkip(cellRef.mEnchantmentCharge);
break;
case fourCC("INTV"):
getHTOrSkip(cellRef.mChargeInt);
break;
case fourCC("NAM9"):
getHTOrSkip(cellRef.mCount);
break;
case fourCC("DODT"):
if constexpr (load)
{
esm.getSubComposite(cellRef.mDoorDest);
cellRef.mTeleport = true;
}
else
esm.skipHSub();
break;
case fourCC("DNAM"):
getHStringOrSkip(cellRef.mDestCell);
break;
case fourCC("FLTV"):
getHTOrSkip(cellRef.mLockLevel);
break;
case fourCC("KNAM"):
getRefIdOrSkip(cellRef.mKey);
break;
case fourCC("TNAM"):
getRefIdOrSkip(cellRef.mTrap);
break;
case fourCC("DATA"):
if constexpr (load)
esm.getSubComposite(cellRef.mPos);
else
esm.skipHSub();
break;
case fourCC("NAM0"):
{
esm.skipHSub();
break;
}
case SREC_DELE:
esm.skipHSub();
if constexpr (load)
isDeleted = true;
break;
default:
esm.cacheSubName();
isLoaded = true;
break;
}
}
if constexpr (load)
{
if (esm.getFormatVersion() == DefaultFormatVersion) // loading a content file
cellRef.mIsLocked = !cellRef.mKey.empty() || cellRef.mLockLevel > 0;
else
cellRef.mIsLocked = cellRef.mLockLevel > 0;
if (cellRef.mLockLevel == ZeroLock)
cellRef.mLockLevel = 0;
}
}
}
void CellRef::load(ESMReader& esm, bool& isDeleted, bool wideRefNum)
{
loadId(esm, wideRefNum);
loadData(esm, isDeleted);
}
void CellRef::loadId(ESMReader& esm, bool wideRefNum)
{
loadIdImpl<true>(esm, wideRefNum, *this);
}
void CellRef::loadData(ESMReader& esm, bool& isDeleted)
{
loadDataImpl<true>(esm, isDeleted, *this);
}
void CellRef::save(ESMWriter& esm, bool wideRefNum, bool inInventory, bool isDeleted) const
{
esm.writeFormId(mRefNum, wideRefNum);
esm.writeHNCRefId("NAME", mRefID);
if (isDeleted)
{
esm.writeHNString("DELE", "", 3);
return;
}
if (mScale != 1.0)
{
esm.writeHNT("XSCL", std::clamp(mScale, 0.5f, 2.0f));
}
if (!inInventory)
esm.writeHNOCRefId("ANAM", mOwner);
esm.writeHNOCString("BNAM", mGlobalVariable);
esm.writeHNOCRefId("XSOL", mSoul);
if (!inInventory)
{
esm.writeHNOCRefId("CNAM", mFaction);
if (mFactionRank != -2)
{
esm.writeHNT("INDX", mFactionRank);
}
}
if (mEnchantmentCharge != -1)
esm.writeHNT("XCHG", mEnchantmentCharge);
if (mChargeInt != -1)
esm.writeHNT("INTV", mChargeInt);
if (mCount != 1)
esm.writeHNT("NAM9", mCount);
if (!inInventory && mTeleport)
{
esm.writeNamedComposite("DODT", mDoorDest);
esm.writeHNOCString("DNAM", mDestCell);
}
if (!inInventory)
{
if (mIsLocked)
{
int lockLevel = mLockLevel;
if (lockLevel == 0)
lockLevel = ZeroLock;
esm.writeHNT("FLTV", lockLevel);
esm.writeHNOCRefId("KNAM", mKey);
}
esm.writeHNOCRefId("TNAM", mTrap);
}
if (mReferenceBlocked != -1)
esm.writeHNT("UNAM", mReferenceBlocked);
if (!inInventory)
esm.writeNamedComposite("DATA", mPos);
}
void CellRef::blank()
{
mRefNum = RefNum{};
mRefID = ESM::RefId();
mScale = 1;
mOwner = ESM::RefId();
mGlobalVariable.clear();
mSoul = ESM::RefId();
mFaction = ESM::RefId();
mFactionRank = -2;
mChargeInt = -1;
mChargeIntRemainder = 0.0f;
mEnchantmentCharge = -1;
mCount = 1;
mDestCell.clear();
mLockLevel = 0;
mIsLocked = false;
mKey = ESM::RefId();
mTrap = ESM::RefId();
mReferenceBlocked = -1;
mTeleport = false;
for (int i = 0; i < 3; ++i)
{
mDoorDest.pos[i] = 0;
mDoorDest.rot[i] = 0;
mPos.pos[i] = 0;
mPos.rot[i] = 0;
}
}
void skipLoadCellRef(ESMReader& esm, bool wideRefNum)
{
CellRef cellRef;
loadIdImpl<false>(esm, wideRefNum, cellRef);
bool isDeleted;
loadDataImpl<false>(esm, isDeleted, cellRef);
}
CellRef makeBlankCellRef()
{
CellRef result;
result.blank();
return result;
}
}
| 9,363
|
C++
|
.cpp
| 262
| 20.958015
| 118
| 0.46024
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,522
|
cellid.cpp
|
OpenMW_openmw/components/esm3/cellid.cpp
|
#include "cellid.hpp"
#include "esmreader.hpp"
#include "esmwriter.hpp"
#include <components/misc/algorithm.hpp>
#include <components/misc/concepts.hpp>
namespace ESM
{
template <Misc::SameAsWithoutCvref<CellId::CellIndex> T>
void decompose(T&& v, const auto& f)
{
f(v.mX, v.mY);
}
void CellId::load(ESMReader& esm)
{
mWorldspace = esm.getHNString("SPAC");
mIndex.mX = 0;
mIndex.mY = 0;
mPaged = esm.getOptionalComposite("CIDX", mIndex);
}
void CellId::save(ESMWriter& esm) const
{
esm.writeHNString("SPAC", mWorldspace);
if (mPaged)
esm.writeNamedComposite("CIDX", mIndex);
}
struct VisitCellRefId
{
CellId operator()(const ESM::EmptyRefId)
{
CellId out;
out.mPaged = true;
out.mIndex = {};
return out;
}
CellId operator()(const ESM::StringRefId& id)
{
CellId out;
out.mPaged = false;
out.mWorldspace = id.getValue();
out.mIndex = { 0, 0 };
return out;
}
CellId operator()(const ESM::ESM3ExteriorCellRefId& id)
{
CellId out;
out.mPaged = true;
out.mIndex = { id.getX(), id.getY() };
return out;
}
template <typename T>
CellId operator()(const T& id)
{
throw std::runtime_error("cannot extract CellId from this Id type");
}
};
CellId CellId::extractFromRefId(const ESM::RefId& id)
{
// This is bad and that code should not be merged.
return visit(VisitCellRefId(), id);
}
bool operator==(const CellId& left, const CellId& right)
{
return left.mWorldspace == right.mWorldspace && left.mPaged == right.mPaged
&& (!left.mPaged || (left.mIndex.mX == right.mIndex.mX && left.mIndex.mY == right.mIndex.mY));
}
bool operator!=(const CellId& left, const CellId& right)
{
return !(left == right);
}
bool operator<(const CellId& left, const CellId& right)
{
if (left.mPaged < right.mPaged)
return true;
if (left.mPaged > right.mPaged)
return false;
if (left.mPaged)
{
if (left.mIndex.mX < right.mIndex.mX)
return true;
if (left.mIndex.mX > right.mIndex.mX)
return false;
if (left.mIndex.mY < right.mIndex.mY)
return true;
if (left.mIndex.mY > right.mIndex.mY)
return false;
}
return left.mWorldspace < right.mWorldspace;
}
}
| 2,701
|
C++
|
.cpp
| 89
| 21.640449
| 106
| 0.555513
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,523
|
loadcrea.cpp
|
OpenMW_openmw/components/esm3/loadcrea.cpp
|
#include "loadcrea.hpp"
#include <components/debug/debuglog.hpp>
#include <components/misc/concepts.hpp>
#include "esmreader.hpp"
#include "esmwriter.hpp"
namespace ESM
{
template <Misc::SameAsWithoutCvref<Creature::NPDTstruct> T>
void decompose(T&& v, const auto& f)
{
f(v.mType, v.mLevel, v.mAttributes, v.mHealth, v.mMana, v.mFatigue, v.mSoul, v.mCombat, v.mMagic, v.mStealth,
v.mAttack, v.mGold);
}
void Creature::load(ESMReader& esm, bool& isDeleted)
{
isDeleted = false;
mRecordFlags = esm.getRecordFlags();
mAiPackage.mList.clear();
mInventory.mList.clear();
mSpells.mList.clear();
mTransport.mList.clear();
mScale = 1.f;
mAiData.blank();
mAiData.mFight = 90;
mAiData.mFlee = 20;
bool hasName = false;
bool hasNpdt = false;
bool hasFlags = false;
while (esm.hasMoreSubs())
{
esm.getSubName();
switch (esm.retSubName().toInt())
{
case SREC_NAME:
mId = esm.getRefId();
hasName = true;
break;
case fourCC("MODL"):
mModel = esm.getHString();
break;
case fourCC("CNAM"):
mOriginal = esm.getRefId();
break;
case fourCC("FNAM"):
mName = esm.getHString();
break;
case fourCC("SCRI"):
mScript = esm.getRefId();
break;
case fourCC("NPDT"):
esm.getSubComposite(mData);
hasNpdt = true;
break;
case fourCC("FLAG"):
int flags;
esm.getHT(flags);
mFlags = flags & 0xFF;
mBloodType = ((flags >> 8) & 0xFF) >> 2;
hasFlags = true;
break;
case fourCC("XSCL"):
esm.getHT(mScale);
break;
case fourCC("NPCO"):
mInventory.add(esm);
break;
case fourCC("NPCS"):
mSpells.add(esm);
break;
case fourCC("AIDT"):
esm.getSubComposite(mAiData);
break;
case fourCC("DODT"):
case fourCC("DNAM"):
mTransport.add(esm);
break;
case AI_Wander:
case AI_Activate:
case AI_Escort:
case AI_Follow:
case AI_Travel:
case AI_CNDT:
mAiPackage.add(esm);
break;
case SREC_DELE:
esm.skipHSub();
isDeleted = true;
break;
case fourCC("INDX"):
// seems to occur only in .ESS files, unsure of purpose
int index;
esm.getHT(index);
Log(Debug::Warning) << "Creature::load: Unhandled INDX " << index;
break;
default:
esm.fail("Unknown subrecord");
break;
}
}
if (!hasName)
esm.fail("Missing NAME subrecord");
if (!hasNpdt && !isDeleted)
esm.fail("Missing NPDT subrecord");
if (!hasFlags && !isDeleted)
esm.fail("Missing FLAG subrecord");
}
void Creature::save(ESMWriter& esm, bool isDeleted) const
{
esm.writeHNCRefId("NAME", mId);
if (isDeleted)
{
esm.writeHNString("DELE", "", 3);
return;
}
esm.writeHNCString("MODL", mModel);
esm.writeHNOCRefId("CNAM", mOriginal);
esm.writeHNOCString("FNAM", mName);
esm.writeHNOCRefId("SCRI", mScript);
esm.writeNamedComposite("NPDT", mData);
esm.writeHNT("FLAG", ((mBloodType << 10) + mFlags));
if (mScale != 1.0)
{
esm.writeHNT("XSCL", mScale);
}
mInventory.save(esm);
mSpells.save(esm);
esm.writeNamedComposite("AIDT", mAiData);
mTransport.save(esm);
mAiPackage.save(esm);
}
void Creature::blank()
{
mRecordFlags = 0;
mData.mType = 0;
mData.mLevel = 0;
mData.mAttributes.fill(0);
mData.mHealth = mData.mMana = mData.mFatigue = 0;
mData.mSoul = 0;
mData.mCombat = mData.mMagic = mData.mStealth = 0;
for (int i = 0; i < 6; ++i)
mData.mAttack[i] = 0;
mData.mGold = 0;
mBloodType = 0;
mFlags = 0;
mScale = 1.f;
mModel.clear();
mName.clear();
mScript = ESM::RefId();
mOriginal = ESM::RefId();
mInventory.mList.clear();
mSpells.mList.clear();
mAiData.blank();
mAiData.mFight = 90;
mAiData.mFlee = 20;
mAiPackage.mList.clear();
mTransport.mList.clear();
}
const std::vector<Transport::Dest>& Creature::getTransport() const
{
return mTransport.mList;
}
}
| 5,347
|
C++
|
.cpp
| 162
| 20.216049
| 117
| 0.471862
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,524
|
loadbody.cpp
|
OpenMW_openmw/components/esm3/loadbody.cpp
|
#include "loadbody.hpp"
#include "esmreader.hpp"
#include "esmwriter.hpp"
#include <components/misc/concepts.hpp>
namespace ESM
{
template <Misc::SameAsWithoutCvref<BodyPart::BYDTstruct> T>
void decompose(T&& v, const auto& f)
{
f(v.mPart, v.mVampire, v.mFlags, v.mType);
}
void BodyPart::load(ESMReader& esm, bool& isDeleted)
{
isDeleted = false;
mRecordFlags = esm.getRecordFlags();
bool hasName = false;
bool hasData = false;
while (esm.hasMoreSubs())
{
esm.getSubName();
switch (esm.retSubName().toInt())
{
case SREC_NAME:
mId = esm.getRefId();
hasName = true;
break;
case fourCC("MODL"):
mModel = esm.getHString();
break;
case fourCC("FNAM"):
mRace = esm.getRefId();
break;
case fourCC("BYDT"):
esm.getSubComposite(mData);
hasData = true;
break;
case SREC_DELE:
esm.skipHSub();
isDeleted = true;
break;
default:
esm.fail("Unknown subrecord");
break;
}
}
if (!hasName)
esm.fail("Missing NAME subrecord");
if (!hasData && !isDeleted)
esm.fail("Missing BYDT subrecord");
}
void BodyPart::save(ESMWriter& esm, bool isDeleted) const
{
esm.writeHNCRefId("NAME", mId);
if (isDeleted)
{
esm.writeHNString("DELE", "", 3);
return;
}
esm.writeHNCString("MODL", mModel);
esm.writeHNOCRefId("FNAM", mRace);
esm.writeNamedComposite("BYDT", mData);
}
void BodyPart::blank()
{
mRecordFlags = 0;
mData.mPart = 0;
mData.mVampire = 0;
mData.mFlags = 0;
mData.mType = 0;
mModel.clear();
mRace = ESM::RefId();
}
bool isFirstPersonBodyPart(const BodyPart& value)
{
return value.mId.endsWith("1st");
}
}
| 2,254
|
C++
|
.cpp
| 77
| 18.298701
| 63
| 0.490069
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,525
|
projectilestate.cpp
|
OpenMW_openmw/components/esm3/projectilestate.cpp
|
#include "projectilestate.hpp"
#include "esmreader.hpp"
#include "esmwriter.hpp"
namespace ESM
{
void BaseProjectileState::save(ESMWriter& esm) const
{
esm.writeHNRefId("ID__", mId);
esm.writeHNT("VEC3", mPosition);
esm.writeHNT("QUAT", mOrientation);
esm.writeHNT("ACTO", mActorId);
}
void BaseProjectileState::load(ESMReader& esm)
{
mId = esm.getHNRefId("ID__");
esm.getHNT("VEC3", mPosition.mValues);
esm.getHNT("QUAT", mOrientation.mValues);
esm.getHNT(mActorId, "ACTO");
}
void MagicBoltState::save(ESMWriter& esm) const
{
BaseProjectileState::save(esm);
esm.writeHNRefId("SPEL", mSpellId);
esm.writeHNT("SPED", mSpeed);
if (mItem.isSet())
esm.writeFormId(mItem, true, "ITEM");
}
void MagicBoltState::load(ESMReader& esm)
{
BaseProjectileState::load(esm);
mSpellId = esm.getHNRefId("SPEL");
esm.getHNT(mSpeed, "SPED");
if (esm.peekNextSub("ITEM"))
mItem = esm.getFormId(true, "ITEM");
if (esm.isNextSub("SLOT")) // for backwards compatibility
esm.skipHSub();
}
void ProjectileState::save(ESMWriter& esm) const
{
BaseProjectileState::save(esm);
esm.writeHNRefId("BOW_", mBowId);
esm.writeHNT("VEL_", mVelocity);
esm.writeHNT("STR_", mAttackStrength);
}
void ProjectileState::load(ESMReader& esm)
{
BaseProjectileState::load(esm);
mBowId = esm.getHNRefId("BOW_");
esm.getHNT("VEL_", mVelocity.mValues);
mAttackStrength = 1.f;
esm.getHNOT(mAttackStrength, "STR_");
}
}
| 1,701
|
C++
|
.cpp
| 53
| 24.867925
| 65
| 0.615055
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,526
|
esmreader.cpp
|
OpenMW_openmw/components/esm3/esmreader.cpp
|
#include "esmreader.hpp"
#include "readerscache.hpp"
#include <components/esm3/cellid.hpp>
#include <components/esm3/loadcell.hpp>
#include <components/files/conversion.hpp>
#include <components/files/openfile.hpp>
#include <components/misc/strings/algorithm.hpp>
#include <filesystem>
#include <fstream>
#include <sstream>
#include <stdexcept>
namespace ESM
{
ESM_Context ESMReader::getContext()
{
// Update the file position before returning
mCtx.filePos = mEsm->tellg();
return mCtx;
}
ESMReader::ESMReader()
: mRecordFlags(0)
, mBuffer(50 * 1024)
, mEncoder(nullptr)
, mFileSize(0)
{
clearCtx();
mCtx.index = 0;
}
void ESMReader::restoreContext(const ESM_Context& rc)
{
// Reopen the file if necessary
if (mCtx.filename != rc.filename)
openRaw(rc.filename);
// Copy the data
mCtx = rc;
// Make sure we seek to the right place
mEsm->seekg(mCtx.filePos);
}
void ESMReader::close()
{
mEsm.reset();
clearCtx();
mHeader.blank();
}
void ESMReader::clearCtx()
{
mCtx.filename.clear();
mCtx.leftFile = 0;
mCtx.leftRec = 0;
mCtx.leftSub = 0;
mCtx.subCached = false;
mCtx.recName.clear();
mCtx.subName.clear();
}
void ESMReader::resolveParentFileIndices(ReadersCache& readers)
{
mCtx.parentFileIndices.clear();
for (const Header::MasterData& mast : getGameFiles())
{
const std::string& fname = mast.name;
int index = getIndex();
for (int i = 0; i < getIndex(); i++)
{
const ESM::ReadersCache::BusyItem reader = readers.get(static_cast<std::size_t>(i));
if (reader->getFileSize() == 0)
continue; // Content file in non-ESM format
const auto fnamecandidate = Files::pathToUnicodeString(reader->getName().filename());
if (Misc::StringUtils::ciEqual(fname, fnamecandidate))
{
index = i;
break;
}
}
mCtx.parentFileIndices.push_back(index);
}
}
bool ESMReader::applyContentFileMapping(FormId& id)
{
if (mContentFileMapping && id.hasContentFile())
{
auto iter = mContentFileMapping->find(id.mContentFile);
if (iter == mContentFileMapping->end())
return false;
id.mContentFile = iter->second;
}
return true;
}
ESM::RefId ESMReader::getCellId()
{
if (mHeader.mFormatVersion <= ESM::MaxUseEsmCellIdFormatVersion)
{
ESM::CellId cellId;
cellId.load(*this);
if (cellId.mPaged)
{
return ESM::RefId::esm3ExteriorCell(cellId.mIndex.mX, cellId.mIndex.mY);
}
else
{
return ESM::RefId::stringRefId(cellId.mWorldspace);
}
}
return getHNRefId("NAME");
}
void ESMReader::openRaw(std::unique_ptr<std::istream>&& stream, const std::filesystem::path& name)
{
close();
mEsm = std::move(stream);
mCtx.filename = name;
mEsm->seekg(0, mEsm->end);
mCtx.leftFile = mFileSize = mEsm->tellg();
mEsm->seekg(0, mEsm->beg);
}
void ESMReader::openRaw(const std::filesystem::path& filename)
{
openRaw(Files::openBinaryInputFileStream(filename), filename);
}
void ESMReader::open(std::unique_ptr<std::istream>&& stream, const std::filesystem::path& name)
{
openRaw(std::move(stream), name);
if (getRecName() != "TES3")
fail("Not a valid Morrowind file");
getRecHeader();
mHeader.load(*this);
}
void ESMReader::open(const std::filesystem::path& file)
{
open(Files::openBinaryInputFileStream(file), file);
}
std::string ESMReader::getHNOString(NAME name)
{
if (isNextSub(name))
return getHString();
return {};
}
ESM::RefId ESMReader::getHNORefId(NAME name)
{
if (isNextSub(name))
return getRefId();
return ESM::RefId();
}
void ESMReader::skipHNORefId(NAME name)
{
if (isNextSub(name))
skipHRefId();
}
std::string ESMReader::getHNString(NAME name)
{
getSubNameIs(name);
return getHString();
}
RefId ESMReader::getHNRefId(NAME name)
{
getSubNameIs(name);
return getRefId();
}
std::string ESMReader::getHString()
{
return std::string(getHStringView());
}
std::string_view ESMReader::getHStringView()
{
getSubHeader();
if (mHeader.mFormatVersion > MaxStringRefIdFormatVersion)
return getStringView(mCtx.leftSub);
// Hack to make MultiMark.esp load. Zero-length strings do not
// occur in any of the official mods, but MultiMark makes use of
// them. For some reason, they break the rules, and contain a byte
// (value 0) even if the header says there is no data. If
// Morrowind accepts it, so should we.
if (mCtx.leftSub == 0 && hasMoreSubs() && !mEsm->peek())
{
// Skip the following zero byte
mCtx.leftRec--;
char c;
getT(c);
return std::string_view();
}
return getStringView(mCtx.leftSub);
}
RefId ESMReader::getRefId()
{
if (mHeader.mFormatVersion <= MaxStringRefIdFormatVersion)
return ESM::RefId::stringRefId(getHStringView());
getSubHeader();
return getRefIdImpl(mCtx.leftSub);
}
void ESMReader::skipHString()
{
getSubHeader();
// Hack to make MultiMark.esp load. Zero-length strings do not
// occur in any of the official mods, but MultiMark makes use of
// them. For some reason, they break the rules, and contain a byte
// (value 0) even if the header says there is no data. If
// Morrowind accepts it, so should we.
if (mHeader.mFormatVersion <= MaxStringRefIdFormatVersion && mCtx.leftSub == 0 && hasMoreSubs()
&& !mEsm->peek())
{
// Skip the following zero byte
mCtx.leftRec--;
skipT<char>();
return;
}
skip(mCtx.leftSub);
}
void ESMReader::skipHRefId()
{
skipHString();
}
FormId ESMReader::getFormId(bool wide, NAME tag)
{
FormId res;
if (wide)
getHNT(tag, res.mIndex, res.mContentFile);
else
getHNT(res.mIndex, tag);
return res;
}
// Get the next subrecord name and check if it matches the parameter
void ESMReader::getSubNameIs(NAME name)
{
getSubName();
if (mCtx.subName != name)
fail("Expected subrecord " + name.toString() + " but got " + mCtx.subName.toString());
}
bool ESMReader::isNextSub(NAME name)
{
if (!hasMoreSubs())
return false;
getSubName();
// If the name didn't match, then mark the it as 'cached' so it's
// available for the next call to getSubName.
mCtx.subCached = (mCtx.subName != name);
// If subCached is false, then subName == name.
return !mCtx.subCached;
}
bool ESMReader::peekNextSub(NAME name)
{
if (!hasMoreSubs())
return false;
getSubName();
mCtx.subCached = true;
return mCtx.subName == name;
}
// Read subrecord name. This gets called a LOT, so I've optimized it
// slightly.
void ESMReader::getSubName()
{
// If the name has already been read, do nothing
if (mCtx.subCached)
{
mCtx.subCached = false;
return;
}
// reading the subrecord data anyway.
const std::size_t subNameSize = decltype(mCtx.subName)::sCapacity;
getExact(mCtx.subName.mData, subNameSize);
mCtx.leftRec -= static_cast<std::uint32_t>(subNameSize);
}
void ESMReader::skipHSub()
{
getSubHeader();
skip(mCtx.leftSub);
}
void ESMReader::skipHSubSize(std::size_t size)
{
skipHSub();
if (mCtx.leftSub != size)
reportSubSizeMismatch(mCtx.leftSub, size);
}
void ESMReader::skipHSubUntil(NAME name)
{
while (hasMoreSubs() && !isNextSub(name))
{
mCtx.subCached = false;
skipHSub();
}
if (hasMoreSubs())
mCtx.subCached = true;
}
void ESMReader::getSubHeader()
{
if (mCtx.leftRec < static_cast<std::streamsize>(sizeof(mCtx.leftSub)))
fail("End of record while reading sub-record header: " + std::to_string(mCtx.leftRec) + " < "
+ std::to_string(sizeof(mCtx.leftSub)));
// Get subrecord size
getUint(mCtx.leftSub);
mCtx.leftRec -= sizeof(mCtx.leftSub);
// Adjust number of record bytes left; may go negative
mCtx.leftRec -= mCtx.leftSub;
}
NAME ESMReader::getRecName()
{
if (!hasMoreRecs())
fail("No more records, getRecName() failed");
if (hasMoreSubs())
fail("Previous record contains unread bytes");
// We went out of the previous record's bounds. Backtrack.
if (mCtx.leftRec < 0)
mEsm->seekg(mCtx.leftRec, std::ios::cur);
getName(mCtx.recName);
mCtx.leftFile -= decltype(mCtx.recName)::sCapacity;
// Make sure we don't carry over any old cached subrecord
// names. This can happen in some cases when we skip parts of a
// record.
mCtx.subCached = false;
return mCtx.recName;
}
void ESMReader::skipRecord()
{
skip(mCtx.leftRec);
mCtx.leftRec = 0;
mCtx.subCached = false;
}
void ESMReader::getRecHeader(uint32_t& flags)
{
if (mCtx.leftFile < static_cast<std::streamsize>(3 * sizeof(uint32_t)))
fail("End of file while reading record header");
std::uint32_t leftRec = 0;
getUint(leftRec);
mCtx.leftRec = static_cast<std::streamsize>(leftRec);
getUint(flags); // This header entry is always zero
getUint(flags);
mCtx.leftFile -= 3 * sizeof(uint32_t);
// Check that sizes add up
if (mCtx.leftFile < mCtx.leftRec)
reportSubSizeMismatch(mCtx.leftFile, mCtx.leftRec);
// Adjust number of bytes mCtx.left in file
mCtx.leftFile -= mCtx.leftRec;
}
/*************************************************************************
*
* Lowest level data reading and misc methods
*
*************************************************************************/
std::string ESMReader::getMaybeFixedStringSize(std::size_t size)
{
if (mHeader.mFormatVersion > MaxLimitedSizeStringsFormatVersion)
{
StringSizeType storedSize = 0;
getT(storedSize);
if (storedSize > mCtx.leftSub)
fail("String does not fit subrecord (" + std::to_string(storedSize) + " > "
+ std::to_string(mCtx.leftSub) + ")");
size = static_cast<std::size_t>(storedSize);
}
return std::string(getStringView(size));
}
RefId ESMReader::getMaybeFixedRefIdSize(std::size_t size)
{
if (mHeader.mFormatVersion <= MaxStringRefIdFormatVersion)
return RefId::stringRefId(getMaybeFixedStringSize(size));
return getRefIdImpl(mCtx.leftSub);
}
std::string_view ESMReader::getStringView(std::size_t size)
{
if (mBuffer.size() <= size)
// Add some extra padding to reduce the chance of having to resize
// again later.
mBuffer.resize(3 * size);
// And make sure the string is zero terminated
mBuffer[size] = 0;
// read ESM data
char* ptr = mBuffer.data();
getExact(ptr, size);
size = strnlen(ptr, size);
// Convert to UTF8 and return
if (mEncoder != nullptr)
return mEncoder->getUtf8(std::string_view(ptr, size));
return std::string_view(ptr, size);
}
RefId ESMReader::getRefId(std::size_t size)
{
if (mHeader.mFormatVersion <= MaxStringRefIdFormatVersion)
return ESM::RefId::stringRefId(getStringView(size));
return getRefIdImpl(size);
}
RefId ESMReader::getRefIdImpl(std::size_t size)
{
RefIdType refIdType = RefIdType::Empty;
getT(refIdType);
switch (refIdType)
{
case RefIdType::Empty:
return RefId();
case RefIdType::SizedString:
{
const std::size_t minSize = sizeof(refIdType) + sizeof(StringSizeType);
if (size < minSize)
fail("Requested RefId record size is too small (" + std::to_string(size) + " < "
+ std::to_string(minSize) + ")");
StringSizeType storedSize = 0;
getT(storedSize);
const std::size_t maxSize = size - minSize;
if (storedSize > maxSize)
fail("RefId string does not fit subrecord size (" + std::to_string(storedSize) + " > "
+ std::to_string(maxSize) + ")");
return RefId::stringRefId(getStringView(storedSize));
}
case RefIdType::UnsizedString:
if (size < sizeof(refIdType))
fail("Requested RefId record size is too small (" + std::to_string(size) + " < "
+ std::to_string(sizeof(refIdType)) + ")");
return RefId::stringRefId(getStringView(size - sizeof(refIdType)));
case RefIdType::FormId:
{
FormId formId{};
getT(formId.mIndex);
getT(formId.mContentFile);
if (applyContentFileMapping(formId))
return RefId(formId);
else
return RefId(); // content file was removed from load order
}
case RefIdType::Generated:
{
std::uint64_t generated{};
getT(generated);
return RefId::generated(generated);
}
case RefIdType::Index:
{
RecNameInts recordType{};
getExact(&recordType, sizeof(std::uint32_t));
std::uint32_t index{};
getT(index);
return RefId::index(recordType, index);
}
case RefIdType::ESM3ExteriorCell:
{
int32_t x, y;
getT(x);
getT(y);
return RefId::esm3ExteriorCell(x, y);
}
}
fail("Unsupported RefIdType: " + std::to_string(static_cast<unsigned>(refIdType)));
}
[[noreturn]] void ESMReader::fail(std::string_view msg)
{
std::stringstream ss;
ss << "ESM Error: " << msg;
ss << "\n File: " << Files::pathToUnicodeString(mCtx.filename);
ss << "\n Record: " << mCtx.recName.toStringView();
ss << "\n Subrecord: " << mCtx.subName.toStringView();
if (mEsm.get())
ss << "\n Offset: 0x" << std::hex << mEsm->tellg();
throw std::runtime_error(ss.str());
}
}
| 15,703
|
C++
|
.cpp
| 450
| 25.371111
| 106
| 0.562512
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,527
|
loadclot.cpp
|
OpenMW_openmw/components/esm3/loadclot.cpp
|
#include "loadclot.hpp"
#include "esmreader.hpp"
#include "esmwriter.hpp"
#include <components/misc/concepts.hpp>
namespace ESM
{
template <Misc::SameAsWithoutCvref<Clothing::CTDTstruct> T>
void decompose(T&& v, const auto& f)
{
f(v.mType, v.mWeight, v.mValue, v.mEnchant);
}
void Clothing::load(ESMReader& esm, bool& isDeleted)
{
isDeleted = false;
mRecordFlags = esm.getRecordFlags();
mParts.mParts.clear();
bool hasName = false;
bool hasData = false;
while (esm.hasMoreSubs())
{
esm.getSubName();
switch (esm.retSubName().toInt())
{
case SREC_NAME:
mId = esm.getRefId();
hasName = true;
break;
case fourCC("MODL"):
mModel = esm.getHString();
break;
case fourCC("FNAM"):
mName = esm.getHString();
break;
case fourCC("CTDT"):
esm.getSubComposite(mData);
hasData = true;
break;
case fourCC("SCRI"):
mScript = esm.getRefId();
break;
case fourCC("ITEX"):
mIcon = esm.getHString();
break;
case fourCC("ENAM"):
mEnchant = esm.getRefId();
break;
case fourCC("INDX"):
mParts.add(esm);
break;
case SREC_DELE:
esm.skipHSub();
isDeleted = true;
break;
default:
esm.fail("Unknown subrecord");
break;
}
}
if (!hasName)
esm.fail("Missing NAME subrecord");
if (!hasData && !isDeleted)
esm.fail("Missing CTDT subrecord");
}
void Clothing::save(ESMWriter& esm, bool isDeleted) const
{
esm.writeHNCRefId("NAME", mId);
if (isDeleted)
{
esm.writeHNString("DELE", "", 3);
return;
}
esm.writeHNCString("MODL", mModel);
esm.writeHNOCString("FNAM", mName);
esm.writeNamedComposite("CTDT", mData);
esm.writeHNOCRefId("SCRI", mScript);
esm.writeHNOCString("ITEX", mIcon);
mParts.save(esm);
esm.writeHNOCRefId("ENAM", mEnchant);
}
void Clothing::blank()
{
mRecordFlags = 0;
mData.mType = 0;
mData.mWeight = 0;
mData.mValue = 0;
mData.mEnchant = 0;
mParts.mParts.clear();
mName.clear();
mModel.clear();
mIcon.clear();
mEnchant = ESM::RefId();
mScript = ESM::RefId();
}
}
| 2,891
|
C++
|
.cpp
| 94
| 18.62766
| 63
| 0.471434
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,528
|
loadprob.cpp
|
OpenMW_openmw/components/esm3/loadprob.cpp
|
#include "loadprob.hpp"
#include "esmreader.hpp"
#include "esmwriter.hpp"
#include <components/misc/concepts.hpp>
namespace ESM
{
template <Misc::SameAsWithoutCvref<Probe::Data> T>
void decompose(T&& v, const auto& f)
{
f(v.mWeight, v.mValue, v.mQuality, v.mUses);
}
void Probe::load(ESMReader& esm, bool& isDeleted)
{
isDeleted = false;
mRecordFlags = esm.getRecordFlags();
bool hasName = false;
bool hasData = false;
while (esm.hasMoreSubs())
{
esm.getSubName();
switch (esm.retSubName().toInt())
{
case SREC_NAME:
mId = esm.getRefId();
hasName = true;
break;
case fourCC("MODL"):
mModel = esm.getHString();
break;
case fourCC("FNAM"):
mName = esm.getHString();
break;
case fourCC("PBDT"):
esm.getSubComposite(mData);
hasData = true;
break;
case fourCC("SCRI"):
mScript = esm.getRefId();
break;
case fourCC("ITEX"):
mIcon = esm.getHString();
break;
case SREC_DELE:
esm.skipHSub();
isDeleted = true;
break;
default:
esm.fail("Unknown subrecord");
break;
}
}
if (!hasName)
esm.fail("Missing NAME subrecord");
if (!hasData && !isDeleted)
esm.fail("Missing PBDT subrecord");
}
void Probe::save(ESMWriter& esm, bool isDeleted) const
{
esm.writeHNCRefId("NAME", mId);
if (isDeleted)
{
esm.writeHNString("DELE", "", 3);
return;
}
esm.writeHNCString("MODL", mModel);
esm.writeHNOCString("FNAM", mName);
esm.writeNamedComposite("PBDT", mData);
esm.writeHNORefId("SCRI", mScript);
esm.writeHNOCString("ITEX", mIcon);
}
void Probe::blank()
{
mRecordFlags = 0;
mData.mWeight = 0;
mData.mValue = 0;
mData.mQuality = 0;
mData.mUses = 0;
mName.clear();
mModel.clear();
mIcon.clear();
mScript = ESM::RefId();
}
}
| 2,490
|
C++
|
.cpp
| 83
| 18.26506
| 58
| 0.472454
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,529
|
journalentry.cpp
|
OpenMW_openmw/components/esm3/journalentry.cpp
|
#include "journalentry.hpp"
#include "esmreader.hpp"
#include "esmwriter.hpp"
namespace ESM
{
void JournalEntry::load(ESMReader& esm)
{
esm.getHNOT(mType, "JETY");
mTopic = esm.getHNRefId("YETO");
mInfo = esm.getHNRefId("YEIN");
mText = esm.getHNString("TEXT");
if (mType == Type_Journal)
{
esm.getHNT(mDay, "JEDA");
esm.getHNT(mMonth, "JEMO");
esm.getHNT(mDayOfMonth, "JEDM");
}
else if (mType == Type_Topic)
mActorName = esm.getHNOString("ACT_");
}
void JournalEntry::save(ESMWriter& esm) const
{
esm.writeHNT("JETY", mType);
esm.writeHNRefId("YETO", mTopic);
esm.writeHNRefId("YEIN", mInfo);
esm.writeHNString("TEXT", mText);
if (mType == Type_Journal)
{
esm.writeHNT("JEDA", mDay);
esm.writeHNT("JEMO", mMonth);
esm.writeHNT("JEDM", mDayOfMonth);
}
else if (mType == Type_Topic)
esm.writeHNString("ACT_", mActorName);
}
}
| 1,081
|
C++
|
.cpp
| 36
| 21.944444
| 50
| 0.55973
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| true
| true
| false
|
34,530
|
globalmap.cpp
|
OpenMW_openmw/components/esm3/globalmap.cpp
|
#include "globalmap.hpp"
#include "esmreader.hpp"
#include "esmwriter.hpp"
namespace ESM
{
void GlobalMap::load(ESMReader& esm)
{
esm.getHNT("BNDS", mBounds.mMinX, mBounds.mMaxX, mBounds.mMinY, mBounds.mMaxY);
esm.getSubNameIs("DATA");
esm.getSubHeader();
mImageData.resize(esm.getSubSize());
esm.getExact(mImageData.data(), mImageData.size());
while (esm.isNextSub("MRK_"))
{
esm.getSubHeader();
CellId cell;
esm.getT(cell.first);
esm.getT(cell.second);
mMarkers.insert(cell);
}
}
void GlobalMap::save(ESMWriter& esm) const
{
esm.writeHNT("BNDS", mBounds);
esm.startSubRecord("DATA");
esm.write(mImageData.data(), mImageData.size());
esm.endRecord("DATA");
for (std::set<CellId>::const_iterator it = mMarkers.begin(); it != mMarkers.end(); ++it)
{
esm.startSubRecord("MRK_");
esm.writeT(it->first);
esm.writeT(it->second);
esm.endRecord("MRK_");
}
}
}
| 1,114
|
C++
|
.cpp
| 36
| 22.694444
| 96
| 0.572498
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| true
| false
|
34,531
|
loadstat.cpp
|
OpenMW_openmw/components/esm3/loadstat.cpp
|
#include "loadstat.hpp"
#include "esmreader.hpp"
#include "esmwriter.hpp"
namespace ESM
{
void Static::load(ESMReader& esm, bool& isDeleted)
{
isDeleted = false;
mRecordFlags = esm.getRecordFlags();
// bool isBlocked = (mRecordFlags & FLAG_Blocked) != 0;
// bool isPersistent = (mRecordFlags & FLAG_Persistent) != 0;
bool hasName = false;
while (esm.hasMoreSubs())
{
esm.getSubName();
switch (esm.retSubName().toInt())
{
case SREC_NAME:
mId = esm.getRefId();
hasName = true;
break;
case fourCC("MODL"):
mModel = esm.getHString();
break;
case SREC_DELE:
esm.skipHSub();
isDeleted = true;
break;
default:
esm.fail("Unknown subrecord");
break;
}
}
if (!hasName)
esm.fail("Missing NAME subrecord");
}
void Static::save(ESMWriter& esm, bool isDeleted) const
{
esm.writeHNCRefId("NAME", mId);
if (isDeleted)
{
esm.writeHNString("DELE", "", 3);
}
else
{
esm.writeHNCString("MODL", mModel);
}
}
void Static::blank()
{
mRecordFlags = 0;
mModel.clear();
}
}
| 1,481
|
C++
|
.cpp
| 54
| 16.555556
| 69
| 0.466245
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,532
|
loadregn.cpp
|
OpenMW_openmw/components/esm3/loadregn.cpp
|
#include "loadregn.hpp"
#include "esmreader.hpp"
#include "esmwriter.hpp"
#include <components/esm/common.hpp>
namespace ESM
{
void Region::load(ESMReader& esm, bool& isDeleted)
{
isDeleted = false;
mRecordFlags = esm.getRecordFlags();
bool hasName = false;
while (esm.hasMoreSubs())
{
esm.getSubName();
switch (esm.retSubName().toInt())
{
case SREC_NAME:
mId = esm.getRefId();
hasName = true;
break;
case fourCC("FNAM"):
mName = esm.getHString();
break;
case fourCC("WEAT"):
{
esm.getSubHeader();
// Cold weather not included before 1.3
if (esm.getSubSize() == mData.mProbabilities.size())
{
esm.getT(mData.mProbabilities);
}
else if (esm.getSubSize() == mData.mProbabilities.size() - 2)
{
mData.mProbabilities.fill(0);
esm.getExact(&mData.mProbabilities, esm.getSubSize());
}
else
{
esm.fail("Don't know what to do in this version");
}
break;
}
case fourCC("BNAM"):
mSleepList = esm.getRefId();
break;
case fourCC("CNAM"):
esm.getHT(mMapColor);
break;
case fourCC("SNAM"):
{
esm.getSubHeader();
SoundRef sr;
sr.mSound = esm.getMaybeFixedRefIdSize(32);
esm.getT(sr.mChance);
mSoundList.push_back(sr);
break;
}
case SREC_DELE:
esm.skipHSub();
isDeleted = true;
break;
default:
esm.fail("Unknown subrecord");
break;
}
}
if (!hasName)
esm.fail("Missing NAME subrecord");
}
void Region::save(ESMWriter& esm, bool isDeleted) const
{
esm.writeHNCRefId("NAME", mId);
if (isDeleted)
{
esm.writeHNString("DELE", "", 3);
return;
}
esm.writeHNOCString("FNAM", mName);
if (esm.getVersion() == VER_120)
esm.writeHNT("WEAT", mData.mProbabilities, mData.mProbabilities.size() - 2);
else
esm.writeHNT("WEAT", mData.mProbabilities);
esm.writeHNOCRefId("BNAM", mSleepList);
esm.writeHNT("CNAM", mMapColor);
for (std::vector<SoundRef>::const_iterator it = mSoundList.begin(); it != mSoundList.end(); ++it)
{
esm.startSubRecord("SNAM");
esm.writeMaybeFixedSizeRefId(it->mSound, 32);
esm.writeT(it->mChance);
esm.endRecord("SNAM");
}
}
void Region::blank()
{
mRecordFlags = 0;
mData.mProbabilities.fill(0);
mMapColor = 0;
mName.clear();
mSleepList = ESM::RefId();
mSoundList.clear();
}
}
| 3,401
|
C++
|
.cpp
| 102
| 19.27451
| 105
| 0.450091
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,533
|
statstate.cpp
|
OpenMW_openmw/components/esm3/statstate.cpp
|
#include "statstate.hpp"
#include "esmreader.hpp"
#include "esmwriter.hpp"
namespace ESM
{
template <typename T>
StatState<T>::StatState()
: mBase(0)
, mMod(0)
, mCurrent(0)
, mDamage(0)
, mProgress(0)
{
}
template <typename T>
void StatState<T>::load(ESMReader& esm, bool intFallback)
{
// We changed stats values from integers to floats; ensure backwards compatibility
if (intFallback)
{
int32_t base = 0;
esm.getHNT(base, "STBA");
mBase = static_cast<T>(base);
int32_t mod = 0;
esm.getHNOT(mod, "STMO");
mMod = static_cast<T>(mod);
int32_t current = 0;
esm.getHNOT(current, "STCU");
mCurrent = static_cast<T>(current);
}
else
{
mBase = 0;
esm.getHNT(mBase, "STBA");
mMod = 0;
esm.getHNOT(mMod, "STMO");
mCurrent = 0;
esm.getHNOT(mCurrent, "STCU");
mDamage = 0;
esm.getHNOT(mDamage, "STDF");
mProgress = 0;
}
esm.getHNOT(mDamage, "STDF");
mProgress = 0;
esm.getHNOT(mProgress, "STPR");
}
template <typename T>
void StatState<T>::save(ESMWriter& esm) const
{
esm.writeHNT("STBA", mBase);
if (mMod != 0)
esm.writeHNT("STMO", mMod);
if (mCurrent)
esm.writeHNT("STCU", mCurrent);
if (mDamage)
esm.writeHNT("STDF", mDamage);
if (mProgress)
esm.writeHNT("STPR", mProgress);
}
template struct StatState<int>;
template struct StatState<float>;
}
| 1,737
|
C++
|
.cpp
| 62
| 19
| 90
| 0.522316
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,534
|
loaddoor.cpp
|
OpenMW_openmw/components/esm3/loaddoor.cpp
|
#include "loaddoor.hpp"
#include "esmreader.hpp"
#include "esmwriter.hpp"
namespace ESM
{
void Door::load(ESMReader& esm, bool& isDeleted)
{
isDeleted = false;
mRecordFlags = esm.getRecordFlags();
bool hasName = false;
while (esm.hasMoreSubs())
{
esm.getSubName();
switch (esm.retSubName().toInt())
{
case SREC_NAME:
mId = esm.getRefId();
hasName = true;
break;
case fourCC("MODL"):
mModel = esm.getHString();
break;
case fourCC("FNAM"):
mName = esm.getHString();
break;
case fourCC("SCRI"):
mScript = esm.getRefId();
break;
case fourCC("SNAM"):
mOpenSound = esm.getRefId();
break;
case fourCC("ANAM"):
mCloseSound = esm.getRefId();
break;
case SREC_DELE:
esm.skipHSub();
isDeleted = true;
break;
default:
esm.fail("Unknown subrecord");
break;
}
}
if (!hasName)
esm.fail("Missing NAME subrecord");
}
void Door::save(ESMWriter& esm, bool isDeleted) const
{
esm.writeHNCRefId("NAME", mId);
if (isDeleted)
{
esm.writeHNString("DELE", "", 3);
return;
}
esm.writeHNCString("MODL", mModel);
esm.writeHNOCString("FNAM", mName);
esm.writeHNOCRefId("SCRI", mScript);
esm.writeHNOCRefId("SNAM", mOpenSound);
esm.writeHNOCRefId("ANAM", mCloseSound);
}
void Door::blank()
{
mRecordFlags = 0;
mName.clear();
mModel.clear();
mScript = ESM::RefId();
mOpenSound = ESM::RefId();
mCloseSound = ESM::RefId();
}
}
| 2,086
|
C++
|
.cpp
| 70
| 17.485714
| 57
| 0.455179
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,535
|
stolenitems.cpp
|
OpenMW_openmw/components/esm3/stolenitems.cpp
|
#include "stolenitems.hpp"
#include <components/esm3/esmreader.hpp>
#include <components/esm3/esmwriter.hpp>
namespace ESM
{
void StolenItems::write(ESMWriter& esm) const
{
for (StolenItemsMap::const_iterator it = mStolenItems.begin(); it != mStolenItems.end(); ++it)
{
esm.writeHNRefId("NAME", it->first);
for (auto ownerIt = it->second.begin(); ownerIt != it->second.end(); ++ownerIt)
{
if (ownerIt->first.second)
esm.writeHNRefId("FNAM", ownerIt->first.first);
else
esm.writeHNRefId("ONAM", ownerIt->first.first);
esm.writeHNT("COUN", ownerIt->second);
}
}
}
void StolenItems::load(ESMReader& esm)
{
while (esm.isNextSub("NAME"))
{
ESM::RefId itemid = esm.getRefId();
std::map<std::pair<ESM::RefId, bool>, int> ownerMap;
while (esm.isNextSub("FNAM") || esm.isNextSub("ONAM"))
{
const bool isFaction = (esm.retSubName() == "FNAM");
ESM::RefId owner = esm.getRefId();
int count;
esm.getHNT(count, "COUN");
ownerMap.emplace(std::make_pair(std::move(owner), isFaction), count);
}
mStolenItems.insert_or_assign(std::move(itemid), std::move(ownerMap));
}
}
}
| 1,423
|
C++
|
.cpp
| 38
| 26.789474
| 102
| 0.54209
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,536
|
loadrepa.cpp
|
OpenMW_openmw/components/esm3/loadrepa.cpp
|
#include "loadrepa.hpp"
#include "esmreader.hpp"
#include "esmwriter.hpp"
#include <components/misc/concepts.hpp>
namespace ESM
{
template <Misc::SameAsWithoutCvref<Repair::Data> T>
void decompose(T&& v, const auto& f)
{
f(v.mWeight, v.mValue, v.mUses, v.mQuality);
}
void Repair::load(ESMReader& esm, bool& isDeleted)
{
isDeleted = false;
mRecordFlags = esm.getRecordFlags();
bool hasName = false;
bool hasData = false;
while (esm.hasMoreSubs())
{
esm.getSubName();
switch (esm.retSubName().toInt())
{
case SREC_NAME:
mId = esm.getRefId();
hasName = true;
break;
case fourCC("MODL"):
mModel = esm.getHString();
break;
case fourCC("FNAM"):
mName = esm.getHString();
break;
case fourCC("RIDT"):
esm.getSubComposite(mData);
hasData = true;
break;
case fourCC("SCRI"):
mScript = esm.getRefId();
break;
case fourCC("ITEX"):
mIcon = esm.getHString();
break;
case SREC_DELE:
esm.skipHSub();
isDeleted = true;
break;
default:
esm.fail("Unknown subrecord");
break;
}
}
if (!hasName)
esm.fail("Missing NAME subrecord");
if (!hasData && !isDeleted)
esm.fail("Missing RIDT subrecord");
}
void Repair::save(ESMWriter& esm, bool isDeleted) const
{
esm.writeHNCRefId("NAME", mId);
if (isDeleted)
{
esm.writeHNString("DELE", "", 3);
return;
}
esm.writeHNCString("MODL", mModel);
esm.writeHNOCString("FNAM", mName);
esm.writeNamedComposite("RIDT", mData);
esm.writeHNORefId("SCRI", mScript);
esm.writeHNOCString("ITEX", mIcon);
}
void Repair::blank()
{
mRecordFlags = 0;
mData.mWeight = 0;
mData.mValue = 0;
mData.mQuality = 0;
mData.mUses = 0;
mName.clear();
mModel.clear();
mIcon.clear();
mScript = ESM::RefId();
}
}
| 2,494
|
C++
|
.cpp
| 83
| 18.313253
| 59
| 0.473333
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,537
|
loadbook.cpp
|
OpenMW_openmw/components/esm3/loadbook.cpp
|
#include "loadbook.hpp"
#include "esmreader.hpp"
#include "esmwriter.hpp"
#include <components/misc/concepts.hpp>
namespace ESM
{
template <Misc::SameAsWithoutCvref<Book::BKDTstruct> T>
void decompose(T&& v, const auto& f)
{
f(v.mWeight, v.mValue, v.mIsScroll, v.mSkillId, v.mEnchant);
}
void Book::load(ESMReader& esm, bool& isDeleted)
{
isDeleted = false;
mRecordFlags = esm.getRecordFlags();
bool hasName = false;
bool hasData = false;
while (esm.hasMoreSubs())
{
esm.getSubName();
switch (esm.retSubName().toInt())
{
case SREC_NAME:
mId = esm.getRefId();
hasName = true;
break;
case fourCC("MODL"):
mModel = esm.getHString();
break;
case fourCC("FNAM"):
mName = esm.getHString();
break;
case fourCC("BKDT"):
esm.getSubComposite(mData);
hasData = true;
break;
case fourCC("SCRI"):
mScript = esm.getRefId();
break;
case fourCC("ITEX"):
mIcon = esm.getHString();
break;
case fourCC("ENAM"):
mEnchant = esm.getRefId();
break;
case fourCC("TEXT"):
mText = esm.getHString();
break;
case SREC_DELE:
esm.skipHSub();
isDeleted = true;
break;
default:
esm.fail("Unknown subrecord");
break;
}
}
if (!hasName)
esm.fail("Missing NAME subrecord");
if (!hasData && !isDeleted)
esm.fail("Missing BKDT subrecord");
}
void Book::save(ESMWriter& esm, bool isDeleted) const
{
esm.writeHNCRefId("NAME", mId);
if (isDeleted)
{
esm.writeHNString("DELE", "", 3);
return;
}
esm.writeHNCString("MODL", mModel);
esm.writeHNOCString("FNAM", mName);
esm.writeNamedComposite("BKDT", mData);
esm.writeHNOCRefId("SCRI", mScript);
esm.writeHNOCString("ITEX", mIcon);
esm.writeHNOString("TEXT", mText);
esm.writeHNOCRefId("ENAM", mEnchant);
}
void Book::blank()
{
mRecordFlags = 0;
mData.mWeight = 0;
mData.mValue = 0;
mData.mIsScroll = 0;
mData.mSkillId = 0;
mData.mEnchant = 0;
mName.clear();
mModel.clear();
mIcon.clear();
mScript = ESM::RefId();
mEnchant = ESM::RefId();
mText.clear();
}
}
| 2,905
|
C++
|
.cpp
| 94
| 18.829787
| 68
| 0.471806
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,538
|
loadgmst.cpp
|
OpenMW_openmw/components/esm3/loadgmst.cpp
|
#include "loadgmst.hpp"
#include "esmreader.hpp"
#include "esmwriter.hpp"
namespace ESM
{
void GameSetting::load(ESMReader& esm, bool& isDeleted)
{
isDeleted = false; // GameSetting record can't be deleted now (may be changed in the future)
mRecordFlags = esm.getRecordFlags();
mId = esm.getHNRefId("NAME");
mValue.read(esm, Variant::Format_Gmst);
}
void GameSetting::save(ESMWriter& esm, bool /*isDeleted*/) const
{
esm.writeHNCRefId("NAME", mId);
mValue.write(esm, Variant::Format_Gmst);
}
void GameSetting::blank()
{
mRecordFlags = 0;
mValue.setType(VT_None);
}
bool operator==(const GameSetting& left, const GameSetting& right)
{
return left.mValue == right.mValue;
}
}
| 800
|
C++
|
.cpp
| 27
| 23.962963
| 100
| 0.646675
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,539
|
loadbsgn.cpp
|
OpenMW_openmw/components/esm3/loadbsgn.cpp
|
#include "loadbsgn.hpp"
#include "esmreader.hpp"
#include "esmwriter.hpp"
namespace ESM
{
void BirthSign::load(ESMReader& esm, bool& isDeleted)
{
isDeleted = false;
mRecordFlags = esm.getRecordFlags();
mPowers.mList.clear();
bool hasName = false;
while (esm.hasMoreSubs())
{
esm.getSubName();
switch (esm.retSubName().toInt())
{
case SREC_NAME:
mId = esm.getRefId();
hasName = true;
break;
case fourCC("FNAM"):
mName = esm.getHString();
break;
case fourCC("TNAM"):
mTexture = esm.getHString();
break;
case fourCC("DESC"):
mDescription = esm.getHString();
break;
case fourCC("NPCS"):
mPowers.add(esm);
break;
case SREC_DELE:
esm.skipHSub();
isDeleted = true;
break;
default:
esm.fail("Unknown subrecord");
break;
}
}
if (!hasName)
esm.fail("Missing NAME subrecord");
}
void BirthSign::save(ESMWriter& esm, bool isDeleted) const
{
esm.writeHNCRefId("NAME", mId);
if (isDeleted)
{
esm.writeHNString("DELE", "", 3);
return;
}
esm.writeHNOCString("FNAM", mName);
esm.writeHNOCString("TNAM", mTexture);
esm.writeHNOCString("DESC", mDescription);
mPowers.save(esm);
}
void BirthSign::blank()
{
mRecordFlags = 0;
mName.clear();
mDescription.clear();
mTexture.clear();
mPowers.mList.clear();
}
}
| 1,917
|
C++
|
.cpp
| 66
| 16.984848
| 62
| 0.461706
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,540
|
creaturestate.cpp
|
OpenMW_openmw/components/esm3/creaturestate.cpp
|
#include "creaturestate.hpp"
namespace ESM
{
void CreatureState::load(ESMReader& esm)
{
ObjectState::load(esm);
if (mHasCustomState)
{
mInventory.load(esm);
mCreatureStats.load(esm);
}
}
void CreatureState::save(ESMWriter& esm, bool inInventory) const
{
ObjectState::save(esm, inInventory);
if (mHasCustomState)
{
mInventory.save(esm);
mCreatureStats.save(esm);
}
}
void CreatureState::blank()
{
ObjectState::blank();
mCreatureStats.blank();
}
}
| 619
|
C++
|
.cpp
| 27
| 15.518519
| 68
| 0.574614
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,541
|
loadalch.cpp
|
OpenMW_openmw/components/esm3/loadalch.cpp
|
#include "loadalch.hpp"
#include "esmreader.hpp"
#include "esmwriter.hpp"
#include <components/misc/concepts.hpp>
namespace ESM
{
template <Misc::SameAsWithoutCvref<Potion::ALDTstruct> T>
void decompose(T&& v, const auto& f)
{
f(v.mWeight, v.mValue, v.mFlags);
}
void Potion::load(ESMReader& esm, bool& isDeleted)
{
isDeleted = false;
mRecordFlags = esm.getRecordFlags();
mEffects.mList.clear();
bool hasName = false;
bool hasData = false;
while (esm.hasMoreSubs())
{
esm.getSubName();
switch (esm.retSubName().toInt())
{
case SREC_NAME:
mId = esm.getRefId();
hasName = true;
break;
case fourCC("MODL"):
mModel = esm.getHString();
break;
case fourCC("TEXT"): // not ITEX here for some reason
mIcon = esm.getHString();
break;
case fourCC("SCRI"):
mScript = esm.getRefId();
break;
case fourCC("FNAM"):
mName = esm.getHString();
break;
case fourCC("ALDT"):
esm.getSubComposite(mData);
hasData = true;
break;
case fourCC("ENAM"):
mEffects.add(esm);
break;
case SREC_DELE:
esm.skipHSub();
isDeleted = true;
break;
default:
esm.fail("Unknown subrecord");
break;
}
}
if (!hasName)
esm.fail("Missing NAME subrecord");
if (!hasData && !isDeleted)
esm.fail("Missing ALDT subrecord");
}
void Potion::save(ESMWriter& esm, bool isDeleted) const
{
esm.writeHNCRefId("NAME", mId);
if (isDeleted)
{
esm.writeHNString("DELE", "", 3);
return;
}
esm.writeHNCString("MODL", mModel);
esm.writeHNOCString("TEXT", mIcon);
esm.writeHNOCRefId("SCRI", mScript);
esm.writeHNOCString("FNAM", mName);
esm.writeNamedComposite("ALDT", mData);
mEffects.save(esm);
}
void Potion::blank()
{
mRecordFlags = 0;
mData.mWeight = 0;
mData.mValue = 0;
mData.mFlags = 0;
mName.clear();
mModel.clear();
mIcon.clear();
mScript = ESM::RefId();
mEffects.mList.clear();
}
}
| 2,690
|
C++
|
.cpp
| 88
| 18.636364
| 69
| 0.474537
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,542
|
dialoguecondition.cpp
|
OpenMW_openmw/components/esm3/dialoguecondition.cpp
|
#include "dialoguecondition.hpp"
#include "esmreader.hpp"
#include "esmwriter.hpp"
#include "variant.hpp"
#include <components/debug/debuglog.hpp>
#include <components/misc/concepts.hpp>
#include <components/misc/strings/conversion.hpp>
namespace ESM
{
std::optional<DialogueCondition> DialogueCondition::load(ESMReader& esm, ESM::RefId context)
{
std::string rule = esm.getHString();
ESM::Variant variant;
variant.read(esm, Variant::Format_Info);
if (rule.size() < 5)
{
Log(Debug::Warning) << "Found invalid SCVR rule of size " << rule.size() << " in INFO " << context;
return {};
}
if (rule[4] < '0' || rule[4] > '5')
{
Log(Debug::Warning) << "Found invalid SCVR comparison operator " << static_cast<int>(rule[4]) << " in INFO "
<< context;
return {};
}
DialogueCondition condition;
if (rule[0] >= '0' && rule[0] <= '9')
condition.mIndex = rule[0] - '0';
else
{
Log(Debug::Info) << "Found invalid SCVR index " << static_cast<int>(rule[0]) << " in INFO " << context;
condition.mIndex = 0;
}
if (rule[1] == '1')
{
int function = Misc::StringUtils::toNumeric<int>(std::string_view{ rule }.substr(2, 2), -1);
if (function >= Function_FacReactionLowest && function <= Function_PcWerewolfKills)
condition.mFunction = static_cast<Function>(function);
else
{
Log(Debug::Warning) << "Encountered invalid SCVR function index " << function << " in INFO " << context;
return {};
}
}
else if ((rule[1] > '1' && rule[1] <= '9') || (rule[1] >= 'A' && rule[1] <= 'C'))
{
if (rule.size() == 5)
{
Log(Debug::Warning) << "Missing variable for SCVR of type " << rule[1] << " in INFO " << context;
return {};
}
bool malformed = rule[3] != 'X';
if (rule[1] == '2')
{
condition.mFunction = Function_Global;
malformed |= rule[2] != 'f' && rule[2] != 'l' && rule[2] != 's';
}
else if (rule[1] == '3')
{
condition.mFunction = Function_Local;
malformed |= rule[2] != 'f' && rule[2] != 'l' && rule[2] != 's';
}
else if (rule[1] == '4')
{
condition.mFunction = Function_Journal;
malformed |= rule[2] != 'J';
}
else if (rule[1] == '5')
{
condition.mFunction = Function_Item;
malformed |= rule[2] != 'I';
}
else if (rule[1] == '6')
{
condition.mFunction = Function_Dead;
malformed |= rule[2] != 'D';
}
else if (rule[1] == '7')
{
condition.mFunction = Function_NotId;
malformed |= rule[2] != 'X';
}
else if (rule[1] == '8')
{
condition.mFunction = Function_NotFaction;
malformed |= rule[2] != 'F';
}
else if (rule[1] == '9')
{
condition.mFunction = Function_NotClass;
malformed |= rule[2] != 'C';
}
else if (rule[1] == 'A')
{
condition.mFunction = Function_NotRace;
malformed |= rule[2] != 'R';
}
else if (rule[1] == 'B')
{
condition.mFunction = Function_NotCell;
malformed |= rule[2] != 'L';
}
else if (rule[1] == 'C')
{
condition.mFunction = Function_NotLocal;
malformed |= rule[2] != 'f' && rule[2] != 'l' && rule[2] != 's';
}
if (malformed)
Log(Debug::Info) << "Found malformed SCVR rule in INFO " << context;
}
else
{
Log(Debug::Warning) << "Found invalid SCVR function " << static_cast<int>(rule[1]) << " in INFO "
<< context;
return {};
}
condition.mComparison = static_cast<Comparison>(rule[4]);
condition.mVariable = rule.substr(5);
if (variant.getType() == VT_Int)
condition.mValue = variant.getInteger();
else if (variant.getType() == VT_Float)
condition.mValue = variant.getFloat();
else
{
Log(Debug::Warning) << "Found invalid SCVR variant " << variant.getType() << " in INFO " << context;
return {};
}
return condition;
}
void DialogueCondition::save(ESMWriter& esm) const
{
auto variant = std::visit([](auto value) { return ESM::Variant(value); }, mValue);
if (variant.getType() != VT_Float)
variant.setType(VT_Int);
std::string rule;
rule.reserve(5 + mVariable.size());
rule += static_cast<char>(mIndex + '0');
const auto appendVariableType = [&]() {
if (variant.getType() == VT_Float)
rule += "fX";
else
{
int32_t value = variant.getInteger();
if (static_cast<int16_t>(value) == value)
rule += "sX";
else
rule += "lX";
}
};
if (mFunction == Function_Global)
{
rule += '2';
appendVariableType();
}
else if (mFunction == Function_Local)
{
rule += '3';
appendVariableType();
}
else if (mFunction == Function_Journal)
rule += "4JX";
else if (mFunction == Function_Item)
rule += "5IX";
else if (mFunction == Function_Dead)
rule += "6DX";
else if (mFunction == Function_NotId)
rule += "7XX";
else if (mFunction == Function_NotFaction)
rule += "8FX";
else if (mFunction == Function_NotClass)
rule += "9CX";
else if (mFunction == Function_NotRace)
rule += "ARX";
else if (mFunction == Function_NotCell)
rule += "BLX";
else if (mFunction == Function_NotLocal)
{
rule += 'C';
appendVariableType();
}
else
{
rule += "100";
char* start = rule.data() + rule.size();
char* end = start;
if (mFunction < Function_PcStrength)
start--;
else
start -= 2;
auto result = std::to_chars(start, end, static_cast<int>(mFunction));
if (result.ec != std::errc())
{
Log(Debug::Error) << "Failed to save SCVR rule";
return;
}
}
rule += static_cast<char>(mComparison);
rule += mVariable;
esm.writeHNString("SCVR", rule);
variant.write(esm, Variant::Format_Info);
}
}
| 7,235
|
C++
|
.cpp
| 202
| 23.866337
| 120
| 0.460521
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,543
|
loadmgef.cpp
|
OpenMW_openmw/components/esm3/loadmgef.cpp
|
#include "loadmgef.hpp"
#include "esmreader.hpp"
#include "esmwriter.hpp"
#include "loadskil.hpp"
#include <components/misc/strings/algorithm.hpp>
namespace ESM
{
namespace
{
const int NumberOfHardcodedFlags = 143;
const int HardcodedFlags[NumberOfHardcodedFlags] = { 0x11c8, 0x11c0, 0x11c8, 0x11e0, 0x11e0, 0x11e0, 0x11e0,
0x11d0, 0x11c0, 0x11c0, 0x11e0, 0x11c0, 0x11184, 0x11184, 0x1f0, 0x1f0, 0x1f0, 0x11d2, 0x11f0, 0x11d0,
0x11d0, 0x11d1, 0x1d2, 0x1f0, 0x1d0, 0x1d0, 0x1d1, 0x1f0, 0x11d0, 0x11d0, 0x11d0, 0x11d0, 0x11d0, 0x11d0,
0x11d0, 0x11d0, 0x11d0, 0x1d0, 0x1d0, 0x11c8, 0x31c0, 0x11c0, 0x11c0, 0x11c0, 0x1180, 0x11d8, 0x11d8,
0x11d0, 0x11d0, 0x11180, 0x11180, 0x11180, 0x11180, 0x11180, 0x11180, 0x11180, 0x11180, 0x11c4, 0x111b8,
0x1040, 0x104c, 0x104c, 0x104c, 0x104c, 0x1040, 0x1040, 0x1040, 0x11c0, 0x11c0, 0x1cc, 0x1cc, 0x1cc, 0x1cc,
0x1cc, 0x1c2, 0x1c0, 0x1c0, 0x1c0, 0x1c1, 0x11c2, 0x11c0, 0x11c0, 0x11c0, 0x11c1, 0x11c0, 0x21192, 0x20190,
0x20190, 0x20190, 0x21191, 0x11c0, 0x11c0, 0x11c0, 0x11c0, 0x11c0, 0x11c0, 0x11c0, 0x11c0, 0x11c0, 0x11c0,
0x1c0, 0x11190, 0x9048, 0x9048, 0x9048, 0x9048, 0x9048, 0x9048, 0x9048, 0x9048, 0x9048, 0x9048, 0x9048,
0x9048, 0x9048, 0x9048, 0x9048, 0x11c0, 0x1180, 0x1180, 0x5048, 0x5048, 0x5048, 0x5048, 0x5048, 0x5048,
0x1188, 0x5048, 0x5048, 0x5048, 0x5048, 0x5048, 0x1048, 0x104c, 0x1048, 0x40, 0x11c8, 0x1048, 0x1048,
0x1048, 0x1048, 0x1048, 0x1048 };
}
void MagicEffect::load(ESMReader& esm, bool& isDeleted)
{
isDeleted = false; // MagicEffect record can't be deleted now (may be changed in the future)
mRecordFlags = esm.getRecordFlags();
esm.getHNT(mIndex, "INDX");
mId = indexToRefId(mIndex);
esm.getSubNameIs("MEDT");
esm.getSubHeader();
int32_t school;
esm.getT(school);
mData.mSchool = MagicSchool::indexToSkillRefId(school);
esm.getT(mData.mBaseCost);
esm.getT(mData.mFlags);
esm.getT(mData.mRed);
esm.getT(mData.mGreen);
esm.getT(mData.mBlue);
esm.getT(mData.mUnknown1);
esm.getT(mData.mSpeed);
esm.getT(mData.mUnknown2);
if (esm.getFormatVersion() == DefaultFormatVersion)
{
// don't allow mods to change fixed flags in the legacy format
mData.mFlags &= (AllowSpellmaking | AllowEnchanting | NegativeLight);
if (mIndex >= 0 && mIndex < NumberOfHardcodedFlags)
mData.mFlags |= HardcodedFlags[mIndex];
}
// vanilla MW accepts the _SND subrecords before or after DESC... I hope
// this isn't true for other records, or we have to do a mass-refactor
while (esm.hasMoreSubs())
{
esm.getSubName();
switch (esm.retSubName().toInt())
{
case fourCC("ITEX"):
mIcon = esm.getHString();
break;
case fourCC("PTEX"):
mParticle = esm.getHString();
break;
case fourCC("BSND"):
mBoltSound = esm.getRefId();
break;
case fourCC("CSND"):
mCastSound = esm.getRefId();
break;
case fourCC("HSND"):
mHitSound = esm.getRefId();
break;
case fourCC("ASND"):
mAreaSound = esm.getRefId();
break;
case fourCC("CVFX"):
mCasting = esm.getRefId();
break;
case fourCC("BVFX"):
mBolt = esm.getRefId();
break;
case fourCC("HVFX"):
mHit = esm.getRefId();
break;
case fourCC("AVFX"):
mArea = esm.getRefId();
break;
case fourCC("DESC"):
mDescription = esm.getHString();
break;
default:
esm.fail("Unknown subrecord");
}
}
}
void MagicEffect::save(ESMWriter& esm, bool /*isDeleted*/) const
{
esm.writeHNT("INDX", mIndex);
esm.startSubRecord("MEDT");
esm.writeT(MagicSchool::skillRefIdToIndex(mData.mSchool));
esm.writeT(mData.mBaseCost);
esm.writeT(mData.mFlags);
esm.writeT(mData.mRed);
esm.writeT(mData.mGreen);
esm.writeT(mData.mBlue);
esm.writeT(mData.mUnknown1);
esm.writeT(mData.mSpeed);
esm.writeT(mData.mUnknown2);
esm.endRecord("MEDT");
esm.writeHNOCString("ITEX", mIcon);
esm.writeHNOCString("PTEX", mParticle);
esm.writeHNOCRefId("BSND", mBoltSound);
esm.writeHNOCRefId("CSND", mCastSound);
esm.writeHNOCRefId("HSND", mHitSound);
esm.writeHNOCRefId("ASND", mAreaSound);
esm.writeHNOCRefId("CVFX", mCasting);
esm.writeHNOCRefId("BVFX", mBolt);
esm.writeHNOCRefId("HVFX", mHit);
esm.writeHNOCRefId("AVFX", mArea);
esm.writeHNOString("DESC", mDescription);
}
namespace
{
std::map<short, short> makeEffectsMap()
{
std::map<short, short> effects;
effects[MagicEffect::Effects::DisintegrateArmor] = MagicEffect::Effects::Sanctuary;
effects[MagicEffect::Effects::DisintegrateWeapon] = MagicEffect::Effects::Sanctuary;
for (int i = MagicEffect::Effects::DrainAttribute; i <= MagicEffect::Effects::DamageSkill; ++i)
effects[i] = MagicEffect::Effects::ResistMagicka;
for (int i = MagicEffect::Effects::AbsorbAttribute; i <= MagicEffect::Effects::AbsorbSkill; ++i)
effects[i] = MagicEffect::Effects::ResistMagicka;
for (int i = MagicEffect::Effects::WeaknessToFire; i <= MagicEffect::Effects::WeaknessToNormalWeapons; ++i)
effects[i] = MagicEffect::Effects::ResistMagicka;
effects[MagicEffect::Effects::Burden] = MagicEffect::Effects::ResistMagicka;
effects[MagicEffect::Effects::Charm] = MagicEffect::Effects::ResistMagicka;
effects[MagicEffect::Effects::Silence] = MagicEffect::Effects::ResistMagicka;
effects[MagicEffect::Effects::Blind] = MagicEffect::Effects::ResistMagicka;
effects[MagicEffect::Effects::Sound] = MagicEffect::Effects::ResistMagicka;
for (int i = 0; i < 2; ++i)
{
effects[MagicEffect::Effects::CalmHumanoid + i] = MagicEffect::Effects::ResistMagicka;
effects[MagicEffect::Effects::FrenzyHumanoid + i] = MagicEffect::Effects::ResistMagicka;
effects[MagicEffect::Effects::DemoralizeHumanoid + i] = MagicEffect::Effects::ResistMagicka;
effects[MagicEffect::Effects::RallyHumanoid + i] = MagicEffect::Effects::ResistMagicka;
}
effects[MagicEffect::Effects::TurnUndead] = MagicEffect::Effects::ResistMagicka;
effects[MagicEffect::Effects::FireDamage] = MagicEffect::Effects::ResistFire;
effects[MagicEffect::Effects::FrostDamage] = MagicEffect::Effects::ResistFrost;
effects[MagicEffect::Effects::ShockDamage] = MagicEffect::Effects::ResistShock;
effects[MagicEffect::Effects::Vampirism] = MagicEffect::Effects::ResistCommonDisease;
effects[MagicEffect::Effects::Corprus] = MagicEffect::Effects::ResistCorprusDisease;
effects[MagicEffect::Effects::Poison] = MagicEffect::Effects::ResistPoison;
effects[MagicEffect::Effects::Paralyze] = MagicEffect::Effects::ResistParalysis;
return effects;
}
}
short MagicEffect::getResistanceEffect(short effect)
{
// Source https://wiki.openmw.org/index.php?title=Research:Magic#Effect_attribute
// <Effect, Effect providing resistance against first effect>
static const std::map<short, short> effects = makeEffectsMap();
if (const auto it = effects.find(effect); it != effects.end())
return it->second;
return -1;
}
short MagicEffect::getWeaknessEffect(short effect)
{
static std::map<short, short> effects;
if (effects.empty())
{
for (int i = DrainAttribute; i <= DamageSkill; ++i)
effects[i] = WeaknessToMagicka;
for (int i = AbsorbAttribute; i <= AbsorbSkill; ++i)
effects[i] = WeaknessToMagicka;
for (int i = WeaknessToFire; i <= WeaknessToNormalWeapons; ++i)
effects[i] = WeaknessToMagicka;
effects[Burden] = WeaknessToMagicka;
effects[Charm] = WeaknessToMagicka;
effects[Silence] = WeaknessToMagicka;
effects[Blind] = WeaknessToMagicka;
effects[Sound] = WeaknessToMagicka;
for (int i = 0; i < 2; ++i)
{
effects[CalmHumanoid + i] = WeaknessToMagicka;
effects[FrenzyHumanoid + i] = WeaknessToMagicka;
effects[DemoralizeHumanoid + i] = WeaknessToMagicka;
effects[RallyHumanoid + i] = WeaknessToMagicka;
}
effects[TurnUndead] = WeaknessToMagicka;
effects[FireDamage] = WeaknessToFire;
effects[FrostDamage] = WeaknessToFrost;
effects[ShockDamage] = WeaknessToShock;
effects[Vampirism] = WeaknessToCommonDisease;
effects[Corprus] = WeaknessToCorprusDisease;
effects[Poison] = WeaknessToPoison;
effects[Paralyze] = -1;
}
if (effects.find(effect) != effects.end())
return effects[effect];
else
return -1;
}
// Map effect ID to GMST name
const std::array<std::string, MagicEffect::Length> MagicEffect::sGmstEffectIds = {
"sEffectWaterBreathing",
"sEffectSwiftSwim",
"sEffectWaterWalking",
"sEffectShield",
"sEffectFireShield",
"sEffectLightningShield",
"sEffectFrostShield",
"sEffectBurden",
"sEffectFeather",
"sEffectJump",
"sEffectLevitate",
"sEffectSlowFall",
"sEffectLock",
"sEffectOpen",
"sEffectFireDamage",
"sEffectShockDamage",
"sEffectFrostDamage",
"sEffectDrainAttribute",
"sEffectDrainHealth",
"sEffectDrainSpellpoints",
"sEffectDrainFatigue",
"sEffectDrainSkill",
"sEffectDamageAttribute",
"sEffectDamageHealth",
"sEffectDamageMagicka",
"sEffectDamageFatigue",
"sEffectDamageSkill",
"sEffectPoison",
"sEffectWeaknesstoFire",
"sEffectWeaknesstoFrost",
"sEffectWeaknesstoShock",
"sEffectWeaknesstoMagicka",
"sEffectWeaknesstoCommonDisease",
"sEffectWeaknesstoBlightDisease",
"sEffectWeaknesstoCorprusDisease",
"sEffectWeaknesstoPoison",
"sEffectWeaknesstoNormalWeapons",
"sEffectDisintegrateWeapon",
"sEffectDisintegrateArmor",
"sEffectInvisibility",
"sEffectChameleon",
"sEffectLight",
"sEffectSanctuary",
"sEffectNightEye",
"sEffectCharm",
"sEffectParalyze",
"sEffectSilence",
"sEffectBlind",
"sEffectSound",
"sEffectCalmHumanoid",
"sEffectCalmCreature",
"sEffectFrenzyHumanoid",
"sEffectFrenzyCreature",
"sEffectDemoralizeHumanoid",
"sEffectDemoralizeCreature",
"sEffectRallyHumanoid",
"sEffectRallyCreature",
"sEffectDispel",
"sEffectSoultrap",
"sEffectTelekinesis",
"sEffectMark",
"sEffectRecall",
"sEffectDivineIntervention",
"sEffectAlmsiviIntervention",
"sEffectDetectAnimal",
"sEffectDetectEnchantment",
"sEffectDetectKey",
"sEffectSpellAbsorption",
"sEffectReflect",
"sEffectCureCommonDisease",
"sEffectCureBlightDisease",
"sEffectCureCorprusDisease",
"sEffectCurePoison",
"sEffectCureParalyzation",
"sEffectRestoreAttribute",
"sEffectRestoreHealth",
"sEffectRestoreSpellPoints",
"sEffectRestoreFatigue",
"sEffectRestoreSkill",
"sEffectFortifyAttribute",
"sEffectFortifyHealth",
"sEffectFortifySpellpoints",
"sEffectFortifyFatigue",
"sEffectFortifySkill",
"sEffectFortifyMagickaMultiplier",
"sEffectAbsorbAttribute",
"sEffectAbsorbHealth",
"sEffectAbsorbSpellPoints",
"sEffectAbsorbFatigue",
"sEffectAbsorbSkill",
"sEffectResistFire",
"sEffectResistFrost",
"sEffectResistShock",
"sEffectResistMagicka",
"sEffectResistCommonDisease",
"sEffectResistBlightDisease",
"sEffectResistCorprusDisease",
"sEffectResistPoison",
"sEffectResistNormalWeapons",
"sEffectResistParalysis",
"sEffectRemoveCurse",
"sEffectTurnUndead",
"sEffectSummonScamp",
"sEffectSummonClannfear",
"sEffectSummonDaedroth",
"sEffectSummonDremora",
"sEffectSummonAncestralGhost",
"sEffectSummonSkeletalMinion",
"sEffectSummonLeastBonewalker",
"sEffectSummonGreaterBonewalker",
"sEffectSummonBonelord",
"sEffectSummonWingedTwilight",
"sEffectSummonHunger",
"sEffectSummonGoldenSaint",
"sEffectSummonFlameAtronach",
"sEffectSummonFrostAtronach",
"sEffectSummonStormAtronach",
"sEffectFortifyAttackBonus",
"sEffectCommandCreatures",
"sEffectCommandHumanoids",
"sEffectBoundDagger",
"sEffectBoundLongsword",
"sEffectBoundMace",
"sEffectBoundBattleAxe",
"sEffectBoundSpear",
"sEffectBoundLongbow",
"sEffectExtraSpell",
"sEffectBoundCuirass",
"sEffectBoundHelm",
"sEffectBoundBoots",
"sEffectBoundShield",
"sEffectBoundGloves",
"sEffectCorpus", // NB this typo. (bethesda made it)
"sEffectVampirism",
"sEffectSummonCenturionSphere",
"sEffectSunDamage",
"sEffectStuntedMagicka",
// tribunal
"sEffectSummonFabricant",
// bloodmoon
"sEffectSummonCreature01",
"sEffectSummonCreature02",
"sEffectSummonCreature03",
"sEffectSummonCreature04",
"sEffectSummonCreature05",
};
// Map effect ID to identifying name
const std::array<std::string_view, MagicEffect::Length> MagicEffect::sIndexNames = {
"WaterBreathing",
"SwiftSwim",
"WaterWalking",
"Shield",
"FireShield",
"LightningShield",
"FrostShield",
"Burden",
"Feather",
"Jump",
"Levitate",
"SlowFall",
"Lock",
"Open",
"FireDamage",
"ShockDamage",
"FrostDamage",
"DrainAttribute",
"DrainHealth",
"DrainMagicka",
"DrainFatigue",
"DrainSkill",
"DamageAttribute",
"DamageHealth",
"DamageMagicka",
"DamageFatigue",
"DamageSkill",
"Poison",
"WeaknessToFire",
"WeaknessToFrost",
"WeaknessToShock",
"WeaknessToMagicka",
"WeaknessToCommonDisease",
"WeaknessToBlightDisease",
"WeaknessToCorprusDisease",
"WeaknessToPoison",
"WeaknessToNormalWeapons",
"DisintegrateWeapon",
"DisintegrateArmor",
"Invisibility",
"Chameleon",
"Light",
"Sanctuary",
"NightEye",
"Charm",
"Paralyze",
"Silence",
"Blind",
"Sound",
"CalmHumanoid",
"CalmCreature",
"FrenzyHumanoid",
"FrenzyCreature",
"DemoralizeHumanoid",
"DemoralizeCreature",
"RallyHumanoid",
"RallyCreature",
"Dispel",
"Soultrap",
"Telekinesis",
"Mark",
"Recall",
"DivineIntervention",
"AlmsiviIntervention",
"DetectAnimal",
"DetectEnchantment",
"DetectKey",
"SpellAbsorption",
"Reflect",
"CureCommonDisease",
"CureBlightDisease",
"CureCorprusDisease",
"CurePoison",
"CureParalyzation",
"RestoreAttribute",
"RestoreHealth",
"RestoreMagicka",
"RestoreFatigue",
"RestoreSkill",
"FortifyAttribute",
"FortifyHealth",
"FortifyMagicka",
"FortifyFatigue",
"FortifySkill",
"FortifyMaximumMagicka",
"AbsorbAttribute",
"AbsorbHealth",
"AbsorbMagicka",
"AbsorbFatigue",
"AbsorbSkill",
"ResistFire",
"ResistFrost",
"ResistShock",
"ResistMagicka",
"ResistCommonDisease",
"ResistBlightDisease",
"ResistCorprusDisease",
"ResistPoison",
"ResistNormalWeapons",
"ResistParalysis",
"RemoveCurse",
"TurnUndead",
"SummonScamp",
"SummonClannfear",
"SummonDaedroth",
"SummonDremora",
"SummonAncestralGhost",
"SummonSkeletalMinion",
"SummonBonewalker",
"SummonGreaterBonewalker",
"SummonBonelord",
"SummonWingedTwilight",
"SummonHunger",
"SummonGoldenSaint",
"SummonFlameAtronach",
"SummonFrostAtronach",
"SummonStormAtronach",
"FortifyAttack",
"CommandCreature",
"CommandHumanoid",
"BoundDagger",
"BoundLongsword",
"BoundMace",
"BoundBattleAxe",
"BoundSpear",
"BoundLongbow",
"ExtraSpell",
"BoundCuirass",
"BoundHelm",
"BoundBoots",
"BoundShield",
"BoundGloves",
"Corprus",
"Vampirism",
"SummonCenturionSphere",
"SunDamage",
"StuntedMagicka",
// tribunal
"SummonFabricant",
// bloodmoon
"SummonWolf",
"SummonBear",
"SummonBonewolf",
"SummonCreature04",
"SummonCreature05",
};
template <typename Collection>
static std::map<std::string_view, int, Misc::StringUtils::CiComp> initStringToIntMap(const Collection& strings)
{
std::map<std::string_view, int, Misc::StringUtils::CiComp> map;
for (size_t i = 0; i < strings.size(); i++)
map[strings[i]] = i;
return map;
}
const std::map<std::string_view, int, Misc::StringUtils::CiComp> MagicEffect::sGmstEffectIdToIndexMap
= initStringToIntMap(MagicEffect::sGmstEffectIds);
const std::map<std::string_view, int, Misc::StringUtils::CiComp> MagicEffect::sIndexNameToIndexMap
= initStringToIntMap(MagicEffect::sIndexNames);
class FindSecond
{
std::string_view mName;
public:
FindSecond(std::string_view name)
: mName(name)
{
}
bool operator()(const std::pair<short, std::string>& item) const
{
if (Misc::StringUtils::ciEqual(item.second, mName))
return true;
return false;
}
};
MagicEffect::MagnitudeDisplayType MagicEffect::getMagnitudeDisplayType() const
{
if (mData.mFlags & NoMagnitude)
return MDT_None;
if (mIndex == 84)
return MDT_TimesInt;
if (mIndex == 59 || (mIndex >= 64 && mIndex <= 66))
return MDT_Feet;
if (mIndex == 118 || mIndex == 119)
return MDT_Level;
if ((mIndex >= 28 && mIndex <= 36) || (mIndex >= 90 && mIndex <= 99) || mIndex == 40 || mIndex == 47
|| mIndex == 57 || mIndex == 68)
return MDT_Percentage;
return MDT_Points;
}
void MagicEffect::blank()
{
mRecordFlags = 0;
mData.mSchool = ESM::Skill::Alteration;
mData.mBaseCost = 0;
mData.mFlags = 0;
mData.mRed = 0;
mData.mGreen = 0;
mData.mBlue = 0;
mData.mSpeed = 1;
mIcon.clear();
mParticle.clear();
mCasting = ESM::RefId();
mHit = ESM::RefId();
mArea = ESM::RefId();
mBolt = ESM::RefId();
mCastSound = ESM::RefId();
mBoltSound = ESM::RefId();
mHitSound = ESM::RefId();
mAreaSound = ESM::RefId();
mDescription.clear();
}
osg::Vec4f MagicEffect::getColor() const
{
osg::Vec4f color{ mData.mRed / 255.f, mData.mGreen / 255.f, mData.mBlue / 255.f, 1.f };
if (mData.mFlags & NegativeLight)
return osg::Vec4f(1.f, 1.f, 1.f, 2.f) - color;
return color;
}
const std::string& MagicEffect::indexToGmstString(int effectID)
{
if (effectID < 0 || static_cast<std::size_t>(effectID) >= sGmstEffectIds.size())
throw std::runtime_error(std::string("Unimplemented effect ID ") + std::to_string(effectID));
return sGmstEffectIds[effectID];
}
std::string_view MagicEffect::indexToName(int effectID)
{
if (effectID < 0 || static_cast<std::size_t>(effectID) >= sIndexNames.size())
throw std::runtime_error(std::string("Unimplemented effect ID ") + std::to_string(effectID));
return sIndexNames[effectID];
}
int MagicEffect::indexNameToIndex(std::string_view effect)
{
auto name = sIndexNameToIndexMap.find(effect);
if (name == sIndexNameToIndexMap.end())
return -1;
return name->second;
}
int MagicEffect::effectGmstIdToIndex(std::string_view gmstId)
{
auto name = sGmstEffectIdToIndexMap.find(gmstId);
if (name == sGmstEffectIdToIndexMap.end())
throw std::runtime_error("Unimplemented effect " + std::string(gmstId));
return name->second;
}
RefId MagicEffect::indexToRefId(int index)
{
if (index == -1)
return RefId();
return RefId::index(sRecordId, static_cast<std::uint32_t>(index));
}
}
| 22,393
|
C++
|
.cpp
| 602
| 27.234219
| 119
| 0.59942
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,544
|
savedgame.cpp
|
OpenMW_openmw/components/esm3/savedgame.cpp
|
#include "savedgame.hpp"
#include "esmreader.hpp"
#include "esmwriter.hpp"
#include <components/misc/algorithm.hpp>
#include <components/misc/concepts.hpp>
namespace ESM
{
template <Misc::SameAsWithoutCvref<EpochTimeStamp> T>
void decompose(T&& v, const auto& f)
{
f(v.mGameHour, v.mDay, v.mMonth, v.mYear);
}
void SavedGame::load(ESMReader& esm)
{
mPlayerName = esm.getHNString("PLNA");
esm.getHNOT(mPlayerLevel, "PLLE");
mPlayerClassId = esm.getHNORefId("PLCL");
mPlayerClassName = esm.getHNOString("PLCN");
if (esm.getFormatVersion() <= ESM::MaxSavedGameCellNameAsRefIdFormatVersion)
mPlayerCellName = esm.getHNRefId("PLCE").toString();
else
mPlayerCellName = esm.getHNString("PLCE");
esm.getNamedComposite("TSTM", mInGameTime);
esm.getHNT(mTimePlayed, "TIME");
mDescription = esm.getHNString("DESC");
while (esm.isNextSub("DEPE"))
mContentFiles.push_back(esm.getHString());
esm.getSubNameIs("SCRN");
esm.getSubHeader();
mScreenshot.resize(esm.getSubSize());
esm.getExact(mScreenshot.data(), mScreenshot.size());
esm.getHNOT(mCurrentDay, "CDAY");
esm.getHNOT(mCurrentHealth, "CHLT");
esm.getHNOT(mMaximumHealth, "MHLT");
}
void SavedGame::save(ESMWriter& esm) const
{
esm.writeHNString("PLNA", mPlayerName);
esm.writeHNT("PLLE", mPlayerLevel);
if (!mPlayerClassId.empty())
esm.writeHNRefId("PLCL", mPlayerClassId);
else
esm.writeHNString("PLCN", mPlayerClassName);
esm.writeHNString("PLCE", mPlayerCellName);
esm.writeNamedComposite("TSTM", mInGameTime);
esm.writeHNT("TIME", mTimePlayed);
esm.writeHNString("DESC", mDescription);
for (const std::string& dependency : mContentFiles)
esm.writeHNString("DEPE", dependency);
esm.startSubRecord("SCRN");
esm.write(mScreenshot.data(), mScreenshot.size());
esm.endRecord("SCRN");
esm.writeHNT("CDAY", mCurrentDay);
esm.writeHNT("CHLT", mCurrentHealth);
esm.writeHNT("MHLT", mMaximumHealth);
}
std::vector<std::string_view> SavedGame::getMissingContentFiles(
const std::vector<std::string>& allContentFiles) const
{
std::vector<std::string_view> missingFiles;
for (const std::string& contentFile : mContentFiles)
{
auto it = std::find_if(allContentFiles.begin(), allContentFiles.end(),
[&](const std::string& file) { return Misc::StringUtils::ciEqual(file, contentFile); });
if (it == allContentFiles.end())
{
missingFiles.emplace_back(contentFile);
}
}
return missingFiles;
}
}
| 2,858
|
C++
|
.cpp
| 72
| 31.291667
| 104
| 0.635247
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,545
|
aisequence.cpp
|
OpenMW_openmw/components/esm3/aisequence.cpp
|
#include "aisequence.hpp"
#include "esmreader.hpp"
#include "esmwriter.hpp"
#include <components/misc/concepts.hpp>
#include <algorithm>
#include <memory>
namespace ESM
{
template <Misc::SameAsWithoutCvref<AiSequence::AiWanderData> T>
void decompose(T&& v, const auto& f)
{
f(v.mDistance, v.mDuration, v.mTimeOfDay, v.mIdle, v.mShouldRepeat);
}
template <Misc::SameAsWithoutCvref<AiSequence::AiWanderDuration> T>
void decompose(T&& v, const auto& f)
{
std::uint32_t unused = 0;
f(v.mRemainingDuration, unused);
}
template <Misc::SameAsWithoutCvref<AiSequence::AiTravelData> T>
void decompose(T&& v, const auto& f)
{
f(v.mX, v.mY, v.mZ);
}
template <Misc::SameAsWithoutCvref<AiSequence::AiEscortData> T>
void decompose(T&& v, const auto& f)
{
f(v.mX, v.mY, v.mZ, v.mDuration);
}
namespace AiSequence
{
void AiWander::load(ESMReader& esm)
{
esm.getNamedComposite("DATA", mData);
esm.getNamedComposite("STAR", mDurationData); // was mStartTime
mStoredInitialActorPosition = esm.getHNOT("POS_", mInitialActorPosition.mValues);
}
void AiWander::save(ESMWriter& esm) const
{
esm.writeNamedComposite("DATA", mData);
esm.writeNamedComposite("STAR", mDurationData); // was mStartTime
if (mStoredInitialActorPosition)
esm.writeHNT("POS_", mInitialActorPosition.mValues);
}
void AiTravel::load(ESMReader& esm)
{
esm.getNamedComposite("DATA", mData);
esm.getHNT(mHidden, "HIDD");
mRepeat = false;
esm.getHNOT(mRepeat, "REPT");
}
void AiTravel::save(ESMWriter& esm) const
{
esm.writeNamedComposite("DATA", mData);
esm.writeHNT("HIDD", mHidden);
if (mRepeat)
esm.writeHNT("REPT", mRepeat);
}
void AiEscort::load(ESMReader& esm)
{
esm.getNamedComposite("DATA", mData);
mTargetId = esm.getHNRefId("TARG");
mTargetActorId = -1;
esm.getHNOT(mTargetActorId, "TAID");
esm.getHNT(mRemainingDuration, "DURA");
mCellId = esm.getHNOString("CELL");
mRepeat = false;
esm.getHNOT(mRepeat, "REPT");
if (esm.getFormatVersion() <= MaxOldAiPackageFormatVersion)
{
// mDuration isn't saved in the save file, so just giving it "1" for now if the package has a duration.
// The exact value of mDuration only matters for repeating packages.
// Previously mRemainingDuration could be negative even when mDuration was 0. Checking for > 0 should
// fix old saves.
mData.mDuration = std::max<float>(mRemainingDuration > 0, mRemainingDuration);
}
}
void AiEscort::save(ESMWriter& esm) const
{
esm.writeNamedComposite("DATA", mData);
esm.writeHNRefId("TARG", mTargetId);
esm.writeHNT("TAID", mTargetActorId);
esm.writeHNT("DURA", mRemainingDuration);
if (!mCellId.empty())
esm.writeHNString("CELL", mCellId);
if (mRepeat)
esm.writeHNT("REPT", mRepeat);
}
void AiFollow::load(ESMReader& esm)
{
esm.getNamedComposite("DATA", mData);
mTargetId = esm.getHNRefId("TARG");
mTargetActorId = -1;
esm.getHNOT(mTargetActorId, "TAID");
esm.getHNT(mRemainingDuration, "DURA");
mCellId = esm.getHNOString("CELL");
esm.getHNT(mAlwaysFollow, "ALWY");
mCommanded = false;
esm.getHNOT(mCommanded, "CMND");
mActive = false;
esm.getHNOT(mActive, "ACTV");
mRepeat = false;
esm.getHNOT(mRepeat, "REPT");
if (esm.getFormatVersion() <= MaxOldAiPackageFormatVersion)
{
// mDuration isn't saved in the save file, so just giving it "1" for now if the package has a duration.
// The exact value of mDuration only matters for repeating packages.
// Previously mRemainingDuration could be negative even when mDuration was 0. Checking for > 0 should
// fix old saves.
mData.mDuration = std::max<float>(mRemainingDuration > 0, mRemainingDuration);
}
}
void AiFollow::save(ESMWriter& esm) const
{
esm.writeNamedComposite("DATA", mData);
esm.writeHNRefId("TARG", mTargetId);
esm.writeHNT("TAID", mTargetActorId);
esm.writeHNT("DURA", mRemainingDuration);
if (!mCellId.empty())
esm.writeHNString("CELL", mCellId);
esm.writeHNT("ALWY", mAlwaysFollow);
esm.writeHNT("CMND", mCommanded);
if (mActive)
esm.writeHNT("ACTV", mActive);
if (mRepeat)
esm.writeHNT("REPT", mRepeat);
}
void AiActivate::load(ESMReader& esm)
{
mTargetId = esm.getHNRefId("TARG");
mRepeat = false;
esm.getHNOT(mRepeat, "REPT");
}
void AiActivate::save(ESMWriter& esm) const
{
esm.writeHNRefId("TARG", mTargetId);
if (mRepeat)
esm.writeHNT("REPT", mRepeat);
}
void AiCombat::load(ESMReader& esm)
{
esm.getHNT(mTargetActorId, "TARG");
}
void AiCombat::save(ESMWriter& esm) const
{
esm.writeHNT("TARG", mTargetActorId);
}
void AiPursue::load(ESMReader& esm)
{
esm.getHNT(mTargetActorId, "TARG");
}
void AiPursue::save(ESMWriter& esm) const
{
esm.writeHNT("TARG", mTargetActorId);
}
void AiSequence::save(ESMWriter& esm) const
{
for (std::vector<AiPackageContainer>::const_iterator it = mPackages.begin(); it != mPackages.end(); ++it)
{
esm.writeHNT("AIPK", it->mType);
switch (it->mType)
{
case Ai_Wander:
static_cast<const AiWander&>(*it->mPackage).save(esm);
break;
case Ai_Travel:
static_cast<const AiTravel&>(*it->mPackage).save(esm);
break;
case Ai_Escort:
static_cast<const AiEscort&>(*it->mPackage).save(esm);
break;
case Ai_Follow:
static_cast<const AiFollow&>(*it->mPackage).save(esm);
break;
case Ai_Activate:
static_cast<const AiActivate&>(*it->mPackage).save(esm);
break;
case Ai_Combat:
static_cast<const AiCombat&>(*it->mPackage).save(esm);
break;
case Ai_Pursue:
static_cast<const AiPursue&>(*it->mPackage).save(esm);
break;
default:
break;
}
}
esm.writeHNT("LAST", mLastAiPackage);
}
void AiSequence::load(ESMReader& esm)
{
int count = 0;
while (esm.isNextSub("AIPK"))
{
int32_t type;
esm.getHT(type);
mPackages.emplace_back();
mPackages.back().mType = type;
switch (type)
{
case Ai_Wander:
{
std::unique_ptr<AiWander> ptr = std::make_unique<AiWander>();
ptr->load(esm);
mPackages.back().mPackage = std::move(ptr);
++count;
break;
}
case Ai_Travel:
{
std::unique_ptr<AiTravel> ptr = std::make_unique<AiTravel>();
ptr->load(esm);
mPackages.back().mPackage = std::move(ptr);
++count;
break;
}
case Ai_Escort:
{
std::unique_ptr<AiEscort> ptr = std::make_unique<AiEscort>();
ptr->load(esm);
mPackages.back().mPackage = std::move(ptr);
++count;
break;
}
case Ai_Follow:
{
std::unique_ptr<AiFollow> ptr = std::make_unique<AiFollow>();
ptr->load(esm);
mPackages.back().mPackage = std::move(ptr);
++count;
break;
}
case Ai_Activate:
{
std::unique_ptr<AiActivate> ptr = std::make_unique<AiActivate>();
ptr->load(esm);
mPackages.back().mPackage = std::move(ptr);
++count;
break;
}
case Ai_Combat:
{
std::unique_ptr<AiCombat> ptr = std::make_unique<AiCombat>();
ptr->load(esm);
mPackages.back().mPackage = std::move(ptr);
break;
}
case Ai_Pursue:
{
std::unique_ptr<AiPursue> ptr = std::make_unique<AiPursue>();
ptr->load(esm);
mPackages.back().mPackage = std::move(ptr);
break;
}
default:
return;
}
}
esm.getHNT(mLastAiPackage, "LAST");
if (count > 1 && esm.getFormatVersion() <= MaxOldAiPackageFormatVersion)
{
for (auto& pkg : mPackages)
{
if (pkg.mType == Ai_Wander)
static_cast<AiWander&>(*pkg.mPackage).mData.mShouldRepeat = true;
else if (pkg.mType == Ai_Travel)
static_cast<AiTravel&>(*pkg.mPackage).mRepeat = true;
else if (pkg.mType == Ai_Escort)
static_cast<AiEscort&>(*pkg.mPackage).mRepeat = true;
else if (pkg.mType == Ai_Follow)
static_cast<AiFollow&>(*pkg.mPackage).mRepeat = true;
else if (pkg.mType == Ai_Activate)
static_cast<AiActivate&>(*pkg.mPackage).mRepeat = true;
}
}
}
}
}
| 11,144
|
C++
|
.cpp
| 278
| 24.881295
| 119
| 0.48316
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,546
|
dialoguestate.cpp
|
OpenMW_openmw/components/esm3/dialoguestate.cpp
|
#include "dialoguestate.hpp"
#include "esmreader.hpp"
#include "esmwriter.hpp"
namespace ESM
{
void DialogueState::load(ESMReader& esm)
{
while (esm.isNextSub("TOPI"))
mKnownTopics.push_back(esm.getRefId());
while (esm.isNextSub("FACT"))
{
ESM::RefId faction = esm.getRefId();
while (esm.isNextSub("REA2"))
{
ESM::RefId faction2 = esm.getRefId();
int reaction;
esm.getHNT(reaction, "INTV");
mChangedFactionReaction[faction][faction2] = reaction;
}
}
}
void DialogueState::save(ESMWriter& esm) const
{
for (auto iter(mKnownTopics.begin()); iter != mKnownTopics.end(); ++iter)
{
esm.writeHNRefId("TOPI", *iter);
}
for (auto iter = mChangedFactionReaction.begin(); iter != mChangedFactionReaction.end(); ++iter)
{
esm.writeHNRefId("FACT", iter->first);
for (auto reactIter = iter->second.begin(); reactIter != iter->second.end(); ++reactIter)
{
esm.writeHNRefId("REA2", reactIter->first);
esm.writeHNT("INTV", reactIter->second);
}
}
}
}
| 1,264
|
C++
|
.cpp
| 38
| 23.605263
| 104
| 0.549712
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| true
| true
| false
|
34,547
|
inventorystate.cpp
|
OpenMW_openmw/components/esm3/inventorystate.cpp
|
#include "inventorystate.hpp"
#include "esmreader.hpp"
#include "esmwriter.hpp"
#include <components/misc/strings/algorithm.hpp>
namespace ESM
{
namespace
{
constexpr uint32_t sInvalidSlot = static_cast<uint32_t>(-1);
}
void InventoryState::load(ESMReader& esm)
{
// obsolete
while (esm.isNextSub("IOBJ"))
{
esm.skipHT<int32_t>();
ObjectState state;
state.mRef.loadId(esm, true);
state.load(esm);
if (state.mRef.mCount == 0)
continue;
mItems.push_back(state);
}
uint32_t itemsCount = 0;
esm.getHNOT(itemsCount, "ICNT");
for (; itemsCount > 0; --itemsCount)
{
ObjectState state;
state.mRef.loadId(esm, true);
state.load(esm);
// Update content file index if load order was changed.
if (!esm.applyContentFileMapping(state.mRef.mRefNum))
state.mRef.mRefNum = FormId(); // content file removed; unset refnum, but keep object.
if (state.mRef.mCount == 0)
continue;
mItems.push_back(state);
}
std::map<std::pair<ESM::RefId, std::string>, int32_t> levelledItemMap;
// Next item is Levelled item
while (esm.isNextSub("LEVM"))
{
// Get its name
ESM::RefId id = esm.getRefId();
int32_t count;
// Then get its count
esm.getHNT(count, "COUN");
std::string parentGroup = esm.getHNString("LGRP");
levelledItemMap[std::make_pair(id, parentGroup)] = count;
}
while (esm.isNextSub("MAGI"))
{
ESM::RefId id = esm.getRefId();
std::vector<std::pair<float, float>> params;
while (esm.isNextSub("RAND"))
{
float rand, multiplier;
esm.getHT(rand);
esm.getHNT(multiplier, "MULT");
params.emplace_back(rand, multiplier);
}
mPermanentMagicEffectMagnitudes[id] = std::move(params);
}
while (esm.isNextSub("EQUI"))
{
esm.getSubHeader();
int32_t equipIndex;
esm.getT(equipIndex);
int32_t slot;
esm.getT(slot);
mEquipmentSlots[equipIndex] = slot;
}
if (esm.isNextSub("EQIP"))
{
esm.getSubHeader();
uint32_t slotsCount = 0;
esm.getT(slotsCount);
for (; slotsCount > 0; --slotsCount)
{
int32_t equipIndex;
esm.getT(equipIndex);
int32_t slot;
esm.getT(slot);
mEquipmentSlots[equipIndex] = slot;
}
}
uint32_t selectedEnchantItem = sInvalidSlot;
esm.getHNOT(selectedEnchantItem, "SELE");
if (selectedEnchantItem == sInvalidSlot)
mSelectedEnchantItem.reset();
else
mSelectedEnchantItem = selectedEnchantItem;
// Old saves had restocking levelled items in a special map
// This turns items from that map into negative quantities
for (const auto& entry : levelledItemMap)
{
const ESM::RefId& id = entry.first.first;
const int count = entry.second;
for (auto& item : mItems)
{
if (item.mRef.mCount == count && id == item.mRef.mRefID)
item.mRef.mCount = -count;
}
}
}
void InventoryState::save(ESMWriter& esm) const
{
uint32_t itemsCount = static_cast<uint32_t>(mItems.size());
if (itemsCount > 0)
{
esm.writeHNT("ICNT", itemsCount);
for (const ObjectState& state : mItems)
{
state.save(esm, true);
}
}
for (const auto& [id, params] : mPermanentMagicEffectMagnitudes)
{
esm.writeHNRefId("MAGI", id);
for (const auto& [rand, mult] : params)
{
esm.writeHNT("RAND", rand);
esm.writeHNT("MULT", mult);
}
}
uint32_t slotsCount = static_cast<uint32_t>(mEquipmentSlots.size());
if (slotsCount > 0)
{
esm.startSubRecord("EQIP");
esm.writeT(slotsCount);
for (const auto& [index, slot] : mEquipmentSlots)
{
esm.writeT(index);
esm.writeT(slot);
}
esm.endRecord("EQIP");
}
if (mSelectedEnchantItem)
esm.writeHNT("SELE", *mSelectedEnchantItem);
}
}
| 4,746
|
C++
|
.cpp
| 140
| 22.542857
| 102
| 0.522926
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,548
|
variantimp.cpp
|
OpenMW_openmw/components/esm3/variantimp.cpp
|
#include "variantimp.hpp"
#include <cmath>
#include <sstream>
#include <stdexcept>
#include "esmreader.hpp"
#include "esmwriter.hpp"
namespace ESM
{
void readESMVariantValue(ESMReader& esm, Variant::Format format, VarType type, std::string& out)
{
if (type != VT_String)
throw std::logic_error("not a string type");
if (format == Variant::Format_Global)
esm.fail("global variables of type string not supported");
if (format == Variant::Format_Info)
esm.fail("info variables of type string not supported");
if (format == Variant::Format_Local)
esm.fail("local variables of type string not supported");
// GMST
out = esm.getHString();
}
void writeESMVariantValue(ESMWriter& esm, Variant::Format format, VarType type, const std::string& in)
{
if (type != VT_String)
throw std::logic_error("not a string type");
if (format == Variant::Format_Global)
throw std::runtime_error("global variables of type string not supported");
if (format == Variant::Format_Info)
throw std::runtime_error("info variables of type string not supported");
if (format == Variant::Format_Local)
throw std::runtime_error("local variables of type string not supported");
// GMST
esm.writeHNString("STRV", in);
}
void readESMVariantValue(ESMReader& esm, Variant::Format format, VarType type, int32_t& out)
{
if (type != VT_Short && type != VT_Long && type != VT_Int)
throw std::logic_error("not an integer type");
if (format == Variant::Format_Global)
{
float value;
esm.getHNT(value, "FLTV");
if (type == VT_Short)
if (std::isnan(value))
out = 0;
else
out = static_cast<int16_t>(value);
else if (type == VT_Long)
out = static_cast<int32_t>(value);
else
esm.fail("unsupported global variable integer type");
}
else if (format == Variant::Format_Gmst || format == Variant::Format_Info)
{
if (type != VT_Int)
{
std::ostringstream stream;
stream << "unsupported " << (format == Variant::Format_Gmst ? "gmst" : "info")
<< " variable integer type";
esm.fail(stream.str());
}
esm.getHT(out);
}
else if (format == Variant::Format_Local)
{
if (type == VT_Short)
{
int16_t value;
esm.getHT(value);
out = value;
}
else if (type == VT_Int)
{
esm.getHT(out);
}
else
esm.fail("unsupported local variable integer type");
}
}
void writeESMVariantValue(ESMWriter& esm, Variant::Format format, VarType type, int32_t in)
{
if (type != VT_Short && type != VT_Long && type != VT_Int)
throw std::logic_error("not an integer type");
if (format == Variant::Format_Global)
{
if (type == VT_Short || type == VT_Long)
{
float value = static_cast<float>(in);
esm.writeHNString("FNAM", type == VT_Short ? "s" : "l");
esm.writeHNT("FLTV", value);
}
else
throw std::runtime_error("unsupported global variable integer type");
}
else if (format == Variant::Format_Gmst || format == Variant::Format_Info)
{
if (type != VT_Int)
{
std::ostringstream stream;
stream << "unsupported " << (format == Variant::Format_Gmst ? "gmst" : "info")
<< " variable integer type";
throw std::runtime_error(stream.str());
}
esm.writeHNT("INTV", in);
}
else if (format == Variant::Format_Local)
{
if (type == VT_Short)
esm.writeHNT("STTV", static_cast<int16_t>(in));
else if (type == VT_Int)
esm.writeHNT("INTV", in);
else
throw std::runtime_error("unsupported local variable integer type");
}
}
void readESMVariantValue(ESMReader& esm, Variant::Format format, VarType type, float& out)
{
if (type != VT_Float)
throw std::logic_error("not a float type");
if (format == Variant::Format_Global)
{
esm.getHNT(out, "FLTV");
}
else if (format == Variant::Format_Gmst || format == Variant::Format_Info || format == Variant::Format_Local)
{
esm.getHT(out);
}
}
void writeESMVariantValue(ESMWriter& esm, Variant::Format format, VarType type, float in)
{
if (type != VT_Float)
throw std::logic_error("not a float type");
if (format == Variant::Format_Global)
{
esm.writeHNString("FNAM", "f");
esm.writeHNT("FLTV", in);
}
else if (format == Variant::Format_Gmst || format == Variant::Format_Info || format == Variant::Format_Local)
{
esm.writeHNT("FLTV", in);
}
}
}
| 5,404
|
C++
|
.cpp
| 143
| 26.783217
| 117
| 0.526929
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,549
|
transport.cpp
|
OpenMW_openmw/components/esm3/transport.cpp
|
#include "transport.hpp"
#include <components/debug/debuglog.hpp>
#include <components/esm3/esmreader.hpp>
#include <components/esm3/esmwriter.hpp>
namespace ESM
{
void Transport::add(ESMReader& esm)
{
if (esm.retSubName().toInt() == fourCC("DODT"))
{
Dest dodt;
esm.getSubComposite(dodt.mPos);
mList.push_back(dodt);
}
else if (esm.retSubName().toInt() == fourCC("DNAM"))
{
std::string name = esm.getHString();
if (mList.empty())
Log(Debug::Warning) << "Encountered DNAM record without DODT record, skipped.";
else
mList.back().mCellName = std::move(name);
}
}
void Transport::save(ESMWriter& esm) const
{
for (const Dest& dest : mList)
{
esm.writeNamedComposite("DODT", dest.mPos);
esm.writeHNOCString("DNAM", dest.mCellName);
}
}
}
| 965
|
C++
|
.cpp
| 32
| 21.96875
| 95
| 0.569579
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,550
|
loadsoun.cpp
|
OpenMW_openmw/components/esm3/loadsoun.cpp
|
#include "loadsoun.hpp"
#include "esmreader.hpp"
#include "esmwriter.hpp"
#include <components/misc/concepts.hpp>
namespace ESM
{
template <Misc::SameAsWithoutCvref<SOUNstruct> T>
void decompose(T&& v, const auto& f)
{
f(v.mVolume, v.mMinRange, v.mMaxRange);
}
void Sound::load(ESMReader& esm, bool& isDeleted)
{
isDeleted = false;
mRecordFlags = esm.getRecordFlags();
bool hasName = false;
bool hasData = false;
while (esm.hasMoreSubs())
{
esm.getSubName();
switch (esm.retSubName().toInt())
{
case SREC_NAME:
mId = esm.getRefId();
hasName = true;
break;
case fourCC("FNAM"):
mSound = esm.getHString();
break;
case fourCC("DATA"):
esm.getSubComposite(mData);
hasData = true;
break;
case SREC_DELE:
esm.skipHSub();
isDeleted = true;
break;
default:
esm.fail("Unknown subrecord");
break;
}
}
if (!hasName)
esm.fail("Missing NAME subrecord");
if (!hasData && !isDeleted)
esm.fail("Missing DATA subrecord");
}
void Sound::save(ESMWriter& esm, bool isDeleted) const
{
esm.writeHNCRefId("NAME", mId);
if (isDeleted)
{
esm.writeHNString("DELE", "", 3);
return;
}
esm.writeHNOCString("FNAM", mSound);
esm.writeNamedComposite("DATA", mData);
}
void Sound::blank()
{
mRecordFlags = 0;
mSound.clear();
mData.mVolume = 128;
mData.mMinRange = 0;
mData.mMaxRange = 255;
}
}
| 1,928
|
C++
|
.cpp
| 67
| 17.820896
| 58
| 0.487568
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,551
|
creaturestats.cpp
|
OpenMW_openmw/components/esm3/creaturestats.cpp
|
#include "creaturestats.hpp"
#include "esmreader.hpp"
#include "esmwriter.hpp"
#include <limits>
namespace ESM
{
void CreatureStats::load(ESMReader& esm)
{
const bool intFallback = esm.getFormatVersion() <= MaxIntFallbackFormatVersion;
for (auto& attribute : mAttributes)
attribute.load(esm, intFallback);
for (auto& dynamic : mDynamic)
dynamic.load(esm);
mGoldPool = 0;
esm.getHNOT(mGoldPool, "GOLD");
mTradeTime.mDay = 0;
mTradeTime.mHour = 0;
if (esm.peekNextSub("TIME"))
mTradeTime.load(esm);
int32_t flags = 0;
mDead = false;
mDeathAnimationFinished = false;
mDied = false;
mMurdered = false;
mTalkedTo = false;
mAlarmed = false;
mAttacked = false;
mKnockdown = false;
mKnockdownOneFrame = false;
mKnockdownOverOneFrame = false;
mHitRecovery = false;
mBlock = false;
mRecalcDynamicStats = false;
if (esm.getFormatVersion() <= MaxUnoptimizedCharacterDataFormatVersion)
{
esm.getHNOT(mDead, "DEAD");
esm.getHNOT(mDeathAnimationFinished, "DFNT");
esm.getHNOT(mDied, "DIED");
esm.getHNOT(mMurdered, "MURD");
esm.getHNOT(mTalkedTo, "TALK");
esm.getHNOT(mAlarmed, "ALRM");
esm.getHNOT(mAttacked, "ATKD");
esm.getHNOT(mKnockdown, "KNCK");
esm.getHNOT(mKnockdownOneFrame, "KNC1");
esm.getHNOT(mKnockdownOverOneFrame, "KNCO");
esm.getHNOT(mHitRecovery, "HITR");
esm.getHNOT(mBlock, "BLCK");
}
else
{
esm.getHNOT(flags, "AFLG");
mDead = flags & Dead;
mDeathAnimationFinished = flags & DeathAnimationFinished;
mDied = flags & Died;
mMurdered = flags & Murdered;
mTalkedTo = flags & TalkedTo;
mAlarmed = flags & Alarmed;
mAttacked = flags & Attacked;
mKnockdown = flags & Knockdown;
mKnockdownOneFrame = flags & KnockdownOneFrame;
mKnockdownOverOneFrame = flags & KnockdownOverOneFrame;
mHitRecovery = flags & HitRecovery;
mBlock = flags & Block;
mRecalcDynamicStats = flags & RecalcDynamicStats;
}
mMovementFlags = 0;
esm.getHNOT(mMovementFlags, "MOVE");
mFallHeight = 0;
esm.getHNOT(mFallHeight, "FALL");
mLastHitObject = esm.getHNORefId("LHIT");
mLastHitAttemptObject = esm.getHNORefId("LHAT");
if (esm.getFormatVersion() <= MaxUnoptimizedCharacterDataFormatVersion)
esm.getHNOT(mRecalcDynamicStats, "CALC");
mDrawState = 0;
esm.getHNOT(mDrawState, "DRAW");
mLevel = 1;
esm.getHNOT(mLevel, "LEVL");
mActorId = -1;
esm.getHNOT(mActorId, "ACID");
mDeathAnimation = -1;
esm.getHNOT(mDeathAnimation, "DANM");
mTimeOfDeath.mDay = 0;
mTimeOfDeath.mHour = 0;
if (esm.peekNextSub("DTIM"))
mTimeOfDeath.load(esm, "DTIM");
mSpells.load(esm);
mActiveSpells.load(esm);
mAiSequence.load(esm);
mMagicEffects.load(esm);
if (esm.getFormatVersion() <= MaxClearModifiersFormatVersion)
{
while (esm.isNextSub("SUMM"))
{
int32_t magicEffect;
esm.getHT(magicEffect);
ESM::RefId source = esm.getHNORefId("SOUR");
int32_t effectIndex = -1;
esm.getHNOT(effectIndex, "EIND");
int32_t actorId;
esm.getHNT(actorId, "ACID");
mSummonedCreatureMap[SummonKey(magicEffect, source, effectIndex)] = actorId;
mSummonedCreatures.emplace(magicEffect, actorId);
}
}
else
{
while (esm.isNextSub("SUMM"))
{
int32_t magicEffect;
esm.getHT(magicEffect);
int32_t actorId;
esm.getHNT(actorId, "ACID");
mSummonedCreatures.emplace(magicEffect, actorId);
}
}
while (esm.isNextSub("GRAV"))
{
int32_t actorId;
esm.getHT(actorId);
mSummonGraveyard.push_back(actorId);
}
mHasAiSettings = false;
esm.getHNOT(mHasAiSettings, "AISE");
if (mHasAiSettings)
{
for (auto& setting : mAiSettings)
setting.load(esm);
}
while (esm.isNextSub("CORP"))
{
ESM::RefId id = esm.getRefId();
CorprusStats stats;
esm.getHNT(stats.mWorsenings, "WORS");
stats.mNextWorsening.load(esm);
mCorprusSpells[id] = stats;
}
if (esm.getFormatVersion() <= MaxOldSkillsAndAttributesFormatVersion)
mMissingACDT = mGoldPool == std::numeric_limits<int>::min();
else
{
mMissingACDT = false;
esm.getHNOT(mMissingACDT, "NOAC");
}
}
void CreatureStats::save(ESMWriter& esm) const
{
for (const auto& attribute : mAttributes)
attribute.save(esm);
for (const auto& dynamic : mDynamic)
dynamic.save(esm);
if (mGoldPool)
esm.writeHNT("GOLD", mGoldPool);
if (mTradeTime.mDay != 0 || mTradeTime.mHour != 0)
esm.writeHNT("TIME", mTradeTime);
int32_t flags = 0;
if (mDead)
flags |= Dead;
if (mDeathAnimationFinished)
flags |= DeathAnimationFinished;
if (mDied)
flags |= Died;
if (mMurdered)
flags |= Murdered;
if (mTalkedTo)
flags |= TalkedTo;
if (mAlarmed)
flags |= Alarmed;
if (mAttacked)
flags |= Attacked;
if (mKnockdown)
flags |= Knockdown;
if (mKnockdownOneFrame)
flags |= KnockdownOneFrame;
if (mKnockdownOverOneFrame)
flags |= KnockdownOverOneFrame;
if (mHitRecovery)
flags |= HitRecovery;
if (mBlock)
flags |= Block;
if (mRecalcDynamicStats)
flags |= RecalcDynamicStats;
if (flags)
esm.writeHNT("AFLG", flags);
if (mMovementFlags)
esm.writeHNT("MOVE", mMovementFlags);
if (mFallHeight)
esm.writeHNT("FALL", mFallHeight);
if (!mLastHitObject.empty())
esm.writeHNRefId("LHIT", mLastHitObject);
if (!mLastHitAttemptObject.empty())
esm.writeHNRefId("LHAT", mLastHitAttemptObject);
if (mDrawState)
esm.writeHNT("DRAW", mDrawState);
if (mLevel != 1)
esm.writeHNT("LEVL", mLevel);
if (mActorId != -1)
esm.writeHNT("ACID", mActorId);
if (mDeathAnimation != -1)
esm.writeHNT("DANM", mDeathAnimation);
if (mTimeOfDeath.mHour != 0 || mTimeOfDeath.mDay != 0)
esm.writeHNT("DTIM", mTimeOfDeath);
mSpells.save(esm);
mActiveSpells.save(esm);
mAiSequence.save(esm);
mMagicEffects.save(esm);
for (const auto& [effectId, actorId] : mSummonedCreatures)
{
esm.writeHNT("SUMM", effectId);
esm.writeHNT("ACID", actorId);
}
for (int32_t key : mSummonGraveyard)
{
esm.writeHNT("GRAV", key);
}
esm.writeHNT("AISE", mHasAiSettings);
if (mHasAiSettings)
{
for (const auto& setting : mAiSettings)
setting.save(esm);
}
if (mMissingACDT)
esm.writeHNT("NOAC", mMissingACDT);
}
void CreatureStats::blank()
{
mTradeTime.mHour = 0;
mTradeTime.mDay = 0;
mGoldPool = 0;
mActorId = -1;
mHasAiSettings = false;
mDead = false;
mDeathAnimationFinished = false;
mDied = false;
mMurdered = false;
mTalkedTo = false;
mAlarmed = false;
mAttacked = false;
mKnockdown = false;
mKnockdownOneFrame = false;
mKnockdownOverOneFrame = false;
mHitRecovery = false;
mBlock = false;
mMovementFlags = 0;
mFallHeight = 0.f;
mRecalcDynamicStats = false;
mDrawState = 0;
mDeathAnimation = -1;
mLevel = 1;
mCorprusSpells.clear();
mMissingACDT = false;
}
}
| 8,624
|
C++
|
.cpp
| 252
| 23.611111
| 92
| 0.556089
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,552
|
loadscpt.cpp
|
OpenMW_openmw/components/esm3/loadscpt.cpp
|
#include "loadscpt.hpp"
#include <algorithm>
#include <numeric>
#include <optional>
#include <sstream>
#include <components/debug/debuglog.hpp>
#include <components/misc/concepts.hpp>
#include "esmreader.hpp"
#include "esmwriter.hpp"
namespace ESM
{
namespace
{
struct SCHD
{
/// Data from script-precompling in the editor.
/// \warning Do not use them. OpenCS currently does not precompile scripts.
std::uint32_t mNumShorts = 0;
std::uint32_t mNumLongs = 0;
std::uint32_t mNumFloats = 0;
std::uint32_t mScriptDataSize = 0;
std::uint32_t mStringTableSize = 0;
};
template <Misc::SameAsWithoutCvref<SCHD> T>
void decompose(T&& v, const auto& f)
{
f(v.mNumShorts, v.mNumLongs, v.mNumFloats, v.mScriptDataSize, v.mStringTableSize);
}
void loadVarNames(const SCHD& header, std::vector<std::string>& varNames, ESMReader& esm)
{
uint32_t s = header.mStringTableSize;
std::vector<char> tmp(s);
// not using getHExact, vanilla doesn't seem to mind unused bytes at the end
esm.getSubHeader();
uint32_t left = esm.getSubSize();
if (left < s)
esm.fail("SCVR string list is smaller than specified");
esm.getExact(tmp.data(), s);
if (left > s)
esm.skip(left - s); // skip the leftover junk
// Set up the list of variable names
varNames.resize(header.mNumShorts + header.mNumLongs + header.mNumFloats);
// The tmp buffer is a null-byte separated string list, we
// just have to pick out one string at a time.
if (tmp.empty())
{
if (!varNames.empty())
Log(Debug::Warning) << "SCVR with no variable names";
return;
}
// Support '\r' terminated strings like vanilla. See Bug #1324.
std::replace(tmp.begin(), tmp.end(), '\r', '\0');
// Avoid heap corruption
if (tmp.back() != '\0')
{
tmp.push_back('\0');
std::stringstream ss;
ss << "Malformed string table";
ss << "\n File: " << esm.getName();
ss << "\n Record: " << esm.getContext().recName.toStringView();
ss << "\n Subrecord: "
<< "SCVR";
ss << "\n Offset: 0x" << std::hex << esm.getFileOffset();
Log(Debug::Verbose) << ss.str();
}
const char* str = tmp.data();
const char* const tmpEnd = tmp.data() + tmp.size();
for (size_t i = 0; i < varNames.size(); i++)
{
varNames[i] = std::string(str);
str += varNames[i].size() + 1;
if (str >= tmpEnd)
{
if (str > tmpEnd)
{
// SCVR subrecord is unused and variable names are determined
// from the script source, so an overflow is not fatal.
std::stringstream ss;
ss << "String table overflow";
ss << "\n File: " << esm.getName();
ss << "\n Record: " << esm.getContext().recName.toStringView();
ss << "\n Subrecord: "
<< "SCVR";
ss << "\n Offset: 0x" << std::hex << esm.getFileOffset();
Log(Debug::Verbose) << ss.str();
}
// Get rid of empty strings in the list.
varNames.resize(i + 1);
break;
}
}
}
}
void Script::load(ESMReader& esm, bool& isDeleted)
{
isDeleted = false;
mRecordFlags = esm.getRecordFlags();
mVarNames.clear();
std::optional<SCHD> header;
while (esm.hasMoreSubs())
{
esm.getSubName();
switch (esm.retSubName().toInt())
{
case fourCC("SCHD"):
{
esm.getSubHeader();
mId = esm.getMaybeFixedRefIdSize(32);
esm.getComposite(header.emplace());
mNumShorts = header->mNumShorts;
mNumLongs = header->mNumLongs;
mNumFloats = header->mNumFloats;
break;
}
case fourCC("SCVR"):
if (!header.has_value())
esm.fail("SCVR is placed before SCHD record");
loadVarNames(*header, mVarNames, esm);
break;
case fourCC("SCDT"):
{
if (!header.has_value())
esm.fail("SCDT is placed before SCHD record");
// compiled script
esm.getSubHeader();
uint32_t subSize = esm.getSubSize();
if (subSize != header->mScriptDataSize)
{
std::stringstream ss;
ss << "Script data size defined in SCHD subrecord does not match size of SCDT subrecord";
ss << "\n File: " << esm.getName();
ss << "\n Offset: 0x" << std::hex << esm.getFileOffset();
Log(Debug::Verbose) << ss.str();
}
mScriptData.resize(subSize);
esm.getExact(mScriptData.data(), mScriptData.size());
break;
}
case fourCC("SCTX"):
mScriptText = esm.getHString();
break;
case SREC_DELE:
esm.skipHSub();
isDeleted = true;
break;
default:
esm.fail("Unknown subrecord");
break;
}
}
if (!header.has_value())
esm.fail("Missing SCHD subrecord");
}
void Script::save(ESMWriter& esm, bool isDeleted) const
{
esm.startSubRecord("SCHD");
esm.writeMaybeFixedSizeRefId(mId, 32);
esm.writeComposite(SCHD{
.mNumShorts = mNumShorts,
.mNumLongs = mNumLongs,
.mNumFloats = mNumFloats,
.mScriptDataSize = static_cast<std::uint32_t>(mScriptData.size()),
.mStringTableSize = computeScriptStringTableSize(mVarNames),
});
esm.endRecord("SCHD");
if (isDeleted)
{
esm.writeHNString("DELE", "", 3);
return;
}
if (!mVarNames.empty())
{
esm.startSubRecord("SCVR");
for (const std::string& v : mVarNames)
esm.writeHCString(v);
esm.endRecord("SCVR");
}
esm.startSubRecord("SCDT");
esm.write(reinterpret_cast<const char*>(mScriptData.data()), mScriptData.size());
esm.endRecord("SCDT");
esm.writeHNOString("SCTX", mScriptText);
}
void Script::blank()
{
mRecordFlags = 0;
mNumShorts = 0;
mNumLongs = 0;
mNumFloats = 0;
mVarNames.clear();
mScriptData.clear();
const std::string& stringId = mId.getRefIdString();
if (stringId.find("::") != std::string::npos)
mScriptText = "Begin \"" + stringId + "\"\n\nEnd " + stringId + "\n";
else
mScriptText = "Begin " + stringId + "\n\nEnd " + stringId + "\n";
}
std::uint32_t computeScriptStringTableSize(const std::vector<std::string>& varNames)
{
return std::accumulate(varNames.begin(), varNames.end(), static_cast<std::uint32_t>(0),
[](std::uint32_t r, const std::string& v) { return r + 1 + static_cast<std::uint32_t>(v.size()); });
}
}
| 8,087
|
C++
|
.cpp
| 202
| 26.09901
| 113
| 0.482566
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,553
|
globalscript.cpp
|
OpenMW_openmw/components/esm3/globalscript.cpp
|
#include "globalscript.hpp"
#include "esmreader.hpp"
#include "esmwriter.hpp"
#include <cstdint>
namespace ESM
{
void GlobalScript::load(ESMReader& esm)
{
mId = esm.getHNRefId("NAME");
mLocals.load(esm);
int32_t running = 0;
esm.getHNOT(running, "RUN_");
mRunning = running != 0;
mTargetRef = RefNum{};
mTargetId = esm.getHNORefId("TARG");
if (esm.peekNextSub("FRMR"))
mTargetRef = esm.getFormId(true, "FRMR");
if (!esm.applyContentFileMapping(mTargetRef))
{
mTargetId = ESM::RefId();
mTargetRef = ESM::FormId();
}
}
void GlobalScript::save(ESMWriter& esm) const
{
esm.writeHNRefId("NAME", mId);
mLocals.save(esm);
if (mRunning)
esm.writeHNT("RUN_", int32_t{ 1 });
if (!mTargetId.empty())
{
esm.writeHNORefId("TARG", mTargetId);
if (mTargetRef.isSet())
esm.writeFormId(mTargetRef, true, "FRMR");
}
}
}
| 1,062
|
C++
|
.cpp
| 37
| 20.675676
| 58
| 0.559724
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,554
|
doorstate.cpp
|
OpenMW_openmw/components/esm3/doorstate.cpp
|
#include "doorstate.hpp"
#include "esmreader.hpp"
#include "esmwriter.hpp"
#include <components/debug/debuglog.hpp>
namespace ESM
{
void DoorState::load(ESMReader& esm)
{
ObjectState::load(esm);
mDoorState = 0;
esm.getHNOT(mDoorState, "ANIM");
if (mDoorState < 0 || mDoorState > 2)
Log(Debug::Warning) << "Dropping invalid door state (" << mDoorState << ") for door " << mRef.mRefID;
}
void DoorState::save(ESMWriter& esm, bool inInventory) const
{
ObjectState::save(esm, inInventory);
if (mDoorState < 0 || mDoorState > 2)
{
Log(Debug::Warning) << "Dropping invalid door state (" << mDoorState << ") for door " << mRef.mRefID;
return;
}
if (mDoorState != 0)
esm.writeHNT("ANIM", mDoorState);
}
}
| 850
|
C++
|
.cpp
| 26
| 25.807692
| 113
| 0.596319
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,555
|
loadcell.cpp
|
OpenMW_openmw/components/esm3/loadcell.cpp
|
#include "loadcell.hpp"
#include <limits>
#include <list>
#include <string>
#include <components/debug/debuglog.hpp>
#include <components/misc/concepts.hpp>
#include <components/misc/strings/algorithm.hpp>
#include "esmreader.hpp"
#include "esmwriter.hpp"
namespace ESM
{
namespace
{
///< Translate 8bit/24bit code (stored in refNum.mIndex) into a proper refNum
void adjustRefNum(RefNum& refNum, const ESMReader& reader)
{
uint32_t local = (refNum.mIndex & 0xff000000) >> 24;
// If we have an index value that does not make sense, assume that it was an addition
// by the present plugin (but a faulty one)
if (local && local <= reader.getParentFileIndices().size())
{
// If the most significant 8 bits are used, then this reference already exists.
// In this case, do not spawn a new reference, but overwrite the old one.
refNum.mIndex &= 0x00ffffff; // delete old plugin ID
refNum.mContentFile = reader.getParentFileIndices()[local - 1];
}
else
{
// This is an addition by the present plugin. Set the corresponding plugin index.
refNum.mContentFile = reader.getIndex();
}
}
}
}
namespace ESM
{
const StringRefId Cell::sDefaultWorldspaceId = StringRefId("sys::default");
template <Misc::SameAsWithoutCvref<Cell::DATAstruct> T>
void decompose(T&& v, const auto& f)
{
f(v.mFlags, v.mX, v.mY);
}
template <Misc::SameAsWithoutCvref<Cell::AMBIstruct> T>
void decompose(T&& v, const auto& f)
{
f(v.mAmbient, v.mSunlight, v.mFog, v.mFogDensity);
}
// Some overloaded compare operators.
bool operator==(const MovedCellRef& ref, const RefNum& refNum)
{
return ref.mRefNum == refNum;
}
bool operator==(const CellRef& ref, const RefNum& refNum)
{
return ref.mRefNum == refNum;
}
void Cell::load(ESMReader& esm, bool& isDeleted, bool saveContext)
{
loadNameAndData(esm, isDeleted);
loadCell(esm, saveContext);
}
const ESM::RefId& Cell::updateId()
{
mId = generateIdForCell(isExterior(), mName, getGridX(), getGridY());
return mId;
}
ESM::RefId Cell::generateIdForCell(bool exterior, std::string_view cellName, int x, int y)
{
if (!exterior)
{
return ESM::RefId::stringRefId(cellName);
}
else
{
return ESM::RefId::esm3ExteriorCell(x, y);
}
}
void Cell::loadNameAndData(ESMReader& esm, bool& isDeleted)
{
isDeleted = false;
blank();
bool hasData = false;
bool isLoaded = false;
while (!isLoaded && esm.hasMoreSubs())
{
esm.getSubName();
switch (esm.retSubName().toInt())
{
case SREC_NAME:
mName = esm.getHString();
break;
case fourCC("DATA"):
esm.getSubComposite(mData);
hasData = true;
break;
case SREC_DELE:
esm.skipHSub();
isDeleted = true;
break;
default:
esm.cacheSubName();
isLoaded = true;
break;
}
}
if (!hasData)
esm.fail("Missing DATA subrecord");
updateId();
}
void Cell::loadCell(ESMReader& esm, bool saveContext)
{
bool overriding = !mName.empty();
bool isLoaded = false;
mHasAmbi = false;
mHasWaterHeightSub = false;
while (!isLoaded && esm.hasMoreSubs())
{
esm.getSubName();
switch (esm.retSubName().toInt())
{
case fourCC("INTV"):
int32_t waterl;
esm.getHT(waterl);
mHasWaterHeightSub = true;
mWater = static_cast<float>(waterl);
break;
case fourCC("WHGT"):
float waterLevel;
esm.getHT(waterLevel);
mHasWaterHeightSub = true;
if (!std::isfinite(waterLevel))
{
if (!overriding)
mWater = std::numeric_limits<float>::max();
Log(Debug::Warning) << "Warning: Encountered invalid water level in cell " << mName
<< " defined in " << esm.getContext().filename;
}
else
mWater = waterLevel;
break;
case fourCC("AMBI"):
esm.getSubComposite(mAmbi);
mHasAmbi = true;
break;
case fourCC("RGNN"):
mRegion = esm.getRefId();
break;
case fourCC("NAM5"):
esm.getHT(mMapColor);
break;
case fourCC("NAM0"):
esm.getHT(mRefNumCounter);
break;
default:
esm.cacheSubName();
isLoaded = true;
break;
}
}
if (saveContext)
{
mContextList.push_back(esm.getContext());
esm.skipRecord();
}
}
void Cell::postLoad(ESMReader& esm)
{
// Save position of the cell references and move on
mContextList.push_back(esm.getContext());
esm.skipRecord();
}
void Cell::save(ESMWriter& esm, bool isDeleted) const
{
esm.writeHNCString("NAME", mName);
esm.writeNamedComposite("DATA", mData);
if (isDeleted)
{
esm.writeHNString("DELE", "", 3);
return;
}
if (mData.mFlags & Interior)
{
// Try to avoid saving ambient information when it's unnecessary.
// This is to fix black lighting and flooded water
// in resaved cell records that lack this information.
if (mHasWaterHeightSub)
esm.writeHNT("WHGT", mWater);
if (mData.mFlags & QuasiEx)
esm.writeHNOCRefId("RGNN", mRegion);
else if (mHasAmbi)
esm.writeNamedComposite("AMBI", mAmbi);
}
else
{
esm.writeHNOCRefId("RGNN", mRegion);
if (mMapColor != 0)
esm.writeHNT("NAM5", mMapColor);
}
}
void Cell::saveTempMarker(ESMWriter& esm, int32_t tempCount) const
{
if (tempCount != 0)
esm.writeHNT("NAM0", tempCount);
}
void Cell::restore(ESMReader& esm, size_t iCtx) const
{
esm.restoreContext(mContextList.at(iCtx));
}
std::string Cell::getDescription() const
{
const auto& nameString = mName;
if (mData.mFlags & Interior)
return nameString;
std::string cellGrid = "(" + std::to_string(mData.mX) + ", " + std::to_string(mData.mY) + ")";
if (!mName.empty())
return nameString + ' ' + cellGrid;
// FIXME: should use sDefaultCellname GMST instead, but it's not available in this scope
std::string region = !mRegion.empty() ? mRegion.getRefIdString() : "Wilderness";
return region + ' ' + cellGrid;
}
bool Cell::getNextRef(ESMReader& esm, CellRef& ref, bool& isDeleted)
{
isDeleted = false;
// TODO: Try and document reference numbering, I don't think this has been done anywhere else.
if (!esm.hasMoreSubs())
return false;
// MVRF are FRMR are present in pairs. MVRF indicates that following FRMR describes moved CellRef.
// This function has to skip all moved CellRefs therefore read all such pairs to ignored values.
while (esm.isNextSub("MVRF"))
{
MovedCellRef movedCellRef;
esm.getHT(movedCellRef.mRefNum.mIndex);
esm.getHNOT(movedCellRef.mTarget, "CNDT");
CellRef skippedCellRef;
if (!esm.peekNextSub("FRMR"))
return false;
bool skippedDeleted;
skippedCellRef.load(esm, skippedDeleted);
}
if (esm.peekNextSub("FRMR"))
{
ref.load(esm, isDeleted);
// TODO: should count the number of temp refs and validate the number
// Identify references belonging to a parent file and adapt the ID accordingly.
adjustRefNum(ref.mRefNum, esm);
return true;
}
return false;
}
bool Cell::getNextRef(
ESMReader& esm, CellRef& cellRef, bool& deleted, MovedCellRef& movedCellRef, bool& moved, GetNextRefMode mode)
{
deleted = false;
moved = false;
if (!esm.hasMoreSubs())
return false;
if (esm.isNextSub("MVRF"))
{
moved = true;
getNextMVRF(esm, movedCellRef);
}
if (!esm.peekNextSub("FRMR"))
return false;
if ((!moved && mode == GetNextRefMode::LoadOnlyMoved) || (moved && mode == GetNextRefMode::LoadOnlyNotMoved))
{
skipLoadCellRef(esm);
return true;
}
cellRef.load(esm, deleted);
adjustRefNum(cellRef.mRefNum, esm);
return true;
}
bool Cell::getNextMVRF(ESMReader& esm, MovedCellRef& mref)
{
esm.getHT(mref.mRefNum.mIndex);
esm.getHNOT(mref.mTarget, "CNDT");
adjustRefNum(mref.mRefNum, esm);
return true;
}
void Cell::blank()
{
mName.clear();
mRegion = ESM::RefId();
mWater = 0;
mMapColor = 0;
mRefNumCounter = 0;
mData.mFlags = 0;
mData.mX = 0;
mData.mY = 0;
mHasAmbi = true;
mHasWaterHeightSub = true;
mAmbi.mAmbient = 0;
mAmbi.mSunlight = 0;
mAmbi.mFog = 0;
mAmbi.mFogDensity = 0;
}
}
| 10,258
|
C++
|
.cpp
| 297
| 23.474747
| 118
| 0.535916
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,556
|
effectlist.cpp
|
OpenMW_openmw/components/esm3/effectlist.cpp
|
#include "effectlist.hpp"
#include "esmreader.hpp"
#include "esmwriter.hpp"
#include <components/misc/concepts.hpp>
namespace ESM
{
template <Misc::SameAsWithoutCvref<ENAMstruct> T>
void decompose(T&& v, const auto& f)
{
f(v.mEffectID, v.mSkill, v.mAttribute, v.mRange, v.mArea, v.mDuration, v.mMagnMin, v.mMagnMax);
}
void EffectList::load(ESMReader& esm)
{
mList.clear();
while (esm.isNextSub("ENAM"))
{
add(esm);
}
}
void EffectList::populate(const std::vector<ENAMstruct>& effects)
{
mList.clear();
for (size_t i = 0; i < effects.size(); i++)
mList.push_back({ effects[i], static_cast<uint32_t>(i) });
}
void EffectList::updateIndexes()
{
for (size_t i = 0; i < mList.size(); i++)
mList[i].mIndex = i;
}
void EffectList::add(ESMReader& esm)
{
ENAMstruct s;
esm.getSubComposite(s);
mList.push_back({ s, static_cast<uint32_t>(mList.size()) });
}
void EffectList::save(ESMWriter& esm) const
{
for (const IndexedENAMstruct& enam : mList)
{
esm.writeNamedComposite("ENAM", enam.mData);
}
}
bool IndexedENAMstruct::operator!=(const IndexedENAMstruct& rhs) const
{
return mData.mEffectID != rhs.mData.mEffectID || mData.mArea != rhs.mData.mArea
|| mData.mRange != rhs.mData.mRange || mData.mSkill != rhs.mData.mSkill
|| mData.mAttribute != rhs.mData.mAttribute || mData.mMagnMin != rhs.mData.mMagnMin
|| mData.mMagnMax != rhs.mData.mMagnMax || mData.mDuration != rhs.mData.mDuration;
}
} // end namespace
| 1,704
|
C++
|
.cpp
| 51
| 26.490196
| 103
| 0.606817
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,557
|
loadsndg.cpp
|
OpenMW_openmw/components/esm3/loadsndg.cpp
|
#include "loadsndg.hpp"
#include "components/esm/defs.hpp"
#include "esmreader.hpp"
#include "esmwriter.hpp"
namespace ESM
{
void SoundGenerator::load(ESMReader& esm, bool& isDeleted)
{
isDeleted = false;
mRecordFlags = esm.getRecordFlags();
bool hasName = false;
bool hasData = false;
while (esm.hasMoreSubs())
{
esm.getSubName();
switch (esm.retSubName().toInt())
{
case SREC_NAME:
mId = esm.getRefId();
hasName = true;
break;
case fourCC("DATA"):
esm.getHT(mType);
hasData = true;
break;
case fourCC("CNAM"):
mCreature = esm.getRefId();
break;
case fourCC("SNAM"):
mSound = esm.getRefId();
break;
case SREC_DELE:
esm.skipHSub();
isDeleted = true;
break;
default:
esm.fail("Unknown subrecord");
break;
}
}
if (!hasName)
esm.fail("Missing NAME subrecord");
if (!hasData && !isDeleted)
esm.fail("Missing DATA subrecord");
}
void SoundGenerator::save(ESMWriter& esm, bool isDeleted) const
{
esm.writeHNCRefId("NAME", mId);
if (isDeleted)
{
esm.writeHNString("DELE", "", 3);
return;
}
esm.writeHNT("DATA", mType);
esm.writeHNOCRefId("CNAM", mCreature);
esm.writeHNOCRefId("SNAM", mSound);
}
void SoundGenerator::blank()
{
mRecordFlags = 0;
mType = LeftFoot;
mCreature = ESM::RefId();
mSound = ESM::RefId();
}
}
| 1,904
|
C++
|
.cpp
| 65
| 17.6
| 67
| 0.469432
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,558
|
loadsscr.cpp
|
OpenMW_openmw/components/esm3/loadsscr.cpp
|
#include "loadsscr.hpp"
#include "esmreader.hpp"
#include "esmwriter.hpp"
namespace ESM
{
void StartScript::load(ESMReader& esm, bool& isDeleted)
{
isDeleted = false;
mRecordFlags = esm.getRecordFlags();
bool hasData = false;
bool hasName = false;
while (esm.hasMoreSubs())
{
esm.getSubName();
switch (esm.retSubName().toInt())
{
case SREC_NAME:
mId = esm.getRefId();
hasName = true;
break;
case fourCC("DATA"):
mData = esm.getHString();
hasData = true;
break;
case SREC_DELE:
esm.skipHSub();
isDeleted = true;
break;
default:
esm.fail("Unknown subrecord");
break;
}
}
if (!hasName)
esm.fail("Missing NAME");
if (!hasData && !isDeleted)
esm.fail("Missing DATA");
}
void StartScript::save(ESMWriter& esm, bool isDeleted) const
{
esm.writeHNCRefId("NAME", mId);
if (isDeleted)
{
esm.writeHNString("DELE", "", 3);
}
else
{
esm.writeHNString("DATA", mData);
}
}
void StartScript::blank()
{
mRecordFlags = 0;
mData.clear();
}
}
| 1,488
|
C++
|
.cpp
| 56
| 15.482143
| 64
| 0.4541
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,559
|
activespells.cpp
|
OpenMW_openmw/components/esm3/activespells.cpp
|
#include "activespells.hpp"
#include "esmreader.hpp"
#include "esmwriter.hpp"
#include "loadmgef.hpp"
#include "loadskil.hpp"
#include <components/esm/attr.hpp>
#include <cstdint>
namespace ESM
{
namespace
{
bool isSummon(int effectId)
{
switch (effectId)
{
case MagicEffect::SummonScamp:
case MagicEffect::SummonClannfear:
case MagicEffect::SummonDaedroth:
case MagicEffect::SummonDremora:
case MagicEffect::SummonAncestralGhost:
case MagicEffect::SummonSkeletalMinion:
case MagicEffect::SummonBonewalker:
case MagicEffect::SummonGreaterBonewalker:
case MagicEffect::SummonBonelord:
case MagicEffect::SummonWingedTwilight:
case MagicEffect::SummonHunger:
case MagicEffect::SummonGoldenSaint:
case MagicEffect::SummonFlameAtronach:
case MagicEffect::SummonFrostAtronach:
case MagicEffect::SummonStormAtronach:
case MagicEffect::SummonCenturionSphere:
case MagicEffect::SummonFabricant:
case MagicEffect::SummonWolf:
case MagicEffect::SummonBear:
case MagicEffect::SummonBonewolf:
case MagicEffect::SummonCreature04:
case MagicEffect::SummonCreature05:
return true;
}
return false;
}
bool affectsAttribute(int effectId)
{
switch (effectId)
{
case MagicEffect::DrainAttribute:
case MagicEffect::DamageAttribute:
case MagicEffect::RestoreAttribute:
case MagicEffect::FortifyAttribute:
case MagicEffect::AbsorbAttribute:
return true;
}
return false;
}
bool affectsSkill(int effectId)
{
switch (effectId)
{
case MagicEffect::DrainSkill:
case MagicEffect::DamageSkill:
case MagicEffect::RestoreSkill:
case MagicEffect::FortifySkill:
case MagicEffect::AbsorbSkill:
return true;
}
return false;
}
struct ToInt
{
int effectId;
int operator()(const ESM::RefId& id) const
{
if (!id.empty())
{
if (affectsAttribute(effectId))
return ESM::Attribute::refIdToIndex(id);
else if (affectsSkill(effectId))
return ESM::Skill::refIdToIndex(id);
}
return -1;
}
int operator()(int actor) const { return actor; }
};
void saveImpl(ESMWriter& esm, const std::vector<ActiveSpells::ActiveSpellParams>& spells, NAME tag)
{
for (const auto& params : spells)
{
esm.writeHNRefId(tag, params.mSourceSpellId);
esm.writeHNRefId("SPID", params.mActiveSpellId);
esm.writeHNT("CAST", params.mCasterActorId);
esm.writeHNString("DISP", params.mDisplayName);
esm.writeHNT("FLAG", params.mFlags);
if (params.mItem.isSet())
esm.writeFormId(params.mItem, true, "ITEM");
if (params.mWorsenings >= 0)
{
esm.writeHNT("WORS", params.mWorsenings);
esm.writeHNT("TIME", params.mNextWorsening);
}
for (auto& effect : params.mEffects)
{
esm.writeHNT("MGEF", effect.mEffectId);
int arg = std::visit(ToInt{ effect.mEffectId }, effect.mArg);
if (arg != -1)
esm.writeHNT("ARG_", arg);
esm.writeHNT("MAGN", effect.mMagnitude);
esm.writeHNT("MAGN", effect.mMinMagnitude);
esm.writeHNT("MAGN", effect.mMaxMagnitude);
esm.writeHNT("DURA", effect.mDuration);
esm.writeHNT("EIND", effect.mEffectIndex);
esm.writeHNT("LEFT", effect.mTimeLeft);
esm.writeHNT("FLAG", effect.mFlags);
}
}
}
void loadImpl(ESMReader& esm, std::vector<ActiveSpells::ActiveSpellParams>& spells, NAME tag)
{
const FormatVersion format = esm.getFormatVersion();
while (esm.isNextSub(tag))
{
ActiveSpells::ActiveSpellParams params;
params.mSourceSpellId = esm.getRefId();
if (format > MaxActiveSpellTypeVersion)
params.mActiveSpellId = esm.getHNRefId("SPID");
esm.getHNT(params.mCasterActorId, "CAST");
params.mDisplayName = esm.getHNString("DISP");
if (format <= MaxClearModifiersFormatVersion)
params.mFlags = Compatibility::ActiveSpells::Type_Temporary_Flags;
else
{
if (format <= MaxActiveSpellTypeVersion)
{
Compatibility::ActiveSpells::EffectType type;
esm.getHNT(type, "TYPE");
switch (type)
{
case Compatibility::ActiveSpells::Type_Ability:
params.mFlags = Compatibility::ActiveSpells::Type_Ability_Flags;
break;
case Compatibility::ActiveSpells::Type_Consumable:
params.mFlags = Compatibility::ActiveSpells::Type_Consumable_Flags;
break;
case Compatibility::ActiveSpells::Type_Enchantment:
params.mFlags = Compatibility::ActiveSpells::Type_Enchantment_Flags;
break;
case Compatibility::ActiveSpells::Type_Permanent:
params.mFlags = Compatibility::ActiveSpells::Type_Permanent_Flags;
break;
case Compatibility::ActiveSpells::Type_Temporary:
params.mFlags = Compatibility::ActiveSpells::Type_Temporary_Flags;
break;
}
}
else
{
esm.getHNT(params.mFlags, "FLAG");
}
if (esm.peekNextSub("ITEM"))
params.mItem = esm.getFormId(true, "ITEM");
}
if (esm.isNextSub("WORS"))
{
esm.getHT(params.mWorsenings);
params.mNextWorsening.load(esm);
}
else
params.mWorsenings = -1;
// spell casting timestamp, no longer used
if (esm.isNextSub("TIME"))
esm.skipHSub();
while (esm.isNextSub("MGEF"))
{
ActiveEffect effect;
esm.getHT(effect.mEffectId);
int32_t arg = -1;
esm.getHNOT(arg, "ARG_");
if (arg >= 0)
{
if (isSummon(effect.mEffectId))
effect.mArg = arg;
else if (affectsAttribute(effect.mEffectId))
effect.mArg = ESM::Attribute::indexToRefId(arg);
else if (affectsSkill(effect.mEffectId))
effect.mArg = ESM::Skill::indexToRefId(arg);
}
esm.getHNT(effect.mMagnitude, "MAGN");
if (format <= MaxClearModifiersFormatVersion)
{
effect.mMinMagnitude = effect.mMagnitude;
effect.mMaxMagnitude = effect.mMagnitude;
}
else
{
esm.getHNT(effect.mMinMagnitude, "MAGN");
esm.getHNT(effect.mMaxMagnitude, "MAGN");
}
esm.getHNT(effect.mDuration, "DURA");
effect.mEffectIndex = -1;
esm.getHNOT(effect.mEffectIndex, "EIND");
if (format <= MaxOldTimeLeftFormatVersion)
effect.mTimeLeft = effect.mDuration;
else
esm.getHNT(effect.mTimeLeft, "LEFT");
if (format <= MaxClearModifiersFormatVersion)
effect.mFlags = ActiveEffect::Flag_None;
else
esm.getHNT(effect.mFlags, "FLAG");
params.mEffects.push_back(effect);
}
spells.emplace_back(params);
}
}
}
void ActiveSpells::save(ESMWriter& esm) const
{
saveImpl(esm, mSpells, "ID__");
saveImpl(esm, mQueue, "QID_");
}
void ActiveSpells::load(ESMReader& esm)
{
loadImpl(esm, mSpells, "ID__");
loadImpl(esm, mQueue, "QID_");
}
RefId ActiveEffect::getSkillOrAttribute() const
{
if (const auto* id = std::get_if<ESM::RefId>(&mArg))
return *id;
return {};
}
int ActiveEffect::getActorId() const
{
if (const auto* id = std::get_if<int>(&mArg))
return *id;
return -1;
}
}
| 9,876
|
C++
|
.cpp
| 236
| 24.834746
| 107
| 0.48706
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,560
|
quickkeys.cpp
|
OpenMW_openmw/components/esm3/quickkeys.cpp
|
#include "quickkeys.hpp"
#include "esmreader.hpp"
#include "esmwriter.hpp"
namespace ESM
{
void QuickKeys::load(ESMReader& esm)
{
while (esm.isNextSub("TYPE"))
{
QuickKey key;
esm.getHT(key.mType);
key.mId = esm.getHNRefId("ID__");
mKeys.push_back(key);
}
}
void QuickKeys::save(ESMWriter& esm) const
{
for (const QuickKey& key : mKeys)
{
esm.writeHNT("TYPE", key.mType);
esm.writeHNRefId("ID__", key.mId);
}
}
}
| 563
|
C++
|
.cpp
| 24
| 16.208333
| 46
| 0.538462
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,561
|
mappings.cpp
|
OpenMW_openmw/components/esm3/mappings.cpp
|
#include "mappings.hpp"
#include <stdexcept>
namespace ESM
{
BodyPart::MeshPart getMeshPart(PartReferenceType type)
{
switch (type)
{
case PRT_Head:
return BodyPart::MP_Head;
case PRT_Hair:
return BodyPart::MP_Hair;
case PRT_Neck:
return BodyPart::MP_Neck;
case PRT_Cuirass:
return BodyPart::MP_Chest;
case PRT_Groin:
return BodyPart::MP_Groin;
case PRT_RHand:
return BodyPart::MP_Hand;
case PRT_LHand:
return BodyPart::MP_Hand;
case PRT_RWrist:
return BodyPart::MP_Wrist;
case PRT_LWrist:
return BodyPart::MP_Wrist;
case PRT_RForearm:
return BodyPart::MP_Forearm;
case PRT_LForearm:
return BodyPart::MP_Forearm;
case PRT_RUpperarm:
return BodyPart::MP_Upperarm;
case PRT_LUpperarm:
return BodyPart::MP_Upperarm;
case PRT_RFoot:
return BodyPart::MP_Foot;
case PRT_LFoot:
return BodyPart::MP_Foot;
case PRT_RAnkle:
return BodyPart::MP_Ankle;
case PRT_LAnkle:
return BodyPart::MP_Ankle;
case PRT_RKnee:
return BodyPart::MP_Knee;
case PRT_LKnee:
return BodyPart::MP_Knee;
case PRT_RLeg:
return BodyPart::MP_Upperleg;
case PRT_LLeg:
return BodyPart::MP_Upperleg;
case PRT_Tail:
return BodyPart::MP_Tail;
default:
throw std::runtime_error(
"PartReferenceType " + std::to_string(type) + " not associated with a mesh part");
}
}
std::string getBoneName(PartReferenceType type)
{
switch (type)
{
case PRT_Head:
return "head";
case PRT_Hair:
return "head"; // This is purposeful.
case PRT_Neck:
return "neck";
case PRT_Cuirass:
return "chest";
case PRT_Groin:
return "groin";
case PRT_Skirt:
return "groin";
case PRT_RHand:
return "right hand";
case PRT_LHand:
return "left hand";
case PRT_RWrist:
return "right wrist";
case PRT_LWrist:
return "left wrist";
case PRT_Shield:
return "shield bone";
case PRT_RForearm:
return "right forearm";
case PRT_LForearm:
return "left forearm";
case PRT_RUpperarm:
return "right upper arm";
case PRT_LUpperarm:
return "left upper arm";
case PRT_RFoot:
return "right foot";
case PRT_LFoot:
return "left foot";
case PRT_RAnkle:
return "right ankle";
case PRT_LAnkle:
return "left ankle";
case PRT_RKnee:
return "right knee";
case PRT_LKnee:
return "left knee";
case PRT_RLeg:
return "right upper leg";
case PRT_LLeg:
return "left upper leg";
case PRT_RPauldron:
return "right clavicle";
case PRT_LPauldron:
return "left clavicle";
case PRT_Weapon:
return "weapon bone";
case PRT_Tail:
return "tail";
default:
throw std::runtime_error("unknown PartReferenceType");
}
}
std::string getMeshFilter(PartReferenceType type)
{
switch (type)
{
case PRT_Hair:
return "hair";
default:
return getBoneName(type);
}
}
}
| 4,149
|
C++
|
.cpp
| 130
| 18.484615
| 102
| 0.473973
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,562
|
timestamp.cpp
|
OpenMW_openmw/components/esm3/timestamp.cpp
|
#include "timestamp.hpp"
#include "esmreader.hpp"
namespace ESM
{
void TimeStamp::load(ESMReader& esm, NAME name)
{
esm.getHNT(name, mHour, mDay);
}
}
| 173
|
C++
|
.cpp
| 9
| 15.777778
| 51
| 0.67284
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,563
|
loadland.cpp
|
OpenMW_openmw/components/esm3/loadland.cpp
|
#include "loadland.hpp"
#include <algorithm>
#include <cstdint>
#include <limits>
#include <utility>
#include <components/esm/defs.hpp>
#include <components/misc/concepts.hpp>
#include "esmreader.hpp"
#include "esmwriter.hpp"
namespace ESM
{
namespace
{
struct VHGT
{
float mHeightOffset;
std::int8_t mHeightData[LandRecordData::sLandNumVerts];
};
template <Misc::SameAsWithoutCvref<VHGT> T>
void decompose(T&& v, const auto& f)
{
char padding[3] = { 0, 0, 0 };
f(v.mHeightOffset, v.mHeightData, padding);
}
void transposeTextureData(const std::uint16_t* in, std::uint16_t* out)
{
size_t readPos = 0; // bit ugly, but it works
for (size_t y1 = 0; y1 < 4; y1++)
for (size_t x1 = 0; x1 < 4; x1++)
for (size_t y2 = 0; y2 < 4; y2++)
for (size_t x2 = 0; x2 < 4; x2++)
out[(y1 * 4 + y2) * 16 + (x1 * 4 + x2)] = in[readPos++];
}
// Loads data and marks it as loaded. Return true if data is actually loaded from reader, false otherwise
// including the case when data is already loaded.
bool condLoad(ESMReader& reader, int dataTypes, int& targetDataTypes, int dataFlag, auto& in)
{
if ((targetDataTypes & dataFlag) == 0 && (dataTypes & dataFlag) != 0)
{
if constexpr (std::is_same_v<std::remove_cvref_t<decltype(in)>, VHGT>)
reader.getSubComposite(in);
else
reader.getHT(in);
targetDataTypes |= dataFlag;
return true;
}
reader.skipHSub();
return false;
}
}
void Land::load(ESMReader& esm, bool& isDeleted)
{
isDeleted = false;
bool hasLocation = false;
bool isLoaded = false;
while (!isLoaded && esm.hasMoreSubs())
{
esm.getSubName();
switch (esm.retSubName().toInt())
{
case fourCC("INTV"):
esm.getHT(mX, mY);
hasLocation = true;
break;
case fourCC("DATA"):
esm.getHT(mFlags);
break;
case SREC_DELE:
esm.skipHSub();
isDeleted = true;
break;
default:
esm.cacheSubName();
isLoaded = true;
break;
}
}
if (!hasLocation)
esm.fail("Missing INTV subrecord");
mContext = esm.getContext();
mLandData = nullptr;
std::fill(std::begin(mWnam), std::end(mWnam), 0);
// Skip the land data here. Load it when the cell is loaded.
while (esm.hasMoreSubs())
{
esm.getSubName();
switch (esm.retSubName().toInt())
{
case fourCC("VNML"):
esm.skipHSub();
if (mFlags & Flag_HeightsNormals)
mDataTypes |= DATA_VNML;
break;
case fourCC("VHGT"):
esm.skipHSub();
if (mFlags & Flag_HeightsNormals)
mDataTypes |= DATA_VHGT;
break;
case fourCC("WNAM"):
esm.getHT(mWnam);
if (mFlags & Flag_HeightsNormals)
mDataTypes |= DATA_WNAM;
break;
case fourCC("VCLR"):
esm.skipHSub();
if (mFlags & Flag_Colors)
mDataTypes |= DATA_VCLR;
break;
case fourCC("VTEX"):
esm.skipHSub();
if (mFlags & Flag_Textures)
mDataTypes |= DATA_VTEX;
break;
default:
esm.fail("Unknown subrecord");
break;
}
}
}
void Land::save(ESMWriter& esm, bool isDeleted) const
{
esm.startSubRecord("INTV");
esm.writeT(mX);
esm.writeT(mY);
esm.endRecord("INTV");
esm.writeHNT("DATA", mFlags);
if (isDeleted)
{
esm.writeHNString("DELE", "", 3);
return;
}
if (mLandData)
{
if (mDataTypes & Land::DATA_VNML)
{
esm.writeHNT("VNML", mLandData->mNormals);
}
if (mDataTypes & Land::DATA_VHGT)
{
VHGT offsets;
offsets.mHeightOffset = mLandData->mHeights[0] / sHeightScale;
float prevY = mLandData->mHeights[0];
size_t number = 0; // avoid multiplication
for (unsigned i = 0; i < LandRecordData::sLandSize; ++i)
{
float diff = (mLandData->mHeights[number] - prevY) / sHeightScale;
offsets.mHeightData[number]
= diff >= 0 ? static_cast<std::int8_t>(diff + 0.5) : static_cast<std::int8_t>(diff - 0.5);
float prevX = prevY = mLandData->mHeights[number];
++number;
for (unsigned j = 1; j < LandRecordData::sLandSize; ++j)
{
diff = (mLandData->mHeights[number] - prevX) / sHeightScale;
offsets.mHeightData[number]
= diff >= 0 ? static_cast<std::int8_t>(diff + 0.5) : static_cast<std::int8_t>(diff - 0.5);
prevX = mLandData->mHeights[number];
++number;
}
}
esm.writeNamedComposite("VHGT", offsets);
}
if (mDataTypes & Land::DATA_WNAM)
{
// Generate WNAM record
std::array<std::int8_t, sGlobalMapLodSize> wnam;
generateWnam(mLandData->mHeights, wnam);
esm.writeHNT("WNAM", wnam);
}
if (mDataTypes & Land::DATA_VCLR)
{
esm.writeHNT("VCLR", mLandData->mColours);
}
if (mDataTypes & Land::DATA_VTEX)
{
uint16_t vtex[LandRecordData::sLandNumTextures];
transposeTextureData(mLandData->mTextures.data(), vtex);
esm.writeHNT("VTEX", vtex);
}
}
}
void Land::blank()
{
setPlugin(0);
mWnam.fill(0);
if (mLandData == nullptr)
mLandData = std::make_unique<LandData>();
mLandData->mHeights.fill(DEFAULT_HEIGHT);
mLandData->mMinHeight = DEFAULT_HEIGHT;
mLandData->mMaxHeight = DEFAULT_HEIGHT;
for (size_t i = 0; i < LandRecordData::sLandNumVerts; ++i)
{
mLandData->mNormals[i * 3 + 0] = 0;
mLandData->mNormals[i * 3 + 1] = 0;
mLandData->mNormals[i * 3 + 2] = 127;
}
mLandData->mTextures.fill(0);
mLandData->mColours.fill(255);
mLandData->mDataLoaded
= Land::DATA_VNML | Land::DATA_VHGT | Land::DATA_WNAM | Land::DATA_VCLR | Land::DATA_VTEX;
mDataTypes = mLandData->mDataLoaded;
// No file associated with the land now
mContext.filename.clear();
}
void Land::loadData(int dataTypes) const
{
if (mLandData == nullptr)
mLandData = std::make_unique<LandData>();
loadData(dataTypes, *mLandData);
}
void Land::loadData(int dataTypes, LandData& data) const
{
// Try to load only available data
dataTypes = dataTypes & mDataTypes;
// Return if all required data is loaded
if ((data.mDataLoaded & dataTypes) == dataTypes)
{
return;
}
if (mContext.filename.empty())
{
// Make sure there is data, and that it doesn't point to the same object.
if (mLandData != nullptr && mLandData.get() != &data)
data = *mLandData;
return;
}
ESMReader reader;
reader.restoreContext(mContext);
loadLandRecordData(dataTypes, reader, data);
}
void Land::unloadData()
{
mLandData = nullptr;
}
bool Land::isDataLoaded(int flags) const
{
return mLandData && (mLandData->mDataLoaded & flags) == flags;
}
Land::Land(const Land& land)
: mFlags(land.mFlags)
, mX(land.mX)
, mY(land.mY)
, mContext(land.mContext)
, mDataTypes(land.mDataTypes)
, mWnam(land.mWnam)
, mLandData(land.mLandData != nullptr ? std::make_unique<LandData>(*land.mLandData) : nullptr)
{
}
Land& Land::operator=(const Land& land)
{
Land copy(land);
*this = std::move(copy);
return *this;
}
const Land::LandData* Land::getLandData(int flags) const
{
if (!(flags & mDataTypes))
return nullptr;
loadData(flags);
return mLandData.get();
}
void Land::add(int flags)
{
if (mLandData == nullptr)
mLandData = std::make_unique<LandData>();
mDataTypes |= flags;
mLandData->mDataLoaded |= flags;
}
void loadLandRecordData(int dataTypes, ESMReader& reader, LandRecordData& data)
{
if (reader.isNextSub("VNML"))
condLoad(reader, dataTypes, data.mDataLoaded, Land::DATA_VNML, data.mNormals);
if (reader.isNextSub("VHGT"))
{
VHGT vhgt;
if (condLoad(reader, dataTypes, data.mDataLoaded, Land::DATA_VHGT, vhgt))
{
data.mMinHeight = std::numeric_limits<float>::max();
data.mMaxHeight = -std::numeric_limits<float>::max();
float rowOffset = vhgt.mHeightOffset;
for (unsigned y = 0; y < LandRecordData::sLandSize; y++)
{
rowOffset += vhgt.mHeightData[y * LandRecordData::sLandSize];
data.mHeights[y * LandRecordData::sLandSize] = rowOffset * Land::sHeightScale;
if (rowOffset * Land::sHeightScale > data.mMaxHeight)
data.mMaxHeight = rowOffset * Land::sHeightScale;
if (rowOffset * Land::sHeightScale < data.mMinHeight)
data.mMinHeight = rowOffset * Land::sHeightScale;
float colOffset = rowOffset;
for (unsigned x = 1; x < LandRecordData::sLandSize; x++)
{
colOffset += vhgt.mHeightData[y * LandRecordData::sLandSize + x];
data.mHeights[x + y * LandRecordData::sLandSize] = colOffset * Land::sHeightScale;
if (colOffset * Land::sHeightScale > data.mMaxHeight)
data.mMaxHeight = colOffset * Land::sHeightScale;
if (colOffset * Land::sHeightScale < data.mMinHeight)
data.mMinHeight = colOffset * Land::sHeightScale;
}
}
}
}
if (reader.isNextSub("WNAM"))
reader.skipHSub();
if (reader.isNextSub("VCLR"))
condLoad(reader, dataTypes, data.mDataLoaded, Land::DATA_VCLR, data.mColours);
if (reader.isNextSub("VTEX"))
{
std::uint16_t vtex[LandRecordData::sLandNumTextures];
if (condLoad(reader, dataTypes, data.mDataLoaded, Land::DATA_VTEX, vtex))
transposeTextureData(vtex, data.mTextures.data());
}
}
void generateWnam(const std::array<float, LandRecordData::sLandNumVerts>& heights,
std::array<std::int8_t, Land::sGlobalMapLodSize>& wnam)
{
constexpr float max = std::numeric_limits<std::int8_t>::max();
constexpr float min = std::numeric_limits<std::int8_t>::min();
constexpr float vertMult = static_cast<float>(LandRecordData::sLandSize - 1) / Land::sGlobalMapLodSizeSqrt;
for (std::size_t row = 0; row < Land::sGlobalMapLodSizeSqrt; ++row)
{
for (std::size_t col = 0; col < Land::sGlobalMapLodSizeSqrt; ++col)
{
float height = heights[static_cast<std::size_t>(row * vertMult) * LandRecordData::sLandSize
+ static_cast<std::size_t>(col * vertMult)];
height /= height > 0 ? 128.f : 16.f;
height = std::clamp(height, min, max);
wnam[row * Land::sGlobalMapLodSizeSqrt + col] = static_cast<std::int8_t>(height);
}
}
}
}
| 12,857
|
C++
|
.cpp
| 330
| 26.027273
| 118
| 0.509898
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,564
|
cellstate.cpp
|
OpenMW_openmw/components/esm3/cellstate.cpp
|
#include "cellstate.hpp"
#include "esmreader.hpp"
#include "esmwriter.hpp"
namespace ESM
{
void CellState::load(ESMReader& esm)
{
mWaterLevel = 0;
esm.getHNOT(mWaterLevel, "WLVL");
mHasFogOfWar = false;
esm.getHNOT(mHasFogOfWar, "HFOW");
mLastRespawn.mDay = 0;
mLastRespawn.mHour = 0;
if (esm.peekNextSub("RESP"))
mLastRespawn.load(esm, "RESP");
}
void CellState::save(ESMWriter& esm) const
{
if (mIsInterior)
esm.writeHNT("WLVL", mWaterLevel);
esm.writeHNT("HFOW", mHasFogOfWar);
esm.writeHNT("RESP", mLastRespawn);
}
}
| 658
|
C++
|
.cpp
| 24
| 20.708333
| 46
| 0.6128
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| true
| true
| false
|
34,565
|
loadpgrd.cpp
|
OpenMW_openmw/components/esm3/loadpgrd.cpp
|
#include "loadpgrd.hpp"
#include "esmreader.hpp"
#include "esmwriter.hpp"
#include <components/misc/concepts.hpp>
namespace ESM
{
template <Misc::SameAsWithoutCvref<Pathgrid::DATAstruct> T>
void decompose(T&& v, const auto& f)
{
f(v.mX, v.mY, v.mGranularity, v.mPoints);
}
template <Misc::SameAsWithoutCvref<Pathgrid::Point> T>
void decompose(T&& v, const auto& f)
{
char padding[2] = { 0, 0 };
f(v.mX, v.mY, v.mZ, v.mAutogenerated, v.mConnectionNum, padding);
}
Pathgrid::Point& Pathgrid::Point::operator=(const float rhs[3])
{
mX = static_cast<int32_t>(rhs[0]);
mY = static_cast<int32_t>(rhs[1]);
mZ = static_cast<int32_t>(rhs[2]);
mAutogenerated = 0;
mConnectionNum = 0;
return *this;
}
Pathgrid::Point::Point(const float rhs[3])
: mX(static_cast<int32_t>(rhs[0]))
, mY(static_cast<int32_t>(rhs[1]))
, mZ(static_cast<int32_t>(rhs[2]))
, mAutogenerated(0)
, mConnectionNum(0)
{
}
Pathgrid::Point::Point()
: mX(0)
, mY(0)
, mZ(0)
, mAutogenerated(0)
, mConnectionNum(0)
{
}
void Pathgrid::load(ESMReader& esm, bool& isDeleted)
{
isDeleted = false;
mPoints.clear();
mEdges.clear();
// keep track of total connections so we can reserve edge vector size
size_t edgeCount = 0;
bool hasData = false;
while (esm.hasMoreSubs())
{
esm.getSubName();
switch (esm.retSubName().toInt())
{
case SREC_NAME:
mCell = esm.getRefId();
break;
case fourCC("DATA"):
esm.getSubComposite(mData);
hasData = true;
break;
case fourCC("PGRP"):
{
esm.getSubHeader();
uint32_t size = esm.getSubSize();
if (size != getCompositeSize(Point{}) * mData.mPoints)
esm.fail("Path point subrecord size mismatch");
else
{
mPoints.reserve(mData.mPoints);
for (uint16_t i = 0; i < mData.mPoints; ++i)
{
Point p;
esm.getComposite(p);
mPoints.push_back(p);
edgeCount += p.mConnectionNum;
}
}
break;
}
case fourCC("PGRC"):
{
esm.getSubHeader();
uint32_t size = esm.getSubSize();
if (size % sizeof(uint32_t) != 0)
esm.fail("PGRC size not a multiple of 4");
else
{
size_t rawConnNum = size / sizeof(uint32_t);
std::vector<size_t> rawConnections;
rawConnections.reserve(rawConnNum);
for (size_t i = 0; i < rawConnNum; ++i)
{
uint32_t currentValue;
esm.getT(currentValue);
rawConnections.push_back(currentValue);
}
auto rawIt = rawConnections.begin();
size_t pointIndex = 0;
mEdges.reserve(edgeCount);
for (const auto& point : mPoints)
{
unsigned char connectionNum = point.mConnectionNum;
if (rawConnections.end() - rawIt < connectionNum)
esm.fail("Not enough connections");
for (int i = 0; i < connectionNum; ++i)
{
Edge edge;
edge.mV0 = pointIndex;
edge.mV1 = *rawIt;
++rawIt;
mEdges.push_back(edge);
}
++pointIndex;
}
}
break;
}
case SREC_DELE:
esm.skipHSub();
isDeleted = true;
break;
default:
esm.fail("Unknown subrecord");
break;
}
}
if (!hasData)
esm.fail("Missing DATA subrecord");
}
void Pathgrid::save(ESMWriter& esm, bool isDeleted) const
{
// Correct connection count and sort edges by point
// Can probably be optimized
PointList correctedPoints = mPoints;
std::vector<uint32_t> sortedEdges;
sortedEdges.reserve(mEdges.size());
for (size_t point = 0; point < correctedPoints.size(); ++point)
{
correctedPoints[point].mConnectionNum = 0;
for (const auto& edge : mEdges)
{
if (edge.mV0 == point)
{
sortedEdges.push_back(static_cast<uint32_t>(edge.mV1));
++correctedPoints[point].mConnectionNum;
}
}
}
// Save
esm.writeHNCRefId("NAME", mCell);
esm.writeNamedComposite("DATA", mData);
if (isDeleted)
{
esm.writeHNString("DELE", {}, 3);
return;
}
if (!correctedPoints.empty())
{
esm.startSubRecord("PGRP");
for (const Point& point : correctedPoints)
{
esm.writeComposite(point);
}
esm.endRecord("PGRP");
}
if (!sortedEdges.empty())
{
esm.startSubRecord("PGRC");
for (const uint32_t& edge : sortedEdges)
{
esm.writeT(edge);
}
esm.endRecord("PGRC");
}
}
void Pathgrid::blank()
{
mCell = ESM::RefId();
mData.mX = 0;
mData.mY = 0;
mData.mGranularity = 0;
mData.mPoints = 0;
mPoints.clear();
mEdges.clear();
}
}
| 6,441
|
C++
|
.cpp
| 188
| 19.579787
| 79
| 0.437189
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,566
|
loadingr.cpp
|
OpenMW_openmw/components/esm3/loadingr.cpp
|
#include "loadingr.hpp"
#include "esmreader.hpp"
#include "esmwriter.hpp"
#include <components/misc/concepts.hpp>
namespace ESM
{
template <Misc::SameAsWithoutCvref<Ingredient::IRDTstruct> T>
void decompose(T&& v, const auto& f)
{
f(v.mWeight, v.mValue, v.mEffectID, v.mSkills, v.mAttributes);
}
void Ingredient::load(ESMReader& esm, bool& isDeleted)
{
isDeleted = false;
mRecordFlags = esm.getRecordFlags();
bool hasName = false;
bool hasData = false;
while (esm.hasMoreSubs())
{
esm.getSubName();
switch (esm.retSubName().toInt())
{
case SREC_NAME:
mId = esm.getRefId();
hasName = true;
break;
case fourCC("MODL"):
mModel = esm.getHString();
break;
case fourCC("FNAM"):
mName = esm.getHString();
break;
case fourCC("IRDT"):
esm.getSubComposite(mData);
hasData = true;
break;
case fourCC("SCRI"):
mScript = esm.getRefId();
break;
case fourCC("ITEX"):
mIcon = esm.getHString();
break;
case SREC_DELE:
esm.skipHSub();
isDeleted = true;
break;
default:
esm.fail("Unknown subrecord");
break;
}
}
if (!hasName)
esm.fail("Missing NAME subrecord");
if (!hasData && !isDeleted)
esm.fail("Missing IRDT subrecord");
// horrible hack to fix broken data in records
for (int i = 0; i < 4; ++i)
{
if (mData.mEffectID[i] != 85 && mData.mEffectID[i] != 22 && mData.mEffectID[i] != 17
&& mData.mEffectID[i] != 79 && mData.mEffectID[i] != 74)
{
mData.mAttributes[i] = -1;
}
// is this relevant in cycle from 0 to 4?
if (mData.mEffectID[i] != 89 && mData.mEffectID[i] != 26 && mData.mEffectID[i] != 21
&& mData.mEffectID[i] != 83 && mData.mEffectID[i] != 78)
{
mData.mSkills[i] = -1;
}
}
}
void Ingredient::save(ESMWriter& esm, bool isDeleted) const
{
esm.writeHNCRefId("NAME", mId);
if (isDeleted)
{
esm.writeHNString("DELE", "", 3);
return;
}
esm.writeHNCString("MODL", mModel);
esm.writeHNOCString("FNAM", mName);
esm.writeNamedComposite("IRDT", mData);
esm.writeHNOCRefId("SCRI", mScript);
esm.writeHNOCString("ITEX", mIcon);
}
void Ingredient::blank()
{
mRecordFlags = 0;
mData.mWeight = 0;
mData.mValue = 0;
for (int i = 0; i < 4; ++i)
{
mData.mEffectID[i] = 0;
mData.mSkills[i] = 0;
mData.mAttributes[i] = 0;
}
mName.clear();
mModel.clear();
mIcon.clear();
mScript = ESM::RefId();
}
}
| 3,291
|
C++
|
.cpp
| 102
| 20.313725
| 96
| 0.469144
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,567
|
loaddial.cpp
|
OpenMW_openmw/components/esm3/loaddial.cpp
|
#include "loaddial.hpp"
#include "esmreader.hpp"
#include "esmwriter.hpp"
#include <stdexcept>
namespace ESM
{
void Dialogue::load(ESMReader& esm, bool& isDeleted)
{
loadId(esm);
loadData(esm, isDeleted);
}
void Dialogue::loadId(ESMReader& esm)
{
if (esm.getFormatVersion() <= MaxStringRefIdFormatVersion)
{
mStringId = esm.getHNString("NAME");
mId = ESM::RefId::stringRefId(mStringId);
return;
}
if (esm.getFormatVersion() <= MaxNameIsRefIdOnlyFormatVersion)
{
mId = esm.getHNRefId("NAME");
return;
}
mId = esm.getHNRefId("ID__");
}
void Dialogue::loadData(ESMReader& esm, bool& isDeleted)
{
isDeleted = false;
while (esm.hasMoreSubs())
{
esm.getSubName();
switch (esm.retSubName().toInt())
{
case fourCC("DATA"):
{
esm.getSubHeader();
int size = esm.getSubSize();
if (size == 1)
{
esm.getT(mType);
}
else
{
esm.skip(size);
mType = Unknown;
}
break;
}
case SREC_DELE:
esm.skipHSub();
mType = Unknown;
isDeleted = true;
break;
case SREC_NAME:
mStringId = esm.getHString();
break;
default:
esm.fail("Unknown subrecord");
break;
}
}
if (!isDeleted && MaxStringRefIdFormatVersion < esm.getFormatVersion()
&& esm.getFormatVersion() <= MaxNameIsRefIdOnlyFormatVersion)
mStringId = mId.toString();
}
void Dialogue::save(ESMWriter& esm, bool isDeleted) const
{
if (esm.getFormatVersion() <= MaxStringRefIdFormatVersion)
{
if (mId != mStringId)
throw std::runtime_error("Trying to save Dialogue record with name \"" + mStringId
+ "\" not maching id " + mId.toDebugString());
esm.writeHNCString("NAME", mStringId);
}
else if (esm.getFormatVersion() <= MaxNameIsRefIdOnlyFormatVersion)
esm.writeHNCRefId("NAME", mId);
else
esm.writeHNRefId("ID__", mId);
if (isDeleted)
{
esm.writeHNString("DELE", "", 3);
}
else
{
if (esm.getFormatVersion() > MaxNameIsRefIdOnlyFormatVersion)
esm.writeHNString("NAME", mStringId);
esm.writeHNT("DATA", mType);
}
}
void Dialogue::blank()
{
mType = Unknown;
mInfo.clear();
}
void Dialogue::readInfo(ESMReader& esm)
{
DialInfo info;
bool isDeleted = false;
info.load(esm, isDeleted);
mInfoOrder.insertInfo(std::move(info), isDeleted);
}
void Dialogue::setUp()
{
mInfoOrder.removeDeleted();
mInfoOrder.extractOrderedInfo(mInfo);
}
}
| 3,291
|
C++
|
.cpp
| 108
| 18.925926
| 98
| 0.493687
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,568
|
objectstate.cpp
|
OpenMW_openmw/components/esm3/objectstate.cpp
|
#include "objectstate.hpp"
#include <array>
#include <sstream>
#include <stdexcept>
#include <typeinfo>
#include "esmreader.hpp"
#include "esmwriter.hpp"
namespace ESM
{
void ObjectState::load(ESMReader& esm)
{
mVersion = esm.getFormatVersion();
bool isDeleted;
mRef.loadData(esm, isDeleted);
mHasLocals = 0;
esm.getHNOT(mHasLocals, "HLOC");
if (mHasLocals)
mLocals.load(esm);
mLuaScripts.load(esm);
mEnabled = 1;
esm.getHNOT(mEnabled, "ENAB");
if (mVersion <= MaxOldCountFormatVersion)
{
if (mVersion <= MaxOldGoldValueFormatVersion)
mRef.mCount = std::max(1, mRef.mCount);
esm.getHNOT("COUN", mRef.mCount);
}
mPosition = mRef.mPos;
esm.getOptionalComposite("POS_", mPosition);
mFlags = 0;
esm.getHNOT(mFlags, "FLAG");
mAnimationState.load(esm);
// FIXME: assuming "false" as default would make more sense, but also break compatibility with older save files
mHasCustomState = true;
esm.getHNOT(mHasCustomState, "HCUS");
}
void ObjectState::save(ESMWriter& esm, bool inInventory) const
{
mRef.save(esm, true, inInventory);
if (mHasLocals)
{
esm.writeHNT("HLOC", mHasLocals);
mLocals.save(esm);
}
mLuaScripts.save(esm);
if (!mEnabled && !inInventory)
esm.writeHNT("ENAB", mEnabled);
if (!inInventory && mPosition != mRef.mPos)
{
esm.writeNamedComposite("POS_", mPosition);
}
if (mFlags != 0)
esm.writeHNT("FLAG", mFlags);
mAnimationState.save(esm);
if (!mHasCustomState)
esm.writeHNT("HCUS", false);
}
void ObjectState::blank()
{
mRef.blank();
mHasLocals = 0;
mEnabled = false;
for (int i = 0; i < 3; ++i)
{
mPosition.pos[i] = 0;
mPosition.rot[i] = 0;
}
mFlags = 0;
mHasCustomState = true;
}
const NpcState& ObjectState::asNpcState() const
{
std::stringstream error;
error << "bad cast " << typeid(this).name() << " to NpcState";
throw std::logic_error(error.str());
}
NpcState& ObjectState::asNpcState()
{
std::stringstream error;
error << "bad cast " << typeid(this).name() << " to NpcState";
throw std::logic_error(error.str());
}
const CreatureState& ObjectState::asCreatureState() const
{
std::stringstream error;
error << "bad cast " << typeid(this).name() << " to CreatureState";
throw std::logic_error(error.str());
}
CreatureState& ObjectState::asCreatureState()
{
std::stringstream error;
error << "bad cast " << typeid(this).name() << " to CreatureState";
throw std::logic_error(error.str());
}
const ContainerState& ObjectState::asContainerState() const
{
std::stringstream error;
error << "bad cast " << typeid(this).name() << " to ContainerState";
throw std::logic_error(error.str());
}
ContainerState& ObjectState::asContainerState()
{
std::stringstream error;
error << "bad cast " << typeid(this).name() << " to ContainerState";
throw std::logic_error(error.str());
}
const DoorState& ObjectState::asDoorState() const
{
std::stringstream error;
error << "bad cast " << typeid(this).name() << " to DoorState";
throw std::logic_error(error.str());
}
DoorState& ObjectState::asDoorState()
{
std::stringstream error;
error << "bad cast " << typeid(this).name() << " to DoorState";
throw std::logic_error(error.str());
}
const CreatureLevListState& ObjectState::asCreatureLevListState() const
{
std::stringstream error;
error << "bad cast " << typeid(this).name() << " to CreatureLevListState";
throw std::logic_error(error.str());
}
CreatureLevListState& ObjectState::asCreatureLevListState()
{
std::stringstream error;
error << "bad cast " << typeid(this).name() << " to CreatureLevListState";
throw std::logic_error(error.str());
}
ObjectState::~ObjectState() = default;
}
| 4,389
|
C++
|
.cpp
| 132
| 25.409091
| 119
| 0.589057
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,569
|
selectiongroup.cpp
|
OpenMW_openmw/components/esm3/selectiongroup.cpp
|
#include "selectiongroup.hpp"
#include "esmreader.hpp"
#include "esmwriter.hpp"
namespace ESM
{
void SelectionGroup::load(ESMReader& esm, bool& isDeleted)
{
while (esm.hasMoreSubs())
{
esm.getSubName();
switch (esm.retSubName().toInt())
{
case fourCC("SELC"):
mId = esm.getRefId();
break;
case fourCC("SELI"):
selectedInstances.push_back(esm.getRefId().getRefIdString());
break;
default:
esm.fail("Unknown subrecord");
break;
}
}
}
void SelectionGroup::save(ESMWriter& esm, bool isDeleted) const
{
esm.writeHNCRefId("SELC", mId);
for (std::string id : selectedInstances)
esm.writeHNCString("SELI", id);
}
void SelectionGroup::blank() {}
}
| 941
|
C++
|
.cpp
| 32
| 18.96875
| 81
| 0.516058
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,570
|
custommarkerstate.cpp
|
OpenMW_openmw/components/esm3/custommarkerstate.cpp
|
#include "custommarkerstate.hpp"
#include "esmreader.hpp"
#include "esmwriter.hpp"
namespace ESM
{
void CustomMarker::save(ESMWriter& esm) const
{
esm.writeHNT("POSX", mWorldX);
esm.writeHNT("POSY", mWorldY);
esm.writeCellId(mCell);
if (!mNote.empty())
esm.writeHNString("NOTE", mNote);
}
void CustomMarker::load(ESMReader& esm)
{
esm.getHNT(mWorldX, "POSX");
esm.getHNT(mWorldY, "POSY");
mCell = esm.getCellId();
mNote = esm.getHNOString("NOTE");
}
}
| 557
|
C++
|
.cpp
| 21
| 20.52381
| 49
| 0.615819
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,571
|
loadarmo.cpp
|
OpenMW_openmw/components/esm3/loadarmo.cpp
|
#include "loadarmo.hpp"
#include "esmreader.hpp"
#include "esmwriter.hpp"
#include <components/misc/concepts.hpp>
namespace ESM
{
template <Misc::SameAsWithoutCvref<Armor::AODTstruct> T>
void decompose(T&& v, const auto& f)
{
f(v.mType, v.mWeight, v.mValue, v.mHealth, v.mEnchant, v.mArmor);
}
void PartReferenceList::add(ESMReader& esm)
{
PartReference pr;
esm.getHT(pr.mPart); // The INDX byte
pr.mMale = esm.getHNORefId("BNAM");
pr.mFemale = esm.getHNORefId("CNAM");
mParts.push_back(pr);
}
void PartReferenceList::load(ESMReader& esm)
{
mParts.clear();
while (esm.isNextSub("INDX"))
{
add(esm);
}
}
void PartReferenceList::save(ESMWriter& esm) const
{
for (std::vector<PartReference>::const_iterator it = mParts.begin(); it != mParts.end(); ++it)
{
esm.writeHNT("INDX", it->mPart);
esm.writeHNORefId("BNAM", it->mMale);
esm.writeHNORefId("CNAM", it->mFemale);
}
}
void Armor::load(ESMReader& esm, bool& isDeleted)
{
isDeleted = false;
mRecordFlags = esm.getRecordFlags();
mParts.mParts.clear();
bool hasName = false;
bool hasData = false;
while (esm.hasMoreSubs())
{
esm.getSubName();
switch (esm.retSubName().toInt())
{
case SREC_NAME:
mId = esm.getRefId();
hasName = true;
break;
case fourCC("MODL"):
mModel = esm.getHString();
break;
case fourCC("FNAM"):
mName = esm.getHString();
break;
case fourCC("AODT"):
esm.getSubComposite(mData);
hasData = true;
break;
case fourCC("SCRI"):
mScript = esm.getRefId();
break;
case fourCC("ITEX"):
mIcon = esm.getHString();
break;
case fourCC("ENAM"):
mEnchant = esm.getRefId();
break;
case fourCC("INDX"):
mParts.add(esm);
break;
case SREC_DELE:
esm.skipHSub();
isDeleted = true;
break;
default:
esm.fail("Unknown subrecord");
break;
}
}
if (!hasName)
esm.fail("Missing NAME subrecord");
if (!hasData && !isDeleted)
esm.fail("Missing AODT subrecord");
}
void Armor::save(ESMWriter& esm, bool isDeleted) const
{
esm.writeHNCRefId("NAME", mId);
if (isDeleted)
{
esm.writeHNString("DELE", "", 3);
return;
}
esm.writeHNCString("MODL", mModel);
esm.writeHNOCString("FNAM", mName);
esm.writeHNOCRefId("SCRI", mScript);
esm.writeNamedComposite("AODT", mData);
esm.writeHNOCString("ITEX", mIcon);
mParts.save(esm);
esm.writeHNOCRefId("ENAM", mEnchant);
}
void Armor::blank()
{
mRecordFlags = 0;
mData.mType = 0;
mData.mWeight = 0;
mData.mValue = 0;
mData.mHealth = 0;
mData.mEnchant = 0;
mData.mArmor = 0;
mParts.mParts.clear();
mName.clear();
mModel.clear();
mIcon.clear();
mScript = ESM::RefId();
mEnchant = ESM::RefId();
}
}
| 3,707
|
C++
|
.cpp
| 121
| 19.371901
| 102
| 0.488242
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| true
| true
| false
|
34,572
|
loadltex.cpp
|
OpenMW_openmw/components/esm3/loadltex.cpp
|
#include "loadltex.hpp"
#include "components/esm/defs.hpp"
#include "esmreader.hpp"
#include "esmwriter.hpp"
namespace ESM
{
void LandTexture::load(ESMReader& esm, bool& isDeleted)
{
isDeleted = false;
bool hasName = false;
bool hasIndex = false;
while (esm.hasMoreSubs())
{
esm.getSubName();
switch (esm.retSubName().toInt())
{
case SREC_NAME:
mId = esm.getRefId();
hasName = true;
break;
case fourCC("INTV"):
esm.getHT(mIndex);
hasIndex = true;
break;
case fourCC("DATA"):
mTexture = esm.getHString();
break;
case SREC_DELE:
esm.skipHSub();
isDeleted = true;
break;
default:
esm.fail("Unknown subrecord");
break;
}
}
if (!hasName)
esm.fail("Missing NAME subrecord");
if (!hasIndex)
esm.fail("Missing INTV subrecord");
}
void LandTexture::save(ESMWriter& esm, bool isDeleted) const
{
esm.writeHNCRefId("NAME", mId);
esm.writeHNT("INTV", mIndex);
esm.writeHNCString("DATA", mTexture);
if (isDeleted)
{
esm.writeHNString("DELE", "", 3);
}
}
void LandTexture::blank()
{
mId = ESM::RefId();
mTexture.clear();
}
}
| 1,604
|
C++
|
.cpp
| 57
| 16.719298
| 64
| 0.464633
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,573
|
loadappa.cpp
|
OpenMW_openmw/components/esm3/loadappa.cpp
|
#include "loadappa.hpp"
#include "esmreader.hpp"
#include "esmwriter.hpp"
#include <components/misc/concepts.hpp>
namespace ESM
{
template <Misc::SameAsWithoutCvref<Apparatus::AADTstruct> T>
void decompose(T&& v, const auto& f)
{
f(v.mType, v.mQuality, v.mWeight, v.mValue);
}
void Apparatus::load(ESMReader& esm, bool& isDeleted)
{
isDeleted = false;
mRecordFlags = esm.getRecordFlags();
bool hasName = false;
bool hasData = false;
while (esm.hasMoreSubs())
{
esm.getSubName();
switch (esm.retSubName().toInt())
{
case SREC_NAME:
mId = esm.getRefId();
hasName = true;
break;
case fourCC("MODL"):
mModel = esm.getHString();
break;
case fourCC("FNAM"):
mName = esm.getHString();
break;
case fourCC("AADT"):
esm.getSubComposite(mData);
hasData = true;
break;
case fourCC("SCRI"):
mScript = esm.getRefId();
break;
case fourCC("ITEX"):
mIcon = esm.getHString();
break;
case SREC_DELE:
esm.skipHSub();
isDeleted = true;
break;
default:
esm.fail("Unknown subrecord");
break;
}
}
if (!hasName)
esm.fail("Missing NAME subrecord");
if (!hasData && !isDeleted)
esm.fail("Missing AADT subrecord");
}
void Apparatus::save(ESMWriter& esm, bool isDeleted) const
{
esm.writeHNCRefId("NAME", mId);
if (isDeleted)
{
esm.writeHNString("DELE", "", 3);
return;
}
esm.writeHNCString("MODL", mModel);
esm.writeHNCString("FNAM", mName);
esm.writeNamedComposite("AADT", mData);
esm.writeHNOCRefId("SCRI", mScript);
esm.writeHNCString("ITEX", mIcon);
}
void Apparatus::blank()
{
mRecordFlags = 0;
mData.mType = 0;
mData.mQuality = 0;
mData.mWeight = 0;
mData.mValue = 0;
mModel.clear();
mIcon.clear();
mScript = ESM::RefId();
mName.clear();
}
}
| 2,510
|
C++
|
.cpp
| 83
| 18.518072
| 64
| 0.477038
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,574
|
spelllist.cpp
|
OpenMW_openmw/components/esm3/spelllist.cpp
|
#include "spelllist.hpp"
#include "esmreader.hpp"
#include "esmwriter.hpp"
#include <components/misc/strings/algorithm.hpp>
namespace ESM
{
void SpellList::add(ESMReader& esm)
{
mList.push_back(esm.getRefId());
}
void SpellList::save(ESMWriter& esm) const
{
for (auto it = mList.begin(); it != mList.end(); ++it)
{
esm.writeHNRefId("NPCS", *it, 32);
}
}
bool SpellList::exists(const ESM::RefId& spell) const
{
for (auto it = mList.begin(); it != mList.end(); ++it)
if (*it == spell)
return true;
return false;
}
}
| 645
|
C++
|
.cpp
| 25
| 19.56
| 62
| 0.574225
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| true
| false
|
34,575
|
loadspel.cpp
|
OpenMW_openmw/components/esm3/loadspel.cpp
|
#include "loadspel.hpp"
#include "esmreader.hpp"
#include "esmwriter.hpp"
#include <components/misc/concepts.hpp>
namespace ESM
{
template <Misc::SameAsWithoutCvref<Spell::SPDTstruct> T>
void decompose(T&& v, const auto& f)
{
f(v.mType, v.mCost, v.mFlags);
}
void Spell::load(ESMReader& esm, bool& isDeleted)
{
isDeleted = false;
mRecordFlags = esm.getRecordFlags();
mEffects.mList.clear();
bool hasName = false;
bool hasData = false;
while (esm.hasMoreSubs())
{
esm.getSubName();
switch (esm.retSubName().toInt())
{
case SREC_NAME:
mId = esm.getRefId();
hasName = true;
break;
case fourCC("FNAM"):
mName = esm.getHString();
break;
case fourCC("SPDT"):
esm.getSubComposite(mData);
hasData = true;
break;
case fourCC("ENAM"):
mEffects.add(esm);
break;
case SREC_DELE:
esm.skipHSub();
isDeleted = true;
break;
default:
esm.fail("Unknown subrecord");
break;
}
}
if (!hasName)
esm.fail("Missing NAME subrecord");
if (!hasData && !isDeleted)
esm.fail("Missing SPDT subrecord");
}
void Spell::save(ESMWriter& esm, bool isDeleted) const
{
esm.writeHNCRefId("NAME", mId);
if (isDeleted)
{
esm.writeHNString("DELE", "", 3);
return;
}
esm.writeHNOCString("FNAM", mName);
esm.writeNamedComposite("SPDT", mData);
mEffects.save(esm);
}
void Spell::blank()
{
mRecordFlags = 0;
mData.mType = 0;
mData.mCost = 0;
mData.mFlags = 0;
mName.clear();
mEffects.mList.clear();
}
}
| 2,106
|
C++
|
.cpp
| 73
| 17.60274
| 60
| 0.477981
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,576
|
loadacti.cpp
|
OpenMW_openmw/components/esm3/loadacti.cpp
|
#include "loadacti.hpp"
#include "esmreader.hpp"
#include "esmwriter.hpp"
namespace ESM
{
void Activator::load(ESMReader& esm, bool& isDeleted)
{
isDeleted = false;
mRecordFlags = esm.getRecordFlags();
bool hasName = false;
while (esm.hasMoreSubs())
{
esm.getSubName();
switch (esm.retSubName().toInt())
{
case SREC_NAME:
mId = esm.getRefId();
hasName = true;
break;
case fourCC("MODL"):
mModel = esm.getHString();
break;
case fourCC("FNAM"):
mName = esm.getHString();
break;
case fourCC("SCRI"):
mScript = esm.getRefId();
break;
case SREC_DELE:
esm.skipHSub();
isDeleted = true;
break;
default:
esm.fail("Unknown subrecord");
break;
}
}
if (!hasName)
esm.fail("Missing NAME subrecord");
}
void Activator::save(ESMWriter& esm, bool isDeleted) const
{
esm.writeHNCRefId("NAME", mId);
if (isDeleted)
{
esm.writeHNString("DELE", "", 3);
return;
}
esm.writeHNCString("MODL", mModel);
esm.writeHNOCString("FNAM", mName);
esm.writeHNOCRefId("SCRI", mScript);
}
void Activator::blank()
{
mRecordFlags = 0;
mName.clear();
mScript = ESM::RefId();
mModel.clear();
}
}
| 1,705
|
C++
|
.cpp
| 60
| 16.633333
| 62
| 0.456654
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,577
|
filter.cpp
|
OpenMW_openmw/components/esm3/filter.cpp
|
#include "filter.hpp"
#include "esmreader.hpp"
#include "esmwriter.hpp"
namespace ESM
{
void Filter::load(ESMReader& esm, bool& isDeleted)
{
isDeleted = false;
mRecordFlags = esm.getRecordFlags();
while (esm.hasMoreSubs())
{
esm.getSubName();
uint32_t name = esm.retSubName().toInt();
switch (name)
{
case SREC_NAME:
mId = esm.getRefId();
break;
case fourCC("FILT"):
mFilter = esm.getHString();
break;
case fourCC("DESC"):
mDescription = esm.getHString();
break;
case SREC_DELE:
esm.skipHSub();
isDeleted = true;
break;
default:
esm.fail("Unknown subrecord");
break;
}
}
}
void Filter::save(ESMWriter& esm, bool isDeleted) const
{
esm.writeHNCRefId("NAME", mId);
if (isDeleted)
{
esm.writeHNString("DELE", "", 3);
return;
}
esm.writeHNCString("FILT", mFilter);
esm.writeHNCString("DESC", mDescription);
}
void Filter::blank()
{
mRecordFlags = 0;
mFilter.clear();
mDescription.clear();
}
}
| 1,430
|
C++
|
.cpp
| 52
| 16.096154
| 59
| 0.461651
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,578
|
readerscache.cpp
|
OpenMW_openmw/components/esm3/readerscache.cpp
|
#include "readerscache.hpp"
#include <stdexcept>
namespace ESM
{
ReadersCache::BusyItem::BusyItem(ReadersCache& owner, std::list<Item>::iterator item) noexcept
: mOwner(owner)
, mItem(item)
{
}
ReadersCache::BusyItem::~BusyItem() noexcept
{
mOwner.releaseItem(mItem);
}
ReadersCache::ReadersCache(std::size_t capacity)
: mCapacity(capacity)
{
}
ReadersCache::BusyItem ReadersCache::get(std::size_t index)
{
const auto indexIt = mIndex.find(index);
std::list<Item>::iterator it;
if (indexIt == mIndex.end())
{
closeExtraReaders();
it = mBusyItems.emplace(mBusyItems.end());
mIndex.emplace(index, it);
}
else
{
switch (indexIt->second->mState)
{
case State::Busy:
throw std::logic_error("ESMReader at index " + std::to_string(index) + " is busy");
case State::Free:
it = indexIt->second;
mBusyItems.splice(mBusyItems.end(), mFreeItems, it);
break;
case State::Closed:
closeExtraReaders();
it = indexIt->second;
if (it->mName.has_value())
{
it->mReader.open(*it->mName);
it->mName.reset();
}
mBusyItems.splice(mBusyItems.end(), mClosedItems, it);
break;
}
it->mState = State::Busy;
}
return BusyItem(*this, it);
}
void ReadersCache::closeExtraReaders()
{
while (!mFreeItems.empty() && mBusyItems.size() + mFreeItems.size() + 1 > mCapacity)
{
const auto it = mFreeItems.begin();
if (it->mReader.isOpen())
{
it->mName = it->mReader.getName();
it->mReader.close();
}
mClosedItems.splice(mClosedItems.end(), mFreeItems, it);
it->mState = State::Closed;
}
}
void ReadersCache::releaseItem(std::list<Item>::iterator it) noexcept
{
assert(it->mState == State::Busy);
if (it->mReader.isOpen())
{
mFreeItems.splice(mFreeItems.end(), mBusyItems, it);
it->mState = State::Free;
}
else
{
mClosedItems.splice(mClosedItems.end(), mBusyItems, it);
it->mState = State::Closed;
}
}
void ReadersCache::clear()
{
mIndex.clear();
mBusyItems.clear();
mFreeItems.clear();
mClosedItems.clear();
}
}
| 2,734
|
C++
|
.cpp
| 88
| 20.284091
| 103
| 0.507016
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,579
|
loadmisc.cpp
|
OpenMW_openmw/components/esm3/loadmisc.cpp
|
#include "loadmisc.hpp"
#include "esmreader.hpp"
#include "esmwriter.hpp"
#include <components/misc/concepts.hpp>
namespace ESM
{
template <Misc::SameAsWithoutCvref<Miscellaneous::MCDTstruct> T>
void decompose(T&& v, const auto& f)
{
f(v.mWeight, v.mValue, v.mFlags);
}
void Miscellaneous::load(ESMReader& esm, bool& isDeleted)
{
isDeleted = false;
mRecordFlags = esm.getRecordFlags();
bool hasName = false;
bool hasData = false;
while (esm.hasMoreSubs())
{
esm.getSubName();
switch (esm.retSubName().toInt())
{
case SREC_NAME:
mId = esm.getRefId();
hasName = true;
break;
case fourCC("MODL"):
mModel = esm.getHString();
break;
case fourCC("FNAM"):
mName = esm.getHString();
break;
case fourCC("MCDT"):
esm.getSubComposite(mData);
hasData = true;
break;
case fourCC("SCRI"):
mScript = esm.getRefId();
break;
case fourCC("ITEX"):
mIcon = esm.getHString();
break;
case SREC_DELE:
esm.skipHSub();
isDeleted = true;
break;
default:
esm.fail("Unknown subrecord");
break;
}
}
if (!hasName)
esm.fail("Missing NAME subrecord");
if (!hasData && !isDeleted)
esm.fail("Missing MCDT subrecord");
}
void Miscellaneous::save(ESMWriter& esm, bool isDeleted) const
{
esm.writeHNCRefId("NAME", mId);
if (isDeleted)
{
esm.writeHNString("DELE", "", 3);
return;
}
esm.writeHNCString("MODL", mModel);
esm.writeHNOCString("FNAM", mName);
esm.writeNamedComposite("MCDT", mData);
esm.writeHNOCRefId("SCRI", mScript);
esm.writeHNOCString("ITEX", mIcon);
}
void Miscellaneous::blank()
{
mRecordFlags = 0;
mData.mWeight = 0;
mData.mValue = 0;
mData.mFlags = 0;
mName.clear();
mModel.clear();
mIcon.clear();
mScript = ESM::RefId();
}
}
| 2,490
|
C++
|
.cpp
| 82
| 18.609756
| 68
| 0.479566
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,580
|
loadskil.cpp
|
OpenMW_openmw/components/esm3/loadskil.cpp
|
#include "loadskil.hpp"
#include "esmreader.hpp"
#include "esmwriter.hpp"
#include <components/misc/concepts.hpp>
#include <components/misc/strings/algorithm.hpp>
#include <cstdint>
namespace ESM
{
const SkillId Skill::Block("Block");
const SkillId Skill::Armorer("Armorer");
const SkillId Skill::MediumArmor("MediumArmor");
const SkillId Skill::HeavyArmor("HeavyArmor");
const SkillId Skill::BluntWeapon("BluntWeapon");
const SkillId Skill::LongBlade("LongBlade");
const SkillId Skill::Axe("Axe");
const SkillId Skill::Spear("Spear");
const SkillId Skill::Athletics("Athletics");
const SkillId Skill::Enchant("Enchant");
const SkillId Skill::Destruction("Destruction");
const SkillId Skill::Alteration("Alteration");
const SkillId Skill::Illusion("Illusion");
const SkillId Skill::Conjuration("Conjuration");
const SkillId Skill::Mysticism("Mysticism");
const SkillId Skill::Restoration("Restoration");
const SkillId Skill::Alchemy("Alchemy");
const SkillId Skill::Unarmored("Unarmored");
const SkillId Skill::Security("Security");
const SkillId Skill::Sneak("Sneak");
const SkillId Skill::Acrobatics("Acrobatics");
const SkillId Skill::LightArmor("LightArmor");
const SkillId Skill::ShortBlade("ShortBlade");
const SkillId Skill::Marksman("Marksman");
const SkillId Skill::Mercantile("Mercantile");
const SkillId Skill::Speechcraft("Speechcraft");
const SkillId Skill::HandToHand("HandToHand");
template <Misc::SameAsWithoutCvref<Skill::SKDTstruct> T>
void decompose(T&& v, const auto& f)
{
f(v.mAttribute, v.mSpecialization, v.mUseValue);
}
void Skill::load(ESMReader& esm, bool& isDeleted)
{
isDeleted = false; // Skill record can't be deleted now (may be changed in the future)
mRecordFlags = esm.getRecordFlags();
bool hasIndex = false;
bool hasData = false;
int32_t index = -1;
while (esm.hasMoreSubs())
{
esm.getSubName();
switch (esm.retSubName().toInt())
{
case fourCC("INDX"):
esm.getHT(index);
hasIndex = true;
break;
case fourCC("SKDT"):
esm.getSubComposite(mData);
hasData = true;
break;
case fourCC("DESC"):
mDescription = esm.getHString();
break;
default:
esm.fail("Unknown subrecord");
}
}
if (!hasIndex)
esm.fail("Missing INDX");
else if (index < 0 || index >= Length)
esm.fail("Invalid INDX");
if (!hasData)
esm.fail("Missing SKDT");
mId = *indexToRefId(index).getIf<SkillId>();
}
void Skill::save(ESMWriter& esm, bool /*isDeleted*/) const
{
esm.writeHNT("INDX", refIdToIndex(mId));
esm.writeNamedComposite("SKDT", mData);
esm.writeHNOString("DESC", mDescription);
}
void Skill::blank()
{
mRecordFlags = 0;
mData.mAttribute = 0;
mData.mSpecialization = 0;
mData.mUseValue[0] = mData.mUseValue[1] = mData.mUseValue[2] = mData.mUseValue[3] = 1.0;
mDescription.clear();
}
static const RefId sSkills[Skill::Length] = {
Skill::Block,
Skill::Armorer,
Skill::MediumArmor,
Skill::HeavyArmor,
Skill::BluntWeapon,
Skill::LongBlade,
Skill::Axe,
Skill::Spear,
Skill::Athletics,
Skill::Enchant,
Skill::Destruction,
Skill::Alteration,
Skill::Illusion,
Skill::Conjuration,
Skill::Mysticism,
Skill::Restoration,
Skill::Alchemy,
Skill::Unarmored,
Skill::Security,
Skill::Sneak,
Skill::Acrobatics,
Skill::LightArmor,
Skill::ShortBlade,
Skill::Marksman,
Skill::Mercantile,
Skill::Speechcraft,
Skill::HandToHand,
};
RefId Skill::indexToRefId(int index)
{
if (index < 0 || index >= Length)
return RefId();
return sSkills[index];
}
int Skill::refIdToIndex(RefId id)
{
for (int i = 0; i < Length; ++i)
{
if (sSkills[i] == id)
return i;
}
return -1;
}
const std::array<RefId, MagicSchool::Length> sMagicSchools = {
Skill::Alteration,
Skill::Conjuration,
Skill::Destruction,
Skill::Illusion,
Skill::Mysticism,
Skill::Restoration,
};
RefId MagicSchool::indexToSkillRefId(int index)
{
if (index < 0 || index >= Length)
return {};
return sMagicSchools[index];
}
int MagicSchool::skillRefIdToIndex(RefId id)
{
for (size_t i = 0; i < sMagicSchools.size(); ++i)
{
if (id == sMagicSchools[i])
return static_cast<int>(i);
}
return -1;
}
}
| 5,101
|
C++
|
.cpp
| 157
| 24
| 96
| 0.587256
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,581
|
aipackage.cpp
|
OpenMW_openmw/components/esm3/aipackage.cpp
|
#include "aipackage.hpp"
#include "esmreader.hpp"
#include "esmwriter.hpp"
namespace ESM
{
template <Misc::SameAsWithoutCvref<AIWander> T>
void decompose(T&& v, const auto& f)
{
f(v.mDistance, v.mDuration, v.mTimeOfDay, v.mIdle, v.mShouldRepeat);
}
template <Misc::SameAsWithoutCvref<AITravel> T>
void decompose(T&& v, const auto& f)
{
char padding[3] = { 0, 0, 0 };
f(v.mX, v.mY, v.mZ, v.mShouldRepeat, padding);
}
template <Misc::SameAsWithoutCvref<AITarget> T>
void decompose(T&& v, const auto& f)
{
char padding = 0;
f(v.mX, v.mY, v.mZ, v.mDuration, v.mId.mData, v.mShouldRepeat, padding);
}
template <Misc::SameAsWithoutCvref<AIActivate> T>
void decompose(T&& v, const auto& f)
{
f(v.mName.mData, v.mShouldRepeat);
}
void AIData::blank()
{
mHello = mFight = mFlee = mAlarm = 0;
mServices = 0;
}
void AIPackageList::add(ESMReader& esm)
{
AIPackage pack;
if (esm.retSubName() == AI_CNDT)
{
if (mList.empty())
{
esm.fail("AIPackge with an AI_CNDT applying to no cell.");
}
else
{
mList.back().mCellName = esm.getHString();
}
}
else if (esm.retSubName() == AI_Wander)
{
pack.mType = AI_Wander;
esm.getSubComposite(pack.mWander);
mList.push_back(pack);
}
else if (esm.retSubName() == AI_Travel)
{
pack.mType = AI_Travel;
esm.getSubComposite(pack.mTravel);
mList.push_back(pack);
}
else if (esm.retSubName() == AI_Escort || esm.retSubName() == AI_Follow)
{
pack.mType = (esm.retSubName() == AI_Escort) ? AI_Escort : AI_Follow;
esm.getSubComposite(pack.mTarget);
mList.push_back(pack);
}
else if (esm.retSubName() == AI_Activate)
{
pack.mType = AI_Activate;
esm.getSubComposite(pack.mActivate);
mList.push_back(pack);
}
}
void AIPackageList::save(ESMWriter& esm) const
{
for (const AIPackage& package : mList)
{
switch (package.mType)
{
case AI_Wander:
esm.writeNamedComposite("AI_W", package.mWander);
break;
case AI_Travel:
esm.writeNamedComposite("AI_T", package.mTravel);
break;
case AI_Activate:
esm.writeNamedComposite("AI_A", package.mActivate);
break;
case AI_Escort:
case AI_Follow:
{
const NAME name = (package.mType == AI_Escort) ? NAME("AI_E") : NAME("AI_F");
esm.writeNamedComposite(name, package.mTarget);
esm.writeHNOCString("CNDT", package.mCellName);
break;
}
default:
break;
}
}
}
}
| 3,159
|
C++
|
.cpp
| 100
| 20.99
| 97
| 0.510994
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,582
|
player.cpp
|
OpenMW_openmw/components/esm3/player.cpp
|
#include "player.hpp"
#include "esmreader.hpp"
#include "esmwriter.hpp"
namespace ESM
{
void Player::load(ESMReader& esm)
{
mObject.mRef.loadId(esm, true);
mObject.load(esm);
mCellId = esm.getCellId();
esm.getHNT("LKEP", mLastKnownExteriorPosition);
mHasMark = esm.getOptionalComposite("MARK", mMarkedPosition);
if (mHasMark)
mMarkedCell = esm.getCellId();
// Automove, no longer used.
if (esm.isNextSub("AMOV"))
esm.skipHSub();
mBirthsign = esm.getHNRefId("SIGN");
mCurrentCrimeId = -1;
esm.getHNOT(mCurrentCrimeId, "CURD");
mPaidCrimeId = -1;
esm.getHNOT(mPaidCrimeId, "PAYD");
while (esm.peekNextSub("BOUN"))
{
ESM::RefId boundItemId = esm.getHNRefId("BOUN");
ESM::RefId prevItemId = esm.getHNRefId("PREV");
mPreviousItems[boundItemId] = prevItemId;
}
if (esm.getFormatVersion() <= MaxOldSkillsAndAttributesFormatVersion)
{
const bool intFallback = esm.getFormatVersion() <= MaxIntFallbackFormatVersion;
const bool clearModified
= esm.getFormatVersion() <= MaxClearModifiersFormatVersion && !mObject.mNpcStats.mIsWerewolf;
if (esm.hasMoreSubs())
{
for (size_t i = 0; i < std::size(mSaveAttributes); ++i)
{
StatState<float> attribute;
attribute.load(esm, intFallback);
if (clearModified)
attribute.mMod = 0.f;
mSaveAttributes[i] = attribute.mBase + attribute.mMod - attribute.mDamage;
if (mObject.mNpcStats.mIsWerewolf)
mObject.mCreatureStats.mAttributes[i] = attribute;
}
for (size_t i = 0; i < std::size(mSaveSkills); ++i)
{
StatState<float> skill;
skill.load(esm, intFallback);
if (clearModified)
skill.mMod = 0.f;
mSaveSkills[i] = skill.mBase + skill.mMod - skill.mDamage;
if (mObject.mNpcStats.mIsWerewolf)
{
constexpr int Acrobatics = 20;
if (i == Acrobatics)
mSetWerewolfAcrobatics = mObject.mNpcStats.mSkills[i].mBase != skill.mBase;
mObject.mNpcStats.mSkills[i] = skill;
}
}
}
}
else
{
mSetWerewolfAcrobatics = false;
esm.getHNT(mSaveAttributes, "WWAT");
esm.getHNT(mSaveSkills, "WWSK");
}
}
void Player::save(ESMWriter& esm) const
{
mObject.save(esm);
esm.writeCellId(mCellId);
esm.writeHNT("LKEP", mLastKnownExteriorPosition);
if (mHasMark)
{
esm.writeNamedComposite("MARK", mMarkedPosition);
esm.writeCellId(mMarkedCell);
}
esm.writeHNRefId("SIGN", mBirthsign);
esm.writeHNT("CURD", mCurrentCrimeId);
esm.writeHNT("PAYD", mPaidCrimeId);
for (const auto& [bound, prev] : mPreviousItems)
{
esm.writeHNRefId("BOUN", bound);
esm.writeHNRefId("PREV", prev);
}
esm.writeHNT("WWAT", mSaveAttributes);
esm.writeHNT("WWSK", mSaveSkills);
}
}
| 3,508
|
C++
|
.cpp
| 91
| 25.89011
| 109
| 0.538869
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,583
|
containerstate.cpp
|
OpenMW_openmw/components/esm3/containerstate.cpp
|
#include "containerstate.hpp"
namespace ESM
{
void ContainerState::load(ESMReader& esm)
{
ObjectState::load(esm);
mInventory.load(esm);
}
void ContainerState::save(ESMWriter& esm, bool inInventory) const
{
ObjectState::save(esm, inInventory);
mInventory.save(esm);
}
}
| 331
|
C++
|
.cpp
| 14
| 18.214286
| 69
| 0.659164
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| true
| true
| false
|
34,585
|
loadench.cpp
|
OpenMW_openmw/components/esm3/loadench.cpp
|
#include "loadench.hpp"
#include "esmreader.hpp"
#include "esmwriter.hpp"
#include <components/misc/concepts.hpp>
namespace ESM
{
template <Misc::SameAsWithoutCvref<Enchantment::ENDTstruct> T>
void decompose(T&& v, const auto& f)
{
f(v.mType, v.mCost, v.mCharge, v.mFlags);
}
void Enchantment::load(ESMReader& esm, bool& isDeleted)
{
isDeleted = false;
mRecordFlags = esm.getRecordFlags();
mEffects.mList.clear();
bool hasName = false;
bool hasData = false;
while (esm.hasMoreSubs())
{
esm.getSubName();
switch (esm.retSubName().toInt())
{
case SREC_NAME:
mId = esm.getRefId();
hasName = true;
break;
case fourCC("ENDT"):
esm.getSubComposite(mData);
hasData = true;
break;
case fourCC("ENAM"):
mEffects.add(esm);
break;
case SREC_DELE:
esm.skipHSub();
isDeleted = true;
break;
default:
esm.fail("Unknown subrecord");
break;
}
}
if (!hasName)
esm.fail("Missing NAME subrecord");
if (!hasData && !isDeleted)
esm.fail("Missing ENDT subrecord");
}
void Enchantment::save(ESMWriter& esm, bool isDeleted) const
{
esm.writeHNCRefId("NAME", mId);
if (isDeleted)
{
esm.writeHNString("DELE", "", 3);
return;
}
esm.writeNamedComposite("ENDT", mData);
mEffects.save(esm);
}
void Enchantment::blank()
{
mRecordFlags = 0;
mData.mType = 0;
mData.mCost = 0;
mData.mCharge = 0;
mData.mFlags = 0;
mEffects.mList.clear();
}
}
| 1,990
|
C++
|
.cpp
| 69
| 17.942029
| 66
| 0.490576
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,586
|
loadlevlist.cpp
|
OpenMW_openmw/components/esm3/loadlevlist.cpp
|
#include "loadlevlist.hpp"
#include "components/esm/defs.hpp"
#include "esmreader.hpp"
#include "esmwriter.hpp"
namespace ESM
{
void LevelledListBase::load(ESMReader& esm, NAME recName, bool& isDeleted)
{
isDeleted = false;
mRecordFlags = esm.getRecordFlags();
bool hasName = false;
bool hasList = false;
while (esm.hasMoreSubs())
{
esm.getSubName();
switch (esm.retSubName().toInt())
{
case SREC_NAME:
mId = esm.getRefId();
hasName = true;
break;
case fourCC("DATA"):
esm.getHT(mFlags);
break;
case fourCC("NNAM"):
esm.getHT(mChanceNone);
break;
case fourCC("INDX"):
{
uint32_t length = 0;
esm.getHT(length);
mList.resize(length);
// If this levelled list was already loaded by a previous content file,
// we overwrite the list. Merging lists should probably be left to external tools,
// with the limited amount of information there is in the records, all merging methods
// will be flawed in some way. For a proper fix the ESM format would have to be changed
// to actually track list changes instead of including the whole list for every file
// that does something with that list.
for (size_t i = 0; i < mList.size(); i++)
{
LevelItem& li = mList[i];
li.mId = esm.getHNRefId(recName);
esm.getHNT(li.mLevel, "INTV");
}
hasList = true;
break;
}
case SREC_DELE:
esm.skipHSub();
isDeleted = true;
break;
default:
{
if (!hasList)
{
// Original engine ignores rest of the record, even if there are items following
mList.clear();
esm.skipRecord();
}
else
{
esm.fail("Unknown subrecord");
}
break;
}
}
}
if (!hasName)
esm.fail("Missing NAME subrecord");
}
void LevelledListBase::save(ESMWriter& esm, NAME recName, bool isDeleted) const
{
esm.writeHNCRefId("NAME", mId);
if (isDeleted)
{
esm.writeHNString("DELE", "", 3);
return;
}
esm.writeHNT("DATA", mFlags);
esm.writeHNT("NNAM", mChanceNone);
esm.writeHNT("INDX", static_cast<uint32_t>(mList.size()));
for (const auto& item : mList)
{
esm.writeHNCRefId(recName, item.mId);
esm.writeHNT("INTV", item.mLevel);
}
}
void LevelledListBase::blank()
{
mRecordFlags = 0;
mFlags = 0;
mChanceNone = 0;
mList.clear();
}
}
| 3,340
|
C++
|
.cpp
| 95
| 20.694737
| 107
| 0.458565
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,587
|
loadrace.cpp
|
OpenMW_openmw/components/esm3/loadrace.cpp
|
#include "loadrace.hpp"
#include "esmreader.hpp"
#include "esmwriter.hpp"
#include <components/esm/attr.hpp>
namespace ESM
{
int32_t Race::RADTstruct::getAttribute(ESM::RefId attribute, bool male) const
{
int index = ESM::Attribute::refIdToIndex(attribute);
if (index < 0)
return 0;
index *= 2;
if (!male)
index++;
return mAttributeValues[static_cast<size_t>(index)];
}
void Race::RADTstruct::setAttribute(ESM::RefId attribute, bool male, int32_t value)
{
int index = ESM::Attribute::refIdToIndex(attribute);
if (index < 0)
return;
index *= 2;
if (!male)
index++;
mAttributeValues[static_cast<size_t>(index)] = value;
}
void Race::RADTstruct::load(ESMReader& esm)
{
esm.getSubHeader();
for (auto& bonus : mBonus)
{
esm.getT(bonus.mSkill);
esm.getT(bonus.mBonus);
}
esm.getT(mAttributeValues);
esm.getT(mMaleHeight);
esm.getT(mFemaleHeight);
esm.getT(mMaleWeight);
esm.getT(mFemaleWeight);
esm.getT(mFlags);
}
void Race::RADTstruct::save(ESMWriter& esm) const
{
esm.startSubRecord("RADT");
for (const auto& bonus : mBonus)
{
esm.writeT(bonus.mSkill);
esm.writeT(bonus.mBonus);
}
esm.writeT(mAttributeValues);
esm.writeT(mMaleHeight);
esm.writeT(mFemaleHeight);
esm.writeT(mMaleWeight);
esm.writeT(mFemaleWeight);
esm.writeT(mFlags);
esm.endRecord("RADT");
}
void Race::load(ESMReader& esm, bool& isDeleted)
{
isDeleted = false;
mRecordFlags = esm.getRecordFlags();
mPowers.mList.clear();
bool hasName = false;
bool hasData = false;
while (esm.hasMoreSubs())
{
esm.getSubName();
switch (esm.retSubName().toInt())
{
case SREC_NAME:
mId = esm.getRefId();
hasName = true;
break;
case fourCC("FNAM"):
mName = esm.getHString();
break;
case fourCC("RADT"):
mData.load(esm);
hasData = true;
break;
case fourCC("DESC"):
mDescription = esm.getHString();
break;
case fourCC("NPCS"):
mPowers.add(esm);
break;
case SREC_DELE:
esm.skipHSub();
isDeleted = true;
break;
default:
esm.fail("Unknown subrecord");
}
}
if (!hasName)
esm.fail("Missing NAME subrecord");
if (!hasData && !isDeleted)
esm.fail("Missing RADT subrecord");
}
void Race::save(ESMWriter& esm, bool isDeleted) const
{
esm.writeHNCRefId("NAME", mId);
if (isDeleted)
{
esm.writeHNString("DELE", "", 3);
return;
}
esm.writeHNOCString("FNAM", mName);
mData.save(esm);
mPowers.save(esm);
esm.writeHNOString("DESC", mDescription);
}
void Race::blank()
{
mRecordFlags = 0;
mName.clear();
mDescription.clear();
mPowers.mList.clear();
for (auto& bonus : mData.mBonus)
{
bonus.mSkill = -1;
bonus.mBonus = 0;
}
mData.mAttributeValues.fill(1);
mData.mMaleHeight = mData.mFemaleHeight = 1;
mData.mMaleWeight = mData.mFemaleWeight = 1;
mData.mFlags = 0;
}
}
| 3,825
|
C++
|
.cpp
| 129
| 19.116279
| 87
| 0.510332
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,588
|
loadligh.cpp
|
OpenMW_openmw/components/esm3/loadligh.cpp
|
#include "loadligh.hpp"
#include "esmreader.hpp"
#include "esmwriter.hpp"
#include <components/misc/concepts.hpp>
namespace ESM
{
template <Misc::SameAsWithoutCvref<Light::LHDTstruct> T>
void decompose(T&& v, const auto& f)
{
f(v.mWeight, v.mValue, v.mTime, v.mRadius, v.mColor, v.mFlags);
}
void Light::load(ESMReader& esm, bool& isDeleted)
{
isDeleted = false;
mRecordFlags = esm.getRecordFlags();
bool hasName = false;
bool hasData = false;
while (esm.hasMoreSubs())
{
esm.getSubName();
switch (esm.retSubName().toInt())
{
case SREC_NAME:
mId = esm.getRefId();
hasName = true;
break;
case fourCC("MODL"):
mModel = esm.getHString();
break;
case fourCC("FNAM"):
mName = esm.getHString();
break;
case fourCC("ITEX"):
mIcon = esm.getHString();
break;
case fourCC("LHDT"):
esm.getSubComposite(mData);
hasData = true;
break;
case fourCC("SCRI"):
mScript = esm.getRefId();
break;
case fourCC("SNAM"):
mSound = esm.getRefId();
break;
case SREC_DELE:
esm.skipHSub();
isDeleted = true;
break;
default:
esm.fail("Unknown subrecord");
break;
}
}
if (!hasName)
esm.fail("Missing NAME subrecord");
if (!hasData && !isDeleted)
esm.fail("Missing LHDT subrecord");
}
void Light::save(ESMWriter& esm, bool isDeleted) const
{
esm.writeHNCRefId("NAME", mId);
if (isDeleted)
{
esm.writeHNString("DELE", "", 3);
return;
}
esm.writeHNCString("MODL", mModel);
esm.writeHNOCString("FNAM", mName);
esm.writeHNOCString("ITEX", mIcon);
esm.writeNamedComposite("LHDT", mData);
esm.writeHNOCRefId("SCRI", mScript);
esm.writeHNOCRefId("SNAM", mSound);
}
void Light::blank()
{
mRecordFlags = 0;
mData.mWeight = 0;
mData.mValue = 0;
mData.mTime = 0;
mData.mRadius = 0;
mData.mColor = 0;
mData.mFlags = 0;
mSound = ESM::RefId();
mScript = ESM::RefId();
mModel.clear();
mIcon.clear();
mName.clear();
}
}
| 2,749
|
C++
|
.cpp
| 90
| 18.688889
| 71
| 0.472453
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,589
|
loadclas.cpp
|
OpenMW_openmw/components/esm3/loadclas.cpp
|
#include "loadclas.hpp"
#include <stdexcept>
#include <components/esm/defs.hpp>
#include <components/misc/concepts.hpp>
#include "esmreader.hpp"
#include "esmwriter.hpp"
namespace ESM
{
const std::string_view Class::sGmstSpecializationIds[3]
= { "sSpecializationCombat", "sSpecializationMagic", "sSpecializationStealth" };
const std::array<std::string_view, 3> Class::specializationIndexToLuaId = { "combat", "magic", "stealth" };
template <Misc::SameAsWithoutCvref<Class::CLDTstruct> T>
void decompose(T&& v, const auto& f)
{
f(v.mAttribute, v.mSpecialization, v.mSkills, v.mIsPlayable, v.mServices);
}
int32_t& Class::CLDTstruct::getSkill(int index, bool major)
{
return mSkills.at(index)[major ? 1 : 0];
}
int32_t Class::CLDTstruct::getSkill(int index, bool major) const
{
return mSkills.at(index)[major ? 1 : 0];
}
void Class::load(ESMReader& esm, bool& isDeleted)
{
isDeleted = false;
mRecordFlags = esm.getRecordFlags();
bool hasName = false;
bool hasData = false;
while (esm.hasMoreSubs())
{
esm.getSubName();
switch (esm.retSubName().toInt())
{
case SREC_NAME:
mId = esm.getRefId();
hasName = true;
break;
case fourCC("FNAM"):
mName = esm.getHString();
break;
case fourCC("CLDT"):
esm.getSubComposite(mData);
if (mData.mIsPlayable > 1)
esm.fail("Unknown bool value");
hasData = true;
break;
case fourCC("DESC"):
mDescription = esm.getHString();
break;
case SREC_DELE:
esm.skipHSub();
isDeleted = true;
break;
default:
esm.fail("Unknown subrecord");
break;
}
}
if (!hasName)
esm.fail("Missing NAME subrecord");
if (!hasData && !isDeleted)
esm.fail("Missing CLDT subrecord");
}
void Class::save(ESMWriter& esm, bool isDeleted) const
{
esm.writeHNCRefId("NAME", mId);
if (isDeleted)
{
esm.writeHNString("DELE", "", 3);
return;
}
esm.writeHNOCString("FNAM", mName);
esm.writeNamedComposite("CLDT", mData);
esm.writeHNOString("DESC", mDescription);
}
void Class::blank()
{
mRecordFlags = 0;
mName.clear();
mDescription.clear();
mData.mAttribute.fill(0);
mData.mSpecialization = 0;
mData.mIsPlayable = 0;
mData.mServices = 0;
for (auto& skills : mData.mSkills)
skills.fill(0);
}
}
| 2,954
|
C++
|
.cpp
| 90
| 22.144444
| 111
| 0.530011
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,590
|
variant.cpp
|
OpenMW_openmw/components/esm3/variant.cpp
|
#include "variant.hpp"
#include <stdexcept>
#include "esmreader.hpp"
#include "variantimp.hpp"
namespace ESM
{
namespace
{
constexpr uint32_t STRV = fourCC("STRV");
constexpr uint32_t INTV = fourCC("INTV");
constexpr uint32_t FLTV = fourCC("FLTV");
constexpr uint32_t STTV = fourCC("STTV");
template <typename T, bool orDefault = false>
struct GetValue
{
constexpr T operator()(int32_t value) const { return static_cast<T>(value); }
constexpr T operator()(float value) const { return static_cast<T>(value); }
template <typename V>
constexpr T operator()(const V&) const
{
if constexpr (orDefault)
return T{};
else
throw std::runtime_error("cannot convert variant");
}
};
template <typename T>
struct SetValue
{
T mValue;
explicit SetValue(T value)
: mValue(value)
{
}
void operator()(int32_t& value) const { value = static_cast<int32_t>(mValue); }
void operator()(float& value) const { value = static_cast<float>(mValue); }
template <typename V>
void operator()(V&) const
{
throw std::runtime_error("cannot convert variant");
}
};
}
const std::string& Variant::getString() const
{
return std::get<std::string>(mData);
}
int32_t Variant::getInteger() const
{
return std::visit(GetValue<int32_t>{}, mData);
}
float Variant::getFloat() const
{
return std::visit(GetValue<float>{}, mData);
}
void Variant::read(ESMReader& esm, Format format)
{
// type
VarType type = VT_Unknown;
if (format == Format_Global)
{
std::string typeId = esm.getHNString("FNAM");
if (typeId == "s")
type = VT_Short;
else if (typeId == "l")
type = VT_Long;
else if (typeId == "f")
type = VT_Float;
else
esm.fail("illegal global variable type " + typeId);
}
else if (format == Format_Gmst)
{
if (!esm.hasMoreSubs())
{
type = VT_None;
}
else
{
esm.getSubName();
NAME name = esm.retSubName();
if (name == STRV)
{
type = VT_String;
}
else if (name == INTV)
{
type = VT_Int;
}
else if (name == FLTV)
{
type = VT_Float;
}
else
esm.fail("invalid subrecord: " + name.toString());
}
}
else if (format == Format_Info)
{
esm.getSubName();
NAME name = esm.retSubName();
if (name == INTV)
{
type = VT_Int;
}
else if (name == FLTV)
{
type = VT_Float;
}
else
esm.fail("invalid subrecord: " + name.toString());
}
else if (format == Format_Local)
{
esm.getSubName();
NAME name = esm.retSubName();
if (name == INTV)
{
type = VT_Int;
}
else if (name == FLTV)
{
type = VT_Float;
}
else if (name == STTV)
{
type = VT_Short;
}
else
esm.fail("invalid subrecord: " + name.toString());
}
setType(type);
std::visit(ReadESMVariantValue{ esm, format, mType }, mData);
}
void Variant::write(ESMWriter& esm, Format format) const
{
if (mType == VT_Unknown)
{
throw std::runtime_error("can not serialise variant of unknown type");
}
else if (mType == VT_None)
{
if (format == Format_Global)
throw std::runtime_error("can not serialise variant of type none to global format");
if (format == Format_Info)
throw std::runtime_error("can not serialise variant of type none to info format");
if (format == Format_Local)
throw std::runtime_error("can not serialise variant of type none to local format");
// nothing to do here for GMST format
}
else
std::visit(WriteESMVariantValue{ esm, format, mType }, mData);
}
void Variant::write(std::ostream& stream) const
{
switch (mType)
{
case VT_Unknown:
stream << "variant unknown";
break;
case VT_None:
stream << "variant none";
break;
case VT_Short:
stream << "variant short: " << std::get<int32_t>(mData);
break;
case VT_Int:
stream << "variant int: " << std::get<int32_t>(mData);
break;
case VT_Long:
stream << "variant long: " << std::get<int32_t>(mData);
break;
case VT_Float:
stream << "variant float: " << std::get<float>(mData);
break;
case VT_String:
stream << "variant string: \"" << std::get<std::string>(mData) << "\"";
break;
}
}
void Variant::setType(VarType type)
{
if (type != mType)
{
switch (type)
{
case VT_Unknown:
case VT_None:
mData = std::monostate{};
break;
case VT_Short:
case VT_Int:
case VT_Long:
mData = std::visit(GetValue<int, true>{}, mData);
break;
case VT_Float:
mData = std::visit(GetValue<float, true>{}, mData);
break;
case VT_String:
mData = std::string{};
break;
}
mType = type;
}
}
void Variant::setString(const std::string& value)
{
std::get<std::string>(mData) = value;
}
void Variant::setString(std::string&& value)
{
std::get<std::string>(mData) = std::move(value);
}
void Variant::setInteger(int32_t value)
{
std::visit(SetValue(value), mData);
}
void Variant::setFloat(float value)
{
std::visit(SetValue(value), mData);
}
std::ostream& operator<<(std::ostream& stream, const Variant& value)
{
value.write(stream);
return stream;
}
}
| 7,055
|
C++
|
.cpp
| 227
| 19.070485
| 100
| 0.459643
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,591
|
queststate.cpp
|
OpenMW_openmw/components/esm3/queststate.cpp
|
#include "queststate.hpp"
#include "esmreader.hpp"
#include "esmwriter.hpp"
namespace ESM
{
void QuestState::load(ESMReader& esm)
{
mTopic = esm.getHNRefId("YETO");
esm.getHNOT(mState, "QSTA");
esm.getHNOT(mFinished, "QFIN");
}
void QuestState::save(ESMWriter& esm) const
{
esm.writeHNRefId("YETO", mTopic);
esm.writeHNT("QSTA", mState);
esm.writeHNT("QFIN", mFinished);
}
}
| 452
|
C++
|
.cpp
| 18
| 19.833333
| 47
| 0.631702
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| true
| true
| false
|
34,592
|
loadglob.cpp
|
OpenMW_openmw/components/esm3/loadglob.cpp
|
#include "loadglob.hpp"
#include "esmreader.hpp"
#include "esmwriter.hpp"
namespace ESM
{
void Global::load(ESMReader& esm, bool& isDeleted)
{
isDeleted = false;
mRecordFlags = esm.getRecordFlags();
mId = esm.getHNRefId("NAME");
if (esm.isNextSub("DELE"))
{
esm.skipHSub();
isDeleted = true;
}
else
{
mValue.read(esm, Variant::Format_Global);
}
}
void Global::save(ESMWriter& esm, bool isDeleted) const
{
esm.writeHNCRefId("NAME", mId);
if (isDeleted)
{
esm.writeHNCString("DELE", "");
}
else
{
mValue.write(esm, Variant::Format_Global);
}
}
void Global::blank()
{
mRecordFlags = 0;
mValue.setType(VT_None);
}
bool operator==(const Global& left, const Global& right)
{
return left.mId == right.mId && left.mValue == right.mValue;
}
}
| 1,002
|
C++
|
.cpp
| 42
| 16.47619
| 68
| 0.542017
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,593
|
loadnpc.cpp
|
OpenMW_openmw/components/esm3/loadnpc.cpp
|
#include "loadnpc.hpp"
#include "esmreader.hpp"
#include "esmwriter.hpp"
#include <components/misc/concepts.hpp>
namespace ESM
{
namespace
{
struct NPDTstruct12
{
NPC::NPDTstruct52& mStruct;
};
}
template <Misc::SameAsWithoutCvref<NPC::NPDTstruct52> T>
void decompose(T&& v, const auto& f)
{
char padding1 = 0;
char padding2 = 0;
f(v.mLevel, v.mAttributes, v.mSkills, padding1, v.mHealth, v.mMana, v.mFatigue, v.mDisposition, v.mReputation,
v.mRank, padding2, v.mGold);
}
template <Misc::SameAsWithoutCvref<NPDTstruct12> T>
void decompose(T&& v, const auto& f)
{
char padding[] = { 0, 0, 0 };
f(v.mStruct.mLevel, v.mStruct.mDisposition, v.mStruct.mReputation, v.mStruct.mRank, padding, v.mStruct.mGold);
}
void NPC::load(ESMReader& esm, bool& isDeleted)
{
isDeleted = false;
mRecordFlags = esm.getRecordFlags();
mSpells.mList.clear();
mInventory.mList.clear();
mTransport.mList.clear();
mAiPackage.mList.clear();
mAiData.blank();
mAiData.mHello = mAiData.mFight = mAiData.mFlee = 30;
bool hasName = false;
bool hasNpdt = false;
bool hasFlags = false;
while (esm.hasMoreSubs())
{
esm.getSubName();
switch (esm.retSubName().toInt())
{
case SREC_NAME:
mId = esm.getRefId();
hasName = true;
break;
case fourCC("MODL"):
mModel = esm.getHString();
break;
case fourCC("FNAM"):
mName = esm.getHString();
break;
case fourCC("RNAM"):
mRace = esm.getRefId();
break;
case fourCC("CNAM"):
mClass = esm.getRefId();
break;
case fourCC("ANAM"):
mFaction = esm.getRefId();
break;
case fourCC("BNAM"):
mHead = esm.getRefId();
break;
case fourCC("KNAM"):
mHair = esm.getRefId();
break;
case fourCC("SCRI"):
mScript = esm.getRefId();
break;
case fourCC("NPDT"):
hasNpdt = true;
esm.getSubHeader();
if (esm.getSubSize() == getCompositeSize(mNpdt))
{
mNpdtType = NPC_DEFAULT;
esm.getComposite(mNpdt);
}
else
{
NPDTstruct12 data{ mNpdt };
if (esm.getSubSize() == getCompositeSize(data))
{
mNpdtType = NPC_WITH_AUTOCALCULATED_STATS;
// Clearing the mNdpt struct to initialize all values
blankNpdt();
esm.getComposite(data);
}
else
esm.fail("NPC_NPDT must be 12 or 52 bytes long");
}
break;
case fourCC("FLAG"):
hasFlags = true;
int32_t flags;
esm.getHT(flags);
mFlags = flags & 0xFF;
mBloodType = ((flags >> 8) & 0xFF) >> 2;
break;
case fourCC("NPCS"):
mSpells.add(esm);
break;
case fourCC("NPCO"):
mInventory.add(esm);
break;
case fourCC("AIDT"):
esm.getSubComposite(mAiData);
break;
case fourCC("DODT"):
case fourCC("DNAM"):
mTransport.add(esm);
break;
case AI_Wander:
case AI_Activate:
case AI_Escort:
case AI_Follow:
case AI_Travel:
case AI_CNDT:
mAiPackage.add(esm);
break;
case SREC_DELE:
esm.skipHSub();
isDeleted = true;
break;
default:
esm.fail("Unknown subrecord");
break;
}
}
if (!hasName)
esm.fail("Missing NAME subrecord");
if (!hasNpdt && !isDeleted)
esm.fail("Missing NPDT subrecord");
if (!hasFlags && !isDeleted)
esm.fail("Missing FLAG subrecord");
}
void NPC::save(ESMWriter& esm, bool isDeleted) const
{
esm.writeHNCRefId("NAME", mId);
if (isDeleted)
{
esm.writeHNString("DELE", "", 3);
return;
}
esm.writeHNOCString("MODL", mModel);
esm.writeHNOCString("FNAM", mName);
esm.writeHNCRefId("RNAM", mRace);
esm.writeHNCRefId("CNAM", mClass);
esm.writeHNCRefId("ANAM", mFaction);
esm.writeHNCRefId("BNAM", mHead);
esm.writeHNCRefId("KNAM", mHair);
esm.writeHNOCRefId("SCRI", mScript);
if (mNpdtType == NPC_DEFAULT)
{
esm.writeNamedComposite("NPDT", mNpdt);
}
else if (mNpdtType == NPC_WITH_AUTOCALCULATED_STATS)
{
esm.writeNamedComposite("NPDT", NPDTstruct12{ const_cast<NPDTstruct52&>(mNpdt) });
}
esm.writeHNT("FLAG", ((mBloodType << 10) + mFlags));
mInventory.save(esm);
mSpells.save(esm);
esm.writeNamedComposite("AIDT", mAiData);
mTransport.save(esm);
mAiPackage.save(esm);
}
bool NPC::isMale() const
{
return (mFlags & Female) == 0;
}
void NPC::setIsMale(bool value)
{
mFlags |= Female;
if (value)
{
mFlags ^= Female;
}
}
void NPC::blank()
{
mRecordFlags = 0;
mNpdtType = NPC_DEFAULT;
blankNpdt();
mBloodType = 0;
mFlags = 0;
mInventory.mList.clear();
mSpells.mList.clear();
mAiData.blank();
mAiData.mHello = mAiData.mFight = mAiData.mFlee = 30;
mTransport.mList.clear();
mAiPackage.mList.clear();
mName.clear();
mModel.clear();
mRace = ESM::RefId();
mClass = ESM::RefId();
mFaction = ESM::RefId();
mScript = ESM::RefId();
mHair = ESM::RefId();
mHead = ESM::RefId();
}
void NPC::blankNpdt()
{
mNpdt.mLevel = 0;
mNpdt.mAttributes.fill(0);
mNpdt.mSkills.fill(0);
mNpdt.mReputation = 0;
mNpdt.mHealth = mNpdt.mMana = mNpdt.mFatigue = 0;
mNpdt.mDisposition = 0;
mNpdt.mRank = 0;
mNpdt.mGold = 0;
}
int NPC::getFactionRank() const
{
if (mFaction.empty())
return -1;
else
return mNpdt.mRank;
}
const std::vector<Transport::Dest>& NPC::getTransport() const
{
return mTransport.mList;
}
}
| 7,377
|
C++
|
.cpp
| 227
| 19.60793
| 118
| 0.467237
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,594
|
controlsstate.cpp
|
OpenMW_openmw/components/esm3/controlsstate.cpp
|
#include "controlsstate.hpp"
#include "esmreader.hpp"
#include "esmwriter.hpp"
namespace ESM
{
ControlsState::ControlsState()
: mViewSwitchDisabled(false)
, mControlsDisabled(false)
, mJumpingDisabled(false)
, mLookingDisabled(false)
, mVanityModeDisabled(false)
, mWeaponDrawingDisabled(false)
, mSpellDrawingDisabled(false)
{
}
void ControlsState::load(ESMReader& esm)
{
int flags;
esm.getHNT(flags, "CFLG");
mViewSwitchDisabled = flags & ViewSwitchDisabled;
mControlsDisabled = flags & ControlsDisabled;
mJumpingDisabled = flags & JumpingDisabled;
mLookingDisabled = flags & LookingDisabled;
mVanityModeDisabled = flags & VanityModeDisabled;
mWeaponDrawingDisabled = flags & WeaponDrawingDisabled;
mSpellDrawingDisabled = flags & SpellDrawingDisabled;
}
void ControlsState::save(ESMWriter& esm) const
{
int flags = 0;
if (mViewSwitchDisabled)
flags |= ViewSwitchDisabled;
if (mControlsDisabled)
flags |= ControlsDisabled;
if (mJumpingDisabled)
flags |= JumpingDisabled;
if (mLookingDisabled)
flags |= LookingDisabled;
if (mVanityModeDisabled)
flags |= VanityModeDisabled;
if (mWeaponDrawingDisabled)
flags |= WeaponDrawingDisabled;
if (mSpellDrawingDisabled)
flags |= SpellDrawingDisabled;
esm.writeHNT("CFLG", flags);
}
}
| 1,554
|
C++
|
.cpp
| 47
| 25.085106
| 63
| 0.653769
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,595
|
loadweap.cpp
|
OpenMW_openmw/components/esm3/loadweap.cpp
|
#include "loadweap.hpp"
#include <components/esm/defs.hpp>
#include <components/misc/concepts.hpp>
#include "esmreader.hpp"
#include "esmwriter.hpp"
namespace ESM
{
template <Misc::SameAsWithoutCvref<Weapon::WPDTstruct> T>
void decompose(T&& v, const auto& f)
{
f(v.mWeight, v.mValue, v.mType, v.mHealth, v.mSpeed, v.mReach, v.mEnchant, v.mChop, v.mSlash, v.mThrust,
v.mFlags);
}
void Weapon::load(ESMReader& esm, bool& isDeleted)
{
isDeleted = false;
mRecordFlags = esm.getRecordFlags();
bool hasName = false;
bool hasData = false;
while (esm.hasMoreSubs())
{
esm.getSubName();
switch (esm.retSubName().toInt())
{
case SREC_NAME:
mId = esm.getRefId();
hasName = true;
break;
case fourCC("MODL"):
mModel = esm.getHString();
break;
case fourCC("FNAM"):
mName = esm.getHString();
break;
case fourCC("WPDT"):
esm.getSubComposite(mData);
hasData = true;
break;
case fourCC("SCRI"):
mScript = esm.getRefId();
break;
case fourCC("ITEX"):
mIcon = esm.getHString();
break;
case fourCC("ENAM"):
mEnchant = esm.getRefId();
break;
case SREC_DELE:
esm.skipHSub();
isDeleted = true;
break;
default:
esm.fail("Unknown subrecord");
}
}
if (!hasName)
esm.fail("Missing NAME subrecord");
if (!hasData && !isDeleted)
esm.fail("Missing WPDT subrecord");
}
void Weapon::save(ESMWriter& esm, bool isDeleted) const
{
esm.writeHNCRefId("NAME", mId);
if (isDeleted)
{
esm.writeHNString("DELE", "", 3);
return;
}
esm.writeHNCString("MODL", mModel);
esm.writeHNOCString("FNAM", mName);
esm.writeNamedComposite("WPDT", mData);
esm.writeHNOCRefId("SCRI", mScript);
esm.writeHNOCString("ITEX", mIcon);
esm.writeHNOCRefId("ENAM", mEnchant);
}
void Weapon::blank()
{
mRecordFlags = 0;
mData.mWeight = 0;
mData.mValue = 0;
mData.mType = 0;
mData.mHealth = 0;
mData.mSpeed = 0;
mData.mReach = 0;
mData.mEnchant = 0;
mData.mChop.fill(0);
mData.mSlash.fill(0);
mData.mThrust.fill(0);
mData.mFlags = 0;
mName.clear();
mModel.clear();
mIcon.clear();
mEnchant = ESM::RefId();
mScript = ESM::RefId();
}
}
| 2,976
|
C++
|
.cpp
| 96
| 19.479167
| 112
| 0.486063
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,596
|
validate.cpp
|
OpenMW_openmw/components/fallback/validate.cpp
|
#include "validate.hpp"
#include <boost/any.hpp>
#include <boost/program_options/errors.hpp>
#include <set>
#include <string>
static const std::set<std::string_view> allowedKeysInt = { "LightAttenuation_LinearMethod",
"LightAttenuation_OutQuadInLin", "LightAttenuation_QuadraticMethod", "LightAttenuation_UseConstant",
"LightAttenuation_UseLinear", "LightAttenuation_UseQuadratic", "Water_MaxNumberRipples", "Water_NearWaterRadius",
"Water_NearWaterPoints", "Water_RippleFrameCount", "Water_SurfaceTileCount", "Water_SurfaceFrameCount",
"Weather_Clear_Using_Precip", "Weather_Cloudy_Using_Precip", "Weather_Foggy_Using_Precip",
"Weather_Overcast_Using_Precip", "Weather_Rain_Using_Precip", "Weather_Thunderstorm_Using_Precip",
"Weather_Ashstorm_Using_Precip", "Weather_Blight_Using_Precip", "Weather_Snow_Using_Precip",
"Weather_Blizzard_Using_Precip", "Weather_Rain_Ripples", "Weather_Snow_Ripples", "Weather_Timescale_Clouds" };
static const std::set<std::string_view> allowedKeysFloat = { "General_Werewolf_FOV", "Inventory_DirectionalAmbientB",
"Inventory_DirectionalAmbientG", "Inventory_DirectionalAmbientR", "Inventory_DirectionalDiffuseB",
"Inventory_DirectionalDiffuseG", "Inventory_DirectionalDiffuseR", "Inventory_DirectionalRotationX",
"Inventory_DirectionalRotationY", "LightAttenuation_ConstantValue", "LightAttenuation_LinearValue",
"LightAttenuation_LinearRadiusMult", "LightAttenuation_QuadraticValue", "LightAttenuation_QuadraticRadiusMult",
"Moons_Masser_Axis_Offset", "Moons_Masser_Daily_Increment", "Moons_Masser_Fade_End_Angle",
"Moons_Masser_Fade_In_Finish", "Moons_Masser_Fade_In_Start", "Moons_Masser_Fade_Out_Finish",
"Moons_Masser_Fade_Out_Start", "Moons_Masser_Fade_Start_Angle", "Moons_Masser_Moon_Shadow_Early_Fade_Angle",
"Moons_Masser_Size", "Moons_Masser_Speed", "Moons_Secunda_Axis_Offset", "Moons_Secunda_Daily_Increment",
"Moons_Secunda_Fade_End_Angle", "Moons_Secunda_Fade_In_Finish", "Moons_Secunda_Fade_In_Start",
"Moons_Secunda_Fade_Out_Finish", "Moons_Secunda_Fade_Out_Start", "Moons_Secunda_Fade_Start_Angle",
"Moons_Secunda_Moon_Shadow_Early_Fade_Angle", "Moons_Secunda_Size", "Moons_Secunda_Speed", "Water_World_Alpha",
"Water_Map_Alpha", "Water_NearWaterIndoorTolerance", "Water_NearWaterOutdoorTolerance", "Water_RippleLifetime",
"Water_RippleRotSpeed", "Water_SurfaceFPS", "Water_UnderwaterColorWeight", "Water_UnderwaterDayFog",
"Water_UnderwaterIndoorFog", "Water_UnderwaterNightFog", "Water_UnderwaterSunriseFog", "Water_UnderwaterSunsetFog",
"Weather_Ambient_Post-Sunrise_Time", "Weather_Ambient_Post-Sunset_Time", "Weather_Ambient_Pre-Sunrise_Time",
"Weather_Ambient_Pre-Sunset_Time", "Weather_Ashstorm_Clouds_Maximum_Percent", "Weather_Ashstorm_Cloud_Speed",
"Weather_Ashstorm_Flash_Decrement", "Weather_Ashstorm_Glare_View", "Weather_Ashstorm_Land_Fog_Day_Depth",
"Weather_Ashstorm_Land_Fog_Night_Depth", "Weather_Ashstorm_Max_Raindrops", "Weather_Ashstorm_Rain_Diameter",
"Weather_Ashstorm_Rain_Entrance_Speed", "Weather_Ashstorm_Rain_Height_Max", "Weather_Ashstorm_Rain_Height_Min",
"Weather_Ashstorm_Rain_Threshold", "Weather_Ashstorm_Thunder_Frequency", "Weather_Ashstorm_Thunder_Threshold",
"Weather_Ashstorm_Transition_Delta", "Weather_Ashstorm_Wind_Speed", "Weather_Blight_Clouds_Maximum_Percent",
"Weather_Blight_Cloud_Speed", "Weather_Blight_Flash_Decrement", "Weather_Blight_Glare_View",
"Weather_Blight_Land_Fog_Day_Depth", "Weather_Blight_Land_Fog_Night_Depth", "Weather_Blight_Max_Raindrops",
"Weather_Blight_Rain_Diameter", "Weather_Blight_Rain_Entrance_Speed", "Weather_Blight_Rain_Height_Max",
"Weather_Blight_Rain_Height_Min", "Weather_Blight_Rain_Threshold", "Weather_Blight_Thunder_Frequency",
"Weather_Blight_Thunder_Threshold", "Weather_Blight_Transition_Delta", "Weather_Blight_Wind_Speed",
"Weather_Blizzard_Clouds_Maximum_Percent", "Weather_Blizzard_Cloud_Speed", "Weather_Blizzard_Flash_Decrement",
"Weather_Blizzard_Glare_View", "Weather_Blizzard_Land_Fog_Day_Depth", "Weather_Blizzard_Land_Fog_Night_Depth",
"Weather_Blizzard_Max_Raindrops", "Weather_Blizzard_Rain_Diameter", "Weather_Blizzard_Rain_Entrance_Speed",
"Weather_Blizzard_Rain_Height_Max", "Weather_Blizzard_Rain_Height_Min", "Weather_Blizzard_Rain_Threshold",
"Weather_Blizzard_Thunder_Frequency", "Weather_Blizzard_Thunder_Threshold", "Weather_Blizzard_Transition_Delta",
"Weather_Blizzard_Wind_Speed", "Weather_Clear_Clouds_Maximum_Percent", "Weather_Clear_Cloud_Speed",
"Weather_Clear_Flash_Decrement", "Weather_Clear_Glare_View", "Weather_Clear_Land_Fog_Day_Depth",
"Weather_Clear_Land_Fog_Night_Depth", "Weather_Clear_Max_Raindrops", "Weather_Clear_Rain_Diameter",
"Weather_Clear_Rain_Entrance_Speed", "Weather_Clear_Rain_Height_Max", "Weather_Clear_Rain_Height_Min",
"Weather_Clear_Rain_Threshold", "Weather_Clear_Thunder_Frequency", "Weather_Clear_Thunder_Threshold",
"Weather_Clear_Transition_Delta", "Weather_Clear_Wind_Speed", "Weather_Cloudy_Clouds_Maximum_Percent",
"Weather_Cloudy_Cloud_Speed", "Weather_Cloudy_Flash_Decrement", "Weather_Cloudy_Glare_View",
"Weather_Cloudy_Land_Fog_Day_Depth", "Weather_Cloudy_Land_Fog_Night_Depth", "Weather_Cloudy_Max_Raindrops",
"Weather_Cloudy_Rain_Diameter", "Weather_Cloudy_Rain_Entrance_Speed", "Weather_Cloudy_Rain_Height_Max",
"Weather_Cloudy_Rain_Height_Min", "Weather_Cloudy_Rain_Threshold", "Weather_Cloudy_Thunder_Frequency",
"Weather_Cloudy_Thunder_Threshold", "Weather_Cloudy_Transition_Delta", "Weather_Cloudy_Wind_Speed",
"Weather_Foggy_Clouds_Maximum_Percent", "Weather_Foggy_Cloud_Speed", "Weather_Foggy_Flash_Decrement",
"Weather_Foggy_Glare_View", "Weather_Foggy_Land_Fog_Day_Depth", "Weather_Foggy_Land_Fog_Night_Depth",
"Weather_Foggy_Max_Raindrops", "Weather_Foggy_Rain_Diameter", "Weather_Foggy_Rain_Entrance_Speed",
"Weather_Foggy_Rain_Height_Max", "Weather_Foggy_Rain_Height_Min", "Weather_Foggy_Rain_Threshold",
"Weather_Foggy_Thunder_Frequency", "Weather_Foggy_Thunder_Threshold", "Weather_Foggy_Transition_Delta",
"Weather_Foggy_Wind_Speed", "Weather_Fog_Post-Sunrise_Time", "Weather_Fog_Post-Sunset_Time",
"Weather_Fog_Pre-Sunrise_Time", "Weather_Fog_Pre-Sunset_Time", "Weather_Hours_Between_Weather_Changes",
"Weather_Maximum_Time_Between_Environmental_Sounds", "Weather_Minimum_Time_Between_Environmental_Sounds",
"Weather_Overcast_Clouds_Maximum_Percent", "Weather_Overcast_Cloud_Speed", "Weather_Overcast_Flash_Decrement",
"Weather_Overcast_Glare_View", "Weather_Overcast_Land_Fog_Day_Depth", "Weather_Overcast_Land_Fog_Night_Depth",
"Weather_Overcast_Max_Raindrops", "Weather_Overcast_Rain_Diameter", "Weather_Overcast_Rain_Entrance_Speed",
"Weather_Overcast_Rain_Height_Max", "Weather_Overcast_Rain_Height_Min", "Weather_Overcast_Rain_Threshold",
"Weather_Overcast_Thunder_Frequency", "Weather_Overcast_Thunder_Threshold", "Weather_Overcast_Transition_Delta",
"Weather_Overcast_Wind_Speed", "Weather_Precip_Gravity", "Weather_Rain_Clouds_Maximum_Percent",
"Weather_Rain_Cloud_Speed", "Weather_Rain_Flash_Decrement", "Weather_Rain_Glare_View",
"Weather_Rain_Land_Fog_Day_Depth", "Weather_Rain_Land_Fog_Night_Depth", "Weather_Rain_Max_Raindrops",
"Weather_Rain_Rain_Diameter", "Weather_Rain_Rain_Entrance_Speed", "Weather_Rain_Rain_Height_Max",
"Weather_Rain_Rain_Height_Min", "Weather_Rain_Rain_Threshold", "Weather_Rain_Thunder_Frequency",
"Weather_Rain_Thunder_Threshold", "Weather_Rain_Transition_Delta", "Weather_Rain_Wind_Speed",
"Weather_Sky_Post-Sunrise_Time", "Weather_Sky_Post-Sunset_Time", "Weather_Sky_Pre-Sunrise_Time",
"Weather_Sky_Pre-Sunset_Time", "Weather_Snow_Clouds_Maximum_Percent", "Weather_Snow_Cloud_Speed",
"Weather_Snow_Flash_Decrement", "Weather_Snow_Glare_View", "Weather_Snow_Land_Fog_Day_Depth",
"Weather_Snow_Land_Fog_Night_Depth", "Weather_Snow_Max_Raindrops", "Weather_Snow_Rain_Diameter",
"Weather_Snow_Rain_Entrance_Speed", "Weather_Snow_Rain_Height_Max", "Weather_Snow_Rain_Height_Min",
"Weather_Snow_Rain_Threshold", "Weather_Snow_Thunder_Frequency", "Weather_Snow_Thunder_Threshold",
"Weather_Snow_Transition_Delta", "Weather_Snow_Wind_Speed", "Weather_Stars_Fading_Duration",
"Weather_Stars_Post-Sunset_Start", "Weather_Stars_Pre-Sunrise_Finish", "Weather_Sun_Glare_Fader_Angle_Max",
"Weather_Sun_Glare_Fader_Max", "Weather_Sun_Post-Sunrise_Time", "Weather_Sun_Post-Sunset_Time",
"Weather_Sun_Pre-Sunrise_Time", "Weather_Sun_Pre-Sunset_Time", "Weather_Sunrise_Duration", "Weather_Sunrise_Time",
"Weather_Sunset_Duration", "Weather_Sunset_Time", "Weather_Thunderstorm_Clouds_Maximum_Percent",
"Weather_Thunderstorm_Cloud_Speed", "Weather_Thunderstorm_Flash_Decrement", "Weather_Thunderstorm_Glare_View",
"Weather_Thunderstorm_Land_Fog_Day_Depth", "Weather_Thunderstorm_Land_Fog_Night_Depth",
"Weather_Thunderstorm_Max_Raindrops", "Weather_Thunderstorm_Rain_Diameter",
"Weather_Thunderstorm_Rain_Entrance_Speed", "Weather_Thunderstorm_Rain_Height_Max",
"Weather_Thunderstorm_Rain_Height_Min", "Weather_Thunderstorm_Rain_Threshold",
"Weather_Thunderstorm_Thunder_Frequency", "Weather_Thunderstorm_Thunder_Threshold",
"Weather_Thunderstorm_Transition_Delta", "Weather_Thunderstorm_Wind_Speed" };
static const std::set<std::string_view> allowedKeysNonNumeric = { "Blood_Model_0", "Blood_Model_1", "Blood_Model_2",
"FontColor_color_active", "FontColor_color_active_over", "FontColor_color_active_pressed", "FontColor_color_answer",
"FontColor_color_answer_over", "FontColor_color_answer_pressed", "FontColor_color_background",
"FontColor_color_big_answer", "FontColor_color_big_answer_over", "FontColor_color_big_answer_pressed",
"FontColor_color_big_header", "FontColor_color_big_link", "FontColor_color_big_link_over",
"FontColor_color_big_link_pressed", "FontColor_color_big_normal", "FontColor_color_big_normal_over",
"FontColor_color_big_normal_pressed", "FontColor_color_big_notify", "FontColor_color_count",
"FontColor_color_disabled", "FontColor_color_disabled_over", "FontColor_color_disabled_pressed",
"FontColor_color_fatigue", "FontColor_color_focus", "FontColor_color_header", "FontColor_color_health",
"FontColor_color_journal_link", "FontColor_color_journal_link_over", "FontColor_color_journal_link_pressed",
"FontColor_color_journal_topic", "FontColor_color_journal_topic_over", "FontColor_color_journal_topic_pressed",
"FontColor_color_link", "FontColor_color_link_over", "FontColor_color_link_pressed", "FontColor_color_magic",
"FontColor_color_magic_fill", "FontColor_color_misc", "FontColor_color_negative", "FontColor_color_normal",
"FontColor_color_normal_over", "FontColor_color_normal_pressed", "FontColor_color_notify",
"FontColor_color_positive", "FontColor_color_weapon_fill", "Fonts_Font_0", "Fonts_Font_1", "Fonts_Font_2",
"Level_Up_Default", "Moons_Script_Color", "Movies_Company_Logo", "Movies_Morrowind_Logo", "Movies_New_Game",
"Question_10_AnswerOne", "Question_10_AnswerThree", "Question_10_AnswerTwo", "Question_10_Question",
"Question_10_Sound", "Question_1_AnswerOne", "Question_1_AnswerThree", "Question_1_AnswerTwo",
"Question_1_Question", "Question_1_Sound", "Question_2_AnswerOne", "Question_2_AnswerThree", "Question_2_AnswerTwo",
"Question_2_Question", "Question_2_Sound", "Question_3_AnswerOne", "Question_3_AnswerThree", "Question_3_AnswerTwo",
"Question_3_Question", "Question_3_Sound", "Question_4_AnswerOne", "Question_4_AnswerThree", "Question_4_AnswerTwo",
"Question_4_Question", "Question_4_Sound", "Question_5_AnswerOne", "Question_5_AnswerThree", "Question_5_AnswerTwo",
"Question_5_Question", "Question_5_Sound", "Question_6_AnswerOne", "Question_6_AnswerThree", "Question_6_AnswerTwo",
"Question_6_Question", "Question_6_Sound", "Question_7_AnswerOne", "Question_7_AnswerThree", "Question_7_AnswerTwo",
"Question_7_Question", "Question_7_Sound", "Question_8_AnswerOne", "Question_8_AnswerThree", "Question_8_AnswerTwo",
"Question_8_Question", "Question_8_Sound", "Question_9_AnswerOne", "Question_9_AnswerThree", "Question_9_AnswerTwo",
"Question_9_Question", "Question_9_Sound", "Water_NearWaterIndoorID", "Water_NearWaterOutdoorID",
"Water_RippleTexture", "Water_SurfaceTexture", "Water_UnderwaterColor", "Weather_Blizzard_Ambient_Day_Color",
"Weather_Blizzard_Ambient_Loop_Sound_ID", "Weather_Blizzard_Ambient_Night_Color",
"Weather_Blizzard_Ambient_Sunrise_Color", "Weather_Blizzard_Ambient_Sunset_Color", "Weather_Blizzard_Cloud_Texture",
"Weather_Blizzard_Fog_Day_Color", "Weather_Blizzard_Fog_Night_Color", "Weather_Blizzard_Fog_Sunrise_Color",
"Weather_Blizzard_Fog_Sunset_Color", "Weather_Blizzard_Sky_Day_Color", "Weather_Blizzard_Sky_Night_Color",
"Weather_Blizzard_Sky_Sunrise_Color", "Weather_Blizzard_Sky_Sunset_Color", "Weather_Blizzard_Storm_Threshold",
"Weather_Blizzard_Sun_Day_Color", "Weather_Blizzard_Sun_Disc_Sunset_Color", "Weather_Blizzard_Sun_Night_Color",
"Weather_Blizzard_Sun_Sunrise_Color", "Weather_Blizzard_Sun_Sunset_Color", "Weather_BumpFadeColor",
"Weather_Clear_Ambient_Day_Color", "Weather_Clear_Ambient_Loop_Sound_ID", "Weather_Clear_Ambient_Night_Color",
"Weather_Clear_Ambient_Sunrise_Color", "Weather_Clear_Ambient_Sunset_Color", "Weather_Clear_Cloud_Texture",
"Weather_Clear_Fog_Day_Color", "Weather_Clear_Fog_Night_Color", "Weather_Clear_Fog_Sunrise_Color",
"Weather_Clear_Fog_Sunset_Color", "Weather_Clear_Sky_Day_Color", "Weather_Clear_Sky_Night_Color",
"Weather_Clear_Sky_Sunrise_Color", "Weather_Clear_Sky_Sunset_Color", "Weather_Clear_Sun_Day_Color",
"Weather_Clear_Sun_Disc_Sunset_Color", "Weather_Clear_Sun_Night_Color", "Weather_Clear_Sun_Sunrise_Color",
"Weather_Clear_Sun_Sunset_Color", "Weather_Cloudy_Ambient_Day_Color", "Weather_Cloudy_Ambient_Loop_Sound_ID",
"Weather_Cloudy_Ambient_Night_Color", "Weather_Cloudy_Ambient_Sunrise_Color", "Weather_Cloudy_Ambient_Sunset_Color",
"Weather_Cloudy_Cloud_Texture", "Weather_Cloudy_Fog_Day_Color", "Weather_Cloudy_Fog_Night_Color",
"Weather_Cloudy_Fog_Sunrise_Color", "Weather_Cloudy_Fog_Sunset_Color", "Weather_Cloudy_Sky_Day_Color",
"Weather_Cloudy_Sky_Night_Color", "Weather_Cloudy_Sky_Sunrise_Color", "Weather_Cloudy_Sky_Sunset_Color",
"Weather_Cloudy_Sun_Day_Color", "Weather_Cloudy_Sun_Disc_Sunset_Color", "Weather_Cloudy_Sun_Night_Color",
"Weather_Cloudy_Sun_Sunrise_Color", "Weather_Cloudy_Sun_Sunset_Color", "Weather_EnvReduceColor",
"Weather_Fog_Depth_Change_Speed", "Weather_Foggy_Ambient_Day_Color", "Weather_Foggy_Ambient_Loop_Sound_ID",
"Weather_Foggy_Ambient_Night_Color", "Weather_Foggy_Ambient_Sunrise_Color", "Weather_Foggy_Ambient_Sunset_Color",
"Weather_Foggy_Cloud_Texture", "Weather_Foggy_Fog_Day_Color", "Weather_Foggy_Fog_Night_Color",
"Weather_Foggy_Fog_Sunrise_Color", "Weather_Foggy_Fog_Sunset_Color", "Weather_Foggy_Sky_Day_Color",
"Weather_Foggy_Sky_Night_Color", "Weather_Foggy_Sky_Sunrise_Color", "Weather_Foggy_Sky_Sunset_Color",
"Weather_Foggy_Sun_Day_Color", "Weather_Foggy_Sun_Disc_Sunset_Color", "Weather_Foggy_Sun_Night_Color",
"Weather_Foggy_Sun_Sunrise_Color", "Weather_Foggy_Sun_Sunset_Color", "Weather_LerpCloseColor",
"Weather_Overcast_Ambient_Day_Color", "Weather_Overcast_Ambient_Loop_Sound_ID",
"Weather_Overcast_Ambient_Night_Color", "Weather_Overcast_Ambient_Sunrise_Color",
"Weather_Overcast_Ambient_Sunset_Color", "Weather_Overcast_Cloud_Texture", "Weather_Overcast_Fog_Day_Color",
"Weather_Overcast_Fog_Night_Color", "Weather_Overcast_Fog_Sunrise_Color", "Weather_Overcast_Fog_Sunset_Color",
"Weather_Overcast_Sky_Day_Color", "Weather_Overcast_Sky_Night_Color", "Weather_Overcast_Sky_Sunrise_Color",
"Weather_Overcast_Sky_Sunset_Color", "Weather_Overcast_Sun_Day_Color", "Weather_Overcast_Sun_Disc_Sunset_Color",
"Weather_Overcast_Sun_Night_Color", "Weather_Overcast_Sun_Sunrise_Color", "Weather_Overcast_Sun_Sunset_Color",
"Weather_Rain_Ambient_Day_Color", "Weather_Rain_Ambient_Loop_Sound_ID", "Weather_Rain_Ambient_Night_Color",
"Weather_Rain_Ambient_Sunrise_Color", "Weather_Rain_Ambient_Sunset_Color", "Weather_Rain_Cloud_Texture",
"Weather_Rain_Fog_Day_Color", "Weather_Rain_Fog_Night_Color", "Weather_Rain_Fog_Sunrise_Color",
"Weather_Rain_Fog_Sunset_Color", "Weather_Rain_Rain_Loop_Sound_ID", "Weather_Rain_Ripple_Radius",
"Weather_Rain_Ripple_Scale", "Weather_Rain_Ripple_Speed", "Weather_Rain_Ripples_Per_Drop",
"Weather_Rain_Sky_Day_Color", "Weather_Rain_Sky_Night_Color", "Weather_Rain_Sky_Sunrise_Color",
"Weather_Rain_Sky_Sunset_Color", "Weather_Rain_Sun_Day_Color", "Weather_Rain_Sun_Disc_Sunset_Color",
"Weather_Rain_Sun_Night_Color", "Weather_Rain_Sun_Sunrise_Color", "Weather_Rain_Sun_Sunset_Color",
"Weather_Snow_Ambient_Day_Color", "Weather_Snow_Ambient_Loop_Sound_ID", "Weather_Snow_Ambient_Night_Color",
"Weather_Snow_Ambient_Sunrise_Color", "Weather_Snow_Ambient_Sunset_Color", "Weather_Snow_Cloud_Texture",
"Weather_Snow_Fog_Day_Color", "Weather_Snow_Fog_Night_Color", "Weather_Snow_Fog_Sunrise_Color",
"Weather_Snow_Fog_Sunset_Color", "Weather_Snow_Gravity_Scale", "Weather_Snow_High_Kill", "Weather_Snow_Low_Kill",
"Weather_Snow_Max_Snowflakes", "Weather_Snow_Ripple_Radius", "Weather_Snow_Ripple_Scale",
"Weather_Snow_Ripple_Speed", "Weather_Snow_Ripples_Per_Flake", "Weather_Snow_Sky_Day_Color",
"Weather_Snow_Sky_Night_Color", "Weather_Snow_Sky_Sunrise_Color", "Weather_Snow_Sky_Sunset_Color",
"Weather_Snow_Snow_Diameter", "Weather_Snow_Snow_Entrance_Speed", "Weather_Snow_Snow_Height_Max",
"Weather_Snow_Snow_Height_Min", "Weather_Snow_Snow_Threshold", "Weather_Snow_Sun_Day_Color",
"Weather_Snow_Sun_Disc_Sunset_Color", "Weather_Snow_Sun_Night_Color", "Weather_Snow_Sun_Sunrise_Color",
"Weather_Snow_Sun_Sunset_Color", "Weather_Sun_Glare_Fader_Color", "Weather_Thunderstorm_Ambient_Day_Color",
"Weather_Thunderstorm_Ambient_Loop_Sound_ID", "Weather_Thunderstorm_Ambient_Night_Color",
"Weather_Thunderstorm_Ambient_Sunrise_Color", "Weather_Thunderstorm_Ambient_Sunset_Color",
"Weather_Thunderstorm_Cloud_Texture", "Weather_Thunderstorm_Fog_Day_Color", "Weather_Thunderstorm_Fog_Night_Color",
"Weather_Thunderstorm_Fog_Sunrise_Color", "Weather_Thunderstorm_Fog_Sunset_Color",
"Weather_Thunderstorm_Rain_Loop_Sound_ID", "Weather_Thunderstorm_Sky_Day_Color",
"Weather_Thunderstorm_Sky_Night_Color", "Weather_Thunderstorm_Sky_Sunrise_Color",
"Weather_Thunderstorm_Sky_Sunset_Color", "Weather_Thunderstorm_Sun_Day_Color",
"Weather_Thunderstorm_Sun_Disc_Sunset_Color", "Weather_Thunderstorm_Sun_Night_Color",
"Weather_Thunderstorm_Sun_Sunrise_Color", "Weather_Thunderstorm_Sun_Sunset_Color",
"Weather_Thunderstorm_Thunder_Sound_ID_0", "Weather_Thunderstorm_Thunder_Sound_ID_1",
"Weather_Thunderstorm_Thunder_Sound_ID_2", "Weather_Thunderstorm_Thunder_Sound_ID_3",
"Weather_Clear_Thunder_Sound_ID_0", "Weather_Clear_Thunder_Sound_ID_1", "Weather_Clear_Thunder_Sound_ID_2",
"Weather_Clear_Thunder_Sound_ID_3", "Weather_Cloudy_Thunder_Sound_ID_0", "Weather_Cloudy_Thunder_Sound_ID_1",
"Weather_Cloudy_Thunder_Sound_ID_2", "Weather_Cloudy_Thunder_Sound_ID_3", "Weather_Foggy_Thunder_Sound_ID_0",
"Weather_Foggy_Thunder_Sound_ID_1", "Weather_Foggy_Thunder_Sound_ID_2", "Weather_Foggy_Thunder_Sound_ID_3",
"Weather_Overcast_Thunder_Sound_ID_0", "Weather_Overcast_Thunder_Sound_ID_1", "Weather_Overcast_Thunder_Sound_ID_2",
"Weather_Overcast_Thunder_Sound_ID_3", "Weather_Rain_Thunder_Sound_ID_0", "Weather_Rain_Thunder_Sound_ID_1",
"Weather_Rain_Thunder_Sound_ID_2", "Weather_Rain_Thunder_Sound_ID_3", "Weather_Ashstorm_Cloud_Texture",
"Weather_Ashstorm_Sky_Sunrise_Color", "Weather_Ashstorm_Sky_Day_Color", "Weather_Ashstorm_Sky_Sunset_Color",
"Weather_Ashstorm_Sky_Night_Color", "Weather_Ashstorm_Fog_Sunrise_Color", "Weather_Ashstorm_Fog_Day_Color",
"Weather_Ashstorm_Fog_Sunset_Color", "Weather_Ashstorm_Fog_Night_Color", "Weather_Ashstorm_Ambient_Sunrise_Color",
"Weather_Ashstorm_Ambient_Day_Color", "Weather_Ashstorm_Ambient_Sunset_Color",
"Weather_Ashstorm_Ambient_Night_Color", "Weather_Ashstorm_Sun_Sunrise_Color", "Weather_Ashstorm_Sun_Day_Color",
"Weather_Ashstorm_Sun_Sunset_Color", "Weather_Ashstorm_Sun_Night_Color", "Weather_Ashstorm_Sun_Disc_Sunset_Color",
"Weather_Ashstorm_Thunder_Sound_ID_0", "Weather_Ashstorm_Thunder_Sound_ID_1", "Weather_Ashstorm_Thunder_Sound_ID_2",
"Weather_Ashstorm_Thunder_Sound_ID_3", "Weather_Ashstorm_Ambient_Loop_Sound_ID", "Weather_Blight_Cloud_Texture",
"Weather_Blight_Sky_Sunrise_Color", "Weather_Blight_Sky_Day_Color", "Weather_Blight_Sky_Sunset_Color",
"Weather_Blight_Sky_Night_Color", "Weather_Blight_Fog_Sunrise_Color", "Weather_Blight_Fog_Day_Color",
"Weather_Blight_Fog_Sunset_Color", "Weather_Blight_Fog_Night_Color", "Weather_Blight_Ambient_Sunrise_Color",
"Weather_Blight_Ambient_Day_Color", "Weather_Blight_Ambient_Sunset_Color", "Weather_Blight_Ambient_Night_Color",
"Weather_Blight_Sun_Sunrise_Color", "Weather_Blight_Sun_Day_Color", "Weather_Blight_Sun_Sunset_Color",
"Weather_Blight_Sun_Night_Color", "Weather_Blight_Sun_Disc_Sunset_Color", "Weather_Blight_Thunder_Sound_ID_0",
"Weather_Blight_Thunder_Sound_ID_1", "Weather_Blight_Thunder_Sound_ID_2", "Weather_Blight_Thunder_Sound_ID_3",
"Weather_Blight_Ambient_Loop_Sound_ID", "Weather_Snow_Thunder_Sound_ID_0", "Weather_Snow_Thunder_Sound_ID_1",
"Weather_Snow_Thunder_Sound_ID_2", "Weather_Snow_Thunder_Sound_ID_3", "Weather_Blizzard_Thunder_Sound_ID_0",
"Weather_Blizzard_Thunder_Sound_ID_1", "Weather_Blizzard_Thunder_Sound_ID_2",
"Weather_Blizzard_Thunder_Sound_ID_3" };
static const std::set<std::string_view> allowedKeysUnused = { "Inventory_UniformScaling", "Map_Show_Travel_Lines",
"Map_Travel_Boat_Blue", "Map_Travel_Boat_Green", "Map_Travel_Boat_Red", "Map_Travel_Magic_Blue",
"Map_Travel_Magic_Green", "Map_Travel_Magic_Red", "Map_Travel_Siltstrider_Blue", "Map_Travel_Siltstrider_Green",
"Map_Travel_Siltstrider_Red", "Movies_Game_Logo", "PixelWater_Resolution", "PixelWater_SurfaceFPS",
"PixelWater_TileCount", "Movies_Loading", "Movies_Options_Menu", "Movies_Project_Logo",
"Water_NearWaterUnderwaterFreq", "Water_NearWaterUnderwaterVolume", "Water_PSWaterReflectTerrain",
"Water_PSWaterReflectUpdate", "Water_RippleAlphas", "Water_RippleScale", "Water_SurfaceTextureSize",
"Water_TileTextureDivisor", "Weather_AlphaReduce", "Weather_Ashstorm_Storm_Threshold",
"Weather_Blight_Disease_Chance", "Weather_Blight_Storm_Threshold" };
bool Fallback::isAllowedIntFallbackKey(std::string_view key)
{
return allowedKeysInt.contains(key);
}
bool Fallback::isAllowedFloatFallbackKey(std::string_view key)
{
return allowedKeysFloat.contains(key);
}
bool Fallback::isAllowedNonNumericFallbackKey(std::string_view key)
{
return allowedKeysNonNumeric.contains(key) || key.starts_with("Blood_Texture_")
|| key.starts_with("Level_Up_Level");
}
bool Fallback::isAllowedUnusedFallbackKey(std::string_view key)
{
return allowedKeysUnused.contains(key);
}
void Fallback::validate(boost::any& v, std::vector<std::string> const& tokens, FallbackMap*, int)
{
if (v.empty())
{
v = boost::any(FallbackMap());
}
FallbackMap* map = boost::any_cast<FallbackMap>(&v);
for (const auto& token : tokens)
{
size_t sep = token.find(',');
if (sep < 1 || sep == token.length() - 1 || sep == std::string::npos)
throw boost::program_options::validation_error(
boost::program_options::validation_error::invalid_option_value);
std::string key(token.substr(0, sep));
std::string value(token.substr(sep + 1));
map->mMap[key] = std::move(value);
}
}
| 24,108
|
C++
|
.cpp
| 255
| 89.67451
| 120
| 0.751038
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,597
|
fallback.cpp
|
OpenMW_openmw/components/fallback/fallback.cpp
|
#include "fallback.hpp"
#include <string>
#include <vector>
#include <components/debug/debuglog.hpp>
#include <components/misc/strings/algorithm.hpp>
#include <components/misc/strings/conversion.hpp>
#include "validate.hpp"
namespace Fallback
{
std::map<std::string, int, std::less<>> Map::mIntFallbackMap;
std::map<std::string, float, std::less<>> Map::mFloatFallbackMap;
std::map<std::string, std::string, std::less<>> Map::mNonNumericFallbackMap;
void Map::init(const std::map<std::string, std::string>& fallback)
{
for (const auto& [key, value] : fallback)
{
if (isAllowedIntFallbackKey(key))
mIntFallbackMap.emplace(key, Misc::StringUtils::toNumeric<int>(value, 0));
else if (isAllowedFloatFallbackKey(key))
mFloatFallbackMap.emplace(key, Misc::StringUtils::toNumeric<float>(value, 0.0f));
else if (isAllowedNonNumericFallbackKey(key))
mNonNumericFallbackMap.emplace(key, value);
else if (!isAllowedUnusedFallbackKey(key))
Log(Debug::Error) << "Ignoring unknown fallback: " << key;
}
}
std::string_view Map::getString(std::string_view fall)
{
const auto it = mNonNumericFallbackMap.find(fall);
if (it == mNonNumericFallbackMap.end())
{
if (!isAllowedNonNumericFallbackKey(fall))
throw std::logic_error("Requested invalid string fallback: " + std::string(fall));
return {};
}
return it->second;
}
float Map::getFloat(std::string_view fall)
{
const auto it = mFloatFallbackMap.find(fall);
if (it == mFloatFallbackMap.end())
{
if (!isAllowedFloatFallbackKey(fall))
throw std::logic_error("Requested invalid float fallback: " + std::string(fall));
return {};
}
return it->second;
}
int Map::getInt(std::string_view fall)
{
const auto it = mIntFallbackMap.find(fall);
if (it == mIntFallbackMap.end())
{
if (!isAllowedIntFallbackKey(fall))
throw std::logic_error("Requested invalid int fallback: " + std::string(fall));
return {};
}
return it->second;
}
bool Map::getBool(std::string_view fall)
{
return getInt(fall) != 0;
}
osg::Vec4f Map::getColour(std::string_view fall)
{
const std::string_view sum = getString(fall);
if (!sum.empty())
{
std::vector<std::string> ret;
Misc::StringUtils::split(sum, ret, ",");
if (ret.size() == 3)
{
const auto r = Misc::StringUtils::toNumeric<float>(ret[0]);
const auto g = Misc::StringUtils::toNumeric<float>(ret[1]);
const auto b = Misc::StringUtils::toNumeric<float>(ret[2]);
if (r.has_value() && g.has_value() && b.has_value())
{
return osg::Vec4f(*r / 255.0f, *g / 255.0f, *b / 255.0f, 1.0f);
}
}
Log(Debug::Error) << "Error: '" << fall << "' setting value (" << sum
<< ") is not a valid color, using middle gray as a fallback";
}
return osg::Vec4f(0.5f, 0.5f, 0.5f, 1.f);
}
}
| 3,359
|
C++
|
.cpp
| 86
| 29.44186
| 98
| 0.569982
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,598
|
processinvoker.cpp
|
OpenMW_openmw/components/process/processinvoker.cpp
|
#include "processinvoker.hpp"
#include <QDir>
#include <QMessageBox>
#include <QString>
#include <QStringList>
#if defined(Q_OS_MAC)
#include <QCoreApplication>
#endif
Process::ProcessInvoker::ProcessInvoker(QObject* parent)
: QObject(parent)
{
mProcess = new QProcess(this);
connect(mProcess, &QProcess::errorOccurred, this, &ProcessInvoker::processError);
connect(
mProcess, qOverload<int, QProcess::ExitStatus>(&QProcess::finished), this, &ProcessInvoker::processFinished);
mName = QString();
mArguments = QStringList();
}
Process::ProcessInvoker::~ProcessInvoker() {}
// void Process::ProcessInvoker::setProcessName(const QString &name)
//{
// mName = name;
// }
// void Process::ProcessInvoker::setProcessArguments(const QStringList &arguments)
//{
// mArguments = arguments;
// }
QProcess* Process::ProcessInvoker::getProcess()
{
return mProcess;
}
// QString Process::ProcessInvoker::getProcessName()
//{
// return mName;
// }
// QStringList Process::ProcessInvoker::getProcessArguments()
//{
// return mArguments;
// }
bool Process::ProcessInvoker::startProcess(const QString& name, const QStringList& arguments, bool detached)
{
// mProcess = new QProcess(this);
mName = name;
mArguments = arguments;
mIgnoreErrors = false;
QString path(name);
#ifdef Q_OS_WIN
path.append(QLatin1String(".exe"));
#elif defined(Q_OS_MAC)
QDir dir(QCoreApplication::applicationDirPath());
path = dir.absoluteFilePath(name);
#else
path.prepend(QLatin1String("./"));
#endif
QFileInfo info(path);
if (!info.exists())
{
QMessageBox msgBox;
msgBox.setWindowTitle(tr("Error starting executable"));
msgBox.setIcon(QMessageBox::Warning);
msgBox.setStandardButtons(QMessageBox::Ok);
msgBox.setText(
tr("<html><head/><body><p><b>Could not find %1</b></p>"
"<p>The application is not found.</p>"
"<p>Please make sure OpenMW is installed correctly and try again.</p></body></html>")
.arg(info.fileName()));
msgBox.exec();
return false;
}
if (!info.isExecutable())
{
QMessageBox msgBox;
msgBox.setWindowTitle(tr("Error starting executable"));
msgBox.setIcon(QMessageBox::Warning);
msgBox.setStandardButtons(QMessageBox::Ok);
msgBox.setText(
tr("<html><head/><body><p><b>Could not start %1</b></p>"
"<p>The application is not executable.</p>"
"<p>Please make sure you have the right permissions and try again.</p></body></html>")
.arg(info.fileName()));
msgBox.exec();
return false;
}
// Start the executable
if (detached)
{
if (!mProcess->startDetached(path, arguments))
{
QMessageBox msgBox;
msgBox.setWindowTitle(tr("Error starting executable"));
msgBox.setIcon(QMessageBox::Critical);
msgBox.setStandardButtons(QMessageBox::Ok);
msgBox.setText(
tr("<html><head/><body><p><b>Could not start %1</b></p>"
"<p>An error occurred while starting %1.</p>"
"<p>Press \"Show Details...\" for more information.</p></body></html>")
.arg(info.fileName()));
msgBox.setDetailedText(mProcess->errorString());
msgBox.exec();
return false;
}
}
else
{
mProcess->start(path, arguments);
/*
if (!mProcess->waitForFinished()) {
QMessageBox msgBox;
msgBox.setWindowTitle(tr("Error starting executable"));
msgBox.setIcon(QMessageBox::Critical);
msgBox.setStandardButtons(QMessageBox::Ok);
msgBox.setText(tr("<html><head/><body><p><b>Could not start %1</b></p> \
<p>An error occurred while starting %1.</p> \
<p>Press \"Show Details...\" for more
information.</p></body></html>").arg(info.fileName())); msgBox.setDetailedText(mProcess->errorString());
msgBox.exec();
return false;
}
if (mProcess->exitCode() != 0 || mProcess->exitStatus() == QProcess::CrashExit) {
QString error(mProcess->readAllStandardError());
error.append(tr("\nArguments:\n"));
error.append(arguments.join(" "));
QMessageBox msgBox;
msgBox.setWindowTitle(tr("Error running executable"));
msgBox.setIcon(QMessageBox::Critical);
msgBox.setStandardButtons(QMessageBox::Ok);
msgBox.setText(tr("<html><head/><body><p><b>Executable %1 returned an error</b></p> \
<p>An error occurred while running %1.</p> \
<p>Press \"Show Details...\" for more
information.</p></body></html>").arg(info.fileName())); msgBox.setDetailedText(error); msgBox.exec();
return false;
}
*/
}
return true;
}
void Process::ProcessInvoker::processError(QProcess::ProcessError error)
{
if (mIgnoreErrors)
return;
QMessageBox msgBox;
msgBox.setWindowTitle(tr("Error running executable"));
msgBox.setIcon(QMessageBox::Critical);
msgBox.setStandardButtons(QMessageBox::Ok);
msgBox.setText(
tr("<html><head/><body><p><b>Executable %1 returned an error</b></p>"
"<p>An error occurred while running %1.</p>"
"<p>Press \"Show Details...\" for more information.</p></body></html>")
.arg(mName));
msgBox.setDetailedText(mProcess->errorString());
msgBox.exec();
}
void Process::ProcessInvoker::processFinished(int exitCode, QProcess::ExitStatus exitStatus)
{
if (exitCode != 0 || exitStatus == QProcess::CrashExit)
{
if (mIgnoreErrors)
return;
QString error(mProcess->readAllStandardError());
error.append(tr("\nArguments:\n"));
error.append(mArguments.join(" "));
QMessageBox msgBox;
msgBox.setWindowTitle(tr("Error running executable"));
msgBox.setIcon(QMessageBox::Critical);
msgBox.setStandardButtons(QMessageBox::Ok);
msgBox.setText(
tr("<html><head/><body><p><b>Executable %1 returned an error</b></p>"
"<p>An error occurred while running %1.</p>"
"<p>Press \"Show Details...\" for more information.</p></body></html>")
.arg(mName));
msgBox.setDetailedText(error);
msgBox.exec();
}
}
void Process::ProcessInvoker::killProcess()
{
mIgnoreErrors = true;
mProcess->kill();
}
| 6,707
|
C++
|
.cpp
| 179
| 29.620112
| 117
| 0.613538
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| true
| false
| false
|
34,599
|
stream.cpp
|
OpenMW_openmw/components/bgsm/stream.cpp
|
#include "stream.hpp"
namespace Bgsm
{
template <>
void BGSMStream::read<osg::Vec2f>(osg::Vec2f& vec)
{
readBufferOfType(mStream, vec._v);
}
template <>
void BGSMStream::read<osg::Vec3f>(osg::Vec3f& vec)
{
readBufferOfType(mStream, vec._v);
}
template <>
void BGSMStream::read<osg::Vec4f>(osg::Vec4f& vec)
{
readBufferOfType(mStream, vec._v);
}
template <>
void BGSMStream::read<std::string>(std::string& str)
{
std::uint32_t length;
read(length);
// Prevent potential memory allocation freezes; strings this long are not expected in BGSM
if (length > 1024)
throw std::runtime_error("Requested string length is too large: " + std::to_string(length));
str = std::string(length, '\0');
mStream->read(str.data(), length);
if (mStream->bad())
throw std::runtime_error("Failed to read sized string of " + std::to_string(length) + " chars");
std::size_t end = str.find('\0');
if (end != std::string::npos)
str.erase(end);
}
}
| 1,120
|
C++
|
.cpp
| 35
| 25.285714
| 108
| 0.593895
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,600
|
file.cpp
|
OpenMW_openmw/components/bgsm/file.cpp
|
#include "file.hpp"
#include <array>
#include <stdexcept>
#include "stream.hpp"
namespace Bgsm
{
MaterialFilePtr parse(Files::IStreamPtr&& inputStream)
{
std::shared_ptr<Bgsm::MaterialFile> file;
BGSMStream stream(std::move(inputStream));
std::array<char, 4> signature;
stream.readArray(signature);
std::string shaderType(signature.data(), 4);
if (shaderType == "BGEM")
{
file = std::make_shared<BGEMFile>();
file->mShaderType = Bgsm::ShaderType::Effect;
}
else if (shaderType == "BGSM")
{
file = std::make_shared<BGSMFile>();
file->mShaderType = Bgsm::ShaderType::Lighting;
}
else
throw std::runtime_error("Invalid material file");
file->read(stream);
return file;
}
void MaterialFile::read(BGSMStream& stream)
{
stream.read(mVersion);
stream.read(mClamp);
stream.read(mUVOffset);
stream.read(mUVScale);
stream.read(mTransparency);
stream.read(mAlphaBlend);
stream.read(mSourceBlendMode);
stream.read(mDestinationBlendMode);
stream.read(mAlphaTestThreshold);
stream.read(mAlphaTest);
stream.read(mDepthWrite);
stream.read(mDepthTest);
stream.read(mSSR);
stream.read(mWetnessControlSSR);
stream.read(mDecal);
stream.read(mTwoSided);
stream.read(mDecalNoFade);
stream.read(mNonOccluder);
stream.read(mRefraction);
stream.read(mRefractionFalloff);
stream.read(mRefractionPower);
if (mVersion < 10)
{
stream.read(mEnvMapEnabled);
stream.read(mEnvMapMaskScale);
}
else
{
stream.read(mDepthBias);
}
stream.read(mGrayscaleToPaletteColor);
if (mVersion >= 6)
stream.read(mMaskWrites);
}
void BGSMFile::read(BGSMStream& stream)
{
MaterialFile::read(stream);
stream.read(mDiffuseMap);
stream.read(mNormalMap);
stream.read(mSmoothSpecMap);
stream.read(mGrayscaleMap);
if (mVersion >= 3)
{
stream.read(mGlowMap);
stream.read(mWrinkleMap);
stream.read(mSpecularMap);
stream.read(mLightingMap);
stream.read(mFlowMap);
if (mVersion >= 17)
stream.read(mDistanceFieldAlphaMap);
}
else
{
stream.read(mEnvMap);
stream.read(mGlowMap);
stream.read(mInnerLayerMap);
stream.read(mWrinkleMap);
stream.read(mDisplacementMap);
}
stream.read(mEnableEditorAlphaThreshold);
if (mVersion >= 8)
{
stream.read(mTranslucency);
stream.read(mTranslucencyThickObject);
stream.read(mTranslucencyMixAlbedoWithSubsurfaceColor);
stream.read(mTranslucencySubsurfaceColor);
stream.read(mTranslucencyTransmissiveScale);
stream.read(mTranslucencyTurbulence);
}
else
{
stream.read(mRimLighting);
stream.read(mRimPower);
stream.read(mBackLightPower);
stream.read(mSubsurfaceLighting);
stream.read(mSubsurfaceLightingRolloff);
}
stream.read(mSpecularEnabled);
stream.read(mSpecularColor);
stream.read(mSpecularMult);
stream.read(mSmoothness);
stream.read(mFresnelPower);
stream.read(mWetnessControlSpecScale);
stream.read(mWetnessControlSpecPowerScale);
stream.read(mWetnessControlSpecMinvar);
if (mVersion < 10)
stream.read(mWetnessControlEnvMapScale);
stream.read(mWetnessControlFresnelPower);
stream.read(mWetnessControlMetalness);
if (mVersion >= 3)
{
stream.read(mPBR);
if (mVersion >= 9)
{
stream.read(mCustomPorosity);
stream.read(mPorosityValue);
}
}
stream.read(mRootMaterialPath);
stream.read(mAnisoLighting);
stream.read(mEmitEnabled);
if (mEmitEnabled)
stream.read(mEmittanceColor);
stream.read(mEmittanceMult);
stream.read(mModelSpaceNormals);
stream.read(mExternalEmittance);
if (mVersion >= 12)
{
stream.read(mLumEmittance);
if (mVersion >= 13)
{
stream.read(mUseAdaptiveEmissive);
stream.read(mAdaptiveEmissiveExposureParams);
}
}
else if (mVersion < 8)
{
stream.read(mBackLighting);
}
stream.read(mReceiveShadows);
stream.read(mHideSecret);
stream.read(mCastShadows);
stream.read(mDissolveFade);
stream.read(mAssumeShadowmask);
stream.read(mGlowMapEnabled);
if (mVersion < 7)
{
stream.read(mEnvMapWindow);
stream.read(mEnvMapEye);
}
stream.read(mHair);
stream.read(mHairTintColor);
stream.read(mTree);
stream.read(mFacegen);
stream.read(mSkinTint);
stream.read(mTessellate);
if (mVersion < 3)
{
stream.read(mDisplacementMapParams);
stream.read(mTessellationParams);
}
stream.read(mGrayscaleToPaletteScale);
if (mVersion >= 1)
{
stream.read(mSkewSpecularAlpha);
stream.read(mTerrain);
if (mTerrain)
{
if (mVersion == 3)
stream.skip(4); // Unknown
stream.read(mTerrainParams);
}
}
}
void BGEMFile::read(BGSMStream& stream)
{
MaterialFile::read(stream);
stream.read(mBaseMap);
stream.read(mGrayscaleMap);
stream.read(mEnvMap);
stream.read(mNormalMap);
stream.read(mEnvMapMask);
if (mVersion >= 11)
{
stream.read(mSpecularMap);
stream.read(mLightingMap);
stream.read(mGlowMap);
}
if (mVersion >= 10)
{
stream.read(mEnvMapEnabled);
stream.read(mEnvMapMaskScale);
}
stream.read(mBlood);
stream.read(mEffectLighting);
stream.read(mFalloff);
stream.read(mFalloffColor);
stream.read(mGrayscaleToPaletteAlpha);
stream.read(mSoft);
stream.read(mBaseColor);
stream.read(mBaseColorScale);
stream.read(mFalloffParams);
stream.read(mLightingInfluence);
stream.read(mEnvmapMinLOD);
stream.read(mSoftDepth);
if (mVersion >= 11)
stream.read(mEmittanceColor);
if (mVersion >= 15)
stream.read(mAdaptiveEmissiveExposureParams);
if (mVersion >= 16)
stream.read(mGlowMapEnabled);
if (mVersion >= 20)
stream.read(mEffectPbrSpecular);
}
}
| 7,100
|
C++
|
.cpp
| 225
| 21.6
| 67
| 0.580128
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,601
|
box.cpp
|
OpenMW_openmw/components/widgets/box.cpp
|
#include "box.hpp"
#include <MyGUI_EditText.h>
namespace Gui
{
void AutoSizedWidget::notifySizeChange(MyGUI::Widget* w)
{
MyGUI::Widget* parent = w->getParent();
if (parent != nullptr)
{
if (mExpandDirection.isLeft())
{
int hdiff = getRequestedSize().width - w->getSize().width;
w->setPosition(w->getPosition() - MyGUI::IntPoint(hdiff, 0));
}
w->setSize(getRequestedSize());
while (parent != nullptr)
{
Box* b = dynamic_cast<Box*>(parent);
if (b)
b->notifyChildrenSizeChanged();
else
break;
parent = parent->getParent();
}
}
}
MyGUI::IntSize AutoSizedTextBox::getRequestedSize()
{
return getCaption().empty() ? MyGUI::IntSize{ 0, 0 } : getTextSize();
}
void AutoSizedTextBox::setCaption(const MyGUI::UString& _value)
{
TextBox::setCaption(_value);
notifySizeChange(this);
}
void AutoSizedTextBox::setPropertyOverride(std::string_view _key, std::string_view _value)
{
if (_key == "ExpandDirection")
{
mExpandDirection = MyGUI::Align::parse(_value);
}
else
{
Gui::TextBox::setPropertyOverride(_key, _value);
}
}
int AutoSizedEditBox::getWidth()
{
// If the widget has the one short text line, we can shrink widget to avoid a lot of empty space.
int textWidth = mMaxWidth;
if (mShrink)
{
// MyGUI needs to know the widget size for wordwrapping, but we will know the widget size only after
// wordwrapping. To solve this issue, use the maximum tooltip width first for wordwrapping, then resize
// widget to its actual used space.
if (mWasResized)
{
int maxLineWidth = 0;
const MyGUI::VectorLineInfo& lines = getSubWidgetText()->castType<MyGUI::EditText>()->getLineInfo();
for (unsigned int i = 0; i < lines.size(); ++i)
maxLineWidth = std::max(maxLineWidth, lines[i].width);
textWidth = std::min(maxLineWidth, textWidth);
}
else
{
mWasResized = true;
}
}
return textWidth;
}
MyGUI::IntSize AutoSizedEditBox::getRequestedSize()
{
if (getAlign().isHStretch())
throw std::runtime_error("AutoSizedEditBox can't have HStretch align (" + getName() + ")");
return MyGUI::IntSize(getWidth(), getTextSize().height);
}
void AutoSizedEditBox::setCaption(const MyGUI::UString& _value)
{
EditBox::setCaption(_value);
mWasResized = false;
notifySizeChange(this);
}
void AutoSizedEditBox::initialiseOverride()
{
mMaxWidth = getSize().width;
Base::initialiseOverride();
setNeedKeyFocus(false);
setEditStatic(true);
}
void AutoSizedEditBox::setPropertyOverride(std::string_view _key, std::string_view _value)
{
if (_key == "ExpandDirection")
{
mExpandDirection = MyGUI::Align::parse(_value);
}
else if (_key == "Shrink")
{
mShrink = MyGUI::utility::parseValue<bool>(_value);
}
else
{
Gui::EditBox::setPropertyOverride(_key, _value);
}
}
MyGUI::IntSize AutoSizedButton::getRequestedSize()
{
MyGUI::IntSize padding(24, 8);
if (isUserString("TextPadding"))
padding = MyGUI::IntSize::parse(getUserString("TextPadding"));
MyGUI::IntSize size = getTextSize() + MyGUI::IntSize(padding.width, padding.height);
return size;
}
void AutoSizedButton::setCaption(const MyGUI::UString& _value)
{
Button::setCaption(_value);
notifySizeChange(this);
}
void AutoSizedButton::setPropertyOverride(std::string_view _key, std::string_view _value)
{
if (_key == "ExpandDirection")
{
mExpandDirection = MyGUI::Align::parse(_value);
}
else
{
Gui::Button::setPropertyOverride(_key, _value);
}
}
Box::Box()
: mSpacing(4)
, mPadding(0)
, mAutoResize(false)
{
}
void Box::notifyChildrenSizeChanged()
{
align();
}
bool Box::_setPropertyImpl(std::string_view _key, std::string_view _value)
{
if (_key == "Spacing")
mSpacing = MyGUI::utility::parseValue<int>(_value);
else if (_key == "Padding")
mPadding = MyGUI::utility::parseValue<int>(_value);
else if (_key == "AutoResize")
mAutoResize = MyGUI::utility::parseValue<bool>(_value);
else
return false;
return true;
}
void HBox::align()
{
unsigned int count = getChildCount();
size_t h_stretched_count = 0;
int total_width = 0;
int total_height = 0;
std::vector<std::pair<MyGUI::IntSize, bool>> sizes;
sizes.resize(count);
for (unsigned int i = 0; i < count; ++i)
{
MyGUI::Widget* w = getChildAt(i);
bool hstretch = w->getUserString("HStretch") == "true";
bool hidden = w->getUserString("Hidden") == "true";
if (hidden)
continue;
h_stretched_count += hstretch;
AutoSizedWidget* aw = dynamic_cast<AutoSizedWidget*>(w);
if (aw)
{
sizes[i] = std::make_pair(aw->getRequestedSize(), hstretch);
total_width += aw->getRequestedSize().width;
total_height = std::max(total_height, aw->getRequestedSize().height);
}
else
{
sizes[i] = std::make_pair(w->getSize(), hstretch);
total_width += w->getSize().width;
if (!(w->getUserString("VStretch") == "true"))
total_height = std::max(total_height, w->getSize().height);
}
if (i != count - 1)
total_width += mSpacing;
}
if (mAutoResize
&& (total_width + mPadding * 2 != getClientCoord().width
|| total_height + mPadding * 2 != getClientCoord().height))
{
int xmargin = getSize().width - getClientCoord().width;
int ymargin = getSize().height - getClientCoord().height;
setSize(MyGUI::IntSize(total_width + mPadding * 2 + xmargin, total_height + mPadding * 2 + ymargin));
return;
}
int curX = 0;
for (unsigned int i = 0; i < count; ++i)
{
if (i == 0)
curX += mPadding;
MyGUI::Widget* w = getChildAt(i);
bool hidden = w->getUserString("Hidden") == "true";
if (hidden)
continue;
bool vstretch = w->getUserString("VStretch") == "true";
int max_height = getClientCoord().height - mPadding * 2;
int height = vstretch ? max_height : sizes[i].first.height;
MyGUI::IntCoord widgetCoord;
widgetCoord.left = curX;
widgetCoord.top = mPadding + (getClientCoord().height - mPadding * 2 - height) / 2;
int width = 0;
if (sizes[i].second)
{
if (h_stretched_count == 0)
throw std::logic_error("unexpected");
width
= sizes[i].first.width + (getClientCoord().width - mPadding * 2 - total_width) / h_stretched_count;
}
else
width = sizes[i].first.width;
widgetCoord.width = width;
widgetCoord.height = height;
w->setCoord(widgetCoord);
curX += width;
if (i != count - 1)
curX += mSpacing;
}
}
void HBox::setPropertyOverride(std::string_view _key, std::string_view _value)
{
if (!Box::_setPropertyImpl(_key, _value))
MyGUI::Widget::setPropertyOverride(_key, _value);
}
void HBox::setSize(const MyGUI::IntSize& _value)
{
MyGUI::Widget::setSize(_value);
align();
}
void HBox::setCoord(const MyGUI::IntCoord& _value)
{
MyGUI::Widget::setCoord(_value);
align();
}
void HBox::initialiseOverride()
{
Base::initialiseOverride();
MyGUI::Widget* client = nullptr;
assignWidget(client, "Client");
setWidgetClient(client);
}
void HBox::onWidgetCreated(MyGUI::Widget* _widget)
{
align();
}
MyGUI::IntSize HBox::getRequestedSize()
{
MyGUI::IntSize size(0, 0);
for (unsigned int i = 0; i < getChildCount(); ++i)
{
bool hidden = getChildAt(i)->getUserString("Hidden") == "true";
if (hidden)
continue;
AutoSizedWidget* w = dynamic_cast<AutoSizedWidget*>(getChildAt(i));
if (w)
{
MyGUI::IntSize requested = w->getRequestedSize();
size.height = std::max(size.height, requested.height);
size.width = size.width + requested.width;
if (i != getChildCount() - 1)
size.width += mSpacing;
}
else
{
MyGUI::IntSize requested = getChildAt(i)->getSize();
size.height = std::max(size.height, requested.height);
if (getChildAt(i)->getUserString("HStretch") != "true")
size.width = size.width + requested.width;
if (i != getChildCount() - 1)
size.width += mSpacing;
}
size.height += mPadding * 2;
size.width += mPadding * 2;
}
return size;
}
void VBox::align()
{
unsigned int count = getChildCount();
size_t v_stretched_count = 0;
int total_height = 0;
int total_width = 0;
std::vector<std::pair<MyGUI::IntSize, bool>> sizes;
sizes.resize(count);
for (unsigned int i = 0; i < count; ++i)
{
MyGUI::Widget* w = getChildAt(i);
bool hidden = w->getUserString("Hidden") == "true";
if (hidden)
continue;
bool vstretch = w->getUserString("VStretch") == "true";
v_stretched_count += vstretch;
AutoSizedWidget* aw = dynamic_cast<AutoSizedWidget*>(w);
if (aw)
{
sizes[i] = std::make_pair(aw->getRequestedSize(), vstretch);
total_height += aw->getRequestedSize().height;
total_width = std::max(total_width, aw->getRequestedSize().width);
}
else
{
sizes[i] = std::make_pair(w->getSize(), vstretch);
total_height += w->getSize().height;
if (!(w->getUserString("HStretch") == "true"))
total_width = std::max(total_width, w->getSize().width);
}
if (i != count - 1)
total_height += mSpacing;
}
if (mAutoResize
&& (total_width + mPadding * 2 != getClientCoord().width
|| total_height + mPadding * 2 != getClientCoord().height))
{
int xmargin = getSize().width - getClientCoord().width;
int ymargin = getSize().height - getClientCoord().height;
setSize(MyGUI::IntSize(total_width + mPadding * 2 + xmargin, total_height + mPadding * 2 + ymargin));
return;
}
int curY = 0;
for (unsigned int i = 0; i < count; ++i)
{
if (i == 0)
curY += mPadding;
MyGUI::Widget* w = getChildAt(i);
bool hidden = w->getUserString("Hidden") == "true";
if (hidden)
continue;
bool hstretch = w->getUserString("HStretch") == "true";
int maxWidth = getClientCoord().width - mPadding * 2;
int width = hstretch ? maxWidth : sizes[i].first.width;
MyGUI::IntCoord widgetCoord;
widgetCoord.top = curY;
widgetCoord.left = mPadding + (getClientCoord().width - mPadding * 2 - width) / 2;
int height = 0;
if (sizes[i].second)
{
if (v_stretched_count == 0)
throw std::logic_error("unexpected");
height = sizes[i].first.height
+ (getClientCoord().height - mPadding * 2 - total_height) / v_stretched_count;
}
else
height = sizes[i].first.height;
widgetCoord.height = height;
widgetCoord.width = width;
w->setCoord(widgetCoord);
curY += height;
if (i != count - 1)
curY += mSpacing;
}
}
void VBox::setPropertyOverride(std::string_view _key, std::string_view _value)
{
if (!Box::_setPropertyImpl(_key, _value))
MyGUI::Widget::setPropertyOverride(_key, _value);
}
void VBox::setSize(const MyGUI::IntSize& _value)
{
MyGUI::Widget::setSize(_value);
align();
}
void VBox::setCoord(const MyGUI::IntCoord& _value)
{
MyGUI::Widget::setCoord(_value);
align();
}
void VBox::initialiseOverride()
{
Base::initialiseOverride();
MyGUI::Widget* client = nullptr;
assignWidget(client, "Client");
setWidgetClient(client);
}
MyGUI::IntSize VBox::getRequestedSize()
{
MyGUI::IntSize size(0, 0);
for (unsigned int i = 0; i < getChildCount(); ++i)
{
bool hidden = getChildAt(i)->getUserString("Hidden") == "true";
if (hidden)
continue;
AutoSizedWidget* w = dynamic_cast<AutoSizedWidget*>(getChildAt(i));
if (w)
{
MyGUI::IntSize requested = w->getRequestedSize();
size.width = std::max(size.width, requested.width);
size.height = size.height + requested.height;
if (i != getChildCount() - 1)
size.height += mSpacing;
}
else
{
MyGUI::IntSize requested = getChildAt(i)->getSize();
size.width = std::max(size.width, requested.width);
if (getChildAt(i)->getUserString("VStretch") != "true")
size.height = size.height + requested.height;
if (i != getChildCount() - 1)
size.height += mSpacing;
}
size.height += mPadding * 2;
size.width += mPadding * 2;
}
return size;
}
void VBox::onWidgetCreated(MyGUI::Widget* _widget)
{
align();
}
Spacer::Spacer()
{
setUserString("HStretch", "true");
setUserString("VStretch", "true");
}
}
| 15,223
|
C++
|
.cpp
| 420
| 25.247619
| 119
| 0.526066
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| true
| false
|
34,602
|
sharedstatebutton.cpp
|
OpenMW_openmw/components/widgets/sharedstatebutton.cpp
|
#include "sharedstatebutton.hpp"
namespace Gui
{
SharedStateButton::SharedStateButton()
: mIsMousePressed(false)
, mIsMouseFocus(false)
{
}
void SharedStateButton::shutdownOverride()
{
ButtonGroup group = mSharedWith; // make a copy so that we don't nuke the vector during iteration
for (ButtonGroup::iterator it = group.begin(); it != group.end(); ++it)
{
(*it)->shareStateWith(ButtonGroup());
}
}
void SharedStateButton::shareStateWith(const ButtonGroup& shared)
{
mSharedWith = shared;
}
void SharedStateButton::onMouseButtonPressed(int _left, int _top, MyGUI::MouseButton _id)
{
mIsMousePressed = true;
Base::onMouseButtonPressed(_left, _top, _id);
updateButtonState();
}
void SharedStateButton::onMouseButtonReleased(int _left, int _top, MyGUI::MouseButton _id)
{
mIsMousePressed = false;
Base::onMouseButtonReleased(_left, _top, _id);
updateButtonState();
}
void SharedStateButton::onMouseSetFocus(MyGUI::Widget* _old)
{
mIsMouseFocus = true;
Base::onMouseSetFocus(_old);
updateButtonState();
}
void SharedStateButton::onMouseLostFocus(MyGUI::Widget* _new)
{
mIsMouseFocus = false;
Base::onMouseLostFocus(_new);
updateButtonState();
}
void SharedStateButton::baseUpdateEnable()
{
Base::baseUpdateEnable();
updateButtonState();
}
void SharedStateButton::setStateSelected(bool _value)
{
Base::setStateSelected(_value);
updateButtonState();
for (ButtonGroup::iterator it = mSharedWith.begin(); it != mSharedWith.end(); ++it)
{
(*it)->MyGUI::Button::setStateSelected(getStateSelected());
}
}
bool SharedStateButton::_setState(const std::string& _value)
{
bool ret = _setWidgetState(_value);
if (ret)
{
for (ButtonGroup::iterator it = mSharedWith.begin(); it != mSharedWith.end(); ++it)
{
(*it)->_setWidgetState(_value);
}
}
return ret;
}
void SharedStateButton::updateButtonState()
{
if (getStateSelected())
{
if (!getInheritedEnabled())
{
if (!_setState("disabled_checked"))
_setState("disabled");
}
else if (mIsMousePressed)
{
if (!_setState("pushed_checked"))
_setState("pushed");
}
else if (mIsMouseFocus)
{
if (!_setState("highlighted_checked"))
_setState("pushed");
}
else
_setState("normal_checked");
}
else
{
if (!getInheritedEnabled())
_setState("disabled");
else if (mIsMousePressed)
_setState("pushed");
else if (mIsMouseFocus)
_setState("highlighted");
else
_setState("normal");
}
}
void SharedStateButton::createButtonGroup(ButtonGroup& group)
{
for (ButtonGroup::iterator it = group.begin(); it != group.end(); ++it)
{
(*it)->shareStateWith(group);
}
}
}
| 3,394
|
C++
|
.cpp
| 112
| 21.0625
| 105
| 0.556474
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,603
|
numericeditbox.cpp
|
OpenMW_openmw/components/widgets/numericeditbox.cpp
|
#include <stdexcept>
#include "numericeditbox.hpp"
#include <components/misc/strings/conversion.hpp>
namespace Gui
{
void NumericEditBox::initialiseOverride()
{
Base::initialiseOverride();
eventEditTextChange += MyGUI::newDelegate(this, &NumericEditBox::onEditTextChange);
mValue = 0;
setCaption("0");
}
void NumericEditBox::shutdownOverride()
{
Base::shutdownOverride();
eventEditTextChange -= MyGUI::newDelegate(this, &NumericEditBox::onEditTextChange);
}
void NumericEditBox::onEditTextChange(MyGUI::EditBox* sender)
{
const std::string newCaption = sender->getCaption();
if (newCaption.empty())
{
return;
}
if (const auto conversion = Misc::StringUtils::toNumeric<int>(newCaption))
{
mValue = conversion.value();
const int capped = std::clamp(mValue, mMinValue, mMaxValue);
if (capped != mValue)
{
mValue = capped;
setCaption(MyGUI::utility::toString(mValue));
}
}
else
{
setCaption(MyGUI::utility::toString(mValue));
}
eventValueChanged(mValue);
}
void NumericEditBox::setValue(int value)
{
if (value != mValue)
{
setCaption(MyGUI::utility::toString(value));
mValue = value;
}
}
int NumericEditBox::getValue()
{
return mValue;
}
void NumericEditBox::setMinValue(int minValue)
{
mMinValue = minValue;
}
void NumericEditBox::setMaxValue(int maxValue)
{
mMaxValue = maxValue;
}
void NumericEditBox::onKeyLostFocus(MyGUI::Widget* _new)
{
Base::onKeyLostFocus(_new);
setCaption(MyGUI::utility::toString(mValue));
}
void NumericEditBox::onKeyButtonPressed(MyGUI::KeyCode key, MyGUI::Char character)
{
if (key == MyGUI::KeyCode::ArrowUp)
{
setValue(std::min(mValue + 1, mMaxValue));
eventValueChanged(mValue);
}
else if (key == MyGUI::KeyCode::ArrowDown)
{
setValue(std::max(mValue - 1, mMinValue));
eventValueChanged(mValue);
}
else if (character == 0 || (character >= '0' && character <= '9'))
Base::onKeyButtonPressed(key, character);
}
}
| 2,422
|
C++
|
.cpp
| 81
| 21.716049
| 91
| 0.590616
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,604
|
widgets.cpp
|
OpenMW_openmw/components/widgets/widgets.cpp
|
#include "widgets.hpp"
#include <MyGUI_FactoryManager.h>
#include "box.hpp"
#include "imagebutton.hpp"
#include "list.hpp"
#include "numericeditbox.hpp"
#include "sharedstatebutton.hpp"
#include "windowcaption.hpp"
namespace Gui
{
void registerAllWidgets()
{
MyGUI::FactoryManager::getInstance().registerFactory<Gui::MWList>("Widget");
MyGUI::FactoryManager::getInstance().registerFactory<Gui::HBox>("Widget");
MyGUI::FactoryManager::getInstance().registerFactory<Gui::Spacer>("Widget");
MyGUI::FactoryManager::getInstance().registerFactory<Gui::VBox>("Widget");
MyGUI::FactoryManager::getInstance().registerFactory<Gui::EditBox>("Widget");
MyGUI::FactoryManager::getInstance().registerFactory<Gui::TextBox>("Widget");
MyGUI::FactoryManager::getInstance().registerFactory<Gui::AutoSizedTextBox>("Widget");
MyGUI::FactoryManager::getInstance().registerFactory<Gui::AutoSizedEditBox>("Widget");
MyGUI::FactoryManager::getInstance().registerFactory<Gui::AutoSizedButton>("Widget");
MyGUI::FactoryManager::getInstance().registerFactory<Gui::Button>("Widget");
MyGUI::FactoryManager::getInstance().registerFactory<Gui::ImageButton>("Widget");
MyGUI::FactoryManager::getInstance().registerFactory<Gui::NumericEditBox>("Widget");
MyGUI::FactoryManager::getInstance().registerFactory<Gui::SharedStateButton>("Widget");
MyGUI::FactoryManager::getInstance().registerFactory<Gui::WindowCaption>("Widget");
}
}
| 1,528
|
C++
|
.cpp
| 28
| 48.964286
| 95
| 0.734448
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| true
| false
|
34,605
|
windowcaption.cpp
|
OpenMW_openmw/components/widgets/windowcaption.cpp
|
#include "windowcaption.hpp"
#include <stdexcept>
namespace Gui
{
WindowCaption::WindowCaption()
: mLeft(nullptr)
, mRight(nullptr)
, mClient(nullptr)
{
}
void WindowCaption::initialiseOverride()
{
Base::initialiseOverride();
assignWidget(mLeft, "Left");
assignWidget(mRight, "Right");
assignWidget(mClient, "Client");
if (!mClient)
throw std::runtime_error("WindowCaption needs an EditBox Client widget in its skin");
}
void WindowCaption::setCaption(const MyGUI::UString& _value)
{
EditBox::setCaption(_value);
align();
}
void WindowCaption::setSize(const MyGUI::IntSize& _value)
{
Base::setSize(_value);
align();
}
void WindowCaption::setCoord(const MyGUI::IntCoord& _value)
{
Base::setCoord(_value);
align();
}
void WindowCaption::align()
{
MyGUI::IntSize textSize = getTextSize();
MyGUI::Widget* caption = mClient;
caption->setSize(textSize.width + 24, caption->getHeight());
int barwidth = (getWidth() - caption->getWidth()) / 2;
caption->setPosition(barwidth, caption->getTop());
if (mLeft)
mLeft->setCoord(0, mLeft->getTop(), barwidth, mLeft->getHeight());
if (mRight)
mRight->setCoord(barwidth + caption->getWidth(), mRight->getTop(), barwidth, mRight->getHeight());
}
}
| 1,468
|
C++
|
.cpp
| 47
| 24.106383
| 110
| 0.612491
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,606
|
imagebutton.cpp
|
OpenMW_openmw/components/widgets/imagebutton.cpp
|
#include "imagebutton.hpp"
#include <cmath>
#include <MyGUI_RenderManager.h>
#include <components/debug/debuglog.hpp>
namespace Gui
{
bool ImageButton::sDefaultNeedKeyFocus = true;
ImageButton::ImageButton()
: Base()
, mMouseFocus(false)
, mMousePress(false)
, mKeyFocus(false)
, mUseWholeTexture(true)
, mTextureRect(MyGUI::IntCoord(0, 0, 0, 0))
{
setNeedKeyFocus(sDefaultNeedKeyFocus);
}
void ImageButton::setDefaultNeedKeyFocus(bool enabled)
{
sDefaultNeedKeyFocus = enabled;
}
void ImageButton::setTextureRect(MyGUI::IntCoord coord)
{
mTextureRect = coord;
mUseWholeTexture = (coord == MyGUI::IntCoord(0, 0, 0, 0));
updateImage();
}
void ImageButton::setPropertyOverride(std::string_view _key, std::string_view _value)
{
if (_key == "ImageHighlighted")
mImageHighlighted = _value;
else if (_key == "ImagePushed")
mImagePushed = _value;
else if (_key == "ImageNormal")
{
if (mImageNormal.empty())
{
setImageTexture(_value);
}
mImageNormal = _value;
}
else if (_key == "TextureRect")
{
mTextureRect = MyGUI::IntCoord::parse(_value);
mUseWholeTexture = (mTextureRect == MyGUI::IntCoord(0, 0, 0, 0));
}
else
ImageBox::setPropertyOverride(_key, _value);
}
void ImageButton::onMouseSetFocus(Widget* _old)
{
mMouseFocus = true;
updateImage();
Base::onMouseSetFocus(_old);
}
void ImageButton::onMouseLostFocus(Widget* _new)
{
mMouseFocus = false;
updateImage();
Base::onMouseLostFocus(_new);
}
void ImageButton::onMouseButtonPressed(int _left, int _top, MyGUI::MouseButton _id)
{
if (_id == MyGUI::MouseButton::Left)
{
mMousePress = true;
updateImage();
}
Base::onMouseButtonPressed(_left, _top, _id);
}
void ImageButton::updateImage()
{
std::string textureName = mImageNormal;
if (mMousePress)
textureName = mImagePushed;
else if (mMouseFocus || mKeyFocus)
textureName = mImageHighlighted;
if (!mUseWholeTexture)
{
float scale = 1.f;
MyGUI::ITexture* texture = MyGUI::RenderManager::getInstance().getTexture(textureName);
if (texture && getHeight() != 0)
scale = static_cast<float>(texture->getHeight()) / getHeight();
const int width = static_cast<int>(std::round(mTextureRect.width * scale));
const int height = static_cast<int>(std::round(mTextureRect.height * scale));
setImageTile(MyGUI::IntSize(width, height));
MyGUI::IntCoord scaledSize(static_cast<int>(std::round(mTextureRect.left * scale)),
static_cast<int>(std::round(mTextureRect.top * scale)), width, height);
setImageCoord(scaledSize);
}
setImageTexture(textureName);
}
MyGUI::IntSize ImageButton::getRequestedSize()
{
MyGUI::ITexture* texture = MyGUI::RenderManager::getInstance().getTexture(mImageNormal);
if (!texture)
{
Log(Debug::Error) << "ImageButton: can't find image " << mImageNormal;
return MyGUI::IntSize(0, 0);
}
if (mUseWholeTexture)
return MyGUI::IntSize(texture->getWidth(), texture->getHeight());
return MyGUI::IntSize(mTextureRect.width, mTextureRect.height);
}
void ImageButton::setImage(const std::string& image)
{
size_t extpos = image.find_last_of('.');
std::string imageNoExt = image.substr(0, extpos);
std::string ext = image.substr(extpos);
mImageNormal = imageNoExt + "_idle" + ext;
mImageHighlighted = imageNoExt + "_over" + ext;
mImagePushed = imageNoExt + "_pressed" + ext;
updateImage();
}
void ImageButton::onMouseButtonReleased(int _left, int _top, MyGUI::MouseButton _id)
{
if (_id == MyGUI::MouseButton::Left)
{
mMousePress = false;
updateImage();
}
Base::onMouseButtonReleased(_left, _top, _id);
}
void ImageButton::onKeySetFocus(MyGUI::Widget* _old)
{
mKeyFocus = true;
updateImage();
}
void ImageButton::onKeyLostFocus(MyGUI::Widget* _new)
{
mKeyFocus = false;
updateImage();
}
}
| 4,590
|
C++
|
.cpp
| 134
| 25.708955
| 99
| 0.595394
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,607
|
tags.cpp
|
OpenMW_openmw/components/widgets/tags.cpp
|
#include "tags.hpp"
#include <components/fallback/fallback.hpp>
#include <MyGUI_Colour.h>
namespace Gui
{
bool replaceTag(std::string_view tag, MyGUI::UString& out)
{
std::string_view fontcolour = "fontcolour=";
std::string_view fontcolourhtml = "fontcolourhtml=";
if (tag.starts_with(fontcolour))
{
std::string fallbackName = "FontColor_color_";
fallbackName += tag.substr(fontcolour.length());
std::string_view str = Fallback::Map::getString(fallbackName);
if (str.empty())
throw std::runtime_error("Unknown fallback name: " + fallbackName);
std::string ret[3];
unsigned int j = 0;
for (unsigned int i = 0; i < str.length(); ++i)
{
if (str[i] == ',')
j++;
else if (str[i] != ' ')
ret[j] += str[i];
}
MyGUI::Colour col(MyGUI::utility::parseInt(ret[0]) / 255.f, MyGUI::utility::parseInt(ret[1]) / 255.f,
MyGUI::utility::parseInt(ret[2]) / 255.f);
out = col.print();
return true;
}
else if (tag.starts_with(fontcolourhtml))
{
std::string fallbackName = "FontColor_color_";
fallbackName += tag.substr(fontcolourhtml.length());
std::string_view str = Fallback::Map::getString(fallbackName);
if (str.empty())
throw std::runtime_error("Unknown fallback name: " + fallbackName);
std::string ret[3];
unsigned int j = 0;
for (unsigned int i = 0; i < str.length(); ++i)
{
if (str[i] == ',')
j++;
else if (str[i] != ' ')
ret[j] += str[i];
}
std::stringstream html;
html << "#" << std::hex << MyGUI::utility::parseInt(ret[0]) << MyGUI::utility::parseInt(ret[1])
<< MyGUI::utility::parseInt(ret[2]);
out = html.str();
return true;
}
return false;
}
}
| 2,141
|
C++
|
.cpp
| 55
| 26.981818
| 113
| 0.496389
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,608
|
list.cpp
|
OpenMW_openmw/components/widgets/list.cpp
|
#include "list.hpp"
#include <MyGUI_Button.h>
#include <MyGUI_Gui.h>
#include <MyGUI_ImageBox.h>
#include <components/misc/strings/algorithm.hpp>
namespace Gui
{
MWList::MWList()
: mScrollView(nullptr)
, mClient(nullptr)
, mItemHeight(0)
{
}
void MWList::initialiseOverride()
{
Base::initialiseOverride();
assignWidget(mClient, "Client");
if (mClient == nullptr)
mClient = this;
mScrollView
= mClient->createWidgetReal<MyGUI::ScrollView>("MW_ScrollView", MyGUI::FloatCoord(0.0, 0.0, 1.0, 1.0),
MyGUI::Align::Top | MyGUI::Align::Left | MyGUI::Align::Stretch, getName() + "_ScrollView");
}
void MWList::addItem(std::string_view name)
{
mItems.emplace_back(name);
}
void MWList::addSeparator()
{
mItems.emplace_back(std::string{});
}
void MWList::adjustSize()
{
redraw();
}
void MWList::redraw(bool scrollbarShown)
{
constexpr int _scrollBarWidth = 20; // fetch this from skin?
const int scrollBarWidth = scrollbarShown ? _scrollBarWidth : 0;
constexpr int spacing = 3;
int viewPosition = -mScrollView->getViewOffset().top;
while (mScrollView->getChildCount())
{
MyGUI::Gui::getInstance().destroyWidget(mScrollView->getChildAt(0));
}
mItemHeight = 0;
int i = 0;
for (const auto& item : mItems)
{
if (!item.empty())
{
if (mListItemSkin.empty())
return;
MyGUI::Button* button = mScrollView->createWidget<MyGUI::Button>(mListItemSkin,
MyGUI::IntCoord(0, mItemHeight, mScrollView->getSize().width - scrollBarWidth - 2, 24),
MyGUI::Align::Left | MyGUI::Align::Top, getName() + "_item_" + item);
button->setCaption(item);
button->getSubWidgetText()->setWordWrap(true);
button->getSubWidgetText()->setTextAlign(MyGUI::Align::Left);
button->eventMouseWheel += MyGUI::newDelegate(this, &MWList::onMouseWheelMoved);
button->eventMouseButtonClick += MyGUI::newDelegate(this, &MWList::onItemSelected);
button->setNeedKeyFocus(true);
int height = button->getTextSize().height;
button->setSize(MyGUI::IntSize(button->getSize().width, height));
button->setUserData(i);
mItemHeight += height + spacing;
}
else
{
MyGUI::ImageBox* separator = mScrollView->createWidget<MyGUI::ImageBox>("MW_HLine",
MyGUI::IntCoord(2, mItemHeight, mScrollView->getWidth() - scrollBarWidth - 4, 18),
MyGUI::Align::Left | MyGUI::Align::Top | MyGUI::Align::HStretch);
separator->setNeedMouseFocus(false);
mItemHeight += 18 + spacing;
}
++i;
}
// Canvas size must be expressed with VScroll disabled, otherwise MyGUI would expand the scroll area when the
// scrollbar is hidden
mScrollView->setVisibleVScroll(false);
mScrollView->setCanvasSize(mClient->getSize().width, std::max(mItemHeight, mClient->getSize().height));
mScrollView->setVisibleVScroll(true);
if (!scrollbarShown && mItemHeight > mClient->getSize().height)
redraw(true);
int viewRange = mScrollView->getCanvasSize().height;
if (viewPosition > viewRange)
viewPosition = viewRange;
mScrollView->setViewOffset(MyGUI::IntPoint(0, -viewPosition));
}
void MWList::setPropertyOverride(std::string_view _key, std::string_view _value)
{
if (_key == "ListItemSkin")
mListItemSkin = _value;
else
Base::setPropertyOverride(_key, _value);
}
size_t MWList::getItemCount()
{
return mItems.size();
}
const std::string& MWList::getItemNameAt(size_t at)
{
assert(at < mItems.size() && "List item out of bounds");
return mItems[at];
}
void MWList::sort()
{
// A special case for separators is not needed for now
std::sort(mItems.begin(), mItems.end(), Misc::StringUtils::ciLess);
}
void MWList::removeItem(const std::string& name)
{
auto it = std::find(mItems.begin(), mItems.end(), name);
assert(it != mItems.end());
mItems.erase(it);
}
void MWList::clear()
{
mItems.clear();
}
void MWList::onMouseWheelMoved(MyGUI::Widget* _sender, int _rel)
{
// NB view offset is negative
if (mScrollView->getViewOffset().top + _rel * 0.3f > 0)
mScrollView->setViewOffset(MyGUI::IntPoint(0, 0));
else
mScrollView->setViewOffset(
MyGUI::IntPoint(0, static_cast<int>(mScrollView->getViewOffset().top + _rel * 0.3)));
}
void MWList::onItemSelected(MyGUI::Widget* _sender)
{
std::string name = _sender->castType<MyGUI::Button>()->getCaption();
int id = *_sender->getUserData<int>();
eventItemSelected(name, id);
eventWidgetSelected(_sender);
}
MyGUI::Button* MWList::getItemWidget(std::string_view name)
{
std::string search = getName() + "_item_";
search += name;
return mScrollView->findWidget(search)->castType<MyGUI::Button>();
}
void MWList::scrollToTop()
{
mScrollView->setViewOffset(MyGUI::IntPoint(0, 0));
}
}
| 5,613
|
C++
|
.cpp
| 147
| 28.959184
| 117
| 0.592238
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,609
|
multidircollection.cpp
|
OpenMW_openmw/components/files/multidircollection.cpp
|
#include "multidircollection.hpp"
#include "conversion.hpp"
#include <filesystem>
#include <components/debug/debuglog.hpp>
namespace Files
{
MultiDirCollection::MultiDirCollection(const Files::PathContainer& directories, const std::string& extension)
{
for (const auto& directory : directories)
{
if (!std::filesystem::is_directory(directory))
{
Log(Debug::Info) << "Skipping invalid directory: " << directory;
continue;
}
for (const auto& dirIter : std::filesystem::directory_iterator(directory))
{
const auto& path = dirIter.path();
if (!Misc::StringUtils::ciEqual(extension, Files::pathToUnicodeString(path.extension())))
continue;
const auto filename = Files::pathToUnicodeString(path.filename());
TIter result = mFiles.find(filename);
if (result == mFiles.end())
{
mFiles.insert(std::make_pair(filename, path));
}
else if (result->first == filename)
{
mFiles[filename] = path;
}
else
{
// handle case folding
mFiles.erase(result->first);
mFiles.insert(std::make_pair(filename, path));
}
}
}
}
std::filesystem::path MultiDirCollection::getPath(const std::string& file) const
{
TIter iter = mFiles.find(file);
if (iter == mFiles.end())
throw std::runtime_error("file " + file + " not found");
return iter->second;
}
bool MultiDirCollection::doesExist(const std::string& file) const
{
return mFiles.find(file) != mFiles.end();
}
MultiDirCollection::TIter MultiDirCollection::begin() const
{
return mFiles.begin();
}
MultiDirCollection::TIter MultiDirCollection::end() const
{
return mFiles.end();
}
}
| 2,094
|
C++
|
.cpp
| 59
| 24.474576
| 113
| 0.549505
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.