Java Android onTouch Richtung

Question

Ich versuche ein einfaches Spiel zu entwickeln, in dem ich eine Kugel werfen muss. Ich möchte der Ball folgt die Berührung oder Swipe-Richtung.

Allerdings habe ich ein kleines Problem, das ich nicht erfolgreich gelöst habe.

Ich nehme Koordinaten auf die ACTION_DOWN von MotionEvent, und die Koordinaten auf die ACTION_UP von MotionEvent, dann berechnet die Geradengleichung, um den Ball zu bewegen, gemäß dieser geraden Linie.

Das Problem ist, dass, wenn ich in eine Richtung in der Nähe von "oben" oder "vorwärts" oder "vor" wische, der Ball blitzschnell bewegt, während in der anderen Richtung mehr schief (rechts oder links) oder Diagonal bewegt sich der Ball mit normaler Geschwindigkeit.

Wo ist der Fehler in meiner Berechnung?

Helfen Sie mir bitte, ich bin nicht weit von dem Ergebnis, aber müssen Sie für die Lösung dieses Problems!

Die onTouch Methode:

public boolean onTouchEvent(MotionEvent event) { 
    switch(event.getAction()) { 
     case(MotionEvent.ACTION_DOWN): 
      balle.setX(event.getX()); 
      balle.setY(event.getY()); 
      ya = event.getY(); 
      xa = event.getX(); 
      break; 

     case(MotionEvent.ACTION_UP): 
      xb = event.getX(); 
      yb = event.getY(); 
      balle.setMove(true); 
      break; 
    } 

    return true; 
} 

Das ist mein moveDirection Methode:

public void moveDirection(float xa, float ya, float xb, float yb) { 
    if(!move) { 
     return; 
    } 
    else { 
     float m, b; 
     float dx = xb-xa; 

     m = (yb - ya)/(xb - xa); 

     b = ya - (m * xa); 

     if(dx > 0) { 
      this.x += speedX; 
     } 
     else { 
      this.x += -speedX; 
     } 

     this.y = (m * this.x + b); 
    } 
} 

Vielen Dank im Voraus!

Answer 1

Ich sehe, dass Sie nicht alle Ereignisse erfassen, also vielleicht hilft der Code aus der Android Dokumentation mit de VelocityTracker api, in diesem Beispiel, wenn Sie Ihren Finger herunterziehen, wird ein neuer Tracker erstellt und wenn Sie (in Jede Richtung) Sie erfassen die Geschwindigkeit des Ereignisses, ich denke, Sie können den Ball entsprechend der Geschwindigkeit und Richtung der Berührung bewegen.

public class MainActivity extends Activity { 
private static final String DEBUG_TAG = "Velocity"; 
    ... 
private VelocityTracker mVelocityTracker = null; 
@Override 
public boolean onTouchEvent(MotionEvent event) { 
    int index = event.getActionIndex(); 
    int action = event.getActionMasked(); 
    int pointerId = event.getPointerId(index); 

    switch(action) { 
     case MotionEvent.ACTION_DOWN: 
      if(mVelocityTracker == null) { 
       // Retrieve a new VelocityTracker object to watch the velocity of a motion. 
       mVelocityTracker = VelocityTracker.obtain(); 
      } 
      else { 
       // Reset the velocity tracker back to its initial state. 
       mVelocityTracker.clear(); 
      } 
      // Add a user's movement to the tracker. 
      mVelocityTracker.addMovement(event); 
      break; 
     case MotionEvent.ACTION_MOVE: 
      mVelocityTracker.addMovement(event); 
      // When you want to determine the velocity, call 
      // computeCurrentVelocity(). Then call getXVelocity() 
      // and getYVelocity() to retrieve the velocity for each pointer ID. 
      mVelocityTracker.computeCurrentVelocity(1000); 
      // Log velocity of pixels per second 
      // Best practice to use VelocityTrackerCompat where possible. 
      Log.d("", "X velocity: " + 
        VelocityTrackerCompat.getXVelocity(mVelocityTracker, 
        pointerId)); 
      Log.d("", "Y velocity: " + 
        VelocityTrackerCompat.getYVelocity(mVelocityTracker, 
        pointerId)); 
      break; 
     case MotionEvent.ACTION_UP: 
     case MotionEvent.ACTION_CANCEL: 
      // Return a VelocityTracker object back to be re-used by others. 
      mVelocityTracker.recycle(); 
      break; 
    } 
    return true; 
} 
} 

Link für doc.