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

 

 


Tema destacado: Usando Git para manipular el directorio de trabajo, el índice y commits (segunda parte)


+  Foro de elhacker.net
|-+  Programación
| |-+  Programación General
| | |-+  Java
| | | |-+  Necesito una mano con con A*Pathfinding (mover jugador con AI)
0 Usuarios y 1 Visitante están viendo este tema.
Páginas: [1] Ir Abajo Respuesta Imprimir
Autor Tema: Necesito una mano con con A*Pathfinding (mover jugador con AI)  (Leído 1,616 veces)
rastanthology

Desconectado Desconectado

Mensajes: 130


Ver Perfil
Necesito una mano con con A*Pathfinding (mover jugador con AI)
« en: 31 Octubre 2010, 18:43 pm »

Estaba tratando de hacer un juego para android. Lo que quiero hacer es que cuando uno hace click en la pantalla el jugador vaya hasta ese punto esquivando todos los obstaculos que hay en el medio. Para eso trate de seguir la logica de A*Pathfinding, con los calculos "manhatan". Pero la verdad es que despues de dos dias de tratar de que ande bien cada vez estoy mas mareado.

Algo de info para entender lo que hice hasta ahora:

 El mapa esta dividido en 50*50 tiles de 32 pixeles c/u. Cuando se carga el mapa se cargan todos los objetos colisionables en mapindexT[ x] [y] = true. Cuando hago click en cualquier tile le paso al void findpath() la coordenada del tile. Despues este void chequea las colisiones de alrededor de las coordenadas que le paso y despues,  al estilo "Manhatan", el costo de caminar horizontal y verticalmente de ir hasta el lugar donde esta el jugador. Despues determina los valores de los tiles de acuerdo al costo de caminar hasta ahi.

Una vez pasado esto deberia buscar cual es el tile optimo y guardar sus coordenadas en un arraylist. Las estoy grabando en 2. Una para pasarle 1 tile x tile las coordenadas de a donde ir una vez calculado como llegar. Y la otra para limpiar otro array booleano que contiene cuales tiles fueron ya calculados una vez que el jugador se termino de mover.

Una vez calculado como deberia llegar vuelve al loop principal en donde agarro las coordenadas que guarde anteriormente "optimas" de como llegar del arraylist y las voy borrando 1 x 1 a medida que el jugador completa un movimiento de tile entero. Una vez que termina el movimiento total calculado le pido que limpie mi array booleano que contiene los tiles que fueron usados.

Actualmente tengo varios errores que no me dejan esclarecer bien cual es el problema. Habre estado 4~6 horas programando esto y 8~10 debuggeando y corrigiendo. Hay variables que estan al pedo, fui creando variables y borrando a medida que debuggeaba para ver si solucionaba el problema, hay mas de una colgada, pero eso no es lo importante, cuando este andando bien voy a borrar las cosas innecesarias.

Estos eran los problemas que tenia al principio, algunos los resolvi, leer el final del post para ver los problemas del codigo actual:
Citar
Los problemas a simple vista que tengo son:
  • El jugador no siempre calcula su tile optima, hay veces que si, hay veces que no
  • Una vez finalizado el movimiento no siempre limpia mi array, cosa que no le encontre sentido alguno
  • Hay veces que el jugador se queda loopeando el movimiento entre 2 tiles, llendo y viniendo
  • Si le pido de que esquive un colisionable a veces entra en un loop infinito :/
  • Seguramente abra mas, pero necesito que alguien que tal vez no este tan cerca del codigo pueda ver que estoy haciendo mal


Bueno les dejo partes del codigo por que el juego total es bastante largo

De aca se inicia el movimiento
Código
  1. @Override
  2. public boolean onSceneTouchEvent(Scene pScene,
  3. TouchEvent pSceneTouchEvent) {
  4.  
  5. if (pSceneTouchEvent.getAction() == MotionEvent.ACTION_DOWN) {
  6.  
  7.     otoy = toy;
  8.     otox = tox;
  9.  
  10.  
  11. toy =(int) pSceneTouchEvent.getY() / 32;
  12. tox = (int) pSceneTouchEvent.getX() / 32;
  13.  
  14. chartouched = false;
  15. onqueuex.clear();
  16. onqueuey.clear();
  17. queue = 0;
  18. Log.d("MO", "tox " + tox + " toy " + toy);
  19. //Game.this.touchmove();
  20. lpath = true;
  21. realfinish = false;
  22. findpath("player", tox, toy);
  23.  
  24.  
  25. return true;
  26.  
  27. };
  28. return false;
  29. }
  30.  
  31.  
  32. });

