Intersects with Rectangle

[AntiTD.git] / src / se / umu / cs / dit06ajnajs / agent / Unit.java

package se.umu.cs.dit06ajnajs.agent;

import java.awt.Image;
import java.awt.Point;
import java.util.logging.Logger;

import se.umu.cs.dit06ajnajs.Paintable;
import se.umu.cs.dit06ajnajs.map.Map;
import se.umu.cs.dit06ajnajs.map.MapSquare;
import se.umu.cs.dit06ajnajs.map.Traversable;
import java.awt.Rectangle;

// TODO: write a testclass to test all get- set-positions with center top left..
public abstract class Unit implements Agent, Paintable, Cloneable {
    private static Logger logger = Logger.getLogger("AntiTD");

    private int x;
    private int y;
    private int centerX;
    private int centerY;

    private int width;
    private int height;

    private int speed;
    private int health;
    private int cost;

    private Image image;
    private Direction direction;
    private Map map;
    private boolean alive;
    private boolean pause;

    public Unit(int width, int height, int speed, int health,
                int cost, Image image) {
        this.width = width;
        this.height = height;
        setX(x);
        setY(y);
        this.speed = speed;
        this.health = health;
        this.cost = cost;
        this.image = image;

        this.alive = true;
        this.pause = false;
    }

    public void setImage(Image img) {
        // TODO Auto-generated method stub
    }

    public Image getImage() {
        return this.image;
    }

    public void act() {
        
            // Check if this unit has health left
            if (this.health >= 0) {
                // Check if this unit is active
                if (!pause) {
                    Point nextPos = getNextPosition();
                    // TODO check for collision on next position
                    move(nextPos);

                    // Land on current square
                    MapSquare currentSquare= map.getMapSquareAtPoint(centerX, centerY);
                    if (currentSquare instanceof Traversable) {
                        ((Traversable) currentSquare).landOn(this);
                    }
                }
                else {
                    // Toggle pause back to false;
                    pause = false;
                }
            } else {
                // Kill unit
                this.alive = false;
            }
    }



    public Point getNextPosition() {
        switch (direction) {
        case UP:
            logger.fine("UP");
            return new Point(x, y - speed);
        case DOWN:
            logger.fine("DOWN");
            return new Point(x, y + speed);
        case LEFT:
            logger.fine("LEFT");
            return new Point(x - speed, y);
        case RIGHT:
            logger.fine("RIGHT");
            return new Point(x + speed, y);
        default:
            System.err.println("Unit has not got a valid Direction");
            return null;
        }
    }

    public void move(Point p) {
        setX(p.x);
        setY(p.y);
    }

    public int getX() {
        return x;
    }

    public void setX(int x) {
        this.x = x;
        recalculateCenterX();
    }

    public int getY() {
        return y;
    }

    public void setY(int y) {
        this.y = y;
        recalculateCenterY();
    }

    public void setWidth(int width) {
        this.width = width;
        recalculateCenterX();
    }
    
    public void setHeight(int height) {
        this.height = height;
        recalculateCenterY();
    }

    public void setCenterX(int centerX) {
        this.centerX = centerX;
        setX(centerX - (width / 2));
    }
    
    public void setCenterY(int centerY) {
        this.centerY = centerY;
        setY(centerY - (width / 2));
    }
    
    public void setCenterPoint(int centerX, int centerY) {
        setCenterPoint(new Point(centerX, centerY));
    }
    
    public void setCenterPoint(Point point) {
        setCenterX(point.x);
        setCenterY(point.y);
    }
    
    public Point getCenterPoint() {
        return new Point(this.centerX, this.centerY);
    }

    public int getWidth() {
        return width;
    }

    public int getHeight() {
        return height;
    }

    public int getSpeed() {
        return speed;
    }

    public void setSpeed(int speed) {
        this.speed = speed;
    }

    public void setCost(int cost) {
        this.cost = cost;
    }

    public Direction getDirection() {
        return direction;
    }

    public void setDirection(Direction direction) {
        this.direction = direction;
    }

    public void setMap(Map map) {
        this.map = map;
    }

    public boolean isAlive() {
        return this.alive;
    }

    public void setAlive(boolean state) {
        this.alive = state;
    }

    public int getHealth() {
        return health;
    }
    
    
    /** Used to calculate and set a new x-center after x is changed. */
    private void recalculateCenterX() {
        this.centerX = this.x + this.width / 2;
    }
    
    /** Used to calculate and set a new y-center after y is changed. */
    private void recalculateCenterY() {
        this.centerY = this.y + this.height / 2;
    }

    /**
     * Decrease the units health
     * @param damage The number of health points to substract
     */
    public void damage(int damage) {
        this.health -= damage;
    }

    public void setHealth(int health) {
        this.health = health;
    }

    /**
     * Attemts to clone this Unit.
     *
     * @return A new instance of the same type as the instantiated Unit.
     */
    @Override
    public Object clone() {
        try {
            return super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
            throw new Error("Object " + this.getClass().getName()
                            + " is not Cloneable");
        }
    }
    
    public void setPause(boolean state) {
        this.pause = state;
    }

    @Override
    public String toString() {
        return this.getClass().getSimpleName();
    }
    
    public Rectangle getBounds() {
        return new Rectangle(x, y, width, height);
    }
    
    private Rectangle getFutureBounds() {
        Point nextPoint = getNextPosition();
        return new Rectangle(nextPoint.x, nextPoint.y, width, height);
    }
    
    public boolean intersects(Unit unit) {
        return this.getBounds().intersects(unit.getBounds());
    }
    
    public boolean intersectsNextMove(Unit unit) {
        return this.getFutureBounds().intersects(unit.getBounds());
    }
}