aleajactaest/khanat-code-old
1
0
Fork 0
mirror of https://port.numenaute.org/aleajactaest/khanat-code-old.git synced 2024-12-04 17:24:47 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions
khanat-code-old/code/ryzom/server/src/entities_game_service/mission_pd.cpp
acemtp 1792297c93 initial version
2010-05-06 02:08:41 +02:00

3378 lines
107 KiB
C++
Raw Blame History

// Ryzom - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
// Copyright (C) 2010 Winch Gate Property Limited
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as
// published by the Free Software Foundation, either version 3 of the
// License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
#include "stdpch.h"
#include "egs_pd.h"
namespace EGSPD
{
/* -----------------------------------------
* Static Implementation of CActiveStepStatePD
* ----------------------------------------- */
uint32 CActiveStepStatePD::getIndex() const
{
return _Index;
}
uint32 CActiveStepStatePD::getState() const
{
return _State;
}
void CActiveStepStatePD::setState(uint32 __v, bool forceWrite)
{
if ((_State != __v) || forceWrite)
{
PDSLib.set(6, __BaseRow, (RY_PDS::TColumnIndex)(1), __v);
}
_State = __v;
}
CActiveStepPD* CActiveStepStatePD::getStep()
{
return _Step;
}
const CActiveStepPD* CActiveStepStatePD::getStep() const
{
return _Step;
}
void CActiveStepStatePD::clear()
{
_State = 0;
PDSLib.set(6, __BaseRow, (RY_PDS::TColumnIndex)(1), 0);
}
CActiveStepStatePD* CActiveStepStatePD::cast(RY_PDS::IPDBaseData* obj)
{
return (obj->getTable() == 6) ? static_cast<CActiveStepStatePD*>(obj) : NULL;
}
const CActiveStepStatePD* CActiveStepStatePD::cast(const RY_PDS::IPDBaseData* obj)
{
return (obj->getTable() == 6) ? static_cast<const CActiveStepStatePD*>(obj) : NULL;
}
void CActiveStepStatePD::apply(CPersistentDataRecord &__pdr)
{
uint16 __Tok_MapKey = __pdr.addString("__Key__");
uint16 __Tok_MapVal = __pdr.addString("__Val__");
uint16 __Tok_ClassName = __pdr.addString("__Class__");
uint16 __TokIndex = __pdr.addString("Index");
uint16 __TokState = __pdr.addString("State");
_Step = NULL;
while (!__pdr.isEndOfStruct())
{
if (false) {}
else if (__pdr.peekNextToken() == __TokIndex)
{
__pdr.pop(__TokIndex, _Index);
}
else if (__pdr.peekNextToken() == __TokState)
{
__pdr.pop(__TokState, _State);
}
else
{
nlwarning("Skipping unrecognised token: %s", __pdr.peekNextTokenName().c_str());
__pdr.skipData();
}
}
}
void CActiveStepStatePD::store(CPersistentDataRecord &__pdr) const
{
uint16 __Tok_MapKey = __pdr.addString("__Key__");
uint16 __Tok_MapVal = __pdr.addString("__Val__");
uint16 __Tok_ClassName = __pdr.addString("__Class__");
uint16 __TokIndex = __pdr.addString("Index");
uint16 __TokState = __pdr.addString("State");
__pdr.push(__TokIndex, _Index);
__pdr.push(__TokState, _State);
}
void CActiveStepStatePD::pds__init(const uint32 &Index)
{
_Index = Index;
_State = 0;
_Step = NULL;
}
void CActiveStepStatePD::pds__destroy()
{
}
void CActiveStepStatePD::pds__fetch(RY_PDS::CPData &data)
{
data.serial(_Index);
data.serial(_State);
_Step = NULL;
}
void CActiveStepStatePD::pds__register()
{
__BaseRow = _IndexAllocator.allocate();
PDSLib.allocateRow(6, __BaseRow, 0);
pds__registerAttributes();
}
void CActiveStepStatePD::pds__registerAttributes()
{
if (RY_PDS::PDVerbose) nldebug("CActiveStepStatePD: registerAttributes %u:%u", 6, __BaseRow);
PDSLib.set(6, __BaseRow, (RY_PDS::TColumnIndex)(0), _Index);
}
void CActiveStepStatePD::pds__unregister()
{
pds__unregisterAttributes();
PDSLib.deallocateRow(6, __BaseRow);
_IndexAllocator.deallocate(__BaseRow);
}
void CActiveStepStatePD::pds__unregisterAttributes()
{
if (RY_PDS::PDVerbose) nldebug("CActiveStepStatePD: unregisterAttributes %u:%u", 6, __BaseRow);
pds__setParent(NULL);
}
void CActiveStepStatePD::pds__setParent(CActiveStepPD* __parent)
{
_Step = __parent;
PDSLib.setParent(6, getRow(), (RY_PDS::TColumnIndex)(2), (__parent != NULL ? RY_PDS::CObjectIndex(7, __parent->getRow()) : RY_PDS::CObjectIndex::null()));
}
void CActiveStepStatePD::pds__setParentUnnotified(CActiveStepPD* __parent)
{
_Step = __parent;
}
void CActiveStepStatePD::pds__notifyInit()
{
}
void CActiveStepStatePD::pds__notifyRelease()
{
PDSLib.release(6, __BaseRow);
}
void CActiveStepStatePD::pds_static__init()
{
PDSLib.setIndexAllocator(6, _IndexAllocator);
}
RY_PDS::CIndexAllocator CActiveStepStatePD::_IndexAllocator;
// End of static implementation of CActiveStepStatePD
/* -----------------------------------------
* Static Implementation of CActiveStepPD
* ----------------------------------------- */
uint32 CActiveStepPD::getIndexInTemplate() const
{
return _IndexInTemplate;
}
CActiveStepStatePD* CActiveStepPD::getStates(const uint32& __k)
{
std::map<uint32, CActiveStepStatePD>::iterator _it = _States.find(__k);
return (_it==_States.end() ? NULL : &((*_it).second));
}
const CActiveStepStatePD* CActiveStepPD::getStates(const uint32& __k) const
{
std::map<uint32, CActiveStepStatePD>::const_iterator _it = _States.find(__k);
return (_it==_States.end() ? NULL : &((*_it).second));
}
std::map<uint32, CActiveStepStatePD>::iterator CActiveStepPD::getStatesBegin()
{
return _States.begin();
}
std::map<uint32, CActiveStepStatePD>::iterator CActiveStepPD::getStatesEnd()
{
return _States.end();
}
std::map<uint32, CActiveStepStatePD>::const_iterator CActiveStepPD::getStatesBegin() const
{
return _States.begin();
}
std::map<uint32, CActiveStepStatePD>::const_iterator CActiveStepPD::getStatesEnd() const
{
return _States.end();
}
const std::map<uint32, CActiveStepStatePD> & CActiveStepPD::getStates() const
{
return _States;
}
CActiveStepStatePD* CActiveStepPD::addToStates(const uint32 &__k)
{
std::map<uint32, CActiveStepStatePD>::iterator __it = _States.find(__k);
if (__it == _States.end())
{
__it = _States.insert(std::map<uint32, CActiveStepStatePD>::value_type(__k, CActiveStepStatePD())).first;
CActiveStepStatePD* __o = &((*__it).second);
__o->pds__init(__k);
__o->pds__register();
__o->pds__setParent(this);
}
return &((*__it).second);
}
void CActiveStepPD::deleteFromStates(const uint32 &__k)
{
std::map<uint32, CActiveStepStatePD>::iterator __it = _States.find(__k);
if (__it == _States.end()) return;
CActiveStepStatePD& __o = (*__it).second;
__o.pds__unregister();
_States.erase(__it);
}
CMissionPD* CActiveStepPD::getMission()
{
return _Mission;
}
const CMissionPD* CActiveStepPD::getMission() const
{
return _Mission;
}
void CActiveStepPD::clear()
{
for (std::map<uint32, CActiveStepStatePD>::iterator __it=_States.begin(); __it!=_States.end(); )
{
std::map<uint32, CActiveStepStatePD>::iterator __itr=__it++;
CActiveStepStatePD* __o = &((*__itr).second);
__o->pds__unregister();
__o->pds__destroy();
}
_States.clear();
}
CActiveStepPD* CActiveStepPD::cast(RY_PDS::IPDBaseData* obj)
{
return (obj->getTable() == 7) ? static_cast<CActiveStepPD*>(obj) : NULL;
}
const CActiveStepPD* CActiveStepPD::cast(const RY_PDS::IPDBaseData* obj)
{
return (obj->getTable() == 7) ? static_cast<const CActiveStepPD*>(obj) : NULL;
}
void CActiveStepPD::apply(CPersistentDataRecord &__pdr)
{
uint16 __Tok_MapKey = __pdr.addString("__Key__");
uint16 __Tok_MapVal = __pdr.addString("__Val__");
uint16 __Tok_ClassName = __pdr.addString("__Class__");
uint16 __TokIndexInTemplate = __pdr.addString("IndexInTemplate");
uint16 __TokStates = __pdr.addString("States");
_Mission = NULL;
while (!__pdr.isEndOfStruct())
{
if (false) {}
else if (__pdr.peekNextToken() == __TokIndexInTemplate)
{
__pdr.pop(__TokIndexInTemplate, _IndexInTemplate);
}
// apply States
else if (__pdr.peekNextToken() == __TokStates)
{
__pdr.popStructBegin(__TokStates);
while (!__pdr.isEndOfStruct())
{
uint32 key;
__pdr.pop(__Tok_MapKey, key);
__pdr.popStructBegin(__Tok_MapVal);
CActiveStepStatePD& obj = _States[key];
obj.apply(__pdr);
obj.pds__setParentUnnotified(this);
__pdr.popStructEnd(__Tok_MapVal);
}
__pdr.popStructEnd(__TokStates);
}
// end of apply States
else
{
nlwarning("Skipping unrecognised token: %s", __pdr.peekNextTokenName().c_str());
__pdr.skipData();
}
}
}
void CActiveStepPD::store(CPersistentDataRecord &__pdr) const
{
uint16 __Tok_MapKey = __pdr.addString("__Key__");
uint16 __Tok_MapVal = __pdr.addString("__Val__");
uint16 __Tok_ClassName = __pdr.addString("__Class__");
uint16 __TokIndexInTemplate = __pdr.addString("IndexInTemplate");
uint16 __TokStates = __pdr.addString("States");
__pdr.push(__TokIndexInTemplate, _IndexInTemplate);
// store States
__pdr.pushStructBegin(__TokStates);
for (std::map<uint32, CActiveStepStatePD>::const_iterator it=_States.begin(); it!=_States.end(); ++it)
{
uint32 key = (*it).first;
__pdr.push(__Tok_MapKey, key);
__pdr.pushStructBegin(__Tok_MapVal);
(*it).second.store(__pdr);
__pdr.pushStructEnd(__Tok_MapVal);
}
__pdr.pushStructEnd(__TokStates);
// end of store States
}
void CActiveStepPD::pds__init(const uint32 &IndexInTemplate)
{
_IndexInTemplate = IndexInTemplate;
_Mission = NULL;
}
void CActiveStepPD::pds__destroy()
{
for (std::map<uint32, CActiveStepStatePD>::iterator __it=_States.begin(); __it!=_States.end(); )
{
std::map<uint32, CActiveStepStatePD>::iterator __itr=__it++;
((*__itr).second).pds__destroy();
}
_States.clear();
}
void CActiveStepPD::pds__fetch(RY_PDS::CPData &data)
{
data.serial(_IndexInTemplate);
RY_PDS::TTableIndex tableIndex;
RY_PDS::TRowIndex rowIndex;
do
{
// read table and row, create an object, affect to the ref, and fetch it
data.serial(tableIndex, rowIndex);
if (rowIndex == RY_PDS::INVALID_ROW_INDEX || tableIndex == RY_PDS::INVALID_TABLE_INDEX) break;
uint32 __k;
data.serial(__k);
_States.insert(std::make_pair<uint32,CActiveStepStatePD>(__k, CActiveStepStatePD()));
CActiveStepStatePD* __o = &(_States[__k]);
PDSLib.setRowIndex(rowIndex, __o);
__o->pds__fetch(data);
__o->pds__setParentUnnotified(this);
}
while (true);
_Mission = NULL;
}
void CActiveStepPD::pds__register()
{
__BaseRow = _IndexAllocator.allocate();
PDSLib.allocateRow(7, __BaseRow, 0);
pds__registerAttributes();
}
void CActiveStepPD::pds__registerAttributes()
{
if (RY_PDS::PDVerbose) nldebug("CActiveStepPD: registerAttributes %u:%u", 7, __BaseRow);
PDSLib.set(7, __BaseRow, (RY_PDS::TColumnIndex)(0), _IndexInTemplate);
}
void CActiveStepPD::pds__unregister()
{
pds__unregisterAttributes();
PDSLib.deallocateRow(7, __BaseRow);
_IndexAllocator.deallocate(__BaseRow);
}
void CActiveStepPD::pds__unregisterAttributes()
{
if (RY_PDS::PDVerbose) nldebug("CActiveStepPD: unregisterAttributes %u:%u", 7, __BaseRow);
pds__setParent(NULL);
for (std::map<uint32, CActiveStepStatePD>::iterator __it=_States.begin(); __it!=_States.end(); )
{
std::map<uint32, CActiveStepStatePD>::iterator __itr=__it++;
CActiveStepStatePD& __o = (*__itr).second;
__o.pds__unregister();
}
}
void CActiveStepPD::pds__setParent(CMissionPD* __parent)
{
_Mission = __parent;
PDSLib.setParent(7, getRow(), (RY_PDS::TColumnIndex)(2), (__parent != NULL ? RY_PDS::CObjectIndex(__parent->getTable(), __parent->getRow()) : RY_PDS::CObjectIndex::null()));
}
void CActiveStepPD::pds__setParentUnnotified(CMissionPD* __parent)
{
_Mission = __parent;
}
void CActiveStepPD::pds__notifyInit()
{
for (std::map<uint32, CActiveStepStatePD>::iterator __it=_States.begin(); __it!=_States.end(); )
{
std::map<uint32, CActiveStepStatePD>::iterator __itr=__it++;
(*__itr).second.pds__notifyInit();
}
}
void CActiveStepPD::pds__notifyRelease()
{
PDSLib.release(7, __BaseRow);
for (std::map<uint32, CActiveStepStatePD>::iterator __it=_States.begin(); __it!=_States.end(); )
{
std::map<uint32, CActiveStepStatePD>::iterator __itr=__it++;
(*__itr).second.pds__notifyRelease();
}
}
void CActiveStepPD::pds_static__init()
{
PDSLib.setIndexAllocator(7, _IndexAllocator);
}
RY_PDS::CIndexAllocator CActiveStepPD::_IndexAllocator;
// End of static implementation of CActiveStepPD
/* -----------------------------------------
* Static Implementation of CDoneStepPD
* ----------------------------------------- */
uint32 CDoneStepPD::getIndex() const
{
return _Index;
}
CMissionPD* CDoneStepPD::getMission()
{
return _Mission;
}
const CMissionPD* CDoneStepPD::getMission() const
{
return _Mission;
}
void CDoneStepPD::clear()
{
}
CDoneStepPD* CDoneStepPD::cast(RY_PDS::IPDBaseData* obj)
{
return (obj->getTable() == 8) ? static_cast<CDoneStepPD*>(obj) : NULL;
}
const CDoneStepPD* CDoneStepPD::cast(const RY_PDS::IPDBaseData* obj)
{
return (obj->getTable() == 8) ? static_cast<const CDoneStepPD*>(obj) : NULL;
}
void CDoneStepPD::apply(CPersistentDataRecord &__pdr)
{
uint16 __Tok_MapKey = __pdr.addString("__Key__");
uint16 __Tok_MapVal = __pdr.addString("__Val__");
uint16 __Tok_ClassName = __pdr.addString("__Class__");
uint16 __TokIndex = __pdr.addString("Index");
_Mission = NULL;
while (!__pdr.isEndOfStruct())
{
if (false) {}
else if (__pdr.peekNextToken() == __TokIndex)
{
__pdr.pop(__TokIndex, _Index);
}
else
{
nlwarning("Skipping unrecognised token: %s", __pdr.peekNextTokenName().c_str());
__pdr.skipData();
}
}
}
void CDoneStepPD::store(CPersistentDataRecord &__pdr) const
{
uint16 __Tok_MapKey = __pdr.addString("__Key__");
uint16 __Tok_MapVal = __pdr.addString("__Val__");
uint16 __Tok_ClassName = __pdr.addString("__Class__");
uint16 __TokIndex = __pdr.addString("Index");
__pdr.push(__TokIndex, _Index);
}
void CDoneStepPD::pds__init(const uint32 &Index)
{
_Index = Index;
_Mission = NULL;
}
void CDoneStepPD::pds__destroy()
{
}
void CDoneStepPD::pds__fetch(RY_PDS::CPData &data)
{
data.serial(_Index);
_Mission = NULL;
}
void CDoneStepPD::pds__register()
{
__BaseRow = _IndexAllocator.allocate();
PDSLib.allocateRow(8, __BaseRow, 0);
pds__registerAttributes();
}
void CDoneStepPD::pds__registerAttributes()
{
if (RY_PDS::PDVerbose) nldebug("CDoneStepPD: registerAttributes %u:%u", 8, __BaseRow);
PDSLib.set(8, __BaseRow, (RY_PDS::TColumnIndex)(0), _Index);
}
void CDoneStepPD::pds__unregister()
{
pds__unregisterAttributes();
PDSLib.deallocateRow(8, __BaseRow);
_IndexAllocator.deallocate(__BaseRow);
}
void CDoneStepPD::pds__unregisterAttributes()
{
if (RY_PDS::PDVerbose) nldebug("CDoneStepPD: unregisterAttributes %u:%u", 8, __BaseRow);
pds__setParent(NULL);
}
void CDoneStepPD::pds__setParent(CMissionPD* __parent)
{
_Mission = __parent;
PDSLib.setParent(8, getRow(), (RY_PDS::TColumnIndex)(1), (__parent != NULL ? RY_PDS::CObjectIndex(__parent->getTable(), __parent->getRow()) : RY_PDS::CObjectIndex::null()));
}
void CDoneStepPD::pds__setParentUnnotified(CMissionPD* __parent)
{
_Mission = __parent;
}
void CDoneStepPD::pds__notifyInit()
{
}
void CDoneStepPD::pds__notifyRelease()
{
PDSLib.release(8, __BaseRow);
}
void CDoneStepPD::pds_static__init()
{
PDSLib.setIndexAllocator(8, _IndexAllocator);
}
RY_PDS::CIndexAllocator CDoneStepPD::_IndexAllocator;
// End of static implementation of CDoneStepPD
/* -----------------------------------------
* Static Implementation of CMissionCompassPD
* ----------------------------------------- */
uint32 CMissionCompassPD::getIndex() const
{
return _Index;
}
uint32 CMissionCompassPD::getPlace() const
{
return _Place;
}
void CMissionCompassPD::setPlace(uint32 __v, bool forceWrite)
{
if ((_Place != __v) || forceWrite)
{
PDSLib.set(9, __BaseRow, (RY_PDS::TColumnIndex)(1), __v);
}
_Place = __v;
}
uint32 CMissionCompassPD::getBotId() const
{
return _BotId;
}
void CMissionCompassPD::setBotId(uint32 __v, bool forceWrite)
{
if ((_BotId != __v) || forceWrite)
{
PDSLib.set(9, __BaseRow, (RY_PDS::TColumnIndex)(2), __v);
}
_BotId = __v;
}
CMissionPD* CMissionCompassPD::getMission()
{
return _Mission;
}
const CMissionPD* CMissionCompassPD::getMission() const
{
return _Mission;
}
void CMissionCompassPD::clear()
{
_Place = 0;
PDSLib.set(9, __BaseRow, (RY_PDS::TColumnIndex)(1), 0);
_BotId = 0;
PDSLib.set(9, __BaseRow, (RY_PDS::TColumnIndex)(2), 0);
}
CMissionCompassPD* CMissionCompassPD::cast(RY_PDS::IPDBaseData* obj)
{
return (obj->getTable() == 9) ? static_cast<CMissionCompassPD*>(obj) : NULL;
}
const CMissionCompassPD* CMissionCompassPD::cast(const RY_PDS::IPDBaseData* obj)
{
return (obj->getTable() == 9) ? static_cast<const CMissionCompassPD*>(obj) : NULL;
}
void CMissionCompassPD::apply(CPersistentDataRecord &__pdr)
{
uint16 __Tok_MapKey = __pdr.addString("__Key__");
uint16 __Tok_MapVal = __pdr.addString("__Val__");
uint16 __Tok_ClassName = __pdr.addString("__Class__");
uint16 __TokIndex = __pdr.addString("Index");
uint16 __TokPlace = __pdr.addString("Place");
uint16 __TokBotId = __pdr.addString("BotId");
_Mission = NULL;
while (!__pdr.isEndOfStruct())
{
if (false) {}
else if (__pdr.peekNextToken() == __TokIndex)
{
__pdr.pop(__TokIndex, _Index);
}
else if (__pdr.peekNextToken() == __TokPlace)
{
__pdr.pop(__TokPlace, _Place);
}
else if (__pdr.peekNextToken() == __TokBotId)
{
__pdr.pop(__TokBotId, _BotId);
}
else
{
nlwarning("Skipping unrecognised token: %s", __pdr.peekNextTokenName().c_str());
__pdr.skipData();
}
}
}
void CMissionCompassPD::store(CPersistentDataRecord &__pdr) const
{
uint16 __Tok_MapKey = __pdr.addString("__Key__");
uint16 __Tok_MapVal = __pdr.addString("__Val__");
uint16 __Tok_ClassName = __pdr.addString("__Class__");
uint16 __TokIndex = __pdr.addString("Index");
uint16 __TokPlace = __pdr.addString("Place");
uint16 __TokBotId = __pdr.addString("BotId");
__pdr.push(__TokIndex, _Index);
__pdr.push(__TokPlace, _Place);
__pdr.push(__TokBotId, _BotId);
}
void CMissionCompassPD::pds__init(const uint32 &Index)
{
_Index = Index;
_Place = 0;
_BotId = 0;
_Mission = NULL;
}
void CMissionCompassPD::pds__destroy()
{
}
void CMissionCompassPD::pds__fetch(RY_PDS::CPData &data)
{
data.serial(_Index);
data.serial(_Place);
data.serial(_BotId);
_Mission = NULL;
}
void CMissionCompassPD::pds__register()
{
__BaseRow = _IndexAllocator.allocate();
PDSLib.allocateRow(9, __BaseRow, 0);
pds__registerAttributes();
}
void CMissionCompassPD::pds__registerAttributes()
{
if (RY_PDS::PDVerbose) nldebug("CMissionCompassPD: registerAttributes %u:%u", 9, __BaseRow);
PDSLib.set(9, __BaseRow, (RY_PDS::TColumnIndex)(0), _Index);
}
void CMissionCompassPD::pds__unregister()
{
pds__unregisterAttributes();
PDSLib.deallocateRow(9, __BaseRow);
_IndexAllocator.deallocate(__BaseRow);
}
void CMissionCompassPD::pds__unregisterAttributes()
{
if (RY_PDS::PDVerbose) nldebug("CMissionCompassPD: unregisterAttributes %u:%u", 9, __BaseRow);
pds__setParent(NULL);
}
void CMissionCompassPD::pds__setParent(CMissionPD* __parent)
{
_Mission = __parent;
PDSLib.setParent(9, getRow(), (RY_PDS::TColumnIndex)(3), (__parent != NULL ? RY_PDS::CObjectIndex(__parent->getTable(), __parent->getRow()) : RY_PDS::CObjectIndex::null()));
}
void CMissionCompassPD::pds__setParentUnnotified(CMissionPD* __parent)
{
_Mission = __parent;
}
void CMissionCompassPD::pds__notifyInit()
{
{
// CMissionCompassPD init user code, defined at entities_game_service/pd_scripts/mission.pds:27
NameStringId = 0;
NameString.clear();
}
}
void CMissionCompassPD::pds__notifyRelease()
{
PDSLib.release(9, __BaseRow);
}
void CMissionCompassPD::pds_static__init()
{
PDSLib.setIndexAllocator(9, _IndexAllocator);
}
RY_PDS::CIndexAllocator CMissionCompassPD::_IndexAllocator;
// End of static implementation of CMissionCompassPD
/* -----------------------------------------
* Static Implementation of CMissionTeleportPD
* ----------------------------------------- */
uint32 CMissionTeleportPD::getIndex() const
{
return _Index;
}
CMissionPD* CMissionTeleportPD::getMission()
{
return _Mission;
}
const CMissionPD* CMissionTeleportPD::getMission() const
{
return _Mission;
}
void CMissionTeleportPD::clear()
{
}
CMissionTeleportPD* CMissionTeleportPD::cast(RY_PDS::IPDBaseData* obj)
{
return (obj->getTable() == 10) ? static_cast<CMissionTeleportPD*>(obj) : NULL;
}
const CMissionTeleportPD* CMissionTeleportPD::cast(const RY_PDS::IPDBaseData* obj)
{
return (obj->getTable() == 10) ? static_cast<const CMissionTeleportPD*>(obj) : NULL;
}
void CMissionTeleportPD::apply(CPersistentDataRecord &__pdr)
{
uint16 __Tok_MapKey = __pdr.addString("__Key__");
uint16 __Tok_MapVal = __pdr.addString("__Val__");
uint16 __Tok_ClassName = __pdr.addString("__Class__");
uint16 __TokIndex = __pdr.addString("Index");
_Mission = NULL;
while (!__pdr.isEndOfStruct())
{
if (false) {}
else if (__pdr.peekNextToken() == __TokIndex)
{
__pdr.pop(__TokIndex, _Index);
}
else
{
nlwarning("Skipping unrecognised token: %s", __pdr.peekNextTokenName().c_str());
__pdr.skipData();
}
}
}
void CMissionTeleportPD::store(CPersistentDataRecord &__pdr) const
{
uint16 __Tok_MapKey = __pdr.addString("__Key__");
uint16 __Tok_MapVal = __pdr.addString("__Val__");
uint16 __Tok_ClassName = __pdr.addString("__Class__");
uint16 __TokIndex = __pdr.addString("Index");
__pdr.push(__TokIndex, _Index);
}
void CMissionTeleportPD::pds__init(const uint32 &Index)
{
_Index = Index;
_Mission = NULL;
}
void CMissionTeleportPD::pds__destroy()
{
}
void CMissionTeleportPD::pds__fetch(RY_PDS::CPData &data)
{
data.serial(_Index);
_Mission = NULL;
}
void CMissionTeleportPD::pds__register()
{
__BaseRow = _IndexAllocator.allocate();
PDSLib.allocateRow(10, __BaseRow, 0);
pds__registerAttributes();
}
void CMissionTeleportPD::pds__registerAttributes()
{
if (RY_PDS::PDVerbose) nldebug("CMissionTeleportPD: registerAttributes %u:%u", 10, __BaseRow);
PDSLib.set(10, __BaseRow, (RY_PDS::TColumnIndex)(0), _Index);
}
void CMissionTeleportPD::pds__unregister()
{
pds__unregisterAttributes();
PDSLib.deallocateRow(10, __BaseRow);
_IndexAllocator.deallocate(__BaseRow);
}
void CMissionTeleportPD::pds__unregisterAttributes()
{
if (RY_PDS::PDVerbose) nldebug("CMissionTeleportPD: unregisterAttributes %u:%u", 10, __BaseRow);
pds__setParent(NULL);
}
void CMissionTeleportPD::pds__setParent(CMissionPD* __parent)
{
_Mission = __parent;
PDSLib.setParent(10, getRow(), (RY_PDS::TColumnIndex)(1), (__parent != NULL ? RY_PDS::CObjectIndex(__parent->getTable(), __parent->getRow()) : RY_PDS::CObjectIndex::null()));
}
void CMissionTeleportPD::pds__setParentUnnotified(CMissionPD* __parent)
{
_Mission = __parent;
}
void CMissionTeleportPD::pds__notifyInit()
{
}
void CMissionTeleportPD::pds__notifyRelease()
{
PDSLib.release(10, __BaseRow);
}
void CMissionTeleportPD::pds_static__init()
{
PDSLib.setIndexAllocator(10, _IndexAllocator);
}
RY_PDS::CIndexAllocator CMissionTeleportPD::_IndexAllocator;
// End of static implementation of CMissionTeleportPD
/* -----------------------------------------
* Static Implementation of CMissionInsidePlacePD
* ----------------------------------------- */
uint32 CMissionInsidePlacePD::getAlias() const
{
return _Alias;
}
uint32 CMissionInsidePlacePD::getDelay() const
{
return _Delay;
}
void CMissionInsidePlacePD::setDelay(uint32 __v, bool forceWrite)
{
if ((_Delay != __v) || forceWrite)
{
PDSLib.set(11, __BaseRow, (RY_PDS::TColumnIndex)(1), __v);
}
_Delay = __v;
}
CMissionPD* CMissionInsidePlacePD::getMission()
{
return _Mission;
}
const CMissionPD* CMissionInsidePlacePD::getMission() const
{
return _Mission;
}
void CMissionInsidePlacePD::clear()
{
_Delay = 0;
PDSLib.set(11, __BaseRow, (RY_PDS::TColumnIndex)(1), 0);
}
CMissionInsidePlacePD* CMissionInsidePlacePD::cast(RY_PDS::IPDBaseData* obj)
{
return (obj->getTable() == 11) ? static_cast<CMissionInsidePlacePD*>(obj) : NULL;
}
const CMissionInsidePlacePD* CMissionInsidePlacePD::cast(const RY_PDS::IPDBaseData* obj)
{
return (obj->getTable() == 11) ? static_cast<const CMissionInsidePlacePD*>(obj) : NULL;
}
void CMissionInsidePlacePD::apply(CPersistentDataRecord &__pdr)
{
uint16 __Tok_MapKey = __pdr.addString("__Key__");
uint16 __Tok_MapVal = __pdr.addString("__Val__");
uint16 __Tok_ClassName = __pdr.addString("__Class__");
uint16 __TokAlias = __pdr.addString("Alias");
uint16 __TokDelay = __pdr.addString("Delay");
_Mission = NULL;
while (!__pdr.isEndOfStruct())
{
if (false) {}
else if (__pdr.peekNextToken() == __TokAlias)
{
__pdr.pop(__TokAlias, _Alias);
}
else if (__pdr.peekNextToken() == __TokDelay)
{
__pdr.pop(__TokDelay, _Delay);
}
else
{
nlwarning("Skipping unrecognised token: %s", __pdr.peekNextTokenName().c_str());
__pdr.skipData();
}
}
}
void CMissionInsidePlacePD::store(CPersistentDataRecord &__pdr) const
{
uint16 __Tok_MapKey = __pdr.addString("__Key__");
uint16 __Tok_MapVal = __pdr.addString("__Val__");
uint16 __Tok_ClassName = __pdr.addString("__Class__");
uint16 __TokAlias = __pdr.addString("Alias");
uint16 __TokDelay = __pdr.addString("Delay");
__pdr.push(__TokAlias, _Alias);
__pdr.push(__TokDelay, _Delay);
}
void CMissionInsidePlacePD::pds__init(const uint32 &Alias)
{
_Alias = Alias;
_Delay = 0;
_Mission = NULL;
}
void CMissionInsidePlacePD::pds__destroy()
{
}
void CMissionInsidePlacePD::pds__fetch(RY_PDS::CPData &data)
{
data.serial(_Alias);
data.serial(_Delay);
_Mission = NULL;
}
void CMissionInsidePlacePD::pds__register()
{
__BaseRow = _IndexAllocator.allocate();
PDSLib.allocateRow(11, __BaseRow, 0);
pds__registerAttributes();
}
void CMissionInsidePlacePD::pds__registerAttributes()
{
if (RY_PDS::PDVerbose) nldebug("CMissionInsidePlacePD: registerAttributes %u:%u", 11, __BaseRow);
PDSLib.set(11, __BaseRow, (RY_PDS::TColumnIndex)(0), _Alias);
}
void CMissionInsidePlacePD::pds__unregister()
{
pds__unregisterAttributes();
PDSLib.deallocateRow(11, __BaseRow);
_IndexAllocator.deallocate(__BaseRow);
}
void CMissionInsidePlacePD::pds__unregisterAttributes()
{
if (RY_PDS::PDVerbose) nldebug("CMissionInsidePlacePD: unregisterAttributes %u:%u", 11, __BaseRow);
pds__setParent(NULL);
}
void CMissionInsidePlacePD::pds__setParent(CMissionPD* __parent)
{
_Mission = __parent;
PDSLib.setParent(11, getRow(), (RY_PDS::TColumnIndex)(2), (__parent != NULL ? RY_PDS::CObjectIndex(__parent->getTable(), __parent->getRow()) : RY_PDS::CObjectIndex::null()));
}
void CMissionInsidePlacePD::pds__setParentUnnotified(CMissionPD* __parent)
{
_Mission = __parent;
}
void CMissionInsidePlacePD::pds__notifyInit()
{
}
void CMissionInsidePlacePD::pds__notifyRelease()
{
PDSLib.release(11, __BaseRow);
}
void CMissionInsidePlacePD::pds_static__init()
{
PDSLib.setIndexAllocator(11, _IndexAllocator);
}
RY_PDS::CIndexAllocator CMissionInsidePlacePD::_IndexAllocator;
// End of static implementation of CMissionInsidePlacePD
/* -----------------------------------------
* Static Implementation of CMissionOutsidePlacePD
* ----------------------------------------- */
uint32 CMissionOutsidePlacePD::getAlias() const
{
return _Alias;
}
uint32 CMissionOutsidePlacePD::getDelay() const
{
return _Delay;
}
void CMissionOutsidePlacePD::setDelay(uint32 __v, bool forceWrite)
{
if ((_Delay != __v) || forceWrite)
{
PDSLib.set(12, __BaseRow, (RY_PDS::TColumnIndex)(1), __v);
}
_Delay = __v;
}
CMissionPD* CMissionOutsidePlacePD::getMission()
{
return _Mission;
}
const CMissionPD* CMissionOutsidePlacePD::getMission() const
{
return _Mission;
}
void CMissionOutsidePlacePD::clear()
{
_Delay = 0;
PDSLib.set(12, __BaseRow, (RY_PDS::TColumnIndex)(1), 0);
}
CMissionOutsidePlacePD* CMissionOutsidePlacePD::cast(RY_PDS::IPDBaseData* obj)
{
return (obj->getTable() == 12) ? static_cast<CMissionOutsidePlacePD*>(obj) : NULL;
}
const CMissionOutsidePlacePD* CMissionOutsidePlacePD::cast(const RY_PDS::IPDBaseData* obj)
{
return (obj->getTable() == 12) ? static_cast<const CMissionOutsidePlacePD*>(obj) : NULL;
}
void CMissionOutsidePlacePD::apply(CPersistentDataRecord &__pdr)
{
uint16 __Tok_MapKey = __pdr.addString("__Key__");
uint16 __Tok_MapVal = __pdr.addString("__Val__");
uint16 __Tok_ClassName = __pdr.addString("__Class__");
uint16 __TokAlias = __pdr.addString("Alias");
uint16 __TokDelay = __pdr.addString("Delay");
_Mission = NULL;
while (!__pdr.isEndOfStruct())
{
if (false) {}
else if (__pdr.peekNextToken() == __TokAlias)
{
__pdr.pop(__TokAlias, _Alias);
}
else if (__pdr.peekNextToken() == __TokDelay)
{
__pdr.pop(__TokDelay, _Delay);
}
else
{
nlwarning("Skipping unrecognised token: %s", __pdr.peekNextTokenName().c_str());
__pdr.skipData();
}
}
}
void CMissionOutsidePlacePD::store(CPersistentDataRecord &__pdr) const
{
uint16 __Tok_MapKey = __pdr.addString("__Key__");
uint16 __Tok_MapVal = __pdr.addString("__Val__");
uint16 __Tok_ClassName = __pdr.addString("__Class__");
uint16 __TokAlias = __pdr.addString("Alias");
uint16 __TokDelay = __pdr.addString("Delay");
__pdr.push(__TokAlias, _Alias);
__pdr.push(__TokDelay, _Delay);
}
void CMissionOutsidePlacePD::pds__init(const uint32 &Alias)
{
_Alias = Alias;
_Delay = 0;
_Mission = NULL;
}
void CMissionOutsidePlacePD::pds__destroy()
{
}
void CMissionOutsidePlacePD::pds__fetch(RY_PDS::CPData &data)
{
data.serial(_Alias);
data.serial(_Delay);
_Mission = NULL;
}
void CMissionOutsidePlacePD::pds__register()
{
__BaseRow = _IndexAllocator.allocate();
PDSLib.allocateRow(12, __BaseRow, 0);
pds__registerAttributes();
}
void CMissionOutsidePlacePD::pds__registerAttributes()
{
if (RY_PDS::PDVerbose) nldebug("CMissionOutsidePlacePD: registerAttributes %u:%u", 12, __BaseRow);
PDSLib.set(12, __BaseRow, (RY_PDS::TColumnIndex)(0), _Alias);
}
void CMissionOutsidePlacePD::pds__unregister()
{
pds__unregisterAttributes();
PDSLib.deallocateRow(12, __BaseRow);
_IndexAllocator.deallocate(__BaseRow);
}
void CMissionOutsidePlacePD::pds__unregisterAttributes()
{
if (RY_PDS::PDVerbose) nldebug("CMissionOutsidePlacePD: unregisterAttributes %u:%u", 12, __BaseRow);
pds__setParent(NULL);
}
void CMissionOutsidePlacePD::pds__setParent(CMissionPD* __parent)
{
_Mission = __parent;
PDSLib.setParent(12, getRow(), (RY_PDS::TColumnIndex)(2), (__parent != NULL ? RY_PDS::CObjectIndex(__parent->getTable(), __parent->getRow()) : RY_PDS::CObjectIndex::null()));
}
void CMissionOutsidePlacePD::pds__setParentUnnotified(CMissionPD* __parent)
{
_Mission = __parent;
}
void CMissionOutsidePlacePD::pds__notifyInit()
{
}
void CMissionOutsidePlacePD::pds__notifyRelease()
{
PDSLib.release(12, __BaseRow);
}
void CMissionOutsidePlacePD::pds_static__init()
{
PDSLib.setIndexAllocator(12, _IndexAllocator);
}
RY_PDS::CIndexAllocator CMissionOutsidePlacePD::_IndexAllocator;
// End of static implementation of CMissionOutsidePlacePD
/* -----------------------------------------
* Static Implementation of CHandledAIGroupPD
* ----------------------------------------- */
uint32 CHandledAIGroupPD::getGroupAlias() const
{
return _GroupAlias;
}
uint32 CHandledAIGroupPD::getDespawnTime() const
{
return _DespawnTime;
}
void CHandledAIGroupPD::setDespawnTime(uint32 __v, bool forceWrite)
{
if ((_DespawnTime != __v) || forceWrite)
{
PDSLib.set(13, __BaseRow, (RY_PDS::TColumnIndex)(1), __v);
}
_DespawnTime = __v;
}
CMissionPD* CHandledAIGroupPD::getMission()
{
return _Mission;
}
const CMissionPD* CHandledAIGroupPD::getMission() const
{
return _Mission;
}
void CHandledAIGroupPD::clear()
{
_DespawnTime = 0;
PDSLib.set(13, __BaseRow, (RY_PDS::TColumnIndex)(1), 0);
}
CHandledAIGroupPD* CHandledAIGroupPD::cast(RY_PDS::IPDBaseData* obj)
{
return (obj->getTable() == 13) ? static_cast<CHandledAIGroupPD*>(obj) : NULL;
}
const CHandledAIGroupPD* CHandledAIGroupPD::cast(const RY_PDS::IPDBaseData* obj)
{
return (obj->getTable() == 13) ? static_cast<const CHandledAIGroupPD*>(obj) : NULL;
}
void CHandledAIGroupPD::apply(CPersistentDataRecord &__pdr)
{
uint16 __Tok_MapKey = __pdr.addString("__Key__");
uint16 __Tok_MapVal = __pdr.addString("__Val__");
uint16 __Tok_ClassName = __pdr.addString("__Class__");
uint16 __TokGroupAlias = __pdr.addString("GroupAlias");
uint16 __TokDespawnTime = __pdr.addString("DespawnTime");
_Mission = NULL;
while (!__pdr.isEndOfStruct())
{
if (false) {}
else if (__pdr.peekNextToken() == __TokGroupAlias)
{
__pdr.pop(__TokGroupAlias, _GroupAlias);
}
else if (__pdr.peekNextToken() == __TokDespawnTime)
{
__pdr.pop(__TokDespawnTime, _DespawnTime);
}
else
{
nlwarning("Skipping unrecognised token: %s", __pdr.peekNextTokenName().c_str());
__pdr.skipData();
}
}
}
void CHandledAIGroupPD::store(CPersistentDataRecord &__pdr) const
{
uint16 __Tok_MapKey = __pdr.addString("__Key__");
uint16 __Tok_MapVal = __pdr.addString("__Val__");
uint16 __Tok_ClassName = __pdr.addString("__Class__");
uint16 __TokGroupAlias = __pdr.addString("GroupAlias");
uint16 __TokDespawnTime = __pdr.addString("DespawnTime");
__pdr.push(__TokGroupAlias, _GroupAlias);
__pdr.push(__TokDespawnTime, _DespawnTime);
}
void CHandledAIGroupPD::pds__init(const uint32 &GroupAlias)
{
_GroupAlias = GroupAlias;
_DespawnTime = 0;
_Mission = NULL;
}
void CHandledAIGroupPD::pds__destroy()
{
}
void CHandledAIGroupPD::pds__fetch(RY_PDS::CPData &data)
{
data.serial(_GroupAlias);
data.serial(_DespawnTime);
_Mission = NULL;
}
void CHandledAIGroupPD::pds__register()
{
__BaseRow = _IndexAllocator.allocate();
PDSLib.allocateRow(13, __BaseRow, 0);
pds__registerAttributes();
}
void CHandledAIGroupPD::pds__registerAttributes()
{
if (RY_PDS::PDVerbose) nldebug("CHandledAIGroupPD: registerAttributes %u:%u", 13, __BaseRow);
PDSLib.set(13, __BaseRow, (RY_PDS::TColumnIndex)(0), _GroupAlias);
}
void CHandledAIGroupPD::pds__unregister()
{
pds__unregisterAttributes();
PDSLib.deallocateRow(13, __BaseRow);
_IndexAllocator.deallocate(__BaseRow);
}
void CHandledAIGroupPD::pds__unregisterAttributes()
{
if (RY_PDS::PDVerbose) nldebug("CHandledAIGroupPD: unregisterAttributes %u:%u", 13, __BaseRow);
pds__setParent(NULL);
}
void CHandledAIGroupPD::pds__setParent(CMissionPD* __parent)
{
_Mission = __parent;
PDSLib.setParent(13, getRow(), (RY_PDS::TColumnIndex)(2), (__parent != NULL ? RY_PDS::CObjectIndex(__parent->getTable(), __parent->getRow()) : RY_PDS::CObjectIndex::null()));
}
void CHandledAIGroupPD::pds__setParentUnnotified(CMissionPD* __parent)
{
_Mission = __parent;
}
void CHandledAIGroupPD::pds__notifyInit()
{
}
void CHandledAIGroupPD::pds__notifyRelease()
{
PDSLib.release(13, __BaseRow);
}
void CHandledAIGroupPD::pds_static__init()
{
PDSLib.setIndexAllocator(13, _IndexAllocator);
}
RY_PDS::CIndexAllocator CHandledAIGroupPD::_IndexAllocator;
// End of static implementation of CHandledAIGroupPD
/* -----------------------------------------
* Static Implementation of CMissionPD
* ----------------------------------------- */
uint32 CMissionPD::getTemplateId() const
{
return _TemplateId;
}
uint32 CMissionPD::getMainMissionTemplateId() const
{
return _MainMissionTemplateId;
}
void CMissionPD::setMainMissionTemplateId(uint32 __v, bool forceWrite)
{
if ((_MainMissionTemplateId != __v) || forceWrite)
{
PDSLib.set(__BaseTable, __BaseRow, (RY_PDS::TColumnIndex)(1), __v);
}
_MainMissionTemplateId = __v;
}
uint32 CMissionPD::getGiver() const
{
return _Giver;
}
void CMissionPD::setGiver(uint32 __v, bool forceWrite)
{
if ((_Giver != __v) || forceWrite)
{
PDSLib.set(__BaseTable, __BaseRow, (RY_PDS::TColumnIndex)(2), __v);
}
_Giver = __v;
}
float CMissionPD::getHourLowerBound() const
{
return _HourLowerBound;
}
void CMissionPD::setHourLowerBound(float __v, bool forceWrite)
{
if ((_HourLowerBound != __v) || forceWrite)
{
PDSLib.set(__BaseTable, __BaseRow, (RY_PDS::TColumnIndex)(3), __v);
}
_HourLowerBound = __v;
}
float CMissionPD::getHourUpperBound() const
{
return _HourUpperBound;
}
void CMissionPD::setHourUpperBound(float __v, bool forceWrite)
{
if ((_HourUpperBound != __v) || forceWrite)
{
PDSLib.set(__BaseTable, __BaseRow, (RY_PDS::TColumnIndex)(4), __v);
}
_HourUpperBound = __v;
}
CSeason::TSeason CMissionPD::getSeason() const
{
return _Season;
}
void CMissionPD::setSeason(CSeason::TSeason __v, bool forceWrite)
{
nlassert(__v<CSeason::___TSeason_useSize);
if ((_Season != __v) || forceWrite)
{
PDSLib.set(__BaseTable, __BaseRow, (RY_PDS::TColumnIndex)(5), (uint32)__v);
}
_Season = __v;
}
uint32 CMissionPD::getMonoEndDate() const
{
return _MonoEndDate;
}
void CMissionPD::setMonoEndDate(uint32 __v, bool forceWrite)
{
if ((_MonoEndDate != __v) || forceWrite)
{
PDSLib.set(__BaseTable, __BaseRow, (RY_PDS::TColumnIndex)(6), __v);
}
_MonoEndDate = __v;
}
uint32 CMissionPD::getEndDate() const
{
return _EndDate;
}
void CMissionPD::setEndDate(uint32 __v, bool forceWrite)
{
if ((_EndDate != __v) || forceWrite)
{
PDSLib.set(__BaseTable, __BaseRow, (RY_PDS::TColumnIndex)(7), __v);
}
_EndDate = __v;
}
uint32 CMissionPD::getCriticalPartEndDate() const
{
return _CriticalPartEndDate;
}
void CMissionPD::setCriticalPartEndDate(uint32 __v, bool forceWrite)
{
if ((_CriticalPartEndDate != __v) || forceWrite)
{
PDSLib.set(__BaseTable, __BaseRow, (RY_PDS::TColumnIndex)(8), __v);
}
_CriticalPartEndDate = __v;
}
uint32 CMissionPD::getBeginDate() const
{
return _BeginDate;
}
void CMissionPD::setBeginDate(uint32 __v, bool forceWrite)
{
if ((_BeginDate != __v) || forceWrite)
{
PDSLib.set(__BaseTable, __BaseRow, (RY_PDS::TColumnIndex)(9), __v);
}
_BeginDate = __v;
}
uint32 CMissionPD::getFailureIndex() const
{
return _FailureIndex;
}
void CMissionPD::setFailureIndex(uint32 __v, bool forceWrite)
{
if ((_FailureIndex != __v) || forceWrite)
{
PDSLib.set(__BaseTable, __BaseRow, (RY_PDS::TColumnIndex)(10), __v);
}
_FailureIndex = __v;
}
uint32 CMissionPD::getCrashHandlerIndex() const
{
return _CrashHandlerIndex;
}
void CMissionPD::setCrashHandlerIndex(uint32 __v, bool forceWrite)
{
if ((_CrashHandlerIndex != __v) || forceWrite)
{
PDSLib.set(__BaseTable, __BaseRow, (RY_PDS::TColumnIndex)(11), __v);
}
_CrashHandlerIndex = __v;
}
uint32 CMissionPD::getPlayerReconnectHandlerIndex() const
{
return _PlayerReconnectHandlerIndex;
}
void CMissionPD::setPlayerReconnectHandlerIndex(uint32 __v, bool forceWrite)
{
if ((_PlayerReconnectHandlerIndex != __v) || forceWrite)
{
PDSLib.set(__BaseTable, __BaseRow, (RY_PDS::TColumnIndex)(12), __v);
}
_PlayerReconnectHandlerIndex = __v;
}
bool CMissionPD::getFinished() const
{
return _Finished;
}
void CMissionPD::setFinished(bool __v, bool forceWrite)
{
if ((_Finished != __v) || forceWrite)
{
PDSLib.set(__BaseTable, __BaseRow, (RY_PDS::TColumnIndex)(13), __v);
}
_Finished = __v;
}
bool CMissionPD::getMissionSuccess() const
{
return _MissionSuccess;
}
void CMissionPD::setMissionSuccess(bool __v, bool forceWrite)
{
if ((_MissionSuccess != __v) || forceWrite)
{
PDSLib.set(__BaseTable, __BaseRow, (RY_PDS::TColumnIndex)(14), __v);
}
_MissionSuccess = __v;
}
uint32 CMissionPD::getDescIndex() const
{
return _DescIndex;
}
void CMissionPD::setDescIndex(uint32 __v, bool forceWrite)
{
if ((_DescIndex != __v) || forceWrite)
{
PDSLib.set(__BaseTable, __BaseRow, (RY_PDS::TColumnIndex)(15), __v);
}
_DescIndex = __v;
}
uint32 CMissionPD::getWaitingQueueId() const
{
return _WaitingQueueId;
}
void CMissionPD::setWaitingQueueId(uint32 __v, bool forceWrite)
{
if ((_WaitingQueueId != __v) || forceWrite)
{
PDSLib.set(__BaseTable, __BaseRow, (RY_PDS::TColumnIndex)(16), __v);
}
_WaitingQueueId = __v;
}
CActiveStepPD* CMissionPD::getSteps(const uint32& __k)
{
std::map<uint32, CActiveStepPD>::iterator _it = _Steps.find(__k);
return (_it==_Steps.end() ? NULL : &((*_it).second));
}
const CActiveStepPD* CMissionPD::getSteps(const uint32& __k) const
{
std::map<uint32, CActiveStepPD>::const_iterator _it = _Steps.find(__k);
return (_it==_Steps.end() ? NULL : &((*_it).second));
}
std::map<uint32, CActiveStepPD>::iterator CMissionPD::getStepsBegin()
{
return _Steps.begin();
}
std::map<uint32, CActiveStepPD>::iterator CMissionPD::getStepsEnd()
{
return _Steps.end();
}
std::map<uint32, CActiveStepPD>::const_iterator CMissionPD::getStepsBegin() const
{
return _Steps.begin();
}
std::map<uint32, CActiveStepPD>::const_iterator CMissionPD::getStepsEnd() const
{
return _Steps.end();
}
const std::map<uint32, CActiveStepPD> & CMissionPD::getSteps() const
{
return _Steps;
}
CActiveStepPD* CMissionPD::addToSteps(const uint32 &__k)
{
std::map<uint32, CActiveStepPD>::iterator __it = _Steps.find(__k);
if (__it == _Steps.end())
{
__it = _Steps.insert(std::map<uint32, CActiveStepPD>::value_type(__k, CActiveStepPD())).first;
CActiveStepPD* __o = &((*__it).second);
__o->pds__init(__k);
__o->pds__register();
__o->pds__setParent(this);
}
return &((*__it).second);
}
void CMissionPD::deleteFromSteps(const uint32 &__k)
{
std::map<uint32, CActiveStepPD>::iterator __it = _Steps.find(__k);
if (__it == _Steps.end()) return;
CActiveStepPD& __o = (*__it).second;
__o.pds__unregister();
_Steps.erase(__it);
}
CMissionCompassPD* CMissionPD::getCompass(const uint32& __k)
{
std::map<uint32, CMissionCompassPD>::iterator _it = _Compass.find(__k);
return (_it==_Compass.end() ? NULL : &((*_it).second));
}
const CMissionCompassPD* CMissionPD::getCompass(const uint32& __k) const
{
std::map<uint32, CMissionCompassPD>::const_iterator _it = _Compass.find(__k);
return (_it==_Compass.end() ? NULL : &((*_it).second));
}
std::map<uint32, CMissionCompassPD>::iterator CMissionPD::getCompassBegin()
{
return _Compass.begin();
}
std::map<uint32, CMissionCompassPD>::iterator CMissionPD::getCompassEnd()
{
return _Compass.end();
}
std::map<uint32, CMissionCompassPD>::const_iterator CMissionPD::getCompassBegin() const
{
return _Compass.begin();
}
std::map<uint32, CMissionCompassPD>::const_iterator CMissionPD::getCompassEnd() const
{
return _Compass.end();
}
const std::map<uint32, CMissionCompassPD> & CMissionPD::getCompass() const
{
return _Compass;
}
CMissionCompassPD* CMissionPD::addToCompass(const uint32 &__k)
{
std::map<uint32, CMissionCompassPD>::iterator __it = _Compass.find(__k);
if (__it == _Compass.end())
{
__it = _Compass.insert(std::map<uint32, CMissionCompassPD>::value_type(__k, CMissionCompassPD())).first;
CMissionCompassPD* __o = &((*__it).second);
__o->pds__init(__k);
__o->pds__register();
__o->pds__setParent(this);
}
return &((*__it).second);
}
void CMissionPD::deleteFromCompass(const uint32 &__k)
{
std::map<uint32, CMissionCompassPD>::iterator __it = _Compass.find(__k);
if (__it == _Compass.end()) return;
CMissionCompassPD& __o = (*__it).second;
__o.pds__unregister();
_Compass.erase(__it);
}
CDoneStepPD* CMissionPD::getStepsDone(const uint32& __k)
{
std::map<uint32, CDoneStepPD>::iterator _it = _StepsDone.find(__k);
return (_it==_StepsDone.end() ? NULL : &((*_it).second));
}
const CDoneStepPD* CMissionPD::getStepsDone(const uint32& __k) const
{
std::map<uint32, CDoneStepPD>::const_iterator _it = _StepsDone.find(__k);
return (_it==_StepsDone.end() ? NULL : &((*_it).second));
}
std::map<uint32, CDoneStepPD>::iterator CMissionPD::getStepsDoneBegin()
{
return _StepsDone.begin();
}
std::map<uint32, CDoneStepPD>::iterator CMissionPD::getStepsDoneEnd()
{
return _StepsDone.end();
}
std::map<uint32, CDoneStepPD>::const_iterator CMissionPD::getStepsDoneBegin() const
{
return _StepsDone.begin();
}
std::map<uint32, CDoneStepPD>::const_iterator CMissionPD::getStepsDoneEnd() const
{
return _StepsDone.end();
}
const std::map<uint32, CDoneStepPD> & CMissionPD::getStepsDone() const
{
return _StepsDone;
}
CDoneStepPD* CMissionPD::addToStepsDone(const uint32 &__k)
{
std::map<uint32, CDoneStepPD>::iterator __it = _StepsDone.find(__k);
if (__it == _StepsDone.end())
{
__it = _StepsDone.insert(std::map<uint32, CDoneStepPD>::value_type(__k, CDoneStepPD())).first;
CDoneStepPD* __o = &((*__it).second);
__o->pds__init(__k);
__o->pds__register();
__o->pds__setParent(this);
}
return &((*__it).second);
}
void CMissionPD::deleteFromStepsDone(const uint32 &__k)
{
std::map<uint32, CDoneStepPD>::iterator __it = _StepsDone.find(__k);
if (__it == _StepsDone.end()) return;
CDoneStepPD& __o = (*__it).second;
__o.pds__unregister();
_StepsDone.erase(__it);
}
CMissionTeleportPD* CMissionPD::getTeleports(const uint32& __k)
{
std::map<uint32, CMissionTeleportPD>::iterator _it = _Teleports.find(__k);
return (_it==_Teleports.end() ? NULL : &((*_it).second));
}
const CMissionTeleportPD* CMissionPD::getTeleports(const uint32& __k) const
{
std::map<uint32, CMissionTeleportPD>::const_iterator _it = _Teleports.find(__k);
return (_it==_Teleports.end() ? NULL : &((*_it).second));
}
std::map<uint32, CMissionTeleportPD>::iterator CMissionPD::getTeleportsBegin()
{
return _Teleports.begin();
}
std::map<uint32, CMissionTeleportPD>::iterator CMissionPD::getTeleportsEnd()
{
return _Teleports.end();
}
std::map<uint32, CMissionTeleportPD>::const_iterator CMissionPD::getTeleportsBegin() const
{
return _Teleports.begin();
}
std::map<uint32, CMissionTeleportPD>::const_iterator CMissionPD::getTeleportsEnd() const
{
return _Teleports.end();
}
const std::map<uint32, CMissionTeleportPD> & CMissionPD::getTeleports() const
{
return _Teleports;
}
CMissionTeleportPD* CMissionPD::addToTeleports(const uint32 &__k)
{
std::map<uint32, CMissionTeleportPD>::iterator __it = _Teleports.find(__k);
if (__it == _Teleports.end())
{
__it = _Teleports.insert(std::map<uint32, CMissionTeleportPD>::value_type(__k, CMissionTeleportPD())).first;
CMissionTeleportPD* __o = &((*__it).second);
__o->pds__init(__k);
__o->pds__register();
__o->pds__setParent(this);
}
return &((*__it).second);
}
void CMissionPD::deleteFromTeleports(const uint32 &__k)
{
std::map<uint32, CMissionTeleportPD>::iterator __it = _Teleports.find(__k);
if (__it == _Teleports.end()) return;
CMissionTeleportPD& __o = (*__it).second;
__o.pds__unregister();
_Teleports.erase(__it);
}
CMissionInsidePlacePD* CMissionPD::getInsidePlaces(const uint32& __k)
{
std::map<uint32, CMissionInsidePlacePD>::iterator _it = _InsidePlaces.find(__k);
return (_it==_InsidePlaces.end() ? NULL : &((*_it).second));
}
const CMissionInsidePlacePD* CMissionPD::getInsidePlaces(const uint32& __k) const
{
std::map<uint32, CMissionInsidePlacePD>::const_iterator _it = _InsidePlaces.find(__k);
return (_it==_InsidePlaces.end() ? NULL : &((*_it).second));
}
std::map<uint32, CMissionInsidePlacePD>::iterator CMissionPD::getInsidePlacesBegin()
{
return _InsidePlaces.begin();
}
std::map<uint32, CMissionInsidePlacePD>::iterator CMissionPD::getInsidePlacesEnd()
{
return _InsidePlaces.end();
}
std::map<uint32, CMissionInsidePlacePD>::const_iterator CMissionPD::getInsidePlacesBegin() const
{
return _InsidePlaces.begin();
}
std::map<uint32, CMissionInsidePlacePD>::const_iterator CMissionPD::getInsidePlacesEnd() const
{
return _InsidePlaces.end();
}
const std::map<uint32, CMissionInsidePlacePD> & CMissionPD::getInsidePlaces() const
{
return _InsidePlaces;
}
CMissionInsidePlacePD* CMissionPD::addToInsidePlaces(const uint32 &__k)
{
std::map<uint32, CMissionInsidePlacePD>::iterator __it = _InsidePlaces.find(__k);
if (__it == _InsidePlaces.end())
{
__it = _InsidePlaces.insert(std::map<uint32, CMissionInsidePlacePD>::value_type(__k, CMissionInsidePlacePD())).first;
CMissionInsidePlacePD* __o = &((*__it).second);
__o->pds__init(__k);
__o->pds__register();
__o->pds__setParent(this);
}
return &((*__it).second);
}
void CMissionPD::deleteFromInsidePlaces(const uint32 &__k)
{
std::map<uint32, CMissionInsidePlacePD>::iterator __it = _InsidePlaces.find(__k);
if (__it == _InsidePlaces.end()) return;
CMissionInsidePlacePD& __o = (*__it).second;
__o.pds__unregister();
_InsidePlaces.erase(__it);
}
CMissionOutsidePlacePD* CMissionPD::getOutsidePlaces(const uint32& __k)
{
std::map<uint32, CMissionOutsidePlacePD>::iterator _it = _OutsidePlaces.find(__k);
return (_it==_OutsidePlaces.end() ? NULL : &((*_it).second));
}
const CMissionOutsidePlacePD* CMissionPD::getOutsidePlaces(const uint32& __k) const
{
std::map<uint32, CMissionOutsidePlacePD>::const_iterator _it = _OutsidePlaces.find(__k);
return (_it==_OutsidePlaces.end() ? NULL : &((*_it).second));
}
std::map<uint32, CMissionOutsidePlacePD>::iterator CMissionPD::getOutsidePlacesBegin()
{
return _OutsidePlaces.begin();
}
std::map<uint32, CMissionOutsidePlacePD>::iterator CMissionPD::getOutsidePlacesEnd()
{
return _OutsidePlaces.end();
}
std::map<uint32, CMissionOutsidePlacePD>::const_iterator CMissionPD::getOutsidePlacesBegin() const
{
return _OutsidePlaces.begin();
}
std::map<uint32, CMissionOutsidePlacePD>::const_iterator CMissionPD::getOutsidePlacesEnd() const
{
return _OutsidePlaces.end();
}
const std::map<uint32, CMissionOutsidePlacePD> & CMissionPD::getOutsidePlaces() const
{
return _OutsidePlaces;
}
CMissionOutsidePlacePD* CMissionPD::addToOutsidePlaces(const uint32 &__k)
{
std::map<uint32, CMissionOutsidePlacePD>::iterator __it = _OutsidePlaces.find(__k);
if (__it == _OutsidePlaces.end())
{
__it = _OutsidePlaces.insert(std::map<uint32, CMissionOutsidePlacePD>::value_type(__k, CMissionOutsidePlacePD())).first;
CMissionOutsidePlacePD* __o = &((*__it).second);
__o->pds__init(__k);
__o->pds__register();
__o->pds__setParent(this);
}
return &((*__it).second);
}
void CMissionPD::deleteFromOutsidePlaces(const uint32 &__k)
{
std::map<uint32, CMissionOutsidePlacePD>::iterator __it = _OutsidePlaces.find(__k);
if (__it == _OutsidePlaces.end()) return;
CMissionOutsidePlacePD& __o = (*__it).second;
__o.pds__unregister();
_OutsidePlaces.erase(__it);
}
CHandledAIGroupPD* CMissionPD::getHandledAIGroups(const uint32& __k)
{
std::map<uint32, CHandledAIGroupPD>::iterator _it = _HandledAIGroups.find(__k);
return (_it==_HandledAIGroups.end() ? NULL : &((*_it).second));
}
const CHandledAIGroupPD* CMissionPD::getHandledAIGroups(const uint32& __k) const
{
std::map<uint32, CHandledAIGroupPD>::const_iterator _it = _HandledAIGroups.find(__k);
return (_it==_HandledAIGroups.end() ? NULL : &((*_it).second));
}
std::map<uint32, CHandledAIGroupPD>::iterator CMissionPD::getHandledAIGroupsBegin()
{
return _HandledAIGroups.begin();
}
std::map<uint32, CHandledAIGroupPD>::iterator CMissionPD::getHandledAIGroupsEnd()
{
return _HandledAIGroups.end();
}
std::map<uint32, CHandledAIGroupPD>::const_iterator CMissionPD::getHandledAIGroupsBegin() const
{
return _HandledAIGroups.begin();
}
std::map<uint32, CHandledAIGroupPD>::const_iterator CMissionPD::getHandledAIGroupsEnd() const
{
return _HandledAIGroups.end();
}
const std::map<uint32, CHandledAIGroupPD> & CMissionPD::getHandledAIGroups() const
{
return _HandledAIGroups;
}
CHandledAIGroupPD* CMissionPD::addToHandledAIGroups(const uint32 &__k)
{
std::map<uint32, CHandledAIGroupPD>::iterator __it = _HandledAIGroups.find(__k);
if (__it == _HandledAIGroups.end())
{
__it = _HandledAIGroups.insert(std::map<uint32, CHandledAIGroupPD>::value_type(__k, CHandledAIGroupPD())).first;
CHandledAIGroupPD* __o = &((*__it).second);
__o->pds__init(__k);
__o->pds__register();
__o->pds__setParent(this);
}
return &((*__it).second);
}
void CMissionPD::deleteFromHandledAIGroups(const uint32 &__k)
{
std::map<uint32, CHandledAIGroupPD>::iterator __it = _HandledAIGroups.find(__k);
if (__it == _HandledAIGroups.end()) return;
CHandledAIGroupPD& __o = (*__it).second;
__o.pds__unregister();
_HandledAIGroups.erase(__it);
}
CMissionContainerPD* CMissionPD::getContainer()
{
return _Container;
}
const CMissionContainerPD* CMissionPD::getContainer() const
{
return _Container;
}
void CMissionPD::clear()
{
_MainMissionTemplateId = 0;
PDSLib.set(__BaseTable, __BaseRow, (RY_PDS::TColumnIndex)(1), 0);
_Giver = 0;
PDSLib.set(__BaseTable, __BaseRow, (RY_PDS::TColumnIndex)(2), 0);
_HourLowerBound = 0.0f;
PDSLib.set(__BaseTable, __BaseRow, (RY_PDS::TColumnIndex)(3), 0.0f);
_HourUpperBound = 0.0f;
PDSLib.set(__BaseTable, __BaseRow, (RY_PDS::TColumnIndex)(4), 0.0f);
_Season = (CSeason::TSeason)0;
PDSLib.set(__BaseTable, __BaseRow, (RY_PDS::TColumnIndex)(5), (uint32)(CSeason::TSeason)0);
_MonoEndDate = 0;
PDSLib.set(__BaseTable, __BaseRow, (RY_PDS::TColumnIndex)(6), 0);
_EndDate = 0;
PDSLib.set(__BaseTable, __BaseRow, (RY_PDS::TColumnIndex)(7), 0);
_CriticalPartEndDate = 0;
PDSLib.set(__BaseTable, __BaseRow, (RY_PDS::TColumnIndex)(8), 0);
_BeginDate = 0;
PDSLib.set(__BaseTable, __BaseRow, (RY_PDS::TColumnIndex)(9), 0);
_FailureIndex = 0;
PDSLib.set(__BaseTable, __BaseRow, (RY_PDS::TColumnIndex)(10), 0);
_CrashHandlerIndex = 0xFFFFFFFF;
PDSLib.set(__BaseTable, __BaseRow, (RY_PDS::TColumnIndex)(11), 0xFFFFFFFF);
_PlayerReconnectHandlerIndex = 0xFFFFFFFF;
PDSLib.set(__BaseTable, __BaseRow, (RY_PDS::TColumnIndex)(12), 0xFFFFFFFF);
_Finished = false;
PDSLib.set(__BaseTable, __BaseRow, (RY_PDS::TColumnIndex)(13), false);
_MissionSuccess = true;
PDSLib.set(__BaseTable, __BaseRow, (RY_PDS::TColumnIndex)(14), true);
_DescIndex = 0;
PDSLib.set(__BaseTable, __BaseRow, (RY_PDS::TColumnIndex)(15), 0);
_WaitingQueueId = 0;
PDSLib.set(__BaseTable, __BaseRow, (RY_PDS::TColumnIndex)(16), 0);
for (std::map<uint32, CActiveStepPD>::iterator __it=_Steps.begin(); __it!=_Steps.end(); )
{
std::map<uint32, CActiveStepPD>::iterator __itr=__it++;
CActiveStepPD* __o = &((*__itr).second);
__o->pds__unregister();
__o->pds__destroy();
}
_Steps.clear();
for (std::map<uint32, CMissionCompassPD>::iterator __it=_Compass.begin(); __it!=_Compass.end(); )
{
std::map<uint32, CMissionCompassPD>::iterator __itr=__it++;
CMissionCompassPD* __o = &((*__itr).second);
__o->pds__unregister();
__o->pds__destroy();
}
_Compass.clear();
for (std::map<uint32, CDoneStepPD>::iterator __it=_StepsDone.begin(); __it!=_StepsDone.end(); )
{
std::map<uint32, CDoneStepPD>::iterator __itr=__it++;
CDoneStepPD* __o = &((*__itr).second);
__o->pds__unregister();
__o->pds__destroy();
}
_StepsDone.clear();
for (std::map<uint32, CMissionTeleportPD>::iterator __it=_Teleports.begin(); __it!=_Teleports.end(); )
{
std::map<uint32, CMissionTeleportPD>::iterator __itr=__it++;
CMissionTeleportPD* __o = &((*__itr).second);
__o->pds__unregister();
__o->pds__destroy();
}
_Teleports.clear();
for (std::map<uint32, CMissionInsidePlacePD>::iterator __it=_InsidePlaces.begin(); __it!=_InsidePlaces.end(); )
{
std::map<uint32, CMissionInsidePlacePD>::iterator __itr=__it++;
CMissionInsidePlacePD* __o = &((*__itr).second);
__o->pds__unregister();
__o->pds__destroy();
}
_InsidePlaces.clear();
for (std::map<uint32, CMissionOutsidePlacePD>::iterator __it=_OutsidePlaces.begin(); __it!=_OutsidePlaces.end(); )
{
std::map<uint32, CMissionOutsidePlacePD>::iterator __itr=__it++;
CMissionOutsidePlacePD* __o = &((*__itr).second);
__o->pds__unregister();
__o->pds__destroy();
}
_OutsidePlaces.clear();
for (std::map<uint32, CHandledAIGroupPD>::iterator __it=_HandledAIGroups.begin(); __it!=_HandledAIGroups.end(); )
{
std::map<uint32, CHandledAIGroupPD>::iterator __itr=__it++;
CHandledAIGroupPD* __o = &((*__itr).second);
__o->pds__unregister();
__o->pds__destroy();
}
_HandledAIGroups.clear();
}
CMissionPD* CMissionPD::cast(RY_PDS::IPDBaseData* obj)
{
switch (obj->getTable())
{
case 14:
case 15:
case 16:
case 17:
return static_cast<CMissionPD*>(obj);
}
return NULL;
}
const CMissionPD* CMissionPD::cast(const RY_PDS::IPDBaseData* obj)
{
switch (obj->getTable())
{
case 14:
case 15:
case 16:
case 17:
return static_cast<const CMissionPD*>(obj);
}
return NULL;
}
void CMissionPD::setFactory(RY_PDS::TPDFactory userFactory)
{
pds_static__setFactory(userFactory);
}
CMissionPD* CMissionPD::create(const uint32 &TemplateId)
{
CMissionPD *__o = static_cast<CMissionPD*>(PDSLib.create(14));
__o->pds__init(TemplateId);
__o->pds__register();
__o->pds__notifyInit();
return __o;
}
void CMissionPD::apply(CPersistentDataRecord &__pdr)
{
uint16 __Tok_MapKey = __pdr.addString("__Key__");
uint16 __Tok_MapVal = __pdr.addString("__Val__");
uint16 __Tok_ClassName = __pdr.addString("__Class__");
uint16 __TokTemplateId = __pdr.addString("TemplateId");
uint16 __TokMainMissionTemplateId = __pdr.addString("MainMissionTemplateId");
uint16 __TokGiver = __pdr.addString("Giver");
uint16 __TokHourLowerBound = __pdr.addString("HourLowerBound");
uint16 __TokHourUpperBound = __pdr.addString("HourUpperBound");
uint16 __TokSeason = __pdr.addString("Season");
uint16 __TokMonoEndDate = __pdr.addString("MonoEndDate");
uint16 __TokEndDate = __pdr.addString("EndDate");
uint16 __TokCriticalPartEndDate = __pdr.addString("CriticalPartEndDate");
uint16 __TokBeginDate = __pdr.addString("BeginDate");
uint16 __TokFailureIndex = __pdr.addString("FailureIndex");
uint16 __TokCrashHandlerIndex = __pdr.addString("CrashHandlerIndex");
uint16 __TokPlayerReconnectHandlerIndex = __pdr.addString("PlayerReconnectHandlerIndex");
uint16 __TokFinished = __pdr.addString("Finished");
uint16 __TokMissionSuccess = __pdr.addString("MissionSuccess");
uint16 __TokDescIndex = __pdr.addString("DescIndex");
uint16 __TokWaitingQueueId = __pdr.addString("WaitingQueueId");
uint16 __TokSteps = __pdr.addString("Steps");
uint16 __TokCompass = __pdr.addString("Compass");
uint16 __TokStepsDone = __pdr.addString("StepsDone");
uint16 __TokTeleports = __pdr.addString("Teleports");
uint16 __TokInsidePlaces = __pdr.addString("InsidePlaces");
uint16 __TokOutsidePlaces = __pdr.addString("OutsidePlaces");
uint16 __TokHandledAIGroups = __pdr.addString("HandledAIGroups");
_Container = NULL;
while (!__pdr.isEndOfStruct())
{
if (false) {}
else if (__pdr.peekNextToken() == __TokTemplateId)
{
__pdr.pop(__TokTemplateId, _TemplateId);
}
else if (__pdr.peekNextToken() == __TokMainMissionTemplateId)
{
__pdr.pop(__TokMainMissionTemplateId, _MainMissionTemplateId);
}
else if (__pdr.peekNextToken() == __TokGiver)
{
__pdr.pop(__TokGiver, _Giver);
}
else if (__pdr.peekNextToken() == __TokHourLowerBound)
{
__pdr.pop(__TokHourLowerBound, _HourLowerBound);
}
else if (__pdr.peekNextToken() == __TokHourUpperBound)
{
__pdr.pop(__TokHourUpperBound, _HourUpperBound);
}
else if (__pdr.peekNextToken() == __TokSeason)
{
{
std::string valuename;
__pdr.pop(__TokSeason, valuename);
_Season = CSeason::fromString(valuename);
}
}
else if (__pdr.peekNextToken() == __TokMonoEndDate)
{
__pdr.pop(__TokMonoEndDate, _MonoEndDate);
}
else if (__pdr.peekNextToken() == __TokEndDate)
{
__pdr.pop(__TokEndDate, _EndDate);
}
else if (__pdr.peekNextToken() == __TokCriticalPartEndDate)
{
__pdr.pop(__TokCriticalPartEndDate, _CriticalPartEndDate);
}
else if (__pdr.peekNextToken() == __TokBeginDate)
{
__pdr.pop(__TokBeginDate, _BeginDate);
}
else if (__pdr.peekNextToken() == __TokFailureIndex)
{
__pdr.pop(__TokFailureIndex, _FailureIndex);
}
else if (__pdr.peekNextToken() == __TokCrashHandlerIndex)
{
__pdr.pop(__TokCrashHandlerIndex, _CrashHandlerIndex);
}
else if (__pdr.peekNextToken() == __TokPlayerReconnectHandlerIndex)
{
__pdr.pop(__TokPlayerReconnectHandlerIndex, _PlayerReconnectHandlerIndex);
}
else if (__pdr.peekNextToken() == __TokFinished)
{
__pdr.pop(__TokFinished, _Finished);
}
else if (__pdr.peekNextToken() == __TokMissionSuccess)
{
__pdr.pop(__TokMissionSuccess, _MissionSuccess);
}
else if (__pdr.peekNextToken() == __TokDescIndex)
{
__pdr.pop(__TokDescIndex, _DescIndex);
}
else if (__pdr.peekNextToken() == __TokWaitingQueueId)
{
__pdr.pop(__TokWaitingQueueId, _WaitingQueueId);
}
// apply Steps
else if (__pdr.peekNextToken() == __TokSteps)
{
__pdr.popStructBegin(__TokSteps);
while (!__pdr.isEndOfStruct())
{
uint32 key;
__pdr.pop(__Tok_MapKey, key);
__pdr.popStructBegin(__Tok_MapVal);
CActiveStepPD& obj = _Steps[key];
obj.apply(__pdr);
obj.pds__setParentUnnotified(this);
__pdr.popStructEnd(__Tok_MapVal);
}
__pdr.popStructEnd(__TokSteps);
}
// end of apply Steps
// apply Compass
else if (__pdr.peekNextToken() == __TokCompass)
{
__pdr.popStructBegin(__TokCompass);
while (!__pdr.isEndOfStruct())
{
uint32 key;
__pdr.pop(__Tok_MapKey, key);
__pdr.popStructBegin(__Tok_MapVal);
CMissionCompassPD& obj = _Compass[key];
obj.apply(__pdr);
obj.pds__setParentUnnotified(this);
__pdr.popStructEnd(__Tok_MapVal);
}
__pdr.popStructEnd(__TokCompass);
}
// end of apply Compass
// apply StepsDone
else if (__pdr.peekNextToken() == __TokStepsDone)
{
__pdr.popStructBegin(__TokStepsDone);
while (!__pdr.isEndOfStruct())
{
uint32 key;
__pdr.pop(__Tok_MapKey, key);
__pdr.popStructBegin(__Tok_MapVal);
CDoneStepPD& obj = _StepsDone[key];
obj.apply(__pdr);
obj.pds__setParentUnnotified(this);
__pdr.popStructEnd(__Tok_MapVal);
}
__pdr.popStructEnd(__TokStepsDone);
}
// end of apply StepsDone
// apply Teleports
else if (__pdr.peekNextToken() == __TokTeleports)
{
__pdr.popStructBegin(__TokTeleports);
while (!__pdr.isEndOfStruct())
{
uint32 key;
__pdr.pop(__Tok_MapKey, key);
__pdr.popStructBegin(__Tok_MapVal);
CMissionTeleportPD& obj = _Teleports[key];
obj.apply(__pdr);
obj.pds__setParentUnnotified(this);
__pdr.popStructEnd(__Tok_MapVal);
}
__pdr.popStructEnd(__TokTeleports);
}
// end of apply Teleports
// apply InsidePlaces
else if (__pdr.peekNextToken() == __TokInsidePlaces)
{
__pdr.popStructBegin(__TokInsidePlaces);
while (!__pdr.isEndOfStruct())
{
uint32 key;
__pdr.pop(__Tok_MapKey, key);
__pdr.popStructBegin(__Tok_MapVal);
CMissionInsidePlacePD& obj = _InsidePlaces[key];
obj.apply(__pdr);
obj.pds__setParentUnnotified(this);
__pdr.popStructEnd(__Tok_MapVal);
}
__pdr.popStructEnd(__TokInsidePlaces);
}
// end of apply InsidePlaces
// apply OutsidePlaces
else if (__pdr.peekNextToken() == __TokOutsidePlaces)
{
__pdr.popStructBegin(__TokOutsidePlaces);
while (!__pdr.isEndOfStruct())
{
uint32 key;
__pdr.pop(__Tok_MapKey, key);
__pdr.popStructBegin(__Tok_MapVal);
CMissionOutsidePlacePD& obj = _OutsidePlaces[key];
obj.apply(__pdr);
obj.pds__setParentUnnotified(this);
__pdr.popStructEnd(__Tok_MapVal);
}
__pdr.popStructEnd(__TokOutsidePlaces);
}
// end of apply OutsidePlaces
// apply HandledAIGroups
else if (__pdr.peekNextToken() == __TokHandledAIGroups)
{
__pdr.popStructBegin(__TokHandledAIGroups);
while (!__pdr.isEndOfStruct())
{
uint32 key;
__pdr.pop(__Tok_MapKey, key);
__pdr.popStructBegin(__Tok_MapVal);
CHandledAIGroupPD& obj = _HandledAIGroups[key];
obj.apply(__pdr);
obj.pds__setParentUnnotified(this);
__pdr.popStructEnd(__Tok_MapVal);
}
__pdr.popStructEnd(__TokHandledAIGroups);
}
// end of apply HandledAIGroups
else
{
nlwarning("Skipping unrecognised token: %s", __pdr.peekNextTokenName().c_str());
__pdr.skipData();
}
}
}
void CMissionPD::store(CPersistentDataRecord &__pdr) const
{
uint16 __Tok_MapKey = __pdr.addString("__Key__");
uint16 __Tok_MapVal = __pdr.addString("__Val__");
uint16 __Tok_ClassName = __pdr.addString("__Class__");
uint16 __TokTemplateId = __pdr.addString("TemplateId");
uint16 __TokMainMissionTemplateId = __pdr.addString("MainMissionTemplateId");
uint16 __TokGiver = __pdr.addString("Giver");
uint16 __TokHourLowerBound = __pdr.addString("HourLowerBound");
uint16 __TokHourUpperBound = __pdr.addString("HourUpperBound");
uint16 __TokSeason = __pdr.addString("Season");
uint16 __TokMonoEndDate = __pdr.addString("MonoEndDate");
uint16 __TokEndDate = __pdr.addString("EndDate");
uint16 __TokCriticalPartEndDate = __pdr.addString("CriticalPartEndDate");
uint16 __TokBeginDate = __pdr.addString("BeginDate");
uint16 __TokFailureIndex = __pdr.addString("FailureIndex");
uint16 __TokCrashHandlerIndex = __pdr.addString("CrashHandlerIndex");
uint16 __TokPlayerReconnectHandlerIndex = __pdr.addString("PlayerReconnectHandlerIndex");
uint16 __TokFinished = __pdr.addString("Finished");
uint16 __TokMissionSuccess = __pdr.addString("MissionSuccess");
uint16 __TokDescIndex = __pdr.addString("DescIndex");
uint16 __TokWaitingQueueId = __pdr.addString("WaitingQueueId");
uint16 __TokSteps = __pdr.addString("Steps");
uint16 __TokCompass = __pdr.addString("Compass");
uint16 __TokStepsDone = __pdr.addString("StepsDone");
uint16 __TokTeleports = __pdr.addString("Teleports");
uint16 __TokInsidePlaces = __pdr.addString("InsidePlaces");
uint16 __TokOutsidePlaces = __pdr.addString("OutsidePlaces");
uint16 __TokHandledAIGroups = __pdr.addString("HandledAIGroups");
__pdr.push(__TokTemplateId, _TemplateId);
__pdr.push(__TokMainMissionTemplateId, _MainMissionTemplateId);
__pdr.push(__TokGiver, _Giver);
__pdr.push(__TokHourLowerBound, _HourLowerBound);
__pdr.push(__TokHourUpperBound, _HourUpperBound);
{
std::string valuename = CSeason::toString(_Season);
__pdr.push(__TokSeason, valuename);
}
__pdr.push(__TokMonoEndDate, _MonoEndDate);
__pdr.push(__TokEndDate, _EndDate);
__pdr.push(__TokCriticalPartEndDate, _CriticalPartEndDate);
__pdr.push(__TokBeginDate, _BeginDate);
__pdr.push(__TokFailureIndex, _FailureIndex);
__pdr.push(__TokCrashHandlerIndex, _CrashHandlerIndex);
__pdr.push(__TokPlayerReconnectHandlerIndex, _PlayerReconnectHandlerIndex);
__pdr.push(__TokFinished, _Finished);
__pdr.push(__TokMissionSuccess, _MissionSuccess);
__pdr.push(__TokDescIndex, _DescIndex);
__pdr.push(__TokWaitingQueueId, _WaitingQueueId);
// store Steps
__pdr.pushStructBegin(__TokSteps);
for (std::map<uint32, CActiveStepPD>::const_iterator it=_Steps.begin(); it!=_Steps.end(); ++it)
{
uint32 key = (*it).first;
__pdr.push(__Tok_MapKey, key);
__pdr.pushStructBegin(__Tok_MapVal);
(*it).second.store(__pdr);
__pdr.pushStructEnd(__Tok_MapVal);
}
__pdr.pushStructEnd(__TokSteps);
// end of store Steps
// store Compass
__pdr.pushStructBegin(__TokCompass);
for (std::map<uint32, CMissionCompassPD>::const_iterator it=_Compass.begin(); it!=_Compass.end(); ++it)
{
uint32 key = (*it).first;
__pdr.push(__Tok_MapKey, key);
__pdr.pushStructBegin(__Tok_MapVal);
(*it).second.store(__pdr);
__pdr.pushStructEnd(__Tok_MapVal);
}
__pdr.pushStructEnd(__TokCompass);
// end of store Compass
// store StepsDone
__pdr.pushStructBegin(__TokStepsDone);
for (std::map<uint32, CDoneStepPD>::const_iterator it=_StepsDone.begin(); it!=_StepsDone.end(); ++it)
{
uint32 key = (*it).first;
__pdr.push(__Tok_MapKey, key);
__pdr.pushStructBegin(__Tok_MapVal);
(*it).second.store(__pdr);
__pdr.pushStructEnd(__Tok_MapVal);
}
__pdr.pushStructEnd(__TokStepsDone);
// end of store StepsDone
// store Teleports
__pdr.pushStructBegin(__TokTeleports);
for (std::map<uint32, CMissionTeleportPD>::const_iterator it=_Teleports.begin(); it!=_Teleports.end(); ++it)
{
uint32 key = (*it).first;
__pdr.push(__Tok_MapKey, key);
__pdr.pushStructBegin(__Tok_MapVal);
(*it).second.store(__pdr);
__pdr.pushStructEnd(__Tok_MapVal);
}
__pdr.pushStructEnd(__TokTeleports);
// end of store Teleports
// store InsidePlaces
__pdr.pushStructBegin(__TokInsidePlaces);
for (std::map<uint32, CMissionInsidePlacePD>::const_iterator it=_InsidePlaces.begin(); it!=_InsidePlaces.end(); ++it)
{
uint32 key = (*it).first;
__pdr.push(__Tok_MapKey, key);
__pdr.pushStructBegin(__Tok_MapVal);
(*it).second.store(__pdr);
__pdr.pushStructEnd(__Tok_MapVal);
}
__pdr.pushStructEnd(__TokInsidePlaces);
// end of store InsidePlaces
// store OutsidePlaces
__pdr.pushStructBegin(__TokOutsidePlaces);
for (std::map<uint32, CMissionOutsidePlacePD>::const_iterator it=_OutsidePlaces.begin(); it!=_OutsidePlaces.end(); ++it)
{
uint32 key = (*it).first;
__pdr.push(__Tok_MapKey, key);
__pdr.pushStructBegin(__Tok_MapVal);
(*it).second.store(__pdr);
__pdr.pushStructEnd(__Tok_MapVal);
}
__pdr.pushStructEnd(__TokOutsidePlaces);
// end of store OutsidePlaces
// store HandledAIGroups
__pdr.pushStructBegin(__TokHandledAIGroups);
for (std::map<uint32, CHandledAIGroupPD>::const_iterator it=_HandledAIGroups.begin(); it!=_HandledAIGroups.end(); ++it)
{
uint32 key = (*it).first;
__pdr.push(__Tok_MapKey, key);
__pdr.pushStructBegin(__Tok_MapVal);
(*it).second.store(__pdr);
__pdr.pushStructEnd(__Tok_MapVal);
}
__pdr.pushStructEnd(__TokHandledAIGroups);
// end of store HandledAIGroups
}
void CMissionPD::init()
{
}
void CMissionPD::release()
{
}
void CMissionPD::pds__init(const uint32 &TemplateId)
{
_TemplateId = TemplateId;
_MainMissionTemplateId = 0;
_Giver = 0;
_HourLowerBound = 0.0f;
_HourUpperBound = 0.0f;
_Season = (CSeason::TSeason)0;
_MonoEndDate = 0;
_EndDate = 0;
_CriticalPartEndDate = 0;
_BeginDate = 0;
_FailureIndex = 0;
_CrashHandlerIndex = 0xFFFFFFFF;
_PlayerReconnectHandlerIndex = 0xFFFFFFFF;
_Finished = false;
_MissionSuccess = true;
_DescIndex = 0;
_WaitingQueueId = 0;
_Container = NULL;
}
void CMissionPD::pds__destroy()
{
for (std::map<uint32, CActiveStepPD>::iterator __it=_Steps.begin(); __it!=_Steps.end(); )
{
std::map<uint32, CActiveStepPD>::iterator __itr=__it++;
((*__itr).second).pds__destroy();
}
_Steps.clear();
for (std::map<uint32, CMissionCompassPD>::iterator __it=_Compass.begin(); __it!=_Compass.end(); )
{
std::map<uint32, CMissionCompassPD>::iterator __itr=__it++;
((*__itr).second).pds__destroy();
}
_Compass.clear();
for (std::map<uint32, CDoneStepPD>::iterator __it=_StepsDone.begin(); __it!=_StepsDone.end(); )
{
std::map<uint32, CDoneStepPD>::iterator __itr=__it++;
((*__itr).second).pds__destroy();
}
_StepsDone.clear();
for (std::map<uint32, CMissionTeleportPD>::iterator __it=_Teleports.begin(); __it!=_Teleports.end(); )
{
std::map<uint32, CMissionTeleportPD>::iterator __itr=__it++;
((*__itr).second).pds__destroy();
}
_Teleports.clear();
for (std::map<uint32, CMissionInsidePlacePD>::iterator __it=_InsidePlaces.begin(); __it!=_InsidePlaces.end(); )
{
std::map<uint32, CMissionInsidePlacePD>::iterator __itr=__it++;
((*__itr).second).pds__destroy();
}
_InsidePlaces.clear();
for (std::map<uint32, CMissionOutsidePlacePD>::iterator __it=_OutsidePlaces.begin(); __it!=_OutsidePlaces.end(); )
{
std::map<uint32, CMissionOutsidePlacePD>::iterator __itr=__it++;
((*__itr).second).pds__destroy();
}
_OutsidePlaces.clear();
for (std::map<uint32, CHandledAIGroupPD>::iterator __it=_HandledAIGroups.begin(); __it!=_HandledAIGroups.end(); )
{
std::map<uint32, CHandledAIGroupPD>::iterator __itr=__it++;
((*__itr).second).pds__destroy();
}
_HandledAIGroups.clear();
}
void CMissionPD::pds__fetch(RY_PDS::CPData &data)
{
data.serial(_TemplateId);
data.serial(_MainMissionTemplateId);
data.serial(_Giver);
data.serial(_HourLowerBound);
data.serial(_HourUpperBound);
data.serialEnum(_Season);
data.serial(_MonoEndDate);
data.serial(_EndDate);
data.serial(_CriticalPartEndDate);
data.serial(_BeginDate);
data.serial(_FailureIndex);
data.serial(_CrashHandlerIndex);
data.serial(_PlayerReconnectHandlerIndex);
data.serial(_Finished);
data.serial(_MissionSuccess);
data.serial(_DescIndex);
data.serial(_WaitingQueueId);
RY_PDS::TTableIndex tableIndex;
RY_PDS::TRowIndex rowIndex;
do
{
// read table and row, create an object, affect to the ref, and fetch it
data.serial(tableIndex, rowIndex);
if (rowIndex == RY_PDS::INVALID_ROW_INDEX || tableIndex == RY_PDS::INVALID_TABLE_INDEX) break;
uint32 __k;
data.serial(__k);
_Steps.insert(std::make_pair<uint32,CActiveStepPD>(__k, CActiveStepPD()));
CActiveStepPD* __o = &(_Steps[__k]);
PDSLib.setRowIndex(rowIndex, __o);
__o->pds__fetch(data);
__o->pds__setParentUnnotified(this);
}
while (true);
do
{
// read table and row, create an object, affect to the ref, and fetch it
data.serial(tableIndex, rowIndex);
if (rowIndex == RY_PDS::INVALID_ROW_INDEX || tableIndex == RY_PDS::INVALID_TABLE_INDEX) break;
uint32 __k;
data.serial(__k);
_Compass.insert(std::make_pair<uint32,CMissionCompassPD>(__k, CMissionCompassPD()));
CMissionCompassPD* __o = &(_Compass[__k]);
PDSLib.setRowIndex(rowIndex, __o);
__o->pds__fetch(data);
__o->pds__setParentUnnotified(this);
}
while (true);
do
{
// read table and row, create an object, affect to the ref, and fetch it
data.serial(tableIndex, rowIndex);
if (rowIndex == RY_PDS::INVALID_ROW_INDEX || tableIndex == RY_PDS::INVALID_TABLE_INDEX) break;
uint32 __k;
data.serial(__k);
_StepsDone.insert(std::make_pair<uint32,CDoneStepPD>(__k, CDoneStepPD()));
CDoneStepPD* __o = &(_StepsDone[__k]);
PDSLib.setRowIndex(rowIndex, __o);
__o->pds__fetch(data);
__o->pds__setParentUnnotified(this);
}
while (true);
do
{
// read table and row, create an object, affect to the ref, and fetch it
data.serial(tableIndex, rowIndex);
if (rowIndex == RY_PDS::INVALID_ROW_INDEX || tableIndex == RY_PDS::INVALID_TABLE_INDEX) break;
uint32 __k;
data.serial(__k);
_Teleports.insert(std::make_pair<uint32,CMissionTeleportPD>(__k, CMissionTeleportPD()));
CMissionTeleportPD* __o = &(_Teleports[__k]);
PDSLib.setRowIndex(rowIndex, __o);
__o->pds__fetch(data);
__o->pds__setParentUnnotified(this);
}
while (true);
do
{
// read table and row, create an object, affect to the ref, and fetch it
data.serial(tableIndex, rowIndex);
if (rowIndex == RY_PDS::INVALID_ROW_INDEX || tableIndex == RY_PDS::INVALID_TABLE_INDEX) break;
uint32 __k;
data.serial(__k);
_InsidePlaces.insert(std::make_pair<uint32,CMissionInsidePlacePD>(__k, CMissionInsidePlacePD()));
CMissionInsidePlacePD* __o = &(_InsidePlaces[__k]);
PDSLib.setRowIndex(rowIndex, __o);
__o->pds__fetch(data);
__o->pds__setParentUnnotified(this);
}
while (true);
do
{
// read table and row, create an object, affect to the ref, and fetch it
data.serial(tableIndex, rowIndex);
if (rowIndex == RY_PDS::INVALID_ROW_INDEX || tableIndex == RY_PDS::INVALID_TABLE_INDEX) break;
uint32 __k;
data.serial(__k);
_OutsidePlaces.insert(std::make_pair<uint32,CMissionOutsidePlacePD>(__k, CMissionOutsidePlacePD()));
CMissionOutsidePlacePD* __o = &(_OutsidePlaces[__k]);
PDSLib.setRowIndex(rowIndex, __o);
__o->pds__fetch(data);
__o->pds__setParentUnnotified(this);
}
while (true);
do
{
// read table and row, create an object, affect to the ref, and fetch it
data.serial(tableIndex, rowIndex);
if (rowIndex == RY_PDS::INVALID_ROW_INDEX || tableIndex == RY_PDS::INVALID_TABLE_INDEX) break;
uint32 __k;
data.serial(__k);
_HandledAIGroups.insert(std::make_pair<uint32,CHandledAIGroupPD>(__k, CHandledAIGroupPD()));
CHandledAIGroupPD* __o = &(_HandledAIGroups[__k]);
PDSLib.setRowIndex(rowIndex, __o);
__o->pds__fetch(data);
__o->pds__setParentUnnotified(this);
}
while (true);
_Container = NULL;
}
void CMissionPD::pds__register()
{
__BaseRow = _IndexAllocator.allocate();
PDSLib.allocateRow(__BaseTable, __BaseRow, 0);
pds__registerAttributes();
}
void CMissionPD::pds__registerAttributes()
{
if (RY_PDS::PDVerbose) nldebug("CMissionPD: registerAttributes %u:%u", __BaseTable, __BaseRow);
PDSLib.set(__BaseTable, __BaseRow, (RY_PDS::TColumnIndex)(0), _TemplateId);
}
void CMissionPD::pds__unregister()
{
pds__unregisterAttributes();
PDSLib.deallocateRow(__BaseTable, __BaseRow);
_IndexAllocator.deallocate(__BaseRow);
}
void CMissionPD::pds__unregisterAttributes()
{
if (RY_PDS::PDVerbose) nldebug("CMissionPD: unregisterAttributes %u:%u", __BaseTable, __BaseRow);
pds__setParent(NULL);
for (std::map<uint32, CActiveStepPD>::iterator __it=_Steps.begin(); __it!=_Steps.end(); )
{
std::map<uint32, CActiveStepPD>::iterator __itr=__it++;
CActiveStepPD& __o = (*__itr).second;
__o.pds__unregister();
}
for (std::map<uint32, CMissionCompassPD>::iterator __it=_Compass.begin(); __it!=_Compass.end(); )
{
std::map<uint32, CMissionCompassPD>::iterator __itr=__it++;
CMissionCompassPD& __o = (*__itr).second;
__o.pds__unregister();
}
for (std::map<uint32, CDoneStepPD>::iterator __it=_StepsDone.begin(); __it!=_StepsDone.end(); )
{
std::map<uint32, CDoneStepPD>::iterator __itr=__it++;
CDoneStepPD& __o = (*__itr).second;
__o.pds__unregister();
}
for (std::map<uint32, CMissionTeleportPD>::iterator __it=_Teleports.begin(); __it!=_Teleports.end(); )
{
std::map<uint32, CMissionTeleportPD>::iterator __itr=__it++;
CMissionTeleportPD& __o = (*__itr).second;
__o.pds__unregister();
}
for (std::map<uint32, CMissionInsidePlacePD>::iterator __it=_InsidePlaces.begin(); __it!=_InsidePlaces.end(); )
{
std::map<uint32, CMissionInsidePlacePD>::iterator __itr=__it++;
CMissionInsidePlacePD& __o = (*__itr).second;
__o.pds__unregister();
}
for (std::map<uint32, CMissionOutsidePlacePD>::iterator __it=_OutsidePlaces.begin(); __it!=_OutsidePlaces.end(); )
{
std::map<uint32, CMissionOutsidePlacePD>::iterator __itr=__it++;
CMissionOutsidePlacePD& __o = (*__itr).second;
__o.pds__unregister();
}
for (std::map<uint32, CHandledAIGroupPD>::iterator __it=_HandledAIGroups.begin(); __it!=_HandledAIGroups.end(); )
{
std::map<uint32, CHandledAIGroupPD>::iterator __itr=__it++;
CHandledAIGroupPD& __o = (*__itr).second;
__o.pds__unregister();
}
}
void CMissionPD::pds__setParent(CMissionContainerPD* __parent)
{
NLMISC::CEntityId prevId;
if (_Container != NULL)
{
prevId = _Container->getCharId();
_Container->pds__unlinkMissions(_TemplateId);
}
_Container = __parent;
PDSLib.setParent(__BaseTable, getRow(), (RY_PDS::TColumnIndex)(24), (__parent != NULL ? RY_PDS::CObjectIndex(18, __parent->getRow()) : RY_PDS::CObjectIndex::null()), (_Container != NULL ? _Container->getCharId() : NLMISC::CEntityId::Unknown), prevId);
}
void CMissionPD::pds__setParentUnnotified(CMissionContainerPD* __parent)
{
_Container = __parent;
}
void CMissionPD::pds__notifyInit()
{
init();
{
// CMissionPD init user code, defined at entities_game_service/pd_scripts/mission.pds:75
_Mission = this;
}
for (std::map<uint32, CActiveStepPD>::iterator __it=_Steps.begin(); __it!=_Steps.end(); )
{
std::map<uint32, CActiveStepPD>::iterator __itr=__it++;
(*__itr).second.pds__notifyInit();
}
for (std::map<uint32, CMissionCompassPD>::iterator __it=_Compass.begin(); __it!=_Compass.end(); )
{
std::map<uint32, CMissionCompassPD>::iterator __itr=__it++;
(*__itr).second.pds__notifyInit();
}
for (std::map<uint32, CDoneStepPD>::iterator __it=_StepsDone.begin(); __it!=_StepsDone.end(); )
{
std::map<uint32, CDoneStepPD>::iterator __itr=__it++;
(*__itr).second.pds__notifyInit();
}
for (std::map<uint32, CMissionTeleportPD>::iterator __it=_Teleports.begin(); __it!=_Teleports.end(); )
{
std::map<uint32, CMissionTeleportPD>::iterator __itr=__it++;
(*__itr).second.pds__notifyInit();
}
for (std::map<uint32, CMissionInsidePlacePD>::iterator __it=_InsidePlaces.begin(); __it!=_InsidePlaces.end(); )
{
std::map<uint32, CMissionInsidePlacePD>::iterator __itr=__it++;
(*__itr).second.pds__notifyInit();
}
for (std::map<uint32, CMissionOutsidePlacePD>::iterator __it=_OutsidePlaces.begin(); __it!=_OutsidePlaces.end(); )
{
std::map<uint32, CMissionOutsidePlacePD>::iterator __itr=__it++;
(*__itr).second.pds__notifyInit();
}
for (std::map<uint32, CHandledAIGroupPD>::iterator __it=_HandledAIGroups.begin(); __it!=_HandledAIGroups.end(); )
{
std::map<uint32, CHandledAIGroupPD>::iterator __itr=__it++;
(*__itr).second.pds__notifyInit();
}
}
void CMissionPD::pds__notifyRelease()
{
release();
PDSLib.release(__BaseTable, __BaseRow);
for (std::map<uint32, CActiveStepPD>::iterator __it=_Steps.begin(); __it!=_Steps.end(); )
{
std::map<uint32, CActiveStepPD>::iterator __itr=__it++;
(*__itr).second.pds__notifyRelease();
}
for (std::map<uint32, CMissionCompassPD>::iterator __it=_Compass.begin(); __it!=_Compass.end(); )
{
std::map<uint32, CMissionCompassPD>::iterator __itr=__it++;
(*__itr).second.pds__notifyRelease();
}
for (std::map<uint32, CDoneStepPD>::iterator __it=_StepsDone.begin(); __it!=_StepsDone.end(); )
{
std::map<uint32, CDoneStepPD>::iterator __itr=__it++;
(*__itr).second.pds__notifyRelease();
}
for (std::map<uint32, CMissionTeleportPD>::iterator __it=_Teleports.begin(); __it!=_Teleports.end(); )
{
std::map<uint32, CMissionTeleportPD>::iterator __itr=__it++;
(*__itr).second.pds__notifyRelease();
}
for (std::map<uint32, CMissionInsidePlacePD>::iterator __it=_InsidePlaces.begin(); __it!=_InsidePlaces.end(); )
{
std::map<uint32, CMissionInsidePlacePD>::iterator __itr=__it++;
(*__itr).second.pds__notifyRelease();
}
for (std::map<uint32, CMissionOutsidePlacePD>::iterator __it=_OutsidePlaces.begin(); __it!=_OutsidePlaces.end(); )
{
std::map<uint32, CMissionOutsidePlacePD>::iterator __itr=__it++;
(*__itr).second.pds__notifyRelease();
}
for (std::map<uint32, CHandledAIGroupPD>::iterator __it=_HandledAIGroups.begin(); __it!=_HandledAIGroups.end(); )
{
std::map<uint32, CHandledAIGroupPD>::iterator __itr=__it++;
(*__itr).second.pds__notifyRelease();
}
}
void CMissionPD::pds_static__init()
{
PDSLib.setIndexAllocator(14, _IndexAllocator);
nlassertex(_FactoryInitialised, ("User Factory for class CMissionPD not set!"));
// factory must have been set by user before database init called!
// You must provide a factory for the class CMissionPD as it is marked as derived
// Call EGSPD::CMissionPD::setFactory() with a factory before any call to EGSPD::init()!
}
void CMissionPD::pds_static__setFactory(RY_PDS::TPDFactory userFactory)
{
if (!_FactoryInitialised)
{
PDSLib.registerClass(14, userFactory, pds_static__fetch, NULL);
_FactoryInitialised = true;
}
}
bool CMissionPD::_FactoryInitialised;
RY_PDS::CIndexAllocator CMissionPD::_IndexAllocator;
void CMissionPD::pds_static__fetch(RY_PDS::IPDBaseData *object, RY_PDS::CPData &data)
{
CMissionPD *__o = static_cast<CMissionPD*>(object);
__o->pds__fetch(data);
__o->pds__notifyInit();
}
// End of static implementation of CMissionPD
/* -----------------------------------------
* Static Implementation of CMissionGuildPD
* ----------------------------------------- */
void CMissionGuildPD::clear()
{
CMissionPD::clear();
}
CMissionGuildPD* CMissionGuildPD::cast(RY_PDS::IPDBaseData* obj)
{
return (obj->getTable() == 15) ? static_cast<CMissionGuildPD*>(obj) : NULL;
}
const CMissionGuildPD* CMissionGuildPD::cast(const RY_PDS::IPDBaseData* obj)
{
return (obj->getTable() == 15) ? static_cast<const CMissionGuildPD*>(obj) : NULL;
}
void CMissionGuildPD::setFactory(RY_PDS::TPDFactory userFactory)
{
pds_static__setFactory(userFactory);
}
CMissionGuildPD* CMissionGuildPD::create(const uint32 &TemplateId)
{
CMissionGuildPD *__o = static_cast<CMissionGuildPD*>(PDSLib.create(15));
__o->pds__init(TemplateId);
__o->pds__register();
__o->pds__notifyInit();
return __o;
}
void CMissionGuildPD::apply(CPersistentDataRecord &__pdr)
{
uint16 __Tok_MapKey = __pdr.addString("__Key__");
uint16 __Tok_MapVal = __pdr.addString("__Val__");
uint16 __Tok_ClassName = __pdr.addString("__Class__");
uint16 __Tok_Parent = __pdr.addString("__Parent__");
while (!__pdr.isEndOfStruct())
{
if (false) {}
else if (__pdr.peekNextToken() == __Tok_Parent)
{
__pdr.popStructBegin(__Tok_Parent);
CMissionPD::apply(__pdr);
__pdr.popStructEnd(__Tok_Parent);
}
else
{
nlwarning("Skipping unrecognised token: %s", __pdr.peekNextTokenName().c_str());
__pdr.skipData();
}
}
}
void CMissionGuildPD::store(CPersistentDataRecord &__pdr) const
{
uint16 __Tok_MapKey = __pdr.addString("__Key__");
uint16 __Tok_MapVal = __pdr.addString("__Val__");
uint16 __Tok_ClassName = __pdr.addString("__Class__");
uint16 __Tok_Parent = __pdr.addString("__Parent__");
__pdr.pushStructBegin(__Tok_Parent);
CMissionPD::store(__pdr);
__pdr.pushStructEnd(__Tok_Parent);
}
void CMissionGuildPD::init()
{
}
void CMissionGuildPD::release()
{
}
void CMissionGuildPD::pds__init(const uint32 &TemplateId)
{
CMissionPD::pds__init(TemplateId);
}
void CMissionGuildPD::pds__destroy()
{
CMissionPD::pds__destroy();
}
void CMissionGuildPD::pds__fetch(RY_PDS::CPData &data)
{
CMissionPD::pds__fetch(data);
}
void CMissionGuildPD::pds__register()
{
__BaseRow = _IndexAllocator.allocate();
PDSLib.allocateRow(__BaseTable, __BaseRow, 0);
pds__registerAttributes();
}
void CMissionGuildPD::pds__registerAttributes()
{
if (RY_PDS::PDVerbose) nldebug("CMissionGuildPD: registerAttributes %u:%u", __BaseTable, __BaseRow);
CMissionPD::pds__registerAttributes();
}
void CMissionGuildPD::pds__unregister()
{
pds__unregisterAttributes();
PDSLib.deallocateRow(__BaseTable, __BaseRow);
_IndexAllocator.deallocate(__BaseRow);
}
void CMissionGuildPD::pds__unregisterAttributes()
{
if (RY_PDS::PDVerbose) nldebug("CMissionGuildPD: unregisterAttributes %u:%u", __BaseTable, __BaseRow);
CMissionPD::pds__unregisterAttributes();
}
void CMissionGuildPD::pds__notifyInit()
{
CMissionPD::pds__notifyInit();
init();
}
void CMissionGuildPD::pds__notifyRelease()
{
release();
CMissionPD::pds__notifyRelease();
}
void CMissionGuildPD::pds_static__init()
{
PDSLib.setIndexAllocator(15, _IndexAllocator);
nlassertex(_FactoryInitialised, ("User Factory for class CMissionGuildPD not set!"));
// factory must have been set by user before database init called!
// You must provide a factory for the class CMissionGuildPD as it is marked as derived
// Call EGSPD::CMissionGuildPD::setFactory() with a factory before any call to EGSPD::init()!
}
void CMissionGuildPD::pds_static__setFactory(RY_PDS::TPDFactory userFactory)
{
if (!_FactoryInitialised)
{
PDSLib.registerClass(15, userFactory, pds_static__fetch, NULL);
_FactoryInitialised = true;
}
}
bool CMissionGuildPD::_FactoryInitialised;
RY_PDS::CIndexAllocator CMissionGuildPD::_IndexAllocator;
// End of static implementation of CMissionGuildPD
/* -----------------------------------------
* Static Implementation of CMissionTeamPD
* ----------------------------------------- */
void CMissionTeamPD::clear()
{
CMissionPD::clear();
}
CMissionTeamPD* CMissionTeamPD::cast(RY_PDS::IPDBaseData* obj)
{
return (obj->getTable() == 16) ? static_cast<CMissionTeamPD*>(obj) : NULL;
}
const CMissionTeamPD* CMissionTeamPD::cast(const RY_PDS::IPDBaseData* obj)
{
return (obj->getTable() == 16) ? static_cast<const CMissionTeamPD*>(obj) : NULL;
}
void CMissionTeamPD::setFactory(RY_PDS::TPDFactory userFactory)
{
pds_static__setFactory(userFactory);
}
CMissionTeamPD* CMissionTeamPD::create(const uint32 &TemplateId)
{
CMissionTeamPD *__o = static_cast<CMissionTeamPD*>(PDSLib.create(16));
__o->pds__init(TemplateId);
__o->pds__register();
__o->pds__notifyInit();
return __o;
}
void CMissionTeamPD::apply(CPersistentDataRecord &__pdr)
{
uint16 __Tok_MapKey = __pdr.addString("__Key__");
uint16 __Tok_MapVal = __pdr.addString("__Val__");
uint16 __Tok_ClassName = __pdr.addString("__Class__");
uint16 __Tok_Parent = __pdr.addString("__Parent__");
while (!__pdr.isEndOfStruct())
{
if (false) {}
else if (__pdr.peekNextToken() == __Tok_Parent)
{
__pdr.popStructBegin(__Tok_Parent);
CMissionPD::apply(__pdr);
__pdr.popStructEnd(__Tok_Parent);
}
else
{
nlwarning("Skipping unrecognised token: %s", __pdr.peekNextTokenName().c_str());
__pdr.skipData();
}
}
}
void CMissionTeamPD::store(CPersistentDataRecord &__pdr) const
{
uint16 __Tok_MapKey = __pdr.addString("__Key__");
uint16 __Tok_MapVal = __pdr.addString("__Val__");
uint16 __Tok_ClassName = __pdr.addString("__Class__");
uint16 __Tok_Parent = __pdr.addString("__Parent__");
__pdr.pushStructBegin(__Tok_Parent);
CMissionPD::store(__pdr);
__pdr.pushStructEnd(__Tok_Parent);
}
void CMissionTeamPD::init()
{
}
void CMissionTeamPD::release()
{
}
void CMissionTeamPD::pds__init(const uint32 &TemplateId)
{
CMissionPD::pds__init(TemplateId);
}
void CMissionTeamPD::pds__destroy()
{
CMissionPD::pds__destroy();
}
void CMissionTeamPD::pds__fetch(RY_PDS::CPData &data)
{
CMissionPD::pds__fetch(data);
}
void CMissionTeamPD::pds__register()
{
__BaseRow = _IndexAllocator.allocate();
PDSLib.allocateRow(__BaseTable, __BaseRow, 0);
pds__registerAttributes();
}
void CMissionTeamPD::pds__registerAttributes()
{
if (RY_PDS::PDVerbose) nldebug("CMissionTeamPD: registerAttributes %u:%u", __BaseTable, __BaseRow);
CMissionPD::pds__registerAttributes();
}
void CMissionTeamPD::pds__unregister()
{
pds__unregisterAttributes();
PDSLib.deallocateRow(__BaseTable, __BaseRow);
_IndexAllocator.deallocate(__BaseRow);
}
void CMissionTeamPD::pds__unregisterAttributes()
{
if (RY_PDS::PDVerbose) nldebug("CMissionTeamPD: unregisterAttributes %u:%u", __BaseTable, __BaseRow);
CMissionPD::pds__unregisterAttributes();
}
void CMissionTeamPD::pds__notifyInit()
{
CMissionPD::pds__notifyInit();
init();
}
void CMissionTeamPD::pds__notifyRelease()
{
release();
CMissionPD::pds__notifyRelease();
}
void CMissionTeamPD::pds_static__init()
{
PDSLib.setIndexAllocator(16, _IndexAllocator);
nlassertex(_FactoryInitialised, ("User Factory for class CMissionTeamPD not set!"));
// factory must have been set by user before database init called!
// You must provide a factory for the class CMissionTeamPD as it is marked as derived
// Call EGSPD::CMissionTeamPD::setFactory() with a factory before any call to EGSPD::init()!
}
void CMissionTeamPD::pds_static__setFactory(RY_PDS::TPDFactory userFactory)
{
if (!_FactoryInitialised)
{
PDSLib.registerClass(16, userFactory, pds_static__fetch, NULL);
_FactoryInitialised = true;
}
}
bool CMissionTeamPD::_FactoryInitialised;
RY_PDS::CIndexAllocator CMissionTeamPD::_IndexAllocator;
// End of static implementation of CMissionTeamPD
/* -----------------------------------------
* Static Implementation of CMissionSoloPD
* ----------------------------------------- */
void CMissionSoloPD::clear()
{
CMissionPD::clear();
}
CMissionSoloPD* CMissionSoloPD::cast(RY_PDS::IPDBaseData* obj)
{
return (obj->getTable() == 17) ? static_cast<CMissionSoloPD*>(obj) : NULL;
}
const CMissionSoloPD* CMissionSoloPD::cast(const RY_PDS::IPDBaseData* obj)
{
return (obj->getTable() == 17) ? static_cast<const CMissionSoloPD*>(obj) : NULL;
}
void CMissionSoloPD::setFactory(RY_PDS::TPDFactory userFactory)
{
pds_static__setFactory(userFactory);
}
CMissionSoloPD* CMissionSoloPD::create(const uint32 &TemplateId)
{
CMissionSoloPD *__o = static_cast<CMissionSoloPD*>(PDSLib.create(17));
__o->pds__init(TemplateId);
__o->pds__register();
__o->pds__notifyInit();
return __o;
}
void CMissionSoloPD::apply(CPersistentDataRecord &__pdr)
{
uint16 __Tok_MapKey = __pdr.addString("__Key__");
uint16 __Tok_MapVal = __pdr.addString("__Val__");
uint16 __Tok_ClassName = __pdr.addString("__Class__");
uint16 __Tok_Parent = __pdr.addString("__Parent__");
while (!__pdr.isEndOfStruct())
{
if (false) {}
else if (__pdr.peekNextToken() == __Tok_Parent)
{
__pdr.popStructBegin(__Tok_Parent);
CMissionPD::apply(__pdr);
__pdr.popStructEnd(__Tok_Parent);
}
else
{
nlwarning("Skipping unrecognised token: %s", __pdr.peekNextTokenName().c_str());
__pdr.skipData();
}
}
}
void CMissionSoloPD::store(CPersistentDataRecord &__pdr) const
{
uint16 __Tok_MapKey = __pdr.addString("__Key__");
uint16 __Tok_MapVal = __pdr.addString("__Val__");
uint16 __Tok_ClassName = __pdr.addString("__Class__");
uint16 __Tok_Parent = __pdr.addString("__Parent__");
__pdr.pushStructBegin(__Tok_Parent);
CMissionPD::store(__pdr);
__pdr.pushStructEnd(__Tok_Parent);
}
void CMissionSoloPD::init()
{
}
void CMissionSoloPD::release()
{
}
void CMissionSoloPD::pds__init(const uint32 &TemplateId)
{
CMissionPD::pds__init(TemplateId);
}
void CMissionSoloPD::pds__destroy()
{
CMissionPD::pds__destroy();
}
void CMissionSoloPD::pds__fetch(RY_PDS::CPData &data)
{
CMissionPD::pds__fetch(data);
}
void CMissionSoloPD::pds__register()
{
__BaseRow = _IndexAllocator.allocate();
PDSLib.allocateRow(__BaseTable, __BaseRow, 0);
pds__registerAttributes();
}
void CMissionSoloPD::pds__registerAttributes()
{
if (RY_PDS::PDVerbose) nldebug("CMissionSoloPD: registerAttributes %u:%u", __BaseTable, __BaseRow);
CMissionPD::pds__registerAttributes();
}
void CMissionSoloPD::pds__unregister()
{
pds__unregisterAttributes();
PDSLib.deallocateRow(__BaseTable, __BaseRow);
_IndexAllocator.deallocate(__BaseRow);
}
void CMissionSoloPD::pds__unregisterAttributes()
{
if (RY_PDS::PDVerbose) nldebug("CMissionSoloPD: unregisterAttributes %u:%u", __BaseTable, __BaseRow);
CMissionPD::pds__unregisterAttributes();
}
void CMissionSoloPD::pds__notifyInit()
{
CMissionPD::pds__notifyInit();
init();
}
void CMissionSoloPD::pds__notifyRelease()
{
release();
CMissionPD::pds__notifyRelease();
}
void CMissionSoloPD::pds_static__init()
{
PDSLib.setIndexAllocator(17, _IndexAllocator);
nlassertex(_FactoryInitialised, ("User Factory for class CMissionSoloPD not set!"));
// factory must have been set by user before database init called!
// You must provide a factory for the class CMissionSoloPD as it is marked as derived
// Call EGSPD::CMissionSoloPD::setFactory() with a factory before any call to EGSPD::init()!
}
void CMissionSoloPD::pds_static__setFactory(RY_PDS::TPDFactory userFactory)
{
if (!_FactoryInitialised)
{
PDSLib.registerClass(17, userFactory, pds_static__fetch, NULL);
_FactoryInitialised = true;
}
}
bool CMissionSoloPD::_FactoryInitialised;
RY_PDS::CIndexAllocator CMissionSoloPD::_IndexAllocator;
// End of static implementation of CMissionSoloPD
/* -----------------------------------------
* Static Implementation of CMissionContainerPD
* ----------------------------------------- */
NLMISC::CEntityId CMissionContainerPD::getCharId() const
{
return _CharId;
}
CMissionPD* CMissionContainerPD::getMissions(const uint32& __k)
{
std::map<uint32, CMissionPD*>::iterator _it = _Missions.find(__k);
return (_it==_Missions.end() ? NULL : (*_it).second);
}
const CMissionPD* CMissionContainerPD::getMissions(const uint32& __k) const
{
std::map<uint32, CMissionPD*>::const_iterator _it = _Missions.find(__k);
return (_it==_Missions.end() ? NULL : (*_it).second);
}
std::map<uint32, CMissionPD*>::iterator CMissionContainerPD::getMissionsBegin()
{
return _Missions.begin();
}
std::map<uint32, CMissionPD*>::iterator CMissionContainerPD::getMissionsEnd()
{
return _Missions.end();
}
std::map<uint32, CMissionPD*>::const_iterator CMissionContainerPD::getMissionsBegin() const
{
return _Missions.begin();
}
std::map<uint32, CMissionPD*>::const_iterator CMissionContainerPD::getMissionsEnd() const
{
return _Missions.end();
}
const std::map<uint32, CMissionPD*> & CMissionContainerPD::getMissions() const
{
return _Missions;
}
void CMissionContainerPD::setMissions(CMissionPD* __v)
{
if (__v == NULL) return;
uint32 __k = __v->getTemplateId();
std::map<uint32, CMissionPD*>::iterator _it = _Missions.find(__k);
if (_it != _Missions.end())
{
CMissionPD* __prev = (*_it).second;
if (__prev == __v) return;
__prev->pds__setParent(NULL);
__prev->pds__unregister();
__prev->pds__destroy();
delete __prev;
}
__v->pds__setParent(this);
_Missions[__k] = __v;
}
void CMissionContainerPD::deleteFromMissions(const uint32 &__k)
{
std::map<uint32, CMissionPD*>::iterator __it = _Missions.find(__k);
if (__it == _Missions.end()) return;
CMissionPD* __o = (*__it).second;
__o->pds__unregister();
__o->pds__destroy();
delete __o;
}
void CMissionContainerPD::clear()
{
for (std::map<uint32, CMissionPD*>::iterator __it=_Missions.begin(); __it!=_Missions.end(); )
{
std::map<uint32, CMissionPD*>::iterator __itr=__it++;
CMissionPD* __o = (*__itr).second;
__o->pds__unregister();
__o->pds__destroy();
delete __o;
}
_Missions.clear();
}
CMissionContainerPD* CMissionContainerPD::cast(RY_PDS::IPDBaseData* obj)
{
return (obj->getTable() == 18) ? static_cast<CMissionContainerPD*>(obj) : NULL;
}
const CMissionContainerPD* CMissionContainerPD::cast(const RY_PDS::IPDBaseData* obj)
{
return (obj->getTable() == 18) ? static_cast<const CMissionContainerPD*>(obj) : NULL;
}
CMissionContainerPD* CMissionContainerPD::create(const NLMISC::CEntityId &CharId)
{
CMissionContainerPD *__o = static_cast<CMissionContainerPD*>(pds_static__factory());
__o->pds__init(CharId);
__o->pds__register();
__o->pds__notifyInit();
return __o;
}
void CMissionContainerPD::remove(const NLMISC::CEntityId& CharId)
{
std::map<NLMISC::CEntityId,CMissionContainerPD*>::iterator it = _Map.find(CharId);
if (it != _Map.end())
{
CMissionContainerPD* __o = (*it).second;
__o->pds__notifyRelease();
__o->pds__unregister();
__o->pds__destroy();
delete __o;
}
}
void CMissionContainerPD::load(const NLMISC::CEntityId& CharId)
{
PDSLib.load(18, CharId.asUint64());
}
void CMissionContainerPD::setLoadCallback(void (*callback)(const NLMISC::CEntityId& key, CMissionContainerPD* object))
{
__pds__LoadCallback = callback;
}
void CMissionContainerPD::unload(const NLMISC::CEntityId &CharId)
{
std::map<NLMISC::CEntityId,CMissionContainerPD*>::iterator it = _Map.find(CharId);
if (it != _Map.end())
{
CMissionContainerPD* __o = (*it).second;
__o->pds__notifyRelease();
__o->pds__destroy();
delete __o;
}
}
CMissionContainerPD* CMissionContainerPD::get(const NLMISC::CEntityId &CharId)
{
std::map<NLMISC::CEntityId, CMissionContainerPD*>::iterator __it = _Map.find(CharId);
return (__it != _Map.end()) ? (*__it).second : NULL;
}
std::map<NLMISC::CEntityId, CMissionContainerPD*>::iterator CMissionContainerPD::begin()
{
return _Map.begin();
}
std::map<NLMISC::CEntityId, CMissionContainerPD*>::iterator CMissionContainerPD::end()
{
return _Map.end();
}
void CMissionContainerPD::apply(CPersistentDataRecord &__pdr)
{
uint16 __Tok_MapKey = __pdr.addString("__Key__");
uint16 __Tok_MapVal = __pdr.addString("__Val__");
uint16 __Tok_ClassName = __pdr.addString("__Class__");
uint16 __TokCharId = __pdr.addString("CharId");
uint16 __TokMissions = __pdr.addString("Missions");
while (!__pdr.isEndOfStruct())
{
if (false) {}
else if (__pdr.peekNextToken() == __TokCharId)
{
__pdr.pop(__TokCharId, _CharId);
}
// apply Missions
else if (__pdr.peekNextToken() == __TokMissions)
{
__pdr.popStructBegin(__TokMissions);
while (!__pdr.isEndOfStruct())
{
uint32 key;
__pdr.pop(__Tok_MapKey, key);
__pdr.popStructBegin(__Tok_MapVal);
CMissionPD* obj;
obj = NULL;
if (__pdr.peekNextToken() == __Tok_ClassName)
{
std::string __className;
__pdr.pop(__Tok_ClassName, __className);
obj = CMissionPD::cast(PDSLib.create(__className));
if (obj != NULL)
{
__pdr.popStructBegin(__TokMissions);
obj->apply(__pdr);
obj->pds__setParentUnnotified(this);
__pdr.popStructEnd(__TokMissions);
}
else
{
__pdr.skipStruct();
}
}
if (obj != NULL)
{
_Missions[key] = obj;
}
__pdr.popStructEnd(__Tok_MapVal);
}
__pdr.popStructEnd(__TokMissions);
}
// end of apply Missions
else
{
nlwarning("Skipping unrecognised token: %s", __pdr.peekNextTokenName().c_str());
__pdr.skipData();
}
}
pds__notifyInit();
}
void CMissionContainerPD::store(CPersistentDataRecord &__pdr) const
{
uint16 __Tok_MapKey = __pdr.addString("__Key__");
uint16 __Tok_MapVal = __pdr.addString("__Val__");
uint16 __Tok_ClassName = __pdr.addString("__Class__");
uint16 __TokCharId = __pdr.addString("CharId");
uint16 __TokMissions = __pdr.addString("Missions");
__pdr.push(__TokCharId, _CharId);
// store Missions
__pdr.pushStructBegin(__TokMissions);
for (std::map<uint32, CMissionPD*>::const_iterator it=_Missions.begin(); it!=_Missions.end(); ++it)
{
uint32 key = (*it).first;
__pdr.push(__Tok_MapKey, key);
__pdr.pushStructBegin(__Tok_MapVal);
if ((*it).second != NULL)
{
std::string __className = PDSLib.getClassName((*it).second);
__pdr.push(__Tok_ClassName, __className);
__pdr.pushStructBegin(__TokMissions);
(*it).second->store(__pdr);
__pdr.pushStructEnd(__TokMissions);
}
__pdr.pushStructEnd(__Tok_MapVal);
}
__pdr.pushStructEnd(__TokMissions);
// end of store Missions
}
void CMissionContainerPD::pds__init(const NLMISC::CEntityId &CharId)
{
_CharId = CharId;
_Map[getCharId()] = this;
}
void CMissionContainerPD::pds__destroy()
{
for (std::map<uint32, CMissionPD*>::iterator __it=_Missions.begin(); __it!=_Missions.end(); )
{
std::map<uint32, CMissionPD*>::iterator __itr=__it++;
CMissionPD* __o = ((*__itr).second);
if (__o != NULL)
{
__o->pds__destroy();
delete __o;
}
}
_Missions.clear();
_Map.erase(getCharId());
}
void CMissionContainerPD::pds__fetch(RY_PDS::CPData &data)
{
data.serial(_CharId);
RY_PDS::TTableIndex tableIndex;
RY_PDS::TRowIndex rowIndex;
do
{
// read table and row, create an object, affect to the ref, and fetch it
data.serial(tableIndex, rowIndex);
if (rowIndex == RY_PDS::INVALID_ROW_INDEX || tableIndex == RY_PDS::INVALID_TABLE_INDEX) break;
uint32 __k;
data.serial(__k);
CMissionPD* __o = static_cast<CMissionPD*>(PDSLib.create(tableIndex));
_Missions.insert(std::make_pair<uint32,CMissionPD*>(__k, __o));
PDSLib.setRowIndex(rowIndex, __o);
__o->pds__fetch(data);
__o->pds__setParentUnnotified(this);
}
while (true);
_Map[getCharId()] = this;
}
void CMissionContainerPD::pds__register()
{
__BaseRow = _IndexAllocator.allocate();
PDSLib.allocateRow(18, __BaseRow, _CharId.asUint64(), _CharId);
pds__registerAttributes();
}
void CMissionContainerPD::pds__registerAttributes()
{
if (RY_PDS::PDVerbose) nldebug("CMissionContainerPD: registerAttributes %u:%u", 18, __BaseRow);
PDSLib.set(18, __BaseRow, (RY_PDS::TColumnIndex)(0), _CharId);
}
void CMissionContainerPD::pds__unregister()
{
pds__unregisterAttributes();
PDSLib.deallocateRow(18, __BaseRow, _CharId);
_IndexAllocator.deallocate(__BaseRow);
}
void CMissionContainerPD::pds__unregisterAttributes()
{
if (RY_PDS::PDVerbose) nldebug("CMissionContainerPD: unregisterAttributes %u:%u", 18, __BaseRow);
for (std::map<uint32, CMissionPD*>::iterator __it=_Missions.begin(); __it!=_Missions.end(); )
{
std::map<uint32, CMissionPD*>::iterator __itr=__it++;
CMissionPD* __o = (*__itr).second;
__o->pds__unregister();
__o->pds__destroy();
delete __o;
}
}
void CMissionContainerPD::pds__notifyInit()
{
for (std::map<uint32, CMissionPD*>::iterator __it=_Missions.begin(); __it!=_Missions.end(); )
{
std::map<uint32, CMissionPD*>::iterator __itr=__it++;
(*__itr).second->pds__notifyInit();
}
}
void CMissionContainerPD::pds__notifyRelease()
{
PDSLib.release(18, __BaseRow);
for (std::map<uint32, CMissionPD*>::iterator __it=_Missions.begin(); __it!=_Missions.end(); )
{
std::map<uint32, CMissionPD*>::iterator __itr=__it++;
(*__itr).second->pds__notifyRelease();
}
}
void CMissionContainerPD::pds__unlinkMissions(uint32 __k)
{
_Missions.erase(__k);
}
void CMissionContainerPD::pds_static__init()
{
PDSLib.setIndexAllocator(18, _IndexAllocator);
pds_static__setFactory(pds_static__factory);
}
std::map<NLMISC::CEntityId,CMissionContainerPD*> CMissionContainerPD::_Map;
void CMissionContainerPD::pds_static__setFactory(RY_PDS::TPDFactory userFactory)
{
if (!_FactoryInitialised)
{
PDSLib.registerClass(18, userFactory, pds_static__fetch, pds_static__notifyFailure);
_FactoryInitialised = true;
}
}
bool CMissionContainerPD::_FactoryInitialised;
void CMissionContainerPD::pds_static__notifyFailure(uint64 key)
{
if (__pds__LoadCallback != NULL)
{
__pds__LoadCallback((NLMISC::CEntityId)key, NULL);
}
}
void (*CMissionContainerPD::__pds__LoadCallback)(const NLMISC::CEntityId& key, CMissionContainerPD* object) = NULL;
RY_PDS::CIndexAllocator CMissionContainerPD::_IndexAllocator;
RY_PDS::IPDBaseData* CMissionContainerPD::pds_static__factory()
{
return new CMissionContainerPD();
}
void CMissionContainerPD::pds_static__fetch(RY_PDS::IPDBaseData *object, RY_PDS::CPData &data)
{
CMissionContainerPD *__o = static_cast<CMissionContainerPD*>(object);
__o->pds__fetch(data);
if (__pds__LoadCallback != NULL)
{
__pds__LoadCallback(__o->getCharId(), __o);
}
__o->pds__notifyInit();
}
// End of static implementation of CMissionContainerPD
} // End of EGSPD
Reference in a new issue View git blame Copy permalink