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