ChecksMate: implement new game

docs/CODEOWNERS

@@ -31,6 +31,9 @@
 # ChecksFinder
 /worlds/checksfinder/ @jonloveslegos
 
+# ChecksMate Chess
+/worlds/checksmate/ @chesslogic
+
 # Clique
 /worlds/clique/ @ThePhar
 

worlds/checksmate/Items.py

@@ -0,0 +1,105 @@
+import math
+from typing import Dict, NamedTuple, Optional
+
+from BaseClasses import Item, ItemClassification
+
+
+class CMItem(Item):
+    game: str = "ChecksMate"
+
+
+class CMItemData(NamedTuple):
+    code: Optional[int]
+    classification: ItemClassification
+    quantity: float = 1 # maximum, not guaranteed
+    material: int = 0 # pawns=2, minor=6, major=10, queen=18 - doubled to account for 0.5 values
+    parents: list[str] = None
+
+
+item_table = {
+    "Play as White": CMItemData(4_901_000, ItemClassification.progression, material=50),
+    "Progressive Engine ELO Lobotomy": CMItemData(4_901_001, ItemClassification.useful, quantity=5),
+    # TODO: stop counting material if the board fills up with 23 pieces+pawns
+    "Progressive Pawn": CMItemData(4_901_002, ItemClassification.progression, quantity=14, material=100),
+    "Progressive Pawn Forwardness": CMItemData(4_901_003, ItemClassification.filler, quantity=4, parents=["Progressive Pawn"]),
+    # Bishops and Knights are worth 3.25 to 3.5, but some minor pieces are worse, so we assume 3.0 conservatively
+    "Progressive Minor Piece": CMItemData(4_901_004, ItemClassification.progression, quantity=9, material=300),
+    # Rooks are worth 5.25 to 5.5, but many major pieces are worse, so we assume 4.85, which stays under 5.0
+    "Progressive Major Piece": CMItemData(4_901_005, ItemClassification.progression, quantity=9, material=485),
+    # Queen pieces are pretty good, and even the weak ones are pretty close, so queens can stay 9.0 (but not 10.0)
+    "Progressive Major To Queen": CMItemData(4_901_006, ItemClassification.progression, quantity=5, material=415,
+                                             parents=["Progressive Major Piece"]),
+    "Victory": CMItemData(4_901_009, ItemClassification.progression),
+    # TODO: implement extra moves
+    # "Progressive Enemy Pawn": CMItemData(4_907, ItemClassification.trap, quantity=8),
+    # "Progressive Enemy Piece": CMItemData(4_908, ItemClassification.trap, quantity=7),
+    # "Progressive Opening Move": CMItemData(4_010, ItemClassification.useful, quantity=3),
+
+    # Players have 3 pockets, which can be empty, or hold a pawn, minor piece, major piece, or queen.
+    # Collected pocket items are distributed randomly to the 3 pockets in the above order.
+    # Pocket pawns are playable onto home row instead of making a move
+    # Pocket pieces start as minor pieces (e.g. Knight) - they upgrade in both Gem cost and type
+    # Piece upgrades turn minor pieces into major pieces or major pieces into Queen - implementation may decide
+    "Progressive Pocket": CMItemData(4_901_020, ItemClassification.progression, quantity=12, material=100),
+
+    # Gems are a way to generate filler items and limit use of Pocket items
+    # Gems are generated 1/turn and Pocket pieces cost 1 Gem per their material value
+    # Turn off Pocket entirely to hide this item. Also you can't or generation will fail EleGiggle
+    # WARNING: Do not set all your filler items to local_only or generation will fail
+    "Progressive Pocket Gems": CMItemData(4_901_023, ItemClassification.filler, quantity=math.inf),
+    # Allows the player to deploy pocket items one rank further from the home row, but not the opponent's home row
+    # WARNING: Do not set all your filler items to local_only or generation will fail
+    "Progressive Pocket Range": CMItemData(4_901_024, ItemClassification.filler, quantity=6),
+
+    "Progressive King Promotion": CMItemData(4_901_025, ItemClassification.progression, quantity=2, material=300),
+    "Progressive Consul": CMItemData(4_901_026, ItemClassification.progression, quantity=2, material=300),
+
+    "Enemy Pawn A": CMItemData(4_901_030, ItemClassification.progression),
+    "Enemy Pawn B": CMItemData(4_901_031, ItemClassification.progression),
+    "Enemy Pawn C": CMItemData(4_901_032, ItemClassification.progression),
+    "Enemy Pawn D": CMItemData(4_901_033, ItemClassification.progression),
+    "Enemy Pawn E": CMItemData(4_901_034, ItemClassification.progression),
+    "Enemy Pawn F": CMItemData(4_901_035, ItemClassification.progression),
+    "Enemy Pawn G": CMItemData(4_901_036, ItemClassification.progression),
+    "Enemy Pawn H": CMItemData(4_901_037, ItemClassification.progression),
+    "Enemy Piece A": CMItemData(4_901_038, ItemClassification.progression),
+    "Enemy Piece B": CMItemData(4_901_039, ItemClassification.progression),
+    "Enemy Piece C": CMItemData(4_901_040, ItemClassification.progression),
+    "Enemy Piece D": CMItemData(4_901_041, ItemClassification.progression),
+    "Enemy Piece F": CMItemData(4_901_042, ItemClassification.progression),
+    "Enemy Piece G": CMItemData(4_901_043, ItemClassification.progression),
+    "Enemy Piece H": CMItemData(4_901_044, ItemClassification.progression),
+    # TODO: implement castling rule & guarantee major piece on that side for Locations
+    # "Play 00 Castle": CMItemData(4_010, ItemClassification.progression),
+    # "Play 000 Castle": CMItemData(4_011, ItemClassification.progression),
+    # TODO: consider breaking passant into individual pawns, or progressive for outer..center pawns
+    # "Play En Passant": CMItemData(4_012, ItemClassification.progression),
+
+    # == Possible pocket implementation ==
+    # "Progressive Pocket Pawn": CMItemData(4_021, ItemClassification.progression, quantity=3, material=90),
+    # "Progressive Pocket Pawn to Piece": CMItemData(4_022, ItemClassification.progression, quantity=3, material=190,
+    #                                               parents=["Progressive Pocket Pawn"]),
+    # "Progressive Pocket Piece Promotion": parents=["Progressive Pocket Pawn to Piece",
+    #          "Progressive Pocket Pawn"]),
+    # == End possible pocket implementation ==
+}
+
+lookup_id_to_name: Dict[int, str] = {data.code: item_name for item_name, data in item_table.items() if data.code}
+
+
+material_items: Dict[str, CMItemData] = {
+    item: item_data for (item, item_data) in item_table.items() if item_data.material > 0}
+progression_items: Dict[str, CMItemData] = {
+    item: item_data for (item, item_data) in item_table.items() if item_data.classification == ItemClassification.progression}
+useful_items: Dict[str, CMItemData] = {
+    item: item_data for (item, item_data) in item_table.items() if item_data.classification == ItemClassification.useful}
+filler_items: Dict[str, CMItemData] = {
+    item: item_data for (item, item_data) in item_table.items() if item_data.classification == ItemClassification.filler}
+
+
+def create_item_with_correct_settings(player: int, name: str) -> Item:
+    data = item_table[name]
+
+    item = Item(name, data.classification, data.code, player)
+
+    return item

