Migrate to Crews over AthenaPlayerState

Author: DougTheDruid

Modules/crews.py

@@ -0,0 +1,118 @@
+"""
+@Author https://github.com/DougTheDruid
+@Source https://github.com/DougTheDruid/SoT-ESP-Framework
+"""
+
+from helpers import *
+import struct
+from Modules.display_object import DisplayObject
+from helpers import crew_tracker
+
+
+class Crews(DisplayObject):
+    """
+    Class to generate information about the crews current on our server
+    """
+
+    def __init__(self, memory_reader, actor_id, address):
+        """
+        be located at the screen coordinated + our text_offsets from helpers.py
+        The function of this class is to collect all of the data about the crews
+        currently on our server. `CrewService` is effectively just a list of
+        `Crew` structures in memory, which we will iterating over to collect the
+        requisite data.
+
+        Previously, you were able to collect player names from this data but we
+        cannot any longer. Instead we will simply use it to get a count of how
+        many players are on the server and on each crew.
+
+        :param memory_reader: The SoT MemoryHelper Object we use to read memory
+        :param actor_id: The actor ID of our CrewService. Used to validate if
+        there is an unexpected change
+        :param address: The address in which our CrewService lives
+        """
+        # Initialize our super-class
+        super().__init__(memory_reader)
+
+        self.rm = memory_reader
+        self.actor_id = actor_id
+        self.address = address
+
+        # Collect and store information about the crews on the server
+        self.crew_info = self._get_crews_info()
+
+        # Sum all of the crew sizes into our total_players variable
+        self.total_players = sum(crew['size'] for crew in self.crew_info)
+
+        # All of our actual display information & rendering
+        self.crew_str = self._built_text_string()
+
+        # Used to track if the display object needs to be removed
+        self.to_delete = False
+
+    def _built_text_string(self):
+        """
+        Generates a string used for rendering. Separate function in the event
+        you need to add more data or want to change formatting
+        """
+        output = ""
+        for x in range(len(self.crew_info)):
+            # We store all of the crews in a tracker dictionary. This allows us
+            # to assign each crew a "Short"-ID based on count on the server.
+            short_id = crew_tracker.get(self.crew_info[x]['guid'], None)
+            output += f" Crew #{short_id} - {self.crew_info[x]['size']} Pirates\n"
+
+        return output
+
+    def _get_crews_info(self):
+        # Find the starting address for our Crews TArray
+        crew_raw = self.rm.read_bytes(self.address + OFFSETS.get('CrewService.Crews'), 16)
+
+        # (Crews_Data<Array>, Crews length, Crews max)
+        crews = struct.unpack("<Qii", crew_raw)
+
+        # Will contain all of our condensed Crew Data
+        crews_data = []
+
+        # For each crew on the server
+        for x in range(0, crews[1]):
+            # Each crew has a unique ID composed of four ints, maybe be useful if you
+            # add functionality around Crews on your own
+            crew_guid_raw = self.rm.read_bytes(crews[0] + (OFFSETS.get('Crew.Size') * x), 16)
+            crew_guid = struct.unpack("<iiii", crew_guid_raw)
+
+            # Read the TArray of Players on the the specific Crew, used to determine
+            # Crew size
+            crew_raw = self.rm.read_bytes(
+                crews[0] + OFFSETS.get('Crew.Players') + (OFFSETS.get('Crew.Size') * x), 16
+            )
+
+            # Players<Array>, current length, max length
+            crew = struct.unpack("<Qii", crew_raw)
+
+            # If our crew has more than 0 people on it, we care about it, so we add it to our tracker
+            if crew[1] > 0:
+                crew_data = {
+                    "guid": crew_guid,
+                    "size": crew[1]
+                }
+                crews_data.append(crew_data)
+                if crew_guid not in crew_tracker:
+                    crew_tracker[crew_guid] = len(crew_tracker)+1
+        return crews_data
+
+    def update(self, my_coords):
+        """
+        A generic method to update all the interesting data about the
+        crews on our server. To be called when seeking to perform an update on
+        the CrewService actor without reinitializing our class.
+
+        1. Determine if our actor is what we expect it to be
+        2. Pull the latest crew information
+        3. Update our strings accordingly
+        """
+        if self._get_actor_id(self.address) != self.actor_id:
+            self.to_delete = True
+            return
+        self.crew_info = self._get_crews_info()
+        self.crew_str = self._built_text_string()

README.md

@@ -56,7 +56,7 @@ of guidance as to where to look to find those bugs.
 This hack has the following implemented:
 - Get the location of ships in render distance and display them on screen
 - Display a count of the players on the server
-- Display a list of all players on the server, and update the list correctly
+- Display a list of all the crews on the server, how many players are on that crew, and update this list regularly
 
 ## Your First Additions
 Once you have accomplished getting the framework working as intended, you may find yourself asking, what do I do next?

helpers.py

