Discussion :

[joel.drigo]

C'est ça en gros le code de tes rectangles superposés :

Code :

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

1
2
3
4
5
6
7
8
9
Color c = g.getColor();
            g.setColor(Color.RED);
            g.fillRect(0,0,600,310);
            g.fillRect(0,0,50,50);
 
            g.setColor(Color.black);
            g.fillRect(10,10,580,290);
            g.fillRect(10,10,30,30);
            g.setColor(c);

Tu le mets dans un if (ou if/else), avec une condition sur un booléen, et que tu changes ce booléen sur évenement (key, souris, ce que tu veux) et un repaint() après, pour redessiner.

Mais juste pour un rectangle comme ça, tu pourrais faire simplement un "matte border".

PSA quoi sert le deuxième petit rectangle (celui de 50×50 ou 30×30) ? Il se superpose au rectangle précédent qui est plus grand et dans la même couleur, donc il n'est pas visible.

[R1beLlu2B]

Merci,

je vais tente cela.

Les deuxièmes petit rectangle ne servent a rien effectivement. C'etais pour faire des tests, Je vais les supprime

[R1beLlu2B]

Ca marche super bien, même mieux que j'espérais



Maintenant je vais tente de mettre une image dans la condition "if" de Action.


Merci beaucoup pour le soutien

[R1beLlu2B]

Tout est parfait, tout marche super bien.


Je souhaiterai modifier cette ligne :

Code :

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

 static boolean zoom = false;

En faite au lieu de vrai ou faux, je voudrai que ça fasse défile des termes.

La boolean me donne vrai ou faux et en fonction m'affiche deux mot (qui apparaisse dans ma fenetre) qui sont en faite des choix.


Mais je voudrai avoir plus de choix.


je suis ne train d'étudier les variables car a priori c'est avec cela que je vais m'en sortir


Merci

[joel.drigo]

zoom c'est déjà une variable. Mais le mot "boolean" devant sa déclaration indique que son type est "boolean", donc que cette variable peut prendre 2 valeurs, true ou false.
Il y'a d'autres types primitifs, comme int (pour un entier, compris entre -2³¹ et 2³¹-1), ou double par exemple. Regarde la doc Oracle pour voir tous les types primitifs et ce qu'ils permettent comme valeurs pour choisir le type adapté à ton besoin.

A priori, je suppose que zoom représente un coefficient d'échelle (en absolu ou en pourcentage), donc pourrait être un float.

Éventuellement, si tu prévois un échantillon de zooms possibles, genre 10%, 25%, 50%, 75%, 100%, 200%..., (une liste finie de choix dans une combo par exemple), une enum pourrait être intéressante comme type, comme intermédiaire à la valeur réelle de type float. Après, tout dépend à quoi ce zoom s'applique : pour un affichage à l'écran, ou la manipulation de java.awt.Shape, utiliser un type AffineTransform peut avoir son avantage (voir mon exemple).

[R1beLlu2B]

Oui zoom est une variable, s'il c'est true, la souris bouge plus rapidement.


(Le Termes zoom sera change par la suite par vitesse 1)

Il est appele par la commande suivante :

Code :

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

1
2
3
if (e.getKeyCode() == NativeKeyEvent.VC_F7) {
        Main.zoom = !Main.zoom;
    }

ce que je souhaite faire c'est quand je presse F7 ca me choisi zoom, si je reappuie dessus ca me choisi vitesse 2 et ainsi de suite.


zoom(vitesse1) est dans mon fichier mouselistener

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
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
package r1bellu2b.norecoil;
 
import java.awt.MouseInfo;
import java.awt.Point;
import java.awt.Robot;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import org.jnativehook.mouse.NativeMouseEvent;
import org.jnativehook.mouse.NativeMouseInputListener;
 
public class MouseListener implements NativeMouseInputListener {
 
  static ExecutorService executorService = Executors.newFixedThreadPool(4);
 
  public void nativeMouseClicked(NativeMouseEvent e) {
  }
 
