root/trunk/src/game/Level1.cpp @ 232

Revision 232, 62.3 kB (checked in by yumileroy, 17 years ago)

[svn] *** Source: MaNGOS ***
* Fixed english spelling in src/game/WorldSocket.h/cpp. Author: Derex
* [240_world.sql] Create new command .senditems and remove from moderator level command .sendmail possibility send items. Author: Vladimir
* Added new command: .sendmoney player "subject" "message" money - Sends a mail with money to a player. Author: fredi
* Correctly apply taken damage debufs/bonuses in cases non-physical melee damage. Author: Frankir
* Fix a crash in add friend/ignore callback. (check if player still logged in). Author: Hunuza
* Better args checking in .sendmoney command. Author: Vladimir

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