Discussion :

[Zarr.be]

voilà mon problème, je débute c# et en programmation objet...
Je suis en train de faire un jeu ou j'ai un objet "zone de jeu" qui accède à un objet "carte" qui possède des objets "cellule" qui possède des objets "élément" qui ont un objet "définition des éléments" qui lui possède un objet "bitmap"
donc vous avez compris que zone de jeu a besoin de récupérer les bitmaps...
j'essaye bien entendu de respecter le principe de couplage faible (ne pas transpercer tous les objets)
ce qui fait que j'ai un tas de méthodes pour aller récupérer le bitmap

Code :

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

1
2
3
4
5
       public Bitmap GetBitmapCase (int x, int y, int tx, int ty)
        {
            CellBase c= (CellBase)carte[x, y];
            return c.GetBitmap(tx, ty);
        }

résultats (j'ai fait des tests) pourra afficher le bitmap avec DrawImageUnscaled il met 0.00003 sec
et pour simplement aller récupérer le bitmap il met 0.0008 sec dont il met 24 fois plus de temps

j'ai trois questions:
est-ce que ma vision de la programmation objet est bonne?
est-ce que c'est normal qu'ils mettent autant de temps dans les appels de méthode??
est-ce que ça serait judicieux de mettre les bitmap dans un objet de stockage directement relié à "zone de jeu"??

[maa]

Pourrais-tu afficher ton code en entier ?

[Zarr.be]

Non!

[theMonz31]

la lenteur peut-etre du à des opérations de boxing / unboxing ou eventuellement
l'utilisation de liste ou de tableau qui font que cela ralenti grandement ton
application...

apres, ca me choque pas que l'affichage soit plus rapide que la recherche
dans la mesure ou quand tu fais ta méthode GetBitmap() tu dois faire
une recherche par rapport à une position et que regarder l'ensemble des images
pour trouver la bonne doit etre lent.. .

Peut-etre qu'un dictionnaire avec pour clé un Point et une image comme donnée pourrait résoudre le problème de performance...

Quand au fait que tu ne montres pas le code, c'est ton droit le plus libre mais
pour autant, t'aider sans connaitre un minimum les objets ou les types
de structures ou listes ou tableaux que tu utilises limites les pistes ou solutions que l'on pourrait te donner ici

Et pis, ton code, tu peux "toujours" le diminuer des infos ULTRA sensibles et confidentiel que tu y as dedans

Maintenant, mon avis est qu'ici, beaucoup de gens sont capables de faire ton jeu (en dehors de l'aspect visuel) , donc pour moi, etre catégorique sur la non diffusion du code... c'est pour moi, euh, comment dirais-je poliement.. ridicule

(te vexes pas

The Monz, TOulouse

[theMonz31]

en faisant le test avec un Dictionnary<Point,Bitmap>

j'arrive aux perfos suivantes :

Temps pour obtenir la bitmap au point(800,0) = 0.00006 secondes
soit 0.06 ms.. c'est rapide quand meme ? non ?

The Monz, Toulouse

[Zarr.be]

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
//------------classe zone de jeu, j'ai cette instruction ci-jointe:
 
 g.DrawImageUnscaled(Carte.GetBitmapCase(ix, iy,(int) tailleHexaX, (int) tailleHexaY),xg, yg);
 
//------------------ classe carte
        public Bitmap GetBitmapCase (int x, int y, int tx, int ty)
        {
            CellBase c= (CellBase)carte[x, y];
 
             return c.GetBitmap(tx, ty);
         }
 
//--------------------- classe cellules
        public Bitmap GetBitmap(int x, int y)
        {
            bt=new Bitmap(x, y);
            Graphics g= Graphics.FromImage(bt);
 
            foreach(Element el in listeElements)
            {
 
                g.DrawImageUnscaled(el.GetBmpMini(x, y), 0, 0);
            }
            g.Dispose();
            return bt;
        }
//--------------------------- classes éléments
        public Bitmap GetBmpMini (int x, int y)
        {
            return def.GetBmpMini(x, y);
        }
//----------------------- classe définition éléments
//---------------------- bmpmini est un bitmap déjà réduit
        public Bitmap GetBmpMini (int X, int Y)
        {
            if(X == tailleX && Y == tailleY)
            {
                return bmpMini;
            }
            else
            {
                ResizeBmpMini(X, Y);
                return bmpMini;
            }
 
        }

pour réaliser une image complète je dois effectuer 400 fois cette suite d'instructions +-0.20 seconde
à chaque cycle, je récupère l'image d'un Hexagone
par Hexagone il y a au maximum cinq images qui s'empile
j'ai déjà optimisé ma fonction GetBmpMini en recréant une miniature si elle est différente de celle en mémoire


j'ai trois questions:
est-ce que ma vision de la programmation objet est bonne?
est-ce que c'est normal qu'ils mettent autant de temps dans les appels de méthode??
est-ce que ça serait judicieux de mettre les bitmap dans un objet de stockage directement relié à "zone de jeu"??