Discussion :

[Gory]

Salut à tous je suis débutant en assembleur et pour m'entrainer je pratique quelques exercices parmi eux j'ai quelques problèmes.
Tout d'abord j'aimerais trier par ordre ASCII une chaine de caractère par exemple si je rentre "salut" je dois avoir en sortie "alstu" j'essaye de le programmer avec cette algo qui disons le me simplifie la tache :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
FinTri <- N - 1
          FAIRE
            Bool <- FAUX
            POUR i allant de 1 à FinTri FAIRE
              SI A[i] > A[i+1] ALORS
                Echanger A[i] et A[i+1]
                Bool <- VRAI
              FINSI
            FINPOUR
          FinTri <- FinTri - 1
          TANQUE Bool = VRAI

Et voici ce que j'en sors en assembleur :

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
47
48
49
50
data SEGMENT
chaine DB 'Saisir une chaine',10,13,'$'		
car DB ?						
affiche DB 'La chaine triée par ordre ASCII croissant est : ',10,13,'$'
tampon DB 10,0,10 DUP('$')				     data ENDS
 
code SEGMENT
	Assume CS : code, DS : data
 
	deb : 
		MOV AX, data			
		MOV DS, AX
		MOV DX, OFFSET chaine			
		MOV AH, 09h			
		INT 21h	
 
		MOV DX, OFFSET tampon
		MOV AH, 0Ah						
		INT 21h							
 
		MOV DX, OFFSET affiche			
		MOV AH, 09h						
		INT 21h
 
		MOV CX,0
		MOV CL, tampon[1]
		dec cx
		mov si,2
 
		boucle  :
			MOV DL, tampon[SI]
			MOV DH, tampon[SI + 1]
			CMP DL,DH
			JBE paspermut
				MOV tampon[SI], DH
				MOV tampon[SI + 1], DL
			paspermut : 
			INC SI
			loop boucle
 
		MOV DX, OFFSET tampon + 2		
		MOV AH, 09h						
		INT 21h
 
		MOV AL,0						
		MOV AH,4Ch
		INT 21h
 
code ENDS
	END deb

Voilà c'est le source. Le problème c'est que cela marche pour certains mots mais pas pour tous et je ne sais pas pourquoi. Je ne cherche pas à gérer les doublons donc j'aimerais savoir ce qui ne va pas.

Mon deuxième problème et peut etre un peu plus complexe.
J'arrive à afficher un fond d'ecran et une image par dessus.
J'arrive à deplacer l'image mais le problème c'est que quand je la déplace il y a des trainées donc pouvez vous me dire comment éviter ces trainées.
Et la dernière petite chose ( je sais j'en demande bcp d'un coup ) c'est de savoir comment fixer des limites d'ecran en d'autres termes j'aimerais que mon sprite ne sorte pas de l'ecran.

Je vous rappelle que je suis vraiment novice donc si vous pouviez etre gentil avec moi cela serait super mais j'ai confiance.

Merci d'avance.

PS : je bosse en assembleur x86

[Nico*3-3]

Bonjour et bienvenue !

Déjà, je vois une petite erreur dans ton algorithme : le "FAIRE...TANT QUE" ne sert pas vraiment à grand chose...

Ensuite il y a forcément une erreur dans ton code mais pour la dicerner, peux-tu nous dire ce qui se passe exactement et nous donner quelques exemples avec des mots fonctionnant et d'autres ne fonctionnant pas ?

Pour la deuxième question : Je présume que tu es en mode 13h et que tu affiches ton sprite directement par la mémoire vidéo...
L'écran a un taux de rafraîchissement (70 Hz environ), mais tu dois le savoir...
Dans la mémoire vidéo, lorsque tu "écrit" ton sprite, il s'affiche bien la première fois, mais dès que tu l'écris une deuxième fois, il s'affiche en laissant une traînée du sprite affiché précédemment.
C'est tout simple, si tu n'efface pas le buffer vidéo à chaque nouvelle image, il reste les traces du sprite précédemment affiché et ainsi de suite...
Mais connais-tu la notion de buffer vidéo etc. (je vais pas me lancer dans une explication si tu le sais déjà...) ?

Pour la troisième question, c'est simple : c'est à toi de vérifier que ton sprite ne sort pas de l'écran. Tu dois avoir des valeurs X Y pour chaque objet à afficher, à partir de là tu fais :

Code :

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

1
2
3
4
If X_sprite > largeur_écran - largeur_sprite 
  ;Le sprite dépasse les limites de l'écran
Else
  ;Le sprite ne dépasse pas

Et pareil pour Y...

[Alcatîz]

Bonjour et bienvenue !

L'algorithme de tri lui-même a l'air correct mais il n'est pas entièrement traduit en Assembleur : la boucle dans le source se borne à comparer une seule fois les caractères du mot deux à deux. Le résultat ne peut donc être correct que dans certains cas particuliers.

[Gory]

Concernant mon tri a bulle le problème que j'ai est que il ne trie pas les doublons par exemple si j'ecris blocos il va me le trié de cette facon "obclos" par contre pour le mot salut il me le traduit bien " alstu".

Concernant le sprite oui je connais la notion de buffer video pour une certaine aide on m'a expliqué qu'il fallé que je sauvegarde la position du sprite grace a une variable tampon ( par exemple) puis que je devais le réaffiché avant de modifié les coodonnées X et Y de la voiture mais je trouve pas ca logique voici mon code source pour l'affichage de mon sprite :

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
 
affichage PROC				; routine pour l'affichage appellé par call
 
 
		MOV AX, Y					;multiplication ax contient Y*320
		MOV BX, 320
		MUL BX
 
		MOV DI, AX					;addition ax + x dans DI
		ADD DI, X
 
		MOV SI, 2
		mov ch, 0				;puisque l'on utilise CL il faut initialisé CH
		MOV CL, sprite[1]		;sprite est un DB il faut donc utilisé CL et non CX
		boucle1 :
			PUSH CX
			PUSH DI
 
			MOV CL, sprite[0]
			boucle2 :
				mov al,es:[di]
				mov tampon[si],al
				mov al,sprite[SI]
				cmp al, 0
				je transparent
				mov es:[di],al
				transparent:
				inc si
				inc di
 
				;instruction
 
				LOOP boucle2
				POP DI
				add di,320
			POP CX
			LOOP boucle1
	RET							;fin PROC
affichage ENDP

Comme vous le voyez je sauvegarde la postion de mon sprite dans un tampon mé comment le réaffiché normalement aprés mouvement.

Même si vous n'arrivez pas à me répondre je vous remercie d'avance de prendre le temps de m'aider.

[Nico*3-3]

C'est simple : Comme je l'ai dit plus haut, tu affiches tu sprite dans la mémoire vidéo, mais lorsque tu le réaffiches, ça n'efface pas le le reste en mémoire de l'affcihage précédent, c'est pour ça que tu as une traînée...

Ce que je veux dire par buffer vidéo, c'est que tu dois définir une zone mémoire de 64000 octets (320 * 200).
Pourquoi ? Pour faire tous les calculs dont tu as besoin.
Car la mémoire vidéo est bien plus lente à accéder que la mémoire conventionnelle.
Tu définis donc un segment rien que pour le buffer vidéo, et à chaque nouvelle image, tu l'effaces, ensuite tu affiche ton sprite dedans, et seulement à la fin, quand tu as tout terminé, tu copies tout ton segment de buffer vidéo dans la mémoire vidéo (enfin pas tout le segment, les 64000 premiers octets).
De cette façon, tu accélère considérablement la vitesse d'éxécution et tu évites toute traînée malencontreuse...

Ensuite, on pourrait te conseiller plein d'optimisations :

Code :

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

mov cx, 0

A remplacer par :

Code :

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

xor cx, cx

Enormément plus rapide !

Code :

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

cmp al, 0

A remplacer par :

Code :

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

or al, al

Bien plus rapide aussi...

Il y a aussi la super optimisation pour multiplier par 320 mais je dois partir et je n'ai pas le temps de te l'expliquer maintenant...
Donc si quelqu'un veut bien lui montrer, sinon je t'expliquerai à mon retour.

Salut !

[Blustuff]

Les deux versions des codes sont aussi rapides, il n'y a pas d'optimisation de vitesse mais juste de taille. (Ce qui aide tout de même en terme de cache) Attention en optimisant les multiplications... Un site donnait un code qui optimisait la multiplication par 800, et qui était 60 % plus long que la simple multiplication. (Et accessoirement plus long que ce qu'un compilateur C produit)