project2.py

########################################### Minesweeper ###############################################

def letras_possiveis():
    '''
    Esta função retorna todos os caracteres maiúsculos válidos para este projeto

       -> str
    '''
    
    return 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'

#TAD Gerador

def cria_gerador(b,s):
    '''
    Construtor do TAD Gerador
    Esta função recebe um inteiro correspondente ao número de bits
    do gerador e um inteiro correspondente ao estado inicial,
    e devolve o gerador correspondente em forma de dicionário

    int x int -> dict (correspondente a um gerador)
    '''

    if b in (32,64) and type(b) == int and type(s) == int and s > 0 and s < 2**b:
        return {'bits': b, 'estado': s}
    else:
        raise ValueError ('cria_gerador: argumentos invalidos')

def cria_copia_gerador(g):
    '''
    Construtor do TAD Gerador
    Esta função recebe um gerador e cria uma cópia com forma igual ao do gerador e devolve essa cópia

    dict (correspondente a um gerador) -> dict (correspondente a um gerador)
    '''

    return {'bits': g['bits'],'estado':g['estado']}

def obtem_estado(g):
    '''
    Seletor do TAD Gerador
    Esta função recebe um gerador e devolve o estado atual do gerador

    dict (correspondente a um gerador) -> int
    '''

    return g['estado']

def obtem_bits(g):
    '''
    Esta função recebe um gerador e devolve o número de bits do gerador

    dict (correspondente a um gerador) -> int
    '''
    
    return g['bits']

def define_estado(g,s):
    '''
    Modificador do TAD Gerador
    Esta função recebe um gerador e um inteiro correspondente a um estado e altera o estado do gerador e retorna o novo estado

    dict (correspondente a um gerador) x int -> int
    '''

    g['estado'] = s

    return g['estado']

def atualiza_estado(g):
    '''
    Modificador do TAD Gerador
    Esta função recebe um gerador e atualiza o seu estado usando um algoritmo xorshift (pseudoaleatório)

    dict (correspondente a um gerador) -> int
    '''

    s = obtem_estado(g)

    if obtem_bits(g) == 32:
        s ^= (s << 13) & (0xFFFFFFFF)
        s ^= (s >> 17) & (0xFFFFFFFF)
        s ^= (s << 5) & (0xFFFFFFFF)

        g['estado'] = s

    elif obtem_bits(g) == 64:
        s ^= (s << 13) & (0xFFFFFFFFFFFFFFFF)
        s ^= (s >> 7) & (0xFFFFFFFFFFFFFFFF)
        s ^= (s << 17) & (0xFFFFFFFFFFFFFFFF)

        g['estado'] = s
    
    return g['estado']

def eh_gerador(arg):
    '''
    Reconhecedor do TAD Gerador
    Esta função recebe um argumento e verifica se ele é gerador, retornando True se isto for verdade e False em caso contrário

    any -> bool
    '''

    if isinstance(arg,dict) and len(arg) == 2 and arg['estado'] > 0 and arg['estado'] < 2**arg['bits'] and \
        isinstance(arg['estado'],int) and arg['bits'] in (32,64) and isinstance(arg['bits'],int):
            return True

    return False

def geradores_iguais(g1,g2):
    '''
    Teste do TAD Gerador
    Esta função recebe dois geradores e compara-os, retornando True se forem iguais e False em caso contrário

    dict (correspondente a um gerador) x dict (correspondente a um gerador) -> bool
    '''

    if eh_gerador(g1) and eh_gerador(g2) and obtem_estado(g1) == obtem_estado(g2)\
        and obtem_bits(g1) == obtem_bits(g2):
            return True

    return False

def gerador_para_str(g):
    '''
    Transformador do TAD Gerador
    Esta função recebe um gerador e devolve a cadeia de caracteres representando o seu argumento

    dict (correspondente a um gerador) -> str
    '''
    
    return 'xorshift{0}(s={1})'.format(obtem_bits(g),obtem_estado(g))    

