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