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

Ha habido frío y cuando eso sucede no uso mucho el mouse, así que sobre esto no había hecho mucho más hasta ayer. Además he estado ocupado, sólo pasó 1 día, cuando me quede cómodo te respondo bien, ahora estoy comiendo.

Ya.

Eso también lo había visto, pero parece demasiado complejo ponerme a hacer cálculos para esto. Mira, esto me dijeron en Quora:
Si entiendo bien lo que dices en tu comentario eso se llama "perspectiva".

En todos los programas de edición de imágenes, como Photoshop, Illustrator, GIMP o Inkscape, hay herramientas para transformar un objeto plano en un objeto con perspectiva.

En GIMP (editor de imágenes en mapa de bits gratuito) está en el menú Herramientas > Herramientas de transformación > Perspectiva:



Eso era lo que buscaba pero como ese programa no me sirvió (los ladrillos se agrandan demasiado) decidí hacerlo a mano, agrandé la imagen y le encontré la vuelta:
- En vez de los colores que usaré, usar en principio colores vistosos, cambiarlos luego.
- Ir pintando los ladrillos de modo horizontal, que ahí es diagonal, es decir, 1ero una fila, luego la otra, etc. Yo estaba haciendo de arriba hacia abajo. Es simplemente buscar la siguiente raya | borrarla y pintar.
Por ahora lo tengo así:

Vista ampliada de una parte:

Básicamente sólo me falta poner los colores rojizos y líneas. Los tamaños quedaron mal porque Flash delira en eso, yo iba estirando las líneas de a una a la vez y algunas filas quedaron más altas que otras, no lo voy a cambiar por ahora, no lo necesito perfecto xP

Las nuevas cosas que dices me parecen más sencillas que lo de hacer cálculos pero aún no lo capto bien.

Aquí tengo un problema similar.

Así está normal:

Cuando borro algo de una celda, enloquece:


Le quitaré el autocorrector a ver... ¡Ya está bien!

Creo que te confundiste, esto no es para un juego ni es animación...

Por ejemplo aquí se considera que no hay:

En este contexto lo blanco no se considera pintado, es fondo. Todos los cuadraditos pintados tienen al menos 1 pintado al lado (diagonal también cuenta).

Estoy haciendo un generador de dibujos así y quiero que no muestre (o que no genere, sería lo ideal) los que tengan cierta cantidad de cuadraditos pintados aislados. La cantidad depende del tamaño del dibujo, no importa aquí cual es. El dibujo se va modificando de a 1 cuadradito, se pinta uno, o se despinta uno (o más) y se pinta otro. Así, debo hacer algo como:
- Cuando se pinte uno nuevo, mirar si al lado hay otro. Si no hay, incrementar el contador de aislados. Si hay, ver si ese o esos estaban aislados, en cuyo caso disminuir el contador cuanto corresponda (según cuantos eran los aislados).
- Cuando se despinte uno, mirar si hay cuadraditos pintados al lado. Si no hay, disminuir el contador de aislados. Si hay, mirar al lado de cada uno y aumentar el contador de aislados por cada uno que haya quedado aislado.

Mi pregunta es: ¿Hay un modo más fácil? ¿es posible que lo haga GPT o algo así? Es que es mucho código... Por ahora hice esto y luego vi que no sirven else ifs, sólo ifs:

		// Para juzgar:
		// ¿El dibujo tiene menos de Largo/2 cuadraditos aislados?
		// Se actualizará el contador de 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á.
		CuadraditoAislado = "Sí";
		// ¿El modificado es el inferior derecho?
		if (Puntero == MaxPosiciondePuntero) {
			// Sí, ver el -1 (izquierdo), -L (up) y -L-1 (iu):
			// xSS
			// xS*
			if (eval("ColordeCuadradito"+(Puntero-1)) == 1) {
				CuadraditoAislado = "No";
			}
 
 
if (eval("ColordeCuadradito"+(Puntero-CuadraditosPorFila)) == 1) {
				CuadraditoAislado = "No";
			} else if (eval("ColordeCuadradito"+(Puntero-CuadraditosPorFila-1)) == 1) {
				CuadraditoAislado = "No";
			}
		} else if (Puntero > MinCuadraditoInferior) {
			// Inferior no en una esquina,
			// contar el +1 (derecho), -1, -L+1 (du), -L y -L-1:
			// SSS
			// S*S
			if (eval("ColordeCuadradito"+(Puntero+1)) == 1) {
				CuadraditoAislado = "No";
			} else if (eval("ColordeCuadradito"+(Puntero-1) == 1) {
				CuadraditoAislado = "No";
			} else if (eval("ColordeCuadradito"+(Puntero-CuadraditosPorFila+1)) == 1) {
				CuadraditoAislado = "No";
			} else if (eval("ColordeCuadradito"+(Puntero-CuadraditosPorFila)) == 1) {
				CuadraditoAislado = "No";
			} else if (eval("ColordeCuadradito"+(Puntero-CuadraditosPorFila-1)) == 1) {
				CuadraditoAislado = "No";
			}
		} else if (Puntero == MinCuadraditoInferior) {
			// Inferior izquierdo,
			// contar el +1, -L+1 y -L:
			// SSx
			// *Sx
			if (eval("ColordeCuadradito"+(Puntero+1)) == 1) {
				CuadraditoAislado = "No";
			} else if (eval("ColordeCuadradito"+(Puntero-CuadraditosPorFila+1)) == 1) {
				CuadraditoAislado = "No";
			} else if (eval("ColordeCuadradito"+(Puntero-CuadraditosPorFila)) == 1) {
				CuadraditoAislado = "No";
			}
		} else if (Puntero > CuadraditosPorFila) {
			// No es superior.
			if (Puntero%CuadraditosPorFila == 0) {
				// Central derecho,
				// contar el +L, +L-1, -1, -L y -L-1:
				// xSS
				// xS*
				// xSS
				if (eval("ColordeCuadradito"+(Puntero+CuadraditosPorFila)) == 1) {
					CuadraditoAislado = "No";
				} else if (eval("ColordeCuadradito"+(Puntero+CuadraditosPorFila-1)) == 1) {
					CuadraditoAislado = "No";
				} else if (eval("ColordeCuadradito"+(Puntero-1)) == 1) {
					CuadraditoAislado = "No";
				} else if (eval("ColordeCuadradito"+(Puntero-CuadraditosPorFila)) == 1) {
					CuadraditoAislado = "No";
				} else if (eval("ColordeCuadradito"+(Puntero-CuadraditosPorFila-1)) == 1) {
					CuadraditoAislado = "No";
				}
			} else if (Puntero%CuadraditosPorFila != 1) {
				// Central, contar todos los contiguos:
				// SSS
				// S*S
				// SSS
				if (eval("ColordeCuadradito"+(Puntero+CuadraditosPorFila+1)) == 1) {
					CuadraditoAislado = "No";
				} else if (eval("ColordeCuadradito"+(Puntero+CuadraditosPorFila)) == 1) {
					CuadraditoAislado = "No";
				} else if (eval("ColordeCuadradito"+(Puntero+CuadraditosPorFila-1)) == 1) {
					CuadraditoAislado = "No";
				} else if (eval("ColordeCuadradito"+(Puntero+1)) == 1) {
					CuadraditoAislado = "No";
				} else if (eval("ColordeCuadradito"+(Puntero-1)) == 1) {
					CuadraditoAislado = "No";
				} else if (eval("ColordeCuadradito"+(Puntero-CuadraditosPorFila+1)) == 1) {
					CuadraditoAislado = "No";
				} else if (eval("ColordeCuadradito"+(Puntero-CuadraditosPorFila)) == 1) {
					CuadraditoAislado = "No";
				} else if (eval("ColordeCuadradito"+(Puntero-CuadraditosPorFila-1)) == 1) {
					CuadraditoAislado = "No";
				}
			} else {
				// Central izquierdo,
				// contar el +L+1, +L, +1, -L+1 y -L:
				// SSx
				// *Sx
				// SSx
				if (eval("ColordeCuadradito"+(Puntero+CuadraditosPorFila+1)) == 1) {
					CuadraditoAislado = "No";
				} else if (eval("ColordeCuadradito"+(Puntero+CuadraditosPorFila)) == 1) {
					CuadraditoAislado = "No";
				} else if (eval("ColordeCuadradito"+(Puntero+1)) == 1) {
					CuadraditoAislado = "No";
				} else if (eval("ColordeCuadradito"+(Puntero-CuadraditosPorFila+1)) == 1) {
					CuadraditoAislado = "No";
				} else if (eval("ColordeCuadradito"+(Puntero-CuadraditosPorFila)) == 1) {
					CuadraditoAislado = "No";
				}
			}
		} else if (Puntero == CuadraditosPorFila) {
			// Superior derecho,
			// contar el +L+1, +L y +1:
			// *Sx
			// SSx
			if (eval("ColordeCuadradito"+(Puntero+CuadraditosPorFila+1)) == 1) {
				CuadraditoAislado = "No";
			} else if (eval("ColordeCuadradito"+(Puntero+CuadraditosPorFila)) == 1) {
					CuadraditoAislado = "No";
			} else if (eval("ColordeCuadradito"+(Puntero+1)) == 1) {
					CuadraditoAislado = "No";
			}
		} else if (Puntero > 1) {
			// Superior cemtral,
			// contar el +L+1, +L, +L-1, +1 y -1:
			// S*S
			// SSS
			if (eval("ColordeCuadradito"+(Puntero+CuadraditosPorFila+1)) == 1) {
				CuadraditoAislado = "No";
			} else if (eval("ColordeCuadradito"+(Puntero+CuadraditosPorFila)) == 1) {
				CuadraditoAislado = "No";
			} else if (eval("ColordeCuadradito"+(Puntero+CuadraditosPorFila-1)) == 1) {
				CuadraditoAislado = "No";
			} else if (eval("ColordeCuadradito"+(Puntero+1)) == 1) {
				CuadraditoAislado = "No";
			} else if (eval("ColordeCuadradito"+(Puntero-1)) == 1) {
				CuadraditoAislado = "No";
			}
		} else {
			// Superior izquierdo,
			// contar el +L+1, +L y +1:
			// *Sx
			// SSx
			if (eval("ColordeCuadradito"+(Puntero+CuadraditosPorFila+1)) == 1) {
				CuadraditoAislado = "No";
			} else if (eval("ColordeCuadradito"+(Puntero+CuadraditosPorFila)) == 1) {
				CuadraditoAislado = "No";
			} else if (eval("ColordeCuadradito"+(Puntero-1)) == 1) {
				CuadraditoAislado = "No";
			}
		}
		if (CuadraditoAislado == "Sí") {
			CuadraditosAislados++;
		}

Es decir, ahí sólo estoy viendo si el cuadradito nuevo está aislado ¡me falta ver si sus contiguos lo estaban! (o si lo están sin contar al nuevo) y me falta el caso en que se despinta un cuadradito. ¿Tal vez se podrían usar functions para evitar repetir código? No sé bien cómo. Además, siendo tanto, puede que haya cometido algún error :/

¿Datos que uno ingresa en ellas o qué datos? ¿de dónde los sacan? ¿copian cosas de la memoria del dispositivo?

Algo cerca del cerro, hubo una fila de varias luces similares a las de estrellas, a considerable distancia entre sí. Entre todas ocuparían el largo del cielo que alguien puede ver, más o menos. Hubo también unas pequeñas luces instantáneas y a veces vi algunas que iban a otra dirección. En eso vi un avión hacer un movimiento distinto al que suelo ver hacer, pero a esta hora no suelo verlos. Hizo una especie de curva. Las luces iban a su misma velocidad más o menos.

Si alguien puede averiguar algo, agradezco.

Ah, cierto, no tenía con qué filmarlos ni tomarles fotos, sorry.

Si entró a tu cuenta puede ser porque averiguó tu contraseña, él mismo dice en su mensaje que tienes "virus troyanos", y no sé bien qué significa "harmful software that is driver-based, </br>
which refreshes its signatures on 4-hourly basis", pero suena a que es un virus muy problemático. No me interesa mucho el hacking así que tocará que otro te de los detalles, yo sólo me limité a decirte lo que yo haría en tu situación, solucionar el problema, no cómo esa gente causa problemas. Hay programas, imagino, que intentan logearse a cuentas probando muchos passwords. Otros quizá capten todo lo que escribas, especialmente luego de que entras a páginas donde se sabe que escribes o puedes escribir passwords. Él creo que dijo que puede ver todo lo que haces, así que si pones asteriscos incluso en el password, puede ver la cantidad y eso le facilita averiguarlo.

Otra cosa que podrías hacer, luego de que la policía investigue, es llevar la máquina a un reparador y decirle la situación, mostrarle el mensaje y que te diga si puede quitar el virus y si no puede entonces buscar a otro.

Enviarse un email a uno mismo es posible, yo lo he hecho (para pasar algo de una PC a la mía), aunque no sé si aparece mi propio correo o qué.

Yo lo que haría es hablar con los administradores de tu correo y la policía, porque pagarle al tipo no te asegura que él cumplirá lo que dice y que no te pedirá más luego, por lo mismo o por otra cosa. Quizá podrías, conjuntamente con la policía, decirle que te ofreces a pagarle más si te da más información de cómo lo hizo, eso para aumentar la probabilidad de cazarlo. Podrías enviarte el correo a ti mismo como si se lo estuvieras enviando a él.

"Nunca usa 4 o 5 variables"
Me refería al ejemplo de GPT.

En conclusión, me parece demasiado lío para algo que me resulta suficientemente bien de otro modo. No se me da bien aprender todo eso.

Me gustó lo de hacer cuentas operando los caracteres de modo independiente y limitando el resultado xD
   329
!+209
-------
   529 -> se pone 9 porque en decimales el máximo es 9, y en esta operación mal no se lleva el sobrante a la izquierda.

   125
!*433
-------
   469 -> 1*4, 2*3, 3*5 limitado a 9

De 2 números obtener el más alto de cada columna y concatenar esos:
8723
9283
------
9783

El númedro más bajo, el promedio... En fin, cosas raras que me podrían servir.