import greenfoot.*;

/**
 * 
 * @author Edwin 
 */
public class Asteroid extends SmoothMover
{
    private int size;
    private int stability;
    Space space = (Space) getWorld();

    public Asteroid()
    {
        this(50);
    }


    public Asteroid(int size)
    {
        super(new Vector(Greenfoot.getRandomNumber(360), 2));
        setSize(size);
    }


    public Asteroid(int size, Vector velocity)
    {
        super(velocity);
        setSize(size);
    }

    public void act()
    {         
        move();
        checkShield();
        reverseMovement();
    }


    public void setSize(int size) 
    {
        stability = size;
        this.size = size;
        GreenfootImage image = getImage();
        image.scale(size, size);
    }


    public int getStability() 
    {
        return stability;
    }

    public void hit(int damage) 
    {
        stability = stability - damage;
        if (stability <= 0) 
        {
            breakUp();
        }
    }


    private void breakUp() 
    {
        Greenfoot.playSound("Explosion.wav");
        Space space = (Space) getWorld();
        if (size <= 16) {
            getWorld().removeObject(this);
            space.countScore(space.asteroidScore2);
        }
        else {
            int r = getVelocity().getDirection() + Greenfoot.getRandomNumber(45);
            double l = getVelocity().getLength();
            Vector speed1 = new Vector(r + 60, l * 1.2);
            Vector speed2 = new Vector(r - 60, l * 1.2);        
            Asteroid a1 = new Asteroid(size/2, speed1);
            Asteroid a2 = new Asteroid(size/2, speed2);
            getWorld().addObject(a1, getX(), getY());
            getWorld().addObject(a2, getX(), getY());        
            a1.move();
            a2.move();
            space.countScore(space.asteroidScore1);
            getWorld().removeObject(this);
        }
        int currentLevelFullScore = space.getTotalAsteroids()*space.oneAsteroidsPoints;

        if(space.getValueFromSpace() == currentLevelFullScore)
        {
            space.increaseGameLevel();
            int asteriodsForNextLevel = space.startAsteroids + space.getGameLevel()*space.asteroidsAddedEachLevel;
            space.addAsteroids(asteriodsForNextLevel);                
            space.totalAsteroidsIncrease(asteriodsForNextLevel);
            Greenfoot.playSound("levelUp.wav");
        }

    }



    public void checkShield()
    {
        Actor shield = getOneIntersectingObject(Shield.class);
        if (shield != null)
        {
            getWorld().removeObject(shield);
            turn(180);
        }
    }
}

    public void reverseMovement()
    {
        if(deltaY == 5)
        {
            exactY = -exactY;
        }
    }

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

/**
 * 
 * @author Edwin
 * 
 * @version 1
 */
public abstract class SmoothMover extends Actor
{
    private Vector velocity;
    private boolean shieldReady;
    private boolean moveBackward;
    private int shieldDelayCount = 500;
  
    private double exactX;
    private double exactY;

    public SmoothMover()
    {
        this(new Vector());
    }

    /**
     * Create new Mover initialised with given velocity.
     */
    public SmoothMover(Vector velocity)
    {
        this.velocity = velocity;
    }
    public void move() 
    {
        if (shieldReady == true)
        {
            moveBackward = true;
        }

        if (moveBackward == true)
        {
            exactX = exactX - velocity.getX();
            exactY = exactY - velocity.getY();
            shieldDelayCount--;
        }
        else
        {
            exactX = exactX + velocity.getX();
            exactY = exactY + velocity.getY();
        }
        if(shieldDelayCount == 0)
        {
            moveBackward = false;
            shieldDelayCount = 500;
        }
        if (exactX >= getWorld().getWidth()) {
            exactX = 0;
        }
        if (exactX < 0) {
            exactX = getWorld().getWidth() - 1;
        }
        if (exactY >= getWorld().getHeight()) {
            exactY = 0;
        }
        if (exactY < 0) {
            exactY = getWorld().getHeight() - 1;
        }
        super.setLocation((int) exactX, (int) exactY);
    }

    /**
     * Set the location using exact (double) co-ordinates.
     */
    public void setLocation(double x, double y) 
    {
        exactX = x;
        exactY = y;
        super.setLocation((int) x, (int) y);
    }

    public void setLocation(int x, int y) 
    {
        exactX = x;
        exactY = y;
        super.setLocation(x, y);
    }


    public double getExactX() 
    {
        return exactX;
    }

    public double getExactY() 
    {
        return exactY;
    }


    public void addToVelocity(Vector boost) 
    {
        velocity.add(boost);
    }

    public void accelerate(double factor)
    {
        velocity.scale(factor);
        if (velocity.getLength() < 0.15) 
        {
            velocity.setNeutral();
        }
    }

    /**
     * Return the speed of this actor.
     */
    public double getSpeed()
    {
        return velocity.getLength();
    }


    public void invertHorizontalVelocity()
    {
        velocity.revertHorizontal();
    }

 
    public void invertVerticalVelocity()
    {
        velocity.revertVertical();
    }


    public Vector getVelocity() 
    {
        return velocity.copy();
    }

    public void setShieldReady(boolean newStatus)
    {
        shieldReady = newStatus;

    }
}

    public void checkShield()
    {
        Actor shield = getOneIntersectingObject(Shield.class);
        if (shield != null)
        {
            getWorld().removeObject(shield);
            setShieldReady(true);
        }
        else
        {
            setShieldReady(false);
        }
    }