New Game Implementation: Wargroove 2

BaseClasses.py

@@ -37,6 +37,7 @@ class Group(TypedDict, total=False):
 
 class ThreadBarrierProxy:
     """Passes through getattr while passthrough is True"""
+
     def __init__(self, obj: object) -> None:
         self.passthrough = True
         self.obj = obj
@@ -97,9 +98,9 @@ class RegionManager:
         location_cache: Dict[int, Dict[str, Location]]
 
         def __init__(self, players: int):
-            self.region_cache = {player: {} for player in range(1, players+1)}
-            self.entrance_cache = {player: {} for player in range(1, players+1)}
-            self.location_cache = {player: {} for player in range(1, players+1)}
+            self.region_cache = {player: {} for player in range(1, players + 1)}
+            self.entrance_cache = {player: {} for player in range(1, players + 1)}
+            self.location_cache = {player: {} for player in range(1, players + 1)}
 
         def __iadd__(self, other: Iterable[Region]):
             self.extend(other)
@@ -166,7 +167,7 @@ def set_player_attr(attr, val):
             set_player_attr('completion_condition', lambda state: True)
         self.worlds = {}
         self.per_slot_randoms = Utils.DeprecateDict("Using per_slot_randoms is now deprecated. Please use the "
-                                                      "world's random object instead (usually self.random)")
+                                                    "world's random object instead (usually self.random)")
         self.plando_options = PlandoOptions.none
 
     def get_all_ids(self) -> Tuple[int, ...]:
@@ -451,7 +452,8 @@ def find_item(self, item, player: int) -> Location:
         return next(location for location in self.get_locations() if
                     location.item and location.item.name == item and location.item.player == player)
 
