Projet Casse-briques

Bonjour à tous,

Je suis nouveau sur le site. Je me suis inscrit car je viens de recevoir mon projet en assembleur à faire.

J'ai commencé l'assembleur depuis 2 mois et notre prof et tout jeune et donc explique pas très bien. On a eu qu'un seul cours d'assembleur traitant du graphisme (affichage d'une palette de couleurs) et là il nous demande de faire un casse-brique (Arkanoid). Tout le monde connaît le jeu.

Voila mon probleme, je n'ai aucune idée pour commencer ce projet. Je ne vois pas comment diriger avec la souris la barre, comment faire rebondir la balle, comment casser les briques...

J'ai absolument besoin d'aide svp.

Si vous avez un cours bien expliqué sur le graphisme en assembleur 8086, je suis prenant car je n'en ai pas trouvé ou si quelqu'un l'a deja fait et peut m'aider.

Merci beaucoup

Julien

salut,


la premiere question a se poser c'est sous quel systeme d'exploitation tu va le creer.
ensuite, tu te documente sur les api fournies par ce systeme d'exploitation.

pour faire rebondir ta balle, tu dois connaitre sa direction et la projeter a l'angle opposé de la perpendiculaire a son point de contact.

      \    |    /
ping  \  |  / pong
_____\|/______


@++

Bonjour,

Je développe sur Windows grâce à MASM ( ce que l'on utilise en cours).

Je ne vois vraiment pas comment coder les rebonds de la balle. Faire le rectangle c'est bon je sais; deplacer la barre à l'aide de la souris cela devrait aller mais les rebonds de la balle et quand elle touche une brique, la supprimer, ça je ne sais pas.

Personne ne l'a deja fait ou a quelques petits bouts de codes concernant un sujet qui ressemble aux casse-briques ?

Merci

Bonjour

Voila, on a deja reussi à afficher le rectangle plus la "raquette". Mais maintenant, j'aimerais savoir comment gérer la raquette avec la souris.

Voici mon programme qui affiche le rectangle et la "raquette" :

Data segment

data ends

Code segment
Assume CS : Code , DS : data

Deb :

MOV AX, data
MOV DS, AX

MOV AH, 0 ;mode VGA
MOV AL, 13h
INT 10h

MOV AX, 0A000h ;Segment écran
MOV ES, AX


MOV AX, 30
MOV BX, 50
MOV CX, 100
mov dx,0
call droite

MOV AX, 30
MOV BX, 50
MOV cX, 120
mov dx,1
call droite

;MOV AX, 30
;MOV BX, 170
;MOV cX, 101
;mov dx,0
;call droite

MOV AX, 130
MOV BX, 50
MOV cX, 120
mov dx,1
call droite

mov AX, 85
mov BX, 165
mov CX, 20
mov dx, 0
call droite

MOV AH,8
INT 21h

MOV AH, 0
MOV AL, 3
INT 10h

MOV AH, 4Ch
INT 21h

droite proc

mov si,bx
mov di,ax
mov ax,320
push dx
mul bx
add di,ax
pop dx
cmp dx,0
je boucle2
boucle:
inc si
mov es:byte ptr[di],95
add di , 320
cmp si,200
jge fin
loop boucle

jmp fin
boucle2:
inc si
mov es:byte ptr[di],95
inc di
cmp si , 320
jge fin
loop boucle2

fin:
ret
droite endp

efface_ecran PROC

MOV DI, 0
MOV CX,320
bigboucle2:
PUSH CX
MOV CX,200
boucle3:
MOV AL, 0
MOV ES:[DI], AL
INC DI
LOOP boucle3
POP CX
LOOP bigboucle2
RET
efface_ecran ENDP

Code ends
END deb


Merci pour votre aide

Salut

Le  tracé du billard  et de la palette est assez maladroit et le manque de commentaire manifeste.

   

Il te  faut d'abord écrire une  procédure qui trace une ligne horizontale  partant d'un point x ,y et d'une longueur L. Cette procédure sera utilisée non seulement pour le bord supérieur et la palette mais aussi pour toutes les briques.

Note que pour tracer une ligne horizontale, si DI contient l'origine, CX la taille  et AL la couleur, il suffit d'écrire :

Boucle : Stosb

Loop boucle     

 

Parce que : Stosb= Mov  ES: byte ptr  [DI],AL  suivi de inc DI.

 

Pour rester fidèle au modèle original, il faut utiliser les flèches horizontales du clavier et non pas la souris. Pour cela l'int 16h avec ah=1 est l'idéal

Dans le segment Data il te faudra loger les constantes : taille de la raquette, hauteur et largeur des briques, hauteur et largeur de la balle ( = pavé) et comme variable l'origine de la  raquette.

Quand tu auras réalisé tout ça, il ne restera plus qu'à programmer le mouvement de la balle.

Une piste : la balle progresse par  pas de  dx et dy. Quand elle rencontre un bord vertical on change le signe de dx et quand elle rencontre une ligne horizontale c'est dy qui doit changer de signe. Elle ne pourra tracer que des parallélogrammes, il faut donc modifier dx et dy en fonction de l'endroit où elle touche la raquette       

Bonne chance et n'oublie pas de prévoir des boucles de délais: on est loin d'un  8080.

Ah désolé pour l'erreur !!!

En fait, c'est un prof qui débute donc ses cours ne sont pas clairs. Donc je ne vois pas trop comment faire le projet enfin toute la classe est dans mon cas. En fait, on a appris vaguement les boucles (suites de fibonacci) affichage de phrases ... mais en ce qui concerne le graphique on n'a rien fait à part l'affichage d'une palette de couleurs.

Donc, la je suis entrain de me prendre la tête avec les conseils de Guilou34le résultat ne suit pas. J'ai quand meme reussi a faire le cadre avec la raquette mais maintenant pour diriger la raquette avec la souris et gérer les rebonds de la balle, c'est mission impossible pour un débutant comme moi.

Je compte vraiment sur votre aide.

Merci beaucoup

Le lien ne marche plus. Est-ce que quelqu'un l'a pris le code, ou le pseudo du membre du forum qui l'a posté, cela m'interesserait car là je galère de trop.

Merci beaucoup

Le code est  sur  http://www.asmfr.com/codes/BOOT-PONG_32086.aspx, il s'assemble avec Tasm.
et fonctionne très bien
Patatalo a raison: je ne vois pas l'intérêt d'un tel projet, d'autant plus qu'étant en mode graphique, il est difficile de le tracer avec debug.
Il te reste  à comprendre boot-pong   et à l'adapter à ton travail
Bonne chance