#include "SkillExtraItems.h"
#include "DatabaseEnv.h"
#include "Log.h"
#include "ObjectMgr.h"
#include "Player.h"
#include "SpellMgr.h"
#include <map>

Classes
struct	SkillPerfectItemEntry

struct	SkillExtraItemEntry

Typedefs
typedef std::map< uint32, SkillPerfectItemEntry >	SkillPerfectItemMap

typedef std::map< uint32, SkillExtraItemEntry >	SkillExtraItemMap

Functions
void	LoadSkillPerfectItemTable ()

void	LoadSkillExtraItemTable ()

bool	CanCreatePerfectItem (Player *player, uint32 spellId, float &perfectCreateChance, uint32 &perfectItemType)

bool	canCreateExtraItems (Player *player, uint32 spellId, float &additionalChance, int32 &newMaxOrEntry)

Variables
SkillPerfectItemMap	SkillPerfectItemStore

SkillExtraItemMap	SkillExtraItemStore

Typedef Documentation

◆ SkillExtraItemMap

typedef std::map<uint32, SkillExtraItemEntry> SkillExtraItemMap

◆ SkillPerfectItemMap

typedef std::map<uint32, SkillPerfectItemEntry> SkillPerfectItemMap

Function Documentation

◆ canCreateExtraItems()

bool canCreateExtraItems	(	Player *	player,
		uint32	spellId,
		float &	additionalChance,
		int32 &	newMaxOrEntry
	)

{
    // get the info for the specified spell
    SkillExtraItemMap::const_iterator ret = SkillExtraItemStore.find(spellId);
    if (ret == SkillExtraItemStore.end())
        return false;
 
    SkillExtraItemEntry const* specEntry = &ret->second;
 
    // if no entry, then no extra items can be created
    if (!specEntry)
        return false;
 
    // the player doesn't have the required specialization, return false
    if (!player->HasSpell(specEntry->requiredSpecialization))
        return false;
 
    // set the arguments to the appropriate values
    additionalChance = specEntry->additionalCreateChance;
    newMaxOrEntry = specEntry->newMaxOrEntry;
 
    // enable extra item creation
    return true;
}

References SkillExtraItemEntry::additionalCreateChance, Player::HasSpell(), SkillExtraItemEntry::newMaxOrEntry, SkillExtraItemEntry::requiredSpecialization, and SkillExtraItemStore.

Referenced by Spell::DoCreateItem().

◆ CanCreatePerfectItem()

bool CanCreatePerfectItem	(	Player *	player,
		uint32	spellId,
		float &	perfectCreateChance,
		uint32 &	perfectItemType
	)

{
    SkillPerfectItemMap::const_iterator ret = SkillPerfectItemStore.find(spellId);
    // no entry in DB means no perfection proc possible
    if (ret == SkillPerfectItemStore.end())
        return false;
 
    SkillPerfectItemEntry const* thisEntry = &ret->second;
    // lack of entry means no perfection proc possible
    if (!thisEntry)
        return false;
 
    // if you don't have the spell needed, then no procs for you
    if (!player->HasSpell(thisEntry->requiredSpecialization))
        return false;
 
    // set values as appropriate
    perfectCreateChance = thisEntry->perfectCreateChance;
    perfectItemType = thisEntry->perfectItemType;
 
    // and tell the caller to start rolling the dice
    return true;
}

References Player::HasSpell(), SkillPerfectItemEntry::perfectCreateChance, SkillPerfectItemEntry::perfectItemType, SkillPerfectItemEntry::requiredSpecialization, and SkillPerfectItemStore.

Referenced by Spell::DoCreateItem().

◆ LoadSkillExtraItemTable()

void LoadSkillExtraItemTable ( )

{
    uint32 oldMSTime = getMSTime();
 
    SkillExtraItemStore.clear();                            // need for reload
 
    //                                                  0               1                       2                    3
    QueryResult result = WorldDatabase.Query("SELECT spellId, requiredSpecialization, additionalCreateChance, additionalMaxNum FROM skill_extra_item_template");
 
    if (!result)
    {
        LOG_WARN("server.loading", ">> Loaded 0 spell specialization definitions. DB table `skill_extra_item_template` is empty.");
        LOG_INFO("server.loading", " ");
        return;
    }
 
    uint32 count = 0;
 
    do
    {
        Field* fields = result->Fetch();
 
        uint32 spellId = fields[0].Get<uint32>();
 
        if (!sSpellMgr->GetSpellInfo(spellId))
        {
            LOG_ERROR("sql.sql", "Skill specialization {} has non-existent spell id in `skill_extra_item_template`!", spellId);
            continue;
        }
 
        uint32 requiredSpecialization = fields[1].Get<uint32>();
        if (!sSpellMgr->GetSpellInfo(requiredSpecialization))
        {
            LOG_ERROR("sql.sql", "Skill specialization {} have not existed required specialization spell id {} in `skill_extra_item_template`!", spellId, requiredSpecialization);
            continue;
        }
 
        float additionalCreateChance = fields[2].Get<float>();
        if (additionalCreateChance <= 0.0f)
        {
            LOG_ERROR("sql.sql", "Skill specialization {} has too low additional create chance in `skill_extra_item_template`!", spellId);
            continue;
        }
 
        int32 newMaxOrEntry = fields[3].Get<int32>();
        if (!newMaxOrEntry)
        {
            LOG_ERROR("sql.sql", "Skill specialization {} has 0 max number of extra items in `skill_extra_item_template`!", spellId);
            continue;
        }
 
        SkillExtraItemEntry& skillExtraItemEntry = SkillExtraItemStore[spellId];
 
        skillExtraItemEntry.requiredSpecialization = requiredSpecialization;
        skillExtraItemEntry.additionalCreateChance = additionalCreateChance;
        skillExtraItemEntry.newMaxOrEntry          = newMaxOrEntry;
 
        ++count;
    } while (result->NextRow());
 
    LOG_INFO("server.loading", ">> Loaded {} spell specialization definitions in {} ms", count, GetMSTimeDiffToNow(oldMSTime));
    LOG_INFO("server.loading", " ");
}

References SkillExtraItemEntry::additionalCreateChance, Field::Get(), getMSTime(), GetMSTimeDiffToNow(), LOG_ERROR, LOG_INFO, LOG_WARN, SkillExtraItemEntry::newMaxOrEntry, SkillExtraItemEntry::requiredSpecialization, SkillExtraItemStore, sSpellMgr, and WorldDatabase.

Referenced by reload_commandscript::HandleReloadSkillExtraItemTemplateCommand(), and World::SetInitialWorldSettings().

◆ LoadSkillPerfectItemTable()

void LoadSkillPerfectItemTable ( )

{
    uint32 oldMSTime = getMSTime();
 
    SkillPerfectItemStore.clear(); // reload capability
 
    //                                                  0               1                      2                  3
    QueryResult result = WorldDatabase.Query("SELECT spellId, requiredSpecialization, perfectCreateChance, perfectItemType FROM skill_perfect_item_template");
 
    if (!result)
    {
        LOG_WARN("server.loading", ">> Loaded 0 spell perfection definitions. DB table `skill_perfect_item_template` is empty.");
        LOG_INFO("server.loading", " ");
        return;
    }
 
    uint32 count = 0;
 
    do /* fetch data and run sanity checks */
    {
        Field* fields = result->Fetch();
 
        uint32 spellId = fields[0].Get<uint32>();
 
        if (!sSpellMgr->GetSpellInfo(spellId))
        {
            LOG_ERROR("sql.sql", "Skill perfection data for spell {} has non-existent spell id in `skill_perfect_item_template`!", spellId);
            continue;
        }
 
        uint32 requiredSpecialization = fields[1].Get<uint32>();
        if (!sSpellMgr->GetSpellInfo(requiredSpecialization))
        {
            LOG_ERROR("sql.sql", "Skill perfection data for spell {} has non-existent required specialization spell id {} in `skill_perfect_item_template`!", spellId, requiredSpecialization);
            continue;
        }
 
        float perfectCreateChance = fields[2].Get<float>();
        if (perfectCreateChance <= 0.0f)
        {
            LOG_ERROR("sql.sql", "Skill perfection data for spell {} has impossibly low proc chance in `skill_perfect_item_template`!", spellId);
            continue;
        }
 
        uint32 perfectItemType = fields[3].Get<uint32>();
        if (!sObjectMgr->GetItemTemplate(perfectItemType))
        {
            LOG_ERROR("sql.sql", "Skill perfection data for spell {} references non-existent perfect item id {} in `skill_perfect_item_template`!", spellId, perfectItemType);
            continue;
        }
 
        SkillPerfectItemEntry& skillPerfectItemEntry = SkillPerfectItemStore[spellId];
 
        skillPerfectItemEntry.requiredSpecialization = requiredSpecialization;
        skillPerfectItemEntry.perfectCreateChance = perfectCreateChance;
        skillPerfectItemEntry.perfectItemType = perfectItemType;
 
        ++count;
    } while (result->NextRow());
 
    LOG_INFO("server.loading", ">> Loaded {} spell perfection definitions in {} ms", count, GetMSTimeDiffToNow(oldMSTime));
    LOG_INFO("server.loading", " ");
}