?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[7916] Fixed pet action bar setup.
[getmangos.git] / src / game / Object.cpp
blob5b3d9ef4fedfa774ed01b3bd44c1d7c1f398364c
1 /*
2 * Copyright (C) 2005-2009 MaNGOS <http://getmangos.com/>
3 *
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License as published by
6 * the Free Software Foundation; either version 2 of the License, or
7 * (at your option) any later version.
8 *
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
13 *
14 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, write to the Free Software
16 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17 */
18
19 #include "Common.h"
20 #include "SharedDefines.h"
21 #include "WorldPacket.h"
22 #include "Opcodes.h"
23 #include "Log.h"
24 #include "World.h"
25 #include "Object.h"
26 #include "Creature.h"
27 #include "Player.h"
28 #include "Vehicle.h"
29 #include "ObjectMgr.h"
30 #include "UpdateData.h"
31 #include "UpdateMask.h"
32 #include "Util.h"
33 #include "MapManager.h"
34 #include "ObjectAccessor.h"
35 #include "Log.h"
36 #include "Transports.h"
37 #include "TargetedMovementGenerator.h"
38 #include "WaypointMovementGenerator.h"
39 #include "VMapFactory.h"
40 #include "CellImpl.h"
41 #include "GridNotifiers.h"
42 #include "GridNotifiersImpl.h"
43
44 #include "ObjectPosSelector.h"
45
46 #include "TemporarySummon.h"
47
48 uint32 GuidHigh2TypeId(uint32 guid_hi)
49 {
50 switch(guid_hi)
51 {
52 case HIGHGUID_ITEM: return TYPEID_ITEM;
53 //case HIGHGUID_CONTAINER: return TYPEID_CONTAINER; HIGHGUID_CONTAINER==HIGHGUID_ITEM currently
54 case HIGHGUID_UNIT: return TYPEID_UNIT;
55 case HIGHGUID_PET: return TYPEID_UNIT;
56 case HIGHGUID_PLAYER: return TYPEID_PLAYER;
57 case HIGHGUID_GAMEOBJECT: return TYPEID_GAMEOBJECT;
58 case HIGHGUID_DYNAMICOBJECT:return TYPEID_DYNAMICOBJECT;
59 case HIGHGUID_CORPSE: return TYPEID_CORPSE;
60 case HIGHGUID_MO_TRANSPORT: return TYPEID_GAMEOBJECT;
61 case HIGHGUID_VEHICLE: return TYPEID_UNIT;
62 }
63 return NUM_CLIENT_OBJECT_TYPES; // unknown
64 }
65
66 Object::Object( )
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);
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(50);
128
129 buf << uint8( UPDATETYPE_MOVEMENT );
130 buf.append(GetPackGUID());
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 return;
141
142 uint8 updatetype = UPDATETYPE_CREATE_OBJECT;
143 uint8 flags = m_updateFlag;
144 uint32 flags2 = 0;
145
146 /** lower flag1 **/
147 if(target == this) // building packet for yourself
148 flags |= UPDATEFLAG_SELF;
149
150 if(flags & UPDATEFLAG_HAS_POSITION)
151 {
152 // UPDATETYPE_CREATE_OBJECT2 dynamic objects, corpses...
153 if(isType(TYPEMASK_DYNAMICOBJECT) || isType(TYPEMASK_CORPSE) || isType(TYPEMASK_PLAYER))
154 updatetype = UPDATETYPE_CREATE_OBJECT2;
155
156 // UPDATETYPE_CREATE_OBJECT2 for pets...
157 if(target->GetPetGUID() == GetGUID())
158 updatetype = UPDATETYPE_CREATE_OBJECT2;
159
160 // UPDATETYPE_CREATE_OBJECT2 for some gameobject types...
161 if(isType(TYPEMASK_GAMEOBJECT))
162 {
163 switch(((GameObject*)this)->GetGoType())
164 {
165 case GAMEOBJECT_TYPE_TRAP:
166 case GAMEOBJECT_TYPE_DUEL_ARBITER:
167 case GAMEOBJECT_TYPE_FLAGSTAND:
168 case GAMEOBJECT_TYPE_FLAGDROP:
169 updatetype = UPDATETYPE_CREATE_OBJECT2;
170 break;
171 case GAMEOBJECT_TYPE_TRANSPORT:
172 flags |= UPDATEFLAG_TRANSPORT;
173 break;
174 default:
175 break;
176 }
177 }
178
179 if(isType(TYPEMASK_UNIT))
180 {
181 if(((Unit*)this)->getVictim())
182 flags |= UPDATEFLAG_HAS_TARGET;
183 }
184 }
185
186 //sLog.outDebug("BuildCreateUpdate: update-type: %u, object-type: %u got flags: %X, flags2: %X", updatetype, m_objectTypeId, flags, flags2);
187
188 ByteBuffer buf(50);
189 buf << (uint8)updatetype;
190 buf.append(GetPackGUID());
191 buf << (uint8)m_objectTypeId;
192
193 _BuildMovementUpdate(&buf, flags, flags2);
194
195 UpdateMask updateMask;
196 updateMask.SetCount( m_valuesCount );
197 _SetCreateBits( &updateMask, target );
198 _BuildValuesUpdate(updatetype, &buf, &updateMask, target);
199 data->AddUpdateBlock(buf);
200 }
201
202 void Object::BuildUpdate(UpdateDataMapType &update_players)
203 {
204 ObjectAccessor::_buildUpdateObject(this,update_players);
205 ClearUpdateMask(true);
206 }
207
208 void Object::SendUpdateToPlayer(Player* player)
209 {
210 // send update to another players
211 SendUpdateObjectToAllExcept(player);
212
213 // send create update to player
214 UpdateData upd;
215 WorldPacket packet;
216
217 upd.Clear();
218 BuildCreateUpdateBlockForPlayer(&upd, player);
219 upd.BuildPacket(&packet);
220 player->GetSession()->SendPacket(&packet);
221 }
222
223 void Object::BuildValuesUpdateBlockForPlayer(UpdateData *data, Player *target) const
224 {
225 ByteBuffer buf(50);
226
227 buf << (uint8) UPDATETYPE_VALUES;
228 buf.append(GetPackGUID());
229
230 UpdateMask updateMask;
231 updateMask.SetCount( m_valuesCount );
232
233 _SetUpdateBits( &updateMask, target );
234 _BuildValuesUpdate(UPDATETYPE_VALUES, &buf, &updateMask, target);
235
236 data->AddUpdateBlock(buf);
237 }
238
239 void Object::BuildOutOfRangeUpdateBlock(UpdateData * data) const
240 {
241 data->AddOutOfRangeGUID(GetGUID());
242 }
243
244 void Object::DestroyForPlayer(Player *target) const
245 {
246 ASSERT(target);
247
248 WorldPacket data(SMSG_DESTROY_OBJECT, 8);
249 data << uint64(GetGUID());
250 data << uint8(0); // WotLK (bool)
251 target->GetSession()->SendPacket( &data );
252 }
253
254 void Object::_BuildMovementUpdate(ByteBuffer * data, uint8 flags, uint32 flags2) const
255 {
256 uint16 unk_flags = ((GetTypeId() == TYPEID_PLAYER) ? ((Player*)this)->m_movementInfo.unk1 : 0);
257
258 if(GetTypeId() == TYPEID_UNIT)
259 if(((Creature*)this)->isVehicle())
260 unk_flags |= 0x20; // always allow pitch
261
262 *data << (uint8)flags; // update flags
263
264 // 0x20
265 if (flags & UPDATEFLAG_LIVING)
266 {
267 switch(GetTypeId())
268 {
269 case TYPEID_UNIT:
270 {
271 flags2 = ((Unit*)this)->GetUnitMovementFlags();
272 }
273 break;
274 case TYPEID_PLAYER:
275 {
276 flags2 = ((Player*)this)->GetUnitMovementFlags();
277
278 if(((Player*)this)->GetTransport())
279 flags2 |= MOVEMENTFLAG_ONTRANSPORT;
280 else
281 flags2 &= ~MOVEMENTFLAG_ONTRANSPORT;
282
283 // remove unknown, unused etc flags for now
284 flags2 &= ~MOVEMENTFLAG_SPLINE2; // will be set manually
285
286 if(((Player*)this)->isInFlight())
287 {
288 WPAssert(((Player*)this)->GetMotionMaster()->GetCurrentMovementGeneratorType() == FLIGHT_MOTION_TYPE);
289 flags2 = (MOVEMENTFLAG_FORWARD | MOVEMENTFLAG_SPLINE2);
290 }
291 }
292 break;
293 }
294
295 *data << uint32(flags2); // movement flags
296 *data << uint16(unk_flags); // unknown 2.3.0
297 *data << uint32(getMSTime()); // time (in milliseconds)
298 }
299
300 // 0x40
301 if (flags & UPDATEFLAG_HAS_POSITION)
302 {
303 // 0x02
304 if(flags & UPDATEFLAG_TRANSPORT && ((GameObject*)this)->GetGoType() == GAMEOBJECT_TYPE_MO_TRANSPORT)
305 {
306 *data << (float)0;
307 *data << (float)0;
308 *data << (float)0;
309 *data << ((WorldObject *)this)->GetOrientation();
310 }
311 else
312 {
313 *data << ((WorldObject *)this)->GetPositionX();
314 *data << ((WorldObject *)this)->GetPositionY();
315 *data << ((WorldObject *)this)->GetPositionZ();
316 *data << ((WorldObject *)this)->GetOrientation();
317 }
318 }
319
320 // 0x20
321 if(flags & UPDATEFLAG_LIVING)
322 {
323 // 0x00000200
324 if(flags2 & MOVEMENTFLAG_ONTRANSPORT)
325 {
326 if(GetTypeId() == TYPEID_PLAYER)
327 {
328 *data << (uint64)((Player*)this)->GetTransport()->GetGUID();
329 *data << (float)((Player*)this)->GetTransOffsetX();
330 *data << (float)((Player*)this)->GetTransOffsetY();
331 *data << (float)((Player*)this)->GetTransOffsetZ();
332 *data << (float)((Player*)this)->GetTransOffsetO();
333 *data << (uint32)((Player*)this)->GetTransTime();
334 *data << (int8)((Player*)this)->GetTransSeat();
335 }
336 //MaNGOS currently not have support for other than player on transport
337 }
338
339 // 0x02200000
340 if((flags2 & (MOVEMENTFLAG_SWIMMING | MOVEMENTFLAG_FLYING2)) || (unk_flags & 0x20))
341 {
342 if(GetTypeId() == TYPEID_PLAYER)
343 *data << (float)((Player*)this)->m_movementInfo.s_pitch;
344 else
345 *data << (float)0; // is't part of movement packet, we must store and send it...
346 }
347
348 if(GetTypeId() == TYPEID_PLAYER)
349 *data << (uint32)((Player*)this)->m_movementInfo.fallTime;
350 else
351 *data << (uint32)0; // last fall time
352
353 // 0x00001000
354 if(flags2 & MOVEMENTFLAG_JUMPING)
355 {
356 if(GetTypeId() == TYPEID_PLAYER)
357 {
358 *data << (float)((Player*)this)->m_movementInfo.j_unk;
359 *data << (float)((Player*)this)->m_movementInfo.j_sinAngle;
360 *data << (float)((Player*)this)->m_movementInfo.j_cosAngle;
361 *data << (float)((Player*)this)->m_movementInfo.j_xyspeed;
362 }
363 else
364 {
365 *data << (float)0;
366 *data << (float)0;
367 *data << (float)0;
368 *data << (float)0;
369 }
370 }
371
372 // 0x04000000
373 if(flags2 & MOVEMENTFLAG_SPLINE)
374 {
375 if(GetTypeId() == TYPEID_PLAYER)
376 *data << (float)((Player*)this)->m_movementInfo.u_unk1;
377 else
378 *data << (float)0;
379 }
380
381 *data << ((Unit*)this)->GetSpeed( MOVE_WALK );
382 *data << ((Unit*)this)->GetSpeed( MOVE_RUN );
383 *data << ((Unit*)this)->GetSpeed( MOVE_SWIM_BACK );
384 *data << ((Unit*)this)->GetSpeed( MOVE_SWIM );
385 *data << ((Unit*)this)->GetSpeed( MOVE_RUN_BACK );
386 *data << ((Unit*)this)->GetSpeed( MOVE_FLIGHT );
387 *data << ((Unit*)this)->GetSpeed( MOVE_FLIGHT_BACK );
388 *data << ((Unit*)this)->GetSpeed( MOVE_TURN_RATE );
389 *data << ((Unit*)this)->GetSpeed( MOVE_PITCH_RATE );
390
391 // 0x08000000
392 if(flags2 & MOVEMENTFLAG_SPLINE2)
393 {
394 if(GetTypeId() != TYPEID_PLAYER)
395 {
396 sLog.outDebug("_BuildMovementUpdate: MOVEMENTFLAG_SPLINE2 for non-player");
397 return;
398 }
399
400 if(!((Player*)this)->isInFlight())
401 {
402 sLog.outDebug("_BuildMovementUpdate: MOVEMENTFLAG_SPLINE2 but not in flight");
403 return;
404 }
405
406 WPAssert(((Player*)this)->GetMotionMaster()->GetCurrentMovementGeneratorType() == FLIGHT_MOTION_TYPE);
407
408 FlightPathMovementGenerator *fmg = (FlightPathMovementGenerator*)(((Player*)this)->GetMotionMaster()->top());
409
410 uint32 flags3 = 0x00000300;
411
412 *data << uint32(flags3); // splines flag?
413
414 if(flags3 & 0x10000) // probably x,y,z coords there
415 {
416 *data << (float)0;
417 *data << (float)0;
418 *data << (float)0;
419 }
420
421 if(flags3 & 0x20000) // probably guid there
422 {
423 *data << uint64(0);
424 }
425
426 if(flags3 & 0x40000) // may be orientation
427 {
428 *data << (float)0;
429 }
430
431 Path &path = fmg->GetPath();
432
433 float x, y, z;
434 ((Player*)this)->GetPosition(x, y, z);
435
436 uint32 inflighttime = uint32(path.GetPassedLength(fmg->GetCurrentNode(), x, y, z) * 32);
437 uint32 traveltime = uint32(path.GetTotalLength() * 32);
438
439 *data << uint32(inflighttime); // passed move time?
440 *data << uint32(traveltime); // full move time?
441 *data << uint32(0); // ticks count?
442
443 uint32 poscount = uint32(path.Size());
444
445 *data << uint32(poscount); // points count
446
447 for(uint32 i = 0; i < poscount; ++i)
448 {
449 *data << path.GetNodes()[i].x;
450 *data << path.GetNodes()[i].y;
451 *data << path.GetNodes()[i].z;
452 }
453
454 *data << uint8(0); // added in 3.0.8
455
456 /*for(uint32 i = 0; i < poscount; i++)
457 {
458 // path points
459 *data << (float)0;
460 *data << (float)0;
461 *data << (float)0;
462 }*/
463
464 *data << path.GetNodes()[poscount-1].x;
465 *data << path.GetNodes()[poscount-1].y;
466 *data << path.GetNodes()[poscount-1].z;
467
468 // target position (path end)
469 /**data << ((Unit*)this)->GetPositionX();
470 *data << ((Unit*)this)->GetPositionY();
471 *data << ((Unit*)this)->GetPositionZ();*/
472 }
473 }
474
475 // 0x8
476 if(flags & UPDATEFLAG_LOWGUID)
477 {
478 switch(GetTypeId())
479 {
480 case TYPEID_OBJECT:
481 case TYPEID_ITEM:
482 case TYPEID_CONTAINER:
483 case TYPEID_GAMEOBJECT:
484 case TYPEID_DYNAMICOBJECT:
485 case TYPEID_CORPSE:
486 *data << uint32(GetGUIDLow()); // GetGUIDLow()
487 break;
488 case TYPEID_UNIT:
489 *data << uint32(0x0000000B); // unk, can be 0xB or 0xC
490 break;
491 case TYPEID_PLAYER:
492 if(flags & UPDATEFLAG_SELF)
493 *data << uint32(0x0000002F); // unk, can be 0x15 or 0x22
494 else
495 *data << uint32(0x00000008); // unk, can be 0x7 or 0x8
496 break;
497 default:
498 *data << uint32(0x00000000); // unk
499 break;
500 }
501 }
502
503 // 0x10
504 if(flags & UPDATEFLAG_HIGHGUID)
505 {
506 switch(GetTypeId())
507 {
508 case TYPEID_OBJECT:
509 case TYPEID_ITEM:
510 case TYPEID_CONTAINER:
511 case TYPEID_GAMEOBJECT:
512 case TYPEID_DYNAMICOBJECT:
513 case TYPEID_CORPSE:
514 *data << uint32(GetGUIDHigh()); // GetGUIDHigh()
515 break;
516 case TYPEID_UNIT:
517 *data << uint32(0x0000000B); // unk, can be 0xB or 0xC
518 break;
519 case TYPEID_PLAYER:
520 if(flags & UPDATEFLAG_SELF)
521 *data << uint32(0x0000002F); // unk, can be 0x15 or 0x22
522 else
523 *data << uint32(0x00000008); // unk, can be 0x7 or 0x8
524 break;
525 default:
526 *data << uint32(0x00000000); // unk
527 break;
528 }
529 }
530
531 // 0x4
532 if(flags & UPDATEFLAG_HAS_TARGET) // packed guid (current target guid)
533 {
534 if(Unit *victim = ((Unit*)this)->getVictim())
535 data->append(victim->GetPackGUID());
536 else
537 *data << uint8(0);
538 }
539
540 // 0x2
541 if(flags & UPDATEFLAG_TRANSPORT)
542 {
543 *data << uint32(getMSTime()); // ms time
544 }
545
546 // 0x80
547 if(flags & UPDATEFLAG_VEHICLE) // unused for now
548 {
549 *data << uint32(((Vehicle*)this)->GetVehicleId()); // vehicle id
550 *data << float(0); // facing adjustment
551 }
552 }
553
554 void Object::_BuildValuesUpdate(uint8 updatetype, ByteBuffer * data, UpdateMask *updateMask, Player *target) const
555 {
556 if(!target)
557 return;
558
559 bool IsActivateToQuest = false;
560 if (updatetype == UPDATETYPE_CREATE_OBJECT || updatetype == UPDATETYPE_CREATE_OBJECT2)
561 {
562 if (isType(TYPEMASK_GAMEOBJECT) && !((GameObject*)this)->IsTransport())
563 {
564 if ( ((GameObject*)this)->ActivateToQuest(target) || target->isGameMaster())
565 {
566 IsActivateToQuest = true;
567 updateMask->SetBit(GAMEOBJECT_DYNAMIC);
568 }
569 }
570 }
571 else // case UPDATETYPE_VALUES
572 {
573 if (isType(TYPEMASK_GAMEOBJECT) && !((GameObject*)this)->IsTransport())
574 {
575 if ( ((GameObject*)this)->ActivateToQuest(target) || target->isGameMaster())
576 {
577 IsActivateToQuest = true;
578 }
579 updateMask->SetBit(GAMEOBJECT_DYNAMIC);
580 updateMask->SetBit(GAMEOBJECT_BYTES_1);
581 }
582 }
583
584 WPAssert(updateMask && updateMask->GetCount() == m_valuesCount);
585
586 *data << (uint8)updateMask->GetBlockCount();
587 data->append( updateMask->GetMask(), updateMask->GetLength() );
588
589 // 2 specialized loops for speed optimization in non-unit case
590 if(isType(TYPEMASK_UNIT)) // unit (creature/player) case
591 {
592 for( uint16 index = 0; index < m_valuesCount; index ++ )
593 {
594 if( updateMask->GetBit( index ) )
595 {
596 if( index == UNIT_NPC_FLAGS )
597 {
598 // remove custom flag before sending
599 uint32 appendValue = m_uint32Values[ index ] & ~UNIT_NPC_FLAG_GUARD;
600
601 if (GetTypeId() == TYPEID_UNIT && !target->canSeeSpellClickOn((Creature*)this))
602 appendValue &= ~UNIT_NPC_FLAG_SPELLCLICK;
603
604 *data << uint32(appendValue);
605 }
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(float x, float y, 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::IsWithinDist3d(float x, float y, float z, float dist2compare) const
1111 {
1112 float dx = GetPositionX() - x;
1113 float dy = GetPositionY() - y;
1114 float dz = GetPositionZ() - z;
1115 float distsq = dx*dx + dy*dy + dz*dz;
1116
1117 float sizefactor = GetObjectSize();
1118 float maxdist = dist2compare + sizefactor;
1119
1120 return distsq < maxdist * maxdist;
1121 }
1122
1123 bool WorldObject::IsWithinDist2d(float x, float y, float dist2compare) const
1124 {
1125 float dx = GetPositionX() - x;
1126 float dy = GetPositionY() - y;
1127 float distsq = dx*dx + dy*dy;
1128
1129 float sizefactor = GetObjectSize();
1130 float maxdist = dist2compare + sizefactor;
1131
1132 return distsq < maxdist * maxdist;
1133 }
1134
1135 bool WorldObject::_IsWithinDist(WorldObject const* obj, float dist2compare, bool is3D) const
1136 {
1137 float dx = GetPositionX() - obj->GetPositionX();
1138 float dy = GetPositionY() - obj->GetPositionY();
1139 float distsq = dx*dx + dy*dy;
1140 if(is3D)
1141 {
1142 float dz = GetPositionZ() - obj->GetPositionZ();
1143 distsq += dz*dz;
1144 }
1145 float sizefactor = GetObjectSize() + obj->GetObjectSize();
1146 float maxdist = dist2compare + sizefactor;
1147
1148 return distsq < maxdist * maxdist;
1149 }
1150
1151 bool WorldObject::IsWithinLOSInMap(const WorldObject* obj) const
1152 {
1153 if (!IsInMap(obj)) return false;
1154 float ox,oy,oz;
1155 obj->GetPosition(ox,oy,oz);
1156 return(IsWithinLOS(ox, oy, oz ));
1157 }
1158
1159 bool WorldObject::IsWithinLOS(float ox, float oy, float oz) const
1160 {
1161 float x,y,z;
1162 GetPosition(x,y,z);
1163 VMAP::IVMapManager *vMapManager = VMAP::VMapFactory::createOrGetVMapManager();
1164 return vMapManager->isInLineOfSight(GetMapId(), x, y, z+2.0f, ox, oy, oz+2.0f);
1165 }
1166
1167 bool WorldObject::GetDistanceOrder(WorldObject const* obj1, WorldObject const* obj2, bool is3D /* = true */) const
1168 {
1169 float dx1 = GetPositionX() - obj1->GetPositionX();
1170 float dy1 = GetPositionY() - obj1->GetPositionY();
1171 float distsq1 = dx1*dx1 + dy1*dy1;
1172 if(is3D)
1173 {
1174 float dz1 = GetPositionZ() - obj1->GetPositionZ();
1175 distsq1 += dz1*dz1;
1176 }
1177
1178 float dx2 = GetPositionX() - obj2->GetPositionX();
1179 float dy2 = GetPositionY() - obj2->GetPositionY();
1180 float distsq2 = dx2*dx2 + dy2*dy2;
1181 if(is3D)
1182 {
1183 float dz2 = GetPositionZ() - obj2->GetPositionZ();
1184 distsq2 += dz2*dz2;
1185 }
1186
1187 return distsq1 < distsq2;
1188 }
1189
1190 bool WorldObject::IsInRange(WorldObject const* obj, float minRange, float maxRange, bool is3D /* = true */) const
1191 {
1192 float dx = GetPositionX() - obj->GetPositionX();
1193 float dy = GetPositionY() - obj->GetPositionY();
1194 float distsq = dx*dx + dy*dy;
1195 if(is3D)
1196 {
1197 float dz = GetPositionZ() - obj->GetPositionZ();
1198 distsq += dz*dz;
1199 }
1200
1201 float sizefactor = GetObjectSize() + obj->GetObjectSize();
1202
1203 // check only for real range
1204 if(minRange > 0.0f)
1205 {
1206 float mindist = minRange + sizefactor;
1207 if(distsq < mindist * mindist)
1208 return false;
1209 }
1210
1211 float maxdist = maxRange + sizefactor;
1212 return distsq < maxdist * maxdist;
1213 }
1214
1215 bool WorldObject::IsInRange2d(float x, float y, float minRange, float maxRange) const
1216 {
1217 float dx = GetPositionX() - x;
1218 float dy = GetPositionY() - y;
1219 float distsq = dx*dx + dy*dy;
1220
1221 float sizefactor = GetObjectSize();
1222
1223 // check only for real range
1224 if(minRange > 0.0f)
1225 {
1226 float mindist = minRange + sizefactor;
1227 if(distsq < mindist * mindist)
1228 return false;
1229 }
1230
1231 float maxdist = maxRange + sizefactor;
1232 return distsq < maxdist * maxdist;
1233 }
1234
1235 bool WorldObject::IsInRange3d(float x, float y, float z, float minRange, float maxRange) const
1236 {
1237 float dx = GetPositionX() - x;
1238 float dy = GetPositionY() - y;
1239 float dz = GetPositionZ() - z;
1240 float distsq = dx*dx + dy*dy + dz*dz;
1241
1242 float sizefactor = GetObjectSize();
1243
1244 // check only for real range
1245 if(minRange > 0.0f)
1246 {
1247 float mindist = minRange + sizefactor;
1248 if(distsq < mindist * mindist)
1249 return false;
1250 }
1251
1252 float maxdist = maxRange + sizefactor;
1253 return distsq < maxdist * maxdist;
1254 }
1255
1256 float WorldObject::GetAngle(const WorldObject* obj) const
1257 {
1258 if(!obj) return 0;
1259 return GetAngle( obj->GetPositionX(), obj->GetPositionY() );
1260 }
1261
1262 // Return angle in range 0..2*pi
1263 float WorldObject::GetAngle( const float x, const float y ) const
1264 {
1265 float dx = x - GetPositionX();
1266 float dy = y - GetPositionY();
1267
1268 float ang = atan2(dy, dx);
1269 ang = (ang >= 0) ? ang : 2 * M_PI + ang;
1270 return ang;
1271 }
1272
1273 bool WorldObject::HasInArc(const float arcangle, const WorldObject* obj) const
1274 {
1275 // always have self in arc
1276 if(obj == this)
1277 return true;
1278
1279 float arc = arcangle;
1280
1281 // move arc to range 0.. 2*pi
1282 while( arc >= 2.0f * M_PI )
1283 arc -= 2.0f * M_PI;
1284 while( arc < 0 )
1285 arc += 2.0f * M_PI;
1286
1287 float angle = GetAngle( obj );
1288 angle -= m_orientation;
1289
1290 // move angle to range -pi ... +pi
1291 while( angle > M_PI)
1292 angle -= 2.0f * M_PI;
1293 while(angle < -M_PI)
1294 angle += 2.0f * M_PI;
1295
1296 float lborder = -1 * (arc/2.0f); // in range -pi..0
1297 float rborder = (arc/2.0f); // in range 0..pi
1298 return (( angle >= lborder ) && ( angle <= rborder ));
1299 }
1300
1301 void WorldObject::GetRandomPoint( float x, float y, float z, float distance, float &rand_x, float &rand_y, float &rand_z) const
1302 {
1303 if(distance==0)
1304 {
1305 rand_x = x;
1306 rand_y = y;
1307 rand_z = z;
1308 return;
1309 }
1310
1311 // angle to face `obj` to `this`
1312 float angle = rand_norm()*2*M_PI;
1313 float new_dist = rand_norm()*distance;
1314
1315 rand_x = x + new_dist * cos(angle);
1316 rand_y = y + new_dist * sin(angle);
1317 rand_z = z;
1318
1319 MaNGOS::NormalizeMapCoord(rand_x);
1320 MaNGOS::NormalizeMapCoord(rand_y);
1321 UpdateGroundPositionZ(rand_x,rand_y,rand_z); // update to LOS height if available
1322 }
1323
1324 void WorldObject::UpdateGroundPositionZ(float x, float y, float &z) const
1325 {
1326 float new_z = MapManager::Instance().GetBaseMap(GetMapId())->GetHeight(x,y,z,true);
1327 if(new_z > INVALID_HEIGHT)
1328 z = new_z+ 0.05f; // just to be sure that we are not a few pixel under the surface
1329 }
1330
1331 bool WorldObject::IsPositionValid() const
1332 {
1333 return MaNGOS::IsValidMapCoord(m_positionX,m_positionY,m_positionZ,m_orientation);
1334 }
1335
1336 void WorldObject::MonsterSay(const char* text, uint32 language, uint64 TargetGuid)
1337 {
1338 WorldPacket data(SMSG_MESSAGECHAT, 200);
1339 BuildMonsterChat(&data,CHAT_MSG_MONSTER_SAY,text,language,GetName(),TargetGuid);
1340 SendMessageToSetInRange(&data,sWorld.getConfig(CONFIG_LISTEN_RANGE_SAY),true);
1341 }
1342
1343 void WorldObject::MonsterYell(const char* text, uint32 language, uint64 TargetGuid)
1344 {
1345 WorldPacket data(SMSG_MESSAGECHAT, 200);
1346 BuildMonsterChat(&data,CHAT_MSG_MONSTER_YELL,text,language,GetName(),TargetGuid);
1347 SendMessageToSetInRange(&data,sWorld.getConfig(CONFIG_LISTEN_RANGE_YELL),true);
1348 }
1349
1350 void WorldObject::MonsterTextEmote(const char* text, uint64 TargetGuid, bool IsBossEmote)
1351 {
1352 WorldPacket data(SMSG_MESSAGECHAT, 200);
1353 BuildMonsterChat(&data,IsBossEmote ? CHAT_MSG_RAID_BOSS_EMOTE : CHAT_MSG_MONSTER_EMOTE,text,LANG_UNIVERSAL,GetName(),TargetGuid);
1354 SendMessageToSetInRange(&data,sWorld.getConfig(CONFIG_LISTEN_RANGE_TEXTEMOTE),true);
1355 }
1356
1357 void WorldObject::MonsterWhisper(const char* text, uint64 receiver, bool IsBossWhisper)
1358 {
1359 Player *player = objmgr.GetPlayer(receiver);
1360 if(!player || !player->GetSession())
1361 return;
1362
1363 WorldPacket data(SMSG_MESSAGECHAT, 200);
1364 BuildMonsterChat(&data,IsBossWhisper ? CHAT_MSG_RAID_BOSS_WHISPER : CHAT_MSG_MONSTER_WHISPER,text,LANG_UNIVERSAL,GetName(),receiver);
1365
1366 player->GetSession()->SendPacket(&data);
1367 }
1368
1369 namespace MaNGOS
1370 {
1371 class MonsterChatBuilder
1372 {
1373 public:
1374 MonsterChatBuilder(WorldObject const& obj, ChatMsg msgtype, int32 textId, uint32 language, uint64 targetGUID)
1375 : i_object(obj), i_msgtype(msgtype), i_textId(textId), i_language(language), i_targetGUID(targetGUID) {}
1376 void operator()(WorldPacket& data, int32 loc_idx)
1377 {
1378 char const* text = objmgr.GetMangosString(i_textId,loc_idx);
1379
1380 // TODO: i_object.GetName() also must be localized?
1381 i_object.BuildMonsterChat(&data,i_msgtype,text,i_language,i_object.GetNameForLocaleIdx(loc_idx),i_targetGUID);
1382 }
1383
1384 private:
1385 WorldObject const& i_object;
1386 ChatMsg i_msgtype;
1387 int32 i_textId;
1388 uint32 i_language;
1389 uint64 i_targetGUID;
1390 };
1391 } // namespace MaNGOS
1392
1393 void WorldObject::MonsterSay(int32 textId, uint32 language, uint64 TargetGuid)
1394 {
1395 CellPair p = MaNGOS::ComputeCellPair(GetPositionX(), GetPositionY());
1396
1397 Cell cell(p);
1398 cell.data.Part.reserved = ALL_DISTRICT;
1399 cell.SetNoCreate();
1400
1401 MaNGOS::MonsterChatBuilder say_build(*this, CHAT_MSG_MONSTER_SAY, textId,language,TargetGuid);
1402 MaNGOS::LocalizedPacketDo<MaNGOS::MonsterChatBuilder> say_do(say_build);
1403 MaNGOS::PlayerDistWorker<MaNGOS::LocalizedPacketDo<MaNGOS::MonsterChatBuilder> > say_worker(this,sWorld.getConfig(CONFIG_LISTEN_RANGE_SAY),say_do);
1404 TypeContainerVisitor<MaNGOS::PlayerDistWorker<MaNGOS::LocalizedPacketDo<MaNGOS::MonsterChatBuilder> >, WorldTypeMapContainer > message(say_worker);
1405 CellLock<GridReadGuard> cell_lock(cell, p);
1406 cell_lock->Visit(cell_lock, message, *GetMap());
1407 }
1408
1409 void WorldObject::MonsterYell(int32 textId, uint32 language, uint64 TargetGuid)
1410 {
1411 CellPair p = MaNGOS::ComputeCellPair(GetPositionX(), GetPositionY());
1412
1413 Cell cell(p);
1414 cell.data.Part.reserved = ALL_DISTRICT;
1415 cell.SetNoCreate();
1416
1417 MaNGOS::MonsterChatBuilder say_build(*this, CHAT_MSG_MONSTER_YELL, textId,language,TargetGuid);
1418 MaNGOS::LocalizedPacketDo<MaNGOS::MonsterChatBuilder> say_do(say_build);
1419 MaNGOS::PlayerDistWorker<MaNGOS::LocalizedPacketDo<MaNGOS::MonsterChatBuilder> > say_worker(this,sWorld.getConfig(CONFIG_LISTEN_RANGE_YELL),say_do);
1420 TypeContainerVisitor<MaNGOS::PlayerDistWorker<MaNGOS::LocalizedPacketDo<MaNGOS::MonsterChatBuilder> >, WorldTypeMapContainer > message(say_worker);
1421 CellLock<GridReadGuard> cell_lock(cell, p);
1422 cell_lock->Visit(cell_lock, message, *GetMap());
1423 }
1424
1425 void WorldObject::MonsterYellToZone(int32 textId, uint32 language, uint64 TargetGuid)
1426 {
1427 MaNGOS::MonsterChatBuilder say_build(*this, CHAT_MSG_MONSTER_YELL, textId,language,TargetGuid);
1428 MaNGOS::LocalizedPacketDo<MaNGOS::MonsterChatBuilder> say_do(say_build);
1429
1430 uint32 zoneid = GetZoneId();
1431
1432 Map::PlayerList const& pList = GetMap()->GetPlayers();
1433 for(Map::PlayerList::const_iterator itr = pList.begin(); itr != pList.end(); ++itr)
1434 if(itr->getSource()->GetZoneId()==zoneid)
1435 say_do(itr->getSource());
1436 }
1437
1438 void WorldObject::MonsterTextEmote(int32 textId, uint64 TargetGuid, bool IsBossEmote)
1439 {
1440 CellPair p = MaNGOS::ComputeCellPair(GetPositionX(), GetPositionY());
1441
1442 Cell cell(p);
1443 cell.data.Part.reserved = ALL_DISTRICT;
1444 cell.SetNoCreate();
1445
1446 MaNGOS::MonsterChatBuilder say_build(*this, IsBossEmote ? CHAT_MSG_RAID_BOSS_EMOTE : CHAT_MSG_MONSTER_EMOTE, textId,LANG_UNIVERSAL,TargetGuid);
1447 MaNGOS::LocalizedPacketDo<MaNGOS::MonsterChatBuilder> say_do(say_build);
1448 MaNGOS::PlayerDistWorker<MaNGOS::LocalizedPacketDo<MaNGOS::MonsterChatBuilder> > say_worker(this,sWorld.getConfig(CONFIG_LISTEN_RANGE_TEXTEMOTE),say_do);
1449 TypeContainerVisitor<MaNGOS::PlayerDistWorker<MaNGOS::LocalizedPacketDo<MaNGOS::MonsterChatBuilder> >, WorldTypeMapContainer > message(say_worker);
1450 CellLock<GridReadGuard> cell_lock(cell, p);
1451 cell_lock->Visit(cell_lock, message, *GetMap());
1452 }
1453
1454 void WorldObject::MonsterWhisper(int32 textId, uint64 receiver, bool IsBossWhisper)
1455 {
1456 Player *player = objmgr.GetPlayer(receiver);
1457 if(!player || !player->GetSession())
1458 return;
1459
1460 uint32 loc_idx = player->GetSession()->GetSessionDbLocaleIndex();
1461 char const* text = objmgr.GetMangosString(textId,loc_idx);
1462
1463 WorldPacket data(SMSG_MESSAGECHAT, 200);
1464 BuildMonsterChat(&data,IsBossWhisper ? CHAT_MSG_RAID_BOSS_WHISPER : CHAT_MSG_MONSTER_WHISPER,text,LANG_UNIVERSAL,GetNameForLocaleIdx(loc_idx),receiver);
1465
1466 player->GetSession()->SendPacket(&data);
1467 }
1468
1469 void WorldObject::BuildMonsterChat(WorldPacket *data, uint8 msgtype, char const* text, uint32 language, char const* name, uint64 targetGuid) const
1470 {
1471 bool pre = (msgtype==CHAT_MSG_MONSTER_EMOTE || msgtype==CHAT_MSG_RAID_BOSS_EMOTE);
1472
1473 *data << (uint8)msgtype;
1474 *data << (uint32)language;
1475 *data << (uint64)GetGUID();
1476 *data << (uint32)0; // 2.1.0
1477 *data << (uint32)(strlen(name)+1);
1478 *data << name;
1479 *data << (uint64)targetGuid; // Unit Target
1480 if( targetGuid && !IS_PLAYER_GUID(targetGuid) )
1481 {
1482 *data << (uint32)1; // target name length
1483 *data << (uint8)0; // target name
1484 }
1485 *data << (uint32)(strlen(text)+1+(pre?3:0));
1486 if(pre)
1487 data->append("%s ",3);
1488 *data << text;
1489 *data << (uint8)0; // ChatTag
1490 }
1491
1492 void WorldObject::BuildHeartBeatMsg(WorldPacket *data) const
1493 {
1494 //Heartbeat message cannot be used for non-units
1495 if (!isType(TYPEMASK_UNIT))
1496 return;
1497
1498 data->Initialize(MSG_MOVE_HEARTBEAT, 32);
1499 data->append(GetPackGUID());
1500 *data << uint32(((Unit*)this)->GetUnitMovementFlags()); // movement flags
1501 *data << uint16(0); // 2.3.0
1502 *data << uint32(getMSTime()); // time
1503 *data << m_positionX;
1504 *data << m_positionY;
1505 *data << m_positionZ;
1506 *data << m_orientation;
1507 *data << uint32(0);
1508 }
1509
1510 void WorldObject::BuildTeleportAckMsg(WorldPacket *data, float x, float y, float z, float ang) const
1511 {
1512 //TeleportAck message cannot be used for non-units
1513 if (!isType(TYPEMASK_UNIT))
1514 return;
1515
1516 data->Initialize(MSG_MOVE_TELEPORT_ACK, 41);
1517 data->append(GetPackGUID());
1518 *data << uint32(0); // this value increments every time
1519 *data << uint32(((Unit*)this)->GetUnitMovementFlags()); // movement flags
1520 *data << uint16(0); // 2.3.0
1521 *data << uint32(getMSTime()); // time
1522 *data << x;
1523 *data << y;
1524 *data << z;
1525 *data << ang;
1526 *data << uint32(0);
1527 }
1528
1529 void WorldObject::SendMessageToSet(WorldPacket *data, bool /*bToSelf*/)
1530 {
1531 GetMap()->MessageBroadcast(this, data);
1532 }
1533
1534 void WorldObject::SendMessageToSetInRange(WorldPacket *data, float dist, bool /*bToSelf*/)
1535 {
1536 GetMap()->MessageDistBroadcast(this, data, dist);
1537 }
1538
1539 void WorldObject::SendObjectDeSpawnAnim(uint64 guid)
1540 {
1541 WorldPacket data(SMSG_GAMEOBJECT_DESPAWN_ANIM, 8);
1542 data << guid;
1543 SendMessageToSet(&data, true);
1544 }
1545
1546 Map* WorldObject::GetMap() const
1547 {
1548 return MapManager::Instance().GetMap(GetMapId(), this);
1549 }
1550
1551 Map const* WorldObject::GetBaseMap() const
1552 {
1553 return MapManager::Instance().GetBaseMap(GetMapId());
1554 }
1555
1556 void WorldObject::AddObjectToRemoveList()
1557 {
1558 Map* map = GetMap();
1559 if(!map)
1560 {
1561 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());
1562 return;
1563 }
1564
1565 map->AddObjectToRemoveList(this);
1566 }
1567
1568 Creature* WorldObject::SummonCreature(uint32 id, float x, float y, float z, float ang,TempSummonType spwtype,uint32 despwtime)
1569 {
1570 TemporarySummon* pCreature = new TemporarySummon(GetGUID());
1571
1572 pCreature->SetInstanceId(GetInstanceId());
1573 uint32 team = 0;
1574 if (GetTypeId()==TYPEID_PLAYER)
1575 team = ((Player*)this)->GetTeam();
1576
1577 if (!pCreature->Create(objmgr.GenerateLowGuid(HIGHGUID_UNIT), GetMap(), GetPhaseMask(), id, team))
1578 {
1579 delete pCreature;
1580 return NULL;
1581 }
1582
1583 if (x == 0.0f && y == 0.0f && z == 0.0f)
1584 GetClosePoint(x, y, z, pCreature->GetObjectSize());
1585
1586 pCreature->Relocate(x, y, z, ang);
1587
1588 if(!pCreature->IsPositionValid())
1589 {
1590 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());
1591 delete pCreature;
1592 return NULL;
1593 }
1594
1595 pCreature->Summon(spwtype, despwtime);
1596
1597 if(GetTypeId()==TYPEID_UNIT && ((Creature*)this)->AI())
1598 ((Creature*)this)->AI()->JustSummoned(pCreature);
1599
1600 // return the creature therewith the summoner has access to it
1601 return pCreature;
1602 }
1603
1604 namespace MaNGOS
1605 {
1606 class NearUsedPosDo
1607 {
1608 public:
1609 NearUsedPosDo(WorldObject const& obj, WorldObject const* searcher, float angle, ObjectPosSelector& selector)
1610 : i_object(obj), i_searcher(searcher), i_angle(angle), i_selector(selector) {}
1611
1612 void operator()(Corpse*) const {}
1613 void operator()(DynamicObject*) const {}
1614
1615 void operator()(Creature* c) const
1616 {
1617 // skip self or target
1618 if(c==i_searcher || c==&i_object)
1619 return;
1620
1621 float x,y,z;
1622
1623 if( !c->isAlive() || c->hasUnitState(UNIT_STAT_ROOT | UNIT_STAT_STUNNED | UNIT_STAT_DISTRACTED) ||
1624 !c->GetMotionMaster()->GetDestination(x,y,z) )
1625 {
1626 x = c->GetPositionX();
1627 y = c->GetPositionY();
1628 }
1629
1630 add(c,x,y);
1631 }
1632
1633 template<class T>
1634 void operator()(T* u) const
1635 {
1636 // skip self or target
1637 if(u==i_searcher || u==&i_object)
1638 return;
1639
1640 float x,y;
1641
1642 x = u->GetPositionX();
1643 y = u->GetPositionY();
1644
1645 add(u,x,y);
1646 }
1647
1648 // we must add used pos that can fill places around center
1649 void add(WorldObject* u, float x, float y) const
1650 {
1651 // u is too nearest/far away to i_object
1652 if(!i_object.IsInRange2d(x,y,i_selector.m_dist - i_selector.m_size,i_selector.m_dist + i_selector.m_size))
1653 return;
1654
1655 float angle = i_object.GetAngle(u)-i_angle;
1656
1657 // move angle to range -pi ... +pi
1658 while( angle > M_PI)
1659 angle -= 2.0f * M_PI;
1660 while(angle < -M_PI)
1661 angle += 2.0f * M_PI;
1662
1663 // dist include size of u
1664 float dist2d = i_object.GetDistance2d(x,y);
1665 i_selector.AddUsedPos(u->GetObjectSize(),angle,dist2d + i_object.GetObjectSize());
1666 }
1667 private:
1668 WorldObject const& i_object;
1669 WorldObject const* i_searcher;
1670 float i_angle;
1671 ObjectPosSelector& i_selector;
1672 };
1673 } // namespace MaNGOS
1674
1675 //===================================================================================================
1676
1677 void WorldObject::GetNearPoint2D(float &x, float &y, float distance2d, float absAngle ) const
1678 {
1679 x = GetPositionX() + (GetObjectSize() + distance2d) * cos(absAngle);
1680 y = GetPositionY() + (GetObjectSize() + distance2d) * sin(absAngle);
1681
1682 MaNGOS::NormalizeMapCoord(x);
1683 MaNGOS::NormalizeMapCoord(y);
1684 }
1685
1686 void WorldObject::GetNearPoint(WorldObject const* searcher, float &x, float &y, float &z, float searcher_size, float distance2d, float absAngle ) const
1687 {
1688 GetNearPoint2D(x,y,distance2d+searcher_size,absAngle);
1689 z = GetPositionZ();
1690
1691 // if detection disabled, return first point
1692 if(!sWorld.getConfig(CONFIG_DETECT_POS_COLLISION))
1693 {
1694 UpdateGroundPositionZ(x,y,z); // update to LOS height if available
1695 return;
1696 }
1697
1698 // or remember first point
1699 float first_x = x;
1700 float first_y = y;
1701 bool first_los_conflict = false; // first point LOS problems
1702
1703 // prepare selector for work
1704 ObjectPosSelector selector(GetPositionX(),GetPositionY(),GetObjectSize(),distance2d+searcher_size);
1705
1706 // adding used positions around object
1707 {
1708 CellPair p(MaNGOS::ComputeCellPair(GetPositionX(), GetPositionY()));
1709 Cell cell(p);
1710 cell.data.Part.reserved = ALL_DISTRICT;
1711 cell.SetNoCreate();
1712
1713 MaNGOS::NearUsedPosDo u_do(*this,searcher,absAngle,selector);
1714 MaNGOS::WorldObjectWorker<MaNGOS::NearUsedPosDo> worker(this,u_do);
1715
1716 TypeContainerVisitor<MaNGOS::WorldObjectWorker<MaNGOS::NearUsedPosDo>, GridTypeMapContainer > grid_obj_worker(worker);
1717 TypeContainerVisitor<MaNGOS::WorldObjectWorker<MaNGOS::NearUsedPosDo>, WorldTypeMapContainer > world_obj_worker(worker);
1718
1719 CellLock<GridReadGuard> cell_lock(cell, p);
1720 cell_lock->Visit(cell_lock, grid_obj_worker, *GetMap());
1721 cell_lock->Visit(cell_lock, world_obj_worker, *GetMap());
1722 }
1723
1724 // maybe can just place in primary position
1725 if( selector.CheckOriginal() )
1726 {
1727 UpdateGroundPositionZ(x,y,z); // update to LOS height if available
1728
1729 if(IsWithinLOS(x,y,z))
1730 return;
1731
1732 first_los_conflict = true; // first point have LOS problems
1733 }
1734
1735 float angle; // candidate of angle for free pos
1736
1737 // special case when one from list empty and then empty side preferred
1738 if(selector.FirstAngle(angle))
1739 {
1740 GetNearPoint2D(x,y,distance2d,absAngle+angle);
1741 z = GetPositionZ();
1742 UpdateGroundPositionZ(x,y,z); // update to LOS height if available
1743
1744 if(IsWithinLOS(x,y,z))
1745 return;
1746 }
1747
1748 // set first used pos in lists
1749 selector.InitializeAngle();
1750
1751 // select in positions after current nodes (selection one by one)
1752 while(selector.NextAngle(angle)) // angle for free pos
1753 {
1754 GetNearPoint2D(x,y,distance2d,absAngle+angle);
1755 z = GetPositionZ();
1756 UpdateGroundPositionZ(x,y,z); // update to LOS height if available
1757
1758 if(IsWithinLOS(x,y,z))
1759 return;
1760 }
1761
1762 // BAD NEWS: not free pos (or used or have LOS problems)
1763 // Attempt find _used_ pos without LOS problem
1764
1765 if(!first_los_conflict)
1766 {
1767 x = first_x;
1768 y = first_y;
1769
1770 UpdateGroundPositionZ(x,y,z); // update to LOS height if available
1771 return;
1772 }
1773
1774 // special case when one from list empty and then empty side preferred
1775 if( selector.IsNonBalanced() )
1776 {
1777 if(!selector.FirstAngle(angle)) // _used_ pos
1778 {
1779 GetNearPoint2D(x,y,distance2d,absAngle+angle);
1780 z = GetPositionZ();
1781 UpdateGroundPositionZ(x,y,z); // update to LOS height if available
1782
1783 if(IsWithinLOS(x,y,z))
1784 return;
1785 }
1786 }
1787
1788 // set first used pos in lists
1789 selector.InitializeAngle();
1790
1791 // select in positions after current nodes (selection one by one)
1792 while(selector.NextUsedAngle(angle)) // angle for used pos but maybe without LOS problem
1793 {
1794 GetNearPoint2D(x,y,distance2d,absAngle+angle);
1795 z = GetPositionZ();
1796 UpdateGroundPositionZ(x,y,z); // update to LOS height if available
1797
1798 if(IsWithinLOS(x,y,z))
1799 return;
1800 }
1801
1802 // BAD BAD NEWS: all found pos (free and used) have LOS problem :(
1803 x = first_x;
1804 y = first_y;
1805
1806 UpdateGroundPositionZ(x,y,z); // update to LOS height if available
1807 }
1808
1809 void WorldObject::SetPhaseMask(uint32 newPhaseMask, bool update)
1810 {
1811 m_phaseMask = newPhaseMask;
1812
1813 if(update && IsInWorld())
1814 ObjectAccessor::UpdateObjectVisibility(this);
1815 }
1816
1817 void WorldObject::PlayDistanceSound( uint32 sound_id, Player* target /*= NULL*/ )
1818 {
1819 WorldPacket data(SMSG_PLAY_OBJECT_SOUND,4+8);
1820 data << uint32(sound_id);
1821 data << uint64(GetGUID());
1822 if (target)
1823 target->SendDirectMessage( &data );
1824 else
1825 SendMessageToSet( &data, true );
1826 }
1827
1828 void WorldObject::PlayDirectSound( uint32 sound_id, Player* target /*= NULL*/ )
1829 {
1830 WorldPacket data(SMSG_PLAY_SOUND, 4);
1831 data << uint32(sound_id);
1832 if (target)
1833 target->SendDirectMessage( &data );
1834 else
1835 SendMessageToSet( &data, true );
1836 }
MaNGOS is a free, Open Source implementation of a game server compatible with the original World of Warcraft client.