elhacker.net cabecera Bienvenido(a), Visitante. Por favor Ingresar o Registrarse
¿Perdiste tu email de activación?.


Tema destacado: Trabajando con las ramas de git (tercera parte)


  Mostrar Temas
Páginas: 1 2 3 4 5 6 7 8 9 10 11 12 13 [14] 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 ... 50
131  Programación / Programación General / ¿Por qué a veces no se aplica la animación? en: 30 Junio 2024, 03:35 am
Intento programar un personaje parecido a Jumpman (Mario antes de ser llamado así), pero la animación de caminar a veces no se aplica ¿por qué? ¿cómo lo arreglo?

En el fotograma 1:
Código
  1. fscommand ("fullscreen", "true");
  2. // /////////////////////////////////////////////
  3. // /////////////////  Jumpman  /////////////////
  4. // /////////////////////////////////////////////
  5. // Por ahora siempre está atacando:
  6. Player.Action = "Attacking";
  7. // Indica cómo está o qué está haciendo,
  8. // independientemente de si está atacando o no:
  9. Player.Action2 = "Quiet";
  10. // Cuando ataca qu¡eto:
  11. function AttackingQuiet () {
  12. Player.gotoAndPlay(2);
  13. Player.Action2 = "Quiet";
  14. }
  15. // Cuando ataca caminando:
  16. function AttackingWalk () {
  17. Player.gotoAndPlay(5);
  18. Player.Action2 = "Walking";
  19. }
  20. // Al presionar derecha cuando está atacando quieto:
  21. function RightWhenAttackingQuiet () {
  22. Player._x = Player._x+0.7;
  23. AttackingWalk();
  24. }
  25. // Al presionar derecha cuando está atacando caminando:
  26. function RightWhenAttackingWalking () {
  27. Player._x = Player._x+0.7;
  28. }
  29. // Al presionar nada cuando está atacando caminando:
  30. function QuietWhenAttackingWalking () {
  31. AttackingQuiet();
  32. }
  33. function ControlJumpman () {
  34. if (Key.isDown(39)) {
  35. // Si se presiona derecha:
  36. eval("RightWhen"+Player.Action+Player.Action2)();
  37. } else {
  38. // Si nada se presiona:
  39. eval("QuietWhen"+Player.Action+Player.Action2)();
  40. }
  41. }

2:
Código
  1. stop();
  2. En un objeto:
  3. onClipEvent (enterFrame) {
  4. _level0.ControlJumpman();
  5. }
  6.  

El objeto Player está siempre y es así:
Fotograma 1: Jumpman no atacando y quieto, es irrelevante aquí.
2: Tiene el martillo arriba con pose de quieto.
3: Martillo aplastando, pose de quieto.
4: gotoAndPlay (2);
5~10: Atacando mientras camina.
11: gotoAndPlay (5);
132  Foros Generales / Foro Libre / ¿Alguien me traduce estas acciones? De un mod de otro foro hace años. en: 28 Junio 2024, 01:23 am


Apareció un tema titulado "Soy un Troll" que figuraba como creado por un usuario U, pero él decía que no lo creó. El moderador más activo, M1, dijo que no recordaba haberlo hecho. El admin A no participaba, casi. Otro moderador M2 tampoco y otro M3 dió esa imagen.

Todas esas acciones figuran como realizadas por M1. Asumiendo que la imagen no está editada y que no se ururpó la identidad de M1 (hubiera sido la única vez, es poco creíble) ¿qué significan esas acciones que se describen en la imagen? ¿demuestran que es culpable?

El asunto causó bastante revuelo en el foro, U pedía que se modifique el tema, decía no poder edtarlo él mismo, los mods tampoco lo modificaban, y M1 terminó dejando de ser mod.

