/* * 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 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 mDangerWillRobinson; private Vector 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(); mExplosion = new Vector(); 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; } }