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 xD
---------------------------------------------------------------------------------------------------------
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...