def gera_numero_aleatorio(g,n):
    '''
    Função de alto nível associada ao TAD Gerador
    Esta função recebe um gerador e um inteiro n e devolve um número aleatório entre 1 e n, da seguinte forma:
    Obtido a partir do novo estado do gerador, seguindo o algoritmo xorshift, como 1 + resto da divisão do estado por n

    dict (correspondente a um gerador) x int -> int
    '''

    g['estado'] = atualiza_estado(g)

    return 1 + (g['estado'] % n)


def gera_carater_aleatorio(g,c):
    '''
    Função de alto nível associada ao TAD Gerador
    Esta função recebe um gerador e um carácter c e devolve um carácter maiúsculo aleatório entre 'A' e c, da seguinte forma:
    Obtido a partir do novo estado do gerador, seguindo o algoritmo xorshift, como o carácter na posição do resto da divisão
    do estado por l, tamanho da cadeia de caracteres formada por todos os caracteres entre 'A' e c

    dict (correspondente a um gerador) x str -> str
    '''
    
    g['estado'] = atualiza_estado(g)

    return chr((g['estado'] % (ord(c) - ord('A') + 1)) + 65)

#TAD Coordenada#

def cria_coordenada(col,lin):
    '''
    Construtor do TAD Coordenada
    Esta função recebe uma cadeia de caracteres e um inteiro e devolve um tuplo formado pelos dois, que corresponde a uma coordenada

    str x int -> tuple (correspondente a uma coordenada)
    '''

    if isinstance(lin,int) and lin > 0 and lin <= 99 and isinstance(col,str) and len(col) == 1 and col in letras_possiveis():

        return (col,lin)
    
    else:
        raise ValueError('cria_coordenada: argumentos invalidos')

def obtem_coluna(coord):
    '''
    Seletor do TAD Coordenada
    Esta função recebe uma coordenada e retorna a cadeia de caracteres da coordenada

    tuple (correspondente a uma coordenada) -> str
    '''
    
    return coord[0]

def obtem_linha(coord):
    '''
    Seletor do TAD Coordenada
    Esta função recebe uma coordenada e retorna o interio da coordenada

    tuple (correspondente a uma coordenada) -> int
    '''
    return coord[1]

def eh_coordenada(arg):
    '''
    Reconhecedor do TAD Coordenada
    Esta função recebe um argumento e verifica se ele é coordenada, retornando True ou False em caso contrário

    any -> bool
    '''

    if isinstance(arg,tuple) and isinstance(obtem_linha(arg),int) and obtem_linha(arg) > 0 and \
        obtem_linha(arg) <= 99 and isinstance(obtem_coluna(arg),str) \
            and obtem_coluna(arg) in letras_possiveis():
            
                return True
    
    return False

def coordenadas_iguais(coord1,coord2):
    '''
    Teste do TAD Coordenada
    Esta função recebe duas coordenadas e verifica se são iguais, retornando True ou False em caso contrário

    tuple (correspondente a uma coordenada) x tuple (correspondente a uma coordenada) -> bool
    '''

    if eh_coordenada(coord1) and eh_coordenada(coord2) and obtem_coluna(coord1) \
        == obtem_coluna(coord2) and obtem_linha(coord1) == obtem_linha(coord2):

            return True

    return False

def coordenada_para_str(coord):
    '''
    Transformador do TAD Coordenada
    Esta função recebe uma coordenada e devolve a coordenada em forma de cadeia de caracteres

    tuple (correspondente a uma coordenada) -> str
    '''

    return '{}{}'.format(obtem_coluna(coord), str(obtem_linha(coord)).zfill(2)) #zfill para preencher a string com um 0 à esquerda se necessário

def str_para_coordenada(string):
    '''
    Transformador do TAD Coordenada
    Esta função recebe uma cadeia de caracteres e devolve a cadeia em forma de coordenada

    str -> tuple (correspondente a uma coordenada)
    '''

    col = string[0]

    return cria_coordenada(col,int(string[1:]))#Separa a string em dois, para obter a coordenada

