apackage animationPersonnages;

import java.awt.Color;
import java.util.ArrayList;
import java.util.Random;

import personnages.Balle;
import personnages.BalleAttaque;
import personnages.Personnage;

/** Cette classe sert a "lancer des balles" a l'horizontal, avec une vitesse
 *  aleatoire dont le minimum et le maximum  peuvent etre modifies.
 *  On peut construire une liste de "personnages", appelees ici 
 *  "promeneurs". 
 * Lorsqu'une balle atteint un des "promeneurs", celui-ci est tue */
public class LanceBalles implements Runnable
{
	static Random aleat;
	private   int y;
	private  int direction = Balle.DROITE;
	private  int vitesseMax = IHMJeuBalles.VITESSE_RAPIDE;
	private  int vitesseMin = IHMJeuBalles.VITESSE_LENTE;
	private  IHMJeuBalles  jeu;
	private  boolean fonctionne = true;
	private ArrayList<BalleAttaque> lesBalles = new ArrayList<BalleAttaque>();
	private int compteur;
	private boolean promeneurTouche = false;
	private int delai;

	/** Constructeur de la classe
	 * @param zone  composant graphique dans lequel l'action se passe
	 * @param y  hauteur de l'apparition des balles dans la fenetre,
	 *     comptee a partir du haut de la fenetre.*/
	public LanceBalles(IHMJeuBalles jeu, int y) {
		this.jeu = jeu;
		this.y = y;
	}
	static {
		aleat = new Random();
	}

	/** @return la balle */
	public ArrayList<BalleAttaque> getLesBalles() {
		return lesBalles;
	}

	public boolean isPromeneurTouche() {
		return promeneurTouche;
	}

	public void setPromeneurTouche(boolean promeneurTouche) {
		this.promeneurTouche = promeneurTouche;
	}

	/** fixe la vitesse minimum de la balle, en pixels par seconde 
	 * @param  vitesseMin la valeur choisie */
	public void setVitesseMin(int vitesseMin)
	{
		this.vitesseMin = vitesseMin;
		if (vitesseMin > vitesseMax) vitesseMin = vitesseMax;
	}

	/** @return le nombre de balles evitees */
	public int getCompteur() {
		return compteur;
	}

	public int getDelai() {
		return delai;
	}

	public void setDelai(int vitesse) {
		this.delai = 50 * (IHMJeuBalles.VITESSE_LENTE + 
				IHMJeuBalles.VITESSE_RAPIDE - vitesse);
	}
	
	/** change la valeur du compteur */
	public void setCompteur(int compteur) {
		this.compteur = compteur;
		jeu.actualiserLabelEtat();
	}

	/** si la valeur est mise a false, le lanceur de balles 
	 * est definitivement stoppe */
	public void setFonctionne(boolean fonctionne) {
		this.fonctionne = fonctionne;
	}

	/** fixe la vitesse maximum de la balle, en pixels par seconde 
	 * @param  vitesseMax  la valeur choisie*/
	public void setVitesseMax(int vitesseMax) {
		this.vitesseMax = vitesseMax;
		if (vitesseMax < vitesseMin) vitesseMax = vitesseMin;
	}

	public void demarrer() {
		fonctionne = true;
		Thread t = new Thread(this);
		t.setPriority(Thread.MAX_PRIORITY );
		new Thread(this).start();
	}

        public void retirer(BalleAttaque balle) {
	    lesBalles.remove(balle);
	}

        public void vider() {
	    for (BalleAttaque b : lesBalles) {
		if (b.isAlive()) b.stopper();
	    }
	    lesBalles.clear();
        }

	/** "lance" de façon repetitive une balle a partir du bord droit 
     ou gauche (au hasard) de la fenetre, avec une vitesse comprise 
     entre les vitesses minimum et maximum.
     Les balles sont de type BalleAttaque. Si une balle rencontre un 
     promeneur enregistre, le promeneur est supprime.*/
	public void run()  {
		BalleAttaque balle;
		int x;
		int dir;

		while(fonctionne) {
			if (jeu.getPromeneur() != null)  {
				dir = aleat.nextInt(2);
				if (dir == 0) {
					direction = Personnage.DROITE;
					x = 0;
				}
				else {
					direction = Personnage.GAUCHE;
					x = jeu.getBounds().width; ;
				}
				balle = new BalleAttaque(jeu, x, y, 10, Color.RED);
				balle.setDirection(direction);
				balle.setPas(4);
				balle.setVitesse(vitesseMin + (int)(aleat.nextFloat() *
						(vitesseMax - vitesseMin)));
				lesBalles.add(balle);
				balle.start();
				try  {
					Thread.sleep(aleat.nextInt(delai) + 1000);
				}
				catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		}
		vider();
	}
}