EnumVisibleObjects problem

[!@^^@!]

this is probably not the best way but delay the creation of your wpf window till endscene have been called once and copy that inptr? that's at least what im gonna try for now :P

[skra]

this is probably not the best way but delay the creation of your wpf window till endscene have been called once and copy that inptr? that's at least what im gonna try for now :P

umm what intptr are you refering to?

[YetiHunter]

try this:

            if (!guiCreated)
            {
                hash = Thread.CurrentThread.GetHashCode();
                init_guiThread();
                guiCreated = true;
            }
            if(hash == Thread.CurrentThread.GetHashCode())
                globalPulse();

thats the code i run in endscene. and globalPulse gets called every frame

[skra]

thanks works nice but i still get no usefull stuff for activeplayer or the enumobjdelegate =/

and WOW resizing my wpf window doesn't crash wow anymore.. no idea y it did that in the first place Oo

[YetiHunter]

resizing doesn't crash wow anymore

ROFL

[skra]

alright, i triple checked my code and i can't find a logical reason why i don't get the objectlist or even the active player. I can do static readings for example the playername which shouldn't work if i'd be in the wpf endscene method, should it? So i'm in wow's mainthread, the addresses are correct and i can't find anything wrong about the delegates. has someone a hint for me?

[Apoc]

Reading/writing memory can be done from any thread, at any time.

Calling engine functions usually need to be done from the main thread to avoid silly issues and whatnot.

[skra]

hmm ok but the functions i'm calling don't crash wow anymore. doesn't that mean that i'm calling them in the right spot?

[TOM_RUS]

Post your code again. You probably did something wrong.

[skra]

thanks for looking over it again ^^ here it is:

using System;
using System.Collections.Generic;
using System.Linq;
using Thor.Helper;
using Thor.WoWObjects;
using System.Runtime.InteropServices;
using System.Diagnostics;

namespace Thor
{
    public static 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 = Thor_Main.m.RegisterDelegate<ClntObjMgrGetActivePlayerDelegate>((uint)Offsets.ClntObjMgrGetActivePlayer);
            EnumObjs = Thor_Main.m.RegisterDelegate<EnumVisibleObjectsDelegate>((uint)Offsets.EnumVisibleObjects);
            ClntObjMgrGetObjectPtrWoW = Thor_Main.m.RegisterDelegate<ClntObjMgrGetObjectPtrDelegate>((uint)Offsets.ClntObjMgrObjectPtr);
        }

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

        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 (Thor_Main._frameCounter % 10 == 0)
            { RemoveInvalidEntries(); }

        }
        private static void RemoveInvalidEntries()
        {
            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
    }
}

[TOM_RUS]

Code looks correct, except RemoveInvalidEntries(), which will throw exceptions. Replace it with:

        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);
        }

[skra]

well that doesn't change anything about the fact that there are no objects getting stored in that list i changed it so it'll work when there are objects in it, but all the functions, the activeplayer as well as the enum objects funktion, are returning nothing.

[MaiN]

Code looks correct, except RemoveInvalidEntries(), which will throw exceptions. Replace it with:

        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);
        }

Why would it throw exceptions?

[Robske]

Why would it throw exceptions?

Haven't looked at the original code but I assume it's because ForEach cannot iterate over a modified collection.

[MaiN]

Haven't looked at the original code but I assume it's because ForEach cannot iterate over a modified collection.

        private static void RemoveInvalidEntries()
        {
            IEnumerable<KeyValuePair<ulong, WoWObject>> r = from o in RealObjects where !o.Value.IsValid select o;
            foreach (var pair in r)
            {
                RealObjects.Remove(pair.Key);
            }
        }

The original code. It amazes me to see you write a post before you even use ctrl + F and search for "RemoveInvalidEntries" and check the code out - lazy ass. :P