worlds/checksmate/Locations.py

@@ -0,0 +1,102 @@
+from typing import Dict, NamedTuple, Optional
+
+from BaseClasses import Location
+
+
+class CMLocation(Location):
+    game: str = "ChecksMate"
+
+
+class CMLocationData(NamedTuple):
+    code: Optional[int]
+    capture: bool
+    difficult: bool
+
+
+location_table = {
+    # capture individual pieces and pawns
+    "Capture Pawn A": CMLocationData(4_902_000, True, False),
+    "Capture Pawn B": CMLocationData(4_902_001, True, False),
+    "Capture Pawn C": CMLocationData(4_902_002, True, False),
+    "Capture Pawn D": CMLocationData(4_902_003, True, False),
+    "Capture Pawn E": CMLocationData(4_902_004, True, False),
+    "Capture Pawn F": CMLocationData(4_902_005, True, False),
+    "Capture Pawn G": CMLocationData(4_902_006, True, False),
+    "Capture Pawn H": CMLocationData(4_902_007, True, False),
+    "Capture Piece A": CMLocationData(4_902_008, True, False),
+    "Capture Piece B": CMLocationData(4_902_010, True, False),
+    "Capture Piece C": CMLocationData(4_902_012, True, False),
+    "Capture Piece D": CMLocationData(4_902_014, True, False),
+    "Capture Piece F": CMLocationData(4_902_013, True, False),
+    "Capture Piece G": CMLocationData(4_902_011, True, False),
+    "Capture Piece H": CMLocationData(4_902_009, True, False),
+    # some first locations
+    # for strategic analysis see: https://en.wikipedia.org/wiki/Bongcloud_Attack
+    "Bongcloud Once": CMLocationData(4_902_015, True, False),
+    "Bongcloud Center": CMLocationData(4_902_016, True, False),
+    "Bongcloud A File": CMLocationData(4_902_017, True, False),
+    "Bongcloud Capture": CMLocationData(4_902_018, True, False),
+    "Bongcloud Promotion": CMLocationData(4_902_019, True, False),
+    # capture series of pieces and pawns within 1 game
+    "Capture 2 Pawns": CMLocationData(4_902_020, True, False),
+    "Capture 3 Pawns": CMLocationData(4_902_021, True, False),
+    "Capture 4 Pawns": CMLocationData(4_902_022, True, False),
+    "Capture 5 Pawns": CMLocationData(4_902_023, True, False),
+    "Capture 6 Pawns": CMLocationData(4_902_024, True, False),
+    "Capture 7 Pawns": CMLocationData(4_902_025, True, False),
+    "Capture 8 Pawns": CMLocationData(4_902_026, True, False),
+    "Capture 2 Pieces": CMLocationData(4_902_027, True, False),
+    "Capture 3 Pieces": CMLocationData(4_902_028, True, False),
+    "Capture 4 Pieces": CMLocationData(4_902_029, True, False),
+    "Capture 5 Pieces": CMLocationData(4_902_030, True, False),
+    "Capture 6 Pieces": CMLocationData(4_902_031, True, False),
+    "Capture 7 Pieces": CMLocationData(4_902_032, True, False),
+    "Capture 2 Of Each": CMLocationData(4_902_033, True, False),
+    "Capture 3 Of Each": CMLocationData(4_902_034, True, False),
+    "Capture 4 Of Each": CMLocationData(4_902_035, True, False),
+    "Capture 5 Of Each": CMLocationData(4_902_036, True, False),
+    "Capture 6 Of Each": CMLocationData(4_902_037, True, False),
+    "Capture 7 Of Each": CMLocationData(4_902_038, True, False),
+    "Capture Everything": CMLocationData(4_902_039, True, False),
+    "Threaten Pawn": CMLocationData(4_902_040, True, False),
+    "Threaten Minor": CMLocationData(4_902_041, True, False),
+    "Threaten Major": CMLocationData(4_902_042, True, False),
+    "Threaten Queen": CMLocationData(4_902_043, True, False),
+    "Threaten King": CMLocationData(4_902_044, True, False),
+    # special moves and tactics
+    # TODO: Getting a french move on the AI seems nigh impossible - maybe I can tweak the evaluation or something
+    # "French Move": CMLocationData(4_902_050, True, False),
+    # "Discovered Attack": CMLocationData(4_902_051, True, False),
+    "Fork, Sacrificial": CMLocationData(4_902_052, True, False),
+    "Fork, Sacrificial Triple": CMLocationData(4_902_053, True, False),
+    "Fork, Sacrificial Royal": CMLocationData(4_902_054, True, True),
+    "Fork, True": CMLocationData(4_902_055, True, False),
+    "Fork, True Triple": CMLocationData(4_902_056, True, False),
+    "Fork, True Royal": CMLocationData(4_902_057, True, True),
+    # TODO: prevent castle from holding enemy pieces (progression item) in case of "Oops all queens."
+    "O-O Castle": CMLocationData(4_902_058, True, False),
+    "O-O-O Castle": CMLocationData(4_902_059, True, False),
+    # "Discovered Attack": CMLocationData(4_902_060, True, False),
+    # "Pin": CMLocationData(4_902_061, True, False),
+    # "Skewer": CMLocationData(4_902_062, True, False),
+    # goal 1+ requires that you successively checkmate your opponent as they gain material
+    # "Checkmate Minima": CMLocationData(4_902_084, True, False),
+    # "Checkmate One Piece": CMLocationData(4_902_085, True, False),
+    # "Checkmate 2 Pieces": CMLocationData(4_902_086, True, False),
+    # "Checkmate 3 Pieces": CMLocationData(4_902_087, True, False),
+    # "Checkmate 4 Pieces": CMLocationData(4_902_088, True, False),
+    # "Checkmate 5 Pieces": CMLocationData(4_902_089, True, False),
+    # "Checkmate 6 Pieces": CMLocationData(4_902_090, True, False),
+    # "Checkmate 7 Pieces": CMLocationData(4_902_091, True, False),
+    # "Checkmate 8 Pieces": CMLocationData(4_902_092, True, False),
+    # "Checkmate 9 Pieces": CMLocationData(4_902_093, True, False),
+    # "Checkmate 10 Pieces": CMLocationData(4_902_094, True, False),
+    # "Checkmate 11 Pieces": CMLocationData(4_902_095, True, False),
+    # "Checkmate 12 Pieces": CMLocationData(4_902_096, True, False),
+    # "Checkmate 13 Pieces": CMLocationData(4_902_097, True, False),
+    # "Checkmate 14 Pieces": CMLocationData(4_902_098, True, False),
+    "Checkmate Maxima": CMLocationData(4_902_099, True, False),
+
+}
+
+lookup_id_to_name: Dict[int, str] = {data.code: item_name for item_name, data in location_table.items() if data.code}