ItemDB Namespace Reference

Typedefs
typedef std::map< int, ItemInfo * >	ItemInfos
typedef std::map< std::string, ItemInfo * >	NamedItemInfos

Functions
void	load ()
void	unload ()
void	loadXmlFile (const std::string &fileName, int &tagNum, const SkipError skipError)
const StringVect &	getTags ()
bool	exists (const int id)
bool	exists (const std::string &name)
const ItemInfo &	get (const int id)
const ItemInfo &	get (const std::string &name)
const ItemInfo &	getEmpty ()
int	getNumOfHairstyles ()
const ItemDB::ItemInfos &	getItemInfos ()
std::string	getNamesStr (const std::vector< int > &parts)
int	getTagId (const std::string &tagName)

Detailed Description

Item information database.

Typedef Documentation

ItemInfos

typedef std::map<int, ItemInfo*> ItemDB::ItemInfos

Definition at line 63 of file itemdb.h.

NamedItemInfos

typedef std::map<std::string, ItemInfo*> ItemDB::NamedItemInfos

Definition at line 64 of file itemdb.h.

Function Documentation

exists() [1/2]

bool ItemDB::exists

(

const int

id

)

Definition at line 773 of file itemdb.cpp.

{
 if (!mLoaded)
 return false;
 
 const ItemInfos::const_iterator i = mItemInfos.find(id);
 return i != mItemInfos.end();
}

References anonymous_namespace{itemdb.cpp}::mItemInfos, and anonymous_namespace{itemdb.cpp}::mLoaded.

Referenced by load(), TextCommand::loadImage(), and Being::setSubtype().

exists() [2/2]

bool ItemDB::exists

(

const std::string &

name

)

Definition at line 782 of file itemdb.cpp.

{
 if (!mLoaded)
 return false;
 
 const NamedItemInfos::const_iterator i = mNamedItemInfos.find(
 normalize(name));
 return i != mNamedItemInfos.end();
}

References anonymous_namespace{itemdb.cpp}::mLoaded, anonymous_namespace{itemdb.cpp}::mNamedItemInfos, and normalize().

get() [1/2]

const ItemInfo & ItemDB::get

(

const int

id

)

Definition at line 792 of file itemdb.cpp.

{
 if (!mLoaded)
 load();
 
 const ItemInfos::const_iterator i = mItemInfos.find(id);
 
 if (i == mItemInfos.end())
 {
 reportAlways("ItemDB: Warning, unknown item ID# %d", id)
 return *mUnknown;
 }
 
 return *(i->second);
}

References AvatarDB::load(), anonymous_namespace{itemdb.cpp}::mItemInfos, anonymous_namespace{itemdb.cpp}::mLoaded, anonymous_namespace{itemdb.cpp}::mUnknown, and reportAlways.

Referenced by ItemAmountWindow::action(), Being::addItemParticlesCards(), ActorManager::cloneBeing(), ItemPopup::getCardsString(), ItemColorManager::getColorFromCards(), Item::getImage(), FloorItem::getInfo(), Item::getInfo(), FloorItem::getName(), Item::getName(), ItemSoundManager::getSoundEffect(), ItemInfo::getSprite(), Being::handleAttack(), ItemLinkHandler::handleItemLink(), load(), TextCommand::loadImage(), ItemSoundManager::playSfx(), FloorItem::postInit(), EAthena::BeingRecv::processBeingChangeLookContinue(), TmwAthena::BeingRecv::processBeingMove(), TmwAthena::BeingRecv::processBeingVisible(), EAthena::HomunculusRecv::processHomunculusFood(), EAthena::InventoryRecv::processPlayerInventoryAdd(), TmwAthena::InventoryRecv::processPlayerInventoryAdd(), EAthena::InventoryRecv::processPlayerItemRentalExpired(), EAthena::InventoryRecv::processPlayerItemRentalTime(), TmwAthena::BeingRecv::processPlayerMove(), TmwAthena::BeingRecv::processPlayerUpdate1(), TmwAthena::BeingRecv::processPlayerUpdate2(), EAthena::SkillRecv::processSkillFailed(), EAthena::CharServerRecv::readPlayerData(), TmwAthena::CharServerRecv::readPlayerData(), Being::recalcSpritesOrder(), replaceItemLinks(), BrowserBoxTools::replaceLinkCommands(), NpcSellDialog::sellAction(), EAthena::setBasicFields(), Being::setGender(), Being::setHairColor(), Being::setHairStyle(), Being::setHairTempSprite(), Being::setSpriteCards(), Being::setSpriteColor(), Being::setSpriteColorId(), Being::setSpriteId(), Being::setSubtype(), Being::setTempSprite(), Being::setWeaponId(), CharCreateDialog::updateHair(), and CharCreateDialog::updateLook().

