Repetir
	Si se puede variar
		VariaciónConChequeoNormal
		Si se capta simetría
			repetir pero VariaciónConChequeoExtra
		sino
			repetir normalmente
	sino
		despintar
mientras no se capte un dibujo ok

Repetir
	Si se puede variar
		Si no se captó simetría
			VariaciónConChequeoNormal
		sino
			VariaciónConChequeoExtra
		fin del si
		Si se capta simetría
			Marcar que se detectó simetría y repetir
		sino
			Marcar que no se detectó simetría y repetir
	sino
		despintar
mientras no se capte un dibujo ok

Si no se captó simetría
	VariaciónConChequeoNormal
sino
	VariaciónConChequeoExtra
fin del si

// En este programa hay cuadraditos nombrados así:
// 123
// 456
// 789
// Se irán pintando diferentes combinaciones y...
// su tamaño se reducirá a medida que...
// la cantidad por fila y columna aumente.
// Para que un dibujo se muestre...
// debe tener algún cuadradito pintado en cada columna y fila,
// no debe haber muchos pintados aislados,
// no debe ser simétrico (espejo vertical | ) a alguno ya mostrado,
// y no debe tener demasiados cuadraditos despintados
// (contando desde el MinPintado).
// Ver frame 2 por más información.
// 
// CuadraditosPorFila es también porColumna.
// 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 >1;
// aumenta 1 antes de aplicarse:
CuadraditosPorFila = 2;
// Usada en Variar:
function ObtenerColumnayFila () {
	Fila = Math.ceil(Puntero/CuadraditosPorFila);
	// trace ("Su Fila según el cálculo es: "+Fila);
	Columna = (Puntero-1)%CuadraditosPorFila+1;
	// trace ("Su Columna: "+Columna);
	// Esto se usa para evitar repeticiones...
	// de concatenaciones y simplificarlas:
	ColumnaRelevante = "PintadosenC"+Columna;
	FilaRelevante = "PintadosenF"+Fila;
}
// Usada en ParteDeContarEtc:
function PosibleIncrementoDeContiguosPintados () {
	// ¿El contiguo indicado está pintado?
	if (eval("Cuadradito"+Fila3+"_"+Columna3) == 0) {
		// Sí, aumentar contador:
		ContiguosPintados++;
		// trace ("De ese contiguo ("+Fila2+"_"+Columna2+"), su contiguo "+Fila3+"_"+Columna3+" está pintado; por ahora se vió que tiene "+ContiguosPintados+" contiguos pintados.");
	}
}
// Usada en ContarContiguosDeContiguoAlNewPintado y ContarContiguosDeContiguoAlNewDespintado:
function ParteDeContarEtc () {
	ContiguosPintados = 0;
	// trace("Analizando su inferior derecho.");
	Fila3 = Fila2+1;
	Columna3 = Columna2+1;
	PosibleIncrementoDeContiguosPintados();
	// trace("Analizando su inferior.");
	Columna3--;
	PosibleIncrementoDeContiguosPintados();
	// trace("Analizando su inferior izquierdo.");
	Columna3--;
	PosibleIncrementoDeContiguosPintados();
	// trace("Analizando su derecho.");
	Columna3 = Columna3+2;
	Fila3--;
	PosibleIncrementoDeContiguosPintados();
	// trace("Analizando su izquierdo.");
	Columna3 = Columna3-2;
	PosibleIncrementoDeContiguosPintados();
	// trace("Analizando su superior derecho.");
	Columna3 = Columna3+2;
	Fila3--;
	PosibleIncrementoDeContiguosPintados();
	// trace("Analizando su superior.");
	Columna3--;
	PosibleIncrementoDeContiguosPintados();
	// trace("Analizando su superior izquierdo.");
	Columna3--;
	PosibleIncrementoDeContiguosPintados();
}
// Usada en Variar:
function ContarContiguosDeContiguoAlNewPintado () {
	// ¿El contiguo indicado está pintado?
	// trace ("Analizando Cuadradito"+Fila2+"_"+Columna2+": "+eval("Cuadradito"+Fila2+"_"+Columna2));
	if (eval("Cuadradito"+Fila2+"_"+Columna2) == 0) {
		// Sí, el recién pintado no está aislado:
		ElRecienPintadoEstaAislado = "No";
		// trace ("Está pintado; el recién pintado no está aislado.");
		// Se contarán los contiguos de este (contiguo al recién...).
		ParteDeContarEtc();
		// trace ("Ese contiguo ("+Fila2+"_"+Columna2+") al recién pintado tiene "+ContiguosPintados+" contiguos pintados.");
		// ¿Estaba aislado?
		if (ContiguosPintados == 1) {
			// Sí, reducir el contador:
			CuadraditosAislados--;
			// trace ("El contiguo al recién pintado sólo tiene 1 contiguo pintado, estaba aislado, ahora hay "+CuadraditosAislados+" aislados.");
		}
	} else {
		// trace ("No está pintado.");
	}
}
// Usada en Variar:
function ContarContiguosDeContiguoAlNewDespintado () {
	// ¿El contiguo indicado está pintado?
	// trace ("Analizando Cuadradito"+Fila2+"_"+Columna2+": "+eval("Cuadradito"+Fila2+"_"+Columna2));
	if (eval("Cuadradito"+Fila2+"_"+Columna2) == 0) {
		// Sí, el recién despintado no estaba aislado:
		ElRecienDespintadoEstabaAislado = "No";
		// trace ("Está pintado; el recién despintado no estaba aislado.");
		// Se contarán los contiguos de este (contiguo al recién...).
		ParteDeContarEtc();
		// trace ("Ese contiguo ("+Fila2+"_"+Columna2+") al recién despintado tiene "+ContiguosPintados+" contiguos pintados.");
		// ¿Está aislado?
		if (ContiguosPintados == 0) {
			// Sí, aumentar el contador:
			CuadraditosAislados++;
			// trace ("El contiguo al recién despintado quedó aislado, ahora hay "+CuadraditosAislados+" aislados.");
		}
	} else {
		// trace ("No está pintado.");
	}
}
// En F3 se repite:
function Variar () {
	// Repetir mientras no se produzca un dibujo ok:
	do {
		// Esto para modificar la variable que indica el color,
		// que es 0 o 1:
		ReferenciaAlColoraModificar = "ColordeCuadradito"+Puntero;
		ColoraModificar = eval(ReferenciaAlColoraModificar);
		// Esto para el color real:
		NuevoColor = new Color("Cuadradito"+Puntero);
		// ¿El cuadradito puede cambiar de color?
		if (ColoraModificar>0) {
			// Sí, hacer los cambios:
			// En la variable:
			set (ReferenciaAlColoraModificar, ColoraModificar-1);
			// Del color real:
			NuevoColor.setRGB(0);
			// trace ("   Se pintó el cuadradito "+Puntero);
			// Asignarle el color de la 2nda manera:
			ObtenerColumnayFila();
			set ("Cuadradito"+Fila+"_"+Columna, 0);
			// Incrementar contador de cuadraditos pintados en...:
			// la columna y fila donde se pintó:
			set (ColumnaRelevante, eval(ColumnaRelevante)+1);
			set (FilaRelevante, eval(FilaRelevante)+1);
			// Actualizar cantidad de cuadraditos pintados aislados:
			// De cada pintado al lado del recién pintado,
			// se verá si estaba aislado,
			// en cuyo caso disminuirá el contador.
			// Si no hay pintados al lado del nuevo, aumentará.
			// trace ("Se actualizará el contador de pintados aislados:");
			// Esta variable puede cambiar, se refiere al recién pintado:
			ElRecienPintadoEstaAislado = "Sí";
			// Para analizar a su izquierdo:
			Fila2 = Fila;
			Columna2 = Columna-1;
			// Si su izquierdo existe y está pintado,
			// entonces el actual no está aislado,
			// y se mira si el izquierdo de ese estaba aislado:
			// Cuántos de sus contiguos están pintados.
			// Si la cantidad es 1, estaba aislado,
			// el contador de Aislados baja.
			// Debido a que al pintar un cuadradito...
			// los de abajo y el de la derecha estarán despintados,
			// sólo se miran el de la izquierda y los de arriba:
			ContarContiguosDeContiguoAlNewPintado();
			// Para analizar a su izquierdo de arriba:
			Fila2--;
			ContarContiguosDeContiguoAlNewPintado();
			// Para analizar al de arriba:
			Columna2++;
			ContarContiguosDeContiguoAlNewPintado();
			// Para analizar a su derecho de arriba:
			Columna2++;
			ContarContiguosDeContiguoAlNewPintado();
			if (ElRecienPintadoEstaAislado == "Sí") {
				// trace("El recién pintado está aislado");
				CuadraditosAislados++;
			}
			// trace("        El dibujo tiene "+CuadraditosAislados+" cuadraditos aislados");
			// Actualizar contador de despintados
			// (contando desde MinPintado)
			CuadraditosDespintados--;
			// Para juzgar:
			// ¿El dibujo tiene cuadraditos pintados en toda columna y fila?
			Puntero2 = 0;
			// Esto puede que cambie:
			CuadraditoenCadaFyC = "Sí";
			do {
				Puntero2 = Puntero2+1;
				// ¿La columna Puntero2 no tiene algún cuadradito pintado?
				if (eval("PintadosenC"+Puntero2)<1) {
					CuadraditoenCadaFyC = "No";
				} else if (eval("PintadosenF"+Puntero2)<1) {
					// La fila Puntero2 no tiene algún cuadradito pintado.
					CuadraditoenCadaFyC = "No";
				}
			} while (CuadraditoenCadaFyC == "Sí" && Puntero2<CuadraditosPorFila);
			// ¿El dibujo tiene cuadraditos pintados en toda columna y fila?
			if (CuadraditoenCadaFyC == "No") {
				// No, no mostrarlo y hacer otro:
				// trace ("    No ocupa cada F y C, salteándolo.");
				DibujosPequeños++;
				// Actualizar MinCuadraditoPintado si corresponde:
				if (Puntero<MinCuadraditoPintado) {
					MinCuadraditoPintado = Puntero;
					// trace(Puntero);
					// Como ahora se cuenta un cuadradito extra,
					// que estaba despintado, el contador aumenta:
					CuadraditosDespintados++;
					// Si se llegó al punto en que los dibujos...
					// pueden ser simétricos a unos ya hechos:
					if (Puntero<CuadraditoCentraloCD) {
						// En el próximo dibujo se pintará el superior derecho:
						Puntero = CuadraditosPorFila;
					} else {
						// Preparar Puntero para generar el próximo dibujo:
						Puntero = MaxPosiciondePuntero;
					}
				} else {
					// Preparar Puntero para generar el próximo dibujo:
					Puntero = MaxPosiciondePuntero;
				}
			} else if (CuadraditosAislados>MaxCuadraditosAislados) {
				// trace ("    Tiene demasiados cuadraditos pintados aislados: "+CuadraditosAislados+" salteándolo.");
				DibujosAislados++;
				// Preparar Puntero para generar el próximo dibujo:
				Puntero = MaxPosiciondePuntero;
			} else if (MinCuadraditoPintado<CuadraditoCentraloCD) {
				// El dibujo puede ser simétrico...
				// a otro ya mostrado. ¿Lo es?
				// Esto puede cambiar:
				DibujoEsSimetrico = "No";
				// Captar valor (colores) de cada fila;
				// si alguno es menor al inverso, sí:
				PunteroDeFilas = 0;
				do {
					PunteroDeFilas++;
					PunteroDeColumnas = 0;
					PunteroInverso = CuadraditosPorFila;
					do {
						PunteroDeColumnas++;
						Valor = eval("Cuadradito"+PunteroDeFilas+"_"+PunteroDeColumnas);
						ValorInverso = eval("Cuadradito"+PunteroDeFilas+"_"+PunteroInverso);
						// trace("Valor: "+Valor);
						// trace("ValorInverso: "+ValorInverso);
						if (Valor<ValorInverso) {
							DibujoEsSimetrico = "Sí";
							FilaFallada = PunteroDeFilas;
							PunteroDeFilas = CuadraditosPorFila;
							break;
						} else if (Valor>ValorInverso) {
							// Es ok:
							PunteroDeFilas = CuadraditosPorFila;
							break;
						}
						PunteroInverso--;
					} while (PunteroDeColumnas<CuadraditosPorFila);
				} while (PunteroDeFilas<CuadraditosPorFila);
				// Este if es probablemente innecesario,
				// porque se supone que el dibujo será simétrico u ok,
				// antes de que se terminen de comparar todas las filas.
				if (DibujoEsSimetrico == "Sí") {
					// trace ("  El dibujo es simétrico a otro ya mostrado.");
					DibujosSimetricos++;
					// Al Puntero ponerlo al final de la fila...
					// captada como simétrica, para posiblemente...
					// evitar algunos otros dibujos simétricos:
					Puntero = CuadraditosPorFila*FilaFallada;
				} else if (CuadraditosDespintados<MinCuadraditosDespintados) {
					trace ("  El dibujo tiene demasiados cuadraditos despintados: "+CuadraditosDespintados);
					DibujosDensos++;
					// Preparar Puntero para generar el próximo dibujo:
					Puntero = MaxPosiciondePuntero;
				} else {
					DibujosOk++;
					// trace ("  Mostrando dibujo nro: "+DibujosOk);
					// Preparar Puntero para generar el próximo dibujo:
					Puntero = MaxPosiciondePuntero;
					play ();
					break;
				}
			} else if (CuadraditosDespintados<MinCuadraditosDespintados) {
				trace ("  El dibujo tiene demasiados cuadraditos despintados: "+CuadraditosDespintados);
				DibujosDensos++;
				// Preparar Puntero para generar el próximo dibujo:
				Puntero = MaxPosiciondePuntero;
			} else {
				DibujosOk++;
				// trace ("  Mostrando dibujo nro: "+DibujosOk);
				// Preparar Puntero para generar el próximo dibujo:
				Puntero = MaxPosiciondePuntero;
				play ();
				break;
			}
		} else {
			// Despintar un cuadradito, no viene al caso.
		}
	} while (true);
}
 

function MoveBarriles () {
	// Empieza desde 2 porque el 1 no existe, porque cada objeto tiene una "profundidad" que determina cual aparece delante/atrás y se basa en el número del barril, para más facilidad, pero el número 1 está reservado para el personaje.
	Moved = 1;
	do {
		Moved++;
		// I es un objeto donde van las imágenes, es útil para eliminarlas todas a la vez, por ejemplo.
		BarrilaMover = "I.Barril"+Moved;
		BarrilSpeed = BarrilaMover+"Speed";
		EvaluedBarrilSpeed = eval(BarrilSpeed);
		// Aplicar rozamiento:
		if (EvaluedBarrilSpeed > 0) {
			EvaluedBarrilSpeed = EvaluedBarrilSpeed/1.0025;
			if (EvaluedBarrilSpeed < 0.05) {
				EvaluedBarrilSpeed = 0;
			}
			set(BarrilSpeed, EvaluedBarrilSpeed);
		}
		setProperty (BarrilaMover, _x, getProperty(BarrilaMover, _x)+EvaluedBarrilSpeed);
		// Resumen:
		Res = BarrilaMover+".Part";
		// El barril no se gira sino que se gira una parte suya, porque como no es redondo no se ve bien cuando se gira. Lo copié de un juego y lo quiero así a pesar de sus defectos.
		setProperty (Res, _rotation, getProperty(Res, _rotation)+EvaluedBarrilSpeed*2);
		// Si tocan al personaje y él se está moviendo:
		if (I.Player.hitTest(eval(BarrilaMover)) == true && I.Player.Action == "Walking") {
			// Game over:
			gotoAndStop (3);
			break;
		} else {
			// Ver si tocó al barril anterior, que está delante:
			BarrilAnterior = "I.Barril"+(Moved-1);
			if (eval(BarrilaMover).hitTest(eval(BarrilAnterior)) == true) {
				// Pasarle la velocidad:
				set(BarrilAnterior+"Speed", eval(BarrilAnterior+"Speed")+EvaluedBarrilSpeed);
				// Quedar sin velocidad:
				set(BarrilSpeed, 0);
			}
		}
	} while (Moved<Barriles);
}

