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


Tema destacado: Arreglado, de nuevo, el registro del warzone (wargame) de EHN


  Mostrar Mensajes
Páginas: 1 ... 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 [26] 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 ... 243
251  Programación / Programación General / Re: Busco eficiencia, tengo while con función y quiero evitar un if. en: 22 Noviembre 2024, 18:30 pm
Creo que te confundiste de tema, tu respuesta sería para el tema de los passwords. Si es así, dime y lo hablamos allá, o sea acá:
https://foro.elhacker.net/programacion_general/iquestcomo_generar_passwords_rapido_flash_es_muy_lento_y_mi_pc_creo_que_no_resiste-t522729.0.html;topicseen
252  Programación / Programación General / Busco eficiencia, tengo while con función y quiero evitar un if. en: 22 Noviembre 2024, 07:37 am
Tengo algo como:
Código
  1. Repetir
  2. Si se puede variar
  3. VariaciónConChequeoNormal
  4. Si se capta simetría
  5. repetir pero VariaciónConChequeoExtra
  6. sino
  7. repetir normalmente
  8. sino
  9. despintar
  10. mientras no se capte un dibujo ok

Básicamente, en un caso tengo que hacer unos chequeos extra que normalmente no, así que no quiero hacerlos si es innecesario, pero quiero evitar poner ese if en el código que siento que es innecesario (*), y por cómo es el código es complicado... ¿Basado en eso se les ocurre algo?

Me refiero a algo así:
Código
  1. Repetir
  2. Si se puede variar
  3. Si no se captó simetría
  4. VariaciónConChequeoNormal
  5. sino
  6. VariaciónConChequeoExtra
  7. fin del si
  8. Si se capta simetría
  9. Marcar que se detectó simetría y repetir
  10. sino
  11. Marcar que no se detectó simetría y repetir
  12. sino
  13. despintar
  14. mientras no se capte un dibujo ok

Esto:
Código:
Si no se captó simetría
VariaciónConChequeoNormal
sino
VariaciónConChequeoExtra
fin del si

Si en vez de VariaciónConChequeoExtra se pudiera poner un do parecido al original, tal vez... Lo pensaré.


Aquí una explicación más detallada:
Intento que un programa genere todos los dibujos de X*X cuadraditos en blanco y negro, que cumplan ciertas condiciones, X va aumentando. Las condiciones son:
// debe tener algún cuadradito pintado en cada columna y fila,
// no debe haber muchos pintados aislados,
// no debe ser simétrico (espejo vertical | ) a alguno ya mostrado,
// y no debe tener demasiados cuadraditos despintados (contando desde el MinPintado, que se cuenta desde arriba a la derecha, como un texto).

El conteo de aislados, cuando se pinta un cuadradito, no es completo porque no es necesario, porque como se pintan desde abajo a la izquierda, nunca habrá uno pintado a la derecha ni abajo, como se explica aquí (más abajo está el código completo):
// Debido a que al pintar un cuadradito...
// los de abajo y el de la derecha estarán despintados,
// sólo se miran el de la izquierda y los de arriba:
Eso es el chequeo normal.

Cuando se capta que un dibujo es simétrico a uno ya hecho, para evitar que se generen posibles otros simétricos se modifica el cuadradito más derecho de la fila donde se detectó la falla, en vez de modificar el cuadradito de más abajo o donde fuera normalmente. Esto es bueno, pero al hacerlo se requiere un chequeo extra de los aislados, porque en este caso puede que haya pintados abajo.

Son suposiciones sobre este programa, un error que me ha parecido detectar, no es que lo tenga del todo claro.

He pensado, como puse arriba, en crear 2 funciones para los 2 tipos de variaciones, pero no quiero usar un if, siento que no es necesario.

Código
  1. // En este programa hay cuadraditos nombrados así:
  2. // 123
  3. // 456
  4. // 789
  5. // Se irán pintando diferentes combinaciones y...
  6. // su tamaño se reducirá a medida que...
  7. // la cantidad por fila y columna aumente.
  8. // Para que un dibujo se muestre...
  9. // debe tener algún cuadradito pintado en cada columna y fila,
  10. // no debe haber muchos pintados aislados,
  11. // no debe ser simétrico (espejo vertical | ) a alguno ya mostrado,
  12. // y no debe tener demasiados cuadraditos despintados
  13. // (contando desde el MinPintado).
  14. // Ver frame 2 por más información.
  15. //
  16. // CuadraditosPorFila es también porColumna.
  17. // Debido a que en cierto chequeo se asume que...
  18. // si el cuadradito no está en la parte inferior ni...
  19. // superior entonces está en una fila intermedia,
  20. // conviene que CuadraditosPorFila comience siendo >1;
  21. // aumenta 1 antes de aplicarse:
  22. CuadraditosPorFila = 2;
  23. // Usada en Variar:
  24. function ObtenerColumnayFila () {
  25. Fila = Math.ceil(Puntero/CuadraditosPorFila);
  26. // trace ("Su Fila según el cálculo es: "+Fila);
  27. Columna = (Puntero-1)%CuadraditosPorFila+1;
  28. // trace ("Su Columna: "+Columna);
  29. // Esto se usa para evitar repeticiones...
  30. // de concatenaciones y simplificarlas:
  31. ColumnaRelevante = "PintadosenC"+Columna;
  32. FilaRelevante = "PintadosenF"+Fila;
  33. }
  34. // Usada en ParteDeContarEtc:
  35. function PosibleIncrementoDeContiguosPintados () {
  36. // ¿El contiguo indicado está pintado?
  37. if (eval("Cuadradito"+Fila3+"_"+Columna3) == 0) {
  38. // Sí, aumentar contador:
  39. ContiguosPintados++;
  40. // trace ("De ese contiguo ("+Fila2+"_"+Columna2+"), su contiguo "+Fila3+"_"+Columna3+" está pintado; por ahora se vió que tiene "+ContiguosPintados+" contiguos pintados.");
  41. }
  42. }
  43. // Usada en ContarContiguosDeContiguoAlNewPintado y ContarContiguosDeContiguoAlNewDespintado:
  44. function ParteDeContarEtc () {
  45. ContiguosPintados = 0;
  46. // trace("Analizando su inferior derecho.");
  47. Fila3 = Fila2+1;
  48. Columna3 = Columna2+1;
  49. PosibleIncrementoDeContiguosPintados();
  50. // trace("Analizando su inferior.");
  51. Columna3--;
  52. PosibleIncrementoDeContiguosPintados();
  53. // trace("Analizando su inferior izquierdo.");
  54. Columna3--;
  55. PosibleIncrementoDeContiguosPintados();
  56. // trace("Analizando su derecho.");
  57. Columna3 = Columna3+2;
  58. Fila3--;
  59. PosibleIncrementoDeContiguosPintados();
  60. // trace("Analizando su izquierdo.");
  61. Columna3 = Columna3-2;
  62. PosibleIncrementoDeContiguosPintados();
  63. // trace("Analizando su superior derecho.");
  64. Columna3 = Columna3+2;
  65. Fila3--;
  66. PosibleIncrementoDeContiguosPintados();
  67. // trace("Analizando su superior.");
  68. Columna3--;
  69. PosibleIncrementoDeContiguosPintados();
  70. // trace("Analizando su superior izquierdo.");
  71. Columna3--;
  72. PosibleIncrementoDeContiguosPintados();
  73. }
  74. // Usada en Variar:
  75. function ContarContiguosDeContiguoAlNewPintado () {
  76. // ¿El contiguo indicado está pintado?
  77. // trace ("Analizando Cuadradito"+Fila2+"_"+Columna2+": "+eval("Cuadradito"+Fila2+"_"+Columna2));
  78. if (eval("Cuadradito"+Fila2+"_"+Columna2) == 0) {
  79. // Sí, el recién pintado no está aislado:
  80. ElRecienPintadoEstaAislado = "No";
  81. // trace ("Está pintado; el recién pintado no está aislado.");
  82. // Se contarán los contiguos de este (contiguo al recién...).
  83. ParteDeContarEtc();
  84. // trace ("Ese contiguo ("+Fila2+"_"+Columna2+") al recién pintado tiene "+ContiguosPintados+" contiguos pintados.");
  85. // ¿Estaba aislado?
  86. if (ContiguosPintados == 1) {
  87. // Sí, reducir el contador:
  88. CuadraditosAislados--;
  89. // trace ("El contiguo al recién pintado sólo tiene 1 contiguo pintado, estaba aislado, ahora hay "+CuadraditosAislados+" aislados.");
  90. }
  91. } else {
  92. // trace ("No está pintado.");
  93. }
  94. }
  95. // Usada en Variar:
  96. function ContarContiguosDeContiguoAlNewDespintado () {
  97. // ¿El contiguo indicado está pintado?
  98. // trace ("Analizando Cuadradito"+Fila2+"_"+Columna2+": "+eval("Cuadradito"+Fila2+"_"+Columna2));
  99. if (eval("Cuadradito"+Fila2+"_"+Columna2) == 0) {
  100. // Sí, el recién despintado no estaba aislado:
  101. ElRecienDespintadoEstabaAislado = "No";
  102. // trace ("Está pintado; el recién despintado no estaba aislado.");
  103. // Se contarán los contiguos de este (contiguo al recién...).
  104. ParteDeContarEtc();
  105. // trace ("Ese contiguo ("+Fila2+"_"+Columna2+") al recién despintado tiene "+ContiguosPintados+" contiguos pintados.");
  106. // ¿Está aislado?
  107. if (ContiguosPintados == 0) {
  108. // Sí, aumentar el contador:
  109. CuadraditosAislados++;
  110. // trace ("El contiguo al recién despintado quedó aislado, ahora hay "+CuadraditosAislados+" aislados.");
  111. }
  112. } else {
  113. // trace ("No está pintado.");
  114. }
  115. }
  116. // En F3 se repite:
  117. function Variar () {
  118. // Repetir mientras no se produzca un dibujo ok:
  119. do {
  120. // Esto para modificar la variable que indica el color,
  121. // que es 0 o 1:
  122. ReferenciaAlColoraModificar = "ColordeCuadradito"+Puntero;
  123. ColoraModificar = eval(ReferenciaAlColoraModificar);
  124. // Esto para el color real:
  125. NuevoColor = new Color("Cuadradito"+Puntero);
  126. // ¿El cuadradito puede cambiar de color?
  127. if (ColoraModificar>0) {
  128. // Sí, hacer los cambios:
  129. // En la variable:
  130. set (ReferenciaAlColoraModificar, ColoraModificar-1);
  131. // Del color real:
  132. NuevoColor.setRGB(0);
  133. // trace ("   Se pintó el cuadradito "+Puntero);
  134. // Asignarle el color de la 2nda manera:
  135. ObtenerColumnayFila();
  136. set ("Cuadradito"+Fila+"_"+Columna, 0);
  137. // Incrementar contador de cuadraditos pintados en...:
  138. // la columna y fila donde se pintó:
  139. set (ColumnaRelevante, eval(ColumnaRelevante)+1);
  140. set (FilaRelevante, eval(FilaRelevante)+1);
  141. // Actualizar cantidad de cuadraditos pintados aislados:
  142. // De cada pintado al lado del recién pintado,
  143. // se verá si estaba aislado,
  144. // en cuyo caso disminuirá el contador.
  145. // Si no hay pintados al lado del nuevo, aumentará.
  146. // trace ("Se actualizará el contador de pintados aislados:");
  147. // Esta variable puede cambiar, se refiere al recién pintado:
  148. ElRecienPintadoEstaAislado = "Sí";
  149. // Para analizar a su izquierdo:
  150. Fila2 = Fila;
  151. Columna2 = Columna-1;
  152. // Si su izquierdo existe y está pintado,
  153. // entonces el actual no está aislado,
  154. // y se mira si el izquierdo de ese estaba aislado:
  155. // Cuántos de sus contiguos están pintados.
  156. // Si la cantidad es 1, estaba aislado,
  157. // el contador de Aislados baja.
  158. // Debido a que al pintar un cuadradito...
  159. // los de abajo y el de la derecha estarán despintados,
  160. // sólo se miran el de la izquierda y los de arriba:
  161. ContarContiguosDeContiguoAlNewPintado();
  162. // Para analizar a su izquierdo de arriba:
  163. Fila2--;
  164. ContarContiguosDeContiguoAlNewPintado();
  165. // Para analizar al de arriba:
  166. Columna2++;
  167. ContarContiguosDeContiguoAlNewPintado();
  168. // Para analizar a su derecho de arriba:
  169. Columna2++;
  170. ContarContiguosDeContiguoAlNewPintado();
  171. if (ElRecienPintadoEstaAislado == "Sí") {
  172. // trace("El recién pintado está aislado");
  173. CuadraditosAislados++;
  174. }
  175. // trace("        El dibujo tiene "+CuadraditosAislados+" cuadraditos aislados");
  176. // Actualizar contador de despintados
  177. // (contando desde MinPintado)
  178. CuadraditosDespintados--;
  179. // Para juzgar:
  180. // ¿El dibujo tiene cuadraditos pintados en toda columna y fila?
  181. Puntero2 = 0;
  182. // Esto puede que cambie:
  183. CuadraditoenCadaFyC = "Sí";
  184. do {
  185. Puntero2 = Puntero2+1;
  186. // ¿La columna Puntero2 no tiene algún cuadradito pintado?
  187. if (eval("PintadosenC"+Puntero2)<1) {
  188. CuadraditoenCadaFyC = "No";
  189. } else if (eval("PintadosenF"+Puntero2)<1) {
  190. // La fila Puntero2 no tiene algún cuadradito pintado.
  191. CuadraditoenCadaFyC = "No";
  192. }
  193. } while (CuadraditoenCadaFyC == "Sí" && Puntero2<CuadraditosPorFila);
  194. // ¿El dibujo tiene cuadraditos pintados en toda columna y fila?
  195. if (CuadraditoenCadaFyC == "No") {
  196. // No, no mostrarlo y hacer otro:
  197. // trace ("    No ocupa cada F y C, salteándolo.");
  198. DibujosPequeños++;
  199. // Actualizar MinCuadraditoPintado si corresponde:
  200. if (Puntero<MinCuadraditoPintado) {
  201. MinCuadraditoPintado = Puntero;
  202. // trace(Puntero);
  203. // Como ahora se cuenta un cuadradito extra,
  204. // que estaba despintado, el contador aumenta:
  205. CuadraditosDespintados++;
  206. // Si se llegó al punto en que los dibujos...
  207. // pueden ser simétricos a unos ya hechos:
  208. if (Puntero<CuadraditoCentraloCD) {
  209. // En el próximo dibujo se pintará el superior derecho:
  210. Puntero = CuadraditosPorFila;
  211. } else {
  212. // Preparar Puntero para generar el próximo dibujo:
  213. Puntero = MaxPosiciondePuntero;
  214. }
  215. } else {
  216. // Preparar Puntero para generar el próximo dibujo:
  217. Puntero = MaxPosiciondePuntero;
  218. }
  219. } else if (CuadraditosAislados>MaxCuadraditosAislados) {
  220. // trace ("    Tiene demasiados cuadraditos pintados aislados: "+CuadraditosAislados+" salteándolo.");
  221. DibujosAislados++;
  222. // Preparar Puntero para generar el próximo dibujo:
  223. Puntero = MaxPosiciondePuntero;
  224. } else if (MinCuadraditoPintado<CuadraditoCentraloCD) {
  225. // El dibujo puede ser simétrico...
  226. // a otro ya mostrado. ¿Lo es?
  227. // Esto puede cambiar:
  228. DibujoEsSimetrico = "No";
  229. // Captar valor (colores) de cada fila;
  230. // si alguno es menor al inverso, sí:
  231. PunteroDeFilas = 0;
  232. do {
  233. PunteroDeFilas++;
  234. PunteroDeColumnas = 0;
  235. PunteroInverso = CuadraditosPorFila;
  236. do {
  237. PunteroDeColumnas++;
  238. Valor = eval("Cuadradito"+PunteroDeFilas+"_"+PunteroDeColumnas);
  239. ValorInverso = eval("Cuadradito"+PunteroDeFilas+"_"+PunteroInverso);
  240. // trace("Valor: "+Valor);
  241. // trace("ValorInverso: "+ValorInverso);
  242. if (Valor<ValorInverso) {
  243. DibujoEsSimetrico = "Sí";
  244. FilaFallada = PunteroDeFilas;
  245. PunteroDeFilas = CuadraditosPorFila;
  246. break;
  247. } else if (Valor>ValorInverso) {
  248. // Es ok:
  249. PunteroDeFilas = CuadraditosPorFila;
  250. break;
  251. }
  252. PunteroInverso--;
  253. } while (PunteroDeColumnas<CuadraditosPorFila);
  254. } while (PunteroDeFilas<CuadraditosPorFila);
  255. // Este if es probablemente innecesario,
  256. // porque se supone que el dibujo será simétrico u ok,
  257. // antes de que se terminen de comparar todas las filas.
  258. if (DibujoEsSimetrico == "Sí") {
  259. // trace ("  El dibujo es simétrico a otro ya mostrado.");
  260. DibujosSimetricos++;
  261. // Al Puntero ponerlo al final de la fila...
  262. // captada como simétrica, para posiblemente...
  263. // evitar algunos otros dibujos simétricos:
  264. Puntero = CuadraditosPorFila*FilaFallada;
  265. } else if (CuadraditosDespintados<MinCuadraditosDespintados) {
  266. trace ("  El dibujo tiene demasiados cuadraditos despintados: "+CuadraditosDespintados);
  267. DibujosDensos++;
  268. // Preparar Puntero para generar el próximo dibujo:
  269. Puntero = MaxPosiciondePuntero;
  270. } else {
  271. DibujosOk++;
  272. // trace ("  Mostrando dibujo nro: "+DibujosOk);
  273. // Preparar Puntero para generar el próximo dibujo:
  274. Puntero = MaxPosiciondePuntero;
  275. play ();
  276. break;
  277. }
  278. } else if (CuadraditosDespintados<MinCuadraditosDespintados) {
  279. trace ("  El dibujo tiene demasiados cuadraditos despintados: "+CuadraditosDespintados);
  280. DibujosDensos++;
  281. // Preparar Puntero para generar el próximo dibujo:
  282. Puntero = MaxPosiciondePuntero;
  283. } else {
  284. DibujosOk++;
  285. // trace ("  Mostrando dibujo nro: "+DibujosOk);
  286. // Preparar Puntero para generar el próximo dibujo:
  287. Puntero = MaxPosiciondePuntero;
  288. play ();
  289. break;
  290. }
  291. } else {
  292. // Despintar un cuadradito, no viene al caso.
  293. }
  294. } while (true);
  295. }
  296.  

Pero dudo que convenga poner por ahí una copia modificada de todo eso... Tendría que crear muchas funciones. No sé, joder ¿ideas?
253  Programación / Programación General / ¿Cómo generar passwords rápido? Flash es muy lento y mi PC creo que no resiste. en: 22 Noviembre 2024, 04:21 am
Si pongo un while probablemente se tranque porque tarda mucho, y si pongo que el código se ejecute en cada frame es muy lento, pero aunque se me acaba de ocurrir que se ejecute más de 1 vez por frame, el otro problema es que mi PC no creo que pueda seguir ejecutando ese programa, si el texto generado es mucho.

Conozco estas formas de generarlo:

A- En traces, que son como prints. Ya vi que entre más haya, más se enlentece.

B- En un cuadro de texto. Dudo que sea mejor.

C- En variables, un password por cada variable (P1 = "Aaaa", P2 = ... etc). Idem. Luego copiaría las variables, sustituiría = por tab, lo pegaría en Excel y quedarían los contenidos de las variables listos para copiar, separados de sus nombres y del =.

D- En 1 variable, poniendo salto de línea. Podría ser mejor que lo anterior, pero que los traces no sé.

Arrays, guardar en archivos, en fin, como sea, creo que Flash es muy lento para esto. Pensé eb Excel ¿será muy lento? ¿qué programa recomiendan, que permita copiar los passwords o genere un archivo de ellos?
Quiero que se generen por mi código, aclaro, ya lo tengo, tendría que conviertirlo al lenguaje que me recomienden ¿cual? ¿y cómo lo uso?

