Exemple #1
0
        private void ReadObjectCreateUpdate(StreamHandler Reader)
        {
            var guid = Reader.ReadPackedGuid();
            var type = (ObjectTypeId)Reader.ReadByte();

            WowObject obj;

            switch (type)
            {
            case ObjectTypeId.Container:
                obj = new WowContainer();
                break;

            case ObjectTypeId.Corpse:
                obj = new WowCorpse();
                break;

            case ObjectTypeId.DynamicObject:
                obj = new WowDynamicObject();
                break;

            case ObjectTypeId.GameObject:
                obj = new WowGameObject();
                break;

            case ObjectTypeId.Item:
                obj = new WowItem();
                break;

            case ObjectTypeId.Object:
            default:
                throw new Exception("Cannot instantiate an object with TypeId=" + type);

            case ObjectTypeId.Player:
                obj = new WowPlayer();
                break;

            case ObjectTypeId.Unit:
                obj = new WowUnit();
                break;

            case ObjectTypeId.AreaTrigger:
                obj = new WowAreaTrigger();
                break;
            }

            obj.Guid         = guid;
            obj.MovementData = new MovementInfo(Reader);
            obj.SetValues(ReadValues(Reader));
            obj.ResetUpdatedFields();

            if (!m_createdObjects.ContainsKey(guid))
            {
                m_createdObjects.Add(guid, obj);
            }
            else
            {
                Console.WriteLine("Error: Created object duplicate guid {0}", guid);
            }
        }
Exemple #2
0
        private static void Pulse()
        {
            var objectManager  = _reader.ReadUInt((uint)Offsets.WowObjectManager.BASE);
            var currentObject  = _reader.ReadUInt(objectManager + (uint)Offsets.WowObjectManager.FIRST_OBJECT);
            var activeGuidList = new List <ulong>();

            while (currentObject != 0 && (currentObject & 1) == 0)
            {
                var objectType = _reader.ReadByte(currentObject + (uint)Offsets.WowObject.OBJECT_FIELD_TYPE);
                switch (objectType)
                {
                case (byte)ObjectType.Unit:
                {
                    var unit = new WowUnit(_reader, currentObject);
                    _objects.GetOrAdd(unit.Guid, unit);
                    activeGuidList.Add(unit.Guid);
                    break;
                }

                case (byte)ObjectType.Player:
                {
                    var player = new WowPlayer(_process, _reader, currentObject);
                    _objects.GetOrAdd(player.Guid, player);
                    activeGuidList.Add(player.Guid);
                    break;
                }

                case (byte)ObjectType.Item:
                {
                    break;
                }

                case (byte)ObjectType.GameObject:
                {
                    var obj = new WowGameObject(_reader, currentObject);
                    _objects.GetOrAdd(obj.Guid, obj);
                    activeGuidList.Add(obj.Guid);
                    break;
                }
                }

                var nextObject = _reader.ReadUInt(currentObject + (uint)Offsets.WowObjectManager.NEXT_OBJECT);

                if (nextObject == currentObject)
                {
                    break;
                }

                currentObject = nextObject;
            }

            var deadGuids = _objects.Keys.Where(k => !activeGuidList.Contains(k)).Select(k => k);

            foreach (var guid in deadGuids)
            {
                IWowObject deadObject;
                _objects.TryRemove(guid, out deadObject);
            }
        }
Exemple #3
0
 public WowGOBlip(WowGameObject wowGameObject) : base(wowGameObject)
 {
     BlipObject = wowGameObject;
 }
Exemple #4
0
        private static void ReadObjectList()
        {
            var localPlayerGuid =
                Memory.ReadAtOffset <ulong>(CurrentManager, (uint)Offsets.ObjectManager.LocalGUID);
            var current =
                Memory.ReadAtOffset <IntPtr>(CurrentManager, (uint)Offsets.ObjectManager.FirstObject);

            if (current == IntPtr.Zero || ((uint)current & 1) == 1)
            {
                Reset(WowProcess);
                return;
            }

            while (current != IntPtr.Zero && ((uint)current & 1) != 1)
            {
                var guid = WowObject.GetStorageField <ulong>(current,
                                                             (uint)Descriptors.WowObjectFields.OBJECT_FIELD_GUID);

                if (!ObjectDictionary.ContainsKey(guid))
                {
                    var oType =
                        (Offsets.ObjectType)Memory.ReadAtOffset <uint>(current, (uint)Offsets.ObjectManager.ObjectType);

                    WowObject wowObject = null;

                    switch (oType)
                    {
                    case Offsets.ObjectType.GameObject:
                        wowObject = new WowGameObject(current);
                        break;

                    case Offsets.ObjectType.Object:
                        wowObject = new WowObject(current);
                        break;

                    case Offsets.ObjectType.Player:
                        wowObject = new WowPlayer(current);
                        break;

                    case Offsets.ObjectType.Unit:
                        wowObject = new WowUnit(current);
                        break;

                    default:
                        break;
                    }

                    if (wowObject != null)
                    {
                        ObjectDictionary.Add(guid, wowObject);
                    }
                }
                else
                {
                    ObjectDictionary[guid].BaseAddress = current;
                }

                //  Keep the local player's GUID up-to-date
                if (localPlayerGuid == guid)
                {
                    Me.BaseAddress = current;
                }

                current = Memory.ReadAtOffset <IntPtr>(current, (uint)Offsets.ObjectManager.NextObject);
            }
        }