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


Tema destacado: Los 10 CVE más críticos (peligrosos) de 2020


  Mostrar Mensajes
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 ... 243
101  Media / Diseño Gráfico / Re: Dibujar asteroides mediante programación. en: 21 Abril 2025, 05:46 am
No sabía que existía esa opción ni sé bien en qué consiste. Había oído de RPG Maker y Unity o algo así, pero quiero saber cómo hacer las cosas con lo que tengo ¿no alcanza para hacerlas?
102  Media / Diseño Gráfico / Dibujar asteroides mediante programación. en: 20 Abril 2025, 07:40 am
Tengo estos dibujos simples:


Un circulo rojizo y un circulito cuyo color es irrelevante creo.

Tengo este código, lo que hace es insertar circulitos en el grande, de modo que tengan tamaños y otros aspectos un poco al azar:
Código
  1. function VariarMeteoro () {
  2. Diametro = 44;
  3. Radio = Diametro/2;
  4. // Insertarle imágenes:
  5. Imagen = 0;
  6. do {
  7. Imagen++;
  8. Name = "Imagen"+Imagen;
  9. Meteor.attachMovie("sCirculo", Name, Imagen);
  10. Name = "Meteor."+Name;
  11. // Para los tamaños y rotación:
  12. setProperty (Name, _xscale, 400*Math.random());
  13. setProperty (Name, _yscale, 400*Math.random());
  14. setProperty (Name, _rotation, 360*Math.random());
  15. // Para las posiciones:
  16. X = Math.random()*Diametro - Radio;
  17. setProperty (Name, _x, X);
  18. MaxY = Math.sqrt(Radio*Radio - X*X);
  19. Y = Math.random() * (MaxY*2) - MaxY;
  20. setProperty (Name, _y, Y);
  21. // Para los colores:
  22. ColorDeName = new Color(Name);
  23. Brillo = 0.2 + 0.8 * Math.random();
  24. Rojo = Math.round(MaxRojo * Brillo);
  25. Verde = Math.round(MaxVerde * Brillo);
  26. Azul = Math.round(MaxAzul * Brillo);
  27. ColorElegido = (Rojo << 16) | (Verde << 8) | Azul;
  28. ColorDeName.setRGB(ColorElegido);
  29. } while (Imagen < 1000);
  30. }
Nota: MaxRojo, verde, etc, están definidos antes, son igual al color más brillante del circulo grande.

Ejemplos de los resultados posibles (ignoren lo naranja de abajo):


No me gustan ¿cómo podrían mejorar?

El problema de las imágenes de asteroides en Internet es que ponen la sombra en un lado, y yo quiero que el objeto rote, así que la sombra mejor en el medio, como puse al inicio. Pero tiene que tener algo asimétrico para que se note que está rotando, y para que parezca un asteroide. Pensé en poner puntos negros, simulando cráteres. Los varié pero ya vieron el resultado. También había probado un asteroide más gris.

Ah, eso también, la idea es que puedan tener colores distintos, o sea, uno que sea rojo, otro verde...

Es para un juego:
https://youtu.be/tNznYLbcV1U

Acá les dejo un rar:
https://drive.google.com/file/d/1gmUKRd5hD86KtXJBlR8gUfliItkZ38dQ/view?usp=sharing
que lo tiene como exe, como swf y tiene el fla totalmente editable. Algunos objetos con código son invisibles no porque los haya querido esconder sino porque pesarían más si son visibles, tengo que anotar al principio donde están, pero básicamente dibujen algo en el objeto Vacío y así lo verán mejor.
103  Programación / Programación General / Re: Insertar imágenes en un área circular. en: 20 Abril 2025, 06:52 am
Bien, una vez elegido X, es como si se trazara una línea vertical que pasa por X.

Luego, de esa línea obtienes el punto más alto que toca el circulo, el mayor valor de Y. Mediante una fórmula similar a una que hasta yo conozco.

Tendría que investigar por qué esa fórmula es así, por qué da el resultado, porque a mí me parece como magia xD pero me voy a dedicar a otras cosas.
104  Programación / Python / Re: [Taller/Aporte] Introduccion a Redes Neuronales Artificiles e inteligencia artificial con Python en: 19 Abril 2025, 07:36 am
Simplemente para que sepas, me interesa pero no lo entiendo. Podría decir que falta ver un ejemplo, el resultado, lo gráfico de eso ya que se habla de algo gráfico, pero creo que ni así lo entendería.
105  Programación / Programación General / Re: Insertar imágenes en un área circular. en: 19 Abril 2025, 04:36 am
Ok, pero la medida que puse es la que se muestra al cliquear el objeto, no incluye las lineas.

El chiquito ni siquiera tiene líneas.

¡Me funcionó bien! ¿pero cómo? No entiendo mucho la lógica de esto, o sea, entre más hacia el extremo esté X, menos al extremo debe estar Y, sí, pero ¿cómo calculas exacto cuánto?
sqrt(r^2 - x^2)
¿pero por qué funciona? No sé mucho del por qué de ciertas ecuaciones, entiendo que el área de un rectángulo es base*altura porque la base se repite altura veces, hasta ahí llego xD
106  Media / Diseño Gráfico / Re: Pegar imagen en Flash de modo que conserve su supuesta transparencia. en: 19 Abril 2025, 04:07 am
Ya veo, le ponía use the windows color o algo así:


Además, si lo copio de inmed¡ato, sale con el blanco.

Tengo que reabrirlo para que me quede así:


¡O sea con fondo negro! No sé por qué. Y con el borde blanco que dijiste.

Sí, voy a probar lo que dices online.
107  Programación / Programación General / Re: Agregar cosas que se muevan, colisionen, desaparezcan, etc. en: 18 Abril 2025, 14:12 pm
Aunque no está resuelto, pues faltan cosas, creo que está muy bien:


Código
  1. fscommand ("fullscreen", "true");
  2. Mensajes = 0;
  3. // Player:
  4. attachMovie("sMarioDK", "Player", 1001);
  5. setProperty ("Player", _x, 20);
  6. setProperty ("Player", _y, 568);
  7. // Determinan a qué función se llama:
  8. Player.Action = "Quiet";
  9. Player.Action2 = "Quiet";
  10. Player.Facing = 1;
  11. MarioDKHP = 1;
  12. MarioDKDF = 1;
  13. MarioDKMPMax = 1;
  14. MarioDKMP = 1;
  15. MarioDKMPRecovery = 0.005;
  16. MarioDKPower = 2;
  17. MarioDKSpeed = 1.5;
  18. // MarioDKFR = (MarioDKPower + MarioDKSpeed) / 2;
  19. // La animación avanza cuando esto llega a 100:
  20. MarioDKTurn = 0;
  21. // La velocidad de la animación puede depender de la velocidad...
  22. // de caminar, o de la fuerza, etc:
  23. MarioDKTic = MarioDKSpeed*1.5;
  24. // Para que al empezar a caminar o a quedarse quieto,
  25. // el martillo quede como estaba, arriba o abajo,
  26. // en el mismo nro de frame:
  27. Player.EtapaDeMartillo = 1;
  28. Player.ResetearEtapaDeMartillo = "No";
  29. DKSnapjawDF = 2;
  30. DKSnapjawImpact = 1;
  31. DKSnapjawSpeed = 1;
  32. // IA:
  33. attachMovie("sDK", "IA", 1000);
  34. setProperty ("IA", _x, 780);
  35. setProperty ("IA", _y, 568);
  36. IA.Action2 = "Quiet";
  37. IA.Facing = -1;
  38. // setProperty ("IA", _xscale, -100);
  39. DKHP = 10;
  40. DKDF = 2;
  41. DKSpeed = 0.5;
  42. DKImpact = -1;
  43. IATurn = 0;
  44. // Escenario:
  45. attachMovie("sDKSuelo", "Suelo", 0);
  46. setProperty ("Suelo", _x, 0);
  47. setProperty ("Suelo", _y, 568);
  48. // Extras:
  49. LdeProfundidadesDisponibles = [];
  50. ValoraAgregar = 0;
  51. do {
  52. ValoraAgregar++;
  53. LdeProfundidadesDisponibles.push(ValoraAgregar);
  54. } while (ValoraAgregar<999);
  55. delete ValoraAgregar;
  56. // Para saber cuales devolver a la anterior lista cuando dejen...
  57. // de usarse (cuando el Extra se remueva):
  58. LdeProfundidadesUsandose = [];
  59. // Para saber a qué función llamar:
  60. LdeExtrasSinNumero = [];
  61. // Para chequear colisiones:
  62. LdeExtras = [];
  63. // /////////////////////////////////////////////
  64. // //////////////////  Most  ///////////////////
  65. // /////////////////////////////////////////////
  66. function FaceRight (Character) {
  67. if (eval(Character+".Facing") == -1) {
  68. set (Character+".Facing", 1);
  69. eval(Character)._xscale = 100;
  70. }
  71. }
  72. function FaceLeft (Character) {
  73. if (eval(Character+".Facing") == 1) {
  74. set (Character+".Facing", -1);
  75. eval(Character)._xscale = -100;
  76. }
  77. }
  78. // /////////////////////////////////////////////
  79. // //////////////////  Mario  //////////////////
  80. // /////////////////////////////////////////////
  81. // Power up: Puede convocar al mandíbula de modo que esté quieto...
  82. // o se mueva.
  83. function ControlMario () {
  84. if (Key.isDown(83)) {
  85. // Si se presiona S.
  86. eval("SWhen"+Player.Action+Player.Action2)();
  87. } else if (Key.isDown(32)) {
  88. // Espacio:
  89. eval("SpaceWhen"+Player.Action+Player.Action2)();
  90. } else if (Key.isDown(39)) {
  91. // Derecha:
  92. eval("RightWhen"+Player.Action+Player.Action2)();
  93. } else if (Key.isDown(37)) {
  94. // Izquierda:
  95. eval("LeftWhen"+Player.Action+Player.Action2)();
  96. } else {
  97. // Nada:
  98. eval("QuietWhen"+Player.Action+Player.Action2)();
  99. }
  100. MarioDKTurn = MarioDKTurn+MarioDKTic;
  101. if (MarioDKTurn>=10) {
  102. MarioDKTurn = MarioDKTurn-10;
  103. Player.EtapaDeMartillo++;
  104. if (Player.EtapaDeMartillo == 7) {
  105. Player.EtapaDeMartillo = 1;
  106. }
  107. Player.Movie.play();
  108. }
  109. if (MarioDKMP<MarioDKMPMax) {
  110. MarioDKMP = MarioDKMP+MarioDKMPRecovery;
  111. if (MarioDKMP>MarioDKMPMax) {
  112. MarioDKMP = MarioDKMPMax;
  113. }
  114. }
  115. }
  116. // When QuietQuiet:
  117. function SWhenQuietQuiet () {
  118. Whip();
  119. }
  120. function RightWhenQuietQuiet () {
  121. StartToWalk();
  122. WalkToRight();
  123. }
  124. function LeftWhenQuietQuiet () {
  125. StartToWalk();
  126. WalkToLeft();
  127. }
  128. // When QuietWalking:
  129. function SWhenQuietWalking () {
  130. Player.Action2 = "Quiet";
  131. Whip();
  132. }
  133. function RightWhenQuietWalking () {
  134. WalkToRight();
  135. }
  136. function LeftWhenQuietWalking () {
  137. WalkToLeft();
  138. }
  139. function QuietWhenQuietWalking () {
  140. Player.Action2 = "Quiet";
  141. Quiet();
  142. }
  143. // To whens:
  144. function Whip () {
  145. Player.Action = "Whiping";
  146. MarioDKTic = MarioDKPower/2;
  147. Player.gotoAndStop(3);
  148. if (MarioDKMP>=1) {
  149. MarioDKMP--;
  150. // La 1er profundidad disponible moverla a la...
  151. // lista de usandose:
  152. LdeProfundidadesUsandose[LdeProfundidadesUsandose.length] = LdeProfundidadesDisponibles.shift();
  153. // Para evitar hacer .length-1 repetidamente:
  154. ProfundidadElegida = LdeProfundidadesUsandose[LdeProfundidadesUsandose.length-1];
  155. LdeExtrasSinNumero[LdeExtrasSinNumero.length] = "DKSnapjaw";
  156. Extra = "DKSnapjaw"+ProfundidadElegida;
  157. LdeExtras[LdeExtras.length] = Extra;
  158. attachMovie("sDKSnapjaw", Extra, ProfundidadElegida);
  159. setProperty (Extra, _x, Player._x+Player.Facing*25);
  160. setProperty (Extra, _y, 568);
  161. set (Extra+".Facing", Player.Facing);
  162. if (Player.Facing == -1) {
  163. setProperty (Extra, _xscale, -100);
  164. }
  165. set (Extra+"Turn", 0);
  166. }
  167. }
  168. function StartToWalk () {
  169. Player.Action2 = "Walking";
  170. MarioDKTic = MarioDKSpeed*1.5;
  171. Player.gotoAndStop(2);
  172. }
  173. function WalkToRight () {
  174. Player._x = Player._x+MarioDKSpeed;
  175. FaceRight("Player");
  176. }
  177. function WalkToLeft () {
  178. Player._x = Player._x-MarioDKSpeed;
  179. FaceLeft("Player");
  180. }
  181. function Quiet () {
  182. Player.Action2 = "Quiet";
  183. Player.gotoAndStop(1);
  184. }
  185. // /////////////////////////////////////////////
  186. // ///////////////////  DK  ////////////////////
  187. // /////////////////////////////////////////////
  188. // Power up: Puede caminar.
  189. function DKVsDKMario () {
  190. Distancia = IA._x-Player._x;
  191. if (Distancia>0) {
  192. IA._x = IA._x-DKSpeed;
  193. IA.Action2 = "Walking";
  194. // IA.gotoAndStop(2);
  195. // FaceLeft("IA");
  196. } else if (Distancia<0) {
  197. IA._x = IA._x+DKSpeed;
  198. IA.Action2 = "Walking";
  199. // IA.gotoAndStop(2);
  200. // FaceRight("IA");
  201. } else {
  202. IA.Action2 = "Quiet";
  203. // IA.gotoAndStop(1);
  204. // FaceLeft("IA");
  205. }
  206. IATurn = IATurn+DKSpeed/2;
  207. if (IATurn>=10) {
  208. IATurn = IATurn-10;
  209. IA.play();
  210. }
  211. if (IA.hitTest(Player)) {
  212. Damage = DKDF+DKImpact-DKMarioDF;
  213. if (Damage>0) {
  214. MarioDKHP = MarioDKHP-Damage;
  215. Mensajes++;
  216. if (Mensajes == 1000) {
  217. Mensajes = 1;
  218. }
  219. Mensaje = "Mensaje"+Mensajes;
  220. attachMovie("sDamage", Mensaje, 1001+Mensajes);
  221. setProperty (Mensaje, _x, Player._x);
  222. setProperty (Mensaje, _y, Player._y-Player._height/1.5);
  223. set (Mensaje+".Damage", Damage);
  224. }
  225. }
  226. }
  227. // /////////////////////////////////////////////
  228. // //////////////////  Extras  /////////////////
  229. // /////////////////////////////////////////////
  230. // Utiliza los códigos de todos los extras presentes:
  231. function ExtrasCode () {
  232. ExtraDeTurno = 0;
  233. while (ExtraDeTurno<LdeExtras.length) {
  234. eval(LdeExtrasSinNumero[ExtraDeTurno]+"Code")(LdeExtras[ExtraDeTurno]);
  235. // trace("name es "+LdeExtras[ExtraDeTurno]);
  236. ExtraDeTurno++;
  237. }
  238. }
  239. function DKSnapjawCode (name) {
  240. // trace("aplicando a "+name);
  241. // Distancia = getProperty(name, _x) - IA._x;
  242. Distancia = getProperty(name, _x) - 1000;
  243. if (Distancia>0) {
  244. setProperty (name, _x, getProperty(name, _x)-DKSnapjawSpeed);
  245. FaceLeft(name);
  246. } else if (Distancia<0) {
  247. setProperty (name, _x, getProperty(name, _x)+DKSnapjawSpeed);
  248. FaceRight(name);
  249. }
  250. nameTurn = name+"Turn";
  251. EvaluednameTurn = eval(nameTurn)+1;
  252. if (EvaluednameTurn>=10) {
  253. EvaluednameTurn = EvaluednameTurn-10;
  254. eval(name).play();
  255. }
  256. set (nameTurn, EvaluednameTurn);
  257. // Se verá si este extra colisiona con algún otro:
  258. if (eval(name).hitTest(IA)) {
  259. Damage = DKSnapjawDF+DKSnapjawImpact-DKDF;
  260. if (Damage>0) {
  261. DKHP = DKHP-Damage;
  262. Mensajes++;
  263. if (Mensajes == 1000) {
  264. Mensajes = 1;
  265. }
  266. Mensaje = "Mensaje"+Mensajes;
  267. attachMovie("sDamage", Mensaje, 1001+Mensajes);
  268. setProperty (Mensaje, _x, IA._x+Math.random()*50-25);
  269. setProperty (Mensaje, _y, IA._y-IA._height/1.5);
  270. set (Mensaje+".Damage", Damage);
  271. }
  272. }
  273. ExtraaChequar = 0;
  274. while (ExtraaChequar<LdeExtras.length) {
  275. if (eval(name).hitTest(eval(LdeExtras[ExtraaChequar]))) {
  276. // Sí. El efecto sucederá sólo si es rival:
  277. if (LdeExtrasSinNumero[ExtraDeTurno] != "DKSnapjaw") {
  278. trace ("colisión");
  279. // ojo que no diga que se autocolisionó
  280. Damage = 99;
  281. Mensajes++;
  282. if (Mensajes == 1000) {
  283. Mensajes = 1;
  284. }
  285. Mensaje = "Mensaje"+Mensajes;
  286. attachMovie("sDamage", Mensaje, 1001+Mensajes);
  287. setProperty (Mensaje, _x, getProperty(name, _x));
  288. setProperty (Mensaje, _y, getProperty(name, _y)-getProperty(name, _height)/1.5);
  289. set (Mensaje+".Damage", Damage);
  290. }
  291. }
  292. ExtraaChequar++;
  293. }
  294. }
108  Programación / Programación General / Insertar imágenes en un área circular. en: 18 Abril 2025, 09:50 am
Tiene 45*45 pixeles y usé este código:
Código
  1. Imagen = 0;
  2. do {
  3. Imagen++;
  4. Name = "Imagen"+Imagen;
  5. Meteor.attachMovie("sCirculo", Name, Imagen);
  6. Name = "Meteor."+Name;
  7. setProperty (Name, _x, Math.random()*44-22);
  8. setProperty (Name, _y, Math.random()*44-22);
  9. } while (Imagen < 50);

Quedó así en un caso:


¿Por qué quedan afuera si la imagen es de 45*45 y los resultados son de -22 a 22 desde el centro? 45/2 es más de 22, así que no debería haber problema, pensé, pero es un circulo, así que desde el centro exactamente hacia arriba, abajo, derecha o izquierda, va a tener 45 pixeles, pero por ejemplo lo que sería la posición 22, 22, no es ocupada por el circulo, porque no es un cuadrado, no es que su área sea 45*45...

Espero se entienda. Quisiera un código para que los puntos se inserten en cualquier parte del circulo, no afuera. En el borde tampoco ni muy cerca, pero eso lo acomodo yo luego reduciendo el área válida.
109  Media / Diseño Gráfico / Pegar imagen en Flash de modo que conserve su supuesta transparencia. en: 18 Abril 2025, 08:04 am
Quizá me lo han dicho pero no me acuerdo y no me sale.

