En este post de programación en Python vamos a resolver un ejercicio que tiene que ver con los Pokémon. Se trata de un programa para simular una batalla para planear mejor las estrategias de los combates.

El programa debe calcular los puntos estadísticos, HP, ataque, defensa, etcétera además de tomar en cuenta los puntos individuales, puntos de esfuerzo, entre otros.

De igual modo el programa debe calcular la potencia de daño que hará un ataque desde un Pokémon a otro.

Vamos a aplicar fórmulas y leer los datos desde un archivo CSV así como desde un archivo que nos dirá el daño de un ataque a partir de su nombre. Al final podremos elegir un Pokémon, calcular sus estadísticas y seleccionar un ataque; todo esto con Python.

Las fórmulas

Antes de pasar al código debemos ver las fórmulas. Según el ejercicio tenemos 3 fórmulas: una para el daño (damage), otra para puntos de vida (HP) y otra para puntos estadísticos (Other stats).

Para calcular los HP tenemos lo siguiente:

Cuya fórmula en LaTeX es:

HP = \left[  \frac{ \left((Base + IV) * 2 + \frac{\left[ \sqrt{EV} \right]}{4} \right) * Level} {100}  \right] + Level + 10

Luego tenemos la fórmula para otros puntos estadísticos:

Que en LaTeX se ve así:

OtherStat = \left[  \frac{ \left((Base + IV) * 2 + \left[\frac{\left[ \sqrt{EV} \right]}{4}\right] \right) * Level} {100}  \right] + 5

Y finalmente la del daño:

Que se ve así:

Damage = \left(\frac{\left(\frac{2 * Level}{5}+2\right) * Power * A/D}{50}+2\right)*random

Pasando fórmulas a Python

Al pasar las fórmulas a programación tenemos lo siguiente:

def obtener_hp(base):
    resultado_parentesis = (base+IV)*2+((math.sqrt(EV))/4)
    return (resultado_parentesis * LEVEL / 100) + LEVEL+10


def obtener_other_stat(base):
    resultado_parentesis = (base+IV)*2+((math.sqrt(EV))/4)
    return (resultado_parentesis * LEVEL / 100)+5


def obtener_damage(power, ataque, defensa):
    resultado_parentesis_interior = ((2*LEVEL)/5)+2
    numero_aleatorio = random.uniform(0.85, 1.0)
    resultado_parentesis = (
        (resultado_parentesis_interior * power * (ataque/defensa)) / 50) + 2
    return resultado_parentesis * numero_aleatorio

Por cierto algunas cosas como el IV, el EV y el LEVEL son constantes. Recuerda que para la raíz cuadrada usamos sqrt, y en este caso para sacar un número aleatorio flotante utilizamos random.uniform.

Leer lista de Pokémon

Tenemos a los Pokémon en un archivo CSV pero vamos a parsearlos y cargarlos en un diccionario.

El archivo tiene varias líneas, y en cada línea están los datos del Pokémon en el orden: nombre, puntos de vida, puntos de ataque base, puntos de defensa, movimientos separados por ;.

Te dejo el archivo aquí, pues es un poco largo. La función que lo interpreta y lo carga en un diccionario es:

def obtener_diccionario_segun_csv():
    pokemones = {}
    with open(ARCHIVO_POKEMON_DATA, "r") as archivo:
        for linea in archivo:
            columnas = linea.split(",")
            nombre = columnas[0]
            puntos_de_vida = int(columnas[1])
            puntos_de_ataque = int(columnas[2])
            puntos_de_defensa = int(columnas[3])
            movimientos_posibles = columnas[4].split(";")
            # Ahora que ya lo tenemos parseado, lo agregamos al diccionario
            pokemones[nombre] = {
                "puntos_de_vida": puntos_de_vida,
                "puntos_de_ataque": puntos_de_ataque,
                "puntos_de_defensa": puntos_de_defensa,
                "movimientos_posibles": movimientos_posibles,
            }
    return pokemones

Lo único que hacemos es usar split por cada línea para ir interpretando el CSV.

Calcular poder de ataque

El ejercicio ya proporciona una función que devuelve el poder de ataque y que recibe el nombre del ataque a realizar, misma que está dentro de moves.py. Hay que importarlo con from moves import get_move.

De nuevo te dejo el archivo de moves.py aquí, pues es incluso más largo que el CSV.

Para esto hay que listar todos los movimientos del Pokémon, solicitar al usuario el ataque y luego comprobar que el daño sea distinto de cero.

Todo eso queda encerrado en la siguiente función:

