Foros del Web » Programación para mayores de 30 ;) » Programación móvil »

Ayuda con programación en Wireless Toolkit 2.5.1

 Estas en el tema de Ayuda con programación en Wireless Toolkit 2.5.1 en el foro de Programación móvil en Foros del Web. Buenas amigos, soy nuevo en esta gran comunidad. Mi problema es el siguiente: Tengo una aplicación en Wireless Toolkit 2.5.1 en el cual tengo una ...
  #1 (permalink)  
Antiguo 17/02/2011, 00:03
 
Fecha de Ingreso: enero-2011
Mensajes: 2
Antigüedad: 13 años, 2 meses
Puntos: 0
Ayuda con programación en Wireless Toolkit 2.5.1
Buenas amigos, soy nuevo en esta gran comunidad.
Mi problema es el siguiente:
Tengo una aplicación en Wireless Toolkit 2.5.1 en el cual tengo una bola manual(de color verde, la cual manipulo con las flechas del teclado) y un player (bola automática de color celeste, la cual se mueve de izquierda a derecha y viceversa) y quisiera que me ayuden en la programación de tal manera que la bola manual al mínimo roce con el player se produzca un efecto de eclipse(que se pinte de color negro el fondo de pantalla), sólo en el instante del choque.

PD: En el siguiente archivo, lo que NO QUIERO es que me salga el efecto de eclipse cuando la bola manual se encuentre a cierta inclinación con respecto a la bola automática.

Espero me hayan entendido. Gracias de antemano por su ayuda.
POR FAVOR LA LINEA 196, EN ESA NECESITO LA MODIFICACION

