Merge pull request #2 from Magnemania/wargroove

FlySniper · web-flow · commit 8e6026f0f74c · 2022-11-21T17:48:31.000-05:00
WG: GUI Client for tracking and selecting commanders
diff --git a/WargrooveClient.py b/WargrooveClient.py
@@ -3,22 +3,28 @@
 import sys
 import asyncio
 import random
-from typing import Tuple, List, Iterable
-from worlds.wargroove.Items import faction_table, CommanderData
+from typing import Tuple, List, Iterable, Dict
+
+from worlds.wargroove import WargrooveWorld
+from worlds.wargroove.Items import item_table, faction_table, CommanderData, ItemData
 
 import ModuleUpdate
 ModuleUpdate.update()
 
 import Utils
 import json
+import logging
 
 if __name__ == "__main__":
     Utils.init_logging("WargrooveClient", exception_logger="Client")
+    Utils.init_logging("WG", exception_logger="Client")
 
 from NetUtils import NetworkItem, ClientStatus
 from CommonClient import gui_enabled, logger, get_base_parser, ClientCommandProcessor, \
     CommonContext, server_loop
 
+wg_logger = logging.getLogger("WG")
+
 
 class WargrooveClientCommandProcessor(ClientCommandProcessor):
     def _cmd_resync(self):
@@ -33,23 +39,32 @@ def _cmd_commander(self, *commander_name: Iterable[str]):
         else:
             if self.ctx.can_choose_commander:
                 commanders = self.ctx.get_commanders()
-                logger.info('Unlocked commanders: ' +
-                            ', '.join((commander.name for commander, unlocked in commanders if unlocked))
-                            )
-                logger.info('Locked commanders: ' +
-                            ', '.join((commander.name for commander, unlocked in commanders if not unlocked))
-                            )
+                wg_logger.info('Unlocked commanders: ' +
+                               ', '.join((commander.name for commander, unlocked in commanders if unlocked)))
+                wg_logger.info('Locked commanders: ' +
+                               ', '.join((commander.name for commander, unlocked in commanders if not unlocked)))
             else:
-                logger.error('Cannot set commanders in this game mode.')
+                wg_logger.error('Cannot set commanders in this game mode.')
 
 
 class WargrooveContext(CommonContext):
     command_processor: int = WargrooveClientCommandProcessor
     game = "Wargroove"
     items_handling = 0b111  # full remote
     current_commander: CommanderData = faction_table["Starter"][0]
-    can_choose_commander: bool
+    can_choose_commander: bool = False
+    commander_defense_boost_multiplier: int = 0
+    income_boost_multiplier: int = 0
     starting_groove_multiplier: float
+    faction_item_ids = {
+        'Starter': 0,
+        'Cherrystone': 52025,
+        'Felheim': 52026,
+        'Floran': 52027,
+        'Heavensong': 52028,
+        'Requiem': 52029,
+        'Outlaw': 52030
+    }
 
     def __init__(self, server_address, password):
         super(WargrooveContext, self).__init__(server_address, password)
@@ -108,13 +123,17 @@ def on_package(self, cmd: str, args: dict):
                 slot_data = args["slot_data"]
                 json.dump(args["slot_data"], f)
                 self.can_choose_commander = slot_data["can_choose_commander"]
+                print('can choose commander:', self.can_choose_commander)
                 self.starting_groove_multiplier = slot_data["starting_groove_multiplier"]
+                self.income_boost_multiplier = slot_data["income_boost"]
+                self.commander_defense_boost_multiplier = slot_data["commander_defense_boost"]
                 f.close()
             for ss in self.checked_locations:
                 filename = f"send{ss}"
                 with open(os.path.join(self.game_communication_path, filename), 'w') as f:
                     f.close()
             self.update_commander_data()
+            self.ui.update_tracker()
 
             random.seed(self.seed_name + str(self.slot))
             # Our indexes start at 1 and we have 23 levels
@@ -168,6 +187,7 @@ def on_package(self, cmd: str, args: dict):
                                 self.player_names[network_item.player])
                         f.close()
                 self.update_commander_data()
+                self.ui.update_tracker()
 
         if cmd in {"RoomUpdate"}:
             if "checked_locations" in args:
