[Tetris] Dessiner array mode 13h

**denzi** · 09/08/2016, 06h13

Bonjour, je reprends mon Tetris de plus belle.

J'essaye de dessiner un array en Assembleur, il doit faire 20*10, j'utilise l'int13 mode et Dosbox pour simuler.
J'ai déjà le code suivant ; pour être clair, j'essaye de dessiner le blockarray :

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
PROC setVideoMode
    ARG mode RETURNS eax
    mov     eax, [mode]
    int     10h
    ret
ENDP setVideoMode
PROC waitKey
    mov     eax, 0
    int     16h
    ret
ENDP waitKey
PROC start
        sti                             ; Set The Interrupt Flag
        cld                             ; Clear The Direction Flag
        push ds      	; Put value of DS register on the stack
        pop es        ; And write this value to ES
 ; Your code comes here
 call setVideoMode, 13h
 mov     edi, 0a0000h
 ; setup colors
 mov     esi, offset pal     ; set the palette (DAC) address
 mov     ecx, 2 * 3          ; set color 0 and 1 (2 indexes in total, 2 * 3 bytes)
 mov     dx, 03c8h           ; VGA DAC set port
 mov     al, 0               ; set start color index
 out     dx, al
 inc     dx
 rep     outsb
 add     edi, 360 *10 +160
  mov     [dword ptr edi], 1
 call    waitKey
 call    setVideoMode, 3h
        mov eax, 4c00h                  ; AH = 4Ch - Exit To DOS
        int 21h                         ; DOS INT 21h
ENDP start
;北北北北北北北北北北北北北北北北北北北北北北北北北北北北北北北北北北北北北北?
; DATA
;北北北北北北北北北北北北北北北北北北北北北北北北北北北北北北北北北北北北北北?
DATASEG
; Your data comes here
pal db 0, 0, 0, 63, 63, 63
blockarray db 200 dup(1)

Merci pour votre aide

**chrtophe** · 09/08/2016, 08h27

Regardes du coté des modes VESA.

Code :

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

1
2
ax=0x4f02
int 0x10

Voir la doc des fonctions.

Ces modes permettent l'accès en mémoire un pixel=1 valeur 32 bits (avec 1 octet pour chaque couleur).

Il te suffit ensuite de calculer le décalage depuis le début de la mémoire pour afficher tel ou tel pixel.

Attention, utilisable uniquement en mode DOS.

**Forthman** · 09/08/2016, 12h50

"de plus belle"

Mais je salue ta persévérance

(c'est assez rare pour le signaler je trouve)

Chrstophe, je ne suis pas sûr de l'utilité de faire une interface en "haute définition" pour plusieurs raisons :
- le vesa en mode réel c'est chiant (accès à la ram vidéo par buffers de 64Ko)
- un Tetris n'a pas beaucoup d'informations à afficher donc ça tient très bien dans un écran en 320x200
- Si son code est bien écrit, le passage VGA -> VESA ne lui posera pas de problème pour la suite

Bon, alors voyons ce code....
Ok... dis donc ça n'a pas beaucoup bougé depuis la dernière fois

Donc tu veux afficher ton tableau blockarray qui fait 200 octets, en 20 lignes de 10 colonnes c'est ça ?
Peux-tu nous dire sur quoi tu butes exactement ?

**denzi** · 09/08/2016, 12h56

fair 2 buffer (dsl je sais pas comment on dis en francais) fair un buffer de array 200 valeur (20*10) et fair tombé mes block dedans une fois qu'une ligne de 10 sera repli la fair disparaitrer pour ca que jessaye d'abord de dessiné le block de 20*10

**chrtophe** · 09/08/2016, 14h15

le vesa en mode réel c'est chiant (accès à la ram vidéo par buffers de 64Ko)

Avec le mode LFB (Linear Frame Buffer), pas de fenêtre , il faut activer le bit 15 (ajout de 0x4000 au mode) et récupérer l'adresse à l'offset 0x28 du bloc récupéré par la fonction ax=0x4f01 int 0x10. A vérifier siu c'est exploitable en mode réel.

**Forthman** · 09/08/2016, 14h53

@chrstophe : Il faut être en mode FLAT pour pouvoir écrire en direct, et DosBox n'aime pas du tout

@Denzi...
Oui, mais non, il faut que tes demandes soient plus précises.
On ne sais même pas comment tu comptes gérer ce buffer (ça va bien en Français aussi)
Chaque "case" de ton écran de jeu occupe 1 octet.
J'imagine que c'est pour y stocker le type de bloc qui va s'y trouver.
par exemple :
octet = 0 = case vide
octet = 1 = case avec un bloc bleu
octet = 2 = case avec un bloc vert
octet = 3 = case avec un bloc rouge
octet = 4 = case avec un bloc jaune
...
...

Mais je n'en sais rien, c'est ton programme, Tu parles de 2 buffers... pourquoi deux ?

**denzi** · 09/08/2016, 14h56

ben en gros ce que je veux fair je me suis peutetre mal exprimé le blockarray de 200 sera ma case de jeu ( au debu je vais juste travaillé avec 1 seul pixel don 1 bloc sera 4 pixel)
moi jai envie de dessiné un block de 200*10 noir et de fair apparaitre un block tetris dedans pour commencé apres je vais voir comment continué mais dessiné le premier block noir jarriver pas enfin les 200*10 pour testé jai mis un fond decran rouge pour etre sur que c'est bien du un block noir que je vois apparaitre

**Forthman** · 09/08/2016, 16h50

J'avais bien compris, sauf pour les dimensions qui ont changé depuis l'autre post.
C'est vrai que c'est bien de tester petit à petit.

donc en fait tu va avoir un rectangle de 10x20 pixel noirs quelque part dans ton écran rouge

Depuis le début, tu bidouille la palette de couleurs... pourquoi n'utilises-tu pas les couleurs par défaut
de la palette VGA ?
Même si au premier abord elle paraît "à chier" elle comporte pas mal de dégradés et de nuances pratiques
perso je ne me sert que de ça (sauf à faire de l'affichage de photos)

Pour en revenir à ton aire de jeu, le rouge dont tu parles c'est la couleur 0 que tu as initialisée avec du rouge ?
du coup ta couleur noire sera une autre couleur dans la palette c'est bien ça ?
Et du coup tu butes sur quoi exactement ? car dans tes précédents posts, tu savais écrire un point sur l'écran,
avec la formule y*320+x

**denzi** · 09/08/2016, 23h14

Ben simplement comment dessiner le blockarray c'est la que je bute

**denzi** · 09/08/2016, 23h15

Avant je dessinai sans aller chercher de data dans mon data seg

**Forthman** · 10/08/2016, 11h16

Comme d'habitude, il y a plusieurs façons de procéder,
En voici une :

tu as besoin de :
- 1 pointeur pour ton tableau en mémoire qui contient ton aire de jeu
- 1 pointeur pour l'écran (position du pixel)
- une boucle pour la largeur de l'aire de jeu
- une boucle pour la hauteur de l'aire de jeu

pour les pointeurs, tu peux utiliser les registres bx, si, di ou bp (ou n'importe quel registre 32 bits)
j'ai pour habitude d'utiliser si et di car ils ont des instructions spécifiques (et à la base ils ont étés créés pour ça)

le registre SI (Source Index) s'utilise généralement avec le registre de segment DS (Datas Segment)
et le registre DI (Destination Index) s'utilise généralement avec le registre de segment ES (Extra Segment)

Voici le "code" pour afficher ton aire de jeu :

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
 
initialise ES=A000h ; pointe sur le segment video
DI=X_aire_de_jeu + (Y_aire_de_jeu*320) ;  = adresse de debut de l'affichage
SI=blockarray ; = adresse du debut des donnees
CL=20 ; compteur pour les lignes
boucle1:
  CH=10 : compteur de colones
  boucle2:
    AL=DS:[SI] ; recupere l'octet de donnee
    si AL = 0 alors AH couleur = couleur pour donnee = 0
    si AL = 1 alors AH couleur = couleur pour donnee = 1
    si AL = 2 alors AH couleur = couleur pour donnee = 2
    ...
    ...
    ES:[DI]=AH ;  place la couleur choisie dans l''ecran
    SI=SI+1
    DI=DI+1
    CH=CH-1
    si CH>0 jump boucle2
  DI=DI+320-10 ; pour pointer a la premiere colonne de la ligne suivante
  ; on ne touche pas a SI car les donnees sont continues
  CL=CL-1
  si CL>0 jump boucle1
fin

il ne te reste plus qu'à transposer ça en assembleur

**denzi** · 11/08/2016, 11h37

merci jessaye toute a lheure la reponse vers minuit ahahahah

**denzi** · 11/08/2016, 14h15

voila ce que aji pour le moment et jai quelque question

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
; setup colors
		mov     esi, offset pal     ; set the palette (DAC) address
		mov     ecx, 2 * 3          ; set color 0 and 1 (2 indexes in total, 2 * 3 bytes)
		mov     dx, 03c8h           ; VGA DAC set port
		mov     al, 0               ; set start color index
		out     dx, al 
		inc     dx
		rep     outsb
 
		add     edi, 320*10 + 160
 
		mov esi , [offset blockarray]
		mov cl, 20
			drawline:
				mov ch,10
				drawcolum:
 
 
				inc esi
				inc edi
				dec ch
				jnz drawcolum
 
			dec cl
			jnz drawline

la premier parti setup color a vec la quelle je fais le fond d'ecran , je l'ai pris du prof et je la comprend plus ou moin sauf la parti

Code :

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

rep outsb

?
apres le rest c'est moi qui a ecrit

de ton code il y a que tu mas donné il y aune parti que je comprend pas

Code :

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

1
2
3
4
5
6
7
 AL=DS:[SI] ; recupere l'octet de donnee
    si AL = 0 alors AH couleur = couleur pour donnee = 0
    si AL = 1 alors AH couleur = couleur pour donnee = 1
    si AL = 2 alors AH couleur = couleur pour donnee = 2
    ...
    ...
    ES:[DI]=AH ;  place la couleur choisie dans l''ecran

tu veux bien me lexpliqué surtous

Code :

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

 AL=DS:[SI]

merci d'avance

**denzi** · 11/08/2016, 15h46

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
mov esi , offset blockarray
		mov cl, 20
			drawline:
				mov ch,10
				drawcolum:
				mov eax, [ds:esi]
				mov  [edi], eax
				inc esi
				inc edi
				dec ch
				jnz drawcolum
 
			add edi ,320-10	
			dec cl
			jnz drawline

j'y suis pressque mais j'ai limpression qu'il me manque quelque pixelles vers la fin quelquun sais me dire pourquoi ?

**denzi** · 11/08/2016, 16h20

quand je prend mon blockarray db 203 a la place de 200 ca marche parfaitement mais je ne sais pas pourquoi ?

**denzi** · 11/08/2016, 22h56

jai réussi a arangé se premier probleme en remplacent eax par al :p

**chrtophe** · 12/08/2016, 08h55

utilises plutôt la fonction

Code :

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

rep movsb

(e)si contenant l'adresse source
(e)di contenant l'adresse destination
(e)cx contenant le nombre d'octets à copier

Pour un tableau, on utilises la notion de ligne/colonne, en assembleur, on a une seule dimension, toutes les lignes sont donc les une derrière les autres. Pour se placer ligne 2 colonne 3, il faut utiliser un décalage (offset), si ton tableau est de 10x10, la ligne 2 colonne 3 correspondra au décalage 10*2+3 par rapport à l'adresse de début de tableau.

**denzi** · 12/08/2016, 08h57

je dois utiliser ta fonction a la place de quelle ligne de code ?

**chrtophe** · 12/08/2016, 09h23

Tu charges le contenu de esi dans eax, copie le contenu de eax dans edi, et incrémentes esi puis edi (lignes 6 à 9) ce que fait le mnémonique movsb, le rep devant signifie qu'il faut répéter la commande selon la valeur dans ecx. La commande movsb incrémente automatiquement esi et edi. C'est plus simple non ?

Par ailleurs, tu utilises ch comme premier compteur, et cl pour un second, je ne ferais pas comme cela. Ca me parait source à erreur quand on débute, utilises plutôt un autre registre comme (e)dx.

edi contient l'adresse vidéo je supposes ?

**Forthman** · 12/08/2016, 13h00

Code :

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

rep outsb

déjà, un petit lien vers l'instruction http://www.gladir.com/LEXIQUE/ASM/outsb.htm
pour voir comment elle fonctionne.

outsb est en fait l'instruction out + s (plusieurs) + b (byte)
ça fonctionne aussi avec d'autres instructions en terminaison ...sb ou ...sw (word 16 bits) ou ...sd (double 32bits)+s +b)

le préfixe "rep" indique que cette instruction doit être exécutée CX fois (le registre cx sert de compteur)
(il existe d'autres préfixes de répétition)

par contre, là où l'instruction out envoie la valeur de AL/AX dans le port, outsb trouve cette valeur à l'adresse DS:[SI]
c'est pour ça que SI est initialisé avec l'adresse de la palette de couleurs
à chaque envoie, la valeur de SI va être incrémentée (à cause du STD) afin de ne pas envoyer toujours le même octet.

Il faut aussi savoir (un peu) comment fonctionne la carte VGA.

l'instruction out (qui est l'opcode à la base de outsb) permet d'envoyer une valeur 8 ou 16 bits sur
un port d'entrée/sortie. Le numéro du port est placé dans DX et ici les adresses utilisées sont 3C8h et 3C9h
ce sont des ports de la carte VGA qui permettent d'avoir accès à la palette de couleurs 8 bits
3C8h reçoit le numéro de la couleur ( 0 à 255)
3C9h reçoit les composantes de couleurs RVB
pour envoyer les 3 composantes, on envoie simplement ces dernières sur ce même port, les
unes après les autres,et la carte les dispatche dans les bonnes composantes.
par contre, si on envoie 3 composantes de plus, elles seront attribuées à la couleur suivante,
et ainsi de suite...

Voilà pour rep outsb

Je ne comprends pas pourquoi tu utilises des registres 32 bits systématiquement car ton code est en 16 bits.
certaines fonctions (comme le outsb) utiliseront les registres si et di et ignoreront les 16 bits de poids fort

D'ailleurs, tu as corrigé ton erreur en utilisant un registre 8 bits (al) et pas 32 (eax) pour lire une valeur 8 bits

Tu as choisi de recopier directement le contenu de ton tableau sur l'écran.
dans ce cas, effectivement le conseil de chrstophe est bienvenue car l'instruction movsb te permettrait
d'écrire toute une ligne (10 pixels) en une seule ligne de code.

Par contre, tu devras utiliser du code compatible 8086
dans ton programme, tu utilises edi pour stocker l'adresse vidéo sur 32 bits, et l'instruction movsb utilise
DS:SI pour la source et ES

I pour la destination (donc avec ES=A000h)

Enfin, si tu veux faire évoluer ton programme et faire afficher plus que des pixels, tu ne pourras plus faire
avec movsb, et tu devras gérer chaque type de case.
d'où mon exemple avec : si AL=1 alors AH=1 ...etc...
qui pourra être transformé en :
SI AL=0 alors affiche case vide
SI AL=1 alors affiche brique rouge
SI AL=2 alors affiche brique verte
...
SI AL=20 alors affiche pave blanc, remplace valeur par 19
SI AL=19 alors affiche pave gris clair, remplace valeur par 18
SI AL=18 alors affiche pave gris, remplace valeur par 17
... ce qui te permettra par exemple de traiter la disparition d'une ligne par un flash du blanc au noir

pour ce qui est de l'utilisation de registres 8 bits dans les boucles, je ne vois pas en quoi
ça peut poser problème, tant qu'on est bien conscient que l'on traite des valeurs 8 bits et
donc qui s'étendent de 0 à 255 (ou de -128 à +127 en signé)
bien sûr, s'il veut utiliser l'instruction LOOP (qui utilise cx) ça va poser problème, mais sinon ça roule.
Et puis des registres, on n'en a jamais trop sur une x86

[Tetris] Dessiner array mode 13h

x86 16-bits Assembleur

Discussions similaires

Partager

Partager