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