src/game/Level1.cpp

   1 /*
   2  * Copyright (C) 2005-2013 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 "Player.h"
  26 #include "Opcodes.h"
  27 #include "Chat.h"
  28 #include "Log.h"
  29 #include "MapManager.h"
  30 #include "ObjectAccessor.h"
  31 #include "Language.h"
  32 #include "CellImpl.h"
  33 #include "MapPersistentStateMgr.h"
  34 #include "Mail.h"
  35 #include "Util.h"
  36 #include "SpellMgr.h"
  37 #ifdef _DEBUG_VMAPS
  38 #include "VMapFactory.h"
  39 #endif
  40
  41 //-----------------------Npc Commands-----------------------
  42 bool ChatHandler::HandleNpcSayCommand(char* args)
  43 {
  44     if (!*args)
  45         return false;
  46
  47     Creature* pCreature = getSelectedCreature();
  48     if (!pCreature)
  49     {
  50         SendSysMessage(LANG_SELECT_CREATURE);
  51         SetSentErrorMessage(true);
  52         return false;
  53     }
  54
  55     pCreature->MonsterSay(args, LANG_UNIVERSAL);
  56
  57     return true;
  58 }
  59
  60 bool ChatHandler::HandleNpcYellCommand(char* args)
  61 {
  62     if (!*args)
  63         return false;
  64
  65     Creature* pCreature = getSelectedCreature();
  66     if (!pCreature)
  67     {
  68         SendSysMessage(LANG_SELECT_CREATURE);
  69         SetSentErrorMessage(true);
  70         return false;
  71     }
  72
  73     pCreature->MonsterYell(args, LANG_UNIVERSAL);
  74
  75     return true;
  76 }
  77
  78 // show text emote by creature in chat
  79 bool ChatHandler::HandleNpcTextEmoteCommand(char* args)
  80 {
  81     if (!*args)
  82         return false;
  83
  84     Creature* pCreature = getSelectedCreature();
  85
  86     if (!pCreature)
  87     {
  88         SendSysMessage(LANG_SELECT_CREATURE);
  89         SetSentErrorMessage(true);
  90         return false;
  91     }
  92
  93     pCreature->MonsterTextEmote(args, NULL);
  94
  95     return true;
  96 }
  97
  98 // make npc whisper to player
  99 bool ChatHandler::HandleNpcWhisperCommand(char* args)
 100 {
 101     Player* target;
 102     if (!ExtractPlayerTarget(&args, &target))
 103         return false;
 104
 105     ObjectGuid guid = m_session->GetPlayer()->GetSelectionGuid();
 106     if (!guid)
 107         return false;
 108
 109     Creature* pCreature = m_session->GetPlayer()->GetMap()->GetCreature(guid);
 110
 111     if (!pCreature || !target || !*args)
 112         return false;
 113
 114     // check online security
 115     if (HasLowerSecurity(target))
 116         return false;
 117
 118     pCreature->MonsterWhisper(args, target);
 119
 120     return true;
 121 }
 122 //----------------------------------------------------------
 123
 124 // global announce
 125 bool ChatHandler::HandleAnnounceCommand(char* args)
 126 {
 127     if (!*args)
 128         return false;
 129
 130     sWorld.SendWorldText(LANG_SYSTEMMESSAGE, args);
 131     return true;
 132 }
 133
 134 // notification player at the screen
 135 bool ChatHandler::HandleNotifyCommand(char* args)
 136 {
 137     if (!*args)
 138         return false;
 139
 140     std::string str = GetMangosString(LANG_GLOBAL_NOTIFY);
 141     str += args;
 142
 143     WorldPacket data(SMSG_NOTIFICATION, str.size() + 1);
 144     data.WriteBits(str.length(), 13);
 145     data.FlushBits();
 146     data.append(str.c_str(), str.length());
 147     sWorld.SendGlobalMessage(&data);
 148
 149     return true;
 150 }
 151
 152 // Enable\Dissable GM Mode
 153 bool ChatHandler::HandleGMCommand(char* args)
 154 {
 155     if (!*args)
 156     {
 157         if (m_session->GetPlayer()->isGameMaster())
 158             m_session->SendNotification(LANG_GM_ON);
 159         else
 160             m_session->SendNotification(LANG_GM_OFF);
 161         return true;
 162     }
 163
 164     bool value;
 165     if (!ExtractOnOff(&args, value))
 166     {
 167         SendSysMessage(LANG_USE_BOL);
 168         SetSentErrorMessage(true);
 169         return false;
 170     }
 171
 172     if (value)
 173     {
 174         m_session->GetPlayer()->SetGameMaster(true);
 175         m_session->SendNotification(LANG_GM_ON);
 176     }
 177     else
 178     {
 179         m_session->GetPlayer()->SetGameMaster(false);
 180         m_session->SendNotification(LANG_GM_OFF);
 181     }
 182
 183     return true;
 184 }
 185
 186 // Enables or disables hiding of the staff badge
 187 bool ChatHandler::HandleGMChatCommand(char* args)
 188 {
 189     if (!*args)
 190     {
 191         if (m_session->GetPlayer()->isGMChat())
 192             m_session->SendNotification(LANG_GM_CHAT_ON);
 193         else
 194             m_session->SendNotification(LANG_GM_CHAT_OFF);
 195         return true;
 196     }
 197
 198     bool value;
 199     if (!ExtractOnOff(&args, value))
 200     {
 201         SendSysMessage(LANG_USE_BOL);
 202         SetSentErrorMessage(true);
 203         return false;
 204     }
 205
 206     if (value)
 207     {
 208         m_session->GetPlayer()->SetGMChat(true);
 209         m_session->SendNotification(LANG_GM_CHAT_ON);
 210     }
 211     else
 212     {
 213         m_session->GetPlayer()->SetGMChat(false);
 214         m_session->SendNotification(LANG_GM_CHAT_OFF);
 215     }
 216
 217     return true;
 218 }
 219
 220 // Enable\Dissable Invisible mode
 221 bool ChatHandler::HandleGMVisibleCommand(char* args)
 222 {
 223     if (!*args)
 224     {
 225         PSendSysMessage(LANG_YOU_ARE, m_session->GetPlayer()->isGMVisible() ?  GetMangosString(LANG_VISIBLE) : GetMangosString(LANG_INVISIBLE));
 226         return true;
 227     }
 228
 229     bool value;
 230     if (!ExtractOnOff(&args, value))
 231     {
 232         SendSysMessage(LANG_USE_BOL);
 233         SetSentErrorMessage(true);
 234         return false;
 235     }
 236
 237     Player* player = m_session->GetPlayer();
 238     SpellEntry const* invisibleAuraInfo = sSpellStore.LookupEntry(sWorld.getConfig(CONFIG_UINT32_GM_INVISIBLE_AURA));
 239     if (!invisibleAuraInfo || !IsSpellAppliesAura(invisibleAuraInfo))
 240         invisibleAuraInfo = NULL;
 241
 242     if (value)
 243     {
 244         player->SetGMVisible(true);
 245         m_session->SendNotification(LANG_INVISIBLE_VISIBLE);
 246         if (invisibleAuraInfo)
 247             player->RemoveAurasDueToSpell(invisibleAuraInfo->Id);
 248     }
 249     else
 250     {
 251         m_session->SendNotification(LANG_INVISIBLE_INVISIBLE);
 252         player->SetGMVisible(false);
 253         if (invisibleAuraInfo)
 254             player->CastSpell(player, invisibleAuraInfo, true);
 255     }
 256
 257     return true;
 258 }
 259
 260 bool ChatHandler::HandleGPSCommand(char* args)
 261 {
 262     WorldObject* obj = NULL;
 263     if (*args)
 264     {
 265         if (ObjectGuid guid = ExtractGuidFromLink(&args))
 266             obj = (WorldObject*)m_session->GetPlayer()->GetObjectByTypeMask(guid, TYPEMASK_CREATURE_OR_GAMEOBJECT);
 267
 268         if (!obj)
 269         {
 270             SendSysMessage(LANG_PLAYER_NOT_FOUND);
 271             SetSentErrorMessage(true);
 272             return false;
 273         }
 274     }
 275     else
 276     {
 277         obj = getSelectedUnit();
 278
 279         if (!obj)
 280         {
 281             SendSysMessage(LANG_SELECT_CHAR_OR_CREATURE);
 282             SetSentErrorMessage(true);
 283             return false;
 284         }
 285     }
 286     CellPair cell_val = MaNGOS::ComputeCellPair(obj->GetPositionX(), obj->GetPositionY());
 287     Cell cell(cell_val);
 288
 289     uint32 zone_id, area_id;
 290     obj->GetZoneAndAreaId(zone_id, area_id);
 291
 292     MapEntry const* mapEntry = sMapStore.LookupEntry(obj->GetMapId());
 293     AreaTableEntry const* zoneEntry = GetAreaEntryByAreaID(zone_id);
 294     AreaTableEntry const* areaEntry = GetAreaEntryByAreaID(area_id);
 295
 296     float zone_x = obj->GetPositionX();
 297     float zone_y = obj->GetPositionY();
 298
 299     if (!Map2ZoneCoordinates(zone_x, zone_y, zone_id))
 300     {
 301         zone_x = 0;
 302         zone_y = 0;
 303     }
 304
 305     TerrainInfo const* map = obj->GetTerrain();
 306     float ground_z = map->GetHeight(obj->GetPositionX(), obj->GetPositionY(), MAX_HEIGHT);
 307     float floor_z = map->GetHeight(obj->GetPositionX(), obj->GetPositionY(), obj->GetPositionZ());
 308
 309     GridPair p = MaNGOS::ComputeGridPair(obj->GetPositionX(), obj->GetPositionY());
 310
 311     int gx = 63 - p.x_coord;
 312     int gy = 63 - p.y_coord;
 313
 314     uint32 have_map = GridMap::ExistMap(obj->GetMapId(), gx, gy) ? 1 : 0;
 315     uint32 have_vmap = GridMap::ExistVMap(obj->GetMapId(), gx, gy) ? 1 : 0;
 316
 317     if (have_vmap)
 318     {
 319         if (map->IsOutdoors(obj->GetPositionX(), obj->GetPositionY(), obj->GetPositionZ()))
 320             PSendSysMessage("You are OUTdoor");
 321         else
 322             PSendSysMessage("You are INdoor");
 323     }
 324     else PSendSysMessage("no VMAP available for area info");
 325
 326     PSendSysMessage(LANG_MAP_POSITION,
 327                     obj->GetMapId(), (mapEntry ? mapEntry->name[GetSessionDbcLocale()] : "<unknown>"),
 328                     zone_id, (zoneEntry ? zoneEntry->area_name[GetSessionDbcLocale()] : "<unknown>"),
 329                     area_id, (areaEntry ? areaEntry->area_name[GetSessionDbcLocale()] : "<unknown>"),
 330                     obj->GetPhaseMask(),
 331                     obj->GetPositionX(), obj->GetPositionY(), obj->GetPositionZ(), obj->GetOrientation(),
 332                     cell.GridX(), cell.GridY(), cell.CellX(), cell.CellY(), obj->GetInstanceId(),
 333                     zone_x, zone_y, ground_z, floor_z, have_map, have_vmap);
 334
 335     DEBUG_LOG("Player %s GPS call for %s '%s' (%s: %u):",
 336               m_session ? GetNameLink().c_str() : GetMangosString(LANG_CONSOLE_COMMAND),
 337               (obj->GetTypeId() == TYPEID_PLAYER ? "player" : "creature"), obj->GetName(),
 338               (obj->GetTypeId() == TYPEID_PLAYER ? "GUID" : "Entry"), (obj->GetTypeId() == TYPEID_PLAYER ? obj->GetGUIDLow() : obj->GetEntry()));
 339
 340     DEBUG_LOG(GetMangosString(LANG_MAP_POSITION),
 341               obj->GetMapId(), (mapEntry ? mapEntry->name[sWorld.GetDefaultDbcLocale()] : "<unknown>"),
 342               zone_id, (zoneEntry ? zoneEntry->area_name[sWorld.GetDefaultDbcLocale()] : "<unknown>"),
 343               area_id, (areaEntry ? areaEntry->area_name[sWorld.GetDefaultDbcLocale()] : "<unknown>"),
 344               obj->GetPhaseMask(),
 345               obj->GetPositionX(), obj->GetPositionY(), obj->GetPositionZ(), obj->GetOrientation(),
 346               cell.GridX(), cell.GridY(), cell.CellX(), cell.CellY(), obj->GetInstanceId(),
 347               zone_x, zone_y, ground_z, floor_z, have_map, have_vmap);
 348
 349     GridMapLiquidData liquid_status;
 350     GridMapLiquidStatus res = map->getLiquidStatus(obj->GetPositionX(), obj->GetPositionY(), obj->GetPositionZ(), MAP_ALL_LIQUIDS, &liquid_status);
 351     if (res)
 352     {
 353         PSendSysMessage(LANG_LIQUID_STATUS, liquid_status.level, liquid_status.depth_level, liquid_status.type, res);
 354     }
 355     return true;
 356 }
 357
 358 // Summon Player
 359 bool ChatHandler::HandleNamegoCommand(char* args)
 360 {
 361     Player* target;
 362     ObjectGuid target_guid;
 363     std::string target_name;
 364     if (!ExtractPlayerTarget(&args, &target, &target_guid, &target_name))
 365         return false;
 366
 367     Player* _player = m_session->GetPlayer();
 368     if (target == _player || target_guid == _player->GetObjectGuid())
 369     {
 370         PSendSysMessage(LANG_CANT_TELEPORT_SELF);
 371         SetSentErrorMessage(true);
 372         return false;
 373     }
 374
 375     if (target)
 376     {
 377         std::string nameLink = playerLink(target_name);
 378         // check online security
 379         if (HasLowerSecurity(target))
 380             return false;
 381
 382         if (target->IsBeingTeleported())
 383         {
 384             PSendSysMessage(LANG_IS_TELEPORTED, nameLink.c_str());
 385             SetSentErrorMessage(true);
 386             return false;
 387         }
 388
 389         Map* pMap = m_session->GetPlayer()->GetMap();
 390
 391         if (pMap->IsBattleGroundOrArena())
 392         {
 393             // only allow if gm mode is on
 394             if (!target->isGameMaster())
 395             {
 396                 PSendSysMessage(LANG_CANNOT_GO_TO_BG_GM, nameLink.c_str());
 397                 SetSentErrorMessage(true);
 398                 return false;
 399             }
 400             // if both players are in different bgs
 401             else if (target->GetBattleGroundId() && m_session->GetPlayer()->GetBattleGroundId() != target->GetBattleGroundId())
 402             {
 403                 PSendSysMessage(LANG_CANNOT_GO_TO_BG_FROM_BG, nameLink.c_str());
 404                 SetSentErrorMessage(true);
 405                 return false;
 406             }
 407             // all's well, set bg id
 408             // when porting out from the bg, it will be reset to 0
 409             target->SetBattleGroundId(m_session->GetPlayer()->GetBattleGroundId(), m_session->GetPlayer()->GetBattleGroundTypeId());
 410             // remember current position as entry point for return at bg end teleportation
 411             if (!target->GetMap()->IsBattleGroundOrArena())
 412                 target->SetBattleGroundEntryPoint();
 413         }
 414         else if (pMap->IsDungeon())
 415         {
 416             Map* cMap = target->GetMap();
 417             if (cMap->Instanceable() && cMap->GetInstanceId() != pMap->GetInstanceId())
 418             {
 419                 // cannot summon from instance to instance
 420                 PSendSysMessage(LANG_CANNOT_SUMMON_TO_INST, nameLink.c_str());
 421                 SetSentErrorMessage(true);
 422                 return false;
 423             }
 424
 425             // we are in instance, and can summon only player in our group with us as lead
 426             if (!m_session->GetPlayer()->GetGroup() || !target->GetGroup() ||
 427                     (target->GetGroup()->GetLeaderGuid() != m_session->GetPlayer()->GetObjectGuid()) ||
 428                     (m_session->GetPlayer()->GetGroup()->GetLeaderGuid() != m_session->GetPlayer()->GetObjectGuid()))
 429                 // the last check is a bit excessive, but let it be, just in case
 430             {
 431                 PSendSysMessage(LANG_CANNOT_SUMMON_TO_INST, nameLink.c_str());
 432                 SetSentErrorMessage(true);
 433                 return false;
 434             }
 435         }
 436
 437         PSendSysMessage(LANG_SUMMONING, nameLink.c_str(), "");
 438         if (needReportToTarget(target))
 439             ChatHandler(target).PSendSysMessage(LANG_SUMMONED_BY, playerLink(_player->GetName()).c_str());
 440
 441         // stop flight if need
 442         if (target->IsTaxiFlying())
 443         {
 444             target->GetMotionMaster()->MovementExpired();
 445             target->m_taxi.ClearTaxiDestinations();
 446         }
 447         // save only in non-flight case
 448         else
 449             target->SaveRecallPosition();
 450
 451         // before GM
 452         float x, y, z;
 453         m_session->GetPlayer()->GetClosePoint(x, y, z, target->GetObjectBoundingRadius());
 454         target->TeleportTo(m_session->GetPlayer()->GetMapId(), x, y, z, target->GetOrientation());
 455     }
 456     else
 457     {
 458         // check offline security
 459         if (HasLowerSecurity(NULL, target_guid))
 460             return false;
 461
 462         std::string nameLink = playerLink(target_name);
 463
 464         PSendSysMessage(LANG_SUMMONING, nameLink.c_str(), GetMangosString(LANG_OFFLINE));
 465
 466         // in point where GM stay
 467         Player::SavePositionInDB(target_guid, m_session->GetPlayer()->GetMapId(),
 468                                  m_session->GetPlayer()->GetPositionX(),
 469                                  m_session->GetPlayer()->GetPositionY(),
 470                                  m_session->GetPlayer()->GetPositionZ(),
 471                                  m_session->GetPlayer()->GetOrientation(),
 472                                  m_session->GetPlayer()->GetZoneId());
 473     }
 474
 475     return true;
 476 }
 477
 478 // Teleport to Player
 479 bool ChatHandler::HandleGonameCommand(char* args)
 480 {
 481     Player* target;
 482     ObjectGuid target_guid;
 483     std::string target_name;
 484     if (!ExtractPlayerTarget(&args, &target, &target_guid, &target_name))
 485         return false;
 486
 487     Player* _player = m_session->GetPlayer();
 488     if (target == _player || target_guid == _player->GetObjectGuid())
 489     {
 490         SendSysMessage(LANG_CANT_TELEPORT_SELF);
 491         SetSentErrorMessage(true);
 492         return false;
 493     }
 494
 495
 496     if (target)
 497     {
 498         // check online security
 499         if (HasLowerSecurity(target))
 500             return false;
 501
 502         std::string chrNameLink = playerLink(target_name);
 503
 504         Map* cMap = target->GetMap();
 505         if (cMap->IsBattleGroundOrArena())
 506         {
 507             // only allow if gm mode is on
 508             if (!_player->isGameMaster())
 509             {
 510                 PSendSysMessage(LANG_CANNOT_GO_TO_BG_GM, chrNameLink.c_str());
 511                 SetSentErrorMessage(true);
 512                 return false;
 513             }
 514             // if both players are in different bgs
 515             else if (_player->GetBattleGroundId() && _player->GetBattleGroundId() != target->GetBattleGroundId())
 516             {
 517                 PSendSysMessage(LANG_CANNOT_GO_TO_BG_FROM_BG, chrNameLink.c_str());
 518                 SetSentErrorMessage(true);
 519                 return false;
 520             }
 521             // all's well, set bg id
 522             // when porting out from the bg, it will be reset to 0
 523             _player->SetBattleGroundId(target->GetBattleGroundId(), target->GetBattleGroundTypeId());
 524             // remember current position as entry point for return at bg end teleportation
 525             if (!_player->GetMap()->IsBattleGroundOrArena())
 526                 _player->SetBattleGroundEntryPoint();
 527         }
 528         else if (cMap->IsDungeon())
 529         {
 530             // we have to go to instance, and can go to player only if:
 531             //   1) we are in his group (either as leader or as member)
 532             //   2) we are not bound to any group and have GM mode on
 533             if (_player->GetGroup())
 534             {
 535                 // we are in group, we can go only if we are in the player group
 536                 if (_player->GetGroup() != target->GetGroup())
 537                 {
 538                     PSendSysMessage(LANG_CANNOT_GO_TO_INST_PARTY, chrNameLink.c_str());
 539                     SetSentErrorMessage(true);
 540                     return false;
 541                 }
 542             }
 543             else
 544             {
 545                 // we are not in group, let's verify our GM mode
 546                 if (!_player->isGameMaster())
 547                 {
 548                     PSendSysMessage(LANG_CANNOT_GO_TO_INST_GM, chrNameLink.c_str());
 549                     SetSentErrorMessage(true);
 550                     return false;
 551                 }
 552             }
 553
 554             // if the player or the player's group is bound to another instance
 555             // the player will not be bound to another one
 556             InstancePlayerBind* pBind = _player->GetBoundInstance(target->GetMapId(), target->GetDifficulty(cMap->IsRaid()));
 557             if (!pBind)
 558             {
 559                 Group* group = _player->GetGroup();
 560                 // if no bind exists, create a solo bind
 561                 InstanceGroupBind* gBind = group ? group->GetBoundInstance(target->GetMapId(), target) : NULL;
 562                 // if no bind exists, create a solo bind
 563                 if (!gBind)
 564                 {
 565                     DungeonPersistentState* save = ((DungeonMap*)target->GetMap())->GetPersistanceState();
 566
 567                     // if player is group leader then we need add group bind
 568                     if (group && group->IsLeader(_player->GetObjectGuid()))
 569                         group->BindToInstance(save, !save->CanReset());
 570                     else
 571                         _player->BindToInstance(save, !save->CanReset());
 572                 }
 573             }
 574
 575             if (cMap->IsRaid())
 576                 _player->SetRaidDifficulty(target->GetRaidDifficulty());
 577             else
 578                 _player->SetDungeonDifficulty(target->GetDungeonDifficulty());
 579         }
 580
 581         PSendSysMessage(LANG_APPEARING_AT, chrNameLink.c_str());
 582         if (needReportToTarget(target))
 583             ChatHandler(target).PSendSysMessage(LANG_APPEARING_TO, GetNameLink().c_str());
 584
 585         // stop flight if need
 586         if (_player->IsTaxiFlying())
 587         {
 588             _player->GetMotionMaster()->MovementExpired();
 589             _player->m_taxi.ClearTaxiDestinations();
 590         }
 591         // save only in non-flight case
 592         else
 593             _player->SaveRecallPosition();
 594
 595         // to point to see at target with same orientation
 596         float x, y, z;
 597         target->GetContactPoint(_player, x, y, z);
 598
 599         _player->TeleportTo(target->GetMapId(), x, y, z, _player->GetAngle(target), TELE_TO_GM_MODE);
 600     }
 601     else
 602     {
 603         // check offline security
 604         if (HasLowerSecurity(NULL, target_guid))
 605             return false;
 606
 607         std::string nameLink = playerLink(target_name);
 608
 609         PSendSysMessage(LANG_APPEARING_AT, nameLink.c_str());
 610
 611         // to point where player stay (if loaded)
 612         float x, y, z, o;
 613         uint32 map;
 614         bool in_flight;
 615         if (!Player::LoadPositionFromDB(target_guid, map, x, y, z, o, in_flight))
 616             return false;
 617
 618         return HandleGoHelper(_player, map, x, y, &z);
 619     }
 620
 621     return true;
 622 }
 623
 624 // Teleport player to last position
 625 bool ChatHandler::HandleRecallCommand(char* args)
 626 {
 627     Player* target;
 628     if (!ExtractPlayerTarget(&args, &target))
 629         return false;
 630
 631     // check online security
 632     if (HasLowerSecurity(target))
 633         return false;
 634
 635     if (target->IsBeingTeleported())
 636     {
 637         PSendSysMessage(LANG_IS_TELEPORTED, GetNameLink(target).c_str());
 638         SetSentErrorMessage(true);
 639         return false;
 640     }
 641
 642     return HandleGoHelper(target, target->m_recallMap, target->m_recallX, target->m_recallY, &target->m_recallZ, &target->m_recallO);
 643 }
 644
 645 bool ChatHandler::HandleModifyHolyPowerCommand(char* args)
 646 {
 647     if (!*args)
 648         return false;
 649
 650     int32 power = atoi(args);
 651
 652     if (power < 0)
 653     {
 654         SendSysMessage(LANG_BAD_VALUE);
 655         SetSentErrorMessage(true);
 656         return false;
 657     }
 658
 659     Player* chr = getSelectedPlayer();
 660     if (!chr)
 661     {
 662         SendSysMessage(LANG_NO_CHAR_SELECTED);
 663         SetSentErrorMessage(true);
 664         return false;
 665     }
 666
 667     // check online security
 668     if (HasLowerSecurity(chr))
 669         return false;
 670
 671     int32 maxPower = int32(chr->GetMaxPower(POWER_HOLY_POWER));
 672     if (power > maxPower)
 673     {
 674         SendSysMessage(LANG_BAD_VALUE);
 675         SetSentErrorMessage(true);
 676         return false;
 677     }
 678
 679     PSendSysMessage(LANG_YOU_CHANGE_HOLY_POWER, GetNameLink(chr).c_str(), power, maxPower);
 680     if (needReportToTarget(chr))
 681         ChatHandler(chr).PSendSysMessage(LANG_YOURS_HOLY_POWER_CHANGED, GetNameLink().c_str(), power, maxPower);
 682
 683     chr->SetPower(POWER_HOLY_POWER, power);
 684
 685     return true;
 686 }
 687
 688 // Edit Player HP
 689 bool ChatHandler::HandleModifyHPCommand(char* args)
 690 {
 691     if (!*args)
 692         return false;
 693
 694     int32 hp = atoi(args);
 695     int32 hpm = atoi(args);
 696
 697     if (hp <= 0 || hpm <= 0 || hpm < hp)
 698     {
 699         SendSysMessage(LANG_BAD_VALUE);
 700         SetSentErrorMessage(true);
 701         return false;
 702     }
 703
 704     Player* chr = getSelectedPlayer();
 705     if (chr == NULL)
 706     {
 707         SendSysMessage(LANG_NO_CHAR_SELECTED);
 708         SetSentErrorMessage(true);
 709         return false;
 710     }
 711
 712     // check online security
 713     if (HasLowerSecurity(chr))
 714         return false;
 715
 716     PSendSysMessage(LANG_YOU_CHANGE_HP, GetNameLink(chr).c_str(), hp, hpm);
 717     if (needReportToTarget(chr))
 718         ChatHandler(chr).PSendSysMessage(LANG_YOURS_HP_CHANGED, GetNameLink().c_str(), hp, hpm);
 719
 720     chr->SetMaxHealth(hpm);
 721     chr->SetHealth(hp);
 722
 723     return true;
 724 }
 725
 726 // Edit Player Mana
 727 bool ChatHandler::HandleModifyManaCommand(char* args)
 728 {
 729     if (!*args)
 730         return false;
 731
 732     int32 mana = atoi(args);
 733     int32 manam = atoi(args);
 734
 735     if (mana <= 0 || manam <= 0 || manam < mana)
 736     {
 737         SendSysMessage(LANG_BAD_VALUE);
 738         SetSentErrorMessage(true);
 739         return false;
 740     }
 741
 742     Player* chr = getSelectedPlayer();
 743     if (chr == NULL)
 744     {
 745         SendSysMessage(LANG_NO_CHAR_SELECTED);
 746         SetSentErrorMessage(true);
 747         return false;
 748     }
 749
 750     // check online security
 751     if (HasLowerSecurity(chr))
 752         return false;
 753
 754     PSendSysMessage(LANG_YOU_CHANGE_MANA, GetNameLink(chr).c_str(), mana, manam);
 755     if (needReportToTarget(chr))
 756         ChatHandler(chr).PSendSysMessage(LANG_YOURS_MANA_CHANGED, GetNameLink().c_str(), mana, manam);
 757
 758     chr->SetMaxPower(POWER_MANA, manam);
 759     chr->SetPower(POWER_MANA, mana);
 760
 761     return true;
 762 }
 763
 764 // Edit Player Energy
 765 bool ChatHandler::HandleModifyEnergyCommand(char* args)
 766 {
 767     if (!*args)
 768         return false;
 769
 770     int32 energy = atoi(args) * 10;
 771     int32 energym = atoi(args) * 10;
 772
 773     if (energy <= 0 || energym <= 0 || energym < energy)
 774     {
 775         SendSysMessage(LANG_BAD_VALUE);
 776         SetSentErrorMessage(true);
 777         return false;
 778     }
 779
 780     Player* chr = getSelectedPlayer();
 781     if (!chr)
 782     {
 783         SendSysMessage(LANG_NO_CHAR_SELECTED);
 784         SetSentErrorMessage(true);
 785         return false;
 786     }
 787
 788     // check online security
 789     if (HasLowerSecurity(chr))
 790         return false;
 791
 792     PSendSysMessage(LANG_YOU_CHANGE_ENERGY, GetNameLink(chr).c_str(), energy / 10, energym / 10);
 793     if (needReportToTarget(chr))
 794         ChatHandler(chr).PSendSysMessage(LANG_YOURS_ENERGY_CHANGED, GetNameLink().c_str(), energy / 10, energym / 10);
 795
 796     chr->SetMaxPower(POWER_ENERGY, energym);
 797     chr->SetPower(POWER_ENERGY, energy);
 798
 799     DETAIL_LOG(GetMangosString(LANG_CURRENT_ENERGY), chr->GetMaxPower(POWER_ENERGY));
 800
 801     return true;
 802 }
 803
 804 // Edit Player Rage
 805 bool ChatHandler::HandleModifyRageCommand(char* args)
 806 {
 807     if (!*args)
 808         return false;
 809
 810     int32 rage = atoi(args) * 10;
 811     int32 ragem = atoi(args) * 10;
 812
 813     if (rage <= 0 || ragem <= 0 || ragem < rage)
 814     {
 815         SendSysMessage(LANG_BAD_VALUE);
 816         SetSentErrorMessage(true);
 817         return false;
 818     }
 819
 820     Player* chr = getSelectedPlayer();
 821     if (chr == NULL)
 822     {
 823         SendSysMessage(LANG_NO_CHAR_SELECTED);
 824         SetSentErrorMessage(true);
 825         return false;
 826     }
 827
 828     // check online security
 829     if (HasLowerSecurity(chr))
 830         return false;
 831
 832     PSendSysMessage(LANG_YOU_CHANGE_RAGE, GetNameLink(chr).c_str(), rage / 10, ragem / 10);
 833     if (needReportToTarget(chr))
 834         ChatHandler(chr).PSendSysMessage(LANG_YOURS_RAGE_CHANGED, GetNameLink().c_str(), rage / 10, ragem / 10);
 835
 836     chr->SetMaxPower(POWER_RAGE, ragem);
 837     chr->SetPower(POWER_RAGE, rage);
 838
 839     return true;
 840 }
 841
 842 // Edit Player Runic Power
 843 bool ChatHandler::HandleModifyRunicPowerCommand(char* args)
 844 {
 845     if (!*args)
 846         return false;
 847
 848     int32 rune = atoi(args) * 10;
 849     int32 runem = atoi(args) * 10;
 850
 851     if (rune <= 0 || runem <= 0 || runem < rune)
 852     {
 853         SendSysMessage(LANG_BAD_VALUE);
 854         SetSentErrorMessage(true);
 855         return false;
 856     }
 857
 858     Player* chr = getSelectedPlayer();
 859     if (chr == NULL)
 860     {
 861         SendSysMessage(LANG_NO_CHAR_SELECTED);
 862         SetSentErrorMessage(true);
 863         return false;
 864     }
 865
 866     PSendSysMessage(LANG_YOU_CHANGE_RUNIC_POWER, GetNameLink(chr).c_str(), rune / 10, runem / 10);
 867     if (needReportToTarget(chr))
 868         ChatHandler(chr).PSendSysMessage(LANG_YOURS_RUNIC_POWER_CHANGED, GetNameLink().c_str(), rune / 10, runem / 10);
 869
 870     chr->SetMaxPower(POWER_RUNIC_POWER, runem);
 871     chr->SetPower(POWER_RUNIC_POWER, rune);
 872
 873     return true;
 874 }
 875
 876 // Edit Player Faction
 877 bool ChatHandler::HandleModifyFactionCommand(char* args)
 878 {
 879     Creature* chr = getSelectedCreature();
 880     if (!chr)
 881     {
 882         SendSysMessage(LANG_SELECT_CREATURE);
 883         SetSentErrorMessage(true);
 884         return false;
 885     }
 886
 887     if (!*args)
 888     {
 889         if (chr)
 890         {
 891             uint32 factionid = chr->getFaction();
 892             uint32 flag      = chr->GetUInt32Value(UNIT_FIELD_FLAGS);
 893             uint32 npcflag   = chr->GetUInt32Value(UNIT_NPC_FLAGS);
 894             uint32 dyflag    = chr->GetUInt32Value(UNIT_DYNAMIC_FLAGS);
 895             PSendSysMessage(LANG_CURRENT_FACTION, chr->GetGUIDLow(), factionid, flag, npcflag, dyflag);
 896         }
 897         return true;
 898     }
 899
 900     if (!chr)
 901     {
 902         SendSysMessage(LANG_NO_CHAR_SELECTED);
 903         SetSentErrorMessage(true);
 904         return false;
 905     }
 906
 907     uint32 factionid;
 908     if (!ExtractUint32KeyFromLink(&args, "Hfaction", factionid))
 909         return false;
 910
 911     if (!sFactionTemplateStore.LookupEntry(factionid))
 912     {
 913         PSendSysMessage(LANG_WRONG_FACTION, factionid);
 914         SetSentErrorMessage(true);
 915         return false;
 916     }
 917
 918     uint32 flag;
 919     if (!ExtractOptUInt32(&args, flag, chr->GetUInt32Value(UNIT_FIELD_FLAGS)))
 920         return false;
 921
 922     uint32 npcflag;
 923     if (!ExtractOptUInt32(&args, npcflag, chr->GetUInt32Value(UNIT_NPC_FLAGS)))
 924         return false;
 925
 926     uint32  dyflag;
 927     if (!ExtractOptUInt32(&args, dyflag, chr->GetUInt32Value(UNIT_DYNAMIC_FLAGS)))
 928         return false;
 929
 930     PSendSysMessage(LANG_YOU_CHANGE_FACTION, chr->GetGUIDLow(), factionid, flag, npcflag, dyflag);
 931
 932     chr->setFaction(factionid);
 933     chr->SetUInt32Value(UNIT_FIELD_FLAGS, flag);
 934     chr->SetUInt32Value(UNIT_NPC_FLAGS, npcflag);
 935     chr->SetUInt32Value(UNIT_DYNAMIC_FLAGS, dyflag);
 936
 937     return true;
 938 }
 939
 940 // Edit Player TP
 941 bool ChatHandler::HandleModifyTalentCommand(char* args)
 942 {
 943     if (!*args)
 944         return false;
 945
 946     int tp = atoi(args);
 947     if (tp < 0)
 948         return false;
 949
 950     Unit* target = getSelectedUnit();
 951     if (!target)
 952     {
 953         SendSysMessage(LANG_NO_CHAR_SELECTED);
 954         SetSentErrorMessage(true);
 955         return false;
 956     }
 957
 958     if (target->GetTypeId() == TYPEID_PLAYER)
 959     {
 960         // check online security
 961         if (HasLowerSecurity((Player*)target))
 962             return false;
 963
 964         ((Player*)target)->SetFreeTalentPoints(tp);
 965         ((Player*)target)->SendTalentsInfoData(false);
 966         return true;
 967     }
 968     else if (((Creature*)target)->IsPet())
 969     {
 970         Unit* owner = target->GetOwner();
 971         if (owner && owner->GetTypeId() == TYPEID_PLAYER && ((Pet*)target)->IsPermanentPetFor((Player*)owner))
 972         {
 973             // check online security
 974             if (HasLowerSecurity((Player*)owner))
 975                 return false;
 976
 977             ((Pet*)target)->SetFreeTalentPoints(tp);
 978             ((Player*)owner)->SendTalentsInfoData(true);
 979             return true;
 980         }
 981     }
 982
 983     SendSysMessage(LANG_NO_CHAR_SELECTED);
 984     SetSentErrorMessage(true);
 985     return false;
 986 }
 987
 988 // Enable On\OFF all taxi paths
 989 bool ChatHandler::HandleTaxiCheatCommand(char* args)
 990 {
 991     bool value;
 992     if (!ExtractOnOff(&args, value))
 993     {
 994         SendSysMessage(LANG_USE_BOL);
 995         SetSentErrorMessage(true);
 996         return false;
 997     }
 998
 999     Player* chr = getSelectedPlayer();
1000     if (!chr)
1001         chr = m_session->GetPlayer();
1002     // check online security
1003     else if (HasLowerSecurity(chr))
1004         return false;
1005
1006     if (value)
1007     {
1008         chr->SetTaxiCheater(true);
1009         PSendSysMessage(LANG_YOU_GIVE_TAXIS, GetNameLink(chr).c_str());
1010         if (needReportToTarget(chr))
1011             ChatHandler(chr).PSendSysMessage(LANG_YOURS_TAXIS_ADDED, GetNameLink().c_str());
1012     }
1013     else
1014     {
1015         chr->SetTaxiCheater(false);
1016         PSendSysMessage(LANG_YOU_REMOVE_TAXIS, GetNameLink(chr).c_str());
1017         if (needReportToTarget(chr))
1018             ChatHandler(chr).PSendSysMessage(LANG_YOURS_TAXIS_REMOVED, GetNameLink().c_str());
1019     }
1020
1021     return true;
1022 }
1023
1024 // Edit Player Aspeed
1025 bool ChatHandler::HandleModifyASpeedCommand(char* args)
1026 {
1027     if (!*args)
1028         return false;
1029
1030     float modSpeed = (float)atof(args);
1031
1032     if (modSpeed > 10 || modSpeed < 0.1)
1033     {
1034         SendSysMessage(LANG_BAD_VALUE);
1035         SetSentErrorMessage(true);
1036         return false;
1037     }
1038
1039     Player* chr = getSelectedPlayer();
1040     if (chr == NULL)
1041     {
1042         SendSysMessage(LANG_NO_CHAR_SELECTED);
1043         SetSentErrorMessage(true);
1044         return false;
1045     }
1046
1047     // check online security
1048     if (HasLowerSecurity(chr))
1049         return false;
1050
1051     std::string chrNameLink = GetNameLink(chr);
1052
1053     if (chr->IsTaxiFlying())
1054     {
1055         PSendSysMessage(LANG_CHAR_IN_FLIGHT, chrNameLink.c_str());
1056         SetSentErrorMessage(true);
1057         return false;
1058     }
1059
1060     PSendSysMessage(LANG_YOU_CHANGE_ASPEED, modSpeed, chrNameLink.c_str());
1061     if (needReportToTarget(chr))
1062         ChatHandler(chr).PSendSysMessage(LANG_YOURS_ASPEED_CHANGED, GetNameLink().c_str(), modSpeed);
1063
1064     chr->UpdateSpeed(MOVE_WALK,   true, modSpeed);
1065     chr->UpdateSpeed(MOVE_RUN,    true, modSpeed);
1066     chr->UpdateSpeed(MOVE_SWIM,   true, modSpeed);
1067     // chr->UpdateSpeed(MOVE_TURN,   true, modSpeed);
1068     chr->UpdateSpeed(MOVE_FLIGHT, true, modSpeed);
1069     return true;
1070 }
1071
1072 // Edit Player Speed
1073 bool ChatHandler::HandleModifySpeedCommand(char* args)
1074 {
1075     if (!*args)
1076         return false;
1077
1078     float modSpeed = (float)atof(args);
1079
1080     if (modSpeed > 10 || modSpeed < 0.1)
1081     {
1082         SendSysMessage(LANG_BAD_VALUE);
1083         SetSentErrorMessage(true);
1084         return false;
1085     }
1086
1087     Player* chr = getSelectedPlayer();
1088     if (chr == NULL)
1089     {
1090         SendSysMessage(LANG_NO_CHAR_SELECTED);
1091         SetSentErrorMessage(true);
1092         return false;
1093     }
1094
1095     // check online security
1096     if (HasLowerSecurity(chr))
1097         return false;
1098
1099     std::string chrNameLink = GetNameLink(chr);
1100
1101     if (chr->IsTaxiFlying())
1102     {
1103         PSendSysMessage(LANG_CHAR_IN_FLIGHT, chrNameLink.c_str());
1104         SetSentErrorMessage(true);
1105         return false;
1106     }
1107
1108     PSendSysMessage(LANG_YOU_CHANGE_SPEED, modSpeed, chrNameLink.c_str());
1109     if (needReportToTarget(chr))
1110         ChatHandler(chr).PSendSysMessage(LANG_YOURS_SPEED_CHANGED, GetNameLink().c_str(), modSpeed);
1111
1112     chr->UpdateSpeed(MOVE_RUN, true, modSpeed);
1113
1114     return true;
1115 }
1116
1117 // Edit Player Swim Speed
1118 bool ChatHandler::HandleModifySwimCommand(char* args)
1119 {
1120     if (!*args)
1121         return false;
1122
1123     float modSpeed = (float)atof(args);
1124
1125     if (modSpeed > 10.0f || modSpeed < 0.01f)
1126     {
1127         SendSysMessage(LANG_BAD_VALUE);
1128         SetSentErrorMessage(true);
1129         return false;
1130     }
1131
1132     Player* chr = getSelectedPlayer();
1133     if (chr == NULL)
1134     {
1135         SendSysMessage(LANG_NO_CHAR_SELECTED);
1136         SetSentErrorMessage(true);
1137         return false;
1138     }
1139
1140     // check online security
1141     if (HasLowerSecurity(chr))
1142         return false;
1143
1144     std::string chrNameLink = GetNameLink(chr);
1145
1146     if (chr->IsTaxiFlying())
1147     {
1148         PSendSysMessage(LANG_CHAR_IN_FLIGHT, chrNameLink.c_str());
1149         SetSentErrorMessage(true);
1150         return false;
1151     }
1152
1153     PSendSysMessage(LANG_YOU_CHANGE_SWIM_SPEED, modSpeed, chrNameLink.c_str());
1154     if (needReportToTarget(chr))
1155         ChatHandler(chr).PSendSysMessage(LANG_YOURS_SWIM_SPEED_CHANGED, GetNameLink().c_str(), modSpeed);
1156
1157     chr->UpdateSpeed(MOVE_SWIM, true, modSpeed);
1158
1159     return true;
1160 }
1161
1162 // Edit Player Walk Speed
1163 bool ChatHandler::HandleModifyBWalkCommand(char* args)
1164 {
1165     if (!*args)
1166         return false;
1167
1168     float modSpeed = (float)atof(args);
1169
1170     if (modSpeed > 10.0f || modSpeed < 0.1f)
1171     {
1172         SendSysMessage(LANG_BAD_VALUE);
1173         SetSentErrorMessage(true);
1174         return false;
1175     }
1176
1177     Player* chr = getSelectedPlayer();
1178     if (chr == NULL)
1179     {
1180         SendSysMessage(LANG_NO_CHAR_SELECTED);
1181         SetSentErrorMessage(true);
1182         return false;
1183     }
1184
1185     // check online security
1186     if (HasLowerSecurity(chr))
1187         return false;
1188
1189     std::string chrNameLink = GetNameLink(chr);
1190
1191     if (chr->IsTaxiFlying())
1192     {
1193         PSendSysMessage(LANG_CHAR_IN_FLIGHT, chrNameLink.c_str());
1194         SetSentErrorMessage(true);
1195         return false;
1196     }
1197
1198     PSendSysMessage(LANG_YOU_CHANGE_BACK_SPEED, modSpeed, chrNameLink.c_str());
1199     if (needReportToTarget(chr))
1200         ChatHandler(chr).PSendSysMessage(LANG_YOURS_BACK_SPEED_CHANGED, GetNameLink().c_str(), modSpeed);
1201
1202     chr->UpdateSpeed(MOVE_RUN_BACK, true, modSpeed);
1203
1204     return true;
1205 }
1206
1207 // Edit Player Fly
1208 bool ChatHandler::HandleModifyFlyCommand(char* args)
1209 {
1210     if (!*args)
1211         return false;
1212
1213     float modSpeed = (float)atof(args);
1214
1215     if (modSpeed > 10.0f || modSpeed < 0.1f)
1216     {
1217         SendSysMessage(LANG_BAD_VALUE);
1218         SetSentErrorMessage(true);
1219         return false;
1220     }
1221
1222     Player* chr = getSelectedPlayer();
1223     if (chr == NULL)
1224     {
1225         SendSysMessage(LANG_NO_CHAR_SELECTED);
1226         SetSentErrorMessage(true);
1227         return false;
1228     }
1229
1230     // check online security
1231     if (HasLowerSecurity(chr))
1232         return false;
1233
1234     PSendSysMessage(LANG_YOU_CHANGE_FLY_SPEED, modSpeed, GetNameLink(chr).c_str());
1235     if (needReportToTarget(chr))
1236         ChatHandler(chr).PSendSysMessage(LANG_YOURS_FLY_SPEED_CHANGED, GetNameLink().c_str(), modSpeed);
1237
1238     chr->UpdateSpeed(MOVE_FLIGHT, true, modSpeed);
1239
1240     return true;
1241 }
1242
1243 // Edit Player Scale
1244 bool ChatHandler::HandleModifyScaleCommand(char* args)
1245 {
1246     if (!*args)
1247         return false;
1248
1249     float Scale = (float)atof(args);
1250     if (Scale > 10.0f || Scale <= 0.0f)
1251     {
1252         SendSysMessage(LANG_BAD_VALUE);
1253         SetSentErrorMessage(true);
1254         return false;
1255     }
1256
1257     Unit* target = getSelectedUnit();
1258     if (target == NULL)
1259     {
1260         SendSysMessage(LANG_SELECT_CHAR_OR_CREATURE);
1261         SetSentErrorMessage(true);
1262         return false;
1263     }
1264
1265     if (target->GetTypeId() == TYPEID_PLAYER)
1266     {
1267         // check online security
1268         if (HasLowerSecurity((Player*)target))
1269             return false;
1270
1271         PSendSysMessage(LANG_YOU_CHANGE_SIZE, Scale, GetNameLink((Player*)target).c_str());
1272         if (needReportToTarget((Player*)target))
1273             ChatHandler((Player*)target).PSendSysMessage(LANG_YOURS_SIZE_CHANGED, GetNameLink().c_str(), Scale);
1274     }
1275
1276     target->SetObjectScale(Scale);
1277     target->UpdateModelData();
1278
1279     return true;
1280 }
1281
1282 // Enable Player mount
1283 bool ChatHandler::HandleModifyMountCommand(char* args)
1284 {
1285     if (!*args)
1286         return false;
1287
1288     uint16 mId = 1147;
1289     float speed = (float)15;
1290     uint32 num = atoi(args);
1291     switch (num)
1292     {
1293         case 1:
1294             mId = 14340;
1295             break;
1296         case 2:
1297             mId = 4806;
1298             break;
1299         case 3:
1300             mId = 6471;
1301             break;
1302         case 4:
1303             mId = 12345;
1304             break;
1305         case 5:
1306             mId = 6472;
1307             break;
1308         case 6:
1309             mId = 6473;
1310             break;
1311         case 7:
1312             mId = 10670;
1313             break;
1314         case 8:
1315             mId = 10719;
1316             break;
1317         case 9:
1318             mId = 10671;
1319             break;
1320         case 10:
1321             mId = 10672;
1322             break;
1323         case 11:
1324             mId = 10720;
1325             break;
1326         case 12:
1327             mId = 14349;
1328             break;
1329         case 13:
1330             mId = 11641;
1331             break;
1332         case 14:
1333             mId = 12244;
1334             break;
1335         case 15:
1336             mId = 12242;
1337             break;
1338         case 16:
1339             mId = 14578;
1340             break;
1341         case 17:
1342             mId = 14579;
1343             break;
1344         case 18:
1345             mId = 14349;
1346             break;
1347         case 19:
1348             mId = 12245;
1349             break;
1350         case 20:
1351             mId = 14335;
1352             break;
1353         case 21:
1354             mId = 207;
1355             break;
1356         case 22:
1357             mId = 2328;
1358             break;
1359         case 23:
1360             mId = 2327;
1361             break;
1362         case 24:
1363             mId = 2326;
1364             break;
1365         case 25:
1366             mId = 14573;
1367             break;
1368         case 26:
1369             mId = 14574;
1370             break;
1371         case 27:
1372             mId = 14575;
1373             break;
1374         case 28:
1375             mId = 604;
1376             break;
1377         case 29:
1378             mId = 1166;
1379             break;
1380         case 30:
1381             mId = 2402;
1382             break;
1383         case 31:
1384             mId = 2410;
1385             break;
1386         case 32:
1387             mId = 2409;
1388             break;
1389         case 33:
1390             mId = 2408;
1391             break;
1392         case 34:
1393             mId = 2405;
1394             break;
1395         case 35:
1396             mId = 14337;
1397             break;
1398         case 36:
1399             mId = 6569;
1400             break;
1401         case 37:
1402             mId = 10661;
1403             break;
1404         case 38:
1405             mId = 10666;
1406             break;
1407         case 39:
1408             mId = 9473;
1409             break;
1410         case 40:
1411             mId = 9476;
1412             break;
1413         case 41:
1414             mId = 9474;
1415             break;
1416         case 42:
1417             mId = 14374;
1418             break;
1419         case 43:
1420             mId = 14376;
1421             break;
1422         case 44:
1423             mId = 14377;
1424             break;
1425         case 45:
1426             mId = 2404;
1427             break;
1428         case 46:
1429             mId = 2784;
1430             break;
1431         case 47:
1432             mId = 2787;
1433             break;
1434         case 48:
1435             mId = 2785;
1436             break;
1437         case 49:
1438             mId = 2736;
1439             break;
1440         case 50:
1441             mId = 2786;
1442             break;
1443         case 51:
1444             mId = 14347;
1445             break;
1446         case 52:
1447             mId = 14346;
1448             break;
1449         case 53:
1450             mId = 14576;
1451             break;
1452         case 54:
1453             mId = 9695;
1454             break;
1455         case 55:
1456             mId = 9991;
1457             break;
1458         case 56:
1459             mId = 6448;
1460             break;
1461         case 57:
1462             mId = 6444;
1463             break;
1464         case 58:
1465             mId = 6080;
1466             break;
1467         case 59:
1468             mId = 6447;
1469             break;
1470         case 60:
1471             mId = 4805;
1472             break;
1473         case 61:
1474             mId = 9714;
1475             break;
1476         case 62:
1477             mId = 6448;
1478             break;
1479         case 63:
1480             mId = 6442;
1481             break;
1482         case 64:
1483             mId = 14632;
1484             break;
1485         case 65:
1486             mId = 14332;
1487             break;
1488         case 66:
1489             mId = 14331;
1490             break;
1491         case 67:
1492             mId = 8469;
1493             break;
1494         case 68:
1495             mId = 2830;
1496             break;
1497         case 69:
1498             mId = 2346;
1499             break;
1500         default:
1501             SendSysMessage(LANG_NO_MOUNT);
1502             SetSentErrorMessage(true);
1503             return false;
1504     }
1505
1506     Player* chr = getSelectedPlayer();
1507     if (!chr)
1508     {
1509         SendSysMessage(LANG_NO_CHAR_SELECTED);
1510         SetSentErrorMessage(true);
1511         return false;
1512     }
1513
1514     // check online security
1515     if (HasLowerSecurity(chr))
1516         return false;
1517
1518     PSendSysMessage(LANG_YOU_GIVE_MOUNT, GetNameLink(chr).c_str());
1519     if (needReportToTarget(chr))
1520         ChatHandler(chr).PSendSysMessage(LANG_MOUNT_GIVED, GetNameLink().c_str());
1521
1522     chr->SetUInt32Value(UNIT_FIELD_FLAGS, UNIT_FLAG_PVP);
1523     chr->Mount(mId);
1524
1525     ObjectGuid guid = chr->GetObjectGuid();
1526
1527     WorldPacket data(SMSG_MOVE_SET_RUN_SPEED, 8 + 4 + 4);
1528     data.WriteGuidMask<6, 1, 5, 2, 7, 0, 3, 4>(guid);
1529     data.WriteGuidBytes<5, 3, 1, 4>(guid);
1530     data << uint32(0);
1531     data << float(speed);
1532     data.WriteGuidBytes<6, 0, 7, 2>(guid);
1533     chr->SendMessageToSet(&data, true);
1534
1535     data.Initialize(SMSG_MOVE_SET_SWIM_SPEED, 8 + 4 + 4);
1536     data.WriteGuidMask<5, 4, 7, 3, 2, 0, 1, 6>(guid);
1537     data.WriteGuidBytes<0>(guid);
1538     data << uint32(0);
1539     data.WriteGuidBytes<6, 3, 5, 2>(guid);
1540     data << float(speed);
1541     data.WriteGuidBytes<1, 7, 4>(guid);
1542     chr->SendMessageToSet(&data, true);
1543
1544     return true;
1545 }
1546
1547 // Edit Player money
1548 bool ChatHandler::HandleModifyMoneyCommand(char* args)
1549 {
1550     if (!*args)
1551         return false;
1552
1553     Player* chr = getSelectedPlayer();
1554     if (chr == NULL)
1555     {
1556         SendSysMessage(LANG_NO_CHAR_SELECTED);
1557         SetSentErrorMessage(true);
1558         return false;
1559     }
1560
1561     // check online security
1562     if (HasLowerSecurity(chr))
1563         return false;
1564
1565     int64 addmoney;
1566     if (!ExtractInt64(&args, addmoney))
1567         return false;
1568
1569     uint64 moneyuser = chr->GetMoney();
1570
1571     std::stringstream absadd; absadd << abs(addmoney);
1572     std::stringstream add; add << addmoney;
1573
1574     if (addmoney < 0)
1575     {
1576         int64 newmoney = int64(moneyuser) + addmoney;
1577         DETAIL_LOG("USER1: %s, ADD: %s, DIF: %s",
1578             MoneyToString(moneyuser).c_str(), MoneyToString(addmoney).c_str(), MoneyToString(newmoney).c_str());
1579         if (newmoney <= 0)
1580         {
1581             PSendSysMessage(LANG_YOU_TAKE_ALL_MONEY, GetNameLink(chr).c_str());
1582             if (needReportToTarget(chr))
1583                 ChatHandler(chr).PSendSysMessage(LANG_YOURS_ALL_MONEY_GONE, GetNameLink().c_str());
1584
1585             chr->SetMoney(0);
1586         }
1587         else
1588         {
1589             if (newmoney > MAX_MONEY_AMOUNT)
1590                 newmoney = MAX_MONEY_AMOUNT;
1591
1592             PSendSysMessage(LANG_YOU_TAKE_MONEY, MoneyToString(abs(addmoney)).c_str(), GetNameLink(chr).c_str());
1593             if (needReportToTarget(chr))
1594                 ChatHandler(chr).PSendSysMessage(LANG_YOURS_MONEY_TAKEN, GetNameLink().c_str(), MoneyToString(abs(addmoney)).c_str());
1595             chr->SetMoney(newmoney);
1596         }
1597     }
1598     else
1599     {
1600         PSendSysMessage(LANG_YOU_GIVE_MONEY, MoneyToString(addmoney).c_str(), GetNameLink(chr).c_str());
1601         if (needReportToTarget(chr))
1602             ChatHandler(chr).PSendSysMessage(LANG_YOURS_MONEY_GIVEN, GetNameLink().c_str(), MoneyToString(addmoney).c_str());
1603
1604         if (addmoney >= MAX_MONEY_AMOUNT)
1605             chr->SetMoney(MAX_MONEY_AMOUNT);
1606         else
1607             chr->ModifyMoney(addmoney);
1608     }
1609
1610     DETAIL_LOG("USER2: %s, ADD: %s, RESULT: %s\n",
1611         MoneyToString(moneyuser).c_str(), MoneyToString(addmoney).c_str(), MoneyToString(chr->GetMoney()).c_str());
1612
1613     return true;
1614 }
1615
1616 bool ChatHandler::HandleTeleCommand(char* args)
1617 {
1618     if (!*args)
1619         return false;
1620
1621     Player* _player = m_session->GetPlayer();
1622
1623     // id, or string, or [name] Shift-click form |color|Htele:id|h[name]|h|r
1624     GameTele const* tele = ExtractGameTeleFromLink(&args);
1625
1626     if (!tele)
1627     {
1628         SendSysMessage(LANG_COMMAND_TELE_NOTFOUND);
1629         SetSentErrorMessage(true);
1630         return false;
1631     }
1632
1633     return HandleGoHelper(_player, tele->mapId, tele->position_x, tele->position_y, &tele->position_z, &tele->orientation);
1634 }
1635
1636 bool ChatHandler::HandleLookupAreaCommand(char* args)
1637 {
1638     if (!*args)
1639         return false;
1640
1641     std::string namepart = args;
1642     std::wstring wnamepart;
1643
1644     if (!Utf8toWStr(namepart, wnamepart))
1645         return false;
1646
1647     uint32 counter = 0;                                     // Counter for figure out that we found smth.
1648
1649     // converting string that we try to find to lower case
1650     wstrToLower(wnamepart);
1651
1652     // Search in AreaTable.dbc
1653     for (uint32 areaflag = 0; areaflag < sAreaStore.GetNumRows(); ++areaflag)
1654     {
1655         AreaTableEntry const* areaEntry = sAreaStore.LookupEntry(areaflag);
1656         if (areaEntry)
1657         {
1658             int loc = GetSessionDbcLocale();
1659             std::string name = areaEntry->area_name[loc];
1660             if (name.empty())
1661                 continue;
1662
1663             if (!Utf8FitTo(name, wnamepart))
1664             {
1665                 loc = 0;
1666                 for (; loc < MAX_LOCALE; ++loc)
1667                 {
1668                     if (loc == GetSessionDbcLocale())
1669                         continue;
1670
1671                     name = areaEntry->area_name[loc];
1672                     if (name.empty())
1673                         continue;
1674
1675                     if (Utf8FitTo(name, wnamepart))
1676                         break;
1677                 }
1678             }
1679
1680             if (loc < MAX_LOCALE)
1681             {
1682                 // send area in "id - [name]" format
1683                 std::ostringstream ss;
1684                 if (m_session)
1685                     ss << areaEntry->ID << " - |cffffffff|Harea:" << areaEntry->ID << "|h[" << name << " " << localeNames[loc] << "]|h|r";
1686                 else
1687                     ss << areaEntry->ID << " - " << name << " " << localeNames[loc];
1688
1689                 SendSysMessage(ss.str().c_str());
1690
1691                 ++counter;
1692             }
1693         }
1694     }
1695
1696     if (counter == 0)                                      // if counter == 0 then we found nth
1697         SendSysMessage(LANG_COMMAND_NOAREAFOUND);
1698
1699     return true;
1700 }
1701
1702 // Find tele in game_tele order by name
1703 bool ChatHandler::HandleLookupTeleCommand(char* args)
1704 {
1705     if (!*args)
1706     {
1707         SendSysMessage(LANG_COMMAND_TELE_PARAMETER);
1708         SetSentErrorMessage(true);
1709         return false;
1710     }
1711
1712     std::string namepart = args;
1713     std::wstring wnamepart;
1714
1715     if (!Utf8toWStr(namepart, wnamepart))
1716         return false;
1717
1718     // converting string that we try to find to lower case
1719     wstrToLower(wnamepart);
1720
1721     std::ostringstream reply;
1722
1723     GameTeleMap const& teleMap = sObjectMgr.GetGameTeleMap();
1724     for (GameTeleMap::const_iterator itr = teleMap.begin(); itr != teleMap.end(); ++itr)
1725     {
1726         GameTele const* tele = &itr->second;
1727
1728         if (tele->wnameLow.find(wnamepart) == std::wstring::npos)
1729             continue;
1730
1731         if (m_session)
1732             reply << "  |cffffffff|Htele:" << itr->first << "|h[" << tele->name << "]|h|r\n";
1733         else
1734             reply << "  " << itr->first << " " << tele->name << "\n";
1735     }
1736
1737     if (reply.str().empty())
1738         SendSysMessage(LANG_COMMAND_TELE_NOLOCATION);
1739     else
1740         PSendSysMessage(LANG_COMMAND_TELE_LOCATION, reply.str().c_str());
1741
1742     return true;
1743 }
1744
1745 // Enable\Dissable accept whispers (for GM)
1746 bool ChatHandler::HandleWhispersCommand(char* args)
1747 {
1748     if (!*args)
1749     {
1750         PSendSysMessage(LANG_COMMAND_WHISPERACCEPTING, GetOnOffStr(m_session->GetPlayer()->isAcceptWhispers()));
1751         return true;
1752     }
1753
1754     bool value;
1755     if (!ExtractOnOff(&args, value))
1756     {
1757         SendSysMessage(LANG_USE_BOL);
1758         SetSentErrorMessage(true);
1759         return false;
1760     }
1761
1762     // whisper on
1763     if (value)
1764     {
1765         m_session->GetPlayer()->SetAcceptWhispers(true);
1766         SendSysMessage(LANG_COMMAND_WHISPERON);
1767     }
1768     // whisper off
1769     else
1770     {
1771         m_session->GetPlayer()->SetAcceptWhispers(false);
1772         SendSysMessage(LANG_COMMAND_WHISPEROFF);
1773     }
1774
1775     return true;
1776 }
1777
1778 // Save all players in the world
1779 bool ChatHandler::HandleSaveAllCommand(char* /*args*/)
1780 {
1781     sObjectAccessor.SaveAllPlayers();
1782     SendSysMessage(LANG_PLAYERS_SAVED);
1783     return true;
1784 }
1785
1786 // Send mail by command
1787 bool ChatHandler::HandleSendMailCommand(char* args)
1788 {
1789     // format: name "subject text" "mail text"
1790     Player* target;
1791     ObjectGuid target_guid;
1792     std::string target_name;
1793     if (!ExtractPlayerTarget(&args, &target, &target_guid, &target_name))
1794         return false;
1795
1796     MailDraft draft;
1797
1798     // fill draft
1799     if (!HandleSendMailHelper(draft, args))
1800         return false;
1801
1802     // from console show nonexistent sender
1803     MailSender sender(MAIL_NORMAL, m_session ? m_session->GetPlayer()->GetObjectGuid().GetCounter() : 0, MAIL_STATIONERY_GM);
1804
1805     draft.SendMailTo(MailReceiver(target, target_guid), sender);
1806
1807     std::string nameLink = playerLink(target_name);
1808     PSendSysMessage(LANG_MAIL_SENT, nameLink.c_str());
1809     return true;
1810 }
1811
1812 // teleport player to given game_tele.entry
1813 bool ChatHandler::HandleTeleNameCommand(char* args)
1814 {
1815     char* nameStr = ExtractOptNotLastArg(&args);
1816
1817     Player* target;
1818     ObjectGuid target_guid;
1819     std::string target_name;
1820     if (!ExtractPlayerTarget(&nameStr, &target, &target_guid, &target_name))
1821         return false;
1822
1823     // id, or string, or [name] Shift-click form |color|Htele:id|h[name]|h|r
1824     GameTele const* tele = ExtractGameTeleFromLink(&args);
1825     if (!tele)
1826     {
1827         SendSysMessage(LANG_COMMAND_TELE_NOTFOUND);
1828         SetSentErrorMessage(true);
1829         return false;
1830     }
1831
1832     if (target)
1833     {
1834         // check online security
1835         if (HasLowerSecurity(target))
1836             return false;
1837
1838         std::string chrNameLink = playerLink(target_name);
1839
1840         if (target->IsBeingTeleported() == true)
1841         {
1842             PSendSysMessage(LANG_IS_TELEPORTED, chrNameLink.c_str());
1843             SetSentErrorMessage(true);
1844             return false;
1845         }
1846
1847         PSendSysMessage(LANG_TELEPORTING_TO, chrNameLink.c_str(), "", tele->name.c_str());
1848         if (needReportToTarget(target))
1849             ChatHandler(target).PSendSysMessage(LANG_TELEPORTED_TO_BY, GetNameLink().c_str());
1850
1851         return HandleGoHelper(target, tele->mapId, tele->position_x, tele->position_y, &tele->position_z, &tele->orientation);
1852     }
1853     else
1854     {
1855         // check offline security
1856         if (HasLowerSecurity(NULL, target_guid))
1857             return false;
1858
1859         std::string nameLink = playerLink(target_name);
1860
1861         PSendSysMessage(LANG_TELEPORTING_TO, nameLink.c_str(), GetMangosString(LANG_OFFLINE), tele->name.c_str());
1862         Player::SavePositionInDB(target_guid, tele->mapId,
1863                                  tele->position_x, tele->position_y, tele->position_z, tele->orientation,
1864                                  sTerrainMgr.GetZoneId(tele->mapId, tele->position_x, tele->position_y, tele->position_z));
1865     }
1866
1867     return true;
1868 }
1869
1870 // Teleport group to given game_tele.entry
1871 bool ChatHandler::HandleTeleGroupCommand(char* args)
1872 {
1873     if (!*args)
1874         return false;
1875
1876     Player* player = getSelectedPlayer();
1877     if (!player)
1878     {
1879         SendSysMessage(LANG_NO_CHAR_SELECTED);
1880         SetSentErrorMessage(true);
1881         return false;
1882     }
1883
1884     // check online security
1885     if (HasLowerSecurity(player))
1886         return false;
1887
1888     // id, or string, or [name] Shift-click form |color|Htele:id|h[name]|h|r
1889     GameTele const* tele = ExtractGameTeleFromLink(&args);
1890     if (!tele)
1891     {
1892         SendSysMessage(LANG_COMMAND_TELE_NOTFOUND);
1893         SetSentErrorMessage(true);
1894         return false;
1895     }
1896
1897     std::string nameLink = GetNameLink(player);
1898
1899     Group* grp = player->GetGroup();
1900     if (!grp)
1901     {
1902         PSendSysMessage(LANG_NOT_IN_GROUP, nameLink.c_str());
1903         SetSentErrorMessage(true);
1904         return false;
1905     }
1906
1907     for (GroupReference* itr = grp->GetFirstMember(); itr != NULL; itr = itr->next())
1908     {
1909         Player* pl = itr->getSource();
1910
1911         if (!pl || !pl->GetSession())
1912             continue;
1913
1914         // check online security
1915         if (HasLowerSecurity(pl))
1916             return false;
1917
1918         std::string plNameLink = GetNameLink(pl);
1919
1920         if (pl->IsBeingTeleported())
1921         {
1922             PSendSysMessage(LANG_IS_TELEPORTED, plNameLink.c_str());
1923             continue;
1924         }
1925
1926         PSendSysMessage(LANG_TELEPORTING_TO, plNameLink.c_str(), "", tele->name.c_str());
1927         if (needReportToTarget(pl))
1928             ChatHandler(pl).PSendSysMessage(LANG_TELEPORTED_TO_BY, nameLink.c_str());
1929
1930         // stop flight if need
1931         if (pl->IsTaxiFlying())
1932         {
1933             pl->GetMotionMaster()->MovementExpired();
1934             pl->m_taxi.ClearTaxiDestinations();
1935         }
1936         // save only in non-flight case
1937         else
1938             pl->SaveRecallPosition();
1939
1940         pl->TeleportTo(tele->mapId, tele->position_x, tele->position_y, tele->position_z, tele->orientation);
1941     }
1942
1943     return true;
1944 }
1945
1946 // Summon group of player
1947 bool ChatHandler::HandleGroupgoCommand(char* args)
1948 {
1949     Player* target;
1950     if (!ExtractPlayerTarget(&args, &target))
1951         return false;
1952
1953     // check online security
1954     if (HasLowerSecurity(target))
1955         return false;
1956
1957     Group* grp = target->GetGroup();
1958
1959     std::string nameLink = GetNameLink(target);
1960
1961     if (!grp)
1962     {
1963         PSendSysMessage(LANG_NOT_IN_GROUP, nameLink.c_str());
1964         SetSentErrorMessage(true);
1965         return false;
1966     }
1967
1968     Map* gmMap = m_session->GetPlayer()->GetMap();
1969     bool to_instance =  gmMap->Instanceable();
1970
1971     // we are in instance, and can summon only player in our group with us as lead
1972     if (to_instance && (
1973                 !m_session->GetPlayer()->GetGroup() || (grp->GetLeaderGuid() != m_session->GetPlayer()->GetObjectGuid()) ||
1974                 (m_session->GetPlayer()->GetGroup()->GetLeaderGuid() != m_session->GetPlayer()->GetObjectGuid())))
1975         // the last check is a bit excessive, but let it be, just in case
1976     {
1977         SendSysMessage(LANG_CANNOT_SUMMON_TO_INST);
1978         SetSentErrorMessage(true);
1979         return false;
1980     }
1981
1982     for (GroupReference* itr = grp->GetFirstMember(); itr != NULL; itr = itr->next())
1983     {
1984         Player* pl = itr->getSource();
1985
1986         if (!pl || pl == m_session->GetPlayer() || !pl->GetSession())
1987             continue;
1988
1989         // check online security
1990         if (HasLowerSecurity(pl))
1991             return false;
1992
1993         std::string plNameLink = GetNameLink(pl);
1994
1995         if (pl->IsBeingTeleported() == true)
1996         {
1997             PSendSysMessage(LANG_IS_TELEPORTED, plNameLink.c_str());
1998             SetSentErrorMessage(true);
1999             return false;
2000         }
2001
2002         if (to_instance)
2003         {
2004             Map* plMap = pl->GetMap();
2005
2006             if (plMap->Instanceable() && plMap->GetInstanceId() != gmMap->GetInstanceId())
2007             {
2008                 // cannot summon from instance to instance
2009                 PSendSysMessage(LANG_CANNOT_SUMMON_TO_INST, plNameLink.c_str());
2010                 SetSentErrorMessage(true);
2011                 return false;
2012             }
2013         }
2014
2015         PSendSysMessage(LANG_SUMMONING, plNameLink.c_str(), "");
2016         if (needReportToTarget(pl))
2017             ChatHandler(pl).PSendSysMessage(LANG_SUMMONED_BY, nameLink.c_str());
2018
2019         // stop flight if need
2020         if (pl->IsTaxiFlying())
2021         {
2022             pl->GetMotionMaster()->MovementExpired();
2023             pl->m_taxi.ClearTaxiDestinations();
2024         }
2025         // save only in non-flight case
2026         else
2027             pl->SaveRecallPosition();
2028
2029         // before GM
2030         float x, y, z;
2031         m_session->GetPlayer()->GetClosePoint(x, y, z, pl->GetObjectBoundingRadius());
2032         pl->TeleportTo(m_session->GetPlayer()->GetMapId(), x, y, z, pl->GetOrientation());
2033     }
2034
2035     return true;
2036 }
2037
2038 bool ChatHandler::HandleGoHelper(Player* player, uint32 mapid, float x, float y, float const* zPtr, float const* ortPtr)
2039 {
2040     float z;
2041     float ort = player->GetOrientation();
2042
2043     if (zPtr)
2044     {
2045         z = *zPtr;
2046
2047         if (ortPtr)
2048             ort = *ortPtr;
2049
2050         // check full provided coordinates
2051         if (!MapManager::IsValidMapCoord(mapid, x, y, z, ort))
2052         {
2053             PSendSysMessage(LANG_INVALID_TARGET_COORD, x, y, mapid);
2054             SetSentErrorMessage(true);
2055             return false;
2056         }
2057     }
2058     else
2059     {
2060         // we need check x,y before ask Z or can crash at invalide coordinates
2061         if (!MapManager::IsValidMapCoord(mapid, x, y))
2062         {
2063             PSendSysMessage(LANG_INVALID_TARGET_COORD, x, y, mapid);
2064             SetSentErrorMessage(true);
2065             return false;
2066         }
2067
2068         TerrainInfo const* map = sTerrainMgr.LoadTerrain(mapid);
2069         z = map->GetWaterOrGroundLevel(x, y, MAX_HEIGHT);
2070     }
2071
2072     // stop flight if need
2073     if (player->IsTaxiFlying())
2074     {
2075         player->GetMotionMaster()->MovementExpired();
2076         player->m_taxi.ClearTaxiDestinations();
2077     }
2078     // save only in non-flight case
2079     else
2080         player->SaveRecallPosition();
2081
2082     player->TeleportTo(mapid, x, y, z, ort);
2083
2084     return true;
2085 }
2086
2087 bool ChatHandler::HandleGoTaxinodeCommand(char* args)
2088 {
2089     Player* _player = m_session->GetPlayer();
2090
2091     uint32 nodeId;
2092     if (!ExtractUint32KeyFromLink(&args, "Htaxinode", nodeId))
2093         return false;
2094
2095     TaxiNodesEntry const* node = sTaxiNodesStore.LookupEntry(nodeId);
2096     if (!node)
2097     {
2098         PSendSysMessage(LANG_COMMAND_GOTAXINODENOTFOUND, nodeId);
2099         SetSentErrorMessage(true);
2100         return false;
2101     }
2102
2103     if (node->x == 0.0f && node->y == 0.0f && node->z == 0.0f)
2104     {
2105         PSendSysMessage(LANG_INVALID_TARGET_COORD, node->x, node->y, node->map_id);
2106         SetSentErrorMessage(true);
2107         return false;
2108     }
2109
2110     return HandleGoHelper(_player, node->map_id, node->x, node->y, &node->z);
2111 }
2112
2113 bool ChatHandler::HandleGoCommand(char* args)
2114 {
2115     if (!*args)
2116         return false;
2117
2118     Player* _player = m_session->GetPlayer();
2119
2120     uint32 mapid;
2121     float x, y, z;
2122
2123     // raw coordinates case
2124     if (ExtractFloat(&args, x))
2125     {
2126         if (!ExtractFloat(&args, y))
2127             return false;
2128
2129         if (!ExtractFloat(&args, z))
2130             return false;
2131
2132         if (!ExtractOptUInt32(&args, mapid, _player->GetMapId()))
2133             return false;
2134     }
2135     // link case
2136     else if (!ExtractLocationFromLink(&args, mapid, x, y, z))
2137         return false;
2138
2139     return HandleGoHelper(_player, mapid, x, y, &z);
2140 }
2141
2142
2143
2144 // teleport at coordinates
2145 bool ChatHandler::HandleGoXYCommand(char* args)
2146 {
2147     Player* _player = m_session->GetPlayer();
2148
2149     float x;
2150     if (!ExtractFloat(&args, x))
2151         return false;
2152
2153     float y;
2154     if (!ExtractFloat(&args, y))
2155         return false;
2156
2157     uint32 mapid;
2158     if (!ExtractOptUInt32(&args, mapid, _player->GetMapId()))
2159         return false;
2160
2161     return HandleGoHelper(_player, mapid, x, y);
2162 }
2163
2164 // teleport at coordinates, including Z
2165 bool ChatHandler::HandleGoXYZCommand(char* args)
2166 {
2167     Player* _player = m_session->GetPlayer();
2168
2169     float x;
2170     if (!ExtractFloat(&args, x))
2171         return false;
2172
2173     float y;
2174     if (!ExtractFloat(&args, y))
2175         return false;
2176
2177     float z;
2178     if (!ExtractFloat(&args, z))
2179         return false;
2180
2181     uint32 mapid;
2182     if (!ExtractOptUInt32(&args, mapid, _player->GetMapId()))
2183         return false;
2184
2185     return HandleGoHelper(_player, mapid, x, y, &z);
2186 }
2187
2188 // teleport at coordinates
2189 bool ChatHandler::HandleGoZoneXYCommand(char* args)
2190 {
2191     Player* _player = m_session->GetPlayer();
2192
2193     float x;
2194     if (!ExtractFloat(&args, x))
2195         return false;
2196
2197     float y;
2198     if (!ExtractFloat(&args, y))
2199         return false;
2200
2201     uint32 areaid;
2202     if (*args)
2203     {
2204         if (!ExtractUint32KeyFromLink(&args, "Harea", areaid))
2205             return false;
2206     }
2207     else
2208         areaid = _player->GetZoneId();
2209
2210     AreaTableEntry const* areaEntry = GetAreaEntryByAreaID(areaid);
2211
2212     if (x < 0 || x > 100 || y < 0 || y > 100 || !areaEntry)
2213     {
2214         PSendSysMessage(LANG_INVALID_ZONE_COORD, x, y, areaid);
2215         SetSentErrorMessage(true);
2216         return false;
2217     }
2218
2219     // update to parent zone if exist (client map show only zones without parents)
2220     AreaTableEntry const* zoneEntry = areaEntry->zone ? GetAreaEntryByAreaID(areaEntry->zone) : areaEntry;
2221
2222     MapEntry const* mapEntry = sMapStore.LookupEntry(zoneEntry->mapid);
2223
2224     if (mapEntry->Instanceable())
2225     {
2226         PSendSysMessage(LANG_INVALID_ZONE_MAP, areaEntry->ID, areaEntry->area_name[GetSessionDbcLocale()],
2227                         mapEntry->MapID, mapEntry->name[GetSessionDbcLocale()]);
2228         SetSentErrorMessage(true);
2229         return false;
2230     }
2231
2232     if (!Zone2MapCoordinates(x, y, zoneEntry->ID))
2233     {
2234         PSendSysMessage(LANG_INVALID_ZONE_MAP, areaEntry->ID, areaEntry->area_name[GetSessionDbcLocale()],
2235                         mapEntry->MapID, mapEntry->name[GetSessionDbcLocale()]);
2236         SetSentErrorMessage(true);
2237         return false;
2238     }
2239
2240     return HandleGoHelper(_player, mapEntry->MapID, x, y);
2241 }
2242
2243 // teleport to grid
2244 bool ChatHandler::HandleGoGridCommand(char* args)
2245 {
2246     Player* _player = m_session->GetPlayer();
2247
2248     float grid_x;
2249     if (!ExtractFloat(&args, grid_x))
2250         return false;
2251
2252     float grid_y;
2253     if (!ExtractFloat(&args, grid_y))
2254         return false;
2255
2256     uint32 mapid;
2257     if (!ExtractOptUInt32(&args, mapid, _player->GetMapId()))
2258         return false;
2259
2260     // center of grid
2261     float x = (grid_x - CENTER_GRID_ID + 0.5f) * SIZE_OF_GRIDS;
2262     float y = (grid_y - CENTER_GRID_ID + 0.5f) * SIZE_OF_GRIDS;
2263
2264     return HandleGoHelper(_player, mapid, x, y);
2265 }
2266
2267 bool ChatHandler::HandleModifyDrunkCommand(char* args)
2268 {
2269     if (!*args)    return false;
2270
2271     uint32 drunklevel = (uint32)atoi(args);
2272     if (drunklevel > 100)
2273         drunklevel = 100;
2274
2275     uint16 drunkMod = drunklevel * 0xFFFF / 100;
2276
2277     m_session->GetPlayer()->SetDrunkValue(drunkMod);
2278
2279     return true;
2280 }
2281
2282 bool ChatHandler::HandleSetViewCommand(char* /*args*/)
2283 {
2284     if (Unit* unit = getSelectedUnit())
2285         m_session->GetPlayer()->GetCamera().SetView(unit);
2286     else
2287     {
2288         PSendSysMessage(LANG_SELECT_CHAR_OR_CREATURE);
2289         SetSentErrorMessage(true);
2290         return false;
2291     }
2292
2293     return true;
2294 }