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