Afficher un background dans ma fenêtre

Version imprimable

Voir 40 message(s) de cette discussion en une page

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

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.

04/04/2018, 14h10
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
04/04/2018, 14h20
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
04/04/2018, 18h27
R1beLlu2B

Tout est parfait, tout marche super bien.

Je souhaiterai modifier cette ligne :

Code:

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
04/04/2018, 20h29
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).

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:

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:

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:

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;
            }
          }

Citation:

Envoyé par R1beLlu2B

(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.
Citation:
Envoyé par R1beLlu2B
Il est appele par la commande suivante :
Code:

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 ?
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:

1 2 3 if (e.getKeyCode() == NativeKeyEvent.VC_F7) { Main.vitesse ++; // on ajoute 1 à la vitesse }
On fait défiler des choix prédéterminés, gérés avec une enum par exemple :
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 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:

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

pour la modif sur F7 qui fait défiler :
Code:

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:

x = vitesse.getPosition(x, direction);
Il y a bien entendu pleins d'autres moyens de gérer ça

Citation:

ç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:

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:

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; .....

04/04/2018, 21h29
joel.drigo
Non, surtout pas ça :
Citation:
Envoyé par R1beLlu2B

Code:

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.

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:

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.

Citation:

Envoyé par R1beLlu2B

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

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

Code:

static int choix=1;

Réaction à l'appui de touche

Code:

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:

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;
}

soit une enum

Code:

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:

static Choix choix = Choix.CHOIX1;

Réaction à l'appui de touche

Code:

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

Et ensuite, pour exploiter le choix :

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
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;
}

Citation:

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

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

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:

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

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:

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

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:

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:

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

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:

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

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

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
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:

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

05/04/2018, 15h08
joel.drigo

Citation:

Envoyé par R1beLlu2B

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.

Super,

Ca marche avec la deuxieme solution :

Dans le main :
Code:

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:

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

05/04/2018, 15h40
joel.drigo

Citation:

Envoyé par R1beLlu2B

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 ;)

Citation:

Envoyé par R1beLlu2B

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.

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:

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:

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

mais je n'es sur quoi ecrire

j'ai essaye ca mais sans succes

Code:

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

Citation:

Envoyé par R1beLlu2B

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 ?

Citation:

Envoyé par R1beLlu2B

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:

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

1 2 ConfigManager2.getInstance().cycleConfigs();
et que ça change rien si tu accèdes toujours à la config par
Code:

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:

static ConfigManager configManager = ConfigManager.getInstance();

et
Code:

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

Je pense que ca devrai marche avec la solution :

Code:

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:

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:

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

je doit refaire un switch comme pour :

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
 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

Voir 40 message(s) de cette discussion en une page