interagir avec la console par des interfaces graphiques

**JeanArchibalde** · 29/12/2016, 13h51

Bonjour,

j'aimerai interagir avec la console par le biais de boutons sur une interface graphique, mais je ne sais pas trop si c'est possible :

j'ai un jeu, avec des joueurs qui jouent tour a tour en lignes de commandes dans mon main, et je veux leur créer une interface graphique, mais que cette interface graphique continue a utiliser la boucle de tour de jeu du main.

je sais pas trop si j'ai été clair ou pas :o : c'est un jeu de cartes, en ligne de commande c'est a dire que pour poser une carte je tape son nom lors de mon tour, mais j'aimerai également pourvoir poser cette carte avec l'interface graphique sans ré-appeller la méthode poser() (dans le bouton), mais que ce bouton pose ma carte dans la continuité du main (comme ca, le tour de jeu continue normalement dans le main)

Merci d'avance

**joel.drigo** · 29/12/2016, 15h47

Salut,

Déjà, la notion de console est abstraite. En Java, on intéragit avec soit un flux de caractères (de sortie, pour afficher, d'entrée pour saisir), ou éventuellement avec une encapsulation sous la forme de la classe Console, qui permet juste de simplifier l'accès à ces flux et qui ajoute quelques services (comme par exemple, saisir un mot de passe sans echo ou avec des * pour masquer). Le but est de ne pas être lié aux spécificités d'un shell en particulier (qui n'est en fin de compte qu'une application comme n'importe quelle autre). Et je ne parle même pas des spécificités du matériel (imagine que l'affichage se fasse sur un VT-52 (voire sur une plage braille) : tu peux oublier les notions de boutons, souris, etc.)
Il y aurait bien la soluton de gérer nativement le shell (s'il existe une API le permettant), mais ça contraint l'application à fonctionner soit obligatoirement avec ce shell (si c'est une application qui n'existe que pour un seul OS, donc uniquement sur cet OS), soit de gérer un mode hybride qui sera capable de s'adapter à la présence ou non de telle "console".

Par ailleurs, pourquoi vouloir faire une application qui tourne en console, mais avec une interface graphique ? Fais simplement une application avec une interface graphique ! A la limite, tu peux simuler une console avec une interface graphique si tu veux.

En revanche, le dernier paragraphe m'est assez sibyllin : je ne comprends pas trop cette histoire d'appeler une méthode poser() sans l'appeller et encore moins le rapport que cela peut avoir avec une notion d'interface graphique, bouton ou pas bouton. Si tu parles de simuler la saisie au clavier, alors la classe Robot pourrait être la solution (ou piper l'entrée standard, avec une belle usine à gaz pour gérer les conflits entre les deux sources). Mais ça ne t'aidera pas à mettre des composants interactifs contrôlables à la souris dans la console, et les afficher à part dans une fenêtre graphique va introduire un sérieux problème de gestion du focus.

**JeanArchibalde** · 29/12/2016, 19h33

En fait c'est pour un projet a l'ecole : j'ai déja du rendre l'application utilisable en ligne de commande, donc elle fonctionne sur la console. Du coup je me demandait si pour faire l'interface j'avais moyen de juste me coller aux instruction du main déja existant par l'interface.
C'est pour ca que je disait appeller la methode poser sans vraiment l'appeler vu qu'elle existe deja dans le main, et que je n'ai pas envie que la remetre sur le bouton de l'interface. Je cherchais a passer par l'interface pour recoller sur les appels des methodes deja existantes du main.
Apparement c'est pas possible 😢😢

Du coup, le déroulement du tour de jeu ne sera plus dans le main, mais la se pose le probleme : lorsque je joue, je crée un nouvel objet 'PartieDeJeu', et chaque Joueur passe dans la méthode jouer(Joueur ), dans PartieDeJeu.
Donc dans le main j'ai une boucle qui faire jouer les joueurs chacun leur tour.

Lorsque j'ajoute l'interface, les joueurs peuvent encore jouer dans la console (par le main) mais avec les interface je fais du multi thread (arretez moi si je dis n'importe quoi &#128514

et donc ils peuvent jouer sur leur fenêtre, mais je n'ai plus vraiment de fil conducteur comme lorsque j'avais le main, en ligne de commande (a cause du multi thread, chacun peut faire ce qu'il veut dans son coin &#128544

**joel.drigo** · 30/12/2016, 10h24

J'imagine que ton main est une boucle du genre :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
tant que pas fin de partie
     joueur courant joue
     joueur = joueur suivant

Tu ne peux pas intervenir sur cette boucle de manière externe. On pourrait adapter le code mais ça va être inutilement compliqué, surtout qu'une interface graphique est évenementielle (il y a bien une boucle quelque part mais c'est de la cuisine interne). Il te faut simplement faire une alternative à cette boucle pour la gérer de manière évenementielle et dans les évenements appeler les méthodes qui sont appelées dans la boucle : si elles sont bien faites, suffisamment indépendantes, ça devrait être très simple. Eventuellement, pour pouvoir gérer les 2 aspects (console/graphique), on peut introduire une notion de contexte (avec un interface/classe abstraite) et 2 implémentations. Par exemple, l'affichage en console se fait par un System.out.println(), et l'affichage dans une fenêtre va se faire par exemple par un setText() sur un JLabel. Dans l'interface tu auras une méthode display(String message) par exemple, et l'implémentation concrète console fera un [c]System.out.println(message)[c] et la version graphique fera un messageLabel.setText(message).

En revanche, je ne comprends pas bien ce que vient faire cette histoire de multithread ? Tu gères chaque joueur dans un thread différent, avec une gestion de l'alternance, par wait/notify ou lock ou équivalent, c'est ça ?

**noboxstyle** · 30/12/2016, 10h53

En fait tu as une appli console, et tu veux la copier coller pour l'interface graphique ?
Pour cela il aurait fallu travailler en MVC. Cela t'aurait permis de créer des classes et méthodes spécifiques à chaque action, et ne changer que l'engine (console ou graphique).

Là le plus simple (je ne connais pas l'archi de ton code puisque tu ne nous la fournis pas mais je vais le supposer) ce serait de reprendre tranquillement ton projet, faire l'interface graphique sans les evenements en swing, et ensuite essayer d'intercaler ce qui te semble pertinent de réutiliser.

**JeanArchibalde** · 30/12/2016, 13h08

joel.drigo, pour le multithread, je débute : avoir une fenetre graphique c'est bien un nouveau thread par rapport au main, ou je dis n'importe quoi?
Si c'est bien ca, je comprend ce que tu veux dire, effectivement je n'avais pas pensé à gerer le tour des joueur par un verou

Pour la boucle de jeu du main, si j'ai bien compris je ne peut pas y accéder par l'interface, donc je dois faire un choix entre le jeu en ligne de commande ou par l'interface. Du coup je supprime cette boucle du main, mais la ca devient compliqué:
noboxstyle, NORMALEMENT (mdrrrrr) je suis en MVC (en tout cas c'est Observer Observable). J'ai un sale doute du coup : vous pouvez me confirmer si c'est du MVC? :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
 
public void update(Observable arg0, Object arg1) {
	//methode update, instanciée dans mon code, je l'enlève pour plus de visibilité
	}
 
	public VueJoueur (Joueur joueur){
this.setTitle(""+joueur.getNomJoueur());
		this.joueur = joueur;
		joueur.addObserver(this);//pas sur que se soit utile, (peut etre) deja fait ailleur (je sais pas)
		joueur.poserCarte.addObserver(this);
 
		JPanel panelJoueur = new JPanel(); // je crée le boutons pour l'interface des joueurs
	JButton actionTourJeuD = new JButton("Defausser");
	    JButton actionTourJeuPi= new JButton("Piocher");
	    JButton actionTourJeuP = new JButton("Poser");
	    JButton actionTourJeuS = new JButton("Sacrifier");
	    JButton actionTourJeuSu = new JButton("Joueur suivant");
		JPanel actionJoueur = new JPanel();
		String[] listContent = {"ACTION_1", "ACTION_2", "ACTION_3","ACTION_4","ACTION_5"}; 
		CardLayout cl = new CardLayout();//au clic le texte du bouton change et "a" augmente, qui permet de gérer les action qui seron faites
//au clic sur les cartes
		actionTourJeuD.addActionListener(new ActionListener(){
		      public void actionPerformed(ActionEvent event){
		        //Via cette instruction, on passe au prochain conteneur de la pile
		        cl.next(actionJoueur);
		        a=2;
		      }
		    });
 
for (int i=0;i<7;i++){
//crée les cartes de la main
//et en fonction de la valeur de "a", leur fait faire une action, comme défausser ou poser
			boutonMain[i] = new JButton(""+joueur.mainJoueur[i].getNomCarte());
			panelJoueur.add(boutonMain[i]);
			int b = i;
			boutonMain[i].addActionListener(new ActionListener(){
			      public void actionPerformed(ActionEvent event){
			    	if(a==1){
			    		System.out.println("ok");
			    		joueur.seDefausser(joueur, b);
			    	}else if(a==3){
			    		joueur.poserCarte(b);
			    	}
			      }
			    });
		}
		Container c = this.getContentPane();
}

(J'ai pas tout mis pour que se soit plus lisible)
Donc ca c'est ma vue qui va se coller a chaque Joueur et leur faire une fenêtre pour chacun
Joueur etant ma classe Observable, le modèle

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
 
public class Joueur extends Observable{
 
public Joueur(String nomJoueur){
		tableJoueur = new LinkedList<GuideSpirituel>() ;//les cartes du joueur posées devant lui
		mainJoueur = new CarteJouable[7];
		this.nomJoueur=nomJoueur;
		this.poserCarte = new JoueurReel();//pour le patron strategy
	}
 
public void seDefausser(int a){
		//fonctionnement : pour linterface graphique, défausse la carte a la position int a
			this.mainJoueur[a] = null;
			setChanged();
			notifyObservers();
 
	}
 
	public void joue(){
		setChanged();
		notifyObservers();//je sais pas trop ou mettre le notify efficacement :,(
		try{
		System.out.println("A ton tour --------------"+this.getNomJoueur());
		this.afficherCartesMain();
		this.seDefausser();
		this.ajouterCarteMain(ensembleCarte);//le joueur joue, mais ici c'est en ligne de commandes
		this.afficherCartesMain();
		this.poserCarte();
		}
		catch(java.util.InputMismatchException a){
			System.out.println("Erreur---------------");
		}
		setChanged();
		notifyObservers();
	}
 
}

Du coup j'ai la vue dans une autre classe (la vue est combinée avec le controleur, le modèle existant déja au moment ou j'ai commencé) : (bon encore une fois c'est la première fois que je touche au mvc)

Dans le main je passe en revue la colletion de joueur et je les fait tous jouer tant que personne n'a gagné

ET LE problème c'est pour ajouter l'interface la dessus, je ne sais pas du tout comment faire
A la base je voulais pourvoir me recoller sur la methode jouer() de joueur, qui est déja en ligne de commande (le MVC quoi, je touche pas au modèle et je me colle dessus).

**noboxstyle** · 30/12/2016, 13h16

wow wow ! Pourquoi il y a des System.out.Println dans ton appli swing ? Retire moi ca :p.

Sépare ton code qui concerne le graphique de ton code qui concernent les évenements

.
Appelle les méthodes/les evenements dans tes classes graphiques uniquement par exemple.

Là c'est un peu le bordel mec ! ahah.

Soit clair et precis.
genre --> une classe A qui fait la fenetre (uniiiquement les composants graphiques et le bouton d'évenement par exemple)
--> une classe Abis qui gère le code des evenements (genre si tu as un bouton jouer dans ta classe A, Abis aura une méthode jouer() avec ce que doit faire le bouton quand on clique sur le "jouer" de la classe A).

**joel.drigo** · 30/12/2016, 13h55

Envoyé par JeanArchibalde

joel.drigo, pour le multithread, je débute : avoir une fenetre graphique c'est bien un nouveau thread par rapport au main, ou je dis n'importe quoi?

Oui, tout ce qui se passe dans l'interface graphique se passe dans son propre thread (l'Event Dispatch Thread), mais ce n'est pas pareil que de dire que ton application est multithread (elle l'est implicitement certes, mais tu ne gères pas explicitement plusieurs threads) : c'est simplement que pour certaines actions il faudra tenir compte que le rafraichissement de l'interface et les évenements se passent dans un thread particulier. Maintenant, tu peux ouvrir 50 JFrames, tu n'auras qu'un seul EDT.

Envoyé par JeanArchibalde

Si c'est bien ca, je comprend ce que tu veux dire, effectivement je n'avais pas pensé à gerer le tour des joueur par un verou

Je parlais d'une éventualité de plusieurs threads, un par joueur, mais pas de l'EDT.

Pour la boucle de jeu du main, si j'ai bien compris je ne peut pas y accéder par l'interface, donc je dois faire un choix entre le jeu en ligne de commande ou par l'interface. Du coup je supprime cette boucle du main, mais la ca devient compliqué:

Envoyé par JeanArchibalde

noboxstyle, NORMALEMENT (mdrrrrr) je suis en MVC (en tout cas c'est Observer Observable). J'ai un sale doute du coup : vous pouvez me confirmer si c'est du MVC?

Le MVC n'implique pas nécessairement le pattern Observer/Observable, et inversement. Ce pattern permet juste de mettre en place un système où un composant est notifié du changement d'une valeur gérée par un autre composant, (pour éviter que le composant qui a besoin d'utiliser la valeur soit obligé de demander sans arrêt au composant qui modifie la valeur, si celle-ci est modifié). Maintenant, si tu as un MVC (Modèle, Vue, Contrôleur), tu dois pouvoir facilement remplacer ta vue (console) par une autre vue (graphique elle). Bien sûr, il faut que le MVC soit correct : donc aucune instruction d'affichage ou d'entrée utilisateur, ni dans le modèle, ni dans le contrôleur. Seule la vue doit traiter de ces aspects. Il y a juste une difficulté à gérer entre les deux types de vues : dans une vue graphique les composants de saisie existent toujours, concurament aux composants d'affichage, alors que dans la console, il faudra alterner entre affichage et demande de saisie (d'une certaine manière simuler la "boucle" de l'EDT pour qu'elle alterne rafraichissement de l'affichage (les System.out.println()) et saisie au clavier (System.in/ou méthodes de Console)).

**JeanArchibalde** · 30/12/2016, 14h13

Ah mdrrrrrr le System.out c'est parce que le la méthode allait pas au bout avant et je voulais voir ou ça s’arrêtait, j'ai oublié de l'enlever ^^

Pour ton histoire de methode avec les classes A et Abis, c'est pas ce qui est fait la? :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
 
boutonMain[i].addActionListener(new ActionListener(){
			      public void actionPerformed(ActionEvent event){
			    	if(a==1){
			    		System.out.println("ok");
			    		joueur.seDefausser(joueur, b);
			    	}else if(a==3){
			    		joueur.poserCarte(b);
			    	}
			      }
			    });

Arf joel.drigo j'ai l'impression de pas avoir tout compris au MVC, pour moi ca nécessitait l'Observable Observer

Maintenant, si tu as un MVC (Modèle, Vue, Contrôleur), tu dois pouvoir facilement remplacer ta vue (console) par une autre vue (graphique elle). Bien sûr, il faut que le MVC soit correct : donc aucune instruction d'affichage ou d'entrée utilisateur, ni dans le modèle, ni dans le contrôleur. Seule la vue doit traiter de ces aspects.

Mais j'avais déja un jeu en ligne de commande, du coup j'avais des interaction avec la console dans mon modèle : du coup il me faut refaire ces méthodes sans les interaction console?

Je crois avoir compris le problème : j'ai découvert le java en septembre, et lorsque j'ai du faire le jeu en ligne de commande, je ne connaissait pas encore l'existence du MVC, DONC le jeu en ligne de commande n'est pas MVC, les interaction sont intégrées au modèle. Du coup la, si je veux ajouter une interface grâce au MVC, c'est le bazar puisque les méthodes existantes dans le modèle sont adaptées pour la console :/

**joel.drigo** · 30/12/2016, 14h19

Envoyé par JeanArchibalde

Arf joel.drigo j'ai l'impression de pas avoir tout compris au MVC, pour moi ca nécessitait l'Observable Observer

Il faut un système de ce type, mais si système évenementiel y ressemble fortement, ce n'est pas exactement le pattern et en Swing, on peut faire un MVC uniquement évenementiel (voir SwingPropertyChangeSupport). Mais on est dans le détail : ce que je voulais surtout dire c'est qu'avoir un Observer/Observable n'est pas suffisant pour avoir un MVC. L'erreur dans le MVC c'est souvent de faire un MV ou un VC (et l'Observer/Observable ne l'empêche pas).

**JeanArchibalde** · 30/12/2016, 14h40

Mince j'ai l'impression de faire que du MV depuis le début : est ce que ce bout de code correspond a la vue ou au contrôleur? ( dans la classe Vue)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
 
boutonMain[i].addActionListener(new ActionListener(){
			      public void actionPerformed(ActionEvent event){
			    	if(a==1){
			    		System.out.println("ok");
			    		joueur.seDefausser(joueur, b);
			    	}else if(a==3){
			    		joueur.poserCarte(b);
			    	}
			      }

Parce que c'est ce modèle que les prof nous ont donné,une gestion d'événement pas swing, une classe Modèle extends Observable, une classe Vue implements Observer, et une classe anonyme (ci dessus) qui gère les événements, redéfinit par actionPerformed

interagir avec la console par des interfaces graphiques

Java

Discussions similaires

Partager

Partager