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