Sabía del mono, pero siendo unos puntitos de colores, no creí que fuese tan improbable.
Supongo que los dibujos "buenos" tienen ciertas reglas, pero tampoco logré mucho pensando cuales son.
Las imágenes se generan poniendo objetos en la pantalla, cuadraditos, y asignándoles colores al azar, no tiene mucha ciencia digamos. Te paso el código pero está un poco desparramado:
// Algunas cosas se cuentan desde 0, otras desde 1;
// se indicará las que se cuenten desde 0, cuando no es obvio;
// las demás son desde 1.
function ConvertirHexEnDec (Hexadecimal) {
return parseInt(Hexadecimal, 16);
}
function ConvertirDecEnHex (Decimal) {
Hexadecimal = Decimal.toString(16).toUpperCase();
if (Hexadecimal.length == 1) {
Hexadecimal = "0"+Hexadecimal;
}
return Hexadecimal;
}
function ActualizarColorDelFondo () {
// Formar el color:
ColorDelFondo = Rojo+Verde+Azul;
// Actualizar el color del objeto:
ColorDelObjetoFondo.setRGB(parseInt(ColorDelFondo, 16));
}
function Iniciar () {
// Cada cuadro será un dibujo, así que esto...
// luego sería MaxDibujo:
MaxCuadro = DibujosPorFila*DibujosPorFila;
// Contando desde 0:
ColumnaCentral0 = (CuadraditosPorFila-1)/2;
// Columna izquierda más cercana al centro:
ColumnaCentralIzquierda0 = Math.floor(ColumnaCentral0-0.5);
// Lo mismo pero derecha:
ColumnaCentralDerecha0 = Math.floor(ColumnaCentral0+1);
// Contando desde 1:
// ColumnaCentralDerecha1 = ColumnaCentralDerecha0+1;
ColumnaCentral1 = (CuadraditosPorFila+1)/2;
MaxCuadradito = CuadraditosPorFila*CuadraditosPorFila;
LargoDeCuadraditos = 384/(CuadraditosPorFila*DibujosPorFila+GrosorDeSeparacionesxC*(DibujosPorFila-1));
// LargoDeCuadraditos = 384/(CuadraditosPorFila*DibujosPorFila+DibujosPorFila-1);
LargoDeDibujos = CuadraditosPorFila*LargoDeCuadraditos;
GrosorDeSeparaciones = GrosorDeSeparacionesxC*LargoDeCuadraditos;
DistintasMutaciones = Math.floor(MaxCuadro/CuadraditosPorFila);
Resto = MaxCuadro%CuadraditosPorFila;
// Agregar y distribuir cuadros (que serán dibujos):
CuadrosColocados = 0;
// Sus columnas y filas se cuentan desde 0:
Columna = 0;
Fila = 0;
do {
CuadrosColocados++;
// mCuadro tiene código.
attachMovie("mCuadro", "Dibujo"+CuadrosColocados, CuadrosColocados);
setProperty ("Dibujo"+CuadrosColocados, _x, LargoDeDibujos*Columna+Columna*GrosorDeSeparaciones);
setProperty ("Dibujo"+CuadrosColocados, _y, LargoDeDibujos*Fila+Fila*GrosorDeSeparaciones);
Columna = Columna+1;
if (Columna == DibujosPorFila) {
Columna = 0;
Fila = Fila+1;
}
// Un ID usado en el botón de los dibujos:
set ("Dibujo"+CuadrosColocados+".ID", CuadrosColocados);
} while (CuadrosColocados<MaxCuadro);
}
fscommand ("fullscreen", "true");
DibujosPorFila = 4;
CuadraditosPorFila = 6;
// Esto es en cuadraditos, por ejemplo 2 significa que...
// mide lo mismo que 2 cuadraditos:
GrosorDeSeparacionesxC = 1;
// Esto se refiere al color de los cuadraditos:
PosiblesColores = [0xFFFFFF, 0xFF0000, 0];
// Para mostrarlos en cuadros de texto:
ShowerDePosibleColor0 = "FFFFFF";
ShowerDePosibleColor1 = "FF0000";
ShowerDePosibleColor2 = "000000";
Numero = 2;
do {
Numero++;
set ("ShowerDePosibleColor"+Numero, "Ninguno");
} while (Numero<9);
//
ColorSugerido1 = 0xFFFFFF;
ColorSugerido2 = 0;
ColorSugerido3 = 0xFF0000;
ColorSugerido4 = 0x00FF00;
ColorSugerido5 = 0x0000FF;
ColorSugerido6 = 0xFFFF00;
ColorSugerido7 = 0x00FFFF;
ColorSugerido8 = 0xFF00FF;
ColoresRequeridos = 3;
ColorDelFondo = "999999";
ColorDelObjetoFondo = new Color(Fondo);
ColorDelObjetoFondo.setRGB(parseInt(ColorDelFondo, 16));
// Para se puedan cambiar las opciones:
Frame = 2;
Iniciar();
Código en mCuadro:
// 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--;
}
// Asignar la cantidad requerida:
ColoresAsignados = 0;
MaxColumnaElegible1 = Math.floor(_level0.ColumnaCentral1);
do {
// Elegir cuadradito al azar:
ColumnaElegida = random(MaxColumnaElegible1)+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);
// El botón queda del mismo tamaño que este dibujo:
setProperty (Boton, _width, getProperty(this, _width));
setProperty (Boton, _height, getProperty(this, _height));
Botones en cuadros (para mutar dibujos):
on (release) {
// Los dibujos serán como el de encima de este botón:
// Dibujo a modificar, esto irá aumentando:
Dibujo = 1;
// Usado más adelante:
ModificacionesRequeridas = 1;
// Repetir para el dibujo 1, 2, etc:
while (Dibujo < _level0.MaxCuadro+1) {
// Este if es porque el dibujo a copiar no necesita...
// ser modificado, eso sería como sustituirse por él mismo:
if (Dibujo != _parent.ID) {
Cuadradito = 0;
// Repetir hasta que todo cuadradito se haya copiado:
do {
Cuadradito++;
ColoraCopiar = new Color("_parent.Cuadradito"+Cuadradito);
ColoraSustituirse = new Color("_level0.Dibujo"+Dibujo+".Cuadradito"+Cuadradito);
ColoraSustituirse.setRGB(ColoraCopiar.getRGB());
} while (Cuadradito<_level0.MaxCuadradito);
// Los dibujos mutarán:
// De cada dibujo copia, variarán cuadraditos al azar,
// de 1 hasta CuadraditosPorFila,
// aumentando por dibujo hacia derecha y abajo.
// Pero la cantidad de colores en el dibujo...
// debe mantenerse, así que si se eligen los...
// únicos cuadraditos que tienen cierto color...
// (por ejemplo si son los únicos verdes),
// entonces la elección debe repetirse.
GrupoValido = "No confirmado";
// Repetir hasta que el grupo elegido sea válido:
do {
// Repetir hasta elegir...
// la cantidad requerida de cuadraditos:
CuadraditosElegidos = 0;
do {
// Cuando se elige un cuadradito al azar,
// puede que sea uno ya elegido.
// Para evitarlo, los elegidos se guardan...
// en una lista, y cuando se elige otro...
// se mira que no esté en la lista,
// sino se elige otro:
trace("Se elegirá un cuadradito del dibujo "+Dibujo);
NroDeCuadraditoElegido = random(_level0.MaxCuadradito)+1;
trace("El nro: "+NroDeCuadraditoElegido);
trace("Se verá si ya fue elegido.");
// Esto puede cambiar:
ElegidoValido = "Sí";
PunteroDeElegidos = 1;
// Ver si NroDeCuadraditoElegido está en la lista de elegidos:
while (PunteroDeElegidos <= CuadraditosElegidos) {
trace("Comparando con el nro "+PunteroDeElegidos+" de la lista de elegidos.");
if (NroDeCuadraditoElegido == eval("CuadraditoElegido"+PunteroDeElegidos)) {
trace("Ya fue elegido, se volverá a elegir otro en su lugar.");
ElegidoValido = "No";
// Para que no siga mirando la lista:
PunteroDeElegidos = CuadraditosElegidos+1;
}
PunteroDeElegidos++;
}
if (ElegidoValido == "Sí") {
CuadraditosElegidos++;
trace("Ok, la cantidad de cuadraditos elegidos es "+CuadraditosElegidos);
// Agregar el cuadradito a la lista de elegidos:
set("CuadraditoElegido"+CuadraditosElegidos, NroDeCuadraditoElegido);
}
} while (CuadraditosElegidos<ModificacionesRequeridas);
trace("Grupo completado, se verá que sea válido");
// Obtener el color del 1er cuadradito elegido:
ColorDelElegido = new Color("_level0.Dibujo"+Dibujo+".Cuadradito"+CuadraditoElegido1);
ColorDelElegido = ColorDelElegido.getRGB();
// Ver si otro de los elegidos tiene un color distinto a ese:
PunteroDeElegidos = 2;
while (PunteroDeElegidos <= CuadraditosElegidos) {
// Obtener color del elegido indicado por el puntero:
ColorDelIndicado = new Color("_level0.Dibujo"+Dibujo+".Cuadradito"+eval("CuadraditoElegido"+PunteroDeElegidos));
ColorDelIndicado = ColorDelIndicado.getRGB();
if (ColorDelElegido != ColorDelIndicado) {
trace ("Los colores de los elegidos son distintos, el grupo es válido");
GrupoValido = "Sí";
// Para que no siga mirando la lista:
PunteroDeElegidos = CuadraditosElegidos+1;
}
PunteroDeElegidos++;
}
if (GrupoValido == "No confirmado") {
trace ("Los colores de los elegidos son iguales, se verá si son iguales a alguno no elegido");
// Comparar el color con los no elegidos:
CuadraditoaComparar = 1;
// Esto es para evitar que se comparen con ellos mismos:
PrimerElegidoNoComparado = 1;
do {
if (CuadraditoaComparar != eval("CuadraditoElegido"+PrimerElegidoNoComparado)) {
// El cuadradito a comparar no es uno de los elegidos,
// compararlo entonces:
// Obtener color del indicado por el puntero:
ColoraComparar = new Color("_level0.Dibujo"+Dibujo+".Cuadradito"+CuadraditoaComparar);
ColoraComparar = ColoraComparar.getRGB();
if (ColorDelElegido == ColoraComparar) {
// Los colores que se comparan son iguales,
// los elegidos no son los únicos con ese color,
// el grupo elegido es válido.
trace("Los cuadraditos no son los únicos con su color, el grupo es válido");
GrupoValido = "Sí";
// Para que no siga mirando la lista:
CuadraditoaComparar = _level0.MaxCuadradito;
}
} else {
// Se iba a comparar consigo mismo,
// saltearlo y aumetar el PrimerElegidoNoComparado:
PrimerElegidoNoComparado++;
}
CuadraditoaComparar++;
} while (CuadraditoaComparar < _level0.MaxCuadradito);
}
// Esto es sólo para que los mensajes sean más claros:
if (GrupoValido == "No confirmado") {
trace("El grupo no es válido, se volverá a elegir");
}
} while (GrupoValido == "No confirmado");
// Repetir hasta que el dibujo tenga...
// la cantidad requerida de colores:
trace("Variando colores de los elegidos.");
do {
NrodeElegidoaModificar = 0;
// Repetir hasta haber modificado...
// la cantidad requerida:
do {
NrodeElegidoaModificar++;
CuadraditoaCambiar = "_level0.Dibujo"+Dibujo+".Cuadradito"+eval("CuadraditoElegido"+NrodeElegidoaModificar);
ColoraSustituirse = new Color(CuadraditoaCambiar);
// A esto lo convierto a String porque...
// lo debo comparar con un string y es más fácil así:
SavedeColoraSustituirse = ""+(ColoraSustituirse.getRGB());
// trace ("SavedeColoraSustituirse: "+SavedeColoraSustituirse);
// Repetir mientras el color no cambie:
do {
NuevoColor = _level0.PosiblesColores[random(_level0.PosiblesColores.length)];
trace ("NuevoColor: "+NuevoColor);
} while (NuevoColor == SavedeColoraSustituirse);
ColoraSustituirse.setRGB(NuevoColor);
trace("El color del cuadradito "+eval("CuadraditoElegido"+NrodeElegidoaModificar)+" era "+SavedeColoraSustituirse+" y ahora es "+NuevoColor);
} while (NrodeElegidoaModificar < CuadraditosElegidos);
trace("Se modificaron todos los elegidos.");
trace("Contando cuántos colores tiene el dibujo.");
ColoresDelDibujo = 0;
NrodeCuadraditoaChequear = 0;
do {
NrodeCuadraditoaChequear++;
// Captar color del cuadradito:
ColoraChequear = new Color("_level0.Dibujo"+Dibujo+".Cuadradito"+NrodeCuadraditoaChequear);
ColoraChequear = ColoraChequear.getRGB();
// Esto puede cambiar:
ColorDistinto = "Sí";
// Ver si el color captado está en la lista:
PunteroDeColores = 0;
while (PunteroDeColores < ColoresDelDibujo) {
PunteroDeColores++;
if (ColoraChequear == eval("ColorEnLista"+PunteroDeColores)) {
trace ("El color ya está en la lista.");
ColorDistinto = "No";
// Para que no siga mirando la lista:
PunteroDeColores = ColoresDelDibujo;
}
}
// Si el color no está en la lista:
if (ColorDistinto == "Sí") {
// Agregarlo:
ColoresDelDibujo++;
set("ColorEnLista"+ColoresDelDibujo, ColoraChequear);
trace("El cuadradito "+NrodeCuadraditoaChequear+" fue el 1ero de un color no anotado: "+ColoraChequear);
trace("La cantidad de colores captada hasta ahora es "+ColoresDelDibujo);
}
} while (NrodeCuadraditoaChequear < _level0.MaxCuadradito && ColoresDelDibujo < _level0.ColoresRequeridos);
} while (ColoresDelDibujo < _level0.ColoresRequeridos);
}
Dibujo++;
if (ModificacionesRequeridas <= _level0.Resto) {
ModificacionesRequeridas = Math.floor((Dibujo-1)/(_level0.DistintasMutaciones+1))+1;
} else {
ModificacionesRequeridas = Math.floor((Dibujo-1-_level0.Resto*(_level0.DistintasMutaciones+1))/(_level0.DistintasMutaciones))+1+_level0.Resto
}
}
}
No sé si falta alguna parte importante.
Podría ser que las mutaciones puedan mejorarse. Hace tiempo que no vicho eso. Mi idea fue que si los dibujos tienen 5 cuadraditos de largo, en el dibujo de más arriba izquierda mutara sólo uno, en el de abajo derecha 5, y en el medio fuese intermedio, incrementando.
