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().