1
0
mirror of https://gitlab.com/OpenMW/openmw.git synced 2025-01-09 21:42:13 +00:00
OpenMW/apps/openmw/mwworld/cellref.cpp
elsid e910dd7a25
Rename CellRef::getRefIdPtr -> getRefIdRef and return reference
Return value can't be nullptr. Pointer complicates the code because has to be
dereferenced.

Also move function definition to hpp to make it easier for compiler to optimize
calls.
2021-09-06 22:52:08 +02:00

308 lines
6.8 KiB
C++

#include "cellref.hpp"
#include <assert.h>
#include <components/debug/debuglog.hpp>
#include <components/esm/objectstate.hpp>
namespace MWWorld
{
const ESM::RefNum& CellRef::getRefNum() const
{
return mCellRef.mRefNum;
}
const ESM::RefNum& CellRef::getOrAssignRefNum(ESM::RefNum& lastAssignedRefNum)
{
if (!mCellRef.mRefNum.isSet())
{
// Generated RefNums have negative mContentFile
assert(lastAssignedRefNum.mContentFile < 0);
lastAssignedRefNum.mIndex++;
if (lastAssignedRefNum.mIndex == 0) // mIndex overflow, so mContentFile should be changed
{
if (lastAssignedRefNum.mContentFile > std::numeric_limits<int32_t>::min())
lastAssignedRefNum.mContentFile--;
else
Log(Debug::Error) << "RefNum counter overflow in CellRef::getOrAssignRefNum";
}
mCellRef.mRefNum = lastAssignedRefNum;
mChanged = true;
}
return mCellRef.mRefNum;
}
bool CellRef::hasContentFile() const
{
return mCellRef.mRefNum.hasContentFile();
}
void CellRef::unsetRefNum()
{
mCellRef.mRefNum.unset();
}
std::string CellRef::getRefId() const
{
return mCellRef.mRefID;
}
bool CellRef::getTeleport() const
{
return mCellRef.mTeleport;
}
ESM::Position CellRef::getDoorDest() const
{
return mCellRef.mDoorDest;
}
std::string CellRef::getDestCell() const
{
return mCellRef.mDestCell;
}
float CellRef::getScale() const
{
return mCellRef.mScale;
}
void CellRef::setScale(float scale)
{
if (scale != mCellRef.mScale)
{
mChanged = true;
mCellRef.mScale = scale;
}
}
ESM::Position CellRef::getPosition() const
{
return mCellRef.mPos;
}
void CellRef::setPosition(const ESM::Position &position)
{
mChanged = true;
mCellRef.mPos = position;
}
float CellRef::getEnchantmentCharge() const
{
return mCellRef.mEnchantmentCharge;
}
float CellRef::getNormalizedEnchantmentCharge(int maxCharge) const
{
if (maxCharge == 0)
{
return 0;
}
else if (mCellRef.mEnchantmentCharge == -1)
{
return 1;
}
else
{
return mCellRef.mEnchantmentCharge / static_cast<float>(maxCharge);
}
}
void CellRef::setEnchantmentCharge(float charge)
{
if (charge != mCellRef.mEnchantmentCharge)
{
mChanged = true;
mCellRef.mEnchantmentCharge = charge;
}
}
int CellRef::getCharge() const
{
return mCellRef.mChargeInt;
}
void CellRef::setCharge(int charge)
{
if (charge != mCellRef.mChargeInt)
{
mChanged = true;
mCellRef.mChargeInt = charge;
}
}
void CellRef::applyChargeRemainderToBeSubtracted(float chargeRemainder)
{
mCellRef.mChargeIntRemainder += std::abs(chargeRemainder);
if (mCellRef.mChargeIntRemainder > 1.0f)
{
float newChargeRemainder = (mCellRef.mChargeIntRemainder - std::floor(mCellRef.mChargeIntRemainder));
if (mCellRef.mChargeInt <= static_cast<int>(mCellRef.mChargeIntRemainder))
{
mCellRef.mChargeInt = 0;
}
else
{
mCellRef.mChargeInt -= static_cast<int>(mCellRef.mChargeIntRemainder);
}
mCellRef.mChargeIntRemainder = newChargeRemainder;
}
}
float CellRef::getChargeFloat() const
{
return mCellRef.mChargeFloat;
}
void CellRef::setChargeFloat(float charge)
{
if (charge != mCellRef.mChargeFloat)
{
mChanged = true;
mCellRef.mChargeFloat = charge;
}
}
std::string CellRef::getOwner() const
{
return mCellRef.mOwner;
}
std::string CellRef::getGlobalVariable() const
{
return mCellRef.mGlobalVariable;
}
void CellRef::resetGlobalVariable()
{
if (!mCellRef.mGlobalVariable.empty())
{
mChanged = true;
mCellRef.mGlobalVariable.erase();
}
}
void CellRef::setFactionRank(int factionRank)
{
if (factionRank != mCellRef.mFactionRank)
{
mChanged = true;
mCellRef.mFactionRank = factionRank;
}
}
int CellRef::getFactionRank() const
{
return mCellRef.mFactionRank;
}
void CellRef::setOwner(const std::string &owner)
{
if (owner != mCellRef.mOwner)
{
mChanged = true;
mCellRef.mOwner = owner;
}
}
std::string CellRef::getSoul() const
{
return mCellRef.mSoul;
}
void CellRef::setSoul(const std::string &soul)
{
if (soul != mCellRef.mSoul)
{
mChanged = true;
mCellRef.mSoul = soul;
}
}
std::string CellRef::getFaction() const
{
return mCellRef.mFaction;
}
void CellRef::setFaction(const std::string &faction)
{
if (faction != mCellRef.mFaction)
{
mChanged = true;
mCellRef.mFaction = faction;
}
}
int CellRef::getLockLevel() const
{
return mCellRef.mLockLevel;
}
void CellRef::setLockLevel(int lockLevel)
{
if (lockLevel != mCellRef.mLockLevel)
{
mChanged = true;
mCellRef.mLockLevel = lockLevel;
}
}
void CellRef::lock(int lockLevel)
{
if(lockLevel != 0)
setLockLevel(abs(lockLevel)); //Changes lock to locklevel, if positive
else
setLockLevel(ESM::UnbreakableLock); // If zero, set to max lock level
}
void CellRef::unlock()
{
setLockLevel(-abs(mCellRef.mLockLevel)); //Makes lockLevel negative
}
std::string CellRef::getKey() const
{
return mCellRef.mKey;
}
std::string CellRef::getTrap() const
{
return mCellRef.mTrap;
}
void CellRef::setTrap(const std::string& trap)
{
if (trap != mCellRef.mTrap)
{
mChanged = true;
mCellRef.mTrap = trap;
}
}
int CellRef::getGoldValue() const
{
return mCellRef.mGoldValue;
}
void CellRef::setGoldValue(int value)
{
if (value != mCellRef.mGoldValue)
{
mChanged = true;
mCellRef.mGoldValue = value;
}
}
void CellRef::writeState(ESM::ObjectState &state) const
{
state.mRef = mCellRef;
}
bool CellRef::hasChanged() const
{
return mChanged;
}
}