Les membres ayant 30 points peuvent parler sur les canaux annonces, projets et hs du chat.

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 ··· 10 ··· 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23 Suivante
Theprog Hors ligne Membre Points: 1447 Défis: 20 Message

Citer : Posté le 01/12/2014 21:18 | #


Retour des problèmes
Je pensait qu'il était possible de déclarer des variables dans des if mais j'ai une erreur:
void drawBriques(int x, int y, int rotation, Type type)
{
    int tx, ty;
    
    if(type == BRIQUE)
    {
        const unsigned char sprite[]={
            0x6f, 0x9f, 0x9f, 0xbf, 0x9f, 0x9f, 0xdf,
            0x9f, 0x9f, 0xbf, 0x9f, 0x9f, 0xdf, 0x9f, 0x6f,
        };

        tx = 4;
        ty = 15;
    }
    
    ML_bmp_or_cl(sprite, x, y, tx, ty);
}

L'erreur c'est a la ligne du ML_bmp: C2225 (E) Undeclared name "sprite"

Citer : Posté le 01/12/2014 21:29 | #


En fait la durée de vie de la variable est celle du bloc dans lequel elle est déclarée, soit ici, la "durée" du if. Ce que tu peux faire c'est appeler la fonction de ML directement dans le bloc ;).
Theprog Hors ligne Membre Points: 1447 Défis: 20 Message

Citer : Posté le 01/12/2014 21:45 | #


Merci ca marche
Et un autre soucis, une variable glabale dans un fichier, le sera dans tous les autres fichiers qui l'incluent non ?

Ajouté le 08/12/2014 à 22:03 :
Donc voila mon probleme avec les structures:
J'ai la fonction qui gere les collisions entre les briques et l'oiseau pour mon AGBSW
Juste ici
Cliquer pour enrouler
int collisionBriques(Oiseau *oiseau, Brique *briques, int nbrBriques)
{
    int i, j;
    
    for(i=0, j=0; i<nbrBriques; i++)
    {
        if(oiseau->x >= briques[i].x[0] && oiseau->x <= briques[i].x[1]  &&  oiseau->y >= briques[i].y[0] && oiseau->y <= briques[i].y[1]  &&  briques[i].vie)
        {
            if(oiseau->apti == 1 && oiseau->type+4 == CHEWBACA)
            {
                oiseau->vx /= RALENTI_COLLI/2;
                oiseau->vy /= RALENTI_COLLI/2;
            }
            else
            {
                oiseau->vx /= RALENTI_COLLI;
                oiseau->vy /= RALENTI_COLLI;
            }
            oiseau->apti = 0;
            briques[i].vie = 0;
            j++;
        }
    }
    
    return j;
}

Mais le "briques.vie = 0;" ne marche pas.
Sauf que je peux pas passer autrement le tableau de brique. Donc si quelqu'un a une idée

Lephenixnoir En ligne Administrateur Points: 21330 Défis: 149 Message

Citer : Posté le 08/12/2014 22:06 | #


Les autres affectations fonctionnent-elles ?
Normalement, ça devrait fonctionner...
Theprog Hors ligne Membre Points: 1447 Défis: 20 Message

Citer : Posté le 08/12/2014 22:12 | #


En effet ca marche desolé je me suis fail dans l'affichage ><

Ajouté le 18/01/2015 à 23:57 :
Encore un probleme...
La fonction
Cliquer pour enrouler
void Read()
{
    int i, j, handle;
    int error = 0;
    const char *filesNames[NBR_FILES] = {"\\\\fls0\\ROGUE\\OPTN.txt", "\\\\fls0\\ROGUE\\HISC.txt", "\\\\fls0\\ROGUE\\ELSE.txt"};
    
    // Alloc
    data = calloc(NBR_FILES, sizeof(int *));
    for(i=0; i<NBR_FILES; i++)
        data[i] = calloc(datal[i], sizeof(int));
        
    // Read
    memory_createdir("\\\\fls0\\ROGUE");
    for(i=0; i<NBR_FILES; i++)
    {
        if(!memory_exists(filesNames[i]))
        {
            memory_createfile(filesNames[i], datal[i]);
            error++;
            
            for(j=0; j<datal[i]; j++)
                data[i][j] = 0;
        }
    }
    
    PrintV(120, 55, error);
    
    if(error)
    {
        SaveDisp(1);
        ML_clear_vram();
        Draw_printText("\tA directory \"ROGUE\" had been created. Please don't delete it or the files it contains.");
        ML_display_vram();
        Sleep(2500);
        RestoreDisp(1);
    }
    
    for(i=0; i<NBR_FILES; i++)
    {
        handle = memory_openfile(filesNames[i],_OPENMODE_READ);
        memory_readfile(handle,(void *)data[i],datal[i]*sizeof(int),0);
        memory_closefile(handle);
    }
}


