Shoot 'm up - Page 1

Voila g fait un prgm de course un peu futuriste avec des bouclier energetique, et autres bizarerie du genre mais le probléme que j'ai outre une lenteur exaspérente (que j'ai compensé par une augmentation extréme de la difficulté du jeu) c'est que je n'arrive pas à faire un tir, par exemple en appuyant sur 2nd faire en sorte que le faiseaux tir, et détruise le vaisseau ennemi, pour le moment j'ai esseyer avec sa mais sa ne fait qu'un tir et il fait disparaitre l'adversaire mais, sa le rend juste invisible:

début du prog,

:While 1
:If W=1:Then:U+1 (pour faire avancer le tir)
:If U>15:Then:Output(T,U," ")
:...
:Output(A,B,">" (A et B sont déterminé en fonction des mvt du vaisseau)
:getKey->K
:If K=21 and W=0:Then:1->W:A->T:B+1->U:Output(T,U,"-") (Je met B+1 pour que le tir apparaisse devant le vaisseau et W me sert pour faire une vérification de l'activité du tir, savoir si il est tiré ou non)
:...
:If T=E and U=F:Then:Output(E,F," "):Output(T,U," "):0->W (pour faire disparaitre le vaisseau ennemi et le tir)
:...

Voila si vous pouvez m'aider merci d'avance ^^

Salut
J'ai du mal a comprendre ton programme (j'ai comme l'impression qu'il manque beaucoup de ligne)
Par contre si j'ai bien compris, pour faire disparaître le vaisseau il faut que, tu enregistre que le vaisseau a été détruit (dans une liste ou dans une variable (dépend du nombre)) et que tu n'affiche le vaisseau que s'il n'a pas été détruit
En gros

(presence_vaisseau)=1
...
If (presence_vaisseau)
Output(A,B,">")
.......
If T=E and U=F
then
Output(E,F," ")
Output(T,U," ")
0->W
0->(presence_vaisseau) End

évidement (presence_vaisseau) c'est une variable/liste que tu choisis (en fonction de ce qu'il te reste disponible)

Concernant la lenteur
Sache quand même que les programmes écrit en basic ne sont jamais d'une rapidité immense (du au fait que chaque instruction écrite sont traduite en temps réel en instruction asm, ça fait pareil avec mes scripts pour linux sur le pc)
Maintenant il y a peut être des optimisations qui peuvent être faite

Comme un
If toto=1
then
25->tata
End
qui peut être remplacer par
If toto
25->tata

(j'ai mis en forme ta source)

Comme un
If toto=1
then
25->tata
End
qui peut être remplacer par
If toto
25->tata

Je suis pas sur que ça te fasse gagner de la vitesse, mais seulement quelques octets. Le truc auquel il faut faire attention dans un programme c'est surtout les boucles males faites du genre avec des labels, etc...
Par éxemple :

Lbl 1
While 1
If [truc]:Goto 1
[...]
End

Ici le code n'est pas bon car dans le cas ou le truc est égale à 1 on saut au label sans que la boucle 'While' n'est rencontrer le 'End' (et par ailleur on peut remplacer 'While 1' par 'For(I,1,1E99)', d'après very c'est un peu plus rapide ).

Ok merci pour votre aide ^^
Mais je vais vous postez mon prog entier pour que vousd puissiez cernez tout le pb. paske c'est un peu plus compliqué que sa mais sa va me prendre du tps paske je l'ai fait à la main sur la calculette et que du coup je doit tout le taper au fur et à mesure mais bon je vous le post et comme c'est mon premier prog si vous pouvez m'aider à trouver et résoudres les quelques pb qu'il doit y avoir sa m'arrengerait bcp ^^.

Voila je vous post le début du prgm et je vous envois la suite dés que je l'ai écrite sur l'ordi ^^
Si vous repérez des bug n'hésitez pas à me le dire ^^


:Clrhome:fix 0
:Clrhome
:17->Dim(L1)
:15->T
:0->Z
:1->G
:0->V
:0->W
:2->R
:5->A
:1->B
:0->D
:3->E
:4->H
:6->P
:0->J
:0->X
:Clrhome
:for(Y,5,16)
:Output(4,5,"Race 1.0"
:Output(4,4," "
:for(C,1,100)
:End
:End
:For(O,1,200)
:End
:Clrhome
:Output(4,1,"Press graph for"
:Output(5,1,"Help screen"
:Output(8,1,"Press enter..."
:Pause
:Clrhome
:Output(4,1,"Last score:"
:Output(4,12,S
:Output(8,1,"Press enter..."
:Pause
:0->S
:Clrhome
:Output(4,1,"Best score:"
:Output(4,12,Théta (c'est le symbol aprés le Z quand on utilise la commande Alpha)
:Output(8,1,"Press enter..."
:Pause
:Clrhome
:
:15->I
:15->Q
:15->F
:Output(1,2,"OFF"
:Lbl X
:While 1
:
:If J (n'est pas églal à) 1 and R>2:Then:2->R:End
:If S>50 and S<100:Then:14->T:1->G:End (c'est pour augmenter la vitesse à laquelle augmete le score et la difficulté du jeu)
: ... (Il y a plusieur autres lignes comme celle du dessus alors je passe directement à celle aprés car seul les valeurs changes)
:If v<0:Then:0->W:0->V:Output(1,2,"OFF":End
:
:If W (n'est pas églal à) 1: Then:V+0.1->V:End
:
:If V>100:Then:100->V:End
:Ouput(2,1,"----------------"
:Ouput(7,1,"----------------"
:
:Output(E,F," "
:Output(H,I," "
:Output(P,Q," "
:
:I-1->I
:
:If I<1:Then:randint(3,6)->H:End
:If I<1:Then:T->I:End
:
:Q-1->Q
:
:If Q<1:Then:randint(3,6)->P:End
:If Q<1:Then:T->Q:End:
:
:F-1->F
:
:If F<1:Then:randint(3,6)->E:End
:If F<1:Then:T->F:End
:
:Output(P,Q,"X")
:Output(E,F,"X")
:Output(H,I,"X")
:Output(8,13," ")
:Output(8,10,"Dep")
:Output(8,13,R)
:Output(1,12," ")
:Output(1,6,"score")
:Output(1,12,S)
:Output(8,1," ")
:Output(8,1,"ENE:")
:Output(8,5,V)
:Output(A,B,">")
:
:Getkey->K
:
:If K=25:Then:A-1->A:Output(A+1,B," ":If X (n'est pas églal à) 1: Then:R-1->R:End:End
:If R=-1:Then:A+1->A:R+1->R:End
:If K=34:Then:A+1->A:Output(A+1,B," ":If X (n'est pas églal à) 1: Then:R-1->R:End:End
:If R=-1:Then:A-1->A:R+1->R:End
:If A<3:Then:3->A:End
:If B<1:Then:1->B:End
:If A>6:Then:6->A:End

Déjà pourquoi il y a trois 'ClrHome' au départ ? Un seul suffit.

Après, comme tu semble vouloir faire patienter le programme avec des boucles 'For(' (et à certain moment tu peut les remplacées par un 'Pause ' pour stopper le programme), utilise au moins la même variable puisqu'elle prendra simplement la valeur initial du 'For(' jusqu'à la valeur final.

Ensuite, dans la boucle 'While 1' (qui n'a pas de End ici, mais ça t'as seulement du l'oublier je pense), évite de mettre dedans les trucs à afficher qui sont 'statiques' du genre :

:Output(8,13," ")
:Output(8,10,"Dep")
:Output(1,12," ")
:Output(1,6,"score")
:Output(8,1," ")
:Output(8,1,"ENE:")

Car ça ralentit vachement le programme (surtout si tu n'as de ClrHome dans la boucle enfaite). Et le reste j'ai pas tout lu mais je trouve qu'il y a beaucoup de tests dans ta boucle...

Hoshi_ (./5) :
:for(Y,5,16)
:Output(4,5,"Race 1.0"
:Output(4,4," "
:for(C,1,100)
:End
:End
:For(O,1,200) :End

là il y a quelque chose que je ne comprend pas soit utiliser "Pause" soit ne fait que un seul for (C,1,500):End.

Hoshi_ (./5) :
:Output(4,1,"Last score:" :Output(4,12,S

Là je serai toi je sauvegarderai le score dans une liste (si tu lance un autre programme qui vient toucher a S :/
utput(4,12,lRACE(1)
pis au moment de sauvegarder le score si il est dans la variable S, tu met S->lRACE(1)
Il en va de même pour le meilleur score. (Tu pourrais même sauvegarder les 3 derniers par exemple )

Hoshi_ (./5) :
:If S>50 and S<100:Then:14->T:1->G:End (c'est pour augmenter la vitesse à laquelle augmente le score et la difficulté du jeu): ... (Il y a plusieurs autres lignes comme celle du dessus alors je passe directement à celle après car seul les valeurs changes)

ça ça doit ralentir

Hoshi_ (./5) :
:I-1->I
:
:If I<1:Then:randint(3,6)->H:End
:If I<1:Then:T->I:End
:
:Q-1->Q
:
:If Q<1:Then:randint(3,6)->P:End
:If Q<1:Then:T->Q:End:
:
:F-1->F
:
:If F<1:Then:randint(3,6)->E:End:If F<1:Then:T->F:End

les 6 If peuvent devenir 3
If I<1 : Then :randint(3,6)->H:T->I:End
If q<1 ....


Voilà pour une première lecture.
Il doit rester encore des modifications a faire vu que j'ai fait une lecture rapide (très rapide)

MulX (./7) :

Hoshi_ (./5) :
:If S>50 and ST:1->G:End (c'est pour augmenter la vitesse à laquelle augmente le score et la difficulté du jeu) : ... (Il y a plusieurs autres lignes comme celle du dessus alors je passe directement à celle après car seul les valeurs changes)

ça ça doit ralentir

surtout que pour des fonctions aussi simples (escalier –à pas et hauteur constant je suppose ?–) on fait la même chose bien plus efficacement: avec un simple compteur, des int( et divisions, du genre 15-int(S/50) -> T ici si je n'ai pas lu trop vite.
Sur Ti z80 on gagne réellement *beaucoup* de temps à faire de calculs plutôt que des tests...( c'est du à la foi à la bonne implémentation des calculs et la mauvaise du Ti-basic..)
Mais bon c'est pas très immédiat pour un codeur non confirmé.

par contre le minimum très simplement réalisable et compréhensible c'est de tester les valeurs (si =50, 100, 150 ..) et non les intervals.. (test plus simple et pas d'affectation à chaque fois..)
Enfin y'a pleins de bricolages intermédiaires plus efficaces réalisables. ( du genre faire un seul teste avec une variable 'borne' que l'on implémente de l'écart suivant lorsque le teste est vérifié et que l'on fait un truc du genre T-1->T, etc. )


Bon j'ai pas vraiment lu attentivement, (à ce que j'ai vu tout ou presque est très largement améliorable. Je trouve qu'il y a beaucoup de variables et de tests.. ), j'ai juste rebondi sur la remarque précédente... c'était quoi l'objectif de Hoshi_ ?

Bon ensuite les jeux à défilement, faut de préférence utiliser l'astuce du Disp qui fait défiler l'écran tout seul si on se permet le mode texte ( seul moyen pour être un peu rapide, en tous cas de ce que j'ai fait / j'ai vu.).
Dans un vieux jeux que j'avais codé comme ça en 1reS, Racspeed je crois, ça arrivait à avancer assez vite – je veux dire réellement une impression de vitesse–sur 82. (Un seul if dans le programme, celui pour quand on est mort ). Et encore j'étais pas à mon meilleurs à l'époque, suis sur que ça doit s'optimiser..

Avec le Disp c'est vraiment plus rapide qu'avec le Output, rien qu'en faisant :

For(A,0,100
Disp "----------------"
End

On fait pareil (mais en plus rapide et avec le scroll) que :

For(A,0,100
For(B,1,8
Output(B,1,"----------------"
End
End

'fin bon, après ça dépend aussi de quel sens est ton scroll (si c'est gauche/droite c'est un peu mort).

( bha surtout que le disp fait 'naturellement' décaler l'écran, avec des Ouputs c'est bien moins évident de faire dérouler..)

C'est carrément impossible, faudrai garder en mémoire l'écran (chaque lignes) et les faire défilées (en prennant en compte qu'il faut supprimer la dernière). A moins d'utiliser les chaines de caractères je vois pas comment faire (et ça doit être super lent ).

Pas bien dur suffit d'une liste de 8 éléments que tu remonte (voir 8 variables avec quasi-rotation) pour les bordures (et encore tu peux radiner façile ) + les variables d'objets et une de largeur. ça tient en une douzaine de var, (il me semble que c'est plus rapide de manipuler une liste, voir deux si objets qui trainent, + deux-trois variables d'états complémentaires.)

Je sais j'ai déjà fait. ( à titre purement expérimental lorsque j'étais jeune, ça va de soi )
Par contre rien que le fait d'effacer/dessiner l'écran ça ram....

C'est carrement long ça (puis utiliser une liste pour un simple scroll, voilà quoi ), par contre il me semble que la dernière ligne de l'écran (en Y=8) n'est pas utilisable avec Disp (donc on peut y afficher un truc du genre le score, etc...).

la dernière ligne de l'écran (en Y=8) n'est pas utilisable avec Disp (donc on peut y afficher un truc du genre le score, etc...)

oui, le disp s'affiche en Y=7, mais si tu met un output(8,*,"blablabla" puis que apré tu disp, ca te fera tout remonté, même la ligne 8...

Sinon, moi g déja fait un jeu ac un scroll de gauche à droite, et ca avance à une vitesse respectable. Dans le jeu en fait fallais tiré depuis une position fixe au bas de l'écran sur un vaisseau qui défilé, ac plusieur niveaux et tout, enfin bref, pour faire défilé je faisia :

1->B
reapeat A#A (# = différent) pour que ca y répéte à l'infini
output(3,B," [=}"
B+1->B
if B>14:thenutput(3,B," ":1->B:end
End

et ac ca, ca défile tt seul, sans mettre de ClrHome, vu que le blanc à gauche du vaisseau ( qui est, vous l'aurez deviné : [=}) efface au fur et à mesure que le vaisseau avance.

Oui mais c'est bien plus lent qu'avec un 'Disp', car la le scroll ne se fait pas automatiquement.
Sinon tu peux faire :

:End End

[nosmile]1→B
While 1
Output(3,B," [=}
If B≠14:Then:B+1→B:Else:Output(3,B," 
1→B

(C'est juste le 'While 1' qui, je pense, fait plus propre qu'une 'Repeat A≠A', ou alors si tu veux tellement l'utiliser : 'Repeat 0').

ha ben ce soir je me coucherai moins con... Merci +deeph !! (je connaissai pas repeat 0...)
Je pense d'ailleur que je vais finir par être certain, à force de rester sur ce forum que le manuel (le gros) de TI83+ dans le section programmation est assez succin...

Plus je suis là, plus j'apprends des choses !
hum, et tant qu'a faire, quelqu'un pourrai m'expliqué clairement le fonctionnement de quelques fonction que je n'utilise jamais, faute de savoir ce que c'est :
IS>(
DS<(
For(
While ?

Merci d'avance, se serai simpa !

t'a lu ce manuel ?

Il est assez complet (sur les fonctions, c'est pas un guide de programmation ! )

Regarde bien For et While car c'est très important.

IS>( et DS<( permettent de belles optimisations mais c'est assez spécifique

(le '+' devant mon pseudo c'est pour dire que je suis modérateur, tout comme les '@' que tu peux voir devant certains pseudo, qui signifie que la personne est un admin, cf ici )

Bon sinon, 'IS>(' et 'DS<(' je ne les utilisent jamais, mais ça doit être éxpliqué dans le manuel. (bon à ce que je viens de voir ça s'utilise comme ça :

1→A
IS>(A,1
Disp "A est plus grand","que 1"

Enfaite ça t'incrémente la variable (ici 'A') et si elle est superieur à la valeur (ici 1), elle éxecutera la commande d'après (sinon elle l'ignore). Puis 'DS<(' c'est l'inverse, ça te décremente la variable et éxecute la prochaine commande seulement si la variable est plus petite que la valeur).

Ensuite le 'For(' c'est une boucle hyper pratique qui s'utilise comme ça 'For([variable],[valeur initiale],[valeur finale],([pas])'. Voilà un éxemple :

For(A,1,7
Disp "TEST
End

Ici ça t'affichera sept fois 'TEST' (car la variable A commence à 1 et est incrémenté à chaque fin de la boucle jusqu'a sept).
J'aurai aussi pu faire :

For(A,1,7
Output(A,1,"TEST
End

Pour ce qui est du [pas], on est pas forcé de l'utiliser mais ça définit juste comment on fait pour que la variable arrive à sa valeur finale. Du genre :

For(A,7,1,-1
Output(A,1,"TEST
End

Ici ça affichera 'TEST' en partant du bas vu que la valeur initiale est sept et qu'elle est décrémenté (due au pas) jusqu'à 1.

Et le dernier : 'While(' c'est à peu près l'inverse du 'Repeat(' :

Où tu mettras 'Repeat 0' tu pourra surement mettre 'While 1'.

Y'a pas une différence, genre le repeat exécute d'abord le bloc et regarde ensuite la condition ? ( ce qu'il fait qu'il l'éxécute au mins une fois ? )

Je dis ça, je ne l'utilise presque jamais ^^

Le manuel n'en parle pas mais je croit qu'il y a bien une différence au niveau des tests (le 'Repeat(' doit bien tester la condition à la fin du bloc).

Sinon ça servirai pas à grand chose d'avoir fait 'While(' vu que :

'While A=B' est égale à 'Repeat A≠B'...

d'ailleurs je viens de tomber sur un truc intéressant (je savais pas que ça y figurait):

Cette erreur peut également provenir d’un branchement à
partir d’une boucle If/Then, For(, While ou Repeat à l’aide
de l’instruction Goto car l’instruction End qui met fin à la
boucle n’est alors jamais atteinte.

A propos d'Err: memory (en relation avec un autre topic qui parlait de alentissement )

.19 > mauvaise langue:

Repeat répète un groupe de commandes jusqu’à ce
qu’une condition soit vraie (non nulle). Cette instruction
ressemble à While, mais la condition est testée à la fin
(End) ; de cette manière, le groupe de commandes est
toujours exécuté au moins une fois. Les instructions
Repeat peuvent être imbriquées.

C'est ce que je disait :

je croit qu'il y a bien une différence au niveau des tests (le 'Repeat(' doit bien tester la condition à la fin du bloc).

Bon après j'ai juste était vérifier dans le bouquin à la page où ils éxpliquent par une phrase chaques instructions

fégnasse

Ceci dit je me souvenais même pas qu'ils en parlais ailleurs ('puis bon, si on connais d'autres langages ça ce devine).

on peut le télécharger ou ton jeu ??

Slt !

Voilà les différences entre les boucles While et Repeat :

While "TEST"

TEST

Si TEST=VRAI --> ACTION, puis retour à TEST
Si TEST=FAUX --> Fin de la boucle

End


Repeat "TEST"

ACTION

TEST

Si TEST=VRAI --> Fin de la boucle
Si TEST=FAUX --> Retour à ACTION

End



Donc effectivement pour la boucle Repeat, l'action est bien effectuée au moins une fois.
De plus, pour While, la boucle continue si le test est VRAI, alors que pour Repeat, la boucle continue si le test est FAUX.
On peut donc passer de While à Repeat et inversement en prenant l'opposé logique du test, bien entendu en prenant en compte que pour Repeat, et pas pour While, l'action est faite avant le premier test.,
Je m'explique : si l'on excepte cette différence d'ordre d'exécution pour les 2 boucles, on a :
Si TEST est le test d'une boucle While, alors not(TEST) est le test d'une boucle Repeat, et l'effet reste inchangé.

Bon allez, j'en profite :-)

Voici quelques astuces logiques :

not(A)=B <-> A=not(B)

not(A=B) <-> A=/=B
not(A>B) <-> A<=B
not(A<B) <-> A>=B
not(A and B) <-> A xor B
not(0)=1

Boucle A=0 équivaut à Boucle not(A)

Si A est un nombre différent de 0, alors A est considéré dans ces tests logiques comme étant égal à 1.


Voilà j'ai du en faire un peu trop mais ça devrait aider certains.

Le sujet date un peu mais oui, ça peut toujours servir

(Tiens sinon t'es nouveau sur le forum ? Tu programmes depuis quand ?)

Yep dsl j'avais pas vu la date, enfin bon peu importe.

Yep yep je suis nouveau mais je programme depuis plus de 2 ans maintenant, et je pense avoir un bon niveau, en tout cas en basic pur.

jai une question pour un programme comment je peut faire une commande du genre

RandInt(1,5)->x
Disp " (un nombre d'espace egal à x ) o"


??