Ejemplo Juego Nicole y Hugo

Ejemplo de Nicole y Hugo

# coding=utf-8
"""                                                    BATALLA NAVALRepresentación de cómo se verá el juego COMPUTADORA                JUGADOR  1  2  3  4               1  2  3  41[*][ ][ ][*]            1[ ][*][ ][ ]2[ ][*][ ][ ]            2[ ][ ][ ][ ]3[ ][ ][ ][ ]            3[ ][ ][*][ ]4[ ][*][ ][ ]            4[*][*][ ][ ]"""import random, copy, time, textwrap # copy nos proporciona operaciones genericas de copiado
# Declaración de constantes.DIMENSION_ = 6TURNO_ = 4

# Imprime el mapadef __imprimir_mapa__(jugador, mesa, dimension):
    player = 'la computadora'    if jugador == 'u':
        player = 'el jugador'
    print "\033[1m"+ 'La mesa de ' + player + ' se ve así:' + "\033[0m"    # Imprimir el número de columna    for i in range(dimension):
        print '   ' + str(i+1) + '',    print ' '
    for i in range(dimension):
        # Imprimir el número de fila        print str(i+1) + '',        # Imprime los valores de las celdas        for j in range(dimension):
            if mesa[i][j] == -1:
                print '[ ] ', # Imprime la mesa vacía por primera vez (ésto sólo se ejecuta la primera vez)            elif jugador == 'u':
                print mesa[i][j], # Aquí se imprime la mesa del jugador, puede contener [] o [S]            elif jugador == 'c': # Si el jugador es computadora se imprime su mesa                if mesa[i][j] == '[!] ' or mesa[i][j] == '[*] ':
                    print mesa[i][j],                else:
                    print '[ ] ',        print ' '

# Obtener coordenadas usuariodef __obtener_coordenada__(dimension):
    while True:
        user_input = raw_input("\033[1m"+'Por favor, ingresa las coordenadas (columna,fila): ' + "\033[0m")
        try:
            # Verificar si el usuario ingresó 2 valores separados por coma            coor = user_input.split(',')
            if len(coor) != 2:
                raise Exception("\033[1m"+'Entrada invalida, pocas/muchas coordenadas' + "\033[0m")

            coor[0] = int(coor[0]) -1            coor[1] = int(coor[1]) -1
            # Verifica si están dentro del limite            if coor[0] > dimension-1 or coor[0] < 0 or coor[1] > dimension-1 or coor[1] < 0:
                exc = "\033[1m"+'Entrada invalida, ingresa valores entre 1 y ', str(dimension) ,' solamente.' + "\033[0m"                raise Exception(exc)

            # Si todo esta bien, devuelvelo            return coor
        except ValueError:
            print "\033[1m"+'Entrada inválida, ingresa sólo dos coordenadas' + "\033[0m"        except Exception as e:
            print e


# La computadora escoge por randomdef __computadora_escoge__(mesa_computadora, DIMENSION_, turno):
    lista_comp = [] # Se crea una lista con la cantidad de turno que se pasen por parametro
    for i in range(DIMENSION_):
        lista_comp.append(i) # En caso de DIMENSION_ = 8 E lista_comp = ['1','2','3','4','5','6','7','8']
    # Variable auxiliar para controlar el flujo de turnos    m = 0
    while m < turno:
        # Se escoge un número.        escoger_coordenada_x_comp = random.choice(lista_comp)
        escoger_coordenada_y_comp = random.choice(lista_comp)
        validacion = __validar__('c',escoger_coordenada_x_comp, escoger_coordenada_y_comp)
        if validacion:
            m = m - 1        else:
            m = m + 1    print "\033[1m"+'La computadora ya colocó sus submarinos' + "\033[0m"    return mesa_computadora


# Colocar submarinodef __colocar_submarino__(mesa, x, y):
    mesa[x][y] = '[S] '    return mesa


# Validacion de que ya se ingresaron esas coordenadascoordenadas_usuario = []
coordenadas_computadora = []
def __validar__(player,x,y):

    individual = str(x+1)+str(y+1)

    if player == 'u':
        if individual in coordenadas_usuario:
            return True        else:
            coordenadas_usuario.append(individual)
            return False    elif player == 'c':
        if individual in coordenadas_computadora:
            return True        else:
            coordenadas_computadora.append(individual)
            return False

# El usuario escogedef __usuario_escoge__(mesaus, DIMENSION_,turno):
    p = 0    while True:

        p = p + 1
        __imprimir_mapa__('u',mesaus, DIMENSION_)

        if p > turno:
            break
        print "\033[1m"+ 'Colocando un submarino: ' + "\033[0m"        x, y = __obtener_coordenada__(DIMENSION_) # Obtiene coordenadas (x,y) del 0 a dimension        validacion = __validar__('u',x,y) # Devuelve True si dicha coordenada ya fue ingresada, False si no
        # Si la coordenada ya se ingresó se resta un turno        if validacion:
            p = p - 1            print "\033[1m"+ 'Verifica el mapa, ya hay un submarino en esa coordenada' + "\033[0m"        else: # Si la coordenada no se ha ingresado, se coloca el submarino en la mesa            __colocar_submarino__(mesaus, x, y)
    raw_input("\033[1m"+'Se han colocado todos los submarinos, presiona ENTER para continuar' + "\033[0m") # Una 'pausa'
    return mesaus


# Configurar tabla de juegodef __configurar_mesa__(mesa, dmnsn):
    # Esta función rellena la mesa de dmnsn * dmnsn con -1    for i in range(dmnsn):
        __mesa_fila__ = []
        for j in range(dmnsn):
            __mesa_fila__.append(-1)
        mesa.append(__mesa_fila__)


ataques_jugador = []
ataques_computadora = []
# Verifica si dio en el blancodef __validar_ataque__(mesa,player, x, y):
    """    __validar_ataque__ es una función que entra después de que las coordenadas hayan sido ingresadas para el ataque.    Retorna un número (-1,0,1) dependiendo a dónde fue el misil    :param mesa: De qué mesa se trata    :param player: A qué jugador atacar. c = computadora; u = usuario    :param x: La coordenada x    :param y: La coordenada y    :return: -1 si la coordenada ya se ingresó anteriormente    :return: 1 si la coordenada ingresada dió en el blanco    :return: 0 si la coordenada ingresada no dió en el blanco    """    coordenada = str(x+1) + str(y+1)
    if player == 'c':  # Turno del usuario        if coordenada in ataques_jugador:
            return -1        else:
            if coordenada in coordenadas_computadora:
                mesa[x][y] = '[!] '                ataques_jugador.append(coordenada)
                return 1            else:
                mesa[x][y] = '[*] '                ataques_jugador.append(coordenada)
                return 0    elif player == 'u':  # Turno de la computadora        if coordenada in ataques_computadora:
            return -1        else:
            if coordenada in coordenadas_usuario:
                mesa[x][y] = '[!] '                ataques_computadora.append(coordenada)
                return 1            else:
                mesa[x][y] = '[*] '                ataques_computadora.append(coordenada)
                return 0

# El jugador ingresa coordendas para mandar misildef __jugador_ataca__(mesacomp,dimension):
    """    Obtiene las coordenadas del usuario y hace el ataque.    Si el jugador da en el blanco, cambia a  [!] y suma punto.    :param mesacomp:    :param dimension:    :return:    """    global pts_jugador
    while True:
        x, y = __obtener_coordenada__(dimension)

        validacion = __validar_ataque__(mesacomp, 'c', x, y)

        if validacion == -1:
            print "\033[1m"+'Ya se ha mandado un mísil a dicha coordenada, intenta de nuevo' + "\033[0m"        elif validacion == 0:
            print "\033[1m"+'Mísil mandado a ' + str(x+1) + ',' + str(y+1) + "\033[0m"            time.sleep(1)
            print "\033[1m"+'El mísil no dió en el blanco :(' + "\033[0m"            return mesacomp
        elif validacion == 1:
            print "\033[1m"+'Mísil mandado a ' + str(x+1) + ',' + str(y+1) + "\033[0m"            time.sleep(1)
            print "\033[1m"+'¡El mísil dió en el blanco!' + "\033[0m"            pts_jugador = pts_jugador + 1            return mesacomp


# La computadora elige aleatoriamente las coordenadasdef __computadora_ataca__(mesaus, DIMENSION_):
    global pts_computadora

    intento = True
    while intento:
        # Se elige aleatoriamente las coordenadas        x = random.randint(0, DIMENSION_ - 1)
        y = random.randint(0, DIMENSION_ - 1)

        validacion = __validar_ataque__(mesaus, 'u', x, y)

        if validacion == -1:
            print "\033[1m"+'La computadora ya mandó un mísil a esa coordenada, lo volverá a intentar' + "\033[0m"            intento = True        elif validacion == 0:
            print "\033[1m" + 'Mísil mandado a ' + str(x + 1) + ',' + str(y + 1) + "\033[0m"            time.sleep(1)
            print "\033[1m"+'Excelente, la computadora no dió en el blanco' + "\033[0m"            intento = False            return mesaus
        elif validacion == 1:
            print "\033[1m" + 'Mísil mandado a ' + str(x + 1) + ',' + str(y + 1) + "\033[0m"            time.sleep(1)
            print "\033[1m"+'La computadora ha destruido uno de tus submarinos' + "\033[0m"            pts_computadora = pts_computadora + 1            intento = False            return mesaus


def __juego__():
    print "\033[1m"+ '== BATALLA NAVAL ==' + "\033[0m"    # AQUÍ VA LA HISTORIA    msg=('Instrucciones: '              'Hay dos mesas de la misma dimensión y te enfrentaras a un enemigo desconocido :3 '              'Primero ingresaras las coordenadas donde se localizara tus submarinos (columna,fila) Ej. 3,2 '              'posteriormente, el enemigo colocara sus submarinos, por defecto estaran ocultos para ti.'              ' El objetivo es mandar mísiles con las coordenadas que ingresaste para atacar al enemigo.'              ' Gana el primero en derribar todos los submarinos')
    mesa = []
    __configurar_mesa__(mesa, DIMENSION_) # Configura una mesa de DIMENSION_ * DIMENSION_    print(textwrap.fill(msg, width=112))
    # Configurar la mesa del usuario y computadora. Se copia la mesa a mesa_usuario y mesa_computadora    mesa_usuario = copy.deepcopy(mesa)
    mesa_computadora = copy.deepcopy(mesa)

    #                                           COLOCACIÓN DE SUBMARINOS    # El usuario escoge coordenadas    mesa_usuario = __usuario_escoge__(mesa_usuario, DIMENSION_,TURNO_)
    # print coordenadas_usuario    # La computadora escoge coordenadas    mesa_computadora = __computadora_escoge__(mesa_computadora, DIMENSION_, TURNO_)
    # print coordenadas_computadora
    # Main loop    while 1:

        #        #                                               Turno del jugador        # Jugador ingresa coordenadas para atacar a la computadora        mesa_computadora = __jugador_ataca__(mesa_computadora, DIMENSION_) # Por eso se está modificando la mesa_computadora        # Si pasó la validación, pasa a atacar
        if pts_jugador == TURNO_:
            print "\033[1m"+ 'Has derrivado todos los submarinos de la computadora, ¡HAS GANADO!' + "\033[0m"            raw_input("\033[1m"+ 'Presiona ENTER para terminar' + "\033[0m")
            quit()

        # Muestra el mapa enemigo, si dió en el blanco [!], si no, [*]        __imprimir_mapa__('c',mesa_computadora,DIMENSION_)
        raw_input('Presiona ENTER para continuar')
        # Si dió en el blanco[!], se incrementa un punto        #        #                                               Turno del enemigo        # Computadora 'adivina' las coordenadas        mesa_usuario = __computadora_ataca__(mesa_usuario, DIMENSION_)
        # Se valida si la PC ya atacó a esa coordenada        #        if pts_computadora == TURNO_:
            print "\033[1m"+ 'La computadora ha derrivado todos tus submarinos, has perdido.' + "\033[0m"            raw_input("\033[1m"+ 'Presiona ENTER para terminar' + "\033[0m")
            quit()
        # Si pasó la validación, pasa a atacar        # Muestra el mapa enemigo, si dio en blanco [!], si no, [o]        __imprimir_mapa__('u',mesa_usuario,DIMENSION_)
        # Si dió en el blanco[!], se incrementa un punto        #

if __name__ == '__main__':
    pts_jugador = 0    pts_computadora = 0    __juego__()