package view;

import java.awt.Color;

//Cette classe represente la partie graphique d'une boule.
//Elle permet donc de dessiner une boule en fonction de ses caracteristiques (dimension et position).

public class BallView extends ShapeView{

	private static final long serialVersionUID = 1L;
	private int radius;
	private Color color;
	private Point2D.Double posInit;
	private Ball ball;
	
	public BallView(Drawing drawing, Ball ball) {
		this.drawing = drawing;
		this.position = ball.getPosition();
		this.color = ball.getColor();
		this.radius = ball.getRadius();
		this.posInit = ball.getPosInit();
		this.ball = ball;
	}
	
	@Override
	public void paintComponent(Graphics g) {
		this.position = ball.getPosition();
		g.setColor(this.color);
		int radiusMouche = 3;
		if(!g.getColor().equals(Color.red) && !g.getColor().equals(Color.white))
			g.fillOval((int) (posInit.x - radiusMouche) ,(int) (posInit.y - radiusMouche), 2*radiusMouche, 2*radiusMouche);
		
		g.fillOval((int) (position.x - radius) ,(int) (position.y - radius), 2*radius, 2*radius);
	}

	
}

package view;

import java.awt.Graphics;

//Cette super-classe regroupe les objets graphiques qui servent a dessiner des "Shapes".
//Elle implemente egalement le pattern Observer pour pouvoir actualiser les dessins.

public abstract class ShapeView extends Rectangle implements Observer{
	
	private static final long serialVersionUID = 1L;
	// Origine du dessin par rapport ‡ la table.
	protected Point2D.Double position = new Point2D.Double();
	protected Drawing drawing;
	
	public Point2D.Double getPosition(){
		return position;
	}
	
	// Dessine la forme sur un objet graphic.
	public abstract void paintComponent(Graphics g);

	@Override
	public void update() {
		drawing.repaint();
	}
	
	public void delete(){
		ArrayList<ShapeView> shapes = drawing.getShapes();
		for(int i = 0 ; i < shapes.size() ; i++){
			if(shapes.get(i) == this)
				shapes.remove(i);
		}
		
	}
}

package model;

import java.awt.Color;

//Cette classe permet de particulariser la liste de balles.
//Cela signifie qu'elle ajoute des fonctionnalites qui permettent de gerer une liste de boules d'un jeu de billard.
//En particulier, elle va creer les boules (en les positionnant) et gerer leurs rebonds entre elles.

public class BallsList extends ArrayList<Ball>{

	private static final long serialVersionUID = 1L;
	
	protected int ballsRadius;
	protected int nbrBalls;
	protected Ball whiteBall;
	protected Color colorFirstBallTouched = null;
	
	public void initialize(){
		
		//boule blanche
		double posX = __Pool.tablePosX + __Pool.tableWidth - __Pool.whiteLinePos;
		double posY = __Pool.tablePosY + __Pool.tableHeight/2 + 2*ballsRadius;
		
		Point2D.Double pos = new Point2D.Double(posX,posY);
		whiteBall = new WhiteBall(pos, Color.WHITE, ballsRadius);
		
		//ajoute la boule blanche
		this.add(whiteBall);

	}
	
	public boolean add(Ball b){
		super.add(b);
		return true;
	}

	public void bounce(Ball a, Ball b){
		//Modifie les vitesses de deux boules a et b qui se collisionnent
		
		double posAPRBX = a.getPosition().x - b.getPosition().x; // Position relative de A par rapport  B selon x.
		double posAPRBY = a.getPosition().y - b.getPosition().y; // Position relative de A par rapport  B selon y.
		double inclinaisonAB = 0;
		try{
			inclinaisonAB = Math.atan(posAPRBY/posAPRBX);
		}
		catch (ArithmeticException e) {
			inclinaisonAB =  Math.PI/2;
		}
		inclinaisonAB = Math.abs(inclinaisonAB);
		
		double speedAParaAB = (Math.abs(a.getSpeed().x * Math.cos(inclinaisonAB))) + Math.abs((a.getSpeed().y * Math.sin(inclinaisonAB)));
		double speedBParaAB = (Math.abs(b.getSpeed().x * Math.cos(inclinaisonAB))) + Math.abs((b.getSpeed().y * Math.sin(inclinaisonAB)));

		if((speedAParaAB-speedBParaAB)>0){
				
			Point2D.Double newSpeedAParaAB = new Point2D.Double ((int) (Math.signum(b.getSpeed().x) * speedBParaAB * Math.cos(inclinaisonAB)), (int) (Math.signum(b.getSpeed().y) * speedBParaAB * Math.sin(inclinaisonAB)));
			Point2D.Double newSpeedBParaAB = new Point2D.Double ((int) (Math.signum(a.getSpeed().x) * speedAParaAB * Math.cos(inclinaisonAB)), (int) (Math.signum(a.getSpeed().y) * speedAParaAB * Math.sin(inclinaisonAB)));
		 
			Point2D.Double speedALeft = new Point2D.Double ( a.getSpeed().x - newSpeedBParaAB.x, a.getSpeed().y - newSpeedBParaAB.y); // chaque boule a perdu la vitesse transmis a l'autre
			Point2D.Double speedBLeft = new Point2D.Double ( b.getSpeed().x - newSpeedAParaAB.x, b.getSpeed().y - newSpeedAParaAB.y);
		 
			Point2D.Double finalSpeedA = new Point2D.Double ( speedALeft.x + newSpeedAParaAB.x, speedALeft.y + newSpeedAParaAB.y);
			Point2D.Double finalSpeedB = new Point2D.Double ( speedBLeft.x + newSpeedBParaAB.x, speedBLeft.y + newSpeedBParaAB.y);
		 
			a.setSpeed(finalSpeedA);
			b.setSpeed(finalSpeedB);
		}
	}
	
