src/game/PetHandler.cpp

   1 /*
   2  * Copyright (C) 2005-2009 MaNGOS <http://getmangos.com/>
   3  *
   4  * This program is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License as published by
   6  * the Free Software Foundation; either version 2 of the License, or
   7  * (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, write to the Free Software
  16  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  17  */
  18
  19 #include "Common.h"
  20 #include "WorldPacket.h"
  21 #include "WorldSession.h"
  22 #include "ObjectMgr.h"
  23 #include "SpellMgr.h"
  24 #include "Log.h"
  25 #include "Opcodes.h"
  26 #include "Spell.h"
  27 #include "ObjectAccessor.h"
  28 #include "CreatureAI.h"
  29 #include "Util.h"
  30 #include "Pet.h"
  31
  32 void WorldSession::HandlePetAction( WorldPacket & recv_data )
  33 {
  34     uint64 guid1;
  35     uint32 data;
  36     uint64 guid2;
  37     recv_data >> guid1;                                     //pet guid
  38     recv_data >> data;
  39     recv_data >> guid2;                                     //tag guid
  40
  41     uint32 spellid = UNIT_ACTION_BUTTON_ACTION(data);
  42     uint8 flag = UNIT_ACTION_BUTTON_TYPE(data);             //delete = 0x07 CastSpell = C1
  43
  44     // used also for charmed creature
  45     Unit* pet= ObjectAccessor::GetUnit(*_player, guid1);
  46     sLog.outDetail("HandlePetAction.Pet %u flag is %u, spellid is %u, target %u.", uint32(GUID_LOPART(guid1)), uint32(flag), spellid, uint32(GUID_LOPART(guid2)) );
  47     if(!pet)
  48     {
  49         sLog.outError( "Pet %u not exist.", uint32(GUID_LOPART(guid1)) );
  50         return;
  51     }
  52
  53     if(pet != GetPlayer()->GetPet() && pet != GetPlayer()->GetCharm())
  54     {
  55         sLog.outError("HandlePetAction.Pet %u isn't pet of player %s.", uint32(GUID_LOPART(guid1)), GetPlayer()->GetName() );
  56         return;
  57     }
  58
  59     if(!pet->isAlive())
  60         return;
  61
  62     if(pet->GetTypeId() == TYPEID_PLAYER && !(flag == ACT_COMMAND && spellid == COMMAND_ATTACK))
  63         return;
  64
  65     CharmInfo *charmInfo = pet->GetCharmInfo();
  66     if(!charmInfo)
  67     {
  68         sLog.outError("WorldSession::HandlePetAction: object (GUID: %u TypeId: %u) is considered pet-like but doesn't have a charminfo!", pet->GetGUIDLow(), pet->GetTypeId());
  69         return;
  70     }
  71
  72     switch(flag)
  73     {
  74         case ACT_COMMAND:                                   //0x07
  75             switch(spellid)
  76             {
  77                 case COMMAND_STAY:                          //flat=1792  //STAY
  78                     pet->StopMoving();
  79                     pet->GetMotionMaster()->Clear();
  80                     pet->GetMotionMaster()->MoveIdle();
  81                     charmInfo->SetCommandState( COMMAND_STAY );
  82                     break;
  83                 case COMMAND_FOLLOW:                        //spellid=1792  //FOLLOW
  84                     pet->AttackStop();
  85                     pet->GetMotionMaster()->MoveFollow(_player,PET_FOLLOW_DIST,PET_FOLLOW_ANGLE);
  86                     charmInfo->SetCommandState( COMMAND_FOLLOW );
  87                     break;
  88                 case COMMAND_ATTACK:                        //spellid=1792  //ATTACK
  89                 {
  90                     const uint64& selguid = _player->GetSelection();
  91                     Unit *TargetUnit = ObjectAccessor::GetUnit(*_player, selguid);
  92                     if(!TargetUnit)
  93                         return;
  94
  95                     // not let attack friendly units.
  96                     if(GetPlayer()->IsFriendlyTo(TargetUnit))
  97                         return;
  98                     // Not let attack through obstructions
  99                     if(!pet->IsWithinLOSInMap(TargetUnit))
 100                         return;
 101
 102                     // This is true if pet has no target or has target but targets differs.
 103                     if(pet->getVictim() != TargetUnit)
 104                     {
 105                         if (pet->getVictim())
 106                             pet->AttackStop();
 107
 108                         if(pet->GetTypeId() != TYPEID_PLAYER)
 109                         {
 110                             pet->GetMotionMaster()->Clear();
 111                             if (((Creature*)pet)->AI())
 112                                 ((Creature*)pet)->AI()->AttackStart(TargetUnit);
 113
 114                             //10% chance to play special pet attack talk, else growl
 115                             if(((Creature*)pet)->isPet() && ((Pet*)pet)->getPetType() == SUMMON_PET && pet != TargetUnit && urand(0, 100) < 10)
 116                                 pet->SendPetTalk((uint32)PET_TALK_ATTACK);
 117                             else
 118                             {
 119                                 // 90% chance for pet and 100% chance for charmed creature
 120                                 pet->SendPetAIReaction(guid1);
 121                             }
 122                         }
 123                         else                                // charmed player
 124                         {
 125                             pet->Attack(TargetUnit,true);
 126                             pet->SendPetAIReaction(guid1);
 127                         }
 128                     }
 129                     break;
 130                 }
 131                 case COMMAND_ABANDON:                       // abandon (hunter pet) or dismiss (summoned pet)
 132                     if(((Creature*)pet)->isPet())
 133                     {
 134                         Pet* p = (Pet*)pet;
 135                         if(p->getPetType() == HUNTER_PET)
 136                             _player->RemovePet(p,PET_SAVE_AS_DELETED);
 137                         else
 138                             //dismissing a summoned pet is like killing them (this prevents returning a soulshard...)
 139                             p->setDeathState(CORPSE);
 140                     }
 141                     else                                    // charmed
 142                         _player->Uncharm();
 143                     break;
 144                 default:
 145                     sLog.outError("WORLD: unknown PET flag Action %i and spellid %i.", uint32(flag), spellid);
 146             }
 147             break;
 148         case ACT_REACTION:                                  // 0x6
 149             switch(spellid)
 150             {
 151                 case REACT_PASSIVE:                         //passive
 152                 case REACT_DEFENSIVE:                       //recovery
 153                 case REACT_AGGRESSIVE:                      //activete
 154                     charmInfo->SetReactState( ReactStates(spellid) );
 155                     break;
 156             }
 157             break;
 158         case ACT_DISABLED:                                  // 0x81    spell (disabled), ignore
 159         case ACT_PASSIVE:                                   // 0x01
 160         case ACT_ENABLED:                                   // 0xC1    spell
 161         {
 162             Unit* unit_target = NULL;
 163             if (((Creature*)pet)->GetGlobalCooldown() > 0)
 164                 return;
 165
 166             if(guid2)
 167                 unit_target = ObjectAccessor::GetUnit(*_player,guid2);
 168
 169             // do not cast unknown spells
 170             SpellEntry const *spellInfo = sSpellStore.LookupEntry(spellid );
 171             if(!spellInfo)
 172             {
 173                 sLog.outError("WORLD: unknown PET spell id %i", spellid);
 174                 return;
 175             }
 176
 177             for(uint32 i = 0; i < 3;++i)
 178             {
 179                 if(spellInfo->EffectImplicitTargetA[i] == TARGET_ALL_ENEMY_IN_AREA || spellInfo->EffectImplicitTargetA[i] == TARGET_ALL_ENEMY_IN_AREA_INSTANT || spellInfo->EffectImplicitTargetA[i] == TARGET_ALL_ENEMY_IN_AREA_CHANNELED)
 180                     return;
 181             }
 182
 183             // do not cast not learned spells
 184             if(!pet->HasSpell(spellid) || IsPassiveSpell(spellid))
 185                 return;
 186
 187             pet->clearUnitState(UNIT_STAT_FOLLOW);
 188
 189             Spell *spell = new Spell(pet, spellInfo, false);
 190
 191             SpellCastResult result = spell->CheckPetCast(unit_target);
 192
 193             //auto turn to target unless possessed
 194             if(result == SPELL_FAILED_UNIT_NOT_INFRONT && !pet->HasAuraType(SPELL_AURA_MOD_POSSESS))
 195             {
 196                 if(unit_target)
 197                 {
 198                     pet->SetInFront(unit_target);
 199                     if (unit_target->GetTypeId() == TYPEID_PLAYER)
 200                         pet->SendCreateUpdateToPlayer( (Player*)unit_target );
 201                 }
 202                 else if(Unit *unit_target2 = spell->m_targets.getUnitTarget())
 203                 {
 204                     pet->SetInFront(unit_target2);
 205                     if (unit_target2->GetTypeId() == TYPEID_PLAYER)
 206                         pet->SendCreateUpdateToPlayer( (Player*)unit_target2 );
 207                 }
 208                 if (Unit* powner = pet->GetCharmerOrOwner())
 209                     if(powner->GetTypeId() == TYPEID_PLAYER)
 210                         pet->SendCreateUpdateToPlayer((Player*)powner);
 211                 result = SPELL_CAST_OK;
 212             }
 213
 214             if(result == SPELL_CAST_OK)
 215             {
 216                 ((Creature*)pet)->AddCreatureSpellCooldown(spellid);
 217
 218                 unit_target = spell->m_targets.getUnitTarget();
 219
 220                 //10% chance to play special pet attack talk, else growl
 221                 //actually this only seems to happen on special spells, fire shield for imp, torment for voidwalker, but it's stupid to check every spell
 222                 if(((Creature*)pet)->isPet() && (((Pet*)pet)->getPetType() == SUMMON_PET) && (pet != unit_target) && (urand(0, 100) < 10))
 223                     pet->SendPetTalk((uint32)PET_TALK_SPECIAL_SPELL);
 224                 else
 225                 {
 226                     pet->SendPetAIReaction(guid1);
 227                 }
 228
 229                 if( unit_target && !GetPlayer()->IsFriendlyTo(unit_target) && !pet->HasAuraType(SPELL_AURA_MOD_POSSESS))
 230                 {
 231                     // This is true if pet has no target or has target but targets differs.
 232                     if (pet->getVictim() != unit_target)
 233                     {
 234                         if (pet->getVictim())
 235                             pet->AttackStop();
 236                         pet->GetMotionMaster()->Clear();
 237                         if (((Creature*)pet)->AI())
 238                             ((Creature*)pet)->AI()->AttackStart(unit_target);
 239                     }
 240                 }
 241
 242                 spell->prepare(&(spell->m_targets));
 243             }
 244             else
 245             {
 246                 if(pet->HasAuraType(SPELL_AURA_MOD_POSSESS))
 247                     Spell::SendCastResult(GetPlayer(),spellInfo,0,result);
 248                 else
 249                     pet->SendPetCastFail(spellid, result);
 250
 251                 if (!((Creature*)pet)->HasSpellCooldown(spellid))
 252                     GetPlayer()->SendClearCooldown(spellid, pet);
 253
 254                 spell->finish(false);
 255                 delete spell;
 256             }
 257             break;
 258         }
 259         default:
 260             sLog.outError("WORLD: unknown PET flag Action %i and spellid %i.", uint32(flag), spellid);
 261     }
 262 }
 263
 264 void WorldSession::HandlePetNameQuery( WorldPacket & recv_data )
 265 {
 266     sLog.outDetail( "HandlePetNameQuery. CMSG_PET_NAME_QUERY" );
 267
 268     uint32 petnumber;
 269     uint64 petguid;
 270
 271     recv_data >> petnumber;
 272     recv_data >> petguid;
 273
 274     SendPetNameQuery(petguid,petnumber);
 275 }
 276
 277 void WorldSession::SendPetNameQuery( uint64 petguid, uint32 petnumber)
 278 {
 279     Creature* pet = _player->GetMap()->GetCreatureOrPetOrVehicle(petguid);
 280     if(!pet || !pet->GetCharmInfo() || pet->GetCharmInfo()->GetPetNumber() != petnumber)
 281         return;
 282
 283     std::string name = pet->GetName();
 284
 285     WorldPacket data(SMSG_PET_NAME_QUERY_RESPONSE, (4+4+name.size()+1));
 286     data << uint32(petnumber);
 287     data << name.c_str();
 288     data << uint32(pet->GetUInt32Value(UNIT_FIELD_PET_NAME_TIMESTAMP));
 289
 290     if( pet->isPet() && ((Pet*)pet)->GetDeclinedNames() )
 291     {
 292         data << uint8(1);
 293         for(int i = 0; i < MAX_DECLINED_NAME_CASES; ++i)
 294             data << ((Pet*)pet)->GetDeclinedNames()->name[i];
 295     }
 296     else
 297         data << uint8(0);
 298
 299     _player->GetSession()->SendPacket(&data);
 300 }
 301
 302 void WorldSession::HandlePetSetAction( WorldPacket & recv_data )
 303 {
 304     sLog.outDetail( "HandlePetSetAction. CMSG_PET_SET_ACTION" );
 305
 306     uint64 petguid;
 307     uint8  count;
 308
 309     recv_data >> petguid;
 310
 311     Creature* pet = _player->GetMap()->GetCreatureOrPetOrVehicle(petguid);
 312
 313     if(!pet || (pet != _player->GetPet() && pet != _player->GetCharm()))
 314     {
 315         sLog.outError( "HandlePetSetAction: Unknown pet or pet owner." );
 316         return;
 317     }
 318
 319     CharmInfo *charmInfo = pet->GetCharmInfo();
 320     if(!charmInfo)
 321     {
 322         sLog.outError("WorldSession::HandlePetSetAction: object (GUID: %u TypeId: %u) is considered pet-like but doesn't have a charminfo!", pet->GetGUIDLow(), pet->GetTypeId());
 323         return;
 324     }
 325
 326     count = (recv_data.size() == 24) ? 2 : 1;
 327
 328     uint32 position[2];
 329     uint32 data[2];
 330     bool move_command = false;
 331
 332     for(uint8 i = 0; i < count; ++i)
 333     {
 334         recv_data >> position[i];
 335         recv_data >> data[i];
 336
 337         uint8 act_state = UNIT_ACTION_BUTTON_TYPE(data[i]);
 338
 339         //ignore invalid position
 340         if(position[i] >= MAX_UNIT_ACTION_BAR_INDEX)
 341             return;
 342
 343         // in the normal case, command and reaction buttons can only be moved, not removed
 344         // at moving count ==2, at removing count == 1
 345         // ignore attempt to remove command|reaction buttons (not possible at normal case)
 346         if (act_state == ACT_COMMAND || act_state == ACT_REACTION)
 347         {
 348             if (count == 1)
 349                 return;
 350
 351             move_command = true;
 352         }
 353     }
 354
 355     // check swap (at command->spell swap client remove spell first in another packet, so check only command move correctness)
 356     if (move_command)
 357     {
 358         uint8 act_state_0 = UNIT_ACTION_BUTTON_TYPE(data[0]);
 359         if(act_state_0 == ACT_COMMAND || act_state_0 == ACT_REACTION)
 360         {
 361             uint32 spell_id_0 = UNIT_ACTION_BUTTON_ACTION(data[0]);
 362             UnitActionBarEntry const* actionEntry_1 = charmInfo->GetActionBarEntry(position[1]);
 363             if (!actionEntry_1 || spell_id_0 != actionEntry_1->GetAction() ||
 364                 act_state_0 != actionEntry_1->GetType())
 365                 return;
 366         }
 367
 368         uint8 act_state_1 = UNIT_ACTION_BUTTON_TYPE(data[1]);
 369         if(act_state_1 == ACT_COMMAND || act_state_1 == ACT_REACTION)
 370         {
 371             uint32 spell_id_1 = UNIT_ACTION_BUTTON_ACTION(data[1]);
 372             UnitActionBarEntry const* actionEntry_0 = charmInfo->GetActionBarEntry(position[0]);
 373             if (!actionEntry_0 || spell_id_1 != actionEntry_0->GetAction() ||
 374                 act_state_1 != actionEntry_0->GetType())
 375                 return;
 376         }
 377     }
 378
 379     for(uint8 i = 0; i < count; ++i)
 380     {
 381         uint32 spell_id = UNIT_ACTION_BUTTON_ACTION(data[i]);
 382         uint8 act_state = UNIT_ACTION_BUTTON_TYPE(data[i]);
 383
 384         sLog.outDetail( "Player %s has changed pet spell action. Position: %u, Spell: %u, State: 0x%X", _player->GetName(), position[i], spell_id, uint32(act_state));
 385
 386         //if it's act for spell (en/disable/cast) and there is a spell given (0 = remove spell) which pet doesn't know, don't add
 387         if(!((act_state == ACT_ENABLED || act_state == ACT_DISABLED || act_state == ACT_PASSIVE) && spell_id && !pet->HasSpell(spell_id)))
 388         {
 389             //sign for autocast
 390             if(act_state == ACT_ENABLED && spell_id)
 391             {
 392                 if(pet->isCharmed())
 393                     charmInfo->ToggleCreatureAutocast(spell_id, true);
 394                 else
 395                     ((Pet*)pet)->ToggleAutocast(spell_id, true);
 396             }
 397             //sign for no/turn off autocast
 398             else if(act_state == ACT_DISABLED && spell_id)
 399             {
 400                 if(pet->isCharmed())
 401                     charmInfo->ToggleCreatureAutocast(spell_id, false);
 402                 else
 403                     ((Pet*)pet)->ToggleAutocast(spell_id, false);
 404             }
 405
 406             charmInfo->SetActionBar(position[i],spell_id,ActiveStates(act_state));
 407         }
 408     }
 409 }
 410
 411 void WorldSession::HandlePetRename( WorldPacket & recv_data )
 412 {
 413     sLog.outDetail( "HandlePetRename. CMSG_PET_RENAME" );
 414
 415     uint64 petguid;
 416     uint8 isdeclined;
 417
 418     std::string name;
 419     DeclinedName declinedname;
 420
 421     recv_data >> petguid;
 422     recv_data >> name;
 423     recv_data >> isdeclined;
 424
 425     Pet* pet = _player->GetMap()->GetPet(petguid);
 426                                                             // check it!
 427     if( !pet || pet->getPetType() != HUNTER_PET ||
 428         pet->GetByteValue(UNIT_FIELD_BYTES_2, 2) != UNIT_RENAME_ALLOWED ||
 429         pet->GetOwnerGUID() != _player->GetGUID() || !pet->GetCharmInfo() )
 430         return;
 431
 432     PetNameInvalidReason res = ObjectMgr::CheckPetName(name);
 433     if(res != PET_NAME_SUCCESS)
 434     {
 435         SendPetNameInvalid(res, name, NULL);
 436         return;
 437     }
 438
 439     if(sObjectMgr.IsReservedName(name))
 440     {
 441         SendPetNameInvalid(PET_NAME_RESERVED, name, NULL);
 442         return;
 443     }
 444
 445     pet->SetName(name);
 446
 447     if(_player->GetGroup())
 448         _player->SetGroupUpdateFlag(GROUP_UPDATE_FLAG_PET_NAME);
 449
 450     pet->SetByteValue(UNIT_FIELD_BYTES_2, 2, UNIT_RENAME_NOT_ALLOWED);
 451
 452     if(isdeclined)
 453     {
 454         for(int i = 0; i < MAX_DECLINED_NAME_CASES; ++i)
 455         {
 456             recv_data >> declinedname.name[i];
 457         }
 458
 459         std::wstring wname;
 460         Utf8toWStr(name, wname);
 461         if(!ObjectMgr::CheckDeclinedNames(GetMainPartOfName(wname,0),declinedname))
 462         {
 463             SendPetNameInvalid(PET_NAME_DECLENSION_DOESNT_MATCH_BASE_NAME, name, &declinedname);
 464             return;
 465         }
 466     }
 467
 468     CharacterDatabase.BeginTransaction();
 469     if(isdeclined)
 470     {
 471         for(int i = 0; i < MAX_DECLINED_NAME_CASES; ++i)
 472             CharacterDatabase.escape_string(declinedname.name[i]);
 473         CharacterDatabase.PExecute("DELETE FROM character_pet_declinedname WHERE owner = '%u' AND id = '%u'", _player->GetGUIDLow(), pet->GetCharmInfo()->GetPetNumber());
 474         CharacterDatabase.PExecute("INSERT INTO character_pet_declinedname (id, owner, genitive, dative, accusative, instrumental, prepositional) VALUES ('%u','%u','%s','%s','%s','%s','%s')",
 475             pet->GetCharmInfo()->GetPetNumber(), _player->GetGUIDLow(), declinedname.name[0].c_str(), declinedname.name[1].c_str(), declinedname.name[2].c_str(), declinedname.name[3].c_str(), declinedname.name[4].c_str());
 476     }
 477
 478     CharacterDatabase.escape_string(name);
 479     CharacterDatabase.PExecute("UPDATE character_pet SET name = '%s', renamed = '1' WHERE owner = '%u' AND id = '%u'", name.c_str(), _player->GetGUIDLow(), pet->GetCharmInfo()->GetPetNumber());
 480     CharacterDatabase.CommitTransaction();
 481
 482     pet->SetUInt32Value(UNIT_FIELD_PET_NAME_TIMESTAMP, time(NULL));
 483 }
 484
 485 void WorldSession::HandlePetAbandon( WorldPacket & recv_data )
 486 {
 487     uint64 guid;
 488     recv_data >> guid;                                      //pet guid
 489     sLog.outDetail( "HandlePetAbandon. CMSG_PET_ABANDON pet guid is %u", GUID_LOPART(guid) );
 490
 491     if(!_player->IsInWorld())
 492         return;
 493
 494     // pet/charmed
 495     if (Creature* pet = _player->GetMap()->GetCreatureOrPetOrVehicle(guid))
 496     {
 497         if(pet->isPet())
 498         {
 499             if(pet->GetGUID() == _player->GetPetGUID())
 500             {
 501                 uint32 feelty = pet->GetPower(POWER_HAPPINESS);
 502                 pet->SetPower(POWER_HAPPINESS ,(feelty-50000) > 0 ?(feelty-50000) : 0);
 503             }
 504
 505             _player->RemovePet((Pet*)pet,PET_SAVE_AS_DELETED);
 506         }
 507         else if(pet->GetGUID() == _player->GetCharmGUID())
 508         {
 509             _player->Uncharm();
 510         }
 511     }
 512 }
 513
 514 void WorldSession::HandlePetUnlearnOpcode(WorldPacket& recvPacket)
 515 {
 516     sLog.outDetail("CMSG_PET_UNLEARN");
 517     uint64 guid;
 518     recvPacket >> guid;                 // Pet guid
 519
 520     Pet* pet = _player->GetPet();
 521
 522     if(!pet || pet->getPetType() != HUNTER_PET || pet->m_usedTalentCount == 0)
 523         return;
 524
 525     if(guid != pet->GetGUID())
 526     {
 527         sLog.outError( "HandlePetUnlearnOpcode.Pet %u isn't pet of player %s .", uint32(GUID_LOPART(guid)),GetPlayer()->GetName() );
 528         return;
 529     }
 530
 531     CharmInfo *charmInfo = pet->GetCharmInfo();
 532     if(!charmInfo)
 533     {
 534         sLog.outError("WorldSession::HandlePetUnlearnOpcode: object (GUID: %u TypeId: %u) is considered pet-like but doesn't have a charminfo!", pet->GetGUIDLow(), pet->GetTypeId());
 535         return;
 536     }
 537     pet->resetTalents();
 538     _player->SendTalentsInfoData(true);
 539 }
 540
 541 void WorldSession::HandlePetSpellAutocastOpcode( WorldPacket& recvPacket )
 542 {
 543     sLog.outDetail("CMSG_PET_SPELL_AUTOCAST");
 544     uint64 guid;
 545     uint32 spellid;
 546     uint8  state;                                           //1 for on, 0 for off
 547     recvPacket >> guid >> spellid >> state;
 548
 549     if(!_player->GetPet() && !_player->GetCharm())
 550         return;
 551
 552     Creature* pet = _player->GetMap()->GetCreatureOrPetOrVehicle(guid);
 553
 554     if(!pet || (pet != _player->GetPet() && pet != _player->GetCharm()))
 555     {
 556         sLog.outError( "HandlePetSpellAutocastOpcode.Pet %u isn't pet of player %s .", uint32(GUID_LOPART(guid)),GetPlayer()->GetName() );
 557         return;
 558     }
 559
 560     // do not add not learned spells/ passive spells
 561     if(!pet->HasSpell(spellid) || IsPassiveSpell(spellid))
 562         return;
 563
 564     CharmInfo *charmInfo = pet->GetCharmInfo();
 565     if(!charmInfo)
 566     {
 567         sLog.outError("WorldSession::HandlePetSpellAutocastOpcod: object (GUID: %u TypeId: %u) is considered pet-like but doesn't have a charminfo!", pet->GetGUIDLow(), pet->GetTypeId());
 568         return;
 569     }
 570
 571     if(pet->isCharmed())
 572                                                             //state can be used as boolean
 573         pet->GetCharmInfo()->ToggleCreatureAutocast(spellid, state);
 574     else
 575         ((Pet*)pet)->ToggleAutocast(spellid, state);
 576
 577     charmInfo->SetSpellAutocast(spellid,state);
 578 }
 579
 580 void WorldSession::HandlePetCastSpellOpcode( WorldPacket& recvPacket )
 581 {
 582     sLog.outDetail("WORLD: CMSG_PET_CAST_SPELL");
 583
 584     uint64 guid;
 585     uint32 spellid;
 586     uint8  cast_count;
 587     uint8  unk_flags;                                       // flags (if 0x02 - some additional data are received)
 588
 589     recvPacket >> guid >> cast_count >> spellid >> unk_flags;
 590
 591     sLog.outDebug("WORLD: CMSG_PET_CAST_SPELL, cast_count: %u, spellid %u, unk_flags %u", cast_count, spellid, unk_flags);
 592
 593     if (!_player->GetPet() && !_player->GetCharm())
 594         return;
 595
 596     Creature* pet = _player->GetMap()->GetCreatureOrPetOrVehicle(guid);
 597
 598     if (!pet || (pet != _player->GetPet() && pet!= _player->GetCharm()))
 599     {
 600         sLog.outError( "HandlePetCastSpellOpcode: Pet %u isn't pet of player %s .", uint32(GUID_LOPART(guid)),GetPlayer()->GetName() );
 601         return;
 602     }
 603
 604     if (pet->GetGlobalCooldown() > 0)
 605         return;
 606
 607     SpellEntry const *spellInfo = sSpellStore.LookupEntry(spellid);
 608     if (!spellInfo)
 609     {
 610         sLog.outError("WORLD: unknown PET spell id %i", spellid);
 611         return;
 612     }
 613
 614     // do not cast not learned spells
 615     if (!pet->HasSpell(spellid) || IsPassiveSpell(spellid))
 616         return;
 617
 618     SpellCastTargets targets;
 619     if (!targets.read(&recvPacket,pet))
 620         return;
 621
 622     pet->clearUnitState(UNIT_STAT_FOLLOW);
 623
 624     Spell *spell = new Spell(pet, spellInfo, false);
 625     spell->m_cast_count = cast_count;                       // probably pending spell cast
 626     spell->m_targets = targets;
 627
 628     SpellCastResult result = spell->CheckPetCast(NULL);
 629     if (result == SPELL_CAST_OK)
 630     {
 631         pet->AddCreatureSpellCooldown(spellid);
 632         if (pet->isPet())
 633         {
 634             //10% chance to play special pet attack talk, else growl
 635             //actually this only seems to happen on special spells, fire shield for imp, torment for voidwalker, but it's stupid to check every spell
 636             if(((Pet*)pet)->getPetType() == SUMMON_PET && (urand(0, 100) < 10))
 637                 pet->SendPetTalk((uint32)PET_TALK_SPECIAL_SPELL);
 638             else
 639                 pet->SendPetAIReaction(guid);
 640         }
 641
 642         spell->prepare(&(spell->m_targets));
 643     }
 644     else
 645     {
 646         pet->SendPetCastFail(spellid, result);
 647         if (!pet->HasSpellCooldown(spellid))
 648             GetPlayer()->SendClearCooldown(spellid, pet);
 649
 650         spell->finish(false);
 651         delete spell;
 652     }
 653 }
 654
 655 void WorldSession::SendPetNameInvalid(uint32 error, const std::string& name, DeclinedName *declinedName)
 656 {
 657     WorldPacket data(SMSG_PET_NAME_INVALID, 4 + name.size() + 1 + 1);
 658     data << uint32(error);
 659     data << name;
 660     if(declinedName)
 661     {
 662         data << uint8(1);
 663         for(uint32 i = 0; i < MAX_DECLINED_NAME_CASES; ++i)
 664             data << declinedName->name[i];
 665     }
 666     else
 667         data << uint8(0);
 668     SendPacket(&data);
 669 }
 670
 671 void WorldSession::HandlePetLearnTalent( WorldPacket & recv_data )
 672 {
 673     sLog.outDebug("WORLD: CMSG_PET_LEARN_TALENT");
 674
 675     uint64 guid;
 676     uint32 talent_id, requested_rank;
 677     recv_data >> guid >> talent_id >> requested_rank;
 678
 679     _player->LearnPetTalent(guid, talent_id, requested_rank);
 680     _player->SendTalentsInfoData(true);
 681 }
 682
 683 void WorldSession::HandleLearnPreviewTalentsPet( WorldPacket & recv_data )
 684 {
 685     sLog.outDebug("CMSG_LEARN_PREVIEW_TALENTS_PET");
 686
 687     uint64 guid;
 688     recv_data >> guid;
 689
 690     uint32 talentsCount;
 691     recv_data >> talentsCount;
 692
 693     uint32 talentId, talentRank;
 694
 695     for(uint32 i = 0; i < talentsCount; ++i)
 696     {
 697         recv_data >> talentId >> talentRank;
 698
 699         _player->LearnPetTalent(guid, talentId, talentRank);
 700     }
 701
 702     _player->SendTalentsInfoData(true);
 703 }