def solicitar_movimiento(movimientos):
    while True:
        print("Movimientos que puede aprender el pokémon: ")
        for indice, movimiento in enumerate(movimientos):
            print(f"{indice} - {movimiento}")
        indice_movimiento = int(input("Seleccione un ataque a ejecutar: "))
        if indice_movimiento < 0 or indice_movimiento > len(movimientos) - 1:
            print("Número inválido")
            continue

        movimiento = movimientos[indice_movimiento]
        print(f"El ataque seleccionado es: {movimiento}")
        poder_ataque = get_move(normalizar_nombre(movimiento))
        if poder_ataque > 0:
            return poder_ataque
        else:
            print("El ataque tiene un poder de 0. Seleccione otro movimiento")

Simular batalla Pokémon

Ahora que ya tenemos las fórmulas, movimientos, lista de los Pokémon y todo eso, es momento de simular una batalla. Para ello tenemos el siguiente código:

def main():
    pokemones = obtener_diccionario_segun_csv()
    print("Bienvenido al simulador")
    nombre_primer_pokemon = normalizar_nombre(
        input("Ingrese el nombre del primer Pokémon: "))
    if nombre_primer_pokemon not in pokemones:
        print("El Pokémon no existe")
        return
    primer_pokemon = pokemones[nombre_primer_pokemon]
    nombre_capitalizado = nombre_primer_pokemon.capitalize()
    print("Nombre del Pokémon seleccionado: " + nombre_capitalizado)
    print("Estadísticas base del Pokémon:")
    print(f"- HP = {primer_pokemon.get('puntos_de_vida')}")
    print(f"- Ataque = {primer_pokemon.get('puntos_de_ataque')}")
    print(f"- Defensa = {primer_pokemon.get('puntos_de_defensa')}")
    movimientos_primer_pokemon = primer_pokemon.get("movimientos_posibles")
    poder_ataque = solicitar_movimiento(movimientos_primer_pokemon)
    print(f"Poder de ataque es: {poder_ataque}")
    hp_nivel_100 = obtener_hp(primer_pokemon.get("puntos_de_vida"))
    atk_nivel_100 = obtener_other_stat(primer_pokemon.get("puntos_de_ataque"))
    def_nivel_100 = obtener_other_stat(primer_pokemon.get("puntos_de_defensa"))
    print(f"El hp al nivel 100 de {nombre_capitalizado} es {hp_nivel_100}")
    print(f"El atk al nivel 100 de {nombre_capitalizado} es {atk_nivel_100}")
    print(f"El def al nivel 100 de {nombre_capitalizado} es {def_nivel_100}")
    nombre_segundo_pokemon = normalizar_nombre(
        input("Ingrese el nombre a atacar Pokémon: "))
    if nombre_segundo_pokemon not in pokemones:
        print("El Pokémon no existe")
        return
    nombre_segundo_pokemon_capitalizado = nombre_segundo_pokemon.capitalize()
    print(
        f"Nombre del Pokémon seleccionado: {nombre_segundo_pokemon_capitalizado}")
    segundo_pokemon = pokemones.get(nombre_segundo_pokemon)
    hp_nivel_100_segundo_pokemon = obtener_hp(
        segundo_pokemon.get("puntos_de_vida"))
    print(
        f"El hp al nivel 100 de {nombre_segundo_pokemon_capitalizado} es {hp_nivel_100_segundo_pokemon}")
    def_nivel_100_segundo_pokemon = obtener_other_stat(
        segundo_pokemon.get("puntos_de_defensa"))
    damage = obtener_damage(poder_ataque, atk_nivel_100,
                            def_nivel_100_segundo_pokemon)
    print(
        f"El daño realizó {nombre_capitalizado} a {nombre_segundo_pokemon_capitalizado} fue de: {damage}")
    nuevo_hp = hp_nivel_100_segundo_pokemon - damage
    print(f"{nombre_segundo_pokemon_capitalizado} quedó con un HP de: {nuevo_hp}")

Poniendo todo junto

El código completo queda así:

"""
    https://parzibyte.me/blog
"""

from moves import get_move
import math
import random

LEVEL = 100  # nivel constante
IV = 31  # nivel constante
EV = 250  # nivel constante
ARCHIVO_POKEMON_DATA = "pokemon_data.csv"


def obtener_hp(base):
    resultado_parentesis = (base+IV)*2+((math.sqrt(EV))/4)
    return (resultado_parentesis * LEVEL / 100) + LEVEL+10


def obtener_other_stat(base):
    resultado_parentesis = (base+IV)*2+((math.sqrt(EV))/4)
    return (resultado_parentesis * LEVEL / 100)+5


def obtener_damage(power, ataque, defensa):
    resultado_parentesis_interior = ((2*LEVEL)/5)+2
    numero_aleatorio = random.uniform(0.85, 1.0)
    resultado_parentesis = (
        (resultado_parentesis_interior * power * (ataque/defensa)) / 50) + 2
    return resultado_parentesis * numero_aleatorio


# Regresa el nombre sin espacios y en minúscula
def normalizar_nombre(nombre):
    return nombre.lower().replace(" ", "")