get() [2/2]

const ItemInfo & ItemDB::get

(

const std::string &

name

)

Definition at line 808 of file itemdb.cpp.

{
 if (!mLoaded)
 load();
 
 const NamedItemInfos::const_iterator i = mNamedItemInfos.find(
 normalize(name));
 
 if (i == mNamedItemInfos.end())
 {
 if (!name.empty())
 {
 reportAlways("ItemDB: Warning, unknown item name \"%s\"",
 name.c_str())
 }
 return *mUnknown;
 }
 
 return *(i->second);
}

References AvatarDB::load(), anonymous_namespace{itemdb.cpp}::mLoaded, anonymous_namespace{itemdb.cpp}::mNamedItemInfos, anonymous_namespace{itemdb.cpp}::mUnknown, normalize(), and reportAlways.

getEmpty()

const ItemInfo & ItemDB::getEmpty

(

)

Definition at line 834 of file itemdb.cpp.

{
 return *mUnknown;
}

References anonymous_namespace{itemdb.cpp}::mUnknown.

Referenced by EAthena::InventoryRecv::processPlayerInventoryAdd(), and TmwAthena::InventoryRecv::processPlayerInventoryAdd().

getItemInfos()

const ItemDB::ItemInfos & ItemDB::getItemInfos

(

)

Definition at line 829 of file itemdb.cpp.

{
 return mItemInfos;
}

References anonymous_namespace{itemdb.cpp}::mItemInfos.

Referenced by IconsModel::IconsModel(), and ItemsModal::ItemsModal().

getNamesStr()

std::string ItemDB::getNamesStr

(

const std::vector< int > &

parts

)

Definition at line 1176 of file itemdb.cpp.

{
 std::string str;
 FOR_EACH (STD_VECTOR<int>::const_iterator, it, parts)
 {
 const int id = *it;
 if (exists(id))
 {
 if (!str.empty())
 str.append(",");
 str.append(get(id).getName());
 }
 }
 return str;
}

References VirtFs::exists(), FOR_EACH, AttributesEnum::get(), and GroupDb::getName().

Referenced by OutfitWindow::getOutfitString().

getNumOfHairstyles()

int ItemDB::getNumOfHairstyles

(

)

Definition at line 1192 of file itemdb.cpp.

{
 return mNumberOfHairstyles;
}

References anonymous_namespace{itemdb.cpp}::mNumberOfHairstyles.

Referenced by CharCreateDialog::CharCreateDialog(), and CharCreateDialog::updateHair().

getTagId()

int ItemDB::getTagId

(

const std::string &

tagName

)

Definition at line 754 of file itemdb.cpp.

{
 return mTags[tagName];
}

References anonymous_namespace{itemdb.cpp}::mTags.

Referenced by InventoryWindow::action().

getTags()

const StringVect & ItemDB::getTags

(

)

Definition at line 749 of file itemdb.cpp.

{
 return mTagNames;
}

References anonymous_namespace{itemdb.cpp}::mTagNames.

Referenced by InventoryWindow::InventoryWindow().

load()

void ItemDB::load

(

)

Definition at line 147 of file itemdb.cpp.

