((Space)getWorld()).getCounter().add(1);

import greenfoot.*;  // (World, Actor, GreenfootImage, and Greenfoot)

/**
 * A rocket that can be controlled by the arrowkeys: up, left, right.
 * The gun is fired by hitting the 'space' key. 'z' releases a proton wave.
 * 
 * @author Poul Henriksen
 * 
 * @author Michael Kolling
 * @version 1.0
 */
public class Rocket extends SmoothMover
{
    private static final int gunReloadTime = 5;         // The minimum delay between firing the gun.
    private static final int protonReloadTime = 20;    // The minimum delay between proton wave bursts.

    private int reloadDelayCount;               // How long ago we fired the gun the last time.
    private int protonDelayCount;               // How long ago we fired the proton wave the last time.
    
    private GreenfootImage rocket = new GreenfootImage("rocket.png");    
    private GreenfootImage rocketWithThrust = new GreenfootImage("rocketWithThrust.png");
    private boolean touched=false;
    /**
     * Initilise this rocket.
     */
    public Rocket()
    {
        reloadDelayCount = 5;
        protonDelayCount = 20;
     }

    /**
     * Do what a rocket's gotta do. (Which is: mostly flying about, and turning,
     * accelerating and shooting when the right keys are pressed.)
     */
    public void act()
    {
         checkKeys();
         reloadDelayCount++;
         move(); 
         imageSwitch();
         explode(); 
        
    }
    
    /**
     * Check whether there are any key pressed and react to them.
     */
    private void checkKeys() 
    {
        if (Greenfoot.isKeyDown("up"));
        
        if (Greenfoot.isKeyDown("left")) 
        {
            setRotation(getRotation() - 5);
        }
        if (Greenfoot.isKeyDown("right")) 
        {
            setRotation(getRotation() + 5);
        }
        if (Greenfoot.isKeyDown("space")) 
        {
            fire();
        }
        if (Greenfoot.isKeyDown("p")) 
    {
            ProtonWave();
        }
    }
      private void ProtonWave(){
         if (waveDelayCount >=protonWaveReload)
         {
           getWorld().addObject(new ProtonWave(), getX(), getY());
           waveDelayCount = 0;
}
    }   
    public void imageSwitch(){
        if (Greenfoot.isKeyDown("up")){
             setImage("rocketWithThrust.png");
              int rotation = getRotation();
              double force = .3;
               Vector ignite = new Vector (rotation, force);
               addForce(ignite);
            }
             else if (!Greenfoot.isKeyDown("up")){
                 setImage("rocket.png"); 
                }
            }
     /**
      * Fire a bullet if the gun is ready. 
      */
     private void fire() 
     {
         if (reloadDelayCount >= gunReloadTime) 
         {
             Bullet bullet = new Bullet (getMovement().copy(), getRotation());
              getWorld().addObject (bullet, getX(), getY());
               bullet.move ();
               reloadDelayCount = 0;
            }
        }
         public void explode(){
             Asteroid asteroid = (Asteroid) getOneIntersectingObject(Asteroid.class);
             if (touched && asteroid == null)
             {
                 touched = false;
                }
        else if(!touched && asteroid != null)
    {
         getWorld().addObject( new Explosion(), getX(), getY());
         getWorld().removeObject(this);
         touched = true;
        }
    }
}

import greenfoot.*;  // (World, Actor, GreenfootImage, and Greenfoot)
import java.util.List;

/**
 * A proton wave that expands and destroys things in its path.
 * 
 * @author me
 * @version 1.0
 */
public class ProtonWave extends Actor
{
    /** The damage this wave will deal */
    private static final int DAMAGE = 30;
     private int imageCount = 0;
    /** How many images should be used in the animation of the wave */
    private static final int NUMBER_IMAGES= 60;
    
    /** 
     * The images of the wave. This is static so the images are not
     * recreated for every object (improves performance significantly).
     */
    private static GreenfootImage images;
        
    /**
     * Create a new proton wave.
     */
    public ProtonWave() 
    {
        initializeImages();
        setImage(images);
        Greenfoot.playSound("proton.wav");
    }
    
    /** 
     * Create the images for expanding the wave.
     */
    public static void initializeImages() 
    {
        if (images == null) 
        {
            GreenfootImage baseImage = new GreenfootImage("wave.png");
            images = new GreenfootImage();
            for (int i = 0; 
            While (i < NUMBER_IMAGES);

                int size = (i+1) * ( baseImage.getWidth() / NUMBER_IMAGES );
                images = new GreenfootImage(baseImage);
                images.scale(size, size);
                i++;
            }
        }
    }
    
    /**
     * Act for the proton wave is: grow and check whether we hit anything.
     */
    public void act()
    { 
        checkCollision();
        grow();
    } 
    private void grow()
      { if ((imageCount>= NUMBER_IMAGES))
          {
             getWorld().removeObject(this);
            }
            else
            {
                setImage(images);
                 imageCount++;
                }
            }
    /**
     * Explode all intersecting asteroids.
     */
    private void checkCollision()
    {
        int range = getImage().getWidth() / 2;
        List<Asteroid> asteroids = getObjectsInRange(range, Asteroid.class);     
        
        for (Asteroid a : asteroids) 
        {
            a.hit (DAMAGE);
        }
    }

}