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 = MapManager::Instance().GetMap(obj->GetMapId(),obj);
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         MapManager::Instance().GetMap(pCreature->GetMapId(),pCreature)->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 = MapManager::Instance().GetMap(obj->GetMapId(),obj);
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 = MapManager::Instance().GetMap(obj->GetMapId(),obj);
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 != "text1") && (show != "text2")
2363         && (show != "text3") && (show != "text4") && (show != "text5")
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                 //MapManager::Instance().GetMap(npcCreature->GetMapId())->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     WaypointMgr.SetNodeText(lowguid, point, show_str, arg_str);
2707
2708     Creature* npcCreature = ObjectAccessor::GetCreature(*m_session->GetPlayer(), MAKE_NEW_GUID(lowguid, data->id, HIGHGUID_UNIT));
2709     if(npcCreature)
2710     {
2711         npcCreature->SetDefaultMovementType(WAYPOINT_MOTION_TYPE);
2712         npcCreature->GetMotionMaster()->Initialize();
2713         if(npcCreature->isAlive())                          // dead creature will reset movement generator at respawn
2714         {
2715             npcCreature->setDeathState(JUST_DIED);
2716             npcCreature->Respawn();
2717         }
2718     }
2719     PSendSysMessage(LANG_WAYPOINT_CHANGED_NO, show_str);
2720
2721     return true;
2722 }
2723
2724 /**
2725  * .wp show info | on | off
2726  *
2727  * info -> User has selected a visual waypoint before
2728  *
2729  * info <GUID> <WPNUM> -> User did not select a visual waypoint and
2730  *                        provided the GUID of the NPC and the number of
2731  *                        the waypoint.
2732  *
2733  * on -> User has selected an NPC; all visual waypoints for this
2734  *       NPC are added to the world
2735  *
2736  * on <GUID> -> User did not select an NPC - instead the GUID of the
2737  *              NPC is provided. All visual waypoints for this NPC
2738  *              are added from the world.
2739  *
2740  * off -> User has selected an NPC; all visual waypoints for this
2741  *        NPC are removed from 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 removed from the world.
2746  *
2747  *
2748  */
2749 bool ChatHandler::HandleWpShowCommand(const char* args)
2750 {
2751     sLog.outDebug("DEBUG: HandleWpShowCommand");
2752
2753     if(!*args)
2754         return false;
2755
2756     // first arg: on, off, first, last
2757     char* show_str = strtok((char*)args, " ");
2758     if (!show_str)
2759     {
2760         return false;
2761     }
2762     // second arg: GUID (optional, if a creature is selected)
2763     char* guid_str = strtok((char*)NULL, " ");
2764     sLog.outDebug("DEBUG: HandleWpShowCommand: show_str: %s guid_str: %s", show_str, guid_str);
2765     //if (!guid_str) {
2766     //    return false;
2767     //}
2768
2769     // Did user provide a GUID
2770     // or did the user select a creature?
2771     // -> variable lowguid is filled with the GUID
2772     Creature* target = getSelectedCreature();
2773     // Did player provide a GUID?
2774     if (!guid_str)
2775     {
2776         sLog.outDebug("DEBUG: HandleWpShowCommand: !guid_str");
2777         // No GUID provided
2778         // -> Player must have selected a creature
2779
2780         if(!target)
2781         {
2782             SendSysMessage(LANG_SELECT_CREATURE);
2783             SetSentErrorMessage(true);
2784             return false;
2785         }
2786     }
2787     else
2788     {
2789         sLog.outDebug("DEBUG: HandleWpShowCommand: GUID provided");
2790         // GUID provided
2791         // Warn if player also selected a creature
2792         // -> Creature selection is ignored <-
2793         if(target)
2794         {
2795             SendSysMessage(LANG_WAYPOINT_CREATSELECTED);
2796         }
2797
2798         uint32 lowguid = atoi((char*)guid_str);
2799
2800         CreatureData const* data = objmgr.GetCreatureData(lowguid);
2801         if(!data)
2802         {
2803             PSendSysMessage(LANG_WAYPOINT_CREATNOTFOUND, lowguid);
2804             SetSentErrorMessage(true);
2805             return false;
2806         }
2807
2808         target = ObjectAccessor::GetCreature(*m_session->GetPlayer(),MAKE_NEW_GUID(lowguid,data->id,HIGHGUID_UNIT));
2809
2810         if(!target)
2811         {
2812             PSendSysMessage(LANG_WAYPOINT_CREATNOTFOUND, lowguid);
2813             SetSentErrorMessage(true);
2814             return false;
2815         }
2816     }
2817
2818     uint32 lowguid = target->GetDBTableGUIDLow();
2819
2820     std::string show = show_str;
2821     uint32 Maxpoint;
2822
2823     sLog.outDebug("DEBUG: HandleWpShowCommand: lowguid: %u show: %s", lowguid, show_str);
2824
2825     // Show info for the selected waypoint
2826     if(show == "info")
2827     {
2828         PSendSysMessage("DEBUG: wp info, GUID: %u", lowguid);
2829
2830         // Check if the user did specify a visual waypoint
2831         if( target->GetEntry() != VISUAL_WAYPOINT )
2832         {
2833             PSendSysMessage(LANG_WAYPOINT_VP_SELECT);
2834             SetSentErrorMessage(true);
2835             return false;
2836         }
2837
2838         //PSendSysMessage("wp on, GUID: %u", lowguid);
2839
2840         //pCreature->GetPositionX();
2841
2842         QueryResult *result =
2843             WorldDatabase.PQuery( "SELECT id, point, waittime, emote, spell, text1, text2, text3, text4, text5, model1, model2 FROM creature_movement WHERE wpguid = %u",
2844             target->GetGUIDLow() );
2845         if(!result)
2846         {
2847             // Since we compare float values, we have to deal with
2848             // some difficulties.
2849             // Here we search for all waypoints that only differ in one from 1 thousand
2850             // (0.001) - There is no other way to compare C++ floats with mySQL floats
2851             // See also: http://dev.mysql.com/doc/refman/5.0/en/problems-with-float.html
2852             const char* maxDIFF = "0.01";
2853             PSendSysMessage(LANG_WAYPOINT_NOTFOUNDSEARCH, target->GetGUID());
2854
2855             result = WorldDatabase.PQuery( "SELECT id, point, waittime, emote, spell, text1, text2, text3, text4, text5, model1, model2 FROM creature_movement WHERE (abs(position_x - %f) <= %s ) and (abs(position_y - %f) <= %s ) and (abs(position_z - %f) <= %s )",
2856                 target->GetPositionX(), maxDIFF, target->GetPositionY(), maxDIFF, target->GetPositionZ(), maxDIFF);
2857             if(!result)
2858             {
2859                 PSendSysMessage(LANG_WAYPOINT_NOTFOUNDDBPROBLEM, lowguid);
2860                 SetSentErrorMessage(true);
2861                 return false;
2862             }
2863         }
2864         do
2865         {
2866             Field *fields = result->Fetch();
2867             uint32 creGUID          = fields[0].GetUInt32();
2868             uint32 point            = fields[1].GetUInt32();
2869             int waittime            = fields[2].GetUInt32();
2870             uint32 emote            = fields[3].GetUInt32();
2871             uint32 spell            = fields[4].GetUInt32();
2872             const char * text1      = fields[5].GetString();
2873             const char * text2      = fields[6].GetString();
2874             const char * text3      = fields[7].GetString();
2875             const char * text4      = fields[8].GetString();
2876             const char * text5      = fields[9].GetString();
2877             uint32 model1           = fields[10].GetUInt32();
2878             uint32 model2           = fields[11].GetUInt32();
2879
2880             // Get the creature for which we read the waypoint
2881             Creature* wpCreature = ObjectAccessor::GetCreature(*m_session->GetPlayer(),MAKE_NEW_GUID(creGUID,VISUAL_WAYPOINT,HIGHGUID_UNIT));
2882
2883             PSendSysMessage(LANG_WAYPOINT_INFO_TITLE, point, (wpCreature ? wpCreature->GetName() : "<not found>"), creGUID);
2884             PSendSysMessage(LANG_WAYPOINT_INFO_WAITTIME, waittime);
2885             PSendSysMessage(LANG_WAYPOINT_INFO_MODEL, 1, model1);
2886             PSendSysMessage(LANG_WAYPOINT_INFO_MODEL, 2, model2);
2887             PSendSysMessage(LANG_WAYPOINT_INFO_EMOTE, emote);
2888             PSendSysMessage(LANG_WAYPOINT_INFO_SPELL, spell);
2889             PSendSysMessage(LANG_WAYPOINT_INFO_TEXT, 1, text1);
2890             PSendSysMessage(LANG_WAYPOINT_INFO_TEXT, 2, text2);
2891             PSendSysMessage(LANG_WAYPOINT_INFO_TEXT, 3, text3);
2892             PSendSysMessage(LANG_WAYPOINT_INFO_TEXT, 4, text4);
2893             PSendSysMessage(LANG_WAYPOINT_INFO_TEXT, 5, text5);
2894
2895         }while( result->NextRow() );
2896         // Cleanup memory
2897         delete result;
2898         return true;
2899     }
2900
2901     if(show == "on")
2902     {
2903         PSendSysMessage("DEBUG: wp on, GUID: %u", lowguid);
2904
2905         QueryResult *result = WorldDatabase.PQuery( "SELECT point, position_x,position_y,position_z FROM creature_movement WHERE id = '%u'",lowguid);
2906         if(!result)
2907         {
2908             PSendSysMessage(LANG_WAYPOINT_NOTFOUND, lowguid);
2909             SetSentErrorMessage(true);
2910             return false;
2911         }
2912         // Delete all visuals for this NPC
2913         QueryResult *result2 = WorldDatabase.PQuery( "SELECT wpguid FROM creature_movement WHERE id = '%u' and wpguid <> 0", lowguid);
2914         if(result2)
2915         {
2916             bool hasError = false;
2917             do
2918             {
2919                 Field *fields = result2->Fetch();
2920                 uint32 wpguid = fields[0].GetUInt32();
2921                 Creature* pCreature = ObjectAccessor::GetCreature(*m_session->GetPlayer(),MAKE_NEW_GUID(wpguid,VISUAL_WAYPOINT,HIGHGUID_UNIT));
2922
2923                 if(!pCreature)
2924                 {
2925                     PSendSysMessage(LANG_WAYPOINT_NOTREMOVED, wpguid);
2926                     hasError = true;
2927                     WorldDatabase.PExecuteLog("DELETE FROM creature WHERE guid = '%u'", wpguid);
2928                 }
2929                 else
2930                 {
2931                     pCreature->DeleteFromDB();
2932                     pCreature->CleanupsBeforeDelete();
2933                     pCreature->AddObjectToRemoveList();
2934                 }
2935
2936             }while( result2->NextRow() );
2937             delete result2;
2938             if( hasError )
2939             {
2940                 PSendSysMessage(LANG_WAYPOINT_TOOFAR1);
2941                 PSendSysMessage(LANG_WAYPOINT_TOOFAR2);
2942                 PSendSysMessage(LANG_WAYPOINT_TOOFAR3);
2943             }
2944         }
2945
2946         do
2947         {
2948             Field *fields = result->Fetch();
2949             uint32 point    = fields[0].GetUInt32();
2950             float x         = fields[1].GetFloat();
2951             float y         = fields[2].GetFloat();
2952             float z         = fields[3].GetFloat();
2953
2954             uint32 id = VISUAL_WAYPOINT;
2955
2956             Player *chr = m_session->GetPlayer();
2957             Map *map = chr->GetMap();
2958             float o = chr->GetOrientation();
2959
2960             Creature* wpCreature = new Creature;
2961             if (!wpCreature->Create(objmgr.GenerateLowGuid(HIGHGUID_UNIT), map, id, 0))
2962             {
2963                 PSendSysMessage(LANG_WAYPOINT_VP_NOTCREATED, id);
2964                 delete wpCreature;
2965                 delete result;
2966                 return false;
2967             }
2968
2969             wpCreature->Relocate(x, y, z, o);
2970
2971             if(!wpCreature->IsPositionValid())
2972             {
2973                 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());
2974                 delete wpCreature;
2975                 delete result;
2976                 return false;
2977             }
2978
2979             wpCreature->SetVisibility(VISIBILITY_OFF);
2980             sLog.outDebug("DEBUG: UPDATE creature_movement SET wpguid = '%u");
2981             // set "wpguid" column to the visual waypoint
2982             WorldDatabase.PExecuteLog("UPDATE creature_movement SET wpguid = '%u' WHERE id = '%u' and point = '%u'", wpCreature->GetGUIDLow(), lowguid, point);
2983
2984             wpCreature->SaveToDB(map->GetId(), (1 << map->GetSpawnMode()));
2985             // To call _LoadGoods(); _LoadQuests(); CreateTrainerSpells();
2986             wpCreature->LoadFromDB(wpCreature->GetDBTableGUIDLow(),map);
2987             map->Add(wpCreature);
2988             //MapManager::Instance().GetMap(wpCreature->GetMapId())->Add(wpCreature);
2989         }while( result->NextRow() );
2990
2991         // Cleanup memory
2992         delete result;
2993         return true;
2994     }
2995
2996     if(show == "first")
2997     {
2998         PSendSysMessage("DEBUG: wp first, GUID: %u", lowguid);
2999
3000         QueryResult *result = WorldDatabase.PQuery( "SELECT position_x,position_y,position_z FROM creature_movement WHERE point='1' AND id = '%u'",lowguid);
3001         if(!result)
3002         {
3003             PSendSysMessage(LANG_WAYPOINT_NOTFOUND, lowguid);
3004             SetSentErrorMessage(true);
3005             return false;
3006         }
3007
3008         Field *fields = result->Fetch();
3009         float x         = fields[0].GetFloat();
3010         float y         = fields[1].GetFloat();
3011         float z         = fields[2].GetFloat();
3012         uint32 id = VISUAL_WAYPOINT;
3013
3014         Player *chr = m_session->GetPlayer();
3015         float o = chr->GetOrientation();
3016         Map *map = chr->GetMap();
3017
3018         Creature* pCreature = new Creature;
3019         if (!pCreature->Create(objmgr.GenerateLowGuid(HIGHGUID_UNIT),map, id, 0))
3020         {
3021             PSendSysMessage(LANG_WAYPOINT_VP_NOTCREATED, id);
3022             delete pCreature;
3023             delete result;
3024             return false;
3025         }
3026
3027         pCreature->Relocate(x, y, z, o);
3028
3029         if(!pCreature->IsPositionValid())
3030         {
3031             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());
3032             delete pCreature;
3033             delete result;
3034             return false;
3035         }
3036
3037         pCreature->SaveToDB(map->GetId(), (1 << map->GetSpawnMode()));
3038         pCreature->LoadFromDB(pCreature->GetDBTableGUIDLow(), map);
3039         map->Add(pCreature);
3040         //player->PlayerTalkClass->SendPointOfInterest(x, y, 6, 6, 0, "First Waypoint");
3041
3042         // Cleanup memory
3043         delete result;
3044         return true;
3045     }
3046
3047     if(show == "last")
3048     {
3049         PSendSysMessage("DEBUG: wp last, GUID: %u", lowguid);
3050
3051         QueryResult *result = WorldDatabase.PQuery( "SELECT MAX(point) FROM creature_movement WHERE id = '%u'",lowguid);
3052         if( result )
3053         {
3054             Maxpoint = (*result)[0].GetUInt32();
3055
3056             delete result;
3057         }
3058         else
3059             Maxpoint = 0;
3060
3061         result = WorldDatabase.PQuery( "SELECT position_x,position_y,position_z FROM creature_movement WHERE point ='%u' AND id = '%u'",Maxpoint, lowguid);
3062         if(!result)
3063         {
3064             PSendSysMessage(LANG_WAYPOINT_NOTFOUNDLAST, lowguid);
3065             SetSentErrorMessage(true);
3066             return false;
3067         }
3068         Field *fields = result->Fetch();
3069         float x         = fields[0].GetFloat();
3070         float y         = fields[1].GetFloat();
3071         float z         = fields[2].GetFloat();
3072         uint32 id = VISUAL_WAYPOINT;
3073
3074         Player *chr = m_session->GetPlayer();
3075         float o = chr->GetOrientation();
3076         Map *map = chr->GetMap();
3077
3078         Creature* pCreature = new Creature;
3079         if (!pCreature->Create(objmgr.GenerateLowGuid(HIGHGUID_UNIT), map, id, 0))
3080         {
3081             PSendSysMessage(LANG_WAYPOINT_NOTCREATED, id);
3082             delete pCreature;
3083             delete result;
3084             return false;
3085         }
3086
3087         pCreature->Relocate(x, y, z, o);
3088
3089         if(!pCreature->IsPositionValid())
3090         {
3091             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());
3092             delete pCreature;
3093             delete result;
3094             return false;
3095         }
3096
3097         pCreature->SaveToDB(map->GetId(), (1 << map->GetSpawnMode()));
3098         pCreature->LoadFromDB(pCreature->GetDBTableGUIDLow(), map);
3099         map->Add(pCreature);
3100         //player->PlayerTalkClass->SendPointOfInterest(x, y, 6, 6, 0, "Last Waypoint");
3101         // Cleanup memory
3102         delete result;
3103         return true;
3104     }
3105
3106     if(show == "off")
3107     {
3108         QueryResult *result = WorldDatabase.PQuery("SELECT guid FROM creature WHERE id = '%d'", VISUAL_WAYPOINT);
3109         if(!result)
3110         {
3111             SendSysMessage(LANG_WAYPOINT_VP_NOTFOUND);
3112             SetSentErrorMessage(true);
3113             return false;
3114         }
3115         bool hasError = false;
3116         do
3117         {
3118             Field *fields = result->Fetch();
3119             uint32 guid = fields[0].GetUInt32();
3120             Creature* pCreature = ObjectAccessor::GetCreature(*m_session->GetPlayer(),MAKE_NEW_GUID(guid,VISUAL_WAYPOINT,HIGHGUID_UNIT));
3121
3122             //Creature* pCreature = ObjectAccessor::GetCreature(*m_session->GetPlayer(), guid);
3123
3124             if(!pCreature)
3125             {
3126                 PSendSysMessage(LANG_WAYPOINT_NOTREMOVED, guid);
3127                 hasError = true;
3128                 WorldDatabase.PExecuteLog("DELETE FROM creature WHERE guid = '%u'", guid);
3129             }
3130             else
3131             {
3132                 pCreature->DeleteFromDB();
3133                 pCreature->CleanupsBeforeDelete();
3134                 pCreature->AddObjectToRemoveList();
3135             }
3136         }while(result->NextRow());
3137         // set "wpguid" column to "empty" - no visual waypoint spawned
3138         WorldDatabase.PExecuteLog("UPDATE creature_movement SET wpguid = '0'");
3139
3140         if( hasError )
3141         {
3142             PSendSysMessage(LANG_WAYPOINT_TOOFAR1);
3143             PSendSysMessage(LANG_WAYPOINT_TOOFAR2);
3144             PSendSysMessage(LANG_WAYPOINT_TOOFAR3);
3145         }
3146
3147         SendSysMessage(LANG_WAYPOINT_VP_ALLREMOVED);
3148         // Cleanup memory
3149         delete result;
3150
3151         return true;
3152     }
3153
3154     PSendSysMessage("DEBUG: wpshow - no valid command found");
3155
3156     return true;
3157 }                                                           // HandleWpShowCommand
3158
3159 bool ChatHandler::HandleWpExportCommand(const char *args)
3160 {
3161     if(!*args)
3162         return false;
3163
3164     // Next arg is: <GUID> <ARGUMENT>
3165
3166     // Did user provide a GUID
3167     // or did the user select a creature?
3168     // -> variable lowguid is filled with the GUID of the NPC
3169     uint32 lowguid = 0;
3170     Creature* target = getSelectedCreature();
3171     char* arg_str = NULL;
3172     if (target)
3173     {
3174         if (target->GetEntry() != VISUAL_WAYPOINT)
3175             lowguid = target->GetGUIDLow();
3176         else
3177         {
3178             QueryResult *result = WorldDatabase.PQuery( "SELECT id FROM creature_movement WHERE wpguid = %u LIMIT 1", target->GetGUIDLow() );
3179             if (!result)
3180             {
3181                 PSendSysMessage(LANG_WAYPOINT_NOTFOUNDDBPROBLEM, target->GetGUIDLow());
3182                 return true;
3183             }
3184             Field *fields = result->Fetch();
3185             lowguid = fields[0].GetUInt32();;
3186             delete result;
3187         }
3188
3189         arg_str = strtok((char*)args, " ");
3190     }
3191     else
3192     {
3193         // user provided <GUID>
3194         char* guid_str = strtok((char*)args, " ");
3195         if( !guid_str )
3196         {
3197             SendSysMessage(LANG_WAYPOINT_NOGUID);
3198             return false;
3199         }
3200         lowguid = atoi((char*)guid_str);
3201
3202         arg_str = strtok((char*)NULL, " ");
3203     }
3204
3205     if( !arg_str)
3206     {
3207         PSendSysMessage(LANG_WAYPOINT_ARGUMENTREQ, "export");
3208         return false;
3209     }
3210
3211     PSendSysMessage("DEBUG: wp export, GUID: %u", lowguid);
3212
3213     QueryResult *result = WorldDatabase.PQuery(
3214     //          0      1           2           3           4            5       6       7         8      9      10     11     12     13     14     15
3215         "SELECT point, position_x, position_y, position_z, orientation, model1, model2, waittime, emote, spell, text1, text2, text3, text4, text5, id FROM creature_movement WHERE id = '%u' ORDER BY point", lowguid );
3216
3217     if (!result)
3218     {
3219         PSendSysMessage(LANG_WAYPOINT_NOTHINGTOEXPORT);
3220         SetSentErrorMessage(true);
3221         return false;
3222     }
3223
3224     std::ofstream outfile;
3225     outfile.open (arg_str);
3226
3227     do
3228     {
3229         Field *fields = result->Fetch();
3230
3231         outfile << "INSERT INTO creature_movement ";
3232         outfile << "( id, point, position_x, position_y, position_z, orientation, model1, model2, waittime, emote, spell, text1, text2, text3, text4, text5 ) VALUES ";
3233
3234         outfile << "( ";
3235         outfile << fields[15].GetUInt32();                  // id
3236         outfile << ", ";
3237         outfile << fields[0].GetUInt32();                   // point
3238         outfile << ", ";
3239         outfile << fields[1].GetFloat();                    // position_x
3240         outfile << ", ";
3241         outfile << fields[2].GetFloat();                    // position_y
3242         outfile << ", ";
3243         outfile << fields[3].GetUInt32();                   // position_z
3244         outfile << ", ";
3245         outfile << fields[4].GetUInt32();                   // orientation
3246         outfile << ", ";
3247         outfile << fields[5].GetUInt32();                   // model1
3248         outfile << ", ";
3249         outfile << fields[6].GetUInt32();                   // model2
3250         outfile << ", ";
3251         outfile << fields[7].GetUInt16();                   // waittime
3252         outfile << ", ";
3253         outfile << fields[8].GetUInt32();                   // emote
3254         outfile << ", ";
3255         outfile << fields[9].GetUInt32();                   // spell
3256         outfile << ", ";
3257         const char *tmpChar = fields[10].GetString();
3258         if( !tmpChar )
3259         {
3260             outfile << "NULL";                              // text1
3261         }
3262         else
3263         {
3264             outfile << "'";
3265             outfile << tmpChar;                             // text1
3266             outfile << "'";
3267         }
3268         outfile << ", ";
3269         tmpChar = fields[11].GetString();
3270         if( !tmpChar )
3271         {
3272             outfile << "NULL";                              // text2
3273         }
3274         else
3275         {
3276             outfile << "'";
3277             outfile << tmpChar;                             // text2
3278             outfile << "'";
3279         }
3280         outfile << ", ";
3281         tmpChar = fields[12].GetString();
3282         if( !tmpChar )
3283         {
3284             outfile << "NULL";                              // text3
3285         }
3286         else
3287         {
3288             outfile << "'";
3289             outfile << tmpChar;                             // text3
3290             outfile << "'";
3291         }
3292         outfile << ", ";
3293         tmpChar = fields[13].GetString();
3294         if( !tmpChar )
3295         {
3296             outfile << "NULL";                              // text4
3297         }
3298         else
3299         {
3300             outfile << "'";
3301             outfile << tmpChar;                             // text4
3302             outfile << "'";
3303         }
3304         outfile << ", ";
3305         tmpChar = fields[14].GetString();
3306         if( !tmpChar )
3307         {
3308             outfile << "NULL";                              // text5
3309         }
3310         else
3311         {
3312             outfile << "'";
3313             outfile << tmpChar;                             // text5
3314             outfile << "'";
3315         }
3316         outfile << ");\n ";
3317
3318     } while( result->NextRow() );
3319     delete result;
3320
3321     PSendSysMessage(LANG_WAYPOINT_EXPORTED);
3322     outfile.close();
3323
3324     return true;
3325 }
3326
3327 bool ChatHandler::HandleWpImportCommand(const char *args)
3328 {
3329     if(!*args)
3330         return false;
3331
3332     char* arg_str = strtok((char*)args, " ");
3333     if (!arg_str)
3334         return false;
3335
3336     std::string line;
3337     std::ifstream infile (arg_str);
3338     if (infile.is_open())
3339     {
3340         while (! infile.eof() )
3341         {
3342             getline (infile,line);
3343             //cout << line << endl;
3344             QueryResult *result = WorldDatabase.Query(line.c_str());
3345             delete result;
3346         }
3347         infile.close();
3348     }
3349     PSendSysMessage(LANG_WAYPOINT_IMPORTED);
3350
3351     return true;
3352 }
3353
3354 //rename characters
3355 bool ChatHandler::HandleRenameCommand(const char* args)
3356 {
3357     Player* target = NULL;
3358     uint64 targetGUID = 0;
3359     std::string oldname;
3360
3361     char* px = strtok((char*)args, " ");
3362
3363     if(px)
3364     {
3365         oldname = px;
3366
3367         if(!normalizePlayerName(oldname))
3368         {
3369             SendSysMessage(LANG_PLAYER_NOT_FOUND);
3370             SetSentErrorMessage(true);
3371             return false;
3372         }
3373
3374         target = objmgr.GetPlayer(oldname.c_str());
3375
3376         if (!target)
3377             targetGUID = objmgr.GetPlayerGUIDByName(oldname);
3378     }
3379
3380     if(!target && !targetGUID)
3381     {
3382         target = getSelectedPlayer();
3383     }
3384
3385     if(!target && !targetGUID)
3386     {
3387         SendSysMessage(LANG_PLAYER_NOT_FOUND);
3388         SetSentErrorMessage(true);
3389         return false;
3390     }
3391
3392     if(target)
3393     {
3394         PSendSysMessage(LANG_RENAME_PLAYER, target->GetName());
3395         target->SetAtLoginFlag(AT_LOGIN_RENAME);
3396         CharacterDatabase.PExecute("UPDATE characters SET at_login = at_login | '1' WHERE guid = '%u'", target->GetGUIDLow());
3397     }
3398     else
3399     {
3400         PSendSysMessage(LANG_RENAME_PLAYER_GUID, oldname.c_str(), GUID_LOPART(targetGUID));
3401         CharacterDatabase.PExecute("UPDATE characters SET at_login = at_login | '1' WHERE guid = '%u'", GUID_LOPART(targetGUID));
3402     }
3403
3404     return true;
3405 }
3406
3407 //spawn go
3408 bool ChatHandler::HandleGameObjectCommand(const char* args)
3409 {
3410     if (!*args)
3411         return false;
3412
3413     char* pParam1 = strtok((char*)args, " ");
3414     if (!pParam1)
3415         return false;
3416
3417     uint32 id = atoi((char*)pParam1);
3418     if(!id)
3419         return false;
3420
3421     char* spawntimeSecs = strtok(NULL, " ");
3422
3423     const GameObjectInfo *goI = objmgr.GetGameObjectInfo(id);
3424
3425     if (!goI)
3426     {
3427         PSendSysMessage(LANG_GAMEOBJECT_NOT_EXIST,id);
3428         SetSentErrorMessage(true);
3429         return false;
3430     }
3431
3432     Player *chr = m_session->GetPlayer();
3433     float x = float(chr->GetPositionX());
3434     float y = float(chr->GetPositionY());
3435     float z = float(chr->GetPositionZ());
3436     float o = float(chr->GetOrientation());
3437     Map *map = chr->GetMap();
3438
3439     float rot2 = sin(o/2);
3440     float rot3 = cos(o/2);
3441
3442     GameObject* pGameObj = new GameObject;
3443     uint32 db_lowGUID = objmgr.GenerateLowGuid(HIGHGUID_GAMEOBJECT);
3444
3445     if(!pGameObj->Create(db_lowGUID, goI->id, map, x, y, z, o, 0, 0, rot2, rot3, 0, 1))
3446     {
3447         delete pGameObj;
3448         return false;
3449     }
3450
3451     if( spawntimeSecs )
3452     {
3453         uint32 value = atoi((char*)spawntimeSecs);
3454         pGameObj->SetRespawnTime(value);
3455         //sLog.outDebug("*** spawntimeSecs: %d", value);
3456     }
3457
3458     // fill the gameobject data and save to the db
3459     pGameObj->SaveToDB(map->GetId(), (1 << map->GetSpawnMode()));
3460
3461     // this will generate a new guid if the object is in an instance
3462     if(!pGameObj->LoadFromDB(db_lowGUID, map))
3463     {
3464         delete pGameObj;
3465         return false;
3466     }
3467
3468     sLog.outDebug(GetMangosString(LANG_GAMEOBJECT_CURRENT), goI->name, db_lowGUID, x, y, z, o);
3469
3470     map->Add(pGameObj);
3471
3472     // TODO: is it really necessary to add both the real and DB table guid here ?
3473     objmgr.AddGameobjectToGrid(db_lowGUID, objmgr.GetGOData(db_lowGUID));
3474
3475     PSendSysMessage(LANG_GAMEOBJECT_ADD,id,goI->name,db_lowGUID,x,y,z);
3476     return true;
3477 }
3478
3479 //show animation
3480 bool ChatHandler::HandleAnimCommand(const char* args)
3481 {
3482     if (!*args)
3483         return false;
3484
3485     uint32 anim_id = atoi((char*)args);
3486     m_session->GetPlayer()->HandleEmoteCommand(anim_id);
3487     return true;
3488 }
3489
3490 //change standstate
3491 bool ChatHandler::HandleStandStateCommand(const char* args)
3492 {
3493     if (!*args)
3494         return false;
3495
3496     uint32 anim_id = atoi((char*)args);
3497     m_session->GetPlayer( )->SetUInt32Value( UNIT_NPC_EMOTESTATE , anim_id );
3498
3499     return true;
3500 }
3501
3502 bool ChatHandler::HandleAddHonorCommand(const char* args)
3503 {
3504     if (!*args)
3505         return false;
3506
3507     Player *target = getSelectedPlayer();
3508     if(!target)
3509     {
3510         SendSysMessage(LANG_PLAYER_NOT_FOUND);
3511         SetSentErrorMessage(true);
3512         return false;
3513     }
3514
3515     uint32 amount = (uint32)atoi(args);
3516     target->RewardHonor(NULL, 1, amount);
3517     return true;
3518 }
3519
3520 bool ChatHandler::HandleHonorAddKillCommand(const char* /*args*/)
3521 {
3522     Unit *target = getSelectedUnit();
3523     if(!target)
3524     {
3525         SendSysMessage(LANG_PLAYER_NOT_FOUND);
3526         SetSentErrorMessage(true);
3527         return false;
3528     }
3529
3530     m_session->GetPlayer()->RewardHonor(target, 1);
3531     return true;
3532 }
3533
3534 bool ChatHandler::HandleUpdateHonorFieldsCommand(const char* /*args*/)
3535 {
3536     Player *target = getSelectedPlayer();
3537     if(!target)
3538     {
3539         SendSysMessage(LANG_PLAYER_NOT_FOUND);
3540         SetSentErrorMessage(true);
3541         return false;
3542     }
3543
3544     target->UpdateHonorFields();
3545     return true;
3546 }
3547
3548 bool ChatHandler::HandleLookupEventCommand(const char* args)
3549 {
3550     if(!*args)
3551         return false;
3552
3553     std::string namepart = args;
3554     std::wstring wnamepart;
3555
3556     // converting string that we try to find to lower case
3557     if(!Utf8toWStr(namepart,wnamepart))
3558         return false;
3559
3560     wstrToLower(wnamepart);
3561
3562     uint32 counter = 0;
3563
3564     GameEvent::GameEventDataMap const& events = gameeventmgr.GetEventMap();
3565     GameEvent::ActiveEvents const& activeEvents = gameeventmgr.GetActiveEventList();
3566
3567     for(uint32 id = 0; id < events.size(); ++id )
3568     {
3569         GameEventData const& eventData = events[id];
3570
3571         std::string descr = eventData.description;
3572         if(descr.empty())
3573             continue;
3574
3575         if (Utf8FitTo(descr, wnamepart))
3576         {
3577             char const* active = activeEvents.find(id) != activeEvents.end() ? GetMangosString(LANG_ACTIVE) : "";
3578
3579             if(m_session)
3580                 PSendSysMessage(LANG_EVENT_ENTRY_LIST_CHAT,id,id,eventData.description.c_str(),active );
3581             else
3582                 PSendSysMessage(LANG_EVENT_ENTRY_LIST_CONSOLE,id,eventData.description.c_str(),active );
3583
3584             ++counter;
3585         }
3586     }
3587
3588     if (counter==0)
3589         SendSysMessage(LANG_NOEVENTFOUND);
3590
3591     return true;
3592 }
3593
3594 bool ChatHandler::HandleEventActiveListCommand(const char* /*args*/)
3595 {
3596     uint32 counter = 0;
3597
3598     GameEvent::GameEventDataMap const& events = gameeventmgr.GetEventMap();
3599     GameEvent::ActiveEvents const& activeEvents = gameeventmgr.GetActiveEventList();
3600
3601     char const* active = GetMangosString(LANG_ACTIVE);
3602
3603     for(GameEvent::ActiveEvents::const_iterator itr = activeEvents.begin(); itr != activeEvents.end(); ++itr )
3604     {
3605         uint32 event_id = *itr;
3606         GameEventData const& eventData = events[event_id];
3607
3608         if(m_session)
3609             PSendSysMessage(LANG_EVENT_ENTRY_LIST_CHAT,event_id,event_id,eventData.description.c_str(),active );
3610         else
3611             PSendSysMessage(LANG_EVENT_ENTRY_LIST_CONSOLE,event_id,eventData.description.c_str(),active );
3612
3613         ++counter;
3614     }
3615
3616     if (counter==0)
3617         SendSysMessage(LANG_NOEVENTFOUND);
3618
3619     return true;
3620 }
3621
3622 bool ChatHandler::HandleEventInfoCommand(const char* args)
3623 {
3624     if(!*args)
3625         return false;
3626
3627     // id or [name] Shift-click form |color|Hgameevent:id|h[name]|h|r
3628     char* cId = extractKeyFromLink((char*)args,"Hgameevent");
3629     if(!cId)
3630         return false;
3631
3632     uint32 event_id = atoi(cId);
3633
3634     GameEvent::GameEventDataMap const& events = gameeventmgr.GetEventMap();
3635
3636     if(event_id >=events.size())
3637     {
3638         SendSysMessage(LANG_EVENT_NOT_EXIST);
3639         SetSentErrorMessage(true);
3640         return false;
3641     }
3642
3643     GameEventData const& eventData = events[event_id];
3644     if(!eventData.isValid())
3645     {
3646         SendSysMessage(LANG_EVENT_NOT_EXIST);
3647         SetSentErrorMessage(true);
3648         return false;
3649     }
3650
3651     GameEvent::ActiveEvents const& activeEvents = gameeventmgr.GetActiveEventList();
3652     bool active = activeEvents.find(event_id) != activeEvents.end();
3653     char const* activeStr = active ? GetMangosString(LANG_ACTIVE) : "";
3654
3655     std::string startTimeStr = TimeToTimestampStr(eventData.start);
3656     std::string endTimeStr = TimeToTimestampStr(eventData.end);
3657
3658     uint32 delay = gameeventmgr.NextCheck(event_id);
3659     time_t nextTime = time(NULL)+delay;
3660     std::string nextStr = nextTime >= eventData.start && nextTime < eventData.end ? TimeToTimestampStr(time(NULL)+delay) : "-";
3661
3662     std::string occurenceStr = secsToTimeString(eventData.occurence * MINUTE);
3663     std::string lengthStr = secsToTimeString(eventData.length * MINUTE);
3664
3665     PSendSysMessage(LANG_EVENT_INFO,event_id,eventData.description.c_str(),activeStr,
3666         startTimeStr.c_str(),endTimeStr.c_str(),occurenceStr.c_str(),lengthStr.c_str(),
3667         nextStr.c_str());
3668     return true;
3669 }
3670
3671 bool ChatHandler::HandleEventStartCommand(const char* args)
3672 {
3673     if(!*args)
3674         return false;
3675
3676     // id or [name] Shift-click form |color|Hgameevent:id|h[name]|h|r
3677     char* cId = extractKeyFromLink((char*)args,"Hgameevent");
3678     if(!cId)
3679         return false;
3680
3681     int32 event_id = atoi(cId);
3682
3683     GameEvent::GameEventDataMap const& events = gameeventmgr.GetEventMap();
3684
3685     if(event_id < 1 || event_id >=events.size())
3686     {
3687         SendSysMessage(LANG_EVENT_NOT_EXIST);
3688         SetSentErrorMessage(true);
3689         return false;
3690     }
3691
3692     GameEventData const& eventData = events[event_id];
3693     if(!eventData.isValid())
3694     {
3695         SendSysMessage(LANG_EVENT_NOT_EXIST);
3696         SetSentErrorMessage(true);
3697         return false;
3698     }
3699
3700     GameEvent::ActiveEvents const& activeEvents = gameeventmgr.GetActiveEventList();
3701     if(activeEvents.find(event_id) != activeEvents.end())
3702     {
3703         PSendSysMessage(LANG_EVENT_ALREADY_ACTIVE,event_id);
3704         SetSentErrorMessage(true);
3705         return false;
3706     }
3707
3708     gameeventmgr.StartEvent(event_id,true);
3709     return true;
3710 }
3711
3712 bool ChatHandler::HandleEventStopCommand(const char* args)
3713 {
3714     if(!*args)
3715         return false;
3716
3717     // id or [name] Shift-click form |color|Hgameevent:id|h[name]|h|r
3718     char* cId = extractKeyFromLink((char*)args,"Hgameevent");
3719     if(!cId)
3720         return false;
3721
3722     int32 event_id = atoi(cId);
3723
3724     GameEvent::GameEventDataMap const& events = gameeventmgr.GetEventMap();
3725
3726     if(event_id < 1 || event_id >=events.size())
3727     {
3728         SendSysMessage(LANG_EVENT_NOT_EXIST);
3729         SetSentErrorMessage(true);
3730         return false;
3731     }
3732
3733     GameEventData const& eventData = events[event_id];
3734     if(!eventData.isValid())
3735     {
3736         SendSysMessage(LANG_EVENT_NOT_EXIST);
3737         SetSentErrorMessage(true);
3738         return false;
3739     }
3740
3741     GameEvent::ActiveEvents const& activeEvents = gameeventmgr.GetActiveEventList();
3742
3743     if(activeEvents.find(event_id) == activeEvents.end())
3744     {
3745         PSendSysMessage(LANG_EVENT_NOT_ACTIVE,event_id);
3746         SetSentErrorMessage(true);
3747         return false;
3748     }
3749
3750     gameeventmgr.StopEvent(event_id,true);
3751     return true;
3752 }
3753
3754 bool ChatHandler::HandleCombatStopCommand(const char* args)
3755 {
3756     Player *player;
3757
3758     if(*args)
3759     {
3760         std::string playername = args;
3761
3762         if(!normalizePlayerName(playername))
3763         {
3764             SendSysMessage(LANG_PLAYER_NOT_FOUND);
3765             SetSentErrorMessage(true);
3766             return false;
3767         }
3768
3769         player = objmgr.GetPlayer(playername.c_str());
3770
3771         if(!player)
3772         {
3773             SendSysMessage(LANG_PLAYER_NOT_FOUND);
3774             SetSentErrorMessage(true);
3775             return false;
3776         }
3777     }
3778     else
3779     {
3780         player = getSelectedPlayer();
3781
3782         if (!player)
3783             player = m_session->GetPlayer();
3784     }
3785
3786     player->CombatStop();
3787     player->getHostilRefManager().deleteReferences();
3788     return true;
3789 }
3790
3791 bool ChatHandler::HandleLearnAllCraftsCommand(const char* /*args*/)
3792 {
3793     uint32 classmask = m_session->GetPlayer()->getClassMask();
3794
3795     for (uint32 i = 0; i < sSkillLineStore.GetNumRows(); ++i)
3796     {
3797         SkillLineEntry const *skillInfo = sSkillLineStore.LookupEntry(i);
3798         if( !skillInfo )
3799             continue;
3800
3801         if( skillInfo->categoryId == SKILL_CATEGORY_PROFESSION || skillInfo->categoryId == SKILL_CATEGORY_SECONDARY )
3802         {
3803             for (uint32 j = 0; j < sSkillLineAbilityStore.GetNumRows(); ++j)
3804             {
3805                 SkillLineAbilityEntry const *skillLine = sSkillLineAbilityStore.LookupEntry(j);
3806                 if( !skillLine )
3807                     continue;
3808
3809                 // skip racial skills
3810                 if( skillLine->racemask != 0 )
3811                     continue;
3812
3813                 // skip wrong class skills
3814                 if( skillLine->classmask && (skillLine->classmask & classmask) == 0)
3815                     continue;
3816
3817                 if( skillLine->skillId != i || skillLine->forward_spellid )
3818                     continue;
3819
3820                 SpellEntry const* spellInfo = sSpellStore.LookupEntry(skillLine->spellId);
3821                 if(!spellInfo || !SpellMgr::IsSpellValid(spellInfo,m_session->GetPlayer(),false))
3822                     continue;
3823
3824                 m_session->GetPlayer()->learnSpell(skillLine->spellId);
3825             }
3826         }
3827     }
3828
3829     SendSysMessage(LANG_COMMAND_LEARN_ALL_CRAFT);
3830     return true;
3831 }
3832
3833 bool ChatHandler::HandleLearnAllRecipesCommand(const char* args)
3834 {
3835     //  Learns all recipes of specified profession and sets skill to max
3836     //  Example: .learn all_recipes enchanting
3837
3838     Player* target = getSelectedPlayer();
3839     if( !target )
3840     {
3841         SendSysMessage(LANG_PLAYER_NOT_FOUND);
3842         return false;
3843     }
3844
3845     if(!*args)
3846         return false;
3847
3848     std::wstring wnamepart;
3849
3850     if(!Utf8toWStr(args,wnamepart))
3851         return false;
3852
3853     // converting string that we try to find to lower case
3854     wstrToLower( wnamepart );
3855
3856     uint32 classmask = m_session->GetPlayer()->getClassMask();
3857
3858     for (uint32 i = 0; i < sSkillLineStore.GetNumRows(); ++i)
3859     {
3860         SkillLineEntry const *skillInfo = sSkillLineStore.LookupEntry(i);
3861         if( !skillInfo )
3862             continue;
3863
3864         if( skillInfo->categoryId != SKILL_CATEGORY_PROFESSION &&
3865             skillInfo->categoryId != SKILL_CATEGORY_SECONDARY )
3866             continue;
3867
3868         int loc = m_session->GetSessionDbcLocale();
3869         std::string name = skillInfo->name[loc];
3870
3871         if(Utf8FitTo(name, wnamepart))
3872         {
3873             for (uint32 j = 0; j < sSkillLineAbilityStore.GetNumRows(); ++j)
3874             {
3875                 SkillLineAbilityEntry const *skillLine = sSkillLineAbilityStore.LookupEntry(j);
3876                 if( !skillLine )
3877                     continue;
3878
3879                 if( skillLine->skillId != i || skillLine->forward_spellid )
3880                     continue;
3881
3882                 // skip racial skills
3883                 if( skillLine->racemask != 0 )
3884                     continue;
3885
3886                 // skip wrong class skills
3887                 if( skillLine->classmask && (skillLine->classmask & classmask) == 0)
3888                     continue;
3889
3890                 SpellEntry const* spellInfo = sSpellStore.LookupEntry(skillLine->spellId);
3891                 if(!spellInfo || !SpellMgr::IsSpellValid(spellInfo,m_session->GetPlayer(),false))
3892                     continue;
3893
3894                 if( !target->HasSpell(spellInfo->Id) )
3895                     m_session->GetPlayer()->learnSpell(skillLine->spellId);
3896             }
3897
3898             uint16 maxLevel = target->GetPureMaxSkillValue(skillInfo->id);
3899             target->SetSkill(skillInfo->id, maxLevel, maxLevel);
3900             PSendSysMessage(LANG_COMMAND_LEARN_ALL_RECIPES, name.c_str());
3901             return true;
3902         }
3903     }
3904
3905     return false;
3906 }
3907
3908 bool ChatHandler::HandleLookupPlayerIpCommand(const char* args)
3909 {
3910
3911     if (!*args)
3912         return false;
3913
3914     std::string ip = strtok ((char*)args, " ");
3915     char* limit_str = strtok (NULL, " ");
3916     int32 limit = limit_str ? atoi (limit_str) : -1;
3917
3918     loginDatabase.escape_string (ip);
3919
3920     QueryResult* result = loginDatabase.PQuery ("SELECT id,username FROM account WHERE last_ip = '%s'", ip.c_str ());
3921
3922     return LookupPlayerSearchCommand (result,limit);
3923 }
3924
3925 bool ChatHandler::HandleLookupPlayerAccountCommand(const char* args)
3926 {
3927     if (!*args)
3928         return false;
3929
3930     std::string account = strtok ((char*)args, " ");
3931     char* limit_str = strtok (NULL, " ");
3932     int32 limit = limit_str ? atoi (limit_str) : -1;
3933
3934     if (!AccountMgr::normilizeString (account))
3935         return false;
3936
3937     loginDatabase.escape_string (account);
3938
3939     QueryResult* result = loginDatabase.PQuery ("SELECT id,username FROM account WHERE username = '%s'", account.c_str ());
3940
3941     return LookupPlayerSearchCommand (result,limit);
3942 }
3943
3944 bool ChatHandler::HandleLookupPlayerEmailCommand(const char* args)
3945 {
3946
3947     if (!*args)
3948         return false;
3949
3950     std::string email = strtok ((char*)args, " ");
3951     char* limit_str = strtok (NULL, " ");
3952     int32 limit = limit_str ? atoi (limit_str) : -1;
3953
3954     loginDatabase.escape_string (email);
3955
3956     QueryResult* result = loginDatabase.PQuery ("SELECT id,username FROM account WHERE email = '%s'", email.c_str ());
3957
3958     return LookupPlayerSearchCommand (result,limit);
3959 }
3960
3961 bool ChatHandler::LookupPlayerSearchCommand(QueryResult* result, int32 limit)
3962 {
3963     if(!result)
3964     {
3965         PSendSysMessage(LANG_NO_PLAYERS_FOUND);
3966         SetSentErrorMessage(true);
3967         return false;
3968     }
3969
3970     int i =0;
3971     do
3972     {
3973         Field* fields = result->Fetch();
3974         uint32 acc_id = fields[0].GetUInt32();
3975         std::string acc_name = fields[1].GetCppString();
3976
3977         QueryResult* chars = CharacterDatabase.PQuery("SELECT guid,name FROM characters WHERE account = '%u'", acc_id);
3978         if(chars)
3979         {
3980             PSendSysMessage(LANG_LOOKUP_PLAYER_ACCOUNT,acc_name.c_str(),acc_id);
3981
3982             uint64 guid = 0;
3983             std::string name;
3984
3985             do
3986             {
3987                 Field* charfields = chars->Fetch();
3988                 guid = charfields[0].GetUInt64();
3989                 name = charfields[1].GetCppString();
3990
3991                 PSendSysMessage(LANG_LOOKUP_PLAYER_CHARACTER,name.c_str(),guid);
3992                 ++i;
3993
3994             } while( chars->NextRow() && ( limit == -1 || i < limit ) );
3995
3996             delete chars;
3997         }
3998     } while(result->NextRow());
3999
4000     delete result;
4001
4002     return true;
4003 }
4004
4005 /// Triggering corpses expire check in world
4006 bool ChatHandler::HandleServerCorpsesCommand(const char* /*args*/)
4007 {
4008     CorpsesErase();
4009     return true;
4010 }
4011
4012 bool ChatHandler::HandleRepairitemsCommand(const char* /*args*/)
4013 {
4014     Player *target = getSelectedPlayer();
4015
4016     if(!target)
4017     {
4018         PSendSysMessage(LANG_NO_CHAR_SELECTED);
4019         SetSentErrorMessage(true);
4020         return false;
4021     }
4022
4023     // Repair items
4024     target->DurabilityRepairAll(false, 0, false);
4025
4026     PSendSysMessage(LANG_YOU_REPAIR_ITEMS, target->GetName());
4027     if(needReportToTarget(target))
4028         ChatHandler(target).PSendSysMessage(LANG_YOUR_ITEMS_REPAIRED, GetName());
4029     return true;
4030 }
4031
4032 bool ChatHandler::HandleWaterwalkCommand(const char* args)
4033 {
4034     if(!*args)
4035         return false;
4036
4037     Player *player = getSelectedPlayer();
4038
4039     if(!player)
4040     {
4041         PSendSysMessage(LANG_NO_CHAR_SELECTED);
4042         SetSentErrorMessage(true);
4043         return false;
4044     }
4045
4046     if (strncmp(args, "on", 3) == 0)
4047         player->SetMovement(MOVE_WATER_WALK);               // ON
4048     else if (strncmp(args, "off", 4) == 0)
4049         player->SetMovement(MOVE_LAND_WALK);                // OFF
4050     else
4051     {
4052         SendSysMessage(LANG_USE_BOL);
4053         return false;
4054     }
4055
4056     PSendSysMessage(LANG_YOU_SET_WATERWALK, args, player->GetName());
4057     if(needReportToTarget(player))
4058         ChatHandler(player).PSendSysMessage(LANG_YOUR_WATERWALK_SET, args, GetName());
4059     return true;
4060 }
4061
4062 bool ChatHandler::HandleNpcFollowCommand(const char* /*args*/)
4063 {
4064     Player *player = m_session->GetPlayer();
4065     Creature *creature = getSelectedCreature();
4066
4067     if(!creature)
4068     {
4069         PSendSysMessage(LANG_SELECT_CREATURE);
4070         SetSentErrorMessage(true);
4071         return false;
4072     }
4073
4074     // Follow player - Using pet's default dist and angle
4075     creature->GetMotionMaster()->MoveFollow(player, PET_FOLLOW_DIST, PET_FOLLOW_ANGLE);
4076
4077     PSendSysMessage(LANG_CREATURE_FOLLOW_YOU_NOW, creature->GetName());
4078     return true;
4079 }
4080
4081 bool ChatHandler::HandleNpcUnFollowCommand(const char* /*args*/)
4082 {
4083     Player *player = m_session->GetPlayer();
4084     Creature *creature = getSelectedCreature();
4085
4086     if(!creature)
4087     {
4088         PSendSysMessage(LANG_SELECT_CREATURE);
4089         SetSentErrorMessage(true);
4090         return false;
4091     }
4092
4093     if (creature->GetMotionMaster()->empty() ||
4094         creature->GetMotionMaster()->GetCurrentMovementGeneratorType ()!=TARGETED_MOTION_TYPE)
4095     {
4096         PSendSysMessage(LANG_CREATURE_NOT_FOLLOW_YOU);
4097         SetSentErrorMessage(true);
4098         return false;
4099     }
4100
4101     TargetedMovementGenerator<Creature> const* mgen
4102         = static_cast<TargetedMovementGenerator<Creature> const*>((creature->GetMotionMaster()->top()));
4103
4104     if(mgen->GetTarget()!=player)
4105     {
4106         PSendSysMessage(LANG_CREATURE_NOT_FOLLOW_YOU);
4107         SetSentErrorMessage(true);
4108         return false;
4109     }
4110
4111     // reset movement
4112     creature->GetMotionMaster()->MovementExpired(true);
4113
4114     PSendSysMessage(LANG_CREATURE_NOT_FOLLOW_YOU_NOW, creature->GetName());
4115     return true;
4116 }
4117
4118 bool ChatHandler::HandleNpcTameCommand(const char* /*args*/)
4119 {
4120     Creature *creatureTarget = getSelectedCreature ();
4121     if (!creatureTarget || creatureTarget->isPet ())
4122     {
4123         PSendSysMessage (LANG_SELECT_CREATURE);
4124         SetSentErrorMessage (true);
4125         return false;
4126     }
4127
4128     Player *player = m_session->GetPlayer ();
4129
4130     if(player->GetPetGUID ())
4131     {
4132         SendSysMessage (LANG_YOU_ALREADY_HAVE_PET);
4133         SetSentErrorMessage (true);
4134         return false;
4135     }
4136
4137     CreatureInfo const* cInfo = creatureTarget->GetCreatureInfo();
4138
4139     if (!cInfo->isTameable ())
4140     {
4141         PSendSysMessage (LANG_CREATURE_NON_TAMEABLE,cInfo->Entry);
4142         SetSentErrorMessage (true);
4143         return false;
4144     }
4145
4146     // Everything looks OK, create new pet
4147     Pet* pet = player->CreateTamedPetFrom (creatureTarget);
4148     if (!pet)
4149     {
4150         PSendSysMessage (LANG_CREATURE_NON_TAMEABLE,cInfo->Entry);
4151         SetSentErrorMessage (true);
4152         return false;
4153     }
4154
4155     // place pet before player
4156     float x,y,z;
4157     player->GetClosePoint (x,y,z,creatureTarget->GetObjectSize (),CONTACT_DISTANCE);
4158     pet->Relocate (x,y,z,M_PI-player->GetOrientation ());
4159
4160     // set pet to defensive mode by default (some classes can't control contolled pets in fact).
4161     pet->GetCharmInfo()->SetReactState(REACT_DEFENSIVE);
4162
4163     // prepare visual effect for levelup
4164     pet->SetUInt32Value(UNIT_FIELD_LEVEL,creatureTarget->getLevel()-1);
4165
4166     // add to world
4167     MapManager::Instance().GetMap(pet->GetMapId(), pet)->Add((Creature*)pet);
4168
4169     // visual effect for levelup
4170     pet->SetUInt32Value(UNIT_FIELD_LEVEL,creatureTarget->getLevel());
4171
4172     // caster have pet now
4173     player->SetPet(pet);
4174
4175     pet->SavePetToDB(PET_SAVE_AS_CURRENT);
4176     player->PetSpellInitialize();
4177
4178     return true;
4179 }