TUTO EXPRESS: bille qui "roule" avec l'accéléromètre.

[Profete162]

Bonjour le monde,

J'avais posé il y a quelques minutes des questions pour fabriquer un objet qui bouge avec l'accéléromètre.

Comme j'ai trouvé ma réponse, je poste un "Tuto Express" sur comment réaliser cette application.

En fait, j'ai mixé 2 tutos de anddev.org, tout le mérite revient à leurs posteurs respectifs.

Le programme pourrait être améliorer pour créer une "bille" qui roule dans votre téléphone.

Ze tuto:

Il faut donc créer 2 classes java: BounceView et Move dont voici le code:

Move.Java

import android.app.Activity;
import android.content.Context;
import android.hardware.Sensor;
import android.hardware.SensorEvent;
import android.hardware.SensorEventListener;
import android.hardware.SensorManager;
import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.view.Window;

public class Move extends Activity implements SensorEventListener {
//public class Move extends Activity  {
   /** Called when the activity is first created. */
    // Just a RANDOM ID to recognize a Message later 
   protected static final int GUIUPDATEIDENTIFIER = 0x101; 
   SensorManager sensorManager; 
   Thread myRefreshThread = null; 

   /* Our 'ball' is located within this View */ 
   BounceView myBounceView = null; 

   Handler myGUIUpdateHandler = new Handler() { 

        // @Override 
        public void handleMessage(Message msg) { 
             switch (msg.what) { 
                  case Move.GUIUPDATEIDENTIFIER: 
                       /* Repaint the BounceView 
                        * (where the ball is in) */ 
                      myBounceView.invalidate(); 
                       break; 
             } 
             super.handleMessage(msg); 
        } 
   }; 

   /** Called when the activity is first created. */ 
   @Override 
   public void onCreate(Bundle icicle) { 
        super.onCreate(icicle); 
        // Set fullscreen 
        this.requestWindowFeature(Window.FEATURE_NO_TITLE); 

        // Create a 
        this.myBounceView = new BounceView(this); 
        this.setContentView(this.myBounceView); 
        sensorManager = (SensorManager)getSystemService(Context.SENSOR_SERVICE); 
        //updateOrientation(0, 0, 0);
        /* create a Thread that will 
         * periodically send messages 
         * to our Handler */ 
        new Thread(new RefreshRunner()).start(); 
   } 

   class RefreshRunner implements Runnable { 
        // @Override 
        public void run() { 
             while (!Thread.currentThread().isInterrupted()) { 
                  // Send Message to the Handler which will call the invalidate() method of the BOucneView 
                  Message message = new Message(); 
                  message.what = Move.GUIUPDATEIDENTIFIER; 
                  Move.this.myGUIUpdateHandler.sendMessage(message); 

                  try { 
                       Thread.sleep(100); // a 10th of a second 
                  } catch (InterruptedException e) { 
                       Thread.currentThread().interrupt(); 
                  } 
             } 
        } 
   } 


   protected void onResume() 
   { 
     super.onResume(); 
     sensorManager.registerListener(this, sensorManager.getDefaultSensor(Sensor.TYPE_ORIENTATION), SensorManager.SENSOR_DELAY_FASTEST); 
   } 

   protected void onStop() 
   { 
       sensorManager.unregisterListener(this); 
     super.onStop(); 
   } 


    public void onAccuracyChanged(Sensor sensor, int accuracy) { 
    } 

   public void onSensorChanged(SensorEvent event) { 
       myBounceView.mPitch=event.values[sensorManager.DATA_Z];
       myBounceView.mHeading=event.values[sensorManager.DATA_Y];

        //updateOrientation(event.values[sensorManager.DATA_X], event.values[sensorManager.DATA_Y], event.values[sensorManager.DATA_Z]); 

   } 



}

BounceView.java

import android.content.Context; 
import android.graphics.Canvas; 
import android.graphics.Point; 
import android.graphics.drawable.Drawable; 
import android.view.View; 

public class BounceView extends View { 

    /* Our Ball together with the location it will be painted*/ 
    protected Drawable mySprite; 
    protected Point mySpritePos = new Point(0,0); 