@@ -13,10 +13,13 @@
 
 # True=Enabled & False=Disabled for each of the config items
 CONFIG = {
-    "WORLD_PLAYERS_ENABLED": True,
+    "CREWS_ENABLED": True,
     "SHIPS_ENABLED": False
 }
 
+#
+crew_tracker = {}
+
 version = "1.2.0"
 
 # Config specification for logging file

main.py

@@ -92,9 +92,9 @@ def on_draw():
         """
         window.clear()
 
-        # Update our player count Label & player list
-        player_count.text = f"Player Count: {len(smr.server_players)}"
-        # player_list.text = "\n".join(smr.server_players)
+        # Update our player count Label & crew list
+        player_count.text = f"Player Count: {smr.crew_data.total_players}"
+        # crew_list.text = smr.crew_data.crew_str
 
         # Draw our main batch & FPS counter at the bottom left
         main_batch.draw()
@@ -122,10 +122,11 @@ def on_draw():
                          y=SOT_WINDOW_H * 0.9, batch=main_batch)
 
     # The label for showing all players on the server under the count
+    # This purely INITIALIZES it does not inherently update automatically
     if False:  # pylint: disable=using-constant-test
-        player_list = Label("\n".join(smr.server_players), x=SOT_WINDOW_W * 0.85,
-                            y=(SOT_WINDOW_H-25) * 0.9, batch=main_batch, width=300,
-                            multiline=True)
+        crew_list = Label(f"{smr.crew_data.crew_str}", x=SOT_WINDOW_W * 0.85,
+                          y=(SOT_WINDOW_H-25) * 0.9, batch=main_batch, width=300,
+                          multiline=True)
         # Note: The width of 300 is the max pixel width of a single line
         # before auto-wrapping the text to the next line. Updated in on_draw()
 

mapping.py

@@ -28,16 +28,16 @@
     },
 
     "BP_AISmallShipTemplate_C": {
-        "Name": "Ghost Sloop (Near)",
+        "Name": "Skeleton Sloop (Near)",
     },
     "BP_AISmallShipNetProxy_C": {
-        "Name": "Ghost Sloop",
+        "Name": "Skeleton Sloop",
     },
     "BP_AILargeShipTemplate_C": {
-        "Name": "Ghost Galleon (Near)",
+        "Name": "Skeleton Galleon (Near)",
     },
     "BP_AILargeShipNetProxy_C": {
-        "Name": "Ghost Galleon",
+        "Name": "Skeleton Galleon",
     },
     # "BP_AggressiveGhostShip_C": {
     #     "Name": "Flameheart Galleon",

offsets.json

@@ -1,12 +1,15 @@
 {
   "Actor.actorId": 24,
-  "Actor.rootComponent": 368,
+  "CrewService.Crews": 1184,
+  "Crew.Players": 32,
+  "Crew.Size": 152,
+  "Actor.rootComponent": 360,
   "CameraCacheEntry.MinimalViewInfo": 16,
   "GameInstance.LocalPlayers": 56,
   "LocalPlayer.PlayerController": 48,
   "PlayerCameraManager.CameraCache": 1088,
-  "PlayerController.CameraManager": 1120,
-  "PlayerState.PlayerName": 984,
+  "PlayerController.CameraManager": 1112,
+  "PlayerState.PlayerName": 976,
   "SceneComponent.ActorCoordinates": 300,
   "World.OwningGameInstance": 448,
   "World.PersistentLevel": 48

sot_hack.py

@@ -10,6 +10,7 @@
 from mapping import ship_keys
 from helpers import OFFSETS, CONFIG, logger
 from Modules.ship import Ship
+from Modules.crews import Crews
 
 
 class SoTMemoryReader:
@@ -69,6 +70,8 @@ def __init__(self):
         self.actor_name_map = {}
         self.server_players = []
         self.display_objects = []
+        self.crew_data = None
+
 
     def _load_local_player(self) -> int:
         """
@@ -190,13 +193,15 @@ def read_actors(self):
                 # else:
                 self.display_objects.append(ship)
 
-            # If we have the world players enabled in helpers.py, and the name
-            # of the actor is AthenaPlayerState, we interpret the actor as a
-            # player on the server.
+            # If we have the crews data enabled in helpers.py and the name
+            # of the actor is CrewService, we create a class based on that Crew
+            # data to generate information about people on the server
             # NOTE: This will NOT give us information on nearby players for the
             # sake of ESP
-            elif CONFIG.get('WORLD_PLAYERS_ENABLED') and "AthenaPlayerState" in raw_name:
-                self.read_world_players(actor_address)
+            elif CONFIG.get('CREWS_ENABLED') and raw_name == "CrewService":
+                self.crew_data = Crews(self.rm, actor_id, actor_address)
+            # elif CONFIG.get('WORLD_PLAYERS_ENABLED') and "AthenaPlayerState" in raw_name:
+            #     self.read_world_players(actor_address)
 
     def read_world_players(self, actor_address):
         """