Head

GCC Code Coverage Report

Directory:	src/		Exec	Total	Coverage
File:	src/spellmanager.cpp	Lines:	1	181	0.6 %
Date:	2021-03-17	Branches:	0	298	0.0 %


/*
 *  The ManaPlus Client
 *  Copyright (C) 2009  The Mana World Development Team
 *  Copyright (C) 2011-2019  The ManaPlus Developers
 *  Copyright (C) 2009-2021  Andrei Karas
 *
 *  This file is part of The ManaPlus Client.
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

#include "spellmanager.h"

#include "configuration.h"
#include "textcommand.h"

#include "being/localplayer.h"
#ifdef TMWA_SUPPORT
#include "being/playerinfo.h"
#endif  // TMWA_SUPPORT

#include "const/spells.h"

#include "gui/windows/chatwindow.h"

#include "net/playerhandler.h"

#include "resources/db/commandsdb.h"

#include "utils/dtor.h"
#include "utils/foreach.h"

#include <sstream>

#include "debug.h"

SpellManager *spellManager = nullptr;

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

SpellManager::~SpellManager()
{
    delete_all(mSpells);
    mSpells.clear();
    mSpellsVector.clear();
}

TextCommand* SpellManager::getSpell(const int spellId) const
{
    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;
}

const TextCommand* SpellManager::getSpellByItem(const int itemId) const
{
    return getSpell(itemId - SPELL_MIN_ID);
}

void SpellManager::fillSpells()
{
    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();
}

bool SpellManager::addSpell(TextCommand *const spell)
{
    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;
}

const STD_VECTOR<TextCommand*> &SpellManager::getAll() const
{
    return mSpellsVector;
}

void SpellManager::useItem(const int itemId) const
{
    invoke(itemId - SPELL_MIN_ID);
}

void SpellManager::invoke(const int spellId) const
{
    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);
        }
    }
}

void SpellManager::invokeSpell(const TextCommand *const spell)
{
    if ((chatWindow == nullptr) || (spell == nullptr))
        return;
    chatWindow->localChatInput(parseCommand(spell->getCommand(), nullptr));
}

void SpellManager::invokeSpell(const TextCommand *const spell,
                               const Being *const target)
{
    if (chatWindow == nullptr ||
        spell == nullptr ||
        target == nullptr)
    {
        return;
    }
    chatWindow->localChatInput(parseCommand(spell->getCommand(), target));
}

void SpellManager::invokeCommand(const std::string &command,
                                 const Being *const target)
{
    if (chatWindow == nullptr)
        return;
    chatWindow->localChatInput(parseCommand(command, target));
}

std::string SpellManager::parseCommand(std::string command,
                                       const Being *const target)
{
    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;
}

TextCommand *SpellManager::createNewSpell() const
{
    return new TextCommand(CAST_U32(mSpellsVector.size()));
}

void SpellManager::load()
{
    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));
        }
    }
}

#define setOrDel(str, method) \
    const std::string var##method = spell->method(); \
    if (!var##method.empty()) \
        serverConfig.setValue((str) + toString(i), var##method); \
    else \
        serverConfig.deleteKey((str) + toString(i))

void SpellManager::save() const
{
    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));
            }
        }
    }
}

#undef setOrDel

std::string SpellManager::autoComplete(const std::string &partName) const
{
    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;
}

void SpellManager::swap(const int id1, const int id2)
{
    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;
                }
            }
        }
    }
}


Generated by: GCOVR (Version 3.3)

Line	Branch	Exec	Source
1			/*
2			* The ManaPlus Client
3			* Copyright (C) 2009 The Mana World Development Team
4			* Copyright (C) 2011-2019 The ManaPlus Developers
5			* Copyright (C) 2009-2021 Andrei Karas
6			*
7			* This file is part of The ManaPlus Client.
8			*
9			* This program is free software; you can redistribute it and/or modify
10			* it under the terms of the GNU General Public License as published by
11			* the Free Software Foundation; either version 2 of the License, or
12			* any later version.
13			*
14			* This program is distributed in the hope that it will be useful,
15			* but WITHOUT ANY WARRANTY; without even the implied warranty of
16			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17			* GNU General Public License for more details.
18			*
19			* You should have received a copy of the GNU General Public License
20			* along with this program. If not, see <http://www.gnu.org/licenses/>.
21			*/
22
23			#include "spellmanager.h"
24
25			#include "configuration.h"
26			#include "textcommand.h"
27
28			#include "being/localplayer.h"
29			#ifdef TMWA_SUPPORT
30			#include "being/playerinfo.h"
31			#endif // TMWA_SUPPORT
32
33			#include "const/spells.h"
34
35			#include "gui/windows/chatwindow.h"
36
37			#include "net/playerhandler.h"
38
39			#include "resources/db/commandsdb.h"
40
41			#include "utils/dtor.h"
42			#include "utils/foreach.h"
43
44			#include <sstream>
45
46			#include "debug.h"
47
48			SpellManager *spellManager = nullptr;
49
50			SpellManager::SpellManager() :
51			mSpells(),
52			mSpellsVector()
53			{
54			load();
55			}
56
57			SpellManager::~SpellManager()
58			{
59			delete_all(mSpells);
60			mSpells.clear();
61			mSpellsVector.clear();
62			}
63
64			TextCommand* SpellManager::getSpell(const int spellId) const
65			{
66			if (spellId < 0 \|\| CAST_SIZE(spellId) >= mSpells.size())
67			return nullptr;
68
69			const std::map<unsigned int, TextCommand*>::const_iterator
70			it = mSpells.find(spellId);
71
72			return it != mSpells.end() ? (*it).second : nullptr;
73			}
74
75			const TextCommand* SpellManager::getSpellByItem(const int itemId) const
76			{
77			return getSpell(itemId - SPELL_MIN_ID);
78			}
79
80			void SpellManager::fillSpells()
81			{
82			CommandsDB::load();
83
84			CommandsMap &commands = CommandsDB::getAll();
85			FOR_EACH (CommandsMapIter, it, commands)
86			addSpell((*it).second);
87
88			for (unsigned f = 0; f < SPELL_SHORTCUT_ITEMS * SPELL_SHORTCUT_TABS; f++)
89			{
90			const std::map<unsigned int, TextCommand*>::const_iterator
91			it = mSpells.find(f);
92			if (it == mSpells.end())
93			addSpell(new TextCommand(f));
94			}
95			CommandsDB::unload();
96			}
97
98			bool SpellManager::addSpell(TextCommand *const spell)
99			{
100			if (spell == nullptr)
101			return false;
102
103			const int id = spell->getId();
104			if (id < 0 \|\| id >= CAST_S32(SPELL_SHORTCUT_ITEMS
105			* SPELL_SHORTCUT_TABS))
106			{
107			delete spell;
108			return false;
109			}
110			const std::map<unsigned int, TextCommand*>::const_iterator
111			i = mSpells.find(spell->getId());
112			if (i == mSpells.end())
113			{
114			mSpells[spell->getId()] = spell;
115			mSpellsVector.push_back(spell);
116			return true;
117			}
118			return false;
119			}
120
121			const STD_VECTOR<TextCommand*> &SpellManager::getAll() const
122			{
123			return mSpellsVector;
124			}
125
126			void SpellManager::useItem(const int itemId) const
127			{
128			invoke(itemId - SPELL_MIN_ID);
129			}
130
131			void SpellManager::invoke(const int spellId) const
132			{
133			if (localPlayer == nullptr)
134			return;
135
136			const TextCommand *const spell = getSpell(spellId);
137			if (spell == nullptr)
138			return;
139
140			if ((playerHandler == nullptr) \|\| spell->getCommand().empty())
141			return;
142
143			#ifdef TMWA_SUPPORT
144			if (spell->getCommandType() == TextCommandType::Text \|\|
145			(playerHandler->canUseMagic() &&
146			PlayerInfo::getSkillLevel(CAST_S32(MagicSchool::SkillMagic))
147			>= CAST_S32(spell->getBaseLvl()) &&
148			PlayerInfo::getSkillLevel(CAST_S32(
149			spell->getSchool())) >= CAST_S32(spell->getSchoolLvl())
150			&& PlayerInfo::getAttribute(Attributes::PLAYER_MP)
151			>= CAST_S32(spell->getMana()))
152			)
153			#endif // TMWA_SUPPORT
154			{
155			const Being *const target = localPlayer->getTarget();
156			if (spell->getTargetType() == CommandTarget::NoTarget)
157			{
158			invokeSpell(spell);
159			}
160			#ifdef TMWA_SUPPORT
161			if ((target != nullptr &&
162			(target->getType() != ActorType::Monster \|\|
163			spell->getCommandType() == TextCommandType::Text)) &&
164			(spell->getTargetType() == CommandTarget::AllowTarget \|\|
165			spell->getTargetType() == CommandTarget::NeedTarget))
166			#else // TMWA_SUPPORT
167
168			if (target != nullptr &&
169			(spell->getTargetType() == CommandTarget::AllowTarget \|\|
170			spell->getTargetType() == CommandTarget::NeedTarget))
171			#endif // TMWA_SUPPORT
172			{
173			invokeSpell(spell, target);
174			}
175			else if (spell->getTargetType() == CommandTarget::AllowTarget)
176			{
177			invokeSpell(spell);
178			}
179			}
180			}
181
182			void SpellManager::invokeSpell(const TextCommand *const spell)
183			{
184			if ((chatWindow == nullptr) \|\| (spell == nullptr))
185			return;
186			chatWindow->localChatInput(parseCommand(spell->getCommand(), nullptr));
187			}
188
189			void SpellManager::invokeSpell(const TextCommand *const spell,
190			const Being *const target)
191			{
192			if (chatWindow == nullptr \|\|
193			spell == nullptr \|\|
194			target == nullptr)
195			{
196			return;
197			}
198			chatWindow->localChatInput(parseCommand(spell->getCommand(), target));
199			}
200
201			void SpellManager::invokeCommand(const std::string &command,
202			const Being *const target)
203			{
204			if (chatWindow == nullptr)
205			return;
206			chatWindow->localChatInput(parseCommand(command, target));
207			}
208
209			std::string SpellManager::parseCommand(std::string command,
210			const Being *const target)
211			{
212			if (localPlayer == nullptr)
213			return command;
214
215			std::string name;
216			std::string id;
217			std::string name2;
218
219			if (target != nullptr)
220			{
221			name = target->getName();
222			name2 = name;
223			id = toString(toInt(target->getId(), int));
224			}
225			else
226			{
227			name2 = localPlayer->getName();
228			}
229
230			bool found = false;
231
232			size_t idx = command.find("<TARGET>");
233			if (idx != std::string::npos)
234			{
235			found = true;
236			command = replaceAll(command, "<TARGET>", name);
237			}
238			idx = command.find("<TARGETID>");
239			if (idx != std::string::npos)
240			{
241			found = true;
242			command = replaceAll(command, "<TARGETID>", id);
243			}
244			idx = command.find("<TARGETORSELF>");
245			if (idx != std::string::npos)
246			{
247			found = true;
248			command = replaceAll(command, "<TARGETORSELF>", name2);
249			}
250
251			if (!found && !name.empty())
252			command.append(" ").append(name);
253
254			return command;
255			}
256
257			TextCommand *SpellManager::createNewSpell() const
258			{
259			return new TextCommand(CAST_U32(mSpellsVector.size()));
260			}
261
262			void SpellManager::load()
263			{
264			const Configuration *cfg = &serverConfig;
265
266			delete_all(mSpells);
267			mSpells.clear();
268			mSpellsVector.clear();
269
270			if (cfg->getValue("commandShortcutFlags0", "").empty())
271			{
272			fillSpells();
273			save();
274			return;
275			}
276
277			for (unsigned i = 0; i < SPELL_SHORTCUT_ITEMS * SPELL_SHORTCUT_TABS; i++)
278			{
279			unsigned int targetType;
280			unsigned int basicLvl;
281			unsigned int school;
282			unsigned int schoolLvl;
283			unsigned int mana;
284			unsigned int commandType;
285
286			std::string flags =
287			cfg->getValue("commandShortcutFlags" + toString(i), "");
288			std::stringstream ss(flags);
289			ss >> commandType;
290			ss >> targetType;
291			ss >> basicLvl;
292			ss >> school;
293			ss >> schoolLvl;
294			ss >> mana;
295
296			std::string cmd = cfg->getValue("commandShortcutCmd"
297			+ toString(i), "");
298			std::string comment = cfg->getValue("commandShortcutComment"
299			+ toString(i), "");
300			std::string symbol = cfg->getValue("commandShortcutSymbol"
301			+ toString(i), "");
302			std::string icon = cfg->getValue("commandShortcutIcon"
303			+ toString(i), "");
304
305			#ifdef TMWA_SUPPORT
306			if (static_cast<TextCommandTypeT>(commandType) ==
307			TextCommandType::Magic)
308			{
309			addSpell(new TextCommand(i, symbol, cmd, comment,
310			static_cast<CommandTargetT>(targetType), icon, basicLvl,
311			static_cast<MagicSchoolT>(school), schoolLvl, mana));
312			}
313			else
314			#endif // TMWA_SUPPORT
315			{
316			addSpell(new TextCommand(i, symbol, cmd, comment,
317			static_cast<CommandTargetT>(targetType), icon));
318			}
319			}
320			}
321
322			#define setOrDel(str, method) \
323			const std::string var##method = spell->method(); \
324			if (!var##method.empty()) \
325			serverConfig.setValue((str) + toString(i), var##method); \
326			else \
327			serverConfig.deleteKey((str) + toString(i))
328
329			void SpellManager::save() const
330			{
331			for (unsigned i = 0; i < SPELL_SHORTCUT_ITEMS * SPELL_SHORTCUT_TABS; i++)
332			{
333			const TextCommand *const spell = mSpellsVector[i];
334			if (spell != nullptr)
335			{
336			setOrDel("commandShortcutCmd", getCommand);
337			setOrDel("commandShortcutComment", getComment);
338			setOrDel("commandShortcutSymbol", getSymbol);
339			setOrDel("commandShortcutIcon", getIcon);
340			if (!spell->getCommand().empty() &&
341			!spell->getSymbol().empty())
342			{
343			#ifdef TMWA_SUPPORT
344			serverConfig.setValue("commandShortcutFlags" + toString(i),
345			strprintf("%u %u %u %u %u %u",
346			CAST_U32(spell->getCommandType()),
347			CAST_U32(spell->getTargetType()),
348			spell->getBaseLvl(),
349			CAST_U32(spell->getSchool()),
350			spell->getSchoolLvl(),
351			CAST_U32(spell->getMana())));
352			#else // TMWA_SUPPORT
353
354			serverConfig.setValue("commandShortcutFlags" + toString(i),
355			strprintf("%u %u %u %u %u %u", 1U,
356			CAST_U32(spell->getTargetType()),
357			0U,
358			0U,
359			0U,
360			0U));
361			#endif // TMWA_SUPPORT
362			}
363			else
364			{
365			serverConfig.deleteKey("commandShortcutFlags" + toString(i));
366			}
367			}
368			}
369			}
370
371			#undef setOrDel
372
373			std::string SpellManager::autoComplete(const std::string &partName) const
374			{
375			STD_VECTOR<TextCommand*>::const_iterator i = mSpellsVector.begin();
376			const STD_VECTOR<TextCommand*>::const_iterator
377			i_end = mSpellsVector.end();
378			std::string newName;
379			const TextCommand *newCommand = nullptr;
380
381			while (i != i_end)
382			{
383			const TextCommand const cmd = i;
384			const std::string line = cmd->getCommand();
385
386			if (!line.empty())
387			{
388			const size_t pos = line.find(partName, 0);
389			if (pos == 0)
390			{
391			if (!newName.empty())
392			{
393			newName = findSameSubstring(line, newName);
394			newCommand = nullptr;
395			}
396			else
397			{
398			newName = line;
399			newCommand = cmd;
400			}
401			}
402			}
403			++i;
404			}
405			if (!newName.empty() &&
406			(newCommand != nullptr) &&
407			newCommand->getTargetType() == CommandTarget::NeedTarget)
408			{
409			return newName.append(" ");
410			}
411			return newName;
412			}
413
414			void SpellManager::swap(const int id1, const int id2)
415			{
416			TextCommand *const spell1 = mSpells[id1];
417			TextCommand *const spell2 = mSpells[id2];
418			if ((spell1 == nullptr) \|\| (spell2 == nullptr))
419			return;
420
421			// swap in map
422			mSpells[id1] = spell2;
423			mSpells[id2] = spell1;
424
425			// swap id
426			const int tmp = spell1->getId();
427			spell1->setId(spell2->getId());
428			spell2->setId(tmp);
429
430			// swap in vector
431			const size_t sz = SPELL_SHORTCUT_ITEMS * SPELL_SHORTCUT_TABS;
432			for (size_t f = 0; f < sz; f++)
433			{
434			const TextCommand *const spellA = mSpellsVector[f];
435			if (spellA == spell1)
436			{
437			for (size_t d = 0; d < sz; d++)
438			{
439			const TextCommand *const spellB = mSpellsVector[d];
440			if (spellB == spell2)
441			{
442			mSpellsVector[f] = spell2;
443			mSpellsVector[d] = spell1;
444			return;
445			}
446			}
447			}
448			}
449		2	}