Esta es la funcion que deberia calcular a donde ir:
Código
  1. private void findpath(String who, int ax, int ay) {
  2. int valuesx[][] = new int[3][3];
  3. int valuesy[][] = new int[3][3];
  4. int xx,yy;
  5. int[][] f = new int[3][3];
  6. int[][] h = new int[3][3];
  7. int[][] g = new int[3][3];
  8. int tmpx, tmpy, tmpv;
  9. tmpx = tmpy = tmpv = xx = yy = 0;
  10. boolean[][] ontclosedlist = new boolean[3][3];
  11. firstmove = true;
  12. fx = ax;
  13. fy = ay;
  14. onqueuex.add(fx);
  15. onqueuey.add(fy);
  16. boolean notthere = true;
  17. boolean walkable = true;
  18. if (mapindexT[fx][fy]) { walkable = false; }
  19.  
  20. if (walkable) {
  21. while (lpath) {
  22. // referenciar los 8 puntos que rodean a donde vamos
  23. valuesx[0][0]= fx - 1;
  24. valuesy[0][0]= fy - 1;
  25.  
  26. valuesx[0][1]= fx;
  27. valuesy[0][1]= fy - 1;
  28.  
  29. valuesx[0][2]= fx +1;
  30. valuesy[0][2]= fy - 1;
  31.  
  32. valuesx[1][0]= fx - 1;
  33. valuesy[1][0]= fy;
  34.  
  35. valuesx[1][1]= fx;
  36. valuesy[1][1]= fy;
  37.  
  38. valuesx[1][2]= fx + 1;
  39. valuesy[1][2]= fy;
  40.  
  41. valuesx[2][0]= fx - 1;
  42. valuesy[2][0]= fy + 1;
  43.  
  44. valuesx[2][1]= fx;
  45. valuesy[2][1]= fy + 1;
  46.  
  47. valuesx[2][2]= fx + 1;
  48. valuesy[2][2]= fy + 1;
  49. //--------------------------------------------------
  50. //checkear collidables y conseguir la siguiente tile optima
  51. for (int m=0; m <= 2; m++) {
  52. for (int q=0;q<=2; q++) {
  53.  
  54.  
  55. int tvx = valuesx[m][q];
  56. int tvy = valuesy[m][q];
  57. Log.d("MO", "tvx " + tvx + " tvy " + tvy);
  58. if ( tvx >= 0  && tvy >=0) {
  59. if (mapindexT[tvx][tvy]) {
  60. ontclosedlist[m][q] = true;
  61. Log.d("MO", "Collidables X: " + valuesx[m][q] + " Y: " + valuesy[m][q]);
  62.  
  63. numberofopenlist++;
  64. }
  65. // no entrar en tiles usados
  66. ontclosedlist[1][1] = true;
  67. if (onclosedlist[valuesx[m][q]][valuesy[m][q]]) { ontclosedlist[m][q] = true;}
  68. // else { ontclosedlist[m][q] = true; }
  69. //setear distancia entre el target y el player
  70. // diferenciar x e y de acuerdo al values >>
  71. if (!ontclosedlist[m][q]) {
  72. if ( mx > valuesx[m][q] && my >= valuesy[m][q]) {
  73. g[m][q]= (mx - valuesx[m][q] + my - valuesy[m][q]) * 10;
  74. // Log.d("MO", "Arriba e izquierda" + " mx " + mx + " fx " + valuesx[m][q] + " my " + my + " fy " + valuesy[m][q]);
  75. } else if ( mx <= valuesx[m][q] && my > valuesy[m][q]) {
  76. g[m][q] = (valuesx[m][q] - mx + my - valuesy[m][q]) * 10;  
  77. //Log.d("MO", "Arriba y derecha mx " + mx + " fx " + valuesx[m][q] + " my " + my + " fy " + valuesy[m][q]);
  78. }  else if ( mx >= valuesx[m][q] && my < valuesy[m][q]) {
  79. g[m][q] = ( mx - valuesx[m][q] + valuesy[m][q] - my) * 10;
  80. //Log.d("MO", "Abajo e izquierda" + " mx " + mx + " fx " + valuesx[m][q] + " my " + my + " fy " + valuesy[m][q]);
  81. } else if (mx == valuesx[m][q] && my == valuesy[m][q]) {
  82. g[m][q] = 0;
  83.  
  84. } else if (mx < valuesx[m][q] && my <= valuesy[m][q]) {
  85. //Log.d("MO", "Abajo y derecha" + " mx " + mx + " fx " + valuesx[m][q] + " my " + my + " fy " + valuesy[m][q]);
  86. g[m][q] = ( valuesx[m][q] - mx + valuesy[m][q] - my)*10;
  87. } else { Log.d("MO", "ERROR DE CALCULO DE COSTOS DE MOVIMIENTO MX: " + mx + " MY: " + my + " valuesx: " + valuesx[m][q] + " valuesy " + valuesy[m][q]); }
  88. //Log.d("mo", "g[m][q] " + g[q][m]  );
  89.  
  90. } else { // Log.d("MO", "Collisionable");
  91.  
  92. }
  93. // setear costo diagonal
  94. if ( m == 0 && q == 0 || m == 0 && q == 2 || m == 2 && q == 0 || m == 2 && q == 2) {
  95. h[m][q] = 20;
  96. } else {
  97. // setear costo xy
  98. h[m][q] = 10;
  99. }
  100. // setear costo total;
  101. f[m][q] = g[m][q] + h[m][q];
  102.  
  103.  
  104. }
  105. }
  106. }
  107.  
  108. for (int x = 0; x <= 2; x++) {
  109. for (int y = 0; y <= 2; y++) {
  110. // buscar f optima;
  111. //if (x == 1 && y == 1) { continue; }
  112. if (ontclosedlist[x][y]) {
  113. //continue;
  114. //Log.d("MO", "collisionable \\/");
  115.  
  116. } else {
  117.  
  118. //Log.d("MO", "Buscando f opt X: " + x + " Y: " + y + " realx: " + valuesx[y][x] + " realy: " + valuesy[y][x] + " costo:  " + f[x][y]  );
  119. if (x == 0 && y ==0) { tmpx =valuesx[0][0]; tmpy = valuesy[0][0]; tmpv = f[x][y]; xx = yy = 0; }
  120. if (f[x][y] < tmpv) { tmpx = valuesx[x][y]; tmpy = valuesy[x][y]; tmpv = f[x][y]; xx = x; yy = y; exitloop = 0; Log.d("mo", "F optima calculada" + " x " + tmpx +" y " + tmpy + " cost " + tmpv);}
  121.  
  122. }
  123. ontclosedlist[x][y] = false;
  124.  
  125. }
  126. }
  127. onqueuelistx.add(tmpx);
  128. onqueuelisty.add(tmpy);
  129. onqueuex.add(tmpx);
  130. onqueuey.add(tmpy);
  131. onclosedlist[tmpx][tmpy] = true;
  132. Log.d( " MO ", "onqueuex: " + onqueuex.get(queue) + " onqueuey: " + onqueuey.get(queue));
  133. queue++;
  134. fx = tmpx;
  135. fy = tmpy;
  136. // llenar lista
  137. // for ( int g1=0; g1<=2; g1++) {
  138. // for (int h1=0; h1<= 2; h1++) {
  139. // if (ontclosedlist[g1][h1]) { onclosedlist[valuesx[h1][g1]][valuesy[h1][g1]] = true; }
  140. // }
  141. // }
  142.  
  143. //-------------------
  144. // referenciar para donde moverse
  145. if (queue > 30) {
  146. Log.d("MO", "Saliendo del loop! error");
  147. onqueuex.clear();
  148. onqueuey.clear();
  149. queue = 0;
  150. break;}
  151.  
  152. Log.d("MO", "Fx: " + fx +" Fy " + fy + " cost " + f[xx][yy] + " onqueue " + queue );
  153. // salir del loop
  154. if (fx == mx && fy == my) {notthere = false; realfinish = false; lpath = false; fpath = true; oqueue = queue;
  155. tmoving = true;
  156. onqueuex.remove(onqueuex.size() - 1); onqueuey.remove(onqueuey.size() - 1);
  157. Log.d("MO", "Path calculado, tamaño: " + queue); break;}
  158.  
  159. }// else { notthere = true; }
  160.  
  161. }
  162.  
  163. }
  164.     //}
  165.    //}
  166.  
  167. }
  168.  
  169.  

Una vez calculada entra aca que es donde el jugador se esta moviendo:
Código
  1.  
  2.                             if (!mloop) {
  3.                             if (fpath) {
  4.  
  5.                             //lpath = true;
  6.                             int tmx, tmy, rtmx, rtmy;
  7.                             if (!onqueuex.isEmpty()) {
  8.  
  9.  
  10.  
  11.                             tmx  = onqueuex.get(onqueuex.size() - 1);
  12.                             tmy = onqueuey.get(onqueuey.size() - 1);
  13.                             rtmx = mx - tmx;
  14.                             rtmy = my - tmy;
  15.                             if (rtmx == 1 && rtmy == 1) {
  16.                             //diagonal superior izquierda
  17.                             tindex = 4;
  18.  
  19.                             } else if (rtmx == 1 && rtmy == -1) {
  20.                             // diagonal inferior izquierda
  21.                             tindex = 5;
  22.                             } else if (rtmx == -1 && rtmy == 1) {
  23.                             // diagonal superior derecha
  24.                             tindex = 6;
  25.                             } else if ( rtmx == -1 && rtmy == -1) {
  26.                             //diagonal inferior derecha
  27.                             tindex = 7;
  28.                             } else if (rtmx == 1) { tindex = 1; }
  29.                             else if (rtmx == -1) { tindex = 0; }
  30.                             else if (rtmy == 1) { tindex = 2; }
  31.                             else if (rtmy == -1) { tindex = 3; }
  32.                             Log.d("MO", "tmx: " + tmx + " tmy " + tmy + " rtmx " + rtmx + " rtmy " + rtmy + " tindex " + tindex);
  33.                         onqueuex.remove(onqueuex.size() - 1);
  34.                           onqueuey.remove(onqueuey.size() - 1);
  35.  
  36.                             } else {
  37.                             fpath = false; realfinish = true;
  38.  
  39.                             for (int g2 = 0; g2 < oqueue ; g2++) {
  40.                             onclosedlist[onqueuelistx.get(g2)][onqueuelisty.get(g2)] = false;
  41.                             Log.d("MO", "Limpiando camino");
  42.                             }
  43.                             onqueuelistx.clear();
  44.                             onqueuelisty.clear();
  45.                             onqueuex.clear();
  46.                             onqueuey.clear();
  47.                             oqueue = 0;
  48.                             }
  49.                             }
  50.                             if (!realfinish) {
  51.                             ox = jx = (int) player.getX();
  52.                             oy = jy = (int) player.getY();
  53.                             String p = "player";
  54.  
  55.                             Log.d("MO", "X: " + mx + " Y: " + my);
  56.  
  57.                             switch(tindex) {
  58.                                                    case 0:
  59.                                                        //derecha
  60.                                                     // mapindex(mx, my, true);
  61.                                                     //    if (collidables(mx, my,p,1)){                                                        
  62.                                                        jx = ox + 8;
  63.                                                        ox = jx;
  64.                                                        mloop = true;
  65.                                                        mx++;
  66.                                                            player.setPosition(jx, oy);
  67.  
  68.                                                            player.animate(new long[]{200, 200, 200}, 3, 5, tmoving);
  69.                                                      //  } else { player.animate(new long[]{200, 200, 200}, 3, 5, moving);}
  70.  
  71.  
  72.                                                            break;
  73.  
  74.                                                    case 1:
  75.                                                     //izquierda
  76.                                                    // mapindex(mx, my, true);
  77.                                                    // if (collidables(mx, my,p,1)) {
  78.                                                         jx = ox - 8;
  79.                                                         ox = jx;
  80.                                                         player.setPosition(jx, oy);
  81.                                                         player.animate(new long[]{200, 200, 200}, 9, 11, tmoving);
  82.                                                         mloop = true;
  83.                                                         mx--;
  84.                                                    // } else { player.animate(new long[]{200, 200, 200}, 9, 11, moving); }
  85.                                                            break;
  86.                                                    case 3:
  87.                                                        //abajo
  88.                                                     //mapindex(mx, my, true);
  89.                                                    // if (collidables(mx, my,p,1)) {
  90.                                                     jy = oy + 8;
  91.                                                     oy = jy;
  92.                                                     my++;
  93.                                                     player.setPosition(ox, jy);
  94.                                                     mloop = true;
  95.                                                     player.animate(new long[]{200, 200, 200}, 6, 8, tmoving);
  96.                                                     //} else {  player.animate(new long[]{200, 200, 200}, 6, 8, moving); }
  97.                                                            break;
  98.                                                    case 2:
  99.                                                        //arriba
  100.                                                     //mapindex(mx, my, true);
  101.                                                     //if(collidables(mx, my,p,1)) {
  102.                                                     jy = oy - 8;
  103.                                                        oy = jy;
  104.                                                        my--;
  105.                                                     player.setPosition(ox, jy);
  106.                                                     mloop = true;
  107.                                                     player.animate(new long[]{200, 200, 200}, 0, 2, tmoving);
  108.                                                    // } else { player.animate(new long[]{200, 200, 200}, 0, 2, moving); }
  109.                                                            break;
  110.                                                    case 4:
  111.                                                     //diagonal superior izquierda
  112.                                                     jx = ox - 4;
  113.                                                     ox = jx;
  114.                                                     jy = oy - 4;
  115.                                                     oy = jy;
  116.                                                     mx--;
  117.                                                     my--;
  118.                                                     player.setPosition(jx, jy);
  119.                                                     mloop = true;
  120.                                                     player.animate(new long[]{200, 200, 200}, 9, 11, tmoving);
  121.                                                     break;
  122.                                                    case 5:
  123.                                                     //diagonal inferior izquierda
  124.                                                     jx = ox - 4;
  125.                                                     ox = jx;
  126.                                                     jy = oy + 4;
  127.                                                     oy = jy;
  128.                                                     mx--;
  129.                                                     my++;
  130.                                                     player.setPosition(jx, jy);
  131.                                                     mloop = true;
  132.                                                     player.animate(new long[]{200, 200, 200}, 9, 11, tmoving);
  133.                                                     break;
  134.                                                    case 6:
  135.                                                     // diagonal superior derecha
  136.                                                     jx = ox + 4;
  137.                                                     ox = jx;
  138.                                                     jy = oy - 4;
  139.                                                     oy = jy;
  140.                                                     mx++;
  141.                                                     my--;
  142.                                                     player.setPosition(jx, jy);
  143.                                                     mloop = true;
  144.                                                     player.animate(new long[]{200, 200, 200}, 3, 5, tmoving);
  145.                                                     break;
  146.                                                    case 7:
  147.                                                     //diagonal inferior derecha
  148.  
  149.                                                     jx = ox + 4;
  150.                                                     ox = jx;
  151.                                                     jy = oy + 4;
  152.                                                     oy = jy;
  153.                                                     mx++;
  154.                                                     my++;
  155.                                                     player.setPosition(jx, jy);
  156.                                                     mloop = true;
  157.                                                     player.animate(new long[]{200, 200, 200}, 3, 5, tmoving);
  158.                                                     break;
  159.  
  160.                            }
  161.                             }
  162.                    } else {
  163.  
  164.  
  165.                     switch(tindex) {
  166.  
  167.                     case 0:
  168.                     jx = ox + 8;
  169.                        ox = jx;
  170.                        player.setPosition(jx, oy);
  171.                            temp++;
  172.                            if (temp == 3) { temp = 0; mloop = false; if (realfinish) { tmoving = false; } }
  173.  
  174.                            player.animate(new long[]{200, 200, 200}, 3, 5, moving);
  175.  
  176.                            break;
  177.                     case 1:
  178.                     jx = ox - 8;
  179.                     ox = jx;
  180.                     player.setPosition(jx, oy);
  181.                     temp++;
  182.                     if (temp == 3) { temp = 0; mloop = false; if (realfinish) { tmoving = false; }}
  183.                     player.animate(new long[]{200, 200, 200}, 9, 11, moving);
  184.                     break;
  185.                     case 2:
  186.                     jy = oy - 8;
  187.                     oy = jy;
  188.                     player.setPosition(ox, jy);
  189.                     temp++;
  190.  
  191.                     if (temp == 3) { temp = 0; mloop = false; if (realfinish) { tmoving = false; }}
  192.                     player.animate(new long[]{200, 200, 200}, 0, 2, moving);
  193.                     break;
  194.                     case 3:
  195.                     jy = oy + 8;
  196.                     oy = jy;
  197.                     player.setPosition(ox, jy);
  198.                     temp++;
  199.                     if (temp == 3) { temp = 0; mloop = false; if (realfinish) { tmoving = false; } }
  200.                     player.animate(new long[]{200, 200, 200}, 6, 8, moving);
  201.                     break;
  202.                      case 4:
  203.                           //diagonal superior izquierda
  204.                           jx = ox - 4;
  205.                           ox = jx;
  206.                           jy = oy - 4;
  207.                           oy = jy;
  208.                           temp++;
  209.                           player.setPosition(jx, jy);
  210.  
  211.                           player.animate(new long[]{200, 200, 200}, 9, 11, tmoving);
  212.                           if (temp == 7) { temp = 0; mloop = false; if(realfinish) {tmoving = false;}}
  213.                           break;
  214.                          case 5:
  215.                           //diagonal inferior izquierda
  216.                           jx = ox - 4;
  217.                           ox = jx;
  218.                           jy = oy + 4;
  219.                           oy = jy;
  220.                           temp++;
  221.                           player.setPosition(jx, jy);
  222.  
  223.                           player.animate(new long[]{200, 200, 200}, 9, 11, tmoving);
  224.                           if (temp == 7) { temp = 0; mloop = false; if(realfinish) {tmoving = false;}}
  225.                           break;
  226.                          case 6:
  227.                           // diagonal superior derecha
  228.                           jx = ox + 4;
  229.                           ox = jx;
  230.                           jy = oy - 4;
  231.                           oy = jy;
  232.                           temp++;
  233.                           player.setPosition(jx, jy);
  234.  
  235.                           player.animate(new long[]{200, 200, 200}, 3, 5, tmoving);
  236.                           if (temp == 7) { temp = 0; mloop = false; if(realfinish) {tmoving = false;}}
  237.                           break;
  238.                          case 7:
  239.                           //diagonal inferior derecha
  240.  
  241.                           jx = ox + 4;
  242.                           ox = jx;
  243.                           jy = oy + 4;
  244.                           oy = jy;
  245.  
  246.                           player.setPosition(jx, jy);
  247.                           temp++;
  248.                           player.animate(new long[]{200, 200, 200}, 3, 5, tmoving);
  249.                           if (temp == 7) { temp = 0; mloop = false; if(realfinish) {tmoving = false;}}
  250.                           break;
  251.  
  252.                     }
  253.  
  254.                    }
  255.                     }
  256.  
  257.  
  258.                    }
  259.            });
  260.  
  261.  


