Projet d'application Java - Casse-Bateaux

Version imprimable

17/11/2011, 16h50
Baboulinet_

Projet d'application Java - Casse-Bateaux

Bonjour,

J'aurai voulu savoir plusieurs choses.

En effet, actuellement je suis sur un projet qui s'intitule "Casse-Bateaux" !
C'est en fait une bataille navale classique mais lorsque l'on touche un bateau,
une nouvelle fenêtre s'ouvre (symbolisant le casse-briques) et le joueur qui attaque dirige dès lors la barre horizontale sur le bas de l'écran et la boule doit toucher le bateau pour valider le coup "touché" en un temps donné.

Le bateau est contrôlé par une IA ou par un autre joueur et le bateau ne peut aller que de gauche à droite.

Pour le moment je vais me concentrer sur une IA basique avec des coups aléatoires pour la bataille-navale et des directions aléatoires pour le mode casse-bateau.

Lorsque l'application s'ouvre, 2 grilles apparaissent sur l'écran (celle de gauche est la grille d'attaque et celle de droite la grille où se trouve nos bateaux). A ce moment-là, est-il possible de sélectionner des cases pour attaquer ou pour indiquer l'emplacement de nos bateaux et ce, avec la souris, en utilisant uniquement les moyens que me propose l'environnement java ?

En ce qui concerne le mode 2 joueurs (2 pc en réseau local évidemment), quel outil pouvez-vous me proposer pour effectuer le lien réseau entre les 2 joueurs ?

Est-ce que ce projet est réalisable avec un simple soft comme Eclipse ?

Si vous avez d'autres questions ou suggestions que je n'ai pas évoqué, n'hésitez pas à m'en faire part. Toute aide sera la bienvenue, et je vous remettrai mon code à la fin si vous êtes intéressés :ccool:

Edit : il me semble que je ne suis pas au bon endroit avec mon post (si un admin ou un modo pouvait régler ce léger souci, il aura le droit à une dédicace sur mon appli :mouarf:)
17/11/2011, 17h04
Mako 5013

Citation:

A ce moment-là, est-il possible de sélectionner des cases pour attaquer ou pour indiquer l'emplacement de nos bateaux et ce, avec la souris, en utilisant uniquement les moyens que me propose l'environnement java ?

Oui. Pour ce faire, je te conseille de jeter un oeil du côté de l'interface MouseListener (que ta grille devrait étendre donc). Je pars ici du principe que ton interface graphique serait en Swing, ce qui me semblerait adapté à ton projet.

Citation:

Est-ce que ce projet est réalisable avec un simple soft comme Eclipse ?

Simple soft ?!? Enfin, la réponse est oui. Eclipse n'est qu'un (très) gros éditeur de texte, parfaitement adapté à de la programmation en JAVA (pour faire court).

Par contre, pour la communication entre les joueurs, c'est un domaine que je ne maîtrise pas du tout, et je préfère laisser les plus pointus que moi te répondre plutôt que de raconter des ânneries.

Mako.
17/11/2011, 17h09
Baboulinet_

Oui je compte bien sûr utiliser une interface swing, ça va m'éviter de travailler avec la console ;).

Sinon l'emploi du "simple soft" est parce que je suppose qu'il y a surement des soft plus gros ou plus fournis ou encore plus performants (en ce moment j'utilise IntelliJ Idea et je m'y suis un peu habitué même si je préfère encore coder avec Eclipse). Après, je ne sais pas si il y en a, je n'ai pas encore pris le temps d'aller chercher :D
18/11/2011, 13h50
benratti
Pour la partie réseau, il y a plusieurs possibilités :
- Utiliser les classes Socket et ServerSocket pour gérer la connexion. Tu aruas ensuite des InputStream et OutputStream à utiliser... un peut lourd, tu peux également utiliser la serialisation d'objet... bref, pas forcement le plus simple
- Utiliser RMI, qui permet d'échanger entre ton client et ton serveur. Une fois la connexion RMI entre ton serveur et ton client, les appelles de l'un à l'autre sont plutôt simple (appelle de méthode avec la gestion des exceptions lié à RMI). Par contre, tu vas avoir une dépendance assez forte entre ton client et ton serveur (en cas d'évolution)
- Utiliser des web services telle que SOAP / REST... mais ca demande une infrastruvture un peut plus lourde (serveur d'application pour ton serveur)
- Surement d'autres méthodes...
Dans ton cas, je m'orienterais plutot vers le RMI
21/11/2011, 11h50
Baboulinet_

Citation:

Dans ton cas, je m'orienterais plutot vers le RMI

Je ne connais pas du tout RMI.
C'est une application ? Je vais coder dessus ?
Ca remplace Eclipse ?

Et tu parles de serveur, du coup le pc (celui qui lance en premier le jeu) fait office de serveur et celui qui s'y connecte de client. Ca on est d'accord, mais qu'en est-il des "dépendances assez fortes" ?

Merci en tout cas des réponses apportées :)
21/11/2011, 13h50
benratti