// Barril se movió.
// Si toca al personaje:
if (I.Player.hitTest(eval(BarrilaMover)) == true) {
	// Si él se está moviendo:
	if (I.Player.Action == "Walking") {
		// Game over:
		gotoAndStop (3);
	}

// Barril se movió.
// Si toca al personaje:
if (I.Player.hitTest(eval(BarrilaMover)) == true) {
	// Si él se está moviendo:
	if (I.Player.Action == "Walking") {
		// Game over:
		gotoAndStop (3);
	} else {
		// Ver si toca otro barril.
	}
} else {
	// Ver si toca otro barril.
}

function ConvertirHexEnDec (Hexadecimal) {
    return parseInt(Hexadecimal, 16);
}
function ConvertirDecEnHex (Decimal) {
    Hexadecimal = Decimal.toString(16).toUpperCase();
	if (Hexadecimal.length == 1) {
		Hexadecimal = "0"+Hexadecimal;
	}
	return Hexadecimal;
}
function ActualizarColorDelFondo () {
	// Formar el color:
	ColorDelFondo = Rojo+Verde+Azul;
	// Actualizar el color del objeto:
	ColorDelObjetoFondo.setRGB(parseInt(ColorDelFondo, 16));
}

on (release) {
	// Del color obtener la parte a modificar:
	Azul = ColorDelFondo.substr(4, 2);
	// Convertirla en decimal:
	Azul = ConvertirHexEnDec(Azul);
	// Se aumenta 1 a esa parte y si supera 255 queda en 255:
	Azul = Math.min(Azul+1, 255);
	// Convertirlo en hexadecimal:
	Azul = ConvertirDecEnHex(Azul);
	// Obtener las otras partes:
	Rojo = ColorDelFondo.substr(0, 2);
	Verde = ColorDelFondo.substr(2, 2);
	ActualizarColorDelFondo ()
}

on (release) {
    _root.CFModo = 0;
    _root.CPartB = _root.Fondo.substring( 5, 6 );
    _root.CPartA = _root.Fondo.substring(4, 5);
    if (_root.CPartB == "F") {
        // Aumenta el primer dígito.
        if (_root.CPartA == "F") {
        } else {
            _root.CPartB = "0";
            if (_root.CPartA == "E") {
                _root.CPartA = "F";
            } else if (_root.CPartA == "D") {
                _root.CPartA = "E";
            } else if (_root.CPartA == "C") {
                _root.CPartA = "D";
            } else if (_root.CPartA == "B") {
                _root.CPartA = "C";
            } else if (_root.CPartA == "A") {
                _root.CPartA = "B";
            } else if (_root.CPartA == "9") {
                _root.CPartA = "A";
            } else if (_root.CPartA == "8") {
                _root.CPartA = "9";
            } else if (_root.CPartA == "7") {
                _root.CPartA = "8";
            } else if (_root.CPartA == "6") {
                _root.CPartA = "7";
            } else if (_root.CPartA == "5") {
                _root.CPartA = "6";
            } else if (_root.CPartA == "4") {
                _root.CPartA = "5";
            } else if (_root.CPartA == "3") {
                _root.CPartA = "4";
            } else if (_root.CPartA == "2") {
                _root.CPartA = "3";
            } else if (_root.CPartA == "1") {
                _root.CPartA = "2";
            } else if (_root.CPartA == "0") {
                _root.CPartA = "1";
            }
        }
        // Aumenta el segundo dígito.
    } else if (_root.CPartB == "E") {
        _root.CPartB = "F";
    } else if (_root.CPartB == "D") {
        _root.CPartB = "E";
    } else if (_root.CPartB == "C") {
        _root.CPartB = "D";
    } else if (_root.CPartB == "B") {
        _root.CPartB = "C";
    } else if (_root.CPartB == "A") {
        _root.CPartB = "B";
    } else if (_root.CPartB == "9") {
        _root.CPartB = "A";
    } else if (_root.CPartB == "8") {
        _root.CPartB = "9";
    } else if (_root.CPartB == "7") {
        _root.CPartB = "8";
    } else if (_root.CPartB == "6") {
        _root.CPartB = "7";
    } else if (_root.CPartB == "5") {
        _root.CPartB = "6";
    } else if (_root.CPartB == "4") {
        _root.CPartB = "5";
    } else if (_root.CPartB == "3") {
        _root.CPartB = "4";
    } else if (_root.CPartB == "2") {
        _root.CPartB = "3";
    } else if (_root.CPartB == "1") {
        _root.CPartB = "2";
    } else if (_root.CPartB == "0") {
        _root.CPartB = "1";
    }
    _root.Fondo = _root.Fondo.substring( 0, 4) + _root.CPartA + _root.CPartB;
    ColF = new Color(_root.Fondoimg);
    ColF.setRGB(parseInt(_root.Fondo, 16));
}