More ESM records have DELE handling.

Changed records: Race, Land, Pathgrid, StartScript, DebugProfile, Filter

components/esm/debugprofile.cpp

@@ -7,17 +7,53 @@
 
 unsigned int ESM::DebugProfile::sRecordId = REC_DBGP;
 
+ESM::DebugProfile::DebugProfile()
+    : mIsDeleted(false)
+{}
+
 void ESM::DebugProfile::load (ESMReader& esm)
 {
-    mId = esm.getHNString ("NAME");
+    mIsDeleted = false;
-    mDescription = esm.getHNString ("DESC");
+
-    mScriptText = esm.getHNString ("SCRP");
+    while (esm.hasMoreSubs())
-    esm.getHNT (mFlags, "FLAG");
+    {
+        esm.getSubName();
+        uint32_t name = esm.retSubName().val;
+        switch (name)
+        {
+            case ESM::FourCC<'N','A','M','E'>::value:
+                mId = esm.getHString();
+                break;
+            case ESM::FourCC<'D','E','L','E'>::value:
+                esm.skipHSub();
+                mIsDeleted = true;
+                break;
+            case ESM::FourCC<'D','E','S','C'>::value:
+                mDescription = esm.getHString();
+                break;
+            case ESM::FourCC<'S','C','R','P'>::value:
+                mScriptText = esm.getHString();
+                break;
+            case ESM::FourCC<'F','L','A','G'>::value:
+                esm.getHT(mFlags);
+                break;
+            default:
+                esm.fail("Unknown subrecord");
+                break;
+        }
+    }
 }
 
 void ESM::DebugProfile::save (ESMWriter& esm) const
 {
     esm.writeHNCString ("NAME", mId);
+
+    if (mIsDeleted)
+    {
+        esm.writeHNCString("DELE", "");
+        return;
+    }
+
     esm.writeHNCString ("DESC", mDescription);
     esm.writeHNCString ("SCRP", mScriptText);
     esm.writeHNT ("FLAG", mFlags);
@@ -28,4 +64,5 @@ void ESM::DebugProfile::blank()
     mDescription.clear();
     mScriptText.clear();
     mFlags = 0;
+    mIsDeleted = false;
 }

components/esm/debugprofile.hpp

@@ -27,6 +27,10 @@ namespace ESM
 
         unsigned int mFlags;
 
+        bool mIsDeleted;
+
+        DebugProfile();
+
         void load (ESMReader& esm);
         void save (ESMWriter& esm) const;
 

components/esm/filter.cpp

@@ -7,16 +7,50 @@
 
 unsigned int ESM::Filter::sRecordId = REC_FILT;
 
+ESM::Filter::Filter()
+    : mIsDeleted(false)
+{}
+
 void ESM::Filter::load (ESMReader& esm)
 {
-    mId = esm.getHNString ("NAME");
+    mIsDeleted = false;
-    mFilter = esm.getHNString ("FILT");
+
-    mDescription = esm.getHNString ("DESC");
+    while (esm.hasMoreSubs())
+    {
+        esm.getSubName();
+        uint32_t name = esm.retSubName().val;
+        switch (name)
+        {
+            case ESM::FourCC<'N','A','M','E'>::value:
+                mId = esm.getHString();
+                break;
+            case ESM::FourCC<'D','E','L','E'>::value:
+                esm.skipHSub();
+                mIsDeleted = true;
+                break;
+            case ESM::FourCC<'F','I','L','T'>::value:
+                mFilter = esm.getHString();
+                break;
+            case ESM::FourCC<'D','E','S','C'>::value:
+                mDescription = esm.getHString();
+                break;
+            default:
+                esm.fail("Unknown subrecord");
+                break;
+        }
+    }
 }
 
 void ESM::Filter::save (ESMWriter& esm) const
 {
     esm.writeHNCString ("NAME", mId);
+
+    if (mIsDeleted)
+    {
+        esm.writeHNCString("DELE", "");
+        return;
+    }
+
     esm.writeHNCString ("FILT", mFilter);
     esm.writeHNCString ("DESC", mDescription);
 }
@@ -25,4 +59,5 @@ void ESM::Filter::blank()
 {
     mFilter.clear();
     mDescription.clear();
+    mIsDeleted = false;
 }