{
 if (mLoaded)
 unload();
 
 logger->log1("Initializing item database...");
 
 if (!mConstructed)
 initStatic();
 
 int tagNum = 0;
 
 mTags.clear();
 mTagNames.clear();
 mTagNames.push_back("All");
 mTagNames.push_back("Usable");
 mTagNames.push_back("Unusable");
 mTagNames.push_back("Equipment");
 mTags["All"] = tagNum ++;
 mTags["Usable"] = tagNum ++;
 mTags["Unusable"] = tagNum ++;
 mTags["Equipment"] = tagNum ++;
 
 mUnknown = new ItemInfo;
 // TRANSLATORS: item name
 mUnknown->setName(_("Unknown item"));
 mUnknown->setDisplay(SpriteDisplay());
 std::string errFile = paths.getStringValue("spriteErrorFile");
 mUnknown->setSprite(errFile, Gender::MALE, 0);
 mUnknown->setSprite(errFile, Gender::FEMALE, 0);
 mUnknown->addTag(mTags["All"]);
 loadXmlFile(paths.getStringValue("itemsFile"),
 tagNum,
 SkipError_false);
 loadXmlFile(paths.getStringValue("itemsPatchFile"),
 tagNum,
 SkipError_true);
 
 StringVect list;
 VirtFs::getFilesInDir(paths.getStringValue("itemsPatchDir"),
 list,
 ".xml");
 FOR_EACH (StringVectCIter, it, list)
 loadXmlFile(*it, tagNum, SkipError_true);
 
 // Hairstyles are encoded as negative numbers. Count how far negative
 // we can go.
 int hairstyles = 1;
 while (ItemDB::exists(-hairstyles) &&
 ItemDB::get(-hairstyles).getSprite(Gender::MALE,
 BeingTypeId_zero) != paths.getStringValue("spriteErrorFile"))
 {
 hairstyles ++;
 }
 mNumberOfHairstyles = hairstyles;
 
 int races = 100;
 while (ItemDB::exists(-races) &&
 ItemDB::get(-races).getSprite(Gender::MALE, BeingTypeId_zero) !=
 paths.getStringValue("spriteErrorFile"))
 {
 races ++;
 }
}

References _, ItemInfo::addTag(), BeingTypeId_zero, exists(), Gender::FEMALE, FOR_EACH, get(), VirtFs::getFilesInDir(), EmoteDB::getSprite(), Configuration::getStringValue(), initStatic(), loadXmlFile(), Logger::log1(), logger, Gender::MALE, anonymous_namespace{itemdb.cpp}::mConstructed, anonymous_namespace{itemdb.cpp}::mLoaded, anonymous_namespace{itemdb.cpp}::mNumberOfHairstyles, anonymous_namespace{itemdb.cpp}::mTagNames, anonymous_namespace{itemdb.cpp}::mTags, anonymous_namespace{itemdb.cpp}::mUnknown, paths, ItemInfo::setDisplay(), ItemInfo::setName(), ItemInfo::setSprite(), SkipError_false, SkipError_true, and Net::unload().

Referenced by DbManager::loadDb().

loadXmlFile()

void ItemDB::loadXmlFile	(	const std::string &	fileName,
		int &	tagNum,
		const SkipError	skipError
	)

Definition at line 262 of file itemdb.cpp.

