[recherche source en java du jeux tennis] Fermé

Question

bjour, eske kelk1 peut me donner 1 lien ou le code source d'un jeux de tennis trés simple svp

bucher55 · Accepted Answer

import javax.swing.JPanel;
import javax.swing.JFrame;
import javax.swing.BoxLayout;
import javax.swing.JLabel;
import javax.swing.WindowConstants;
import java.awt.Dimension;
import java.awt.Container;
import java.awt.Graphics;
import java.awt.Color;
import moteur.MoteurJeuTennis;
/**
* Cette classe dessine la table de ping-pong, la balle et
* les raquettes et affiche le score
*/
public class TableVerteTennis extends JPanel
implements ConstantesDuJeu {
private JLabel label;
private int raquetteOrdinateur_Y =
RAQUETTE_ORDINATEUR_Y_DEPART;
private int raquetteEnfant_Y = RAQUETTE_ENFANT_Y_DEPART;
private int balle_X = BALLE_X_DEPART;
private int balle_Y = BALLE_Y_DEPART;
Dimension taillePréférée = new
Dimension(LARGEUR_TABLE, HAUTEUR_TABLE);
// Cette méthode affecte sa taille au cadre.
// Elle est appelée par Java.
public Dimension getPreferredSize() {
return taillePréférée;
}
// Constructeur. Crée un récepteur d'événements souris.
TableVerteTennis() {
MoteurJeuTennis moteurJeu =
new MoteurJeuTennis(this);
// Reçoit les mouvements de la souris pour déplacer la
// raquette.
addMouseMotionListener(moteurJeu);
// Reçoit les événements clavier.
addKeyListener(moteurJeu);
}
void ajouteAuCadre(Container conteneur) {
conteneur.setLayout(new BoxLayout(conteneur,
BoxLayout.Y_AXIS));
conteneur.add(this);
label = new JLabel(
"Taper N pour une nouvelle partie, S pour servir" +
" ou Q pour quitter");
conteneur.add(label);
}
// Repeint la fenêtre. Cette méthode est appelée par Java
// quand il est nécessaire de rafraîchir l'écran ou quand
// la méthode repaint() est appelée.
public void paintComponent(Graphics contexteGraphique) {
super.paintComponent(contexteGraphique);
// Dessine la table verte
contexteGraphique.setColor(Color.GREEN);
contexteGraphique.fillRect(
0, 0, LARGEUR_TABLE, HAUTEUR_TABLE);
// Dessine la raquette droite
contexteGraphique.setColor(Color.yellow)contexteGraphique.fillRect(
RAQUETTE_ENFANT_XraquetteEnfant_Y,
LARGEUR_RAQUETTE, LONGUEUR_RAQUETTE);
// Dessine la raquette gauche
contexteGraphique.setColor(Color.blue);
contexteGraphique.fillRect(RAQUETTE_ORDINATEUR_X,
raquetteOrdinateur_Y,
LARGEUR_RAQUETTE, LONGUEUR_RAQUETTE);
// Dessine la balle
contexteGraphique.setColor(Color.red);
contexteGraphique.fillOval(balle_X, balle_Y, 10, 10);
// Dessine les lignes blanches
contexteGraphique.setColor(Color.white);
contexteGraphique.drawRect(10, 10, 300, 200);
contexteGraphique.drawLine(160, 10, 160, 210);
// Donne le focus à la table, afin que le récepteur de
// touches envoie les commandes à la table
requestFocus();
}
// Affecte sa position courante à la raquette de l'enfant
public void positionnerRaquetteEnfant_Y(int y) {
this.raquetteEnfant_Y = y;
repaint();
}
public int coordonnéeRaquetteEnfant_Y() {
return raquetteEnfant_Y;
}
// Affecte sa position courante à la raquette de
// l'ordinateur
public void positionnerRaquetteOrdinateur_Y(int y) {
this.raquetteOrdinateur_Y = y;
repaint();
}
// Affecte le texte du message du jeu
public void affecterTexteMessage(String texte) {
label.setText(texte);
repaint();
}
// Positionne la balle
public void positionnerBalle(int x, int y) {
balle_X = x;
balle_Y = y;
repaint();
}
public static void main(String[] args) {
// Crée une instance du cadre
JFrame monCadre = new JFrame("Table verte de ping-pong");
// Permet la fermeture de la fenêtre par clic sur la
// petite croix dans le coin.
monCadre.setDefaultCloseOperation(
WindowConstants.EXIT_ON_CLOSE);
TableVerteTennis table = new TableVerteTennis();
table.ajouteAuCadre(monCadre.getContentPane());
// Affecte sa taille au cadre et le rend visible.
monCadre.setBounds(0, 0, LARGEUR_TABLE + 5,
HAUTEUR_TABLE + 40);
monCadre.setVisible(true);
}
}
public interface ConstantesDuJeu {
// Taille de la table de ping-pong
public final int LARGEUR_TABLE = 320;
public final int HAUTEUR_TABLE = 220;
public final int HAUT_TABLE = 12;
public final int BAS_TABLE = 180;
// Incrément du mouvement de la balle en pixels
public final int INCREMENT_BALLE = 4;
// Coordonnées maximum et minimum permises pour la balle
public final int BALLE_X_MIN = 1 + INCREMENT_BALLE;
public final int BALLE_Y_MIN = 1 + INCREMENT_BALLE;
public final int BALLE_X_MAX =
LARGEUR_TABLE - INCREMENT_BALLE;
public final int BALLE_Y_MAX =
HAUTEUR_TABLE - INCREMENT_BALLE;
// Position de départ de la balle
public final int BALLE_X_DEPART = LARGEUR_TABLE / 2;
public final int BALLE_Y_DEPART = HAUTEUR_TABLE / 2;
// Taille, positions et incrément des raquettes
public final int RAQUETTE_ENFANT_X = 300;
public final int RAQUETTE_ENFANT_Y_DEPART = 100;
public final int RAQUETTE_ORDINATEUR_X = 15;
public final int RAQUETTE_ORDINATEUR_Y_DEPART = 100;
public final int INCREMENT_RAQUETTE = 2;
public final int LONGUEUR_RAQUETTE = 30;
public final int LARGEUR_RAQUETTE = 5;
public final int SCORE_GAGNANT = 21;
// Ralentit mes ordinateurs rapides ;
// modifier la valeur si nécessaire.
public final int DUREE_SOMMEIL = 10; // En millisecondes.
}

