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