components/esm/filter.hpp

@@ -18,6 +18,10 @@ namespace ESM
 
         std::string mFilter;
 
+        bool mIsDeleted;
+
+        Filter();
+
         void load (ESMReader& esm);
         void save (ESMWriter& esm) const;
 

components/esm/loadland.cpp

@@ -8,8 +8,8 @@ namespace ESM
 {
     unsigned int Land::sRecordId = REC_LAND;
 
-void Land::LandData::save(ESMWriter &esm)
+    void Land::LandData::save(ESMWriter &esm)
-{
+    {
         if (mDataTypes & Land::DATA_VNML) {
             esm.writeHNT("VNML", mNormals, sizeof(mNormals));
         }
@@ -51,19 +51,19 @@ void Land::LandData::save(ESMWriter &esm)
             transposeTextureData(mTextures, vtex);
             esm.writeHNT("VTEX", vtex, sizeof(vtex));
         }
-}
+    }
 
-void Land::LandData::transposeTextureData(uint16_t *in, uint16_t *out)
+    void Land::LandData::transposeTextureData(uint16_t *in, uint16_t *out)
-{
+    {
         int readPos = 0; //bit ugly, but it works
         for ( int y1 = 0; y1 < 4; y1++ )
             for ( int x1 = 0; x1 < 4; x1++ )
                 for ( int y2 = 0; y2 < 4; y2++)
                     for ( int x2 = 0; x2 < 4; x2++ )
                         out[(y1*4+y2)*16+(x1*4+x2)] = in[readPos++];
-}
+    }
 
-Land::Land()
+    Land::Land()
         : mFlags(0)
         , mX(0)
         , mY(0)
@@ -72,18 +72,20 @@ Land::Land()
         , mDataTypes(0)
         , mDataLoaded(false)
         , mLandData(NULL)
-{
+        , mIsDeleted(false)
-}
+    {
+    }
 
-Land::~Land()
+    Land::~Land()
-{
+    {
         delete mLandData;
-}
+    }
 
-void Land::load(ESMReader &esm)
+    void Land::load(ESMReader &esm)
-{
+    {
         mEsm = &esm;
         mPlugin = mEsm->getIndex();
+        mIsDeleted = false;
 
         // Get the grid location
         esm.getSubNameIs("INTV");
@@ -93,6 +95,12 @@ void Land::load(ESMReader &esm)
 
         esm.getHNT(mFlags, "DATA");
 
+        if (esm.isNextSub("DELE"))
+        {
+            esm.skipHSub();
+            mIsDeleted = true;
+        }
+
         // Store the file position
         mContext = esm.getContext();
 
@@ -125,20 +133,35 @@ void Land::load(ESMReader &esm)
 
         mDataLoaded = 0;
         mLandData = NULL;
-}
+    }
 
-void Land::save(ESMWriter &esm) const
+    void Land::save(ESMWriter &esm) const
-{
+    {
         esm.startSubRecord("INTV");
         esm.writeT(mX);
         esm.writeT(mY);
         esm.endRecord("INTV");
 
         esm.writeHNT("DATA", mFlags);
-}
 
-void Land::loadData(int flags)
+        if (mIsDeleted)
-{
+        {
+            esm.writeHNCString("DELE", "");
+        }
+
+        if (mLandData != NULL)
+        {
+            mLandData->save(esm);
+        }
+    }
+
+    void Land::blank()
+    {
+        mIsDeleted = false;
+    }
+
+    void Land::loadData(int flags)
+    {
         // Try to load only available data
         flags = flags & mDataTypes;
         // Return if all required data is loaded
@@ -187,20 +210,20 @@ void Land::loadData(int flags)
                 LandData::transposeTextureData(vtex, mLandData->mTextures);
             }
         }
-}
+    }
 
-void Land::unloadData()
+    void Land::unloadData()
-{
+    {
         if (mDataLoaded)
         {
             delete mLandData;
             mLandData = NULL;
             mDataLoaded = 0;
         }
-}
+    }
 
-bool Land::condLoad(int flags, int dataFlag, void *ptr, unsigned int size)
+    bool Land::condLoad(int flags, int dataFlag, void *ptr, unsigned int size)
-{
+    {
         if ((mDataLoaded & dataFlag) == 0 && (flags & dataFlag) != 0) {
             mEsm->getHExact(ptr, size);
             mDataLoaded |= dataFlag;
@@ -208,11 +231,11 @@ bool Land::condLoad(int flags, int dataFlag, void *ptr, unsigned int size)
         }
         mEsm->skipHSubSize(size);
         return false;
-}
+    }
 
-bool Land::isDataLoaded(int flags) const
+    bool Land::isDataLoaded(int flags) const
-{
+    {
         return (mDataLoaded & flags) == (flags & mDataTypes);
-}
+    }
 
 }

components/esm/loadland.hpp

@@ -97,10 +97,12 @@ struct Land
 
     LandData *mLandData;
 
+    bool mIsDeleted;
+
     void load(ESMReader &esm);
     void save(ESMWriter &esm) const;
 
-    void blank() {}
+    void blank();
 
     /**
      * Actually loads data

components/esm/loadpgrd.cpp

@@ -32,18 +32,35 @@ namespace ESM
     {
     }
 
-void Pathgrid::load(ESMReader &esm)
+    Pathgrid::Pathgrid()
-{
+        : mIsDeleted(false)
-    esm.getHNT(mData, "DATA", 12);
+    {}
-    mCell = esm.getHNString("NAME");
 
+    void Pathgrid::load(ESMReader &esm)
+    {
         mPoints.clear();
         mEdges.clear();
 
         // keep track of total connections so we can reserve edge vector size
         int edgeCount = 0;
 
-    if (esm.isNextSub("PGRP"))
+        bool hasData = false;
+        bool hasName = false;
+        while (esm.hasMoreSubs())
+        {
+            esm.getSubName();
+            uint32_t name = esm.retSubName().val;
+            switch (name)
+            {
+                case ESM::FourCC<'D','A','T','A'>::value:
+                    esm.getHT(mData, 12);
+                    hasData = true;
+                    break;
+                case ESM::FourCC<'N','A','M','E'>::value:
+                    mCell = esm.getHString();
+                    hasName = true;
+                    break;
+                case ESM::FourCC<'P','G','R','P'>::value:
                 {
                     esm.getSubHeader();
                     int size = esm.getSubSize();
@@ -62,9 +79,9 @@ void Pathgrid::load(ESMReader &esm)
                             edgeCount += p.mConnectionNum;
                         }
                     }
+                    break;
                 }
-
+                case ESM::FourCC<'P','G','R','C'>::value:
-    if (esm.isNextSub("PGRC"))
                 {
                     esm.getSubHeader();
                     int size = esm.getSubSize();
@@ -97,13 +114,35 @@ void Pathgrid::load(ESMReader &esm)
                             }
                         }
                     }
+                    break;
                 }
-}
+                case ESM::FourCC<'D','E','L','E'>::value:
-void Pathgrid::save(ESMWriter &esm) const
+                    esm.skipHSub();
-{
+                    mIsDeleted = true;
+                    break;
+                default:
+                    esm.fail("Unknown subrecord");
+                    break;
+            }
+        }
+
+        if (!hasData)
+            esm.fail("Missing DATA subrecord");
+        if (!hasName)
+            esm.fail("Missing NAME subrecord");
+    }
+
+    void Pathgrid::save(ESMWriter &esm) const
+    {
         esm.writeHNT("DATA", mData, 12);
         esm.writeHNCString("NAME", mCell);
 
+        if (mIsDeleted)
+        {
+            esm.writeHNCString("DELE", "");
+            return;
+        }
+
         if (!mPoints.empty())
         {
             esm.startSubRecord("PGRP");
@@ -123,7 +162,7 @@ void Pathgrid::save(ESMWriter &esm) const
             }
             esm.endRecord("PGRC");
         }
-}
+    }
 
     void Pathgrid::blank()
     {
@@ -134,5 +173,6 @@ void Pathgrid::save(ESMWriter &esm) const
         mData.mS2 = 0;
         mPoints.clear();
         mEdges.clear();
+        mIsDeleted = false;
     }
 }

components/esm/loadpgrd.hpp

@@ -53,6 +53,10 @@ struct Pathgrid
     typedef std::vector<Edge> EdgeList;
     EdgeList mEdges;
 
+    bool mIsDeleted;
+
+    Pathgrid();
+
     void load(ESMReader &esm);
     void save(ESMWriter &esm) const;
 

components/esm/loadrace.cpp

@@ -8,6 +8,10 @@ namespace ESM
 {
     unsigned int Race::sRecordId = REC_RACE;
 
+    Race::Race()
+        : mIsDeleted(false)
+    {}
+
     int Race::MaleFemale::getValue (bool male) const
     {
         return male ? mMale : mFemale;
@@ -18,12 +22,12 @@ namespace ESM
         return static_cast<int>(male ? mMale : mFemale);
     }
 
-void Race::load(ESMReader &esm)
+    void Race::load(ESMReader &esm)
-{
+    {
         mPowers.mList.clear();
+        mIsDeleted = false;
 
-    mId = esm.getHNString("NAME");
+        bool hasName = false;
-
         bool hasData = false;
         while (esm.hasMoreSubs())
         {
@@ -31,6 +35,14 @@ void Race::load(ESMReader &esm)
             uint32_t name = esm.retSubName().val;
             switch (name)
             {
+                case ESM::FourCC<'N','A','M','E'>::value:
+                    mId = esm.getHString();
+                    hasName = true;
+                    break;
+                case ESM::FourCC<'D','E','L','E'>::value:
+                    esm.skipHSub();
+                    mIsDeleted = true;
+                    break;
                 case ESM::FourCC<'F','N','A','M'>::value:
                     mName = esm.getHString();
                     break;
@@ -48,17 +60,27 @@ void Race::load(ESMReader &esm)
                     esm.fail("Unknown subrecord");
             }
         }
-    if (!hasData)
+
+        if (!hasName)
+            esm.fail("Missing NAME subrecord");
+        if (!hasData && !mIsDeleted)
             esm.fail("Missing RADT subrecord");
-}
+    }
-void Race::save(ESMWriter &esm) const
+    void Race::save(ESMWriter &esm) const
-{
+    {
         esm.writeHNCString("NAME", mId);
+
+        if (mIsDeleted)
+        {
+            esm.writeHNCString("DELE", "");
+            return;
+        }
+
         esm.writeHNOCString("FNAM", mName);
         esm.writeHNT("RADT", mData, 140);
         mPowers.save(esm);
         esm.writeHNOString("DESC", mDescription);
-}
+    }
 
     void Race::blank()
     {

components/esm/loadrace.hpp

@@ -68,6 +68,10 @@ struct Race
     std::string mId, mName, mDescription;
     SpellList mPowers;
 
+    bool mIsDeleted;
+
+    Race();
+
     void load(ESMReader &esm);
     void save(ESMWriter &esm) const;
 

components/esm/loadsscr.cpp

@@ -8,8 +8,14 @@ namespace ESM
 {
     unsigned int StartScript::sRecordId = REC_SSCR;
 
+    StartScript::StartScript()
+        : mIsDeleted(false)
+    {}
+
     void StartScript::load(ESMReader &esm)
     {
+        mIsDeleted = false;
+
         bool hasData = false;
         bool hasName = false;
         while (esm.hasMoreSubs())
@@ -26,10 +32,16 @@ namespace ESM
                     mId = esm.getHString();
                     hasName = true;
                     break;
+                case ESM::FourCC<'D','E','L','E'>::value:
+                    esm.skipHSub();
+                    mIsDeleted = true;
+                    break;
                 default:
                     esm.fail("Unknown subrecord");
+                    break;
             }
         }
+
         if (!hasData)
             esm.fail("Missing DATA");
         if (!hasName)
@@ -39,10 +51,16 @@ namespace ESM
     {
         esm.writeHNString("DATA", mData);
         esm.writeHNString("NAME", mId);
+
+        if (mIsDeleted)
+        {
+            esm.writeHNCString("DELE", "");
+        }
     }
 
     void StartScript::blank()
     {
         mData.clear();
+        mIsDeleted = false;
     }
 }

components/esm/loadsscr.hpp

@@ -26,6 +26,10 @@ struct StartScript
     std::string mData;
     std::string mId;
 
+    bool mIsDeleted;
+
+    StartScript();
+
     // Load a record and add it to the list
     void load(ESMReader &esm);
     void save(ESMWriter &esm) const;