A ver si alguien puede ver lo que yo no veo

Desde ya gracias por dedicarle tiempo a este tema

PD: corregi otra cosa q me pase x alto, tambien el jug arranca a moverse a la derecha siempre x mas q no alla terminado de calcular a donde ir, y el loop infinito pasa mas seguido ahora :/

PD2: Le saque algunos errores mas, al parecer me habia confundido pensando en como habia declarado ciertas cosas. Ahora los problemas se reducen a:

El jugador no siempre calcula bien el path, hay veces que entra en un loop que no termina; aunque ahora lo fuerzo a que salga para que sea mas comodo

Otras veces misteriosamente me tira un ArrayOutOfBounds Exception esta linea:


int tvx = valuesx[m][q];
int tvy = valuesy[m][q];

if ( tvx >= 0  && tvy >=0) {

if (onclosedlist[valuesx[m][q]][valuesy[m][q]]) { ontclosedlist[m][q] = true;}

}
y digo misteriosamente por que esta comprendida en el if que no dejaria que entre si esta outofbounds :/. En el log me dice que entra con tvx = tvy = -1


Mi teoria al tener que decidir entre dos tiles con el mismo valor elige uno y para ese lado no puede solucionar el problema. Ahi es cuando no sale del loop. Cuando este mas en frio lo chequeo bien, pero si alguien lo descubre a simple vista mejor



« Última modificación: 2 Noviembre 2010, 03:24 am por rastanthology » En línea

Páginas: [1] Ir Arriba Respuesta Imprimir 

Ir a:  

Mensajes similares
Asunto Iniciado por Respuestas Vistas Último mensaje
El modo jugador contra jugador de Diablo III no estará listo en su lanzamiento
Noticias
wolfbcn 1 2,419 Último mensaje 12 Marzo 2012, 15:33 pm
por anonimo12121
Necesito una mano . [Función en PHP]
Hacking
TheStroker 0 2,099 Último mensaje 2 Agosto 2012, 03:38 am
por TheStroker
sorri necesito una mano
Hacking Wireless
txaske 4 2,558 Último mensaje 9 Diciembre 2013, 09:44 am
por txaske
[PS] Necesito mover ficheros de más de 2 días con PowerShell
Scripting
guercab 0 2,121 Último mensaje 17 Diciembre 2013, 21:06 pm
por guercab
[C++] Necesito una mano :D
Programación C/C++
santiagolo 5 2,455 Último mensaje 21 Febrero 2014, 11:32 am
por xaps
WAP2 - Aviso Legal - Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines