[Axe]Charmap

Voila apres m'etre battue contre cette calculatrice j'ai enfin finis le moteur principal :

Bien sur le code est loin d'etre optmiser mais on m'a demander de le faire comme ceci donc je l'ai fait comme ceci.

Code:


:.ACOURS
:AsmComp(MEMKIT)
:ZXmin)
:0→E
:While ZXmax)
:   dim()→{L1}r
:   ZXresL1+1)
:   GetCalc(L1,Y1)
:   ({Y1}=T.) and ({1+Y1}=T.) and ({2+Y1}=T.)?E++
:End
:E--
:ClrDraw
:Fix 5
:ref(0,,96,11)
:rref(1,,94,9)
:Text(21,2,"Lecteurs de texte")
:13→Y→B
:0→D→C
:sub(ADD)
:C-r2→C
:While 1
:   Pt-Change(1,Y,[FEEEF682F6EEFE00])
:   DispGraph
:   Pt-Change(1,Y,[FEEEF682F6EEFE00])
:   If getKey(1) and (Y≠55) and (Y-13/7≠sub(TE1))
:      Y+7→Y
:   Pause 100
:ElseIf getKey(1) and (Y=55) and (E-6≠D)
:      C++
:   D++
:   sub(ADD)
:   C-r2→C
:End
:If getKey(4) and (Y≠13)
:   Y-7→Y
:Pause 100
:ElseIf getKey(4) and (Y=13) and (D≠0)
:   D--
:C--
:sub(ADD)
:C-r2→C
:End
:
:
:EndIf getKey(15)
:   .-------------
:Lbl TE1
:ZXmin)
:0→r1
:While ZXmax)
:   dim()→{L1}r
:   ZXresL1+1)
:   GetCalc(L1,Y1)
:   ({Y1}=T.) and ({1+Y1}=T.) and ({2+Y1}=T.)?r1++
:End
:r1--
:Return
:.-------------
:Lbl ADD
:ref(0,11,96,53)
:rref(1,11,94,52)
:ZXmin)
:0→r1
:While r1≠D
:   dim()→{L1}r
:   ZXresL1+1}
:   GetCalc(L1,Y1)
:   ({Y1}=T.) and ({1+Y1}=T.) and ({2+Y1}=T.)?r1++
:   ZXmax)
:End
:13→B
:0→r2
:While B<57
:   dim()→{L1}r
:   ZXresL1+1)
:   GetCalc(L1,Y1)
:   If ({Y1}=T.) and ({1+Y1}=T.) and ({2+Y1}=T.)
:       Text(9,B,C+1►Dec," : ")
:    If D≠0 and (C=D)
:       Text(9,B,C+1►Dec,30►Frac)
:    End
: If C≠E and (C-D=6)
:    Text(9,B,C+1►Dec,31►Frac)
: End
: 32→{L1}
: Text(27,B,L1)
: B+7→B
: C++
: r2++
:End
:ReturnIf ZXmax)=0
:End
:Return
:.-------------
:Lbl LEC
:Return
:.-------------
:Lbl TIL
:[]→Pic0LET
:[0000000000000000]
:[6090F09090000000]
:[E090E090E0000000]
:[7080808070000000]
:[E0909090E0000000]
:[E080C080E0000000]
:[E080C08080000000]
:[F080B090F0000000]
:[9090F09090000000]
:[E0404040E0000000]
:[702020A040000000]
:[90A0C0A090000000]
:[80808080E0000000]
:[90F0909090000000]
:[9090D0B090000000]
:[6090909060000000]
:[E090E08080000000]
:[609090A050000000]
:[E090E0A090000000]
:[70806010E0000000]
:[7020202020000000]
:[9090909060000000]
:[A0A0A0A040000000]
:[909090F090000000]
:[A0A040A0A0000000]
:[5050502040000000]
:[7010204070000000]
:.MAJ
:[0030505030000000]
:[8080E090E0000000]
:[0030404030000000]
:[1010709070000000]
:[0020506030000000]
:[205040E040000000]
:[0030503060000000]
:[80A0D09090000000]
:[2000602070000000]
:[200020A040000000]
:[8080A0C0A0000000]
:[6020202070000000]
:[00A0E0A0A0000000]
:[00A0D09090000000]
:[0060909060000000]
:[00E090E080000000]
:[0060907010000000]
:[00A0D08080000000]
:[0060402060000000]
:[40E0405020000000]
:[009090B050000000]
:[0050502020000000]
:[00A0A0E0A0000000]
:[00A0A040A0000000]
:[00A0A04080000000]
:[00F02040F0000000]
:.MIN


