Agregué traces:

on (release) {
	// Los dibujos serán como el de encima de este botón:
	Dibujo = 1;
	ModificacionesRequeridas = 1;
	// Repetir para el dibujo 1, 2, etc:
	while (Dibujo < _level0.MaxCuadro+1) {
		// Este if es porque el dibujo a copiar no necesita...
		// ser modificado, eso sería como sustituirse por él mismo:
		if (Dibujo != _parent.ID) {
			Cuadradito = 0;
			// Repetir hasta que todo cuadradito se haya copiado:
			do {
				Cuadradito++;
				ColoraCopiar = new Color("_parent.Cuadradito"+Cuadradito);
				ColoraSustituirse = new Color("_level0.Dibujo"+Dibujo+".Cuadradito"+Cuadradito);
				ColoraSustituirse.setRGB(ColoraCopiar.getRGB());
			} while (Cuadradito<_level0.MaxCuadradito);
			// Los dibujos mutarán:
			// De cada dibujo copia, variar cuadraditos al azar,
			// de 1 hasta CuadraditosPorFila,
			// aumentando por dibujo hacia derecha y abajo:
			// Repetir hasta que se haya variado esa cantidad...
			// de cuadraditos:
			CuadraditosModificados = 0;
			do {
				// Para evitar que se modifique uno ya modificado,
				// los modificados se guardan en una lista,
				// y cuando se va a modificar uno se mira...
				// que no esté en la lista, sino se elige otro:
				trace("Se modificará un cuadradito del dibujo "+Dibujo);
				Repetido = "No";
				do {
					NroDeCuadraditoaCambiar = random(_level0.MaxCuadradito)+1;
					trace("El nro: "+NroDeCuadraditoaCambiar);
					trace("Se verá si ya fue modificado.");
					PunteroParaLista = 1;
					// Ver si NroDeCuadraditoaCambiar está en la lista de modificados:
					while (PunteroParaLista <= CuadraditosModificados) {
						trace("Comparando con el nro "+Puntero+" de la lista de modificados.");
						if (NroDeCuadraditoaCambiar == eval("CuadraditoModificado"+PunteroParaLista)) {
							Repetido = "Sí";
							PunteroParaLista = CuadraditosModificados+1;
							trace("Ya fue modificado, se elegirá otro.");
						}
						PunteroParaLista++;
					}
				} while (Repetido == "Sí");
				CuadraditoaCambiar = "_level0.Dibujo"+Dibujo+".Cuadradito"+(random(_level0.MaxCuadradito)+1);
				trace("Ya se eligió uno no modificado, es: "+CuadraditoaCambiar);
				ColoraSustituirse = new Color(CuadraditoaCambiar);
				// A esto lo convierto a String porque...
				// lo debo comparar con un string y es más fácil así.
				SavedeColoraSustituirse = ""+(ColoraSustituirse.getRGB());
				// trace ("SavedeColoraSustituirse: "+SavedeColoraSustituirse);
				// Repetir mientras el color no cambie:
				do {
					NuevoColor = _parent.PosiblesColores[random(_parent.PosiblesColores.length)];
				} while (NuevoColor == SavedeColoraSustituirse);
				ColoraSustituirse.setRGB(NuevoColor);
				// trace ("NuevoColor: "+NuevoColor);
				CuadraditosModificados++;
				// Agregar el cuadradito a la lista de modificados:
				set("CuadraditoModificado"+CuadraditosModificados, NroDeCuadraditoaCambiar);
			} while (CuadraditosModificados<ModificacionesRequeridas);
		}
		Dibujo++;
		if (ModificacionesRequeridas <= _level0.Resto) {
			ModificacionesRequeridas = Math.floor((Dibujo-1)/(_level0.DistintasMutaciones+1))+1;
		} else {
		    ModificacionesRequeridas = Math.floor((Dibujo-1-_level0.Resto*(_level0.DistintasMutaciones+1))/(_level0.DistintasMutaciones))+1+_level0.Resto
		}
	}
}

Y el resultado al principio dice:
Que empiece por el dibujo 2 está bien.

Que diga que eligió el cuadradito 8 y luego diga que el elegido es el 2, está mal, no sé qué pasa ahí ¿qué pasa?
Del dibujo 3 dice que modificará el cuadradito 13 pero luego dice que modificó el 14, lo mismo.
Con los demás pasa lo mismo.

