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