Yo me quedé con la curiosidad de saber qué pasó realmente y revisando temas lo recordé, en aquél entonces no se me ocurrió preguntar aquí o no conocía este sitio.
133  Programación / Programación General / ¿Notan alguna falla? ¿y si se reseteara? Y quiero texto con scroll... en: 25 Junio 2024, 09:00 am
Código
  1. // Este programa genera una comparación simple y su evaluación, pero:
  2. // Debe haber alguna parte cuyo contenido no está definido.
  3. // Ejemplo: 1 < ... : true
  4. // Luego intenta asignar los contenidos faltantes.
  5. // Las siguientes funciones se usan en Resolvedor:
  6. function Comparacion() {
  7. trace("Probando: "+P1+" "+P2+" "+P3+": "+P4);
  8. if (P2 == "==") {
  9. Resultado = P1 == P3;
  10. } else if (P2 == "!=") {
  11. Resultado = P1 != P3;
  12. } else if (P2 == "<=") {
  13. Resultado = P1 <= P3;
  14. } else if (P2 == ">=") {
  15. Resultado = P1 >= P3;
  16. } else if (P2 == "<") {
  17. Resultado = P1 < P3;
  18. } else {
  19. Resultado = P1 > P3;
  20. }
  21. return Resultado+"" == P4;
  22. }
  23. function ModificarP1() {
  24. if (P1<10) {
  25. P1++;
  26. } else {
  27. Puntero++;
  28. // ¿Se puede modificar el contenido de otra parte?
  29. if (Puntero > Indefinidos) {
  30. // Sí, resetear esta y modificar esa:
  31. P1 = 0;
  32. eval("ModificarP"+eval("Indefinido"+Puntero))();
  33. } else {
  34. // No, indicar que el resolvedor se detenga:
  35. Continuar = "No";
  36. }
  37. }
  38. }
  39. function ModificarP2() {
  40. if (P2Valor<6) {
  41. P2Valor++;
  42. P2 = PosiblesSignos[P2Valor];
  43. Puntero = 1;
  44. } else {
  45. Puntero++;
  46. // ¿Se puede modificar el contenido de otra parte?
  47. if (Puntero > Indefinidos) {
  48. // Sí, resetear esta y modificar esa:
  49. P2Valor = 0;
  50. P2 = "==";
  51. eval("ModificarP"+eval("Indefinido"+Puntero))();
  52. } else {
  53. // No, indicar que el resolvedor se detenga:
  54. Continuar = "No";
  55. }
  56. }
  57. }
  58. function ModificarP3() {
  59. if (P3<10) {
  60. P3++;
  61. Puntero = 1;
  62. } else {
  63. Puntero++;
  64. // ¿Se puede modificar el contenido de otra parte?
  65. if (Puntero > Indefinidos) {
  66. // Sí, resetear esta y modificar esa:
  67. P3 = 0;
  68. eval("ModificarP"+eval("Indefinido"+Puntero))();
  69. } else {
  70. // No, indicar que el resolvedor se detenga:
  71. Continuar = "No";
  72. }
  73. }
  74. }
  75. function ModificarP4() {
  76. if (P4 == "true") {
  77. P4 = "false";
  78. Puntero = 1;
  79. } else {
  80. Puntero++;
  81. // ¿Se puede modificar el contenido de otra parte?
  82. if (Puntero > Indefinidos) {
  83. // Sí, resetear esta y modificar esa:
  84. P4 = "true";
  85. eval("ModificarP"+eval("Indefinido"+Puntero))();
  86. } else {
  87. // No, indicar que el resolvedor se detenga:
  88. Continuar = "No";
  89. }
  90. }
  91. }
  92. // Se repite en F2:
  93. function Resolvedor () {
  94. if (Comparacion()) {
  95. trace ("Solución hallada, ver respuesta.");
  96. Mensaje = Mensaje+"\n"+P1+" "+P2+" "+P3+": "+P4;
  97. gotoAndStop (3);
  98. } else if (Continuar == "Sí") {
  99. // Se modificará el candidato:
  100. eval(ModificadoraUsar)();
  101. } else {
  102. trace ("No se pudo hallar una solución.");
  103. gotoAndStop (3);
  104. }
  105. }
  106. PosiblesTiposDeContenido = ["Normal", "Indefinido"];
  107. PosiblesSignos = ["==", "!=", "<=", ">=", "<", ">"];
  108. // Generar los contenidos de las 4 partes hasta que alguno sea indefinido:
  109. do {
  110. Indefinidos = 0;
  111. // Parte 1 (cosa 1 a comparar):
  112. TipoDelParte1 = PosiblesTiposDeContenido[random(PosiblesTiposDeContenido.length)];
  113. if (TipoDelParte1 == "Normal") {
  114. Parte1 = random(10);
  115. } else {
  116. Parte1 = "...";
  117. Indefinidos++;
  118. set("Indefinido"+Indefinidos, 1);
  119. }
  120. // Parte 2 (símbolo comparador):
  121. TipoDelParte2 = PosiblesTiposDeContenido[random(PosiblesTiposDeContenido.length)];
  122. if (TipoDelParte2 == "Normal") {
  123. Parte2 = PosiblesSignos[random(6)];
  124. } else {
  125. Parte2 = "...";
  126. Indefinidos++;
  127. set("Indefinido"+Indefinidos, 2);
  128. }
  129. // Parte 3 (cosa 2 a comparar):
  130. TipoDelParte3 = PosiblesTiposDeContenido[random(PosiblesTiposDeContenido.length)];
  131. if (TipoDelParte3 == "Normal") {
  132. Parte3 = random(10);
  133. } else {
  134. Parte3 = "...";
  135. Indefinidos++;
  136. set("Indefinido"+Indefinidos, 3);
  137. }
  138. // Parte 4 (evaluación):
  139. TipoDelParte4 = PosiblesTiposDeContenido[random(PosiblesTiposDeContenido.length)];
  140. if (TipoDelParte4 == "Normal") {
  141. // Definir esta parte según las anteriores:
  142. // ¿Fueron definidas?
  143. if (Parte1 != "..." && Parte2 != "..." && Parte3 != "...") {
  144. // Sí, ver qué definición corresponde:
  145. if (Parte2 == "==") {
  146. Parte4 = Parte1 == Parte3;
  147. } else if (Parte2 == "!=") {
  148. Parte4 = Parte1 != Parte3;
  149. } else if (Parte2 == "<=") {
  150. Parte4 = Parte1 <= Parte3;
  151. } else if (Parte2 == ">=") {
  152. Parte4 = Parte1 >= Parte3;
  153. } else if (Parte2 == "<") {
  154. Parte4 = Parte1 < Parte3;
  155. } else {
  156. Parte4 = Parte1 > Parte3;
  157. }
  158. } else {
  159. // No toda parte fue definida,
  160. // definir esta al azar:
  161. Parte4 = random(2);
  162. if (Parte4 == 0) {
  163. Parte4 = "true";
  164. } else {
  165. Parte4 = "false";
  166. }
  167. }
  168. } else {
  169. Parte4 = "...";
  170. Indefinidos++;
  171. set("Indefinido"+Indefinidos, 4);
  172. }
  173. } while (Indefinidos == 0);
  174. Mensaje = Parte1+" "+Parte2+" "+Parte3+": "+Parte4;
  175. // Preparar variables, asignar valores a los contenidos indefinidos:
  176. // Parte 1:
  177. if (Parte1 != "...") {
  178. P1 = Parte1;
  179. } else {
  180. P1 = 0;
  181. }
  182. // Parte 2:
  183. if (Parte2 != "...") {
  184. P2 = Parte2;
  185. } else {
  186. P2Valor = 0;
  187. P2 = "==";
  188. }
  189. // Parte 3:
  190. if (Parte3 != "...") {
  191. P3 = Parte3;
  192. } else {
  193. P3 = 0;
  194. }
  195. // Parte 4:
  196. if (Parte4 != "...") {
  197. P4 = Parte4;
  198. } else {
  199. P4 = "true";
  200. }
  201. // Usado para variar qué contenido de P se modifica:
  202. Puntero = 1;
  203. ModificadoraUsar = "ModificarP"+Indefinido1;
  204. // Marca si algún cantenido puede modificarse:
  205. Continuar = "Sí";

Ejemplo:
8 ... ...: ...
Probando: 8 == 0: true
Probando: 8 != 0: true
Solución hallada, ver respuesta.

Otro ejemplo:
... > 4: ...
Probando: 0 > 4: true
Probando: 1 > 4: true
Probando: 2 > 4: true
Probando: 3 > 4: true
Probando: 4 > 4: true
Probando: 5 > 4: true
Solución hallada, ver respuesta.

¿Funciona bien siempre? ¿detectan algo en el código que podría generar fallas?

Si pongo un botón de resetear ¿habrá problema? Pondría las funciones en el frame 1, la comparación se generaría en el 2 y el resolvedor se repetiría en el 3; mi temor es que una variable no eliminada, que no estaba definida al inicio, cause un error.

Lo último: El programa muestra mensajes usando trace, el equivalente de print. Pero eso sólo funciona usando el editor de Flash. Quisiera que esos mensajes se muestren también en un swf o exe. El problema es si el mensaje tiene muchas líneas, no sé cómo ponerle scroll. Voy a mirar el tutorial pero si me dicen mejor.
134  Programación / Programación General / Lograr exactamente X cambios random en una imagen. en: 22 Junio 2024, 09:54 am
Tras cliquear en el dibujo superior izquierdo, los demás quedan igual excepto que en este caso los de la fila 1 deben tener 1 diferencia (excepto el que fue cliqueado), los de la fila 2 deben tener 2, y así. Eso no sucede aquí:

Señalé que en la fila 1 hay 1 cambio donde debe, pero en la 4 a veces hay 4, 3, 2 o incluso puede haber 1 porque mi código debe ajustarse para eso ¿cómo?
Código
  1. // Repetir hasta que se haya variado esa cantidad...
  2. // de cuadraditos:
  3. CuadraditosModificados = 0;
  4. do {
  5. CuadraditoaCambiar = "_level0.Dibujo"+Dibujo+".Cuadradito"+(random(_level0.MaxCuadradito)+1);
  6. ColoraSustituirse = new Color(CuadraditoaCambiar);
  7. // A esto lo convierto a String porque...
  8. // lo debo comparar con un string y es más fácil así.
  9. SavedeColoraSustituirse = ""+(ColoraSustituirse.getRGB());
  10. // Repetir mientras el color no cambie:
  11. do {
  12. NuevoColor = _parent.PosiblesColores[random(_parent.PosiblesColores.length)];
  13. } while (NuevoColor == SavedeColoraSustituirse);
  14. ColoraSustituirse.setRGB(NuevoColor);
  15. // trace ("NuevoColor: "+NuevoColor);
  16. CuadraditosModificados++;
  17. } while (CuadraditosModificados<ModificacionesRequeridas);
Si precisan más código avísenme, eso es para modificar los cuadraditos de 1 dibujo, en otras partes se varía cual dibujo. El problema es que se modifica un cuadradito al azar, repetidamente, de modo que cada nuevo modificado puede ser alguno que ya haya sido modificado, por eso aunque en el código se hacen las modificaciones la cantidad de veces requeridas, en la práctica y a la vista pueden ser menos.

¿Debo crear una lista de los modificados y repetir si el nuevo modificado ya lo fue? ¿ha<y alguna alternativa más eficiente, o cómo hago eso? Ya se está repitiendo el cambio de color hasta que efectivamente ocurre (ya que el nuevo es random pero por eso puede ser igual al anterior; se repite para evitar eso), así que en lo posible no quisiera repetir tanta cosa...

Edit:
Acabo de ver que el 2ndo de la 2nda fila es totalmente igual al cliqueado, así que el código está peor de lo que pensé ¿cómo lo mejoro? O tal vez se modificó 1 cuadradito y luego se volvi´a modificar de modo que quedó como estaba, sería como lo que expliqué entonces, no sería un error extra, tal vez.
135  Foros Generales / Sugerencias y dudas sobre el Foro / ¿Sería buena idea crear un blog aquí sobre avances de nuestros proyectos? en: 15 Junio 2024, 02:01 am
Lo bueno:
- Es una opción a ver a quien le interese.
- Implicaría más actividad en el foro, si hay participación ahí.
- Puede atraer a más usuarios, tal vez.

Posibles problemas:
- Spammers. No me refiero a que muchos vengan, publiquen sus cosas una vez y adiós, eso no sé si sería un problema, sino que me refiero al caso de que la gente publique casi lo mismo a cada rato: "Agregué una opción al menú", "agregué otra", etc. Yo mismo podría ser que haga algo así, aunque no por gusto.
- Desorden. Si se postean muchas cosas será un tema de cosas un poco random, no sé si lo consideran un problema. Ya hay un tema donde la gente pùblica canales de YT, o sus blogs, esto sería parecido pero podría ser más activo.
- Más trabajo para los mods, posibles links a malware de usuarios que luego nunca más participen...

¿Hay posibles soluciones, o prevenciones?
Por ejemplo para el 1 se podría limitar el número de post por semana, o mes, o si trabajan en más de 1 proyecto podría limitarse la cantidad de post por semana/mes sobre cada proyecto (es decir se pueden hacer 2 mensajes por semana, por ejemplo, si es sobre 2 proyectos distintos). Pero eso no evita que se puedan postear pequeñeces o incluso "Esta semana se me complicó".
Para el 3, en caso de ser usuarios nuevos se podría exigir que pongan una imagen, código o video a YT, no sólo el link a quien sabe dónde y qué.
136  Programación / Programación General / ¿Programar esto es buena idea o antes debo saber más? en: 12 Junio 2024, 11:25 am
Quiero hacer más rápido esto que me resulta difícil.

Nota: X puede ser monedas, estrellas, cualquier cosa de un videojuego, en esta tarea no es necesario especificarla.

La hoja 1 está completa:


La hoja 2 está completa (vean que lo obtenido en la hoja 1 es usado aquí como base):


La hoja 3 no, y no sé cuántas hojas quiero hacer:


El problema de que un programa lo haga (sólo una lista, no como las imágenes) es que hay casos especiales, no es tan fácil saberlos a priori o que el programa los produzca bien cuando debe ¿qué me recomiendan?
137  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:
Citar
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):
Código
  1. DibujosPorFila = 5;
  2. MaxCuadro = DibujosPorFila*DibujosPorFila;
  3. CuadraditosPorFila = 4;
  4. MaxCuadradito = CuadraditosPorFila*CuadraditosPorFila;
  5. DistintasMutaciones = Math.floor(MaxCuadro/CuadraditosPorFila);
  6. Resto = MaxCuadro%CuadraditosPorFila;
  7. on (release) {
  8. // Los dibujos serán como el de encima de este botón
  9. // y mutarán:
  10. Dibujo = 0;
  11. // Repetir para el dibujo 1, 2, etc:
  12. do {
  13. Dibujo++;
  14. // El dibujo a copiar no necesita ser modificado:
  15. if (Dibujo != _parent.ID) {
  16. Cuadradito = 0;
  17. // Repetir hasta que todo cuadradito se haya copiado,
  18. // por ahora no hay mutación:
  19. do {
  20. Cuadradito++;
  21. ColoraCopiar = new Color("_parent.Cuadradito"+Cuadradito);
  22. ColoraSustituirse = new Color("_level0.Dibujo"+Dibujo+".Cuadradito"+Cuadradito);
  23. ColoraSustituirse.setRGB(ColoraCopiar.getRGB());
  24. } while (Cuadradito<_level0.MaxCuadradito);
  25. // De cada dibujo copia, variar cuadraditos al azar,
  26. // de 1 hasta CuadraditosPorFila,
  27. // aumentando por dibujo hacia derecha y abajo:
  28. // Repetir hasta que se haya variado esa cantidad...
  29. // de cuadraditos:
  30. CuadraditosModificados = 0;
  31. if (Dibujo <= _level0.Resto*(_level0.DistintasMutaciones+1)) {
  32. ModificacionesRequeridas = Math.floor((Dibujo-1)/(_level0.DistintasMutaciones+1))+1;
  33. } else {
  34. ModificacionesRequeridas = _level0.Resto+1+Math.floor((Dibujo-_level0.Resto(_level0.DistintasMutaciones+1)-1)/_level0.DistintasMutaciones);
  35. }
  36. trace(Dibujo+": "+ModificacionesRequeridas);
  37. // Cosas que no vienen al caso.
  38. }
  39. } while (Dibujo<_level0.MaxCuadro);
  40. }

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
138  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:
Código
  1. function ModificarP2() {
  2. if (P2Valor<6) {
  3. P2Valor++;
  4. P2 = PosiblesSignos[P2Valor(PosiblesSignos.length)];
  5. } else {
  6. Continuar = "No";
  7. }
  8. }

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  :xD

---------------------------------------------------------------------------------------------------------

