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             {
 596                 IsActivateToQuest = true;
 597                 updateMask->SetBit(GAMEOBJECT_DYNAMIC);
 598             }
 599         }
 600         else if (isType(TYPEMASK_UNIT))
 601         {
 602             if( ((Unit*)this)->HasAuraState(AURA_STATE_CONFLAGRATE))
 603             {
 604                 IsPerCasterAuraState = true;
 605                 updateMask->SetBit(UNIT_FIELD_AURASTATE);
 606             }
 607         }
 608     }
 609     else                                                    // case UPDATETYPE_VALUES
 610     {
 611         if (isType(TYPEMASK_GAMEOBJECT) && !((GameObject*)this)->IsTransport())
 612         {
 613             if ( ((GameObject*)this)->ActivateToQuest(target) || target->isGameMaster())
 614             {
 615                 IsActivateToQuest = true;
 616             }
 617             updateMask->SetBit(GAMEOBJECT_DYNAMIC);
 618             updateMask->SetBit(GAMEOBJECT_BYTES_1);
 619         }
 620         else if (isType(TYPEMASK_UNIT))
 621         {
 622             if( ((Unit*)this)->HasAuraState(AURA_STATE_CONFLAGRATE))
 623             {
 624                 IsPerCasterAuraState = true;
 625                 updateMask->SetBit(UNIT_FIELD_AURASTATE);
 626             }
 627         }
 628     }
 629
 630     WPAssert(updateMask && updateMask->GetCount() == m_valuesCount);
 631
 632     *data << (uint8)updateMask->GetBlockCount();
 633     data->append( updateMask->GetMask(), updateMask->GetLength() );
 634
 635     // 2 specialized loops for speed optimization in non-unit case
 636     if(isType(TYPEMASK_UNIT))                               // unit (creature/player) case
 637     {
 638         for( uint16 index = 0; index < m_valuesCount; ++index )
 639         {
 640             if( updateMask->GetBit( index ) )
 641             {
 642                 if( index == UNIT_NPC_FLAGS )
 643                 {
 644                     // remove custom flag before sending
 645                     uint32 appendValue = m_uint32Values[ index ] & ~UNIT_NPC_FLAG_GUARD;
 646
 647                     if (GetTypeId() == TYPEID_UNIT && !target->canSeeSpellClickOn((Creature*)this))
 648                         appendValue &= ~UNIT_NPC_FLAG_SPELLCLICK;
 649
 650                     *data << uint32(appendValue);
 651                 }
 652                 else if (index == UNIT_FIELD_AURASTATE)
 653                 {
 654                     if(IsPerCasterAuraState)
 655                     {
 656                         // IsPerCasterAuraState set if related pet caster aura state set already
 657                         if (((Unit*)this)->HasAuraStateForCaster(AURA_STATE_CONFLAGRATE,target->GetGUID()))
 658                             *data << m_uint32Values[ index ];
 659                         else
 660                             *data << (m_uint32Values[ index ] & ~(1 << (AURA_STATE_CONFLAGRATE-1)));
 661                     }
 662                     else
 663                         *data << m_uint32Values[ index ];
 664                 }
 665                 // FIXME: Some values at server stored in float format but must be sent to client in uint32 format
 666                 else if(index >= UNIT_FIELD_BASEATTACKTIME && index <= UNIT_FIELD_RANGEDATTACKTIME)
 667                 {
 668                     // convert from float to uint32 and send
 669                     *data << uint32(m_floatValues[ index ] < 0 ? 0 : m_floatValues[ index ]);
 670                 }
 671                 // there are some float values which may be negative or can't get negative due to other checks
 672                 else if ((index >= UNIT_FIELD_NEGSTAT0   && index <= UNIT_FIELD_NEGSTAT4) ||
 673                     (index >= UNIT_FIELD_RESISTANCEBUFFMODSPOSITIVE  && index <= (UNIT_FIELD_RESISTANCEBUFFMODSPOSITIVE + 6)) ||
 674                     (index >= UNIT_FIELD_RESISTANCEBUFFMODSNEGATIVE  && index <= (UNIT_FIELD_RESISTANCEBUFFMODSNEGATIVE + 6)) ||
 675                     (index >= UNIT_FIELD_POSSTAT0   && index <= UNIT_FIELD_POSSTAT4))
 676                 {
 677                     *data << uint32(m_floatValues[ index ]);
 678                 }
 679                 // Gamemasters should be always able to select units - remove not selectable flag
 680                 else if(index == UNIT_FIELD_FLAGS && target->isGameMaster())
 681                 {
 682                     *data << (m_uint32Values[ index ] & ~UNIT_FLAG_NOT_SELECTABLE);
 683                 }
 684                 // hide lootable animation for unallowed players
 685                 else if(index == UNIT_DYNAMIC_FLAGS && GetTypeId() == TYPEID_UNIT)
 686                 {
 687                     if(!target->isAllowedToLoot((Creature*)this))
 688                         *data << (m_uint32Values[ index ] & ~UNIT_DYNFLAG_LOOTABLE);
 689                     else
 690                         *data << (m_uint32Values[ index ] & ~UNIT_DYNFLAG_OTHER_TAGGER);
 691                 }
 692                 else
 693                 {
 694                     // send in current format (float as float, uint32 as uint32)
 695                     *data << m_uint32Values[ index ];
 696                 }
 697             }
 698         }
 699     }
 700     else if(isType(TYPEMASK_GAMEOBJECT))                    // gameobject case
 701     {
 702         for( uint16 index = 0; index < m_valuesCount; ++index )
 703         {
 704             if( updateMask->GetBit( index ) )
 705             {
 706                 // send in current format (float as float, uint32 as uint32)
 707                 if ( index == GAMEOBJECT_DYNAMIC )
 708                 {
 709                     if(IsActivateToQuest )
 710                     {
 711                         switch(((GameObject*)this)->GetGoType())
 712                         {
 713                             case GAMEOBJECT_TYPE_CHEST:
 714                                 *data << uint32(9);         // enable quest object. Represent 9, but 1 for client before 2.3.0
 715                                 break;
 716                             case GAMEOBJECT_TYPE_GOOBER:
 717                                 *data << uint32(1);
 718                                 break;
 719                             default:
 720                                 *data << uint32(0);         // unknown, not happen.
 721                                 break;
 722                         }
 723                     }
 724                     else
 725                         *data << uint32(0);                 // disable quest object
 726                 }
 727                 else
 728                     *data << m_uint32Values[ index ];       // other cases
 729             }
 730         }
 731     }
 732     else                                                    // other objects case (no special index checks)
 733     {
 734         for( uint16 index = 0; index < m_valuesCount; ++index )
 735         {
 736             if( updateMask->GetBit( index ) )
 737             {
 738                 // send in current format (float as float, uint32 as uint32)
 739                 *data << m_uint32Values[ index ];
 740             }
 741         }
 742     }
 743 }
 744
 745 void Object::ClearUpdateMask(bool remove)
 746 {
 747     for( uint16 index = 0; index < m_valuesCount; ++index )
 748     {
 749         if(m_uint32Values_mirror[index]!= m_uint32Values[index])
 750             m_uint32Values_mirror[index] = m_uint32Values[index];
 751     }
 752     if(m_objectUpdated)
 753     {
 754         if(remove)
 755             ObjectAccessor::Instance().RemoveUpdateObject(this);
 756         m_objectUpdated = false;
 757     }
 758 }
 759
 760 // Send current value fields changes to all viewers
 761 void Object::SendUpdateObjectToAllExcept(Player* exceptPlayer)
 762 {
 763     // changes will be send in create packet
 764     if(!IsInWorld())
 765         return;
 766
 767     // nothing do
 768     if(!m_objectUpdated)
 769         return;
 770
 771     ObjectAccessor::UpdateObject(this,exceptPlayer);
 772 }
 773
 774 bool Object::LoadValues(const char* data)
 775 {
 776     if(!m_uint32Values) _InitValues();
 777
 778     Tokens tokens = StrSplit(data, " ");
 779
 780     if(tokens.size() != m_valuesCount)
 781         return false;
 782
 783     Tokens::iterator iter;
 784     int index;
 785     for (iter = tokens.begin(), index = 0; index < m_valuesCount; ++iter, ++index)
 786     {
 787         m_uint32Values[index] = atol((*iter).c_str());
 788     }
 789
 790     return true;
 791 }
 792
 793 void Object::_SetUpdateBits(UpdateMask *updateMask, Player* /*target*/) const
 794 {
 795     for( uint16 index = 0; index < m_valuesCount; ++index )
 796     {
 797         if(m_uint32Values_mirror[index]!= m_uint32Values[index])
 798             updateMask->SetBit(index);
 799     }
 800 }
 801
 802 void Object::_SetCreateBits(UpdateMask *updateMask, Player* /*target*/) const
 803 {
 804     for( uint16 index = 0; index < m_valuesCount; ++index )
 805     {
 806         if(GetUInt32Value(index) != 0)
 807             updateMask->SetBit(index);
 808     }
 809 }
 810
 811 void Object::SetInt32Value( uint16 index, int32 value )
 812 {
 813     ASSERT( index < m_valuesCount || PrintIndexError( index, true ) );
 814
 815     if(m_int32Values[ index ] != value)
 816     {
 817         m_int32Values[ index ] = value;
 818
 819         if(m_inWorld)
 820         {
 821             if(!m_objectUpdated)
 822             {
 823                 ObjectAccessor::Instance().AddUpdateObject(this);
 824                 m_objectUpdated = true;
 825             }
 826         }
 827     }
 828 }
 829
 830 void Object::SetUInt32Value( uint16 index, uint32 value )
 831 {
 832     ASSERT( index < m_valuesCount || PrintIndexError( index, true ) );
 833
 834     if(m_uint32Values[ index ] != value)
 835     {
 836         m_uint32Values[ index ] = value;
 837
 838         if(m_inWorld)
 839         {
 840             if(!m_objectUpdated)
 841             {
 842                 ObjectAccessor::Instance().AddUpdateObject(this);
 843                 m_objectUpdated = true;
 844             }
 845         }
 846     }
 847 }
 848
 849 void Object::SetUInt64Value( uint16 index, const uint64 &value )
 850 {
 851     ASSERT( index + 1 < m_valuesCount || PrintIndexError( index, true ) );
 852     if(*((uint64*)&(m_uint32Values[ index ])) != value)
 853     {
 854         m_uint32Values[ index ] = *((uint32*)&value);
 855         m_uint32Values[ index + 1 ] = *(((uint32*)&value) + 1);
 856
 857         if(m_inWorld)
 858         {
 859             if(!m_objectUpdated)
 860             {
 861                 ObjectAccessor::Instance().AddUpdateObject(this);
 862                 m_objectUpdated = true;
 863             }
 864         }
 865     }
 866 }
 867
 868 void Object::SetFloatValue( uint16 index, float value )
 869 {
 870     ASSERT( index < m_valuesCount || PrintIndexError( index, true ) );
 871
 872     if(m_floatValues[ index ] != value)
 873     {
 874         m_floatValues[ index ] = value;
 875
 876         if(m_inWorld)
 877         {
 878             if(!m_objectUpdated)
 879             {
 880                 ObjectAccessor::Instance().AddUpdateObject(this);
 881                 m_objectUpdated = true;
 882             }
 883         }
 884     }
 885 }
 886
 887 void Object::SetByteValue( uint16 index, uint8 offset, uint8 value )
 888 {
 889     ASSERT( index < m_valuesCount || PrintIndexError( index, true ) );
 890
 891     if(offset > 4)
 892     {
 893         sLog.outError("Object::SetByteValue: wrong offset %u", offset);
 894         return;
 895     }
 896
 897     if(uint8(m_uint32Values[ index ] >> (offset * 8)) != value)
 898     {
 899         m_uint32Values[ index ] &= ~uint32(uint32(0xFF) << (offset * 8));
 900         m_uint32Values[ index ] |= uint32(uint32(value) << (offset * 8));
 901
 902         if(m_inWorld)
 903         {
 904             if(!m_objectUpdated)
 905             {
 906                 ObjectAccessor::Instance().AddUpdateObject(this);
 907                 m_objectUpdated = true;
 908             }
 909         }
 910     }
 911 }
 912
 913 void Object::SetUInt16Value( uint16 index, uint8 offset, uint16 value )
 914 {
 915     ASSERT( index < m_valuesCount || PrintIndexError( index, true ) );
 916
 917     if(offset > 2)
 918     {
 919         sLog.outError("Object::SetUInt16Value: wrong offset %u", offset);
 920         return;
 921     }
 922
 923     if(uint16(m_uint32Values[ index ] >> (offset * 16)) != value)
 924     {
 925         m_uint32Values[ index ] &= ~uint32(uint32(0xFFFF) << (offset * 16));
 926         m_uint32Values[ index ] |= uint32(uint32(value) << (offset * 16));
 927
 928         if(m_inWorld)
 929         {
 930             if(!m_objectUpdated)
 931             {
 932                 ObjectAccessor::Instance().AddUpdateObject(this);
 933                 m_objectUpdated = true;
 934             }
 935         }
 936     }
 937 }
 938
 939 void Object::SetStatFloatValue( uint16 index, float value)
 940 {
 941     if(value < 0)
 942         value = 0.0f;
 943
 944     SetFloatValue(index, value);
 945 }
 946
 947 void Object::SetStatInt32Value( uint16 index, int32 value)
 948 {
 949     if(value < 0)
 950         value = 0;
 951
 952     SetUInt32Value(index, uint32(value));
 953 }
 954
 955 void Object::ApplyModUInt32Value(uint16 index, int32 val, bool apply)
 956 {
 957     int32 cur = GetUInt32Value(index);
 958     cur += (apply ? val : -val);
 959     if(cur < 0)
 960         cur = 0;
 961     SetUInt32Value(index, cur);
 962 }
 963
 964 void Object::ApplyModInt32Value(uint16 index, int32 val, bool apply)
 965 {
 966     int32 cur = GetInt32Value(index);
 967     cur += (apply ? val : -val);
 968     SetInt32Value(index, cur);
 969 }
 970
 971 void Object::ApplyModSignedFloatValue(uint16 index, float  val, bool apply)
 972 {
 973     float cur = GetFloatValue(index);
 974     cur += (apply ? val : -val);
 975     SetFloatValue(index, cur);
 976 }
 977
 978 void Object::ApplyModPositiveFloatValue(uint16 index, float  val, bool apply)
 979 {
 980     float cur = GetFloatValue(index);
 981     cur += (apply ? val : -val);
 982     if(cur < 0)
 983         cur = 0;
 984     SetFloatValue(index, cur);
 985 }
 986
 987 void Object::SetFlag( uint16 index, uint32 newFlag )
 988 {
 989     ASSERT( index < m_valuesCount || PrintIndexError( index, true ) );
 990     uint32 oldval = m_uint32Values[ index ];
 991     uint32 newval = oldval | newFlag;
 992
 993     if(oldval != newval)
 994     {
 995         m_uint32Values[ index ] = newval;
 996
 997         if(m_inWorld)
 998         {
 999             if(!m_objectUpdated)
1000             {
1001                 ObjectAccessor::Instance().AddUpdateObject(this);
1002                 m_objectUpdated = true;
1003             }
1004         }
1005     }
1006 }
1007
1008 void Object::RemoveFlag( uint16 index, uint32 oldFlag )
1009 {
1010     ASSERT( index < m_valuesCount || PrintIndexError( index, true ) );
1011     uint32 oldval = m_uint32Values[ index ];
1012     uint32 newval = oldval & ~oldFlag;
1013
1014     if(oldval != newval)
1015     {
1016         m_uint32Values[ index ] = newval;
1017
1018         if(m_inWorld)
1019         {
1020             if(!m_objectUpdated)
1021             {
1022                 ObjectAccessor::Instance().AddUpdateObject(this);
1023                 m_objectUpdated = true;
1024             }
1025         }
1026     }
1027 }
1028
1029 void Object::SetByteFlag( uint16 index, uint8 offset, uint8 newFlag )
1030 {
1031     ASSERT( index < m_valuesCount || PrintIndexError( index, true ) );
1032
1033     if(offset > 4)
1034     {
1035         sLog.outError("Object::SetByteFlag: wrong offset %u", offset);
1036         return;
1037     }
1038
1039     if(!(uint8(m_uint32Values[ index ] >> (offset * 8)) & newFlag))
1040     {
1041         m_uint32Values[ index ] |= uint32(uint32(newFlag) << (offset * 8));
1042
1043         if(m_inWorld)
1044         {
1045             if(!m_objectUpdated)
1046             {
1047                 ObjectAccessor::Instance().AddUpdateObject(this);
1048                 m_objectUpdated = true;
1049             }
1050         }
1051     }
1052 }
1053
1054 void Object::RemoveByteFlag( uint16 index, uint8 offset, uint8 oldFlag )
1055 {
1056     ASSERT( index < m_valuesCount || PrintIndexError( index, true ) );
1057
1058     if(offset > 4)
1059     {
1060         sLog.outError("Object::RemoveByteFlag: wrong offset %u", offset);
1061         return;
1062     }
1063
1064     if(uint8(m_uint32Values[ index ] >> (offset * 8)) & oldFlag)
1065     {
1066         m_uint32Values[ index ] &= ~uint32(uint32(oldFlag) << (offset * 8));
1067
1068         if(m_inWorld)
1069         {
1070             if(!m_objectUpdated)
1071             {
1072                 ObjectAccessor::Instance().AddUpdateObject(this);
1073                 m_objectUpdated = true;
1074             }
1075         }
1076     }
1077 }
1078
1079 bool Object::PrintIndexError(uint32 index, bool set) const
1080 {
1081     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);
1082
1083     // assert must fail after function call
1084     return false;
1085 }
1086
1087 WorldObject::WorldObject()
1088     : m_mapId(0), m_InstanceId(0), m_phaseMask(PHASEMASK_NORMAL),
1089     m_positionX(0.0f), m_positionY(0.0f), m_positionZ(0.0f), m_orientation(0.0f), m_currMap(NULL)
1090 {
1091 }
1092
1093 void WorldObject::CleanupsBeforeDelete()
1094 {
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 uint32 WorldObject::GetZoneId() const
1104 {
1105     return GetBaseMap()->GetZoneId(m_positionX, m_positionY, m_positionZ);
1106 }
1107
1108 uint32 WorldObject::GetAreaId() const
1109 {
1110     return GetBaseMap()->GetAreaId(m_positionX, m_positionY, m_positionZ);
1111 }
1112
1113 void WorldObject::GetZoneAndAreaId(uint32& zoneid, uint32& areaid) const
1114 {
1115     GetBaseMap()->GetZoneAndAreaId(zoneid, areaid, m_positionX, m_positionY, m_positionZ);
1116 }
1117
1118 InstanceData* WorldObject::GetInstanceData()
1119 {
1120     Map *map = GetMap();
1121     return map->IsDungeon() ? ((InstanceMap*)map)->GetInstanceData() : NULL;
1122 }
1123
1124                                                             //slow
1125 float WorldObject::GetDistance(const WorldObject* obj) const
1126 {
1127     float dx = GetPositionX() - obj->GetPositionX();
1128     float dy = GetPositionY() - obj->GetPositionY();
1129     float dz = GetPositionZ() - obj->GetPositionZ();
1130     float sizefactor = GetObjectSize() + obj->GetObjectSize();
1131     float dist = sqrt((dx*dx) + (dy*dy) + (dz*dz)) - sizefactor;
1132     return ( dist > 0 ? dist : 0);
1133 }
1134
1135 float WorldObject::GetDistance2d(float x, float y) const
1136 {
1137     float dx = GetPositionX() - x;
1138     float dy = GetPositionY() - y;
1139     float sizefactor = GetObjectSize();
1140     float dist = sqrt((dx*dx) + (dy*dy)) - sizefactor;
1141     return ( dist > 0 ? dist : 0);
1142 }
1143
1144 float WorldObject::GetDistance(float x, float y, float z) const
1145 {
1146     float dx = GetPositionX() - x;
1147     float dy = GetPositionY() - y;
1148     float dz = GetPositionZ() - z;
1149     float sizefactor = GetObjectSize();
1150     float dist = sqrt((dx*dx) + (dy*dy) + (dz*dz)) - sizefactor;
1151     return ( dist > 0 ? dist : 0);
1152 }
1153
1154 float WorldObject::GetDistance2d(const WorldObject* obj) const
1155 {
1156     float dx = GetPositionX() - obj->GetPositionX();
1157     float dy = GetPositionY() - obj->GetPositionY();
1158     float sizefactor = GetObjectSize() + obj->GetObjectSize();
1159     float dist = sqrt((dx*dx) + (dy*dy)) - sizefactor;
1160     return ( dist > 0 ? dist : 0);
1161 }
1162
1163 float WorldObject::GetDistanceZ(const WorldObject* obj) const
1164 {
1165     float dz = fabs(GetPositionZ() - obj->GetPositionZ());
1166     float sizefactor = GetObjectSize() + obj->GetObjectSize();
1167     float dist = dz - sizefactor;
1168     return ( dist > 0 ? dist : 0);
1169 }
1170
1171 bool WorldObject::IsWithinDist3d(float x, float y, float z, float dist2compare) const
1172 {
1173     float dx = GetPositionX() - x;
1174     float dy = GetPositionY() - y;
1175     float dz = GetPositionZ() - z;
1176     float distsq = dx*dx + dy*dy + dz*dz;
1177
1178     float sizefactor = GetObjectSize();
1179     float maxdist = dist2compare + sizefactor;
1180
1181     return distsq < maxdist * maxdist;
1182 }
1183
1184 bool WorldObject::IsWithinDist2d(float x, float y, float dist2compare) const
1185 {
1186     float dx = GetPositionX() - x;
1187     float dy = GetPositionY() - y;
1188     float distsq = dx*dx + dy*dy;
1189
1190     float sizefactor = GetObjectSize();
1191     float maxdist = dist2compare + sizefactor;
1192
1193     return distsq < maxdist * maxdist;
1194 }
1195
1196 bool WorldObject::_IsWithinDist(WorldObject const* obj, float dist2compare, bool is3D) const
1197 {
1198     float dx = GetPositionX() - obj->GetPositionX();
1199     float dy = GetPositionY() - obj->GetPositionY();
1200     float distsq = dx*dx + dy*dy;
1201     if(is3D)
1202     {
1203         float dz = GetPositionZ() - obj->GetPositionZ();
1204         distsq += dz*dz;
1205     }
1206     float sizefactor = GetObjectSize() + obj->GetObjectSize();
1207     float maxdist = dist2compare + sizefactor;
1208
1209     return distsq < maxdist * maxdist;
1210 }
1211
1212 bool WorldObject::IsWithinLOSInMap(const WorldObject* obj) const
1213 {
1214     if (!IsInMap(obj)) return false;
1215     float ox,oy,oz;
1216     obj->GetPosition(ox,oy,oz);
1217     return(IsWithinLOS(ox, oy, oz ));
1218 }
1219
1220 bool WorldObject::IsWithinLOS(float ox, float oy, float oz) const
1221 {
1222     float x,y,z;
1223     GetPosition(x,y,z);
1224     VMAP::IVMapManager *vMapManager = VMAP::VMapFactory::createOrGetVMapManager();
1225     return vMapManager->isInLineOfSight(GetMapId(), x, y, z+2.0f, ox, oy, oz+2.0f);
1226 }
1227
1228 bool WorldObject::GetDistanceOrder(WorldObject const* obj1, WorldObject const* obj2, bool is3D /* = true */) const
1229 {
1230     float dx1 = GetPositionX() - obj1->GetPositionX();
1231     float dy1 = GetPositionY() - obj1->GetPositionY();
1232     float distsq1 = dx1*dx1 + dy1*dy1;
1233     if(is3D)
1234     {
1235         float dz1 = GetPositionZ() - obj1->GetPositionZ();
1236         distsq1 += dz1*dz1;
1237     }
1238
1239     float dx2 = GetPositionX() - obj2->GetPositionX();
1240     float dy2 = GetPositionY() - obj2->GetPositionY();
1241     float distsq2 = dx2*dx2 + dy2*dy2;
1242     if(is3D)
1243     {
1244         float dz2 = GetPositionZ() - obj2->GetPositionZ();
1245         distsq2 += dz2*dz2;
1246     }
1247
1248     return distsq1 < distsq2;
1249 }
1250
1251 bool WorldObject::IsInRange(WorldObject const* obj, float minRange, float maxRange, bool is3D /* = true */) const
1252 {
1253     float dx = GetPositionX() - obj->GetPositionX();
1254     float dy = GetPositionY() - obj->GetPositionY();
1255     float distsq = dx*dx + dy*dy;
1256     if(is3D)
1257     {
1258         float dz = GetPositionZ() - obj->GetPositionZ();
1259         distsq += dz*dz;
1260     }
1261
1262     float sizefactor = GetObjectSize() + obj->GetObjectSize();
1263
1264     // check only for real range
1265     if(minRange > 0.0f)
1266     {
1267         float mindist = minRange + sizefactor;
1268         if(distsq < mindist * mindist)
1269             return false;
1270     }
1271
1272     float maxdist = maxRange + sizefactor;
1273     return distsq < maxdist * maxdist;
1274 }
1275
1276 bool WorldObject::IsInRange2d(float x, float y, float minRange, float maxRange) const
1277 {
1278     float dx = GetPositionX() - x;
1279     float dy = GetPositionY() - y;
1280     float distsq = dx*dx + dy*dy;
1281
1282     float sizefactor = GetObjectSize();
1283
1284     // check only for real range
1285     if(minRange > 0.0f)
1286     {
1287         float mindist = minRange + sizefactor;
1288         if(distsq < mindist * mindist)
1289             return false;
1290     }
1291
1292     float maxdist = maxRange + sizefactor;
1293     return distsq < maxdist * maxdist;
1294 }
1295
1296 bool WorldObject::IsInRange3d(float x, float y, float z, float minRange, float maxRange) const
1297 {
1298     float dx = GetPositionX() - x;
1299     float dy = GetPositionY() - y;
1300     float dz = GetPositionZ() - z;
1301     float distsq = dx*dx + dy*dy + dz*dz;
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 float WorldObject::GetAngle(const WorldObject* obj) const
1318 {
1319     if(!obj) return 0;
1320     return GetAngle( obj->GetPositionX(), obj->GetPositionY() );
1321 }
1322
1323 // Return angle in range 0..2*pi
1324 float WorldObject::GetAngle( const float x, const float y ) const
1325 {
1326     float dx = x - GetPositionX();
1327     float dy = y - GetPositionY();
1328
1329     float ang = atan2(dy, dx);
1330     ang = (ang >= 0) ? ang : 2 * M_PI + ang;
1331     return ang;
1332 }
1333
1334 bool WorldObject::HasInArc(const float arcangle, const WorldObject* obj) const
1335 {
1336     // always have self in arc
1337     if(obj == this)
1338         return true;
1339
1340     float arc = arcangle;
1341
1342     // move arc to range 0.. 2*pi
1343     while( arc >= 2.0f * M_PI )
1344         arc -=  2.0f * M_PI;
1345     while( arc < 0 )
1346         arc +=  2.0f * M_PI;
1347
1348     float angle = GetAngle( obj );
1349     angle -= m_orientation;
1350
1351     // move angle to range -pi ... +pi
1352     while( angle > M_PI)
1353         angle -= 2.0f * M_PI;
1354     while(angle < -M_PI)
1355         angle += 2.0f * M_PI;
1356
1357     float lborder =  -1 * (arc/2.0f);                       // in range -pi..0
1358     float rborder = (arc/2.0f);                             // in range 0..pi
1359     return (( angle >= lborder ) && ( angle <= rborder ));
1360 }
1361
1362 bool WorldObject::isInFrontInMap(WorldObject const* target, float distance,  float arc) const
1363 {
1364     return IsWithinDistInMap(target, distance) && HasInArc( arc, target );
1365 }
1366
1367 bool WorldObject::isInBackInMap(WorldObject const* target, float distance, float arc) const
1368 {
1369     return IsWithinDistInMap(target, distance) && !HasInArc( 2 * M_PI - arc, target );
1370 }
1371
1372 void WorldObject::GetRandomPoint( float x, float y, float z, float distance, float &rand_x, float &rand_y, float &rand_z) const
1373 {
1374     if(distance == 0)
1375     {
1376         rand_x = x;
1377         rand_y = y;
1378         rand_z = z;
1379         return;
1380     }
1381
1382     // angle to face `obj` to `this`
1383     float angle = rand_norm()*2*M_PI;
1384     float new_dist = rand_norm()*distance;
1385
1386     rand_x = x + new_dist * cos(angle);
1387     rand_y = y + new_dist * sin(angle);
1388     rand_z = z;
1389
1390     MaNGOS::NormalizeMapCoord(rand_x);
1391     MaNGOS::NormalizeMapCoord(rand_y);
1392     UpdateGroundPositionZ(rand_x,rand_y,rand_z);            // update to LOS height if available
1393 }
1394
1395 void WorldObject::UpdateGroundPositionZ(float x, float y, float &z) const
1396 {
1397     float new_z = GetBaseMap()->GetHeight(x,y,z,true);
1398     if(new_z > INVALID_HEIGHT)
1399         z = new_z+ 0.05f;                                   // just to be sure that we are not a few pixel under the surface
1400 }
1401
1402 bool WorldObject::IsPositionValid() const
1403 {
1404     return MaNGOS::IsValidMapCoord(m_positionX,m_positionY,m_positionZ,m_orientation);
1405 }
1406
1407 void WorldObject::MonsterSay(const char* text, uint32 language, uint64 TargetGuid)
1408 {
1409     WorldPacket data(SMSG_MESSAGECHAT, 200);
1410     BuildMonsterChat(&data,CHAT_MSG_MONSTER_SAY,text,language,GetName(),TargetGuid);
1411     SendMessageToSetInRange(&data,sWorld.getConfig(CONFIG_LISTEN_RANGE_SAY),true);
1412 }
1413
1414 void WorldObject::MonsterYell(const char* text, uint32 language, uint64 TargetGuid)
1415 {
1416     WorldPacket data(SMSG_MESSAGECHAT, 200);
1417     BuildMonsterChat(&data,CHAT_MSG_MONSTER_YELL,text,language,GetName(),TargetGuid);
1418     SendMessageToSetInRange(&data,sWorld.getConfig(CONFIG_LISTEN_RANGE_YELL),true);
1419 }
1420
1421 void WorldObject::MonsterTextEmote(const char* text, uint64 TargetGuid, bool IsBossEmote)
1422 {
1423     WorldPacket data(SMSG_MESSAGECHAT, 200);
1424     BuildMonsterChat(&data,IsBossEmote ? CHAT_MSG_RAID_BOSS_EMOTE : CHAT_MSG_MONSTER_EMOTE,text,LANG_UNIVERSAL,GetName(),TargetGuid);
1425     SendMessageToSetInRange(&data,sWorld.getConfig(CONFIG_LISTEN_RANGE_TEXTEMOTE),true);
1426 }
1427
1428 void WorldObject::MonsterWhisper(const char* text, uint64 receiver, bool IsBossWhisper)
1429 {
1430     Player *player = objmgr.GetPlayer(receiver);
1431     if(!player || !player->GetSession())
1432         return;
1433
1434     WorldPacket data(SMSG_MESSAGECHAT, 200);
1435     BuildMonsterChat(&data,IsBossWhisper ? CHAT_MSG_RAID_BOSS_WHISPER : CHAT_MSG_MONSTER_WHISPER,text,LANG_UNIVERSAL,GetName(),receiver);
1436
1437     player->GetSession()->SendPacket(&data);
1438 }
1439
1440 namespace MaNGOS
1441 {
1442     class MonsterChatBuilder
1443     {
1444         public:
1445             MonsterChatBuilder(WorldObject const& obj, ChatMsg msgtype, int32 textId, uint32 language, uint64 targetGUID)
1446                 : i_object(obj), i_msgtype(msgtype), i_textId(textId), i_language(language), i_targetGUID(targetGUID) {}
1447             void operator()(WorldPacket& data, int32 loc_idx)
1448             {
1449                 char const* text = objmgr.GetMangosString(i_textId,loc_idx);
1450
1451                 // TODO: i_object.GetName() also must be localized?
1452                 i_object.BuildMonsterChat(&data,i_msgtype,text,i_language,i_object.GetNameForLocaleIdx(loc_idx),i_targetGUID);
1453             }
1454
1455         private:
1456             WorldObject const& i_object;
1457             ChatMsg i_msgtype;
1458             int32 i_textId;
1459             uint32 i_language;
1460             uint64 i_targetGUID;
1461     };
1462 }                                                           // namespace MaNGOS
1463
1464 void WorldObject::MonsterSay(int32 textId, uint32 language, uint64 TargetGuid)
1465 {
1466     CellPair p = MaNGOS::ComputeCellPair(GetPositionX(), GetPositionY());
1467
1468     Cell cell(p);
1469     cell.data.Part.reserved = ALL_DISTRICT;
1470     cell.SetNoCreate();
1471
1472     MaNGOS::MonsterChatBuilder say_build(*this, CHAT_MSG_MONSTER_SAY, textId,language,TargetGuid);
1473     MaNGOS::LocalizedPacketDo<MaNGOS::MonsterChatBuilder> say_do(say_build);
1474     MaNGOS::PlayerDistWorker<MaNGOS::LocalizedPacketDo<MaNGOS::MonsterChatBuilder> > say_worker(this,sWorld.getConfig(CONFIG_LISTEN_RANGE_SAY),say_do);
1475     TypeContainerVisitor<MaNGOS::PlayerDistWorker<MaNGOS::LocalizedPacketDo<MaNGOS::MonsterChatBuilder> >, WorldTypeMapContainer > message(say_worker);
1476     CellLock<GridReadGuard> cell_lock(cell, p);
1477     cell_lock->Visit(cell_lock, message, *GetMap());
1478 }
1479
1480 void WorldObject::MonsterYell(int32 textId, uint32 language, uint64 TargetGuid)
1481 {
1482     CellPair p = MaNGOS::ComputeCellPair(GetPositionX(), GetPositionY());
1483
1484     Cell cell(p);
1485     cell.data.Part.reserved = ALL_DISTRICT;
1486     cell.SetNoCreate();
1487
1488     MaNGOS::MonsterChatBuilder say_build(*this, CHAT_MSG_MONSTER_YELL, textId,language,TargetGuid);
1489     MaNGOS::LocalizedPacketDo<MaNGOS::MonsterChatBuilder> say_do(say_build);
1490     MaNGOS::PlayerDistWorker<MaNGOS::LocalizedPacketDo<MaNGOS::MonsterChatBuilder> > say_worker(this,sWorld.getConfig(CONFIG_LISTEN_RANGE_YELL),say_do);
1491     TypeContainerVisitor<MaNGOS::PlayerDistWorker<MaNGOS::LocalizedPacketDo<MaNGOS::MonsterChatBuilder> >, WorldTypeMapContainer > message(say_worker);
1492     CellLock<GridReadGuard> cell_lock(cell, p);
1493     cell_lock->Visit(cell_lock, message, *GetMap());
1494 }
1495
1496 void WorldObject::MonsterYellToZone(int32 textId, uint32 language, uint64 TargetGuid)
1497 {
1498     MaNGOS::MonsterChatBuilder say_build(*this, CHAT_MSG_MONSTER_YELL, textId,language,TargetGuid);
1499     MaNGOS::LocalizedPacketDo<MaNGOS::MonsterChatBuilder> say_do(say_build);
1500
1501     uint32 zoneid = GetZoneId();
1502
1503     Map::PlayerList const& pList = GetMap()->GetPlayers();
1504     for(Map::PlayerList::const_iterator itr = pList.begin(); itr != pList.end(); ++itr)
1505         if(itr->getSource()->GetZoneId()==zoneid)
1506             say_do(itr->getSource());
1507 }
1508
1509 void WorldObject::MonsterTextEmote(int32 textId, uint64 TargetGuid, bool IsBossEmote)
1510 {
1511     CellPair p = MaNGOS::ComputeCellPair(GetPositionX(), GetPositionY());
1512
1513     Cell cell(p);
1514     cell.data.Part.reserved = ALL_DISTRICT;
1515     cell.SetNoCreate();
1516
1517     MaNGOS::MonsterChatBuilder say_build(*this, IsBossEmote ? CHAT_MSG_RAID_BOSS_EMOTE : CHAT_MSG_MONSTER_EMOTE, textId,LANG_UNIVERSAL,TargetGuid);
1518     MaNGOS::LocalizedPacketDo<MaNGOS::MonsterChatBuilder> say_do(say_build);
1519     MaNGOS::PlayerDistWorker<MaNGOS::LocalizedPacketDo<MaNGOS::MonsterChatBuilder> > say_worker(this,sWorld.getConfig(CONFIG_LISTEN_RANGE_TEXTEMOTE),say_do);
1520     TypeContainerVisitor<MaNGOS::PlayerDistWorker<MaNGOS::LocalizedPacketDo<MaNGOS::MonsterChatBuilder> >, WorldTypeMapContainer > message(say_worker);
1521     CellLock<GridReadGuard> cell_lock(cell, p);
1522     cell_lock->Visit(cell_lock, message, *GetMap());
1523 }
1524
1525 void WorldObject::MonsterWhisper(int32 textId, uint64 receiver, bool IsBossWhisper)
1526 {
1527     Player *player = objmgr.GetPlayer(receiver);
1528     if(!player || !player->GetSession())
1529         return;
1530
1531     uint32 loc_idx = player->GetSession()->GetSessionDbLocaleIndex();
1532     char const* text = objmgr.GetMangosString(textId,loc_idx);
1533
1534     WorldPacket data(SMSG_MESSAGECHAT, 200);
1535     BuildMonsterChat(&data,IsBossWhisper ? CHAT_MSG_RAID_BOSS_WHISPER : CHAT_MSG_MONSTER_WHISPER,text,LANG_UNIVERSAL,GetNameForLocaleIdx(loc_idx),receiver);
1536
1537     player->GetSession()->SendPacket(&data);
1538 }
1539
1540 void WorldObject::BuildMonsterChat(WorldPacket *data, uint8 msgtype, char const* text, uint32 language, char const* name, uint64 targetGuid) const
1541 {
1542     *data << (uint8)msgtype;
1543     *data << (uint32)language;
1544     *data << (uint64)GetGUID();
1545     *data << (uint32)0;                                     // 2.1.0
1546     *data << (uint32)(strlen(name)+1);
1547     *data << name;
1548     *data << (uint64)targetGuid;                            // Unit Target
1549     if( targetGuid && !IS_PLAYER_GUID(targetGuid) )
1550     {
1551         *data << (uint32)1;                                 // target name length
1552         *data << (uint8)0;                                  // target name
1553     }
1554     *data << (uint32)(strlen(text)+1);
1555     *data << text;
1556     *data << (uint8)0;                                      // ChatTag
1557 }
1558
1559 void WorldObject::SendMessageToSet(WorldPacket *data, bool /*bToSelf*/)
1560 {
1561     //if object is in world, map for it already created!
1562     Map * _map = IsInWorld() ? GetMap() : MapManager::Instance().FindMap(GetMapId(), GetInstanceId());
1563     if(_map)
1564         _map->MessageBroadcast(this, data);
1565 }
1566
1567 void WorldObject::SendMessageToSetInRange(WorldPacket *data, float dist, 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->MessageDistBroadcast(this, data, dist);
1573 }
1574
1575 void WorldObject::SendObjectDeSpawnAnim(uint64 guid)
1576 {
1577     WorldPacket data(SMSG_GAMEOBJECT_DESPAWN_ANIM, 8);
1578     data << uint64(guid);
1579     SendMessageToSet(&data, true);
1580 }
1581
1582 void WorldObject::SetMap(Map * map)
1583 {
1584     ASSERT(map);
1585     m_currMap = map;
1586     //lets save current map's Id/instanceId
1587     m_mapId = map->GetId();
1588     m_InstanceId = map->GetInstanceId();
1589 }
1590
1591 Map const* WorldObject::GetBaseMap() const
1592 {
1593     ASSERT(m_currMap);
1594     return m_currMap->GetParent();
1595 }
1596
1597 void WorldObject::AddObjectToRemoveList()
1598 {
1599     GetMap()->AddObjectToRemoveList(this);
1600 }
1601
1602 Creature* WorldObject::SummonCreature(uint32 id, float x, float y, float z, float ang,TempSummonType spwtype,uint32 despwtime)
1603 {
1604     TemporarySummon* pCreature = new TemporarySummon(GetGUID());
1605
1606     uint32 team = 0;
1607     if (GetTypeId()==TYPEID_PLAYER)
1608         team = ((Player*)this)->GetTeam();
1609
1610     if (!pCreature->Create(objmgr.GenerateLowGuid(HIGHGUID_UNIT), GetMap(), GetPhaseMask(), id, team))
1611     {
1612         delete pCreature;
1613         return NULL;
1614     }
1615
1616     if (x == 0.0f && y == 0.0f && z == 0.0f)
1617         GetClosePoint(x, y, z, pCreature->GetObjectSize());
1618
1619     pCreature->Relocate(x, y, z, ang);
1620
1621     if(!pCreature->IsPositionValid())
1622     {
1623         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());
1624         delete pCreature;
1625         return NULL;
1626     }
1627
1628     pCreature->Summon(spwtype, despwtime);
1629
1630     if(GetTypeId()==TYPEID_UNIT && ((Creature*)this)->AI())
1631         ((Creature*)this)->AI()->JustSummoned(pCreature);
1632
1633     // return the creature therewith the summoner has access to it
1634     return pCreature;
1635 }
1636
1637 namespace MaNGOS
1638 {
1639     class NearUsedPosDo
1640     {
1641         public:
1642             NearUsedPosDo(WorldObject const& obj, WorldObject const* searcher, float angle, ObjectPosSelector& selector)
1643                 : i_object(obj), i_searcher(searcher), i_angle(angle), i_selector(selector) {}
1644
1645             void operator()(Corpse*) const {}
1646             void operator()(DynamicObject*) const {}
1647
1648             void operator()(Creature* c) const
1649             {
1650                 // skip self or target
1651                 if(c==i_searcher || c==&i_object)
1652                     return;
1653
1654                 float x,y,z;
1655
1656                 if( !c->isAlive() || c->hasUnitState(UNIT_STAT_ROOT | UNIT_STAT_STUNNED | UNIT_STAT_DISTRACTED) ||
1657                     !c->GetMotionMaster()->GetDestination(x,y,z) )
1658                 {
1659                     x = c->GetPositionX();
1660                     y = c->GetPositionY();
1661                 }
1662
1663                 add(c,x,y);
1664             }
1665
1666             template<class T>
1667                 void operator()(T* u) const
1668             {
1669                 // skip self or target
1670                 if(u==i_searcher || u==&i_object)
1671                     return;
1672
1673                 float x,y;
1674
1675                 x = u->GetPositionX();
1676                 y = u->GetPositionY();
1677
1678                 add(u,x,y);
1679             }
1680
1681             // we must add used pos that can fill places around center
1682             void add(WorldObject* u, float x, float y) const
1683             {
1684                 // u is too nearest/far away to i_object
1685                 if(!i_object.IsInRange2d(x,y,i_selector.m_dist - i_selector.m_size,i_selector.m_dist + i_selector.m_size))
1686                     return;
1687
1688                 float angle = i_object.GetAngle(u)-i_angle;
1689
1690                 // move angle to range -pi ... +pi
1691                 while( angle > M_PI)
1692                     angle -= 2.0f * M_PI;
1693                 while(angle < -M_PI)
1694                     angle += 2.0f * M_PI;
1695
1696                 // dist include size of u
1697                 float dist2d = i_object.GetDistance2d(x,y);
1698                 i_selector.AddUsedPos(u->GetObjectSize(),angle,dist2d + i_object.GetObjectSize());
1699             }
1700         private:
1701             WorldObject const& i_object;
1702             WorldObject const* i_searcher;
1703             float              i_angle;
1704             ObjectPosSelector& i_selector;
1705     };
1706 }                                                           // namespace MaNGOS
1707
1708 //===================================================================================================
1709
1710 void WorldObject::GetNearPoint2D(float &x, float &y, float distance2d, float absAngle ) const
1711 {
1712     x = GetPositionX() + (GetObjectSize() + distance2d) * cos(absAngle);
1713     y = GetPositionY() + (GetObjectSize() + distance2d) * sin(absAngle);
1714
1715     MaNGOS::NormalizeMapCoord(x);
1716     MaNGOS::NormalizeMapCoord(y);
1717 }
1718
1719 void WorldObject::GetNearPoint(WorldObject const* searcher, float &x, float &y, float &z, float searcher_size, float distance2d, float absAngle ) const
1720 {
1721     GetNearPoint2D(x,y,distance2d+searcher_size,absAngle);
1722     z = GetPositionZ();
1723
1724     // if detection disabled, return first point
1725     if(!sWorld.getConfig(CONFIG_DETECT_POS_COLLISION))
1726     {
1727         UpdateGroundPositionZ(x,y,z);                       // update to LOS height if available
1728         return;
1729     }
1730
1731     // or remember first point
1732     float first_x = x;
1733     float first_y = y;
1734     bool first_los_conflict = false;                        // first point LOS problems
1735
1736     // prepare selector for work
1737     ObjectPosSelector selector(GetPositionX(),GetPositionY(),GetObjectSize(),distance2d+searcher_size);
1738
1739     // adding used positions around object
1740     {
1741         CellPair p(MaNGOS::ComputeCellPair(GetPositionX(), GetPositionY()));
1742         Cell cell(p);
1743         cell.data.Part.reserved = ALL_DISTRICT;
1744         cell.SetNoCreate();
1745
1746         MaNGOS::NearUsedPosDo u_do(*this,searcher,absAngle,selector);
1747         MaNGOS::WorldObjectWorker<MaNGOS::NearUsedPosDo> worker(this,u_do);
1748
1749         TypeContainerVisitor<MaNGOS::WorldObjectWorker<MaNGOS::NearUsedPosDo>, GridTypeMapContainer  > grid_obj_worker(worker);
1750         TypeContainerVisitor<MaNGOS::WorldObjectWorker<MaNGOS::NearUsedPosDo>, WorldTypeMapContainer > world_obj_worker(worker);
1751
1752         CellLock<GridReadGuard> cell_lock(cell, p);
1753         cell_lock->Visit(cell_lock, grid_obj_worker,  *GetMap());
1754         cell_lock->Visit(cell_lock, world_obj_worker, *GetMap());
1755     }
1756
1757     // maybe can just place in primary position
1758     if( selector.CheckOriginal() )
1759     {
1760         UpdateGroundPositionZ(x,y,z);                       // update to LOS height if available
1761
1762         if(IsWithinLOS(x,y,z))
1763             return;
1764
1765         first_los_conflict = true;                          // first point have LOS problems
1766     }
1767
1768     float angle;                                            // candidate of angle for free pos
1769
1770     // special case when one from list empty and then empty side preferred
1771     if(selector.FirstAngle(angle))
1772     {
1773         GetNearPoint2D(x,y,distance2d,absAngle+angle);
1774         z = GetPositionZ();
1775         UpdateGroundPositionZ(x,y,z);                       // update to LOS height if available
1776
1777         if(IsWithinLOS(x,y,z))
1778             return;
1779     }
1780
1781     // set first used pos in lists
1782     selector.InitializeAngle();
1783
1784     // select in positions after current nodes (selection one by one)
1785     while(selector.NextAngle(angle))                        // angle for free pos
1786     {
1787         GetNearPoint2D(x,y,distance2d,absAngle+angle);
1788         z = GetPositionZ();
1789         UpdateGroundPositionZ(x,y,z);                       // update to LOS height if available
1790
1791         if(IsWithinLOS(x,y,z))
1792             return;
1793     }
1794
1795     // BAD NEWS: not free pos (or used or have LOS problems)
1796     // Attempt find _used_ pos without LOS problem
1797
1798     if(!first_los_conflict)
1799     {
1800         x = first_x;
1801         y = first_y;
1802
1803         UpdateGroundPositionZ(x,y,z);                       // update to LOS height if available
1804         return;
1805     }
1806
1807     // special case when one from list empty and then empty side preferred
1808     if( selector.IsNonBalanced() )
1809     {
1810         if(!selector.FirstAngle(angle))                     // _used_ pos
1811         {
1812             GetNearPoint2D(x,y,distance2d,absAngle+angle);
1813             z = GetPositionZ();
1814             UpdateGroundPositionZ(x,y,z);                   // update to LOS height if available
1815
1816             if(IsWithinLOS(x,y,z))
1817                 return;
1818         }
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.NextUsedAngle(angle))                    // angle for used pos but maybe without LOS problem
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 BAD NEWS: all found pos (free and used) have LOS problem :(
1836     x = first_x;
1837     y = first_y;
1838
1839     UpdateGroundPositionZ(x,y,z);                           // update to LOS height if available
1840 }
1841
1842 void WorldObject::SetPhaseMask(uint32 newPhaseMask, bool update)
1843 {
1844     m_phaseMask = newPhaseMask;
1845
1846     if(update && IsInWorld())
1847         ObjectAccessor::UpdateObjectVisibility(this);
1848 }
1849
1850 void WorldObject::PlayDistanceSound( uint32 sound_id, Player* target /*= NULL*/ )
1851 {
1852     WorldPacket data(SMSG_PLAY_OBJECT_SOUND,4+8);
1853     data << uint32(sound_id);
1854     data << uint64(GetGUID());
1855     if (target)
1856         target->SendDirectMessage( &data );
1857     else
1858         SendMessageToSet( &data, true );
1859 }
1860
1861 void WorldObject::PlayDirectSound( uint32 sound_id, Player* target /*= NULL*/ )
1862 {
1863     WorldPacket data(SMSG_PLAY_SOUND, 4);
1864     data << uint32(sound_id);
1865     if (target)
1866         target->SendDirectMessage( &data );
1867     else
1868         SendMessageToSet( &data, true );
1869 }