Variables y ciclos con combate Pokémon

Aprender a programar puede ser tan claro como seguir el flujo de una batalla por turnos. Con el ejemplo de Pokémon, entenderás cómo usar objetos, variables, condiciones y ciclos para construir un algoritmo simple en JavaScript que decide quién gana entre Pikachu y Jigglypuff.

¿Cómo se modela el combate con objetos?

En programación, un Pokémon se piensa como un objeto: tiene propiedades como nombre, vida y poder de ataque. Aquí ambos empiezan con vida = 100. Pikachu tiene ataque = 55 y Jigglypuff ataque = 45. El daño se calcula restando el ataque del rival a la vida actual.

• Un objeto agrupa datos relacionados en una sola entidad.
• Vida y ataque son datos numéricos que cambian durante el combate.
• El daño se aplica con una asignación: vida = vida − ataque.

const pikachu = { nombre: 'Pikachu', vida: 100, ataque: 55 };
const jigglypuff = { nombre: 'Jigglypuff', vida: 100, ataque: 45 };

¿Qué datos iniciales importan?

• Vida inicial: 100 para ambos.
• Ataque de Pikachu: 55 puntos.
• Ataque de Jigglypuff: 45 puntos.
• El combate es por turnos: primero uno, luego el otro.

¿Por qué las variables y el turno son clave?

Las variables son como “cajitas” que guardan datos. Igual que en álgebra, se les asigna un valor y luego se usan en expresiones. Para recordar quién ataca, definimos una variable turno: si es 1, ataca Pikachu; si es 0, ataca Jigglypuff. Pikachu arranca con turno = 1.

let turno = 1; // 1: Pikachu, 0: Jigglypuff

Actualizar la vida exige asignar el nuevo valor, no solo escribir la operación. Por eso se usa vida = vida − ataque.

if (turno === 1) {
  jigglypuff.vida = jigglypuff.vida - pikachu.ataque; // aplica daño de Pikachu.
  turno = 0; // cambia el turno.
} else {
  pikachu.vida = pikachu.vida - jigglypuff.ataque; // aplica daño de Jigglypuff.
  turno = 1; // cambia el turno.
}

• Asignar es indispensable: sin “=” la variable no cambia.
• Comparar no es lo mismo que asignar: “===” compara, “=” asigna.
• El turno alterna cada vez para mantener el orden del combate.

¿Cómo operan los ciclos y condiciones?

Un ciclo repite instrucciones mientras una condición sea verdadera. Aquí, el combate sigue mientras ambos tengan vida > 0. Se evalúa el turno, se aplica el daño y se alterna de nuevo. La ejecución es muy rápida, aunque la expliques paso a paso.

while (pikachu.vida > 0 && jigglypuff.vida > 0) {
  if (turno === 1) {
    jigglypuff.vida = jigglypuff.vida - pikachu.ataque;
    turno = 0;
  } else {
    pikachu.vida = pikachu.vida - jigglypuff.ataque;
    turno = 1;
  }
}

Al salir del ciclo, una condición final decide quién “murió”. No hace falta preguntar por ambos: si uno no es menor o igual que cero, el otro sí lo es.

if (pikachu.vida <= 0) {
  // Pikachu perdió.
} else {
  // Pikachu ganó.
}

¿Qué comparadores se usan para decidir?

• Mayor que: >.

• Menor que: <.

• Igual: ===.

• Mayor o igual: >=.

• Menor o igual: <=.

• La condición del ciclo combina reglas con “y” lógico: vida > 0 y vida > 0.

• Salir del ciclo significa que al menos una vida ya no es mayor que 0.

• Mostrar el resultado es tan simple como evaluar una condición final.

¿Te gustaría practicar escribiendo este algoritmo paso a paso en JavaScript y comentar cómo mejorar la claridad del flujo por turnos? Comparte tus dudas y avances en los comentarios.