  public void nativeMousePressed(NativeMouseEvent e) {
 
 
    if (e.getButton() == 2) {
      Main.rightClick = true;
    }
    if (e.getButton() != 1) {      return;
    }
    Main.shooting = true;
    Config currentConfig = ConfigManager.getInstance().getCurrentConfig();
 
    executorService.submit(() -> {
      try {
        Robot robot = new Robot();
        robot.setAutoDelay(0);
        Point point;
        int correctionX;
        int correctionY;
        int beforeSleep;
        int afterSleep;
 
        while (Main.enabled && Main.shooting) {
          if (Main.zoom) {
            if (Main.rightClick) {
              correctionX = currentConfig.correctionZoomRightClickX;
              correctionY = currentConfig.correctionZoomRightClickY;
              beforeSleep = currentConfig.beforeShotSleepRightClickZoom;
              afterSleep = currentConfig.afterShotSleepRightClickZoom;
            } else {
              correctionX = currentConfig.correctionZoomX;
              correctionY = currentConfig.correctionZoomY;
              beforeSleep = currentConfig.beforeShotSleepZoom;
              afterSleep = currentConfig.afterShotSleepZoom;
            }
          } else {
            if (Main.rightClick) {
              correctionX = currentConfig.correctionRightClickX;
              correctionY = currentConfig.correctionRightClickY;
              beforeSleep = currentConfig.beforeShotSleepRightClick;
              afterSleep = currentConfig.afterShotSleepRightClick;
            } else {
              correctionX = currentConfig.correctionX;
              correctionY = currentConfig.correctionY;
              beforeSleep = currentConfig.beforeShotSleep;
              afterSleep = currentConfig.afterShotSleep;
            }
          }
          Thread.sleep(beforeSleep);
          point = MouseInfo.getPointerInfo().getLocation();
          robot.mouseMove(point.x + correctionX, point.y + correctionY);
          Thread.sleep(afterSleep);
        }
      } catch (Exception e1) {
        e1.printStackTrace();
      }
    });
  }
 
  public void nativeMouseReleased(NativeMouseEvent e) {
    if (e.getButton() == 2) {
      Main.rightClick = false;
    }
    if (e.getButton() == 1) {
      Main.shooting = false;
    }
  }
  public void nativeMouseMoved(NativeMouseEvent e) {
  }
  public void nativeMouseDragged(NativeMouseEvent e) {
  }
 }

et je vais rajoute les autres vitesse dedans comme ceci, enfin si ca marche

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
while (Main.enabled && Main.shooting) {
          if (Main.zoom) {
            if (Main.rightClick) {
              correctionX = currentConfig.correctionZoomRightClickX;
              correctionY = currentConfig.correctionZoomRightClickY;
              beforeSleep = currentConfig.beforeShotSleepRightClickZoom;
              afterSleep = currentConfig.afterShotSleepRightClickZoom;
            } else {
              correctionX = currentConfig.correctionZoomX;
              correctionY = currentConfig.correctionZoomY;
              beforeSleep = currentConfig.beforeShotSleepZoom;
              afterSleep = currentConfig.afterShotSleepZoom;
            }
          }
          if (Main.vitesse2) {
            if (Main.rightClick) {
              correctionX = currentConfig.correctionZoomRightClickX;
              correctionY = currentConfig.correctionZoomRightClickY;
              beforeSleep = currentConfig.beforeShotSleepRightClickZoom;
              afterSleep = currentConfig.afterShotSleepRightClickZoom;
            } else {
              correctionX = currentConfig.correctionZoomX;
              correctionY = currentConfig.correctionZoomY;
              beforeSleep = currentConfig.beforeShotSleepZoom;
              afterSleep = currentConfig.afterShotSleepZoom;
            }
          }

[joel.drigo]

(Le terme zoom sera change par la suite par vitesse 1

)
Si cette variable représente une vitesse, alors ne l'appelle pas zoom, mais vitesse.

Il est appele par la commande suivante :

Code :

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

1
2
3
if (e.getKeyCode() == NativeKeyEvent.VC_F7) {
        Main.zoom = !Main.zoom;
    }

ce que je souhaite faire c'est quand je presse F7 ca me choisi zoom, si je reappuie dessus ca me choisi vitesse 2 et ainsi de suite.

ça te choisi zoom puis vitesse 2 ? je ne comprends plus rien, c'est le zoom ou la vitesse ? Et c'est quoi "vitesse 2" ? C'est quoi l'unité de cette vitesse que tu veux gérer ? Et comment la touche F7 va gérer le choix de cette vitesse ?

1. On incrémente une grandeur, d'une valeur constante (mais dans ce cas, il faudrait pouvoir la décrémenter). Par exemple la variable représente un nombre de pixels.
   Le code pourrait être pour l'incrémentation :
   

   Code :

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

   1
   2
   3
   if (e.getKeyCode() == NativeKeyEvent.VC_F7) {
           Main.vitesse ++; // on ajoute 1 à la vitesse
       }

2. On fait défiler des choix prédéterminés, gérés avec une enum par exemple :
   

   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
   public enum VitesseSouris {
    
   	LENTE(1),
   	NORMAL(5),
   	RAPIDE(10),
   	TRES_RAPIDE(25);
    
   	private final int nbpîxels;
       private VitesseSouris(int nbpixels) {
       	this.nbpîxels=nbpixels;
       }
    
       public int getNbPîxels() {
   		return nbpîxels;
   	}
    
       public VitesseSouris next() {
   		int nextOrdinal = this.ordinal()+1;
   		if ( nextOrdinal>=VitesseSouris.values().length ) {
   			nextOrdinal=0;
   		}
   		return VitesseSouris.values()[nextOrdinal];
   	}
    
       public VitesseSouris previous() {
   		int nextOrdinal = this.ordinal()-1;
   		if ( nextOrdinal<0 ) {
   			nextOrdinal=VitesseSouris.values().length-1;
   		}
   		return VitesseSouris.values()[nextOrdinal];
   	}
    
       public int modifierPosition(int x, boolean sens) {
       	if ( sens ) {
       		return x+nbpîxels;
       	}
       	else {
       		return x-nbpîxels;
       	}
       }
    
    
   }

   La déclaration deviendrait :
   

   Code :

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

   static VitesseSouris vitesse = VitesseSouris.NORMAL; // par exemple, ici, la vitesse est initialisée à NORMAL

   pour la modif sur F7 qui fait défiler :
   

   Code :

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

   1
   2
   3
   if (e.getKeyCode() == NativeKeyEvent.VC_F7) {
           Main.vitesse = Main.vitesse.next();
       }

   Et pour modifier la position de la souris, si c'est la variable x,et que direction est un booléen pour le sens (true=vers le bas, false vers le haut) :
   

   Code :

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

   x = vitesse.getPosition(x, direction);

3. Il y a bien entendu pleins d'autres moyens de gérer ça

[R1beLlu2B]

ça te choisi zoom puis vitesse 2 ? je ne comprends plus rien, c'est le zoom ou la vitesse ? Et c'est quoi "vitesse 2" ? C'est quoi l'unité de cette vitesse que tu veux gérer ? Et comment la touche F7 va gérer le choix de cette vitesse ?

en faite "zoom" je vais l'appelle vitesse1 dans le code

A l'heure actuel zoom est bien en true ou false et me donne deux posibilite.

Mon but c'est d'avoir plus que deux posibilite.

je pense que avec :

Code :

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

1
2
3
if (e.getKeyCode() == NativeKeyEvent.VC_F7) {
        Main.vitesse = Main.vitesse.next();
    }

je devrai y arrive.

Apres je suppose que je devrai faire comme ci :

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
public class Main extends JFrame {
 
    static final String CONFIG_DIR = "configs/";
    static final String DEFAULT_CONFIG = CONFIG_DIR + "AKM.json";
    public static boolean rightClick;
    static boolean enabled = true;
    static boolean shooting = false;
  //  static boolean zoom = false;
 
    static boolean vitesse1 = true;
    static boolean vitesse2 = true;
    static boolean vitesse3 = true;
    static boolean vitesse4 = true;
    static boolean vitesse5 = true;
.....

[joel.drigo]

Non, surtout pas ça :

Code :

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

1
2
3
4
5
6
7
 
    static boolean vitesse1 = true;
    static boolean vitesse2 = true;
    static boolean vitesse3 = true;
    static boolean vitesse4 = true;
    static boolean vitesse5 = true;
.....

A une information, une variable, pas 36. Sinon le code devient une usine à gaz. S'il y a réellement plusieurs machins qui ont chacun leur vitesse, éventuellement un tableau, mais mieux un objet.

[R1beLlu2B]

J'ai essaye pas mal de chose et bien fouille le net et je trouve pas grand chose qui correspond a mon besoins.

La boolean choisi vrai ou faux, donc deux choix possible. Dans mode c'est de presse F7 qui True ou Flase.

Je cherche a faire :
Ont appuie sur F7 sa donne le choix 1
Ont reappuie sur F7 sa donne le choix 2
Ont reappuie sur F7 sa donne le choix 3
.....
Ainsi de suite et quand plus de choix, ont retourne au choix 1;

Mes choix serais ecrit comme ceci :

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
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
 Main.shooting = true;
    Config currentConfig = ConfigManager.getInstance().getCurrentConfig();
 
    executorService.submit(() -> {
      try {
        Robot robot = new Robot();
        robot.setAutoDelay(0);
        Point point;
        int correctionX;
        int correctionY;
        int beforeSleep;
        int afterSleep;
        while (Main.enabled && Main.shooting) {
          if (Main.choix1) {
            if (Main.rightClick) {
              correctionX = currentConfig.correctionZoomRightClickX;
              correctionY = currentConfig.correctionZoomRightClickY;
              beforeSleep = currentConfig.beforeShotSleepRightClickZoom;
              afterSleep = currentConfig.afterShotSleepRightClickZoom;
            } else {
              correctionX = currentConfig.correctionZoomX;
              correctionY = currentConfig.correctionZoomY;
              beforeSleep = currentConfig.beforeShotSleepZoom;
              afterSleep = currentConfig.afterShotSleepZoom;
            }
          }
          if (Main.choix2) {
            if (Main.rightClick) {
              correctionX = currentConfig.correctionZoomRightClickX;
              correctionY = currentConfig.correctionZoomRightClickY;
              beforeSleep = currentConfig.beforeShotSleepRightClickZoom;
              afterSleep = currentConfig.afterShotSleepRightClickZoom;
            } else {
              correctionX = currentConfig.correctionZoomX;
              correctionY = currentConfig.correctionZoomY;
              beforeSleep = currentConfig.beforeShotSleepZoom;
              afterSleep = currentConfig.afterShotSleepZoom;
            }
          }
          if (Main.choix3) {
            if (Main.rightClick) {
              correctionX = currentConfig.correctionZoomRightClickX;
              correctionY = currentConfig.correctionZoomRightClickY;
              beforeSleep = currentConfig.beforeShotSleepRightClickZoom;
              afterSleep = currentConfig.afterShotSleepRightClickZoom;
            } else {
              correctionX = currentConfig.correctionZoomX;
              correctionY = currentConfig.correctionZoomY;
              beforeSleep = currentConfig.beforeShotSleepZoom;
              afterSleep = currentConfig.afterShotSleepZoom;
            }
          }
 
 
          else {
            if (Main.rightClick) {
              correctionX = currentConfig.correctionRightClickX;
              correctionY = currentConfig.correctionRightClickY;
              beforeSleep = currentConfig.beforeShotSleepRightClick;
              afterSleep = currentConfig.afterShotSleepRightClick;
            }
            else {
              correctionX = currentConfig.correctionX;
              correctionY = currentConfig.correctionY;
              beforeSleep = currentConfig.beforeShotSleep;
              afterSleep = currentConfig.afterShotSleep;
            }
          }

Mais je ne vois pas trop avec quoi faire cela


Merci

Fred


EDIT: en relisant votre message je croit que avec objet je peu résourdre mon problème.

[joel.drigo]

Je cherche a faire :
Ont appuie sur F7 sa donne le choix 1
Ont reappuie sur F7 sa donne le choix 2
Ont reappuie sur F7 sa donne le choix 3

1. Soit tu utilises une variable de type int
   Déclaration de la variable :
   

   Code :

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

   static int choix=1;

   Réaction à l'appui de touche
   

   Code :

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

   1
   2
   3
   4
   5
   6
   if (e.getKeyCode() == NativeKeyEvent.VC_F7) {
           Main.choix++;
           if ( choix>3 ) { // si le choix max est 3
             Main.choix=1;
           }
       }

   Et ensuite, pour exploiter le choix :
   

   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
   switch(Main.choix) {
   case 1:
       // faire ici ce que tu veux pour le choix 1, comme par exemple :
       if (Main.rightClick) {
                 correctionX = currentConfig.correctionZoomRightClickX;
                 correctionY = currentConfig.correctionZoomRightClickY;
                 beforeSleep = currentConfig.beforeShotSleepRightClickZoom;
                 afterSleep = currentConfig.afterShotSleepRightClickZoom;
               } else {
                 correctionX = currentConfig.correctionZoomX;
                 correctionY = currentConfig.correctionZoomY;
                 beforeSleep = currentConfig.beforeShotSleepZoom;
                 afterSleep = currentConfig.afterShotSleepZoom;
               }
       break;
   case 2:
       // faire ici ce que tu veux pour le choix 2
       // ...
       break;
   case 3:
       // faire ici ce que tu veux pour le choix 3
       // ...
       break;
   }

2. soit une enum
   

   Code :

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

   1
   2
   3
   4
   5
   6
   7
   8
   public enum Choix {
       CHOIX1, CHOIX2, CHOIX3;
    
       public Choix next() {
             return Choix.values()[(ordinal()+1)%Choix.values().length];
       }
    
   }

   Déclaration de la variable :
   

   Code :

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

   static Choix choix = Choix.CHOIX1;

   Réaction à l'appui de touche
   

   Code :

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

   1
   2
   3
   if (e.getKeyCode() == NativeKeyEvent.VC_F7) {
           Main.choix= Main.choix.next();
       }

   Et ensuite, pour exploiter le choix :
   

   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
   switch(Main.choix) {
   case CHOIX1:
       // faire ici ce que tu veux pour le choix 1, comme par exemple :
       if (Main.rightClick) {
                 correctionX = currentConfig.correctionZoomRightClickX;
                 correctionY = currentConfig.correctionZoomRightClickY;
                 beforeSleep = currentConfig.beforeShotSleepRightClickZoom;
                 afterSleep = currentConfig.afterShotSleepRightClickZoom;
               } else {
                 correctionX = currentConfig.correctionZoomX;
                 correctionY = currentConfig.correctionZoomY;
                 beforeSleep = currentConfig.beforeShotSleepZoom;
                 afterSleep = currentConfig.afterShotSleepZoom;
               }
       break;
   case CHOIX2:
       // faire ici ce que tu veux pour le choix 2
       // ...
       break;
   case CHOIX3:
       // faire ici ce que tu veux pour le choix 3
       // ...
       break;
   }

EDIT: en relisant votre message je croit que avec objet je peu résourdre mon problème.

cela ne veut rien dire : "avec objet"...

[R1beLlu2B]

Bonjour,


Désole si parfois j'emplois des termes qui ne veulent rien dire, jE suis débutant en JAVA et en programmations tout cours.

j'avais fait un petit site il y a bien longtemps mais c'étais beaucoup plus simple je trouve XD.

En tout cas merci pour les conseil hier, j'ai réussi à tout applique cette nuit.

J'ai un choix multiple en Configurations et en paralelle un choix multiple d'option, le fameux switch réalise cette nuit grace a vos conseil . (tout ca est gére par mes fichier configs, tout est fonctionnel)

Mais une idée mais venu ,


Dans l'état des choses F7 gère mes option et F8 mes configurations.

J'aimerai que mon programme garde en mémoire (tant qu'il es en marche) l'option séléctionné sur une configs.



je m'explique :

je choisi la Config 1 et je choisi l' option 2,


je passe sur la config 2 et je choisi l'option 3,



je reviens sur la config 1 et l'option 2 est choisi

je repasse sur la config 2 et l'option 3 est choisi



J'éspère que mon explications es compréhensible.

La j'ai réussi a faire ceci, quand je change de config, je reviens a l'option 1, c'est déja pas mal mais pas optimum

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
public void nativeKeyPressed(NativeKeyEvent e) {
 
 
    if (e.getKeyCode() == NativeKeyEvent.VC_F8) {
      ConfigManager.getInstance().cycleConfigs();
     Main.choix = Main.choix.CHOIX1;  // je rapelle le choix 1 
 
    }
 
      if (e.getKeyCode() == NativeKeyEvent.VC_F7) {
        Main.choix = Main.choix.next(CHOIX1);
      }

Merci

Fred

[joel.drigo]

Est-ce toi qui a écrit le code de la classe Config ? Si oui, tu pourrais stocker le choix dans cette configuration, avec une variable, au lieu de le mettre dans Main. Il te suffirait de récupérer la valeur en faisant ConfigManager.getInstance().getCurrentConfig().choix au lieu de Main.choix.

Si tu ne peux pas modifier le code de cette classe Config, tu peux utiliser une map pour stocker l'association entre config et choix.

Si le choix est de type int, déclaration, par exemple dans Main :

Code :

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

static Map<Config, Integer> memoireChoix = new HashMap<>();

Code :

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

1
2
3
4
5
if (e.getKeyCode() == NativeKeyEvent.VC_F8) {
      ConfigManager.getInstance().cycleConfigs();
      Main.choix = Main.memoireChoix.getOrDefault(ConfigManager.getInstance().getCurrentConfig(),1); // obtenir l'association config/choix ou 1 si elle n'existe pas
 
    }

Code :

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

1
2
3
4
5
6
7
8
 
if (e.getKeyCode() == NativeKeyEvent.VC_F7) {
        Main.choix++;
        if ( choix>3 ) { // si le choix max est 3
          Main.choix=1;
        }
        Main.memoireChoix.put(ConfigManager.getInstance().getCurrentConfig(),Main.choix); // stocker l'association config/choix
    }

Si le choix est de type enum ChoixVitesse :

Code :

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

Map<Config, ChoixVitesse> memoireChoix = new HashMap<>();

Code :

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

1
2
3
4
5
if (e.getKeyCode() == NativeKeyEvent.VC_F8) {
      ConfigManager.getInstance().cycleConfigs();
      Main.choix = Main.memoireChoix.getOrDefault(ConfigManager.getInstance().getCurrentConfig(),ChoixVitesse.CHOIX1);
 
    }

Code :

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

1
2
3
4
5
 
if (e.getKeyCode() == NativeKeyEvent.VC_F7) {
        Main.choix=Main.choix.next();
        Main.memoireChoix.put(ConfigManager.getInstance().getCurrentConfig(),Main.choix);
    }

[R1beLlu2B]

j'ai une classe config manager qui elle je l'es récupere sur internet avec quelque modification apporte:

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
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
package r1bellu2b.norecoil;
 
import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.util.ArrayList;
 
 
public class ConfigManager {
 
  public static ArrayList<Config> configs = new ArrayList<>();
  private static ConfigManager ourInstance = new ConfigManager();
  int currentConfig = 0;
 
  private ConfigManager() {
 
  }
 
  public static ConfigManager getInstance() {
    return ourInstance;
  }
 
  public void readConfigs() {
    configs.clear();
    Gson gson = new GsonBuilder().setPrettyPrinting().create();
    File dir = new File(Main.CONFIG_DIR);
    File[] files = dir.listFiles();
    if (files != null) {
      for (File file : files) {
        try {
          BufferedReader br = new BufferedReader(new FileReader(file));
          Config config = gson.fromJson(br, Config.class);
          config.name = file.getName().replace(".json", "");
          configs.add(config);
          System.out.println("Loaded Config:\n" + gson.toJson(config));
          br.close();
        } catch (Exception e) {
          e.printStackTrace();
        }
 
      }
    }
  }
 
  public Config getCurrentConfig() {
    if (configs.size() <= 0) {
      return new Config();
    } else {
      return configs.get(currentConfig);
    }
  }
 
  public void cycleConfigs() {
    if (configs != null && configs.size() > 0) {
      if (currentConfig == configs.size() - 1) {
        currentConfig = 0;
      } else {
        currentConfig++;
      }
    }
  }
 
}

et la class config c'est moi qui l'es créer :

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
package r1bellu2b.norecoil;
 
 
public class Config {  // Ne jamais modifie cette class
 
  String name = "Default";
 
  int correctionX = 0;
  int correctionY = 0;
  int beforeShotSleep = 1;
  int afterShotSleep = 1;
 
   int correctionZoomX = 0;
  int correctionZoomY = 0;
  int beforeShotSleepZoom = 1;
  int afterShotSleepZoom = 1;
 
  int correctionRightClickX = 0;
  int correctionRightClickY = 0;
 
  int beforeShotSleepRightClick = 1;
  int afterShotSleepRightClick = 1;
 
 
  int correctionX2RightClickX = 0;
  int correctionX2RightClickY = 0;
 
 
 
  int correctionX4RightClickX = 0;
  int correctionX4RightClickY = 0;
 
 
  int correctionX8RightClickX = 0;
  int correctionX8RightClickY = 0;
 
  int beforeShotSleepRightClickZoom = 1;
  int afterShotSleepRightClickZoom = 1;
 
}

C'est le fichier config charger par default et qui me renvois sur mes config en .json

[joel.drigo]

et la class config c'est moi qui l'es créer :

Donc tu peux déplacer la variable choix dans cette classe (tu la déclares public, ou tu fais un accesseur) et donc, tu associeras choix et config de fait.

[R1beLlu2B]

Super,

Ca marche avec la deuxieme solution :

Dans le main :

Code :

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

1
2
3
4
5
6
7
  ...
  static Gson gson = new GsonBuilder().setPrettyPrinting().create();
 
 
    static Map<Config, Choix> memoireChoix = new HashMap<>();
 
....

Dans le key bord listener

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
  if (e.getKeyCode() == NativeKeyEvent.VC_F8) {
      ConfigManager.getInstance().cycleConfigs();
     //Main.choix = Main.choix.CHOIX1;
      Main.choix = Main.memoireChoix.getOrDefault(ConfigManager.getInstance().getCurrentConfig(), Main.Choix.CHOIX1);
    }
 
      if (e.getKeyCode() == NativeKeyEvent.VC_F7) {
        Main.choix = Main.choix.next(CHOIX1);
        Main.memoireChoix.put(ConfigManager.getInstance().getCurrentConfig(),Main.choix);
      }

et les import de class qui vont avec .

Merci beaucoup

Auriez vous un lien qui me permettrai de trouvé les solutions a mes futur problème.

Vous êtes vraiment sympa de m'aidé dans mon projet mais je ne voudrai pas trop en "abusé"


Merci

Fred

[joel.drigo]

Auriez vous un lien qui me permettrai de trouvé les solutions a mes futur problème.

A part, https://www.developpez.net/forums/f6/java/, je dirais tous les liens (FAQ et tuto pour commencer) de ma signature

Vous êtes vraiment sympa de m'aidé dans mon projet mais je ne voudrai pas trop en "abusé"

Rien ne m'oblige à répondre si je ne n'en ai pas le temps ou l'envie D'autres membres prendront le relais à ce moment. Pour le moment, tu es bien loin de l'abus si on compare à d'autres discussions.

[R1beLlu2B]

Merci,

J'ai un peu fouille le forum mais la je sèche un peu,

j'ai essaye plusieurs possibilite mais toute echoue.


J'ai F5 et F6 qui me fond défile des choix (j'ai créer un deuxième déffilement de choix ), ceci est fonctionnel .

A l'écran j'ai bien F5 = CHOIX1 par (exemple)
et F6 = CHOIX3 par exemple


et je voudrai que F8 me permette d'affiche et d'utilise le choix 1 ou le choix 3

ceci etant fait pour ne pas a avoir tout le temps a faire défile pour choisir.

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
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
package r1bellu2b.norecoil;
 
 
 
import org.jnativehook.GlobalScreen;
import org.jnativehook.NativeHookException;
import org.jnativehook.keyboard.NativeKeyEvent;
import org.jnativehook.keyboard.NativeKeyListener;
 
import static r1bellu2b.norecoil.Main.Choix.CHOIX1;
 
 
public class KeyBoardListener implements NativeKeyListener {
 
  public void nativeKeyTyped(NativeKeyEvent e) {
  }
  public void nativeKeyPressed(NativeKeyEvent e) {
 
 
    if (e.getKeyCode() == NativeKeyEvent.VC_F5) {
        ConfigManager.getInstance().cycleConfigs();
      //  Main.choix = Main.memoireChoix.getOrDefault(ConfigManager.getInstance().getCurrentConfig(), Main.Choix.CHOIX1);
    }
 
 
    if (e.getKeyCode() == NativeKeyEvent.VC_F6) {
      ConfigManager2.getInstance().cycleConfigs();
      //   Main.choix = Main.memoireChoix.getOrDefault(ConfigManager.getInstance().getCurrentConfig(), Main.Choix.CHOIX1);
    }
 
 
    if (e.getKeyCode() == NativeKeyEvent.VC_F8) {
 
//c'est ici que je seche !!!!
 
          Main.choix = Main.memoireChoix.getOrDefault(ConfigManager.getInstance().getCurrentConfig(), Main.Choix.CHOIX1);
    }
 
    if (e.getKeyCode() == NativeKeyEvent.VC_F7) {  //VISEURS
        Main.choix = Main.choix.next(CHOIX1);
        Main.memoireChoix.put(ConfigManager.getInstance().getCurrentConfig(),Main.choix);
      }
 
 
 
 
 
      if (e.getKeyCode() == NativeKeyEvent.VC_F10) {
        Main.Overlay = !Main.Overlay;
      }
 
      if (e.getKeyCode() == NativeKeyEvent.VC_F11) {
        Main.enabled = !Main.enabled;
        ConfigManager.getInstance().readConfigs();
      }
      if (e.getKeyCode() == NativeKeyEvent.VC_F12) {
        try {
          GlobalScreen.unregisterNativeHook();
          Main.enabled = false;
          Main.shooting = false;
 
          MouseListener.executorService.shutdown();
          System.exit(1);
        } catch (NativeHookException e1) {
          e1.printStackTrace();
        }
      }
    }
 
  public void nativeKeyReleased(NativeKeyEvent e) {
 
  }
}

j'ai essayé de faire un switch sur la ligne :

Code :

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

  if (e.getKeyCode() == NativeKeyEvent.VC_F8) {

mais je n'es sur quoi ecrire

j'ai essaye ca mais sans succes

Code :

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

1
2
3
4
5
6
7
8
   if (e.getKeyCode() == NativeKeyEvent.VC_F8) {
switch (e.getKeyCode()) {
        case KeyCode.VC_F5())
          break;
        case KeyCode.VC_F6())
 
 
      }

Merci


Fred

[joel.drigo]

J'ai F5 et F6 qui me fond défile des choix (j'ai créer un deuxième déffilement de choix ), ceci est fonctionnel .

A l'écran j'ai bien F5 = CHOIX1 par (exemple)
et F6 = CHOIX3 par exemple


et je voudrai que F8 me permette d'affiche et d'utilise le choix 1 ou le choix 3

C'est assez obscur pour moi. Tu as deux types de config ? Et tu veux alterner entre les deux,sur F8 ?

ceci etant fait pour ne pas a avoir tout le temps a faire défile pour choisir.

Pourquoi ne pas faire soit un système d'accède directe (par exemple SHIFT+F1 donne choix1, SHIFT+F2 donne choix2...), ou un système de pref comme dans certains jeux : par exemple 4 pref, sur par exemple les flêches droite, gauche, haut, bas, SHIFT+FLECHE sauve le choix courant pour la flêche, un appui FLECHE sélectionne le choix mémorisé pour cette flêche

le souci pour :

Code :

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

1
2
 
      ConfigManager.getInstance().cycleConfigs();

Code :

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

1
2
 
      ConfigManager2.getInstance().cycleConfigs();

et que ça change rien si tu accèdes toujours à la config par

Code :

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

1
2
 
      ConfigManager.getInstance().getCurrentConfigs();

Maintenant la solution à ton problème pourrait être (comme c'est assez obscur, je ne suis pas sûr de ce que tu cherches à faire) de gérer les ConfigManager en variable dans Main.
Si tu déclares une variable, par exemple dans Main :

Code :

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

static ConfigManager configManager = ConfigManager.getInstance();

et

Code :

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

1
2
3
4
5
6
7
8
if (e.getKeyCode() == NativeKeyEvent.VC_F8) {
    if ( Main.configManager==ConfigManager.getInstance() ) {
         Main.configManager=ConfigManager2.getInstance();
    }
    else {
         Main.configManager=ConfigManager.getInstance();
    }
}

(tu peux aussi faire un tableau de ConfigManager et faire défiler par l'index, si tu as besoin de plus de 2 configs).

et ensuite au lieu d'utiliser un config en faisant ConfigManager.getInstance().getCurrentConfig(), tu fais Main.configManager.getCurrentConfig() (et pareil pour cycleConfig())...tout simplement.

D'une manière générale, il faut éviter les static : justement, sans static, tu peux avoir plusieurs "version" d'un même objet. Si au lieu d'avoir toutes tes variables static dans Main, tu avais un objet avec ces variables en attributs (donc non static), il suffirait d'avoir deux objets avec des valeurs différentes pour tous ces attributs, pour basculer d'un état à un autre, l'un ayant un choix, une config courant, une liste de config, etc, et l'autre ayant un autre choix, une autre config courante... etc

[R1beLlu2B]

Je pense que ca devrai marche avec la solution :

Code :

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

1
2
3
4
5
6
7
8
if (e.getKeyCode() == NativeKeyEvent.VC_F8) {
    if ( Main.configManager==ConfigManager.getInstance() ) {
         Main.configManager=ConfigManager2.getInstance();
    }
    else {
         Main.configManager=ConfigManager.getInstance();
    }
}

J'ai du rajoute dans le Main :

Code :

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

1
2
3
4
 static ConfigManager configManager = ConfigManager.getInstance();
 
//erreur si pas de staic pour le confiDManager2
    static ConfigManager2 configManager2 = ConfigManager2.getInstance();

J'ai d'erreur dans mon code, celui ci ce compile bien mais je doit ecrire comme le

Code :

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

1
2
 g2.setColor(new Color(225, 96, 0));
            g2.drawString( ?????????);

je doit refaire un switch comme pour :

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
 switch (Main.choix) {
 
                case CHOIX1:
                    g2.setColor(Color.GREEN);
                    g2.setFont(myFont);
                    g2.drawString(" X1", 180, 170);
                    break;
                case CHOIX2:
                    g2.setFont(myFont);
                    g2.setColor(Color.GREEN);
                    g2.drawString("X2", 180, 170);
                    break;
                case CHOIX3:
                    g2.setFont(myFont);
                    g2.setColor(Color.GREEN);
                    g2.drawString("  X4", 180, 170);
                    break;
                case CHOIX4:
                    g2.setFont(myFont);
                    g2.setColor(Color.GREEN);
                    g2.drawString("   X8", 180, 170);
                    break;
            }
 
        }

merci


Fred