Otra aclaración, aunque en el fondo no sirve: Es para averiguar un password que olvidé, de un archivo mío, o de varios míos, con passwords que olvidé (no sé si tienen el mismo password o se diferencian en 1 caracter).
254  Informática / Software / Re: En Excel, especificar fórmulas más rápido. en: 21 Noviembre 2024, 04:51 am
Usando reemplazar en el bloc de notas separé lo que tenía escrito, cambié algunos números que sirven de referencia a qué fila mirar y con eso parece que quedó bien...
Elegí una variable random y el resultado fue mejor del que obtuve manualmente, pues me equivoqué al poner un 1 donde debía poner 0. No es una comprobación ideal pero para mí es suficiente como para seguir avanzando.

https://docs.google.com/spreadsheets/d/1qUmI-h8Y9OxPEcPin9m78g3r5bwUeGrL/edit?usp=sharing&ouid=109273743447273895658&rtpof=true&sd=true

Nota: No me deja modificar el título para poner solucionado, ni está la opción de ponerlo.
255  Foros Generales / Foro Libre / ¿Qué programa te gustaría que yo haga? Gratis y te doy el editable. en: 19 Noviembre 2024, 23:28 pm
No me pidan cosas complicadísimas, que no sé tanto.

Tampoco cosas que claramente son no éticas (aunque la mayoría está descartada por lo anterior).

