krageon
/
openmw-tes3coop
forked from teamnwah/openmw-tes3coop
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Don't rely on subrecord order when reading (Fixes #2361)

Browse Source
celladd
scrawl 10 years ago
parent bf1839b370
commit 9009889d24
17 changed files with 575 additions and 254 deletions
Show Stats Download Patch File Download Diff File

67
components/esm/aipackage.cpp
Unescape Escape View File

@ -11,36 +11,55 @@ namespace ESM
mServices = 0; mServices = 0;
} }
void AIPackageList::add(ESMReader &esm)
{
AIPackage pack;
if (esm.retSubName() == AI_CNDT) {
mList.back().mCellName = esm.getHString();
} else if (esm.retSubName() == AI_Wander) {
pack.mType = AI_Wander;
esm.getHExact(&pack.mWander, 14);
mList.push_back(pack);
} else if (esm.retSubName() == AI_Travel) {
pack.mType = AI_Travel;
esm.getHExact(&pack.mTravel, 16);
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.getHExact(&pack.mTarget, 48);
mList.push_back(pack);
} else if (esm.retSubName() == AI_Activate) {
pack.mType = AI_Activate;
esm.getHExact(&pack.mActivate, 33);
mList.push_back(pack);
} else { // not AI package related data, so leave
return;
}
}
void AIPackageList::load(ESMReader &esm) void AIPackageList::load(ESMReader &esm)
{ {
mList.clear(); mList.clear();
while (esm.hasMoreSubs()) { while (esm.hasMoreSubs()) {
// initialize every iteration // initialize every iteration
AIPackage pack; esm.getSubName();
esm.getSubName(); switch (esm.retSubName().val)
if (esm.retSubName() == 0x54444e43) { // CNDT
mList.back().mCellName = esm.getHString();
} else if (esm.retSubName() == AI_Wander) {
pack.mType = AI_Wander;
esm.getHExact(&pack.mWander, 14);
mList.push_back(pack);
} else if (esm.retSubName() == AI_Travel) {
pack.mType = AI_Travel;
esm.getHExact(&pack.mTravel, 16);
mList.push_back(pack);
} else if (esm.retSubName() == AI_Escort ||
esm.retSubName() == AI_Follow)
{ {
pack.mType = case AI_Wander:
(esm.retSubName() == AI_Escort) ? AI_Escort : AI_Follow; case AI_Activate:
esm.getHExact(&pack.mTarget, 48); case AI_Escort:
mList.push_back(pack); case AI_Follow:
} else if (esm.retSubName() == AI_Activate) { case AI_Travel:
pack.mType = AI_Activate; case AI_CNDT:
esm.getHExact(&pack.mActivate, 33);
mList.push_back(pack); add(esm);
} else { // not AI package related data, so leave break;
return; default:
return;
} }
} }
} }

12
components/esm/aipackage.hpp
Unescape Escape View File

@ -63,7 +63,8 @@ namespace ESM
AI_Travel = 0x545f4941, AI_Travel = 0x545f4941,
AI_Follow = 0x465f4941, AI_Follow = 0x465f4941,
AI_Escort = 0x455f4941, AI_Escort = 0x455f4941,
AI_Activate = 0x415f4941 AI_Activate = 0x415f4941,
AI_CNDT = 0x54444e43
}; };
/// \note Used for storaging packages in a single container /// \note Used for storaging packages in a single container
@ -90,11 +91,12 @@ namespace ESM
{ {
std::vector<AIPackage> mList; std::vector<AIPackage> mList;
/// \note This breaks consistency of subrecords reading: /// Add a single AIPackage, assumes subrecord name was already read
/// after calling it subrecord name is already read, so void add(ESMReader &esm);
/// it needs to use retSubName() if needed. But, hey, there
/// is only one field left (XSCL) and only two records uses AI /// TODO: remove this method. The ESM format does not guarantee that all AI packages follow one another
void load(ESMReader &esm); void load(ESMReader &esm);
void save(ESMWriter &esm) const; void save(ESMWriter &esm) const;
}; };
} }

101
components/esm/loadarmo.cpp
Unescape Escape View File

