EnumVisibleObjects problem

[MaiN]

The problem with the Linq in the first place was just because of delayed execution. That means it is actually yield returning inside the Linq expression, which causes it to generate the collection modified exception. The safest way to solve this problem is either by iterating it yourself or by calling IEnumerable.ToList on returned IEnumerable<WoWObject> from the Linq expression.
The fix you use, TOM_RUS, only works because of the 'ToArray' - you don't have to select 'o.Key'.

[TOM_RUS]

The fix you use, TOM_RUS, only works because of the 'ToArray' - you don't have to select 'o.Key'.

Fix was taken from original thread and works fine: http://www.mmowned.com/forums/wow-me...ml#post1767140

[MaiN]

Fix was taken from original thread and works fine: http://www.mmowned.com/forums/wow-me...ml#post1767140

I know, where have I said it didn't?

[amadmonk]

    public static class LinqExtensions
    {
        public static Dictionary<K, V> RemoveAll<K, V>(this Dictionary<K, V> dict, Predicate<V> predicate)
        {
            foreach (var kvp in dict.Where(_kvp => predicate(_kvp.Value)).ToArray())
                dict.Remove(kvp.Key);

            return dict;
        }
    }

There. Now Dictionary<K, V> has a RemoveAll<V>(Predicate<V>) function.

For extra credit, you can add a key value pair version that lets you select based upon the keys, too, although this is probably useless for ObjectManager.

For your use:

myObjects.RemoveAll(o => !o.IsValid)

Nothing magical there.

Edit: edited it to return the dictionary instead of void; that way you can keep chaining it in LINQ calls if you want.

[YetiHunter]

That means that EnumVisibleObjects also doesn't work properly. Try to dig it.

no it doesn't. I get a complete list of guids from the function. I can't check them of cause but i'm pretty sure it is right. but when i call getobjbyguid it always returns 0

[flo8464]

no it doesn't. I get a complete list of guids from the function. I can't check them of cause but i'm pretty sure it is right. but when i call getobjbyguid it always returns 0

Maybe you are calling the filtered Version with a invalid filter?

[YetiHunter]

i'm calling with -1. everything else crashes wow but i can't figure out y..

[YetiHunter]

i just can't get getObjectbyGuid function to work =/. is there an alternative? the only thing i could think of would be searching for the guid in memory and having a "negative" offset to the object pointer but i think that would be inefficient and i could iterate through the objectlist manually instead of using enumvisobj and it would be the same. does anyone have a suggestion ?

[!@^^@!]

isen't that exactly the point why we store them in a dictionary so we can use

 Objects[YourGUID]

?

[YetiHunter]

of cause but i'm using the enumVisibleObjects function which returns the guid, and since the guid to pointer function does not work i can't access the the object information by just adding the offsets, because i have no baseadress

[adaephon]

What is your function definition for GetObjectByGuid and what offset are you using? The following (approximate) code works fine for me:

Delegate:

        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
        private delegate IntPtr ClntObjMgrGetObjectPtrDelegate(ulong guid, int filter);

Offset:

getObjectPtrFunc = (ClntObjMgrGetObjectPtrDelegate)Marshal.GetDelegateForFunctionPointer(new IntPtr(0x0047BBC0), typeof(ClntObjMgrGetObjectPtrDelegate));

[YetiHunter]

i'm using apocs whitemagic with:
[CODE]
ClntObjMgrGetObjectPtrWoW = Main.m.RegisterDelegate<ClntObjMgrGetObjectPtrDelegate>((uint)Offsets.ClntObjMgr ObjectPtr);