Sería en Macromedia Flash 5.

Te doy el exe.

Un swf que lo puedes abrir con el reproductor que viene con el editor Flash. Los reproductores que se descargaban sueltos, para Youtube y similares, no sé si sirven.
Por lo que sé, los swf son menos peligrosos, los exes pueden crear/modificar archivos, los swf no he visto que puedan (aunque es probable).

Y te doy el fla, el archivo editable, que lo puedes abrir con el editor Flash.

Si por algún motivo cierran el tema, me pueden enviar un mensaje privado.


Simplemente para practicar y ver qué quiere la gente. Por ahora lo que me pidieron fue:
- Algo para ganar en juegos de azar. Complicado y no ético.
- Un programa que diga si otro termina o no. Dicen que es imposible en ciertos casos, que hay paradojas.

Cosas que he visto en este foro:
A- Ganar dinero, objetos, etc, sin esfuerzo.
B- Ubicar a supuesto acosador, estafador o hacker.
C- Robar cuenta del amigo porque no le dice cómo hacer trampa en juego, por ejemplo.
D- Aparente virus, de broma.
E- Recuperar cuenta que el servicio se niega a dar.

A: No sé, además esfuérzate y merécelo, o juegoa algún juego donde a nadie le importe si haces trampa.
B: Tampoco sé, además no se sabe si la historia es verídica, y no es el acosador quien pide ubicar a la persona.
C: Idem, y busca mejores amigos/juegos.
D: Prefiero algo útil, pero podría intentar. Igual ya hay, mejor que busquen por ahí.
E: No sé, y es similar a B.