Cette fonction de lecture et par la meme occasion d'initialisation ne marche pas ><
En fait, au lieu d'initialiser a 0, les premieres cases de data sont initialiséses a -255 (c'est bizarrement la valeur minimale d'un char ...)
Donc voila ca me fait un peu chier de pas trouver d'ou ca vient, alors si quelqu'un a une idée ...

Lephenixnoir En ligne Administrateur Points: 21330 Défis: 149 Message

Citer : Posté le 19/01/2015 06:15 | #


Caste le pointeur retourné par calloc(). data est bien de type int ** ?
Au passage, -255 n'est pas la valeur minimale (c'est -256) et sa représentation en binaire n'a rien d'extraordinaire : 0b1000001 sur un octet signé.
Dodormeur Hors ligne Ancien rédacteur Points: 3964 Défis: 82 Message

Citer : Posté le 19/01/2015 16:39 | #


Au passage, la valeur minimale d'un char n'est pas -256, c'est -128
Pokemon !!!!!! => pokemon stadium/battle

mes meilleurs jeux
Cliquer pour enrouler
un jeu avec des niveaux de gris mais compatible SH4 (mais en monochrome pour les SH4) => bomberman
envie de plonger dans la mer pour ramasser des tresors? => ballon sea
envie de sauver l'univers dans un jeu avec une longue durée de vie? => saviors of the future
un add-in addictif avec plein de secret et de trophées => evasion survival
un shmup bien dur et sadique => saviors 2

projets
Cliquer pour enrouler

pokemon
Cliquer pour enrouler



encodage des données de combat (sprite, attaques et nom)
   100%

systeme de combat
   100%