-    def find_items_in_locations(self, items: Set[str], player: int, resolve_group_locations: bool = False) -> List[Location]:
+    def find_items_in_locations(self, items: Set[str], player: int, resolve_group_locations: bool = False) -> List[
+        Location]:
         if resolve_group_locations:
             player_groups = self.get_player_groups(player)
             return [location for location in self.get_locations() if
@@ -498,13 +500,15 @@ def get_unfilled_locations(self, player: Optional[int] = None) -> List[Location]
     def get_filled_locations(self, player: Optional[int] = None) -> List[Location]:
         return [location for location in self.get_locations(player) if location.item is not None]
 
-    def get_reachable_locations(self, state: Optional[CollectionState] = None, player: Optional[int] = None) -> List[Location]:
+    def get_reachable_locations(self, state: Optional[CollectionState] = None, player: Optional[int] = None) -> List[
+        Location]:
         state: CollectionState = state if state else self.state
         return [location for location in self.get_locations(player) if location.can_reach(state)]
 
     def get_placeable_locations(self, state=None, player=None) -> List[Location]:
         state: CollectionState = state if state else self.state
-        return [location for location in self.get_locations(player) if location.item is None and location.can_reach(state)]
+        return [location for location in self.get_locations(player) if
+                location.item is None and location.can_reach(state)]
 
     def get_unfilled_locations_for_players(self, location_names: List[str], players: Iterable[int]):
         for player in players:
@@ -963,7 +967,7 @@ class LocationRegister(Register):
         def __delitem__(self, index: int) -> None:
             location: Location = self._list.__getitem__(index)
             self._list.__delitem__(index)
-            del(self.region_manager.location_cache[location.player][location.name])
+            del (self.region_manager.location_cache[location.player][location.name])
 
         def insert(self, index: int, value: Location) -> None:
             assert value.name not in self.region_manager.location_cache[value.player], \
@@ -975,7 +979,7 @@ class EntranceRegister(Register):
         def __delitem__(self, index: int) -> None:
             entrance: Entrance = self._list.__getitem__(index)
             self._list.__delitem__(index)
-            del(self.region_manager.entrance_cache[entrance.player][entrance.name])
+            del (self.region_manager.entrance_cache[entrance.player][entrance.name])
 
         def insert(self, index: int, value: Entrance) -> None:
             assert value.name not in self.region_manager.entrance_cache[value.player], \
@@ -1090,7 +1094,8 @@ def __repr__(self):
         return self.__str__()
 
     def __str__(self):
-        return self.multiworld.get_name_string_for_object(self) if self.multiworld else f'{self.name} (Player {self.player})'
+        return self.multiworld.get_name_string_for_object(
+            self) if self.multiworld else f'{self.name} (Player {self.player})'
 
 
 class LocationProgressType(IntEnum):

Wargroove2Client.py

@@ -0,0 +1,11 @@
+from __future__ import annotations
+
+import ModuleUpdate
+ModuleUpdate.update()
+
+from worlds.wargroove2.client import launch
+import Utils
+
+if __name__ == "__main__":
+    Utils.init_logging("Wargroove2Client", exception_logger="Client")
+    launch()

worlds/wargroove2/Items.py

@@ -0,0 +1,140 @@
+import typing
+
+from BaseClasses import Item, ItemClassification
+from typing import Dict, List
+
+PROGRESSION = ItemClassification.progression
+PROGRESSION_SKIP_BALANCING = ItemClassification.progression_skip_balancing
+USEFUL = ItemClassification.useful
+FILLER = ItemClassification.filler
+
+
+class ItemData(typing.NamedTuple):
+    code: typing.Optional[int]
+    type: str
+    classification: ItemClassification = PROGRESSION
+
+
+item_table: Dict[str, ItemData] = {
+    # Units
+    'Spearman': ItemData(252000, 'Unit'),
+    'Wagon': ItemData(252001, 'Unit'),
+    'Mage': ItemData(252002, 'Unit'),
+    'Archer': ItemData(252003, 'Unit'),
+    'Knight': ItemData(252004, 'Unit'),
+    'Ballista': ItemData(252005, 'Unit'),
+    'Trebuchet': ItemData(252006, 'Unit'),
+    'Golem': ItemData(252007, 'Unit'),
+    'Air Trooper': ItemData(252008, 'Unit'),
+    'Harpy': ItemData(252009, 'Unit'),
+    'Witch': ItemData(252010, 'Unit'),
+    'Dragon': ItemData(252011, 'Unit'),
+    'Balloon': ItemData(252012, 'Unit'),
+    'Barge': ItemData(252013, 'Unit'),
+    'River Boat': ItemData(252014, 'Unit'),
+    'Merfolk': ItemData(252015, 'Unit'),
+    'Turtle': ItemData(252016, 'Unit'),
+    'Harpoon Ship': ItemData(252017, 'Unit'),
+    'Warship': ItemData(252018, 'Unit'),
+    'Frog': ItemData(252019, 'Unit'),
+    'Kraken': ItemData(252020, 'Unit'),
+    'Thief': ItemData(252021, 'Unit'),
+    'Rifleman': ItemData(252022, 'Unit'),
+
+    # Map Triggers
+    'Bridges Event': ItemData(252023, 'Trigger'),
+    'Walls Event': ItemData(252024, 'Trigger'),
+    'Landing Event': ItemData(252025, 'Trigger'),
+    'Airstrike Event': ItemData(252026, 'Trigger'),
+    'Final North': ItemData(252027, 'Trigger', PROGRESSION_SKIP_BALANCING),
+    'Final East': ItemData(252028, 'Trigger', PROGRESSION_SKIP_BALANCING),
+    'Final South': ItemData(252029, 'Trigger', PROGRESSION_SKIP_BALANCING),
+    'Final West': ItemData(252030, 'Trigger', PROGRESSION_SKIP_BALANCING),
+    'Final Center': ItemData(252031, 'Trigger', PROGRESSION_SKIP_BALANCING),
+
+    # Player Buffs
+    'Income Boost': ItemData(252032, 'Boost', FILLER),
+
+    'Commander Defense Boost': ItemData(252033, 'Boost', FILLER),
+    'Groove Boost': ItemData(252041, 'Boost', FILLER),
+
+    # Factions
+    'Cherrystone Commanders': ItemData(252034, 'Faction', USEFUL),
+    'Felheim Commanders': ItemData(252035, 'Faction', USEFUL),
+    'Floran Commanders': ItemData(252036, 'Faction', USEFUL),
+    'Heavensong Commanders': ItemData(252037, 'Faction', USEFUL),
+    'Requiem Commanders': ItemData(252038, 'Faction', USEFUL),
+    'Pirate Commanders': ItemData(252039, 'Faction', USEFUL),
+    'Faahri Commanders': ItemData(252040, 'Faction', USEFUL),
+
+    # Event Items
+    'Wargroove 2 Victory': ItemData(None, 'Goal')
+
+}
+
+item_id_name: {int, str} = {}
+for name in item_table.keys():
+    id = item_table[name].code
+    if id is not None:
+        item_id_name[id] = name
+
+
+class CommanderData(typing.NamedTuple):
+    name: str
+    internal_name: str
+    alt_name: str = None
+
+
+faction_table: Dict[str, List[CommanderData]] = {
+    'Starter': [
+        CommanderData('Mercival', 'commander_mercival', 'Mercival II')
+    ],
+    'Cherrystone': [
+        CommanderData('Mercia', 'commander_mercia'),
+        CommanderData('Emeric', 'commander_emeric'),
+        CommanderData('Caesar', 'commander_caesar'),
+    ],
+    'Felheim': [
+        CommanderData('Valder', 'commander_valder'),
+        CommanderData('Ragna', 'commander_ragna'),
+        CommanderData('Sigrid', 'commander_sigrid')
+    ],
+    'Floran': [
+        CommanderData('Greenfinger', 'commander_greenfinger', 'Zawan'),
+        CommanderData('Sedge', 'commander_sedge'),
+        CommanderData('Nuru', 'commander_nuru')
+    ],
+    'Heavensong': [
+        CommanderData('Tenri', 'commander_tenri'),
+        CommanderData('Koji', 'commander_koji'),
+        CommanderData('Ryota', 'commander_ryota')
+    ],
+    'Requiem': [
+        CommanderData('Elodie', 'commander_elodie'),
+        CommanderData('Dark Mercia', 'commander_darkmercia')
+    ],
+    'Pirate': [
+        CommanderData('Wulfar', 'commander_wulfar_pirate'),
+        CommanderData('Twins', 'commander_twins', 'Errol & Orla'),
+        CommanderData('Vesper', 'commander_vesper'),
+        CommanderData('Nadia', 'commander_nadia')
+    ],
+    'Faahri': [
+        CommanderData('Lytra', 'commander_lytra'),
+        CommanderData('Pistil', 'commander_pistil'),
+        CommanderData('Rhomb', 'commander_rhomb')
+    ]
+}
+
+
+class Wargroove2Item(Item):
+    game = "Wargroove 2"
+
+    def __init__(self, name, player: int = None):
+        item_data = item_table[name]
+        super(Wargroove2Item, self).__init__(
+            name,
+            item_data.classification,
+            item_data.code,
+            player
+        )