import java.applet.*;
import java.awt.Graphics;
import java.awt.Color;
import java.awt.Font;
import java.awt.FontMetrics;
import java.awt.event.*;
import java.net.URL;
import java.util.*;

public class Asteroids extends Applet implements Runnable
{ Thread gameThread = null;  
  GameEngine gameEngine = null;
  boolean stop=false;
  boolean wait=true;
  URL codeBase;
  
  int lives, newLife, level, shields, score, ufoTime=0, pause;
  
  AudioClip sndLaser, sndXplode, sndShields, sndZap, sndBugle;
     
  Model mPlayer, mBullet, mRock, mRock1, mRock2, mRock3, mBack, mShield, mUfo, mIcon, mPanel;
  Actor aPlayer, aBullet, aPhoton, aRock, aBack, aShield, aUfo, aTemp;
  Particle pRock, pPanel;
  
  Actor[] aScore = new Actor[6];
  Actor[] aLives = new Actor[100];
  GLFont fBasic, fBlue, fRed;
  
  List aBullets = new ArrayList(99);
  List aPhotons = new ArrayList(99);
  List aRocks   = new ArrayList(99);
  
  boolean shotOk = true;

  private void startUp()
  { Graphics g = this.getGraphics();
    this.setBackground(Color.black);
    g.setColor(Color.yellow);
    
    g.setFont(new Font("sansserif", Font.BOLD, 16));
    centerString(g, "Asteroids...", 1); 
    centerString(g, "by Robert Walsh", 2); 
    centerString(g, "MonkeyFighter.com", 3); 
    
    g.setColor(Color.red);    
    centerString(g, "Please use latest JRE:  www.java.com", 6); 
    
    centerString(g, "This program requires gl4java:  www.jausoft.com/gl4java.html", 8); 
    
    g.setColor(Color.white);
    centerString(g, "Please wait while program loads data files...", 12); 
        
    gameEngine = new GameEngine(getSize().width, getSize().height, codeBase); 
        
    gameEngine.models.add(mBack     = new Model(codeBase + "Back.glo"));  
    gameEngine.models.add(mPlayer   = new Model(codeBase + "Ship.glo"));
    gameEngine.models.add(mBullet   = new Model(codeBase + "Bullet.glo"));
    gameEngine.models.add(mRock     = new Model(codeBase + "Rock.glo"));
    gameEngine.models.add(mRock1    = new Model(codeBase + "Rock1.glo"));
    gameEngine.models.add(mRock2    = new Model(codeBase + "Rock2.glo"));
    gameEngine.models.add(mRock3    = new Model(codeBase + "Rock3.glo"));
    gameEngine.models.add(mShield   = new Model(codeBase + "Shield.glo"));
    gameEngine.models.add(mUfo      = new Model(codeBase + "Ufo.glo"));
    gameEngine.models.add(mIcon     = new Model(codeBase + "Icon.glo"));        
    gameEngine.models.add(mPanel    = new Model(codeBase + "Panel.glo"));     
    g.setColor(Color.blue);        
    centerString(g, "Loading Model Data...", 15);
    
    gameEngine.glFonts.add(fBasic = new GLFont(codeBase + "Basic.glf"));
    gameEngine.glFonts.add(fBlue  = new GLFont(codeBase + "Basic.glf", 0, 0, 48, 0.2f, 0.2f, 0.2f));
    gameEngine.glFonts.add(fRed   = new GLFont(codeBase + "Basic.glf", 32, 0, 8, 0.2f, 0.2f, 0.2f));    
    centerString(g, "Loading Font Data...", 16);
      
    sndLaser   = getAudioClip(codeBase, "Laser.wav");
    sndXplode  = getAudioClip(codeBase, "Xplode.wav");
    sndShields = getAudioClip(codeBase, "Shields.wav");
    sndZap     = getAudioClip(codeBase, "Zap.wav");    
    sndBugle   = getAudioClip(codeBase, "Bugle.wav");     
    centerString(g, "Loading Sound Data...", 17);  

    pRock = new Particle(mRock, 4);
    pRock.xs = 40;
    pRock.ys = 40;
    pRock.zs = 40;        
    pRock.die = 50;
    pRock.xrs = 5f;
    pRock.yrs = 5f;
    pRock.zrs = 5f;

    pPanel = new Particle(mPanel, 4);               
    pPanel.xrs = 5f;
    pPanel.yrs = 5f;
    pPanel.zrs = 5f;
        
    add("Center", gameEngine);
    while(gameEngine.modelCount<14) sleep(100);
               
    while(sndLaser  ==null) sleep(100);
    while(sndXplode ==null) sleep(100);
    while(sndShields==null) sleep(100);
    while(sndZap    ==null) sleep(100);   
    while(sndBugle  ==null) sleep(100);
  }
  
  private void sleep(int t)
  { try { Thread.sleep(t); }
    catch(Exception e) {     };
  }
  
  private void newGame()
  { aBack     = gameEngine.addActor(mBack, 0, 0, -480);
    aBack.zrs = 0.003f;
    aBack.yrs = 0.007f;
    aBack.zs  = 0.37f;
        
    aPlayer      = gameEngine.addActor(mPlayer, 0, 0, 10);
    aPlayer.xmin =-90;
    aPlayer.xmax = 90;
    aPlayer.ymin =-90;
    aPlayer.ymax = 90;         
    aPlayer.x=aPlayer.y = 0;
    
    gameEngine.print(fBasic, "SCORE:", -16f, 15f, -39f);
        
    for(int t=0; t<6; t++)
      aScore[t] = gameEngine.addGLLetter(fBasic, 48,  -8f-((float)t/1.4f), 15f, -39f);
      
    for(int t=0; t<lives; t++)
      aLives[t] = gameEngine.addActor(mIcon, -6+((float)t), 14.9f, -38.75f);      
  }
  
  private void reset()
  { aTemp     = gameEngine.addActor(mRock1, 40, 55, -200);
    aTemp.yrs = 0.25f;
    aTemp     = gameEngine.addActor(mRock2, 40,  5, -200);
    aTemp.yrs = 0.25f;    
    aTemp     = gameEngine.addActor(mRock3, 40,-20, -200);
    aTemp.yrs = 0.25f;    
    aTemp     = gameEngine.addActor(mUfo,   40,-45, -200);
    aTemp.zrs = 0.25f;
    aTemp.xr  = -80f;
    aTemp     = gameEngine.addActor(mPlayer, -70, 0, -200);
    aTemp.zrs = 0.25f;    
    
    gameEngine.print(fBasic, "PRESS ENTER TO PLAY", -7f, -15f, -38f);
    gameEngine.print(fBlue, "25  POINTS", 4.5f, 4.7f, -39f);
    gameEngine.print(fBlue, "50  POINTS", 4.5f, -2.5f, -39f);
    gameEngine.print(fBlue, "100 POINTS", 4.5f, -6.8f,-39f);
    gameEngine.print(fBlue, "500 POINTS", 4.5f, -11.8f,-39f);

    gameEngine.print(fRed, "ASTEROIDS", -7.5f, 7.5f, -25f);
    gameEngine.print(fRed, "BY ROBERT WALSH", -12f, 10f, -39);    
    gameEngine.print(fRed, "MONKEYFIGHTER.COM", -12.75f, 8.25f, -39);    
    gameEngine.print(fBlue, "EVERY 10000 POINTS", -12f, -0.5f, -39f);
     
    while(!gameEngine.keys[10])
    { sleep(10);
      doBack();
      gameEngine.updateActors();
      gameEngine.sDisplay();     
    }
    
    lives  =2;
    newLife=10000;
    level  =1;
    score  =0;
    ufoTime=0;
    aUfo   =null;
    
    gameEngine.killActors();
    aBullets.clear();
    aPhotons.clear();
    aRocks.clear();
    newGame();
  }
  
  private void initAsteroids()
  { for(int t=0; t<level+2; t++)
      makeRock(1, 1, (float)Math.random()*220-110, (float)Math.random()*220-110);              
  }
  
  private void playAsteroids()
  { RunAsteroids rAster = new RunAsteroids();
    rAster.setPriority(10);
    while((aRocks.size()>0)&&(!stop)&&(lives>-1))
    { sleep(12);
      rAster.run();           
      gameEngine.sDisplay();
  } }
   