Finalmente: ¿Es posible simplificar este código, cómo?
Código
  1. // Este programa genera una comparación simple y su evaluación, pero:
  2. // Debe haber alguna parte cuyo contenido no está definido.
  3. // Ejemplo: 1 < ... : true
  4. // Luego intenta asignar el contenido faltante,
  5. // pero por ahora sólo si falta sólo 1.
  6. // Las siguientes funciones se usan en Resolvedor1, etc:
  7. function Comparacion() {
  8. if (P2 == "==") {
  9. Resultado = P1 == P3;
  10. } else if (P2 == "!=") {
  11. Resultado = P1 != P3;
  12. } else if (P2 == "<=") {
  13. Resultado = P1 <= P3;
  14. } else if (P2 == ">=") {
  15. Resultado = P1 >= P3;
  16. } else if (P2 == "<") {
  17. Resultado = P1 < P3;
  18. } else {
  19. Resultado = P1 > P3;
  20. }
  21. return Resultado+"" == P4;
  22. }
  23. function ModificarP1() {
  24. if (P1<10) {
  25. P1++;
  26. } else {
  27. Continuar = "No";
  28. }
  29. }
  30. function ModificarP2() {
  31. if (P2Valor<6) {
  32. P2Valor++;
  33. P2 = PosiblesSignos[P2Valor];
  34. } else {
  35. Continuar = "No";
  36. }
  37. }
  38. function ModificarP3() {
  39. if (P3<10) {
  40. P3++;
  41. } else {
  42. Continuar = "No";
  43. }
  44. }
  45. function ModificarP4() {
  46. if (P4 == "true") {
  47. P4 = "false";
  48. } else {
  49. Continuar = "No";
  50. }
  51. }
  52. // Se repite en F2, cuando hay 1 contenido indefinido y es el 1:
  53. function Resolvedor1 () {
  54. trace("Se probará el Candidato "+eval("P"+Indefinido));
  55. if (Comparacion()) {
  56. trace ("Solución hallada, ver respuesta.");
  57. Mensaje = Mensaje+"\n"+P1+" "+P2+" "+P3+": "+P4;
  58. gotoAndStop (3);
  59. } else if (Continuar == "Sí") {
  60. // Se modificará el candidato:
  61. eval(ModificadoraUsar)();
  62. } else {
  63. trace ("No se pudo hallar una solución.");
  64. gotoAndStop (3);
  65. }
  66. }
  67. PosiblesTiposDeContenido = ["Normal", "Indefinido"];
  68. PosiblesSignos = ["==", "!=", "<=", ">=", "<", ">"];
  69. // Generar las 4 partes hasta que se cumpla la condición:
  70. do {
  71. Indefinidos = 0;
  72. // Parte 1 (cosa 1 a comparar):
  73. TipoDelParte1 = PosiblesTiposDeContenido[random(PosiblesTiposDeContenido.length)];
  74. if (TipoDelParte1 == "Normal") {
  75. Parte1 = random(10);
  76. } else {
  77. Parte1 = "...";
  78. Indefinidos++;
  79. Indefinido = 1;
  80. // set("Indefinido"+Indefinidos, 1);
  81. }
  82. // Parte 2 (símbolo comparador):
  83. TipoDelParte2 = PosiblesTiposDeContenido[random(PosiblesTiposDeContenido.length)];
  84. if (TipoDelParte2 == "Normal") {
  85. Parte2 = PosiblesSignos[random(6)];
  86. } else {
  87. Parte2 = "...";
  88. Indefinidos++;
  89. Indefinido = 2;
  90. // set("Indefinido"+Indefinidos, 2);
  91. }
  92. // Parte 3 (cosa 2 a comparar):
  93. TipoDelParte3 = PosiblesTiposDeContenido[random(PosiblesTiposDeContenido.length)];
  94. if (TipoDelParte3 == "Normal") {
  95. Parte3 = random(10);
  96. } else {
  97. Parte3 = "...";
  98. Indefinidos++;
  99. Indefinido = 3;
  100. // set("Indefinido"+Indefinidos, 3);
  101. }
  102. // Parte 4 (evaluación):
  103. TipoDelParte4 = PosiblesTiposDeContenido[random(PosiblesTiposDeContenido.length)];
  104. if (TipoDelParte4 == "Normal") {
  105. // Definir esta parte según las anteriores:
  106. // ¿Fueron definidas?
  107. if (Parte1 != "..." && Parte2 != "..." && Parte3 != "...") {
  108. // Sí, ver qué definición corresponde:
  109. if (Parte2 == "==") {
  110. Parte4 = Parte1 == Parte3;
  111. } else if (Parte2 == "!=") {
  112. Parte4 = Parte1 != Parte3;
  113. } else if (Parte2 == "<=") {
  114. Parte4 = Parte1 <= Parte3;
  115. } else if (Parte2 == ">=") {
  116. Parte4 = Parte1 >= Parte3;
  117. } else if (Parte2 == "<") {
  118. Parte4 = Parte1 < Parte3;
  119. } else {
  120. Parte4 = Parte1 > Parte3;
  121. }
  122. } else {
  123. // No toda parte fue definida,
  124. // definir esta al azar:
  125. Parte4 = random(2);
  126. if (Parte4 == 0) {
  127. Parte4 = "true";
  128. } else {
  129. Parte4 = "false";
  130. }
  131. }
  132. } else {
  133. Parte4 = "...";
  134. Indefinidos++;
  135. Indefinido = 4;
  136. // set("Indefinido"+Indefinidos, 4);
  137. }
  138. } while (Indefinidos == 0);
  139. Mensaje = Parte1+" "+Parte2+" "+Parte3+": "+Parte4;
  140. // Marca si algún canditato puede modificarse:
  141. Continuar = "Sí";
  142. // Decidir qué resolvedor usar y preparar variables:
  143. if (Indefinidos == 1) {
  144. P1 = Parte1;
  145. P2 = Parte2;
  146. P3 = Parte3;
  147. P4 = Parte4;
  148. // Asignar un valor al contenido indefinido:
  149. if (Indefinido == 1) {
  150. P1 = 0;
  151. } else if (Indefinido == 2) {
  152. P2Valor = 0;
  153. P2 = "==";
  154. } else if (Indefinido == 3) {
  155. P3 = 0;
  156. } else {
  157. P4 = "true";
  158. }
  159. ResolvedoraUsar = "_level0.Resolvedor"+Indefinidos;
  160. ModificadoraUsar = "ModificarP"+Indefinido;
  161. } else {
  162. Mensaje = Mensaje+"\nAún no hay resolvedor para esta duda.";
  163. stop();
  164. }

