Enemie code?

/**
     * Test if we are close to one of the edges of the world. Return true if we are.
     */
    public boolean atWorldEdge()
    {
        if (getX() <= 1 || getX() >= getWorld().getWidth() - 1) {
            return true;
        }
        if (getY() <= 1 || getY() >= getWorld().getHeight() - 1 ) {
            return true;
        } else {
            return false;
        }
    }

List<Rocket> ships = getObjectsInRange(100,Rocket.class);

moveHorizontally(5.0);

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

/**
 * A variation of an actor that maintains a precise location (using doubles for the co-ordinates
 * instead of ints).  This allows small precise movements (e.g. movements of 1 pixel or less)
 * that do not lose precision.
 * 
 * @author Poul Henriksen
 * @author Michael Kolling
 * @author Neil Brown
 * @author Sven van Nigtevecht
 * 
 * @version 3.0.1
 */
public abstract class SmoothMover extends Actor
{
    private double exactX;
    private double exactY;
    
    /**
     * Move forward by the specified distance.
     * (Overrides the method in Actor).
     */
    public void moveHorizontally(int distance)
    {
        moveHorizontally((double)distance);
    }
    
    /**
     * Move forward by the specified exact distance.
     */
    public void moveHorizontally(double distance)
    {
        double radians = Math.toRadians(getRotation());
        double dx = Math.cos(radians) * distance;
        double dy = Math.sin(radians) * distance;
        setLocation(exactX + dx, exactY + dy);
    }
    
    /**
     * Move up or down.
     */
    public void moveVertically(int distance)
    {
        moveVertically((double) distance);
    }
    
    /**
     * Move up or down, really precise.
     */
    public void moveVertically(double distance)
    {
        double radians = Math.toRadians(getRotation());
        setLocation(exactX, exactY - distance);
    }
    
    /**
     * Set the location using exact coordinates.
     */
    public void setLocation(double x, double y) 
    {
        exactX = x;
        exactY = y;
        super.setLocation((int) (x + 0.5), (int) (y + 0.5));
    }
    
    /**
     * Set the location using integer coordinates.
     * (Overrides the method in Actor.)
     */
    @Override
    public void setLocation(int x, int y) 
    {
        exactX = x;
        exactY = y;
        super.setLocation(x, y);
    }
    
    /**
     * Return the exact x-coordinate (as a double).
     */
    public double getExactX() 
    {
        return exactX;
    }
    
    /**
     * Return the exact y-coordinate (as a double).
     */
    public double getExactY() 
    {
        return exactY;
    }
    
    /**
     * Return true if we can see an object of class 'clss' right where we are. 
     * False if there is no such object here.
     */
    public boolean canSee(Class clss)
    {
        return (getOneIntersectingObject(clss) != null);
    }
    
    /**
     * Try to eat an object of class 'clss'. This is only successful if there
     * is such an object where we currently are. Otherwise this method does
     * nothing.
     */
    public void eat(Class clss)
    {
        Actor actor = getOneIntersectingObject(clss);
        if(actor == null) return;
        getWorld().removeObject(actor);
    }
    
    /**
     * Test if we are close to one of the edges of the world. Return true is we are.
     */
    public boolean atWorldEdge()
    {
        if (getX() <= 1 || getX() >= getWorld().getWidth() - 1) {
            return true;
        }
        if (getY() <= 1 || getY() >= getWorld().getHeight() - 1 ) {
            return true;
        } else {
            return false;
        }
    }
}

public void moveHorizontally(double distance)  
    {
        double radians = Math.toRadians(getRotation());
        double dx = Math.cos(radians) * distance;
        double dy = Math.sin(radians) * distance;
        setLocation(exactX + dx, exactY + dy);
    }

public void moveHorizontally(double distance)  
    {
        double radians = Math.toRadians(getRotation());
        double dx = Math.cos(radians) * distance;
        double dy = Math.sin(radians) * distance;
        setLocation(getExactX() + dx, getExactY() + dy);
    }

private double exactX;
private double exactY;