src/game/Object.cpp

   1 /*
   2  * Copyright (C) 2005-2010 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 "SharedDefines.h"
  21 #include "WorldPacket.h"
  22 #include "Opcodes.h"
  23 #include "Log.h"
  24 #include "World.h"
  25 #include "Object.h"
  26 #include "Creature.h"
  27 #include "Player.h"
  28 #include "Vehicle.h"
  29 #include "ObjectMgr.h"
  30 #include "ObjectGuid.h"
  31 #include "UpdateData.h"
  32 #include "UpdateMask.h"
  33 #include "Util.h"
  34 #include "MapManager.h"
  35 #include "Log.h"
  36 #include "Transports.h"
  37 #include "TargetedMovementGenerator.h"
  38 #include "WaypointMovementGenerator.h"
  39 #include "VMapFactory.h"
  40 #include "CellImpl.h"
  41 #include "GridNotifiers.h"
  42 #include "GridNotifiersImpl.h"
  43
  44 #include "ObjectPosSelector.h"
  45
  46 #include "TemporarySummon.h"
  47
  48 uint32 GuidHigh2TypeId(uint32 guid_hi)
  49 {
  50     switch(guid_hi)
  51     {
  52         case HIGHGUID_ITEM:         return TYPEID_ITEM;
  53         //case HIGHGUID_CONTAINER:    return TYPEID_CONTAINER; HIGHGUID_CONTAINER==HIGHGUID_ITEM currently
  54         case HIGHGUID_UNIT:         return TYPEID_UNIT;
  55         case HIGHGUID_PET:          return TYPEID_UNIT;
  56         case HIGHGUID_PLAYER:       return TYPEID_PLAYER;
  57         case HIGHGUID_GAMEOBJECT:   return TYPEID_GAMEOBJECT;
  58         case HIGHGUID_DYNAMICOBJECT:return TYPEID_DYNAMICOBJECT;
  59         case HIGHGUID_CORPSE:       return TYPEID_CORPSE;
  60         case HIGHGUID_MO_TRANSPORT: return TYPEID_GAMEOBJECT;
  61         case HIGHGUID_VEHICLE:      return TYPEID_UNIT;
  62     }
  63     return TYPEID_OBJECT;                                   // unknown
  64 }
  65
  66 Object::Object( )
  67 {
  68     m_objectTypeId      = TYPEID_OBJECT;
  69     m_objectType        = TYPEMASK_OBJECT;
  70
  71     m_uint32Values      = 0;
  72     m_uint32Values_mirror = 0;
  73     m_valuesCount       = 0;
  74
  75     m_inWorld           = false;
  76     m_objectUpdated     = false;
  77 }
  78
  79 Object::~Object( )
  80 {
  81     if(IsInWorld())
  82     {
  83         ///- Do NOT call RemoveFromWorld here, if the object is a player it will crash
  84         sLog.outError("Object::~Object (GUID: %u TypeId: %u) deleted but still in world!!", GetGUIDLow(), GetTypeId());
  85         ASSERT(false);
  86     }
  87
  88     if(m_objectUpdated)
  89     {
  90         sLog.outError("Object::~Object (GUID: %u TypeId: %u) deleted but still have updated status!!", GetGUIDLow(), GetTypeId());
  91         ASSERT(false);
  92     }
  93
  94     if(m_uint32Values)
  95     {
  96         //DEBUG_LOG("Object desctr 1 check (%p)",(void*)this);
  97         delete [] m_uint32Values;
  98         delete [] m_uint32Values_mirror;
  99         //DEBUG_LOG("Object desctr 2 check (%p)",(void*)this);
 100     }
 101 }
 102
 103 void Object::_InitValues()
 104 {
 105     m_uint32Values = new uint32[ m_valuesCount ];
 106     memset(m_uint32Values, 0, m_valuesCount*sizeof(uint32));
 107
 108     m_uint32Values_mirror = new uint32[ m_valuesCount ];
 109     memset(m_uint32Values_mirror, 0, m_valuesCount*sizeof(uint32));
 110
 111     m_objectUpdated = false;
 112 }
 113
 114 void Object::_Create( uint32 guidlow, uint32 entry, HighGuid guidhigh )
 115 {
 116     if(!m_uint32Values)
 117         _InitValues();
 118
 119     uint64 guid = MAKE_NEW_GUID(guidlow, entry, guidhigh);
 120     SetUInt64Value(OBJECT_FIELD_GUID, guid);
 121     SetUInt32Value(OBJECT_FIELD_TYPE, m_objectType);
 122     m_PackGUID.Set(guid);
 123 }
 124
 125 void Object::BuildMovementUpdateBlock(UpdateData * data, uint16 flags ) const
 126 {
 127     ByteBuffer buf(500);
 128
 129     buf << uint8(UPDATETYPE_MOVEMENT);
 130     buf << GetPackGUID();
 131
 132     BuildMovementUpdate(&buf, flags);
 133
 134     data->AddUpdateBlock(buf);
 135 }
 136
 137 void Object::BuildCreateUpdateBlockForPlayer(UpdateData *data, Player *target) const
 138 {
 139     if(!target)
 140         return;
 141
 142     uint8  updatetype   = UPDATETYPE_CREATE_OBJECT;
 143     uint16 updateFlags  = m_updateFlag;
 144
 145     /** lower flag1 **/
 146     if(target == this)                                      // building packet for yourself
 147         updateFlags |= UPDATEFLAG_SELF;
 148
 149     if(updateFlags & UPDATEFLAG_HAS_POSITION)
 150     {
 151         // UPDATETYPE_CREATE_OBJECT2 dynamic objects, corpses...
 152         if(isType(TYPEMASK_DYNAMICOBJECT) || isType(TYPEMASK_CORPSE) || isType(TYPEMASK_PLAYER))
 153             updatetype = UPDATETYPE_CREATE_OBJECT2;
 154
 155         // UPDATETYPE_CREATE_OBJECT2 for pets...
 156         if(target->GetPetGUID() == GetGUID())
 157             updatetype = UPDATETYPE_CREATE_OBJECT2;
 158
 159         // UPDATETYPE_CREATE_OBJECT2 for some gameobject types...
 160         if(isType(TYPEMASK_GAMEOBJECT))
 161         {
 162             switch(((GameObject*)this)->GetGoType())
 163             {
 164                 case GAMEOBJECT_TYPE_TRAP:
 165                 case GAMEOBJECT_TYPE_DUEL_ARBITER:
 166                 case GAMEOBJECT_TYPE_FLAGSTAND:
 167                 case GAMEOBJECT_TYPE_FLAGDROP:
 168                     updatetype = UPDATETYPE_CREATE_OBJECT2;
 169                     break;
 170                 case GAMEOBJECT_TYPE_TRANSPORT:
 171                     updateFlags |= UPDATEFLAG_TRANSPORT;
 172                     break;
 173                 default:
 174                     break;
 175             }
 176         }
 177
 178         if(isType(TYPEMASK_UNIT))
 179         {
 180             if(((Unit*)this)->getVictim())
 181                 updateFlags |= UPDATEFLAG_HAS_ATTACKING_TARGET;
 182         }
 183     }
 184
 185     //sLog.outDebug("BuildCreateUpdate: update-type: %u, object-type: %u got updateFlags: %X", updatetype, m_objectTypeId, updateFlags);
 186
 187     ByteBuffer buf(500);
 188     buf << uint8(updatetype);
 189     buf << GetPackGUID();
 190     buf << uint8(m_objectTypeId);
 191
 192     BuildMovementUpdate(&buf, updateFlags);
 193
 194     UpdateMask updateMask;
 195     updateMask.SetCount(m_valuesCount);
 196     _SetCreateBits(&updateMask, target);
 197     BuildValuesUpdate(updatetype, &buf, &updateMask, target);
 198     data->AddUpdateBlock(buf);
 199 }
 200
 201 void Object::SendCreateUpdateToPlayer(Player* player)
 202 {
 203     // send create update to player
 204     UpdateData upd;
 205     WorldPacket packet;
 206
 207     BuildCreateUpdateBlockForPlayer(&upd, player);
 208     upd.BuildPacket(&packet);
 209     player->GetSession()->SendPacket(&packet);
 210 }
 211
 212 void Object::BuildValuesUpdateBlockForPlayer(UpdateData *data, Player *target) const
 213 {
 214     ByteBuffer buf(500);
 215
 216     buf << uint8(UPDATETYPE_VALUES);
 217     buf << GetPackGUID();
 218
 219     UpdateMask updateMask;
 220     updateMask.SetCount(m_valuesCount);
 221
 222     _SetUpdateBits(&updateMask, target);
 223     BuildValuesUpdate(UPDATETYPE_VALUES, &buf, &updateMask, target);
 224
 225     data->AddUpdateBlock(buf);
 226 }
 227
 228 void Object::BuildOutOfRangeUpdateBlock(UpdateData * data) const
 229 {
 230     data->AddOutOfRangeGUID(GetGUID());
 231 }
 232
 233 void Object::DestroyForPlayer( Player *target, bool anim ) const
 234 {
 235     ASSERT(target);
 236
 237     WorldPacket data(SMSG_DESTROY_OBJECT, 8);
 238     data << uint64(GetGUID());
 239     data << uint8(anim ? 1 : 0);                            // WotLK (bool), may be despawn animation
 240     target->GetSession()->SendPacket(&data);
 241 }
 242
 243 void Object::BuildMovementUpdate(ByteBuffer * data, uint16 updateFlags) const
 244 {
 245     uint16 moveFlags2 = (isType(TYPEMASK_UNIT) ? ((Unit*)this)->m_movementInfo.GetMovementFlags2() : MOVEFLAG2_NONE);
 246
 247     if(GetTypeId() == TYPEID_UNIT)
 248         if(((Creature*)this)->isVehicle())
 249             moveFlags2 |= MOVEFLAG2_ALLOW_PITCHING;         // always allow pitch
 250
 251     *data << uint16(updateFlags);                           // update flags
 252
 253     // 0x20
 254     if (updateFlags & UPDATEFLAG_LIVING)
 255     {
 256         Unit *unit = ((Unit*)this);
 257
 258         switch(GetTypeId())
 259         {
 260             case TYPEID_UNIT:
 261             {
 262                 unit->m_movementInfo.SetMovementFlags(MOVEFLAG_NONE);
 263
 264                 // disabled, makes them run-in-same-place before movement generator updated once.
 265                 /*if (((Creature*)unit)->hasUnitState(UNIT_STAT_MOVING))
 266                     unit->m_movementInfo.SetMovementFlags(MOVEFLAG_FORWARD);*/
 267
 268                 if (((Creature*)unit)->canFly())
 269                 {
 270                     // (ok) most seem to have this
 271                     unit->m_movementInfo.AddMovementFlag(MOVEFLAG_LEVITATING);
 272
 273                     if (!((Creature*)unit)->hasUnitState(UNIT_STAT_MOVING))
 274                     {
 275                         // (ok) possibly some "hover" mode
 276                         unit->m_movementInfo.AddMovementFlag(MOVEFLAG_ROOT);
 277                     }
 278                     else
 279                     {
 280                         if (((Creature*)unit)->IsMounted())
 281                         {
 282                             // seems to be often when mounted
 283                             unit->m_movementInfo.AddMovementFlag(MOVEFLAG_FLYING);
 284                         }
 285                     }
 286                 }
 287             }
 288             break;
 289             case TYPEID_PLAYER:
 290             {
 291                 Player *player = ((Player*)unit);
 292
 293                 if(player->GetTransport())
 294                     player->m_movementInfo.AddMovementFlag(MOVEFLAG_ONTRANSPORT);
 295                 else
 296                     player->m_movementInfo.RemoveMovementFlag(MOVEFLAG_ONTRANSPORT);
 297
 298                 // remove unknown, unused etc flags for now
 299                 player->m_movementInfo.RemoveMovementFlag(MOVEFLAG_SPLINE_ENABLED);
 300
 301                 if(player->isInFlight())
 302                 {
 303                     ASSERT(player->GetMotionMaster()->GetCurrentMovementGeneratorType() == FLIGHT_MOTION_TYPE);
 304                     player->m_movementInfo.AddMovementFlag(MOVEFLAG_FORWARD);
 305                     player->m_movementInfo.AddMovementFlag(MOVEFLAG_SPLINE_ENABLED);
 306                 }
 307             }
 308             break;
 309         }
 310
 311         // Update movement info time
 312         unit->m_movementInfo.UpdateTime(getMSTime());
 313         // Write movement info
 314         unit->m_movementInfo.Write(*data);
 315
 316         // Unit speeds
 317         *data << float(unit->GetSpeed(MOVE_WALK));
 318         *data << float(unit->GetSpeed(MOVE_RUN));
 319         *data << float(unit->GetSpeed(MOVE_SWIM_BACK));
 320         *data << float(unit->GetSpeed(MOVE_SWIM));
 321         *data << float(unit->GetSpeed(MOVE_RUN_BACK));
 322         *data << float(unit->GetSpeed(MOVE_FLIGHT));
 323         *data << float(unit->GetSpeed(MOVE_FLIGHT_BACK));
 324         *data << float(unit->GetSpeed(MOVE_TURN_RATE));
 325         *data << float(unit->GetSpeed(MOVE_PITCH_RATE));
 326
 327         // 0x08000000
 328         if(unit->m_movementInfo.GetMovementFlags() & MOVEFLAG_SPLINE_ENABLED)
 329         {
 330             if(GetTypeId() != TYPEID_PLAYER)
 331             {
 332                 sLog.outDebug("_BuildMovementUpdate: MOVEFLAG_SPLINE_ENABLED for non-player");
 333                 return;
 334             }
 335
 336             Player *player = ((Player*)unit);
 337
 338             if(!player->isInFlight())
 339             {
 340                 sLog.outDebug("_BuildMovementUpdate: MOVEFLAG_SPLINE_ENABLED but not in flight");
 341                 return;
 342             }
 343
 344             ASSERT(player->GetMotionMaster()->GetCurrentMovementGeneratorType() == FLIGHT_MOTION_TYPE);
 345
 346             FlightPathMovementGenerator *fmg = (FlightPathMovementGenerator*)(player->GetMotionMaster()->top());
 347
 348             uint32 flags3 = SPLINEFLAG_WALKMODE | SPLINEFLAG_FLYING;
 349
 350             *data << uint32(flags3);                        // splines flag?
 351
 352             if(flags3 & SPLINEFLAG_FINALFACING)             // may be orientation
 353             {
 354                 *data << float(0);
 355             }
 356             else
 357             {
 358                 if(flags3 & SPLINEFLAG_FINALTARGET)         // probably guid there
 359                 {
 360                     *data << uint64(0);
 361                 }
 362                 else
 363                 {
 364                     if(flags3 & SPLINEFLAG_FINALPOINT)      // probably x,y,z coords there
 365                     {
 366                         *data << float(0);
 367                         *data << float(0);
 368                         *data << float(0);
 369                     }
 370                 }
 371             }
 372
 373             Path &path = fmg->GetPath();
 374
 375             float x, y, z;
 376             player->GetPosition(x, y, z);
 377
 378             uint32 inflighttime = uint32(path.GetPassedLength(fmg->GetCurrentNode(), x, y, z) * 32);
 379             uint32 traveltime = uint32(path.GetTotalLength() * 32);
 380
 381             *data << uint32(inflighttime);                  // passed move time?
 382             *data << uint32(traveltime);                    // full move time?
 383             *data << uint32(0);                             // sequenceId
 384
 385             *data << float(0);                              // added in 3.1
 386             *data << float(0);                              // added in 3.1
 387             *data << float(0);                              // added in 3.1
 388
 389             *data << uint32(0);                             // added in 3.1
 390
 391             uint32 poscount = uint32(path.Size());
 392             *data << uint32(poscount);                      // points count
 393
 394             for(uint32 i = 0; i < poscount; ++i)
 395             {
 396                 *data << float(path.GetNodes()[i].x);
 397                 *data << float(path.GetNodes()[i].y);
 398                 *data << float(path.GetNodes()[i].z);
 399             }
 400
 401             *data << uint8(0);                              // splineMode
 402
 403             *data << float(path.GetNodes()[poscount-1].x);
 404             *data << float(path.GetNodes()[poscount-1].y);
 405             *data << float(path.GetNodes()[poscount-1].z);
 406         }
 407     }
 408     else
 409     {
 410         if(updateFlags & UPDATEFLAG_POSITION)
 411         {
 412             *data << uint8(0);                              // unk PGUID!
 413             *data << float(((WorldObject*)this)->GetPositionX());
 414             *data << float(((WorldObject*)this)->GetPositionY());
 415             *data << float(((WorldObject*)this)->GetPositionZ());
 416             *data << float(((WorldObject*)this)->GetPositionX());
 417             *data << float(((WorldObject*)this)->GetPositionY());
 418             *data << float(((WorldObject*)this)->GetPositionZ());
 419             *data << float(((WorldObject*)this)->GetOrientation());
 420
 421             if(GetTypeId() == TYPEID_CORPSE)
 422                 *data << float(((WorldObject*)this)->GetOrientation());
 423             else
 424                 *data << float(0);
 425         }
 426         else
 427         {
 428             // 0x40
 429             if (updateFlags & UPDATEFLAG_HAS_POSITION)
 430             {
 431                 // 0x02
 432                 if(updateFlags & UPDATEFLAG_TRANSPORT && ((GameObject*)this)->GetGoType() == GAMEOBJECT_TYPE_MO_TRANSPORT)
 433                 {
 434                     *data << float(0);
 435                     *data << float(0);
 436                     *data << float(0);
 437                     *data << float(((WorldObject *)this)->GetOrientation());
 438                 }
 439                 else
 440                 {
 441                     *data << float(((WorldObject *)this)->GetPositionX());
 442                     *data << float(((WorldObject *)this)->GetPositionY());
 443                     *data << float(((WorldObject *)this)->GetPositionZ());
 444                     *data << float(((WorldObject *)this)->GetOrientation());
 445                 }
 446             }
 447         }
 448     }
 449
 450     // 0x8
 451     if(updateFlags & UPDATEFLAG_LOWGUID)
 452     {
 453         switch(GetTypeId())
 454         {
 455             case TYPEID_OBJECT:
 456             case TYPEID_ITEM:
 457             case TYPEID_CONTAINER:
 458             case TYPEID_GAMEOBJECT:
 459             case TYPEID_DYNAMICOBJECT:
 460             case TYPEID_CORPSE:
 461                 *data << uint32(GetGUIDLow());              // GetGUIDLow()
 462                 break;
 463             case TYPEID_UNIT:
 464                 *data << uint32(0x0000000B);                // unk, can be 0xB or 0xC
 465                 break;
 466             case TYPEID_PLAYER:
 467                 if(updateFlags & UPDATEFLAG_SELF)
 468                     *data << uint32(0x0000002F);            // unk, can be 0x15 or 0x22
 469                 else
 470                     *data << uint32(0x00000008);            // unk, can be 0x7 or 0x8
 471                 break;
 472             default:
 473                 *data << uint32(0x00000000);                // unk
 474                 break;
 475         }
 476     }
 477
 478     // 0x10
 479     if(updateFlags & UPDATEFLAG_HIGHGUID)
 480     {
 481         switch(GetTypeId())
 482         {
 483             case TYPEID_OBJECT:
 484             case TYPEID_ITEM:
 485             case TYPEID_CONTAINER:
 486             case TYPEID_GAMEOBJECT:
 487             case TYPEID_DYNAMICOBJECT:
 488             case TYPEID_CORPSE:
 489                 *data << uint32(GetObjectGuid().GetHigh()); // GetGUIDHigh()
 490                 break;
 491             case TYPEID_UNIT:
 492                 *data << uint32(0x0000000B);                // unk, can be 0xB or 0xC
 493                 break;
 494             case TYPEID_PLAYER:
 495                 if(updateFlags & UPDATEFLAG_SELF)
 496                     *data << uint32(0x0000002F);            // unk, can be 0x15 or 0x22
 497                 else
 498                     *data << uint32(0x00000008);            // unk, can be 0x7 or 0x8
 499                 break;
 500             default:
 501                 *data << uint32(0x00000000);                // unk
 502                 break;
 503         }
 504     }
 505
 506     // 0x4
 507     if(updateFlags & UPDATEFLAG_HAS_ATTACKING_TARGET)       // packed guid (current target guid)
 508     {
 509         if (((Unit*)this)->getVictim())
 510             *data << ((Unit*)this)->getVictim()->GetPackGUID();
 511         else
 512             data->appendPackGUID(0);
 513     }
 514
 515     // 0x2
 516     if(updateFlags & UPDATEFLAG_TRANSPORT)
 517     {
 518         *data << uint32(getMSTime());                       // ms time
 519     }
 520
 521     // 0x80
 522     if(updateFlags & UPDATEFLAG_VEHICLE)                    // unused for now
 523     {
 524         *data << uint32(((Vehicle*)this)->GetVehicleId());  // vehicle id
 525         *data << float(((WorldObject*)this)->GetOrientation());
 526     }
 527
 528     // 0x200
 529     if(updateFlags & UPDATEFLAG_ROTATION)
 530     {
 531         *data << uint64(((GameObject*)this)->GetRotation());
 532     }
 533 }
 534
 535 void Object::BuildValuesUpdate(uint8 updatetype, ByteBuffer * data, UpdateMask *updateMask, Player *target) const
 536 {
 537     if(!target)
 538         return;
 539
 540     bool IsActivateToQuest = false;
 541     bool IsPerCasterAuraState = false;
 542     if (updatetype == UPDATETYPE_CREATE_OBJECT || updatetype == UPDATETYPE_CREATE_OBJECT2)
 543     {
 544         if (isType(TYPEMASK_GAMEOBJECT) && !((GameObject*)this)->IsTransport())
 545         {
 546             if ( ((GameObject*)this)->ActivateToQuest(target) || target->isGameMaster())
 547                 IsActivateToQuest = true;
 548
 549             updateMask->SetBit(GAMEOBJECT_DYNAMIC);
 550         }
 551         else if (isType(TYPEMASK_UNIT))
 552         {
 553             if( ((Unit*)this)->HasAuraState(AURA_STATE_CONFLAGRATE))
 554             {
 555                 IsPerCasterAuraState = true;
 556                 updateMask->SetBit(UNIT_FIELD_AURASTATE);
 557             }
 558         }
 559     }
 560     else                                                    // case UPDATETYPE_VALUES
 561     {
 562         if (isType(TYPEMASK_GAMEOBJECT) && !((GameObject*)this)->IsTransport())
 563         {
 564             if ( ((GameObject*)this)->ActivateToQuest(target) || target->isGameMaster())
 565             {
 566                 IsActivateToQuest = true;
 567             }
 568             updateMask->SetBit(GAMEOBJECT_DYNAMIC);
 569             updateMask->SetBit(GAMEOBJECT_BYTES_1);
 570         }
 571         else if (isType(TYPEMASK_UNIT))
 572         {
 573             if( ((Unit*)this)->HasAuraState(AURA_STATE_CONFLAGRATE))
 574             {
 575                 IsPerCasterAuraState = true;
 576                 updateMask->SetBit(UNIT_FIELD_AURASTATE);
 577             }
 578         }
 579     }
 580
 581     ASSERT(updateMask && updateMask->GetCount() == m_valuesCount);
 582
 583     *data << (uint8)updateMask->GetBlockCount();
 584     data->append( updateMask->GetMask(), updateMask->GetLength() );
 585
 586     // 2 specialized loops for speed optimization in non-unit case
 587     if(isType(TYPEMASK_UNIT))                               // unit (creature/player) case
 588     {
 589         for( uint16 index = 0; index < m_valuesCount; ++index )
 590         {
 591             if( updateMask->GetBit( index ) )
 592             {
 593                 if( index == UNIT_NPC_FLAGS )
 594                 {
 595                     // remove custom flag before sending
 596                     uint32 appendValue = m_uint32Values[ index ] & ~UNIT_NPC_FLAG_GUARD;
 597
 598                     if (GetTypeId() == TYPEID_UNIT)
 599                     {
 600                         if (!target->canSeeSpellClickOn((Creature*)this))
 601                             appendValue &= ~UNIT_NPC_FLAG_SPELLCLICK;
 602
 603                         if (appendValue & UNIT_NPC_FLAG_TRAINER)
 604                         {
 605                             if (!((Creature*)this)->isCanTrainingOf(target, false))
 606                                 appendValue &= ~(UNIT_NPC_FLAG_TRAINER | UNIT_NPC_FLAG_TRAINER_CLASS | UNIT_NPC_FLAG_TRAINER_PROFESSION);
 607                         }
 608
 609                         if (appendValue & UNIT_NPC_FLAG_STABLEMASTER)
 610                         {
 611                             if (target->getClass() != CLASS_HUNTER)
 612                                 appendValue &= ~UNIT_NPC_FLAG_STABLEMASTER;
 613                         }
 614                     }
 615
 616                     *data << uint32(appendValue);
 617                 }
 618                 else if (index == UNIT_FIELD_AURASTATE)
 619                 {
 620                     if(IsPerCasterAuraState)
 621                     {
 622                         // IsPerCasterAuraState set if related pet caster aura state set already
 623                         if (((Unit*)this)->HasAuraStateForCaster(AURA_STATE_CONFLAGRATE,target->GetGUID()))
 624                             *data << m_uint32Values[ index ];
 625                         else
 626                             *data << (m_uint32Values[ index ] & ~(1 << (AURA_STATE_CONFLAGRATE-1)));
 627                     }
 628                     else
 629                         *data << m_uint32Values[ index ];
 630                 }
 631                 // FIXME: Some values at server stored in float format but must be sent to client in uint32 format
 632                 else if(index >= UNIT_FIELD_BASEATTACKTIME && index <= UNIT_FIELD_RANGEDATTACKTIME)
 633                 {
 634                     // convert from float to uint32 and send
 635                     *data << uint32(m_floatValues[ index ] < 0 ? 0 : m_floatValues[ index ]);
 636                 }
 637
 638                 // there are some float values which may be negative or can't get negative due to other checks
 639                 else if ((index >= UNIT_FIELD_NEGSTAT0   && index <= UNIT_FIELD_NEGSTAT4) ||
 640                     (index >= UNIT_FIELD_RESISTANCEBUFFMODSPOSITIVE  && index <= (UNIT_FIELD_RESISTANCEBUFFMODSPOSITIVE + 6)) ||
 641                     (index >= UNIT_FIELD_RESISTANCEBUFFMODSNEGATIVE  && index <= (UNIT_FIELD_RESISTANCEBUFFMODSNEGATIVE + 6)) ||
 642                     (index >= UNIT_FIELD_POSSTAT0   && index <= UNIT_FIELD_POSSTAT4))
 643                 {
 644                     *data << uint32(m_floatValues[ index ]);
 645                 }
 646
 647                 // Gamemasters should be always able to select units - remove not selectable flag
 648                 else if(index == UNIT_FIELD_FLAGS && target->isGameMaster())
 649                 {
 650                     *data << (m_uint32Values[ index ] & ~UNIT_FLAG_NOT_SELECTABLE);
 651                 }
 652                 // hide lootable animation for unallowed players
 653                 else if(index == UNIT_DYNAMIC_FLAGS && GetTypeId() == TYPEID_UNIT)
 654                 {
 655                     if(!target->isAllowedToLoot((Creature*)this))
 656                         *data << (m_uint32Values[ index ] & ~UNIT_DYNFLAG_LOOTABLE);
 657                     else
 658                         *data << (m_uint32Values[ index ] & ~UNIT_DYNFLAG_TAPPED);
 659                 }
 660                 else
 661                 {
 662                     // send in current format (float as float, uint32 as uint32)
 663                     *data << m_uint32Values[ index ];
 664                 }
 665             }
 666         }
 667     }
 668     else if(isType(TYPEMASK_GAMEOBJECT))                    // gameobject case
 669     {
 670         for( uint16 index = 0; index < m_valuesCount; ++index )
 671         {
 672             if( updateMask->GetBit( index ) )
 673             {
 674                 // send in current format (float as float, uint32 as uint32)
 675                 if ( index == GAMEOBJECT_DYNAMIC )
 676                 {
 677                     if(IsActivateToQuest )
 678                     {
 679                         switch(((GameObject*)this)->GetGoType())
 680                         {
 681                             case GAMEOBJECT_TYPE_CHEST:
 682                                 // enable quest object. Represent 9, but 1 for client before 2.3.0
 683                                 *data << uint16(9);
 684                                 *data << uint16(-1);
 685                                 break;
 686                             case GAMEOBJECT_TYPE_GOOBER:
 687                                 *data << uint16(1);
 688                                 *data << uint16(-1);
 689                                 break;
 690                             default:
 691                                 // unknown, not happen.
 692                                 *data << uint16(0);
 693                                 *data << uint16(-1);
 694                                 break;
 695                         }
 696                     }
 697                     else
 698                     {
 699                         // disable quest object
 700                         *data << uint16(0);
 701                         *data << uint16(-1);
 702                     }
 703                 }
 704                 else
 705                     *data << m_uint32Values[ index ];       // other cases
 706             }
 707         }
 708     }
 709     else                                                    // other objects case (no special index checks)
 710     {
 711         for( uint16 index = 0; index < m_valuesCount; ++index )
 712         {
 713             if( updateMask->GetBit( index ) )
 714             {
 715                 // send in current format (float as float, uint32 as uint32)
 716                 *data << m_uint32Values[ index ];
 717             }
 718         }
 719     }
 720 }
 721
 722 void Object::ClearUpdateMask(bool remove)
 723 {
 724     if(m_uint32Values)
 725     {
 726         for( uint16 index = 0; index < m_valuesCount; ++index )
 727         {
 728             if(m_uint32Values_mirror[index]!= m_uint32Values[index])
 729                 m_uint32Values_mirror[index] = m_uint32Values[index];
 730         }
 731     }
 732
 733     if(m_objectUpdated)
 734     {
 735         if(remove)
 736             RemoveFromClientUpdateList();
 737         m_objectUpdated = false;
 738     }
 739 }
 740
 741 bool Object::LoadValues(const char* data)
 742 {
 743     if(!m_uint32Values) _InitValues();
 744
 745     Tokens tokens = StrSplit(data, " ");
 746
 747     if(tokens.size() != m_valuesCount)
 748         return false;
 749
 750     Tokens::iterator iter;
 751     int index;
 752     for (iter = tokens.begin(), index = 0; index < m_valuesCount; ++iter, ++index)
 753     {
 754         m_uint32Values[index] = atol((*iter).c_str());
 755     }
 756
 757     return true;
 758 }
 759
 760 void Object::_SetUpdateBits(UpdateMask *updateMask, Player* /*target*/) const
 761 {
 762     for( uint16 index = 0; index < m_valuesCount; ++index )
 763     {
 764         if(m_uint32Values_mirror[index]!= m_uint32Values[index])
 765             updateMask->SetBit(index);
 766     }
 767 }
 768
 769 void Object::_SetCreateBits(UpdateMask *updateMask, Player* /*target*/) const
 770 {
 771     for( uint16 index = 0; index < m_valuesCount; ++index )
 772     {
 773         if(GetUInt32Value(index) != 0)
 774             updateMask->SetBit(index);
 775     }
 776 }
 777
 778 void Object::SetInt32Value( uint16 index, int32 value )
 779 {
 780     ASSERT( index < m_valuesCount || PrintIndexError( index, true ) );
 781
 782     if(m_int32Values[ index ] != value)
 783     {
 784         m_int32Values[ index ] = value;
 785
 786         if(m_inWorld)
 787         {
 788             if(!m_objectUpdated)
 789             {
 790                 AddToClientUpdateList();
 791                 m_objectUpdated = true;
 792             }
 793         }
 794     }
 795 }
 796
 797 void Object::SetUInt32Value( uint16 index, uint32 value )
 798 {
 799     ASSERT( index < m_valuesCount || PrintIndexError( index, true ) );
 800
 801     if(m_uint32Values[ index ] != value)
 802     {
 803         m_uint32Values[ index ] = value;
 804
 805         if(m_inWorld)
 806         {
 807             if(!m_objectUpdated)
 808             {
 809                 AddToClientUpdateList();
 810                 m_objectUpdated = true;
 811             }
 812         }
 813     }
 814 }
 815
 816 void Object::SetUInt64Value( uint16 index, const uint64 &value )
 817 {
 818     ASSERT( index + 1 < m_valuesCount || PrintIndexError( index, true ) );
 819     if(*((uint64*)&(m_uint32Values[ index ])) != value)
 820     {
 821         m_uint32Values[ index ] = *((uint32*)&value);
 822         m_uint32Values[ index + 1 ] = *(((uint32*)&value) + 1);
 823
 824         if(m_inWorld)
 825         {
 826             if(!m_objectUpdated)
 827             {
 828                 AddToClientUpdateList();
 829                 m_objectUpdated = true;
 830             }
 831         }
 832     }
 833 }
 834
 835 void Object::SetFloatValue( uint16 index, float value )
 836 {
 837     ASSERT( index < m_valuesCount || PrintIndexError( index, true ) );
 838
 839     if(m_floatValues[ index ] != value)
 840     {
 841         m_floatValues[ index ] = value;
 842
 843         if(m_inWorld)
 844         {
 845             if(!m_objectUpdated)
 846             {
 847                 AddToClientUpdateList();
 848                 m_objectUpdated = true;
 849             }
 850         }
 851     }
 852 }
 853
 854 void Object::SetByteValue( uint16 index, uint8 offset, uint8 value )
 855 {
 856     ASSERT( index < m_valuesCount || PrintIndexError( index, true ) );
 857
 858     if(offset > 4)
 859     {
 860         sLog.outError("Object::SetByteValue: wrong offset %u", offset);
 861         return;
 862     }
 863
 864     if(uint8(m_uint32Values[ index ] >> (offset * 8)) != value)
 865     {
 866         m_uint32Values[ index ] &= ~uint32(uint32(0xFF) << (offset * 8));
 867         m_uint32Values[ index ] |= uint32(uint32(value) << (offset * 8));
 868
 869         if(m_inWorld)
 870         {
 871             if(!m_objectUpdated)
 872             {
 873                 AddToClientUpdateList();
 874                 m_objectUpdated = true;
 875             }
 876         }
 877     }
 878 }
 879
 880 void Object::SetUInt16Value( uint16 index, uint8 offset, uint16 value )
 881 {
 882     ASSERT( index < m_valuesCount || PrintIndexError( index, true ) );
 883
 884     if(offset > 2)
 885     {
 886         sLog.outError("Object::SetUInt16Value: wrong offset %u", offset);
 887         return;
 888     }
 889
 890     if(uint16(m_uint32Values[ index ] >> (offset * 16)) != value)
 891     {
 892         m_uint32Values[ index ] &= ~uint32(uint32(0xFFFF) << (offset * 16));
 893         m_uint32Values[ index ] |= uint32(uint32(value) << (offset * 16));
 894
 895         if(m_inWorld)
 896         {
 897             if(!m_objectUpdated)
 898             {
 899                 AddToClientUpdateList();
 900                 m_objectUpdated = true;
 901             }
 902         }
 903     }
 904 }
 905
 906 void Object::SetStatFloatValue( uint16 index, float value)
 907 {
 908     if(value < 0)
 909         value = 0.0f;
 910
 911     SetFloatValue(index, value);
 912 }
 913
 914 void Object::SetStatInt32Value( uint16 index, int32 value)
 915 {
 916     if(value < 0)
 917         value = 0;
 918
 919     SetUInt32Value(index, uint32(value));
 920 }
 921
 922 void Object::ApplyModUInt32Value(uint16 index, int32 val, bool apply)
 923 {
 924     int32 cur = GetUInt32Value(index);
 925     cur += (apply ? val : -val);
 926     if(cur < 0)
 927         cur = 0;
 928     SetUInt32Value(index, cur);
 929 }
 930
 931 void Object::ApplyModInt32Value(uint16 index, int32 val, bool apply)
 932 {
 933     int32 cur = GetInt32Value(index);
 934     cur += (apply ? val : -val);
 935     SetInt32Value(index, cur);
 936 }
 937
 938 void Object::ApplyModSignedFloatValue(uint16 index, float  val, bool apply)
 939 {
 940     float cur = GetFloatValue(index);
 941     cur += (apply ? val : -val);
 942     SetFloatValue(index, cur);
 943 }
 944
 945 void Object::ApplyModPositiveFloatValue(uint16 index, float  val, bool apply)
 946 {
 947     float cur = GetFloatValue(index);
 948     cur += (apply ? val : -val);
 949     if(cur < 0)
 950         cur = 0;
 951     SetFloatValue(index, cur);
 952 }
 953
 954 void Object::SetFlag( uint16 index, uint32 newFlag )
 955 {
 956     ASSERT( index < m_valuesCount || PrintIndexError( index, true ) );
 957     uint32 oldval = m_uint32Values[ index ];
 958     uint32 newval = oldval | newFlag;
 959
 960     if(oldval != newval)
 961     {
 962         m_uint32Values[ index ] = newval;
 963
 964         if(m_inWorld)
 965         {
 966             if(!m_objectUpdated)
 967             {
 968                 AddToClientUpdateList();
 969                 m_objectUpdated = true;
 970             }
 971         }
 972     }
 973 }
 974
 975 void Object::RemoveFlag( uint16 index, uint32 oldFlag )
 976 {
 977     ASSERT( index < m_valuesCount || PrintIndexError( index, true ) );
 978     uint32 oldval = m_uint32Values[ index ];
 979     uint32 newval = oldval & ~oldFlag;
 980
 981     if(oldval != newval)
 982     {
 983         m_uint32Values[ index ] = newval;
 984
 985         if(m_inWorld)
 986         {
 987             if(!m_objectUpdated)
 988             {
 989                 AddToClientUpdateList();
 990                 m_objectUpdated = true;
 991             }
 992         }
 993     }
 994 }
 995
 996 void Object::SetByteFlag( uint16 index, uint8 offset, uint8 newFlag )
 997 {
 998     ASSERT( index < m_valuesCount || PrintIndexError( index, true ) );
 999
1000     if(offset > 4)
1001     {
1002         sLog.outError("Object::SetByteFlag: wrong offset %u", offset);
1003         return;
1004     }
1005
1006     if(!(uint8(m_uint32Values[ index ] >> (offset * 8)) & newFlag))
1007     {
1008         m_uint32Values[ index ] |= uint32(uint32(newFlag) << (offset * 8));
1009
1010         if(m_inWorld)
1011         {
1012             if(!m_objectUpdated)
1013             {
1014                 AddToClientUpdateList();
1015                 m_objectUpdated = true;
1016             }
1017         }
1018     }
1019 }
1020
1021 void Object::RemoveByteFlag( uint16 index, uint8 offset, uint8 oldFlag )
1022 {
1023     ASSERT( index < m_valuesCount || PrintIndexError( index, true ) );
1024
1025     if(offset > 4)
1026     {
1027         sLog.outError("Object::RemoveByteFlag: wrong offset %u", offset);
1028         return;
1029     }
1030
1031     if(uint8(m_uint32Values[ index ] >> (offset * 8)) & oldFlag)
1032     {
1033         m_uint32Values[ index ] &= ~uint32(uint32(oldFlag) << (offset * 8));
1034
1035         if(m_inWorld)
1036         {
1037             if(!m_objectUpdated)
1038             {
1039                 AddToClientUpdateList();
1040                 m_objectUpdated = true;
1041             }
1042         }
1043     }
1044 }
1045
1046 bool Object::PrintIndexError(uint32 index, bool set) const
1047 {
1048     sLog.outError("Attempt %s non-existed value field: %u (count: %u) for object typeid: %u type mask: %u",(set ? "set value to" : "get value from"),index,m_valuesCount,GetTypeId(),m_objectType);
1049
1050     // assert must fail after function call
1051     return false;
1052 }
1053
1054 void Object::BuildUpdateDataForPlayer(Player* pl, UpdateDataMapType& update_players)
1055 {
1056     UpdateDataMapType::iterator iter = update_players.find(pl);
1057
1058     if (iter == update_players.end())
1059     {
1060         std::pair<UpdateDataMapType::iterator, bool> p = update_players.insert( UpdateDataMapType::value_type(pl, UpdateData()) );
1061         assert(p.second);
1062         iter = p.first;
1063     }
1064
1065     BuildValuesUpdateBlockForPlayer(&iter->second, iter->first);
1066 }
1067
1068 void Object::AddToClientUpdateList()
1069 {
1070     sLog.outError("Unexpected call of Object::AddToClientUpdateList for object (TypeId: %u Update fields: %u)",GetTypeId(), m_valuesCount);
1071     ASSERT(false);
1072 }
1073
1074 void Object::RemoveFromClientUpdateList()
1075 {
1076     sLog.outError("Unexpected call of Object::RemoveFromClientUpdateList for object (TypeId: %u Update fields: %u)",GetTypeId(), m_valuesCount);
1077     ASSERT(false);
1078 }
1079
1080 void Object::BuildUpdateData( UpdateDataMapType& /*update_players */)
1081 {
1082     sLog.outError("Unexpected call of Object::BuildUpdateData for object (TypeId: %u Update fields: %u)",GetTypeId(), m_valuesCount);
1083     ASSERT(false);
1084 }
1085
1086 WorldObject::WorldObject()
1087     : m_currMap(NULL), m_mapId(0), m_InstanceId(0), m_phaseMask(PHASEMASK_NORMAL),
1088     m_positionX(0.0f), m_positionY(0.0f), m_positionZ(0.0f), m_orientation(0.0f)
1089 {
1090 }
1091
1092 void WorldObject::CleanupsBeforeDelete()
1093 {
1094     RemoveFromWorld();
1095 }
1096
1097 void WorldObject::_Create( uint32 guidlow, HighGuid guidhigh, uint32 phaseMask )
1098 {
1099     Object::_Create(guidlow, 0, guidhigh);
1100     m_phaseMask = phaseMask;
1101 }
1102
1103 void WorldObject::Relocate(float x, float y, float z, float orientation)
1104 {
1105     m_positionX = x;
1106     m_positionY = y;
1107     m_positionZ = z;
1108     m_orientation = orientation;
1109
1110     if(isType(TYPEMASK_UNIT))
1111         ((Unit*)this)->m_movementInfo.ChangePosition(x, y, z, orientation);
1112 }
1113
1114 void WorldObject::Relocate(float x, float y, float z)
1115 {
1116     m_positionX = x;
1117     m_positionY = y;
1118     m_positionZ = z;
1119
1120     if(isType(TYPEMASK_UNIT))
1121         ((Unit*)this)->m_movementInfo.ChangePosition(x, y, z, GetOrientation());
1122 }
1123
1124 uint32 WorldObject::GetZoneId() const
1125 {
1126     return GetBaseMap()->GetZoneId(m_positionX, m_positionY, m_positionZ);
1127 }
1128
1129 uint32 WorldObject::GetAreaId() const
1130 {
1131     return GetBaseMap()->GetAreaId(m_positionX, m_positionY, m_positionZ);
1132 }
1133
1134 void WorldObject::GetZoneAndAreaId(uint32& zoneid, uint32& areaid) const
1135 {
1136     GetBaseMap()->GetZoneAndAreaId(zoneid, areaid, m_positionX, m_positionY, m_positionZ);
1137 }
1138
1139 InstanceData* WorldObject::GetInstanceData()
1140 {
1141     Map *map = GetMap();
1142     return map->IsDungeon() ? ((InstanceMap*)map)->GetInstanceData() : NULL;
1143 }
1144
1145                                                             //slow
1146 float WorldObject::GetDistance(const WorldObject* obj) const
1147 {
1148     float dx = GetPositionX() - obj->GetPositionX();
1149     float dy = GetPositionY() - obj->GetPositionY();
1150     float dz = GetPositionZ() - obj->GetPositionZ();
1151     float sizefactor = GetObjectSize() + obj->GetObjectSize();
1152     float dist = sqrt((dx*dx) + (dy*dy) + (dz*dz)) - sizefactor;
1153     return ( dist > 0 ? dist : 0);
1154 }
1155
1156 float WorldObject::GetDistance2d(float x, float y) const
1157 {
1158     float dx = GetPositionX() - x;
1159     float dy = GetPositionY() - y;
1160     float sizefactor = GetObjectSize();
1161     float dist = sqrt((dx*dx) + (dy*dy)) - sizefactor;
1162     return ( dist > 0 ? dist : 0);
1163 }
1164
1165 float WorldObject::GetDistance(float x, float y, float z) const
1166 {
1167     float dx = GetPositionX() - x;
1168     float dy = GetPositionY() - y;
1169     float dz = GetPositionZ() - z;
1170     float sizefactor = GetObjectSize();
1171     float dist = sqrt((dx*dx) + (dy*dy) + (dz*dz)) - sizefactor;
1172     return ( dist > 0 ? dist : 0);
1173 }
1174
1175 float WorldObject::GetDistance2d(const WorldObject* obj) const
1176 {
1177     float dx = GetPositionX() - obj->GetPositionX();
1178     float dy = GetPositionY() - obj->GetPositionY();
1179     float sizefactor = GetObjectSize() + obj->GetObjectSize();
1180     float dist = sqrt((dx*dx) + (dy*dy)) - sizefactor;
1181     return ( dist > 0 ? dist : 0);
1182 }
1183
1184 float WorldObject::GetDistanceZ(const WorldObject* obj) const
1185 {
1186     float dz = fabs(GetPositionZ() - obj->GetPositionZ());
1187     float sizefactor = GetObjectSize() + obj->GetObjectSize();
1188     float dist = dz - sizefactor;
1189     return ( dist > 0 ? dist : 0);
1190 }
1191
1192 bool WorldObject::IsWithinDist3d(float x, float y, float z, float dist2compare) const
1193 {
1194     float dx = GetPositionX() - x;
1195     float dy = GetPositionY() - y;
1196     float dz = GetPositionZ() - z;
1197     float distsq = dx*dx + dy*dy + dz*dz;
1198
1199     float sizefactor = GetObjectSize();
1200     float maxdist = dist2compare + sizefactor;
1201
1202     return distsq < maxdist * maxdist;
1203 }
1204
1205 bool WorldObject::IsWithinDist2d(float x, float y, float dist2compare) const
1206 {
1207     float dx = GetPositionX() - x;
1208     float dy = GetPositionY() - y;
1209     float distsq = dx*dx + dy*dy;
1210
1211     float sizefactor = GetObjectSize();
1212     float maxdist = dist2compare + sizefactor;
1213
1214     return distsq < maxdist * maxdist;
1215 }
1216
1217 bool WorldObject::_IsWithinDist(WorldObject const* obj, float dist2compare, bool is3D) const
1218 {
1219     float dx = GetPositionX() - obj->GetPositionX();
1220     float dy = GetPositionY() - obj->GetPositionY();
1221     float distsq = dx*dx + dy*dy;
1222     if(is3D)
1223     {
1224         float dz = GetPositionZ() - obj->GetPositionZ();
1225         distsq += dz*dz;
1226     }
1227     float sizefactor = GetObjectSize() + obj->GetObjectSize();
1228     float maxdist = dist2compare + sizefactor;
1229
1230     return distsq < maxdist * maxdist;
1231 }
1232
1233 bool WorldObject::IsWithinLOSInMap(const WorldObject* obj) const
1234 {
1235     if (!IsInMap(obj)) return false;
1236     float ox,oy,oz;
1237     obj->GetPosition(ox,oy,oz);
1238     return(IsWithinLOS(ox, oy, oz ));
1239 }
1240
1241 bool WorldObject::IsWithinLOS(float ox, float oy, float oz) const
1242 {
1243     float x,y,z;
1244     GetPosition(x,y,z);
1245     VMAP::IVMapManager *vMapManager = VMAP::VMapFactory::createOrGetVMapManager();
1246     return vMapManager->isInLineOfSight(GetMapId(), x, y, z+2.0f, ox, oy, oz+2.0f);
1247 }
1248
1249 bool WorldObject::GetDistanceOrder(WorldObject const* obj1, WorldObject const* obj2, bool is3D /* = true */) const
1250 {
1251     float dx1 = GetPositionX() - obj1->GetPositionX();
1252     float dy1 = GetPositionY() - obj1->GetPositionY();
1253     float distsq1 = dx1*dx1 + dy1*dy1;
1254     if(is3D)
1255     {
1256         float dz1 = GetPositionZ() - obj1->GetPositionZ();
1257         distsq1 += dz1*dz1;
1258     }
1259
1260     float dx2 = GetPositionX() - obj2->GetPositionX();
1261     float dy2 = GetPositionY() - obj2->GetPositionY();
1262     float distsq2 = dx2*dx2 + dy2*dy2;
1263     if(is3D)
1264     {
1265         float dz2 = GetPositionZ() - obj2->GetPositionZ();
1266         distsq2 += dz2*dz2;
1267     }
1268
1269     return distsq1 < distsq2;
1270 }
1271
1272 bool WorldObject::IsInRange(WorldObject const* obj, float minRange, float maxRange, bool is3D /* = true */) const
1273 {
1274     float dx = GetPositionX() - obj->GetPositionX();
1275     float dy = GetPositionY() - obj->GetPositionY();
1276     float distsq = dx*dx + dy*dy;
1277     if(is3D)
1278     {
1279         float dz = GetPositionZ() - obj->GetPositionZ();
1280         distsq += dz*dz;
1281     }
1282
1283     float sizefactor = GetObjectSize() + obj->GetObjectSize();
1284
1285     // check only for real range
1286     if(minRange > 0.0f)
1287     {
1288         float mindist = minRange + sizefactor;
1289         if(distsq < mindist * mindist)
1290             return false;
1291     }
1292
1293     float maxdist = maxRange + sizefactor;
1294     return distsq < maxdist * maxdist;
1295 }
1296
1297 bool WorldObject::IsInRange2d(float x, float y, float minRange, float maxRange) const
1298 {
1299     float dx = GetPositionX() - x;
1300     float dy = GetPositionY() - y;
1301     float distsq = dx*dx + dy*dy;
1302
1303     float sizefactor = GetObjectSize();
1304
1305     // check only for real range
1306     if(minRange > 0.0f)
1307     {
1308         float mindist = minRange + sizefactor;
1309         if(distsq < mindist * mindist)
1310             return false;
1311     }
1312
1313     float maxdist = maxRange + sizefactor;
1314     return distsq < maxdist * maxdist;
1315 }
1316
1317 bool WorldObject::IsInRange3d(float x, float y, float z, float minRange, float maxRange) const
1318 {
1319     float dx = GetPositionX() - x;
1320     float dy = GetPositionY() - y;
1321     float dz = GetPositionZ() - z;
1322     float distsq = dx*dx + dy*dy + dz*dz;
1323
1324     float sizefactor = GetObjectSize();
1325
1326     // check only for real range
1327     if(minRange > 0.0f)
1328     {
1329         float mindist = minRange + sizefactor;
1330         if(distsq < mindist * mindist)
1331             return false;
1332     }
1333
1334     float maxdist = maxRange + sizefactor;
1335     return distsq < maxdist * maxdist;
1336 }
1337
1338 float WorldObject::GetAngle(const WorldObject* obj) const
1339 {
1340     if(!obj) return 0;
1341     return GetAngle( obj->GetPositionX(), obj->GetPositionY() );
1342 }
1343
1344 // Return angle in range 0..2*pi
1345 float WorldObject::GetAngle( const float x, const float y ) const
1346 {
1347     float dx = x - GetPositionX();
1348     float dy = y - GetPositionY();
1349
1350     float ang = atan2(dy, dx);
1351     ang = (ang >= 0) ? ang : 2 * M_PI_F + ang;
1352     return ang;
1353 }
1354
1355 bool WorldObject::HasInArc(const float arcangle, const WorldObject* obj) const
1356 {
1357     // always have self in arc
1358     if(obj == this)
1359         return true;
1360
1361     float arc = arcangle;
1362
1363     // move arc to range 0.. 2*pi
1364     while( arc >= 2.0f * M_PI_F )
1365         arc -=  2.0f * M_PI_F;
1366     while( arc < 0 )
1367         arc +=  2.0f * M_PI_F;
1368
1369     float angle = GetAngle( obj );
1370     angle -= m_orientation;
1371
1372     // move angle to range -pi ... +pi
1373     while( angle > M_PI_F)
1374         angle -= 2.0f * M_PI_F;
1375     while(angle < -M_PI_F)
1376         angle += 2.0f * M_PI_F;
1377
1378     float lborder =  -1 * (arc/2.0f);                       // in range -pi..0
1379     float rborder = (arc/2.0f);                             // in range 0..pi
1380     return (( angle >= lborder ) && ( angle <= rborder ));
1381 }
1382
1383 bool WorldObject::isInFrontInMap(WorldObject const* target, float distance,  float arc) const
1384 {
1385     return IsWithinDistInMap(target, distance) && HasInArc( arc, target );
1386 }
1387
1388 bool WorldObject::isInBackInMap(WorldObject const* target, float distance, float arc) const
1389 {
1390     return IsWithinDistInMap(target, distance) && !HasInArc( 2 * M_PI_F - arc, target );
1391 }
1392
1393 bool WorldObject::isInFront(WorldObject const* target, float distance,  float arc) const
1394 {
1395     return IsWithinDist(target, distance) && HasInArc( arc, target );
1396 }
1397
1398 bool WorldObject::isInBack(WorldObject const* target, float distance, float arc) const
1399 {
1400     return IsWithinDist(target, distance) && !HasInArc( 2 * M_PI_F - arc, target );
1401 }
1402
1403 void WorldObject::GetRandomPoint( float x, float y, float z, float distance, float &rand_x, float &rand_y, float &rand_z) const
1404 {
1405     if(distance == 0)
1406     {
1407         rand_x = x;
1408         rand_y = y;
1409         rand_z = z;
1410         return;
1411     }
1412
1413     // angle to face `obj` to `this`
1414     float angle = rand_norm_f()*2*M_PI_F;
1415     float new_dist = rand_norm_f()*distance;
1416
1417     rand_x = x + new_dist * cos(angle);
1418     rand_y = y + new_dist * sin(angle);
1419     rand_z = z;
1420
1421     MaNGOS::NormalizeMapCoord(rand_x);
1422     MaNGOS::NormalizeMapCoord(rand_y);
1423     UpdateGroundPositionZ(rand_x,rand_y,rand_z);            // update to LOS height if available
1424 }
1425
1426 void WorldObject::UpdateGroundPositionZ(float x, float y, float &z) const
1427 {
1428     float new_z = GetBaseMap()->GetHeight(x,y,z,true);
1429     if(new_z > INVALID_HEIGHT)
1430         z = new_z+ 0.05f;                                   // just to be sure that we are not a few pixel under the surface
1431 }
1432
1433 bool WorldObject::IsPositionValid() const
1434 {
1435     return MaNGOS::IsValidMapCoord(m_positionX,m_positionY,m_positionZ,m_orientation);
1436 }
1437
1438 void WorldObject::MonsterSay(const char* text, uint32 language, uint64 TargetGuid)
1439 {
1440     WorldPacket data(SMSG_MESSAGECHAT, 200);
1441     BuildMonsterChat(&data,CHAT_MSG_MONSTER_SAY,text,language,GetName(),TargetGuid);
1442     SendMessageToSetInRange(&data,sWorld.getConfig(CONFIG_FLOAT_LISTEN_RANGE_SAY),true);
1443 }
1444
1445 void WorldObject::MonsterYell(const char* text, uint32 language, uint64 TargetGuid)
1446 {
1447     WorldPacket data(SMSG_MESSAGECHAT, 200);
1448     BuildMonsterChat(&data,CHAT_MSG_MONSTER_YELL,text,language,GetName(),TargetGuid);
1449     SendMessageToSetInRange(&data,sWorld.getConfig(CONFIG_FLOAT_LISTEN_RANGE_YELL),true);
1450 }
1451
1452 void WorldObject::MonsterTextEmote(const char* text, uint64 TargetGuid, bool IsBossEmote)
1453 {
1454     WorldPacket data(SMSG_MESSAGECHAT, 200);
1455     BuildMonsterChat(&data,IsBossEmote ? CHAT_MSG_RAID_BOSS_EMOTE : CHAT_MSG_MONSTER_EMOTE,text,LANG_UNIVERSAL,GetName(),TargetGuid);
1456     SendMessageToSetInRange(&data,sWorld.getConfig(IsBossEmote ? CONFIG_FLOAT_LISTEN_RANGE_YELL : CONFIG_FLOAT_LISTEN_RANGE_TEXTEMOTE),true);
1457 }
1458
1459 void WorldObject::MonsterWhisper(const char* text, uint64 receiver, bool IsBossWhisper)
1460 {
1461     Player *player = sObjectMgr.GetPlayer(receiver);
1462     if(!player || !player->GetSession())
1463         return;
1464
1465     WorldPacket data(SMSG_MESSAGECHAT, 200);
1466     BuildMonsterChat(&data,IsBossWhisper ? CHAT_MSG_RAID_BOSS_WHISPER : CHAT_MSG_MONSTER_WHISPER,text,LANG_UNIVERSAL,GetName(),receiver);
1467
1468     player->GetSession()->SendPacket(&data);
1469 }
1470
1471 namespace MaNGOS
1472 {
1473     class MonsterChatBuilder
1474     {
1475         public:
1476             MonsterChatBuilder(WorldObject const& obj, ChatMsg msgtype, int32 textId, uint32 language, uint64 targetGUID)
1477                 : i_object(obj), i_msgtype(msgtype), i_textId(textId), i_language(language), i_targetGUID(targetGUID) {}
1478             void operator()(WorldPacket& data, int32 loc_idx)
1479             {
1480                 char const* text = sObjectMgr.GetMangosString(i_textId,loc_idx);
1481
1482                 // TODO: i_object.GetName() also must be localized?
1483                 i_object.BuildMonsterChat(&data,i_msgtype,text,i_language,i_object.GetNameForLocaleIdx(loc_idx),i_targetGUID);
1484             }
1485
1486         private:
1487             WorldObject const& i_object;
1488             ChatMsg i_msgtype;
1489             int32 i_textId;
1490             uint32 i_language;
1491             uint64 i_targetGUID;
1492     };
1493 }                                                           // namespace MaNGOS
1494
1495 void WorldObject::MonsterSay(int32 textId, uint32 language, uint64 TargetGuid)
1496 {
1497     CellPair p = MaNGOS::ComputeCellPair(GetPositionX(), GetPositionY());
1498
1499     Cell cell(p);
1500     cell.data.Part.reserved = ALL_DISTRICT;
1501     cell.SetNoCreate();
1502
1503     MaNGOS::MonsterChatBuilder say_build(*this, CHAT_MSG_MONSTER_SAY, textId,language,TargetGuid);
1504     MaNGOS::LocalizedPacketDo<MaNGOS::MonsterChatBuilder> say_do(say_build);
1505     MaNGOS::PlayerDistWorker<MaNGOS::LocalizedPacketDo<MaNGOS::MonsterChatBuilder> > say_worker(this,sWorld.getConfig(CONFIG_FLOAT_LISTEN_RANGE_SAY),say_do);
1506     TypeContainerVisitor<MaNGOS::PlayerDistWorker<MaNGOS::LocalizedPacketDo<MaNGOS::MonsterChatBuilder> >, WorldTypeMapContainer > message(say_worker);
1507     cell.Visit(p, message, *GetMap(), *this, sWorld.getConfig(CONFIG_FLOAT_LISTEN_RANGE_SAY));
1508 }
1509
1510 void WorldObject::MonsterYell(int32 textId, uint32 language, uint64 TargetGuid)
1511 {
1512     CellPair p = MaNGOS::ComputeCellPair(GetPositionX(), GetPositionY());
1513
1514     Cell cell(p);
1515     cell.data.Part.reserved = ALL_DISTRICT;
1516     cell.SetNoCreate();
1517
1518     float range = sWorld.getConfig(CONFIG_FLOAT_LISTEN_RANGE_YELL);
1519
1520     MaNGOS::MonsterChatBuilder say_build(*this, CHAT_MSG_MONSTER_YELL, textId,language,TargetGuid);
1521     MaNGOS::LocalizedPacketDo<MaNGOS::MonsterChatBuilder> say_do(say_build);
1522     MaNGOS::PlayerDistWorker<MaNGOS::LocalizedPacketDo<MaNGOS::MonsterChatBuilder> > say_worker(this,range,say_do);
1523     TypeContainerVisitor<MaNGOS::PlayerDistWorker<MaNGOS::LocalizedPacketDo<MaNGOS::MonsterChatBuilder> >, WorldTypeMapContainer > message(say_worker);
1524     cell.Visit(p, message, *GetMap(), *this, range);
1525 }
1526
1527 void WorldObject::MonsterYellToZone(int32 textId, uint32 language, uint64 TargetGuid)
1528 {
1529     MaNGOS::MonsterChatBuilder say_build(*this, CHAT_MSG_MONSTER_YELL, textId,language,TargetGuid);
1530     MaNGOS::LocalizedPacketDo<MaNGOS::MonsterChatBuilder> say_do(say_build);
1531
1532     uint32 zoneid = GetZoneId();
1533
1534     Map::PlayerList const& pList = GetMap()->GetPlayers();
1535     for(Map::PlayerList::const_iterator itr = pList.begin(); itr != pList.end(); ++itr)
1536         if(itr->getSource()->GetZoneId()==zoneid)
1537             say_do(itr->getSource());
1538 }
1539
1540 void WorldObject::MonsterTextEmote(int32 textId, uint64 TargetGuid, bool IsBossEmote)
1541 {
1542     CellPair p = MaNGOS::ComputeCellPair(GetPositionX(), GetPositionY());
1543
1544     Cell cell(p);
1545     cell.data.Part.reserved = ALL_DISTRICT;
1546     cell.SetNoCreate();
1547
1548     float range = sWorld.getConfig(IsBossEmote ? CONFIG_FLOAT_LISTEN_RANGE_YELL : CONFIG_FLOAT_LISTEN_RANGE_TEXTEMOTE);
1549
1550     MaNGOS::MonsterChatBuilder say_build(*this, IsBossEmote ? CHAT_MSG_RAID_BOSS_EMOTE : CHAT_MSG_MONSTER_EMOTE, textId,LANG_UNIVERSAL,TargetGuid);
1551     MaNGOS::LocalizedPacketDo<MaNGOS::MonsterChatBuilder> say_do(say_build);
1552     MaNGOS::PlayerDistWorker<MaNGOS::LocalizedPacketDo<MaNGOS::MonsterChatBuilder> > say_worker(this,range,say_do);
1553     TypeContainerVisitor<MaNGOS::PlayerDistWorker<MaNGOS::LocalizedPacketDo<MaNGOS::MonsterChatBuilder> >, WorldTypeMapContainer > message(say_worker);
1554     cell.Visit(p, message, *GetMap(), *this, range);
1555 }
1556
1557 void WorldObject::MonsterWhisper(int32 textId, uint64 receiver, bool IsBossWhisper)
1558 {
1559     Player *player = sObjectMgr.GetPlayer(receiver);
1560     if(!player || !player->GetSession())
1561         return;
1562
1563     uint32 loc_idx = player->GetSession()->GetSessionDbLocaleIndex();
1564     char const* text = sObjectMgr.GetMangosString(textId,loc_idx);
1565
1566     WorldPacket data(SMSG_MESSAGECHAT, 200);
1567     BuildMonsterChat(&data,IsBossWhisper ? CHAT_MSG_RAID_BOSS_WHISPER : CHAT_MSG_MONSTER_WHISPER,text,LANG_UNIVERSAL,GetNameForLocaleIdx(loc_idx),receiver);
1568
1569     player->GetSession()->SendPacket(&data);
1570 }
1571
1572 void WorldObject::BuildMonsterChat(WorldPacket *data, uint8 msgtype, char const* text, uint32 language, char const* name, uint64 targetGuid) const
1573 {
1574     *data << (uint8)msgtype;
1575     *data << (uint32)language;
1576     *data << (uint64)GetGUID();
1577     *data << (uint32)0;                                     // 2.1.0
1578     *data << (uint32)(strlen(name)+1);
1579     *data << name;
1580     *data << (uint64)targetGuid;                            // Unit Target
1581     if( targetGuid && !IS_PLAYER_GUID(targetGuid) )
1582     {
1583         *data << (uint32)1;                                 // target name length
1584         *data << (uint8)0;                                  // target name
1585     }
1586     *data << (uint32)(strlen(text)+1);
1587     *data << text;
1588     *data << (uint8)0;                                      // ChatTag
1589 }
1590
1591 void WorldObject::SendMessageToSet(WorldPacket *data, bool /*bToSelf*/)
1592 {
1593     //if object is in world, map for it already created!
1594     Map * _map = IsInWorld() ? GetMap() : sMapMgr.FindMap(GetMapId(), GetInstanceId());
1595     if(_map)
1596         _map->MessageBroadcast(this, data);
1597 }
1598
1599 void WorldObject::SendMessageToSetInRange(WorldPacket *data, float dist, bool /*bToSelf*/)
1600 {
1601     //if object is in world, map for it already created!
1602     Map * _map = IsInWorld() ? GetMap() : sMapMgr.FindMap(GetMapId(), GetInstanceId());
1603     if(_map)
1604         _map->MessageDistBroadcast(this, data, dist);
1605 }
1606
1607 void WorldObject::SendObjectDeSpawnAnim(uint64 guid)
1608 {
1609     WorldPacket data(SMSG_GAMEOBJECT_DESPAWN_ANIM, 8);
1610     data << uint64(guid);
1611     SendMessageToSet(&data, true);
1612 }
1613
1614 void WorldObject::SendGameObjectCustomAnim(uint64 guid)
1615 {
1616     WorldPacket data(SMSG_GAMEOBJECT_CUSTOM_ANIM, 8+4);
1617     data << uint64(guid);
1618     data << uint32(0);                                      // not known what this is
1619     SendMessageToSet(&data, true);
1620 }
1621
1622 void WorldObject::SetMap(Map * map)
1623 {
1624     ASSERT(map);
1625     m_currMap = map;
1626     //lets save current map's Id/instanceId
1627     m_mapId = map->GetId();
1628     m_InstanceId = map->GetInstanceId();
1629 }
1630
1631 Map const* WorldObject::GetBaseMap() const
1632 {
1633     ASSERT(m_currMap);
1634     return m_currMap->GetParent();
1635 }
1636
1637 void WorldObject::AddObjectToRemoveList()
1638 {
1639     GetMap()->AddObjectToRemoveList(this);
1640 }
1641
1642 Creature* WorldObject::SummonCreature(uint32 id, float x, float y, float z, float ang,TempSummonType spwtype,uint32 despwtime)
1643 {
1644     TemporarySummon* pCreature = new TemporarySummon(GetGUID());
1645
1646     uint32 team = 0;
1647     if (GetTypeId()==TYPEID_PLAYER)
1648         team = ((Player*)this)->GetTeam();
1649
1650     if (!pCreature->Create(sObjectMgr.GenerateLowGuid(HIGHGUID_UNIT), GetMap(), GetPhaseMask(), id, team))
1651     {
1652         delete pCreature;
1653         return NULL;
1654     }
1655
1656     if (x == 0.0f && y == 0.0f && z == 0.0f)
1657         GetClosePoint(x, y, z, pCreature->GetObjectSize());
1658
1659     pCreature->Relocate(x, y, z, ang);
1660     pCreature->SetSummonPoint(x, y, z, ang);
1661
1662     if(!pCreature->IsPositionValid())
1663     {
1664         sLog.outError("Creature (guidlow %d, entry %d) not summoned. Suggested coordinates isn't valid (X: %f Y: %f)",pCreature->GetGUIDLow(),pCreature->GetEntry(),pCreature->GetPositionX(),pCreature->GetPositionY());
1665         delete pCreature;
1666         return NULL;
1667     }
1668
1669     pCreature->Summon(spwtype, despwtime);
1670
1671     if(GetTypeId()==TYPEID_UNIT && ((Creature*)this)->AI())
1672         ((Creature*)this)->AI()->JustSummoned(pCreature);
1673
1674     // return the creature therewith the summoner has access to it
1675     return pCreature;
1676 }
1677
1678 namespace MaNGOS
1679 {
1680     class NearUsedPosDo
1681     {
1682         public:
1683             NearUsedPosDo(WorldObject const& obj, WorldObject const* searcher, float angle, ObjectPosSelector& selector)
1684                 : i_object(obj), i_searcher(searcher), i_angle(angle), i_selector(selector) {}
1685
1686             void operator()(Corpse*) const {}
1687             void operator()(DynamicObject*) const {}
1688
1689             void operator()(Creature* c) const
1690             {
1691                 // skip self or target
1692                 if(c==i_searcher || c==&i_object)
1693                     return;
1694
1695                 float x,y,z;
1696
1697                 if( !c->isAlive() || c->hasUnitState(UNIT_STAT_NOT_MOVE) ||
1698                     !c->GetMotionMaster()->GetDestination(x,y,z) )
1699                 {
1700                     x = c->GetPositionX();
1701                     y = c->GetPositionY();
1702                 }
1703
1704                 add(c,x,y);
1705             }
1706
1707             template<class T>
1708                 void operator()(T* u) const
1709             {
1710                 // skip self or target
1711                 if(u==i_searcher || u==&i_object)
1712                     return;
1713
1714                 float x,y;
1715
1716                 x = u->GetPositionX();
1717                 y = u->GetPositionY();
1718
1719                 add(u,x,y);
1720             }
1721
1722             // we must add used pos that can fill places around center
1723             void add(WorldObject* u, float x, float y) const
1724             {
1725                 // u is too nearest/far away to i_object
1726                 if(!i_object.IsInRange2d(x,y,i_selector.m_dist - i_selector.m_size,i_selector.m_dist + i_selector.m_size))
1727                     return;
1728
1729                 float angle = i_object.GetAngle(u)-i_angle;
1730
1731                 // move angle to range -pi ... +pi
1732                 while( angle > M_PI_F)
1733                     angle -= 2.0f * M_PI_F;
1734                 while(angle < -M_PI_F)
1735                     angle += 2.0f * M_PI_F;
1736
1737                 // dist include size of u
1738                 float dist2d = i_object.GetDistance2d(x,y);
1739                 i_selector.AddUsedPos(u->GetObjectSize(),angle,dist2d + i_object.GetObjectSize());
1740             }
1741         private:
1742             WorldObject const& i_object;
1743             WorldObject const* i_searcher;
1744             float              i_angle;
1745             ObjectPosSelector& i_selector;
1746     };
1747 }                                                           // namespace MaNGOS
1748
1749 //===================================================================================================
1750
1751 void WorldObject::GetNearPoint2D(float &x, float &y, float distance2d, float absAngle ) const
1752 {
1753     x = GetPositionX() + (GetObjectSize() + distance2d) * cos(absAngle);
1754     y = GetPositionY() + (GetObjectSize() + distance2d) * sin(absAngle);
1755
1756     MaNGOS::NormalizeMapCoord(x);
1757     MaNGOS::NormalizeMapCoord(y);
1758 }
1759
1760 void WorldObject::GetNearPoint(WorldObject const* searcher, float &x, float &y, float &z, float searcher_size, float distance2d, float absAngle ) const
1761 {
1762     GetNearPoint2D(x,y,distance2d+searcher_size,absAngle);
1763     z = GetPositionZ();
1764
1765     // if detection disabled, return first point
1766     if(!sWorld.getConfig(CONFIG_BOOL_DETECT_POS_COLLISION))
1767     {
1768         UpdateGroundPositionZ(x,y,z);                       // update to LOS height if available
1769         return;
1770     }
1771
1772     // or remember first point
1773     float first_x = x;
1774     float first_y = y;
1775     bool first_los_conflict = false;                        // first point LOS problems
1776
1777     // prepare selector for work
1778     ObjectPosSelector selector(GetPositionX(),GetPositionY(),GetObjectSize(),distance2d+searcher_size);
1779
1780     // adding used positions around object
1781     {
1782         CellPair p(MaNGOS::ComputeCellPair(GetPositionX(), GetPositionY()));
1783         Cell cell(p);
1784         cell.data.Part.reserved = ALL_DISTRICT;
1785         cell.SetNoCreate();
1786
1787         MaNGOS::NearUsedPosDo u_do(*this,searcher,absAngle,selector);
1788         MaNGOS::WorldObjectWorker<MaNGOS::NearUsedPosDo> worker(this,u_do);
1789
1790         TypeContainerVisitor<MaNGOS::WorldObjectWorker<MaNGOS::NearUsedPosDo>, GridTypeMapContainer  > grid_obj_worker(worker);
1791         TypeContainerVisitor<MaNGOS::WorldObjectWorker<MaNGOS::NearUsedPosDo>, WorldTypeMapContainer > world_obj_worker(worker);
1792
1793         cell.Visit(p, grid_obj_worker,  *GetMap(), *this, distance2d);
1794         cell.Visit(p, world_obj_worker, *GetMap(), *this, distance2d);
1795     }
1796
1797     // maybe can just place in primary position
1798     if( selector.CheckOriginal() )
1799     {
1800         UpdateGroundPositionZ(x,y,z);                       // update to LOS height if available
1801
1802         if(IsWithinLOS(x,y,z))
1803             return;
1804
1805         first_los_conflict = true;                          // first point have LOS problems
1806     }
1807
1808     float angle;                                            // candidate of angle for free pos
1809
1810     // special case when one from list empty and then empty side preferred
1811     if(selector.FirstAngle(angle))
1812     {
1813         GetNearPoint2D(x,y,distance2d,absAngle+angle);
1814         z = GetPositionZ();
1815         UpdateGroundPositionZ(x,y,z);                       // update to LOS height if available
1816
1817         if(IsWithinLOS(x,y,z))
1818             return;
1819     }
1820
1821     // set first used pos in lists
1822     selector.InitializeAngle();
1823
1824     // select in positions after current nodes (selection one by one)
1825     while(selector.NextAngle(angle))                        // angle for free pos
1826     {
1827         GetNearPoint2D(x,y,distance2d,absAngle+angle);
1828         z = GetPositionZ();
1829         UpdateGroundPositionZ(x,y,z);                       // update to LOS height if available
1830
1831         if(IsWithinLOS(x,y,z))
1832             return;
1833     }
1834
1835     // BAD NEWS: not free pos (or used or have LOS problems)
1836     // Attempt find _used_ pos without LOS problem
1837
1838     if(!first_los_conflict)
1839     {
1840         x = first_x;
1841         y = first_y;
1842
1843         UpdateGroundPositionZ(x,y,z);                       // update to LOS height if available
1844         return;
1845     }
1846
1847     // special case when one from list empty and then empty side preferred
1848     if( selector.IsNonBalanced() )
1849     {
1850         if(!selector.FirstAngle(angle))                     // _used_ pos
1851         {
1852             GetNearPoint2D(x,y,distance2d,absAngle+angle);
1853             z = GetPositionZ();
1854             UpdateGroundPositionZ(x,y,z);                   // update to LOS height if available
1855
1856             if(IsWithinLOS(x,y,z))
1857                 return;
1858         }
1859     }
1860
1861     // set first used pos in lists
1862     selector.InitializeAngle();
1863
1864     // select in positions after current nodes (selection one by one)
1865     while(selector.NextUsedAngle(angle))                    // angle for used pos but maybe without LOS problem
1866     {
1867         GetNearPoint2D(x,y,distance2d,absAngle+angle);
1868         z = GetPositionZ();
1869         UpdateGroundPositionZ(x,y,z);                       // update to LOS height if available
1870
1871         if(IsWithinLOS(x,y,z))
1872             return;
1873     }
1874
1875     // BAD BAD NEWS: all found pos (free and used) have LOS problem :(
1876     x = first_x;
1877     y = first_y;
1878
1879     UpdateGroundPositionZ(x,y,z);                           // update to LOS height if available
1880 }
1881
1882 void WorldObject::SetPhaseMask(uint32 newPhaseMask, bool update)
1883 {
1884     m_phaseMask = newPhaseMask;
1885
1886     if(update && IsInWorld())
1887         UpdateObjectVisibility();
1888 }
1889
1890 void WorldObject::PlayDistanceSound( uint32 sound_id, Player* target /*= NULL*/ )
1891 {
1892     WorldPacket data(SMSG_PLAY_OBJECT_SOUND,4+8);
1893     data << uint32(sound_id);
1894     data << uint64(GetGUID());
1895     if (target)
1896         target->SendDirectMessage( &data );
1897     else
1898         SendMessageToSet( &data, true );
1899 }
1900
1901 void WorldObject::PlayDirectSound( uint32 sound_id, Player* target /*= NULL*/ )
1902 {
1903     WorldPacket data(SMSG_PLAY_SOUND, 4);
1904     data << uint32(sound_id);
1905     if (target)
1906         target->SendDirectMessage( &data );
1907     else
1908         SendMessageToSet( &data, true );
1909 }
1910
1911 void WorldObject::UpdateObjectVisibility()
1912 {
1913     CellPair p = MaNGOS::ComputeCellPair(GetPositionX(), GetPositionY());
1914     Cell cell(p);
1915
1916     GetMap()->UpdateObjectVisibility(this, cell, p);
1917 }
1918
1919 void WorldObject::AddToClientUpdateList()
1920 {
1921     GetMap()->AddUpdateObject(this);
1922 }
1923
1924 void WorldObject::RemoveFromClientUpdateList()
1925 {
1926     GetMap()->RemoveUpdateObject(this);
1927 }
1928
1929 struct WorldObjectChangeAccumulator
1930 {
1931     UpdateDataMapType &i_updateDatas;
1932     WorldObject &i_object;
1933     WorldObjectChangeAccumulator(WorldObject &obj, UpdateDataMapType &d) : i_updateDatas(d), i_object(obj) {}
1934     void Visit(PlayerMapType &m)
1935     {
1936         for(PlayerMapType::iterator iter = m.begin(); iter != m.end(); ++iter)
1937             if(iter->getSource()->HaveAtClient(&i_object))
1938                 i_object.BuildUpdateDataForPlayer(iter->getSource(), i_updateDatas);
1939     }
1940
1941     template<class SKIP> void Visit(GridRefManager<SKIP> &) {}
1942 };
1943
1944 void WorldObject::BuildUpdateData( UpdateDataMapType & update_players)
1945 {
1946     CellPair p = MaNGOS::ComputeCellPair(GetPositionX(), GetPositionY());
1947     Cell cell(p);
1948     cell.data.Part.reserved = ALL_DISTRICT;
1949     cell.SetNoCreate();
1950     WorldObjectChangeAccumulator notifier(*this, update_players);
1951     TypeContainerVisitor<WorldObjectChangeAccumulator, WorldTypeMapContainer > player_notifier(notifier);
1952     Map* aMap = GetMap();
1953     //we must build packets for all visible players
1954     cell.Visit(p, player_notifier, *aMap, *this, aMap->GetVisibilityDistance());
1955
1956     ClearUpdateMask(false);
1957 }
1958
1959 bool WorldObject::IsControlledByPlayer() const
1960 {
1961     switch (GetTypeId())
1962     {
1963         case TYPEID_GAMEOBJECT:
1964             return IS_PLAYER_GUID(((GameObject*)this)->GetOwnerGUID());
1965         case TYPEID_UNIT:
1966         case TYPEID_PLAYER:
1967             return ((Unit*)this)->IsCharmerOrOwnerPlayerOrPlayerItself();
1968         case TYPEID_DYNAMICOBJECT:
1969             return IS_PLAYER_GUID(((DynamicObject*)this)->GetCasterGUID());
1970         case TYPEID_CORPSE:
1971             return true;
1972         default:
1973             return false;
1974     }
1975 }