{
 if (fileName.empty())
 {
 mLoaded = true;
 return;
 }
 
 XML::Document doc(fileName,
 UseVirtFs_true,
 skipError);
 XmlNodeConstPtrConst rootNode = doc.rootNode();
 
 if ((rootNode == nullptr) || !xmlNameEqual(rootNode, "items"))
 {
 logger->log("ItemDB: Error while loading %s!", fileName.c_str());
 mLoaded = true;
 return;
 }
 
 const ItemFieldInfos &requiredFields =
 ItemFieldDb::getRequiredFields();
 const ItemFieldInfos &addFields =
 ItemFieldDb::getAddFields();
 
 for_each_xml_child_node(node, rootNode)
 {
 if (xmlNameEqual(node, "include"))
 {
 const std::string name = XML::getProperty(node, "name", "");
 if (!name.empty())
 loadXmlFile(name, tagNum, skipError);
 continue;
 }
 if (!xmlNameEqual(node, "item"))
 continue;
 
 const int id = XML::getProperty(node, "id", 0);
 ItemInfo *itemInfo = nullptr;
 
 if (id == 0)
 {
 reportAlways("ItemDB: Invalid or missing item ID in %s!",
 fileName.c_str())
 continue;
 }
 else if (mItemInfos.find(id) != mItemInfos.end())
 {
 logger->log("ItemDB: Redefinition of item ID %d", id);
 itemInfo = mItemInfos[id];
 }
 if (itemInfo == nullptr)
 itemInfo = new ItemInfo;
 
 const std::string typeStr = XML::getProperty(node, "type", "");
 int weight = XML::getProperty(node, "weight", 0);
 int view = XML::getProperty(node, "view", 0);
 const int cardColor = XML::getProperty(node, "cardColor", -1);
 const int inherit = XML::getProperty(node, "inherit", -1);
 
 std::string name = XML::langProperty(node, "name", "");
 std::string nameEn = XML::getProperty(node, "name", "");
 std::string image = XML::getProperty(node, "image", "");
 std::string floor = XML::getProperty(node, "floor", "");
 std::string description = XML::langProperty(node, "description", "");
 std::string attackAction = XML::getProperty(node, "attack-action", "");
 std::string skyAttackAction = XML::getProperty(
 node, "skyattack-action", "");
 std::string waterAttackAction = XML::getProperty(
 node, "waterattack-action", "");
 std::string rideAttackAction = XML::getProperty(
 node, "rideattack-action", "");
 std::string drawBefore = XML::getProperty(node, "drawBefore", "");
 std::string drawAfter = XML::getProperty(node, "drawAfter", "");
 const int maxFloorOffset = XML::getIntProperty(
 node, "maxFloorOffset", mapTileSize, 0, mapTileSize);
 const int maxFloorOffsetX = XML::getIntProperty(
 node, "maxFloorOffsetX", maxFloorOffset, 0, mapTileSize);
 const int maxFloorOffsetY = XML::getIntProperty(
 node, "maxFloorOffsetY", maxFloorOffset, 0, mapTileSize);
 std::string useButton = XML::langProperty(node, "useButton", "");
 std::string useButton2 = XML::langProperty(node, "useButton2", "");
 std::string colors = XML::getProperty(node, "colors", "");
 std::string iconColors = XML::getProperty(node, "iconColors", "");
 if (iconColors.empty())
 iconColors = colors;
 
 // check for empty hair palete
 if (id <= -1 && id > -100)
 {
 if (colors.empty())
 colors = "hair";
 if (iconColors.empty())
 iconColors = "hair";
 }
 
 std::string tags[3];
 tags[0] = XML::getProperty(node, "tag",
 XML::getProperty(node, "tag1", ""));
 tags[1] = XML::getProperty(node, "tag2", "");
 tags[2] = XML::getProperty(node, "tag3", "");
 
 const int drawPriority = XML::getProperty(node, "drawPriority", 0);
 
 int attackRange = XML::getProperty(node, "attack-range", 0);
 std::string missileParticle = XML::getProperty(
 node, "missile-particle", "");
 float missileZ = XML::getFloatProperty(
 node, "missile-z", 32.0F);
 int missileLifeTime = XML::getProperty(
 node, "missile-lifetime", 500);
 float missileSpeed = XML::getFloatProperty(
 node, "missile-speed", 7.0F);
 float missileDieDistance = XML::getFloatProperty(
 node, "missile-diedistance", 8.0F);
 int hitEffectId = XML::getProperty(node, "hit-effect-id",
 paths.getIntValue("hitEffectId"));
 int criticalEffectId = XML::getProperty(
 node, "critical-hit-effect-id",
 paths.getIntValue("criticalHitEffectId"));
 int missEffectId = XML::getProperty(node, "miss-effect-id",
 paths.getIntValue("missEffectId"));
 
 SpriteDisplay display;
 display.image = image;
 if (!floor.empty())
 display.floor = STD_MOVE(floor);
 else
 display.floor = image;
 
 const ItemInfo *inheritItemInfo = nullptr;
 
 if (inherit >= 0)
 {
 if (mItemInfos.find(inherit) != mItemInfos.end())
 {
 inheritItemInfo = mItemInfos[inherit];
 }
 else
 {
 reportAlways("Inherit item %d from not existing item %d",
 id,
 inherit)
 }
 }
 
 itemInfo->setId(id);
 if (name.empty() && (inheritItemInfo != nullptr))
 name = inheritItemInfo->getName();
 // TRANSLATORS: item info name
 itemInfo->setName(name.empty() ? _("unnamed") : name);
 if (nameEn.empty())
 {
 // TRANSLATORS: item info name
 itemInfo->setNameEn(name.empty() ? _("unnamed") : name);
 }
 else
 {
 itemInfo->setNameEn(nameEn);
 }
 
 if (description.empty() && (inheritItemInfo != nullptr))
 description = inheritItemInfo->getDescription();
 itemInfo->setDescription(description);
 if (typeStr.empty())
 {
 if (inheritItemInfo != nullptr)
 itemInfo->setType(inheritItemInfo->getType());
 else
 itemInfo->setType(itemTypeFromString("other"));
 }
 else
 {
 itemInfo->setType(itemTypeFromString(typeStr));
 }
 itemInfo->setType(itemTypeFromString(typeStr));
 if (useButton.empty() && (inheritItemInfo != nullptr))
 useButton = inheritItemInfo->getUseButton();
 if (useButton.empty())
 useButton = useButtonFromItemType(itemInfo->getType());
 itemInfo->setUseButton(useButton);
 if (useButton2.empty() && (inheritItemInfo != nullptr))
 useButton2 = inheritItemInfo->getUseButton();
 if (useButton2.empty())
 useButton2 = useButton2FromItemType(itemInfo->getType());
 itemInfo->setUseButton2(useButton2);
 itemInfo->addTag(mTags["All"]);
 itemInfo->setProtected(XML::getBoolProperty(
 node, "sellProtected", false));
 if (cardColor != -1)
 itemInfo->setCardColor(fromInt(cardColor, ItemColor));
 else if (inheritItemInfo != nullptr)
 itemInfo->setCardColor(inheritItemInfo->getCardColor());
 
 switch (itemInfo->getType())
 {
 case ItemDbType::USABLE:
 itemInfo->addTag(mTags["Usable"]);
 break;
 case ItemDbType::CARD:
 case ItemDbType::UNUSABLE:
 itemInfo->addTag(mTags["Unusable"]);
 break;
 default:
 case ItemDbType::EQUIPMENT_ONE_HAND_WEAPON:
 case ItemDbType::EQUIPMENT_TWO_HANDS_WEAPON:
 case ItemDbType::EQUIPMENT_TORSO:
 case ItemDbType::EQUIPMENT_ARMS:
 case ItemDbType::EQUIPMENT_HEAD:
 case ItemDbType::EQUIPMENT_LEGS:
 case ItemDbType::EQUIPMENT_SHIELD:
 case ItemDbType::EQUIPMENT_RING:
 case ItemDbType::EQUIPMENT_NECKLACE:
 case ItemDbType::EQUIPMENT_FEET:
 case ItemDbType::EQUIPMENT_AMMO:
 case ItemDbType::EQUIPMENT_CHARM:
 case ItemDbType::SPRITE_RACE:
 case ItemDbType::SPRITE_HAIR:
 itemInfo->addTag(mTags["Equipment"]);
 break;
 }
 for (int f = 0; f < 3; f++)
 {
 if (!tags[f].empty())
 {
 if (mTags.find(tags[f]) == mTags.end())
 {
 mTagNames.push_back(tags[f]);
 mTags[tags[f]] = tagNum ++;
 }
 itemInfo->addTag(mTags[tags[f]]);
 }
 }
 
 std::string effect;
 readItemStatsString(effect, node, requiredFields);
 readItemStatsString(effect, node, addFields);
 std::string temp = XML::langProperty(node, "effect", "");
 if (!effect.empty() && !temp.empty())
 effect.append(" / ");
 effect.append(temp);
 
 if (inheritItemInfo != nullptr)
 {
 if (view == 0)
 view = inheritItemInfo->getView();
 if (weight == 0)
 weight = inheritItemInfo->getWeight();
 if (attackAction.empty())
 attackAction = inheritItemInfo->getAttackAction();
 if (skyAttackAction.empty())
 skyAttackAction = inheritItemInfo->getSkyAttackAction();
 if (waterAttackAction.empty())
 waterAttackAction = inheritItemInfo->getWaterAttackAction();
 if (rideAttackAction.empty())
 rideAttackAction = inheritItemInfo->getRideAttackAction();
 if (attackRange == 0)
 attackRange = inheritItemInfo->getAttackRange();
 if (hitEffectId == 0)
 hitEffectId = inheritItemInfo->getHitEffectId();
 if (criticalEffectId == 0)
 criticalEffectId = inheritItemInfo->getCriticalHitEffectId();
 if (missEffectId == 0)
 missEffectId = inheritItemInfo->getMissEffectId();
 if (colors.empty())
 colors = inheritItemInfo->getColorsListName();
 if (iconColors.empty())
 iconColors = inheritItemInfo->getIconColorsListName();
 if (effect.empty())
 effect = inheritItemInfo->getEffect();
 
 const MissileInfo &inheritMissile =
 inheritItemInfo->getMissileConst();
 if (missileParticle.empty())
 missileParticle = inheritMissile.particle;
 if (missileZ == 32.0F)
 missileZ = inheritMissile.z;
 if (missileLifeTime == 500)
 missileLifeTime = inheritMissile.lifeTime;
 if (missileSpeed == 7.0F)
 missileSpeed = inheritMissile.speed;
 if (missileDieDistance == 8.0F)
 missileDieDistance = inheritMissile.dieDistance;
 }
 
 itemInfo->setView(view);
 itemInfo->setWeight(weight);
 itemInfo->setAttackAction(attackAction);
 itemInfo->setSkyAttackAction(skyAttackAction);
 itemInfo->setWaterAttackAction(waterAttackAction);
 itemInfo->setRideAttackAction(rideAttackAction);
 itemInfo->setAttackRange(attackRange);
 itemInfo->setHitEffectId(hitEffectId);
 itemInfo->setCriticalHitEffectId(criticalEffectId);
 itemInfo->setMissEffectId(missEffectId);
 itemInfo->setDrawBefore(-1, parseSpriteName(drawBefore));
 itemInfo->setDrawAfter(-1, parseSpriteName(drawAfter));
 itemInfo->setDrawPriority(-1, drawPriority);
 itemInfo->setColorsList(colors);
 itemInfo->setIconColorsList(iconColors);
 itemInfo->setMaxFloorOffsetX(maxFloorOffsetX);
 itemInfo->setMaxFloorOffsetY(maxFloorOffsetY);
 itemInfo->setPickupCursor(XML::getProperty(
 node, "pickupCursor", "pickup"));
 
 MissileInfo &missile = itemInfo->getMissile();
 missile.particle = STD_MOVE(missileParticle);
 missile.z = missileZ;
 missile.lifeTime = missileLifeTime;
 missile.speed = missileSpeed;
 missile.dieDistance = missileDieDistance;
 
 for_each_xml_child_node(itemChild, node)
 {
 if (xmlNameEqual(itemChild, "sprite"))
 {
 loadSpriteRef(itemInfo, itemChild);
 }
 else if (xmlNameEqual(itemChild, "particlefx"))
 {
 if (XmlHaveChildContent(itemChild))
 display.particles.push_back(XmlChildContent(itemChild));
 }
 else if (xmlNameEqual(itemChild, "sound"))
 {
 loadSoundRef(itemInfo, itemChild);
 }
 else if (xmlNameEqual(itemChild, "floor"))
 {
 loadFloorSprite(display, itemChild);
 }
 else if (xmlNameEqual(itemChild, "replace"))
 {
 loadReplaceSprite(itemInfo, itemChild);
 }
 else if (xmlNameEqual(itemChild, "drawAfter"))
 {
 loadOrderSprite(itemInfo, itemChild, true);
 }
 else if (xmlNameEqual(itemChild, "drawBefore"))
 {
 loadOrderSprite(itemInfo, itemChild, false);
 }
 else if (xmlNameEqual(itemChild, "inventory"))
 {
 loadMenu(itemChild, itemInfo->getInventoryMenu());
 }
 else if (xmlNameEqual(itemChild, "storage"))
 {
 loadMenu(itemChild, itemInfo->getStorageMenu());
 }
 else if (xmlNameEqual(itemChild, "cart"))
 {
 loadMenu(itemChild, itemInfo->getCartMenu());
 }
 else if (xmlNameEqual(itemChild, "addStats"))
 {
 readItemStatsString(effect, itemChild, addFields);
 }
 else if (xmlNameEqual(itemChild, "requireStats"))
 {
 readItemStatsString(effect, itemChild, requiredFields);
 }
 }
 itemInfo->setEffect(effect);
 
/*
 logger->log("start dump item: %d", id);
 if (itemInfo->isRemoveSprites())
 {
 for (int f = 0; f < 10; f ++)
 {
 logger->log("dir: %d", f);
 SpriteToItemMap *const spriteToItems
 = itemInfo->getSpriteToItemReplaceMap(f);
 if (!spriteToItems)
 {
 logger->log("null");
 continue;
 }
 for (SpriteToItemMapCIter itr = spriteToItems->begin(),
 itr_end = spriteToItems->end(); itr != itr_end; ++ itr)
 {
 const int remSprite = itr->first;
 const IntMap &itemReplacer = itr->second;
 logger->log("sprite: %d", remSprite);
 
 for (IntMapCIter repIt = itemReplacer.begin(),
 repIt_end = itemReplacer.end();
 repIt != repIt_end; ++ repIt)
 {
 logger->log("from %d to %d", repIt->first,
 repIt->second);
 }
 }
 }
 }
 
 logger->log("--------------------------------");
 logger->log("end dump item");
*/
 
 itemInfo->setDisplay(display);
 
 mItemInfos[id] = itemInfo;
 if (!name.empty())
 {
 temp = normalize(name);
 mNamedItemInfos[temp] = itemInfo;
 }
 if (!nameEn.empty())
 {
 temp = normalize(nameEn);
 mNamedItemInfos[temp] = itemInfo;
 }
 
 if (!attackAction.empty())
 {
 if (attackRange == 0)
 {
 reportAlways("ItemDB: Missing attack range from weapon %i!",
 id)
 }
 }
 
 STD_VECTOR<ItemMenuItem> &inventoryMenu = itemInfo->getInventoryMenu();
 
 if (inventoryMenu.empty())
 {
 std::string name1 = itemInfo->getUseButton();
 std::string name2 = itemInfo->getUseButton2();
 const bool isEquipment = getIsEquipment(itemInfo->getType());
 
 if (isEquipment)
 {
 if (name1.empty())
 {
 // TRANSLATORS: popup menu item
 name1 = _("Equip");
 }
 if (name2.empty())
 {
 // TRANSLATORS: popup menu item
 name2 = _("Unequip");
 }
 }
 else
 {
 if (name1.empty())
 {
 // TRANSLATORS: popup menu item
 name1 = _("Use");
 }
 if (name2.empty())
 {
 // TRANSLATORS: popup menu item
 name2 = _("Use");
 }
 }
 inventoryMenu.push_back(ItemMenuItem(
 name1,
 name2,
 "useinv 'INVINDEX'",
 "useinv 'INVINDEX'"));
 }
 
#define CHECK_PARAM(param) \
 if (param.empty()) \
 { \
 logger->log("ItemDB: Missing " #param " attribute for item %i!", \
 id); \
 }
 
 if (id >= 0 && typeStr != "other")
 {
 CHECK_PARAM(name)
 CHECK_PARAM(description)
 CHECK_PARAM(image)
 }
#undef CHECK_PARAM
 }
 
 mLoaded = true;
}

