Proyecto final: Guerra naval

Mal curso, el curso esta lleno de vacios en el cual no explican lo basico de manera correcta, habla muchas veces de terminos y concepto que no explica por ejemplo de los maps, no explico de manera correcta que es el constructor el POO !

Muy bueno el curso, aun que este juego de batalla naval aun me parece complicado. Al estudiar el código logro comprenderlo, pero siento que por mi cuenta, me tomaría mucho tiempo hacer algo así

Continuación...No estoy de acuerdo con Fabio Rojas en que el curso es malo y al igual que otros compañeros pienso que cada curso siempre debe complementarse con la información oficial del lenguaje que se esté estudiando, cursos por YouTube (Freddy me va a querer ahorcar jejejejeje), comentarios de los compañeros, etc), sin embargo, la mayor cantidad de información debe venir de los cursos de Platzi debido a que para eso se paga. Clari es una excelente profesora, se nota que es una experta en Python y posee gran pedagogia (es por eso mi gran desacuerdo con Fabio).

Excelente curso, ya presente el examen, me encanto, aunque deberia de haber otro donde sea mas avanzando en cuanto a la programacion orientada a objetos

A medida que he avanzado en mi aprendizaje, comprendí la importancia de desarrollar una lógica sólida en Python. Esto implica trabajar en habilidades como el pensamiento algorítmico, la resolución de problemas y la comprensión de cómo estructurar y manipular datos.🦉![]()

Muy buen curso!!!!

Explicación del Código```js import random class Barco: def __init__(self, nombre, tamaño): self.nombre = nombre self.tamaño = tamaño self.posiciones = [] self.hundido = False def colocar(self, posiciones): self.posiciones = posiciones def recibir_disparo(self, posicion): if posicion in self.posiciones: self.posiciones.remove(posicion) if not self.posiciones: self.hundido = True return True return False class Tablero: def __init__(self, tamaño=10): self.tamaño = tamaño self.tablero = [['~'] * tamaño for _ in range(tamaño)] self.barcos = [] def colocar_barco(self, barco, posiciones): for x, y in posiciones: self.tablero[x][y] = 'B' barco.colocar(posiciones) self.barcos.append(barco) def disparar(self, x, y): for barco in self.barcos: if barco.recibir_disparo((x, y)): self.tablero[x][y] = 'X' if barco.hundido: print(f"¡Hundiste el {barco.nombre}!") else: print(f"¡Tocado!") return True self.tablero[x][y] = 'O' print("¡Agua!") return False def mostrar(self): for fila in self.tablero: print(" ".join(fila)) class Jugador: def __init__(self, nombre): self.nombre = nombre self.tablero_propio = Tablero() self.tablero_oponente = Tablero() def colocar_barco(self, barco, posiciones): self.tablero_propio.colocar_barco(barco, posiciones) def disparar(self, oponente, x, y): return oponente.tablero_propio.disparar(x, y) class Juego: def __init__(self, jugador1, jugador2): self.jugador1 = jugador1 self.jugador2 = jugador2 self.turno_actual = jugador1 def jugar(self): while True: print(f"Turno de {self.turno_actual.nombre}") self.turno_actual.tablero_oponente.mostrar() x, y = map(int, input("Introduce las coordenadas de disparo (x y): ").split()) if self.turno_actual == self.jugador1: if self.turno_actual.disparar(self.jugador2, x, y): if self.jugador2.tablero_propio.barcos == []: print(f"¡{self.jugador1.nombre} ha ganado!") break self.turno_actual = self.jugador2 else: if self.turno_actual.disparar(self.jugador1, x, y): if self.jugador1.tablero_propio.barcos == []: print(f"¡{self.jugador2.nombre} ha ganado!") break self.turno_actual = self.jugador1 # Ejemplo de uso: # Crear jugadores jugador1 = Jugador("Jugador 1") jugador2 = Jugador("Jugador 2") # Crear y colocar barcos barco1 = Barco("Acorazado", 4) barco2 = Barco("Submarino", 3) barco3 = Barco("Destructor", 2) jugador1.colocar_barco(barco1, [(1, 1), (1, 2), (1, 3), (1, 4)]) jugador1.colocar_barco(barco2, [(3, 3), (3, 4), (3, 5)]) jugador1.colocar_barco(barco3, [(5, 5), (5, 6)]) jugador2.colocar_barco(barco1, [(2, 2), (2, 3), (2, 4), (2, 5)]) jugador2.colocar_barco(barco2, [(4, 4), (4, 5), (4, 6)]) jugador2.colocar_barco(barco3, [(6, 6), (6, 7)]) # Iniciar el juego juego = Juego(jugador1, jugador2) juego.jugar() ``` 1. **Clase** `Barco`: Define los atributos y métodos de un barco, como su nombre, tamaño, posiciones y estado (hundido o no). El método `recibir_disparo` actualiza el estado del barco cuando recibe un disparo. 2. **Clase** `Tablero`: Define el tablero de juego y los métodos para colocar barcos y realizar disparos. El método `disparar` verifica si un disparo acierta un barco o cae al agua. 3. **Clase** `Jugador`: Define los atributos y métodos de un jugador, incluyendo su propio tablero y el tablero del oponente. Los métodos permiten al jugador colocar barcos y disparar al tablero del oponente. 4. **Clase** `Juego`: Controla el flujo del juego, alternando los turnos entre los jugadores hasta que uno de ellos gane. ### Ejecución del Código

El final lo sentí tipo: No olvides darle 'like', suscribirte y darle a la campanita🤣

Mi código. Consideré: 1\. Que si el jugador ingresa una coordenada que no existe, se le indique de dicha coordenada es invalida y así mismo, se le especifica la forma correcta de hacerlo. 2\. Enseñarle las dimensiones del tablero al jugador para que entienda cómo colocar los barcos. 3\. Se tuvo en cuenta la parte gráfica, es decir ¿Qué pasa si un jugador coloca un barco en la posición "x,y", pues para la siguiente posición de su otro barco, ese espacio se le indicará de forma gráfica que está ocupado, todo para un mejor entendimiento del jugador. 4\. Al hacer impacto, el tablero se enseñaría con esos espacios en blanco, donde se impactó. 5\. Al atacar el jugador x, si le da al agua, sería turno del jugador y, pero si le da a un barco, vuelve a atacar el jugador x. ```python import random # Definimos el tamaño del tablero y el número de barcos BOARD_SIZE = 5 NUM_SHIPS = 3 SHIP_SIZE = 3 # Tamaño de los barcos # Inicializamos los tableros def create_board(): return [["O"] * BOARD_SIZE for _ in range(BOARD_SIZE)] # Mostramos el tablero def print_board(board): print(" " + " ".join(str(i) for i in range(BOARD_SIZE))) # Encabezado de columnas for index, row in enumerate(board): # Cambiamos 'O' por '0' y 'S' por espacio vacío para mostrar los barcos en el tablero display_row = ["0" if cell == "O" else " " if cell == "S" else cell for cell in row] print(f"{index} " + " ".join(display_row)) # Colocamos un barco en la posición elegida por el jugador def place_ship(board, x, y, orientation): if orientation == "H": if y + SHIP_SIZE > BOARD_SIZE: print("Error: El barco no cabe en el tablero horizontalmente.") return False if any(board[x][y+i] == "S" for i in range(SHIP_SIZE)): print("Error: Ya hay un barco en esa posición. Elige otra.") return False for i in range(SHIP_SIZE): board[x][y+i] = "S" return True elif orientation == "V": if x + SHIP_SIZE > BOARD_SIZE: print("Error: El barco no cabe en el tablero verticalmente.") return False if any(board[x+i][y] == "S" for i in range(SHIP_SIZE)): print("Error: Ya hay un barco en esa posición. Elige otra.") return False for i in range(SHIP_SIZE): board[x+i][y] = "S" return True return False # Función para atacar def attack(board, x, y, display_board): if board[x][y] == "S": board[x][y] = "X" # Barco alcanzado display_board[x][y] = " " # Cambiamos "0" a espacio vacío en el tablero del atacante print(f"¡Impacto en ({x}, {y})!") print_board(display_board) # Mostrar el tablero actualizado return True elif board[x][y] == "O": board[x][y] = "-" # Agua print("Agua.") return False else: print("Ya atacaste esa posición.") return False # Comprobamos si todos los barcos han sido hundidos def all_ships_sunk(board): return all("S" not in row for row in board) # Validar coordenadas def is_valid_coordinate(x, y): return 0 <= x < BOARD_SIZE and 0 <= y < BOARD_SIZE # Mostrar tablero inicial y dimensiones def show_initial_board(): initial_board = [["O"] * BOARD_SIZE for _ in range(BOARD_SIZE)] print("Tablero inicial (coordenadas disponibles para colocar barcos):") print_board(initial_board) print(f"Dimensiones del tablero: {BOARD_SIZE}x{BOARD_SIZE}") print("Las coordenadas van de 0 a", BOARD_SIZE - 1) # Colocar barcos por parte del jugador def setup_board(player_board): for i in range(NUM_SHIPS): while True: print(f"Colocando barco {i + 1}:") print_board(player_board) # Mostrar el tablero actual antes de cada intento de colocación try: x, y = map(int, input(f"Introduce las coordenadas (X Y) para el barco {i + 1} (0-{BOARD_SIZE-1}): ").split()) orientation = input("Introduce la orientación (H para horizontal, V para vertical): ").upper() if is_valid_coordinate(x, y) and (orientation in ["H", "V"]): if place_ship(player_board, x, y, orientation): print("Barco colocado.") break else: print(f"Coordenadas no válidas o orientación incorrecta. Deben estar entre 0 y {BOARD_SIZE - 1}.") except ValueError: print("Entrada inválida. Por favor, introduce números enteros separados por espacio.") # Inicializamos los tableros para los dos jugadores player1_board = create_board() player2_board = create_board() player1_display = create_board() # Tablero visible para el jugador 1 (sin barcos del oponente) player2_display = create_board() # Tablero visible para el jugador 2 (sin barcos del oponente) # Mostrar tablero inicial y dimensiones show_initial_board() # Configuramos los barcos para ambos jugadores print("Jugador 1, configura tu tablero.") setup_board(player1_board) print("\nJugador 2, configura tu tablero.") setup_board(player2_board) # Juego por turnos turn = 1 while True: print(f"\nTurno del Jugador {turn}") if turn == 1: print("Tablero del Jugador 2:") print_board(player1_display) while True: try: x, y = map(int, input("Introduce las coordenadas de ataque (X Y): ").split()) if is_valid_coordinate(x, y): hit = attack(player2_board, x, y, player1_display) # Atacar if not hit: # Si no hubo impacto turn = 2 # Cambiar de turno break else: print(f"Coordenadas no válidas. Deben estar entre 0 y {BOARD_SIZE - 1}.") except ValueError: print("Entrada inválida. Por favor, introduce números enteros separados por espacio.") if all_ships_sunk(player2_board): print("¡Jugador 1 ha ganado!") break else: print("Tablero del Jugador 1:") print_board(player2_display) while True: try: x, y = map(int, input("Introduce las coordenadas de ataque (X Y): ").split()) if is_valid_coordinate(x, y): hit = attack(player1_board, x, y, player2_display) # Atacar if not hit: # Si no hubo impacto turn = 1 # Cambiar de turno break else: print(f"Coordenadas no válidas. Deben estar entre 0 y {BOARD_SIZE - 1}.") except ValueError: print("Entrada inválida. Por favor, introduce números enteros separados por espacio.") if all_ships_sunk(player1_board): print("¡Jugador 2 ha ganado!") break ```

