Intento hacer un juego pero hay una colisión que falla en detectarse, así que hice una versión más simple, que también falla xP

Un personaje se mueve hacia la derecha y cuando toca el barril debería empujarlo, pero como el programa falla, hay game over 

El archivo editable:
https://docs.google.com/document/d/1oHcl-CnBQtm79ABWG9JuJDslrA77XZho/edit?usp=sharing&ouid=109273743447273895658&rtpof=true&sd=true
Nota: Donde dice "      // Hay que ver si tocaría un barril, arreglarlo.", creo que está mal, ya lo arreglé, además no es el problema.

El código:

// Indica si el juego continúa o no:
Game = "Ok";
// Por motivos que no recuerdo, las imágenes se ponen...
// en un objeto I.
// Agregar personaje:
I.attachMovie("sMedaMan", "Player", 1);
// X es porque la posición real del personaje no admite...
// tantos valores, los simplifica, se pierde parte;
// de este modo no:
I.Player.X = 0;
I.Player._X = I.Player.X;
I.Player._Y = 584;
I.Player.Action = "Quiet";
I.attachMovie("sBarril", "Barril2", 2);
I.Barril2.X = 80;
I.Barril2._X = I.Barril2.X;
I.Barril2._Y = 584;
LV = 1;
Recorrido = 0;
// /////////////////////////////////////////////
// /////////////////  MedaMan  /////////////////
// /////////////////////////////////////////////
function AumentarRecorrido () {
	Recorrido++;
	if (Recorrido == 50) {
		Recorrido = 0;
		LV++;
	}
}
function Walk () {
	I.Player.Action = "Walking";
	I.Player.gotoAndStop(2);
	// Indica si debe empujar un barril o no:
	I.Player.Empujar = "No";
	// Ver si empuja algún barril:
	// (tal vez convenga chequear desde el último)
	BarrilesChequeados = 1;
		BarrilesChequeados++;
		BarrilaChequear = "I.Barril"+BarrilesChequeados;
		BarrilX = getProperty(BarrilaChequear, _x);
		// Si el barril existe:
		if (BarrilX != undefined) {
			DistanciaPlayerBarril = Math.abs(I.Player.X-BarrilX);
			trace("DistanciaPlayerBarril: "+DistanciaPlayerBarril);
			// 26 es la mínima distancia conque no se tocan,
			// pero se agrega 0.2 por el movimiento de Medaman:
			if (DistanciaPlayerBarril < 26.2) {
				trace("Empuja");
				I.Player.Empujar = "Sí";
			}
		}
	if (I.Player.Empujar == "No") {
		// El personaje avanza:
		// Hay que ver si tocaría un barril, arreglarlo.
		I.Player.X = I.Player.X+0.2;
		I.Player._X = I.Player.X;
		AumentarRecorrido();
	} else {
		// Determinar movimientos:
		// MaxDist < 14+12+0.2
		// MinDist > 0
		// Distancia 26.2 -> 0 movimiento
		// 0 -> 0.2
		MovimientoDelPers = DistanciaPlayerBarril*0.2/26.2;
		I.Player.X = I.Player.X+MovimientoDelPers;
		I.Player._X = I.Player.X;
		// Recorrido debe aumentar acorde a eso, arreglarlo:
		AumentarRecorrido();
		// Empuja un barril:
		// Esto sólo aumenta la velocidad, ojo que si no se mueve puede que quede tocando al personaje:
		BarrilSpeed = BarrilaChequear+"Speed";
		set (BarrilSpeed, eval(BarrilSpeed)+0.2-MovimientoDelPers);
		trace("Speed: "+eval(BarrilSpeed));
	}
}
function Quiet () {
	I.Player.Action = "Quiet";
	I.Player.gotoAndStop(1);
}
// Whens:
function RightWhenQuiet () {
	// Ver si toca algún barril:
	BarrilesChequeados = 1;
		BarrilesChequeados++;
		if (I.Player.hitTest(eval("I.Barril"+BarrilesChequeados)) == true) {
			trace("Apareció en barril");
			// Game over:
			Game = "Over";
			I.Player.gotoAndStop(2);
		}
	if (Game == "Ok") {
		Walk();
	} else {
		gotoAndStop (3);
	}
}
function RightWhenWalking () {
	// AumentarRecorrido();
	Walk();
}
function QuietWhenWalking () {
	Quiet();
}
// QuietWhenQuiet nada hace.
function ControlPlayer () {
	if (Key.isDown(39)) {
		// Si se presiona derecha:
		eval("RightWhen"+I.Player.Action)();
	} else {
		// Si nada se presiona:
		eval("QuietWhen"+I.Player.Action)();
	}
}
// /////////////////////////////////////////////
// ////////////////  Barriles  /////////////////
// /////////////////////////////////////////////
function MoveBarriles () {
	Moved = 1;
		Moved++;
		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);
		}
		PosicionDelBarril = getProperty(BarrilaMover, _x)+EvaluedBarrilSpeed;
		// Si ya no está en la pantalla:
		if (PosicionDelBarril>850) {
			// Quitarlo:
			removeMovieClip (BarrilaMover);
		} else {
			// Actualizar posición y girar su parte:
			setProperty (BarrilaMover, _x, PosicionDelBarril);
			Res = BarrilaMover+".Part";
			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") {
				DistanciaPlayerBarril = Math.abs(I.Player.X-PosicionDelBarril);
				trace("Golpeado");
				trace("DistanciaPlayerBarril: "+DistanciaPlayerBarril);
				// Game over:
				gotoAndStop (3);
			} 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);
				}
			}
		}
}