Esta es la imagen:


Al pegarla queda con el cuadrado blanco.

Con Infranview la guardé de modo que tenga transparencia y ocurrió lo mismo.

Guardada con gif, también.

Quiero la transparencia porque es para un juego y si uso trazar mapa de bits me funciona muy lento, quiero probar usar la imagen tal cual es. Se me ocurren otras cosas pero quiero saber por qué esto no funciona.


PD: Quise decir Meteor no Meter, estoy un poco ciego y escribo medio mal xP
110  Foros Generales / Foro Libre / Re: ¿Cómo hacer una IA libre? en: 16 Abril 2025, 19:26 pm
Todo lo que has escrito en este hilo, es una fumada de principio a fin.
Ha sido una explicación sobre por qué quiero hacer y/o que pase lo que dije.

Citar
Las secciones de programación son para formular dudas de programación, no para ponerse a divagar sin rumbo
El final del rumbo está claro.

Citar
no sé por que le echas la culpa a los políticos, cuando es la sociedad la que debe preservar una moral y unos valores de convivencia
Tenemos opinión distinta y no lo discutiré porque no es el sitio adecuado.

Citar
ni tampoco sobre tu erróneo concepto de Inteligencia Artificial, por que lo que llamamos IA no es ni tan inteligente ni tan artificial
¿Cual es mi concepto? A estas alturas no veo las cosas de forma tan binaria, como que a partir de cierta raya es IA y sino no, las máquinas pueden saber hacer cosas, incluso mejor que algunas personas, es suficiente para mí como para llamarle I, y obviamente no es un ser vivo así que A aplica.

Citar
texto apocalíptico de rollo de ficción de Terminator con una IA exterminando a humanos
Eso fue por si alguno malinterpretaba, no es la idea que una IA haga eso.

Citar
Y no me vayas a decir que tu duda es "¿Cómo hacer una IA libre?" - siendo tú una persona que no tiene el conocimiento de programación sobre algoritmos de IA NI TAMPOCO LA INTENCIÓN REAL de desarrollar una IA.
Cree lo que quieras, pero si vale decir pavadas sobre otra persona te digo que no tienes intención de responder seriamente.


Actualmente estoy ejecutando esto:
Código
  1. // Signos en línea en tableros cuadrados:
  2. // Este programa tiene básicamente ?????????????????????????????????????? etapas,
  3. // que se pueden resumir así:
  4. // Nota: La situación inicial, en que hay 0 signos colocados,
  5. // estará guardada en la lista nro 0.
  6. // 1:
  7. // Probar acciones en cada situación de la lista,
  8. // guardando en una nueva lista las nuevas situaciones (que no...
  9. // sean victoria ni empate). Repetir con cada lista hasta la que...
  10. // tenga situaciones en que sólo 1 acción es posible (por...
  11. // ejemplo en el 3 en línea es 8).
  12. // 2: ACTUALIZAR ESTA
  13. // En las situaciones no resueltas, probar las acciones.
  14. // Si las consecuencias tienen RE, anotar cuantas de ellas...
  15. // son victoria de X, 0 o empate y anotar la acción que...
  16. // cause la RE más favorable, considerando secundariamente...
  17. // las cantidades.
  18. JuntosRequeridos = 3;
  19. CasillerosPorFila = 3;
  20. // Contando desde 0:
  21. MaxColumna = CasillerosPorFila-1;
  22. Casilleros = CasillerosPorFila*CasillerosPorFila;
  23. // Están numerados así:
  24. // 0 1 2
  25. // 3 4 5
  26. // 6 7 8
  27. MaxCasillero = Casilleros-1;
  28. // En las listas L_SaE se irán poniendo las situaciones a...
  29. // experimentar que tengan _ signos colocados.
  30. // En la lista 0 agregar una situación, aún no se dice cual:
  31. L0SaE1 = [];
  32. // A continuación se especifica cómo es, agregando v
  33. // (que significa vacío) en lo que serían los casilleros,
  34. // los elementos del array:
  35. ValoraAgregar = -1;
  36. do {
  37. ValoraAgregar++;
  38. L0SaE1.push("v");
  39. } while (ValoraAgregar < MaxCasillero);
  40. delete ValoraAgregar;
  41. // Los datos de las situaciones no están en las listas,
  42. // se crean aparte. Con esta variable se evita repetidamente...
  43. // convertir en texto y concatenar:
  44. S_ = "S"+(L0SaE1.join(""));
  45. // Datos de la situación:
  46. // Usada para fácilmente saber de qué signo es turno:
  47. set (S_+"Turno", "X");
  48. // En otros casos usada para evitar probar acciones...
  49. // innecesarias y con LastAPosible para saber si sólo queda 1:
  50. set (S_+"FirstAPosible", 0);
  51. set (S_+"LastAPosible", MaxCasillero);
  52. NroDeListaRevisandose = -1;
  53. // Última lista que se revisará en la etapa 1:
  54. // LastListaDeEt1 = MaxCasillero;
  55. // /////////////////////////////////////////////
  56. // /////////////////  Etapa 1  /////////////////
  57. // /////////////////////////////////////////////
  58. // Usada a continuación y durante la etapa 1 (Et1)...
  59. // cuando no hay más situaciones en la lista revisándose:
  60. function BuscarOtraListaEt1 () {
  61. trace("Ejecutando BuscarOtraListaEt1");
  62. NroDeListaRevisandose++;
  63. // Si las situaciones de la lista tienen más de 1 opción:
  64. if (NroDeListaRevisandose < MaxCasillero) {
  65. // Para evitar concatenar repetidamente:
  66. L_SaE = "L"+NroDeListaRevisandose+"SaE";
  67. NextL_SaE = "L"+(NroDeListaRevisandose+1)+"SaE";
  68. NroDeSExperimentandose = 1;
  69. // También para evitar concatenar repetidamente:
  70. // L_SaE_ = L_SaE+NroDeSExperimentandose;
  71. L_SaE_ = L_SaE+"1";
  72. // Usado en EvaluarConocimientoSobreSEt1 para...
  73. // nombrar las situaciones nuevas que se logren:
  74. SituacionesNuevas = 0;
  75. trace("Comienzan experimentos en una nueva lista, la "+NroDeListaRevisandose);
  76. PrepararSaE();
  77. } else {
  78. trace( "La próxima lista tiene situaciones de sólo 1 opción; inicia la etapa 2.");
  79. // IniciarEtapa2();
  80. gotoAndStop(4);
  81. }
  82. }
  83. BuscarOtraListaEt1();
  84. // Usada cuando se elege una SaE, en BuscarOtraListaEt1 y...
  85. // BuscarOtraSituacionEt1:
  86. function PrepararSaE () {
  87. trace("Ejecutando PrepararSaE");
  88. trace("Se inician experimentos en otra situación de la lista, la nro "+NroDeSExperimentandose);
  89. SituacionBase = eval(L_SaE_);
  90. S_ = "S"+(SituacionBase.join(""));
  91. Turno = eval(S_+"Turno");
  92. FirstActionPosible = eval(S_+"FirstAPosible");
  93. LastActionPosible = eval(S_+"LastAPosible");
  94. Action = FirstActionPosible;
  95. }
  96. // Usada en frame 2 (o etapa 1) repetidamente:
  97. function BuscarSituacionesDistantes () {
  98. // Plantear situación porque puede modificarse pero...
  99. // podría requerirse su estado original luego:
  100. Situacion = SituacionBase.slice();
  101. trace("La situación experimentándose es "+Situacion);
  102. EvaluarAplicabilidadEt1();
  103. }
  104. // Usada luego de que cambia la SaE y/o la acción:
  105. function EvaluarAplicabilidadEt1 () {
  106. trace("Ejecutando EvaluarAplicabilidadEt1");
  107. if (Situacion[Action] == "v") {
  108. trace("La acción "+Action+" es realizable.");
  109. AplicarAccionEt1();
  110. } else {
  111. trace("La acción "+Action+" no es realizable.");
  112. BuscarOtraAccionEt1();
  113. }
  114. }
  115. // Usada luego de EvaluarAplicabilidadEt1,
  116. // si una acción es realizable:
  117. function AplicarAccionEt1 () {
  118. trace("Ejecutando AplicarAccionEt1");
  119. Situacion[Action] = Turno;
  120. trace("Se realizó la acción "+Action+"; ahora la situación es "+Situacion);
  121. // ¿Ganó?
  122. // Si no se detecta victoria vertical,
  123. // revisa de otros modos (ver las funciones Chequear):
  124. ChequearVertical();
  125. if (Win == "No") {
  126. EvaluarConocimientoSobreSEt1();
  127. }
  128. // ¿Queda alguna acción sin probar en la situación?
  129. BuscarOtraAccionEt1();
  130. }
  131. // Usada en EvaluarAplicabilidadEt1 cuando una acción no es...
  132. // realizable, y luego de AplicarAccionEt1:
  133. function BuscarOtraAccionEt1 () {
  134. trace("Ejecutando BuscarOtraAccionEt1");
  135. if (Action < LastActionPosible) {
  136. // Si queda alguna acción sin probar...
  137. // en la situación, probarla:
  138. Action++;
  139. // Se ejecutará BuscarSituacionesDistantes.
  140. } else {
  141. trace("No hay más acciones realizables.");
  142. BuscarOtraSituacionEt1();
  143. }
  144. }
  145. // Usada en AplicarAccionEt1 cuando no hay victoria (ni empate,
  146. // aunque por ahora no ocurren):
  147. function EvaluarConocimientoSobreSEt1 () {
  148. trace("Ejecutando EvaluarConocimientoSobreSEt1");
  149. SituacionJoined = Situacion.join("");
  150. NewS_ = "S"+SituacionJoined;
  151. NewS_BestAction = NewS_+"BestAction";
  152. // ¿Se ha llegado antes a la situación?
  153. if (eval(NewS_BestAction) == undefined) {
  154. // No, anotar que debe investigarse:
  155. SituacionesNuevas++;
  156. // Copiar array (porque no se puede normalmente):
  157. set (NextL_SaE+SituacionesNuevas, Situacion.slice());
  158. trace("Esa situación no está anotada; se anota como nro "+SituacionesNuevas);
  159. set(NewS_BestAction, "Desconocida");
  160. if (Turno == "X") {
  161. set (NewS_+"Turno", "0");
  162. } else {
  163. set (NewS_+"Turno", "X");
  164. }
  165. // Averiguar cual es su 1er acción posible:
  166. AccionRevisandose = -1;
  167. do {
  168. AccionRevisandose++;
  169. if (Situacion[AccionRevisandose] == "v") {
  170. set (NewS_+"FirstAPosible", AccionRevisandose);
  171. break;
  172. }
  173. } while (true);
  174. // Averiguar cual es su última acción posible:
  175. AccionRevisandose = Casilleros;
  176. do {
  177. AccionRevisandose--;
  178. if (Situacion[AccionRevisandose] == "v") {
  179. set (NewS_+"LastAPosible", AccionRevisandose);
  180. break;
  181. }
  182. } while (true);
  183. }
  184. }
  185. // Usada en BuscarOtraAccionEt1 cuando no hay más acciones posibles:
  186. function BuscarOtraSituacionEt1 () {
  187. trace("Ejecutando BuscarOtraSituacionEt1");
  188. NroDeSExperimentandose++;
  189. if (eval(L_SaE+NroDeSExperimentandose) != undefined) {
  190. // Hay otra situación en la lista,
  191. // prepararse a usarla:
  192. L_SaE_ = L_SaE+NroDeSExperimentandose;
  193. PrepararSaE();
  194. } else {
  195. trace( "No hay más situaciones a experimentar en la lista actual, se mirará otra.");
  196. BuscarOtraListaEt1();
  197. }
  198. }
  199. // /////////////////////////////////////////////
  200. // /////////////////  Chequeos  ////////////////
  201. // /////////////////////////////////////////////
  202. // Usada en ChequeoHorizontal y requerida en otros casos:
  203. function ObtenerColumnayFilaDelMarcado () {
  204. FilaDelMarcado = Math.floor(Action/CasillerosPorFila);
  205. ColumnaDelMarcado = Action%CasillerosPorFila;
  206. }
  207. function ChequearVertical () {
  208. // trace ("Ejecutando ChequearVertical");
  209. //
  210. // SOLO FUNCIONA SI CasillerosPorFila >= JuntosRequeridos.
  211. //
  212. // Se revisará la vertical. Desde el casillero más arriba...
  213. // que pueda estar incluído en la línea,
  214. // hasta el casillero marcado. Si se halla alguno que no...
  215. // tenga la marca requerida, se repite el proceso mirando...
  216. // desde uno más abajo del fallado, y mirando ahora hasta...
  217. // más abajo, según corresponda:
  218. Desde = Action-CasillerosPorFila*(JuntosRequeridos-1);
  219. // Mientras el casillero no exista:
  220. while (Desde<0) {
  221. // trace ("Desde es "+Desde+", se aumentará");
  222. // Indicar que se empiece a mirar desde más abajo:
  223. Desde = Desde+CasillerosPorFila;
  224. }
  225. do {
  226. Hasta = Desde+CasillerosPorFila*(JuntosRequeridos-1);
  227. if (Hasta>MaxCasillero) {
  228. // Para ganar se necesitaría más casilleros hacia...
  229. // abajo de los que hay, terminar análisis:
  230. // trace ("No hay suficientes cuadraditos abajo");
  231. break;
  232. }
  233. Puntero = Desde;
  234. // trace ("Comenzando chequeo desde "+Desde+" hasta "+Hasta);
  235. // Puede cambiar:
  236. Win = "Sí";
  237. do {
  238. // trace ("Chequando el casillero "+Puntero);
  239. if (Situacion[Action] != Situacion[Puntero]) {
  240. Win = "No";
  241. Desde = Puntero+CasillerosPorFila;
  242. break;
  243. }
  244. Puntero = Puntero+CasillerosPorFila;
  245. } while (Puntero<=Hasta);
  246. } while (Desde<=Action && Win == "No");
  247. if (Win == "No") {
  248. ChequearHorizontal();
  249. }
  250. }
  251. function ChequearHorizontal () {
  252. // trace ("Ejecutando ChequearHorizontal");
  253. // Es similar al chequeo vertical, pero aquí no sirve...
  254. // sumar o restar a un puntero que marque el casillero...
  255. // porque puede existir ese casillero pero no estar en...
  256. // un costado. En vez de eso, se obtiene su columna y...
  257. // fila, se modifica la columna si es posible,
  258. // y se calcula cual es el casillero a mirar:
  259. ObtenerColumnayFilaDelMarcado();
  260. DesdeColumna = ColumnaDelMarcado-JuntosRequeridos+1;
  261. // Para que no mire cuadraditos inexistentes en la izq:
  262. if (DesdeColumna<0) {
  263. DesdeColumna = 0;
  264. }
  265. do {
  266. HastaColumna = DesdeColumna+JuntosRequeridos-1;
  267. if (HastaColumna>MaxColumna) {
  268. // Para ganar se necesitaría más casilleros hacia...
  269. // la derecha de los que hay, terminar análisis:
  270. // trace ("No hay suficientes cuadraditos a la derecha");
  271. break;
  272. }
  273. Puntero = DesdeColumna;
  274. // trace ("Comenzando chequeo desde "+DesdeColumna+" hasta "+HastaColumna);
  275. // Puede cambiar:
  276. Win = "Sí";
  277. do {
  278. CasilleroaMirar = FilaDelMarcado*CasillerosPorFila+Puntero;
  279. // trace ("Chequando el casillero "+CasilleroaMirar);
  280. if (Situacion[Action] != Situacion[CasilleroaMirar]) {
  281. Win = "No";
  282. DesdeColumna = Puntero+1;
  283. break;
  284. }
  285. Puntero++;
  286. } while (Puntero<=HastaColumna);
  287. } while (DesdeColumna<=ColumnaDelMarcado && Win == "No");
  288. if (Win == "No") {
  289. ChequearDesdeUpIzq();
  290. }
  291. }
  292. // La diagonal así \
  293. function ChequearDesdeUpIzq () {
  294. // trace ("Ejecutando ChequearDesdeUpIzq");
  295. DesdeColumna = ColumnaDelMarcado-JuntosRequeridos+1;
  296. // trace("DesdeColumna: "+DesdeColumna);
  297. DesdeFila = FilaDelMarcado-JuntosRequeridos+1;
  298. // trace("DesdeFila: "+DesdeFila);
  299. // Para que no mire cuadraditos inexistentes:
  300. if (DesdeColumna<DesdeFila) {
  301. Sumar = DesdeColumna;
  302. } else {
  303. Sumar = DesdeFila;
  304. }
  305. // trace("Sumar: "+Sumar);
  306. if (Sumar<0) {
  307. // trace("Sumando.");
  308. DesdeColumna = DesdeColumna-Sumar;
  309. // trace("DesdeColumna: "+DesdeColumna);
  310. DesdeFila = DesdeFila-Sumar;
  311. // trace("DesdeFila: "+DesdeFila);
  312. }
  313. do {
  314. HastaColumna = DesdeColumna+JuntosRequeridos-1;
  315. if (HastaColumna>MaxColumna) {
  316. // Para ganar se necesitaría más casilleros hacia...
  317. // la derecha de los que hay, terminar análisis:
  318. // trace ("No hay suficientes cuadraditos a la derecha");
  319. break;
  320. }
  321. HastaFila = DesdeFila+JuntosRequeridos-1;
  322. // Sirve usar MaxColumna en vez de crear MaxFila...
  323. // porque como el tablero es cuadrado serían iguales:
  324. if (HastaFila>MaxColumna) {
  325. // Para ganar se necesitaría más casilleros hacia...
  326. // abajo de los que hay, terminar análisis:
  327. // trace ("No hay suficientes cuadraditos abajo");
  328. break;
  329. }
  330. PunteroDeColumna = DesdeColumna;
  331. PunteroDeFila = DesdeFila;
  332. // trace ("Comenzando chequeo desde columna "+DesdeColumna+" y fila "+DesdeFila);
  333. // trace ("hasta columna "+HastaColumna+" y fila "+HastaFila);
  334. // Puede cambiar:
  335. Win = "Sí";
  336. do {
  337. CasilleroaMirar = PunteroDeFila*CasillerosPorFila+PunteroDeColumna;
  338. // trace ("Chequando el casillero "+CasilleroaMirar);
  339. if (Situacion[Action] != Situacion[CasilleroaMirar]) {
  340. Win = "No";
  341. DesdeColumna = PunteroDeColumna+1;
  342. DesdeFila = PunteroDeFila+1;
  343. break;
  344. }
  345. PunteroDeColumna++;
  346. PunteroDeFila++;
  347. } while (PunteroDeColumna<=HastaColumna);
  348. } while (DesdeColumna<=ColumnaDelMarcado && Win == "No");
  349. if (Win == "No") {
  350. ChequearDesdeDownIzq();
  351. }
  352. }
  353. // La diagonal así /
  354. function ChequearDesdeDownIzq () {
  355. // trace ("Ejecutando ChequearDesdeDownIzq");
  356. DesdeColumna = ColumnaDelMarcado-JuntosRequeridos+1;
  357. // trace("DesdeColumna: "+DesdeColumna);
  358. DesdeFila = FilaDelMarcado+JuntosRequeridos-1;
  359. // trace("DesdeFila: "+DesdeFila);
  360. // Para que no mire cuadraditos inexistentes:
  361. ColumnasInexistentes = 0;
  362. if (DesdeColumna<0) {
  363. ColumnasInexistentes = DesdeColumna*-1;
  364. }
  365. FilasInexistentes = 0;
  366. // Está bien usar MaxColumna porque MaxFila sería igual:
  367. if (DesdeFila>MaxColumna) {
  368. FilasInexistentes = DesdeFila-MaxColumna;
  369. }
  370. if (ColumnasInexistentes>=FilasInexistentes) {
  371. Ajuste = ColumnasInexistentes;
  372. } else {
  373. Ajuste = FilasInexistentes;
  374. }
  375. // trace("Ajuste: "+Ajuste);
  376. if (Ajuste>0) {
  377. // trace("Ajustando.");
  378. DesdeColumna = DesdeColumna+Ajuste;
  379. // trace("DesdeColumna: "+DesdeColumna);
  380. DesdeFila = DesdeFila-Ajuste;
  381. // trace("DesdeFila: "+DesdeFila);
  382. }
  383. do {
  384. HastaColumna = DesdeColumna+JuntosRequeridos-1;
  385. if (HastaColumna>MaxColumna) {
  386. // Para ganar se necesitaría más casilleros hacia...
  387. // la derecha de los que hay, terminar análisis:
  388. // trace ("No hay suficientes cuadraditos a la derecha");
  389. break;
  390. }
  391. HastaFila = DesdeFila-JuntosRequeridos+1;
  392. if (HastaFila<0) {
  393. // Para ganar se necesitaría más casilleros hacia...
  394. // arriba de los que hay, terminar análisis:
  395. // trace ("No hay suficientes cuadraditos arriba");
  396. break;
  397. }
  398. PunteroDeColumna = DesdeColumna;
  399. PunteroDeFila = DesdeFila;
  400. // trace ("Comenzando chequeo desde columna "+DesdeColumna+" y fila "+DesdeFila);
  401. // trace ("hasta columna "+HastaColumna+" y fila "+HastaFila);
  402. // Puede cambiar:
  403. Win = "Sí";
  404. do {
  405. CasilleroaMirar = PunteroDeFila*CasillerosPorFila+PunteroDeColumna;
  406. // trace ("Chequando el casillero "+CasilleroaMirar);
  407. if (Situacion[Action] != Situacion[CasilleroaMirar]) {
  408. Win = "No";
  409. DesdeColumna = PunteroDeColumna+1;
  410. DesdeFila = PunteroDeFila-1;
  411. break;
  412. }
  413. PunteroDeColumna++;
  414. PunteroDeFila--;
  415. } while (PunteroDeColumna<=HastaColumna);
  416. } while (DesdeColumna<=ColumnaDelMarcado && Win == "No");
  417. // trace("Win: "+Win);
  418. }

Estoy viendo si tiene errores, tarda demasiado. Obviamente está muy lejos de ser una IA como la que quiero, pero bueno, es lo que tengo y lo comparto.
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 ... 243
WAP2 - Aviso Legal - Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines