import greenfoot.*;
import java.util.*;

public abstract class Towers extends Actor
{
    
    private boolean isGrabbed; // wordt de tower grabbed (mouse vasthouden en rontrekken)
    private int tellerGrabbed; // teller voor grabbed
    private int box; // de grote van de snap box (vierkant selectie helper)
    private boolean release; // wordt de tower losgelaten
    private Enemies enemie; // veld voor klasse Enemies met de naam enemie
    private boolean validate; // valideren of de tower op de juiste plaats staad
    private int validateTeller;

    public Towers()
    {
        isGrabbed = false;
        tellerGrabbed = 0;
        box = 10;
        release = false;
        validate = true;
        validateTeller = 0;
    }

    public void act() 
    {
        // Als release niet waar is.
        if (release)
        {
            validateLocation();
            // Lijst van klasse Enemies in de radius van 200
            List<Enemies> enemies = getObjectsInRange(200, Enemies.class);
            // Als enmies leeg is.
            if (enemies.isEmpty())
            {
            }
            else
            {
                // ga enemie uit array list halen.
                // getObjectsInRange(200, Enemies.class);
                enemie = enemies.get(0);
                turnTowards(enemie.getX(), enemie.getY()); 
            }
        }
        else
        {
            dragObj();
        }
    }

    /**
     * dragObj is de methode voor het verplaatsen van dit object.
     */
    private void dragObj()
    {
        /**
         * Als de muis ingedrukt is en niet isGrabbed.
         * Zet isGrabbed naar waar.
         * Krijg de info van wereld en verwijder dit object en plaats het terug.
         * Dit zorgt ervoor dat dit object telkens bovenaan blijft.
         */
        if (Greenfoot.mousePressed(this) && !isGrabbed)
        {
            MouseInfo mi = Greenfoot.getMouseInfo();
            // grab object
            isGrabbed = true;
            // Deze code dient om het object boven alle andere objecten te houden.
            World myWorld = getWorld();
            myWorld.removeObject(this);
            myWorld.addObject(this, mi.getX(), mi.getY());
            return;
        }

        /**
         * Hier neem ik de values van de TowerHelper array en verminder en vermeer ze met box.
         * Dan bekijk ik of de waarde van de muis hier tussen valt.
         * Indien ja zet ik de locatie op de TowerHelper array values. (Center van de plaats vierkantjes op de map.)
         * Anders volg de muis.
         */

        if (Greenfoot.mouseDragged(this) && isGrabbed)
        {
            MouseInfo mi = Greenfoot.getMouseInfo();
            int x = TowerHelper.getCordX(tellerGrabbed);
            int y = TowerHelper.getCordY(tellerGrabbed);

            if (mi.getX() >= x - box && mi.getX() <= x + box && 
            mi.getY() >= y - box && mi.getY() <= y + box){
                setLocation(x, y);
            }
            else{
                setLocation(mi.getX(), mi.getY());
                tellerGrabbed++;
            }

            // als de TowerHelper array lengte gelijk is aan teller zet teller terug op 0.
            if(tellerGrabbed == TowerHelper.getSizeOfCords()){
                tellerGrabbed = 0;
            }
            return;
        }

        /**
         * Check of de muis word gereleased.
         * Indien zo zet isGrabbed && release op false
         */
        if (Greenfoot.mouseDragEnded(this) && isGrabbed)
        {
            // release het object
            isGrabbed = false;
            release = true;
        }
    }

    private void validateLocation()
    {
        int x = TowerHelper.getCordX(validateTeller);
        int y = TowerHelper.getCordY(validateTeller);
        
        if (validate && validateTeller < TowerHelper.getSizeOfCords())
        {
            if(getX() > x + box && getX() > x - box && getY() > y + box && getY() < y - box)
            {
                validate = false;
            }
            validateTeller++;
        }

        if (!validate)
        {
            World myWorld = getWorld();
            myWorld.removeObject(this);
        }
    }
}

import greenfoot.*;
import java.util.*;

public class Cannon extends Towers
{
    private String cannonType;
    private int reloadDelayCount;
    private int shellReloadTime;
    private int tellerFire;

    public Cannon()
    {
        this("0");
    }

    public Cannon(String newCannon)
    {
        setCannon(newCannon);
        loadImage();
        reloadDelayCount = 0;
        shellReloadTime = 50;
        tellerFire = 0;
    }

    private void setCannon(String newCannon)
    {
        cannonType = newCannon;
    }

    /**
     * Gebruik de act van de super classe
     * Maak een for lus zodoende het wapen pas schiet zodra het op de juiste plaats staad.
     * +1 reloadDelayCount
     */
    public void act() 
    {
        super.act();
        for (int i = 0; i < TowerHelper.getSizeOfCords(); i++)
        {
            int x = TowerHelper.getCordX(i);
            int y = TowerHelper.getCordY(i);
            
            if (getX() == x && getY() == y)
            {
                fireShell();
            }
        }
        reloadDelayCount++;
    }

    /**
     * Load Image
     */
    private void loadImage()
    {
        setImage("towers/cannon" + cannonType + ".png");
    }

    /**
     * De methode om een ammo soort af te vuren.
     * Als reloadDelayCount >= shellReloadTime, de groter dan is omdat tijdens de act +1 gedaan wordt.
     * Maak een nieuwe ammo soort aan en zet de x en y positie van de ammo.
     * Zet een standaard move in zodat de ammo vanop de juiste plaats zichtbaar word.
     * Zet de reloadDelayCount terug op 0.
     */
    public void fireShell()
    {
        if (reloadDelayCount >= shellReloadTime)
        {
            Shell s = new Shell(getRotation());
            getWorld().addObject(s ,getX() ,getY());
            s.move(40);
            reloadDelayCount = 0;
        }
    }
}

/**
 * Deze klassen heeft een lijst(array) van verschillende posities, in dit geval voor Tower.
 */
public class TowerHelper  
{
    // Maak een array van de classe Position met veld naam positions.
    private static Position[] positions;

    // positions = nieuwe array Positions[index].
    static
    {
       positions = new Position[] {
           new Position(224, 32),
           new Position(416, 32),
           new Position(96, 160),
           new Position(288, 224),
           new Position(352, 224),
           new Position(416, 224),
           new Position(96, 288),
           new Position(608, 288),
           new Position(224, 416),
           new Position(288, 416),
           new Position(352, 416),
           new Position(608, 480),
           new Position(160, 608),
           new Position(288, 608),
           new Position(352, 608)
        };  
    }
    
    /**
     * Deze constructor mag niet gebruikt worden daarom private
     */
    private TowerHelper()
    {
    }
    
    /**
     * Geef de X waarde terug van een positie in de lijst
     * 
     * @param index integer waarde voor het krijgen van een posisitie uit de array.
     * @return de integer waarde X van een Position
     */
    public static int getCordX(int index)
    {
        // return value getX() van Position uit array positions vb positions[0].getX() = Posititions(224,32). methode getX()
        return positions[index].getX();
    }
    
    /**
     * Geef de Y waarde terug van een positie in de lijst
     * 
     * @param index integer waarde voor het krijgen van een posisitie uit de array.
     * @return de integer waarde Y van een Position
     */
    public static int getCordY(int index)
    {
        // return value getY() van Position uit array positions vb positions[0].getY() = Posititions(224,32). methode getY()
        return positions[index].getY();
    }
    
    /**
     * Geef de aantal elementen in de lijst(array) terug.
     * 
     * @return returns de length van de array
     */
    public static int getSizeOfCords()
    {
        // Return de value length van positions.
        return positions.length;
    }
}

/**
 * Deze klasse heb je nodig om een beter onderscheid te maken waar alles gepositioneerd dient te worden
 * op je scherm. Momenteel kent Position enkel maar X en Y, maar er zijn meerdere mogelijkheden vanaf nu.
 * 
 * Dien je meer informatie te gaan stokeren, dan is het misschien beter om afgeleide klassen te maken,
 * deze zullen er dan voor zorgen je X en Y cadeau krijgt, maar extra informatie is dan beschikbaar in de
 * afgeleide klasse.
 * 
 */

public class Position  
{
    // De X coordinaat van een element
    private int x;
    // De Y coordinaat van een element
    private int y;
   
    public Position()
    {
       // lege constructor
    }
   
    /**
     * @param x een integer representatie van the mogelijke x waarde
     * @param y een integer representatie van the mogelijke y waarde
     */
    public Position(int x, int y)
    {
        this.x = x;
        this.y = y;
    }
    
    /**
     * Deze getter geeft je de x waarde terug
     * @return de integer value van x
     */
    public int getX()
    {
        return x;
    }
    
    /**
     * Deze setter laat je toe om de reeds ingevulde X waarde te onverschrijven
     * @param x een integer representatie van the mogelijke x waarde
     */
    public void setX(int x)
    {
        this.x = x;
    }
    
    /**
     * Deze getter geeft je de y waarde terug
     * @return de integer value van y
     */
    public int getY()
    {
        return y;
    }
    
    /**
     * Deze setter laat je toe om de reeds ingevulde Y waarde te onverschrijven
     * @param y een integer representatie van the mogelijke y waarde
     */
    public void setY(int y)
    {
        this.y = y;
    }
}