encodage des données de pokemon (niveau d'apprentisage et evolution)
   100%


moteur de la carte
   50%

level design
   1%

finition de pokemon jade
   42%

merci a tout le monde pour son soutien


projets que je soutiens
Cliquer pour enrouler
minecraft de limachi
zelda prizm de smashmaster (en esperant qu'il puisse le finir)
les tests de marmotti
un RPG de dark storm (dont je connais le nom, mais pas vous ) Arcuz !
Theprog Hors ligne Membre Points: 1447 Défis: 20 Message

Citer : Posté le 19/01/2015 18:41 | #


Ha oui en effet, enfin bon ca me retourne toujours ce -255, pour tous les fichiers...
Oui data est bien un int**

Ajouté le 19/01/2015 à 18:46 :
En fait j'ai trouvé.
Lors de la creation des fichiers, j'initialise data mais apres je relit les fichiers qui viennent d'etre créés sans entrer de valeurs dedans ... Donc un memory_save() et c'est reglé
Lephenixnoir En ligne Administrateur Points: 21330 Défis: 149 Message

Citer : Posté le 26/01/2015 22:25 | #


Je voyais pas d'autre topic pour mettre ça.
Voilà ce que notre cher Torvalds pense du C++...

http://article.gmane.org/gmane.comp.version-control.git/57918
Dark storm Hors ligne Labélisateur Points: 11549 Défis: 176 Message

Citer : Posté le 27/01/2015 00:12 | #


Il avait bien raison
Finir est souvent bien plus difficile que commencer. — Jack Beauregard
Theprog Hors ligne Membre Points: 1447 Défis: 20 Message

Citer : Posté le 03/02/2015 22:06 | #


J'ai encore un probleme, et je trouve pas mon erreur:
typedef struct
{
    int team;
    int life;
    int pos[2];
} Player;

void Fight_start()
{
    Map map;
    Player *players;
    int nbrPlayers = -1;
    
    Fight_generateWorld(&map, players, &nbrPlayers);
    
    ML_clear_vram();
    Draw_mapFight(map);
    Draw_playersFight(players, nbrPlayers);
    ML_display_vram();
    Sleep(5000);
    
    Fight_quit(&map, players);
}

void Fight_generateWorld(Map *map, Player *players, int *nbrPlayers)
{
    Fight_mapLoad(1, map);
    *nbrPlayers = Fight_playerLoad(1, players);
}

int Fight_playerLoad(int id, Player *players)
{
    char fileName[50];
    char buffer[40];
    int nbrPlayers = -1;
    int handle;
    int i, j;
    
    sprintf(fileName, "\\\\fls0\\SNOWF\\ff%d.pla", id);
    
    if(!memory_exists(fileName))
    {
        ML_clear_vram();
        Draw_printText("Error loading player.\nFile missing:", 20);
        Draw_textCenter(fileName, 40);
        ML_display_vram();
        Sleep(5000);
        return -1;
    }
    
    handle = memory_openfile(fileName, _OPENMODE_READ);
    
    memory_readfile(handle, (void *)&nbrPlayers, sizeof(int), 0);
    players = calloc(nbrPlayers, sizeof(Player));
    for(i=0; i<nbrPlayers; i++)
    {
        players[i].life = 100;
        players[i].team = (i>=nbrPlayers/2)?0:1;
        memory_readfile(handle, (void *)players[i].pos, 2*sizeof(int), 1+2*sizeof(int)*i);
        
        // DEBUG
        sprintf(buffer, "i:%d life:%d team:%d pos:%d,%d", i, players[i].life, players[i].team, players[i].pos[0], players[i].pos[1]);
        PrintMini(0, 0, buffer, 0);
        ML_display_vram();
        Sleep(2500);
    }
    
    memory_closefile(handle);
    return nbrPlayers;
}

void Draw_playersFight(Player *players, int nbrPlayers)
{
    const unsigned char sprite[2][8] = {
        {0x38, 0x38, 0x38, 0x10, 0x38, 0x54, 0x10, 0x28},
        {0x38, 0x28, 0x38, 0x10, 0x38, 0x54, 0x10, 0x28}
    };
    char buffer[40];
    int i;
    
    for(i=0; i<nbrPlayers; i++)
    {
        ML_bmp_8_or(sprite[players[i].team], players[i].pos[0], players[i].pos[1]);
        
        // DEBUG
        sprintf(buffer, "i:%d life:%d team:%d pos:%d,%d", i, players[i].life, players[i].team, players[i].pos[0], players[i].pos[1]);
        PrintMini(0, 0, buffer, 0);
        ML_display_vram();
        Sleep(5000);
    }
}



void Fight_mapGenerate()
{
    char map1[128] = {
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
        1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
        1, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 1,
        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
    };
    int map1p[9] = {
        4,
        10, 10,
        20, 10,
        30, 10,
        40, 10
    };
    
    char map2[128] = {
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
        1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1,
        1, 0, 0, 0, 1, 0, 1, 0, 0, 1, 0, 1, 0, 0, 0, 1,
        1, 1, 1, 1, 1, 1, 1, 2, 2, 1, 1, 1, 1, 1, 1, 1,
    };
    char map3[128] = {
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0,
        1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 1,
        1, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
        1, 0, 0, 0, 0, 0, 0, 2, 2, 0, 0, 0, 0, 0, 0, 1,
        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
    };
    
    if(!memory_exists("\\\\fls0\\SNOWF\\ff1.map"))
        memory_save("\\\\fls0\\SNOWF\\ff1.map", map1, 16*8*sizeof(char));
    if(!memory_exists("\\\\fls0\\SNOWF\\ff1.pla"))
        memory_save("\\\\fls0\\SNOWF\\ff1.pla", map1p, 9*sizeof(int));
    
    if(!memory_exists("\\\\fls0\\SNOWF\\ff2.map"))
    {
        memory_save("\\\\fls0\\SNOWF\\ff2.map", map2, 16*8*sizeof(char));
    }
    if(!memory_exists("\\\\fls0\\SNOWF\\ff3.map"))
    {
        memory_save("\\\\fls0\\SNOWF\\ff3.map", map3, 16*8*sizeof(char));
    }
}

Je cherche a lire dans le fichier créé par Fight_mapGenerate() les donnés necessaire a l'affichage des joueurs.
Le probleme que j'ai est double:
Lors de la lecture du fichier, les valeurs lues de pos sont incorectes.
Lors de l'affichage, les valeurs contenues dans *players sont completement aleatoires alors qu'elles sont bonnes (hormis la pos signalé au dessus) lors de la lecture du fichier, du coup j'ai un sys error...
Donc je commence un peu a lacher sans trouver meme si c'est surement une histoire de structure que je maitrise mal.
Lephenixnoir En ligne Administrateur Points: 21330 Défis: 149 Message

Citer : Posté le 03/02/2015 22:36 | #


Lorsque tu appelles memory_read(), à moins de ne pas lire le fichier de manière séquentielle, passe toujours -1 en dernier argument. Il avancera tout seul et ça t'évitera d'avoir à calculer des offsets toujours plus foireux au fur et à mesure.

Sinon pour Fight_mapGenerate() tu pourrais avoir un tableau de maps et itérer dessus, ce serait plus propre.
Theprog Hors ligne Membre Points: 1447 Défis: 20 Message

Citer : Posté le 03/02/2015 22:50 | #


En effet, ca regle mon premier probleme avec le -1
Par contre, j'ai toujours le probleme pour Draw_playersFight()

Pour Fight_mapGenerate() je sais, c'est une fonction tres temporaire, elle me sert juste a creer mes fichiers mais je compte la virer apres

Ajouté le 04/02/2015 à 08:19 :
Bon j'ai rajouté deux petits sprintf pour voir si je trouvait pas l'erreur avant et avec ceci:
void Fight_start()
{
    Map map;
    Player *players = NULL;
    int nbrPlayers = -1;
    
    Fight_generateWorld(&map, players, &nbrPlayers);
    
    ML_clear_vram();
    Draw_mapFight(map);
    Draw_playersFight(players, nbrPlayers);
    ML_display_vram();
    Sleep(5000);
    
    Fight_quit(&map, players);
}

void Fight_generateWorld(Map *map, Player *players, int *nbrPlayers)
{
    char buffer[50];
    
    Fight_mapLoad(1, map);
    *nbrPlayers = Fight_playerLoad(1, players);
    
    // DEBUG
    sprintf(buffer, "players: %p", players);
    PrintMini(0, 10, buffer, 0);
    ML_display_vram();
    Sleep(2500);
}

int Fight_playerLoad(int id, Player *players)
{
    char fileName[50];
    char buffer[40];
    int nbrPlayers = -1;
    int handle;
    int i, j;
    
    sprintf(fileName, "\\\\fls0\\SNOWF\\ff%d.pla", id);
    
    if(!memory_exists(fileName))
    {
        ML_clear_vram();
        Draw_printText("Error loading player.\nFile missing:", 20);
        Draw_textCenter(fileName, 40);
        ML_display_vram();
        Sleep(5000);
        return -1;
    }
    
    handle = memory_openfile(fileName, _OPENMODE_READ);
    
    memory_readfile(handle, (void *)&nbrPlayers, sizeof(int), -1);
    players = calloc(nbrPlayers, sizeof(Player));
    for(i=0; i<nbrPlayers; i++)
    {
        players[i].life = 100;
        players[i].team = (i>=nbrPlayers/2)?0:1;
        memory_readfile(handle, (void *)players[i].pos, 2*sizeof(int), -1);
    }
    
    // DEBUG
    ML_clear_vram();
    sprintf(buffer, "players: %p", players);
    PrintMini(0, 0, buffer, 0);
    ML_display_vram();
    Sleep(2500);
    
    memory_closefile(handle);
    return nbrPlayers;
}

Le pointeur est modifié dans Fight_playerLoad() mais est null partout en dehors de celle-ci ...
Lephenixnoir En ligne Administrateur Points: 21330 Défis: 149 Message

Citer : Posté le 04/02/2015 13:10 | #


Ben évidemment. Tu passes le pointeur et il est copié donc ton original est toujours à NULL en fin de compte... si tu veux qu'une fonction modifie une donnée il faut lui donner un pointeur mais si tu veux qu'elle modifie un pointeur il fait lui donner l'adresse du pointeur !
Theprog Hors ligne Membre Points: 1447 Défis: 20 Message

Citer : Posté le 04/02/2015 14:50 | #


Ouais, je me disai aussi mais un pointeur de pointeur je trauvais ca bizarre
Bon apres le probleme c'est que je suis surement en train de faire n'imp avec ce code:
void Fight_start()
{
    Map map;
    Player *players = NULL;
    int nbrPlayers = -1;
    
    Fight_generateWorld(&map, &players, &nbrPlayers);
    
    ML_clear_vram();
    Draw_mapFight(map);
    Draw_playersFight(players, nbrPlayers);
    ML_display_vram();
    Sleep(5000);
    
    Fight_quit(&map, players);
}

void Fight_generateWorld(Map *map, Player **players, int *nbrPlayers)
{
    char buffer[50];
    
    Fight_mapLoad(1, map);
    *nbrPlayers = Fight_playerLoad(1, players);
    
    // DEBUG
    sprintf(buffer, "players: %p", players);
    PrintMini(0, 10, (unsigned char*)buffer, 0);
    ML_display_vram();
    Sleep(2500);
}

int Fight_playerLoad(int id, Player **players) //-- ok
{
    char fileName[50];
    char buffer[40];
    int nbrPlayers = -1;
    int handle;
    int i, j;
    
    sprintf(fileName, "\\\\fls0\\SNOWF\\ff%d.pla", id);
    
    if(!memory_exists(fileName))
    {
        ML_clear_vram();
        Draw_printText("Error loading player.\nFile missing:", 20);
        Draw_textCenter(fileName, 40);
        ML_display_vram();
        Sleep(5000);
        return -1;
    }
    
    handle = memory_openfile(fileName, _OPENMODE_READ);
    
    memory_readfile(handle, (void *)&nbrPlayers, sizeof(int), -1);
    *players = calloc(nbrPlayers, sizeof(Player));
    for(i=0; i<nbrPlayers; i++)
    {
        players[i]->life = 100;
        players[i]->team = (i>=nbrPlayers/2)?0:1;
        memory_readfile(handle, (void *)players[i]->pos, 2*sizeof(int), -1);
    }
    
    // DEBUG
    ML_clear_vram();
    sprintf(buffer, "players: %p", players);
    PrintMini(0, 0, (unsigned char*)buffer, 0);
    ML_display_vram();
    Sleep(2500);
    
    memory_closefile(handle);
    return nbrPlayers;
}

Lephenixnoir En ligne Administrateur Points: 21330 Défis: 149 Message

Citer : Posté le 04/02/2015 18:23 | #


*players = calloc(nbrPlayers, sizeof(Player));

Tu ne charges qu'une structure donc ?
Theprog Hors ligne Membre Points: 1447 Défis: 20 Message

Citer : Posté le 04/02/2015 18:39 | #


Non le but est de faire un tableau de Player.
Et une fois que je l'ai les remplir un a un avec le fichier et les autres données.
Lephenixnoir En ligne Administrateur Points: 21330 Défis: 149 Message

Citer : Posté le 04/02/2015 20:11 | #


for(i=0; i<nbrPlayers; i++)
    {
        players[i]→life = 100;
        players[i]→team = (i>=nbrPlayers/2)?0:1;
        memory_readfile(handle, (void *)players[i]→pos, 2*sizeof(int), -1);
    }

C'est pas bon ça.
Ton pointeur sur tes structures tu viens de l'allouer, c'est *players pas players. Et en plus c'est des structures directes (t'as alloué des struct Player).
En gros tu n'as pas un tableau de pointeurs sur des structures mais un pointeur sur un tableau de structures. Donc au lieu d'utiliser :
players[i]→life

Il faut utiliser :
(*players)[i].life
Theprog Hors ligne Membre Points: 1447 Défis: 20 Message

Citer : Posté le 04/02/2015 20:28 | #


Pfiou j'etais loin de trouver ca ...
Encore une fois merci, je commence un peu a comprendre le truc, mais c'est quand meme sacrement compliqué des fois
Lephenixnoir En ligne Administrateur Points: 21330 Défis: 149 Message

Citer : Posté le 04/02/2015 20:29 | #


Pas de problème, faut bien faire attention au schéma mais c'est pas le pire à debugger.
Theprog Hors ligne Membre Points: 1447 Défis: 20 Message

Citer : Posté le 13/02/2015 13:03 | #


Bon alors, une fois n'est pas coutume, j'ai surement une erreur du meme type lors de la liberation de la memoire...
J'ai le SE ou un reboot au moment de liberer (le texte n'apparait pas).
#include "fxlib.h"
#include "fight.h"
#include "draw.h"
#include "memory.h"
#include "MonochromeLib.h"
#include "key.h"

