Escena 1
   actions for fotograma 1
      // De las permutaciones a crear:
      Largo = 1;
      // Primeras opciones y costos:
      // Largo de la permutación, id:
      L1P1 = "A";
      L1P1Costo = 4;
      L1P1Opciones = ["B", "C", "D", "E", "F", "G", "H"];
      L1P2 = "B";
      L1P2Costo = 4;
      L1P2Opciones = ["A", "C", "D", "E", "F", "G", "H"];
      L1P3 = "C";
      L1P3Costo = 4;
      L1P3Opciones = ["A", "B", "D", "E", "F", "G", "H"];
      L1P4 = "D";
      L1P4Costo = 4;
      L1P4Opciones = ["A", "B", "C", "E", "F", "G", "H"];
      L1P5 = "E";
      L1P5Costo = 2;
      L1P5Opciones = ["A", "B", "C", "D", "F", "G", "H"];
      L1P6 = "F";
      L1P6Costo = 2;
      L1P6Opciones = ["A", "B", "C", "D", "E", "G", "H"];
      L1P7 = "G";
      L1P7Costo = 2;
      L1P7Opciones = ["A", "B", "C", "D", "E", "F", "H"];
      L1P8 = "H";
      L1P8Costo = 2;
      L1P8Opciones = ["A", "B", "C", "D", "E", "F", "G"];
      // Costes:
      CostoAB = 2;
      CostoBA = 2;
      CostoAC = 1;
      CostoCA = 1;
      CostoAD = 2;
      CostoDA = 2;
      CostoAE = 2;
      CostoEA = 2;
      CostoAF = 2;
      CostoFA = 2;
      CostoAG = 3;
      CostoGA = 3;
      CostoAH = 3;
      CostoHA = 3;
      // 
      CostoBC = 2;
      CostoCB = 2;
      CostoBD = 1;
      CostoDB = 1;
      CostoBE = 2;
      CostoEB = 2;
      CostoBF = 2;
      CostoFB = 2;
      CostoBG = 3;
      CostoGB = 3;
      CostoBH = 3;
      CostoHB = 3;
      // 
      CostoCD = 2;
      CostoDC = 2;
      CostoCE = 2;
      CostoEC = 2;
      CostoCF = 2;
      CostoFC = 2;
      CostoCG = 3;
      CostoGC = 3;
      CostoCH = 3;
      CostoHC = 3;
      // 
      CostoDE = 3;
      CostoED = 3;
      CostoDF = 2;
      CostoFD = 2;
      CostoDG = 3;
      CostoGD = 3;
      CostoDH = 3;
      CostoHD = 3;
      // 
      CostoEF = 1;
      CostoFE = 1;
      CostoEG = 1;
      CostoGE = 1;
      CostoEH = 2;
      CostoHE = 2;
      // 
      CostoFG = 2;
      CostoGF = 2;
      CostoFH = 1;
      CostoHF = 1;
      // 
      CostoGH = 1;
      CostoHG = 1;
      // Para saber cuántas permutaciones con el largo anterior hay...
      // que extender:
      PermutacionesDeOldL = 8;
      Mensaje = "";
   actions for fotograma 2
      // Se extenderá L?P1, L?P2, etc, esto evita repetir concatenaciones:
      L_OldLargo_P = "L"+Largo+"P";
      // Incrementar largo de las permutaciones a crearse:
      Largo++;
      Mensaje = "Nuevo largo de permutaciones: "+Largo;
      // Parte de nombres de nuevas permutaciones, usado para evitar...
      // repetir concatenaciones:
      L_NewLargo_P = "L"+Largo+"P";
      NroDePermutacionaExtender = 0;
      // Cuando se empiece a extender permutaciones más largas,
      // esto determina cuántas hay que extender (PermutacionesDeOldL):
      PermutacionesNuevas = 0;
   actions for fotograma 3
      // Cambiar permutación a extender:
      NroDePermutacionaExtender++;
      NombreDePaExtender = L_OldLargo_P+NroDePermutacionaExtender;
      // Para evitar evals:
      EvaluedNombreDePaExtender = eval(NombreDePaExtender);
      // trace ("Se extenderá la permutación "+NombreDePaExtender+", que es "+EvaluedNombreDePaExtender);
      // Copia de variable, para evitar referencias:
      CaracteresDisponibles = eval(NombreDePaExtender+"Opciones");
      // Para evitar restas:
      LastNroDeCaracter = CaracteresDisponibles.length-1;
      NroDeCaracteraAgregar = -1;
      // Copia para evitar referencias:
      Costo = eval(NombreDePaExtender+"Costo");
      Mensaje = "Se extenderá la permutación "+NombreDePaExtender+", que es "+EvaluedNombreDePaExtender+" y cuesta "+Costo;
      // Último punto alcanzado:
      LastPunto = EvaluedNombreDePaExtender.charat(EvaluedNombreDePaExtender.length-1);
      // ¿NO SE PODRÍA USAR LastNroDeCaracter?
      // Para evitar repetir concatenaciones al averiguar costo a sumar:
      Costo_LastPunto = "Costo"+LastPunto;
      // ResumenParaCosto = "Costo"+(eval(NombreDePaExtender).charat(LastNroDeCaracter));
   actions for fotograma 4
      // Cambiar el caracter que se agrega:
      NroDeCaracteraAgregar++;
      // Crear permutación usando la a extender,
      // agregándole el caracter señalado:
      PermutacionesNuevas++;
      NombreDeNuevaP = L_NewLargo_P+PermutacionesNuevas;
      set (NombreDeNuevaP, eval(NombreDePaExtender)+CaracteresDisponibles[NroDeCaracteraAgregar]);
      // trace ("Nueva permutación: "+NombreDeNuevaP+": "+eval(NombreDeNuevaP));
      // Crear su variable de Opciones
      // (slice para copiar el array,
      // splice para quitarle un elemento):
      // Copia el array:
      CopiaDelArray = CaracteresDisponibles.slice();
      // A esa copia se le quita el caracter agregado en la permutación:
      CopiaDelArray.splice(NroDeCaracteraAgregar, 1);
      set (NombreDeNuevaP+"Opciones", CopiaDelArray);
      // trace ("Sus opciones son: "+NombreDeNuevaP+"Opciones: "+eval(NombreDeNuevaP+"Opciones"));
      set (NombreDeNuevaP+"Costo", Costo+(eval(Costo_LastPunto+(eval(NombreDeNuevaP).charat(eval(NombreDeNuevaP).length-1)))));
   actions for fotograma 5
      if (NroDeCaracteraAgregar<LastNroDeCaracter) {
         // Se volverá a extender la permutación, cambiando el caracter:
         gotoAndPlay (4);
      } else if (NroDePermutacionaExtender<PermutacionesDeOldL) {
         // Se volverá a cambiar la permutación a extender:
         delete eval(NombreDePaExtender);
         delete eval(NombreDePaExtender+"Opciones");
         delete eval(NombreDePaExtender+"Costo");
         gotoAndPlay (3);
      } else if (Largo<4) {
         // Se volverá a incrementar el largo...
         // de las permutaciones a extender:
         delete eval(NombreDePaExtender);
         delete eval(NombreDePaExtender+"Opciones");
         delete eval(NombreDePaExtender+"Costo");
         PermutacionesDeOldL = PermutacionesNuevas;
         gotoAndPlay (2);
      }
   actions for fotograma 6
      Mensaje = "Borrando variables innecesarias.";
      NroDePermutacionaBorrar = 0;
      do {
         NroDePermutacionaBorrar++;
         delete eval(L_NewLargo_P+NroDePermutacionaBorrar+"Opciones");
         delete eval(L_NewLargo_P+NroDePermutacionaBorrar);
      } while (NroDePermutacionaBorrar<PermutacionesNuevas);
   actions for fotograma 7
      delete eval(NombreDePaExtender);
      delete eval(NombreDePaExtender+"Opciones");
      delete PermutacionesDeOldL;
      delete Largo;
      delete L_OldLargo_P;
      delete L_NewLargo_P;
      delete NroDePermutacionaExtender;
      delete PermutacionesNuevas;
      delete NombreDePaExtender;
      delete CaracteresDisponibles;
      delete LastNroDeCaracter;
      delete NroDeCaracteraAgregar;
      delete NombreDeNuevaP;
      delete CopiaDelArray;
      delete NroDePermutacionaBorrar;
      Mensaje = "Listo.";
      stop ();
 

	DibujoEnBinario = "";
	NroDelCaracter = Cuadraditos;
	AnteriorCaracteraPintar = Cuadraditos-CuadraditosPorFila;
	// Esto genera la |
	do {
		NroDelCaracter--;
		if (NroDelCaracter != AnteriorCaracteraPintar) {
			DibujoEnBinario = DibujoEnBinario+1;
		} else {
			DibujoEnBinario = DibujoEnBinario+0;
			AnteriorCaracteraPintar = AnteriorCaracteraPintar-CuadraditosPorFila;
		}
	} while (NroDelCaracter > CuadraditosPorFila);
	// Esto la _
	do {
		NroDelCaracter--;
		DibujoEnBinario = DibujoEnBinario+0;
	} while (NroDelCaracter > 0);
	trace("DibujoEnBinario (_|): "+DibujoEnBinario);

	DibujoaMostrar = 0;
	do {
		DibujoaMostrar = DibujoaMostrar+(Number(DibujoEnBinario.charat(NroDelCaracter))*Math.pow(2, DibujoEnBinario.length-1-NroDelCaracter));
		NroDelCaracter++;
	} while	(NroDelCaracter < Cuadraditos);
	DibujoaMostrar = Number(DibujoaMostrar);

