Confusión en cuanto a cambiar colores de películas en Flash.
(1/1)
Tachikomaia:
Intento hacer un generador de posibles dibujos, para eso se va variando qué pixel está negro o blanco, creo que se puede resumir en esto:
Código
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(000000, 16));
Los nombres de las variables son confusos, no sé cómo mejorarlos, pero hay un pixel del cual se mira si puede cambiar de color (a negro, 1, 0 es blanco), y en tal caso se lo modifica.
El problema es que, supongo, se debería hacer de forma más directa, pero no sé cómo. Tengo ColordePixel1, ColordePixel2, etc, la cantidad de variables así va aumentando, todas son 0 o 1, y eso luego se usa para determinar si el pixel (Pixel1, Pixel2, etc) debe volverse negro o blanco. Para hacer ese cambio se crea una variable que es como una propiedad de una película (Pixel1, o Pixel2, etc), y luego se le asigna un valor que sería el color. También resulta curioso que al redefinir esa variable apuntando a otra película, el color de las películas anteriores que fueron definidas por ella no cambia. No me perjudica, de hecho podría ser mejor tener un montón de variables con 0 o 1, en vez de un montón con FFFFFF y 000000, pero al menos por curiosidad quisiera saber si se puede hacer de modo más directo y que me expliquen mejor qué hacen las 2 últimas líneas del código.
Lo normal, digamos, debería ser algo así:
Código:
Apuntar a un pixel.
Si su color es FFFFFF
Ahora es 000000
Yo al principio creo variables para que las referencias a nombres o valores queden grabadas, ya que se usan más adelante, así no se tienen que concatenar cosas de nuevo, ese no es el problema. Lo del código que puse al inicio es como:
Código:
Apuntar a un pixel.
Si su color es 0
Ahora es 1
Crear una variable que marca el color del pixel.
Asignarle 000000
¿Cómo se simplifica? Tengo 2 variables marcando el color, no puede ser. Una es eterna pero de por sí no lo cambia, y la otra varia a qué pixel apunta...
EdePC:
No sé si entiendo bien tu pregunta pero estimo que quieres cambiar el color de un MovieClip dependiendo del color que tenga actualmente, para esto puedes recuperar el color con getRGB que tiene SIEMPRE Y CUANDO al momento de crearlos usaste setRGB
Por ejemplo yo puedo crear 25 cuadritos uno después de otro como si fuera un tablero, cada cuadrito de un color aleatorio entre blanco (0xFFFFFF) y negro (0x000000 o simplemente 0), luego reviso el color de cada cuadrito y comparo si es negro (0), si lo es le cambio a blanco (0xFFFFFF), sino lo cambio a negro (0)
Crear cuadritos:
Código
var col = 0;
var row = 0;
for (var i = 0; i < 25; i++) {
_root.attachMovie( "cuadro", "cuadro"+i, i);
setProperty ("cuadro" + i, _x, col * 100);
setProperty ("cuadro" + i, _y, row * 100);
c = new Color("cuadro" + i);
c.setRGB(genColor());
col++;
if (col > 4) {
col = 0;
row++;
}
}
function genColor() {
var colores = [0xFFFFFF, 0x000000];
return colores[random(colores.length)];
}
Cambiar color:
Código
for (var i = 0; i < 25; i++) {
var c = new Color("cuadro" + i);
if (c.getRGB() == 0) { //Si es negro
c.setRGB(0xFFFFFF); //le ponemos blanco
} else {
c.setRGB(0) //Sino le ponemos negro
}
}
Cita de: Tachikomaia en 29 Marzo 2024, 12:00 pm
... y que me expliquen mejor qué hacen las 2 últimas líneas del código.
La primera de esas dos crea una Objeto Color para la instancia (vínculo) de un MovieClip y le llama Col
La segunda especifica un color en formato RGB Hexadecimal (RRGGBB RedGreenBlue RojoVerdeAzul) para el Objeto Col creado anteriormente y como este está vinculado a una Instancia de un MovieClip, pues afecta a ese MovieClip
Están usando parseInt() para convertir un texto dado en base 16 (hexadecimal) a número, pero no es necesario porque directamente puedes especificar un número hexadecimal, es decir 0xFFFFFF para blanco y 0x000000 (o solo 0) para negro
El parseInt() está pensado más para cuando debes recibir un texto y convertirlo en número, por ejemplo de un cuadro de texto (txtColor) donde debe indicarlo el usuario y presionar un botón, si dicho usuario quiere el color verde pondrá: 00FF00 o FF00 en su cuadro de texto, luego tendrías que recuperar ese texto y convertirlo a número indicando que está en base 16 (hexadecimal)
Código
on (release) {
c = new Color(c1);
c.setRGB(parseInt(txtColor, 16));
}
Tachikomaia:
Estoy asombrado por la simpleza conque generas los píxeles, mi código tiene variables que debo ver si sobran o no, luego quizá te lo muestre para que, en lo posible, me digas cómo simplificarlo, si no me doy cuenta, o como anécdota.
Lo del array también está interesante, pensaré en aplicarlo.
Bien, todo bien. ¿Pero no te parece que sería más fácil algo como:
setProperty ("cuadro" + i, _color, FFFFFF);
? Si existiera eso. Me resulta absurdo que requiera tanto trámite. El cuadradito ya tiene un color, como bien has dicho y no sabía sería cuestión de captar cual con get y según eso cambiárselo, como cuando se le cambia la posición u otra propiedad. Uno no hace:
c = new XPosition("cuadro" + i);
c.set(genXPosition());
en vez de eso se pone:
setProperty ("cuadro" + i, _x, genXPosition());
Tal vez tiene que ver con la necesidad de que sea hexadecimal, no sé, asumo que es una imperfección de Flash. No me gustan los trámites absurdos xD
Bueno, voy a cambiar cosas y luego comento, pero no sé cuánto tardaré, tal vez 3 días.
Tachikomaia:
Quité el Parseint y simplifiqué el cambio de colores como me dijiste, dejo los archivos a quien le interesen:
https://drive.google.com/file/d/1z3lL4wWYmJ_SCZcZliXx7fK8dH4TdOUS/view?usp=sharing
Incluye la versión anterior y la nueva (simplificando).
El objeto Vacío en frame 3 está en la punta inferior derecha, tiene la función Variar.
Como alternativa, el código:
Código
actions for fotograma 1
// Los píxeles mayores están abajo en la derecha, ejemplo:
// 12
// 34
PixelesdeLargo = 1;
// En F3 se repite:
function Variar () {
// trace("Variando");
PixelaModificar = "Pixel"+Puntero;
ColorDePixel = new Color(PixelaModificar);
// trace("Color: "+ColorDePixel.getRGB());
// ¿El pixel puede cambiar de color? ¿es blanco?
if (ColorDePixel.getRGB() == 0xFFFFFF) {
// Sí, cambiarlo:
ColorDePixel.setRGB(0);
// trace ("Se pintó el pixel "+PixelaModificar);
// Para juzgar: ¿El dibujo es repetido? o:
// ¿El dibujo tiene píxeles pintados en toda columna y fila?
// Averiguar la columna del pixel:
Columna = 1+(Puntero-1)%PixelesdeLargo;
// trace ("Columna: "+Columna);
// Esto se usa para evitar repeticiones de concatenaciones y simplificarlas:
ColumnaRelevante = "PintadosenC"+Columna;
// Incrementar contador de píxeles pintados en ella:
set (ColumnaRelevante, eval(ColumnaRelevante)+1);
// Averiguar la fila del pixel:
Fila = Math.ceil(Puntero/PixelesdeLargo);
// trace ("Fila: "+Fila);
// Esto se usa para evitar repeticiones de concatenaciones y simplificarlas:
FilaRelevante = "PintadosenF"+Fila;
// Incrementar contador de píxeles pintados en ella:
set (FilaRelevante, eval(FilaRelevante)+1);
// trace ("Pintados: "+ColordePixel1+" "+ColordePixel2+" "+ColordePixel3+" "+ColordePixel4);
// trace ("PintadosenC1: "+PintadosenC1);
// trace ("PintadosenC2: "+PintadosenC2);
// trace ("PintadosenF1: "+PintadosenF1);
// trace ("PintadosenF2: "+PintadosenF2);
// Para juzgar: ¿El dibujo tiene píxeles pintados en toda columna y fila?
Puntero2 = 0;
Repetido = "N";
do {
Puntero2 = Puntero2+1;
// ¿La columna Puntero2 no tiene algún pixel pintado?
if (eval("PintadosenC"+Puntero2)<1) {
// trace (eval("PintadosenC"+Puntero2)+ "< 1");
Repetido = "S";
} else if (eval("PintadosenF"+Puntero2)<1) {
// La fila Puntero2 no tiene algún pixel pintado.
// trace (eval("PintadosenF"+Puntero2)+ "< 1");
Repetido = "S";
}
} while (Repetido == "N" && Puntero2<PixelesdeLargo);
// Preparar Puntero para la próxima generación:
Puntero = MaxPosiciondePuntero;
// ¿El dibujo tiene píxeles pintados en toda columna y fila?
if (Repetido == "N") {
// trace (" Mostrando dibujo.");
ContadorDeDibujos = ContadorDeDibujos+1;
} else {
// No, el dibujo es repetido, no mostrarlo y hacer otro:
// trace (" Repetido, salteándolo.");
Variar();
}
} else {
// El pixel no puede cambiar de color, resetearlo:
ColorDePixel.setRGB(0xFFFFFF);
// trace ("Se reseteó el pixel "+PixelaModificar);
// Actualizar los valores de PintadosenC y PintadosenF:
// Averiguar la columna del pixel:
Columna = 1+(Puntero-1)%PixelesdeLargo;
// Esto se usa para evitar repeticiones de concatenaciones y simplificarlas:
ColumnaRelevante = "PintadosenC"+Columna;
// Disminuir contador de píxeles pintados en ella:
set (ColumnaRelevante, eval(ColumnaRelevante)-1);
// Averiguar la fila del pixel:
Fila = Math.ceil(Puntero/PixelesdeLargo);
// Esto se usa para evitar repeticiones de concatenaciones y simplificarlas:
FilaRelevante = "PintadosenF"+Fila;
// Disminuir contador de píxeles pintados en ella:
set (FilaRelevante, eval(FilaRelevante)-1);
// ¿Hay un pixel anterior?
if (Puntero>1) {
// Sí, apuntar a ese:
Puntero = Puntero-1;
// Continuar haciendo el dibujo:
// trace (" Haciendo dibujo, apuntando al pixel anterior.");
// trace ("SumadePintados: "+SumadePintados);
// trace ("SumadePintadosNuevos: "+SumadePintadosNuevos);
Variar();
} else {
// No, aumentar tamaño de hoja y reiniciar.
trace (ContadorDeDibujos);
gotoAndPlay (2);
}
}
}
actions for fotograma 2
ContadorDeDibujos = 0;
PixelesdeLargo = PixelesdeLargo+1;
// Colocados:
Pixeles = 0;
DistanciaEntrePixeles = 384/PixelesdeLargo;
PosicionX = 64-DistanciaEntrePixeles;
EnlaFilaActual = 0;
PosicionY = 0;
MaxPosiciondePuntero = PixelesdeLargo*PixelesdeLargo;
// Aquí MinPixelInferior es 3:
// 12
// 34
MinPixelInferior = PixelesdeLargo*(PixelesdeLargo-1)+1;
// Agregar y distribuir 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);
ColorDePixel = new Color("Pixel"+Pixeles);
ColorDePixel.setRGB(0xFFFFFF);
} while (Pixeles<MaxPosiciondePuntero);
// Pintar una diagonal /:
Incremento = PixelesdeLargo-1;
Puntero = PixelesdeLargo-Incremento;
do {
Puntero = Puntero+Incremento;
Col = new Color("Pixel"+Puntero);
Col.setRGB(0);
// trace("Se pintó el pixel "+Puntero);
} while (Puntero<MinPixelInferior);
// Asignar que en cada columna y fila hay 1 pixel pintado:
Puntero = 0;
do {
Puntero = Puntero+1;
set ("PintadosenC"+Puntero, 1);
set ("PintadosenF"+Puntero, 1);
} while (Puntero<PixelesdeLargo);
// El puntero debe estar abajo a la derecha:
Puntero = MaxPosiciondePuntero;
// El 1er dibujo mostrado no será la diagonal sino...
// ella con el pixel mayor pintado, así que...
// los dibujos producible siempre son +1 de lo que se dice aquí.
actions for fotograma 3
stop ();
actions for Vacío
onClipEvent (enterFrame) {
_level0.Variar();
}
Cosas que quiero hacer luego:
- Simplificar la creación de Píxeles, si es posible, debo ver bien cómo lo hiciste.
- Evitar repeticiones por simetría horizontal.
- Intentar que el orden sea según la combinación más distinta.
La idea es que se muestren todos los dibujos posibles en que haya algún píxel pintado en cada columna y fila, pero son TANTOS, que es algo inútil de ver, no se produce mucho interesante...
Por eso luego...
- Hacer un generador random, de muchos dibujos con tamaño y colores a elección. Y programación genética.
La idea es hacer un generador de sprites.
Navegación