import java.awt.event.MouseMotionListener;
import java.awt.event.MouseEvent;
import java.awt.event.KeyListener;
import java.awt.event.KeyEvent;
import écrans.*;
/**
* Cette classe est un récepteur de souris et de clavier.
* Elle calcule les déplacements de la balle et des raquettes
* et change leurs coordonnées.
*/
public class MoteurJeuTennis implements Runnable,
MouseMotionListener, KeyListener, ConstantesDuJeu {
private TableVerteTennis table; // Référence à la table.
private int raquetteEnfant_Y = RAQUETTE_ENFANT_Y_DEPART;
private int raquetteOrdinateur_Y =
RAQUETTE_ORDINATEUR_Y_DEPART;
private int scoreEnfant;
private int scoreOrdinateur;
private int balle_X; // position X de la balle
private int balle_Y; // position Y de la balle
private boolean déplacementGauche = true;
private boolean balleServie = false;
//Valeur en pixels du déplacement vertical de la balle.
private int déplacementVertical;
// Constructeur. Stocke une référence à la table.
public MoteurJeuTennis(TableVerteTennis tableVerte) {
table = tableVerte;
Thread travailleur = new Thread(this);
travailleur.start();
}
// Méthodes requises par l'interface MouseMotionListener
// (certaines sont vides, mais doivent être incluses dans
// la classe de toute façon).
public void mouseDragged(MouseEvent événement) {
}
public void mouseMoved(MouseEvent événement) {
int souris_Y = événement.getY();
// Si la souris est au-dessus de la raquette de l'enfant
// et que la raquette n'a pas dépassé le haut de la
// table, la déplace vers le haut ;
// sinon, la déplace vers le bas.
if (souris_Y < raquetteEnfant_Y &&
raquetteEnfant_Y > HAUT_TABLE) {
raquetteEnfant_Y -= INCREMENT_RAQUETTE;
} else if (raquetteEnfant_Y < BAS_TABLE) {
raquetteEnfant_Y += INCREMENT_RAQUETTE;
}
// Affecte la nouvelle position de la raquette
table.positionnerRaquetteEnfant_Y(raquetteEnfant_Y);
}
// Méthodes requises par l'interface KeyListener.
public void keyPressed(KeyEvent événement) {
char touche = événement.getKeyChar();
if ('n' == touche || 'N' == touche) {
démarrerNouvellePartie();
} else if ('q' == touche || 'Q' == touche) {
terminerJeu();
} else if ('s' == touche || 'S' == touche) {
serviceEnfant();
}
}
public void keyReleased(KeyEvent événement) {}
public void keyTyped(KeyEvent événement) {}
// Démarre une nouvelle partie.
public void démarrerNouvellePartie() {
scoreOrdinateur = 0;
scoreEnfant = 0;
table.affecterTexteMessage("Scores - Ordinateur : 0"
+ "Enfant : 0");
serviceEnfant();
}
// Termine le jeu.
public void terminerJeu(){
System.exit(0);
}
public void run() {
boolean rebondPossible = false;
while (true) {
if (balleServie) { // Si la balle est en mouvement
// Etape 1. La balle se déplace-t-elle vers la
// gauche ?
if (déplacementGauche && balle_X > BALLE_X_MIN) {
rebondPossible = (balle_Y >= raquetteOrdinateur_Y
&& balle_Y < (raquetteOrdinateur_Y +
LONGUEUR_RAQUETTE) ? true : false);
balle_X -= INCREMENT_BALLE;
// Ajoute un déplacement vertical à chaque
// mouvement horizontal de la balle.
balle_Y -= déplacementVertical;
table.positionnerBalle(balle_X, balle_Y);
// La balle peut-elle rebondir ?
if (balle_X <= RAQUETTE_ORDINATEUR_X
&& rebondPossible) {
déplacementGauche = false;
}
}
// Etape 2. La balle se déplace-t-elle vers la
// droite ?
if (!déplacementGauche && balle_X <= BALLE_X_MAX) {
rebondPossible = (balle_Y >= raquetteEnfant_Y &&
balle_Y < (raquetteEnfant_Y +
LONGUEUR_RAQUETTE) ? true : false);
balle_X += INCREMENT_BALLE;
table.positionnerBalle(balle_X, balle_Y);
// La balle peut-elle rebondir ?
if (balle_X >= RAQUETTE_ENFANT_X &&
rebondPossible) {
déplacementGauche = true;
}
}
if (raquetteOrdinateur_Y < balle_Y
&& raquetteOrdinateur_Y < BAS_TABLE) {
raquetteOrdinateur_Y += INCREMENT_RAQUETTE;
} else if (raquetteOrdinateur_Y > HAUT_TABLE) {
raquetteOrdinateur_Y -= INCREMENT_RAQUETTE;
}
table.positionnerRaquetteOrdinateur_Y(
raquetteOrdinateur_Y);
// Etape 4. Sommeiller un peu
try {
Thread.sleep(DUREE_SOMMEIL);
} catch (InterruptedException exception) {
exception.printStackTrace();
}
// Etape 5. Mettre le score à jour si la balle est
// dans la surface verte mais ne bouge plus.
if (balleSurLaTable()) {
if (balle_X > BALLE_X_MAX ) {
scoreOrdinateur++;
afficherScore();
} else if (balle_X < BALLE_X_MIN) {
scoreEnfant++;
afficherScore();
}
}
} // Fin du if balleServie
} // Fin du while
}// Fin de run()
// Sert depuis la position courante de la raquette
// de l'enfant.
private void serviceEnfant() {
balleServie = true;
balle_X = RAQUETTE_ENFANT_X - 1;
balle_Y = raquetteEnfant_Y;
if (balle_Y > HAUTEUR_TABLE / 2) {
déplacementVertical = -1;
} else {
déplacementVertical = 1;
}
table.positionnerBalle(balle_X, balle_Y);
table.positionnerRaquetteEnfant_Y(raquetteEnfant_Y);
}
private void afficherScore() {
balleServie = false;
if (scoreOrdinateur == SCORE_GAGNANT) {
table.affecterTexteMessage("L'ordinateur a gagné ! " +
scoreOrdinateur +
" : " + scoreEnfant);
} else if (scoreEnfant == SCORE_GAGNANT) {
table.affecterTexteMessage ("Tu as gagné ! "+
scoreEnfant +
" : " + scoreOrdinateur);
} else {
table.affecterTexteMessage ("Ordinateur : "+
scoreOrdinateur +
" Enfant: " + scoreEnfant);
}
}
// Vérifie que la balle n'a pas dépassé la limite
// inférieure ou supérieure de la table.
private boolean balleSurLaTable() {
if (balle_Y >= BALLE_Y_MIN && balle_Y <= BALLE_Y_MAX) {
return true;
} else {
return false;
}
}
}

[recherche source en java du jeux tennis]

1 réponse

Discussions similaires