En la raíz:

DibujosPorFila = 8;
CuadraditosPorFila = 3;
LargoDeCuadraditos = 384/(CuadraditosPorFila*DibujosPorFila+DibujosPorFila-1);
LargoDeDibujos = CuadraditosPorFila*LargoDeCuadraditos;
MaxPosiciondePuntero = DibujosPorFila*DibujosPorFila;
// Agregar y distribuir cuadros (que serán dibujos):
CuadrosColocados = 0;
Columna = 0;
Fila = 0;
do {
	CuadrosColocados++;
	attachMovie("mCuadro", "Dibujo"+CuadrosColocados, CuadrosColocados);
	setProperty ("Dibujo"+CuadrosColocados, _x, 64+LargoDeDibujos*Columna+Columna*LargoDeCuadraditos);
	setProperty ("Dibujo"+CuadrosColocados, _y, LargoDeDibujos*Fila+Fila*LargoDeCuadraditos);
	Columna = Columna+1;
	if (Columna == DibujosPorFila) {
		Columna = 0;
		Fila = Fila+1;
	}
} while (CuadrosColocados<MaxPosiciondePuntero);

En mCuadro (m es por Movie, para distinguirlo de variables):

MaxPosiciondePuntero = _level0.CuadraditosPorFila*_level0.CuadraditosPorFila;
PosiblesColores = [0xFFFFFF, 0x888888, 0x000000];
// Agregar y distribuir cuadraditos:
CuadraditosColocados = 0;
Columna = 0;
Fila = 0;
do {
	CuadraditosColocados = CuadraditosColocados+1;
	attachMovie("mCuadradito", "Cuadradito"+CuadraditosColocados, CuadraditosColocados);
	setProperty ("Cuadradito"+CuadraditosColocados, _x, Columna*_level0.LargoDeCuadraditos);
	setProperty ("Cuadradito"+CuadraditosColocados, _y, Fila*_level0.LargoDeCuadraditos);
	setProperty ("Cuadradito"+CuadraditosColocados, _width, _level0.LargoDeCuadraditos);
	setProperty ("Cuadradito"+CuadraditosColocados, _height, _level0.LargoDeCuadraditos);
	ColorDeCuadradito = new Color("Cuadradito"+CuadraditosColocados);
	ColorDeCuadradito.setRGB(PosiblesColores[random(PosiblesColores.length)]);
	Columna = Columna+1;
	if (Columna == _level0.CuadraditosPorFila) {
		Columna = 0;
		Fila = Fila+1;
	}
} while (CuadraditosColocados<MaxPosiciondePuntero);

Este es uno de los posibles resultados, todo bien:


A mCuadro le puse una instancia llamada Botón. Dentro tiene un botón. El dibujo del botón es como un cuadradito. Si su color es 999999 se ve así:


Sino, como arriba, normal.

¿Por qué será?

999999 es el color original de los cuadraditos, sólo se me ocurre que el aparente bug tenga relación con eso, pero no tiene mucho sentido

Dejo aquí el archivo editable para quien quiera intentar explicar qué pasa y lo precise:
https://drive.google.com/file/d/11wJWUeWJAiGyeYH0Mz_TGU7IH7iN-P4J/view?usp=sharing

Veo que si cambio la forma del dibujo también funciona, pero si sólo le cambio el tamaño no ¿tendrá que ver con el hit test area o algo así?

Organícense para hacerle una demanda y dejen de usar ese banco.

Quisiera que me des más detalles de eso.

Yo en principio sólo quiero sprites como de Game Boy y Nes. Tomaría fotos a los que me gusten, no sé si es necesario guardar cosas más allá de eso.

Por cierto, suelen tener pocos colores, los de GB suelen ser sólo 3 o 4, contando el fondo (que no debe ser igual al borde; sino serían 5).

Buena pregunta, puede que haya una regla o truco que usar para evitar eso, algo como: ¿Qué relación hay entre el tamaño de la hoja, la cantidad de colores, y la cantidad que debe cambiar para que el dibujo cambie significativamente?

Es que por ahora sólo había pensado en blanco y negro.

También empecé otro programa en que la idea sería hacer programación genética basada en las elecciones del usuario. Primero genera dibujos random según ciertas especificaciones:

2ndo: El usuario cliquearía una, la que más le guste.
3ero: Todas las demás se volverían iguales a esa, y se modificarían un X% o X cantidad de píxeles, según la configuración inicial y otras cosas que deberé pensar.
Los pasos 2 y 3 se repetirían hasta que el usuario quiera. Cuando tenga algo suficientemente decente lo publico, por ahora es sólo ese random.

Puede sonar muy vago, pero últimamente cuando miro un video subo +20 el volúmen y usando gapa incremento la gamma de la pantalla a 1.50 (por practicidad, un poco menos sería mejor), y cuando dejo de mirarlo vuelvo a la configuración anterior, así que pierdo tiempo, etc.

¿No hay forma de hacer todo eso con sólo un par de clics o algo así? Luego de haber escrito código, claro.

También me podría servir algo como un acceso directo o programa, pero que abra varios a la vez. Por ejemplo que abra un archivo y una carpeta, o un archivo, un emulador y un programa. Algo he oído de archivos bats...

La lista la puedo generar usando un programa hecho por mí, con las restricciones que quiera, será interesante Si el archivo es muy largo puedo hacerlo por partes.

Me asombra que no exista algo como john --mask=[A]Lower(5), entendiendo que ese 5 significa que los 5 caracteres siguientes a A son minúsculas.

No me refería a quitar "u" y "q", sino el par, la combinación, que no pruebe passwords que tengan "uq", pero sí "qu", "q" y "u", salvo que tengan "uq" claro. De eso yo me encargo. Quizá se me complique mucho pero por ahora me tengo confianza xD

A GPT:
Olvidé el password que puse a archivos rar, quiero probar uno de longitud 6 que empiece con A y luego minúsculas ¿cómo hago?

GPT:
¿Es así? Puedo hacer una lista que no implique combinaciones que no usé (como "uq")...

No sé si les interesa pero hace poco recordé que en otro foro, al final de cada post podían aparecer 1 de 3 firmas, al azar, si el usuario lo configuraba. Yo ya no tengo mucha paciencia para hacer firmas, pero creo que estaría bueno eso.

También doy +1 a que exista la opción de ignorar, mencionada por otro usuario hace poco. O mejor bloquear, porque no está bueno tampoco que alguien haga un post, otro le tome el pelo o algo así, y quede ignorado, mejor que el bloqueado por un usuario ni pueda ver los post de quien lo bloqueó, ni responder sus temas.

Creo que más de un programador o que intentaba serlo me dijo que a las variables las llamara del modo mejor descriptivo posible, y yo no les hacía mucho caso a veces porque yo me acordaba qué representaba cada una y me resultaba más fácil de leer y escribir así, un vistado o un par de teclazos y ya estaba.
A golpes comprobé lo que me decían: Cuando pasaba mucho tiempo sin ver mis códigos, me costaba entenderlos, o a medida que crecían.
Decidí entonces intentar ser bien descriptivo, ya incluso con los contadores. Además así otros entienden mejor mis códigos, se supone.

Por otro lado, parece que a los matemáticos les gusta resumir cada variable a sólo 1 letra que muchas veces ni siquiera es la inicial de alguna palabra que la representaría o a veces ni parece tener sentido, y a mí probablemente por poca capacidad para memorizar cosas random pero también porque me acostumbré a otra cosa, me cuesta entenderlos y parece un diálogo de sordos porque ellos me dicen que no entienden mis códigos.

¿Les pasa eso a uds?

Sea a el ataque del pokemon atacante, b el ataque usado, c el daño base de b, d la cantidad de incrementos habidos a a en esta batalla, e la defensa del pokemon atacado, f la cantidad de incrementos a e, g el incremento del daño por el "stab", h la modificación del daño por el clima, e i la reducción por las barreras, la fórmula del daño j es...

Creo que puedo hacer un programa que haga todos los dibujos posibles (aunque el tamaño de los puntitos y la variedad de colores tiene cierto límite), sin repetir, de forma ordenada (no es lo ideal pero es la forma más fácil de evitar repeticiones; es como si cada número pudiera convertirse en un dibujo diferente, entonces el número 0 se convierte en un dibujo, el 1 en otro distinto, y así), en cierta medida ya lo hice.

El problema es que los dibujos posibles son MUCHÍSIMOS y muchos no tienen sentido o son tan parecidos a otros ya mostrados que no vale la pena que el programa los haga.

Creo que más o menos logré que no se muestren los repetidos: Exigiendo que en cada columna y fila (la hoja va aumentando de tamaño digamos) haya al menos 1 puntito pintado, y que si un dibujo es simétrico (considerando un espejo vertical) a otro ya mostrado, no se muestre. Por ejemplo esto / es muy parecido a esto \ No quiero que mi programa muestre esos 2, con 1 me alcanza.

Evitar que se muestren los "casi iguales" es un arma de doble filo porque ese casi puede hacer una gran diferencia, al menos en dibujos pequeños. ¿Cual dirías que es la relación entre el tamaño de la hoja (siempre cuadrada) y la cantidad de puntitos que pueden ser distintos sin que haga gran diferencia? Quizá no exista tal relación, pero por ejemplo en un dibujo pequeño de una E, quitar dos puntitos de abajo lo puede convertir en una F, mientras que si el dibujo es muy grande sólo parecerá un pequeño error.

Me falta evitar que se generen dibujos sin sentido, imágenes que no tiene sentido ver, porque es como si fuesen nada, por ejemplo puntitos todos desconectados y al azar, parecido a pecas, yo no quiero ver todas las formas en que puede haber pecas, son muy similares, es aburrido, la idea es ver dibujos distintos que pueda usar de personajes. Lo que para alguien no tiene sentido, para otro puede que sí, pero bue, no busco generar imágenes para esos juegos de "une los puntos para descubrir la imagen secreta". Por eso pensé que lo esencial es que todos los puntitos estuvieran conectados con algún otro, pero he aquí un ejemplo en que no, el que parece un Pikachu:

Sus ojos y mejillas son puntitos desconectados, y no por eso el dibujo deja de tener sentido, ni siquiera los puntitos en cuestión. ¿Qué características dirías que debe tener un dibujo para que tenga sentido, para que parezca algo?

Es que la tabla será muy ancha y alta, no entra en la pantalla. Seguiré haciendolo manualmente.