def obtem_coordenadas_vizinhas(coord):
    '''
    Função de alto nível associada ao TAD Coordenada
    Esta função recebe uma coordenada e retorna um tuplo com todas as coordenadas vizinhas, seguindo a ordem do relógio, começando pela
    coordenada superior esquerda

    tuple (correspondente a uma coordenada) -> tuple
    '''
    
    lin = obtem_linha(coord)
    col = obtem_coluna(coord)
    vizinhas = ()

    if lin >= 2: #para fazer por ordem, seguindo a ordem de 1º-diagonal acima-esquerda e depois segue a ordem do relógio
        if col >= 'B':#se fosse 'A' as da coluna à esquerda não existem, logo iria dar erro
            vizinhas += (cria_coordenada(chr(ord(col) - 1),lin - 1),)
        vizinhas += (cria_coordenada(col, lin - 1),)
        if col <= 'Y':
            vizinhas += (cria_coordenada(chr(ord(col) + 1),lin - 1),)
    if col <= 'Y':
        vizinhas += (cria_coordenada(chr(ord(col) + 1),lin),)
        if lin <= 98:
            vizinhas += (cria_coordenada(chr(ord(col) + 1),lin + 1),)
    if lin <= 98:
        vizinhas += (cria_coordenada(col,lin + 1),)
        if col >= 'B':
            vizinhas += (cria_coordenada(chr(ord(col) - 1),lin + 1),)
    if col >= 'B':
        vizinhas += (cria_coordenada(chr(ord(col) - 1),lin),)

    return vizinhas

def obtem_coordenada_aleatoria(coord,g): 
    '''
    Função de alto nível associada ao TAD Coordenada
    Esta função recebe uma coordenada e um gerador, e usando o algoritmo xorshift retorna uma coordenada aleatória

    tuple (correspondente a uma coordenada) x dict (correspondente a um gerador) -> tuple (correspondente a uma coordenada)
    '''
    col = obtem_coluna(coord)
    lin = obtem_linha(coord)

    return (cria_coordenada(gera_carater_aleatorio(g,col),gera_numero_aleatorio(g,lin)))

#TAD Parcela

def cria_parcela():
    '''
    Construtor do TAD Parcela
    Esta função não recebe argumentos e devolve uma parcela com estado tapada e sem mina('mina': nope ) em forma de dicionário

    -> dict (correspondente a uma parcela)
    '''
    return {'estado': 'tapada', 'mina': 'nope'}

def cria_copia_parcela(parcela):
    '''
    Construtor do TAD Parcela
    Esta função recebe uma parcela e cria uma cópia com forma igual à da parcela

    dict (correspondente a uma parcela) -> dict (correspondente a uma parcela)
    '''

    return {'estado': parcela['estado'], 'mina': parcela['mina']}

def limpa_parcela(parcela):
    '''
    Modificador do TAD Parcela
    Esta função recebe uma parcela, modifica o seu estado para limpa e devolve a parcela

    dict (correspondente a uma parcela) -> dict (correspondente a uma parcela)
    '''

    parcela['estado'] = 'limpa'

    return parcela

def marca_parcela(parcela):
    '''
    Modificador do TAD Parcela
    Esta função recebe uma parcela, modifica o seu estado para marcada e devolve a parcela

    dict (correspondente a uma parcela) -> dict (correspondente a uma parcela)
    '''

    parcela['estado'] = 'marcada'

    return parcela

def desmarca_parcela(parcela):
    '''
    Modificador do TAD Parcela
    Esta função recebe uma parcela, modifica o seu estado para tapada e devolve a parcela

    dict (correspondente a uma parcela) -> dict (correspondente a uma parcela)
    '''

    parcela['estado'] = 'tapada'

    return parcela

def esconde_mina(parcela):
    '''
    Modificador do TAD Parcela
    Esta função recebe uma parcela, esconde uma mina(mudando 'mina' para sim) e devolve a parcela

    dict (correspondente a uma parcela) -> dict (correspondente a uma parcela)
    '''

    parcela['mina'] = 'sim'

    return parcela

def eh_parcela(arg):
    '''
    Reconhecedor do TAD Parcela
    Esta função recebe um argumento e verifica se é uma parcela, retornando True ou False em caso contrário

    any -> bool
    '''
    
    if type(arg) == dict and len(arg) == 2 and 'estado' in arg \
        and 'mina' in arg and arg['estado'] in ('tapada', 'limpa', 'marcada')\
            and arg['mina'] in ('sim', 'nope'):
                
                return True
    
    return False

def eh_parcela_tapada(arg):
    '''
    Reconhecedor do TAD Parcela
    Esta função recebe uma parcela e verifica se o seu estado é tapada, retornando True ou False em caso contrário
    dict (correspondente a uma parcela) -> bool
    '''

    if eh_parcela(arg) and arg['estado'] == 'tapada':

        return True
    
    return False

def eh_parcela_marcada(arg):
    '''
    Reconhecedor do TAD Parcela
    Esta função recebe uma parcela e verifica se o seu estado é marcada, retornando True ou False em caso contrário

    dict (correspondente a uma parcela) -> bool
    '''

    if eh_parcela(arg) and arg['estado'] == 'marcada':

        return True

    return False

def eh_parcela_limpa(arg):
    '''
    Reconhecedor do TAD Parcela
    Esta função recebe uma parcela e verifica se o seu estado é limpa, retornando True ou False em caso contrário

    dict (correspondente a uma parcela) -> bool
    '''

    if eh_parcela(arg) and arg['estado'] == 'limpa':

        return True

    return False

def eh_parcela_minada(arg):
    '''
    Reconhecedor do TAD Parcela
    Esta função recebe uma parcela e verifica se tem mina, retornando True ou False em caso contrário

    dict (correspondente a uma parcela) -> bool
    '''

    if eh_parcela(arg) and arg['mina'] == 'sim':
        
        return True

    return False

def parcelas_iguais(parcela1, parcela2):
    '''
    Teste do TAD Parcela
    Esta função recebe duas parcelas e verificas se são iguais, retornando True ou Falso em caso contrário

    dict (correspondente a uma parcela) x dict (correspondente a uma parcela) -> bool
    '''

    if eh_parcela(parcela1) and eh_parcela(parcela2):
        if parcela1['estado'] == parcela2['estado'] and parcela1['mina'] == parcela2['mina']:
            
            return True

    return False

def parcela_para_str(parcela):
    '''
    Transformador do TAD Parcela
    Esta função recebe uma parcela e retorna a cadeia de caracteres correspondente
    Tapada = '#', Marcada = '@', Limpa sem mina = '?', Limpa com mina = 'X'

    dict (correspondente a uma parcela) -> str
    '''
    
    associacao = {'tapada': '#', 'marcada' : '@', 'limpa' : ('?', 'X')}

    if parcela['estado'] in associacao:
        if not eh_parcela_limpa(parcela): 

            return associacao[parcela['estado']]

        else:
            if eh_parcela_minada(parcela): 

                return associacao['limpa'][1]

            else:

                return associacao['limpa'][0]              

def alterna_bandeira(parcela):
    '''
    Função de alto nível associada ao TAD Parcela
    Esta função recebe uma parcela e altera o estado, marcada para tapada ou tapada para marcada e retorna True se alterou
    ou False em contrario

    dict (correspondente a uma parcela) -> bool
    '''

    if eh_parcela_marcada(parcela):

        parcela = desmarca_parcela(parcela)
        return True

    elif eh_parcela_tapada(parcela):

        parcela = marca_parcela(parcela)
        return True
    
    return False

#TAD Campo

def cria_campo(col_max,lin_max):
    '''
    Construtor do TAD Campo
    Esta função recebe um caracter maiúsculo e um inteiro, correspondente à coluna máxima e uma linha máxima, e 
    retorna um campo em forma de dicionário

    str x int -> dict (correspondente a um campo)
    '''

    if isinstance(lin_max,int) and lin_max > 0 and lin_max <= 99 and isinstance(col_max,str) \
        and len(col_max) == 1 and col_max in letras_possiveis():

            parcelas = {}
            linhas = []

            for cont1 in range(1,lin_max+1):    
                for cont2 in range(ord('A'),ord(col_max)+1):
                    linhas += [cria_parcela()]

                parcelas.update({str(cont1).zfill(2): linhas}) #o meu campo está primeiro ordenado por linhas
                linhas = []

            return parcelas

    raise ValueError('cria_campo: argumentos invalidos')

def cria_copia_campo(campo):
    '''
    Construtor do TAD Campo
    Esta função recebe um campo e cria uma cópia com forma igual à do campo e retorna a cópia

    dict (correspondente a um campo) -> dict (correspondente a um campo)
    '''

    campo_copiado = {}
    chave_nova = []
    
    for chave in campo: #forma de dar deepcopy em dicionários, não quebrando nenhuma barreira
        for valor in campo[chave]:
            chave_nova += [cria_copia_parcela(valor)]

        campo_copiado[chave] = chave_nova
        chave_nova = []

    return campo_copiado

def obtem_ultima_coluna(campo):
    '''
    Seletor do TAD Campo
    Esta função recebe um campo e retorna a última coluna do campo

    dict (correspondente a um campo) -> str
    '''
    
    return chr(ord('A')+len(campo['01'])-1) #verificar o tamanho de cada linha dá o número de colunas

def obtem_ultima_linha(campo):
    '''
    Seletor do TAD Campo
    Esta função recebe um campo e retorna a última linha do campo

    dict (correspondente a um campo) -> int
    '''

    return len(campo)

def obtem_parcela(campo, coord):
    '''
    Seletor do TAD Campo
    Esta função recebe um campo e uma coordenada e retorna a parcela do campo correspondente a essa coordenada

    dict (correspondente a um campo) x tuple (correspondente a uma coordenada) -> dict (correspondente a uma parcela)
    '''

    lin = str(obtem_linha(coord)).zfill(2) 
    col = ord(obtem_coluna(coord))-ord('A')

    return campo[lin][col] 

def obtem_coordenadas(campo,s):
    '''
    Seletor do TAD Campo
    Esta função recebe um campo e uma cadeia de caracteres correspondente a um estado, e retorna um tuplo com as coordenadas
    cujas parcelas estao nesse estado

    dict (correspondente a um campo) x str -> tuple
    '''

    coordenadas = ()
    n_coluna = ord('A')

    for linha in campo:
        for coluna in campo[linha]:
            
            if s == 'tapadas' and eh_parcela_tapada(coluna): #verificar cada caso para não quebrar barreiras
                coordenadas += (cria_coordenada(chr(n_coluna),int(linha)),)
            
            elif s == 'marcadas' and eh_parcela_marcada(coluna):
                coordenadas += (cria_coordenada(chr(n_coluna),int(linha)),)
            
            elif s == 'limpas' and eh_parcela_limpa(coluna):
                coordenadas += (cria_coordenada(chr(n_coluna),int(linha)),)
            
            elif s == 'minadas' and eh_parcela_minada(coluna):
                coordenadas += (cria_coordenada(chr(n_coluna),int(linha)),)

            n_coluna += 1

        n_coluna = ord('A')
    
    return coordenadas

def obtem_numero_minas_vizinhas(campo,coord):
    '''
    Seletor do TAD Campo
    Esta função recebe um campo e uma coordenada e retorna um inteiro, correspondente ao número de minas nas coordenadas do campo
    vizinhas à coordenada

    dict (correspondente a um campo) x tuple (correspondente a uma coordenada) -> int
    '''

    coord_vizinhas = (obtem_coordenadas_vizinhas(coord))
    minas = 0

    for vizinho in coord_vizinhas:
        if eh_coordenada(vizinho) and ord(obtem_coluna(vizinho)) <= ord(obtem_ultima_coluna(campo))\
            and obtem_linha(vizinho) <= obtem_ultima_linha(campo):#verificar que a coordenada pertence ao campo

                parcela = obtem_parcela(campo,vizinho)

                if eh_parcela_minada(parcela):
                    minas += 1

    return minas

def eh_campo(arg): 
    '''
    Reconhecedor do TAD Campo
    Esta função recebe um argumento e verifica se é campo, retornando True ou False em caso contrário

    any -> bool
    '''
    
    if type(arg) == dict and len(arg) != 0:
        for chave in arg:
            if type(chave) == str and int(chave) >= 1 and int(chave) <= 99 and \
                len(arg[chave]) != 0:
                
                for parcela in arg[chave]:
                    if not eh_parcela(parcela): #se uma 'parcela' não for parcela, tem de dar logo False
                        return False

            else:
                return False
        
        return True

    return False

def eh_coordenada_do_campo(campo,coord):
    '''
    Reconhecedor do TAD Campo
    Esta função recebe um campo e uma coordenada e verifica se a coordenada pertence ao campo, retornando True ou False em caso contrário

    dict (correspondente a um campo) x tuple(correspondente a uma coordenada) -> bool
    '''

    if eh_campo(campo) and ord(obtem_coluna(coord)) <= ord(obtem_ultima_coluna(campo)) \
        and obtem_linha(coord) <= obtem_ultima_linha(campo):
            
            return True

    return False

def campos_iguais(campo1,campo2):
    '''
    Teste do TAD Campo
    Esta função recebe dois campos e verifica se são iguais, retornando True ou False em caso contrário

    dict (correspondente a um campo) x dict (correspondente a um campo) -> bool
    '''

    if eh_campo(campo1) and eh_campo(campo2):
        if obtem_ultima_coluna(campo1) == obtem_ultima_coluna(campo2) and \
            obtem_ultima_linha(campo1) == obtem_ultima_linha(campo2):

                for lin in range(1, obtem_ultima_linha(campo1)+1):
                    for col in range(ord('A'), ord(obtem_ultima_coluna(campo1))+1):
                        if not parcelas_iguais(obtem_parcela(campo1,cria_coordenada(chr(col),lin)),obtem_parcela(campo2,cria_coordenada(chr(col),lin))): #verificação parcela a parcela para ser igual
                            return False
                
                return True
    
    return False

def campo_para_str (campo):
    '''
    Transformador do TAD Campo
    Esta função recebe um campo e retorna a cadeia de caracteres correspondente ao campo de minas

    dict (correspondente a um campo) -> str
    '''

    inicio = '   '
    limite = '  +' + '-'*(ord(obtem_ultima_coluna(campo))-ord('A')+1) + '+' #dar print aos + e -
    meio = ''
    n_lin = 1
    n_col = 65

    while n_col != ord(obtem_ultima_coluna(campo))+1: #dar print às letras
        inicio += chr(n_col)
        n_col += 1

    inicio += '\n'
    n_col = 65
    
    for lin in campo:
        meio += lin + '|'

        for parcela in campo[lin]:
            
            if eh_parcela_limpa(parcela) and not eh_parcela_minada(parcela):
                if obtem_numero_minas_vizinhas(campo,cria_coordenada(chr(n_col),n_lin)) == 0:
                    meio += ' '

                else:
                    meio += str(obtem_numero_minas_vizinhas(campo,cria_coordenada(chr(n_col),n_lin)))
                
            else:
                meio += parcela_para_str(parcela)

            n_col += 1

        meio += '|\n'
        n_lin += 1
        n_col = 65


    texto_jogo = inicio + limite +'\n' + meio + limite
    return texto_jogo

def coloca_minas(campo,coord,g,n): 
    '''
    Função de alto nível associada ao TAD Campo
    Esta função recebe um campo, uma coordenada, um gerador e um número de minas e retorna um campo modificado, colocando as minas
    em coordenadas aleatórias usando o algoritmo xorshift, verificando que não coloca minas na coordenada escolhida e nas vizinhas
    e em coordenadas que já estão minadas

    dict (correspondente a um campo) x tuple (correspondente a uma coordenada) x dict (correspondente a um gerador) x int -> dict (correspondente a um campo)
    '''

    def eh_vizinha(coord_1,coord_2):
        '''
        Esta função recebe duas coordenadas e verifica se são vizinhas, retornando True ou False em caso contrário

        tuple (correspondente a uma coordenada) x tuple (correspondente a uma coordenada) -> bool
        '''
        for c in obtem_coordenadas_vizinhas(coord_2):
            if coordenadas_iguais(coord_1,c):
                return True
        return False


    while n != 0:
        coord_aleatoria = obtem_coordenada_aleatoria(cria_coordenada(obtem_ultima_coluna(campo),obtem_ultima_linha(campo)),g)
        if eh_coordenada_do_campo(campo,coord_aleatoria) and not coordenadas_iguais(coord_aleatoria,coord)\
            and not eh_parcela_minada(obtem_parcela(campo,coord_aleatoria)) \
                and not eh_vizinha(coord_aleatoria,coord): #verificar se não é vizinha

                    esconde_mina(obtem_parcela(campo,coord_aleatoria))
                    n -= 1

    return campo

def limpa_campo(campo,coord):
    '''
    Função de alto nível associada ao TAD Campo
    Esta função recebe um campo e uma coordenada e retorna o campo com a coordenada limpa, se não tiver minas na vizinhança
    limpa também as coordenadas da vizinhança (exceto se estiver marcada ou já limpa) iterativamente

    dict (correspondente a um campo) x tuple (correspondente a uma coordenada) -> dict (correspondente a um campo)
    '''

    def limpa_campo_aux(campo,coord): #criar uma auxiliar para o caso de a parcela vizinha ser marcada
        '''
        Esta função recebe um campo e uma coordenada e permite após da primeira limpeza, não limpar mais a que estão marcadas
        após isso retorna o campo

        dict (correspondente a um campo) x tuple (correspondente a uma coordenada) -> dict (correspondente a um campo)
        '''
        parcela = obtem_parcela(campo,coord)

        if eh_parcela_limpa(parcela):
            return campo
        elif eh_parcela_tapada(parcela) and not eh_parcela_minada(parcela):
            limpa_parcela(parcela)
            if obtem_numero_minas_vizinhas(campo,coord) == 0:
                for c in obtem_coordenadas_vizinhas(coord):
                    if eh_coordenada_do_campo(campo,c):
                        limpa_campo_aux(campo,c)
        elif eh_parcela_minada(parcela):
            limpa_parcela(parcela)

        return campo

    parcela = obtem_parcela(campo,coord)

    if eh_parcela_limpa(parcela):
        return campo
    else:
        if not eh_parcela_minada(parcela): #ignora o facto de ser marcada ou tapada, simplesmente limpa para a primeira coordenada dada
            limpa_parcela(parcela)
            if obtem_numero_minas_vizinhas(campo,coord) == 0:
                for c in obtem_coordenadas_vizinhas(coord):
                    if eh_coordenada_do_campo(campo,c):
                        limpa_campo_aux(campo,c)

        else:
            limpa_parcela(parcela)

    return campo