arli, muchas gracias por el tiempo que te tomaste en diseñar este manual de videos para enseñarnos Python. Te cuento que estoy súper emocionado, tengo 60 años de edad, me gradué como analista programador en 1985, y te puedo decir que la forma en que explicas hace las cosas muy fáciles. De todos los lenguajes que he conocido, Python me ha parecido espectacular. Estuve buscando cómo aprenderlo; arranqué con Coursera, pero me dejaron tirado al comienzo y procrastiné. Sin embargo, ahora, con la ayuda de la AI, es como tener a un mentor al lado. La introducción al lenguaje fue importante, y ahora voy como un volador. Hace muchos años dejé de programar porque me vine a Norteamérica, primero a Estados Unidos y luego a Canadá, y nunca pude ingresar al campo laboral. Lo último que hice fue una capacitación en **Quality Assurance Software**. Trabajé por seis meses, pero me aburrí porque, después de haber hecho código, limpiar los errores de otros programadores no me daba ninguna satisfacción. Así que me retiré y volví a la construcción. Sin embargo, después de una operación, decidí aprender Python, porque sabía que esa era la conexión para aprovechar al máximo la AI. Te cuento que, desde el viernes pasado hasta hoy, he desarrollado dos proyectos, y esto me tiene fascinado. Nunca me gustaron los exámenes, por eso no lo he presentado, así que prefiero crear y hacer, lo cual es lo que estoy haciendo ahora. Nuevamente, muchas gracias por devolverme el espíritu. Me siento vivo. quiero compartir contigo algunos de los proyectos en los que he estado trabajando. Estoy súper emocionado porque, a mis 60 años, después de haberme graduado como analista programador en 1985, he vuelto a encontrar mi pasión por la programación, específicamente con Python. En los últimos días, he desarrollado dos proyectos y esto me tiene fascinado. Quiero contarte más sobre ellos y sobre mi experiencia reciente. ### 1. **Conversión de Video a Texto** Este proyecto ha sido un parteaguas en mi forma de ver la programación, pues actualmente estoy pagando una plataforma que hace esto, y gracias a mi propio desarrollo, ahora puedo hacerlo por mí mismo y mejorarlo. Mi siguiente paso será poder traducir el contenido a cualquier idioma, usarlo para generar descripciones en YouTube e incluso thumbnails con la ayuda de DALL·E, integrándolo con otras plataformas. Además, sé crear páginas web utilizando **WordPress** y el tema **Divi**, por lo que pienso implementar este sistema dentro de alguna de esas páginas, integrando AI y Python para hacer el proceso más eficiente. ### 2. **Preparación de Devocionales con AI y Envío Diario a través de WhatsApp** Este es el proyecto más grande en el que estoy trabajando actualmente. Logré obtener la API de **Twilio** y aprendí por mi cuenta, usando **ChatGPT** y **Claude**, cómo conectarla con WhatsApp. Desarrollé un módulo que selecciona aleatoriamente versículos de los 66 libros canónicos de la Biblia, y con un diseño de prompt específico, genero devocionales limitados a 150 palabras (o tokens). Antes de enviar los devocionales, los guardo en un archivo **PDF** y genero los logs del sistema en un directorio aparte, capturando las fechas del sistema para llevar un registro detallado. Además, pude hacer la conexión completa con la API de Twilio y ahora estoy trabajando con una **cuenta trial** de WhatsApp Business, que me permite enviar hasta 10 mensajes a contactos verificados. Para escalar este proyecto, necesitaré adquirir la versión de producción y desarrollar más código para implementar funcionalidades de **opt-in** y cumplir con cuestiones legales sobre el manejo de la información y la seguridad de los datos. También tengo el sistema configurado para que corra automáticamente todos los días a las 6:30 am. Adicionalmente, desarrollé un código que, integrado con este sistema, ejecuta una interfaz gráfica usando la biblioteca **Tkinter**, la cual permite gestionar los contactos en un formato gráfico. Con esta ventana, puedo añadir, actualizar y borrar registros, y todo es manejado en archivos **CSV**. ### Mi Visión de Futuro Estoy muy contento con estos proyectos y estoy pensando en buscar un patrocinador para, una vez que termine el producto, poder subirlo a una plataforma y ofrecerlo bajo un modelo de suscripción. Elegí este tema porque soy cristiano y estudié en el Instituto Bíblico del Sur de la Florida, y mi pasión siempre ha sido enseñar las Escrituras. Creo que mi **target** serían los pastores de iglesias, para que mantengan a la comunidad cristiana conectada con la palabra de Dios. Además, he venido desarrollando otros servicios, como un **GPT personalizado** que llamé **"El Verbo"**, el cual puedes encontrar en los GPTs públicos. Está diseñado especialmente para **pastores**, **maestros de Biblia** y la **comunidad cristiana** en general, que quieran profundizar en el estudio de las Escrituras. ### Agradecimientos Quería compartir esta experiencia contigo, y también agradecerle a **Fredy** por creer en Colombia y realizar esta hermosa labor con nuestro pueblo. Y a ti, muchas gracias de nuevo. Este proceso me ha devuelto el espíritu y me siento vivo de nuevo. ### Próximos Pasos en mi Formación Me gustaría también que me pudieras orientar con un **mapa de estudios** sobre qué otros cursos debería tomar. Siempre he estado interesado en **ciencia de datos** y **deep learning**, y creo que todo lo relacionado con **Azure** es fundamental para la seguridad de los datos, ya que es clave si quiero ofrecer mis servicios en el mercado empresarial. Por el momento, no estoy trabajando, ya que decidí hacer una pausa para darle un cambio a mi vida, y creo que este camino está valiendo mucho la pena. Estoy disponible para cualquier cosa que necesites. Me despido siempre como tu amigo, **Jair Lozano** (freddy-antonius-nickname).

Anexo" **Desafíos en mi Reencuentro con la Programación** Uno de los principales desafíos que encontré en este nuevo reencuentro con la programación fue la parte tecnológica. A medida que iba profundizando en los proyectos, fui descubriendo todo lo que se entreteje cuando intentas llevar a cabo una idea. Por eso, uno nunca debe mirar el bosque en su totalidad, porque puede resultar aterrador y podría disuadirte de entrar en él. Lo mejor es concentrar la mirada en un solo árbol, y una vez lo derribes, pasas al siguiente y luego al siguiente, hasta que finalmente atraviesas el bosque. Eso es exactamente lo que he estado experimentando. A veces, los retos parecen imposibles a simple vista, pero cuando te decides a empezar un proyecto y tienes la determinación, la \*\*inteligencia artificial\*\* se convierte en una herramienta eficaz para superar esos obstáculos. También he hecho uso de mi experiencia vivida a lo largo de los años: la sabiduría adquirida, los estudios realizados y, sí, incluso los errores cometidos, todo ello me ha dado la fortaleza para seguir avanzando y vencer esos obstáculos. Por ejemplo, cuando hice mis estudios en \*\*Quality Assurance\*\*, aprendí sobre \*\*REST APIs\*\* y herramientas como \*\*Postman\*\*, pero para ser honesto, en ese momento no entendí mucho. Era como un autómata; no lo pude conectar con la vida real. Sin embargo, ahora, con la ayuda de la AI, he logrado aprenderlo y aplicarlo de manera efectiva. Lo mismo ha sucedido con la configuración de proveedores de mensajería, que tiene tantos detalles complejos que, sin una preparación adecuada, sería muy difícil de gestionar. La AI te explica todo de manera sencilla, y solo necesitas poner tu sentido común en práctica y seguir las instrucciones. Hace tiempo escuchaba que no se necesitaría escribir código en el futuro, que todo se programaría con lenguaje natural, y creo que estamos llegando a ese punto. El código sigue siendo el trasfondo, pero lo que realmente importa es la \*\*experiencia\*\*, la \*\*sabiduría\*\*, y la \*\*tenacidad\*\* que pongas para lograr tus metas. Quise agregar esta parte para que, quien lo lea, se anime y aprenda a usar la AI para su beneficio. Al final, lo que importa no es lo que la gente piense, sino que tú puedas ver el producto final, y eso será lo que más impacte a los demás.

Me agrado mucho el curso , vi temas nuevos que no los conocía, hubo momentos en los que me sentí un poco perdido pero conforme el curso fue avanzando esas dudas se fueron despejando , muchas gracias!!!!

Este curso en lo personal desde un principio hace que te enamores de python pero siento que a medida que vas avanzado es logico que aumente el grado de dificultad, pero asi mismo pienso que deben ser las explicaciones ya que muchas veces se da por obvio un tema sin considerar que muchos no tenemos los conocimientos previos al lenguaje. Tambien soy consiente que una habilidad de los programadores es estar averiguando por temas desconocidos pero en esta caso siento que no aplica del todo ya que si buscas información por fuera del curso que no esta planificada, puede llegar a confundirte mas de lo que estas y eso me paso muchas veces durante el curso. Sin embargo es un excelente curso con una excelente profesora.

Que bueno hubiese sido ir trabajando los conceptos de POO vistos en este proyecto y clase a clase ir avanzando hasta tener el juego realizado. Esto para ir interiorizando el por qué de cada línea de código.

Tomé este curso luego del de Fundamentos de Python y el Curso de Python: Comprehensions, Funciones y Manejo de Errores. Al principio pensé que era una introduccion al de Fundamentos pero luego me di cuenta que lo sustituyó. Este curso posee cosas geneiales como POO, aplicacion de listas en la construccón de matrices, espacio en memria de las variables, etc. Sin embargo no lo sustituye debido a que le falta contenido como ampliar en los metodos de listas, tuplas, diccionarios, sets (de lo cual no habló), operadores de pertenencia, operadores lógicos, etc.

espectacular! ahora a poner todo en práctica

```js print(f"muchas gracias, me encanto el curso") ```

Excelente curso, Gracias Carla.

Carla, me gustó el curso, tarde bastante en terminar el proyecto y quisiera compartirtelo para que lo revises si es posible y me comentes si tienes algo que añadir o acotar, espero haberlo hecho bien, aprendí bastante, muchas gracias. ```python import random class Mar: def __init__(self): self.tablero = [["-" for pos in range(8)] for pos in range(8)] def show_dashboard(self): for i in self.tablero: print(" ".join(i)) class Barco: def __init__(self, type_ship, size,ship_id) -> None: self.type_ship = type_ship self.size = size self.ship_id = ship_id self.available = True class Distribuidor: def __init__(self): self.ships = [] def create_ship(self, ship): self.ships.append(ship) #print(f"Creando barco... ¡Listo! {ship.type_ship} de tamaño {ship.size} ha sido creado") def show_ship(self): print("🚢 Barcos en la Flota: 🚢") for i in self.ships: print(f"- Barco {i.type_ship} tamaño {i.size}. Estado: {'🟢 Disponible' if i.available else '🔴 No disponible'}") def show_available(self): print(f"\n⚓ Barcos Disponibles: ⚓") contador = 0 available_ships = [ship for ship in self.ships if ship.available] if available_ships: for ship in available_ships: print(f"- {contador+1}. {ship.type_ship}, tamaño {ship.size}.") contador += 1 else: print("🏴‍☠️ No hay barcos disponibles, ¡al abordaje! 🏴‍☠️") def transfer_ship_to_player(self, ship: Barco): if ship.available: ship.available = False print(f"🚢 ¡El Barco {ship.type_ship} ha sido transferido al jugador! 🚢") else: print(f"🚫 ¡El Barco {ship.type_ship} ya ha sido transferido a otro jugador! 🚫") class Jugador: def __init__(self, name): self.name = name self.fleet = [] self.impacts = 0 self.fails = 0 def add_ship(self, ship): if ship.available: self.fleet.append(ship) print(f"🚤 ¡El Barco {ship.type_ship} ha sido añadido a tu flota, {self.name}! 🚤") else: print(f"⚓ ¡El Barco {ship.type_ship} no se ha podido añadir a tu flota, parece que otro marinero lo ha elegido primero! ⚓") def place_ship(self, tablero: Mar, ship: Barco): while True: orientacion = input(f"🧭 {self.name}, elige la orientación del barco. Escribe 'V' para Vertical o 'H' para Horizontal -> ").upper() if orientacion not in ["V", "H"]: print("❌ ¡Escribe una orientación válida, marinero! 'V' o 'H' ❌") continue lista = [] while True: try: fila = int(input(f"🌊 {self.name}, elige la fila para colocar tu barco en el tablero ({len(tablero.tablero[0])} x {len(tablero.tablero)}): -> ")) if fila not in range(1, len(tablero.tablero) + 1): print("🚫 ¡Esa fila está fuera de los límites del tablero! 🚫") continue columna = int(input(f"🌊 {self.name}, elige la columna para colocar tu barco en el tablero ({len(tablero.tablero[0])} x {len(tablero.tablero)}): -> ")) if columna not in range(1, len(tablero.tablero[0]) + 1): print("🚫 ¡Esa columna está fuera de los límites del tablero! 🚫") continue if orientacion == "V": if fila + ship.size - 1 > len(tablero.tablero): print(f"❌ ¡No puedes colocar un barco de tamaño {ship.size} desde la fila {fila} porque excede los límites del tablero! ❌") continue lista = [(fila - 1 + p, columna - 1) for p in range(ship.size)] else: # Orientación "H" if columna + ship.size - 1 > len(tablero.tablero[0]): print(f"❌ ¡No puedes colocar un barco de tamaño {ship.size} desde la columna {columna} porque excede los límites del tablero! ❌") continue lista = [(fila - 1, columna - 1 + p) for p in range(ship.size)] if any(tablero.tablero[p[0]][p[1]] != "-" for p in lista): # Verificar superposición print(f"🚫 ¡El barco no puede colocarse porque se superpone a otro barco! 🚫") continue for p in lista: # Colocar el barco en el tablero tablero.tablero[p[0]][p[1]] = self.name[0]+ship.ship_id[0] tablero.show_dashboard() break # Salir del bucle de colocación de barco except ValueError: print("❌ ¡Entrada no válida! Debes ingresar un número, marinero. ❌") continue break # Salir del bucle de orientación def show_fleet(self): for ship in self.fleet: print(f"- {ship.type_ship} tamaño {ship.size}") # Funciones del juego def lanzar_moneda(jugador1: Jugador, jugador2: Jugador): print(f"\n🪙 ¡Vamos a lanzar una moneda al aire para decidir quién comenzará! 🪙") moneda = random.choice(["1", "2"]) while True: choiceplayer1 = input(f"\n{jugador1.name}, elige: Escribe 1 para 'Cara' o 2 para 'Sello' -> ") match choiceplayer1: case "1": print(f"⚓ {jugador1.name} ha elegido Cara, {jugador2.name} se queda con Sello. ¡Lanzando moneda! ⚓") match moneda: case "1": print(f"🎉 ¡Cara! {jugador1.name} ha ganado y puede elegir primero sus barcos y orientarlos.") return jugador1, jugador2 case "2": print(f"🎉 ¡Sello! {jugador2.name} ha ganado y puede elegir primero sus barcos y orientarlos.") return jugador2, jugador1 case "2": print(f"⚓ {jugador1.name} ha elegido Sello, {jugador2.name} se queda con Cara. ¡Lanzando moneda! ⚓") match moneda: case "1": print(f"🎉 ¡Cara! {jugador2.name} ha ganado y puede elegir primero sus barcos y orientarlos.") return jugador2, jugador1 case "2": print(f"🎉 ¡Sello! {jugador1.name} ha ganado y puede elegir primero sus barcos y orientarlos.") return jugador1, jugador2 case _: print("❌ ¡Elige una opción válida, marinero! ❌") def choice_ships(distribuidor1: Distribuidor, yes_coin: Jugador, no_coin: Jugador, size_ship: int, message1, message2): available_ships = [ship for ship in distribuidor1.ships if ship.size == size_ship and ship.available] print(f"🚢 ¡Elige tus barcos del tamaño {size_ship}, marinero! 🚢") while True: try: print(message1) for index, ship in enumerate(available_ships, start=1): print(f"{index}. {ship.type_ship}, tamaño {ship.size}.") eleccion = int(input(f"⚓ Escribe un número entre 1 y {len(available_ships)} para escoger un barco -> ")) if eleccion in range(1, len(available_ships) + 1): chosen_ship = available_ships[eleccion - 1] print(f"🎉 ¡Genial! Has elegido el {chosen_ship.type_ship}.") yes_coin.add_ship(chosen_ship) distribuidor1.transfer_ship_to_player(chosen_ship) break else: print("❌ ¡Escoge una opción válida, marinero! ❌") continue except ValueError: print("❌ Entrada no válida. Debes ingresar un número, marinero. ❌") available_ships = [ship for ship in distribuidor1.ships if ship.size == size_ship and ship.available] while True: try: print(message2) for index, ship in enumerate(available_ships, start=1): print(f"{index}. {ship.type_ship}, tamaño {ship.size}.") eleccion = int(input(f"⚓ Escribe un número entre 1 y {len(available_ships)} para escoger un barco -> ")) if eleccion in range(1, len(available_ships) + 1): chosen_ship = available_ships[eleccion - 1] print(f"🎉 ¡Genial! Has elegido el {chosen_ship.type_ship}.") no_coin.add_ship(chosen_ship) distribuidor1.transfer_ship_to_player(chosen_ship) break else: print("❌ ¡Escoge una opción válida, marinero! ❌") continue except ValueError: print("❌ Entrada no válida. Debes ingresar un número, marinero. ❌") def eligiendo_barcos(yes_coin: Jugador, no_coin: Jugador, distribuidor1: Distribuidor): message1 = (f"\n🌟 {yes_coin.name}, elige tu primer barco a continuación. ¡Solo puedes escoger uno entre los disponibles! 🌟") message2 = (f"\n🚢 Ahora es el turno de {no_coin.name}. Elige tu primer barco a continuación. ¡Solo puedes escoger uno entre los disponibles! 🚢") choice_ships(distribuidor1, yes_coin, no_coin, 2, message1, message2) choice_ships(distribuidor1, yes_coin, no_coin, 4, message1, message2) choice_ships(distribuidor1, yes_coin, no_coin, 6, message1, message2) print(f"\n🏆 ¡La elección de barcos ha terminado! Aquí están las flotas finales:") print(f"\n🌊 Flota de {yes_coin.name}: 🌊") yes_coin.show_fleet() print(f"\n🌊 Flota de {no_coin.name}: 🌊") no_coin.show_fleet() def play_game(tableroj2: Mar, tableroj1: Mar, yes_coin: Jugador, no_coin: Jugador): print(f"\n🚢 ¡Barcos en sus posiciones! Que comience el ataque. Es tu turno {yes_coin.name} para atacar. 🚢") ronda = 1 while yes_coin.impacts < 3 and no_coin.impacts < 3: while True: print(f"\n⚓ ¡Ronda número {ronda}! ⚓") try: print(f"🔥 ¡{yes_coin.name} ataca! 🔥") attack_fila = int(input(f"Elige una fila para atacar a {no_coin.name}, el tablero tiene {len(tableroj2.tablero)} filas -> ")) if attack_fila not in range(1, len(tableroj2.tablero) + 1): print("❌ Introduce un número dentro del tablero, marinero. ❌") continue attack_column = int(input(f"Elige una columna para atacar a {no_coin.name}, el tablero tiene {len(tableroj2.tablero[0])} columnas -> ")) if attack_column not in range(1, len(tableroj2.tablero[0]) + 1): print("❌ Introduce un número dentro del tablero, marinero. ❌") continue if tableroj2.tablero[attack_fila - 1][attack_column - 1][0] == no_coin.name[0]: ship = tableroj2.tablero[attack_fila - 1][attack_column - 1] print("💥 ¡Impacto! 💥") no_coin.impacts += 1 for i_fila in range(len(tableroj2.tablero)): for i_column in range(len(tableroj2.tablero[i_fila])): if tableroj2.tablero[i_fila][i_column] == ship: tableroj2.tablero[i_fila][i_column] = "-" tableroj2.show_dashboard() print(f"Estadisticas:\nDisparos acertados: {no_coin.impacts} | Fallos: {no_coin.fails}") break else: no_coin.fails += 1 print("🌊 ¡Agua! Tu disparo no ha dado en el blanco. 🌊") print(f"Estadisticas:\nDisparos acertados: {no_coin.impacts} | Fallos: {no_coin.fails}") break except ValueError: print("❌ Introduce un valor numérico, marinero. ❌") while True: try: print(f"⚓ Ahora es el turno de {no_coin.name} para atacar. ⚓") attack_fila = int(input(f"Elige una fila para atacar a {yes_coin.name}, el tablero tiene {len(tableroj1.tablero)} filas -> ")) if attack_fila not in range(1, len(tableroj1.tablero) + 1): print("❌ Introduce un número dentro del tablero, marinero. ❌") continue attack_column = int(input(f"Elige una columna para atacar a {yes_coin.name}, el tablero tiene {len(tableroj1.tablero[0])} columnas -> ")) if attack_column not in range(1, len(tableroj1.tablero[0]) + 1): print("❌ Introduce un número dentro del tablero, marinero. ❌") continue if tableroj1.tablero[attack_fila - 1][attack_column - 1][0] == yes_coin.name[0]: ship = tableroj1.tablero[attack_fila - 1][attack_column - 1] print("💥 ¡Impacto! 💥") yes_coin.impacts += 1 for i_fila in range(len(tableroj1.tablero)): for i_column in range(len(tableroj1.tablero[i_fila])): if tableroj1.tablero[i_fila][i_column] == ship: tableroj1.tablero[i_fila][i_column] = "-" tableroj1.show_dashboard() print(f"Estadisticas:\nDisparos acertados: {yes_coin.impacts} | Fallos: {yes_coin.fails}") break else: yes_coin.fails += 1 print("🌊 ¡Agua! Tu disparo no ha dado en el blanco. 🌊") print(f"Estadisticas:\nDisparos acertados: {yes_coin.impacts} | Fallos: {yes_coin.fails}") break except ValueError: print("❌ Introduce un valor numérico, marinero. ❌") ronda += 1 def main(): # Creando barcos print("🌊 Iniciando procesos... ¡A bordo! 🌊") print("🚢 Creando barcos... 🚢") barco1 = Barco("Patrullero", 2,"1") barco2 = Barco("Cañonera", 2,"2") barco3 = Barco("Submarino", 4,"3") barco4 = Barco("Artillero", 4,"4") barco5 = Barco("Porta Aviones", 6,"5") barco6 = Barco("Buque", 6,"6") print("🎉 ¡Barcos creados y listos para zarpar! 🎉") # Crear distribuidor y añadir barcos al inventario print("⚓ Creando Distribuidor de barcos... ⚓") distribuidor1 = Distribuidor() distribuidor1.create_ship(barco1) distribuidor1.create_ship(barco2) distribuidor1.create_ship(barco3) distribuidor1.create_ship(barco4) distribuidor1.create_ship(barco5) distribuidor1.create_ship(barco6) print("🛳️ ¡Distribuidor de barcos creado! 🛳️") # Creación de tablero print("🗺️ Ubicándonos en el océano... 🗺️") tableroj1 = Mar() tableroj2 = Mar() print("🚤 ¡Ya estamos en el mar, marinero! 🚤") # Inicio del juego, creación de jugadores print(f"👋 ¡Hola Marinos! Bienvenidos a la Batalla Naval. Ahora vamos a registrarlos y que comience la campaña: 👋") nombre_jugador1 = input(f"🎖️ Jugador 1, introduce tu nombre -> ") nombre_jugador2 = input(f"🎖️ Jugador 2, introduce tu nombre -> ") jugador1 = Jugador(nombre_jugador1) jugador2 = Jugador(nombre_jugador2) # Elección de quién escoge primero sus barcos lanzando una moneda yes_coin, no_coin = lanzar_moneda(jugador1, jugador2) eligiendo_barcos(yes_coin, no_coin, distribuidor1) # Comenzando el ataque print(f"⚔️ ¡Ahora vamos a comenzar el ataque! ⚔️") print(f"🚢 Marino {yes_coin.name}, vamos a colocar tu barco de tamaño {yes_coin.fleet[0].size}: 🚢") yes_coin.place_ship(tableroj1, yes_coin.fleet[0]) print(f"🚢 Marino {no_coin.name}, vamos a colocar tu barco de tamaño {no_coin.fleet[0].size}: 🚢") no_coin.place_ship(tableroj2, no_coin.fleet[0]) print(f"🚢 Marino {yes_coin.name}, vamos a colocar tu barco de tamaño {yes_coin.fleet[1].size}: 🚢") yes_coin.place_ship(tableroj1, yes_coin.fleet[1]) print(f"🚢 Marino {no_coin.name}, vamos a colocar tu barco de tamaño {no_coin.fleet[1].size}: 🚢") no_coin.place_ship(tableroj2, no_coin.fleet[1]) print(f"🚢 Marino {yes_coin.name}, vamos a colocar tu barco de tamaño {yes_coin.fleet[2].size}: 🚢") yes_coin.place_ship(tableroj1, yes_coin.fleet[2]) print(f"🚢 Marino {no_coin.name}, vamos a colocar tu barco de tamaño {no_coin.fleet[2].size}: 🚢") no_coin.place_ship(tableroj2, no_coin.fleet[2]) play_game(tableroj2, tableroj1, yes_coin, no_coin) if __name__ == "__main__": main() ```import random class Mar:    def \_\_init\_\_(self):        self.tablero = \[\["-" for pos in range(8)] for pos in range(8)]     def show\_dashboard(self):        for i in self.tablero:            print("   ".join(i)) class Barco:    def \_\_init\_\_(self, type\_ship, size,ship\_id) -> None:        self.type\_ship = type\_ship        self.size = size        self.ship\_id = ship\_id        self.available = True class Distribuidor:    def \_\_init\_\_(self):        self.ships = \[]     def create\_ship(self, ship):        self.ships.append(ship)        #print(f"Creando barco... ¡Listo! {ship.type\_ship} de tamaño {ship.size} ha sido creado")     def show\_ship(self):        print("🚢 Barcos en la Flota: 🚢")        for i in self.ships:            print(f"- Barco {i.type\_ship} tamaño {i.size}. Estado: {'🟢 Disponible' if i.available else '🔴 No disponible'}")     def show\_available(self):        print(f"\n⚓ Barcos Disponibles: ⚓")        contador = 0        available\_ships = \[ship for ship in self.ships if ship.available]        if available\_ships:            for ship in available\_ships:                print(f"- {contador+1}. {ship.type\_ship}, tamaño {ship.size}.")                contador += 1        else:            print("🏴‍☠️ No hay barcos disponibles, ¡al abordaje! 🏴‍☠️")     def transfer\_ship\_to\_player(self, ship: Barco):        if ship.available:            ship.available = False            print(f"🚢 ¡El Barco {ship.type\_ship} ha sido transferido al jugador! 🚢")        else:            print(f"🚫 ¡El Barco {ship.type\_ship} ya ha sido transferido a otro jugador! 🚫") class Jugador:    def \_\_init\_\_(self, name):        self.name = name        self.fleet = \[]        self.impacts = 0        self.fails = 0        def add\_ship(self, ship):        if ship.available:            self.fleet.append(ship)            print(f"🚤 ¡El Barco {ship.type\_ship} ha sido añadido a tu flota, {self.name}! 🚤")        else:            print(f"⚓ ¡El Barco {ship.type\_ship} no se ha podido añadir a tu flota, parece que otro marinero lo ha elegido primero! ⚓")        def place\_ship(self, tablero: Mar, ship: Barco):        while True:            orientacion = input(f"🧭 {self.name}, elige la orientación del barco. Escribe 'V' para Vertical o 'H' para Horizontal -> ").upper()            if orientacion not in \["V", "H"]:                print("❌ ¡Escribe una orientación válida, marinero! 'V' o 'H' ❌")                continue                        lista = \[]            while True:                try:                    fila = int(input(f"🌊 {self.name}, elige la fila para colocar tu barco en el tablero ({len(tablero.tablero\[0])} x {len(tablero.tablero)}): -> "))                    if fila not in range(1, len(tablero.tablero) + 1):                        print("🚫 ¡Esa fila está fuera de los límites del tablero! 🚫")                        continue                     columna = int(input(f"🌊 {self.name}, elige la columna para colocar tu barco en el tablero ({len(tablero.tablero\[0])} x {len(tablero.tablero)}): -> "))                    if columna not in range(1, len(tablero.tablero\[0]) + 1):                        print("🚫 ¡Esa columna está fuera de los límites del tablero! 🚫")                        continue                                        if orientacion == "V":                        if fila + ship.size - 1 > len(tablero.tablero):                            print(f"❌ ¡No puedes colocar un barco de tamaño {ship.size} desde la fila {fila} porque excede los límites del tablero! ❌")                            continue                        lista = \[(fila - 1 + p, columna - 1) for p in range(ship.size)]                     else: # Orientación "H"                        if columna + ship.size - 1 > len(tablero.tablero\[0]):                            print(f"❌ ¡No puedes colocar un barco de tamaño {ship.size} desde la columna {columna} porque excede los límites del tablero! ❌")                            continue                        lista = \[(fila - 1, columna - 1 + p) for p in range(ship.size)]                                        if any(tablero.tablero\[p\[0]]\[p\[1]] != "-" for p in lista): # Verificar superposición                        print(f"🚫 ¡El barco no puede colocarse porque se superpone a otro barco! 🚫")                        continue                     for p in lista: # Colocar el barco en el tablero                        tablero.tablero\[p\[0]]\[p\[1]] = self.name\[0]+ship.ship\_id\[0]                    tablero.show\_dashboard()                    break # Salir del bucle de colocación de barco                                except ValueError:                    print("❌ ¡Entrada no válida! Debes ingresar un número, marinero. ❌")                    continue             break # Salir del bucle de orientación     def show\_fleet(self):        for ship in self.fleet:            print(f"- {ship.type\_ship} tamaño {ship.size}") \# Funciones del juegodef lanzar\_moneda(jugador1: Jugador, jugador2: Jugador):    print(f"\n🪙 ¡Vamos a lanzar una moneda al aire para decidir quién comenzará! 🪙")    moneda = random.choice(\["1", "2"])    while True:        choiceplayer1 = input(f"\n{jugador1.name}, elige: Escribe 1 para 'Cara' o 2 para 'Sello' -> ")        match choiceplayer1:            case "1":                print(f"⚓ {jugador1.name} ha elegido Cara, {jugador2.name} se queda con Sello. ¡Lanzando moneda! ⚓")                match moneda:                    case "1":                        print(f"🎉 ¡Cara! {jugador1.name} ha ganado y puede elegir primero sus barcos y orientarlos.")                        return jugador1, jugador2                    case "2":                        print(f"🎉 ¡Sello! {jugador2.name} ha ganado y puede elegir primero sus barcos y orientarlos.")                        return jugador2, jugador1            case "2":                print(f"⚓ {jugador1.name} ha elegido Sello, {jugador2.name} se queda con Cara. ¡Lanzando moneda! ⚓")                match moneda:                    case "1":                        print(f"🎉 ¡Cara! {jugador2.name} ha ganado y puede elegir primero sus barcos y orientarlos.")                        return jugador2, jugador1                    case "2":                        print(f"🎉 ¡Sello! {jugador1.name} ha ganado y puede elegir primero sus barcos y orientarlos.")                        return jugador1, jugador2            case \_:                print("❌ ¡Elige una opción válida, marinero! ❌") def choice\_ships(distribuidor1: Distribuidor, yes\_coin: Jugador, no\_coin: Jugador, size\_ship: int, message1, message2):    available\_ships = \[ship for ship in distribuidor1.ships if ship.size == size\_ship and ship.available]    print(f"🚢 ¡Elige tus barcos del tamaño {size\_ship}, marinero! 🚢")    while True:        try:            print(message1)            for index, ship in enumerate(available\_ships, start=1):                print(f"{index}. {ship.type\_ship}, tamaño {ship.size}.")            eleccion = int(input(f"⚓ Escribe un número entre 1 y {len(available\_ships)} para escoger un barco -> "))            if eleccion in range(1, len(available\_ships) + 1):                chosen\_ship = available\_ships\[eleccion - 1]                print(f"🎉 ¡Genial! Has elegido el {chosen\_ship.type\_ship}.")                yes\_coin.add\_ship(chosen\_ship)                distribuidor1.transfer\_ship\_to\_player(chosen\_ship)                break            else:                print("❌ ¡Escoge una opción válida, marinero! ❌")                continue        except ValueError:            print("❌ Entrada no válida. Debes ingresar un número, marinero. ❌")     available\_ships = \[ship for ship in distribuidor1.ships if ship.size == size\_ship and ship.available]    while True:        try:            print(message2)            for index, ship in enumerate(available\_ships, start=1):                print(f"{index}. {ship.type\_ship}, tamaño {ship.size}.")            eleccion = int(input(f"⚓ Escribe un número entre 1 y {len(available\_ships)} para escoger un barco -> "))            if eleccion in range(1, len(available\_ships) + 1):                chosen\_ship = available\_ships\[eleccion - 1]                print(f"🎉 ¡Genial! Has elegido el {chosen\_ship.type\_ship}.")                no\_coin.add\_ship(chosen\_ship)                distribuidor1.transfer\_ship\_to\_player(chosen\_ship)                break            else:                print("❌ ¡Escoge una opción válida, marinero! ❌")                continue        except ValueError:            print("❌ Entrada no válida. Debes ingresar un número, marinero. ❌") def eligiendo\_barcos(yes\_coin: Jugador, no\_coin: Jugador, distribuidor1: Distribuidor):    message1 = (f"\n🌟 {yes\_coin.name}, elige tu primer barco a continuación. ¡Solo puedes escoger uno entre los disponibles! 🌟")    message2 = (f"\n🚢 Ahora es el turno de {no\_coin.name}. Elige tu primer barco a continuación. ¡Solo puedes escoger uno entre los disponibles! 🚢")    choice\_ships(distribuidor1, yes\_coin, no\_coin, 2, message1, message2)    choice\_ships(distribuidor1, yes\_coin, no\_coin, 4, message1, message2)    choice\_ships(distribuidor1, yes\_coin, no\_coin, 6, message1, message2)    print(f"\n🏆 ¡La elección de barcos ha terminado! Aquí están las flotas finales:")    print(f"\n🌊 Flota de {yes\_coin.name}: 🌊")    yes\_coin.show\_fleet()    print(f"\n🌊 Flota de {no\_coin.name}: 🌊")    no\_coin.show\_fleet() def play\_game(tableroj2: Mar, tableroj1: Mar, yes\_coin: Jugador, no\_coin: Jugador):    print(f"\n🚢 ¡Barcos en sus posiciones! Que comience el ataque. Es tu turno {yes\_coin.name} para atacar. 🚢")    ronda = 1    while yes\_coin.impacts < 3 and no\_coin.impacts < 3:          while True:            print(f"\n⚓ ¡Ronda número {ronda}! ⚓")                  try:                print(f"🔥 ¡{yes\_coin.name} ataca! 🔥")                attack\_fila = int(input(f"Elige una fila para atacar a {no\_coin.name}, el tablero tiene {len(tableroj2.tablero)} filas -> "))                if attack\_fila not in range(1, len(tableroj2.tablero) + 1):                    print("❌ Introduce un número dentro del tablero, marinero. ❌")                    continue                                attack\_column = int(input(f"Elige una columna para atacar a {no\_coin.name}, el tablero tiene {len(tableroj2.tablero\[0])} columnas -> "))                if attack\_column not in range(1, len(tableroj2.tablero\[0]) + 1):                    print("❌ Introduce un número dentro del tablero, marinero. ❌")                    continue                 if tableroj2.tablero\[attack\_fila - 1]\[attack\_column - 1]\[0] == no\_coin.name\[0]:                    ship = tableroj2.tablero\[attack\_fila - 1]\[attack\_column - 1]                    print("💥 ¡Impacto! 💥")                    no\_coin.impacts += 1                    for i\_fila in range(len(tableroj2.tablero)):                        for i\_column in range(len(tableroj2.tablero\[i\_fila])):                            if tableroj2.tablero\[i\_fila]\[i\_column] == ship:                                tableroj2.tablero\[i\_fila]\[i\_column] = "-"                    tableroj2.show\_dashboard()                    print(f"Estadisticas:\nDisparos acertados: {no\_coin.impacts} | Fallos: {no\_coin.fails}")                    break                else:                    no\_coin.fails += 1                    print("🌊 ¡Agua! Tu disparo no ha dado en el blanco. 🌊")                    print(f"Estadisticas:\nDisparos acertados: {no\_coin.impacts} | Fallos: {no\_coin.fails}")                    break                            except ValueError:                print("❌ Introduce un valor numérico, marinero. ❌")         while True:            try:                print(f"⚓ Ahora es el turno de {no\_coin.name} para atacar. ⚓")                attack\_fila = int(input(f"Elige una fila para atacar a {yes\_coin.name}, el tablero tiene {len(tableroj1.tablero)} filas -> "))                if attack\_fila not in range(1, len(tableroj1.tablero) + 1):                    print("❌ Introduce un número dentro del tablero, marinero. ❌")                    continue                                attack\_column = int(input(f"Elige una columna para atacar a {yes\_coin.name}, el tablero tiene {len(tableroj1.tablero\[0])} columnas -> "))                if attack\_column not in range(1, len(tableroj1.tablero\[0]) + 1):                    print("❌ Introduce un número dentro del tablero, marinero. ❌")                    continue                 if tableroj1.tablero\[attack\_fila - 1]\[attack\_column - 1]\[0] == yes\_coin.name\[0]:                    ship = tableroj1.tablero\[attack\_fila - 1]\[attack\_column - 1]                    print("💥 ¡Impacto! 💥")                    yes\_coin.impacts += 1                    for i\_fila in range(len(tableroj1.tablero)):                        for i\_column in range(len(tableroj1.tablero\[i\_fila])):                            if tableroj1.tablero\[i\_fila]\[i\_column] == ship:                                tableroj1.tablero\[i\_fila]\[i\_column] = "-"                    tableroj1.show\_dashboard()                    print(f"Estadisticas:\nDisparos acertados: {yes\_coin.impacts} | Fallos: {yes\_coin.fails}")                    break                else:                    yes\_coin.fails += 1                    print("🌊 ¡Agua! Tu disparo no ha dado en el blanco. 🌊")                    print(f"Estadisticas:\nDisparos acertados: {yes\_coin.impacts} | Fallos: {yes\_coin.fails}")                    break             except ValueError:                print("❌ Introduce un valor numérico, marinero. ❌")                    ronda += 1 def main():    # Creando barcos    print("🌊 Iniciando procesos... ¡A bordo! 🌊")    print("🚢 Creando barcos... 🚢")    barco1 = Barco("Patrullero", 2,"1")    barco2 = Barco("Cañonera", 2,"2")    barco3 = Barco("Submarino", 4,"3")    barco4 = Barco("Artillero", 4,"4")    barco5 = Barco("Porta Aviones", 6,"5")    barco6 = Barco("Buque", 6,"6")    print("🎉 ¡Barcos creados y listos para zarpar! 🎉")     # Crear distribuidor y añadir barcos al inventario    print("⚓ Creando Distribuidor de barcos... ⚓")    distribuidor1 = Distribuidor()    distribuidor1.create\_ship(barco1)    distribuidor1.create\_ship(barco2)    distribuidor1.create\_ship(barco3)    distribuidor1.create\_ship(barco4)    distribuidor1.create\_ship(barco5)    distribuidor1.create\_ship(barco6)    print("🛳️ ¡Distribuidor de barcos creado! 🛳️")        # Creación de tablero    print("🗺️ Ubicándonos en el océano... 🗺️")    tableroj1 = Mar()    tableroj2 = Mar()    print("🚤 ¡Ya estamos en el mar, marinero! 🚤")     # Inicio del juego, creación de jugadores    print(f"👋 ¡Hola Marinos! Bienvenidos a la Batalla Naval. Ahora vamos a registrarlos y que comience la campaña: 👋")    nombre\_jugador1 = input(f"🎖️ Jugador 1, introduce tu nombre -> ")    nombre\_jugador2 = input(f"🎖️ Jugador 2, introduce tu nombre -> ")     jugador1 = Jugador(nombre\_jugador1)    jugador2 = Jugador(nombre\_jugador2)     # Elección de quién escoge primero sus barcos lanzando una moneda    yes\_coin, no\_coin = lanzar\_moneda(jugador1, jugador2)    eligiendo\_barcos(yes\_coin, no\_coin, distribuidor1)        # Comenzando el ataque    print(f"⚔️ ¡Ahora vamos a comenzar el ataque! ⚔️")    print(f"🚢 Marino {yes\_coin.name}, vamos a colocar tu barco de tamaño {yes\_coin.fleet\[0].size}: 🚢")    yes\_coin.place\_ship(tableroj1, yes\_coin.fleet\[0])    print(f"🚢 Marino {no\_coin.name}, vamos a colocar tu barco de tamaño {no\_coin.fleet\[0].size}: 🚢")    no\_coin.place\_ship(tableroj2, no\_coin.fleet\[0])    print(f"🚢 Marino {yes\_coin.name}, vamos a colocar tu barco de tamaño {yes\_coin.fleet\[1].size}: 🚢")    yes\_coin.place\_ship(tableroj1, yes\_coin.fleet\[1])    print(f"🚢 Marino {no\_coin.name}, vamos a colocar tu barco de tamaño {no\_coin.fleet\[1].size}: 🚢")    no\_coin.place\_ship(tableroj2, no\_coin.fleet\[1])    print(f"🚢 Marino {yes\_coin.name}, vamos a colocar tu barco de tamaño {yes\_coin.fleet\[2].size}: 🚢")    yes\_coin.place\_ship(tableroj1, yes\_coin.fleet\[2])    print(f"🚢 Marino {no\_coin.name}, vamos a colocar tu barco de tamaño {no\_coin.fleet\[2].size}: 🚢")    no\_coin.place\_ship(tableroj2, no\_coin.fleet\[2])    play\_game(tableroj2, tableroj1, yes\_coin, no\_coin) if \_\_name\_\_ == "\_\_main\_\_":    main()

Esta es mi respuesta al reto y muchas gracias, excelente curso. ```js # 3 barcos con tamanos diferentes en matriz # 2 jugadores, cada uno con su matriz # se atacan uno a otro adivinando las posiciones # gana el jugador que adivine las posiciones del oponente # Bienvenido al juego de bataal Naval # Jugador 1 coloca sus barcos # Jugador 1 coloca su destructor de tamano 2 # Fila Inicial import random class Ship: def __init__(self, initial_position_x, initial_position_y, orientation): self.initial_position_x = initial_position_x self.initial_position_y = initial_position_y self.orientation = orientation def check_place(self): print(f'La posicion inicial del barco es {self.initial_position_x} en x, {self.initial_position_y} en y, con orientación {self.orientation}') class Portaaviones(Ship): def __init__(self, initial_position_x, initial_position_y, orientation ): super().__init__(initial_position_x, initial_position_y, orientation) self.name = 'Portaaviones' self.id = 'P' self.hits_taken = 0 self.lenght = 4 def ship_status(self): print(f'Las vidas predeterminadas de tu {self.name} son: {self.lenght}, las vidas actuales que tiene son: {self.lenght-self.hits_taken}') def hit_ship(self): self.hits_taken = self.hits_taken + 1 print(f'La nave ha sido golpeada, su vida actual es {self.lenght - self.hits_taken}') class Submarino(Ship): def __init__(self, initial_position_x, initial_position_y, orientation ): super().__init__(initial_position_x, initial_position_y, orientation) self.name = 'Submarino' self.id = 'S' self.hits_taken = 0 self.lenght = 3 def ship_status(self): print(f'Las vidas predeterminadas de tu {self.name} son: {self.lenght}, las vidas actuales que tiene son: {self.lenght-self.hits_taken}') def hit_ship(self): self.hits_taken = self.hits_taken + 1 print(f'La nave ha sido golpeada, su vida actual es {self.lenght - self.hits_taken}') class Destructor(Ship): def __init__(self, initial_position_x, initial_position_y, orientation ): super().__init__(initial_position_x, initial_position_y, orientation) self.name = 'Destructor' self.id = 'D' self.hits_taken = 0 self.lenght = 2 def ship_status(self): print(f'Las vidas predeterminadas de tu {self.name} son: {self.lenght}, las vidas actuales que tiene son: {self.lenght-self.hits_taken}') def hit_ship(self): self.hits_taken = self.hits_taken + 1 print(f'La nave ha sido golpeada, su vida actual es {self.lenght - self.hits_taken}') class Fragata(Ship): def __init__(self, initial_position_x, initial_position_y, orientation ): super().__init__(initial_position_x, initial_position_y, orientation) self.name = 'Fragata' self.id = 'F' self.hits_taken = 0 self.lenght = 1 def ship_status(self): print(f'Las vidas predeterminadas de tu {self.name} son: {self.lenght}, las vidas actuales que tiene son: {self.lenght-self.hits_taken}') def hit_ship(self): self.hits_taken = self.hits_taken + 1 print(f'La nave ha sido golpeada, su vida actual es {self.lenght - self.hits_taken}') class Player: def __init__(self, name): self.name = name class Human(Player): def __init__(self, name): super().__init__(name) self.ships = [] def check_user_name(self): print(f'Bienvenida o bienvenido: {self.name}') def set_ships(self, ship): self.ships.append(ship) print(f'Acabas de agregar la nave: {ship.name}, coordenadas {ship.initial_position_x} en x y {ship.initial_position_x} en y') def disparar(self, x, y): coord_x = int(x) coord_y = int(y) print(f'Acabas de dispirar en la coordenada {coord_x} en x y {coord_y} en y') class Computer(Player): def __init__(self, name): super().__init__(name) ships_array = [] opciones = [ 'Vertical', 'Horizontal', ] PortaavionesComputer = Portaaviones(int(random.random() * 10),int(random.random() * 10),opciones[int(round(random.random(),0)*1)]) SubmarinoComputer = Submarino(int(random.random() * 10),int(random.random() * 10),opciones[int(round(random.random(),0)*1)]) DestructorComputer = Destructor(int(random.random() * 10),int(random.random() * 10),opciones[int(round(random.random(),0)*1)]) FragataComputer = Fragata(int(random.random() * 10),int(random.random() * 10),opciones[int(round(random.random(),0)*1)]) ships_array.append(PortaavionesComputer) ships_array.append(SubmarinoComputer) ships_array.append(DestructorComputer) ships_array.append(FragataComputer) self.ships = ships_array[:] def check_user_name(self): print(f'Soy {self.name}, tu oponente') def set_ships(self, ship): self.ships.append(ship) print(f'Ahora tengo la nave: {ship.name}') def disparar(self): x = int(random.random() * 10) y = int(random.random() * 10) print(f'Acabas de dispirar en la coordenada {x} en x y {y} en y') class Board: def __init__(self): board_x = [] x = 0 while x < 10: board_y = [] y = 0 while y < 10: board_y.append('.') y += 1 board_x.append(board_y) x += 1 self.board = board_x def show(self): i = 1 while i < 11 : print(f'{self.board[i-1:i]}') i += 1 class Player_Board(Board): def __init__(self, player): super().__init__() self.player = player i = 0 while i < len(player.ships): n = 0 while n < player.ships[i].lenght: if player.ships[i].orientation == 'Horizontal': self.board[player.ships[i].initial_position_y - 1][player.ships[i].initial_position_x - 1 + n] = str(player.ships[i].id) elif player.ships[i].orientation == 'Vertical': self.board[player.ships[i].initial_position_y - 1 + n][player.ships[i].initial_position_x - 1] = str(player.ships[i].id) n += 1 i += 1 def show_player_board(self): print(f'Est es el tablero de {self.player.name}') self.show() def attack(self): x = int(random.random() * 10) y = int(random.random() * 10) attacked_item = self.board[y-1][x-1] # Busca el barco correspondiente basado en su id for ship in self.player.ships: if ship.id == attacked_item: # Esto encuentra el barco correcto ship.hits_taken += 1 remaining_lifes = ship.lenght - ship.hits_taken if remaining_lifes == 0: print(f'El barco {ship.name} ha sido hundido') self.player.ships.remove(ship) # Remueve el barco hundido break self.board[y-1][x-1] = 'X' print(f'Han atacado atacado al tablero de {self.player.name}') self.show() class Computer_Board(Board): def __init__(self, player): super().__init__() self.player = player board_x = [] x = 0 while x < 10: board_y = [] y = 0 while y < 10: board_y.append('-') y += 1 board_x.append(board_y) x += 1 i = 0 while i < len(player.ships): n = 0 while n < player.ships[i].lenght: if player.ships[i].orientation == 'Horizontal': self.board[player.ships[i].initial_position_y - 1][player.ships[i].initial_position_x - 1 + n] = str(player.ships[i].id) elif player.ships[i].orientation == 'Vertical': self.board[player.ships[i].initial_position_y - 1 + n][player.ships[i].initial_position_x - 1] = str(player.ships[i].id) n += 1 i += 1 self.hidden_ships = board_x def show_player_board(self): print(f'Est es el tablero de {self.player.name}') self.show() def attack(self, x, y): attacked_item = self.board[y-1][x-1] # Busca el barco correspondiente basado en su id for ship in self.player.ships: if ship.id == attacked_item: # Esto encuentra el barco correcto ship.hits_taken += 1 remaining_lifes = ship.lenght - ship.hits_taken if remaining_lifes == 0: print(f'El barco {ship.name} ha sido hundido') self.player.ships.remove(ship) # Remueve el barco hundido break self.board[y-1][x-1] = 'X' print(f'Han atacado atacado al tablero de {self.player.name}') self.show() def juego(): print('Vamos a jugar Batalla Naval') print('Si en algún momento el juego te marca error, para el juego con CTRL + C y vuelve a correr la funcion juego(), empezarás de cero pero podrás jugar.') opcion = str(input('¿Quieres jugar un juego de configuración rápida? (Escribe S para o N para no ): ')) if opcion == 'S' or opcion == 's' or opcion == 'Si' or opcion == 'si' or opcion == 'Sí' or opcion == 'sí': human_name = 'Fulane' human = Human(human_name) computer_name = 'Computina' computer = Computer(computer_name) PortaavionesX = 1 PortaavionesY = 1 PortaavionesOrientacion = 'Horizontal' human.set_ships(Portaaviones(PortaavionesX,PortaavionesY,PortaavionesOrientacion)) SubmarinoX = 2 SubmarinoY = 2 SubmarinoOrientacion = 'Horizontal' human.set_ships(Submarino(SubmarinoX,SubmarinoY,SubmarinoOrientacion)) DestructorX = 3 DestructorY = 3 DestructorOrientacion = 'Horizontal' human.set_ships(Destructor(DestructorX,DestructorY,DestructorOrientacion)) FragataX = 4 FragataY = 4 FragataOrientacion = 'Horizontal' human.set_ships(Fragata(FragataX,FragataY,FragataOrientacion)) player_board = Player_Board(human) player_board.show_player_board() computer_board = Computer_Board(computer) computer_board.show_player_board() x = 0 while x < 15: print('¡Vamos a atacar!') atack_x_axis = int(input('Escoge la coordenada en x que quieres atacar del 1 al 10 (números enteros): ')) atack_y_axis = int(input('Escoge la coordenada en x que quieres atacar del 1 al 10 (números enteros): ')) computer_board.attack(atack_x_axis,atack_y_axis) if int(len(computer.ships)) == 0: print('A lo computadora no le quedan naves, has GANADO.') break else: print(f'Aun le quedan a la computadora {int(len(computer.ships))} naves') print('¡Le toca a la computadora atacar!') player_board.attack() if int(len(human.ships)) == 0: print('No te quedan naves, has perdido.') break else: print(f'Aun te quedan {int(len(human.ships))} naves') else: human_name = str(input('¿Cuál es tu nombre?: ')) human = Human(human_name) computer_name = str(input('¿Cuál es el nombre de tu rival?: ')) computer = Computer(computer_name) PortaavionesX = int(input('Ingresa las coordenadas x de tu Portaaviones: ')) PortaavionesY = int(input('Ingresa las coordenadas x de tu Portaaviones: ')) PortaavionesOrientacion = str(input('Ingresa la orientación de tu Portaaviones (Horizontal o Vertical): ')) human.set_ships(Portaaviones(PortaavionesX,PortaavionesY,PortaavionesOrientacion)) SubmarinoX = int(input('Ingresa las coordenadas x de tu Submarino: ')) SubmarinoY = int(input('Ingresa las coordenadas x de tu Submarino: ')) SubmarinoOrientacion = str(input('Ingresa la orientación de tu Submarino (Horizontal o Vertical): ')) human.set_ships(Submarino(SubmarinoX,SubmarinoY,SubmarinoOrientacion)) DestructorX = int(input('Ingresa las coordenadas x de tu Destructor: ')) DestructorY = int(input('Ingresa las coordenadas x de tu Destructor: ')) DestructorOrientacion = str(input('Ingresa la orientación de tu Destructor (Horizontal o Vertical): ')) human.set_ships(Destructor(DestructorX,DestructorY,DestructorOrientacion)) FragataX = int(input('Ingresa las coordenadas x de tu Fragata: ')) FragataY = int(input('Ingresa las coordenadas x de tu Fragata: ')) FragataOrientacion = str(input('Ingresa la orientación de tu Fragata (Horizontal o Vertical): ')) human.set_ships(Fragata(FragataX,FragataY,FragataOrientacion)) player_board = Player_Board(human) player_board.show_player_board() computer_board = Computer_Board(computer) computer_board.show_player_board() x = 0 while x < 15: print('¡Vamos a atacar!') atack_x_axis = int(input('Escoge la coordenada en x que quiers atacar del 1 al 10 (números enteros): ')) atack_y_axis = int(input('Escoge la coordenada en x que quiers atacar del 1 al 10 (números enteros): ')) computer_board.attack(atack_x_axis,atack_y_axis) print(f'Aun le quedan a la computadora {int(len(computer.ships))} naves') if int(len(computer.ships)) == 0: 'A lo computadora no le quedan naves, has GANADO.' break print('¡Le toca a la computadora atacar!') player_board.attack() print(f'Aun te quedan {int(len(human.ships))} naves') if int(len(human.ships)) == 0: 'No te quedan naves, has perdido.' break juego() ```

Muchas gracias por el curso aprendí bastante

👏👏👏👏👏 Tremendo Curso, ya presenté, pero me queda repasar... sobre todo POO @carlicode tiene mis 5 Estrellas completas....

👏👏👏👏👏 Tremendo Curso, ya presenté, pero me queda repasar... sobre todo POO @carlicode tiene mis 5 ⭐⭐⭐⭐⭐

import random def crear\_cuadricula():    return \[\['~' for \_ in range(5)] for \_ in range(5)] def imprimir\_cuadricula(cuadricula):    print("  1 2 3 4 5")    for i in range(5):        print(chr(65 + i), ' '.join(cuadricula\[i])) def colocar\_barcos(cuadricula, num\_barcos):    for \_ in range(num\_barcos):        while True:            fila = random.randint(0, 4)            columna = random.randint(0, 4)            if cuadricula\[fila]\[columna] == '~':                cuadricula\[fila]\[columna] = 'O'                break def pedir\_ataque():    while True:        try:            ataque = input("Ingresa la posición de tu ataque (Ejemplo: A1): ").strip().upper()            fila = ord(ataque\[0]) - 65            columna = int(ataque\[1]) - 1            if 0 <= fila <= 4 and 0 <= columna <= 4:                return fila, columna            else:                print("Posición fuera de rango. Inténtalo de nuevo.")        except (IndexError, ValueError):            print("Entrada inválida. Inténtalo de nuevo.") def verificar\_ataque(cuadricula, fila, columna):    if cuadricula\[fila]\[columna] == 'O':        cuadricula\[fila]\[columna] = 'X'        return True    return False def verificar\_victoria(cuadricula):    for fila in cuadricula:        if 'O' in fila:            return False    return True def jugar\_guerra\_naval():    print("¡Bienvenido a la Guerra Naval!")        print("\nJugador 1, coloca tus barcos:")    cuadricula\_jugador1 = crear\_cuadricula()    colocar\_barcos(cuadricula\_jugador1, 3)    imprimir\_cuadricula(cuadricula\_jugador1)        print("\nJugador 2, coloca tus barcos:")    cuadricula\_jugador2 = crear\_cuadricula()    colocar\_barcos(cuadricula\_jugador2, 3)    imprimir\_cuadricula(cuadricula\_jugador2)        turno = 1    while True:        if turno == 1:            print("\nTurno del Jugador 1:")            imprimir\_cuadricula(cuadricula\_jugador2)             fila, columna = pedir\_ataque()            if verificar\_ataque(cuadricula\_jugador2, fila, columna):                print("¡Ataque exitoso!")                if verificar\_victoria(cuadricula\_jugador2):                    print("¡El Jugador 1 ha ganado!")                    break            else:                print("¡Ataque fallido!")            turno = 2        else:            print("\nTurno del Jugador 2:")            imprimir\_cuadricula(cuadricula\_jugador1)              fila, columna = pedir\_ataque()            if verificar\_ataque(cuadricula\_jugador1, fila, columna):                print("¡Ataque exitoso!")                if verificar\_victoria(cuadricula\_jugador1):                    print("¡El Jugador 2 ha ganado!")                    break            else:                print("¡Ataque fallido!")            turno = 1 \# Iniciar el juegojugar\_guerra\_naval()

creo que es impresindible estudiar el texto que esta en la seccion de recursos para entender que implica su construccion, como fue formado y la estructura mental del programa que hay que poseer\*(diagrama de flujo pseudocodigo) para poder pasar a texto un ejemplo similar. por aquello de chat gpt

Este es el código de la profe :D ```python class Ship: def __init__(self, name, size): self.name = name self.size = size self.positions = [] self.hits = 0 def place_ship(self, start_row, start_col, direction, board): positions = [] if direction == 'H': if start_col + self.size > len(board[0]): return False for i in range(self.size): if board[start_row][start_col + i] != ' ': return False positions.append((start_row, start_col + i)) elif direction == 'V': if start_row + self.size > len(board): return False for i in range(self.size): if board[start_row + i][start_col] != ' ': return False positions.append((start_row + i, start_col)) else: return False for pos in positions: board[pos[0]][pos[1]] = self.name[0] self.positions = positions return True def hit(self): self.hits += 1 return self.hits == self.size class Destroyer(Ship): def __init__(self): super().__init__('Destructor', 2) class Submarine(Ship): def __init__(self): super().__init__('Submarino', 3) class Battleship(Ship): def __init__(self): super().__init__('Acorazado', 4) class Player: def __init__(self, name): self.name = name self.board = [[' ' for _ in range(10)] for _ in range(10)] self.ships = [] self.hits = [[' ' for _ in range(10)] for _ in range(10)] def place_ships(self): ships = [Destroyer(), Submarine(), Battleship()] for ship in ships: while True: print(f"{self.name}, coloca tu {ship.name} de tamaño {ship.size}.") start_row = int(input("Fila inicial: ")) start_col = int(input("Columna inicial: ")) direction = input("Dirección (H para horizontal, V para vertical): ").upper() if ship.place_ship(start_row, start_col, direction, self.board): self.ships.append(ship) self.print_board(self.board) break else: print("Posición no válida. Inténtalo de nuevo.") def print_board(self, board): for row in board: print(" ".join(row)) print() def attack(self, opponent): while True: print(f"{self.name}, elige una posición para atacar.") row = int(input("Fila: ")) col = int(input("Columna: ")) if 0 <= row < 10 and 0 <= col < 10: if opponent.board[row][col] == ' ': print("Agua!") self.hits[row][col] = 'A' opponent.board[row][col] = 'A' break elif opponent.board[row][col] != 'A': print("Impacto!") self.hits[row][col] = 'T' for ship in opponent.ships: if (row, col) in ship.positions: if ship.hit(): print(f"¡Hundido! Has hundido el {ship.name}.") break opponent.board[row][col] = 'T' break else: print("Ya has atacado esta posición. Intenta de nuevo.") else: print("Posición no válida. Intenta de nuevo.") def all_ships_sunk(self): return all(ship.hits == ship.size for ship in self.ships) class BattleshipGame: def __init__(self): self.player1 = Player("Jugador 1") self.player2 = Player("Jugador 2") def play(self): print("Bienvenido al juego de Batalla Naval!") print("Jugador 1 coloca sus barcos.") self.player1.place_ships() print("Jugador 2 coloca sus barcos.") self.player2.place_ships() current_player = self.player1 opponent = self.player2 while True: current_player.attack(opponent) if opponent.all_ships_sunk(): print(f"¡{current_player.name} ha ganado el juego!") break current_player, opponent = opponent, current_player # Crear una instancia del juego y jugar game = BattleshipGame() game.play() ```

El proyecto me parece un reto bastante complicado, pero me gusta. Hace varios años tomé los cursos de Python anteriores. Me parece que explicaban mejor los conceptos; sin embargo, este curso es menos tedioso/pesado. Aún me falta la mitad, porque de repente, de tener 36 clases, me aparecen 63. Eso quiere decir que lo complementaron, y ya quiero terminarlo para saber cuántos conceptos nuevos añadieron.

Dejo el codigo del reto del juego de batalla naval. Implemente librerias, metodo constructor entre otras cosas vistas en las anteriores clases. ```js import tkinter as tk #Libreria tkinter from tkinter import messagebox #Libreria messagebox import random #Libreria random import json #Libreria json #El proyecto esta organizado en una clase principal "Batalla Naval" que maneja la logica del juego y su interfaz grafica con Tkinter. #1.Configuracion Inicial - definimos la clase class BatallaNaval: def __init__(self): self.window = tk.Tk() #Crear la ventana principal de Tkinter self.window.title("Batalla Naval") #Titulo de la ventana self.tamano_tablero = 5 #Tamaño Inicial del tablero self.num_barcos = 3 #Numero de barcos por defecto self.dificultad = "Facil" #Dificultad por defecto self.menu_principal() #Muestra el menu principal #2. Definiendo el Menu Principal def menu_principal(self): #Limpiamos la ventana actual for widget in self.window.winfo_children(): widget.destroy() #Agregamos opciones al menu tk.Label(self.window, text="Batalla Naval", font=("Arial", 20)).pack(pady=20) tk.Button(self.window, text="Iniciar Juego", font=("Arial", 14), command=self.configurar_juego).pack(pady=10) #Configuramos el boton de start tk.Button(self.window, text="Cargar Partida", font=("Arial", 14), command=self.cargar_partida).pack(pady=10) #Configurar el boton de cargar partida tk.Button(self.window, text="Salir", font=("Arial", 14), command=self.window.quit).pack(pady=10) #Configuramos el boton de salir #3. definiendo la configuracion del Juego def configurar_juego(self): for widget in self.window.winfo_children(): widget.destroy() tk.Label(self.window, text="Configurar Juego", font=("Arial", 18)).pack(pady=10) #Definimos el tamaño del tablero tk.Label(self.window, text="Tamaño del tablero:", font=("Arial", 14)).pack(pady=5) self.tamano_var = tk.IntVar(value=self.tamano_tablero) tk.OptionMenu(self.window, self.tamano_var, 5, 7, 10).pack() #Seleccionamos la dificultad tk.Label(self.window, text="Dificultad:", font=("Arial", 14)).pack(pady=5) self.dificultad_var = tk.StringVar(value=self.dificultad) tk.OptionMenu(self.window, self.dificultad_var, "Facil", "Dificil").pack() #Numero de Barcos tk.Label(self.window, text="Numero de barcos:", font=("Arial", 14)).pack(pady=5) self.num_barcos_var = tk.IntVar(value=self.num_barcos) tk.Spinbox(self.window, from_=1, to=10, textvariable=self.num_barcos_var).pack() #boton de iniciar tk.Button(self.window, text="Iniciar", font=("Arial", 14), command=self.iniciar_juego).pack(pady=20) #4. Iniciamos el juego def iniciar_juego(self): self.tamano_tablero = self.tamano_var.get() self.num_barcos = self.num_barcos_var.get() self.dificultad = self.dificultad_var.get() self.jugador_tablero = [[" "]*self.tamano_tablero for _ in range(self.tamano_tablero)] #Tablero del usuario self.sentinel_tablero = [[" "]*self.tamano_tablero for _ in range(self.tamano_tablero)] #Tablero de la maquina #Colocamos los barcos self.colocar_barcos(self.sentinel_tablero) self.colocar_barcos(self.jugador_tablero) self.turno_usuario = True self.mostrar_juego() #5. Colocar barcos def colocar_barcos(self, tablero): for _ in range(self.num_barcos): while True: x, y = random.randint(0, self.tamano_tablero - 1), random.randint(0, self.tamano_tablero - 1) if tablero[x][y] == " ": tablero[x][y] = "B" # Pone los barcos en posiciones aleatorias con la letra B break #6. Mostrar el tablero def mostrar_juego(self): for widget in self.window.winfo_children(): widget.destroy() tk.Label(self.window, text="Tu Tablero", font=("Arial", 16)).grid(row=0, column=0, padx=10) tk.Label(self.window, text="Tablero de Sentinel", font=("Arial", 16)).grid(row=0, column=1, padx=10) for i in range(self.tamano_tablero): for j in range(self.tamano_tablero): cell = tk.Label(self.window, text=self.jugador_tablero[i][j], font=("Arial", 14), width=2, height=1, borderwidth=1, relief="solid") cell.grid(row=i+1, column=j) for i in range(self.tamano_tablero): for j in range(self.tamano_tablero): cell = tk.Button(self.window, text="?", font=("Arial", 14), width=2, height=1, command=lambda x=i, y=j: self.disparar(x, y)) cell.grid(row=i+1, column=j+6) #7. Disparo del Usuario def disparar(self, x, y): if self.sentinel_tablero[x][y] == "B": messagebox.showinfo("Impacto!!", "Le diste a un Barco!!") self.sentinel_tablero[x][y] = "X" else: messagebox.showinfo("Fallaste", "Agua") self.sentinel_tablero[x][y] = "O" self.turno_usuario = False self.turno_sentinel() #8. Turno de Sentinel def turno_sentinel(self): if self.dificultad == "Facil": #Disparo Aleatorio while not self.turno_usuario: x, y = random.randint(0, self.tamano_tablero - 1), random.randint(0, self.tamano_tablero - 1) if self.jugador_tablero[x][y] == " ": if self .jugador_tablero[x][y] == "B": messagebox.showinfo("Sentinel Impacta", f"Sentinel hundio tu barco ({x}, {y})") self.jugador_tablero[x][y] = "X" else: self.jugador_tablero[x][y] = "O" self.turno_usuario = True elif self.dificultad == "Dificil": #Disparo Inteligente while not self.turno_usuario: #Buscar Disparo Inteligente disparos_previos = [(i, j) for i in range(self.tamano_tablero) for j in range(self.tamano_tablero) if self.jugador_tablero[i][j] == "X"] objetivo = None #Si se hizo impactos anteriores buscar adyacentes for x, y in disparos_previos: for dx, dy in [(-1, 0), (1, 0), (0, -1), (0,1)]: nx, ny = x + dx, y + dy if 0 <= nx < self.tamano_tablero and 0 <= ny < self.tamano_tablero and self.jugador_tablero[nx][ny] == " ": objetivo = (nx, ny) break if objetivo: break if not objetivo: #Si no se hiz impactos antes, disparar aleatoriamente x, y = random.randint(0, self.tamano_tablero - 1), random.randint(0, self.tamano_tablero - 1) while self.jugador_tablero[x][y] != " ": x, y = random.randint(0, self.tamano_tablero - 1), random.randint(0, self.tamano_tablero - 1) objetivo = (x, y) x, y = objetivo if self.jugador_tablero[x][y] == "B": messagebox.showinfo("Sentinel Impacta", f"Sentinel hundio tu barco en ({x}, {y})") self.jugador_tablero[x][y] = "O" self.turno_usuario = True self.mostrar_juego() #9. Configuramos para guarda la partida def guardar_partida(self): partida = { "tamaño_tablero": self.tamano_tablero, "num_barcos": self.num_barcos, "dificultad": self.dificultad, "jugador_tablero": self.jugador_tablero, "sentinel_tablero": self.sentinel_tablero } with open("batalla_naval_guardado.json", "w") as file: json.dump(partida, file) messagebox.showinfo("Guardar Partida", "La partida ha sido guardado con exito") #10. Configuramos para cargar la partida def cargar_partida(self): try: with open("batalla_naval_guardado.json", "r") as file: partida = json.load(file) self.tamano_tablero = partida["tamano_tablero"] self.num_barcos = partida["num_barcos"] self.dificultad = partida["dificultad"] self.jugador_tablero = partida["jugador_tablero"] self.sentinel_tablero = partida["sentinel_tablero"] self.mostrar_juego() except FileNotFoundError: messagebox.showerror("Error", "No se encontro ninguna partida guardada.") #11. ejecutamos def run(self): self.window.mainloop() #12. Ejecutamos el juego if __name__ == "__main__": juego = BatallaNaval() juego.run() ```

esta clase es mi favorita al momento

Gracias!!!!

Me he dado cuenta de un pequeño error que nunca va a dejar terminar el juego. El nombre Acorazado empieza por A al igual que Agua. Esto nunca les va a permirtir atinar un solo golpe al Acorazado porque el tablero del oponente va a tener una A en las coordenadas del mismo, y tenemos un **elif** que nos dicen que solo debemos registar un impacto si lo que hay allí no es A. Conclusión, o cambian la A de agua, o cambianel nombre Acorazado.

el codigo no estaba tan dificl, pero siento hubo partes que fue dificil entender al 100%, siento que debio haber dos clases, una para dejarnos el proyecto y otra explicandos como hacerlo, algunas cosas si entendi que hacia y podrias hacerlas, pero otras no las entendi bien, entonces si seria buena idea que hubiera otra clase donde se explicara el codigo para asi poder entender todo mejor

Ercoles de un momento a otro agregaron más contenido al curso.

Me pareció buen curso, nos da un acercamiento del alcance de python y definitivamente hay que estar claro que del lado nuestro hay que invertir muchas horas adicionales para tomar confianza y profundizar en la herramienta.

Muy buenos ejercicios y ejemplos ⭐️⭐️⭐️⭐️⭐️

Gracias Carli excelente curso, ojala hayan muchos mas cursos para seguir aprendiendo con la excelencia que te caracteriza. Muchas gracias!.

```python import random # Crear el tablero vacío de 5x5 def crear_tablero(): """ Crea un tablero vacío de 5x5 con el símbolo '~' representando el agua. Retorna: tablero (list): Lista de listas que representa un tablero de 5x5 con agua en todas las posiciones. """ return [['~' for _ in range(5)] for _ in range(5)] # Mostrar el tablero def mostrar_tablero(tablero): """ Muestra el tablero en la consola de manera legible, incluyendo los números de columna y fila. Parámetros: tablero (list): La matriz del tablero que será mostrada en la consola. """ print(" 0 1 2 3 4") # Números de columna for i, fila in enumerate(tablero): print(i, " ".join(fila)) # Muestra el número de fila y el contenido de cada fila # Colocar un barco en el tablero (horizontal o vertical) def colocar_barco(tablero, barco, jugador): """ Permite a un jugador colocar un barco en el tablero. El barco puede ser colocado en orientación horizontal o vertical. Verifica que el barco quepa en el tablero y que no colisione con otros barcos. Parámetros: tablero (list): El tablero donde se colocará el barco. barco (dict): Diccionario con información del barco, como nombre y tamaño. jugador (int): El número del jugador que está colocando el barco. """ while True: print(f"Jugador {jugador}: Coloca tu barco {barco['nombre']} de tamaño {barco['tamano']}") fila = int(input("Ingresa la fila inicial (0-4): ")) columna = int(input("Ingresa la columna inicial (0-4): ")) orientacion = input("Orientación (h: horizontal, v: vertical): ").lower() # Colocar el barco de forma horizontal if orientacion == 'h': # Verifica que el barco quepa en el tablero y no colisione con otros barcos if columna + barco['tamano'] <= 5 and all(tablero[fila][columna + i] == '~' for i in range(barco['tamano'])): for i in range(barco['tamano']): tablero[fila][columna + i] = 'B' # Coloca el barco en el tablero break else: print("No se puede colocar el barco aquí, intenta nuevamente.") # Colocar el barco de forma vertical elif orientacion == 'v': # Verifica que el barco quepa en el tablero y no colisione con otros barcos if fila + barco['tamano'] <= 5 and all(tablero[fila + i][columna] == '~' for i in range(barco['tamano'])): for i in range(barco['tamano']): tablero[fila + i][columna] = 'B' # Coloca el barco en el tablero break else: print("No se puede colocar el barco aquí, intenta nuevamente.") else: print("Orientación no válida, intenta nuevamente.") # Atacar una posición del tablero enemigo def atacar(tablero_enemigo, fila, columna): """ Permite que un jugador ataque una posición en el tablero enemigo. Verifica si el ataque fue un impacto o un fallo. Parámetros: tablero_enemigo (list): El tablero del oponente que está siendo atacado. fila (int): La fila de la posición que está siendo atacada. columna (int): La columna de la posición que está siendo atacada. Retorna: bool: Verdadero si fue un impacto, Falso si fue un fallo. """ if tablero_enemigo[fila][columna] == 'B': tablero_enemigo[fila][columna] = 'X' # Impacto en un barco print("¡Impacto!") return True elif tablero_enemigo[fila][columna] == '~': tablero_enemigo[fila][columna] = 'O' # Agua, no había barco print("¡Fallaste!") return False else: print("Ya has atacado esta posición.") # Si la posición ya fue atacada return False # Verificar si todos los barcos han sido hundidos def barcos_hundidos(tablero): """ Verifica si todos los barcos en el tablero han sido hundidos. Parámetros: tablero (list): El tablero en el que se verificarán los barcos. Retorna: bool: Verdadero si todos los barcos han sido hundidos, Falso de lo contrario. """ for fila in tablero: if 'B' in fila: # Si todavía hay barcos en el tablero return False return True # Si no hay barcos, han sido hundidos todos # Juego principal def batalla_naval(): """ Función principal que organiza el flujo del juego Batalla Naval. 1. Crea los tableros para los jugadores. 2. Permite que cada jugador coloque sus barcos. 3. Alterna turnos para atacar el tablero del oponente. 4. Verifica si todos los barcos del oponente han sido hundidos para declarar al ganador. """ print("Bienvenidos a Batalla Naval") # Crear tableros para ambos jugadores tablero_jugador_1 = crear_tablero() # Tablero para Jugador 1 tablero_jugador_2 = crear_tablero() # Tablero para Jugador 2 # Definir los barcos (nombre y tamaño) barcos = [{'nombre': 'Destructor', 'tamano': 2}, {'nombre': 'Submarino', 'tamano': 3}] # Colocar barcos para el Jugador 1 print("Jugador 1, coloca tus barcos:") for barco in barcos: mostrar_tablero(tablero_jugador_1) colocar_barco(tablero_jugador_1, barco, 1) # Colocar barcos para el Jugador 2 print("Jugador 2, coloca tus barcos:") for barco in barcos: mostrar_tablero(tablero_jugador_2) colocar_barco(tablero_jugador_2, barco, 2) # Inicia el bucle de turnos turno_jugador_1 = True # El Jugador 1 empieza while True: if turno_jugador_1: # Turno del Jugador 1 print("\nTurno del Jugador 1:") mostrar_tablero(tablero_jugador_2) # Mostrar el tablero del Jugador 2 para atacar fila = int(input("Jugador 1, ingresa la fila para atacar (0-4): ")) columna = int(input("Jugador 1, ingresa la columna para atacar (0-4): ")) atacar(tablero_jugador_2, fila, columna) # Verificar si todos los barcos del Jugador 2 han sido hundidos if barcos_hundidos(tablero_jugador_2): print("¡Jugador 1 ha ganado! Todos los barcos del Jugador 2 han sido hundidos.") break else: # Turno del Jugador 2 print("\nTurno del Jugador 2:") mostrar_tablero(tablero_jugador_1) # Mostrar el tablero del Jugador 1 para atacar fila = int(input("Jugador 2, ingresa la fila para atacar (0-4): ")) columna = int(input("Jugador 2, ingresa la columna para atacar (0-4): ")) atacar(tablero_jugador_1, fila, columna) # Verificar si todos los barcos del Jugador 1 han sido hundidos if barcos_hundidos(tablero_jugador_1): print("¡Jugador 2 ha ganado! Todos los barcos del Jugador 1 han sido hundidos.") break turno_jugador_1 = not turno_jugador_1 # Alternar el turno entre jugadores # Ejecutar el juego batalla_naval() ```**Descripción General** * Este es un juego de **Batalla Naval** para dos jugadores. Ambos jugadores colocan barcos en sus respectivos tableros y se turnan para atacar el tablero del oponente, intentando hundir todos los barcos. ### **Funciones Clave** * `crear_tablero()`: Crea un tablero vacío para cada jugador. * `mostrar_tablero(tablero)`: Muestra el tablero de un jugador en la consola. * `colocar_barco(tablero, barco, jugador)`: Permite a los jugadores colocar barcos en sus tableros. * `atacar(tablero_enemigo, fila, columna)`: Permite a un jugador atacar una posición en el tablero enemigo. * `barcos_hundidos(tablero)`: Verifica si todos los barcos en un tablero han sido hundidos. * `batalla_naval()`: Función principal que controla el flujo del juego, alternando entre los jugadores y determinando el ganador. * Este código ofrece una base sólida para el juego de Batalla Naval, fácil de expandir o modificar para incluir nuevas funcionalidades, como más barcos * \============================= * \# \*\***Manual de Usuario: Juego de Batalla Naval en Python\*\*** * * \## \*\*1. Introducción\*\* * El juego de Batalla Naval es un clásico de estrategia en el que dos jugadores compiten por hundir los barcos del oponente. Este manual de usuario está diseñado para guiarte en el uso y disfrute del juego desarrollado en Python, proporcionando una descripción detallada de las funciones, reglas y procedimientos para jugar de manera efectiva. * * \## \*\*2. Requisitos del sistema\*\* * Para jugar este juego, necesitas lo siguiente: * \- \*\*Sistema operativo\*\*: Windows, macOS o Linux. * \- \*\*Python\*\*: Versión 3.6 o superior. * \- \*\*Editor de código\*\*: Cualquier editor de texto o entorno de desarrollo integrado (IDE) como Visual Studio Code, PyCharm, o el propio editor de Python. * * \## \*\*3. Descripción del juego\*\* * \### \*\*Objetivo del juego\*\* * El objetivo del juego es ser el primero en hundir todos los barcos del oponente. Cada jugador tiene un tablero de 5x5 donde coloca sus barcos. Durante el turno de cada jugador, se intenta adivinar las posiciones de los barcos del oponente, con el fin de hundirlos. * * \### \*\*Reglas principales\*\* * 1\. \*\*Turnos alternos\*\*: Los jugadores se turnan para atacar las posiciones del tablero del oponente. * 2\. \*\*Colocación de barcos\*\*: Cada jugador tiene dos barcos que debe colocar en su propio tablero. Los barcos pueden ser colocados de forma horizontal o vertical. * 3\. \*\*Ganador\*\*: Gana el jugador que logre hundir todos los barcos del oponente primero. * * \## \*\*4. Instrucciones para jugar\*\* * \### \*\*Paso 1: Ejecutar el juego\*\* * 1\. Descarga el código fuente del juego o cópialo en tu entorno de programación preferido. * 2\. Asegúrate de tener Python instalado. * 3\. Ejecuta el archivo Python que contiene el código del juego. Desde la terminal o consola, ejecuta el siguiente comando: * ```bash * python nombre\_del\_archivo.py * ``` * * \### \*\*Paso 2: Colocación de barcos\*\* * Después de iniciar el juego, cada jugador colocará sus barcos en su propio tablero. * * 1\. \*\*Selección de posición\*\*: Se te pedirá que ingreses la \*\*fila\*\* y la \*\*columna\*\* donde deseas que empiece tu barco. * * 2\. \*\*Orientación\*\*: Debes elegir si el barco estará colocado de manera horizontal (`h`) o vertical (`v`). * * 3\. \*\*Barcos disponibles\*\*: * \- \*\*Destructor\*\*: Ocupa 2 espacios. * \- \*\*Submarino\*\*: Ocupa 3 espacios. * * \*\*Ejemplo de entrada para colocar un barco\*\*: * \- Fila inicial: 1 * \- Columna inicial: 2 * \- Orientación: Horizontal (`h`) * * Si el barco puede colocarse sin chocar con otros barcos o los bordes del tablero, se colocará. Si no, se te pedirá que ingreses una posición válida nuevamente. * * \### \*\*Paso 3: Atacar\*\* * Una vez que ambos jugadores han colocado sus barcos, el juego comienza. * * 1\. Durante tu turno, selecciona una posición del tablero del oponente para atacar. * 2\. Ingresarás la fila y la columna que deseas atacar. * * \*\*Resultado del ataque\*\*: * \- \*\*Impacto\*\*: Si aciertas a un barco, el tablero del oponente mostrará una `X` en esa posición. * \- \*\*Fallo\*\*: Si no hay un barco en esa posición, aparecerá un `O` indicando que el disparo fue fallido. * * \### \*\*Paso 4: Turnos alternos\*\* * El juego se desarrolla por turnos. Cuando un jugador ha hecho su ataque, el siguiente jugador tiene la oportunidad de atacar una posición en el tablero del oponente. * * \### \*\*Paso 5: Final del juego\*\* * El juego terminará cuando uno de los jugadores haya hundido todos los barcos del oponente. El tablero no mostrará más símbolos de `B` (barco) y se declarará al ganador. * * \## \*\*5. Funcionalidades del juego\*\* * \### \*\*Tablero\*\* * \- Los tableros de ambos jugadores son de 5x5 y están representados por símbolos. * \- `~`: Agua, sin atacar. * \- `B`: Barco (solo visible para el jugador propietario del tablero). * \- `X`: Impacto exitoso. * \- `O`: Ataque fallido. * * \### \*\*Colocación de barcos\*\* * \- Los barcos se colocan en una fila y columna inicial que define el comienzo del barco, y se extienden horizontal o verticalmente en función de la orientación elegida por el jugador. * * \### \*\*Ataques\*\* * \- Los jugadores atacan posiciones ingresando una fila y una columna. Si la posición tiene un barco, se marca un impacto, y si no, un fallo. * * \## \*\*6. Estrategia\*\* * 1\. \*\*Colocación estratégica\*\*: Coloca tus barcos en posiciones no obvias y distribúyelos bien para evitar que el oponente los encuentre rápidamente. * 2\. \*\*Atacar con patrón\*\*: En lugar de atacar aleatoriamente, utiliza patrones de ataque, como disparar en una cuadrícula alternada, para aumentar las probabilidades de impacto. * 3\. \*\*Observación del oponente\*\*: Toma notas mentales de los lugares que ya has atacado y usa esa información para deducir dónde pueden estar los barcos restantes. * * \## \*\*7. Resolución de problemas\*\* * \### Error: "No se puede colocar el barco aquí" * \- \*\*Solución\*\*: Asegúrate de que el barco no se salga del tablero y que no colisione con otro barco ya colocado. * * \### Error: "Posición ya atacada" * \- \*\*Solución\*\*: Si intentas atacar una posición que ya has atacado, se te informará. Elige una posición diferente. * * \### Tablero no muestra correctamente los ataques * \- \*\*Solución\*\*: Verifica que has ingresado correctamente las coordenadas (fila y columna) dentro del rango permitido (0-4). * * \## \*\*8. Créditos\*\* * Este juego fue desarrollado como una implementación básica del popular juego de Batalla Naval en Python. Puedes modificar y expandir este código según tus necesidades. * * ¡Disfruta jugando y que la suerte esté de tu lado en la batalla! * * \--- * * Este manual cubre todo lo necesario para comenzar a jugar Batalla Naval en Python.

Excelente curso, muchas gracias, Carla

Carla que buen curso el que hiciste, estoy emocionado de seguir aprendiendo :D

Excelente curso, reforzando y aprendiendo nuevas cosas.

Me ha gustado mucho el curso, no tenia idea de muchas cosas. Mil gracias

Comenta que en los recursos estan las especificaciones del proyecto, pero no las veo, me parece que hace falta definir mejor los requerimentos para poder realizar el proyecto como, de que tamaño debe ser la matriz, el tamaño y forma de cada barco dentro de la matriz y una explicacion un poco mas detallada de las instrucciones del juego. Veo que esta el codigo, pero realmente me gustaria intentarlo por mi cuenta antes de ver como se hizo.

Un excelente curso estimada Carli, me encantó quede picado de sus clases.

Muy buen curso, me aclaró dudas sobre POO y recomiendo que si no entienden algunas cosas, apóyense en la IA y documentación

Carla, muchas gracias por tus enseñanzas, definitivamente me ayudaste a dar un primer paso de este largo camino, admirable tu forma de programar. Espero verte en otras partes de este camino!

Y donde estan los recursos ?

¿ SEria posible un curso que implemente patrones de diseño? almenos los mas basicos

`import random` `# Clase Tablero para representar el tablero de juego` `class Tablero:` ` def __init__(self, n):` ` self.n = n` ` self.casillas = []` ` self.termino = 0` ` for i in range(n):` ` self.casillas.append([0] * n) # Inicializar el tablero con ceros (agua)` ` # Método para imprimir el tablero` ` def imprimir_tablero(self):` ` for fila in self.casillas:` ` print(fila)` ` # Método para marcar el tablero` ` def marcar_tablero(self, ren, col, ficha):` ` self.casillas[ren][col] = ficha` ` # Método para verificar si alguien ha ganado` ` def alguien_gano(self):` ` for fila in self.casillas:` ` for celda in fila:` ` if celda in ['P', 'M', 'G']:` ` return False` ` return True` `# Clase Barcos para manejar los barcos y su colocación` `class Barcos:` ` def __init__(self):` ` self.pequenio = 2` ` self.mediano = 3` ` self.grande = 4` ` # Método para verificar si un barco puede ser colocado en una posición` ` def puedo_ir_aqui(self, tablero, ren, col):` ` return 0 <= ren < tablero.n and 0 <= col < tablero.n and tablero.casillas[ren][col] == 0` ` # Métodos para colocar los barcos` ` def poner_barco(self, tablero, ren, col, modo, tamano, ficha):` ` if modo == 0: # Horizontal` ` for i in range(tamano):` ` if not self.puedo_ir_aqui(tablero, ren, col + i):` ` return False` ` for i in range(tamano):` ` tablero.marcar_tablero(ren, col + i, ficha)` ` elif modo == 1: # Vertical` ` for i in range(tamano):` ` if not self.puedo_ir_aqui(tablero, ren + i, col):` ` return False` ` for i in range(tamano):` ` tablero.marcar_tablero(ren + i, col, ficha)` ` else:` ` return False` ` return True` `# Clase Usuario para representar a cada jugador` `class Usuario:` ` def __init__(self, nombre, n):` ` self.nombre = nombre` ` self.tablero = Tablero(n)` ` self.barcos = Barcos()` ` # Método para llenar el tablero con los barcos del jugador` ` def llenar_tablero(self):` ` print(f"Comenzaremos a llenar tu tablero, {self.nombre}")` ` barcos_info = [("BARCO PEQUEÑO (1X2)", 2, 'P'), ("BARCO MEDIANO (1X3)", 3, 'M'), ("BARCO GRANDE (1X4)", 4, 'G')]` ` for barco in barcos_info:` ` print(barco[0])` ` while True:` ` modo = int(input("Escoje tu barco en horizontal(0) o en vertical(1): "))` ` renglon = int(input("Dame el renglon donde lo quieres poner: "))` ` columna = int(input("Dame la columna donde lo quieres poner: "))` ` if self.barcos.poner_barco(self.tablero, renglon, columna, modo, barco[1], barco[2]):` ` print("OK")` ` self.tablero.imprimir_tablero()` ` break` ` else:` ` print("No se puede colocar aquí, intenta de nuevo.")` ` # Método para disparar a una celda del tablero enemigo` ` def dispara(self, tablero, ren, col):` ` if tablero.casillas[ren][col] != 0:` ` tablero.casillas[ren][col] = 'X'` ` return True` ` else:` ` return False` `# Clase Simulador para manejar las simulaciones del juego` `class Simulador:` ` def __init__(self, n):` ` self.n = n` ` self.jugador1 = Usuario("Simulador1", n)` ` self.jugador2 = Usuario("Simulador2", n)` ` # Método para llenar los tableros con barcos de manera aleatoria` ` def llenar_tableros(self):` ` for jugador in [self.jugador1, self.jugador2]:` ` barcos_info = [(2, 'P'), (3, 'M'), (4, 'G')]` ` for barco in barcos_info:` ` while True:` ` modo = random.choice([0, 1])` ` ren = random.randint(0, self.n - 1)` ` col = random.randint(0, self.n - 1)` ` if jugador.barcos.poner_barco(jugador.tablero, ren, col, modo, barco[0], barco[1]):` ` break` ` # Método para simular el juego hasta que alguien gane` ` def jugar_simulacion(self):` ` self.llenar_tableros()` ` i = 0` ` while True:` ` i += 1` ` if i % 2 != 0:` ` ren = random.randint(0, self.n - 1)` ` col = random.randint(0, self.n - 1)` ` if self.jugador1.dispara(self.jugador2.tablero, ren, col):` ` if self.jugador2.tablero.alguien_gano():` ` print(f"¡{self.jugador1.nombre} ha ganado!")` ` break` ` else:` ` continue` ` else:` ` ren = random.randint(0, self.n - 1)` ` col = random.randint(0, self.n - 1)` ` if self.jugador2.dispara(self.jugador1.tablero, ren, col):` ` if self.jugador1.tablero.alguien_gano():` ` print(f"¡{self.jugador2.nombre} ha ganado!")` ` break` ` else:` ` continue` ` if self.jugador1.tablero.alguien_gano() or self.jugador2.tablero.alguien_gano():` ` break` `# Función para mostrar el menú principal` `def menu():` ` print("Bienvenido a Batalla Naval")` ` print("1. Jugar")` ` print("2. Simulador")` ` opcion = int(input("Selecciona una opción: "))` ` if opcion == 1:` ` n = int(input("Jugadores, ingresen el tamaño de tu tablero: "))` ` nombre1 = input("Jugador 1, ingresa tu nombre: ")` ` jugador1 = Usuario(nombre1, n)` ` jugador1.llenar_tablero()` ` nombre2 = input("Jugador 2, ingresa tu nombre: ")` ` jugador2 = Usuario(nombre2, n)` ` jugador2.llenar_tablero()` ` i = 0` ` while True:` ` i += 1` ` if i % 2 != 0:` ` print(f"{jugador1.nombre}:")` ` while True:` ` ren = int(input("Ingresa el renglon que quieres disparar: "))` ` col = int(input("Ingresa la columna que quieres disparar: "))` ` if jugador1.dispara(jugador2.tablero, ren, col):` ` if jugador2.tablero.alguien_gano():` ` print(f"¡{jugador1.nombre} ha ganado!")` ` return` ` continue` ` else:` ` break` ` else:` ` print(f"{jugador2.nombre}:")` ` while True:` ` ren = int(input("Ingresa el renglon que quieres disparar: "))` ` col = int(input("Ingresa la columna que quieres disparar: "))` ` if jugador2.dispara(jugador1.tablero, ren, col):` ` if jugador1.tablero.alguien_gano():` ` print(f"¡{jugador2.nombre} ha ganado!")` ` return` ` continue` ` else:` ` break` ` if jugador1.tablero.alguien_gano() or jugador2.tablero.alguien_gano():` ` break` ` elif opcion == 2:` ` n = int(input("Ingresa el tamaño del tablero para la simulación: "))` ` simulador = Simulador(n)` ` simulador.jugar_simulacion()` ` print("Fin de la simulación")` `# Código principal` `if __name__ == "__main__":` ` menu()`

hubiera sido interesante ver el ejemplo aplicando la teoría de la anterior clase.

Buen día, en donde puedo yo publicar el proyecto final? Lo pongo aquí o como proyecto del curso?

Muy buen curso, agadeciéndole a la profesora por su metodologiía y sus explicaciones. Muchas gracias.