#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
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:
{
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 ;).
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
{
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
Citer : Posté le 08/12/2014 22:06 | #
Les autres affectations fonctionnent-elles ?
Normalement, ça devrait fonctionner...
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...
{
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 ...
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é.
Citer : Posté le 19/01/2015 16:39 | #
Au passage, la valeur minimale d'un char n'est pas -256, c'est -128
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
merci a tout le monde pour son soutien
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 !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é
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
Citer : Posté le 27/01/2015 00:12 | #
Il avait bien raison
Citer : Posté le 03/02/2015 22:06 | #
J'ai encore un probleme, et je trouve pas mon erreur:
{
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:
Donc je commence un peu a lacher sans trouver meme si c'est surement une histoire de structure que je maitrise mal.
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.
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:
{
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 ...
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 !
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:
{
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;
}
Citer : Posté le 04/02/2015 18:23 | #
Tu ne charges qu'une structure donc ?
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.
Citer : Posté le 04/02/2015 20:11 | #
{
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 :
Il faut utiliser :
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
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.
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 "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()...