Linting

board_possibilities.py

@@ -4,7 +4,9 @@ import board
 import board_actions
 
 
-def possible_huakill_action(search_board: board.Board) -> Iterator[board_actions.HuaKillAction]:
+def possible_huakill_action(
+    search_board: board.Board
+) -> Iterator[board_actions.HuaKillAction]:
     """Check if the flowercard can be eliminated"""
     for index, stack in enumerate(search_board.field):
         if stack[-1] == board.SpecialCard.Hua:
@@ -12,10 +14,14 @@ def possible_huakill_action(search_board: board.Board) -> Iterator[board_actions
 
 
 def possible_dragonkill_actions(
-        search_board: board.Board) -> Iterator[board_actions.DragonKillAction]:
+    search_board: board.Board
+) -> Iterator[board_actions.DragonKillAction]:
     """Enumerate all possible dragon kills"""
-    possible_dragons = [board.SpecialCard.Zhong,
-                        board.SpecialCard.Fa, board.SpecialCard.Bai]
+    possible_dragons = [
+        board.SpecialCard.Zhong,
+        board.SpecialCard.Fa,
+        board.SpecialCard.Bai,
+    ]
     if not any(x is None for x in search_board.bunker):
         new_possible_dragons = []
         for dragon in possible_dragons:
@@ -24,10 +30,10 @@ def possible_dragonkill_actions(
         possible_dragons = new_possible_dragons
 
     for dragon in possible_dragons:
-        bunker_dragons = [i for i, d in enumerate(
-            search_board.bunker) if d == dragon]
-        field_dragons = [i for i, f in enumerate(
-            search_board.field) if f if f[-1] == dragon]
+        bunker_dragons = [i for i, d in enumerate(search_board.bunker) if d == dragon]
+        field_dragons = [
+            i for i, f in enumerate(search_board.field) if f if f[-1] == dragon
+        ]
         if len(bunker_dragons) + len(field_dragons) != 4:
             continue
         destination_bunker_id = 0
@@ -35,20 +41,24 @@ def possible_dragonkill_actions(
             destination_bunker_id = bunker_dragons[0]
         else:
             destination_bunker_id = [
-                i for i, x in enumerate(search_board.bunker) if x is None][0]
+                i for i, x in enumerate(search_board.bunker) if x is None
+            ][0]
 
         source_stacks = [(board.Position.Bunker, i) for i in bunker_dragons]
-        source_stacks.extend([(board.Position.Field, i)
-                              for i in field_dragons])
+        source_stacks.extend([(board.Position.Field, i) for i in field_dragons])
 
-        yield board_actions.DragonKillAction(dragon=dragon, source_stacks=source_stacks,
-                                             destination_bunker_id=destination_bunker_id)
+        yield board_actions.DragonKillAction(
+            dragon=dragon,
+            source_stacks=source_stacks,
+            destination_bunker_id=destination_bunker_id,
+        )
 
 
-def possible_bunkerize_actions(search_board: board.Board) -> Iterator[board_actions.StoreAction]:
+def possible_bunkerize_actions(
+    search_board: board.Board
+) -> Iterator[board_actions.BunkerizeAction]:
     """Enumerates all possible card moves from the field to the bunker"""
-    open_bunker_list = [i for i, x in enumerate(
-        search_board.bunker) if x is None]
+    open_bunker_list = [i for i, x in enumerate(search_board.bunker) if x is None]
 
     if not open_bunker_list:
         return
@@ -57,16 +67,20 @@ def possible_bunkerize_actions(search_board: board.Board) -> Iterator[board_acti
     for index, stack in enumerate(search_board.field):
         if not stack:
             continue
-        yield board_actions.StoreAction(card=stack[-1],
-                                        source_id=index,
-                                        destination_id=open_bunker)
+        yield board_actions.BunkerizeAction(
+            card=stack[-1], source_id=index, destination_id=open_bunker, to_bunker=True
+        )
 
 
 def possible_debunkerize_actions(
-        search_board: board.Board) -> Iterator[board_actions.RestoreAction]:
+    search_board: board.Board
+) -> Iterator[board_actions.BunkerizeAction]:
     """Enumerates all possible card moves from the bunker to the field"""
-    bunker_number_cards = [(i, x) for i, x in enumerate(
-        search_board.bunker) if isinstance(x, board.NumberCard)]
+    bunker_number_cards = [
+        (i, x)
+        for i, x in enumerate(search_board.bunker)
+        if isinstance(x, board.NumberCard)
+    ]
     for index, card in bunker_number_cards:
         for other_index, other_stack in enumerate(search_board.field):
             if not other_stack:
@@ -77,29 +91,41 @@ def possible_debunkerize_actions(
                 continue
             if other_stack[-1].number != card.number + 1:
                 continue
-            yield board_actions.RestoreAction(card=card,
-                                              source_id=index,
-                                              destination_id=other_index)
+            yield board_actions.BunkerizeAction(
+                card=card, source_id=index, destination_id=other_index, to_bunker=False
+            )
 
 
-def possible_goal_move_actions(search_board: board.Board) -> Iterator[board_actions.GoalAction]:
+def possible_goal_move_actions(
+    search_board: board.Board
+) -> Iterator[board_actions.GoalAction]:
     """Enumerates all possible moves from anywhere to the goal"""
-    field_cards = [(board.Position.Field, index, stack[-1]) for index, stack in enumerate(
-        search_board.field) if stack if isinstance(stack[-1], board.NumberCard)]
-    bunker_cards = [(board.Position.Bunker, index, stack)
-                    for index, stack in enumerate(search_board.bunker)
-                    if isinstance(stack, board.NumberCard)]
+    field_cards = [
+        (board.Position.Field, index, stack[-1])
+        for index, stack in enumerate(search_board.field)
+        if stack
+        if isinstance(stack[-1], board.NumberCard)
+    ]
+    bunker_cards = [
+        (board.Position.Bunker, index, stack)
+        for index, stack in enumerate(search_board.bunker)
+        if isinstance(stack, board.NumberCard)
+    ]
     top_cards = field_cards + bunker_cards
 
     for suit, number in search_board.goal.items():
         for source, index, stack in top_cards:
             if not (stack.suit == suit and stack.number == number + 1):
                 continue
-            yield board_actions.GoalAction(card=stack, source_id=index, source_position=source)
+            yield board_actions.GoalAction(
+                card=stack, source_id=index, source_position=source
+            )
         break
 
 
-def possible_field_move_actions(search_board: board.Board) -> Iterator[board_actions.MoveAction]:
+def possible_field_move_actions(
+    search_board: board.Board
+) -> Iterator[board_actions.MoveAction]:
     """Enumerate all possible move actions from one field stack to another field stack"""
     for index, stack in enumerate(search_board.field):
         if not stack:
@@ -107,17 +133,16 @@ def possible_field_move_actions(search_board: board.Board) -> Iterator[board_act
         if not isinstance(stack[-1], board.NumberCard):
             continue
         for other_index, other_stack in enumerate(search_board.field):
-            if not other_stack:
-                continue
-            if not isinstance(other_stack[-1], board.NumberCard):
-                continue
-            if other_stack[-1].suit == stack[-1].suit:
-                continue
-            if other_stack[-1].number != stack[-1].number + 1:
-                continue
-            yield board_actions.MoveAction(card=stack[-1],
-                                           source_id=index,
-                                           destination_id=other_index)
+            if other_stack:
+                if not isinstance(other_stack[-1], board.NumberCard):
+                    continue
+                if other_stack[-1].suit == stack[-1].suit:
+                    continue
+                if other_stack[-1].number != stack[-1].number + 1:
+                    continue
+            yield board_actions.MoveAction(
+                cards=[stack[-1]], source_id=index, destination_id=other_index
+            )
 
 
 def possible_actions(search_board: board.Board) -> Iterator[board_actions.Action]: