Need some help/guidance regarding memory reading

Hello,
First of all thank you for the great memory reading tool. It’s great and it’s actually what i have been looking for for a long time.
I managed to use it and now i a small proof of concept bot that salvages wrecks and loots them while i’m writing this. (i’m writing things in go, sorry elm is just a no no for me otherwise i’d happily contribute to your project)

But back to main topic for now. Some objects as they are defined by eve ui have some associated icons. Unfortunately i could not find any way of obtaining any useful information regarding the icon itself. I can get the position of course but that does not help. Below it’s an example on why i would need this:

( this is a small tree i’m building for myself with only the python object type and the name )

Container /  /  /  / 
  Container / aRowx_0 /  /  / 
    TargetInBar / target /  /  / 
      Container / barAndImageCont /  /  / 
        Transform / iconPar /  /  / 
          Icon /  /  /  / 
          TargetHealthBars /  /  /  / 
            Container / armorBar /  /  / 
              Sprite / armorBar_Right /  /  / 
              Sprite / armorBar_Left /  /  / 
            Container / hullBar /  /  / 
              Sprite / hullBar_Right /  /  / 
              Sprite / hullBar_Left /  /  / 
            Sprite / healthBarBackground /  /  / 
          Sprite / circle /  /  / 
          ActiveTargetOnBracket /  /  /  / 
            Sprite / rotatingArrows /  /  / 
            Sprite / selectedTargetCircle /  /  / 
      ContainerAutoSize / labelContainer /  /  / 
        EveLabelSmall /  / <center>Coreli Scout /  / 
        EveLabelSmall /  / <center>Wreck [SWA] /  / 
        EveLabelSmall /  / <center>4,066 m /  / 
      Container / assignedPar /  /  / 
        Container / assigned /  /  / 
          Weapon /  /  /  / 
            Icon /  /  /  / 
            ModuleEffectTimer /  /  /  / 

As you can see this would correspond to a targeted object (in this case a wreck) that has an active module on it. In my case it was a salvager. However from inside the bot i’m not finding a way to tell that.
I could find no useful information in the weapon python object type. I was hoping i could extract some from the Icon child object. Which looks like this:

                                {
                                  "pythonObjectAddress": "2096415577648",
                                  "pythonObjectTypeName": "Icon",
                                  "dictEntriesOfInterest": {
                                    "_displayHeight": "32",
                                    "_displayX": "0",
                                    "_texture": {
                                      "address": "2095989219848",
                                      "pythonObjectTypeName": "trinity.Tr2Sprite2dTexture"
                                    },
                                    "_displayWidth": "32",
                                    "_color": {
                                      "aPercent": "100",
                                      "rPercent": "100",
                                      "gPercent": "100",
                                      "bPercent": "100"
                                    },
                                    "_sr": {
                                      "entriesOfInterest": {}
                                    },
                                    "_displayY": "0"
                                  },
                                  "otherDictEntriesKeys": null,
                                  "children": null
                                },

As you can also see i added the _texture field to the “Interesting Fields” array. However i’m still not getting any useful information.

I went as far as adding trinity.Tr2Sprite2dTexture to the specializedReadingFromPythonType
in memory-read-64 bit but it did not help at all.

The python object is recognized but memoryReadingTools.getDictionaryEntriesWithStringKeys(address)
does not return anything useful.

So i’m blocked here and now. Yes i know i could do a little more (probably much more digging around) and try to actually decode the python object myself. But since that’s not the main direction i want to go right now i thought why not ask ? Maybe you could give me a hand, and maybe you could even improve the memory reading program adding some interesting info in output :wink:

I could provide a memory dump of the object if you could let me know what length i should dump or how to find out. (still wary of sending a full emory dump of my eve client tho …)

Below is the code i tried to add in order to decode trinity.Tr2Sprite2dTexture …
I used the ‘Bunch’ type as template and had some small debug printouts added.

It could just be the texture itself and not a python object ? But if so how would i get the length ?

            .Add("trinity.Tr2Sprite2dTexture", new Func<ulong, LocalMemoryReadingTools, object>((address, memoryReadingTools) =>
            {
                var dictionaryEntries = memoryReadingTools.getDictionaryEntriesWithStringKeys(address);
                var pic = memoryReadingTools.memoryReader.ReadBytes(address, 0x100);
                foreach (var b in pic)
                {
                    Console.Write("{0} ", b.ToString());
                }
                Console.WriteLine("=========================");
                if (dictionaryEntries == null)
                    return "Failed to read dictionary entries.";
            
                var entriesOfInterest = new List<UITreeNode.DictEntry>();
                foreach (var entry in dictionaryEntries)
                {
                    // if (!DictEntriesOfInterestKeys.Contains(entry.Key))
                    // {
                    //     continue;
                    // }
                    Console.WriteLine("KEY: {0} '.", entry.Key);
                    Console.WriteLine("VAL: {0} '.", memoryReadingTools.GetDictEntryValueRepresentation(entry.Value));
                    entriesOfInterest.Add(new UITreeNode.DictEntry
                    {
                        key = entry.Key,
                        value = memoryReadingTools.GetDictEntryValueRepresentation(entry.Value),
                    });
                }
            
                var entriesOfInterestJObject =
                    new Newtonsoft.Json.Linq.JObject(
                        entriesOfInterest.Select(dictEntry =>
                            new Newtonsoft.Json.Linq.JProperty(dictEntry.key, Newtonsoft.Json.Linq.JToken.FromObject(dictEntry.value))));
            
                return new UITreeNode.Bunch
                {
                    entriesOfInterest = entriesOfInterestJObject,
                };
            }))

The key/val output looks like this:

KEY: String too long. '.
VAL: read_memory_64_bit.UITreeNode+DictEntryValueGenericRepresentation '.

Good point that reminds me of a common approach to finding entries of interest: Look at the list of all keys in the dictionary.
What are all key in the dictionary for 2096415577648?

As far as I remember, the CLI is configured to fill the otherDictEntriesKeys by default. So you can get the list without making any changes to the program.

Another place to look for useful data is the _sr entry.

Sure, when you want to go the memory reading route, the next step is to get a process sample of your scenario: https://to.botengine.org/guide/collect-samples-for-memory-reading-development
When I have a sample of your scenario I can take a look.

To distinguish the icons in the assigned container in general, you can also use image-processing. The classification is relatively simple because you already have the icon’s display region from the memory reading.