Pour le moment je n'utilise que A-B-C-D-E-X-Y mais je pourrais reduire le nombre de variable...

ATTENTION : faire super gaffe avec les vraible temporaire r1-r6 elle sont glisse un peu partout

Bon alors j'ai fait plusieurs changement :

1) j'ai juste optimiser un truc pas bien dur qui enleve 500 octets

2) j'ai remplacer l'affichage des nom des programme par les 13 premier chiffe des 13 octets apres les trois "..." (ce sont les chiffre de 0 a (1+26+26) pour dire quel charactere dessiner car c'est super dure d'afficher les tokens a l'ecran.

3)rien j'aimerais juste de vos nouvelles

Code:


:.ACOURS
:AsmComp(MEMKIT)
:ZXmin)
:0→E
:While ZXmax)
:   sub(NAM)
:   ({Y1}=T.) and ({1+Y1}=T.) and ({2+Y1}=T.)?E++
:End
:ClrDraw
:Fix 5
:ref(0,,96,11)
:rref(1,,94,9)
:Text(21,2,"Lecteurs de texte")
:13→Y
:0→D→C
:sub(ADD)
:C-r2→C
:While 1
:   Pt-Change(1,Y,[FEEEF682F6EEFE00])
:   DispGraph
:   Pt-Change(1,Y,[FEEEF682F6EEFE00])
:   If getKey(1) and (Y≠55) and (Y-13/7≠sub(TE1))
:      Y+7→Y
:   Pause 100
:ElseIf getKey(1) and (Y=55) and (E-6≠D)
:      C++
:   D++
:   sub(ADD)
:   C-r2→C
:End
:If getKey(4) and (Y≠13)
:   Y-7→Y
:Pause 100
:ElseIf getKey(4) and (Y=13) and (D≠0)
:   D--
:C--
:sub(ADD)
:C-r2→C
:End
:
:
:EndIf getKey(15)
:   .-------------
:Lbl TE1
:ZXmin)
:0→r1
:While ZXmax)
:   sub(NAM)
:   ({Y1}=T.) and ({1+Y1}=T.) and ({2+Y1}=T.)?r1++
:End
:r1--
:Return
:.-------------
:Lbl NAM
:dim()→{L1}r
:ZXresL1+1)
:GetCalc(L1,Y1)
:Return
:.-------------
:Lbl ADD
:ref(0,11,96,53)
:rref(1,11,94,52)
:ZXmin)
:0→r1
:While r1≠D
:   sub(NAM)
:   ({Y1}=T.) and ({1+Y1}=T.) and ({2+Y1}=T.)?r1++
:   ZXmax)
:End
:13→B
:0→r2
:While B<57
:   sub(NAM)
:   If ({Y1}=T.) and ({1+Y1}=T.) and ({2+Y1}=T.)
:       Text(9,B,C+1►Dec," : ")
:    If D≠0 and (C=D)
:       Text(9,B,C+1►Dec,30►Frac)
:    End
: If C≠E and (C-D=6)
:    Text(9,B,C+1►Dec,31►Frac)
: End
: 0→r3
: For(13)
:    Pt-On(r3*5+27,B,{3+r3+Y1}*8+Pic0)
:    r3++
:    End
: B+7→B
: C++
: r2++
:End
:ReturnIf ZXmax)=0
:End
:Return
:.-------------
:Lbl LEC
:Return
:.-------------
:Lbl TIL
:[]→Pic0
:[00000000000000006090F09090000000E090E090E00000007080808070000000E0909090E0000000E080C080E0000000E080C08080000000F080B090F00000009090F09090000000E0404040E0000000702020A04000000090A0C0A09000000080808080E000000090F09090900000009090D0B0900000006090909060000000E090E08080000000609090A050000000E090E0A09000000070806010E000000070202020200000009090909060000000A0A0A0A040000000909090F090000000A0A040A0A000000050505020400000007010204070000000]
:.MAJ
:[00305050300000008080E090E0000000003040403000000010107090700000000020506030000000205040E040000000003050306000000080A0D090900000002000602070000000200020A0400000008080A0C0A0000000602020207000000000A0E0A0A000000000A0D09090000000006090906000000000E090E080000000006090701000000000A0D08080000000006040206000000040E0405020000000009090B050000000005050202000000000A0A0E0A000000000A0A040A000000000A0A0408000000000F02040F0000000]