	public void collisions (Ball b)
	{	//Verifie tous les rebonds que la boule b va engendrer
		//Cette fonction est recursive car quand une boule a collisionne une boule b (et donc change sa vitesse), il faudra alors reverifier tous les rebonds que la boule b pourrait engendrer avec cette nouvelle vitesse.
		if (b.isMoving()){
			Ball copyBall = null;
			try {
				//pour Èviter les chevauchements on cree une copie de la boule
				copyBall = b.clone();
				copyBall.move();
				// On fait rebondir les boules
				for(Ball c : this){
					// test si une boule possede une intersection avec une autre (attention a ne pas tester entre une boule et elle meme)
					if (copyBall.isOnShape(c) && b != c)
					{
						// on rÈcupËre la couleur de la premiËre balle touchÈe et on s'assure d'en avoir touchee une
						if (colorFirstBallTouched == null && (b.getColor() == Color.white || c.getColor() == Color.white)){
							if (b.getColor() == Color.white)
								colorFirstBallTouched = c.getColor();
							else
								colorFirstBallTouched = b.getColor();
						}
						this.bounce(b,c);
						collisions (c);
					}
				}
			} catch (CloneNotSupportedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}	
	}
	
	public Ball getWhiteBall()
	{
		Ball whiteBall = null;
		try{
			for (Ball c : this)
				if (c.getColor() == Color.white)
					whiteBall = c;
		}
		catch (NullPointerException e)
		{
		}
		
		return whiteBall;			
	}
	
	public boolean isRemovable(int i)
	{
		return true;
	}
	
	public void move(){
		//Fais bouger toutes les boules de la liste.
		for(Ball b : this){
			if(b.isMoving())
				b.move();
		}
	}
	
	public int getBallsRadius()
	{
		return ballsRadius;
	}
	
	public Color getColorFirstBallTouched()
	{
		return colorFirstBallTouched;
	}
	
	public void setColorFirstBallTouched(Color colorFirstBallTouched)
	{
		this.colorFirstBallTouched = colorFirstBallTouched;
	}
}

package model;

import java.awt.Color;

//Cette classe contient els principales caracteristiques d'une boule.
//C'est elle qui s'occupe de la faire bouger en fonction de la vitesse et quand c'est demande.

public class Ball extends Shape implements Cloneable{

	private static final long serialVersionUID = 1L;

	private int radius;
	private Color color;
	private Point2D.Double posInit;
	private Point2D.Double speed;
	
	public Ball(Point2D.Double posInit, Color color, int radius) {
		// TODO Auto-generated constructor stub
		this.color = color;
		this.radius = radius;
		this.position = posInit;
		this.posInit = new Point2D.Double(posInit.x,posInit.y);
		this.speed = new Point2D.Double();
		this.setBounds(this.position.x - radius, this.position.y - radius, 2*radius, 2*radius);	
	}
	
	public Ball(){
		
	}
	
	protected void delay(int waitTime){
		try{
			Thread.sleep(waitTime);
		}catch(InterruptedException e) {}
	}
	
	public void replacement(__Pool pool){}
	
	public void move(){
		
		int divFactor = 5;
		position.x += speed.x/divFactor;
		position.y += speed.y/divFactor;
		
		this.setPosition(new Point2D.Double(position.x,position.y));
		
		speed.x *= 1 - Table.frotTable;
		speed.y *= 1 - Table.frotTable;
	
		this.setBounds(position.x - radius,position.y - radius, 2*radius, 2*radius);
	}	
	
	public boolean overLine(boolean vertical, double positionTopLeft, double positionDownRight)
	{
		if(vertical){
			return ((this.position.x+this.radius>positionDownRight && this.speed.x>0) || (this.position.x-this.radius<positionTopLeft && this.speed.x<0));
		}
		else{
			return ((this.position.y+this.radius>positionDownRight && this.speed.y>0) || (this.position.y-this.radius<positionTopLeft && this.speed.y<0));
		}
	}
	
	public boolean isMoving()
	{// Arret la balle lorsque sa vitesse est trop faible (sinon elle met trop de temps pour s'arreter)
		double norm = Math.sqrt((speed.x*speed.x) + (speed.y*speed.y));
		boolean motion = false;
		
		if(norm  <  1.0) 
			setSpeed(new Point2D.Double(0,0));
		else
			motion =  true;
		
		return motion;
	}
	
	public Ball clone() throws CloneNotSupportedException{ 
		Ball ball = null;
		try {
			ball = (Ball) super.clone();
			ball.posInit = (Double) posInit.clone();
			ball.speed = (Double) speed.clone();
		} catch(CloneNotSupportedException cnse) {
			cnse.printStackTrace(System.err);
		}		
		return ball; 
	} 

	
	/*********************************************************************
	 * 				
	 * 								ACCESSEURS
	 * 
	 ********************************************************************** */
	@Override
	public void setPosition(Point2D.Double p){
		this.position = p;
		this.setBounds(this.position.x - radius, this.position.y -radius, 2*radius, 2*radius);
		
		//Des que la position de la bille change, il faut le signaler a la vue
		notifyObserver();
	}

	public Point2D.Double getSpeed() {
		return this.speed;
	}

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

	public int getRadius() {
		return this.radius;
	}

	public Color getColor() {
		return this.color;
	}
	
	public Point2D.Double getPosInit() {
		return posInit;
	}
	
}