@ -7,52 +7,87 @@
namespace ESM namespace ESM
{ {
void PartReferenceList::load(ESMReader &esm) void PartReferenceList::add(ESMReader &esm)
{
mParts.clear();
while (esm.isNextSub("INDX"))
{ {
PartReference pr; PartReference pr;
esm.getHT(pr.mPart); // The INDX byte esm.getHT(pr.mPart); // The INDX byte
pr.mMale = esm.getHNOString("BNAM"); pr.mMale = esm.getHNOString("BNAM");
pr.mFemale = esm.getHNOString("CNAM"); pr.mFemale = esm.getHNOString("CNAM");
mParts.push_back(pr); mParts.push_back(pr);
} }
}
void PartReferenceList::save(ESMWriter &esm) const void PartReferenceList::load(ESMReader &esm)
{
for (std::vector<PartReference>::const_iterator it = mParts.begin(); it != mParts.end(); ++it)
{ {
esm.writeHNT("INDX", it->mPart); mParts.clear();
esm.writeHNOString("BNAM", it->mMale); while (esm.isNextSub("INDX"))
esm.writeHNOString("CNAM", it->mFemale); {
add(esm);
}
} }
}
unsigned int Armor::sRecordId = REC_ARMO; 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.writeHNOString("BNAM", it->mMale);
esm.writeHNOString("CNAM", it->mFemale);
}
}
void Armor::load(ESMReader &esm) unsigned int Armor::sRecordId = REC_ARMO;
{
mModel = esm.getHNString("MODL");
mName = esm.getHNOString("FNAM");
mScript = esm.getHNOString("SCRI");
esm.getHNT(mData, "AODT", 24);
mIcon = esm.getHNOString("ITEX");
mParts.load(esm);
mEnchant = esm.getHNOString("ENAM");
}
void Armor::save(ESMWriter &esm) const void Armor::load(ESMReader &esm)
{ {
esm.writeHNCString("MODL", mModel); mParts.mParts.clear();
esm.writeHNOCString("FNAM", mName); bool hasData = false;
esm.writeHNOCString("SCRI", mScript); while (esm.hasMoreSubs())
esm.writeHNT("AODT", mData, 24); {
esm.writeHNOCString("ITEX", mIcon); esm.getSubName();
mParts.save(esm); uint32_t name = esm.retSubName().val;
esm.writeHNOCString("ENAM", mEnchant); switch (name)
} {
case ESM::FourCC<'M','O','D','L'>::value:
mModel = esm.getHString();
break;
case ESM::FourCC<'F','N','A','M'>::value:
mName = esm.getHString();
break;
case ESM::FourCC<'A','O','D','T'>::value:
esm.getHT(mData, 24);
hasData = true;
break;
case ESM::FourCC<'S','C','R','I'>::value:
mScript = esm.getHString();
break;
case ESM::FourCC<'I','T','E','X'>::value:
mIcon = esm.getHString();
break;
case ESM::FourCC<'E','N','A','M'>::value:
mEnchant = esm.getHString();
break;
case ESM::FourCC<'I','N','D','X'>::value:
mParts.add(esm);
break;
default:
esm.fail("Unknown subrecord");
}
}
if (!hasData)
esm.fail("Missing CTDT subrecord");
}
void Armor::save(ESMWriter &esm) const
{
esm.writeHNCString("MODL", mModel);
esm.writeHNOCString("FNAM", mName);
esm.writeHNOCString("SCRI", mScript);
esm.writeHNT("AODT", mData, 24);
esm.writeHNOCString("ITEX", mIcon);
mParts.save(esm);
esm.writeHNOCString("ENAM", mEnchant);
}
void Armor::blank() void Armor::blank()
{ {

4
components/esm/loadarmo.hpp
Unescape Escape View File

@ -55,6 +55,10 @@ struct PartReferenceList
{ {
std::vector<PartReference> mParts; std::vector<PartReference> mParts;
/// Load one part, assumes the subrecord name was already read
void add(ESMReader &esm);
/// TODO: remove this method. The ESM format does not guarantee that all Part subrecords follow one another.
void load(ESMReader &esm); void load(ESMReader &esm);
void save(ESMWriter &esm) const; void save(ESMWriter &esm) const;
}; };

68
components/esm/loadbook.cpp
Unescape Escape View File

@ -8,26 +8,54 @@ namespace ESM
{ {
unsigned int Book::sRecordId = REC_BOOK; unsigned int Book::sRecordId = REC_BOOK;
void Book::load(ESMReader &esm) void Book::load(ESMReader &esm)
{ {
mModel = esm.getHNString("MODL"); bool hasData = false;
mName = esm.getHNOString("FNAM"); while (esm.hasMoreSubs())
esm.getHNT(mData, "BKDT", 20); {
mScript = esm.getHNOString("SCRI"); esm.getSubName();
mIcon = esm.getHNOString("ITEX"); uint32_t name = esm.retSubName().val;
mText = esm.getHNOString("TEXT"); switch (name)
mEnchant = esm.getHNOString("ENAM"); {
} case ESM::FourCC<'M','O','D','L'>::value:
void Book::save(ESMWriter &esm) const mModel = esm.getHString();
{ break;
esm.writeHNCString("MODL", mModel); case ESM::FourCC<'F','N','A','M'>::value:
esm.writeHNOCString("FNAM", mName); mName = esm.getHString();
esm.writeHNT("BKDT", mData, 20); break;
esm.writeHNOCString("SCRI", mScript); case ESM::FourCC<'B','K','D','T'>::value:
esm.writeHNOCString("ITEX", mIcon); esm.getHT(mData, 20);
esm.writeHNOString("TEXT", mText); hasData = true;
esm.writeHNOCString("ENAM", mEnchant); break;
} case ESM::FourCC<'S','C','R','I'>::value:
mScript = esm.getHString();
break;
case ESM::FourCC<'I','T','E','X'>::value:
mIcon = esm.getHString();
break;
case ESM::FourCC<'E','N','A','M'>::value:
mEnchant = esm.getHString();
break;
case ESM::FourCC<'T','E','X','T'>::value:
mText = esm.getHString();
break;
default:
esm.fail("Unknown subrecord");
}
}
if (!hasData)
esm.fail("Missing BKDT subrecord");
}
void Book::save(ESMWriter &esm) const
{
esm.writeHNCString("MODL", mModel);
esm.writeHNOCString("FNAM", mName);
esm.writeHNT("BKDT", mData, 20);
esm.writeHNOCString("SCRI", mScript);
esm.writeHNOCString("ITEX", mIcon);
esm.writeHNOString("TEXT", mText);
esm.writeHNOCString("ENAM", mEnchant);
}
void Book::blank() void Book::blank()
{ {

47
components/esm/loadclot.cpp
Unescape Escape View File

@ -10,17 +10,42 @@ namespace ESM
void Clothing::load(ESMReader &esm) void Clothing::load(ESMReader &esm)
{ {
mModel = esm.getHNString("MODL"); mParts.mParts.clear();
mName = esm.getHNOString("FNAM"); bool hasData = false;
esm.getHNT(mData, "CTDT", 12); while (esm.hasMoreSubs())
{
mScript = esm.getHNOString("SCRI"); esm.getSubName();
mIcon = esm.getHNOString("ITEX"); uint32_t name = esm.retSubName().val;
switch (name)
mParts.load(esm); {
case ESM::FourCC<'M','O','D','L'>::value:
mModel = esm.getHString();
mEnchant = esm.getHNOString("ENAM"); break;
case ESM::FourCC<'F','N','A','M'>::value:
mName = esm.getHString();
break;
case ESM::FourCC<'C','T','D','T'>::value:
esm.getHT(mData, 12);
hasData = true;
break;
case ESM::FourCC<'S','C','R','I'>::value:
mScript = esm.getHString();
break;
case ESM::FourCC<'I','T','E','X'>::value:
mIcon = esm.getHString();
break;
case ESM::FourCC<'E','N','A','M'>::value:
mEnchant = esm.getHString();
break;
case ESM::FourCC<'I','N','D','X'>::value:
mParts.add(esm);
break;
default:
esm.fail("Unknown subrecord");
}
}
if (!hasData)
esm.fail("Missing CTDT subrecord");
} }
void Clothing::save(ESMWriter &esm) const void Clothing::save(ESMWriter &esm) const

11
components/esm/loadcont.cpp
Unescape Escape View File

@ -7,14 +7,19 @@
namespace ESM namespace ESM
{ {
void InventoryList::add(ESMReader &esm)
{
ContItem ci;
esm.getHT(ci, 36);
mList.push_back(ci);
}
void InventoryList::load(ESMReader &esm) void InventoryList::load(ESMReader &esm)
{ {
mList.clear(); mList.clear();
ContItem ci;
while (esm.isNextSub("NPCO")) while (esm.isNextSub("NPCO"))
{ {
esm.getHT(ci, 36); add(esm);
mList.push_back(ci);
} }
} }

4
components/esm/loadcont.hpp
Unescape Escape View File

@ -26,6 +26,10 @@ struct InventoryList
{ {
std::vector<ContItem> mList; std::vector<ContItem> mList;
/// Load one item, assumes subrecord name is already read
void add(ESMReader &esm);
/// TODO: remove this method, the ESM format doesn't guarantee that all ContItems follow one another
void load(ESMReader &esm); void load(ESMReader &esm);
void save(ESMWriter &esm) const; void save(ESMWriter &esm) const;
}; };

52
components/esm/loaddoor.cpp
Unescape Escape View File

@ -8,23 +8,43 @@ namespace ESM
{ {
unsigned int Door::sRecordId = REC_DOOR; unsigned int Door::sRecordId = REC_DOOR;
void Door::load(ESMReader &esm) void Door::load(ESMReader &esm)
{ {
mModel = esm.getHNString("MODL"); while (esm.hasMoreSubs())
mName = esm.getHNOString("FNAM"); {
mScript = esm.getHNOString("SCRI"); esm.getSubName();
mOpenSound = esm.getHNOString("SNAM"); uint32_t name = esm.retSubName().val;
mCloseSound = esm.getHNOString("ANAM"); switch (name)
} {
case ESM::FourCC<'M','O','D','L'>::value:
mModel = esm.getHString();
break;
case ESM::FourCC<'F','N','A','M'>::value:
mName = esm.getHString();
break;
case ESM::FourCC<'S','C','R','I'>::value:
mScript = esm.getHString();
break;
case ESM::FourCC<'S','N','A','M'>::value:
mOpenSound = esm.getHString();
break;
case ESM::FourCC<'A','N','A','M'>::value:
mCloseSound = esm.getHString();
break;
default:
esm.fail("Unknown subrecord");
}
}
}
void Door::save(ESMWriter &esm) const void Door::save(ESMWriter &esm) const
{ {
esm.writeHNCString("MODL", mModel); esm.writeHNCString("MODL", mModel);
esm.writeHNOCString("FNAM", mName); esm.writeHNOCString("FNAM", mName);
esm.writeHNOCString("SCRI", mScript); esm.writeHNOCString("SCRI", mScript);
esm.writeHNOCString("SNAM", mOpenSound); esm.writeHNOCString("SNAM", mOpenSound);
esm.writeHNOCString("ANAM", mCloseSound); esm.writeHNOCString("ANAM", mCloseSound);
} }
void Door::blank() void Door::blank()
{ {

75
components/esm/loadmgef.cpp
Unescape Escape View File

@ -191,33 +191,64 @@ namespace ESM
void MagicEffect::load(ESMReader &esm) void MagicEffect::load(ESMReader &esm)
{ {
esm.getHNT(mIndex, "INDX"); esm.getHNT(mIndex, "INDX");
mId = indexToId (mIndex); mId = indexToId (mIndex);
esm.getHNT(mData, "MEDT", 36); esm.getHNT(mData, "MEDT", 36);
if (esm.getFormat() == 0) if (esm.getFormat() == 0)
{ {
// don't allow mods to change fixed flags in the legacy format // don't allow mods to change fixed flags in the legacy format
mData.mFlags &= (AllowSpellmaking | AllowEnchanting | NegativeLight); mData.mFlags &= (AllowSpellmaking | AllowEnchanting | NegativeLight);
if (mIndex>=0 && mIndex<NumberOfHardcodedFlags) if (mIndex>=0 && mIndex<NumberOfHardcodedFlags)
mData.mFlags |= HardcodedFlags[mIndex]; mData.mFlags |= HardcodedFlags[mIndex];
} }
mIcon = esm.getHNOString("ITEX");
mParticle = esm.getHNOString("PTEX");
mBoltSound = esm.getHNOString("BSND");
mCastSound = esm.getHNOString("CSND");
mHitSound = esm.getHNOString("HSND");
mAreaSound = esm.getHNOString("ASND");
mCasting = esm.getHNOString("CVFX");
mBolt = esm.getHNOString("BVFX");
mHit = esm.getHNOString("HVFX");
mArea = esm.getHNOString("AVFX");
mDescription = esm.getHNOString("DESC"); // 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();
uint32_t name = esm.retSubName().val;
switch (name)
{
case ESM::FourCC<'I','T','E','X'>::value:
mIcon = esm.getHString();
break;
case ESM::FourCC<'P','T','E','X'>::value:
mParticle = esm.getHString();
break;
case ESM::FourCC<'B','S','N','D'>::value:
mBoltSound = esm.getHString();
break;
case ESM::FourCC<'C','S','N','D'>::value:
mCastSound = esm.getHString();
break;
case ESM::FourCC<'H','S','N','D'>::value:
mHitSound = esm.getHString();
break;
case ESM::FourCC<'A','S','N','D'>::value:
mAreaSound = esm.getHString();
break;
case ESM::FourCC<'C','V','F','X'>::value:
mCasting = esm.getHString();
break;
case ESM::FourCC<'B','V','F','X'>::value:
mBolt = esm.getHString();
break;
case ESM::FourCC<'H','V','F','X'>::value:
mHit = esm.getHString();
break;
case ESM::FourCC<'A','V','F','X'>::value:
mArea = esm.getHString();
break;
case ESM::FourCC<'D','E','S','C'>::value:
mDescription = esm.getHString();
break;
default:
esm.fail("Unknown subrecord " + esm.retSubName().toString());
}
}
} }
void MagicEffect::save(ESMWriter &esm) const void MagicEffect::save(ESMWriter &esm) const
{ {

55
components/esm/loadmisc.cpp
Unescape Escape View File

@ -8,22 +8,45 @@ namespace ESM
{ {
unsigned int Miscellaneous::sRecordId = REC_MISC; unsigned int Miscellaneous::sRecordId = REC_MISC;
void Miscellaneous::load(ESMReader &esm) void Miscellaneous::load(ESMReader &esm)
{ {
mModel = esm.getHNString("MODL"); bool hasData = false;
mName = esm.getHNOString("FNAM"); while (esm.hasMoreSubs())
esm.getHNT(mData, "MCDT", 12); {
mScript = esm.getHNOString("SCRI"); esm.getSubName();
mIcon = esm.getHNOString("ITEX"); uint32_t name = esm.retSubName().val;
} switch (name)
void Miscellaneous::save(ESMWriter &esm) const {
{ case ESM::FourCC<'M','O','D','L'>::value:
esm.writeHNCString("MODL", mModel); mModel = esm.getHString();
esm.writeHNOCString("FNAM", mName); break;
esm.writeHNT("MCDT", mData, 12); case ESM::FourCC<'F','N','A','M'>::value:
esm.writeHNOCString("SCRI", mScript); mName = esm.getHString();
esm.writeHNOCString("ITEX", mIcon); break;
} case ESM::FourCC<'M','C','D','T'>::value:
esm.getHT(mData, 12);
hasData = true;
break;
case ESM::FourCC<'S','C','R','I'>::value:
mScript = esm.getHString();
break;
case ESM::FourCC<'I','T','E','X'>::value:
mIcon = esm.getHString();
break;
}
}
if (!hasData)
esm.fail("Missing MCDT subrecord");
}
void Miscellaneous::save(ESMWriter &esm) const
{
esm.writeHNCString("MODL", mModel);
esm.writeHNOCString("FNAM", mName);
esm.writeHNT("MCDT", mData, 12);
esm.writeHNOCString("SCRI", mScript);
esm.writeHNOCString("ITEX", mIcon);
}
void Miscellaneous::blank() void Miscellaneous::blank()
{ {

200
components/esm/loadnpc.cpp
Unescape Escape View File

@ -8,92 +8,136 @@ namespace ESM
{ {
unsigned int NPC::sRecordId = REC_NPC_; unsigned int NPC::sRecordId = REC_NPC_;
void NPC::load(ESMReader &esm) void NPC::load(ESMReader &esm)
{
mPersistent = esm.getRecordFlags() & 0x0400;
mModel = esm.getHNOString("MODL");
mName = esm.getHNOString("FNAM");
mRace = esm.getHNString("RNAM");
mClass = esm.getHNString("CNAM");
mFaction = esm.getHNString("ANAM");
mHead = esm.getHNString("BNAM");
mHair = esm.getHNString("KNAM");
mScript = esm.getHNOString("SCRI");
esm.getSubNameIs("NPDT");
esm.getSubHeader();
if (esm.getSubSize() == 52)
{
mNpdtType = NPC_DEFAULT;
esm.getExact(&mNpdt52, 52);
}
else if (esm.getSubSize() == 12)
{ {
mNpdtType = NPC_WITH_AUTOCALCULATED_STATS; mPersistent = esm.getRecordFlags() & 0x0400;
esm.getExact(&mNpdt12, 12);
}
else
esm.fail("NPC_NPDT must be 12 or 52 bytes long");
esm.getHNT(mFlags, "FLAG");
mInventory.load(esm); mSpells.mList.clear();
mSpells.load(esm); mInventory.mList.clear();
mTransport.clear();
mAiPackage.mList.clear();
if (esm.isNextSub("AIDT")) bool hasNpdt = false;
{ bool hasFlags = false;
esm.getHExact(&mAiData, sizeof(mAiData));
mHasAI= true;
}
else
mHasAI = false; mHasAI = false;
while (esm.hasMoreSubs())
mTransport.clear(); {
while (esm.isNextSub("DODT") || esm.isNextSub("DNAM")) { esm.getSubName();
if (esm.retSubName() == 0x54444f44) { // DODT struct uint32_t name = esm.retSubName().val;
Dest dodt; switch (name)
esm.getHExact(&dodt.mPos, 24); {
mTransport.push_back(dodt); case ESM::FourCC<'M','O','D','L'>::value:
} else if (esm.retSubName() == 0x4d414e44) { // DNAM struct mModel = esm.getHString();
mTransport.back().mCellName = esm.getHString(); break;
case ESM::FourCC<'F','N','A','M'>::value:
mName = esm.getHString();
break;
case ESM::FourCC<'R','N','A','M'>::value:
mRace = esm.getHString();
break;
case ESM::FourCC<'C','N','A','M'>::value:
mClass = esm.getHString();
break;
case ESM::FourCC<'A','N','A','M'>::value:
mFaction = esm.getHString();
break;
case ESM::FourCC<'B','N','A','M'>::value:
mHead = esm.getHString();
break;
case ESM::FourCC<'K','N','A','M'>::value:
mHair = esm.getHString();
break;
case ESM::FourCC<'S','C','R','I'>::value:
mScript = esm.getHString();
break;
case ESM::FourCC<'N','P','D','T'>::value:
hasNpdt = true;
esm.getSubHeader();
if (esm.getSubSize() == 52)
{
mNpdtType = NPC_DEFAULT;
esm.getExact(&mNpdt52, 52);
}
else if (esm.getSubSize() == 12)
{
mNpdtType = NPC_WITH_AUTOCALCULATED_STATS;
esm.getExact(&mNpdt12, 12);
}
else
esm.fail("NPC_NPDT must be 12 or 52 bytes long");
break;
case ESM::FourCC<'F','L','A','G'>::value:
hasFlags = true;
esm.getHT(mFlags);
break;
case ESM::FourCC<'N','P','C','S'>::value:
mSpells.add(esm);
break;
case ESM::FourCC<'N','P','C','O'>::value:
mInventory.add(esm);
break;
case ESM::FourCC<'A','I','D','T'>::value:
esm.getHExact(&mAiData, sizeof(mAiData));
mHasAI= true;
break;
case ESM::FourCC<'D','O','D','T'>::value:
{
Dest dodt;
esm.getHExact(&dodt.mPos, 24);
mTransport.push_back(dodt);
break;
}
case ESM::FourCC<'D','N','A','M'>::value:
mTransport.back().mCellName = esm.getHString();
break;
case AI_Wander:
case AI_Activate:
case AI_Escort:
case AI_Follow:
case AI_Travel:
case AI_CNDT:
mAiPackage.add(esm);
break;
default:
esm.fail("Unknown subrecord " + esm.retSubName().toString());
}
} }
if (!hasNpdt)
esm.fail("Missing NPDT subrecord");
if (!hasFlags)
esm.fail("Missing FLAG subrecord");
} }
mAiPackage.load(esm); void NPC::save(ESMWriter &esm) const
} {
void NPC::save(ESMWriter &esm) const esm.writeHNOCString("MODL", mModel);
{ esm.writeHNOCString("FNAM", mName);
esm.writeHNOCString("MODL", mModel); esm.writeHNCString("RNAM", mRace);
esm.writeHNOCString("FNAM", mName); esm.writeHNCString("CNAM", mClass);
esm.writeHNCString("RNAM", mRace); esm.writeHNCString("ANAM", mFaction);
esm.writeHNCString("CNAM", mClass); esm.writeHNCString("BNAM", mHead);
esm.writeHNCString("ANAM", mFaction); esm.writeHNCString("KNAM", mHair);
esm.writeHNCString("BNAM", mHead); esm.writeHNOCString("SCRI", mScript);
esm.writeHNCString("KNAM", mHair);
esm.writeHNOCString("SCRI", mScript); if (mNpdtType == NPC_DEFAULT)
esm.writeHNT("NPDT", mNpdt52, 52);
if (mNpdtType == NPC_DEFAULT) else if (mNpdtType == NPC_WITH_AUTOCALCULATED_STATS)
esm.writeHNT("NPDT", mNpdt52, 52); esm.writeHNT("NPDT", mNpdt12, 12);
else if (mNpdtType == NPC_WITH_AUTOCALCULATED_STATS)
esm.writeHNT("NPDT", mNpdt12, 12); esm.writeHNT("FLAG", mFlags);
esm.writeHNT("FLAG", mFlags); mInventory.save(esm);
mSpells.save(esm);
mInventory.save(esm); if (mHasAI) {
mSpells.save(esm); esm.writeHNT("AIDT", mAiData, sizeof(mAiData));
if (mHasAI) { }
esm.writeHNT("AIDT", mAiData, sizeof(mAiData));
}
typedef std::vector<Dest>::const_iterator DestIter; typedef std::vector<Dest>::const_iterator DestIter;
for (DestIter it = mTransport.begin(); it != mTransport.end(); ++it) { for (DestIter it = mTransport.begin(); it != mTransport.end(); ++it) {
esm.writeHNT("DODT", it->mPos, sizeof(it->mPos)); esm.writeHNT("DODT", it->mPos, sizeof(it->mPos));
esm.writeHNOCString("DNAM", it->mCellName); esm.writeHNOCString("DNAM", it->mCellName);
}
mAiPackage.save(esm);
} }
mAiPackage.save(esm);
}
bool NPC::isMale() const { bool NPC::isMale() const {
return (mFlags & Female) == 0; return (mFlags & Female) == 0;

32
components/esm/loadrace.cpp
Unescape Escape View File

@ -20,10 +20,34 @@ namespace ESM
void Race::load(ESMReader &esm) void Race::load(ESMReader &esm)
{ {
mName = esm.getHNOString("FNAM"); mPowers.mList.clear();
esm.getHNT(mData, "RADT", 140);
mPowers.load(esm); bool hasData = false;
mDescription = esm.getHNOString("DESC"); while (esm.hasMoreSubs())
{
esm.getSubName();
uint32_t name = esm.retSubName().val;
switch (name)
{
case ESM::FourCC<'F','N','A','M'>::value:
mName = esm.getHString();
break;
case ESM::FourCC<'R','A','D','T'>::value:
esm.getHT(mData, 140);
hasData = true;
break;
case ESM::FourCC<'D','E','S','C'>::value:
mDescription = esm.getHString();
break;
case ESM::FourCC<'N','P','C','S'>::value:
mPowers.add(esm);
break;
default:
esm.fail("Unknown subrecord " + esm.retSubName().toString());
}
}
if (!hasData)
esm.fail("Missing RADT subrecord");
} }
void Race::save(ESMWriter &esm) const void Race::save(ESMWriter &esm) const
{ {

27
components/esm/loadspel.cpp
Unescape Escape View File

@ -10,9 +10,30 @@ namespace ESM
void Spell::load(ESMReader &esm) void Spell::load(ESMReader &esm)
{ {
mName = esm.getHNOString("FNAM"); bool hasData = false;
esm.getHNT(mData, "SPDT", 12); while (esm.hasMoreSubs())
mEffects.load(esm); {
esm.getSubName();
uint32_t val = esm.retSubName().val;
switch (val)
{
case ESM::FourCC<'F','N','A','M'>::value:
mName = esm.getHString();
break;
case ESM::FourCC<'S','P','D','T'>::value:
esm.getHT(mData, 12);
hasData = true;
break;
case ESM::FourCC<'E','N','A','M'>::value:
ENAMstruct s;
esm.getHT(s, 24);
mEffects.mList.push_back(s);
break;
}
}
if (!hasData)
esm.fail("Missing SPDT subrecord");
} }
void Spell::save(ESMWriter &esm) const void Spell::save(ESMWriter &esm) const

62
components/esm/loadweap.cpp
Unescape Escape View File

@ -8,24 +8,50 @@ namespace ESM
{ {
unsigned int Weapon::sRecordId = REC_WEAP; unsigned int Weapon::sRecordId = REC_WEAP;
void Weapon::load(ESMReader &esm) void Weapon::load(ESMReader &esm)
{ {
mModel = esm.getHNString("MODL"); bool hasData = false;
mName = esm.getHNOString("FNAM"); while (esm.hasMoreSubs())
esm.getHNT(mData, "WPDT", 32); {
mScript = esm.getHNOString("SCRI"); esm.getSubName();
mIcon = esm.getHNOString("ITEX"); uint32_t name = esm.retSubName().val;
mEnchant = esm.getHNOString("ENAM"); switch (name)
} {
void Weapon::save(ESMWriter &esm) const case ESM::FourCC<'M','O','D','L'>::value:
{ mModel = esm.getHString();
esm.writeHNCString("MODL", mModel); break;
esm.writeHNOCString("FNAM", mName); case ESM::FourCC<'F','N','A','M'>::value:
esm.writeHNT("WPDT", mData, 32); mName = esm.getHString();
esm.writeHNOCString("SCRI", mScript); break;
esm.writeHNOCString("ITEX", mIcon); case ESM::FourCC<'W','P','D','T'>::value:
esm.writeHNOCString("ENAM", mEnchant); esm.getHT(mData, 32);
} hasData = true;
break;
case ESM::FourCC<'S','C','R','I'>::value:
mScript = esm.getHString();
break;
case ESM::FourCC<'I','T','E','X'>::value:
mIcon = esm.getHString();
break;
case ESM::FourCC<'E','N','A','M'>::value:
mEnchant = esm.getHString();
break;
default:
esm.fail("Unknown subrecord");
}
}
if (!hasData)
esm.fail("Missing WPDT subrecord");
}
void Weapon::save(ESMWriter &esm) const
{
esm.writeHNCString("MODL", mModel);
esm.writeHNOCString("FNAM", mName);
esm.writeHNT("WPDT", mData, 32);
esm.writeHNOCString("SCRI", mScript);
esm.writeHNOCString("ITEX", mIcon);
esm.writeHNOCString("ENAM", mEnchant);
}
void Weapon::blank() void Weapon::blank()
{ {

7
components/esm/spelllist.cpp
Unescape Escape View File

@ -9,10 +9,15 @@ void SpellList::load(ESMReader &esm)
{ {
mList.clear(); mList.clear();
while (esm.isNextSub("NPCS")) { while (esm.isNextSub("NPCS")) {
mList.push_back(esm.getHString()); add(esm);
} }
} }
void SpellList::add(ESMReader &esm)
{
mList.push_back(esm.getHString());
}
void SpellList::save(ESMWriter &esm) const void SpellList::save(ESMWriter &esm) const
{ {
for (std::vector<std::string>::const_iterator it = mList.begin(); it != mList.end(); ++it) { for (std::vector<std::string>::const_iterator it = mList.begin(); it != mList.end(); ++it) {

5
components/esm/spelllist.hpp
Unescape Escape View File

@ -19,6 +19,11 @@ namespace ESM
/// Is this spell ID in mList? /// Is this spell ID in mList?
bool exists(const std::string& spell) const; bool exists(const std::string& spell) const;
/// Load one spell, assumes the subrecord name was already read
void add(ESMReader &esm);
/// Load all spells
/// TODO: remove this method, the ESM format doesn't guarantee that all spell subrecords follow one another
void load(ESMReader &esm); void load(ESMReader &esm);
void save(ESMWriter &esm) const; void save(ESMWriter &esm) const;
}; };

Write Preview
Loading…
Cancel
Save