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();
	}
 

// Signos en línea en tableros cuadrados:
// Este programa tiene básicamente ?????????????????????????????????????? etapas,
// que se pueden resumir así:
// Nota: La situación inicial, en que hay 0 signos colocados,
// estará guardada en la lista nro 0.
// 1:
// Probar acciones en cada situación de la lista,
// guardando en una nueva lista las nuevas situaciones (que no...
// sean victoria ni empate). Repetir con cada lista hasta la que...
// tenga situaciones en que sólo 1 acción es posible (por...
// ejemplo en el 3 en línea es 8).
// 2:		ACTUALIZAR ESTA
// En las situaciones no resueltas, probar las acciones.
// Si las consecuencias tienen RE, anotar cuantas de ellas...
// son victoria de X, 0 o empate y anotar la acción que...
// cause la RE más favorable, considerando secundariamente...
// las cantidades.
JuntosRequeridos = 2;
CasillerosPorFila = 2;
// Contando desde 0:
MaxColumna = CasillerosPorFila-1;
Casilleros = CasillerosPorFila*CasillerosPorFila;
// Están numerados así:
// 0 1
// 2 3
MaxCasillero = Casilleros-1;
// En las listas L_SaE se irán poniendo las situaciones a...
// experimentar que tengan _ signos colocados.
// En la lista 0 agregar una situación, aún no se dice cual:
L0SaE1 = [];
// A continuación se especifica cómo es, agregando v
// (que significa vacío) en lo que serían los casilleros,
// los elementos del array:
ValoraAgregar = -1;
do {
	ValoraAgregar++;
	L0SaE1.push("v");
} while (ValoraAgregar < MaxCasillero);
delete ValoraAgregar;
// Los datos de las situaciones no están en las listas,
// se crean aparte. Con esta variable se evita repetidamente...
// convertir en texto y concatenar:
S_ = "S"+(L0SaE1.join(""));
// Datos de la situación:
// Usada para fácilmente saber de qué signo es turno:
set (S_+"Turno", "X");
// En otros casos usada para evitar probar acciones...
// innecesarias y con LastAPosible para saber si sólo queda 1:
set (S_+"FirstAPosible", 0);
set (S_+"LastAPosible", MaxCasillero);
NroDeListaRevisandose = -1;
// Última lista que se revisará en la etapa 1:
LastListaDeEt1 = MaxCasillero;
// /////////////////////////////////////////////
// /////////////////  Etapa 1  /////////////////
// /////////////////////////////////////////////
// Usada a continuación y durante la etapa 1 (Et1)...
// cuando no hay más situaciones en la lista revisándose:
function BuscarOtraListaEt1 () {
	trace("Ejecutando BuscarOtraListaEt1");
	NroDeListaRevisandose++;
	// Si las situaciones de la lista tienen más de 1 opción:
	if (NroDeListaRevisandose < LastListaDeEt1) {
		// Para evitar concatenar repetidamente:
		L_SaE = "L"+NroDeListaRevisandose+"SaE";
		NextL_SaE = "L"+(NroDeListaRevisandose+1)+"SaE";
		NroDeSExperimentandose = 1;
		// También para evitar concatenar repetidamente:
		// L_SaE_ = L_SaE+NroDeSExperimentandose;
		L_SaE_ = L_SaE+"1";
		// Usado en EvaluarConocimientoSobreSEt1 para...
		// nombrar las situaciones nuevas que se logren:
		SituacionesNuevas = 0;
		trace("Comienzan experimentos en una nueva lista, la "+NroDeListaRevisandose);
		PrepararSaE();
	} else {
		trace(	"La próxima lista tiene situaciones de sólo 1 opción; inicia la etapa 2.");
		// IniciarEtapa2();
		gotoAndStop(4);
	}
}
BuscarOtraListaEt1();
// Usada cuando se elege una SaE, en BuscarOtraListaEt1 y...
// BuscarOtraSituacionEt1:
function PrepararSaE () {
	trace("Ejecutando PrepararSaE");
	trace("Se inician experimentos en otra situación de la lista, la nro "+NroDeSExperimentandose);
	SituacionBase = eval(L_SaE_);
	S_ = "S"+(SituacionBase.join(""));
	Turno = eval(S_+"Turno");
	FirstActionPosible = eval(S_+"FirstAPosible");
	LastActionPosible = eval(S_+"LastAPosible");
	Action = FirstActionPosible;
}
// Usada en frame 2 (o etapa 1) repetidamente:
function BuscarSituacionesDistantes () {
	// Plantear situación porque puede modificarse pero...
	// podría requerirse su estado original luego:
	Situacion = SituacionBase.slice();
	trace("La situación experimentándose es "+Situacion);
	EvaluarAplicabilidadEt1();
}
// Usada luego de que cambia la SaE y/o la acción:
function EvaluarAplicabilidadEt1 () {
	trace("Ejecutando EvaluarAplicabilidadEt1");
	if (Situacion[Action] == "v") {
		trace("La acción "+Action+" es realizable.");
		AplicarAccionEt1();
	} else {
		trace("La acción "+Action+" no es realizable.");
		BuscarOtraAccionEt1();
	}
}
// Usada luego de EvaluarAplicabilidadEt1,
// si una acción es realizable:
function AplicarAccionEt1 () {
	trace("Ejecutando AplicarAccionEt1");
	Situacion[Action] = Turno;
	trace("Se realizó la acción "+Action+"; ahora la situación es "+Situacion);
	// ¿Ganó?
	// Si no se detecta victoria vertical,
	// revisa de otros modos (ver las funciones Chequear):
	ChequearVertical();
	if (Win == "No") {
		EvaluarConocimientoSobreSEt1();
	}
	// ¿Queda alguna acción sin probar en la situación?
	BuscarOtraAccionEt1();
}
// Usada en EvaluarAplicabilidadEt1 cuando una acción no es...
// realizable, y luego de AplicarAccionEt1:
function BuscarOtraAccionEt1 () {
	trace("Ejecutando BuscarOtraAccionEt1");
	if (Action < LastActionPosible) {
		// Si queda alguna acción sin probar...
		// en la situación, probarla:
		Action++;
		// Se ejecutará BuscarSituacionesDistantes.
	} else {
		trace("No hay más acciones realizables.");
		BuscarOtraSituacionEt1();
	}
}
// Usada en AplicarAccionEt1 cuando no hay victoria (ni empate,
// aunque por ahora no ocurren):
function EvaluarConocimientoSobreSEt1 () {
	trace("Ejecutando EvaluarConocimientoSobreSEt1");
	SituacionJoined = Situacion.join("");
	NewS_ = "S"+SituacionJoined;
	NewS_BestAction = NewS_+"BestAction";
	// ¿Se ha llegado antes a la situación?
	if (eval(NewS_BestAction) == undefined) {
		// No, anotar que debe investigarse:
		SituacionesNuevas++; 
		// Copiar array (porque no se puede normalmente):
		trace("Situación a copiar a "+NextL_SaE+SituacionesNuevas+" es "+Situacion);
		set (NextL_SaE+SituacionesNuevas, Situacion.slice());
		trace("Esa situación no está anotada; se anota como nro "+SituacionesNuevas);
		set(NewS_BestAction, "Desconocida");
		if (Turno == "X") {
			set (NewS_+"Turno", "0");
		} else {
			set (NewS_+"Turno", "X");
		}
		// Averiguar cual es su 1er acción posible:
		AccionRevisandose = -1;
		do {
			AccionRevisandose++;
			if (Situacion[AccionRevisandose] == "v") {
				set (NewS_+"FirstAPosible", AccionRevisandose);
				break;
			}
		} while (true);
		// Averiguar cual es su última acción posible:
		AccionRevisandose = Casilleros;
		do {
			AccionRevisandose--;
			if (Situacion[AccionRevisandose] == "v") {
				set (NewS_+"LastAPosible", AccionRevisandose);
				break;
			}
		} while (true);
	}
}
// Usada en BuscarOtraAccionEt1 cuando no hay más acciones posibles:
function BuscarOtraSituacionEt1 () {
	trace("Ejecutando BuscarOtraSituacionEt1");
	NroDeSExperimentandose++;
	if (eval(L_SaE+NroDeSExperimentandose) != undefined) {
		// Hay otra situación en la lista,
		// prepararse a usarla:
		L_SaE_ = L_SaE+NroDeSExperimentandose;
		PrepararSaE();
	} else {
		trace(	"No hay más situaciones a experimentar en la lista actual, se mirará otra.");
		BuscarOtraListaEt1();
	}
}

function VariarMeteoro () {
	Diametro = 44;
	Radio = Diametro/2;
	// Insertarle imágenes:
	Imagen = 0;
	do {
		Imagen++;
		Name = "Imagen"+Imagen;
		Meteor.attachMovie("sCirculo", Name, Imagen);
		Name = "Meteor."+Name;
		// Para los tamaños y rotación:
		setProperty (Name, _xscale, 400*Math.random());
		setProperty (Name, _yscale, 400*Math.random());
		setProperty (Name, _rotation, 360*Math.random());
		// Para las posiciones:
		X = Math.random()*Diametro - Radio;
		setProperty (Name, _x, X);
		MaxY = Math.sqrt(Radio*Radio - X*X);
		Y = Math.random() * (MaxY*2) - MaxY;
		setProperty (Name, _y, Y);
		// Para los colores:
		ColorDeName = new Color(Name);
		Brillo = 0.2 + 0.8 * Math.random();
		Rojo = Math.round(MaxRojo * Brillo);
		Verde = Math.round(MaxVerde * Brillo);
		Azul = Math.round(MaxAzul * Brillo);
		ColorElegido = (Rojo << 16) | (Verde << 8) | Azul;
		ColorDeName.setRGB(ColorElegido);
	} while (Imagen < 1000);
}

Imagen = 0;
do {
	Imagen++;
	Name = "Imagen"+Imagen;
	Meteor.attachMovie("sCirculo", Name, Imagen);
	Name = "Meteor."+Name;
	setProperty (Name, _x, Math.random()*44-22);
	setProperty (Name, _y, Math.random()*44-22);
} while (Imagen < 50);