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