#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 25/03/2014 21:18 | #
><
Quoi qu'en fasse le compilateur, toi tu l'utilises en tableau 2d comme d'habitude, d'accord ?
Citer : Posté le 25/03/2014 21:19 | #
Tu peux pas m'envoyer la fonction comme il faudrait que je comprennes parce que ce que vous dites est contradictoire non
Citer : Posté le 25/03/2014 21:21 | #
int main()
{
int tableau[8][8] = { ... };
int x;
x = tabsum(tableau);
}
int tabsum(int **tab)
{
int i,j,s=0;
for(i=0;i<8;i++) for(j=0;j<8;j++) s+=tab[i][j];
return s;
}
Ce que Dodormeur voulait dire, c'est que le compilateur va gérer ton tableau 2d comme un tableau 1d, ce qui est vrai.
Mais c'est son affaire, il se démerde. Tu n'as pas besoin de t'en occuper.
Si on commence à changer les tableaux 2d en 1d, pourquoi pas faire l'inverse ? Si on s'amuse à changer les types des variables, ça devient juste le bordel
Citer : Posté le 25/03/2014 21:28 | #
Je précise qu'il faut initialiser un tab2dim de cette manière:
tableau [...][...] =
{
{1,2,3,4,5,6},
{3,8,5,3,8,2},
...
{3,8,5,3,8,2}
};
Citer : Posté le 25/03/2014 21:31 | #
Je présume que ton bouton "valider" a dû mal réagir, j'ai supprimé les doublons
Citer : Posté le 25/03/2014 21:33 | #
Ok merci il m'a embrouillé avec ces histoires alors
Et pour remplir le tableau ca marche pas un
0,0,1,1,1,0,0,
1,1,1,1,1,1,1,
1,1,1,1,1,1,1,
1,1,1,1,1,1,1,
0,0,1,1,1,0,0,
0,0,1,1,1,0,0);
?
Ajouté le 25/03/2014 à 21:33 :
Ok bon forcement si la communauté est trop active ca pose des soucis
Merci de lire dans mes pensées
Citer : Posté le 25/03/2014 21:34 | #
{ 0,0,1,1,1,0,0 },
{ 0,0,1,1,1,0,0 },
{ 1,1,1,1,1,1,1 },
{ 1,1,1,1,1,1,1 },
{ 1,1,1,1,1,1,1 },
{ 0,0,1,1,1,0,0 },
{ 0,0,1,1,1,0,0 } };
Citer : Posté le 25/03/2014 21:34 | #
Non ça ne marche qu'avec les tableaux normaux.
édit : grillé
Citer : Posté le 25/03/2014 21:35 | #
Au fait, c'est un "+" ?
Ça sert à quoi ?
Citer : Posté le 25/03/2014 21:36 | #
c'est un plateau de solitaire pour une IA qui le résout en récursif (en tout cas qui essaie)
Citer : Posté le 25/03/2014 21:40 | #
Solitaire c'est un jeu de carte, je pense que tu confonds avec un autre jeu.
Attention si tu essayes de résoudre ce problème recursivement, premièrement ça peut prendre énormément de temps (au niveau du temps d'exécution), deuxièmement n'oublie pas que tu n'envoies pas une copie du tableau à cette fonction.
Citer : Posté le 25/03/2014 21:44 | #
Solitaire, mule, ce jeu a tellement de nom que je sais jamais comment l'appeler
Oui je sais maintenant que je sais utiliser les pointeurs je les utilisent a tord et a travers c'est pour ca que je le fais principalement pour m'entrainer et que j'utilise le récursif aussi pour m'entrainer a l'utiliser vu qu'on l'utilise presque jamais et que quand on en a besoin on sait pas s'en servir
Citer : Posté le 25/03/2014 21:46 | #
Non, ce jeu s'appelle bien solitaire.
D'ailleurs, le jeu de cartes que tu mentionnes ne s'appelle-t-il pas aussi patience ?
Citer : Posté le 25/03/2014 21:48 | #
En gros les solitaires sont des jeux qui se pratiquent tout seul
Ca peut être des jeux de cartes, des jeux de n'importe quoi tant que quelqu'un a osé l'appeler solitaire apres c'est le mer**** pour savoir de quoi on parle
Ajouté le 25/03/2014 à 21:59 :
Bo ca commence a m'amuser ...
J'ai un System Error dans la fonction qui affiche le plateau:
{
int x, y;
// SPRITE DU PLATEAU
const unsigned char solitaire[]={
0xff,0xff,0xff,0xff,0xff,0xe0,
0x80,0x8,0x20,0x82,0x0,0x20,
0x80,0x8,0x20,0x82,0x0,0x20,
0x80,0x8,0x20,0x82,0x0,0x20,
0x80,0x8,0x20,0x82,0x0,0x20,
0x80,0x8,0x20,0x82,0x0,0x20,
0x80,0xf,0xff,0xfe,0x0,0x20,
0x80,0x8,0x20,0x82,0x0,0x20,
0x80,0x8,0x20,0x82,0x0,0x20,
0x80,0x8,0x20,0x82,0x0,0x20,
0x80,0x8,0x20,0x82,0x0,0x20,
0x80,0x8,0x20,0x82,0x0,0x20,
0xff,0xff,0xff,0xff,0xff,0xe0,
0x82,0x8,0x20,0x82,0x8,0x20,
0x82,0x8,0x20,0x82,0x8,0x20,
0x82,0x8,0x20,0x82,0x8,0x20,
0x82,0x8,0x20,0x82,0x8,0x20,
0x82,0x8,0x20,0x82,0x8,0x20,
0xff,0xff,0xff,0xff,0xff,0xe0,
0x82,0x8,0x20,0x82,0x8,0x20,
0x82,0x8,0x20,0x82,0x8,0x20,
0x82,0x8,0x20,0x82,0x8,0x20,
0x82,0x8,0x20,0x82,0x8,0x20,
0x82,0x8,0x20,0x82,0x8,0x20,
0xff,0xff,0xff,0xff,0xff,0xe0,
0x82,0x8,0x20,0x82,0x8,0x20,
0x82,0x8,0x20,0x82,0x8,0x20,
0x82,0x8,0x20,0x82,0x8,0x20,
0x82,0x8,0x20,0x82,0x8,0x20,
0x82,0x8,0x20,0x82,0x8,0x20,
0xff,0xff,0xff,0xff,0xff,0xe0,
0x80,0x8,0x20,0x82,0x0,0x20,
0x80,0x8,0x20,0x82,0x0,0x20,
0x80,0x8,0x20,0x82,0x0,0x20,
0x80,0x8,0x20,0x82,0x0,0x20,
0x80,0x8,0x20,0x82,0x0,0x20,
0x80,0xf,0xff,0xfe,0x0,0x20,
0x80,0x8,0x20,0x82,0x0,0x20,
0x80,0x8,0x20,0x82,0x0,0x20,
0x80,0x8,0x20,0x82,0x0,0x20,
0x80,0x8,0x20,0x82,0x0,0x20,
0x80,0x8,0x20,0x82,0x0,0x20,
0xff,0xff,0xff,0xff,0xff,0xe0
};
ML_bmp_or(solitaire, x_plateau, y_plateau, 43, 43);
for(x=0;x<7;x++){
for(y=0;y<7;y++){
if(plateau[x][y] == 1) ML_point((x_plateau)+3+6*x, (y_plateau)+3+6*y, 3, ML_BLACK);
}
}
}
Pourtant il me semble pas avoir fait de bêtises
Citer : Posté le 25/03/2014 22:02 | # |
Fichier joint
Il faut allouer les tableaux à deux dimensions de manière dynamique, attend deux minutes je t'envoie les sources.
édit : Ci-joint une petite librairie que j'avais programmé et qui permet d'allouer dynamiquement des tableaux à deux dimensions.
Pour créer un tableau à deux dimension de taille 7*7, utilise la fonction New_tab2dim_int(int height, int lenght);
int** tableau = New_tab2dim_int(7,7);
...
affiche_plateau(tableau, ... , ...);
Free_tab2dim_int(tableau, 7, 7); [green]//Pour libérer le tableau[/green]
Citer : Posté le 25/03/2014 22:10 | #
@theprog et lephenix : Faut écouter un peu
Utilise le script de smash si tu veux utiliser des int**
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 26/03/2014 06:35 | #
Je n'ai jamais dit le contraire !
Si le compilateur organise ses données de sorte qu'un tableau à deux dimensions soit lisible comme une liste, il n'y a pas de souci.
Mais l'expression tab[x][y], puisqu'elle est transformée en *(*(tab+x)+y), va le gérer comme un tableau à deux dimensions dynamique (tableau de pointeurs) et va donc utiliser une valeur comme pointeur.
Citer : Posté le 26/03/2014 14:30 | #
Pff je commence a desesperer ...
J'ai encore un System Error qui tombe du ciel alors qu'il me semble pas qu'il y ai encore des problemes avec le tableau en 2 dimmensions
*L'erreur se trouve quelque part dans la fonction bouger je crois
#include "MonochromeLib.h"
#include "solitr.h"
#include "tab2dim.h"
int AddIn_main(int isAppli, unsigned short OptionNum)
{
unsigned int key;
int** plateau = New_tab2dim_int(7,7);
int x_plateau, y_plateau;
srand(RTC_getTicks());
Bdisp_AllClr_DDVRAM();
x_plateau = 30;
y_plateau = 10;
init_plateau(plateau);
affiche_plateau(plateau, x_plateau, y_plateau);
do{
GetKey(&key);
}while(key != 30004);
resoudre(plateau);
GetKey(&key);
Sleep(5000);
return 1;
}
void init_plateau(int **plateau)
{
int i, j, k, l;
// {0,0,1,1,1,0,0}
// {0,0,1,1,1,0,0}
// {1,1,1,1,1,1,1}
// {1,1,1,0,1,1,1}
// {1,1,1,1,1,1,1}
// {0,0,1,1,1,0,0}
// {0,0,1,1,1,0,0}
for(i=0;i<7;i++){
for(j=0;j<7;j++){
plateau[i][j] = 1;
}
}
for(k=0;k<2;k++){
for(l=0;l<2;l++){
for(i=0;i<2;i++){
for(j=0;j<2;j++){
plateau[i+5*k][j+5*l] = 0;
}
}
}
}
plateau[3][3]=0;
}
void affiche_plateau(int **plateau, int x_plateau, int y_plateau)
{
int x, y;
// SPRITE DU PLATEAU
const unsigned char solitaire[]={
0xff,0xff,0xff,0xff,0xff,0xe0,
0x80,0x8,0x20,0x82,0x0,0x20,
0x80,0x8,0x20,0x82,0x0,0x20,
0x80,0x8,0x20,0x82,0x0,0x20,
0x80,0x8,0x20,0x82,0x0,0x20,
0x80,0x8,0x20,0x82,0x0,0x20,
0x80,0xf,0xff,0xfe,0x0,0x20,
0x80,0x8,0x20,0x82,0x0,0x20,
0x80,0x8,0x20,0x82,0x0,0x20,
0x80,0x8,0x20,0x82,0x0,0x20,
0x80,0x8,0x20,0x82,0x0,0x20,
0x80,0x8,0x20,0x82,0x0,0x20,
0xff,0xff,0xff,0xff,0xff,0xe0,
0x82,0x8,0x20,0x82,0x8,0x20,
0x82,0x8,0x20,0x82,0x8,0x20,
0x82,0x8,0x20,0x82,0x8,0x20,
0x82,0x8,0x20,0x82,0x8,0x20,
0x82,0x8,0x20,0x82,0x8,0x20,
0xff,0xff,0xff,0xff,0xff,0xe0,
0x82,0x8,0x20,0x82,0x8,0x20,
0x82,0x8,0x20,0x82,0x8,0x20,
0x82,0x8,0x20,0x82,0x8,0x20,
0x82,0x8,0x20,0x82,0x8,0x20,
0x82,0x8,0x20,0x82,0x8,0x20,
0xff,0xff,0xff,0xff,0xff,0xe0,
0x82,0x8,0x20,0x82,0x8,0x20,
0x82,0x8,0x20,0x82,0x8,0x20,
0x82,0x8,0x20,0x82,0x8,0x20,
0x82,0x8,0x20,0x82,0x8,0x20,
0x82,0x8,0x20,0x82,0x8,0x20,
0xff,0xff,0xff,0xff,0xff,0xe0,
0x80,0x8,0x20,0x82,0x0,0x20,
0x80,0x8,0x20,0x82,0x0,0x20,
0x80,0x8,0x20,0x82,0x0,0x20,
0x80,0x8,0x20,0x82,0x0,0x20,
0x80,0x8,0x20,0x82,0x0,0x20,
0x80,0xf,0xff,0xfe,0x0,0x20,
0x80,0x8,0x20,0x82,0x0,0x20,
0x80,0x8,0x20,0x82,0x0,0x20,
0x80,0x8,0x20,0x82,0x0,0x20,
0x80,0x8,0x20,0x82,0x0,0x20,
0x80,0x8,0x20,0x82,0x0,0x20,
0xff,0xff,0xff,0xff,0xff,0xe0
};
ML_bmp_or(solitaire, x_plateau, y_plateau, 43, 43);
for(x=0;x<7;x++){
for(y=0;y<7;y++){
if(plateau[x][y] == 1) ML_point((x_plateau)+3+6*x, (y_plateau)+3+6*y, 3, ML_BLACK);
}
}
}
void resoudre(int **plateau)
{
do{
bouger(plateau);
}while(somme_plateau(plateau) != 1);
}
int somme_plateau(int **plateau)
{
int i,j,s=0;
for(i=0;i<7;i++){
for(j=0;j<7;j++){
s+=plateau[i][j];
}
}
return s;
}
void bouger(int **plateau)
{
int x, y;
int direction, sav_direction;
int x_direct, y_direct;
int terminer;
terminer = 0;
do{
x = rand_int(6);
y = rand_int(6);
}while(plateau[x][y] != 1);
/* DIRECTION :
+-+-+-+-+-+-+
| | | |1| | |
+-+-+-+-+-+-+
| | |4|O|2| |
+-+-+-+-+-+-+
| | | |3| | |
+-+-+-+-+-+-+
*/
direction = rand_int(4)+1;
sav_direction = direction;
do{
if(direction==1){
x_direct = 0;
y_direct = -1;
if(y-2 < 0) y_direct = 0;
}
if(direction==2){
x_direct = 1;
y_direct = 0;
if(x+2 > 7) x_direct = 0;
}
if(direction==3){
x_direct = 0;
y_direct = 1;
if(y+2 < 0) y_direct = 0;
}
if(direction==4){
x_direct = -1;
y_direct = 0;
if(x-2 < 0) x_direct = 0;
direction = 0;
}
direction++;
}while(direction != sav_direction && (plateau[x+x_direct][y+y_direct] != 1 || plateau[x+2*x_direct][y+2*y_direct] != 0));
if(plateau[x+x_direct][y+y_direct]==1 && plateau[x+2*x_direct][y+2*y_direct] == 0){
plateau[x][y]=0;
plateau[x+x_direct][y+y_direct]=0;
plateau[x+2*x_direct][y+2*y_direct]=1;
Bdisp_AllClr_DDVRAM();
affiche_plateau(plateau,30,10);
Bdisp_PutDisp_DD();
Sleep(50);
if (somme_plateau(plateau) == 1) terminer = 1;
bouger(plateau);
if(terminer==0){
plateau[x][y]=1;
plateau[x+x_direct][y+y_direct]=1;
plateau[x+2*x_direct][y+2*y_direct]=0;
}
}
}
RTC_getTicks()
{
static int SysCallCode[] = {0xD201422B,0x60F20000,0x80010070};
static int (*SysCall)(int R4, int R5, int R6, int R7, int FNo ) = (void*)&SysCallCode;
return (*SysCall)(0, 0, 0, 0, 0x3B);
}
rand_int(int max)
{
return rand() % max;
}
#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
Edit: C'est bon j'ai trouvé tout seul j'avais des erreurs dans mes conditions de debordement de la taille du plateau
Citer : Posté le 26/03/2014 15:34 | # |
Fichier joint
Bon ben voila j'ai fini mon programme qui est en effet pas très performant
Il ne trouve pas plus loin que 2 cases
Enfin c'est deja un debut
Citer : Posté le 26/03/2014 22:02 | #
Voila mon soucis, à la manière de Flappy Bird de Dark Storm, je voudrais afficher un nombre (celui des coups joué) avec des sprites représentant des chiffres
_00000_
_0___0_
_0_0_0_
_0_0_0_
_0_0_0_
_0___0_
_00000_
Malheureusement mon code fait des chose bizarre, le voici, une amélioration (ou un nouveau code complet) serait la bienvenu
ML_bmp_and(Chiffres[(Coups/(10^Z))%10],92+Z*6,11,7,7);
ML_bmp_or(Chiffres[(Coups/(10^Z))%10],92+Z*6,11,7,7);
}
Citer : Posté le 26/03/2014 22:11 | #
10^Z n'existe pas en C.
utilise plutot pow(10,z), cela marchera (mais la fonction est plutôt lente) (il faut inclure math.h)
plus précisement, ^ permet de comparer deux nombre bits a bits en effectuant un Xor
par exemple,
100111 ^
101010 =
001101
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 !