O sea, que si empuja o no, en vez de chequearlo con hittest calculo la distancia entre el personaje y el barril, porque quiero que el personaje se mueva más o se mueva menos de acuerdo a qué tan cerca estaba el barril antes de tocarlo, y si lo hiciera con hittest tendría que mover al personaje, ver si toca, y en tal caso retrocederlo cierta cantidad, o sea cancelar parte del movimiento. Me pareció mejor de esta otra forma, calculando la distancia.

El juego dice que hay colisión en el chequeo del golpe, cuando la distancia es 27.7999999999998. Ese chequeo tiene que estar, es para ver si el personaje es golpeado desee atrás cuando los barriles se mueven (en esta versión no sucede porque es simplificada). El chequeo que falla es el de empuje, que es lógico que falle porque la distancia debe ser <26.2 según mis cálculos, que deben estar mal o no sé qué pasa.

El personaje mide
.................................+306666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666
..3+02222222222222222222222222222222222222222222222222222222222222222222222222222222222220
no, eso fue porque me pareció ver una cucaracha cerca de donde tengo el mouse, me fijé y toqué teclas sin darme cuenta, han habido varias cerca, lo dejo como chiste 

28 de ancho y está en el medio de su película.
El barril 24, lo mismo.

La línea roja, la distancia, mide 26:


Tal vez debí poner 25.8, no lo entiendo, si a 26 no se tocan pero el personaje se moverá 0.2... ¿entonces a 26 debo sumarle 0.2 o restarle? No sé, pero teniendo en cuenta que por ese movimiento es más fácil que se toquen, entonces supuse que sería 26.2, porque <26.2 es más fácil de cumplirse que 25.8.

Igual el problema no es ese ¿por qué con hittest se detecta una colisión a distancia 27.7999999999998?

Aunque parte del barril se gira, lo cual podría extender (según el criterio de Flash) el ancho del objeto barril, en esta versión no se gira, pero quito eso del código a ver. Sucedió lo mismo.

Acabo de ver que en el estado Wait, Medaman tiene ancho 30, pruebo quitarlo a ver. Lo mismo. Pensé que quizá aunque su estado e imagen fuese walking, hittest funcionaba con el ancho de la 1er imagen, pero no.

Cierto, haré eso, pero igual quisiera entender qué está fallando con lo que hice y cómo se podría hacer si efectivamente el fondo fuese más complejo.

Algo quizá relevante que no creí tal es que el cuadro se achicaba hacia la derecha, o sea, el centro del movieclip está puesto en la derecha de la hoja, y a su vez el dibujo dentro del movieclip está puesto a la izquierda de su centro:

Y ahora lo puse al revés, porque quiero que se agrande hacia la derecha, pero creo que en ese sentido está bien.

