Assignment 5

Due: Tuesday June 2, 2015, end of day.

In this assignment, you will program a very simple game, called The Drain.

Make a drawing on the screen (via a View, obviously) as in the drawing below. Some small variation / improvement on the drawing is possible; just keep the general idea.

This represents a drain with a drain-hole (below, gray); two dirty objects left inattentively in the sink by your house-mates, and a bright red cherry tomato. The goal of the game is to send the cherry tomato down the drain. Once the cherry tomato falls down the drain, a new cherry tomato materializes at the top of the screen (and the monster living in the sink piping emits a burping noise -- this is optional though). Note: my daughter actually suggests that the monster makes a disgusted noise and spits the tomato back up in the game to its original position, but this again is optional.

The motion of the tomato is governed by the following rules. Let vx, vy be the velocity of the tomato in the x and y directions.

• A friction force with components fx = - alpha * vx, fy = - alpha * vy , for some alpha of your choice.
• A gravitational acceleration force with components gx = beta * ix, gy = beta * iy, where ix, iy are the readings of the inclination sensor (more on this below). Basically, if you tilt the phone, the tomato is going to accelerate down as if it was a real tomato rolling off the screen.
• When the tomato hits a horizontal wall or partition, it bounces with elasticity gamma, meaning that vy = - gamma * vy, for some gamma < 1 (take gamma = 0.7 for instance). Similarly, vx = - gamma * vx when the tomato hits a vertical wall. You can detect when a tomato hits a wall because the distance from the wall is less than its radius.
• When the tomato is entirely within the drainhole, it falls down and disappears. The tomato is entirely in the drainhole when the distance between the centers of the tomato and the drainhole is smaller than the difference between their radiuses. Obviously the drainhole is bigger than the tomato.

Note: to detect whether the tomato hits one of the partitions, it helps to consider the partition as a partition line from (0, py) to (px, py), and of the point (px, py). Then, to check whether a tomato of center (x, y) and radius r is hitting the partition, you can do:

• If 0 <= x <= px and abs(y - py) < r, then you are hitting the "flat" part of the partition.
• If px < x and dist((px, py), (x, y)) < r, then you are hitting its endpoint.

If you are hitting the flat partition, simply bounce along the horizontal axis of the partition. If you are hitting the endpoint... just model what would happen to an infinitely elastic and rigid sphere that has no friction.

You don't need to worry about modeling the angular rotation of the tomato, in particular, and the friction effects on the walls. Although it would definitely be fun if you did.

To do this assignment, study carefully how they do in the tutorial to do the animation (as described in class as well): basically:

• You have a tomato object that can update its own position if you give it a delta-time. In theory, you would have to check whether the tomato hits an object at any point of its trajectory, and similarly for falling in the drainhole. In practice, use sufficient friction (to limit the speed) and a sufficiently short update time (20ms?) so that you can just check for collisions and fall-ins at the end of each position update, and not have the tomato go through walls. Remember to put some hard limits so the tomato does not leave the screen. When the tomato falls in, create a new one at the top.
• You post every 20ms or so a runnable. The runnable asks the tomato to update its position, then draws the new screen with the tomato in the new position, and re-posts itself, forever.

You need to read the inclination sensors. You can do it by simply reading the accelerometer, which gives you the direction of the gravity acceleration (plus any additional shaking you do). Here is sample code. Please check I got the signs right for the acceleration (it will be pretty obvious in practice). This code updates activity variables accelx and accely. In the tomato object, you can just look at the value of these variables, and update the state accordingly. The point is that you cannot get the acceleration from the sensors when you need it. You need to register a listener (as done below), that will give you the acceleration when it has it, and stores the values. Then the tomato reads the acceleration when it needs.

Note that you need to add the permission in the AndroidManifest.xml in order to use the sensors.

        ((SensorManager) getSystemService(Context.SENSOR_SERVICE)).registerListener(

                new SensorEventListener() {

                    @Override

                    public void onSensorChanged(SensorEvent event) {

                        // I hope I got the signs right.  If not, experiment with this.

                        accelx = -event.values[0];

                        accely = event.values[1];

                    }

                    @Override

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

                },

                ((SensorManager)getSystemService(Context.SENSOR_SERVICE))

                        .getSensorList(Sensor.TYPE_ACCELEROMETER).get(0) SensorManager.SENSOR_DELAY_GAME);