  class RunAsteroids extends Thread
  { public void run()
    { if(!wait)
      { if(aShield!=null)
        { aShield.x = aPlayer.x;
          aShield.y = aPlayer.y; 
          if(pause--<0)
          { gameEngine.killActor(aShield);
            aShield=null; } }
        doUfo();
        keyboard(); }
      else
      { if(pause--<0)
        { if(aShield==null)
          { aShield     = gameEngine.addActor(mShield, 0, 0, -200);
            aShield.yrs = 1f;
            aShield.zrs = 1f; }
          
          if(gameEngine.keys[16])
          { sndShields.play();
            wait        = false;
            aPlayer.z   =-200;  
            pause       = 32; } } }
        
      doBack();
      gameEngine.updateActors();
      collisionBulletUfo();
      collisionBulletRock();
      collisionPhotonRock();
      collisionPhotonPlayer();
      collisionUfoPlayer();
      collisionUfoRock();
      collisionPlayerRock();     
  } }
                    
  public void run()
  { startUp();
       
    while(!stop)
    { newGame();
      reset();
    
      while((lives>-1)&&(!stop))
      { aPlayer.z  = 10f;
        aPlayer.x  = 0f;
        aPlayer.y  = 0f;
        aPlayer.xs = 0f;
        aPlayer.ys = 0f;        
        pause = 32;
        wait  = true;
        
        showLevel();
        initAsteroids();
        playAsteroids();
        level++;
      }
      
      if(!stop) GameOver();
  } }
  
  private void GameOver()
  { aTemp     = gameEngine.addGLLetter(fBlue, 'G', -4f, 1f, -20f);
    aTemp.yrs = 0.5f;
    aTemp     = gameEngine.addGLLetter(fBlue, 'A', -3f, 1f, -20f);
    aTemp.yrs = 0.5f;
    aTemp     = gameEngine.addGLLetter(fBlue, 'M', -2f, 1f, -20f);
    aTemp.yrs = 0.5f;
    aTemp     = gameEngine.addGLLetter(fBlue, 'E', -1f, 1f, -20f);
    aTemp.yrs = 0.5f;    
    aTemp     = gameEngine.addGLLetter(fBlue, 'O', 1f, 1f, -20f);
    aTemp.yrs = 0.5f;
    aTemp     = gameEngine.addGLLetter(fBlue, 'V', 2f, 1f, -20f);
    aTemp.yrs = 0.5f;
    aTemp     = gameEngine.addGLLetter(fBlue, 'E', 3f, 1f, -20f);
    aTemp.yrs = 0.5f;
    aTemp     = gameEngine.addGLLetter(fBlue, 'R', 4f, 1f, -20f);      
    aTemp.yrs = 0.5f;
    
    gameEngine.print(fBasic, "PRESS ENTER TO CONTINUE", -8f, -2f, -38f);
    while(!gameEngine.keys[10])
    { sleep(10);
      doBack();
      doUfo();      
      gameEngine.updateActors();
      gameEngine.sDisplay();     
    }
    while(gameEngine.keys[10]);
    gameEngine.killActors();
    aBullets.clear();
    aPhotons.clear();
    aRocks.clear();    
  }
    
  private void showLevel()
  { aTemp     = gameEngine.addGLLetter(fBlue, 'L', -4f, 1f, -35f);
    aTemp.die = 200;
    aTemp.zs  = 0.1f;
    aTemp     = gameEngine.addGLLetter(fBlue, 'E', -3f, 1f, -35f);
    aTemp.die = 205;
    aTemp.zs  = 0.1f;
    aTemp     = gameEngine.addGLLetter(fBlue, 'V', -2f, 1f, -35f);
    aTemp.die = 210;
    aTemp.zs  = 0.1f;
    aTemp     = gameEngine.addGLLetter(fBlue, 'E', -1f, 1f, -35f);
    aTemp.die = 215;
    aTemp.zs  = 0.1f;    
    aTemp     = gameEngine.addGLLetter(fBlue, 'L',  0f, 1f, -35f);
    aTemp.die = 220;
    aTemp.zs  = 0.1f;
            
    aTemp     = gameEngine.addGLLetter(fBlue, (int)(level/10+48),  2f, 1f, -35f);
    aTemp.die = 225;
    aTemp.zs  = 0.1f;    
    aTemp     = gameEngine.addGLLetter(fBlue, (int)(level%10+48),  3f, 1f, -35f);
    aTemp.die = 230; 
    aTemp.zs  = 0.1f;   
  }
  
  private void doBack()
  { if((aBack.zr<-5)||(aBack.zr>5)) aBack.zrs*=-1.0f;
    if((aBack.yr<-2)||(aBack.yr>2)) aBack.yrs*=-1.0f;
    if((aBack.z<-492)||(aBack.zr>-485)) aBack.zs*=-1.0f;
  }
  
  private void doUfo()
  { if(ufoTime++>900)
    { if(aUfo==null)
      { if(Math.random()>.5)
        { aUfo = gameEngine.addActor(mUfo, 100, (float)(Math.random()*140)-70.0f, -200);
          aUfo.xs = -0.3f;
          aUfo.zr = 90; 
          aUfo.yrs = -0.001f;          
          aUfo.xr = -80;}
        else
        { aUfo = gameEngine.addActor(mUfo, -100, (float)(Math.random()*140)-70.0f, -200);
          aUfo.xs = 0.3f;
          aUfo.zr = 270; 
          aUfo.yrs = 0.001f;
          aUfo.xr = -80; }
        aUfo.ys  = 0.25f;
        aUfo.xrs = 0.5f;        
      }
      if((aUfo.y> 80)||(aUfo.y<-80)||(Math.random()>0.99)) 
      { aUfo.ys *= -1.0f;
        aUfo.yrs *= -1.0f; 
        aUfo.yr  += (aUfo.yrs*-10000f); }
      
      if((ufoTime%50)==0)
      { sndZap.play();
        aPhotons.add(aPhoton = gameEngine.addActor(mBullet, aUfo.x, aUfo.y, aUfo.z));

        aPhoton.xs = aUfo.xs * 2.5f;
        aPhoton.ys = (float)Math.random() - 0.5f;
        aPhoton.yrs = 3.1415f;
        aPhoton.zrs = 3.1415f;
        aPhoton.die = 425;
      }
      if((ufoTime%75)==0)
        aUfo.xrs *= -1.0f;
                      
      if((aUfo.x<-100)||(aUfo.x>100))
      { gameEngine.killActor(aUfo);
        aUfo=null;
        ufoTime = 0;  }
    }
  }
  
  public void init()
  { codeBase = getCodeBase();
    setLayout(new java.awt.BorderLayout()); 
  }

  public void start()
  { if(gameThread == null)
    { gameThread = new Thread(this);
      gameThread.start();
    }
  }
   
  public void stop()
  { if((gameThread != null) && gameThread.isAlive())
      stop=true;
    gameThread = null;

    gameEngine.cvsDispose();    
  }
  
  private void keyboard()   
  { if(gameEngine.keys[37])
      aPlayer.zr += 3f;
    if(gameEngine.keys[39])
      aPlayer.zr -= 3f;

    if(gameEngine.keys[38])
    { aPlayer.xs += (float)Math.sin(Math.toRadians(-aPlayer.zr)) * 0.01f;
      aPlayer.ys += (float)Math.cos(Math.toRadians(-aPlayer.zr)) * 0.01f;

      if(Math.abs(aPlayer.xs)>0.2f) aPlayer.xs=(aPlayer.xs/Math.abs(aPlayer.xs))*0.2f;
      if(Math.abs(aPlayer.ys)>0.2f) aPlayer.ys=(aPlayer.ys/Math.abs(aPlayer.ys))*0.2f;
    }

    if(gameEngine.keys[40])
    { aPlayer.xs -= (aPlayer.xs * 0.05f);
      aPlayer.ys -= (aPlayer.ys * 0.05f);
    }       

    if(!gameEngine.keys[16])
      shotOk=true;
              
    if(gameEngine.keys[16])
    { if(shotOk)
      { sndLaser.play();
        shotOk=false;
        aBullets.add(aBullet = gameEngine.addActor(mBullet, aPlayer.x, aPlayer.y, aPlayer.z));

        aBullet.xs = (float)Math.sin(Math.toRadians(-aPlayer.zr)) * 0.5f;
        aBullet.ys = (float)Math.cos(Math.toRadians(-aPlayer.zr)) * 0.5f;          
        aBullet.zrs = 3.1415f;
        aBullet.die = 425;
  } } }
  
  private void setScore(int a)
  { int s, v;
  
    s = score += a;
    for(int t=0; t<6; t++)
    { v = s%10;
      s /= 10;
      gameEngine.setGLLetter(fBasic, aScore[t], v+48); }
    
    if(score>newLife)
    { sndBugle.play();
      aLives[lives] = gameEngine.addActor(mIcon, -6+((float)lives), 14.9f, -38.75f);
      lives ++;
      newLife += 10000;  
    }
  }
   
  private void death()
  { pPanel.size=200;
    pPanel.die =320;
    pPanel.xs = 12;
    pPanel.ys = 12;
    pPanel.zs = 12;     
    pPanel.x  =aPlayer.x;
    pPanel.y  =aPlayer.y;
    pPanel.z  =aPlayer.z;
    pPanel.xdr=aPlayer.model.maxRadius;
    pPanel.ydr=aPlayer.model.maxRadius;
    pPanel.zdr=aPlayer.model.maxRadius;                    
    gameEngine.addRadParticles(pPanel);
    sndXplode.play();
    sndXplode.play();        
    
    aPlayer.z  = 10f;
    aPlayer.xs = 0f;
    aPlayer.ys = 0f;
    aPlayer.x  = 0f;
    aPlayer.y  = 0f;
    wait  = true;
    pause = 180;
    if(--lives>-1)
      gameEngine.killActor(aLives[lives]);
  }
       
  private void collisionPlayerRock()
  { for(int r=0; r<aRocks.size(); r++) 
    { aRock = (Actor)aRocks.get(r);
      if(gameEngine.collisionBallBall(aPlayer, aPlayer.model.maxRadius, aRock, aRock.model.maxRadius))
      { sndXplode.play();
        gameEngine.killActor(aRock);
        aRocks.remove(aRocks.indexOf(aRock));
        death();    
                  
        if(aRock.model==mRock1)
        { makeRock(4, 2, aRock.x, aRock.y); }
        if(aRock.model==mRock2)
        { makeRock(4, 3, aRock.x, aRock.y); }

        r=aRocks.size();         
  } } }
  
  private void collisionPhotonPlayer()
  { for(int b=0; b<aPhotons.size(); b++)
    { aPhoton = (Actor)aPhotons.get(b);
      if(gameEngine.collisionBallBall(aPhoton, aPhoton.model.maxRadius, aPlayer, aPlayer.model.maxRadius))
      { gameEngine.killActor(aPhoton);
        aPhotons.remove(aPhotons.indexOf(aPhoton));
        b=aPhotons.size();
        death();    
  } } } 

  private void collisionUfoPlayer()
  { if(aUfo==null) return;
    if(gameEngine.collisionBallBall(aUfo, aUfo.model.maxRadius/2, aPlayer, aPlayer.model.maxRadius))
    { sndXplode.play();
      makeUfoParts(aUfo);
      gameEngine.killActor(aUfo);
      aUfo    = null;
      ufoTime = 0;
      death();     
  } }
    
  private void collisionPhotonRock()
  { for(int b=0; b<aPhotons.size(); b++)
    { aPhoton = (Actor)aPhotons.get(b);
      for(int r=0; r<aRocks.size(); r++) 
      { aRock = (Actor)aRocks.get(r);
        if(gameEngine.collisionBallBall(aPhoton, aPhoton.model.maxRadius, aRock, aRock.model.minRadius))
        { sndXplode.play();
          makeRockParts(aRock);
          gameEngine.killActor(aPhoton);
          gameEngine.killActor(aRock);
          aPhotons.remove(aPhotons.indexOf(aPhoton));
          aRocks.remove(aRocks.indexOf(aRock));
                    
          if(aRock.model==mRock1)
            makeRock(3, 2, aRock.x, aRock.y);
          if(aRock.model==mRock2)
            makeRock(2, 3, aRock.x, aRock.y);
                              
          b=aPhotons.size();
          r=aRocks.size();
  } } } }
    
  private void collisionBulletRock()
  { for(int b=0; b<aBullets.size(); b++)
    { aBullet = (Actor)aBullets.get(b);
      for(int r=0; r<aRocks.size(); r++) 
      { aRock = (Actor)aRocks.get(r);
        if(gameEngine.collisionBallBall(aBullet, aBullet.model.minRadius, aRock, aRock.model.minRadius))
        { sndXplode.play();
          makeRockParts(aRock);
          gameEngine.killActor(aBullet);
          gameEngine.killActor(aRock);
          aBullets.remove(aBullets.indexOf(aBullet));          
          aRocks.remove(aRocks.indexOf(aRock)); 
                 
          if(aRock.model==mRock1)
          { makeRock(3, 2, aRock.x, aRock.y);
            setScore(25);
          }
          if(aRock.model==mRock2)
          { makeRock(2, 3, aRock.x, aRock.y); 
            setScore(50); 
          }
          if(aRock.model==mRock3)
          { setScore(100); }
                    
          b=aBullets.size();
          r=aRocks.size();         
  } } } }
  
  private void collisionUfoRock()
  { if(aUfo==null) return;
    for(int r=0; r<aRocks.size(); r++) 
    { aRock = (Actor)aRocks.get(r);
      if(gameEngine.collisionBallBall(aUfo, aUfo.model.maxRadius/2, aRock, aRock.model.maxRadius))
      { sndXplode.play();
        makeUfoParts(aUfo);        
        makeRockParts(aRock);      
        gameEngine.killActor(aRock);
        aRocks.remove(aRocks.indexOf(aRock));
        gameEngine.killActor(aUfo);
        aUfo    = null;
        ufoTime = 0;        
        
        if(aRock.model==mRock1)
        { makeRock(4, 2, aRock.x, aRock.y); }
        if(aRock.model==mRock2)
        { makeRock(4, 3, aRock.x, aRock.y); }

        r=aRocks.size();         
  } } }
    
  private void collisionBulletUfo()
  { if(aUfo==null) return;
    for(int b=0; b<aBullets.size(); b++)
    { aBullet = (Actor)aBullets.get(b);
      if(gameEngine.collisionBallBall(aBullet, aBullet.model.minRadius, aUfo, aUfo.model.maxRadius/2f))
      { sndXplode.play();
        gameEngine.killActor(aBullet);
        aBullets.remove(aBullets.indexOf(aBullet));
        gameEngine.killActor(aUfo);
        makeUfoParts(aUfo);
        aUfo    = null;
        ufoTime = 0;
        setScore(500);
        b = aBullets.size();       
  } } } 
  
  private void makeUfoParts(Actor act)
  { pPanel.size=64;
    pPanel.die = 120;
    pPanel.xs = 25;
    pPanel.ys = 25;
    pPanel.zs = 25; 
    pPanel.x  =act.x;
    pPanel.y  =act.y;
    pPanel.z  =act.z;
    pPanel.xdr=act.model.maxRadius;
    pPanel.ydr=act.model.maxRadius;
    pPanel.zdr=act.model.maxRadius;                    
    gameEngine.addRadParticles(pPanel);
  }
    
  private void makeRockParts(Actor act)
  { if(act.model==mRock1) pRock.size=8;
    if(act.model==mRock2) pRock.size=4;
    if(act.model==mRock3) pRock.size=2;
    pRock.x  =act.x;
    pRock.y  =act.y;
    pRock.z  =act.z;
    pRock.xdr=act.model.maxRadius;
    pRock.ydr=act.model.maxRadius;
    pRock.zdr=act.model.maxRadius;                    
    gameEngine.addRadParticles(pRock);
  }
  
  private void makeRock(int qnty, int size, float x, float y)
  { Actor aRock=null;
    float d1, d2;

    for(int t=0; t<qnty; t++)
    { if(size==1) 
      { aRocks.add(aRock = gameEngine.addActor(mRock1, x, y, -200f));
        aRock.xmax=aRock.ymax= 100f;
        aRock.xmin=aRock.ymin=-100f;
      }
      if(size==2)
      { aRocks.add(aRock = gameEngine.addActor(mRock2, x, y, -200f));
        aRock.xmax=aRock.ymax= 90;
        aRock.xmin=aRock.ymin=-90;   
      }
      if(size==3)
      { aRocks.add(aRock = gameEngine.addActor(mRock3, x, y, -200f));
        aRock.xmax=aRock.ymax= 82f;
        aRock.xmin=aRock.ymin=-82f;         
      }
      
      aRock.xs = (float)(Math.random()*0.12f*size*size)-(0.06f*size*size);
      aRock.ys = (float)(Math.random()*0.12f*size*size)-(0.06f*size*size);
      aRock.zrs = (float)(Math.random()*0.5f*size)-(0.25f*size);
      aRock.yrs = (float)(Math.random()*0.5f*size)-(0.25f*size);
  } }
  
  private void centerString(Graphics g, String s, int y)
  { Font f = g.getFont();
    FontMetrics fm = g.getFontMetrics(f);
    int a  = fm.getAscent();
    int h  = fm.getHeight();
    int sw = fm.stringWidth(s);
    
    g.drawString(s, (this.getWidth()/2) - (sw/2), h*y+a);
  }
}