raven

import chess

def simplify_fen_string(fen):
    parts = fen.split(' ')
    simplified_fen = ' '.join(parts[:4])  # Zachováváme pouze informace o pozici
    return simplified_fen

def evaluate_position(board):
    if board.is_checkmate():
        return -1000  # Mat protihráči
    elif board.is_stalemate() or board.is_insufficient_material() or board.can_claim_draw():
        return 0  # Remíza
    else:
        return None  # Hra pokračuje

# def update_AR_for_mate_in_k(board, AR, max_k=1000):
#     for k in range(1, max_k + 1):
#         changed = False
#         for fen in list(AR.keys()):
#             board.set_fen(fen)
#             if AR[fen] is not None:
#                 continue

#             position_evaluated = False
#             for move in board.legal_moves:
#                 board.push(move)
#                 next_fen = simplify_fen_string(board.fen())
#                 board.pop()

#                 if next_fen not in AR:
#                     AR[next_fen] = evaluate_position(board)

#                 next_eval = AR[next_fen]
#                 if next_eval is not None:
#                     if next_eval == -1000:
#                         # Pokud z některého tahu plyne mat, znamená to vítězství
#                         AR[fen] = 1000 - k
#                         changed = True
#                         position_evaluated = True
#                         break
#                     elif next_eval == 0:
#                         # Pokud je možná remíza, nastavíme hodnotu na 0
#                         AR[fen] = 0
#                         changed = True
#                         position_evaluated = True
#                         break

#             if not position_evaluated and AR[fen] is None:
#                 # Pokud není možné matovat nebo remizovat, značíme pozici jako -1000 + k
#                 AR[fen] = -1000 + k
#                 changed = True

#         if not changed:
#             break

# def update_AR_for_mate_in_k(board, AR, max_k=1000):
#     for k in range(1, max_k + 1):
#         for _ in range(2):  # Pro každé k provádíme aktualizaci dvakrát
#             changed = False
#             for fen in list(AR.keys()):
#                 board.set_fen(fen)
#                 if AR[fen] is not None:
#                     continue  # Tato pozice již byla ohodnocena

#                 position_evaluated = False
#                 for move in board.legal_moves:
#                     board.push(move)
#                     next_fen = simplify_fen_string(board.fen())
#                     board.pop()

#                     if next_fen not in AR:
#                         AR[next_fen] = evaluate_position(board)

#                     next_eval = AR[next_fen]
#                     if next_eval is not None:
#                         if next_eval == -1000:
#                             # Pokud z některého tahu plyne mat, znamená to vítězství
#                             AR[fen] = 1000 - k
#                             changed = True
#                             position_evaluated = True
#                             break
#                         elif next_eval == 0:
#                             # Pokud je možná remíza, nastavíme hodnotu na 0
#                             AR[fen] = 0
#                             changed = True
#                             position_evaluated = True
#                             break

#                 if not position_evaluated and AR[fen] is None:
#                     # Pokud není možné matovat nebo remizovat, značíme pozici jako -1000 + k
#                     AR[fen] = -1000 + k
#                     changed = True

#             if not changed:
#                 break  # Pokud nedošlo k žádné změně během obou iterací pro dané k, ukončíme smyčku

def update_AR_for_mate_in_k(board, AR, max_k=1000):
    for k in range(1, max_k + 1):
        changed = False
        for _ in range(2):  # Zajistíme, že pro každé k proběhne aktualizace dvakrát
            for fen in list(AR.keys()):
                board.set_fen(fen)

                if AR[fen] is not None:
                    continue  # Pokud již máme hodnocení, přeskočíme

                # Získáme výchozí hodnoty pro nejlepší a nejhorší scénář
                best_case = float("-inf")
                worst_case = float("inf")

                for move in board.legal_moves:
                    board.push(move)
                    next_fen = simplify_fen_string(board.fen())
                    board.pop()

                    if next_fen not in AR:
                        AR[next_fen] = evaluate_position(board)

                    next_eval = AR[next_fen]
                    if next_eval is not None:
                        best_case = max(best_case, next_eval)
                        worst_case = min(worst_case, next_eval)

                # Aktualizace hodnocení podle nejlepšího a nejhoršího scénáře
                if worst_case == -1000:
                    # Pokud všechny tahy vedou k matu, hráč na tahu může být matován v k tazích
                    AR[fen] = -1000 + k
                    changed = True
                elif best_case <= 0:
                    # Pokud nejlepší scénář není lepší než remíza, znamená to remízu nebo prohru
                    AR[fen] = max(best_case, 0)  # Zabráníme nastavení hodnoty méně než 0, pokud je remíza možná
                    changed = True
                elif best_case == 1000:
                    # Pokud existuje alespoň jeden tah, který vede k matu protihráče, hráč na tahu může vynutit mat v k tazích
                    AR[fen] = 1000 - k
                    changed = True

            if not changed:
                break  # Pokud nedošlo k žádné změně, ukončíme smyčku

        if not changed:
            break  # Ukončíme hlavní smyčku, pokud nedošlo ke změně v poslední iteraci


# def print_positions(AR):
#     for fen, value in AR.items():
#         if value < -990:
#             print(f"FEN: {fen}, Hodnota: {value}")

# def main():
#     initial_fen = "8/8/8/8/3Q4/5K2/8/4k3 w - - 0 1"
#     board = chess.Board(initial_fen)
#     AR = {simplify_fen_string(initial_fen): evaluate_position(board)}

#     update_AR_for_mate_in_k(board, AR, max_k=50)
#     print_positions(AR)

# main()

def print_draw_positions(AR):
    """
    Vytiskne všechny remízové pozice (hodnota 0) zaznamenané v slovníku AR.
    """
    print("Remízové pozice:")
    for fen, value in AR.items():
        if True or (value > 990 and value < 1000):
            print(f"FEN>: {fen}, Hodnota: {value}","\n",chess.Board(fen),"<\n")


def main():
    initial_fen = "8/8/8/8/3Q4/5K2/8/4k3 w - - 0 1"
    board = chess.Board(initial_fen)
    AR = {simplify_fen_string(initial_fen): None}  # Inicializace AR s počáteční pozicí

    update_AR_for_mate_in_k(board, AR, max_k=50)  # Aktualizace AR
    print_draw_positions(AR)



main()