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