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
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
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,
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é.Pourquoi tester si une feuille existe à chaque fois?
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).Par contre je ne vois pas en quoi une gestion d'erreur est nécessaire, l'instruction "exit for" sert exactement à faire ça nan?
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é !
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é ?Le mieux est de modifier la police clairement ou directement de faire dans les MFC
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...
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.Tout comme "normalement" les bonnes méthodologie
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
d’où les .selectErreur d'éxécution '1004': Erreur définie par l'application ou par l'objet
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 :
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