b69d09ecd9
When exiting the LunarLander sample, it was possible for the canvas to get destroyed before execution was halted. Added additional synchronization to make sure the current run-state is accounted for before performing a canvas update. Also updated deprecated constants in lunar_layout.xml. Bug: 6164549 Change-Id: I9a710f6b128491f1beece84dd39ab00f4937a4c6
896 lines
33 KiB
Java
896 lines
33 KiB
Java
/*
|
|
* Copyright (C) 2007 The Android Open Source Project
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
package com.example.android.lunarlander;
|
|
|
|
import android.content.Context;
|
|
import android.content.res.Resources;
|
|
import android.graphics.Bitmap;
|
|
import android.graphics.BitmapFactory;
|
|
import android.graphics.Canvas;
|
|
import android.graphics.Paint;
|
|
import android.graphics.RectF;
|
|
import android.graphics.drawable.Drawable;
|
|
import android.os.Bundle;
|
|
import android.os.Handler;
|
|
import android.os.Message;
|
|
import android.util.AttributeSet;
|
|
import android.view.KeyEvent;
|
|
import android.view.SurfaceHolder;
|
|
import android.view.SurfaceView;
|
|
import android.view.View;
|
|
import android.widget.TextView;
|
|
|
|
|
|
/**
|
|
* View that draws, takes keystrokes, etc. for a simple LunarLander game.
|
|
*
|
|
* Has a mode which RUNNING, PAUSED, etc. Has a x, y, dx, dy, ... capturing the
|
|
* current ship physics. All x/y etc. are measured with (0,0) at the lower left.
|
|
* updatePhysics() advances the physics based on realtime. draw() renders the
|
|
* ship, and does an invalidate() to prompt another draw() as soon as possible
|
|
* by the system.
|
|
*/
|
|
class LunarView extends SurfaceView implements SurfaceHolder.Callback {
|
|
class LunarThread extends Thread {
|
|
/*
|
|
* Difficulty setting constants
|
|
*/
|
|
public static final int DIFFICULTY_EASY = 0;
|
|
public static final int DIFFICULTY_HARD = 1;
|
|
public static final int DIFFICULTY_MEDIUM = 2;
|
|
/*
|
|
* Physics constants
|
|
*/
|
|
public static final int PHYS_DOWN_ACCEL_SEC = 35;
|
|
public static final int PHYS_FIRE_ACCEL_SEC = 80;
|
|
public static final int PHYS_FUEL_INIT = 60;
|
|
public static final int PHYS_FUEL_MAX = 100;
|
|
public static final int PHYS_FUEL_SEC = 10;
|
|
public static final int PHYS_SLEW_SEC = 120; // degrees/second rotate
|
|
public static final int PHYS_SPEED_HYPERSPACE = 180;
|
|
public static final int PHYS_SPEED_INIT = 30;
|
|
public static final int PHYS_SPEED_MAX = 120;
|
|
/*
|
|
* State-tracking constants
|
|
*/
|
|
public static final int STATE_LOSE = 1;
|
|
public static final int STATE_PAUSE = 2;
|
|
public static final int STATE_READY = 3;
|
|
public static final int STATE_RUNNING = 4;
|
|
public static final int STATE_WIN = 5;
|
|
|
|
/*
|
|
* Goal condition constants
|
|
*/
|
|
public static final int TARGET_ANGLE = 18; // > this angle means crash
|
|
public static final int TARGET_BOTTOM_PADDING = 17; // px below gear
|
|
public static final int TARGET_PAD_HEIGHT = 8; // how high above ground
|
|
public static final int TARGET_SPEED = 28; // > this speed means crash
|
|
public static final double TARGET_WIDTH = 1.6; // width of target
|
|
/*
|
|
* UI constants (i.e. the speed & fuel bars)
|
|
*/
|
|
public static final int UI_BAR = 100; // width of the bar(s)
|
|
public static final int UI_BAR_HEIGHT = 10; // height of the bar(s)
|
|
private static final String KEY_DIFFICULTY = "mDifficulty";
|
|
private static final String KEY_DX = "mDX";
|
|
|
|
private static final String KEY_DY = "mDY";
|
|
private static final String KEY_FUEL = "mFuel";
|
|
private static final String KEY_GOAL_ANGLE = "mGoalAngle";
|
|
private static final String KEY_GOAL_SPEED = "mGoalSpeed";
|
|
private static final String KEY_GOAL_WIDTH = "mGoalWidth";
|
|
|
|
private static final String KEY_GOAL_X = "mGoalX";
|
|
private static final String KEY_HEADING = "mHeading";
|
|
private static final String KEY_LANDER_HEIGHT = "mLanderHeight";
|
|
private static final String KEY_LANDER_WIDTH = "mLanderWidth";
|
|
private static final String KEY_WINS = "mWinsInARow";
|
|
|
|
private static final String KEY_X = "mX";
|
|
private static final String KEY_Y = "mY";
|
|
|
|
/*
|
|
* Member (state) fields
|
|
*/
|
|
/** The drawable to use as the background of the animation canvas */
|
|
private Bitmap mBackgroundImage;
|
|
|
|
/**
|
|
* Current height of the surface/canvas.
|
|
*
|
|
* @see #setSurfaceSize
|
|
*/
|
|
private int mCanvasHeight = 1;
|
|
|
|
/**
|
|
* Current width of the surface/canvas.
|
|
*
|
|
* @see #setSurfaceSize
|
|
*/
|
|
private int mCanvasWidth = 1;
|
|
|
|
/** What to draw for the Lander when it has crashed */
|
|
private Drawable mCrashedImage;
|
|
|
|
/**
|
|
* Current difficulty -- amount of fuel, allowed angle, etc. Default is
|
|
* MEDIUM.
|
|
*/
|
|
private int mDifficulty;
|
|
|
|
/** Velocity dx. */
|
|
private double mDX;
|
|
|
|
/** Velocity dy. */
|
|
private double mDY;
|
|
|
|
/** Is the engine burning? */
|
|
private boolean mEngineFiring;
|
|
|
|
/** What to draw for the Lander when the engine is firing */
|
|
private Drawable mFiringImage;
|
|
|
|
/** Fuel remaining */
|
|
private double mFuel;
|
|
|
|
/** Allowed angle. */
|
|
private int mGoalAngle;
|
|
|
|
/** Allowed speed. */
|
|
private int mGoalSpeed;
|
|
|
|
/** Width of the landing pad. */
|
|
private int mGoalWidth;
|
|
|
|
/** X of the landing pad. */
|
|
private int mGoalX;
|
|
|
|
/** Message handler used by thread to interact with TextView */
|
|
private Handler mHandler;
|
|
|
|
/**
|
|
* Lander heading in degrees, with 0 up, 90 right. Kept in the range
|
|
* 0..360.
|
|
*/
|
|
private double mHeading;
|
|
|
|
/** Pixel height of lander image. */
|
|
private int mLanderHeight;
|
|
|
|
/** What to draw for the Lander in its normal state */
|
|
private Drawable mLanderImage;
|
|
|
|
/** Pixel width of lander image. */
|
|
private int mLanderWidth;
|
|
|
|
/** Used to figure out elapsed time between frames */
|
|
private long mLastTime;
|
|
|
|
/** Paint to draw the lines on screen. */
|
|
private Paint mLinePaint;
|
|
|
|
/** "Bad" speed-too-high variant of the line color. */
|
|
private Paint mLinePaintBad;
|
|
|
|
/** The state of the game. One of READY, RUNNING, PAUSE, LOSE, or WIN */
|
|
private int mMode;
|
|
|
|
/** Currently rotating, -1 left, 0 none, 1 right. */
|
|
private int mRotating;
|
|
|
|
/** Indicate whether the surface has been created & is ready to draw */
|
|
private boolean mRun = false;
|
|
|
|
private final Object mRunLock = new Object();
|
|
|
|
/** Scratch rect object. */
|
|
private RectF mScratchRect;
|
|
|
|
/** Handle to the surface manager object we interact with */
|
|
private SurfaceHolder mSurfaceHolder;
|
|
|
|
/** Number of wins in a row. */
|
|
private int mWinsInARow;
|
|
|
|
/** X of lander center. */
|
|
private double mX;
|
|
|
|
/** Y of lander center. */
|
|
private double mY;
|
|
|
|
public LunarThread(SurfaceHolder surfaceHolder, Context context,
|
|
Handler handler) {
|
|
// get handles to some important objects
|
|
mSurfaceHolder = surfaceHolder;
|
|
mHandler = handler;
|
|
mContext = context;
|
|
|
|
Resources res = context.getResources();
|
|
// cache handles to our key sprites & other drawables
|
|
mLanderImage = context.getResources().getDrawable(
|
|
R.drawable.lander_plain);
|
|
mFiringImage = context.getResources().getDrawable(
|
|
R.drawable.lander_firing);
|
|
mCrashedImage = context.getResources().getDrawable(
|
|
R.drawable.lander_crashed);
|
|
|
|
// load background image as a Bitmap instead of a Drawable b/c
|
|
// we don't need to transform it and it's faster to draw this way
|
|
mBackgroundImage = BitmapFactory.decodeResource(res,
|
|
R.drawable.earthrise);
|
|
|
|
// Use the regular lander image as the model size for all sprites
|
|
mLanderWidth = mLanderImage.getIntrinsicWidth();
|
|
mLanderHeight = mLanderImage.getIntrinsicHeight();
|
|
|
|
// Initialize paints for speedometer
|
|
mLinePaint = new Paint();
|
|
mLinePaint.setAntiAlias(true);
|
|
mLinePaint.setARGB(255, 0, 255, 0);
|
|
|
|
mLinePaintBad = new Paint();
|
|
mLinePaintBad.setAntiAlias(true);
|
|
mLinePaintBad.setARGB(255, 120, 180, 0);
|
|
|
|
mScratchRect = new RectF(0, 0, 0, 0);
|
|
|
|
mWinsInARow = 0;
|
|
mDifficulty = DIFFICULTY_MEDIUM;
|
|
|
|
// initial show-up of lander (not yet playing)
|
|
mX = mLanderWidth;
|
|
mY = mLanderHeight * 2;
|
|
mFuel = PHYS_FUEL_INIT;
|
|
mDX = 0;
|
|
mDY = 0;
|
|
mHeading = 0;
|
|
mEngineFiring = true;
|
|
}
|
|
|
|
/**
|
|
* Starts the game, setting parameters for the current difficulty.
|
|
*/
|
|
public void doStart() {
|
|
synchronized (mSurfaceHolder) {
|
|
// First set the game for Medium difficulty
|
|
mFuel = PHYS_FUEL_INIT;
|
|
mEngineFiring = false;
|
|
mGoalWidth = (int) (mLanderWidth * TARGET_WIDTH);
|
|
mGoalSpeed = TARGET_SPEED;
|
|
mGoalAngle = TARGET_ANGLE;
|
|
int speedInit = PHYS_SPEED_INIT;
|
|
|
|
// Adjust difficulty params for EASY/HARD
|
|
if (mDifficulty == DIFFICULTY_EASY) {
|
|
mFuel = mFuel * 3 / 2;
|
|
mGoalWidth = mGoalWidth * 4 / 3;
|
|
mGoalSpeed = mGoalSpeed * 3 / 2;
|
|
mGoalAngle = mGoalAngle * 4 / 3;
|
|
speedInit = speedInit * 3 / 4;
|
|
} else if (mDifficulty == DIFFICULTY_HARD) {
|
|
mFuel = mFuel * 7 / 8;
|
|
mGoalWidth = mGoalWidth * 3 / 4;
|
|
mGoalSpeed = mGoalSpeed * 7 / 8;
|
|
speedInit = speedInit * 4 / 3;
|
|
}
|
|
|
|
// pick a convenient initial location for the lander sprite
|
|
mX = mCanvasWidth / 2;
|
|
mY = mCanvasHeight - mLanderHeight / 2;
|
|
|
|
// start with a little random motion
|
|
mDY = Math.random() * -speedInit;
|
|
mDX = Math.random() * 2 * speedInit - speedInit;
|
|
mHeading = 0;
|
|
|
|
// Figure initial spot for landing, not too near center
|
|
while (true) {
|
|
mGoalX = (int) (Math.random() * (mCanvasWidth - mGoalWidth));
|
|
if (Math.abs(mGoalX - (mX - mLanderWidth / 2)) > mCanvasHeight / 6)
|
|
break;
|
|
}
|
|
|
|
mLastTime = System.currentTimeMillis() + 100;
|
|
setState(STATE_RUNNING);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Pauses the physics update & animation.
|
|
*/
|
|
public void pause() {
|
|
synchronized (mSurfaceHolder) {
|
|
if (mMode == STATE_RUNNING) setState(STATE_PAUSE);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Restores game state from the indicated Bundle. Typically called when
|
|
* the Activity is being restored after having been previously
|
|
* destroyed.
|
|
*
|
|
* @param savedState Bundle containing the game state
|
|
*/
|
|
public synchronized void restoreState(Bundle savedState) {
|
|
synchronized (mSurfaceHolder) {
|
|
setState(STATE_PAUSE);
|
|
mRotating = 0;
|
|
mEngineFiring = false;
|
|
|
|
mDifficulty = savedState.getInt(KEY_DIFFICULTY);
|
|
mX = savedState.getDouble(KEY_X);
|
|
mY = savedState.getDouble(KEY_Y);
|
|
mDX = savedState.getDouble(KEY_DX);
|
|
mDY = savedState.getDouble(KEY_DY);
|
|
mHeading = savedState.getDouble(KEY_HEADING);
|
|
|
|
mLanderWidth = savedState.getInt(KEY_LANDER_WIDTH);
|
|
mLanderHeight = savedState.getInt(KEY_LANDER_HEIGHT);
|
|
mGoalX = savedState.getInt(KEY_GOAL_X);
|
|
mGoalSpeed = savedState.getInt(KEY_GOAL_SPEED);
|
|
mGoalAngle = savedState.getInt(KEY_GOAL_ANGLE);
|
|
mGoalWidth = savedState.getInt(KEY_GOAL_WIDTH);
|
|
mWinsInARow = savedState.getInt(KEY_WINS);
|
|
mFuel = savedState.getDouble(KEY_FUEL);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void run() {
|
|
while (mRun) {
|
|
Canvas c = null;
|
|
try {
|
|
c = mSurfaceHolder.lockCanvas(null);
|
|
synchronized (mSurfaceHolder) {
|
|
if (mMode == STATE_RUNNING) updatePhysics();
|
|
// Critical section. Do not allow mRun to be set false until
|
|
// we are sure all canvas draw operations are complete.
|
|
//
|
|
// If mRun has been toggled false, inhibit canvas operations.
|
|
synchronized (mRunLock) {
|
|
if (mRun) doDraw(c);
|
|
}
|
|
}
|
|
} finally {
|
|
// do this in a finally so that if an exception is thrown
|
|
// during the above, we don't leave the Surface in an
|
|
// inconsistent state
|
|
if (c != null) {
|
|
mSurfaceHolder.unlockCanvasAndPost(c);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Dump game state to the provided Bundle. Typically called when the
|
|
* Activity is being suspended.
|
|
*
|
|
* @return Bundle with this view's state
|
|
*/
|
|
public Bundle saveState(Bundle map) {
|
|
synchronized (mSurfaceHolder) {
|
|
if (map != null) {
|
|
map.putInt(KEY_DIFFICULTY, Integer.valueOf(mDifficulty));
|
|
map.putDouble(KEY_X, Double.valueOf(mX));
|
|
map.putDouble(KEY_Y, Double.valueOf(mY));
|
|
map.putDouble(KEY_DX, Double.valueOf(mDX));
|
|
map.putDouble(KEY_DY, Double.valueOf(mDY));
|
|
map.putDouble(KEY_HEADING, Double.valueOf(mHeading));
|
|
map.putInt(KEY_LANDER_WIDTH, Integer.valueOf(mLanderWidth));
|
|
map.putInt(KEY_LANDER_HEIGHT, Integer
|
|
.valueOf(mLanderHeight));
|
|
map.putInt(KEY_GOAL_X, Integer.valueOf(mGoalX));
|
|
map.putInt(KEY_GOAL_SPEED, Integer.valueOf(mGoalSpeed));
|
|
map.putInt(KEY_GOAL_ANGLE, Integer.valueOf(mGoalAngle));
|
|
map.putInt(KEY_GOAL_WIDTH, Integer.valueOf(mGoalWidth));
|
|
map.putInt(KEY_WINS, Integer.valueOf(mWinsInARow));
|
|
map.putDouble(KEY_FUEL, Double.valueOf(mFuel));
|
|
}
|
|
}
|
|
return map;
|
|
}
|
|
|
|
/**
|
|
* Sets the current difficulty.
|
|
*
|
|
* @param difficulty
|
|
*/
|
|
public void setDifficulty(int difficulty) {
|
|
synchronized (mSurfaceHolder) {
|
|
mDifficulty = difficulty;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Sets if the engine is currently firing.
|
|
*/
|
|
public void setFiring(boolean firing) {
|
|
synchronized (mSurfaceHolder) {
|
|
mEngineFiring = firing;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Used to signal the thread whether it should be running or not.
|
|
* Passing true allows the thread to run; passing false will shut it
|
|
* down if it's already running. Calling start() after this was most
|
|
* recently called with false will result in an immediate shutdown.
|
|
*
|
|
* @param b true to run, false to shut down
|
|
*/
|
|
public void setRunning(boolean b) {
|
|
// Do not allow mRun to be modified while any canvas operations
|
|
// are potentially in-flight. See doDraw().
|
|
synchronized (mRunLock) {
|
|
mRun = b;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Sets the game mode. That is, whether we are running, paused, in the
|
|
* failure state, in the victory state, etc.
|
|
*
|
|
* @see #setState(int, CharSequence)
|
|
* @param mode one of the STATE_* constants
|
|
*/
|
|
public void setState(int mode) {
|
|
synchronized (mSurfaceHolder) {
|
|
setState(mode, null);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Sets the game mode. That is, whether we are running, paused, in the
|
|
* failure state, in the victory state, etc.
|
|
*
|
|
* @param mode one of the STATE_* constants
|
|
* @param message string to add to screen or null
|
|
*/
|
|
public void setState(int mode, CharSequence message) {
|
|
/*
|
|
* This method optionally can cause a text message to be displayed
|
|
* to the user when the mode changes. Since the View that actually
|
|
* renders that text is part of the main View hierarchy and not
|
|
* owned by this thread, we can't touch the state of that View.
|
|
* Instead we use a Message + Handler to relay commands to the main
|
|
* thread, which updates the user-text View.
|
|
*/
|
|
synchronized (mSurfaceHolder) {
|
|
mMode = mode;
|
|
|
|
if (mMode == STATE_RUNNING) {
|
|
Message msg = mHandler.obtainMessage();
|
|
Bundle b = new Bundle();
|
|
b.putString("text", "");
|
|
b.putInt("viz", View.INVISIBLE);
|
|
msg.setData(b);
|
|
mHandler.sendMessage(msg);
|
|
} else {
|
|
mRotating = 0;
|
|
mEngineFiring = false;
|
|
Resources res = mContext.getResources();
|
|
CharSequence str = "";
|
|
if (mMode == STATE_READY)
|
|
str = res.getText(R.string.mode_ready);
|
|
else if (mMode == STATE_PAUSE)
|
|
str = res.getText(R.string.mode_pause);
|
|
else if (mMode == STATE_LOSE)
|
|
str = res.getText(R.string.mode_lose);
|
|
else if (mMode == STATE_WIN)
|
|
str = res.getString(R.string.mode_win_prefix)
|
|
+ mWinsInARow + " "
|
|
+ res.getString(R.string.mode_win_suffix);
|
|
|
|
if (message != null) {
|
|
str = message + "\n" + str;
|
|
}
|
|
|
|
if (mMode == STATE_LOSE) mWinsInARow = 0;
|
|
|
|
Message msg = mHandler.obtainMessage();
|
|
Bundle b = new Bundle();
|
|
b.putString("text", str.toString());
|
|
b.putInt("viz", View.VISIBLE);
|
|
msg.setData(b);
|
|
mHandler.sendMessage(msg);
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Callback invoked when the surface dimensions change. */
|
|
public void setSurfaceSize(int width, int height) {
|
|
// synchronized to make sure these all change atomically
|
|
synchronized (mSurfaceHolder) {
|
|
mCanvasWidth = width;
|
|
mCanvasHeight = height;
|
|
|
|
// don't forget to resize the background image
|
|
mBackgroundImage = Bitmap.createScaledBitmap(
|
|
mBackgroundImage, width, height, true);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Resumes from a pause.
|
|
*/
|
|
public void unpause() {
|
|
// Move the real time clock up to now
|
|
synchronized (mSurfaceHolder) {
|
|
mLastTime = System.currentTimeMillis() + 100;
|
|
}
|
|
setState(STATE_RUNNING);
|
|
}
|
|
|
|
/**
|
|
* Handles a key-down event.
|
|
*
|
|
* @param keyCode the key that was pressed
|
|
* @param msg the original event object
|
|
* @return true
|
|
*/
|
|
boolean doKeyDown(int keyCode, KeyEvent msg) {
|
|
synchronized (mSurfaceHolder) {
|
|
boolean okStart = false;
|
|
if (keyCode == KeyEvent.KEYCODE_DPAD_UP) okStart = true;
|
|
if (keyCode == KeyEvent.KEYCODE_DPAD_DOWN) okStart = true;
|
|
if (keyCode == KeyEvent.KEYCODE_S) okStart = true;
|
|
|
|
if (okStart
|
|
&& (mMode == STATE_READY || mMode == STATE_LOSE || mMode == STATE_WIN)) {
|
|
// ready-to-start -> start
|
|
doStart();
|
|
return true;
|
|
} else if (mMode == STATE_PAUSE && okStart) {
|
|
// paused -> running
|
|
unpause();
|
|
return true;
|
|
} else if (mMode == STATE_RUNNING) {
|
|
// center/space -> fire
|
|
if (keyCode == KeyEvent.KEYCODE_DPAD_CENTER
|
|
|| keyCode == KeyEvent.KEYCODE_SPACE) {
|
|
setFiring(true);
|
|
return true;
|
|
// left/q -> left
|
|
} else if (keyCode == KeyEvent.KEYCODE_DPAD_LEFT
|
|
|| keyCode == KeyEvent.KEYCODE_Q) {
|
|
mRotating = -1;
|
|
return true;
|
|
// right/w -> right
|
|
} else if (keyCode == KeyEvent.KEYCODE_DPAD_RIGHT
|
|
|| keyCode == KeyEvent.KEYCODE_W) {
|
|
mRotating = 1;
|
|
return true;
|
|
// up -> pause
|
|
} else if (keyCode == KeyEvent.KEYCODE_DPAD_UP) {
|
|
pause();
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Handles a key-up event.
|
|
*
|
|
* @param keyCode the key that was pressed
|
|
* @param msg the original event object
|
|
* @return true if the key was handled and consumed, or else false
|
|
*/
|
|
boolean doKeyUp(int keyCode, KeyEvent msg) {
|
|
boolean handled = false;
|
|
|
|
synchronized (mSurfaceHolder) {
|
|
if (mMode == STATE_RUNNING) {
|
|
if (keyCode == KeyEvent.KEYCODE_DPAD_CENTER
|
|
|| keyCode == KeyEvent.KEYCODE_SPACE) {
|
|
setFiring(false);
|
|
handled = true;
|
|
} else if (keyCode == KeyEvent.KEYCODE_DPAD_LEFT
|
|
|| keyCode == KeyEvent.KEYCODE_Q
|
|
|| keyCode == KeyEvent.KEYCODE_DPAD_RIGHT
|
|
|| keyCode == KeyEvent.KEYCODE_W) {
|
|
mRotating = 0;
|
|
handled = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
return handled;
|
|
}
|
|
|
|
/**
|
|
* Draws the ship, fuel/speed bars, and background to the provided
|
|
* Canvas.
|
|
*/
|
|
private void doDraw(Canvas canvas) {
|
|
// Draw the background image. Operations on the Canvas accumulate
|
|
// so this is like clearing the screen.
|
|
canvas.drawBitmap(mBackgroundImage, 0, 0, null);
|
|
|
|
int yTop = mCanvasHeight - ((int) mY + mLanderHeight / 2);
|
|
int xLeft = (int) mX - mLanderWidth / 2;
|
|
|
|
// Draw the fuel gauge
|
|
int fuelWidth = (int) (UI_BAR * mFuel / PHYS_FUEL_MAX);
|
|
mScratchRect.set(4, 4, 4 + fuelWidth, 4 + UI_BAR_HEIGHT);
|
|
canvas.drawRect(mScratchRect, mLinePaint);
|
|
|
|
// Draw the speed gauge, with a two-tone effect
|
|
double speed = Math.sqrt(mDX * mDX + mDY * mDY);
|
|
int speedWidth = (int) (UI_BAR * speed / PHYS_SPEED_MAX);
|
|
|
|
if (speed <= mGoalSpeed) {
|
|
mScratchRect.set(4 + UI_BAR + 4, 4,
|
|
4 + UI_BAR + 4 + speedWidth, 4 + UI_BAR_HEIGHT);
|
|
canvas.drawRect(mScratchRect, mLinePaint);
|
|
} else {
|
|
// Draw the bad color in back, with the good color in front of
|
|
// it
|
|
mScratchRect.set(4 + UI_BAR + 4, 4,
|
|
4 + UI_BAR + 4 + speedWidth, 4 + UI_BAR_HEIGHT);
|
|
canvas.drawRect(mScratchRect, mLinePaintBad);
|
|
int goalWidth = (UI_BAR * mGoalSpeed / PHYS_SPEED_MAX);
|
|
mScratchRect.set(4 + UI_BAR + 4, 4, 4 + UI_BAR + 4 + goalWidth,
|
|
4 + UI_BAR_HEIGHT);
|
|
canvas.drawRect(mScratchRect, mLinePaint);
|
|
}
|
|
|
|
// Draw the landing pad
|
|
canvas.drawLine(mGoalX, 1 + mCanvasHeight - TARGET_PAD_HEIGHT,
|
|
mGoalX + mGoalWidth, 1 + mCanvasHeight - TARGET_PAD_HEIGHT,
|
|
mLinePaint);
|
|
|
|
|
|
// Draw the ship with its current rotation
|
|
canvas.save();
|
|
canvas.rotate((float) mHeading, (float) mX, mCanvasHeight
|
|
- (float) mY);
|
|
if (mMode == STATE_LOSE) {
|
|
mCrashedImage.setBounds(xLeft, yTop, xLeft + mLanderWidth, yTop
|
|
+ mLanderHeight);
|
|
mCrashedImage.draw(canvas);
|
|
} else if (mEngineFiring) {
|
|
mFiringImage.setBounds(xLeft, yTop, xLeft + mLanderWidth, yTop
|
|
+ mLanderHeight);
|
|
mFiringImage.draw(canvas);
|
|
} else {
|
|
mLanderImage.setBounds(xLeft, yTop, xLeft + mLanderWidth, yTop
|
|
+ mLanderHeight);
|
|
mLanderImage.draw(canvas);
|
|
}
|
|
canvas.restore();
|
|
}
|
|
|
|
/**
|
|
* Figures the lander state (x, y, fuel, ...) based on the passage of
|
|
* realtime. Does not invalidate(). Called at the start of draw().
|
|
* Detects the end-of-game and sets the UI to the next state.
|
|
*/
|
|
private void updatePhysics() {
|
|
long now = System.currentTimeMillis();
|
|
|
|
// Do nothing if mLastTime is in the future.
|
|
// This allows the game-start to delay the start of the physics
|
|
// by 100ms or whatever.
|
|
if (mLastTime > now) return;
|
|
|
|
double elapsed = (now - mLastTime) / 1000.0;
|
|
|
|
// mRotating -- update heading
|
|
if (mRotating != 0) {
|
|
mHeading += mRotating * (PHYS_SLEW_SEC * elapsed);
|
|
|
|
// Bring things back into the range 0..360
|
|
if (mHeading < 0)
|
|
mHeading += 360;
|
|
else if (mHeading >= 360) mHeading -= 360;
|
|
}
|
|
|
|
// Base accelerations -- 0 for x, gravity for y
|
|
double ddx = 0.0;
|
|
double ddy = -PHYS_DOWN_ACCEL_SEC * elapsed;
|
|
|
|
if (mEngineFiring) {
|
|
// taking 0 as up, 90 as to the right
|
|
// cos(deg) is ddy component, sin(deg) is ddx component
|
|
double elapsedFiring = elapsed;
|
|
double fuelUsed = elapsedFiring * PHYS_FUEL_SEC;
|
|
|
|
// tricky case where we run out of fuel partway through the
|
|
// elapsed
|
|
if (fuelUsed > mFuel) {
|
|
elapsedFiring = mFuel / fuelUsed * elapsed;
|
|
fuelUsed = mFuel;
|
|
|
|
// Oddball case where we adjust the "control" from here
|
|
mEngineFiring = false;
|
|
}
|
|
|
|
mFuel -= fuelUsed;
|
|
|
|
// have this much acceleration from the engine
|
|
double accel = PHYS_FIRE_ACCEL_SEC * elapsedFiring;
|
|
|
|
double radians = 2 * Math.PI * mHeading / 360;
|
|
ddx = Math.sin(radians) * accel;
|
|
ddy += Math.cos(radians) * accel;
|
|
}
|
|
|
|
double dxOld = mDX;
|
|
double dyOld = mDY;
|
|
|
|
// figure speeds for the end of the period
|
|
mDX += ddx;
|
|
mDY += ddy;
|
|
|
|
// figure position based on average speed during the period
|
|
mX += elapsed * (mDX + dxOld) / 2;
|
|
mY += elapsed * (mDY + dyOld) / 2;
|
|
|
|
mLastTime = now;
|
|
|
|
// Evaluate if we have landed ... stop the game
|
|
double yLowerBound = TARGET_PAD_HEIGHT + mLanderHeight / 2
|
|
- TARGET_BOTTOM_PADDING;
|
|
if (mY <= yLowerBound) {
|
|
mY = yLowerBound;
|
|
|
|
int result = STATE_LOSE;
|
|
CharSequence message = "";
|
|
Resources res = mContext.getResources();
|
|
double speed = Math.sqrt(mDX * mDX + mDY * mDY);
|
|
boolean onGoal = (mGoalX <= mX - mLanderWidth / 2 && mX
|
|
+ mLanderWidth / 2 <= mGoalX + mGoalWidth);
|
|
|
|
// "Hyperspace" win -- upside down, going fast,
|
|
// puts you back at the top.
|
|
if (onGoal && Math.abs(mHeading - 180) < mGoalAngle
|
|
&& speed > PHYS_SPEED_HYPERSPACE) {
|
|
result = STATE_WIN;
|
|
mWinsInARow++;
|
|
doStart();
|
|
|
|
return;
|
|
// Oddball case: this case does a return, all other cases
|
|
// fall through to setMode() below.
|
|
} else if (!onGoal) {
|
|
message = res.getText(R.string.message_off_pad);
|
|
} else if (!(mHeading <= mGoalAngle || mHeading >= 360 - mGoalAngle)) {
|
|
message = res.getText(R.string.message_bad_angle);
|
|
} else if (speed > mGoalSpeed) {
|
|
message = res.getText(R.string.message_too_fast);
|
|
} else {
|
|
result = STATE_WIN;
|
|
mWinsInARow++;
|
|
}
|
|
|
|
setState(result, message);
|
|
}
|
|
}
|
|
}
|
|
|
|
/** Handle to the application context, used to e.g. fetch Drawables. */
|
|
private Context mContext;
|
|
|
|
/** Pointer to the text view to display "Paused.." etc. */
|
|
private TextView mStatusText;
|
|
|
|
/** The thread that actually draws the animation */
|
|
private LunarThread thread;
|
|
|
|
public LunarView(Context context, AttributeSet attrs) {
|
|
super(context, attrs);
|
|
|
|
// register our interest in hearing about changes to our surface
|
|
SurfaceHolder holder = getHolder();
|
|
holder.addCallback(this);
|
|
|
|
// create thread only; it's started in surfaceCreated()
|
|
thread = new LunarThread(holder, context, new Handler() {
|
|
@Override
|
|
public void handleMessage(Message m) {
|
|
mStatusText.setVisibility(m.getData().getInt("viz"));
|
|
mStatusText.setText(m.getData().getString("text"));
|
|
}
|
|
});
|
|
|
|
setFocusable(true); // make sure we get key events
|
|
}
|
|
|
|
/**
|
|
* Fetches the animation thread corresponding to this LunarView.
|
|
*
|
|
* @return the animation thread
|
|
*/
|
|
public LunarThread getThread() {
|
|
return thread;
|
|
}
|
|
|
|
/**
|
|
* Standard override to get key-press events.
|
|
*/
|
|
@Override
|
|
public boolean onKeyDown(int keyCode, KeyEvent msg) {
|
|
return thread.doKeyDown(keyCode, msg);
|
|
}
|
|
|
|
/**
|
|
* Standard override for key-up. We actually care about these, so we can
|
|
* turn off the engine or stop rotating.
|
|
*/
|
|
@Override
|
|
public boolean onKeyUp(int keyCode, KeyEvent msg) {
|
|
return thread.doKeyUp(keyCode, msg);
|
|
}
|
|
|
|
/**
|
|
* Standard window-focus override. Notice focus lost so we can pause on
|
|
* focus lost. e.g. user switches to take a call.
|
|
*/
|
|
@Override
|
|
public void onWindowFocusChanged(boolean hasWindowFocus) {
|
|
if (!hasWindowFocus) thread.pause();
|
|
}
|
|
|
|
/**
|
|
* Installs a pointer to the text view used for messages.
|
|
*/
|
|
public void setTextView(TextView textView) {
|
|
mStatusText = textView;
|
|
}
|
|
|
|
/* Callback invoked when the surface dimensions change. */
|
|
public void surfaceChanged(SurfaceHolder holder, int format, int width,
|
|
int height) {
|
|
thread.setSurfaceSize(width, height);
|
|
}
|
|
|
|
/*
|
|
* Callback invoked when the Surface has been created and is ready to be
|
|
* used.
|
|
*/
|
|
public void surfaceCreated(SurfaceHolder holder) {
|
|
// start the thread here so that we don't busy-wait in run()
|
|
// waiting for the surface to be created
|
|
thread.setRunning(true);
|
|
thread.start();
|
|
}
|
|
|
|
/*
|
|
* Callback invoked when the Surface has been destroyed and must no longer
|
|
* be touched. WARNING: after this method returns, the Surface/Canvas must
|
|
* never be touched again!
|
|
*/
|
|
public void surfaceDestroyed(SurfaceHolder holder) {
|
|
// we have to tell thread to shut down & wait for it to finish, or else
|
|
// it might touch the Surface after we return and explode
|
|
boolean retry = true;
|
|
thread.setRunning(false);
|
|
while (retry) {
|
|
try {
|
|
thread.join();
|
|
retry = false;
|
|
} catch (InterruptedException e) {
|
|
}
|
|
}
|
|
}
|
|
}
|