move(1);

setLocation(getX(), getY()+1);

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

/**
 * Class Snake:
 * the head and the body segments are both of this class
 */
public class Snake extends Actor
{
    private Snake follower = null; // holds a reference to the body segment behind this one, if there is one
    
    /** Size of this Snake */
    private int size;
    
    /** When the stability reaches 0 the snake will break up */
    private int stability;

    
    /**
     * Act - do whatever the centipede wants to do. This method is called whenever
     * the 'Act' or 'Run' button gets pressed in the environment.
     */
    public void act() 
    {
        move();
        AbprallenMushroom ();
        turnAtEdge();
    }    
    
    private static final double WALKING_SPEED = 1.0;
   
    /**
     * Move forward in the current direction.
     */
    public void move()
    {
        double angle = Math.toRadians( getRotation() );
        int x = (int) Math.round(getX() + Math.cos(angle) * WALKING_SPEED);
        int y = (int) Math.round(getY() + Math.sin(angle) * WALKING_SPEED);
        
        setLocation(x, y);
    }
    
    /**
     * Make the snake sequence disappear
     */
    private void breakUp() 
    {
        Greenfoot.playSound("Explosion.wav");
        
        if (size <= 16) {
            // if we are already very small, just disappear
            getWorld().removeObject(this);
            return;
        }
    }
    
    /**
     * Return true if we can see an object of class 'class' right where we are. 
     * False if there is no such object here.
     */
    public boolean canSee(Class clss)
    {
        Actor actor = getOneObjectAtOffset(0, 0, clss);
        return actor != null;        
    }
    
    /**
     * Snake should turn, if running into a mushroom
     */
    public void AbprallenMushroom()
    {
        if (canSee(Mushroom.class))
        {
            setLocation(getX(), getY()+1);
        } 
    }
    
    /**
     * Test if we are close to one of the edges of the world. Return true is we are.
     */
    public boolean atWorldEdge()
    {
        if(getX() < 20 || getX() > getWorld().getWidth() - 20)
            return true;
        if(getY() < 20 || getY() > getWorld().getHeight() - 20)
            return true;
        else
            return false;
    }
    
   /**
    * This method works to make the snake turn at the edge
    */
   public void turnAtEdge()
   {
    if(atWorldEdge())
     {
           setLocation(getX(), getY()+1);

        } 
    }

     /**
     * Hit this snake dealing the given amount of damage.
     */
    public void hit(int damage) 
    {
        stability = stability - damage;
        if (stability <= 0) {
            breakUp();       
        }
    }
   
    /**
     * Create an asteroid with default size and speed.
     */
    public Snake()
    {
        this(15);
    }
    
    /**
     * Create an snake with a given size size, direction, and speed.
     */
    private Snake(int size)
    {
        setSize(size);
    }
    
    /**
     * Set the size of this asteroid. Note that stability is directly
     * related to size. Smaller asteroids are less stable.
     */
    public void setSize(int size) 
    {
        this.size = size;
        GreenfootImage image = getImage();
        image.scale(size, size);
    }
    
    /**
     * Method setFollower
     * allows the world to inform a segment which segment is following it
     * 
     * @param follows A parameter to recieve a reference to the body segment that follows this one
     */
    public void setFollower(Snake follows)
    {
        follower = follows;
    }

}

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.
 * 
 * @version 2.0
 */
public class Rocket extends Mover
{
    private int gunReloadTime;              // The minimum delay between firing the gun.
    private int reloadDelayCount;           // How long ago we fired the gun the last time.
    private Vector acceleration;            // A vector used to accelerate when using booster.
    private int shotsFired;                 // Number of shots fired.
    
    private GreenfootImage rocket = new GreenfootImage("rocket.png");
    //private GreenfootImage rocketWithThrust = new GreenfootImage("rocketWithThrust.png");

    /**
     * Initialise this rocket.
     */
    public Rocket()
    {
        gunReloadTime = 0;
        reloadDelayCount = 0;
        acceleration = new Vector(0, 0.3);    // used to accelerate when thrust is on
        shotsFired = 0;
    }
    
    /**
     * 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()
    {
        move();
        checkKeys();
        reloadDelayCount++;
    }
    
    /**
     * Return the number of shots fired from this rocket.
     */
    public int getShotsFired()
    {
        return shotsFired;
    }
    
    /**
     * Set the time needed for re-loading the rocket's gun. The shorter this time is,
     * the faster the rocket can fire. The (initial) standard time is 20.
     */
    public void setGunReloadTime(int reloadTime)
    {
        gunReloadTime = reloadTime;
    }
    
    /**
     * Check whether there are any key pressed and react to them.
     */
    private void checkKeys() 
    {
        if(Greenfoot.isKeyDown("left")) {
            move(-1);
        }        
        if(Greenfoot.isKeyDown("right")) {
            move(1);
        }
        if(Greenfoot.isKeyDown("space")) {
            fire();
        }        
    }
    
    /**
     * Fire a bullet if the gun is ready.
     */
    private void fire() 
    {
        if (reloadDelayCount >= gunReloadTime) {
            Bullet b = new Bullet(getMovement().copy(), getRotation());
            getWorld().addObject(b, getX(), getY());
            b.move();
            shotsFired++;
            reloadDelayCount = 0;   // time since last shot fired
        }
    }
}

System.out.println("Bullet shot");