Un "pong" qui ne marche pas" - Page 1

Bonjour,

J'ai fait un "pong" mais y marche pas parceque j'arrive pas à le quitter ni à bouger la balle, SVP aidez moi parceque la je patoge



Voici le code (ps: comme il y a des bugs partout je déconseil fortement de le mettre sur votre calculatrice):

.nolist
#include "ion.inc" ;the area in itallics is the standard
#define x_raquette saferam1
#define y_raquette saferam2
#define x_balle saferam3
#define y_balle saferam4

.list ;ion header. you can change the name

#ifdef TI83P ;displayed by ion and the 2 labels
.org progstart-2
.db $BB,6D
#else
.org progstart
#endif
ret
jr nc,lblStart ;jumps to the label lblstart
.db "Pong",0 ;The title displayed by ION

lblStart:
ld hl,txtStartup
bcall(_puts)
bcall(_getkey)
ld a,50 ;tu met
ld (x_raquette),a ;tes variables
ld (y_raquette),a ;au point que tu veux, ici 50
ld a,10 ;tu met
ld (x_balle),a ;tes variables
ld (y_balle),a ;au point que tu veux, ici 50
directinput:

bcall(_cleargbuf) ;effacer le graphbuffer





ld b,8 ;
ld a,(y_raquette) ; affiche ta raquette
ld l,a ;
ld a,(x_raquette) ;
ld ix,raquette ;
call Ionputsprite ;
ld b,8 ;
ld a,(y_raquette) ; affiche ta raquette
ld l,a ;
ld a,(x_raquette)
add a,8
ld ix,raquetteb ;
call Ionputsprite ;

ld b,4 ;
ld a,(y_balle) ; affiche la balle
ld l,a ;
ld a,(x_balle) ;
ld ix,balle ;
call Ionputsprite ;
call IonFastCopy ;


ld a,$FF ;
out (1),a ;
ld a,$FE ;
out (1),a ;routine de directinput, tu choisis les touches que tu veux scanner, j'ai pris
in a,(1) ; haut et bas pour bouger le raquette de bas en haut , j'ai pas mis gauche droite expres
bit 2,a ; pour que tu le fasse, par contre, la touche gauche permet de quitter le jeu pour l'instant
call z,gauche ;
bit 1,a ;
call z,quitter ;
bit 0,a ;
call z,droite ;
jp directinput

gauche:
push af ; met a dans la pile pour pouvoir continuer a faire marcher le directinput
ld a,(x_raquette)
inc a
ld (x_raquette),a
pop af ;retire la valeur de la pile et la stoque dans a
ret

droite:
push af
ld a,(x_raquette)
dec a
ld (x_raquette),a
pop af
ret

balle:
.db %0110
.db %1011
.db %1111
.db %0110

raquette:
.db %01111111
.db %10000000
.db %11111111
.db %01111111
.db %00000000
.db %00000000
.db %00000000
.db %00000000

raquetteb:
.db %11111110
.db %00000001
.db %11111111
.db %11111110
.db %00000000
.db %00000000
.db %00000000
.db %00000000

txtStartup:
.db " -------- "
.db " | Pong | "
.db " -------- "
.db " Version 0.1",0


quitter:
ret
.end


END

bon déjà, pour les variable ^^
faut définir tes variables dans la saferam1 pour les 3 de préférences.
ce qui donne un truc comme ça
#define x_raquette saferam1
#define y_raquette x_raquette+1
#define x_balle saferam3 y_raquette+1
#define y_balle saferam4 x_balle+1

les +1 montrent que la variable se trouve apres n octet (ici n = 1) dans la saferam.
Pour un variable d'un octet (256 valeurs), tu met +1 etc...
par exemple, : #define y_raquette x_raquette+1 veux dire que ta variable y_raquette se trouve a un octet plus loin que x_raquette. autrement dis, tu a laissé un octet de place pour x_raquette, donc x_raquette est un octet. Bon j'espere que c'est assez clair, mais je pense pas, j'écris vite la ...
Ensuite, essai de faire juste le moteur du jeu et de facon claire.(met pas de texte ni rien pour le début)
c'est-à-dire :
pour commencer, essai de faire pour que ton "jeu" affiche juste des curseur qui bouge (avec limites pour les curseurs)
donc, fais déjà un programme qui fait en gros :

_effacer les graphbuffer
_regarder si les touche pour bouger les curseurs ont été activées.
_si activées : vérifier les conditions de limites
_si les conditions sont bonnes, faire les changements des variables necessaires/ sinon, passer é l'étape suivante.
_afficher les sprites sur le graphbuffer
_afficher le graphbuffer à l'écran
_retourenr au debut.


Ensuite, quand tu auras fais cette étape, ajoute la balle qui ne fais au début que ricochet sur les murs sans conditions ni rien (en gardant les curseur s toujours)


Bon, voila en gros ce qu'il faut que tu fasse pour commencer, sans que ça devienne une bouillit

Et si t'as besoisn d'aide, hésite pas

Ce serait pas plutôt ca par hasard

#define x_raquette saferam1
#define y_raquette saferam2 x_raquette+1
#define x_balle saferam3 y_raquette+1
#define y_balle saferam4 x_balle+1


