Discussion :

[gnoirzox]

Bonjour à tous,

Dans le cadre de mes études, je dois produire un casse brique en assembleur 8086. Je ne peux pas utiliser les dérives nasm, masm ou fasm. Je dois donc produire ce logiciel avec le jeu d'instruction du processeur 8086 avec le systeme d'exploitation DOS (je dois utiliser Emu8086).

Pour ce projet, je suis bloqué au début pour pouvoir afficher une ligne oblique faite d'espaces colorés partant de l'origine cartesienne x, y (0, 0).

Voici le peu de code que j'ai produit

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
name 'jalon1'
include 'emu8086.inc'
org 100h
 
cursor_position:
mov dl, 1       ;position X du curseur
mov dh, 1       ;position Y du curseur
mov bh, 0       ;la page active ou se trouve
                ;la position (X;Y) du curseur
 
cursor_character:
mov al, ' '     ;caractere a afficher (' ')
mov bh, 0       ;la page active ou afficher
mov bl, 0001b   ;couleur du caractere (blanc)
mov cx, 25      ;nombre de fois a afficher le caractere 
 
deplacement PROC
    inc dl      ;incrementation position X
    inc dh      ;incrementation position Y
 
    mov ah, 6   ;affichage du caractere sur 
    int 21h     ;la position du curseur
 
    cmp dh, 25  ;comparaison dh et valeur immediate 25
    jne deplacement   
endp
ret

Pouvez vous m'aider à avancer sur ce projet ?

Cordialement,

[Obsidian]

Bonjour,

Je ne comprends pas ce que tu veux dire par « ligne oblique faite d'espaces colorés ». Peux-tu être plus précis ?

Si tu programmes en 8086 avec D.O.S., tu auras quand même peut-être droit au mode VGA − 13h: 320×200 256 couleurs. Dans ce mode, un octet = un pixel. C'est quand même nettement moins pénible à gérer que le reste.

À l'époque, j'en avais écrit un entier en assembleur, de la même manière (malheureusement, j'ai tout perdu dans un crash disque :-) ).

[gnoirzox]

Bonjour Obsidian,

Par "ligne droite oblique" je voulais dire qu'à partir d'espaces colorés faire une ligne droite du type "\". J'ai finalement réussi à afficher cette ligne et également faire les rebonds. Cependant je n'ai pas encore réussi à afficher des espaces colorés pour le caractère représentant la position du curseur, mais ceci n'est pas mon plus gros problème à cette heure ci. (je suis en text-mode)

Maintenant, je dois effacer les anciennes positions du curseurs qui matérialises la trajectoire de la balle. Je ne sais pas exactement comment je dois faire. Dois je effacer une partie du buffer video ? Comment dois je faire pour effacer uniquement un caractère à une position donnée et non pas l'écran tout entier ?

Voici ma production à ce stade là:

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
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
name "jalon03"
include "emu8086.inc"
org 100h
 
cursor_position:
mov dl, -1      ;position X du curseur
mov dh, -1      ;position Y du curseur
mov bh, 0       ;la page active ou se trouve
 
cursor_character:
mov al, ' '     ;caractere a afficher (' ')
mov bh, 0       ;la page active ou afficher
mov bl, 0001b   ;couleur du caractere (blanc)
mov cx, 1       ;nombre de fois a afficher le caractere 
 
deplacement:
    cmp dh, 23 ;comparaison dh et valeur immediate 23
    je rebond1
 
    cmp dl, 78 ;comparaison dl et valeur immediate 78
    je rebond2
 
    inc dl      ;incrementation position X
    inc dh      ;incrementation position Y
    call mode_video
 
    push dx     ;archivage position curseur dans pile
    mov dl, 178 ;caractere a afficher
 
    mov ah, 6   ;affichage du caractere sur 
    int 21h     ;la position du curseur
 
    pop dx      ;position curseur remise dans registre
 
    jmp deplacement
 
                ;rebonds
 
rebond1:        ;si Y==25 et inc dl & inc dh
    cmp dh, 0
    je deplacement
 
    cmp dl, 78
    je rebond3
 
    inc dl      ;incrementation position X
    dec dh      ;decrementation position Y 
    call mode_video
 
    push dx     ;position (X;Y) du curseur dans la pile
    mov dl, 178 ;caractere a afficher
 
    mov ah, 6   ;affichage du caractere sur 
    int 21h     ;la position du curseur
 
    pop dx      ;remise de la position du curseur dans registre
 
    jmp rebond1
 
rebond2:        ;si X==80 et inc dl & inc dh
    cmp dh, 23
    je rebond3
 
    cmp dl, 0
    je deplacement
 
    dec dl      ;decrementation position X
    inc dh      ;incrementation position Y
    call mode_video 
 
    push dx
    mov dl, 178
 
    mov ah, 6   ;affichage du caractere sur 
    int 21h     ;la position du curseur
 
    pop dx       
 
    jmp rebond2
 
rebond3:        ;si Y==25 et dec dl & inc dh    
    cmp dh, 0
    je rebond2
 
    cmp dl, 0
    je rebond1
 
    dec dl      ;decrementation position X
    dec dh      ;decrementation position Y
    call mode_video
 
    push dx
    mov dl, 178
 
    mov ah, 6
    int 21h
 
    pop dx
 
    jmp rebond3
 
ancienne_position PROC
 
 
 
endp ancienne_position
 
mode_video PROC ;mode d affichage des evenements
    mov ah, 2
    int 10h    
 
endp mode_video
ret

Cordialement,

[Obsidian]

Ok, tu travailles en mode texte. Je maintiens tout de même qu'un bon mode graphique serait plus sympa.

N'utilise pas le curseur et l'int 10h pour modifier tes caractères. La mémoire vidéo du mode texte en mode réel se trouve en B800:0000. Il suffit d'écrire dans les adresses paires le code ASCII du caractère à afficher pour qu'il apparaisse automatiquement à l'écran. En écrivant dans les adresses impaires, tu modifies les attributs (couleur de forme, de fond, clignotement et surbrillance) du caractère codé dans l'octet immédiatement précédent.

Cache le curseur avec l'int 10, puis exploite la mémoire directement comme s'il s'agissait de pixels.

[gnoirzox]

Merci de ta réponse.

Je vois bien que je suis bloqué en utilisant les interruptions pour la trajectoire de la balle et la gestion des briques ... Justement, je ne sais pas comment faire pour utiliser directement la mémoire video... Si tu aurai un tuto ce serai sympa . Si je travail en mode texte, c'est que les modalités du projet nous contraignent de l'utiliser.

EDIT: J'ai réussi à afficher le caractère correspondant à la balle, cependant, puis-je utiliser des registres pour modifier la position du caractère (registre correspondant à la position x et un autre pour la position y) ? Sinon, quelle méthode me proposez vous pour modéliser ce déplacement ?

Cordialement,

[Forthman]

Le segment vidéo du mode texte est en B800h, le caractère en haut à gauche
est à l'offset 0000h ses attributs sont sur l'octet 0001h
Si tu utilise le mode texte 80x25 (standard au démarrage) chaque ligne comporte 160 octets.

Pour pointer un caractère précis à l'écran la formule est :
adresse = X + Y*160

Par exemple, pour afficher le code DBh (pave plein) au centre de l'écran
de couleur verte (valeur 02h sur palette par défaut), tu peux écrire un truc du genre :

Code :

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

1
2
3
4
5
6
7
 
mov ax,0B800h
mov es,ax
mov bx,2000 ; X=40 Y=12 : 40+12*160=2000
mov al,0DBh ; code ascii du pave plein
mov ah,02h ; couleur verte
mov es:[bx],ax

à toi de jouer

a+ François

[gnoirzox]

Merci encore à vous de s'intéresser à mon cas,

Pour ta solution, François, J'arrive bien à afficher un caractère à une position donnée. Cependant, je ne sais pas comment on peut faire pour faire une boucle en incrémentant la position X et la position Y du caractère pour permettre l'affichage d'un trait oblique. Qu'est ce que vous pouvez me proposer comme méthode ? Il faut avouer que l'utilisation de la position du curseur était plus facile mais restais limitée pour mon projet...

J'espère retenir toute votre attention et vous remercie de bien vouloir donner suite à ma demande.

Cordialement

[Forthman]

rien ne t'empêche de définir une fonction qui sera aussi pratique (sinon plus)
que l'utilisation des interruptions du BIOS

par exemple, si tu compte utiliser uniquement le caractère DBh (pavé plein)
ce qui reviendrait à gérer l'écran texte comme un écran graphique de 80x25 points (ça c'est de la haute résolution )

Tu as donc besoin de 3 valeurs par pixel : X, Y, et la couleur
Disons que :
bx = X
ax = Y
cx = couleur
(ok, on a pas besoin de registres 16 bits, mais ça simplifie un peu la fonction)

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
 
Pixel:
  push dx
  push cx
  push bx
  push ax
 
  mul ax,160
  shl bx,1
  add bx,ax
  mov ch,0DBh
  xchg ch,cl
  mov es:[bx],cx
 
  pop ax
  pop bx
  pop cx
  pop dx
 ret

comme tous les registres sont sauvés lors de l'appel à cette fonction,
tu peux très bien les incrémenter/décrémenter dans le programme principal.
Exemple pour tracer 10 "pixels" de couleurs différentes depuis le haut/gauche de l'écran :

Code :

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

1
2
3
4
5
6
7
8
9
10
 
  mov bx,0 ; X=0
  mov ax,0 ; Y=0
  mov cx,10 ; compteur = 10 et sert aussi pour la couleur du coup
  boucle:
    call pixel
    inc bx
    inc ax
    dec cx
   jnz boucle

Et voila ! (et c'est compliqué ça ?)

a+ François

[gnoirzox]

Merci beaucoup François pour ton aide. J'ai dû modifier quelques élément pour que ça fonctionne mais dans l'ensemble tu m'a beaucoup aider .

Cependant, là, je bloque vraiment sur la gestion des obstacles. Je ne sais comment faire, quel élément prendre en compte pour que à une position donnée on puisse faire rebondir la balle sur cet obstacle et également le supprimer . Le résultat demandé est en image en pièce jointe. Je suis vraiment bloqué là dessus, c'est à cause de cette partie que j'ai du refaire l'affichage. J'espère que vous pourrez m'aider et je vous remercie encore pour l'intérêt que vous portez à mes problèmes.

voici ce que j'ai fait jusqu'à maintenant pour afficher l'obstacle en croix et la balle en mouvement:

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
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
name 'test2'
org 100h
 
  mov ax,0B800h
  mov es,ax
 
  mov bx,0 ; X=0
  mov al,0 ; Y=0
  mov cx,0 ; la couleur effacant le trace de la balle
 
 
 
  obstacle PROC
  mov bx, 40
  mov al, 12
  mov cx, 2
 
  mov [00h], al
  mov [02h], bx
  mov [04h], al
  mov [06h], bx
 
 
  call position_centre
 
  position_verti1:
  mov bx, 40
  mov al, [00h]
  inc al
 
  call position_verticale
 
  mov [00h], al
 
  position_hori1:
  mov al, 12
  mov bx, [02h]
  dec bx
 
  call position_horizontale
 
  mov [02h], bx
 
  position_verti2:
  mov bx, 40
  mov al, [04h]
  dec al
 
  call position_verticale
 
  mov [04h], al
 
  position_honri2:
  mov al, 12
  mov bx, [06h]
  inc bx
 
  call position_horizontale
 
  mov [06h], bx
 
  cmp bx, 50
  je init
  jmp position_verti1
 
  position_centre PROC
  push cx
  push bx
  push ax
 
  mov ah, 160
  mul ah
  shl bx, 1
  add bx, ax
  mov ch, 02Bh
  xchg ch, cl
  mov es: [bx], cx
  mov dx, cx
 
  pop ax
  pop bx
  pop cx
 
  ret
  position_centre endp
 
  position_horizontale PROC 
  push cx
  push bx
  push ax
 
  mov ah, 160
  mul ah
  shl bx, 1
  add bx, ax
  mov ch, 02Dh
  xchg ch, cl
  mov es: [bx], cx
  mov dx, cx
 
  pop ax
  pop bx
  pop cx
 
  ret
  position_horizontale endp
 
  position_verticale PROC
  push cx
  push bx
  push ax
 
  mov ah, 160
  mul ah
  shl bx, 1
  add bx, ax
  mov ch, 07Ch
  xchg ch, cl
  mov es: [bx], cx
  mov dx, cx
 
  pop ax
  pop bx
  pop cx
 
  ret
  position_verticale endp
 
  init:
  mov bx,0 ; X=0
  mov al,0 ; Y=0
  mov cx,0 ; la couleur effacant le trace de la balle
 
 deplacement:
 
  cmp al, 24 ; si Y=24 on change de boucle
  je rebond1 
 
  cmp bx, 79 ; si X=79 on change de boucle
  je rebond2
 
  inc bx   ; incrementation X
  inc al   ; incrementation Y 
 
  call position_active 
  call position
  jmp deplacement
 
  rebond1:
  cmp al, 0
  je deplacement
 
  cmp bx, 79
  je rebond3
 
  inc bx
  dec al
 
  call position_active
  call position
  jmp rebond1
 
  rebond2:
  cmp al, 24
  je rebond3
 
  cmp bx, 0
  je deplacement 
 
  dec bx
  inc al
 
  call position_active
  call position
  jmp rebond2
 
  rebond3:
  cmp al, 0
  je rebond2
 
  cmp bx, 0
  je rebond1
 
  dec bx
  dec al
 
  call position_active
  call position
  jmp rebond3
 
  position PROC
  push dx
  push cx
  push bx
  push ax
 
  mov ah, 160
  mul ah
  shl bx, 1
  add bx, ax
  mov ch, 0DBh
  xchg ch, cl
  mov es: [bx], cx
 
  pop ax
  pop bx
  pop cx
  pop dx
  ret
  position endp
 
  position_active PROC
  push cx
 
  mov cx, 1 ; couleur bleu permettant d'afficher la balle
  call position
 
  pop cx
  ret
  position_active endp 
 
 fin:
 mov ah, 04Ch 
 int 21h
 ret

Cordialement.

[Forthman]

J'avais compris que tu bloquais sur l'affichage... mais en fait tu bloque sur tout

Pour gérer la direction de la balle, tu devrais utiliser la même routine quel que
soit le sens de déplacement de celle-ci.

Code :

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

1
2
3
4
5
 
Variable BALLE_X = position X de la balle
Variable BALLE_Y = position Y de la balle
Variable Sens_X  = sens de déplacement en X ( -1 ou +1 )
Variable Sens_Y  = sens de déplacement en Y ( -1 ou +1 )

Comme ta résolution n'est pas importante ( 80x25 ), utilise un tableau
pour gérer les collisions, la présence des briques, et la raquette.

Ton programme devrait donc ressembler à ça :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
Boucle principale
  gestion des touches du clavier
  gestion position raquette
  gestion position balle
  calcul nouvelle position balle
  test collisions
      actions en cas de collision (mur, raquette, briques, perdu ...etc...)
  affichage
  effets sonores (au moins un bip-bip ! :P )
 retour Boucle principale

En fait, rien de bien compliqué...

a+ François