?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[9545] Rename ObjectDefines.h -> ObjectGuid.h
[getmangos.git] / src / game / Object.cpp
blob5dea8a5f1ededcabc17a574b8bed10801aaed8b4
1 /*
2 * Copyright (C) 2005-2010 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 "ObjectGuid.h"
31 #include "UpdateData.h"
32 #include "UpdateMask.h"
33 #include "Util.h"
34 #include "MapManager.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( ) : m_PackGUID(sizeof(uint64)+1)
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.appendPackGUID(0);
79 }
80
81 Object::~Object( )
82 {
83 if(IsInWorld())
84 {
85 ///- Do NOT call RemoveFromWorld here, if the object is a player it will crash
86 sLog.outError("Object::~Object (GUID: %u TypeId: %u) deleted but still in world!!", GetGUIDLow(), GetTypeId());
87 ASSERT(false);
88 }
89
90 if(m_objectUpdated)
91 {
92 sLog.outError("Object::~Object (GUID: %u TypeId: %u) deleted but still have updated status!!", GetGUIDLow(), GetTypeId());
93 ASSERT(false);
94 }
95
96 if(m_uint32Values)
97 {
98 //DEBUG_LOG("Object desctr 1 check (%p)",(void*)this);
99 delete [] m_uint32Values;
100 delete [] m_uint32Values_mirror;
101 //DEBUG_LOG("Object desctr 2 check (%p)",(void*)this);
102 }
103 }
104
105 void Object::_InitValues()
106 {
107 m_uint32Values = new uint32[ m_valuesCount ];
108 memset(m_uint32Values, 0, m_valuesCount*sizeof(uint32));
109
110 m_uint32Values_mirror = new uint32[ m_valuesCount ];
111 memset(m_uint32Values_mirror, 0, m_valuesCount*sizeof(uint32));
112
113 m_objectUpdated = false;
114 }
115
116 void Object::_Create( uint32 guidlow, uint32 entry, HighGuid guidhigh )
117 {
118 if(!m_uint32Values)
119 _InitValues();
120
121 uint64 guid = MAKE_NEW_GUID(guidlow, entry, guidhigh);
122 SetUInt64Value(OBJECT_FIELD_GUID, guid);
123 SetUInt32Value(OBJECT_FIELD_TYPE, m_objectType);
124 m_PackGUID.wpos(0);
125 m_PackGUID.appendPackGUID(GetGUID());
126 }
127
128 void Object::BuildMovementUpdateBlock(UpdateData * data, uint16 flags ) const
129 {
130 ByteBuffer buf(500);
131
132 buf << uint8(UPDATETYPE_MOVEMENT);
133 buf.append(GetPackGUID());
134
135 BuildMovementUpdate(&buf, flags);
136
137 data->AddUpdateBlock(buf);
138 }
139
140 void Object::BuildCreateUpdateBlockForPlayer(UpdateData *data, Player *target) const
141 {
142 if(!target)
143 return;
144
145 uint8 updatetype = UPDATETYPE_CREATE_OBJECT;
146 uint16 updateFlags = m_updateFlag;
147
148 /** lower flag1 **/
149 if(target == this) // building packet for yourself
150 updateFlags |= UPDATEFLAG_SELF;
151
152 if(updateFlags & 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 updateFlags |= UPDATEFLAG_TRANSPORT;
175 break;
176 default:
177 break;
178 }
179 }
180
181 if(isType(TYPEMASK_UNIT))
182 {
183 if(((Unit*)this)->getVictim())
184 updateFlags |= UPDATEFLAG_HAS_ATTACKING_TARGET;
185 }
186 }
187
188 //sLog.outDebug("BuildCreateUpdate: update-type: %u, object-type: %u got updateFlags: %X", updatetype, m_objectTypeId, updateFlags);
189
190 ByteBuffer buf(500);
191 buf << uint8(updatetype);
192 buf.append(GetPackGUID());
193 buf << uint8(m_objectTypeId);
194
195 BuildMovementUpdate(&buf, updateFlags);
196
197 UpdateMask updateMask;
198 updateMask.SetCount(m_valuesCount);
199 _SetCreateBits(&updateMask, target);
200 BuildValuesUpdate(updatetype, &buf, &updateMask, target);
201 data->AddUpdateBlock(buf);
202 }
203
204 void Object::SendCreateUpdateToPlayer(Player* player)
205 {
206 // send create update to player
207 UpdateData upd;
208 WorldPacket packet;
209
210 BuildCreateUpdateBlockForPlayer(&upd, player);
211 upd.BuildPacket(&packet);
212 player->GetSession()->SendPacket(&packet);
213 }
214
215 void Object::BuildValuesUpdateBlockForPlayer(UpdateData *data, Player *target) const
216 {
217 ByteBuffer buf(500);
218
219 buf << uint8(UPDATETYPE_VALUES);
220 buf.append(GetPackGUID());
221
222 UpdateMask updateMask;
223 updateMask.SetCount(m_valuesCount);
224
225 _SetUpdateBits(&updateMask, target);
226 BuildValuesUpdate(UPDATETYPE_VALUES, &buf, &updateMask, target);
227
228 data->AddUpdateBlock(buf);
229 }
230
231 void Object::BuildOutOfRangeUpdateBlock(UpdateData * data) const
232 {
233 data->AddOutOfRangeGUID(GetGUID());
234 }
235
236 void Object::DestroyForPlayer( Player *target, bool anim ) const
237 {
238 ASSERT(target);
239
240 WorldPacket data(SMSG_DESTROY_OBJECT, 8);
241 data << uint64(GetGUID());
242 data << uint8(anim ? 1 : 0); // WotLK (bool), may be despawn animation
243 target->GetSession()->SendPacket(&data);
244 }
245
246 void Object::BuildMovementUpdate(ByteBuffer * data, uint16 updateFlags) const
247 {
248 uint16 moveFlags2 = (isType(TYPEMASK_UNIT) ? ((Unit*)this)->m_movementInfo.GetMovementFlags2() : MOVEFLAG2_NONE);
249
250 if(GetTypeId() == TYPEID_UNIT)
251 if(((Creature*)this)->isVehicle())
252 moveFlags2 |= MOVEFLAG2_ALLOW_PITCHING; // always allow pitch
253
254 *data << uint16(updateFlags); // update flags
255
256 // 0x20
257 if (updateFlags & UPDATEFLAG_LIVING)
258 {
259 Unit *unit = ((Unit*)this);
260
261 switch(GetTypeId())
262 {
263 case TYPEID_UNIT:
264 {
265 unit->m_movementInfo.SetMovementFlags(MOVEFLAG_NONE);
266
267 // disabled, makes them run-in-same-place before movement generator updated once.
268 /*if (((Creature*)unit)->hasUnitState(UNIT_STAT_MOVING))
269 unit->m_movementInfo.SetMovementFlags(MOVEFLAG_FORWARD);*/
270
271 if (((Creature*)unit)->canFly())
272 {
273 // (ok) most seem to have this
274 unit->m_movementInfo.AddMovementFlag(MOVEFLAG_LEVITATING);
275
276 if (!((Creature*)unit)->hasUnitState(UNIT_STAT_MOVING))
277 {
278 // (ok) possibly some "hover" mode
279 unit->m_movementInfo.AddMovementFlag(MOVEFLAG_ROOT);
280 }
281 else
282 {
283 if (((Creature*)unit)->IsMounted())
284 {
285 // seems to be often when mounted
286 unit->m_movementInfo.AddMovementFlag(MOVEFLAG_FLYING);
287 }
288 }
289 }
290 }
291 break;
292 case TYPEID_PLAYER:
293 {
294 Player *player = ((Player*)unit);
295
296 if(player->GetTransport())
297 player->m_movementInfo.AddMovementFlag(MOVEFLAG_ONTRANSPORT);
298 else
299 player->m_movementInfo.RemoveMovementFlag(MOVEFLAG_ONTRANSPORT);
300
301 // remove unknown, unused etc flags for now
302 player->m_movementInfo.RemoveMovementFlag(MOVEFLAG_SPLINE_ENABLED);
303
304 if(player->isInFlight())
305 {
306 ASSERT(player->GetMotionMaster()->GetCurrentMovementGeneratorType() == FLIGHT_MOTION_TYPE);
307 player->m_movementInfo.AddMovementFlag(MOVEFLAG_FORWARD);
308 player->m_movementInfo.AddMovementFlag(MOVEFLAG_SPLINE_ENABLED);
309 }
310 }
311 break;
312 }
313
314 // Update movement info time
315 unit->m_movementInfo.UpdateTime(getMSTime());
316 // Write movement info
317 unit->m_movementInfo.Write(*data);
318
319 // Unit speeds
320 *data << float(unit->GetSpeed(MOVE_WALK));
321 *data << float(unit->GetSpeed(MOVE_RUN));
322 *data << float(unit->GetSpeed(MOVE_SWIM_BACK));
323 *data << float(unit->GetSpeed(MOVE_SWIM));
324 *data << float(unit->GetSpeed(MOVE_RUN_BACK));
325 *data << float(unit->GetSpeed(MOVE_FLIGHT));
326 *data << float(unit->GetSpeed(MOVE_FLIGHT_BACK));
327 *data << float(unit->GetSpeed(MOVE_TURN_RATE));
328 *data << float(unit->GetSpeed(MOVE_PITCH_RATE));
329
330 // 0x08000000
331 if(unit->m_movementInfo.GetMovementFlags() & MOVEFLAG_SPLINE_ENABLED)
332 {
333 if(GetTypeId() != TYPEID_PLAYER)
334 {
335 sLog.outDebug("_BuildMovementUpdate: MOVEFLAG_SPLINE_ENABLED for non-player");
336 return;
337 }
338
339 Player *player = ((Player*)unit);
340
341 if(!player->isInFlight())
342 {
343 sLog.outDebug("_BuildMovementUpdate: MOVEFLAG_SPLINE_ENABLED but not in flight");
344 return;
345 }
346
347 ASSERT(player->GetMotionMaster()->GetCurrentMovementGeneratorType() == FLIGHT_MOTION_TYPE);
348
349 FlightPathMovementGenerator *fmg = (FlightPathMovementGenerator*)(player->GetMotionMaster()->top());
350
351 uint32 flags3 = SPLINEFLAG_WALKMODE | SPLINEFLAG_FLYING;
352
353 *data << uint32(flags3); // splines flag?
354
355 if(flags3 & SPLINEFLAG_FINALFACING) // may be orientation
356 {
357 *data << float(0);
358 }
359 else
360 {
361 if(flags3 & SPLINEFLAG_FINALTARGET) // probably guid there
362 {
363 *data << uint64(0);
364 }
365 else
366 {
367 if(flags3 & SPLINEFLAG_FINALPOINT) // probably x,y,z coords there
368 {
369 *data << float(0);
370 *data << float(0);
371 *data << float(0);
372 }
373 }
374 }
375
376 Path &path = fmg->GetPath();
377
378 float x, y, z;
379 player->GetPosition(x, y, z);
380
381 uint32 inflighttime = uint32(path.GetPassedLength(fmg->GetCurrentNode(), x, y, z) * 32);
382 uint32 traveltime = uint32(path.GetTotalLength() * 32);
383
384 *data << uint32(inflighttime); // passed move time?
385 *data << uint32(traveltime); // full move time?
386 *data << uint32(0); // sequenceId
387
388 *data << float(0); // added in 3.1
389 *data << float(0); // added in 3.1
390 *data << float(0); // added in 3.1
391
392 *data << uint32(0); // added in 3.1
393
394 uint32 poscount = uint32(path.Size());
395 *data << uint32(poscount); // points count
396
397 for(uint32 i = 0; i < poscount; ++i)
398 {
399 *data << float(path.GetNodes()[i].x);
400 *data << float(path.GetNodes()[i].y);
401 *data << float(path.GetNodes()[i].z);
402 }
403
404 *data << uint8(0); // splineMode
405
406 *data << float(path.GetNodes()[poscount-1].x);
407 *data << float(path.GetNodes()[poscount-1].y);
408 *data << float(path.GetNodes()[poscount-1].z);
409 }
410 }
411 else
412 {
413 if(updateFlags & UPDATEFLAG_POSITION)
414 {
415 *data << uint8(0); // unk PGUID!
416 *data << float(((WorldObject*)this)->GetPositionX());
417 *data << float(((WorldObject*)this)->GetPositionY());
418 *data << float(((WorldObject*)this)->GetPositionZ());
419 *data << float(((WorldObject*)this)->GetPositionX());
420 *data << float(((WorldObject*)this)->GetPositionY());
421 *data << float(((WorldObject*)this)->GetPositionZ());
422 *data << float(((WorldObject*)this)->GetOrientation());
423
424 if(GetTypeId() == TYPEID_CORPSE)
425 *data << float(((WorldObject*)this)->GetOrientation());
426 else
427 *data << float(0);
428 }
429 else
430 {
431 // 0x40
432 if (updateFlags & UPDATEFLAG_HAS_POSITION)
433 {
434 // 0x02
435 if(updateFlags & UPDATEFLAG_TRANSPORT && ((GameObject*)this)->GetGoType() == GAMEOBJECT_TYPE_MO_TRANSPORT)
436 {
437 *data << float(0);
438 *data << float(0);
439 *data << float(0);
440 *data << float(((WorldObject *)this)->GetOrientation());
441 }
442 else
443 {
444 *data << float(((WorldObject *)this)->GetPositionX());
445 *data << float(((WorldObject *)this)->GetPositionY());
446 *data << float(((WorldObject *)this)->GetPositionZ());
447 *data << float(((WorldObject *)this)->GetOrientation());
448 }
449 }
450 }
451 }
452
453 // 0x8
454 if(updateFlags & UPDATEFLAG_LOWGUID)
455 {
456 switch(GetTypeId())
457 {
458 case TYPEID_OBJECT:
459 case TYPEID_ITEM:
460 case TYPEID_CONTAINER:
461 case TYPEID_GAMEOBJECT:
462 case TYPEID_DYNAMICOBJECT:
463 case TYPEID_CORPSE:
464 *data << uint32(GetGUIDLow()); // GetGUIDLow()
465 break;
466 case TYPEID_UNIT:
467 *data << uint32(0x0000000B); // unk, can be 0xB or 0xC
468 break;
469 case TYPEID_PLAYER:
470 if(updateFlags & UPDATEFLAG_SELF)
471 *data << uint32(0x0000002F); // unk, can be 0x15 or 0x22
472 else
473 *data << uint32(0x00000008); // unk, can be 0x7 or 0x8
474 break;
475 default:
476 *data << uint32(0x00000000); // unk
477 break;
478 }
479 }
480
481 // 0x10
482 if(updateFlags & UPDATEFLAG_HIGHGUID)
483 {
484 switch(GetTypeId())
485 {
486 case TYPEID_OBJECT:
487 case TYPEID_ITEM:
488 case TYPEID_CONTAINER:
489 case TYPEID_GAMEOBJECT:
490 case TYPEID_DYNAMICOBJECT:
491 case TYPEID_CORPSE:
492 *data << uint32(GetGUIDHigh()); // GetGUIDHigh()
493 break;
494 case TYPEID_UNIT:
495 *data << uint32(0x0000000B); // unk, can be 0xB or 0xC
496 break;
497 case TYPEID_PLAYER:
498 if(updateFlags & UPDATEFLAG_SELF)
499 *data << uint32(0x0000002F); // unk, can be 0x15 or 0x22
500 else
501 *data << uint32(0x00000008); // unk, can be 0x7 or 0x8
502 break;
503 default:
504 *data << uint32(0x00000000); // unk
505 break;
506 }
507 }
508
509 // 0x4
510 if(updateFlags & UPDATEFLAG_HAS_ATTACKING_TARGET) // packed guid (current target guid)
511 {
512 if (((Unit*)this)->getVictim())
513 data->append(((Unit*)this)->getVictim()->GetPackGUID());
514 else
515 data->appendPackGUID(0);
516 }
517
518 // 0x2
519 if(updateFlags & UPDATEFLAG_TRANSPORT)
520 {
521 *data << uint32(getMSTime()); // ms time
522 }
523
524 // 0x80
525 if(updateFlags & UPDATEFLAG_VEHICLE) // unused for now
526 {
527 *data << uint32(((Vehicle*)this)->GetVehicleId()); // vehicle id
528 *data << float(((WorldObject*)this)->GetOrientation());
529 }
530
531 // 0x200
532 if(updateFlags & UPDATEFLAG_ROTATION)
533 {
534 *data << uint64(((GameObject*)this)->GetRotation());
535 }
536 }
537
538 void Object::BuildValuesUpdate(uint8 updatetype, ByteBuffer * data, UpdateMask *updateMask, Player *target) const
539 {
540 if(!target)
541 return;
542
543 bool IsActivateToQuest = false;
544 bool IsPerCasterAuraState = false;
545 if (updatetype == UPDATETYPE_CREATE_OBJECT || updatetype == UPDATETYPE_CREATE_OBJECT2)
546 {
547 if (isType(TYPEMASK_GAMEOBJECT) && !((GameObject*)this)->IsTransport())
548 {
549 if ( ((GameObject*)this)->ActivateToQuest(target) || target->isGameMaster())
550 IsActivateToQuest = true;
551
552 updateMask->SetBit(GAMEOBJECT_DYNAMIC);
553 }
554 else if (isType(TYPEMASK_UNIT))
555 {
556 if( ((Unit*)this)->HasAuraState(AURA_STATE_CONFLAGRATE))
557 {
558 IsPerCasterAuraState = true;
559 updateMask->SetBit(UNIT_FIELD_AURASTATE);
560 }
561 }
562 }
563 else // case UPDATETYPE_VALUES
564 {
565 if (isType(TYPEMASK_GAMEOBJECT) && !((GameObject*)this)->IsTransport())
566 {
567 if ( ((GameObject*)this)->ActivateToQuest(target) || target->isGameMaster())
568 {
569 IsActivateToQuest = true;
570 }
571 updateMask->SetBit(GAMEOBJECT_DYNAMIC);
572 updateMask->SetBit(GAMEOBJECT_BYTES_1);
573 }
574 else if (isType(TYPEMASK_UNIT))
575 {
576 if( ((Unit*)this)->HasAuraState(AURA_STATE_CONFLAGRATE))
577 {
578 IsPerCasterAuraState = true;
579 updateMask->SetBit(UNIT_FIELD_AURASTATE);
580 }
581 }
582 }
583
584 ASSERT(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)
602 {
603 if (!target->canSeeSpellClickOn((Creature*)this))
604 appendValue &= ~UNIT_NPC_FLAG_SPELLCLICK;
605
606 if (appendValue & UNIT_NPC_FLAG_TRAINER)
607 {
608 if (!((Creature*)this)->isCanTrainingOf(target, false))
609 appendValue &= ~(UNIT_NPC_FLAG_TRAINER | UNIT_NPC_FLAG_TRAINER_CLASS | UNIT_NPC_FLAG_TRAINER_PROFESSION);
610 }
611
612 if (appendValue & UNIT_NPC_FLAG_STABLEMASTER)
613 {
614 if (target->getClass() != CLASS_HUNTER)
615 appendValue &= ~UNIT_NPC_FLAG_STABLEMASTER;
616 }
617 }
618
619 *data << uint32(appendValue);
620 }
621 else if (index == UNIT_FIELD_AURASTATE)
622 {
623 if(IsPerCasterAuraState)
624 {
625 // IsPerCasterAuraState set if related pet caster aura state set already
626 if (((Unit*)this)->HasAuraStateForCaster(AURA_STATE_CONFLAGRATE,target->GetGUID()))
627 *data << m_uint32Values[ index ];
628 else
629 *data << (m_uint32Values[ index ] & ~(1 << (AURA_STATE_CONFLAGRATE-1)));
630 }
631 else
632 *data << m_uint32Values[ index ];
633 }
634 // FIXME: Some values at server stored in float format but must be sent to client in uint32 format
635 else if(index >= UNIT_FIELD_BASEATTACKTIME && index <= UNIT_FIELD_RANGEDATTACKTIME)
636 {
637 // convert from float to uint32 and send
638 *data << uint32(m_floatValues[ index ] < 0 ? 0 : m_floatValues[ index ]);
639 }
640
641 // there are some float values which may be negative or can't get negative due to other checks
642 else if ((index >= UNIT_FIELD_NEGSTAT0 && index <= UNIT_FIELD_NEGSTAT4) ||
643 (index >= UNIT_FIELD_RESISTANCEBUFFMODSPOSITIVE && index <= (UNIT_FIELD_RESISTANCEBUFFMODSPOSITIVE + 6)) ||
644 (index >= UNIT_FIELD_RESISTANCEBUFFMODSNEGATIVE && index <= (UNIT_FIELD_RESISTANCEBUFFMODSNEGATIVE + 6)) ||
645 (index >= UNIT_FIELD_POSSTAT0 && index <= UNIT_FIELD_POSSTAT4))
646 {
647 *data << uint32(m_floatValues[ index ]);
648 }
649
650 // Gamemasters should be always able to select units - remove not selectable flag
651 else if(index == UNIT_FIELD_FLAGS && target->isGameMaster())
652 {
653 *data << (m_uint32Values[ index ] & ~UNIT_FLAG_NOT_SELECTABLE);
654 }
655 // hide lootable animation for unallowed players
656 else if(index == UNIT_DYNAMIC_FLAGS && GetTypeId() == TYPEID_UNIT)
657 {
658 if(!target->isAllowedToLoot((Creature*)this))
659 *data << (m_uint32Values[ index ] & ~UNIT_DYNFLAG_LOOTABLE);
660 else
661 *data << (m_uint32Values[ index ] & ~UNIT_DYNFLAG_TAPPED);
662 }
663 else
664 {
665 // send in current format (float as float, uint32 as uint32)
666 *data << m_uint32Values[ index ];
667 }
668 }
669 }
670 }
671 else if(isType(TYPEMASK_GAMEOBJECT)) // gameobject case
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 if ( index == GAMEOBJECT_DYNAMIC )
679 {
680 if(IsActivateToQuest )
681 {
682 switch(((GameObject*)this)->GetGoType())
683 {
684 case GAMEOBJECT_TYPE_CHEST:
685 // enable quest object. Represent 9, but 1 for client before 2.3.0
686 *data << uint16(9);
687 *data << uint16(-1);
688 break;
689 case GAMEOBJECT_TYPE_GOOBER:
690 *data << uint16(1);
691 *data << uint16(-1);
692 break;
693 default:
694 // unknown, not happen.
695 *data << uint16(0);
696 *data << uint16(-1);
697 break;
698 }
699 }
700 else
701 {
702 // disable quest object
703 *data << uint16(0);
704 *data << uint16(-1);
705 }
706 }
707 else
708 *data << m_uint32Values[ index ]; // other cases
709 }
710 }
711 }
712 else // other objects case (no special index checks)
713 {
714 for( uint16 index = 0; index < m_valuesCount; ++index )
715 {
716 if( updateMask->GetBit( index ) )
717 {
718 // send in current format (float as float, uint32 as uint32)
719 *data << m_uint32Values[ index ];
720 }
721 }
722 }
723 }
724
725 void Object::ClearUpdateMask(bool remove)
726 {
727 if(m_uint32Values)
728 {
729 for( uint16 index = 0; index < m_valuesCount; ++index )
730 {
731 if(m_uint32Values_mirror[index]!= m_uint32Values[index])
732 m_uint32Values_mirror[index] = m_uint32Values[index];
733 }
734 }
735
736 if(m_objectUpdated)
737 {
738 if(remove)
739 RemoveFromClientUpdateList();
740 m_objectUpdated = false;
741 }
742 }
743
744 bool Object::LoadValues(const char* data)
745 {
746 if(!m_uint32Values) _InitValues();
747
748 Tokens tokens = StrSplit(data, " ");
749
750 if(tokens.size() != m_valuesCount)
751 return false;
752
753 Tokens::iterator iter;
754 int index;
755 for (iter = tokens.begin(), index = 0; index < m_valuesCount; ++iter, ++index)
756 {
757 m_uint32Values[index] = atol((*iter).c_str());
758 }
759
760 return true;
761 }
762
763 void Object::_SetUpdateBits(UpdateMask *updateMask, Player* /*target*/) const
764 {
765 for( uint16 index = 0; index < m_valuesCount; ++index )
766 {
767 if(m_uint32Values_mirror[index]!= m_uint32Values[index])
768 updateMask->SetBit(index);
769 }
770 }
771
772 void Object::_SetCreateBits(UpdateMask *updateMask, Player* /*target*/) const
773 {
774 for( uint16 index = 0; index < m_valuesCount; ++index )
775 {
776 if(GetUInt32Value(index) != 0)
777 updateMask->SetBit(index);
778 }
779 }
780
781 void Object::SetInt32Value( uint16 index, int32 value )
782 {
783 ASSERT( index < m_valuesCount || PrintIndexError( index, true ) );
784
785 if(m_int32Values[ index ] != value)
786 {
787 m_int32Values[ index ] = value;
788
789 if(m_inWorld)
790 {
791 if(!m_objectUpdated)
792 {
793 AddToClientUpdateList();
794 m_objectUpdated = true;
795 }
796 }
797 }
798 }
799
800 void Object::SetUInt32Value( uint16 index, uint32 value )
801 {
802 ASSERT( index < m_valuesCount || PrintIndexError( index, true ) );
803
804 if(m_uint32Values[ index ] != value)
805 {
806 m_uint32Values[ index ] = value;
807
808 if(m_inWorld)
809 {
810 if(!m_objectUpdated)
811 {
812 AddToClientUpdateList();
813 m_objectUpdated = true;
814 }
815 }
816 }
817 }
818
819 void Object::SetUInt64Value( uint16 index, const uint64 &value )
820 {
821 ASSERT( index + 1 < m_valuesCount || PrintIndexError( index, true ) );
822 if(*((uint64*)&(m_uint32Values[ index ])) != value)
823 {
824 m_uint32Values[ index ] = *((uint32*)&value);
825 m_uint32Values[ index + 1 ] = *(((uint32*)&value) + 1);
826
827 if(m_inWorld)
828 {
829 if(!m_objectUpdated)
830 {
831 AddToClientUpdateList();
832 m_objectUpdated = true;
833 }
834 }
835 }
836 }
837
838 void Object::SetFloatValue( uint16 index, float value )
839 {
840 ASSERT( index < m_valuesCount || PrintIndexError( index, true ) );
841
842 if(m_floatValues[ index ] != value)
843 {
844 m_floatValues[ index ] = value;
845
846 if(m_inWorld)
847 {
848 if(!m_objectUpdated)
849 {
850 AddToClientUpdateList();
851 m_objectUpdated = true;
852 }
853 }
854 }
855 }
856
857 void Object::SetByteValue( uint16 index, uint8 offset, uint8 value )
858 {
859 ASSERT( index < m_valuesCount || PrintIndexError( index, true ) );
860
861 if(offset > 4)
862 {
863 sLog.outError("Object::SetByteValue: wrong offset %u", offset);
864 return;
865 }
866
867 if(uint8(m_uint32Values[ index ] >> (offset * 8)) != value)
868 {
869 m_uint32Values[ index ] &= ~uint32(uint32(0xFF) << (offset * 8));
870 m_uint32Values[ index ] |= uint32(uint32(value) << (offset * 8));
871
872 if(m_inWorld)
873 {
874 if(!m_objectUpdated)
875 {
876 AddToClientUpdateList();
877 m_objectUpdated = true;
878 }
879 }
880 }
881 }
882
883 void Object::SetUInt16Value( uint16 index, uint8 offset, uint16 value )
884 {
885 ASSERT( index < m_valuesCount || PrintIndexError( index, true ) );
886
887 if(offset > 2)
888 {
889 sLog.outError("Object::SetUInt16Value: wrong offset %u", offset);
890 return;
891 }
892
893 if(uint16(m_uint32Values[ index ] >> (offset * 16)) != value)
894 {
895 m_uint32Values[ index ] &= ~uint32(uint32(0xFFFF) << (offset * 16));
896 m_uint32Values[ index ] |= uint32(uint32(value) << (offset * 16));
897
898 if(m_inWorld)
899 {
900 if(!m_objectUpdated)
901 {
902 AddToClientUpdateList();
903 m_objectUpdated = true;
904 }
905 }
906 }
907 }
908
909 void Object::SetStatFloatValue( uint16 index, float value)
910 {
911 if(value < 0)
912 value = 0.0f;
913
914 SetFloatValue(index, value);
915 }
916
917 void Object::SetStatInt32Value( uint16 index, int32 value)
918 {
919 if(value < 0)
920 value = 0;
921
922 SetUInt32Value(index, uint32(value));
923 }
924
925 void Object::ApplyModUInt32Value(uint16 index, int32 val, bool apply)
926 {
927 int32 cur = GetUInt32Value(index);
928 cur += (apply ? val : -val);
929 if(cur < 0)
930 cur = 0;
931 SetUInt32Value(index, cur);
932 }
933
934 void Object::ApplyModInt32Value(uint16 index, int32 val, bool apply)
935 {
936 int32 cur = GetInt32Value(index);
937 cur += (apply ? val : -val);
938 SetInt32Value(index, cur);
939 }
940
941 void Object::ApplyModSignedFloatValue(uint16 index, float val, bool apply)
942 {
943 float cur = GetFloatValue(index);
944 cur += (apply ? val : -val);
945 SetFloatValue(index, cur);
946 }
947
948 void Object::ApplyModPositiveFloatValue(uint16 index, float val, bool apply)
949 {
950 float cur = GetFloatValue(index);
951 cur += (apply ? val : -val);
952 if(cur < 0)
953 cur = 0;
954 SetFloatValue(index, cur);
955 }
956
957 void Object::SetFlag( uint16 index, uint32 newFlag )
958 {
959 ASSERT( index < m_valuesCount || PrintIndexError( index, true ) );
960 uint32 oldval = m_uint32Values[ index ];
961 uint32 newval = oldval | newFlag;
962
963 if(oldval != newval)
964 {
965 m_uint32Values[ index ] = newval;
966
967 if(m_inWorld)
968 {
969 if(!m_objectUpdated)
970 {
971 AddToClientUpdateList();
972 m_objectUpdated = true;
973 }
974 }
975 }
976 }
977
978 void Object::RemoveFlag( uint16 index, uint32 oldFlag )
979 {
980 ASSERT( index < m_valuesCount || PrintIndexError( index, true ) );
981 uint32 oldval = m_uint32Values[ index ];
982 uint32 newval = oldval & ~oldFlag;
983
984 if(oldval != newval)
985 {
986 m_uint32Values[ index ] = newval;
987
988 if(m_inWorld)
989 {
990 if(!m_objectUpdated)
991 {
992 AddToClientUpdateList();
993 m_objectUpdated = true;
994 }
995 }
996 }
997 }
998
999 void Object::SetByteFlag( uint16 index, uint8 offset, uint8 newFlag )
1000 {
1001 ASSERT( index < m_valuesCount || PrintIndexError( index, true ) );
1002
1003 if(offset > 4)
1004 {
1005 sLog.outError("Object::SetByteFlag: wrong offset %u", offset);
1006 return;
1007 }
1008
1009 if(!(uint8(m_uint32Values[ index ] >> (offset * 8)) & newFlag))
1010 {
1011 m_uint32Values[ index ] |= uint32(uint32(newFlag) << (offset * 8));
1012
1013 if(m_inWorld)
1014 {
1015 if(!m_objectUpdated)
1016 {
1017 AddToClientUpdateList();
1018 m_objectUpdated = true;
1019 }
1020 }
1021 }
1022 }
1023
1024 void Object::RemoveByteFlag( uint16 index, uint8 offset, uint8 oldFlag )
1025 {
1026 ASSERT( index < m_valuesCount || PrintIndexError( index, true ) );
1027
1028 if(offset > 4)
1029 {
1030 sLog.outError("Object::RemoveByteFlag: wrong offset %u", offset);
1031 return;
1032 }
1033
1034 if(uint8(m_uint32Values[ index ] >> (offset * 8)) & oldFlag)
1035 {
1036 m_uint32Values[ index ] &= ~uint32(uint32(oldFlag) << (offset * 8));
1037
1038 if(m_inWorld)
1039 {
1040 if(!m_objectUpdated)
1041 {
1042 AddToClientUpdateList();
1043 m_objectUpdated = true;
1044 }
1045 }
1046 }
1047 }
1048
1049 bool Object::PrintIndexError(uint32 index, bool set) const
1050 {
1051 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);
1052
1053 // assert must fail after function call
1054 return false;
1055 }
1056
1057 void Object::BuildUpdateDataForPlayer(Player* pl, UpdateDataMapType& update_players)
1058 {
1059 UpdateDataMapType::iterator iter = update_players.find(pl);
1060
1061 if (iter == update_players.end())
1062 {
1063 std::pair<UpdateDataMapType::iterator, bool> p = update_players.insert( UpdateDataMapType::value_type(pl, UpdateData()) );
1064 assert(p.second);
1065 iter = p.first;
1066 }
1067
1068 BuildValuesUpdateBlockForPlayer(&iter->second, iter->first);
1069 }
1070
1071 void Object::AddToClientUpdateList()
1072 {
1073 sLog.outError("Unexpected call of Object::AddToClientUpdateList for object (TypeId: %u Update fields: %u)",GetTypeId(), m_valuesCount);
1074 ASSERT(false);
1075 }
1076
1077 void Object::RemoveFromClientUpdateList()
1078 {
1079 sLog.outError("Unexpected call of Object::RemoveFromClientUpdateList for object (TypeId: %u Update fields: %u)",GetTypeId(), m_valuesCount);
1080 ASSERT(false);
1081 }
1082
1083 void Object::BuildUpdateData( UpdateDataMapType& /*update_players */)
1084 {
1085 sLog.outError("Unexpected call of Object::BuildUpdateData for object (TypeId: %u Update fields: %u)",GetTypeId(), m_valuesCount);
1086 ASSERT(false);
1087 }
1088
1089 WorldObject::WorldObject()
1090 : m_currMap(NULL), m_mapId(0), m_InstanceId(0), m_phaseMask(PHASEMASK_NORMAL),
1091 m_positionX(0.0f), m_positionY(0.0f), m_positionZ(0.0f), m_orientation(0.0f)
1092 {
1093 }
1094
1095 void WorldObject::CleanupsBeforeDelete()
1096 {
1097 RemoveFromWorld();
1098 }
1099
1100 void WorldObject::_Create( uint32 guidlow, HighGuid guidhigh, uint32 phaseMask )
1101 {
1102 Object::_Create(guidlow, 0, guidhigh);
1103 m_phaseMask = phaseMask;
1104 }
1105
1106 void WorldObject::Relocate(float x, float y, float z, float orientation)
1107 {
1108 m_positionX = x;
1109 m_positionY = y;
1110 m_positionZ = z;
1111 m_orientation = orientation;
1112
1113 if(isType(TYPEMASK_UNIT))
1114 ((Unit*)this)->m_movementInfo.ChangePosition(x, y, z, orientation);
1115 }
1116
1117 void WorldObject::Relocate(float x, float y, float z)
1118 {
1119 m_positionX = x;
1120 m_positionY = y;
1121 m_positionZ = z;
1122
1123 if(isType(TYPEMASK_UNIT))
1124 ((Unit*)this)->m_movementInfo.ChangePosition(x, y, z, GetOrientation());
1125 }
1126
1127 uint32 WorldObject::GetZoneId() const
1128 {
1129 return GetBaseMap()->GetZoneId(m_positionX, m_positionY, m_positionZ);
1130 }
1131
1132 uint32 WorldObject::GetAreaId() const
1133 {
1134 return GetBaseMap()->GetAreaId(m_positionX, m_positionY, m_positionZ);
1135 }
1136
1137 void WorldObject::GetZoneAndAreaId(uint32& zoneid, uint32& areaid) const
1138 {
1139 GetBaseMap()->GetZoneAndAreaId(zoneid, areaid, m_positionX, m_positionY, m_positionZ);
1140 }
1141
1142 InstanceData* WorldObject::GetInstanceData()
1143 {
1144 Map *map = GetMap();
1145 return map->IsDungeon() ? ((InstanceMap*)map)->GetInstanceData() : NULL;
1146 }
1147
1148 //slow
1149 float WorldObject::GetDistance(const WorldObject* obj) const
1150 {
1151 float dx = GetPositionX() - obj->GetPositionX();
1152 float dy = GetPositionY() - obj->GetPositionY();
1153 float dz = GetPositionZ() - obj->GetPositionZ();
1154 float sizefactor = GetObjectSize() + obj->GetObjectSize();
1155 float dist = sqrt((dx*dx) + (dy*dy) + (dz*dz)) - sizefactor;
1156 return ( dist > 0 ? dist : 0);
1157 }
1158
1159 float WorldObject::GetDistance2d(float x, float y) const
1160 {
1161 float dx = GetPositionX() - x;
1162 float dy = GetPositionY() - y;
1163 float sizefactor = GetObjectSize();
1164 float dist = sqrt((dx*dx) + (dy*dy)) - sizefactor;
1165 return ( dist > 0 ? dist : 0);
1166 }
1167
1168 float WorldObject::GetDistance(float x, float y, float z) const
1169 {
1170 float dx = GetPositionX() - x;
1171 float dy = GetPositionY() - y;
1172 float dz = GetPositionZ() - z;
1173 float sizefactor = GetObjectSize();
1174 float dist = sqrt((dx*dx) + (dy*dy) + (dz*dz)) - sizefactor;
1175 return ( dist > 0 ? dist : 0);
1176 }
1177
1178 float WorldObject::GetDistance2d(const WorldObject* obj) const
1179 {
1180 float dx = GetPositionX() - obj->GetPositionX();
1181 float dy = GetPositionY() - obj->GetPositionY();
1182 float sizefactor = GetObjectSize() + obj->GetObjectSize();
1183 float dist = sqrt((dx*dx) + (dy*dy)) - sizefactor;
1184 return ( dist > 0 ? dist : 0);
1185 }
1186
1187 float WorldObject::GetDistanceZ(const WorldObject* obj) const
1188 {
1189 float dz = fabs(GetPositionZ() - obj->GetPositionZ());
1190 float sizefactor = GetObjectSize() + obj->GetObjectSize();
1191 float dist = dz - sizefactor;
1192 return ( dist > 0 ? dist : 0);
1193 }
1194
1195 bool WorldObject::IsWithinDist3d(float x, float y, float z, float dist2compare) const
1196 {
1197 float dx = GetPositionX() - x;
1198 float dy = GetPositionY() - y;
1199 float dz = GetPositionZ() - z;
1200 float distsq = dx*dx + dy*dy + dz*dz;
1201
1202 float sizefactor = GetObjectSize();
1203 float maxdist = dist2compare + sizefactor;
1204
1205 return distsq < maxdist * maxdist;
1206 }
1207
1208 bool WorldObject::IsWithinDist2d(float x, float y, float dist2compare) const
1209 {
1210 float dx = GetPositionX() - x;
1211 float dy = GetPositionY() - y;
1212 float distsq = dx*dx + dy*dy;
1213
1214 float sizefactor = GetObjectSize();
1215 float maxdist = dist2compare + sizefactor;
1216
1217 return distsq < maxdist * maxdist;
1218 }
1219
1220 bool WorldObject::_IsWithinDist(WorldObject const* obj, float dist2compare, bool is3D) const
1221 {
1222 float dx = GetPositionX() - obj->GetPositionX();
1223 float dy = GetPositionY() - obj->GetPositionY();
1224 float distsq = dx*dx + dy*dy;
1225 if(is3D)
1226 {
1227 float dz = GetPositionZ() - obj->GetPositionZ();
1228 distsq += dz*dz;
1229 }
1230 float sizefactor = GetObjectSize() + obj->GetObjectSize();
1231 float maxdist = dist2compare + sizefactor;
1232
1233 return distsq < maxdist * maxdist;
1234 }
1235
1236 bool WorldObject::IsWithinLOSInMap(const WorldObject* obj) const
1237 {
1238 if (!IsInMap(obj)) return false;
1239 float ox,oy,oz;
1240 obj->GetPosition(ox,oy,oz);
1241 return(IsWithinLOS(ox, oy, oz ));
1242 }
1243
1244 bool WorldObject::IsWithinLOS(float ox, float oy, float oz) const
1245 {
1246 float x,y,z;
1247 GetPosition(x,y,z);
1248 VMAP::IVMapManager *vMapManager = VMAP::VMapFactory::createOrGetVMapManager();
1249 return vMapManager->isInLineOfSight(GetMapId(), x, y, z+2.0f, ox, oy, oz+2.0f);
1250 }
1251
1252 bool WorldObject::GetDistanceOrder(WorldObject const* obj1, WorldObject const* obj2, bool is3D /* = true */) const
1253 {
1254 float dx1 = GetPositionX() - obj1->GetPositionX();
1255 float dy1 = GetPositionY() - obj1->GetPositionY();
1256 float distsq1 = dx1*dx1 + dy1*dy1;
1257 if(is3D)
1258 {
1259 float dz1 = GetPositionZ() - obj1->GetPositionZ();
1260 distsq1 += dz1*dz1;
1261 }
1262
1263 float dx2 = GetPositionX() - obj2->GetPositionX();
1264 float dy2 = GetPositionY() - obj2->GetPositionY();
1265 float distsq2 = dx2*dx2 + dy2*dy2;
1266 if(is3D)
1267 {
1268 float dz2 = GetPositionZ() - obj2->GetPositionZ();
1269 distsq2 += dz2*dz2;
1270 }
1271
1272 return distsq1 < distsq2;
1273 }
1274
1275 bool WorldObject::IsInRange(WorldObject const* obj, float minRange, float maxRange, bool is3D /* = true */) const
1276 {
1277 float dx = GetPositionX() - obj->GetPositionX();
1278 float dy = GetPositionY() - obj->GetPositionY();
1279 float distsq = dx*dx + dy*dy;
1280 if(is3D)
1281 {
1282 float dz = GetPositionZ() - obj->GetPositionZ();
1283 distsq += dz*dz;
1284 }
1285
1286 float sizefactor = GetObjectSize() + obj->GetObjectSize();
1287
1288 // check only for real range
1289 if(minRange > 0.0f)
1290 {
1291 float mindist = minRange + sizefactor;
1292 if(distsq < mindist * mindist)
1293 return false;
1294 }
1295
1296 float maxdist = maxRange + sizefactor;
1297 return distsq < maxdist * maxdist;
1298 }
1299
1300 bool WorldObject::IsInRange2d(float x, float y, float minRange, float maxRange) const
1301 {
1302 float dx = GetPositionX() - x;
1303 float dy = GetPositionY() - y;
1304 float distsq = dx*dx + dy*dy;
1305
1306 float sizefactor = GetObjectSize();
1307
1308 // check only for real range
1309 if(minRange > 0.0f)
1310 {
1311 float mindist = minRange + sizefactor;
1312 if(distsq < mindist * mindist)
1313 return false;
1314 }
1315
1316 float maxdist = maxRange + sizefactor;
1317 return distsq < maxdist * maxdist;
1318 }
1319
1320 bool WorldObject::IsInRange3d(float x, float y, float z, float minRange, float maxRange) const
1321 {
1322 float dx = GetPositionX() - x;
1323 float dy = GetPositionY() - y;
1324 float dz = GetPositionZ() - z;
1325 float distsq = dx*dx + dy*dy + dz*dz;
1326
1327 float sizefactor = GetObjectSize();
1328
1329 // check only for real range
1330 if(minRange > 0.0f)
1331 {
1332 float mindist = minRange + sizefactor;
1333 if(distsq < mindist * mindist)
1334 return false;
1335 }
1336
1337 float maxdist = maxRange + sizefactor;
1338 return distsq < maxdist * maxdist;
1339 }
1340
1341 float WorldObject::GetAngle(const WorldObject* obj) const
1342 {
1343 if(!obj) return 0;
1344 return GetAngle( obj->GetPositionX(), obj->GetPositionY() );
1345 }
1346
1347 // Return angle in range 0..2*pi
1348 float WorldObject::GetAngle( const float x, const float y ) const
1349 {
1350 float dx = x - GetPositionX();
1351 float dy = y - GetPositionY();
1352
1353 float ang = atan2(dy, dx);
1354 ang = (ang >= 0) ? ang : 2 * M_PI_F + ang;
1355 return ang;
1356 }
1357
1358 bool WorldObject::HasInArc(const float arcangle, const WorldObject* obj) const
1359 {
1360 // always have self in arc
1361 if(obj == this)
1362 return true;
1363
1364 float arc = arcangle;
1365
1366 // move arc to range 0.. 2*pi
1367 while( arc >= 2.0f * M_PI_F )
1368 arc -= 2.0f * M_PI_F;
1369 while( arc < 0 )
1370 arc += 2.0f * M_PI_F;
1371
1372 float angle = GetAngle( obj );
1373 angle -= m_orientation;
1374
1375 // move angle to range -pi ... +pi
1376 while( angle > M_PI_F)
1377 angle -= 2.0f * M_PI_F;
1378 while(angle < -M_PI_F)
1379 angle += 2.0f * M_PI_F;
1380
1381 float lborder = -1 * (arc/2.0f); // in range -pi..0
1382 float rborder = (arc/2.0f); // in range 0..pi
1383 return (( angle >= lborder ) && ( angle <= rborder ));
1384 }
1385
1386 bool WorldObject::isInFrontInMap(WorldObject const* target, float distance, float arc) const
1387 {
1388 return IsWithinDistInMap(target, distance) && HasInArc( arc, target );
1389 }
1390
1391 bool WorldObject::isInBackInMap(WorldObject const* target, float distance, float arc) const
1392 {
1393 return IsWithinDistInMap(target, distance) && !HasInArc( 2 * M_PI_F - arc, target );
1394 }
1395
1396 bool WorldObject::isInFront(WorldObject const* target, float distance, float arc) const
1397 {
1398 return IsWithinDist(target, distance) && HasInArc( arc, target );
1399 }
1400
1401 bool WorldObject::isInBack(WorldObject const* target, float distance, float arc) const
1402 {
1403 return IsWithinDist(target, distance) && !HasInArc( 2 * M_PI_F - arc, target );
1404 }
1405
1406 void WorldObject::GetRandomPoint( float x, float y, float z, float distance, float &rand_x, float &rand_y, float &rand_z) const
1407 {
1408 if(distance == 0)
1409 {
1410 rand_x = x;
1411 rand_y = y;
1412 rand_z = z;
1413 return;
1414 }
1415
1416 // angle to face `obj` to `this`
1417 float angle = rand_norm_f()*2*M_PI_F;
1418 float new_dist = rand_norm_f()*distance;
1419
1420 rand_x = x + new_dist * cos(angle);
1421 rand_y = y + new_dist * sin(angle);
1422 rand_z = z;
1423
1424 MaNGOS::NormalizeMapCoord(rand_x);
1425 MaNGOS::NormalizeMapCoord(rand_y);
1426 UpdateGroundPositionZ(rand_x,rand_y,rand_z); // update to LOS height if available
1427 }
1428
1429 void WorldObject::UpdateGroundPositionZ(float x, float y, float &z) const
1430 {
1431 float new_z = GetBaseMap()->GetHeight(x,y,z,true);
1432 if(new_z > INVALID_HEIGHT)
1433 z = new_z+ 0.05f; // just to be sure that we are not a few pixel under the surface
1434 }
1435
1436 bool WorldObject::IsPositionValid() const
1437 {
1438 return MaNGOS::IsValidMapCoord(m_positionX,m_positionY,m_positionZ,m_orientation);
1439 }
1440
1441 void WorldObject::MonsterSay(const char* text, uint32 language, uint64 TargetGuid)
1442 {
1443 WorldPacket data(SMSG_MESSAGECHAT, 200);
1444 BuildMonsterChat(&data,CHAT_MSG_MONSTER_SAY,text,language,GetName(),TargetGuid);
1445 SendMessageToSetInRange(&data,sWorld.getConfig(CONFIG_FLOAT_LISTEN_RANGE_SAY),true);
1446 }
1447
1448 void WorldObject::MonsterYell(const char* text, uint32 language, uint64 TargetGuid)
1449 {
1450 WorldPacket data(SMSG_MESSAGECHAT, 200);
1451 BuildMonsterChat(&data,CHAT_MSG_MONSTER_YELL,text,language,GetName(),TargetGuid);
1452 SendMessageToSetInRange(&data,sWorld.getConfig(CONFIG_FLOAT_LISTEN_RANGE_YELL),true);
1453 }
1454
1455 void WorldObject::MonsterTextEmote(const char* text, uint64 TargetGuid, bool IsBossEmote)
1456 {
1457 WorldPacket data(SMSG_MESSAGECHAT, 200);
1458 BuildMonsterChat(&data,IsBossEmote ? CHAT_MSG_RAID_BOSS_EMOTE : CHAT_MSG_MONSTER_EMOTE,text,LANG_UNIVERSAL,GetName(),TargetGuid);
1459 SendMessageToSetInRange(&data,sWorld.getConfig(IsBossEmote ? CONFIG_FLOAT_LISTEN_RANGE_YELL : CONFIG_FLOAT_LISTEN_RANGE_TEXTEMOTE),true);
1460 }
1461
1462 void WorldObject::MonsterWhisper(const char* text, uint64 receiver, bool IsBossWhisper)
1463 {
1464 Player *player = sObjectMgr.GetPlayer(receiver);
1465 if(!player || !player->GetSession())
1466 return;
1467
1468 WorldPacket data(SMSG_MESSAGECHAT, 200);
1469 BuildMonsterChat(&data,IsBossWhisper ? CHAT_MSG_RAID_BOSS_WHISPER : CHAT_MSG_MONSTER_WHISPER,text,LANG_UNIVERSAL,GetName(),receiver);
1470
1471 player->GetSession()->SendPacket(&data);
1472 }
1473
1474 namespace MaNGOS
1475 {
1476 class MonsterChatBuilder
1477 {
1478 public:
1479 MonsterChatBuilder(WorldObject const& obj, ChatMsg msgtype, int32 textId, uint32 language, uint64 targetGUID)
1480 : i_object(obj), i_msgtype(msgtype), i_textId(textId), i_language(language), i_targetGUID(targetGUID) {}
1481 void operator()(WorldPacket& data, int32 loc_idx)
1482 {
1483 char const* text = sObjectMgr.GetMangosString(i_textId,loc_idx);
1484
1485 // TODO: i_object.GetName() also must be localized?
1486 i_object.BuildMonsterChat(&data,i_msgtype,text,i_language,i_object.GetNameForLocaleIdx(loc_idx),i_targetGUID);
1487 }
1488
1489 private:
1490 WorldObject const& i_object;
1491 ChatMsg i_msgtype;
1492 int32 i_textId;
1493 uint32 i_language;
1494 uint64 i_targetGUID;
1495 };
1496 } // namespace MaNGOS
1497
1498 void WorldObject::MonsterSay(int32 textId, uint32 language, uint64 TargetGuid)
1499 {
1500 CellPair p = MaNGOS::ComputeCellPair(GetPositionX(), GetPositionY());
1501
1502 Cell cell(p);
1503 cell.data.Part.reserved = ALL_DISTRICT;
1504 cell.SetNoCreate();
1505
1506 MaNGOS::MonsterChatBuilder say_build(*this, CHAT_MSG_MONSTER_SAY, textId,language,TargetGuid);
1507 MaNGOS::LocalizedPacketDo<MaNGOS::MonsterChatBuilder> say_do(say_build);
1508 MaNGOS::PlayerDistWorker<MaNGOS::LocalizedPacketDo<MaNGOS::MonsterChatBuilder> > say_worker(this,sWorld.getConfig(CONFIG_FLOAT_LISTEN_RANGE_SAY),say_do);
1509 TypeContainerVisitor<MaNGOS::PlayerDistWorker<MaNGOS::LocalizedPacketDo<MaNGOS::MonsterChatBuilder> >, WorldTypeMapContainer > message(say_worker);
1510 cell.Visit(p, message, *GetMap(), *this, sWorld.getConfig(CONFIG_FLOAT_LISTEN_RANGE_SAY));
1511 }
1512
1513 void WorldObject::MonsterYell(int32 textId, uint32 language, uint64 TargetGuid)
1514 {
1515 CellPair p = MaNGOS::ComputeCellPair(GetPositionX(), GetPositionY());
1516
1517 Cell cell(p);
1518 cell.data.Part.reserved = ALL_DISTRICT;
1519 cell.SetNoCreate();
1520
1521 float range = sWorld.getConfig(CONFIG_FLOAT_LISTEN_RANGE_YELL);
1522
1523 MaNGOS::MonsterChatBuilder say_build(*this, CHAT_MSG_MONSTER_YELL, textId,language,TargetGuid);
1524 MaNGOS::LocalizedPacketDo<MaNGOS::MonsterChatBuilder> say_do(say_build);
1525 MaNGOS::PlayerDistWorker<MaNGOS::LocalizedPacketDo<MaNGOS::MonsterChatBuilder> > say_worker(this,range,say_do);
1526 TypeContainerVisitor<MaNGOS::PlayerDistWorker<MaNGOS::LocalizedPacketDo<MaNGOS::MonsterChatBuilder> >, WorldTypeMapContainer > message(say_worker);
1527 cell.Visit(p, message, *GetMap(), *this, range);
1528 }
1529
1530 void WorldObject::MonsterYellToZone(int32 textId, uint32 language, uint64 TargetGuid)
1531 {
1532 MaNGOS::MonsterChatBuilder say_build(*this, CHAT_MSG_MONSTER_YELL, textId,language,TargetGuid);
1533 MaNGOS::LocalizedPacketDo<MaNGOS::MonsterChatBuilder> say_do(say_build);
1534
1535 uint32 zoneid = GetZoneId();
1536
1537 Map::PlayerList const& pList = GetMap()->GetPlayers();
1538 for(Map::PlayerList::const_iterator itr = pList.begin(); itr != pList.end(); ++itr)
1539 if(itr->getSource()->GetZoneId()==zoneid)
1540 say_do(itr->getSource());
1541 }
1542
1543 void WorldObject::MonsterTextEmote(int32 textId, uint64 TargetGuid, bool IsBossEmote)
1544 {
1545 CellPair p = MaNGOS::ComputeCellPair(GetPositionX(), GetPositionY());
1546
1547 Cell cell(p);
1548 cell.data.Part.reserved = ALL_DISTRICT;
1549 cell.SetNoCreate();
1550
1551 float range = sWorld.getConfig(IsBossEmote ? CONFIG_FLOAT_LISTEN_RANGE_YELL : CONFIG_FLOAT_LISTEN_RANGE_TEXTEMOTE);
1552
1553 MaNGOS::MonsterChatBuilder say_build(*this, IsBossEmote ? CHAT_MSG_RAID_BOSS_EMOTE : CHAT_MSG_MONSTER_EMOTE, textId,LANG_UNIVERSAL,TargetGuid);
1554 MaNGOS::LocalizedPacketDo<MaNGOS::MonsterChatBuilder> say_do(say_build);
1555 MaNGOS::PlayerDistWorker<MaNGOS::LocalizedPacketDo<MaNGOS::MonsterChatBuilder> > say_worker(this,range,say_do);
1556 TypeContainerVisitor<MaNGOS::PlayerDistWorker<MaNGOS::LocalizedPacketDo<MaNGOS::MonsterChatBuilder> >, WorldTypeMapContainer > message(say_worker);
1557 cell.Visit(p, message, *GetMap(), *this, range);
1558 }
1559
1560 void WorldObject::MonsterWhisper(int32 textId, uint64 receiver, bool IsBossWhisper)
1561 {
1562 Player *player = sObjectMgr.GetPlayer(receiver);
1563 if(!player || !player->GetSession())
1564 return;
1565
1566 uint32 loc_idx = player->GetSession()->GetSessionDbLocaleIndex();
1567 char const* text = sObjectMgr.GetMangosString(textId,loc_idx);
1568
1569 WorldPacket data(SMSG_MESSAGECHAT, 200);
1570 BuildMonsterChat(&data,IsBossWhisper ? CHAT_MSG_RAID_BOSS_WHISPER : CHAT_MSG_MONSTER_WHISPER,text,LANG_UNIVERSAL,GetNameForLocaleIdx(loc_idx),receiver);
1571
1572 player->GetSession()->SendPacket(&data);
1573 }
1574
1575 void WorldObject::BuildMonsterChat(WorldPacket *data, uint8 msgtype, char const* text, uint32 language, char const* name, uint64 targetGuid) const
1576 {
1577 *data << (uint8)msgtype;
1578 *data << (uint32)language;
1579 *data << (uint64)GetGUID();
1580 *data << (uint32)0; // 2.1.0
1581 *data << (uint32)(strlen(name)+1);
1582 *data << name;
1583 *data << (uint64)targetGuid; // Unit Target
1584 if( targetGuid && !IS_PLAYER_GUID(targetGuid) )
1585 {
1586 *data << (uint32)1; // target name length
1587 *data << (uint8)0; // target name
1588 }
1589 *data << (uint32)(strlen(text)+1);
1590 *data << text;
1591 *data << (uint8)0; // ChatTag
1592 }
1593
1594 void WorldObject::SendMessageToSet(WorldPacket *data, bool /*bToSelf*/)
1595 {
1596 //if object is in world, map for it already created!
1597 Map * _map = IsInWorld() ? GetMap() : sMapMgr.FindMap(GetMapId(), GetInstanceId());
1598 if(_map)
1599 _map->MessageBroadcast(this, data);
1600 }
1601
1602 void WorldObject::SendMessageToSetInRange(WorldPacket *data, float dist, bool /*bToSelf*/)
1603 {
1604 //if object is in world, map for it already created!
1605 Map * _map = IsInWorld() ? GetMap() : sMapMgr.FindMap(GetMapId(), GetInstanceId());
1606 if(_map)
1607 _map->MessageDistBroadcast(this, data, dist);
1608 }
1609
1610 void WorldObject::SendObjectDeSpawnAnim(uint64 guid)
1611 {
1612 WorldPacket data(SMSG_GAMEOBJECT_DESPAWN_ANIM, 8);
1613 data << uint64(guid);
1614 SendMessageToSet(&data, true);
1615 }
1616
1617 void WorldObject::SendGameObjectCustomAnim(uint64 guid)
1618 {
1619 WorldPacket data(SMSG_GAMEOBJECT_CUSTOM_ANIM, 8+4);
1620 data << uint64(guid);
1621 data << uint32(0); // not known what this is
1622 SendMessageToSet(&data, true);
1623 }
1624
1625 void WorldObject::SetMap(Map * map)
1626 {
1627 ASSERT(map);
1628 m_currMap = map;
1629 //lets save current map's Id/instanceId
1630 m_mapId = map->GetId();
1631 m_InstanceId = map->GetInstanceId();
1632 }
1633
1634 Map const* WorldObject::GetBaseMap() const
1635 {
1636 ASSERT(m_currMap);
1637 return m_currMap->GetParent();
1638 }
1639
1640 void WorldObject::AddObjectToRemoveList()
1641 {
1642 GetMap()->AddObjectToRemoveList(this);
1643 }
1644
1645 Creature* WorldObject::SummonCreature(uint32 id, float x, float y, float z, float ang,TempSummonType spwtype,uint32 despwtime)
1646 {
1647 TemporarySummon* pCreature = new TemporarySummon(GetGUID());
1648
1649 uint32 team = 0;
1650 if (GetTypeId()==TYPEID_PLAYER)
1651 team = ((Player*)this)->GetTeam();
1652
1653 if (!pCreature->Create(sObjectMgr.GenerateLowGuid(HIGHGUID_UNIT), GetMap(), GetPhaseMask(), id, team))
1654 {
1655 delete pCreature;
1656 return NULL;
1657 }
1658
1659 if (x == 0.0f && y == 0.0f && z == 0.0f)
1660 GetClosePoint(x, y, z, pCreature->GetObjectSize());
1661
1662 pCreature->Relocate(x, y, z, ang);
1663 pCreature->SetSummonPoint(x, y, z, ang);
1664
1665 if(!pCreature->IsPositionValid())
1666 {
1667 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());
1668 delete pCreature;
1669 return NULL;
1670 }
1671
1672 pCreature->Summon(spwtype, despwtime);
1673
1674 if(GetTypeId()==TYPEID_UNIT && ((Creature*)this)->AI())
1675 ((Creature*)this)->AI()->JustSummoned(pCreature);
1676
1677 // return the creature therewith the summoner has access to it
1678 return pCreature;
1679 }
1680
1681 namespace MaNGOS
1682 {
1683 class NearUsedPosDo
1684 {
1685 public:
1686 NearUsedPosDo(WorldObject const& obj, WorldObject const* searcher, float angle, ObjectPosSelector& selector)
1687 : i_object(obj), i_searcher(searcher), i_angle(angle), i_selector(selector) {}
1688
1689 void operator()(Corpse*) const {}
1690 void operator()(DynamicObject*) const {}
1691
1692 void operator()(Creature* c) const
1693 {
1694 // skip self or target
1695 if(c==i_searcher || c==&i_object)
1696 return;
1697
1698 float x,y,z;
1699
1700 if( !c->isAlive() || c->hasUnitState(UNIT_STAT_NOT_MOVE) ||
1701 !c->GetMotionMaster()->GetDestination(x,y,z) )
1702 {
1703 x = c->GetPositionX();
1704 y = c->GetPositionY();
1705 }
1706
1707 add(c,x,y);
1708 }
1709
1710 template<class T>
1711 void operator()(T* u) const
1712 {
1713 // skip self or target
1714 if(u==i_searcher || u==&i_object)
1715 return;
1716
1717 float x,y;
1718
1719 x = u->GetPositionX();
1720 y = u->GetPositionY();
1721
1722 add(u,x,y);
1723 }
1724
1725 // we must add used pos that can fill places around center
1726 void add(WorldObject* u, float x, float y) const
1727 {
1728 // u is too nearest/far away to i_object
1729 if(!i_object.IsInRange2d(x,y,i_selector.m_dist - i_selector.m_size,i_selector.m_dist + i_selector.m_size))
1730 return;
1731
1732 float angle = i_object.GetAngle(u)-i_angle;
1733
1734 // move angle to range -pi ... +pi
1735 while( angle > M_PI_F)
1736 angle -= 2.0f * M_PI_F;
1737 while(angle < -M_PI_F)
1738 angle += 2.0f * M_PI_F;
1739
1740 // dist include size of u
1741 float dist2d = i_object.GetDistance2d(x,y);
1742 i_selector.AddUsedPos(u->GetObjectSize(),angle,dist2d + i_object.GetObjectSize());
1743 }
1744 private:
1745 WorldObject const& i_object;
1746 WorldObject const* i_searcher;
1747 float i_angle;
1748 ObjectPosSelector& i_selector;
1749 };
1750 } // namespace MaNGOS
1751
1752 //===================================================================================================
1753
1754 void WorldObject::GetNearPoint2D(float &x, float &y, float distance2d, float absAngle ) const
1755 {
1756 x = GetPositionX() + (GetObjectSize() + distance2d) * cos(absAngle);
1757 y = GetPositionY() + (GetObjectSize() + distance2d) * sin(absAngle);
1758
1759 MaNGOS::NormalizeMapCoord(x);
1760 MaNGOS::NormalizeMapCoord(y);
1761 }
1762
1763 void WorldObject::GetNearPoint(WorldObject const* searcher, float &x, float &y, float &z, float searcher_size, float distance2d, float absAngle ) const
1764 {
1765 GetNearPoint2D(x,y,distance2d+searcher_size,absAngle);
1766 z = GetPositionZ();
1767
1768 // if detection disabled, return first point
1769 if(!sWorld.getConfig(CONFIG_BOOL_DETECT_POS_COLLISION))
1770 {
1771 UpdateGroundPositionZ(x,y,z); // update to LOS height if available
1772 return;
1773 }
1774
1775 // or remember first point
1776 float first_x = x;
1777 float first_y = y;
1778 bool first_los_conflict = false; // first point LOS problems
1779
1780 // prepare selector for work
1781 ObjectPosSelector selector(GetPositionX(),GetPositionY(),GetObjectSize(),distance2d+searcher_size);
1782
1783 // adding used positions around object
1784 {
1785 CellPair p(MaNGOS::ComputeCellPair(GetPositionX(), GetPositionY()));
1786 Cell cell(p);
1787 cell.data.Part.reserved = ALL_DISTRICT;
1788 cell.SetNoCreate();
1789
1790 MaNGOS::NearUsedPosDo u_do(*this,searcher,absAngle,selector);
1791 MaNGOS::WorldObjectWorker<MaNGOS::NearUsedPosDo> worker(this,u_do);
1792
1793 TypeContainerVisitor<MaNGOS::WorldObjectWorker<MaNGOS::NearUsedPosDo>, GridTypeMapContainer > grid_obj_worker(worker);
1794 TypeContainerVisitor<MaNGOS::WorldObjectWorker<MaNGOS::NearUsedPosDo>, WorldTypeMapContainer > world_obj_worker(worker);
1795
1796 cell.Visit(p, grid_obj_worker, *GetMap(), *this, distance2d);
1797 cell.Visit(p, world_obj_worker, *GetMap(), *this, distance2d);
1798 }
1799
1800 // maybe can just place in primary position
1801 if( selector.CheckOriginal() )
1802 {
1803 UpdateGroundPositionZ(x,y,z); // update to LOS height if available
1804
1805 if(IsWithinLOS(x,y,z))
1806 return;
1807
1808 first_los_conflict = true; // first point have LOS problems
1809 }
1810
1811 float angle; // candidate of angle for free pos
1812
1813 // special case when one from list empty and then empty side preferred
1814 if(selector.FirstAngle(angle))
1815 {
1816 GetNearPoint2D(x,y,distance2d,absAngle+angle);
1817 z = GetPositionZ();
1818 UpdateGroundPositionZ(x,y,z); // update to LOS height if available
1819
1820 if(IsWithinLOS(x,y,z))
1821 return;
1822 }
1823
1824 // set first used pos in lists
1825 selector.InitializeAngle();
1826
1827 // select in positions after current nodes (selection one by one)
1828 while(selector.NextAngle(angle)) // angle for free pos
1829 {
1830 GetNearPoint2D(x,y,distance2d,absAngle+angle);
1831 z = GetPositionZ();
1832 UpdateGroundPositionZ(x,y,z); // update to LOS height if available
1833
1834 if(IsWithinLOS(x,y,z))
1835 return;
1836 }
1837
1838 // BAD NEWS: not free pos (or used or have LOS problems)
1839 // Attempt find _used_ pos without LOS problem
1840
1841 if(!first_los_conflict)
1842 {
1843 x = first_x;
1844 y = first_y;
1845
1846 UpdateGroundPositionZ(x,y,z); // update to LOS height if available
1847 return;
1848 }
1849
1850 // special case when one from list empty and then empty side preferred
1851 if( selector.IsNonBalanced() )
1852 {
1853 if(!selector.FirstAngle(angle)) // _used_ pos
1854 {
1855 GetNearPoint2D(x,y,distance2d,absAngle+angle);
1856 z = GetPositionZ();
1857 UpdateGroundPositionZ(x,y,z); // update to LOS height if available
1858
1859 if(IsWithinLOS(x,y,z))
1860 return;
1861 }
1862 }
1863
1864 // set first used pos in lists
1865 selector.InitializeAngle();
1866
1867 // select in positions after current nodes (selection one by one)
1868 while(selector.NextUsedAngle(angle)) // angle for used pos but maybe without LOS problem
1869 {
1870 GetNearPoint2D(x,y,distance2d,absAngle+angle);
1871 z = GetPositionZ();
1872 UpdateGroundPositionZ(x,y,z); // update to LOS height if available
1873
1874 if(IsWithinLOS(x,y,z))
1875 return;
1876 }
1877
1878 // BAD BAD NEWS: all found pos (free and used) have LOS problem :(
1879 x = first_x;
1880 y = first_y;
1881
1882 UpdateGroundPositionZ(x,y,z); // update to LOS height if available
1883 }
1884
1885 void WorldObject::SetPhaseMask(uint32 newPhaseMask, bool update)
1886 {
1887 m_phaseMask = newPhaseMask;
1888
1889 if(update && IsInWorld())
1890 UpdateObjectVisibility();
1891 }
1892
1893 void WorldObject::PlayDistanceSound( uint32 sound_id, Player* target /*= NULL*/ )
1894 {
1895 WorldPacket data(SMSG_PLAY_OBJECT_SOUND,4+8);
1896 data << uint32(sound_id);
1897 data << uint64(GetGUID());
1898 if (target)
1899 target->SendDirectMessage( &data );
1900 else
1901 SendMessageToSet( &data, true );
1902 }
1903
1904 void WorldObject::PlayDirectSound( uint32 sound_id, Player* target /*= NULL*/ )
1905 {
1906 WorldPacket data(SMSG_PLAY_SOUND, 4);
1907 data << uint32(sound_id);
1908 if (target)
1909 target->SendDirectMessage( &data );
1910 else
1911 SendMessageToSet( &data, true );
1912 }
1913
1914 void WorldObject::UpdateObjectVisibility()
1915 {
1916 CellPair p = MaNGOS::ComputeCellPair(GetPositionX(), GetPositionY());
1917 Cell cell(p);
1918
1919 GetMap()->UpdateObjectVisibility(this, cell, p);
1920 }
1921
1922 void WorldObject::AddToClientUpdateList()
1923 {
1924 GetMap()->AddUpdateObject(this);
1925 }
1926
1927 void WorldObject::RemoveFromClientUpdateList()
1928 {
1929 GetMap()->RemoveUpdateObject(this);
1930 }
1931
1932 struct WorldObjectChangeAccumulator
1933 {
1934 UpdateDataMapType &i_updateDatas;
1935 WorldObject &i_object;
1936 WorldObjectChangeAccumulator(WorldObject &obj, UpdateDataMapType &d) : i_updateDatas(d), i_object(obj) {}
1937 void Visit(PlayerMapType &m)
1938 {
1939 for(PlayerMapType::iterator iter = m.begin(); iter != m.end(); ++iter)
1940 if(iter->getSource()->HaveAtClient(&i_object))
1941 i_object.BuildUpdateDataForPlayer(iter->getSource(), i_updateDatas);
1942 }
1943
1944 template<class SKIP> void Visit(GridRefManager<SKIP> &) {}
1945 };
1946
1947 void WorldObject::BuildUpdateData( UpdateDataMapType & update_players)
1948 {
1949 CellPair p = MaNGOS::ComputeCellPair(GetPositionX(), GetPositionY());
1950 Cell cell(p);
1951 cell.data.Part.reserved = ALL_DISTRICT;
1952 cell.SetNoCreate();
1953 WorldObjectChangeAccumulator notifier(*this, update_players);
1954 TypeContainerVisitor<WorldObjectChangeAccumulator, WorldTypeMapContainer > player_notifier(notifier);
1955 Map* aMap = GetMap();
1956 //we must build packets for all visible players
1957 cell.Visit(p, player_notifier, *aMap, *this, aMap->GetVisibilityDistance());
1958
1959 ClearUpdateMask(false);
1960 }
1961
1962 bool WorldObject::IsControlledByPlayer() const
1963 {
1964 switch (GetTypeId())
1965 {
1966 case TYPEID_GAMEOBJECT:
1967 return IS_PLAYER_GUID(((GameObject*)this)->GetOwnerGUID());
1968 case TYPEID_UNIT:
1969 case TYPEID_PLAYER:
1970 return ((Unit*)this)->IsCharmerOrOwnerPlayerOrPlayerItself();
1971 case TYPEID_DYNAMICOBJECT:
1972 return IS_PLAYER_GUID(((DynamicObject*)this)->GetCasterGUID());
1973 case TYPEID_CORPSE:
1974 return true;
1975 default:
1976 return false;
1977 }
1978 }
MaNGOS is a free, Open Source implementation of a game server compatible with the original World of Warcraft client.