Disminucion = Math.floor(DibujoaMostrar/Cuadros);
// Se llama disminución porque se comenzará mostrando...
// el dibujo que según el modo conque los numero,
// es el último, y se irá disminuyendo.

// Generador de dibujos.
// 
// Se insertarán cuadros numerados así:
// 0 1
// 2 3
// En cada uno se insertarán cuadraditos numerados al revés (ver...
// Por qué cuadraditos numerados inversamente.txt por detalles).
// 
// Usada en InsertarCuadros sólo 1 vez
// (ergo podría no ser una función, pero por ahora simplifica):
function AjustarVariables () {
	Cuadros = CuadrosPorFila*CuadrosPorFila;
	MaxCuadro = Cuadros-1;
	Cuadraditos = CuadraditosPorFila*CuadraditosPorFila;
	MaxCuadradito = Cuadraditos-1;
	LargoDeCuadraditos = 384/(CuadraditosPorFila*CuadrosPorFila+CuadrosPorFila-1);
	LargoDeCuadros = CuadraditosPorFila*LargoDeCuadraditos;
	// Esto es para que el 1er dibujo sea una |_ porque es el...
	// 1ero que tiene algún cuadradito pintado en cada fila y...
	// columna (en realidad el 1ero es el que tiene despintado el punto de unión, pero hay poca diferencia)
	// esto es para evitar que se salteén montones de dibujos.
	// Se averigua su número representante:
	DibujoEnBinario = "";
	NroDelCaracter = Cuadraditos;
	AnteriorCaracteraPintar = Cuadraditos-CuadraditosPorFila;
	// Esto genera la |
	do {
		NroDelCaracter--;
		if (NroDelCaracter != AnteriorCaracteraPintar) {
			DibujoEnBinario = DibujoEnBinario+1;
		} else {
			DibujoEnBinario = DibujoEnBinario+0;
			AnteriorCaracteraPintar = AnteriorCaracteraPintar-CuadraditosPorFila;
		}
	} while (NroDelCaracter > CuadraditosPorFila);
	// Esto la _
	do {
		NroDelCaracter--;
		DibujoEnBinario = DibujoEnBinario+0;
	} while (NroDelCaracter > 0);
	trace("DibujoEnBinario (_|): "+DibujoEnBinario);
	// Convertirlo en decimal:
	DibujoaMostrar = 0;
	do {
		DibujoaMostrar = DibujoaMostrar+(Number(DibujoEnBinario.charat(NroDelCaracter))*Math.pow(2, DibujoEnBinario.length-1-NroDelCaracter));
		NroDelCaracter++;
	} while (NroDelCaracter < Cuadraditos);
	DibujoaMostrar = Number(DibujoaMostrar);
	// Esa cantidad se dividirá según la cantidad de cuadros,
	// de modo que cada cuadro mostrará la misma cantidad de...
	// dibujos, pero distintos a los de otros cuadros:
	Disminucion = Math.floor(DibujoaMostrar/Cuadros);
	// Se llama disminución porque se comenzará mostrando...
	// el dibujo que según el modo conque los numero,
	// es el último, y se irá disminuyendo:
	// DibujoaMostrar = DibujoaMostrar-1;
	trace("DibujoaMostrar: "+DibujoaMostrar);
}
// Usada en InsertarCuadros una vez (totalmente innecesaria):
function ConvertiraBinarioInverso (numero) {
	trace(numero);
	// Averiguar cómo es en binario:
	DibujoEnBinario = "";
	while (numero>0) {
		DibujoEnBinario = DibujoEnBinario+numero%2;
		numero = Math.floor(numero/2);
	}
	// Agregar 0s a DibujoEnBinario si hacen falta:
	while (DibujoEnBinario.length<Cuadraditos) {
		DibujoEnBinario = DibujoEnBinario+0;
	}
	trace("DibujoEnBinario: "+DibujoEnBinario);
}
// Usada al inicio y cuando aumenta la cantidad de cuadraditos por fila:
function InsertarCuadros () {
	AjustarVariables();
	NroDelCuadroaColocar = 0;
	// Sus columnas y filas se cuentan desde 0 también:
	ColumnaDeCuadro = 0;
	FilaDeCuadro = 0;
	do {
		NombreDelCuadro = "Cuadro"+NroDelCuadroaColocar;
		attachMovie("sCuadro", NombreDelCuadro, NroDelCuadroaColocar);
		setProperty (NombreDelCuadro, _x, LargoDeCuadros*ColumnaDeCuadro+ColumnaDeCuadro*LargoDeCuadraditos);
		setProperty (NombreDelCuadro, _y, LargoDeCuadros*FilaDeCuadro+FilaDeCuadro*LargoDeCuadraditos);
		ColumnaDeCuadro++;
		if (ColumnaDeCuadro == CuadrosPorFila) {
			ColumnaDeCuadro = 0;
			FilaDeCuadro++;
		}
		// Se agregarán y distribuirán cuadraditos en el cuadro...
		// recién agregado, numerándolos del modo opuesto:
		NroDelCuadraditoaColocar = MaxCuadradito;
		// Sus columnas y filas se cuentan desde 0:
		ColumnaDeCuadradito = 0;
		FilaDeCuadradito = 0;
		// Se pintarán de modo que muestren el dibujo...
		// acorde a la división de dibujos; averiguarlo:
		ConvertiraBinarioInverso(DibujoaMostrar);
		ColumnaDeCuadradito = 0;
		FilaDeCuadradito = 0;
		do {
			eval(NombreDelCuadro).attachMovie("sCuadradito", "Cuadradito"+NroDelCuadraditoaColocar, NroDelCuadraditoaColocar);
			NombreDelCuadraditoSinNum = NombreDelCuadro+".Cuadradito";
			NombreDelCuadradito = NombreDelCuadraditoSinNum+NroDelCuadraditoaColocar;
			setProperty (NombreDelCuadradito, _x, ColumnaDeCuadradito*LargoDeCuadraditos);
			setProperty (NombreDelCuadradito, _y, FilaDeCuadradito*LargoDeCuadraditos);
			setProperty (NombreDelCuadradito, _width, LargoDeCuadraditos);
			setProperty (NombreDelCuadradito, _height, LargoDeCuadraditos);
			ColorDelCuadradito = new Color(NombreDelCuadradito);
			// Los números tomados del binario son los opuestos al cuadradito,
			// ya que los cuadraditos están numerados al revés.
			// Tomando el 1er caracter del binario y borrándolo para que...
			// en la próxima repetición se use el siguiente, se logra eso:
			NroDeColor = Number(DibujoEnBinario.charat(0));
			DibujoEnBinario = DibujoEnBinario.substring(1, DibujoEnBinario.length);
			if (NroDeColor == 0) {
				ColorDelCuadradito.setRGB(0);
			} else {
				ColorDelCuadradito.setRGB(0xFFFFFF);
			}
			// Esto es para modificar con más practicidad el color:
			set (NombreDelCuadro+".ColordeCuadradito"+NroDelCuadraditoaColocar, NroDeColor);
			ColumnaDeCuadradito++;
			if (ColumnaDeCuadradito == CuadraditosPorFila) {
				ColumnaDeCuadradito = 0;
				FilaDeCuadradito++;
			}
			NroDelCuadraditoaColocar--;
		} while (NroDelCuadraditoaColocar > -1);
		NroDelCuadroaColocar++;
		DibujoaMostrar = DibujoaMostrar-Disminucion;
		// trace("DibujoaMostrar: "+DibujoaMostrar);
	} while (NroDelCuadroaColocar < Cuadros);
}
// PorFila es también por columna:
CuadrosPorFila = 2;
// Debido a que en cierto chequeo se asume que...
// si el cuadradito no está en la parte inferior ni...
// superior entonces está en una fila intermedia,
// conviene que CuadraditosPorFila comience siendo >2:
CuadraditosPorFila = 3;