Progreso normal
[URL=http://img254.imageshack.us/i/juego2b.jpg/][IMG]http://img254.imageshack.us/img254/755/juego2b.th.jpg[/IMG][/URL]

Roce normal
[URL=http://img717.imageshack.us/i/juego2a.jpg/][IMG]http://img717.imageshack.us/img717/7641/juego2a.th.jpg[/IMG][/URL]

He aquí mi problema
[URL=http://img401.imageshack.us/i/juego2p.jpg/][IMG]http://img401.imageshack.us/img401/5083/juego2p.th.jpg[/IMG][/URL]

Por favor miren la imagen y hay verán lo que no quiero


Código Java: 
Ver original
  1. /*importamos las clases de java que utilizaremos en nuestro programa*/
  2. import javax.microedition.midlet.*;
  3. import javax.microedition.lcdui.*;
  4.  
  5. /*aqui nuestro MIDlet, esta clase sera la primera en ser ejecutada cuando se
  6. ejecute el programa*/
  7.  public class Juego2 extends MIDlet {    
  8.     //metodo cuando el midlet arranca
  9.     public void startApp() {
  10.         //creamos un objeto SSCanvas (nuestra pantalla de juego)
  11.         SSCanvas screen=new SSCanvas();
  12.         //indicamos al dispositivo que screen (instancia de SSCanvas) será la nueva pantalla activa
  13.         Display.getDisplay(this).setCurrent(screen);   
  14.         new Thread(screen).start();     //arrancamos el bucle (nuevo hilo de ejecución)
  15.     }
  16.     
  17.     //metodo cuando el midlet entra en pausa
  18.     public void pauseApp() {
  19.     }
  20.     
  21.     //metodo cuando el midlet es destruido
  22.     public void destroyApp(boolean unconditional) {
  23.     }
  24. }
  25.  
  26.  
  27. //esta clase es la encargada de hacer funcionar nuestra aplicación gráfica 
  28. class SSCanvas extends Canvas implements Runnable{ 
  29.     private Sprite ball;
  30.     private Sprite player;
  31.  
  32.     //metodo constructor
  33.     public SSCanvas(){
  34.         //instanciamos (creamos) el objeto ball a partir de la clase Sprite
  35.         ball = new Sprite(getWidth()/2,getHeight()/2,20,20);
  36.         player = new Sprite(getWidth()/2,getHeight()/2,20,20);  
  37.     }
  38.     
  39.     public void run(){
  40.         while(true){
  41.             //actualizamos la posicion de la bola
  42.             ball.computeBallX(getWidth(),getHeight());  
  43.             player.computePlayerX(getWidth(),getHeight());
  44.             player.computePlayerY(getWidth(),getHeight());
  45.  
  46.  
  47.  
  48.             //forzamos el repintado de la pantalla
  49.             repaint();
  50.             serviceRepaints();
  51.             try {
  52.                 Thread.sleep(5);            
  53.             } catch (InterruptedException e) {        
  54.             }
  55.         }
  56.     }
  57.     //metodo de la clase canvas para pintar en pantalla
  58.     public void paint(Graphics g){          
  59.         //seleccionamos el color negro para pintar el fondo
  60.         if(player.collision(ball) )g.setColor(0,0,0);
  61.         else g.setColor(255,255,255);
  62.     //pintamos el fondo de pantalla con un rectangulo con el tamaño de
  63.     //la pantalla getWidth() y getHeight() es un método de la clase canvas
  64.     //que nos devuelve el ancho y alto de la pantalla
  65.  
  66.         g.fillRect(0,0,getWidth(),getHeight());
  67.         //pintamos la bola en pantalla
  68.          ball.draw(g);
  69.          player.draw1(g);
  70.  
  71.  
  72.  
  73.  
  74.  
  75.     }    
  76.     
  77.     /*sobrecarga de método para detectar cuando una tecla es soltada 
  78.     por el usuario*/
  79.     public void keyReleased(int keyCode) {
  80.     int action=getGameAction(keyCode);      
  81.     switch (action) {
  82.             case LEFT:    
  83.                  player.keyUp(player.LEFT);             
  84.         break;
  85.             case RIGHT: 
  86.                  player.keyUp(player.RIGHT);
  87.         break;
  88.             case UP:
  89.               player.keyUp(player.UP);
  90.         break;
  91.             case DOWN:  
  92.                  player.keyUp(player.DOWN);
  93.         break;  
  94.             case FIRE:                
  95.                 break;            
  96.         }
  97.     }
  98.  
  99.     //sobrecarga del método que detecta cuando una tecla es pulsada por el usuario
  100.     public void keyPressed(int keyCode) {
  101.     int action=getGameAction(keyCode);              
  102.         switch (action) {
  103.             case LEFT:
  104.                 player.keyPress(player.LEFT);               
  105.                 break;
  106.             case RIGHT:
  107.                 player.keyPress(player.RIGHT);      
  108.         break;
  109.             case UP:
  110.                 player.keyPress(player.UP);                
  111.                 break;
  112.             case DOWN:
  113.         player.keyPress(player.DOWN); 
  114.         break;
  115.             case FIRE:          
  116.         break;                     
  117.          }        
  118.     }
  119. }
  120.  
  121. class Sprite{
  122.     //atributos privados
  123.     protected int x; 
  124.     protected int y;
  125.     protected int width;
  126.     protected int height;
  127.     protected int incX,incY;   
  128.     private boolean startX=false;   //movimiento inicial en x=apagado
  129.     private boolean startY=false;   //movimiento inicial en y=apagado
  130.  
  131.  
  132.  //declaracion de constantes
  133.     protected static final int LEFT = 1;
  134.     protected static final int RIGHT = 2;
  135.     protected static final int UP = 3;
  136.     protected static final int DOWN = 4;
  137.     protected static final int FIRE = 5;
  138.     
  139.     //metodo constructor 
  140.     public Sprite(int x,int y,int width,int height){
  141.         this.x=x;
  142.         this.y=y;
  143.         this.width=width;
  144.         this.height=height;
  145.         incX=1;
  146.         incY=1;
  147.     }
  148.     
  149.  
  150.     //metodo que actualiza la posición del sprite
  151.     public void computeBallX(int screenW, int screenH){
  152.         if(x <= 0)incX=1;
  153.         else if(x+width >= screenW)incX=-1;
  154.         x+=incX;
  155.     }  
  156.  
  157.     public void computeBallY(int screenW, int screenH){
  158.      if(y <= 0)incY=1;
  159.          else if(y+width >= screenH)incY=-1;
  160.          y+=incY;
  161.      }
  162.  
  163.  
  164.  
  165.  
  166. //metodo que actualiza la posicion del sprite que controlamos por teclado
  167.     public void computePlayerX(int screenW, int screenH) {
  168.         if(x + incX > 0 && (x + incX) < (screenW - width)){
  169.           x+=incX;                  
  170.           if(startX==false)incX=0;
  171.         
  172.           }
  173.      }
  174.     public void computePlayerY(int screenW, int screenH) {
  175.         if(y + incY > 0 && (y + incY) < (screenH - height)){
  176.           y+=incY;
  177.           if(startY==false)incY=0;
  178.  
  179.           }          
  180.      }  
  181.  
  182.  
  183.    
  184.     
  185.    
  186.     //metodo para detectar colisiones
  187.     public boolean collision(Sprite sp){
  188.         //comprobamos si el sprite 1 ha colisionado o 
  189.         //superpuesto sobre el sprite 2
  190.           int mayor=x,menor=x;
  191.           int mayor2=y,menor2=y;
  192.           if(sp.x>mayor)mayor=sp.x;
  193.           if(sp.x<menor)menor=sp.x;
  194.           if(sp.y>mayor2)mayor2=sp.y;
  195.           if(sp.y<menor2)menor2=sp.y;
  196.           if (((mayor-menor)<(width/2+sp.width/2))&&((mayor2-menor2)<(height/2+sp.height/2)))return true;
  197.          // ^
  198.          // |
  199.          // | EN ESTA CONDICION SE LE REALIZA ALGUNOS CAMBIOS PARA PODER LOGRAR LO QUE PIDO!
  200.         else  return false;
  201.                     
  202.      }
  203.  
  204.     
  205.     //metodo que actualiza la posicion del sprite 
  206.     
  207.     //metodo para detener el desplazamiento del sprite
  208.      public void keyUp(int keyCode) {
  209.     switch (keyCode) {
  210.             case LEFT:
  211.         startX=false;               
  212.         break;
  213.             case RIGHT:
  214.         startX=false;
  215.         break;
  216.             case UP:
  217.         startY=false;
  218.                 break;
  219.             case DOWN:
  220.         startY=false;
  221.         break;                              
  222.         }       
  223.     }
  224.     
  225.     //método para indicar la dirección del desplazamiento
  226.     public void keyPress(int keyCode) { 
  227.         switch (keyCode) {
  228.             case LEFT:
  229.                 incX=-1;
  230.                 startX=false;                   
  231.                 break;
  232.             case RIGHT:
  233.                 incX=1; 
  234.                 startX=false;           
  235.                 break;
  236.             case UP:
  237.                 incY=-1;
  238.                 startY=false;
  239.                 break;
  240.             case DOWN:
  241.                 incY=1;
  242.                 startY=false;
  243.                 break;
  244.             case FIRE:                    
  245.                 break;
  246.         }
  247.     }
  248.  //metodo que muestra en pantalla al sprite
  249.     public void draw(Graphics g){
  250.         g.setColor(x,255,255);
  251.         g.fillArc(x,y, width, height,0, 360);        
  252.     }
  253.  
  254.     public void draw1(Graphics g){
  255.         g.setColor(0,250,0);
  256.         g.fillArc(x,y,y/8, y/8,0, 360);  
  257.     }
  258.  
  259.  
  260. }
Última edición por mayhemdeath; 17/02/2011 a las 21:27

Etiquetas: java, movil, programacion
Atención: Estás leyendo un tema que no tiene actividad desde hace más de 6 MESES, te recomendamos abrir un Nuevo tema en lugar de responder al actual.
Respuesta


« Tema Anterior | Próximo Tema »


La zona horaria es GMT -6. Ahora son las 10:10.