[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
private delegate IntPtr ClntObjMgrGetObjectPtrDelegate(ulong guid, int filter);

ClntObjMgrObjectPtr = 0x0047BBC0
[\CODE]

[adaephon]

Well it's very difficult to diagnose your problem when you claim you're doing everything right and aren't providing any additional information. Post more code / information and we might have more of a chance of helping. Presumably you are calling it something like

IntPtr obj = ClntObjMgrGetObjectPtrWoW(guid, -1);

from within EnumVisibleObjects?

Have you ensured that EnumVisibleObjects works? Have you tried logging out just a list of GUIDs without calling GetObjectByGuid to ensure you are getting valid GUIDs? Have you tried using a try { ... } catch { ... } in the crashing situations to see if it is a non fatal exception that you can log out?

[YetiHunter]

sorry was in a hurry when i posted the first answer.

    public unsafe class ObjectManager
    {
        #region private stuff
        private static readonly EnumObjectsCallbackDelegate Callback;
        private static readonly IntPtr CallbackPtr;
        private static readonly ClntObjMgrGetObjectPtrDelegate ClntObjMgrGetObjectPtrWoW;
        private static readonly EnumVisibleObjectsDelegate EnumObjs;
        private static readonly ClntObjMgrGetActivePlayerDelegate GetActivePlayerDelegate;
        private static readonly Dictionary<ulong, WoWObject> RealObjects = new Dictionary<ulong, WoWObject>();
        #endregion

        internal static ActivePlayer Me { get; private set; }
        internal static List<WoWObject> ObjectList { get { return RealObjects.Values.Where(o => o.IsValid).ToList(); } }
        
        static ObjectManager()
        {
            Me = new ActivePlayer(IntPtr.Zero);
            Callback = EnumObjectsCallbackHandler;
            CallbackPtr = Marshal.GetFunctionPointerForDelegate(Callback);
            GetActivePlayerDelegate = Main.m.RegisterDelegate<ClntObjMgrGetActivePlayerDelegate>((uint)Offsets.ClntObjMgrGetActivePlayer);
            EnumObjs = Main.m.RegisterDelegate<EnumVisibleObjectsDelegate>((uint)Offsets.EnumVisibleObjects);
            ClntObjMgrGetObjectPtrWoW = Main.m.RegisterDelegate<ClntObjMgrGetObjectPtrDelegate>((uint)Offsets.ClntObjMgrObjectPtr);
        }

        internal static ulong ActivePlayer
        { get { return GetActivePlayerDelegate(); } }
        public static bool IsInWorld
        { get { return ActivePlayer != (ulong)IntPtr.Zero; } }

        public static void Pulse()
        {
            if (Me == IntPtr.Zero)
            {
                Me = ClntObjMgrGetActivePlayerWow();
                ObjectList.Add(Me);
            }

            foreach (WoWObject o in RealObjects.Values)
            { o.UpdateObjectPointer(IntPtr.Zero); }
           
            EnumObjs(CallbackPtr, 0);
         
            if (Main._frameCounter % 10 == 0)
                RemoveInvalidEntries();
        }
        private static void RemoveInvalidEntries()
        {
            var guids = (from o in RealObjects where !o.Value.IsValid select o.Key).ToArray();
            foreach (var guid in guids)
                RealObjects.Remove(guid);
            //IEnumerable<KeyValuePair<ulong, WoWObject>> r = from o in RealObjects where !o.Value.IsValid select o;
            //foreach (var pair in r)
            //{
            //    RealObjects.Remove(pair.Key);
            //}
        }

        private static int EnumObjectsCallbackHandler(ulong guid, int filter)
        {
            IntPtr objPtr = InternalGetObjectByGuid(guid);
            
            if (!RealObjects.ContainsKey(guid))
            {
                var tmp = new WoWObject(objPtr);

                switch (tmp.Type)
                {
                    case ObjectType.Item:
                        tmp = new Item(objPtr);
                        break;
                    case ObjectType.Container:
                        tmp = new Container(objPtr);
                        break;
                    case ObjectType.Unit:
                        tmp = new Unit(objPtr);
                        break;
                    case ObjectType.Player:
                        tmp = new Player(objPtr);
                        break;
                    case ObjectType.GameObject:
                        tmp = new GameObject(objPtr);
                        break;
                    case ObjectType.Corpse:
                        tmp = new Corpse(objPtr);
                        break;
                    default:
                        return 1;
                }

                RealObjects.Add(guid, tmp);
            }
            else if (RealObjects[guid] != objPtr)
            { RealObjects[guid].UpdateObjectPointer(objPtr); }
            return 1;
        }

        internal static WoWObject GetObjectByGuid(ulong guid)
        {
            WoWObject ret;
            RealObjects.TryGetValue(guid, out ret);

            return ret ?? new WoWObject(IntPtr.Zero);
        }

        internal static IntPtr InternalGetObjectByGuid(ulong guid)
        { return ClntObjMgrGetObjectPtrWoW(guid, -1); }

        internal static ActivePlayer ClntObjMgrGetActivePlayerWow()
        { return new ActivePlayer(GetObjectByGuid(GetActivePlayerDelegate())); }
       
        
        #region delegates
        #region Nested type: ClntObjMgrGetActivePlayerDelegate

        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
        private delegate ulong ClntObjMgrGetActivePlayerDelegate();

        #endregion

        #region Nested type: ClntObjMgrGetObjectPtrDelegate

        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
        private delegate IntPtr ClntObjMgrGetObjectPtrDelegate(ulong guid, int filter);

        #endregion

        #region Nested type: EnumObjectsCallback

        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
        private delegate int EnumObjectsCallbackDelegate(ulong guid, int filter);

        #endregion       

        #region Nested type: EnumVisibleObjectsDelegate
        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
        private delegate int EnumVisibleObjectsDelegate(IntPtr callback, int filter);
        #endregion
        #endregion
    }
}

this is my complete code for the objectmanager. i get a list of guids out of it and with try {} catch {} it doesn't crash anymore is i filter for anything else than -1

[Cromon]

Are you sure about that:

 [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
        private delegate IntPtr ClntObjMgrGetObjectPtrDelegate(ulong guid, int filter);

Im using:

typedef DWORD (__cdecl* tGetObjectByGUID)(UINT64);

and i get correct offsets to the objects in the EnumVisibleObjects-Callback.