Citation:

Envoyé par Baboulinet_

Je ne connais pas du tout RMI.
C'est une application ? Je vais coder dessus ?

RMI (Remote Method Invocation) va te permettre t'appeler des methodes qui se trouvent une une jvm, voir un machine différente. Il s'agit d'une api supplémentaire à appeler.

tu trouveras pas mal de tuto t'expliquant comment mettre cela en place.

Citation:

Ca remplace Eclipse ?

Non, eclipse reste ton studio de developpement. De manière générale en java, tu n'as pas besoin d'en changer pour utiliser des API supplémentaires.

Citation:

Et tu parles de serveur, du coup le pc (celui qui lance en premier le jeu) fait office de serveur et celui qui s'y connecte de client.

Ca peut... sinon, tu peux mettre en place un serveur centralisé qui fait le lien entre tous les clients.

Citation:

Ca on est d'accord, mais qu'en est-il des "dépendances assez fortes" ?

C'est dans le cas où tu fais des changements sur la partie serveur, il faudra les impacters sur les clients.

Bonjour,

quelques petites nouvelles de mon projet.
Pour le moment tout se passe bien (j'ai pas toujours du temps dispo pour m'affairer à ce projet, mais je suis assez satisfait de mon rythme pour le moment).

Je viens de terminer les 2 premières étapes de mon projet :
=> la création des grilles
=> le positionnement des bateaux aléatoirement sur la grille

Voici mon premier souci :

En affichage, il y a 2 grilles (GridLayout[11][11] qui contient un tableau[10][10] de JButton), celle de gauche étant cliquable (pour attaquer), celle de droite n'étant pas cliquable et représente la grille de nos bateaux.

Lorsque je clique sur un bouton de la grille de gauche, j'aimerai pouvoir d'une part récupérer sa position sur la grille, et d'autre part, pouvoir la comparer à une position de la grille de l'IA.

Je suppose qu'il faut utiliser un ActionListener ou un MouseListener comme cité plus haut. Mais Si je le fait sur ma classe Tableau (je vous joins les classe juste après), je ne pourrai pas comparer le bouton d'attaque cliqué avec un bouton de la grille des bateaux de l'ordi.

Je ne sais pas si j'ai été clair, mais voici les classes dont vous avez besoin pour comprendre mon problème. Si vous pensez à d'autres solutions, ou même des choses pouvant améliorer mon code, n'hésitez pas :D

Classe FvsOrdi

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
package cassBatal;
 
import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Container;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
 
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
 
@SuppressWarnings("serial")
public class FvsOrdi extends JFrame {
 
	private FStart fStart;
 
	public FvsOrdi(FStart fStart){
		super();
		this.fStart = fStart;
		build();
	}
 
	private void build() {
 
		setTitle("Le Casse-Batal");
		setSize(835,500);
		setLocationRelativeTo(null);
		//setResizable(false);
		setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		setContentPane(buildContentPane());
		start();
 
	}
 
	private Container buildContentPane() {
 
		//Caractéristiques du Panel Principal
		JPanel p = new JPanel();
		p.setBackground(Color.white);
		p.setLayout(new BorderLayout(10,10));
 
		String joueur = fStart.getTPseudo();
		JPanel pJoueur = new JPanel();
		JLabel lJoueur = new JLabel(joueur + "  VS  " + "Ordinateur");
		pJoueur.add(lJoueur);
 
		//Tableau caché pour l'ordinateur
		JPanel pBatOrdi = new JPanel();
		Tableau tabBatOrdi = new Tableau("Bateau");
		tabBatOrdi.positionBatalAleat();
		System.out.println("Placement des bateaux de l'ordi effectué !");
		pBatOrdi.add(tabBatOrdi.getPanAtt());
 
		//Panel des Tableaux du Joueur
		JPanel pAtq = new JPanel();
		Tableau tabAtq = new Tableau("Attaque");
		pAtq.add(tabAtq.getPanAtt());
 
		JPanel pBat = new JPanel();
		//pBat.setLayout(new BorderLayout());
		Tableau tabBat = new Tableau("Bateau");
		tabBat.positionBatalAleat(); //Placement aléatoire des bateaux pour le moment
		System.out.println("Placement de mes bateaux effectué !");
		pBat.add(tabBat.getPanAtt());
 
		JPanel pMilieu = new JPanel();
		JLabel lMilieu = new JLabel("Mode Chat désactivé - L'ordinateur ne sait pas parler, désolé :/");
		//lMilieu.setSize(pAtt.getSize());
		pMilieu.setBackground(Color.LIGHT_GRAY);
		pMilieu.add(lMilieu);
 
		JPanel pPosition = new JPanel();
		JLabel lPosition = new JLabel("Veuillez indiquer la position de vos bateaux !");
		TableauChoix tabChoixBatal = new TableauChoix(); //Pop up demandant le type de placement des bateaux (aléatoire ou manuel)
		pPosition.add(lPosition);
 
		p.add(pJoueur, BorderLayout.NORTH);
		p.add(pAtq, BorderLayout.WEST);
		p.add(pMilieu, BorderLayout.CENTER);
		p.add(pBat, BorderLayout.EAST);
		p.add(pPosition, BorderLayout.SOUTH);
 
 
		return p;
	}
 
 
	private void start() {
 
		System.out.println("Partie lancée !");
 
	}
 
 
}

Et voici la fameuse classe Tableau

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
package cassBatal;
 
import java.awt.Color;
import java.awt.GridLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.text.DecimalFormat;
import java.util.ArrayList;
import java.util.List;
 
import javax.swing.JButton;
import javax.swing.JLabel;
import javax.swing.JPanel;
 
public class Tableau implements ActionListener{
 
	private JPanel p = new JPanel();
	private JButton[][] tabAtt;
	DecimalFormat nbf = new DecimalFormat("00");
 
	public Tableau(String Mode){
 
		JLabel ltemp;
		tabAtt =  new JButton[10][10];
		p.setLayout(new GridLayout(11,11));
		int posx = 0;
		int posy = 0;
		Boolean jpeuxClic = false;
 
		if(Mode.equals("Attaque")){
			jpeuxClic = true;
		}
 
		for(int i = 0; i < 11; i++){
 
			for(int j = 0; j < 11; j++){
 
				posx = i - 1;
				posy = j - 1;
 
				if(i == 0){					
					if(j == 0){
						ltemp = new JLabel(getLettre(i));
						ltemp.setHorizontalAlignment(JLabel.CENTER);						
						p.add(ltemp);
					}
					else{
						ltemp = new JLabel((j-1) + "");
						ltemp.setHorizontalAlignment(JLabel.CENTER);
						p.add(ltemp);
					}					
				}
				else if(j == 0){
					ltemp = new JLabel(getLettre(i));
					ltemp.setHorizontalAlignment(JLabel.CENTER);						
					p.add(ltemp);
				}
				else{
					tabAtt[posx][posy] = new JButton(" ");
					tabAtt[posx][posy].setBackground(Color.WHITE);
					tabAtt[posx][posy].setEnabled(jpeuxClic);
					tabAtt[posx][posy].addActionListener(this);
					p.add(tabAtt[posx][posy]);
				}
 
 
			}
 
		}
 
	}
 
	public void positionBatalAleat(){
 
		//Explication du choix des positions par coup aléatoire :
		//on éclate la tableau en une seule ligne (10 lignes de 10 cases = 100 cases en tout)
		//un random (1,100) va donc être exécuté
		//si le nombre 56 par exemple est tiré, ceci équivaut à la ligne E et à la colonne 6
		//ensuite on tire un chiffre en random (1,4) où 1 = vers le haut, 2 vers la droite, 3 vers le bas, 4 vers la gauche
		//ceci a pour effet de placer le batal dans la direction choisie alatoirement par l'ordi
		//faire attention si il y a assez de place dans la direction choisie
 
 
 
		//////////////////////////////////////////////PORTE-AVIONS//////////////////////////////////////////
		Batal porteAvions = new PorteAvion();
		positionner(porteAvions);
 
		//////////////////////////////////////////////SOUS-MARIN////////////////////////////////////////////
		Batal sousMarin = new SousMarin();
		positionner(sousMarin);
		//////////////////////////////////////////////CROISEUR//////////////////////////////////////////////
		Batal croiseur = new Croiseur();
		positionner(croiseur);
 
		//////////////////////////////////////////////INTERCEPTEUR//////////////////////////////////////////
		Batal intercepteur = new Intercepteur();
		positionner(intercepteur);
 
		//////////////////////////////////////////////ECLAIREUR/////////////////////////////////////////////
		Batal eclaireur = new Eclaireur();
		positionner(eclaireur);
 
 
	}
 
 
	private void positionner(Batal batal) {
 
		System.out.print("Placement du " + batal.toString());
		System.out.println(" de longueur " + batal.getLongueur());
 
		int posAvt = -1;
		int posArr = -1;
		int direction = -1;
		List<String> listeCases = new ArrayList<String>();
 
		while(posArr == -1){
			while(posAvt == -1){
				posAvt = getPlace((int) (Math.random() * 100));
			}
			direction = (int) (Math.random() * 4 + 1);
			/*//Tests
			if(batal.toString().equals("Porte-Avions")){
				posAvt = 76;
				direction = 4;
			}
			if(batal.toString().equals("Sous-Marin")){
				posAvt = 78;
				direction = 4;
			}
			//Fin Tests*/
			posArr = getPosQueue(posAvt, direction, batal.getLongueur() - 1); //Le devant du Batal est déjà placé, il faut une case de moins pour le gabarit
		}
 
		switch(direction){
			case 1 : 	for(int i = posAvt; i>= posArr; i=i-10){
							tabAtt[i/10][i%10].setBackground(Color.CYAN);
							listeCases.add(getLettre((i/10)+1).toString() + i%10);
 
						}
						break;
			case 2 : 	for(int i = posAvt; i<= posArr; i=i+1){
							tabAtt[i/10][i%10].setBackground(Color.CYAN);
							listeCases.add(getLettre((i/10)+1).toString() + i%10);
						}
						break;
			case 3 : 	for(int i = posAvt; i<= posArr; i=i+10){
							tabAtt[i/10][i%10].setBackground(Color.CYAN);
							listeCases.add(getLettre((i/10)+1).toString() + i%10);
						}
						break;
			case 4 : 	for(int i = posAvt; i>= posArr; i=i-1){
							tabAtt[i/10][i%10].setBackground(Color.CYAN);
							listeCases.add(getLettre((i/10)+1).toString() + i%10);
						}
						break;
		}
 
		batal.setCasesOccupees(listeCases);
		batal.getCasesOccupees();
 
	}
 
	private int getPlace(int pos) {
		//renvoie si oui ou non la place est occupée par un autre batal
 
		if(tabAtt[pos/10][pos%10].getBackground().equals(Color.CYAN)){
			return -1;
		}
 
		return pos;
	}
 
	private int getPosQueue(int posPa, int dirPa, int nbCases) {
		//retourne la position de la queue du batal s'il y a de la place pour le positionner
 
		int posQueue = -1;
 
		switch(dirPa){
 
			//Cas 1 : Le batal se dirige vers le haut
			case 1 : 	if((posPa / 10 - nbCases) >= 0){
							posQueue = ((posPa/10)-nbCases)*10 + posPa%10;
							//Il n'y a pas de soucis quant au placement du bateau dans la grille (du moins l'arrière du bateau)
							//On vérifie maintenant s'il n'y a pas de bateau placé entre le devant et le derrière du bateau
							//Sinon, ça serait cheaté :D
							for(int i = posPa; i>= posQueue; i=i-10){
								if(tabAtt[i/10][i%10].getBackground().equals(Color.CYAN)){
									posQueue = -1;
									break;
								}
							}
						}
 
						break;
 
			//Cas 2 : Le batal se dirige vers la droite
			case 2 : 	if((10 - posPa % 10 - nbCases) > 0){ 
							posQueue = posPa + nbCases;
							for(int i = posPa; i<= posQueue; i=i+1){
								if(tabAtt[i/10][i%10].getBackground().equals(Color.CYAN)){
									posQueue = -1;
									break;
								}
							}
						}
 
						break;
 
			//Cas 3 : Le batal se dirige vers le bas
			case 3 : 	if((10 - posPa / 10 - nbCases) > 0){ 
							posQueue = ((posPa/10)+nbCases)*10 + posPa%10;
							for(int i = posPa; i<= posQueue; i=i+10){
								if(tabAtt[i/10][i%10].getBackground().equals(Color.CYAN)){
									posQueue = -1;
									break;
								}
							}
						}
 
						break;
 
			//Cas 4 : Le batal se dirige vers la gauche
			case 4 : 	if((posPa % 10 - nbCases) >= 0){ 
							posQueue = posPa - nbCases; 
							for(int i = posPa; i>= posQueue; i=i-1){
								if(tabAtt[i/10][i%10].getBackground().equals(Color.CYAN)){
									posQueue = -1;
									break;
								}
							}
						}
 
						break;
		}
 
 
 
		return posQueue;
 
	}
 