def obtener_diccionario_segun_csv():
    pokemones = {}
    with open(ARCHIVO_POKEMON_DATA, "r") as archivo:
        for linea in archivo:
            columnas = linea.split(",")
            nombre = columnas[0]
            puntos_de_vida = int(columnas[1])
            puntos_de_ataque = int(columnas[2])
            puntos_de_defensa = int(columnas[3])
            movimientos_posibles = columnas[4].split(";")
            # Ahora que ya lo tenemos parseado, lo agregamos al diccionario
            pokemones[nombre] = {
                "puntos_de_vida": puntos_de_vida,
                "puntos_de_ataque": puntos_de_ataque,
                "puntos_de_defensa": puntos_de_defensa,
                "movimientos_posibles": movimientos_posibles,
            }
    return pokemones


def solicitar_movimiento(movimientos):
    while True:
        print("Movimientos que puede aprender el pokémon: ")
        for indice, movimiento in enumerate(movimientos):
            print(f"{indice} - {movimiento}")
        indice_movimiento = int(input("Seleccione un ataque a ejecutar: "))
        if indice_movimiento < 0 or indice_movimiento > len(movimientos) - 1:
            print("Número inválido")
            continue

        movimiento = movimientos[indice_movimiento]
        print(f"El ataque seleccionado es: {movimiento}")
        poder_ataque = get_move(normalizar_nombre(movimiento))
        if poder_ataque > 0:
            return poder_ataque
        else:
            print("El ataque tiene un poder de 0. Seleccione otro movimiento")


def main():
    pokemones = obtener_diccionario_segun_csv()
    print("Bienvenido al simulador")
    nombre_primer_pokemon = normalizar_nombre(
        input("Ingrese el nombre del primer Pokémon: "))
    if nombre_primer_pokemon not in pokemones:
        print("El Pokémon no existe")
        return
    primer_pokemon = pokemones[nombre_primer_pokemon]
    nombre_capitalizado = nombre_primer_pokemon.capitalize()
    print("Nombre del Pokémon seleccionado: " + nombre_capitalizado)
    print("Estadísticas base del Pokémon:")
    print(f"- HP = {primer_pokemon.get('puntos_de_vida')}")
    print(f"- Ataque = {primer_pokemon.get('puntos_de_ataque')}")
    print(f"- Defensa = {primer_pokemon.get('puntos_de_defensa')}")
    movimientos_primer_pokemon = primer_pokemon.get("movimientos_posibles")
    poder_ataque = solicitar_movimiento(movimientos_primer_pokemon)
    print(f"Poder de ataque es: {poder_ataque}")
    hp_nivel_100 = obtener_hp(primer_pokemon.get("puntos_de_vida"))
    atk_nivel_100 = obtener_other_stat(primer_pokemon.get("puntos_de_ataque"))
    def_nivel_100 = obtener_other_stat(primer_pokemon.get("puntos_de_defensa"))
    print(f"El hp al nivel 100 de {nombre_capitalizado} es {hp_nivel_100}")
    print(f"El atk al nivel 100 de {nombre_capitalizado} es {atk_nivel_100}")
    print(f"El def al nivel 100 de {nombre_capitalizado} es {def_nivel_100}")
    nombre_segundo_pokemon = normalizar_nombre(
        input("Ingrese el nombre a atacar Pokémon: "))
    if nombre_segundo_pokemon not in pokemones:
        print("El Pokémon no existe")
        return
    nombre_segundo_pokemon_capitalizado = nombre_segundo_pokemon.capitalize()
    print(
        f"Nombre del Pokémon seleccionado: {nombre_segundo_pokemon_capitalizado}")
    segundo_pokemon = pokemones.get(nombre_segundo_pokemon)
    hp_nivel_100_segundo_pokemon = obtener_hp(
        segundo_pokemon.get("puntos_de_vida"))
    print(
        f"El hp al nivel 100 de {nombre_segundo_pokemon_capitalizado} es {hp_nivel_100_segundo_pokemon}")
    def_nivel_100_segundo_pokemon = obtener_other_stat(
        segundo_pokemon.get("puntos_de_defensa"))
    damage = obtener_damage(poder_ataque, atk_nivel_100,
                            def_nivel_100_segundo_pokemon)
    print(
        f"El daño realizó {nombre_capitalizado} a {nombre_segundo_pokemon_capitalizado} fue de: {damage}")
    nuevo_hp = hp_nivel_100_segundo_pokemon - damage
    print(f"{nombre_segundo_pokemon_capitalizado} quedó con un HP de: {nuevo_hp}")


main()

Recuerda que además del código necesitas los archivos moves.py y pokemon_data.csv (ya los dejé arriba) en el mismo directorio en donde se encuentre el archivo principal

Si quieres puedes leer más sobre Python en mi blog.