redid comments & misc pylget updates

Author: DougTheDruid

FAQ.md

@@ -6,14 +6,25 @@ to get there also mentioned in the readme.md (Prerequisites section)
 
 Check the following:
 1. By default, it works for the Microsoft version of the game, there is a variable to toggle if you are using Steam. 
-   Does this apply to you?
+   Does this apply to you? Did you change the toggle?
 2. Validate you have a pyglet window that is opening and there are no errors in the python window
-3. Have you made sure all of your window sizes have been updated according to the readme?
-4. Have you corrected the tests of faith mentioned in the readme.md (Prerequisites section)?
-5. Are you running in windowed mode?
+3. Have you corrected the tests of faith mentioned in the readme.md (Prerequisites section)?
+4. Are you running in windowed mode?
+
+### Rendered items in the hack (text/circles) are fuzzy and larger than they should be
+If you have windows scaling on (for a large/high DPI monitor), you may need to make a small change to python to avoid
+your pyglet window also scaling:
+1. Navigate to your python folder (Mine is `C:\Python37` for example)
+2. Right-click your `python.exe` application and select "Properties"
+3. Select the "Compatibility" tab at the top
+4. Select "Change high DPI Setting"
+5. Check the box labelled "Override high DPI scaling behavior. Scaling performed by:"
+6. Select "Application" in the dropdown 
+7. Select "OK"
+8. Select "Apply" and then "OK" 
 
 ### What do I do first?
-First, you should get the hack to a state where all of the features mentioned in the readme are working as expected.
+First, you should get the hack to a state where all the features mentioned in the readme are working as expected.
 Once you are familiar with the hack and how the code operates, I would take a look through the below list, pick one small
 component to implement, and give it your best shot. Ask for help on Discord
 

README.md

@@ -1,12 +1,13 @@
 # Doug's Python SoT ESP Framework
-Hello all! This is a framework to develop an SoT ESP Hack, all utilizing Python 3.7.9. This is a trimmed down version 
+Hello all! This is a framework to develop an SoT ESP Hack, all utilizing Python. This is a trimmed down version 
 of a personal creation I utilize actively. This is a great foundation for someone who is looking to get started in 
-ESP hacks for Sea of Thieves, and should be loaded with comments to help you grasp the "how" and "why" of basic 
+ESP hacks for Sea of Thieves and maybe even other UE4 games! The code should be loaded with comments to help you grasp the "how" and "why" of basic 
 memory editing and data display with Python. While this is intended for use within Sea of Thieves specifically, there is a lot
-of resources utilized which could be useful in memory reading/editing for almost any game/program :D
+of resources utilized which could be useful in memory reading/editing for almost any game/program.
 
-This hack has the following implemented: 
+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
 
 This is intentionally left as a framework and not a full-featured hack for a few reasons:
@@ -15,7 +16,7 @@ This is intentionally left as a framework and not a full-featured hack for a few
 3. Much of the code is very well documented to help you understand the "how" of the hacks inner workings; as a 
    result many resources on hacking forums will give you guidelines for implementing new functionality; I did it myself, 
    you can to
-4. I have undergone 3 or 4 major interations of this same code. **I am still learning** and re-writing functionality all 
+4. I have undergone 5 or 6 major interations of this same code. **I am still learning** and re-writing functionality all 
    the time; a smaller code base is much more simple to maintain
 
 I do ask that if you decided to take this into your own personal development, encourage others to think for themselves a
@@ -29,22 +30,22 @@ Microsoft version. If you are using the Steam version, you will need to change t
 of SoTHack.py
 
 ### Why Python?!
-Python is at its root a more user-friendly (IMO) version of C. Hypothetically, we can perform any C action using python,
+Python is at its more user-friendly version of C. Hypothetically, we can perform any C action using python,
 but make it more readible and beginner-friendly. I am also much more comfortable developing in Python and saw this as
 an opportunity to challenge myself.
 
 ### Prerequisites
