PrintTest

All position, velocity and acceleration variables are in real physical units (doubles, m, m/s, m/s^2)
Some initial conditions are set by the constructor, but because the constructor is called before the actor is added to the game grid, some other parameters are unknown when the constructor runs, especially the actor's location and the simulation period. Because reset() is invoked when the actor is added to the game grid, these parameters can be easily retrieved here
The state change from time t to t + dt is performed in act(). We use the well-known equations for a free falling object in the homogenous gravitational field
The dimension factor dimFactor maps the screen dimension (integer pixel coordinates) to the real world dimensions
When the actor leaves the game grid, it is removed to save memory and increase execution speed (especially important with colliding actors)

package ch.aplu.tut;

import ch.aplu.android.*;

public class TennisBall extends Actor
{
  private final double g = 9.81; // in m/s^2
  private double dimFactor;
  private double x, y;  // in m
  private double vx, vy; // in  m/s
  private double dt;  // in s

  public TennisBall(double vx, double vy, double dimFactor)
  {
    super("tennisball");
    // Initial condition
    this.vx = vx;
    this.vy = vy;
    this.dimFactor = dimFactor;
  }

  public void reset()
  {
    // Initial condition
    x = getX() / dimFactor;
    y = getY() / dimFactor;
    dt = gameGrid.getSimulationPeriod() / 1000.0;  // in s
  }

  public void act()
  {
    vy = vy + g * dt;
    x = x + vx * dt;
    y = y + vy * dt;
    setLocation(new Location(dimFactor * x, dimFactor * y));
    if (!isInGrid())
      removeSelf();
  }
}

For the purpose of a demonstration the application program is kept simple. We create a full-screen window in landscape orientation with a status bar, where we want to display the velocity values from the fling event (in a suitable decimal format). The velocity reported from the fling event needs to be scaled with vFactor.

package ch.aplu.tut;

import ch.aplu.android.*;
import android.graphics.Point;
import java.text.DecimalFormat;

public class Ex09 extends GameGrid implements GGFlingListener
{
  private final double courtWidth = 23.77; // m
  private double dimFactor;
  private final double vFactor = 50.0;
  private GGStatusBar status;

  public Ex09()
  {
    super(WHITE, false, true, null); // full screen, white boarder
    setScreenOrientation(LANDSCAPE);
    status = addStatusBar(20);
  }

  public void main()
  {
    addFlingListener(this);
    dimensionFactor = getNbHorzCells() / courtWidth;
    setSimulationPeriod(50);
    doRun();
    status.setText("Fling the ball!");
  }

  public boolean flingEvent(Point start, Point end, GGVector velocity)
  {
    TennisBall tennisBall = new TennisBall(
            vFactor * velocity.x, vFactor * velocity.y, dimFactor);
    DecimalFormat d = new DecimalFormat("#.#");
    String vx = d.format(velocity.x);
    String vy = d.format(velocity.y);
    String v = d.format(velocity.magnitude());
    status.setText("(vx, vy) = (" + vx + ", " + vy + "); v = " + v);
    addActorNoRefresh(tennisBall, toLocation(end.x, end.y));
    return true;
  }
}

Download Ex09 app for installation on a smartphone

Create QR code to download Android app to your smartphone.

Download sources (Ex09.zip).

With the knowledge of the above example it is not difficult to simulate the movement of a tennis ball subject to air friction. We assume that the frictional force is proportional to the square of the magnitude of the velocity and has a direction opposite to the velocity vector. To solve the problem it is highly recommended to use a vector notation and the GGVector class. Below are summarized the algebraic formulas and their implementation in Java.

Quantity	Mathematical notation	Program implementation
Force		GGVector f = g.mult(m).add(v.mult(-R * v.magnitude()));
Acceleration		GGVector a = f.mult(1 / m);
New velocity		GGVector vnew = v.add(a.mult(dt));
New position		GGVector rnew = r.add(v.mult(dt));

Using the vector notation the code of the modified class TennisBall1 that takes into account the air friction is clean and simple. The only modification in the application class is to replace TennisBall by TennisBall1.

package ch.aplu.tut;

import ch.aplu.android.*;
import android.graphics.Point;

public class TennisBall1 extends Actor
{
  private final GGVector g = new GGVector(0, 9.81);
  private final double m = 0.057; // kg
  private final double R = 0.005; // Air friction (N per (m/s)^2)
  private double dimFactor;
  private GGVector r;
  private GGVector v;
  private double dt;  // in s

  public TennisBall1(GGVector v, double dimFactor)
  {
    super("tennisball");
    // Initial condition
    this.v = v;
    this.dimFactor = dimFactor;
  }

  public void reset()
  {
    // Initial condition
    r = new GGVector(getX() / dimFactor, getY() / dimFactor);
    dt = gameGrid.getSimulationPeriod() / 1000.0;  // in s
  }

  public void act()
  {
    GGVector f = g.mult(m).add(v.mult(-R * v.magnitude()));
    GGVector a = f.mult(1 / m);
    GGVector vnew = v.add(a.mult(dt));
    GGVector rnew = r.add(v.mult(dt));
    setLocation(new Location(toPix(rnew).x, toPix(rnew).y));
    gameGrid.getBg().drawLine(toPix(r), toPix(rnew));
    r = rnew;
    v = vnew();

    if (!isInGrid())
      removeSelf();
  }

  private Point toPix(GGVector z)
  {
    return new Point((int)(dimFactor * z.x + 0.5),
      (int)(dimFactor * z.y + 0.5));
  }
}

fling3

Download Ex09a app for installation on a smartphone

Create QR code to download Android app to your smartphone.

Download sources (Ex09a.zip).

In the examples above, the gravitational field acceleration is supposed to be constant and directed from the top to the bottom of the application window. Because we use physical units, it is easy to modify the scenario to simulate a moving disk with air friction on the device surface (a rolling ball would behave like a disk with a somewhat greater mass). We use the internal acceleration sensor and initialize it by calling GGComboSensor.init() in the application class. In the modified Tennisball2.java we have just to add the two following lines at the beginning of act() instead of using a constant GGVector g:

double[] acc = Ex09b.sensor.getAcceleration(0);
GGVector g = new GGVector(-acc[3], acc[4]);

fling4

Download Ex09b app for installation on a smartphone

Create QR code to download Android app to your smartphone.

Download sources (Ex09b.zip).

A prototype of a shooting game with fling

In many games using fling you select the object by tapping first the image you want to fling. This corresponds to the starting point of the fling event callback. In a typical "Shooting Gallery Game" the player launches selected balls to hit a moving figure. The following code shows several important implementation details:

Ten balls are generated in createBalls(), shown at equal distances and inserted into a balls list. This list is used to define the collision partners for each figure created in createFigure(). All actors are added to the game grid using addActorNoRefresh() because the game grid is automatically refreshed by the simulation loop. This avoids the interference of refreshing by the simulation loop and callback methods that causes flickering.
In the flingEvent() callback the coordinates of start and end must be converted to locations using the toLocation() method. If it is important to have only locations within the game grid, use toLocationInGrid(). end is used to limit the launch area to the lower part of the window. start selects the ball to launch by traversing the balls list and testing with isIntersecting(), if the start point is part of the non-transparent pixels of a particular ball. If this is the case, the ball's launch() method is invoked that starts the movement of the selected ball.
When the figure and a ball collide, the collide() callback is invoked that removes the figure and hides the ball. (The ball is removed when it is outside the game grid). At this time the game score is updated.
GameGrid.act() is the ideal place to put the code for a game supervisor, because act() is invoked in every simulation period. The supervisor checks if the game is over (because all balls are used). It also creates a new figure if the current figure has been hit (and removed).

package ch.aplu.shootinggallery;

import ch.aplu.android.*;
import android.graphics.Point;
import java.util.ArrayList;

public class ShootingGallery extends GameGrid
  implements GGFlingListener, GGActorCollisionListener
{
  private final int nbBalls = 10;
  private GGStatusBar status;
  private Ball[] balls = new Ball[nbBalls];
  private int width, height;
  private int nbPoints = 0;
  private Figure f;

  public ShootingGallery()
  {
    super(WHITE, false, true, windowZoom(1000));
    setScreenOrientation(LANDSCAPE);
    status = addStatusBar(30);
  }

  public void main()
  {
    width = getNbHorzCells();
    height = getNbVertCells();
    addFlingListener(this);
    setSimulationPeriod(30);
    getBg().setPaintColor(YELLOW);
    getBg().drawLine(0, 2 * height / 10, width, 2 * height / 10);
    getBg().setPaintColor(RED);
    getBg().drawLine(0, height / 2, width, height / 2);
    createBalls();
    status.setText("Fling a ball!");
    doRun();
  }

  public void act()
  {
    if (getNumberOfActors(Ball.class) == 0)  // Game over
    {
      status.setText("Game over. Total points: " + nbPoints);
      f.removeSelf();
      refresh();  // delay will inhibit automatic refresh
      delay(3000);
      createBalls();
      createFigure();
      nbPoints = 0;
      status.setText("Fling a ball!");
    }
    if (getNumberOfActors(Figure.class) == 0)
    {
      delay(1000);
      if (getNumberOfActors(Ball.class) != 0)
        createFigure();
    }
  }

  private void createBalls()
  {
    for (int i = 0; i < nbBalls; i++)
    {
      Ball ball = new Ball(this, (i + 1) * 10);
      int d = width / nbBalls;
      addActorNoRefresh(ball, new Location(d / 2 + i * d, height - d / 2));
      balls[i] = ball;
    }
  }

  private void createFigure()
  {
    f = new Figure();
    double x = 10 + Math.random() * (width - 10);
    addActorNoRefresh(f, new Location(x, height / 10),
     (Math.random() < 0.5) ? 0 : 180);
    f.setCollisionRectangle(new Point(0, 50), 50, 50);
    for (Ball ball : balls)
    {
      if (ball != null)
      {
        f.addCollisionActor(ball);
        f.addActorCollisionListener(this);
      }
    }
  }

  public boolean flingEvent(Point start, Point end, GGVector velocity)
  {
    Location endLocation = toLocationInGrid(end);
    if (endLocation.y < height / 2)
      return true;
    Location startLocation = toLocationInGrid(start);
    Point startPos = new Point(startLocation.x, startLocation.y);
    int index = getBallIndex(startPos);
    if (index != -1)
    {
      balls[index].launch(endLocation, velocity);
      balls[index] = null; // tag as removed
    }
    return true;
  }

  // Returns the index of the ball cell where pt resides or
  // -1 if pt is not part of any ball cell
  private int getBallIndex(Point pt)
  {
    int d = width / nbBalls;
    if (pt.y < height - d) // not in lower row
      return -1;
    int index = pt.x / d;
    if (balls[index] == null) // tagged as removed
      return -1;
    return index;
  }

  public int collide(Actor actor1, Actor actor2)
  {
    actor1.removeSelf();
    actor2.hide();
    nbPoints += ((Ball)actor2).getValue();
    displayResult();
    return 10;
  }

  protected void displayResult()
  {
    status.setText("# point: " + nbPoints);
  }
}

A Ball is-an Actor (derived from Actor) and disables act() when created. Its launch() method uses the start and v parameter to set the starting location, the direction and the speed before enabling act() where the movement of the ball is engaged. In act() we just call move() using the speed value to move the ball to next position.

package ch.aplu.shootinggallery;

import android.graphics.Point;
import ch.aplu.android.*;

class Ball extends Actor
{
  private ShootingGallery app;
  private final int speedFactor = 100;
  private int speed;
  private int value;

  public Ball(ShootingGallery app, int value)
  {
    super("ball_" + value);
    this.app = app;
    this.value = value;
    setActEnabled(false);
  }

  protected void launch(Location start, GGVector v)
  {
    setLocation(start);
    setDirection(Math.toDegrees(v.getDirection()));
    speed = (int)(speedFactor * v.magnitude());
    setActEnabled(true);
  }

  protected int getValue()
  {
    return value;
  }

  public void act()
  {
    if (isInGrid())
     move(speed);
    else
    {
      app.displayResult();
      removeSelf();
    }
  }
}

Finally the Figure class is also derived from Actor and moves the figure forth and back.

package ch.aplu.shootinggallery;

import ch.aplu.android.*;

public class Figure extends Actor
{
  public Figure()
  {
    super("figure_green");
  }

  public void act()
  {
    if (isMoveValid())
      move((int)(10 * gameGrid.getZoomFactor()));
    else
      turn(180);

  }
}

It is up to your programming skills and your fantacy to include more challenge and thrill.

shootinggalery

Download ShootingGallery app for installation on a smartphone

Create QR code to download Android app to your smartphone.

Download sources (ShootingGallery.zip).

There are several alternatives to determine the object you want to fling. You may use Actor.contains():

public boolean flingEvent(Point start, Point end, GGVector velocity)
{
  Location endLocation = toLocationInGrid(end);
  if (endLocation.y < height / 2)
    return true;
  Location startLocation = toLocationInGrid(start);
  Point startPos = new Point(startLocation.x, startLocation.y);
  for (int i = 0; i < nbBalls; i++)
  {
    Ball ball = balls[i];
    if (ball.contains(startPos))
    {
      ball.launch(endLocation, velocity);
      balls[i] = null; // tag as removed
      break;
    }
  }
  return true;
}

or GGCircle.isIntersecting():

public boolean flingEvent(Point start, Point end, GGVector velocity)
{
  Location endLocation = toLocationInGrid(end);
  if (endLocation.y < height / 2)
    return true;
  Location startLocation = toLocationInGrid(start);
  Point startPos = new Point(startLocation.x, startLocation.y);
  int d = width / nbBalls;
  for (int i = 0; i < nbBalls; i++)
  {
    Ball ball = balls[i];
    GGCircle circle =
      new GGCircle(new GGVector(ball.getX(), ball.getY()), d / 2);
    if (circle.isIntersecting(new GGVector(startPos)))
    {
      ball.launch(endLocation, velocity);
      balls[i] = null; // tag as removed
      break;
    }
  }
  return true;
}

or GGRectangle.isIntersecting():

public boolean flingEvent(Point start, Point end, GGVector velocity)
{
  Location endLocation = toLocationInGrid(end);
  if (endLocation.y < height / 2)
    return true;
  Location startLocation = toLocationInGrid(start);
  Point startPos = new Point(startLocation.x, startLocation.y);
  int d = width / nbBalls;
  for (int i = 0; i < nbBalls; i++)
  {
    Ball ball = balls[i];
    GGRectangle rectangle =
      new GGRectangle(new GGVector(ball.getX(), ball.getY()), 0, d, d);
    if (rectangle.isIntersecting(new GGVector(startPos), false))
    {
      ball.launch(endLocation, velocity);
      balls[i] = null; // tag as removed
      break;
    }
  }
  return true;
}

Android Gesture Detection The Fling Gesture

A prototype of a shooting game with fling

Android Gesture Detection
The Fling Gesture