En tout cas merci beaucoup pour ton explication, je essayer de faire plus propre,


Juste 2 petites questions :
-Comment ca ce fait que ca ne quitte pas,
-ou puis je trouver un tableau avec la valeur de chaque touche??

Perso, je préfère la saferam3 (enfin, moi je dis ça, c'est surtout pour rajouter mon grain de sel inutilement, en fait).

On peut mettre celle qu'on veut, si je met ca ca marche??

#define x_raquette saferam1
#define y_raquette saferam1 x_raquette+1
#define x_balle saferam1 y_raquette+1
#define y_balle saferam1 x_balle+1

Non! En fait tu as 2 possibilité, soit tu te base sur le début de la saferam, soit sur la variable précédente, donc les 2 truc la revienne au même :
#define x_raquette saferam1
#define y_raquette x_raquette+1 => 1 octet apres x_raquette
#define x_balle saferam3 y_raquette+1 => 1 octet apres y_raquette
#define y_balle saferam4 x_balle+1 => etc..

et

#define x_raquette saferam1
#define y_raquette saferam1+1 => 1 octet apres la saferam 1
#define x_balle saferam1+2 => 2 octet apres la saferam 1
#define y_balle saferam1+3 => etc..

et tu peux aussi mettre tes variable dans la saferam2 ou saferam3, c'est une question de place apres. Perso, je prend la saferam1 pour pouvoir scroller et saferam3 aussi pour mes variables
Et pour les valeur des touche du directinput, tu peux trouver ça ici http://paxl.org/~tift/tuts/chapitre7.htm

Merci pour le lien

En fait saferam1+1 ca revient à mettre saferam2 ???

non !

saferam1 est une définition, ca correspond à une adresse mémoire
par le compilo comme valeur de saferam1 +1saferam1+1 est compris
càd l'adresse de saferam1, une case mémoire plus loin

et saferam2 est une autre définition, c'est uen autre adresse mémoire, où tu peux aussi stocker des trucs

Ah d'accord je comprend, mais je suppose qu'il y a quand même une limite

si je met saferam1+1+1+1+1+1+1+1+1+1+1+1
ou encore saferam100

En tout cas merci pour tous vos conseil, c'est sympa de m'aider, promis j'arrete les questions après , je reposterais lorsque je ferais une nouvelle version de mon pong

saferam1 doit faire 768 octets (càd de saferam1 à saferam1+767 tu peux tout utiliser)
mais attention, encore une fois saferamX n'est qu'une définition (regarde dans ion.inc), et -si je ne m'abuse- y'a que saferam1, 2, 3, 4 et 5 qui sont définies (càd que des gens ont vérifié que les adresse qu'ils mettaient comme définition des ces saferam2 étient libres et sûres)
donc saferam100 n'a pas de sens, mais saferam1+99 si

tu vois ?

oui c'est bien 768, c'est pratique pour scroller d'ailleur, c'est la même taille que le graphbuffer

En fait chaque saferam à un role particulier si je comprend bien ??

Bon alors comme promis je donne mon nouveau code, mais j'ai 2 problème:
- Déja je n'arrive pas à fixer les limites ( j'ai fait un truc mais ca ne marche pas du tout )
- Comment on fait pour quitter le prg??

.nolist
#include "ion.inc"
#define x_raquette saferam1
#define y_raquette saferam1+1
#define x_balle saferam1+1+1
#define y_balle saferam1+1+1+1

.list

#ifdef TI83P
.org progstart-2
.db $BB,6D
#else
.org progstart
#endif
ret
jr nc,lblStart
.db "Pong",0


lblStart:
ld hl,txtStartup
bcall(_puts)
bcall(_getkey)
ld a,47
ld (x_raquette),a
ld (y_raquette),a
ld a,10
ld (x_balle),a
ld (y_balle),a



directinput:
bcall(_cleargbuf)
ld b,8
ld a,(y_raquette)
ld l,a
ld a,(x_raquette)
ld ix,raquette
call Ionputsprite

ld b,8
ld a,(y_raquette)
ld l,a
ld a,(x_raquette)
add a,8
ld ix,raquetteb
call Ionputsprite

ld b,4
ld a,(y_balle)
ld l,a
ld a,(x_balle)
ld ix,balle
call Ionputsprite
call IonFastCopy


ld a,$FF ;;;;
out (1),a ;;
ld a,$FE ;; Ca j'ai pas trop saisi à quoi ca servait
out (1),a ;;
in a,(1) ;;;;
cp 253
call z,droite
cp 251
call z,gauche
jp directinput


gauche:
ld a,(x_raquette)
cp 1
jp z,directinput
push af
ld a,(x_raquette)
inc a
ld (x_raquette),a
pop af
ret


droite:
ld a,(x_raquette)
cp 70
jp z,directinput
push af
ld a,(x_raquette)
dec a
ld (x_raquette),a
pop af
ret


balle:
.db %0110
.db %1011
.db %1111
.db %0110


raquette:
.db %01111111
.db %10000000
.db %11111111
.db %01111111
.db %00000000
.db %00000000
.db %00000000
.db %00000000


raquetteb:
.db %11111110
.db %00000001
.db %11111111
.db %11111110
.db %00000000
.db %00000000
.db %00000000
.db %00000000


txtStartup:
.db "----------------"
.db "| Pong |"
.db "----------------"
.db "| Version 0.1 |"
.db "----------------",0



.end END

tont ruc pour fixer les limites ne marche pas. En effet, tu fais cp 1 ; jp z directinput. Or tu as fais un call avant, donc pour les limites, il te suffit de faire : gauche:
ld a,(x_raquette)
cp 1
jp z,fin_direction
[...]
fin_direction:
ret

Voila, c'est pas plus compliqué que ça pour les limites

Sinon , "ld a,$FE ;; Ca j'ai pas trop saisi à quoi ca servait" ça sert a choisir le port que tu veux scanner.
Voila, bonne continuation

Bon ok merci, je vais arranger ca

>ça sert a choisir le port que tu veux
euh ??

oups, nan ça sert a choisir le groupe du clavier qu'on veut scanner. Ici, $FE est le groupe avec les 4 flèches directionnelles

Pour quitter le programme, il suffit de faire un ret lorsque l'adresse contenue en haut de la pile est l'adresse qui y a été stockée par la TI lorsqu'elle a lancé le programme (en gros, il faut que les "call" et les "push" soient équilibrés par rapport aux "ret" et "pop" (en supposant que tu n'as pas modifié l'adresse du SP) au moment où tu exécutes le "ret" de sortie.

sinon chaques saferam n'est pas destiné a quelques choses en particulier, mais ils on eu taille bien particulière, à toi apres de les utiliser pour ce que tu veux

Oui d'accord , mais sinon les "pop" "rush" et "ret" ca veux dire quoi exactement. (moi on m'a dit qu'il y avait une histoire de pile mais ca j'ai copletement rien compris )

la pile, c'est une zone de la mémoire où le remplissage s'effectue en "empilant" les données. C'est-à-dire que lorsque tu fais "push hl", par exemple, le contenu de hl est sauvé dans le "haut" de la pile. Si ensuite tu fais "push de", le contenu de de est "empilé" par dessus. Donc, si tu veux récupérer le contenu de hl que tu as sauvegardé et le mettre dans bc (par exemple), tu dois faire "pop rr" (avec rr équivalent de hl, de ou bc, attention, la valeur précédente de rr sera perdue) puis "pop bc", car on ne peut récupérer que la dernière adresse en date. Donc, on sort d'abord l'adresse sauvée en dernier, puis celle qu'on veut (sauvée en avant-dernier).

Bon, c'est assez flou là, donc n'hésite pas à poser des questions (je rajouterai d'autres infos, notamment le fonctionnement des call-ret plus tard).

la fonctionement est pourtant simple pour un geek: ça marche pareil qu'avec ta pile de vétements

Merci pour ton aide joe14 (et aussi pour very ) , je vois déja mieux.
En fait la pile c'est une zone de mémoire comme la zone pour les registres ou la saferam??.

Ps: on peut en empiler combien des données comme ca ??

oauis c'est uen zone de mémoire, enfin c'ets aps très pratique hein : - les appels entassent l'adresse de retour dessus
- si tu veux accéder à un élément, faut tout dépiler puis rempiler, autrement dit on s'en sert jamais comme une zone libre

ca a une taille limite, en effet, mais je saurais pas te dire quelle taille c'est
enfin si tu n'appelles pas 3000 fonctions imbriquées, tout devrait bien aller

J'avais entendu parler de 200 octets ou 200 adresses (400 octets), je sais plus trop.

c'ets aps très pratique hein

Bha c'est pas du tout pratique pour s'en servir d'une mémoir 'normale', mais super pratique lorsque c'est utilisé....dans son domaine d'utilisation utile.
( par contre j'ai quasi-jamais codé en asm z80, donc bon, les caractéristiques spécifiques...)

A propos du fonctionnement des "call"-"ret", voilà un exemple :





$00C0 ld bc,$12D8
$00C3 call jeanpaulrouves
$00C6 suite du programme...




jeanpaulrouves:
$0107 ex hl,de
$0108 ret

Voilà, donc, quand "call jeanpaulrouves" s'exécute, il enregistre $00C6 (l'adresse mémoire suivant "call jeanpaulrouves'dans la pile et mets le pointeur d'exécution à l'adresse du label "jeanpaulrouves", comme un "jp jeanpaulrouves"). Ensuite, il exécute les lignes à partir de "ex hl,de" jusqu'à "ret". "ret" fais une sorte de "pop pointeur d'exécution", ainsi, on retourne à l'adresse qui était stockée dans la pile ($00C6). Les "call"-"ret" sont trés pratiques pour réaliser des sortes de sous-programmes.

Je vois à peu près l'utilité mais j'admet que pour l'instant c'est quand même assez chaud , peut etre que plus tard je comprendrais mieux .

Non, franchement, c'est facile, et trés utile pour faire des routines. Tu trouves ça chaud parce que je m'explique mal

Meuh non

A propos est ce qu'il y a un equivalant de if, while, ou for...