#include <stdlib.h>
#include <stdio.h>

void Fight_start() //-- ok
{
    Map map;
    Player *players = NULL;
    int nbrPlayers = -1;
    int i, j;
    
    char debug[50];
    
    // Load
    Fight_worldLoad(&map, &players, &nbrPlayers);
    
    // Draw
    ML_clear_vram();
    Draw_mapFight(map);
    
    // Get down players
    Fight_playerDown(map, players, nbrPlayers);
    
    // Play
    Fight_play(map, players, nbrPlayers);
    
    Fight_quit(&map, &players);
    
    Sleep(250);
}

void Fight_worldLoad(Map *map, Player **players, int *nbrPlayers) //-- ok
{
    int mapId;
    int difficulty, mapMode;
    
    Fight_readOptions(&difficulty, &mapMode);
    
    if(mapMode)
        mapId = mapMode;
    else
        mapId = (rand()%Fight_nbrOfMap())+1;
    
    Fight_mapLoad(mapId, map);
    *nbrPlayers = Fight_playerLoad(mapId, players);
}

int Fight_mapLoad(int id, Map *map) //-- ok for fixed size (16*8)
{
    char fileName[50];
    int handle;
    int i, j;
    
    sprintf(fileName, "\\\\fls0\\SNOWF\\ff%d.map", id);
    
    if(!memory_exists(fileName))
    {
        ML_clear_vram();
        Draw_printText("Error loading map.\nFile missing:", 20);
        Draw_textCenter(fileName, 40);
        ML_display_vram();
        Sleep(5000);
        return -1;
    }
    
    map->lenght = 16;
    map->height = 8;
    
    map->tiles = calloc(map->height,sizeof(char *));
    for(i=0; i<map->height; i++)
    {
        map->tiles[i] = calloc(map->lenght,sizeof(char));
        
        handle = memory_openfile(fileName, _OPENMODE_READ);
        memory_readfile(handle, (void *)map->tiles[i], (map->lenght)*sizeof(char), (map->lenght)*sizeof(char)*i);
        memory_closefile(handle);
    }
    return 1;
}