La idea es solucionar problemas así cada vez más complejos. Esto es sólo el comienzo...
139  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:
Código
  1. // Para juzgar:
  2. // ¿El dibujo tiene menos de Largo/2 cuadraditos aislados?
  3. // Se actualizará el contador de pintados aislados:
  4. // De cada pintado al lado del recién pintado,
  5. // se verá si estaba aislado,
  6. // en cuyo caso disminuirá el contador.
  7. // Si no hay pintados al lado del nuevo, aumentará.
  8. CuadraditoAislado = "Sí";
  9. // ¿El modificado es el inferior derecho?
  10. if (Puntero == MaxPosiciondePuntero) {
  11. // Sí, ver el -1 (izquierdo), -L (up) y -L-1 (iu):
  12. // xSS
  13. // xS*
  14. if (eval("ColordeCuadradito"+(Puntero-1)) == 1) {
  15. CuadraditoAislado = "No";
  16. }
  17.  
  18.  
  19. if (eval("ColordeCuadradito"+(Puntero-CuadraditosPorFila)) == 1) {
  20. CuadraditoAislado = "No";
  21. } else if (eval("ColordeCuadradito"+(Puntero-CuadraditosPorFila-1)) == 1) {
  22. CuadraditoAislado = "No";
  23. }
  24. } else if (Puntero > MinCuadraditoInferior) {
  25. // Inferior no en una esquina,
  26. // contar el +1 (derecho), -1, -L+1 (du), -L y -L-1:
  27. // SSS
  28. // S*S
  29. if (eval("ColordeCuadradito"+(Puntero+1)) == 1) {
  30. CuadraditoAislado = "No";
  31. } else if (eval("ColordeCuadradito"+(Puntero-1) == 1) {
  32. CuadraditoAislado = "No";
  33. } else if (eval("ColordeCuadradito"+(Puntero-CuadraditosPorFila+1)) == 1) {
  34. CuadraditoAislado = "No";
  35. } else if (eval("ColordeCuadradito"+(Puntero-CuadraditosPorFila)) == 1) {
  36. CuadraditoAislado = "No";
  37. } else if (eval("ColordeCuadradito"+(Puntero-CuadraditosPorFila-1)) == 1) {
  38. CuadraditoAislado = "No";
  39. }
  40. } else if (Puntero == MinCuadraditoInferior) {
  41. // Inferior izquierdo,
  42. // contar el +1, -L+1 y -L:
  43. // SSx
  44. // *Sx
  45. if (eval("ColordeCuadradito"+(Puntero+1)) == 1) {
  46. CuadraditoAislado = "No";
  47. } else if (eval("ColordeCuadradito"+(Puntero-CuadraditosPorFila+1)) == 1) {
  48. CuadraditoAislado = "No";
  49. } else if (eval("ColordeCuadradito"+(Puntero-CuadraditosPorFila)) == 1) {
  50. CuadraditoAislado = "No";
  51. }
  52. } else if (Puntero > CuadraditosPorFila) {
  53. // No es superior.
  54. if (Puntero%CuadraditosPorFila == 0) {
  55. // Central derecho,
  56. // contar el +L, +L-1, -1, -L y -L-1:
  57. // xSS
  58. // xS*
  59. // xSS
  60. if (eval("ColordeCuadradito"+(Puntero+CuadraditosPorFila)) == 1) {
  61. CuadraditoAislado = "No";
  62. } else if (eval("ColordeCuadradito"+(Puntero+CuadraditosPorFila-1)) == 1) {
  63. CuadraditoAislado = "No";
  64. } else if (eval("ColordeCuadradito"+(Puntero-1)) == 1) {
  65. CuadraditoAislado = "No";
  66. } else if (eval("ColordeCuadradito"+(Puntero-CuadraditosPorFila)) == 1) {
  67. CuadraditoAislado = "No";
  68. } else if (eval("ColordeCuadradito"+(Puntero-CuadraditosPorFila-1)) == 1) {
  69. CuadraditoAislado = "No";
  70. }
  71. } else if (Puntero%CuadraditosPorFila != 1) {
  72. // Central, contar todos los contiguos:
  73. // SSS
  74. // S*S
  75. // SSS
  76. if (eval("ColordeCuadradito"+(Puntero+CuadraditosPorFila+1)) == 1) {
  77. CuadraditoAislado = "No";
  78. } else if (eval("ColordeCuadradito"+(Puntero+CuadraditosPorFila)) == 1) {
  79. CuadraditoAislado = "No";
  80. } else if (eval("ColordeCuadradito"+(Puntero+CuadraditosPorFila-1)) == 1) {
  81. CuadraditoAislado = "No";
  82. } else if (eval("ColordeCuadradito"+(Puntero+1)) == 1) {
  83. CuadraditoAislado = "No";
  84. } else if (eval("ColordeCuadradito"+(Puntero-1)) == 1) {
  85. CuadraditoAislado = "No";
  86. } else if (eval("ColordeCuadradito"+(Puntero-CuadraditosPorFila+1)) == 1) {
  87. CuadraditoAislado = "No";
  88. } else if (eval("ColordeCuadradito"+(Puntero-CuadraditosPorFila)) == 1) {
  89. CuadraditoAislado = "No";
  90. } else if (eval("ColordeCuadradito"+(Puntero-CuadraditosPorFila-1)) == 1) {
  91. CuadraditoAislado = "No";
  92. }
  93. } else {
  94. // Central izquierdo,
  95. // contar el +L+1, +L, +1, -L+1 y -L:
  96. // SSx
  97. // *Sx
  98. // SSx
  99. if (eval("ColordeCuadradito"+(Puntero+CuadraditosPorFila+1)) == 1) {
  100. CuadraditoAislado = "No";
  101. } else if (eval("ColordeCuadradito"+(Puntero+CuadraditosPorFila)) == 1) {
  102. CuadraditoAislado = "No";
  103. } else if (eval("ColordeCuadradito"+(Puntero+1)) == 1) {
  104. CuadraditoAislado = "No";
  105. } else if (eval("ColordeCuadradito"+(Puntero-CuadraditosPorFila+1)) == 1) {
  106. CuadraditoAislado = "No";
  107. } else if (eval("ColordeCuadradito"+(Puntero-CuadraditosPorFila)) == 1) {
  108. CuadraditoAislado = "No";
  109. }
  110. }
  111. } else if (Puntero == CuadraditosPorFila) {
  112. // Superior derecho,
  113. // contar el +L+1, +L y +1:
  114. // *Sx
  115. // SSx
  116. if (eval("ColordeCuadradito"+(Puntero+CuadraditosPorFila+1)) == 1) {
  117. CuadraditoAislado = "No";
  118. } else if (eval("ColordeCuadradito"+(Puntero+CuadraditosPorFila)) == 1) {
  119. CuadraditoAislado = "No";
  120. } else if (eval("ColordeCuadradito"+(Puntero+1)) == 1) {
  121. CuadraditoAislado = "No";
  122. }
  123. } else if (Puntero > 1) {
  124. // Superior cemtral,
  125. // contar el +L+1, +L, +L-1, +1 y -1:
  126. // S*S
  127. // SSS
  128. if (eval("ColordeCuadradito"+(Puntero+CuadraditosPorFila+1)) == 1) {
  129. CuadraditoAislado = "No";
  130. } else if (eval("ColordeCuadradito"+(Puntero+CuadraditosPorFila)) == 1) {
  131. CuadraditoAislado = "No";
  132. } else if (eval("ColordeCuadradito"+(Puntero+CuadraditosPorFila-1)) == 1) {
  133. CuadraditoAislado = "No";
  134. } else if (eval("ColordeCuadradito"+(Puntero+1)) == 1) {
  135. CuadraditoAislado = "No";
  136. } else if (eval("ColordeCuadradito"+(Puntero-1)) == 1) {
  137. CuadraditoAislado = "No";
  138. }
  139. } else {
  140. // Superior izquierdo,
  141. // contar el +L+1, +L y +1:
  142. // *Sx
  143. // SSx
  144. if (eval("ColordeCuadradito"+(Puntero+CuadraditosPorFila+1)) == 1) {
  145. CuadraditoAislado = "No";
  146. } else if (eval("ColordeCuadradito"+(Puntero+CuadraditosPorFila)) == 1) {
  147. CuadraditoAislado = "No";
  148. } else if (eval("ColordeCuadradito"+(Puntero-1)) == 1) {
  149. CuadraditoAislado = "No";
  150. }
  151. }
  152. if (CuadraditoAislado == "Sí") {
  153. CuadraditosAislados++;
  154. }
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 :/
140  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.
Páginas: 1 2 3 4 5 6 7 8 9 10 11 12 13 [14] 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 ... 50
WAP2 - Aviso Legal - Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines