Discussion :

[Hornetmix]

Bonjour à tous,

Je suis en train de programmer un petit jeu avec un ami depuis 1 mois . Nous nous demandons comment faire pour charger toutes les images et sons dont nous avons besoin tout au long de notre jeu afin que java n'ait pas à les recharger en plein milieu du jeu ( Le jeu a alors un léger lag pour le chargement des sons par exemple ! ) . On voudrait que tout se charge en début de programme ( un écran de Loading en quelque sorte je pense )

Avez vous une solution à cela ? Merci !

[joel.drigo]

Salut,

Il suffit que tu fasses une classe qui contient toutes tes ressources, avec des accesseurs pour les récupérer. Par exemple, tu peux utiliser des enum pour les identifier, et utiliser des maps pour les stocker.

Exemple de base :

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
public class Ressources {
 
    public enum Sprite {
         SPRITE_DE_CECI,
         SPRITE_DE_CELA,
         ...
    }
 
    public enum Son {
         SON_DE_CECI,
         SON_DE_CELA,
         ...
    }
 
    private Map<Sprite, Image> mapSprite = new HashMap<>; // Image ou buffered image
    private Map<Son, XXX> mapSons = new HashMap<>; // XXX la classe que vous utilisez pour le son (Player, Clip... que sais-je)
 
    public Ressources() {
    }
 
    public Image getSprite(Sprite imageId) {
        return mapSprite.get(imageId);
    }
 
    public XXX getSon(Son sonId) {
        return mapSons.get(sonId);
    }
 
    public void charger() {
         mapImages.put(Image.SPRITE_DE_CECI, ImageIO.load( nomDuFichierDeImageDeCeci ); // je mets pas le détail de l'accès au fichier (à priori il devrait y avoir du getResourceAsStream..., et de l'IOException à catcher)
         mapImages.put(Image.SPRITE_DE_CELA, ImageIO.load( nomDuFichierDeImageDeCela );
         ...
    }
 
}

La méthode loadResources pourrait avoir un argument de type JProgressBar si tu veux afficher la progression (ou mieux, mais un petit peu moins simple, utiliser un système évènementiel).

Ensuite dans le main :

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 LancementDuJeu {
 
    public static void main(String[] args) {
 
         Ressources ressources = new Resources();
 
         ressources.load();
 
         Jeu jeu = new Jeu(ressources);
 
         jeu.demarrer();
 
    }
 
}

Ensuite, il y a des variantes :

• par exemple, tu pourrais avoir, pour un sprite, plusieurs positions (animations), et donc avoir une méthode getSprite(Sprite spriteId, int position) , avoir plusieurs façons de le résoudre (par exemple, une Map<Sprite, Image[]>);
• gérer tes sprites par image map (une seule image, et chaque sprite et une sous partie de l'image (la map stockerait des java.awt.Rectangle pour déterminer la partie de l'image qui correspond au sprite);

Tu peux également te passer des maps, en intégrant directement les images dans les variables de l'énumération (le nom du fichier est passé en argument du constructeur de l'enum, et on ajoute une méthode getImage(), mais ce ne sera pas possible de gérer une progression du chargement. Une méthode hybride est possible, en utilisant des maps statiques. Au lieu de faire resource.getSprite(Sprite.SPRITE_DE_CELA), tu ferais Sprite.SPRITE_DE_CELA.getImage().

Une variante pour gérer les noms des fichiers :

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
...
     public enum Sprite {
         SPRITE_DE_CECI("fichier1.png"),
         SPRITE_DE_CELA("fichier2.png"),
         ...;
         private final String fichier;
         Sprite(String fichier) {
             this.fichier=fichier;
         }
         String getFichier() {
              return fichier;
         }
    }
 
   ...
 
   public void charger() {
 
 
        for(Sprite sprite : Sprite.values()) {
 
           mapSprite.put(sprite, ImageIO.load(DIRECTORY_IMAGES + sprite.getFicher()); 
 
        }
 
   }

[kolodz]

La solution proposé par joel.drigo fonctionne parfaitement.
Il faut juste faire attention à l’empreinte mémoire et ne pas charger trop de chose. Même si aujourd'hui la problématique de manque RAM aussi important qu'avant.

Cordialement,
Patrick Kolodziejczyk.

[Hornetmix]

Merci beaucoup pour cette réponse très détaillée et rapide !
Je vais tester ça ce soir et je te tiens au courant.

Encore Merci !