Que modifique 2 del dibujo 5 está bien, pero cuando compara el candidato a modificado con los modificados debería decir cuales son los que está comparando, quizá olvidé poner ese trace.

El dibujo 10 no lo termina de modificar, dice:
Algo falla ahí, antes de decir "El nro: 2" debería decir "Ya se eligió uno no modificado, es..." o "Ya fue modificado, se elegirá otro.".

El programa se repite en eso, básicamente, lo último que muestra (luego de indicar que está tardando demasiado y que yo lo detenga) es:
El nro: 6
Se verá si ya fue modificado.
Comparando con el nro  de la lista de modificados.
Comparando con el nro  de la lista de modificados.
El nro: 4
Se verá si ya fue modificado.

¿Cómo corrijo esos errores?

Interesante. ¿Qué significa "Era el clan de las bosnias, que yo desmantelé"?

Había una, quizá no me apareció por el tipo de roms que estoy buscando (NES), busco la versión japonesa de Tag Team Match: M.U.S.C.L.E., sólo para confirmar que es igual a la de USA, excepto en algunos sprites.

No es esta:
https://nesninja.com/game/nes/m.u.s.c.l.e./roms
Pero supongo que sirve. La que digo descargabas un rar y dentro estaban las versiones. Probablemente era Emuparadise, muchos roms ya no están ahí.

Intento programar un personaje parecido a Jumpman (Mario antes de ser llamado así), pero la animación de caminar a veces no se aplica ¿por qué? ¿cómo lo arreglo?

En el fotograma 1:

fscommand ("fullscreen", "true");
// /////////////////////////////////////////////
// /////////////////  Jumpman  /////////////////
// /////////////////////////////////////////////
// Por ahora siempre está atacando:
Player.Action = "Attacking";
// Indica cómo está o qué está haciendo,
// independientemente de si está atacando o no:
Player.Action2 = "Quiet";
// Cuando ataca qu¡eto:
function AttackingQuiet () {
	Player.gotoAndPlay(2);
	Player.Action2 = "Quiet";
}
// Cuando ataca caminando:
function AttackingWalk () {
	Player.gotoAndPlay(5);
	Player.Action2 = "Walking";
}
// Al presionar derecha cuando está atacando quieto:
function RightWhenAttackingQuiet () {
	Player._x = Player._x+0.7;
	AttackingWalk();
}
// Al presionar derecha cuando está atacando caminando:
function RightWhenAttackingWalking () {
	Player._x = Player._x+0.7;
}
// Al presionar nada cuando está atacando caminando:
function QuietWhenAttackingWalking () {
	AttackingQuiet();
}
function ControlJumpman () {
	if (Key.isDown(39)) {
		// Si se presiona derecha:
		eval("RightWhen"+Player.Action+Player.Action2)();
	} else {
		// Si nada se presiona:
		eval("QuietWhen"+Player.Action+Player.Action2)();
	}
}

2:

stop();
En un objeto:
onClipEvent (enterFrame) {
	_level0.ControlJumpman();
}
 

El objeto Player está siempre y es así:
Fotograma 1: Jumpman no atacando y quieto, es irrelevante aquí.
2: Tiene el martillo arriba con pose de quieto.
3: Martillo aplastando, pose de quieto.
4: gotoAndPlay (2);
5~10: Atacando mientras camina.
11: gotoAndPlay (5);

El nombre lo borré yo respeto al mod. Su IP o sus IP no estaban en la imagen original porque los borraron por lo mismo.

Pero no dice cual era el nombre original o el autor original de ese tema. No dice algo como "Changed name from 'Demostración de la inexistencia de Dios' to Soy un Troll".

En cuanto a la papelera no recuerdo bien cómo era o quizá cambió en el tiempo. Lo que sí, en aquél foro esa sección era accesible a todos, lo que no recuerdo es si hubo un tiempo en que incluso se podía participar ahí. Era un foro de Filosofía así que era un poco demasiado permisivo, si algo no gustaba a la mayoría o al mod se enviaba ahí, aunque podía seguirse viendo mientras el tema tuviera mensajes recientes, creo que sí se podía participar, había un usuario que hablaba todo metafóricamente y hacía multiposts cortitos eternamente, es decir, como lo consideraron loco y le tenían lástima lo dejaban postear ahí en su propio tema que por estar en Papelera no aparecía en los temas activos.

Raro lo del type, quizá se refiere al ícono.

En definitiva esa imagen no dice algo importante ¿no? Faltaría la acción que diga cómo era el nombre del tema y que el mod lo cambió.

No sé si hubo otra imagen, esa es la que me topé ayer.

m, aunque sí dice algo relevante, el tema estaba en la papelera (creo que podíamos ver eso, no es como acá) y el mod lo movió a presentaciones, haciendo que el usuario pareciera estarse presentando como troll. El usuario en cuestión murió hace tiempo, nos dijo un familiar suyo con su cuenta. A él le molestó bastante lo que le hicieron, supuestamente.

Apareció un tema titulado "Soy un Troll" que figuraba como creado por un usuario U, pero él decía que no lo creó. El moderador más activo, M1, dijo que no recordaba haberlo hecho. El admin A no participaba, casi. Otro moderador M2 tampoco y otro M3 dió esa imagen.

Todas esas acciones figuran como realizadas por M1. Asumiendo que la imagen no está editada y que no se ururpó la identidad de M1 (hubiera sido la única vez, es poco creíble) ¿qué significan esas acciones que se describen en la imagen? ¿demuestran que es culpable?

El asunto causó bastante revuelo en el foro, U pedía que se modifique el tema, decía no poder edtarlo él mismo, los mods tampoco lo modificaban, y M1 terminó dejando de ser mod.

Yo me quedé con la curiosidad de saber qué pasó realmente y revisando temas lo recordé, en aquél entonces no se me ocurrió preguntar aquí o no conocía este sitio.

Puse esto y el código tarda demasiado ¿sugerencias?

on (release) {
	// Los dibujos serán como el de encima de este botón:
	Dibujo = 1;
	ModificacionesRequeridas = 1;
	// Repetir para el dibujo 1, 2, etc:
	while (Dibujo < _level0.MaxCuadro+1) {
		// Este if es porque el dibujo a copiar no necesita...
		// ser modificado, eso sería como sustituirse por él mismo:
		if (Dibujo != _parent.ID) {
			Cuadradito = 0;
			// Repetir hasta que todo cuadradito se haya copiado:
			do {
				Cuadradito++;
				ColoraCopiar = new Color("_parent.Cuadradito"+Cuadradito);
				ColoraSustituirse = new Color("_level0.Dibujo"+Dibujo+".Cuadradito"+Cuadradito);
				ColoraSustituirse.setRGB(ColoraCopiar.getRGB());
			} while (Cuadradito<_level0.MaxCuadradito);
			// Los dibujos mutarán:
			// De cada dibujo copia, variar cuadraditos al azar,
			// de 1 hasta CuadraditosPorFila,
			// aumentando por dibujo hacia derecha y abajo:
			// Repetir hasta que se haya variado esa cantidad...
			// de cuadraditos:
			CuadraditosModificados = 0;
			do {
				// Para evitar que se modifique uno ya modificado,
				// los modificados se guardan en una lista,
				// y cuando se va a modificar uno se mira...
				// que no esté en la lista, sino se elige otro:
				Repetido = "No";
				do {
					NroDeCuadraditoaCambiar = random(_level0.MaxCuadradito)+1;
					PunteroParaLista = 1;
					// Ver si NroDeCuadraditoaCambiar está en la lista de modificados:
					while (PunteroParaLista <= CuadraditosModificados) {
						if (NroDeCuadraditoaCambiar == eval("CuadraditoModificado"+PunteroParaLista)) {
							Repetido = "Sí";
							PunteroParaLista = CuadraditosModificados+1;
						}
						PunteroParaLista++;
					}
				} while (Repetido == "Sí");
				CuadraditoaCambiar = "_level0.Dibujo"+Dibujo+".Cuadradito"+(random(_level0.MaxCuadradito)+1);
				ColoraSustituirse = new Color(CuadraditoaCambiar);
				// A esto lo convierto a String porque...
				// lo debo comparar con un string y es más fácil así.
				SavedeColoraSustituirse = ""+(ColoraSustituirse.getRGB());
				// trace ("SavedeColoraSustituirse: "+SavedeColoraSustituirse);
				// Repetir mientras el color no cambie:
				do {
					NuevoColor = _parent.PosiblesColores[random(_parent.PosiblesColores.length)];
				} while (NuevoColor == SavedeColoraSustituirse);
				ColoraSustituirse.setRGB(NuevoColor);
				// trace ("NuevoColor: "+NuevoColor);
				CuadraditosModificados++;
				// Agregar el cuadradito a la lista de modificados:
				set("CuadraditoModificado"+CuadraditosModificados, NroDeCuadraditoaCambiar);
			} while (CuadraditosModificados<ModificacionesRequeridas);
		}
		Dibujo++;
		if (ModificacionesRequeridas <= _level0.Resto) {
			ModificacionesRequeridas = Math.floor((Dibujo-1)/(_level0.DistintasMutaciones+1))+1;
		} else {
		    ModificacionesRequeridas = Math.floor((Dibujo-1-_level0.Resto*(_level0.DistintasMutaciones+1))/(_level0.DistintasMutaciones))+1+_level0.Resto
		}
	}
}