Dejo eso último:
https://docs.google.com/document/d/104xaU2CooZQas5PtJRPZz5m2psOZYPTA/edit?usp=sharing&ouid=109273743447273895658&rtpof=true&sd=true

El código está en el cuadradito verde de arriba-izquierda.

EDIT: Ahora probé poner la moto en la máscara y el cuadro en una capa normal. El resultado fue que la moto no se movió y el cuadro se expandió. Conclusión: Lo que se pone en la máscara no se modifica.

Se tendría que hacer agregando el texto a un texto dinámico entonces, a una variable. Al menos es lo mejor que se me ocurre. También se puede, en cada frame, ir poniendo el texto cada vez más completo, es más fácil de hacer pero el otro modo sirve para cualquier texto una vez que se haga...

https://youtu.be/xvKPm6Sox3c

Lo negro que cliqueo estará debajo de unos botones, ya hay uno, blanco.

Tienen 3 estados, o frames.

El 1ero es simple, estático.

Cuando uno de esos botones se señala, su borde parpadea cambiando de colores al azar. El estado 2: Señalándolo.

Cuando se cliquea, su borde adquiere el color de su centro, y su centro parpadea cambiando de colores al azar. El estado 3: Cliqueándolo.

Cuando se suelta, su centro adquiere el color del separador de dibujos, eso adquiere el color del borde del botón, y eso vuelve a como era (negro transparente).

Es un botón que asigna un color a los separadores de dibujos, pero en vez de asignar siempre el mismo, luego de usarse adquiere el color de los separadores, porque si son blancos no tiene mucho sentido un botón que los vuelva blancos. El resto son efectos para que quede mejor.

El problema es que si se cliquea, sin soltar el clic se deja de señalar, y se suelta el clic sin señalar el botón, entonces queda en el estado 3, incluso sin estarlo señalando, ni cliqueando, y eso está mal.

¿Cómo se evita ese error? Aún no lo pensé porque tuve mucho lío intentando lograr esos efectos que dije arriba xP Tengo que acomodar algunos nombres de variables también.

Pongo el código y luego el archivo. También pueden darme sugerencias sobre cómo mejorar el proceso.

La película que tiene el botón inicia así:

onClipEvent (load) {
	ColorDel = 0xFFFFFF;
}

DelCentro sería, pero ese nombre ya lo tenía usado, culpa de cómo Flash guarda los colores  
Eso hará que cada botón tenga un color distinto, aunque el símbolo u objeto sea el mismo. Sólo debe aplicarse una vez, sino el botón podría quedar como al inicio, cuando no debe.

En el frame 1 de la película:
ColorDelCentro = new Color(Centro);
stop ();
Posiblemente se puede poner esa definición en el load anterior. El stop hace que la película se quede mostrando el estado 1, normal, del botón.

Esto es de la parte central del botón, que ocupa el frame 1 y el 2:

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

Adquiere el color asignado por la variable.

Botón en el frame 1:

on (rollOver) {
	gotoAndStop (2);
}

Cuando el botón se señala, va a su frame 2.

Frame 2:

El borde del botón, llamado Extremo (pues de hecho también tiene un borde exterior a eso, pero no cambia) tiene esto:

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

El botón, que ocupa el frame 2 y 3, tiene:

on (rollOut) {
	gotoAndStop (1);
}
on (press) {
	// El extremo de este botón tendrá el color del centro,
	// y él cambiará a colores random:
	ExColorDelCentro = ColorDelCentro.getRGB();
	gotoAndStop (3);
}
on (release) {
	// El centro tendrá los colores de los separadores (fondo):
	ColorDel = _level0.ColorDelObjetoFondo.getRGB();
	ColorDelCentro.setRGB(ColorDel);
	// Los separadores el color del extremo:
	_level0.ColorDelFondo = ColorDelExtremo.getRGB().toString(16).toUpperCase();
	_level0.ColorDelObjetoFondo.setRGB(ColorDelExtremo.getRGB());
	gotoAndStop (2);
}

Frame 3:

ColorDelExtremo = new Color(Extremo);
ColorDelExtremo.setRGB(ExColorDelCentro);

Un detalle quizá relevante es que en el frame 1, el objeto Extremo no tiene nombre, porque no se quiere que tenga efectos.

