Forum Casio - Problèmes SDK divers et variés par Theprog

Forum Casio - Autres questions

Index du Forum » Autres questions » Problèmes SDK divers et variés

Theprog Hors ligne Membre Points: 1447 Défis: 20 Message

Problèmes SDK divers et variés

Posté le 26/10/2013 11:00

Salut j'ai fait un petit programme mais je comprends pas pourquoi la fonction Print ne veut pas afficher la chaine que je lui demande ...

Le code

Cliquer pour enrouler

#include "fxlib.h"
#include "stdio.h"

unsigned int key;
int caractere, caractere2;
char chaine[21];
char ident[21];
char domaine[30];
char mdp[30];
char destinataire[40];
char sujet[30];
char corps[50];

int AddIn_main(int isAppli, unsigned short OptionNum){
    Bdisp_AllClr_DDVRAM();
    demmarage();
    identif();

    return 1;
}

demmarage(){
    int key;
    Bdisp_AllClr_DDVRAM();
    PrintMini(80,58,"Version 1.0",0);
    Bdisp_DrawLineVRAM(10,10,10,50);
    Bdisp_DrawLineVRAM(10,50,117,50);
    Bdisp_DrawLineVRAM(117,50,117,10);
    Bdisp_DrawLineVRAM(10,10,117,10);
    Bdisp_DrawLineVRAM(10,10,63,25);
    Bdisp_DrawLineVRAM(117,10,63,25);
    locate(7,5);
    Print("Messagerie");
    do{
        GetKey(&key);
    } while(key != 30004);

    Bdisp_AllClr_DDVRAM();
}

identif(){
    Bdisp_AllClr_DDVRAM();
    locate(1,1);
    Print("Identifiant:");
    locate(1,2);
    Print("+------------------+");
    locate(1,3);
    Print("|                  |");
    locate(1,4);
    Print("+------------------+");
    remplichaine();

    caractere2=0;
    do{
        caractere2++;
        ident[caractere2] = chaine[caractere2];
    } while(caractere2+1 != caractere);
    ========================== > ICI < ========
    locate(2,3);
    Print(ident);
    do{
        GetKey(&key);
    } while(key != 30004);

}

remplichaine(){
    caractere=0;
    do{
        caractere++;
    ======================= > ET ICI < ========
        locate(2,3);
        Print(chaine);
        GetKey(&key);
        //==========Conversion==========
        if (key==48)key= 71;
        if (key==46)key= 61;
        if (key==15)key= 51;
        if (key==135)key= 41;
        if (key==30004)key= 31;
        if (key==49)key= 72;
        if (key==50)key= 62;
        if (key==51)key= 52;
        if (key==137)key= 42;
        if (key==153)key= 32;
        if (key==52)key= 73;
        if (key==53)key= 63;
        if (key==54)key= 53;
        if (key==169)key= 43;
        if (key==185)key= 33;
        if (key==55)key= 74;
        if (key==56)key= 64;
        if (key==57)key= 54;
        if (key==30025)key= 44;
        if (key==30015)key= 34;
        if (key==187)key= 75;
        if (key==30046)key= 65;
        if (key==40)key= 55;
        if (key==41)key= 45;
        if (key==44)key= 35;
        if (key==14)key= 25;
        if (key==30001)key= 76;
        if (key==149)key= 66;
        if (key==133)key= 56;
        if (key==129)key= 46;
        if (key==130)key= 36;
        if (key==131)key= 26;
        if (key==30007)key= 77;
        if (key==205)key= 67;
        if (key==168)key= 57;
        if (key==30002)key= 47;
        if (key==30023)key= 37;
        if (key==30021)key= 27;
        if (key==30006)key= 78;
        if (key==30008)key= 68;
        if (key==30016)key= 58;
        if (key==30020)key= 38;
        if (key==30018)key= 28;
        if (key==30009)key= 79;
        if (key==30010)key= 69;
        if (key==30011)key= 59;
        if (key==30012)key= 49;
        if (key==30013)key= 39;
        if (key==30014)key= 29;
        //==============================
        if(key==31)caractere=19;
        if(key==76)chaine[caractere]='a';
        if(key==66)chaine[caractere]='b';
        if(key==56)chaine[caractere]='c';
        if(key==46)chaine[caractere]='d';
        if(key==36)chaine[caractere]='e';
        if(key==26)chaine[caractere]='f';
        if(key==75)chaine[caractere]='g';
        if(key==65)chaine[caractere]='h';
        if(key==55)chaine[caractere]='i';
        if(key==45)chaine[caractere]='j';
        if(key==35)chaine[caractere]='k';
        if(key==25)chaine[caractere]='l';
        if(key==74)chaine[caractere]='m';
        if(key==64)chaine[caractere]='n';
        if(key==54)chaine[caractere]='o';
        if(key==73)chaine[caractere]='p';
        if(key==63)chaine[caractere]='q';
        if(key==53)chaine[caractere]='r';
        if(key==43)chaine[caractere]='s';
        if(key==33)chaine[caractere]='t';
        if(key==72)chaine[caractere]='u';
        if(key==62)chaine[caractere]='v';
        if(key==52)chaine[caractere]='w';
        if(key==42)chaine[caractere]='x';
        if(key==32)chaine[caractere]='y';
        if(key==71)chaine[caractere]='z';
        if(key==61)chaine[caractere]='.';
        if(key==57)chaine[caractere]='@';
    } while(caractere!=19);

    if(key==31)chaine[caractere]='\0';
    if(key!=31)chaine[caractere+1]='\0';
}

#pragma section _BR_Size
unsigned long BR_Size;
#pragma section
#pragma section _TOP
int InitializeSystem(int isAppli, unsigned short OptionNum){return INIT_ADDIN_APPLICATION(isAppli, OptionNum);}
#pragma section

la chaine ident fait 21 caracteres

Précédente – 1, 2, 3 ··· 6, 7, 8, 9, 10, 11, 12 ··· 20, 21, 22, 23 – Suivante

Theprog Hors ligne Membre Points: 1447 Défis: 20 Message

Citer : Posté le 29/04/2014 01:13 | #

Ben en grosz stocker un octet comme ça:

octet monOctet[]={00100110}

∆ Mon RPG en Basic ◄► Mon simulateur spatial ◄► Mon Fourmizzz ◄► Mon projet en cours ∆

Limachi Hors ligne Youtuber Points: 2798 Défis: 67 Message

Citer : Posté le 29/04/2014 01:59 | #

les char et unsigned char sont des octets, pour "octet monOctet[]={0,0,1,0,0,1,1,0};" tu peux faire "unsigned char monOctet=38;" ou "unsigned char monOctet=0x26;" et enfin si tu veux y aller au bit par bit (0b ne marchant pas sur le sdk quant j'ai tenté de l'utiliser) "unsigned char monOctet=1<<1|1<<2|1<<5;"

Ajouté le 29/04/2014 à 02:02 :
et pour lire un bit particulier de l'octet voici une formule: (monOctet&(1<<b))>>b (b étant le numéro de bit que tu veux lire, 0 étant celui de "droite" et 7 celui de "gauche", le ()>>b est facultatif, sans ça tu as 0 ou 1*2^b en sortie, et avec tu as 0 ou 1)

Mes Programmes

Cliquer pour enrouler

-en basic: un programme nommé PICFMLIM convertissant une picture en code basic.
-en C:
-Un pong.
-Un projet en pause. Je compte le reprendre de temps en temps: Summer Cursed

-mon tuto sur les Str

Mes calto: G25+, G75
Mon minecraft en dévelopement

Projets et Programmes que je soutiens (sur une idée de Marmotti)

Cliquer pour enrouler

-Pokemon Jade de Dodormeur
-Portal2D de JavierXD
-CalCraft de Wime
-GeekBros du groupe GeekBrothers (Eiyeron,Siapran,KevKevVTT,Adbook,LIMachi)

Dark storm Hors ligne Labélisateur Points: 11634 Défis: 176 Message

Citer : Posté le 29/04/2014 08:29 | #

Perso, pour ça j'utilise :

(mon_octet>>b)%2

Et ça retourne 0 ou 1 (avec 0 le bit de droite, 7 celui de gauche)

Ajouté le 29/04/2014 à 08:29 :
Par contre ça doit être moins rapide.

Finir est souvent bien plus difficile que commencer. — Jack Beauregard

Theprog Hors ligne Membre Points: 1447 Défis: 20 Message

Citer : Posté le 29/04/2014 09:10 | #

je vais exposer mon besoin comme ça ça sera plus simple.

En fait je dois faire un encodeur en base 64.
Donc dans un premier temps, il me faut les codes binaires ASCII de chaque caractères de la chaine, puis dans un second temps, exploiter par groupe de 3 octets pour ressortir le code en base 64.
C'est sûrement pas très clair mais voilà ce que je dois faire

∆ Mon RPG en Basic ◄► Mon simulateur spatial ◄► Mon Fourmizzz ◄► Mon projet en cours ∆

Lephenixnoir Hors ligne Administrateur Points: 24235 Défis: 170 Message

Citer : Posté le 29/04/2014 10:44 | #

Les codes binaires ASCII ? Facile.

char ch[20] = "Une chaine";
int x = ch[3];

Les caractères sont des entiers (entre simple cotes ' ', les constantes cacactères sont des entiers). Tu peux les additioner, soustraire, tout ce que tu veux. Tu peux aussi écrire

sprintf(str,"%d",ch[2]);

Le cast est automatique.

Par contre, pourquoi 3 octets pour une base 64 ?

Mon graphe (11 Avril): ((Rogue Life || HH2) ; PythonExtra ; serial gint ; Boson X ; passe gint 3 ; ...) || (shoutbox v5 ; v5)

Theprog Hors ligne Membre Points: 1447 Défis: 20 Message

Citer : Posté le 29/04/2014 10:52 | #

Ca je sais mais voila le truc:
1) mettons que ma chaine soit: "ABC"
2) son code binaire est: 01000001 01000010 01000011
3) je doit prendre la chaine par paquet de 3 octets car en base 64, chaque chiffre est une lettre codée sur 6 bits
4) je me retrouve donc avec 4 chiffres: 010000 010100 001001 000011
5) Ce qui correspond a: QUJD

∆ Mon RPG en Basic ◄► Mon simulateur spatial ◄► Mon Fourmizzz ◄► Mon projet en cours ∆

Lephenixnoir Hors ligne Administrateur Points: 24235 Défis: 170 Message

Citer : Posté le 29/04/2014 10:55 | #

Dans ce cas, tu est obligé de découper les octets, et de partir par la fin, si le nombre de bits n'est pas un multiple de 6.

Ajouté le 29/04/2014 à 10:55 :
Pour prendre 6 bits dans un octet à partir du n-ième:

(byte>>n)&63

Mon graphe (11 Avril): ((Rogue Life || HH2) ; PythonExtra ; serial gint ; Boson X ; passe gint 3 ; ...) || (shoutbox v5 ; v5)

Theprog Hors ligne Membre Points: 1447 Défis: 20 Message

Citer : Posté le 29/04/2014 10:56 | #

Si le nombre de bits est trop grand ou trop faible, il faut rajouter un '=' a la fin du code en base 64

Ajouté le 29/04/2014 à 10:57 :
Au passage, e comprends pas pourquoi ma calto n'accepte pas:

void dec_bin(int nbr, char* chaine)
{
    int reste;
    int i;

    reste = nbr;

    for(i=0;i<8;i++){
        sprintf(chaine[7-i],"%d",reste%2);
        reste = reste/2;
    }
}

Le probleme est dans le sprintf ...

Ajouté le 29/04/2014 à 11:09 :
Je sais ca reste pas tres propre mais je comprends pas pourquoi le sprintf me fait sortir un Systeme Error

void dec_bin(int nbr, char* chaine)
{
    int reste[8];
    int i;

    for(i=0;i<8;i++){
        reste[7-i] = nbr%2;
        nbr= nbr/2;
    }
    sprintf(chaine, "%d%d%d%d%d%d%d%d", reste[0], reste[1], reste[2], reste[3], reste[4], reste[5], reste[6], reste[7]);

}

∆ Mon RPG en Basic ◄► Mon simulateur spatial ◄► Mon Fourmizzz ◄► Mon projet en cours ∆

Lephenixnoir Hors ligne Administrateur Points: 24235 Défis: 170 Message

Citer : Posté le 29/04/2014 11:14 | #

C'est parce que tu as oublié l'include (stdio.h) ?
Ça génère toujours une SR.

Mon graphe (11 Avril): ((Rogue Life || HH2) ; PythonExtra ; serial gint ; Boson X ; passe gint 3 ; ...) || (shoutbox v5 ; v5)

Theprog Hors ligne Membre Points: 1447 Défis: 20 Message

Citer : Posté le 29/04/2014 11:16 | #

abruti que je suis ...
J'avais pas fait gaffe

Ajouté le 29/04/2014 à 11:17 :
Maintenant ca marche niquel

Forcement ...

∆ Mon RPG en Basic ◄► Mon simulateur spatial ◄► Mon Fourmizzz ◄► Mon projet en cours ∆

Lephenixnoir Hors ligne Administrateur Points: 24235 Défis: 170 Message

Citer : Posté le 29/04/2014 11:46 | #

Simple information.

a = n%2;
n = n/2;

peut être optimisé en

a = n&1;
n >> = 1;

Mon graphe (11 Avril): ((Rogue Life || HH2) ; PythonExtra ; serial gint ; Boson X ; passe gint 3 ; ...) || (shoutbox v5 ; v5)

Theprog Hors ligne Membre Points: 1447 Défis: 20 Message

Citer : Posté le 29/04/2014 18:17 | #

Encore un probleme face a moi

Donc voila ma chaine b64 devrait se remplir mais elle le fait pas ...

Le code

Cliquer pour enrouler

void encoder(char* identifiant, char* mdp, int longueur)
{
    char code_bin[496];
    char total[32];
    char bin[20];
    char b64[60];

    int curseur;
    int i, j;
    int nbr_bit;

    curseur = 0;
    total[0] = '\0';

    // REMPLISSAGE CHAINE total
    while(identifiant[curseur]!='\0'){
        curseur++;
        total[curseur] = identifiant[curseur-1];
    }
    curseur++;
    total[curseur] = '\0';
    while(mdp[curseur-2-longueur]!='\0'){
        curseur++;
        total[curseur] = mdp[curseur-3-longueur];
    }

    nbr_bit = 0;
    // REMPLISSAGE CODE BINAIRE total
    for(i=0; i<=curseur;i++){
        dec_bin(total[i], bin);
        for(j=0; j<8; j++){
            code_bin[j+8*i] = bin[j];
        }
        nbr_bit += 8;
    }

    // ENCODAGE B64
    bin_b64(code_bin, b64, nbr_bit);

    while(1){
        Sleep(500);
    }
}

void dec_bin(int nbr, char* chaine)
{
    char buf[10];
    int reste;
    int i;

    for(i=0;i<8;i++){
        reste = nbr%2;
        nbr= nbr/2;
        sprintf(buf, "%d", reste);
        chaine[7-i] =  buf[0];
    }
}

void bin_b64(char* bin, char* b64, int nbr_bit)
{
    int nbr;
    int i, j;

    i = nbr_bit/6;

    // /!\
    for(j=0; j<i; j++){
        if(test_b64(bin, 6*j, "000000")) b64[j] = 'A';
        if(test_b64(bin, 6*j, "000001")) b64[j] = 'B';
        if(test_b64(bin, 6*j, "000010")) b64[j] = 'C';
        if(test_b64(bin, 6*j, "000011")) b64[j] = 'D';
        if(test_b64(bin, 6*j, "000100")) b64[j] = 'E';
        if(test_b64(bin, 6*j, "000101")) b64[j] = 'F';
        if(test_b64(bin, 6*j, "000110")) b64[j] = 'G';
        if(test_b64(bin, 6*j, "000111")) b64[j] = 'H';
        if(test_b64(bin, 6*j, "001000")) b64[j] = 'I';
        if(test_b64(bin, 6*j, "001001")) b64[j] = 'J';
        if(test_b64(bin, 6*j, "001010")) b64[j] = 'K';
        if(test_b64(bin, 6*j, "001011")) b64[j] = 'L';
        if(test_b64(bin, 6*j, "001100")) b64[j] = 'M';
        if(test_b64(bin, 6*j, "001101")) b64[j] = 'N';
        if(test_b64(bin, 6*j, "001110")) b64[j] = 'O';
        if(test_b64(bin, 6*j, "001111")) b64[j] = 'P';
        if(test_b64(bin, 6*j, "010000")) b64[j] = 'Q';
        if(test_b64(bin, 6*j, "010001")) b64[j] = 'R';
        if(test_b64(bin, 6*j, "010010")) b64[j] = 'S';
        if(test_b64(bin, 6*j, "010011")) b64[j] = 'T';
        if(test_b64(bin, 6*j, "010100")) b64[j] = 'U';
        if(test_b64(bin, 6*j, "010101")) b64[j] = 'V';
        if(test_b64(bin, 6*j, "010110")) b64[j] = 'W';
        if(test_b64(bin, 6*j, "010111")) b64[j] = 'X';
        if(test_b64(bin, 6*j, "011000")) b64[j] = 'Y';
        if(test_b64(bin, 6*j, "011001")) b64[j] = 'Z';
        if(test_b64(bin, 6*j, "011010")) b64[j] = 'a';
        if(test_b64(bin, 6*j, "011011")) b64[j] = 'b';
        if(test_b64(bin, 6*j, "011100")) b64[j] = 'c';
        if(test_b64(bin, 6*j, "011101")) b64[j] = 'd';
        if(test_b64(bin, 6*j, "011110")) b64[j] = 'e';
        if(test_b64(bin, 6*j, "011111")) b64[j] = 'f';
        if(test_b64(bin, 6*j, "100000")) b64[j] = 'g';
        if(test_b64(bin, 6*j, "100001")) b64[j] = 'h';
        if(test_b64(bin, 6*j, "100010")) b64[j] = 'i';
        if(test_b64(bin, 6*j, "100011")) b64[j] = 'j';
        if(test_b64(bin, 6*j, "100100")) b64[j] = 'k';
        if(test_b64(bin, 6*j, "100101")) b64[j] = 'l';
        if(test_b64(bin, 6*j, "100110")) b64[j] = 'm';
        if(test_b64(bin, 6*j, "100111")) b64[j] = 'n';
        if(test_b64(bin, 6*j, "101000")) b64[j] = 'o';
        if(test_b64(bin, 6*j, "101001")) b64[j] = 'p';
        if(test_b64(bin, 6*j, "101010")) b64[j] = 'q';
        if(test_b64(bin, 6*j, "101011")) b64[j] = 'r';
        if(test_b64(bin, 6*j, "101100")) b64[j] = 's';
        if(test_b64(bin, 6*j, "101101")) b64[j] = 't';
        if(test_b64(bin, 6*j, "101110")) b64[j] = 'u';
        if(test_b64(bin, 6*j, "101111")) b64[j] = 'v';
        if(test_b64(bin, 6*j, "110000")) b64[j] = 'w';
        if(test_b64(bin, 6*j, "110001")) b64[j] = 'x';
        if(test_b64(bin, 6*j, "110010")) b64[j] = 'y';
        if(test_b64(bin, 6*j, "110011")) b64[j] = 'z';
        if(test_b64(bin, 6*j, "110100")) b64[j] = '0';
        if(test_b64(bin, 6*j, "110101")) b64[j] = '1';
        if(test_b64(bin, 6*j, "110110")) b64[j] = '2';
        if(test_b64(bin, 6*j, "110111")) b64[j] = '3';
        if(test_b64(bin, 6*j, "111000")) b64[j] = '4';
        if(test_b64(bin, 6*j, "111001")) b64[j] = '5';
        if(test_b64(bin, 6*j, "111010")) b64[j] = '6';
        if(test_b64(bin, 6*j, "111011")) b64[j] = '7';
        if(test_b64(bin, 6*j, "111100")) b64[j] = '8';
        if(test_b64(bin, 6*j, "111101")) b64[j] = '9';
        if(test_b64(bin, 6*j, "111110")) b64[j] = '+';
        if(test_b64(bin, 6*j, "111111")) b64[j] = '/';
    }
}

int test_b64(char* bin, int curseur, char* comparaison)
{
    char buffer[6];
    int nbr;

    for(nbr = curseur; nbr<6+6*curseur; nbr++){
        buffer[nbr%6] = bin[nbr];
    }

    // debug(curseur);

    if(strcmp(buffer, comparaison)) return 0;
    else return 1;
}

Si quelqu'un de genereux pouvait encore m'aider

∆ Mon RPG en Basic ◄► Mon simulateur spatial ◄► Mon Fourmizzz ◄► Mon projet en cours ∆

Lephenixnoir Hors ligne Administrateur Points: 24235 Défis: 170 Message

Citer : Posté le 29/04/2014 18:23 | #

Mais qu'est-ce que tu nous a fait ?

Attends une seconde, je vais regarder plus en détail.

Ajouté le 29/04/2014 à 18:31 :

void encoder(unsigned char *source, unsigned char *dest, int len)
{
  int i,j;
  unsigned char tmp;

  len /= 6;
  for(i=0;i<len;i++)
  {
    tmp=0;
    for(j=0;j<6;j++)
    tmp += getBit(source,6*i+j);
  }
  dest[i] = tmp;
}

int getBit(unsigned char *src, int index)
{
  return *(src+(index>>3)) & (128>>(index&7));
}

Là, ta suite de bits devrait être identique mais séparée par 6.

01100110 01001001 11100001 devient [blue]00[/blue]011001 [blue]00[/blue]100100 [blue]00[/blue]100111 [blue]00[/blue]100001

C'est bien ce que tu veux ?
Ensuite, il ne te reste plus qu'à transformer les octets obtenus selon ta table de conversion (dont je n'ai pas compris le principe

Mon graphe (11 Avril): ((Rogue Life || HH2) ; PythonExtra ; serial gint ; Boson X ; passe gint 3 ; ...) || (shoutbox v5 ; v5)

Theprog Hors ligne Membre Points: 1447 Défis: 20 Message

Citer : Posté le 29/04/2014 23:40 | #

Alors en fait c'est pour l'encodage en base 64 de l'identifiant et du mot de passe pour l'accès au serveur SMTP...
Pour la base 64

http://fr.m.wikipedia.org/wiki/Base64
Pour les serveur SMTP :here :http://fr.openclassrooms.com/informatique/cours/comprendre-la-messagerie-electronique/l-encodage-base64

Mon problème est que le code binaire est bon mais que la conversion en b64 ne marche pas

Ajouté le 29/04/2014 à 23:43 :
Je ne gère pas encore les bits restants dans le cas ou il faudrait rajouter un égal ...

Ajouté le 30/04/2014 à 00:13 :
Bon après beaucoup de temps a debugger, j'ai réussi a isoler des soucis:
-deja:

nbr<6+6*curseur

se remplace par:

nbr<6+curseur

-ensuite j'ai un bug dans ma variable "char buffer[6]" de "test_b64()" qui a deux cases en trop

En effet le debug m'affiche par exemple:
buffer = 010001T2

Ajouté le 30/04/2014 à 00:20 :
Bon je vais arreter de faire un monologue mais la je suis une fois de plus sur les fesses...

int test_b64(char* bin, int curseur, char* comparaison)
{
    char buffer[6];
    char buf[6];
    int nbr;
    int debug = 0;

    for(nbr = curseur; nbr<6+curseur; nbr++){
        buffer[nbr%6] = bin[nbr];
        debug = nbr%6;
    }
    buffer[6] = '\0';

    if(strcmp(buffer, comparaison)) return 0;
    else return 1;
}

Il l'accepte et ca a suffit a debugger

∆ Mon RPG en Basic ◄► Mon simulateur spatial ◄► Mon Fourmizzz ◄► Mon projet en cours ∆

Lephenixnoir Hors ligne Administrateur Points: 24235 Défis: 170 Message

Citer : Posté le 30/04/2014 07:37 | #

Donc ton tableau bin contient les octets en 0 et en 1 ? Ou en '0' et en '1' (c.a.d. 48 et 49) ?
Si tu as effectivement des valeurs nulles, alors passe un void *, puis caste-le en unsigned char *.

Et puis !

char buffer[[blue]6[/blue]];
...
buffer[[red]6[/red]] = 0;

Qui t'a appris ça ?

buffer[nbr%6] = bin[nbr];

Est-tu sûr qu'à la première itération, nbr est toujours un multiple de 6 (géré par le fonction appelante, je suppose) ?

Enfin on a:

for(...) buffer[nbr%6] = bin[nbr];
strcmp(buffer,comparaison);

Si buffer contient des caractères nuls, comme je l'ai dit il ne lira pas tout et s'arrêtera au premier 0.
Dans ce cas, utilise strncmp().

strncmp(const char *str1, const char *str2, size_t num);

Mon graphe (11 Avril): ((Rogue Life || HH2) ; PythonExtra ; serial gint ; Boson X ; passe gint 3 ; ...) || (shoutbox v5 ; v5)

Theprog Hors ligne Membre Points: 1447 Défis: 20 Message

Citer : Posté le 30/04/2014 11:51 | #

Et puis !
char buffer[6];
...
buffer[6] = 0;

Qui t'a appris ça ?

Ben oui c'est bien pour ça que je suis sur les fesses !
J'ai mis un printMini(buffer) et il m'a mis des trucs dans le style de "011010<R".
Vu qu'il y avait 2 caractères en trop, les chaînes ne pouvaient pas être identiques !
Et comme buffer fait 6 de taille c'était totalement impossible mais en ultime chance j'ai rajouté ce '\0' (a ne pas confondre avec '0') pour dire que ma chaine ce terminait au 5 ème caractère et la comme par magie, le print m'a sorti "011010" du coup c'était bon ...

∆ Mon RPG en Basic ◄► Mon simulateur spatial ◄► Mon Fourmizzz ◄► Mon projet en cours ∆

Lephenixnoir Hors ligne Administrateur Points: 24235 Défis: 170 Message

Citer : Posté le 30/04/2014 12:18 | #

Alors, mets char buffer[7] !
Tes caractères sont donc des '0' et des '1', mais pourquoi ne pas les transformer avec atoi(), puis les passer en décimal ?
Ainsi ta conversion serait bien plus puissante.

char conversions[64] = { 'A', 'B', 'C', ... };

Mon graphe (11 Avril): ((Rogue Life || HH2) ; PythonExtra ; serial gint ; Boson X ; passe gint 3 ; ...) || (shoutbox v5 ; v5)

Theprog Hors ligne Membre Points: 1447 Défis: 20 Message

Citer : Posté le 07/05/2014 14:38 | #

Le retour des erreurs ...

Le code

Cliquer pour enrouler

void options(int* handle)
{
    // SPRITES
    const unsigned char fond[]={
        0x0,0x0,0x0,0x0,0x0,0x1,0xc0,0x31,0x80,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
        0x0,0x0,0x0,0x0,0x0,0x3,0x60,0x30,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
        0x1,0xff,0x80,0x0,0x0,0x3,0x67,0x3d,0x9c,0xf1,0xe0,0x0,0x0,0x0,0x0,0x0,
        0x7,0x0,0xe0,0x0,0x0,0x3,0x6d,0xb1,0xb6,0xdb,0x0,0x0,0x0,0x0,0x0,0x0,
        0x8,0x0,0x10,0x0,0x0,0x3,0x6d,0xb1,0xb6,0xd9,0xc0,0x0,0x0,0x0,0x0,0x0,
        0x18,0x0,0x18,0x0,0x0,0x3,0x6d,0xb1,0xb6,0xd8,0x60,0x0,0x0,0x0,0x0,0x0,
        0x18,0x0,0x18,0x0,0x0,0x1,0xcf,0x31,0x9c,0xdb,0xc0,0x0,0x0,0x0,0x0,0x0,
        0x18,0x0,0x18,0x0,0x0,0x0,0xc,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
        0x10,0x0,0x8,0x0,0x0,0x0,0xc,0xd,0x58,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
        0x3f,0xff,0xfc,0x0,0x0,0x7f,0xff,0xfe,0xbf,0xff,0xfe,0x0,0x0,0x0,0x0,0x0,
        0x20,0x0,0x4,0x0,0x0,0xc0,0x0,0xe,0xb8,0x0,0x1,0x0,0x0,0x0,0x0,0x0,
        0x27,0xc3,0xe4,0x0,0x0,0x7f,0xff,0xfe,0xbf,0xff,0xfe,0x0,0x0,0x0,0x0,0x0,
        0x23,0x81,0xc4,0x0,0x0,0x0,0x0,0xd,0x58,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
        0x20,0x42,0x4,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
        0x20,0x0,0x4,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
        0x30,0x18,0xc,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
        0x30,0x7e,0xc,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
        0x40,0xc3,0x2,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
        0x40,0x0,0x2,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
        0x40,0x0,0x2,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
        0x41,0x18,0x82,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
        0x33,0xbd,0xcc,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
        0x9,0x3c,0x90,0x1,0xf0,0x18,0x0,0x36,0x30,0x1b,0x0,0x0,0x0,0x0,0x0,0x0,
        0x8,0x3c,0x10,0x1,0x98,0x0,0x0,0x6,0x0,0x18,0x0,0x0,0x0,0x0,0x0,0x0,
        0x7,0xff,0xe0,0x1,0x9b,0xdb,0xcf,0x37,0xb3,0xdb,0x3d,0xef,0x80,0x0,0x0,0x0,
        0x0,0x0,0x0,0x1,0xf3,0x1b,0x6d,0xb6,0x36,0xdb,0x61,0x8d,0x80,0x0,0x0,0x0,
        0x0,0x0,0x0,0x1,0xb3,0x9b,0x6d,0xb6,0x36,0xdb,0x39,0xcc,0x0,0x0,0x0,0x0,
        0x0,0x0,0x0,0x1,0x9b,0x1b,0x6d,0xb6,0x36,0xdb,0xd,0x8c,0x0,0x0,0x0,0x0,
        0x0,0x0,0x0,0x1,0x9b,0xdb,0x6d,0xb6,0x33,0x5b,0x79,0xec,0x0,0x0,0x0,0x0,
        0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
        0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
        0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
        0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
        0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
        0x0,0x0,0x0,0x0,0x0,0x0,0x3,0xe6,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
        0x0,0x0,0x0,0x0,0x0,0x0,0x3,0x30,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
        0x0,0x0,0x0,0x0,0x0,0x0,0x3,0x36,0x7b,0xc0,0x0,0x0,0x0,0x0,0x0,0x0,
        0x0,0x0,0x0,0x0,0x0,0x0,0x3,0xe6,0xdb,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
        0x0,0x0,0x0,0x0,0x0,0x0,0x3,0x6,0xdb,0x80,0x0,0x0,0x0,0x0,0x0,0x0,
        0x0,0x0,0x0,0x0,0x0,0x0,0x3,0x6,0xdb,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
        0x0,0x0,0x0,0x0,0x0,0x0,0x3,0x6,0x6b,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
        0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3,0x80,0x0,
        0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xd,0x60,0x0,
        0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x13,0x90,0x0,
        0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x21,0x8,0x0,
        0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x20,0x8,0x0,
        0x0,0x0,0x0,0x0,0x0,0x1,0xf0,0x18,0x0,0x0,0x0,0x0,0x0,0x44,0x24,0x0,
        0x0,0x0,0x0,0x0,0x0,0x1,0x98,0x18,0x0,0x0,0x0,0x0,0x0,0x4e,0x74,0x0,
        0x0,0x0,0x0,0x0,0x0,0x1,0x9b,0xde,0x73,0x6f,0x0,0x0,0x0,0x40,0x4,0x0,
        0x0,0x0,0x0,0x0,0x0,0x1,0xf3,0x18,0xdb,0x6d,0x0,0x0,0x1,0xff,0xff,0x0,
        0x0,0x0,0x0,0x0,0x0,0x1,0xb3,0x98,0xdb,0x6c,0x0,0x0,0x2,0x44,0x44,0x80,
        0x0,0x0,0x0,0x0,0x0,0x1,0x9b,0x18,0xdb,0x6c,0x0,0x0,0x3,0x47,0xc5,0x80,
        0x0,0x0,0x0,0x0,0x0,0x1,0x9b,0xd8,0x71,0xcc,0x0,0x0,0x2,0x70,0x1c,0x80,
        0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x53,0x95,0x0,
        0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x50,0x15,0x0,
        0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x73,0x9d,0x0,
        0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x40,0x5,0x0,
        0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0xf7,0xdf,0x0,
        0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x20,0x9,0x0,
        0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x3f,0xf9,0x0,
        0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3,0xe4,0x4f,0x80,
        0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2,0x4f,0xe4,0x80,
        0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2,0x29,0x28,0x80,
        0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3,0xef,0xef,0x80
    };
    const unsigned char pointeur_g[]={
        0x36,
        0x7c,
        0xff,
        0xff,
        0x7c,
        0x30
    };
    const unsigned char pointeur_d[]={
        0x6c,
        0x3e,
        0xff,
        0xff,
        0x3e,
        0xc
    };

    unsigned int choix, key;
    unsigned int x_g, x_d, y;

    choix = 0;
    x_g = 21;
    x_d = 100;
    y = 23;
    do{
        // AFFICHAGE
        Bdisp_AllClr_DDVRAM();
        ML_bmp_or(fond, 0, 0, 128, 64);
        ML_bmp_or(pointeur_g, x_g, y, 8, 6);
        ML_bmp_or(pointeur_d, x_d, y, 8, 6);

        // GESTION TOUCHES
        GetKey(&key);
        if(key == KEY_CTRL_UP) choix--;
        if(key == KEY_CTRL_DOWN) choix++;
        if(key == KEY_CTRL_EXE){
            if(choix == 0) reinitialiser(&handle);
            if(choix == 1) piaf(&handle);
            if(choix == 2) break;
        }
        if(choix == -1) choix = 2;
        if(choix == 3) choix = 0;

        if(choix == 0){
            x_g = 21;
            x_d = 100;
            y = 23;
        }
        if(choix == 1){
            x_g = 44;
            x_d = 77;
            y = 35;
        }
        if(choix == 2){
            x_g = 37;
            x_d = 84;
            y = 47;
        }
        [big][b][red]Sleep(50);[/red][/b][/big]
    }while(1);
}

void reinitialiser(int* handle)
{
    unsigned char buffer[NBR_NIVEAUX+1];
    unsigned int nbr;
    FONTCHARACTER filename[]={'\\','\\','f','l','s','0','\\','a','g','r','y','s','w','.','r','g','l',0};

    Bdisp_AllClr_DDVRAM();
    PrintXY(1,1," Voulez-vous vraiment",0);
    PrintXY(1,8,"supprimer tout votre ",0);
    PrintXY(1,16,"avancement ?",0);
    PrintXY(47,36,"[EXE]",0);

    GetKey(&nbr);
    if(nbr != KEY_CTRL_EXE) return;

    Bfile_CloseFile(*handle);
    Bfile_DeleteFile(filename);
    Bfile_CreateFile(filename, NBR_NIVEAUX+1);
    *handle = Bfile_OpenFile(filename,_OPENMODE_READWRITE);
    buffer[0] = '1';
    for(nbr = 1; nbr<NBR_NIVEAUX+1; nbr++){
        buffer[nbr] = '0';
    }
    Bfile_WriteFile(*handle,buffer,NBR_NIVEAUX+1);
}

void piaf(int* handle)
{
    // SPRITES
    const unsigned char fond[]={
        0x0,0x0,0x0,0x0,0x0,0x0,0x3,0xe6,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
        0x0,0x0,0x0,0x0,0x0,0x0,0x3,0x30,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
        0x0,0x0,0x0,0x0,0x0,0x0,0x3,0x36,0x7b,0xc0,0x0,0x0,0x0,0x0,0x0,0x0,
        0x0,0x0,0x0,0x0,0x0,0x0,0x3,0xe6,0xdb,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
        0x0,0x0,0x0,0x0,0x0,0x0,0x3,0x6,0xdb,0x80,0x0,0x0,0x0,0x0,0x0,0x0,
        0x0,0x0,0x0,0x0,0x0,0x0,0x3,0x6,0xdb,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
        0x0,0x0,0x0,0x0,0x0,0x0,0x3,0x6,0x6b,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
        0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
        0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xd,0x58,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
        0x0,0x0,0x0,0x0,0x0,0x7f,0xff,0xfe,0xbf,0xff,0xfe,0x0,0x0,0x0,0x0,0x0,
        0x0,0x0,0x0,0x0,0x0,0xc0,0x0,0xe,0xb8,0x0,0x1,0x0,0x0,0x0,0x0,0x0,
        0x0,0x0,0x0,0x0,0x0,0x7f,0xff,0xfe,0xbf,0xff,0xfe,0x0,0x0,0x0,0x0,0x0,
        0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xd,0x58,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
        0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
        0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1e,0x0,
        0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x33,0x0,
        0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xe,0x7,0x21,0x0,
        0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x11,0x18,0xc0,0x80,
        0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x10,0xa0,0x4c,0x80,
        0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x26,0x40,0xd,0x0,
        0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x26,0x0,0x3,0x0,
        0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x10,0x0,0x4,0x0,
        0x0,0x0,0x0,0x0,0x0,0x3,0xe6,0x0,0x0,0x0,0x0,0x0,0xc,0x7,0x3,0x0,
        0x0,0x0,0x0,0x0,0x0,0x3,0x30,0x0,0x6,0x0,0x0,0x0,0x4,0x18,0xe0,0x80,
        0x0,0x0,0x0,0x0,0x0,0x3,0x36,0x7b,0xce,0x30,0x0,0x0,0x8,0x20,0x10,0x80,
        0x0,0x0,0x0,0x0,0x0,0x3,0xe6,0xdb,0x6,0x30,0x80,0x0,0x10,0x40,0x8,0x40,
        0x0,0x0,0x0,0x0,0x0,0x3,0x6,0xdb,0x86,0x1,0xc0,0x0,0x2e,0x8d,0x8b,0xa0,
        0x0,0x0,0x0,0x0,0x0,0x3,0x6,0xdb,0x6,0x30,0x80,0x0,0x51,0x9d,0xcc,0x50,
        0x0,0x0,0x0,0x0,0x0,0x3,0x6,0x6b,0xf,0x30,0x0,0x0,0x53,0x98,0xcc,0xd0,
        0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x51,0xc0,0x14,0x50,
        0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x4e,0x20,0x23,0x90,
        0x0,0x8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x40,0x1f,0xc0,0x10,
        0x0,0xc,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x40,0x8,0x80,0x10,
        0x0,0x1c,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x20,0x7,0x0,0x20,
        0x0,0x3f,0x0,0x0,0x0,0x3,0xe6,0x0,0x0,0x0,0x0,0x0,0x10,0x0,0x0,0x40,
        0x0,0x1e,0x0,0x0,0x0,0x3,0x30,0x0,0x6,0x0,0x0,0x0,0x8,0x0,0x0,0x80,
        0x0,0x33,0x0,0x0,0x0,0x3,0x36,0x7b,0xc9,0x30,0x0,0x0,0x6,0x0,0x3,0x0,
        0x0,0x40,0x80,0x0,0x0,0x3,0xe6,0xdb,0x1,0x31,0x80,0x0,0x1,0xe0,0xfc,0x0,
        0x3,0xe0,0x40,0x0,0x0,0x3,0x6,0xdb,0x82,0x1,0xc0,0x0,0x0,0x1f,0x0,0x0,
        0x1,0x97,0xfe,0x0,0x0,0x3,0x6,0xdb,0x4,0x31,0x80,0x0,0x0,0x0,0x0,0x0,
        0x3,0x28,0x1,0x80,0x0,0x3,0x6,0x6b,0xf,0x30,0x0,0x0,0x0,0x0,0x0,0x0,
        0x2,0x88,0x0,0x40,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
        0x4,0x73,0xe0,0x20,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
        0x14,0x10,0x1e,0x10,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
        0x18,0x10,0x1,0xe8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
        0x18,0x8,0x0,0x18,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
        0x18,0x7,0x0,0x10,0x0,0x1,0xf0,0x18,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
        0x18,0x0,0xfe,0x20,0x0,0x1,0x98,0x18,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
        0x4,0x0,0x21,0xc0,0x0,0x1,0x9b,0xde,0x73,0x6f,0x0,0x0,0x0,0x0,0x0,0x0,
        0x2,0x0,0x20,0x0,0x0,0x1,0xf3,0x18,0xdb,0x6d,0x0,0x0,0x0,0x0,0x0,0x0,
        0x1,0x0,0x40,0x0,0x0,0x1,0xb3,0x98,0xdb,0x6c,0x0,0x0,0x0,0x0,0x0,0x0,
        0x0,0xc1,0x80,0x0,0x0,0x1,0x9b,0x18,0xdb,0x6c,0x0,0x0,0x0,0x0,0x0,0x0,
        0x0,0x3e,0x0,0x0,0x0,0x1,0x9b,0xd8,0x71,0xcc,0x0,0x0,0x0,0x0,0x0,0x0,
        0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
        0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
        0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
        0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
        0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
        0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
        0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
        0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
        0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
        0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
        0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0
    };
    const unsigned char pointeur_g[]={
        0x36,
        0x7c,
        0xff,
        0xff,
        0x7c,
        0x30
    };
    const unsigned char pointeur_d[]={
        0x6c,
        0x3e,
        0xff,
        0xff,
        0x3e,
        0xc
    };

    unsigned int choix, key, piaf;
    unsigned int x_g, x_d, y;

    unsigned char buffer[NBR_NIVEAUX+1];
    FONTCHARACTER filename[]={'\\','\\','f','l','s','0','\\','a','g','r','y','s','w','.','r','g','l',0};

    lecture_piaf(&piaf, *handle);
    choix = 0;
    x_g = 35;
    x_d = 86;
    y = 23;
    do{
        // AFFICHAGE
        Bdisp_AllClr_DDVRAM();
        ML_bmp_or(fond, 0, 0, 128, 64);
        ML_bmp_or(pointeur_g, x_g, y, 8, 6);
        ML_bmp_or(pointeur_d, x_d, y, 8, 6);

        // GESTION TOUCHES
        GetKey(&key);
        if(key == KEY_CTRL_UP) choix--;
        if(key == KEY_CTRL_DOWN) choix++;
        if(key == KEY_CTRL_EXE){
            if(choix == 0) piaf = 1;
            if(choix == 1) piaf = 2;
            if(choix == 2) break;
            choix = 2;
        }

        if(choix == -1) choix = 2;
        if(choix == 3) choix = 0;

        if(choix == 0){
            x_g = 35;
            x_d = 86;
            y = 23;
        }
        if(choix == 1){
            x_g = 35;
            x_d = 86;
            y = 35;
        }
        if(choix == 2){
            x_g = 36;
            x_d = 84;
            y = 47;
        }
        Sleep(50);
    }while(1);

    // ENREGISTREMENT DANS LE FICHIER
    Bfile_ReadFile(*handle,buffer,NBR_NIVEAUX+1,0);
    if(piaf == 1) buffer[0] = '1';
    else buffer[0] = '2';
    Bfile_CloseFile(*handle);
    Bfile_DeleteFile(filename);
    Bfile_CreateFile(filename, NBR_NIVEAUX+1);
    *handle = Bfile_OpenFile(filename,_OPENMODE_READWRITE);
    Bfile_WriteFile(*handle,buffer,NBR_NIVEAUX+1);
}

void lecture_piaf(int* piaf, int handle)
{
    unsigned char buffer[2];

    Bfile_ReadFile(handle,buffer,1,0);
    if(buffer[0] == '1') *piaf = 1;
    else *piaf = 2;
}

Si je vais dans piaf, en ressortant (retour dans options), j'ai un SE au niveau du Sleep(50); ...
Mais en allant dans réinitialiser j'ai aucun soucis ...
Le SDK n'aime pas les oiseaux ?

∆ Mon RPG en Basic ◄► Mon simulateur spatial ◄► Mon Fourmizzz ◄► Mon projet en cours ∆

Lephenixnoir Hors ligne Administrateur Points: 24235 Défis: 170 Message

Citer : Posté le 07/05/2014 14:40 | #

Pourquoi

lecture_piaf(&piaf, *handle);

piaf est une fonction.

Mon graphe (11 Avril): ((Rogue Life || HH2) ; PythonExtra ; serial gint ; Boson X ; passe gint 3 ; ...) || (shoutbox v5 ; v5)

Theprog Hors ligne Membre Points: 1447 Défis: 20 Message

Citer : Posté le 07/05/2014 14:43 | #

Modifié, toujours le meme SE

∆ Mon RPG en Basic ◄► Mon simulateur spatial ◄► Mon Fourmizzz ◄► Mon projet en cours ∆

Lephenixnoir Hors ligne Administrateur Points: 24235 Défis: 170 Message

Citer : Posté le 07/05/2014 14:45 | #

Modifié aussi dans la fonction lecture_piaf ?

Mon graphe (11 Avril): ((Rogue Life || HH2) ; PythonExtra ; serial gint ; Boson X ; passe gint 3 ; ...) || (shoutbox v5 ; v5)

Précédente – 1, 2, 3 ··· 6, 7, 8, 9, 10, 11, 12 ··· 20, 21, 22, 23 – Suivante

Nom d'utilisateur

Adresse email

Message

Ajouter un spoiler(texte affichable/masquable par un clic)

Nom du lien (facultatif): Adresse du lien:

Adresse de l'image: Alignement de l'image: Normal Flottante à gauche Centrée Flottante à droite Redimensionnement de l'image (en pixel): Largeur : Hauteur :

Adresse de la vidéo:

Pseudo du profil: Afficher la liste des membres

Auteur de la citation (faculatif):

Texte de déroulage du spoiler (modification faculative): Texte d'enroulage du spoiler (modification faculative):

Titre de la barre de progression: Pourcentage de la barre de progression entre 1 et 100:

→ ⇒ √ Σ ∫ ≠ ≥ ≤ π θ ◢ ± α β γ δ Δ σ ≈ ∞ ∈ λ

Fichier joint

Me prévenir par email lorsqu'une réponse est postée

Combien font quatre plus neuf ?

Veuillez donner la réponse en chiffre

Vous devez activer le Javascript dans votre navigateur pour pouvoir valider ce formulaire.

Si vous n'avez pas volontairement désactivé cette fonctionnalité de votre navigateur, il s'agit probablement d'un bug : contactez l'équipe de Planète Casio.

Planète Casio v4.3 © créé par Neuronix et Muelsaco 2004 - 2024 | Il y a 110 connectés | Nous contacter | Qui sommes-nous ? | Licences et remerciements

Planète Casio est un site communautaire non affilié à Casio. Toute reproduction de Planète Casio, même partielle, est interdite.
Les programmes et autres publications présentes sur Planète Casio restent la propriété de leurs auteurs et peuvent être soumis à des licences ou copyrights.
CASIO est une marque déposée par CASIO Computer Co., Ltd