Script directionnel pour le rebondissement d'une balle

Soyez le premier à donner votre avis sur cette source.

Snippet vu 4 426 fois - Téléchargée 15 fois

Contenu du snippet

ce code permet de gérer le déplacement et le rebondissment d'une balle sur interface graphique, dans le cadre du jeu ping pong.

Source / Exemple :


public class ThreadBougeBalle implements Runnable{
    public final static int NORMAL = 1;
    public final static int INVERSE = -1;
    public final static int FPS = 20;
    public final static int EN_TRAIN_DE_JOUER = 20000000;
    public final static int EN_ARRET = 444444444;
    private int etat;
    public final static int CADENCE = 1000 / FPS;
    public final static boolean IS_ALIVE = true;

    private volatile boolean threadSuspendu;

    private Thread thread;
    private int direction_x;
    private int direction_y;
    private int vitesse;
    private ModeleBalle entiteControlee;
    private ModeleSurface entiteEcoutee;

    public ThreadBougeBalle(ModeleBalle mb,ModeleSurface ms){
        entiteControlee = mb;
        entiteEcoutee=ms;
        vitesse = 1;
        direction_x = 1;
        direction_y = 2;
        threadSuspendu = false;
        etat = 0;
    }

    public synchronized void start(){
        if(thread==null){
            thread = new Thread(this);
            if(!enTrainDeJouer()){
                thread.start();
            }
        }else{
                if(threadSuspendu&&enTrainDeJouer()){
                    threadSuspendu = false;
                    notify();
                }else{
                    if(!enTrainDeJouer())
                        thread.start();
                }
        }
    }

    public void stop(){
        threadSuspendu = true;
    }

    public void run(){
        while(IS_ALIVE){
            try{
                eventuel_choc();
                entiteControlee.setPosition(entiteControlee.getPosition().getX()+direction_x,(entiteControlee.getPosition().getY()+direction_y));
                Thread.sleep(10);
            }catch(InterruptedException e){
                e.printStackTrace();
            }
        }
    }

    private void eventuel_choc(){
       if((entiteControlee.getPosition().getY()<0)){
            direction_y = Math.abs(direction_y);
       }else if((entiteControlee.getPosition().getY()==370)||(entiteControlee.getPosition().getY()==371)){
            //Est ce qu'une raquette(au moins) touche la balle?
            if(presence_raquette(entiteControlee.getPosition().getX())){
                ArrayList meilleurs = meilleure_postion(entiteControlee.getPosition().getX());
                modifier_trajectoire(entiteControlee.getPosition().getX(),((ModeleRaquette)(meilleurs.get(0))).getPosition().getX());
                direction_y = Math.abs(direction_y)*(-1);
            }
       }else if(400<entiteControlee.getPosition().getY()){
            direction_y = Math.abs(direction_y)*(-1);
       }

       if(500<entiteControlee.getPosition().getX()){
            direction_x = Math.abs(direction_x)*(-1);
       }else if(0>entiteControlee.getPosition().getX()){
        direction_x = Math.abs(direction_x);
       }

    }

    public void avance(){
        direction_x = NORMAL;
    }

    public void recule(){
        direction_x = INVERSE;
    }

    public void arret(){
        etat = EN_ARRET;
    }

    public void lecture(){
        etat = EN_TRAIN_DE_JOUER;
    }

    public void setVitesse(int v){
        vitesse = v;
    }

    public boolean enTrainDeJouer(){
        return(etat==EN_TRAIN_DE_JOUER);
    }

    public int getEtat(){
        return etat;
    }

    private ArrayList meilleure_postion(int x) {
        ArrayList res = new ArrayList();
        int min_ecart = ModeleRaquette.LONGUEUR;
        for(int i=0;i<entiteEcoutee.getNombreJoueurs();i++){
            //Copie du tableau de joueurs + calcul du minimum d ecart entre la meilleure raquette et la balle
            res.add((ModeleRaquette)(entiteEcoutee.accederJoueur(i)));
            int x_joueur = ((ModeleRaquette)(entiteEcoutee.accederJoueur(i))).getPosition().getX();
            min_ecart = (Math.abs(x_joueur-x)<min_ecart)?Math.abs(x_joueur-x):min_ecart;
        }

         //On supprime de res toutes les raquettes n'ayant pas l'ecart minimum
        for(int i=0;i<entiteEcoutee.getNombreJoueurs();i++){
            ModeleRaquette mr = ((ModeleRaquette)(entiteEcoutee.accederJoueur(i)));
            int x_joueur = mr.getPosition().getX();
            int ecart = Math.abs(x_joueur-x);
            if(ecart!=min_ecart)
                res.remove(mr);
        }
        return res;
    }

    private boolean presence_raquette(int x){
        for(int i=0;i<entiteEcoutee.getNombreJoueurs();i++){
            int x_joueur = ((ModeleRaquette)(entiteEcoutee.accederJoueur(i))).getPosition().getX();
            if((x_joueur<x)&&(x<(x_joueur+ModeleRaquette.LONGUEUR)))
                return true;
        }
        return false;
    }

    private void modifier_trajectoire(int x_balle,int x_joueur){
        int centre_raquette = x_joueur+(ModeleRaquette.LONGUEUR/2);
        //System.out.println(centre_raquette+"    "+x_balle);
        for(int x=0;x<5;x++)
            if(centre_raquette-((ModeleRaquette.LONGUEUR/2)*(0.2*x))<=x_balle&&x_balle<=centre_raquette+((ModeleRaquette.LONGUEUR/2)*(0.2*x))){
                if(x!=0)
                    direction_x = x*(direction_x/Math.abs(direction_x));
                return;
            }
    }

}

A voir également

Ajouter un commentaire

Commentaire

Messages postés
120
Date d'inscription
lundi 26 février 2007
Statut
Membre
Dernière intervention
7 octobre 2011

Il n'y a qu'un seul fichier source ? Alors c'est quoi ModeleBalle et ModeleSurface ? Pas très claire tous ça, ou alors c'est que j'ai toujours les deux yeux un peu collé par la fatigue... Je met 5.

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.