Temp

package Breakout;

import java.awt.Color;
import java.awt.Component;

import acm.graphics.*;
import acm.program.*;

public class FunctionalityTest extends GraphicsProgram{

//	private static final double SIZE = 5;
//	AnimatedBall redBall = new AnimatedBall(SIZE);

	public void run() {
		
		setSize(Model.getWidth(), Model.getHeight());
		
		AnimatedBall curBall = Model.getRedBall(); 
		
		curBall.setFilled(true);
		curBall.setColor(Color.RED);
		add(curBall, Model.getBallStart());
		
		AnimatedPaddle curPaddle = Model.getPaddle();
		
		curPaddle.setFilled(true);
		curPaddle.setColor(Color.BLACK);
		add(curPaddle, Model.getPaddleStart());
		
		GLabel startMessage = new GLabel("Click to start Breakout!");
		startMessage.setLocation(Model.getPaddleStart().getX() - 50, Model.getPaddleStart().getY() + 25);
		add(startMessage);
		
		Thread curBallThread = new Thread(curBall);
		Thread curPaddleThread = new Thread(curPaddle);
			
		waitForClick();
		remove(startMessage);
		curBallThread.start();
		curPaddleThread.start();
		
		while(curBallThread.isAlive() && !Model.isLost() && !Model.isWon()){
			println(curBall.getLocation().toString());
			
			
			if(wouldCollideWith(curBall) != null){
				curBall.setDirection(calculateDirection(curBall,getElementAt(curBall.getX(),curBall.getY())));
			}

		}
	}

private Object wouldCollideWith(AnimatedBall curBall) {
	
	double deltaX = Math.sin(curBall.getDirection()) * AnimatedBall.getDelta();
	double deltaY = Math.cos(curBall.getDirection()) * AnimatedBall.getDelta();
	double redX = curBall.getX();
	double redY = curBall.getY();
	double size = AnimatedBall.getBallSize();
	
	
	Object collisionObject = null;
	
	collisionObject = getElementAt(redX + deltaX, redY + deltaY);
	if(!(collisionObject instanceof GCanvas)){
		collisionObject = getElementAt(redX + deltaX + size , redY + deltaY);
		if(!(collisionObject instanceof GCanvas)){
			collisionObject = getElementAt(redX + deltaX , redY + deltaY + size);
			if(!(collisionObject instanceof GCanvas)){
				collisionObject = getElementAt(redX + deltaX + size, redY + deltaY + size);
			}else{
				/*When all cllisionObjects were GCanvas*/
				collisionObject = null;
			}
		}
	}
	return collisionObject;
}
		
	private double calculateDirection(AnimatedBall redBall, Object elementAt) {
		double newDirection = redBall.getDirection();
//		if(redBall.getX() >= Model.getWidth() || redBall.getX() <= 0 || redBall.getY() <= 0){
//			reflect(redBall);
//t		}
		if(elementAt != null){
			if(elementAt instanceof AnimatedPaddle){
				newDirection = paddleReflect(redBall, elementAt);
			}else if(elementAt instanceof Brick /*|| elementAt instanceof Wall*/){
				newDirection = reflect(redBall);
//			}else if(elementAt instanceof Bottom){
//				Model.setLost(true);
			}
		}else{
			assert false : "No collision object handed to calculate new direction.";
		}
		
		assert newDirection == redBall.getDirection() : "No new direction set.";
		return newDirection;
	}

	private double paddleReflect(AnimatedBall redBall,  Object elementAt) {
		double direction = redBall.getDirection();
		assert(360 >= direction && 0 <= direction):"Invalid direction.";
		
		double xBall = redBall.getLocation().getX();
		double xPaddle = ((Component) elementAt).getLocation().getX();
		
		double deltaDistance = xBall - (xPaddle + redBall.getWidth() / 2.0);
		double deltaMax = ((Program) elementAt).getWidth() / 2.0 +  redBall.getWidth();
		
		double newDirection;
		if(direction <= 180){
			newDirection = 180 - direction;
		}else{
			newDirection = 360 - direction;
		}
		newDirection = newDirection - (deltaDistance/deltaMax * newDirection);

				
		return newDirection;
	}

	private double reflect(AnimatedBall redBall) {
		double newDirection;
		double direction = redBall.getDirection();
		int side = (int) (direction / 180);
		switch (side) {
		case 0:
			newDirection = 180 - direction;
		case 1:
			newDirection = 360 - direction;
		default:
			assert (false): "Reflection can not be callucalted correctly";
			newDirection = direction;
		}
		return newDirection;
	}	
	
}

///////////////////////////////////////////////////////////////////////////////////////////



package Breakout;

	import java.awt.MouseInfo;
	import java.awt.Point;
	import java.awt.PointerInfo;
	import acm.graphics.GRect;
//	import acm.program.*;
	
	
	public class AnimatedPaddle extends GRect implements Runnable{

		/* Private instance variables */
		private static double width = 50;
		private static double height = 10;
		
		/* Creates a new AnimatedRectangle of the specified size */
		public AnimatedPaddle(double width, double height) {
			super(width, height);
		}
		
		/* Runs when this object is started to animate the rectangle */
		public void run() {
			
			//while(Model.isRunning() == true){
			while(true){
				PointerInfo pointer = MouseInfo.getPointerInfo();
				Point point = pointer.getLocation();
				double x = point.getX();
				this.setLocation(x - width / 2, Model.getHeight() - 100);
			}
		}
		
		private void setLocation(double d, int i) {
			// TODO Auto-generated method stub
			
		}

		public static double getPaddleWidth() {
			return width;
		}
		
		public static double getPaddleHeight() {
			return height;
		}

		public static void setWidth(double width) {
			AnimatedPaddle.width = width;
		}
		
		public static void setHeight(double height) {
			AnimatedPaddle.height = height;
		}
	}



///////////////////////////////////////////////////////////////////////////////////////////



package Breakout;

import acm.graphics.GOval;
import acm.util.RandomGenerator;

public class AnimatedBall extends GOval implements Runnable{

	/* Private instance variables */
	private double direction = 90;
	private static int size = 5;
//	private double x = 150;
//	private double y = 350;
	
	static final int PAUSE_TIME = 20;
	static final int CHANGE_TIME = 50;
	private static double DELTA = 2;
	
	/* Creates a new AnimatedBall of the specified size */
	public AnimatedBall(double size) {
		super(size,size);
	}
	
	/* Runs when this object is started to animate the ball */
	
	public void run() {
		
		//while(Model.isRunning() == true){
		while(true){
			movePolar(DELTA, direction);
			pause(PAUSE_TIME);
		}
	}
	
	public void setDirection(double dir){
		this.direction = dir;
	}

	public double getDirection(){
		return direction;
	}

	public static double getDelta() {
		return DELTA;
	}
	
	public static int getBallSize() {
		return size;
	}

	public static void setSize(int size) {
		AnimatedBall.size = size;
	}



	
	
//	public double getY() {
//		return y;
//	}
//
//	public void setY(double y) {
//		this.y = y;
//	}
//
//	public double getX() {
//		return x;
//	}
//
//	public void setX(double x) {
//		this.x = x;
//	}
	
	
	
}




///////////////////////////////////////////////////////////////////////////////////////////




package Breakout;

import acm.graphics.*;
import acm.program.*;

public class Model {
	
	/*Activity state of Model*/
	private static boolean won = false;
	private static boolean lost = false;
	private static boolean running = true;
	
	/*Field specification*/
	private static final int HEIGHT = 600;
	private static final int WIDTH = 250;
	
	/*Ball specification*/
	private static final GPoint BALL_START = new GPoint(WIDTH/2,HEIGHT/2);
	private static AnimatedBall redBall = new AnimatedBall(AnimatedBall.getBallSize());
	
	/*Paddle specification*/
	private static int paddleWidth = 50;
	private final double PADDLE_HEIGHT = 5;
	private static AnimatedPaddle paddle = new AnimatedPaddle(AnimatedPaddle.getPaddleWidth(), AnimatedPaddle.getPaddleHeight());
	private static final GPoint PADDLE_START = new GPoint(WIDTH/2 - paddleWidth/2,HEIGHT - 100 );
	
	
	public static boolean isRunning() {
		return running;
	}

	public static void setRunning(boolean newRunStatus) {
		running = newRunStatus;
	}

	public static GPoint getBallStart() {
		return BALL_START;
	}

	public static int getHeight() {
		return HEIGHT;
	}

	public static int getWidth() {
		return WIDTH;
	}

	public static AnimatedBall getRedBall() {
		return redBall;
	}

	public static void setRedBall(AnimatedBall redBall) {
		Model.redBall = redBall;
	}

	public static GPoint getPaddleStart() {
		return PADDLE_START;
	}

	public double getPADDLE_HEIGHT() {
		return PADDLE_HEIGHT;
	}

	public static boolean isLost() {
		return lost;
	}

	public static void setLost(boolean lost) {
		Model.lost = lost;
	}

	public static boolean isWon() {
		return won;
	}

	public static void setWon(boolean won) {
		Model.won = won;
	}

	public static AnimatedPaddle getPaddle() {
		return paddle;
	}

}