Cartas = ["MarioDK", "DK"];
// Lo anterior se usa para hacer sus efectos, esto es cómo se muestran sus nombres:
ShowerDeCartas = ["Mario de Donkey Kong", "Donkey Kong"];
HumanoHP = 10;
IAHP = 10;
// Frame 1: Se dan cartas, el mensaje no tiene saltos de línea.
// F2: Un objeto repite TurnoDeHumano hasta que se presione A.
NroDeCartaDeHumano = random(Cartas.length);
Mensaje = "Tu carta ahora es "+ShowerDeCartas[NroDeCartaDeHumano];
NroDeCartaDeIA = random(Cartas.length);
function TurnoDeHumano () {
	// Si se presiona A:
	if (Key.isDown(65)) {
		// Usa la carta (dando su estadística AT a la función):
		eval(Cartas[NroDeCartaDeHumano])(eval(Cartas[NroDeCartaDeHumano]+"AT"));
	}
}
function HumanoObtieneCarta () {
	NroDeCartaDeHumano = random(Cartas.length);
	Mensaje = Mensaje+"\n\nTu carta ahora es "+ShowerDeCartas[NroDeCartaDeHumano];
}
function FinDelTurnoDeHumano () {
	HumanoObtieneCarta();
	// Turno de la IA:
}
function Victoria () {
	Mensaje = Mensaje+"\n\n¡Ganaste!";
	gotoAndStop (4);
}
// Estadísticas:
MarioDKAT = 1;
DKAT = 2;
// Efectos:
function MarioDK (ataque) {
	Mensaje = "¡Tu rival ha sido enjaulado!";
	IAHP = IAHP-ataque;
	if (IAHP > 0) {
		FinDelTurnoDeHumano();
	} else {
		Victoria();
	}
}
function DK (ataque) {
	Mensaje = "¡Rival dañado!";
	IAHP = IAHP-ataque;
	if (IAHP > 0) {
		FinDelTurnoDeHumano();
	} else {
		Victoria();
	}
}

	IAHP = IAHP-ataque;
	if (IAHP > 0) {
		FinDelTurnoDeHumano();
	} else {
		Victoria();
	}
 

# Análisis y Mejoras para el Juego de Cartas

## Mejoras de Código y Estructura

1. **Eliminar duplicación de código**: El patrón de reducir HP y verificar victoria se repite. Podrías crear una función común:
```actionscript
function aplicarAtaque(target, ataque, mensajeEfecto) {
    target.HP -= ataque;
    Mensaje = mensajeEfecto;
    if (target.HP > 0) {
        FinDelTurnoDeHumano();
    } else {
        Victoria();
    }
}
```

2. **Sistema de objetivos más flexible**: En lugar de hardcodear el objetivo, puedes pasar el objetivo como parámetro:

```actionscript
function MarioDK(ataque, objetivo) {
    aplicarAtaque(objetivo, ataque, "¡Tu rival ha sido enjaulado!");
}

// Llamada:
eval(Cartas[NroDeCartaDeHumano])(eval(Cartas[NroDeCartaDeHumano]+"AT"), IA);
```

3. **Estructura de datos más organizada**: En lugar de tener arrays separados para nombres y estadísticas, podrías usar objetos:

```actionscript
Cartas = [
    {nombre: "Mario de Donkey Kong", ataque: 1, efecto: MarioDK},
    {nombre: "Donkey Kong", ataque: 2, efecto: DK}
];
```

4. **Sistema de turnos más robusto**: Implementar un sistema de gestión de turnos que alterna entre jugadores.

## Implementación Mejorada

Aquí tienes una versión mejorada que aborda estos puntos:

```actionscript
// Configuración inicial
Cartas = [
    {nombre: "Mario de Donkey Kong", ataque: 1, efecto: function(objetivo) {
        aplicarAtaque(objetivo, this.ataque, "¡Tu rival ha sido enjaulado!");
    }},
    {nombre: "Donkey Kong", ataque: 2, efecto: function(objetivo) {
        aplicarAtaque(objetivo, this.ataque, "¡Rival dañado!");
    }}
];

Jugador = {HP: 10, nombre: "Humano"};
IA = {HP: 10, nombre: "IA"};
turnoActual = Jugador;
Mensaje = "";

// Frame 1: Repartir cartas iniciales
repartirCartas();

// Frame 2: Lógica del juego
function repartirCartas() {
    NroDeCartaDeHumano = random(Cartas.length);
    NroDeCartaDeIA = random(Cartas.length);
    Mensaje = "Tu carta ahora es " + Cartas[NroDeCartaDeHumano].nombre;
}

function TurnoDeHumano() {
    if (Key.isDown(65)) { // Si se presiona A
        var carta = Cartas[NroDeCartaDeHumano];
        carta.efecto(IA); // Siempre ataca a la IA en este caso
    }
}

function aplicarAtaque(objetivo, ataque, mensajeEfecto) {
    objetivo.HP -= ataque;
    Mensaje = mensajeEfecto;
   
    if (objetivo.HP <= 0) {
        Victoria();
    } else if (turnoActual == Jugador) {
        FinDelTurnoDeHumano();
    } else {
        // Turno de la IA
        turnoIA();
    }
}

function FinDelTurnoDeHumano() {
    turnoActual = IA;
    repartirCartas();
    // La IA juega inmediatamente después
    turnoIA();
}

function turnoIA() {
    var carta = Cartas[NroDeCartaDeIA];
    carta.efecto(Jugador); // La IA siempre ataca al jugador
   
    // Volver al turno del jugador
    turnoActual = Jugador;
    repartirCartas();
}

function Victoria() {
    var ganador = (IA.HP <= 0) ? Jugador : IA;
    Mensaje = "¡" + ganador.nombre + " ha ganado!";
    gotoAndStop(4);
}
```

## Ventajas de esta implementación:

1. **Flexibilidad en objetivos**: Las funciones de efecto ahora reciben explícitamente su objetivo.
2. **Estructura más clara**: Los datos de las cartas están encapsulados en objetos.
3. **Sistema de turnos**: Más fácil de extender para más jugadores o mecánicas complejas.
4. **Menos duplicación**: La lógica común está centralizada en `aplicarAtaque`.

## Para futuras expansiones:

1. **Efectos complejos**: Puedes añadir propiedades adicionales a las cartas (como "dañoAutomatico", "curar", etc.)
2. **Selección de objetivo**: Modificar la UI para permitir elegir objetivo cuando sea relevante.
3. **Múltiples jugadores**: El sistema de turnos ya está preparado para escalar.

Esta estructura hace que sea más fácil añadir nuevos tipos de cartas con efectos variados sin tener que modificar mucho la lógica principal del juego.