Centro del botón, pero no tiene nombre:

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

Creo que eso es todo.

https://drive.google.com/file/d/1cveV1htg1Hto9ylnu-hNnCMpwrdV45ma/view?usp=sharing


Edit:
Solucionado, los botones tienen la opción de "release out", simplemente hice tic en esa opción y puse que vaya al frame 1 en vez de al 2.
Lo que está mal es cómo queda el texto del color luego de que se seleccionan ciertos colores, pero eso es otro tema.

En el siguiente video pueden ver 2 animaciones.
https://youtu.be/If4OhphUivw

La 1era está bien, pero la moto anda en un fondo negro, vacío.

La 2nda está mal, pero tiene pista.

Quiero que esté bien y tenga pista.

En la 1era, delante del texto hay un cuadro negro que se va achicando a medida que la moto avanza.

En la 2nda no puedo hacer lo mismo, no puedo poner un cuadro negro o se vería una cosa negra moverse en la pista. Tampoco puedo poner algo similar a la pista, que se achique o mueva, porque la pista tiene puntitos separados y se notaría.
Intenté poner una máscara (cosa de Flash), pero nunca tuve claro cómo funciona y en este caso no me sirvió. Creo que es:
- Máscara.
- Capa en máscara.
- Capa común.
El objeto que haya en la máscara determina lo que se muestra de la capa en máscara. Lo que tape se muestra. No afecta a la capas comunes.
Basado en eso acabo de probar que el cuadro negro esté pequeño y se agrande, pero no parece que se agrande porque el texto sólo se ve donde está el objeto, chiquito. En la versión anterior se achica sin problema, ahora sólo cambié un - por un + y puse al objeto en una máscara ¿es por eso?

onClipEvent (load) {
	Wait = 15;
}
onClipEvent (enterFrame) {
	setProperty ("_level0.Excitebiker", _x, getProperty("_level0.Excitebiker", _x)+5);
	setProperty ("_level0.Tapador", _width, getProperty("_level0.Tapador", _width)+5);
	setProperty ("_level0.Texto", _x, getProperty("_level0.Texto", _x)-0.1);
	Wait--;
	if (Wait == 0) {
		setProperty ("_level0.Texto", _alpha, getProperty("_level0.Texto", _alpha)-1);
		Wait = 15;
		if (getProperty("_level0.Texto", _alpha) < 20) {
			_level0.gotoAndStop (3);
		}
	}
}

En fin ¿cómo lo podría hacer?

No te entiendo y lo explicaré más pues quizá me faltó, no sé.

El programa luego de hacer dibujos de 3x3 hace de 4x4, empezando así:
BBBN
BBNB
BNBB
NBBB
Donde N es negro y B blanco. Traza una / no viene al caso por qué.

Luego pinta o despinta cuadraditos desde abajo hacia la izquierda, por lo que el siguiente dibujo será:
BBBN
BBNB
BNBB
NBBN

Están nombrados así:
1 2 3 4
5 6 7 8
9 10 11 12
13 14 15 16
Y pinta/despinta desde el 16, haciendo todas las combinaciones posibles.

Debido a esa forma conque pinta/despinta, cuando se quiere saber si el recién pintado está aislado, no es necesario chequear el de la derecha ni los de abajo. Porque todos estarán despintados. Es como cuando reduces lo mínimo posible al binario 1000, te va a quedar 0111, no sé si realmente es así en binario pero el punto es que cuando disminuye algo de adelante, todo lo demás queda al máximo, que en este caso es despintado (pintado=0 porque en Flash el color negro es 0, así no me entrevero en eso, y 1 es despintado, blanco). Por lo tanto, había puesto que esos análisis innecesarios no se hagan.

Por otro lado, se quiere que los dibujos no sean simétricos (espejo | ) a otros ya hechos, porque son iguales pero al revés, es aburrido. No confundir conque el dibujo sea simétrico. Esto es simétrico:
NBBN
BBBB
NNNN
NBBN
o capicúa, como quieran. Pero lo que yo digo es simétrico a uno ya hecho, por ejemplo este:
NNBB
BBBB
BBBB
BBBB
es simétrico a:
BBNN
BBBB
BBBB
BBBB
que fue hecho antes. Para saber si fue hecho antes, se usan los números. Como di a entender, los dibujos con más valor son hechos antes. El cuadradito 1 empieza teniendo valor 1, el 2 también, etc, y el valor va bajando como dije en el ejemplo de los binarios. La fila superior del que se quiere analizar (NNBB) es 0011. Si eso es < que su inverso (1100) entonces su simétrico ya fue hecho y ese dibujo no debe mostrarse. No me acuerdo de memoria el resto, acá está:

				// 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);