int Fight_playerLoad(int id, Player **players) //-- ok LePhe<3
{
    char fileName[50];
    int nbrPlayers = -1;
    int handle;
    int i, j;
    
    sprintf(fileName, "\\\\fls0\\SNOWF\\ff%d.pla", id);
    
    if(!memory_exists(fileName))
    {
        ML_clear_vram();
        Draw_printText("Error loading player.\nFile missing:", 20);
        Draw_textCenter(fileName, 40);
        ML_display_vram();
        Sleep(5000);
        return -1;
    }
    
    handle = memory_openfile(fileName, _OPENMODE_READ);
    
    memory_readfile(handle, (void *)&nbrPlayers, sizeof(int), -1);
    *players = calloc(nbrPlayers, sizeof(Player));
    for(i=0; i<nbrPlayers; i++)
    {
        (*players)[i].life = 100;
        (*players)[i].team = i%2;
        memory_readfile(handle, (void *)(*players)[i].pos, 2*sizeof(int), -1);
    }
    
    memory_closefile(handle);
    return nbrPlayers;
}

void Fight_quit(Map *map, Player **players) //-- ok
{
    int i;
    
    for(i=0; i<map->height; i++)
        free(map->tiles[i]);
    free(map->tiles);
    free(players);
    
    ML_clear_vram();
    PrintMini(0, 0, "Free() Done", 0);
    ML_display_vram();
    Sleep(5000);
}

Donc tout se passe bien jusqu'a ce que je revienne dans Fight_start() apres Fight_play()...
Précédente 1, 2, 3 ··· 10 ··· 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23 Suivante

LienAjouter une imageAjouter une vidéoAjouter un lien vers un profilAjouter du codeCiterAjouter un spoiler(texte affichable/masquable par un clic)Ajouter une barre de progressionItaliqueGrasSoulignéAfficher du texte barréCentréJustifiéPlus petitPlus grandPlus de smileys !
Cliquez pour épingler Cliquez pour détacher Cliquez pour fermer
Alignement de l'image: Redimensionnement de l'image (en pixel):
Afficher la liste des membres
:bow: :cool: :good: :love: ^^
:omg: :fusil: :aie: :argh: :mdr:
:boulet2: :thx: :champ: :whistle: :bounce:
valider
 :)  ;)  :D  :p
 :lol:  8)  :(  :@
 0_0  :oops:  :grr:  :E
 :O  :sry:  :mmm:  :waza:
 :'(  :here:  ^^  >:)

Σ π θ ± α β γ δ Δ σ λ
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 v42 © créé par Neuronix et Muelsaco 2004 - 2022 | Il y a 42 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