/**************************************************
*                                                 *
*   MarsLanderApplication class: Creates the main *
*      simulator application.                     *
*                                                 *
*   Created by S.Cartwright ©2000                 *
*                                                 *
**************************************************/

package source;

//Import the Sun classes we need
import java.awt.image.*;
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import com.borland.jbcl.layout.*;
import javax.swing.event.*;
import java.applet.*;
import javax.swing.border.*;
import javax.swing.UIManager;

//**********************************************************************************************//
//The main applications class definition

public class MarsLanderApplication extends JFrame implements ActionListener{

//**********************************************************************************************//
//Main panel objects

  XYLayout xYLayout1 = new XYLayout();
  JPanel jPanel1 = new JPanel();
  JSlider jSlider1 = new JSlider();
  JProgressBar jProgressBar1 = new JProgressBar();
  JButton jButton1 = new JButton();
  JLabel jLabel1 = new JLabel();
  TitledBorder titledBorder1;
  JLabel jLabel2 = new JLabel();
  JCheckBox radar = new JCheckBox();
  JLabel jLabel3 = new JLabel();

//**********************************************************************************************//
//Declare and create some of the game objects

  private MonitorEffect mE=new MonitorEffect(1,6);
  private Lander lander=new Lander();
  private Zoom intro=new Zoom(1,5,20),countdown=new Zoom(1,5,20), ending=new Zoom(1,2,100);
  private BufferedImage buffImage=new BufferedImage(360,370,BufferedImage.TYPE_INT_RGB);
  private Graphics bufferedImageHandle,jPanel1ImageHandle;
  private Flash flash=new Flash(true,10,5),panelFlash[]=new Flash[6],verbalWarning=new Flash(false,1,20);
  private Scroller scroller=new Scroller("",
  "                     MARS LANDER By S. Cartwright!                         "+
  "        Use the slider control to alter your Mars Lander's engine thrust, "+
  "so you touch down gently!     Falling too fast will mean you crash. "+
  "See how much fuel you can land with to get todays high score!"
  ,"",40,3);
  private Audio sound=new Audio();
  private MissionTimer missionTimer=new MissionTimer();
  private AsteroidDisplay asteroids=new AsteroidDisplay();
  private Lightning lightning=new Lightning();
  private HighScores scoreTable;

  private Timer gameTimer;
  private Image dbackground,nbackground,dforeground,window,dparalax,slider,fuelgage,fuelback,beacon,dlandingPad,
                nforeground,nparalax,nlandingPad,rforeground,rparalax,rlandingPad,dust;
  private AudioClip lowThrust,mediumThrust,highThrust,maxThrust,say3,say2,say1,sayGo,
                    pullUp,lowFuel,prepareToLand,finalApproach,lookingGood,asteroid;

  private Image monitorScreenBlock,digitsBlock,introPicBlock,countDownBlock,lightBulbBlock,reportBlock;
  private Sprite monitorScreen,introPic,countDown,lightBulb,report;
  private GraphicalDigits digits;

//**********************************************************************************************//
//Declare Toolbar objects

  JMenuBar bar;
  JMenu fileMenu,effectsMenu,diffMenu,soundMenu;
  JCheckBoxMenuItem effectsItems[];
  JRadioButtonMenuItem diffItems[],soundItems[],effectsRadioItems[];
  ButtonGroup diffGroup,effectsGroup,soundGroup;

//**********************************************************************************************//
//Define local variables

  boolean _CLOSING=false,highScores=true,oldMenuBusy=false;
  float thrust;
  int landerPhase,lastWarning=0,eta=0,highScoreYPos=0,menuOn=0,oldMenuOn=0,dustXPos=0;
  int warningOverideTimer=0, asteroidStrikeTimer=10;//(int)(Math.random()%1000)+100;
  boolean saidPrepareToLand=false,saidFinalApproach=false,saidLookingGood=false;
  boolean isDay=true,dustCloudOn=false,radiationOn=true,asteroidOn=false;

//**********************************************************************************************//
//Run the application...
//The application container class is also the main game object class as we
//don't have to have multiple instances.
  public static void main(String[] args)
    {
    //Try to change the look and feel of the window components
    try
      {
      UIManager.setLookAndFeel(UIManager.getCrossPlatformLookAndFeelClassName());
      } catch(Exception e) {}
    //Instantiate this class
    new MarsLanderApplication();
    }

//**********************************************************************************************//
//Construct the object

  public MarsLanderApplication()
    {
    for(int j=0;j<50;j++) System.err.println();
    System.err.println("ENGINE LOGGER V 1.0");
    System.err.print("--------------------------------------------------------------------------------");
    //Add on the system menu
    createAndAddSystemMenu();
    //Allow this object to trap window events
    enableEvents(AWTEvent.WINDOW_EVENT_MASK);
    //Print a stack trace for any exceptions during initialisation
    try{jbInit();} catch(Exception e){e.printStackTrace();}
    //Setup global variables
    initialiseApplicationEnvironment();
    //Create the application window, and grab graphics handles
    createWindow();
    //Automate this objects execution, before we finish the constructor
    start();
    }

//**********************************************************************************************//
//Define all the system menu items, and add them to the main application window

