Posté le 08/04/2006 à 14:15 Membre depuis le 14/02/2006, 1844 messages
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
Posté le 12/04/2006 à 18:52 Membre depuis le 10/10/2004, 541 messages
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, smile 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 grin

Posté le 12/04/2006 à 18:53 Membre depuis le 10/10/2004, 541 messages
Et si t'as besoisn d'aide, hésite pas
Posté le 13/04/2006 à 07:45 Membre depuis le 14/02/2006, 1844 messages
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??
Posté le 13/04/2006 à 07:56 Membre depuis le 19/12/2002, 480 messages
Perso, je préfère la saferam3 (enfin, moi je dis ça, c'est surtout pour rajouter mon grain de sel inutilement, en fait).
Posté le 13/04/2006 à 08:06 Membre depuis le 14/02/2006, 1844 messages
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
Posté le 13/04/2006 à 08:15 Membre depuis le 10/10/2004, 541 messages
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..
Posté le 13/04/2006 à 08:17 Membre depuis le 10/10/2004, 541 messages
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 variablessmile
Et pour les valeur des touche du directinput, tu peux trouver ça icismile http://paxl.org/~tift/tuts/chapitre7.htm
Posté le 13/04/2006 à 19:22 Membre depuis le 14/02/2006, 1844 messages
Merci pour le lien top

En fait saferam1+1 ca revient à mettre saferam2 ???
Posté le 13/04/2006 à 21:56 Membre depuis le 10/03/2003, 641 messages
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 smile

et saferam2 est une autre définition, c'est uen autre adresse mémoire, où tu peux aussi stocker des trucs
Posté le 14/04/2006 à 07:08 Membre depuis le 14/02/2006, 1844 messages
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 grin , je reposterais lorsque je ferais une nouvelle version de mon pong happy
Posté le 14/04/2006 à 12:44 Membre depuis le 10/03/2003, 641 messages
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 ? smile
Posté le 14/04/2006 à 17:18 Membre depuis le 10/10/2004, 541 messages
oui c'est bien 768, c'est pratique pour scroller d'ailleur, c'est la même taille que le graphbuffersmile
Posté le 16/04/2006 à 20:06 Membre depuis le 14/02/2006, 1844 messages
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 mourn)
- 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 hehe
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
Posté le 17/04/2006 à 15:14 Membre depuis le 10/10/2004, 541 messages
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 limitesgrin

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 continuationsmile
Posté le 17/04/2006 à 15:31 Membre depuis le 14/02/2006, 1844 messages
Bon ok merci, je vais arranger ca smile

>ça sert a choisir le port que tu veux
euh ?? confus grin
Posté le 17/04/2006 à 16:36 Membre depuis le 10/10/2004, 541 messages
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
Posté le 17/04/2006 à 17:31 Membre depuis le 19/12/2002, 480 messages
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.
Posté le 18/04/2006 à 12:18 Membre depuis le 10/10/2004, 541 messages
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
Posté le 18/04/2006 à 18:27 Membre depuis le 14/02/2006, 1844 messages
Oui d'accord smile , 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 grin)
Posté le 19/04/2006 à 07:52 Membre depuis le 19/12/2002, 480 messages
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).
Posté le 19/04/2006 à 09:36 Membre depuis le 09/07/2003, 21783 messages
la fonctionement est pourtant simple pour un geek: ça marche pareil qu'avec ta pile de vétements gni
Posté le 19/04/2006 à 16:34 Membre depuis le 14/02/2006, 1844 messages
Merci pour ton aide joe14 (et aussi pour very grin) , je vois déja mieux. smile top
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 ??
Posté le 19/04/2006 à 21:30 Membre depuis le 10/03/2003, 641 messages
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 smile
Posté le 20/04/2006 à 07:58 Membre depuis le 19/12/2002, 480 messages
J'avais entendu parler de 200 octets ou 200 adresses (400 octets), je sais plus trop.
Posté le 20/04/2006 à 10:00 Membre depuis le 09/07/2003, 21783 messages
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...)

Posté le 20/04/2006 à 12:35 Membre depuis le 19/12/2002, 480 messages
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.
Posté le 21/04/2006 à 19:11 Membre depuis le 14/02/2006, 1844 messages
Je vois à peu près l'utilité mais j'admet que pour l'instant c'est quand même assez chaud grin, peut etre que plus tard je comprendrais mieux smile .
Posté le 22/04/2006 à 12:40 Membre depuis le 19/12/2002, 480 messages
Non, franchement, c'est facile, et trés utile pour faire des routines. Tu trouves ça chaud parce que je m'explique mal smile
Posté le 22/04/2006 à 17:48 Membre depuis le 14/02/2006, 1844 messages
Meuh non roll tongue wink

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