Loading comps from lolchess.gg

.gitignore

@@ -334,3 +334,6 @@ ASALocalRun/
 .localhistory/
 *.pyproj
 .vscode
+test2222.py
+dump_comps.py
+cached_data/cached8.json

README.md

@@ -1,38 +1,9 @@
-![main](https://i.imgur.com/roX0N3C.png)
+Fork of https://github.com/jfd02/TFT-OCR-BOT (Get the installation instructions, but use the files from this repository)
 
-## NOTES:
-- Make sure you don't have any overlays on (Blitz, Mobalytics, etc.).
-- League & client must be in English.
-- 16:9 resolution borderless windowed is required in League, the game must also be on the main monitor (Use 1920x1080 for best results).
-- If the program crashes, create an issue with the error.
 
-## INSTALLATION:
-1. Install Python 3.10.6 from https://www.python.org/downloads/windows/
-   - Note that Python 3.10.6 cannot be used on Windows 7 or earlier.
-2. Clone the repository or download it from here https://github.com/jfd02/TFT-OCR-BOT/archive/refs/heads/main.zip
-3. Open Command Prompt and change the current directory to the folder where main.py is located 
-4. Run pip install -r requirements.txt in Command Prompt
-5. Install tesseract using the Windows installer available at: https://github.com/UB-Mannheim/tesseract/wiki
-   - Note the tesseract path from the installation.
-   - Set the tesseract path in the settings.py file (it may already be correct)
-6. Configure settings.py so the league client path is correct
-7. Disable all in-game overlays
-8. Run the main.py file
+- Implemented auto comps loading from lolchess (champion, board pos, items, augments)
+- Fixed items adding (emblems, other items)
+- Added new items (set 8)
+- Various comps selection modes
 
-## FEATURES:
-![main](https://i.imgur.com/1bXOmag.png)
-- Read the board state (Round / Level / Gold / Shop / Items)
-- Keeps track of champions on the board and bench
-- Pick a random item/champ from the carousel
-- Pickup items from the board after PVE rounds
-- Place correct items onto champions
-- Plays the user-defined team comp
-- Auto queue using the LCU API
-
-## TODO:
-- Implement tome of traits logic
-- Revamp the gold spending function
-- Revamp auto queue to have more safety checks / fail-safes
-- Grab the best compositions from TFT website
-- Intelligent carousel item selection
-- Change item pickup to be based on the coordinates of orbs
+![preview](https://user-images.githubusercontent.com/67195196/206607219-ce2f6397-ff3b-4543-87e8-17f8ab61325b.png)

arena.py

@@ -2,30 +2,32 @@
 Handles the board / bench state inside of the game and
 other variables used by the bot to make decisions
 """
-
+import json
 from time import sleep
 import game_assets
 import mk_functions
 import screen_coords
 from champion import Champion
-import comps
 import ocr
 import game_functions
 import arena_functions
-
+from comps import CompsManager
+import comps
 
 class Arena:
     """Arena class that handles game logic such as board and bench state"""
 
     # pylint: disable=too-many-instance-attributes,too-many-public-methods
-    def __init__(self, message_queue) -> None:
+    def __init__(self, message_queue, comps_manager : CompsManager) -> None:
+        self.comps_manager = comps_manager
+        self.comps_manager.SelectNextComp()
         self.message_queue = message_queue
         self.board_size = 0
         self.bench: list[None] = [None, None, None, None, None, None, None, None, None]
         self.board: list = []
         self.board_unknown: list = []
-        self.unknown_slots: list = comps.get_unknown_slots()
-        self.champs_to_buy: list = comps.champions_to_buy()
+        self.unknown_slots: list = comps_manager.get_unknown_slots()
+        self.champs_to_buy: list = comps_manager.champions_to_buy()
         self.board_names: list = []
         self.items: list = []
         self.final_comp = False
@@ -49,10 +51,10 @@ def bought_champion(self, name: str, slot: int) -> None:
         self.bench[slot] = Champion(name=name,
                                     coords=screen_coords.BENCH_LOC[slot].get_coords(
                                     ),
-                                    build=comps.COMP[name]["items"].copy(),
+                                    build=self.comps_manager.CURRENT_COMP()[1][name]["items"].copy(),
                                     slot=slot,
-                                    size=game_assets.CHAMPIONS[name]["Board Size"],
-                                    final_comp=comps.COMP[name]["final_comp"])
+                                    size=self.comps_manager.champions[name]["Board Size"],
+                                    final_comp=self.comps_manager.CURRENT_COMP()[1][name]["final_comp"])
         mk_functions.move_mouse(screen_coords.DEFAULT_LOC.get_coords())
         sleep(0.5)
         self.fix_bench_state()
@@ -72,15 +74,15 @@ def have_champion(self) -> Champion | None:
     def move_known(self, champion: Champion) -> None:
         """Moves champion to the board"""
         print(f"  Moving {champion.name} to board")
-        destination: tuple = screen_coords.BOARD_LOC[comps.COMP[champion.name]["board_position"]].get_coords()
+        destination: tuple = screen_coords.BOARD_LOC[self.comps_manager.CURRENT_COMP()[1][champion.name]["board_position"]].get_coords()
         mk_functions.left_click(champion.coords)
         sleep(0.1)
         mk_functions.left_click(destination)
         champion.coords = destination
         self.board.append(champion)
         self.board_names.append(champion.name)
         self.bench[champion.index] = None
-        champion.index = comps.COMP[champion.name]["board_position"]
+        champion.index = self.comps_manager.CURRENT_COMP()[1][champion.name]["board_position"]
         self.board_size += champion.size
 
     def move_unknown(self) -> None:
@@ -118,17 +120,16 @@ def move_champions(self) -> None:
                 self.move_unknown()
             else:
                 bought_unknown = False
-                shop: list = arena_functions.get_shop()
+                shop: list = arena_functions.get_shop(self.comps_manager)
                 for champion in shop:
                     gold: int = arena_functions.get_gold()
                     valid_champ: bool = (
-                        champion[1] in game_assets.CHAMPIONS and
-                        game_assets.champion_gold_cost(champion[1]) <= gold and
-                        game_assets.champion_board_size(champion[1]) == 1 and
+                        champion[1] in self.comps_manager.champions and
+                        self.comps_manager.champion_gold_cost(champion[1]) <= gold and
+                        self.comps_manager.champion_board_size(champion[1]) == 1 and
                         champion[1] not in self.champs_to_buy and
                         champion[1] not in self.board_unknown
                     )
-
                     if valid_champ:
                         none_slot: int = arena_functions.empty_slot()
                         mk_functions.left_click(screen_coords.BUY_LOC[champion[0]].get_coords())
@@ -173,6 +174,7 @@ def clear_anvil(self) -> None:
                 mk_functions.press_e(screen_coords.BENCH_LOC[index].get_coords())
         sleep(1)
         mk_functions.left_click(screen_coords.BUY_LOC[2].get_coords())
+        sleep(0.5)
 
     def place_items(self) -> None:
         """Iterates through items and tries to add them to champion"""
@@ -204,7 +206,7 @@ def add_item_to_champ(self, item_index: int, champ: Champion) -> None:
             item_to_move: None = None
             for build_item in champ.build:
                 build_item_components: list = list(
-                    game_assets.FULL_ITEMS[build_item])
+                    game_assets.FULL_ITEMS.get(build_item, []))
                 if item in build_item_components:
                     item_to_move: None = item
                     build_item_components.remove(item_to_move)
@@ -295,11 +297,11 @@ def spend_gold(self) -> None:
                     print("  Purchasing XP")
                 mk_functions.reroll()
                 print("  Rerolling shop")
-            shop: list = arena_functions.get_shop()
+            shop: list = arena_functions.get_shop(self.comps_manager)
             print(f"  Shop: {shop}")
             for champion in shop:
                 if (champion[1] in self.champs_to_buy and
-                    arena_functions.get_gold() - game_assets.CHAMPIONS[champion[1]]["Gold"] >= 0
+                    arena_functions.get_gold() - self.comps_manager.champions[champion[1]]["Gold"] >= 0
                  ):
                     none_slot: int = arena_functions.empty_slot()
                     if none_slot != -1:
@@ -308,7 +310,7 @@ def spend_gold(self) -> None:
                         self.bought_champion(champion[1], none_slot)
                         self.champs_to_buy.remove(champion[1])
                     else:
-                        # Try to buy champ 3 when bench is full
+                        """Try to buy champ 3 when bench is full"""
                         print(f"  Board is full but want {champion[1]}")
                         mk_functions.left_click(screen_coords.BUY_LOC[champion[0]].get_coords())
                         game_functions.default_pos()
@@ -326,20 +328,35 @@ def buy_xp_round(self) -> None:
         if arena_functions.get_gold() >= 4:
             mk_functions.buy_xp()
 
+
+    def load_aguments(self):
+        augments = self.comps_manager.CURRENT_COMP()[2]
+        return augments
+
     def pick_augment(self) -> None:
-        """Picks an augment from user defined augment priority list or defaults to first augment"""
+        """Picks an augment from comp specific/user defined augment list or defaults to first augment"""
         augments: list = []
+        game_augments = self.load_aguments()
         for coords in screen_coords.AUGMENT_POS:
             augment: str = ocr.get_text(screenxy=coords.get_coords(), scale=3, psm=7)
             augments.append(augment)
 
         for augment in augments:
-            for potential in comps.AUGMENTS:
-                if potential in augment:
-                    print(f"  Choosing augment {augment}")
-                    mk_functions.left_click(screen_coords.AUGMENT_LOC[augments.index(augment)].get_coords())
-                    return
-
+            try:
+                for potential in game_augments:
+                    """Picks an augment from comp defined augments"""
+                    if potential in augment:
+                        print(f"  Choosing comp defined augment: {augment}")
+                        mk_functions.left_click(screen_coords.AUGMENT_LOC[augments.index(augment)].get_coords())
+                        return
+            except:
+                for potential in game_assets.AUGMENTS:
+                    """Picks an augment from user defined augments"""
+                    if potential in augment:
+                        print(f"  Choosing user defined augment: {augment}")
+                        mk_functions.left_click(screen_coords.AUGMENT_LOC[augments.index(augment)].get_coords())
+                        return
+
         if self.augment_roll:
             print("  Rolling for augment")
             mk_functions.left_click(screen_coords.AUGMENT_ROLL.get_coords())
@@ -367,6 +384,7 @@ def get_label(self) -> None:
             for slot in self.bench
             if isinstance(slot, Champion)
         ]
+
         for slot in self.board:
             if isinstance(slot, Champion):
                 labels.append((f"{slot.name}", slot.coords))

arena_functions.py

@@ -12,7 +12,7 @@
 import game_assets
 import mk_functions
 from vec4 import Vec4
-
+from comps import CompsManager
 
 def get_level() -> int:
     """Returns the level for the tactician"""
@@ -43,34 +43,29 @@ def get_gold() -> int:
         return 0
 
 
-def valid_champ(champ: str) -> str:
+def valid_champ(champ: str, comps : CompsManager) -> str:
     """Matches champion string to a valid champion name string and returns it"""
-    if champ in game_assets.CHAMPIONS:
+    if champ in comps.champions:
         return champ
 
-    return next(
-        (
-            champion
-            for champion in game_assets.CHAMPIONS
-            if SequenceMatcher(a=champion, b=champ).ratio() >= 0.7
-        ),
-        "",
-    )
+    for champion in comps.champions:
+        if SequenceMatcher(a=champion, b=champ).ratio() >= 0.7:
+            return champion
+    return ""
 
-def get_champ(screen_capture: ImageGrab.Image, name_pos: Vec4, shop_pos: int, shop_array: list) -> str:
+def get_champ(screen_capture: ImageGrab.Image, name_pos: Vec4, shop_pos: int, shop_array: list, comps : CompsManager) -> str:
     """Returns a tuple containing the shop position and champion name"""
     champ: str = screen_capture.crop(name_pos.get_coords())
     champ: str = ocr.get_text_from_image(image=champ, whitelist="")
-    shop_array.append((shop_pos, valid_champ(champ)))
-
+    shop_array.append((shop_pos, valid_champ(champ, comps)))
 
-def get_shop() -> list:
+def get_shop(comps : CompsManager) -> list:
     """Returns the list of champions in the shop"""
     screen_capture = ImageGrab.grab(bbox=screen_coords.SHOP_POS.get_coords())
     shop: list = []
     thread_list: list = []
     for shop_index, name_pos in enumerate(screen_coords.CHAMP_NAME_POS):
-        thread = threading.Thread(target=get_champ, args=(screen_capture, name_pos, shop_index, shop))
+        thread = threading.Thread(target=get_champ, args=(screen_capture, name_pos, shop_index, shop, comps))
         thread_list.append(thread)
     for thread in thread_list:
         thread.start()
@@ -104,15 +99,10 @@ def bench_occupied_check() -> list:
 
 def valid_item(item: str) -> str | None:
     """Checks if the item passed in arg one is valid"""
-    return next(
-        (
-            valid_item_name
-            for valid_item_name in game_assets.ITEMS
-            if valid_item_name in item
-            or SequenceMatcher(a=valid_item_name, b=item).ratio() >= 0.7
-        ),
-        None,
-    )
+    for valid_item_name in game_assets.ITEMS:
+        if valid_item_name in item or SequenceMatcher(a=valid_item_name, b=item).ratio() >= 0.7:
+            return valid_item_name
+    return None
 
 
 def get_items() -> list:
@@ -125,3 +115,4 @@ def get_items() -> list:
         item_bench.append(valid_item(item))
     mk_functions.move_mouse(screen_coords.DEFAULT_LOC.get_coords())
     return item_bench
+