No entiendo por qué me resulta tan complicado.

Los dibujos empiezan teniendo 3*3 cuadraditos, siempre los números serán iguales entre sí.

Como regla he puesto que, si son X*X, se muestren (X-1)*(X-1) dibujos en la pantalla, o sea que al inicio serían 2*2.

Una muestra:

Lo gris son separadores. Hay 2*2 dibujos o cuadros, de 3*3 cuadraditos cada uno. Son blancos o negros.

Hay 2^(3*3) dibujos posibles, creo, no importa si está mal el cálculo. Esa cantidad se quiere que se divida en 4, para que cada cuadro muestre la misma cantidad de dibujos.

Los dibujos se pueden representar mediante un número, especialmente uno binario. Como en Flash el negro es 000000, decido que el 0 represente negro y 1 blanco.

Quiero que se vayan mostrando dibujos en orden desde todo blanco, o sea, si los dibujos fuesen de 2*2 sería:
1er dibujo del 1er cuadro: 1111
2ndo dibujo de ese cuadro: 1110
3ero: 1101
el número va bajando, sin sobresaltos.

También quiero que inicialmente los dibujos varíen desde arriba e izquierda, por lo que, supongo, me conviene numerar a los cuadraditos así:
8 7 6
5 4 3
2 1 0
Así que el dibujo correspondiente a 111111110 sería:
0 1 1
1 1 1
1 1 1
O sea ¡al revés!

El número debe variar normal, pero debe aplicarse al revés, creo.

Creo que ya había logrado eso. Entonces quise que en vez de mostrarse todos los dibujos, se empiece por este:
1 1 0
1 1 0
0 0 0
No viene al caso por qué. La cosa es que se mostrarán menos dibujos, la cantidad a dividir en cuadros es distinta. Hay que averiguar qué cantidad es.

Hago esto:

	DibujoEnBinario = "";
	NroDelCaracter = Cuadraditos;
	AnteriorCaracteraPintar = Cuadraditos-CuadraditosPorFila;
	// Esto genera la |
	do {
		NroDelCaracter--;
		if (NroDelCaracter != AnteriorCaracteraPintar) {
			DibujoEnBinario = DibujoEnBinario+1;
		} else {
			DibujoEnBinario = DibujoEnBinario+0;
			AnteriorCaracteraPintar = AnteriorCaracteraPintar-CuadraditosPorFila;
		}
	} while (NroDelCaracter > CuadraditosPorFila);
	// Esto la _
	do {
		NroDelCaracter--;
		DibujoEnBinario = DibujoEnBinario+0;
	} while (NroDelCaracter > 0);
	trace("DibujoEnBinario (_|): "+DibujoEnBinario);

Me da: DibujoEnBinario (_|): 110110000
Está bien.

Lo convierto a decimal, porque ese es el número de dibujo más grande que se mostrará, esa esa la cantidad que quiero repartir en los cuadros.

	DibujoaMostrar = 0;
	do {
		DibujoaMostrar = DibujoaMostrar+(Number(DibujoEnBinario.charat(NroDelCaracter))*Math.pow(2, DibujoEnBinario.length-1-NroDelCaracter));
		NroDelCaracter++;
	} while	(NroDelCaracter < Cuadraditos);
	DibujoaMostrar = Number(DibujoaMostrar);

Me da 432.

Disminucion = Math.floor(DibujoaMostrar/Cuadros);
// Se llama disminución porque se comenzará mostrando...
// el dibujo que según el modo conque los numero,
// es el último, y se irá disminuyendo.

No creo que el error esté ahí, tampoco.

Pero como vieron en la imagen, el 1er cuadro (arriba izquierda, los cuadros están numerados normal) no muestra una _| sino una
 _
|

¿Qué estoy haciendo mal?

// Generador de dibujos.
// 
// Se insertarán cuadros numerados así:
// 0 1
// 2 3
// En cada uno se insertarán cuadraditos numerados al revés (ver...
// Por qué cuadraditos numerados inversamente.txt por detalles).
// 
// Usada en InsertarCuadros sólo 1 vez
// (ergo podría no ser una función, pero por ahora simplifica):
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 |_ porque es el...
	// 1ero que tiene algún cuadradito pintado en cada fila y...
	// columna (en realidad el 1ero es el que tiene despintado el punto de unión, pero hay poca diferencia)
	// esto es para evitar que se salteén montones de dibujos.
	// Se averigua su número representante:
	DibujoEnBinario = "";
	NroDelCaracter = Cuadraditos;
	AnteriorCaracteraPintar = Cuadraditos-CuadraditosPorFila;
	// Esto genera la |
	do {
		NroDelCaracter--;
		if (NroDelCaracter != AnteriorCaracteraPintar) {
			DibujoEnBinario = DibujoEnBinario+1;
		} else {
			DibujoEnBinario = DibujoEnBinario+0;
			AnteriorCaracteraPintar = AnteriorCaracteraPintar-CuadraditosPorFila;
		}
	} while (NroDelCaracter > CuadraditosPorFila);
	// Esto la _
	do {
		NroDelCaracter--;
		DibujoEnBinario = DibujoEnBinario+0;
	} while (NroDelCaracter > 0);
	trace("DibujoEnBinario (_|): "+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);
	// Esa cantidad se dividirá según la cantidad de cuadros,
	// de modo que cada cuadro mostrará la misma cantidad de...
	// dibujos, pero distintos a los de otros cuadros:
	Disminucion = Math.floor(DibujoaMostrar/Cuadros);
	// Se llama disminución porque se comenzará mostrando...
	// el dibujo que según el modo conque los numero,
	// es el último, y se irá disminuyendo:
	// DibujoaMostrar = DibujoaMostrar-1;
	trace("DibujoaMostrar: "+DibujoaMostrar);
}
// Usada en InsertarCuadros una vez (totalmente innecesaria):
function ConvertiraBinarioInverso (numero) {
	trace(numero);
	// Averiguar cómo es en binario:
	DibujoEnBinario = "";
	while (numero>0) {
		DibujoEnBinario = DibujoEnBinario+numero%2;
		numero = Math.floor(numero/2);
	}
	// Agregar 0s a DibujoEnBinario si hacen falta:
	while (DibujoEnBinario.length<Cuadraditos) {
		DibujoEnBinario = DibujoEnBinario+0;
	}
	trace("DibujoEnBinario: "+DibujoEnBinario);
}
// Usada al inicio y cuando aumenta la cantidad de cuadraditos por fila:
function InsertarCuadros () {
	AjustarVariables();
	NroDelCuadroaColocar = 0;
	// Sus columnas y filas se cuentan desde 0 también:
	ColumnaDeCuadro = 0;
	FilaDeCuadro = 0;
	do {
		NombreDelCuadro = "Cuadro"+NroDelCuadroaColocar;
		attachMovie("sCuadro", NombreDelCuadro, NroDelCuadroaColocar);
		setProperty (NombreDelCuadro, _x, LargoDeCuadros*ColumnaDeCuadro+ColumnaDeCuadro*LargoDeCuadraditos);
		setProperty (NombreDelCuadro, _y, LargoDeCuadros*FilaDeCuadro+FilaDeCuadro*LargoDeCuadraditos);
		ColumnaDeCuadro++;
		if (ColumnaDeCuadro == CuadrosPorFila) {
			ColumnaDeCuadro = 0;
			FilaDeCuadro++;
		}
		// Se agregarán y distribuirán cuadraditos en el cuadro...
		// recién agregado, numerándolos del modo opuesto:
		NroDelCuadraditoaColocar = MaxCuadradito;
		// Sus columnas y filas se cuentan desde 0:
		ColumnaDeCuadradito = 0;
		FilaDeCuadradito = 0;
		// Se pintarán de modo que muestren el dibujo...
		// acorde a la división de dibujos; averiguarlo:
		ConvertiraBinarioInverso(DibujoaMostrar);
		ColumnaDeCuadradito = 0;
		FilaDeCuadradito = 0;
		do {
			eval(NombreDelCuadro).attachMovie("sCuadradito", "Cuadradito"+NroDelCuadraditoaColocar, NroDelCuadraditoaColocar);
			NombreDelCuadraditoSinNum = NombreDelCuadro+".Cuadradito";
			NombreDelCuadradito = NombreDelCuadraditoSinNum+NroDelCuadraditoaColocar;
			setProperty (NombreDelCuadradito, _x, ColumnaDeCuadradito*LargoDeCuadraditos);
			setProperty (NombreDelCuadradito, _y, FilaDeCuadradito*LargoDeCuadraditos);
			setProperty (NombreDelCuadradito, _width, LargoDeCuadraditos);
			setProperty (NombreDelCuadradito, _height, LargoDeCuadraditos);
			ColorDelCuadradito = new Color(NombreDelCuadradito);
			// Los números tomados del binario son los opuestos al cuadradito,
			// ya que los cuadraditos están numerados al revés.
			// Tomando el 1er caracter del binario y borrándolo para que...
			// en la próxima repetición se use el siguiente, se logra eso:
			NroDeColor = Number(DibujoEnBinario.charat(0));
			DibujoEnBinario = DibujoEnBinario.substring(1, DibujoEnBinario.length);
			if (NroDeColor == 0) {
				ColorDelCuadradito.setRGB(0);
			} else {
				ColorDelCuadradito.setRGB(0xFFFFFF);
			}
			// Esto es para modificar con más practicidad el color:
			set (NombreDelCuadro+".ColordeCuadradito"+NroDelCuadraditoaColocar, NroDeColor);
			ColumnaDeCuadradito++;
			if (ColumnaDeCuadradito == CuadraditosPorFila) {
				ColumnaDeCuadradito = 0;
				FilaDeCuadradito++;
			}
			NroDelCuadraditoaColocar--;
		} while (NroDelCuadraditoaColocar > -1);
		NroDelCuadroaColocar++;
		DibujoaMostrar = DibujoaMostrar-Disminucion;
		// trace("DibujoaMostrar: "+DibujoaMostrar);
	} while (NroDelCuadroaColocar < Cuadros);
}
// PorFila es también por columna:
CuadrosPorFila = 2;
// Debido a que en cierto chequeo se asume que...
// si el cuadradito no está en la parte inferior ni...
// superior entonces está en una fila intermedia,
// conviene que CuadraditosPorFila comience siendo >2:
CuadraditosPorFila = 3;

Probablemente obtengo el binario al revés y luego lo aplica al revés de eso, no sé, algunos cálculos me los dijo GPT ¿qué me conviene hacer?