-In theory, all you need to get started in using this hack is Python 3.7.9, and to install the requirement found in the 
-requirements.txt. The base framework relies on a 4k main monitor. You MAY need to make some minor changes in
-the code to accomidate your display configuration (helpers.py, top of file). I personally run all of my Python from PyCharm, and 
-start/stop the code execution through the built-in Run and Stop functionality. You may choose to implement proper 
-"closing" functionality using pyglet. 
+In theory, all you need to get started in using this hack is Python 3.7.9 (have also verified in 3.9.6), and to install 
+the requirement found in the requirements.txt. The base framework should automatically create an overlay over your SoT window, 
+regardless of size. You MAY need to make some minor changes in the code to accomidate your display configuration 
+(helpers.py, top of file). I personally run all of my Python from PyCharm, and start/stop the code execution 
+through the built-in Run and Stop functionality. You may choose to implement proper "closing" functionality using pyglet. 
 
 ***As a test of faith, to get this code fully-functional you must modify one line of code and remove another entirely.
 This is a VERY small countermeasure to ensure this framework is actually used as intended.***
 
 ### How to execute
-At the time of writting, the script is built for a version of SoT with ~5 weeks left in Season 2 and given you have the
+At the time of writting, the script is built for a version of SoT with ~6 weeks left in Season 3 and given you have the
 necessary pre-requisites, should execute with no major issues. Simply run `main.py` once you are in a server.
 
 ### How to update for new SoT Versions
@@ -71,12 +72,12 @@ your issues.
 ### cAn i GeT bAnNeD?!
 TL;DR: Yes. You _can_ get banned, such is the risk of cheating.
 
-Longer version: As is, this code purely utilizes a read-only state for the computers memory. With hundreds of hours utilizing these same read-only permissions, I have never been
+Longer version: As is, this code purely utilizes a read-only state for the computer's memory. With hundreds of hours utilizing these same read-only permissions, I have never been
 banned, nor concerned for being banned. Does that guarentee you won't be? No. Does that guarentee you won't change something (like trying to write memory) that will cause you to 
-get banned? No. If you arent sure what something does, or why something is done a certain way, do some research on the potential impact of changing it before actually changing it. 
+get banned? No. If you aren't sure what something does, or why something is done a certain way, do some research on the potential impact of changing it before actually changing it. 
 
 ### Can you help me implement X feature?
-No. I learned utilizing already posted questions/comments easily found online, you can as well. This framework is meant for people who want to put in the work and learn something, 
+No. I learned to utilize already posted questions/comments easily found online, you can as well. This framework is meant for people who want to put in the work and learn something, 
 not recieve a hand-out. You also may be able to see the FAQ.md for some useful information.
 For community support, please contact me on Discord: DougTheDruid#2784
 
@@ -88,22 +89,19 @@ update methods every so often (or every frame).
 
 The `SoTMemoryReader` object gets data about the game world, but has a main game loop function called `read_actors`.
 This method is responsible for determining how many actors there are, and reading data about all of those actors. For 
-Actors we are interested in knowing more about, we create a relevant class-object to track their information. We also
+actors we are interested in knowing more about, we create a relevant class-object to track their information. We also
 use that object to build display information for Pyglet to utilize. 
 
 Largely speaking, if you want to see the flow of the code, start at `main.py` and work your way down into the objects
 and other files.
 
-*This is an early build using Pyglet and probably isn't super optimized.*
+*This is an early build using Pyglet and I am still working to optimize some of the code*
 
 ### Pyglet Todo
-   1. In `ship.py`, for some reason I was unable to use `.visibile = False` for the text similarly to the circle visiblity.
-      So I ended up setting the text-size to 0. How do we make this better?
-   2. Currently we are replacing spaces in play names with `-`'s, this has to do with the multiline functionality
+   1. Currently we are replacing spaces in play names with `-`'s, this has to do with the multiline functionality
       specified for `player_list` creation in `main.py`. Can you make a specific doc format to get around this weirdness?
