# coding=utf-8
"""
BATALLA NAVAL
Representación de cómo se verá el juego
COMPUTADORA JUGADOR
1 2 3 4 1 2 3 4
1[*][ ][ ][*] 1[ ][*][ ][ ]
2[ ][*][ ][ ] 2[ ][ ][ ][ ]
3[ ][ ][ ][ ] 3[ ][ ][*][ ]
4[ ][*][ ][ ] 4[*][*][ ][ ]
"""
import random, copy, time, textwrap # copy nos proporciona operaciones genericas de copiado
# Declaración de constantes.
DIMENSION_ = 6
TURNO_ = 4
# Imprime el mapa
def __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 usuario
def __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 random
def __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 submarino
def __colocar_submarino__(mesa, x, y):
mesa[x][y] = '[S] '
return mesa
# Validacion de que ya se ingresaron esas coordenadas
coordenadas_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 escoge
def __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 juego
def __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 blanco
def __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 misil
def __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 coordenadas
def __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__()
Comentarios
Publicar un comentario