En cuanto a que el problema es que sea en Flash, ni idea, es como que te ofrezcan una silla hecha a martillazo común y con una madera que la pueden comer las hormigas, por poner un ejemplo. ¿Qué importa si fue hecha con un martillo común o uno eléctrico y taladro y demás? Importa que funcione. En cuanto a los peligros por madera de mala calidad, no la lleves donde haya hormigas y listo. Son juegos offline, no sé online, no usan Internet, así que si te pueden hackear alguno no es problema del juego sino que el hacker ese tiene mucho nivel, es como que te pueda hackear el buscaminas...

Ah, sí, puede que pida ayuda a una IA o a gente, claro.
256  Programación / Programación General / Re: Simulación de choques desde atrás. en: 19 Noviembre 2024, 16:28 pm
A la izquierda se notan problemas a medida que avanza el juego, pero más allá de eso se volvió más aburrido, es como que sólo se mueve un barril a la vez :/
¿Así es realista o hice algo mal?

https://youtu.be/Ouy3ysDW6L0

Código
  1. function MoveBarriles () {
  2. // Empieza desde 2 porque el 1 no existe, porque cada objeto tiene una "profundidad" que determina cual aparece delante/atrás y se basa en el número del barril, para más facilidad, pero el número 1 está reservado para el personaje.
  3. Moved = 1;
  4. do {
  5. Moved++;
  6. // I es un objeto donde van las imágenes, es útil para eliminarlas todas a la vez, por ejemplo.
  7. BarrilaMover = "I.Barril"+Moved;
  8. BarrilSpeed = BarrilaMover+"Speed";
  9. EvaluedBarrilSpeed = eval(BarrilSpeed);
  10. // Aplicar rozamiento:
  11. if (EvaluedBarrilSpeed > 0) {
  12. EvaluedBarrilSpeed = EvaluedBarrilSpeed/1.0025;
  13. if (EvaluedBarrilSpeed < 0.05) {
  14. EvaluedBarrilSpeed = 0;
  15. }
  16. set(BarrilSpeed, EvaluedBarrilSpeed);
  17. }
  18. setProperty (BarrilaMover, _x, getProperty(BarrilaMover, _x)+EvaluedBarrilSpeed);
  19. // Resumen:
  20. Res = BarrilaMover+".Part";
  21. // El barril no se gira sino que se gira una parte suya, porque como no es redondo no se ve bien cuando se gira. Lo copié de un juego y lo quiero así a pesar de sus defectos.
  22. setProperty (Res, _rotation, getProperty(Res, _rotation)+EvaluedBarrilSpeed*2);
  23. // Si tocan al personaje y él se está moviendo:
  24. if (I.Player.hitTest(eval(BarrilaMover)) == true && I.Player.Action == "Walking") {
  25. // Game over:
  26. gotoAndStop (3);
  27. break;
  28. } else {
  29. // Ver si tocó al barril anterior, que está delante:
  30. BarrilAnterior = "I.Barril"+(Moved-1);
  31. if (eval(BarrilaMover).hitTest(eval(BarrilAnterior)) == true) {
  32. // Pasarle la velocidad:
  33. set(BarrilAnterior+"Speed", eval(BarrilAnterior+"Speed")+EvaluedBarrilSpeed);
  34. // Quedar sin velocidad:
  35. set(BarrilSpeed, 0);
  36. }
  37. }
  38. } while (Moved<Barriles);
  39. }

