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