Ya más o menos comprobé que eso puede ocurrir desde que un superior izquierdo está pintado:
IIDD

Bueno, cuando se capta un simétrico, intenté evitar que se produzcan dibujos que también lo serán. Para eso, en vez de mandar el Puntero hacia el inferior derecho, lo mando al final de la fila que se captó como "fallida". Porque si por ejemplo el error está en la fila superior, hacer todas las variaciones posibles en filas inferiores es inútil, el dibujo seguirá siendo simétrico. No es el método ideal de evitarlos, sólo lo mejor que se me ocurrió.
Pero al cambiar el lugar a donde va el Puntero en esos casos, ahora sí es necesario chequear otros cuadraditos. O eso creo... antes desde que se captaba una simetría el contador de cuadraditos aislados me daba -1 a partir de cierto punto, está mal, y dibujos que estaban bien los consideraba con muchos aislados. En fin, yo no puedo entender todo esto todo el tiempo, a veces me olvido de algunas cosas. Vamos a ver un caso concreto, este es el 1er simétrico que capta en 4x4:

Los que pinté de rojo es que están aislados. ¿Por qué ese es el 1er simétrico captado? Supongo que porque otros anteriores fueron descartados por otros motivos (es "pequeño" o tiene demasiados aislados).
1010 > 0101 así que no debería captarse como simétrico, m... Lo grabo en video a ver si lo entiendo mejor. Como se saltea dibujos, no sé bien qué pasa, y no tengo ganas de cambiar el code ahora y ver otra vez:
https://youtu.be/e-Qn3K8t_3A

Luego de esto:

Se pinta el inferior derecho y se capta como dibujo denso (demasiados pintados).
Luego quedará así:
BNBB
BBBB
BBBB
BBBB
Se considera "pequeño" (hay alguna columna o fila donde no hay un pintado), y en este caso especial (el mínimo pintado disminuyó, o sea, el 1er pintado era el 3, ahora el 2), para evitar simétricos supongo, se pone el Puntero en el superior derecho, por lo que el siguiente es:
BNBN
BBBB
BBBB
BBBB
Pequeño. Ahora el Puntero se pone en el inferior derecho. Y sigue, pero no entiendo por qué se considera simétrico el mencionado antes, tendré que pensarlo.

La cosa es que yo quería evitar hace los análisis innecesarios, pero ahora a veces lo son así que podría poner un if para ver si debe hacer el análisis completo o no, pero no quiero poner ese if, no sé, eso es lo que recuerdo de todo esto xP Por ahora puse que se haga el análisis completo siempre.


EDIT: El error estaba en una parte del código que no mostré porque no pensé que pudiera tener un error. Cuando el dibujo se agranda, a cada cuadradito se le asigna color de 3 maneras, o mejor dicho hay 3 variables que guardan el mismo color, aunque puede que con distinto valor:
- La normal, la que tiene efecto directo, cambia el color del cuadradito.
- ColordeCuadradito1, ColordeCuadradito2, etc, los valores son 0 para negro y 1 para blanco.
- Cuadradito1_1, Cuadradito1_2, etc, es igual que el anterior pero se indica con filas y columnas.
Bueno, en ese momento se hacía:
set ("Cuadradito"+(Fila+1)+"_"+(Columna+1), "FFFFFF");
Luego al hacer el análisis de simetría, en unos traces decía:
Analizando fila 1, columna 1
Valor: FFFFFF
ValorInverso: 0
Analizando fila 1, columna 2
Valor: 0
ValorInverso: 1
0 < 1
...No se interpretaba que "FFFFFF" fuese > 0. causando el error. Lo corregí poniendo 1 en vez de "FFFFFF" cuando se define, nunca se usa el "FFFFFF" excepto para asignar el color real, pero no necesita estar definido ahí.

