src/game/Object.cpp

   1 /*
   2  * Copyright (C) 2005-2008 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 "ObjectMgr.h"
  29 #include "WorldSession.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     }
  62     return 10;                                              // unknown
  63 }
  64
  65 Object::Object( )
  66 {
  67     m_objectTypeId      = TYPEID_OBJECT;
  68     m_objectType        = TYPEMASK_OBJECT;
  69
  70     m_uint32Values      = 0;
  71     m_uint32Values_mirror = 0;
  72     m_valuesCount       = 0;
  73
  74     m_inWorld           = false;
  75     m_objectUpdated     = false;
  76
  77     m_PackGUID.clear();
  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="I64FMTD", typeid=%d deleted but still in world!!", GetGUID(), 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);  // required more changes to make it working
 118     SetUInt64Value( OBJECT_FIELD_GUID, guid );
 119     SetUInt32Value( OBJECT_FIELD_TYPE, m_objectType );
 120     m_PackGUID.clear();
 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 << GetGUID();
 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     {
 140         return;
 141     }
 142
 143     uint8  updatetype = UPDATETYPE_CREATE_OBJECT;
 144     uint8  flags      = m_updateFlag;
 145     uint32 flags2     = 0;
 146
 147     /** lower flag1 **/
 148     if(target == this)                                      // building packet for oneself
 149     {
 150         flags |= UPDATEFLAG_SELF;
 151
 152         /*** temporary reverted - until real source of stack corruption will not found
 153         updatetype = UPDATETYPE_CREATE_OBJECT2;
 154         ****/
 155     }
 156
 157     if(flags & UPDATEFLAG_HASPOSITION)
 158     {
 159         // UPDATETYPE_CREATE_OBJECT2 dynamic objects, corpses...
 160         if(isType(TYPEMASK_DYNAMICOBJECT) || isType(TYPEMASK_CORPSE) || isType(TYPEMASK_PLAYER))
 161             updatetype = UPDATETYPE_CREATE_OBJECT2;
 162
 163         // UPDATETYPE_CREATE_OBJECT2 for pets...
 164         if(target->GetPetGUID() == GetGUID())
 165             updatetype = UPDATETYPE_CREATE_OBJECT2;
 166
 167         // UPDATETYPE_CREATE_OBJECT2 for some gameobject types...
 168         if(isType(TYPEMASK_GAMEOBJECT))
 169         {
 170             switch(((GameObject*)this)->GetGoType())
 171             {
 172                 case GAMEOBJECT_TYPE_TRAP:
 173                 case GAMEOBJECT_TYPE_DUEL_ARBITER:
 174                 case GAMEOBJECT_TYPE_FLAGSTAND:
 175                 case GAMEOBJECT_TYPE_FLAGDROP:
 176                     updatetype = UPDATETYPE_CREATE_OBJECT2;
 177                     break;
 178                 case GAMEOBJECT_TYPE_TRANSPORT:
 179                     flags |= UPDATEFLAG_TRANSPORT;
 180                     break;
 181             }
 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());    //client crashes when using this
 190     buf << (uint8)0xFF << GetGUID();
 191     buf << (uint8)m_objectTypeId;
 192
 193     _BuildMovementUpdate(&buf, flags, flags2);
 194
 195     UpdateMask updateMask;
 196     updateMask.SetCount( m_valuesCount );
 197     _SetCreateBits( &updateMask, target );
 198     _BuildValuesUpdate(updatetype, &buf, &updateMask, target );
 199     data->AddUpdateBlock(buf);
 200 }
 201
 202 void Object::BuildUpdate(UpdateDataMapType &update_players)
 203 {
 204     ObjectAccessor::_buildUpdateObject(this,update_players);
 205     ClearUpdateMask(true);
 206 }
 207
 208 void Object::SendUpdateToPlayer(Player* player)
 209 {
 210     // send update to another players
 211     SendUpdateObjectToAllExcept(player);
 212
 213     // send create update to player
 214     UpdateData upd;
 215     WorldPacket packet;
 216
 217     upd.Clear();
 218     BuildCreateUpdateBlockForPlayer(&upd, player);
 219     upd.BuildPacket(&packet);
 220     player->GetSession()->SendPacket(&packet);
 221
 222     // now object updated/(create updated)
 223 }
 224
 225 void Object::BuildValuesUpdateBlockForPlayer(UpdateData *data, Player *target) const
 226 {
 227     ByteBuffer buf(500);
 228
 229     buf << (uint8) UPDATETYPE_VALUES;
 230     //buf.append(GetPackGUID());    //client crashes when using this. but not have crash in debug mode
 231     buf << (uint8)0xFF;
 232     buf << GetGUID();
 233
 234     UpdateMask updateMask;
 235     updateMask.SetCount( m_valuesCount );
 236
 237     _SetUpdateBits( &updateMask, target );
 238     _BuildValuesUpdate(UPDATETYPE_VALUES, &buf, &updateMask, target );
 239
 240     data->AddUpdateBlock(buf);
 241 }
 242
 243 void Object::BuildOutOfRangeUpdateBlock(UpdateData * data) const
 244 {
 245     data->AddOutOfRangeGUID(GetGUID());
 246 }
 247
 248 void Object::DestroyForPlayer(Player *target) const
 249 {
 250     ASSERT(target);
 251
 252     WorldPacket data(SMSG_DESTROY_OBJECT, 8);
 253     data << GetGUID();
 254     target->GetSession()->SendPacket( &data );
 255 }
 256
 257 void Object::_BuildMovementUpdate(ByteBuffer * data, uint8 flags, uint32 flags2 ) const
 258 {
 259     *data << (uint8)flags;                                  // update flags
 260
 261     // 0x20
 262     if (flags & UPDATEFLAG_LIVING)
 263     {
 264         switch(GetTypeId())
 265         {
 266             case TYPEID_UNIT:
 267             {
 268                 flags2 = ((Unit*)this)->GetUnitMovementFlags();
 269             }
 270             break;
 271             case TYPEID_PLAYER:
 272             {
 273                 flags2 = ((Player*)this)->GetUnitMovementFlags();
 274
 275                 if(((Player*)this)->GetTransport())
 276                     flags2 |= MOVEMENTFLAG_ONTRANSPORT;
 277                 else
 278                     flags2 &= ~MOVEMENTFLAG_ONTRANSPORT;
 279
 280                 // remove unknown, unused etc flags for now
 281                 flags2 &= ~MOVEMENTFLAG_SPLINE2;            // will be set manually
 282
 283                 if(((Player*)this)->isInFlight())
 284                 {
 285                     WPAssert(((Player*)this)->GetMotionMaster()->GetCurrentMovementGeneratorType() == FLIGHT_MOTION_TYPE);
 286                     flags2 = (MOVEMENTFLAG_FORWARD | MOVEMENTFLAG_SPLINE2);
 287                 }
 288             }
 289             break;
 290         }
 291
 292         *data << uint32(flags2);                            // movement flags
 293         *data << uint8(0);                                  // unk 2.3.0
 294         *data << uint32(getMSTime());                       // time (in milliseconds)
 295     }
 296
 297     // 0x40
 298     if (flags & UPDATEFLAG_HASPOSITION)
 299     {
 300         // 0x02
 301         if(flags & UPDATEFLAG_TRANSPORT && ((GameObject*)this)->GetGoType() == GAMEOBJECT_TYPE_MO_TRANSPORT)
 302         {
 303             *data << (float)0;
 304             *data << (float)0;
 305             *data << (float)0;
 306             *data << ((WorldObject *)this)->GetOrientation();
 307         }
 308         else
 309         {
 310             *data << ((WorldObject *)this)->GetPositionX();
 311             *data << ((WorldObject *)this)->GetPositionY();
 312             *data << ((WorldObject *)this)->GetPositionZ();
 313             *data << ((WorldObject *)this)->GetOrientation();
 314         }
 315     }
 316
 317     // 0x20
 318     if(flags & UPDATEFLAG_LIVING)
 319     {
 320         // 0x00000200
 321         if(flags2 & MOVEMENTFLAG_ONTRANSPORT)
 322         {
 323             if(GetTypeId() == TYPEID_PLAYER)
 324             {
 325                 *data << (uint64)((Player*)this)->GetTransport()->GetGUID();
 326                 *data << (float)((Player*)this)->GetTransOffsetX();
 327                 *data << (float)((Player*)this)->GetTransOffsetY();
 328                 *data << (float)((Player*)this)->GetTransOffsetZ();
 329                 *data << (float)((Player*)this)->GetTransOffsetO();
 330                 *data << (uint32)((Player*)this)->GetTransTime();
 331             }
 332             //MaNGOS currently not have support for other than player on transport
 333         }
 334
 335         // 0x02200000
 336         if(flags2 & (MOVEMENTFLAG_SWIMMING | MOVEMENTFLAG_FLYING2))
 337         {
 338             if(GetTypeId() == TYPEID_PLAYER)
 339                 *data << (float)((Player*)this)->m_movementInfo.s_pitch;
 340             else
 341                 *data << (float)0;                          // is't part of movement packet, we must store and send it...
 342         }
 343
 344         if(GetTypeId() == TYPEID_PLAYER)
 345             *data << (uint32)((Player*)this)->m_movementInfo.fallTime;
 346         else
 347             *data << (uint32)0;                             // last fall time
 348
 349         // 0x00001000
 350         if(flags2 & MOVEMENTFLAG_JUMPING)
 351         {
 352             if(GetTypeId() == TYPEID_PLAYER)
 353             {
 354                 *data << (float)((Player*)this)->m_movementInfo.j_unk;
 355                 *data << (float)((Player*)this)->m_movementInfo.j_sinAngle;
 356                 *data << (float)((Player*)this)->m_movementInfo.j_cosAngle;
 357                 *data << (float)((Player*)this)->m_movementInfo.j_xyspeed;
 358             }
 359             else
 360             {
 361                 *data << (float)0;
 362                 *data << (float)0;
 363                 *data << (float)0;
 364                 *data << (float)0;
 365             }
 366         }
 367
 368         // 0x04000000
 369         if(flags2 & MOVEMENTFLAG_SPLINE)
 370         {
 371             if(GetTypeId() == TYPEID_PLAYER)
 372                 *data << (float)((Player*)this)->m_movementInfo.u_unk1;
 373             else
 374                 *data << (float)0;
 375         }
 376
 377         *data << ((Unit*)this)->GetSpeed( MOVE_WALK );
 378         *data << ((Unit*)this)->GetSpeed( MOVE_RUN );
 379         *data << ((Unit*)this)->GetSpeed( MOVE_SWIMBACK );
 380         *data << ((Unit*)this)->GetSpeed( MOVE_SWIM );
 381         *data << ((Unit*)this)->GetSpeed( MOVE_WALKBACK );
 382         *data << ((Unit*)this)->GetSpeed( MOVE_FLY );
 383         *data << ((Unit*)this)->GetSpeed( MOVE_FLYBACK );
 384         *data << ((Unit*)this)->GetSpeed( MOVE_TURN );
 385
 386         // 0x08000000
 387         if(flags2 & MOVEMENTFLAG_SPLINE2)
 388         {
 389             if(GetTypeId() != TYPEID_PLAYER)
 390             {
 391                 sLog.outDebug("_BuildMovementUpdate: MOVEMENTFLAG_SPLINE2 for non-player");
 392                 return;
 393             }
 394
 395             if(!((Player*)this)->isInFlight())
 396             {
 397                 sLog.outDebug("_BuildMovementUpdate: MOVEMENTFLAG_SPLINE2 but not in flight");
 398                 return;
 399             }
 400
 401             WPAssert(((Player*)this)->GetMotionMaster()->GetCurrentMovementGeneratorType() == FLIGHT_MOTION_TYPE);
 402
 403             FlightPathMovementGenerator *fmg = (FlightPathMovementGenerator*)(((Player*)this)->GetMotionMaster()->top());
 404
 405             uint32 flags3 = 0x00000300;
 406
 407             *data << uint32(flags3);                        // splines flag?
 408
 409             if(flags3 & 0x10000)                            // probably x,y,z coords there
 410             {
 411                 *data << (float)0;
 412                 *data << (float)0;
 413                 *data << (float)0;
 414             }
 415
 416             if(flags3 & 0x20000)                            // probably guid there
 417             {
 418                 *data << uint64(0);
 419             }
 420
 421             if(flags3 & 0x40000)                            // may be orientation
 422             {
 423                 *data << (float)0;
 424             }
 425
 426             Path &path = fmg->GetPath();
 427
 428             float x, y, z;
 429             ((Player*)this)->GetPosition(x, y, z);
 430
 431             uint32 inflighttime = uint32(path.GetPassedLength(fmg->GetCurrentNode(), x, y, z) * 32);
 432             uint32 traveltime = uint32(path.GetTotalLength() * 32);
 433
 434             *data << uint32(inflighttime);                  // passed move time?
 435             *data << uint32(traveltime);                    // full move time?
 436             *data << uint32(0);                             // ticks count?
 437
 438             uint32 poscount = uint32(path.Size());
 439
 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             /*for(uint32 i = 0; i < poscount; i++)
 450             {
 451                 // path points
 452                 *data << (float)0;
 453                 *data << (float)0;
 454                 *data << (float)0;
 455             }*/
 456
 457             *data << path.GetNodes()[poscount-1].x;
 458             *data << path.GetNodes()[poscount-1].y;
 459             *data << path.GetNodes()[poscount-1].z;
 460
 461             // target position (path end)
 462             /**data << ((Unit*)this)->GetPositionX();
 463              *data << ((Unit*)this)->GetPositionY();
 464              *data << ((Unit*)this)->GetPositionZ();*/
 465         }
 466     }
 467
 468     // 0x8
 469     if(flags & UPDATEFLAG_LOWGUID)
 470     {
 471         switch(GetTypeId())
 472         {
 473             case TYPEID_OBJECT:
 474             case TYPEID_ITEM:
 475             case TYPEID_CONTAINER:
 476             case TYPEID_GAMEOBJECT:
 477             case TYPEID_DYNAMICOBJECT:
 478             case TYPEID_CORPSE:
 479                 *data << uint32(GetGUIDLow());              // GetGUIDLow()
 480                 break;
 481             case TYPEID_UNIT:
 482                 *data << uint32(0x0000000B);                // unk, can be 0xB or 0xC
 483                 break;
 484             case TYPEID_PLAYER:
 485                 if(flags & UPDATEFLAG_SELF)
 486                     *data << uint32(0x00000015);            // unk, can be 0x15 or 0x22
 487                 else
 488                     *data << uint32(0x00000008);            // unk, can be 0x7 or 0x8
 489                 break;
 490             default:
 491                 *data << uint32(0x00000000);                // unk
 492                 break;
 493         }
 494     }
 495
 496     // 0x10
 497     if(flags & UPDATEFLAG_HIGHGUID)
 498     {
 499         switch(GetTypeId())
 500         {
 501             case TYPEID_OBJECT:
 502             case TYPEID_ITEM:
 503             case TYPEID_CONTAINER:
 504             case TYPEID_GAMEOBJECT:
 505             case TYPEID_DYNAMICOBJECT:
 506             case TYPEID_CORPSE:
 507                 *data << uint32(GetGUIDHigh());             // GetGUIDHigh()
 508                 break;
 509             default:
 510                 *data << uint32(0x00000000);                // unk
 511                 break;
 512         }
 513     }
 514
 515     // 0x4
 516     if(flags & UPDATEFLAG_FULLGUID)
 517     {
 518         *data << uint8(0);                                  // packed guid (probably target guid)
 519     }
 520
 521     // 0x2
 522     if(flags & UPDATEFLAG_TRANSPORT)
 523     {
 524         *data << uint32(getMSTime());                       // ms time
 525     }
 526 }
 527
 528 void Object::_BuildValuesUpdate(uint8 updatetype, ByteBuffer * data, UpdateMask *updateMask, Player *target) const
 529 {
 530     if(!target)
 531         return;
 532
 533     bool IsActivateToQuest = false;
 534     if (updatetype == UPDATETYPE_CREATE_OBJECT || updatetype == UPDATETYPE_CREATE_OBJECT2)
 535     {
 536         if (isType(TYPEMASK_GAMEOBJECT) && !((GameObject*)this)->IsTransport())
 537         {
 538             if ( ((GameObject*)this)->ActivateToQuest(target) || target->isGameMaster())
 539             {
 540                 IsActivateToQuest = true;
 541                 updateMask->SetBit(GAMEOBJECT_DYN_FLAGS);
 542             }
 543         }
 544     }
 545     else                                                    //case UPDATETYPE_VALUES
 546     {
 547         if (isType(TYPEMASK_GAMEOBJECT) && !((GameObject*)this)->IsTransport())
 548         {
 549             if ( ((GameObject*)this)->ActivateToQuest(target) || target->isGameMaster())
 550             {
 551                 IsActivateToQuest = true;
 552             }
 553             updateMask->SetBit(GAMEOBJECT_DYN_FLAGS);
 554             updateMask->SetBit(GAMEOBJECT_ANIMPROGRESS);
 555         }
 556     }
 557
 558     WPAssert(updateMask && updateMask->GetCount() == m_valuesCount);
 559
 560     *data << (uint8)updateMask->GetBlockCount();
 561     data->append( updateMask->GetMask(), updateMask->GetLength() );
 562
 563     // 2 specialized loops for speed optimization in non-unit case
 564     if(isType(TYPEMASK_UNIT))                               // unit (creature/player) case
 565     {
 566         for( uint16 index = 0; index < m_valuesCount; index ++ )
 567         {
 568             if( updateMask->GetBit( index ) )
 569             {
 570                 // remove custom flag before send
 571                 if( index == UNIT_NPC_FLAGS )
 572                     *data << uint32(m_uint32Values[ index ] & ~UNIT_NPC_FLAG_GUARD);
 573                 // FIXME: Some values at server stored in float format but must be sent to client in uint32 format
 574                 else if(index >= UNIT_FIELD_BASEATTACKTIME && index <= UNIT_FIELD_RANGEDATTACKTIME)
 575                 {
 576                     // convert from float to uint32 and send
 577                     *data << uint32(m_floatValues[ index ] < 0 ? 0 : m_floatValues[ index ]);
 578                 }
 579                 // there are some float values which may be negative or can't get negative due to other checks
 580                 else if(index >= UNIT_FIELD_NEGSTAT0   && index <= UNIT_FIELD_NEGSTAT4 ||
 581                     index >= UNIT_FIELD_RESISTANCEBUFFMODSPOSITIVE  && index <= (UNIT_FIELD_RESISTANCEBUFFMODSPOSITIVE + 6) ||
 582                     index >= UNIT_FIELD_RESISTANCEBUFFMODSNEGATIVE  && index <= (UNIT_FIELD_RESISTANCEBUFFMODSNEGATIVE + 6) ||
 583                     index >= UNIT_FIELD_POSSTAT0   && index <= UNIT_FIELD_POSSTAT4)
 584                 {
 585                     *data << uint32(m_floatValues[ index ]);
 586                 }
 587                 // Gamemasters should be always able to select units - remove not selectable flag
 588                 else if(index == UNIT_FIELD_FLAGS && target->isGameMaster())
 589                 {
 590                     *data << (m_uint32Values[ index ] & ~UNIT_FLAG_NOT_SELECTABLE);
 591                 }
 592                 // hide lootable animation for unallowed players
 593                 else if(index == UNIT_DYNAMIC_FLAGS && GetTypeId() == TYPEID_UNIT)
 594                 {
 595                     if(!target->isAllowedToLoot((Creature*)this))
 596                         *data << (m_uint32Values[ index ] & ~UNIT_DYNFLAG_LOOTABLE);
 597                     else
 598                         *data << (m_uint32Values[ index ] & ~UNIT_DYNFLAG_OTHER_TAGGER);
 599                 }
 600                 else
 601                 {
 602                     // send in current format (float as float, uint32 as uint32)
 603                     *data << m_uint32Values[ index ];
 604                 }
 605             }
 606         }
 607     }
 608     else if(isType(TYPEMASK_GAMEOBJECT))                    // gameobject case
 609     {
 610         for( uint16 index = 0; index < m_valuesCount; index ++ )
 611         {
 612             if( updateMask->GetBit( index ) )
 613             {
 614                 // send in current format (float as float, uint32 as uint32)
 615                 if ( index == GAMEOBJECT_DYN_FLAGS )
 616                 {
 617                     if(IsActivateToQuest )
 618                     {
 619                         switch(((GameObject*)this)->GetGoType())
 620                         {
 621                             case GAMEOBJECT_TYPE_CHEST:
 622                                 *data << uint32(9);         // enable quest object. Represent 9, but 1 for client before 2.3.0
 623                                 break;
 624                             case GAMEOBJECT_TYPE_GOOBER:
 625                                 *data << uint32(1);
 626                                 break;
 627                             default:
 628                                 *data << uint32(0);         //unknown. not happen.
 629                                 break;
 630                         }
 631                     }
 632                     else
 633                         *data << uint32(0);                 // disable quest object
 634                 }
 635                 else
 636                     *data << m_uint32Values[ index ];       // other cases
 637             }
 638         }
 639     }
 640     else                                                    // other objects case (no special index checks)
 641     {
 642         for( uint16 index = 0; index < m_valuesCount; index ++ )
 643         {
 644             if( updateMask->GetBit( index ) )
 645             {
 646                 // send in current format (float as float, uint32 as uint32)
 647                 *data << m_uint32Values[ index ];
 648             }
 649         }
 650     }
 651 }
 652
 653 void Object::ClearUpdateMask(bool remove)
 654 {
 655     for( uint16 index = 0; index < m_valuesCount; index ++ )
 656     {
 657         if(m_uint32Values_mirror[index]!= m_uint32Values[index])
 658             m_uint32Values_mirror[index] = m_uint32Values[index];
 659     }
 660     if(m_objectUpdated)
 661     {
 662         if(remove)
 663             ObjectAccessor::Instance().RemoveUpdateObject(this);
 664         m_objectUpdated = false;
 665     }
 666 }
 667
 668 // Send current value fields changes to all viewers
 669 void Object::SendUpdateObjectToAllExcept(Player* exceptPlayer)
 670 {
 671     // changes will be send in create packet
 672     if(!IsInWorld())
 673         return;
 674
 675     // nothing do
 676     if(!m_objectUpdated)
 677         return;
 678
 679     ObjectAccessor::UpdateObject(this,exceptPlayer);
 680 }
 681
 682 bool Object::LoadValues(const char* data)
 683 {
 684     if(!m_uint32Values) _InitValues();
 685
 686     Tokens tokens = StrSplit(data, " ");
 687
 688     if(tokens.size() != m_valuesCount)
 689         return false;
 690
 691     Tokens::iterator iter;
 692     int index;
 693     for (iter = tokens.begin(), index = 0; index < m_valuesCount; ++iter, ++index)
 694     {
 695         m_uint32Values[index] = atol((*iter).c_str());
 696     }
 697
 698     return true;
 699 }
 700
 701 void Object::_SetUpdateBits(UpdateMask *updateMask, Player* /*target*/) const
 702 {
 703     for( uint16 index = 0; index < m_valuesCount; index ++ )
 704     {
 705         if(m_uint32Values_mirror[index]!= m_uint32Values[index])
 706             updateMask->SetBit(index);
 707     }
 708 }
 709
 710 void Object::_SetCreateBits(UpdateMask *updateMask, Player* /*target*/) const
 711 {
 712     for( uint16 index = 0; index < m_valuesCount; index++ )
 713     {
 714         if(GetUInt32Value(index) != 0)
 715             updateMask->SetBit(index);
 716     }
 717 }
 718
 719 void Object::SetInt32Value( uint16 index, int32 value )
 720 {
 721     ASSERT( index < m_valuesCount || PrintIndexError( index , true ) );
 722
 723     if(m_int32Values[ index ] != value)
 724     {
 725         m_int32Values[ index ] = value;
 726
 727         if(m_inWorld)
 728         {
 729             if(!m_objectUpdated)
 730             {
 731                 ObjectAccessor::Instance().AddUpdateObject(this);
 732                 m_objectUpdated = true;
 733             }
 734         }
 735     }
 736 }
 737
 738 void Object::SetUInt32Value( uint16 index, uint32 value )
 739 {
 740     ASSERT( index < m_valuesCount || PrintIndexError( index , true ) );
 741
 742     if(m_uint32Values[ index ] != value)
 743     {
 744         m_uint32Values[ index ] = value;
 745
 746         if(m_inWorld)
 747         {
 748             if(!m_objectUpdated)
 749             {
 750                 ObjectAccessor::Instance().AddUpdateObject(this);
 751                 m_objectUpdated = true;
 752             }
 753         }
 754     }
 755 }
 756
 757 void Object::SetUInt64Value( uint16 index, const uint64 &value )
 758 {
 759     ASSERT( index + 1 < m_valuesCount || PrintIndexError( index , true ) );
 760     if(*((uint64*)&(m_uint32Values[ index ])) != value)
 761     {
 762         m_uint32Values[ index ] = *((uint32*)&value);
 763         m_uint32Values[ index + 1 ] = *(((uint32*)&value) + 1);
 764
 765         if(m_inWorld)
 766         {
 767             if(!m_objectUpdated)
 768             {
 769                 ObjectAccessor::Instance().AddUpdateObject(this);
 770                 m_objectUpdated = true;
 771             }
 772         }
 773     }
 774 }
 775
 776 void Object::SetFloatValue( uint16 index, float value )
 777 {
 778     ASSERT( index < m_valuesCount || PrintIndexError( index , true ) );
 779
 780     if(m_floatValues[ index ] != value)
 781     {
 782         m_floatValues[ index ] = value;
 783
 784         if(m_inWorld)
 785         {
 786             if(!m_objectUpdated)
 787             {
 788                 ObjectAccessor::Instance().AddUpdateObject(this);
 789                 m_objectUpdated = true;
 790             }
 791         }
 792     }
 793 }
 794
 795 void Object::SetByteValue( uint16 index, uint8 offset, uint8 value )
 796 {
 797     ASSERT( index < m_valuesCount || PrintIndexError( index , true ) );
 798
 799     if(offset > 4)
 800     {
 801         sLog.outError("Object::SetByteValue: wrong offset %u", offset);
 802         return;
 803     }
 804
 805     if(uint8(m_uint32Values[ index ] >> (offset * 8)) != value)
 806     {
 807         m_uint32Values[ index ] &= ~uint32(uint32(0xFF) << (offset * 8));
 808         m_uint32Values[ index ] |= uint32(uint32(value) << (offset * 8));
 809
 810         if(m_inWorld)
 811         {
 812             if(!m_objectUpdated)
 813             {
 814                 ObjectAccessor::Instance().AddUpdateObject(this);
 815                 m_objectUpdated = true;
 816             }
 817         }
 818     }
 819 }
 820
 821 void Object::SetUInt16Value( uint16 index, uint8 offset, uint16 value )
 822 {
 823     ASSERT( index < m_valuesCount || PrintIndexError( index , true ) );
 824
 825     if(offset > 2)
 826     {
 827         sLog.outError("Object::SetUInt16Value: wrong offset %u", offset);
 828         return;
 829     }
 830
 831     if(uint8(m_uint32Values[ index ] >> (offset * 16)) != value)
 832     {
 833         m_uint32Values[ index ] &= ~uint32(uint32(0xFFFF) << (offset * 16));
 834         m_uint32Values[ index ] |= uint32(uint32(value) << (offset * 16));
 835
 836         if(m_inWorld)
 837         {
 838             if(!m_objectUpdated)
 839             {
 840                 ObjectAccessor::Instance().AddUpdateObject(this);
 841                 m_objectUpdated = true;
 842             }
 843         }
 844     }
 845 }
 846
 847 void Object::SetStatFloatValue( uint16 index, float value)
 848 {
 849     if(value < 0)
 850         value = 0.0f;
 851
 852     SetFloatValue(index, value);
 853 }
 854
 855 void Object::SetStatInt32Value( uint16 index, int32 value)
 856 {
 857     if(value < 0)
 858         value = 0;
 859
 860     SetUInt32Value(index, uint32(value));
 861 }
 862
 863 void Object::ApplyModUInt32Value(uint16 index, int32 val, bool apply)
 864 {
 865     int32 cur = GetUInt32Value(index);
 866     cur += (apply ? val : -val);
 867     if(cur < 0)
 868         cur = 0;
 869     SetUInt32Value(index,cur);
 870 }
 871
 872 void Object::ApplyModInt32Value(uint16 index, int32 val, bool apply)
 873 {
 874     int32 cur = GetInt32Value(index);
 875     cur += (apply ? val : -val);
 876     SetInt32Value(index,cur);
 877 }
 878
 879 void Object::ApplyModSignedFloatValue(uint16 index, float  val, bool apply)
 880 {
 881     float cur = GetFloatValue(index);
 882     cur += (apply ? val : -val);
 883     SetFloatValue(index,cur);
 884 }
 885
 886 void Object::ApplyModPositiveFloatValue(uint16 index, float  val, bool apply)
 887 {
 888     float cur = GetFloatValue(index);
 889     cur += (apply ? val : -val);
 890     if(cur < 0)
 891         cur = 0;
 892     SetFloatValue(index,cur);
 893 }
 894
 895 void Object::SetFlag( uint16 index, uint32 newFlag )
 896 {
 897     ASSERT( index < m_valuesCount || PrintIndexError( index , true ) );
 898     uint32 oldval = m_uint32Values[ index ];
 899     uint32 newval = oldval | newFlag;
 900
 901     if(oldval != newval)
 902     {
 903         m_uint32Values[ index ] = newval;
 904
 905         if(m_inWorld)
 906         {
 907             if(!m_objectUpdated)
 908             {
 909                 ObjectAccessor::Instance().AddUpdateObject(this);
 910                 m_objectUpdated = true;
 911             }
 912         }
 913     }
 914 }
 915
 916 void Object::RemoveFlag( uint16 index, uint32 oldFlag )
 917 {
 918     ASSERT( index < m_valuesCount || PrintIndexError( index , true ) );
 919     uint32 oldval = m_uint32Values[ index ];
 920     uint32 newval = oldval & ~oldFlag;
 921
 922     if(oldval != newval)
 923     {
 924         m_uint32Values[ index ] = newval;
 925
 926         if(m_inWorld)
 927         {
 928             if(!m_objectUpdated)
 929             {
 930                 ObjectAccessor::Instance().AddUpdateObject(this);
 931                 m_objectUpdated = true;
 932             }
 933         }
 934     }
 935 }
 936
 937 bool Object::PrintIndexError(uint32 index, bool set) const
 938 {
 939     sLog.outError("ERROR: 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);
 940
 941     // assert must fail after function call
 942     return false;
 943 }
 944
 945 WorldObject::WorldObject()
 946 {
 947     m_positionX         = 0.0f;
 948     m_positionY         = 0.0f;
 949     m_positionZ         = 0.0f;
 950     m_orientation       = 0.0f;
 951
 952     m_mapId             = 0;
 953     m_InstanceId        = 0;
 954
 955     m_name = "";
 956
 957     mSemaphoreTeleport  = false;
 958 }
 959
 960 void WorldObject::_Create( uint32 guidlow, HighGuid guidhigh, uint32 mapid )
 961 {
 962     Object::_Create(guidlow, 0, guidhigh);
 963
 964     m_mapId = mapid;
 965 }
 966
 967 uint32 WorldObject::GetZoneId() const
 968 {
 969     return MapManager::Instance().GetBaseMap(m_mapId)->GetZoneId(m_positionX,m_positionY);
 970 }
 971
 972 uint32 WorldObject::GetAreaId() const
 973 {
 974     return MapManager::Instance().GetBaseMap(m_mapId)->GetAreaId(m_positionX,m_positionY);
 975 }
 976
 977 InstanceData* WorldObject::GetInstanceData()
 978 {
 979     Map *map = GetMap();
 980     return map->IsDungeon() ? ((InstanceMap*)map)->GetInstanceData() : NULL;
 981 }
 982
 983                                                             //slow
 984 float WorldObject::GetDistance(const WorldObject* obj) const
 985 {
 986     float dx = GetPositionX() - obj->GetPositionX();
 987     float dy = GetPositionY() - obj->GetPositionY();
 988     float dz = GetPositionZ() - obj->GetPositionZ();
 989     float sizefactor = GetObjectSize() + obj->GetObjectSize();
 990     float dist = sqrt((dx*dx) + (dy*dy) + (dz*dz)) - sizefactor;
 991     return ( dist > 0 ? dist : 0);
 992 }
 993
 994 float WorldObject::GetDistance2d(float x, float y) const
 995 {
 996     float dx = GetPositionX() - x;
 997     float dy = GetPositionY() - y;
 998     float sizefactor = GetObjectSize();
 999     float dist = sqrt((dx*dx) + (dy*dy)) - sizefactor;
1000     return ( dist > 0 ? dist : 0);
1001 }
1002
1003 float WorldObject::GetDistance(const float x, const float y, const float z) const
1004 {
1005     float dx = GetPositionX() - x;
1006     float dy = GetPositionY() - y;
1007     float dz = GetPositionZ() - z;
1008     float sizefactor = GetObjectSize();
1009     float dist = sqrt((dx*dx) + (dy*dy) + (dz*dz)) - sizefactor;
1010     return ( dist > 0 ? dist : 0);
1011 }
1012
1013 float WorldObject::GetDistance2d(const WorldObject* obj) const
1014 {
1015     float dx = GetPositionX() - obj->GetPositionX();
1016     float dy = GetPositionY() - obj->GetPositionY();
1017     float sizefactor = GetObjectSize() + obj->GetObjectSize();
1018     float dist = sqrt((dx*dx) + (dy*dy)) - sizefactor;
1019     return ( dist > 0 ? dist : 0);
1020 }
1021
1022 float WorldObject::GetDistanceZ(const WorldObject* obj) const
1023 {
1024     float dz = fabs(GetPositionZ() - obj->GetPositionZ());
1025     float sizefactor = GetObjectSize() + obj->GetObjectSize();
1026     float dist = dz - sizefactor;
1027     return ( dist > 0 ? dist : 0);
1028 }
1029
1030 bool WorldObject::IsWithinDistInMap(const WorldObject* obj, const float dist2compare) const
1031 {
1032     if (!obj || !IsInMap(obj)) return false;
1033
1034     float dx = GetPositionX() - obj->GetPositionX();
1035     float dy = GetPositionY() - obj->GetPositionY();
1036     float dz = GetPositionZ() - obj->GetPositionZ();
1037     float distsq = dx*dx + dy*dy + dz*dz;
1038     float sizefactor = GetObjectSize() + obj->GetObjectSize();
1039     float maxdist = dist2compare + sizefactor;
1040
1041     return distsq < maxdist * maxdist;
1042 }
1043
1044 bool WorldObject::IsWithinLOSInMap(const WorldObject* obj) const
1045 {
1046     if (!IsInMap(obj)) return false;
1047     float ox,oy,oz;
1048     obj->GetPosition(ox,oy,oz);
1049     return(IsWithinLOS(ox, oy, oz ));
1050 }
1051
1052 bool WorldObject::IsWithinLOS(const float ox, const float oy, const float oz ) const
1053 {
1054     float x,y,z;
1055     GetPosition(x,y,z);
1056     VMAP::IVMapManager *vMapManager = VMAP::VMapFactory::createOrGetVMapManager();
1057     return vMapManager->isInLineOfSight(GetMapId(), x, y, z+2.0f, ox, oy, oz+2.0f);
1058 }
1059
1060 float WorldObject::GetAngle(const WorldObject* obj) const
1061 {
1062     if(!obj) return 0;
1063     return GetAngle( obj->GetPositionX(), obj->GetPositionY() );
1064 }
1065
1066 // Return angle in range 0..2*pi
1067 float WorldObject::GetAngle( const float x, const float y ) const
1068 {
1069     float dx = x - GetPositionX();
1070     float dy = y - GetPositionY();
1071
1072     float ang = atan2(dy, dx);
1073     ang = (ang >= 0) ? ang : 2 * M_PI + ang;
1074     return ang;
1075 }
1076
1077 bool WorldObject::HasInArc(const float arcangle, const WorldObject* obj) const
1078 {
1079     float arc = arcangle;
1080
1081     // move arc to range 0.. 2*pi
1082     while( arc >= 2.0f * M_PI )
1083         arc -=  2.0f * M_PI;
1084     while( arc < 0 )
1085         arc +=  2.0f * M_PI;
1086
1087     float angle = GetAngle( obj );
1088     angle -= m_orientation;
1089
1090     // move angle to range -pi ... +pi
1091     while( angle > M_PI)
1092         angle -= 2.0f * M_PI;
1093     while(angle < -M_PI)
1094         angle += 2.0f * M_PI;
1095
1096     float lborder =  -1 * (arc/2.0f);                       // in range -pi..0
1097     float rborder = (arc/2.0f);                             // in range 0..pi
1098     return (( angle >= lborder ) && ( angle <= rborder ));
1099 }
1100
1101 void WorldObject::GetRandomPoint( float x, float y, float z, float distance, float &rand_x, float &rand_y, float &rand_z) const
1102 {
1103     if(distance==0)
1104     {
1105         rand_x = x;
1106         rand_y = y;
1107         rand_z = z;
1108         return;
1109     }
1110
1111     // angle to face `obj` to `this`
1112     float angle = rand_norm()*2*M_PI;
1113     float new_dist = rand_norm()*distance;
1114
1115     rand_x = x + new_dist * cos(angle);
1116     rand_y = y + new_dist * sin(angle);
1117     rand_z = z;
1118
1119     MaNGOS::NormalizeMapCoord(rand_x);
1120     MaNGOS::NormalizeMapCoord(rand_y);
1121     UpdateGroundPositionZ(rand_x,rand_y,rand_z);            // update to LOS height if available
1122 }
1123
1124 void WorldObject::UpdateGroundPositionZ(float x, float y, float &z) const
1125 {
1126     float new_z = MapManager::Instance().GetBaseMap(GetMapId())->GetHeight(x,y,z,true);
1127     if(new_z > INVALID_HEIGHT)
1128         z = new_z+ 0.05f;                                   // just to be sure that we are not a few pixel under the surface
1129 }
1130
1131 bool WorldObject::IsPositionValid() const
1132 {
1133     return MaNGOS::IsValidMapCoord(m_positionX,m_positionY,m_positionZ,m_orientation);
1134 }
1135
1136 void WorldObject::MonsterSay(const char* text, uint32 language, uint64 TargetGuid)
1137 {
1138     WorldPacket data(SMSG_MESSAGECHAT, 200);
1139     BuildMonsterChat(&data,CHAT_MSG_MONSTER_SAY,text,language,GetName(),TargetGuid);
1140     SendMessageToSetInRange(&data,sWorld.getConfig(CONFIG_LISTEN_RANGE_SAY),true);
1141 }
1142
1143 void WorldObject::MonsterYell(const char* text, uint32 language, uint64 TargetGuid)
1144 {
1145     WorldPacket data(SMSG_MESSAGECHAT, 200);
1146     BuildMonsterChat(&data,CHAT_MSG_MONSTER_YELL,text,language,GetName(),TargetGuid);
1147     SendMessageToSetInRange(&data,sWorld.getConfig(CONFIG_LISTEN_RANGE_YELL),true);
1148 }
1149
1150 void WorldObject::MonsterTextEmote(const char* text, uint64 TargetGuid, bool IsBossEmote)
1151 {
1152     WorldPacket data(SMSG_MESSAGECHAT, 200);
1153     BuildMonsterChat(&data,IsBossEmote ? CHAT_MSG_RAID_BOSS_EMOTE : CHAT_MSG_MONSTER_EMOTE,text,LANG_UNIVERSAL,GetName(),TargetGuid);
1154     SendMessageToSetInRange(&data,sWorld.getConfig(CONFIG_LISTEN_RANGE_TEXTEMOTE),true);
1155 }
1156
1157 void WorldObject::MonsterWhisper(const char* text, uint64 receiver, bool IsBossWhisper)
1158 {
1159     Player *player = objmgr.GetPlayer(receiver);
1160     if(!player || !player->GetSession())
1161         return;
1162
1163     WorldPacket data(SMSG_MESSAGECHAT, 200);
1164     BuildMonsterChat(&data,IsBossWhisper ? CHAT_MSG_RAID_BOSS_WHISPER : CHAT_MSG_MONSTER_WHISPER,text,LANG_UNIVERSAL,GetName(),receiver);
1165
1166     player->GetSession()->SendPacket(&data);
1167 }
1168
1169 namespace MaNGOS
1170 {
1171     class MessageChatLocaleCacheDo
1172     {
1173         public:
1174             MessageChatLocaleCacheDo(WorldObject const& obj, ChatMsg msgtype, int32 textId, uint32 language, uint64 targetGUID, float dist)
1175                 : i_object(obj), i_msgtype(msgtype), i_textId(textId), i_language(language),
1176                 i_targetGUID(targetGUID), i_dist(dist)
1177             {
1178             }
1179
1180             ~MessageChatLocaleCacheDo()
1181             {
1182                 for(int i = 0; i < i_data_cache.size(); ++i)
1183                     delete i_data_cache[i];
1184             }
1185
1186             void operator()(Player* p)
1187             {
1188                 // skip far away players
1189                 if(p->GetDistance(&i_object) > i_dist)
1190                     return;
1191
1192                 uint32 loc_idx = p->GetSession()->GetSessionDbLocaleIndex();
1193                 uint32 cache_idx = loc_idx+1;
1194                 WorldPacket* data;
1195
1196                 // create if not cached yet
1197                 if(i_data_cache.size() < cache_idx+1 || !i_data_cache[cache_idx])
1198                 {
1199                     if(i_data_cache.size() < cache_idx+1)
1200                         i_data_cache.resize(cache_idx+1);
1201
1202                     char const* text = objmgr.GetMangosString(i_textId,loc_idx);
1203
1204                     data = new WorldPacket(SMSG_MESSAGECHAT, 200);
1205
1206                     // TODO: i_object.GetName() also must be localized?
1207                     i_object.BuildMonsterChat(data,i_msgtype,text,i_language,i_object.GetNameForLocaleIdx(loc_idx),i_targetGUID);
1208
1209                     i_data_cache[cache_idx] = data;
1210                 }
1211                 else
1212                     data = i_data_cache[cache_idx];
1213
1214                 p->SendDirectMessage(data);
1215             }
1216
1217         private:
1218             WorldObject const& i_object;
1219             ChatMsg i_msgtype;
1220             int32 i_textId;
1221             uint32 i_language;
1222             uint64 i_targetGUID;
1223             float i_dist;
1224             std::vector<WorldPacket*> i_data_cache;             // 0 = default, i => i-1 locale index
1225     };
1226 }                                                           // namespace MaNGOS
1227
1228 void WorldObject::MonsterSay(int32 textId, uint32 language, uint64 TargetGuid)
1229 {
1230     CellPair p = MaNGOS::ComputeCellPair(GetPositionX(), GetPositionY());
1231
1232     Cell cell(p);
1233     cell.data.Part.reserved = ALL_DISTRICT;
1234     cell.SetNoCreate();
1235
1236     MaNGOS::MessageChatLocaleCacheDo say_do(*this, CHAT_MSG_MONSTER_SAY, textId,language,TargetGuid,sWorld.getConfig(CONFIG_LISTEN_RANGE_SAY));
1237     MaNGOS::PlayerWorker<MaNGOS::MessageChatLocaleCacheDo> say_worker(say_do);
1238     TypeContainerVisitor<MaNGOS::PlayerWorker<MaNGOS::MessageChatLocaleCacheDo>, WorldTypeMapContainer > message(say_worker);
1239     CellLock<GridReadGuard> cell_lock(cell, p);
1240     cell_lock->Visit(cell_lock, message, *GetMap());
1241 }
1242
1243 void WorldObject::MonsterYell(int32 textId, uint32 language, uint64 TargetGuid)
1244 {
1245     CellPair p = MaNGOS::ComputeCellPair(GetPositionX(), GetPositionY());
1246
1247     Cell cell(p);
1248     cell.data.Part.reserved = ALL_DISTRICT;
1249     cell.SetNoCreate();
1250
1251     MaNGOS::MessageChatLocaleCacheDo say_do(*this, CHAT_MSG_MONSTER_YELL, textId,language,TargetGuid,sWorld.getConfig(CONFIG_LISTEN_RANGE_YELL));
1252     MaNGOS::PlayerWorker<MaNGOS::MessageChatLocaleCacheDo> say_worker(say_do);
1253     TypeContainerVisitor<MaNGOS::PlayerWorker<MaNGOS::MessageChatLocaleCacheDo>, WorldTypeMapContainer > message(say_worker);
1254     CellLock<GridReadGuard> cell_lock(cell, p);
1255     cell_lock->Visit(cell_lock, message, *GetMap());
1256 }
1257
1258 void WorldObject::MonsterTextEmote(int32 textId, uint64 TargetGuid, bool IsBossEmote)
1259 {
1260     CellPair p = MaNGOS::ComputeCellPair(GetPositionX(), GetPositionY());
1261
1262     Cell cell(p);
1263     cell.data.Part.reserved = ALL_DISTRICT;
1264     cell.SetNoCreate();
1265
1266     MaNGOS::MessageChatLocaleCacheDo say_do(*this, IsBossEmote ? CHAT_MSG_RAID_BOSS_EMOTE : CHAT_MSG_MONSTER_EMOTE, textId,LANG_UNIVERSAL,TargetGuid,sWorld.getConfig(CONFIG_LISTEN_RANGE_TEXTEMOTE));
1267     MaNGOS::PlayerWorker<MaNGOS::MessageChatLocaleCacheDo> say_worker(say_do);
1268     TypeContainerVisitor<MaNGOS::PlayerWorker<MaNGOS::MessageChatLocaleCacheDo>, WorldTypeMapContainer > message(say_worker);
1269     CellLock<GridReadGuard> cell_lock(cell, p);
1270     cell_lock->Visit(cell_lock, message, *GetMap());
1271 }
1272
1273 void WorldObject::MonsterWhisper(int32 textId, uint64 receiver, bool IsBossWhisper)
1274 {
1275     Player *player = objmgr.GetPlayer(receiver);
1276     if(!player || !player->GetSession())
1277         return;
1278
1279     uint32 loc_idx = player->GetSession()->GetSessionDbLocaleIndex();
1280     char const* text = objmgr.GetMangosString(textId,loc_idx);
1281
1282     WorldPacket data(SMSG_MESSAGECHAT, 200);
1283     BuildMonsterChat(&data,IsBossWhisper ? CHAT_MSG_RAID_BOSS_WHISPER : CHAT_MSG_MONSTER_WHISPER,text,LANG_UNIVERSAL,GetName(),receiver);
1284
1285     player->GetSession()->SendPacket(&data);
1286 }
1287
1288 void WorldObject::BuildMonsterChat(WorldPacket *data, uint8 msgtype, char const* text, uint32 language, char const* name, uint64 targetGuid) const
1289 {
1290     bool pre = (msgtype==CHAT_MSG_MONSTER_EMOTE || msgtype==CHAT_MSG_RAID_BOSS_EMOTE);
1291
1292     *data << (uint8)msgtype;
1293     *data << (uint32)language;
1294     *data << (uint64)GetGUID();
1295     *data << (uint32)0;                                     //2.1.0
1296     *data << (uint32)(strlen(name)+1);
1297     *data << name;
1298     *data << (uint64)targetGuid;                            //Unit Target
1299     if( targetGuid && !IS_PLAYER_GUID(targetGuid) )
1300     {
1301         *data << (uint32)1;                                 // target name length
1302         *data << (uint8)0;                                  // target name
1303     }
1304     *data << (uint32)(strlen(text)+1+(pre?3:0));
1305     if(pre)
1306         data->append("%s ",3);
1307     *data << text;
1308     *data << (uint8)0;                                      // ChatTag
1309 }
1310
1311 void WorldObject::BuildHeartBeatMsg(WorldPacket *data) const
1312 {
1313     //Heartbeat message cannot be used for non-units
1314     if (!isType(TYPEMASK_UNIT))
1315         return;
1316
1317     data->Initialize(MSG_MOVE_HEARTBEAT, 32);
1318     data->append(GetPackGUID());
1319     *data << uint32(((Unit*)this)->GetUnitMovementFlags()); // movement flags
1320     *data << uint8(0);                                      // 2.3.0
1321     *data << getMSTime();                                   // time
1322     *data << m_positionX;
1323     *data << m_positionY;
1324     *data << m_positionZ;
1325     *data << m_orientation;
1326     *data << uint32(0);
1327 }
1328
1329 void WorldObject::BuildTeleportAckMsg(WorldPacket *data, float x, float y, float z, float ang) const
1330 {
1331     //TeleportAck message cannot be used for non-units
1332     if (!isType(TYPEMASK_UNIT))
1333         return;
1334
1335     data->Initialize(MSG_MOVE_TELEPORT_ACK, 41);
1336     data->append(GetPackGUID());
1337     *data << uint32(0);                                     // this value increments every time
1338     *data << uint32(((Unit*)this)->GetUnitMovementFlags()); // movement flags
1339     *data << uint8(0);                                      // 2.3.0
1340     *data << getMSTime();                                   // time
1341     *data << x;
1342     *data << y;
1343     *data << z;
1344     *data << ang;
1345     *data << uint32(0);
1346 }
1347
1348 void WorldObject::SendMessageToSet(WorldPacket *data, bool /*bToSelf*/)
1349 {
1350     GetMap()->MessageBroadcast(this, data);
1351 }
1352
1353 void WorldObject::SendMessageToSetInRange(WorldPacket *data, float dist, bool /*bToSelf*/)
1354 {
1355     GetMap()->MessageDistBroadcast(this, data, dist);
1356 }
1357
1358 void WorldObject::SendObjectDeSpawnAnim(uint64 guid)
1359 {
1360     WorldPacket data(SMSG_GAMEOBJECT_DESPAWN_ANIM, 8);
1361     data << guid;
1362     SendMessageToSet(&data, true);
1363 }
1364
1365 Map* WorldObject::GetMap() const
1366 {
1367     return MapManager::Instance().GetMap(GetMapId(), this);
1368 }
1369
1370 Map const* WorldObject::GetBaseMap() const
1371 {
1372     return MapManager::Instance().GetBaseMap(GetMapId());
1373 }
1374
1375 void WorldObject::AddObjectToRemoveList()
1376 {
1377     Map* map = GetMap();
1378     if(!map)
1379     {
1380         sLog.outError("Object (TypeId: %u Entry: %u GUID: %u) at attempt add to move list not have valid map (Id: %u).",GetTypeId(),GetEntry(),GetGUIDLow(),GetMapId());
1381         return;
1382     }
1383
1384     map->AddObjectToRemoveList(this);
1385 }
1386
1387 Creature* WorldObject::SummonCreature(uint32 id, float x, float y, float z, float ang,TempSummonType spwtype,uint32 despwtime)
1388 {
1389     TemporarySummon* pCreature = new TemporarySummon(GetGUID());
1390
1391     pCreature->SetInstanceId(GetInstanceId());
1392     uint32 team = 0;
1393     if (GetTypeId()==TYPEID_PLAYER)
1394         team = ((Player*)this)->GetTeam();
1395
1396     if (!pCreature->Create(objmgr.GenerateLowGuid(HIGHGUID_UNIT), GetMap(), id, team))
1397     {
1398         delete pCreature;
1399         return NULL;
1400     }
1401
1402     if (x == 0.0f && y == 0.0f && z == 0.0f)
1403         GetClosePoint(x, y, z, pCreature->GetObjectSize());
1404
1405     pCreature->Relocate(x, y, z, ang);
1406
1407     if(!pCreature->IsPositionValid())
1408     {
1409         sLog.outError("ERROR: Creature (guidlow %d, entry %d) not summoned. Suggested coordinates isn't valid (X: %f Y: %f)",pCreature->GetGUIDLow(),pCreature->GetEntry(),pCreature->GetPositionX(),pCreature->GetPositionY());
1410         delete pCreature;
1411         return NULL;
1412     }
1413
1414     pCreature->Summon(spwtype, despwtime);
1415
1416     if(GetTypeId()==TYPEID_UNIT && ((Creature*)this)->AI())
1417         ((Creature*)this)->AI()->JustSummoned(pCreature);
1418
1419     //return the creature therewith the summoner has access to it
1420     return pCreature;
1421 }
1422
1423 namespace MaNGOS
1424 {
1425     class NearUsedPosDo
1426     {
1427         public:
1428             NearUsedPosDo(WorldObject const& obj, WorldObject const* searcher, float angle, ObjectPosSelector& selector)
1429                 : i_object(obj), i_searcher(searcher), i_angle(angle), i_selector(selector) {}
1430
1431             void operator()(Corpse*) const {}
1432             void operator()(DynamicObject*) const {}
1433
1434             void operator()(Creature* c) const
1435             {
1436                 // skip self or target
1437                 if(c==i_searcher || c==&i_object)
1438                     return;
1439
1440                 float x,y,z;
1441
1442                 if( !c->isAlive() || c->hasUnitState(UNIT_STAT_ROOT | UNIT_STAT_STUNNED | UNIT_STAT_DISTRACTED) ||
1443                     !c->GetMotionMaster()->GetDestination(x,y,z) )
1444                 {
1445                     x = c->GetPositionX();
1446                     y = c->GetPositionY();
1447                 }
1448
1449                 add(c,x,y);
1450             }
1451
1452             template<class T>
1453                 void operator()(T* u) const
1454             {
1455                 // skip self or target
1456                 if(u==i_searcher || u==&i_object)
1457                     return;
1458
1459                 float x,y;
1460
1461                 x = u->GetPositionX();
1462                 y = u->GetPositionY();
1463
1464                 add(u,x,y);
1465             }
1466
1467             // we must add used pos that can fill places around center
1468             void add(WorldObject* u, float x, float y) const
1469             {
1470                 // dist include size of u
1471                 float dist2d = i_object.GetDistance2d(x,y);
1472
1473                 // u is too nearest to i_object
1474                 if(dist2d + i_object.GetObjectSize() + u->GetObjectSize() < i_selector.m_dist - i_selector.m_size)
1475                     return;
1476
1477                 // u is too far away from i_object
1478                 if(dist2d + i_object.GetObjectSize() - u->GetObjectSize() > i_selector.m_dist + i_selector.m_size)
1479                     return;
1480
1481                 float angle = i_object.GetAngle(u)-i_angle;
1482
1483                 // move angle to range -pi ... +pi
1484                 while( angle > M_PI)
1485                     angle -= 2.0f * M_PI;
1486                 while(angle < -M_PI)
1487                     angle += 2.0f * M_PI;
1488
1489                 i_selector.AddUsedPos(u->GetObjectSize(),angle,dist2d + i_object.GetObjectSize());
1490             }
1491         private:
1492             WorldObject const& i_object;
1493             WorldObject const* i_searcher;
1494             float              i_angle;
1495             ObjectPosSelector& i_selector;
1496     };
1497 }                                                           // namespace MaNGOS
1498
1499 //===================================================================================================
1500
1501 void WorldObject::GetNearPoint2D(float &x, float &y, float distance2d, float absAngle ) const
1502 {
1503     x = GetPositionX() + (GetObjectSize() + distance2d) * cos(absAngle);
1504     y = GetPositionY() + (GetObjectSize() + distance2d) * sin(absAngle);
1505
1506     MaNGOS::NormalizeMapCoord(x);
1507     MaNGOS::NormalizeMapCoord(y);
1508 }
1509
1510 void WorldObject::GetNearPoint(WorldObject const* searcher, float &x, float &y, float &z, float searcher_size, float distance2d, float absAngle ) const
1511 {
1512     GetNearPoint2D(x,y,distance2d+searcher_size,absAngle);
1513     z = GetPositionZ();
1514
1515     // if detection disabled, return first point
1516     if(!sWorld.getConfig(CONFIG_DETECT_POS_COLLISION))
1517     {
1518         UpdateGroundPositionZ(x,y,z);                       // update to LOS height if available
1519         return;
1520     }
1521
1522     // or remember first point
1523     float first_x = x;
1524     float first_y = y;
1525     bool first_los_conflict = false;                        // first point LOS problems
1526
1527     // prepare selector for work
1528     ObjectPosSelector selector(GetPositionX(),GetPositionY(),GetObjectSize(),distance2d+searcher_size);
1529
1530     // adding used positions around object
1531     {
1532         CellPair p(MaNGOS::ComputeCellPair(GetPositionX(), GetPositionY()));
1533         Cell cell(p);
1534         cell.data.Part.reserved = ALL_DISTRICT;
1535         cell.SetNoCreate();
1536
1537         MaNGOS::NearUsedPosDo u_do(*this,searcher,absAngle,selector);
1538         MaNGOS::WorldObjectWorker<MaNGOS::NearUsedPosDo> worker(u_do);
1539
1540         TypeContainerVisitor<MaNGOS::WorldObjectWorker<MaNGOS::NearUsedPosDo>, GridTypeMapContainer  > grid_obj_worker(worker);
1541         TypeContainerVisitor<MaNGOS::WorldObjectWorker<MaNGOS::NearUsedPosDo>, WorldTypeMapContainer > world_obj_worker(worker);
1542
1543         CellLock<GridReadGuard> cell_lock(cell, p);
1544         cell_lock->Visit(cell_lock, grid_obj_worker,  *GetMap());
1545         cell_lock->Visit(cell_lock, world_obj_worker, *GetMap());
1546     }
1547
1548     // maybe can just place in primary position
1549     if( selector.CheckOriginal() )
1550     {
1551         UpdateGroundPositionZ(x,y,z);                       // update to LOS height if available
1552
1553         if(IsWithinLOS(x,y,z))
1554             return;
1555
1556         first_los_conflict = true;                          // first point have LOS problems
1557     }
1558
1559     float angle;                                            // candidate of angle for free pos
1560
1561     // special case when one from list empty and then empty side preferred
1562     if(selector.FirstAngle(angle))
1563     {
1564         GetNearPoint2D(x,y,distance2d,absAngle+angle);
1565         z = GetPositionZ();
1566         UpdateGroundPositionZ(x,y,z);                       // update to LOS height if available
1567
1568         if(IsWithinLOS(x,y,z))
1569             return;
1570     }
1571
1572     // set first used pos in lists
1573     selector.InitializeAngle();
1574
1575     // select in positions after current nodes (selection one by one)
1576     while(selector.NextAngle(angle))                        // angle for free pos
1577     {
1578         GetNearPoint2D(x,y,distance2d,absAngle+angle);
1579         z = GetPositionZ();
1580         UpdateGroundPositionZ(x,y,z);                       // update to LOS height if available
1581
1582         if(IsWithinLOS(x,y,z))
1583             return;
1584     }
1585
1586     // BAD NEWS: not free pos (or used or have LOS problems)
1587     // Attempt find _used_ pos without LOS problem
1588
1589     if(!first_los_conflict)
1590     {
1591         x = first_x;
1592         y = first_y;
1593
1594         UpdateGroundPositionZ(x,y,z);                       // update to LOS height if available
1595         return;
1596     }
1597
1598     // special case when one from list empty and then empty side preferred
1599     if( selector.IsNonBalanced() )
1600     {
1601         if(!selector.FirstAngle(angle))                     // _used_ pos
1602         {
1603             GetNearPoint2D(x,y,distance2d,absAngle+angle);
1604             z = GetPositionZ();
1605             UpdateGroundPositionZ(x,y,z);                   // update to LOS height if available
1606
1607             if(IsWithinLOS(x,y,z))
1608                 return;
1609         }
1610     }
1611
1612     // set first used pos in lists
1613     selector.InitializeAngle();
1614
1615     // select in positions after current nodes (selection one by one)
1616     while(selector.NextUsedAngle(angle))                    // angle for used pos but maybe without LOS problem
1617     {
1618         GetNearPoint2D(x,y,distance2d,absAngle+angle);
1619         z = GetPositionZ();
1620         UpdateGroundPositionZ(x,y,z);                       // update to LOS height if available
1621
1622         if(IsWithinLOS(x,y,z))
1623             return;
1624     }
1625
1626     // BAD BAD NEWS: all found pos (free and used) have LOS problem :(
1627     x = first_x;
1628     y = first_y;
1629
1630     UpdateGroundPositionZ(x,y,z);                           // update to LOS height if available
1631 }