Si elipse es muy complicado será rectángulo.

Quiero imitar una nube cambiando, más o menos. Circulos aparecerían detrás, crecerían y se achicarían hasta desaparecer. Hay un video que me gustó que más o menos hace eso pero no lo encuentro.

Entonces, tenemos una elipse de 200 de ancho y 100 de alto. Supongamos que está colocado en las coordenadas 0, 0. ¿Cómo los circulos podrían aparecer en cualquier parte del perímetro con igual probabilidad? No en el área.

Si es muy complicado, tenemos un rectángulo, digamos de la misma medida y lugar. Y misma pregunta.
Sobre este lo pensé y no supe. Puedo hacer que aparezca en el perímetro, pero con igual chance cada punto no sé.

https://youtu.be/TmACx8Du3as

Cuando el meteoro se está acercando a la nave de abajo, si presiono A o S aparece una mira, que se va moviendo a la izquierda si apreté A y a la derecha si apreté S.
Cuando el meteoro toque la nave de abajo, debe ir hacia donde haya quedado la mira.

Pueden ver que a veces funciona, y a veces no, no sé por qué...

La pantalla es de 800 pixeles de ancho y 600 de largo. Las coordenadas avanzan a la derecha y abajo, así que arriba a la izquierda es 0, 0
y abajo a la derecha es 800, 600
El 1er número corresponde a X, el 2ndo a Y.

La mira es algo provisorio para mostrar la falla, no habrá mira en el juego.

Creo que el error está acá:

	if (Meteor.hitTest(Player) && MeteorYSpeed>0) {
		// Determinar velocidad Y al azar:
		MeteorYSpeed = -Math.random()*(2+Dificultad)-1;
		// Distancia Y desde el meteoro hasta el punto hacia donde se lo apuntó:
		DistanciaY = Meteor._y-20.5;
		// Cuánto tardará el meteoro en recorrerla:
		TardanzaY = Math.ceil(DistanciaY/-MeteorYSpeed);
		// Distancia X desde el meteoro hasta el punto hacia donde se lo apuntó:
		DistanciaX = Meteor._x-400+Apuntando;
		// Determinar la velocidad X para que el meteoro llegue...
		// al punto X apuntado justo cuando llega al punto Y apuntado:
		MeteorXSpeed = DistanciaX/TardanzaY;

Código completo:

// Algo como esto if (MeteorYSpeed>0) { se está haciendo 2 veces,
// pero evitarlo implicaría unir cosas del jugador y la IA?
//
fscommand ("fullscreen", "true");
// Varía según diferencia de puntajes:
Dificultad = 0;
// Player:
attachMovie("sShip", "Player", 1);
setProperty ("Player", _x, 400);
setProperty ("Player", _y, 579.5);
PlayerSpeed = 3;
PlayerScore = 0;
// IA:
attachMovie("sIA", "IA", 2);
setProperty ("IA", _x, 400);
setProperty ("IA", _y, 20.5);
IASpeed = 3;
IAScore = 0;
// Meteor:
attachMovie("sMeteor", "Meteor", 3);
setProperty ("Meteor", _x, 400);
setProperty ("Meteor", _y, 544.5);
// Se define acá para que luego el programa considere que...
// hubo contacto entre la nave del jugador y el meteoro:
MeteorYSpeed = 1;
// Para que la curvatura dependa de MeteorYSpeed
// (1 es hacia arriba, -1 hacia abajo):
MeteorYDirection = -1;
// Valores del color más brillante del meteoro (F0D9C8):
MaxRojo = 255;
MaxVerde = 217;
MaxAzul = 200;
// /////////////////////////////////////////////
// /////////////////// Ship ////////////////////
// /////////////////////////////////////////////
function ControlShip () {
	if (Key.isDown(39)) {
		// Derecha.
		// Para evitar que se vaya demasiado al extremo derecho:
		if (Player._x<722) {
			Player._x = Player._x+PlayerSpeed;
		} else {
			Player._x = 725;
		}
	} else if (Key.isDown(37)) {
		// Izquierda.
		// Para evitar que se vaya demasiado al extremo izquierdo:
		if (Player._x>78) {
			Player._x = Player._x-PlayerSpeed;
		} else {
			Player._x = 75;
		}
	}
	// Si el meteoro va hacia abajo:
	if (MeteorYSpeed>0) {
		// Si aún no se eligió hacia dónde rebotarlo:
		if (Apuntando == 0) {
			if (Key.isDown(65)) {
				Apuntando = -1;
				attachMovie("sMira", "Mira", 4);
				setProperty ("Mira", _x, 399);
				setProperty ("Mira", _y, 20.5);
			} else if (Key.isDown(83)) {
				Apuntando = 1;
				attachMovie("sMira", "Mira", 4);
				setProperty ("Mira", _x, 401);
				setProperty ("Mira", _y, 20.5);
			}
		} else if (Apuntando < 0) {
			Apuntando = Apuntando-3;
			if (Apuntando < -400) {
				Apuntando = -400;
			}
			setProperty ("Mira", _x, 400+Apuntando);
		} else {
			Apuntando = Apuntando+3;
			if (Apuntando > 400) {
				Apuntando = 400;
			}
			setProperty ("Mira", _x, 400+Apuntando);
		}
	}
}
// /////////////////////////////////////////////
// ////////////////////  IA  ///////////////////
// /////////////////////////////////////////////
function IATurn () {
	// Si el meteoro va hacia arriba:
	if (MeteorYSpeed<0) {
		// La IA se moverá hacia él:
		Distancia = IA._x-Meteor._x;
	} else {
		// La IA irá hacia el centro:
		Distancia = IA._x-400;
	}
	if (Distancia < 0) {
		IA._x = IA._x+IASpeed;
		// Para evitar que se vaya demasiado a la derecha:
		if (IA._x > 725) {
			IA._x = 725;
		}
	} else if (Distancia > 0) {
		IA._x = IA._x-IASpeed;
		// Para evitar que se vaya demasiado a la izquierda:
		if (IA._x < 75) {
			IA._x = 75;
		}
	}
}
// /////////////////////////////////////////////
// /////////////////  Meteor  //////////////////
// /////////////////////////////////////////////
function VariarMeteoro () {
	Diametro = 44;
	Radio = Diametro/2;
	// Insertarle imágenes:
	Imagen = 0;
	do {
		Imagen++;
		Name = "Imagen"+Imagen;
		Meteor.attachMovie("sCirculo", Name, Imagen);
		Name = "Meteor."+Name;
		// Para los tamaños y rotación:
		setProperty (Name, _xscale, 400*Math.random());
		setProperty (Name, _yscale, 400*Math.random());
		setProperty (Name, _rotation, 360*Math.random());
		// Para las posiciones:
		X = Math.random()*Diametro - Radio;
		setProperty (Name, _x, X);
		MaxY = Math.sqrt(Radio*Radio - X*X);
		Y = Math.random() * (MaxY*2) - MaxY;
		setProperty (Name, _y, Y);
		// Para los colores:
		ColorDeName = new Color(Name);
		Brillo = 0.2 + 0.8 * Math.random();
		Rojo = Math.round(MaxRojo * Brillo);
		Verde = Math.round(MaxVerde * Brillo);
		Azul = Math.round(MaxAzul * Brillo);
		ColorElegido = (Rojo << 16) | (Verde << 8) | Azul;
		ColorDeName.setRGB(ColorElegido);
	} while (Imagen < 1000);
}
VariarMeteoro ();
function MeteorMoves () {
	MeteorXSpeed = MeteorXSpeed+MeteorRotation/1000*MeteorYDirection;
	MeteorRotation = MeteorRotation/1.01;
	Meteor._x = Meteor._x+MeteorXSpeed;
	Meteor._y = Meteor._y+MeteorYSpeed;
	Meteor._rotation = Meteor._rotation+MeteorRotation;
	// Choque con nave derecha:
	if (Meteor._x > 752.5) {
		MeteorXSpeed = -MeteorXSpeed;
		if (MeteorYSpeed > 0) {
			// Si va hacia abajo:
			MeteorYSpeed = Math.max (MeteorYSpeed, MeteorYSpeed-MeteorRotation/50);
		} else if (MeteorYSpeed < 0) {
			MeteorYSpeed = Math.min (MeteorYSpeed, MeteorYSpeed+MeteorRotation/50);
		}
		MeteorRotation = Math.random()*10*(2*random(2)-1);
	} else if (Meteor._x < 47.5) {
		// Choque con nave izquierda:
		MeteorXSpeed = -MeteorXSpeed;
		if (MeteorYSpeed > 0) {
			// Si va hacia abajo:
			MeteorYSpeed = Math.max (MeteorYSpeed, MeteorYSpeed+MeteorRotation/50);
		} else if (MeteorYSpeed < 0) {
			MeteorYSpeed = Math.min (MeteorYSpeed, MeteorYSpeed-MeteorRotation/50);
		}
		MeteorRotation = Math.random()*10*(2*random(2)-1);
	}
	if (Meteor.hitTest(Player) && MeteorYSpeed>0) {
		// Determinar velocidad Y al azar:
		MeteorYSpeed = -Math.random()*(2+Dificultad)-1;
		if (Apuntando < -400) {
			Apuntando = -400;
		} else if (Apuntando > 400) {
			Apuntando = 400;
		}
		// Distancia Y desde el meteoro hasta el punto hacia donde se lo apuntó:
		DistanciaY = Meteor._y-20.5;
		// Cuánto tardará el meteoro en recorrerla:
		TardanzaY = Math.ceil(DistanciaY/-MeteorYSpeed);
		// Distancia X desde el meteoro hasta el punto hacia donde se lo apuntó:
		DistanciaX = Meteor._x-400+Apuntando;
		// Determinar la velocidad X para que el meteoro llegue...
		// al punto X apuntado justo cuando llega al punto Y apuntado:
		MeteorXSpeed = DistanciaX/TardanzaY;
		MeteorRotation = 0;
		// MeteorRotation = Math.random()*(180+Dificultad)*(2*random(2)-1);
		MeteorYDirection = 1;
		trace("MeteorYSpeed: "+MeteorYSpeed);
		trace("Apuntando: "+Apuntando);
		trace("DistanciaY: "+DistanciaY);
		trace("TardanzaY: "+TardanzaY);
		trace("DistanciaX: "+DistanciaX);
		trace("MeteorXSpeed: "+MeteorXSpeed);
		removeMovieclip("Mira");
	} else if (Meteor.hitTest(IA) && MeteorYSpeed<0) {
		MeteorYSpeed = Math.random()*(2+Dificultad)+1;
		MeteorXSpeed = Math.random()*(3+Dificultad)*(2*random(2)-1);
		MeteorRotation = Math.random()*(180+Dificultad)*(2*random(2)-1);
		MeteorYDirection = -1;
		Apuntando = 0;
	} else if (Meteor._y<0) {
		setProperty ("Meteor", _x, 400);
		setProperty ("Meteor", _y, 55.5);
		PlayerScore++;
		Dificultad++;
		PlayerSpeed = PlayerSpeed+0.1;
		IASpeed = IASpeed+0.11;
		ShowScore();
	} else if (Meteor._y>600) {
		setProperty ("Meteor", _x, 400);
		setProperty ("Meteor", _y, 544.5);
		IAScore++;
		Dificultad--;
		PlayerSpeed = PlayerSpeed-0.1;
		IASpeed = IASpeed-0.11;
		ShowScore();
	}
}
// 
function ShowScore () {
	attachMovie("sPuntaje", "Mensaje", 4);
	setProperty ("Mensaje", _x, 400);
	setProperty ("Mensaje", _y, 300);
	setProperty ("Player", _x, 400);
	setProperty ("IA", _x, 400);
	gotoAndStop (3);
}
// stop ();

Kung Fu Master de NES es sencillo, ya lo pasé hace mucho, e hice experimentos recientemente, pero quiero hacerlos mejor. Elijo ese juego porque es sencillo y suficientemente bueno.
https://www.youtube.com/watch?v=e7PIr6hpaBY

La idea es empezar también por un experimento sencillo, por ejemplo sólo usar puñetazos normales (no agachado ni saltando). Supongamos que así vencí a 0 jefes. Tengo que anotar datos sobre el resultado:
Usar 1 ataque: 0
Ataque tipo puñetazo: 0
Ataque tipo normal: 0
Puñetazo: 0

El siguiente experimento debe ser lo más distinto posible a ese pero sin complicarme demasiado: 2 ataques, preferentemente que no sean tipo puñetazo, ni normal, y claro que no sean puñetazo.  Por ejemplo patada agachado y patada saltando sin avanzar. Luego pongo los resultados de eso.

Poco a poco se complica comprender cual es el siguiente experimento que conviene hacer, pero mi pregunta es ¿cómo se recomienda que sea la tabla de Excel para anotar los datos o cómo los anotarían? Ciertos datos deben llenarse automáticamente cuando se pone algo en ciertas celdas.

Para empezar pienso en algo así:

Ahí nada se está llenando automáticamente, parece innecesario, es poca cosa.

Luego pienso en algo así:

No sé si tiene sentido tanto dato, creo que es para en el futuro ir viendo qué combinaciones no volver a probar aún, o cuales probar preferentemente, la cosa es que siendo así, ya varios datos se tendrían que llenar automáticamente y probablemente ajustar la tabla para eso o para que quede mejor. Además, si algo tiene puntaje en varias columnas, veo 2 opciones:
A- Crear otra columna que haga un promedio.
B- Que en cada columna se use el nuevo puntaje para promediarlo con el anterior. Creo que esto hace que los últimos puntajes tengan más influencia, no es bueno.

Se va a complicar aún más. El tema es cómo automatizar que se llenen los datos. Lo de las combinaciones lo estoy hablando con GPT.

Pensé en algo así:

Los datos se llenarían así:
Usar 1 ataque: Si en Ataques dice 1, se pone el contenido de Puntaje.
2 ataques: Si en Ataques dice 2, contenido de Puntaje.
Ataque tipo puñetazo: Se busca eso (Ataque tipo puñetazo) en el rango de datos de la columna (hasta donde dice Tipo 2 de Ataque 2). Si se encuentra alguna vez, se pone el Puntaje.
Y así sucesivamente, se busca lo que marca la celda en la fila, y si se encuentra se pone el puntaje.
Entonces llegamos a:
2 ataques   Ataque tipo patada:
Si en Ataques dice 2 y se encuentra "Ataque tipo patada" en el rango de datos, se pone el puntaje.
Más adelante llegamos a:
Ataque tipo patada   Ataque tipo agachado:
Desde ahí se me complica porque lo que se preguntaría es ¿en el experimento se hicieron ataques tipo patada y además otro ataque tipo agachado? Y se se pondría el puntaje si la respuesta es sí, pero no es cuestión de buscar y si aparecen ambas palabras ya está, porque si por ejemplo hubo patadas agachado y puñetazos normales no es que hubo ataques tipo patadas y otro tipo agachado, sino que 1 ataque cumple ambas condiciones, no es lo mismo...
Dicho de otro modo, si es un juego de cartas Pokemon y pongo:
Carta tipo Pokemon   Carta tipo Pokemon tipo planta
lo que se pregunta es ¿hubo una carta Pokemon y otra Pokemon tipo planta? Si hubo un Pokemon tipo planta, eso cumple una condición u otra, no ambas a la vez, para que se cumplan ambas debe haber uno de esos y otro cualquiera.
¿Cómo puedo poner los datos y fórmulas para que se llenen automáticamente la mayoría de datos teniendo en cuenta eso?

Quizá debería aprender a no prestar atención a asuntos ajenos. Probablemente. Pero mirar temas de foros parece algo normal.

En Quora, gente postea chistes, curiosidades de la historia, respuestas varias a preguntas de los usuarios... En general, nada me parece tonto, nomás bloqueé a uno que daba mensajes "espirituales" crípticos disfrazados de sabiduría y a otro no recuerdo exactamente por qué, algo como que daba información irrelevante o le ponía demasiada opinión suya con la que no estaba de acuerdo.

Acá, El_Andaluz postea, no cualquier cosa sobre guerras, pero muchas cosas sobre guerras ¿demasiadas? Para mí sí, considerando que es un foro de Informática y que en teoría no se puede opinar de política. Lo que postea sobre eso es generalmente casi todo noticias copiadas de otro lado, que quien quiera verlas las podría leer en otro lado, así que no entiendo para qué. Se puede decir que es un tema importante, preocupante, y que cada uno puede postear de lo que se le de la gana, pero a mí me choca que casi siempre se esté hablando de lo mismo, como si te tiraran el tema en la cara, una y otra vez, donde para colmo no se puede opinar casi y no parece que corresponda, por ser un foro de informática, no de guerras ni tan general como otros foros. No entiendo la intención, me parece incomprensible, esa manía de copiar cosas de guerra de un diario hacia un foro de informática.
También de vez en cuando postea videos de cosas paranormales. Que me hacen sentir más o menos lo mismo: ¿Para qué muestra videos random? ¿por qué tengo que leer sobre eso en un foro de informática? Se lee acá:
https://foro.elhacker.net/unread.html;all
y sí entro porque quiero creer que es algo importante, revolucionario, como pareció que fue lo de la esfera de buga, aunque pasó mucho tiempo y no la abrieron, así que quedó en probable farsa, pero ese video que puso sí estuvo bueno.

Por otro lado, Elektro publicó un tema donde casi que dice haber alcanzado la iluminación, la sabiduría, y hace muchas recomendaciones pero parece decir nada, que tienes que ver los videos enteros o leer los libros para poder opinar debidamente. Para mí si alguien tiene algo importante y sabio que decir lo debería poder resumir un poco, pero bueno, no quise creer que fuera una tontería, aunque ese no resumen inspira desconfianza. Leí un resumen, el señor que recomienda cree que la vida es un videojuego, un montaje de la consciencia para evolucionar.

Ante tanta "espiritualidad" en el foro, me pregunté: ¿Esta gente ha experimentado algo paranormal alguna vez o...?
Por eso en parte hice el tema preguntando si alguna vez experimentaron algo paranormal. Y me pareció interesante. Videos probablemente hechos para lucrar, no. Tampoco me gusta asustarme al pedo.

Electro me insultó más o menos, y el tema se desvió.

Ahora, hice este tema que están leyendo porque quería preguntar cómo se supone que evite que se desvíe si me insulta y casi cualquier cosa menos decir lo que más me interesaba. Si él cree que la vida es un videojuego o no sé qué cosa aparentemente paranormal, podría explicar por qué ¿ha tenido alguna experiencia que lo induzca a creer eso? No explicó. ¿Qué debo pensar? Probablemente nada, pero ese tipo de gente me cansa. Si tienen algo importante que decir, que lo digan, sino es como una burla, no sé explicarlo, como si uno tuviese hambre (de sabiduría) y estos tipos nos intentaran hacer ver que están comiendo, pero algo probablemente falso, que probablemente ni ellos se dan cuenta, así que siento una mezcla de rabia y pena.

Más allá de eso, no sé lo que quiero, explicar algunas cosas sí.

Y bueno, no quiero que se prohíban ciertos temas en el foro, ni quiero que la gente se dedique sólo a cosas "inteligentes", pero siento que algo está mal, que no encaja, puede que sea yo, que necesite unas vacaciones de las redes sociales, o de este foro, pero como digo en Quora es muy difícil que te llegue una notificación de un video random de YT de dudosa credibilidad, de cada puñetero ataque en una guerra, o si llegan, como los mensajes espirituales crípticos, se tiene la opción de bloquear, de ignorar.

Quizá, por ejemplo, podrían hacer que los temas del foro libre no aparezcan acá:
https://foro.elhacker.net/unread.html;all
o denme un link donde no aparezcan, aunque igual me siento un poco mal, se me olvida esto: ¿Por qué no hacen algo más importante o relacionado con la Informática? Avances en la IA por ejemplo. No sé, es como que siento que está mal que alguien pierda su tiempo viendo o leyendo "estupideces", no sé, porque lo que siento cambia a veces, me olvido qué era, yo puedo pensar, en teoría, que son unos locos e ignorarlos, pero los temas me aparecen en el link, así que los veo, no puedo ignorarlos... Además a veces me da como rabia que pierdan el tiempo en "estupideces" pudiendo hacer algo mejor, aunque claro no debo obligarlos, pero me molesta ser obligado a ver esos temas.

En mi barrio hay gente durmiendo en la calle, y varios más revisan contenedores de basura, buscando sobras de comida o algo que vender. Yo no me siento tan distinto. Muy cerca se reúnen unos hinchas de políticos a charlar. ¿Debería spamearles una y otra vez lo mal que está el país? No lo hago porque hacer propaganda, joder una y otra vez con lo mismo, me parece mal.

No sé, lamento si soy el problema, demasiado intolerante, intentaré no prestar atención a temas que no sean de informática aquí y no dar importancia a lo "no importante" que hagan otros, pero sería bueno, y quizá importante, que haya una mejora en el foro como para que nos llegue lo que nos interesa, y no lo que no. ¿Qué sentido tiene que se pueda publicar cualquier cosa y que a la gente le llegue cualquier cosa aunque no quieran?

Que no parece tener explicación científica, que parece magia o de otro mundo.

Yo lo 1ero sería cuando con unos 5 años más o menos intentando abrir una puerta con una llave que no era de esa puerta, luego vi que la llave estaba doblada. No sé si originalmente estaba así, pero es un fierro corto y grueso, no creo que lo pudiera doblar ahora.

Lo 2ndo sería más o menos a los 9. Aunque tengo los recuerdos un poco mezclados, el orden. Creo que 1ero me pasó que una noche desperté, escuchaba "fshc, fshc, fshc", como si fuese un aleteo o algo, y vi entrar por la puerta abierta de mi cuarto, una especie de boomerang de luz, que giraba, se acercó y me pasó. El problema es que también recuerdo que en otra ocasión escuché ese ruido y me tapé todo pensando que era un vampiro xP Lo que no recuerdo es cual de los 2 eventos fue 1ero.

El resto de mis experiencias son relacionadas con OVNIS que no me parece lo mismo.

Bueno, una vez vi un líquido en el piso de casa, afuera, lo toqué, froté 2 dedos y brilló verde, como si fueran pequeñas explosiones, fue bastante raro eso, quizá era líquido de algún bicho.

No es una página confiable, ni me interesa usarla seguido, nomás estoy viendo una serie, pero este problema puede ocurrir en otras páginas así que, quisiera respuesta.

Básicamente cuando se carga la página te ponen un cartel de que detectaron el bloqueador de anuncios y no te dejan usar la página.

Ah, ya me acordé de algo: Detenerla antes de que se cargue del todo. Ya evité el cartel en un caso. Bien.

¿Otras técnicas?


¿Por qué no desactivar el bloqueador?
Porque te abren ventanas que en general no se pueden cargar, o las bloquea el antivirus, o no me interesan.

En el dibujo de arriba izquierda:

debería formarse esto:
┌
es como una L reflejada verticalmente.
pero como ven, está mal.

Ahí hay 7*7 dibujos (cuadros) compuestos de 8*8 cuadraditos cada uno.

El problema ocurre con esos números, no ocurre con números menores como
2 y 3
3 y 4
...
6 y 7
como ven siempre pongo que CuadrosPorFila = CuadraditosPorFila-1

Creo que el problema está en cómo se genera la variable DibujoaMostrar, en esta función, que se usa al inicio y cada vez que cambian esos números:

function AjustarVariables () {
	Cuadros = CuadrosPorFila*CuadrosPorFila;
	MaxCuadro = Cuadros-1;
	Cuadraditos = CuadraditosPorFila*CuadraditosPorFila;
	MaxCuadradito = Cuadraditos-1;
	LargoDeCuadraditos = 384/(CuadraditosPorFila*CuadrosPorFila+CuadrosPorFila-1);
	LargoDeCuadros = CuadraditosPorFila*LargoDeCuadraditos;
	// Esto es para que el 1er dibujo sea una L al revés...
	// Se averigua su número representante en binario:
	// Para formar la _
	DibujoEnBinario = String(Math.round(Math.pow(10, CuadraditosPorFila)));
	// Quitar el 1:
	DibujoEnBinario = DibujoEnBinario.substring(1, CuadraditosPorFila+1);
	// Esto forma las filas siguientes, con el 1ero pintado:
	NroDelCaracter = Cuadraditos-CuadraditosPorFila;
	AnterioraPintar = MaxCuadradito-CuadraditosPorFila;
	do {
		NroDelCaracter--;
		if (NroDelCaracter != AnterioraPintar) {
			DibujoEnBinario = 1+DibujoEnBinario;
		} else {
			DibujoEnBinario = 0+DibujoEnBinario;
			AnterioraPintar = AnterioraPintar-CuadraditosPorFila;
		}
	} while (NroDelCaracter>0);
	// trace("DibujoEnBinario que hace la L invertida: "+DibujoEnBinario);
	// Convertirlo en decimal:
	DibujoaMostrar = 0;
	do {
		DibujoaMostrar = DibujoaMostrar+(Number(DibujoEnBinario.charat(NroDelCaracter))*Math.pow(2, DibujoEnBinario.length-1-NroDelCaracter));
		NroDelCaracter++;
	} while (NroDelCaracter<Cuadraditos);
	DibujoaMostrar = Number(DibujoaMostrar);
	trace("DibujoaMostrar calculado desde la L invertida: "+DibujoaMostrar);
}

Porque tengo una función que convierte DibujoaMostrar a binario y...

Si CuadroPorFila es 2 y CuadraditosPorFila es 3, la conversión dice:
Convirtiendo a binario esto: 432
DibujoEnBinario: 110110000
y está bien, vean que tiene 4 0s al final. Los dibujos se muestran al revés a eso, o sea:
000
011
011
y 0 es negro, vean que se forma la ┌
son 3 0s y uno más que sigue en la siguiente fila. 4.

Si pongo 3 y 4:
Convirtiendo a binario esto: 61152
DibujoEnBinario: 1110111011100000
5 0s, la cantidad de 0s aumentó 1.

Con 4 y 5:
Convirtiendo a binario esto: 32472000
DibujoEnBinario: 1111011110111101111000000
6, de nuevo aumentó 1.

5 y 6:
Convirtiendo a binario esto: 67628691328
DibujoEnBinario: 111110111110111110111110111110000000
7, de nuevo +1.

6 y 7:
Convirtiendo a binario esto: 558517276622592
DibujoEnBinario: 1111110111111011111101111110111111011111100000000
8, de nuevo +1.

7 y 8:
Convirtiendo a binario esto: 1.83744039008715e+19
DibujoEnBinario: 1111111011111110111111101111111011111110111111110000000000000000
Con esto ocurre el problema. Vean que en 1er lugar el número se muestra raro, y el binario en vez de tener 9 0s al final tiene 16.
Creo haber confirmado que la función que convierte a binario no es el problema, falla porque se le da ese número raro.

¿Se puede corregir el error o es un número muy largo y por eso fallará sí o sí?

Explico por qué uso números grandes:
Supongan que el programa calcula cuántos dibujos pueden formarse con las condiciones dadas. Siendo 8*8 cuadraditos, si mal no recuerdo el cálculo es 2^64, que en la calculadora dice que es:
18446744073709551616
ese número convertido a binario forma lo que sería el dibujo todo pintado, con uno 1 delante que sobra:
10000000000000000000000000000000000000000000000000000000000000000
se vería así si quitamos el 1:
00000000
00000000
00000000
00000000
00000000
00000000
00000000
00000000
son 8*8 0s.

Supongan que esa cantidad la queremos dividir entre 7, para que cada cuadro muestre la misma cantidad de esos posibles dibujos a lo largo de cierto tiempo.
El cuadro nro 1 mostrará los 1eros 1000 dibujos posibles, por decir algo, el 2ndo los siguientes, y así.

Básicamente por eso es que necesito los números grandes. A la cantidad de dibujos posible le voy restando la cantidad que va a mostrar cada cuadro, para saber qué dibujo se mostrará 1ero en cada cuadro. Eso no lo puse en el código aquí porque no creo que sea el problema.

¿Hay alguna otra cosa importante que deba decir sobre esto?

La conversión es:

function ConvertiraBinario (numero) {
	// trace("Convirtiendo a binario esto: "+numero);
	// Averiguar cómo es en binario:
	DibujoEnBinario = "";
	while (numero>0) {
		DibujoEnBinario = numero%2+DibujoEnBinario;
		numero = Math.floor(numero/2);
	}
	// Agregar 0s a DibujoEnBinario si hacen falta:
	while (DibujoEnBinario.length<Cuadraditos) {
		DibujoEnBinario = 0+DibujoEnBinario;
	}
	// trace("DibujoEnBinario: "+DibujoEnBinario);
}

Pregunta tonta o que debería serlo pero TY me hace dar muchas vueltas para casi todo.

Lo pude hacer pero no sé cómo y no puedo volver a hacerlo. Busqué info y tampoco encontré. Por ejemplo esto:
https://www.youtube.com/watch?v=qla5PqXF274
A mí se me ve así:

No hay opción de copiar link, obtener enlace, etc.
Si entro en la lista y copio el enlace, ajá, podría ser, pero eso da un link más largo y de un video en específico, creo. Yo vi un modo de obtener un link más corto.

Y lo tengo copiado en el bloc de notas, pero como YT no mostraba los videos en el orden que le dije (y tuve que buscar cómo se ordenaban, pero no se aplica) no me sirve, no sé si andará bien ese link, tuve que quitar los videos de las listas y volverlos a poner.


Quejas extras:
- Tampoco me dejó poner el video entero, lo tuve que cortar. Lo intenté unas 3 veces.
- Siempre me pregunta si es para niños. No, no, no, NO, ¡NO! No me vuelvas a preguntar por favor.
- Que si es público. Sí, la mayoría lo será, para eso es, debería haber una opción especial, cliqueable, OPCIONAL, no que me obligue a cliquear una cosa un otra. Que esté marcado como público y si lo desmarco me de otras opciones.
- Votar las listas está deshabilitado por defecto @_@

Son la empresa más usada y grande del mundo ¿es tan difícil hacerlo bien?

Deberían agregar un ícono de confusión.

Esta es la salida:
Caminó a la derecha: 0.5
Caminó a la izquierda: 0
Caminó a la izquierda: -0.5
Caminó a la derecha: 0
Caminó a la derecha: 0.5
Caminó a la izquierda: 0
Caminó a la izquierda: -0.5
Mario empujado mientras caminaba a: -0.5
El EmpujeaDKMario es: 0
Distancia: 60.7
Empuje negativo, no debería ocurrir
Mario empujado mientras caminaba a: -0.5

y se repite. Esos mensajes indican la velocidad pixeles por frame, conque Mario se está moviendo, y la distancia respecto a Donkey Kong, que está a su derecha, moviéndose hacia él:
Mario <-DK
Los mensajes de movimientos son sobre Mario.

La velocidad de ambos es 0.5. Así que... voy a poner que la distancia se muestre más seguido, pero no es un error que pueda obtener a voluntad.

Distancia: 57.8
Mario empujado mientras caminaba a: 0.5
El EmpujeaDKMario es: 2.93
Moving por ser empujado: -2.43
Caminó a la derecha contra gran empuje: -2.4007
Distancia: 59.75
Mario empujado mientras caminaba a: -2.4007
El EmpujeaDKMario es: -5.569051
Empuje negativo, no debería ocurrir

Casi seguro que es cuando presiono izquierda justo antes de que sea empujado o en el mismo momento.

No puedo explicar lo que no entiendo, pero quedan tan cerca que hay colisión, cuando Mario caminaba a la derecha, así que es empujado a la izquierda, bastante, no debería haber colisión de nuevo en ese momento, pero hay... ¿por qué?

¿Cómo lo puedo entender más?

Viendo mensajes que no puse (son muchas líneas que parecen irrelevantes) veo que con 58.8 no ocurre colisión:
Distancia: 59.8
Distancia: 58.8
Distancia: 57.8
Mario empujado mientras caminaba a: 0.5
...pero en lo que puse antes dice que se detectó a 59.75, o sea, a mayor distancia sí se detectó colisión, no puede ser. Les dejo lo que me parece relevante del código, espero no resumir de más. Ah, un detalle: Cuando Mario es empujado, su velocidad tarda en normalizarse, dependiendo de si camina contra el empuje, si se queda quieto o camina a favor, pero dudo que eso sea la causa del problema, creo que es en la parte de DK.

// Player:
attachMovie("sDKMario", "Player", 1001);
setProperty ("Player", _x, 620);
setProperty ("Player", _y, 568);
// Velocidad conque se está moviendo y dirección:
Player.Moving = 0;
DKMarioSpeed = 0.5;
// IA:
attachMovie("sDK", "IA", 1000);
setProperty ("IA", _x, 780);
setProperty ("IA", _y, 568);
IA.Moving = 0;
DKSpeed = 0.5;
// /////////////////////////////////////////////
// //////////////////  Most  ///////////////////
// /////////////////////////////////////////////
// Nota: Creo que no estoy usando esto:
function FrenoPorFriccion (ID, Character) {
	if (Math.abs(eval(ID+".Moving")) > eval(Character+"Speed")) {
		set(ID+".Moving", (eval(ID+".Moving")+eval(Character+"Speed")*eval(ID+".Facing"))/2);
	}
}
// /////////////////////////////////////////////
// //////////////////  Mario  //////////////////
// /////////////////////////////////////////////
function WalkToRight () {
	// Si no está empujado a la derecha con más velocidad a la propia:
	if (Player.Moving < DKMarioSpeed) {
		// Si no está empujado a la izquierda con más velocidad a la propia:
		if (Player.Moving >= -DKMarioSpeed) {
			// Aumenta su velocidad hacia la derecha sin exceder el máximo:
			Player.Moving = Math.min(DKMarioSpeed, Player.Moving+DKMarioSpeed);
			trace("Caminó a la derecha: "+Player.Moving);
		} else {
			// Aumenta su velocidad un poco hacia la derecha sin exceder el máximo:
			Player.Moving = Math.min(DKMarioSpeed, (Player.Moving*99+DKMarioSpeed)/100);
			trace("Caminó a la derecha contra gran empuje: "+Player.Moving);
		}
	} else if (Player.Moving > DKMarioSpeed) {
		// Reducción de la velocidad:
		Player.Moving = (Player.Moving*99+DKMarioSpeed)/100;
		trace("Derecha con empuje: "+Player.Moving);
	}
	Player._x = Player._x+Player.Moving;
}
function WalkToLeft () {
	// Si no está empujado a la izquierda con más velocidad a la propia:
	if (Player.Moving > -DKMarioSpeed) {
		// Si no está empujado a la derecha con más velocidad a la propia:
		if (Player.Moving <= DKMarioSpeed) {
			// Aumenta su velocidad hacia la izquierda sin exceder el máximo:
			Player.Moving = Math.max(-DKMarioSpeed, Player.Moving-DKMarioSpeed);
			trace("Caminó a la izquierda: "+Player.Moving);
		} else {
			// Esto no ocurre por ahora (haber sido empujado a la derecha).
		}
	} else if (Player.Moving < -DKMarioSpeed) {
		// Reducción de la velocidad:
		Player.Moving = (Player.Moving*99-DKMarioSpeed)/100;
		trace("Izquierda con empuje: "+Player.Moving);
	}
	Player._x = Player._x+Player.Moving;
}
function Frenar () {
	if (Player.Moving > DKMarioSpeed) {
		// Si está moviéndose a la derecha más rápido de lo normal
		// (porque está empujado), poca reducción de la velocidad:
		Player.Moving = 0.99*Player.Moving;
		trace("Frenando naturalmente: "+Player.Moving);
		Player._x = Player._x+Player.Moving;
	} else if (Player.Moving < -DKMarioSpeed) {
		// Si está moviéndose a la izq más rápido de lo normal
		// (porque está empujado), poca reducción de la velocidad:
		Player.Moving = 0.99*Player.Moving;
		trace("Frenando naturalmente: "+Player.Moving);
		Player._x = Player._x+Player.Moving;
	}
}
// /////////////////////////////////////////////
// ///////////////////  DK  ////////////////////
// /////////////////////////////////////////////
function DKVsDKMario () {
	Distancia = IA._x-Player._x;
	trace("Distancia: "+Distancia);
	if (Distancia > 0) {
		// DK está a la derecha de Mario:
		IA._x = IA._x-DKSpeed;
		if (IA.hitTest(Player)) {
			if (Player.Action2 == "Walking") {
				EmpujeaDKMario = (DKSpeed+Player.Moving)*((DKPeso-DKMarioPeso)/100);
				trace("Mario empujado mientras caminaba a: "+Player.Moving);
				trace("El EmpujeaDKMario es: "+EmpujeaDKMario);
			} else {
				EmpujeaDKMario = DKSpeed*((DKPeso-DKMarioPeso)/100);
				trace("Mario empujado mientras estaba quieto.");
				trace("EmpujeaDKMario: "+EmpujeaDKMario);
			}
			if (EmpujeaDKMario > 0) {
				Player.Moving = Player.Moving-EmpujeaDKMario;
				trace("Moving por ser empujado: "+Player.Moving);
			} else {
				trace("Empuje negativo, no debería ocurrir");
			}
		}
	} else if (Distancia < 0) {
		// DK está a la izquierda de Mario, esto tampoco ocurre por ahora.
	} else {
		// DK está en el mismo lugar que DKMario, tampoco.
	}
}

Resumiendo el código acá me di cuenta de que el empuje no es necesariamente negativo, lo dice el if... Puede ser 0, de hecho al inicio dice que es 0, no lo había visto. Pero en la 2nda salida es negativo. El cálculo es:
EmpujeaDKMario = (DKSpeed+Player.Moving)*((DKPeso-DKMarioPeso)/100);
Supongo que resulta negativo porque Player.Moving es negativo, lo cual como expliqué no sé cómo ocurre en ese momento, parece que a veces se capta una colisión a una distancia menor, pero que yo sepa el tamaño de los dibujos (animados) no varía tanto.

¿Necesitan algo más?

O sea, estaba a Distancia 57.8, hubo colisión, fue empujado a la izquierda, caminó a la derecha intentando oponerse, pero estaba a distancia mayor que antes, y aún así se detectó otra colisión. ¿Acaso el caminar se está aplicando luego de que se dice la distancia, antes de terminar el frame? Digo, puede que la salida esté desordenada, chequearé eso.

A veces cuando enciendo la PC, el monitor muestra imagen y luego nada. Tengo que apagarlo y prenderlo muchas veces para que quede... un poco rojo u oscuro en un costado, pero "bien". Una forma más cómoda es abrir ZSNES, un programa de DOS parece, y hacer alt+tab cada vez que el monitor deja de mostrar imagen. Porque ir a "DOS" y volver a Windows, o viceversa, hace que el monitor se apague o algo así por un momento.

Lo dejo encendido siempre ya con la esperanza de que no dé problemas, pero estar como 5 minútos o no sé cuánto, haciendo alt+tab sin poder hacer mucho más, es como, desastrozo. No puedo mandar a arreglarlo ni conseguir otro.

Pregunto cómo podría, con un programa o test, causar el efecto de "reinicio" de monitor, o apagado y reencendido, como expliqué.
Recuerdo que sucedía con los test de Direct X, posiblemente también con un emulador de Playstation y posiblemente con el cambio de tamaño del escritorio o pantalla en Windows.
Imaginen que no pueden ver. Yo muevo el mouse para un costado, hago clic, apreto Z, sé que se selecciona el ZSNES que está en el escritorio, pongo un juego y empiezo a hacer alt+tab como ¿boludo? hasta que el monitor quede bien.
Me gustaría algo más simple, algo que lo ponga en el monitor, lo abra así con una tecla (puedo ponerle un nombre con X por ejemplo), y que luego tenga el efecto usando sólo 1 tecla.

¿Qué se les ocurre?

Hablando con GPT me dijo algo de crear un programa que se ponga en pantalla completa. Tendría que cerrarse cuando yo le diga. Que se abra con Enter, claro, y en lo posible con Enter también se cierre, pero que el detector de Enter empiece luego de unos segundos para que no se cierre enseguida.
Pero no cualquier pantalla completa sirve. Por ejemplo la de Chrome creo que no sirve, debe ser una que "reinicie" al monitor.