// Este programa genera una comparación simple y su evaluación, pero:
// Debe haber alguna parte cuyo contenido no está definido.
// Ejemplo: 1 < ... : true
// Luego intenta asignar los contenidos faltantes.
// Las siguientes funciones se usan en Resolvedor:
function Comparacion() {
	trace("Probando: "+P1+" "+P2+" "+P3+": "+P4);
	if (P2 == "==") {
		Resultado = P1 == P3;
	} else if (P2 == "!=") {
		Resultado = P1 != P3;
	} else if (P2 == "<=") {
		Resultado = P1 <= P3;
	} else if (P2 == ">=") {
		Resultado = P1 >= P3;
	} else if (P2 == "<") {
		Resultado = P1 < P3;
	} else {
		Resultado = P1 > P3;
	}
	return Resultado+"" == P4;
}
function ModificarP1() {
	if (P1<10) {
		P1++;
	} else {
		Puntero++;
		// ¿Se puede modificar el contenido de otra parte?
		if (Puntero > Indefinidos) {
			// Sí, resetear esta y modificar esa:
			P1 = 0;
			eval("ModificarP"+eval("Indefinido"+Puntero))();
		} else {
			// No, indicar que el resolvedor se detenga:
			Continuar = "No";
		}
	}
}
function ModificarP2() {
	if (P2Valor<6) {
		P2Valor++;
		P2 = PosiblesSignos[P2Valor];
		Puntero = 1;
	} else {
		Puntero++;
		// ¿Se puede modificar el contenido de otra parte?
		if (Puntero > Indefinidos) {
			// Sí, resetear esta y modificar esa:
			P2Valor = 0;
			P2 = "==";
			eval("ModificarP"+eval("Indefinido"+Puntero))();
		} else {
			// No, indicar que el resolvedor se detenga:
			Continuar = "No";
		}
	}
}
function ModificarP3() {
	if (P3<10) {
		P3++;
		Puntero = 1;
	} else {
		Puntero++;
		// ¿Se puede modificar el contenido de otra parte?
		if (Puntero > Indefinidos) {
			// Sí, resetear esta y modificar esa:
			P3 = 0;
			eval("ModificarP"+eval("Indefinido"+Puntero))();
		} else {
			// No, indicar que el resolvedor se detenga:
			Continuar = "No";
		}
	}
}
function ModificarP4() {
	if (P4 == "true") {
		P4 = "false";
		Puntero = 1;
	} else {
		Puntero++;
		// ¿Se puede modificar el contenido de otra parte?
		if (Puntero > Indefinidos) {
			// Sí, resetear esta y modificar esa:
			P4 = "true";
			eval("ModificarP"+eval("Indefinido"+Puntero))();
		} else {
			// No, indicar que el resolvedor se detenga:
			Continuar = "No";
		}
	}
}
// Se repite en F2:
function Resolvedor () {
	if (Comparacion()) {
		trace ("Solución hallada, ver respuesta.");
		Mensaje = Mensaje+"\n"+P1+" "+P2+" "+P3+": "+P4;
		gotoAndStop (3);
	} else if (Continuar == "Sí") {
		// Se modificará el candidato:
		eval(ModificadoraUsar)();
	} else {
		trace ("No se pudo hallar una solución.");
		gotoAndStop (3);
	}
}
PosiblesTiposDeContenido = ["Normal", "Indefinido"];
PosiblesSignos = ["==", "!=", "<=", ">=", "<", ">"];
// Generar los contenidos de las 4 partes hasta que alguno sea indefinido:
do {
	Indefinidos = 0;
	// Parte 1 (cosa 1 a comparar):
	TipoDelParte1 = PosiblesTiposDeContenido[random(PosiblesTiposDeContenido.length)];
	if (TipoDelParte1 == "Normal") {
		Parte1 = random(10);
	} else {
		Parte1 = "...";
		Indefinidos++;
		set("Indefinido"+Indefinidos, 1);
	}
	// Parte 2 (símbolo comparador):
	TipoDelParte2 = PosiblesTiposDeContenido[random(PosiblesTiposDeContenido.length)];
	if (TipoDelParte2 == "Normal") {
		Parte2 = PosiblesSignos[random(6)];
	} else {
		Parte2 = "...";
		Indefinidos++;
		set("Indefinido"+Indefinidos, 2);
	}
	// Parte 3 (cosa 2 a comparar):
	TipoDelParte3 = PosiblesTiposDeContenido[random(PosiblesTiposDeContenido.length)];
	if (TipoDelParte3 == "Normal") {
		Parte3 = random(10);
	} else {
		Parte3 = "...";
		Indefinidos++;
		set("Indefinido"+Indefinidos, 3);
	}
	// Parte 4 (evaluación):
	TipoDelParte4 = PosiblesTiposDeContenido[random(PosiblesTiposDeContenido.length)];
	if (TipoDelParte4 == "Normal") {
		// Definir esta parte según las anteriores:
		// ¿Fueron definidas?
		if (Parte1 != "..." && Parte2 != "..." && Parte3 != "...") {
			// Sí, ver qué definición corresponde:
			if (Parte2 == "==") {
				Parte4 = Parte1 == Parte3;
			} else if (Parte2 == "!=") {
				Parte4 = Parte1 != Parte3;
			} else if (Parte2 == "<=") {
				Parte4 = Parte1 <= Parte3;
			} else if (Parte2 == ">=") {
				Parte4 = Parte1 >= Parte3;
			} else if (Parte2 == "<") {
				Parte4 = Parte1 < Parte3;
			} else {
				Parte4 = Parte1 > Parte3;
			}
		} else {
			// No toda parte fue definida,
			// definir esta al azar:
			Parte4 = random(2);
			if (Parte4 == 0) {
				Parte4 = "true";
			} else {
				Parte4 = "false";
			}			
		}
	} else {
		Parte4 = "...";
		Indefinidos++;
		set("Indefinido"+Indefinidos, 4);
	}
} while (Indefinidos == 0);
Mensaje = Parte1+" "+Parte2+" "+Parte3+": "+Parte4;
// Preparar variables, asignar valores a los contenidos indefinidos:
// Parte 1:
if (Parte1 != "...") {
	P1 = Parte1;
} else {
	P1 = 0;
}
// Parte 2:
if (Parte2 != "...") {
	P2 = Parte2;
} else {
	P2Valor = 0;
	P2 = "==";
}
// Parte 3:
if (Parte3 != "...") {
	P3 = Parte3;
} else {
	P3 = 0;
}
// Parte 4:
if (Parte4 != "...") {
	P4 = Parte4;
} else {
	P4 = "true";
}
// Usado para variar qué contenido de P se modifica:
Puntero = 1;
ModificadoraUsar = "ModificarP"+Indefinido1;
// Marca si algún cantenido puede modificarse:
Continuar = "Sí";

Ejemplo:
8 ... ...: ...
Probando: 8 == 0: true
Probando: 8 != 0: true
Solución hallada, ver respuesta.

Otro ejemplo:
... > 4: ...
Probando: 0 > 4: true
Probando: 1 > 4: true
Probando: 2 > 4: true
Probando: 3 > 4: true
Probando: 4 > 4: true
Probando: 5 > 4: true
Solución hallada, ver respuesta.

¿Funciona bien siempre? ¿detectan algo en el código que podría generar fallas?

Si pongo un botón de resetear ¿habrá problema? Pondría las funciones en el frame 1, la comparación se generaría en el 2 y el resolvedor se repetiría en el 3; mi temor es que una variable no eliminada, que no estaba definida al inicio, cause un error.

Lo último: El programa muestra mensajes usando trace, el equivalente de print. Pero eso sólo funciona usando el editor de Flash. Quisiera que esos mensajes se muestren también en un swf o exe. El problema es si el mensaje tiene muchas líneas, no sé cómo ponerle scroll. Voy a mirar el tutorial pero si me dicen mejor.

Estuvo tan bueno que no me detuve para escribir preguntas, en otro momento las escribo.