References _, ItemDbType::CARD, CHECK_PARAM, MissileInfo::dieDistance, empty, ItemDbType::EQUIPMENT_AMMO, ItemDbType::EQUIPMENT_ARMS, ItemDbType::EQUIPMENT_CHARM, ItemDbType::EQUIPMENT_FEET, ItemDbType::EQUIPMENT_HEAD, ItemDbType::EQUIPMENT_LEGS, ItemDbType::EQUIPMENT_NECKLACE, ItemDbType::EQUIPMENT_ONE_HAND_WEAPON, ItemDbType::EQUIPMENT_RING, ItemDbType::EQUIPMENT_SHIELD, ItemDbType::EQUIPMENT_TORSO, ItemDbType::EQUIPMENT_TWO_HANDS_WEAPON, fileName, SpriteDisplay::floor, for_each_xml_child_node, fromInt, ItemFieldDb::getAddFields(), ItemInfo::getAttackAction(), ItemInfo::getAttackRange(), XML::getBoolProperty(), ItemInfo::getCardColor(), ItemInfo::getColorsListName(), ItemInfo::getCriticalHitEffectId(), ItemInfo::getDescription(), ItemInfo::getEffect(), XML::getFloatProperty(), ItemInfo::getHitEffectId(), ItemInfo::getIconColorsListName(), XML::getIntProperty(), Configuration::getIntValue(), getIsEquipment(), ItemInfo::getMissEffectId(), ItemInfo::getMissileConst(), ItemInfo::getName(), XML::getProperty(), ItemFieldDb::getRequiredFields(), ItemInfo::getRideAttackAction(), ItemInfo::getSkyAttackAction(), ItemInfo::getType(), ItemInfo::getUseButton(), ItemInfo::getView(), ItemInfo::getWaterAttackAction(), ItemInfo::getWeight(), SpriteDisplay::image, Actions::itemInfo(), itemTypeFromString(), XML::langProperty(), MissileInfo::lifeTime, loadFloorSprite(), loadMenu(), loadOrderSprite(), loadReplaceSprite(), loadSoundRef(), loadSpriteRef(), loadXmlFile(), Logger::log(), logger, mapTileSize, anonymous_namespace{itemdb.cpp}::mItemInfos, anonymous_namespace{itemdb.cpp}::mLoaded, anonymous_namespace{itemdb.cpp}::mNamedItemInfos, anonymous_namespace{itemdb.cpp}::mTagNames, anonymous_namespace{itemdb.cpp}::mTags, normalize(), parseSpriteName(), MissileInfo::particle, SpriteDisplay::particles, paths, readItemStatsString(), reportAlways, XML::Document::rootNode(), MissileInfo::speed, ItemDbType::SPRITE_HAIR, ItemDbType::SPRITE_RACE, STD_MOVE, ItemDbType::UNUSABLE, ItemDbType::USABLE, useButton2FromItemType(), useButtonFromItemType(), UseVirtFs_true, and MissileInfo::z.

unload()

void ItemDB::unload

(

)

Definition at line 759 of file itemdb.cpp.

{
 logger->log1("Unloading item database...");
 
 delete2(mUnknown)
 
 delete_all(mItemInfos);
 mItemInfos.clear();
 mNamedItemInfos.clear();
 mTags.clear();
 mTagNames.clear();
 mLoaded = false;
}

References delete2, delete_all(), Logger::log1(), logger, anonymous_namespace{itemdb.cpp}::mItemInfos, anonymous_namespace{itemdb.cpp}::mLoaded, anonymous_namespace{itemdb.cpp}::mNamedItemInfos, anonymous_namespace{itemdb.cpp}::mTagNames, anonymous_namespace{itemdb.cpp}::mTags, and anonymous_namespace{itemdb.cpp}::mUnknown.

Referenced by DbManager::unloadDb().