Skip to content
The Chat Archive
o1-mini-2024-09-12· OpenAI WildChat-4.8M (AI2)

Juego de dados de futbol con dados de 1-6 16 equipos de 1era división 16 equipos de…

  1. User

    Juego de dados de futbol con dados de 1-6

    16 equipos de 1era división 16 equipos de serie ascenso

    Copa

    32 copa juegan por playoff en partidos únicos de eliminación hasta la final. Los empates se definen con dados.

    En ambas ligas todos juegan contra todos gana: 3 puntos, empate;1 punto, derrota -1 punto. Campeón 1era división suma más puntos. Registra 1 copa suma copas Los puestos 15 y 16 relegados a serie de ascenso y sin reemplazos por 1ero y 2do se serie de ascenso.

    Serie ascenso Campeon de ascenso sube a 1era división Subcampeón asciende a 1era división

    Crea nombre de equipos 16 equipos de 1era Crea nombre de 16 equipos de ascenso

    Genera fixture Crea dashboard tabla e calificaiones Guarda registro de estadísticas por usuario como backup Usa colores para cada equipo.

    MAneja errores

    Pop de avisos de resultados, crampones, promociones, relgaciones, Manten estadística de campeones por división

    Comienza campeonatos por año 1900

    Cream vents random de desaparición de equipos o fusión, pero siempre manteniendo los 32 en todoal.

    Cada año se realizan campeonatos

    Crea un secuencia de acción donde le usuario comience el juego. Mostrando el fixture primera fecha en ambas divisiones. Al final de la 1era ruda, se ejecuta la copa, cuando termina la copa, comienza segunda rueda de coampeonato.

L mecánica es que app interactúas con el usuario tira los dados de 6 caras, 1 a 6 en cada uno de los partidos. La app registra el valor y actualiza dashboard , Avannzdo hasta el final del campeonato y copas. App generar todo el fixture por año y un fixture por copa. El usuario hace la acción de tirar el dado, numero que se agrega a l resultado . Por ejemplo, año 1900, esta la primera fecha del campeonato. Y genera pops para los avisos AL app guarda datos en csv para su análisis después de cada año, en un archivo que se diferencia por nombre

    La app prepara el fixture, no debe simular nada. La app mantiene los datos actualizados fecha a fecha.

  2. Assistant

    ¡Claro! A continuación, proporcionaré una guía detallada para crear tu juego de dados de fútbol, incluyendo generación de nombres de equipos, asignación de colores, creación de fixtures, manejo de puntuaciones, estadísticas, eventos aleatorios y persistencia de datos en archivos CSV. Utilizaremos Python para desarrollar una aplicación de línea de comandos que cumpla con tus requisitos.

    1. Requisitos Previos

    Antes de comenzar, asegúrate de tener instalado Python en tu sistema. También utilizaremos algunas bibliotecas adicionales:

    • pandas: Para manejar las tablas y datos.
    • random: Para generar eventos aleatorios y simular tiradas de dados.
    • csv: Para manejar la lectura y escritura de archivos CSV.
    • colorama: Para manejar colores en la consola (opcional, para mejorar la visualización).

    Puedes instalar las bibliotecas necesarias utilizando pip:

    pip install pandas colorama
    

    2. Estructura del Proyecto

    Organizaremos el proyecto de la siguiente manera:

    futbol_dados/
    │
    ├── equipos.py
    ├── fixtures.py
    ├── campeonato.py
    ├── eventos.py
    ├── utils.py
    ├── main.py
    └── datos/
        ├── primera_division.csv
        ├── serie_ascenso.csv
        └── estadisticas.csv
    

    3. Creación de los Equipos

    Primero, generaremos nombres para los equipos de ambas divisiones y les asignaremos colores.

    # equipos.py
    import random
    from colorama import Fore
    
    # Listas de posibles nombres y colores
    nombres_ciudades = [
        "Valencia", "Madrid", "Barcelona", "Sevilla", "Bilbao", "Zaragoza",
        "Málaga", "Murcia", "Valladolid", "Alicante", "Córdoba", "Granada",
        "Vigo", "Gijón", "Huelva", "Vitoria"
    ]
    
    nombres_escudos = [
        "Toros", "Leones", "Águilas", "Rivales", "Galácticos", "Atléticos",
        "Fénix", "Titanes", "Dragones", "Piratas", "Serpientes", "Halcones",
        "Pumas", "Osos", "Coyotes", "Centauros"
    ]
    
    colores = [
        Fore.RED, Fore.BLUE, Fore.GREEN, Fore.YELLOW, Fore.CYAN,
        Fore.MAGENTA, Fore.WHITE, Fore.LIGHTGREEN_EX, Fore.LIGHTBLUE_EX,
        Fore.LIGHTMAGENTA_EX, Fore.LIGHTYELLOW_EX, Fore.LIGHTCYAN_EX,
        Fore.LIGHTWHITE_EX, Fore.LIGHTRED_EX, Fore.LIGHTBLACK_EX, Fore.LIGHTGREEN_EX
    ]
    
    def generar_equipos():
        equipos_1era = []
        equipos_ascenso = []
        used_names = set()
    
        for i in range(16):
            ciudad = random.choice(nombres_ciudades)
            escudo = random.choice(nombres_escudos)
            nombre = f"{ciudad} {escudo}"
            while nombre in used_names:
                ciudad = random.choice(nombres_ciudades)
                escudo = random.choice(nombres_escudos)
                nombre = f"{ciudad} {escudo}"
            used_names.add(nombre)
            color = colores[i % len(colores)]
            equipo = {
                "nombre": nombre,
                "color": color
            }
            equipos_1era.append(equipo)
    
        for i in range(16):
            ciudad = random.choice(nombres_ciudades)
            escudo = random.choice(nombres_escudos)
            nombre = f"{ciudad} {escudo} B"
            while nombre in used_names:
                ciudad = random.choice(nombres_ciudades)
                escudo = random.choice(nombres_escudos)
                nombre = f"{ciudad} {escudo} B"
            used_names.add(nombre)
            color = colores[i % len(colores)]
            equipo = {
                "nombre": nombre,
                "color": color
            }
            equipos_ascenso.append(equipo)
    
        return equipos_1era, equipos_ascenso
    
    if __name__ == "__main__":
        equipos_1era, equipos_ascenso = generar_equipos()
        print("Equipos de Primera División:")
        for equipo in equipos_1era:
            print(f"{equipo['color']}{equipo['nombre']}{Fore.RESET}")
        
        print("\nEquipos de Serie Ascenso:")
        for equipo in equipos_ascenso:
            print(f"{equipo['color']}{equipo['nombre']}{Fore.RESET}")
    

    Descripción:

    • Generación de Nombres: Combina nombres de ciudades con nombres de escudos para crear nombres únicos.
    • Asignación de Colores: Asigna un color diferente a cada equipo para una mejor identificación visual.
    • Prevención de Duplicados: Asegura que cada equipo tenga un nombre único.

    4. Creación del Fixture

    Generaremos un fixture donde todos los equipos juegan contra todos en un formato de liga.

    # fixtures.py
    import itertools
    import random
    
    def generar_fixture(equipos):
        # Genera todas las combinaciones de partidos
        partidos = list(itertools.combinations(equipos, 2))
        random.shuffle(partidos)  # Mezcla para aleatorizar el orden de los partidos
        return partidos
    
    if __name__ == "__main__":
        from equipos import generar_equipos
        equipos_1era, equipos_ascenso = generar_equipos()
        fixture_1era = generar_fixture(equipos_1era)
        fixture_ascenso = generar_fixture(equipos_ascenso)
        
        print("Fixture Primera División:")
        for partido in fixture_1era:
            print(f"{partido[0]['nombre']} vs {partido[1]['nombre']}")
        
        print("\nFixture Serie Ascenso:")
        for partido in fixture_ascenso:
            print(f"{partido[0]['nombre']} vs {partido[1]['nombre']}")
    

    Descripción:

    • Utiliza la función itertools.combinations para generar todos los partidos posibles donde cada equipo juega contra todos los demás.
    • Mezcla aleatoriamente el orden de los partidos para simular fechas.

    5. Simulación de Partidos y Actualización de Puntuaciones

    Simularemos cada partido tirando dados para ambos equipos y actualizando las puntuaciones según el resultado.

    # campeonato.py
    import random
    import pandas as pd
    from fixtures import generar_fixture
    from equipos import generar_equipos
    from colorama import Fore
    
    class Campeonato:
        def __init__(self, año, equipos_1era, equipos_ascenso):
            self.año = año
            self.equipos_1era = equipos_1era.copy()
            self.equipos_ascenso = equipos_ascenso.copy()
            self.fixture_1era = generar_fixture(self.equipos_1era)
            self.fixture_ascenso = generar_fixture(self.equipos_ascenso)
            self.resultados_1era = []
            self.resultados_ascenso = []
            self.tabla_1era = self.inicializar_tabla(self.equipos_1era)
            self.tabla_ascenso = self.inicializar_tabla(self.equipos_ascenso)
        
        def inicializar_tabla(self, equipos):
            data = {
                "Equipo": [equipo['nombre'] for equipo in equipos],
                "Puntos": [0 for _ in equipos],
                "Victorias": [0 for _ in equipos],
                "Empates": [0 for _ in equipos],
                "Derrotas": [0 for _ in equipos]
            }
            df = pd.DataFrame(data)
            return df
    
        def tirar_dado(self):
            return random.randint(1,6)
        
        def simular_partido(self, equipo_local, equipo_visitante, tabla):
            resultado_local = self.tirar_dado()
            resultado_visitante = self.tirar_dado()
            resultado = ""
    
            if resultado_local > resultado_visitante:
                puntos_local = 3
                puntos_visitante = -1
                resultado = f"Victoria de {equipo_local['nombre']}"
                tabla.loc[tabla['Equipo'] == equipo_local['nombre'], 'Puntos'] += puntos_local
                tabla.loc[tabla['Equipo'] == equipo_visitante['nombre'], 'Puntos'] += puntos_visitante
                tabla.loc[tabla['Equipo'] == equipo_local['nombre'], 'Victorias'] += 1
                tabla.loc[tabla['Equipo'] == equipo_visitante['nombre'], 'Derrotas'] += 1
            elif resultado_local < resultado_visitante:
                puntos_local = -1
                puntos_visitante = 3
                resultado = f"Victoria de {equipo_visitante['nombre']}"
                tabla.loc[tabla['Equipo'] == equipo_local['nombre'], 'Puntos'] += puntos_local
                tabla.loc[tabla['Equipo'] == equipo_visitante['nombre'], 'Puntos'] += puntos_visitante
                tabla.loc[tabla['Equipo'] == equipo_visitante['nombre'], 'Victorias'] += 1
                tabla.loc[tabla['Equipo'] == equipo_local['nombre'], 'Derrotas'] += 1
            else:
                puntos_local = 1
                puntos_visitante = 1
                resultado = f"Empate entre {equipo_local['nombre']} y {equipo_visitante['nombre']}"
                tabla.loc[tabla['Equipo'] == equipo_local['nombre'], 'Puntos'] += puntos_local
                tabla.loc[tabla['Equipo'] == equipo_visitante['nombre'], 'Puntos'] += puntos_visitante
                tabla.loc[tabla['Equipo'] == equipo_local['nombre'], 'Empates'] += 1
                tabla.loc[tabla['Equipo'] == equipo_visitante['nombre'], 'Empates'] += 1
    
            return resultado
    
        def jugar_todos_los_partidos(self):
            print(f"\n=== Campeonato {self.año} - Primera División ===\n")
            for partido in self.fixture_1era:
                resultado = self.simular_partido(partido[0], partido[1], self.tabla_1era)
                print(resultado)
                self.resultados_1era.append(resultado)
            
            print(f"\n=== Campeonato {self.año} - Serie Ascenso ===\n")
            for partido in self.fixture_ascenso:
                resultado = self.simular_partido(partido[0], partido[1], self.tabla_ascenso)
                print(resultado)
                self.resultados_ascenso.append(resultado)
        
        def mostrar_tablas(self):
            print("\nTabla de Primera División:")
            print(self.tabla_1era.sort_values(by="Puntos", ascending=False).to_string(index=False))
            
            print("\nTabla de Serie Ascenso:")
            print(self.tabla_ascenso.sort_values(by="Puntos", ascending=False).to_string(index=False))
        
        def guardar_resultados(self):
            # Guardar resultados en CSV
            self.tabla_1era.to_csv(f"datos/primera_division_{self.año}.csv", index=False)
            self.tabla_ascenso.to_csv(f"datos/serie_ascenso_{self.año}.csv", index=False)
        
        def manejar_fianlizacion(self):
            # Aquí puedes implementar la lógica para manejar promociones, relegaciones y copas
            pass
    
    if __name__ == "__main__":
        equipos_1era, equipos_ascenso = generar_equipos()
        campeonato = Campeonato(1900, equipos_1era, equipos_ascenso)
        campeonato.jugar_todos_los_partidos()
        campeonato.mostrar_tablas()
        campeonato.guardar_resultados()
    

    Descripción:

    • Inicialización de Tablas: Crea DataFrames para almacenar las puntuaciones y estadísticas de cada equipo.
    • Simulación de Partidos: Por cada partido, se tiran dos dados y se determina el resultado según las reglas proporcionadas:
      • Victoria: +3 puntos para el ganador, -1 para el perdedor.
      • Empate: +1 punto para ambos.
    • Actualización de Estadísticas: Actualiza victorias, empates y derrotas en la tabla.
    • Guardado de Resultados: Al final del campeonato, guarda las tablas en archivos CSV para futuras referencias.

    6. Manejo de Promociones y Relegaciones

    Implementaremos la lógica para promover equipos desde la Serie Ascenso y relegar equipos de la Primera División.

    # campeonato.py (continúa)
    
        def manejar_promociones_relegaciones(self):
            # Ordenar tablas
            tabla_1era_sorted = self.tabla_1era.sort_values(by="Puntos", ascending=False).reset_index(drop=True)
            tabla_ascenso_sorted = self.tabla_ascenso.sort_values(by="Puntos", ascending=False).reset_index(drop=True)
            
            # Encontrar los dos últimos de Primera División
            relegados = tabla_1era_sorted.tail(2)['Equipo'].tolist()
            print(f"\nEquipos Relegados de Primera División: {relegados}")
            
            # Encuentra los dos primeros de Serie Ascenso
            promovidos = tabla_ascenso_sorted.head(2)['Equipo'].tolist()
            print(f"Equipos Promovidos a Primera División: {promovidos}")
            
            # Actualizar listas de equipos
            for equipo in relegados:
                equipo_obj = next((item for item in self.equipos_1era if item["nombre"] == equipo), None)
                if equipo_obj:
                    self.equipos_ascenso.append(equipo_obj)
                    self.equipos_1era.remove(equipo_obj)
            
            for equipo in promovidos:
                equipo_obj = next((item for item in self.equipos_ascenso if item["nombre"] == equipo), None)
                if equipo_obj:
                    self.equipos_1era.append(equipo_obj)
                    self.equipos_ascenso.remove(equipo_obj)
            
            # Regenerar fixtures después de promociones y relegaciones
            self.fixture_1era = generar_fixture(self.equipos_1era)
            self.fixture_ascenso = generar_fixture(self.equipos_ascenso)
    
        def jugar_campeonato(self):
            self.jugar_todos_los_partidos()
            self.mostrar_tablas()
            self.manejar_promociones_relegaciones()
            self.guardar_resultados()
    
    # main.py
    from equipos import generar_equipos
    from campeonato import Campeonato
    
    def main():
        año = 1900
        equipos_1era, equipos_ascenso = generar_equipos()
        
        while año <= 2024:  # Puedes ajustar el año final según lo desees
            print(f"\n========== Año {año} ==========")
            campeonato = Campeonato(año, equipos_1era, equipos_ascenso)
            campeonato.jugar_campeonato()
            año += 1
    
    if __name__ == "__main__":
        main()
    

    Descripción:

    • Promociones y Relegaciones: Después de cada campeonato, los dos equipos con menos puntos en la Primera División son relegados a la Serie Ascenso, y los dos mejores equipos de la Serie Ascenso son promovidos a la Primera División.
    • Actualización de Fixtures: Después de cambios en las divisiones, se regeneran los fixtures para el próximo año.
    • Ejecución del Campeonato por Año: Se ejecuta el campeonato año tras año desde 1900 hasta 2024 (puedes ajustar el rango según tus necesidades).

    7. Implementación de Copas (Playoffs)

    Implementaremos el sistema de copas donde 32 equipos juegan en partidos únicos de eliminación hasta la final.

    # campeonato.py (continúa)
    import math
    
        def generar_copa(self):
            equipos = self.equipos_1era + self.equipos_ascenso
            random.shuffle(equipos)
            rondas = int(math.log2(len(equipos)))
            ganadores = equipos.copy()
            resultado_copa = []
    
            for ronda in range(rondas):
                print(f"\n--- Ronda {ronda + 1} de la Copa ---")
                nuevos_ganadores = []
                for i in range(0, len(ganadores), 2):
                    equipo1 = ganadores[i]
                    equipo2 = ganadores[i+1]
                    resultado = self.simular_copa(equipo1, equipo2)
                    print(resultado)
                    resultado_copa.append(resultado)
                    ganador = equipo1 if "Victoria de" in resultado and equipo1["nombre"] in resultado else equipo2
                    nuevos_ganadores.append(ganador)
                ganadores = nuevos_ganadores
            print(f"\n¡Campeón de la Copa {self.año}: {ganadores[0]['nombre']}!")
            return resultado_copa
    
        def simular_copa(self, equipo1, equipo2):
            resultado1 = self.tirar_dado()
            resultado2 = self.tirar_dado()
            if resultado1 > resultado2:
                return f"Victoria de {equipo1['nombre']} sobre {equipo2['nombre']}"
            elif resultado1 < resultado2:
                return f"Victoria de {equipo2['nombre']} sobre {equipo1['nombre']}"
            else:
                # En caso de empate, tirar nuevamente hasta que haya un ganador
                while resultado1 == resultado2:
                    resultado1 = self.tirar_dado()
                    resultado2 = self.tirar_dado()
                if resultado1 > resultado2:
                    return f"Victoria de {equipo1['nombre']} sobre {equipo2['nombre']} (desempate)"
                else:
                    return f"Victoria de {equipo2['nombre']} sobre {equipo1['nombre']} (desempate)"
    
        def jugar_campeonato(self):
            self.jugar_todos_los_partidos()
            self.generar_copa()
            self.mostrar_tablas()
            self.manejar_promociones_relegaciones()
            self.guardar_resultados()
    

    Descripción:

    • Generación de la Copa: Combina todos los equipos de ambas divisiones, mezcla aleatoriamente los partidos y luego juega rondas de eliminación hasta determinar al campeón.
    • Simulación de Partidos de Copa: Similar a los partidos de liga, pero en un formato de eliminación directa. En caso de empate, se sigue tirando el dado hasta obtener un ganador.
    • Integración en el Campeonato: Después de la fase de liga, se ejecuta la copa antes de manejar las promociones y relegaciones.

    8. Manejo de Eventos Aleatorios (Desaparición o Fusión de Equipos)

    Implementaremos eventos aleatorios que pueden ocurrir cada año, como la desaparición o fusión de equipos, asegurando que siempre haya 32 equipos.

    # eventos.py
    import random
    from equipos import generar_equipos
    
    def evento_aleatorio(equipos_1era, equipos_ascenso):
        evento = random.choice(["ninguno", "desaparicion", "fusion"])
        if evento == "ninguno":
            print("\nNo hubo eventos aleatorios este año.")
            return equipos_1era, equipos_ascenso
        elif evento == "desaparicion":
            # Desaparecer un equipo de Primera División o Serie Ascenso
            division = random.choice(["1era", "ascenso"])
            if division == "1era" and equipos_1era:
                equipo = random.choice(equipos_1era)
                equipos_1era.remove(equipo)
                print(f"\nEvento: El equipo {equipo['nombre']} de Primera División ha desaparecido.")
            elif division == "ascenso" and equipos_ascenso:
                equipo = random.choice(equipos_ascenso)
                equipos_ascenso.remove(equipo)
                print(f"\nEvento: El equipo {equipo['nombre']} de Serie Ascenso ha desaparecido.")
            # Crear un nuevo equipo para mantener el número
            nuevo_equipo = crear_nuevo_equipo(equipos_1era + equipos_ascenso)
            asignar_division(nuevo_equipo, equipos_1era, equipos_ascenso)
        elif evento == "fusion":
            # Fusionar dos equipos de la misma división
            division = random.choice(["1era", "ascenso"])
            if division == "1era" and len(equipos_1era) >=2:
                equipo1, equipo2 = random.sample(equipos_1era, 2)
                nombre_fusion = f"{equipo1['nombre']}-{equipo2['nombre']}"
                color_fusion = random.choice(["RED", "BLUE", "GREEN", "YELLOW", "CYAN", "MAGENTA", "WHITE"])
                nuevo_equipo = {"nombre": nombre_fusion, "color": getattr(Fore, color_fusion)}
                equipos_1era.remove(equipo1)
                equipos_1era.remove(equipo2)
                equipos_1era.append(nuevo_equipo)
                print(f"\nEvento: Los equipos {equipo1['nombre']} y {equipo2['nombre']} se han fusionado para formar {nombre_fusion}.")
            elif division == "ascenso" and len(equipos_ascenso) >=2:
                equipo1, equipo2 = random.sample(equipos_ascenso, 2)
                nombre_fusion = f"{equipo1['nombre']}-{equipo2['nombre']}"
                color_fusion = random.choice(["RED", "BLUE", "GREEN", "YELLOW", "CYAN", "MAGENTA", "WHITE"])
                nuevo_equipo = {"nombre": nombre_fusion, "color": getattr(Fore, color_fusion)}
                equipos_ascenso.remove(equipo1)
                equipos_ascenso.remove(equipo2)
                equipos_ascenso.append(nuevo_equipo)
                print(f"\nEvento: Los equipos {equipo1['nombre']} y {equipo2['nombre']} se han fusionado para formar {nombre_fusion}.")
        return equipos_1era, equipos_ascenso
    
    def crear_nuevo_equipo(equipos_existentes):
        nombres_ciudades = [
            "Santander", "Salamanca", "Burgos", "Badajoz", "Cádiz", "Almería",
            "Castellón", "Logroño", "Lugo", "Oviedo", "Pamplona", "Las Palmas",
            "Bilbao", "Benevento", "Róterdam", "Nápoles"
        ]
    
        nombres_escudos = [
            "Lobos", "Jinetes", "Centellas", "Leones", "Nacionales", "Atléticos",
            "Gladiadores", "Cimarrones", "Fieras", "Águilas", "Rojos", "Blancos",
            "Verdes", "Amarillos", "Negros", "Azules"
        ]
    
        ciudad = random.choice(nombres_ciudades)
        escudo = random.choice(nombres_escudos)
        nombre = f"{ciudad} {escudo}"
        color = random.choice([
            Fore.RED, Fore.BLUE, Fore.GREEN, Fore.YELLOW, Fore.CYAN,
            Fore.MAGENTA, Fore.WHITE, Fore.LIGHTGREEN_EX, Fore.LIGHTBLUE_EX,
            Fore.LIGHTMAGENTA_EX, Fore.LIGHTYELLOW_EX, Fore.LIGHTCYAN_EX,
            Fore.LIGHTWHITE_EX, Fore.LIGHTRED_EX, Fore.LIGHTBLACK_EX
        ])
        nuevo_equipo = {"nombre": nombre, "color": color}
        print(f"Nueva incorporación: {nombre}")
        return nuevo_equipo
    
    def asignar_division(equipo, equipos_1era, equipos_ascenso):
        # Decidir aleatoriamente a qué división asignar el nuevo equipo
        division = random.choice(["1era", "ascenso"])
        if division == "1era":
            equipos_1era.append(equipo)
            print(f"El nuevo equipo {equipo['nombre']} se ha asignado a Primera División.")
        else:
            equipos_ascenso.append(equipo)
            print(f"El nuevo equipo {equipo['nombre']} se ha asignado a Serie Ascenso.")
    

    Descripción:

    • Eventos Aleatorios:
      • Desaparición: Un equipo aleatorio puede desaparecer de una división y ser reemplazado por un nuevo equipo.
      • Fusión: Dos equipos de la misma división pueden fusionarse para formar un nuevo equipo.
    • Mantenimiento de Equipos: Siempre se mantiene el número total de equipos en 32 añadiendo nuevos equipos si es necesario.

    Integración en el Campeonato:

    Actualizaremos campeonato.py para incorporar estos eventos.

    # campeonato.py (continúa)
    from eventos import evento_aleatorio
    
        def jugar_campeonato(self):
            # Manejar eventos aleatorios antes del campeonato
            self.equipos_1era, self.equipos_ascenso = evento_aleatorio(self.equipos_1era, self.equipos_ascenso)
            self.fixture_1era = generar_fixture(self.equipos_1era)
            self.fixture_ascenso = generar_fixture(self.equipos_ascenso)
            
            self.jugar_todos_los_partidos()
            self.generar_copa()
            self.mostrar_tablas()
            self.manejar_promociones_relegaciones()
            self.guardar_resultados()
    

    9. Persistencia de Datos y Estadísticas por Usuario

    Para mantener un registro de estadísticas y respaldos, utilizaremos archivos CSV.

    # campeonato.py (continúa)
    
        def guardar_resultados(self):
            # Guardar resultados en CSV
            self.tabla_1era.to_csv(f"datos/primera_division_{self.año}.csv", index=False)
            self.tabla_ascenso.to_csv(f"datos/serie_ascenso_{self.año}.csv", index=False)
            
            # Actualizar estadísticas generales
            try:
                estadisticas = pd.read_csv("datos/estadisticas.csv")
            except FileNotFoundError:
                estadisticas = pd.DataFrame(columns=["Año", "Campeon_1era", "Campeon_Ascenso", "Copa"])
            
            # Determinar campeones
            campeon_1era = self.tabla_1era.sort_values(by="Puntos", ascending=False).iloc[0]["Equipo"]
            campeon_ascenso = self.tabla_ascenso.sort_values(by="Puntos", ascending=False).iloc[0]["Equipo"]
            copa = self.copa_campeon  # Asumiendo que guardas el campeón de la copa
    
            # Añadir a estadísticas
            nueva_estadistica = {
                "Año": self.año,
                "Campeon_1era": campeon_1era,
                "Campeon_Ascenso": campeon_ascenso,
                "Copa": copa
            }
            estadisticas = estadisticas.append(nueva_estadistica, ignore_index=True)
            estadisticas.to_csv("datos/estadisticas.csv", index=False)
    

    Descripción:

    • Guardado de Tablas: Al finalizar cada campeonato, las tablas de Primera División y Serie Ascenso se guardan en archivos CSV separados según el año.
    • Estadísticas Generales: Se mantiene un archivo estadisticas.csv que almacena el campeón de la Primera División, el campeón de la Serie Ascenso y el campeón de la Copa por año.
    • Manejo de Errores: Si el archivo de estadísticas no existe, se crea uno nuevo.

    10. Notifications Pop-up y Colores

    Dado que estamos trabajando en una aplicación de línea de comandos, las "notificaciones pop-up" serán impresiones en consola con colores para resaltar eventos importantes.

    # campeonato.py (actualización en métodos relevantes)
    from colorama import init, Fore
    
    # Inicializar colorama
    init(autoreset=True)
    
        def manejar_promociones_relegaciones(self):
            # (Código previo)
            print(f"\n{Fore.GREEN}Equipos Relegados de Primera División: {relegados}{Fore.RESET}")
            print(f"{Fore.CYAN}Equipos Promovidos a Primera División: {promovidos}{Fore.RESET}")
            # ... resto del código
    
        def generar_copa(self):
            # ... código previo
            print(f"\n{Fore.MAGENTA}¡Campeón de la Copa {self.año}: {ganadores[0]['nombre']}!{Fore.RESET}")
            return ganadores[0]['nombre']
    

    Descripción:

    • Utiliza colorama para imprimir mensajes destacados en diferentes colores, facilitando la identificación de eventos clave como promociones, relegaciones y campeones de la copa.

    11. Manejo de Errores

    Implementaremos manejo básico de errores, especialmente para la lectura/escritura de archivos.

    # utils.py
    import os
    
    def asegurarse_directorio():
        if not os.path.exists("datos"):
            os.makedirs("datos")
    

    Modifica main.py para asegurarte de que el directorio de datos exista.

    # main.py (actualización)
    from equipos import generar_equipos
    from campeonato import Campeonato
    from utils import asegurarse_directorio
    
    def main():
        asegurarse_directorio()
        año = 1900
        equipos_1era, equipos_ascenso = generar_equipos()
        
        while año <= 2024:  # Puedes ajustar el año final según lo desees
            print(f"\n========== Año {año} ==========")
            campeonato = Campeonato(año, equipos_1era, equipos_ascenso)
            campeonato.jugar_campeonato()
            año += 1
    
    if __name__ == "__main__":
        main()
    

    Descripción:

    • Asegura que el directorio datos exista antes de intentar guardar archivos.

    12. Ejecución del Juego

    Finalmente, ejecuta el juego simplemente corriendo el archivo main.py:

    python main.py
    

    Consideraciones Finales

    • Optimización: Dependiendo del tamaño y necesidades, podrías optimizar el manejo de grandes cantidades de datos o agregar funcionalidades adicionales.
    • Interfaz Gráfica: Para una experiencia de usuario más rica, considera desarrollar una interfaz gráfica utilizando bibliotecas como Tkinter o PyQt.
    • Persistencia Avanzada: Para manejar múltiples usuarios o sesiones, podrías integrar una base de datos como SQLite.

    Este es un punto de partida sólido para tu juego de dados de fútbol. Puedes expandir y personalizar cada parte según tus preferencias y necesidades específicas. ¡Buena suerte con tu proyecto!