Untitled

import json
import re

def generate_prediction_grid(websocket_message):
    try:
        # Rimuove il prefisso "4" e pulisce il messaggio
        if websocket_message.startswith('4'):
            trimmed_message = websocket_message[1:]
            
            # Sostituisci i valori non quotati con stringhe quotate
            trimmed_message = re.sub(r':(\w+),', r':"\1",', trimmed_message)
            trimmed_message = re.sub(r':(\w+)}', r':"\1"}', trimmed_message)
            trimmed_message = re.sub(r'([{,])(\w+):', r'\1"\2":', trimmed_message)
            
            data = json.loads(trimmed_message)
        else:
            data = json.loads(websocket_message)

        # Estrai il valore p2w dal messaggio
        p2w = data.get("BvNw", [{}])[0].get("O_9H", {}).get("p2w", "")
        
        # Crea la griglia di predizione
        prediction_grid = []
        for i in range(5):
            row = []
            for j in range(5):
                idx = i * 5 + j
                if idx < len(p2w):
                    val = ord(p2w[idx]) % 3
                    if val == 0:
                        row.append('B')
                    else:
                        row.append('C')
                else:
                    row.append('C')
            prediction_grid.append(row)

        # Stampa la griglia di predizione
        print("\nPrediction Grid (le mine saranno una posizione avanti):")
        for row in prediction_grid:
            print("[ " + ", ".join(row) + " ]")

        # Crea la griglia reale spostando le mine di una posizione in avanti
        real_grid = [['C' for _ in range(5)] for _ in range(5)]
        
        # Trova tutte le posizioni delle mine nella griglia di predizione
        mine_positions = []
        for i in range(5):
            for j in range(5):
                if prediction_grid[i][j] == 'B':
                    pos = i * 5 + j
                    mine_positions.append(pos)

        # Sposta ogni mina una posizione in avanti nella griglia reale
        for pos in mine_positions:
            next_pos = (pos + 1) % 25  # Wrap around alla posizione 0 se necessario
            real_row = next_pos // 5
            real_col = next_pos % 5
            real_grid[real_row][real_col] = 'B'

        print("\nReal Grid (mine spostate una posizione avanti):")
        for row in real_grid:
            print("[ " + ", ".join(row) + " ]")
        
        return real_grid

    except json.JSONDecodeError as e:
        print(f"Error processing the WebSocket message: {e}")
        print(f"Message: {websocket_message}")
        return None
    except Exception as e:
        print(f"General error: {e}")
        return None

def handle_websocket_message():
    try:
        message = input("Inserisci il messaggio WebSocket: ")
        grid = generate_prediction_grid(message)
        
        if grid:
            # Calcola le posizioni sicure (dove c'è 'C')
            safe_positions = []
            for i in range(5):
                for j in range(5):
                    if grid[i][j] == 'C':
                        position = i * 5 + j
                        safe_positions.append(position)
            
            print(f"\nPosizioni sicure: {sorted(safe_positions)}")
            return safe_positions

    except Exception as e:
        print(f"Errore: {e}")
        return None

if __name__ == "__main__":
    handle_websocket_message()