@@ -178,15 +198,128 @@ def on_package(self, cmd: str, args: dict):
 
     def run_gui(self):
         """Import kivy UI system and start running it as self.ui_task."""
-        from kvui import GameManager
+        from kvui import GameManager, HoverBehavior, ServerToolTip
+        from kivy.uix.tabbedpanel import TabbedPanelItem
+        from kivy.lang import Builder
+        from kivy.uix.button import Button
+        from kivy.uix.togglebutton import ToggleButton
+        from kivy.uix.boxlayout import BoxLayout
+        from kivy.uix.gridlayout import GridLayout
+        from kivy.uix.image import AsyncImage, Image
+        from kivy.uix.stacklayout import StackLayout
+        from kivy.uix.label import Label
+        from kivy.properties import ColorProperty
+        from kivy.uix.image import Image
+        import pkgutil
+
+        class TrackerLayout(BoxLayout):
+            pass
+
+        class CommanderSelect(BoxLayout):
+            pass
+
+        class CommanderButton(ToggleButton):
+            pass
+
+        class FactionBox(BoxLayout):
+            pass
+
+        class CommanderGroup(BoxLayout):
+            pass
+
+        class ItemTracker(BoxLayout):
+            pass
+
+        class ItemLabel(Label):
+            pass
 
         class WargrooveManager(GameManager):
             logging_pairs = [
-                ("Client", "Archipelago")
+                ("Client", "Archipelago"),
+                ("WG", "WG Console"),
             ]
             base_title = "Archipelago Wargroove Client"
+            ctx: WargrooveContext
+            unit_tracker: ItemTracker
+            trigger_tracker: BoxLayout
+            boost_tracker: BoxLayout
+            commander_buttons: Dict[int, List[CommanderButton]]
+            tracker_items = {
+                "Swordsman": ItemData(None, "Unit", False),
+                "Dog": ItemData(None, "Unit", False),
+                **item_table
+            }
+
+            def build(self):
+                container = super().build()
+                panel = TabbedPanelItem(text="Wargroove")
+                panel.content = self.build_tracker()
+                self.tabs.add_widget(panel)
+                return container
+
+            def build_tracker(self) -> TrackerLayout:
+                try:
+                    tracker = TrackerLayout(orientation="horizontal")
+                    commander_select = CommanderSelect(orientation="vertical")
+                    self.commander_buttons = {}
+
+                    for faction, commanders in faction_table.items():
+                        faction_box = FactionBox(size_hint=(None, None), width=100 * len(commanders), height=70)
+                        commander_group = CommanderGroup()
+                        commander_buttons = []
+                        for commander in commanders:
+                            commander_button = CommanderButton(text=commander.name, group="commanders")
+                            if faction == "Starter":
+                                commander_button.disabled = False
+                            commander_button.bind(on_press=lambda instance: self.ctx.set_commander(instance.text))
+                            commander_buttons.append(commander_button)
+                            commander_group.add_widget(commander_button)
+                        self.commander_buttons[faction] = commander_buttons
+                        faction_box.add_widget(Label(text=faction, size_hint_x=None, pos_hint={'left': 1}, size_hint_y=None, height=10))
+                        faction_box.add_widget(commander_group)
+                        commander_select.add_widget(faction_box)
+                    item_tracker = ItemTracker(padding=[0,20])
+                    self.unit_tracker = BoxLayout(orientation="vertical")
+                    other_tracker = BoxLayout(orientation="vertical")
+                    self.trigger_tracker = BoxLayout(orientation="vertical")
+                    self.boost_tracker = BoxLayout(orientation="vertical")
+                    other_tracker.add_widget(self.trigger_tracker)
+                    other_tracker.add_widget(self.boost_tracker)
+                    item_tracker.add_widget(self.unit_tracker)
+                    item_tracker.add_widget(other_tracker)
+                    tracker.add_widget(commander_select)
+                    tracker.add_widget(item_tracker)
+                    self.update_tracker()
+                    return tracker
+                except Exception as e:
+                    print(e)
+
+            def update_tracker(self):
+                received_ids = [item.item for item in self.ctx.items_received]
+                for faction, item_id in self.ctx.faction_item_ids.items():
+                    for commander_button in self.commander_buttons[faction]:
+                        commander_button.disabled = not (faction == "Starter" or item_id in received_ids)
+                self.unit_tracker.clear_widgets()
+                self.trigger_tracker.clear_widgets()
+                for name, item in self.tracker_items.items():
+                    if item.type in ("Unit", "Trigger"):
+                        status_color = (1, 1, 1, 1) if item.code is None or item.code in received_ids else (0.6, 0.2, 0.2, 1)
+                        label = ItemLabel(text=name, color=status_color)
+                        if item.type == "Unit":
+                            self.unit_tracker.add_widget(label)
+                        else:
+                            self.trigger_tracker.add_widget(label)
+                self.boost_tracker.clear_widgets()
+                extra_income = received_ids.count(52023) * self.ctx.income_boost_multiplier
+                extra_defense = received_ids.count(52024) * self.ctx.commander_defense_boost_multiplier
+                income_boost = ItemLabel(text="Extra Income: " + str(extra_income))
+                defense_boost = ItemLabel(text="Comm Defense: " + str(100 + extra_defense))
+                self.boost_tracker.add_widget(income_boost)
+                self.boost_tracker.add_widget(defense_boost)
 
         self.ui = WargrooveManager(self)