-   3. Gummy set the window attibutes to LWA_Alpha vs ColorKey, then set the DirectX alpha flags to do the transparency. 
+   2. Gummy set the window attibutes to LWA_Alpha vs ColorKey, then set the DirectX alpha flags to do the transparency. 
       Can something similar with with this & OpenGL (which pyglet uses)?
-   4. Add typehints & update docstrings for new stuff
 
 ### Structs
 Instead of rebuilding structures similarly to how you would in C or C++, I utilize something fairly frequently in my
@@ -127,7 +125,7 @@ Note: [See other `Structs` format information here](https://docs.python.org/3/li
 If you are interested in helping maintain this code base, first off, thank you! My only asks are as follows:
 1. Document your additions/changes in accordance with what exists
 2. Utilize Pylint and the provided pylintrc file to ensure your code is 10/10 compliant prior to submittion of a PR
-3. Keep the framework a framework, do not add new features outside of those listed in the "TODO" section
+3. Keep the framework a framework, do not add new features outside those listed in the "TODO" section
 4. Create "Issues" if something strikes you as incorrect or needing improvement. Also consider looking at issues for
 opportunities to contribute
 

display_object.py

@@ -11,40 +11,41 @@
 
 class DisplayObject(metaclass=abc.ABCMeta):
     """
-    Class responsible for the base functionality of pulling data from
-    our memory objects. These are typically identical regardless of the actor
-    type we are looking at
+    Parent class to objects like Ship's. Responsible for the base functionality
+    of pulling data from our memory objects. These are typically identical
+    regardless of the actor type we are looking at; as such would be
+    considered "common" and reduces redundant code.
     """
 
     def __init__(self, memory_reader: ReadMemory):
         """
-        Parent class to objects like Ship's. Helpful as the methods found here
-        would be considered "common" and reduces redundent code.
+        Some of our DisplayObject calls need to make memory reads, so we will
+        ser out memory reader as a class variable.
         :param memory_reader: The SoT MemoryHelper object we are utilizing to
         read memory data from the game
         """
-        self.m_r = memory_reader
+        self.rm = memory_reader
 
-    def _get_actor_id(self, address):
+    def _get_actor_id(self, address: int) -> int:
         """
         Function to get the AActor's ID, used to validate the ID hasnt chaned
         while running a "quick" scan
-        :param address: the base address for a given AActor
+        :param int address: the base address for a given AActor
         :rtype: int
         :return: The AActors ID
         """
-        return self.m_r.read_int(
+        return self.rm.read_int(
             address + OFFSETS.get('AActor.actorId')
         )
 
     def _get_root_comp_address(self, address: int) -> int:
         """
         Function to get an AActor's root component memory address
-        :param address: the base address for a given AActor
+        :param int address: the base address for a given AActor
         :rtype: int
         :return: the address of an AActors root component
         """
-        return self.m_r.read_ptr(
+        return self.rm.read_ptr(
             address + OFFSETS.get("AActor.rootComponent")
         )
 
@@ -55,10 +56,10 @@ def _coord_builder(self, root_comp_ptr: int, offset: int) -> dict:
         :param int offset: Offset from root component to beginning of coords,
         Often determined manually with Cheat Engine
         :rtype: dict
-        :return: A dictionary contianing the coordinate information
+        :return: A dictionary containing the coordinate information
         for a specific actor
         """
-        actor_bytes = self.m_r.read_bytes(root_comp_ptr + offset, 24)
+        actor_bytes = self.rm.read_bytes(root_comp_ptr + offset, 24)
         unpacked = struct.unpack("<ffffff", actor_bytes)
 
         coordinate_dict = {"x": unpacked[0] / 100, "y": unpacked[1] / 100,
@@ -68,5 +69,6 @@ def _coord_builder(self, root_comp_ptr: int, offset: int) -> dict:
     @abc.abstractmethod
     def update(self, my_coords):
         """
-
+        Required implementation method that we can call to update
+        the objects data in a quick fashion vs scanning every actor.
         """

helpers.py

@@ -14,30 +14,35 @@
     "SHIPS_ENABLED": False,
 }
 
+# Offset values for the text labels from the circles we draw to the screen
 TEXT_OFFSET_X = 13
 TEXT_OFFSET_Y = -5
 
-# Information on your monitor height and width. Used here and
-# in main.py to display data to the screen. May need to manually override if
-# wonky
+# Information on SoT height and width. Used here and in main.py to display
+# data to the screen. May need to manually override if wonky
 window = win32gui.FindWindow(None, "Sea of Thieves")
-SOT_WINDOW = win32gui.GetWindowRect(window)
+SOT_WINDOW = win32gui.GetWindowRect(window)  # (x1, y1, x2, y2)
 SOT_WINDOW_H = SOT_WINDOW[3]-SOT_WINDOW[1]
 SOT_WINDOW_W = SOT_WINDOW[2]-SOT_WINDOW[0]
 
+# Creates a pyglet "Batch" that we draw our information to. Effectively serves
+# as a piece of paper, so we save render cost because its 2D
 main_batch = Batch()
 
-
+# Load our offset json file
 with open("offsets.json") as infile:
     OFFSETS = json.load(infile)
 
 
 def dot(array_1: list, array_2: list) -> float:
     """
-    Python-converted version of Gummy's External SoT v2 vMatrix Dot method:
-    https://tinyurl.com/hcpafjs
-
+    Python-converted version of Gummy's External SoT v2 vMatrix Dot method (No
+    Longer Avail). Takes two lists and multiplies the same index across both
+    lists, and adds them together. (Need Source)
+    :param list array_1: Presumably some array about our player position
+    :param list array_2: Presumably some array about the dest actor position
     :rtype: float
+    :return: The result of a math equation between those two arrays
     """
     if array_2[0] == 0 and array_2[1] == 0 and array_2[2] == 0:
         return 0.0
@@ -52,7 +57,7 @@ def object_to_screen(player: dict, actor: dict) -> tuple:
     an object should be displayed. Assumes your screen is 2560x1440
 
     Python-converted version of Gummy's External SoT v2 WorldToScreen method:
-    https://tinyurl.com/3bef29jd
+    (No Longer Avail; Need Source)
 
     :param player: The player coordinate dictionary
     :param actor: An actor coordinate dictionary
@@ -105,11 +110,11 @@ def make_v_matrix(rot: dict) -> list:
     Builds data around how the camera is currently rotated.
 
     Python-converted version of Gummy's External SoT v2 Matrix method:
-    https://tinyurl.com/3bt9brm3
+    (No Longer Avail; Need Source)
 
     :param rot: The player objects camera rotation information
     :rtype: list
-    :return:
+    :return: A list of lists containing data about the rotation of our actor
     """
     rad_pitch = (rot[0] * math.pi / 180)
     rad_yaw = (rot[1] * math.pi / 180)
@@ -137,15 +142,19 @@ def make_v_matrix(rot: dict) -> list:
     return matrix
 
 
-def calculate_distance(obj_to: dict, obj_from: dict) -> float:
+def calculate_distance(obj_to: dict, obj_from: dict) -> int:
     """
     Determines the distances From one object To another in meters, rounding
     to whatever degree of precision you request
+    (**2 == ^2)
+
+    Note: Can convert the int() to a round() if you want more precision
 
     :param obj_to: A coordinate dict for the object we are going "to"
     :param obj_from: A coordinate dict for the object we are going "from"
+    :rtype: int
     :return: the distance in meters from obj_from to obj_to
     """
-    return int(math.sqrt(math.pow((obj_to.get("x") - obj_from.get("x")), 2) +
-                         math.pow((obj_to.get("y") - obj_from.get("y")), 2) +
-                         math.pow((obj_to.get("z") - obj_from.get("z")), 2)))
+    return int(math.sqrt((obj_to.get("x") - obj_from.get("x"))**2 +
+                         (obj_to.get("y") - obj_from.get("y"))**2 +
+                         (obj_to.get("z") - obj_from.get("z"))**2))