Porque me acostumbré y suelo hacer referencia a objetos variables, por ejemplo si hay Cuadradito1, 2, etc, y les estoy cambiando el color con un while, me referiré a ellos con "Cuadradito"+Contador, por lo que considero que el nombre va en comillas si es un objeto, y sin comillas cuando es una variable.
Pero pruebo lo que me dices. Funciona xD   ¿Por qué con string no? Ah, ya entendí, lo explicaste luego  

Si en vez de while usara autollamadas o llamadas a la función similar, sería el fin del problema. Lo hice pero me di cuenta de 2 cosas:
> Luego de que se detecta simetría y hay variaciones, los análisis posiblemente deberían ser completos, es decir como VariarLuegoDeSimetria, así que las funciones serían más distintas de lo que pensé, VariarLuegoDeSimetria podría tener que autollamarse donde normalmente se llamaría a Variar.
> Luego de que se detecta simetría y se despinta un cuadradito, el chequeo de aislados posiblemente debe ser completo.
...Intento evitar que el programa haga análisis en vano, pero es muy complicado parece, así que parece que conviene que el análisis sea completo siempre.

O sea, puse que cuando se pinta/despinta un cuadradito, mire de todos los contiguos a ver si estaban aislados. Dudo que sea lo más eficiente pero me resulta muy complicado todo esto, ni siquiera estoy seguro de haber logrado resultados correctos, pero eso es otro tema.

No puedo ver tu gif en este momento porque imgbb está caído, pero usando Wordpad pude abrir un archivo más pequeño que tengo, seguí las instrucciones y se dañó el archivo (era una copia). Tal vez es porque mi archivo rar tiene muchos dentro, o es que sólo hay que hacer las 2 sustituciones 1 vez.
Igual parecía demasiado fácil ese método (4).

En cuanto al bat, pensé en modificarlo para que generara las que me interesan, pero supuse que john sería más rápido, y considerando lo que yo tardaría en aprender.

En cuanto a métodos conque se obtiene o genera un número a partir de otro, por ahora me sirvió clasificarlos en 4 tipos:
A: No cambian los caracteres, sólo cambian de lugar.
B: Se pierden algunos y se generan otros.
C: Se pierden algunos.
D: Se generan algunos.

Por ahora intento hacer la lista de los C, es decir de los métodos que modifican a un número mediante quitarle caracteres, sin cambiarlos de lugar ni transformarlos de otros modos.

Lo más reciente que tengo es esto:


Vease que en naranja parece haber 2 variables:
1: Qué caracter se quita: El 1ero, el central, el último.
2: De qué parte se quita: Del todo, de la parte entera, de la decimal, 1 de cada una.

La variable 1 varía hacia abajo, la 2 varía hacia la derecha.

En rojo hay 3 variables así que me lío, no puedo variarlas hacia 3 lados porque la tabla sólo tiene 2 dimensiones. Que una varíe hacia la izquierda y la otra a la derecha no sirve porque ya no habría cruces de 3 coordenadas.

Lo que se me ocurre es que una de las variables varíe en hojas, o sea, en otra hoja sólo estaría lo rojo y en vez de decir "su siguiente presencia" podría decir "su última presencia" (referirse a la central no es tan simple), pero para mí es lioso, y además ¿si llegan a ser 4 qué, hago distintos archivos?

Pienso que debe haber alguna buena manera de hacer la lista visiblemente ordenada, para facilitar que se pongan todas las posibilidades, pero distintas cosas que probé no me funcionaron por a o por b.

Es combinatoria, pero los posibles valores no se saben a priori. Tampoco se pueden concatenar todos igual.

Lo normal es hacer una lista de una columna, hacia abajo:
A0a
A0b
etc
donde cada caracter de eso sería cada valor de las variables, 3 en este caso.

Pero yo haciéndolo así me entrevero en este caso, no sé bien por qué, me parece que queda más comprensible si los que son similares se ponen al lado, formando una tabla.

Se me acaba de ocurrir hacer una tabla en que en cada celda, los valores varíen cada cierto tiempo, de ese modo podrían entrar en 2 dimensiones la variación de 3 variables, pero ya probé algo similar y el hecho de que parte del texto cambie mientras lo miro me genera cierta confusión en casos como este. Además si hay 4 variables no servirá.

