Créer et afficher un quadrillage

Je constate que le linotte met beaucoup de temps à créer et afficher un quadrillage, par exemple de 25x 25 cases, de taille 32 x 32.
J'ai créer un système de scrolling afin de pouvoir créer un quadrillage de 100 x 100 mais d'en afficher les cases que par 10 x 10.
En appuyant sur les flèches du clavier, on peut donc faire défiler toutes les cases du quadrillage.
Malgré ça, le temps mis pour créer et afficher mon quadrillage est beaucoup trop long.

Voici comment je créer un quadrillage, de manière générale :
[php]
Affichage_quadrillage :
Rôles :
§ case est un monrectangle, couleur vaut "blanc", hauteur vaut taille_hauteur_case, largeur vaut taille_largeur_case, position vaut 1, plein vaut "oui"
§ contour_case est un rectangle, couleur vaut "noir", hauteur vaut taille_hauteur_case, largeur vaut taille_largeur_case, position vaut 100, plein vaut "non"
xx est un nombre <
- (((largeur de fond - largeur de bordure_gauche) - (nombre_case_largeur_effectif * taille_largeur_case))/2) + largeur de bordure_gauche
yy est un nombre <
- (hauteur de fond - (nombre_case_hauteur_effectif * taille_hauteur_case))/2
Actions :
("ici on dessine des cases pleines")
pour chaque nombre_case, lis
ajoute #case dans grille4
déplace grille4{joker} vers xx et yy
projette grille4{joker}
incrémente index
xx = xx + taille_largeur_case
si xx est plus grand que largeur de bordure_gauche + (nombre_case_largeur_effectif * taille_largeur_case) + (((largeur de fond - largeur de bordure_gauche) - (nombre_case_largeur_effectif * taille_largeur_case))/2) - taille_largeur_case alors lis
xx = (((largeur de fond - largeur de bordure_gauche) - (nombre_case_largeur_effectif * taille_largeur_case))/2) + largeur de bordure_gauche
yy = yy + taille_hauteur_case
index = index + nombre_case_largeur_attente
ferme
si yy est plus grand que (((hauteur de fond - (nombre_case_hauteur_effectif * taille_hauteur_case))/2) + (nombre_case_hauteur_effectif * taille_hauteur_case)) - taille_hauteur_case alors lis
yy = (hauteur de fond - (nombre_case_hauteur_effectif * taille_hauteur_case))/2
ferme
ferme
xx = (((largeur de fond - largeur de bordure_gauche) - (nombre_case_largeur_effectif * taille_largeur_case))/2) + largeur de bordure_gauche
yy = (hauteur de fond - (nombre_case_hauteur_effectif * taille_hauteur_case))/2

("ici on dessine le contour des cases")
pour chaque nombre_case, lis
ajoute #contour_case dans grille5
déplace grille5{joker} vers xx et yy
Projette grille5{joker}
xx = xx + taille_largeur_case
si xx est plus grand que largeur de bordure_gauche + (nombre_case_largeur_effectif * taille_largeur_case) + (((largeur de fond - largeur de bordure_gauche) - (nombre_case_largeur_effectif * taille_largeur_case))/2) - taille_largeur_case alors lis
xx = (((largeur de fond - largeur de bordure_gauche) - (nombre_case_largeur_effectif * taille_largeur_case))/2) + largeur de bordure_gauche
yy = yy + taille_hauteur_case
ferme
si yy est plus grand que (((hauteur de fond - (nombre_case_hauteur_effectif * taille_hauteur_case))/2) + (nombre_case_hauteur_effectif * taille_hauteur_case)) - taille_hauteur_case alors lis
yy = (hauteur de fond - (nombre_case_hauteur_effectif * taille_hauteur_case))/2
ferme
ferme
[/php]

Des solutions ?

Edit :

Créer et afficher des quadrillages ralenti :
- un peu l'atelier
- énormément l'inspecteur
- énormément le lancement d'un livre

Si bien qu'au bout de 3 essais de mon programme, je suis obligé de redémarrer l'atelier.

Wam,

Peux-tu me faire un livre qui s'exécute et affiche ta grille que je puisse analyser ?

En faisant ceci, il n'y a pas de problèmes :
- la création du quadrillage est rapide
- il n'y a pas de ralentissements de l'atelier

[php]
Editeur de cartes :

Grands rôles :
("Fenêtre principale")
Fenêtre_principale est un formulaire, hauteur vaut 828, largeur vaut 1600, titre vaut "Editeur de cartes"

("Fenêtre nouveau quadrillage")
Fenêtre_nouveau_quadrillage est un formulaire, hauteur vaut 140, largeur vaut 300, titre vaut "Nouveau quadrillage", visible vaut "non", x vaut 450, y vaut 255
txt_Fnq1 est une étiquette, texte vaut "Nombre de cases en largeur :", x vaut 10, y vaut 10
txt_Fnq2 est une étiquette, texte vaut "Nombre de cases en hauteur :", x vaut 10, y vaut 30
txt_Fnq3 est une étiquette, texte vaut "Largeur des cases :", x vaut 10, y vaut 50
txt_Fnq4 est une étiquette, texte vaut "Hauteur des cases :", x vaut 10, y vaut 70
choix_case_largeur est un sélecteur, valeurs vaut "", x vaut 200, y vaut 10
choix_case_hauteur est un sélecteur, valeurs vaut "", x vaut 200, y vaut 30
choix_taille_largeur_case est un sélecteur, valeurs vaut "", x vaut 200, y vaut 50
choix_taille_hauteur_case est un sélecteur, valeurs vaut "", x vaut 200, y vaut 70
bouton_valider_Fnq est un bouton, texte vaut "Valider", x vaut 70, y vaut 110
bouton_annuler_Fnq est un bouton, texte vaut "Annuler", x vaut 160, y vaut 110

("Menus")
menu2 est un menu, texte vaut "Carte"
menu2s1 est un sousmenu, texte vaut "Nouveau quadrillage"

("Toile")
fond est une toile, hauteur vaut 800, largeur vaut 1600, couleur vaut "blanc", pointeur vaut "flèche"
xtoile est une xtoile, x vaut 0, y vaut 0
bordure_gauche est un rectangle, x = 0, y = 0, position vaut 1, hauteur vaut hauteur de fond, largeur vaut 150, plein vaut "oui", couleur vaut "blanc"

("Quadrillage")
taille_largeur_case est un nombre
taille_hauteur_case est un nombre
nombre_case_largeur est un nombre
nombre_case_hauteur est un nombre
nombre_case_largeur_effectif est un nombre
nombre_case_hauteur_effectif est un nombre
nombre_case est un nombre

grille4 est un casier de rectangle
grille5 est un casier de rectangle

Fenêtre_principale :
Rôles :
Actions :
("Construction des fenêtres")
Tu ajoutes txt_Fnq1 & txt_Fnq2 & txt_Fnq3 & txt_Fnq4 & choix_case_largeur & choix_case_hauteur & choix_taille_largeur_case & choix_taille_hauteur_case & bouton_valider_Fnq & bouton_annuler_Fnq dans Fenêtre_nouveau_quadrillage
Tu fais réagir Fenêtre_nouveau_quadrillage à "clic souris" pour Fermer_fenêtre_nouveau_quadrillage
Tu fais réagir bouton_annuler_Fnq à "clic souris" pour Fermer_fenêtre_nouveau_quadrillage
Tu fais réagir bouton_valider_Fnq à "clic souris" pour Générer_quadrillage

("Début du programme")

Tu ajoutes xtoile dans Fenêtre_principale
visible de Fenêtre_principale vaut "oui"
Tu ajoutes menu2 dans Fenêtre_principale
Tu ajoutes menu2s1 dans menu2
Tu fais réagir Fenêtre_principale à "clic souris" pour Fermer_fenêtre_principale
Tu fais réagir menu2s1 à "clic souris" pour Fenêtre_nouveau_quadrillage
Tu fais réagir menu2s1 à "clic souris" pour Affichage_toile

tant que 1 est différent de 2, lis
temporise
ferme

Fenêtre_nouveau_quadrillage :
Rôles :
§ i est un nombre
Actions :
visible de Fenêtre_nouveau_quadrillage vaut "oui"

Pour i de 1 à 100, lis
Tu ajoutes i +"|" dans valeurs@choix_case_largeur
Tu ajoutes i +"|" dans valeurs@choix_case_hauteur
Tu ajoutes i +"|" dans valeurs@choix_taille_largeur_case
Tu ajoutes i +"|" dans valeurs@choix_taille_hauteur_case
Tu fermes

Fermer_fenêtre_principale :
Rôles :
*f :: formulaire
Actions :
Efface la toile
Tu termines

Fermer_fenêtre_nouveau_quadrillage :
Rôles :
Actions :
visible de Fenêtre_nouveau_quadrillage vaut "non"
Tu reviens

Affichage_toile :
Rôles :
Actions :
Efface la toile
Projette le fond & bordure_gauche

Tant que vrai, lis
Temporise
Ferme

Générer_quadrillage :
Rôles :
§ valeur1 est un texte
§ valeur2 est un texte
§ valeur3 est un texte
§ valeur4 est un texte
Actions :
valeur1 = valeur@choix_case_largeur
Tu convertis valeur1 en nombre_case_largeur
valeur2 = valeur@choix_case_hauteur
Tu convertis valeur2 en nombre_case_hauteur
valeur3 = valeur@choix_taille_largeur_case
Tu convertis valeur3 en taille_largeur_case
valeur4 = valeur@choix_taille_hauteur_case
Tu convertis valeur4 en taille_hauteur_case

nombre_case_largeur_effectif = entier ((largeur de fond - largeur de bordure_gauche) / taille_largeur_case)
nombre_case_hauteur_effectif = entier (hauteur de fond / taille_hauteur_case)
Si nombre_case_largeur_effectif >
nombre_case_largeur alors nombre_case_largeur_effectif = nombre_case_largeur
Si nombre_case_hauteur_effectif >
nombre_case_hauteur alors nombre_case_hauteur_effectif = nombre_case_hauteur
nombre_case = nombre_case_hauteur_effectif*nombre_case_largeur_effectif

visible de Fenêtre_nouveau_quadrillage vaut "non"

Tu vas vers Affichage_quadrillage

Affichage_quadrillage :
Rôles :
§ case est un rectangle, couleur vaut "blanc", hauteur vaut taille_hauteur_case, largeur vaut taille_largeur_case, position vaut 1, plein vaut "oui"
§ contour_case est un rectangle, couleur vaut "noir", hauteur vaut taille_hauteur_case, largeur vaut taille_largeur_case, position vaut 100, plein vaut "non"
xx est un nombre <
- (((largeur de fond - largeur de bordure_gauche) - (nombre_case_largeur_effectif * taille_largeur_case))/2) + largeur de bordure_gauche
yy est un nombre <
- (hauteur de fond - (nombre_case_hauteur_effectif * taille_hauteur_case))/2
Actions :
("ici on dessine des cases pleines")
pour chaque nombre_case, lis
ajoute #case dans grille4
déplace grille4{joker} vers xx et yy
projette grille4{joker}
xx = xx + taille_largeur_case
si xx est plus grand que largeur de bordure_gauche + (nombre_case_largeur_effectif * taille_largeur_case) + (((largeur de fond - largeur de bordure_gauche) - (nombre_case_largeur_effectif * taille_largeur_case))/2) - taille_largeur_case alors lis
xx = (((largeur de fond - largeur de bordure_gauche) - (nombre_case_largeur_effectif * taille_largeur_case))/2) + largeur de bordure_gauche
yy = yy + taille_hauteur_case
ferme
si yy est plus grand que (((hauteur de fond - (nombre_case_hauteur_effectif * taille_hauteur_case))/2) + (nombre_case_hauteur_effectif * taille_hauteur_case)) - taille_hauteur_case alors lis
yy = (hauteur de fond - (nombre_case_hauteur_effectif * taille_hauteur_case))/2
ferme
ferme
xx = (((largeur de fond - largeur de bordure_gauche) - (nombre_case_largeur_effectif * taille_largeur_case))/2) + largeur de bordure_gauche
yy = (hauteur de fond - (nombre_case_hauteur_effectif * taille_hauteur_case))/2

("ici on dessine le contour des cases")
pour chaque nombre_case, lis
ajoute #contour_case dans grille5
déplace grille5{joker} vers xx et yy
Projette grille5{joker}
xx = xx + taille_largeur_case
si xx est plus grand que largeur de bordure_gauche + (nombre_case_largeur_effectif * taille_largeur_case) + (((largeur de fond - largeur de bordure_gauche) - (nombre_case_largeur_effectif * taille_largeur_case))/2) - taille_largeur_case alors lis
xx = (((largeur de fond - largeur de bordure_gauche) - (nombre_case_largeur_effectif * taille_largeur_case))/2) + largeur de bordure_gauche
yy = yy + taille_hauteur_case
ferme
si yy est plus grand que (((hauteur de fond - (nombre_case_hauteur_effectif * taille_hauteur_case))/2) + (nombre_case_hauteur_effectif * taille_hauteur_case)) - taille_hauteur_case alors lis
yy = (hauteur de fond - (nombre_case_hauteur_effectif * taille_hauteur_case))/2
ferme
ferme
[/php]

C'est donc mon système de scrolling qui pose problème.
Voici mon code :

[php]
Editeur de cartes :

Grands rôles :
("Fenêtre principale")
Fenêtre_principale est un formulaire, hauteur vaut 800, largeur vaut 1400, titre vaut "Editeur de cartes"

("Fenêtre nouveau quadrillage")
Fenêtre_nouveau_quadrillage est un formulaire, hauteur vaut 140, largeur vaut 300, titre vaut "Nouveau quadrillage", visible vaut "non", x vaut 450, y vaut 255
txt_Fnq1 est une étiquette, texte vaut "Nombre de cases en largeur :", x vaut 10, y vaut 10
txt_Fnq2 est une étiquette, texte vaut "Nombre de cases en hauteur :", x vaut 10, y vaut 30
txt_Fnq3 est une étiquette, texte vaut "Largeur des cases :", x vaut 10, y vaut 50
txt_Fnq4 est une étiquette, texte vaut "Hauteur des cases :", x vaut 10, y vaut 70
choix_case_largeur est un sélecteur, valeurs vaut "", x vaut 200, y vaut 10
choix_case_hauteur est un sélecteur, valeurs vaut "", x vaut 200, y vaut 30
choix_taille_largeur_case est un sélecteur, valeurs vaut "", x vaut 200, y vaut 50
choix_taille_hauteur_case est un sélecteur, valeurs vaut "", x vaut 200, y vaut 70
bouton_valider_Fnq est un bouton, texte vaut "Valider", x vaut 70, y vaut 110
bouton_annuler_Fnq est un bouton, texte vaut "Annuler", x vaut 160, y vaut 110

("Menus")
menu2 est un menu, texte vaut "Carte"
menu2s1 est un sousmenu, texte vaut "Nouveau quadrillage"

("Toile")
fond est une toile, hauteur vaut 800, largeur vaut 1400, couleur vaut "blanc", pointeur vaut "flèche"
xtoile est une xtoile, x vaut 0, y vaut 0
bordure_gauche est un rectangle, x = 0, y = 0, position vaut 1, hauteur vaut hauteur de fond, largeur vaut 150, plein vaut "oui", couleur vaut "blanc"

("Fenêtre de scrolling")
cadre est un rectangle, couleur vaut "blanc", hauteur vaut 330, largeur vaut 330, position vaut 1, plein vaut "non", x = 0, y = 0
indice_horizontal est un nombre <
- 0
indice_vertical est un nombre <
- 0

("Quadrillage")
taille_largeur_case est un nombre
taille_hauteur_case est un nombre
nombre_case_largeur est un nombre
nombre_case_hauteur est un nombre
nombre_case_largeur_effectif est un nombre
nombre_case_hauteur_effectif est un nombre
nombre_case est un nombre

grille4 est un casier de rectangle
grille5 est un casier de rectangle
carte est un casier de nombre

Fenêtre_principale :
Rôles :
Actions :
("Construction des fenêtres")
Tu ajoutes txt_Fnq1 & txt_Fnq2 & txt_Fnq3 & txt_Fnq4 & choix_case_largeur & choix_case_hauteur & choix_taille_largeur_case & choix_taille_hauteur_case & bouton_valider_Fnq & bouton_annuler_Fnq dans Fenêtre_nouveau_quadrillage
Tu fais réagir Fenêtre_nouveau_quadrillage à "clic souris" pour Fermer_fenêtre_nouveau_quadrillage
Tu fais réagir bouton_annuler_Fnq à "clic souris" pour Fermer_fenêtre_nouveau_quadrillage
Tu fais réagir bouton_valider_Fnq à "clic souris" pour Générer_quadrillage

("Début du programme")

Tu ajoutes xtoile dans Fenêtre_principale
visible de Fenêtre_principale vaut "oui"
Tu ajoutes menu2 dans Fenêtre_principale
Tu ajoutes menu2s1 dans menu2
Tu fais réagir Fenêtre_principale à "clic souris" pour Fermer_fenêtre_principale
Tu fais réagir menu2s1 à "clic souris" pour Affichage_toile
Tu fais réagir menu2s1 à "clic souris" pour Fenêtre_nouveau_quadrillage

tant que 1 est différent de 2, lis
temporise
ferme

Fenêtre_nouveau_quadrillage :
Rôles :
§ i est un nombre
Actions :
visible de Fenêtre_nouveau_quadrillage vaut "oui"

Pour i de 1 à 100, lis
Tu ajoutes i +"|" dans valeurs@choix_case_largeur
Tu ajoutes i +"|" dans valeurs@choix_case_hauteur
Tu ajoutes i +"|" dans valeurs@choix_taille_largeur_case
Tu ajoutes i +"|" dans valeurs@choix_taille_hauteur_case
Tu fermes

Fermer_fenêtre_principale :
Rôles :
*f :: formulaire
Actions :
Efface la toile
Tu termines

Fermer_fenêtre_nouveau_quadrillage :
Rôles :
Actions :
visible de Fenêtre_nouveau_quadrillage vaut "non"
Tu reviens

Affichage_toile :
Rôles :
Actions :
Efface la toile
Projette le fond & bordure_gauche

Tant que vrai, lis
Temporise
Ferme

Générer_quadrillage :
Rôles :
§ valeur1 est un texte
§ valeur2 est un texte
§ valeur3 est un texte
§ valeur4 est un texte
Actions :
valeur1 = valeur@choix_case_largeur
Tu convertis valeur1 en nombre_case_largeur
valeur2 = valeur@choix_case_hauteur
Tu convertis valeur2 en nombre_case_hauteur
valeur3 = valeur@choix_taille_largeur_case
Tu convertis valeur3 en taille_largeur_case
valeur4 = valeur@choix_taille_hauteur_case
Tu convertis valeur4 en taille_hauteur_case

nombre_case = nombre_case_hauteur*nombre_case_largeur

("on calcule le nombre de cases à afficher en fonction des dimensions de la fenêtre de scrolling")
nombre_case_largeur_effectif = entier (largeur de cadre / taille_largeur_case)
nombre_case_hauteur_effectif = entier (hauteur de cadre / taille_hauteur_case)
Si nombre_case_largeur_effectif >
nombre_case_largeur alors nombre_case_largeur_effectif = nombre_case_largeur
Si nombre_case_hauteur_effectif >
nombre_case_hauteur alors nombre_case_hauteur_effectif = nombre_case_hauteur

visible de Fenêtre_nouveau_quadrillage vaut "non"

Tu vas vers Création_quadrillage

Création_quadrillage :
Rôles :
§ case est un rectangle, couleur vaut "blanc", hauteur vaut taille_hauteur_case, largeur vaut taille_largeur_case, position vaut 1, plein vaut "oui"
§ contour_case est un rectangle, couleur vaut "noir", hauteur vaut taille_hauteur_case, largeur vaut taille_largeur_case, position vaut 100, plein vaut "non"
Actions :
("ici on créer des cases pleines")
pour chaque nombre_case, lis
ajoute #case dans grille4
ferme

("ici on créer le contour des cases")
pour chaque nombre_case, lis
ajoute #contour_case dans grille5
ferme

("ici on indique que le quadrillage est vide")
pour chaque nombre_case, lis
ajoute 0 dans carte
ferme

Va vers Affichage_quadrillage

Affichage_quadrillage :
Rôles :
§ x_case_min est un nombre <
- x de cadre / taille_largeur_case
§ y_case_min est un nombre <
- y de cadre / taille_hauteur_case
§ x_case_max est un nombre
§ y_case_max est un nombre
§ numéro_case_grille est un nombre
§ i est un nombre
§ j est un nombre
xx est un nombre <
- (((largeur de fond - largeur de bordure_gauche) - (nombre_case_largeur_effectif * taille_largeur_case))/2) + largeur de bordure_gauche
yy est un nombre <
- (hauteur de fond - (nombre_case_hauteur_effectif * taille_hauteur_case))/2
§ pos_x est un nombre
§ pos_y est un nombre
Actions :
("ici on calcule le numéro des cases de la grille4 à afficher, en fonction de la position de la fenêtre de scrolling")
x_case_min = x_case_min + (y_case_min * nombre_case_largeur)
y_case_min = (y_case_min * nombre_case_largeur) + (x de cadre / taille_largeur_case)
x_case_max = x_case_min + (nombre_case_largeur_effectif - 1)
y_case_max = y_case_min + ((nombre_case_hauteur_effectif - 1) * nombre_case_largeur)

("ici on dessine des cases pleines")
Pour i de y_case_min à y_case_max suivant i + nombre_case_largeur, lis
Pour j de x_case_min à x_case_max, lis
numéro_case_grille = i + j - ((y de cadre / taille_hauteur_case) * nombre_case_largeur) - (x de cadre / taille_largeur_case)
déplace grille4{numéro_case_grille} vers xx et yy
projette grille4{numéro_case_grille}
xx = xx + taille_largeur_case
si xx est plus grand que largeur de bordure_gauche + (nombre_case_largeur_effectif * taille_largeur_case) + (((largeur de fond - largeur de bordure_gauche) - (nombre_case_largeur_effectif * taille_largeur_case))/2) - taille_largeur_case alors lis
xx = (((largeur de fond - largeur de bordure_gauche) - (nombre_case_largeur_effectif * taille_largeur_case))/2) + largeur de bordure_gauche
yy = yy + taille_hauteur_case
ferme
si yy est plus grand que (((hauteur de fond - (nombre_case_hauteur_effectif * taille_hauteur_case))/2) + (nombre_case_hauteur_effectif * taille_hauteur_case)) - taille_hauteur_case alors lis
yy = (hauteur de fond - (nombre_case_hauteur_effectif * taille_hauteur_case))/2
ferme
ferme
ferme
xx = (((largeur de fond - largeur de bordure_gauche) - (nombre_case_largeur_effectif * taille_largeur_case))/2) + largeur de bordure_gauche
yy = (hauteur de fond - (nombre_case_hauteur_effectif * taille_hauteur_case))/2

("ici on dessine le contour des cases")
Pour i de y_case_min à y_case_max suivant i+nombre_case_largeur, lis
Pour j de x_case_min à x_case_max, lis
numéro_case_grille = i + j - ((y de cadre / taille_hauteur_case) * nombre_case_largeur) - (x de cadre / taille_largeur_case)
déplace grille5{numéro_case_grille} vers xx et yy
projette grille5{numéro_case_grille}
xx = xx + taille_largeur_case
si xx est plus grand que largeur de bordure_gauche + (nombre_case_largeur_effectif * taille_largeur_case) + (((largeur de fond - largeur de bordure_gauche) - (nombre_case_largeur_effectif * taille_largeur_case))/2) - taille_largeur_case alors lis
xx = (((largeur de fond - largeur de bordure_gauche) - (nombre_case_largeur_effectif * taille_largeur_case))/2) + largeur de bordure_gauche
yy = yy + taille_hauteur_case
ferme
si yy est plus grand que (((hauteur de fond - (nombre_case_hauteur_effectif * taille_hauteur_case))/2) + (nombre_case_hauteur_effectif * taille_hauteur_case)) - taille_hauteur_case alors lis
yy = (hauteur de fond - (nombre_case_hauteur_effectif * taille_hauteur_case))/2
ferme
ferme
ferme

Va vers Attente_clavier2

Attente_clavier2 :
Rôles :
clavier :: clavier
§i est un nombre
Actions :
évoque clavier.commencer()
tant que vrai, lis
attends 100 millisecondes
parcours Scrolling avec clavier.touches(), clavier
ferme

Scrolling :
Rôles :
*liste :: casier de nombre
*clavier :: clavier
Actions :
Si liste est non vide alors lis
Pour chaque liste, lis
Si joker == "Droite" alors lis
si indice_horizontal <
(nombre_case_largeur - nombre_case_largeur_effectif) alors lis
"droite" !
déplace cadre vers la droite de taille_largeur_case
incrémente indice_horizontal
évoque clavier.stop()
va vers Affichage_quadrillage
ferme
ferme
Sinon si joker == "Gauche" alors lis
si indice_horizontal >
0 alors lis
"gauche" !
déplace cadre vers la gauche de taille_largeur_case
décrémente indice_horizontal
évoque clavier.stop()
va vers Affichage_quadrillage
ferme
ferme
Sinon si joker == "Haut" alors lis
si indice_vertical >
0 alors lis
"haut" !
déplace cadre vers le haut de taille_hauteur_case
décrémente indice_vertical
évoque clavier.stop()
va vers Affichage_quadrillage
ferme
ferme
Sinon si joker == "Bas" alors lis
si indice_vertical <
(nombre_case_hauteur - nombre_case_hauteur_effectif) alors lis
"Bas" !
déplace cadre vers le bas de taille_hauteur_case
incrémente indice_vertical
évoque clavier.stop()
va vers Affichage_quadrillage
ferme
ferme
ferme
ferme
Reviens
[/php]

J'ai voulu séparer la création des cases de leur affichage, me permettant ainsi de créer mon quadrillage en entier et d'en afficher qu'une partie.

Cependant, cette façon de faire se révèle beaucoup plus lente que celle au-dessus.
De plus, elle ralenti énormément l'inspecteur et la lecture des livres.

Comment puis-je faire pour réparer ça ?

Bonjour,
Après quelques test il s'avère que c'est la création des cases qui pose ce problème de ralentissement.
Vouloir séparer la création des cases de leur affichage se révèle donc inutile.

Ainsi, si je reprend mon premier code :
[php]
Editeur de cartes :

Grands rôles :
("Fenêtre principale")
Fenêtre_principale est un formulaire, hauteur vaut 828, largeur vaut 1600, titre vaut "Editeur de cartes"

("Fenêtre nouveau quadrillage")
Fenêtre_nouveau_quadrillage est un formulaire, hauteur vaut 140, largeur vaut 300, titre vaut "Nouveau quadrillage", visible vaut "non", x vaut 450, y vaut 255
txt_Fnq1 est une étiquette, texte vaut "Nombre de cases en largeur :", x vaut 10, y vaut 10
txt_Fnq2 est une étiquette, texte vaut "Nombre de cases en hauteur :", x vaut 10, y vaut 30
txt_Fnq3 est une étiquette, texte vaut "Largeur des cases :", x vaut 10, y vaut 50
txt_Fnq4 est une étiquette, texte vaut "Hauteur des cases :", x vaut 10, y vaut 70
choix_case_largeur est un sélecteur, valeurs vaut "", x vaut 200, y vaut 10
choix_case_hauteur est un sélecteur, valeurs vaut "", x vaut 200, y vaut 30
choix_taille_largeur_case est un sélecteur, valeurs vaut "", x vaut 200, y vaut 50
choix_taille_hauteur_case est un sélecteur, valeurs vaut "", x vaut 200, y vaut 70
bouton_valider_Fnq est un bouton, texte vaut "Valider", x vaut 70, y vaut 110
bouton_annuler_Fnq est un bouton, texte vaut "Annuler", x vaut 160, y vaut 110

("Menus")
menu2 est un menu, texte vaut "Carte"
menu2s1 est un sousmenu, texte vaut "Nouveau quadrillage"

("Toile")
fond est une toile, hauteur vaut 800, largeur vaut 1600, couleur vaut "blanc", pointeur vaut "flèche"
xtoile est une xtoile, x vaut 0, y vaut 0
bordure_gauche est un rectangle, x = 0, y = 0, position vaut 1, hauteur vaut hauteur de fond, largeur vaut 150, plein vaut "oui", couleur vaut "blanc"

("Quadrillage")
taille_largeur_case est un nombre
taille_hauteur_case est un nombre
nombre_case_largeur est un nombre
nombre_case_hauteur est un nombre
nombre_case_largeur_effectif est un nombre
nombre_case_hauteur_effectif est un nombre
nombre_case est un nombre

grille4 est un casier de rectangle
grille5 est un casier de rectangle

Fenêtre_principale :
Rôles :
Actions :
("Construction des fenêtres")
Tu ajoutes txt_Fnq1 & txt_Fnq2 & txt_Fnq3 & txt_Fnq4 & choix_case_largeur & choix_case_hauteur & choix_taille_largeur_case & choix_taille_hauteur_case & bouton_valider_Fnq & bouton_annuler_Fnq dans Fenêtre_nouveau_quadrillage
Tu fais réagir Fenêtre_nouveau_quadrillage à "clic souris" pour Fermer_fenêtre_nouveau_quadrillage
Tu fais réagir bouton_annuler_Fnq à "clic souris" pour Fermer_fenêtre_nouveau_quadrillage
Tu fais réagir bouton_valider_Fnq à "clic souris" pour Générer_quadrillage

("Début du programme")

Tu ajoutes xtoile dans Fenêtre_principale
visible de Fenêtre_principale vaut "oui"
Tu ajoutes menu2 dans Fenêtre_principale
Tu ajoutes menu2s1 dans menu2
Tu fais réagir Fenêtre_principale à "clic souris" pour Fermer_fenêtre_principale
Tu fais réagir menu2s1 à "clic souris" pour Fenêtre_nouveau_quadrillage
Tu fais réagir menu2s1 à "clic souris" pour Affichage_toile

tant que 1 est différent de 2, lis
temporise
ferme

Fenêtre_nouveau_quadrillage :
Rôles :
§ i est un nombre
Actions :
visible de Fenêtre_nouveau_quadrillage vaut "oui"

Pour i de 1 à 100, lis
Tu ajoutes i +"|" dans valeurs@choix_case_largeur
Tu ajoutes i +"|" dans valeurs@choix_case_hauteur
Tu ajoutes i +"|" dans valeurs@choix_taille_largeur_case
Tu ajoutes i +"|" dans valeurs@choix_taille_hauteur_case
Tu fermes

Fermer_fenêtre_principale :
Rôles :
*f :: formulaire
Actions :
Efface la toile
Tu termines

Fermer_fenêtre_nouveau_quadrillage :
Rôles :
Actions :
visible de Fenêtre_nouveau_quadrillage vaut "non"
Tu reviens

Affichage_toile :
Rôles :
Actions :
Efface la toile
Projette le fond & bordure_gauche

Tant que vrai, lis
Temporise
Ferme

Générer_quadrillage :
Rôles :
§ valeur1 est un texte
§ valeur2 est un texte
§ valeur3 est un texte
§ valeur4 est un texte
Actions :
valeur1 = valeur@choix_case_largeur
Tu convertis valeur1 en nombre_case_largeur
valeur2 = valeur@choix_case_hauteur
Tu convertis valeur2 en nombre_case_hauteur
valeur3 = valeur@choix_taille_largeur_case
Tu convertis valeur3 en taille_largeur_case
valeur4 = valeur@choix_taille_hauteur_case
Tu convertis valeur4 en taille_hauteur_case

nombre_case_largeur_effectif = entier ((largeur de fond - largeur de bordure_gauche) / taille_largeur_case)
nombre_case_hauteur_effectif = entier (hauteur de fond / taille_hauteur_case)
Si nombre_case_largeur_effectif >
nombre_case_largeur alors nombre_case_largeur_effectif = nombre_case_largeur
Si nombre_case_hauteur_effectif >
nombre_case_hauteur alors nombre_case_hauteur_effectif = nombre_case_hauteur
nombre_case = nombre_case_hauteur*nombre_case_largeur

visible de Fenêtre_nouveau_quadrillage vaut "non"

Tu vas vers Affichage_quadrillage

Affichage_quadrillage :
Rôles :
§ case est un rectangle, couleur vaut "blanc", hauteur vaut taille_hauteur_case, largeur vaut taille_largeur_case, position vaut 1, plein vaut "oui"
§ contour_case est un rectangle, couleur vaut "noir", hauteur vaut taille_hauteur_case, largeur vaut taille_largeur_case, position vaut 100, plein vaut "non"
xx est un nombre <
- (((largeur de fond - largeur de bordure_gauche) - (nombre_case_largeur_effectif * taille_largeur_case))/2) + largeur de bordure_gauche
yy est un nombre <
- (hauteur de fond - (nombre_case_hauteur_effectif * taille_hauteur_case))/2
Actions :
("ici on dessine des cases pleines")

pour chaque nombre_case, lis
ajoute #case dans grille4
déplace grille4{joker} vers xx et yy
projette grille4{joker}
xx = xx + taille_largeur_case
si xx est plus grand que largeur de bordure_gauche + (nombre_case_largeur_effectif * taille_largeur_case) + (((largeur de fond - largeur de bordure_gauche) - (nombre_case_largeur_effectif * taille_largeur_case))/2) - taille_largeur_case alors lis
xx = (((largeur de fond - largeur de bordure_gauche) - (nombre_case_largeur_effectif * taille_largeur_case))/2) + largeur de bordure_gauche
yy = yy + taille_hauteur_case
ferme
si yy est plus grand que (((hauteur de fond - (nombre_case_hauteur_effectif * taille_hauteur_case))/2) + (nombre_case_hauteur_effectif * taille_hauteur_case)) - taille_hauteur_case alors lis
yy = (hauteur de fond - (nombre_case_hauteur_effectif * taille_hauteur_case))/2
ferme
ferme
xx = (((largeur de fond - largeur de bordure_gauche) - (nombre_case_largeur_effectif * taille_largeur_case))/2) + largeur de bordure_gauche
yy = (hauteur de fond - (nombre_case_hauteur_effectif * taille_hauteur_case))/2

("ici on dessine le contour des cases")
pour chaque nombre_case, lis
ajoute #contour_case dans grille5
déplace grille5{joker} vers xx et yy
Projette grille5{joker}
xx = xx + taille_largeur_case
si xx est plus grand que largeur de bordure_gauche + (nombre_case_largeur_effectif * taille_largeur_case) + (((largeur de fond - largeur de bordure_gauche) - (nombre_case_largeur_effectif * taille_largeur_case))/2) - taille_largeur_case alors lis
xx = (((largeur de fond - largeur de bordure_gauche) - (nombre_case_largeur_effectif * taille_largeur_case))/2) + largeur de bordure_gauche
yy = yy + taille_hauteur_case
ferme
si yy est plus grand que (((hauteur de fond - (nombre_case_hauteur_effectif * taille_hauteur_case))/2) + (nombre_case_hauteur_effectif * taille_hauteur_case)) - taille_hauteur_case alors lis
yy = (hauteur de fond - (nombre_case_hauteur_effectif * taille_hauteur_case))/2
ferme
ferme
[/php]

Vouloir créer un quadrillage de 32x32 cases ne pose pas de problème.
Par contre, si j'essaie de créer un quadrillage de 100x 100 cases, c'est là que sa plante.

La seule façon de créer un très grand quadrillage consiste alors à créer d'abord un petit quadrillage de 32x32 puis, à chaque scrolling, recréer un nouveau quadrillage de 32x32.

La difficulté pour moi revient donc à attribuer le bon numéro correspondant à chaque case.
En effet, si la première case de mon quadrillage (comprendre la case en haut à gauche) porte le numéro 0, la même case après 3 scrolling vers la droite portera le numéro 93.
Mais si on effectue 3 scrolling vers le bas au lieu de la droite, la même case aura alors le numéro 3069.
A chaque création d'un nouveau quadrillage je dois donc réussir à attribuer le bon numéro à chaque case pour pouvoir garder une cohérence et donner l'illusion qu'il s'agisse d'un très grand quadrillage.

Ayai !
J'ai réussit à créer mon système de scrolling.
Désormais, je peux créer de très grands quadrillages sans problème x)

Un défaut tout de même :
L'affichage n'est pas très fluide.
En effet, comme je créer un nouveau quadrillage à chaque scrolling, le quadrillage précédent s'efface.
Du coup, à chaque déplacement la toile redevient blanche pendant une fraction de seconde.
Il va falloir que je trouve une solution pour avoir un affichage constant.

Problème résolu.
L'affichage est désormais fluide x)

J'ai découvert un bogue assez troublant.
Je vais tenter de l'expliquer :
J'affiche un tile.
Je créer ensuite un quadrillage de 5x5 cases.
A l'écran, je n'affiche qu'une partie de mon quadrillage, soit un quadrillage de 3x3 cases seulement.

Je déplace ensuite le tile dans la case numéro 0 de mon quadrillage.
Pour positionner correctement le tile dans la case, j'utilise le système de collision, comme ceci :

[php]
Drop :
Rôles :
§ i est un nombre
§ pos_x est un nombre
§ pos_y est un nombre
§ pos_x_mini est un nombre <
- ((((largeur de fond - largeur de bordure_gauche) - (nombre_case_largeur_effectif * taille_largeur_case))/2) + largeur de bordure_gauche) - (taille_largeur_case / 2)
§ pos_x_maxi est un nombre <
- ((((largeur de fond - largeur de bordure_gauche) - (nombre_case_largeur_effectif * taille_largeur_case))/2) + largeur de bordure_gauche) + (nombre_case_largeur_effectif * taille_largeur_case) - (taille_largeur_case / 2)
§ pos_y_mini est un nombre <
- ((hauteur de fond - (nombre_case_hauteur_effectif * taille_hauteur_case))/2) - (taille_hauteur_case / 2)
§ pos_y_maxi est un nombre <
- ((hauteur de fond - (nombre_case_hauteur_effectif * taille_hauteur_case))/2) + (nombre_case_hauteur_effectif * taille_hauteur_case) - (taille_hauteur_case / 2)
§ num_x est un nombre
§ num_y est un nombre
§ numéro_case est un nombre
§ copie_validation_drop est un drapeau
§ copie_validation_annulation est un drapeau
Actions :
Attends 0.1 seconde
drop_valide = vrai

("copie_casier_tiles est le tableau contenant mes tiles ")
Mesure copie_casier_tiles dans copie_nombre_tiles
pour i de 0 à nombre_case - 1, lis
pour chaque copie_nombre_tiles, lis
("grille4 est mon quadrillage")
Si (copie_casier_tiles{joker}) est en collision avec grille4{i} alors lis
pos_x = x de (copie_casier_tiles{joker})
pos_y = y de (copie_casier_tiles{joker})

("on détermine la case qui est en collision")
num_x = (pos_x - ((((largeur de fond - largeur de bordure_gauche) - (nombre_case_largeur_effectif * taille_largeur_case))/2) + largeur de bordure_gauche)) / taille_largeur_case
num_y = (pos_y - ((hauteur de fond - (nombre_case_hauteur_effectif * taille_hauteur_case))/2)) / taille_hauteur_case
numéro_case = (arrondi num_x * nombre_case_hauteur_effectif) + arrondi num_y

("on améliore la précision du drag&drop")
Si pos_x <
pos_x_mini alors lis
("coin haut gauche")
Si pos_y <
pos_y_mini alors numéro_case = 0
("coin bas gauche")
Sinon, si pos_y >
pos_y_maxi alors numéro_case = nombre_case_hauteur - 1
("milieu gauche")
Sinon, numéro_case = abs (numéro_case + nombre_case_hauteur_effectif)
ferme
Sinon, si pos_x >
pos_x_maxi alors lis
("coin haut droit")
Si pos_y <
pos_y_mini alors numéro_case = nombre_case - nombre_case_hauteur
("coin bas droit")
Sinon, si pos_y >
pos_y_maxi alors numéro_case = nombre_case - 1
("milieu droit")
Sinon, numéro_case = numéro_case - nombre_case_hauteur_effectif
ferme
("milieu haut")
Sinon, si pos_y <
pos_y_mini alors numéro_case = numéro_case + 1
("mileu bas")
Sinon, si pos_y >
pos_y_maxi alors numéro_case = numéro_case - 1

("on détermine le tile qui est en collision")
copie_pos_case = pos_case de (copie_casier_tiles{joker})
("on repositionne le tile concerné, en vérifiant qu'il ne s'agit pas d'un tile effacé")
Si (copie_pos_case != numéro_case) et (copie_pos_case != -1) alors lis
pos_case de (copie_casier_tiles{joker}) = numéro_case
validation_drop de (copie_casier_tiles{joker}) = vrai
parcours Repositionnement avec (copie_casier_tiles{joker}), joker, numéro_case
ferme
("si on replace le tile au même endroit, inutile de le repositionner")
Sinon validation_drop de (copie_casier_tiles{joker}) = faux
ferme
ferme
ferme
("on vérifie que le tile ne sort pas du quadrillage")
Mesure copie_casier_tiles dans copie_nombre_tiles
pour chaque copie_nombre_tiles, lis
copie_validation_drop = validation_drop de (copie_casier_tiles{joker})
copie_validation_annulation = validation_annulation de (copie_casier_tiles{joker})
Si (copie_validation_drop == faux) et (copie_validation_annulation == faux) alors parcours Annulation_drop avec (copie_casier_tiles{joker}), joker
Sinon, validation_drop de (copie_casier_tiles{joker}) = faux
ferme
[/php]

La ligne de code à retenir est celle-ci :
[php]
Si (copie_casier_tiles{joker}) est en collision avec grille4{i} alors lis
[/php]

J'utilise alors mon système de scrolling pour afficher une autre partie de mon quadrillage à l'écran.
Un nouveau quadrillage est alors créer.
La case numéro 0 n'apparaît plus et donc le tile est effacé.

Je reprend alors un autre tile et le met dans la case numéro 16.
Le système de collision détecte mon tile et le place correctement dans la case du quadrillage.

Et c'est là qu'intervient le bogue :
le système de collision détecte également le tile de la case numéro 0 !
Hors celui-ci est effacé et le précédent quadrillage a été supprimé.

En fait, quand j'efface et je créer un nouveau quadrillage, sans redémarrer mon programme, apparemment le système de collision garde en mémoire ses précédentes collisions.
Bien entendu, cela fait planter mon programme x)

Je viens de vérifier sur une version précédente de mon programme :
Quand j'efface un tile de mon quadrillage, en faisant :

[php]
("on efface le tile")
Efface (copie_casier_tiles{index_copie_casier_tiles2})
Ne fais plus réagir copie_casier_tiles{index_copie_casier_tiles2} à "glisser-déposer"
Ne fais plus réagir copie_casier_tiles{index_copie_casier_tiles2} à "clic souris"
[/php]

Il est toujours détecté par le système de collision.

Ce n'était pas gênant à l'époque, mais là avec mon système de scrolling, sa fait tout planter, snif...

Je viens aux nouvelles x)
Le problème décrit dans mon post au-dessus, c'est un bogue du système de collision ?

Une amélioration à apporter (si l'élément graphique est effacé, il ne doit plus être détecté par le système de collision) ?

Ou je dois le prendre en compte en écrivant mon code ?

Me voilà de retour...

Donc, le bogue a corriger est : si l'élément est effacé, alors, il ne doit pas être détecté par le système de collision.

exact ^^