+        data = pkgutil.get_data(WargrooveWorld.__module__, "Wargroove.kv").decode()
+        Builder.load_string(data)
         self.ui_task = asyncio.create_task(self.ui.async_run(), name="UI")
 
     def update_commander_data(self):
@@ -211,34 +344,35 @@ def update_commander_data(self):
         filename = 'commander.json'
         with open(os.path.join(self.game_communication_path, filename), 'w') as f:
             json.dump(data, f)
+        if self.ui:
+            self.ui.update_tracker()
 
     def set_commander(self, commander_name: str) -> bool:
         """Sets the current commander to the given one, if possible"""
         if not self.can_choose_commander:
-            logger.error("Cannot set commanders in this game mode.")
+            wg_logger.error("Cannot set commanders in this game mode.")
             return
         match_name = commander_name.lower()
         for commander, unlocked in self.get_commanders():
             if commander.name.lower() == match_name or commander.alt_name and commander.alt_name.lower() == match_name:
                 if unlocked:
                     self.current_commander = commander
                     self.syncing = True
-                    logger.info(f"Commander set to {commander.name}.")
+                    wg_logger.info(f"Commander set to {commander.name}.")
                     self.update_commander_data()
                     return True
                 else:
-                    logger.error(f"Commander {commander.name} has not been unlocked.")
+                    wg_logger.error(f"Commander {commander.name} has not been unlocked.")
                     return False
         else:
-            logger.error(f"{commander_name} is not a recognized Wargroove commander.")
+            wg_logger.error(f"{commander_name} is not a recognized Wargroove commander.")
 
     def get_commanders(self) -> List[Tuple[CommanderData, bool]]:
         """Gets a list of commanders with their unlocked status"""
-        received_item_names = (self.item_names[network_item.item] for network_item in self.items_received)
-        received_factions = {item_name[:-11] for item_name in received_item_names if item_name.endswith(' Commanders')}
         commanders = []
+        received_ids = [item.item for item in self.items_received]
         for faction in faction_table.keys():
-            unlocked = faction == 'Starter' or str(faction) in received_factions
+            unlocked = faction == 'Starter' or self.faction_item_ids[faction] in received_ids
             commanders += [(commander, unlocked) for commander in faction_table[faction]]
         return commanders
 
diff --git a/worlds/wargroove/Items.py b/worlds/wargroove/Items.py
@@ -6,53 +6,54 @@
 
 class ItemData(typing.NamedTuple):
     code: typing.Optional[int]