    /* Working with a Enum is 10000% 
     * safer than working with int's 
     * to 'remember' the direction. */ 
    static float mRoll, mPitch, mHeading;
    protected enum HorizontalDirection {LEFT, RIGHT} 
    protected enum VerticalDirection {UP, DOWN} 
    protected HorizontalDirection myXDirection = HorizontalDirection.RIGHT; 
    protected VerticalDirection myYDirection = VerticalDirection.UP; 


    public BounceView(Context context) { 
         super(context); 
         // Set the background 
         this.setBackgroundDrawable(this.getResources().getDrawable(R.drawable.icon)); 
         // Load our "Ball" 
         this.mySprite = this.getResources().getDrawable(R.drawable.icon); 
    } 

    @Override 
    protected void onDraw(Canvas canvas) { 
         /* Check if the Ball started to leave 
          * the screen on left or right side */ 

        this.mySpritePos.x -= mPitch; 

         if (mySpritePos.x >= this.getWidth() - mySprite.getBounds().width()) { 
             mySpritePos.x = this.getWidth() - mySprite.getBounds().width();
              //this.myXDirection = HorizontalDirection.LEFT; 
         } else if (mySpritePos.x <= 0) { 
             mySpritePos.x = 0;
              //this.myXDirection = HorizontalDirection.RIGHT; 
         } 


        this.mySpritePos.y -= mHeading; 

         if (mySpritePos.y >= this.getHeight() - mySprite.getBounds().height()) { 
             mySpritePos.y = this.getHeight() - mySprite.getBounds().height(); 
        } else if (mySpritePos.y <= 0) { 
            mySpritePos.y = 0; 
        } 



         /* Set the location, where the sprite 
          * will draw itself to the canvas */ 
         this.mySprite.setBounds(this.mySpritePos.x, this.mySpritePos.y, 
                   this.mySpritePos.x + 50, this.mySpritePos.y + 50); 

         /* Make the sprite draw itself to the canvas */ 
         this.mySprite.draw(canvas); 
    } 
}

Au plaisir!

Modifié 12 février 2010 par Profete162

[Profete162]

*Reserve*

Voilà, je suis ouvert à tous les commentaires.

TODO LIST

* Empecher la rotation de l'écran.

* Faire rebondir la balle sur les murs.

Modifié 12 février 2010 par Profete162

[Profete162]

Désolé, mais j'ai pas envie de me lancer dans le wiki, faute de courage et de temps.

Si une personne charitable le trouve utile, qu'il le mette là dedans et je verrai pour comment le modifier au fur et à mesure.

[bobotetete]

Sympa d'avoir poster ça. :)

Je vais l'essayer.

[Stilgardt]

@Profete162: Sympa ce code. Et en plus, ça marche du premier coup! Merci! :)

Pour l'anticollision pour ta bille "carrée", peut-être que le plus simple et d'utiliser un système de Views imbriquées?

Sinon, pour des jeux tels que Buka, je me demande encore comment ils font car c'est vraiment très précis...

[Profete162]

Pour l'anticollision pour ta bille "carrée", peut-être que le plus simple et d'utiliser un système de Views imbriquées?

Aucune idée de quoi tu parles, mais tu peux peut-être améliorer mon tuto et le poster, ce serait vraiment sympa!

[Stilgardt]

Pour l'anticollision pour ta bille "carrée"' date=' peut-être que le plus simple et d'utiliser un système de Views imbriquées?[/quote']

Aucune idée de quoi tu parles, mais tu peux peut-être améliorer mon tuto et le poster, ce serait vraiment sympa!

En me relisant, moi non plus, je n'ai plus les idées trop claires sur ce que je voulais dire. :P

Par contre, j'ai ouvert un sujet spécial "Collision" ici:

https://www.frandroid.com/forum/viewtopic.php?id=8869

et dans lequel, j'ai mis un morceau de code qui je pense s'adapterait très simplement à ta gestion de l'accéléromètre (et donc là ça ferait plein de petites billes qui rouleraient sur l'écran en fonction de l'orientation du téléphone :) )

Pourquoi pas un billard géré uniquement par accéléromètre? (mais pas trop le courage de me lancer là-dedans donc si quelqu'un est tenté, j'offre l'idée :P )