CodeTouche avec clignotement

Salut !

voilà je pense avoir compris le fonctionnement du codeTouche depuis un moment, mais j'ai un problème il y a un foutu clignotement du + que je souhaite afficher comment y remédier merci :

Code:

EffEcr
1→A:1→B
Repeat K=105
CodeTouche→K
Output(A,B," "
A+(K=34 et A<9)-(K=25 et A>1)→A
B+(K=26 et B<17)-(K=24 et B>1)→B
Output(A,B,"+
End

Normal, dans ta boucle, tu effaces le +:

Code:


Output(A, B, "  "


Puis tu l'affiches:

Code:


Output(A, B, "+


Cet alternance d'effacement/affichage va provoquer ce clignotement intempestif.
Pour résoudre le soucis, il faut effacer le + uniquement lors d'un déplacement.

Pour cela, on fait ceci:

Code:


If max(K={24,25,34,26 :Then
//Si l'utilisateur presse la touche 24 ou 25 ou 26 ou 34, alors....
End


Appliqué à ton programme, cela donne:

Code:


EffEcr
1→A:1→B
Repeat K=105
CodeTouche→K
If max(K={24, 25, 34, 26:Output(A,B," "
A+(K=34 et A<9)-(K=25 et A>1)→A
B+(K=26 et B<17)-(K=24 et B>1)→B
Output(A,B,"+


Et voilà ;-) Si tu as d'autres questions, n'hésite pas[/code]

Tout-à-fait.  

Tu balances le test optimisé en OU directement, je crois qu'un rappel de ce détail peut aider.
ceci :
If max(K={24,25,34,26})
correspond à cela :
If K=24 ou K=25 ou K=34 ou K=26
En tout cas dès la ti82stats.

Mais je ne peux plus me déplacer vers la gauche et en bas → erreur...

Quel type d'erreur et quel endroit ?
Je te garantis qu'en procédant ainsi, peu importe le niveau d'optimisation du test "K=24 ou K=25 ou ..." cela permet de n'effectuer d'affichage que lors d'une pression de touche de direction puisque c'est ce que signifie le test.

Code:

EffEcr
1→A:1→B
Repeat K=105
CodeTouche→K
If K=24 ou K=25 ou K=26 ou K=34  // je reviens à le ligne mais peu importe
Output(A,B," "
A+(K=34 et A<9)-(K=25 et A>1)→A
B+(K=26 et B<17)-(K=24 et B>1)→B
Output(A,B,"+
End

En revanche tu peux détecter une touche quelconque avec simplement "If K".

Code:

EffEcr
1→A:1→B
Repeat K=105
CodeTouche→K
If K  // je reviens à le ligne mais peu importe
Output(A,B," "
A+(K=34 et A<9)-(K=25 et A>1)→A
B+(K=26 et B<17)-(K=24 et B>1)→B
Output(A,B,"+
End

Lorsque je code des jeux qui n'agissent jamais seul, je place une boucle autour du codeTouche et il n'y a plus de clignotement tant qu'on ne touche pas au clavier.

Code:

EffEcr
1→A:1→B
Repeat K=105
Repeat K  // ici on pourrait détecter des touches précises
CodeTouche→K
End
Output(A,B," "
A+(K=34 et A<9)-(K=25 et A>1)→A
B+(K=26 et B<17)-(K=24 et B>1)→B
Output(A,B,"+
End

pito2901 a écrit:Mais je ne peux plus me déplacer vers la gauche et en bas → erreur...

J'ai testé, le programme fonctionne. Verifie que tout est correct

Le code est identique, je lance le programme le + est en position 1,1, lorsque je vais à gauche il ne me renvoie pas en 1,16, il reste sur place idem si je vais en haut. Si je vais trop à droite (1,17) ou trop en bas (9,1) → erreur domaine...

Le wrapping (retour d'un bord à l'autre) n'a rien à voir avec le clignotement intempestif et ses palliatifs.

Les calculs que tu utilises devraient imposer des limites puisque les conditions sont incluses. Et je rappelle que l'algèbre de boole génère des zéros et des 1, c'est pour ça qu'on peut écrire ces calculs ainsi.

Code:

A+(K=34 et A<9)-(K=25 et A>1)→A
B+(K=26 et B<17)-(K=24 et B>1)→B

Code:

If K=34 et A<9
A+1→A
If K=25 et A>1
A-1→A
If K=26 et B<17
B+1→B
K=24 et B>1
B-1→B

Mais les conditions présentes ne respectent même pas tout l'écran puisque tu évites la première ligne et la première colonne auxquelles tu initialises pourtant. Je pense que ceci lié à une erreur rend les tests inefficaces.

Malgré cela tu recherches le wrapping (retour d'un bord à l'autre) donc je te présenterai quelques méthodes.
D'abord les tests, c'est évident.

Code:

If K=34
A+1→A
If K=25
A-1→A
If K=26
B+1→B
K=24
B-1→B
If A<1
8→A
If A>8
1→A
If B<1
16→B
If B>16
1→B

Comme j'affecte les valeurs au lieu d'incrémenter ou décrémenter, le wrapping ramène toujours dans l'écran peu importe l'origine, ce qui ne serait pas forcément le cas autrement.

Puis les conditions booléennes.
J'aime séparer le déplacement et le wrapping car les conditions sont plus faciles à prévoir, surtout sans langage préprocesseur.

Code:

A+(K=34)-(K=25→A
B+(K=26)-(K=24→B
A+8(A<1)-8(A>8→A
B+16(B<1)-16(B>16→B

Puis les calculs de modulo grâce à la division. C'est un peu plus compliqué que la base car tes valeurs ne commencent pas à zéro.

Code:

A-(K=24)+(K=26
Rép-8partEnt((Rép-1)/8→A
// le calcul le plus fiable, mais attention à int/ent/iPart/partEnt
// on peut s'adapter aux négatifs (parEnt et int le sont)

// le "-1" permet que les valeurs soient entre 1 et 8 inclus, c'est ça qui est plus compliqué

A-(K=24)+(K=26
1+arrondi(8partDéc((Rép-1)/8),0→A
// l'arrondi évite des risques de nombres décimaux, mais il n'est pas indispensable dans certains programme, tout dépend des opérations
//Cela n'a aucune ambiguité de langue
// mais cela ne supporte pas les nombres négatifs

// un moyen efficace mais tordu de supporter les négatifs malgré partDéc, est de modifier les valeurs des pas comme le snake de Ratuss qui préfère incrémenter d'une grande valeur qui reviendra au même à la fin que de décrémenter.
X+5 modulo 8 revient à X-3 modulo 8, puisque 8=5+3

Personnellement pour les retours d'un bord à l'autre j'utilise toujours les conditions booléennes, qui sont plus simple à comprendre