/*
* 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<GameEvent>();
/** 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;
}
}