2019-08-19 18:39:33 +00:00
|
|
|
#include <components/openmw-mp/TimedLog.hpp>
|
2018-04-12 11:18:19 +00:00
|
|
|
|
2019-09-28 10:12:48 +00:00
|
|
|
#include "../mwworld/cellstore.hpp"
|
2018-04-12 11:18:19 +00:00
|
|
|
#include "../mwworld/worldimp.hpp"
|
|
|
|
|
|
|
|
|
|
#include "RecordHelper.hpp"
|
2020-08-11 10:33:03 +00:00
|
|
|
#include "Main.hpp"
|
|
|
|
|
#include "CellController.hpp"
|
|
|
|
|
#include "Cell.hpp"
|
2018-04-12 11:18:19 +00:00
|
|
|
|
2019-10-17 03:58:56 +00:00
|
|
|
void RecordHelper::overrideRecord(const mwmp::ActivatorRecord& record)
|
[General] Implement RecordDynamic packet, part 1
Spell, potion, enchantment, creature, NPC, armor, book, clothing, miscellaneous and weapon record data can now be sent in a RecordDynamic packet. Additionally, the packets include data related to associated magical effects (for spells, potions and enchantments), data related to default inventory contents (for creatures and NPCs) and data related to body parts affected (for armor and clothing).
The server now has associated script functions for setting most of the details of the above, with the main exception being individual creature and NPC stats.
Records can either be created entirely from scratch or can use an existing record (set via the baseId variable) as a starting point for their values. In the latter case, only the values that are specifically set override the starting values. Creature and NPC records also have an inventoryBaseId that can be used on top of the baseId to base their inventories on another existing record.
The client's RecordHelper class has been heavily expanded to allow for the above mentioned functionality.
When players create spells, potions and enchantments as part of regular gameplay, they send RecordDynamic packets that provide the server with the complete details of the records that should be created. When they create enchantments, they also provide the server with armor, book, clothing and weapon records corresponding to the items they've enchanted.
This functionality added by this packet was originally supposed to be exclusive to the rewrite, but I've gone ahead and tried to provide it for the pre-rewrite in a way that can mostly be reused for the rewrite.
2018-07-30 07:56:26 +00:00
|
|
|
{
|
2019-10-17 03:58:56 +00:00
|
|
|
const ESM::Activator &recordData = record.data;
|
[General] Implement RecordDynamic packet, part 1
Spell, potion, enchantment, creature, NPC, armor, book, clothing, miscellaneous and weapon record data can now be sent in a RecordDynamic packet. Additionally, the packets include data related to associated magical effects (for spells, potions and enchantments), data related to default inventory contents (for creatures and NPCs) and data related to body parts affected (for armor and clothing).
The server now has associated script functions for setting most of the details of the above, with the main exception being individual creature and NPC stats.
Records can either be created entirely from scratch or can use an existing record (set via the baseId variable) as a starting point for their values. In the latter case, only the values that are specifically set override the starting values. Creature and NPC records also have an inventoryBaseId that can be used on top of the baseId to base their inventories on another existing record.
The client's RecordHelper class has been heavily expanded to allow for the above mentioned functionality.
When players create spells, potions and enchantments as part of regular gameplay, they send RecordDynamic packets that provide the server with the complete details of the records that should be created. When they create enchantments, they also provide the server with armor, book, clothing and weapon records corresponding to the items they've enchanted.
This functionality added by this packet was originally supposed to be exclusive to the rewrite, but I've gone ahead and tried to provide it for the pre-rewrite in a way that can mostly be reused for the rewrite.
2018-07-30 07:56:26 +00:00
|
|
|
|
|
|
|
|
if (recordData.mId.empty())
|
|
|
|
|
{
|
2019-08-19 18:39:33 +00:00
|
|
|
LOG_APPEND(TimedLog::LOG_INFO, "-- Ignoring record override with no id provided");
|
[General] Implement RecordDynamic packet, part 1
Spell, potion, enchantment, creature, NPC, armor, book, clothing, miscellaneous and weapon record data can now be sent in a RecordDynamic packet. Additionally, the packets include data related to associated magical effects (for spells, potions and enchantments), data related to default inventory contents (for creatures and NPCs) and data related to body parts affected (for armor and clothing).
The server now has associated script functions for setting most of the details of the above, with the main exception being individual creature and NPC stats.
Records can either be created entirely from scratch or can use an existing record (set via the baseId variable) as a starting point for their values. In the latter case, only the values that are specifically set override the starting values. Creature and NPC records also have an inventoryBaseId that can be used on top of the baseId to base their inventories on another existing record.
The client's RecordHelper class has been heavily expanded to allow for the above mentioned functionality.
When players create spells, potions and enchantments as part of regular gameplay, they send RecordDynamic packets that provide the server with the complete details of the records that should be created. When they create enchantments, they also provide the server with armor, book, clothing and weapon records corresponding to the items they've enchanted.
This functionality added by this packet was originally supposed to be exclusive to the rewrite, but I've gone ahead and tried to provide it for the pre-rewrite in a way that can mostly be reused for the rewrite.
2018-07-30 07:56:26 +00:00
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
2019-10-17 03:58:56 +00:00
|
|
|
bool isExistingId = doesRecordIdExist<ESM::Activator>(recordData.mId);
|
[General] Implement RecordDynamic packet, part 1
Spell, potion, enchantment, creature, NPC, armor, book, clothing, miscellaneous and weapon record data can now be sent in a RecordDynamic packet. Additionally, the packets include data related to associated magical effects (for spells, potions and enchantments), data related to default inventory contents (for creatures and NPCs) and data related to body parts affected (for armor and clothing).
The server now has associated script functions for setting most of the details of the above, with the main exception being individual creature and NPC stats.
Records can either be created entirely from scratch or can use an existing record (set via the baseId variable) as a starting point for their values. In the latter case, only the values that are specifically set override the starting values. Creature and NPC records also have an inventoryBaseId that can be used on top of the baseId to base their inventories on another existing record.
The client's RecordHelper class has been heavily expanded to allow for the above mentioned functionality.
When players create spells, potions and enchantments as part of regular gameplay, they send RecordDynamic packets that provide the server with the complete details of the records that should be created. When they create enchantments, they also provide the server with armor, book, clothing and weapon records corresponding to the items they've enchanted.
This functionality added by this packet was originally supposed to be exclusive to the rewrite, but I've gone ahead and tried to provide it for the pre-rewrite in a way that can mostly be reused for the rewrite.
2018-07-30 07:56:26 +00:00
|
|
|
MWBase::World *world = MWBase::Environment::get().getWorld();
|
|
|
|
|
|
|
|
|
|
if (record.baseId.empty())
|
|
|
|
|
{
|
|
|
|
|
world->getModifiableStore().overrideRecord(recordData);
|
|
|
|
|
}
|
2019-10-17 03:58:56 +00:00
|
|
|
else if (doesRecordIdExist<ESM::Activator>(record.baseId))
|
[General] Implement RecordDynamic packet, part 1
Spell, potion, enchantment, creature, NPC, armor, book, clothing, miscellaneous and weapon record data can now be sent in a RecordDynamic packet. Additionally, the packets include data related to associated magical effects (for spells, potions and enchantments), data related to default inventory contents (for creatures and NPCs) and data related to body parts affected (for armor and clothing).
The server now has associated script functions for setting most of the details of the above, with the main exception being individual creature and NPC stats.
Records can either be created entirely from scratch or can use an existing record (set via the baseId variable) as a starting point for their values. In the latter case, only the values that are specifically set override the starting values. Creature and NPC records also have an inventoryBaseId that can be used on top of the baseId to base their inventories on another existing record.
The client's RecordHelper class has been heavily expanded to allow for the above mentioned functionality.
When players create spells, potions and enchantments as part of regular gameplay, they send RecordDynamic packets that provide the server with the complete details of the records that should be created. When they create enchantments, they also provide the server with armor, book, clothing and weapon records corresponding to the items they've enchanted.
This functionality added by this packet was originally supposed to be exclusive to the rewrite, but I've gone ahead and tried to provide it for the pre-rewrite in a way that can mostly be reused for the rewrite.
2018-07-30 07:56:26 +00:00
|
|
|
{
|
2019-10-17 03:58:56 +00:00
|
|
|
const ESM::Activator *baseData = world->getStore().get<ESM::Activator>().search(record.baseId);
|
|
|
|
|
ESM::Activator finalData = *baseData;
|
[General] Implement RecordDynamic packet, part 1
Spell, potion, enchantment, creature, NPC, armor, book, clothing, miscellaneous and weapon record data can now be sent in a RecordDynamic packet. Additionally, the packets include data related to associated magical effects (for spells, potions and enchantments), data related to default inventory contents (for creatures and NPCs) and data related to body parts affected (for armor and clothing).
The server now has associated script functions for setting most of the details of the above, with the main exception being individual creature and NPC stats.
Records can either be created entirely from scratch or can use an existing record (set via the baseId variable) as a starting point for their values. In the latter case, only the values that are specifically set override the starting values. Creature and NPC records also have an inventoryBaseId that can be used on top of the baseId to base their inventories on another existing record.
The client's RecordHelper class has been heavily expanded to allow for the above mentioned functionality.
When players create spells, potions and enchantments as part of regular gameplay, they send RecordDynamic packets that provide the server with the complete details of the records that should be created. When they create enchantments, they also provide the server with armor, book, clothing and weapon records corresponding to the items they've enchanted.
This functionality added by this packet was originally supposed to be exclusive to the rewrite, but I've gone ahead and tried to provide it for the pre-rewrite in a way that can mostly be reused for the rewrite.
2018-07-30 07:56:26 +00:00
|
|
|
finalData.mId = recordData.mId;
|
|
|
|
|
|
|
|
|
|
if (record.baseOverrides.hasName)
|
|
|
|
|
finalData.mName = recordData.mName;
|
|
|
|
|
|
|
|
|
|
if (record.baseOverrides.hasModel)
|
|
|
|
|
finalData.mModel = recordData.mModel;
|
|
|
|
|
|
2019-10-17 03:58:56 +00:00
|
|
|
if (record.baseOverrides.hasScript)
|
|
|
|
|
finalData.mScript = recordData.mScript;
|
[General] Implement RecordDynamic packet, part 1
Spell, potion, enchantment, creature, NPC, armor, book, clothing, miscellaneous and weapon record data can now be sent in a RecordDynamic packet. Additionally, the packets include data related to associated magical effects (for spells, potions and enchantments), data related to default inventory contents (for creatures and NPCs) and data related to body parts affected (for armor and clothing).
The server now has associated script functions for setting most of the details of the above, with the main exception being individual creature and NPC stats.
Records can either be created entirely from scratch or can use an existing record (set via the baseId variable) as a starting point for their values. In the latter case, only the values that are specifically set override the starting values. Creature and NPC records also have an inventoryBaseId that can be used on top of the baseId to base their inventories on another existing record.
The client's RecordHelper class has been heavily expanded to allow for the above mentioned functionality.
When players create spells, potions and enchantments as part of regular gameplay, they send RecordDynamic packets that provide the server with the complete details of the records that should be created. When they create enchantments, they also provide the server with armor, book, clothing and weapon records corresponding to the items they've enchanted.
This functionality added by this packet was originally supposed to be exclusive to the rewrite, but I've gone ahead and tried to provide it for the pre-rewrite in a way that can mostly be reused for the rewrite.
2018-07-30 07:56:26 +00:00
|
|
|
|
2019-10-17 03:58:56 +00:00
|
|
|
world->getModifiableStore().overrideRecord(finalData);
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
LOG_APPEND(TimedLog::LOG_INFO, "-- Ignoring record override with invalid baseId %s", record.baseId.c_str());
|
|
|
|
|
return;
|
|
|
|
|
}
|
[General] Implement RecordDynamic packet, part 1
Spell, potion, enchantment, creature, NPC, armor, book, clothing, miscellaneous and weapon record data can now be sent in a RecordDynamic packet. Additionally, the packets include data related to associated magical effects (for spells, potions and enchantments), data related to default inventory contents (for creatures and NPCs) and data related to body parts affected (for armor and clothing).
The server now has associated script functions for setting most of the details of the above, with the main exception being individual creature and NPC stats.
Records can either be created entirely from scratch or can use an existing record (set via the baseId variable) as a starting point for their values. In the latter case, only the values that are specifically set override the starting values. Creature and NPC records also have an inventoryBaseId that can be used on top of the baseId to base their inventories on another existing record.
The client's RecordHelper class has been heavily expanded to allow for the above mentioned functionality.
When players create spells, potions and enchantments as part of regular gameplay, they send RecordDynamic packets that provide the server with the complete details of the records that should be created. When they create enchantments, they also provide the server with armor, book, clothing and weapon records corresponding to the items they've enchanted.
This functionality added by this packet was originally supposed to be exclusive to the rewrite, but I've gone ahead and tried to provide it for the pre-rewrite in a way that can mostly be reused for the rewrite.
2018-07-30 07:56:26 +00:00
|
|
|
|
2019-10-17 03:58:56 +00:00
|
|
|
if (isExistingId)
|
|
|
|
|
world->updatePtrsWithRefId(recordData.mId);
|
|
|
|
|
}
|
2018-08-05 08:00:25 +00:00
|
|
|
|
2019-10-17 03:58:56 +00:00
|
|
|
void RecordHelper::overrideRecord(const mwmp::ApparatusRecord& record)
|
|
|
|
|
{
|
|
|
|
|
const ESM::Apparatus &recordData = record.data;
|
2018-08-05 08:00:25 +00:00
|
|
|
|
2019-10-17 03:58:56 +00:00
|
|
|
if (recordData.mId.empty())
|
|
|
|
|
{
|
|
|
|
|
LOG_APPEND(TimedLog::LOG_INFO, "-- Ignoring record override with no id provided");
|
|
|
|
|
return;
|
|
|
|
|
}
|
2018-08-05 08:00:25 +00:00
|
|
|
|
2019-10-17 03:58:56 +00:00
|
|
|
bool isExistingId = doesRecordIdExist<ESM::Apparatus>(recordData.mId);
|
|
|
|
|
MWBase::World *world = MWBase::Environment::get().getWorld();
|
2018-08-05 08:00:25 +00:00
|
|
|
|
2019-10-17 03:58:56 +00:00
|
|
|
if (record.baseId.empty())
|
|
|
|
|
{
|
|
|
|
|
world->getModifiableStore().overrideRecord(recordData);
|
|
|
|
|
}
|
|
|
|
|
else if (doesRecordIdExist<ESM::Apparatus>(record.baseId))
|
|
|
|
|
{
|
|
|
|
|
const ESM::Apparatus *baseData = world->getStore().get<ESM::Apparatus>().search(record.baseId);
|
|
|
|
|
ESM::Apparatus finalData = *baseData;
|
|
|
|
|
finalData.mId = recordData.mId;
|
2019-08-07 08:21:22 +00:00
|
|
|
|
2019-10-17 03:58:56 +00:00
|
|
|
if (record.baseOverrides.hasName)
|
|
|
|
|
finalData.mName = recordData.mName;
|
2019-08-07 08:21:22 +00:00
|
|
|
|
2019-10-17 03:58:56 +00:00
|
|
|
if (record.baseOverrides.hasModel)
|
|
|
|
|
finalData.mModel = recordData.mModel;
|
2019-08-07 07:44:07 +00:00
|
|
|
|
2019-10-17 03:58:56 +00:00
|
|
|
if (record.baseOverrides.hasIcon)
|
|
|
|
|
finalData.mIcon = recordData.mIcon;
|
|
|
|
|
|
|
|
|
|
if (record.baseOverrides.hasSubtype)
|
|
|
|
|
finalData.mData.mType = recordData.mData.mType;
|
|
|
|
|
|
|
|
|
|
if (record.baseOverrides.hasWeight)
|
|
|
|
|
finalData.mData.mWeight = recordData.mData.mWeight;
|
|
|
|
|
|
|
|
|
|
if (record.baseOverrides.hasValue)
|
|
|
|
|
finalData.mData.mValue = recordData.mData.mValue;
|
|
|
|
|
|
|
|
|
|
if (record.baseOverrides.hasQuality)
|
|
|
|
|
finalData.mData.mQuality = recordData.mData.mQuality;
|
[General] Implement RecordDynamic packet, part 1
Spell, potion, enchantment, creature, NPC, armor, book, clothing, miscellaneous and weapon record data can now be sent in a RecordDynamic packet. Additionally, the packets include data related to associated magical effects (for spells, potions and enchantments), data related to default inventory contents (for creatures and NPCs) and data related to body parts affected (for armor and clothing).
The server now has associated script functions for setting most of the details of the above, with the main exception being individual creature and NPC stats.
Records can either be created entirely from scratch or can use an existing record (set via the baseId variable) as a starting point for their values. In the latter case, only the values that are specifically set override the starting values. Creature and NPC records also have an inventoryBaseId that can be used on top of the baseId to base their inventories on another existing record.
The client's RecordHelper class has been heavily expanded to allow for the above mentioned functionality.
When players create spells, potions and enchantments as part of regular gameplay, they send RecordDynamic packets that provide the server with the complete details of the records that should be created. When they create enchantments, they also provide the server with armor, book, clothing and weapon records corresponding to the items they've enchanted.
This functionality added by this packet was originally supposed to be exclusive to the rewrite, but I've gone ahead and tried to provide it for the pre-rewrite in a way that can mostly be reused for the rewrite.
2018-07-30 07:56:26 +00:00
|
|
|
|
|
|
|
|
if (record.baseOverrides.hasScript)
|
|
|
|
|
finalData.mScript = recordData.mScript;
|
|
|
|
|
|
|
|
|
|
world->getModifiableStore().overrideRecord(finalData);
|
|
|
|
|
}
|
2019-01-22 22:48:06 +00:00
|
|
|
else
|
|
|
|
|
{
|
2019-08-19 18:39:33 +00:00
|
|
|
LOG_APPEND(TimedLog::LOG_INFO, "-- Ignoring record override with invalid baseId %s", record.baseId.c_str());
|
2019-01-22 22:48:06 +00:00
|
|
|
return;
|
|
|
|
|
}
|
[General] Implement RecordDynamic packet, part 1
Spell, potion, enchantment, creature, NPC, armor, book, clothing, miscellaneous and weapon record data can now be sent in a RecordDynamic packet. Additionally, the packets include data related to associated magical effects (for spells, potions and enchantments), data related to default inventory contents (for creatures and NPCs) and data related to body parts affected (for armor and clothing).
The server now has associated script functions for setting most of the details of the above, with the main exception being individual creature and NPC stats.
Records can either be created entirely from scratch or can use an existing record (set via the baseId variable) as a starting point for their values. In the latter case, only the values that are specifically set override the starting values. Creature and NPC records also have an inventoryBaseId that can be used on top of the baseId to base their inventories on another existing record.
The client's RecordHelper class has been heavily expanded to allow for the above mentioned functionality.
When players create spells, potions and enchantments as part of regular gameplay, they send RecordDynamic packets that provide the server with the complete details of the records that should be created. When they create enchantments, they also provide the server with armor, book, clothing and weapon records corresponding to the items they've enchanted.
This functionality added by this packet was originally supposed to be exclusive to the rewrite, but I've gone ahead and tried to provide it for the pre-rewrite in a way that can mostly be reused for the rewrite.
2018-07-30 07:56:26 +00:00
|
|
|
|
|
|
|
|
if (isExistingId)
|
|
|
|
|
world->updatePtrsWithRefId(recordData.mId);
|
|
|
|
|
}
|
|
|
|
|
|
2019-10-17 03:58:56 +00:00
|
|
|
void RecordHelper::overrideRecord(const mwmp::ArmorRecord& record)
|
[General] Implement RecordDynamic packet, part 1
Spell, potion, enchantment, creature, NPC, armor, book, clothing, miscellaneous and weapon record data can now be sent in a RecordDynamic packet. Additionally, the packets include data related to associated magical effects (for spells, potions and enchantments), data related to default inventory contents (for creatures and NPCs) and data related to body parts affected (for armor and clothing).
The server now has associated script functions for setting most of the details of the above, with the main exception being individual creature and NPC stats.
Records can either be created entirely from scratch or can use an existing record (set via the baseId variable) as a starting point for their values. In the latter case, only the values that are specifically set override the starting values. Creature and NPC records also have an inventoryBaseId that can be used on top of the baseId to base their inventories on another existing record.
The client's RecordHelper class has been heavily expanded to allow for the above mentioned functionality.
When players create spells, potions and enchantments as part of regular gameplay, they send RecordDynamic packets that provide the server with the complete details of the records that should be created. When they create enchantments, they also provide the server with armor, book, clothing and weapon records corresponding to the items they've enchanted.
This functionality added by this packet was originally supposed to be exclusive to the rewrite, but I've gone ahead and tried to provide it for the pre-rewrite in a way that can mostly be reused for the rewrite.
2018-07-30 07:56:26 +00:00
|
|
|
{
|
2019-10-17 03:58:56 +00:00
|
|
|
const ESM::Armor &recordData = record.data;
|
[General] Implement RecordDynamic packet, part 1
Spell, potion, enchantment, creature, NPC, armor, book, clothing, miscellaneous and weapon record data can now be sent in a RecordDynamic packet. Additionally, the packets include data related to associated magical effects (for spells, potions and enchantments), data related to default inventory contents (for creatures and NPCs) and data related to body parts affected (for armor and clothing).
The server now has associated script functions for setting most of the details of the above, with the main exception being individual creature and NPC stats.
Records can either be created entirely from scratch or can use an existing record (set via the baseId variable) as a starting point for their values. In the latter case, only the values that are specifically set override the starting values. Creature and NPC records also have an inventoryBaseId that can be used on top of the baseId to base their inventories on another existing record.
The client's RecordHelper class has been heavily expanded to allow for the above mentioned functionality.
When players create spells, potions and enchantments as part of regular gameplay, they send RecordDynamic packets that provide the server with the complete details of the records that should be created. When they create enchantments, they also provide the server with armor, book, clothing and weapon records corresponding to the items they've enchanted.
This functionality added by this packet was originally supposed to be exclusive to the rewrite, but I've gone ahead and tried to provide it for the pre-rewrite in a way that can mostly be reused for the rewrite.
2018-07-30 07:56:26 +00:00
|
|
|
|
|
|
|
|
if (recordData.mId.empty())
|
|
|
|
|
{
|
2019-08-19 18:39:33 +00:00
|
|
|
LOG_APPEND(TimedLog::LOG_INFO, "-- Ignoring record override with no id provided");
|
[General] Implement RecordDynamic packet, part 1
Spell, potion, enchantment, creature, NPC, armor, book, clothing, miscellaneous and weapon record data can now be sent in a RecordDynamic packet. Additionally, the packets include data related to associated magical effects (for spells, potions and enchantments), data related to default inventory contents (for creatures and NPCs) and data related to body parts affected (for armor and clothing).
The server now has associated script functions for setting most of the details of the above, with the main exception being individual creature and NPC stats.
Records can either be created entirely from scratch or can use an existing record (set via the baseId variable) as a starting point for their values. In the latter case, only the values that are specifically set override the starting values. Creature and NPC records also have an inventoryBaseId that can be used on top of the baseId to base their inventories on another existing record.
The client's RecordHelper class has been heavily expanded to allow for the above mentioned functionality.
When players create spells, potions and enchantments as part of regular gameplay, they send RecordDynamic packets that provide the server with the complete details of the records that should be created. When they create enchantments, they also provide the server with armor, book, clothing and weapon records corresponding to the items they've enchanted.
This functionality added by this packet was originally supposed to be exclusive to the rewrite, but I've gone ahead and tried to provide it for the pre-rewrite in a way that can mostly be reused for the rewrite.
2018-07-30 07:56:26 +00:00
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
2019-10-17 03:58:56 +00:00
|
|
|
bool isExistingId = doesRecordIdExist<ESM::Armor>(recordData.mId);
|
[General] Implement RecordDynamic packet, part 1
Spell, potion, enchantment, creature, NPC, armor, book, clothing, miscellaneous and weapon record data can now be sent in a RecordDynamic packet. Additionally, the packets include data related to associated magical effects (for spells, potions and enchantments), data related to default inventory contents (for creatures and NPCs) and data related to body parts affected (for armor and clothing).
The server now has associated script functions for setting most of the details of the above, with the main exception being individual creature and NPC stats.
Records can either be created entirely from scratch or can use an existing record (set via the baseId variable) as a starting point for their values. In the latter case, only the values that are specifically set override the starting values. Creature and NPC records also have an inventoryBaseId that can be used on top of the baseId to base their inventories on another existing record.
The client's RecordHelper class has been heavily expanded to allow for the above mentioned functionality.
When players create spells, potions and enchantments as part of regular gameplay, they send RecordDynamic packets that provide the server with the complete details of the records that should be created. When they create enchantments, they also provide the server with armor, book, clothing and weapon records corresponding to the items they've enchanted.
This functionality added by this packet was originally supposed to be exclusive to the rewrite, but I've gone ahead and tried to provide it for the pre-rewrite in a way that can mostly be reused for the rewrite.
2018-07-30 07:56:26 +00:00
|
|
|
MWBase::World *world = MWBase::Environment::get().getWorld();
|
|
|
|
|
|
|
|
|
|
if (record.baseId.empty())
|
|
|
|
|
{
|
2019-10-17 03:58:56 +00:00
|
|
|
if (!recordData.mEnchant.empty() && !doesRecordIdExist<ESM::Enchantment>(recordData.mEnchant))
|
[General] Implement RecordDynamic packet, part 1
Spell, potion, enchantment, creature, NPC, armor, book, clothing, miscellaneous and weapon record data can now be sent in a RecordDynamic packet. Additionally, the packets include data related to associated magical effects (for spells, potions and enchantments), data related to default inventory contents (for creatures and NPCs) and data related to body parts affected (for armor and clothing).
The server now has associated script functions for setting most of the details of the above, with the main exception being individual creature and NPC stats.
Records can either be created entirely from scratch or can use an existing record (set via the baseId variable) as a starting point for their values. In the latter case, only the values that are specifically set override the starting values. Creature and NPC records also have an inventoryBaseId that can be used on top of the baseId to base their inventories on another existing record.
The client's RecordHelper class has been heavily expanded to allow for the above mentioned functionality.
When players create spells, potions and enchantments as part of regular gameplay, they send RecordDynamic packets that provide the server with the complete details of the records that should be created. When they create enchantments, they also provide the server with armor, book, clothing and weapon records corresponding to the items they've enchanted.
This functionality added by this packet was originally supposed to be exclusive to the rewrite, but I've gone ahead and tried to provide it for the pre-rewrite in a way that can mostly be reused for the rewrite.
2018-07-30 07:56:26 +00:00
|
|
|
{
|
2019-10-17 03:58:56 +00:00
|
|
|
LOG_APPEND(TimedLog::LOG_INFO, "-- Ignoring new armor record with invalid enchantmentId %s", recordData.mEnchant.c_str());
|
[General] Implement RecordDynamic packet, part 1
Spell, potion, enchantment, creature, NPC, armor, book, clothing, miscellaneous and weapon record data can now be sent in a RecordDynamic packet. Additionally, the packets include data related to associated magical effects (for spells, potions and enchantments), data related to default inventory contents (for creatures and NPCs) and data related to body parts affected (for armor and clothing).
The server now has associated script functions for setting most of the details of the above, with the main exception being individual creature and NPC stats.
Records can either be created entirely from scratch or can use an existing record (set via the baseId variable) as a starting point for their values. In the latter case, only the values that are specifically set override the starting values. Creature and NPC records also have an inventoryBaseId that can be used on top of the baseId to base their inventories on another existing record.
The client's RecordHelper class has been heavily expanded to allow for the above mentioned functionality.
When players create spells, potions and enchantments as part of regular gameplay, they send RecordDynamic packets that provide the server with the complete details of the records that should be created. When they create enchantments, they also provide the server with armor, book, clothing and weapon records corresponding to the items they've enchanted.
This functionality added by this packet was originally supposed to be exclusive to the rewrite, but I've gone ahead and tried to provide it for the pre-rewrite in a way that can mostly be reused for the rewrite.
2018-07-30 07:56:26 +00:00
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
world->getModifiableStore().overrideRecord(recordData);
|
|
|
|
|
}
|
2019-10-17 03:58:56 +00:00
|
|
|
else if (doesRecordIdExist<ESM::Armor>(record.baseId))
|
[General] Implement RecordDynamic packet, part 1
Spell, potion, enchantment, creature, NPC, armor, book, clothing, miscellaneous and weapon record data can now be sent in a RecordDynamic packet. Additionally, the packets include data related to associated magical effects (for spells, potions and enchantments), data related to default inventory contents (for creatures and NPCs) and data related to body parts affected (for armor and clothing).
The server now has associated script functions for setting most of the details of the above, with the main exception being individual creature and NPC stats.
Records can either be created entirely from scratch or can use an existing record (set via the baseId variable) as a starting point for their values. In the latter case, only the values that are specifically set override the starting values. Creature and NPC records also have an inventoryBaseId that can be used on top of the baseId to base their inventories on another existing record.
The client's RecordHelper class has been heavily expanded to allow for the above mentioned functionality.
When players create spells, potions and enchantments as part of regular gameplay, they send RecordDynamic packets that provide the server with the complete details of the records that should be created. When they create enchantments, they also provide the server with armor, book, clothing and weapon records corresponding to the items they've enchanted.
This functionality added by this packet was originally supposed to be exclusive to the rewrite, but I've gone ahead and tried to provide it for the pre-rewrite in a way that can mostly be reused for the rewrite.
2018-07-30 07:56:26 +00:00
|
|
|
{
|
2019-10-17 03:58:56 +00:00
|
|
|
const ESM::Armor *baseData = world->getStore().get<ESM::Armor>().search(record.baseId);
|
|
|
|
|
ESM::Armor finalData = *baseData;
|
[General] Implement RecordDynamic packet, part 1
Spell, potion, enchantment, creature, NPC, armor, book, clothing, miscellaneous and weapon record data can now be sent in a RecordDynamic packet. Additionally, the packets include data related to associated magical effects (for spells, potions and enchantments), data related to default inventory contents (for creatures and NPCs) and data related to body parts affected (for armor and clothing).
The server now has associated script functions for setting most of the details of the above, with the main exception being individual creature and NPC stats.
Records can either be created entirely from scratch or can use an existing record (set via the baseId variable) as a starting point for their values. In the latter case, only the values that are specifically set override the starting values. Creature and NPC records also have an inventoryBaseId that can be used on top of the baseId to base their inventories on another existing record.
The client's RecordHelper class has been heavily expanded to allow for the above mentioned functionality.
When players create spells, potions and enchantments as part of regular gameplay, they send RecordDynamic packets that provide the server with the complete details of the records that should be created. When they create enchantments, they also provide the server with armor, book, clothing and weapon records corresponding to the items they've enchanted.
This functionality added by this packet was originally supposed to be exclusive to the rewrite, but I've gone ahead and tried to provide it for the pre-rewrite in a way that can mostly be reused for the rewrite.
2018-07-30 07:56:26 +00:00
|
|
|
finalData.mId = recordData.mId;
|
|
|
|
|
|
2019-10-17 03:58:56 +00:00
|
|
|
finalData.mParts.mParts.at(0);
|
|
|
|
|
|
[General] Implement RecordDynamic packet, part 1
Spell, potion, enchantment, creature, NPC, armor, book, clothing, miscellaneous and weapon record data can now be sent in a RecordDynamic packet. Additionally, the packets include data related to associated magical effects (for spells, potions and enchantments), data related to default inventory contents (for creatures and NPCs) and data related to body parts affected (for armor and clothing).
The server now has associated script functions for setting most of the details of the above, with the main exception being individual creature and NPC stats.
Records can either be created entirely from scratch or can use an existing record (set via the baseId variable) as a starting point for their values. In the latter case, only the values that are specifically set override the starting values. Creature and NPC records also have an inventoryBaseId that can be used on top of the baseId to base their inventories on another existing record.
The client's RecordHelper class has been heavily expanded to allow for the above mentioned functionality.
When players create spells, potions and enchantments as part of regular gameplay, they send RecordDynamic packets that provide the server with the complete details of the records that should be created. When they create enchantments, they also provide the server with armor, book, clothing and weapon records corresponding to the items they've enchanted.
This functionality added by this packet was originally supposed to be exclusive to the rewrite, but I've gone ahead and tried to provide it for the pre-rewrite in a way that can mostly be reused for the rewrite.
2018-07-30 07:56:26 +00:00
|
|
|
if (record.baseOverrides.hasName)
|
|
|
|
|
finalData.mName = recordData.mName;
|
|
|
|
|
|
|
|
|
|
if (record.baseOverrides.hasModel)
|
|
|
|
|
finalData.mModel = recordData.mModel;
|
|
|
|
|
|
2019-10-17 03:58:56 +00:00
|
|
|
if (record.baseOverrides.hasIcon)
|
|
|
|
|
finalData.mIcon = recordData.mIcon;
|
[General] Implement RecordDynamic packet, part 1
Spell, potion, enchantment, creature, NPC, armor, book, clothing, miscellaneous and weapon record data can now be sent in a RecordDynamic packet. Additionally, the packets include data related to associated magical effects (for spells, potions and enchantments), data related to default inventory contents (for creatures and NPCs) and data related to body parts affected (for armor and clothing).
The server now has associated script functions for setting most of the details of the above, with the main exception being individual creature and NPC stats.
Records can either be created entirely from scratch or can use an existing record (set via the baseId variable) as a starting point for their values. In the latter case, only the values that are specifically set override the starting values. Creature and NPC records also have an inventoryBaseId that can be used on top of the baseId to base their inventories on another existing record.
The client's RecordHelper class has been heavily expanded to allow for the above mentioned functionality.
When players create spells, potions and enchantments as part of regular gameplay, they send RecordDynamic packets that provide the server with the complete details of the records that should be created. When they create enchantments, they also provide the server with armor, book, clothing and weapon records corresponding to the items they've enchanted.
This functionality added by this packet was originally supposed to be exclusive to the rewrite, but I've gone ahead and tried to provide it for the pre-rewrite in a way that can mostly be reused for the rewrite.
2018-07-30 07:56:26 +00:00
|
|
|
|
2019-10-17 03:58:56 +00:00
|
|
|
if (record.baseOverrides.hasSubtype)
|
|
|
|
|
finalData.mData.mType = recordData.mData.mType;
|
[General] Implement RecordDynamic packet, part 1
Spell, potion, enchantment, creature, NPC, armor, book, clothing, miscellaneous and weapon record data can now be sent in a RecordDynamic packet. Additionally, the packets include data related to associated magical effects (for spells, potions and enchantments), data related to default inventory contents (for creatures and NPCs) and data related to body parts affected (for armor and clothing).
The server now has associated script functions for setting most of the details of the above, with the main exception being individual creature and NPC stats.
Records can either be created entirely from scratch or can use an existing record (set via the baseId variable) as a starting point for their values. In the latter case, only the values that are specifically set override the starting values. Creature and NPC records also have an inventoryBaseId that can be used on top of the baseId to base their inventories on another existing record.
The client's RecordHelper class has been heavily expanded to allow for the above mentioned functionality.
When players create spells, potions and enchantments as part of regular gameplay, they send RecordDynamic packets that provide the server with the complete details of the records that should be created. When they create enchantments, they also provide the server with armor, book, clothing and weapon records corresponding to the items they've enchanted.
This functionality added by this packet was originally supposed to be exclusive to the rewrite, but I've gone ahead and tried to provide it for the pre-rewrite in a way that can mostly be reused for the rewrite.
2018-07-30 07:56:26 +00:00
|
|
|
|
2019-10-17 03:58:56 +00:00
|
|
|
if (record.baseOverrides.hasWeight)
|
|
|
|
|
finalData.mData.mWeight = recordData.mData.mWeight;
|
[General] Implement RecordDynamic packet, part 1
Spell, potion, enchantment, creature, NPC, armor, book, clothing, miscellaneous and weapon record data can now be sent in a RecordDynamic packet. Additionally, the packets include data related to associated magical effects (for spells, potions and enchantments), data related to default inventory contents (for creatures and NPCs) and data related to body parts affected (for armor and clothing).
The server now has associated script functions for setting most of the details of the above, with the main exception being individual creature and NPC stats.
Records can either be created entirely from scratch or can use an existing record (set via the baseId variable) as a starting point for their values. In the latter case, only the values that are specifically set override the starting values. Creature and NPC records also have an inventoryBaseId that can be used on top of the baseId to base their inventories on another existing record.
The client's RecordHelper class has been heavily expanded to allow for the above mentioned functionality.
When players create spells, potions and enchantments as part of regular gameplay, they send RecordDynamic packets that provide the server with the complete details of the records that should be created. When they create enchantments, they also provide the server with armor, book, clothing and weapon records corresponding to the items they've enchanted.
This functionality added by this packet was originally supposed to be exclusive to the rewrite, but I've gone ahead and tried to provide it for the pre-rewrite in a way that can mostly be reused for the rewrite.
2018-07-30 07:56:26 +00:00
|
|
|
|
2019-10-17 03:58:56 +00:00
|
|
|
if (record.baseOverrides.hasValue)
|
|
|
|
|
finalData.mData.mValue = recordData.mData.mValue;
|
[General] Implement RecordDynamic packet, part 1
Spell, potion, enchantment, creature, NPC, armor, book, clothing, miscellaneous and weapon record data can now be sent in a RecordDynamic packet. Additionally, the packets include data related to associated magical effects (for spells, potions and enchantments), data related to default inventory contents (for creatures and NPCs) and data related to body parts affected (for armor and clothing).
The server now has associated script functions for setting most of the details of the above, with the main exception being individual creature and NPC stats.
Records can either be created entirely from scratch or can use an existing record (set via the baseId variable) as a starting point for their values. In the latter case, only the values that are specifically set override the starting values. Creature and NPC records also have an inventoryBaseId that can be used on top of the baseId to base their inventories on another existing record.
The client's RecordHelper class has been heavily expanded to allow for the above mentioned functionality.
When players create spells, potions and enchantments as part of regular gameplay, they send RecordDynamic packets that provide the server with the complete details of the records that should be created. When they create enchantments, they also provide the server with armor, book, clothing and weapon records corresponding to the items they've enchanted.
This functionality added by this packet was originally supposed to be exclusive to the rewrite, but I've gone ahead and tried to provide it for the pre-rewrite in a way that can mostly be reused for the rewrite.
2018-07-30 07:56:26 +00:00
|
|
|
|
2018-08-05 08:00:25 +00:00
|
|
|
if (record.baseOverrides.hasHealth)
|
2019-10-17 03:58:56 +00:00
|
|
|
finalData.mData.mHealth = recordData.mData.mHealth;
|
2019-08-07 07:44:07 +00:00
|
|
|
|
2019-10-17 03:58:56 +00:00
|
|
|
if (record.baseOverrides.hasArmorRating)
|
|
|
|
|
finalData.mData.mArmor = recordData.mData.mArmor;
|
2018-08-05 08:00:25 +00:00
|
|
|
|
2019-10-17 03:58:56 +00:00
|
|
|
if (record.baseOverrides.hasEnchantmentId)
|
2018-08-05 08:00:25 +00:00
|
|
|
{
|
2019-10-17 03:58:56 +00:00
|
|
|
if (recordData.mEnchant.empty() || doesRecordIdExist<ESM::Enchantment>(recordData.mEnchant))
|
|
|
|
|
finalData.mEnchant = recordData.mEnchant;
|
2018-08-05 08:00:25 +00:00
|
|
|
else
|
2019-10-17 03:58:56 +00:00
|
|
|
LOG_APPEND(TimedLog::LOG_INFO, "-- Ignoring invalid enchantmentId %s", recordData.mEnchant.c_str());
|
2018-08-05 08:00:25 +00:00
|
|
|
}
|
|
|
|
|
|
2019-10-17 03:58:56 +00:00
|
|
|
if (record.baseOverrides.hasEnchantmentCharge)
|
|
|
|
|
finalData.mData.mEnchant = recordData.mData.mEnchant;
|
|
|
|
|
|
|
|
|
|
if (record.baseOverrides.hasScript)
|
|
|
|
|
finalData.mScript = recordData.mScript;
|
|
|
|
|
|
|
|
|
|
if (record.baseOverrides.hasBodyParts)
|
|
|
|
|
finalData.mParts.mParts = recordData.mParts.mParts;
|
[General] Implement RecordDynamic packet, part 1
Spell, potion, enchantment, creature, NPC, armor, book, clothing, miscellaneous and weapon record data can now be sent in a RecordDynamic packet. Additionally, the packets include data related to associated magical effects (for spells, potions and enchantments), data related to default inventory contents (for creatures and NPCs) and data related to body parts affected (for armor and clothing).
The server now has associated script functions for setting most of the details of the above, with the main exception being individual creature and NPC stats.
Records can either be created entirely from scratch or can use an existing record (set via the baseId variable) as a starting point for their values. In the latter case, only the values that are specifically set override the starting values. Creature and NPC records also have an inventoryBaseId that can be used on top of the baseId to base their inventories on another existing record.
The client's RecordHelper class has been heavily expanded to allow for the above mentioned functionality.
When players create spells, potions and enchantments as part of regular gameplay, they send RecordDynamic packets that provide the server with the complete details of the records that should be created. When they create enchantments, they also provide the server with armor, book, clothing and weapon records corresponding to the items they've enchanted.
This functionality added by this packet was originally supposed to be exclusive to the rewrite, but I've gone ahead and tried to provide it for the pre-rewrite in a way that can mostly be reused for the rewrite.
2018-07-30 07:56:26 +00:00
|
|
|
|
|
|
|
|
world->getModifiableStore().overrideRecord(finalData);
|
|
|
|
|
}
|
2019-01-22 22:48:06 +00:00
|
|
|
else
|
|
|
|
|
{
|
2019-08-19 18:39:33 +00:00
|
|
|
LOG_APPEND(TimedLog::LOG_INFO, "-- Ignoring record override with invalid baseId %s", record.baseId.c_str());
|
2019-01-22 22:48:06 +00:00
|
|
|
return;
|
|
|
|
|
}
|
[General] Implement RecordDynamic packet, part 1
Spell, potion, enchantment, creature, NPC, armor, book, clothing, miscellaneous and weapon record data can now be sent in a RecordDynamic packet. Additionally, the packets include data related to associated magical effects (for spells, potions and enchantments), data related to default inventory contents (for creatures and NPCs) and data related to body parts affected (for armor and clothing).
The server now has associated script functions for setting most of the details of the above, with the main exception being individual creature and NPC stats.
Records can either be created entirely from scratch or can use an existing record (set via the baseId variable) as a starting point for their values. In the latter case, only the values that are specifically set override the starting values. Creature and NPC records also have an inventoryBaseId that can be used on top of the baseId to base their inventories on another existing record.
The client's RecordHelper class has been heavily expanded to allow for the above mentioned functionality.
When players create spells, potions and enchantments as part of regular gameplay, they send RecordDynamic packets that provide the server with the complete details of the records that should be created. When they create enchantments, they also provide the server with armor, book, clothing and weapon records corresponding to the items they've enchanted.
This functionality added by this packet was originally supposed to be exclusive to the rewrite, but I've gone ahead and tried to provide it for the pre-rewrite in a way that can mostly be reused for the rewrite.
2018-07-30 07:56:26 +00:00
|
|
|
|
|
|
|
|
if (isExistingId)
|
|
|
|
|
world->updatePtrsWithRefId(recordData.mId);
|
|
|
|
|
}
|
|
|
|
|
|
2019-11-29 12:06:17 +00:00
|
|
|
void RecordHelper::overrideRecord(const mwmp::BodyPartRecord& record)
|
|
|
|
|
{
|
|
|
|
|
const ESM::BodyPart &recordData = record.data;
|
|
|
|
|
|
|
|
|
|
if (recordData.mId.empty())
|
|
|
|
|
{
|
|
|
|
|
LOG_APPEND(TimedLog::LOG_INFO, "-- Ignoring record override with no id provided");
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
MWBase::World *world = MWBase::Environment::get().getWorld();
|
|
|
|
|
|
|
|
|
|
if (record.baseId.empty())
|
|
|
|
|
{
|
|
|
|
|
world->getModifiableStore().overrideRecord(recordData);
|
|
|
|
|
}
|
|
|
|
|
else if (doesRecordIdExist<ESM::BodyPart>(record.baseId))
|
|
|
|
|
{
|
|
|
|
|
const ESM::BodyPart *baseData = world->getStore().get<ESM::BodyPart>().search(record.baseId);
|
|
|
|
|
ESM::BodyPart finalData = *baseData;
|
|
|
|
|
finalData.mId = recordData.mId;
|
|
|
|
|
|
|
|
|
|
if (record.baseOverrides.hasModel)
|
|
|
|
|
finalData.mModel = recordData.mModel;
|
|
|
|
|
|
|
|
|
|
if (record.baseOverrides.hasRace)
|
|
|
|
|
finalData.mRace = recordData.mRace;
|
|
|
|
|
|
|
|
|
|
if (record.baseOverrides.hasSubtype)
|
|
|
|
|
finalData.mData.mType = recordData.mData.mType;
|
|
|
|
|
|
|
|
|
|
if (record.baseOverrides.hasBodyPartType)
|
|
|
|
|
finalData.mData.mPart = recordData.mData.mPart;
|
|
|
|
|
|
|
|
|
|
if (record.baseOverrides.hasVampireState)
|
|
|
|
|
finalData.mData.mVampire = recordData.mData.mVampire;
|
|
|
|
|
|
|
|
|
|
if (record.baseOverrides.hasFlags)
|
|
|
|
|
finalData.mData.mFlags = recordData.mData.mFlags;
|
|
|
|
|
|
|
|
|
|
world->getModifiableStore().overrideRecord(finalData);
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
LOG_APPEND(TimedLog::LOG_INFO, "-- Ignoring record override with invalid baseId %s", record.baseId.c_str());
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2019-10-17 03:58:56 +00:00
|
|
|
void RecordHelper::overrideRecord(const mwmp::BookRecord& record)
|
[General] Implement RecordDynamic packet, part 1
Spell, potion, enchantment, creature, NPC, armor, book, clothing, miscellaneous and weapon record data can now be sent in a RecordDynamic packet. Additionally, the packets include data related to associated magical effects (for spells, potions and enchantments), data related to default inventory contents (for creatures and NPCs) and data related to body parts affected (for armor and clothing).
The server now has associated script functions for setting most of the details of the above, with the main exception being individual creature and NPC stats.
Records can either be created entirely from scratch or can use an existing record (set via the baseId variable) as a starting point for their values. In the latter case, only the values that are specifically set override the starting values. Creature and NPC records also have an inventoryBaseId that can be used on top of the baseId to base their inventories on another existing record.
The client's RecordHelper class has been heavily expanded to allow for the above mentioned functionality.
When players create spells, potions and enchantments as part of regular gameplay, they send RecordDynamic packets that provide the server with the complete details of the records that should be created. When they create enchantments, they also provide the server with armor, book, clothing and weapon records corresponding to the items they've enchanted.
This functionality added by this packet was originally supposed to be exclusive to the rewrite, but I've gone ahead and tried to provide it for the pre-rewrite in a way that can mostly be reused for the rewrite.
2018-07-30 07:56:26 +00:00
|
|
|
{
|
2019-10-17 03:58:56 +00:00
|
|
|
const ESM::Book &recordData = record.data;
|
[General] Implement RecordDynamic packet, part 1
Spell, potion, enchantment, creature, NPC, armor, book, clothing, miscellaneous and weapon record data can now be sent in a RecordDynamic packet. Additionally, the packets include data related to associated magical effects (for spells, potions and enchantments), data related to default inventory contents (for creatures and NPCs) and data related to body parts affected (for armor and clothing).
The server now has associated script functions for setting most of the details of the above, with the main exception being individual creature and NPC stats.
Records can either be created entirely from scratch or can use an existing record (set via the baseId variable) as a starting point for their values. In the latter case, only the values that are specifically set override the starting values. Creature and NPC records also have an inventoryBaseId that can be used on top of the baseId to base their inventories on another existing record.
The client's RecordHelper class has been heavily expanded to allow for the above mentioned functionality.
When players create spells, potions and enchantments as part of regular gameplay, they send RecordDynamic packets that provide the server with the complete details of the records that should be created. When they create enchantments, they also provide the server with armor, book, clothing and weapon records corresponding to the items they've enchanted.
This functionality added by this packet was originally supposed to be exclusive to the rewrite, but I've gone ahead and tried to provide it for the pre-rewrite in a way that can mostly be reused for the rewrite.
2018-07-30 07:56:26 +00:00
|
|
|
|
|
|
|
|
if (recordData.mId.empty())
|
|
|
|
|
{
|
2019-08-19 18:39:33 +00:00
|
|
|
LOG_APPEND(TimedLog::LOG_INFO, "-- Ignoring record override with no id provided");
|
[General] Implement RecordDynamic packet, part 1
Spell, potion, enchantment, creature, NPC, armor, book, clothing, miscellaneous and weapon record data can now be sent in a RecordDynamic packet. Additionally, the packets include data related to associated magical effects (for spells, potions and enchantments), data related to default inventory contents (for creatures and NPCs) and data related to body parts affected (for armor and clothing).
The server now has associated script functions for setting most of the details of the above, with the main exception being individual creature and NPC stats.
Records can either be created entirely from scratch or can use an existing record (set via the baseId variable) as a starting point for their values. In the latter case, only the values that are specifically set override the starting values. Creature and NPC records also have an inventoryBaseId that can be used on top of the baseId to base their inventories on another existing record.
The client's RecordHelper class has been heavily expanded to allow for the above mentioned functionality.
When players create spells, potions and enchantments as part of regular gameplay, they send RecordDynamic packets that provide the server with the complete details of the records that should be created. When they create enchantments, they also provide the server with armor, book, clothing and weapon records corresponding to the items they've enchanted.
This functionality added by this packet was originally supposed to be exclusive to the rewrite, but I've gone ahead and tried to provide it for the pre-rewrite in a way that can mostly be reused for the rewrite.
2018-07-30 07:56:26 +00:00
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
2019-10-17 03:58:56 +00:00
|
|
|
bool isExistingId = doesRecordIdExist<ESM::Book>(recordData.mId);
|
[General] Implement RecordDynamic packet, part 1
Spell, potion, enchantment, creature, NPC, armor, book, clothing, miscellaneous and weapon record data can now be sent in a RecordDynamic packet. Additionally, the packets include data related to associated magical effects (for spells, potions and enchantments), data related to default inventory contents (for creatures and NPCs) and data related to body parts affected (for armor and clothing).
The server now has associated script functions for setting most of the details of the above, with the main exception being individual creature and NPC stats.
Records can either be created entirely from scratch or can use an existing record (set via the baseId variable) as a starting point for their values. In the latter case, only the values that are specifically set override the starting values. Creature and NPC records also have an inventoryBaseId that can be used on top of the baseId to base their inventories on another existing record.
The client's RecordHelper class has been heavily expanded to allow for the above mentioned functionality.
When players create spells, potions and enchantments as part of regular gameplay, they send RecordDynamic packets that provide the server with the complete details of the records that should be created. When they create enchantments, they also provide the server with armor, book, clothing and weapon records corresponding to the items they've enchanted.
This functionality added by this packet was originally supposed to be exclusive to the rewrite, but I've gone ahead and tried to provide it for the pre-rewrite in a way that can mostly be reused for the rewrite.
2018-07-30 07:56:26 +00:00
|
|
|
MWBase::World *world = MWBase::Environment::get().getWorld();
|
|
|
|
|
|
|
|
|
|
if (record.baseId.empty())
|
|
|
|
|
{
|
2019-10-17 03:58:56 +00:00
|
|
|
if (!recordData.mEnchant.empty() && !doesRecordIdExist<ESM::Enchantment>(recordData.mEnchant))
|
2018-08-20 12:24:20 +00:00
|
|
|
{
|
2019-10-17 03:58:56 +00:00
|
|
|
LOG_APPEND(TimedLog::LOG_INFO, "-- Ignoring new book record with invalid enchantmentId %s", recordData.mEnchant.c_str());
|
2018-08-20 12:24:20 +00:00
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
world->getModifiableStore().overrideRecord(recordData);
|
[General] Implement RecordDynamic packet, part 1
Spell, potion, enchantment, creature, NPC, armor, book, clothing, miscellaneous and weapon record data can now be sent in a RecordDynamic packet. Additionally, the packets include data related to associated magical effects (for spells, potions and enchantments), data related to default inventory contents (for creatures and NPCs) and data related to body parts affected (for armor and clothing).
The server now has associated script functions for setting most of the details of the above, with the main exception being individual creature and NPC stats.
Records can either be created entirely from scratch or can use an existing record (set via the baseId variable) as a starting point for their values. In the latter case, only the values that are specifically set override the starting values. Creature and NPC records also have an inventoryBaseId that can be used on top of the baseId to base their inventories on another existing record.
The client's RecordHelper class has been heavily expanded to allow for the above mentioned functionality.
When players create spells, potions and enchantments as part of regular gameplay, they send RecordDynamic packets that provide the server with the complete details of the records that should be created. When they create enchantments, they also provide the server with armor, book, clothing and weapon records corresponding to the items they've enchanted.
This functionality added by this packet was originally supposed to be exclusive to the rewrite, but I've gone ahead and tried to provide it for the pre-rewrite in a way that can mostly be reused for the rewrite.
2018-07-30 07:56:26 +00:00
|
|
|
}
|
2019-10-17 03:58:56 +00:00
|
|
|
else if (doesRecordIdExist<ESM::Book>(record.baseId))
|
[General] Implement RecordDynamic packet, part 1
Spell, potion, enchantment, creature, NPC, armor, book, clothing, miscellaneous and weapon record data can now be sent in a RecordDynamic packet. Additionally, the packets include data related to associated magical effects (for spells, potions and enchantments), data related to default inventory contents (for creatures and NPCs) and data related to body parts affected (for armor and clothing).
The server now has associated script functions for setting most of the details of the above, with the main exception being individual creature and NPC stats.
Records can either be created entirely from scratch or can use an existing record (set via the baseId variable) as a starting point for their values. In the latter case, only the values that are specifically set override the starting values. Creature and NPC records also have an inventoryBaseId that can be used on top of the baseId to base their inventories on another existing record.
The client's RecordHelper class has been heavily expanded to allow for the above mentioned functionality.
When players create spells, potions and enchantments as part of regular gameplay, they send RecordDynamic packets that provide the server with the complete details of the records that should be created. When they create enchantments, they also provide the server with armor, book, clothing and weapon records corresponding to the items they've enchanted.
This functionality added by this packet was originally supposed to be exclusive to the rewrite, but I've gone ahead and tried to provide it for the pre-rewrite in a way that can mostly be reused for the rewrite.
2018-07-30 07:56:26 +00:00
|
|
|
{
|
2019-10-17 03:58:56 +00:00
|
|
|
const ESM::Book *baseData = world->getStore().get<ESM::Book>().search(record.baseId);
|
|
|
|
|
ESM::Book finalData = *baseData;
|
[General] Implement RecordDynamic packet, part 1
Spell, potion, enchantment, creature, NPC, armor, book, clothing, miscellaneous and weapon record data can now be sent in a RecordDynamic packet. Additionally, the packets include data related to associated magical effects (for spells, potions and enchantments), data related to default inventory contents (for creatures and NPCs) and data related to body parts affected (for armor and clothing).
The server now has associated script functions for setting most of the details of the above, with the main exception being individual creature and NPC stats.
Records can either be created entirely from scratch or can use an existing record (set via the baseId variable) as a starting point for their values. In the latter case, only the values that are specifically set override the starting values. Creature and NPC records also have an inventoryBaseId that can be used on top of the baseId to base their inventories on another existing record.
The client's RecordHelper class has been heavily expanded to allow for the above mentioned functionality.
When players create spells, potions and enchantments as part of regular gameplay, they send RecordDynamic packets that provide the server with the complete details of the records that should be created. When they create enchantments, they also provide the server with armor, book, clothing and weapon records corresponding to the items they've enchanted.
This functionality added by this packet was originally supposed to be exclusive to the rewrite, but I've gone ahead and tried to provide it for the pre-rewrite in a way that can mostly be reused for the rewrite.
2018-07-30 07:56:26 +00:00
|
|
|
finalData.mId = recordData.mId;
|
|
|
|
|
|
2019-10-17 03:58:56 +00:00
|
|
|
if (record.baseOverrides.hasName)
|
|
|
|
|
finalData.mName = recordData.mName;
|
[General] Implement RecordDynamic packet, part 1
Spell, potion, enchantment, creature, NPC, armor, book, clothing, miscellaneous and weapon record data can now be sent in a RecordDynamic packet. Additionally, the packets include data related to associated magical effects (for spells, potions and enchantments), data related to default inventory contents (for creatures and NPCs) and data related to body parts affected (for armor and clothing).
The server now has associated script functions for setting most of the details of the above, with the main exception being individual creature and NPC stats.
Records can either be created entirely from scratch or can use an existing record (set via the baseId variable) as a starting point for their values. In the latter case, only the values that are specifically set override the starting values. Creature and NPC records also have an inventoryBaseId that can be used on top of the baseId to base their inventories on another existing record.
The client's RecordHelper class has been heavily expanded to allow for the above mentioned functionality.
When players create spells, potions and enchantments as part of regular gameplay, they send RecordDynamic packets that provide the server with the complete details of the records that should be created. When they create enchantments, they also provide the server with armor, book, clothing and weapon records corresponding to the items they've enchanted.
This functionality added by this packet was originally supposed to be exclusive to the rewrite, but I've gone ahead and tried to provide it for the pre-rewrite in a way that can mostly be reused for the rewrite.
2018-07-30 07:56:26 +00:00
|
|
|
|
2019-10-17 03:58:56 +00:00
|
|
|
if (record.baseOverrides.hasModel)
|
|
|
|
|
finalData.mModel = recordData.mModel;
|
[General] Implement RecordDynamic packet, part 1
Spell, potion, enchantment, creature, NPC, armor, book, clothing, miscellaneous and weapon record data can now be sent in a RecordDynamic packet. Additionally, the packets include data related to associated magical effects (for spells, potions and enchantments), data related to default inventory contents (for creatures and NPCs) and data related to body parts affected (for armor and clothing).
The server now has associated script functions for setting most of the details of the above, with the main exception being individual creature and NPC stats.
Records can either be created entirely from scratch or can use an existing record (set via the baseId variable) as a starting point for their values. In the latter case, only the values that are specifically set override the starting values. Creature and NPC records also have an inventoryBaseId that can be used on top of the baseId to base their inventories on another existing record.
The client's RecordHelper class has been heavily expanded to allow for the above mentioned functionality.
When players create spells, potions and enchantments as part of regular gameplay, they send RecordDynamic packets that provide the server with the complete details of the records that should be created. When they create enchantments, they also provide the server with armor, book, clothing and weapon records corresponding to the items they've enchanted.
This functionality added by this packet was originally supposed to be exclusive to the rewrite, but I've gone ahead and tried to provide it for the pre-rewrite in a way that can mostly be reused for the rewrite.
2018-07-30 07:56:26 +00:00
|
|
|
|
2019-10-17 03:58:56 +00:00
|
|
|
if (record.baseOverrides.hasIcon)
|
|
|
|
|
finalData.mIcon = recordData.mIcon;
|
[General] Implement RecordDynamic packet, part 1
Spell, potion, enchantment, creature, NPC, armor, book, clothing, miscellaneous and weapon record data can now be sent in a RecordDynamic packet. Additionally, the packets include data related to associated magical effects (for spells, potions and enchantments), data related to default inventory contents (for creatures and NPCs) and data related to body parts affected (for armor and clothing).
The server now has associated script functions for setting most of the details of the above, with the main exception being individual creature and NPC stats.
Records can either be created entirely from scratch or can use an existing record (set via the baseId variable) as a starting point for their values. In the latter case, only the values that are specifically set override the starting values. Creature and NPC records also have an inventoryBaseId that can be used on top of the baseId to base their inventories on another existing record.
The client's RecordHelper class has been heavily expanded to allow for the above mentioned functionality.
When players create spells, potions and enchantments as part of regular gameplay, they send RecordDynamic packets that provide the server with the complete details of the records that should be created. When they create enchantments, they also provide the server with armor, book, clothing and weapon records corresponding to the items they've enchanted.
This functionality added by this packet was originally supposed to be exclusive to the rewrite, but I've gone ahead and tried to provide it for the pre-rewrite in a way that can mostly be reused for the rewrite.
2018-07-30 07:56:26 +00:00
|
|
|
|
2019-10-17 03:58:56 +00:00
|
|
|
if (record.baseOverrides.hasText)
|
|
|
|
|
finalData.mText = recordData.mText;
|
[General] Implement RecordDynamic packet, part 1
Spell, potion, enchantment, creature, NPC, armor, book, clothing, miscellaneous and weapon record data can now be sent in a RecordDynamic packet. Additionally, the packets include data related to associated magical effects (for spells, potions and enchantments), data related to default inventory contents (for creatures and NPCs) and data related to body parts affected (for armor and clothing).
The server now has associated script functions for setting most of the details of the above, with the main exception being individual creature and NPC stats.
Records can either be created entirely from scratch or can use an existing record (set via the baseId variable) as a starting point for their values. In the latter case, only the values that are specifically set override the starting values. Creature and NPC records also have an inventoryBaseId that can be used on top of the baseId to base their inventories on another existing record.
The client's RecordHelper class has been heavily expanded to allow for the above mentioned functionality.
When players create spells, potions and enchantments as part of regular gameplay, they send RecordDynamic packets that provide the server with the complete details of the records that should be created. When they create enchantments, they also provide the server with armor, book, clothing and weapon records corresponding to the items they've enchanted.
This functionality added by this packet was originally supposed to be exclusive to the rewrite, but I've gone ahead and tried to provide it for the pre-rewrite in a way that can mostly be reused for the rewrite.
2018-07-30 07:56:26 +00:00
|
|
|
|
2019-10-17 03:58:56 +00:00
|
|
|
if (record.baseOverrides.hasWeight)
|
|
|
|
|
finalData.mData.mWeight = recordData.mData.mWeight;
|
|
|
|
|
|
|
|
|
|
if (record.baseOverrides.hasValue)
|
|
|
|
|
finalData.mData.mValue = recordData.mData.mValue;
|
|
|
|
|
|
|
|
|
|
if (record.baseOverrides.hasScrollState)
|
|
|
|
|
finalData.mData.mIsScroll = recordData.mData.mIsScroll;
|
|
|
|
|
|
|
|
|
|
if (record.baseOverrides.hasSkillId)
|
|
|
|
|
finalData.mData.mSkillId = recordData.mData.mSkillId;
|
|
|
|
|
|
|
|
|
|
if (record.baseOverrides.hasEnchantmentId)
|
|
|
|
|
{
|
|
|
|
|
if (recordData.mEnchant.empty() || doesRecordIdExist<ESM::Enchantment>(recordData.mEnchant))
|
|
|
|
|
finalData.mEnchant = recordData.mEnchant;
|
|
|
|
|
else
|
|
|
|
|
LOG_APPEND(TimedLog::LOG_INFO, "-- Ignoring invalid enchantmentId %s", recordData.mEnchant.c_str());
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (record.baseOverrides.hasEnchantmentCharge)
|
|
|
|
|
finalData.mData.mEnchant = recordData.mData.mEnchant;
|
|
|
|
|
|
|
|
|
|
if (record.baseOverrides.hasScript)
|
|
|
|
|
finalData.mScript = recordData.mScript;
|
|
|
|
|
|
|
|
|
|
world->getModifiableStore().overrideRecord(finalData);
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
LOG_APPEND(TimedLog::LOG_INFO, "-- Ignoring record override with invalid baseId %s", record.baseId.c_str());
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (isExistingId)
|
|
|
|
|
world->updatePtrsWithRefId(recordData.mId);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void RecordHelper::overrideRecord(const mwmp::CellRecord& record)
|
|
|
|
|
{
|
|
|
|
|
MWBase::World *world = MWBase::Environment::get().getWorld();
|
|
|
|
|
|
|
|
|
|
ESM::Cell recordData = record.data;
|
|
|
|
|
|
|
|
|
|
if (recordData.mName.empty())
|
|
|
|
|
{
|
|
|
|
|
LOG_APPEND(TimedLog::LOG_INFO, "-- Ignoring record override with no id provided");
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
MWWorld::Ptr playerPtr = world->getPlayerPtr();
|
2020-08-11 10:33:03 +00:00
|
|
|
ESM::Cell playerCell = *playerPtr.getCell()->getCell();
|
|
|
|
|
ESM::Position playerPos = playerPtr.getRefData().getPosition();
|
|
|
|
|
|
|
|
|
|
bool isActiveCell = world->isCellActive(recordData);
|
|
|
|
|
|
|
|
|
|
if (isActiveCell)
|
|
|
|
|
{
|
|
|
|
|
mwmp::Main::get().getCellController()->uninitializeCell(recordData);
|
|
|
|
|
|
|
|
|
|
// Change to temporary holding interior cell
|
|
|
|
|
world->changeToInteriorCell(RecordHelper::getPlaceholderInteriorCellName(), playerPos, true, true);
|
|
|
|
|
}
|
2019-10-17 03:58:56 +00:00
|
|
|
|
|
|
|
|
if (record.baseId.empty())
|
|
|
|
|
{
|
|
|
|
|
recordData.mData.mFlags |= ESM::Cell::Flags::Interior;
|
|
|
|
|
recordData.mCellId.mWorldspace = Misc::StringUtils::lowerCase(recordData.mName);
|
|
|
|
|
|
|
|
|
|
world->unloadCell(recordData);
|
|
|
|
|
world->clearCellStore(recordData);
|
|
|
|
|
world->getModifiableStore().overrideRecord(recordData);
|
|
|
|
|
}
|
|
|
|
|
else if (doesRecordIdExist<ESM::Cell>(record.baseId))
|
|
|
|
|
{
|
|
|
|
|
const ESM::Cell *baseData = world->getStore().get<ESM::Cell>().search(record.baseId);
|
|
|
|
|
ESM::Cell finalData = *baseData;
|
|
|
|
|
finalData.mName = recordData.mName;
|
|
|
|
|
finalData.mCellId.mWorldspace = Misc::StringUtils::lowerCase(recordData.mName);
|
|
|
|
|
|
|
|
|
|
world->unloadCell(finalData);
|
|
|
|
|
world->clearCellStore(finalData);
|
|
|
|
|
world->getModifiableStore().overrideRecord(finalData);
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
LOG_APPEND(TimedLog::LOG_INFO, "-- Ignoring record override with invalid baseId %s", record.baseId.c_str());
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
2020-08-11 10:33:03 +00:00
|
|
|
// Move the player back to the cell they were in
|
|
|
|
|
if (isActiveCell)
|
2019-10-17 03:58:56 +00:00
|
|
|
{
|
2020-08-11 10:33:03 +00:00
|
|
|
if (playerCell.isExterior())
|
|
|
|
|
world->changeToExteriorCell(playerPos, true, true);
|
|
|
|
|
else
|
|
|
|
|
world->changeToInteriorCell(playerCell.mName, playerPos, true, true);
|
2019-01-22 22:48:06 +00:00
|
|
|
}
|
[General] Implement RecordDynamic packet, part 1
Spell, potion, enchantment, creature, NPC, armor, book, clothing, miscellaneous and weapon record data can now be sent in a RecordDynamic packet. Additionally, the packets include data related to associated magical effects (for spells, potions and enchantments), data related to default inventory contents (for creatures and NPCs) and data related to body parts affected (for armor and clothing).
The server now has associated script functions for setting most of the details of the above, with the main exception being individual creature and NPC stats.
Records can either be created entirely from scratch or can use an existing record (set via the baseId variable) as a starting point for their values. In the latter case, only the values that are specifically set override the starting values. Creature and NPC records also have an inventoryBaseId that can be used on top of the baseId to base their inventories on another existing record.
The client's RecordHelper class has been heavily expanded to allow for the above mentioned functionality.
When players create spells, potions and enchantments as part of regular gameplay, they send RecordDynamic packets that provide the server with the complete details of the records that should be created. When they create enchantments, they also provide the server with armor, book, clothing and weapon records corresponding to the items they've enchanted.
This functionality added by this packet was originally supposed to be exclusive to the rewrite, but I've gone ahead and tried to provide it for the pre-rewrite in a way that can mostly be reused for the rewrite.
2018-07-30 07:56:26 +00:00
|
|
|
}
|
|
|
|
|
|
2019-10-17 03:58:56 +00:00
|
|
|
void RecordHelper::overrideRecord(const mwmp::ClothingRecord& record)
|
[General] Implement RecordDynamic packet, part 1
Spell, potion, enchantment, creature, NPC, armor, book, clothing, miscellaneous and weapon record data can now be sent in a RecordDynamic packet. Additionally, the packets include data related to associated magical effects (for spells, potions and enchantments), data related to default inventory contents (for creatures and NPCs) and data related to body parts affected (for armor and clothing).
The server now has associated script functions for setting most of the details of the above, with the main exception being individual creature and NPC stats.
Records can either be created entirely from scratch or can use an existing record (set via the baseId variable) as a starting point for their values. In the latter case, only the values that are specifically set override the starting values. Creature and NPC records also have an inventoryBaseId that can be used on top of the baseId to base their inventories on another existing record.
The client's RecordHelper class has been heavily expanded to allow for the above mentioned functionality.
When players create spells, potions and enchantments as part of regular gameplay, they send RecordDynamic packets that provide the server with the complete details of the records that should be created. When they create enchantments, they also provide the server with armor, book, clothing and weapon records corresponding to the items they've enchanted.
This functionality added by this packet was originally supposed to be exclusive to the rewrite, but I've gone ahead and tried to provide it for the pre-rewrite in a way that can mostly be reused for the rewrite.
2018-07-30 07:56:26 +00:00
|
|
|
{
|
2019-10-17 03:58:56 +00:00
|
|
|
const ESM::Clothing &recordData = record.data;
|
[General] Implement RecordDynamic packet, part 1
Spell, potion, enchantment, creature, NPC, armor, book, clothing, miscellaneous and weapon record data can now be sent in a RecordDynamic packet. Additionally, the packets include data related to associated magical effects (for spells, potions and enchantments), data related to default inventory contents (for creatures and NPCs) and data related to body parts affected (for armor and clothing).
The server now has associated script functions for setting most of the details of the above, with the main exception being individual creature and NPC stats.
Records can either be created entirely from scratch or can use an existing record (set via the baseId variable) as a starting point for their values. In the latter case, only the values that are specifically set override the starting values. Creature and NPC records also have an inventoryBaseId that can be used on top of the baseId to base their inventories on another existing record.
The client's RecordHelper class has been heavily expanded to allow for the above mentioned functionality.
When players create spells, potions and enchantments as part of regular gameplay, they send RecordDynamic packets that provide the server with the complete details of the records that should be created. When they create enchantments, they also provide the server with armor, book, clothing and weapon records corresponding to the items they've enchanted.
This functionality added by this packet was originally supposed to be exclusive to the rewrite, but I've gone ahead and tried to provide it for the pre-rewrite in a way that can mostly be reused for the rewrite.
2018-07-30 07:56:26 +00:00
|
|
|
|
|
|
|
|
if (recordData.mId.empty())
|
|
|
|
|
{
|
2019-08-19 18:39:33 +00:00
|
|
|
LOG_APPEND(TimedLog::LOG_INFO, "-- Ignoring record override with no id provided");
|
[General] Implement RecordDynamic packet, part 1
Spell, potion, enchantment, creature, NPC, armor, book, clothing, miscellaneous and weapon record data can now be sent in a RecordDynamic packet. Additionally, the packets include data related to associated magical effects (for spells, potions and enchantments), data related to default inventory contents (for creatures and NPCs) and data related to body parts affected (for armor and clothing).
The server now has associated script functions for setting most of the details of the above, with the main exception being individual creature and NPC stats.
Records can either be created entirely from scratch or can use an existing record (set via the baseId variable) as a starting point for their values. In the latter case, only the values that are specifically set override the starting values. Creature and NPC records also have an inventoryBaseId that can be used on top of the baseId to base their inventories on another existing record.
The client's RecordHelper class has been heavily expanded to allow for the above mentioned functionality.
When players create spells, potions and enchantments as part of regular gameplay, they send RecordDynamic packets that provide the server with the complete details of the records that should be created. When they create enchantments, they also provide the server with armor, book, clothing and weapon records corresponding to the items they've enchanted.
This functionality added by this packet was originally supposed to be exclusive to the rewrite, but I've gone ahead and tried to provide it for the pre-rewrite in a way that can mostly be reused for the rewrite.
2018-07-30 07:56:26 +00:00
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
2019-10-17 03:58:56 +00:00
|
|
|
bool isExistingId = doesRecordIdExist<ESM::Clothing>(recordData.mId);
|
[General] Implement RecordDynamic packet, part 1
Spell, potion, enchantment, creature, NPC, armor, book, clothing, miscellaneous and weapon record data can now be sent in a RecordDynamic packet. Additionally, the packets include data related to associated magical effects (for spells, potions and enchantments), data related to default inventory contents (for creatures and NPCs) and data related to body parts affected (for armor and clothing).
The server now has associated script functions for setting most of the details of the above, with the main exception being individual creature and NPC stats.
Records can either be created entirely from scratch or can use an existing record (set via the baseId variable) as a starting point for their values. In the latter case, only the values that are specifically set override the starting values. Creature and NPC records also have an inventoryBaseId that can be used on top of the baseId to base their inventories on another existing record.
The client's RecordHelper class has been heavily expanded to allow for the above mentioned functionality.
When players create spells, potions and enchantments as part of regular gameplay, they send RecordDynamic packets that provide the server with the complete details of the records that should be created. When they create enchantments, they also provide the server with armor, book, clothing and weapon records corresponding to the items they've enchanted.
This functionality added by this packet was originally supposed to be exclusive to the rewrite, but I've gone ahead and tried to provide it for the pre-rewrite in a way that can mostly be reused for the rewrite.
2018-07-30 07:56:26 +00:00
|
|
|
MWBase::World *world = MWBase::Environment::get().getWorld();
|
|
|
|
|
|
|
|
|
|
if (record.baseId.empty())
|
|
|
|
|
{
|
2019-10-17 03:58:56 +00:00
|
|
|
if (!recordData.mEnchant.empty() && !doesRecordIdExist<ESM::Enchantment>(recordData.mEnchant))
|
|
|
|
|
{
|
|
|
|
|
LOG_APPEND(TimedLog::LOG_INFO, "-- Ignoring new clothing record with invalid enchantmentId %s", recordData.mEnchant.c_str());
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
world->getModifiableStore().overrideRecord(recordData);
|
[General] Implement RecordDynamic packet, part 1
Spell, potion, enchantment, creature, NPC, armor, book, clothing, miscellaneous and weapon record data can now be sent in a RecordDynamic packet. Additionally, the packets include data related to associated magical effects (for spells, potions and enchantments), data related to default inventory contents (for creatures and NPCs) and data related to body parts affected (for armor and clothing).
The server now has associated script functions for setting most of the details of the above, with the main exception being individual creature and NPC stats.
Records can either be created entirely from scratch or can use an existing record (set via the baseId variable) as a starting point for their values. In the latter case, only the values that are specifically set override the starting values. Creature and NPC records also have an inventoryBaseId that can be used on top of the baseId to base their inventories on another existing record.
The client's RecordHelper class has been heavily expanded to allow for the above mentioned functionality.
When players create spells, potions and enchantments as part of regular gameplay, they send RecordDynamic packets that provide the server with the complete details of the records that should be created. When they create enchantments, they also provide the server with armor, book, clothing and weapon records corresponding to the items they've enchanted.
This functionality added by this packet was originally supposed to be exclusive to the rewrite, but I've gone ahead and tried to provide it for the pre-rewrite in a way that can mostly be reused for the rewrite.
2018-07-30 07:56:26 +00:00
|
|
|
}
|
2019-10-17 03:58:56 +00:00
|
|
|
else if (doesRecordIdExist<ESM::Clothing>(record.baseId))
|
[General] Implement RecordDynamic packet, part 1
Spell, potion, enchantment, creature, NPC, armor, book, clothing, miscellaneous and weapon record data can now be sent in a RecordDynamic packet. Additionally, the packets include data related to associated magical effects (for spells, potions and enchantments), data related to default inventory contents (for creatures and NPCs) and data related to body parts affected (for armor and clothing).
The server now has associated script functions for setting most of the details of the above, with the main exception being individual creature and NPC stats.
Records can either be created entirely from scratch or can use an existing record (set via the baseId variable) as a starting point for their values. In the latter case, only the values that are specifically set override the starting values. Creature and NPC records also have an inventoryBaseId that can be used on top of the baseId to base their inventories on another existing record.
The client's RecordHelper class has been heavily expanded to allow for the above mentioned functionality.
When players create spells, potions and enchantments as part of regular gameplay, they send RecordDynamic packets that provide the server with the complete details of the records that should be created. When they create enchantments, they also provide the server with armor, book, clothing and weapon records corresponding to the items they've enchanted.
This functionality added by this packet was originally supposed to be exclusive to the rewrite, but I've gone ahead and tried to provide it for the pre-rewrite in a way that can mostly be reused for the rewrite.
2018-07-30 07:56:26 +00:00
|
|
|
{
|
2019-10-17 03:58:56 +00:00
|
|
|
const ESM::Clothing *baseData = world->getStore().get<ESM::Clothing>().search(record.baseId);
|
|
|
|
|
ESM::Clothing finalData = *baseData;
|
[General] Implement RecordDynamic packet, part 1
Spell, potion, enchantment, creature, NPC, armor, book, clothing, miscellaneous and weapon record data can now be sent in a RecordDynamic packet. Additionally, the packets include data related to associated magical effects (for spells, potions and enchantments), data related to default inventory contents (for creatures and NPCs) and data related to body parts affected (for armor and clothing).
The server now has associated script functions for setting most of the details of the above, with the main exception being individual creature and NPC stats.
Records can either be created entirely from scratch or can use an existing record (set via the baseId variable) as a starting point for their values. In the latter case, only the values that are specifically set override the starting values. Creature and NPC records also have an inventoryBaseId that can be used on top of the baseId to base their inventories on another existing record.
The client's RecordHelper class has been heavily expanded to allow for the above mentioned functionality.
When players create spells, potions and enchantments as part of regular gameplay, they send RecordDynamic packets that provide the server with the complete details of the records that should be created. When they create enchantments, they also provide the server with armor, book, clothing and weapon records corresponding to the items they've enchanted.
This functionality added by this packet was originally supposed to be exclusive to the rewrite, but I've gone ahead and tried to provide it for the pre-rewrite in a way that can mostly be reused for the rewrite.
2018-07-30 07:56:26 +00:00
|
|
|
finalData.mId = recordData.mId;
|
|
|
|
|
|
|
|
|
|
if (record.baseOverrides.hasName)
|
|
|
|
|
finalData.mName = recordData.mName;
|
|
|
|
|
|
|
|
|
|
if (record.baseOverrides.hasModel)
|
|
|
|
|
finalData.mModel = recordData.mModel;
|
|
|
|
|
|
|
|
|
|
if (record.baseOverrides.hasIcon)
|
|
|
|
|
finalData.mIcon = recordData.mIcon;
|
|
|
|
|
|
2019-10-17 03:58:56 +00:00
|
|
|
if (record.baseOverrides.hasSubtype)
|
|
|
|
|
finalData.mData.mType = recordData.mData.mType;
|
|
|
|
|
|
[General] Implement RecordDynamic packet, part 1
Spell, potion, enchantment, creature, NPC, armor, book, clothing, miscellaneous and weapon record data can now be sent in a RecordDynamic packet. Additionally, the packets include data related to associated magical effects (for spells, potions and enchantments), data related to default inventory contents (for creatures and NPCs) and data related to body parts affected (for armor and clothing).
The server now has associated script functions for setting most of the details of the above, with the main exception being individual creature and NPC stats.
Records can either be created entirely from scratch or can use an existing record (set via the baseId variable) as a starting point for their values. In the latter case, only the values that are specifically set override the starting values. Creature and NPC records also have an inventoryBaseId that can be used on top of the baseId to base their inventories on another existing record.
The client's RecordHelper class has been heavily expanded to allow for the above mentioned functionality.
When players create spells, potions and enchantments as part of regular gameplay, they send RecordDynamic packets that provide the server with the complete details of the records that should be created. When they create enchantments, they also provide the server with armor, book, clothing and weapon records corresponding to the items they've enchanted.
This functionality added by this packet was originally supposed to be exclusive to the rewrite, but I've gone ahead and tried to provide it for the pre-rewrite in a way that can mostly be reused for the rewrite.
2018-07-30 07:56:26 +00:00
|
|
|
if (record.baseOverrides.hasWeight)
|
|
|
|
|
finalData.mData.mWeight = recordData.mData.mWeight;
|
|
|
|
|
|
|
|
|
|
if (record.baseOverrides.hasValue)
|
|
|
|
|
finalData.mData.mValue = recordData.mData.mValue;
|
|
|
|
|
|
2019-10-17 03:58:56 +00:00
|
|
|
if (record.baseOverrides.hasEnchantmentId)
|
|
|
|
|
{
|
|
|
|
|
if (recordData.mEnchant.empty() || doesRecordIdExist<ESM::Enchantment>(recordData.mEnchant))
|
|
|
|
|
finalData.mEnchant = recordData.mEnchant;
|
|
|
|
|
else
|
|
|
|
|
LOG_APPEND(TimedLog::LOG_INFO, "-- Ignoring invalid enchantmentId %s", recordData.mEnchant.c_str());
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (record.baseOverrides.hasEnchantmentCharge)
|
|
|
|
|
finalData.mData.mEnchant = recordData.mData.mEnchant;
|
[General] Implement RecordDynamic packet, part 1
Spell, potion, enchantment, creature, NPC, armor, book, clothing, miscellaneous and weapon record data can now be sent in a RecordDynamic packet. Additionally, the packets include data related to associated magical effects (for spells, potions and enchantments), data related to default inventory contents (for creatures and NPCs) and data related to body parts affected (for armor and clothing).
The server now has associated script functions for setting most of the details of the above, with the main exception being individual creature and NPC stats.
Records can either be created entirely from scratch or can use an existing record (set via the baseId variable) as a starting point for their values. In the latter case, only the values that are specifically set override the starting values. Creature and NPC records also have an inventoryBaseId that can be used on top of the baseId to base their inventories on another existing record.
The client's RecordHelper class has been heavily expanded to allow for the above mentioned functionality.
When players create spells, potions and enchantments as part of regular gameplay, they send RecordDynamic packets that provide the server with the complete details of the records that should be created. When they create enchantments, they also provide the server with armor, book, clothing and weapon records corresponding to the items they've enchanted.
This functionality added by this packet was originally supposed to be exclusive to the rewrite, but I've gone ahead and tried to provide it for the pre-rewrite in a way that can mostly be reused for the rewrite.
2018-07-30 07:56:26 +00:00
|
|
|
|
|
|
|
|
if (record.baseOverrides.hasScript)
|
|
|
|
|
finalData.mScript = recordData.mScript;
|
|
|
|
|
|
2019-10-17 03:58:56 +00:00
|
|
|
if (record.baseOverrides.hasBodyParts)
|
|
|
|
|
finalData.mParts.mParts = recordData.mParts.mParts;
|
[General] Implement RecordDynamic packet, part 1
Spell, potion, enchantment, creature, NPC, armor, book, clothing, miscellaneous and weapon record data can now be sent in a RecordDynamic packet. Additionally, the packets include data related to associated magical effects (for spells, potions and enchantments), data related to default inventory contents (for creatures and NPCs) and data related to body parts affected (for armor and clothing).
The server now has associated script functions for setting most of the details of the above, with the main exception being individual creature and NPC stats.
Records can either be created entirely from scratch or can use an existing record (set via the baseId variable) as a starting point for their values. In the latter case, only the values that are specifically set override the starting values. Creature and NPC records also have an inventoryBaseId that can be used on top of the baseId to base their inventories on another existing record.
The client's RecordHelper class has been heavily expanded to allow for the above mentioned functionality.
When players create spells, potions and enchantments as part of regular gameplay, they send RecordDynamic packets that provide the server with the complete details of the records that should be created. When they create enchantments, they also provide the server with armor, book, clothing and weapon records corresponding to the items they've enchanted.
This functionality added by this packet was originally supposed to be exclusive to the rewrite, but I've gone ahead and tried to provide it for the pre-rewrite in a way that can mostly be reused for the rewrite.
2018-07-30 07:56:26 +00:00
|
|
|
|
|
|
|
|
world->getModifiableStore().overrideRecord(finalData);
|
|
|
|
|
}
|
2019-01-22 22:48:06 +00:00
|
|
|
else
|
|
|
|
|
{
|
2019-08-19 18:39:33 +00:00
|
|
|
LOG_APPEND(TimedLog::LOG_INFO, "-- Ignoring record override with invalid baseId %s", record.baseId.c_str());
|
2019-01-22 22:48:06 +00:00
|
|
|
return;
|
|
|
|
|
}
|
[General] Implement RecordDynamic packet, part 1
Spell, potion, enchantment, creature, NPC, armor, book, clothing, miscellaneous and weapon record data can now be sent in a RecordDynamic packet. Additionally, the packets include data related to associated magical effects (for spells, potions and enchantments), data related to default inventory contents (for creatures and NPCs) and data related to body parts affected (for armor and clothing).
The server now has associated script functions for setting most of the details of the above, with the main exception being individual creature and NPC stats.
Records can either be created entirely from scratch or can use an existing record (set via the baseId variable) as a starting point for their values. In the latter case, only the values that are specifically set override the starting values. Creature and NPC records also have an inventoryBaseId that can be used on top of the baseId to base their inventories on another existing record.
The client's RecordHelper class has been heavily expanded to allow for the above mentioned functionality.
When players create spells, potions and enchantments as part of regular gameplay, they send RecordDynamic packets that provide the server with the complete details of the records that should be created. When they create enchantments, they also provide the server with armor, book, clothing and weapon records corresponding to the items they've enchanted.
This functionality added by this packet was originally supposed to be exclusive to the rewrite, but I've gone ahead and tried to provide it for the pre-rewrite in a way that can mostly be reused for the rewrite.
2018-07-30 07:56:26 +00:00
|
|
|
|
|
|
|
|
if (isExistingId)
|
|
|
|
|
world->updatePtrsWithRefId(recordData.mId);
|
|
|
|
|
}
|
|
|
|
|
|
2019-10-17 03:58:56 +00:00
|
|
|
void RecordHelper::overrideRecord(const mwmp::ContainerRecord& record)
|
[General] Implement RecordDynamic packet, part 1
Spell, potion, enchantment, creature, NPC, armor, book, clothing, miscellaneous and weapon record data can now be sent in a RecordDynamic packet. Additionally, the packets include data related to associated magical effects (for spells, potions and enchantments), data related to default inventory contents (for creatures and NPCs) and data related to body parts affected (for armor and clothing).
The server now has associated script functions for setting most of the details of the above, with the main exception being individual creature and NPC stats.
Records can either be created entirely from scratch or can use an existing record (set via the baseId variable) as a starting point for their values. In the latter case, only the values that are specifically set override the starting values. Creature and NPC records also have an inventoryBaseId that can be used on top of the baseId to base their inventories on another existing record.
The client's RecordHelper class has been heavily expanded to allow for the above mentioned functionality.
When players create spells, potions and enchantments as part of regular gameplay, they send RecordDynamic packets that provide the server with the complete details of the records that should be created. When they create enchantments, they also provide the server with armor, book, clothing and weapon records corresponding to the items they've enchanted.
This functionality added by this packet was originally supposed to be exclusive to the rewrite, but I've gone ahead and tried to provide it for the pre-rewrite in a way that can mostly be reused for the rewrite.
2018-07-30 07:56:26 +00:00
|
|
|
{
|
2019-10-17 03:58:56 +00:00
|
|
|
const ESM::Container &recordData = record.data;
|
[General] Implement RecordDynamic packet, part 1
Spell, potion, enchantment, creature, NPC, armor, book, clothing, miscellaneous and weapon record data can now be sent in a RecordDynamic packet. Additionally, the packets include data related to associated magical effects (for spells, potions and enchantments), data related to default inventory contents (for creatures and NPCs) and data related to body parts affected (for armor and clothing).
The server now has associated script functions for setting most of the details of the above, with the main exception being individual creature and NPC stats.
Records can either be created entirely from scratch or can use an existing record (set via the baseId variable) as a starting point for their values. In the latter case, only the values that are specifically set override the starting values. Creature and NPC records also have an inventoryBaseId that can be used on top of the baseId to base their inventories on another existing record.
The client's RecordHelper class has been heavily expanded to allow for the above mentioned functionality.
When players create spells, potions and enchantments as part of regular gameplay, they send RecordDynamic packets that provide the server with the complete details of the records that should be created. When they create enchantments, they also provide the server with armor, book, clothing and weapon records corresponding to the items they've enchanted.
This functionality added by this packet was originally supposed to be exclusive to the rewrite, but I've gone ahead and tried to provide it for the pre-rewrite in a way that can mostly be reused for the rewrite.
2018-07-30 07:56:26 +00:00
|
|
|
|
|
|
|
|
if (recordData.mId.empty())
|
|
|
|
|
{
|
2019-08-19 18:39:33 +00:00
|
|
|
LOG_APPEND(TimedLog::LOG_INFO, "-- Ignoring record override with no id provided");
|
[General] Implement RecordDynamic packet, part 1
Spell, potion, enchantment, creature, NPC, armor, book, clothing, miscellaneous and weapon record data can now be sent in a RecordDynamic packet. Additionally, the packets include data related to associated magical effects (for spells, potions and enchantments), data related to default inventory contents (for creatures and NPCs) and data related to body parts affected (for armor and clothing).
The server now has associated script functions for setting most of the details of the above, with the main exception being individual creature and NPC stats.
Records can either be created entirely from scratch or can use an existing record (set via the baseId variable) as a starting point for their values. In the latter case, only the values that are specifically set override the starting values. Creature and NPC records also have an inventoryBaseId that can be used on top of the baseId to base their inventories on another existing record.
The client's RecordHelper class has been heavily expanded to allow for the above mentioned functionality.
When players create spells, potions and enchantments as part of regular gameplay, they send RecordDynamic packets that provide the server with the complete details of the records that should be created. When they create enchantments, they also provide the server with armor, book, clothing and weapon records corresponding to the items they've enchanted.
This functionality added by this packet was originally supposed to be exclusive to the rewrite, but I've gone ahead and tried to provide it for the pre-rewrite in a way that can mostly be reused for the rewrite.
2018-07-30 07:56:26 +00:00
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
2019-10-17 03:58:56 +00:00
|
|
|
bool isExistingId = doesRecordIdExist<ESM::Container>(recordData.mId);
|
[General] Implement RecordDynamic packet, part 1
Spell, potion, enchantment, creature, NPC, armor, book, clothing, miscellaneous and weapon record data can now be sent in a RecordDynamic packet. Additionally, the packets include data related to associated magical effects (for spells, potions and enchantments), data related to default inventory contents (for creatures and NPCs) and data related to body parts affected (for armor and clothing).
The server now has associated script functions for setting most of the details of the above, with the main exception being individual creature and NPC stats.
Records can either be created entirely from scratch or can use an existing record (set via the baseId variable) as a starting point for their values. In the latter case, only the values that are specifically set override the starting values. Creature and NPC records also have an inventoryBaseId that can be used on top of the baseId to base their inventories on another existing record.
The client's RecordHelper class has been heavily expanded to allow for the above mentioned functionality.
When players create spells, potions and enchantments as part of regular gameplay, they send RecordDynamic packets that provide the server with the complete details of the records that should be created. When they create enchantments, they also provide the server with armor, book, clothing and weapon records corresponding to the items they've enchanted.
This functionality added by this packet was originally supposed to be exclusive to the rewrite, but I've gone ahead and tried to provide it for the pre-rewrite in a way that can mostly be reused for the rewrite.
2018-07-30 07:56:26 +00:00
|
|
|
MWBase::World *world = MWBase::Environment::get().getWorld();
|
|
|
|
|
|
|
|
|
|
if (record.baseId.empty())
|
|
|
|
|
{
|
|
|
|
|
world->getModifiableStore().overrideRecord(recordData);
|
|
|
|
|
}
|
2019-10-17 03:58:56 +00:00
|
|
|
else if (doesRecordIdExist<ESM::Container>(record.baseId))
|
[General] Implement RecordDynamic packet, part 1
Spell, potion, enchantment, creature, NPC, armor, book, clothing, miscellaneous and weapon record data can now be sent in a RecordDynamic packet. Additionally, the packets include data related to associated magical effects (for spells, potions and enchantments), data related to default inventory contents (for creatures and NPCs) and data related to body parts affected (for armor and clothing).
The server now has associated script functions for setting most of the details of the above, with the main exception being individual creature and NPC stats.
Records can either be created entirely from scratch or can use an existing record (set via the baseId variable) as a starting point for their values. In the latter case, only the values that are specifically set override the starting values. Creature and NPC records also have an inventoryBaseId that can be used on top of the baseId to base their inventories on another existing record.
The client's RecordHelper class has been heavily expanded to allow for the above mentioned functionality.
When players create spells, potions and enchantments as part of regular gameplay, they send RecordDynamic packets that provide the server with the complete details of the records that should be created. When they create enchantments, they also provide the server with armor, book, clothing and weapon records corresponding to the items they've enchanted.
This functionality added by this packet was originally supposed to be exclusive to the rewrite, but I've gone ahead and tried to provide it for the pre-rewrite in a way that can mostly be reused for the rewrite.
2018-07-30 07:56:26 +00:00
|
|
|
{
|
2019-10-17 03:58:56 +00:00
|
|
|
const ESM::Container *baseData = world->getStore().get<ESM::Container>().search(record.baseId);
|
|
|
|
|
ESM::Container finalData = *baseData;
|
[General] Implement RecordDynamic packet, part 1
Spell, potion, enchantment, creature, NPC, armor, book, clothing, miscellaneous and weapon record data can now be sent in a RecordDynamic packet. Additionally, the packets include data related to associated magical effects (for spells, potions and enchantments), data related to default inventory contents (for creatures and NPCs) and data related to body parts affected (for armor and clothing).
The server now has associated script functions for setting most of the details of the above, with the main exception being individual creature and NPC stats.
Records can either be created entirely from scratch or can use an existing record (set via the baseId variable) as a starting point for their values. In the latter case, only the values that are specifically set override the starting values. Creature and NPC records also have an inventoryBaseId that can be used on top of the baseId to base their inventories on another existing record.
The client's RecordHelper class has been heavily expanded to allow for the above mentioned functionality.
When players create spells, potions and enchantments as part of regular gameplay, they send RecordDynamic packets that provide the server with the complete details of the records that should be created. When they create enchantments, they also provide the server with armor, book, clothing and weapon records corresponding to the items they've enchanted.
This functionality added by this packet was originally supposed to be exclusive to the rewrite, but I've gone ahead and tried to provide it for the pre-rewrite in a way that can mostly be reused for the rewrite.
2018-07-30 07:56:26 +00:00
|
|
|
finalData.mId = recordData.mId;
|
|
|
|
|
|
|
|
|
|
if (record.baseOverrides.hasName)
|
|
|
|
|
finalData.mName = recordData.mName;
|
|
|
|
|
|
2019-10-17 03:58:56 +00:00
|
|
|
if (record.baseOverrides.hasModel)
|
|
|
|
|
finalData.mModel = recordData.mModel;
|
[General] Implement RecordDynamic packet, part 1
Spell, potion, enchantment, creature, NPC, armor, book, clothing, miscellaneous and weapon record data can now be sent in a RecordDynamic packet. Additionally, the packets include data related to associated magical effects (for spells, potions and enchantments), data related to default inventory contents (for creatures and NPCs) and data related to body parts affected (for armor and clothing).
The server now has associated script functions for setting most of the details of the above, with the main exception being individual creature and NPC stats.
Records can either be created entirely from scratch or can use an existing record (set via the baseId variable) as a starting point for their values. In the latter case, only the values that are specifically set override the starting values. Creature and NPC records also have an inventoryBaseId that can be used on top of the baseId to base their inventories on another existing record.
The client's RecordHelper class has been heavily expanded to allow for the above mentioned functionality.
When players create spells, potions and enchantments as part of regular gameplay, they send RecordDynamic packets that provide the server with the complete details of the records that should be created. When they create enchantments, they also provide the server with armor, book, clothing and weapon records corresponding to the items they've enchanted.
This functionality added by this packet was originally supposed to be exclusive to the rewrite, but I've gone ahead and tried to provide it for the pre-rewrite in a way that can mostly be reused for the rewrite.
2018-07-30 07:56:26 +00:00
|
|
|
|
2019-10-17 03:58:56 +00:00
|
|
|
if (record.baseOverrides.hasWeight)
|
|
|
|
|
finalData.mWeight = recordData.mWeight;
|
[General] Implement RecordDynamic packet, part 1
Spell, potion, enchantment, creature, NPC, armor, book, clothing, miscellaneous and weapon record data can now be sent in a RecordDynamic packet. Additionally, the packets include data related to associated magical effects (for spells, potions and enchantments), data related to default inventory contents (for creatures and NPCs) and data related to body parts affected (for armor and clothing).
The server now has associated script functions for setting most of the details of the above, with the main exception being individual creature and NPC stats.
Records can either be created entirely from scratch or can use an existing record (set via the baseId variable) as a starting point for their values. In the latter case, only the values that are specifically set override the starting values. Creature and NPC records also have an inventoryBaseId that can be used on top of the baseId to base their inventories on another existing record.
The client's RecordHelper class has been heavily expanded to allow for the above mentioned functionality.
When players create spells, potions and enchantments as part of regular gameplay, they send RecordDynamic packets that provide the server with the complete details of the records that should be created. When they create enchantments, they also provide the server with armor, book, clothing and weapon records corresponding to the items they've enchanted.
This functionality added by this packet was originally supposed to be exclusive to the rewrite, but I've gone ahead and tried to provide it for the pre-rewrite in a way that can mostly be reused for the rewrite.
2018-07-30 07:56:26 +00:00
|
|
|
|
|
|
|
|
if (record.baseOverrides.hasFlags)
|
2019-10-17 03:58:56 +00:00
|
|
|
finalData.mFlags = recordData.mFlags;
|
[General] Implement RecordDynamic packet, part 1
Spell, potion, enchantment, creature, NPC, armor, book, clothing, miscellaneous and weapon record data can now be sent in a RecordDynamic packet. Additionally, the packets include data related to associated magical effects (for spells, potions and enchantments), data related to default inventory contents (for creatures and NPCs) and data related to body parts affected (for armor and clothing).
The server now has associated script functions for setting most of the details of the above, with the main exception being individual creature and NPC stats.
Records can either be created entirely from scratch or can use an existing record (set via the baseId variable) as a starting point for their values. In the latter case, only the values that are specifically set override the starting values. Creature and NPC records also have an inventoryBaseId that can be used on top of the baseId to base their inventories on another existing record.
The client's RecordHelper class has been heavily expanded to allow for the above mentioned functionality.
When players create spells, potions and enchantments as part of regular gameplay, they send RecordDynamic packets that provide the server with the complete details of the records that should be created. When they create enchantments, they also provide the server with armor, book, clothing and weapon records corresponding to the items they've enchanted.
This functionality added by this packet was originally supposed to be exclusive to the rewrite, but I've gone ahead and tried to provide it for the pre-rewrite in a way that can mostly be reused for the rewrite.
2018-07-30 07:56:26 +00:00
|
|
|
|
2019-10-17 03:58:56 +00:00
|
|
|
if (record.baseOverrides.hasScript)
|
|
|
|
|
finalData.mScript = recordData.mScript;
|
|
|
|
|
|
|
|
|
|
if (record.baseOverrides.hasInventory)
|
|
|
|
|
finalData.mInventory.mList = recordData.mInventory.mList;
|
[General] Implement RecordDynamic packet, part 1
Spell, potion, enchantment, creature, NPC, armor, book, clothing, miscellaneous and weapon record data can now be sent in a RecordDynamic packet. Additionally, the packets include data related to associated magical effects (for spells, potions and enchantments), data related to default inventory contents (for creatures and NPCs) and data related to body parts affected (for armor and clothing).
The server now has associated script functions for setting most of the details of the above, with the main exception being individual creature and NPC stats.
Records can either be created entirely from scratch or can use an existing record (set via the baseId variable) as a starting point for their values. In the latter case, only the values that are specifically set override the starting values. Creature and NPC records also have an inventoryBaseId that can be used on top of the baseId to base their inventories on another existing record.
The client's RecordHelper class has been heavily expanded to allow for the above mentioned functionality.
When players create spells, potions and enchantments as part of regular gameplay, they send RecordDynamic packets that provide the server with the complete details of the records that should be created. When they create enchantments, they also provide the server with armor, book, clothing and weapon records corresponding to the items they've enchanted.
This functionality added by this packet was originally supposed to be exclusive to the rewrite, but I've gone ahead and tried to provide it for the pre-rewrite in a way that can mostly be reused for the rewrite.
2018-07-30 07:56:26 +00:00
|
|
|
|
|
|
|
|
world->getModifiableStore().overrideRecord(finalData);
|
|
|
|
|
}
|
2019-01-22 22:48:06 +00:00
|
|
|
else
|
|
|
|
|
{
|
2019-08-19 18:39:33 +00:00
|
|
|
LOG_APPEND(TimedLog::LOG_INFO, "-- Ignoring record override with invalid baseId %s", record.baseId.c_str());
|
2019-01-22 22:48:06 +00:00
|
|
|
return;
|
|
|
|
|
}
|
2019-10-17 03:58:56 +00:00
|
|
|
|
|
|
|
|
if (isExistingId)
|
|
|
|
|
world->updatePtrsWithRefId(recordData.mId);
|
[General] Implement RecordDynamic packet, part 1
Spell, potion, enchantment, creature, NPC, armor, book, clothing, miscellaneous and weapon record data can now be sent in a RecordDynamic packet. Additionally, the packets include data related to associated magical effects (for spells, potions and enchantments), data related to default inventory contents (for creatures and NPCs) and data related to body parts affected (for armor and clothing).
The server now has associated script functions for setting most of the details of the above, with the main exception being individual creature and NPC stats.
Records can either be created entirely from scratch or can use an existing record (set via the baseId variable) as a starting point for their values. In the latter case, only the values that are specifically set override the starting values. Creature and NPC records also have an inventoryBaseId that can be used on top of the baseId to base their inventories on another existing record.
The client's RecordHelper class has been heavily expanded to allow for the above mentioned functionality.
When players create spells, potions and enchantments as part of regular gameplay, they send RecordDynamic packets that provide the server with the complete details of the records that should be created. When they create enchantments, they also provide the server with armor, book, clothing and weapon records corresponding to the items they've enchanted.
This functionality added by this packet was originally supposed to be exclusive to the rewrite, but I've gone ahead and tried to provide it for the pre-rewrite in a way that can mostly be reused for the rewrite.
2018-07-30 07:56:26 +00:00
|
|
|
}
|
|
|
|
|
|
2019-10-17 03:58:56 +00:00
|
|
|
void RecordHelper::overrideRecord(const mwmp::CreatureRecord& record)
|
[General] Implement RecordDynamic packet, part 1
Spell, potion, enchantment, creature, NPC, armor, book, clothing, miscellaneous and weapon record data can now be sent in a RecordDynamic packet. Additionally, the packets include data related to associated magical effects (for spells, potions and enchantments), data related to default inventory contents (for creatures and NPCs) and data related to body parts affected (for armor and clothing).
The server now has associated script functions for setting most of the details of the above, with the main exception being individual creature and NPC stats.
Records can either be created entirely from scratch or can use an existing record (set via the baseId variable) as a starting point for their values. In the latter case, only the values that are specifically set override the starting values. Creature and NPC records also have an inventoryBaseId that can be used on top of the baseId to base their inventories on another existing record.
The client's RecordHelper class has been heavily expanded to allow for the above mentioned functionality.
When players create spells, potions and enchantments as part of regular gameplay, they send RecordDynamic packets that provide the server with the complete details of the records that should be created. When they create enchantments, they also provide the server with armor, book, clothing and weapon records corresponding to the items they've enchanted.
This functionality added by this packet was originally supposed to be exclusive to the rewrite, but I've gone ahead and tried to provide it for the pre-rewrite in a way that can mostly be reused for the rewrite.
2018-07-30 07:56:26 +00:00
|
|
|
{
|
2019-10-17 03:58:56 +00:00
|
|
|
const ESM::Creature &recordData = record.data;
|
[General] Implement RecordDynamic packet, part 1
Spell, potion, enchantment, creature, NPC, armor, book, clothing, miscellaneous and weapon record data can now be sent in a RecordDynamic packet. Additionally, the packets include data related to associated magical effects (for spells, potions and enchantments), data related to default inventory contents (for creatures and NPCs) and data related to body parts affected (for armor and clothing).
The server now has associated script functions for setting most of the details of the above, with the main exception being individual creature and NPC stats.
Records can either be created entirely from scratch or can use an existing record (set via the baseId variable) as a starting point for their values. In the latter case, only the values that are specifically set override the starting values. Creature and NPC records also have an inventoryBaseId that can be used on top of the baseId to base their inventories on another existing record.
The client's RecordHelper class has been heavily expanded to allow for the above mentioned functionality.
When players create spells, potions and enchantments as part of regular gameplay, they send RecordDynamic packets that provide the server with the complete details of the records that should be created. When they create enchantments, they also provide the server with armor, book, clothing and weapon records corresponding to the items they've enchanted.
This functionality added by this packet was originally supposed to be exclusive to the rewrite, but I've gone ahead and tried to provide it for the pre-rewrite in a way that can mostly be reused for the rewrite.
2018-07-30 07:56:26 +00:00
|
|
|
|
|
|
|
|
if (recordData.mId.empty())
|
|
|
|
|
{
|
2019-08-19 18:39:33 +00:00
|
|
|
LOG_APPEND(TimedLog::LOG_INFO, "-- Ignoring record override with no id provided");
|
[General] Implement RecordDynamic packet, part 1
Spell, potion, enchantment, creature, NPC, armor, book, clothing, miscellaneous and weapon record data can now be sent in a RecordDynamic packet. Additionally, the packets include data related to associated magical effects (for spells, potions and enchantments), data related to default inventory contents (for creatures and NPCs) and data related to body parts affected (for armor and clothing).
The server now has associated script functions for setting most of the details of the above, with the main exception being individual creature and NPC stats.
Records can either be created entirely from scratch or can use an existing record (set via the baseId variable) as a starting point for their values. In the latter case, only the values that are specifically set override the starting values. Creature and NPC records also have an inventoryBaseId that can be used on top of the baseId to base their inventories on another existing record.
The client's RecordHelper class has been heavily expanded to allow for the above mentioned functionality.
When players create spells, potions and enchantments as part of regular gameplay, they send RecordDynamic packets that provide the server with the complete details of the records that should be created. When they create enchantments, they also provide the server with armor, book, clothing and weapon records corresponding to the items they've enchanted.
This functionality added by this packet was originally supposed to be exclusive to the rewrite, but I've gone ahead and tried to provide it for the pre-rewrite in a way that can mostly be reused for the rewrite.
2018-07-30 07:56:26 +00:00
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
2019-10-17 03:58:56 +00:00
|
|
|
bool isExistingId = doesRecordIdExist<ESM::Creature>(recordData.mId);
|
[General] Implement RecordDynamic packet, part 1
Spell, potion, enchantment, creature, NPC, armor, book, clothing, miscellaneous and weapon record data can now be sent in a RecordDynamic packet. Additionally, the packets include data related to associated magical effects (for spells, potions and enchantments), data related to default inventory contents (for creatures and NPCs) and data related to body parts affected (for armor and clothing).
The server now has associated script functions for setting most of the details of the above, with the main exception being individual creature and NPC stats.
Records can either be created entirely from scratch or can use an existing record (set via the baseId variable) as a starting point for their values. In the latter case, only the values that are specifically set override the starting values. Creature and NPC records also have an inventoryBaseId that can be used on top of the baseId to base their inventories on another existing record.
The client's RecordHelper class has been heavily expanded to allow for the above mentioned functionality.
When players create spells, potions and enchantments as part of regular gameplay, they send RecordDynamic packets that provide the server with the complete details of the records that should be created. When they create enchantments, they also provide the server with armor, book, clothing and weapon records corresponding to the items they've enchanted.
This functionality added by this packet was originally supposed to be exclusive to the rewrite, but I've gone ahead and tried to provide it for the pre-rewrite in a way that can mostly be reused for the rewrite.
2018-07-30 07:56:26 +00:00
|
|
|
MWBase::World *world = MWBase::Environment::get().getWorld();
|
|
|
|
|
|
|
|
|
|
if (record.baseId.empty())
|
|
|
|
|
{
|
2019-10-17 03:58:56 +00:00
|
|
|
world->getModifiableStore().overrideRecord(recordData);
|
[General] Implement RecordDynamic packet, part 1
Spell, potion, enchantment, creature, NPC, armor, book, clothing, miscellaneous and weapon record data can now be sent in a RecordDynamic packet. Additionally, the packets include data related to associated magical effects (for spells, potions and enchantments), data related to default inventory contents (for creatures and NPCs) and data related to body parts affected (for armor and clothing).
The server now has associated script functions for setting most of the details of the above, with the main exception being individual creature and NPC stats.
Records can either be created entirely from scratch or can use an existing record (set via the baseId variable) as a starting point for their values. In the latter case, only the values that are specifically set override the starting values. Creature and NPC records also have an inventoryBaseId that can be used on top of the baseId to base their inventories on another existing record.
The client's RecordHelper class has been heavily expanded to allow for the above mentioned functionality.
When players create spells, potions and enchantments as part of regular gameplay, they send RecordDynamic packets that provide the server with the complete details of the records that should be created. When they create enchantments, they also provide the server with armor, book, clothing and weapon records corresponding to the items they've enchanted.
This functionality added by this packet was originally supposed to be exclusive to the rewrite, but I've gone ahead and tried to provide it for the pre-rewrite in a way that can mostly be reused for the rewrite.
2018-07-30 07:56:26 +00:00
|
|
|
}
|
2019-10-17 03:58:56 +00:00
|
|
|
else if (doesRecordIdExist<ESM::Creature>(record.baseId))
|
[General] Implement RecordDynamic packet, part 1
Spell, potion, enchantment, creature, NPC, armor, book, clothing, miscellaneous and weapon record data can now be sent in a RecordDynamic packet. Additionally, the packets include data related to associated magical effects (for spells, potions and enchantments), data related to default inventory contents (for creatures and NPCs) and data related to body parts affected (for armor and clothing).
The server now has associated script functions for setting most of the details of the above, with the main exception being individual creature and NPC stats.
Records can either be created entirely from scratch or can use an existing record (set via the baseId variable) as a starting point for their values. In the latter case, only the values that are specifically set override the starting values. Creature and NPC records also have an inventoryBaseId that can be used on top of the baseId to base their inventories on another existing record.
The client's RecordHelper class has been heavily expanded to allow for the above mentioned functionality.
When players create spells, potions and enchantments as part of regular gameplay, they send RecordDynamic packets that provide the server with the complete details of the records that should be created. When they create enchantments, they also provide the server with armor, book, clothing and weapon records corresponding to the items they've enchanted.
This functionality added by this packet was originally supposed to be exclusive to the rewrite, but I've gone ahead and tried to provide it for the pre-rewrite in a way that can mostly be reused for the rewrite.
2018-07-30 07:56:26 +00:00
|
|
|
{
|
2019-10-17 03:58:56 +00:00
|
|
|
const ESM::Creature *baseData = world->getStore().get<ESM::Creature>().search(record.baseId);
|
|
|
|
|
ESM::Creature finalData = *baseData;
|
[General] Implement RecordDynamic packet, part 1
Spell, potion, enchantment, creature, NPC, armor, book, clothing, miscellaneous and weapon record data can now be sent in a RecordDynamic packet. Additionally, the packets include data related to associated magical effects (for spells, potions and enchantments), data related to default inventory contents (for creatures and NPCs) and data related to body parts affected (for armor and clothing).
The server now has associated script functions for setting most of the details of the above, with the main exception being individual creature and NPC stats.
Records can either be created entirely from scratch or can use an existing record (set via the baseId variable) as a starting point for their values. In the latter case, only the values that are specifically set override the starting values. Creature and NPC records also have an inventoryBaseId that can be used on top of the baseId to base their inventories on another existing record.
The client's RecordHelper class has been heavily expanded to allow for the above mentioned functionality.
When players create spells, potions and enchantments as part of regular gameplay, they send RecordDynamic packets that provide the server with the complete details of the records that should be created. When they create enchantments, they also provide the server with armor, book, clothing and weapon records corresponding to the items they've enchanted.
This functionality added by this packet was originally supposed to be exclusive to the rewrite, but I've gone ahead and tried to provide it for the pre-rewrite in a way that can mostly be reused for the rewrite.
2018-07-30 07:56:26 +00:00
|
|
|
finalData.mId = recordData.mId;
|
|
|
|
|
|
|
|
|
|
if (record.baseOverrides.hasName)
|
|
|
|
|
finalData.mName = recordData.mName;
|
|
|
|
|
|
|
|
|
|
if (record.baseOverrides.hasModel)
|
|
|
|
|
finalData.mModel = recordData.mModel;
|
|
|
|
|
|
2019-11-10 07:20:45 +00:00
|
|
|
if (record.baseOverrides.hasScale)
|
|
|
|
|
finalData.mScale = recordData.mScale;
|
|
|
|
|
|
|
|
|
|
if (record.baseOverrides.hasBloodType)
|
|
|
|
|
finalData.mBloodType = recordData.mBloodType;
|
|
|
|
|
|
[General] Implement RecordDynamic packet, part 1
Spell, potion, enchantment, creature, NPC, armor, book, clothing, miscellaneous and weapon record data can now be sent in a RecordDynamic packet. Additionally, the packets include data related to associated magical effects (for spells, potions and enchantments), data related to default inventory contents (for creatures and NPCs) and data related to body parts affected (for armor and clothing).
The server now has associated script functions for setting most of the details of the above, with the main exception being individual creature and NPC stats.
Records can either be created entirely from scratch or can use an existing record (set via the baseId variable) as a starting point for their values. In the latter case, only the values that are specifically set override the starting values. Creature and NPC records also have an inventoryBaseId that can be used on top of the baseId to base their inventories on another existing record.
The client's RecordHelper class has been heavily expanded to allow for the above mentioned functionality.
When players create spells, potions and enchantments as part of regular gameplay, they send RecordDynamic packets that provide the server with the complete details of the records that should be created. When they create enchantments, they also provide the server with armor, book, clothing and weapon records corresponding to the items they've enchanted.
This functionality added by this packet was originally supposed to be exclusive to the rewrite, but I've gone ahead and tried to provide it for the pre-rewrite in a way that can mostly be reused for the rewrite.
2018-07-30 07:56:26 +00:00
|
|
|
if (record.baseOverrides.hasSubtype)
|
|
|
|
|
finalData.mData.mType = recordData.mData.mType;
|
|
|
|
|
|
2019-10-17 03:58:56 +00:00
|
|
|
if (record.baseOverrides.hasLevel)
|
|
|
|
|
finalData.mData.mLevel = recordData.mData.mLevel;
|
[General] Implement RecordDynamic packet, part 1
Spell, potion, enchantment, creature, NPC, armor, book, clothing, miscellaneous and weapon record data can now be sent in a RecordDynamic packet. Additionally, the packets include data related to associated magical effects (for spells, potions and enchantments), data related to default inventory contents (for creatures and NPCs) and data related to body parts affected (for armor and clothing).
The server now has associated script functions for setting most of the details of the above, with the main exception being individual creature and NPC stats.
Records can either be created entirely from scratch or can use an existing record (set via the baseId variable) as a starting point for their values. In the latter case, only the values that are specifically set override the starting values. Creature and NPC records also have an inventoryBaseId that can be used on top of the baseId to base their inventories on another existing record.
The client's RecordHelper class has been heavily expanded to allow for the above mentioned functionality.
When players create spells, potions and enchantments as part of regular gameplay, they send RecordDynamic packets that provide the server with the complete details of the records that should be created. When they create enchantments, they also provide the server with armor, book, clothing and weapon records corresponding to the items they've enchanted.
This functionality added by this packet was originally supposed to be exclusive to the rewrite, but I've gone ahead and tried to provide it for the pre-rewrite in a way that can mostly be reused for the rewrite.
2018-07-30 07:56:26 +00:00
|
|
|
|
|
|
|
|
if (record.baseOverrides.hasHealth)
|
|
|
|
|
finalData.mData.mHealth = recordData.mData.mHealth;
|
|
|
|
|
|
2019-10-17 03:58:56 +00:00
|
|
|
if (record.baseOverrides.hasMagicka)
|
|
|
|
|
finalData.mData.mMana = recordData.mData.mMana;
|
[General] Implement RecordDynamic packet, part 1
Spell, potion, enchantment, creature, NPC, armor, book, clothing, miscellaneous and weapon record data can now be sent in a RecordDynamic packet. Additionally, the packets include data related to associated magical effects (for spells, potions and enchantments), data related to default inventory contents (for creatures and NPCs) and data related to body parts affected (for armor and clothing).
The server now has associated script functions for setting most of the details of the above, with the main exception being individual creature and NPC stats.
Records can either be created entirely from scratch or can use an existing record (set via the baseId variable) as a starting point for their values. In the latter case, only the values that are specifically set override the starting values. Creature and NPC records also have an inventoryBaseId that can be used on top of the baseId to base their inventories on another existing record.
The client's RecordHelper class has been heavily expanded to allow for the above mentioned functionality.
When players create spells, potions and enchantments as part of regular gameplay, they send RecordDynamic packets that provide the server with the complete details of the records that should be created. When they create enchantments, they also provide the server with armor, book, clothing and weapon records corresponding to the items they've enchanted.
This functionality added by this packet was originally supposed to be exclusive to the rewrite, but I've gone ahead and tried to provide it for the pre-rewrite in a way that can mostly be reused for the rewrite.
2018-07-30 07:56:26 +00:00
|
|
|
|
2019-10-17 03:58:56 +00:00
|
|
|
if (record.baseOverrides.hasFatigue)
|
|
|
|
|
finalData.mData.mFatigue = recordData.mData.mFatigue;
|
[General] Implement RecordDynamic packet, part 1
Spell, potion, enchantment, creature, NPC, armor, book, clothing, miscellaneous and weapon record data can now be sent in a RecordDynamic packet. Additionally, the packets include data related to associated magical effects (for spells, potions and enchantments), data related to default inventory contents (for creatures and NPCs) and data related to body parts affected (for armor and clothing).
The server now has associated script functions for setting most of the details of the above, with the main exception being individual creature and NPC stats.
Records can either be created entirely from scratch or can use an existing record (set via the baseId variable) as a starting point for their values. In the latter case, only the values that are specifically set override the starting values. Creature and NPC records also have an inventoryBaseId that can be used on top of the baseId to base their inventories on another existing record.
The client's RecordHelper class has been heavily expanded to allow for the above mentioned functionality.
When players create spells, potions and enchantments as part of regular gameplay, they send RecordDynamic packets that provide the server with the complete details of the records that should be created. When they create enchantments, they also provide the server with armor, book, clothing and weapon records corresponding to the items they've enchanted.
This functionality added by this packet was originally supposed to be exclusive to the rewrite, but I've gone ahead and tried to provide it for the pre-rewrite in a way that can mostly be reused for the rewrite.
2018-07-30 07:56:26 +00:00
|
|
|
|
2021-05-25 11:55:12 +00:00
|
|
|
if (record.baseOverrides.hasSoulValue)
|
|
|
|
|
finalData.mData.mSoul = recordData.mData.mSoul;
|
|
|
|
|
|
2021-05-28 17:35:05 +00:00
|
|
|
if (record.baseOverrides.hasDamageChop)
|
|
|
|
|
{
|
|
|
|
|
finalData.mData.mAttack[0] = recordData.mData.mAttack[0];
|
|
|
|
|
finalData.mData.mAttack[1] = recordData.mData.mAttack[1];
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (record.baseOverrides.hasDamageSlash)
|
|
|
|
|
{
|
|
|
|
|
finalData.mData.mAttack[2] = recordData.mData.mAttack[2];
|
|
|
|
|
finalData.mData.mAttack[3] = recordData.mData.mAttack[3];
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (record.baseOverrides.hasDamageThrust)
|
|
|
|
|
{
|
|
|
|
|
finalData.mData.mAttack[4] = recordData.mData.mAttack[4];
|
|
|
|
|
finalData.mData.mAttack[5] = recordData.mData.mAttack[5];
|
|
|
|
|
}
|
|
|
|
|
|
2019-10-17 03:58:56 +00:00
|
|
|
if (record.baseOverrides.hasAiFight)
|
|
|
|
|
finalData.mAiData.mFight = recordData.mAiData.mFight;
|
|
|
|
|
|
|
|
|
|
if (record.baseOverrides.hasAiFlee)
|
|
|
|
|
finalData.mAiData.mFlee = recordData.mAiData.mFlee;
|
|
|
|
|
|
|
|
|
|
if (record.baseOverrides.hasAiAlarm)
|
|
|
|
|
finalData.mAiData.mAlarm = recordData.mAiData.mAlarm;
|
|
|
|
|
|
|
|
|
|
if (record.baseOverrides.hasAiServices)
|
|
|
|
|
finalData.mAiData.mServices = recordData.mAiData.mServices;
|
|
|
|
|
|
|
|
|
|
if (record.baseOverrides.hasFlags)
|
|
|
|
|
finalData.mFlags = recordData.mFlags;
|
[General] Implement RecordDynamic packet, part 1
Spell, potion, enchantment, creature, NPC, armor, book, clothing, miscellaneous and weapon record data can now be sent in a RecordDynamic packet. Additionally, the packets include data related to associated magical effects (for spells, potions and enchantments), data related to default inventory contents (for creatures and NPCs) and data related to body parts affected (for armor and clothing).
The server now has associated script functions for setting most of the details of the above, with the main exception being individual creature and NPC stats.
Records can either be created entirely from scratch or can use an existing record (set via the baseId variable) as a starting point for their values. In the latter case, only the values that are specifically set override the starting values. Creature and NPC records also have an inventoryBaseId that can be used on top of the baseId to base their inventories on another existing record.
The client's RecordHelper class has been heavily expanded to allow for the above mentioned functionality.
When players create spells, potions and enchantments as part of regular gameplay, they send RecordDynamic packets that provide the server with the complete details of the records that should be created. When they create enchantments, they also provide the server with armor, book, clothing and weapon records corresponding to the items they've enchanted.
This functionality added by this packet was originally supposed to be exclusive to the rewrite, but I've gone ahead and tried to provide it for the pre-rewrite in a way that can mostly be reused for the rewrite.
2018-07-30 07:56:26 +00:00
|
|
|
|
|
|
|
|
if (record.baseOverrides.hasScript)
|
|
|
|
|
finalData.mScript = recordData.mScript;
|
|
|
|
|
|
2019-10-17 03:58:56 +00:00
|
|
|
if (!record.inventoryBaseId.empty() && doesRecordIdExist<ESM::Creature>(record.inventoryBaseId))
|
|
|
|
|
finalData.mInventory.mList = world->getStore().get<ESM::Creature>().search(record.inventoryBaseId)->mInventory.mList;
|
|
|
|
|
else if (record.baseOverrides.hasInventory)
|
|
|
|
|
finalData.mInventory.mList = recordData.mInventory.mList;
|
[General] Implement RecordDynamic packet, part 1
Spell, potion, enchantment, creature, NPC, armor, book, clothing, miscellaneous and weapon record data can now be sent in a RecordDynamic packet. Additionally, the packets include data related to associated magical effects (for spells, potions and enchantments), data related to default inventory contents (for creatures and NPCs) and data related to body parts affected (for armor and clothing).
The server now has associated script functions for setting most of the details of the above, with the main exception being individual creature and NPC stats.
Records can either be created entirely from scratch or can use an existing record (set via the baseId variable) as a starting point for their values. In the latter case, only the values that are specifically set override the starting values. Creature and NPC records also have an inventoryBaseId that can be used on top of the baseId to base their inventories on another existing record.
The client's RecordHelper class has been heavily expanded to allow for the above mentioned functionality.
When players create spells, potions and enchantments as part of regular gameplay, they send RecordDynamic packets that provide the server with the complete details of the records that should be created. When they create enchantments, they also provide the server with armor, book, clothing and weapon records corresponding to the items they've enchanted.
This functionality added by this packet was originally supposed to be exclusive to the rewrite, but I've gone ahead and tried to provide it for the pre-rewrite in a way that can mostly be reused for the rewrite.
2018-07-30 07:56:26 +00:00
|
|
|
|
|
|
|
|
world->getModifiableStore().overrideRecord(finalData);
|
|
|
|
|
}
|
2019-01-22 22:48:06 +00:00
|
|
|
else
|
|
|
|
|
{
|
2019-08-19 18:39:33 +00:00
|
|
|
LOG_APPEND(TimedLog::LOG_INFO, "-- Ignoring record override with invalid baseId %s", record.baseId.c_str());
|
2019-01-22 22:48:06 +00:00
|
|
|
return;
|
|
|
|
|
}
|
[General] Implement RecordDynamic packet, part 1
Spell, potion, enchantment, creature, NPC, armor, book, clothing, miscellaneous and weapon record data can now be sent in a RecordDynamic packet. Additionally, the packets include data related to associated magical effects (for spells, potions and enchantments), data related to default inventory contents (for creatures and NPCs) and data related to body parts affected (for armor and clothing).
The server now has associated script functions for setting most of the details of the above, with the main exception being individual creature and NPC stats.
Records can either be created entirely from scratch or can use an existing record (set via the baseId variable) as a starting point for their values. In the latter case, only the values that are specifically set override the starting values. Creature and NPC records also have an inventoryBaseId that can be used on top of the baseId to base their inventories on another existing record.
The client's RecordHelper class has been heavily expanded to allow for the above mentioned functionality.
When players create spells, potions and enchantments as part of regular gameplay, they send RecordDynamic packets that provide the server with the complete details of the records that should be created. When they create enchantments, they also provide the server with armor, book, clothing and weapon records corresponding to the items they've enchanted.
This functionality added by this packet was originally supposed to be exclusive to the rewrite, but I've gone ahead and tried to provide it for the pre-rewrite in a way that can mostly be reused for the rewrite.
2018-07-30 07:56:26 +00:00
|
|
|
|
|
|
|
|
if (isExistingId)
|
|
|
|
|
world->updatePtrsWithRefId(recordData.mId);
|
|
|
|
|
}
|
|
|
|
|
|
2019-10-17 03:58:56 +00:00
|
|
|
void RecordHelper::overrideRecord(const mwmp::DoorRecord& record)
|
[General] Implement RecordDynamic packet, part 1
Spell, potion, enchantment, creature, NPC, armor, book, clothing, miscellaneous and weapon record data can now be sent in a RecordDynamic packet. Additionally, the packets include data related to associated magical effects (for spells, potions and enchantments), data related to default inventory contents (for creatures and NPCs) and data related to body parts affected (for armor and clothing).
The server now has associated script functions for setting most of the details of the above, with the main exception being individual creature and NPC stats.
Records can either be created entirely from scratch or can use an existing record (set via the baseId variable) as a starting point for their values. In the latter case, only the values that are specifically set override the starting values. Creature and NPC records also have an inventoryBaseId that can be used on top of the baseId to base their inventories on another existing record.
The client's RecordHelper class has been heavily expanded to allow for the above mentioned functionality.
When players create spells, potions and enchantments as part of regular gameplay, they send RecordDynamic packets that provide the server with the complete details of the records that should be created. When they create enchantments, they also provide the server with armor, book, clothing and weapon records corresponding to the items they've enchanted.
This functionality added by this packet was originally supposed to be exclusive to the rewrite, but I've gone ahead and tried to provide it for the pre-rewrite in a way that can mostly be reused for the rewrite.
2018-07-30 07:56:26 +00:00
|
|
|
{
|
2019-10-17 03:58:56 +00:00
|
|
|
const ESM::Door &recordData = record.data;
|
[General] Implement RecordDynamic packet, part 1
Spell, potion, enchantment, creature, NPC, armor, book, clothing, miscellaneous and weapon record data can now be sent in a RecordDynamic packet. Additionally, the packets include data related to associated magical effects (for spells, potions and enchantments), data related to default inventory contents (for creatures and NPCs) and data related to body parts affected (for armor and clothing).
The server now has associated script functions for setting most of the details of the above, with the main exception being individual creature and NPC stats.
Records can either be created entirely from scratch or can use an existing record (set via the baseId variable) as a starting point for their values. In the latter case, only the values that are specifically set override the starting values. Creature and NPC records also have an inventoryBaseId that can be used on top of the baseId to base their inventories on another existing record.
The client's RecordHelper class has been heavily expanded to allow for the above mentioned functionality.
When players create spells, potions and enchantments as part of regular gameplay, they send RecordDynamic packets that provide the server with the complete details of the records that should be created. When they create enchantments, they also provide the server with armor, book, clothing and weapon records corresponding to the items they've enchanted.
This functionality added by this packet was originally supposed to be exclusive to the rewrite, but I've gone ahead and tried to provide it for the pre-rewrite in a way that can mostly be reused for the rewrite.
2018-07-30 07:56:26 +00:00
|
|
|
|
|
|
|
|
if (recordData.mId.empty())
|
|
|
|
|
{
|
2019-08-19 18:39:33 +00:00
|
|
|
LOG_APPEND(TimedLog::LOG_INFO, "-- Ignoring record override with no id provided");
|
[General] Implement RecordDynamic packet, part 1
Spell, potion, enchantment, creature, NPC, armor, book, clothing, miscellaneous and weapon record data can now be sent in a RecordDynamic packet. Additionally, the packets include data related to associated magical effects (for spells, potions and enchantments), data related to default inventory contents (for creatures and NPCs) and data related to body parts affected (for armor and clothing).
The server now has associated script functions for setting most of the details of the above, with the main exception being individual creature and NPC stats.
Records can either be created entirely from scratch or can use an existing record (set via the baseId variable) as a starting point for their values. In the latter case, only the values that are specifically set override the starting values. Creature and NPC records also have an inventoryBaseId that can be used on top of the baseId to base their inventories on another existing record.
The client's RecordHelper class has been heavily expanded to allow for the above mentioned functionality.
When players create spells, potions and enchantments as part of regular gameplay, they send RecordDynamic packets that provide the server with the complete details of the records that should be created. When they create enchantments, they also provide the server with armor, book, clothing and weapon records corresponding to the items they've enchanted.
This functionality added by this packet was originally supposed to be exclusive to the rewrite, but I've gone ahead and tried to provide it for the pre-rewrite in a way that can mostly be reused for the rewrite.
2018-07-30 07:56:26 +00:00
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
2019-10-17 03:58:56 +00:00
|
|
|
bool isExistingId = doesRecordIdExist<ESM::Door>(recordData.mId);
|
[General] Implement RecordDynamic packet, part 1
Spell, potion, enchantment, creature, NPC, armor, book, clothing, miscellaneous and weapon record data can now be sent in a RecordDynamic packet. Additionally, the packets include data related to associated magical effects (for spells, potions and enchantments), data related to default inventory contents (for creatures and NPCs) and data related to body parts affected (for armor and clothing).
The server now has associated script functions for setting most of the details of the above, with the main exception being individual creature and NPC stats.
Records can either be created entirely from scratch or can use an existing record (set via the baseId variable) as a starting point for their values. In the latter case, only the values that are specifically set override the starting values. Creature and NPC records also have an inventoryBaseId that can be used on top of the baseId to base their inventories on another existing record.
The client's RecordHelper class has been heavily expanded to allow for the above mentioned functionality.
When players create spells, potions and enchantments as part of regular gameplay, they send RecordDynamic packets that provide the server with the complete details of the records that should be created. When they create enchantments, they also provide the server with armor, book, clothing and weapon records corresponding to the items they've enchanted.
This functionality added by this packet was originally supposed to be exclusive to the rewrite, but I've gone ahead and tried to provide it for the pre-rewrite in a way that can mostly be reused for the rewrite.
2018-07-30 07:56:26 +00:00
|
|
|
MWBase::World *world = MWBase::Environment::get().getWorld();
|
|
|
|
|
|
|
|
|
|
if (record.baseId.empty())
|
|
|
|
|
{
|
2019-10-17 03:58:56 +00:00
|
|
|
world->getModifiableStore().overrideRecord(recordData);
|
[General] Implement RecordDynamic packet, part 1
Spell, potion, enchantment, creature, NPC, armor, book, clothing, miscellaneous and weapon record data can now be sent in a RecordDynamic packet. Additionally, the packets include data related to associated magical effects (for spells, potions and enchantments), data related to default inventory contents (for creatures and NPCs) and data related to body parts affected (for armor and clothing).
The server now has associated script functions for setting most of the details of the above, with the main exception being individual creature and NPC stats.
Records can either be created entirely from scratch or can use an existing record (set via the baseId variable) as a starting point for their values. In the latter case, only the values that are specifically set override the starting values. Creature and NPC records also have an inventoryBaseId that can be used on top of the baseId to base their inventories on another existing record.
The client's RecordHelper class has been heavily expanded to allow for the above mentioned functionality.
When players create spells, potions and enchantments as part of regular gameplay, they send RecordDynamic packets that provide the server with the complete details of the records that should be created. When they create enchantments, they also provide the server with armor, book, clothing and weapon records corresponding to the items they've enchanted.
This functionality added by this packet was originally supposed to be exclusive to the rewrite, but I've gone ahead and tried to provide it for the pre-rewrite in a way that can mostly be reused for the rewrite.
2018-07-30 07:56:26 +00:00
|
|
|
}
|
2019-10-17 03:58:56 +00:00
|
|
|
else if (doesRecordIdExist<ESM::Door>(record.baseId))
|
[General] Implement RecordDynamic packet, part 1
Spell, potion, enchantment, creature, NPC, armor, book, clothing, miscellaneous and weapon record data can now be sent in a RecordDynamic packet. Additionally, the packets include data related to associated magical effects (for spells, potions and enchantments), data related to default inventory contents (for creatures and NPCs) and data related to body parts affected (for armor and clothing).
The server now has associated script functions for setting most of the details of the above, with the main exception being individual creature and NPC stats.
Records can either be created entirely from scratch or can use an existing record (set via the baseId variable) as a starting point for their values. In the latter case, only the values that are specifically set override the starting values. Creature and NPC records also have an inventoryBaseId that can be used on top of the baseId to base their inventories on another existing record.
The client's RecordHelper class has been heavily expanded to allow for the above mentioned functionality.
When players create spells, potions and enchantments as part of regular gameplay, they send RecordDynamic packets that provide the server with the complete details of the records that should be created. When they create enchantments, they also provide the server with armor, book, clothing and weapon records corresponding to the items they've enchanted.
This functionality added by this packet was originally supposed to be exclusive to the rewrite, but I've gone ahead and tried to provide it for the pre-rewrite in a way that can mostly be reused for the rewrite.
2018-07-30 07:56:26 +00:00
|
|
|
{
|
2019-10-17 03:58:56 +00:00
|
|
|
const ESM::Door *baseData = world->getStore().get<ESM::Door>().search(record.baseId);
|
|
|
|
|
ESM::Door finalData = *baseData;
|
[General] Implement RecordDynamic packet, part 1
Spell, potion, enchantment, creature, NPC, armor, book, clothing, miscellaneous and weapon record data can now be sent in a RecordDynamic packet. Additionally, the packets include data related to associated magical effects (for spells, potions and enchantments), data related to default inventory contents (for creatures and NPCs) and data related to body parts affected (for armor and clothing).
The server now has associated script functions for setting most of the details of the above, with the main exception being individual creature and NPC stats.
Records can either be created entirely from scratch or can use an existing record (set via the baseId variable) as a starting point for their values. In the latter case, only the values that are specifically set override the starting values. Creature and NPC records also have an inventoryBaseId that can be used on top of the baseId to base their inventories on another existing record.
The client's RecordHelper class has been heavily expanded to allow for the above mentioned functionality.
When players create spells, potions and enchantments as part of regular gameplay, they send RecordDynamic packets that provide the server with the complete details of the records that should be created. When they create enchantments, they also provide the server with armor, book, clothing and weapon records corresponding to the items they've enchanted.
This functionality added by this packet was originally supposed to be exclusive to the rewrite, but I've gone ahead and tried to provide it for the pre-rewrite in a way that can mostly be reused for the rewrite.
2018-07-30 07:56:26 +00:00
|
|
|
finalData.mId = recordData.mId;
|
|
|
|
|
|
|
|
|
|
if (record.baseOverrides.hasName)
|
|
|
|
|
finalData.mName = recordData.mName;
|
|
|
|
|
|
|
|
|
|
if (record.baseOverrides.hasModel)
|
|
|
|
|
finalData.mModel = recordData.mModel;
|
|
|
|
|
|
2019-10-17 03:58:56 +00:00
|
|
|
if (record.baseOverrides.hasOpenSound)
|
|
|
|
|
finalData.mOpenSound = recordData.mOpenSound;
|
[General] Implement RecordDynamic packet, part 1
Spell, potion, enchantment, creature, NPC, armor, book, clothing, miscellaneous and weapon record data can now be sent in a RecordDynamic packet. Additionally, the packets include data related to associated magical effects (for spells, potions and enchantments), data related to default inventory contents (for creatures and NPCs) and data related to body parts affected (for armor and clothing).
The server now has associated script functions for setting most of the details of the above, with the main exception being individual creature and NPC stats.
Records can either be created entirely from scratch or can use an existing record (set via the baseId variable) as a starting point for their values. In the latter case, only the values that are specifically set override the starting values. Creature and NPC records also have an inventoryBaseId that can be used on top of the baseId to base their inventories on another existing record.
The client's RecordHelper class has been heavily expanded to allow for the above mentioned functionality.
When players create spells, potions and enchantments as part of regular gameplay, they send RecordDynamic packets that provide the server with the complete details of the records that should be created. When they create enchantments, they also provide the server with armor, book, clothing and weapon records corresponding to the items they've enchanted.
This functionality added by this packet was originally supposed to be exclusive to the rewrite, but I've gone ahead and tried to provide it for the pre-rewrite in a way that can mostly be reused for the rewrite.
2018-07-30 07:56:26 +00:00
|
|
|
|
2019-10-17 03:58:56 +00:00
|
|
|
if (record.baseOverrides.hasCloseSound)
|
|
|
|
|
finalData.mCloseSound = recordData.mCloseSound;
|
[General] Implement RecordDynamic packet, part 1
Spell, potion, enchantment, creature, NPC, armor, book, clothing, miscellaneous and weapon record data can now be sent in a RecordDynamic packet. Additionally, the packets include data related to associated magical effects (for spells, potions and enchantments), data related to default inventory contents (for creatures and NPCs) and data related to body parts affected (for armor and clothing).
The server now has associated script functions for setting most of the details of the above, with the main exception being individual creature and NPC stats.
Records can either be created entirely from scratch or can use an existing record (set via the baseId variable) as a starting point for their values. In the latter case, only the values that are specifically set override the starting values. Creature and NPC records also have an inventoryBaseId that can be used on top of the baseId to base their inventories on another existing record.
The client's RecordHelper class has been heavily expanded to allow for the above mentioned functionality.
When players create spells, potions and enchantments as part of regular gameplay, they send RecordDynamic packets that provide the server with the complete details of the records that should be created. When they create enchantments, they also provide the server with armor, book, clothing and weapon records corresponding to the items they've enchanted.
This functionality added by this packet was originally supposed to be exclusive to the rewrite, but I've gone ahead and tried to provide it for the pre-rewrite in a way that can mostly be reused for the rewrite.
2018-07-30 07:56:26 +00:00
|
|
|
|
|
|
|
|
if (record.baseOverrides.hasScript)
|
|
|
|
|
finalData.mScript = recordData.mScript;
|
|
|
|
|
|
|
|
|
|
world->getModifiableStore().overrideRecord(finalData);
|
|
|
|
|
}
|
2019-01-22 22:48:06 +00:00
|
|
|
else
|
|
|
|
|
{
|
2019-08-19 18:39:33 +00:00
|
|
|
LOG_APPEND(TimedLog::LOG_INFO, "-- Ignoring record override with invalid baseId %s", record.baseId.c_str());
|
2019-01-22 22:48:06 +00:00
|
|
|
return;
|
|
|
|
|
}
|
[General] Implement RecordDynamic packet, part 1
Spell, potion, enchantment, creature, NPC, armor, book, clothing, miscellaneous and weapon record data can now be sent in a RecordDynamic packet. Additionally, the packets include data related to associated magical effects (for spells, potions and enchantments), data related to default inventory contents (for creatures and NPCs) and data related to body parts affected (for armor and clothing).
The server now has associated script functions for setting most of the details of the above, with the main exception being individual creature and NPC stats.
Records can either be created entirely from scratch or can use an existing record (set via the baseId variable) as a starting point for their values. In the latter case, only the values that are specifically set override the starting values. Creature and NPC records also have an inventoryBaseId that can be used on top of the baseId to base their inventories on another existing record.
The client's RecordHelper class has been heavily expanded to allow for the above mentioned functionality.
When players create spells, potions and enchantments as part of regular gameplay, they send RecordDynamic packets that provide the server with the complete details of the records that should be created. When they create enchantments, they also provide the server with armor, book, clothing and weapon records corresponding to the items they've enchanted.
This functionality added by this packet was originally supposed to be exclusive to the rewrite, but I've gone ahead and tried to provide it for the pre-rewrite in a way that can mostly be reused for the rewrite.
2018-07-30 07:56:26 +00:00
|
|
|
|
|
|
|
|
if (isExistingId)
|
|
|
|
|
world->updatePtrsWithRefId(recordData.mId);
|
|
|
|
|
}
|
|
|
|
|
|
2019-10-17 03:58:56 +00:00
|
|
|
void RecordHelper::overrideRecord(const mwmp::EnchantmentRecord& record)
|
[General] Implement RecordDynamic packet, part 1
Spell, potion, enchantment, creature, NPC, armor, book, clothing, miscellaneous and weapon record data can now be sent in a RecordDynamic packet. Additionally, the packets include data related to associated magical effects (for spells, potions and enchantments), data related to default inventory contents (for creatures and NPCs) and data related to body parts affected (for armor and clothing).
The server now has associated script functions for setting most of the details of the above, with the main exception being individual creature and NPC stats.
Records can either be created entirely from scratch or can use an existing record (set via the baseId variable) as a starting point for their values. In the latter case, only the values that are specifically set override the starting values. Creature and NPC records also have an inventoryBaseId that can be used on top of the baseId to base their inventories on another existing record.
The client's RecordHelper class has been heavily expanded to allow for the above mentioned functionality.
When players create spells, potions and enchantments as part of regular gameplay, they send RecordDynamic packets that provide the server with the complete details of the records that should be created. When they create enchantments, they also provide the server with armor, book, clothing and weapon records corresponding to the items they've enchanted.
This functionality added by this packet was originally supposed to be exclusive to the rewrite, but I've gone ahead and tried to provide it for the pre-rewrite in a way that can mostly be reused for the rewrite.
2018-07-30 07:56:26 +00:00
|
|
|
{
|
2019-10-17 03:58:56 +00:00
|
|
|
const ESM::Enchantment &recordData = record.data;
|
[General] Implement RecordDynamic packet, part 1
Spell, potion, enchantment, creature, NPC, armor, book, clothing, miscellaneous and weapon record data can now be sent in a RecordDynamic packet. Additionally, the packets include data related to associated magical effects (for spells, potions and enchantments), data related to default inventory contents (for creatures and NPCs) and data related to body parts affected (for armor and clothing).
The server now has associated script functions for setting most of the details of the above, with the main exception being individual creature and NPC stats.
Records can either be created entirely from scratch or can use an existing record (set via the baseId variable) as a starting point for their values. In the latter case, only the values that are specifically set override the starting values. Creature and NPC records also have an inventoryBaseId that can be used on top of the baseId to base their inventories on another existing record.
The client's RecordHelper class has been heavily expanded to allow for the above mentioned functionality.
When players create spells, potions and enchantments as part of regular gameplay, they send RecordDynamic packets that provide the server with the complete details of the records that should be created. When they create enchantments, they also provide the server with armor, book, clothing and weapon records corresponding to the items they've enchanted.
This functionality added by this packet was originally supposed to be exclusive to the rewrite, but I've gone ahead and tried to provide it for the pre-rewrite in a way that can mostly be reused for the rewrite.
2018-07-30 07:56:26 +00:00
|
|
|
|
|
|
|
|
if (recordData.mId.empty())
|
|
|
|
|
{
|
2019-08-19 18:39:33 +00:00
|
|
|
LOG_APPEND(TimedLog::LOG_INFO, "-- Ignoring record override with no id provided");
|
[General] Implement RecordDynamic packet, part 1
Spell, potion, enchantment, creature, NPC, armor, book, clothing, miscellaneous and weapon record data can now be sent in a RecordDynamic packet. Additionally, the packets include data related to associated magical effects (for spells, potions and enchantments), data related to default inventory contents (for creatures and NPCs) and data related to body parts affected (for armor and clothing).
The server now has associated script functions for setting most of the details of the above, with the main exception being individual creature and NPC stats.
Records can either be created entirely from scratch or can use an existing record (set via the baseId variable) as a starting point for their values. In the latter case, only the values that are specifically set override the starting values. Creature and NPC records also have an inventoryBaseId that can be used on top of the baseId to base their inventories on another existing record.
The client's RecordHelper class has been heavily expanded to allow for the above mentioned functionality.
When players create spells, potions and enchantments as part of regular gameplay, they send RecordDynamic packets that provide the server with the complete details of the records that should be created. When they create enchantments, they also provide the server with armor, book, clothing and weapon records corresponding to the items they've enchanted.
This functionality added by this packet was originally supposed to be exclusive to the rewrite, but I've gone ahead and tried to provide it for the pre-rewrite in a way that can mostly be reused for the rewrite.
2018-07-30 07:56:26 +00:00
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
MWBase::World *world = MWBase::Environment::get().getWorld();
|
|
|
|
|
|
|
|
|
|
if (record.baseId.empty())
|
|
|
|
|
{
|
2019-10-17 03:58:56 +00:00
|
|
|
if (recordData.mEffects.mList.empty())
|
[General] Implement RecordDynamic packet, part 1
Spell, potion, enchantment, creature, NPC, armor, book, clothing, miscellaneous and weapon record data can now be sent in a RecordDynamic packet. Additionally, the packets include data related to associated magical effects (for spells, potions and enchantments), data related to default inventory contents (for creatures and NPCs) and data related to body parts affected (for armor and clothing).
The server now has associated script functions for setting most of the details of the above, with the main exception being individual creature and NPC stats.
Records can either be created entirely from scratch or can use an existing record (set via the baseId variable) as a starting point for their values. In the latter case, only the values that are specifically set override the starting values. Creature and NPC records also have an inventoryBaseId that can be used on top of the baseId to base their inventories on another existing record.
The client's RecordHelper class has been heavily expanded to allow for the above mentioned functionality.
When players create spells, potions and enchantments as part of regular gameplay, they send RecordDynamic packets that provide the server with the complete details of the records that should be created. When they create enchantments, they also provide the server with armor, book, clothing and weapon records corresponding to the items they've enchanted.
This functionality added by this packet was originally supposed to be exclusive to the rewrite, but I've gone ahead and tried to provide it for the pre-rewrite in a way that can mostly be reused for the rewrite.
2018-07-30 07:56:26 +00:00
|
|
|
{
|
2019-10-17 03:58:56 +00:00
|
|
|
LOG_APPEND(TimedLog::LOG_INFO, "-- Ignoring new enchantment record with no effects");
|
[General] Implement RecordDynamic packet, part 1
Spell, potion, enchantment, creature, NPC, armor, book, clothing, miscellaneous and weapon record data can now be sent in a RecordDynamic packet. Additionally, the packets include data related to associated magical effects (for spells, potions and enchantments), data related to default inventory contents (for creatures and NPCs) and data related to body parts affected (for armor and clothing).
The server now has associated script functions for setting most of the details of the above, with the main exception being individual creature and NPC stats.
Records can either be created entirely from scratch or can use an existing record (set via the baseId variable) as a starting point for their values. In the latter case, only the values that are specifically set override the starting values. Creature and NPC records also have an inventoryBaseId that can be used on top of the baseId to base their inventories on another existing record.
The client's RecordHelper class has been heavily expanded to allow for the above mentioned functionality.
When players create spells, potions and enchantments as part of regular gameplay, they send RecordDynamic packets that provide the server with the complete details of the records that should be created. When they create enchantments, they also provide the server with armor, book, clothing and weapon records corresponding to the items they've enchanted.
This functionality added by this packet was originally supposed to be exclusive to the rewrite, but I've gone ahead and tried to provide it for the pre-rewrite in a way that can mostly be reused for the rewrite.
2018-07-30 07:56:26 +00:00
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
world->getModifiableStore().overrideRecord(recordData);
|
|
|
|
|
}
|
2019-10-17 03:58:56 +00:00
|
|
|
else if (doesRecordIdExist<ESM::Enchantment>(record.baseId))
|
[General] Implement RecordDynamic packet, part 1
Spell, potion, enchantment, creature, NPC, armor, book, clothing, miscellaneous and weapon record data can now be sent in a RecordDynamic packet. Additionally, the packets include data related to associated magical effects (for spells, potions and enchantments), data related to default inventory contents (for creatures and NPCs) and data related to body parts affected (for armor and clothing).
The server now has associated script functions for setting most of the details of the above, with the main exception being individual creature and NPC stats.
Records can either be created entirely from scratch or can use an existing record (set via the baseId variable) as a starting point for their values. In the latter case, only the values that are specifically set override the starting values. Creature and NPC records also have an inventoryBaseId that can be used on top of the baseId to base their inventories on another existing record.
The client's RecordHelper class has been heavily expanded to allow for the above mentioned functionality.
When players create spells, potions and enchantments as part of regular gameplay, they send RecordDynamic packets that provide the server with the complete details of the records that should be created. When they create enchantments, they also provide the server with armor, book, clothing and weapon records corresponding to the items they've enchanted.
This functionality added by this packet was originally supposed to be exclusive to the rewrite, but I've gone ahead and tried to provide it for the pre-rewrite in a way that can mostly be reused for the rewrite.
2018-07-30 07:56:26 +00:00
|
|
|
{
|
2019-10-17 03:58:56 +00:00
|
|
|
const ESM::Enchantment *baseData = world->getStore().get<ESM::Enchantment>().search(record.baseId);
|
|
|
|
|
ESM::Enchantment finalData = *baseData;
|
[General] Implement RecordDynamic packet, part 1
Spell, potion, enchantment, creature, NPC, armor, book, clothing, miscellaneous and weapon record data can now be sent in a RecordDynamic packet. Additionally, the packets include data related to associated magical effects (for spells, potions and enchantments), data related to default inventory contents (for creatures and NPCs) and data related to body parts affected (for armor and clothing).
The server now has associated script functions for setting most of the details of the above, with the main exception being individual creature and NPC stats.
Records can either be created entirely from scratch or can use an existing record (set via the baseId variable) as a starting point for their values. In the latter case, only the values that are specifically set override the starting values. Creature and NPC records also have an inventoryBaseId that can be used on top of the baseId to base their inventories on another existing record.
The client's RecordHelper class has been heavily expanded to allow for the above mentioned functionality.
When players create spells, potions and enchantments as part of regular gameplay, they send RecordDynamic packets that provide the server with the complete details of the records that should be created. When they create enchantments, they also provide the server with armor, book, clothing and weapon records corresponding to the items they've enchanted.
This functionality added by this packet was originally supposed to be exclusive to the rewrite, but I've gone ahead and tried to provide it for the pre-rewrite in a way that can mostly be reused for the rewrite.
2018-07-30 07:56:26 +00:00
|
|
|
finalData.mId = recordData.mId;
|
|
|
|
|
|
|
|
|
|
if (record.baseOverrides.hasSubtype)
|
|
|
|
|
finalData.mData.mType = recordData.mData.mType;
|
|
|
|
|
|
2019-10-17 03:58:56 +00:00
|
|
|
if (record.baseOverrides.hasCost)
|
|
|
|
|
finalData.mData.mCost = recordData.mData.mCost;
|
[General] Implement RecordDynamic packet, part 1
Spell, potion, enchantment, creature, NPC, armor, book, clothing, miscellaneous and weapon record data can now be sent in a RecordDynamic packet. Additionally, the packets include data related to associated magical effects (for spells, potions and enchantments), data related to default inventory contents (for creatures and NPCs) and data related to body parts affected (for armor and clothing).
The server now has associated script functions for setting most of the details of the above, with the main exception being individual creature and NPC stats.
Records can either be created entirely from scratch or can use an existing record (set via the baseId variable) as a starting point for their values. In the latter case, only the values that are specifically set override the starting values. Creature and NPC records also have an inventoryBaseId that can be used on top of the baseId to base their inventories on another existing record.
The client's RecordHelper class has been heavily expanded to allow for the above mentioned functionality.
When players create spells, potions and enchantments as part of regular gameplay, they send RecordDynamic packets that provide the server with the complete details of the records that should be created. When they create enchantments, they also provide the server with armor, book, clothing and weapon records corresponding to the items they've enchanted.
This functionality added by this packet was originally supposed to be exclusive to the rewrite, but I've gone ahead and tried to provide it for the pre-rewrite in a way that can mostly be reused for the rewrite.
2018-07-30 07:56:26 +00:00
|
|
|
|
2019-10-17 03:58:56 +00:00
|
|
|
if (record.baseOverrides.hasCharge)
|
|
|
|
|
finalData.mData.mCharge = recordData.mData.mCharge;
|
[General] Implement RecordDynamic packet, part 1
Spell, potion, enchantment, creature, NPC, armor, book, clothing, miscellaneous and weapon record data can now be sent in a RecordDynamic packet. Additionally, the packets include data related to associated magical effects (for spells, potions and enchantments), data related to default inventory contents (for creatures and NPCs) and data related to body parts affected (for armor and clothing).
The server now has associated script functions for setting most of the details of the above, with the main exception being individual creature and NPC stats.
Records can either be created entirely from scratch or can use an existing record (set via the baseId variable) as a starting point for their values. In the latter case, only the values that are specifically set override the starting values. Creature and NPC records also have an inventoryBaseId that can be used on top of the baseId to base their inventories on another existing record.
The client's RecordHelper class has been heavily expanded to allow for the above mentioned functionality.
When players create spells, potions and enchantments as part of regular gameplay, they send RecordDynamic packets that provide the server with the complete details of the records that should be created. When they create enchantments, they also provide the server with armor, book, clothing and weapon records corresponding to the items they've enchanted.
This functionality added by this packet was originally supposed to be exclusive to the rewrite, but I've gone ahead and tried to provide it for the pre-rewrite in a way that can mostly be reused for the rewrite.
2018-07-30 07:56:26 +00:00
|
|
|
|
2020-04-13 23:15:24 +00:00
|
|
|
if (record.baseOverrides.hasFlags)
|
|
|
|
|
finalData.mData.mFlags = recordData.mData.mFlags;
|
[General] Implement RecordDynamic packet, part 1
Spell, potion, enchantment, creature, NPC, armor, book, clothing, miscellaneous and weapon record data can now be sent in a RecordDynamic packet. Additionally, the packets include data related to associated magical effects (for spells, potions and enchantments), data related to default inventory contents (for creatures and NPCs) and data related to body parts affected (for armor and clothing).
The server now has associated script functions for setting most of the details of the above, with the main exception being individual creature and NPC stats.
Records can either be created entirely from scratch or can use an existing record (set via the baseId variable) as a starting point for their values. In the latter case, only the values that are specifically set override the starting values. Creature and NPC records also have an inventoryBaseId that can be used on top of the baseId to base their inventories on another existing record.
The client's RecordHelper class has been heavily expanded to allow for the above mentioned functionality.
When players create spells, potions and enchantments as part of regular gameplay, they send RecordDynamic packets that provide the server with the complete details of the records that should be created. When they create enchantments, they also provide the server with armor, book, clothing and weapon records corresponding to the items they've enchanted.
This functionality added by this packet was originally supposed to be exclusive to the rewrite, but I've gone ahead and tried to provide it for the pre-rewrite in a way that can mostly be reused for the rewrite.
2018-07-30 07:56:26 +00:00
|
|
|
|
2019-10-17 03:58:56 +00:00
|
|
|
if (record.baseOverrides.hasEffects)
|
|
|
|
|
finalData.mEffects.mList = recordData.mEffects.mList;
|
[General] Implement RecordDynamic packet, part 1
Spell, potion, enchantment, creature, NPC, armor, book, clothing, miscellaneous and weapon record data can now be sent in a RecordDynamic packet. Additionally, the packets include data related to associated magical effects (for spells, potions and enchantments), data related to default inventory contents (for creatures and NPCs) and data related to body parts affected (for armor and clothing).
The server now has associated script functions for setting most of the details of the above, with the main exception being individual creature and NPC stats.
Records can either be created entirely from scratch or can use an existing record (set via the baseId variable) as a starting point for their values. In the latter case, only the values that are specifically set override the starting values. Creature and NPC records also have an inventoryBaseId that can be used on top of the baseId to base their inventories on another existing record.
The client's RecordHelper class has been heavily expanded to allow for the above mentioned functionality.
When players create spells, potions and enchantments as part of regular gameplay, they send RecordDynamic packets that provide the server with the complete details of the records that should be created. When they create enchantments, they also provide the server with armor, book, clothing and weapon records corresponding to the items they've enchanted.
This functionality added by this packet was originally supposed to be exclusive to the rewrite, but I've gone ahead and tried to provide it for the pre-rewrite in a way that can mostly be reused for the rewrite.
2018-07-30 07:56:26 +00:00
|
|
|
|
|
|
|
|
world->getModifiableStore().overrideRecord(finalData);
|
|
|
|
|
}
|
2019-01-22 22:48:06 +00:00
|
|
|
else
|
|
|
|
|
{
|
2019-08-19 18:39:33 +00:00
|
|
|
LOG_APPEND(TimedLog::LOG_INFO, "-- Ignoring record override with invalid baseId %s", record.baseId.c_str());
|
2019-01-22 22:48:06 +00:00
|
|
|
return;
|
|
|
|
|
}
|
[General] Implement RecordDynamic packet, part 1
Spell, potion, enchantment, creature, NPC, armor, book, clothing, miscellaneous and weapon record data can now be sent in a RecordDynamic packet. Additionally, the packets include data related to associated magical effects (for spells, potions and enchantments), data related to default inventory contents (for creatures and NPCs) and data related to body parts affected (for armor and clothing).
The server now has associated script functions for setting most of the details of the above, with the main exception being individual creature and NPC stats.
Records can either be created entirely from scratch or can use an existing record (set via the baseId variable) as a starting point for their values. In the latter case, only the values that are specifically set override the starting values. Creature and NPC records also have an inventoryBaseId that can be used on top of the baseId to base their inventories on another existing record.
The client's RecordHelper class has been heavily expanded to allow for the above mentioned functionality.
When players create spells, potions and enchantments as part of regular gameplay, they send RecordDynamic packets that provide the server with the complete details of the records that should be created. When they create enchantments, they also provide the server with armor, book, clothing and weapon records corresponding to the items they've enchanted.
This functionality added by this packet was originally supposed to be exclusive to the rewrite, but I've gone ahead and tried to provide it for the pre-rewrite in a way that can mostly be reused for the rewrite.
2018-07-30 07:56:26 +00:00
|
|
|
}
|
|
|
|
|
|
2021-07-18 09:36:07 +00:00
|
|
|
void RecordHelper::overrideRecord(const mwmp::GameSettingRecord& record)
|
|
|
|
|
{
|
|
|
|
|
const ESM::GameSetting& recordData = record.data;
|
|
|
|
|
|
|
|
|
|
if (recordData.mId.empty())
|
|
|
|
|
{
|
|
|
|
|
LOG_APPEND(TimedLog::LOG_INFO, "-- Ignoring record override with no id provided");
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
MWBase::World* world = MWBase::Environment::get().getWorld();
|
|
|
|
|
|
|
|
|
|
if (record.baseId.empty())
|
|
|
|
|
{
|
|
|
|
|
world->getModifiableStore().overrideRecord(recordData);
|
|
|
|
|
}
|
|
|
|
|
else if (doesRecordIdExist<ESM::GameSetting>(record.baseId))
|
|
|
|
|
{
|
|
|
|
|
const ESM::GameSetting* baseData = world->getStore().get<ESM::GameSetting>().search(record.baseId);
|
|
|
|
|
ESM::GameSetting finalData = *baseData;
|
|
|
|
|
finalData.mId = recordData.mId;
|
|
|
|
|
|
|
|
|
|
world->getModifiableStore().overrideRecord(finalData);
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
LOG_APPEND(TimedLog::LOG_INFO, "-- Ignoring record override with invalid baseId %s", record.baseId.c_str());
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2019-10-17 03:58:56 +00:00
|
|
|
void RecordHelper::overrideRecord(const mwmp::IngredientRecord& record)
|
[General] Implement RecordDynamic packet, part 1
Spell, potion, enchantment, creature, NPC, armor, book, clothing, miscellaneous and weapon record data can now be sent in a RecordDynamic packet. Additionally, the packets include data related to associated magical effects (for spells, potions and enchantments), data related to default inventory contents (for creatures and NPCs) and data related to body parts affected (for armor and clothing).
The server now has associated script functions for setting most of the details of the above, with the main exception being individual creature and NPC stats.
Records can either be created entirely from scratch or can use an existing record (set via the baseId variable) as a starting point for their values. In the latter case, only the values that are specifically set override the starting values. Creature and NPC records also have an inventoryBaseId that can be used on top of the baseId to base their inventories on another existing record.
The client's RecordHelper class has been heavily expanded to allow for the above mentioned functionality.
When players create spells, potions and enchantments as part of regular gameplay, they send RecordDynamic packets that provide the server with the complete details of the records that should be created. When they create enchantments, they also provide the server with armor, book, clothing and weapon records corresponding to the items they've enchanted.
This functionality added by this packet was originally supposed to be exclusive to the rewrite, but I've gone ahead and tried to provide it for the pre-rewrite in a way that can mostly be reused for the rewrite.
2018-07-30 07:56:26 +00:00
|
|
|
{
|
2019-10-17 03:58:56 +00:00
|
|
|
const ESM::Ingredient &recordData = record.data;
|
[General] Implement RecordDynamic packet, part 1
Spell, potion, enchantment, creature, NPC, armor, book, clothing, miscellaneous and weapon record data can now be sent in a RecordDynamic packet. Additionally, the packets include data related to associated magical effects (for spells, potions and enchantments), data related to default inventory contents (for creatures and NPCs) and data related to body parts affected (for armor and clothing).
The server now has associated script functions for setting most of the details of the above, with the main exception being individual creature and NPC stats.
Records can either be created entirely from scratch or can use an existing record (set via the baseId variable) as a starting point for their values. In the latter case, only the values that are specifically set override the starting values. Creature and NPC records also have an inventoryBaseId that can be used on top of the baseId to base their inventories on another existing record.
The client's RecordHelper class has been heavily expanded to allow for the above mentioned functionality.
When players create spells, potions and enchantments as part of regular gameplay, they send RecordDynamic packets that provide the server with the complete details of the records that should be created. When they create enchantments, they also provide the server with armor, book, clothing and weapon records corresponding to the items they've enchanted.
This functionality added by this packet was originally supposed to be exclusive to the rewrite, but I've gone ahead and tried to provide it for the pre-rewrite in a way that can mostly be reused for the rewrite.
2018-07-30 07:56:26 +00:00
|
|
|
|
|
|
|
|
if (recordData.mId.empty())
|
|
|
|
|
{
|
2019-08-19 18:39:33 +00:00
|
|
|
LOG_APPEND(TimedLog::LOG_INFO, "-- Ignoring record override with no id provided");
|
[General] Implement RecordDynamic packet, part 1
Spell, potion, enchantment, creature, NPC, armor, book, clothing, miscellaneous and weapon record data can now be sent in a RecordDynamic packet. Additionally, the packets include data related to associated magical effects (for spells, potions and enchantments), data related to default inventory contents (for creatures and NPCs) and data related to body parts affected (for armor and clothing).
The server now has associated script functions for setting most of the details of the above, with the main exception being individual creature and NPC stats.
Records can either be created entirely from scratch or can use an existing record (set via the baseId variable) as a starting point for their values. In the latter case, only the values that are specifically set override the starting values. Creature and NPC records also have an inventoryBaseId that can be used on top of the baseId to base their inventories on another existing record.
The client's RecordHelper class has been heavily expanded to allow for the above mentioned functionality.
When players create spells, potions and enchantments as part of regular gameplay, they send RecordDynamic packets that provide the server with the complete details of the records that should be created. When they create enchantments, they also provide the server with armor, book, clothing and weapon records corresponding to the items they've enchanted.
This functionality added by this packet was originally supposed to be exclusive to the rewrite, but I've gone ahead and tried to provide it for the pre-rewrite in a way that can mostly be reused for the rewrite.
2018-07-30 07:56:26 +00:00
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
2019-10-17 03:58:56 +00:00
|
|
|
bool isExistingId = doesRecordIdExist<ESM::Ingredient>(recordData.mId);
|
[General] Implement RecordDynamic packet, part 1
Spell, potion, enchantment, creature, NPC, armor, book, clothing, miscellaneous and weapon record data can now be sent in a RecordDynamic packet. Additionally, the packets include data related to associated magical effects (for spells, potions and enchantments), data related to default inventory contents (for creatures and NPCs) and data related to body parts affected (for armor and clothing).
The server now has associated script functions for setting most of the details of the above, with the main exception being individual creature and NPC stats.
Records can either be created entirely from scratch or can use an existing record (set via the baseId variable) as a starting point for their values. In the latter case, only the values that are specifically set override the starting values. Creature and NPC records also have an inventoryBaseId that can be used on top of the baseId to base their inventories on another existing record.
The client's RecordHelper class has been heavily expanded to allow for the above mentioned functionality.
When players create spells, potions and enchantments as part of regular gameplay, they send RecordDynamic packets that provide the server with the complete details of the records that should be created. When they create enchantments, they also provide the server with armor, book, clothing and weapon records corresponding to the items they've enchanted.
This functionality added by this packet was originally supposed to be exclusive to the rewrite, but I've gone ahead and tried to provide it for the pre-rewrite in a way that can mostly be reused for the rewrite.
2018-07-30 07:56:26 +00:00
|
|
|
MWBase::World *world = MWBase::Environment::get().getWorld();
|
|
|
|
|
|
|
|
|
|
if (record.baseId.empty())
|
|
|
|
|
{
|
|
|
|
|
world->getModifiableStore().overrideRecord(recordData);
|
|
|
|
|
}
|
2019-10-17 03:58:56 +00:00
|
|
|
else if (doesRecordIdExist<ESM::Ingredient>(record.baseId))
|
[General] Implement RecordDynamic packet, part 1
Spell, potion, enchantment, creature, NPC, armor, book, clothing, miscellaneous and weapon record data can now be sent in a RecordDynamic packet. Additionally, the packets include data related to associated magical effects (for spells, potions and enchantments), data related to default inventory contents (for creatures and NPCs) and data related to body parts affected (for armor and clothing).
The server now has associated script functions for setting most of the details of the above, with the main exception being individual creature and NPC stats.
Records can either be created entirely from scratch or can use an existing record (set via the baseId variable) as a starting point for their values. In the latter case, only the values that are specifically set override the starting values. Creature and NPC records also have an inventoryBaseId that can be used on top of the baseId to base their inventories on another existing record.
The client's RecordHelper class has been heavily expanded to allow for the above mentioned functionality.
When players create spells, potions and enchantments as part of regular gameplay, they send RecordDynamic packets that provide the server with the complete details of the records that should be created. When they create enchantments, they also provide the server with armor, book, clothing and weapon records corresponding to the items they've enchanted.
This functionality added by this packet was originally supposed to be exclusive to the rewrite, but I've gone ahead and tried to provide it for the pre-rewrite in a way that can mostly be reused for the rewrite.
2018-07-30 07:56:26 +00:00
|
|
|
{
|
2019-10-17 03:58:56 +00:00
|
|
|
const ESM::Ingredient *baseData = world->getStore().get<ESM::Ingredient>().search(record.baseId);
|
|
|
|
|
ESM::Ingredient finalData = *baseData;
|
[General] Implement RecordDynamic packet, part 1
Spell, potion, enchantment, creature, NPC, armor, book, clothing, miscellaneous and weapon record data can now be sent in a RecordDynamic packet. Additionally, the packets include data related to associated magical effects (for spells, potions and enchantments), data related to default inventory contents (for creatures and NPCs) and data related to body parts affected (for armor and clothing).
The server now has associated script functions for setting most of the details of the above, with the main exception being individual creature and NPC stats.
Records can either be created entirely from scratch or can use an existing record (set via the baseId variable) as a starting point for their values. In the latter case, only the values that are specifically set override the starting values. Creature and NPC records also have an inventoryBaseId that can be used on top of the baseId to base their inventories on another existing record.
The client's RecordHelper class has been heavily expanded to allow for the above mentioned functionality.
When players create spells, potions and enchantments as part of regular gameplay, they send RecordDynamic packets that provide the server with the complete details of the records that should be created. When they create enchantments, they also provide the server with armor, book, clothing and weapon records corresponding to the items they've enchanted.
This functionality added by this packet was originally supposed to be exclusive to the rewrite, but I've gone ahead and tried to provide it for the pre-rewrite in a way that can mostly be reused for the rewrite.
2018-07-30 07:56:26 +00:00
|
|
|
finalData.mId = recordData.mId;
|
|
|
|
|
|
|
|
|
|
if (record.baseOverrides.hasName)
|
|
|
|
|
finalData.mName = recordData.mName;
|
|
|
|
|
|
|
|
|
|
if (record.baseOverrides.hasModel)
|
|
|
|
|
finalData.mModel = recordData.mModel;
|
|
|
|
|
|
|
|
|
|
if (record.baseOverrides.hasIcon)
|
|
|
|
|
finalData.mIcon = recordData.mIcon;
|
|
|
|
|
|
|
|
|
|
if (record.baseOverrides.hasWeight)
|
|
|
|
|
finalData.mData.mWeight = recordData.mData.mWeight;
|
|
|
|
|
|
|
|
|
|
if (record.baseOverrides.hasValue)
|
|
|
|
|
finalData.mData.mValue = recordData.mData.mValue;
|
|
|
|
|
|
|
|
|
|
if (record.baseOverrides.hasScript)
|
|
|
|
|
finalData.mScript = recordData.mScript;
|
|
|
|
|
|
2019-10-17 03:58:56 +00:00
|
|
|
if (record.baseOverrides.hasEffects)
|
|
|
|
|
{
|
|
|
|
|
const static unsigned int effectCap = sizeof(recordData.mData.mEffectID) / sizeof(recordData.mData.mEffectID[0]);
|
|
|
|
|
|
|
|
|
|
for (int effectIndex = 0; effectIndex < effectCap; effectIndex++)
|
|
|
|
|
{
|
|
|
|
|
finalData.mData.mEffectID[effectIndex] = recordData.mData.mEffectID[effectIndex];
|
|
|
|
|
finalData.mData.mAttributes[effectIndex] = recordData.mData.mAttributes[effectIndex];
|
|
|
|
|
finalData.mData.mSkills[effectIndex] = recordData.mData.mSkills[effectIndex];
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
[General] Implement RecordDynamic packet, part 1
Spell, potion, enchantment, creature, NPC, armor, book, clothing, miscellaneous and weapon record data can now be sent in a RecordDynamic packet. Additionally, the packets include data related to associated magical effects (for spells, potions and enchantments), data related to default inventory contents (for creatures and NPCs) and data related to body parts affected (for armor and clothing).
The server now has associated script functions for setting most of the details of the above, with the main exception being individual creature and NPC stats.
Records can either be created entirely from scratch or can use an existing record (set via the baseId variable) as a starting point for their values. In the latter case, only the values that are specifically set override the starting values. Creature and NPC records also have an inventoryBaseId that can be used on top of the baseId to base their inventories on another existing record.
The client's RecordHelper class has been heavily expanded to allow for the above mentioned functionality.
When players create spells, potions and enchantments as part of regular gameplay, they send RecordDynamic packets that provide the server with the complete details of the records that should be created. When they create enchantments, they also provide the server with armor, book, clothing and weapon records corresponding to the items they've enchanted.
This functionality added by this packet was originally supposed to be exclusive to the rewrite, but I've gone ahead and tried to provide it for the pre-rewrite in a way that can mostly be reused for the rewrite.
2018-07-30 07:56:26 +00:00
|
|
|
world->getModifiableStore().overrideRecord(finalData);
|
|
|
|
|
}
|
2019-01-22 22:48:06 +00:00
|
|
|
else
|
|
|
|
|
{
|
2019-08-19 18:39:33 +00:00
|
|
|
LOG_APPEND(TimedLog::LOG_INFO, "-- Ignoring record override with invalid baseId %s", record.baseId.c_str());
|
2019-01-22 22:48:06 +00:00
|
|
|
return;
|
|
|
|
|
}
|
[General] Implement RecordDynamic packet, part 1
Spell, potion, enchantment, creature, NPC, armor, book, clothing, miscellaneous and weapon record data can now be sent in a RecordDynamic packet. Additionally, the packets include data related to associated magical effects (for spells, potions and enchantments), data related to default inventory contents (for creatures and NPCs) and data related to body parts affected (for armor and clothing).
The server now has associated script functions for setting most of the details of the above, with the main exception being individual creature and NPC stats.
Records can either be created entirely from scratch or can use an existing record (set via the baseId variable) as a starting point for their values. In the latter case, only the values that are specifically set override the starting values. Creature and NPC records also have an inventoryBaseId that can be used on top of the baseId to base their inventories on another existing record.
The client's RecordHelper class has been heavily expanded to allow for the above mentioned functionality.
When players create spells, potions and enchantments as part of regular gameplay, they send RecordDynamic packets that provide the server with the complete details of the records that should be created. When they create enchantments, they also provide the server with armor, book, clothing and weapon records corresponding to the items they've enchanted.
This functionality added by this packet was originally supposed to be exclusive to the rewrite, but I've gone ahead and tried to provide it for the pre-rewrite in a way that can mostly be reused for the rewrite.
2018-07-30 07:56:26 +00:00
|
|
|
|
|
|
|
|
if (isExistingId)
|
|
|
|
|
world->updatePtrsWithRefId(recordData.mId);
|
|
|
|
|
}
|
|
|
|
|
|
2019-10-17 03:58:56 +00:00
|
|
|
void RecordHelper::overrideRecord(const mwmp::LightRecord& record)
|
[General] Implement RecordDynamic packet, part 1
Spell, potion, enchantment, creature, NPC, armor, book, clothing, miscellaneous and weapon record data can now be sent in a RecordDynamic packet. Additionally, the packets include data related to associated magical effects (for spells, potions and enchantments), data related to default inventory contents (for creatures and NPCs) and data related to body parts affected (for armor and clothing).
The server now has associated script functions for setting most of the details of the above, with the main exception being individual creature and NPC stats.
Records can either be created entirely from scratch or can use an existing record (set via the baseId variable) as a starting point for their values. In the latter case, only the values that are specifically set override the starting values. Creature and NPC records also have an inventoryBaseId that can be used on top of the baseId to base their inventories on another existing record.
The client's RecordHelper class has been heavily expanded to allow for the above mentioned functionality.
When players create spells, potions and enchantments as part of regular gameplay, they send RecordDynamic packets that provide the server with the complete details of the records that should be created. When they create enchantments, they also provide the server with armor, book, clothing and weapon records corresponding to the items they've enchanted.
This functionality added by this packet was originally supposed to be exclusive to the rewrite, but I've gone ahead and tried to provide it for the pre-rewrite in a way that can mostly be reused for the rewrite.
2018-07-30 07:56:26 +00:00
|
|
|
{
|
2019-10-17 03:58:56 +00:00
|
|
|
const ESM::Light &recordData = record.data;
|
[General] Implement RecordDynamic packet, part 1
Spell, potion, enchantment, creature, NPC, armor, book, clothing, miscellaneous and weapon record data can now be sent in a RecordDynamic packet. Additionally, the packets include data related to associated magical effects (for spells, potions and enchantments), data related to default inventory contents (for creatures and NPCs) and data related to body parts affected (for armor and clothing).
The server now has associated script functions for setting most of the details of the above, with the main exception being individual creature and NPC stats.
Records can either be created entirely from scratch or can use an existing record (set via the baseId variable) as a starting point for their values. In the latter case, only the values that are specifically set override the starting values. Creature and NPC records also have an inventoryBaseId that can be used on top of the baseId to base their inventories on another existing record.
The client's RecordHelper class has been heavily expanded to allow for the above mentioned functionality.
When players create spells, potions and enchantments as part of regular gameplay, they send RecordDynamic packets that provide the server with the complete details of the records that should be created. When they create enchantments, they also provide the server with armor, book, clothing and weapon records corresponding to the items they've enchanted.
This functionality added by this packet was originally supposed to be exclusive to the rewrite, but I've gone ahead and tried to provide it for the pre-rewrite in a way that can mostly be reused for the rewrite.
2018-07-30 07:56:26 +00:00
|
|
|
|
|
|
|
|
if (recordData.mId.empty())
|
|
|
|
|
{
|
2019-08-19 18:39:33 +00:00
|
|
|
LOG_APPEND(TimedLog::LOG_INFO, "-- Ignoring record override with no id provided");
|
[General] Implement RecordDynamic packet, part 1
Spell, potion, enchantment, creature, NPC, armor, book, clothing, miscellaneous and weapon record data can now be sent in a RecordDynamic packet. Additionally, the packets include data related to associated magical effects (for spells, potions and enchantments), data related to default inventory contents (for creatures and NPCs) and data related to body parts affected (for armor and clothing).
The server now has associated script functions for setting most of the details of the above, with the main exception being individual creature and NPC stats.
Records can either be created entirely from scratch or can use an existing record (set via the baseId variable) as a starting point for their values. In the latter case, only the values that are specifically set override the starting values. Creature and NPC records also have an inventoryBaseId that can be used on top of the baseId to base their inventories on another existing record.
The client's RecordHelper class has been heavily expanded to allow for the above mentioned functionality.
When players create spells, potions and enchantments as part of regular gameplay, they send RecordDynamic packets that provide the server with the complete details of the records that should be created. When they create enchantments, they also provide the server with armor, book, clothing and weapon records corresponding to the items they've enchanted.
This functionality added by this packet was originally supposed to be exclusive to the rewrite, but I've gone ahead and tried to provide it for the pre-rewrite in a way that can mostly be reused for the rewrite.
2018-07-30 07:56:26 +00:00
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
2019-10-17 03:58:56 +00:00
|
|
|
bool isExistingId = doesRecordIdExist<ESM::Light>(recordData.mId);
|
[General] Implement RecordDynamic packet, part 1
Spell, potion, enchantment, creature, NPC, armor, book, clothing, miscellaneous and weapon record data can now be sent in a RecordDynamic packet. Additionally, the packets include data related to associated magical effects (for spells, potions and enchantments), data related to default inventory contents (for creatures and NPCs) and data related to body parts affected (for armor and clothing).
The server now has associated script functions for setting most of the details of the above, with the main exception being individual creature and NPC stats.
Records can either be created entirely from scratch or can use an existing record (set via the baseId variable) as a starting point for their values. In the latter case, only the values that are specifically set override the starting values. Creature and NPC records also have an inventoryBaseId that can be used on top of the baseId to base their inventories on another existing record.
The client's RecordHelper class has been heavily expanded to allow for the above mentioned functionality.
When players create spells, potions and enchantments as part of regular gameplay, they send RecordDynamic packets that provide the server with the complete details of the records that should be created. When they create enchantments, they also provide the server with armor, book, clothing and weapon records corresponding to the items they've enchanted.
This functionality added by this packet was originally supposed to be exclusive to the rewrite, but I've gone ahead and tried to provide it for the pre-rewrite in a way that can mostly be reused for the rewrite.
2018-07-30 07:56:26 +00:00
|
|
|
MWBase::World *world = MWBase::Environment::get().getWorld();
|
|
|
|
|
|
|
|
|
|
if (record.baseId.empty())
|
|
|
|
|
{
|
2019-10-17 03:58:56 +00:00
|
|
|
world->getModifiableStore().overrideRecord(recordData);
|
[General] Implement RecordDynamic packet, part 1
Spell, potion, enchantment, creature, NPC, armor, book, clothing, miscellaneous and weapon record data can now be sent in a RecordDynamic packet. Additionally, the packets include data related to associated magical effects (for spells, potions and enchantments), data related to default inventory contents (for creatures and NPCs) and data related to body parts affected (for armor and clothing).
The server now has associated script functions for setting most of the details of the above, with the main exception being individual creature and NPC stats.
Records can either be created entirely from scratch or can use an existing record (set via the baseId variable) as a starting point for their values. In the latter case, only the values that are specifically set override the starting values. Creature and NPC records also have an inventoryBaseId that can be used on top of the baseId to base their inventories on another existing record.
The client's RecordHelper class has been heavily expanded to allow for the above mentioned functionality.
When players create spells, potions and enchantments as part of regular gameplay, they send RecordDynamic packets that provide the server with the complete details of the records that should be created. When they create enchantments, they also provide the server with armor, book, clothing and weapon records corresponding to the items they've enchanted.
This functionality added by this packet was originally supposed to be exclusive to the rewrite, but I've gone ahead and tried to provide it for the pre-rewrite in a way that can mostly be reused for the rewrite.
2018-07-30 07:56:26 +00:00
|
|
|
}
|
2019-10-17 03:58:56 +00:00
|
|
|
else if (doesRecordIdExist<ESM::Light>(record.baseId))
|
[General] Implement RecordDynamic packet, part 1
Spell, potion, enchantment, creature, NPC, armor, book, clothing, miscellaneous and weapon record data can now be sent in a RecordDynamic packet. Additionally, the packets include data related to associated magical effects (for spells, potions and enchantments), data related to default inventory contents (for creatures and NPCs) and data related to body parts affected (for armor and clothing).
The server now has associated script functions for setting most of the details of the above, with the main exception being individual creature and NPC stats.
Records can either be created entirely from scratch or can use an existing record (set via the baseId variable) as a starting point for their values. In the latter case, only the values that are specifically set override the starting values. Creature and NPC records also have an inventoryBaseId that can be used on top of the baseId to base their inventories on another existing record.
The client's RecordHelper class has been heavily expanded to allow for the above mentioned functionality.
When players create spells, potions and enchantments as part of regular gameplay, they send RecordDynamic packets that provide the server with the complete details of the records that should be created. When they create enchantments, they also provide the server with armor, book, clothing and weapon records corresponding to the items they've enchanted.
This functionality added by this packet was originally supposed to be exclusive to the rewrite, but I've gone ahead and tried to provide it for the pre-rewrite in a way that can mostly be reused for the rewrite.
2018-07-30 07:56:26 +00:00
|
|
|
{
|
2019-10-17 03:58:56 +00:00
|
|
|
const ESM::Light *baseData = world->getStore().get<ESM::Light>().search(record.baseId);
|
|
|
|
|
ESM::Light finalData = *baseData;
|
[General] Implement RecordDynamic packet, part 1
Spell, potion, enchantment, creature, NPC, armor, book, clothing, miscellaneous and weapon record data can now be sent in a RecordDynamic packet. Additionally, the packets include data related to associated magical effects (for spells, potions and enchantments), data related to default inventory contents (for creatures and NPCs) and data related to body parts affected (for armor and clothing).
The server now has associated script functions for setting most of the details of the above, with the main exception being individual creature and NPC stats.
Records can either be created entirely from scratch or can use an existing record (set via the baseId variable) as a starting point for their values. In the latter case, only the values that are specifically set override the starting values. Creature and NPC records also have an inventoryBaseId that can be used on top of the baseId to base their inventories on another existing record.
The client's RecordHelper class has been heavily expanded to allow for the above mentioned functionality.
When players create spells, potions and enchantments as part of regular gameplay, they send RecordDynamic packets that provide the server with the complete details of the records that should be created. When they create enchantments, they also provide the server with armor, book, clothing and weapon records corresponding to the items they've enchanted.
This functionality added by this packet was originally supposed to be exclusive to the rewrite, but I've gone ahead and tried to provide it for the pre-rewrite in a way that can mostly be reused for the rewrite.
2018-07-30 07:56:26 +00:00
|
|
|
finalData.mId = recordData.mId;
|
|
|
|
|
|
|
|
|
|
if (record.baseOverrides.hasName)
|
|
|
|
|
finalData.mName = recordData.mName;
|
|
|
|
|
|
|
|
|
|
if (record.baseOverrides.hasModel)
|
|
|
|
|
finalData.mModel = recordData.mModel;
|
|
|
|
|
|
|
|
|
|
if (record.baseOverrides.hasIcon)
|
|
|
|
|
finalData.mIcon = recordData.mIcon;
|
|
|
|
|
|
2019-10-17 03:58:56 +00:00
|
|
|
if (record.baseOverrides.hasSound)
|
|
|
|
|
finalData.mSound = recordData.mSound;
|
[General] Implement RecordDynamic packet, part 1
Spell, potion, enchantment, creature, NPC, armor, book, clothing, miscellaneous and weapon record data can now be sent in a RecordDynamic packet. Additionally, the packets include data related to associated magical effects (for spells, potions and enchantments), data related to default inventory contents (for creatures and NPCs) and data related to body parts affected (for armor and clothing).
The server now has associated script functions for setting most of the details of the above, with the main exception being individual creature and NPC stats.
Records can either be created entirely from scratch or can use an existing record (set via the baseId variable) as a starting point for their values. In the latter case, only the values that are specifically set override the starting values. Creature and NPC records also have an inventoryBaseId that can be used on top of the baseId to base their inventories on another existing record.
The client's RecordHelper class has been heavily expanded to allow for the above mentioned functionality.
When players create spells, potions and enchantments as part of regular gameplay, they send RecordDynamic packets that provide the server with the complete details of the records that should be created. When they create enchantments, they also provide the server with armor, book, clothing and weapon records corresponding to the items they've enchanted.
This functionality added by this packet was originally supposed to be exclusive to the rewrite, but I've gone ahead and tried to provide it for the pre-rewrite in a way that can mostly be reused for the rewrite.
2018-07-30 07:56:26 +00:00
|
|
|
|
|
|
|
|
if (record.baseOverrides.hasWeight)
|
|
|
|
|
finalData.mData.mWeight = recordData.mData.mWeight;
|
|
|
|
|
|
|
|
|
|
if (record.baseOverrides.hasValue)
|
|
|
|
|
finalData.mData.mValue = recordData.mData.mValue;
|
|
|
|
|
|
2019-10-17 03:58:56 +00:00
|
|
|
if (record.baseOverrides.hasTime)
|
|
|
|
|
finalData.mData.mTime = recordData.mData.mTime;
|
[General] Implement RecordDynamic packet, part 1
Spell, potion, enchantment, creature, NPC, armor, book, clothing, miscellaneous and weapon record data can now be sent in a RecordDynamic packet. Additionally, the packets include data related to associated magical effects (for spells, potions and enchantments), data related to default inventory contents (for creatures and NPCs) and data related to body parts affected (for armor and clothing).
The server now has associated script functions for setting most of the details of the above, with the main exception being individual creature and NPC stats.
Records can either be created entirely from scratch or can use an existing record (set via the baseId variable) as a starting point for their values. In the latter case, only the values that are specifically set override the starting values. Creature and NPC records also have an inventoryBaseId that can be used on top of the baseId to base their inventories on another existing record.
The client's RecordHelper class has been heavily expanded to allow for the above mentioned functionality.
When players create spells, potions and enchantments as part of regular gameplay, they send RecordDynamic packets that provide the server with the complete details of the records that should be created. When they create enchantments, they also provide the server with armor, book, clothing and weapon records corresponding to the items they've enchanted.
This functionality added by this packet was originally supposed to be exclusive to the rewrite, but I've gone ahead and tried to provide it for the pre-rewrite in a way that can mostly be reused for the rewrite.
2018-07-30 07:56:26 +00:00
|
|
|
|
2019-10-17 03:58:56 +00:00
|
|
|
if (record.baseOverrides.hasRadius)
|
|
|
|
|
finalData.mData.mRadius = recordData.mData.mRadius;
|
[General] Implement RecordDynamic packet, part 1
Spell, potion, enchantment, creature, NPC, armor, book, clothing, miscellaneous and weapon record data can now be sent in a RecordDynamic packet. Additionally, the packets include data related to associated magical effects (for spells, potions and enchantments), data related to default inventory contents (for creatures and NPCs) and data related to body parts affected (for armor and clothing).
The server now has associated script functions for setting most of the details of the above, with the main exception being individual creature and NPC stats.
Records can either be created entirely from scratch or can use an existing record (set via the baseId variable) as a starting point for their values. In the latter case, only the values that are specifically set override the starting values. Creature and NPC records also have an inventoryBaseId that can be used on top of the baseId to base their inventories on another existing record.
The client's RecordHelper class has been heavily expanded to allow for the above mentioned functionality.
When players create spells, potions and enchantments as part of regular gameplay, they send RecordDynamic packets that provide the server with the complete details of the records that should be created. When they create enchantments, they also provide the server with armor, book, clothing and weapon records corresponding to the items they've enchanted.
This functionality added by this packet was originally supposed to be exclusive to the rewrite, but I've gone ahead and tried to provide it for the pre-rewrite in a way that can mostly be reused for the rewrite.
2018-07-30 07:56:26 +00:00
|
|
|
|
2019-10-17 03:58:56 +00:00
|
|
|
if (record.baseOverrides.hasColor)
|
|
|
|
|
finalData.mData.mColor = recordData.mData.mColor;
|
[General] Implement RecordDynamic packet, part 1
Spell, potion, enchantment, creature, NPC, armor, book, clothing, miscellaneous and weapon record data can now be sent in a RecordDynamic packet. Additionally, the packets include data related to associated magical effects (for spells, potions and enchantments), data related to default inventory contents (for creatures and NPCs) and data related to body parts affected (for armor and clothing).
The server now has associated script functions for setting most of the details of the above, with the main exception being individual creature and NPC stats.
Records can either be created entirely from scratch or can use an existing record (set via the baseId variable) as a starting point for their values. In the latter case, only the values that are specifically set override the starting values. Creature and NPC records also have an inventoryBaseId that can be used on top of the baseId to base their inventories on another existing record.
The client's RecordHelper class has been heavily expanded to allow for the above mentioned functionality.
When players create spells, potions and enchantments as part of regular gameplay, they send RecordDynamic packets that provide the server with the complete details of the records that should be created. When they create enchantments, they also provide the server with armor, book, clothing and weapon records corresponding to the items they've enchanted.
This functionality added by this packet was originally supposed to be exclusive to the rewrite, but I've gone ahead and tried to provide it for the pre-rewrite in a way that can mostly be reused for the rewrite.
2018-07-30 07:56:26 +00:00
|
|
|
|
|
|
|
|
if (record.baseOverrides.hasFlags)
|
|
|
|
|
finalData.mData.mFlags = recordData.mData.mFlags;
|
|
|
|
|
|
|
|
|
|
if (record.baseOverrides.hasScript)
|
|
|
|
|
finalData.mScript = recordData.mScript;
|
|
|
|
|
|
|
|
|
|
world->getModifiableStore().overrideRecord(finalData);
|
|
|
|
|
}
|
2019-01-22 22:48:06 +00:00
|
|
|
else
|
|
|
|
|
{
|
2019-08-19 18:39:33 +00:00
|
|
|
LOG_APPEND(TimedLog::LOG_INFO, "-- Ignoring record override with invalid baseId %s", record.baseId.c_str());
|
2019-01-22 22:48:06 +00:00
|
|
|
return;
|
|
|
|
|
}
|
[General] Implement RecordDynamic packet, part 1
Spell, potion, enchantment, creature, NPC, armor, book, clothing, miscellaneous and weapon record data can now be sent in a RecordDynamic packet. Additionally, the packets include data related to associated magical effects (for spells, potions and enchantments), data related to default inventory contents (for creatures and NPCs) and data related to body parts affected (for armor and clothing).
The server now has associated script functions for setting most of the details of the above, with the main exception being individual creature and NPC stats.
Records can either be created entirely from scratch or can use an existing record (set via the baseId variable) as a starting point for their values. In the latter case, only the values that are specifically set override the starting values. Creature and NPC records also have an inventoryBaseId that can be used on top of the baseId to base their inventories on another existing record.
The client's RecordHelper class has been heavily expanded to allow for the above mentioned functionality.
When players create spells, potions and enchantments as part of regular gameplay, they send RecordDynamic packets that provide the server with the complete details of the records that should be created. When they create enchantments, they also provide the server with armor, book, clothing and weapon records corresponding to the items they've enchanted.
This functionality added by this packet was originally supposed to be exclusive to the rewrite, but I've gone ahead and tried to provide it for the pre-rewrite in a way that can mostly be reused for the rewrite.
2018-07-30 07:56:26 +00:00
|
|
|
|
|
|
|
|
if (isExistingId)
|
|
|
|
|
world->updatePtrsWithRefId(recordData.mId);
|
|
|
|
|
}
|
|
|
|
|
|
2019-10-17 03:58:56 +00:00
|
|
|
void RecordHelper::overrideRecord(const mwmp::LockpickRecord& record)
|
2019-07-27 00:45:50 +00:00
|
|
|
{
|
2019-10-17 03:58:56 +00:00
|
|
|
const ESM::Lockpick &recordData = record.data;
|
2019-07-27 00:45:50 +00:00
|
|
|
|
|
|
|
|
if (recordData.mId.empty())
|
|
|
|
|
{
|
2019-08-19 18:39:33 +00:00
|
|
|
LOG_APPEND(TimedLog::LOG_INFO, "-- Ignoring record override with no id provided");
|
2019-07-27 00:45:50 +00:00
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
2019-10-17 03:58:56 +00:00
|
|
|
bool isExistingId = doesRecordIdExist<ESM::Lockpick>(recordData.mId);
|
2019-07-27 00:45:50 +00:00
|
|
|
MWBase::World *world = MWBase::Environment::get().getWorld();
|
|
|
|
|
|
|
|
|
|
if (record.baseId.empty())
|
|
|
|
|
{
|
|
|
|
|
world->getModifiableStore().overrideRecord(recordData);
|
|
|
|
|
}
|
2019-10-17 03:58:56 +00:00
|
|
|
else if (doesRecordIdExist<ESM::Lockpick>(record.baseId))
|
2019-07-27 00:45:50 +00:00
|
|
|
{
|
2019-10-17 03:58:56 +00:00
|
|
|
const ESM::Lockpick *baseData = world->getStore().get<ESM::Lockpick>().search(record.baseId);
|
|
|
|
|
ESM::Lockpick finalData = *baseData;
|
2019-07-27 00:45:50 +00:00
|
|
|
finalData.mId = recordData.mId;
|
|
|
|
|
|
|
|
|
|
if (record.baseOverrides.hasName)
|
|
|
|
|
finalData.mName = recordData.mName;
|
|
|
|
|
|
|
|
|
|
if (record.baseOverrides.hasModel)
|
|
|
|
|
finalData.mModel = recordData.mModel;
|
|
|
|
|
|
2019-10-17 03:58:56 +00:00
|
|
|
if (record.baseOverrides.hasIcon)
|
|
|
|
|
finalData.mIcon = recordData.mIcon;
|
|
|
|
|
|
2019-07-27 00:45:50 +00:00
|
|
|
if (record.baseOverrides.hasWeight)
|
2019-10-17 03:58:56 +00:00
|
|
|
finalData.mData.mWeight = recordData.mData.mWeight;
|
2019-07-27 00:45:50 +00:00
|
|
|
|
2019-10-17 03:58:56 +00:00
|
|
|
if (record.baseOverrides.hasValue)
|
|
|
|
|
finalData.mData.mValue = recordData.mData.mValue;
|
|
|
|
|
|
|
|
|
|
if (record.baseOverrides.hasQuality)
|
|
|
|
|
finalData.mData.mQuality = recordData.mData.mQuality;
|
|
|
|
|
|
|
|
|
|
if (record.baseOverrides.hasUses)
|
|
|
|
|
finalData.mData.mUses = recordData.mData.mUses;
|
2019-07-27 00:45:50 +00:00
|
|
|
|
|
|
|
|
if (record.baseOverrides.hasScript)
|
|
|
|
|
finalData.mScript = recordData.mScript;
|
|
|
|
|
|
|
|
|
|
world->getModifiableStore().overrideRecord(finalData);
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
2019-08-19 18:39:33 +00:00
|
|
|
LOG_APPEND(TimedLog::LOG_INFO, "-- Ignoring record override with invalid baseId %s", record.baseId.c_str());
|
2019-07-27 00:45:50 +00:00
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (isExistingId)
|
|
|
|
|
world->updatePtrsWithRefId(recordData.mId);
|
|
|
|
|
}
|
|
|
|
|
|
2019-10-17 03:58:56 +00:00
|
|
|
void RecordHelper::overrideRecord(const mwmp::MiscellaneousRecord& record)
|
2019-07-27 00:45:50 +00:00
|
|
|
{
|
2019-10-17 03:58:56 +00:00
|
|
|
const ESM::Miscellaneous &recordData = record.data;
|
2019-07-27 00:45:50 +00:00
|
|
|
|
|
|
|
|
if (recordData.mId.empty())
|
|
|
|
|
{
|
2019-08-19 18:39:33 +00:00
|
|
|
LOG_APPEND(TimedLog::LOG_INFO, "-- Ignoring record override with no id provided");
|
2019-07-27 00:45:50 +00:00
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
2019-10-17 03:58:56 +00:00
|
|
|
bool isExistingId = doesRecordIdExist<ESM::Miscellaneous>(recordData.mId);
|
2019-07-27 00:45:50 +00:00
|
|
|
MWBase::World *world = MWBase::Environment::get().getWorld();
|
|
|
|
|
|
|
|
|
|
if (record.baseId.empty())
|
|
|
|
|
{
|
|
|
|
|
world->getModifiableStore().overrideRecord(recordData);
|
|
|
|
|
}
|
2019-10-17 03:58:56 +00:00
|
|
|
else if (doesRecordIdExist<ESM::Miscellaneous>(record.baseId))
|
2019-07-27 00:45:50 +00:00
|
|
|
{
|
2019-10-17 03:58:56 +00:00
|
|
|
const ESM::Miscellaneous *baseData = world->getStore().get<ESM::Miscellaneous>().search(record.baseId);
|
|
|
|
|
ESM::Miscellaneous finalData = *baseData;
|
2019-07-27 00:45:50 +00:00
|
|
|
finalData.mId = recordData.mId;
|
|
|
|
|
|
|
|
|
|
if (record.baseOverrides.hasName)
|
|
|
|
|
finalData.mName = recordData.mName;
|
|
|
|
|
|
|
|
|
|
if (record.baseOverrides.hasModel)
|
|
|
|
|
finalData.mModel = recordData.mModel;
|
|
|
|
|
|
2019-10-17 03:58:56 +00:00
|
|
|
if (record.baseOverrides.hasIcon)
|
|
|
|
|
finalData.mIcon = recordData.mIcon;
|
|
|
|
|
|
|
|
|
|
if (record.baseOverrides.hasWeight)
|
|
|
|
|
finalData.mData.mWeight = recordData.mData.mWeight;
|
|
|
|
|
|
|
|
|
|
if (record.baseOverrides.hasValue)
|
|
|
|
|
finalData.mData.mValue = recordData.mData.mValue;
|
|
|
|
|
|
|
|
|
|
if (record.baseOverrides.hasKeyState)
|
|
|
|
|
finalData.mData.mIsKey = recordData.mData.mIsKey;
|
2019-07-27 00:45:50 +00:00
|
|
|
|
|
|
|
|
if (record.baseOverrides.hasScript)
|
|
|
|
|
finalData.mScript = recordData.mScript;
|
|
|
|
|
|
|
|
|
|
world->getModifiableStore().overrideRecord(finalData);
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
2019-08-19 18:39:33 +00:00
|
|
|
LOG_APPEND(TimedLog::LOG_INFO, "-- Ignoring record override with invalid baseId %s", record.baseId.c_str());
|
2019-07-27 00:45:50 +00:00
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (isExistingId)
|
|
|
|
|
world->updatePtrsWithRefId(recordData.mId);
|
|
|
|
|
}
|
|
|
|
|
|
2019-10-17 03:58:56 +00:00
|
|
|
void RecordHelper::overrideRecord(const mwmp::NpcRecord& record)
|
2019-08-01 06:48:57 +00:00
|
|
|
{
|
2019-10-17 03:58:56 +00:00
|
|
|
const ESM::NPC &recordData = record.data;
|
2019-08-01 06:48:57 +00:00
|
|
|
|
|
|
|
|
if (recordData.mId.empty())
|
|
|
|
|
{
|
2019-08-19 18:39:33 +00:00
|
|
|
LOG_APPEND(TimedLog::LOG_INFO, "-- Ignoring record override with no id provided");
|
2019-08-01 06:48:57 +00:00
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
2019-10-17 03:58:56 +00:00
|
|
|
bool isExistingId = doesRecordIdExist<ESM::NPC>(recordData.mId);
|
2019-08-01 06:48:57 +00:00
|
|
|
MWBase::World *world = MWBase::Environment::get().getWorld();
|
|
|
|
|
|
|
|
|
|
if (record.baseId.empty())
|
|
|
|
|
{
|
2019-10-17 03:58:56 +00:00
|
|
|
if (!doesRecordIdExist<ESM::Race>(recordData.mRace))
|
|
|
|
|
{
|
|
|
|
|
LOG_APPEND(TimedLog::LOG_INFO, "-- Ignoring new NPC record with invalid race provided");
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
else if (!doesRecordIdExist<ESM::Class>(recordData.mClass))
|
|
|
|
|
{
|
|
|
|
|
LOG_APPEND(TimedLog::LOG_INFO, "-- Ignoring new NPC record with invalid class provided");
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
world->getModifiableStore().overrideRecord(recordData);
|
2019-08-01 06:48:57 +00:00
|
|
|
}
|
2019-10-17 03:58:56 +00:00
|
|
|
else if (doesRecordIdExist<ESM::NPC>(record.baseId))
|
2019-08-01 06:48:57 +00:00
|
|
|
{
|
2019-10-17 03:58:56 +00:00
|
|
|
const ESM::NPC *baseData = world->getStore().get<ESM::NPC>().search(record.baseId);
|
|
|
|
|
ESM::NPC finalData = *baseData;
|
2019-08-01 06:48:57 +00:00
|
|
|
finalData.mId = recordData.mId;
|
|
|
|
|
|
|
|
|
|
if (record.baseOverrides.hasName)
|
|
|
|
|
finalData.mName = recordData.mName;
|
|
|
|
|
|
2019-10-17 03:58:56 +00:00
|
|
|
if (record.baseOverrides.hasFlags)
|
|
|
|
|
finalData.mFlags = recordData.mFlags;
|
|
|
|
|
|
|
|
|
|
// Because the gender is part of mFlags and can easily be set incorrectly there,
|
|
|
|
|
// we handle it separately here
|
|
|
|
|
if (record.baseOverrides.hasGender)
|
|
|
|
|
finalData.setIsMale(recordData.isMale());
|
|
|
|
|
else
|
|
|
|
|
finalData.setIsMale(baseData->isMale());
|
|
|
|
|
|
2019-11-29 11:28:07 +00:00
|
|
|
if (record.baseOverrides.hasRace)
|
2019-10-17 03:58:56 +00:00
|
|
|
finalData.mRace = recordData.mRace;
|
|
|
|
|
|
2019-08-01 06:48:57 +00:00
|
|
|
if (record.baseOverrides.hasModel)
|
|
|
|
|
finalData.mModel = recordData.mModel;
|
|
|
|
|
|
2019-10-17 03:58:56 +00:00
|
|
|
if (record.baseOverrides.hasHair)
|
|
|
|
|
finalData.mHair = recordData.mHair;
|
|
|
|
|
|
|
|
|
|
if (record.baseOverrides.hasHead)
|
|
|
|
|
finalData.mHead = recordData.mHead;
|
|
|
|
|
|
|
|
|
|
if (!recordData.mClass.empty())
|
|
|
|
|
finalData.mClass = recordData.mClass;
|
|
|
|
|
|
|
|
|
|
if (record.baseOverrides.hasFaction)
|
|
|
|
|
finalData.mFaction = recordData.mFaction;
|
|
|
|
|
|
2019-08-01 06:48:57 +00:00
|
|
|
if (record.baseOverrides.hasScript)
|
|
|
|
|
finalData.mScript = recordData.mScript;
|
|
|
|
|
|
2019-10-17 03:58:56 +00:00
|
|
|
if (record.baseOverrides.hasLevel)
|
|
|
|
|
finalData.mNpdt.mLevel = recordData.mNpdt.mLevel;
|
2019-08-01 06:48:57 +00:00
|
|
|
|
2019-10-17 03:58:56 +00:00
|
|
|
if (record.baseOverrides.hasHealth)
|
|
|
|
|
finalData.mNpdt.mHealth = recordData.mNpdt.mHealth;
|
2019-08-01 06:48:57 +00:00
|
|
|
|
2019-10-17 03:58:56 +00:00
|
|
|
if (record.baseOverrides.hasMagicka)
|
|
|
|
|
finalData.mNpdt.mMana = recordData.mNpdt.mMana;
|
2019-08-01 06:48:57 +00:00
|
|
|
|
2019-10-17 03:58:56 +00:00
|
|
|
if (record.baseOverrides.hasFatigue)
|
|
|
|
|
finalData.mNpdt.mFatigue = recordData.mNpdt.mFatigue;
|
2019-08-01 06:48:57 +00:00
|
|
|
|
2019-10-17 03:58:56 +00:00
|
|
|
if (record.baseOverrides.hasAiFight)
|
|
|
|
|
finalData.mAiData.mFight = recordData.mAiData.mFight;
|
2019-08-01 06:48:57 +00:00
|
|
|
|
2019-10-17 03:58:56 +00:00
|
|
|
if (record.baseOverrides.hasAiFlee)
|
|
|
|
|
finalData.mAiData.mFlee = recordData.mAiData.mFlee;
|
|
|
|
|
|
|
|
|
|
if (record.baseOverrides.hasAiAlarm)
|
|
|
|
|
finalData.mAiData.mAlarm = recordData.mAiData.mAlarm;
|
|
|
|
|
|
|
|
|
|
if (record.baseOverrides.hasAiServices)
|
|
|
|
|
finalData.mAiData.mServices = recordData.mAiData.mServices;
|
|
|
|
|
|
|
|
|
|
if (record.baseOverrides.hasFlags)
|
|
|
|
|
finalData.mFlags = recordData.mFlags;
|
|
|
|
|
|
|
|
|
|
if (record.baseOverrides.hasAutoCalc)
|
|
|
|
|
{
|
|
|
|
|
finalData.mNpdtType = recordData.mNpdtType;
|
|
|
|
|
|
|
|
|
|
if ((recordData.mFlags & ESM::NPC::Autocalc) != 0)
|
|
|
|
|
finalData.mFlags |= ESM::NPC::Autocalc;
|
|
|
|
|
else
|
|
|
|
|
finalData.mFlags &= ~ESM::NPC::Autocalc;
|
|
|
|
|
}
|
2019-08-01 06:48:57 +00:00
|
|
|
|
2019-10-17 03:58:56 +00:00
|
|
|
if (!record.inventoryBaseId.empty() && doesRecordIdExist<ESM::NPC>(record.inventoryBaseId))
|
|
|
|
|
finalData.mInventory.mList = world->getStore().get<ESM::NPC>().search(record.inventoryBaseId)->mInventory.mList;
|
|
|
|
|
else if (record.baseOverrides.hasInventory)
|
|
|
|
|
finalData.mInventory.mList = recordData.mInventory.mList;
|
2019-08-01 06:48:57 +00:00
|
|
|
|
|
|
|
|
world->getModifiableStore().overrideRecord(finalData);
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
2019-08-19 18:39:33 +00:00
|
|
|
LOG_APPEND(TimedLog::LOG_INFO, "-- Ignoring record override with invalid baseId %s", record.baseId.c_str());
|
2019-08-01 06:48:57 +00:00
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (isExistingId)
|
|
|
|
|
world->updatePtrsWithRefId(recordData.mId);
|
|
|
|
|
}
|
|
|
|
|
|
2019-10-17 03:58:56 +00:00
|
|
|
void RecordHelper::overrideRecord(const mwmp::PotionRecord& record)
|
2019-08-03 03:19:22 +00:00
|
|
|
{
|
2019-10-17 03:58:56 +00:00
|
|
|
const ESM::Potion &recordData = record.data;
|
2019-08-03 03:19:22 +00:00
|
|
|
|
|
|
|
|
if (recordData.mId.empty())
|
|
|
|
|
{
|
2019-08-19 18:39:33 +00:00
|
|
|
LOG_APPEND(TimedLog::LOG_INFO, "-- Ignoring record override with no id provided");
|
2019-08-03 03:19:22 +00:00
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
2019-10-17 03:58:56 +00:00
|
|
|
bool isExistingId = doesRecordIdExist<ESM::Potion>(recordData.mId);
|
2019-08-03 03:19:22 +00:00
|
|
|
MWBase::World *world = MWBase::Environment::get().getWorld();
|
|
|
|
|
|
|
|
|
|
if (record.baseId.empty())
|
|
|
|
|
{
|
|
|
|
|
world->getModifiableStore().overrideRecord(recordData);
|
|
|
|
|
}
|
2019-10-17 03:58:56 +00:00
|
|
|
else if (doesRecordIdExist<ESM::Potion>(record.baseId))
|
2019-08-03 03:19:22 +00:00
|
|
|
{
|
2019-10-17 03:58:56 +00:00
|
|
|
const ESM::Potion *baseData = world->getStore().get<ESM::Potion>().search(record.baseId);
|
|
|
|
|
ESM::Potion finalData = *baseData;
|
2019-08-03 03:19:22 +00:00
|
|
|
finalData.mId = recordData.mId;
|
|
|
|
|
|
|
|
|
|
if (record.baseOverrides.hasName)
|
|
|
|
|
finalData.mName = recordData.mName;
|
|
|
|
|
|
|
|
|
|
if (record.baseOverrides.hasModel)
|
|
|
|
|
finalData.mModel = recordData.mModel;
|
|
|
|
|
|
|
|
|
|
if (record.baseOverrides.hasIcon)
|
|
|
|
|
finalData.mIcon = recordData.mIcon;
|
|
|
|
|
|
|
|
|
|
if (record.baseOverrides.hasWeight)
|
|
|
|
|
finalData.mData.mWeight = recordData.mData.mWeight;
|
|
|
|
|
|
|
|
|
|
if (record.baseOverrides.hasValue)
|
|
|
|
|
finalData.mData.mValue = recordData.mData.mValue;
|
|
|
|
|
|
2019-10-17 03:58:56 +00:00
|
|
|
if (record.baseOverrides.hasAutoCalc)
|
|
|
|
|
finalData.mData.mAutoCalc = recordData.mData.mAutoCalc;
|
|
|
|
|
|
2019-08-03 03:19:22 +00:00
|
|
|
if (record.baseOverrides.hasScript)
|
|
|
|
|
finalData.mScript = recordData.mScript;
|
|
|
|
|
|
|
|
|
|
if (record.baseOverrides.hasEffects)
|
2019-10-17 03:58:56 +00:00
|
|
|
finalData.mEffects.mList = recordData.mEffects.mList;
|
2019-08-03 03:19:22 +00:00
|
|
|
|
|
|
|
|
world->getModifiableStore().overrideRecord(finalData);
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
2019-08-19 18:39:33 +00:00
|
|
|
LOG_APPEND(TimedLog::LOG_INFO, "-- Ignoring record override with invalid baseId %s", record.baseId.c_str());
|
2019-08-03 03:19:22 +00:00
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (isExistingId)
|
|
|
|
|
world->updatePtrsWithRefId(recordData.mId);
|
|
|
|
|
}
|
|
|
|
|
|
2019-10-17 03:58:56 +00:00
|
|
|
void RecordHelper::overrideRecord(const mwmp::ProbeRecord& record)
|
2019-08-04 14:53:18 +00:00
|
|
|
{
|
2019-10-17 03:58:56 +00:00
|
|
|
const ESM::Probe &recordData = record.data;
|
2019-08-04 14:53:18 +00:00
|
|
|
|
|
|
|
|
if (recordData.mId.empty())
|
|
|
|
|
{
|
2019-08-19 18:39:33 +00:00
|
|
|
LOG_APPEND(TimedLog::LOG_INFO, "-- Ignoring record override with no id provided");
|
2019-08-04 14:53:18 +00:00
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
2019-10-17 03:58:56 +00:00
|
|
|
bool isExistingId = doesRecordIdExist<ESM::Probe>(recordData.mId);
|
2019-08-04 14:53:18 +00:00
|
|
|
MWBase::World *world = MWBase::Environment::get().getWorld();
|
|
|
|
|
|
|
|
|
|
if (record.baseId.empty())
|
|
|
|
|
{
|
|
|
|
|
world->getModifiableStore().overrideRecord(recordData);
|
|
|
|
|
}
|
2019-10-17 03:58:56 +00:00
|
|
|
else if (doesRecordIdExist<ESM::Probe>(record.baseId))
|
2019-08-04 14:53:18 +00:00
|
|
|
{
|
2019-10-17 03:58:56 +00:00
|
|
|
const ESM::Probe *baseData = world->getStore().get<ESM::Probe>().search(record.baseId);
|
|
|
|
|
ESM::Probe finalData = *baseData;
|
2019-08-04 14:53:18 +00:00
|
|
|
finalData.mId = recordData.mId;
|
|
|
|
|
|
|
|
|
|
if (record.baseOverrides.hasName)
|
|
|
|
|
finalData.mName = recordData.mName;
|
|
|
|
|
|
|
|
|
|
if (record.baseOverrides.hasModel)
|
|
|
|
|
finalData.mModel = recordData.mModel;
|
|
|
|
|
|
|
|
|
|
if (record.baseOverrides.hasIcon)
|
|
|
|
|
finalData.mIcon = recordData.mIcon;
|
|
|
|
|
|
|
|
|
|
if (record.baseOverrides.hasWeight)
|
|
|
|
|
finalData.mData.mWeight = recordData.mData.mWeight;
|
|
|
|
|
|
|
|
|
|
if (record.baseOverrides.hasValue)
|
|
|
|
|
finalData.mData.mValue = recordData.mData.mValue;
|
|
|
|
|
|
|
|
|
|
if (record.baseOverrides.hasQuality)
|
|
|
|
|
finalData.mData.mQuality = recordData.mData.mQuality;
|
|
|
|
|
|
2019-10-17 03:58:56 +00:00
|
|
|
if (record.baseOverrides.hasUses)
|
|
|
|
|
finalData.mData.mUses = recordData.mData.mUses;
|
|
|
|
|
|
2019-08-04 14:53:18 +00:00
|
|
|
if (record.baseOverrides.hasScript)
|
|
|
|
|
finalData.mScript = recordData.mScript;
|
|
|
|
|
|
|
|
|
|
world->getModifiableStore().overrideRecord(finalData);
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
2019-08-19 18:39:33 +00:00
|
|
|
LOG_APPEND(TimedLog::LOG_INFO, "-- Ignoring record override with invalid baseId %s", record.baseId.c_str());
|
2019-08-04 14:53:18 +00:00
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (isExistingId)
|
|
|
|
|
world->updatePtrsWithRefId(recordData.mId);
|
|
|
|
|
}
|
|
|
|
|
|
2019-10-17 03:58:56 +00:00
|
|
|
void RecordHelper::overrideRecord(const mwmp::RepairRecord& record)
|
2019-08-04 14:53:18 +00:00
|
|
|
{
|
2019-10-17 03:58:56 +00:00
|
|
|
const ESM::Repair &recordData = record.data;
|
2019-08-04 14:53:18 +00:00
|
|
|
|
|
|
|
|
if (recordData.mId.empty())
|
|
|
|
|
{
|
2019-08-19 18:39:33 +00:00
|
|
|
LOG_APPEND(TimedLog::LOG_INFO, "-- Ignoring record override with no id provided");
|
2019-08-04 14:53:18 +00:00
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
2019-10-17 03:58:56 +00:00
|
|
|
bool isExistingId = doesRecordIdExist<ESM::Repair>(recordData.mId);
|
2019-08-04 14:53:18 +00:00
|
|
|
MWBase::World *world = MWBase::Environment::get().getWorld();
|
|
|
|
|
|
|
|
|
|
if (record.baseId.empty())
|
|
|
|
|
{
|
|
|
|
|
world->getModifiableStore().overrideRecord(recordData);
|
|
|
|
|
}
|
2019-10-17 03:58:56 +00:00
|
|
|
else if (doesRecordIdExist<ESM::Repair>(record.baseId))
|
2019-08-04 14:53:18 +00:00
|
|
|
{
|
2019-10-17 03:58:56 +00:00
|
|
|
const ESM::Repair *baseData = world->getStore().get<ESM::Repair>().search(record.baseId);
|
|
|
|
|
ESM::Repair finalData = *baseData;
|
2019-08-04 14:53:18 +00:00
|
|
|
finalData.mId = recordData.mId;
|
|
|
|
|
|
|
|
|
|
if (record.baseOverrides.hasName)
|
|
|
|
|
finalData.mName = recordData.mName;
|
|
|
|
|
|
|
|
|
|
if (record.baseOverrides.hasModel)
|
|
|
|
|
finalData.mModel = recordData.mModel;
|
|
|
|
|
|
|
|
|
|
if (record.baseOverrides.hasIcon)
|
|
|
|
|
finalData.mIcon = recordData.mIcon;
|
|
|
|
|
|
|
|
|
|
if (record.baseOverrides.hasWeight)
|
|
|
|
|
finalData.mData.mWeight = recordData.mData.mWeight;
|
|
|
|
|
|
|
|
|
|
if (record.baseOverrides.hasValue)
|
|
|
|
|
finalData.mData.mValue = recordData.mData.mValue;
|
|
|
|
|
|
|
|
|
|
if (record.baseOverrides.hasQuality)
|
|
|
|
|
finalData.mData.mQuality = recordData.mData.mQuality;
|
|
|
|
|
|
|
|
|
|
if (record.baseOverrides.hasUses)
|
|
|
|
|
finalData.mData.mUses = recordData.mData.mUses;
|
|
|
|
|
|
|
|
|
|
if (record.baseOverrides.hasScript)
|
|
|
|
|
finalData.mScript = recordData.mScript;
|
|
|
|
|
|
|
|
|
|
world->getModifiableStore().overrideRecord(finalData);
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
2019-08-19 18:39:33 +00:00
|
|
|
LOG_APPEND(TimedLog::LOG_INFO, "-- Ignoring record override with invalid baseId %s", record.baseId.c_str());
|
2019-08-04 14:53:18 +00:00
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (isExistingId)
|
|
|
|
|
world->updatePtrsWithRefId(recordData.mId);
|
|
|
|
|
}
|
|
|
|
|
|
2019-11-09 19:34:09 +00:00
|
|
|
void RecordHelper::overrideRecord(const mwmp::ScriptRecord& record)
|
|
|
|
|
{
|
|
|
|
|
const ESM::Script &recordData = record.data;
|
|
|
|
|
|
|
|
|
|
if (recordData.mId.empty())
|
|
|
|
|
{
|
|
|
|
|
LOG_APPEND(TimedLog::LOG_INFO, "-- Ignoring record override with no id provided");
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
MWBase::World *world = MWBase::Environment::get().getWorld();
|
|
|
|
|
|
|
|
|
|
if (record.baseId.empty())
|
|
|
|
|
{
|
|
|
|
|
world->getModifiableStore().overrideRecord(recordData);
|
|
|
|
|
}
|
|
|
|
|
else if (doesRecordIdExist<ESM::Script>(record.baseId))
|
|
|
|
|
{
|
|
|
|
|
const ESM::Script *baseData = world->getStore().get<ESM::Script>().search(record.baseId);
|
|
|
|
|
ESM::Script finalData = *baseData;
|
|
|
|
|
finalData.mId = recordData.mId;
|
|
|
|
|
|
|
|
|
|
if (record.baseOverrides.hasScriptText)
|
|
|
|
|
finalData.mScriptText = recordData.mScriptText;
|
|
|
|
|
|
|
|
|
|
world->getModifiableStore().overrideRecord(finalData);
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
LOG_APPEND(TimedLog::LOG_INFO, "-- Ignoring record override with invalid baseId %s", record.baseId.c_str());
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2021-01-17 14:04:12 +00:00
|
|
|
void RecordHelper::overrideRecord(const mwmp::SoundRecord& record)
|
|
|
|
|
{
|
|
|
|
|
const ESM::Sound& recordData = record.data;
|
|
|
|
|
|
|
|
|
|
if (recordData.mId.empty())
|
|
|
|
|
{
|
|
|
|
|
LOG_APPEND(TimedLog::LOG_INFO, "-- Ignoring record override with no id provided");
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
bool isExistingId = doesRecordIdExist<ESM::Sound>(recordData.mId);
|
|
|
|
|
MWBase::World* world = MWBase::Environment::get().getWorld();
|
|
|
|
|
|
|
|
|
|
if (record.baseId.empty())
|
|
|
|
|
{
|
|
|
|
|
world->getModifiableStore().overrideRecord(recordData);
|
|
|
|
|
}
|
|
|
|
|
else if (doesRecordIdExist<ESM::Sound>(record.baseId))
|
|
|
|
|
{
|
|
|
|
|
const ESM::Sound* baseData = world->getStore().get<ESM::Sound>().search(record.baseId);
|
|
|
|
|
ESM::Sound finalData = *baseData;
|
|
|
|
|
finalData.mId = recordData.mId;
|
|
|
|
|
|
|
|
|
|
if (record.baseOverrides.hasSound)
|
|
|
|
|
finalData.mSound = recordData.mSound;
|
|
|
|
|
|
|
|
|
|
if (record.baseOverrides.hasVolume)
|
|
|
|
|
finalData.mData.mVolume = recordData.mData.mVolume;
|
|
|
|
|
|
|
|
|
|
if (record.baseOverrides.hasMinRange)
|
|
|
|
|
finalData.mData.mMinRange = recordData.mData.mMinRange;
|
|
|
|
|
|
|
|
|
|
if (record.baseOverrides.hasMaxRange)
|
|
|
|
|
finalData.mData.mMaxRange = recordData.mData.mMaxRange;
|
|
|
|
|
|
|
|
|
|
world->getModifiableStore().overrideRecord(finalData);
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
LOG_APPEND(TimedLog::LOG_INFO, "-- Ignoring record override with invalid baseId %s", record.baseId.c_str());
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (isExistingId)
|
|
|
|
|
world->updatePtrsWithRefId(recordData.mId);
|
|
|
|
|
}
|
|
|
|
|
|
2019-10-17 03:58:56 +00:00
|
|
|
void RecordHelper::overrideRecord(const mwmp::SpellRecord& record)
|
2019-08-04 14:53:18 +00:00
|
|
|
{
|
2019-10-17 03:58:56 +00:00
|
|
|
const ESM::Spell &recordData = record.data;
|
2019-08-04 14:53:18 +00:00
|
|
|
|
|
|
|
|
if (recordData.mId.empty())
|
|
|
|
|
{
|
2019-08-19 18:39:33 +00:00
|
|
|
LOG_APPEND(TimedLog::LOG_INFO, "-- Ignoring record override with no id provided");
|
2019-08-04 14:53:18 +00:00
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
2019-10-17 03:58:56 +00:00
|
|
|
bool isExistingId = doesRecordIdExist<ESM::Spell>(recordData.mId);
|
2019-08-04 14:53:18 +00:00
|
|
|
MWBase::World *world = MWBase::Environment::get().getWorld();
|
|
|
|
|
|
|
|
|
|
if (record.baseId.empty())
|
|
|
|
|
{
|
|
|
|
|
world->getModifiableStore().overrideRecord(recordData);
|
|
|
|
|
}
|
2019-10-17 03:58:56 +00:00
|
|
|
else if (doesRecordIdExist<ESM::Spell>(record.baseId))
|
2019-08-04 14:53:18 +00:00
|
|
|
{
|
2019-10-17 03:58:56 +00:00
|
|
|
const ESM::Spell *baseData = world->getStore().get<ESM::Spell>().search(record.baseId);
|
|
|
|
|
ESM::Spell finalData = *baseData;
|
2019-08-04 14:53:18 +00:00
|
|
|
finalData.mId = recordData.mId;
|
|
|
|
|
|
|
|
|
|
if (record.baseOverrides.hasName)
|
|
|
|
|
finalData.mName = recordData.mName;
|
|
|
|
|
|
2019-10-17 03:58:56 +00:00
|
|
|
if (record.baseOverrides.hasSubtype)
|
|
|
|
|
finalData.mData.mType = recordData.mData.mType;
|
2019-08-04 14:53:18 +00:00
|
|
|
|
2019-10-17 03:58:56 +00:00
|
|
|
if (record.baseOverrides.hasCost)
|
|
|
|
|
finalData.mData.mCost = recordData.mData.mCost;
|
2019-08-04 14:53:18 +00:00
|
|
|
|
2019-10-17 03:58:56 +00:00
|
|
|
if (record.baseOverrides.hasFlags)
|
|
|
|
|
finalData.mData.mFlags = recordData.mData.mFlags;
|
2019-08-04 14:53:18 +00:00
|
|
|
|
2019-10-17 03:58:56 +00:00
|
|
|
if (record.baseOverrides.hasEffects)
|
|
|
|
|
finalData.mEffects.mList = recordData.mEffects.mList;
|
2019-08-04 14:53:18 +00:00
|
|
|
|
|
|
|
|
world->getModifiableStore().overrideRecord(finalData);
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
2019-08-19 18:39:33 +00:00
|
|
|
LOG_APPEND(TimedLog::LOG_INFO, "-- Ignoring record override with invalid baseId %s", record.baseId.c_str());
|
2019-08-04 14:53:18 +00:00
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2019-10-17 03:58:56 +00:00
|
|
|
void RecordHelper::overrideRecord(const mwmp::StaticRecord& record)
|
2019-08-04 14:53:18 +00:00
|
|
|
{
|
2019-10-17 03:58:56 +00:00
|
|
|
const ESM::Static &recordData = record.data;
|
2019-08-04 14:53:18 +00:00
|
|
|
|
|
|
|
|
if (recordData.mId.empty())
|
|
|
|
|
{
|
2019-08-19 18:39:33 +00:00
|
|
|
LOG_APPEND(TimedLog::LOG_INFO, "-- Ignoring record override with no id provided");
|
2019-08-04 14:53:18 +00:00
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
2019-10-17 03:58:56 +00:00
|
|
|
bool isExistingId = doesRecordIdExist<ESM::Static>(recordData.mId);
|
2019-08-04 14:53:18 +00:00
|
|
|
MWBase::World *world = MWBase::Environment::get().getWorld();
|
|
|
|
|
|
|
|
|
|
if (record.baseId.empty())
|
|
|
|
|
{
|
|
|
|
|
world->getModifiableStore().overrideRecord(recordData);
|
|
|
|
|
}
|
2019-10-17 03:58:56 +00:00
|
|
|
else if (doesRecordIdExist<ESM::Static>(record.baseId))
|
2019-08-04 14:53:18 +00:00
|
|
|
{
|
2019-10-17 03:58:56 +00:00
|
|
|
const ESM::Static *baseData = world->getStore().get<ESM::Static>().search(record.baseId);
|
|
|
|
|
ESM::Static finalData = *baseData;
|
2019-08-04 14:53:18 +00:00
|
|
|
finalData.mId = recordData.mId;
|
|
|
|
|
|
|
|
|
|
if (record.baseOverrides.hasModel)
|
|
|
|
|
finalData.mModel = recordData.mModel;
|
|
|
|
|
|
|
|
|
|
world->getModifiableStore().overrideRecord(finalData);
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
2019-08-19 18:39:33 +00:00
|
|
|
LOG_APPEND(TimedLog::LOG_INFO, "-- Ignoring record override with invalid baseId %s", record.baseId.c_str());
|
2019-08-04 14:53:18 +00:00
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (isExistingId)
|
|
|
|
|
world->updatePtrsWithRefId(recordData.mId);
|
|
|
|
|
}
|
|
|
|
|
|
2019-10-17 03:58:56 +00:00
|
|
|
void RecordHelper::overrideRecord(const mwmp::WeaponRecord& record)
|
2019-08-14 18:10:53 +00:00
|
|
|
{
|
2019-10-17 03:58:56 +00:00
|
|
|
const ESM::Weapon &recordData = record.data;
|
2019-08-14 18:10:53 +00:00
|
|
|
|
|
|
|
|
if (recordData.mId.empty())
|
|
|
|
|
{
|
2019-08-19 18:39:33 +00:00
|
|
|
LOG_APPEND(TimedLog::LOG_INFO, "-- Ignoring record override with no id provided");
|
2019-08-14 18:10:53 +00:00
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
2019-10-17 03:58:56 +00:00
|
|
|
bool isExistingId = doesRecordIdExist<ESM::Weapon>(recordData.mId);
|
2019-08-14 18:10:53 +00:00
|
|
|
MWBase::World *world = MWBase::Environment::get().getWorld();
|
|
|
|
|
|
|
|
|
|
if (record.baseId.empty())
|
|
|
|
|
{
|
2019-10-17 03:58:56 +00:00
|
|
|
if (!recordData.mEnchant.empty() && !doesRecordIdExist<ESM::Enchantment>(recordData.mEnchant))
|
|
|
|
|
{
|
|
|
|
|
LOG_APPEND(TimedLog::LOG_INFO, "-- Ignoring new weapon record with invalid enchantmentId %s", recordData.mEnchant.c_str());
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
world->getModifiableStore().overrideRecord(recordData);
|
2019-08-14 18:10:53 +00:00
|
|
|
}
|
2019-10-17 03:58:56 +00:00
|
|
|
else if (doesRecordIdExist<ESM::Weapon>(record.baseId))
|
2019-08-14 18:10:53 +00:00
|
|
|
{
|
2019-10-17 03:58:56 +00:00
|
|
|
const ESM::Weapon *baseData = world->getStore().get<ESM::Weapon>().search(record.baseId);
|
|
|
|
|
ESM::Weapon finalData = *baseData;
|
2019-08-14 18:10:53 +00:00
|
|
|
finalData.mId = recordData.mId;
|
|
|
|
|
|
|
|
|
|
if (record.baseOverrides.hasName)
|
|
|
|
|
finalData.mName = recordData.mName;
|
|
|
|
|
|
|
|
|
|
if (record.baseOverrides.hasModel)
|
|
|
|
|
finalData.mModel = recordData.mModel;
|
|
|
|
|
|
|
|
|
|
if (record.baseOverrides.hasIcon)
|
|
|
|
|
finalData.mIcon = recordData.mIcon;
|
|
|
|
|
|
2019-10-17 03:58:56 +00:00
|
|
|
if (record.baseOverrides.hasSubtype)
|
|
|
|
|
finalData.mData.mType = recordData.mData.mType;
|
2019-08-14 18:10:53 +00:00
|
|
|
|
|
|
|
|
if (record.baseOverrides.hasWeight)
|
|
|
|
|
finalData.mData.mWeight = recordData.mData.mWeight;
|
|
|
|
|
|
|
|
|
|
if (record.baseOverrides.hasValue)
|
|
|
|
|
finalData.mData.mValue = recordData.mData.mValue;
|
|
|
|
|
|
2019-10-17 03:58:56 +00:00
|
|
|
if (record.baseOverrides.hasHealth)
|
|
|
|
|
finalData.mData.mHealth = recordData.mData.mHealth;
|
2019-08-14 18:10:53 +00:00
|
|
|
|
2019-10-17 03:58:56 +00:00
|
|
|
if (record.baseOverrides.hasSpeed)
|
|
|
|
|
finalData.mData.mSpeed = recordData.mData.mSpeed;
|
2019-08-14 18:10:53 +00:00
|
|
|
|
2019-10-17 03:58:56 +00:00
|
|
|
if (record.baseOverrides.hasReach)
|
|
|
|
|
finalData.mData.mReach = recordData.mData.mReach;
|
|
|
|
|
|
|
|
|
|
if (record.baseOverrides.hasDamageChop)
|
|
|
|
|
{
|
|
|
|
|
finalData.mData.mChop[0] = recordData.mData.mChop[0];
|
|
|
|
|
finalData.mData.mChop[1] = recordData.mData.mChop[1];
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (record.baseOverrides.hasDamageSlash)
|
|
|
|
|
{
|
|
|
|
|
finalData.mData.mSlash[0] = recordData.mData.mSlash[0];
|
|
|
|
|
finalData.mData.mSlash[1] = recordData.mData.mSlash[1];
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (record.baseOverrides.hasDamageThrust)
|
|
|
|
|
{
|
|
|
|
|
finalData.mData.mThrust[0] = recordData.mData.mThrust[0];
|
|
|
|
|
finalData.mData.mThrust[1] = recordData.mData.mThrust[1];
|
|
|
|
|
}
|
2019-08-14 18:10:53 +00:00
|
|
|
|
|
|
|
|
if (record.baseOverrides.hasFlags)
|
|
|
|
|
finalData.mData.mFlags = recordData.mData.mFlags;
|
|
|
|
|
|
2019-10-17 03:58:56 +00:00
|
|
|
if (record.baseOverrides.hasEnchantmentId)
|
|
|
|
|
{
|
|
|
|
|
if (recordData.mEnchant.empty() || doesRecordIdExist<ESM::Enchantment>(recordData.mEnchant))
|
|
|
|
|
finalData.mEnchant = recordData.mEnchant;
|
|
|
|
|
else
|
|
|
|
|
LOG_APPEND(TimedLog::LOG_INFO, "-- Ignoring invalid enchantmentId %s", recordData.mEnchant.c_str());
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (record.baseOverrides.hasEnchantmentCharge)
|
|
|
|
|
finalData.mData.mEnchant = recordData.mData.mEnchant;
|
|
|
|
|
|
2019-08-14 18:10:53 +00:00
|
|
|
if (record.baseOverrides.hasScript)
|
|
|
|
|
finalData.mScript = recordData.mScript;
|
|
|
|
|
|
|
|
|
|
world->getModifiableStore().overrideRecord(finalData);
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
2019-08-19 18:39:33 +00:00
|
|
|
LOG_APPEND(TimedLog::LOG_INFO, "-- Ignoring record override with invalid baseId %s", record.baseId.c_str());
|
2019-08-14 18:10:53 +00:00
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (isExistingId)
|
|
|
|
|
world->updatePtrsWithRefId(recordData.mId);
|
|
|
|
|
}
|
2020-03-15 18:17:00 +00:00
|
|
|
|
2020-08-06 14:25:12 +00:00
|
|
|
void RecordHelper::createPlaceholderInteriorCell()
|
|
|
|
|
{
|
|
|
|
|
MWBase::World* world = MWBase::Environment::get().getWorld();
|
|
|
|
|
|
|
|
|
|
ESM::Cell placeholderInterior;
|
|
|
|
|
placeholderInterior.mData.mFlags |= ESM::Cell::Flags::Interior;
|
|
|
|
|
placeholderInterior.mName = placeholderInteriorCellName;
|
|
|
|
|
|
|
|
|
|
world->getModifiableStore().insert(placeholderInterior);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
const std::string RecordHelper::getPlaceholderInteriorCellName()
|
|
|
|
|
{
|
|
|
|
|
return placeholderInteriorCellName;
|
|
|
|
|
}
|
