SpellManager Class Reference

#include <spellmanager.h>

Public Member Functions
	SpellManager ()
	~SpellManager ()
TextCommand *	getSpell (const int spellId) const
const TextCommand *	getSpellByItem (const int itemId) const
bool	addSpell (TextCommand *const spell)
TextCommand *	createNewSpell () const
const std::vector< TextCommand * > &	getAll () const A_CONST
void	useItem (const int itemId) const
void	invoke (const int spellId) const
void	load ()
void	save () const
std::string	autoComplete (const std::string &partName) const
void	swap (const int id1, const int id2)

Static Public Member Functions
static void	invokeCommand (const std::string &command, const Being *const target)

Private Member Functions
void	fillSpells ()

Static Private Member Functions
static void	invokeSpell (const TextCommand *const spell, const Being *const target)
static void	invokeSpell (const TextCommand *const spell)
static std::string	parseCommand (std::string command, const Being *const target)

Private Attributes
std::map< unsigned int, TextCommand * >	mSpells
std::vector< TextCommand * >	mSpellsVector

Detailed Description

Definition at line 36 of file spellmanager.h.

Constructor & Destructor Documentation

SpellManager()

SpellManager::SpellManager

(

)

Definition at line 50 of file spellmanager.cpp.

                           :
    mSpells(),
    mSpellsVector()
{
    load();
}

References load().

~SpellManager()

SpellManager::~SpellManager

(

)

Definition at line 57 of file spellmanager.cpp.

{
    delete_all(mSpells);
    mSpells.clear();
    mSpellsVector.clear();
}

References delete_all(), mSpells, and mSpellsVector.

Member Function Documentation

addSpell()

bool SpellManager::addSpell

(

TextCommand *const

spell

)

Definition at line 98 of file spellmanager.cpp.

{
    if (spell == nullptr)
        return false;
 
    const int id = spell->getId();
    if (id < 0 || id >= CAST_S32(SPELL_SHORTCUT_ITEMS
        * SPELL_SHORTCUT_TABS))
    {
        delete spell;
        return false;
    }
    const std::map<unsigned int, TextCommand*>::const_iterator
        i = mSpells.find(spell->getId());
    if (i == mSpells.end())
    {
        mSpells[spell->getId()] = spell;
        mSpellsVector.push_back(spell);
        return true;
    }
    return false;
}

References CAST_S32, TextCommand::getId(), mSpells, mSpellsVector, SPELL_SHORTCUT_ITEMS, and SPELL_SHORTCUT_TABS.

Referenced by fillSpells(), and load().

autoComplete()

std::string SpellManager::autoComplete

(

const std::string &

partName

)

const

Definition at line 373 of file spellmanager.cpp.

{
    STD_VECTOR<TextCommand*>::const_iterator i = mSpellsVector.begin();
    const STD_VECTOR<TextCommand*>::const_iterator
        i_end = mSpellsVector.end();
    std::string newName;
    const TextCommand *newCommand = nullptr;
 
    while (i != i_end)
    {
        const TextCommand *const cmd = *i;
        const std::string line = cmd->getCommand();
 
        if (!line.empty())
        {
            const size_t pos = line.find(partName, 0);
            if (pos == 0)
            {
                if (!newName.empty())
                {
                    newName = findSameSubstring(line, newName);
                    newCommand = nullptr;
                }
                else
                {
                    newName = line;
                    newCommand = cmd;
                }
            }
        }
        ++i;
    }
    if (!newName.empty() &&
        (newCommand != nullptr) &&
        newCommand->getTargetType() == CommandTarget::NeedTarget)
    {
        return newName.append(" ");
    }
    return newName;
}

References findSameSubstring(), TextCommand::getCommand(), TextCommand::getTargetType(), mSpellsVector, and CommandTarget::NeedTarget.

Referenced by ChatWindow::autoComplete().

createNewSpell()

TextCommand * SpellManager::createNewSpell

(

)

const

Definition at line 257 of file spellmanager.cpp.

{
    return new TextCommand(CAST_U32(mSpellsVector.size()));
}

References CAST_U32, and mSpellsVector.

fillSpells()

void SpellManager::fillSpells ( )

private

Definition at line 80 of file spellmanager.cpp.

{
    CommandsDB::load();
 
    CommandsMap &commands = CommandsDB::getAll();
    FOR_EACH (CommandsMapIter, it, commands)
        addSpell((*it).second);
 
    for (unsigned f = 0; f < SPELL_SHORTCUT_ITEMS * SPELL_SHORTCUT_TABS; f++)
    {
        const std::map<unsigned int, TextCommand*>::const_iterator
            it = mSpells.find(f);
        if (it == mSpells.end())
            addSpell(new TextCommand(f));
    }
    CommandsDB::unload();
}

References addSpell(), FOR_EACH, CommandsDB::getAll(), CommandsDB::load(), mSpells, SPELL_SHORTCUT_ITEMS, SPELL_SHORTCUT_TABS, and CommandsDB::unload().

Referenced by load().

getAll()

const std::vector< TextCommand * > & SpellManager::getAll

(

)

const

Definition at line 121 of file spellmanager.cpp.

{
    return mSpellsVector;
}

References mSpellsVector.

Referenced by SpellShortcut::load().

getSpell()

TextCommand * SpellManager::getSpell

(

const int

spellId

)

const

Definition at line 64 of file spellmanager.cpp.

{
    if (spellId < 0 || CAST_SIZE(spellId) >= mSpells.size())
        return nullptr;
 
    const std::map<unsigned int, TextCommand*>::const_iterator
        it = mSpells.find(spellId);
 
    return it != mSpells.end() ? (*it).second : nullptr;
}

References CAST_SIZE, and mSpells.

Referenced by SpellShortcutContainer::draw(), getSpellByItem(), invoke(), SpellShortcutContainer::mouseDragged(), SpellShortcutContainer::mouseMoved(), SpellShortcutContainer::mouseReleased(), and SpellShortcutContainer::safeDraw().

getSpellByItem()

const TextCommand * SpellManager::getSpellByItem

(

const int

itemId

)

const

Definition at line 75 of file spellmanager.cpp.

{
    return getSpell(itemId - SPELL_MIN_ID);
}

References getSpell(), and SPELL_MIN_ID.

Referenced by ItemShortcutContainer::draw(), ItemShortcutContainer::mouseDragged(), ItemShortcutContainer::mouseMoved(), and ItemShortcutContainer::safeDraw().

invoke()

void SpellManager::invoke

(

const int

spellId

)

const

Definition at line 131 of file spellmanager.cpp.

{
    if (localPlayer == nullptr)
        return;
 
    const TextCommand *const spell = getSpell(spellId);
    if (spell == nullptr)
        return;
 
    if ((playerHandler == nullptr) || spell->getCommand().empty())
        return;
 
#ifdef TMWA_SUPPORT
    if (spell->getCommandType() == TextCommandType::Text ||
        (playerHandler->canUseMagic() &&
        PlayerInfo::getSkillLevel(CAST_S32(MagicSchool::SkillMagic))
        >= CAST_S32(spell->getBaseLvl()) &&
        PlayerInfo::getSkillLevel(CAST_S32(
        spell->getSchool())) >= CAST_S32(spell->getSchoolLvl())
        && PlayerInfo::getAttribute(Attributes::PLAYER_MP)
        >= CAST_S32(spell->getMana()))
        )
#endif  // TMWA_SUPPORT
    {
        const Being *const target = localPlayer->getTarget();
        if (spell->getTargetType() == CommandTarget::NoTarget)
        {
            invokeSpell(spell);
        }
#ifdef TMWA_SUPPORT
        if ((target != nullptr &&
            (target->getType() != ActorType::Monster ||
            spell->getCommandType() == TextCommandType::Text)) &&
            (spell->getTargetType() == CommandTarget::AllowTarget ||
            spell->getTargetType() == CommandTarget::NeedTarget))
#else  // TMWA_SUPPORT
 
        if (target != nullptr &&
            (spell->getTargetType() == CommandTarget::AllowTarget ||
            spell->getTargetType() == CommandTarget::NeedTarget))
#endif  // TMWA_SUPPORT
        {
            invokeSpell(spell, target);
        }
        else if (spell->getTargetType() == CommandTarget::AllowTarget)
        {
            invokeSpell(spell);
        }
    }
}

References CommandTarget::AllowTarget, Net::PlayerHandler::canUseMagic(), CAST_S32, PlayerInfo::getAttribute(), TextCommand::getBaseLvl(), TextCommand::getCommand(), TextCommand::getCommandType(), TextCommand::getMana(), TextCommand::getSchool(), TextCommand::getSchoolLvl(), PlayerInfo::getSkillLevel(), getSpell(), LocalPlayer::getTarget(), TextCommand::getTargetType(), Being::getType(), invokeSpell(), localPlayer, ActorType::Monster, CommandTarget::NeedTarget, CommandTarget::NoTarget, Attributes::PLAYER_MP, playerHandler, MagicSchool::SkillMagic, and TextCommandType::Text.

Referenced by SpellShortcutContainer::mousePressed(), and useItem().

invokeCommand()

void SpellManager::invokeCommand ( const std::string &  command, const Being *const  target  )

static

Definition at line 201 of file spellmanager.cpp.

{
    if (chatWindow == nullptr)
        return;
    chatWindow->localChatInput(parseCommand(command, target));
}

References chatWindow, ChatWindow::localChatInput(), and parseCommand().

Referenced by SkillDialog::useSkill().

invokeSpell() [1/2]

void SpellManager::invokeSpell ( const TextCommand *const  spell )

staticprivate

Definition at line 182 of file spellmanager.cpp.

{
    if ((chatWindow == nullptr) || (spell == nullptr))
        return;
    chatWindow->localChatInput(parseCommand(spell->getCommand(), nullptr));
}

References chatWindow, TextCommand::getCommand(), ChatWindow::localChatInput(), and parseCommand().

invokeSpell() [2/2]

void SpellManager::invokeSpell ( const TextCommand *const  spell, const Being *const  target  )

staticprivate

Definition at line 189 of file spellmanager.cpp.

{
    if (chatWindow == nullptr ||
        spell == nullptr ||
        target == nullptr)
    {
        return;
    }
    chatWindow->localChatInput(parseCommand(spell->getCommand(), target));
}

References chatWindow, TextCommand::getCommand(), ChatWindow::localChatInput(), and parseCommand().

Referenced by invoke().

load()

void SpellManager::load

(

)

Definition at line 262 of file spellmanager.cpp.

{
    const Configuration *cfg = &serverConfig;
 
    delete_all(mSpells);
    mSpells.clear();
    mSpellsVector.clear();
 
    if (cfg->getValue("commandShortcutFlags0", "").empty())
    {
        fillSpells();
        save();
        return;
    }
 
    for (unsigned i = 0; i < SPELL_SHORTCUT_ITEMS * SPELL_SHORTCUT_TABS; i++)
    {
        unsigned int targetType;
        unsigned int basicLvl;
        unsigned int school;
        unsigned int schoolLvl;
        unsigned int mana;
        unsigned int commandType;
 
        std::string flags =
            cfg->getValue("commandShortcutFlags" + toString(i), "");
        std::stringstream ss(flags);
        ss >> commandType;
        ss >> targetType;
        ss >> basicLvl;
        ss >> school;
        ss >> schoolLvl;
        ss >> mana;
 
        std::string cmd = cfg->getValue("commandShortcutCmd"
                                        + toString(i), "");
        std::string comment = cfg->getValue("commandShortcutComment"
                                        + toString(i), "");
        std::string symbol = cfg->getValue("commandShortcutSymbol"
                                           + toString(i), "");
        std::string icon = cfg->getValue("commandShortcutIcon"
                                         + toString(i), "");
 
#ifdef TMWA_SUPPORT
        if (static_cast<TextCommandTypeT>(commandType) ==
            TextCommandType::Magic)
        {
            addSpell(new TextCommand(i, symbol, cmd, comment,
                static_cast<CommandTargetT>(targetType), icon, basicLvl,
                static_cast<MagicSchoolT>(school), schoolLvl, mana));
        }
        else
#endif  // TMWA_SUPPORT
        {
            addSpell(new TextCommand(i, symbol, cmd, comment,
                static_cast<CommandTargetT>(targetType), icon));
        }
    }
}

References addSpell(), delete_all(), fillSpells(), ConfigurationObject::getValue(), TextCommandType::Magic, mSpells, mSpellsVector, save(), serverConfig, SPELL_SHORTCUT_ITEMS, SPELL_SHORTCUT_TABS, and Catch::toString().

Referenced by SpellManager().

parseCommand()

std::string SpellManager::parseCommand ( std::string  command, const Being *const  target  )

staticprivate

Definition at line 209 of file spellmanager.cpp.

{
    if (localPlayer == nullptr)
        return command;
 
    std::string name;
    std::string id;
    std::string name2;
 
    if (target != nullptr)
    {
        name = target->getName();
        name2 = name;
        id = toString(toInt(target->getId(), int));
    }
    else
    {
        name2 = localPlayer->getName();
    }
 
    bool found = false;
 
    size_t idx = command.find("<TARGET>");
    if (idx != std::string::npos)
    {
        found = true;
        command = replaceAll(command, "<TARGET>", name);
    }
    idx = command.find("<TARGETID>");
    if (idx != std::string::npos)
    {
        found = true;
        command = replaceAll(command, "<TARGETID>", id);
    }
    idx = command.find("<TARGETORSELF>");
    if (idx != std::string::npos)
    {
        found = true;
        command = replaceAll(command, "<TARGETORSELF>", name2);
    }
 
    if (!found && !name.empty())
        command.append(" ").append(name);
 
    return command;
}

References ActorSprite::getId(), Being::getName(), localPlayer, replaceAll(), toInt, and Catch::toString().

Referenced by invokeCommand(), and invokeSpell().

save()

void SpellManager::save

(

)

const

Definition at line 329 of file spellmanager.cpp.

{
    for (unsigned i = 0; i < SPELL_SHORTCUT_ITEMS * SPELL_SHORTCUT_TABS; i++)
    {
        const TextCommand *const spell = mSpellsVector[i];
        if (spell != nullptr)
        {
            setOrDel("commandShortcutCmd", getCommand);
            setOrDel("commandShortcutComment", getComment);
            setOrDel("commandShortcutSymbol", getSymbol);
            setOrDel("commandShortcutIcon", getIcon);
            if (!spell->getCommand().empty() &&
                !spell->getSymbol().empty())
            {
#ifdef TMWA_SUPPORT
                serverConfig.setValue("commandShortcutFlags" + toString(i),
                    strprintf("%u %u %u %u %u %u",
                    CAST_U32(spell->getCommandType()),
                    CAST_U32(spell->getTargetType()),
                    spell->getBaseLvl(),
                    CAST_U32(spell->getSchool()),
                    spell->getSchoolLvl(),
                    CAST_U32(spell->getMana())));
#else  // TMWA_SUPPORT
 
                serverConfig.setValue("commandShortcutFlags" + toString(i),
                    strprintf("%u %u %u %u %u %u", 1U,
                    CAST_U32(spell->getTargetType()),
                    0U,
                    0U,
                    0U,
                    0U));
#endif  // TMWA_SUPPORT
            }
            else
            {
                serverConfig.deleteKey("commandShortcutFlags" + toString(i));
            }
        }
    }
}

References CAST_U32, ConfigurationObject::deleteKey(), TextCommand::getBaseLvl(), TextCommand::getCommand(), TextCommand::getCommandType(), LanguageDb::getIcon(), TextCommand::getMana(), TextCommand::getSchool(), TextCommand::getSchoolLvl(), TextCommand::getSymbol(), TextCommand::getTargetType(), mSpellsVector, serverConfig, setOrDel, Configuration::setValue(), SPELL_SHORTCUT_ITEMS, SPELL_SHORTCUT_TABS, strprintf(), and Catch::toString().

Referenced by TextCommandEditor::deleteCommand(), load(), SpellShortcutContainer::mouseReleased(), and TextCommandEditor::save().

swap()

void SpellManager::swap	(	const int	id1,
		const int	id2
	)

Definition at line 414 of file spellmanager.cpp.

{
    TextCommand *const spell1 = mSpells[id1];
    TextCommand *const spell2 = mSpells[id2];
    if ((spell1 == nullptr) || (spell2 == nullptr))
        return;
 
    // swap in map
    mSpells[id1] = spell2;
    mSpells[id2] = spell1;
 
    // swap id
    const int tmp = spell1->getId();
    spell1->setId(spell2->getId());
    spell2->setId(tmp);
 
    // swap in vector
    const size_t sz = SPELL_SHORTCUT_ITEMS * SPELL_SHORTCUT_TABS;
    for (size_t f = 0; f < sz; f++)
    {
        const TextCommand *const spellA = mSpellsVector[f];
        if (spellA == spell1)
        {
            for (size_t d = 0; d < sz; d++)
            {
                const TextCommand *const spellB = mSpellsVector[d];
                if (spellB == spell2)
                {
                    mSpellsVector[f] = spell2;
                    mSpellsVector[d] = spell1;
                    return;
                }
            }
        }
    }
}

References TextCommand::getId(), mSpells, mSpellsVector, TextCommand::setId(), SPELL_SHORTCUT_ITEMS, and SPELL_SHORTCUT_TABS.

Referenced by SpellShortcutContainer::mouseReleased().

useItem()

void SpellManager::useItem

(

const int

itemId

)

const

Definition at line 126 of file spellmanager.cpp.

{
    invoke(itemId - SPELL_MIN_ID);
}

References invoke(), and SPELL_MIN_ID.

Referenced by ItemShortcut::useItem().

Field Documentation

mSpells

std::map<unsigned int, TextCommand*> SpellManager::mSpells

private

Definition at line 84 of file spellmanager.h.

Referenced by addSpell(), fillSpells(), getSpell(), load(), swap(), and ~SpellManager().

mSpellsVector

std::vector<TextCommand*> SpellManager::mSpellsVector

private

Definition at line 85 of file spellmanager.h.

Referenced by addSpell(), autoComplete(), createNewSpell(), getAll(), load(), save(), swap(), and ~SpellManager().

---

The documentation for this class was generated from the following files:

• src/spellmanager.h (986a3bf)
• src/spellmanager.cpp (986a3bf)