Este código produce dibujos negros y blancos:
actions for fotograma 1
PixelesdeLargo = 1;
// En el frame 3 se repite:
function Variar () {
PixelaModificar = "ColordePixel"+Puntero;
ColordePixelaModificar = eval(PixelaModificar);
// ¿El pixel puede cambiar de color?
if (ColordePixelaModificar<1) {
// Sí, hacer los cambios:
set (PixelaModificar, ColordePixelaModificar+1);
Col = new Color("Pixel"+Puntero);
Col.setRGB(parseInt(0, 16));
// Para juzgar: ¿El dibujo es repetido?
SumadePintados = SumadePintados+1;
// ¿El píxel está en el extremo derecho o abajo, donde no había en una hoja más chica?
if (Puntero/PixelesdeLargo == Math.floor(Puntero/PixelesdeLargo) or Puntero>MinPixelInferior) {
// Sí, actualizar SumadePintadosNuevos:
SumadePintadosNuevos = SumadePintadosNuevos+1;
}
// ¿El dibujo tiene píxeles donde no había en una hoja más chica...
// y son al menos (PixelesdeLargo) píxeles?
if (SumadePintadosNuevos>0 && SumadePintados>MinSumadePintados) {
// Sí, hacer dibujo y dar tiempo para verlo:
Puntero = MaxPosiciondePuntero;
play ();
} else {
// No, el dibujo es repetido, no mostrarlo y hacer otro:
Puntero = MaxPosiciondePuntero;
Variar();
}
} else {
// El pixel no puede cambiar de color, resetearlo:
set (PixelaModificar, 0);
Col = new Color("Pixel"+Puntero);
Col.setRGB(parseInt("FFFFFF", 16));
SumadePintados = SumadePintados-1;
// ¿El píxel está en el extremo derecho o abajo, donde no había en una hoja más chica?
if (Puntero/MaxPosiciondePuntero == Math.floor(Puntero/MaxPosiciondePuntero) or Puntero>MinPixelInferior) {
// Sí, actualizar SumadePintadosNuevos:
SumadePintadosNuevos = SumadePintadosNuevos-1;
}
// ¿Hay un pixel anterior?
if (Puntero>1) {
// Sí, apuntar a ese:
Puntero = Puntero-1;
// Continuar haciendo el dibujo:
Variar();
} else {
// No, aumentar tamaño de hoja y reiniciar.
gotoAndPlay (2);
}
}
}
actions for fotograma 2
PixelesdeLargo = PixelesdeLargo+1;
// Colocados:
Pixeles = 0;
DistanciaEntrePixeles = 384/PixelesdeLargo;
PosicionX = 64-DistanciaEntrePixeles;
EnlaFilaActual = 0;
PosicionY = 0;
MaxPosiciondePuntero = PixelesdeLargo*PixelesdeLargo;
Puntero = MaxPosiciondePuntero;
// Píxeles pintados:
SumadePintados = 0;
MinSumadePintados = PixelesdeLargo-1;
MinPixelInferior = PixelesdeLargo*(PixelesdeLargo-1);
// Píxeles pintados que no estaban en hojas de menos píxeles:
SumadePintadosNuevos = 0;
// Agregar píxeles en blanco:
do {
Pixeles = Pixeles+1;
if (EnlaFilaActual<PixelesdeLargo) {
EnlaFilaActual = EnlaFilaActual+1;
PosicionX = PosicionX+DistanciaEntrePixeles;
} else {
PosicionX = 64;
EnlaFilaActual = 1;
PosicionY = PosicionY+DistanciaEntrePixeles;
}
trace ("El pixel "+Pixeles+" se colocó en "+PosicionX+", "+PosicionY);
attachMovie("mPixel", "Pixel"+Pixeles, Pixeles);
setProperty ("Pixel"+Pixeles, _x, PosicionX);
setProperty ("Pixel"+Pixeles, _y, PosicionY);
setProperty ("Pixel"+Pixeles, _width, DistanciaEntrePixeles);
setProperty ("Pixel"+Pixeles, _height, DistanciaEntrePixeles);
} while (Pixeles<MaxPosiciondePuntero);
stop ();
actions for fotograma 3
stop ();
actions for Vacío
onClipEvent (enterFrame) {
_level0.Variar();
}
actions for fotograma 4
stop ();
actions for fotograma 5
gotoAndPlay (3);
La función se repite dentro de si misma, supongo que un do while sería mejor, no me di cuenta, pero ese no es el tema, el tema es que hago algo así:
Si ColordePixel4 puede colorearse, hacerlo y mostrar dibujo.
sino resetearlo. Si el 3 puede colorearse, hacerlo y mostrar dibujo.
sino resetearlo. Si el 2...
Y así hasta el 1.
Cuando hay más píxeles, eso se repite más veces.
¿Qué otro método más rápido sería mejor? ¿es posible, cómo? Me refiero a algo que varíe todo lo necesario sin tener que variar un puntero y repetir un while y estar reseteando 1 cosa a la vez...
Si un humano quiere escribir una lista así:
0001
0010
0011
0100
etc
No sé bien cómo se hace, pero es como que se mira dónde hay que sumar y si los valores a la derecha están al máximo se resetean. O sea, desde la izquierda se busca el 1er valor que no esté al máximo, se lo aumenta y se resetean los a la derecha suyo. Pero nosotros los humanos es como que no necesitamos mirar desde la izquierda, ya más o menos podemos anticipar en dónde estará el próximo número que debe aumentarse ¿o no?
No sé, a mí esa manera me resulta muy lenta, variando las cosas de a una, siento que debe haber algo mejor.
Una posibilidad sería hacer sumas normales y luego convertirlo en el valor que se precisa:
0 -> 0000
1 -> 0001
2 -> 0010
Hacer la conversión no creo que tarde mucho ¿pero si los posibles valores fuesen más de 9 o de 10? Por eso uso varias variables, no sólo 1. Uds supongo que usan arrays, pero creo que en el fondo es igual. Si son menos de 9 o 10 posibles valores la conversión es literal:
ColordePixel4 = Caracter4
ColordePixel3 = Caracter3
etc
Sino creo que se deben hacer operaciones matemáticas para cada uno y eso implica usar un do while...
Hay que inventar algo mejor o díganme qué hay que no sé xD
Para colmo, en el caso particular de los dibujos, tengo que variar unas variables y luego debo variar colores en base a ellas, creo que lo puedo hacer más rápido, pero el punto es que tendría que usar un do while también (edit: quizá no, probaré).
Tampoco es cuestión de estar haciendo los dibujos desde 0 en cada caso, yo intento que se varíen sólo los pixeles que deben variarse.
¿Ideas, info?
