|
421
|
Programación / Programación General / Distribuir cosas en una tabla ¿división básica?
|
en: 11 Junio 2024, 01:02 am
|
Si tengo una tablero de XxX casilleros y quiero distribuir Y colores ¿cómo defino de qué color es cada casillero? Por ejemplo si X es 3 e Y es 6 quiero esto: 112 233 456 Es decir, se reparte 9 entre 6 y lo que sobre se da a los 1eros colores. El casillero 1 debe ser de color 1. El 2 de color 1. El 3, 2. 4, 2. 5, 3. 6, 3. 7, 4. 8, 5. 9, 6. ¿Cómo logro eso? X e Y pueden variar, claro. Me dieron una supuesta solución en otro lado pero no pude hacerlo funcionar: Para un tablero L×L y c colores llama:
N=L^2 a=floor(N/c) (parte entera de N/c) r=mod(N,c) (resto de dividir N entre c)
Entonces el número de color que tienes que poner en la fija i, columna j, es:
- Si p<=r*(a+1), floor((p-1)/(a+1)+1 - Si p>r*(a+1), r+1+floor((p-r(a+1)-1)/a)
donde p=(i-1)*L+j Mi código (no es sobre asignar colores sino "ModificacionesRequeridas", pero la idea es la misma): DibujosPorFila = 5; MaxCuadro = DibujosPorFila*DibujosPorFila; CuadraditosPorFila = 4; MaxCuadradito = CuadraditosPorFila*CuadraditosPorFila; DistintasMutaciones = Math.floor(MaxCuadro/CuadraditosPorFila); Resto = MaxCuadro%CuadraditosPorFila; on (release) { // Los dibujos serán como el de encima de este botón // y mutarán: Dibujo = 0; // Repetir para el dibujo 1, 2, etc: do { Dibujo++; // El dibujo a copiar no necesita ser modificado: if (Dibujo != _parent.ID) { Cuadradito = 0; // Repetir hasta que todo cuadradito se haya copiado, // por ahora no hay mutación: do { Cuadradito++; ColoraCopiar = new Color("_parent.Cuadradito"+Cuadradito); ColoraSustituirse = new Color("_level0.Dibujo"+Dibujo+".Cuadradito"+Cuadradito); ColoraSustituirse.setRGB(ColoraCopiar.getRGB()); } while (Cuadradito<_level0.MaxCuadradito); // De cada dibujo copia, variar cuadraditos al azar, // de 1 hasta CuadraditosPorFila, // aumentando por dibujo hacia derecha y abajo: // Repetir hasta que se haya variado esa cantidad... // de cuadraditos: CuadraditosModificados = 0; if (Dibujo <= _level0.Resto*(_level0.DistintasMutaciones+1)) { ModificacionesRequeridas = Math.floor((Dibujo-1)/(_level0.DistintasMutaciones+1))+1; } else { ModificacionesRequeridas = _level0.Resto+1+Math.floor((Dibujo-_level0.Resto(_level0.DistintasMutaciones+1)-1)/_level0.DistintasMutaciones); } trace(Dibujo+": "+ModificacionesRequeridas); // Cosas que no vienen al caso. } } while (Dibujo<_level0.MaxCuadro); }
Resultado: (Nro de casillero, número asignado (que puede entenderse como color)): 2: 1 3: 1 4: 1 5: 1 6: 1 7: 1 8: 3 9: 3 10: 3 11: 3 12: 3 13: 4 14: 4 15: 4 16: 4 17: 4 18: 4 19: 5 20: 5 21: 5 22: 5 23: 5 24: 5 25: 6 Necesito que sea: Del 1 al 7: Son de 1. De 8 a 13: De 2. De 14 a 19: De 3. De 20 a 25: De 4. 11111 11222 22233 33334 44444
|
|
|
422
|
Programación / Programación General / Re: Contar cuántos cuadraditos pintados aislados hay en un dibujo.
|
en: 10 Junio 2024, 10:36 am
|
Hummm... otro de esos mensajes que da hasta pereza leerlo completo. ¿Te refieres al mío o al que escribiste? Si es el mío ¿por qué te da pereza? Veamos, un 'cuadradito' es de cualquier tamaño? Un espacio de XxX píxeles se divide en YxY cuadraditos. X no recuerdo cuánto es e Y va aumentando a medida que se muestran los dibujos posibles de 2 colores. Así, el tamaño de los cuadraditos va disminuyendo porque deben entrar cada vez más en el espacio pero el espacio disponible es fijo. Aquí tienes una pequeña muestra, algo antigua: https://www.youtube.com/watch?v=0x5fEw8LGP4Al menos se puede rechazar el cuadrado de 1x1 píxel? No entiendo la pregunta, pero si te refieres a que si habrá de esos, supongo pero cuando la cantidad de cuadraditos por fila sea igual al tamaño de la hoja, cosa que no he llegado a probar. Estoy intentando evitar ciertos dibujos indeseados antes de dejar que el programa llegue a tantos cuadraditos por fila. Si un 'cuadradito', ya se contó, puede todavía formar parte de otro más grande? No se cuentan así, se cuentan individualmente, un cuadradito es el mínimo tamaño en un dibujo, es una simulación de un pixel, simplemente se ve más grande. Si el color blanco refiere al fondo, entonces solo se forman cuadraditos de color negro, o hay más colores?.... Por ahora sólo negros, pero entiende que lo blanco también son cuadraditos de color blanco que pueden cambiar a negro y viceversa, digo que son fondo porque... cuando sean más colores (aún no), es así, como el fondo de la hoja, no es el dibujo... Como ves faltan muchos detalles (y no quiero ser exhaustivo), para poder decirte algo concreto y directo. Podía dar el código completo pero no creí que alguien quisiera leer tanto, además ya puse similares en temas anteriores. Lo subo a un txt para que no ocupe tanto espacio en el post: https://drive.google.com/file/d/13dSzreVp-WgV0RMKvaRTncqB84lMj3mJ/view?usp=sharingY aquí tienes el editable: https://drive.google.com/file/d/11ksgI1ZEgOSTf0o7X_TRVFLAXPmStT9F/view?usp=sharingNo funciona y aunque dice "ifs terminados", en realidad es sólo un grupo. Se me ocurrió una forma de simplificar la tarea, básicamente es tener guardado cuales coordenadas (filas y columnas) están pintadas, lo estaba evitando porque quería evitar crear variables innecesarias; si funciona como pienso cuando lo tenga hecho lo posteo. Ok, si no me funciona lo que se me ocurrió intento aplicar lo tuyo, no lo entiendo bien. Edit: Tras los cambios requeridos en el fotograma 2 que no vienen mucho al caso, tengo esto: function Variar () { ReferenciaAlColoraModificar = "ColordeCuadradito"+Puntero; ColoraModificar = eval(ReferenciaAlColoraModificar); // ¿El cuadradito puede cambiar de color? if (ColoraModificar<1) { // Sí, hacer los cambios: set (ReferenciaAlColoraModificar, ColoraModificar+1); NuevoColor = new Color("Cuadradito"+Puntero); NuevoColor.setRGB(0); // Obtener fila y columna del cuadradito: Fila = Math.ceil(Puntero/CuadraditosPorFila); Columna = (Puntero-1)%CuadraditosPorFila+1; set("Cuadradito"+Fila+"_"+Columna, 0); // Para juzgar: // ¿El dibujo tiene menos de Largo/2 cuadraditos aislados? // Se actualizará el contador de pintados aislados: // De cada pintado al lado del recién pintado, // se verá si estaba aislado, // en cuyo caso disminuirá el contador. // Si no hay pintados al lado del nuevo, aumentará. // Esta variable puede cambiar: CuadraditoAislado = "Sí"; Fila2 = Fila+1; Columna2 = Columna+1; // Si su inferior derecho existe y está pintado, // entonces el actual no está aislado, // y se mira si el infder estaba aislado: // Cuántos de sus contiguos están pintados. // Por practicidad se cuenta también el recién pintado. // Si la cantidad es 1, estaba aislado, // el contador de Aislados baja. // CONVERTIR EN FUNCIÓN: // ¿El contiguo indicado está pintado? if (eval("Cuadradito"+Fila2+"_"+Columna2) == 0 ) { // Sí, el recién pintado no está aislado: CuadraditoAislado = "No"; // Se contarán los contiguos de este (contiguo al recién...). ContiguosPintados = 0; Fila3 = Fila2+1; Columna3 = Columna2+1; // CONVERTIR EN FUNCIÓN2: // ¿El contiguo indicado está pintado? if (eval("Cuadradito"+Fila3+"_"+Columna3) == 0 ) { // Sí, aumentar contador: ContiguosPintados++; } // Columna3--; // APLICAR FUNCIÓN2 // Continuar modificando Col3 y fila3 y rellamando a la func2. } // Columna2--; // APLICAR FUNCIÓN // Continuar modificando Col2 y fila2 y rellamando a la func. // en vez de usar CuadraditoAislado = "Sí"; se podría definir // ContiguosPintados = 0; desde el inicio y si aumentó entonces // se entiende que ek recién pintado no estaba aislado. // Pero igual ese contador debe reiniciarse cada vez que se empieza a contar, // pero en esos casos siempre es 1 mínimo.
No sé si funciona bien pero ahí está la idea. Falta agregar lo que dije ahí. En unos días o algo así supongo que estará.
|
|
|
423
|
Foros Generales / Foro Libre / Re: Otros Foros
|
en: 10 Junio 2024, 05:55 am
|
Nah, lo suyo es más bien como ir a un hospital a preguntar dónde puede hablar con sicarios xD Aunque tampoco es que aquí todo sea tan "white".
PD: Yo estoy aquí porque me gusta usar PC, la programación y videojuegos, mi interés por el hacking no es mucho, y no conozco otros foros de eso, ni he buscado.
|
|
|
424
|
Programación / Programación General / Explicación de estas líneas (Flash) y simplificar el código.
|
en: 9 Junio 2024, 04:02 am
|
Quiero llamar a una función variable de la raíz (level0) desde una película. Si fuese una función fija sería: _level0.NombreDeLaFuncion(); Llamar a una función variable de la raíz, desde la raíz, creo que sería: FuncionALlamar = "Funcion1"; eval(FuncionALlamar)(); Si fuese FuncionALlamar = "_level0.Funcion1"; quizá funcionaría desde una película, se me acaba de ocurrir, pero he estado probando cosas y nada funciona. ¿Cómo sería? "_level0."+eval(_level0.FuncionALlamar)(); o eval("_level0."+_level0.FuncionALlamar)(); No recuerdo qué cosas probé, la solución que puse funcionó (no me gustaba porque me parecía inconveniente extender innecesariamente el valor de la variable), pero estoy liado en cuanto a qué hacen esas líneas. eval usa texto y variables para indicar el nombre de una variable y si existe devuelve su valor, pero si luego hay un () entonces ese nombre es de una función a la cual llama. Hasta ahí entiendo ¿está bien, no? Pero con lo del _level0. me lié. --------------------------------------------------------------------------------------------------------- Otra pregunta. Tengo por ahí: PosiblesSignos = ["==", "!=", "<=", ">=", "<", ">"]; Y uso esta función luego: function ModificarP2() { if (P2Valor<6) { P2Valor++; P2 = PosiblesSignos[P2Valor(PosiblesSignos.length)]; } else { Continuar = "No"; } }
La idea es que P2 cambie a "!=", luego a "<=", y así sucesivamente pero no funciona. Es que esto: P2 = PosiblesSignos[P2Valor(PosiblesSignos.length)]; lo hice basado en algo que me dijeron pero no entiendo qué hace. Obtiene la parte [a definir] del array llamado PosiblesSignos ¿no? Ahora creo que alcanza con decir: P2 = PosiblesSignos[P2Valor]; Sí, ahora me funcionó. ¿Pero qué es esto: P2 = PosiblesSignos[P2Valor(PosiblesSignos.length)]; ? Debo haber copiado mal  --------------------------------------------------------------------------------------------------------- Finalmente: ¿Es posible simplificar este código, cómo? // Este programa genera una comparación simple y su evaluación, pero: // Debe haber alguna parte cuyo contenido no está definido. // Ejemplo: 1 < ... : true // Luego intenta asignar el contenido faltante, // pero por ahora sólo si falta sólo 1. // Las siguientes funciones se usan en Resolvedor1, etc: function Comparacion() { if (P2 == "==") { Resultado = P1 == P3; } else if (P2 == "!=") { Resultado = P1 != P3; } else if (P2 == "<=") { Resultado = P1 <= P3; } else if (P2 == ">=") { Resultado = P1 >= P3; } else if (P2 == "<") { Resultado = P1 < P3; } else { Resultado = P1 > P3; } return Resultado+"" == P4; } function ModificarP1() { if (P1<10) { P1++; } else { Continuar = "No"; } } function ModificarP2() { if (P2Valor<6) { P2Valor++; P2 = PosiblesSignos[P2Valor]; } else { Continuar = "No"; } } function ModificarP3() { if (P3<10) { P3++; } else { Continuar = "No"; } } function ModificarP4() { if (P4 == "true") { P4 = "false"; } else { Continuar = "No"; } } // Se repite en F2, cuando hay 1 contenido indefinido y es el 1: function Resolvedor1 () { trace("Se probará el Candidato "+eval("P"+Indefinido)); if (Comparacion()) { trace ("Solución hallada, ver respuesta."); Mensaje = Mensaje+"\n"+P1+" "+P2+" "+P3+": "+P4; gotoAndStop (3); } else if (Continuar == "Sí") { // Se modificará el candidato: eval(ModificadoraUsar)(); } else { trace ("No se pudo hallar una solución."); gotoAndStop (3); } } PosiblesTiposDeContenido = ["Normal", "Indefinido"]; PosiblesSignos = ["==", "!=", "<=", ">=", "<", ">"]; // Generar las 4 partes hasta que se cumpla la condición: do { Indefinidos = 0; // Parte 1 (cosa 1 a comparar): TipoDelParte1 = PosiblesTiposDeContenido[random(PosiblesTiposDeContenido.length)]; if (TipoDelParte1 == "Normal") { Parte1 = random(10); } else { Parte1 = "..."; Indefinidos++; Indefinido = 1; // set("Indefinido"+Indefinidos, 1); } // Parte 2 (símbolo comparador): TipoDelParte2 = PosiblesTiposDeContenido[random(PosiblesTiposDeContenido.length)]; if (TipoDelParte2 == "Normal") { Parte2 = PosiblesSignos[random(6)]; } else { Parte2 = "..."; Indefinidos++; Indefinido = 2; // set("Indefinido"+Indefinidos, 2); } // Parte 3 (cosa 2 a comparar): TipoDelParte3 = PosiblesTiposDeContenido[random(PosiblesTiposDeContenido.length)]; if (TipoDelParte3 == "Normal") { Parte3 = random(10); } else { Parte3 = "..."; Indefinidos++; Indefinido = 3; // set("Indefinido"+Indefinidos, 3); } // Parte 4 (evaluación): TipoDelParte4 = PosiblesTiposDeContenido[random(PosiblesTiposDeContenido.length)]; if (TipoDelParte4 == "Normal") { // Definir esta parte según las anteriores: // ¿Fueron definidas? if (Parte1 != "..." && Parte2 != "..." && Parte3 != "...") { // Sí, ver qué definición corresponde: if (Parte2 == "==") { Parte4 = Parte1 == Parte3; } else if (Parte2 == "!=") { Parte4 = Parte1 != Parte3; } else if (Parte2 == "<=") { Parte4 = Parte1 <= Parte3; } else if (Parte2 == ">=") { Parte4 = Parte1 >= Parte3; } else if (Parte2 == "<") { Parte4 = Parte1 < Parte3; } else { Parte4 = Parte1 > Parte3; } } else { // No toda parte fue definida, // definir esta al azar: Parte4 = random(2); if (Parte4 == 0) { Parte4 = "true"; } else { Parte4 = "false"; } } } else { Parte4 = "..."; Indefinidos++; Indefinido = 4; // set("Indefinido"+Indefinidos, 4); } } while (Indefinidos == 0); Mensaje = Parte1+" "+Parte2+" "+Parte3+": "+Parte4; // Marca si algún canditato puede modificarse: Continuar = "Sí"; // Decidir qué resolvedor usar y preparar variables: if (Indefinidos == 1) { P1 = Parte1; P2 = Parte2; P3 = Parte3; P4 = Parte4; // Asignar un valor al contenido indefinido: if (Indefinido == 1) { P1 = 0; } else if (Indefinido == 2) { P2Valor = 0; P2 = "=="; } else if (Indefinido == 3) { P3 = 0; } else { P4 = "true"; } ResolvedoraUsar = "_level0.Resolvedor"+Indefinidos; ModificadoraUsar = "ModificarP"+Indefinido; } else { Mensaje = Mensaje+"\nAún no hay resolvedor para esta duda."; stop(); }
La idea es solucionar problemas así cada vez más complejos. Esto es sólo el comienzo...
|
|
|
425
|
Media / Diseño Gráfico / Re: Busco técnicas para dibujar muro: ¿Achicar una parte?
|
en: 7 Junio 2024, 02:01 am
|
Ha habido frío y cuando eso sucede no uso mucho el mouse, así que sobre esto no había hecho mucho más hasta ayer. Además he estado ocupado, sólo pasó 1 día, cuando me quede cómodo te respondo bien, ahora estoy comiendo. Ya. Tu respuesta sigue constando ahí. Eso también lo había visto, pero parece demasiado complejo ponerme a hacer cálculos para esto. Mira, esto me dijeron en Quora: Si entiendo bien lo que dices en tu comentario eso se llama "perspectiva".
En todos los programas de edición de imágenes, como Photoshop, Illustrator, GIMP o Inkscape, hay herramientas para transformar un objeto plano en un objeto con perspectiva.
En GIMP (editor de imágenes en mapa de bits gratuito) está en el menú Herramientas > Herramientas de transformación > Perspectiva:

Eso era lo que buscaba pero como ese programa no me sirvió (los ladrillos se agrandan demasiado) decidí hacerlo a mano, agrandé la imagen y le encontré la vuelta: - En vez de los colores que usaré, usar en principio colores vistosos, cambiarlos luego. - Ir pintando los ladrillos de modo horizontal, que ahí es diagonal, es decir, 1ero una fila, luego la otra, etc. Yo estaba haciendo de arriba hacia abajo. Es simplemente buscar la siguiente raya | borrarla y pintar. Por ahora lo tengo así:  Vista ampliada de una parte:  Básicamente sólo me falta poner los colores rojizos y líneas. Los tamaños quedaron mal porque Flash delira en eso, yo iba estirando las líneas de a una a la vez y algunas filas quedaron más altas que otras, no lo voy a cambiar por ahora, no lo necesito perfecto xP Las nuevas cosas que dices me parecen más sencillas que lo de hacer cálculos pero aún no lo capto bien.
|
|
|
428
|
Programación / Programación General / Contar cuántos cuadraditos pintados aislados hay en un dibujo.
|
en: 2 Junio 2024, 20:05 pm
|
Por ejemplo aquí se considera que no hay:  En este contexto lo blanco no se considera pintado, es fondo. Todos los cuadraditos pintados tienen al menos 1 pintado al lado (diagonal también cuenta). Estoy haciendo un generador de dibujos así y quiero que no muestre (o que no genere, sería lo ideal) los que tengan cierta cantidad de cuadraditos pintados aislados. La cantidad depende del tamaño del dibujo, no importa aquí cual es. El dibujo se va modificando de a 1 cuadradito, se pinta uno, o se despinta uno (o más) y se pinta otro. Así, debo hacer algo como: - Cuando se pinte uno nuevo, mirar si al lado hay otro. Si no hay, incrementar el contador de aislados. Si hay, ver si ese o esos estaban aislados, en cuyo caso disminuir el contador cuanto corresponda (según cuantos eran los aislados). - Cuando se despinte uno, mirar si hay cuadraditos pintados al lado. Si no hay, disminuir el contador de aislados. Si hay, mirar al lado de cada uno y aumentar el contador de aislados por cada uno que haya quedado aislado. Mi pregunta es: ¿Hay un modo más fácil? ¿es posible que lo haga GPT o algo así? Es que es mucho código... Por ahora hice esto y luego vi que no sirven else ifs, sólo ifs: // Para juzgar: // ¿El dibujo tiene menos de Largo/2 cuadraditos aislados? // Se actualizará el contador de pintados aislados: // De cada pintado al lado del recién pintado, // se verá si estaba aislado, // en cuyo caso disminuirá el contador. // Si no hay pintados al lado del nuevo, aumentará. CuadraditoAislado = "Sí"; // ¿El modificado es el inferior derecho? if (Puntero == MaxPosiciondePuntero) { // Sí, ver el -1 (izquierdo), -L (up) y -L-1 (iu): // xSS // xS* if (eval("ColordeCuadradito"+(Puntero-1)) == 1) { CuadraditoAislado = "No"; } if (eval("ColordeCuadradito"+(Puntero-CuadraditosPorFila)) == 1) { CuadraditoAislado = "No"; } else if (eval("ColordeCuadradito"+(Puntero-CuadraditosPorFila-1)) == 1) { CuadraditoAislado = "No"; } } else if (Puntero > MinCuadraditoInferior) { // Inferior no en una esquina, // contar el +1 (derecho), -1, -L+1 (du), -L y -L-1: // SSS // S*S if (eval("ColordeCuadradito"+(Puntero+1)) == 1) { CuadraditoAislado = "No"; } else if (eval("ColordeCuadradito"+(Puntero-1) == 1) { CuadraditoAislado = "No"; } else if (eval("ColordeCuadradito"+(Puntero-CuadraditosPorFila+1)) == 1) { CuadraditoAislado = "No"; } else if (eval("ColordeCuadradito"+(Puntero-CuadraditosPorFila)) == 1) { CuadraditoAislado = "No"; } else if (eval("ColordeCuadradito"+(Puntero-CuadraditosPorFila-1)) == 1) { CuadraditoAislado = "No"; } } else if (Puntero == MinCuadraditoInferior) { // Inferior izquierdo, // contar el +1, -L+1 y -L: // SSx // *Sx if (eval("ColordeCuadradito"+(Puntero+1)) == 1) { CuadraditoAislado = "No"; } else if (eval("ColordeCuadradito"+(Puntero-CuadraditosPorFila+1)) == 1) { CuadraditoAislado = "No"; } else if (eval("ColordeCuadradito"+(Puntero-CuadraditosPorFila)) == 1) { CuadraditoAislado = "No"; } } else if (Puntero > CuadraditosPorFila) { // No es superior. if (Puntero%CuadraditosPorFila == 0) { // Central derecho, // contar el +L, +L-1, -1, -L y -L-1: // xSS // xS* // xSS if (eval("ColordeCuadradito"+(Puntero+CuadraditosPorFila)) == 1) { CuadraditoAislado = "No"; } else if (eval("ColordeCuadradito"+(Puntero+CuadraditosPorFila-1)) == 1) { CuadraditoAislado = "No"; } else if (eval("ColordeCuadradito"+(Puntero-1)) == 1) { CuadraditoAislado = "No"; } else if (eval("ColordeCuadradito"+(Puntero-CuadraditosPorFila)) == 1) { CuadraditoAislado = "No"; } else if (eval("ColordeCuadradito"+(Puntero-CuadraditosPorFila-1)) == 1) { CuadraditoAislado = "No"; } } else if (Puntero%CuadraditosPorFila != 1) { // Central, contar todos los contiguos: // SSS // S*S // SSS if (eval("ColordeCuadradito"+(Puntero+CuadraditosPorFila+1)) == 1) { CuadraditoAislado = "No"; } else if (eval("ColordeCuadradito"+(Puntero+CuadraditosPorFila)) == 1) { CuadraditoAislado = "No"; } else if (eval("ColordeCuadradito"+(Puntero+CuadraditosPorFila-1)) == 1) { CuadraditoAislado = "No"; } else if (eval("ColordeCuadradito"+(Puntero+1)) == 1) { CuadraditoAislado = "No"; } else if (eval("ColordeCuadradito"+(Puntero-1)) == 1) { CuadraditoAislado = "No"; } else if (eval("ColordeCuadradito"+(Puntero-CuadraditosPorFila+1)) == 1) { CuadraditoAislado = "No"; } else if (eval("ColordeCuadradito"+(Puntero-CuadraditosPorFila)) == 1) { CuadraditoAislado = "No"; } else if (eval("ColordeCuadradito"+(Puntero-CuadraditosPorFila-1)) == 1) { CuadraditoAislado = "No"; } } else { // Central izquierdo, // contar el +L+1, +L, +1, -L+1 y -L: // SSx // *Sx // SSx if (eval("ColordeCuadradito"+(Puntero+CuadraditosPorFila+1)) == 1) { CuadraditoAislado = "No"; } else if (eval("ColordeCuadradito"+(Puntero+CuadraditosPorFila)) == 1) { CuadraditoAislado = "No"; } else if (eval("ColordeCuadradito"+(Puntero+1)) == 1) { CuadraditoAislado = "No"; } else if (eval("ColordeCuadradito"+(Puntero-CuadraditosPorFila+1)) == 1) { CuadraditoAislado = "No"; } else if (eval("ColordeCuadradito"+(Puntero-CuadraditosPorFila)) == 1) { CuadraditoAislado = "No"; } } } else if (Puntero == CuadraditosPorFila) { // Superior derecho, // contar el +L+1, +L y +1: // *Sx // SSx if (eval("ColordeCuadradito"+(Puntero+CuadraditosPorFila+1)) == 1) { CuadraditoAislado = "No"; } else if (eval("ColordeCuadradito"+(Puntero+CuadraditosPorFila)) == 1) { CuadraditoAislado = "No"; } else if (eval("ColordeCuadradito"+(Puntero+1)) == 1) { CuadraditoAislado = "No"; } } else if (Puntero > 1) { // Superior cemtral, // contar el +L+1, +L, +L-1, +1 y -1: // S*S // SSS if (eval("ColordeCuadradito"+(Puntero+CuadraditosPorFila+1)) == 1) { CuadraditoAislado = "No"; } else if (eval("ColordeCuadradito"+(Puntero+CuadraditosPorFila)) == 1) { CuadraditoAislado = "No"; } else if (eval("ColordeCuadradito"+(Puntero+CuadraditosPorFila-1)) == 1) { CuadraditoAislado = "No"; } else if (eval("ColordeCuadradito"+(Puntero+1)) == 1) { CuadraditoAislado = "No"; } else if (eval("ColordeCuadradito"+(Puntero-1)) == 1) { CuadraditoAislado = "No"; } } else { // Superior izquierdo, // contar el +L+1, +L y +1: // *Sx // SSx if (eval("ColordeCuadradito"+(Puntero+CuadraditosPorFila+1)) == 1) { CuadraditoAislado = "No"; } else if (eval("ColordeCuadradito"+(Puntero+CuadraditosPorFila)) == 1) { CuadraditoAislado = "No"; } else if (eval("ColordeCuadradito"+(Puntero-1)) == 1) { CuadraditoAislado = "No"; } } if (CuadraditoAislado == "Sí") { CuadraditosAislados++; }
Es decir, ahí sólo estoy viendo si el cuadradito nuevo está aislado ¡me falta ver si sus contiguos lo estaban! (o si lo están sin contar al nuevo) y me falta el caso en que se despinta un cuadradito. ¿Tal vez se podrían usar functions para evitar repetir código? No sé bien cómo. Además, siendo tanto, puede que haya cometido algún error :/
|
|
|
430
|
Foros Generales / Foro Libre / ¿Qué pasó hoy 2024-05-28 a las 6:45 en el cielo de Uruguay, Montevideo?
|
en: 28 Mayo 2024, 12:07 pm
|
Algo cerca del cerro, hubo una fila de varias luces similares a las de estrellas, a considerable distancia entre sí. Entre todas ocuparían el largo del cielo que alguien puede ver, más o menos. Hubo también unas pequeñas luces instantáneas y a veces vi algunas que iban a otra dirección. En eso vi un avión hacer un movimiento distinto al que suelo ver hacer, pero a esta hora no suelo verlos. Hizo una especie de curva. Las luces iban a su misma velocidad más o menos.
Si alguien puede averiguar algo, agradezco.
Ah, cierto, no tenía con qué filmarlos ni tomarles fotos, sorry.
|
|
|
|
|
|
|