Discussion :

[Zenol]

Bonjours,
Tout d'abord j'éspère être au bon endroit pour poser ma question

Voila, je voudrais programmer un jeux(Rien de bien originale), sur un calculette(La sa devien originale), ou je n'ai que 27 variables et 27etiquettes[Pour els gotos] !
De plus je n'ai pas de tableau.
J'ai comme instructions :
if/for/goto/etiquette/while/repeate/menu/pause
Je peut récupèrer la touche tapper, effectuer n'importe quel teste conditionel.

Avec sa comment gèrer l'afichage d'un écran d'une taille de 94*62PX

J'ai des onctions pour changer l'atat de n'importe quel point en x/y
(true/false)
Je peut obtenir l'état de n'importe quel point ou encore l'inverser.

Comment en respectant ces règles puije créer un décore de tunèle

Code :

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

1
2
3
4
5
6
7
8
 
*********
** *** **
*   *   *
 
*   *   *
** *** **
*********

Qui se décale vers la gauche?

_________________
Titre modifié par Sub0 - Ancien titre : 27Variable et 27 etiquettes

[khayyam90]

bien le bonjour,

Comment en respectant ces règles puije créer un décore de tunèle. Qui se décale vers la gauche?

je ne suis pas sur de comprendre ce que tu entends par 'decor de tunnel'
tu veux juste decaler ton decor sur la gauche ?

dans ce cas 2 variables suffisent. 2 boucles imbriquees pour parcourir ton ecran et tu ecrases chaque pixel par le pixel a sa droite.

Tu rempliras la derniere colonne par des pixels de ton choix ou bien si tu veux un decor cyclique, il faudrait stocker la premiere colonne, ce que tu ne peux pas.

donc, pour pallier ce soucis, tu parcours ton ecran ligne par ligne et tu fais une permutation circulaire des pixels (necessite une variable de plus)

mais ai-je bien compris ce que tu veux faire ?

[LorDjidane]

Tu veux programmer sur calculatrice Casio ?
Tu n'as peut-être pas de tableaux, mais tu as les matrices, essaye de voir si tu peux t'en servir dans cet ordre d'idée.

[Zenol]

J'ai une TI82, et mes conaissences mathématiques/algorithmiques se limite au c++ et au programme de Seconde(Donc pas grand chose enfaite).

Je voudrais génèrer la dernière ligne a droite par random, puis décaller toutes les lignes vers la gauche. Si j'aurais programmer en c++ j'aurais fait un tableau de ligne verticale, et haque ligne verticale aurais éter un tableau de point.[x][y]
A notter que je devrais prendre aussi en compte un systheme de colision.
Sinon je croi que la TI82 fait les mattrice mais je ne connais d'elles que leur nom (programme de 1èr?)

[Vick le Viking]

Bonjour tout le monde!
Ayant moi-même possédé une TI-82 et programmé ce genre de jeux dessus, je pense pouvoir t'aider

Tout d'abord saches que tu as plus que 27 variables, penses au listes L1 jusqu'à L6 qui peuvent chacune posséder 99 éléments. Et puis tu as aussi les matrices, dont tu peux définir les dimensions (je crois qu'il y a une limite, à voir dans le manuel), ce qui te fait un bon paquet de variables finalement, même si tu n'utilises pas les matrices.

Ensuite, si tu veux vraiment un décor au pixel près, c'est-à-dire que tu veux changer l'état de tous les pixels d'une colonne à chaque décalage vers la gauche, tu peux abandonner tout de suite car le TI-BASIC que tu utilises pour programmer ceci sera tellement lent que je penses qu'il te faudra 7-8 secondes pour actualiser l'écran :s Dans ce cas, il faudra te tourner vers l'assembleur. En recherchant sur google tu devrais trouver des soft qui te permettent de programmer en assembleur sur ton pc puis d'envoyer le programme sur ta calculette.

Si cette solution ne te convient pas, tu peux tout de même faire ce genre de petit jeu, mais il faudra se contenter d'une précision d'un caractère de calculatrice, c'est-à-dire 6*8 pixels si mes souvenirs sont bons. J'explique : l'astuce consiste à faire défiler le paysage de bas en haut, et non de droite à gauche. Et tu affiches ton décor par des "DISP" et des "OUTPUT". C'est pourquoi ton décor est moins joli (par exemple le décor est une suite de caractères '*'), mais comme la commande "DISP" est très rapide, le jeu devient jouable

Voilà, pour l'instant je ne t'en dis pas plus sur l'algorithme, je te laisses trouver quelque chose.

[Zenol]

J'aurais bien besoin d'un peut d'aide avec les matrices.
Apparement je pourais stocket le décore dans une matrice mais je ne sais pas comment accèder a une donée présise, (Avec l'id de ligne et de columne)
Sinon je pensais faire ceci :
//id_ligne => Y
//id_col => X
while(1)
{
for(id_ligne; ligne < Maxligne; id_col++)
{
for(id_col; ligne < MaxCol; id_col++)
{
output Matrice(id_col,id_ligne);
}
}
if(Matrice(PositionPlayerX,PositionPlayerY)[goto Perdu;}
}

[Vick le Viking]

L'algorithme auquel tu as pensé est bon, même si tu as fais quelques erreurs sur les variables dans les boucles (rédigé trop vite?). Ensuite, il faut voir si ton algorithme est viable en terme de rapidité d'exécution, ce qui, ici, n'est pas garanti.

Maintenant, pour ton problème d'accès au données d'une matrice, voilà comment on procède pour avoir l'élément (id_col, id_ligne) :

Code :

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

 [A](id_ligne,id_col)

où [A] est la matrice concernée.

Donc pour récupérer la valeur de l'élément (7,2) de ton décor dans la variable X, tu fais :

Code :

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

[A](2,7)->X:

où -> est l'opérateur d'affectation (store) de la calculatrice et pas la suite de caractères '-' et '>'

J'allais oublier : fais attention dans tes boucles for, les indices de matrices et listes commencent à 1

[Zenol]

Ok merci bocup, oui enfaite j'ai un peut réiger a la va vitte ^^
Mai je ne voi pas comment aficher autrement une matrice, a moin qu'il y est une comande qui affiche toute une ligne/columne?

[Vick le Viking]

Pour afficher la matrice, tu devras de toute façon parcourir chacun de ses éléments, donc pas la peine de chercher par là. En revanche, ce que je sous-entendais par le problème de rapidité, c'est de stocker le décor dans une structure moins gourmande qu'une matrice, mais là, il faut en savoir plus sur le décor. Avec un tunnel simple, ie comme cela par exemple

Code :

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

1
2
3
4
5
6
7
8
 
*****]    [*****
****]    [******
****]    [******
***]    [*******
****]    [******
*****]    [*****
****]    [******

tu peux n'avoir à stocker qu'une liste dont la dimension est égale à la hauteur de l'affichage (ici 7), et dont les éléments contiennent la position du crochet "]", ce qui rend facile la détection des collisions avec le décor. Comparé à la matrice que tu stockerais (7*16 éléments), le gain est énorme.

[Zenol]

Oui, mais il faudrais conettre la rapiditée d'execution de chaque opération, et la rapaditée d'acès a un élément de matrice, pour pouvoir comparer le temp.
Mais d'après ce que tu me dit sa semble plus rapide. Une matrice avec deux colomnes, une poit la position des crochet gauche, une pour celui de droite.
Et en fesan quelque chose du genre :

Code :

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

1
2
3
4
5
6
7
8
for(i=1;i<=NbML;i++)
      for(j=0;j<Matrice[1][i];j++)
            string1 = "#" + string1
      for(j=0;j<Largeure - (Matrice[1][i]+Matrice[2][i]) ;j++)
            string1 = " " + string1
      for(j=0;j<Matrice[2][i];j++)
            string1 = "#" + string1
      disp string1

Au faite, les string sa s'utilise comme sa?

[Vick le Viking]

L'algo que tu proposes est bon, mais pour le dernier for, il faudrait plutôt faire

Code :

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

1
2
for(j=Matrice[2][i]; j<Largeur;j++) 
            string1 = "#" + string1

il me semble.

Maintenant, pour l'utilisation des strings, on fait pas du C++ !! En C++ l'utilisation pour des opérations basique des chaînes de caractères est plus simple que sur les TI où il faut tout faire à coup de '&' pour concaténer et '#' pour les indirections (ie tout le reste).

De plus, les TI82 ne gèrent absolument pas les strings, et, si je me souviens bien, c'est seulement à partir de la TI83 qu'on a la possibilité de stocker des chaînes de caractères dans les variables Str1 jusqu'à Str9, mais, là encore pas de concaténation ou d'autres manipulations possible!

Donc le seul moyen que j'avais trouvé pour contourner cela, c'est de gérer les string "graphiquement" : on affiche ce qu'on veut afficher, et à chaque changement, on regarde où on doit corriger les textes affichés avec OUTPUT si on est sur l'écran de calcul, ou TEXT si on est sur l'écran de graphe des fonctions. Donc tout se passe sans variables qui stockent les strings, snif.

Mais pour autant, ton problème n'est pas insoluble! Et qui plus est "l'astuce" utilisée rend l'exécution plus rapide qu'un affichage avec des strings comme ton algorithme général le ferait, par exemple sur une TI89 (sur ce modèle, on peut appliquer ton algorithme)

La technique à adopter est la suivante :

supposons qu'on aie déjà le décor suivant :

Code :

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

1
2
3
4
5
6
7
8
 
*****]    [***** 
****]    [****** 
****]    [****** 
***]    [******* 
****]    [****** 
*****]    [***** 
****]    [******

on fait un

Code :

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

Disp "":

afin de décaler toutes les lignes déjà affichées d'une ligne vers le haut. Or la nouvelle chaîne affichée est vide, donc on rajoute :

Code :

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

Output(7,1,"****************":

ce qui a pour effet de remplir la nouvelle ligne vierge par des '*'. Le 7 indique qu'on écrit sur la 7ième ligne qui est la plus en bas de l'écran.
Puis on fait

Code :

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

Output(7,x,"]    [":

pour afficher les bords du tunnel. Comme tu le sais peut-être déjà, la commande OUTPUT écrase l'affichage existant, et c'est exactement ce dont on a besoin. 'x' correspond à l'abscisse à laquelle le bord gauche doit s'afficher.
Donc notre nouvelle ligne est complètement et correctement affichée (libre à toi de rajouter des obstacles entre les deux bords du tunnel ']' et '['). Il reste maintenant à faire nos calculs :

Code :

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

1
2
position_crochet_gauche->[A](7,1):
position crochet_droit->[A](7,2):

Et à chaque itération, on fait une permutation circulaire sur chaque colonne de la matrice, c'est-à-dire qu'on remplace le premier élément par le deuxième, le deuxième par le troisième etc. ce qui fait "grimper vers le haut" nos valeurs représentant les bords du décor, tout comme l'affichage le fait.
Pour tester une collision, on compare l'abscisse du vaisseau (qui est affiché sur la ligne du haut, numéro 1) avec les éléments de la première ligne de la matrice, [A](1,1) et [A](1,2)


J'ai essayé d'expliquer en détail, mais si une partie te sembles tout de même obscure, dis-moi ce que tu ne comprends pas.

[Zenol]

En fait j'ai la TI82 Stat, donc j'ai les variables string.
Mentenant je n'ai jamais vraiment utiliser output alors je ne sais pas si on peut écraser avec.
Parcontr je ne comprend pas comment tu fait pour apliquer une rotation a la matrice?!

Et sinon je me posais des questions sur la vitesse, car il faut que l'utilisateur ne se rende pas compte que l'on retrce l'écran partie par partie, et il faut aussi que le décore ne tourne pas trop vitte, qu'il est le temp de réagir ^^

[Vick le Viking]

Pour l'utilisation de output, tu devrais regarder le manuel de ta calculatrice, son utilisation y est expliquée. En attendant je te confirme que output affiche du texte sans se soucier de ce qui est déjà affiché sur l'écran. Donc pour effacer un rectangle de pixels, par exemple, tu peux utiliser output avec une chaîne de caractères ne contenant que des espaces.

La rotation de la matrice peut se faire à la main, comme je l'ai expliqué, en remplaçant le premier élément d'une colonne par le deuxième, puis le deuxième par le troisième, jusqu'au dernier. Mais tu peux aussi utiliser la fonction SortA (tri croissant) avec une liste remplie de zéro.

Supposons que tu aies la liste L1={1,7,4,9}, alors pour faire la permutation, tu affectes L2 comme ceci : L2={0,0,0,0}, puis tu exécutes

Code :

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

SortA L2,L1:

Maintenant L1 contient {7,4,9,1}.
Pour comprendre pourquoi cela marche, je te renvoie au manuel dans lequel une explication détaillée avec exemple à plusieurs arguments de SortA est fournie.

À toi de voir la méthode la plus rapide pour la permutation, en essayant de minimiser la rapidité d'exécution et la taille du code.


Maintenant pour la rapidité, si c'est trop rapide (ce qui m'étonnerait grandement), on peut topujours ralentir la boucle principale en rajoutant un

Code :

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

For i,1,50:End:

. Et pour avoir une idée de la lenteur, fais un petit programme qui affiche une suite d'une dizaine de disp avec des chaines de caractères différentes en argument (différentes pour être capable de voir le résultat à l'écran), la vitesse de défilement de l'écran te donnera la vitesse maximale théorique de ton programme, puisque dans ton programme tu auras des calculs à faire entre deux disp.

[Zenol]

Enfaite le manuel de la TIStat est incomplet. Pas la moindre page sur la programation, il y a juste les petits truc de base(utilisation de seconde, alpha, adition, multiplication ect...)
Je vérais un peut sur le net, je croi que je pourais trouver des esplications sur les fonctions.
Quand a l'affichage, en effet c'est sésissan de lenteur!

[méphistopheles]

bonjours.

avec la ti 82, faut pas t'attendre à des miracles, les processeurs sonts vraiment lents.
(j'ai quand même réussi à faire un joli invaders et un puissance 4 avec IA (j'avais égualement essayé un pong mais là, la lenteur de la calcullette rendais le jeu mauvais... dommage, j'avais réussi à le paraméter pour deux joueurs (avec link))

au fait, la limite des matrices coressond juste à la memoire libre. Sur ma ti, je n'ais jamais réussi à faire plus de 45/45.

pour ce qui est de ton tunel, s'il ne comporte pas plus de 6 images, tu peux essayer d'utiliser la methode picture qui à un affichage quasi instantané.
toujours avec la methode piture, tu peux afficher ta première image et te contenter de dessiner un rangée de pixels d'un coté et d'en effacer une de l'autre.

une dernière methode consisterais non pas a dessiner des pixels mais des lignes: si ton dessin ressemble à ça:

Code :

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

1
2
3
4
5
6
7
********* 
** *** ** 
*   *   * 
 
*   *   * 
** *** ** 
*********

tu peux parametre avec deux variables:

Code :

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

line(X,Y,X+9,Y):line (X,Y+1,X+9,Y+1):line(X,Y+7,X+9,Y+7):line(X,Y+8,X+9,Y+8):pt-on(X,Y+3):pt-on(X+4,Y+3):pt-on(X+8,Y+3):pt-on(X,Y+6):pt-on(X+4,Y+6):pt-on(X+8,Y+6):pt-Off(X+3,Y+2):pt-Off(X+7,Y+2):pt-Off(X+3,Y+7):pt-Off(X+7,Y+7):

là, tu n'a plus qu'a entre la position de x et y puis à executer ce code.
ce sera pas instantané, mais ça sera plus rapide qu'avec une restitution point par points.
N'oublie cependant pas de configurer ton écran en 62*94 sinon, tu vas voir des trucs bizarres ^^

bonne chance

salut