def verifica_coordenada(campo): #permite verificar se é coordenada e evita levantar valueerror ou indexerror que estragariam o jogo
    '''
    Esta função recebe um campo e verifica se a coordenada pertence ao campo, retornando a coordenada, permite voltar a pedir
    a coordenada no caso de não pertencer

    dict (correspondente a um campo) -> tuple (correspondente a uma coordenada)
    '''
    coord = input('Escolha uma coordenada:')

    if len(coord) != 3:
        return verifica_coordenada(campo)

    try:
        coord = str_para_coordenada(coord)
    except:
        return verifica_coordenada(campo)

    if not eh_coordenada_do_campo(campo,coord):
        return verifica_coordenada(campo)
    
    return coord

#Funções Adicionais

def jogo_ganho(campo):
    '''
    Função adicional
    Esta função recebe um campo e retorna True se todas as parcelas sem mina estão limpas, False em caso contrário

    dict (correspondente a um campo) -> bool
    '''
    for c in obtem_coordenadas(campo,'minadas'):
        if eh_parcela_limpa(obtem_parcela(campo,c)):
            return False
    return len(obtem_coordenadas(campo,'limpas')) + len(obtem_coordenadas(campo,'minadas')) \
        == obtem_ultima_linha(campo) * (ord(obtem_ultima_coluna(campo))-ord('A')+1) #o nº parcelas limpas + nº parcelas minadas têm que dar a área do campo

def turno_jogador(campo):
    '''
    Função adicional
    Esta função recebe um campo e pede um input ao jogador para fazer uma ação, limpar ou marcar, e escolher uma coordenada
    retornando False se limpar uma parcela minada e True em caso contrário

    dict (correspondente a um campo) -> bool
    '''

    acao = input('Escolha uma ação, [L]impar ou [M]arcar:')

    if acao in ('L','M'):
        
        coord = verifica_coordenada(campo)

        if acao == 'L':
            limpa_campo (campo,coord)

            if eh_parcela_minada(obtem_parcela(campo,coord)):

                return False

            else:
                
                return True
        
        elif acao == 'M':

            alterna_bandeira(obtem_parcela(campo,coord))
            return True

    else:
        return turno_jogador(campo)

#Função Principal
def minas(col_max,lin_max,n_minas,bits,seed):
    '''
    Função Principal
    Esta função recebe uma cadeia de carateres, associada à coluna máxima, e 4 inteiros, associados à linha máxima, número
    de minas, número de bits e número de seed e corre o jogo e retorna True se o jogador 
    conseguir ganhar o jogo e False em caso contrário
    
    str x int x int x int x int -> bool
    '''

    if type(n_minas) != int or n_minas <= 0:
        raise ValueError('minas: argumentos invalidos')


    def escrever_campo(campo): #função para dar print ao campo
        '''
        Esta função pega num campo e retorna uma cadeia de carateres para printar o jogo
        '''
        print ('   [Bandeiras {}/{}]'.format(bandeiras,n_minas))
        print (campo_para_str(campo))
        
    try:
        g = cria_gerador(bits,seed)
        campo = cria_campo(col_max,lin_max)
    except:
        raise ValueError('minas: argumentos invalidos')

    if n_minas > obtem_ultima_linha(campo) * (ord(obtem_ultima_coluna(campo))-ord('A')+1)\
        or obtem_ultima_linha(campo) * (ord(obtem_ultima_coluna(campo))-ord('A')+1) < 5:

            raise ValueError('minas: argumentos invalidos')

    bandeiras = len(obtem_coordenadas(campo,'marcadas'))
    escrever_campo(campo)
    coord = verifica_coordenada(campo)

    coloca_minas(campo,coord,g,n_minas)
    limpa_campo(campo,coord)
    escrever_campo(campo)

    while turno_jogador(campo): #enquanto limparmos uma parcela sem mina
        bandeiras = len(obtem_coordenadas(campo,'marcadas'))
        escrever_campo(campo)

        if jogo_ganho(campo):
            print('VITORIA!!!')
            return True

    bandeiras = len(obtem_coordenadas(campo,'marcadas')) #se limparmos uma parcela com mina perdemos o jogo
    escrever_campo(campo)
    print('BOOOOOOOM!!!')
    return False