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, 4, 5, 6, 7 ··· 10 ··· 20, 21, 22, 23 – Suivante

Lephenixnoir En ligne Administrateur Points: 24232 Défis: 170 Message

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 ?

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 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

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

Lephenixnoir En ligne Administrateur Points: 24232 Défis: 170 Message

Citer : Posté le 25/03/2014 21:21 | #

int tabsum(int **);

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

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

Smashmaster Hors ligne Ancien modérateur Points: 4561 Défis: 253 Message

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}
};

Sprite Coder - codeur de sprite pour la cg-20 et g75/85/95,

Louloux Hors ligne Ancien administrateur Points: 7035 Défis: 61 Message

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

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

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

tableau[7][7]={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);

?

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

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

Lephenixnoir En ligne Administrateur Points: 24232 Défis: 170 Message

Citer : Posté le 25/03/2014 21:34 | #

tableau[7][7]= {
{ 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 } };

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

Smashmaster Hors ligne Ancien modérateur Points: 4561 Défis: 253 Message

Citer : Posté le 25/03/2014 21:34 | #

Non ça ne marche qu'avec les tableaux normaux.

édit : grillé

Sprite Coder - codeur de sprite pour la cg-20 et g75/85/95,

Lephenixnoir En ligne Administrateur Points: 24232 Défis: 170 Message

Citer : Posté le 25/03/2014 21:35 | #

Au fait, c'est un "+" ?
Ça sert à quoi ?

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 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)

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

Smashmaster Hors ligne Ancien modérateur Points: 4561 Défis: 253 Message

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.

Sprite Coder - codeur de sprite pour la cg-20 et g75/85/95,

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

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

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

Lephenixnoir En ligne Administrateur Points: 24232 Défis: 170 Message

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 ?

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 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:

La fonction

Cliquer pour enrouler

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);
        }
    }
}

Pourtant il me semble pas avoir fait de bêtises

...

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

Smashmaster Hors ligne Ancien modérateur Points: 4561 Défis: 253 Message

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]

Sprite Coder - codeur de sprite pour la cg-20 et g75/85/95,

Dodormeur Hors ligne Ancien rédacteur Points: 3965 Défis: 84 Message

Citer : Posté le 25/03/2014 22:10 | #

@theprog et lephenix : Faut écouter un peu

quand je dit que le compilateur voit les tableau 2D comme des tableaux 1D, il perçoit le nom du tableau comme un int*, et non pas comme un int** !
Utilise le script de smash si tu veux utiliser des int**

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

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 !

Lephenixnoir En ligne Administrateur Points: 24232 Défis: 170 Message

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.

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 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

Cliquer pour enrouler

#include "fxlib.h"
#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

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

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

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

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

Kirafi Hors ligne Membre Points: 2180 Défis: 10 Message

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

.mes sprites font donc 7*7,

Dessin du 0

Magnifique 0

_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

for(Z=0;Z<(log (Coups))+1;Z++){
    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);
    }

iPod

Pour des parties rapides

Jusqu'où pourras-tu aller dans ce jeu "partie rapide" qu'est Dextris (élu Jeu Du Mois)

Pourras-tu survivre plus de 20 secondes dans ce fameux tunnel appelé Graviton

Rebondis entre les murs en évitant les piques dans SpikeBird

Pourras-tu éviter de te faire écraser dans FallBlocs (élu Jeu Du Mois)

Autres

Franchement ils valent le coups

Deviens l'amiral de la marine dans SeaRush (jeu concours) (élu Jeu Du Mois)

La version 2048 tactile amélioré au plus haut point : 2048 Delux !

Pars à la recherche des morceaux d'étoile dans Lumyce (élu Jeu Du Mois)

Dodormeur Hors ligne Ancien rédacteur Points: 3965 Défis: 84 Message

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

Pokemon !!!!!! => pokemon stadium/battle

mes meilleurs jeux

Cliquer pour enrouler

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

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 !

Précédente – 1, 2, 3, 4, 5, 6, 7 ··· 10 ··· 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 huit ?

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 49 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