  private void createAndAddSystemMenu()
  {
  //Create and attach the system menu bar
  System.err.println("Hooking application with JMenu.");
  bar=new JMenuBar();
  setJMenuBar(bar);

  //Define all four menus
  fileMenu=new JMenu("File");
  fileMenu.setMnemonic('F');
  effectsMenu=new JMenu("Effects");
  effectsMenu.setMnemonic('E');
  diffMenu=new JMenu("Difficulty");
  diffMenu.setMnemonic('D');
  soundMenu=new JMenu("Sound");
  soundMenu.setMnemonic('S');

  //Define the details for the File menu
  //Define the About option
  JMenuItem aboutItem=new JMenuItem("About...");
  aboutItem.setMnemonic('A');
  //Add an anonymous actionPerformed method to the menu item to display a message
  aboutItem.addActionListener(
    new ActionListener(){
      public void actionPerformed(ActionEvent e)
        {
        System.err.print("--------------------------------------------------------------------------------");
        System.err.println("Displaying About information box.");
        JOptionPane.showMessageDialog(MarsLanderApplication.this,"       Mars Lander Simulation Game"+
        "\nWritten and designed by S.Cartwright."+
        "\n  For a second year Java assignment."
        ,"About Mars Lander V 1.00",JOptionPane.PLAIN_MESSAGE);
        }
      }
    );
  //Add the About option to the file menu
  fileMenu.add(aboutItem);

  //Define the Exit option
  JMenuItem exitItem=new JMenuItem("Exit!");
  exitItem.setMnemonic('x');
  exitItem.addActionListener(
    new ActionListener(){
      public void actionPerformed(ActionEvent e)
        {
        System.err.print("--------------------------------------------------------------------------------");
        System.err.println("Closing application");
        stylisedCloseWindow();
        scoreTable.save();
        System.exit(0);
        }
      }
    );
  //Add the Exit option to the file menu
  fileMenu.add(exitItem);

  //Define the Effects options
  final String sn[]={"Sunspot Radiation","Dust Clouds","Asteroids"};
  String st[]={"Day","Night"};
  effectsRadioItems=new JRadioButtonMenuItem[st.length];
  effectsGroup=new ButtonGroup();
  for(int i=0;i<st.length;i++)
    {
    //Create a new item
    effectsRadioItems[i]=new JRadioButtonMenuItem(st[i]);
    //And add it to the Difficulty menu
    effectsMenu.add(effectsRadioItems[i]);
    //Also add it to the diffGroup object, that ensures only 1 option is selected
    effectsGroup.add(effectsRadioItems[i]);
    }
  effectsRadioItems[0].setSelected(true);

  effectsMenu.addSeparator();
  effectsItems=new JCheckBoxMenuItem[sn.length+1];
  for(int i=0;i<sn.length;i++)
    {
    effectsItems[i]=new JCheckBoxMenuItem(sn[i]);
    effectsMenu.add(effectsItems[i]);
    }
  effectsMenu.addSeparator();
  effectsItems[sn.length]=new JCheckBoxMenuItem("Random Events");
  effectsMenu.add(effectsItems[sn.length]);
  effectsItems[sn.length].addActionListener(
    new ActionListener(){
      public void actionPerformed(ActionEvent e)
        {
        if(effectsItems[sn.length].isSelected())
          {
          effectsRadioItems[0].setEnabled(false);
          effectsRadioItems[1].setEnabled(false);
          }
          else
          {
          effectsRadioItems[0].setEnabled(true);
          effectsRadioItems[1].setEnabled(true);
          }
        }
      }
    );

  //Define the Difficulty options
  String tn[]={"Easy","Average","Hard"};
  diffItems=new JRadioButtonMenuItem[tn.length];
  diffGroup=new ButtonGroup();
  for(int i=0;i<tn.length;i++)
    {
    //Create a new item
    diffItems[i]=new JRadioButtonMenuItem(tn[i]);
    //And add it to the Difficulty menu
    diffMenu.add(diffItems[i]);
    //Also add it to the diffGroup object, that ensures only 1 option is selected
    diffGroup.add(diffItems[i]);
    }
  //Finally set the game to Easy
  diffItems[0].setSelected(true);

  //Define the Sound options
  String rn[]={"On","Off"};
  soundItems=new JRadioButtonMenuItem[rn.length];
  soundGroup=new ButtonGroup();
  for(int i=0;i<rn.length;i++)
    {
    //Create a new item
    soundItems[i]=new JRadioButtonMenuItem(rn[i]);
    //And add it to the Sound Menu
    soundMenu.add(soundItems[i]);
    //Also add it to the soundGroup object, that ensures only 1 option is selected
    soundGroup.add(soundItems[i]);
    }
  //Finally set the Sound to On
  soundItems[0].setSelected(true);

  soundItems[1].addActionListener(
    new ActionListener(){
    //Add an action listener to turn off all looping sounds if the sound is turned off
      public void actionPerformed(ActionEvent e)
        {
        sound.stopAll();
        }
      }
    );

  //Add all of the sub menu's to the main system menu for display
  bar.add(fileMenu);
  bar.add(effectsMenu);
  bar.add(diffMenu);
  bar.add(soundMenu);
  System.err.println("Success!");
  }

//**********************************************************************************************//
//Create the window here...

  private void createWindow()
    {
    //Resize, validate, and set the application window to visible
    setSize(445,545);
    validate();
    setVisible(true);
    //Then get the Buffers handle and the Jpanel's handle
    jPanel1ImageHandle=jPanel1.getGraphics();
    bufferedImageHandle=buffImage.getGraphics();
    asteroids.changeGraphicsHandle(bufferedImageHandle);
    lightning.changeGraphicsHandle(bufferedImageHandle);
    bufferedImageHandle.setFont(new java.awt.Font("Serif", 1, 25));
    }

//**********************************************************************************************//
//Setup the global variables

  private void initialiseApplicationEnvironment()
    {
    //Keeps track of the current game phase
    landerPhase=-1;
    //Initialise the flashing console lights
    int timerOn[]={10,12,14,16,18};
    int timerOff[]={5,5,5,5,5};
    for
      (
      int c=0;c<5;
      panelFlash[c]=new Flash(true,timerOn[c],timerOff[c++])
      );
    //Load in the high score table
    try
      {
      System.err.print("--------------------------------------------------------------------------------");
      System.err.println("Attempting to load high score table.");
      scoreTable=new HighScores();
      }
    catch(Exception e)
      {
      System.out.println("High Score table Exception: "+e);
      }
    }

//**********************************************************************************************//
//Keeps track of the system menu, halting the game if the menu is being used.

  public boolean menuBusy()
  {
  //true=if any menu has the focus, false otherwise
  boolean newMenuBusy=fileMenu.isSelected()||effectsMenu.isSelected()||diffMenu.isSelected()||soundMenu.isSelected();
  //If any menu has JUST gained program focus, then pause the game
  if(newMenuBusy==true&&oldMenuBusy==false)
    {
    System.err.print("--------------------------------------------------------------------------------");
    System.err.println("Menu bar is activated, dissabling associated timers.");
    missionTimer.pause();
    lander.pause();
    }
  //If all the menus have JUST lost the program focus, resume the game
  if(newMenuBusy==false&&oldMenuBusy==true)
    {
    System.err.print("--------------------------------------------------------------------------------");
    System.err.println("Menu bar is deactivated, enabling associated timers.");
    missionTimer.resume();
    lander.resume();
    }
  //Remember old values
  oldMenuBusy=newMenuBusy;
  oldMenuOn=menuOn;
  //And return the state of the system menu usage
  return(newMenuBusy);
  }

//**********************************************************************************************//
//Trap event messages, and branch depending on program phase

  public void actionPerformed(ActionEvent a)
    {
    //Do nothing if the system menu has the focus
    if(menuBusy()) return;
    //Find out if the scrolling message needs updating, and if so update it
    if(landerPhase!=-1) if(scroller.scrollerReady()) {jLabel1.setText(scroller.getScroller());};
    //Update the flashing beacon on the house
    flash.updateFlash();
    //Update the console flashiyeah ng lights
    for(int c=0;c<5;panelFlash[c++].updateFlash());
    //Handle the current game phase
    switch(landerPhase)
      {
      case -1: loadResources();   break;//Load the graphics and sounds
      case  0: processIntro();    break;//Display the introduction on screen
      case  1: processCountDown();break;//Display the countdown
      case  2: processGame();     break;//Play the game
      case  3: processEnd();      break;//Display the end sequence
      }
    }

//**********************************************************************************************//
//Demand next game phase, also performs housekeeping between phases

  public void landerChoices()
    {
    //Examine the state of the menu options when we start a simulation
    //and set the games flags to mirror those selections
    System.err.print("--------------------------------------------------------------------------------");
    System.err.println("-----------------New lander game about to start!");
    if(effectsItems[3].isSelected())
      {
      System.err.println("-----------------Using random results.");
      if(!effectsItems[0].isSelected()) System.err.println("-Player has dissabled RADIATION option, so ignoring.");
      if(!effectsItems[1].isSelected()) System.err.println("-Player has dissabled DUSTCLOUD option, so ignoring.");
      if(!effectsItems[2].isSelected()) System.err.println("-Player has dissabled ASTEROIDS option, so ignoring.");
      isDay=(Math.random()<.49);
      radiationOn=(Math.random()<.49&&effectsItems[0].isSelected());
      dustCloudOn=(Math.random()<.49&&effectsItems[1].isSelected());
      asteroidOn=(Math.random()<.49&&effectsItems[2].isSelected());
      }
      else
      {
      System.err.println("-----------------Using player selections.");
      isDay=effectsRadioItems[0].isSelected();
      radiationOn=effectsItems[0].isSelected();
      dustCloudOn=effectsItems[1].isSelected();
      asteroidOn=effectsItems[2].isSelected();
      }
    if(diffItems[0].isSelected()) lander.setDifficulty(Lander.EASY);
      else
      if(diffItems[1].isSelected()) lander.setDifficulty(Lander.AVERAGE);
        else
        if(diffItems[2].isSelected()) lander.setDifficulty(Lander.HARD);
    System.err.println("-----------------Proceeding with these options:");
    System.err.println("-----------------It is "+(isDay?"day":"nigh")+"time.");
    System.err.println("-----------------Radiation is "+(radiationOn?"on":"off")+".");
    System.err.println("-----------------The Dust cloud is "+(dustCloudOn?"on":"off")+".");
    System.err.println("-----------------The Asteroids are "+(asteroidOn?"on":"off")+".");
    System.err.print("-----------------The game difficulty is set to ");
    if(diffItems[0].isSelected()) System.err.println("easy.");
      else
      if(diffItems[1].isSelected()) System.err.println("average.");
        else
        if(diffItems[2].isSelected()) System.err.println("hard.");
    System.err.print("--------------------------------------------------------------------------------");
    }

//**********************************************************************************************//
//Demand next game phase, also performs housekeeping between phases

  public void nextLanderPhase()
    {
    switch(landerPhase++)
      {
      case -1://Ending load graphics
              //So make the start button visible, and remove the slider
              jButton1.setVisible(true);
              jSlider1.setVisible(false);
              //Start the mission timer, just for show
              missionTimer.start();
              //Repaint the window, to reflect the components updated state
              repaint();
              //end
              break;
      case 0://Ending processIntro
              //Pass the users choices from the system menu
              landerChoices();
              //For nighttime we need to draw a black sky, so make colour black now
              bufferedImageHandle.setColor(Color.black);
              //So make the start button invisible, and add the slider
              jButton1.setVisible(false);
              jSlider1.setVisible(true);
              //Set the slider to 0, if the user is currently holding the slider
              //this will not work
              jSlider1.setValue(0);
              //Set the thrust controll to 0
              jProgressBar1.setValue(0);
              //reset the mission timer to 0:0:0
              missionTimer.reset();
              //Repaint the window, to reflect the components updated state
              repaint();
              //end
              break;
      case 1://Ending processCountdown
              //Ensure the thrust value is 0
              thrust=0;
              //Reset the countdown object for reuse
              countdown.resetZoom();
              //Reset the asteroids
              asteroids.resetAsteroids();
              //Reset radar
              radar.setSelected(false);
              //Create a new lander
              lander.newLander();
              //Start the mission timer
              missionTimer.start();
              //and start the lander thread
              lander.start();
              break;
      case 2://Ending processGame
              //ensure any looping sound has stopped
              sound.stopAll();
              //and make the start button visible, and remove the slider
              jButton1.setVisible(true);
              jSlider1.setVisible(false);
              jButton1.setText("Play");
              jSlider1.setValue(0);
              jProgressBar1.setValue(0);
              //Stop the lander thread
              lander.stop();
              //reset the misison timer(also stops it)
              missionTimer.stop();
              //Repaint the window, to reflect the components updated state
              repaint();
              break;
      case 3://Ending processEnd
              //Set the radiation effect back on for the attract mode
              radiationOn=true;
              //ensure thrust is back at 0
              thrust=0;
              jButton1.setText("Start");
              jSlider1.setValue(0);
              jProgressBar1.setValue(0);
              //Get high score!
              if(lander.getStatus()==Lander.LANDED)
                getNewHighScore();
              //Reset the intro animation
              intro.resetZoom();
              ending.resetZoom();
              //and start the mission timer for a nice intro effect
              missionTimer.reset();
              missionTimer.start();
              //Repaint the window, to reflect the components updated state
              repaint();
              break;
      }
    //If we've gone through all the game phases, then start again
    if(landerPhase==4) landerPhase=0;
    System.err.print("--------------------------------------------------------------------------------");
    switch(landerPhase)
      {
      case 0: System.err.println("Displaying introduction and high score table.");break;
      case 1: System.err.println("Displaying countdown.");break;
      case 2: System.err.println("Playing the game");break;
      case 3: System.err.println("Displaying the end sequence.");break;
      }
    }

//**********************************************************************************************//
//Make this objects timer if neccessery, and start it

  public void getNewHighScore()
    {
    String letters;
    //See if the score just acheived is a high score
    if(scoreTable.isAHighScore((int)lander.getFuel()*2))
      {
      //If it is, ask the user for their initials...
      letters=JOptionPane.showInputDialog(this,"Please enter 3 initials!","A New High Score!",JOptionPane.OK_OPTION);
      if(letters!=null) scoreTable.addHighScore(letters,(int)lander.getFuel()*2);
      }
    }

//**********************************************************************************************//
//Make this objects timer if neccessery, and start it

  public void start()
    {
    if(gameTimer==null)
      {
      System.err.print("--------------------------------------------------------------------------------");
      System.err.println("Creating primary game timer.");
      gameTimer=new Timer(30,this);
      System.err.println("---(Graphics Engine will"+(gameTimer.isCoalesce()?" not":"")+" attempt to update skipped frames.)---");
      if(gameTimer.isCoalesce())
        System.err.println("---(Therefore Graphics Engine may run slower on low spec machines.)---");
      }
    System.err.println("Starting primary game timer.\nGraphics Engine attempting to run at "+1000/gameTimer.getDelay()+" FPS.");
    gameTimer.start();
    }

//**********************************************************************************************//
//Stop this objects timer

  public void stop()
    {
    System.err.println("Stopping primary game timer.");
    gameTimer.stop();
    }

//**********************************************************************************************//
//Process the introduction request, which is taken care of by updateIntroDisplay()

  public void processIntro()
    {
    updateIntroDisplay();
    }

//**********************************************************************************************//
//Process the countdown request, which is taken care of by updateCountdownDisplay()

  public void processCountDown()
    {
    updateCountdownDisplay();
    }

//**********************************************************************************************//
//Process the main game loops "Warning" requirements, by using a cascade style warning mechinism
//The warnings are in order of importance, the most important first

  public void updateWarnings()
    {
    boolean Warned=false;
    if((lander.getStatus()!=Lander.FLYING)||(_CLOSING)) return;
    if(warningOverideTimer!=0)
      {
      --warningOverideTimer;
      return;
      }
    verbalWarning.updateFlash();
    if((lander.getVelocity()<-38)||((lander.getVelocity()<-10)&&(lander.getAltitude()<250)))
      {
      if(lastWarning!=1)
        {
        jLabel2.setForeground(Color.red);
        jLabel2.setText("Speed too high!");
        }
      if(verbalWarning.getFlashIsOn()&&soundItems[0].isSelected()) pullUp.play();
      lastWarning=1; Warned=true;
      }
    if((lander.getFuel()<100)&&!Warned)
      {
      if(lastWarning!=2)
        {
        jLabel2.setForeground(Color.red);
        jLabel2.setText("Low Fuel!");
        }
      if(verbalWarning.getFlashIsOn()&&soundItems[0].isSelected()) lowFuel.play();
      lastWarning=2; Warned=true;
      }

    if((lander.getAltitude()<100)&&(lander.getVelocity()>-5))
      {
      if(!Warned)
        {
        if(lastWarning!=3)
          {
          jLabel2.setForeground(Color.green);
          jLabel2.setText("Looking Good!");
          }
        if(!saidLookingGood)
          {
          if(soundItems[0].isSelected()&&soundItems[0].isSelected()) lookingGood.play();
          saidLookingGood=true;
          }
        lastWarning=3; Warned=true;
        }
      }
      else
      saidLookingGood=false;

    if(lander.getAltitude()<500)
      {
      if(!Warned)
        {
        if(lastWarning!=4)
          {
          jLabel2.setForeground(Color.orange);
          jLabel2.setText("Final Approach!");
          }
        if(!saidFinalApproach)
          {
          if(soundItems[0].isSelected()) finalApproach.play();
          saidFinalApproach=true;
          }
        lastWarning=4; Warned=true;
        }
      }
      else
      saidFinalApproach=false;

    if(lander.getAltitude()<1500)
      {
      if(!Warned)
        {
        if(lastWarning!=5)
          {
          jLabel2.setForeground(Color.orange);
          jLabel2.setText("Prepare to land!");
          }
        if(!saidPrepareToLand)
          {
          if(soundItems[0].isSelected()) prepareToLand.play();
          saidPrepareToLand=true;
          }
        lastWarning=5; Warned=true;
        }
      }
      else
      saidPrepareToLand=false;

    if((lastWarning!=0)&&!Warned)
      {
      if(lastWarning!=0)
        {
        jLabel2.setForeground(Color.green);
        jLabel2.setText("Mission OK!");
        }
      lastWarning=0;
      }
    }

//**********************************************************************************************//
//Process the game request, this is called directly from the actionPerformed method

  public void processGame()
    {
    if((lander.getFuel()<1.0)&&(jProgressBar1.getValue()>0))
      {
      jProgressBar1.setValue(jProgressBar1.getValue()-1);
      jProgressBar1.setForeground(new Color(255,0,0));
      sound.stopAll();
      }
      else
      {
      if(lander.getFuel()!=0)
        {
        if(thrust==0) sound.stopAll();
        if(thrust>0&&thrust<33&&soundItems[0].isSelected()) sound.requestLoop(lowThrust);
        if(thrust>32&&thrust<66&&soundItems[0].isSelected()) sound.requestLoop(mediumThrust);
        if(thrust>65&&thrust<100&&soundItems[0].isSelected()) sound.requestLoop(highThrust);
        if(thrust==100)
          {
          if(soundItems[0].isSelected()) sound.requestLoop(maxThrust);
          lander.setFuel( (int) (lander.getFuel()-1) );
          }
        }
      }
    if(lander.getStatus()!=Lander.FLYING)
      {
      if(!radar.isSelected()&&dustCloudOn) lander.setStatus(Lander.CRASHED);
      if(lander.getStatus()==Lander.CRASHED&&soundItems[0].isSelected())
        asteroid.play();
        else
        lookingGood.play();
      nextLanderPhase();
      }
    if(asteroidOn&&!_CLOSING)
      {
      if(--asteroidStrikeTimer==0)
        {
        asteroidStrikeTimer=(int)(Math.random()%300)+200;
        warningOverideTimer=40; lastWarning=-1;
        lander.setVelocity((int)(lander.getVelocity()-(10-(int)(Math.random()*20))));
        jLabel2.setForeground(Color.red);
        jLabel2.setText("Asteroid Strike!");
        if(soundItems[0].isSelected()) asteroid.play();
        }
      }
    updateWarnings();
    updateInGameDisplay(lander.getAltitude());
    }

//**********************************************************************************************//
//Process the game over request, which is dependent on the games outcome

  public void processEnd()
    {
    if(lander.getStatus()==Lander.CRASHED) doLanderCrashed();
    if(lander.getStatus()==Lander.LANDED) doLanderLanded();
    }

//**********************************************************************************************//
//Crash animator...

  public void doLanderCrashed()
    {
    float fvalue=300,scale;
    if(radar.isSelected())
      {
      bufferedImageHandle.clearRect(25,19,266,262);
      bufferedImageHandle.drawImage(rforeground,10,(int)(820-(fvalue*2.8)),this);
      if(fvalue>220) bufferedImageHandle.drawImage(rparalax,200,(int)(1800-(fvalue*7)),this);
      if(fvalue>220) bufferedImageHandle.drawImage(rlandingPad,0,(int)(5330-(fvalue*18)),this);
      }
      else
      {
      if(isDay)
        {
        bufferedImageHandle.drawImage(dbackground,0,(int)-(fvalue*1.5),this);
        bufferedImageHandle.drawImage(dforeground,10,(int)(820-(fvalue*2.8)),this);
        if(fvalue>220) bufferedImageHandle.drawImage(dparalax,200,(int)(1800-(fvalue*7)),this);
        if(fvalue>220) bufferedImageHandle.drawImage(dlandingPad,0,(int)(5330-(fvalue*18)),this);
        }
        else
        {
        bufferedImageHandle.drawImage(nbackground,0,(int)-(fvalue*1.5),this);
        bufferedImageHandle.drawImage(nforeground,10,(int)(820-(fvalue*2.8)),this);
        if(fvalue>220) bufferedImageHandle.drawImage(nparalax,200,(int)(1800-(fvalue*7)),this);
        if(fvalue>220) bufferedImageHandle.drawImage(nlandingPad,0,(int)(5330-(fvalue*18)),this);
        }
      }

    updateAnimation();
    ending.updateZoom();
    if(ending.getImageNumber()==1)
      {
      ending.resetZoom();
      nextLanderPhase();
      return;
      }
    scale=ending.getScaling();
    bufferedImageHandle.drawImage(fuelback,16,307,this);
    bufferedImageHandle.drawImage(fuelgage,-28-(int)((500-lander.getFuel())/1.8),308,this);
    report.drawSprite(165-(int)(115*scale),140,scale,scale,1);
    bufferedImageHandle.drawImage(window,0,0,this);
    bufferedImageHandle.drawImage(slider,322,20+(int)(fvalue*0.85),this);
    updateAnimation();
    jPanel1ImageHandle.drawImage(buffImage,0,0,this);
    }

//**********************************************************************************************//
//Landed animator...

  public void doLanderLanded()
    {
    float fvalue=300,scale;
    if(radar.isSelected())
      {
      bufferedImageHandle.clearRect(25,19,266,262);
      bufferedImageHandle.drawImage(rforeground,10,(int)(820-(fvalue*2.8)),this);
      if(fvalue>220) bufferedImageHandle.drawImage(rparalax,200,(int)(1800-(fvalue*7)),this);
      if(fvalue>220) bufferedImageHandle.drawImage(rlandingPad,0,(int)(5330-(fvalue*18)),this);
      }
      else
      {
      if(isDay)
        {
        bufferedImageHandle.drawImage(dbackground,0,(int)-(fvalue*1.5),this);
        bufferedImageHandle.drawImage(dforeground,10,(int)(820-(fvalue*2.8)),this);
        if(fvalue>220) bufferedImageHandle.drawImage(dparalax,200,(int)(1800-(fvalue*7)),this);
        if(fvalue>220) bufferedImageHandle.drawImage(dlandingPad,0,(int)(5330-(fvalue*18)),this);
        }
        else
        {
        bufferedImageHandle.drawImage(nbackground,0,(int)-(fvalue*1.5),this);
        bufferedImageHandle.drawImage(nforeground,10,(int)(820-(fvalue*2.8)),this);
        if(fvalue>220) bufferedImageHandle.drawImage(nparalax,200,(int)(1800-(fvalue*7)),this);
        if(fvalue>220) bufferedImageHandle.drawImage(nlandingPad,0,(int)(5330-(fvalue*18)),this);
        }
      }
    updateAnimation();
    ending.updateZoom();
    if(ending.getImageNumber()==1)
      {
      ending.resetZoom();
      nextLanderPhase();
      return;
      }
    scale=ending.getScaling();
    bufferedImageHandle.drawImage(fuelback,16,307,this);
    bufferedImageHandle.drawImage(fuelgage,-28-(int)((500-lander.getFuel())/1.8),308,this);
    report.drawSprite(165-(int)(115*scale),140,scale,scale,0);
    bufferedImageHandle.drawImage(window,0,0,this);
    bufferedImageHandle.drawImage(slider,322,20+(int)(fvalue*0.85),this);
    updateAnimation();
    jPanel1ImageHandle.drawImage(buffImage,0,0,this);
    }

//**********************************************************************************************//
//Draw the gradient background for the 'loading graphics' screen

  private void drawGradient()
    {
    for(int c=0;c<this.getHeight();c++)
      {
      this.setForeground(new Color(0,(int)(((float)c/(float)getHeight())*255.0),0));
      this.getGraphics().drawLine(0,c,getWidth(),c);
      }
    this.setForeground(new Color(0,255,0));
    }

//**********************************************************************************************//
//Draw the progress bar for the loading screen

  private void drawProgressBar(int progress,int total)
    {
    this.getGraphics().drawString("LOADING GRAPHICS",160,180);
    this.getGraphics().drawRect(120,190,200,20);
    if(progress<0) progress=0;
    if(progress>100) progress=100;
    if((progress==0)||(total==0)) return;
    this.getGraphics().fillRect(122,192,(int)(((float)progress/(float)total)*200.0)-3,17);
    }

//**********************************************************************************************//
//Load all the graphics and sound here...

  private void loadResources()
    {
    String relativeSound=".\\audio\\",relativeGfx=".\\graphics\\";
    MediaTracker tracker=new MediaTracker(this);
    Toolkit toolkit=getToolkit().getDefaultToolkit();

    drawGradient();
    drawProgressBar(0,0);
    System.err.print("--------------------------------------------------------------------------------");
    System.err.print("Attempting to load resources.");

    lowThrust         =sound.getAudio(relativeSound+"low.wav");
    mediumThrust      =sound.getAudio(relativeSound+"med.wav");
    highThrust        =sound.getAudio(relativeSound+"high.wav");
    maxThrust         =sound.getAudio(relativeSound+"max.wav");
    say3              =sound.getAudio(relativeSound+"3.wav");
    say2              =sound.getAudio(relativeSound+"2.wav");
    say1              =sound.getAudio(relativeSound+"1.wav");
    sayGo             =sound.getAudio(relativeSound+"go.wav");
    pullUp            =sound.getAudio(relativeSound+"pullup.wav");
    lowFuel           =sound.getAudio(relativeSound+"lowfuel.wav");
    prepareToLand     =sound.getAudio(relativeSound+"prepland.wav");
    finalApproach     =sound.getAudio(relativeSound+"finapp.wav");
    lookingGood       =sound.getAudio(relativeSound+"good.wav");
    asteroid          =sound.getAudio(relativeSound+"asteroid.wav");

    //Load daytime things
    dbackground       =toolkit.getImage(relativeGfx+"dbackground.gif");
    dforeground       =toolkit.getImage(relativeGfx+"dforeground.gif");
    dparalax          =toolkit.getImage(relativeGfx+"dparalax.gif");
    dlandingPad       =toolkit.getImage(relativeGfx+"dlandingpad.gif");

    //Load nightime things
    nbackground       =toolkit.getImage(relativeGfx+"nbackground.gif");
    nforeground       =toolkit.getImage(relativeGfx+"nforeground.gif");
    nparalax          =toolkit.getImage(relativeGfx+"nparalax.gif");
    nlandingPad       =toolkit.getImage(relativeGfx+"nlandingpad.gif");

    //LoadRadar things
    rforeground       =toolkit.getImage(relativeGfx+"rforeground.gif");
    rparalax          =toolkit.getImage(relativeGfx+"rparalax.gif");
    rlandingPad       =toolkit.getImage(relativeGfx+"rlandingpad.gif");

    //Load the rest
    window            =toolkit.getImage(relativeGfx+"window.gif");
    slider            =toolkit.getImage(relativeGfx+"slider.gif");
    fuelgage          =toolkit.getImage(relativeGfx+"fuelgage.gif");
    fuelback          =toolkit.getImage(relativeGfx+"fuelback.gif");
    beacon            =toolkit.getImage(relativeGfx+"beacon.gif");
    dust              =toolkit.getImage(relativeGfx+"dust.gif");

    //Load the sprite animation blocks
    monitorScreenBlock=toolkit.getImage(relativeGfx+"monitorBlock.gif");
    introPicBlock     =toolkit.getImage(relativeGfx+"introBlock.gif");
    digitsBlock       =toolkit.getImage(relativeGfx+"digits.gif");
    countDownBlock    =toolkit.getImage(relativeGfx+"countDownBlock.gif");
    lightBulbBlock    =toolkit.getImage(relativeGfx+"lightBulbBlock.gif");
    reportBlock       =toolkit.getImage(relativeGfx+"reportBlock.gif");

    tracker.addImage(dbackground,0);
    tracker.addImage(nbackground,1);
    tracker.addImage(dforeground,2);
    tracker.addImage(nforeground,3);
    tracker.addImage(rforeground,4);
    tracker.addImage(window,5);
    tracker.addImage(dparalax,6);
    tracker.addImage(nparalax,7);
    tracker.addImage(rparalax,8);
    tracker.addImage(fuelback,9);
    tracker.addImage(slider,10);
    tracker.addImage(fuelgage,11);
    tracker.addImage(fuelback,12);
    tracker.addImage(monitorScreenBlock,13);
    tracker.addImage(introPicBlock,14);
    tracker.addImage(digitsBlock,15);
    tracker.addImage(beacon,16);
    tracker.addImage(dust,17);
    tracker.addImage(countDownBlock,18);
    tracker.addImage(lightBulbBlock,19);
    tracker.addImage(dlandingPad,20);
    tracker.addImage(nlandingPad,21);
    tracker.addImage(rlandingPad,22);

    int numberLoaded=0;
    try
      {
      do{
        numberLoaded=0;
        for(int ctr=0;ctr<14;numberLoaded+=tracker.checkID(ctr++)?1:0)
        drawProgressBar(numberLoaded,23);
        if(tracker.isErrorAny())
          reportFatalError("Some resources could not be loaded.\nReinstall Mars Lander and try again!");
        }while(!tracker.waitForAll(10));
      }catch(Exception e){reportFatalError("Low level resource error:\n"+e.getMessage());};
    tracker=null;System.gc();

    drawProgressBar(1,1);
    declareSprites();
    this.getContentPane().setBackground(new java.awt.Color(204, 204, 204));
    this.setForeground(Color.lightGray);
    System.err.println("\nSuccess! Resources are loaded.");
    System.err.print("--------------------------------------------------------------------------------");
    nextLanderPhase();
    }

//**********************************************************************************************//
//If there is an error we can't fix, report it to the user and end

  private void reportFatalError(String error)
    {
    this.setBackground(Color.red);
    this.setSize(0,0);
    JOptionPane.showMessageDialog(null,error+"\nClick OK to end the program!","Mars Lander Fatal Error!",
    JOptionPane.ERROR_MESSAGE);
    System.exit(1);
    }

//**********************************************************************************************//
//Using the Images we've loaded, convert some of them into sprites...

  private void declareSprites()
    {
    monitorScreen=new Sprite(monitorScreenBlock,57,51,111,69,8,buffImage,this);
    introPic=new Sprite(introPicBlock,223,117,4,buffImage,this);
    countDown=new Sprite(countDownBlock,223,117,4,buffImage,this);
    lightBulb=new Sprite(lightBulbBlock,20,20,2,buffImage,this);
    report=new Sprite(reportBlock,224,117,2,buffImage,this);

    int[] kerning={11,7,12,11,13,11,12,12,14,12,15};
    digits=new GraphicalDigits(digitsBlock,20,20,kerning,buffImage,this);
    digits.setNoKerningSpace(12);
    }

//**********************************************************************************************//
//Component initialization...

  private void jbInit() throws Exception
  {
    titledBorder1 = new TitledBorder("");
    xYLayout1.setHeight(519);
    xYLayout1.setWidth(467);
    this.getContentPane().setLayout(xYLayout1);
    this.getContentPane().setBackground(new java.awt.Color(204, 204, 204));
    this.setForeground(Color.lightGray);
    this.setTitle("  Mars Lander!");
    jSlider1.setValue(0);
    jSlider1.setDoubleBuffered(true);
    jSlider1.addChangeListener
      (
      new javax.swing.event.ChangeListener()
        {
        public void stateChanged(ChangeEvent e)
          {
          jSlider1_stateChanged(e);
          }
        }
      );
    jButton1.setText("Start");
    jButton1.addActionListener
      (
      new java.awt.event.ActionListener()
        {
        public void actionPerformed(ActionEvent e)
          {
          jButton1_actionPerformed(e);
          }
        }
      );
    jProgressBar1.setOrientation(JProgressBar.VERTICAL);
    jProgressBar1.setBorder(BorderFactory.createLoweredBevelBorder());
    jProgressBar1.setDoubleBuffered(true);
    jProgressBar1.setOpaque(false);
    jLabel1.setFont(new java.awt.Font("Serif", 1, 20));
    jLabel1.setBorder(BorderFactory.createLoweredBevelBorder());
    jLabel1.setHorizontalAlignment(SwingConstants.CENTER);
    jLabel1.setHorizontalTextPosition(SwingConstants.CENTER);
    jLabel2.setBackground(Color.darkGray);
    jLabel2.setFont(new java.awt.Font("Dialog", 1, 20));
    jLabel2.setForeground(Color.green);
    jLabel2.setBorder(BorderFactory.createEtchedBorder());
    jLabel2.setOpaque(true);
    jLabel2.setHorizontalAlignment(SwingConstants.CENTER);
    jLabel2.setHorizontalTextPosition(SwingConstants.CENTER);
    jLabel2.setText("Mission OK!");
    radar.setDoubleBuffered(true);
    radar.setOpaque(false);
    radar.setContentAreaFilled(false);
    radar.setBorder(null);
    radar.setHorizontalAlignment(SwingConstants.CENTER);
    radar.setFont(new java.awt.Font("Dialog", 1, 12));
    jLabel3.setFont(new java.awt.Font("Dialog", 1, 12));
    jLabel3.setText("RADAR");
    this.getContentPane().add(jPanel1, new XYConstraints(61, 17, 360, 370));
    this.getContentPane().add(jProgressBar1, new XYConstraints(35, 58, 24, 233));
    this.getContentPane().add(jSlider1, new XYConstraints(90, 421, 265, -1));
    this.getContentPane().add(jButton1, new XYConstraints(184, 418, 71, 29));
    this.getContentPane().add(jLabel1, new XYConstraints(21, 451, 402, 32));
    this.getContentPane().add(jLabel2, new XYConstraints(93, 390, 257, 23));
    this.getContentPane().add(radar, new XYConstraints(355, 410, 21, 16));
    this.getContentPane().add(jLabel3, new XYConstraints(374, 403, 55, 31));
  }

//**********************************************************************************************//
//If the user wishes to quit, this method handles the dialog display and informs the
//rest of the program.

  private boolean userIsQuiting()
    {
    int tempSlider=jSlider1.getValue(),option;
    System.err.print("--------------------------------------------------------------------------------");
    System.err.println("Player wishes to quit,confirmation dialog box opening.");
    jSlider1.setValue(0);
    lander.pause();
    missionTimer.pause();
    _CLOSING=true;
    option=JOptionPane.showConfirmDialog(null,"Do you wish to end the program?","Closing Mars Lander!",JOptionPane.CANCEL_OPTION);
    System.err.print("--------------------------------------------------------------------------------");
    System.err.println("Player dissmissed dialog box, so closing dialog box.");
    _CLOSING=false;
    jSlider1.setValue(tempSlider);
    missionTimer.resume();
    lander.resume();
    if(option==0) return(true); else return(false);
    }

//**********************************************************************************************//
//Overiden so we can exit on System Close

  protected void processWindowEvent(WindowEvent e)
    {
    if(e.getID()==WindowEvent.WINDOW_CLOSING)
      {
      if(userIsQuiting())
        {
        System.err.print("--------------------------------------------------------------------------------");
        System.err.println("Player has quit.");
        stylisedCloseWindow();
        super.processWindowEvent(e);
        scoreTable.save();
        System.exit(0);
        }
      }
    if(e.getID()==WindowEvent.WINDOW_ICONIFIED)
      {
      System.err.print("--------------------------------------------------------------------------------");
      System.err.println("Game has been minimised, pausing.");
      sound.pause();
      lander.pause();
      missionTimer.pause();
      stop();
      this.setTitle("  PAUSED!");
      }
    if(e.getID()==WindowEvent.WINDOW_DEICONIFIED)
      {
      System.err.print("--------------------------------------------------------------------------------");
      System.err.println("Game has been restored, resuming.");
      start();
      missionTimer.resume();
      lander.resume();
      sound.resume();
      this.setTitle("  Mars Lander!");
      }
  }

//**********************************************************************************************//
//Close window

  private void stylisedCloseWindow()
    {
    this.setForeground(new Color(0,0,0));
    for(int c=0;c<this.getHeight();c+=2)
     {
     for(int r=0;r<5;r++) this.getGraphics().drawLine(0,c,getWidth(),c);
     }
    for(int c=1;c<this.getHeight();c+=2)
     {
     for(int r=0;r<5;r++) this.getGraphics().drawLine(0,c,getWidth(),c);
     }
    for(int c=0;c<500;c++) setSize(getWidth()-2,getHeight()-2);
    }

//**********************************************************************************************//
//This method updates the animation of the HUD, and also various readout's

  public void updateAnimation()
    {
    int eta=lander.getETA();
    int hours,mins,secs;
    hours=eta/3600;
    mins=(eta-(hours*3600))/60;
    secs=eta%60;
    if(radiationOn==true)
      {
      mE.nextMonitorStatus(isDay);
      switch(mE.getMonitorStatus())
        {
        case MonitorEffect.PICTURE:  monitorScreen.drawSprite(0);
                                     digits.drawNumber(GraphicalDigits.KERN_ON,111,62,(int)lander.getVelocity());
                                     digits.drawNumber(GraphicalDigits.KERN_ON,111,90,(int)lander.getAltitude());break;
        case MonitorEffect.SNOW   :  monitorScreen.drawSprite(mE.getSnowFrame());break;
        case MonitorEffect.BLANK  :  monitorScreen.drawSprite(1);break;
        }
      }
      else
      {
      monitorScreen.drawSprite(0);
      digits.drawNumber(GraphicalDigits.KERN_ON,111,62,(int)lander.getVelocity());
      digits.drawNumber(GraphicalDigits.KERN_ON,111,90,(int)lander.getAltitude());
      }
    for(int c=0;c<5;c++)
      {
      lightBulb.drawSprite(10+(c*20),283,panelFlash[c].getFlashIsOn()?0:1);
      lightBulb.drawSprite(215+((4-c)*20),283,panelFlash[c].getFlashIsOn()?0:1);
      }
    digits.drawNumber(GraphicalDigits.KERN_OFF,120,349,.7,.7,missionTimer.getHours(),2);
    digits.drawNumber(GraphicalDigits.KERN_OFF,149,349,.7,.7,missionTimer.getMins(),2);
    digits.drawNumber(GraphicalDigits.KERN_OFF,178,349,.7,.7,missionTimer.getSecs(),2);

    digits.drawNumber(GraphicalDigits.KERN_OFF,245,349,.7,.7,hours,2);
    digits.drawNumber(GraphicalDigits.KERN_OFF,272,349,.7,.7,mins,2);
    digits.drawNumber(GraphicalDigits.KERN_OFF,298,349,.7,.7,secs,2);
    }

//**********************************************************************************************//
//This method handles the in game graphic display

  public void updateInGameDisplay(float fvalue)
    {
    if(fvalue<0) fvalue=0;
    if(fvalue>3000) fvalue=3000;
    fvalue=300-fvalue/10;

    if(radar.isSelected())
      {
      bufferedImageHandle.clearRect(25,19,266,262);
      if(isDay) lightning.drawLightning(Lightning.RADAR,(int)-(fvalue*1.5));
      bufferedImageHandle.drawImage(rforeground,10,(int)(820-(fvalue*2.8)),this);
      if(fvalue>220) bufferedImageHandle.drawImage(rparalax,200,(int)(1800-(fvalue*7)),this);
      if(asteroidOn) asteroids.drawAsteroids(AsteroidDisplay.RADAR);
      if(fvalue>220) bufferedImageHandle.drawImage(rlandingPad,0,(int)(5330-(fvalue*18)),this);
      }
      else
      {
      if(dustCloudOn)
        {
        if(isDay)
          {
          bufferedImageHandle.drawImage(dbackground,0,(int)-(fvalue*1.5),this);
          lightning.drawLightning(Lightning.NORMAL,(int)-(fvalue*1.5));
          bufferedImageHandle.drawImage(dforeground,10,(int)(820-(fvalue*2.8)),this);
          if(fvalue>220) bufferedImageHandle.drawImage(dparalax,200,(int)(1800-(fvalue*7)),this);
          }
          else
          {
          bufferedImageHandle.drawImage(nbackground,0,(int)-(fvalue*1.5),this);
          bufferedImageHandle.drawImage(nforeground,10,(int)(820-(fvalue*2.8)),this);
          if(fvalue>220) bufferedImageHandle.drawImage(nparalax,200,(int)(1800-(fvalue*7)),this);
          }
        if(flash.getFlashIsOn()) bufferedImageHandle.drawImage(beacon,205,(int)(1882-(fvalue*7)),this);
        int fogLevel=(int)(1880-(fvalue*7));
        if(fogLevel<-150) fogLevel=-150;
        if(asteroidOn) asteroids.drawAsteroids(AsteroidDisplay.NORMAL);
        bufferedImageHandle.drawImage(dust,-dustXPos,fogLevel,this);
        if((dustXPos+=5)==300) dustXPos=0;
        }
        else //Dust cloud is off...
        {
        if(isDay)
          {
          bufferedImageHandle.drawImage(dbackground,0,(int)-(fvalue*1.5),this);
          lightning.drawLightning(Lightning.NORMAL,(int)-(fvalue*1.5));
          bufferedImageHandle.drawImage(dforeground,10,(int)(820-(fvalue*2.8)),this);
          if(fvalue>220) bufferedImageHandle.drawImage(dparalax,200,(int)(1800-(fvalue*7)),this);
          if(fvalue>220) bufferedImageHandle.drawImage(dlandingPad,0,(int)(5330-(fvalue*18)),this);
          if(flash.getFlashIsOn()) bufferedImageHandle.drawImage(beacon,205,(int)(1882-(fvalue*7)),this);
          }
          else
          {
          bufferedImageHandle.drawImage(nbackground,0,(int)-(fvalue*1.5),this);
          bufferedImageHandle.drawImage(nforeground,10,(int)(820-(fvalue*2.8)),this);
          if(fvalue>220) bufferedImageHandle.drawImage(nparalax,200,(int)(1800-(fvalue*7)),this);
          if(fvalue>220) bufferedImageHandle.drawImage(nlandingPad,0,(int)(5330-(fvalue*18)),this);
          if(flash.getFlashIsOn()) bufferedImageHandle.drawImage(beacon,205,(int)(1882-(fvalue*7)),this);
          }
        if(asteroidOn) asteroids.drawAsteroids(AsteroidDisplay.NORMAL);
        }
      }
    bufferedImageHandle.drawImage(fuelback,16,307,this);
    bufferedImageHandle.drawImage(fuelgage,-28-(int)((500-lander.getFuel())/1.8),308,this);
    bufferedImageHandle.drawImage(window,0,0,this);
    bufferedImageHandle.drawImage(slider,322,20+(int)(fvalue*0.85),this);
    updateAnimation();
    jPanel1ImageHandle.drawImage(buffImage,0,0,this);
    }

//**********************************************************************************************//
//This method updates the intro display, either the High Score table, or the credits

  public void updateIntroDisplay()
    {
    if(highScores)
      updateHighScoreDisplay();
      else
      updateIntroScaledDisplay();
    }

//**********************************************************************************************//
//This method updates the High Score display

  public void updateHighScoreDisplay()
     {
     if((highScoreYPos+=2)>=520)
      {
      highScoreYPos=0;
      highScores=false;
      return;
      }
    bufferedImageHandle.drawImage(dbackground,0,0,this);
    bufferedImageHandle.drawImage(dforeground,10,0,this);
    bufferedImageHandle.drawImage(dparalax,200,0,this);
    if(flash.getFlashIsOn()) bufferedImageHandle.drawImage(beacon,205,82,this);

    if(highScoreYPos<100)
      {
      bufferedImageHandle.setColor(new Color(0,0,0,(int)(highScoreYPos*2.55)));
      }
      else
      {
      bufferedImageHandle.setColor(new Color(0,0,0,255));
      }

    if(highScoreYPos>420)
      {
      bufferedImageHandle.setColor(new Color(0,0,0,(int)((100-(highScoreYPos-420))*2.55)));
      }

    bufferedImageHandle.fillRect(25,19,266,262);
    double alp=highScoreYPos+480;
    alp=Math.sin((alp/1.4)/180.0*Math.PI);
    alp=Math.abs(alp*255);
    int alpa=(int)(alp%256);
    bufferedImageHandle.setColor(new Color(0,alpa,0));
    bufferedImageHandle.drawString("HIGH SCORES!",75,300-highScoreYPos);
    for(int y=0;y<10;y++)
      {
      alp=highScoreYPos+(20-y)*20+60;
      alp=Math.sin((alp/1.4)/180.0*Math.PI);
      alp=Math.abs(alp*255);
      alpa=(int)(alp%256);
      bufferedImageHandle.setColor(new Color(0,alpa,0));
      bufferedImageHandle.drawString(
                               scoreTable.getScore(y), //The string to draw, eg "AAA---123"
              160-scoreTable.getScorePixelLength(y)/2, //The X pos, in this case centered in window
                            (325-highScoreYPos)+y*20); //The Y pos,using the scores place in the
                                                       //  table and the overall table offset
      }
    bufferedImageHandle.drawImage(fuelback,16,307,this);
    bufferedImageHandle.drawImage(window,0,0,this);
    bufferedImageHandle.drawImage(slider,322,20,this);
    updateAnimation();
    jPanel1ImageHandle.drawImage(buffImage,0,0,this);
    }

//**********************************************************************************************//
//This method updates the Credits display

  public void updateIntroScaledDisplay()
    {
    double scale,alph;
    bufferedImageHandle.drawImage(dbackground,0,0,this);
    bufferedImageHandle.drawImage(dforeground,10,0,this);
    bufferedImageHandle.drawImage(dparalax,200,0,this);
    bufferedImageHandle.drawImage(fuelback,16,307,this);
    if(flash.getFlashIsOn()) bufferedImageHandle.drawImage(beacon,205,82,this);

    intro.updateZoom();
    if(intro.getImageNumber()==4)
      {
      intro.resetZoom();
      highScores=true;
      return;
      }
    scale=intro.getScaling();

    if(intro.getDirection()==Zoom.OUT)
      {
      alph=1+(double)(1.2-(1.2*scale));
      for(double a=alph;a>=1.0;a-=.05)
        introPic.drawSprite(165-(int)(115*(scale/a)),140,scale/a,
                                scale/a,intro.getImageNumber());
      }
    introPic.drawSprite(165-(int)(115*scale),140,scale,
                            scale,intro.getImageNumber());
    bufferedImageHandle.drawImage(window,0,0,this);
    bufferedImageHandle.drawImage(slider,322,20,this);
    updateAnimation();
    jPanel1ImageHandle.drawImage(buffImage,0,0,this);
    }

//**********************************************************************************************//
//This method updates the Countdown display

  public void updateCountdownDisplay()
    {
    double scale,alph;
    if(isDay)
      bufferedImageHandle.drawImage(dbackground,0,0,this);
      else
      bufferedImageHandle.drawImage(nbackground,0,0,this);
    if(isDay) lightning.drawLightning(Lightning.NORMAL,0);
    bufferedImageHandle.drawImage(fuelback,16,307,this);
    for(int acc=0;acc<3;acc++)
      {
      if(!_CLOSING) countdown.updateZoom();
      if(countdown.isStartedPausing()&&soundItems[0].isSelected())
        {
        switch(countdown.getImageNumber())
          {
          case 0: say3.play();break;
          case 1: say3.stop();say2.play();break;
          case 2: say2.stop();say1.play();break;
          case 3: say1.stop();sayGo.play();break;
          }
        }
      }

    if(countdown.getImageNumber()==4) {sayGo.stop();nextLanderPhase();lightning.reset();return;}
    scale=countdown.getScaling();

    if(countdown.getDirection()==Zoom.OUT)
      {
      alph=1+(double)(2-(2*scale));
      for(double a=alph;a>=1.0;a-=.1)
        countDown.drawSprite(165-(int)((115*(scale/a))+((a-1)*40)),140,scale/a,
                                scale/a,countdown.getImageNumber());
      countDown.drawSprite(165-(int)(115*scale),140,scale,
                                scale,countdown.getImageNumber());
      }
      else
      {
      countDown.drawSprite(85-(int)((115*scale)+((scale-2)*80)),140,scale,
                                scale,countdown.getImageNumber());
      }
    bufferedImageHandle.drawImage(window,0,0,this);
    bufferedImageHandle.drawImage(slider,322,20,this);
    updateAnimation();
    jPanel1ImageHandle.drawImage(buffImage,0,0,this);
    }


//**********************************************************************************************//
//The following are the user triggered events recognised by the game.
//Menu and System control events are handled elsewhere.
//**********************************************************************************************//

//**********************************************************************************************//
//This method is called when the Dynamic Thrust Control (Slider) is moved

  void jSlider1_stateChanged(ChangeEvent e)
    {
    int value=jSlider1.getValue(),red,green,blue;
    thrust=value;
    lander.setThrust(thrust);
    if(lander.getFuel()<1.0) return;
    jProgressBar1.setValue(value);
    red=(int)(value*2.55); green=(int)((100-value)*2.55); blue=0;
    jProgressBar1.setForeground(new Color(red,green,blue));
    }

//**********************************************************************************************//
//This method is called when the Start/Play Button is pressed.

  void jButton1_actionPerformed(ActionEvent e)
    {
    //lander phases -1, 1 and 2 are automatically terminated, and can't be overiden by the user
    if((landerPhase==0)||(landerPhase==3)) nextLanderPhase();
    }

  }//End of class scope