?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[8590] Restore build at Unix/Linux.
[getmangos.git] / src / game / Level3.cpp
blob3e3e650821e4a304f44de4d8fec096063ce63337
1 /*
2 * Copyright (C) 2005-2009 MaNGOS <http://getmangos.com/>
3 *
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License as published by
6 * the Free Software Foundation; either version 2 of the License, or
7 * (at your option) any later version.
8 *
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
13 *
14 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, write to the Free Software
16 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17 */
18
19 #include "Common.h"
20 #include "Database/DatabaseEnv.h"
21 #include "WorldPacket.h"
22 #include "WorldSession.h"
23 #include "World.h"
24 #include "ObjectMgr.h"
25 #include "AccountMgr.h"
26 #include "PlayerDump.h"
27 #include "SpellMgr.h"
28 #include "Player.h"
29 #include "Opcodes.h"
30 #include "GameObject.h"
31 #include "Chat.h"
32 #include "Log.h"
33 #include "Guild.h"
34 #include "ObjectAccessor.h"
35 #include "MapManager.h"
36 #include "ScriptCalls.h"
37 #include "Language.h"
38 #include "GridNotifiersImpl.h"
39 #include "CellImpl.h"
40 #include "Weather.h"
41 #include "PointMovementGenerator.h"
42 #include "TargetedMovementGenerator.h"
43 #include "SkillDiscovery.h"
44 #include "SkillExtraItems.h"
45 #include "SystemConfig.h"
46 #include "Config/ConfigEnv.h"
47 #include "Util.h"
48 #include "ItemEnchantmentMgr.h"
49 #include "BattleGroundMgr.h"
50 #include "InstanceSaveMgr.h"
51 #include "InstanceData.h"
52 #include "CreatureEventAIMgr.h"
53 #include "DBCEnums.h"
54
55 //reload commands
56 bool ChatHandler::HandleReloadAllCommand(const char*)
57 {
58 HandleReloadSkillFishingBaseLevelCommand("");
59
60 HandleReloadAllAchievementCommand("");
61 HandleReloadAllAreaCommand("");
62 HandleReloadAllEventAICommand("");
63 HandleReloadAllLootCommand("");
64 HandleReloadAllNpcCommand("");
65 HandleReloadAllQuestCommand("");
66 HandleReloadAllSpellCommand("");
67 HandleReloadAllItemCommand("");
68 HandleReloadAllLocalesCommand("");
69
70 HandleReloadCommandCommand("");
71 HandleReloadReservedNameCommand("");
72 HandleReloadMangosStringCommand("");
73 HandleReloadGameTeleCommand("");
74 return true;
75 }
76
77 bool ChatHandler::HandleReloadAllAchievementCommand(const char*)
78 {
79 HandleReloadAchievementCriteriaDataCommand("");
80 HandleReloadAchievementRewardCommand("");
81 return true;
82 }
83
84 bool ChatHandler::HandleReloadAllAreaCommand(const char*)
85 {
86 //HandleReloadQuestAreaTriggersCommand(""); -- reloaded in HandleReloadAllQuestCommand
87 HandleReloadAreaTriggerTeleportCommand("");
88 HandleReloadAreaTriggerTavernCommand("");
89 HandleReloadGameGraveyardZoneCommand("");
90 return true;
91 }
92
93 bool ChatHandler::HandleReloadAllLootCommand(const char*)
94 {
95 sLog.outString( "Re-Loading Loot Tables..." );
96 LoadLootTables();
97 SendGlobalSysMessage("DB tables `*_loot_template` reloaded.");
98 return true;
99 }
100
101 bool ChatHandler::HandleReloadAllNpcCommand(const char* /*args*/)
102 {
103 HandleReloadNpcGossipCommand("a");
104 HandleReloadNpcOptionCommand("a");
105 HandleReloadNpcTrainerCommand("a");
106 HandleReloadNpcVendorCommand("a");
107 HandleReloadPointsOfInterestCommand("a");
108 HandleReloadSpellClickSpellsCommand("a");
109 return true;
110 }
111
112 bool ChatHandler::HandleReloadAllQuestCommand(const char* /*args*/)
113 {
114 HandleReloadQuestAreaTriggersCommand("a");
115 HandleReloadQuestTemplateCommand("a");
116
117 sLog.outString( "Re-Loading Quests Relations..." );
118 objmgr.LoadQuestRelations();
119 SendGlobalSysMessage("DB tables `*_questrelation` and `*_involvedrelation` reloaded.");
120 return true;
121 }
122
123 bool ChatHandler::HandleReloadAllScriptsCommand(const char*)
124 {
125 if(sWorld.IsScriptScheduled())
126 {
127 PSendSysMessage("DB scripts used currently, please attempt reload later.");
128 SetSentErrorMessage(true);
129 return false;
130 }
131
132 sLog.outString( "Re-Loading Scripts..." );
133 HandleReloadGameObjectScriptsCommand("a");
134 HandleReloadEventScriptsCommand("a");
135 HandleReloadQuestEndScriptsCommand("a");
136 HandleReloadQuestStartScriptsCommand("a");
137 HandleReloadSpellScriptsCommand("a");
138 SendGlobalSysMessage("DB tables `*_scripts` reloaded.");
139 HandleReloadDbScriptStringCommand("a");
140 return true;
141 }
142
143 bool ChatHandler::HandleReloadAllEventAICommand(const char*)
144 {
145 HandleReloadEventAITextsCommand("a");
146 HandleReloadEventAISummonsCommand("a");
147 HandleReloadEventAIScriptsCommand("a");
148 return true;
149 }
150
151 bool ChatHandler::HandleReloadAllSpellCommand(const char*)
152 {
153 HandleReloadSkillDiscoveryTemplateCommand("a");
154 HandleReloadSkillExtraItemTemplateCommand("a");
155 HandleReloadSpellAreaCommand("a");
156 HandleReloadSpellChainCommand("a");
157 HandleReloadSpellElixirCommand("a");
158 HandleReloadSpellLearnSpellCommand("a");
159 HandleReloadSpellProcEventCommand("a");
160 HandleReloadSpellBonusesCommand("a");
161 HandleReloadSpellProcItemEnchantCommand("a");
162 HandleReloadSpellScriptTargetCommand("a");
163 HandleReloadSpellTargetPositionCommand("a");
164 HandleReloadSpellThreatsCommand("a");
165 HandleReloadSpellPetAurasCommand("a");
166 return true;
167 }
168
169 bool ChatHandler::HandleReloadAllItemCommand(const char*)
170 {
171 HandleReloadPageTextsCommand("a");
172 HandleReloadItemEnchantementsCommand("a");
173 HandleReloadItemRequiredTragetCommand("a");
174 return true;
175 }
176
177 bool ChatHandler::HandleReloadAllLocalesCommand(const char* /*args*/)
178 {
179 HandleReloadLocalesAchievementRewardCommand("a");
180 HandleReloadLocalesCreatureCommand("a");
181 HandleReloadLocalesGameobjectCommand("a");
182 HandleReloadLocalesItemCommand("a");
183 HandleReloadLocalesNpcTextCommand("a");
184 HandleReloadLocalesPageTextCommand("a");
185 HandleReloadLocalesPointsOfInterestCommand("a");
186 HandleReloadLocalesQuestCommand("a");
187 return true;
188 }
189
190 bool ChatHandler::HandleReloadConfigCommand(const char* /*args*/)
191 {
192 sLog.outString( "Re-Loading config settings..." );
193 sWorld.LoadConfigSettings(true);
194 MapManager::Instance().InitializeVisibilityDistanceInfo();
195 SendGlobalSysMessage("World config settings reloaded.");
196 return true;
197 }
198
199 bool ChatHandler::HandleReloadAchievementCriteriaDataCommand(const char*)
200 {
201 sLog.outString( "Re-Loading Additional Achievement Criteria Data..." );
202 achievementmgr.LoadAchievementCriteriaData();
203 SendGlobalSysMessage("DB table `achievement_criteria_data` reloaded.");
204 return true;
205 }
206
207 bool ChatHandler::HandleReloadAchievementRewardCommand(const char*)
208 {
209 sLog.outString( "Re-Loading Achievement Reward Data..." );
210 achievementmgr.LoadRewards();
211 SendGlobalSysMessage("DB table `achievement_reward` reloaded.");
212 return true;
213 }
214
215 bool ChatHandler::HandleReloadAreaTriggerTavernCommand(const char*)
216 {
217 sLog.outString( "Re-Loading Tavern Area Triggers..." );
218 objmgr.LoadTavernAreaTriggers();
219 SendGlobalSysMessage("DB table `areatrigger_tavern` reloaded.");
220 return true;
221 }
222
223 bool ChatHandler::HandleReloadAreaTriggerTeleportCommand(const char*)
224 {
225 sLog.outString( "Re-Loading AreaTrigger teleport definitions..." );
226 objmgr.LoadAreaTriggerTeleports();
227 SendGlobalSysMessage("DB table `areatrigger_teleport` reloaded.");
228 return true;
229 }
230
231 bool ChatHandler::HandleReloadCommandCommand(const char*)
232 {
233 load_command_table = true;
234 SendGlobalSysMessage("DB table `command` will be reloaded at next chat command use.");
235 return true;
236 }
237
238 bool ChatHandler::HandleReloadCreatureQuestRelationsCommand(const char*)
239 {
240 sLog.outString( "Loading Quests Relations... (`creature_questrelation`)" );
241 objmgr.LoadCreatureQuestRelations();
242 SendGlobalSysMessage("DB table `creature_questrelation` (creature quest givers) reloaded.");
243 return true;
244 }
245
246 bool ChatHandler::HandleReloadCreatureQuestInvRelationsCommand(const char*)
247 {
248 sLog.outString( "Loading Quests Relations... (`creature_involvedrelation`)" );
249 objmgr.LoadCreatureInvolvedRelations();
250 SendGlobalSysMessage("DB table `creature_involvedrelation` (creature quest takers) reloaded.");
251 return true;
252 }
253
254 bool ChatHandler::HandleReloadGOQuestRelationsCommand(const char*)
255 {
256 sLog.outString( "Loading Quests Relations... (`gameobject_questrelation`)" );
257 objmgr.LoadGameobjectQuestRelations();
258 SendGlobalSysMessage("DB table `gameobject_questrelation` (gameobject quest givers) reloaded.");
259 return true;
260 }
261
262 bool ChatHandler::HandleReloadGOQuestInvRelationsCommand(const char*)
263 {
264 sLog.outString( "Loading Quests Relations... (`gameobject_involvedrelation`)" );
265 objmgr.LoadGameobjectInvolvedRelations();
266 SendGlobalSysMessage("DB table `gameobject_involvedrelation` (gameobject quest takers) reloaded.");
267 return true;
268 }
269
270 bool ChatHandler::HandleReloadQuestAreaTriggersCommand(const char*)
271 {
272 sLog.outString( "Re-Loading Quest Area Triggers..." );
273 objmgr.LoadQuestAreaTriggers();
274 SendGlobalSysMessage("DB table `areatrigger_involvedrelation` (quest area triggers) reloaded.");
275 return true;
276 }
277
278 bool ChatHandler::HandleReloadQuestTemplateCommand(const char*)
279 {
280 sLog.outString( "Re-Loading Quest Templates..." );
281 objmgr.LoadQuests();
282 SendGlobalSysMessage("DB table `quest_template` (quest definitions) reloaded.");
283
284 /// dependent also from `gameobject` but this table not reloaded anyway
285 sLog.outString( "Re-Loading GameObjects for quests..." );
286 objmgr.LoadGameObjectForQuests();
287 SendGlobalSysMessage("Data GameObjects for quests reloaded.");
288 return true;
289 }
290
291 bool ChatHandler::HandleReloadLootTemplatesCreatureCommand(const char*)
292 {
293 sLog.outString( "Re-Loading Loot Tables... (`creature_loot_template`)" );
294 LoadLootTemplates_Creature();
295 LootTemplates_Creature.CheckLootRefs();
296 SendGlobalSysMessage("DB table `creature_loot_template` reloaded.");
297 return true;
298 }
299
300 bool ChatHandler::HandleReloadLootTemplatesDisenchantCommand(const char*)
301 {
302 sLog.outString( "Re-Loading Loot Tables... (`disenchant_loot_template`)" );
303 LoadLootTemplates_Disenchant();
304 LootTemplates_Disenchant.CheckLootRefs();
305 SendGlobalSysMessage("DB table `disenchant_loot_template` reloaded.");
306 return true;
307 }
308
309 bool ChatHandler::HandleReloadLootTemplatesFishingCommand(const char*)
310 {
311 sLog.outString( "Re-Loading Loot Tables... (`fishing_loot_template`)" );
312 LoadLootTemplates_Fishing();
313 LootTemplates_Fishing.CheckLootRefs();
314 SendGlobalSysMessage("DB table `fishing_loot_template` reloaded.");
315 return true;
316 }
317
318 bool ChatHandler::HandleReloadLootTemplatesGameobjectCommand(const char*)
319 {
320 sLog.outString( "Re-Loading Loot Tables... (`gameobject_loot_template`)" );
321 LoadLootTemplates_Gameobject();
322 LootTemplates_Gameobject.CheckLootRefs();
323 SendGlobalSysMessage("DB table `gameobject_loot_template` reloaded.");
324 return true;
325 }
326
327 bool ChatHandler::HandleReloadLootTemplatesItemCommand(const char*)
328 {
329 sLog.outString( "Re-Loading Loot Tables... (`item_loot_template`)" );
330 LoadLootTemplates_Item();
331 LootTemplates_Item.CheckLootRefs();
332 SendGlobalSysMessage("DB table `item_loot_template` reloaded.");
333 return true;
334 }
335
336 bool ChatHandler::HandleReloadLootTemplatesMillingCommand(const char*)
337 {
338 sLog.outString( "Re-Loading Loot Tables... (`milling_loot_template`)" );
339 LoadLootTemplates_Milling();
340 LootTemplates_Milling.CheckLootRefs();
341 SendGlobalSysMessage("DB table `milling_loot_template` reloaded.");
342 return true;
343 }
344
345 bool ChatHandler::HandleReloadLootTemplatesPickpocketingCommand(const char*)
346 {
347 sLog.outString( "Re-Loading Loot Tables... (`pickpocketing_loot_template`)" );
348 LoadLootTemplates_Pickpocketing();
349 LootTemplates_Pickpocketing.CheckLootRefs();
350 SendGlobalSysMessage("DB table `pickpocketing_loot_template` reloaded.");
351 return true;
352 }
353
354 bool ChatHandler::HandleReloadLootTemplatesProspectingCommand(const char*)
355 {
356 sLog.outString( "Re-Loading Loot Tables... (`prospecting_loot_template`)" );
357 LoadLootTemplates_Prospecting();
358 LootTemplates_Prospecting.CheckLootRefs();
359 SendGlobalSysMessage("DB table `prospecting_loot_template` reloaded.");
360 return true;
361 }
362
363 bool ChatHandler::HandleReloadLootTemplatesQuestMailCommand(const char*)
364 {
365 sLog.outString( "Re-Loading Loot Tables... (`quest_mail_loot_template`)" );
366 LoadLootTemplates_QuestMail();
367 LootTemplates_QuestMail.CheckLootRefs();
368 SendGlobalSysMessage("DB table `quest_mail_loot_template` reloaded.");
369 return true;
370 }
371
372 bool ChatHandler::HandleReloadLootTemplatesReferenceCommand(const char*)
373 {
374 sLog.outString( "Re-Loading Loot Tables... (`reference_loot_template`)" );
375 LoadLootTemplates_Reference();
376 SendGlobalSysMessage("DB table `reference_loot_template` reloaded.");
377 return true;
378 }
379
380 bool ChatHandler::HandleReloadLootTemplatesSkinningCommand(const char*)
381 {
382 sLog.outString( "Re-Loading Loot Tables... (`skinning_loot_template`)" );
383 LoadLootTemplates_Skinning();
384 LootTemplates_Skinning.CheckLootRefs();
385 SendGlobalSysMessage("DB table `skinning_loot_template` reloaded.");
386 return true;
387 }
388
389 bool ChatHandler::HandleReloadLootTemplatesSpellCommand(const char*)
390 {
391 sLog.outString( "Re-Loading Loot Tables... (`spell_loot_template`)" );
392 LoadLootTemplates_Spell();
393 LootTemplates_Spell.CheckLootRefs();
394 SendGlobalSysMessage("DB table `spell_loot_template` reloaded.");
395 return true;
396 }
397
398 bool ChatHandler::HandleReloadMangosStringCommand(const char*)
399 {
400 sLog.outString( "Re-Loading mangos_string Table!" );
401 objmgr.LoadMangosStrings();
402 SendGlobalSysMessage("DB table `mangos_string` reloaded.");
403 return true;
404 }
405
406 bool ChatHandler::HandleReloadNpcOptionCommand(const char*)
407 {
408 sLog.outString( "Re-Loading `npc_option` Table!" );
409 objmgr.LoadNpcOptions();
410 SendGlobalSysMessage("DB table `npc_option` reloaded.");
411 return true;
412 }
413
414 bool ChatHandler::HandleReloadNpcGossipCommand(const char*)
415 {
416 sLog.outString( "Re-Loading `npc_gossip` Table!" );
417 objmgr.LoadNpcTextId();
418 SendGlobalSysMessage("DB table `npc_gossip` reloaded.");
419 return true;
420 }
421
422 bool ChatHandler::HandleReloadNpcTrainerCommand(const char*)
423 {
424 sLog.outString( "Re-Loading `npc_trainer` Table!" );
425 objmgr.LoadTrainerSpell();
426 SendGlobalSysMessage("DB table `npc_trainer` reloaded.");
427 return true;
428 }
429
430 bool ChatHandler::HandleReloadNpcVendorCommand(const char*)
431 {
432 sLog.outString( "Re-Loading `npc_vendor` Table!" );
433 objmgr.LoadVendors();
434 SendGlobalSysMessage("DB table `npc_vendor` reloaded.");
435 return true;
436 }
437
438 bool ChatHandler::HandleReloadPointsOfInterestCommand(const char*)
439 {
440 sLog.outString( "Re-Loading `points_of_interest` Table!" );
441 objmgr.LoadPointsOfInterest();
442 SendGlobalSysMessage("DB table `points_of_interest` reloaded.");
443 return true;
444 }
445
446 bool ChatHandler::HandleReloadSpellClickSpellsCommand(const char*)
447 {
448 sLog.outString( "Re-Loading `npc_spellclick_spells` Table!" );
449 objmgr.LoadNPCSpellClickSpells();
450 SendGlobalSysMessage("DB table `npc_spellclick_spells` reloaded.");
451 return true;
452 }
453
454 bool ChatHandler::HandleReloadReservedNameCommand(const char*)
455 {
456 sLog.outString( "Loading ReservedNames... (`reserved_name`)" );
457 objmgr.LoadReservedPlayersNames();
458 SendGlobalSysMessage("DB table `reserved_name` (player reserved names) reloaded.");
459 return true;
460 }
461
462 bool ChatHandler::HandleReloadSkillDiscoveryTemplateCommand(const char* /*args*/)
463 {
464 sLog.outString( "Re-Loading Skill Discovery Table..." );
465 LoadSkillDiscoveryTable();
466 SendGlobalSysMessage("DB table `skill_discovery_template` (recipes discovered at crafting) reloaded.");
467 return true;
468 }
469
470 bool ChatHandler::HandleReloadSkillExtraItemTemplateCommand(const char* /*args*/)
471 {
472 sLog.outString( "Re-Loading Skill Extra Item Table..." );
473 LoadSkillExtraItemTable();
474 SendGlobalSysMessage("DB table `skill_extra_item_template` (extra item creation when crafting) reloaded.");
475 return true;
476 }
477
478 bool ChatHandler::HandleReloadSkillFishingBaseLevelCommand(const char* /*args*/)
479 {
480 sLog.outString( "Re-Loading Skill Fishing base level requirements..." );
481 objmgr.LoadFishingBaseSkillLevel();
482 SendGlobalSysMessage("DB table `skill_fishing_base_level` (fishing base level for zone/subzone) reloaded.");
483 return true;
484 }
485
486 bool ChatHandler::HandleReloadSpellAreaCommand(const char*)
487 {
488 sLog.outString( "Re-Loading SpellArea Data..." );
489 spellmgr.LoadSpellAreas();
490 SendGlobalSysMessage("DB table `spell_area` (spell dependences from area/quest/auras state) reloaded.");
491 return true;
492 }
493
494 bool ChatHandler::HandleReloadSpellChainCommand(const char*)
495 {
496 sLog.outString( "Re-Loading Spell Chain Data... " );
497 spellmgr.LoadSpellChains();
498 SendGlobalSysMessage("DB table `spell_chain` (spell ranks) reloaded.");
499 return true;
500 }
501
502 bool ChatHandler::HandleReloadSpellElixirCommand(const char*)
503 {
504 sLog.outString( "Re-Loading Spell Elixir types..." );
505 spellmgr.LoadSpellElixirs();
506 SendGlobalSysMessage("DB table `spell_elixir` (spell elixir types) reloaded.");
507 return true;
508 }
509
510 bool ChatHandler::HandleReloadSpellLearnSpellCommand(const char*)
511 {
512 sLog.outString( "Re-Loading Spell Learn Spells..." );
513 spellmgr.LoadSpellLearnSpells();
514 SendGlobalSysMessage("DB table `spell_learn_spell` reloaded.");
515 return true;
516 }
517
518 bool ChatHandler::HandleReloadSpellProcEventCommand(const char*)
519 {
520 sLog.outString( "Re-Loading Spell Proc Event conditions..." );
521 spellmgr.LoadSpellProcEvents();
522 SendGlobalSysMessage("DB table `spell_proc_event` (spell proc trigger requirements) reloaded.");
523 return true;
524 }
525
526 bool ChatHandler::HandleReloadSpellBonusesCommand(const char*)
527 {
528 sLog.outString( "Re-Loading Spell Bonus Data..." );
529 spellmgr.LoadSpellBonusess();
530 SendGlobalSysMessage("DB table `spell_bonus_data` (spell damage/healing coefficients) reloaded.");
531 return true;
532 }
533
534 bool ChatHandler::HandleReloadSpellProcItemEnchantCommand(const char*)
535 {
536 sLog.outString( "Re-Loading Spell Proc Item Enchant..." );
537 spellmgr.LoadSpellProcItemEnchant();
538 SendGlobalSysMessage("DB table `spell_proc_item_enchant` (item enchantment ppm) reloaded.");
539 return true;
540 }
541
542 bool ChatHandler::HandleReloadSpellScriptTargetCommand(const char*)
543 {
544 sLog.outString( "Re-Loading SpellsScriptTarget..." );
545 spellmgr.LoadSpellScriptTarget();
546 SendGlobalSysMessage("DB table `spell_script_target` (spell targets selection in case specific creature/GO requirements) reloaded.");
547 return true;
548 }
549
550 bool ChatHandler::HandleReloadSpellTargetPositionCommand(const char*)
551 {
552 sLog.outString( "Re-Loading Spell target coordinates..." );
553 spellmgr.LoadSpellTargetPositions();
554 SendGlobalSysMessage("DB table `spell_target_position` (destination coordinates for spell targets) reloaded.");
555 return true;
556 }
557
558 bool ChatHandler::HandleReloadSpellThreatsCommand(const char*)
559 {
560 sLog.outString( "Re-Loading Aggro Spells Definitions...");
561 spellmgr.LoadSpellThreats();
562 SendGlobalSysMessage("DB table `spell_threat` (spell aggro definitions) reloaded.");
563 return true;
564 }
565
566 bool ChatHandler::HandleReloadSpellPetAurasCommand(const char*)
567 {
568 sLog.outString( "Re-Loading Spell pet auras...");
569 spellmgr.LoadSpellPetAuras();
570 SendGlobalSysMessage("DB table `spell_pet_auras` reloaded.");
571 return true;
572 }
573
574 bool ChatHandler::HandleReloadPageTextsCommand(const char*)
575 {
576 sLog.outString( "Re-Loading Page Texts..." );
577 objmgr.LoadPageTexts();
578 SendGlobalSysMessage("DB table `page_texts` reloaded.");
579 return true;
580 }
581
582 bool ChatHandler::HandleReloadItemEnchantementsCommand(const char*)
583 {
584 sLog.outString( "Re-Loading Item Random Enchantments Table..." );
585 LoadRandomEnchantmentsTable();
586 SendGlobalSysMessage("DB table `item_enchantment_template` reloaded.");
587 return true;
588 }
589
590 bool ChatHandler::HandleReloadItemRequiredTragetCommand(const char*)
591 {
592 sLog.outString( "Re-Loading Item Required Targets Table..." );
593 objmgr.LoadItemRequiredTarget();
594 SendGlobalSysMessage("DB table `item_required_target` reloaded.");
595 return true;
596 }
597
598 bool ChatHandler::HandleReloadBattleEventCommand(const char*)
599 {
600 sLog.outString( "Re-Loading BattleGround Eventindexes..." );
601 sBattleGroundMgr.LoadBattleEventIndexes();
602 SendGlobalSysMessage("DB table `gameobject_battleground` and `creature_battleground` reloaded.");
603 return true;
604 }
605
606 bool ChatHandler::HandleReloadGameObjectScriptsCommand(const char* arg)
607 {
608 if(sWorld.IsScriptScheduled())
609 {
610 SendSysMessage("DB scripts used currently, please attempt reload later.");
611 SetSentErrorMessage(true);
612 return false;
613 }
614
615 if(*arg!='a')
616 sLog.outString( "Re-Loading Scripts from `gameobject_scripts`...");
617
618 objmgr.LoadGameObjectScripts();
619
620 if(*arg!='a')
621 SendGlobalSysMessage("DB table `gameobject_scripts` reloaded.");
622
623 return true;
624 }
625
626 bool ChatHandler::HandleReloadEventScriptsCommand(const char* arg)
627 {
628 if(sWorld.IsScriptScheduled())
629 {
630 SendSysMessage("DB scripts used currently, please attempt reload later.");
631 SetSentErrorMessage(true);
632 return false;
633 }
634
635 if(*arg!='a')
636 sLog.outString( "Re-Loading Scripts from `event_scripts`...");
637
638 objmgr.LoadEventScripts();
639
640 if(*arg!='a')
641 SendGlobalSysMessage("DB table `event_scripts` reloaded.");
642
643 return true;
644 }
645
646 bool ChatHandler::HandleReloadEventAITextsCommand(const char* arg)
647 {
648
649 sLog.outString( "Re-Loading Texts from `creature_ai_texts`...");
650 CreatureEAI_Mgr.LoadCreatureEventAI_Texts();
651 SendGlobalSysMessage("DB table `creature_ai_texts` reloaded.");
652 return true;
653 }
654
655 bool ChatHandler::HandleReloadEventAISummonsCommand(const char* arg)
656 {
657 sLog.outString( "Re-Loading Summons from `creature_ai_summons`...");
658 CreatureEAI_Mgr.LoadCreatureEventAI_Summons();
659 SendGlobalSysMessage("DB table `creature_ai_summons` reloaded.");
660 return true;
661 }
662
663 bool ChatHandler::HandleReloadEventAIScriptsCommand(const char* arg)
664 {
665 sLog.outString( "Re-Loading Scripts from `creature_ai_scripts`...");
666 CreatureEAI_Mgr.LoadCreatureEventAI_Scripts();
667 SendGlobalSysMessage("DB table `creature_ai_scripts` reloaded.");
668 return true;
669 }
670
671 bool ChatHandler::HandleReloadQuestEndScriptsCommand(const char* arg)
672 {
673 if(sWorld.IsScriptScheduled())
674 {
675 SendSysMessage("DB scripts used currently, please attempt reload later.");
676 SetSentErrorMessage(true);
677 return false;
678 }
679
680 if(*arg!='a')
681 sLog.outString( "Re-Loading Scripts from `quest_end_scripts`...");
682
683 objmgr.LoadQuestEndScripts();
684
685 if(*arg!='a')
686 SendGlobalSysMessage("DB table `quest_end_scripts` reloaded.");
687
688 return true;
689 }
690
691 bool ChatHandler::HandleReloadQuestStartScriptsCommand(const char* arg)
692 {
693 if(sWorld.IsScriptScheduled())
694 {
695 SendSysMessage("DB scripts used currently, please attempt reload later.");
696 SetSentErrorMessage(true);
697 return false;
698 }
699
700 if(*arg!='a')
701 sLog.outString( "Re-Loading Scripts from `quest_start_scripts`...");
702
703 objmgr.LoadQuestStartScripts();
704
705 if(*arg!='a')
706 SendGlobalSysMessage("DB table `quest_start_scripts` reloaded.");
707
708 return true;
709 }
710
711 bool ChatHandler::HandleReloadSpellScriptsCommand(const char* arg)
712 {
713 if(sWorld.IsScriptScheduled())
714 {
715 SendSysMessage("DB scripts used currently, please attempt reload later.");
716 SetSentErrorMessage(true);
717 return false;
718 }
719
720 if(*arg!='a')
721 sLog.outString( "Re-Loading Scripts from `spell_scripts`...");
722
723 objmgr.LoadSpellScripts();
724
725 if(*arg!='a')
726 SendGlobalSysMessage("DB table `spell_scripts` reloaded.");
727
728 return true;
729 }
730
731 bool ChatHandler::HandleReloadDbScriptStringCommand(const char* /*arg*/)
732 {
733 sLog.outString( "Re-Loading Script strings from `db_script_string`...");
734 objmgr.LoadDbScriptStrings();
735 SendGlobalSysMessage("DB table `db_script_string` reloaded.");
736 return true;
737 }
738
739 bool ChatHandler::HandleReloadGameGraveyardZoneCommand(const char* /*arg*/)
740 {
741 sLog.outString( "Re-Loading Graveyard-zone links...");
742
743 objmgr.LoadGraveyardZones();
744
745 SendGlobalSysMessage("DB table `game_graveyard_zone` reloaded.");
746
747 return true;
748 }
749
750 bool ChatHandler::HandleReloadGameTeleCommand(const char* /*arg*/)
751 {
752 sLog.outString( "Re-Loading Game Tele coordinates...");
753
754 objmgr.LoadGameTele();
755
756 SendGlobalSysMessage("DB table `game_tele` reloaded.");
757
758 return true;
759 }
760
761 bool ChatHandler::HandleReloadLocalesAchievementRewardCommand(const char*)
762 {
763 sLog.outString( "Re-Loading Locales Achievement Reward Data..." );
764 achievementmgr.LoadRewardLocales();
765 SendGlobalSysMessage("DB table `locales_achievement_reward` reloaded.");
766 return true;
767 }
768
769 bool ChatHandler::HandleReloadLocalesCreatureCommand(const char* /*arg*/)
770 {
771 sLog.outString( "Re-Loading Locales Creature ...");
772 objmgr.LoadCreatureLocales();
773 SendGlobalSysMessage("DB table `locales_creature` reloaded.");
774 return true;
775 }
776
777 bool ChatHandler::HandleReloadLocalesGameobjectCommand(const char* /*arg*/)
778 {
779 sLog.outString( "Re-Loading Locales Gameobject ... ");
780 objmgr.LoadGameObjectLocales();
781 SendGlobalSysMessage("DB table `locales_gameobject` reloaded.");
782 return true;
783 }
784
785 bool ChatHandler::HandleReloadLocalesItemCommand(const char* /*arg*/)
786 {
787 sLog.outString( "Re-Loading Locales Item ... ");
788 objmgr.LoadItemLocales();
789 SendGlobalSysMessage("DB table `locales_item` reloaded.");
790 return true;
791 }
792
793 bool ChatHandler::HandleReloadLocalesNpcTextCommand(const char* /*arg*/)
794 {
795 sLog.outString( "Re-Loading Locales NPC Text ... ");
796 objmgr.LoadNpcTextLocales();
797 SendGlobalSysMessage("DB table `locales_npc_text` reloaded.");
798 return true;
799 }
800
801 bool ChatHandler::HandleReloadLocalesPageTextCommand(const char* /*arg*/)
802 {
803 sLog.outString( "Re-Loading Locales Page Text ... ");
804 objmgr.LoadPageTextLocales();
805 SendGlobalSysMessage("DB table `locales_page_text` reloaded.");
806 return true;
807 }
808
809 bool ChatHandler::HandleReloadLocalesPointsOfInterestCommand(const char* /*arg*/)
810 {
811 sLog.outString( "Re-Loading Locales Points Of Interest ... ");
812 objmgr.LoadPointOfInterestLocales();
813 SendGlobalSysMessage("DB table `locales_points_of_interest` reloaded.");
814 return true;
815 }
816
817 bool ChatHandler::HandleReloadLocalesQuestCommand(const char* /*arg*/)
818 {
819 sLog.outString( "Re-Loading Locales Quest ... ");
820 objmgr.LoadQuestLocales();
821 SendGlobalSysMessage("DB table `locales_quest` reloaded.");
822 return true;
823 }
824
825 bool ChatHandler::HandleLoadScriptsCommand(const char* args)
826 {
827 if(!LoadScriptingModule(args)) return true;
828
829 sWorld.SendWorldText(LANG_SCRIPTS_RELOADED);
830 return true;
831 }
832
833 bool ChatHandler::HandleAccountSetGmLevelCommand(const char* args)
834 {
835 char* arg1 = strtok((char*)args, " ");
836 if( !arg1 )
837 return false;
838
839 /// must be NULL if targeted syntax and must be not nULL if not targeted
840 char* arg2 = strtok(NULL, " ");
841
842 std::string targetAccountName;
843 uint32 targetAccountId = 0;
844
845 /// only target player different from self allowed (if targetPlayer!=NULL then not console)
846 Player* targetPlayer = getSelectedPlayer();
847 if(targetPlayer && m_session->GetPlayer()!=targetPlayer)
848 {
849 /// wrong command syntax or unexpected targeting
850 if(arg2)
851 return false;
852
853 /// security level expected in arg2 after this if.
854 arg2 = arg1;
855
856 targetAccountId = targetPlayer->GetSession()->GetAccountId();
857 accmgr.GetName(targetAccountId, targetAccountName);
858 }
859 else
860 {
861 /// wrong command syntax (second arg expected)
862 if(!arg2)
863 return false;
864
865 targetAccountName = arg1;
866 if (!AccountMgr::normalizeString(targetAccountName))
867 {
868 PSendSysMessage(LANG_ACCOUNT_NOT_EXIST,targetAccountName.c_str());
869 SetSentErrorMessage(true);
870 return false;
871 }
872
873 targetAccountId = accmgr.GetId(targetAccountName);
874 if(!targetAccountId)
875 {
876 PSendSysMessage(LANG_ACCOUNT_NOT_EXIST,targetAccountName.c_str());
877 SetSentErrorMessage(true);
878 return false;
879 }
880 }
881
882 int32 gm = (int32)atoi(arg2);
883 if ( gm < SEC_PLAYER || gm > SEC_ADMINISTRATOR )
884 {
885 SendSysMessage(LANG_BAD_VALUE);
886 SetSentErrorMessage(true);
887 return false;
888 }
889
890 /// can set security level only for target with less security and to less security that we have
891 /// This will reject self apply by specify account name
892 if(HasLowerSecurityAccount(NULL,targetAccountId,true))
893 return false;
894
895 /// account can't set security to same or grater level, need more power GM or console
896 AccountTypes plSecurity = m_session ? m_session->GetSecurity() : SEC_CONSOLE;
897 if (AccountTypes(gm) >= plSecurity )
898 {
899 SendSysMessage(LANG_YOURS_SECURITY_IS_LOW);
900 SetSentErrorMessage(true);
901 return false;
902 }
903
904 // This will prevent self apply by self target or no target
905 if(targetPlayer && m_session->GetPlayer()!=targetPlayer)
906 {
907 ChatHandler(targetPlayer).PSendSysMessage(LANG_YOURS_SECURITY_CHANGED,GetNameLink().c_str(), gm);
908 targetPlayer->GetSession()->SetSecurity(AccountTypes(gm));
909 }
910
911 PSendSysMessage(LANG_YOU_CHANGE_SECURITY, targetAccountName.c_str(), gm);
912 loginDatabase.PExecute("UPDATE account SET gmlevel = '%i' WHERE id = '%u'", gm, targetAccountId);
913
914 return true;
915 }
916
917 /// Set password for account
918 bool ChatHandler::HandleAccountSetPasswordCommand(const char* args)
919 {
920 if(!*args)
921 return false;
922
923 ///- Get the command line arguments
924 char *szAccount = strtok ((char*)args," ");
925 char *szPassword1 = strtok (NULL," ");
926 char *szPassword2 = strtok (NULL," ");
927
928 if (!szAccount||!szPassword1 || !szPassword2)
929 return false;
930
931 std::string account_name = szAccount;
932 if (!AccountMgr::normalizeString(account_name))
933 {
934 PSendSysMessage(LANG_ACCOUNT_NOT_EXIST,account_name.c_str());
935 SetSentErrorMessage(true);
936 return false;
937 }
938
939 uint32 targetAccountId = accmgr.GetId(account_name);
940 if (!targetAccountId)
941 {
942 PSendSysMessage(LANG_ACCOUNT_NOT_EXIST,account_name.c_str());
943 SetSentErrorMessage(true);
944 return false;
945 }
946
947 /// can set password only for target with less security
948 /// This is also reject self apply in fact
949 if(HasLowerSecurityAccount (NULL,targetAccountId,true))
950 return false;
951
952 if (strcmp(szPassword1,szPassword2))
953 {
954 SendSysMessage (LANG_NEW_PASSWORDS_NOT_MATCH);
955 SetSentErrorMessage (true);
956 return false;
957 }
958
959 AccountOpResult result = accmgr.ChangePassword(targetAccountId, szPassword1);
960
961 switch(result)
962 {
963 case AOR_OK:
964 SendSysMessage(LANG_COMMAND_PASSWORD);
965 break;
966 case AOR_NAME_NOT_EXIST:
967 PSendSysMessage(LANG_ACCOUNT_NOT_EXIST,account_name.c_str());
968 SetSentErrorMessage(true);
969 return false;
970 case AOR_PASS_TOO_LONG:
971 SendSysMessage(LANG_PASSWORD_TOO_LONG);
972 SetSentErrorMessage(true);
973 return false;
974 default:
975 SendSysMessage(LANG_COMMAND_NOTCHANGEPASSWORD);
976 SetSentErrorMessage(true);
977 return false;
978 }
979
980 return true;
981 }
982
983 bool ChatHandler::HandleMaxSkillCommand(const char* /*args*/)
984 {
985 Player* SelectedPlayer = getSelectedPlayer();
986 if(!SelectedPlayer)
987 {
988 SendSysMessage(LANG_NO_CHAR_SELECTED);
989 SetSentErrorMessage(true);
990 return false;
991 }
992
993 // each skills that have max skill value dependent from level seted to current level max skill value
994 SelectedPlayer->UpdateSkillsToMaxSkillsForLevel();
995 return true;
996 }
997
998 bool ChatHandler::HandleSetSkillCommand(const char* args)
999 {
1000 // number or [name] Shift-click form |color|Hskill:skill_id|h[name]|h|r
1001 char* skill_p = extractKeyFromLink((char*)args,"Hskill");
1002 if(!skill_p)
1003 return false;
1004
1005 char *level_p = strtok (NULL, " ");
1006
1007 if( !level_p)
1008 return false;
1009
1010 char *max_p = strtok (NULL, " ");
1011
1012 int32 skill = atoi(skill_p);
1013 if (skill <= 0)
1014 {
1015 PSendSysMessage(LANG_INVALID_SKILL_ID, skill);
1016 SetSentErrorMessage(true);
1017 return false;
1018 }
1019
1020 int32 level = atol (level_p);
1021
1022 Player * target = getSelectedPlayer();
1023 if(!target)
1024 {
1025 SendSysMessage(LANG_NO_CHAR_SELECTED);
1026 SetSentErrorMessage(true);
1027 return false;
1028 }
1029
1030 SkillLineEntry const* sl = sSkillLineStore.LookupEntry(skill);
1031 if(!sl)
1032 {
1033 PSendSysMessage(LANG_INVALID_SKILL_ID, skill);
1034 SetSentErrorMessage(true);
1035 return false;
1036 }
1037
1038 std::string tNameLink = GetNameLink(target);
1039
1040 if(!target->GetSkillValue(skill))
1041 {
1042 PSendSysMessage(LANG_SET_SKILL_ERROR, tNameLink.c_str(), skill, sl->name[0]);
1043 SetSentErrorMessage(true);
1044 return false;
1045 }
1046
1047 int32 max = max_p ? atol (max_p) : target->GetPureMaxSkillValue(skill);
1048
1049 if( level <= 0 || level > max || max <= 0 )
1050 return false;
1051
1052 target->SetSkill(skill, level, max);
1053 PSendSysMessage(LANG_SET_SKILL, skill, sl->name[0], tNameLink.c_str(), level, max);
1054
1055 return true;
1056 }
1057
1058 bool ChatHandler::HandleUnLearnCommand(const char* args)
1059 {
1060 if (!*args)
1061 return false;
1062
1063 // number or [name] Shift-click form |color|Hspell:spell_id|h[name]|h|r
1064 uint32 spell_id = extractSpellIdFromLink((char*)args);
1065 if(!spell_id)
1066 return false;
1067
1068 char const* allStr = strtok(NULL," ");
1069 bool allRanks = allStr ? (strncmp(allStr, "all", strlen(allStr)) == 0) : false;
1070
1071 Player* target = getSelectedPlayer();
1072 if(!target)
1073 {
1074 SendSysMessage(LANG_NO_CHAR_SELECTED);
1075 SetSentErrorMessage(true);
1076 return false;
1077 }
1078
1079 if(allRanks)
1080 spell_id = spellmgr.GetFirstSpellInChain (spell_id);
1081
1082 if (target->HasSpell(spell_id))
1083 target->removeSpell(spell_id,false,!allRanks);
1084 else
1085 SendSysMessage(LANG_FORGET_SPELL);
1086
1087 if(GetTalentSpellCost(spell_id))
1088 target->SendTalentsInfoData(false);
1089
1090 return true;
1091 }
1092
1093 bool ChatHandler::HandleCooldownCommand(const char* args)
1094 {
1095 Player* target = getSelectedPlayer();
1096 if(!target)
1097 {
1098 SendSysMessage(LANG_PLAYER_NOT_FOUND);
1099 SetSentErrorMessage(true);
1100 return false;
1101 }
1102
1103 std::string tNameLink = GetNameLink(target);
1104
1105 if (!*args)
1106 {
1107 target->RemoveAllSpellCooldown();
1108 PSendSysMessage(LANG_REMOVEALL_COOLDOWN, tNameLink.c_str());
1109 }
1110 else
1111 {
1112 // number or [name] Shift-click form |color|Hspell:spell_id|h[name]|h|r or Htalent form
1113 uint32 spell_id = extractSpellIdFromLink((char*)args);
1114 if(!spell_id)
1115 return false;
1116
1117 if(!sSpellStore.LookupEntry(spell_id))
1118 {
1119 PSendSysMessage(LANG_UNKNOWN_SPELL, target==m_session->GetPlayer() ? GetMangosString(LANG_YOU) : tNameLink.c_str());
1120 SetSentErrorMessage(true);
1121 return false;
1122 }
1123
1124 target->RemoveSpellCooldown(spell_id,true);
1125 PSendSysMessage(LANG_REMOVE_COOLDOWN, spell_id, target==m_session->GetPlayer() ? GetMangosString(LANG_YOU) : tNameLink.c_str());
1126 }
1127 return true;
1128 }
1129
1130 bool ChatHandler::HandleLearnAllCommand(const char* /*args*/)
1131 {
1132 static const char *allSpellList[] =
1133 {
1134 "3365",
1135 "6233",
1136 "6247",
1137 "6246",
1138 "6477",
1139 "6478",
1140 "22810",
1141 "8386",
1142 "21651",
1143 "21652",
1144 "522",
1145 "7266",
1146 "8597",
1147 "2479",
1148 "22027",
1149 "6603",
1150 "5019",
1151 "133",
1152 "168",
1153 "227",
1154 "5009",
1155 "9078",
1156 "668",
1157 "203",
1158 "20599",
1159 "20600",
1160 "81",
1161 "20597",
1162 "20598",
1163 "20864",
1164 "1459",
1165 "5504",
1166 "587",
1167 "5143",
1168 "118",
1169 "5505",
1170 "597",
1171 "604",
1172 "1449",
1173 "1460",
1174 "2855",
1175 "1008",
1176 "475",
1177 "5506",
1178 "1463",
1179 "12824",
1180 "8437",
1181 "990",
1182 "5145",
1183 "8450",
1184 "1461",
1185 "759",
1186 "8494",
1187 "8455",
1188 "8438",
1189 "6127",
1190 "8416",
1191 "6129",
1192 "8451",
1193 "8495",
1194 "8439",
1195 "3552",
1196 "8417",
1197 "10138",
1198 "12825",
1199 "10169",
1200 "10156",
1201 "10144",
1202 "10191",
1203 "10201",
1204 "10211",
1205 "10053",
1206 "10173",
1207 "10139",
1208 "10145",
1209 "10192",
1210 "10170",
1211 "10202",
1212 "10054",
1213 "10174",
1214 "10193",
1215 "12826",
1216 "2136",
1217 "143",
1218 "145",
1219 "2137",
1220 "2120",
1221 "3140",
1222 "543",
1223 "2138",
1224 "2948",
1225 "8400",
1226 "2121",
1227 "8444",
1228 "8412",
1229 "8457",
1230 "8401",
1231 "8422",
1232 "8445",
1233 "8402",
1234 "8413",
1235 "8458",
1236 "8423",
1237 "8446",
1238 "10148",
1239 "10197",
1240 "10205",
1241 "10149",
1242 "10215",
1243 "10223",
1244 "10206",
1245 "10199",
1246 "10150",
1247 "10216",
1248 "10207",
1249 "10225",
1250 "10151",
1251 "116",
1252 "205",
1253 "7300",
1254 "122",
1255 "837",
1256 "10",
1257 "7301",
1258 "7322",
1259 "6143",
1260 "120",
1261 "865",
1262 "8406",
1263 "6141",
1264 "7302",
1265 "8461",
1266 "8407",
1267 "8492",
1268 "8427",
1269 "8408",
1270 "6131",
1271 "7320",
1272 "10159",
1273 "8462",
1274 "10185",
1275 "10179",
1276 "10160",
1277 "10180",
1278 "10219",
1279 "10186",
1280 "10177",
1281 "10230",
1282 "10181",
1283 "10161",
1284 "10187",
1285 "10220",
1286 "2018",
1287 "2663",
1288 "12260",
1289 "2660",
1290 "3115",
1291 "3326",
1292 "2665",
1293 "3116",
1294 "2738",
1295 "3293",
1296 "2661",
1297 "3319",
1298 "2662",
1299 "9983",
1300 "8880",
1301 "2737",
1302 "2739",
1303 "7408",
1304 "3320",
1305 "2666",
1306 "3323",
1307 "3324",
1308 "3294",
1309 "22723",
1310 "23219",
1311 "23220",
1312 "23221",
1313 "23228",
1314 "23338",
1315 "10788",
1316 "10790",
1317 "5611",
1318 "5016",
1319 "5609",
1320 "2060",
1321 "10963",
1322 "10964",
1323 "10965",
1324 "22593",
1325 "22594",
1326 "596",
1327 "996",
1328 "499",
1329 "768",
1330 "17002",
1331 "1448",
1332 "1082",
1333 "16979",
1334 "1079",
1335 "5215",
1336 "20484",
1337 "5221",
1338 "15590",
1339 "17007",
1340 "6795",
1341 "6807",
1342 "5487",
1343 "1446",
1344 "1066",
1345 "5421",
1346 "3139",
1347 "779",
1348 "6811",
1349 "6808",
1350 "1445",
1351 "5216",
1352 "1737",
1353 "5222",
1354 "5217",
1355 "1432",
1356 "6812",
1357 "9492",
1358 "5210",
1359 "3030",
1360 "1441",
1361 "783",
1362 "6801",
1363 "20739",
1364 "8944",
1365 "9491",
1366 "22569",
1367 "5226",
1368 "6786",
1369 "1433",
1370 "8973",
1371 "1828",
1372 "9495",
1373 "9006",
1374 "6794",
1375 "8993",
1376 "5203",
1377 "16914",
1378 "6784",
1379 "9635",
1380 "22830",
1381 "20722",
1382 "9748",
1383 "6790",
1384 "9753",
1385 "9493",
1386 "9752",
1387 "9831",
1388 "9825",
1389 "9822",
1390 "5204",
1391 "5401",
1392 "22831",
1393 "6793",
1394 "9845",
1395 "17401",
1396 "9882",
1397 "9868",
1398 "20749",
1399 "9893",
1400 "9899",
1401 "9895",
1402 "9832",
1403 "9902",
1404 "9909",
1405 "22832",
1406 "9828",
1407 "9851",
1408 "9883",
1409 "9869",
1410 "17406",
1411 "17402",
1412 "9914",
1413 "20750",
1414 "9897",
1415 "9848",
1416 "3127",
1417 "107",
1418 "204",
1419 "9116",
1420 "2457",
1421 "78",
1422 "18848",
1423 "331",
1424 "403",
1425 "2098",
1426 "1752",
1427 "11278",
1428 "11288",
1429 "11284",
1430 "6461",
1431 "2344",
1432 "2345",
1433 "6463",
1434 "2346",
1435 "2352",
1436 "775",
1437 "1434",
1438 "1612",
1439 "71",
1440 "2468",
1441 "2458",
1442 "2467",
1443 "7164",
1444 "7178",
1445 "7367",
1446 "7376",
1447 "7381",
1448 "21156",
1449 "5209",
1450 "3029",
1451 "5201",
1452 "9849",
1453 "9850",
1454 "20719",
1455 "22568",
1456 "22827",
1457 "22828",
1458 "22829",
1459 "6809",
1460 "8972",
1461 "9005",
1462 "9823",
1463 "9827",
1464 "6783",
1465 "9913",
1466 "6785",
1467 "6787",
1468 "9866",
1469 "9867",
1470 "9894",
1471 "9896",
1472 "6800",
1473 "8992",
1474 "9829",
1475 "9830",
1476 "780",
1477 "769",
1478 "6749",
1479 "6750",
1480 "9755",
1481 "9754",
1482 "9908",
1483 "20745",
1484 "20742",
1485 "20747",
1486 "20748",
1487 "9746",
1488 "9745",
1489 "9880",
1490 "9881",
1491 "5391",
1492 "842",
1493 "3025",
1494 "3031",
1495 "3287",
1496 "3329",
1497 "1945",
1498 "3559",
1499 "4933",
1500 "4934",
1501 "4935",
1502 "4936",
1503 "5142",
1504 "5390",
1505 "5392",
1506 "5404",
1507 "5420",
1508 "6405",
1509 "7293",
1510 "7965",
1511 "8041",
1512 "8153",
1513 "9033",
1514 "9034",
1515 //"9036", problems with ghost state
1516 "16421",
1517 "21653",
1518 "22660",
1519 "5225",
1520 "9846",
1521 "2426",
1522 "5916",
1523 "6634",
1524 //"6718", phasing stealth, annoying for learn all case.
1525 "6719",
1526 "8822",
1527 "9591",
1528 "9590",
1529 "10032",
1530 "17746",
1531 "17747",
1532 "8203",
1533 "11392",
1534 "12495",
1535 "16380",
1536 "23452",
1537 "4079",
1538 "4996",
1539 "4997",
1540 "4998",
1541 "4999",
1542 "5000",
1543 "6348",
1544 "6349",
1545 "6481",
1546 "6482",
1547 "6483",
1548 "6484",
1549 "11362",
1550 "11410",
1551 "11409",
1552 "12510",
1553 "12509",
1554 "12885",
1555 "13142",
1556 "21463",
1557 "23460",
1558 "11421",
1559 "11416",
1560 "11418",
1561 "1851",
1562 "10059",
1563 "11423",
1564 "11417",
1565 "11422",
1566 "11419",
1567 "11424",
1568 "11420",
1569 "27",
1570 "31",
1571 "33",
1572 "34",
1573 "35",
1574 "15125",
1575 "21127",
1576 "22950",
1577 "1180",
1578 "201",
1579 "12593",
1580 "12842",
1581 "16770",
1582 "6057",
1583 "12051",
1584 "18468",
1585 "12606",
1586 "12605",
1587 "18466",
1588 "12502",
1589 "12043",
1590 "15060",
1591 "12042",
1592 "12341",
1593 "12848",
1594 "12344",
1595 "12353",
1596 "18460",
1597 "11366",
1598 "12350",
1599 "12352",
1600 "13043",
1601 "11368",
1602 "11113",
1603 "12400",
1604 "11129",
1605 "16766",
1606 "12573",
1607 "15053",
1608 "12580",
1609 "12475",
1610 "12472",
1611 "12953",
1612 "12488",
1613 "11189",
1614 "12985",
1615 "12519",
1616 "16758",
1617 "11958",
1618 "12490",
1619 "11426",
1620 "3565",
1621 "3562",
1622 "18960",
1623 "3567",
1624 "3561",
1625 "3566",
1626 "3563",
1627 "1953",
1628 "2139",
1629 "12505",
1630 "13018",
1631 "12522",
1632 "12523",
1633 "5146",
1634 "5144",
1635 "5148",
1636 "8419",
1637 "8418",
1638 "10213",
1639 "10212",
1640 "10157",
1641 "12524",
1642 "13019",
1643 "12525",
1644 "13020",
1645 "12526",
1646 "13021",
1647 "18809",
1648 "13031",
1649 "13032",
1650 "13033",
1651 "4036",
1652 "3920",
1653 "3919",
1654 "3918",
1655 "7430",
1656 "3922",
1657 "3923",
1658 "7411",
1659 "7418",
1660 "7421",
1661 "13262",
1662 "7412",
1663 "7415",
1664 "7413",
1665 "7416",
1666 "13920",
1667 "13921",
1668 "7745",
1669 "7779",
1670 "7428",
1671 "7457",
1672 "7857",
1673 "7748",
1674 "7426",
1675 "13421",
1676 "7454",
1677 "13378",
1678 "7788",
1679 "14807",
1680 "14293",
1681 "7795",
1682 "6296",
1683 "20608",
1684 "755",
1685 "444",
1686 "427",
1687 "428",
1688 "442",
1689 "447",
1690 "3578",
1691 "3581",
1692 "19027",
1693 "3580",
1694 "665",
1695 "3579",
1696 "3577",
1697 "6755",
1698 "3576",
1699 "2575",
1700 "2577",
1701 "2578",
1702 "2579",
1703 "2580",
1704 "2656",
1705 "2657",
1706 "2576",
1707 "3564",
1708 "10248",
1709 "8388",
1710 "2659",
1711 "14891",
1712 "3308",
1713 "3307",
1714 "10097",
1715 "2658",
1716 "3569",
1717 "16153",
1718 "3304",
1719 "10098",
1720 "4037",
1721 "3929",
1722 "3931",
1723 "3926",
1724 "3924",
1725 "3930",
1726 "3977",
1727 "3925",
1728 "136",
1729 "228",
1730 "5487",
1731 "43",
1732 "202",
1733 "0"
1734 };
1735
1736 int loop = 0;
1737 while(strcmp(allSpellList[loop], "0"))
1738 {
1739 uint32 spell = atol((char*)allSpellList[loop++]);
1740
1741 if (m_session->GetPlayer()->HasSpell(spell))
1742 continue;
1743
1744 SpellEntry const* spellInfo = sSpellStore.LookupEntry(spell);
1745 if(!spellInfo || !SpellMgr::IsSpellValid(spellInfo,m_session->GetPlayer()))
1746 {
1747 PSendSysMessage(LANG_COMMAND_SPELL_BROKEN,spell);
1748 continue;
1749 }
1750
1751 m_session->GetPlayer()->learnSpell(spell,false);
1752 }
1753
1754 SendSysMessage(LANG_COMMAND_LEARN_MANY_SPELLS);
1755
1756 return true;
1757 }
1758
1759 bool ChatHandler::HandleLearnAllGMCommand(const char* /*args*/)
1760 {
1761 static const char *gmSpellList[] =
1762 {
1763 "24347", // Become A Fish, No Breath Bar
1764 "35132", // Visual Boom
1765 "38488", // Attack 4000-8000 AOE
1766 "38795", // Attack 2000 AOE + Slow Down 90%
1767 "15712", // Attack 200
1768 "1852", // GM Spell Silence
1769 "31899", // Kill
1770 "31924", // Kill
1771 "29878", // Kill My Self
1772 "26644", // More Kill
1773
1774 "28550", //Invisible 24
1775 "23452", //Invisible + Target
1776 "0"
1777 };
1778
1779 uint16 gmSpellIter = 0;
1780 while( strcmp(gmSpellList[gmSpellIter], "0") )
1781 {
1782 uint32 spell = atol((char*)gmSpellList[gmSpellIter++]);
1783
1784 SpellEntry const* spellInfo = sSpellStore.LookupEntry(spell);
1785 if(!spellInfo || !SpellMgr::IsSpellValid(spellInfo,m_session->GetPlayer()))
1786 {
1787 PSendSysMessage(LANG_COMMAND_SPELL_BROKEN,spell);
1788 continue;
1789 }
1790
1791 m_session->GetPlayer()->learnSpell(spell,false);
1792 }
1793
1794 SendSysMessage(LANG_LEARNING_GM_SKILLS);
1795 return true;
1796 }
1797
1798 bool ChatHandler::HandleLearnAllMyClassCommand(const char* /*args*/)
1799 {
1800 HandleLearnAllMySpellsCommand("");
1801 HandleLearnAllMyTalentsCommand("");
1802 return true;
1803 }
1804
1805 bool ChatHandler::HandleLearnAllMySpellsCommand(const char* /*args*/)
1806 {
1807 ChrClassesEntry const* clsEntry = sChrClassesStore.LookupEntry(m_session->GetPlayer()->getClass());
1808 if(!clsEntry)
1809 return true;
1810 uint32 family = clsEntry->spellfamily;
1811
1812 for (uint32 i = 0; i < sSpellStore.GetNumRows(); ++i)
1813 {
1814 SpellEntry const *spellInfo = sSpellStore.LookupEntry(i);
1815 if(!spellInfo)
1816 continue;
1817
1818 // skip server-side/triggered spells
1819 if(spellInfo->spellLevel==0)
1820 continue;
1821
1822 // skip wrong class/race skills
1823 if(!m_session->GetPlayer()->IsSpellFitByClassAndRace(spellInfo->Id))
1824 continue;
1825
1826 // skip other spell families
1827 if( spellInfo->SpellFamilyName != family)
1828 continue;
1829
1830 // skip spells with first rank learned as talent (and all talents then also)
1831 uint32 first_rank = spellmgr.GetFirstSpellInChain(spellInfo->Id);
1832 if(GetTalentSpellCost(first_rank) > 0 )
1833 continue;
1834
1835 // skip broken spells
1836 if(!SpellMgr::IsSpellValid(spellInfo,m_session->GetPlayer(),false))
1837 continue;
1838
1839 m_session->GetPlayer()->learnSpell(i,false);
1840 }
1841
1842 SendSysMessage(LANG_COMMAND_LEARN_CLASS_SPELLS);
1843 return true;
1844 }
1845
1846 bool ChatHandler::HandleLearnAllMyTalentsCommand(const char* /*args*/)
1847 {
1848 Player* player = m_session->GetPlayer();
1849 uint32 classMask = player->getClassMask();
1850
1851 for (uint32 i = 0; i < sTalentStore.GetNumRows(); ++i)
1852 {
1853 TalentEntry const *talentInfo = sTalentStore.LookupEntry(i);
1854 if(!talentInfo)
1855 continue;
1856
1857 TalentTabEntry const *talentTabInfo = sTalentTabStore.LookupEntry( talentInfo->TalentTab );
1858 if(!talentTabInfo)
1859 continue;
1860
1861 if( (classMask & talentTabInfo->ClassMask) == 0 )
1862 continue;
1863
1864 // search highest talent rank
1865 uint32 spellid = 0;
1866
1867 for(int rank = MAX_TALENT_RANK-1; rank >= 0; --rank)
1868 {
1869 if(talentInfo->RankID[rank]!=0)
1870 {
1871 spellid = talentInfo->RankID[rank];
1872 break;
1873 }
1874 }
1875
1876 if(!spellid) // ??? none spells in talent
1877 continue;
1878
1879 SpellEntry const* spellInfo = sSpellStore.LookupEntry(spellid);
1880 if(!spellInfo || !SpellMgr::IsSpellValid(spellInfo,m_session->GetPlayer(),false))
1881 continue;
1882
1883 // learn highest rank of talent and learn all non-talent spell ranks (recursive by tree)
1884 player->learnSpellHighRank(spellid);
1885 }
1886
1887 SendSysMessage(LANG_COMMAND_LEARN_CLASS_TALENTS);
1888 return true;
1889 }
1890
1891 bool ChatHandler::HandleLearnAllMyPetTalentsCommand(const char* /*args*/)
1892 {
1893 Player* player = m_session->GetPlayer();
1894
1895 Pet* pet = player->GetPet();
1896 if(!pet)
1897 {
1898 SendSysMessage(LANG_NO_PET_FOUND);
1899 SetSentErrorMessage(true);
1900 return false;
1901 }
1902
1903 CreatureInfo const *ci = pet->GetCreatureInfo();
1904 if(!ci)
1905 {
1906 SendSysMessage(LANG_WRONG_PET_TYPE);
1907 SetSentErrorMessage(true);
1908 return false;
1909 }
1910
1911 CreatureFamilyEntry const *pet_family = sCreatureFamilyStore.LookupEntry(ci->family);
1912 if(!pet_family)
1913 {
1914 SendSysMessage(LANG_WRONG_PET_TYPE);
1915 SetSentErrorMessage(true);
1916 return false;
1917 }
1918
1919 if(pet_family->petTalentType < 0) // not hunter pet
1920 {
1921 SendSysMessage(LANG_WRONG_PET_TYPE);
1922 SetSentErrorMessage(true);
1923 return false;
1924 }
1925
1926 for (uint32 i = 0; i < sTalentStore.GetNumRows(); ++i)
1927 {
1928 TalentEntry const *talentInfo = sTalentStore.LookupEntry(i);
1929 if(!talentInfo)
1930 continue;
1931
1932 TalentTabEntry const *talentTabInfo = sTalentTabStore.LookupEntry( talentInfo->TalentTab );
1933 if(!talentTabInfo)
1934 continue;
1935
1936 // prevent learn talent for different family (cheating)
1937 if(((1 << pet_family->petTalentType) & talentTabInfo->petTalentMask)==0)
1938 continue;
1939
1940 // search highest talent rank
1941 uint32 spellid = 0;
1942
1943 for(int rank = MAX_TALENT_RANK-1; rank >= 0; --rank)
1944 {
1945 if(talentInfo->RankID[rank]!=0)
1946 {
1947 spellid = talentInfo->RankID[rank];
1948 break;
1949 }
1950 }
1951
1952 if(!spellid) // ??? none spells in talent
1953 continue;
1954
1955 SpellEntry const* spellInfo = sSpellStore.LookupEntry(spellid);
1956 if(!spellInfo || !SpellMgr::IsSpellValid(spellInfo,m_session->GetPlayer(),false))
1957 continue;
1958
1959 // learn highest rank of talent and learn all non-talent spell ranks (recursive by tree)
1960 pet->learnSpellHighRank(spellid);
1961 }
1962
1963 SendSysMessage(LANG_COMMAND_LEARN_PET_TALENTS);
1964 return true;
1965 }
1966
1967 bool ChatHandler::HandleLearnAllLangCommand(const char* /*args*/)
1968 {
1969 // skipping UNIVERSAL language (0)
1970 for(int i = 1; i < LANGUAGES_COUNT; ++i)
1971 m_session->GetPlayer()->learnSpell(lang_description[i].spell_id,false);
1972
1973 SendSysMessage(LANG_COMMAND_LEARN_ALL_LANG);
1974 return true;
1975 }
1976
1977 bool ChatHandler::HandleLearnAllDefaultCommand(const char* args)
1978 {
1979 Player* target;
1980 if(!extractPlayerTarget((char*)args,&target))
1981 return false;
1982
1983 target->learnDefaultSpells();
1984 target->learnQuestRewardedSpells();
1985
1986 PSendSysMessage(LANG_COMMAND_LEARN_ALL_DEFAULT_AND_QUEST,GetNameLink(target).c_str());
1987 return true;
1988 }
1989
1990 bool ChatHandler::HandleLearnCommand(const char* args)
1991 {
1992 Player* targetPlayer = getSelectedPlayer();
1993
1994 if(!targetPlayer)
1995 {
1996 SendSysMessage(LANG_PLAYER_NOT_FOUND);
1997 SetSentErrorMessage(true);
1998 return false;
1999 }
2000
2001 // number or [name] Shift-click form |color|Hspell:spell_id|h[name]|h|r or Htalent form
2002 uint32 spell = extractSpellIdFromLink((char*)args);
2003 if(!spell || !sSpellStore.LookupEntry(spell))
2004 return false;
2005
2006 char const* allStr = strtok(NULL," ");
2007 bool allRanks = allStr ? (strncmp(allStr, "all", strlen(allStr)) == 0) : false;
2008
2009 SpellEntry const* spellInfo = sSpellStore.LookupEntry(spell);
2010 if(!spellInfo || !SpellMgr::IsSpellValid(spellInfo,m_session->GetPlayer()))
2011 {
2012 PSendSysMessage(LANG_COMMAND_SPELL_BROKEN,spell);
2013 SetSentErrorMessage(true);
2014 return false;
2015 }
2016
2017 if (!allRanks && targetPlayer->HasSpell(spell))
2018 {
2019 if(targetPlayer == m_session->GetPlayer())
2020 SendSysMessage(LANG_YOU_KNOWN_SPELL);
2021 else
2022 PSendSysMessage(LANG_TARGET_KNOWN_SPELL,GetNameLink(targetPlayer).c_str());
2023 SetSentErrorMessage(true);
2024 return false;
2025 }
2026
2027 if(allRanks)
2028 targetPlayer->learnSpellHighRank(spell);
2029 else
2030 targetPlayer->learnSpell(spell,false);
2031
2032 uint32 first_spell = spellmgr.GetFirstSpellInChain(spell);
2033 if(GetTalentSpellCost(first_spell))
2034 targetPlayer->SendTalentsInfoData(false);
2035
2036 return true;
2037 }
2038
2039 bool ChatHandler::HandleAddItemCommand(const char* args)
2040 {
2041 if (!*args)
2042 return false;
2043
2044 uint32 itemId = 0;
2045
2046 if(args[0]=='[') // [name] manual form
2047 {
2048 char* citemName = strtok((char*)args, "]");
2049
2050 if(citemName && citemName[0])
2051 {
2052 std::string itemName = citemName+1;
2053 WorldDatabase.escape_string(itemName);
2054 QueryResult *result = WorldDatabase.PQuery("SELECT entry FROM item_template WHERE name = '%s'", itemName.c_str());
2055 if (!result)
2056 {
2057 PSendSysMessage(LANG_COMMAND_COULDNOTFIND, citemName+1);
2058 SetSentErrorMessage(true);
2059 return false;
2060 }
2061 itemId = result->Fetch()->GetUInt16();
2062 delete result;
2063 }
2064 else
2065 return false;
2066 }
2067 else // item_id or [name] Shift-click form |color|Hitem:item_id:0:0:0|h[name]|h|r
2068 {
2069 char* cId = extractKeyFromLink((char*)args,"Hitem");
2070 if(!cId)
2071 return false;
2072 itemId = atol(cId);
2073 }
2074
2075 char* ccount = strtok(NULL, " ");
2076
2077 int32 count = 1;
2078
2079 if (ccount)
2080 count = strtol(ccount, NULL, 10);
2081
2082 if (count == 0)
2083 count = 1;
2084
2085 Player* pl = m_session->GetPlayer();
2086 Player* plTarget = getSelectedPlayer();
2087 if(!plTarget)
2088 plTarget = pl;
2089
2090 sLog.outDetail(GetMangosString(LANG_ADDITEM), itemId, count);
2091
2092 ItemPrototype const *pProto = objmgr.GetItemPrototype(itemId);
2093 if(!pProto)
2094 {
2095 PSendSysMessage(LANG_COMMAND_ITEMIDINVALID, itemId);
2096 SetSentErrorMessage(true);
2097 return false;
2098 }
2099
2100 //Subtract
2101 if (count < 0)
2102 {
2103 plTarget->DestroyItemCount(itemId, -count, true, false);
2104 PSendSysMessage(LANG_REMOVEITEM, itemId, -count, GetNameLink(plTarget).c_str());
2105 return true;
2106 }
2107
2108 //Adding items
2109 uint32 noSpaceForCount = 0;
2110
2111 // check space and find places
2112 ItemPosCountVec dest;
2113 uint8 msg = plTarget->CanStoreNewItem( NULL_BAG, NULL_SLOT, dest, itemId, count, &noSpaceForCount );
2114 if( msg != EQUIP_ERR_OK ) // convert to possible store amount
2115 count -= noSpaceForCount;
2116
2117 if( count == 0 || dest.empty()) // can't add any
2118 {
2119 PSendSysMessage(LANG_ITEM_CANNOT_CREATE, itemId, noSpaceForCount );
2120 SetSentErrorMessage(true);
2121 return false;
2122 }
2123
2124 Item* item = plTarget->StoreNewItem( dest, itemId, true, Item::GenerateItemRandomPropertyId(itemId));
2125
2126 // remove binding (let GM give it to another player later)
2127 if(pl==plTarget)
2128 for(ItemPosCountVec::const_iterator itr = dest.begin(); itr != dest.end(); ++itr)
2129 if(Item* item1 = pl->GetItemByPos(itr->pos))
2130 item1->SetBinding( false );
2131
2132 if(count > 0 && item)
2133 {
2134 pl->SendNewItem(item,count,false,true);
2135 if(pl!=plTarget)
2136 plTarget->SendNewItem(item,count,true,false);
2137 }
2138
2139 if(noSpaceForCount > 0)
2140 PSendSysMessage(LANG_ITEM_CANNOT_CREATE, itemId, noSpaceForCount);
2141
2142 return true;
2143 }
2144
2145 bool ChatHandler::HandleAddItemSetCommand(const char* args)
2146 {
2147 if (!*args)
2148 return false;
2149
2150 char* cId = extractKeyFromLink((char*)args,"Hitemset"); // number or [name] Shift-click form |color|Hitemset:itemset_id|h[name]|h|r
2151 if (!cId)
2152 return false;
2153
2154 uint32 itemsetId = atol(cId);
2155
2156 // prevent generation all items with itemset field value '0'
2157 if (itemsetId == 0)
2158 {
2159 PSendSysMessage(LANG_NO_ITEMS_FROM_ITEMSET_FOUND,itemsetId);
2160 SetSentErrorMessage(true);
2161 return false;
2162 }
2163
2164 Player* pl = m_session->GetPlayer();
2165 Player* plTarget = getSelectedPlayer();
2166 if(!plTarget)
2167 plTarget = pl;
2168
2169 sLog.outDetail(GetMangosString(LANG_ADDITEMSET), itemsetId);
2170
2171 bool found = false;
2172 for (uint32 id = 0; id < sItemStorage.MaxEntry; id++)
2173 {
2174 ItemPrototype const *pProto = sItemStorage.LookupEntry<ItemPrototype>(id);
2175 if (!pProto)
2176 continue;
2177
2178 if (pProto->ItemSet == itemsetId)
2179 {
2180 found = true;
2181 ItemPosCountVec dest;
2182 uint8 msg = plTarget->CanStoreNewItem( NULL_BAG, NULL_SLOT, dest, pProto->ItemId, 1 );
2183 if (msg == EQUIP_ERR_OK)
2184 {
2185 Item* item = plTarget->StoreNewItem( dest, pProto->ItemId, true);
2186
2187 // remove binding (let GM give it to another player later)
2188 if (pl==plTarget)
2189 item->SetBinding( false );
2190
2191 pl->SendNewItem(item,1,false,true);
2192 if (pl!=plTarget)
2193 plTarget->SendNewItem(item,1,true,false);
2194 }
2195 else
2196 {
2197 pl->SendEquipError( msg, NULL, NULL );
2198 PSendSysMessage(LANG_ITEM_CANNOT_CREATE, pProto->ItemId, 1);
2199 }
2200 }
2201 }
2202
2203 if (!found)
2204 {
2205 PSendSysMessage(LANG_NO_ITEMS_FROM_ITEMSET_FOUND,itemsetId);
2206
2207 SetSentErrorMessage(true);
2208 return false;
2209 }
2210
2211 return true;
2212 }
2213
2214 bool ChatHandler::HandleListItemCommand(const char* args)
2215 {
2216 if(!*args)
2217 return false;
2218
2219 char* cId = extractKeyFromLink((char*)args,"Hitem");
2220 if(!cId)
2221 return false;
2222
2223 uint32 item_id = atol(cId);
2224 if(!item_id)
2225 {
2226 PSendSysMessage(LANG_COMMAND_ITEMIDINVALID, item_id);
2227 SetSentErrorMessage(true);
2228 return false;
2229 }
2230
2231 ItemPrototype const* itemProto = objmgr.GetItemPrototype(item_id);
2232 if(!itemProto)
2233 {
2234 PSendSysMessage(LANG_COMMAND_ITEMIDINVALID, item_id);
2235 SetSentErrorMessage(true);
2236 return false;
2237 }
2238
2239 char* c_count = strtok(NULL, " ");
2240 int count = c_count ? atol(c_count) : 10;
2241
2242 if(count < 0)
2243 return false;
2244
2245 QueryResult *result;
2246
2247 // inventory case
2248 uint32 inv_count = 0;
2249 result=CharacterDatabase.PQuery("SELECT COUNT(item_template) FROM character_inventory WHERE item_template='%u'",item_id);
2250 if(result)
2251 {
2252 inv_count = (*result)[0].GetUInt32();
2253 delete result;
2254 }
2255
2256 result=CharacterDatabase.PQuery(
2257 // 0 1 2 3 4 5
2258 "SELECT ci.item, cibag.slot AS bag, ci.slot, ci.guid, characters.account,characters.name "
2259 "FROM character_inventory AS ci LEFT JOIN character_inventory AS cibag ON (cibag.item=ci.bag),characters "
2260 "WHERE ci.item_template='%u' AND ci.guid = characters.guid LIMIT %u ",
2261 item_id,uint32(count));
2262
2263 if(result)
2264 {
2265 do
2266 {
2267 Field *fields = result->Fetch();
2268 uint32 item_guid = fields[0].GetUInt32();
2269 uint32 item_bag = fields[1].GetUInt32();
2270 uint32 item_slot = fields[2].GetUInt32();
2271 uint32 owner_guid = fields[3].GetUInt32();
2272 uint32 owner_acc = fields[4].GetUInt32();
2273 std::string owner_name = fields[5].GetCppString();
2274
2275 char const* item_pos = 0;
2276 if(Player::IsEquipmentPos(item_bag,item_slot))
2277 item_pos = "[equipped]";
2278 else if(Player::IsInventoryPos(item_bag,item_slot))
2279 item_pos = "[in inventory]";
2280 else if(Player::IsBankPos(item_bag,item_slot))
2281 item_pos = "[in bank]";
2282 else
2283 item_pos = "";
2284
2285 PSendSysMessage(LANG_ITEMLIST_SLOT,
2286 item_guid,owner_name.c_str(),owner_guid,owner_acc,item_pos);
2287 } while (result->NextRow());
2288
2289 int64 res_count = result->GetRowCount();
2290
2291 delete result;
2292
2293 if(count > res_count)
2294 count-=res_count;
2295 else if(count)
2296 count = 0;
2297 }
2298
2299 // mail case
2300 uint32 mail_count = 0;
2301 result=CharacterDatabase.PQuery("SELECT COUNT(item_template) FROM mail_items WHERE item_template='%u'", item_id);
2302 if(result)
2303 {
2304 mail_count = (*result)[0].GetUInt32();
2305 delete result;
2306 }
2307
2308 if(count > 0)
2309 {
2310 result=CharacterDatabase.PQuery(
2311 // 0 1 2 3 4 5 6
2312 "SELECT mail_items.item_guid, mail.sender, mail.receiver, char_s.account, char_s.name, char_r.account, char_r.name "
2313 "FROM mail,mail_items,characters as char_s,characters as char_r "
2314 "WHERE mail_items.item_template='%u' AND char_s.guid = mail.sender AND char_r.guid = mail.receiver AND mail.id=mail_items.mail_id LIMIT %u",
2315 item_id,uint32(count));
2316 }
2317 else
2318 result = NULL;
2319
2320 if(result)
2321 {
2322 do
2323 {
2324 Field *fields = result->Fetch();
2325 uint32 item_guid = fields[0].GetUInt32();
2326 uint32 item_s = fields[1].GetUInt32();
2327 uint32 item_r = fields[2].GetUInt32();
2328 uint32 item_s_acc = fields[3].GetUInt32();
2329 std::string item_s_name = fields[4].GetCppString();
2330 uint32 item_r_acc = fields[5].GetUInt32();
2331 std::string item_r_name = fields[6].GetCppString();
2332
2333 char const* item_pos = "[in mail]";
2334
2335 PSendSysMessage(LANG_ITEMLIST_MAIL,
2336 item_guid,item_s_name.c_str(),item_s,item_s_acc,item_r_name.c_str(),item_r,item_r_acc,item_pos);
2337 } while (result->NextRow());
2338
2339 int64 res_count = result->GetRowCount();
2340
2341 delete result;
2342
2343 if(count > res_count)
2344 count-=res_count;
2345 else if(count)
2346 count = 0;
2347 }
2348
2349 // auction case
2350 uint32 auc_count = 0;
2351 result=CharacterDatabase.PQuery("SELECT COUNT(item_template) FROM auctionhouse WHERE item_template='%u'",item_id);
2352 if(result)
2353 {
2354 auc_count = (*result)[0].GetUInt32();
2355 delete result;
2356 }
2357
2358 if(count > 0)
2359 {
2360 result=CharacterDatabase.PQuery(
2361 // 0 1 2 3
2362 "SELECT auctionhouse.itemguid, auctionhouse.itemowner, characters.account, characters.name "
2363 "FROM auctionhouse,characters WHERE auctionhouse.item_template='%u' AND characters.guid = auctionhouse.itemowner LIMIT %u",
2364 item_id,uint32(count));
2365 }
2366 else
2367 result = NULL;
2368
2369 if(result)
2370 {
2371 do
2372 {
2373 Field *fields = result->Fetch();
2374 uint32 item_guid = fields[0].GetUInt32();
2375 uint32 owner = fields[1].GetUInt32();
2376 uint32 owner_acc = fields[2].GetUInt32();
2377 std::string owner_name = fields[3].GetCppString();
2378
2379 char const* item_pos = "[in auction]";
2380
2381 PSendSysMessage(LANG_ITEMLIST_AUCTION, item_guid, owner_name.c_str(), owner, owner_acc,item_pos);
2382 } while (result->NextRow());
2383
2384 delete result;
2385 }
2386
2387 // guild bank case
2388 uint32 guild_count = 0;
2389 result=CharacterDatabase.PQuery("SELECT COUNT(item_entry) FROM guild_bank_item WHERE item_entry='%u'",item_id);
2390 if(result)
2391 {
2392 guild_count = (*result)[0].GetUInt32();
2393 delete result;
2394 }
2395
2396 result=CharacterDatabase.PQuery(
2397 // 0 1 2
2398 "SELECT gi.item_guid, gi.guildid, guild.name "
2399 "FROM guild_bank_item AS gi, guild WHERE gi.item_entry='%u' AND gi.guildid = guild.guildid LIMIT %u ",
2400 item_id,uint32(count));
2401
2402 if(result)
2403 {
2404 do
2405 {
2406 Field *fields = result->Fetch();
2407 uint32 item_guid = fields[0].GetUInt32();
2408 uint32 guild_guid = fields[1].GetUInt32();
2409 std::string guild_name = fields[2].GetCppString();
2410
2411 char const* item_pos = "[in guild bank]";
2412
2413 PSendSysMessage(LANG_ITEMLIST_GUILD,item_guid,guild_name.c_str(),guild_guid,item_pos);
2414 } while (result->NextRow());
2415
2416 int64 res_count = result->GetRowCount();
2417
2418 delete result;
2419
2420 if(count > res_count)
2421 count-=res_count;
2422 else if(count)
2423 count = 0;
2424 }
2425
2426 if(inv_count+mail_count+auc_count+guild_count == 0)
2427 {
2428 SendSysMessage(LANG_COMMAND_NOITEMFOUND);
2429 SetSentErrorMessage(true);
2430 return false;
2431 }
2432
2433 PSendSysMessage(LANG_COMMAND_LISTITEMMESSAGE,item_id,inv_count+mail_count+auc_count+guild_count,inv_count,mail_count,auc_count,guild_count);
2434
2435 return true;
2436 }
2437
2438 bool ChatHandler::HandleListObjectCommand(const char* args)
2439 {
2440 if(!*args)
2441 return false;
2442
2443 // number or [name] Shift-click form |color|Hgameobject_entry:go_id|h[name]|h|r
2444 char* cId = extractKeyFromLink((char*)args,"Hgameobject_entry");
2445 if(!cId)
2446 return false;
2447
2448 uint32 go_id = atol(cId);
2449 if(!go_id)
2450 {
2451 PSendSysMessage(LANG_COMMAND_LISTOBJINVALIDID, go_id);
2452 SetSentErrorMessage(true);
2453 return false;
2454 }
2455
2456 GameObjectInfo const * gInfo = objmgr.GetGameObjectInfo(go_id);
2457 if(!gInfo)
2458 {
2459 PSendSysMessage(LANG_COMMAND_LISTOBJINVALIDID, go_id);
2460 SetSentErrorMessage(true);
2461 return false;
2462 }
2463
2464 char* c_count = strtok(NULL, " ");
2465 int count = c_count ? atol(c_count) : 10;
2466
2467 if(count < 0)
2468 return false;
2469
2470 QueryResult *result;
2471
2472 uint32 obj_count = 0;
2473 result=WorldDatabase.PQuery("SELECT COUNT(guid) FROM gameobject WHERE id='%u'",go_id);
2474 if(result)
2475 {
2476 obj_count = (*result)[0].GetUInt32();
2477 delete result;
2478 }
2479
2480 if(m_session)
2481 {
2482 Player* pl = m_session->GetPlayer();
2483 result = WorldDatabase.PQuery("SELECT guid, position_x, position_y, position_z, map, (POW(position_x - '%f', 2) + POW(position_y - '%f', 2) + POW(position_z - '%f', 2)) AS order_ FROM gameobject WHERE id = '%u' ORDER BY order_ ASC LIMIT %u",
2484 pl->GetPositionX(), pl->GetPositionY(), pl->GetPositionZ(),go_id,uint32(count));
2485 }
2486 else
2487 result = WorldDatabase.PQuery("SELECT guid, position_x, position_y, position_z, map FROM gameobject WHERE id = '%u' LIMIT %u",
2488 go_id,uint32(count));
2489
2490 if (result)
2491 {
2492 do
2493 {
2494 Field *fields = result->Fetch();
2495 uint32 guid = fields[0].GetUInt32();
2496 float x = fields[1].GetFloat();
2497 float y = fields[2].GetFloat();
2498 float z = fields[3].GetFloat();
2499 int mapid = fields[4].GetUInt16();
2500
2501 if (m_session)
2502 PSendSysMessage(LANG_GO_LIST_CHAT, guid, guid, gInfo->name, x, y, z, mapid);
2503 else
2504 PSendSysMessage(LANG_GO_LIST_CONSOLE, guid, gInfo->name, x, y, z, mapid);
2505 } while (result->NextRow());
2506
2507 delete result;
2508 }
2509
2510 PSendSysMessage(LANG_COMMAND_LISTOBJMESSAGE,go_id,obj_count);
2511 return true;
2512 }
2513
2514 bool ChatHandler::HandleListCreatureCommand(const char* args)
2515 {
2516 if(!*args)
2517 return false;
2518
2519 // number or [name] Shift-click form |color|Hcreature_entry:creature_id|h[name]|h|r
2520 char* cId = extractKeyFromLink((char*)args,"Hcreature_entry");
2521 if(!cId)
2522 return false;
2523
2524 uint32 cr_id = atol(cId);
2525 if(!cr_id)
2526 {
2527 PSendSysMessage(LANG_COMMAND_INVALIDCREATUREID, cr_id);
2528 SetSentErrorMessage(true);
2529 return false;
2530 }
2531
2532 CreatureInfo const* cInfo = objmgr.GetCreatureTemplate(cr_id);
2533 if(!cInfo)
2534 {
2535 PSendSysMessage(LANG_COMMAND_INVALIDCREATUREID, cr_id);
2536 SetSentErrorMessage(true);
2537 return false;
2538 }
2539
2540 char* c_count = strtok(NULL, " ");
2541 int count = c_count ? atol(c_count) : 10;
2542
2543 if(count < 0)
2544 return false;
2545
2546 QueryResult *result;
2547
2548 uint32 cr_count = 0;
2549 result=WorldDatabase.PQuery("SELECT COUNT(guid) FROM creature WHERE id='%u'",cr_id);
2550 if(result)
2551 {
2552 cr_count = (*result)[0].GetUInt32();
2553 delete result;
2554 }
2555
2556 if(m_session)
2557 {
2558 Player* pl = m_session->GetPlayer();
2559 result = WorldDatabase.PQuery("SELECT guid, position_x, position_y, position_z, map, (POW(position_x - '%f', 2) + POW(position_y - '%f', 2) + POW(position_z - '%f', 2)) AS order_ FROM creature WHERE id = '%u' ORDER BY order_ ASC LIMIT %u",
2560 pl->GetPositionX(), pl->GetPositionY(), pl->GetPositionZ(), cr_id,uint32(count));
2561 }
2562 else
2563 result = WorldDatabase.PQuery("SELECT guid, position_x, position_y, position_z, map FROM creature WHERE id = '%u' LIMIT %u",
2564 cr_id,uint32(count));
2565
2566 if (result)
2567 {
2568 do
2569 {
2570 Field *fields = result->Fetch();
2571 uint32 guid = fields[0].GetUInt32();
2572 float x = fields[1].GetFloat();
2573 float y = fields[2].GetFloat();
2574 float z = fields[3].GetFloat();
2575 int mapid = fields[4].GetUInt16();
2576
2577 if (m_session)
2578 PSendSysMessage(LANG_CREATURE_LIST_CHAT, guid, guid, cInfo->Name, x, y, z, mapid);
2579 else
2580 PSendSysMessage(LANG_CREATURE_LIST_CONSOLE, guid, cInfo->Name, x, y, z, mapid);
2581 } while (result->NextRow());
2582
2583 delete result;
2584 }
2585
2586 PSendSysMessage(LANG_COMMAND_LISTCREATUREMESSAGE,cr_id,cr_count);
2587 return true;
2588 }
2589
2590 bool ChatHandler::HandleLookupItemCommand(const char* args)
2591 {
2592 if(!*args)
2593 return false;
2594
2595 std::string namepart = args;
2596 std::wstring wnamepart;
2597
2598 // converting string that we try to find to lower case
2599 if(!Utf8toWStr(namepart,wnamepart))
2600 return false;
2601
2602 wstrToLower(wnamepart);
2603
2604 uint32 counter = 0;
2605
2606 // Search in `item_template`
2607 for (uint32 id = 0; id < sItemStorage.MaxEntry; id++)
2608 {
2609 ItemPrototype const *pProto = sItemStorage.LookupEntry<ItemPrototype >(id);
2610 if(!pProto)
2611 continue;
2612
2613 int loc_idx = GetSessionDbLocaleIndex();
2614 if ( loc_idx >= 0 )
2615 {
2616 ItemLocale const *il = objmgr.GetItemLocale(pProto->ItemId);
2617 if (il)
2618 {
2619 if (il->Name.size() > loc_idx && !il->Name[loc_idx].empty())
2620 {
2621 std::string name = il->Name[loc_idx];
2622
2623 if (Utf8FitTo(name, wnamepart))
2624 {
2625 if (m_session)
2626 PSendSysMessage(LANG_ITEM_LIST_CHAT, id, id, name.c_str());
2627 else
2628 PSendSysMessage(LANG_ITEM_LIST_CONSOLE, id, name.c_str());
2629 ++counter;
2630 continue;
2631 }
2632 }
2633 }
2634 }
2635
2636 std::string name = pProto->Name1;
2637 if(name.empty())
2638 continue;
2639
2640 if (Utf8FitTo(name, wnamepart))
2641 {
2642 if (m_session)
2643 PSendSysMessage(LANG_ITEM_LIST_CHAT, id, id, name.c_str());
2644 else
2645 PSendSysMessage(LANG_ITEM_LIST_CONSOLE, id, name.c_str());
2646 ++counter;
2647 }
2648 }
2649
2650 if (counter==0)
2651 SendSysMessage(LANG_COMMAND_NOITEMFOUND);
2652
2653 return true;
2654 }
2655
2656 bool ChatHandler::HandleLookupItemSetCommand(const char* args)
2657 {
2658 if(!*args)
2659 return false;
2660
2661 std::string namepart = args;
2662 std::wstring wnamepart;
2663
2664 if(!Utf8toWStr(namepart,wnamepart))
2665 return false;
2666
2667 // converting string that we try to find to lower case
2668 wstrToLower( wnamepart );
2669
2670 uint32 counter = 0; // Counter for figure out that we found smth.
2671
2672 // Search in ItemSet.dbc
2673 for (uint32 id = 0; id < sItemSetStore.GetNumRows(); id++)
2674 {
2675 ItemSetEntry const *set = sItemSetStore.LookupEntry(id);
2676 if(set)
2677 {
2678 int loc = GetSessionDbcLocale();
2679 std::string name = set->name[loc];
2680 if(name.empty())
2681 continue;
2682
2683 if (!Utf8FitTo(name, wnamepart))
2684 {
2685 loc = 0;
2686 for(; loc < MAX_LOCALE; ++loc)
2687 {
2688 if(loc==GetSessionDbcLocale())
2689 continue;
2690
2691 name = set->name[loc];
2692 if(name.empty())
2693 continue;
2694
2695 if (Utf8FitTo(name, wnamepart))
2696 break;
2697 }
2698 }
2699
2700 if(loc < MAX_LOCALE)
2701 {
2702 // send item set in "id - [namedlink locale]" format
2703 if (m_session)
2704 PSendSysMessage(LANG_ITEMSET_LIST_CHAT,id,id,name.c_str(),localeNames[loc]);
2705 else
2706 PSendSysMessage(LANG_ITEMSET_LIST_CONSOLE,id,name.c_str(),localeNames[loc]);
2707 ++counter;
2708 }
2709 }
2710 }
2711 if (counter == 0) // if counter == 0 then we found nth
2712 SendSysMessage(LANG_COMMAND_NOITEMSETFOUND);
2713 return true;
2714 }
2715
2716 bool ChatHandler::HandleLookupSkillCommand(const char* args)
2717 {
2718 if(!*args)
2719 return false;
2720
2721 // can be NULL in console call
2722 Player* target = getSelectedPlayer();
2723
2724 std::string namepart = args;
2725 std::wstring wnamepart;
2726
2727 if(!Utf8toWStr(namepart,wnamepart))
2728 return false;
2729
2730 // converting string that we try to find to lower case
2731 wstrToLower( wnamepart );
2732
2733 uint32 counter = 0; // Counter for figure out that we found smth.
2734
2735 // Search in SkillLine.dbc
2736 for (uint32 id = 0; id < sSkillLineStore.GetNumRows(); id++)
2737 {
2738 SkillLineEntry const *skillInfo = sSkillLineStore.LookupEntry(id);
2739 if(skillInfo)
2740 {
2741 int loc = GetSessionDbcLocale();
2742 std::string name = skillInfo->name[loc];
2743 if(name.empty())
2744 continue;
2745
2746 if (!Utf8FitTo(name, wnamepart))
2747 {
2748 loc = 0;
2749 for(; loc < MAX_LOCALE; ++loc)
2750 {
2751 if(loc==GetSessionDbcLocale())
2752 continue;
2753
2754 name = skillInfo->name[loc];
2755 if(name.empty())
2756 continue;
2757
2758 if (Utf8FitTo(name, wnamepart))
2759 break;
2760 }
2761 }
2762
2763 if(loc < MAX_LOCALE)
2764 {
2765 char valStr[50] = "";
2766 char const* knownStr = "";
2767 if(target && target->HasSkill(id))
2768 {
2769 knownStr = GetMangosString(LANG_KNOWN);
2770 uint32 curValue = target->GetPureSkillValue(id);
2771 uint32 maxValue = target->GetPureMaxSkillValue(id);
2772 uint32 permValue = target->GetSkillPermBonusValue(id);
2773 uint32 tempValue = target->GetSkillTempBonusValue(id);
2774
2775 char const* valFormat = GetMangosString(LANG_SKILL_VALUES);
2776 snprintf(valStr,50,valFormat,curValue,maxValue,permValue,tempValue);
2777 }
2778
2779 // send skill in "id - [namedlink locale]" format
2780 if (m_session)
2781 PSendSysMessage(LANG_SKILL_LIST_CHAT,id,id,name.c_str(),localeNames[loc],knownStr,valStr);
2782 else
2783 PSendSysMessage(LANG_SKILL_LIST_CONSOLE,id,name.c_str(),localeNames[loc],knownStr,valStr);
2784
2785 ++counter;
2786 }
2787 }
2788 }
2789 if (counter == 0) // if counter == 0 then we found nth
2790 SendSysMessage(LANG_COMMAND_NOSKILLFOUND);
2791 return true;
2792 }
2793
2794 bool ChatHandler::HandleLookupSpellCommand(const char* args)
2795 {
2796 if(!*args)
2797 return false;
2798
2799 // can be NULL at console call
2800 Player* target = getSelectedPlayer();
2801
2802 std::string namepart = args;
2803 std::wstring wnamepart;
2804
2805 if(!Utf8toWStr(namepart,wnamepart))
2806 return false;
2807
2808 // converting string that we try to find to lower case
2809 wstrToLower( wnamepart );
2810
2811 uint32 counter = 0; // Counter for figure out that we found smth.
2812
2813 // Search in Spell.dbc
2814 for (uint32 id = 0; id < sSpellStore.GetNumRows(); id++)
2815 {
2816 SpellEntry const *spellInfo = sSpellStore.LookupEntry(id);
2817 if(spellInfo)
2818 {
2819 int loc = GetSessionDbcLocale();
2820 std::string name = spellInfo->SpellName[loc];
2821 if(name.empty())
2822 continue;
2823
2824 if (!Utf8FitTo(name, wnamepart))
2825 {
2826 loc = 0;
2827 for(; loc < MAX_LOCALE; ++loc)
2828 {
2829 if(loc==GetSessionDbcLocale())
2830 continue;
2831
2832 name = spellInfo->SpellName[loc];
2833 if(name.empty())
2834 continue;
2835
2836 if (Utf8FitTo(name, wnamepart))
2837 break;
2838 }
2839 }
2840
2841 if(loc < MAX_LOCALE)
2842 {
2843 bool known = target && target->HasSpell(id);
2844 bool learn = (spellInfo->Effect[0] == SPELL_EFFECT_LEARN_SPELL);
2845
2846 uint32 talentCost = GetTalentSpellCost(id);
2847
2848 bool talent = (talentCost > 0);
2849 bool passive = IsPassiveSpell(id);
2850 bool active = target && target->HasAura(id);
2851
2852 // unit32 used to prevent interpreting uint8 as char at output
2853 // find rank of learned spell for learning spell, or talent rank
2854 uint32 rank = talentCost ? talentCost : spellmgr.GetSpellRank(learn ? spellInfo->EffectTriggerSpell[0] : id);
2855
2856 // send spell in "id - [name, rank N] [talent] [passive] [learn] [known]" format
2857 std::ostringstream ss;
2858 if (m_session)
2859 ss << id << " - |cffffffff|Hspell:" << id << "|h[" << name;
2860 else
2861 ss << id << " - " << name;
2862
2863 // include rank in link name
2864 if(rank)
2865 ss << GetMangosString(LANG_SPELL_RANK) << rank;
2866
2867 if (m_session)
2868 ss << " " << localeNames[loc] << "]|h|r";
2869 else
2870 ss << " " << localeNames[loc];
2871
2872 if(talent)
2873 ss << GetMangosString(LANG_TALENT);
2874 if(passive)
2875 ss << GetMangosString(LANG_PASSIVE);
2876 if(learn)
2877 ss << GetMangosString(LANG_LEARN);
2878 if(known)
2879 ss << GetMangosString(LANG_KNOWN);
2880 if(active)
2881 ss << GetMangosString(LANG_ACTIVE);
2882
2883 SendSysMessage(ss.str().c_str());
2884
2885 ++counter;
2886 }
2887 }
2888 }
2889 if (counter == 0) // if counter == 0 then we found nth
2890 SendSysMessage(LANG_COMMAND_NOSPELLFOUND);
2891 return true;
2892 }
2893
2894 bool ChatHandler::HandleLookupQuestCommand(const char* args)
2895 {
2896 if(!*args)
2897 return false;
2898
2899 // can be NULL at console call
2900 Player* target = getSelectedPlayer();
2901
2902 std::string namepart = args;
2903 std::wstring wnamepart;
2904
2905 // converting string that we try to find to lower case
2906 if(!Utf8toWStr(namepart,wnamepart))
2907 return false;
2908
2909 wstrToLower(wnamepart);
2910
2911 uint32 counter = 0 ;
2912
2913 ObjectMgr::QuestMap const& qTemplates = objmgr.GetQuestTemplates();
2914 for (ObjectMgr::QuestMap::const_iterator iter = qTemplates.begin(); iter != qTemplates.end(); ++iter)
2915 {
2916 Quest * qinfo = iter->second;
2917
2918 int loc_idx = GetSessionDbLocaleIndex();
2919 if ( loc_idx >= 0 )
2920 {
2921 QuestLocale const *il = objmgr.GetQuestLocale(qinfo->GetQuestId());
2922 if (il)
2923 {
2924 if (il->Title.size() > loc_idx && !il->Title[loc_idx].empty())
2925 {
2926 std::string title = il->Title[loc_idx];
2927
2928 if (Utf8FitTo(title, wnamepart))
2929 {
2930 char const* statusStr = "";
2931
2932 if(target)
2933 {
2934 QuestStatus status = target->GetQuestStatus(qinfo->GetQuestId());
2935
2936 if(status == QUEST_STATUS_COMPLETE)
2937 {
2938 if(target->GetQuestRewardStatus(qinfo->GetQuestId()))
2939 statusStr = GetMangosString(LANG_COMMAND_QUEST_REWARDED);
2940 else
2941 statusStr = GetMangosString(LANG_COMMAND_QUEST_COMPLETE);
2942 }
2943 else if(status == QUEST_STATUS_INCOMPLETE)
2944 statusStr = GetMangosString(LANG_COMMAND_QUEST_ACTIVE);
2945 }
2946
2947 if (m_session)
2948 PSendSysMessage(LANG_QUEST_LIST_CHAT,qinfo->GetQuestId(),qinfo->GetQuestId(),qinfo->GetQuestLevel(),title.c_str(),statusStr);
2949 else
2950 PSendSysMessage(LANG_QUEST_LIST_CONSOLE,qinfo->GetQuestId(),title.c_str(),statusStr);
2951 ++counter;
2952 continue;
2953 }
2954 }
2955 }
2956 }
2957
2958 std::string title = qinfo->GetTitle();
2959 if(title.empty())
2960 continue;
2961
2962 if (Utf8FitTo(title, wnamepart))
2963 {
2964 char const* statusStr = "";
2965
2966 if(target)
2967 {
2968 QuestStatus status = target->GetQuestStatus(qinfo->GetQuestId());
2969
2970 if(status == QUEST_STATUS_COMPLETE)
2971 {
2972 if(target->GetQuestRewardStatus(qinfo->GetQuestId()))
2973 statusStr = GetMangosString(LANG_COMMAND_QUEST_REWARDED);
2974 else
2975 statusStr = GetMangosString(LANG_COMMAND_QUEST_COMPLETE);
2976 }
2977 else if(status == QUEST_STATUS_INCOMPLETE)
2978 statusStr = GetMangosString(LANG_COMMAND_QUEST_ACTIVE);
2979 }
2980
2981 if (m_session)
2982 PSendSysMessage(LANG_QUEST_LIST_CHAT,qinfo->GetQuestId(),qinfo->GetQuestId(),qinfo->GetQuestLevel(),title.c_str(),statusStr);
2983 else
2984 PSendSysMessage(LANG_QUEST_LIST_CONSOLE,qinfo->GetQuestId(),title.c_str(),statusStr);
2985
2986 ++counter;
2987 }
2988 }
2989
2990 if (counter==0)
2991 SendSysMessage(LANG_COMMAND_NOQUESTFOUND);
2992
2993 return true;
2994 }
2995
2996 bool ChatHandler::HandleLookupCreatureCommand(const char* args)
2997 {
2998 if (!*args)
2999 return false;
3000
3001 std::string namepart = args;
3002 std::wstring wnamepart;
3003
3004 // converting string that we try to find to lower case
3005 if (!Utf8toWStr (namepart,wnamepart))
3006 return false;
3007
3008 wstrToLower (wnamepart);
3009
3010 uint32 counter = 0;
3011
3012 for (uint32 id = 0; id< sCreatureStorage.MaxEntry; ++id)
3013 {
3014 CreatureInfo const* cInfo = sCreatureStorage.LookupEntry<CreatureInfo> (id);
3015 if(!cInfo)
3016 continue;
3017
3018 int loc_idx = GetSessionDbLocaleIndex();
3019 if (loc_idx >= 0)
3020 {
3021 CreatureLocale const *cl = objmgr.GetCreatureLocale (id);
3022 if (cl)
3023 {
3024 if (cl->Name.size() > loc_idx && !cl->Name[loc_idx].empty ())
3025 {
3026 std::string name = cl->Name[loc_idx];
3027
3028 if (Utf8FitTo (name, wnamepart))
3029 {
3030 if (m_session)
3031 PSendSysMessage (LANG_CREATURE_ENTRY_LIST_CHAT, id, id, name.c_str ());
3032 else
3033 PSendSysMessage (LANG_CREATURE_ENTRY_LIST_CONSOLE, id, name.c_str ());
3034 ++counter;
3035 continue;
3036 }
3037 }
3038 }
3039 }
3040
3041 std::string name = cInfo->Name;
3042 if (name.empty ())
3043 continue;
3044
3045 if (Utf8FitTo(name, wnamepart))
3046 {
3047 if (m_session)
3048 PSendSysMessage (LANG_CREATURE_ENTRY_LIST_CHAT, id, id, name.c_str ());
3049 else
3050 PSendSysMessage (LANG_CREATURE_ENTRY_LIST_CONSOLE, id, name.c_str ());
3051 ++counter;
3052 }
3053 }
3054
3055 if (counter==0)
3056 SendSysMessage (LANG_COMMAND_NOCREATUREFOUND);
3057
3058 return true;
3059 }
3060
3061 bool ChatHandler::HandleLookupObjectCommand(const char* args)
3062 {
3063 if(!*args)
3064 return false;
3065
3066 std::string namepart = args;
3067 std::wstring wnamepart;
3068
3069 // converting string that we try to find to lower case
3070 if(!Utf8toWStr(namepart,wnamepart))
3071 return false;
3072
3073 wstrToLower(wnamepart);
3074
3075 uint32 counter = 0;
3076
3077 for (uint32 id = 0; id< sGOStorage.MaxEntry; id++ )
3078 {
3079 GameObjectInfo const* gInfo = sGOStorage.LookupEntry<GameObjectInfo>(id);
3080 if(!gInfo)
3081 continue;
3082
3083 int loc_idx = GetSessionDbLocaleIndex();
3084 if ( loc_idx >= 0 )
3085 {
3086 GameObjectLocale const *gl = objmgr.GetGameObjectLocale(id);
3087 if (gl)
3088 {
3089 if (gl->Name.size() > loc_idx && !gl->Name[loc_idx].empty())
3090 {
3091 std::string name = gl->Name[loc_idx];
3092
3093 if (Utf8FitTo(name, wnamepart))
3094 {
3095 if (m_session)
3096 PSendSysMessage(LANG_GO_ENTRY_LIST_CHAT, id, id, name.c_str());
3097 else
3098 PSendSysMessage(LANG_GO_ENTRY_LIST_CONSOLE, id, name.c_str());
3099 ++counter;
3100 continue;
3101 }
3102 }
3103 }
3104 }
3105
3106 std::string name = gInfo->name;
3107 if(name.empty())
3108 continue;
3109
3110 if(Utf8FitTo(name, wnamepart))
3111 {
3112 if (m_session)
3113 PSendSysMessage(LANG_GO_ENTRY_LIST_CHAT, id, id, name.c_str());
3114 else
3115 PSendSysMessage(LANG_GO_ENTRY_LIST_CONSOLE, id, name.c_str());
3116 ++counter;
3117 }
3118 }
3119
3120 if(counter==0)
3121 SendSysMessage(LANG_COMMAND_NOGAMEOBJECTFOUND);
3122
3123 return true;
3124 }
3125
3126 bool ChatHandler::HandleLookupTaxiNodeCommand(const char * args)
3127 {
3128 if(!*args)
3129 return false;
3130
3131 std::string namepart = args;
3132 std::wstring wnamepart;
3133
3134 if(!Utf8toWStr(namepart,wnamepart))
3135 return false;
3136
3137 // converting string that we try to find to lower case
3138 wstrToLower( wnamepart );
3139
3140 uint32 counter = 0; // Counter for figure out that we found smth.
3141
3142 // Search in TaxiNodes.dbc
3143 for (uint32 id = 0; id < sTaxiNodesStore.GetNumRows(); id++)
3144 {
3145 TaxiNodesEntry const *nodeEntry = sTaxiNodesStore.LookupEntry(id);
3146 if(nodeEntry)
3147 {
3148 int loc = GetSessionDbcLocale();
3149 std::string name = nodeEntry->name[loc];
3150 if(name.empty())
3151 continue;
3152
3153 if (!Utf8FitTo(name, wnamepart))
3154 {
3155 loc = 0;
3156 for(; loc < MAX_LOCALE; ++loc)
3157 {
3158 if(loc==GetSessionDbcLocale())
3159 continue;
3160
3161 name = nodeEntry->name[loc];
3162 if(name.empty())
3163 continue;
3164
3165 if (Utf8FitTo(name, wnamepart))
3166 break;
3167 }
3168 }
3169
3170 if(loc < MAX_LOCALE)
3171 {
3172 // send taxinode in "id - [name] (Map:m X:x Y:y Z:z)" format
3173 if (m_session)
3174 PSendSysMessage (LANG_TAXINODE_ENTRY_LIST_CHAT, id, id, name.c_str(),localeNames[loc],
3175 nodeEntry->map_id,nodeEntry->x,nodeEntry->y,nodeEntry->z);
3176 else
3177 PSendSysMessage (LANG_TAXINODE_ENTRY_LIST_CONSOLE, id, name.c_str(), localeNames[loc],
3178 nodeEntry->map_id,nodeEntry->x,nodeEntry->y,nodeEntry->z);
3179 ++counter;
3180 }
3181 }
3182 }
3183 if (counter == 0) // if counter == 0 then we found nth
3184 SendSysMessage(LANG_COMMAND_NOTAXINODEFOUND);
3185 return true;
3186 }
3187
3188 /** \brief GM command level 3 - Create a guild.
3189 *
3190 * This command allows a GM (level 3) to create a guild.
3191 *
3192 * The "args" parameter contains the name of the guild leader
3193 * and then the name of the guild.
3194 *
3195 */
3196 bool ChatHandler::HandleGuildCreateCommand(const char* args)
3197 {
3198 if(!*args)
3199 return false;
3200
3201 // if not guild name only (in "") then player name
3202 Player* target;
3203 if(!extractPlayerTarget(*args!='"' ? (char*)args : NULL, &target))
3204 return false;
3205
3206 char* tailStr = *args!='"' ? strtok(NULL, "") : (char*)args;
3207 if(!tailStr)
3208 return false;
3209
3210 char* guildStr = extractQuotedArg(tailStr);
3211 if(!guildStr)
3212 return false;
3213
3214 std::string guildname = guildStr;
3215
3216 if (target->GetGuildId())
3217 {
3218 SendSysMessage (LANG_PLAYER_IN_GUILD);
3219 return true;
3220 }
3221
3222 Guild *guild = new Guild;
3223 if (!guild->Create (target,guildname))
3224 {
3225 delete guild;
3226 SendSysMessage (LANG_GUILD_NOT_CREATED);
3227 SetSentErrorMessage (true);
3228 return false;
3229 }
3230
3231 objmgr.AddGuild (guild);
3232 return true;
3233 }
3234
3235 bool ChatHandler::HandleGuildInviteCommand(const char *args)
3236 {
3237 if(!*args)
3238 return false;
3239
3240 // if not guild name only (in "") then player name
3241 uint64 target_guid;
3242 if(!extractPlayerTarget(*args!='"' ? (char*)args : NULL, NULL, &target_guid))
3243 return false;
3244
3245 char* tailStr = *args!='"' ? strtok(NULL, "") : (char*)args;
3246 if(!tailStr)
3247 return false;
3248
3249 char* guildStr = extractQuotedArg(tailStr);
3250 if(!guildStr)
3251 return false;
3252
3253 std::string glName = guildStr;
3254 Guild* targetGuild = objmgr.GetGuildByName (glName);
3255 if (!targetGuild)
3256 return false;
3257
3258 // player's guild membership checked in AddMember before add
3259 if (!targetGuild->AddMember (target_guid,targetGuild->GetLowestRank ()))
3260 return false;
3261
3262 return true;
3263 }
3264
3265 bool ChatHandler::HandleGuildUninviteCommand(const char *args)
3266 {
3267 Player* target;
3268 uint64 target_guid;
3269 if(!extractPlayerTarget((char*)args,&target,&target_guid))
3270 return false;
3271
3272 uint32 glId = target ? target->GetGuildId () : Player::GetGuildIdFromDB (target_guid);
3273 if (!glId)
3274 return false;
3275
3276 Guild* targetGuild = objmgr.GetGuildById (glId);
3277 if (!targetGuild)
3278 return false;
3279
3280 targetGuild->DelMember (target_guid);
3281 return true;
3282 }
3283
3284 bool ChatHandler::HandleGuildRankCommand(const char *args)
3285 {
3286 char* nameStr;
3287 char* rankStr;
3288 extractOptFirstArg((char*)args,&nameStr,&rankStr);
3289 if(!rankStr)
3290 return false;
3291
3292 Player* target;
3293 uint64 target_guid;
3294 std::string target_name;
3295 if(!extractPlayerTarget(nameStr,&target,&target_guid,&target_name))
3296 return false;
3297
3298 uint32 glId = target ? target->GetGuildId () : Player::GetGuildIdFromDB (target_guid);
3299 if (!glId)
3300 return false;
3301
3302 Guild* targetGuild = objmgr.GetGuildById (glId);
3303 if (!targetGuild)
3304 return false;
3305
3306 uint32 newrank = uint32 (atoi (rankStr));
3307 if (newrank > targetGuild->GetLowestRank ())
3308 return false;
3309
3310 targetGuild->ChangeRank (target_guid,newrank);
3311 return true;
3312 }
3313
3314 bool ChatHandler::HandleGuildDeleteCommand(const char* args)
3315 {
3316 if (!*args)
3317 return false;
3318
3319 char* guildStr = extractQuotedArg((char*)args);
3320 if(!guildStr)
3321 return false;
3322
3323 std::string gld = guildStr;
3324
3325 Guild* targetGuild = objmgr.GetGuildByName (gld);
3326 if (!targetGuild)
3327 return false;
3328
3329 targetGuild->Disband ();
3330
3331 return true;
3332 }
3333
3334 bool ChatHandler::HandleGetDistanceCommand(const char* args)
3335 {
3336 WorldObject* obj = NULL;
3337
3338 if (*args)
3339 {
3340 uint64 guid = extractGuidFromLink((char*)args);
3341 if(guid)
3342 obj = (WorldObject*)ObjectAccessor::GetObjectByTypeMask(*m_session->GetPlayer(),guid,TYPEMASK_UNIT|TYPEMASK_GAMEOBJECT);
3343
3344 if(!obj)
3345 {
3346 SendSysMessage(LANG_PLAYER_NOT_FOUND);
3347 SetSentErrorMessage(true);
3348 return false;
3349 }
3350 }
3351 else
3352 {
3353 obj = getSelectedUnit();
3354
3355 if(!obj)
3356 {
3357 SendSysMessage(LANG_SELECT_CHAR_OR_CREATURE);
3358 SetSentErrorMessage(true);
3359 return false;
3360 }
3361 }
3362
3363 PSendSysMessage(LANG_DISTANCE, m_session->GetPlayer()->GetDistance(obj),m_session->GetPlayer()->GetDistance2d(obj));
3364
3365 return true;
3366 }
3367
3368 bool ChatHandler::HandleDieCommand(const char* /*args*/)
3369 {
3370 Unit* target = getSelectedUnit();
3371
3372 if(!target || !m_session->GetPlayer()->GetSelection())
3373 {
3374 SendSysMessage(LANG_SELECT_CHAR_OR_CREATURE);
3375 SetSentErrorMessage(true);
3376 return false;
3377 }
3378
3379 if(target->GetTypeId()==TYPEID_PLAYER)
3380 {
3381 if(HasLowerSecurity((Player*)target,0,false))
3382 return false;
3383 }
3384
3385 if( target->isAlive() )
3386 {
3387 m_session->GetPlayer()->DealDamage(target, target->GetHealth(), NULL, DIRECT_DAMAGE, SPELL_SCHOOL_MASK_NORMAL, NULL, false);
3388 }
3389
3390 return true;
3391 }
3392
3393 bool ChatHandler::HandleDamageCommand(const char * args)
3394 {
3395 if (!*args)
3396 return false;
3397
3398 Unit* target = getSelectedUnit();
3399
3400 if (!target || !m_session->GetPlayer()->GetSelection())
3401 {
3402 SendSysMessage(LANG_SELECT_CHAR_OR_CREATURE);
3403 SetSentErrorMessage(true);
3404 return false;
3405 }
3406
3407 if (!target->isAlive())
3408 return true;
3409
3410 char* damageStr = strtok((char*)args, " ");
3411 if (!damageStr)
3412 return false;
3413
3414 int32 damage_int = atoi((char*)damageStr);
3415 if(damage_int <=0)
3416 return true;
3417
3418 uint32 damage = damage_int;
3419
3420 char* schoolStr = strtok((char*)NULL, " ");
3421
3422 // flat melee damage without resistence/etc reduction
3423 if (!schoolStr)
3424 {
3425 m_session->GetPlayer()->DealDamage(target, damage, NULL, DIRECT_DAMAGE, SPELL_SCHOOL_MASK_NORMAL, NULL, false);
3426 if (target != m_session->GetPlayer())
3427 m_session->GetPlayer()->SendAttackStateUpdate (HITINFO_NORMALSWING2, target, 1, SPELL_SCHOOL_MASK_NORMAL, damage, 0, 0, VICTIMSTATE_NORMAL, 0);
3428 return true;
3429 }
3430
3431 uint32 school = schoolStr ? atoi((char*)schoolStr) : SPELL_SCHOOL_NORMAL;
3432 if(school >= MAX_SPELL_SCHOOL)
3433 return false;
3434
3435 SpellSchoolMask schoolmask = SpellSchoolMask(1 << school);
3436
3437 if ( schoolmask & SPELL_SCHOOL_MASK_NORMAL )
3438 damage = m_session->GetPlayer()->CalcArmorReducedDamage(target, damage);
3439
3440 char* spellStr = strtok((char*)NULL, " ");
3441
3442 // melee damage by specific school
3443 if (!spellStr)
3444 {
3445 uint32 absorb = 0;
3446 uint32 resist = 0;
3447
3448 m_session->GetPlayer()->CalcAbsorbResist(target,schoolmask, SPELL_DIRECT_DAMAGE, damage, &absorb, &resist);
3449
3450 if (damage <= absorb + resist)
3451 return true;
3452
3453 damage -= absorb + resist;
3454
3455 m_session->GetPlayer()->DealDamageMods(target,damage,&absorb);
3456 m_session->GetPlayer()->DealDamage(target, damage, NULL, DIRECT_DAMAGE, schoolmask, NULL, false);
3457 m_session->GetPlayer()->SendAttackStateUpdate (HITINFO_NORMALSWING2, target, 1, schoolmask, damage, absorb, resist, VICTIMSTATE_NORMAL, 0);
3458 return true;
3459 }
3460
3461 // non-melee damage
3462
3463 // number or [name] Shift-click form |color|Hspell:spell_id|h[name]|h|r or Htalent form
3464 uint32 spellid = extractSpellIdFromLink((char*)args);
3465 if (!spellid || !sSpellStore.LookupEntry(spellid))
3466 return false;
3467
3468 m_session->GetPlayer()->SpellNonMeleeDamageLog(target, spellid, damage);
3469 return true;
3470 }
3471
3472 bool ChatHandler::HandleModifyArenaCommand(const char * args)
3473 {
3474 if (!*args)
3475 return false;
3476
3477 Player *target = getSelectedPlayer();
3478 if(!target)
3479 {
3480 SendSysMessage(LANG_PLAYER_NOT_FOUND);
3481 SetSentErrorMessage(true);
3482 return false;
3483 }
3484
3485 int32 amount = (uint32)atoi(args);
3486
3487 target->ModifyArenaPoints(amount);
3488
3489 PSendSysMessage(LANG_COMMAND_MODIFY_ARENA, GetNameLink(target).c_str(), target->GetArenaPoints());
3490
3491 return true;
3492 }
3493
3494 bool ChatHandler::HandleReviveCommand(const char* args)
3495 {
3496 Player* target;
3497 uint64 target_guid;
3498 if(!extractPlayerTarget((char*)args,&target,&target_guid))
3499 return false;
3500
3501 if (target)
3502 {
3503 target->ResurrectPlayer(0.5f);
3504 target->SpawnCorpseBones();
3505 target->SaveToDB();
3506 }
3507 else
3508 // will resurrected at login without corpse
3509 ObjectAccessor::Instance().ConvertCorpseForPlayer(target_guid);
3510
3511 return true;
3512 }
3513
3514 bool ChatHandler::HandleAuraCommand(const char* args)
3515 {
3516 Unit *target = getSelectedUnit();
3517 if(!target)
3518 {
3519 SendSysMessage(LANG_SELECT_CHAR_OR_CREATURE);
3520 SetSentErrorMessage(true);
3521 return false;
3522 }
3523
3524 // number or [name] Shift-click form |color|Hspell:spell_id|h[name]|h|r or Htalent form
3525 uint32 spellID = extractSpellIdFromLink((char*)args);
3526
3527 SpellEntry const *spellInfo = sSpellStore.LookupEntry( spellID );
3528 if(spellInfo)
3529 {
3530 for(uint32 i = 0;i<3;++i)
3531 {
3532 uint8 eff = spellInfo->Effect[i];
3533 if (eff>=TOTAL_SPELL_EFFECTS)
3534 continue;
3535 if( IsAreaAuraEffect(eff) ||
3536 eff == SPELL_EFFECT_APPLY_AURA ||
3537 eff == SPELL_EFFECT_PERSISTENT_AREA_AURA )
3538 {
3539 Aura *Aur = CreateAura(spellInfo, i, NULL, target);
3540 target->AddAura(Aur);
3541 }
3542 }
3543 }
3544
3545 return true;
3546 }
3547
3548 bool ChatHandler::HandleUnAuraCommand(const char* args)
3549 {
3550 Unit *target = getSelectedUnit();
3551 if(!target)
3552 {
3553 SendSysMessage(LANG_SELECT_CHAR_OR_CREATURE);
3554 SetSentErrorMessage(true);
3555 return false;
3556 }
3557
3558 std::string argstr = args;
3559 if (argstr == "all")
3560 {
3561 target->RemoveAllAuras();
3562 return true;
3563 }
3564
3565 // number or [name] Shift-click form |color|Hspell:spell_id|h[name]|h|r or Htalent form
3566 uint32 spellID = extractSpellIdFromLink((char*)args);
3567 if(!spellID)
3568 return false;
3569
3570 target->RemoveAurasDueToSpell(spellID);
3571
3572 return true;
3573 }
3574
3575 bool ChatHandler::HandleLinkGraveCommand(const char* args)
3576 {
3577 if(!*args)
3578 return false;
3579
3580 char* px = strtok((char*)args, " ");
3581 if (!px)
3582 return false;
3583
3584 uint32 g_id = (uint32)atoi(px);
3585
3586 uint32 g_team;
3587
3588 char* px2 = strtok(NULL, " ");
3589
3590 if (!px2)
3591 g_team = 0;
3592 else if (strncmp(px2,"horde",6)==0)
3593 g_team = HORDE;
3594 else if (strncmp(px2,"alliance",9)==0)
3595 g_team = ALLIANCE;
3596 else
3597 return false;
3598
3599 WorldSafeLocsEntry const* graveyard = sWorldSafeLocsStore.LookupEntry(g_id);
3600
3601 if(!graveyard )
3602 {
3603 PSendSysMessage(LANG_COMMAND_GRAVEYARDNOEXIST, g_id);
3604 SetSentErrorMessage(true);
3605 return false;
3606 }
3607
3608 Player* player = m_session->GetPlayer();
3609
3610 uint32 zoneId = player->GetZoneId();
3611
3612 AreaTableEntry const *areaEntry = GetAreaEntryByAreaID(zoneId);
3613 if(!areaEntry || areaEntry->zone !=0 )
3614 {
3615 PSendSysMessage(LANG_COMMAND_GRAVEYARDWRONGZONE, g_id,zoneId);
3616 SetSentErrorMessage(true);
3617 return false;
3618 }
3619
3620 if(objmgr.AddGraveYardLink(g_id,zoneId,g_team))
3621 PSendSysMessage(LANG_COMMAND_GRAVEYARDLINKED, g_id,zoneId);
3622 else
3623 PSendSysMessage(LANG_COMMAND_GRAVEYARDALRLINKED, g_id,zoneId);
3624
3625 return true;
3626 }
3627
3628 bool ChatHandler::HandleNearGraveCommand(const char* args)
3629 {
3630 uint32 g_team;
3631
3632 size_t argslen = strlen(args);
3633
3634 if(!*args)
3635 g_team = 0;
3636 else if (strncmp((char*)args,"horde",argslen)==0)
3637 g_team = HORDE;
3638 else if (strncmp((char*)args,"alliance",argslen)==0)
3639 g_team = ALLIANCE;
3640 else
3641 return false;
3642
3643 Player* player = m_session->GetPlayer();
3644 uint32 zone_id = player->GetZoneId();
3645
3646 WorldSafeLocsEntry const* graveyard = objmgr.GetClosestGraveYard(
3647 player->GetPositionX(), player->GetPositionY(), player->GetPositionZ(),player->GetMapId(),g_team);
3648
3649 if(graveyard)
3650 {
3651 uint32 g_id = graveyard->ID;
3652
3653 GraveYardData const* data = objmgr.FindGraveYardData(g_id,zone_id);
3654 if (!data)
3655 {
3656 PSendSysMessage(LANG_COMMAND_GRAVEYARDERROR,g_id);
3657 SetSentErrorMessage(true);
3658 return false;
3659 }
3660
3661 g_team = data->team;
3662
3663 std::string team_name = GetMangosString(LANG_COMMAND_GRAVEYARD_NOTEAM);
3664
3665 if(g_team == 0)
3666 team_name = GetMangosString(LANG_COMMAND_GRAVEYARD_ANY);
3667 else if(g_team == HORDE)
3668 team_name = GetMangosString(LANG_COMMAND_GRAVEYARD_HORDE);
3669 else if(g_team == ALLIANCE)
3670 team_name = GetMangosString(LANG_COMMAND_GRAVEYARD_ALLIANCE);
3671
3672 PSendSysMessage(LANG_COMMAND_GRAVEYARDNEAREST, g_id,team_name.c_str(),zone_id);
3673 }
3674 else
3675 {
3676 std::string team_name;
3677
3678 if(g_team == 0)
3679 team_name = GetMangosString(LANG_COMMAND_GRAVEYARD_ANY);
3680 else if(g_team == HORDE)
3681 team_name = GetMangosString(LANG_COMMAND_GRAVEYARD_HORDE);
3682 else if(g_team == ALLIANCE)
3683 team_name = GetMangosString(LANG_COMMAND_GRAVEYARD_ALLIANCE);
3684
3685 if(g_team == ~uint32(0))
3686 PSendSysMessage(LANG_COMMAND_ZONENOGRAVEYARDS, zone_id);
3687 else
3688 PSendSysMessage(LANG_COMMAND_ZONENOGRAFACTION, zone_id,team_name.c_str());
3689 }
3690
3691 return true;
3692 }
3693
3694 //-----------------------Npc Commands-----------------------
3695 bool ChatHandler::HandleNpcAllowMovementCommand(const char* /*args*/)
3696 {
3697 if(sWorld.getAllowMovement())
3698 {
3699 sWorld.SetAllowMovement(false);
3700 SendSysMessage(LANG_CREATURE_MOVE_DISABLED);
3701 }
3702 else
3703 {
3704 sWorld.SetAllowMovement(true);
3705 SendSysMessage(LANG_CREATURE_MOVE_ENABLED);
3706 }
3707 return true;
3708 }
3709
3710 bool ChatHandler::HandleNpcChangeEntryCommand(const char *args)
3711 {
3712 if (!*args)
3713 return false;
3714
3715 uint32 newEntryNum = atoi(args);
3716 if(!newEntryNum)
3717 return false;
3718
3719 Unit* unit = getSelectedUnit();
3720 if(!unit || unit->GetTypeId() != TYPEID_UNIT)
3721 {
3722 SendSysMessage(LANG_SELECT_CREATURE);
3723 SetSentErrorMessage(true);
3724 return false;
3725 }
3726 Creature* creature = (Creature*)unit;
3727 if(creature->UpdateEntry(newEntryNum))
3728 SendSysMessage(LANG_DONE);
3729 else
3730 SendSysMessage(LANG_ERROR);
3731 return true;
3732 }
3733
3734 bool ChatHandler::HandleNpcInfoCommand(const char* /*args*/)
3735 {
3736 Creature* target = getSelectedCreature();
3737
3738 if(!target)
3739 {
3740 SendSysMessage(LANG_SELECT_CREATURE);
3741 SetSentErrorMessage(true);
3742 return false;
3743 }
3744
3745 uint32 faction = target->getFaction();
3746 uint32 npcflags = target->GetUInt32Value(UNIT_NPC_FLAGS);
3747 uint32 displayid = target->GetDisplayId();
3748 uint32 nativeid = target->GetNativeDisplayId();
3749 uint32 Entry = target->GetEntry();
3750 CreatureInfo const* cInfo = target->GetCreatureInfo();
3751
3752 int32 curRespawnDelay = target->GetRespawnTimeEx()-time(NULL);
3753 if(curRespawnDelay < 0)
3754 curRespawnDelay = 0;
3755 std::string curRespawnDelayStr = secsToTimeString(curRespawnDelay,true);
3756 std::string defRespawnDelayStr = secsToTimeString(target->GetRespawnDelay(),true);
3757
3758 PSendSysMessage(LANG_NPCINFO_CHAR, target->GetDBTableGUIDLow(), faction, npcflags, Entry, displayid, nativeid);
3759 PSendSysMessage(LANG_NPCINFO_LEVEL, target->getLevel());
3760 PSendSysMessage(LANG_NPCINFO_HEALTH,target->GetCreateHealth(), target->GetMaxHealth(), target->GetHealth());
3761 PSendSysMessage(LANG_NPCINFO_FLAGS, target->GetUInt32Value(UNIT_FIELD_FLAGS), target->GetUInt32Value(UNIT_DYNAMIC_FLAGS), target->getFaction());
3762 PSendSysMessage(LANG_COMMAND_RAWPAWNTIMES, defRespawnDelayStr.c_str(),curRespawnDelayStr.c_str());
3763 PSendSysMessage(LANG_NPCINFO_LOOT, cInfo->lootid,cInfo->pickpocketLootId,cInfo->SkinLootId);
3764 PSendSysMessage(LANG_NPCINFO_DUNGEON_ID, target->GetInstanceId());
3765 PSendSysMessage(LANG_NPCINFO_POSITION,float(target->GetPositionX()), float(target->GetPositionY()), float(target->GetPositionZ()));
3766
3767 if ((npcflags & UNIT_NPC_FLAG_VENDOR) )
3768 {
3769 SendSysMessage(LANG_NPCINFO_VENDOR);
3770 }
3771 if ((npcflags & UNIT_NPC_FLAG_TRAINER) )
3772 {
3773 SendSysMessage(LANG_NPCINFO_TRAINER);
3774 }
3775
3776 return true;
3777 }
3778
3779 //play npc emote
3780 bool ChatHandler::HandleNpcPlayEmoteCommand(const char* args)
3781 {
3782 uint32 emote = atoi((char*)args);
3783
3784 Creature* target = getSelectedCreature();
3785 if(!target)
3786 {
3787 SendSysMessage(LANG_SELECT_CREATURE);
3788 SetSentErrorMessage(true);
3789 return false;
3790 }
3791
3792 target->SetUInt32Value(UNIT_NPC_EMOTESTATE,emote);
3793
3794 return true;
3795 }
3796
3797 //TODO: NpcCommands that needs to be fixed :
3798
3799 bool ChatHandler::HandleNpcAddWeaponCommand(const char* /*args*/)
3800 {
3801 /*if (!*args)
3802 return false;
3803
3804 uint64 guid = m_session->GetPlayer()->GetSelection();
3805 if (guid == 0)
3806 {
3807 SendSysMessage(LANG_NO_SELECTION);
3808 return true;
3809 }
3810
3811 Creature *pCreature = ObjectAccessor::GetCreature(*m_session->GetPlayer(), guid);
3812
3813 if(!pCreature)
3814 {
3815 SendSysMessage(LANG_SELECT_CREATURE);
3816 return true;
3817 }
3818
3819 char* pSlotID = strtok((char*)args, " ");
3820 if (!pSlotID)
3821 return false;
3822
3823 char* pItemID = strtok(NULL, " ");
3824 if (!pItemID)
3825 return false;
3826
3827 uint32 ItemID = atoi(pItemID);
3828 uint32 SlotID = atoi(pSlotID);
3829
3830 ItemPrototype* tmpItem = objmgr.GetItemPrototype(ItemID);
3831
3832 bool added = false;
3833 if(tmpItem)
3834 {
3835 switch(SlotID)
3836 {
3837 case 1:
3838 pCreature->SetUInt32Value(UNIT_VIRTUAL_ITEM_SLOT_DISPLAY, ItemID);
3839 added = true;
3840 break;
3841 case 2:
3842 pCreature->SetUInt32Value(UNIT_VIRTUAL_ITEM_SLOT_DISPLAY_01, ItemID);
3843 added = true;
3844 break;
3845 case 3:
3846 pCreature->SetUInt32Value(UNIT_VIRTUAL_ITEM_SLOT_DISPLAY_02, ItemID);
3847 added = true;
3848 break;
3849 default:
3850 PSendSysMessage(LANG_ITEM_SLOT_NOT_EXIST,SlotID);
3851 added = false;
3852 break;
3853 }
3854
3855 if(added)
3856 PSendSysMessage(LANG_ITEM_ADDED_TO_SLOT,ItemID,tmpItem->Name1,SlotID);
3857 }
3858 else
3859 {
3860 PSendSysMessage(LANG_ITEM_NOT_FOUND,ItemID);
3861 return true;
3862 }
3863 */
3864 return true;
3865 }
3866 //----------------------------------------------------------
3867
3868 bool ChatHandler::HandleExploreCheatCommand(const char* args)
3869 {
3870 if (!*args)
3871 return false;
3872
3873 int flag = atoi((char*)args);
3874
3875 Player *chr = getSelectedPlayer();
3876 if (chr == NULL)
3877 {
3878 SendSysMessage(LANG_NO_CHAR_SELECTED);
3879 SetSentErrorMessage(true);
3880 return false;
3881 }
3882
3883 if (flag != 0)
3884 {
3885 PSendSysMessage(LANG_YOU_SET_EXPLORE_ALL, GetNameLink(chr).c_str());
3886 if (needReportToTarget(chr))
3887 ChatHandler(chr).PSendSysMessage(LANG_YOURS_EXPLORE_SET_ALL,GetNameLink().c_str());
3888 }
3889 else
3890 {
3891 PSendSysMessage(LANG_YOU_SET_EXPLORE_NOTHING, GetNameLink(chr).c_str());
3892 if (needReportToTarget(chr))
3893 ChatHandler(chr).PSendSysMessage(LANG_YOURS_EXPLORE_SET_NOTHING,GetNameLink().c_str());
3894 }
3895
3896 for (uint8 i=0; i<128; ++i)
3897 {
3898 if (flag != 0)
3899 {
3900 m_session->GetPlayer()->SetFlag(PLAYER_EXPLORED_ZONES_1+i,0xFFFFFFFF);
3901 }
3902 else
3903 {
3904 m_session->GetPlayer()->SetFlag(PLAYER_EXPLORED_ZONES_1+i,0);
3905 }
3906 }
3907
3908 return true;
3909 }
3910
3911 bool ChatHandler::HandleHoverCommand(const char* args)
3912 {
3913 char* px = strtok((char*)args, " ");
3914 uint32 flag;
3915 if (!px)
3916 flag = 1;
3917 else
3918 flag = atoi(px);
3919
3920 m_session->GetPlayer()->SetHover(flag);
3921
3922 if (flag)
3923 SendSysMessage(LANG_HOVER_ENABLED);
3924 else
3925 SendSysMessage(LANG_HOVER_DISABLED);
3926
3927 return true;
3928 }
3929
3930 void ChatHandler::HandleCharacterLevel(Player* player, uint64 player_guid, uint32 oldlevel, uint32 newlevel)
3931 {
3932 if(player)
3933 {
3934 player->GiveLevel(newlevel);
3935 player->InitTalentForLevel();
3936 player->SetUInt32Value(PLAYER_XP,0);
3937
3938 if(needReportToTarget(player))
3939 {
3940 if(oldlevel == newlevel)
3941 ChatHandler(player).PSendSysMessage(LANG_YOURS_LEVEL_PROGRESS_RESET,GetNameLink().c_str());
3942 else if(oldlevel < newlevel)
3943 ChatHandler(player).PSendSysMessage(LANG_YOURS_LEVEL_UP,GetNameLink().c_str(),newlevel);
3944 else // if(oldlevel > newlevel)
3945 ChatHandler(player).PSendSysMessage(LANG_YOURS_LEVEL_DOWN,GetNameLink().c_str(),newlevel);
3946 }
3947 }
3948 else
3949 {
3950 // update level and XP at level, all other will be updated at loading
3951 CharacterDatabase.PExecute("UPDATE characters SET level = '%u', xp = 0 WHERE guid = '%u'", newlevel, GUID_LOPART(player_guid));
3952 }
3953 }
3954
3955 bool ChatHandler::HandleCharacterLevelCommand(const char* args)
3956 {
3957 char* nameStr;
3958 char* levelStr;
3959 extractOptFirstArg((char*)args,&nameStr,&levelStr);
3960 if(!levelStr)
3961 return false;
3962
3963 // exception opt second arg: .character level $name
3964 if(isalpha(levelStr[0]))
3965 {
3966 nameStr = levelStr;
3967 levelStr = NULL; // current level will used
3968 }
3969
3970 Player* target;
3971 uint64 target_guid;
3972 std::string target_name;
3973 if(!extractPlayerTarget(nameStr,&target,&target_guid,&target_name))
3974 return false;
3975
3976 int32 oldlevel = target ? target->getLevel() : Player::GetLevelFromDB(target_guid);
3977 int32 newlevel = levelStr ? atoi(levelStr) : oldlevel;
3978
3979 if(newlevel < 1)
3980 return false; // invalid level
3981
3982 if(newlevel > STRONG_MAX_LEVEL) // hardcoded maximum level
3983 newlevel = STRONG_MAX_LEVEL;
3984
3985 HandleCharacterLevel(target,target_guid,oldlevel,newlevel);
3986
3987 if(!m_session || m_session->GetPlayer() != target) // including player==NULL
3988 {
3989 std::string nameLink = playerLink(target_name);
3990 PSendSysMessage(LANG_YOU_CHANGE_LVL,nameLink.c_str(),newlevel);
3991 }
3992
3993 return true;
3994 }
3995
3996 bool ChatHandler::HandleLevelUpCommand(const char* args)
3997 {
3998 char* nameStr;
3999 char* levelStr;
4000 extractOptFirstArg((char*)args,&nameStr,&levelStr);
4001
4002 // exception opt second arg: .character level $name
4003 if(levelStr && isalpha(levelStr[0]))
4004 {
4005 nameStr = levelStr;
4006 levelStr = NULL; // current level will used
4007 }
4008
4009 Player* target;
4010 uint64 target_guid;
4011 std::string target_name;
4012 if(!extractPlayerTarget(nameStr,&target,&target_guid,&target_name))
4013 return false;
4014
4015 int32 oldlevel = target ? target->getLevel() : Player::GetLevelFromDB(target_guid);
4016 int32 addlevel = levelStr ? atoi(levelStr) : 1;
4017 int32 newlevel = oldlevel + addlevel;
4018
4019 if(newlevel < 1)
4020 newlevel = 1;
4021
4022 if(newlevel > STRONG_MAX_LEVEL) // hardcoded maximum level
4023 newlevel = STRONG_MAX_LEVEL;
4024
4025 HandleCharacterLevel(target,target_guid,oldlevel,newlevel);
4026
4027 if(!m_session || m_session->GetPlayer() != target) // including chr==NULL
4028 {
4029 std::string nameLink = playerLink(target_name);
4030 PSendSysMessage(LANG_YOU_CHANGE_LVL,nameLink.c_str(),newlevel);
4031 }
4032
4033 return true;
4034 }
4035
4036 bool ChatHandler::HandleShowAreaCommand(const char* args)
4037 {
4038 if (!*args)
4039 return false;
4040
4041 Player *chr = getSelectedPlayer();
4042 if (chr == NULL)
4043 {
4044 SendSysMessage(LANG_NO_CHAR_SELECTED);
4045 SetSentErrorMessage(true);
4046 return false;
4047 }
4048
4049 int area = GetAreaFlagByAreaID(atoi((char*)args));
4050 int offset = area / 32;
4051 uint32 val = (uint32)(1 << (area % 32));
4052
4053 if(area<0 || offset >= 128)
4054 {
4055 SendSysMessage(LANG_BAD_VALUE);
4056 SetSentErrorMessage(true);
4057 return false;
4058 }
4059
4060 uint32 currFields = chr->GetUInt32Value(PLAYER_EXPLORED_ZONES_1 + offset);
4061 chr->SetUInt32Value(PLAYER_EXPLORED_ZONES_1 + offset, (uint32)(currFields | val));
4062
4063 SendSysMessage(LANG_EXPLORE_AREA);
4064 return true;
4065 }
4066
4067 bool ChatHandler::HandleHideAreaCommand(const char* args)
4068 {
4069 if (!*args)
4070 return false;
4071
4072 Player *chr = getSelectedPlayer();
4073 if (chr == NULL)
4074 {
4075 SendSysMessage(LANG_NO_CHAR_SELECTED);
4076 SetSentErrorMessage(true);
4077 return false;
4078 }
4079
4080 int area = GetAreaFlagByAreaID(atoi((char*)args));
4081 int offset = area / 32;
4082 uint32 val = (uint32)(1 << (area % 32));
4083
4084 if(area<0 || offset >= 128)
4085 {
4086 SendSysMessage(LANG_BAD_VALUE);
4087 SetSentErrorMessage(true);
4088 return false;
4089 }
4090
4091 uint32 currFields = chr->GetUInt32Value(PLAYER_EXPLORED_ZONES_1 + offset);
4092 chr->SetUInt32Value(PLAYER_EXPLORED_ZONES_1 + offset, (uint32)(currFields ^ val));
4093
4094 SendSysMessage(LANG_UNEXPLORE_AREA);
4095 return true;
4096 }
4097
4098 bool ChatHandler::HandleBankCommand(const char* /*args*/)
4099 {
4100 m_session->SendShowBank( m_session->GetPlayer()->GetGUID() );
4101
4102 return true;
4103 }
4104
4105 bool ChatHandler::HandleChangeWeather(const char* args)
4106 {
4107 if(!*args)
4108 return false;
4109
4110 //Weather is OFF
4111 if (!sWorld.getConfig(CONFIG_WEATHER))
4112 {
4113 SendSysMessage(LANG_WEATHER_DISABLED);
4114 SetSentErrorMessage(true);
4115 return false;
4116 }
4117
4118 //*Change the weather of a cell
4119 char* px = strtok((char*)args, " ");
4120 char* py = strtok(NULL, " ");
4121
4122 if (!px || !py)
4123 return false;
4124
4125 uint32 type = (uint32)atoi(px); //0 to 3, 0: fine, 1: rain, 2: snow, 3: sand
4126 float grade = (float)atof(py); //0 to 1, sending -1 is instand good weather
4127
4128 Player *player = m_session->GetPlayer();
4129 uint32 zoneid = player->GetZoneId();
4130
4131 Weather* wth = sWorld.FindWeather(zoneid);
4132
4133 if(!wth)
4134 wth = sWorld.AddWeather(zoneid);
4135 if(!wth)
4136 {
4137 SendSysMessage(LANG_NO_WEATHER);
4138 SetSentErrorMessage(true);
4139 return false;
4140 }
4141
4142 wth->SetWeather(WeatherType(type), grade);
4143
4144 return true;
4145 }
4146
4147 bool ChatHandler::HandleTeleAddCommand(const char * args)
4148 {
4149 if(!*args)
4150 return false;
4151
4152 Player *player=m_session->GetPlayer();
4153 if (!player)
4154 return false;
4155
4156 std::string name = args;
4157
4158 if(objmgr.GetGameTele(name))
4159 {
4160 SendSysMessage(LANG_COMMAND_TP_ALREADYEXIST);
4161 SetSentErrorMessage(true);
4162 return false;
4163 }
4164
4165 GameTele tele;
4166 tele.position_x = player->GetPositionX();
4167 tele.position_y = player->GetPositionY();
4168 tele.position_z = player->GetPositionZ();
4169 tele.orientation = player->GetOrientation();
4170 tele.mapId = player->GetMapId();
4171 tele.name = name;
4172
4173 if(objmgr.AddGameTele(tele))
4174 {
4175 SendSysMessage(LANG_COMMAND_TP_ADDED);
4176 }
4177 else
4178 {
4179 SendSysMessage(LANG_COMMAND_TP_ADDEDERR);
4180 SetSentErrorMessage(true);
4181 return false;
4182 }
4183
4184 return true;
4185 }
4186
4187 bool ChatHandler::HandleTeleDelCommand(const char * args)
4188 {
4189 if(!*args)
4190 return false;
4191
4192 std::string name = args;
4193
4194 if(!objmgr.DeleteGameTele(name))
4195 {
4196 SendSysMessage(LANG_COMMAND_TELE_NOTFOUND);
4197 SetSentErrorMessage(true);
4198 return false;
4199 }
4200
4201 SendSysMessage(LANG_COMMAND_TP_DELETED);
4202 return true;
4203 }
4204
4205 bool ChatHandler::HandleListAurasCommand (const char * /*args*/)
4206 {
4207 Unit *unit = getSelectedUnit();
4208 if(!unit)
4209 {
4210 SendSysMessage(LANG_SELECT_CHAR_OR_CREATURE);
4211 SetSentErrorMessage(true);
4212 return false;
4213 }
4214
4215 char const* talentStr = GetMangosString(LANG_TALENT);
4216 char const* passiveStr = GetMangosString(LANG_PASSIVE);
4217
4218 Unit::AuraMap const& uAuras = unit->GetAuras();
4219 PSendSysMessage(LANG_COMMAND_TARGET_LISTAURAS, uAuras.size());
4220 for (Unit::AuraMap::const_iterator itr = uAuras.begin(); itr != uAuras.end(); ++itr)
4221 {
4222 bool talent = GetTalentSpellCost(itr->second->GetId()) > 0;
4223
4224 char const* name = itr->second->GetSpellProto()->SpellName[GetSessionDbcLocale()];
4225
4226 if (m_session)
4227 {
4228 std::ostringstream ss_name;
4229 ss_name << "|cffffffff|Hspell:" << itr->second->GetId() << "|h[" << name << "]|h|r";
4230
4231 PSendSysMessage(LANG_COMMAND_TARGET_AURADETAIL, itr->second->GetId(), itr->second->GetEffIndex(),
4232 itr->second->GetModifier()->m_auraname, itr->second->GetAuraDuration(), itr->second->GetAuraMaxDuration(),
4233 ss_name.str().c_str(),
4234 (itr->second->IsPassive() ? passiveStr : ""),(talent ? talentStr : ""),
4235 IS_PLAYER_GUID(itr->second->GetCasterGUID()) ? "player" : "creature",GUID_LOPART(itr->second->GetCasterGUID()));
4236 }
4237 else
4238 {
4239 PSendSysMessage(LANG_COMMAND_TARGET_AURADETAIL, itr->second->GetId(), itr->second->GetEffIndex(),
4240 itr->second->GetModifier()->m_auraname, itr->second->GetAuraDuration(), itr->second->GetAuraMaxDuration(),
4241 name,
4242 (itr->second->IsPassive() ? passiveStr : ""),(talent ? talentStr : ""),
4243 IS_PLAYER_GUID(itr->second->GetCasterGUID()) ? "player" : "creature",GUID_LOPART(itr->second->GetCasterGUID()));
4244 }
4245 }
4246 for (int i = 0; i < TOTAL_AURAS; ++i)
4247 {
4248 Unit::AuraList const& uAuraList = unit->GetAurasByType(AuraType(i));
4249 if (uAuraList.empty()) continue;
4250 PSendSysMessage(LANG_COMMAND_TARGET_LISTAURATYPE, uAuraList.size(), i);
4251 for (Unit::AuraList::const_iterator itr = uAuraList.begin(); itr != uAuraList.end(); ++itr)
4252 {
4253 bool talent = GetTalentSpellCost((*itr)->GetId()) > 0;
4254
4255 char const* name = (*itr)->GetSpellProto()->SpellName[GetSessionDbcLocale()];
4256
4257 if (m_session)
4258 {
4259 std::ostringstream ss_name;
4260 ss_name << "|cffffffff|Hspell:" << (*itr)->GetId() << "|h[" << name << "]|h|r";
4261
4262 PSendSysMessage(LANG_COMMAND_TARGET_AURASIMPLE, (*itr)->GetId(), (*itr)->GetEffIndex(),
4263 ss_name.str().c_str(),((*itr)->IsPassive() ? passiveStr : ""),(talent ? talentStr : ""),
4264 IS_PLAYER_GUID((*itr)->GetCasterGUID()) ? "player" : "creature",GUID_LOPART((*itr)->GetCasterGUID()));
4265 }
4266 else
4267 {
4268 PSendSysMessage(LANG_COMMAND_TARGET_AURASIMPLE, (*itr)->GetId(), (*itr)->GetEffIndex(),
4269 name,((*itr)->IsPassive() ? passiveStr : ""),(talent ? talentStr : ""),
4270 IS_PLAYER_GUID((*itr)->GetCasterGUID()) ? "player" : "creature",GUID_LOPART((*itr)->GetCasterGUID()));
4271 }
4272 }
4273 }
4274 return true;
4275 }
4276
4277 bool ChatHandler::HandleResetAchievementsCommand (const char * args)
4278 {
4279 Player* target;
4280 uint64 target_guid;
4281 if (!extractPlayerTarget((char*)args,&target,&target_guid))
4282 return false;
4283
4284 if(target)
4285 target->GetAchievementMgr().Reset();
4286 else
4287 AchievementMgr::DeleteFromDB(GUID_LOPART(target_guid));
4288
4289 return true;
4290 }
4291
4292 bool ChatHandler::HandleResetHonorCommand (const char * args)
4293 {
4294 Player* target;
4295 if (!extractPlayerTarget((char*)args,&target))
4296 return false;
4297
4298 target->SetUInt32Value(PLAYER_FIELD_KILLS, 0);
4299 target->SetUInt32Value(PLAYER_FIELD_LIFETIME_HONORBALE_KILLS, 0);
4300 target->SetUInt32Value(PLAYER_FIELD_HONOR_CURRENCY, 0);
4301 target->SetUInt32Value(PLAYER_FIELD_TODAY_CONTRIBUTION, 0);
4302 target->SetUInt32Value(PLAYER_FIELD_YESTERDAY_CONTRIBUTION, 0);
4303 target->UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_EARN_HONORABLE_KILL);
4304
4305 return true;
4306 }
4307
4308 static bool HandleResetStatsOrLevelHelper(Player* player)
4309 {
4310 ChrClassesEntry const* cEntry = sChrClassesStore.LookupEntry(player->getClass());
4311 if(!cEntry)
4312 {
4313 sLog.outError("Class %u not found in DBC (Wrong DBC files?)",player->getClass());
4314 return false;
4315 }
4316
4317 uint8 powertype = cEntry->powerType;
4318
4319 // reset m_form if no aura
4320 if(!player->HasAuraType(SPELL_AURA_MOD_SHAPESHIFT))
4321 player->m_form = FORM_NONE;
4322
4323 player->SetFloatValue(UNIT_FIELD_BOUNDINGRADIUS, DEFAULT_WORLD_OBJECT_SIZE );
4324 player->SetFloatValue(UNIT_FIELD_COMBATREACH, 1.5f );
4325
4326 player->setFactionForRace(player->getRace());
4327
4328 player->SetUInt32Value(UNIT_FIELD_BYTES_0, ( ( player->getRace() ) | ( player->getClass() << 8 ) | ( player->getGender() << 16 ) | ( powertype << 24 ) ) );
4329
4330 // reset only if player not in some form;
4331 if(player->m_form==FORM_NONE)
4332 player->InitDisplayIds();
4333
4334 player->SetByteValue(UNIT_FIELD_BYTES_2, 1, UNIT_BYTE2_FLAG_PVP );
4335 player->SetByteValue(UNIT_FIELD_BYTES_2, 3, player->m_form);
4336
4337 player->SetUInt32Value(UNIT_FIELD_FLAGS, UNIT_FLAG_PVP_ATTACKABLE);
4338
4339 //-1 is default value
4340 player->SetUInt32Value(PLAYER_FIELD_WATCHED_FACTION_INDEX, uint32(-1));
4341
4342 //player->SetUInt32Value(PLAYER_FIELD_BYTES, 0xEEE00000 );
4343 return true;
4344 }
4345
4346 bool ChatHandler::HandleResetLevelCommand(const char * args)
4347 {
4348 Player* target;
4349 if(!extractPlayerTarget((char*)args,&target))
4350 return false;
4351
4352 if(!HandleResetStatsOrLevelHelper(target))
4353 return false;
4354
4355 // set starting level
4356 uint32 start_level = target->getClass() != CLASS_DEATH_KNIGHT
4357 ? sWorld.getConfig(CONFIG_START_PLAYER_LEVEL)
4358 : sWorld.getConfig(CONFIG_START_HEROIC_PLAYER_LEVEL);
4359
4360 target->_ApplyAllLevelScaleItemMods(false);
4361
4362 target->SetLevel(start_level);
4363 target->InitRunes();
4364 target->InitStatsForLevel(true);
4365 target->InitTaxiNodesForLevel();
4366 target->InitGlyphsForLevel();
4367 target->InitTalentForLevel();
4368 target->SetUInt32Value(PLAYER_XP,0);
4369
4370 target->_ApplyAllLevelScaleItemMods(true);
4371
4372 // reset level for pet
4373 if(Pet* pet = target->GetPet())
4374 pet->SynchronizeLevelWithOwner();
4375
4376 return true;
4377 }
4378
4379 bool ChatHandler::HandleResetStatsCommand(const char * args)
4380 {
4381 Player* target;
4382 if (!extractPlayerTarget((char*)args,&target))
4383 return false;
4384
4385 if (!HandleResetStatsOrLevelHelper(target))
4386 return false;
4387
4388 target->InitRunes();
4389 target->InitStatsForLevel(true);
4390 target->InitTaxiNodesForLevel();
4391 target->InitGlyphsForLevel();
4392 target->InitTalentForLevel();
4393
4394 return true;
4395 }
4396
4397 bool ChatHandler::HandleResetSpellsCommand(const char * args)
4398 {
4399 Player* target;
4400 uint64 target_guid;
4401 std::string target_name;
4402 if(!extractPlayerTarget((char*)args,&target,&target_guid,&target_name))
4403 return false;
4404
4405 if(target)
4406 {
4407 target->resetSpells();
4408
4409 ChatHandler(target).SendSysMessage(LANG_RESET_SPELLS);
4410 if(!m_session || m_session->GetPlayer()!=target)
4411 PSendSysMessage(LANG_RESET_SPELLS_ONLINE,GetNameLink(target).c_str());
4412 }
4413 else
4414 {
4415 CharacterDatabase.PExecute("UPDATE characters SET at_login = at_login | '%u' WHERE guid = '%u'",uint32(AT_LOGIN_RESET_SPELLS), GUID_LOPART(target_guid));
4416 PSendSysMessage(LANG_RESET_SPELLS_OFFLINE,target_name.c_str());
4417 }
4418
4419 return true;
4420 }
4421
4422 bool ChatHandler::HandleResetTalentsCommand(const char * args)
4423 {
4424 Player* target;
4425 uint64 target_guid;
4426 std::string target_name;
4427 if (!extractPlayerTarget((char*)args,&target,&target_guid,&target_name))
4428 {
4429 // Try reset talents as Hunter Pet
4430 Creature* creature = getSelectedCreature();
4431 if (!*args && creature && creature->isPet())
4432 {
4433 Unit *owner = creature->GetOwner();
4434 if(owner && owner->GetTypeId() == TYPEID_PLAYER && ((Pet *)creature)->IsPermanentPetFor((Player*)owner))
4435 {
4436 ((Pet *)creature)->resetTalents(true);
4437 ((Player*)owner)->SendTalentsInfoData(true);
4438
4439 ChatHandler((Player*)owner).SendSysMessage(LANG_RESET_PET_TALENTS);
4440 if(!m_session || m_session->GetPlayer()!=((Player*)owner))
4441 PSendSysMessage(LANG_RESET_PET_TALENTS_ONLINE,GetNameLink((Player*)owner).c_str());
4442 }
4443 return true;
4444 }
4445
4446 SendSysMessage(LANG_NO_CHAR_SELECTED);
4447 SetSentErrorMessage(true);
4448 return false;
4449 }
4450
4451 if (target)
4452 {
4453 target->resetTalents(true);
4454 target->SendTalentsInfoData(false);
4455 ChatHandler(target).SendSysMessage(LANG_RESET_TALENTS);
4456 if (!m_session || m_session->GetPlayer()!=target)
4457 PSendSysMessage(LANG_RESET_TALENTS_ONLINE,GetNameLink(target).c_str());
4458
4459 Pet* pet = target->GetPet();
4460 Pet::resetTalentsForAllPetsOf(target,pet);
4461 if(pet)
4462 target->SendTalentsInfoData(true);
4463 return true;
4464 }
4465 else if (target_guid)
4466 {
4467 uint32 at_flags = AT_LOGIN_NONE | AT_LOGIN_RESET_PET_TALENTS;
4468 CharacterDatabase.PExecute("UPDATE characters SET at_login = at_login | '%u' WHERE guid = '%u'",at_flags, GUID_LOPART(target_guid) );
4469 std::string nameLink = playerLink(target_name);
4470 PSendSysMessage(LANG_RESET_TALENTS_OFFLINE,nameLink.c_str());
4471 return true;
4472 }
4473
4474 SendSysMessage(LANG_NO_CHAR_SELECTED);
4475 SetSentErrorMessage(true);
4476 return false;
4477 }
4478
4479 bool ChatHandler::HandleResetAllCommand(const char * args)
4480 {
4481 if(!*args)
4482 return false;
4483
4484 std::string casename = args;
4485
4486 AtLoginFlags atLogin;
4487
4488 // Command specially created as single command to prevent using short case names
4489 if(casename=="spells")
4490 {
4491 atLogin = AT_LOGIN_RESET_SPELLS;
4492 sWorld.SendWorldText(LANG_RESETALL_SPELLS);
4493 if(!m_session)
4494 SendSysMessage(LANG_RESETALL_SPELLS);
4495 }
4496 else if(casename=="talents")
4497 {
4498 atLogin = AtLoginFlags(AT_LOGIN_RESET_TALENTS | AT_LOGIN_RESET_PET_TALENTS);
4499 sWorld.SendWorldText(LANG_RESETALL_TALENTS);
4500 if(!m_session)
4501 SendSysMessage(LANG_RESETALL_TALENTS);
4502 }
4503 else
4504 {
4505 PSendSysMessage(LANG_RESETALL_UNKNOWN_CASE,args);
4506 SetSentErrorMessage(true);
4507 return false;
4508 }
4509
4510 CharacterDatabase.PExecute("UPDATE characters SET at_login = at_login | '%u' WHERE (at_login & '%u') = '0'",atLogin,atLogin);
4511 HashMapHolder<Player>::MapType const& plist = ObjectAccessor::Instance().GetPlayers();
4512 for(HashMapHolder<Player>::MapType::const_iterator itr = plist.begin(); itr != plist.end(); ++itr)
4513 itr->second->SetAtLoginFlag(atLogin);
4514
4515 return true;
4516 }
4517
4518 bool ChatHandler::HandleServerShutDownCancelCommand(const char* /*args*/)
4519 {
4520 sWorld.ShutdownCancel();
4521 return true;
4522 }
4523
4524 bool ChatHandler::HandleServerShutDownCommand(const char* args)
4525 {
4526 if(!*args)
4527 return false;
4528
4529 char* time_str = strtok ((char*) args, " ");
4530 char* exitcode_str = strtok (NULL, "");
4531
4532 int32 time = atoi (time_str);
4533
4534 ///- Prevent interpret wrong arg value as 0 secs shutdown time
4535 if ((time == 0 && (time_str[0]!='0' || time_str[1]!='\0')) || time < 0)
4536 return false;
4537
4538 if (exitcode_str)
4539 {
4540 int32 exitcode = atoi (exitcode_str);
4541
4542 // Handle atoi() errors
4543 if (exitcode == 0 && (exitcode_str[0] != '0' || exitcode_str[1] != '\0'))
4544 return false;
4545
4546 // Exit code should be in range of 0-125, 126-255 is used
4547 // in many shells for their own return codes and code > 255
4548 // is not supported in many others
4549 if (exitcode < 0 || exitcode > 125)
4550 return false;
4551
4552 sWorld.ShutdownServ (time, 0, exitcode);
4553 }
4554 else
4555 sWorld.ShutdownServ(time,0,SHUTDOWN_EXIT_CODE);
4556 return true;
4557 }
4558
4559 bool ChatHandler::HandleServerRestartCommand(const char* args)
4560 {
4561 if(!*args)
4562 return false;
4563
4564 char* time_str = strtok ((char*) args, " ");
4565 char* exitcode_str = strtok (NULL, "");
4566
4567 int32 time = atoi (time_str);
4568
4569 ///- Prevent interpret wrong arg value as 0 secs shutdown time
4570 if ((time == 0 && (time_str[0]!='0' || time_str[1]!='\0')) || time < 0)
4571 return false;
4572
4573 if (exitcode_str)
4574 {
4575 int32 exitcode = atoi (exitcode_str);
4576
4577 // Handle atoi() errors
4578 if (exitcode == 0 && (exitcode_str[0] != '0' || exitcode_str[1] != '\0'))
4579 return false;
4580
4581 // Exit code should be in range of 0-125, 126-255 is used
4582 // in many shells for their own return codes and code > 255
4583 // is not supported in many others
4584 if (exitcode < 0 || exitcode > 125)
4585 return false;
4586
4587 sWorld.ShutdownServ (time, SHUTDOWN_MASK_RESTART, exitcode);
4588 }
4589 else
4590 sWorld.ShutdownServ(time, SHUTDOWN_MASK_RESTART, RESTART_EXIT_CODE);
4591 return true;
4592 }
4593
4594 bool ChatHandler::HandleServerIdleRestartCommand(const char* args)
4595 {
4596 if(!*args)
4597 return false;
4598
4599 char* time_str = strtok ((char*) args, " ");
4600 char* exitcode_str = strtok (NULL, "");
4601
4602 int32 time = atoi (time_str);
4603
4604 ///- Prevent interpret wrong arg value as 0 secs shutdown time
4605 if ((time == 0 && (time_str[0]!='0' || time_str[1]!='\0')) || time < 0)
4606 return false;
4607
4608 if (exitcode_str)
4609 {
4610 int32 exitcode = atoi (exitcode_str);
4611
4612 // Handle atoi() errors
4613 if (exitcode == 0 && (exitcode_str[0] != '0' || exitcode_str[1] != '\0'))
4614 return false;
4615
4616 // Exit code should be in range of 0-125, 126-255 is used
4617 // in many shells for their own return codes and code > 255
4618 // is not supported in many others
4619 if (exitcode < 0 || exitcode > 125)
4620 return false;
4621
4622 sWorld.ShutdownServ (time, SHUTDOWN_MASK_RESTART|SHUTDOWN_MASK_IDLE, exitcode);
4623 }
4624 else
4625 sWorld.ShutdownServ(time,SHUTDOWN_MASK_RESTART|SHUTDOWN_MASK_IDLE,RESTART_EXIT_CODE);
4626 return true;
4627 }
4628
4629 bool ChatHandler::HandleServerIdleShutDownCommand(const char* args)
4630 {
4631 if(!*args)
4632 return false;
4633
4634 char* time_str = strtok ((char*) args, " ");
4635 char* exitcode_str = strtok (NULL, "");
4636
4637 int32 time = atoi (time_str);
4638
4639 ///- Prevent interpret wrong arg value as 0 secs shutdown time
4640 if ((time == 0 && (time_str[0]!='0' || time_str[1]!='\0')) || time < 0)
4641 return false;
4642
4643 if (exitcode_str)
4644 {
4645 int32 exitcode = atoi (exitcode_str);
4646
4647 // Handle atoi() errors
4648 if (exitcode == 0 && (exitcode_str[0] != '0' || exitcode_str[1] != '\0'))
4649 return false;
4650
4651 // Exit code should be in range of 0-125, 126-255 is used
4652 // in many shells for their own return codes and code > 255
4653 // is not supported in many others
4654 if (exitcode < 0 || exitcode > 125)
4655 return false;
4656
4657 sWorld.ShutdownServ (time, SHUTDOWN_MASK_IDLE, exitcode);
4658 }
4659 else
4660 sWorld.ShutdownServ(time,SHUTDOWN_MASK_IDLE,SHUTDOWN_EXIT_CODE);
4661 return true;
4662 }
4663
4664 bool ChatHandler::HandleQuestAdd(const char* args)
4665 {
4666 Player* player = getSelectedPlayer();
4667 if(!player)
4668 {
4669 SendSysMessage(LANG_NO_CHAR_SELECTED);
4670 SetSentErrorMessage(true);
4671 return false;
4672 }
4673
4674 // .addquest #entry'
4675 // number or [name] Shift-click form |color|Hquest:quest_id:quest_level|h[name]|h|r
4676 char* cId = extractKeyFromLink((char*)args,"Hquest");
4677 if(!cId)
4678 return false;
4679
4680 uint32 entry = atol(cId);
4681
4682 Quest const* pQuest = objmgr.GetQuestTemplate(entry);
4683
4684 if(!pQuest)
4685 {
4686 PSendSysMessage(LANG_COMMAND_QUEST_NOTFOUND,entry);
4687 SetSentErrorMessage(true);
4688 return false;
4689 }
4690
4691 // check item starting quest (it can work incorrectly if added without item in inventory)
4692 for (uint32 id = 0; id < sItemStorage.MaxEntry; id++)
4693 {
4694 ItemPrototype const *pProto = sItemStorage.LookupEntry<ItemPrototype>(id);
4695 if (!pProto)
4696 continue;
4697
4698 if (pProto->StartQuest == entry)
4699 {
4700 PSendSysMessage(LANG_COMMAND_QUEST_STARTFROMITEM, entry, pProto->ItemId);
4701 SetSentErrorMessage(true);
4702 return false;
4703 }
4704 }
4705
4706 // ok, normal (creature/GO starting) quest
4707 if( player->CanAddQuest( pQuest, true ) )
4708 {
4709 player->AddQuest( pQuest, NULL );
4710
4711 if ( player->CanCompleteQuest( entry ) )
4712 player->CompleteQuest( entry );
4713 }
4714
4715 return true;
4716 }
4717
4718 bool ChatHandler::HandleQuestRemove(const char* args)
4719 {
4720 Player* player = getSelectedPlayer();
4721 if(!player)
4722 {
4723 SendSysMessage(LANG_NO_CHAR_SELECTED);
4724 SetSentErrorMessage(true);
4725 return false;
4726 }
4727
4728 // .removequest #entry'
4729 // number or [name] Shift-click form |color|Hquest:quest_id:quest_level|h[name]|h|r
4730 char* cId = extractKeyFromLink((char*)args,"Hquest");
4731 if(!cId)
4732 return false;
4733
4734 uint32 entry = atol(cId);
4735
4736 Quest const* pQuest = objmgr.GetQuestTemplate(entry);
4737
4738 if(!pQuest)
4739 {
4740 PSendSysMessage(LANG_COMMAND_QUEST_NOTFOUND, entry);
4741 SetSentErrorMessage(true);
4742 return false;
4743 }
4744
4745 // remove all quest entries for 'entry' from quest log
4746 for(uint8 slot = 0; slot < MAX_QUEST_LOG_SIZE; ++slot )
4747 {
4748 uint32 quest = player->GetQuestSlotQuestId(slot);
4749 if(quest==entry)
4750 {
4751 player->SetQuestSlot(slot,0);
4752
4753 // we ignore unequippable quest items in this case, its' still be equipped
4754 player->TakeQuestSourceItem( quest, false );
4755 }
4756 }
4757
4758 // set quest status to not started (will updated in DB at next save)
4759 player->SetQuestStatus( entry, QUEST_STATUS_NONE);
4760
4761 // reset rewarded for restart repeatable quest
4762 player->getQuestStatusMap()[entry].m_rewarded = false;
4763
4764 SendSysMessage(LANG_COMMAND_QUEST_REMOVED);
4765 return true;
4766 }
4767
4768 bool ChatHandler::HandleQuestComplete(const char* args)
4769 {
4770 Player* player = getSelectedPlayer();
4771 if(!player)
4772 {
4773 SendSysMessage(LANG_NO_CHAR_SELECTED);
4774 SetSentErrorMessage(true);
4775 return false;
4776 }
4777
4778 // .quest complete #entry
4779 // number or [name] Shift-click form |color|Hquest:quest_id:quest_level|h[name]|h|r
4780 char* cId = extractKeyFromLink((char*)args,"Hquest");
4781 if(!cId)
4782 return false;
4783
4784 uint32 entry = atol(cId);
4785
4786 Quest const* pQuest = objmgr.GetQuestTemplate(entry);
4787
4788 // If player doesn't have the quest
4789 if(!pQuest || player->GetQuestStatus(entry) == QUEST_STATUS_NONE)
4790 {
4791 PSendSysMessage(LANG_COMMAND_QUEST_NOTFOUND, entry);
4792 SetSentErrorMessage(true);
4793 return false;
4794 }
4795
4796 // Add quest items for quests that require items
4797 for(uint8 x = 0; x < QUEST_OBJECTIVES_COUNT; ++x)
4798 {
4799 uint32 id = pQuest->ReqItemId[x];
4800 uint32 count = pQuest->ReqItemCount[x];
4801 if(!id || !count)
4802 continue;
4803
4804 uint32 curItemCount = player->GetItemCount(id,true);
4805
4806 ItemPosCountVec dest;
4807 uint8 msg = player->CanStoreNewItem( NULL_BAG, NULL_SLOT, dest, id, count-curItemCount );
4808 if( msg == EQUIP_ERR_OK )
4809 {
4810 Item* item = player->StoreNewItem( dest, id, true);
4811 player->SendNewItem(item,count-curItemCount,true,false);
4812 }
4813 }
4814
4815 // All creature/GO slain/casted (not required, but otherwise it will display "Creature slain 0/10")
4816 for(uint8 i = 0; i < QUEST_OBJECTIVES_COUNT; ++i)
4817 {
4818 uint32 creature = pQuest->ReqCreatureOrGOId[i];
4819 uint32 creaturecount = pQuest->ReqCreatureOrGOCount[i];
4820
4821 if(uint32 spell_id = pQuest->ReqSpell[i])
4822 {
4823 for(uint16 z = 0; z < creaturecount; ++z)
4824 player->CastedCreatureOrGO(creature,0,spell_id);
4825 }
4826 else if(creature > 0)
4827 {
4828 if(CreatureInfo const* cInfo = objmgr.GetCreatureTemplate(creature))
4829 for(uint16 z = 0; z < creaturecount; ++z)
4830 player->KilledMonster(cInfo,0);
4831 }
4832 else if(creature < 0)
4833 {
4834 for(uint16 z = 0; z < creaturecount; ++z)
4835 player->CastedCreatureOrGO(creature,0,0);
4836 }
4837 }
4838
4839 // If the quest requires reputation to complete
4840 if(uint32 repFaction = pQuest->GetRepObjectiveFaction())
4841 {
4842 uint32 repValue = pQuest->GetRepObjectiveValue();
4843 uint32 curRep = player->GetReputationMgr().GetReputation(repFaction);
4844 if(curRep < repValue)
4845 if(FactionEntry const *factionEntry = sFactionStore.LookupEntry(repFaction))
4846 player->GetReputationMgr().SetReputation(factionEntry,repValue);
4847 }
4848
4849 // If the quest requires money
4850 int32 ReqOrRewMoney = pQuest->GetRewOrReqMoney();
4851 if(ReqOrRewMoney < 0)
4852 player->ModifyMoney(-ReqOrRewMoney);
4853
4854 player->CompleteQuest(entry);
4855 return true;
4856 }
4857
4858 bool ChatHandler::HandleBanAccountCommand(const char* args)
4859 {
4860 return HandleBanHelper(BAN_ACCOUNT,args);
4861 }
4862
4863 bool ChatHandler::HandleBanCharacterCommand(const char* args)
4864 {
4865 return HandleBanHelper(BAN_CHARACTER,args);
4866 }
4867
4868 bool ChatHandler::HandleBanIPCommand(const char* args)
4869 {
4870 return HandleBanHelper(BAN_IP,args);
4871 }
4872
4873 bool ChatHandler::HandleBanHelper(BanMode mode, const char* args)
4874 {
4875 if (!*args)
4876 return false;
4877
4878 char* cnameOrIP = strtok ((char*)args, " ");
4879 if (!cnameOrIP)
4880 return false;
4881
4882 std::string nameOrIP = cnameOrIP;
4883
4884 char* duration = strtok (NULL," ");
4885 if(!duration || !atoi(duration))
4886 return false;
4887
4888 char* reason = strtok (NULL,"");
4889 if(!reason)
4890 return false;
4891
4892 switch(mode)
4893 {
4894 case BAN_ACCOUNT:
4895 if (!AccountMgr::normalizeString(nameOrIP))
4896 {
4897 PSendSysMessage(LANG_ACCOUNT_NOT_EXIST,nameOrIP.c_str());
4898 SetSentErrorMessage(true);
4899 return false;
4900 }
4901 break;
4902 case BAN_CHARACTER:
4903 if(!normalizePlayerName(nameOrIP))
4904 {
4905 SendSysMessage(LANG_PLAYER_NOT_FOUND);
4906 SetSentErrorMessage(true);
4907 return false;
4908 }
4909 break;
4910 case BAN_IP:
4911 if(!IsIPAddress(nameOrIP.c_str()))
4912 return false;
4913 break;
4914 }
4915
4916 switch(sWorld.BanAccount(mode, nameOrIP, duration, reason,m_session ? m_session->GetPlayerName() : ""))
4917 {
4918 case BAN_SUCCESS:
4919 if(atoi(duration)>0)
4920 PSendSysMessage(LANG_BAN_YOUBANNED,nameOrIP.c_str(),secsToTimeString(TimeStringToSecs(duration),true).c_str(),reason);
4921 else
4922 PSendSysMessage(LANG_BAN_YOUPERMBANNED,nameOrIP.c_str(),reason);
4923 break;
4924 case BAN_SYNTAX_ERROR:
4925 return false;
4926 case BAN_NOTFOUND:
4927 switch(mode)
4928 {
4929 default:
4930 PSendSysMessage(LANG_BAN_NOTFOUND,"account",nameOrIP.c_str());
4931 break;
4932 case BAN_CHARACTER:
4933 PSendSysMessage(LANG_BAN_NOTFOUND,"character",nameOrIP.c_str());
4934 break;
4935 case BAN_IP:
4936 PSendSysMessage(LANG_BAN_NOTFOUND,"ip",nameOrIP.c_str());
4937 break;
4938 }
4939 SetSentErrorMessage(true);
4940 return false;
4941 }
4942
4943 return true;
4944 }
4945
4946 bool ChatHandler::HandleUnBanAccountCommand(const char* args)
4947 {
4948 return HandleUnBanHelper(BAN_ACCOUNT,args);
4949 }
4950
4951 bool ChatHandler::HandleUnBanCharacterCommand(const char* args)
4952 {
4953 return HandleUnBanHelper(BAN_CHARACTER,args);
4954 }
4955
4956 bool ChatHandler::HandleUnBanIPCommand(const char* args)
4957 {
4958 return HandleUnBanHelper(BAN_IP,args);
4959 }
4960
4961 bool ChatHandler::HandleUnBanHelper(BanMode mode, const char* args)
4962 {
4963 if (!*args)
4964 return false;
4965
4966 char* cnameOrIP = strtok ((char*)args, " ");
4967 if(!cnameOrIP)
4968 return false;
4969
4970 std::string nameOrIP = cnameOrIP;
4971
4972 switch(mode)
4973 {
4974 case BAN_ACCOUNT:
4975 if (!AccountMgr::normalizeString(nameOrIP))
4976 {
4977 PSendSysMessage(LANG_ACCOUNT_NOT_EXIST,nameOrIP.c_str());
4978 SetSentErrorMessage(true);
4979 return false;
4980 }
4981 break;
4982 case BAN_CHARACTER:
4983 if(!normalizePlayerName(nameOrIP))
4984 {
4985 SendSysMessage(LANG_PLAYER_NOT_FOUND);
4986 SetSentErrorMessage(true);
4987 return false;
4988 }
4989 break;
4990 case BAN_IP:
4991 if(!IsIPAddress(nameOrIP.c_str()))
4992 return false;
4993 break;
4994 }
4995
4996 if(sWorld.RemoveBanAccount(mode,nameOrIP))
4997 PSendSysMessage(LANG_UNBAN_UNBANNED,nameOrIP.c_str());
4998 else
4999 PSendSysMessage(LANG_UNBAN_ERROR,nameOrIP.c_str());
5000
5001 return true;
5002 }
5003
5004 bool ChatHandler::HandleBanInfoAccountCommand(const char* args)
5005 {
5006 if (!*args)
5007 return false;
5008
5009 char* cname = strtok((char*)args, "");
5010 if (!cname)
5011 return false;
5012
5013 std::string account_name = cname;
5014 if (!AccountMgr::normalizeString(account_name))
5015 {
5016 PSendSysMessage(LANG_ACCOUNT_NOT_EXIST,account_name.c_str());
5017 SetSentErrorMessage(true);
5018 return false;
5019 }
5020
5021 uint32 accountid = accmgr.GetId(account_name);
5022 if (!accountid)
5023 {
5024 PSendSysMessage(LANG_ACCOUNT_NOT_EXIST,account_name.c_str());
5025 return true;
5026 }
5027
5028 return HandleBanInfoHelper(accountid,account_name.c_str());
5029 }
5030
5031 bool ChatHandler::HandleBanInfoCharacterCommand(const char* args)
5032 {
5033 Player* target;
5034 uint64 target_guid;
5035 if (!extractPlayerTarget((char*)args,&target,&target_guid))
5036 return false;
5037
5038 uint32 accountid = target ? target->GetSession()->GetAccountId() : objmgr.GetPlayerAccountIdByGUID(target_guid);
5039
5040 std::string accountname;
5041 if (!accmgr.GetName(accountid,accountname))
5042 {
5043 PSendSysMessage(LANG_BANINFO_NOCHARACTER);
5044 return true;
5045 }
5046
5047 return HandleBanInfoHelper(accountid,accountname.c_str());
5048 }
5049
5050 bool ChatHandler::HandleBanInfoHelper(uint32 accountid, char const* accountname)
5051 {
5052 QueryResult *result = loginDatabase.PQuery("SELECT FROM_UNIXTIME(bandate), unbandate-bandate, active, unbandate,banreason,bannedby FROM account_banned WHERE id = '%u' ORDER BY bandate ASC",accountid);
5053 if(!result)
5054 {
5055 PSendSysMessage(LANG_BANINFO_NOACCOUNTBAN, accountname);
5056 return true;
5057 }
5058
5059 PSendSysMessage(LANG_BANINFO_BANHISTORY,accountname);
5060 do
5061 {
5062 Field* fields = result->Fetch();
5063
5064 time_t unbandate = time_t(fields[3].GetUInt64());
5065 bool active = false;
5066 if(fields[2].GetBool() && (fields[1].GetUInt64() == (uint64)0 ||unbandate >= time(NULL)) )
5067 active = true;
5068 bool permanent = (fields[1].GetUInt64() == (uint64)0);
5069 std::string bantime = permanent?GetMangosString(LANG_BANINFO_INFINITE):secsToTimeString(fields[1].GetUInt64(), true);
5070 PSendSysMessage(LANG_BANINFO_HISTORYENTRY,
5071 fields[0].GetString(), bantime.c_str(), active ? GetMangosString(LANG_BANINFO_YES):GetMangosString(LANG_BANINFO_NO), fields[4].GetString(), fields[5].GetString());
5072 }while (result->NextRow());
5073
5074 delete result;
5075 return true;
5076 }
5077
5078 bool ChatHandler::HandleBanInfoIPCommand(const char* args)
5079 {
5080 if (!*args)
5081 return false;
5082
5083 char* cIP = strtok ((char*)args, "");
5084 if(!cIP)
5085 return false;
5086
5087 if (!IsIPAddress(cIP))
5088 return false;
5089
5090 std::string IP = cIP;
5091
5092 loginDatabase.escape_string(IP);
5093 QueryResult *result = loginDatabase.PQuery("SELECT ip, FROM_UNIXTIME(bandate), FROM_UNIXTIME(unbandate), unbandate-UNIX_TIMESTAMP(), banreason,bannedby,unbandate-bandate FROM ip_banned WHERE ip = '%s'",IP.c_str());
5094 if(!result)
5095 {
5096 PSendSysMessage(LANG_BANINFO_NOIP);
5097 return true;
5098 }
5099
5100 Field *fields = result->Fetch();
5101 bool permanent = !fields[6].GetUInt64();
5102 PSendSysMessage(LANG_BANINFO_IPENTRY,
5103 fields[0].GetString(), fields[1].GetString(), permanent ? GetMangosString(LANG_BANINFO_NEVER):fields[2].GetString(),
5104 permanent ? GetMangosString(LANG_BANINFO_INFINITE):secsToTimeString(fields[3].GetUInt64(), true).c_str(), fields[4].GetString(), fields[5].GetString());
5105 delete result;
5106 return true;
5107 }
5108
5109 bool ChatHandler::HandleBanListCharacterCommand(const char* args)
5110 {
5111 loginDatabase.Execute("DELETE FROM ip_banned WHERE unbandate<=UNIX_TIMESTAMP() AND unbandate<>bandate");
5112
5113 char* cFilter = strtok ((char*)args, " ");
5114 if(!cFilter)
5115 return false;
5116
5117 std::string filter = cFilter;
5118 loginDatabase.escape_string(filter);
5119 QueryResult* result = CharacterDatabase.PQuery("SELECT account FROM characters WHERE name "_LIKE_" "_CONCAT3_("'%%'","'%s'","'%%'"),filter.c_str());
5120 if (!result)
5121 {
5122 PSendSysMessage(LANG_BANLIST_NOCHARACTER);
5123 return true;
5124 }
5125
5126 return HandleBanListHelper(result);
5127 }
5128
5129 bool ChatHandler::HandleBanListAccountCommand(const char* args)
5130 {
5131 loginDatabase.Execute("DELETE FROM ip_banned WHERE unbandate<=UNIX_TIMESTAMP() AND unbandate<>bandate");
5132
5133 char* cFilter = strtok((char*)args, " ");
5134 std::string filter = cFilter ? cFilter : "";
5135 loginDatabase.escape_string(filter);
5136
5137 QueryResult* result;
5138
5139 if(filter.empty())
5140 {
5141 result = loginDatabase.Query("SELECT account.id, username FROM account, account_banned"
5142 " WHERE account.id = account_banned.id AND active = 1 GROUP BY account.id");
5143 }
5144 else
5145 {
5146 result = loginDatabase.PQuery("SELECT account.id, username FROM account, account_banned"
5147 " WHERE account.id = account_banned.id AND active = 1 AND username "_LIKE_" "_CONCAT3_("'%%'","'%s'","'%%'")" GROUP BY account.id",
5148 filter.c_str());
5149 }
5150
5151 if (!result)
5152 {
5153 PSendSysMessage(LANG_BANLIST_NOACCOUNT);
5154 return true;
5155 }
5156
5157 return HandleBanListHelper(result);
5158 }
5159
5160 bool ChatHandler::HandleBanListHelper(QueryResult* result)
5161 {
5162 PSendSysMessage(LANG_BANLIST_MATCHINGACCOUNT);
5163
5164 // Chat short output
5165 if(m_session)
5166 {
5167 do
5168 {
5169 Field* fields = result->Fetch();
5170 uint32 accountid = fields[0].GetUInt32();
5171
5172 QueryResult* banresult = loginDatabase.PQuery("SELECT account.username FROM account,account_banned WHERE account_banned.id='%u' AND account_banned.id=account.id",accountid);
5173 if(banresult)
5174 {
5175 Field* fields2 = banresult->Fetch();
5176 PSendSysMessage("%s",fields2[0].GetString());
5177 delete banresult;
5178 }
5179 } while (result->NextRow());
5180 }
5181 // Console wide output
5182 else
5183 {
5184 SendSysMessage(LANG_BANLIST_ACCOUNTS);
5185 SendSysMessage("===============================================================================");
5186 SendSysMessage(LANG_BANLIST_ACCOUNTS_HEADER);
5187 do
5188 {
5189 SendSysMessage("-------------------------------------------------------------------------------");
5190 Field *fields = result->Fetch();
5191 uint32 account_id = fields[0].GetUInt32 ();
5192
5193 std::string account_name;
5194
5195 // "account" case, name can be get in same query
5196 if(result->GetFieldCount() > 1)
5197 account_name = fields[1].GetCppString();
5198 // "character" case, name need extract from another DB
5199 else
5200 accmgr.GetName (account_id,account_name);
5201
5202 // No SQL injection. id is uint32.
5203 QueryResult *banInfo = loginDatabase.PQuery("SELECT bandate,unbandate,bannedby,banreason FROM account_banned WHERE id = %u ORDER BY unbandate", account_id);
5204 if (banInfo)
5205 {
5206 Field *fields2 = banInfo->Fetch();
5207 do
5208 {
5209 time_t t_ban = fields2[0].GetUInt64();
5210 tm* aTm_ban = localtime(&t_ban);
5211
5212 if (fields2[0].GetUInt64() == fields2[1].GetUInt64())
5213 {
5214 PSendSysMessage("|%-15.15s|%02d-%02d-%02d %02d:%02d| permanent |%-15.15s|%-15.15s|",
5215 account_name.c_str(),aTm_ban->tm_year%100, aTm_ban->tm_mon+1, aTm_ban->tm_mday, aTm_ban->tm_hour, aTm_ban->tm_min,
5216 fields2[2].GetString(),fields2[3].GetString());
5217 }
5218 else
5219 {
5220 time_t t_unban = fields2[1].GetUInt64();
5221 tm* aTm_unban = localtime(&t_unban);
5222 PSendSysMessage("|%-15.15s|%02d-%02d-%02d %02d:%02d|%02d-%02d-%02d %02d:%02d|%-15.15s|%-15.15s|",
5223 account_name.c_str(),aTm_ban->tm_year%100, aTm_ban->tm_mon+1, aTm_ban->tm_mday, aTm_ban->tm_hour, aTm_ban->tm_min,
5224 aTm_unban->tm_year%100, aTm_unban->tm_mon+1, aTm_unban->tm_mday, aTm_unban->tm_hour, aTm_unban->tm_min,
5225 fields2[2].GetString(),fields2[3].GetString());
5226 }
5227 }while ( banInfo->NextRow() );
5228 delete banInfo;
5229 }
5230 }while( result->NextRow() );
5231 SendSysMessage("===============================================================================");
5232 }
5233
5234 delete result;
5235 return true;
5236 }
5237
5238 bool ChatHandler::HandleBanListIPCommand(const char* args)
5239 {
5240 loginDatabase.Execute("DELETE FROM ip_banned WHERE unbandate<=UNIX_TIMESTAMP() AND unbandate<>bandate");
5241
5242 char* cFilter = strtok((char*)args, " ");
5243 std::string filter = cFilter ? cFilter : "";
5244 loginDatabase.escape_string(filter);
5245
5246 QueryResult* result;
5247
5248 if(filter.empty())
5249 {
5250 result = loginDatabase.Query ("SELECT ip,bandate,unbandate,bannedby,banreason FROM ip_banned"
5251 " WHERE (bandate=unbandate OR unbandate>UNIX_TIMESTAMP())"
5252 " ORDER BY unbandate" );
5253 }
5254 else
5255 {
5256 result = loginDatabase.PQuery( "SELECT ip,bandate,unbandate,bannedby,banreason FROM ip_banned"
5257 " WHERE (bandate=unbandate OR unbandate>UNIX_TIMESTAMP()) AND ip "_LIKE_" "_CONCAT3_("'%%'","'%s'","'%%'")
5258 " ORDER BY unbandate",filter.c_str() );
5259 }
5260
5261 if(!result)
5262 {
5263 PSendSysMessage(LANG_BANLIST_NOIP);
5264 return true;
5265 }
5266
5267 PSendSysMessage(LANG_BANLIST_MATCHINGIP);
5268 // Chat short output
5269 if(m_session)
5270 {
5271 do
5272 {
5273 Field* fields = result->Fetch();
5274 PSendSysMessage("%s",fields[0].GetString());
5275 } while (result->NextRow());
5276 }
5277 // Console wide output
5278 else
5279 {
5280 SendSysMessage(LANG_BANLIST_IPS);
5281 SendSysMessage("===============================================================================");
5282 SendSysMessage(LANG_BANLIST_IPS_HEADER);
5283 do
5284 {
5285 SendSysMessage("-------------------------------------------------------------------------------");
5286 Field *fields = result->Fetch();
5287 time_t t_ban = fields[1].GetUInt64();
5288 tm* aTm_ban = localtime(&t_ban);
5289 if ( fields[1].GetUInt64() == fields[2].GetUInt64() )
5290 {
5291 PSendSysMessage("|%-15.15s|%02d-%02d-%02d %02d:%02d| permanent |%-15.15s|%-15.15s|",
5292 fields[0].GetString(), aTm_ban->tm_year%100, aTm_ban->tm_mon+1, aTm_ban->tm_mday, aTm_ban->tm_hour, aTm_ban->tm_min,
5293 fields[3].GetString(), fields[4].GetString());
5294 }
5295 else
5296 {
5297 time_t t_unban = fields[2].GetUInt64();
5298 tm* aTm_unban = localtime(&t_unban);
5299 PSendSysMessage("|%-15.15s|%02d-%02d-%02d %02d:%02d|%02d-%02d-%02d %02d:%02d|%-15.15s|%-15.15s|",
5300 fields[0].GetString(), aTm_ban->tm_year%100, aTm_ban->tm_mon+1, aTm_ban->tm_mday, aTm_ban->tm_hour, aTm_ban->tm_min,
5301 aTm_unban->tm_year%100, aTm_unban->tm_mon+1, aTm_unban->tm_mday, aTm_unban->tm_hour, aTm_unban->tm_min,
5302 fields[3].GetString(), fields[4].GetString());
5303 }
5304 }while( result->NextRow() );
5305 SendSysMessage("===============================================================================");
5306 }
5307
5308 delete result;
5309 return true;
5310 }
5311
5312 bool ChatHandler::HandleRespawnCommand(const char* /*args*/)
5313 {
5314 Player* pl = m_session->GetPlayer();
5315
5316 // accept only explicitly selected target (not implicitly self targeting case)
5317 Unit* target = getSelectedUnit();
5318 if(pl->GetSelection() && target)
5319 {
5320 if(target->GetTypeId()!=TYPEID_UNIT)
5321 {
5322 SendSysMessage(LANG_SELECT_CREATURE);
5323 SetSentErrorMessage(true);
5324 return false;
5325 }
5326
5327 if(target->isDead())
5328 ((Creature*)target)->Respawn();
5329 return true;
5330 }
5331
5332 CellPair p(MaNGOS::ComputeCellPair(pl->GetPositionX(), pl->GetPositionY()));
5333 Cell cell(p);
5334 cell.data.Part.reserved = ALL_DISTRICT;
5335 cell.SetNoCreate();
5336
5337 MaNGOS::RespawnDo u_do;
5338 MaNGOS::WorldObjectWorker<MaNGOS::RespawnDo> worker(pl,u_do);
5339
5340 TypeContainerVisitor<MaNGOS::WorldObjectWorker<MaNGOS::RespawnDo>, GridTypeMapContainer > obj_worker(worker);
5341 CellLock<GridReadGuard> cell_lock(cell, p);
5342 cell_lock->Visit(cell_lock, obj_worker, *pl->GetMap());
5343
5344 return true;
5345 }
5346
5347 bool ChatHandler::HandleGMFlyCommand(const char* args)
5348 {
5349 if (!*args)
5350 return false;
5351
5352 Player *target = getSelectedPlayer();
5353 if (!target)
5354 target = m_session->GetPlayer();
5355
5356 WorldPacket data(12);
5357 if (strncmp(args, "on", 3) == 0)
5358 data.SetOpcode(SMSG_MOVE_SET_CAN_FLY);
5359 else if (strncmp(args, "off", 4) == 0)
5360 data.SetOpcode(SMSG_MOVE_UNSET_CAN_FLY);
5361 else
5362 {
5363 SendSysMessage(LANG_USE_BOL);
5364 return false;
5365 }
5366 data.append(target->GetPackGUID());
5367 data << uint32(0); // unknown
5368 target->SendMessageToSet(&data, true);
5369 PSendSysMessage(LANG_COMMAND_FLYMODE_STATUS, GetNameLink(target).c_str(), args);
5370 return true;
5371 }
5372
5373 bool ChatHandler::HandlePDumpLoadCommand(const char *args)
5374 {
5375 if (!*args)
5376 return false;
5377
5378 char * file = strtok((char*)args, " ");
5379 if (!file)
5380 return false;
5381
5382 char * account = strtok(NULL, " ");
5383 if (!account)
5384 return false;
5385
5386 std::string account_name = account;
5387 if (!AccountMgr::normalizeString(account_name))
5388 {
5389 PSendSysMessage(LANG_ACCOUNT_NOT_EXIST,account_name.c_str());
5390 SetSentErrorMessage(true);
5391 return false;
5392 }
5393
5394 uint32 account_id = accmgr.GetId(account_name);
5395 if (!account_id)
5396 {
5397 account_id = atoi(account); // use original string
5398 if (!account_id)
5399 {
5400 PSendSysMessage(LANG_ACCOUNT_NOT_EXIST,account_name.c_str());
5401 SetSentErrorMessage(true);
5402 return false;
5403 }
5404 }
5405
5406 if (!accmgr.GetName(account_id,account_name))
5407 {
5408 PSendSysMessage(LANG_ACCOUNT_NOT_EXIST,account_name.c_str());
5409 SetSentErrorMessage(true);
5410 return false;
5411 }
5412
5413 char* guid_str = NULL;
5414 char* name_str = strtok(NULL, " ");
5415
5416 std::string name;
5417 if (name_str)
5418 {
5419 name = name_str;
5420 // normalize the name if specified and check if it exists
5421 if (!normalizePlayerName(name))
5422 {
5423 PSendSysMessage(LANG_INVALID_CHARACTER_NAME);
5424 SetSentErrorMessage(true);
5425 return false;
5426 }
5427
5428 if (ObjectMgr::CheckPlayerName(name,true) != CHAR_NAME_SUCCESS)
5429 {
5430 PSendSysMessage(LANG_INVALID_CHARACTER_NAME);
5431 SetSentErrorMessage(true);
5432 return false;
5433 }
5434
5435 guid_str = strtok(NULL, " ");
5436 }
5437
5438 uint32 guid = 0;
5439
5440 if (guid_str)
5441 {
5442 guid = atoi(guid_str);
5443 if (!guid)
5444 {
5445 PSendSysMessage(LANG_INVALID_CHARACTER_GUID);
5446 SetSentErrorMessage(true);
5447 return false;
5448 }
5449
5450 if (objmgr.GetPlayerAccountIdByGUID(guid))
5451 {
5452 PSendSysMessage(LANG_CHARACTER_GUID_IN_USE,guid);
5453 SetSentErrorMessage(true);
5454 return false;
5455 }
5456 }
5457
5458 switch(PlayerDumpReader().LoadDump(file, account_id, name, guid))
5459 {
5460 case DUMP_SUCCESS:
5461 PSendSysMessage(LANG_COMMAND_IMPORT_SUCCESS);
5462 break;
5463 case DUMP_FILE_OPEN_ERROR:
5464 PSendSysMessage(LANG_FILE_OPEN_FAIL,file);
5465 SetSentErrorMessage(true);
5466 return false;
5467 case DUMP_FILE_BROKEN:
5468 PSendSysMessage(LANG_DUMP_BROKEN,file);
5469 SetSentErrorMessage(true);
5470 return false;
5471 case DUMP_TOO_MANY_CHARS:
5472 PSendSysMessage(LANG_ACCOUNT_CHARACTER_LIST_FULL,account_name.c_str(),account_id);
5473 SetSentErrorMessage(true);
5474 return false;
5475 default:
5476 PSendSysMessage(LANG_COMMAND_IMPORT_FAILED);
5477 SetSentErrorMessage(true);
5478 return false;
5479 }
5480
5481 return true;
5482 }
5483
5484 bool ChatHandler::HandlePDumpWriteCommand(const char *args)
5485 {
5486 if (!*args)
5487 return false;
5488
5489 char* file = strtok((char*)args, " ");
5490 char* p2 = strtok(NULL, " ");
5491
5492 if(!file || !p2)
5493 return false;
5494
5495 uint32 guid;
5496 // character name can't start from number
5497 if (isNumeric(p2[0]))
5498 guid = atoi(p2);
5499 else
5500 {
5501 std::string name = extractPlayerNameFromLink(p2);
5502 if(name.empty())
5503 {
5504 SendSysMessage(LANG_PLAYER_NOT_FOUND);
5505 SetSentErrorMessage(true);
5506 return false;
5507 }
5508
5509 guid = objmgr.GetPlayerGUIDByName(name);
5510 }
5511
5512 if(!objmgr.GetPlayerAccountIdByGUID(guid))
5513 {
5514 PSendSysMessage(LANG_PLAYER_NOT_FOUND);
5515 SetSentErrorMessage(true);
5516 return false;
5517 }
5518
5519 switch(PlayerDumpWriter().WriteDump(file, guid))
5520 {
5521 case DUMP_SUCCESS:
5522 PSendSysMessage(LANG_COMMAND_EXPORT_SUCCESS);
5523 break;
5524 case DUMP_FILE_OPEN_ERROR:
5525 PSendSysMessage(LANG_FILE_OPEN_FAIL,file);
5526 SetSentErrorMessage(true);
5527 return false;
5528 default:
5529 PSendSysMessage(LANG_COMMAND_EXPORT_FAILED);
5530 SetSentErrorMessage(true);
5531 return false;
5532 }
5533
5534 return true;
5535 }
5536
5537 bool ChatHandler::HandleMovegensCommand(const char* /*args*/)
5538 {
5539 Unit* unit = getSelectedUnit();
5540 if(!unit)
5541 {
5542 SendSysMessage(LANG_SELECT_CHAR_OR_CREATURE);
5543 SetSentErrorMessage(true);
5544 return false;
5545 }
5546
5547 PSendSysMessage(LANG_MOVEGENS_LIST,(unit->GetTypeId()==TYPEID_PLAYER ? "Player" : "Creature" ),unit->GetGUIDLow());
5548
5549 MotionMaster* mm = unit->GetMotionMaster();
5550 for(MotionMaster::const_iterator itr = mm->begin(); itr != mm->end(); ++itr)
5551 {
5552 switch((*itr)->GetMovementGeneratorType())
5553 {
5554 case IDLE_MOTION_TYPE: SendSysMessage(LANG_MOVEGENS_IDLE); break;
5555 case RANDOM_MOTION_TYPE: SendSysMessage(LANG_MOVEGENS_RANDOM); break;
5556 case WAYPOINT_MOTION_TYPE: SendSysMessage(LANG_MOVEGENS_WAYPOINT); break;
5557 case ANIMAL_RANDOM_MOTION_TYPE: SendSysMessage(LANG_MOVEGENS_ANIMAL_RANDOM); break;
5558 case CONFUSED_MOTION_TYPE: SendSysMessage(LANG_MOVEGENS_CONFUSED); break;
5559 case TARGETED_MOTION_TYPE:
5560 {
5561 if(unit->GetTypeId()==TYPEID_PLAYER)
5562 {
5563 TargetedMovementGenerator<Player> const* mgen = static_cast<TargetedMovementGenerator<Player> const*>(*itr);
5564 Unit* target = mgen->GetTarget();
5565 if(target)
5566 PSendSysMessage(LANG_MOVEGENS_TARGETED_PLAYER,target->GetName(),target->GetGUIDLow());
5567 else
5568 SendSysMessage(LANG_MOVEGENS_TARGETED_NULL);
5569 }
5570 else
5571 {
5572 TargetedMovementGenerator<Creature> const* mgen = static_cast<TargetedMovementGenerator<Creature> const*>(*itr);
5573 Unit* target = mgen->GetTarget();
5574 if(target)
5575 PSendSysMessage(LANG_MOVEGENS_TARGETED_CREATURE,target->GetName(),target->GetGUIDLow());
5576 else
5577 SendSysMessage(LANG_MOVEGENS_TARGETED_NULL);
5578 }
5579 break;
5580 }
5581 case HOME_MOTION_TYPE:
5582 if(unit->GetTypeId()==TYPEID_UNIT)
5583 {
5584 float x,y,z;
5585 (*itr)->GetDestination(x,y,z);
5586 PSendSysMessage(LANG_MOVEGENS_HOME_CREATURE,x,y,z);
5587 }
5588 else
5589 SendSysMessage(LANG_MOVEGENS_HOME_PLAYER);
5590 break;
5591 case FLIGHT_MOTION_TYPE: SendSysMessage(LANG_MOVEGENS_FLIGHT); break;
5592 case POINT_MOTION_TYPE:
5593 {
5594 float x,y,z;
5595 (*itr)->GetDestination(x,y,z);
5596 PSendSysMessage(LANG_MOVEGENS_POINT,x,y,z);
5597 break;
5598 }
5599 case FLEEING_MOTION_TYPE: SendSysMessage(LANG_MOVEGENS_FEAR); break;
5600 case DISTRACT_MOTION_TYPE: SendSysMessage(LANG_MOVEGENS_DISTRACT); break;
5601 default:
5602 PSendSysMessage(LANG_MOVEGENS_UNKNOWN,(*itr)->GetMovementGeneratorType());
5603 break;
5604 }
5605 }
5606 return true;
5607 }
5608
5609 bool ChatHandler::HandleServerPLimitCommand(const char *args)
5610 {
5611 if(*args)
5612 {
5613 char* param = strtok((char*)args, " ");
5614 if(!param)
5615 return false;
5616
5617 int l = strlen(param);
5618
5619 if( strncmp(param,"player",l) == 0 )
5620 sWorld.SetPlayerLimit(-SEC_PLAYER);
5621 else if(strncmp(param,"moderator",l) == 0 )
5622 sWorld.SetPlayerLimit(-SEC_MODERATOR);
5623 else if(strncmp(param,"gamemaster",l) == 0 )
5624 sWorld.SetPlayerLimit(-SEC_GAMEMASTER);
5625 else if(strncmp(param,"administrator",l) == 0 )
5626 sWorld.SetPlayerLimit(-SEC_ADMINISTRATOR);
5627 else if(strncmp(param,"reset",l) == 0 )
5628 sWorld.SetPlayerLimit( sConfig.GetIntDefault("PlayerLimit", DEFAULT_PLAYER_LIMIT) );
5629 else
5630 {
5631 int val = atoi(param);
5632 if(val < -SEC_ADMINISTRATOR) val = -SEC_ADMINISTRATOR;
5633
5634 sWorld.SetPlayerLimit(val);
5635 }
5636
5637 // kick all low security level players
5638 if(sWorld.GetPlayerAmountLimit() > SEC_PLAYER)
5639 sWorld.KickAllLess(sWorld.GetPlayerSecurityLimit());
5640 }
5641
5642 uint32 pLimit = sWorld.GetPlayerAmountLimit();
5643 AccountTypes allowedAccountType = sWorld.GetPlayerSecurityLimit();
5644 char const* secName = "";
5645 switch(allowedAccountType)
5646 {
5647 case SEC_PLAYER: secName = "Player"; break;
5648 case SEC_MODERATOR: secName = "Moderator"; break;
5649 case SEC_GAMEMASTER: secName = "Gamemaster"; break;
5650 case SEC_ADMINISTRATOR: secName = "Administrator"; break;
5651 default: secName = "<unknown>"; break;
5652 }
5653
5654 PSendSysMessage("Player limits: amount %u, min. security level %s.",pLimit,secName);
5655
5656 return true;
5657 }
5658
5659 bool ChatHandler::HandleCastCommand(const char* args)
5660 {
5661 if(!*args)
5662 return false;
5663
5664 Unit* target = getSelectedUnit();
5665
5666 if(!target)
5667 {
5668 SendSysMessage(LANG_SELECT_CHAR_OR_CREATURE);
5669 SetSentErrorMessage(true);
5670 return false;
5671 }
5672
5673 // number or [name] Shift-click form |color|Hspell:spell_id|h[name]|h|r or Htalent form
5674 uint32 spell = extractSpellIdFromLink((char*)args);
5675 if(!spell)
5676 return false;
5677
5678 SpellEntry const* spellInfo = sSpellStore.LookupEntry(spell);
5679 if(!spellInfo)
5680 return false;
5681
5682 if(!SpellMgr::IsSpellValid(spellInfo,m_session->GetPlayer()))
5683 {
5684 PSendSysMessage(LANG_COMMAND_SPELL_BROKEN,spell);
5685 SetSentErrorMessage(true);
5686 return false;
5687 }
5688
5689 char* trig_str = strtok(NULL, " ");
5690 if(trig_str)
5691 {
5692 int l = strlen(trig_str);
5693 if(strncmp(trig_str,"triggered",l) != 0 )
5694 return false;
5695 }
5696
5697 bool triggered = (trig_str != NULL);
5698
5699 m_session->GetPlayer()->CastSpell(target,spell,triggered);
5700
5701 return true;
5702 }
5703
5704 bool ChatHandler::HandleCastBackCommand(const char* args)
5705 {
5706 Creature* caster = getSelectedCreature();
5707
5708 if(!caster)
5709 {
5710 SendSysMessage(LANG_SELECT_CHAR_OR_CREATURE);
5711 SetSentErrorMessage(true);
5712 return false;
5713 }
5714
5715 // number or [name] Shift-click form |color|Hspell:spell_id|h[name]|h|r
5716 // number or [name] Shift-click form |color|Hspell:spell_id|h[name]|h|r or Htalent form
5717 uint32 spell = extractSpellIdFromLink((char*)args);
5718 if(!spell || !sSpellStore.LookupEntry(spell))
5719 return false;
5720
5721 char* trig_str = strtok(NULL, " ");
5722 if(trig_str)
5723 {
5724 int l = strlen(trig_str);
5725 if(strncmp(trig_str,"triggered",l) != 0 )
5726 return false;
5727 }
5728
5729 bool triggered = (trig_str != NULL);
5730
5731 // update orientation at server
5732 caster->SetOrientation(caster->GetAngle(m_session->GetPlayer()));
5733
5734 // and client
5735 WorldPacket data;
5736 caster->BuildHeartBeatMsg(&data);
5737 caster->SendMessageToSet(&data,true);
5738
5739 caster->CastSpell(m_session->GetPlayer(),spell,triggered);
5740
5741 return true;
5742 }
5743
5744 bool ChatHandler::HandleCastDistCommand(const char* args)
5745 {
5746 if(!*args)
5747 return false;
5748
5749 // number or [name] Shift-click form |color|Hspell:spell_id|h[name]|h|r or Htalent form
5750 uint32 spell = extractSpellIdFromLink((char*)args);
5751 if(!spell)
5752 return false;
5753
5754 SpellEntry const* spellInfo = sSpellStore.LookupEntry(spell);
5755 if(!spellInfo)
5756 return false;
5757
5758 if(!SpellMgr::IsSpellValid(spellInfo,m_session->GetPlayer()))
5759 {
5760 PSendSysMessage(LANG_COMMAND_SPELL_BROKEN,spell);
5761 SetSentErrorMessage(true);
5762 return false;
5763 }
5764
5765 char *distStr = strtok(NULL, " ");
5766
5767 float dist = 0;
5768
5769 if(distStr)
5770 sscanf(distStr, "%f", &dist);
5771
5772 char* trig_str = strtok(NULL, " ");
5773 if(trig_str)
5774 {
5775 int l = strlen(trig_str);
5776 if(strncmp(trig_str,"triggered",l) != 0 )
5777 return false;
5778 }
5779
5780 bool triggered = (trig_str != NULL);
5781
5782 float x,y,z;
5783 m_session->GetPlayer()->GetClosePoint(x,y,z,dist);
5784
5785 m_session->GetPlayer()->CastSpell(x,y,z,spell,triggered);
5786 return true;
5787 }
5788
5789 bool ChatHandler::HandleCastTargetCommand(const char* args)
5790 {
5791 Creature* caster = getSelectedCreature();
5792
5793 if(!caster)
5794 {
5795 SendSysMessage(LANG_SELECT_CHAR_OR_CREATURE);
5796 SetSentErrorMessage(true);
5797 return false;
5798 }
5799
5800 if(!caster->getVictim())
5801 {
5802 SendSysMessage(LANG_SELECTED_TARGET_NOT_HAVE_VICTIM);
5803 SetSentErrorMessage(true);
5804 return false;
5805 }
5806
5807 // number or [name] Shift-click form |color|Hspell:spell_id|h[name]|h|r or Htalent form
5808 uint32 spell = extractSpellIdFromLink((char*)args);
5809 if(!spell || !sSpellStore.LookupEntry(spell))
5810 return false;
5811
5812 char* trig_str = strtok(NULL, " ");
5813 if(trig_str)
5814 {
5815 int l = strlen(trig_str);
5816 if(strncmp(trig_str,"triggered",l) != 0 )
5817 return false;
5818 }
5819
5820 bool triggered = (trig_str != NULL);
5821
5822 // update orientation at server
5823 caster->SetOrientation(caster->GetAngle(m_session->GetPlayer()));
5824
5825 // and client
5826 WorldPacket data;
5827 caster->BuildHeartBeatMsg(&data);
5828 caster->SendMessageToSet(&data,true);
5829
5830 caster->CastSpell(caster->getVictim(),spell,triggered);
5831
5832 return true;
5833 }
5834
5835 /*
5836 ComeToMe command REQUIRED for 3rd party scripting library to have access to PointMovementGenerator
5837 Without this function 3rd party scripting library will get linking errors (unresolved external)
5838 when attempting to use the PointMovementGenerator
5839 */
5840 bool ChatHandler::HandleComeToMeCommand(const char *args)
5841 {
5842 Creature* caster = getSelectedCreature();
5843
5844 if(!caster)
5845 {
5846 SendSysMessage(LANG_SELECT_CREATURE);
5847 SetSentErrorMessage(true);
5848 return false;
5849 }
5850
5851 char* newFlagStr = strtok((char*)args, " ");
5852
5853 if(!newFlagStr)
5854 return false;
5855
5856 uint32 newFlags = atoi(newFlagStr);
5857
5858 caster->SetMonsterMoveFlags(MonsterMovementFlags(newFlags));
5859
5860 Player* pl = m_session->GetPlayer();
5861
5862 caster->GetMotionMaster()->MovePoint(0, pl->GetPositionX(), pl->GetPositionY(), pl->GetPositionZ());
5863 return true;
5864 }
5865
5866 bool ChatHandler::HandleCastSelfCommand(const char* args)
5867 {
5868 if(!*args)
5869 return false;
5870
5871 Unit* target = getSelectedUnit();
5872
5873 if(!target)
5874 {
5875 SendSysMessage(LANG_SELECT_CHAR_OR_CREATURE);
5876 SetSentErrorMessage(true);
5877 return false;
5878 }
5879
5880 // number or [name] Shift-click form |color|Hspell:spell_id|h[name]|h|r or Htalent form
5881 uint32 spell = extractSpellIdFromLink((char*)args);
5882 if(!spell)
5883 return false;
5884
5885 SpellEntry const* spellInfo = sSpellStore.LookupEntry(spell);
5886 if(!spellInfo)
5887 return false;
5888
5889 if(!SpellMgr::IsSpellValid(spellInfo,m_session->GetPlayer()))
5890 {
5891 PSendSysMessage(LANG_COMMAND_SPELL_BROKEN,spell);
5892 SetSentErrorMessage(true);
5893 return false;
5894 }
5895
5896 target->CastSpell(target,spell,false);
5897
5898 return true;
5899 }
5900
5901 std::string GetTimeString(uint32 time)
5902 {
5903 uint16 days = time / DAY, hours = (time % DAY) / HOUR, minute = (time % HOUR) / MINUTE;
5904 std::ostringstream ss;
5905 if(days) ss << days << "d ";
5906 if(hours) ss << hours << "h ";
5907 ss << minute << "m";
5908 return ss.str();
5909 }
5910
5911 bool ChatHandler::HandleInstanceListBindsCommand(const char* /*args*/)
5912 {
5913 Player* player = getSelectedPlayer();
5914 if (!player) player = m_session->GetPlayer();
5915 uint32 counter = 0;
5916 for(uint8 i = 0; i < MAX_DIFFICULTY; ++i)
5917 {
5918 Player::BoundInstancesMap &binds = player->GetBoundInstances(Difficulty(i));
5919 for(Player::BoundInstancesMap::const_iterator itr = binds.begin(); itr != binds.end(); ++itr)
5920 {
5921 InstanceSave *save = itr->second.save;
5922 std::string timeleft = GetTimeString(save->GetResetTime() - time(NULL));
5923 PSendSysMessage("map: %d inst: %d perm: %s diff: %s canReset: %s TTR: %s", itr->first, save->GetInstanceId(), itr->second.perm ? "yes" : "no", save->GetDifficulty() == DUNGEON_DIFFICULTY_NORMAL ? "normal" : "heroic", save->CanReset() ? "yes" : "no", timeleft.c_str());
5924 counter++;
5925 }
5926 }
5927 PSendSysMessage("player binds: %d", counter);
5928 counter = 0;
5929 Group *group = player->GetGroup();
5930 if(group)
5931 {
5932 for(uint8 i = 0; i < MAX_DIFFICULTY; ++i)
5933 {
5934 Group::BoundInstancesMap &binds = group->GetBoundInstances(Difficulty(i));
5935 for(Group::BoundInstancesMap::const_iterator itr = binds.begin(); itr != binds.end(); ++itr)
5936 {
5937 InstanceSave *save = itr->second.save;
5938 std::string timeleft = GetTimeString(save->GetResetTime() - time(NULL));
5939 PSendSysMessage("map: %d inst: %d perm: %s diff: %s canReset: %s TTR: %s", itr->first, save->GetInstanceId(), itr->second.perm ? "yes" : "no", save->GetDifficulty() == DUNGEON_DIFFICULTY_NORMAL ? "normal" : "heroic", save->CanReset() ? "yes" : "no", timeleft.c_str());
5940 counter++;
5941 }
5942 }
5943 }
5944 PSendSysMessage("group binds: %d", counter);
5945
5946 return true;
5947 }
5948
5949 bool ChatHandler::HandleInstanceUnbindCommand(const char* args)
5950 {
5951 if(!*args)
5952 return false;
5953
5954 std::string cmd = args;
5955 if(cmd == "all")
5956 {
5957 Player* player = getSelectedPlayer();
5958 if (!player) player = m_session->GetPlayer();
5959 uint32 counter = 0;
5960 for(uint8 i = 0; i < MAX_DIFFICULTY; ++i)
5961 {
5962 Player::BoundInstancesMap &binds = player->GetBoundInstances(Difficulty(i));
5963 for(Player::BoundInstancesMap::iterator itr = binds.begin(); itr != binds.end();)
5964 {
5965 if(itr->first != player->GetMapId())
5966 {
5967 InstanceSave *save = itr->second.save;
5968 std::string timeleft = GetTimeString(save->GetResetTime() - time(NULL));
5969 PSendSysMessage("unbinding map: %d inst: %d perm: %s diff: %s canReset: %s TTR: %s", itr->first, save->GetInstanceId(), itr->second.perm ? "yes" : "no", save->GetDifficulty() == DUNGEON_DIFFICULTY_NORMAL ? "normal" : "heroic", save->CanReset() ? "yes" : "no", timeleft.c_str());
5970 player->UnbindInstance(itr, Difficulty(i));
5971 counter++;
5972 }
5973 else
5974 ++itr;
5975 }
5976 }
5977 PSendSysMessage("instances unbound: %d", counter);
5978 }
5979 return true;
5980 }
5981
5982 bool ChatHandler::HandleInstanceStatsCommand(const char* /*args*/)
5983 {
5984 PSendSysMessage("instances loaded: %d", MapManager::Instance().GetNumInstances());
5985 PSendSysMessage("players in instances: %d", MapManager::Instance().GetNumPlayersInInstances());
5986 PSendSysMessage("instance saves: %d", sInstanceSaveManager.GetNumInstanceSaves());
5987 PSendSysMessage("players bound: %d", sInstanceSaveManager.GetNumBoundPlayersTotal());
5988 PSendSysMessage("groups bound: %d", sInstanceSaveManager.GetNumBoundGroupsTotal());
5989 return true;
5990 }
5991
5992 bool ChatHandler::HandleInstanceSaveDataCommand(const char * /*args*/)
5993 {
5994 Player* pl = m_session->GetPlayer();
5995
5996 Map* map = pl->GetMap();
5997 if (!map->IsDungeon())
5998 {
5999 PSendSysMessage("Map is not a dungeon.");
6000 SetSentErrorMessage(true);
6001 return false;
6002 }
6003
6004 if (!((InstanceMap*)map)->GetInstanceData())
6005 {
6006 PSendSysMessage("Map has no instance data.");
6007 SetSentErrorMessage(true);
6008 return false;
6009 }
6010
6011 ((InstanceMap*)map)->GetInstanceData()->SaveToDB();
6012 return true;
6013 }
6014
6015 /// Display the list of GMs
6016 bool ChatHandler::HandleGMListFullCommand(const char* /*args*/)
6017 {
6018 ///- Get the accounts with GM Level >0
6019 QueryResult *result = loginDatabase.Query( "SELECT username,gmlevel FROM account WHERE gmlevel > 0" );
6020 if(result)
6021 {
6022 SendSysMessage(LANG_GMLIST);
6023 SendSysMessage("========================");
6024 SendSysMessage(LANG_GMLIST_HEADER);
6025 SendSysMessage("========================");
6026
6027 ///- Circle through them. Display username and GM level
6028 do
6029 {
6030 Field *fields = result->Fetch();
6031 PSendSysMessage("|%15s|%6s|", fields[0].GetString(),fields[1].GetString());
6032 }while( result->NextRow() );
6033
6034 PSendSysMessage("========================");
6035 delete result;
6036 }
6037 else
6038 PSendSysMessage(LANG_GMLIST_EMPTY);
6039 return true;
6040 }
6041
6042 /// Define the 'Message of the day' for the realm
6043 bool ChatHandler::HandleServerSetMotdCommand(const char* args)
6044 {
6045 sWorld.SetMotd(args);
6046 PSendSysMessage(LANG_MOTD_NEW, args);
6047 return true;
6048 }
6049
6050 /// Set/Unset the expansion level for an account
6051 bool ChatHandler::HandleAccountSetAddonCommand(const char* args)
6052 {
6053 ///- Get the command line arguments
6054 char *szAcc = strtok((char*)args," ");
6055 char *szExp = strtok(NULL," ");
6056
6057 if(!szAcc)
6058 return false;
6059
6060 std::string account_name;
6061 uint32 account_id;
6062
6063 if (!szExp)
6064 {
6065 Player* player = getSelectedPlayer();
6066 if (!player)
6067 return false;
6068
6069 account_id = player->GetSession()->GetAccountId();
6070 accmgr.GetName(account_id,account_name);
6071 szExp = szAcc;
6072 }
6073 else
6074 {
6075 ///- Convert Account name to Upper Format
6076 account_name = szAcc;
6077 if (!AccountMgr::normalizeString(account_name))
6078 {
6079 PSendSysMessage(LANG_ACCOUNT_NOT_EXIST,account_name.c_str());
6080 SetSentErrorMessage(true);
6081 return false;
6082 }
6083
6084 account_id = accmgr.GetId(account_name);
6085 if (!account_id)
6086 {
6087 PSendSysMessage(LANG_ACCOUNT_NOT_EXIST,account_name.c_str());
6088 SetSentErrorMessage(true);
6089 return false;
6090 }
6091
6092 }
6093
6094 // Let set addon state only for lesser (strong) security level
6095 // or to self account
6096 if (m_session && m_session->GetAccountId () != account_id &&
6097 HasLowerSecurityAccount (NULL,account_id,true))
6098 return false;
6099
6100 int lev=atoi(szExp); //get int anyway (0 if error)
6101 if(lev < 0)
6102 return false;
6103
6104 // No SQL injection
6105 loginDatabase.PExecute("UPDATE account SET expansion = '%d' WHERE id = '%u'",lev,account_id);
6106 PSendSysMessage(LANG_ACCOUNT_SETADDON,account_name.c_str(),account_id,lev);
6107 return true;
6108 }
6109
6110 //Send items by mail
6111 bool ChatHandler::HandleSendItemsCommand(const char* args)
6112 {
6113 // format: name "subject text" "mail text" item1[:count1] item2[:count2] ... item12[:count12]
6114 Player* receiver;
6115 uint64 receiver_guid;
6116 std::string receiver_name;
6117 if(!extractPlayerTarget((char*)args,&receiver,&receiver_guid,&receiver_name))
6118 return false;
6119
6120 char* tail1 = strtok(NULL, "");
6121 if(!tail1)
6122 return false;
6123
6124 char* msgSubject = extractQuotedArg(tail1);
6125 if (!msgSubject)
6126 return false;
6127
6128 char* tail2 = strtok(NULL, "");
6129 if(!tail2)
6130 return false;
6131
6132 char* msgText = extractQuotedArg(tail2);
6133 if (!msgText)
6134 return false;
6135
6136 // msgSubject, msgText isn't NUL after prev. check
6137 std::string subject = msgSubject;
6138 std::string text = msgText;
6139
6140 // extract items
6141 typedef std::pair<uint32,uint32> ItemPair;
6142 typedef std::list< ItemPair > ItemPairs;
6143 ItemPairs items;
6144
6145 // get all tail string
6146 char* tail = strtok(NULL, "");
6147
6148 // get from tail next item str
6149 while(char* itemStr = strtok(tail, " "))
6150 {
6151 // and get new tail
6152 tail = strtok(NULL, "");
6153
6154 // parse item str
6155 char* itemIdStr = strtok(itemStr, ":");
6156 char* itemCountStr = strtok(NULL, " ");
6157
6158 uint32 item_id = atoi(itemIdStr);
6159 if(!item_id)
6160 return false;
6161
6162 ItemPrototype const* item_proto = objmgr.GetItemPrototype(item_id);
6163 if(!item_proto)
6164 {
6165 PSendSysMessage(LANG_COMMAND_ITEMIDINVALID, item_id);
6166 SetSentErrorMessage(true);
6167 return false;
6168 }
6169
6170 uint32 item_count = itemCountStr ? atoi(itemCountStr) : 1;
6171 if (item_count < 1 || (item_proto->MaxCount > 0 && item_count > uint32(item_proto->MaxCount)))
6172 {
6173 PSendSysMessage(LANG_COMMAND_INVALID_ITEM_COUNT, item_count,item_id);
6174 SetSentErrorMessage(true);
6175 return false;
6176 }
6177
6178 while(item_count > item_proto->GetMaxStackSize())
6179 {
6180 items.push_back(ItemPair(item_id,item_proto->GetMaxStackSize()));
6181 item_count -= item_proto->GetMaxStackSize();
6182 }
6183
6184 items.push_back(ItemPair(item_id,item_count));
6185
6186 if(items.size() > MAX_MAIL_ITEMS)
6187 {
6188 PSendSysMessage(LANG_COMMAND_MAIL_ITEMS_LIMIT, MAX_MAIL_ITEMS);
6189 SetSentErrorMessage(true);
6190 return false;
6191 }
6192 }
6193
6194 // from console show not existed sender
6195 uint32 sender_guidlo = m_session ? m_session->GetPlayer()->GetGUIDLow() : 0;
6196
6197 uint32 messagetype = MAIL_NORMAL;
6198 uint32 stationery = MAIL_STATIONERY_GM;
6199 uint32 itemTextId = !text.empty() ? objmgr.CreateItemText( text ) : 0;
6200
6201 // fill mail
6202 MailItemsInfo mi; // item list preparing
6203
6204 for(ItemPairs::const_iterator itr = items.begin(); itr != items.end(); ++itr)
6205 {
6206 if(Item* item = Item::CreateItem(itr->first,itr->second,m_session ? m_session->GetPlayer() : 0))
6207 {
6208 item->SaveToDB(); // save for prevent lost at next mail load, if send fail then item will deleted
6209 mi.AddItem(item->GetGUIDLow(), item->GetEntry(), item);
6210 }
6211 }
6212
6213 WorldSession::SendMailTo(receiver,messagetype, stationery, sender_guidlo, GUID_LOPART(receiver_guid), subject, itemTextId, &mi, 0, 0, MAIL_CHECK_MASK_NONE);
6214
6215 std::string nameLink = playerLink(receiver_name);
6216 PSendSysMessage(LANG_MAIL_SENT, nameLink.c_str());
6217 return true;
6218 }
6219
6220 ///Send money by mail
6221 bool ChatHandler::HandleSendMoneyCommand(const char* args)
6222 {
6223 /// format: name "subject text" "mail text" money
6224
6225 Player* receiver;
6226 uint64 receiver_guid;
6227 std::string receiver_name;
6228 if(!extractPlayerTarget((char*)args,&receiver,&receiver_guid,&receiver_name))
6229 return false;
6230
6231 char* tail1 = strtok(NULL, "");
6232 if (!tail1)
6233 return false;
6234
6235 char* msgSubject = extractQuotedArg(tail1);
6236 if (!msgSubject)
6237 return false;
6238
6239 char* tail2 = strtok(NULL, "");
6240 if (!tail2)
6241 return false;
6242
6243 char* msgText = extractQuotedArg(tail2);
6244 if (!msgText)
6245 return false;
6246
6247 char* money_str = strtok(NULL, "");
6248 int32 money = money_str ? atoi(money_str) : 0;
6249 if (money <= 0)
6250 return false;
6251
6252 // msgSubject, msgText isn't NUL after prev. check
6253 std::string subject = msgSubject;
6254 std::string text = msgText;
6255
6256 // from console show not existed sender
6257 uint32 sender_guidlo = m_session ? m_session->GetPlayer()->GetGUIDLow() : 0;
6258
6259 uint32 messagetype = MAIL_NORMAL;
6260 uint32 stationery = MAIL_STATIONERY_GM;
6261 uint32 itemTextId = !text.empty() ? objmgr.CreateItemText( text ) : 0;
6262
6263 WorldSession::SendMailTo(receiver,messagetype, stationery, sender_guidlo, GUID_LOPART(receiver_guid), subject, itemTextId, NULL, money, 0, MAIL_CHECK_MASK_NONE);
6264
6265 std::string nameLink = playerLink(receiver_name);
6266 PSendSysMessage(LANG_MAIL_SENT, nameLink.c_str());
6267 return true;
6268 }
6269
6270 /// Send a message to a player in game
6271 bool ChatHandler::HandleSendMessageCommand(const char* args)
6272 {
6273 ///- Find the player
6274 Player *rPlayer;
6275 if(!extractPlayerTarget((char*)args,&rPlayer))
6276 return false;
6277
6278 char* msg_str = strtok(NULL, "");
6279 if(!msg_str)
6280 return false;
6281
6282 ///- Check that he is not logging out.
6283 if(rPlayer->GetSession()->isLogingOut())
6284 {
6285 SendSysMessage(LANG_PLAYER_NOT_FOUND);
6286 SetSentErrorMessage(true);
6287 return false;
6288 }
6289
6290 ///- Send the message
6291 //Use SendAreaTriggerMessage for fastest delivery.
6292 rPlayer->GetSession()->SendAreaTriggerMessage("%s", msg_str);
6293 rPlayer->GetSession()->SendAreaTriggerMessage("|cffff0000[Message from administrator]:|r");
6294
6295 //Confirmation message
6296 std::string nameLink = GetNameLink(rPlayer);
6297 PSendSysMessage(LANG_SENDMESSAGE,nameLink.c_str(),msg_str);
6298 return true;
6299 }
6300
6301 bool ChatHandler::HandleFlushArenaPointsCommand(const char * /*args*/)
6302 {
6303 sBattleGroundMgr.DistributeArenaPoints();
6304 return true;
6305 }
6306
6307 bool ChatHandler::HandleModifyGenderCommand(const char *args)
6308 {
6309 if(!*args)
6310 return false;
6311
6312 Player *player = getSelectedPlayer();
6313
6314 if(!player)
6315 {
6316 PSendSysMessage(LANG_PLAYER_NOT_FOUND);
6317 SetSentErrorMessage(true);
6318 return false;
6319 }
6320
6321 PlayerInfo const* info = objmgr.GetPlayerInfo(player->getRace(), player->getClass());
6322 if(!info)
6323 return false;
6324
6325 char const* gender_str = (char*)args;
6326 int gender_len = strlen(gender_str);
6327
6328 Gender gender;
6329
6330 if(!strncmp(gender_str, "male", gender_len)) // MALE
6331 {
6332 if(player->getGender() == GENDER_MALE)
6333 return true;
6334
6335 gender = GENDER_MALE;
6336 }
6337 else if (!strncmp(gender_str, "female", gender_len)) // FEMALE
6338 {
6339 if(player->getGender() == GENDER_FEMALE)
6340 return true;
6341
6342 gender = GENDER_FEMALE;
6343 }
6344 else
6345 {
6346 SendSysMessage(LANG_MUST_MALE_OR_FEMALE);
6347 SetSentErrorMessage(true);
6348 return false;
6349 }
6350
6351 // Set gender
6352 player->SetByteValue(UNIT_FIELD_BYTES_0, 2, gender);
6353 player->SetByteValue(PLAYER_BYTES_3, 0, gender);
6354
6355 // Change display ID
6356 player->InitDisplayIds();
6357
6358 char const* gender_full = gender ? "female" : "male";
6359
6360 PSendSysMessage(LANG_YOU_CHANGE_GENDER, GetNameLink(player).c_str(), gender_full);
6361
6362 if (needReportToTarget(player))
6363 ChatHandler(player).PSendSysMessage(LANG_YOUR_GENDER_CHANGED, gender_full, GetNameLink().c_str());
6364
6365 return true;
6366 }
MaNGOS is a free, Open Source implementation of a game server compatible with the original World of Warcraft client.