onClipEvent (load) {
	ColorAsociado = 0;
	ColorDelCentro0 = 0xCCCCCC;
	ColorDelCentro1 = 0x999999;
	ColorDelCentro2 = 0x666666;
	ColorDelCentro3 = 0x333333;
}

onClipEvent (load) {
	ColorDelCentro = _parent.ColorDelCentroX;
}

onClipEvent (load) {
	_parent.ColorDelObjetoCentro.setRGB(_parent.ColorDelCentro);
}

on (rollOver) {
	gotoAndStop (2);
}

onClipEvent (load) {
	ColorDelExtremo = new Color(this);
}
onClipEvent (enterFrame) {
	Rojo = random(256);
	Verde = random(256);
	Azul = random(256);
	ColorDelExtremo.setRGB(Rojo*65536+Verde*256+Azul);
}

on (rollOut) {
	gotoAndStop (1);
}
on (press) {
	// El extremo de este botón tendrá el color del centro,
	// y él cambiará a colores random:
	ExColorDelCentro = ColorDelObjetoCentro.getRGB();
	gotoAndStop (3);
}
on (release, releaseOutside) {
	// El centro tendrá el color asociado (de unos cuadraditos):
	ColorDelCentro = _level0.PosiblesColores[_parent.ColorAsociado];
	ColorDelObjetoCentro.setRGB(ColorDelCentro);
	// Si se saltearon colores (es cuando se asigna el 5to...
	// sin haber asignado el 4to, por ej), asignar los intermedios al azar:
	NroDePosibleColoraAsignar = _level0.PosiblesColores.length;
	while (_level0.PosiblesColores.length < _parent.ColorAsociado) {
		ColorElegido = random(16711681);
		_level0.PosiblesColores[NroDePosibleColoraAsignar] = ColorElegido;
		// A continuación se modificará la variable que muestra...
		// el color, que existe porque el contenido de un array...
		// no se puede mostrar directamente. Se le agregarán "0s"...
		// si tiene menos de lo debido:
		ColoraAsignar = ColorElegido.toString(16).toUpperCase();
		while (ColoraAsignar.length < 6) {
			ColoraAsignar = "0"+ColoraAsignar;
		}
		set("_level0.ShowerDePosibleColor"+NroDePosibleColoraAsignar, ColoraAsignar);
		NroDePosibleColoraAsignar++;
	}
	// El color asociado de los posibles colores de los cuadraditos...
	// tendrá el color del extremo:
	_level0.PosiblesColores[_parent.ColorAsociado] = ColorDelExtremo.getRGB();
	// A continuación se modificará la variable que muestra...
	// el color, que existe porque el contenido de un array...
	// no se puede mostrar directamente. Se le agregarán "0s"...
	// si tiene menos de lo debido:
	ColoraAsignar = ColorDelExtremo.getRGB().toString(16).toUpperCase();
	while (ColoraAsignar.length < 6) {
		ColoraAsignar = "0"+ColoraAsignar;
	}
	set("_level0.ShowerDePosibleColor"+_parent.ColorAsociado, ColoraAsignar);
	_level0.InsertarCuadros();
	gotoAndStop (1);
}

