|
|
Android example source code file (JetBoyView.java)
This example Android source code file (JetBoyView.java) is included in the DevDaily.com
"Java Source Code
Warehouse" project. The intent of this project is to help you "Learn
Android by Example" TM.
The JetBoyView.java Android example source code
/*
* Copyright (C) 2009 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.
*
*/
// Android JET demonstration code:
// All inline comments related to the use of the JetPlayer class are preceded by "JET info:"
package com.example.android.jetboy;
import android.content.Context;
import android.content.res.Resources;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.Canvas;
import android.media.JetPlayer;
import android.media.JetPlayer.OnJetEventListener;
import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.util.AttributeSet;
import android.util.Log;
import android.view.KeyEvent;
import android.view.SurfaceHolder;
import android.view.SurfaceView;
import android.view.View;
import android.widget.Button;
import android.widget.TextView;
import java.util.Random;
import java.util.Timer;
import java.util.TimerTask;
import java.util.Vector;
import java.util.concurrent.ConcurrentLinkedQueue;
public class JetBoyView extends SurfaceView implements SurfaceHolder.Callback {
// the number of asteroids that must be destroyed
public static final int mSuccessThreshold = 50;
// used to calculate level for mutes and trigger clip
public int mHitStreak = 0;
// total number asteroids you need to hit.
public int mHitTotal = 0;
// which music bed is currently playing?
public int mCurrentBed = 0;
// a lazy graphic fudge for the initial title splash
private Bitmap mTitleBG;
private Bitmap mTitleBG2;
/**
* Base class for any external event passed to the JetBoyThread. This can
* include user input, system events, network input, etc.
*/
class GameEvent {
public GameEvent() {
eventTime = System.currentTimeMillis();
}
long eventTime;
}
/**
* A GameEvent subclass for key based user input. Values are those used by
* the standard onKey
*/
class KeyGameEvent extends GameEvent {
/**
* Simple constructor to make populating this event easier.
*/
public KeyGameEvent(int keyCode, boolean up, KeyEvent msg) {
this.keyCode = keyCode;
this.msg = msg;
this.up = up;
}
public int keyCode;
public KeyEvent msg;
public boolean up;
}
/**
* A GameEvent subclass for events from the JetPlayer.
*/
class JetGameEvent extends GameEvent {
/**
* Simple constructor to make populating this event easier.
*/
public JetGameEvent(JetPlayer player, short segment, byte track, byte channel,
byte controller, byte value) {
this.player = player;
this.segment = segment;
this.track = track;
this.channel = channel;
this.controller = controller;
this.value = value;
}
public JetPlayer player;
public short segment;
public byte track;
public byte channel;
public byte controller;
public byte value;
}
// JET info: the JetBoyThread receives all the events from the JET player
// JET info: through the OnJetEventListener interface.
class JetBoyThread extends Thread implements OnJetEventListener {
/**
* State-tracking constants.
*/
public static final int STATE_START = -1;
public static final int STATE_PLAY = 0;
public static final int STATE_LOSE = 1;
public static final int STATE_PAUSE = 2;
public static final int STATE_RUNNING = 3;
// how many frames per beat? The basic animation can be changed for
// instance to 3/4 by changing this to 3.
// untested is the impact on other parts of game logic for non 4/4 time.
private static final int ANIMATION_FRAMES_PER_BEAT = 4;
public boolean mInitialized = false;
/** Queue for GameEvents */
protected ConcurrentLinkedQueue<GameEvent> mEventQueue = new ConcurrentLinkedQueue();
/** Context for processKey to maintain state accross frames * */
protected Object mKeyContext = null;
// the timer display in seconds
public int mTimerLimit;
// used for internal timing logic.
public final int TIMER_LIMIT = 72;
// string value for timer display
private String mTimerValue = "1:12";
// start, play, running, lose are the states we use
public int mState;
// has laser been fired and for how long?
// user for fx logic on laser fire
boolean mLaserOn = false;
long mLaserFireTime = 0;
/** The drawable to use as the far background of the animation canvas */
private Bitmap mBackgroundImageFar;
/** The drawable to use as the close background of the animation canvas */
private Bitmap mBackgroundImageNear;
// JET info: event IDs within the JET file.
// JET info: in this game 80 is used for sending asteroid across the screen
// JET info: 82 is used as game time for 1/4 note beat.
private final byte NEW_ASTEROID_EVENT = 80;
private final byte TIMER_EVENT = 82;
// used to track beat for synch of mute/unmute actions
private int mBeatCount = 1;
// our intrepid space boy
private Bitmap[] mShipFlying = new Bitmap[4];
// the twinkly bit
private Bitmap[] mBeam = new Bitmap[4];
// the things you are trying to hit
private Bitmap[] mAsteroids = new Bitmap[12];
// hit animation
private Bitmap[] mExplosions = new Bitmap[4];
private Bitmap mTimerShell;
private Bitmap mLaserShot;
// used to save the beat event system time.
private long mLastBeatTime;
private long mPassedTime;
// how much do we move the asteroids per beat?
private int mPixelMoveX = 25;
// the asteroid send events are generated from the Jet File.
// but which land they start in is random.
private Random mRandom = new Random();
// JET info: the star of our show, a reference to the JetPlayer object.
private JetPlayer mJet = null;
private boolean mJetPlaying = false;
/** Message handler used by thread to interact with TextView */
private Handler mHandler;
/** Handle to the surface manager object we interact with */
private SurfaceHolder mSurfaceHolder;
/** Handle to the application context, used to e.g. fetch Drawables. */
private Context mContext;
/** Indicate whether the surface has been created & is ready to draw */
private boolean mRun = false;
// updates the screen clock. Also used for tempo timing.
private Timer mTimer = null;
private TimerTask mTimerTask = null;
// one second - used to update timer
private int mTaskIntervalInMillis = 1000;
/**
* Current height of the surface/canvas.
*
* @see #setSurfaceSize
*/
private int mCanvasHeight = 1;
/**
* Current width of the surface/canvas.
*
* @see #setSurfaceSize
*/
private int mCanvasWidth = 1;
// used to track the picture to draw for ship animation
private int mShipIndex = 0;
// stores all of the asteroid objects in order
private Vector<Asteroid> mDangerWillRobinson;
private Vector<Explosion> mExplosion;
// right to left scroll tracker for near and far BG
private int mBGFarMoveX = 0;
private int mBGNearMoveX = 0;
// how far up (close to top) jet boy can fly
private int mJetBoyYMin = 40;
private int mJetBoyX = 0;
private int mJetBoyY = 0;
// this is the pixel position of the laser beam guide.
private int mAsteroidMoveLimitX = 110;
// how far up asteroid can be painted
private int mAsteroidMinY = 40;
Resources mRes;
// array to store the mute masks that are applied during game play to respond to
// the player's hit streaks
private boolean muteMask[][] = new boolean[9][32];
/**
* This is the constructor for the main worker bee
*
* @param surfaceHolder
* @param context
* @param handler
*/
public JetBoyThread(SurfaceHolder surfaceHolder, Context context, Handler handler) {
mSurfaceHolder = surfaceHolder;
mHandler = handler;
mContext = context;
mRes = context.getResources();
// JET info: this are the mute arrays associated with the music beds in the
// JET info: JET file
for (int ii = 0; ii < 8; ii++) {
for (int xx = 0; xx < 32; xx++) {
muteMask[ii][xx] = true;
}
}
muteMask[0][2] = false;
muteMask[0][3] = false;
muteMask[0][4] = false;
muteMask[0][5] = false;
muteMask[1][2] = false;
muteMask[1][3] = false;
muteMask[1][4] = false;
muteMask[1][5] = false;
muteMask[1][8] = false;
muteMask[1][9] = false;
muteMask[2][2] = false;
muteMask[2][3] = false;
muteMask[2][6] = false;
muteMask[2][7] = false;
muteMask[2][8] = false;
muteMask[2][9] = false;
muteMask[3][2] = false;
muteMask[3][3] = false;
muteMask[3][6] = false;
muteMask[3][11] = false;
muteMask[3][12] = false;
muteMask[4][2] = false;
muteMask[4][3] = false;
muteMask[4][10] = false;
muteMask[4][11] = false;
muteMask[4][12] = false;
muteMask[4][13] = false;
muteMask[5][2] = false;
muteMask[5][3] = false;
muteMask[5][10] = false;
muteMask[5][12] = false;
muteMask[5][15] = false;
muteMask[5][17] = false;
muteMask[6][2] = false;
muteMask[6][3] = false;
muteMask[6][14] = false;
muteMask[6][15] = false;
muteMask[6][16] = false;
muteMask[6][17] = false;
muteMask[7][2] = false;
muteMask[7][3] = false;
muteMask[7][6] = false;
muteMask[7][14] = false;
muteMask[7][15] = false;
muteMask[7][16] = false;
muteMask[7][17] = false;
muteMask[7][18] = false;
// set all tracks to play
for (int xx = 0; xx < 32; xx++) {
muteMask[8][xx] = false;
}
// always set state to start, ensure we come in from front door if
// app gets tucked into background
mState = STATE_START;
setInitialGameState();
mTitleBG = BitmapFactory.decodeResource(mRes, R.drawable.title_hori);
// 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...thanks lunar lander :)
// two background since we want them moving at different speeds
mBackgroundImageFar = BitmapFactory.decodeResource(mRes, R.drawable.background_a);
mLaserShot = BitmapFactory.decodeResource(mRes, R.drawable.laser);
mBackgroundImageNear = BitmapFactory.decodeResource(mRes, R.drawable.background_b);
mShipFlying[0] = BitmapFactory.decodeResource(mRes, R.drawable.ship2_1);
mShipFlying[1] = BitmapFactory.decodeResource(mRes, R.drawable.ship2_2);
mShipFlying[2] = BitmapFactory.decodeResource(mRes, R.drawable.ship2_3);
mShipFlying[3] = BitmapFactory.decodeResource(mRes, R.drawable.ship2_4);
mBeam[0] = BitmapFactory.decodeResource(mRes, R.drawable.intbeam_1);
mBeam[1] = BitmapFactory.decodeResource(mRes, R.drawable.intbeam_2);
mBeam[2] = BitmapFactory.decodeResource(mRes, R.drawable.intbeam_3);
mBeam[3] = BitmapFactory.decodeResource(mRes, R.drawable.intbeam_4);
mTimerShell = BitmapFactory.decodeResource(mRes, R.drawable.int_timer);
// I wanted them to rotate in a certain way
// so I loaded them backwards from the way created.
mAsteroids[11] = BitmapFactory.decodeResource(mRes, R.drawable.asteroid01);
mAsteroids[10] = BitmapFactory.decodeResource(mRes, R.drawable.asteroid02);
mAsteroids[9] = BitmapFactory.decodeResource(mRes, R.drawable.asteroid03);
mAsteroids[8] = BitmapFactory.decodeResource(mRes, R.drawable.asteroid04);
mAsteroids[7] = BitmapFactory.decodeResource(mRes, R.drawable.asteroid05);
mAsteroids[6] = BitmapFactory.decodeResource(mRes, R.drawable.asteroid06);
mAsteroids[5] = BitmapFactory.decodeResource(mRes, R.drawable.asteroid07);
mAsteroids[4] = BitmapFactory.decodeResource(mRes, R.drawable.asteroid08);
mAsteroids[3] = BitmapFactory.decodeResource(mRes, R.drawable.asteroid09);
mAsteroids[2] = BitmapFactory.decodeResource(mRes, R.drawable.asteroid10);
mAsteroids[1] = BitmapFactory.decodeResource(mRes, R.drawable.asteroid11);
mAsteroids[0] = BitmapFactory.decodeResource(mRes, R.drawable.asteroid12);
mExplosions[0] = BitmapFactory.decodeResource(mRes, R.drawable.asteroid_explode1);
mExplosions[1] = BitmapFactory.decodeResource(mRes, R.drawable.asteroid_explode2);
mExplosions[2] = BitmapFactory.decodeResource(mRes, R.drawable.asteroid_explode3);
mExplosions[3] = BitmapFactory.decodeResource(mRes, R.drawable.asteroid_explode4);
}
/**
* Does the grunt work of setting up initial jet requirements
*/
private void initializeJetPlayer() {
// JET info: let's create our JetPlayer instance using the factory.
// JET info: if we already had one, the same singleton is returned.
mJet = JetPlayer.getJetPlayer();
mJetPlaying = false;
// JET info: make sure we flush the queue,
// JET info: otherwise left over events from previous gameplay can hang around.
// JET info: ok, here we don't really need that but if you ever reuse a JetPlayer
// JET info: instance, clear the queue before reusing it, this will also clear any
// JET info: trigger clips that have been triggered but not played yet.
mJet.clearQueue();
// JET info: we are going to receive in this example all the JET callbacks
// JET info: inthis animation thread object.
mJet.setEventListener(this);
Log.d(TAG, "opening jet file");
// JET info: load the actual JET content the game will be playing,
// JET info: it's stored as a raw resource in our APK, and is labeled "level1"
mJet.loadJetFile(mContext.getResources().openRawResourceFd(R.raw.level1));
// JET info: if our JET file was stored on the sdcard for instance, we would have used
// JET info: mJet.loadJetFile("/sdcard/level1.jet");
Log.d(TAG, "opening jet file DONE");
mCurrentBed = 0;
byte sSegmentID = 0;
Log.d(TAG, " start queuing jet file");
// JET info: now we're all set to prepare queuing the JET audio segments for the game.
// JET info: in this example, the game uses segment 0 for the duration of the game play,
// JET info: and plays segment 1 several times as the "outro" music, so we're going to
// JET info: queue everything upfront, but with more complex JET compositions, we could
// JET info: also queue the segments during the game play.
// JET info: this is the main game play music
// JET info: it is located at segment 0
// JET info: it uses the first DLS lib in the .jet resource, which is at index 0
// JET info: index -1 means no DLS
mJet.queueJetSegment(0, 0, 0, 0, 0, sSegmentID);
// JET info: end game music, loop 4 times normal pitch
mJet.queueJetSegment(1, 0, 4, 0, 0, sSegmentID);
// JET info: end game music loop 4 times up an octave
mJet.queueJetSegment(1, 0, 4, 1, 0, sSegmentID);
// JET info: set the mute mask as designed for the beginning of the game, when the
// JET info: the player hasn't scored yet.
mJet.setMuteArray(muteMask[0], true);
Log.d(TAG, " start queuing jet file DONE");
}
private void doDraw(Canvas canvas) {
if (mState == STATE_RUNNING) {
doDrawRunning(canvas);
} else if (mState == STATE_START) {
doDrawReady(canvas);
} else if (mState == STATE_PLAY || mState == STATE_LOSE) {
if (mTitleBG2 == null) {
mTitleBG2 = BitmapFactory.decodeResource(mRes, R.drawable.title_bg_hori);
}
doDrawPlay(canvas);
}// end state play block
}
/**
* Draws current state of the game Canvas.
*/
private void doDrawRunning(Canvas canvas) {
// decrement the far background
mBGFarMoveX = mBGFarMoveX - 1;
// decrement the near background
mBGNearMoveX = mBGNearMoveX - 4;
// calculate the wrap factor for matching image draw
int newFarX = mBackgroundImageFar.getWidth() - (-mBGFarMoveX);
// if we have scrolled all the way, reset to start
if (newFarX <= 0) {
mBGFarMoveX = 0;
// only need one draw
canvas.drawBitmap(mBackgroundImageFar, mBGFarMoveX, 0, null);
} else {
// need to draw original and wrap
canvas.drawBitmap(mBackgroundImageFar, mBGFarMoveX, 0, null);
canvas.drawBitmap(mBackgroundImageFar, newFarX, 0, null);
}
// same story different image...
// TODO possible method call
int newNearX = mBackgroundImageNear.getWidth() - (-mBGNearMoveX);
if (newNearX <= 0) {
mBGNearMoveX = 0;
canvas.drawBitmap(mBackgroundImageNear, mBGNearMoveX, 0, null);
} else {
canvas.drawBitmap(mBackgroundImageNear, mBGNearMoveX, 0, null);
canvas.drawBitmap(mBackgroundImageNear, newNearX, 0, null);
}
doAsteroidAnimation(canvas);
canvas.drawBitmap(mBeam[mShipIndex], 51 + 20, 0, null);
mShipIndex++;
if (mShipIndex == 4)
mShipIndex = 0;
// draw the space ship in the same lane as the next asteroid
canvas.drawBitmap(mShipFlying[mShipIndex], mJetBoyX, mJetBoyY, null);
if (mLaserOn) {
canvas.drawBitmap(mLaserShot, mJetBoyX + mShipFlying[0].getWidth(), mJetBoyY
+ (mShipFlying[0].getHeight() / 2), null);
}
// tick tock
canvas.drawBitmap(mTimerShell, mCanvasWidth - mTimerShell.getWidth(), 0, null);
}
private void setInitialGameState() {
mTimerLimit = TIMER_LIMIT;
mJetBoyY = mJetBoyYMin;
// set up jet stuff
initializeJetPlayer();
mTimer = new Timer();
mDangerWillRobinson = new Vector<Asteroid>();
mExplosion = new Vector<Explosion>();
mInitialized = true;
mHitStreak = 0;
mHitTotal = 0;
}
private void doAsteroidAnimation(Canvas canvas) {
if ((mDangerWillRobinson == null | mDangerWillRobinson.size() == 0)
&& (mExplosion != null && mExplosion.size() == 0))
return;
// Compute what percentage through a beat we are and adjust
// animation and position based on that. This assumes 140bpm(428ms/beat).
// This is just inter-beat interpolation, no game state is updated
long frameDelta = System.currentTimeMillis() - mLastBeatTime;
int animOffset = (int)(ANIMATION_FRAMES_PER_BEAT * frameDelta / 428);
for (int i = (mDangerWillRobinson.size() - 1); i >= 0; i--) {
Asteroid asteroid = mDangerWillRobinson.elementAt(i);
if (!asteroid.mMissed)
mJetBoyY = asteroid.mDrawY;
// Log.d(TAG, " drawing asteroid " + ii + " at " +
// asteroid.mDrawX );
canvas.drawBitmap(
mAsteroids[(asteroid.mAniIndex + animOffset) % mAsteroids.length],
asteroid.mDrawX, asteroid.mDrawY, null);
}
for (int i = (mExplosion.size() - 1); i >= 0; i--) {
Explosion ex = mExplosion.elementAt(i);
canvas.drawBitmap(mExplosions[(ex.mAniIndex + animOffset) % mExplosions.length],
ex.mDrawX, ex.mDrawY, null);
}
}
private void doDrawReady(Canvas canvas) {
canvas.drawBitmap(mTitleBG, 0, 0, null);
}
private void doDrawPlay(Canvas canvas) {
canvas.drawBitmap(mTitleBG2, 0, 0, null);
}
/**
* the heart of the worker bee
*/
public void run() {
// while running do stuff in this loop...bzzz!
while (mRun) {
Canvas c = null;
if (mState == STATE_RUNNING) {
// Process any input and apply it to the game state
updateGameState();
if (!mJetPlaying) {
mInitialized = false;
Log.d(TAG, "------> STARTING JET PLAY");
mJet.play();
mJetPlaying = true;
}
mPassedTime = System.currentTimeMillis();
// kick off the timer task for counter update if not already
// initialized
if (mTimerTask == null) {
mTimerTask = new TimerTask() {
public void run() {
doCountDown();
}
};
mTimer.schedule(mTimerTask, mTaskIntervalInMillis);
}// end of TimerTask init block
}// end of STATE_RUNNING block
else if (mState == STATE_PLAY && !mInitialized)
{
setInitialGameState();
} else if (mState == STATE_LOSE) {
mInitialized = false;
}
try {
c = mSurfaceHolder.lockCanvas(null);
// synchronized (mSurfaceHolder) {
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);
}
}// end finally block
}// end while mrun block
}
/**
* This method handles updating the model of the game state. No
* rendering is done here only processing of inputs and update of state.
* This includes positons of all game objects (asteroids, player,
* explosions), their state (animation frame, hit), creation of new
* objects, etc.
*/
protected void updateGameState() {
// Process any game events and apply them
while (true) {
GameEvent event = mEventQueue.poll();
if (event == null)
break;
// Log.d(TAG,"*** EVENT = " + event);
// Process keys tracking the input context to pass in to later
// calls
if (event instanceof KeyGameEvent) {
// Process the key for affects other then asteroid hits
mKeyContext = processKeyEvent((KeyGameEvent)event, mKeyContext);
// Update laser state. Having this here allows the laser to
// be triggered right when the key is
// pressed. If we comment this out the laser will only be
// turned on when updateLaser is called
// when processing a timer event below.
updateLaser(mKeyContext);
}
// JET events trigger a state update
else if (event instanceof JetGameEvent) {
JetGameEvent jetEvent = (JetGameEvent)event;
// Only update state on a timer event
if (jetEvent.value == TIMER_EVENT) {
// Note the time of the last beat
mLastBeatTime = System.currentTimeMillis();
// Update laser state, turning it on if a key has been
// pressed or off if it has been
// on for too long.
updateLaser(mKeyContext);
// Update explosions before we update asteroids because
// updateAsteroids may add
// new explosions that we do not want updated until next
// frame
updateExplosions(mKeyContext);
// Update asteroid positions, hit status and animations
updateAsteroids(mKeyContext);
}
processJetEvent(jetEvent.player, jetEvent.segment, jetEvent.track,
jetEvent.channel, jetEvent.controller, jetEvent.value);
}
}
}
/**
* This method handles the state updates that can be caused by key press
* events. Key events may mean different things depending on what has
* come before, to support this concept this method takes an opaque
* context object as a parameter and returns an updated version. This
* context should be set to null for the first event then should be set
* to the last value returned for subsequent events.
*/
protected Object processKeyEvent(KeyGameEvent event, Object context) {
// Log.d(TAG, "key code is " + event.keyCode + " " + (event.up ?
// "up":"down"));
// If it is a key up on the fire key make sure we mute the
// associated sound
if (event.up) {
if (event.keyCode == KeyEvent.KEYCODE_DPAD_CENTER) {
return null;
}
}
// If it is a key down on the fire key start playing the sound and
// update the context
// to indicate that a key has been pressed and to ignore further
// presses
else {
if (event.keyCode == KeyEvent.KEYCODE_DPAD_CENTER && (context == null)) {
return event;
}
}
// Return the context unchanged
return context;
}
/**
* This method updates the laser status based on user input and shot
* duration
*/
protected void updateLaser(Object inputContext) {
// Lookup the time of the fire event if there is one
long keyTime = inputContext == null ? 0 : ((GameEvent)inputContext).eventTime;
// Log.d(TAG,"keyTime delta = " +
// (System.currentTimeMillis()-keyTime) + ": obj = " +
// inputContext);
// If the laser has been on too long shut it down
if (mLaserOn && System.currentTimeMillis() - mLaserFireTime > 400) {
mLaserOn = false;
}
// trying to tune the laser hit timing
else if (System.currentTimeMillis() - mLaserFireTime > 300) {
// JET info: the laser sound is on track 23, we mute it (true) right away (false)
mJet.setMuteFlag(23, true, false);
}
// Now check to see if we should turn the laser on. We do this after
// the above shutdown
// logic so it can be turned back on in the same frame it was turned
// off in. If we want
// to add a cooldown period this may change.
if (!mLaserOn && System.currentTimeMillis() - keyTime <= 400) {
mLaserOn = true;
mLaserFireTime = keyTime;
// JET info: unmute the laser track (false) right away (false)
mJet.setMuteFlag(23, false, false);
}
}
/**
* Update asteroid state including position and laser hit status.
*/
protected void updateAsteroids(Object inputContext) {
if (mDangerWillRobinson == null | mDangerWillRobinson.size() == 0)
return;
for (int i = (mDangerWillRobinson.size() - 1); i >= 0; i--) {
Asteroid asteroid = mDangerWillRobinson.elementAt(i);
// If the asteroid is within laser range but not already missed
// check if the key was pressed close enough to the beat to make a hit
if (asteroid.mDrawX <= mAsteroidMoveLimitX + 20 && !asteroid.mMissed)
{
// If the laser was fired on the beat destroy the asteroid
if (mLaserOn) {
// Track hit streak for adjusting music
mHitStreak++;
mHitTotal++;
// replace the asteroid with an explosion
Explosion ex = new Explosion();
ex.mAniIndex = 0;
ex.mDrawX = asteroid.mDrawX;
ex.mDrawY = asteroid.mDrawY;
mExplosion.add(ex);
mJet.setMuteFlag(24, false, false);
mDangerWillRobinson.removeElementAt(i);
// This asteroid has been removed process the next one
continue;
} else {
// Sorry, timing was not good enough, mark the asteroid
// as missed so on next frame it cannot be hit even if it is still
// within range
asteroid.mMissed = true;
mHitStreak = mHitStreak - 1;
if (mHitStreak < 0)
mHitStreak = 0;
}
}
// Update the asteroids position, even missed ones keep moving
asteroid.mDrawX -= mPixelMoveX;
// Update asteroid animation frame
asteroid.mAniIndex = (asteroid.mAniIndex + ANIMATION_FRAMES_PER_BEAT)
% mAsteroids.length;
// if we have scrolled off the screen
if (asteroid.mDrawX < 0) {
mDangerWillRobinson.removeElementAt(i);
}
}
}
/**
* This method updates explosion animation and removes them once they
* have completed.
*/
protected void updateExplosions(Object inputContext) {
if (mExplosion == null | mExplosion.size() == 0)
return;
for (int i = mExplosion.size() - 1; i >= 0; i--) {
Explosion ex = mExplosion.elementAt(i);
ex.mAniIndex += ANIMATION_FRAMES_PER_BEAT;
// When the animation completes remove the explosion
if (ex.mAniIndex > 3) {
mJet.setMuteFlag(24, true, false);
mJet.setMuteFlag(23, true, false);
mExplosion.removeElementAt(i);
}
}
}
/**
* This method handles the state updates that can be caused by JET
* events.
*/
protected void processJetEvent(JetPlayer player, short segment, byte track, byte channel,
byte controller, byte value) {
//Log.d(TAG, "onJetEvent(): seg=" + segment + " track=" + track + " chan=" + channel
// + " cntrlr=" + controller + " val=" + value);
// Check for an event that triggers a new asteroid
if (value == NEW_ASTEROID_EVENT) {
doAsteroidCreation();
}
mBeatCount++;
if (mBeatCount > 4) {
mBeatCount = 1;
}
// Scale the music based on progress
// it was a game requirement to change the mute array on 1st beat of
// the next measure when needed
// and so we track beat count, after that we track hitStreak to
// determine the music "intensity"
// if the intensity has go gone up, call a corresponding trigger clip, otherwise just
// execute the rest of the music bed change logic.
if (mBeatCount == 1) {
// do it back wards so you fall into the correct one
if (mHitStreak > 28) {
// did the bed change?
if (mCurrentBed != 7) {
// did it go up?
if (mCurrentBed < 7) {
mJet.triggerClip(7);
}
mCurrentBed = 7;
// JET info: change the mute mask to update the way the music plays based
// JET info: on the player's skills.
mJet.setMuteArray(muteMask[7], false);
}
} else if (mHitStreak > 24) {
if (mCurrentBed != 6) {
if (mCurrentBed < 6) {
// JET info: quite a few asteroids hit, trigger the clip with the guy's
// JET info: voice that encourages the player.
mJet.triggerClip(6);
}
mCurrentBed = 6;
mJet.setMuteArray(muteMask[6], false);
}
} else if (mHitStreak > 20) {
if (mCurrentBed != 5) {
if (mCurrentBed < 5) {
mJet.triggerClip(5);
}
mCurrentBed = 5;
mJet.setMuteArray(muteMask[5], false);
}
} else if (mHitStreak > 16) {
if (mCurrentBed != 4) {
if (mCurrentBed < 4) {
mJet.triggerClip(4);
}
mCurrentBed = 4;
mJet.setMuteArray(muteMask[4], false);
}
} else if (mHitStreak > 12) {
if (mCurrentBed != 3) {
if (mCurrentBed < 3) {
mJet.triggerClip(3);
}
mCurrentBed = 3;
mJet.setMuteArray(muteMask[3], false);
}
} else if (mHitStreak > 8) {
if (mCurrentBed != 2) {
if (mCurrentBed < 2) {
mJet.triggerClip(2);
}
mCurrentBed = 2;
mJet.setMuteArray(muteMask[2], false);
}
} else if (mHitStreak > 4) {
if (mCurrentBed != 1) {
if (mCurrentBed < 1) {
mJet.triggerClip(1);
}
mJet.setMuteArray(muteMask[1], false);
mCurrentBed = 1;
}
}
}
}
private void doAsteroidCreation() {
// Log.d(TAG, "asteroid created");
Asteroid _as = new Asteroid();
int drawIndex = mRandom.nextInt(4);
// TODO Remove hard coded value
_as.mDrawY = mAsteroidMinY + (drawIndex * 63);
_as.mDrawX = (mCanvasWidth - mAsteroids[0].getWidth());
_as.mStartTime = System.currentTimeMillis();
mDangerWillRobinson.add(_as);
}
/**
* 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) {
mRun = b;
if (mRun == false) {
if (mTimerTask != null)
mTimerTask.cancel();
}
}
/**
* returns the current int value of game state as defined by state
* tracking constants
*
* @return
*/
public int getGameState() {
synchronized (mSurfaceHolder) {
return mState;
}
}
/**
* 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 setGameState(int mode) {
synchronized (mSurfaceHolder) {
setGameState(mode, null);
}
}
/**
* Sets state based on input, optionally also passing in a text message.
*
* @param state
* @param message
*/
public void setGameState(int state, CharSequence message) {
synchronized (mSurfaceHolder) {
// change state if needed
if (mState != state) {
mState = state;
}
if (mState == STATE_PLAY) {
Resources res = mContext.getResources();
mBackgroundImageFar = BitmapFactory
.decodeResource(res, R.drawable.background_a);
// don't forget to resize the background image
mBackgroundImageFar = Bitmap.createScaledBitmap(mBackgroundImageFar,
mCanvasWidth * 2, mCanvasHeight, true);
mBackgroundImageNear = BitmapFactory.decodeResource(res,
R.drawable.background_b);
// don't forget to resize the background image
mBackgroundImageNear = Bitmap.createScaledBitmap(mBackgroundImageNear,
mCanvasWidth * 2, mCanvasHeight, true);
} else if (mState == STATE_RUNNING) {
// When we enter the running state we should clear any old
// events in the queue
mEventQueue.clear();
// And reset the key state so we don't think a button is pressed when it isn't
mKeyContext = null;
}
}
}
/**
* Add key press input to the GameEvent queue
*/
public boolean doKeyDown(int keyCode, KeyEvent msg) {
mEventQueue.add(new KeyGameEvent(keyCode, false, msg));
return true;
}
/**
* Add key press input to the GameEvent queue
*/
public boolean doKeyUp(int keyCode, KeyEvent msg) {
mEventQueue.add(new KeyGameEvent(keyCode, true, msg));
return true;
}
/* 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
mBackgroundImageFar = Bitmap.createScaledBitmap(mBackgroundImageFar, width * 2,
height, true);
// don't forget to resize the background image
mBackgroundImageNear = Bitmap.createScaledBitmap(mBackgroundImageNear, width * 2,
height, true);
}
}
/**
* Pauses the physics update & animation.
*/
public void pause() {
synchronized (mSurfaceHolder) {
if (mState == STATE_RUNNING)
setGameState(STATE_PAUSE);
if (mTimerTask != null) {
mTimerTask.cancel();
}
if (mJet != null) {
mJet.pause();
}
}
}
/**
* Does the work of updating timer
*
*/
private void doCountDown() {
//Log.d(TAG,"Time left is " + mTimerLimit);
mTimerLimit = mTimerLimit - 1;
try {
//subtract one minute and see what the result is.
int moreThanMinute = mTimerLimit - 60;
if (moreThanMinute >= 0) {
if (moreThanMinute > 9) {
mTimerValue = "1:" + moreThanMinute;
}
//need an extra '0' for formatting
else {
mTimerValue = "1:0" + moreThanMinute;
}
} else {
if (mTimerLimit > 9) {
mTimerValue = "0:" + mTimerLimit;
} else {
mTimerValue = "0:0" + mTimerLimit;
}
}
} catch (Exception e1) {
Log.e(TAG, "doCountDown threw " + e1.toString());
}
Message msg = mHandler.obtainMessage();
Bundle b = new Bundle();
b.putString("text", mTimerValue);
//time's up
if (mTimerLimit == 0) {
b.putString("STATE_LOSE", "" + STATE_LOSE);
mTimerTask = null;
mState = STATE_LOSE;
} else {
mTimerTask = new TimerTask() {
public void run() {
doCountDown();
}
};
mTimer.schedule(mTimerTask, mTaskIntervalInMillis);
}
//this is how we send data back up to the main JetBoyView thread.
//if you look in constructor of JetBoyView you will see code for
//Handling of messages. This is borrowed directly from lunar lander.
//Thanks again!
msg.setData(b);
mHandler.sendMessage(msg);
}
// JET info: JET event listener interface implementation:
/**
* required OnJetEventListener method. Notifications for queue updates
*
* @param player
* @param nbSegments
*/
public void onJetNumQueuedSegmentUpdate(JetPlayer player, int nbSegments) {
//Log.i(TAG, "onJetNumQueuedUpdate(): nbSegs =" + nbSegments);
}
// JET info: JET event listener interface implementation:
/**
* The method which receives notification from event listener.
* This is where we queue up events 80 and 82.
*
* Most of this data passed is unneeded for JetBoy logic but shown
* for code sample completeness.
*
* @param player
* @param segment
* @param track
* @param channel
* @param controller
* @param value
*/
public void onJetEvent(JetPlayer player, short segment, byte track, byte channel,
byte controller, byte value) {
//Log.d(TAG, "jet got event " + value);
//events fire outside the animation thread. This can cause timing issues.
//put in queue for processing by animation thread.
mEventQueue.add(new JetGameEvent(player, segment, track, channel, controller, value));
}
// JET info: JET event listener interface implementation:
public void onJetPauseUpdate(JetPlayer player, int paused) {
//Log.i(TAG, "onJetPauseUpdate(): paused =" + paused);
}
// JET info: JET event listener interface implementation:
public void onJetUserIdUpdate(JetPlayer player, int userId, int repeatCount) {
//Log.i(TAG, "onJetUserIdUpdate(): userId =" + userId + " repeatCount=" + repeatCount);
}
}//end thread class
public static final String TAG = "JetBoy";
/** The thread that actually draws the animation */
private JetBoyThread thread;
private TextView mTimerView;
private Button mButtonRetry;
// private Button mButtonRestart;
private TextView mTextView;
/**
* The constructor called from the main JetBoy activity
*
* @param context
* @param attrs
*/
public JetBoyView(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()
// except if used in the layout editor.
if (isInEditMode() == false) {
thread = new JetBoyThread(holder, context, new Handler() {
public void handleMessage(Message m) {
mTimerView.setText(m.getData().getString("text"));
if (m.getData().getString("STATE_LOSE") != null) {
//mButtonRestart.setVisibility(View.VISIBLE);
mButtonRetry.setVisibility(View.VISIBLE);
mTimerView.setVisibility(View.INVISIBLE);
mTextView.setVisibility(View.VISIBLE);
Log.d(TAG, "the total was " + mHitTotal);
if (mHitTotal >= mSuccessThreshold) {
mTextView.setText(R.string.winText);
} else {
mTextView.setText("Sorry, You Lose! You got " + mHitTotal
+ ". You need 50 to win.");
}
mTimerView.setText("1:12");
mTextView.setHeight(20);
}
}//end handle msg
});
}
setFocusable(true); // make sure we get key events
Log.d(TAG, "@@@ done creating view!");
}
/**
* Pass in a reference to the timer view widget so we can update it from here.
*
* @param tv
*/
public void setTimerView(TextView tv) {
mTimerView = tv;
}
/**
* 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) {
if (thread != null)
thread.pause();
}
}
/**
* Fetches the animation thread corresponding to this LunarView.
*
* @return the animation thread
*/
public JetBoyThread getThread() {
return thread;
}
/* Callback invoked when the surface dimensions change. */
public void surfaceChanged(SurfaceHolder holder, int format, int width, int height) {
thread.setSurfaceSize(width, height);
}
public void surfaceCreated(SurfaceHolder arg0) {
// 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();
}
public void surfaceDestroyed(SurfaceHolder arg0) {
boolean retry = true;
thread.setRunning(false);
while (retry) {
try {
thread.join();
retry = false;
} catch (InterruptedException e) {
}
}
}
/**
* A reference to the button to start game over.
*
* @param _buttonRetry
*
*/
public void SetButtonView(Button _buttonRetry) {
mButtonRetry = _buttonRetry;
// mButtonRestart = _buttonRestart;
}
//we reuse the help screen from the end game screen.
public void SetTextView(TextView textView) {
mTextView = textView;
}
}
Other Android examples (source code examples)
Here is a short list of links related to this Android JetBoyView.java source code file:
|
The search page
Other Android source code examples at this package level
Click here to learn more about this project