	private String getLettre(int i) { 
		//Placement des lettres sur la GridLayout (différent de la grille contenue par ce Layout)
 
		String lettre = "";
		switch(i){
			case 0 : lettre = " "; break;
			case 1: lettre = "A"; break;
			case 2: lettre = "B"; break;
			case 3: lettre = "C"; break;
			case 4: lettre = "D"; break;
			case 5: lettre = "E"; break;
			case 6: lettre = "F"; break;
			case 7: lettre = "G"; break;
			case 8: lettre = "H"; break;
			case 9: lettre = "I"; break;
			case 10: lettre = "J"; break; 
		}
		return lettre;
	}
 
	public JPanel getPanAtt(){
 
		return p;
 
	}
 
 
	@Override
	public void actionPerformed(ActionEvent e) {
 
		System.out.println(e.getSource());
 
	}
 
 
}

Voilà, si vous désirez mes autres classes pour les compiler dans un projet, je peux vous les mettre à disposition sans soucis.

Merci,

Baboulinet.

PS : Un Batal, des Bateaux. C'est bien connu ;)
PS : Si vous désirez mes autres classes pour compiler le projet, elles sont disponibles à http://www.fufox.net/?d=6481BEAA8F40

Je te dé-conseil l'utilisation de bouton ce que tu veux faire. (A savoir une grille de jeu)
J'ai déjà réalisé plusieurs mini-jeu en utilisant java. Et les boutons ne sont pas fait pour ce genre de chose...
Personnellement, je prend un JPanel où j'ajoute un mouseListener. En considère sa longueur et sa largeur. Il est possible de retrouver les coordonnées cliqué assez simplement :
Code:

1 2 3 4 5 6 7 8 //e => Notre mouseEvent; int x;// ligne X int y;// Colonne Y int widthButton =MyPanelGame.this.getwith()/MyPanelGame.getNumberLine(); //pas de valeur en dur au milieu des calculs. On définit une constante ou une fonction. //Bien plus simple quand on revient sur le code pour faire un tableau 15*20 et qu'on par d'un tableau 10*10... x = e.getX()/widthButton ; // de même pour y
Pour l'affichage, il faut faire un @overwrite de la méthode paint. Mais cela te laisse plus de choix sur l'affichage. (Bordure / Image représentant plusieurs "bouton")

Je te conseil de faire une IA qui ne gère que son domaine, son modèle métier associé. Ainsi, tu va avoir une partie affichage Panel ou Boutons, une partie contrôle (mouseEvent/actionPerformed) et ton modèle métier.
Pour ton modèle métier :
Les "Iterator" sur les string, c'est bien. Mais on est en java 1.6 et java 1.7 pointe son nez :
Code:

1 2 3 4 5 6 7 8 9 10 Iterator<String> it = listeCasesOccupees.iterator(); while(it.hasNext()){ System.out.println(it.next()); } //Plus beau de cette manière : for(String maCase :listeCasesOccupees){ System.out.println(maCase); }
Si c'est une Case, pourquoi c'est un objet String ?
Code:

1 2 3 4 5 class Case{ private int x; private int y; //TODO getter et setter + constructeur valué }
J'aime bien :
Code:

1 2 3 4 5 6 public class Croiseur extends Batal{ public Croiseur(){ super.nom = "Croiseur"; super.longueur = 3; } }
Mais, je préfère :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 public class Croiseur extends Batal{ public Croiseur(){ super("Croiseur",3) } } public class Batel{ private String nom; private int longueur; protected Batel(String nom,int longueur){ this.nom=nom; this.longueur=longueur; }
Ainsi tu sais toujours où et qui modifie le nom et la longueur.

30/11/2011, 09h51
Baboulinet_

Merci pour toutes tes réponses.

En effet, la petite modification sur les héritages est pas mal.
C'est même plus logique et plus perfectionniste.

Pour la méthode supplantant celle de ma boucle while avec l'iterator, j'en suis conscient, mais je ne suis pas encore trop à l'aise avec cette méthode.
D'ailleurs, le for each je n'utilise toujours pas mais va falloir que je commence à le tater (mais bon, comme on dit c'est dans les vieilles marmites qu'on fait les meilleures soupes :D)

Pour le gros du souci que je viens de relever, il va donc falloir par rapport à ce que tu as proposé que je change complètement ma façon de faire pour la grille ?
Tu me déconseilles d'utiliser ma façon (avec les boutons), mais c'est néanmoins possible ?
Sinon, j'utiliserai donc un mouseListener, mais je ne l'ai pas souvent utilisé (et jamais utilisé la méthode paint) du coup je ne vois pas trop par où commencer avec ta méthode. Dis m'en plus stp :mrgreen: