Quiero llamar a una función variable de la raíz (level0) desde una película.

Si fuese una función fija sería: _level0.NombreDeLaFuncion();

Llamar a una función variable de la raíz, desde la raíz, creo que sería:
FuncionALlamar = "Funcion1";
eval(FuncionALlamar)();

Si fuese FuncionALlamar = "_level0.Funcion1";
quizá funcionaría desde una película, se me acaba de ocurrir, pero he estado probando cosas y nada funciona. ¿Cómo sería?
"_level0."+eval(_level0.FuncionALlamar)();
o
eval("_level0."+_level0.FuncionALlamar)();

No recuerdo qué cosas probé, la solución que puse funcionó (no me gustaba porque me parecía inconveniente extender innecesariamente el valor de la variable), pero estoy liado en cuanto a qué hacen esas líneas. eval usa texto y variables para indicar el nombre de una variable y si existe devuelve su valor, pero si luego hay un () entonces ese nombre es de una función a la cual llama. Hasta ahí entiendo ¿está bien, no? Pero con lo del _level0. me lié.

---------------------------------------------------------------------------------------------------------

Otra pregunta.

Tengo por ahí:
PosiblesSignos = ["==", "!=", "<=", ">=", "<", ">"];

Y uso esta función luego:

function ModificarP2() {
	if (P2Valor<6) {
		P2Valor++;
		P2 = PosiblesSignos[P2Valor(PosiblesSignos.length)];
	} else {
		Continuar = "No";
	}
}

La idea es que P2 cambie a "!=", luego a "<=", y así sucesivamente pero no funciona. Es que esto:
P2 = PosiblesSignos[P2Valor(PosiblesSignos.length)];
lo hice basado en algo que me dijeron pero no entiendo qué hace. Obtiene la parte [a definir] del array llamado PosiblesSignos ¿no? Ahora creo que alcanza con decir:
P2 = PosiblesSignos[P2Valor];
Sí, ahora me funcionó. ¿Pero qué es esto:
P2 = PosiblesSignos[P2Valor(PosiblesSignos.length)];
? Debo haber copiado mal  

---------------------------------------------------------------------------------------------------------

Finalmente: ¿Es posible simplificar este código, cómo?

// 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 el contenido faltante,
// pero por ahora sólo si falta sólo 1.
// Las siguientes funciones se usan en Resolvedor1, etc:
function Comparacion() {
	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 {
		Continuar = "No";
	}
}
function ModificarP2() {
	if (P2Valor<6) {
		P2Valor++;
		P2 = PosiblesSignos[P2Valor];
	} else {
		Continuar = "No";
	}
}
function ModificarP3() {
	if (P3<10) {
		P3++;
	} else {
		Continuar = "No";
	}
}
function ModificarP4() {
	if (P4 == "true") {
		P4 = "false";
	} else {
		Continuar = "No";
	}
}
// Se repite en F2, cuando hay 1 contenido indefinido y es el 1:
function Resolvedor1 () {
	trace("Se probará el Candidato "+eval("P"+Indefinido));
	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 las 4 partes hasta que se cumpla la condición:
do {
	Indefinidos = 0;
	// Parte 1 (cosa 1 a comparar):
	TipoDelParte1 = PosiblesTiposDeContenido[random(PosiblesTiposDeContenido.length)];
	if (TipoDelParte1 == "Normal") {
		Parte1 = random(10);
	} else {
		Parte1 = "...";
		Indefinidos++;
		Indefinido = 1;
		// set("Indefinido"+Indefinidos, 1);
	}
	// Parte 2 (símbolo comparador):
	TipoDelParte2 = PosiblesTiposDeContenido[random(PosiblesTiposDeContenido.length)];
	if (TipoDelParte2 == "Normal") {
		Parte2 = PosiblesSignos[random(6)];
	} else {
		Parte2 = "...";
		Indefinidos++;
		Indefinido = 2;
		// set("Indefinido"+Indefinidos, 2);
	}
	// Parte 3 (cosa 2 a comparar):
	TipoDelParte3 = PosiblesTiposDeContenido[random(PosiblesTiposDeContenido.length)];
	if (TipoDelParte3 == "Normal") {
		Parte3 = random(10);
	} else {
		Parte3 = "...";
		Indefinidos++;
		Indefinido = 3;
		// 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++;
		Indefinido = 4;
		// set("Indefinido"+Indefinidos, 4);
	}
} while (Indefinidos == 0);
Mensaje = Parte1+" "+Parte2+" "+Parte3+": "+Parte4;
// Marca si algún canditato puede modificarse:
Continuar = "Sí";
// Decidir qué resolvedor usar y preparar variables:
if (Indefinidos == 1) {
	P1 = Parte1;
	P2 = Parte2;
	P3 = Parte3;
	P4 = Parte4;
	// Asignar un valor al contenido indefinido:
	if (Indefinido == 1) {
		P1 = 0;
	} else if (Indefinido == 2) {
		P2Valor = 0;
		P2 = "==";
	} else if (Indefinido == 3) {
		P3 = 0;
	} else {
		P4 = "true";
	}
	ResolvedoraUsar = "_level0.Resolvedor"+Indefinidos;
	ModificadoraUsar = "ModificarP"+Indefinido;
} else {
	Mensaje = Mensaje+"\nAún no hay resolvedor para esta duda.";
	stop();
}

La idea es solucionar problemas así cada vez más complejos. Esto es sólo el comienzo...