Le chasseur de bombes

Bonjour,

j'ouvre ce soir le sujet "Chasseur de bombes".

Bon je ne l'ai pas encore mis en validation, mais cela devrait se faire sous peu.

J'ai eu beaucoup de mal à gérer l'étendue des cases "blanches", mais ça y est j'ai une procédure correcte.

Je suis content car le jeu en lui-même ne prend pas trop de ligne de code, c'est plus au niveau de la cosmétique que la grandeur augmente !

@ bientôt

LouReeD

j'ouvre ce soir le sujet "Chasseur de bombes".

Bon je ne l'ai pas encore mis en validation, mais cela devrait se faire sous peu.

J'ai eu beaucoup de mal à gérer l'étendue des cases "blanches", mais ça y est j'ai une procédure correcte.

Je suis content car le jeu en lui-même ne prend pas trop de ligne de code, c'est plus au niveau de la cosmétique que la grandeur augmente !

slt LouReeD,

j'ai bien hâte de voir ton "Chasseur de bombes"

à très bientôt

oups, du coup je viens de réaliser que j'ai participé à un fil qui contient un gros mot et que je suis maintenant la proie des chasseurs de gros mots

Bonjour,

évidemment, vu sous cet angle...

Loin de moi cette idée !

Je peux dire "mine" c'est vrai vu que c'est une (pâle) copie du Démineur©... Mais bon, je crois que je vais garder "Bombes" !

@ bientôt

LouReeD

Bonsoir,

Allez, pour faire patienter tout le monde, voici un ScreenShot de la futur version :

apercu

La mise en forme fait ralentir le code mais cela me convient tout de même, Je triche en mettant suffisamment de bombes pour éviter les trop grandes surfaces "blanches" !

@ bientôt

LouReeD

La fin est proche !

Je viens de finir la gestion de la victoire, il me reste à finaliser le tableau des scores où seul le temps et la taille des grilles seront pris en compte... Enfin, pour le moment !

@ bientôt

LouReeD

Le design du jeu est sympa en tout cas

Bonjour,

Merci pour la remarque

Mais comme dit plus haut cela ralenti le code, pourtant je réduis au minimum l'accès à la feuille mais bon vu la mise en forme je suis "obligé" d'y aller pour chaque cellule...

La finalisation est proche...

@ bientôt

LouReeD

Bonsoir,

Petits contre temps... Mais je ne me décourage pas, il devrait bientôt sortir... Mais je travaille actuellement en parallèle sur StarTron ! Alors du coup je m'y perds et je prend du retard !

@ bientôt

LouReeD

Bonsoir,

du nouveau sous le soleil !

Vous racontant que mon code mettait "un peu de temps" à afficher les zones blanches du fait pour une partie de la mise en forme des cellules, je me suis senti "obligé" de chercher une solution...

Et je crois que je suis arrivé sur un joli résultat !

Je me suis rappelé que les "tests" étaient gourmant en ressources...

Je me suis aussi rappelé d'un test "inversé" jouant sur la gestion d'erreur de VBA...

En effet, dans un classeur ayant plusieurs feuilles, lors de la création d'une nouvelle feuille, on "se doit" de vérifier que le nom proposé par l'utilisateur n'est pas déjà existant. Ce que je faisais "à l'époque" était une boucle sur les noms de toutes les feuilles avec un test : "si nom proposé est égal au nom de la feuille 1 testée alors pas bon sinon on teste avec la feuille suivante" etc...

Hors avec une gestion d'erreur tout est plus simple :

on demande d'activer la feuille portant le nom proposé par l'utilisateur : si erreur le nom est inconnu on peut le garder, si pas d'erreur c'est qu'il faut changer de nom ! C'est beaucoup plus rapide car un seul test !

Donc dans mon code il y a plusieurs tests lors de la recherche d'étendue de zone blanche :

une cellule blanche = on vérifie les 8 qui sont autour de la première, mais il y a 8 test pour s'assurer que l'on ne va pas tester une zone "hors jeu", car si la cellule de départ est au bord de la grille, les cellules autours sont pour certaines hors jeu.

Du coup pour une cellule de coordonnées X et Y il me fallait faire si X-1<1 et Y-1 <1 then, et les 7 autres tests...

Maintenant le code est plus simple je fait une boucle de i=-1 to 1 et J=-1 to 1

et je test la cellule de coordonnées X +i, Y+i, au final 9 cellules sont testées, et pour celles qui sont hors jeu la gestion d'erreur permet de se rendre directement à la fin de l'instruction, du coup je passe de 8 tests systématiques à un certains nombres de gestion d'erreur qui arriveront moins souvent que le 8 systématiques.

L'autre "parade" est de joueur sur deux tableaux "grille" : une grille de référence qui contient la place des bombes ainsi que les valeurs numériques des cellules qui les entourent, comme cela lors des tests d'étendue, je n'ai plus besoin d'avoir recours à une procédure de compte de bombe pour afficher le numéro.

Une deuxième grille pour l'affichage du résultat sur la feuille Excel, ce tableau correspond au jeu du joueur.

Une fois l'étendue déterminée est "clôturée" alors il suffit de faire un "copier" de la grille affichage vers la feuille et toutes les données sont copiées dans les cellules...Hélas sur un tableau de 1500 colonnes et lignes il fallait à Excel environ 3 à 4 secondes pour faire cette recopie !

Du coup il m'est venu l'idée de ne copier sur la feuille que la partie de la grille "nouvellement modifiée" pour cela dans la procédure j'ai intégré 4 variables nouvelles Xmin, Xmax, Ymin et Ymax qui ont pour valeur les numéros mini et maxi de la zone "blanche" dans le tableau grille affichage ! Du coup la recopie sur la feuille est quasi instantanée car il n'y a pas les 1500x1500 cellules à copier !

Une MFC est mise en place sur la grille de jeu afin de mettre en couleur les différents chiffres, les cellules "blanches" qui sont violette (j'aime le violet, vous savez ), et l'absence de bordure sur ces dernières.

Il me reste à gérer la modification de police sur les cellules "bombes" afin de les afficher comme des bombes à mèches...

Hélas pour moi Wingdings n'a pas et les bombes et les chiffres ! Il faut donc que je modifie ceci sur la feuille.

Deux solutions : lors du placement des bombes, créer un objet range avec les différentes cellules de bombes calculées (trop long)

Lors du placement des bombes, modifier la police sur les cellules concernées, je penche pour cette solution.

Tout cela mis bout à bout fait que le jeu est plus fluide. Mais par rapport à l'autre code ce n'est pas grand chose mais je suis content de moi !

Alors il est vrai que sur une grille de 1500 x 1500 avec très peu de bombes, le code met malgré tout un peu beaucoup de temps pour faire apparaître le violet, mais à quoi bon une si grande grille avec si peu de bombes !

Voilà pour les dernières nouvelles, je vais de ce pas essayer de finir ce chasseur de bombes !

@ bientôt

LouReeD

Pourquoi tester si une feuille existe à chaque fois? juste le faire à l'ouverture n'est pas suffisant? après si le joueur renomme toute les feuilles en cours de route tant pis pour lui

Pour le check des cases autour en effet de faire une boucle de i=-1 to 1 et J=-1 to 1 je pense aussi

Par contre je ne vois pas en quoi une gestion d'erreur est nécessaire, l'instruction "exit for" sert exactement à faire ça nan? ou du coup il faut partir sur un while ^^

Je crois que je fais des tests dans le miens, je pourrais encore gagner du temps de traitement avec cette astuce au pire

Bizarre pour les 1500x1500 lignes recopié qui prennent du temps, tu passes bien par des tableaux?

Carrément faire des ranges serait vraiment trop long aie!

Le mieux est de modifier la police clairement ou directement de faire dans les MFC

Je suis impatient de voir ce que tu proposes d'autres comme option dans le jeu yeah! courage en tout cas

ECG

Bonsoir,

Pourquoi tester si une feuille existe à chaque fois?

C'est un exemple d'application où il y a ajout d'une feuille dont l'utilisateur choisi son nom, et donc dans le code pour éviter un message d'erreur il faut "gérer" ceci en vérifiant que le nom donné pour la création de la nouvelle feuille n'est pas déjà utilisé.

Par contre je ne vois pas en quoi une gestion d'erreur est nécessaire, l'instruction "exit for" sert exactement à faire ça nan?

Si la grille est représentée sous VBA par un tableau, une dimension de 20 colonnes sur 20 lignes, cela se représente par DIM Tableau(1 to 20, 1 to 20) où chaque "intersections" représente une cellule aux même coordonnées : cellule A1 en Tableau(1,1).

La gestion d'erreur vient au niveau du test des cellules autour de celle cliquée : si c'est en A1, alors la référence du tableau X-1 et Y-1 n'existe pas est engendre une erreur. Pour éviter cela j'avais mis en place 8 tests afin de m'assurer qu'il y avait bien une position "existante" dans le tableau pour faire le test de la cellule vide pour l'ajouter à la zone blanche... Mais avec la gestion d'erreur, plus de test, si ça passe c'est que la cellule existe dans le tableau, si ça passe pas alors le code continue...

Du coup moins de test et plus de rapidité !

Le mieux est de modifier la police clairement ou directement de faire dans les MFC

Dans les MFC en effet la liste des polices est visible mais chez moi elle est grisée, je n'arrive pas à les sélectionner ! Y a t il une astuce de ce coté ?

Car en effet la gestion des polices en directe "est simple" mais elle est lourde sur un gros tableau.

Je suis pour le moment "très" satisfait du code de blanchiment, mais avec cette histoire de police, la "construction" des grandes grilles est un peu longue...

@ bientôt

LouReeD

je viens de faire une boucle sur un classeur avec 30 feuilles, la macro est tellement rapide que quand je calcule le temps d’exécution avec 2 timers la différence vaut 0 donc j'avoue que le gain de temps me semble dérisoire surtout que l'on ne va pas demander au joueur de faire une nouvelle feuille tous les 3 matins nan? ^^

cela fait que 4 tests à faire nan? si X est >= mini et <= maxi et idem pour Y, pourquoi 8 tests?

En tout cas c'est une bonne idée dans le sens ou en effet cela va beaucoup plus vite (il fallait y penser! bien joué) mais je ne pense pas que ce soit une bonne pratique d'utiliser les gestions d'erreur de cette façon car s'il y a un souci lambda alors la macro peut faire n'importe quoi sans le signaler du coup ^^

Quand je verrais le code je comprendrais mieux surement

Je n'avais jamais testé plus que ça mais chez moi aussi au final c'est grisé! c'est emmerdant LOL

Bonsoir,

juste pour vous en téléchargement la version "sans cosmétique" du chasseur de bombes : Effacé par LouReeD

Attention le lien ne restera pas longtemps, donc merci de laisser un message dès qu'il sera téléchargé.

Sa taille n'est pas grande car j'ai enlevé des MFC qui prennent beaucoup de place, par contre avant de cliquer sur "Allons-y", il faut faire une copie de la cellule A1 sur la zone "visible" de la feuille à savoir A1:BER1500. En effet le code est prévu pour 1500 ligne et colonnes.

Il y a 10% de bombes par rapport à ce nombre de cases possibles.

Numérotation et mise en couleur du nombre de bombes adjacentes aux cellule, fond violet pour les zones blanches sans le quadrillage.

Il manque la gestion du clic droit, du score et l'emballage !

@ bientôt

LouReeD

je l'ai c'est bon

merci

Un exemple de "rapidité" par la gestion des erreurs :

Si le code de détermination des chiffres à coté des bombes suivant :

Tempo = Timer
For I = 1 To NB_Bombes
  For J = -1 To 1
    For k = -1 To 1
      ' test que la cellule testée (référence dans le tableau) existe
      If Bombes(1, I) + J > 0 And Bombes(1, I) + J <= Tx And Bombes(2, I) + k > 0 And Bombes(2, I) + k <= Ty Then
        ' test si numérique pour éviter une erreur
        If Grille(Bombes(1, I) + J, Bombes(2, I) + k) <> "B" Then
          Grille(Bombes(1, I) + J, Bombes(2, I) + k) = Grille(Bombes(1, I) + J, Bombes(2, I) + k) + 1
        End If
      End If
    Next k
  Next J
Next I
MsgBox (Timer - Tempo)

est modifié par celui ci-dessous :

    Tempo = Timer
    On Error Resume Next
    ' ici une gestion d'erreur afin de ne pas avoir à faire le test du "numérique" pour faire l'addition
    ' on fait l'addition et si c'est une erreur le code continue
    ' et on zappe également en cas de test "hors grille"
    For I = 1 To NB_Bombes
        For J = -1 To 1
            For k = -1 To 1
                Grille(Bombes(1, I) + J, Bombes(2, I) + k) = Grille(Bombes(1, I) + J, Bombes(2, I) + k) + 1
            Next k
        Next J
    Next I
    MsgBox (Timer - Tempo)

on passe d'environ de 4,5 à 5.2 secondes à de 2.20 à 2.4 secondes pour faire la même chose.

Suivant la disposition des bombes sur la grille on gagne de 2 à 3 secondes !

Alors sur une recherche de zone blanche où il y a énormément de teste avec mon principe de recherche, cela m'a permis de gagner beaucoup de temps.

C'est un exemple, il est vrai que celui des feuilles de classeurs est moins parlant...

Mais le principe est là, VBA détecte une erreur, on zappe l'erreur et on continue le code, cette erreur équivaut au résultat de plusieurs tests pour ne pas provoquer l'erreur, et ces tests cumulés ralentissent le code.

Voilà, alors ? Le code ? J'ai essayé de le simplifier au maximum, mais du coup pour une "accélération" j'ai du l'étoffé, comme la création d'un sous tableau pour l'affichage de la zone blanche calculée...

@ bientôt

LouReeD

L'idée d'utiliser les erreurs pour gagner du temps est vraiment très bonne sur la papier et le gain est très concret mais ce n'est pas une bonne pratique à avoir je dirais

Tout comme "normalement" les bonnes méthodologie pour utiliser une variable passe par des Get/Set mais je n'ai jamais vu une telle chose dans un code sur ce forum ^^

Quoi qu'il en soit c'est très tentant d'utiliser cette méthode pour gagner du temps en effet ou au moins voir ce que je pourrais gagner aussi de mon coté car je viens de regarder à nouveau mon code (j'ai déjà tout oublié de comment j'avais fait LOL) et je fais pas mal de check

Par contre quand on clique sur une case, mon code pour faire l'extension et le calcule de bombe (les commentaires sont peu être faux ou pas très compréhensif car je n'ai pas fait de mise à jour de ce coté la) :

'si on tombe sur une case vide alors on fait une extension
            If Sheets(SHEET_JEU).Cells(LIGNE, COLONNE).Value = 0 Then

                'pas de usedrange le usedrange car les Bombes ne sont pas placé forcément au bon endroit pour délimiter la zone
                Sheets(SHEET_PARAMETRE).Visible = True
                Sheets(SHEET_PARAMETRE).Select
                TABLEAU_GRILLE_PARAMETRE = Sheets(SHEET_PARAMETRE).Range(Cells(LIMITE_INF_LIGNE, LIMITE_INF_COL),     Cells(LIMITE_SUP_LIGNE, LIMITE_SUP_COL)).Value
                Sheets(SHEET_JEU).Select
                TABLEAU_GRILLE_JEU = Sheets(SHEET_JEU).Range(Cells(LIMITE_INF_LIGNE, LIMITE_INF_COL), Cells(LIMITE_SUP_LIGNE, LIMITE_SUP_COL)).Value
                ReDim TABLEAU_RESTANT_A_CHECKER(2, 1000000)

                'on reprend les valeurs pour être en ligne avec les tableaux
                LIGNE = LIGNE - LIMITE_INF_LIGNE + 1
                COLONNE = COLONNE - LIMITE_INF_COL + 1

                BALAYAGE_TABLEAU_RESTANT_A_CHECKER = 1
                BALAYAGE_CREATION_TABLEAU_RESTANT_A_CHECKER = 1

                'on entre la case en cours
                TABLEAU_RESTANT_A_CHECKER(1, BALAYAGE_TABLEAU_RESTANT_A_CHECKER) = LIGNE
                TABLEAU_RESTANT_A_CHECKER(2, BALAYAGE_TABLEAU_RESTANT_A_CHECKER) = COLONNE

                'tant qu'on aura pas regarder toute les cases en "cercle" concentrique et qu'elle ne seront pas vide alors on continue
                ' ???
                ' ?X?
                ' ???

                Do

                    'on reprend les coordonnées de la cellule à checker, pour la première itération c'est une opération inutile mais voulu
                    'car on va reprendre celle que l'on vient de renseigner juste avant
                    LIGNE_CLIQUE = TABLEAU_RESTANT_A_CHECKER(1, BALAYAGE_TABLEAU_RESTANT_A_CHECKER)
                    COLONNE_CLIQUE = TABLEAU_RESTANT_A_CHECKER(2, BALAYAGE_TABLEAU_RESTANT_A_CHECKER)

                    For BALAYAGE_LIGNE = -1 To 1
                        For BALAYAGE_COLONNE = -1 To 1

                            'si regarde la case qui si on est bien dans les limites de la grille
                            If (LIGNE_CLIQUE + BALAYAGE_LIGNE >= 1) And (LIGNE_CLIQUE + BALAYAGE_LIGNE <= UBound(TABLEAU_GRILLE_PARAMETRE(), 1)) And _
                            (COLONNE_CLIQUE + BALAYAGE_COLONNE >= 1) And (COLONNE_CLIQUE + BALAYAGE_COLONNE <= UBound(TABLEAU_GRILLE_PARAMETRE(), 2)) Then

                                'ligne  = 0 et col = 0 est la case en cours donc déja traité
                                'on vérifie que la case est bien vide pour ne pas retraiter une case déja prise en compte
                                If ((BALAYAGE_LIGNE = 0) And (BALAYAGE_COLONNE = 0)) Or _
                                    TABLEAU_GRILLE_PARAMETRE(LIGNE_CLIQUE + BALAYAGE_LIGNE, COLONNE_CLIQUE + BALAYAGE_COLONNE) <> "" Then

                                    'on ne fait rien
                                Else

                                        NB_BOMBE = 0
                                        For BALAYAGE_LIGNE_EXPENSION = -1 To 1
                                            For BALAYAGE_COLONNE_EXPENSION = -1 To 1

                                                'si regarde la case qui si on est bien dans les limites de la grille
                                                If (LIGNE_CLIQUE + BALAYAGE_LIGNE + BALAYAGE_LIGNE_EXPENSION >= 1) And (LIGNE_CLIQUE + BALAYAGE_LIGNE + BALAYAGE_LIGNE_EXPENSION <= UBound(TABLEAU_GRILLE_PARAMETRE(), 1)) And _
                                                (COLONNE_CLIQUE + BALAYAGE_COLONNE + BALAYAGE_COLONNE_EXPENSION >= 1) And (COLONNE_CLIQUE + BALAYAGE_COLONNE + BALAYAGE_COLONNE_EXPENSION <= UBound(TABLEAU_GRILLE_PARAMETRE(), 2)) Then

                                                        'si c'est une bombe on le prends en compte
                                                        If TABLEAU_GRILLE_PARAMETRE(LIGNE_CLIQUE + BALAYAGE_LIGNE + BALAYAGE_LIGNE_EXPENSION, COLONNE_CLIQUE + BALAYAGE_COLONNE + BALAYAGE_COLONNE_EXPENSION) = "X" Then
                                                            NB_BOMBE = NB_BOMBE + 1
                                                        End If

                                                End If

                                            Next
                                        Next

                                        'on renseigner les 2 tableaux, parametre comme quoi la case est checké avec un C et la valeur de la bombe en jeu
                                        TABLEAU_GRILLE_PARAMETRE(LIGNE_CLIQUE + BALAYAGE_LIGNE, COLONNE_CLIQUE + BALAYAGE_COLONNE) = "C"

                                        'le joueur ne voit pas 0 mais une case vide par choix
                                        If NB_BOMBE = 0 Then
                                            TABLEAU_GRILLE_JEU(LIGNE_CLIQUE + BALAYAGE_LIGNE, COLONNE_CLIQUE + BALAYAGE_COLONNE) = 0
                                            'on décale d'une ligne pour reprendre la case à checker
                                            BALAYAGE_CREATION_TABLEAU_RESTANT_A_CHECKER = BALAYAGE_CREATION_TABLEAU_RESTANT_A_CHECKER + 1
                                            TABLEAU_RESTANT_A_CHECKER(1, BALAYAGE_CREATION_TABLEAU_RESTANT_A_CHECKER) = LIGNE_CLIQUE + BALAYAGE_LIGNE
                                            TABLEAU_RESTANT_A_CHECKER(2, BALAYAGE_CREATION_TABLEAU_RESTANT_A_CHECKER) = COLONNE_CLIQUE + BALAYAGE_COLONNE
                                        Else
                                            TABLEAU_GRILLE_JEU(LIGNE_CLIQUE + BALAYAGE_LIGNE, COLONNE_CLIQUE + BALAYAGE_COLONNE) = NB_BOMBE
                                        End If
                                End If
                            End If
                        Next
                    Next

                    'on va voir la prochaine ligne du tableau à tester
                    BALAYAGE_TABLEAU_RESTANT_A_CHECKER = BALAYAGE_TABLEAU_RESTANT_A_CHECKER + 1

                'tant qu'on a renseigner des nouvelles case vide à expendre alors on continue
                Loop Until BALAYAGE_TABLEAU_RESTANT_A_CHECKER > BALAYAGE_CREATION_TABLEAU_RESTANT_A_CHECKER

                'on recopie les tableaux sur les feuilles
                Sheets(SHEET_PARAMETRE).Select
                Sheets(SHEET_PARAMETRE).Range(Cells(LIMITE_INF_LIGNE, LIMITE_INF_COL), Cells(LIMITE_SUP_LIGNE, LIMITE_SUP_COL)).Value = TABLEAU_GRILLE_PARAMETRE

                Sheets(SHEET_JEU).Select
                Sheets(SHEET_JEU).Range(Cells(LIMITE_INF_LIGNE, LIMITE_INF_COL), Cells(LIMITE_SUP_LIGNE, LIMITE_SUP_COL)).Value = TABLEAU_GRILLE_JEU

            End If

Bonjour,

sur le papier cela fonctionne de faire les test par la gestion d'erreur, mais comme cela est indiqué il faut "gérer" cette gestion et de savoir quand l'utiliser. Dans mon cas le risque d'erreur et le fait de "sortir" du tableau pour les test ou bien de faire une addition entre un M et un chiffre, le risque est donc limité

Pour ce qui est de votre code, j'ai du mal à percevoir le fonctionnement, je vois bien les -1 to +1 x2 pour scanner les cellules adjacentes à celles cliquée, mais pour le reste, l'histoire des tableaux...

Tout comme "normalement" les bonnes méthodologie

N'y a t il pas trop de Select dans votre code ? Cela est gourmant en temps... Et je ne pense pas qu'il soit utile de "montrer" une feuille pour écrire dessus tout comme pour la lire.

Le Select sous VBA est très superflue si ce n'est pour réellement sélectionner une cellule et rendre la main à l'utilisateur dans une configuration particulière...

@ bientôt

LouReeD

Je fais 2 select au début de la macro et 2 à la fin en effet mais de toute façon sous un Application.ScreenUpdating =False cela ne se voit pas du tout et prends beaucoup moins de temps

Mais surtout sur ma version, Excel ne me permet pas de faire un .range sur une feuille qui n'est pas sélectionné sinon j'ai l’erreur

Erreur d'éxécution '1004': Erreur définie par l'application ou par l'objet

d’où les .select

Et pour écrire dessus vu qu'elles sont cachés en .veryhidden en plus il faut que je les rendent visible à chaque fois que le joueur clique sinon on ne peut pas y accéder et forcément que je refassent en veryhidden à la fin, du moins j'ai choisi cette solution technique et malgré tout cela le temps de calcule reste correcte donc j'ai pas cherché plus loin faut avouer ^^

Pour faire simple je passe tout simplement par des tableaux car je calcule à la volée le nombre de bombe autour d'une case et comme tu le sais, c'est plus rapide que de calculer sur les feuilles.

Je redim une fois pour toute au début de la macro un TABLEAU_RESTANT_A_CHECKER(2, 1000000), car au maximum en 1000x1000 on aura en gros au max ce nombre de case "blanche à traiter" (bon techniquement -2 car j'ai au mini 2 bombes sur ma grilles mais bon)

Par contre cela prends genre quand même 0.5-1 seconde à excel pour la créer à chaque fois mais encore une fois c'est un choix technique plutôt que de le redimensionner à la volée ou de le garder "en vie" et de le nettoyer avant chaque réutilisation.

Puis en gros je regarde tout autour de la case blanche, si je tombe sur une case non découverte par le joueur alors je calcule et j'y inscrit le nombre de bombe autour, s'il y a 0 bombes alors je stock la case dans mon TABLEAU_RESTANT_A_CHECKER

Puis comme tu imagines bien je fais la même chose pour chaque case répertorié dans ce Tableau

La façon de la construction de ce tableau m'assure que je ne prendrais jamais en compte plusieurs fois une case

Pareil de la même façon c'est une feature au final MUST HAVE sur des grilles 1500x1500, après chaque clique il faut scanner (ou juste une formule excel surement possible) toute la grille pour vérifier si le joueur à trouver toute les cases "blanches" et si c'est le cas alors il gagne instantanément.

En effet si on part sur une grille 1500x1500 avec 2 249 980 bombes soit 10 cases blanches et qu'au hasard de la construction en 2 cliques le joueur découvres ces 10 cases blanches .... il ne faudrait pas qu'il ai à faire 2 249 980 cliques droits pour "identifier" toutes les bombes et gagner !

Bonsoir @ tous !

Bon je prend mon temps pour le sortir ce "Démineur" !

Grâce à ExcelCoreGame, je suis arrivé à descendre aux alentour des 13 secondes pour un clic sur une zone "blanche" pour une grille de 1000 x 1000 avec 66 666 bombes !

Comment ? En reprenant son idée de tableau "déjà" dimensionné au maximum ce qui évite le ralentissement de mon code avec les "ReDim Preserve" qu'il y avait "à chaque tour" !

Merci à lui.

Pour ce qui est du "Skin", je suis parti sur une nouvelle idée qui me rapproche encore un peu plus de l'original : le forme des "briques", en effet maintenant elles ressemblent vraiment à des boutons !

Pour le reste, je reste sur l'idée du USF Modal 0 qui permet d'avoir une zone de jeu maximum par la suppression d'une zone de menu, et le fait de mettre m'application en "maxi grand écran" ! Et toujours l'affichage des chiffres en couleur, par contre j'ai abandonné l'idée de la police "Wingdings" pour l'affichage des bombes et têtes de mort... Cela ralenti trop l'affichage de fin de jeu, mais qui sait, avec un message "d'avertissement" il pourrait y avoir une version de cette forme...

Voici donc une nouvelle capture d'écran :

apercu

Il me reste à ajouter la gestion du temps et du classement des meilleurs scores.

Donc cela ne devrait pas durer longtemps ! Enfin j'espère !

@ bientôt

LouReeD

Rechercher des sujets similaires à "chasseur bombes"