| concernant la COMPILATION [] concernant le PROGRAMME compilé |
+-----------------------------------------------------++---------------------------------+
| OPTIMISATION | RAM UTILISEE | TEMPS [] TAILLE | TEMPS d'exécution |
------+-------------------------+--------------+------------++-------------+-------------------+
GTC | imposée ("standard") | 32 ko | 4 secondes [] 2197 octets | 59 secondes |
------+-------------------------+--------------+------------++-------------+-------------------+
TIGCC | taille et vitesse (-Os) | + de 32ko * | 7 secondes [] 2281 octets | 52 secondes |
------+-------------------------+--------------+------------++-------------+-------------------+
* : très probablement.
On voit que :
- GTC compile plus rapidement que TIGCC
- GTC a besoin de moins de RAM que TIGCC (vraiment très probable pour un compilateur de ce niveau)
- GTC a produit un programme plus petit
- TIGCC a produit un programme un peu plus rapide
Et maintenant, vous vous demandez quelles sources est capable de compiler GTC ?
Je n'y ai pas cru et pourtant c'est bien vrai : GTC a compilé sans broncher mon programme qui avait été codé pour TIGCC, je n'ai eu que le mot-clé inline à virer !
En clair, mon programme TIGCC a été compilé sans problème par GTC.
Voici la source :
// Programmé par Thibaut Barthélemy
// commentaires, questions : barthib@hotmail.com
// C Source File
// Created 08/09/02; 11:23:25
#define USE_TI89 // Compile for TI-89
#define USE_TI92PLUS // Compile for TI-92 Plus
#define USE_V200 // Compile for V200
#define MIN_AMS 100 // Compile for AMS 1.00 or higher
#define SAVE_SCREEN // Save/Restore LCD Contents
#include <tigcclib.h> // Include All Header Files
#define LONG (6+1)
#define HAUT (5+2)
#define DEPA (LONG+1)
#define PROFONDEUR_MAX 6
#define J_AI_GAGNE 16384
#define SANS_EFFET 0
typedef enum {BLANC=-1, NOIR=1, VIDE=0, FIN=2} CASE;
#define swap_player(player) (player == BLANC ? NOIR : BLANC)
CASE *jeu;
short niveaux[LONG-1];
void init_jeu(void)
{
short i;
for (i=LONG; i>=0; i--) jeu[i+LONG*(HAUT-1)+1]= jeu[i]= FIN;
for (i=DEPA; i<DEPA+LONG*(HAUT-2); i++)
jeu[i]= (i % LONG == 0) ? FIN : VIDE;
for (i=LONG-2; i>=0; i--) niveaux[i]= DEPA + i;
}
void dessine_jeu(void)
{
short x, y, i= DEPA;
clrscr();
for (y=HAUT-2; y>=1; y--)
{
for (x=0; x<=LONG-2; x++)
{
MoveTo(12*x, 8*y);
switch (jeu[i])
{
case BLANC : putchar('O'); break;
case NOIR : putchar('X'); break;
case VIDE : putchar(' '); break;
case FIN : putchar('#'); break;
}
putchar('|');
i++;
}
i++;
}
}
short alignement_possible(short repere)
{
short countdown;
CASE *pcase, *porig= &jeu[repere], joueur= *porig;
countdown= 3;
pcase= porig - LONG;
while (*pcase == joueur) {pcase-= LONG; countdown--;}
if (countdown <= 0) return J_AI_GAGNE;
countdown= 3;
pcase= porig + 1;
while (*pcase == joueur) {pcase+= 1; countdown--;}
if (countdown <= 0) return J_AI_GAGNE;
pcase= porig - 1;
while (*pcase == joueur) {pcase-= 1; countdown--;}
if (countdown <= 0) return J_AI_GAGNE;
countdown= 3;
pcase= porig + LONG + 1;
while (*pcase == joueur) {pcase+= LONG + 1; countdown--;}
if (countdown <= 0) return J_AI_GAGNE;
pcase= porig - LONG - 1;
while (*pcase == joueur) {pcase-= LONG + 1; countdown--;}
if (countdown <= 0) return J_AI_GAGNE;
countdown= 3;
pcase= porig + LONG - 1;
while (*pcase == joueur) {pcase+= LONG - 1; countdown--;}
if (countdown <= 0) return J_AI_GAGNE;
pcase= porig - LONG + 1;
while (*pcase == joueur) {pcase-= LONG - 1; countdown--;}
if (countdown <= 0) return J_AI_GAGNE;
return SANS_EFFET;
}
/* (inline n'est pas encore supporté par GTC)
inline*/ short ajout_possible(short repere)
{
return (repere < DEPA+LONG*(HAUT-2));
}
/* (inline n'est pas encore supporté par GTC)
inline*/ short ajouter_jeton(CASE joueur, short x)
{
short repere= niveaux[x];
if (!ajout_possible(repere)) return 0;
jeu[repere]= joueur;
niveaux[x]+= LONG;
return repere;
}
/* (inline n'est pas encore supporté par GTC)
inline*/ void retirer_jeton(short x)
{
short index= niveaux[x] - LONG;
if (index < DEPA) return;
jeu[index]= VIDE;
niveaux[x]= index;
}
short difference_case(CASE joueur, short x, short profondeur, short pire_difference)
{
short repere= ajouter_jeton(joueur, x);
if (repere != 0)
{
short difference= alignement_possible(repere);
if (difference != J_AI_GAGNE && profondeur > 0)
{
short colonne= LONG-2;
//short meilleure_prof= 0;
CASE adversaire= swap_player(joueur);
do
{
short diff_adverse= difference_case(adversaire, colonne, profondeur-1, -pire_difference);
if (diff_adverse == J_AI_GAGNE)
{
difference= -1; // l'adversaire a gagné : 1 point pour lui (comme il va soustraire le résultat, il faut rendre -1 pour que ça lui fasse +1...)
break; // on arrête de le faire jouer, il a gagné !
}
difference-= diff_adverse*(profondeur); // l'adversaire a gagné des points (négativement peut-être) : il faut les soustraire aux nôtres
/*if (difference <= pire_difference) break;
else pire_difference= difference;*/
//if (diff_adverse.profondeur > meilleure_prof) meilleure_prof= diff_adverse.profondeur;
} while (colonne--);
}
retirer_jeton(x);
return difference;
}
return 0;
}
short meilleure_colonne(CASE joueur)
{
short colonne= LONG-2, sp= -1, stack[LONG-1];
short diff= -32768;
do
{
if (ajout_possible(niveaux[colonne])) // si la colonne qu'on veut tester n'est pas pleine
{
short celleci= difference_case(joueur, colonne, PROFONDEUR_MAX, 0);
if (celleci > diff)
{
diff= celleci;
sp= 0;
stack[0]= colonne;
}
else
if (celleci == diff) stack[++sp]= colonne;
}
} while (colonne--);
return stack[random(sp + 1)];
}
short chute_jeton(CASE joueur, short x)
{
short y= 0, stop, index= ajouter_jeton(joueur, x);
if (index == 0) return 0;
stop= 8*(HAUT - 2) - 8*((index - 1)/LONG - 1);
x*= 12;
while (y < stop)
{
short timer= 10000;
MoveTo(x, y); putchar(' ');
y++;
MoveTo(x, y); putchar(joueur == BLANC ? 'O' : 'X');
while (timer--) /* ralentissement */;
}
return index;
}
short entree_joueur(CASE joueur)
{
short touche, x= 12*((LONG-1)/2);
do
{
MoveTo(x, 0);
touche= kbhit() ? ngetchx() : 0;
switch (touche)
{
case 340 : touche= 13; break; // bas
case 344 : x+= 24; // droite
if (x > (LONG - 1) * 12) x= 12;
case 338 : putchar(' '); // gauche
x-= 12;
if (x < 0) x= (LONG - 2) * 12;
MoveTo(x, 0);
break;
case 264 : return -1;
}
putchar(joueur == BLANC ? 'O' : 'X');
} while (touche != 13);
MoveTo(x, 0);
putchar(' ');
x= chute_jeton(joueur, x / 12);
if (x == 0) return entree_joueur(joueur);
else return x;
}
// Main Function
void _main(void)
{
short ordre;
clrscr();
printf("1- Vous commencezn2- Je commence");
ordre= ngetchx();
jeu= malloc((LONG*HAUT+2)*sizeof(*jeu));
init_jeu();
dessine_jeu();
randomize();
if (ordre == '1')
while (TRUE)
{
short choix= entree_joueur(BLANC);
if (choix == -1 || alignement_possible(choix)) break;
MoveTo(0, 0); printf("Je réfléchis...");
if (alignement_possible(chute_jeton(NOIR, meilleure_colonne(NOIR)))) break;
dessine_jeu();
}
else
while (TRUE)
{
MoveTo(0, 0); printf("Je réfléchis...");
if (alignement_possible(chute_jeton(BLANC, meilleure_colonne(BLANC)))) break;
dessine_jeu();
short choix= entree_joueur(NOIR);
if (choix == -1 || alignement_possible(choix)) break;
}
free(jeu);
MoveTo(0, 0); printf("Fin du jeu !");
ngetchx();
}
(c'est une ancienne version de mon Puissance 4, ne croyez pas que j'allais dévoiler la version qui déchire tout
)
Pollux : Etonnant ! Je suis sur le cul. J'ai faillit chialer quand je testais. Quand on voit de quoi tu es partit, je dirais que 60% des fonctionnalités (dont beaucoup sont extrêmement compliquées à coder) de GTC sont de ta main.
Respect éternel !
)
