1 /* 2 * Copyright (C) 2007 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 package com.example.android.lunarlander; 18 19 import android.content.Context; 20 import android.content.res.Resources; 21 import android.graphics.Bitmap; 22 import android.graphics.BitmapFactory; 23 import android.graphics.Canvas; 24 import android.graphics.Paint; 25 import android.graphics.RectF; 26 import android.graphics.drawable.Drawable; 27 import android.os.Bundle; 28 import android.os.Handler; 29 import android.os.Message; 30 import android.util.AttributeSet; 31 import android.view.KeyEvent; 32 import android.view.SurfaceHolder; 33 import android.view.SurfaceView; 34 import android.view.View; 35 import android.widget.TextView; 36 37 38 /** 39 * View that draws, takes keystrokes, etc. for a simple LunarLander game. 40 * 41 * Has a mode which RUNNING, PAUSED, etc. Has a x, y, dx, dy, ... capturing the 42 * current ship physics. All x/y etc. are measured with (0,0) at the lower left. 43 * updatePhysics() advances the physics based on realtime. draw() renders the 44 * ship, and does an invalidate() to prompt another draw() as soon as possible 45 * by the system. 46 */ 47 class LunarView extends SurfaceView implements SurfaceHolder.Callback { 48 class LunarThread extends Thread { 49 /* 50 * Difficulty setting constants 51 */ 52 public static final int DIFFICULTY_EASY = 0; 53 public static final int DIFFICULTY_HARD = 1; 54 public static final int DIFFICULTY_MEDIUM = 2; 55 /* 56 * Physics constants 57 */ 58 public static final int PHYS_DOWN_ACCEL_SEC = 35; 59 public static final int PHYS_FIRE_ACCEL_SEC = 80; 60 public static final int PHYS_FUEL_INIT = 60; 61 public static final int PHYS_FUEL_MAX = 100; 62 public static final int PHYS_FUEL_SEC = 10; 63 public static final int PHYS_SLEW_SEC = 120; // degrees/second rotate 64 public static final int PHYS_SPEED_HYPERSPACE = 180; 65 public static final int PHYS_SPEED_INIT = 30; 66 public static final int PHYS_SPEED_MAX = 120; 67 /* 68 * State-tracking constants 69 */ 70 public static final int STATE_LOSE = 1; 71 public static final int STATE_PAUSE = 2; 72 public static final int STATE_READY = 3; 73 public static final int STATE_RUNNING = 4; 74 public static final int STATE_WIN = 5; 75 76 /* 77 * Goal condition constants 78 */ 79 public static final int TARGET_ANGLE = 18; // > this angle means crash 80 public static final int TARGET_BOTTOM_PADDING = 17; // px below gear 81 public static final int TARGET_PAD_HEIGHT = 8; // how high above ground 82 public static final int TARGET_SPEED = 28; // > this speed means crash 83 public static final double TARGET_WIDTH = 1.6; // width of target 84 /* 85 * UI constants (i.e. the speed & fuel bars) 86 */ 87 public static final int UI_BAR = 100; // width of the bar(s) 88 public static final int UI_BAR_HEIGHT = 10; // height of the bar(s) 89 private static final String KEY_DIFFICULTY = "mDifficulty"; 90 private static final String KEY_DX = "mDX"; 91 92 private static final String KEY_DY = "mDY"; 93 private static final String KEY_FUEL = "mFuel"; 94 private static final String KEY_GOAL_ANGLE = "mGoalAngle"; 95 private static final String KEY_GOAL_SPEED = "mGoalSpeed"; 96 private static final String KEY_GOAL_WIDTH = "mGoalWidth"; 97 98 private static final String KEY_GOAL_X = "mGoalX"; 99 private static final String KEY_HEADING = "mHeading"; 100 private static final String KEY_LANDER_HEIGHT = "mLanderHeight"; 101 private static final String KEY_LANDER_WIDTH = "mLanderWidth"; 102 private static final String KEY_WINS = "mWinsInARow"; 103 104 private static final String KEY_X = "mX"; 105 private static final String KEY_Y = "mY"; 106 107 /* 108 * Member (state) fields 109 */ 110 /** The drawable to use as the background of the animation canvas */ 111 private Bitmap mBackgroundImage; 112 113 /** 114 * Current height of the surface/canvas. 115 * 116 * @see #setSurfaceSize 117 */ 118 private int mCanvasHeight = 1; 119 120 /** 121 * Current width of the surface/canvas. 122 * 123 * @see #setSurfaceSize 124 */ 125 private int mCanvasWidth = 1; 126 127 /** What to draw for the Lander when it has crashed */ 128 private Drawable mCrashedImage; 129 130 /** 131 * Current difficulty -- amount of fuel, allowed angle, etc. Default is 132 * MEDIUM. 133 */ 134 private int mDifficulty; 135 136 /** Velocity dx. */ 137 private double mDX; 138 139 /** Velocity dy. */ 140 private double mDY; 141 142 /** Is the engine burning? */ 143 private boolean mEngineFiring; 144 145 /** What to draw for the Lander when the engine is firing */ 146 private Drawable mFiringImage; 147 148 /** Fuel remaining */ 149 private double mFuel; 150 151 /** Allowed angle. */ 152 private int mGoalAngle; 153 154 /** Allowed speed. */ 155 private int mGoalSpeed; 156 157 /** Width of the landing pad. */ 158 private int mGoalWidth; 159 160 /** X of the landing pad. */ 161 private int mGoalX; 162 163 /** Message handler used by thread to interact with TextView */ 164 private Handler mHandler; 165 166 /** 167 * Lander heading in degrees, with 0 up, 90 right. Kept in the range 168 * 0..360. 169 */ 170 private double mHeading; 171 172 /** Pixel height of lander image. */ 173 private int mLanderHeight; 174 175 /** What to draw for the Lander in its normal state */ 176 private Drawable mLanderImage; 177 178 /** Pixel width of lander image. */ 179 private int mLanderWidth; 180 181 /** Used to figure out elapsed time between frames */ 182 private long mLastTime; 183 184 /** Paint to draw the lines on screen. */ 185 private Paint mLinePaint; 186 187 /** "Bad" speed-too-high variant of the line color. */ 188 private Paint mLinePaintBad; 189 190 /** The state of the game. One of READY, RUNNING, PAUSE, LOSE, or WIN */ 191 private int mMode; 192 193 /** Currently rotating, -1 left, 0 none, 1 right. */ 194 private int mRotating; 195 196 /** Indicate whether the surface has been created & is ready to draw */ 197 private boolean mRun = false; 198 199 /** Scratch rect object. */ 200 private RectF mScratchRect; 201 202 /** Handle to the surface manager object we interact with */ 203 private SurfaceHolder mSurfaceHolder; 204 205 /** Number of wins in a row. */ 206 private int mWinsInARow; 207 208 /** X of lander center. */ 209 private double mX; 210 211 /** Y of lander center. */ 212 private double mY; 213 214 public LunarThread(SurfaceHolder surfaceHolder, Context context, 215 Handler handler) { 216 // get handles to some important objects 217 mSurfaceHolder = surfaceHolder; 218 mHandler = handler; 219 mContext = context; 220 221 Resources res = context.getResources(); 222 // cache handles to our key sprites & other drawables 223 mLanderImage = context.getResources().getDrawable( 224 R.drawable.lander_plain); 225 mFiringImage = context.getResources().getDrawable( 226 R.drawable.lander_firing); 227 mCrashedImage = context.getResources().getDrawable( 228 R.drawable.lander_crashed); 229 230 // load background image as a Bitmap instead of a Drawable b/c 231 // we don't need to transform it and it's faster to draw this way 232 mBackgroundImage = BitmapFactory.decodeResource(res, 233 R.drawable.earthrise); 234 235 // Use the regular lander image as the model size for all sprites 236 mLanderWidth = mLanderImage.getIntrinsicWidth(); 237 mLanderHeight = mLanderImage.getIntrinsicHeight(); 238 239 // Initialize paints for speedometer 240 mLinePaint = new Paint(); 241 mLinePaint.setAntiAlias(true); 242 mLinePaint.setARGB(255, 0, 255, 0); 243 244 mLinePaintBad = new Paint(); 245 mLinePaintBad.setAntiAlias(true); 246 mLinePaintBad.setARGB(255, 120, 180, 0); 247 248 mScratchRect = new RectF(0, 0, 0, 0); 249 250 mWinsInARow = 0; 251 mDifficulty = DIFFICULTY_MEDIUM; 252 253 // initial show-up of lander (not yet playing) 254 mX = mLanderWidth; 255 mY = mLanderHeight * 2; 256 mFuel = PHYS_FUEL_INIT; 257 mDX = 0; 258 mDY = 0; 259 mHeading = 0; 260 mEngineFiring = true; 261 } 262 263 /** 264 * Starts the game, setting parameters for the current difficulty. 265 */ 266 public void doStart() { 267 synchronized (mSurfaceHolder) { 268 // First set the game for Medium difficulty 269 mFuel = PHYS_FUEL_INIT; 270 mEngineFiring = false; 271 mGoalWidth = (int) (mLanderWidth * TARGET_WIDTH); 272 mGoalSpeed = TARGET_SPEED; 273 mGoalAngle = TARGET_ANGLE; 274 int speedInit = PHYS_SPEED_INIT; 275 276 // Adjust difficulty params for EASY/HARD 277 if (mDifficulty == DIFFICULTY_EASY) { 278 mFuel = mFuel * 3 / 2; 279 mGoalWidth = mGoalWidth * 4 / 3; 280 mGoalSpeed = mGoalSpeed * 3 / 2; 281 mGoalAngle = mGoalAngle * 4 / 3; 282 speedInit = speedInit * 3 / 4; 283 } else if (mDifficulty == DIFFICULTY_HARD) { 284 mFuel = mFuel * 7 / 8; 285 mGoalWidth = mGoalWidth * 3 / 4; 286 mGoalSpeed = mGoalSpeed * 7 / 8; 287 speedInit = speedInit * 4 / 3; 288 } 289 290 // pick a convenient initial location for the lander sprite 291 mX = mCanvasWidth / 2; 292 mY = mCanvasHeight - mLanderHeight / 2; 293 294 // start with a little random motion 295 mDY = Math.random() * -speedInit; 296 mDX = Math.random() * 2 * speedInit - speedInit; 297 mHeading = 0; 298 299 // Figure initial spot for landing, not too near center 300 while (true) { 301 mGoalX = (int) (Math.random() * (mCanvasWidth - mGoalWidth)); 302 if (Math.abs(mGoalX - (mX - mLanderWidth / 2)) > mCanvasHeight / 6) 303 break; 304 } 305 306 mLastTime = System.currentTimeMillis() + 100; 307 setState(STATE_RUNNING); 308 } 309 } 310 311 /** 312 * Pauses the physics update & animation. 313 */ 314 public void pause() { 315 synchronized (mSurfaceHolder) { 316 if (mMode == STATE_RUNNING) setState(STATE_PAUSE); 317 } 318 } 319 320 /** 321 * Restores game state from the indicated Bundle. Typically called when 322 * the Activity is being restored after having been previously 323 * destroyed. 324 * 325 * @param savedState Bundle containing the game state 326 */ 327 public synchronized void restoreState(Bundle savedState) { 328 synchronized (mSurfaceHolder) { 329 setState(STATE_PAUSE); 330 mRotating = 0; 331 mEngineFiring = false; 332 333 mDifficulty = savedState.getInt(KEY_DIFFICULTY); 334 mX = savedState.getDouble(KEY_X); 335 mY = savedState.getDouble(KEY_Y); 336 mDX = savedState.getDouble(KEY_DX); 337 mDY = savedState.getDouble(KEY_DY); 338 mHeading = savedState.getDouble(KEY_HEADING); 339 340 mLanderWidth = savedState.getInt(KEY_LANDER_WIDTH); 341 mLanderHeight = savedState.getInt(KEY_LANDER_HEIGHT); 342 mGoalX = savedState.getInt(KEY_GOAL_X); 343 mGoalSpeed = savedState.getInt(KEY_GOAL_SPEED); 344 mGoalAngle = savedState.getInt(KEY_GOAL_ANGLE); 345 mGoalWidth = savedState.getInt(KEY_GOAL_WIDTH); 346 mWinsInARow = savedState.getInt(KEY_WINS); 347 mFuel = savedState.getDouble(KEY_FUEL); 348 } 349 } 350 351 @Override 352 public void run() { 353 while (mRun) { 354 Canvas c = null; 355 try { 356 c = mSurfaceHolder.lockCanvas(null); 357 synchronized (mSurfaceHolder) { 358 if (mMode == STATE_RUNNING) updatePhysics(); 359 doDraw(c); 360 } 361 } finally { 362 // do this in a finally so that if an exception is thrown 363 // during the above, we don't leave the Surface in an 364 // inconsistent state 365 if (c != null) { 366 mSurfaceHolder.unlockCanvasAndPost(c); 367 } 368 } 369 } 370 } 371 372 /** 373 * Dump game state to the provided Bundle. Typically called when the 374 * Activity is being suspended. 375 * 376 * @return Bundle with this view's state 377 */ 378 public Bundle saveState(Bundle map) { 379 synchronized (mSurfaceHolder) { 380 if (map != null) { 381 map.putInt(KEY_DIFFICULTY, Integer.valueOf(mDifficulty)); 382 map.putDouble(KEY_X, Double.valueOf(mX)); 383 map.putDouble(KEY_Y, Double.valueOf(mY)); 384 map.putDouble(KEY_DX, Double.valueOf(mDX)); 385 map.putDouble(KEY_DY, Double.valueOf(mDY)); 386 map.putDouble(KEY_HEADING, Double.valueOf(mHeading)); 387 map.putInt(KEY_LANDER_WIDTH, Integer.valueOf(mLanderWidth)); 388 map.putInt(KEY_LANDER_HEIGHT, Integer 389 .valueOf(mLanderHeight)); 390 map.putInt(KEY_GOAL_X, Integer.valueOf(mGoalX)); 391 map.putInt(KEY_GOAL_SPEED, Integer.valueOf(mGoalSpeed)); 392 map.putInt(KEY_GOAL_ANGLE, Integer.valueOf(mGoalAngle)); 393 map.putInt(KEY_GOAL_WIDTH, Integer.valueOf(mGoalWidth)); 394 map.putInt(KEY_WINS, Integer.valueOf(mWinsInARow)); 395 map.putDouble(KEY_FUEL, Double.valueOf(mFuel)); 396 } 397 } 398 return map; 399 } 400 401 /** 402 * Sets the current difficulty. 403 * 404 * @param difficulty 405 */ 406 public void setDifficulty(int difficulty) { 407 synchronized (mSurfaceHolder) { 408 mDifficulty = difficulty; 409 } 410 } 411 412 /** 413 * Sets if the engine is currently firing. 414 */ 415 public void setFiring(boolean firing) { 416 synchronized (mSurfaceHolder) { 417 mEngineFiring = firing; 418 } 419 } 420 421 /** 422 * Used to signal the thread whether it should be running or not. 423 * Passing true allows the thread to run; passing false will shut it 424 * down if it's already running. Calling start() after this was most 425 * recently called with false will result in an immediate shutdown. 426 * 427 * @param b true to run, false to shut down 428 */ 429 public void setRunning(boolean b) { 430 mRun = b; 431 } 432 433 /** 434 * Sets the game mode. That is, whether we are running, paused, in the 435 * failure state, in the victory state, etc. 436 * 437 * @see #setState(int, CharSequence) 438 * @param mode one of the STATE_* constants 439 */ 440 public void setState(int mode) { 441 synchronized (mSurfaceHolder) { 442 setState(mode, null); 443 } 444 } 445 446 /** 447 * Sets the game mode. That is, whether we are running, paused, in the 448 * failure state, in the victory state, etc. 449 * 450 * @param mode one of the STATE_* constants 451 * @param message string to add to screen or null 452 */ 453 public void setState(int mode, CharSequence message) { 454 /* 455 * This method optionally can cause a text message to be displayed 456 * to the user when the mode changes. Since the View that actually 457 * renders that text is part of the main View hierarchy and not 458 * owned by this thread, we can't touch the state of that View. 459 * Instead we use a Message + Handler to relay commands to the main 460 * thread, which updates the user-text View. 461 */ 462 synchronized (mSurfaceHolder) { 463 mMode = mode; 464 465 if (mMode == STATE_RUNNING) { 466 Message msg = mHandler.obtainMessage(); 467 Bundle b = new Bundle(); 468 b.putString("text", ""); 469 b.putInt("viz", View.INVISIBLE); 470 msg.setData(b); 471 mHandler.sendMessage(msg); 472 } else { 473 mRotating = 0; 474 mEngineFiring = false; 475 Resources res = mContext.getResources(); 476 CharSequence str = ""; 477 if (mMode == STATE_READY) 478 str = res.getText(R.string.mode_ready); 479 else if (mMode == STATE_PAUSE) 480 str = res.getText(R.string.mode_pause); 481 else if (mMode == STATE_LOSE) 482 str = res.getText(R.string.mode_lose); 483 else if (mMode == STATE_WIN) 484 str = res.getString(R.string.mode_win_prefix) 485 + mWinsInARow + " " 486 + res.getString(R.string.mode_win_suffix); 487 488 if (message != null) { 489 str = message + "\n" + str; 490 } 491 492 if (mMode == STATE_LOSE) mWinsInARow = 0; 493 494 Message msg = mHandler.obtainMessage(); 495 Bundle b = new Bundle(); 496 b.putString("text", str.toString()); 497 b.putInt("viz", View.VISIBLE); 498 msg.setData(b); 499 mHandler.sendMessage(msg); 500 } 501 } 502 } 503 504 /* Callback invoked when the surface dimensions change. */ 505 public void setSurfaceSize(int width, int height) { 506 // synchronized to make sure these all change atomically 507 synchronized (mSurfaceHolder) { 508 mCanvasWidth = width; 509 mCanvasHeight = height; 510 511 // don't forget to resize the background image 512 mBackgroundImage = mBackgroundImage.createScaledBitmap( 513 mBackgroundImage, width, height, true); 514 } 515 } 516 517 /** 518 * Resumes from a pause. 519 */ 520 public void unpause() { 521 // Move the real time clock up to now 522 synchronized (mSurfaceHolder) { 523 mLastTime = System.currentTimeMillis() + 100; 524 } 525 setState(STATE_RUNNING); 526 } 527 528 /** 529 * Handles a key-down event. 530 * 531 * @param keyCode the key that was pressed 532 * @param msg the original event object 533 * @return true 534 */ 535 boolean doKeyDown(int keyCode, KeyEvent msg) { 536 synchronized (mSurfaceHolder) { 537 boolean okStart = false; 538 if (keyCode == KeyEvent.KEYCODE_DPAD_UP) okStart = true; 539 if (keyCode == KeyEvent.KEYCODE_DPAD_DOWN) okStart = true; 540 if (keyCode == KeyEvent.KEYCODE_S) okStart = true; 541 542 boolean center = (keyCode == KeyEvent.KEYCODE_DPAD_UP); 543 544 if (okStart 545 && (mMode == STATE_READY || mMode == STATE_LOSE || mMode == STATE_WIN)) { 546 // ready-to-start -> start 547 doStart(); 548 return true; 549 } else if (mMode == STATE_PAUSE && okStart) { 550 // paused -> running 551 unpause(); 552 return true; 553 } else if (mMode == STATE_RUNNING) { 554 // center/space -> fire 555 if (keyCode == KeyEvent.KEYCODE_DPAD_CENTER 556 || keyCode == KeyEvent.KEYCODE_SPACE) { 557 setFiring(true); 558 return true; 559 // left/q -> left 560 } else if (keyCode == KeyEvent.KEYCODE_DPAD_LEFT 561 || keyCode == KeyEvent.KEYCODE_Q) { 562 mRotating = -1; 563 return true; 564 // right/w -> right 565 } else if (keyCode == KeyEvent.KEYCODE_DPAD_RIGHT 566 || keyCode == KeyEvent.KEYCODE_W) { 567 mRotating = 1; 568 return true; 569 // up -> pause 570 } else if (keyCode == KeyEvent.KEYCODE_DPAD_UP) { 571 pause(); 572 return true; 573 } 574 } 575 576 return false; 577 } 578 } 579 580 /** 581 * Handles a key-up event. 582 * 583 * @param keyCode the key that was pressed 584 * @param msg the original event object 585 * @return true if the key was handled and consumed, or else false 586 */ 587 boolean doKeyUp(int keyCode, KeyEvent msg) { 588 boolean handled = false; 589 590 synchronized (mSurfaceHolder) { 591 if (mMode == STATE_RUNNING) { 592 if (keyCode == KeyEvent.KEYCODE_DPAD_CENTER 593 || keyCode == KeyEvent.KEYCODE_SPACE) { 594 setFiring(false); 595 handled = true; 596 } else if (keyCode == KeyEvent.KEYCODE_DPAD_LEFT 597 || keyCode == KeyEvent.KEYCODE_Q 598 || keyCode == KeyEvent.KEYCODE_DPAD_RIGHT 599 || keyCode == KeyEvent.KEYCODE_W) { 600 mRotating = 0; 601 handled = true; 602 } 603 } 604 } 605 606 return handled; 607 } 608 609 /** 610 * Draws the ship, fuel/speed bars, and background to the provided 611 * Canvas. 612 */ 613 private void doDraw(Canvas canvas) { 614 // Draw the background image. Operations on the Canvas accumulate 615 // so this is like clearing the screen. 616 canvas.drawBitmap(mBackgroundImage, 0, 0, null); 617 618 int yTop = mCanvasHeight - ((int) mY + mLanderHeight / 2); 619 int xLeft = (int) mX - mLanderWidth / 2; 620 621 // Draw the fuel gauge 622 int fuelWidth = (int) (UI_BAR * mFuel / PHYS_FUEL_MAX); 623 mScratchRect.set(4, 4, 4 + fuelWidth, 4 + UI_BAR_HEIGHT); 624 canvas.drawRect(mScratchRect, mLinePaint); 625 626 // Draw the speed gauge, with a two-tone effect 627 double speed = Math.sqrt(mDX * mDX + mDY * mDY); 628 int speedWidth = (int) (UI_BAR * speed / PHYS_SPEED_MAX); 629 630 if (speed <= mGoalSpeed) { 631 mScratchRect.set(4 + UI_BAR + 4, 4, 632 4 + UI_BAR + 4 + speedWidth, 4 + UI_BAR_HEIGHT); 633 canvas.drawRect(mScratchRect, mLinePaint); 634 } else { 635 // Draw the bad color in back, with the good color in front of 636 // it 637 mScratchRect.set(4 + UI_BAR + 4, 4, 638 4 + UI_BAR + 4 + speedWidth, 4 + UI_BAR_HEIGHT); 639 canvas.drawRect(mScratchRect, mLinePaintBad); 640 int goalWidth = (UI_BAR * mGoalSpeed / PHYS_SPEED_MAX); 641 mScratchRect.set(4 + UI_BAR + 4, 4, 4 + UI_BAR + 4 + goalWidth, 642 4 + UI_BAR_HEIGHT); 643 canvas.drawRect(mScratchRect, mLinePaint); 644 } 645 646 // Draw the landing pad 647 canvas.drawLine(mGoalX, 1 + mCanvasHeight - TARGET_PAD_HEIGHT, 648 mGoalX + mGoalWidth, 1 + mCanvasHeight - TARGET_PAD_HEIGHT, 649 mLinePaint); 650 651 652 // Draw the ship with its current rotation 653 canvas.save(); 654 canvas.rotate((float) mHeading, (float) mX, mCanvasHeight 655 - (float) mY); 656 if (mMode == STATE_LOSE) { 657 mCrashedImage.setBounds(xLeft, yTop, xLeft + mLanderWidth, yTop 658 + mLanderHeight); 659 mCrashedImage.draw(canvas); 660 } else if (mEngineFiring) { 661 mFiringImage.setBounds(xLeft, yTop, xLeft + mLanderWidth, yTop 662 + mLanderHeight); 663 mFiringImage.draw(canvas); 664 } else { 665 mLanderImage.setBounds(xLeft, yTop, xLeft + mLanderWidth, yTop 666 + mLanderHeight); 667 mLanderImage.draw(canvas); 668 } 669 canvas.restore(); 670 } 671 672 /** 673 * Figures the lander state (x, y, fuel, ...) based on the passage of 674 * realtime. Does not invalidate(). Called at the start of draw(). 675 * Detects the end-of-game and sets the UI to the next state. 676 */ 677 private void updatePhysics() { 678 long now = System.currentTimeMillis(); 679 680 // Do nothing if mLastTime is in the future. 681 // This allows the game-start to delay the start of the physics 682 // by 100ms or whatever. 683 if (mLastTime > now) return; 684 685 double elapsed = (now - mLastTime) / 1000.0; 686 687 // mRotating -- update heading 688 if (mRotating != 0) { 689 mHeading += mRotating * (PHYS_SLEW_SEC * elapsed); 690 691 // Bring things back into the range 0..360 692 if (mHeading < 0) 693 mHeading += 360; 694 else if (mHeading >= 360) mHeading -= 360; 695 } 696 697 // Base accelerations -- 0 for x, gravity for y 698 double ddx = 0.0; 699 double ddy = -PHYS_DOWN_ACCEL_SEC * elapsed; 700 701 if (mEngineFiring) { 702 // taking 0 as up, 90 as to the right 703 // cos(deg) is ddy component, sin(deg) is ddx component 704 double elapsedFiring = elapsed; 705 double fuelUsed = elapsedFiring * PHYS_FUEL_SEC; 706 707 // tricky case where we run out of fuel partway through the 708 // elapsed 709 if (fuelUsed > mFuel) { 710 elapsedFiring = mFuel / fuelUsed * elapsed; 711 fuelUsed = mFuel; 712 713 // Oddball case where we adjust the "control" from here 714 mEngineFiring = false; 715 } 716 717 mFuel -= fuelUsed; 718 719 // have this much acceleration from the engine 720 double accel = PHYS_FIRE_ACCEL_SEC * elapsedFiring; 721 722 double radians = 2 * Math.PI * mHeading / 360; 723 ddx = Math.sin(radians) * accel; 724 ddy += Math.cos(radians) * accel; 725 } 726 727 double dxOld = mDX; 728 double dyOld = mDY; 729 730 // figure speeds for the end of the period 731 mDX += ddx; 732 mDY += ddy; 733 734 // figure position based on average speed during the period 735 mX += elapsed * (mDX + dxOld) / 2; 736 mY += elapsed * (mDY + dyOld) / 2; 737 738 mLastTime = now; 739 740 // Evaluate if we have landed ... stop the game 741 double yLowerBound = TARGET_PAD_HEIGHT + mLanderHeight / 2 742 - TARGET_BOTTOM_PADDING; 743 if (mY <= yLowerBound) { 744 mY = yLowerBound; 745 746 int result = STATE_LOSE; 747 CharSequence message = ""; 748 Resources res = mContext.getResources(); 749 double speed = Math.sqrt(mDX * mDX + mDY * mDY); 750 boolean onGoal = (mGoalX <= mX - mLanderWidth / 2 && mX 751 + mLanderWidth / 2 <= mGoalX + mGoalWidth); 752 753 // "Hyperspace" win -- upside down, going fast, 754 // puts you back at the top. 755 if (onGoal && Math.abs(mHeading - 180) < mGoalAngle 756 && speed > PHYS_SPEED_HYPERSPACE) { 757 result = STATE_WIN; 758 mWinsInARow++; 759 doStart(); 760 761 return; 762 // Oddball case: this case does a return, all other cases 763 // fall through to setMode() below. 764 } else if (!onGoal) { 765 message = res.getText(R.string.message_off_pad); 766 } else if (!(mHeading <= mGoalAngle || mHeading >= 360 - mGoalAngle)) { 767 message = res.getText(R.string.message_bad_angle); 768 } else if (speed > mGoalSpeed) { 769 message = res.getText(R.string.message_too_fast); 770 } else { 771 result = STATE_WIN; 772 mWinsInARow++; 773 } 774 775 setState(result, message); 776 } 777 } 778 } 779 780 /** Handle to the application context, used to e.g. fetch Drawables. */ 781 private Context mContext; 782 783 /** Pointer to the text view to display "Paused.." etc. */ 784 private TextView mStatusText; 785 786 /** The thread that actually draws the animation */ 787 private LunarThread thread; 788 789 public LunarView(Context context, AttributeSet attrs) { 790 super(context, attrs); 791 792 // register our interest in hearing about changes to our surface 793 SurfaceHolder holder = getHolder(); 794 holder.addCallback(this); 795 796 // create thread only; it's started in surfaceCreated() 797 thread = new LunarThread(holder, context, new Handler() { 798 @Override 799 public void handleMessage(Message m) { 800 mStatusText.setVisibility(m.getData().getInt("viz")); 801 mStatusText.setText(m.getData().getString("text")); 802 } 803 }); 804 805 setFocusable(true); // make sure we get key events 806 } 807 808 /** 809 * Fetches the animation thread corresponding to this LunarView. 810 * 811 * @return the animation thread 812 */ 813 public LunarThread getThread() { 814 return thread; 815 } 816 817 /** 818 * Standard override to get key-press events. 819 */ 820 @Override 821 public boolean onKeyDown(int keyCode, KeyEvent msg) { 822 return thread.doKeyDown(keyCode, msg); 823 } 824 825 /** 826 * Standard override for key-up. We actually care about these, so we can 827 * turn off the engine or stop rotating. 828 */ 829 @Override 830 public boolean onKeyUp(int keyCode, KeyEvent msg) { 831 return thread.doKeyUp(keyCode, msg); 832 } 833 834 /** 835 * Standard window-focus override. Notice focus lost so we can pause on 836 * focus lost. e.g. user switches to take a call. 837 */ 838 @Override 839 public void onWindowFocusChanged(boolean hasWindowFocus) { 840 if (!hasWindowFocus) thread.pause(); 841 } 842 843 /** 844 * Installs a pointer to the text view used for messages. 845 */ 846 public void setTextView(TextView textView) { 847 mStatusText = textView; 848 } 849 850 /* Callback invoked when the surface dimensions change. */ 851 public void surfaceChanged(SurfaceHolder holder, int format, int width, 852 int height) { 853 thread.setSurfaceSize(width, height); 854 } 855 856 /* 857 * Callback invoked when the Surface has been created and is ready to be 858 * used. 859 */ 860 public void surfaceCreated(SurfaceHolder holder) { 861 // start the thread here so that we don't busy-wait in run() 862 // waiting for the surface to be created 863 thread.setRunning(true); 864 thread.start(); 865 } 866 867 /* 868 * Callback invoked when the Surface has been destroyed and must no longer 869 * be touched. WARNING: after this method returns, the Surface/Canvas must 870 * never be touched again! 871 */ 872 public void surfaceDestroyed(SurfaceHolder holder) { 873 // we have to tell thread to shut down & wait for it to finish, or else 874 // it might touch the Surface after we return and explode 875 boolean retry = true; 876 thread.setRunning(false); 877 while (retry) { 878 try { 879 thread.join(); 880 retry = false; 881 } catch (InterruptedException e) { 882 } 883 } 884 } 885 } 886