Si hay algo del código que no entiendan pueden preguntar.
257  Programación / Scripting / Re: Actionscript en: 19 Noviembre 2024, 15:37 pm
Si posteas el código o dices qué hace el programa quizá pueda ayudarte.

Pero si lo quieres para esto:
https://foro.elhacker.net/dudas_generales/obtener_metodo_de_login_de_un_juego_flash-t520858.0.html;msg2276671#msg2276671
...entonces no creo porque eso ya es ingeniería inversa, temas de seguridad, que no sé mucho.

En fin, parece que quieres que se adivine algo de un programa luego de adivinar qué quieres :/
258  Programación / Programación General / Re: ¿Se puede evitar estos ifs, cómo? en: 19 Noviembre 2024, 06:39 am
Acá, dentro de un while, tengo un problema similar, aunque más sencillo:
Código
  1. // Barril se movió.
  2. // Si toca al personaje:
  3. if (I.Player.hitTest(eval(BarrilaMover)) == true) {
  4. // Si él se está moviendo:
  5. if (I.Player.Action == "Walking") {
  6. // Game over:
  7. gotoAndStop (3);
  8. }
...a partir de ahí, si no hay Game over, quiero ver si el barril toca a otro barril. En realidad acabo de notar que eso no me sirve, pero supongamos que sí, quiero ver cómo se resolvería. Si uno los ifs (los que ya tiene el código) con una &&, no hay problema, salvo que me queda largo y feo el if, me gusta que cada condición esté en una línea distinta. Quizá concatenando las variables antes lograría eso. Pero si no uno los ifs, parece que debo poner 2 elses con lo mismo:
Código
  1. // Barril se movió.
  2. // Si toca al personaje:
  3. if (I.Player.hitTest(eval(BarrilaMover)) == true) {
  4. // Si él se está moviendo:
  5. if (I.Player.Action == "Walking") {
  6. // Game over:
  7. gotoAndStop (3);
  8. } else {
  9. // Ver si toca otro barril.
  10. }
  11. } else {
  12. // Ver si toca otro barril.
  13. }

No quiero ver eso y luego ver si hay game over, porque si hay game over no tiene sentido que se haga eso xP
259  Programación / Programación General / Re: Cambiar partes de un color definido hexadecimalmente. en: 19 Noviembre 2024, 05:01 am
Con tu ayuda y la de GPT lo hice.

Usando estas funciones:
Código
  1. function ConvertirHexEnDec (Hexadecimal) {
  2.    return parseInt(Hexadecimal, 16);
  3. }
  4. function ConvertirDecEnHex (Decimal) {
  5.    Hexadecimal = Decimal.toString(16).toUpperCase();
  6. if (Hexadecimal.length == 1) {
  7. Hexadecimal = "0"+Hexadecimal;
  8. }
  9. return Hexadecimal;
  10. }
  11. function ActualizarColorDelFondo () {
  12. // Formar el color:
  13. ColorDelFondo = Rojo+Verde+Azul;
  14. // Actualizar el color del objeto:
  15. ColorDelObjetoFondo.setRGB(parseInt(ColorDelFondo, 16));
  16. }

Y por ejemplo el botón azul de +1:
Código
  1. on (release) {
  2. // Del color obtener la parte a modificar:
  3. Azul = ColorDelFondo.substr(4, 2);
  4. // Convertirla en decimal:
  5. Azul = ConvertirHexEnDec(Azul);
  6. // Se aumenta 1 a esa parte y si supera 255 queda en 255:
  7. Azul = Math.min(Azul+1, 255);
  8. // Convertirlo en hexadecimal:
  9. Azul = ConvertirDecEnHex(Azul);
  10. // Obtener las otras partes:
  11. Rojo = ColorDelFondo.substr(0, 2);
  12. Verde = ColorDelFondo.substr(2, 2);
  13. ActualizarColorDelFondo ()
  14. }

Cada botón es un poco distinto pero se entiende la idea.

Hace años lo hice poniendo que si el valor era "A" pasaba a "B", que si era "B" pasaba a "C", etc, un lío, por eso quería hacerlo mejor.

Acá está:
Código
  1. on (release) {
  2.    _root.CFModo = 0;
  3.    _root.CPartB = _root.Fondo.substring( 5, 6 );
  4.    _root.CPartA = _root.Fondo.substring(4, 5);
  5.    if (_root.CPartB == "F") {
  6.        // Aumenta el primer dígito.
  7.        if (_root.CPartA == "F") {
  8.        } else {
  9.            _root.CPartB = "0";
  10.            if (_root.CPartA == "E") {
  11.                _root.CPartA = "F";
  12.            } else if (_root.CPartA == "D") {
  13.                _root.CPartA = "E";
  14.            } else if (_root.CPartA == "C") {
  15.                _root.CPartA = "D";
  16.            } else if (_root.CPartA == "B") {
  17.                _root.CPartA = "C";
  18.            } else if (_root.CPartA == "A") {
  19.                _root.CPartA = "B";
  20.            } else if (_root.CPartA == "9") {
  21.                _root.CPartA = "A";
  22.            } else if (_root.CPartA == "8") {
  23.                _root.CPartA = "9";
  24.            } else if (_root.CPartA == "7") {
  25.                _root.CPartA = "8";
  26.            } else if (_root.CPartA == "6") {
  27.                _root.CPartA = "7";
  28.            } else if (_root.CPartA == "5") {
  29.                _root.CPartA = "6";
  30.            } else if (_root.CPartA == "4") {
  31.                _root.CPartA = "5";
  32.            } else if (_root.CPartA == "3") {
  33.                _root.CPartA = "4";
  34.            } else if (_root.CPartA == "2") {
  35.                _root.CPartA = "3";
  36.            } else if (_root.CPartA == "1") {
  37.                _root.CPartA = "2";
  38.            } else if (_root.CPartA == "0") {
  39.                _root.CPartA = "1";
  40.            }
  41.        }
  42.        // Aumenta el segundo dígito.
  43.    } else if (_root.CPartB == "E") {
  44.        _root.CPartB = "F";
  45.    } else if (_root.CPartB == "D") {
  46.        _root.CPartB = "E";
  47.    } else if (_root.CPartB == "C") {
  48.        _root.CPartB = "D";
  49.    } else if (_root.CPartB == "B") {
  50.        _root.CPartB = "C";
  51.    } else if (_root.CPartB == "A") {
  52.        _root.CPartB = "B";
  53.    } else if (_root.CPartB == "9") {
  54.        _root.CPartB = "A";
  55.    } else if (_root.CPartB == "8") {
  56.        _root.CPartB = "9";
  57.    } else if (_root.CPartB == "7") {
  58.        _root.CPartB = "8";
  59.    } else if (_root.CPartB == "6") {
  60.        _root.CPartB = "7";
  61.    } else if (_root.CPartB == "5") {
  62.        _root.CPartB = "6";
  63.    } else if (_root.CPartB == "4") {
  64.        _root.CPartB = "5";
  65.    } else if (_root.CPartB == "3") {
  66.        _root.CPartB = "4";
  67.    } else if (_root.CPartB == "2") {
  68.        _root.CPartB = "3";
  69.    } else if (_root.CPartB == "1") {
  70.        _root.CPartB = "2";
  71.    } else if (_root.CPartB == "0") {
  72.        _root.CPartB = "1";
  73.    }
  74.    _root.Fondo = _root.Fondo.substring( 0, 4) + _root.CPartA + _root.CPartB;
  75.    ColF = new Color(_root.Fondoimg);
  76.    ColF.setRGB(parseInt(_root.Fondo, 16));
  77. }
260  Foros Generales / Foro Libre / Re: ¿Puede GPT programar más rápido que tú o incluso cosas que no sabes? en: 19 Noviembre 2024, 01:33 am
Hice el tema porque estaba sorprendido de GPT y pensé que ya es como una especie de oráculo o gurú al que se puede preguntar cosas, pero no pregunté aquí en serio sobre Dios, ni voy a hablar de eso. Sólo que en el Budismo, por ejemplo, el "dios" viene a ser Buda, es decir un ser que existió, supuestamente, y que no hizo algo sobrenatural, que yo sepa, más allá de alcanzar el supuesto nirvana, la iluminación o no sé bien qué. Lo que tiene de sobrenatural el budismo es que creen en la reencarnación. También tengo más o menos entendido que hay religiones que adoraban al Sol, o al mar.
Páginas: 1 ... 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 [26] 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 ... 243
WAP2 - Aviso Legal - Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines