src/game/Level2.cpp

   1 /*
   2  * Copyright (C) 2005-2008 MaNGOS <http://getmangos.com/>
   3  *
   4  * This program is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License as published by
   6  * the Free Software Foundation; either version 2 of the License, or
   7  * (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, write to the Free Software
  16  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  17  */
  18
  19 #include "Common.h"
  20 #include "Database/DatabaseEnv.h"
  21 #include "WorldPacket.h"
  22 #include "WorldSession.h"
  23 #include "World.h"
  24 #include "ObjectMgr.h"
  25 #include "Player.h"
  26 #include "Item.h"
  27 #include "GameObject.h"
  28 #include "Opcodes.h"
  29 #include "Chat.h"
  30 #include "ObjectAccessor.h"
  31 #include "MapManager.h"
  32 #include "Language.h"
  33 #include "World.h"
  34 #include "GameEvent.h"
  35 #include "SpellMgr.h"
  36 #include "AccountMgr.h"
  37 #include "GMTicketMgr.h"
  38 #include "WaypointManager.h"
  39 #include "Util.h"
  40 #include <cctype>
  41 #include <iostream>
  42 #include <fstream>
  43 #include <map>
  44 #include "GlobalEvents.h"
  45
  46 #include "TargetedMovementGenerator.h"                      // for HandleNpcUnFollowCommand
  47
  48 static uint32 ReputationRankStrIndex[MAX_REPUTATION_RANK] =
  49 {
  50     LANG_REP_HATED,    LANG_REP_HOSTILE, LANG_REP_UNFRIENDLY, LANG_REP_NEUTRAL,
  51     LANG_REP_FRIENDLY, LANG_REP_HONORED, LANG_REP_REVERED,    LANG_REP_EXALTED
  52 };
  53
  54 //mute player for some times
  55 bool ChatHandler::HandleMuteCommand(const char* args)
  56 {
  57     if (!*args)
  58         return false;
  59
  60     char *charname = strtok((char*)args, " ");
  61     if (!charname)
  62         return false;
  63
  64     std::string cname = charname;
  65
  66     char *timetonotspeak = strtok(NULL, " ");
  67     if(!timetonotspeak)
  68         return false;
  69
  70     uint32 notspeaktime = (uint32) atoi(timetonotspeak);
  71
  72     if(!normalizePlayerName(cname))
  73     {
  74         SendSysMessage(LANG_PLAYER_NOT_FOUND);
  75         SetSentErrorMessage(true);
  76         return false;
  77     }
  78
  79     uint64 guid = objmgr.GetPlayerGUIDByName(cname.c_str());
  80     if(!guid)
  81     {
  82         SendSysMessage(LANG_PLAYER_NOT_FOUND);
  83         SetSentErrorMessage(true);
  84         return false;
  85     }
  86
  87     Player *chr = objmgr.GetPlayer(guid);
  88
  89     // check security
  90     uint32 account_id = 0;
  91     uint32 security = 0;
  92
  93     if (chr)
  94     {
  95         account_id = chr->GetSession()->GetAccountId();
  96         security = chr->GetSession()->GetSecurity();
  97     }
  98     else
  99     {
 100         account_id = objmgr.GetPlayerAccountIdByGUID(guid);
 101         security = accmgr.GetSecurity(account_id);
 102     }
 103
 104     if(m_session && security >= m_session->GetSecurity())
 105     {
 106         SendSysMessage(LANG_YOURS_SECURITY_IS_LOW);
 107         SetSentErrorMessage(true);
 108         return false;
 109     }
 110
 111     time_t mutetime = time(NULL) + notspeaktime*60;
 112
 113     if (chr)
 114         chr->GetSession()->m_muteTime = mutetime;
 115
 116     loginDatabase.PExecute("UPDATE account SET mutetime = " I64FMTD " WHERE id = '%u'",uint64(mutetime), account_id );
 117
 118     if(chr)
 119         ChatHandler(chr).PSendSysMessage(LANG_YOUR_CHAT_DISABLED, notspeaktime);
 120
 121     PSendSysMessage(LANG_YOU_DISABLE_CHAT, cname.c_str(), notspeaktime);
 122
 123     return true;
 124 }
 125
 126 //unmute player
 127 bool ChatHandler::HandleUnmuteCommand(const char* args)
 128 {
 129     if (!*args)
 130         return false;
 131
 132     char *charname = strtok((char*)args, " ");
 133     if (!charname)
 134         return false;
 135
 136     std::string cname = charname;
 137
 138     if(!normalizePlayerName(cname))
 139     {
 140         SendSysMessage(LANG_PLAYER_NOT_FOUND);
 141         SetSentErrorMessage(true);
 142         return false;
 143     }
 144
 145     uint64 guid = objmgr.GetPlayerGUIDByName(cname.c_str());
 146     if(!guid)
 147     {
 148         SendSysMessage(LANG_PLAYER_NOT_FOUND);
 149         SetSentErrorMessage(true);
 150         return false;
 151     }
 152
 153     Player *chr = objmgr.GetPlayer(guid);
 154
 155     // check security
 156     uint32 account_id = 0;
 157     uint32 security = 0;
 158
 159     if (chr)
 160     {
 161         account_id = chr->GetSession()->GetAccountId();
 162         security = chr->GetSession()->GetSecurity();
 163     }
 164     else
 165     {
 166         account_id = objmgr.GetPlayerAccountIdByGUID(guid);
 167         security = accmgr.GetSecurity(account_id);
 168     }
 169
 170     if(m_session && security >= m_session->GetSecurity())
 171     {
 172         SendSysMessage(LANG_YOURS_SECURITY_IS_LOW);
 173         SetSentErrorMessage(true);
 174         return false;
 175     }
 176
 177     if (chr)
 178     {
 179         if(chr->CanSpeak())
 180         {
 181             SendSysMessage(LANG_CHAT_ALREADY_ENABLED);
 182             SetSentErrorMessage(true);
 183             return false;
 184         }
 185
 186         chr->GetSession()->m_muteTime = 0;
 187     }
 188
 189     loginDatabase.PExecute("UPDATE account SET mutetime = '0' WHERE id = '%u'", account_id );
 190
 191     if(chr)
 192         ChatHandler(chr).PSendSysMessage(LANG_YOUR_CHAT_ENABLED);
 193
 194     PSendSysMessage(LANG_YOU_ENABLE_CHAT, cname.c_str());
 195     return true;
 196 }
 197
 198 bool ChatHandler::HandleTargetObjectCommand(const char* args)
 199 {
 200     Player* pl = m_session->GetPlayer();
 201     QueryResult *result;
 202     GameEvent::ActiveEvents const& activeEventsList = gameeventmgr.GetActiveEventList();
 203     if(*args)
 204     {
 205         int32 id = atoi((char*)args);
 206         if(id)
 207             result = WorldDatabase.PQuery("SELECT guid, id, position_x, position_y, position_z, orientation, map, (POW(position_x - '%f', 2) + POW(position_y - '%f', 2) + POW(position_z - '%f', 2)) AS order_ FROM gameobject WHERE map = '%i' AND id = '%u' ORDER BY order_ ASC LIMIT 1",
 208                 pl->GetPositionX(), pl->GetPositionY(), pl->GetPositionZ(), pl->GetMapId(),id);
 209         else
 210         {
 211             std::string name = args;
 212             WorldDatabase.escape_string(name);
 213             result = WorldDatabase.PQuery(
 214                 "SELECT guid, id, position_x, position_y, position_z, orientation, map, (POW(position_x - %f, 2) + POW(position_y - %f, 2) + POW(position_z - %f, 2)) AS order_ "
 215                 "FROM gameobject,gameobject_template WHERE gameobject_template.entry = gameobject.id AND map = %i AND name "_LIKE_" "_CONCAT3_("'%%'","'%s'","'%%'")" ORDER BY order_ ASC LIMIT 1",
 216                 pl->GetPositionX(), pl->GetPositionY(), pl->GetPositionZ(), pl->GetMapId(),name.c_str());
 217         }
 218     }
 219     else
 220     {
 221         std::ostringstream eventFilter;
 222         eventFilter << " AND (event IS NULL ";
 223         bool initString = true;
 224
 225         for (GameEvent::ActiveEvents::const_iterator itr = activeEventsList.begin(); itr != activeEventsList.end(); ++itr)
 226         {
 227             if (initString)
 228             {
 229                 eventFilter  <<  "OR event IN (" <<*itr;
 230                 initString =false;
 231             }
 232             else
 233                 eventFilter << "," << *itr;
 234         }
 235
 236         if (!initString)
 237             eventFilter << "))";
 238         else
 239             eventFilter << ")";
 240
 241         result = WorldDatabase.PQuery("SELECT gameobject.guid, id, position_x, position_y, position_z, orientation, map, "
 242             "(POW(position_x - %f, 2) + POW(position_y - %f, 2) + POW(position_z - %f, 2)) AS order_ FROM gameobject "
 243             "LEFT OUTER JOIN game_event_gameobject on gameobject.guid=game_event_gameobject.guid WHERE map = '%i' %s ORDER BY order_ ASC LIMIT 1",
 244             m_session->GetPlayer()->GetPositionX(), m_session->GetPlayer()->GetPositionY(), m_session->GetPlayer()->GetPositionZ(), m_session->GetPlayer()->GetMapId(),eventFilter.str().c_str());
 245     }
 246
 247     if (!result)
 248     {
 249         SendSysMessage(LANG_COMMAND_TARGETOBJNOTFOUND);
 250         return true;
 251     }
 252
 253     Field *fields = result->Fetch();
 254     uint32 lowguid = fields[0].GetUInt32();
 255     uint32 id = fields[1].GetUInt32();
 256     float x = fields[2].GetFloat();
 257     float y = fields[3].GetFloat();
 258     float z = fields[4].GetFloat();
 259     float o = fields[5].GetFloat();
 260     int mapid = fields[6].GetUInt16();
 261     delete result;
 262
 263     GameObjectInfo const* goI = objmgr.GetGameObjectInfo(id);
 264
 265     if (!goI)
 266     {
 267         PSendSysMessage(LANG_GAMEOBJECT_NOT_EXIST,id);
 268         return false;
 269     }
 270
 271     GameObject* target = ObjectAccessor::GetGameObject(*m_session->GetPlayer(),MAKE_NEW_GUID(lowguid,id,HIGHGUID_GAMEOBJECT));
 272
 273     PSendSysMessage(LANG_GAMEOBJECT_DETAIL, lowguid, goI->name, lowguid, id, x, y, z, mapid, o);
 274
 275     if(target)
 276     {
 277         int32 curRespawnDelay = target->GetRespawnTimeEx()-time(NULL);
 278         if(curRespawnDelay < 0)
 279             curRespawnDelay = 0;
 280
 281         std::string curRespawnDelayStr = secsToTimeString(curRespawnDelay,true);
 282         std::string defRespawnDelayStr = secsToTimeString(target->GetRespawnDelay(),true);
 283
 284         PSendSysMessage(LANG_COMMAND_RAWPAWNTIMES, defRespawnDelayStr.c_str(),curRespawnDelayStr.c_str());
 285     }
 286     return true;
 287 }
 288
 289 //teleport to gameobject
 290 bool ChatHandler::HandleGoObjectCommand(const char* args)
 291 {
 292     if(!*args)
 293         return false;
 294
 295     Player* _player = m_session->GetPlayer();
 296
 297     // number or [name] Shift-click form |color|Hgameobject:go_guid|h[name]|h|r
 298     char* cId = extractKeyFromLink((char*)args,"Hgameobject");
 299     if(!cId)
 300         return false;
 301
 302     int32 guid = atoi(cId);
 303     if(!guid)
 304         return false;
 305
 306     float x, y, z, ort;
 307     int mapid;
 308
 309     // by DB guid
 310     if (GameObjectData const* go_data = objmgr.GetGOData(guid))
 311     {
 312         x = go_data->posX;
 313         y = go_data->posY;
 314         z = go_data->posZ;
 315         ort = go_data->orientation;
 316         mapid = go_data->mapid;
 317     }
 318     else
 319     {
 320         SendSysMessage(LANG_COMMAND_GOOBJNOTFOUND);
 321         SetSentErrorMessage(true);
 322         return false;
 323     }
 324
 325     if(!MapManager::IsValidMapCoord(mapid,x,y,z,ort))
 326     {
 327         PSendSysMessage(LANG_INVALID_TARGET_COORD,x,y,mapid);
 328         SetSentErrorMessage(true);
 329         return false;
 330     }
 331
 332     // stop flight if need
 333     if(_player->isInFlight())
 334     {
 335         _player->GetMotionMaster()->MovementExpired();
 336         _player->m_taxi.ClearTaxiDestinations();
 337     }
 338     // save only in non-flight case
 339     else
 340         _player->SaveRecallPosition();
 341
 342     _player->TeleportTo(mapid, x, y, z, ort);
 343     return true;
 344 }
 345
 346 bool ChatHandler::HandleGoTriggerCommand(const char* args)
 347 {
 348     Player* _player = m_session->GetPlayer();
 349
 350     if (!*args)
 351         return false;
 352
 353     char *atId = strtok((char*)args, " ");
 354     if (!atId)
 355         return false;
 356
 357     int32 i_atId = atoi(atId);
 358
 359     if(!i_atId)
 360         return false;
 361
 362     AreaTriggerEntry const* at = sAreaTriggerStore.LookupEntry(i_atId);
 363     if (!at)
 364     {
 365         PSendSysMessage(LANG_COMMAND_GOAREATRNOTFOUND,i_atId);
 366         SetSentErrorMessage(true);
 367         return false;
 368     }
 369
 370     if(!MapManager::IsValidMapCoord(at->mapid,at->x,at->y,at->z))
 371     {
 372         PSendSysMessage(LANG_INVALID_TARGET_COORD,at->x,at->y,at->mapid);
 373         SetSentErrorMessage(true);
 374         return false;
 375     }
 376
 377     // stop flight if need
 378     if(_player->isInFlight())
 379     {
 380         _player->GetMotionMaster()->MovementExpired();
 381         _player->m_taxi.ClearTaxiDestinations();
 382     }
 383     // save only in non-flight case
 384     else
 385         _player->SaveRecallPosition();
 386
 387     _player->TeleportTo(at->mapid, at->x, at->y, at->z, _player->GetOrientation());
 388     return true;
 389 }
 390
 391 bool ChatHandler::HandleGoGraveyardCommand(const char* args)
 392 {
 393     Player* _player = m_session->GetPlayer();
 394
 395     if (!*args)
 396         return false;
 397
 398     char *gyId = strtok((char*)args, " ");
 399     if (!gyId)
 400         return false;
 401
 402     int32 i_gyId = atoi(gyId);
 403
 404     if(!i_gyId)
 405         return false;
 406
 407     WorldSafeLocsEntry const* gy = sWorldSafeLocsStore.LookupEntry(i_gyId);
 408     if (!gy)
 409     {
 410         PSendSysMessage(LANG_COMMAND_GRAVEYARDNOEXIST,i_gyId);
 411         SetSentErrorMessage(true);
 412         return false;
 413     }
 414
 415     if(!MapManager::IsValidMapCoord(gy->map_id,gy->x,gy->y,gy->z))
 416     {
 417         PSendSysMessage(LANG_INVALID_TARGET_COORD,gy->x,gy->y,gy->map_id);
 418         SetSentErrorMessage(true);
 419         return false;
 420     }
 421
 422     // stop flight if need
 423     if(_player->isInFlight())
 424     {
 425         _player->GetMotionMaster()->MovementExpired();
 426         _player->m_taxi.ClearTaxiDestinations();
 427     }
 428     // save only in non-flight case
 429     else
 430         _player->SaveRecallPosition();
 431
 432     _player->TeleportTo(gy->map_id, gy->x, gy->y, gy->z, _player->GetOrientation());
 433     return true;
 434 }
 435
 436 /** \brief Teleport the GM to the specified creature
 437  *
 438  * .gocreature <GUID>      --> TP using creature.guid
 439  * .gocreature azuregos    --> TP player to the mob with this name
 440  *                             Warning: If there is more than one mob with this name
 441  *                                      you will be teleported to the first one that is found.
 442  * .gocreature id 6109     --> TP player to the mob, that has this creature_template.entry
 443  *                             Warning: If there is more than one mob with this "id"
 444  *                                      you will be teleported to the first one that is found.
 445  */
 446 //teleport to creature
 447 bool ChatHandler::HandleGoCreatureCommand(const char* args)
 448 {
 449     if(!*args)
 450         return false;
 451     Player* _player = m_session->GetPlayer();
 452
 453     // "id" or number or [name] Shift-click form |color|Hcreature_entry:creature_id|h[name]|h|r
 454     char* pParam1 = extractKeyFromLink((char*)args,"Hcreature");
 455     if (!pParam1)
 456         return false;
 457
 458     std::ostringstream whereClause;
 459
 460     // User wants to teleport to the NPC's template entry
 461     if( strcmp(pParam1, "id") == 0 )
 462     {
 463         //sLog.outError("DEBUG: ID found");
 464
 465         // Get the "creature_template.entry"
 466         // number or [name] Shift-click form |color|Hcreature_entry:creature_id|h[name]|h|r
 467         char* tail = strtok(NULL,"");
 468         if(!tail)
 469             return false;
 470         char* cId = extractKeyFromLink(tail,"Hcreature_entry");
 471         if(!cId)
 472             return false;
 473
 474         int32 tEntry = atoi(cId);
 475         //sLog.outError("DEBUG: ID value: %d", tEntry);
 476         if(!tEntry)
 477             return false;
 478
 479         whereClause << "WHERE id = '" << tEntry << "'";
 480     }
 481     else
 482     {
 483         //sLog.outError("DEBUG: ID *not found*");
 484
 485         int32 guid = atoi(pParam1);
 486
 487         // Number is invalid - maybe the user specified the mob's name
 488         if(!guid)
 489         {
 490             std::string name = pParam1;
 491             WorldDatabase.escape_string(name);
 492             whereClause << ", creature_template WHERE creature.id = creature_template.entry AND creature_template.name "_LIKE_" '" << name << "'";
 493         }
 494         else
 495         {
 496             whereClause <<  "WHERE guid = '" << guid << "'";
 497         }
 498     }
 499     //sLog.outError("DEBUG: %s", whereClause.c_str());
 500
 501     QueryResult *result = WorldDatabase.PQuery("SELECT position_x,position_y,position_z,orientation,map FROM creature %s", whereClause.str().c_str() );
 502     if (!result)
 503     {
 504         SendSysMessage(LANG_COMMAND_GOCREATNOTFOUND);
 505         SetSentErrorMessage(true);
 506         return false;
 507     }
 508     if( result->GetRowCount() > 1 )
 509     {
 510         SendSysMessage(LANG_COMMAND_GOCREATMULTIPLE);
 511     }
 512
 513     Field *fields = result->Fetch();
 514     float x = fields[0].GetFloat();
 515     float y = fields[1].GetFloat();
 516     float z = fields[2].GetFloat();
 517     float ort = fields[3].GetFloat();
 518     int mapid = fields[4].GetUInt16();
 519
 520     delete result;
 521
 522     if(!MapManager::IsValidMapCoord(mapid,x,y,z,ort))
 523     {
 524         PSendSysMessage(LANG_INVALID_TARGET_COORD,x,y,mapid);
 525         SetSentErrorMessage(true);
 526         return false;
 527     }
 528
 529     // stop flight if need
 530     if(_player->isInFlight())
 531     {
 532         _player->GetMotionMaster()->MovementExpired();
 533         _player->m_taxi.ClearTaxiDestinations();
 534     }
 535     // save only in non-flight case
 536     else
 537         _player->SaveRecallPosition();
 538
 539     _player->TeleportTo(mapid, x, y, z, ort);
 540     return true;
 541 }
 542
 543 bool ChatHandler::HandleGUIDCommand(const char* /*args*/)
 544 {
 545     uint64 guid = m_session->GetPlayer()->GetSelection();
 546
 547     if (guid == 0)
 548     {
 549         SendSysMessage(LANG_NO_SELECTION);
 550         SetSentErrorMessage(true);
 551         return false;
 552     }
 553
 554     PSendSysMessage(LANG_OBJECT_GUID, GUID_LOPART(guid), GUID_HIPART(guid));
 555     return true;
 556 }
 557
 558 bool ChatHandler::HandleLookupFactionCommand(const char* args)
 559 {
 560     if (!*args)
 561         return false;
 562
 563     // Can be NULL at console call
 564     Player *target = getSelectedPlayer ();
 565
 566     std::string namepart = args;
 567     std::wstring wnamepart;
 568
 569     if (!Utf8toWStr (namepart,wnamepart))
 570         return false;
 571
 572     // converting string that we try to find to lower case
 573     wstrToLower (wnamepart);
 574
 575     uint32 counter = 0;                                     // Counter for figure out that we found smth.
 576
 577     for (uint32 id = 0; id < sFactionStore.GetNumRows(); ++id)
 578     {
 579         FactionEntry const *factionEntry = sFactionStore.LookupEntry (id);
 580         if (factionEntry)
 581         {
 582             FactionState const* repState = NULL;
 583             if(target)
 584             {
 585                 FactionStateList::const_iterator repItr = target->m_factions.find (factionEntry->reputationListID);
 586                 if(repItr != target->m_factions.end())
 587                     repState = &repItr->second;
 588             }
 589
 590
 591             int loc = m_session ? m_session->GetSessionDbcLocale() : sWorld.GetDefaultDbcLocale();
 592             std::string name = factionEntry->name[loc];
 593             if(name.empty())
 594                 continue;
 595
 596             if (!Utf8FitTo(name, wnamepart))
 597             {
 598                 loc = 0;
 599                 for(; loc < MAX_LOCALE; ++loc)
 600                 {
 601                     if(m_session && loc==m_session->GetSessionDbcLocale())
 602                         continue;
 603
 604                     name = factionEntry->name[loc];
 605                     if(name.empty())
 606                         continue;
 607
 608                     if (Utf8FitTo(name, wnamepart))
 609                         break;
 610                 }
 611             }
 612
 613             if(loc < MAX_LOCALE)
 614             {
 615                 // send faction in "id - [faction] rank reputation [visible] [at war] [own team] [unknown] [invisible] [inactive]" format
 616                 // or              "id - [faction] [no reputation]" format
 617                 std::ostringstream ss;
 618                 if (m_session)
 619                     ss << id << " - |cffffffff|Hfaction:" << id << "|h[" << name << " " << localeNames[loc] << "]|h|r";
 620                 else
 621                     ss << id << " - " << name << " " << localeNames[loc];
 622
 623                 if (repState)                               // and then target!=NULL also
 624                 {
 625                     ReputationRank rank = target->GetReputationRank(factionEntry);
 626                     std::string rankName = GetMangosString(ReputationRankStrIndex[rank]);
 627
 628                     ss << " " << rankName << "|h|r (" << target->GetReputation(factionEntry) << ")";
 629
 630                     if(repState->Flags & FACTION_FLAG_VISIBLE)
 631                         ss << GetMangosString(LANG_FACTION_VISIBLE);
 632                     if(repState->Flags & FACTION_FLAG_AT_WAR)
 633                         ss << GetMangosString(LANG_FACTION_ATWAR);
 634                     if(repState->Flags & FACTION_FLAG_PEACE_FORCED)
 635                         ss << GetMangosString(LANG_FACTION_PEACE_FORCED);
 636                     if(repState->Flags & FACTION_FLAG_HIDDEN)
 637                         ss << GetMangosString(LANG_FACTION_HIDDEN);
 638                     if(repState->Flags & FACTION_FLAG_INVISIBLE_FORCED)
 639                         ss << GetMangosString(LANG_FACTION_INVISIBLE_FORCED);
 640                     if(repState->Flags & FACTION_FLAG_INACTIVE)
 641                         ss << GetMangosString(LANG_FACTION_INACTIVE);
 642                 }
 643                 else
 644                     ss << GetMangosString(LANG_FACTION_NOREPUTATION);
 645
 646                 SendSysMessage(ss.str().c_str());
 647                 counter++;
 648             }
 649         }
 650     }
 651
 652     if (counter == 0)                                       // if counter == 0 then we found nth
 653         SendSysMessage(LANG_COMMAND_FACTION_NOTFOUND);
 654     return true;
 655 }
 656
 657 bool ChatHandler::HandleModifyRepCommand(const char * args)
 658 {
 659     if (!*args) return false;
 660
 661     Player* target = NULL;
 662     target = getSelectedPlayer();
 663
 664     if(!target)
 665     {
 666         SendSysMessage(LANG_PLAYER_NOT_FOUND);
 667         SetSentErrorMessage(true);
 668         return false;
 669     }
 670
 671     char* factionTxt = extractKeyFromLink((char*)args,"Hfaction");
 672     if(!factionTxt)
 673         return false;
 674
 675     uint32 factionId = atoi(factionTxt);
 676
 677     int32 amount = 0;
 678     char *rankTxt = strtok(NULL, " ");
 679     if (!factionTxt || !rankTxt)
 680         return false;
 681
 682     amount = atoi(rankTxt);
 683     if ((amount == 0) && (rankTxt[0] != '-') && !isdigit(rankTxt[0]))
 684     {
 685         std::string rankStr = rankTxt;
 686         std::wstring wrankStr;
 687         if(!Utf8toWStr(rankStr,wrankStr))
 688             return false;
 689         wstrToLower( wrankStr );
 690
 691         int r = 0;
 692         amount = -42000;
 693         for (; r < MAX_REPUTATION_RANK; ++r)
 694         {
 695             std::string rank = GetMangosString(ReputationRankStrIndex[r]);
 696             if(rank.empty())
 697                 continue;
 698
 699             std::wstring wrank;
 700             if(!Utf8toWStr(rank,wrank))
 701                 continue;
 702
 703             wstrToLower(wrank);
 704
 705             if(wrank.substr(0,wrankStr.size())==wrankStr)
 706             {
 707                 char *deltaTxt = strtok(NULL, " ");
 708                 if (deltaTxt)
 709                 {
 710                     int32 delta = atoi(deltaTxt);
 711                     if ((delta < 0) || (delta > Player::ReputationRank_Length[r] -1))
 712                     {
 713                         PSendSysMessage(LANG_COMMAND_FACTION_DELTA, (Player::ReputationRank_Length[r]-1));
 714                         SetSentErrorMessage(true);
 715                         return false;
 716                     }
 717                     amount += delta;
 718                 }
 719                 break;
 720             }
 721             amount += Player::ReputationRank_Length[r];
 722         }
 723         if (r >= MAX_REPUTATION_RANK)
 724         {
 725             PSendSysMessage(LANG_COMMAND_FACTION_INVPARAM, rankTxt);
 726             SetSentErrorMessage(true);
 727             return false;
 728         }
 729     }
 730
 731     FactionEntry const *factionEntry = sFactionStore.LookupEntry(factionId);
 732
 733     if (!factionEntry)
 734     {
 735         PSendSysMessage(LANG_COMMAND_FACTION_UNKNOWN, factionId);
 736         SetSentErrorMessage(true);
 737         return false;
 738     }
 739
 740     if (factionEntry->reputationListID < 0)
 741     {
 742         PSendSysMessage(LANG_COMMAND_FACTION_NOREP_ERROR, factionEntry->name[m_session->GetSessionDbcLocale()], factionId);
 743         SetSentErrorMessage(true);
 744         return false;
 745     }
 746
 747     target->SetFactionReputation(factionEntry,amount);
 748     PSendSysMessage(LANG_COMMAND_MODIFY_REP, factionEntry->name[m_session->GetSessionDbcLocale()], factionId, target->GetName(), target->GetReputation(factionId));
 749     return true;
 750 }
 751
 752 bool ChatHandler::HandleNameCommand(const char* /*args*/)
 753 {
 754     /* Temp. disabled
 755         if(!*args)
 756             return false;
 757
 758         if(strlen((char*)args)>75)
 759         {
 760             PSendSysMessage(LANG_TOO_LONG_NAME, strlen((char*)args)-75);
 761             return true;
 762         }
 763
 764         for (uint8 i = 0; i < strlen(args); i++)
 765         {
 766             if(!isalpha(args[i]) && args[i]!=' ')
 767             {
 768                 SendSysMessage(LANG_CHARS_ONLY);
 769                 return false;
 770             }
 771         }
 772
 773         uint64 guid;
 774         guid = m_session->GetPlayer()->GetSelection();
 775         if (guid == 0)
 776         {
 777             SendSysMessage(LANG_NO_SELECTION);
 778             return true;
 779         }
 780
 781         Creature* pCreature = ObjectAccessor::GetCreature(*m_session->GetPlayer(), guid);
 782
 783         if(!pCreature)
 784         {
 785             SendSysMessage(LANG_SELECT_CREATURE);
 786             return true;
 787         }
 788
 789         pCreature->SetName(args);
 790         uint32 idname = objmgr.AddCreatureTemplate(pCreature->GetName());
 791         pCreature->SetUInt32Value(OBJECT_FIELD_ENTRY, idname);
 792
 793         pCreature->SaveToDB();
 794     */
 795
 796     return true;
 797 }
 798
 799 bool ChatHandler::HandleSubNameCommand(const char* /*args*/)
 800 {
 801     /* Temp. disabled
 802
 803     if(!*args)
 804         args = "";
 805
 806     if(strlen((char*)args)>75)
 807     {
 808
 809         PSendSysMessage(LANG_TOO_LONG_SUBNAME, strlen((char*)args)-75);
 810         return true;
 811     }
 812
 813     for (uint8 i = 0; i < strlen(args); i++)
 814     {
 815         if(!isalpha(args[i]) && args[i]!=' ')
 816         {
 817             SendSysMessage(LANG_CHARS_ONLY);
 818             return false;
 819         }
 820     }
 821     uint64 guid;
 822     guid = m_session->GetPlayer()->GetSelection();
 823     if (guid == 0)
 824     {
 825         SendSysMessage(LANG_NO_SELECTION);
 826         return true;
 827     }
 828
 829     Creature* pCreature = ObjectAccessor::GetCreature(*m_session->GetPlayer(), guid);
 830
 831     if(!pCreature)
 832     {
 833         SendSysMessage(LANG_SELECT_CREATURE);
 834         return true;
 835     }
 836
 837     uint32 idname = objmgr.AddCreatureSubName(pCreature->GetName(),args,pCreature->GetUInt32Value(UNIT_FIELD_DISPLAYID));
 838     pCreature->SetUInt32Value(OBJECT_FIELD_ENTRY, idname);
 839
 840     pCreature->SaveToDB();
 841     */
 842     return true;
 843 }
 844
 845 //move item to other slot
 846 bool ChatHandler::HandleItemMoveCommand(const char* args)
 847 {
 848     if(!*args)
 849         return false;
 850     uint8 srcslot, dstslot;
 851
 852     char* pParam1 = strtok((char*)args, " ");
 853     if (!pParam1)
 854         return false;
 855
 856     char* pParam2 = strtok(NULL, " ");
 857     if (!pParam2)
 858         return false;
 859
 860     srcslot = (uint8)atoi(pParam1);
 861     dstslot = (uint8)atoi(pParam2);
 862
 863     if(srcslot==dstslot)
 864         return true;
 865
 866     if(!m_session->GetPlayer()->IsValidPos(INVENTORY_SLOT_BAG_0,srcslot))
 867         return false;
 868
 869     if(!m_session->GetPlayer()->IsValidPos(INVENTORY_SLOT_BAG_0,dstslot))
 870         return false;
 871
 872     uint16 src = ((INVENTORY_SLOT_BAG_0 << 8) | srcslot);
 873     uint16 dst = ((INVENTORY_SLOT_BAG_0 << 8) | dstslot);
 874
 875     m_session->GetPlayer()->SwapItem( src, dst );
 876
 877     return true;
 878 }
 879
 880 //add spawn of creature
 881 bool ChatHandler::HandleNpcAddCommand(const char* args)
 882 {
 883     if(!*args)
 884         return false;
 885     char* charID = strtok((char*)args, " ");
 886     if (!charID)
 887         return false;
 888
 889     char* team = strtok(NULL, " ");
 890     int32 teamval = 0;
 891     if (team) { teamval = atoi(team); }
 892     if (teamval < 0) { teamval = 0; }
 893
 894     uint32 id  = atoi(charID);
 895
 896     Player *chr = m_session->GetPlayer();
 897     float x = chr->GetPositionX();
 898     float y = chr->GetPositionY();
 899     float z = chr->GetPositionZ();
 900     float o = chr->GetOrientation();
 901     Map *map = chr->GetMap();
 902
 903     Creature* pCreature = new Creature;
 904     if (!pCreature->Create(objmgr.GenerateLowGuid(HIGHGUID_UNIT), map, id, (uint32)teamval))
 905     {
 906         delete pCreature;
 907         return false;
 908     }
 909
 910     pCreature->Relocate(x,y,z,o);
 911
 912     if(!pCreature->IsPositionValid())
 913     {
 914         sLog.outError("ERROR: Creature (guidlow %d, entry %d) not created. Suggested coordinates isn't valid (X: %f Y: %f)",pCreature->GetGUIDLow(),pCreature->GetEntry(),pCreature->GetPositionX(),pCreature->GetPositionY());
 915         delete pCreature;
 916         return false;
 917     }
 918
 919     pCreature->SaveToDB(map->GetId(), (1 << map->GetSpawnMode()));
 920
 921     uint32 db_guid = pCreature->GetDBTableGUIDLow();
 922
 923     // To call _LoadGoods(); _LoadQuests(); CreateTrainerSpells();
 924     pCreature->LoadFromDB(db_guid, map);
 925
 926     map->Add(pCreature);
 927     objmgr.AddCreatureToGrid(db_guid, objmgr.GetCreatureData(db_guid));
 928     return true;
 929 }
 930
 931 bool ChatHandler::HandleNpcDeleteCommand(const char* args)
 932 {
 933     Creature* unit = NULL;
 934
 935     if(*args)
 936     {
 937         // number or [name] Shift-click form |color|Hcreature:creature_guid|h[name]|h|r
 938         char* cId = extractKeyFromLink((char*)args,"Hcreature");
 939         if(!cId)
 940             return false;
 941
 942         uint32 lowguid = atoi(cId);
 943         if(!lowguid)
 944             return false;
 945
 946         if (CreatureData const* cr_data = objmgr.GetCreatureData(lowguid))
 947             unit = ObjectAccessor::GetCreature(*m_session->GetPlayer(), MAKE_NEW_GUID(lowguid, cr_data->id, HIGHGUID_UNIT));
 948     }
 949     else
 950         unit = getSelectedCreature();
 951
 952     if(!unit || unit->isPet() || unit->isTotem())
 953     {
 954         SendSysMessage(LANG_SELECT_CREATURE);
 955         SetSentErrorMessage(true);
 956         return false;
 957     }
 958
 959     // Delete the creature
 960     unit->CombatStop();
 961     unit->DeleteFromDB();
 962     unit->CleanupsBeforeDelete();
 963     unit->AddObjectToRemoveList();
 964
 965     SendSysMessage(LANG_COMMAND_DELCREATMESSAGE);
 966
 967     return true;
 968 }
 969
 970 //delete object by selection or guid
 971 bool ChatHandler::HandleDelObjectCommand(const char* args)
 972 {
 973     // number or [name] Shift-click form |color|Hgameobject:go_guid|h[name]|h|r
 974     char* cId = extractKeyFromLink((char*)args,"Hgameobject");
 975     if(!cId)
 976         return false;
 977
 978     uint32 lowguid = atoi(cId);
 979     if(!lowguid)
 980         return false;
 981
 982     GameObject* obj = NULL;
 983
 984     // by DB guid
 985     if (GameObjectData const* go_data = objmgr.GetGOData(lowguid))
 986         obj = GetObjectGlobalyWithGuidOrNearWithDbGuid(lowguid,go_data->id);
 987
 988     if(!obj)
 989     {
 990         PSendSysMessage(LANG_COMMAND_OBJNOTFOUND, lowguid);
 991         SetSentErrorMessage(true);
 992         return false;
 993     }
 994
 995     uint64 owner_guid = obj->GetOwnerGUID();
 996     if(owner_guid)
 997     {
 998         Unit* owner = ObjectAccessor::GetUnit(*m_session->GetPlayer(),owner_guid);
 999         if(!owner && !IS_PLAYER_GUID(owner_guid))
1000         {
1001             PSendSysMessage(LANG_COMMAND_DELOBJREFERCREATURE, GUID_LOPART(owner_guid), obj->GetGUIDLow());
1002             SetSentErrorMessage(true);
1003             return false;
1004         }
1005
1006         owner->RemoveGameObject(obj,false);
1007     }
1008
1009     obj->SetRespawnTime(0);                                 // not save respawn time
1010     obj->Delete();
1011     obj->DeleteFromDB();
1012
1013     PSendSysMessage(LANG_COMMAND_DELOBJMESSAGE, obj->GetGUIDLow());
1014
1015     return true;
1016 }
1017
1018 //turn selected object
1019 bool ChatHandler::HandleTurnObjectCommand(const char* args)
1020 {
1021     // number or [name] Shift-click form |color|Hgameobject:go_id|h[name]|h|r
1022     char* cId = extractKeyFromLink((char*)args,"Hgameobject");
1023     if(!cId)
1024         return false;
1025
1026     uint32 lowguid = atoi(cId);
1027     if(!lowguid)
1028         return false;
1029
1030     GameObject* obj = NULL;
1031
1032     // by DB guid
1033     if (GameObjectData const* go_data = objmgr.GetGOData(lowguid))
1034         obj = GetObjectGlobalyWithGuidOrNearWithDbGuid(lowguid,go_data->id);
1035
1036     if(!obj)
1037     {
1038         PSendSysMessage(LANG_COMMAND_OBJNOTFOUND, lowguid);
1039         SetSentErrorMessage(true);
1040         return false;
1041     }
1042
1043     char* po = strtok(NULL, " ");
1044     float o;
1045
1046     if (po)
1047     {
1048         o = (float)atof(po);
1049     }
1050     else
1051     {
1052         Player *chr = m_session->GetPlayer();
1053         o = chr->GetOrientation();
1054     }
1055
1056     float rot2 = sin(o/2);
1057     float rot3 = cos(o/2);
1058
1059     Map* map = obj->GetMap();
1060     map->Remove(obj,false);
1061
1062     obj->Relocate(obj->GetPositionX(), obj->GetPositionY(), obj->GetPositionZ(), o);
1063
1064     obj->SetFloatValue(GAMEOBJECT_FACING, o);
1065     obj->SetFloatValue(GAMEOBJECT_ROTATION+2, rot2);
1066     obj->SetFloatValue(GAMEOBJECT_ROTATION+3, rot3);
1067
1068     map->Add(obj);
1069
1070     obj->SaveToDB();
1071     obj->Refresh();
1072
1073     PSendSysMessage(LANG_COMMAND_TURNOBJMESSAGE, obj->GetGUIDLow(), o);
1074
1075     return true;
1076 }
1077
1078 //move selected creature
1079 bool ChatHandler::HandleNpcMoveCommand(const char* args)
1080 {
1081     uint32 lowguid = 0;
1082
1083     Creature* pCreature = getSelectedCreature();
1084
1085     if(!pCreature)
1086     {
1087         // number or [name] Shift-click form |color|Hcreature:creature_guid|h[name]|h|r
1088         char* cId = extractKeyFromLink((char*)args,"Hcreature");
1089         if(!cId)
1090             return false;
1091
1092         uint32 lowguid = atoi(cId);
1093
1094         /* FIXME: impossibel without entry
1095         if(lowguid)
1096             pCreature = ObjectAccessor::GetCreature(*m_session->GetPlayer(),MAKE_GUID(lowguid,HIGHGUID_UNIT));
1097         */
1098
1099         // Attempting creature load from DB data
1100         if(!pCreature)
1101         {
1102             CreatureData const* data = objmgr.GetCreatureData(lowguid);
1103             if(!data)
1104             {
1105                 PSendSysMessage(LANG_COMMAND_CREATGUIDNOTFOUND, lowguid);
1106                 SetSentErrorMessage(true);
1107                 return false;
1108             }
1109
1110             uint32 map_id = data->mapid;
1111
1112             if(m_session->GetPlayer()->GetMapId()!=map_id)
1113             {
1114                 PSendSysMessage(LANG_COMMAND_CREATUREATSAMEMAP, lowguid);
1115                 SetSentErrorMessage(true);
1116                 return false;
1117             }
1118         }
1119         else
1120         {
1121             lowguid = pCreature->GetDBTableGUIDLow();
1122         }
1123     }
1124     else
1125     {
1126         lowguid = pCreature->GetDBTableGUIDLow();
1127     }
1128
1129     float x = m_session->GetPlayer()->GetPositionX();
1130     float y = m_session->GetPlayer()->GetPositionY();
1131     float z = m_session->GetPlayer()->GetPositionZ();
1132     float o = m_session->GetPlayer()->GetOrientation();
1133
1134     if (pCreature)
1135     {
1136         if(CreatureData const* data = objmgr.GetCreatureData(pCreature->GetDBTableGUIDLow()))
1137         {
1138             const_cast<CreatureData*>(data)->posX = x;
1139             const_cast<CreatureData*>(data)->posY = y;
1140             const_cast<CreatureData*>(data)->posZ = z;
1141             const_cast<CreatureData*>(data)->orientation = o;
1142         }
1143         pCreature->GetMap()->CreatureRelocation(pCreature,x, y, z,o);
1144         pCreature->GetMotionMaster()->Initialize();
1145         if(pCreature->isAlive())                            // dead creature will reset movement generator at respawn
1146         {
1147             pCreature->setDeathState(JUST_DIED);
1148             pCreature->Respawn();
1149         }
1150     }
1151
1152     WorldDatabase.PExecuteLog("UPDATE creature SET position_x = '%f', position_y = '%f', position_z = '%f', orientation = '%f' WHERE guid = '%u'", x, y, z, o, lowguid);
1153     PSendSysMessage(LANG_COMMAND_CREATUREMOVED);
1154     return true;
1155 }
1156
1157 //move selected object
1158 bool ChatHandler::HandleMoveObjectCommand(const char* args)
1159 {
1160     // number or [name] Shift-click form |color|Hgameobject:go_guid|h[name]|h|r
1161     char* cId = extractKeyFromLink((char*)args,"Hgameobject");
1162     if(!cId)
1163         return false;
1164
1165     uint32 lowguid = atoi(cId);
1166     if(!lowguid)
1167         return false;
1168
1169     GameObject* obj = NULL;
1170
1171     // by DB guid
1172     if (GameObjectData const* go_data = objmgr.GetGOData(lowguid))
1173         obj = GetObjectGlobalyWithGuidOrNearWithDbGuid(lowguid,go_data->id);
1174
1175     if(!obj)
1176     {
1177         PSendSysMessage(LANG_COMMAND_OBJNOTFOUND, lowguid);
1178         SetSentErrorMessage(true);
1179         return false;
1180     }
1181
1182     char* px = strtok(NULL, " ");
1183     char* py = strtok(NULL, " ");
1184     char* pz = strtok(NULL, " ");
1185
1186     if (!px)
1187     {
1188         Player *chr = m_session->GetPlayer();
1189
1190         Map* map = obj->GetMap();
1191         map->Remove(obj,false);
1192
1193         obj->Relocate(chr->GetPositionX(), chr->GetPositionY(), chr->GetPositionZ(), obj->GetOrientation());
1194         obj->SetFloatValue(GAMEOBJECT_POS_X, chr->GetPositionX());
1195         obj->SetFloatValue(GAMEOBJECT_POS_Y, chr->GetPositionY());
1196         obj->SetFloatValue(GAMEOBJECT_POS_Z, chr->GetPositionZ());
1197
1198         map->Add(obj);
1199     }
1200     else
1201     {
1202         if(!py || !pz)
1203             return false;
1204
1205         float x = (float)atof(px);
1206         float y = (float)atof(py);
1207         float z = (float)atof(pz);
1208
1209         if(!MapManager::IsValidMapCoord(obj->GetMapId(),x,y,z))
1210         {
1211             PSendSysMessage(LANG_INVALID_TARGET_COORD,x,y,obj->GetMapId());
1212             SetSentErrorMessage(true);
1213             return false;
1214         }
1215
1216         Map* map = obj->GetMap();
1217         map->Remove(obj,false);
1218
1219         obj->Relocate(x, y, z, obj->GetOrientation());
1220         obj->SetFloatValue(GAMEOBJECT_POS_X, x);
1221         obj->SetFloatValue(GAMEOBJECT_POS_Y, y);
1222         obj->SetFloatValue(GAMEOBJECT_POS_Z, z);
1223
1224         map->Add(obj);
1225     }
1226
1227     obj->SaveToDB();
1228     obj->Refresh();
1229
1230     PSendSysMessage(LANG_COMMAND_MOVEOBJMESSAGE, obj->GetGUIDLow());
1231
1232     return true;
1233 }
1234
1235 //demorph player or unit
1236 bool ChatHandler::HandleDeMorphCommand(const char* /*args*/)
1237 {
1238     Unit *target = getSelectedUnit();
1239     if(!target)
1240         target = m_session->GetPlayer();
1241
1242     target->DeMorph();
1243
1244     return true;
1245 }
1246
1247 //add item in vendorlist
1248 bool ChatHandler::HandleAddVendorItemCommand(const char* args)
1249 {
1250     if (!*args)
1251         return false;
1252
1253     char* pitem  = extractKeyFromLink((char*)args,"Hitem");
1254     if (!pitem)
1255     {
1256         SendSysMessage(LANG_COMMAND_NEEDITEMSEND);
1257         SetSentErrorMessage(true);
1258         return false;
1259     }
1260
1261     uint32 itemId = atol(pitem);
1262
1263     char* fmaxcount = strtok(NULL, " ");                    //add maxcount, default: 0
1264     uint32 maxcount = 0;
1265     if (fmaxcount)
1266         maxcount = atol(fmaxcount);
1267
1268     char* fincrtime = strtok(NULL, " ");                    //add incrtime, default: 0
1269     uint32 incrtime = 0;
1270     if (fincrtime)
1271         incrtime = atol(fincrtime);
1272
1273     char* fextendedcost = strtok(NULL, " ");                //add ExtendedCost, default: 0
1274     uint32 extendedcost = fextendedcost ? atol(fextendedcost) : 0;
1275
1276     Creature* vendor = getSelectedCreature();
1277
1278     uint32 vendor_entry = vendor ? vendor->GetEntry() : 0;
1279
1280     if(!objmgr.IsVendorItemValid(vendor_entry,itemId,maxcount,incrtime,extendedcost,m_session->GetPlayer()))
1281     {
1282         SetSentErrorMessage(true);
1283         return false;
1284     }
1285
1286     objmgr.AddVendorItem(vendor_entry,itemId,maxcount,incrtime,extendedcost);
1287
1288     ItemPrototype const* pProto = objmgr.GetItemPrototype(itemId);
1289
1290     PSendSysMessage(LANG_ITEM_ADDED_TO_LIST,itemId,pProto->Name1,maxcount,incrtime,extendedcost);
1291     return true;
1292 }
1293
1294 //del item from vendor list
1295 bool ChatHandler::HandleDelVendorItemCommand(const char* args)
1296 {
1297     if (!*args)
1298         return false;
1299
1300     Creature* vendor = getSelectedCreature();
1301     if (!vendor || !vendor->isVendor())
1302     {
1303         SendSysMessage(LANG_COMMAND_VENDORSELECTION);
1304         SetSentErrorMessage(true);
1305         return false;
1306     }
1307
1308     char* pitem  = extractKeyFromLink((char*)args,"Hitem");
1309     if (!pitem)
1310     {
1311         SendSysMessage(LANG_COMMAND_NEEDITEMSEND);
1312         SetSentErrorMessage(true);
1313         return false;
1314     }
1315     uint32 itemId = atol(pitem);
1316
1317     if(!objmgr.RemoveVendorItem(vendor->GetEntry(),itemId))
1318     {
1319         PSendSysMessage(LANG_ITEM_NOT_IN_LIST,itemId);
1320         SetSentErrorMessage(true);
1321         return false;
1322     }
1323
1324     ItemPrototype const* pProto = objmgr.GetItemPrototype(itemId);
1325
1326     PSendSysMessage(LANG_ITEM_DELETED_FROM_LIST,itemId,pProto->Name1);
1327     return true;
1328 }
1329
1330 //add move for creature
1331 bool ChatHandler::HandleNpcAddMoveCommand(const char* args)
1332 {
1333     if(!*args)
1334         return false;
1335
1336     char* guid_str = strtok((char*)args, " ");
1337     char* wait_str = strtok((char*)NULL, " ");
1338
1339     uint32 lowguid = atoi((char*)guid_str);
1340
1341     Creature* pCreature = NULL;
1342
1343     /* FIXME: impossible without entry
1344     if(lowguid)
1345         pCreature = ObjectAccessor::GetCreature(*m_session->GetPlayer(),MAKE_GUID(lowguid,HIGHGUID_UNIT));
1346     */
1347
1348     // attempt check creature existence by DB data
1349     if(!pCreature)
1350     {
1351         CreatureData const* data = objmgr.GetCreatureData(lowguid);
1352         if(!data)
1353         {
1354             PSendSysMessage(LANG_COMMAND_CREATGUIDNOTFOUND, lowguid);
1355             SetSentErrorMessage(true);
1356             return false;
1357         }
1358     }
1359     else
1360     {
1361         // obtain real GUID for DB operations
1362         lowguid = pCreature->GetDBTableGUIDLow();
1363     }
1364
1365     int wait = wait_str ? atoi(wait_str) : 0;
1366
1367     if(wait < 0)
1368         wait = 0;
1369
1370     Player* player = m_session->GetPlayer();
1371
1372     WaypointMgr.AddLastNode(lowguid, player->GetPositionX(), player->GetPositionY(), player->GetPositionZ(), player->GetOrientation(), wait, 0);
1373
1374     // update movement type
1375     WorldDatabase.PExecuteLog("UPDATE creature SET MovementType = '%u' WHERE guid = '%u'", WAYPOINT_MOTION_TYPE,lowguid);
1376     if(pCreature)
1377     {
1378         pCreature->SetDefaultMovementType(WAYPOINT_MOTION_TYPE);
1379         pCreature->GetMotionMaster()->Initialize();
1380         if(pCreature->isAlive())                            // dead creature will reset movement generator at respawn
1381         {
1382             pCreature->setDeathState(JUST_DIED);
1383             pCreature->Respawn();
1384         }
1385         pCreature->SaveToDB();
1386     }
1387
1388     SendSysMessage(LANG_WAYPOINT_ADDED);
1389
1390     return true;
1391 }
1392
1393 /**
1394  * Set the movement type for an NPC.<br/>
1395  * <br/>
1396  * Valid movement types are:
1397  * <ul>
1398  * <li> stay - NPC wont move </li>
1399  * <li> random - NPC will move randomly according to the spawndist </li>
1400  * <li> way - NPC will move with given waypoints set </li>
1401  * </ul>
1402  * additional parameter: NODEL - so no waypoints are deleted, if you
1403  *                       change the movement type
1404  */
1405 bool ChatHandler::HandleNpcSetMoveTypeCommand(const char* args)
1406 {
1407     if(!*args)
1408         return false;
1409
1410     // 3 arguments:
1411     // GUID (optional - you can also select the creature)
1412     // stay|random|way (determines the kind of movement)
1413     // NODEL (optional - tells the system NOT to delete any waypoints)
1414     //        this is very handy if you want to do waypoints, that are
1415     //        later switched on/off according to special events (like escort
1416     //        quests, etc)
1417     char* guid_str = strtok((char*)args, " ");
1418     char* type_str = strtok((char*)NULL, " ");
1419     char* dontdel_str = strtok((char*)NULL, " ");
1420
1421     bool doNotDelete = false;
1422
1423     if(!guid_str)
1424         return false;
1425
1426     uint32 lowguid = 0;
1427     Creature* pCreature = NULL;
1428
1429     if( dontdel_str )
1430     {
1431         //sLog.outError("DEBUG: All 3 params are set");
1432
1433         // All 3 params are set
1434         // GUID
1435         // type
1436         // doNotDEL
1437         if( stricmp( dontdel_str, "NODEL" ) == 0 )
1438         {
1439             //sLog.outError("DEBUG: doNotDelete = true;");
1440             doNotDelete = true;
1441         }
1442     }
1443     else
1444     {
1445         // Only 2 params - but maybe NODEL is set
1446         if( type_str )
1447         {
1448             sLog.outError("DEBUG: Only 2 params ");
1449             if( stricmp( type_str, "NODEL" ) == 0 )
1450             {
1451                 //sLog.outError("DEBUG: type_str, NODEL ");
1452                 doNotDelete = true;
1453                 type_str = NULL;
1454             }
1455         }
1456     }
1457
1458     if(!type_str)                                           // case .setmovetype $move_type (with selected creature)
1459     {
1460         type_str = guid_str;
1461         pCreature = getSelectedCreature();
1462         if(!pCreature || pCreature->isPet())
1463             return false;
1464         lowguid = pCreature->GetDBTableGUIDLow();
1465     }
1466     else                                                    // case .setmovetype #creature_guid $move_type (with selected creature)
1467     {
1468         lowguid = atoi((char*)guid_str);
1469
1470         /* impossible without entry
1471         if(lowguid)
1472             pCreature = ObjectAccessor::GetCreature(*m_session->GetPlayer(),MAKE_GUID(lowguid,HIGHGUID_UNIT));
1473         */
1474
1475         // attempt check creature existence by DB data
1476         if(!pCreature)
1477         {
1478             CreatureData const* data = objmgr.GetCreatureData(lowguid);
1479             if(!data)
1480             {
1481                 PSendSysMessage(LANG_COMMAND_CREATGUIDNOTFOUND, lowguid);
1482                 SetSentErrorMessage(true);
1483                 return false;
1484             }
1485         }
1486         else
1487         {
1488             lowguid = pCreature->GetDBTableGUIDLow();
1489         }
1490     }
1491
1492     // now lowguid is low guid really existed creature
1493     // and pCreature point (maybe) to this creature or NULL
1494
1495     MovementGeneratorType move_type;
1496
1497     std::string type = type_str;
1498
1499     if(type == "stay")
1500         move_type = IDLE_MOTION_TYPE;
1501     else if(type == "random")
1502         move_type = RANDOM_MOTION_TYPE;
1503     else if(type == "way")
1504         move_type = WAYPOINT_MOTION_TYPE;
1505     else
1506         return false;
1507
1508     // update movement type
1509     if(doNotDelete == false)
1510         WaypointMgr.DeletePath(lowguid);
1511
1512     if(pCreature)
1513     {
1514         pCreature->SetDefaultMovementType(move_type);
1515         pCreature->GetMotionMaster()->Initialize();
1516         if(pCreature->isAlive())                            // dead creature will reset movement generator at respawn
1517         {
1518             pCreature->setDeathState(JUST_DIED);
1519             pCreature->Respawn();
1520         }
1521         pCreature->SaveToDB();
1522     }
1523     if( doNotDelete == false )
1524     {
1525         PSendSysMessage(LANG_MOVE_TYPE_SET,type_str);
1526     }
1527     else
1528     {
1529         PSendSysMessage(LANG_MOVE_TYPE_SET_NODEL,type_str);
1530     }
1531
1532     return true;
1533 }                                                           // HandleNpcSetMoveTypeCommand
1534
1535 //change level of creature or pet
1536 bool ChatHandler::HandleChangeLevelCommand(const char* args)
1537 {
1538     if (!*args)
1539         return false;
1540
1541     uint8 lvl = (uint8) atoi((char*)args);
1542     if ( lvl < 1 || lvl > sWorld.getConfig(CONFIG_MAX_PLAYER_LEVEL) + 3)
1543     {
1544         SendSysMessage(LANG_BAD_VALUE);
1545         SetSentErrorMessage(true);
1546         return false;
1547     }
1548
1549     Creature* pCreature = getSelectedCreature();
1550     if(!pCreature)
1551     {
1552         SendSysMessage(LANG_SELECT_CREATURE);
1553         SetSentErrorMessage(true);
1554         return false;
1555     }
1556
1557     if(pCreature->isPet())
1558     {
1559         ((Pet*)pCreature)->GivePetLevel(lvl);
1560     }
1561     else
1562     {
1563         pCreature->SetMaxHealth( 100 + 30*lvl);
1564         pCreature->SetHealth( 100 + 30*lvl);
1565         pCreature->SetLevel( lvl);
1566         pCreature->SaveToDB();
1567     }
1568
1569     return true;
1570 }
1571
1572 //set npcflag of creature
1573 bool ChatHandler::HandleNpcFlagCommand(const char* args)
1574 {
1575     if (!*args)
1576         return false;
1577
1578     uint32 npcFlags = (uint32) atoi((char*)args);
1579
1580     Creature* pCreature = getSelectedCreature();
1581
1582     if(!pCreature)
1583     {
1584         SendSysMessage(LANG_SELECT_CREATURE);
1585         SetSentErrorMessage(true);
1586         return false;
1587     }
1588
1589     pCreature->SetUInt32Value(UNIT_NPC_FLAGS, npcFlags);
1590
1591     WorldDatabase.PExecuteLog("UPDATE creature_template SET npcflag = '%u' WHERE entry = '%u'", npcFlags, pCreature->GetEntry());
1592
1593     SendSysMessage(LANG_VALUE_SAVED_REJOIN);
1594
1595     return true;
1596 }
1597
1598 //set model of creature
1599 bool ChatHandler::HandleNpcSetModelCommand(const char* args)
1600 {
1601     if (!*args)
1602         return false;
1603
1604     uint32 displayId = (uint32) atoi((char*)args);
1605
1606     Creature *pCreature = getSelectedCreature();
1607
1608     if(!pCreature || pCreature->isPet())
1609     {
1610         SendSysMessage(LANG_SELECT_CREATURE);
1611         SetSentErrorMessage(true);
1612         return false;
1613     }
1614
1615     pCreature->SetDisplayId(displayId);
1616     pCreature->SetNativeDisplayId(displayId);
1617
1618     pCreature->SaveToDB();
1619
1620     return true;
1621 }
1622
1623 //morph creature or player
1624 bool ChatHandler::HandleMorphCommand(const char* args)
1625 {
1626     if (!*args)
1627         return false;
1628
1629     uint16 display_id = (uint16)atoi((char*)args);
1630
1631     Unit *target = getSelectedUnit();
1632     if(!target)
1633         target = m_session->GetPlayer();
1634
1635     target->SetDisplayId(display_id);
1636
1637     return true;
1638 }
1639
1640 //set faction of creature
1641 bool ChatHandler::HandleNpcFactionIdCommand(const char* args)
1642 {
1643     if (!*args)
1644         return false;
1645
1646     uint32 factionId = (uint32) atoi((char*)args);
1647
1648     if (!sFactionTemplateStore.LookupEntry(factionId))
1649     {
1650         PSendSysMessage(LANG_WRONG_FACTION, factionId);
1651         SetSentErrorMessage(true);
1652         return false;
1653     }
1654
1655     Creature* pCreature = getSelectedCreature();
1656
1657     if(!pCreature)
1658     {
1659         SendSysMessage(LANG_SELECT_CREATURE);
1660         SetSentErrorMessage(true);
1661         return false;
1662     }
1663
1664     pCreature->setFaction(factionId);
1665
1666     // faction is set in creature_template - not inside creature
1667
1668     // update in memory
1669     if(CreatureInfo const *cinfo = pCreature->GetCreatureInfo())
1670     {
1671         const_cast<CreatureInfo*>(cinfo)->faction_A = factionId;
1672         const_cast<CreatureInfo*>(cinfo)->faction_H = factionId;
1673     }
1674
1675     // and DB
1676     WorldDatabase.PExecuteLog("UPDATE creature_template SET faction_A = '%u', faction_H = '%u' WHERE entry = '%u'", factionId, factionId, pCreature->GetEntry());
1677
1678     return true;
1679 }
1680
1681 //kick player
1682 bool ChatHandler::HandleKickPlayerCommand(const char *args)
1683 {
1684     char* kickName = strtok((char*)args, " ");
1685     if (!kickName)
1686     {
1687         Player* player = getSelectedPlayer();
1688
1689         if(!player)
1690         {
1691             SendSysMessage(LANG_NO_CHAR_SELECTED);
1692             SetSentErrorMessage(true);
1693             return false;
1694         }
1695
1696         if(player==m_session->GetPlayer())
1697         {
1698             SendSysMessage(LANG_COMMAND_KICKSELF);
1699             SetSentErrorMessage(true);
1700             return false;
1701         }
1702
1703         player->GetSession()->KickPlayer();
1704     }
1705     else
1706     {
1707         std::string name = kickName;
1708         if(!normalizePlayerName(name))
1709         {
1710             SendSysMessage(LANG_PLAYER_NOT_FOUND);
1711             SetSentErrorMessage(true);
1712             return false;
1713         }
1714
1715         if(m_session && name==m_session->GetPlayer()->GetName())
1716         {
1717             SendSysMessage(LANG_COMMAND_KICKSELF);
1718             SetSentErrorMessage(true);
1719             return false;
1720         }
1721
1722         if(sWorld.KickPlayer(name))
1723         {
1724             PSendSysMessage(LANG_COMMAND_KICKMESSAGE,name.c_str());
1725         }
1726         else
1727             PSendSysMessage(LANG_COMMAND_KICKNOTFOUNDPLAYER,name.c_str());
1728     }
1729
1730     return true;
1731 }
1732
1733 //show info of player
1734 bool ChatHandler::HandlePInfoCommand(const char* args)
1735 {
1736     Player* target = NULL;
1737     uint64 targetGUID = 0;
1738
1739     char* px = strtok((char*)args, " ");
1740     char* py = NULL;
1741
1742     std::string name;
1743
1744     if (px)
1745     {
1746         name = px;
1747
1748         if(name.empty())
1749             return false;
1750
1751         if(!normalizePlayerName(name))
1752         {
1753             SendSysMessage(LANG_PLAYER_NOT_FOUND);
1754             SetSentErrorMessage(true);
1755             return false;
1756         }
1757
1758         target = objmgr.GetPlayer(name.c_str());
1759         if (target)
1760             py = strtok(NULL, " ");
1761         else
1762         {
1763             targetGUID = objmgr.GetPlayerGUIDByName(name);
1764             if(targetGUID)
1765                 py = strtok(NULL, " ");
1766             else
1767                 py = px;
1768         }
1769     }
1770
1771     if(!target && !targetGUID)
1772     {
1773         target = getSelectedPlayer();
1774     }
1775
1776     if(!target && !targetGUID)
1777     {
1778         SendSysMessage(LANG_PLAYER_NOT_FOUND);
1779         SetSentErrorMessage(true);
1780         return false;
1781     }
1782
1783     uint32 accId = 0;
1784     uint32 money = 0;
1785     uint32 total_player_time = 0;
1786     uint32 level = 0;
1787     uint32 latency = 0;
1788
1789     // get additional information from Player object
1790     if(target)
1791     {
1792         targetGUID = target->GetGUID();
1793         name = target->GetName();                           // re-read for case getSelectedPlayer() target
1794         accId = target->GetSession()->GetAccountId();
1795         money = target->GetMoney();
1796         total_player_time = target->GetTotalPlayedTime();
1797         level = target->getLevel();
1798         latency = target->GetSession()->GetLatency();
1799     }
1800     // get additional information from DB
1801     else
1802     {
1803         //                                                     0
1804         QueryResult *result = CharacterDatabase.PQuery("SELECT totaltime FROM characters WHERE guid = '%u'", GUID_LOPART(targetGUID));
1805         if (!result)
1806         {
1807             SendSysMessage(LANG_PLAYER_NOT_FOUND);
1808             SetSentErrorMessage(true);
1809             return false;
1810         }
1811         Field *fields = result->Fetch();
1812         total_player_time = fields[0].GetUInt32();
1813         delete result;
1814
1815         Tokens data;
1816         if (!Player::LoadValuesArrayFromDB(data,targetGUID))
1817         {
1818             SendSysMessage(LANG_PLAYER_NOT_FOUND);
1819             SetSentErrorMessage(true);
1820             return false;
1821         }
1822
1823         money = Player::GetUInt32ValueFromArray(data, PLAYER_FIELD_COINAGE);
1824         level = Player::GetUInt32ValueFromArray(data, UNIT_FIELD_LEVEL);
1825
1826         accId = objmgr.GetPlayerAccountIdByGUID(targetGUID);
1827     }
1828
1829     std::string username = GetMangosString(LANG_ERROR);
1830     std::string last_ip = GetMangosString(LANG_ERROR);
1831     uint32 security = 0;
1832     std::string last_login = GetMangosString(LANG_ERROR);
1833
1834     QueryResult* result = loginDatabase.PQuery("SELECT username,gmlevel,last_ip,last_login FROM account WHERE id = '%u'",accId);
1835     if(result)
1836     {
1837         Field* fields = result->Fetch();
1838         username = fields[0].GetCppString();
1839         security = fields[1].GetUInt32();
1840
1841         if(!m_session || m_session->GetSecurity() >= security)
1842         {
1843             last_ip = fields[2].GetCppString();
1844             last_login = fields[3].GetCppString();
1845         }
1846         else
1847         {
1848             last_ip = "-";
1849             last_login = "-";
1850         }
1851
1852         delete result;
1853     }
1854
1855     PSendSysMessage(LANG_PINFO_ACCOUNT, (target?"":GetMangosString(LANG_OFFLINE)), name.c_str(), GUID_LOPART(targetGUID), username.c_str(), accId, security, last_ip.c_str(), last_login.c_str(), latency);
1856
1857     std::string timeStr = secsToTimeString(total_player_time,true,true);
1858     uint32 gold = money /GOLD;
1859     uint32 silv = (money % GOLD) / SILVER;
1860     uint32 copp = (money % GOLD) % SILVER;
1861     PSendSysMessage(LANG_PINFO_LEVEL,  timeStr.c_str(), level, gold,silv,copp );
1862
1863     if ( py && strncmp(py, "rep", 3) == 0 )
1864     {
1865         if(!target)
1866         {
1867             // rep option not implemented for offline case
1868             SendSysMessage(LANG_PINFO_NO_REP);
1869             SetSentErrorMessage(true);
1870             return false;
1871         }
1872
1873         char* FactionName;
1874         for(FactionStateList::const_iterator itr = target->m_factions.begin(); itr != target->m_factions.end(); ++itr)
1875         {
1876             FactionEntry const *factionEntry = sFactionStore.LookupEntry(itr->second.ID);
1877             if (factionEntry)
1878                 FactionName = factionEntry->name[m_session->GetSessionDbcLocale()];
1879             else
1880                 FactionName = "#Not found#";
1881             ReputationRank rank = target->GetReputationRank(factionEntry);
1882             std::string rankName = GetMangosString(ReputationRankStrIndex[rank]);
1883             std::ostringstream ss;
1884             ss << itr->second.ID << ": |cffffffff|Hfaction:" << itr->second.ID << "|h[" << FactionName << "]|h|r " << rankName << "|h|r (" << target->GetReputation(factionEntry) << ")";
1885
1886             if(itr->second.Flags & FACTION_FLAG_VISIBLE)
1887                 ss << GetMangosString(LANG_FACTION_VISIBLE);
1888             if(itr->second.Flags & FACTION_FLAG_AT_WAR)
1889                 ss << GetMangosString(LANG_FACTION_ATWAR);
1890             if(itr->second.Flags & FACTION_FLAG_PEACE_FORCED)
1891                 ss << GetMangosString(LANG_FACTION_PEACE_FORCED);
1892             if(itr->second.Flags & FACTION_FLAG_HIDDEN)
1893                 ss << GetMangosString(LANG_FACTION_HIDDEN);
1894             if(itr->second.Flags & FACTION_FLAG_INVISIBLE_FORCED)
1895                 ss << GetMangosString(LANG_FACTION_INVISIBLE_FORCED);
1896             if(itr->second.Flags & FACTION_FLAG_INACTIVE)
1897                 ss << GetMangosString(LANG_FACTION_INACTIVE);
1898
1899             SendSysMessage(ss.str().c_str());
1900         }
1901     }
1902     return true;
1903 }
1904
1905 //show tickets
1906 void ChatHandler::ShowTicket(uint64 guid, char const* text, char const* time)
1907 {
1908     std::string name;
1909     if(!objmgr.GetPlayerNameByGUID(guid,name))
1910         name = GetMangosString(LANG_UNKNOWN);
1911
1912     PSendSysMessage(LANG_COMMAND_TICKETVIEW, name.c_str(),time,text);
1913 }
1914
1915 //ticket commands
1916 bool ChatHandler::HandleTicketCommand(const char* args)
1917 {
1918     char* px = strtok((char*)args, " ");
1919
1920     // ticket<end>
1921     if (!px)
1922     {
1923         if(!m_session)
1924         {
1925             SendSysMessage(LANG_PLAYER_NOT_FOUND);
1926             SetSentErrorMessage(true);
1927             return false;
1928         }
1929
1930         size_t count = ticketmgr.GetTicketCount();
1931
1932         bool accept = m_session->GetPlayer()->isAcceptTickets();
1933
1934         PSendSysMessage(LANG_COMMAND_TICKETCOUNT, count, accept ?  GetMangosString(LANG_ON) : GetMangosString(LANG_OFF));
1935         return true;
1936     }
1937
1938     // ticket on
1939     if(strncmp(px,"on",3) == 0)
1940     {
1941         if(!m_session)
1942         {
1943             SendSysMessage(LANG_PLAYER_NOT_FOUND);
1944             SetSentErrorMessage(true);
1945             return false;
1946         }
1947
1948         m_session->GetPlayer()->SetAcceptTicket(true);
1949         SendSysMessage(LANG_COMMAND_TICKETON);
1950         return true;
1951     }
1952
1953     // ticket off
1954     if(strncmp(px,"off",4) == 0)
1955     {
1956         if(!m_session)
1957         {
1958             SendSysMessage(LANG_PLAYER_NOT_FOUND);
1959             SetSentErrorMessage(true);
1960             return false;
1961         }
1962
1963         m_session->GetPlayer()->SetAcceptTicket(false);
1964         SendSysMessage(LANG_COMMAND_TICKETOFF);
1965         return true;
1966     }
1967
1968     // ticket #num
1969     int num = atoi(px);
1970     if(num > 0)
1971     {
1972         QueryResult *result = CharacterDatabase.PQuery("SELECT guid,ticket_text,ticket_lastchange FROM character_ticket ORDER BY ticket_id ASC "_OFFSET_, num-1);
1973
1974         if(!result)
1975         {
1976             PSendSysMessage(LANG_COMMAND_TICKENOTEXIST, num);
1977             SetSentErrorMessage(true);
1978             return false;
1979         }
1980
1981         Field* fields = result->Fetch();
1982
1983         uint32 guid = fields[0].GetUInt32();
1984         char const* text = fields[1].GetString();
1985         char const* time = fields[2].GetString();
1986
1987         ShowTicket(MAKE_NEW_GUID(guid, 0, HIGHGUID_PLAYER),text,time);
1988         delete result;
1989         return true;
1990     }
1991
1992     std::string name = px;
1993
1994     if(!normalizePlayerName(name))
1995     {
1996         SendSysMessage(LANG_PLAYER_NOT_FOUND);
1997         SetSentErrorMessage(true);
1998         return false;
1999     }
2000
2001     uint64 guid = objmgr.GetPlayerGUIDByName(name);
2002
2003     if(!guid)
2004         return false;
2005
2006     // ticket $char_name
2007     GMTicket* ticket = ticketmgr.GetGMTicket(GUID_LOPART(guid));
2008     if(!ticket)
2009         return false;
2010
2011     std::string time = TimeToTimestampStr(ticket->GetLastUpdate());
2012
2013     ShowTicket(guid, ticket->GetText(), time.c_str());
2014
2015     return true;
2016 }
2017
2018 //dell all tickets
2019 bool ChatHandler::HandleDelTicketCommand(const char *args)
2020 {
2021     char* px = strtok((char*)args, " ");
2022     if (!px)
2023         return false;
2024
2025     // delticket all
2026     if(strncmp(px,"all",4) == 0)
2027     {
2028         ticketmgr.DeleteAll();
2029         SendSysMessage(LANG_COMMAND_ALLTICKETDELETED);
2030         return true;
2031     }
2032
2033     int num = (uint32)atoi(px);
2034
2035     // delticket #num
2036     if(num > 0)
2037     {
2038         QueryResult* result = CharacterDatabase.PQuery("SELECT guid FROM character_ticket ORDER BY ticket_id ASC "_OFFSET_,num-1);
2039         if(!result)
2040         {
2041             PSendSysMessage(LANG_COMMAND_TICKENOTEXIST, num);
2042             SetSentErrorMessage(true);
2043             return false;
2044         }
2045         Field* fields = result->Fetch();
2046         uint32 guid = fields[0].GetUInt32();
2047         delete result;
2048
2049         ticketmgr.Delete(guid);
2050
2051         //notify player
2052         if(Player* pl = objmgr.GetPlayer(MAKE_NEW_GUID(guid, 0, HIGHGUID_PLAYER)))
2053         {
2054             pl->GetSession()->SendGMTicketGetTicket(0x0A, 0);
2055             PSendSysMessage(LANG_COMMAND_TICKETPLAYERDEL, pl->GetName());
2056         }
2057         else
2058             PSendSysMessage(LANG_COMMAND_TICKETDEL);
2059
2060         return true;
2061     }
2062
2063     std::string name = px;
2064
2065     if(!normalizePlayerName(name))
2066     {
2067         SendSysMessage(LANG_PLAYER_NOT_FOUND);
2068         SetSentErrorMessage(true);
2069         return false;
2070     }
2071
2072     uint64 guid = objmgr.GetPlayerGUIDByName(name);
2073
2074     if(!guid)
2075         return false;
2076
2077     // delticket $char_name
2078     ticketmgr.Delete(GUID_LOPART(guid));
2079
2080     // notify players about ticket deleting
2081     if(Player* sender = objmgr.GetPlayer(guid))
2082         sender->GetSession()->SendGMTicketGetTicket(0x0A,0);
2083
2084     PSendSysMessage(LANG_COMMAND_TICKETPLAYERDEL,px);
2085     return true;
2086 }
2087
2088 //set spawn dist of creature
2089 bool ChatHandler::HandleNpcSpawnDistCommand(const char* args)
2090 {
2091     if(!*args)
2092         return false;
2093
2094     float option = atof((char*)args);
2095     if (option < 0.0f)
2096     {
2097         SendSysMessage(LANG_BAD_VALUE);
2098         return false;
2099     }
2100
2101     MovementGeneratorType mtype = IDLE_MOTION_TYPE;
2102     if (option >0.0f)
2103         mtype = RANDOM_MOTION_TYPE;
2104
2105     Creature *pCreature = getSelectedCreature();
2106     uint32 u_guidlow = 0;
2107
2108     if (pCreature)
2109         u_guidlow = pCreature->GetDBTableGUIDLow();
2110     else
2111         return false;
2112
2113     pCreature->SetRespawnRadius((float)option);
2114     pCreature->SetDefaultMovementType(mtype);
2115     pCreature->GetMotionMaster()->Initialize();
2116     if(pCreature->isAlive())                                // dead creature will reset movement generator at respawn
2117     {
2118         pCreature->setDeathState(JUST_DIED);
2119         pCreature->Respawn();
2120     }
2121
2122     WorldDatabase.PExecuteLog("UPDATE creature SET spawndist=%f, MovementType=%i WHERE guid=%u",option,mtype,u_guidlow);
2123     PSendSysMessage(LANG_COMMAND_SPAWNDIST,option);
2124     return true;
2125 }
2126
2127 bool ChatHandler::HandleNpcSpawnTimeCommand(const char* args)
2128 {
2129     if(!*args)
2130         return false;
2131
2132     char* stime = strtok((char*)args, " ");
2133
2134     if (!stime)
2135         return false;
2136
2137     int i_stime = atoi((char*)stime);
2138
2139     if (i_stime < 0)
2140     {
2141         SendSysMessage(LANG_BAD_VALUE);
2142         SetSentErrorMessage(true);
2143         return false;
2144     }
2145
2146     Creature *pCreature = getSelectedCreature();
2147     uint32 u_guidlow = 0;
2148
2149     if (pCreature)
2150         u_guidlow = pCreature->GetDBTableGUIDLow();
2151     else
2152         return false;
2153
2154     WorldDatabase.PExecuteLog("UPDATE creature SET spawntimesecs=%i WHERE guid=%u",i_stime,u_guidlow);
2155     pCreature->SetRespawnDelay((uint32)i_stime);
2156     PSendSysMessage(LANG_COMMAND_SPAWNTIME,i_stime);
2157
2158     return true;
2159 }
2160
2161 /**
2162  * Add a waypoint to a creature.
2163  *
2164  * The user can either select an npc or provide its GUID.
2165  *
2166  * The user can even select a visual waypoint - then the new waypoint
2167  * is placed *after* the selected one - this makes insertion of new
2168  * waypoints possible.
2169  *
2170  * eg:
2171  * .wp add 12345
2172  * -> adds a waypoint to the npc with the GUID 12345
2173  *
2174  * .wp add
2175  * -> adds a waypoint to the currently selected creature
2176  *
2177  *
2178  * @param args if the user did not provide a GUID, it is NULL
2179  *
2180  * @return true - command did succeed, false - something went wrong
2181  */
2182 bool ChatHandler::HandleWpAddCommand(const char* args)
2183 {
2184     sLog.outDebug("DEBUG: HandleWpAddCommand");
2185
2186     // optional
2187     char* guid_str = NULL;
2188
2189     if(*args)
2190     {
2191         guid_str = strtok((char*)args, " ");
2192     }
2193
2194     uint32 lowguid = 0;
2195     uint32 point = 0;
2196     Creature* target = getSelectedCreature();
2197     // Did player provide a GUID?
2198     if (!guid_str)
2199     {
2200         sLog.outDebug("DEBUG: HandleWpAddCommand - No GUID provided");
2201
2202         // No GUID provided
2203         // -> Player must have selected a creature
2204
2205         if(!target || target->isPet())
2206         {
2207             SendSysMessage(LANG_SELECT_CREATURE);
2208             SetSentErrorMessage(true);
2209             return false;
2210         }
2211         if (target->GetEntry() == VISUAL_WAYPOINT )
2212         {
2213             sLog.outDebug("DEBUG: HandleWpAddCommand - target->GetEntry() == VISUAL_WAYPOINT (1) ");
2214
2215             QueryResult *result =
2216                 WorldDatabase.PQuery( "SELECT id, point FROM creature_movement WHERE wpguid = %u",
2217                 target->GetGUIDLow() );
2218             if(!result)
2219             {
2220                 PSendSysMessage(LANG_WAYPOINT_NOTFOUNDSEARCH, target->GetGUIDLow());
2221                 // User selected a visual spawnpoint -> get the NPC
2222                 // Select NPC GUID
2223                 // Since we compare float values, we have to deal with
2224                 // some difficulties.
2225                 // Here we search for all waypoints that only differ in one from 1 thousand
2226                 // (0.001) - There is no other way to compare C++ floats with mySQL floats
2227                 // See also: http://dev.mysql.com/doc/refman/5.0/en/problems-with-float.html
2228                 const char* maxDIFF = "0.01";
2229                 result = WorldDatabase.PQuery( "SELECT id, point FROM creature_movement WHERE (abs(position_x - %f) <= %s ) and (abs(position_y - %f) <= %s ) and (abs(position_z - %f) <= %s )",
2230                     target->GetPositionX(), maxDIFF, target->GetPositionY(), maxDIFF, target->GetPositionZ(), maxDIFF);
2231                 if(!result)
2232                 {
2233                     PSendSysMessage(LANG_WAYPOINT_NOTFOUNDDBPROBLEM, target->GetGUIDLow());
2234                     SetSentErrorMessage(true);
2235                     return false;
2236                 }
2237             }
2238             do
2239             {
2240                 Field *fields = result->Fetch();
2241                 lowguid = fields[0].GetUInt32();
2242                 point   = fields[1].GetUInt32();
2243             }while( result->NextRow() );
2244             delete result;
2245
2246             CreatureData const* data = objmgr.GetCreatureData(lowguid);
2247             if(!data)
2248             {
2249                 PSendSysMessage(LANG_WAYPOINT_CREATNOTFOUND, lowguid);
2250                 SetSentErrorMessage(true);
2251                 return false;
2252             }
2253
2254             target = ObjectAccessor::GetCreature(*m_session->GetPlayer(),MAKE_NEW_GUID(lowguid,data->id,HIGHGUID_UNIT));
2255             if(!target)
2256             {
2257                 PSendSysMessage(LANG_WAYPOINT_NOTFOUNDDBPROBLEM, lowguid);
2258                 SetSentErrorMessage(true);
2259                 return false;
2260             }
2261         }
2262         else
2263         {
2264             lowguid = target->GetDBTableGUIDLow();
2265         }
2266     }
2267     else
2268     {
2269         sLog.outDebug("DEBUG: HandleWpAddCommand - GUID provided");
2270
2271         // GUID provided
2272         // Warn if player also selected a creature
2273         // -> Creature selection is ignored <-
2274         if(target)
2275         {
2276             SendSysMessage(LANG_WAYPOINT_CREATSELECTED);
2277         }
2278         lowguid = atoi((char*)guid_str);
2279
2280         CreatureData const* data = objmgr.GetCreatureData(lowguid);
2281         if(!data)
2282         {
2283             PSendSysMessage(LANG_WAYPOINT_CREATNOTFOUND, lowguid);
2284             SetSentErrorMessage(true);
2285             return false;
2286         }
2287
2288         target = ObjectAccessor::GetCreature(*m_session->GetPlayer(),MAKE_NEW_GUID(lowguid,data->id,HIGHGUID_UNIT));
2289         if(!target || target->isPet())
2290         {
2291             PSendSysMessage(LANG_WAYPOINT_CREATNOTFOUND, lowguid);
2292             SetSentErrorMessage(true);
2293             return false;
2294         }
2295     }
2296     // lowguid -> GUID of the NPC
2297     // point   -> number of the waypoint (if not 0)
2298     sLog.outDebug("DEBUG: HandleWpAddCommand - danach");
2299
2300     sLog.outDebug("DEBUG: HandleWpAddCommand - point == 0");
2301
2302     Player* player = m_session->GetPlayer();
2303     WaypointMgr.AddLastNode(lowguid, player->GetPositionX(), player->GetPositionY(), player->GetPositionZ(), player->GetOrientation(), 0, 0);
2304
2305     // update movement type
2306     if(target)
2307     {
2308         target->SetDefaultMovementType(WAYPOINT_MOTION_TYPE);
2309         target->GetMotionMaster()->Initialize();
2310         if(target->isAlive())                               // dead creature will reset movement generator at respawn
2311         {
2312             target->setDeathState(JUST_DIED);
2313             target->Respawn();
2314         }
2315         target->SaveToDB();
2316     }
2317     else
2318         WorldDatabase.PExecuteLog("UPDATE creature SET MovementType = '%u' WHERE guid = '%u'", WAYPOINT_MOTION_TYPE,lowguid);
2319
2320     PSendSysMessage(LANG_WAYPOINT_ADDED, point, lowguid);
2321
2322     return true;
2323 }                                                           // HandleWpAddCommand
2324
2325 /**
2326  * .wp modify emote | spell | text | del | move | add
2327  *
2328  * add -> add a WP after the selected visual waypoint
2329  *        User must select a visual waypoint and then issue ".wp modify add"
2330  *
2331  * emote <emoteID>
2332  *   User has selected a visual waypoint before.
2333  *   <emoteID> is added to this waypoint. Everytime the
2334  *   NPC comes to this waypoint, the emote is called.
2335  *
2336  * emote <GUID> <WPNUM> <emoteID>
2337  *   User has not selected visual waypoint before.
2338  *   For the waypoint <WPNUM> for the NPC with <GUID>
2339  *   an emote <emoteID> is added.
2340  *   Everytime the NPC comes to this waypoint, the emote is called.
2341  *
2342  *
2343  * info <GUID> <WPNUM> -> User did not select a visual waypoint and
2344  */
2345 bool ChatHandler::HandleWpModifyCommand(const char* args)
2346 {
2347     sLog.outDebug("DEBUG: HandleWpModifyCommand");
2348
2349     if(!*args)
2350         return false;
2351
2352     // first arg: add del text emote spell waittime move
2353     char* show_str = strtok((char*)args, " ");
2354     if (!show_str)
2355     {
2356         return false;
2357     }
2358
2359     std::string show = show_str;
2360     // Check
2361     // Remember: "show" must also be the name of a column!
2362     if( (show != "emote") && (show != "spell") && (show != "textid1") && (show != "textid2")
2363         && (show != "textid3") && (show != "textid4") && (show != "textid5")
2364         && (show != "waittime") && (show != "del") && (show != "move") && (show != "add")
2365         && (show != "model1") && (show != "model2") && (show != "orientation"))
2366     {
2367         return false;
2368     }
2369
2370     // Next arg is: <GUID> <WPNUM> <ARGUMENT>
2371
2372     // Did user provide a GUID
2373     // or did the user select a creature?
2374     // -> variable lowguid is filled with the GUID of the NPC
2375     uint32 lowguid = 0;
2376     uint32 point = 0;
2377     uint32 wpGuid = 0;
2378     Creature* target = getSelectedCreature();
2379
2380     if(target)
2381     {
2382         sLog.outDebug("DEBUG: HandleWpModifyCommand - User did select an NPC");
2383
2384         // Did the user select a visual spawnpoint?
2385         if (target->GetEntry() != VISUAL_WAYPOINT )
2386         {
2387             PSendSysMessage(LANG_WAYPOINT_VP_SELECT);
2388             SetSentErrorMessage(true);
2389             return false;
2390         }
2391
2392         wpGuid = target->GetGUIDLow();
2393
2394         // The visual waypoint
2395         QueryResult *result =
2396             WorldDatabase.PQuery( "SELECT id, point FROM creature_movement WHERE wpguid = %u LIMIT 1",
2397             target->GetGUIDLow() );
2398         if(!result)
2399         {
2400             PSendSysMessage(LANG_WAYPOINT_NOTFOUNDDBPROBLEM, wpGuid);
2401             SetSentErrorMessage(true);
2402             return false;
2403         }
2404         sLog.outDebug("DEBUG: HandleWpModifyCommand - After getting wpGuid");
2405
2406         Field *fields = result->Fetch();
2407         lowguid = fields[0].GetUInt32();
2408         point   = fields[1].GetUInt32();
2409
2410         // Cleanup memory
2411         sLog.outDebug("DEBUG: HandleWpModifyCommand - Cleanup memory");
2412         delete result;
2413     }
2414     else
2415     {
2416         // User did provide <GUID> <WPNUM>
2417
2418         char* guid_str = strtok((char*)NULL, " ");
2419         if( !guid_str )
2420         {
2421             SendSysMessage(LANG_WAYPOINT_NOGUID);
2422             return false;
2423         }
2424         lowguid = atoi((char*)guid_str);
2425
2426         CreatureData const* data = objmgr.GetCreatureData(lowguid);
2427         if(!data)
2428         {
2429             PSendSysMessage(LANG_WAYPOINT_CREATNOTFOUND, lowguid);
2430             SetSentErrorMessage(true);
2431             return false;
2432         }
2433
2434         PSendSysMessage("DEBUG: GUID provided: %d", lowguid);
2435
2436         char* point_str = strtok((char*)NULL, " ");
2437         if( !point_str )
2438         {
2439             SendSysMessage(LANG_WAYPOINT_NOWAYPOINTGIVEN);
2440             return false;
2441         }
2442         point    = atoi((char*)point_str);
2443
2444         PSendSysMessage("DEBUG: wpNumber provided: %d", point);
2445
2446         // Now we need the GUID of the visual waypoint
2447         // -> "del", "move", "add" command
2448
2449         QueryResult *result = WorldDatabase.PQuery( "SELECT wpguid FROM creature_movement WHERE id = '%u' AND point = '%u' LIMIT 1", lowguid, point);
2450         if (!result)
2451         {
2452             PSendSysMessage(LANG_WAYPOINT_NOTFOUNDSEARCH, lowguid, point);
2453             SetSentErrorMessage(true);
2454             return false;
2455         }
2456
2457         Field *fields = result->Fetch();
2458         wpGuid  = fields[0].GetUInt32();
2459
2460         // Free memory
2461         delete result;
2462     }
2463
2464     char* arg_str = NULL;
2465     // Check for argument
2466     if( (show.find("text") == std::string::npos ) && (show != "del") && (show != "move") && (show != "add"))
2467     {
2468         // Text is enclosed in "<>", all other arguments not
2469         if( show.find("text") != std::string::npos )
2470             arg_str = strtok((char*)NULL, "<>");
2471         else
2472             arg_str = strtok((char*)NULL, " ");
2473
2474         if( !arg_str)
2475         {
2476             PSendSysMessage(LANG_WAYPOINT_ARGUMENTREQ, show_str);
2477             return false;
2478         }
2479     }
2480
2481     sLog.outDebug("DEBUG: HandleWpModifyCommand - Parameters parsed - now execute the command");
2482
2483     // wpGuid  -> GUID of the waypoint creature
2484     // lowguid -> GUID of the NPC
2485     // point   -> waypoint number
2486
2487     // Special functions:
2488     // add - move - del -> no args commands
2489     // Add a waypoint after the selected visual
2490     if(show == "add" && target)
2491     {
2492         PSendSysMessage("DEBUG: wp modify add, GUID: %u", lowguid);
2493
2494         // Get the creature for which we read the waypoint
2495         CreatureData const* data = objmgr.GetCreatureData(lowguid);
2496         if(!data)
2497         {
2498             PSendSysMessage(LANG_WAYPOINT_CREATNOTFOUND, lowguid);
2499             SetSentErrorMessage(true);
2500             return false;
2501         }
2502
2503         Creature* npcCreature = ObjectAccessor::GetCreature(*m_session->GetPlayer(), MAKE_NEW_GUID(lowguid, data->id, HIGHGUID_UNIT));
2504
2505         if( !npcCreature )
2506         {
2507             PSendSysMessage(LANG_WAYPOINT_NPCNOTFOUND);
2508             SetSentErrorMessage(true);
2509             return false;
2510         }
2511
2512         sLog.outDebug("DEBUG: HandleWpModifyCommand - add -- npcCreature");
2513
2514         // What to do:
2515         // Add the visual spawnpoint (DB only)
2516         // Adjust the waypoints
2517         // Respawn the owner of the waypoints
2518         sLog.outDebug("DEBUG: HandleWpModifyCommand - add");
2519
2520         Player* chr = m_session->GetPlayer();
2521         Map *map = chr->GetMap();
2522
2523         if(npcCreature)
2524         {
2525             npcCreature->GetMotionMaster()->Initialize();
2526             if(npcCreature->isAlive())                      // dead creature will reset movement generator at respawn
2527             {
2528                 npcCreature->setDeathState(JUST_DIED);
2529                 npcCreature->Respawn();
2530             }
2531         }
2532
2533         // create the waypoint creature
2534         wpGuid = 0;
2535         Creature* wpCreature = new Creature;
2536         if (!wpCreature->Create(objmgr.GenerateLowGuid(HIGHGUID_UNIT), map,VISUAL_WAYPOINT,0))
2537         {
2538             PSendSysMessage(LANG_WAYPOINT_VP_NOTCREATED, VISUAL_WAYPOINT);
2539             delete wpCreature;
2540         }
2541         else
2542         {
2543             wpCreature->Relocate(chr->GetPositionX(), chr->GetPositionY(), chr->GetPositionZ(), chr->GetOrientation());
2544
2545             if(!wpCreature->IsPositionValid())
2546             {
2547                 sLog.outError("ERROR: Creature (guidlow %d, entry %d) not created. Suggested coordinates isn't valid (X: %f Y: %f)",wpCreature->GetGUIDLow(),wpCreature->GetEntry(),wpCreature->GetPositionX(),wpCreature->GetPositionY());
2548                 delete wpCreature;
2549             }
2550             else
2551             {
2552                 wpCreature->SaveToDB(map->GetId(), (1 << map->GetSpawnMode()));
2553                 // To call _LoadGoods(); _LoadQuests(); CreateTrainerSpells();
2554                 wpCreature->LoadFromDB(wpCreature->GetDBTableGUIDLow(), map);
2555                 map->Add(wpCreature);
2556                 wpGuid = wpCreature->GetGUIDLow();
2557             }
2558         }
2559
2560         WaypointMgr.AddAfterNode(lowguid, point, chr->GetPositionX(), chr->GetPositionY(), chr->GetPositionZ(), 0, 0, wpGuid);
2561
2562         if(!wpGuid)
2563             return false;
2564
2565         PSendSysMessage(LANG_WAYPOINT_ADDED_NO, point+1);
2566         return true;
2567     }                                                       // add
2568
2569     if(show == "del" && target)
2570     {
2571         PSendSysMessage("DEBUG: wp modify del, GUID: %u", lowguid);
2572
2573         // Get the creature for which we read the waypoint
2574         CreatureData const* data = objmgr.GetCreatureData(lowguid);
2575         if(!data)
2576         {
2577             PSendSysMessage(LANG_WAYPOINT_CREATNOTFOUND, lowguid);
2578             SetSentErrorMessage(true);
2579             return false;
2580         }
2581
2582         Creature* npcCreature = ObjectAccessor::GetCreature(*m_session->GetPlayer(), MAKE_NEW_GUID(lowguid, data->id, HIGHGUID_UNIT));
2583
2584         // wpCreature
2585         Creature* wpCreature = NULL;
2586         if( wpGuid != 0 )
2587         {
2588             wpCreature = ObjectAccessor::GetCreature(*m_session->GetPlayer(),MAKE_NEW_GUID(wpGuid, VISUAL_WAYPOINT, HIGHGUID_UNIT));
2589             wpCreature->DeleteFromDB();
2590             wpCreature->CleanupsBeforeDelete();
2591             wpCreature->AddObjectToRemoveList();
2592         }
2593
2594         // What to do:
2595         // Remove the visual spawnpoint
2596         // Adjust the waypoints
2597         // Respawn the owner of the waypoints
2598
2599         WaypointMgr.DeleteNode(lowguid, point);
2600
2601         if(npcCreature)
2602         {
2603             // Any waypoints left?
2604             QueryResult *result2 = WorldDatabase.PQuery( "SELECT point FROM creature_movement WHERE id = '%u'",lowguid);
2605             if(!result2)
2606             {
2607                 npcCreature->SetDefaultMovementType(RANDOM_MOTION_TYPE);
2608             }
2609             else
2610             {
2611                 npcCreature->SetDefaultMovementType(WAYPOINT_MOTION_TYPE);
2612                 delete result2;
2613             }
2614             npcCreature->GetMotionMaster()->Initialize();
2615             if(npcCreature->isAlive())                      // dead creature will reset movement generator at respawn
2616             {
2617                 npcCreature->setDeathState(JUST_DIED);
2618                 npcCreature->Respawn();
2619             }
2620             npcCreature->SaveToDB();
2621         }
2622
2623         PSendSysMessage(LANG_WAYPOINT_REMOVED);
2624         return true;
2625     }                                                       // del
2626
2627     if(show == "move" && target)
2628     {
2629         PSendSysMessage("DEBUG: wp move, GUID: %u", lowguid);
2630
2631         Player *chr = m_session->GetPlayer();
2632         Map *map = chr->GetMap();
2633         {
2634             // Get the creature for which we read the waypoint
2635             CreatureData const* data = objmgr.GetCreatureData(lowguid);
2636             if(!data)
2637             {
2638                 PSendSysMessage(LANG_WAYPOINT_CREATNOTFOUND, lowguid);
2639                 SetSentErrorMessage(true);
2640                 return false;
2641             }
2642
2643             Creature* npcCreature = ObjectAccessor::GetCreature(*m_session->GetPlayer(), MAKE_NEW_GUID(lowguid, data->id, HIGHGUID_UNIT));
2644
2645             // wpCreature
2646             Creature* wpCreature = NULL;
2647             // What to do:
2648             // Move the visual spawnpoint
2649             // Respawn the owner of the waypoints
2650             if( wpGuid != 0 )
2651             {
2652                 wpCreature = ObjectAccessor::GetCreature(*m_session->GetPlayer(),MAKE_NEW_GUID(wpGuid, VISUAL_WAYPOINT, HIGHGUID_UNIT));
2653                 wpCreature->DeleteFromDB();
2654                 wpCreature->CleanupsBeforeDelete();
2655                 wpCreature->AddObjectToRemoveList();
2656                 // re-create
2657                 Creature* wpCreature2 = new Creature;
2658                 if (!wpCreature2->Create(objmgr.GenerateLowGuid(HIGHGUID_UNIT), map, VISUAL_WAYPOINT, 0))
2659                 {
2660                     PSendSysMessage(LANG_WAYPOINT_VP_NOTCREATED, VISUAL_WAYPOINT);
2661                     delete wpCreature2;
2662                     return false;
2663                 }
2664
2665                 wpCreature2->Relocate(chr->GetPositionX(), chr->GetPositionY(), chr->GetPositionZ(), chr->GetOrientation());
2666
2667                 if(!wpCreature2->IsPositionValid())
2668                 {
2669                     sLog.outError("ERROR: Creature (guidlow %d, entry %d) not created. Suggested coordinates isn't valid (X: %f Y: %f)",wpCreature2->GetGUIDLow(),wpCreature2->GetEntry(),wpCreature2->GetPositionX(),wpCreature2->GetPositionY());
2670                     delete wpCreature2;
2671                     return false;
2672                 }
2673
2674                 wpCreature2->SaveToDB(map->GetId(), (1 << map->GetSpawnMode()));
2675                 // To call _LoadGoods(); _LoadQuests(); CreateTrainerSpells();
2676                 wpCreature2->LoadFromDB(wpCreature2->GetDBTableGUIDLow(), map);
2677                 map->Add(wpCreature2);
2678                 //npcCreature->GetMap()->Add(wpCreature2);
2679             }
2680
2681             WaypointMgr.SetNodePosition(lowguid, point, chr->GetPositionX(), chr->GetPositionY(), chr->GetPositionZ());
2682
2683             if(npcCreature)
2684             {
2685                 npcCreature->GetMotionMaster()->Initialize();
2686                 if(npcCreature->isAlive())                  // dead creature will reset movement generator at respawn
2687                 {
2688                     npcCreature->setDeathState(JUST_DIED);
2689                     npcCreature->Respawn();
2690                 }
2691             }
2692             PSendSysMessage(LANG_WAYPOINT_CHANGED);
2693         }
2694         return true;
2695     }                                                       // move
2696
2697     // Create creature - npc that has the waypoint
2698     CreatureData const* data = objmgr.GetCreatureData(lowguid);
2699     if(!data)
2700     {
2701         PSendSysMessage(LANG_WAYPOINT_CREATNOTFOUND, lowguid);
2702         SetSentErrorMessage(true);
2703         return false;
2704     }
2705
2706     // set in game textids not supported
2707     if( show == "textid1" || show == "textid2" || show == "textid3" ||
2708         show == "textid4" || show == "textid5" )
2709     {
2710         return false;
2711     }
2712
2713     WaypointMgr.SetNodeText(lowguid, point, show_str, arg_str);
2714
2715     Creature* npcCreature = ObjectAccessor::GetCreature(*m_session->GetPlayer(), MAKE_NEW_GUID(lowguid, data->id, HIGHGUID_UNIT));
2716     if(npcCreature)
2717     {
2718         npcCreature->SetDefaultMovementType(WAYPOINT_MOTION_TYPE);
2719         npcCreature->GetMotionMaster()->Initialize();
2720         if(npcCreature->isAlive())                          // dead creature will reset movement generator at respawn
2721         {
2722             npcCreature->setDeathState(JUST_DIED);
2723             npcCreature->Respawn();
2724         }
2725     }
2726     PSendSysMessage(LANG_WAYPOINT_CHANGED_NO, show_str);
2727
2728     return true;
2729 }
2730
2731 /**
2732  * .wp show info | on | off
2733  *
2734  * info -> User has selected a visual waypoint before
2735  *
2736  * info <GUID> <WPNUM> -> User did not select a visual waypoint and
2737  *                        provided the GUID of the NPC and the number of
2738  *                        the waypoint.
2739  *
2740  * on -> User has selected an NPC; all visual waypoints for this
2741  *       NPC are added to the world
2742  *
2743  * on <GUID> -> User did not select an NPC - instead the GUID of the
2744  *              NPC is provided. All visual waypoints for this NPC
2745  *              are added from the world.
2746  *
2747  * off -> User has selected an NPC; all visual waypoints for this
2748  *        NPC are removed from the world.
2749  *
2750  * on <GUID> -> User did not select an NPC - instead the GUID of the
2751  *              NPC is provided. All visual waypoints for this NPC
2752  *              are removed from the world.
2753  *
2754  *
2755  */
2756 bool ChatHandler::HandleWpShowCommand(const char* args)
2757 {
2758     sLog.outDebug("DEBUG: HandleWpShowCommand");
2759
2760     if(!*args)
2761         return false;
2762
2763     // first arg: on, off, first, last
2764     char* show_str = strtok((char*)args, " ");
2765     if (!show_str)
2766     {
2767         return false;
2768     }
2769     // second arg: GUID (optional, if a creature is selected)
2770     char* guid_str = strtok((char*)NULL, " ");
2771     sLog.outDebug("DEBUG: HandleWpShowCommand: show_str: %s guid_str: %s", show_str, guid_str);
2772     //if (!guid_str) {
2773     //    return false;
2774     //}
2775
2776     // Did user provide a GUID
2777     // or did the user select a creature?
2778     // -> variable lowguid is filled with the GUID
2779     Creature* target = getSelectedCreature();
2780     // Did player provide a GUID?
2781     if (!guid_str)
2782     {
2783         sLog.outDebug("DEBUG: HandleWpShowCommand: !guid_str");
2784         // No GUID provided
2785         // -> Player must have selected a creature
2786
2787         if(!target)
2788         {
2789             SendSysMessage(LANG_SELECT_CREATURE);
2790             SetSentErrorMessage(true);
2791             return false;
2792         }
2793     }
2794     else
2795     {
2796         sLog.outDebug("DEBUG: HandleWpShowCommand: GUID provided");
2797         // GUID provided
2798         // Warn if player also selected a creature
2799         // -> Creature selection is ignored <-
2800         if(target)
2801         {
2802             SendSysMessage(LANG_WAYPOINT_CREATSELECTED);
2803         }
2804
2805         uint32 lowguid = atoi((char*)guid_str);
2806
2807         CreatureData const* data = objmgr.GetCreatureData(lowguid);
2808         if(!data)
2809         {
2810             PSendSysMessage(LANG_WAYPOINT_CREATNOTFOUND, lowguid);
2811             SetSentErrorMessage(true);
2812             return false;
2813         }
2814
2815         target = ObjectAccessor::GetCreature(*m_session->GetPlayer(),MAKE_NEW_GUID(lowguid,data->id,HIGHGUID_UNIT));
2816
2817         if(!target)
2818         {
2819             PSendSysMessage(LANG_WAYPOINT_CREATNOTFOUND, lowguid);
2820             SetSentErrorMessage(true);
2821             return false;
2822         }
2823     }
2824
2825     uint32 lowguid = target->GetDBTableGUIDLow();
2826
2827     std::string show = show_str;
2828     uint32 Maxpoint;
2829
2830     sLog.outDebug("DEBUG: HandleWpShowCommand: lowguid: %u show: %s", lowguid, show_str);
2831
2832     // Show info for the selected waypoint
2833     if(show == "info")
2834     {
2835         PSendSysMessage("DEBUG: wp info, GUID: %u", lowguid);
2836
2837         // Check if the user did specify a visual waypoint
2838         if( target->GetEntry() != VISUAL_WAYPOINT )
2839         {
2840             PSendSysMessage(LANG_WAYPOINT_VP_SELECT);
2841             SetSentErrorMessage(true);
2842             return false;
2843         }
2844
2845         //PSendSysMessage("wp on, GUID: %u", lowguid);
2846
2847         //pCreature->GetPositionX();
2848
2849         QueryResult *result =
2850             WorldDatabase.PQuery( "SELECT id, point, waittime, emote, spell, textid1, textid2, textid3, textid4, textid5, model1, model2 FROM creature_movement WHERE wpguid = %u",
2851             target->GetGUIDLow() );
2852         if(!result)
2853         {
2854             // Since we compare float values, we have to deal with
2855             // some difficulties.
2856             // Here we search for all waypoints that only differ in one from 1 thousand
2857             // (0.001) - There is no other way to compare C++ floats with mySQL floats
2858             // See also: http://dev.mysql.com/doc/refman/5.0/en/problems-with-float.html
2859             const char* maxDIFF = "0.01";
2860             PSendSysMessage(LANG_WAYPOINT_NOTFOUNDSEARCH, target->GetGUID());
2861
2862             result = WorldDatabase.PQuery( "SELECT id, point, waittime, emote, spell, textid1, textid2, textid3, textid4, textid5, model1, model2 FROM creature_movement WHERE (abs(position_x - %f) <= %s ) and (abs(position_y - %f) <= %s ) and (abs(position_z - %f) <= %s )",
2863                 target->GetPositionX(), maxDIFF, target->GetPositionY(), maxDIFF, target->GetPositionZ(), maxDIFF);
2864             if(!result)
2865             {
2866                 PSendSysMessage(LANG_WAYPOINT_NOTFOUNDDBPROBLEM, lowguid);
2867                 SetSentErrorMessage(true);
2868                 return false;
2869             }
2870         }
2871         do
2872         {
2873             Field *fields = result->Fetch();
2874             uint32 creGUID          = fields[0].GetUInt32();
2875             uint32 point            = fields[1].GetUInt32();
2876             int waittime            = fields[2].GetUInt32();
2877             uint32 emote            = fields[3].GetUInt32();
2878             uint32 spell            = fields[4].GetUInt32();
2879             uint32 textid[MAX_WAYPOINT_TEXT];
2880             for(int i = 0;  i < MAX_WAYPOINT_TEXT; ++i)
2881                 textid[i]           = fields[5+i].GetUInt32();
2882             uint32 model1           = fields[10].GetUInt32();
2883             uint32 model2           = fields[11].GetUInt32();
2884
2885             // Get the creature for which we read the waypoint
2886             Creature* wpCreature = ObjectAccessor::GetCreature(*m_session->GetPlayer(),MAKE_NEW_GUID(creGUID,VISUAL_WAYPOINT,HIGHGUID_UNIT));
2887
2888             PSendSysMessage(LANG_WAYPOINT_INFO_TITLE, point, (wpCreature ? wpCreature->GetName() : "<not found>"), creGUID);
2889             PSendSysMessage(LANG_WAYPOINT_INFO_WAITTIME, waittime);
2890             PSendSysMessage(LANG_WAYPOINT_INFO_MODEL, 1, model1);
2891             PSendSysMessage(LANG_WAYPOINT_INFO_MODEL, 2, model2);
2892             PSendSysMessage(LANG_WAYPOINT_INFO_EMOTE, emote);
2893             PSendSysMessage(LANG_WAYPOINT_INFO_SPELL, spell);
2894             for(int i = 0;  i < MAX_WAYPOINT_TEXT; ++i)
2895                 PSendSysMessage(LANG_WAYPOINT_INFO_TEXT, i+1, textid[i], (textid[i] ? GetMangosString(textid[i]) : ""));
2896
2897         }while( result->NextRow() );
2898         // Cleanup memory
2899         delete result;
2900         return true;
2901     }
2902
2903     if(show == "on")
2904     {
2905         PSendSysMessage("DEBUG: wp on, GUID: %u", lowguid);
2906
2907         QueryResult *result = WorldDatabase.PQuery( "SELECT point, position_x,position_y,position_z FROM creature_movement WHERE id = '%u'",lowguid);
2908         if(!result)
2909         {
2910             PSendSysMessage(LANG_WAYPOINT_NOTFOUND, lowguid);
2911             SetSentErrorMessage(true);
2912             return false;
2913         }
2914         // Delete all visuals for this NPC
2915         QueryResult *result2 = WorldDatabase.PQuery( "SELECT wpguid FROM creature_movement WHERE id = '%u' and wpguid <> 0", lowguid);
2916         if(result2)
2917         {
2918             bool hasError = false;
2919             do
2920             {
2921                 Field *fields = result2->Fetch();
2922                 uint32 wpguid = fields[0].GetUInt32();
2923                 Creature* pCreature = ObjectAccessor::GetCreature(*m_session->GetPlayer(),MAKE_NEW_GUID(wpguid,VISUAL_WAYPOINT,HIGHGUID_UNIT));
2924
2925                 if(!pCreature)
2926                 {
2927                     PSendSysMessage(LANG_WAYPOINT_NOTREMOVED, wpguid);
2928                     hasError = true;
2929                     WorldDatabase.PExecuteLog("DELETE FROM creature WHERE guid = '%u'", wpguid);
2930                 }
2931                 else
2932                 {
2933                     pCreature->DeleteFromDB();
2934                     pCreature->CleanupsBeforeDelete();
2935                     pCreature->AddObjectToRemoveList();
2936                 }
2937
2938             }while( result2->NextRow() );
2939             delete result2;
2940             if( hasError )
2941             {
2942                 PSendSysMessage(LANG_WAYPOINT_TOOFAR1);
2943                 PSendSysMessage(LANG_WAYPOINT_TOOFAR2);
2944                 PSendSysMessage(LANG_WAYPOINT_TOOFAR3);
2945             }
2946         }
2947
2948         do
2949         {
2950             Field *fields = result->Fetch();
2951             uint32 point    = fields[0].GetUInt32();
2952             float x         = fields[1].GetFloat();
2953             float y         = fields[2].GetFloat();
2954             float z         = fields[3].GetFloat();
2955
2956             uint32 id = VISUAL_WAYPOINT;
2957
2958             Player *chr = m_session->GetPlayer();
2959             Map *map = chr->GetMap();
2960             float o = chr->GetOrientation();
2961
2962             Creature* wpCreature = new Creature;
2963             if (!wpCreature->Create(objmgr.GenerateLowGuid(HIGHGUID_UNIT), map, id, 0))
2964             {
2965                 PSendSysMessage(LANG_WAYPOINT_VP_NOTCREATED, id);
2966                 delete wpCreature;
2967                 delete result;
2968                 return false;
2969             }
2970
2971             wpCreature->Relocate(x, y, z, o);
2972
2973             if(!wpCreature->IsPositionValid())
2974             {
2975                 sLog.outError("ERROR: Creature (guidlow %d, entry %d) not created. Suggested coordinates isn't valid (X: %f Y: %f)",wpCreature->GetGUIDLow(),wpCreature->GetEntry(),wpCreature->GetPositionX(),wpCreature->GetPositionY());
2976                 delete wpCreature;
2977                 delete result;
2978                 return false;
2979             }
2980
2981             wpCreature->SetVisibility(VISIBILITY_OFF);
2982             sLog.outDebug("DEBUG: UPDATE creature_movement SET wpguid = '%u");
2983             // set "wpguid" column to the visual waypoint
2984             WorldDatabase.PExecuteLog("UPDATE creature_movement SET wpguid = '%u' WHERE id = '%u' and point = '%u'", wpCreature->GetGUIDLow(), lowguid, point);
2985
2986             wpCreature->SaveToDB(map->GetId(), (1 << map->GetSpawnMode()));
2987             // To call _LoadGoods(); _LoadQuests(); CreateTrainerSpells();
2988             wpCreature->LoadFromDB(wpCreature->GetDBTableGUIDLow(),map);
2989             map->Add(wpCreature);
2990             //wpCreature->GetMap()->Add(wpCreature);
2991         }while( result->NextRow() );
2992
2993         // Cleanup memory
2994         delete result;
2995         return true;
2996     }
2997
2998     if(show == "first")
2999     {
3000         PSendSysMessage("DEBUG: wp first, GUID: %u", lowguid);
3001
3002         QueryResult *result = WorldDatabase.PQuery( "SELECT position_x,position_y,position_z FROM creature_movement WHERE point='1' AND id = '%u'",lowguid);
3003         if(!result)
3004         {
3005             PSendSysMessage(LANG_WAYPOINT_NOTFOUND, lowguid);
3006             SetSentErrorMessage(true);
3007             return false;
3008         }
3009
3010         Field *fields = result->Fetch();
3011         float x         = fields[0].GetFloat();
3012         float y         = fields[1].GetFloat();
3013         float z         = fields[2].GetFloat();
3014         uint32 id = VISUAL_WAYPOINT;
3015
3016         Player *chr = m_session->GetPlayer();
3017         float o = chr->GetOrientation();
3018         Map *map = chr->GetMap();
3019
3020         Creature* pCreature = new Creature;
3021         if (!pCreature->Create(objmgr.GenerateLowGuid(HIGHGUID_UNIT),map, id, 0))
3022         {
3023             PSendSysMessage(LANG_WAYPOINT_VP_NOTCREATED, id);
3024             delete pCreature;
3025             delete result;
3026             return false;
3027         }
3028
3029         pCreature->Relocate(x, y, z, o);
3030
3031         if(!pCreature->IsPositionValid())
3032         {
3033             sLog.outError("ERROR: Creature (guidlow %d, entry %d) not created. Suggested coordinates isn't valid (X: %f Y: %f)",pCreature->GetGUIDLow(),pCreature->GetEntry(),pCreature->GetPositionX(),pCreature->GetPositionY());
3034             delete pCreature;
3035             delete result;
3036             return false;
3037         }
3038
3039         pCreature->SaveToDB(map->GetId(), (1 << map->GetSpawnMode()));
3040         pCreature->LoadFromDB(pCreature->GetDBTableGUIDLow(), map);
3041         map->Add(pCreature);
3042         //player->PlayerTalkClass->SendPointOfInterest(x, y, 6, 6, 0, "First Waypoint");
3043
3044         // Cleanup memory
3045         delete result;
3046         return true;
3047     }
3048
3049     if(show == "last")
3050     {
3051         PSendSysMessage("DEBUG: wp last, GUID: %u", lowguid);
3052
3053         QueryResult *result = WorldDatabase.PQuery( "SELECT MAX(point) FROM creature_movement WHERE id = '%u'",lowguid);
3054         if( result )
3055         {
3056             Maxpoint = (*result)[0].GetUInt32();
3057
3058             delete result;
3059         }
3060         else
3061             Maxpoint = 0;
3062
3063         result = WorldDatabase.PQuery( "SELECT position_x,position_y,position_z FROM creature_movement WHERE point ='%u' AND id = '%u'",Maxpoint, lowguid);
3064         if(!result)
3065         {
3066             PSendSysMessage(LANG_WAYPOINT_NOTFOUNDLAST, lowguid);
3067             SetSentErrorMessage(true);
3068             return false;
3069         }
3070         Field *fields = result->Fetch();
3071         float x         = fields[0].GetFloat();
3072         float y         = fields[1].GetFloat();
3073         float z         = fields[2].GetFloat();
3074         uint32 id = VISUAL_WAYPOINT;
3075
3076         Player *chr = m_session->GetPlayer();
3077         float o = chr->GetOrientation();
3078         Map *map = chr->GetMap();
3079
3080         Creature* pCreature = new Creature;
3081         if (!pCreature->Create(objmgr.GenerateLowGuid(HIGHGUID_UNIT), map, id, 0))
3082         {
3083             PSendSysMessage(LANG_WAYPOINT_NOTCREATED, id);
3084             delete pCreature;
3085             delete result;
3086             return false;
3087         }
3088
3089         pCreature->Relocate(x, y, z, o);
3090
3091         if(!pCreature->IsPositionValid())
3092         {
3093             sLog.outError("ERROR: Creature (guidlow %d, entry %d) not created. Suggested coordinates isn't valid (X: %f Y: %f)",pCreature->GetGUIDLow(),pCreature->GetEntry(),pCreature->GetPositionX(),pCreature->GetPositionY());
3094             delete pCreature;
3095             delete result;
3096             return false;
3097         }
3098
3099         pCreature->SaveToDB(map->GetId(), (1 << map->GetSpawnMode()));
3100         pCreature->LoadFromDB(pCreature->GetDBTableGUIDLow(), map);
3101         map->Add(pCreature);
3102         //player->PlayerTalkClass->SendPointOfInterest(x, y, 6, 6, 0, "Last Waypoint");
3103         // Cleanup memory
3104         delete result;
3105         return true;
3106     }
3107
3108     if(show == "off")
3109     {
3110         QueryResult *result = WorldDatabase.PQuery("SELECT guid FROM creature WHERE id = '%d'", VISUAL_WAYPOINT);
3111         if(!result)
3112         {
3113             SendSysMessage(LANG_WAYPOINT_VP_NOTFOUND);
3114             SetSentErrorMessage(true);
3115             return false;
3116         }
3117         bool hasError = false;
3118         do
3119         {
3120             Field *fields = result->Fetch();
3121             uint32 guid = fields[0].GetUInt32();
3122             Creature* pCreature = ObjectAccessor::GetCreature(*m_session->GetPlayer(),MAKE_NEW_GUID(guid,VISUAL_WAYPOINT,HIGHGUID_UNIT));
3123
3124             //Creature* pCreature = ObjectAccessor::GetCreature(*m_session->GetPlayer(), guid);
3125
3126             if(!pCreature)
3127             {
3128                 PSendSysMessage(LANG_WAYPOINT_NOTREMOVED, guid);
3129                 hasError = true;
3130                 WorldDatabase.PExecuteLog("DELETE FROM creature WHERE guid = '%u'", guid);
3131             }
3132             else
3133             {
3134                 pCreature->DeleteFromDB();
3135                 pCreature->CleanupsBeforeDelete();
3136                 pCreature->AddObjectToRemoveList();
3137             }
3138         }while(result->NextRow());
3139         // set "wpguid" column to "empty" - no visual waypoint spawned
3140         WorldDatabase.PExecuteLog("UPDATE creature_movement SET wpguid = '0' WHERE wpguid <> '0'");
3141
3142         if( hasError )
3143         {
3144             PSendSysMessage(LANG_WAYPOINT_TOOFAR1);
3145             PSendSysMessage(LANG_WAYPOINT_TOOFAR2);
3146             PSendSysMessage(LANG_WAYPOINT_TOOFAR3);
3147         }
3148
3149         SendSysMessage(LANG_WAYPOINT_VP_ALLREMOVED);
3150         // Cleanup memory
3151         delete result;
3152
3153         return true;
3154     }
3155
3156     PSendSysMessage("DEBUG: wpshow - no valid command found");
3157
3158     return true;
3159 }                                                           // HandleWpShowCommand
3160
3161 bool ChatHandler::HandleWpExportCommand(const char *args)
3162 {
3163     if(!*args)
3164         return false;
3165
3166     // Next arg is: <GUID> <ARGUMENT>
3167
3168     // Did user provide a GUID
3169     // or did the user select a creature?
3170     // -> variable lowguid is filled with the GUID of the NPC
3171     uint32 lowguid = 0;
3172     Creature* target = getSelectedCreature();
3173     char* arg_str = NULL;
3174     if (target)
3175     {
3176         if (target->GetEntry() != VISUAL_WAYPOINT)
3177             lowguid = target->GetGUIDLow();
3178         else
3179         {
3180             QueryResult *result = WorldDatabase.PQuery( "SELECT id FROM creature_movement WHERE wpguid = %u LIMIT 1", target->GetGUIDLow() );
3181             if (!result)
3182             {
3183                 PSendSysMessage(LANG_WAYPOINT_NOTFOUNDDBPROBLEM, target->GetGUIDLow());
3184                 return true;
3185             }
3186             Field *fields = result->Fetch();
3187             lowguid = fields[0].GetUInt32();;
3188             delete result;
3189         }
3190
3191         arg_str = strtok((char*)args, " ");
3192     }
3193     else
3194     {
3195         // user provided <GUID>
3196         char* guid_str = strtok((char*)args, " ");
3197         if( !guid_str )
3198         {
3199             SendSysMessage(LANG_WAYPOINT_NOGUID);
3200             return false;
3201         }
3202         lowguid = atoi((char*)guid_str);
3203
3204         arg_str = strtok((char*)NULL, " ");
3205     }
3206
3207     if( !arg_str)
3208     {
3209         PSendSysMessage(LANG_WAYPOINT_ARGUMENTREQ, "export");
3210         return false;
3211     }
3212
3213     PSendSysMessage("DEBUG: wp export, GUID: %u", lowguid);
3214
3215     QueryResult *result = WorldDatabase.PQuery(
3216     //          0      1           2           3           4            5       6       7         8      9      10       11       12       13       14       15
3217         "SELECT point, position_x, position_y, position_z, orientation, model1, model2, waittime, emote, spell, textid1, textid2, textid3, textid4, textid5, id FROM creature_movement WHERE id = '%u' ORDER BY point", lowguid );
3218
3219     if (!result)
3220     {
3221         PSendSysMessage(LANG_WAYPOINT_NOTHINGTOEXPORT);
3222         SetSentErrorMessage(true);
3223         return false;
3224     }
3225
3226     std::ofstream outfile;
3227     outfile.open (arg_str);
3228
3229     do
3230     {
3231         Field *fields = result->Fetch();
3232
3233         outfile << "INSERT INTO creature_movement ";
3234         outfile << "( id, point, position_x, position_y, position_z, orientation, model1, model2, waittime, emote, spell, textid1, textid2, textid3, textid4, textid5 ) VALUES ";
3235
3236         outfile << "( ";
3237         outfile << fields[15].GetUInt32();                  // id
3238         outfile << ", ";
3239         outfile << fields[0].GetUInt32();                   // point
3240         outfile << ", ";
3241         outfile << fields[1].GetFloat();                    // position_x
3242         outfile << ", ";
3243         outfile << fields[2].GetFloat();                    // position_y
3244         outfile << ", ";
3245         outfile << fields[3].GetUInt32();                   // position_z
3246         outfile << ", ";
3247         outfile << fields[4].GetUInt32();                   // orientation
3248         outfile << ", ";
3249         outfile << fields[5].GetUInt32();                   // model1
3250         outfile << ", ";
3251         outfile << fields[6].GetUInt32();                   // model2
3252         outfile << ", ";
3253         outfile << fields[7].GetUInt16();                   // waittime
3254         outfile << ", ";
3255         outfile << fields[8].GetUInt32();                   // emote
3256         outfile << ", ";
3257         outfile << fields[9].GetUInt32();                   // spell
3258         outfile << ", ";
3259         outfile << fields[10].GetUInt32();                  // textid1
3260         outfile << ", ";
3261         outfile << fields[11].GetUInt32();                  // textid2
3262         outfile << ", ";
3263         outfile << fields[12].GetUInt32();                  // textid3
3264         outfile << ", ";
3265         outfile << fields[13].GetUInt32();                  // textid4
3266         outfile << ", ";
3267         outfile << fields[14].GetUInt32();                  // textid5
3268         outfile << ");\n ";
3269
3270     } while( result->NextRow() );
3271     delete result;
3272
3273     PSendSysMessage(LANG_WAYPOINT_EXPORTED);
3274     outfile.close();
3275
3276     return true;
3277 }
3278
3279 bool ChatHandler::HandleWpImportCommand(const char *args)
3280 {
3281     if(!*args)
3282         return false;
3283
3284     char* arg_str = strtok((char*)args, " ");
3285     if (!arg_str)
3286         return false;
3287
3288     std::string line;
3289     std::ifstream infile (arg_str);
3290     if (infile.is_open())
3291     {
3292         while (! infile.eof() )
3293         {
3294             getline (infile,line);
3295             //cout << line << endl;
3296             QueryResult *result = WorldDatabase.Query(line.c_str());
3297             delete result;
3298         }
3299         infile.close();
3300     }
3301     PSendSysMessage(LANG_WAYPOINT_IMPORTED);
3302
3303     return true;
3304 }
3305
3306 //rename characters
3307 bool ChatHandler::HandleRenameCommand(const char* args)
3308 {
3309     Player* target = NULL;
3310     uint64 targetGUID = 0;
3311     std::string oldname;
3312
3313     char* px = strtok((char*)args, " ");
3314
3315     if(px)
3316     {
3317         oldname = px;
3318
3319         if(!normalizePlayerName(oldname))
3320         {
3321             SendSysMessage(LANG_PLAYER_NOT_FOUND);
3322             SetSentErrorMessage(true);
3323             return false;
3324         }
3325
3326         target = objmgr.GetPlayer(oldname.c_str());
3327
3328         if (!target)
3329             targetGUID = objmgr.GetPlayerGUIDByName(oldname);
3330     }
3331
3332     if(!target && !targetGUID)
3333     {
3334         target = getSelectedPlayer();
3335     }
3336
3337     if(!target && !targetGUID)
3338     {
3339         SendSysMessage(LANG_PLAYER_NOT_FOUND);
3340         SetSentErrorMessage(true);
3341         return false;
3342     }
3343
3344     if(target)
3345     {
3346         PSendSysMessage(LANG_RENAME_PLAYER, target->GetName());
3347         target->SetAtLoginFlag(AT_LOGIN_RENAME);
3348         CharacterDatabase.PExecute("UPDATE characters SET at_login = at_login | '1' WHERE guid = '%u'", target->GetGUIDLow());
3349     }
3350     else
3351     {
3352         PSendSysMessage(LANG_RENAME_PLAYER_GUID, oldname.c_str(), GUID_LOPART(targetGUID));
3353         CharacterDatabase.PExecute("UPDATE characters SET at_login = at_login | '1' WHERE guid = '%u'", GUID_LOPART(targetGUID));
3354     }
3355
3356     return true;
3357 }
3358
3359 //spawn go
3360 bool ChatHandler::HandleGameObjectCommand(const char* args)
3361 {
3362     if (!*args)
3363         return false;
3364
3365     char* pParam1 = strtok((char*)args, " ");
3366     if (!pParam1)
3367         return false;
3368
3369     uint32 id = atoi((char*)pParam1);
3370     if(!id)
3371         return false;
3372
3373     char* spawntimeSecs = strtok(NULL, " ");
3374
3375     const GameObjectInfo *goI = objmgr.GetGameObjectInfo(id);
3376
3377     if (!goI)
3378     {
3379         PSendSysMessage(LANG_GAMEOBJECT_NOT_EXIST,id);
3380         SetSentErrorMessage(true);
3381         return false;
3382     }
3383
3384     Player *chr = m_session->GetPlayer();
3385     float x = float(chr->GetPositionX());
3386     float y = float(chr->GetPositionY());
3387     float z = float(chr->GetPositionZ());
3388     float o = float(chr->GetOrientation());
3389     Map *map = chr->GetMap();
3390
3391     float rot2 = sin(o/2);
3392     float rot3 = cos(o/2);
3393
3394     GameObject* pGameObj = new GameObject;
3395     uint32 db_lowGUID = objmgr.GenerateLowGuid(HIGHGUID_GAMEOBJECT);
3396
3397     if(!pGameObj->Create(db_lowGUID, goI->id, map, x, y, z, o, 0, 0, rot2, rot3, 0, 1))
3398     {
3399         delete pGameObj;
3400         return false;
3401     }
3402
3403     if( spawntimeSecs )
3404     {
3405         uint32 value = atoi((char*)spawntimeSecs);
3406         pGameObj->SetRespawnTime(value);
3407         //sLog.outDebug("*** spawntimeSecs: %d", value);
3408     }
3409
3410     // fill the gameobject data and save to the db
3411     pGameObj->SaveToDB(map->GetId(), (1 << map->GetSpawnMode()));
3412
3413     // this will generate a new guid if the object is in an instance
3414     if(!pGameObj->LoadFromDB(db_lowGUID, map))
3415     {
3416         delete pGameObj;
3417         return false;
3418     }
3419
3420     sLog.outDebug(GetMangosString(LANG_GAMEOBJECT_CURRENT), goI->name, db_lowGUID, x, y, z, o);
3421
3422     map->Add(pGameObj);
3423
3424     // TODO: is it really necessary to add both the real and DB table guid here ?
3425     objmgr.AddGameobjectToGrid(db_lowGUID, objmgr.GetGOData(db_lowGUID));
3426
3427     PSendSysMessage(LANG_GAMEOBJECT_ADD,id,goI->name,db_lowGUID,x,y,z);
3428     return true;
3429 }
3430
3431 //show animation
3432 bool ChatHandler::HandleAnimCommand(const char* args)
3433 {
3434     if (!*args)
3435         return false;
3436
3437     uint32 anim_id = atoi((char*)args);
3438     m_session->GetPlayer()->HandleEmoteCommand(anim_id);
3439     return true;
3440 }
3441
3442 //change standstate
3443 bool ChatHandler::HandleStandStateCommand(const char* args)
3444 {
3445     if (!*args)
3446         return false;
3447
3448     uint32 anim_id = atoi((char*)args);
3449     m_session->GetPlayer( )->SetUInt32Value( UNIT_NPC_EMOTESTATE , anim_id );
3450
3451     return true;
3452 }
3453
3454 bool ChatHandler::HandleAddHonorCommand(const char* args)
3455 {
3456     if (!*args)
3457         return false;
3458
3459     Player *target = getSelectedPlayer();
3460     if(!target)
3461     {
3462         SendSysMessage(LANG_PLAYER_NOT_FOUND);
3463         SetSentErrorMessage(true);
3464         return false;
3465     }
3466
3467     uint32 amount = (uint32)atoi(args);
3468     target->RewardHonor(NULL, 1, amount);
3469     return true;
3470 }
3471
3472 bool ChatHandler::HandleHonorAddKillCommand(const char* /*args*/)
3473 {
3474     Unit *target = getSelectedUnit();
3475     if(!target)
3476     {
3477         SendSysMessage(LANG_PLAYER_NOT_FOUND);
3478         SetSentErrorMessage(true);
3479         return false;
3480     }
3481
3482     m_session->GetPlayer()->RewardHonor(target, 1);
3483     return true;
3484 }
3485
3486 bool ChatHandler::HandleUpdateHonorFieldsCommand(const char* /*args*/)
3487 {
3488     Player *target = getSelectedPlayer();
3489     if(!target)
3490     {
3491         SendSysMessage(LANG_PLAYER_NOT_FOUND);
3492         SetSentErrorMessage(true);
3493         return false;
3494     }
3495
3496     target->UpdateHonorFields();
3497     return true;
3498 }
3499
3500 bool ChatHandler::HandleLookupEventCommand(const char* args)
3501 {
3502     if(!*args)
3503         return false;
3504
3505     std::string namepart = args;
3506     std::wstring wnamepart;
3507
3508     // converting string that we try to find to lower case
3509     if(!Utf8toWStr(namepart,wnamepart))
3510         return false;
3511
3512     wstrToLower(wnamepart);
3513
3514     uint32 counter = 0;
3515
3516     GameEvent::GameEventDataMap const& events = gameeventmgr.GetEventMap();
3517     GameEvent::ActiveEvents const& activeEvents = gameeventmgr.GetActiveEventList();
3518
3519     for(uint32 id = 0; id < events.size(); ++id )
3520     {
3521         GameEventData const& eventData = events[id];
3522
3523         std::string descr = eventData.description;
3524         if(descr.empty())
3525             continue;
3526
3527         if (Utf8FitTo(descr, wnamepart))
3528         {
3529             char const* active = activeEvents.find(id) != activeEvents.end() ? GetMangosString(LANG_ACTIVE) : "";
3530
3531             if(m_session)
3532                 PSendSysMessage(LANG_EVENT_ENTRY_LIST_CHAT,id,id,eventData.description.c_str(),active );
3533             else
3534                 PSendSysMessage(LANG_EVENT_ENTRY_LIST_CONSOLE,id,eventData.description.c_str(),active );
3535
3536             ++counter;
3537         }
3538     }
3539
3540     if (counter==0)
3541         SendSysMessage(LANG_NOEVENTFOUND);
3542
3543     return true;
3544 }
3545
3546 bool ChatHandler::HandleEventActiveListCommand(const char* /*args*/)
3547 {
3548     uint32 counter = 0;
3549
3550     GameEvent::GameEventDataMap const& events = gameeventmgr.GetEventMap();
3551     GameEvent::ActiveEvents const& activeEvents = gameeventmgr.GetActiveEventList();
3552
3553     char const* active = GetMangosString(LANG_ACTIVE);
3554
3555     for(GameEvent::ActiveEvents::const_iterator itr = activeEvents.begin(); itr != activeEvents.end(); ++itr )
3556     {
3557         uint32 event_id = *itr;
3558         GameEventData const& eventData = events[event_id];
3559
3560         if(m_session)
3561             PSendSysMessage(LANG_EVENT_ENTRY_LIST_CHAT,event_id,event_id,eventData.description.c_str(),active );
3562         else
3563             PSendSysMessage(LANG_EVENT_ENTRY_LIST_CONSOLE,event_id,eventData.description.c_str(),active );
3564
3565         ++counter;
3566     }
3567
3568     if (counter==0)
3569         SendSysMessage(LANG_NOEVENTFOUND);
3570
3571     return true;
3572 }
3573
3574 bool ChatHandler::HandleEventInfoCommand(const char* args)
3575 {
3576     if(!*args)
3577         return false;
3578
3579     // id or [name] Shift-click form |color|Hgameevent:id|h[name]|h|r
3580     char* cId = extractKeyFromLink((char*)args,"Hgameevent");
3581     if(!cId)
3582         return false;
3583
3584     uint32 event_id = atoi(cId);
3585
3586     GameEvent::GameEventDataMap const& events = gameeventmgr.GetEventMap();
3587
3588     if(event_id >=events.size())
3589     {
3590         SendSysMessage(LANG_EVENT_NOT_EXIST);
3591         SetSentErrorMessage(true);
3592         return false;
3593     }
3594
3595     GameEventData const& eventData = events[event_id];
3596     if(!eventData.isValid())
3597     {
3598         SendSysMessage(LANG_EVENT_NOT_EXIST);
3599         SetSentErrorMessage(true);
3600         return false;
3601     }
3602
3603     GameEvent::ActiveEvents const& activeEvents = gameeventmgr.GetActiveEventList();
3604     bool active = activeEvents.find(event_id) != activeEvents.end();
3605     char const* activeStr = active ? GetMangosString(LANG_ACTIVE) : "";
3606
3607     std::string startTimeStr = TimeToTimestampStr(eventData.start);
3608     std::string endTimeStr = TimeToTimestampStr(eventData.end);
3609
3610     uint32 delay = gameeventmgr.NextCheck(event_id);
3611     time_t nextTime = time(NULL)+delay;
3612     std::string nextStr = nextTime >= eventData.start && nextTime < eventData.end ? TimeToTimestampStr(time(NULL)+delay) : "-";
3613
3614     std::string occurenceStr = secsToTimeString(eventData.occurence * MINUTE);
3615     std::string lengthStr = secsToTimeString(eventData.length * MINUTE);
3616
3617     PSendSysMessage(LANG_EVENT_INFO,event_id,eventData.description.c_str(),activeStr,
3618         startTimeStr.c_str(),endTimeStr.c_str(),occurenceStr.c_str(),lengthStr.c_str(),
3619         nextStr.c_str());
3620     return true;
3621 }
3622
3623 bool ChatHandler::HandleEventStartCommand(const char* args)
3624 {
3625     if(!*args)
3626         return false;
3627
3628     // id or [name] Shift-click form |color|Hgameevent:id|h[name]|h|r
3629     char* cId = extractKeyFromLink((char*)args,"Hgameevent");
3630     if(!cId)
3631         return false;
3632
3633     int32 event_id = atoi(cId);
3634
3635     GameEvent::GameEventDataMap const& events = gameeventmgr.GetEventMap();
3636
3637     if(event_id < 1 || event_id >=events.size())
3638     {
3639         SendSysMessage(LANG_EVENT_NOT_EXIST);
3640         SetSentErrorMessage(true);
3641         return false;
3642     }
3643
3644     GameEventData const& eventData = events[event_id];
3645     if(!eventData.isValid())
3646     {
3647         SendSysMessage(LANG_EVENT_NOT_EXIST);
3648         SetSentErrorMessage(true);
3649         return false;
3650     }
3651
3652     GameEvent::ActiveEvents const& activeEvents = gameeventmgr.GetActiveEventList();
3653     if(activeEvents.find(event_id) != activeEvents.end())
3654     {
3655         PSendSysMessage(LANG_EVENT_ALREADY_ACTIVE,event_id);
3656         SetSentErrorMessage(true);
3657         return false;
3658     }
3659
3660     gameeventmgr.StartEvent(event_id,true);
3661     return true;
3662 }
3663
3664 bool ChatHandler::HandleEventStopCommand(const char* args)
3665 {
3666     if(!*args)
3667         return false;
3668
3669     // id or [name] Shift-click form |color|Hgameevent:id|h[name]|h|r
3670     char* cId = extractKeyFromLink((char*)args,"Hgameevent");
3671     if(!cId)
3672         return false;
3673
3674     int32 event_id = atoi(cId);
3675
3676     GameEvent::GameEventDataMap const& events = gameeventmgr.GetEventMap();
3677
3678     if(event_id < 1 || event_id >=events.size())
3679     {
3680         SendSysMessage(LANG_EVENT_NOT_EXIST);
3681         SetSentErrorMessage(true);
3682         return false;
3683     }
3684
3685     GameEventData const& eventData = events[event_id];
3686     if(!eventData.isValid())
3687     {
3688         SendSysMessage(LANG_EVENT_NOT_EXIST);
3689         SetSentErrorMessage(true);
3690         return false;
3691     }
3692
3693     GameEvent::ActiveEvents const& activeEvents = gameeventmgr.GetActiveEventList();
3694
3695     if(activeEvents.find(event_id) == activeEvents.end())
3696     {
3697         PSendSysMessage(LANG_EVENT_NOT_ACTIVE,event_id);
3698         SetSentErrorMessage(true);
3699         return false;
3700     }
3701
3702     gameeventmgr.StopEvent(event_id,true);
3703     return true;
3704 }
3705
3706 bool ChatHandler::HandleCombatStopCommand(const char* args)
3707 {
3708     Player *player;
3709
3710     if(*args)
3711     {
3712         std::string playername = args;
3713
3714         if(!normalizePlayerName(playername))
3715         {
3716             SendSysMessage(LANG_PLAYER_NOT_FOUND);
3717             SetSentErrorMessage(true);
3718             return false;
3719         }
3720
3721         player = objmgr.GetPlayer(playername.c_str());
3722
3723         if(!player)
3724         {
3725             SendSysMessage(LANG_PLAYER_NOT_FOUND);
3726             SetSentErrorMessage(true);
3727             return false;
3728         }
3729     }
3730     else
3731     {
3732         player = getSelectedPlayer();
3733
3734         if (!player)
3735             player = m_session->GetPlayer();
3736     }
3737
3738     player->CombatStop();
3739     player->getHostilRefManager().deleteReferences();
3740     return true;
3741 }
3742
3743 bool ChatHandler::HandleLearnAllCraftsCommand(const char* /*args*/)
3744 {
3745     uint32 classmask = m_session->GetPlayer()->getClassMask();
3746
3747     for (uint32 i = 0; i < sSkillLineStore.GetNumRows(); ++i)
3748     {
3749         SkillLineEntry const *skillInfo = sSkillLineStore.LookupEntry(i);
3750         if( !skillInfo )
3751             continue;
3752
3753         if( skillInfo->categoryId == SKILL_CATEGORY_PROFESSION || skillInfo->categoryId == SKILL_CATEGORY_SECONDARY )
3754         {
3755             for (uint32 j = 0; j < sSkillLineAbilityStore.GetNumRows(); ++j)
3756             {
3757                 SkillLineAbilityEntry const *skillLine = sSkillLineAbilityStore.LookupEntry(j);
3758                 if( !skillLine )
3759                     continue;
3760
3761                 // skip racial skills
3762                 if( skillLine->racemask != 0 )
3763                     continue;
3764
3765                 // skip wrong class skills
3766                 if( skillLine->classmask && (skillLine->classmask & classmask) == 0)
3767                     continue;
3768
3769                 if( skillLine->skillId != i || skillLine->forward_spellid )
3770                     continue;
3771
3772                 SpellEntry const* spellInfo = sSpellStore.LookupEntry(skillLine->spellId);
3773                 if(!spellInfo || !SpellMgr::IsSpellValid(spellInfo,m_session->GetPlayer(),false))
3774                     continue;
3775
3776                 m_session->GetPlayer()->learnSpell(skillLine->spellId);
3777             }
3778         }
3779     }
3780
3781     SendSysMessage(LANG_COMMAND_LEARN_ALL_CRAFT);
3782     return true;
3783 }
3784
3785 bool ChatHandler::HandleLearnAllRecipesCommand(const char* args)
3786 {
3787     //  Learns all recipes of specified profession and sets skill to max
3788     //  Example: .learn all_recipes enchanting
3789
3790     Player* target = getSelectedPlayer();
3791     if( !target )
3792     {
3793         SendSysMessage(LANG_PLAYER_NOT_FOUND);
3794         return false;
3795     }
3796
3797     if(!*args)
3798         return false;
3799
3800     std::wstring wnamepart;
3801
3802     if(!Utf8toWStr(args,wnamepart))
3803         return false;
3804
3805     // converting string that we try to find to lower case
3806     wstrToLower( wnamepart );
3807
3808     uint32 classmask = m_session->GetPlayer()->getClassMask();
3809
3810     for (uint32 i = 0; i < sSkillLineStore.GetNumRows(); ++i)
3811     {
3812         SkillLineEntry const *skillInfo = sSkillLineStore.LookupEntry(i);
3813         if( !skillInfo )
3814             continue;
3815
3816         if( skillInfo->categoryId != SKILL_CATEGORY_PROFESSION &&
3817             skillInfo->categoryId != SKILL_CATEGORY_SECONDARY )
3818             continue;
3819
3820         int loc = m_session->GetSessionDbcLocale();
3821         std::string name = skillInfo->name[loc];
3822
3823         if(Utf8FitTo(name, wnamepart))
3824         {
3825             for (uint32 j = 0; j < sSkillLineAbilityStore.GetNumRows(); ++j)
3826             {
3827                 SkillLineAbilityEntry const *skillLine = sSkillLineAbilityStore.LookupEntry(j);
3828                 if( !skillLine )
3829                     continue;
3830
3831                 if( skillLine->skillId != i || skillLine->forward_spellid )
3832                     continue;
3833
3834                 // skip racial skills
3835                 if( skillLine->racemask != 0 )
3836                     continue;
3837
3838                 // skip wrong class skills
3839                 if( skillLine->classmask && (skillLine->classmask & classmask) == 0)
3840                     continue;
3841
3842                 SpellEntry const* spellInfo = sSpellStore.LookupEntry(skillLine->spellId);
3843                 if(!spellInfo || !SpellMgr::IsSpellValid(spellInfo,m_session->GetPlayer(),false))
3844                     continue;
3845
3846                 if( !target->HasSpell(spellInfo->Id) )
3847                     m_session->GetPlayer()->learnSpell(skillLine->spellId);
3848             }
3849
3850             uint16 maxLevel = target->GetPureMaxSkillValue(skillInfo->id);
3851             target->SetSkill(skillInfo->id, maxLevel, maxLevel);
3852             PSendSysMessage(LANG_COMMAND_LEARN_ALL_RECIPES, name.c_str());
3853             return true;
3854         }
3855     }
3856
3857     return false;
3858 }
3859
3860 bool ChatHandler::HandleLookupPlayerIpCommand(const char* args)
3861 {
3862
3863     if (!*args)
3864         return false;
3865
3866     std::string ip = strtok ((char*)args, " ");
3867     char* limit_str = strtok (NULL, " ");
3868     int32 limit = limit_str ? atoi (limit_str) : -1;
3869
3870     loginDatabase.escape_string (ip);
3871
3872     QueryResult* result = loginDatabase.PQuery ("SELECT id,username FROM account WHERE last_ip = '%s'", ip.c_str ());
3873
3874     return LookupPlayerSearchCommand (result,limit);
3875 }
3876
3877 bool ChatHandler::HandleLookupPlayerAccountCommand(const char* args)
3878 {
3879     if (!*args)
3880         return false;
3881
3882     std::string account = strtok ((char*)args, " ");
3883     char* limit_str = strtok (NULL, " ");
3884     int32 limit = limit_str ? atoi (limit_str) : -1;
3885
3886     if (!AccountMgr::normilizeString (account))
3887         return false;
3888
3889     loginDatabase.escape_string (account);
3890
3891     QueryResult* result = loginDatabase.PQuery ("SELECT id,username FROM account WHERE username = '%s'", account.c_str ());
3892
3893     return LookupPlayerSearchCommand (result,limit);
3894 }
3895
3896 bool ChatHandler::HandleLookupPlayerEmailCommand(const char* args)
3897 {
3898
3899     if (!*args)
3900         return false;
3901
3902     std::string email = strtok ((char*)args, " ");
3903     char* limit_str = strtok (NULL, " ");
3904     int32 limit = limit_str ? atoi (limit_str) : -1;
3905
3906     loginDatabase.escape_string (email);
3907
3908     QueryResult* result = loginDatabase.PQuery ("SELECT id,username FROM account WHERE email = '%s'", email.c_str ());
3909
3910     return LookupPlayerSearchCommand (result,limit);
3911 }
3912
3913 bool ChatHandler::LookupPlayerSearchCommand(QueryResult* result, int32 limit)
3914 {
3915     if(!result)
3916     {
3917         PSendSysMessage(LANG_NO_PLAYERS_FOUND);
3918         SetSentErrorMessage(true);
3919         return false;
3920     }
3921
3922     int i =0;
3923     do
3924     {
3925         Field* fields = result->Fetch();
3926         uint32 acc_id = fields[0].GetUInt32();
3927         std::string acc_name = fields[1].GetCppString();
3928
3929         QueryResult* chars = CharacterDatabase.PQuery("SELECT guid,name FROM characters WHERE account = '%u'", acc_id);
3930         if(chars)
3931         {
3932             PSendSysMessage(LANG_LOOKUP_PLAYER_ACCOUNT,acc_name.c_str(),acc_id);
3933
3934             uint64 guid = 0;
3935             std::string name;
3936
3937             do
3938             {
3939                 Field* charfields = chars->Fetch();
3940                 guid = charfields[0].GetUInt64();
3941                 name = charfields[1].GetCppString();
3942
3943                 PSendSysMessage(LANG_LOOKUP_PLAYER_CHARACTER,name.c_str(),guid);
3944                 ++i;
3945
3946             } while( chars->NextRow() && ( limit == -1 || i < limit ) );
3947
3948             delete chars;
3949         }
3950     } while(result->NextRow());
3951
3952     delete result;
3953
3954     return true;
3955 }
3956
3957 /// Triggering corpses expire check in world
3958 bool ChatHandler::HandleServerCorpsesCommand(const char* /*args*/)
3959 {
3960     CorpsesErase();
3961     return true;
3962 }
3963
3964 bool ChatHandler::HandleRepairitemsCommand(const char* /*args*/)
3965 {
3966     Player *target = getSelectedPlayer();
3967
3968     if(!target)
3969     {
3970         PSendSysMessage(LANG_NO_CHAR_SELECTED);
3971         SetSentErrorMessage(true);
3972         return false;
3973     }
3974
3975     // Repair items
3976     target->DurabilityRepairAll(false, 0, false);
3977
3978     PSendSysMessage(LANG_YOU_REPAIR_ITEMS, target->GetName());
3979     if(needReportToTarget(target))
3980         ChatHandler(target).PSendSysMessage(LANG_YOUR_ITEMS_REPAIRED, GetName());
3981     return true;
3982 }
3983
3984 bool ChatHandler::HandleWaterwalkCommand(const char* args)
3985 {
3986     if(!*args)
3987         return false;
3988
3989     Player *player = getSelectedPlayer();
3990
3991     if(!player)
3992     {
3993         PSendSysMessage(LANG_NO_CHAR_SELECTED);
3994         SetSentErrorMessage(true);
3995         return false;
3996     }
3997
3998     if (strncmp(args, "on", 3) == 0)
3999         player->SetMovement(MOVE_WATER_WALK);               // ON
4000     else if (strncmp(args, "off", 4) == 0)
4001         player->SetMovement(MOVE_LAND_WALK);                // OFF
4002     else
4003     {
4004         SendSysMessage(LANG_USE_BOL);
4005         return false;
4006     }
4007
4008     PSendSysMessage(LANG_YOU_SET_WATERWALK, args, player->GetName());
4009     if(needReportToTarget(player))
4010         ChatHandler(player).PSendSysMessage(LANG_YOUR_WATERWALK_SET, args, GetName());
4011     return true;
4012 }
4013
4014 bool ChatHandler::HandleNpcFollowCommand(const char* /*args*/)
4015 {
4016     Player *player = m_session->GetPlayer();
4017     Creature *creature = getSelectedCreature();
4018
4019     if(!creature)
4020     {
4021         PSendSysMessage(LANG_SELECT_CREATURE);
4022         SetSentErrorMessage(true);
4023         return false;
4024     }
4025
4026     // Follow player - Using pet's default dist and angle
4027     creature->GetMotionMaster()->MoveFollow(player, PET_FOLLOW_DIST, PET_FOLLOW_ANGLE);
4028
4029     PSendSysMessage(LANG_CREATURE_FOLLOW_YOU_NOW, creature->GetName());
4030     return true;
4031 }
4032
4033 bool ChatHandler::HandleNpcUnFollowCommand(const char* /*args*/)
4034 {
4035     Player *player = m_session->GetPlayer();
4036     Creature *creature = getSelectedCreature();
4037
4038     if(!creature)
4039     {
4040         PSendSysMessage(LANG_SELECT_CREATURE);
4041         SetSentErrorMessage(true);
4042         return false;
4043     }
4044
4045     if (creature->GetMotionMaster()->empty() ||
4046         creature->GetMotionMaster()->GetCurrentMovementGeneratorType ()!=TARGETED_MOTION_TYPE)
4047     {
4048         PSendSysMessage(LANG_CREATURE_NOT_FOLLOW_YOU);
4049         SetSentErrorMessage(true);
4050         return false;
4051     }
4052
4053     TargetedMovementGenerator<Creature> const* mgen
4054         = static_cast<TargetedMovementGenerator<Creature> const*>((creature->GetMotionMaster()->top()));
4055
4056     if(mgen->GetTarget()!=player)
4057     {
4058         PSendSysMessage(LANG_CREATURE_NOT_FOLLOW_YOU);
4059         SetSentErrorMessage(true);
4060         return false;
4061     }
4062
4063     // reset movement
4064     creature->GetMotionMaster()->MovementExpired(true);
4065
4066     PSendSysMessage(LANG_CREATURE_NOT_FOLLOW_YOU_NOW, creature->GetName());
4067     return true;
4068 }
4069
4070 bool ChatHandler::HandleNpcTameCommand(const char* /*args*/)
4071 {
4072     Creature *creatureTarget = getSelectedCreature ();
4073     if (!creatureTarget || creatureTarget->isPet ())
4074     {
4075         PSendSysMessage (LANG_SELECT_CREATURE);
4076         SetSentErrorMessage (true);
4077         return false;
4078     }
4079
4080     Player *player = m_session->GetPlayer ();
4081
4082     if(player->GetPetGUID ())
4083     {
4084         SendSysMessage (LANG_YOU_ALREADY_HAVE_PET);
4085         SetSentErrorMessage (true);
4086         return false;
4087     }
4088
4089     CreatureInfo const* cInfo = creatureTarget->GetCreatureInfo();
4090
4091     if (!cInfo->isTameable ())
4092     {
4093         PSendSysMessage (LANG_CREATURE_NON_TAMEABLE,cInfo->Entry);
4094         SetSentErrorMessage (true);
4095         return false;
4096     }
4097
4098     // Everything looks OK, create new pet
4099     Pet* pet = player->CreateTamedPetFrom (creatureTarget);
4100     if (!pet)
4101     {
4102         PSendSysMessage (LANG_CREATURE_NON_TAMEABLE,cInfo->Entry);
4103         SetSentErrorMessage (true);
4104         return false;
4105     }
4106
4107     // place pet before player
4108     float x,y,z;
4109     player->GetClosePoint (x,y,z,creatureTarget->GetObjectSize (),CONTACT_DISTANCE);
4110     pet->Relocate (x,y,z,M_PI-player->GetOrientation ());
4111
4112     // set pet to defensive mode by default (some classes can't control contolled pets in fact).
4113     pet->GetCharmInfo()->SetReactState(REACT_DEFENSIVE);
4114
4115     // prepare visual effect for levelup
4116     pet->SetUInt32Value(UNIT_FIELD_LEVEL,creatureTarget->getLevel()-1);
4117
4118     // add to world
4119     pet->GetMap()->Add((Creature*)pet);
4120
4121     // visual effect for levelup
4122     pet->SetUInt32Value(UNIT_FIELD_LEVEL,creatureTarget->getLevel());
4123
4124     // caster have pet now
4125     player->SetPet(pet);
4126
4127     pet->SavePetToDB(PET_SAVE_AS_CURRENT);
4128     player->PetSpellInitialize();
4129
4130     return true;
4131 }