J'avais trouvé ça il y a quelques années mais je n'ai pas testé si c'était correct. Il s'agit à priori du format des fichiers GFA 3.
Un volontaire pour nous faire un éditeur moderne ?
http://members.aol.com/vbdis/GFAFormat.htm
Kochise :
Eine schone AVL baum, meine liebe ! Ich glaube das MString library muss dieses arbeit ganz klar machen...
Some links to help you my dear :
http://mstring.sourceforge.net/
http://www.niksula.cs.hut.fi/~tik76122/arkisto/dsaa_c2e/files.html
http://www.codeproject.com/cpp/avltree.asp
Kochise
Avant, j'ai travaillé dans l'embarqué (petits processeurs avec peu de RAM/ROM) chez Motorola (à Angers), Magneti Marelli (Chatellerault), Sagem (Pontoise), Johnson Controls (Pontoise)... Aaaahhhh, le pied, un processeur Nec 8 bits ou Hitachi 16 bits, et même ARM 32 bits, 4 Ko de RAM, 128 Ko de ROM, un émulateur, miam Ma production la plus connue est la gestion intégrale de l'affichage de la J77 de Renault, la nouvelle Modus Un bonheur à programmer, et c'est pourtant du C :/ Tout ce que j'ai pu coder dans l'embarqué, c'est du C :/
truc%=2 ! Un LONG sur 32 bits qui vaut 2 trac=FN Calcul(truc%) ! On récupère un flottant sur 6 octets (format GFA) qui vaut 4 GOSUB Affiche(trac) ! On affiche la variable 'trac' ~INP(2) ! On attend une touche EXIT ! On se barre FUNCTION Calcul(var%) RETURN (var% * 2) ENDFUNC PROCEDURE Affiche(flottant) PRINT "Résultat = ";flottant RETURN
/* Comme le compilo est à une passe, on définie la gueule des fonctions pour qu'elles soient connues dans 'main */
float Calcul(int); /* Ce n'est pas les fonctions, juste la définition du prototype */
void Affiche(float); /* Avec ça le compilot pourra vérifier si on n'a pas fait une faute de syntaxe */
int main(void) /* Le programme commence TOUJOURS dans la fonction qui s'appelle 'main' */
{ /* Les accolades servent au compilateur à connaitre la hiérarchie des fonctions, puisqu'il n'y à pas d'indentation automatique */
int truc = 2; /* On définie un variable locale et on l'initialise à 2 */
float trac = Calcul(truc); /* Un flottant sur 4 octets, et on l'initialise avec le résultat du calcul */
Affiche(trac); /* Affiche le résultat */
getch(); /* Equivalent de VOID INP(2), on attend un caractère du clavier mais sans utiliser la valeur retournée par getch() */
return 0; /* Si on arrive là, le programme se termine, on renvoie un code d'erreur, comme pour PTERM */
}
float Calcul(int var)
{
return (var * 2); /* Pas plus compliqué que ça */
}
void Affiche(float flottant)
{
printf("Résultat = %ld\r\n", flottant); /* Affiche le résultat en tant que flottant, \r\n c'est CRLF, $0D$0A en assembleur */
}
Pour comprendre l'intéret de la définition des prototypes des fonctions, il faut savoir que j'aurais pu écrire le même programme comme ça :
/* On écrit directement les fonctions avant le 'main', comme ça leur format d'entrée/sorie sera connu dans 'main */
float Calcul(int var)
{
return (var * 2); /* Pas plus compliqué que ça */
}
void Affiche(float flottant)
{
printf("Résultat = %ld\r\n", flottant); /* Affiche le résultat en tant que flottant */
}
int main(void) /* Le programme commence TOUJOURS dans la fonction qui s'appelle 'main' */
{ /* Les accolades servent au compilateur à connaitre la hiérarchie des fonctions, puisqu'il n'y à pas d'indentation automatique */
int truc = 2; /* On définie un variable locale et on l'initialise à 2 */
float trac = Calcul(truc); /* Un flottant sur 4 octets, et on l'initialise avec le résultat du calcul */
Affiche(trac); /* Affiche le résultat */
getch(); /* Equivalent de VOID INP(2), on attend un caractère du clavier mais sans utiliser la valeur retournée par getch() */
return 0; /* Si on arrive là, le programme se termine, on renvoie un code d'erreur, comme pour PTERM */
}
/* Fichier de définition */ float Calcul(int); /* Ce n'est pas les fonctions, juste la définition du prototype */ void Affiche(float); /* Avec ça le compilot pourra vérifier si on n'a pas fait une faute de syntaxe */
#include "Test.h"
int main(void) /* Le programme commence TOUJOURS dans la fonction qui s'appelle 'main' */
{ /* Les accolades servent au compilateur à connaitre la hiérarchie des fonctions, puisqu'il n'y à pas d'indentation automatique */
int truc = 2; /* On définie un variable locale et on l'initialise à 2 */
float trac = Calcul(truc); /* Un flottant sur 4 octets, et on l'initialise avec le résultat du calcul */
Affiche(trac); /* Affiche le résultat */
getch(); /* Equivalent de VOID INP(2), on attend un caractère du clavier mais sans utiliser la valeur retournée par getch() */
return 0; /* Si on arrive là, le programme se termine, on renvoie un code d'erreur, comme pour PTERM */
}
float Calcul(int var)
{
return (var * 2); /* Pas plus compliqué que ça */
}
void Affiche(float flottant)
{
printf("Résultat = %ld\r\n", flottant); /* Affiche le résultat en tant que flottant */
}
/* Définition de la fonction Einstein */ float Einstein(float super); /* On peut mettre un nom ici pour aider à la compréhension, mais le compilo à juste besoin du type de la variable */
/* La fonction e=mc2 */
float Einstein(float machin) /* Le nom de la variable est important ICI, pas dans la définition. Mais le type doit bien correspondre à la définition */
{
return machin*machin;
}
#include "Test.h"
#include "Einstein.h" /* Bah oui, faut pas l'oublier, on ajoute une fonction */
int main(void) /* Le programme commence TOUJOURS dans la fonction qui s'appelle 'main' */
{ /* Les accolades servent au compilateur à connaitre la hiérarchie des fonctions, puisqu'il n'y à pas d'indentation automatique */
int truc = 2; /* On définie un variable locale et on l'initialise à 2 */
float trac = Calcul(truc); /* Un flottant sur 4 octets, et on l'initialise avec le résultat du calcul */
Affiche(Einstein(trac)); /* Affiche la valeur Einstein du résultat de Calcul */
getch(); /* Equivalent de VOID INP(2), on attend un caractère du clavier mais sans utiliser la valeur retournée par getch() */
return 0; /* Si on arrive là, le programme se termine, on renvoie un code d'erreur, comme pour PTERM */
}
compile : Test.c -> Test.o compile : Einstein.c -> Einstein.o link : Test.o Einstein.o -> Programme.prg
/* Fichier de définition */
float Calcul(int); /* Ce n'est pas les fonctions, juste la définition du prototype */
void Affiche(float); /* Avec ça le compilot pourra vérifier si on n'a pas fait une faute de syntaxe */
/* Définition de la fonction Einstein */
float Einstein(float super); /* On peut mettre un nom ici pour aider à la compréhension, mais le compilo à juste besoin du type de la variable */
int main(void) /* Le programme commence TOUJOURS dans la fonction qui s'appelle 'main' */
{ /* Les accolades servent au compilateur à connaitre la hiérarchie des fonctions, puisqu'il n'y à pas d'indentation automatique */
int truc = 2; /* On définie un variable locale et on l'initialise à 2 */
float trac = Calcul(truc); /* Un flottant sur 4 octets, et on l'initialise avec le résultat du calcul */
Affiche(Einstein(trac)); /* Affiche la valeur Einstein du résultat de Calcul */
getch(); /* Equivalent de VOID INP(2), on attend un caractère du clavier mais sans utiliser la valeur retournée par getch() */
return 0; /* Si on arrive là, le programme se termine, on renvoie un code d'erreur, comme pour PTERM */
}
float Calcul(int var)
{
return (var * 2); /* Pas plus compliqué que ça */
}
void Affiche(float flottant)
{
printf("Résultat = %ld\r\n", flottant); /* Affiche le résultat en tant que flottant */
}
/* La fonction e=mc2 */
float Einstein(float machin) /* Le nom de la variable est important ICI, pas dans la définition. Mais le type doit bien correspondre à la définition */
{
return machin*machin;
}
compile : Test.c -> Test.o link : Test.o Einstein.o -> Programme.prg
#define DEBUG
int main(void)
{
int truc = 2;
#ifdef DEBUG
printf("DEBUG : Avant Calcul, truc fait = %d\r\n", truc);
#endif
float trac = Calcul(truc);
#ifdef DEBUG
printf("DEBUG : Après Calcul, trac fait = %ld", trac);
#endif
Affiche(Einstein(trac)); /* Affiche la valeur Einstein du résultat de Calcul */
getch(); /* Equivalent de VOID INP(2), on attend un caractère du clavier mais sans utiliser la valeur retournée par getch() */
return 0;
}
DEBUG : Avant Calcul, truc fait = 2 DEBUG : près Calcul, trac fait = 4 Résultat = 16
C'était un générateur de montagne fractale parus dans ST Magazine n°53 d'été 91 que j'avais repris et considérablement modifié, même que j'avais écrit une version qui générait des height-field pour NeoN GraphiX. Mais la taille des fichiers générés prohibait toute utilisation, même sur une machine de 14 Mo :/
La version C va suivre...
Le C, c'est donc vraiment comme l'assembleur, il faut traiter les chaines de caractères à la main, ou utiliser les fonctions d'une librairie comme 'stdio'. Sur ATARI, ces librairies sont en ROM et connues sous le nom de GEMDOS/BIOS/XBIOS
)Kochise :
Naaaaan, j'la fait (je sait coder en ASM quand même)Mais code ta version, on compare le style ensuite
Kochise
D'ailleurs moins j'en fait mieux je me porte... Mais pour le sport, pourquoi pas ! Dire que mon FRAMOGEN date de 2001 :/ Eeeek, reprendre du vieux code !
J'me lance pas trop ce soir, la flème (grosse maladie ça) !
Rapide et simple... Le VDI utilise la LineA quand elmle est disponible, pour quelques fonctions. Ca me faisait chier de définir des tableaux et pomper la VDI juste pour deux infos Je t'avais prévenu, ch'us un branleur en puissance... Remarque, la version 8 publique qui sera donc écrite en GFA/ASM/C récupèrera la réso par VDI, vu qu'appeler la LineA par le C c'est pas vraiment pratique (même astuce que sur GFA, mais plus chiadé).
Mais je vais modifier ça en dithering (error diffusion) histoire que ça passe mieux. Tu ne verras pas les pixels à cause de la rotation, ce sera trop rapide pour l'oeil...
)