src/game/Level1.cpp

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