onClipEvent (load) {
	ColorDeEsto = new Color(this);
}
onClipEvent (enterFrame) {
	Rojo = random(256);
	Verde = random(256);
	Azul = random(256);
	ColorDeEsto.setRGB(Rojo*65536+Verde*256+Azul);
}

// El centro tendrá el color asociado (de unos cuadraditos):
ColorDelCentro = _level0.PosiblesColores[_parent.ColorAsociado];
ColorDelObjetoCentro.setRGB(ColorDelCentro);

// Si se saltearon colores (es cuando se asigna el 5to...
// sin haber asignado el 4to, por ej), asignar los intermedios al azar:
NroDePosibleColoraAsignar = _level0.PosiblesColores.length;
while (_level0.PosiblesColores.length < _parent.ColorAsociado) {
	ColorElegido = random(16711681);
	_level0.PosiblesColores[NroDePosibleColoraAsignar] = ColorElegido;
	// A continuación se modificará la variable que muestra...
	// el color, que existe porque el contenido de un array...
	// no se puede mostrar directamente. Se le agregarán "0s"...
	// si tiene menos de lo debido:
	ColoraAsignar = ColorElegido.toString(16).toUpperCase();
	while (ColoraAsignar.length < 6) {
		ColoraAsignar = "0"+ColoraAsignar;
	}
	set("_level0.ShowerDePosibleColor"+NroDePosibleColoraAsignar, ColoraAsignar);
	NroDePosibleColoraAsignar++;
}

// El color asociado de los posibles colores de los cuadraditos...
// tendrá el color del extremo:
_level0.PosiblesColores[_parent.ColorAsociado] = ColorDelExtremo.getRGB();
// A continuación se modificará la variable que muestra...
// el color, que existe porque el contenido de un array...
// no se puede mostrar directamente. Se le agregarán "0s"...
// si tiene menos de lo debido:
ColoraAsignar = ColorDelExtremo.getRGB().toString(16).toUpperCase();
while (ColoraAsignar.length < 6) {
	ColoraAsignar = "0"+ColoraAsignar;
}
set("_level0.ShowerDePosibleColor"+_parent.ColorAsociado, ColoraAsignar);

_level0.InsertarCuadros();
gotoAndStop (1);

