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);
}