un petit screen (j'ai pas pu mettre de 0, soit l'espace, dans les titre car c'est tres dure de mettre un zero dans un programme.

[Vous devez être inscrit et connecté pour voir cette image]


ATTENTION: je peut encore ajouter des caracteres je pense qu'il y en aura 13 ou 14 donc on verra bien ce qaue ca donne je vous previens.

Pas mal dites-moi

À quoi va ressembler la syntaxe du langage ? On pourra écrire en gras, souligné et tout ?

C'est prévu.
On a survolé la syntaxe envisagée (des balises avec des sets de caractères indépendants des classiques de la TI) et sachiix69 et samsam progressent dans la pratique.

Mais je suis largué par la programmation Axe et sachiix69 change parfois de méthode quand il a un quelconque problème lié à la mémoire ou à l'Axe.

Sachiix69 son truc c'est qu'il est solo ... il faut savoir coopérer mon p'tit

J'avoue que c'est pas facile mais bon j'ai fait ceci ;

-seul les programme contenant "..." au debut sont affiché qu'il soit archivé ou non.
-les 14 premier octets du programme apres les "..." sont des nombre de 0 a 65 (0=espace 1-27=majuscule 28-54=minuscule 55-65= chiffre) et ils sont affiché pour decrire le programme.

voila c'est tout ce que j'ai fait si quelqu'un veut que e change quelque chose ou a une autre idée qu'il propose mais l'idée de mettre un titre plus long est geniale car j'ai l'habitude d'utiliser TI-doc donc moi je sais evidemment a quoi correspond tout mes programme mais mes amis ne savent pas car le nom est pas assez explicite...

pour ecrire en souligné ca sera possible evidemment grace a des balise je pense, ecrire en gras demande de faire de plus gros caractere ce n'est donc pas la priorité principale.

Bon j'ai reflechis la maniere d'afficher a l'ecran sachant que les lignes seront a des place differents.

-deux variable X et Y pour la position de l'objet a tracer.

-il faudrait calculer la place que prends une ligne avant de l'afficher soit une routine qui fait comme si elle affichait la ligne sans l'afficher, a la fin on connait la hauteur max de la ligne puis on l'affiche

qu'en pensez vous ?

On peut utiliser des variables pour le saut des lignes sinon, avec un en-tête qui indique sa taille.
Maintenant que matref est la, pourquoi ne pas inclure le lecteur à AxeSh? (comme plug-in? )
Pour la syntaxe, si on fait comme le HTML, ça fera un peu "copié sur TIdoc"
mais s'il n'y a pas d'autres solutions, je le fais sans état d'âme!
j'avais pensé à un truc comme:

Code:


<write texteblabla>


au lieu de:

Code:


<write>texteblabla</write>


Pour les noms des balises, je propose quelque-chose de simple que tout le monde peut faire sans apprendre,

Code:


write: écrire
sup:  écrire en exposant
sub:  écrire en indice
underline: souligné
vector: vecteur à taille variable
angle:  pour faire la notation d'angle
highlight: pour écrire en blanc sur noir
list: pour faire une liste
(gray 1 ou gray 2  pour écrire en gris clair ou gris foncé mais ça complique et ralentit vu qu'il faudra constamment afficher les buffers)
lim: pour écrire en dessous du texte en petit
border: pour encadrer


Pour le compilateur, j'ai une petite question en c++
Si je crée un tableau de char dans une boucle pour pouvoir accommoder à la taille finale, est ce que je risque d'avoir des problèmes de mémoire ou l'ancien tableau de caractères est supprimé?

Code:


while (!fin_du_code){

char tableau[variable];

}


Un peu comme ça. (c'est simplifié)

Chaque variable est déclarée une fois, t'inquiètes.

Et laisse AxeSH tout seul, personne l'utilise de toute façon x)

Moi je pense plutot qu'il faut faire des balise comme sur le html c'est bien mieux et au pire on pourras le changer plus tard....

faire par exemple :

Code:

<vect>tout ca sera avec un vecteur au dessus<vect>
<u>tout ca sera soulignee<u>

ect....

car sinon il faudras indiquer le nombre d'octets a surlugner ects et ca sera tres galere....

et chaque balise ne sera pas comme le html avec un / pour fermer car chaque balise representeras un octets une fois que je le rencontre j'active le mode soulignage par exemple, et je le desactive une fois que je le rerencontre...

Code:


<write texteblabla>


Le petit chevron de la fin indique que la balise est terminée
Un peu comme le "end" en TI-basic
Le programme part à la recherche d'un chevron ouvrant, lit le mot qui suit jusqu'au chevron qui ferme
On pourrait utiliser une liste qui simule le stack pour savoir quelle balise est fermée

Une liste ? -_o Serait-tu toi aussi de ceux qui appellent les items de L1 à L6 des listes ?

Il y a un juste un probleme avec vos sprite... ils ne sont pas alignee... et aussi les charactere qu'on a fait sont trop gros ca rend vraiment moche si vous etes d'accord on refait un sept de caractere de 3 pixels de largeur sur 5 de longueur car dans tout les cas il faudra les refaire...

Code:

:[0000000000000000] _
:[40A0E0A0A0000000] A
:[C0A0C0A0C0000000] B
:[6080808060000000] C
:[C0A0A0A0C0000000] D
:[E080C080E0000000] E
:[E080C08080000000] F
:[6080A0A060000000] G
:[A0A0E0A0A0000000] H
:[E0404040E0000000] I
:[202020A0E0000000] J
:[A0A0C0A0A0000000] K
:[80808080E0000000] L
:[A0E0A0A0A0000000] M
:[C0A0A0A0A0000000] N
:[E0A0A0A0E0000000] O
:[C0A0C08080000000] P
:[E0A0A0E060000000] Q
:[C0A0C0A0A0000000] R
:[60804020C0000000] S
:[E040404040000000] T
:[A0A0A0A0E0000000] U
:[A0A0A0A040000000] V
:[A0A0A0E0A0000000] W
:[A0A040A0A0000000] X
:[A0A0404040000000] Y
:[E0204080E0000000] Z
:[0060A0A060000000] a
:[0080C0A0C0000000] b
:[0060808060000000] c
:[002060A060000000] d
:[0040A0C060000000] e
:[006080C080000000] f
:[40A06020C0000000] g
:[0080C0A0A0000000] h
:[4000404040000000] i
:[200020A040000000] j
:[0080A0C0A0000000] k
:[00C0404040000000] l
:[00A0E0A0A0000000] m
:[00C0A0A0A0000000] n
:[0040A0A040000000] o
:[00C0A0C080000000] p
:[0060A06020000000] q
:[00A0C08080000000] r
:[0060402060000000] s
:[0080C08040000000] t
:[00A0A0A0E0000000] u
:[00A0A04040000000] v
:[00A0A0E0A0000000] w
:[00A04040A0000000] x
:[00A0A04080000000] y
:[E0204080E0000000] z
:[E0A0A0A0E0000000] 0
:[40C04040E0000000] 1
:[E020E080E0000000] 2
:[E020E020E0000000] 3
:[A0A0E02020000000] 4
:[E080E020E0000000] 5
:[E080E0A0E0000000] 6
:[E020408080000000] 7
:[E0A0E0A0E0000000] 8
:[E0A0E020E0000000] 9

voila ce sont les principaux caractere refait en 3par5

Le problème d'alignement je l'avais déjà énoncé mais je ne l'avais pas géré.

Je pense que 3*5 est insuffisant pour les caractères exceptionnels comme certaines lettres grecques.
Si on prend quand même 3*5, alors autant copier ceux de la TI voire utiliser les routines (donc caractères) de la TI.
EDIT: on ne pourra pas utiliser directement les routines de la TI car les caractères de sachiix69 sont cadrés plus haut.

Notez que la largeur des caractères graphiques TI est variable de 1 à 6.
Ainsi je suis d'autant plus persuadé de l'insuffisance de la largeur 3.
Par exemple le delta majuscule de TI occupe 5 caractères et le beta ressemble trop au B (sur ses 3 pixels).

Ce sera important de savoir si ton executable supportera une largeur variable pour pouvoir envisager de faire des caractères plus larges. De plus ce serait dommage de fixer une largeur excessive pour les caractères de base qui eux sont assez clairs en 3*5.

Précise les espacements des caractères entre eux et les espaces dessinés vierges, que ce soit généré par le programme ou par un espace vierge à l'intérieur des sprites. Précise aussi le cadrage de tes caractères minuscule, ça permet de savoir immédiatement comment cadrer les nouveaux.
Cela fait une différence de dessin des sprites.
EDIT: j'ai constaté sur a et c que le cadrage est en bas (à gauche) du cadre 3*5.

Pensez qu'on peut aussi créer des sprites différents pour des formats comme les indices/exposants.
EDIT : impossible si le but est de réduire la taille et qu'on est déjà au minimum

(J'envisage d'économiser de la mémoire en ne stockant pas les bits non-affichés du 8*8 habituel.
Il faudra modifier la routine d'affichage (mais je doûte que l'Axe soit d'accord) et utiliser l'éditeur de sprite de TokenIDE si on ne veut pas se fatiger à tronquer les datas.)

Alors je peut mettre des taille differentes ca demande juste de changer mon code.

cependant pour les lettres et chiffres normaux ont fais du 3x5 ca economisera de la place et on pourras affiche plus de texte non ?

Pour certains caractères minuscules, ça devient impossible le 3*5 Ex: m ou w
Si on classait les caractères dans la charmap par taille? Ex: 40 à 70 5 pixels de large, 100 à 150 3 pixels...
Et en fonction du nombre qui sort, on augmente ou on diminue le pas entre chaque lettre

Le but n'est pas de caser un maximum de caractères par page mais de faire quelque-chose de lisible et bien présenté

sachiix69 : Oui je suis d'accord pour garder le 3*5 pour le standard.
J'ai commencé à copier/adapter les sprites des caractères (de TI) que je trouve dans TiDoc. Quand ça dépasse en largeur, je dessine deux versions sauf si vraiment ça rentre pas. Quand ça ne colle pas en hauteur (surtout pour les exposants) je passe.

Bah un W en 3*5 ou un M ca donne ca :

111
010
010
000
010

la c;est ,moche mais ca le fait largement

Si on défini des caractères de largeur>3 en plus du standard, on pourra très bien tricher avec certains caractères du standard en les traitant comme des spéciaux de plus grande largeur.
Cela demande juste plus de travail à la compilation, surtout si on se contente de ranger par ordre de largeur.

Voici ce que j'ai fait hier, je me lasse et manque un peu de temps.
Rappel : pris dans l'odre de la table de TIDoc (et simplement de l'assembleur)

Code:

[00B0484890000000] n suite
[00A0A0A0E0000000] u suite
[00A0A04040000000] v suite
[00A0A0E0A0000000] w suite
[80C0E0C080000000] fleche convert
[0000000000000000] vide
[0070F87020000000] fleche bas
[2040404080000000] integral
[00A040A000000000] cross
[00E0A0E000000000] box graph (remonté)
[0040E04000000000] cross graph (remonté) // finalement identique à +
[0000400000000000] dot graph (remonté)
subT // confusion lettre T
exposant cube de racine // confusion 3
hexF // je connais pas et c'est confus
[604040C040000000] racine
[6020A00000000000] exposant -1 adapté mais bof ou [3010D01000000000] confus
exposant carre confus
[00204080E0000000] angle
[6090906000000000] degre confus
[A0C0808000000000] radian confus
[E040400000000000] transpose mais confusion avec T
[60806000E0000000] <= ou largeur 4 [30C03000F0000000]
[40E040E040000000] != ou largeur 4 [20F040F040000000]
[C020C000E0000000] >= ou largeur 4 [C030C000F0000000]
negatif // innutile et confus
exposant de dix // confus
[4020E02040000000] fleche store ou [4020F02040000000]
large 5 [00B8A8A8B8000000] indice 10
[40E0404040000000] fleche haut
[404040E040000000] fleche bas
[0000000000000000] space
[8080800080000000] !
[A0A0000000000000] "
large 5 [50F850F850000000] #
large 5 [78A07028F0000000] $
[A0204080A0000000] %
large 4 [40A040A050000000] &
[4040000000000000] '
[4080808040000000] (
[8040404080000000] )
large 5 [20A870A820000000] *
[0040E04000000000] +
[0000404080000000] ,
[0000E00000000000] -
[000000C0C0000000] .
[2020408080000000] /

Bon, premierement desolee linkakro mais les charactere 4x5 etait enfaite mieux... j'ai finis le scrolling il me reste plus qu'a rediger le readme et commencer l'implementation des fonctions

pour le moment j'ai :
-scrolling du texte
-lettre maj et min plus espace
-saut de ligne (code=200)
-ecrire en inverser....

J'qi juste deux ou trois propositions vous me dites si vous etes d'accord.

(1)Il faut prendre l'idee de faire des balise <>XXX et chaque octets present dans ces balise devra etre precedee de la commande a effectuer car sinon ca va etre galere pour les autre commande... si vous etes d'accord ca m'arrangerais bien

Pas grave pour la taille : quand c'est codé avec du vierge présent à la fin, c'est plus facile d'afficher sur 4 quelque chose rempli sur 3 que le contraire.

Je me demande si tu peux économiser de la mémoire en stockant les 5 lignes de sprite sur 5 octets, puisque les trois derniers octets seront toujours vierges dans cette solution.

Je ne suis pas sûr de comprendre ce que tu nous demandes.
Tu veux dire utiliser une syntaxe balisée dans l'éditeur et compiler avec un octet de format devant chaque caractère ?
Je préfère que le code compilé signale par les instructions de formats des flags à activer/désactiver. Cela pourra éviter d'utiliser une pile et alléger les fromats répétés. (pile qui permet de savoir quel format désactiver face à l'instruction de fin).
Si ce sont les flags qui te dérangent tu peux déjà essayer comme tu as dit (si j'ai compris ce que tu as dit).

Le principal probleme je vous l'expose....

quand je scroll vers le bas et que je rencontre une balise tout va bien ca marche parfaitement.... mais lorsque je remonte je rencontre les balise...a l'envers donc si il y a une balise qui joue sur plusieurs ligne bah ca bug totalement.... si vous voyer une solution...

Ta solution avec les flags marche parfaitement pour le scrool vers le bas.

Pousse mon idée d'unique instruction d'activation/désactivation jusqu'au bout : on peut interpréter dans les deux sens.
Cependant il faudra lire la ligne de droite à gauche lorsqu'on remonte l'écran.(sinon il faudra commencer par étudier la ligne avec des boucles).

Je réalise maintenant une chose embêtante : il pourra y avoir plusieurs usages d'un même format dans la même image.
Un seul flag ne suffit plus forcément. :S
Il faudra au minimum stocker un ensemble de flags pour un emplacement de l'écran, de préférence le tout début.
Ensuite on peut stocker pour d'autres emplacements (dont la fin) si cela peut éviter de réinterpréter régulièrment l'écran à chaque fois qu'on veut progresser à une autre extrémité.

Lire l'ecran a l'envers... je n'y avait pas penser, hum je vais essayer d'adapter ca.