CasillerosPorFila = 9;
JuntosRequeridos = 3;
MarcadorDeX = "Humano";
MarcadorDe0 = "IA";
Jugadores = "HumanoIA";
// Usado en el botón de quién marca con X:
function CambiarMarcadorDeX () {
	if (MarcadorDeX == "Humano") {
		MarcadorDeX = "IA";
	} else {
		MarcadorDeX = "Humano";
	}
	Jugadores = MarcadorDeX+MarcadorDe0;
	HacerTablero();
}
// Usado en el botón de quién marca con 0:
function CambiarMarcadorDe0 () {
	if (MarcadorDe0 == "IA") {
		MarcadorDe0 = "Humano";
	} else {
		MarcadorDe0 = "IA";
	}
	Jugadores = MarcadorDeX+MarcadorDe0;
	HacerTablero();
}
// Usado ahora y en general cuando se cambia la configuración de la partida:
function HacerTablero () {
	// Esto se irá especificando en el próximo while:
	Situacion = [];
	PosiblesAcciones = [];
	// Los casilleros se cuentan desde 0:
	MaxCasillero = CasillerosPorFila*CasillerosPorFila-1;
	// Las columnas también. Esto es para no repetir restas por ahí:
	MaxColumna = CasillerosPorFila-1;
	LargoDeCasilleros = 384/CasillerosPorFila;
	NroDeCasilleroaColocar = -1;
	// Sus columnas y filas se cuentan desde 0,
	// sirven para posicionarlos más fácil:
	Columna = 0;
	Fila = 0;
	do {
		NroDeCasilleroaColocar++;
		// v es vacío:
		Situacion.push("v");
		PosiblesAcciones.push(NroDeCasilleroaColocar);
		CasilleroaColocar = "Casillero"+NroDeCasilleroaColocar;
		// set ("SignoEn"+CasilleroaColocar, "v");
		// sCasillero tiene código:
		attachMovie("sCasillero", CasilleroaColocar, NroDeCasilleroaColocar);
		setProperty (CasilleroaColocar, _x, LargoDeCasilleros*Columna);
		setProperty (CasilleroaColocar, _y, LargoDeCasilleros*Fila);
		setProperty (CasilleroaColocar, _width, LargoDeCasilleros);
		setProperty (CasilleroaColocar, _height, LargoDeCasilleros);
		Columna++;
		if (Columna == CasillerosPorFila) {
			Columna = 0;
			Fila++;
		}
		// Para que al presionar el botón se sepa qué modificar:
		set (CasilleroaColocar+".CasilleroAsociado", NroDeCasilleroaColocar);
		// trace("Colocado el "+NroDeCasilleroaColocar);
	} while (NroDeCasilleroaColocar < MaxCasillero);
	// Para que no muestre el mensaje de victoria:
	Win = "No";
	// Esto es para evitar restas:
	LastNroDeAcccionPosible = PosiblesAcciones.length-1;
	trace ("LastNroDeAcccionPosible: "+LastNroDeAcccionPosible);
	SignoDeTurno = "X";
	if (Jugadores == "HumanoIA") {
		gotoAndStop(2);
	} else if (Jugadores == "IAHumano") {
		TurnoDeIA();
		if (Win == "No") {
// OJO QUE SI HAY EMPATE NO DEBE IR AL F2, O NO ES NEC
			gotoAndStop(2);
		}
	} else if (Jugadores == "HumanoHumano") {
		gotoAndStop(2);
	} else {
		// IA VS IA:
		InutilizarBotones();
		gotoAndStop(3);
	}
}
HacerTablero();
// Usada cuando el humano marca en un casillero:
function HumanoHaMarcado () {
	// trace("PosiblesAcciones.length: "+PosiblesAcciones.length);
	// trace("Humano ha marcado");
	// Inutilizar botón del casillero marcado:
	setProperty (eval("Casillero"+CasilleroMarcado+".Boton"), _visible, false);
	// Agregar signo:
	// SignosColocados++;
	eval("Casillero"+CasilleroMarcado).attachMovie("s"+SignoDeTurno, "Signo", 1);
	Situacion[CasilleroMarcado] = SignoDeTurno;
	// set ("SignoEnCasillero"+CasilleroMarcado, "X");
	// ¿Gana?
	// Si esta función dice que no, usa otras:
	ChequearVertical();
	if (Win == "Sí") {
		// Sí, inutilizar botones del tablero
		// (debería ser sólo los activos):
		InutilizarBotones();
		// Mostrar mensaje de victoria:
		attachMovie("sGano"+SignoDeTurno, "Mensaje", NroDeCasilleroaColocar+1);
		UbicarMensaje();
	} else if (PosiblesAcciones.length>=2) {
		// Sino, si aún hay >=2 acciones posibles
		// (la que usó aún no se quitó):
		// Quitar su acción de las posibles acciones:
		// Se busca en qué posición del array está:
		AccionRevisandose = -1;
		// Condición original: AccionRevisandose < LastNroDeAcccionPosible
		do {
			AccionRevisandose++;
			if (PosiblesAcciones[AccionRevisandose] == CasilleroMarcado) {
				// Se elimina la acción de la lista de posibles:
				PosiblesAcciones.splice(AccionRevisandose, 1);
				trace (PosiblesAcciones.join(""));
				break;
			}
		} while (true);
		LastNroDeAcccionPosible--;
		trace ("LastNroDeAcccionPosible disminuyó: "+LastNroDeAcccionPosible);
		// trace("PosiblesAcciones.length: "+PosiblesAcciones.length);
		CambiarSigno();
		if (Jugadores == "HumanoIA" or Jugadores == "IAHumano") {
			TurnoDeIA();
		}
	} else {
		// (sólo queda 1 acción en la lista,
		// pero es la que acaba de usar,
		// que debe borrarse, así que no quedan)
		trace ("Empate luego de que marcó el humano");
		// trace("PosiblesAcciones.length: "+PosiblesAcciones.length);
		Empate();
	}
}
// Usada en ChequeoHorizontal y requerida en otros chequeos:
function ObtenerColumnayFilaDelMarcado () {
	ColumnaDelMarcado = CasilleroMarcado%CasillerosPorFila;
	// trace ("Su Columna según el cálculo es: "+ColumnaDelMarcado);
	FilaDelMarcado = Math.floor(CasilleroMarcado/CasillerosPorFila);
	// trace ("Su Fila: "+FilaDelMarcado);
}
// Usada cuando alguien gana o en HacerTablero si es IA VS IA:
function InutilizarBotones () {
	BotonesInutilizados = -1;
	do {
		BotonesInutilizados++;
		setProperty ("Casillero"+BotonesInutilizados+".Boton", _visible, false);
	} while (BotonesInutilizados<MaxCasillero);
}
// Usada cuando hay que ubicar un mensaje, duh:
function UbicarMensaje () {
	setProperty (Mensaje, _x, 192.4);
	setProperty (Mensaje, _y, 192);
	// gotoAndStop (3);
}
// En caso de empate:
function Empate () {
	attachMovie("sEmpate", "Mensaje", NroDeCasilleroaColocar+1);
	UbicarMensaje();
	// Para que en el modo IA VS IA, la IA no juegue más:
	Win = "Sí";
	trace("Empate");
}
function CambiarSigno () {
	if (SignoDeTurno == "X") {
		SignoDeTurno = 0;
	} else {
		SignoDeTurno = "X";
	}
}
function TurnoDeIA () {
	// Elegir una acción al azar:
	NroDeAccionElegida = random(PosiblesAcciones.length);
	AccionElegida = PosiblesAcciones[NroDeAccionElegida];
	trace ("IA ha marcado: "+AccionElegida);
	// Eliminar la que está en el nro elegido:
	PosiblesAcciones.splice(NroDeAccionElegida, 1);
	trace (PosiblesAcciones.join(""));
	LastNroDeAcccionPosible--;
	trace ("LastNroDeAcccionPosible disminuyó: "+LastNroDeAcccionPosible);
	eval("Casillero"+AccionElegida).attachMovie("s"+SignoDeTurno, "Signo", 0);
	Situacion[AccionElegida] = SignoDeTurno;
	// Inutilizar el botón de ahí:
	setProperty (eval("Casillero"+AccionElegida+".Boton"), _visible, false);
	// Ver si IA ganó:
	CasilleroMarcado = AccionElegida;
	// trace ("JuntosRequeridos: "+JuntosRequeridos);
	ChequearVertical();
	// trace("PosiblesAcciones.length: "+PosiblesAcciones.length);
	if (Win == "Sí") {
		// Sí, inutilizar botones del tablero
		// (debería ser sólo los activos):
		InutilizarBotones();
		// Mostrar mensaje de victoria:
		attachMovie("sGano"+SignoDeTurno, "Mensaje", NroDeCasilleroaColocar+1);
		UbicarMensaje ();
	} else if (PosiblesAcciones.length == 0) {
		trace ("Empate luego de que marcó la IA");
		// trace("PosiblesAcciones.length: "+PosiblesAcciones.length);
		Empate();
	} else {
		CambiarSigno();
	}
}

on (release) {
	_level0.CasilleroMarcado = _parent.CasilleroAsociado;
	_level0.HumanoHaMarcado();
}

onClipEvent (enterFrame) {
	trace("SignoDeTurno: "+_level0.SignoDeTurno);
	_level0.TurnoDeIA();
	trace("Win: "+_level0.Win);
	if (_level0.Win == "No") {
		trace("SignoDeTurno: "+_level0.SignoDeTurno);
		_level0.TurnoDeIA();
		trace("Win: "+_level0.Win);
	}
	trace("Win: "+_level0.Win);
	// No va un else, esto es que si la IA ganó en su 1er turno o...
	// en su 2ndo, frana:
	if (_level0.Win == "Sí") {
		trace("Va al frame 2");
		_root.gotoAndStop (2);
	}
}

// Signos en línea en tablero de Lado*Lado:
// Este programa tiene básicamente 2 etapas,
// que se pueden resumir así:
// 1:
// Desde la situación inicial probar las acciones,
// guardando las situaciones nuevas,
// y probando acciones en ellas también.
// Guardar las situación-acción que causan una victoria,
// y las que causan un empate. Es el RE de esa situación,
// resultado esperado (porque en otros casos es el que...
// se espera o supone si el rival juega bien).
// 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;
// Los casilleros están numerados así:
// 0 1 2
// 3 4 5
// 6 7 8
Casilleros = CasillerosPorFila*CasillerosPorFila;
MaxCasillero = Casilleros-1;
// Uso arrays porque es más fácil así modificar partes...
// de los valores de variables (los casilleros):
// Situación a experimentar nro 1, signo en los casilleros
// (a este array se le agregarán valores):
SaE1 = [];
ValoraAgregar = -1;
do {
	ValoraAgregar++;
	// v significa vacío
	SaE1.push("v");
	// trace("ValoraAgregar es "+ValoraAgregar);
} while (ValoraAgregar < MaxCasillero);
delete (ValoraAgregar);
// Situaciones a experimentar (cuántas son):
SaE = 1;
NroDeSExperimentandose = 0;
NoEvaluedSaE = "SaE1";
SaEEvaluedyJoined = "S"+(eval(NoEvaluedSaE).join(""));
// Usada para fácilmente saber de qué signo es turno:
set (SaEEvaluedyJoined+"Turno", "X");
// Con LastAPosible, usada para evitar probar...
// acciones innecesarias y saber si sólo queda 1:
set (SaEEvaluedyJoined+"FirstAPosible", 0);
set (SaEEvaluedyJoined+"LastAPosible", MaxCasillero);
// Usada a continuación y en varios casos:
function PrepararExperimentosEnOtraS () {
	// trace("Ejecutando PrepararExperimentosEnOtraS");
	NroDeSExperimentandose++;
	trace("Se inician experimentos en otra situación, la anotada nro "+NroDeSExperimentandose);
	// Usada para evitar concatenar repetidamente:
	NoEvaluedSaE = "SaE"+NroDeSExperimentandose;
	SituacionBase = eval(NoEvaluedSaE);
	SaEEvaluedyJoined = "S"+(SituacionBase.join(""));
	Turno = eval(SaEEvaluedyJoined+"Turno");
	FirstActionPosible = eval(SaEEvaluedyJoined+"FirstAPosible");
	LastActionPosible = eval(SaEEvaluedyJoined+"LastAPosible");
	Action = FirstActionPosible;
}
PrepararExperimentosEnOtraS();
// Usada en frame 2 repetidamente:
function BuscarBuenasSituacionesEt1 () {
	// 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.");
		BuscarAccionEt1();
	}
}
// 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 == "Sí") {
		// Sí, crear datos sobre eso:
		// trace("Ganó, ahora se sabe que en la situación "+SituacionBase+" se gana usando la acción "+Action);
		set (SaEEvaluedyJoined+"BestAction", Action);
		set (SaEEvaluedyJoined+"RE", Turno);
		// Se borra la situación de la lista a experimentar,
		// pues ya se halló la mejor acción en ella:
		BorrarSaE();
		BuscarOtraSituacionEt1();
	} else if (FirstActionPosible == LastActionPosible) {
		// sino si es empate (no hay más acciones posibles):
		// Parecido, crear datos sobre eso:
		// trace("Empató, ahora se sabe que en la situación "+SituacionBase+" se empata usando la acción "+Action);
		// (y es la mejor acción porque no hay otra)
		set (SaEEvaluedyJoined+"BestAction", Action);
		set (SaEEvaluedyJoined+"RE", "Empate");
		// Se borra la situación de la lista a experimentar,
		// pues ya se halló la mejor acción en ella:
		BorrarSaE();
		BuscarOtraSituacionEt1();
	} else {
		EvaluarConocimientoSobreSEt1();
		// ¿Queda alguna acción sin probar...
		// en la situación?
		BuscarAccionEt1();
	}
}
// Usada luego de AplicarAccionEt1,
// si causa victoria o empate:
function BorrarSaE () {
	// La última SaE ponerla en la actual:
	// trace("ATENCIÓN: "+NoEvaluedSaE+", que es "+SaEEvaluedyJoined);
	set (NoEvaluedSaE, eval("SaE"+SaE).slice());
	// trace("...ahora es: "+eval(NoEvaluedSaE));
	// Borrar la última:
	delete (eval("SaE"+SaE));
	// Indicar que hay una menos:
	SaE--;
	// También se borran datos prácticos que ya no se usarán:
	// trace("SaEEvaluedyJoined: "+SaEEvaluedyJoined);
	// trace("SaEEvaluedyJoined+Turno: "+eval(SaEEvaluedyJoined+"Turno"));
	delete (eval(SaEEvaluedyJoined+"Turno"));
	// trace("SaEEvaluedyJoined+Turno: "+eval(SaEEvaluedyJoined+"Turno"));
	delete (eval(SaEEvaluedyJoined+"FirstAPosible"));
	delete (eval(SaEEvaluedyJoined+"LastAPosible"));
	// Indicar que vuelva a invertigarse la del número actual,
	// pues ahora es otra:
	NroDeSExperimentandose--;
}
// Usada luego de EvaluarAplicabilidadEt1,
// cuando una acción no es realizable:
function BuscarAccionEt1 () {
	// trace("Ejecutando BuscarAccionEt1");
	if (Action < LastActionPosible) {
		// Si queda alguna acción sin probar...
		// en la situación, probarla:
		Action++;
		// Se ejecutará BuscarBuenasSituaciones.
	} else {
		// trace("No hay más acciones realizables.");
		BuscarOtraSituacionEt1();
	}
}
// Usada luego de que hay victoria, empate o si no hay más acciones posibles:
function BuscarOtraSituacionEt1 () {
	// trace("Ejecutando BuscarOtraSituacionEt1");
	if (SaE > NroDeSExperimentandose) {
		PrepararExperimentosEnOtraS();
	} else {
		trace(	"No hay más situaciones a experimentar; inicia la etapa 2.");
		// IniciarEtapa2();
		gotoAndStop(4);
	}
}
// Usada en AplicarAccionEt1 cuando no hay victoria ni empate:
function EvaluarConocimientoSobreSEt1 () {
	// trace("Ejecutando EvaluarConocimientoSobreSEt1");
	SituacionJoined = Situacion.join("");
	NombreDeSituacion = "S"+SituacionJoined;
	ResumenDeBest = NombreDeSituacion+"BestAction";
	// ¿Se ha llegado antes a la situación?
	if (eval(ResumenDeBest) == undefined) {
		// No, anotar que debe investigarse:
		SaE++;
		// Copiar array (porque no se puede normalmente):
		set ("SaE"+SaE, Situacion.slice());
		// trace("Esa situación no está anotada; se anota como nro "+SaE);
		set(ResumenDeBest, "Desconocida");
		if (Turno == "X") {
			set (NombreDeSituacion+"Turno", "0");
		} else {
			set (NombreDeSituacion+"Turno", "X");
		}
		// Averiguar cual es su 1er acción posible:
		AccionRevisandose = -1;
		do {
			AccionRevisandose++;
			if (Situacion[AccionRevisandose] == "v") {
				set (NombreDeSituacion+"FirstAPosible", AccionRevisandose);
				break;
			}
		} while (true);
		// Averiguar cual es su última acción posible:
		AccionRevisandose = Casilleros;
		do {
			AccionRevisandose--;
			if (Situacion[AccionRevisandose] == "v") {
				set (NombreDeSituacion+"LastAPosible", AccionRevisandose);
				break;
			}
		} while (true);
	}
}
function ObtenerColumnayFilaDelMarcado () {
	FilaDelMarcado = Math.floor(Action/CasillerosPorFila);
	ColumnaDelMarcado = Action%CasillerosPorFila;
}
function ChequearVertical () {
	// trace ("Ejecutando ChequearVertical");
	// 
	// SOLO FUNCIONA SI CasillerosPorFila >= JuntosRequeridos.
	// 
	// Se revisará la vertical. Desde el casillero más arriba...
	// que pueda estar incluído en la línea,
	// hasta el casillero marcado. Si se haya alguno que no...
	// tenga la marca requerida, se repite el proceso mirando...
	// desde uno más abajo del fallado, y mirando ahora hasta...
	// más abajo, según corresponda:
	Desde = Action-CasillerosPorFila*(JuntosRequeridos-1);
	// Mientras el casillero no exista:
	while (Desde<0) {
		// trace ("Desde es "+Desde+", se aumentará");
		// Indicar que se empiece a mirar desde más abajo:
		Desde = Desde+CasillerosPorFila;
	}
	do {
		Hasta = Desde+CasillerosPorFila*(JuntosRequeridos-1);
		if (Hasta>MaxCasillero) {
			// Para ganar se necesitaría más casilleros hacia...
			// abajo de los que hay, terminar análisis:
			// trace ("No hay suficientes cuadraditos abajo");
			break;
		}
		Puntero = Desde;
		// trace ("Comenzando chequeo desde "+Desde+" hasta "+Hasta);
		// Puede cambiar:
		Win = "Sí";
		do {
			// trace ("Chequando el casillero "+Puntero);
			if (Situacion[Action] != Situacion[Puntero]) {
				Win = "No";
				Desde = Puntero+CasillerosPorFila;
				break;
			}
			Puntero = Puntero+CasillerosPorFila;
		} while (Puntero<=Hasta);
	} while (Desde<=Action && Win == "No");
	if (Win == "No") {
		ChequearHorizontal();
	}
}
function ChequearHorizontal () {
	// trace ("Ejecutando ChequearHorizontal");
	// Es similar al chequeo vertical, pero aquí no sirve...
	// sumar o restar a un puntero que marque el casillero...
	// porque puede existir ese casillero pero no estar en...
	// un costado. En vez de eso, se obtiene su columna y...
	// fila, se modifica la columna si es posible,
	// y se calcula cual es el casillero a mirar:
	ObtenerColumnayFilaDelMarcado();
	DesdeColumna = ColumnaDelMarcado-JuntosRequeridos+1;
	// Para que no mire cuadraditos inexistentes en la izq:
	if (DesdeColumna<0) {
		DesdeColumna = 0;
	}
	do {
		HastaColumna = DesdeColumna+JuntosRequeridos-1;
		if (HastaColumna>MaxColumna) {
			// Para ganar se necesitaría más casilleros hacia...
			// la derecha de los que hay, terminar análisis:
			// trace ("No hay suficientes cuadraditos a la derecha");
			break;
		}
		Puntero = DesdeColumna;
		// trace ("Comenzando chequeo desde "+DesdeColumna+" hasta "+HastaColumna);
		// Puede cambiar:
		Win = "Sí";
		do {
			CasilleroaMirar = FilaDelMarcado*CasillerosPorFila+Puntero;
			// trace ("Chequando el casillero "+CasilleroaMirar);
			if (Situacion[Action] != Situacion[CasilleroaMirar]) {
				Win = "No";
				DesdeColumna = Puntero+1;
				break;
			}
			Puntero++;
		} while (Puntero<=HastaColumna);
	} while (DesdeColumna<=ColumnaDelMarcado && Win == "No");
	if (Win == "No") {
		ChequearDesdeUpIzq();
	}
}
// La diagonal así \
function ChequearDesdeUpIzq () {
	// trace ("Ejecutando ChequearDesdeUpIzq");
	DesdeColumna = ColumnaDelMarcado-JuntosRequeridos+1;
	// trace("DesdeColumna: "+DesdeColumna);
	DesdeFila = FilaDelMarcado-JuntosRequeridos+1;
	// trace("DesdeFila: "+DesdeFila);
	// Para que no mire cuadraditos inexistentes:
	if (DesdeColumna<DesdeFila) {
		Sumar = DesdeColumna;
	} else {
		Sumar = DesdeFila;
	}
	// trace("Sumar: "+Sumar);
	if (Sumar<0) {
		// trace("Sumando.");
		DesdeColumna = DesdeColumna-Sumar;
		// trace("DesdeColumna: "+DesdeColumna);
		DesdeFila = DesdeFila-Sumar;
		// trace("DesdeFila: "+DesdeFila);
	}
	do {
		HastaColumna = DesdeColumna+JuntosRequeridos-1;
		if (HastaColumna>MaxColumna) {
			// Para ganar se necesitaría más casilleros hacia...
			// la derecha de los que hay, terminar análisis:
			// trace ("No hay suficientes cuadraditos a la derecha");
			break;
		}
		HastaFila = DesdeFila+JuntosRequeridos-1;
		// Sirve usar MaxColumna en vez de crear MaxFila...
		// porque como el tablero es cuadrado serían iguales:
		if (HastaFila>MaxColumna) {
			// Para ganar se necesitaría más casilleros hacia...
			// abajo de los que hay, terminar análisis:
			// trace ("No hay suficientes cuadraditos abajo");
			break;
		}
		PunteroDeColumna = DesdeColumna;
		PunteroDeFila = DesdeFila;
		// trace ("Comenzando chequeo desde columna "+DesdeColumna+" y fila "+DesdeFila);
		// trace ("hasta columna "+HastaColumna+" y fila "+HastaFila);
		// Puede cambiar:
		Win = "Sí";
		do {
			CasilleroaMirar = PunteroDeFila*CasillerosPorFila+PunteroDeColumna;
			// trace ("Chequando el casillero "+CasilleroaMirar);
			if (Situacion[Action] != Situacion[CasilleroaMirar]) {
				Win = "No";
				DesdeColumna = PunteroDeColumna+1;
				DesdeFila = PunteroDeFila+1;
				break;
			}
			PunteroDeColumna++;
			PunteroDeFila++;
		} while (PunteroDeColumna<=HastaColumna);
	} while (DesdeColumna<=ColumnaDelMarcado && Win == "No");
	if (Win == "No") {
		ChequearDesdeDownIzq();
	}
}
// La diagonal así /
function ChequearDesdeDownIzq () {
	// trace ("Ejecutando ChequearDesdeDownIzq");
	DesdeColumna = ColumnaDelMarcado-JuntosRequeridos+1;
	// trace("DesdeColumna: "+DesdeColumna);
	DesdeFila = FilaDelMarcado+JuntosRequeridos-1;
	// trace("DesdeFila: "+DesdeFila);
	// Para que no mire cuadraditos inexistentes:
	ColumnasInexistentes = 0;
	if (DesdeColumna<0) {
		ColumnasInexistentes = DesdeColumna*-1;
	}
	FilasInexistentes = 0;
	// Está bien usar MaxColumna porque MaxFila sería igual:
	if (DesdeFila>MaxColumna) {
		FilasInexistentes = DesdeFila-MaxColumna;
	}
	if (ColumnasInexistentes>=FilasInexistentes) {
		Ajuste = ColumnasInexistentes;
	} else {
		Ajuste = FilasInexistentes;
	}
	// trace("Ajuste: "+Ajuste);
	if (Ajuste>0) {
		// trace("Ajustando.");
		DesdeColumna = DesdeColumna+Ajuste;
		// trace("DesdeColumna: "+DesdeColumna);
		DesdeFila = DesdeFila-Ajuste;
		// trace("DesdeFila: "+DesdeFila);
	}
	do {
		HastaColumna = DesdeColumna+JuntosRequeridos-1;
		if (HastaColumna>MaxColumna) {
			// Para ganar se necesitaría más casilleros hacia...
			// la derecha de los que hay, terminar análisis:
			// trace ("No hay suficientes cuadraditos a la derecha");
			break;
		}
		HastaFila = DesdeFila-JuntosRequeridos+1;
		if (HastaFila<0) {
			// Para ganar se necesitaría más casilleros hacia...
			// arriba de los que hay, terminar análisis:
			// trace ("No hay suficientes cuadraditos arriba");
			break;
		}
		PunteroDeColumna = DesdeColumna;
		PunteroDeFila = DesdeFila;
		// trace ("Comenzando chequeo desde columna "+DesdeColumna+" y fila "+DesdeFila);
		// trace ("hasta columna "+HastaColumna+" y fila "+HastaFila);
		// Puede cambiar:
		Win = "Sí";
		do {
			CasilleroaMirar = PunteroDeFila*CasillerosPorFila+PunteroDeColumna;
			// trace ("Chequando el casillero "+CasilleroaMirar);
			if (Situacion[Action] != Situacion[CasilleroaMirar]) {
				Win = "No";
				DesdeColumna = PunteroDeColumna+1;
				DesdeFila = PunteroDeFila-1;
				break;
			}
			PunteroDeColumna++;
			PunteroDeFila--;
		} while (PunteroDeColumna<=HastaColumna);
	} while (DesdeColumna<=ColumnaDelMarcado && Win == "No");
	// trace("Win: "+Win);
}