bool MoveEvents::registerEvent(Event* event, const pugi::xml_node& node)
{
MoveEvent* moveEvent = dynamic_cast<MoveEvent*>(event);
if (!moveEvent) {
return false;
}
bool success = true;
MoveEvent_t eventType = moveEvent->getEventType();
if (eventType == MOVE_EVENT_ADD_ITEM || eventType == MOVE_EVENT_REMOVE_ITEM) {
pugi::xml_attribute tileItemAttribute = node.attribute("tileitem");
if (tileItemAttribute && pugi::cast<uint16_t>(tileItemAttribute.value()) == 1) {
switch (eventType) {
case MOVE_EVENT_ADD_ITEM:
moveEvent->setEventType(MOVE_EVENT_ADD_ITEM_ITEMTILE);
break;
case MOVE_EVENT_REMOVE_ITEM:
moveEvent->setEventType(MOVE_EVENT_REMOVE_ITEM_ITEMTILE);
break;
default:
break;
}
}
}
pugi::xml_attribute attr;
if ((attr = node.attribute("itemid"))) {
int32_t id = pugi::cast<int32_t>(attr.value());
addEvent(moveEvent, id, m_itemIdMap);
if (moveEvent->getEventType() == MOVE_EVENT_EQUIP) {
ItemType& it = Item::items.getItemType(id);
it.wieldInfo = moveEvent->getWieldInfo();
it.minReqLevel = moveEvent->getReqLevel();
it.minReqMagicLevel = moveEvent->getReqMagLv();
it.vocationString = moveEvent->getVocationString();
}
} else if ((attr = node.attribute("fromid"))) {
int32_t id = pugi::cast<int32_t>(attr.value());
int32_t endId = pugi::cast<int32_t>(node.attribute("toid").value());
addEvent(moveEvent, id, m_itemIdMap);
if (moveEvent->getEventType() == MOVE_EVENT_EQUIP) {
ItemType& it = Item::items.getItemType(id);
it.wieldInfo = moveEvent->getWieldInfo();
it.minReqLevel = moveEvent->getReqLevel();
it.minReqMagicLevel = moveEvent->getReqMagLv();
it.vocationString = moveEvent->getVocationString();
while (++id <= endId) {
addEvent(moveEvent, id, m_itemIdMap);
ItemType& tit = Item::items.getItemType(id);
tit.wieldInfo = moveEvent->getWieldInfo();
tit.minReqLevel = moveEvent->getReqLevel();
tit.minReqMagicLevel = moveEvent->getReqMagLv();
tit.vocationString = moveEvent->getVocationString();
}
} else {
while (++id <= endId) {
addEvent(moveEvent, id, m_itemIdMap);
}
}
} else if ((attr = node.attribute("uniqueid"))) {
addEvent(moveEvent, pugi::cast<int32_t>(attr.value()), m_uniqueIdMap);
} else if ((attr = node.attribute("fromuid"))) {
int32_t id = pugi::cast<int32_t>(attr.value());
int32_t endId = pugi::cast<int32_t>(node.attribute("touid").value());
addEvent(moveEvent, id, m_uniqueIdMap);
while (++id <= endId) {
addEvent(moveEvent, id, m_uniqueIdMap);
}
} else if ((attr = node.attribute("actionid"))) {
addEvent(moveEvent, pugi::cast<int32_t>(attr.value()), m_actionIdMap);
} else if ((attr = node.attribute("fromaid"))) {
int32_t id = pugi::cast<int32_t>(attr.value());
int32_t endId = pugi::cast<int32_t>(node.attribute("toaid").value());
addEvent(moveEvent, id, m_actionIdMap);
while (++id <= endId) {
addEvent(moveEvent, id, m_actionIdMap);
}
} else if ((attr = node.attribute("pos"))) {
std::vector<int32_t> posList = vectorAtoi(explodeString(attr.as_string(), ";"));
if (posList.size() >= 3) {
Position pos(posList[0], posList[1], posList[2]);
addEvent(moveEvent, pos, m_positionMap);
} else {
success = false;
}
} else {
success = false;
}
return success;
}
///This method parses the fitting node. There are only two free parameters at the moment. The main part of this node
/// is the fitting parameters. These parameters are critical to the function of the software. If the fitting node is
/// present then the Parameters node must also be.
void MapNodeXmlParser::ParseFittingNode(const pugi::xml_node &node, TimingConfiguration &config,
const bool &isVerbose) {
config.SetBeta(node.attribute("beta").as_double(DefaultConfig::fitBeta));
config.SetGamma(node.attribute("gamma").as_double(DefaultConfig::fitGamma));
}
void Items::parseItemNode(const pugi::xml_node& itemNode, uint16_t id)
{
if (id > 30000 && id < 30100) {
id -= 30000;
if (id >= items.size()) {
items.resize(id + 1);
}
ItemType& iType = items[id];
iType.id = id;
}
ItemType& it = getItemType(id);
if (it.id == 0) {
return;
}
it.name = itemNode.attribute("name").as_string();
pugi::xml_attribute articleAttribute = itemNode.attribute("article");
if (articleAttribute) {
it.article = articleAttribute.as_string();
}
pugi::xml_attribute pluralAttribute = itemNode.attribute("plural");
if (pluralAttribute) {
it.pluralName = pluralAttribute.as_string();
}
for (pugi::xml_node attributeNode = itemNode.first_child(); attributeNode; attributeNode = attributeNode.next_sibling()) {
pugi::xml_attribute keyAttribute = attributeNode.attribute("key");
if (!keyAttribute) {
continue;
}
pugi::xml_attribute valueAttribute = attributeNode.attribute("value");
if (!valueAttribute) {
continue;
}
std::string tmpStrValue = asLowerCaseString(keyAttribute.as_string());
if (tmpStrValue == "type") {
tmpStrValue = asLowerCaseString(valueAttribute.as_string());
if (tmpStrValue == "key") {
it.type = ITEM_TYPE_KEY;
} else if (tmpStrValue == "magicfield") {
it.type = ITEM_TYPE_MAGICFIELD;
} else if (tmpStrValue == "container") {
it.group = ITEM_GROUP_CONTAINER;
it.type = ITEM_TYPE_CONTAINER;
} else if (tmpStrValue == "depot") {
it.type = ITEM_TYPE_DEPOT;
} else if (tmpStrValue == "mailbox") {
it.type = ITEM_TYPE_MAILBOX;
} else if (tmpStrValue == "trashholder") {
it.type = ITEM_TYPE_TRASHHOLDER;
} else if (tmpStrValue == "teleport") {
it.type = ITEM_TYPE_TELEPORT;
} else if (tmpStrValue == "door") {
it.type = ITEM_TYPE_DOOR;
} else if (tmpStrValue == "bed") {
it.type = ITEM_TYPE_BED;
} else if (tmpStrValue == "rune") {
it.type = ITEM_TYPE_RUNE;
} else {
std::cout << "[Warning - Items::parseItemNode] Unknown type: " << valueAttribute.as_string() << std::endl;
}
} else if (tmpStrValue == "description") {
it.description = valueAttribute.as_string();
} else if (tmpStrValue == "runespellname") {
it.runeSpellName = valueAttribute.as_string();
} else if (tmpStrValue == "weight") {
it.weight = pugi::cast<uint32_t>(valueAttribute.value());
} else if (tmpStrValue == "showcount") {
it.showCount = valueAttribute.as_bool();
} else if (tmpStrValue == "armor") {
it.armor = pugi::cast<int32_t>(valueAttribute.value());
} else if (tmpStrValue == "defense") {
it.defense = pugi::cast<int32_t>(valueAttribute.value());
} else if (tmpStrValue == "extradef") {
it.extraDefense = pugi::cast<int32_t>(valueAttribute.value());
} else if (tmpStrValue == "attack") {
it.attack = pugi::cast<int32_t>(valueAttribute.value());
} else if (tmpStrValue == "rotateto") {
it.rotateTo = pugi::cast<int32_t>(valueAttribute.value());
} else if (tmpStrValue == "moveable" || tmpStrValue == "movable") {
it.moveable = valueAttribute.as_bool();
} else if (tmpStrValue == "blockprojectile") {
it.blockProjectile = valueAttribute.as_bool();
} else if (tmpStrValue == "allowpickupable" || tmpStrValue == "pickupable") {
it.allowPickupable = valueAttribute.as_bool();
} else if (tmpStrValue == "floorchange") {
tmpStrValue = asLowerCaseString(valueAttribute.as_string());
if (tmpStrValue == "down") {
it.floorChangeDown = true;
} else if (tmpStrValue == "north") {
it.floorChangeNorth = true;
} else if (tmpStrValue == "south") {
it.floorChangeSouth = true;
} else if (tmpStrValue == "southalt" || tmpStrValue == "southex") {
it.floorChangeSouthAlt = true;
} else if (tmpStrValue == "west") {
it.floorChangeWest = true;
} else if (tmpStrValue == "east") {
it.floorChangeEast = true;
} else if (tmpStrValue == "eastalt" || tmpStrValue == "eastex") {
it.floorChangeEastAlt = true;
} else {
std::cout << "[Warning - Items::parseItemNode] Unknown floorChange: " << valueAttribute.as_string() << std::endl;
}
} else if (tmpStrValue == "corpsetype") {
tmpStrValue = asLowerCaseString(valueAttribute.as_string());
if (tmpStrValue == "venom") {
it.corpseType = RACE_VENOM;
} else if (tmpStrValue == "blood") {
it.corpseType = RACE_BLOOD;
} else if (tmpStrValue == "undead") {
it.corpseType = RACE_UNDEAD;
} else if (tmpStrValue == "fire") {
it.corpseType = RACE_FIRE;
} else if (tmpStrValue == "energy") {
it.corpseType = RACE_ENERGY;
} else {
std::cout << "[Warning - Items::parseItemNode] Unknown corpseType: " << valueAttribute.as_string() << std::endl;
}
} else if (tmpStrValue == "containersize") {
it.maxItems = pugi::cast<uint16_t>(valueAttribute.value());
} else if (tmpStrValue == "fluidsource") {
tmpStrValue = asLowerCaseString(valueAttribute.as_string());
if (tmpStrValue == "water") {
it.fluidSource = FLUID_WATER;
} else if (tmpStrValue == "blood") {
it.fluidSource = FLUID_BLOOD;
} else if (tmpStrValue == "beer") {
it.fluidSource = FLUID_BEER;
} else if (tmpStrValue == "slime") {
it.fluidSource = FLUID_SLIME;
} else if (tmpStrValue == "lemonade") {
it.fluidSource = FLUID_LEMONADE;
} else if (tmpStrValue == "milk") {
it.fluidSource = FLUID_MILK;
} else if (tmpStrValue == "mana") {
it.fluidSource = FLUID_MANA;
} else if (tmpStrValue == "life") {
it.fluidSource = FLUID_LIFE;
} else if (tmpStrValue == "oil") {
it.fluidSource = FLUID_OIL;
} else if (tmpStrValue == "urine") {
it.fluidSource = FLUID_URINE;
} else if (tmpStrValue == "coconut") {
it.fluidSource = FLUID_COCONUTMILK;
} else if (tmpStrValue == "wine") {
it.fluidSource = FLUID_WINE;
} else if (tmpStrValue == "mud") {
it.fluidSource = FLUID_MUD;
} else if (tmpStrValue == "fruitjuice") {
it.fluidSource = FLUID_FRUITJUICE;
} else if (tmpStrValue == "lava") {
it.fluidSource = FLUID_LAVA;
} else if (tmpStrValue == "rum") {
it.fluidSource = FLUID_RUM;
} else if (tmpStrValue == "swamp") {
it.fluidSource = FLUID_SWAMP;
} else if (tmpStrValue == "tea") {
it.fluidSource = FLUID_TEA;
} else if (tmpStrValue == "mead") {
it.fluidSource = FLUID_MEAD;
} else {
std::cout << "[Warning - Items::parseItemNode] Unknown fluidSource: " << valueAttribute.as_string() << std::endl;
}
} else if (tmpStrValue == "readable") {
it.canReadText = valueAttribute.as_bool();
} else if (tmpStrValue == "writeable") {
it.canWriteText = valueAttribute.as_bool();
it.canReadText = it.canWriteText;
} else if (tmpStrValue == "maxtextlen") {
it.maxTextLen = pugi::cast<uint16_t>(valueAttribute.value());
} else if (tmpStrValue == "writeonceitemid") {
it.writeOnceItemId = pugi::cast<uint16_t>(valueAttribute.value());
} else if (tmpStrValue == "weapontype") {
tmpStrValue = asLowerCaseString(valueAttribute.as_string());
if (tmpStrValue == "sword") {
it.weaponType = WEAPON_SWORD;
} else if (tmpStrValue == "club") {
it.weaponType = WEAPON_CLUB;
} else if (tmpStrValue == "axe") {
it.weaponType = WEAPON_AXE;
} else if (tmpStrValue == "shield") {
it.weaponType = WEAPON_SHIELD;
} else if (tmpStrValue == "distance") {
it.weaponType = WEAPON_DISTANCE;
} else if (tmpStrValue == "wand") {
it.weaponType = WEAPON_WAND;
} else if (tmpStrValue == "ammunition") {
it.weaponType = WEAPON_AMMO;
} else {
std::cout << "[Warning - Items::parseItemNode] Unknown weaponType: " << valueAttribute.as_string() << std::endl;
}
} else if (tmpStrValue == "slottype") {
tmpStrValue = asLowerCaseString(valueAttribute.as_string());
if (tmpStrValue == "head") {
it.slotPosition |= SLOTP_HEAD;
} else if (tmpStrValue == "body") {
it.slotPosition |= SLOTP_ARMOR;
} else if (tmpStrValue == "legs") {
it.slotPosition |= SLOTP_LEGS;
} else if (tmpStrValue == "feet") {
it.slotPosition |= SLOTP_FEET;
} else if (tmpStrValue == "backpack") {
it.slotPosition |= SLOTP_BACKPACK;
} else if (tmpStrValue == "two-handed") {
it.slotPosition |= SLOTP_TWO_HAND;
} else if (tmpStrValue == "right-hand") {
it.slotPosition &= ~SLOTP_LEFT;
} else if (tmpStrValue == "left-hand") {
it.slotPosition &= ~SLOTP_RIGHT;
} else if (tmpStrValue == "necklace") {
it.slotPosition |= SLOTP_NECKLACE;
} else if (tmpStrValue == "ring") {
it.slotPosition |= SLOTP_RING;
} else if (tmpStrValue == "ammo") {
it.slotPosition |= SLOTP_AMMO;
} else if (tmpStrValue == "hand") {
it.slotPosition |= SLOTP_HAND;
} else {
std::cout << "[Warning - Items::parseItemNode] Unknown slotType: " << valueAttribute.as_string() << std::endl;
}
} else if (tmpStrValue == "ammotype") {
it.ammoType = getAmmoType(valueAttribute.as_string());
if (it.ammoType == AMMO_NONE) {
std::cout << "[Warning - Items::parseItemNode] Unknown ammoType: " << valueAttribute.as_string() << std::endl;
}
} else if (tmpStrValue == "shoottype") {
ShootType_t shoot = getShootType(valueAttribute.as_string());
if (shoot != CONST_ANI_NONE) {
it.shootType = shoot;
} else {
std::cout << "[Warning - Items::parseItemNode] Unknown shootType: " << valueAttribute.as_string() << std::endl;
}
} else if (tmpStrValue == "effect") {
MagicEffectClasses effect = getMagicEffect(valueAttribute.as_string());
if (effect != CONST_ME_NONE) {
it.magicEffect = effect;
} else {
std::cout << "[Warning - Items::parseItemNode] Unknown effect: " << valueAttribute.as_string() << std::endl;
}
} else if (tmpStrValue == "range") {
it.shootRange = pugi::cast<uint16_t>(valueAttribute.value());
} else if (tmpStrValue == "stopduration") {
it.stopTime = valueAttribute.as_bool();
} else if (tmpStrValue == "decayto") {
it.decayTo = pugi::cast<int32_t>(valueAttribute.value());
} else if (tmpStrValue == "transformequipto") {
it.transformEquipTo = pugi::cast<uint16_t>(valueAttribute.value());
} else if (tmpStrValue == "transformdeequipto") {
it.transformDeEquipTo = pugi::cast<uint16_t>(valueAttribute.value());
} else if (tmpStrValue == "duration") {
it.decayTime = pugi::cast<uint32_t>(valueAttribute.value());
} else if (tmpStrValue == "showduration") {
it.showDuration = valueAttribute.as_bool();
} else if (tmpStrValue == "charges") {
it.charges = pugi::cast<uint32_t>(valueAttribute.value());
} else if (tmpStrValue == "showcharges") {
it.showCharges = valueAttribute.as_bool();
} else if (tmpStrValue == "showattributes") {
it.showAttributes = valueAttribute.as_bool();
} else if (tmpStrValue == "hitchance") {
it.hitChance = std::min<int8_t>(100, std::max<int8_t>(-100, pugi::cast<int16_t>(valueAttribute.value())));
} else if (tmpStrValue == "maxhitchance") {
it.maxHitChance = std::min<uint32_t>(100, pugi::cast<uint32_t>(valueAttribute.value()));
} else if (tmpStrValue == "invisible") {
it.getAbilities().invisible = valueAttribute.as_bool();
} else if (tmpStrValue == "speed") {
it.getAbilities().speed = pugi::cast<int32_t>(valueAttribute.value());
} else if (tmpStrValue == "healthgain") {
Abilities& abilities = it.getAbilities();
abilities.regeneration = true;
abilities.healthGain = pugi::cast<uint32_t>(valueAttribute.value());
} else if (tmpStrValue == "healthticks") {
Abilities& abilities = it.getAbilities();
abilities.regeneration = true;
abilities.healthTicks = pugi::cast<uint32_t>(valueAttribute.value());
} else if (tmpStrValue == "managain") {
Abilities& abilities = it.getAbilities();
abilities.regeneration = true;
abilities.manaGain = pugi::cast<uint32_t>(valueAttribute.value());
} else if (tmpStrValue == "manaticks") {
Abilities& abilities = it.getAbilities();
abilities.regeneration = true;
abilities.manaTicks = pugi::cast<uint32_t>(valueAttribute.value());
} else if (tmpStrValue == "manashield") {
it.getAbilities().manaShield = valueAttribute.as_bool();
} else if (tmpStrValue == "skillsword") {
it.getAbilities().skills[SKILL_SWORD] = pugi::cast<int32_t>(valueAttribute.value());
} else if (tmpStrValue == "skillaxe") {
it.getAbilities().skills[SKILL_AXE] = pugi::cast<int32_t>(valueAttribute.value());
} else if (tmpStrValue == "skillclub") {
it.getAbilities().skills[SKILL_CLUB] = pugi::cast<int32_t>(valueAttribute.value());
} else if (tmpStrValue == "skilldist") {
it.getAbilities().skills[SKILL_DISTANCE] = pugi::cast<int32_t>(valueAttribute.value());
} else if (tmpStrValue == "skillfish") {
it.getAbilities().skills[SKILL_FISHING] = pugi::cast<int32_t>(valueAttribute.value());
} else if (tmpStrValue == "skillshield") {
it.getAbilities().skills[SKILL_SHIELD] = pugi::cast<int32_t>(valueAttribute.value());
} else if (tmpStrValue == "skillfist") {
it.getAbilities().skills[SKILL_FIST] = pugi::cast<int32_t>(valueAttribute.value());
} else if (tmpStrValue == "maxhitpoints") {
it.getAbilities().stats[STAT_MAXHITPOINTS] = pugi::cast<int32_t>(valueAttribute.value());
} else if (tmpStrValue == "maxhitpointspercent") {
it.getAbilities().statsPercent[STAT_MAXHITPOINTS] = pugi::cast<int32_t>(valueAttribute.value());
} else if (tmpStrValue == "maxmanapoints") {
it.getAbilities().stats[STAT_MAXMANAPOINTS] = pugi::cast<int32_t>(valueAttribute.value());
} else if (tmpStrValue == "maxmanapointspercent") {
it.getAbilities().statsPercent[STAT_MAXMANAPOINTS] = pugi::cast<int32_t>(valueAttribute.value());
} else if (tmpStrValue == "magicpoints" || tmpStrValue == "magiclevelpoints") {
it.getAbilities().stats[STAT_MAGICPOINTS] = pugi::cast<int32_t>(valueAttribute.value());
} else if (tmpStrValue == "magicpointspercent") {
it.getAbilities().statsPercent[STAT_MAGICPOINTS] = pugi::cast<int32_t>(valueAttribute.value());
} else if (tmpStrValue == "fieldabsorbpercentenergy") {
it.getAbilities().fieldAbsorbPercent[combatTypeToIndex(COMBAT_ENERGYDAMAGE)] += pugi::cast<int16_t>(valueAttribute.value());
} else if (tmpStrValue == "fieldabsorbpercentfire") {
it.getAbilities().fieldAbsorbPercent[combatTypeToIndex(COMBAT_FIREDAMAGE)] += pugi::cast<int16_t>(valueAttribute.value());
} else if (tmpStrValue == "fieldabsorbpercentpoison" || tmpStrValue == "fieldabsorpercentearth") {
it.getAbilities().fieldAbsorbPercent[combatTypeToIndex(COMBAT_EARTHDAMAGE)] += pugi::cast<int16_t>(valueAttribute.value());
} else if (tmpStrValue == "absorbpercentall" || tmpStrValue == "absorbpercentallelements") {
int16_t value = pugi::cast<int16_t>(valueAttribute.value());
Abilities& abilities = it.getAbilities();
for (size_t i = 0; i < COMBAT_COUNT; ++i) {
abilities.absorbPercent[i] += value;
}
} else if (tmpStrValue == "absorbpercentelements") {
int16_t value = pugi::cast<int16_t>(valueAttribute.value());
Abilities& abilities = it.getAbilities();
abilities.absorbPercent[combatTypeToIndex(COMBAT_ENERGYDAMAGE)] += value;
abilities.absorbPercent[combatTypeToIndex(COMBAT_FIREDAMAGE)] += value;
abilities.absorbPercent[combatTypeToIndex(COMBAT_EARTHDAMAGE)] += value;
abilities.absorbPercent[combatTypeToIndex(COMBAT_ICEDAMAGE)] += value;
} else if (tmpStrValue == "absorbpercentmagic") {
int16_t value = pugi::cast<int16_t>(valueAttribute.value());
Abilities& abilities = it.getAbilities();
abilities.absorbPercent[combatTypeToIndex(COMBAT_ENERGYDAMAGE)] += value;
abilities.absorbPercent[combatTypeToIndex(COMBAT_FIREDAMAGE)] += value;
abilities.absorbPercent[combatTypeToIndex(COMBAT_EARTHDAMAGE)] += value;
abilities.absorbPercent[combatTypeToIndex(COMBAT_ICEDAMAGE)] += value;
abilities.absorbPercent[combatTypeToIndex(COMBAT_HOLYDAMAGE)] += value;
abilities.absorbPercent[combatTypeToIndex(COMBAT_DEATHDAMAGE)] += value;
} else if (tmpStrValue == "absorbpercentenergy") {
it.getAbilities().absorbPercent[combatTypeToIndex(COMBAT_ENERGYDAMAGE)] += pugi::cast<int16_t>(valueAttribute.value());
} else if (tmpStrValue == "absorbpercentfire") {
it.getAbilities().absorbPercent[combatTypeToIndex(COMBAT_FIREDAMAGE)] += pugi::cast<int16_t>(valueAttribute.value());
} else if (tmpStrValue == "absorbpercentpoison" || tmpStrValue == "absorbpercentearth") {
it.getAbilities().absorbPercent[combatTypeToIndex(COMBAT_EARTHDAMAGE)] += pugi::cast<int16_t>(valueAttribute.value());
} else if (tmpStrValue == "absorbpercentice") {
it.getAbilities().absorbPercent[combatTypeToIndex(COMBAT_ICEDAMAGE)] += pugi::cast<int16_t>(valueAttribute.value());
} else if (tmpStrValue == "absorbpercentholy") {
it.getAbilities().absorbPercent[combatTypeToIndex(COMBAT_HOLYDAMAGE)] += pugi::cast<int16_t>(valueAttribute.value());
} else if (tmpStrValue == "absorbpercentdeath") {
it.getAbilities().absorbPercent[combatTypeToIndex(COMBAT_DEATHDAMAGE)] += pugi::cast<int16_t>(valueAttribute.value());
} else if (tmpStrValue == "absorbpercentlifedrain") {
it.getAbilities().absorbPercent[combatTypeToIndex(COMBAT_LIFEDRAIN)] += pugi::cast<int16_t>(valueAttribute.value());
} else if (tmpStrValue == "absorbpercentmanadrain") {
it.getAbilities().absorbPercent[combatTypeToIndex(COMBAT_MANADRAIN)] += pugi::cast<int16_t>(valueAttribute.value());
} else if (tmpStrValue == "absorbpercentdrown") {
it.getAbilities().absorbPercent[combatTypeToIndex(COMBAT_DROWNDAMAGE)] += pugi::cast<int16_t>(valueAttribute.value());
} else if (tmpStrValue == "absorbpercentphysical") {
it.getAbilities().absorbPercent[combatTypeToIndex(COMBAT_PHYSICALDAMAGE)] += pugi::cast<int16_t>(valueAttribute.value());
} else if (tmpStrValue == "absorbpercenthealing") {
it.getAbilities().absorbPercent[combatTypeToIndex(COMBAT_HEALING)] += pugi::cast<int16_t>(valueAttribute.value());
} else if (tmpStrValue == "absorbpercentundefined") {
it.getAbilities().absorbPercent[combatTypeToIndex(COMBAT_UNDEFINEDDAMAGE)] += pugi::cast<int16_t>(valueAttribute.value());
} else if (tmpStrValue == "suppressdrunk") {
if (valueAttribute.as_bool()) {
it.getAbilities().conditionSuppressions |= CONDITION_DRUNK;
}
} else if (tmpStrValue == "suppressenergy") {
if (valueAttribute.as_bool()) {
it.getAbilities().conditionSuppressions |= CONDITION_ENERGY;
}
} else if (tmpStrValue == "suppressfire") {
if (valueAttribute.as_bool()) {
it.getAbilities().conditionSuppressions |= CONDITION_FIRE;
}
} else if (tmpStrValue == "suppresspoison") {
if (valueAttribute.as_bool()) {
it.getAbilities().conditionSuppressions |= CONDITION_POISON;
}
} else if (tmpStrValue == "suppressdrown") {
if (valueAttribute.as_bool()) {
it.getAbilities().conditionSuppressions |= CONDITION_DROWN;
}
} else if (tmpStrValue == "suppressphysical") {
if (valueAttribute.as_bool()) {
it.getAbilities().conditionSuppressions |= CONDITION_BLEEDING;
}
} else if (tmpStrValue == "suppressfreeze") {
if (valueAttribute.as_bool()) {
it.getAbilities().conditionSuppressions |= CONDITION_FREEZING;
}
} else if (tmpStrValue == "suppressdazzle") {
if (valueAttribute.as_bool()) {
it.getAbilities().conditionSuppressions |= CONDITION_DAZZLED;
}
} else if (tmpStrValue == "suppresscurse") {
if (valueAttribute.as_bool()) {
it.getAbilities().conditionSuppressions |= CONDITION_CURSED;
}
} else if (tmpStrValue == "field") {
it.group = ITEM_GROUP_MAGICFIELD;
it.type = ITEM_TYPE_MAGICFIELD;
CombatType_t combatType = COMBAT_NONE;
ConditionDamage* conditionDamage = nullptr;
tmpStrValue = asLowerCaseString(valueAttribute.as_string());
if (tmpStrValue == "fire") {
conditionDamage = new ConditionDamage(CONDITIONID_COMBAT, CONDITION_FIRE);
combatType = COMBAT_FIREDAMAGE;
} else if (tmpStrValue == "energy") {
conditionDamage = new ConditionDamage(CONDITIONID_COMBAT, CONDITION_ENERGY);
combatType = COMBAT_ENERGYDAMAGE;
} else if (tmpStrValue == "poison") {
conditionDamage = new ConditionDamage(CONDITIONID_COMBAT, CONDITION_POISON);
combatType = COMBAT_EARTHDAMAGE;
} else if (tmpStrValue == "drown") {
conditionDamage = new ConditionDamage(CONDITIONID_COMBAT, CONDITION_DROWN);
combatType = COMBAT_DROWNDAMAGE;
} else if (tmpStrValue == "physical") {
conditionDamage = new ConditionDamage(CONDITIONID_COMBAT, CONDITION_BLEEDING);
combatType = COMBAT_PHYSICALDAMAGE;
} else {
std::cout << "[Warning - Items::parseItemNode] Unknown field value: " << valueAttribute.as_string() << std::endl;
}
if (combatType != COMBAT_NONE) {
it.combatType = combatType;
it.conditionDamage.set(conditionDamage);
uint32_t ticks = 0;
int32_t damage = 0;
int32_t start = 0;
int32_t count = 1;
for (pugi::xml_node subAttributeNode = attributeNode.first_child(); subAttributeNode; subAttributeNode = subAttributeNode.next_sibling()) {
pugi::xml_attribute subKeyAttribute = subAttributeNode.attribute("key");
if (!subKeyAttribute) {
continue;
}
pugi::xml_attribute subValueAttribute = subAttributeNode.attribute("value");
if (!subValueAttribute) {
continue;
}
tmpStrValue = asLowerCaseString(subKeyAttribute.as_string());
if (tmpStrValue == "ticks") {
ticks = pugi::cast<uint32_t>(subValueAttribute.value());
} else if (tmpStrValue == "count") {
count = std::max<int32_t>(1, pugi::cast<int32_t>(subValueAttribute.value()));
} else if (tmpStrValue == "start") {
start = std::max<int32_t>(0, pugi::cast<int32_t>(subValueAttribute.value()));
} else if (tmpStrValue == "damage") {
damage = -pugi::cast<int32_t>(subValueAttribute.value());
if (start > 0) {
std::list<int32_t> damageList;
ConditionDamage::generateDamageList(damage, start, damageList);
for (int32_t damageValue : damageList) {
conditionDamage->addDamage(1, ticks, -damageValue);
}
start = 0;
} else {
conditionDamage->addDamage(count, ticks, damage);
}
}
}
conditionDamage->setParam(CONDITION_PARAM_FIELD, 1);
if (conditionDamage->getTotalDamage() > 0) {
conditionDamage->setParam(CONDITION_PARAM_FORCEUPDATE, 1);
}
}
} else if (tmpStrValue == "replaceable") {
it.replaceable = valueAttribute.as_bool();
} else if (tmpStrValue == "partnerdirection") {
it.bedPartnerDir = getDirection(valueAttribute.as_string());
} else if (tmpStrValue == "leveldoor") {
it.levelDoor = pugi::cast<uint32_t>(valueAttribute.value());
} else if (tmpStrValue == "maletransformto" || tmpStrValue == "malesleeper") {
uint16_t value = pugi::cast<uint16_t>(valueAttribute.value());
it.transformToOnUse[PLAYERSEX_MALE] = value;
ItemType& other = getItemType(value);
if (other.transformToFree == 0) {
other.transformToFree = it.id;
}
if (it.transformToOnUse[PLAYERSEX_FEMALE] == 0) {
it.transformToOnUse[PLAYERSEX_FEMALE] = value;
}
} else if (tmpStrValue == "femaletransformto" || tmpStrValue == "femalesleeper") {
uint16_t value = pugi::cast<uint16_t>(valueAttribute.value());
it.transformToOnUse[PLAYERSEX_FEMALE] = value;
ItemType& other = getItemType(value);
if (other.transformToFree == 0) {
other.transformToFree = it.id;
}
if (it.transformToOnUse[PLAYERSEX_MALE] == 0) {
it.transformToOnUse[PLAYERSEX_MALE] = value;
}
} else if (tmpStrValue == "transformto") {
it.transformToFree = pugi::cast<uint16_t>(valueAttribute.value());
} else if (tmpStrValue == "elementice") {
Abilities& abilities = it.getAbilities();
abilities.elementDamage = pugi::cast<uint16_t>(valueAttribute.value());
abilities.elementType = COMBAT_ICEDAMAGE;
} else if (tmpStrValue == "elementearth") {
Abilities& abilities = it.getAbilities();
abilities.elementDamage = pugi::cast<uint16_t>(valueAttribute.value());
abilities.elementType = COMBAT_EARTHDAMAGE;
} else if (tmpStrValue == "elementfire") {
Abilities& abilities = it.getAbilities();
abilities.elementDamage = pugi::cast<uint16_t>(valueAttribute.value());
abilities.elementType = COMBAT_FIREDAMAGE;
} else if (tmpStrValue == "elementenergy") {
Abilities& abilities = it.getAbilities();
abilities.elementDamage = pugi::cast<uint16_t>(valueAttribute.value());
abilities.elementType = COMBAT_ENERGYDAMAGE;
} else if (tmpStrValue == "walkstack") {
it.walkStack = valueAttribute.as_bool();
} else if (tmpStrValue == "blocking") {
it.blockSolid = valueAttribute.as_bool();
} else if (tmpStrValue == "allowdistread") {
it.allowDistRead = booleanString(valueAttribute.as_string());
} else {
std::cout << "[Warning - Items::parseItemNode] Unknown key value: " << keyAttribute.as_string() << std::endl;
}
}
//check bed items
if ((it.transformToFree != 0 || it.transformToOnUse[PLAYERSEX_FEMALE] != 0 || it.transformToOnUse[PLAYERSEX_MALE] != 0) && it.type != ITEM_TYPE_BED) {
std::cout << "[Warning - Items::parseItemNode] Item " << it.id << " is not set as a bed-type" << std::endl;
}
}
static void xml_read_shader_graph(const XMLReadState& state, Shader *shader, pugi::xml_node graph_node)
{
ShaderGraph *graph = new ShaderGraph();
map<string, ShaderNode*> nodemap;
nodemap["output"] = graph->output();
for(pugi::xml_node node = graph_node.first_child(); node; node = node.next_sibling()) {
ShaderNode *snode = NULL;
if(string_iequals(node.name(), "image_texture")) {
ImageTextureNode *img = new ImageTextureNode();
xml_read_string(&img->filename, node, "src");
img->filename = path_join(state.base, img->filename);
snode = img;
}
else if(string_iequals(node.name(), "environment_texture")) {
EnvironmentTextureNode *env = new EnvironmentTextureNode();
xml_read_string(&env->filename, node, "src");
env->filename = path_join(state.base, env->filename);
snode = env;
}
else if(string_iequals(node.name(), "sky_texture")) {
SkyTextureNode *sky = new SkyTextureNode();
xml_read_float3(&sky->sun_direction, node, "sun_direction");
xml_read_float(&sky->turbidity, node, "turbidity");
snode = sky;
}
else if(string_iequals(node.name(), "noise_texture")) {
snode = new NoiseTextureNode();
}
else if(string_iequals(node.name(), "checker_texture")) {
snode = new CheckerTextureNode();
}
else if(string_iequals(node.name(), "gradient_texture")) {
GradientTextureNode *blend = new GradientTextureNode();
xml_read_enum(&blend->type, GradientTextureNode::type_enum, node, "type");
snode = blend;
}
else if(string_iequals(node.name(), "voronoi_texture")) {
VoronoiTextureNode *voronoi = new VoronoiTextureNode();
xml_read_enum(&voronoi->coloring, VoronoiTextureNode::coloring_enum, node, "coloring");
snode = voronoi;
}
else if(string_iequals(node.name(), "musgrave_texture")) {
MusgraveTextureNode *musgrave = new MusgraveTextureNode();
xml_read_enum(&musgrave->type, MusgraveTextureNode::type_enum, node, "type");
snode = musgrave;
}
else if(string_iequals(node.name(), "magic_texture")) {
MagicTextureNode *magic = new MagicTextureNode();
xml_read_int(&magic->depth, node, "depth");
snode = magic;
}
else if(string_iequals(node.name(), "noise_texture")) {
NoiseTextureNode *dist = new NoiseTextureNode();
snode = dist;
}
else if(string_iequals(node.name(), "wave_texture")) {
WaveTextureNode *wood = new WaveTextureNode();
xml_read_enum(&wood->type, WaveTextureNode::type_enum, node, "type");
snode = wood;
}
else if(string_iequals(node.name(), "normal")) {
snode = new NormalNode();
}
else if(string_iequals(node.name(), "mapping")) {
snode = new MappingNode();
}
else if(string_iequals(node.name(), "ward_bsdf")) {
snode = new WardBsdfNode();
}
else if(string_iequals(node.name(), "diffuse_bsdf")) {
snode = new DiffuseBsdfNode();
}
else if(string_iequals(node.name(), "translucent_bsdf")) {
snode = new TranslucentBsdfNode();
}
else if(string_iequals(node.name(), "transparent_bsdf")) {
snode = new TransparentBsdfNode();
}
else if(string_iequals(node.name(), "velvet_bsdf")) {
snode = new VelvetBsdfNode();
}
else if(string_iequals(node.name(), "glossy_bsdf")) {
GlossyBsdfNode *glossy = new GlossyBsdfNode();
xml_read_enum(&glossy->distribution, GlossyBsdfNode::distribution_enum, node, "distribution");
snode = glossy;
}
else if(string_iequals(node.name(), "glass_bsdf")) {
GlassBsdfNode *diel = new GlassBsdfNode();
xml_read_enum(&diel->distribution, GlassBsdfNode::distribution_enum, node, "distribution");
snode = diel;
}
else if(string_iequals(node.name(), "emission")) {
EmissionNode *emission = new EmissionNode();
xml_read_bool(&emission->total_power, node, "total_power");
snode = emission;
}
else if(string_iequals(node.name(), "background")) {
snode = new BackgroundNode();
}
else if(string_iequals(node.name(), "transparent_volume")) {
snode = new TransparentVolumeNode();
}
else if(string_iequals(node.name(), "isotropic_volume")) {
snode = new IsotropicVolumeNode();
}
else if(string_iequals(node.name(), "geometry")) {
snode = new GeometryNode();
}
else if(string_iequals(node.name(), "texture_coordinate")) {
snode = new TextureCoordinateNode();
}
else if(string_iequals(node.name(), "lightPath")) {
snode = new LightPathNode();
}
else if(string_iequals(node.name(), "value")) {
ValueNode *value = new ValueNode();
xml_read_float(&value->value, node, "value");
snode = value;
}
else if(string_iequals(node.name(), "color")) {
ColorNode *color = new ColorNode();
xml_read_float3(&color->value, node, "value");
snode = color;
}
else if(string_iequals(node.name(), "mix_closure")) {
snode = new MixClosureNode();
}
else if(string_iequals(node.name(), "add_closure")) {
snode = new AddClosureNode();
}
else if(string_iequals(node.name(), "invert")) {
snode = new InvertNode();
}
else if(string_iequals(node.name(), "mix")) {
MixNode *mix = new MixNode();
xml_read_enum(&mix->type, MixNode::type_enum, node, "type");
snode = mix;
}
else if(string_iequals(node.name(), "gamma")) {
snode = new GammaNode();
}
else if(string_iequals(node.name(), "brightness")) {
snode = new BrightContrastNode();
}
else if(string_iequals(node.name(), "combine_rgb")) {
snode = new CombineRGBNode();
}
else if(string_iequals(node.name(), "separate_rgb")) {
snode = new SeparateRGBNode();
}
else if(string_iequals(node.name(), "hsv")) {
snode = new HSVNode();
}
else if(string_iequals(node.name(), "attribute")) {
AttributeNode *attr = new AttributeNode();
xml_read_ustring(&attr->attribute, node, "attribute");
snode = attr;
}
else if(string_iequals(node.name(), "camera")) {
snode = new CameraNode();
}
else if(string_iequals(node.name(), "fresnel")) {
snode = new FresnelNode();
}
else if(string_iequals(node.name(), "math")) {
MathNode *math = new MathNode();
xml_read_enum(&math->type, MathNode::type_enum, node, "type");
snode = math;
}
else if(string_iequals(node.name(), "vector_math")) {
VectorMathNode *vmath = new VectorMathNode();
xml_read_enum(&vmath->type, VectorMathNode::type_enum, node, "type");
snode = vmath;
}
else if(string_iequals(node.name(), "connect")) {
/* connect nodes */
vector<string> from_tokens, to_tokens;
string_split(from_tokens, node.attribute("from").value());
string_split(to_tokens, node.attribute("to").value());
if(from_tokens.size() == 2 && to_tokens.size() == 2) {
/* find nodes and sockets */
ShaderOutput *output = NULL;
ShaderInput *input = NULL;
if(nodemap.find(from_tokens[0]) != nodemap.end()) {
ShaderNode *fromnode = nodemap[from_tokens[0]];
foreach(ShaderOutput *out, fromnode->outputs)
if(string_iequals(xml_socket_name(out->name), from_tokens[1]))
output = out;
if(!output)
fprintf(stderr, "Unknown output socket name \"%s\" on \"%s\".\n", from_tokens[1].c_str(), from_tokens[0].c_str());
}
else
static pugi::xml_node getNode(const pugi::xml_node& node, const std::string& xpath)
{
pugi::xpath_query query(xpath.c_str());
return node.select_single_node(query).node();
}
bool Actions::registerEvent(Event* event, const pugi::xml_node& node)
{
Action* action = dynamic_cast<Action*>(event);
if (!action) {
return false;
}
pugi::xml_attribute attr;
if ((attr = node.attribute("itemid"))) {
uint16_t id = pugi::cast<uint16_t>(attr.value());
if (useItemMap.find(id) != useItemMap.end()) {
std::cout << "[Warning - Actions::registerEvent] Duplicate registered item with id: " << id << std::endl;
return false;
}
useItemMap[id] = action;
} else if ((attr = node.attribute("fromid"))) {
pugi::xml_attribute toIdAttribute = node.attribute("toid");
if (toIdAttribute) {
uint16_t fromId = pugi::cast<uint16_t>(attr.value());
uint16_t iterId = fromId;
uint16_t toId = pugi::cast<uint16_t>(toIdAttribute.value());
bool success = false;
if (useItemMap.find(iterId) != useItemMap.end()) {
std::cout << "[Warning - Actions::registerEvent] Duplicate registered item with id: " << iterId << " in fromid: " << fromId << ", toid: " << toId << std::endl;
} else {
useItemMap[iterId] = action;
success = true;
}
while (++iterId <= toId) {
if (useItemMap.find(iterId) != useItemMap.end()) {
std::cout << "[Warning - Actions::registerEvent] Duplicate registered item with id: " << iterId << " in fromid: " << fromId << ", toid: " << toId << std::endl;
continue;
}
useItemMap[iterId] = action;
success = true;
}
return success;
} else {
std::cout << "[Warning - Actions::registerEvent] Missing toid in fromid: " << attr.as_string() << std::endl;
return false;
}
} else if ((attr = node.attribute("uniqueid"))) {
uint16_t uid = pugi::cast<uint16_t>(attr.value());
if (uniqueItemMap.find(uid) != uniqueItemMap.end()) {
std::cout << "[Warning - Actions::registerEvent] Duplicate registered item with uniqueid: " << uid << std::endl;
return false;
}
uniqueItemMap[uid] = action;
} else if ((attr = node.attribute("fromuid"))) {
pugi::xml_attribute toUidAttribute = node.attribute("touid");
if (toUidAttribute) {
uint16_t fromUid = pugi::cast<uint16_t>(attr.value());
uint16_t iterUid = fromUid;
uint16_t toUid = pugi::cast<uint16_t>(toUidAttribute.value());
bool success = false;
if (uniqueItemMap.find(iterUid) != uniqueItemMap.end()) {
std::cout << "[Warning - Actions::registerEvent] Duplicate registered item with unique id: " << iterUid << " in fromuid: " << fromUid << ", touid: " << toUid << std::endl;
} else {
uniqueItemMap[iterUid] = action;
success = true;
}
while (++iterUid <= toUid) {
if (uniqueItemMap.find(iterUid) != uniqueItemMap.end()) {
std::cout << "[Warning - Actions::registerEvent] Duplicate registered item with unique id: " << iterUid << " in fromuid: " << fromUid << ", touid: " << toUid << std::endl;
continue;
}
uniqueItemMap[iterUid] = action;
success = true;
}
return success;
} else {
std::cout << "[Warning - Actions::registerEvent] Missing touid in fromuid: " << attr.as_string() << std::endl;
return false;
}
} else if ((attr = node.attribute("actionid"))) {
uint16_t aid = pugi::cast<uint16_t>(attr.value());
if (actionItemMap.find(aid) != actionItemMap.end()) {
std::cout << "[Warning - Actions::registerEvent] Duplicate registered item with actionid: " << aid << std::endl;
return false;
}
actionItemMap[aid] = action;
} else if ((attr = node.attribute("fromaid"))) {
pugi::xml_attribute toAidAttribute = node.attribute("toaid");
if (toAidAttribute) {
uint16_t fromAid = pugi::cast<uint16_t>(attr.value());
uint16_t iterAid = fromAid;
uint16_t toAid = pugi::cast<uint16_t>(toAidAttribute.value());
bool success = false;
if (actionItemMap.find(iterAid) != actionItemMap.end()) {
std::cout << "[Warning - Actions::registerEvent] Duplicate registered item with action id: " << iterAid << " in fromaid: " << fromAid << ", toaid: " << toAid << std::endl;
} else {
actionItemMap[iterAid] = action;
success = true;
}
while (++iterAid <= toAid) {
if (actionItemMap.find(iterAid) != actionItemMap.end()) {
std::cout << "[Warning - Actions::registerEvent] Duplicate registered item with action id: " << iterAid << " in fromaid: " << fromAid << ", toaid: " << toAid << std::endl;
continue;
}
actionItemMap[iterAid] = action;
success = true;
}
return success;
} else {
std::cout << "[Warning - Actions::registerEvent] Missing toaid in fromaid: " << attr.as_string() << std::endl;
return false;
}
} else {
return false;
}
return true;
}
//---------------------------------------------------------------------------
int t_mep_parameters::to_xml(pugi::xml_node parent)
{
char tmp_str[30];
pugi::xml_node node = parent.append_child("mutation_probability");
pugi::xml_node data = node.append_child(pugi::node_pcdata);
sprintf(tmp_str, "%lg", mutation_probability);
data.set_value(tmp_str);
node = parent.append_child("crossover_probability");
data = node.append_child(pugi::node_pcdata);
sprintf(tmp_str, "%lg", crossover_probability);
data.set_value(tmp_str);
node = parent.append_child("crossover_type");
data = node.append_child(pugi::node_pcdata);
sprintf(tmp_str, "%d", crossover_type);
data.set_value(tmp_str);
node = parent.append_child("chromosome_length");
data = node.append_child(pugi::node_pcdata);
sprintf(tmp_str, "%ld", code_length);
data.set_value(tmp_str);
node = parent.append_child("subpopulation_size");
data = node.append_child(pugi::node_pcdata);
sprintf(tmp_str, "%ld", subpopulation_size);
data.set_value(tmp_str);
node = parent.append_child("num_subpopulations");
data = node.append_child(pugi::node_pcdata);
sprintf(tmp_str, "%ld", num_subpopulations);
data.set_value(tmp_str);
node = parent.append_child("tournament_size");
data = node.append_child(pugi::node_pcdata);
sprintf(tmp_str, "%ld", tournament_size);
data.set_value(tmp_str);
node = parent.append_child("number_of_generations");
data = node.append_child(pugi::node_pcdata);
sprintf(tmp_str, "%ld", num_generations);
data.set_value(tmp_str);
node = parent.append_child("problem_type");
data = node.append_child(pugi::node_pcdata);
sprintf(tmp_str, "%d", problem_type);
data.set_value(tmp_str);
node = parent.append_child("random_seed");
data = node.append_child(pugi::node_pcdata);
sprintf(tmp_str, "%ld", random_seed);
data.set_value(tmp_str);
node = parent.append_child("operators_probability");
data = node.append_child(pugi::node_pcdata);
sprintf(tmp_str, "%lg", operators_probability);
data.set_value(tmp_str);
node = parent.append_child("variables_probability");
data = node.append_child(pugi::node_pcdata);
sprintf(tmp_str, "%lg", variables_probability);
data.set_value(tmp_str);
node = parent.append_child("constants_probability");
data = node.append_child(pugi::node_pcdata);
sprintf(tmp_str, "%lg", constants_probability);
data.set_value(tmp_str);
node = parent.append_child("num_runs");
data = node.append_child(pugi::node_pcdata);
sprintf(tmp_str, "%ld", num_runs);
data.set_value(tmp_str);
node = parent.append_child("use_validation_data");
data = node.append_child(pugi::node_pcdata);
sprintf(tmp_str, "%d", use_validation_data);
data.set_value(tmp_str);
node = parent.append_child("simplified");
data = node.append_child(pugi::node_pcdata);
sprintf(tmp_str, "%d", simplified_programs);
data.set_value(tmp_str);
node = parent.append_child("num_threads");
data = node.append_child(pugi::node_pcdata);
sprintf(tmp_str, "%ld", num_threads);
data.set_value(tmp_str);
node = parent.append_child("constants");
constants.to_xml(node);
return true;
}
void XMLFile::AddNode(const pugi::xml_node& patch, const pugi::xpath_node& original) const
{
// If pos is null, append or prepend add as a child, otherwise add before or after, the default is to append as a child
pugi::xml_attribute pos = patch.attribute("pos");
if (!pos || strlen(pos.value()) <= 0 || strcmp(pos.value(), "append") == 0)
{
pugi::xml_node::iterator start = patch.begin();
pugi::xml_node::iterator end = patch.end();
// There can not be two consecutive text nodes, so check to see if they need to be combined
// If they have been we can skip the first node of the nodes to add
if (CombineText(patch.first_child(), original.node().last_child(), false))
start++;
for (; start != end; start++)
original.node().append_copy(*start);
}
else if (strcmp(pos.value(), "prepend") == 0)
{
pugi::xml_node::iterator start = patch.begin();
pugi::xml_node::iterator end = patch.end();
// There can not be two consecutive text nodes, so check to see if they need to be combined
// If they have been we can skip the last node of the nodes to add
if (CombineText(patch.last_child(), original.node().first_child(), true))
end--;
pugi::xml_node pos = original.node().first_child();
for (; start != end; start++)
original.node().insert_copy_before(*start, pos);
}
else if (strcmp(pos.value(), "before") == 0)
{
pugi::xml_node::iterator start = patch.begin();
pugi::xml_node::iterator end = patch.end();
// There can not be two consecutive text nodes, so check to see if they need to be combined
// If they have been we can skip the first node of the nodes to add
if (CombineText(patch.first_child(), original.node().previous_sibling(), false))
start++;
// There can not be two consecutive text nodes, so check to see if they need to be combined
// If they have been we can skip the last node of the nodes to add
if (CombineText(patch.last_child(), original.node(), true))
end--;
for (; start != end; start++)
original.parent().insert_copy_before(*start, original.node());
}
else if (strcmp(pos.value(), "after") == 0)
{
pugi::xml_node::iterator start = patch.begin();
pugi::xml_node::iterator end = patch.end();
// There can not be two consecutive text nodes, so check to see if they need to be combined
// If they have been we can skip the first node of the nodes to add
if (CombineText(patch.first_child(), original.node(), false))
start++;
// There can not be two consecutive text nodes, so check to see if they need to be combined
// If they have been we can skip the last node of the nodes to add
if (CombineText(patch.last_child(), original.node().next_sibling(), true))
end--;
pugi::xml_node pos = original.node();
for (; start != end; start++)
pos = original.parent().insert_copy_after(*start, pos);
}
}
bool Weapon::configureEvent(const pugi::xml_node& node)
{
pugi::xml_attribute attr;
if (!(attr = node.attribute("id"))) {
std::cout << "[Error - Weapon::configureEvent] Weapon without id." << std::endl;
return false;
}
id = pugi::cast<uint16_t>(attr.value());
if ((attr = node.attribute("level"))) {
level = pugi::cast<uint32_t>(attr.value());
}
if ((attr = node.attribute("maglv")) || (attr = node.attribute("maglevel"))) {
magLevel = pugi::cast<uint32_t>(attr.value());
}
if ((attr = node.attribute("mana"))) {
mana = pugi::cast<uint32_t>(attr.value());
}
if ((attr = node.attribute("manapercent"))) {
manaPercent = pugi::cast<uint32_t>(attr.value());
}
if ((attr = node.attribute("soul"))) {
soul = pugi::cast<uint32_t>(attr.value());
}
if ((attr = node.attribute("prem"))) {
premium = attr.as_bool();
}
if ((attr = node.attribute("breakchance"))) {
breakChance = std::min<uint8_t>(100, pugi::cast<uint16_t>(attr.value()));
}
if ((attr = node.attribute("action"))) {
action = getWeaponAction(asLowerCaseString(attr.as_string()));
if (action == WEAPONACTION_NONE) {
std::cout << "[Warning - Weapon::configureEvent] Unknown action " << attr.as_string() << std::endl;
}
}
if ((attr = node.attribute("enabled"))) {
enabled = attr.as_bool();
}
if ((attr = node.attribute("unproperly"))) {
wieldUnproperly = attr.as_bool();
}
std::list<std::string> vocStringList;
for (auto vocationNode : node.children()) {
if (!(attr = vocationNode.attribute("name"))) {
continue;
}
int32_t vocationId = g_vocations.getVocationId(attr.as_string());
if (vocationId != -1) {
vocWeaponMap[vocationId] = true;
int32_t promotedVocation = g_vocations.getPromotedVocation(vocationId);
if (promotedVocation != VOCATION_NONE) {
vocWeaponMap[promotedVocation] = true;
}
if (vocationNode.attribute("showInDescription").as_bool(true)) {
vocStringList.push_back(asLowerCaseString(attr.as_string()));
}
}
}
std::string vocationString;
for (const std::string& str : vocStringList) {
if (!vocationString.empty()) {
if (str != vocStringList.back()) {
vocationString.push_back(',');
vocationString.push_back(' ');
} else {
vocationString += " and ";
}
}
vocationString += str;
vocationString.push_back('s');
}
uint32_t wieldInfo = 0;
if (getReqLevel() > 0) {
wieldInfo |= WIELDINFO_LEVEL;
}
if (getReqMagLv() > 0) {
wieldInfo |= WIELDINFO_MAGLV;
}
if (!vocationString.empty()) {
wieldInfo |= WIELDINFO_VOCREQ;
}
if (isPremium()) {
wieldInfo |= WIELDINFO_PREMIUM;
}
if (wieldInfo != 0) {
ItemType& it = Item::items.getItemType(id);
it.wieldInfo = wieldInfo;
it.vocationString = vocationString;
it.minReqLevel = getReqLevel();
it.minReqMagicLevel = getReqMagLv();
}
configureWeapon(Item::items[id]);
return true;
}
void configuration_parser::output_directory_parser(const pugi::xml_node& doc)
{
results.back().output_directory = doc.child_value();
}
void configuration_parser::linker_executable_parser(const pugi::xml_node& doc)
{
results.back().linker_executable = doc.child_value();
}
void configuration_parser::linking_command_parser(const pugi::xml_node& doc)
{
results.back().linking_command = doc.child_value();
}
void configuration_parser::name_parser(const pugi::xml_node& doc)
{
results.back().name.push_back(doc.child_value());
}
bool MoveEvent::configureEvent(const pugi::xml_node& node)
{
pugi::xml_attribute eventAttr = node.attribute("event");
if (!eventAttr) {
std::cout << "[Error - MoveEvent::configureMoveEvent] Missing event" << std::endl;
return false;
}
std::string tmpStr = asLowerCaseString(eventAttr.as_string());
if (tmpStr == "stepin") {
m_eventType = MOVE_EVENT_STEP_IN;
} else if (tmpStr == "stepout") {
m_eventType = MOVE_EVENT_STEP_OUT;
} else if (tmpStr == "equip") {
m_eventType = MOVE_EVENT_EQUIP;
} else if (tmpStr == "deequip") {
m_eventType = MOVE_EVENT_DEEQUIP;
} else if (tmpStr == "additem") {
m_eventType = MOVE_EVENT_ADD_ITEM;
} else if (tmpStr == "removeitem") {
m_eventType = MOVE_EVENT_REMOVE_ITEM;
} else {
std::cout << "Error: [MoveEvent::configureMoveEvent] No valid event name " << eventAttr.as_string() << std::endl;
return false;
}
if (m_eventType == MOVE_EVENT_EQUIP || m_eventType == MOVE_EVENT_DEEQUIP) {
pugi::xml_attribute slotAttribute = node.attribute("slot");
if (slotAttribute) {
tmpStr = asLowerCaseString(slotAttribute.as_string());
if (tmpStr == "head") {
slot = SLOTP_HEAD;
} else if (tmpStr == "necklace") {
slot = SLOTP_NECKLACE;
} else if (tmpStr == "backpack") {
slot = SLOTP_BACKPACK;
} else if (tmpStr == "armor") {
slot = SLOTP_ARMOR;
} else if (tmpStr == "right-hand") {
slot = SLOTP_RIGHT;
} else if (tmpStr == "left-hand") {
slot = SLOTP_LEFT;
} else if (tmpStr == "hand" || tmpStr == "shield") {
slot = SLOTP_RIGHT | SLOTP_LEFT;
} else if (tmpStr == "legs") {
slot = SLOTP_LEGS;
} else if (tmpStr == "feet") {
slot = SLOTP_FEET;
} else if (tmpStr == "ring") {
slot = SLOTP_RING;
} else if (tmpStr == "ammo") {
slot = SLOTP_AMMO;
} else {
std::cout << "[Warning - MoveEvent::configureMoveEvent] Unknown slot type: " << slotAttribute.as_string() << std::endl;
}
}
wieldInfo = 0;
pugi::xml_attribute levelAttribute = node.attribute("level");
if (levelAttribute) {
reqLevel = pugi::cast<int32_t>(levelAttribute.value());
if (reqLevel > 0) {
wieldInfo |= WIELDINFO_LEVEL;
}
}
pugi::xml_attribute magLevelAttribute = node.attribute("maglevel");
if (magLevelAttribute) {
reqMagLevel = pugi::cast<int32_t>(magLevelAttribute.value());
if (reqMagLevel > 0) {
wieldInfo |= WIELDINFO_MAGLV;
}
}
pugi::xml_attribute premiumAttribute = node.attribute("premium");
if (premiumAttribute) {
premium = premiumAttribute.as_bool();
if (premium) {
wieldInfo |= WIELDINFO_PREMIUM;
}
}
//Gather vocation information
std::list<std::string> vocStringList;
for (pugi::xml_node vocationNode = node.first_child(); vocationNode; vocationNode = vocationNode.next_sibling()) {
pugi::xml_attribute vocationNameAttribute = vocationNode.attribute("name");
if (!vocationNameAttribute) {
continue;
}
int32_t vocationId = g_vocations.getVocationId(vocationNameAttribute.as_string());
if (vocationId != -1) {
vocEquipMap[vocationId] = true;
if (vocationNode.attribute("showInDescription").as_bool(true)) {
vocStringList.push_back(asLowerCaseString(vocationNameAttribute.as_string()));
}
}
}
if (!vocEquipMap.empty()) {
wieldInfo |= WIELDINFO_VOCREQ;
}
for (const std::string& str : vocStringList) {
if (!vocationString.empty()) {
if (str != vocStringList.back()) {
vocationString.push_back(',');
vocationString.push_back(' ');
} else {
vocationString += " and ";
}
}
vocationString += str;
vocationString.push_back('s');
}
}
return true;
}
NodePtr append_child(const char* name) {
pugi::xml_node n = m_node.append_child(name);
return NodePtr(new Node(m_parent,n));
}
void TBaluMaterial::Load(const pugi::xml_node& node, const int version, TBaluWorld* world)
{
name = node.attribute("name").as_string();
image_path = node.attribute("image_path").as_string();
color = LoadColor(node.child("Color"));
}
/**
* configures the filter
* @param n the xml subtree
*/
virtual void _configure(const pugi::xml_node& n )
{
if(pugi::xml_node c = n.child("ip_src"))
{
if(parse_filter_mode(c,m_ip_src_mode))
{
if(pugi::xml_attribute attr = c.attribute("address"))
{
m_ip_src_address = string_to_ip(attr.value());
}
else signal_error ("ip_src");
if(pugi::xml_attribute attr = c.attribute("netmask"))
{
m_ip_src_mask = string_to_ip(attr.value());
}
else signal_error ("ip_src");
}
else
signal_error("ip_src");
}
if(pugi::xml_node c = n.child("ip_dst"))
{
if(parse_filter_mode(c,m_ip_dst_mode))
{
if(pugi::xml_attribute attr = c.attribute("address"))
{
m_ip_dst_address = string_to_ip(attr.value());
}
else signal_error ("ip_dst");
if(pugi::xml_attribute attr = c.attribute("netmask"))
{
m_ip_dst_mask = string_to_ip(attr.value());
}
else signal_error ("ip_dst");
}
else
signal_error("ip_dst");
}
if(pugi::xml_node c = n.child("l4_protocol"))
{
if(parse_filter_mode(c,m_layer4_mode))
{
if(pugi::xml_attribute attr = c.attribute("number"))
{
m_layer4_proto = attr.as_uint();
}
else
signal_error("l4_protocol");
}
else
signal_error("l4_protocol");
}
if(pugi::xml_node c = n.child("src_port"))
{
if(parse_filter_mode(c,m_src_port_mode))
{
if(pugi::xml_attribute attr = c.attribute("number"))
{
m_src_port = attr.as_uint();
}
else
signal_error("src_port");
}
else
signal_error("src_port");
}
if(pugi::xml_node c = n.child("dst_port"))
{
if(parse_filter_mode(c,m_dst_port_mode))
{
if(pugi::xml_attribute attr = c.attribute("number"))
{
m_dst_port = attr.as_uint();
}
else
signal_error("dst_port");
}
else
signal_error("dst_port");
}
}
bool has_attribute(const char* name) const {
return m_node.attribute(name);
}
//---------------------------------------------------------------------------
int t_mep_parameters::from_xml(pugi::xml_node parent)
{
pugi::xml_node node = parent.child("mutation_probability");
if (node)
{
const char *value_as_cstring = node.child_value();
mutation_probability = atof(value_as_cstring);
}
node = parent.child("crossover_probability");
if (node)
{
const char *value_as_cstring = node.child_value();
crossover_probability = atof(value_as_cstring);
}
node = parent.child("chromosome_length");
if (node)
{
const char *value_as_cstring = node.child_value();
code_length = atoi(value_as_cstring);
}
node = parent.child("crossover_type");
if (node)
{
const char *value_as_cstring = node.child_value();
crossover_type = atoi(value_as_cstring);
}
node = parent.child("subpopulation_size");
if (node)
{
const char *value_as_cstring = node.child_value();
subpopulation_size = atoi(value_as_cstring);
}
node = parent.child("num_subpopulations");
if (node)
{
const char *value_as_cstring = node.child_value();
num_subpopulations = atoi(value_as_cstring);
}
node = parent.child("operators_probability");
if (node)
{
const char *value_as_cstring = node.child_value();
operators_probability = atof(value_as_cstring);
}
node = parent.child("variables_probability");
if (node)
{
const char *value_as_cstring = node.child_value();
variables_probability = atof(value_as_cstring);
}
node = parent.child("constants_probability");
if (node)
{
const char *value_as_cstring = node.child_value();
constants_probability = atof(value_as_cstring);
}
node = parent.child("number_of_generations");
if (node)
{
const char *value_as_cstring = node.child_value();
num_generations = atoi(value_as_cstring);
}
node = parent.child("tournament_size");
if (node)
{
const char *value_as_cstring = node.child_value();
tournament_size = atoi(value_as_cstring);
}
node = parent.child("problem_type");
if (node)
{
const char *value_as_cstring = node.child_value();
problem_type = atoi(value_as_cstring);
}
node = parent.child("random_seed");
if (node)
{
const char *value_as_cstring = node.child_value();
random_seed = atoi(value_as_cstring);
}
else
random_seed = 0;
node = parent.child("num_runs");
if (node)
{
const char *value_as_cstring = node.child_value();
num_runs = atoi(value_as_cstring);
}
else
num_runs = 1;
node = parent.child("use_validation_data");
if (node)
{
const char *value_as_cstring = node.child_value();
use_validation_data = atoi(value_as_cstring);
}
else
use_validation_data = 0;
node = parent.child("simplified");
if (node)
{
const char *value_as_cstring = node.child_value();
simplified_programs = atoi(value_as_cstring);
}
else
simplified_programs = 0;
node = parent.child("num_threads");
if (node)
{
const char *value_as_cstring = node.child_value();
num_threads = atoi(value_as_cstring);
}
else
num_threads = 1;
node = parent.child("constants");
if (node)
{
constants.from_xml(node);
}
else
constants.init();
return true;
}
void remove_attribute(const char* name) {
m_node.remove_attribute(name);
}
/**
* @brief Configures the block: defines the capture interface, the possible hw-queues in use, etc.
* @param n The configuration parameters
*/
virtual void _configure(const pugi::xml_node& n)
{
std::cout << __PRETTY_FUNCTION__ << std::endl;
int offset = 0;
int slots = 131072;
int caplen = 1514;
bool timestamp = false;
pugi::xml_node queues = n.child("queues");
if(!queues)
throw std::runtime_error("PFQSource:: no queues node");
m_device = std::string(queues.attribute("device").value());
if(m_device.length()==0)
throw std::runtime_error("PFQSource::no device attribute ");
auto clattr = queues.attribute("caplen");
auto offattr = queues.attribute("offset");
auto slotattr = queues.attribute("slots");
auto tsattr = queues.attribute("tstamp");
if (!clattr.empty())
caplen = clattr.as_int();
if (!offattr.empty())
offset = offattr.as_int();
if (!slotattr.empty())
slots = slotattr.as_int();
if (!tsattr.empty())
timestamp = tsattr.as_bool();
std::vector<unsigned int> vq;
m_pfq.open(caplen, offset, slots);
for (xml_node queue=queues.child("queue"); queue; queue=queue.next_sibling("queue"))
vq.push_back(queue.attribute("number").as_uint());
if(!vq.empty())
{
auto it = vq.begin();
auto it_e = vq.end();
for (;it!=it_e;++it)
{
m_pfq.add_device(m_device.c_str(),*it);
}
}
else
{
blocklog("PFQSource: no queues specified, sniffing on device ", log_info);
m_pfq.add_device(m_device.c_str(), net::pfq::any_queue);
}
std::cout << "PFQ: dev:" << m_device << " caplen:" << caplen << " tstamp:" << std::boolalpha << timestamp;
std::cout << " queues:";
std::copy(vq.begin(), vq.end(), std::ostream_iterator<int>(std::cout, ","));
std::cout << std::endl;
{
std::lock_guard<std::mutex> lock(m_mutex);
m_max_caplen = std::max(m_max_caplen, caplen);
}
net::payload::size_of(m_max_caplen);
// the slice_allocator must be created once the dynamic_buffer (or net::payload)
// is set to a given size.
//
#if defined(USE_SIMPLE_PACKET) || defined(USE_SLICED_PACKET)
m_allocator.reset(new allocator_type);
#endif
m_pfq.caplen(caplen);
m_pfq.toggle_time_stamp(timestamp);
m_pfq.enable();
}
const char* get_attribute(const char* name) {
if (!m_node.attribute(name))
return 0;
return m_node.attribute(name).value();
}
bool ItemDatabase::loadItemFromGameXml(pugi::xml_node itemNode, int id)
{
ClientVersionID clientVersion = gui.GetCurrentVersionID();
if (clientVersion < CLIENT_VERSION_980 && id > 20000 && id < 20100) {
itemNode = itemNode.next_sibling();
return true;
} else if (id > 30000 && id < 30100) {
itemNode = itemNode.next_sibling();
return true;
}
ItemType& it = getItemType(id);
it.name = itemNode.attribute("name").as_string();
it.editorsuffix = itemNode.attribute("editorsuffix").as_string();
pugi::xml_attribute attribute;
for (pugi::xml_node itemAttributesNode = itemNode.first_child(); itemAttributesNode; itemAttributesNode = itemAttributesNode.next_sibling()) {
if (!(attribute = itemAttributesNode.attribute("key"))) {
continue;
}
std::string key = attribute.as_string();
to_lower_str(key);
if (key == "type") {
if (!(attribute = itemAttributesNode.attribute("value"))) {
continue;
}
std::string typeValue = attribute.as_string();
to_lower_str(key);
if (typeValue == "magicfield") {
it.group = ITEM_GROUP_MAGICFIELD;
it.type = ITEM_TYPE_MAGICFIELD;
} else if (typeValue == "key") {
it.type = ITEM_TYPE_KEY;
} else if (typeValue == "depot") {
it.type = ITEM_TYPE_DEPOT;
} else if (typeValue == "teleport") {
it.type = ITEM_TYPE_TELEPORT;
} else if (typeValue == "bed") {
it.type = ITEM_TYPE_BED;
} else if (typeValue == "door") {
it.type = ITEM_TYPE_DOOR;
} else {
// We ignore many types, no need to complain
//warnings.push_back("items.xml: Unknown type " + typeValue);
}
} else if (key == "name") {
if ((attribute = itemAttributesNode.attribute("value"))) {
it.name = attribute.as_string();
}
} else if (key == "description") {
if ((attribute = itemAttributesNode.attribute("value"))) {
it.description = attribute.as_string();
}
}else if (key == "runespellName") {
/*if ((attribute = itemAttributesNode.attribute("value"))) {
it.runeSpellName = attribute.as_string();
}*/
} else if (key == "weight") {
if ((attribute = itemAttributesNode.attribute("value"))) {
it.weight = pugi::cast<int32_t>(attribute.value()) / 100.f;
}
} else if (key == "armor") {
if ((attribute = itemAttributesNode.attribute("value"))) {
it.armor = pugi::cast<int32_t>(attribute.value());
}
} else if (key == "defense") {
if ((attribute = itemAttributesNode.attribute("value"))) {
it.defense = pugi::cast<int32_t>(attribute.value());
}
} else if (key == "rotateto") {
if ((attribute = itemAttributesNode.attribute("value"))) {
it.rotateTo = pugi::cast<int32_t>(attribute.value());
}
} else if (key == "containersize") {
if ((attribute = itemAttributesNode.attribute("value"))) {
it.volume = pugi::cast<int32_t>(attribute.value());
}
} else if (key == "readable") {
if ((attribute = itemAttributesNode.attribute("value"))) {
it.canReadText = attribute.as_bool();
}
} else if (key == "writeable") {
if ((attribute = itemAttributesNode.attribute("value"))) {
it.canWriteText = it.canReadText = attribute.as_bool();
}
} else if (key == "decayto") {
it.decays = true;
} else if (key == "maxtextlen" || key == "maxtextlength") {
if ((attribute = itemAttributesNode.attribute("value"))) {
it.maxTextLen = pugi::cast<int32_t>(attribute.value());
it.canReadText = it.maxTextLen > 0;
}
} else if (key == "writeonceitemid") {
/*if ((attribute = itemAttributesNode.attribute("value"))) {
it.writeOnceItemId = pugi::cast<int32_t>(attribute.value());
}*/
} else if (key == "allowdistread") {
if ((attribute = itemAttributesNode.attribute("value"))) {
it.allowDistRead = attribute.as_bool();
}
} else if (key == "charges") {
if ((attribute = itemAttributesNode.attribute("value"))) {
it.charges = pugi::cast<int32_t>(attribute.value());
it.extra_chargeable = true;
}
}
}
return true;
}
const char* get_name() const {
return m_node.name();
}
///We parse the Cfd node here. This node contains the information necessary to the proper function of the various Cfd
/// timing codes. The only currently recognized node here is the Parameters node. If the Cfd node exists then the
/// Parameter node must also exist.
void MapNodeXmlParser::ParseCfdNode(const pugi::xml_node &node, TimingConfiguration &config, const bool &isVerbose) {
config.SetFraction(node.attribute("f").as_double(DefaultConfig::cfdF));
config.SetDelay(node.attribute("d").as_uint(DefaultConfig::cfdD));
config.SetLength(node.attribute("l").as_uint(DefaultConfig::cfdL));
config.SetGap(node.attribute("g").as_uint(DefaultConfig::cfdL));
}
const char* get_value() const {
return m_node.child_value();
}
void Composition::install(const pugi::xml_node& config)
{
for (pugi::xml_node blocknode=config.child("block"); blocknode; blocknode=blocknode.next_sibling("block"))
{
std::string name = blocknode.attribute("id").value();
std::string type = blocknode.attribute("type").value();
if((name.length() == 0) || (type.length() == 0)) {
throw std::runtime_error("block name or type missing");
}
std::string threadpool=blocknode.attribute("threadpool").value();
invocation_type invocation = invocation_type::Direct;
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* OLD AND BUSTED sched_type attribute
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
std::string sched_type=blocknode.attribute("sched_type").value();
if (sched_type.length() > 0) {
if (sched_type.compare("active") == 0) {
invocation = invocation_type::Indirect;
} else {
std::runtime_error("sched_type val invalid");
}
}
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* NEW invocation attribute (wins)
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
std::string invocation_str=blocknode.attribute("invocation").value();
if (invocation_str.length() > 0) {
if (invocation_str.compare("direct") == 0) {
invocation = invocation_type::Direct;
} else if (invocation_str.compare("indirect") == 0) {
invocation = invocation_type::Indirect;
} else if (invocation_str.compare("async") == 0) {
invocation = invocation_type::Async;
} else {
std::runtime_error("invalid invocation type: use direct, indirect, async");
}
}
create_block_from_parsed(type, name, invocation, blocknode);
if (invocation == invocation_type::Indirect || invocation == invocation_type::Async) {
if (threadpool.length() == 0) {
throw std::runtime_error("need a threadpool for active/async invocation");
}
PoolManager::instance().add_to_pool(threadpool, m_map[name]);
}
}
for (pugi::xml_node link=config.child("connection"); link; link=link.next_sibling("connection"))
{
std::string from_block=link.attribute("src_block").value();
if (from_block.length() == 0) throw std::runtime_error("missing begin block in connection");
std::string from_gate=link.attribute("src_gate").value();
if (from_gate.length() == 0) throw std::runtime_error("missing begin gate in connection");
std::string to_block=link.attribute("dst_block").value();
if (to_block.length() == 0) throw std::runtime_error("missing dst block in connection");
std::string to_gate=link.attribute("dst_gate").value();
if (to_gate.length() == 0) throw std::runtime_error("missing begin gate in connection");
create_link(from_block, from_gate, to_block, to_gate);
}
// initialize the configured blocks...
//
initialize();
}
void set_value(const char* v) {
m_node.set_value(v);
}
bool Monsters::deserializeSpell(const pugi::xml_node& node, spellBlock_t& sb, const std::string& description)
{
sb.chance = 100;
sb.speed = 2000;
sb.range = 0;
sb.minCombatValue = 0;
sb.maxCombatValue = 0;
sb.combatSpell = false;
sb.isMelee = false;
std::string name;
std::string scriptName;
bool isScripted = false;
pugi::xml_attribute attr;
if ((attr = node.attribute("script"))) {
scriptName = attr.as_string();
isScripted = true;
} else if ((attr = node.attribute("name"))) {
name = attr.as_string();
} else {
return false;
}
if ((attr = node.attribute("speed")) || (attr = node.attribute("interval"))) {
sb.speed = std::max<int32_t>(1, pugi::cast<int32_t>(attr.value()));
}
if ((attr = node.attribute("chance"))) {
uint32_t chance = pugi::cast<uint32_t>(attr.value());
if (chance > 100) {
chance = 100;
}
sb.chance = chance;
}
if ((attr = node.attribute("range"))) {
uint32_t range = pugi::cast<uint32_t>(attr.value());
if (range > (Map::maxViewportX * 2)) {
range = Map::maxViewportX * 2;
}
sb.range = range;
}
if ((attr = node.attribute("min"))) {
sb.minCombatValue = pugi::cast<int32_t>(attr.value());
}
if ((attr = node.attribute("max"))) {
sb.maxCombatValue = pugi::cast<int32_t>(attr.value());
//normalize values
if (std::abs(sb.minCombatValue) > std::abs(sb.maxCombatValue)) {
int32_t value = sb.maxCombatValue;
sb.maxCombatValue = sb.minCombatValue;
sb.minCombatValue = value;
}
}
sb.spell = g_spells->getSpellByName(name);
if (sb.spell) {
return true;
}
CombatSpell* combatSpell = nullptr;
bool needTarget = false;
bool needDirection = false;
if (isScripted) {
if ((attr = node.attribute("direction"))) {
needDirection = attr.as_bool();
}
if ((attr = node.attribute("target"))) {
needTarget = attr.as_bool();
}
combatSpell = new CombatSpell(nullptr, needTarget, needDirection);
if (!combatSpell->loadScript("data/" + g_spells->getScriptBaseName() + "/scripts/" + scriptName)) {
delete combatSpell;
return false;
}
if (!combatSpell->loadScriptCombat()) {
delete combatSpell;
return false;
}
combatSpell->getCombat()->setPlayerCombatValues(FORMULA_VALUE, sb.minCombatValue, 0, sb.maxCombatValue, 0);
} else {
Combat* combat = new Combat;
sb.combatSpell = true;
if ((attr = node.attribute("length"))) {
int32_t length = pugi::cast<int32_t>(attr.value());
if (length > 0) {
int32_t spread = 3;
//need direction spell
if ((attr = node.attribute("spread"))) {
spread = std::max<int32_t>(0, pugi::cast<int32_t>(attr.value()));
}
AreaCombat* area = new AreaCombat();
area->setupArea(length, spread);
combat->setArea(area);
needDirection = true;
}
}
if ((attr = node.attribute("radius"))) {
int32_t radius = pugi::cast<int32_t>(attr.value());
//target spell
if ((attr = node.attribute("target"))) {
needTarget = attr.as_bool();
}
AreaCombat* area = new AreaCombat();
area->setupArea(radius);
combat->setArea(area);
}
std::string tmpName = asLowerCaseString(name);
if (tmpName == "melee") {
sb.isMelee = true;
pugi::xml_attribute attackAttribute, skillAttribute;
if ((attackAttribute = node.attribute("attack")) && (skillAttribute = node.attribute("skill"))) {
sb.minCombatValue = 0;
sb.maxCombatValue = -Weapons::getMaxMeleeDamage(pugi::cast<int32_t>(skillAttribute.value()), pugi::cast<int32_t>(attackAttribute.value()));
}
ConditionType_t conditionType = CONDITION_NONE;
int32_t minDamage = 0;
int32_t maxDamage = 0;
uint32_t tickInterval = 2000;
if ((attr = node.attribute("fire"))) {
conditionType = CONDITION_FIRE;
minDamage = pugi::cast<int32_t>(attr.value());
maxDamage = minDamage;
tickInterval = 9000;
} else if ((attr = node.attribute("poison"))) {
conditionType = CONDITION_POISON;
minDamage = pugi::cast<int32_t>(attr.value());
maxDamage = minDamage;
tickInterval = 5000;
} else if ((attr = node.attribute("energy"))) {
conditionType = CONDITION_ENERGY;
minDamage = pugi::cast<int32_t>(attr.value());
maxDamage = minDamage;
tickInterval = 10000;
} else if ((attr = node.attribute("drown"))) {
conditionType = CONDITION_DROWN;
minDamage = pugi::cast<int32_t>(attr.value());
maxDamage = minDamage;
tickInterval = 5000;
} else if ((attr = node.attribute("freeze"))) {
conditionType = CONDITION_FREEZING;
minDamage = pugi::cast<int32_t>(attr.value());
maxDamage = minDamage;
tickInterval = 8000;
} else if ((attr = node.attribute("dazzle"))) {
conditionType = CONDITION_DAZZLED;
minDamage = pugi::cast<int32_t>(attr.value());
maxDamage = minDamage;
tickInterval = 10000;
} else if ((attr = node.attribute("curse"))) {
conditionType = CONDITION_CURSED;
minDamage = pugi::cast<int32_t>(attr.value());
maxDamage = minDamage;
tickInterval = 4000;
} else if ((attr = node.attribute("bleed")) || (attr = node.attribute("physical"))) {
conditionType = CONDITION_BLEEDING;
tickInterval = 5000;
}
if ((attr = node.attribute("tick"))) {
int32_t value = pugi::cast<int32_t>(attr.value());
if (value > 0) {
tickInterval = value;
}
}
if (conditionType != CONDITION_NONE) {
Condition* condition = getDamageCondition(conditionType, maxDamage, minDamage, 0, tickInterval);
combat->setCondition(condition);
}
sb.range = 1;
combat->setParam(COMBATPARAM_COMBATTYPE, COMBAT_PHYSICALDAMAGE);
combat->setParam(COMBATPARAM_BLOCKEDBYARMOR, 1);
combat->setParam(COMBATPARAM_BLOCKEDBYSHIELD, 1);
} else if (tmpName == "physical") {
combat->setParam(COMBATPARAM_COMBATTYPE, COMBAT_PHYSICALDAMAGE);
combat->setParam(COMBATPARAM_BLOCKEDBYARMOR, 1);
} else if (tmpName == "bleed") {
combat->setParam(COMBATPARAM_COMBATTYPE, COMBAT_PHYSICALDAMAGE);
} else if (tmpName == "poison" || tmpName == "earth") {
combat->setParam(COMBATPARAM_COMBATTYPE, COMBAT_EARTHDAMAGE);
} else if (tmpName == "fire") {
combat->setParam(COMBATPARAM_COMBATTYPE, COMBAT_FIREDAMAGE);
} else if (tmpName == "energy") {
combat->setParam(COMBATPARAM_COMBATTYPE, COMBAT_ENERGYDAMAGE);
} else if (tmpName == "drown") {
combat->setParam(COMBATPARAM_COMBATTYPE, COMBAT_DROWNDAMAGE);
} else if (tmpName == "ice") {
combat->setParam(COMBATPARAM_COMBATTYPE, COMBAT_ICEDAMAGE);
} else if (tmpName == "holy") {
combat->setParam(COMBATPARAM_COMBATTYPE, COMBAT_HOLYDAMAGE);
} else if (tmpName == "death") {
combat->setParam(COMBATPARAM_COMBATTYPE, COMBAT_DEATHDAMAGE);
} else if (tmpName == "lifedrain") {
combat->setParam(COMBATPARAM_COMBATTYPE, COMBAT_LIFEDRAIN);
} else if (tmpName == "manadrain") {
combat->setParam(COMBATPARAM_COMBATTYPE, COMBAT_MANADRAIN);
} else if (tmpName == "healing") {
combat->setParam(COMBATPARAM_COMBATTYPE, COMBAT_HEALING);
combat->setParam(COMBATPARAM_AGGRESSIVE, 0);
} else if (tmpName == "speed") {
int32_t speedChange = 0;
int32_t duration = 10000;
if ((attr = node.attribute("duration"))) {
duration = pugi::cast<int32_t>(attr.value());
}
if ((attr = node.attribute("speedchange"))) {
speedChange = pugi::cast<int32_t>(attr.value());
if (speedChange < -1000) {
//cant be slower than 100%
speedChange = -1000;
}
}
ConditionType_t conditionType;
if (speedChange > 0) {
conditionType = CONDITION_HASTE;
combat->setParam(COMBATPARAM_AGGRESSIVE, 0);
} else {
conditionType = CONDITION_PARALYZE;
}
ConditionSpeed* condition = dynamic_cast<ConditionSpeed*>(Condition::createCondition(CONDITIONID_COMBAT, conditionType, duration, 0));
condition->setFormulaVars(speedChange / 1000.0, 0, speedChange / 1000.0, 0);
combat->setCondition(condition);
} else if (tmpName == "outfit") {
int32_t duration = 10000;
if ((attr = node.attribute("duration"))) {
duration = pugi::cast<int32_t>(attr.value());
}
if ((attr = node.attribute("monster"))) {
MonsterType* mType = g_monsters.getMonsterType(attr.as_string());
if (mType) {
ConditionOutfit* condition = dynamic_cast<ConditionOutfit*>(Condition::createCondition(CONDITIONID_COMBAT, CONDITION_OUTFIT, duration, 0));
condition->addOutfit(mType->outfit);
combat->setParam(COMBATPARAM_AGGRESSIVE, 0);
combat->setCondition(condition);
}
} else if ((attr = node.attribute("item"))) {
Outfit_t outfit;
outfit.lookTypeEx = pugi::cast<uint16_t>(attr.value());
ConditionOutfit* condition = dynamic_cast<ConditionOutfit*>(Condition::createCondition(CONDITIONID_COMBAT, CONDITION_OUTFIT, duration, 0));
condition->addOutfit(outfit);
combat->setParam(COMBATPARAM_AGGRESSIVE, 0);
combat->setCondition(condition);
}
} else if (tmpName == "invisible") {
int32_t duration = 10000;
if ((attr = node.attribute("duration"))) {
duration = pugi::cast<int32_t>(attr.value());
}
Condition* condition = Condition::createCondition(CONDITIONID_COMBAT, CONDITION_INVISIBLE, duration, 0);
combat->setParam(COMBATPARAM_AGGRESSIVE, 0);
combat->setCondition(condition);
} else if (tmpName == "drunk") {
int32_t duration = 10000;
if ((attr = node.attribute("duration"))) {
duration = pugi::cast<int32_t>(attr.value());
}
Condition* condition = Condition::createCondition(CONDITIONID_COMBAT, CONDITION_DRUNK, duration, 0);
combat->setCondition(condition);
} else if (tmpName == "firefield") {
combat->setParam(COMBATPARAM_CREATEITEM, ITEM_FIREFIELD_PVP_FULL);
} else if (tmpName == "poisonfield") {
combat->setParam(COMBATPARAM_CREATEITEM, ITEM_POISONFIELD_PVP);
} else if (tmpName == "energyfield") {
combat->setParam(COMBATPARAM_CREATEITEM, ITEM_ENERGYFIELD_PVP);
} else if (tmpName == "firecondition" || tmpName == "energycondition" ||
tmpName == "earthcondition" || tmpName == "poisoncondition" ||
tmpName == "icecondition" || tmpName == "freezecondition" ||
tmpName == "deathcondition" || tmpName == "cursecondition" ||
tmpName == "holycondition" || tmpName == "dazzlecondition" ||
tmpName == "drowncondition" || tmpName == "bleedcondition" ||
tmpName == "physicalcondition") {
ConditionType_t conditionType = CONDITION_NONE;
uint32_t tickInterval = 2000;
if (tmpName == "firecondition") {
conditionType = CONDITION_FIRE;
tickInterval = 10000;
} else if (tmpName == "poisoncondition" || tmpName == "earthcondition") {
conditionType = CONDITION_POISON;
tickInterval = 5000;
} else if (tmpName == "energycondition") {
conditionType = CONDITION_ENERGY;
tickInterval = 10000;
} else if (tmpName == "drowncondition") {
conditionType = CONDITION_DROWN;
tickInterval = 5000;
} else if (tmpName == "freezecondition" || tmpName == "icecondition") {
conditionType = CONDITION_FREEZING;
tickInterval = 10000;
} else if (tmpName == "cursecondition" || tmpName == "deathcondition") {
conditionType = CONDITION_CURSED;
tickInterval = 4000;
} else if (tmpName == "dazzlecondition" || tmpName == "holycondition") {
conditionType = CONDITION_DAZZLED;
tickInterval = 10000;
} else if (tmpName == "physicalcondition" || tmpName == "bleedcondition") {
conditionType = CONDITION_BLEEDING;
tickInterval = 5000;
}
if ((attr = node.attribute("tick"))) {
int32_t value = pugi::cast<int32_t>(attr.value());
if (value > 0) {
tickInterval = value;
}
}
int32_t minDamage = std::abs(sb.minCombatValue);
int32_t maxDamage = std::abs(sb.maxCombatValue);
int32_t startDamage = 0;
if ((attr = node.attribute("start"))) {
int32_t value = std::abs(pugi::cast<int32_t>(attr.value()));
if (value <= minDamage) {
startDamage = value;
}
}
Condition* condition = getDamageCondition(conditionType, maxDamage, minDamage, startDamage, tickInterval);
combat->setCondition(condition);
} else if (tmpName == "strength") {
//
} else if (tmpName == "effect") {
//
} else {
std::cout << "[Error - Monsters::deserializeSpell] - " << description << " - Unknown spell name: " << name << std::endl;
delete combat;
return false;
}
combat->setPlayerCombatValues(FORMULA_VALUE, sb.minCombatValue, 0, sb.maxCombatValue, 0);
combatSpell = new CombatSpell(combat, needTarget, needDirection);
for (pugi::xml_node attributeNode = node.first_child(); attributeNode; attributeNode = attributeNode.next_sibling()) {
if ((attr = attributeNode.attribute("key"))) {
std::string tmpStrValue = asLowerCaseString(attr.as_string());
if (tmpStrValue == "shooteffect") {
if ((attr = attributeNode.attribute("value"))) {
ShootType_t shoot = getShootType(attr.as_string());
if (shoot != NM_SHOOT_UNK) {
combat->setParam(COMBATPARAM_DISTANCEEFFECT, shoot);
} else {
std::cout << "[Warning - Monsters::deserializeSpell] " << description << " - Unknown shootEffect: " << attr.as_string() << std::endl;
}
}
} else if (tmpStrValue == "areaeffect") {
if ((attr = attributeNode.attribute("value"))) {
MagicEffectClasses effect = getMagicEffect(attr.as_string());
if (effect != NM_ME_UNK) {
combat->setParam(COMBATPARAM_EFFECT, effect);
} else {
std::cout << "[Warning - Monsters::deserializeSpell] " << description << " - Unknown areaEffect: " << attr.as_string() << std::endl;
}
}
} else {
std::cout << "[Warning - Monsters::deserializeSpells] Effect type \"" << attr.as_string() << "\" does not exist." << std::endl;
}
}
}
}
sb.spell = combatSpell;
return true;
}
int32_t
GCConfigTest::allocationWalker(pugi::xml_node node)
{
OMRPORT_ACCESS_FROM_OMRVM(exampleVM->_omrVM);
int32_t rt = 0;
AttributeElem *numOfFieldsElem = NULL;
AttributeElem *breadthElem = NULL;
int32_t depth = 0;
OMRGCObjectType objType = INVALID;
const char *namePrefixStr = node.attribute("namePrefix").value();
const char *numOfFieldsStr = node.attribute("numOfFields").value();
const char *typeStr = node.attribute("type").value();
const char *breadthStr = node.attribute("breadth").value();
const char *depthStr = node.attribute("depth").value();
if (0 != strcmp(node.name(), "object")) {
/* allow non-object node nested inside allocation? */
goto done;
}
if ((0 == strcmp(namePrefixStr, "")) || (0 == strcmp(typeStr, "")) || (0 == strcmp(numOfFieldsStr, ""))) {
rt = 1;
omrtty_printf("%s:%d Invalid XML input: please specify namePrefix, type and numOfFields for object %s.\n", __FILE__, __LINE__, namePrefixStr);
goto done;
}
/* set default value for breadth and depth to 1 */
if (0 == strcmp(breadthStr, "")) {
breadthStr = "1";
}
if (0 == strcmp(depthStr, "")) {
depthStr = "1";
}
depth = atoi(depthStr);
objType = parseObjectType(node);
rt = parseAttribute(&numOfFieldsElem, numOfFieldsStr);
OMRGCTEST_CHECK_RT(rt)
rt = parseAttribute(&breadthElem, breadthStr);
OMRGCTEST_CHECK_RT(rt);
/* process current xml node, perform allocation for single object or object tree */
rt = processObjNode(node, namePrefixStr, objType, numOfFieldsElem, breadthElem, depth);
OMRGCTEST_CHECK_RT(rt);
/* only single object can contain nested child object */
if ((0 == strcmp(breadthStr, "1")) && (0 == strcmp(depthStr, "1"))) {
for (pugi::xml_node childNode = node.first_child(); childNode; childNode = childNode.next_sibling()) {
rt = allocationWalker(childNode);
OMRGCTEST_CHECK_RT(rt);
}
}
/* After the entire garbage tree is allocated, remove garbage root object from the root set
* or remove garbage top object from the slot of its parent object. */
if (GARBAGE_ROOT == objType) {
for (int32_t i = 0; i < breadthElem->value; i++) {
char objName[MAX_NAME_LENGTH];
omrstr_printf(objName, MAX_NAME_LENGTH, "%s_%d_%d", namePrefixStr, 0, i);
rt = removeObjectFromRootTable(objName);
OMRGCTEST_CHECK_RT(rt);
}
} else if (GARBAGE_TOP == objType) {
char parentName[MAX_NAME_LENGTH];
omrstr_printf(parentName, MAX_NAME_LENGTH, "%s_%d_%d", node.parent().attribute("namePrefix").value(), 0, 0);
ObjectEntry *parentEntry;
rt = objectTable.find(&parentEntry, parentName);
if (0 != rt) {
omrtty_printf("%s:%d Could not find object %s in hash table.\n", __FILE__, __LINE__, parentName);
goto done;
}
omrobjectptr_t parentPtr = parentEntry->objPtr;
for (int32_t i = 0; i < breadthElem->value; i++) {
char objName[MAX_NAME_LENGTH];
omrstr_printf(objName, MAX_NAME_LENGTH, "%s_%d_%d", namePrefixStr, 0, i);
rt = removeObjectFromParentSlot(objName, parentPtr);
OMRGCTEST_CHECK_RT(rt);
}
}
/* insert garbage per tree */
if ((0 == strcmp(gp.frequency, "perRootStruct")) && (ROOT == objType)){
rt = insertGarbage();
OMRGCTEST_CHECK_RT(rt);
}
done:
freeAttributeList(breadthElem);
freeAttributeList(numOfFieldsElem);
return rt;
}