Estoy haciendo un programa que genera dibujos un poco configurables. Un ejemplo:
Buscándole errores, hallé este:
Si:
- Le pongo 10 colores posibles.
- Pongo que la mínima cantidad de colores por dibujo sea 10 (el botón para eso no se ve en la imagen).
- Pongo que los dibujos tengan 4 cuadraditos de largo y alto.
Entonces se tranca.
Pero no es por el error que podrían calcular. Explico ese:
Cuando el dibujo tiene 4 cuadraditos de largo, están numerados así:
0 1 2 3
4 5 6 7
8 9 10 11
12 13 14 15
Debe haber 10 colores, pero como el dibujo es simétrico, de esos 16 cuadraditos, sólo 8 pueden tener un color único, así que no habrá 10 colores.
No es ese el error, porque en el botón de bajar la cantidad de cuadraditos por fila yo le pongo que si ahora es 4, la cantidad de colores requeridos baje a 8.
El problema es algo en la selección de a qué cuadraditos se les pone color, porque siempre elige el 1, 5, 9 y 13, es decir los de la columna 2, cuando debería poder elegir también los de la 1.
No sé por qué sólo elige los de la 2 en ese caso, no probé con otras configuraciones pero con esta es la única con que me ha fallado. A ver si ven la causa.
Esto está bien, o al menos no es aquí donde se tranca:
// Agregar, distribuir cuadraditos y asignarles un color,
// de modo que queden coloreados simétricamente;
// espejo así ( | ):
CuadraditosColocados = 0;
// Sus columnas y filas se cuentan desde 0:
Columna = 0;
Fila = 0;
trace ("Asignando colores para un nuevo dibujo");
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);
// Si el cuadradito está a la izquierda o en el centro:
if (Columna<_level0.ColumnaCentralDerecha0) {
// Asignar color al azar:
ColorDeCuadradito.setRGB(_level0.PosiblesColores[random(_level0.PosiblesColores.length)]);
// Incrementar el contador de cuadraditos de ese color:
Resumen = "Color"+ColorDeCuadradito;
set (Resumen, eval(Resumen)+1);
} else {
// trace ("Tiene simetría el "+CuadraditosColocados);
// Asignar el mismo color que su simétrico:
CuadraditoReflejo = (2*(Fila+1)-1)*_level0.CuadraditosPorFila+1-CuadraditosColocados;
ColoraReflejar = new Color("Cuadradito"+CuadraditoReflejo);
ColorDeCuadradito.setRGB(ColoraReflejar.getRGB());
}
Columna++;
if (Columna == _level0.CuadraditosPorFila) {
Columna = 0;
Fila = Fila+1;
// CuadraditoCentralDeLaFila = (_level0.CuadraditosPorFila*Fila+1+_level0.CuadraditosPorFila*(Fila+1))/2;
}
} while (CuadraditosColocados<_level0.MaxCuadradito);
// El dibujo debe tener la cantidad de colores indicada por...
// _level0.ColoresRequeridos. Por eso, y por practicidad,
// se asignará a cuadraditos al azar (evitando reelegirlos),
// esa cantidad de colores (ordenados al azar). Por ejemplo...
// a uno se le asignará el color nro 3, a otro el 1, etc.
// También se intentará conservar la simetría,
// así que los elegidos sólo estarán en el centro o en la...
// izquierda, en cuyo caso se copiará a la derecha:
// Reordenar al azar los colores para elegirlos sin repeticiones:
ColoresReordenados = _level0.PosiblesColores.concat();
Color1aReubicarse = ColoresReordenados.length-1;
while (Color1aReubicarse > 0) {
Color2aReubicarse = random(Color1aReubicarse+1);
SaveDelColor1 = ColoresReordenados[Color1aReubicarse];
ColoresReordenados[Color1aReubicarse] = ColoresReordenados[Color2aReubicarse];
ColoresReordenados[Color2aReubicarse] = SaveDelColor1;
Color1aReubicarse--;
}Se tranca en el while de aquí, no llega a asignar 8 colores porque siempre elige los 4 que mencioné:
// Asignar la cantidad requerida:
ColoresAsignados = 0;
MaxColumnaElegible = Math.floor(_level0.ColumnaCentral0);
do {
// Elegir cuadradito al azar:
ColumnaElegida = random(MaxColumnaElegible)+1;
// Esto es contando desde 0 por eficiencia al calcular:
FilaElegida = random(_level0.CuadraditosPorFila);
CuadraditoElegido = ColumnaElegida+_level0.CuadraditosPorFila*FilaElegida;
trace ("CuadraditoElegido: "+CuadraditoElegido);
// Esto puede cambiar:
ElegidoValido = "Sí";
// Ver si ya fue elegido:
PunteroDeElegidos = 0;
while (ColoresAsignados>PunteroDeElegidos) {
PunteroDeElegidos++;
trace ("Comparando con el "+PunteroDeElegidos+", que es: "+eval("Elegido"+PunteroDeElegidos));
if (eval("Elegido"+PunteroDeElegidos) == CuadraditoElegido) {
trace ("Repetido");
// Ya elegido, repetir el proceso para elegir otro:
ElegidoValido = "No";
// Terminar este loop:
PunteroDeElegidos = ColoresAsignados;
}
}
if (ElegidoValido == "Sí") {
ColoresAsignados++;
// Guardar en la lista al cuadradito elegido:
set ("Elegido"+ColoresAsignados, CuadraditoElegido);
trace ("El recién elegido fue guardado en: Elegido"+ColoresAsignados);
// Asignarle el color:
ColorDeCuadradito = new Color("Cuadradito"+CuadraditoElegido);
ColorDeCuadradito.setRGB(ColoresReordenados[ColoresAsignados-1]);
trace ("Se le asignó el color "+ColoresReordenados[ColoresAsignados-1]);
trace ("La cantidad de colores asignada es "+ColoresAsignados);
// Si el cuadradito no está en la columna central:
if (ColumnaElegida != _level0.ColumnaCentral1) {
// Se refleja:
CuadraditoReflejo = (2*(FilaElegida+1)-1)*_level0.CuadraditosPorFila+1-CuadraditoElegido;
trace ("CuadraditoReflejo: "+CuadraditoReflejo);
ColorDelReflejo = new Color("Cuadradito"+CuadraditoReflejo);
ColorDelReflejo.setRGB(ColorDeCuadradito.getRGB());
}
}
} while (ColoresAsignados<_level0.ColoresRequeridos);¿Qué está mal?
Edit: Esto parece mal:
ColumnaElegida = random(MaxColumnaElegible)+1;
MaxColumnaElegible en este caso es 1, ya me fijé, y tiene sentido:
0123
SSNN
SSNN
SSNN
SSNN
0 o 1 debe elegirse. Entonces, como el random sólo puede ser 1 valor, es 0. Luego se le suma 1, y por eso siempre elige la columna 1.
La solución parece clara: Poner ese +1 dentro del paréntesis.
Pero si hago eso, al iniciar el programa los dibujos no son simétricos.
Pienso que puede deberse a que a veces conté las columnas desde 0 y a veces desde 1.
Edit 2:
Hice una prueba mejor corrigiendo el supuesto error. En uno de esos casos dice:
CuadraditoElegido: 8
CuadraditoReflejo: 13
O sea:
0 1 2 3
4 5 6 7
8 9 10 11
12 13 14 15
Se calcula mal el reflejo...
Seguiré revisando, pero si ven el error avisenme.