Este tipo de problemas los tuve varias veces. ¿Sugerencias?

on (release) {
	// Los separadores (fondo) tendrán el color de este botón,
	// y este botón el color que tenían los separadores:
	ExColorDelFondo = _level0.ColorDelFondo;
	_level0.ColorDelFondo = ColorDeCentro.getRGB().toString(16).toUpperCase();
 
	_level0.ColorDelObjetoFondo.setRGB(parseInt(_level0.ColorDelFondo, 16));
 
	ColorDeCentro.setRGB(parseInt(ExColorDelFondo, 16));
}

Funciona todo menos:
_level0.ColorDelObjetoFondo.setRGB(parseInt(_level0.ColorDelFondo, 16));

No importa qué ponga luego de RGB, no se aplica.

Pero desde el lv0 funciona:
ColorDelFondo = Rojo+Verde+Azul;
// Actualizar el color del objeto:
ColorDelObjetoFondo.setRGB(parseInt(ColorDelFondo, 16));

Le paso un texto hexadecimal (ColorDelFondo), lo convierte en decimal, y se lo asigna de color a un objeto.

La situación es la misma.

_level0.ColorDelFondo: FFFFFF
ColorDeCentro: 10066329


Explico desde el principio, no sé...

Esto es lo relevante en este momento:

Es largo explicar por qué se ve así, no viene al caso.

Lo que tiene color cyan es "las separaciones", también fondo. Se inició así:

ColorDelObjetoFondo = new Color("Fondo");
ColorDelObjetoFondo.setRGB(parseInt(ColorDelFondo, 16));

Y se le puede cambiar el color con los botones con flechita de colores, así:

function ActualizarColorDelFondo () {
	// Formar el color:
	ColorDelFondo = Rojo+Verde+Azul;
	// Actualizar el color del objeto:
	ColorDelObjetoFondo.setRGB(parseInt(ColorDelFondo, 16));
}
 

Los botones cambian el color correspondiente y luego aplican eso.

Estoy agregando botones que al presionarlos hagan intercambios, o sea, se ve uno blanco, al cliquearlo quedaría cyan (o como esté el fondo o separador en ese momento) y el fondo quedaría blanco.

Pero ese botón, para que aparezca de un color variable y haga un efecto, lo puse en una película. No debería haber problema con eso. Pero sucede lo que dije al inicio, no se aplica, no sé qué pasa.

Les dejo el archivo. Tienen que mirar el código del botón superior izquierdo, que en la imagen se ve blanco pero en el editor se ve gris como los demás. Vayan al 2ndo frame de eso y vean el cuadrado negro. Ahí está el código que falla.

Acabo de poner esto:
_level0.Rojo = "FF";
_level0.ActualizarColorDelFondo ();
...y funciona. Pero por qué esto no:
_level0.ColorDelObjetoFondo.setRGB(parseInt(_level0.ColorDelFondo, 16));
si es lo mismo que:
ColorDelObjetoFondo.setRGB(parseInt(ColorDelFondo, 16));
¿Hay algo mal escrito que no veo? La única diferencia es que el 1ero dice _level0. en 2 lados porque fue usado desde una película y lo que se quiere señalar está en el lv0.

Podría entonces usar la función mencionada luego de cambiar el valor del rojo, etc, pero no tiene mucho sentido modificar partes si ya tengo una variable que tiene el color a transferir.

Una posible explicación sería que ActualizarColorDelFondo se esté aplicando todo el tiempo pero la quité, puse
_level0.ColorDelObjetoFondo.setRGB(0);
y no funcionó.

https://docs.google.com/document/d/1HkhDR97uRp5Gv_ECbm7z0w301a5SFc-6/edit?usp=sharing&ouid=109273743447273895658&rtpof=true&sd=true


EDIT: Parece que es un bug.

Si esto:
on (release) {
   _level0.ColorDelObjetoFondo.setRGB(0);
}
está en un botón del level0, funciona. Pero si el botón está dentro de una película, no. Se puede hacer funcionar poniendo el código en una función y llamándola, pero no debería ser necesario.