+    type: str
     progression: bool
     filler: bool = False
 
 
 item_table: Dict[str, ItemData] = {
     # Units
-    'Spearman': ItemData(52000, True),
-    'Wagon': ItemData(52001, False),
-    'Mage': ItemData(52002, True),
-    'Archer': ItemData(52003, True),
-    'Knight': ItemData(52004, True),
-    'Ballista': ItemData(52005, True),
-    'Golem': ItemData(52006, False),
-    'Harpy': ItemData(52007, True),
-    'Witch': ItemData(52008, False),
-    'Dragon': ItemData(52009, False),
-    'Balloon': ItemData(52010, False),
-    'Barge': ItemData(52011, True),
-    'Merfolk': ItemData(52012, True),
-    'Turtle': ItemData(52013, True),
-    'Harpoon Ship': ItemData(52014, True),
-    'Warship': ItemData(52015, True),
-    'Thief': ItemData(52016, True),
-    'Rifleman': ItemData(52017, False),
+    'Spearman': ItemData(52000, 'Unit', True),
+    'Wagon': ItemData(52001, 'Unit', False),
+    'Mage': ItemData(52002, 'Unit', True),
+    'Archer': ItemData(52003, 'Unit', True),
+    'Knight': ItemData(52004, 'Unit', True),
+    'Ballista': ItemData(52005, 'Unit', True),
+    'Golem': ItemData(52006, 'Unit', False),
+    'Harpy': ItemData(52007, 'Unit', True),
+    'Witch': ItemData(52008, 'Unit', False),
+    'Dragon': ItemData(52009, 'Unit', False),
+    'Balloon': ItemData(52010, 'Unit', False),
+    'Barge': ItemData(52011, 'Unit', True),
+    'Merfolk': ItemData(52012, 'Unit', True),
+    'Turtle': ItemData(52013, 'Unit', True),
+    'Harpoon Ship': ItemData(52014, 'Unit', True),
+    'Warship': ItemData(52015, 'Unit', True),
+    'Thief': ItemData(52016, 'Unit', True),
+    'Rifleman': ItemData(52017, 'Unit', False),
 
     # Map Triggers
-    'Eastern Bridges': ItemData(52018, True),
-    'Southern Walls': ItemData(52019, True),
-    'Final Bridges': ItemData(52020, True),
-    'Final Walls': ItemData(52021, True),
-    'Final Sickle': ItemData(52022, True),
+    'Eastern Bridges': ItemData(52018, 'Trigger', True),
+    'Southern Walls': ItemData(52019, 'Trigger', True),
+    'Final Bridges': ItemData(52020, 'Trigger', True),
+    'Final Walls': ItemData(52021, 'Trigger', True),
+    'Final Sickle': ItemData(52022, 'Trigger', True),
 
     # Player Buffs
-    'Income Boost': ItemData(52023, False, True),
+    'Income Boost': ItemData(52023, 'Boost', False, True),
 
-    'Commander Defense Boost': ItemData(52024, False, True),
+    'Commander Defense Boost': ItemData(52024, 'Boost', False, True),
 
     # Factions
-    'Cherrystone Commanders': ItemData(52025, False),
-    'Felheim Commanders': ItemData(52026, False),
-    'Floran Commanders': ItemData(52027, False),
-    'Heavensong Commanders': ItemData(52028, False),
-    'Requiem Commanders': ItemData(52029, False),
-    'Outlaw Commanders': ItemData(52030, False),
+    'Cherrystone Commanders': ItemData(52025, 'Faction', False),
+    'Felheim Commanders': ItemData(52026, 'Faction', False),
+    'Floran Commanders': ItemData(52027, 'Faction', False),
+    'Heavensong Commanders': ItemData(52028, 'Faction', False),
+    'Requiem Commanders': ItemData(52029, 'Faction', False),
+    'Outlaw Commanders': ItemData(52030, 'Faction', False),
 
     # Event Items
-    'Wargroove Victory': ItemData(None, True, True)
+    'Wargroove Victory': ItemData(None, 'Goal', True)
 
 }
 
diff --git a/worlds/wargroove/Wargroove.kv b/worlds/wargroove/Wargroove.kv
@@ -0,0 +1,29 @@
+<FactionBox>:
+    orientation: 'vertical'
+    padding: [10,5,10,5]
+
+<CommanderGroup>:
+    orientation: 'horizontal'
+
+<CommanderButton>:
+    text_size: self.size
+    size_hint: (None, None)
+    height: 40
+    width: 100
+    markup: True
+    halign: 'center'
+    valign: 'middle'
+    padding_x: 5
+    markup: True
+    outline_width: 1
+    disabled: True
+    on_release: setattr(self, 'state', 'down')
+
+<ItemTracker>:
+    orientation: 'horizontal'
+    padding_y: 5
+
+<ItemLabel>:
+    size_hint_x: None
+    size: self.texture_size
+    pos_hint: {'left': 1}
