Probleme newb c :( - Page 1

Bon voilà, alors que j'essayais d'apprendre à programmer en C, je me suis retrouvé coincé devant un probleme bête.

bon d'abord qqs morceaux de sources:

typedef struct {
short Level;	
short Nbr_ball;	
} Game;

typedef struct {
short Life;
short Pad_x;
short Pad_Largeur;
short Pad_Type;
short Pad_Speed;
} Player;

typedef struct {
unsigned char Briques[120];
short Pad_x;
short Pad_Largeur;
short Pad_Type;
short Pad_Speed;
} Level;


Level Level1 = {
	{
	0,6,6,6,2,2,6,6,6,0,
	0,8,6,6,2,2,6,6,8,0,
	0,0,8,6,2,2,6,8,0,0,
	0,7,8,5,6,6,5,8,7,0,
	0,8,8,8,5,5,8,8,8,0,
	0,0,7,7,8,8,7,7,0,0,
	0,0,0,7,9,9,7,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
	},
	72,
	16,
	NORMAL,
	1	
};

void IniLevel( Game *jeu, Player *joueur)
{
Level * lvl[] = 	{
									 &Level1
								};
								
								
long *Dest=(long*)level_active;
long	*Source=(long*)lvl[jeu->Level]->Briques;
short i;
for (i=0; i<30; i++) (*Dest++)=(*Source);

joueur->Pad_x = lvl[jeu->Level]->Pad_x;
joueur->Pad_Largeur = lvl[jeu->Level]->Pad_Largeur;
joueur->Pad_Type = lvl[jeu->Level]->Pad_Type;
joueur->Pad_Speed = lvl[jeu->Level]->Pad_Speed;

Babal[0].x = lvl[jeu->Level]->Pad_x + (lvl[jeu->Level]->Pad_Largeur>>1) - 3;
Babal[0].y = 88;

for (i=1; i<10; i++)
{
	Babal[i].x=-15;
	Babal[i].dx=0;
	Babal[i].dy=0;	
}


}

void Game1P()
{
	Game Solo;
	Player P1;
	
	Solo.Level=1;
	Solo.Nbr_ball=1;								
	P1.Life=4;

	IniLevel( &Solo, &P1);
	
	
  do{
		XClrGPlan();
		DrawPad(&P1);
		XPrintf(1,1," %u ",(int)P1.Pad_x);
    XCpyGPlanToLCD();
    if (Press.Up) P1.Pad_Largeur++;
    if (Press.Down) P1.Pad_Largeur--;
    

  	XJoyPad();

  } while (!Press.Esc);
	
}

Voià, j'espère ne rien avoir oublié...
Bon le probleme viens de la fonction IniLevel...
Il doit y avoir un problème, puisque quand je lis Pad_x, j'ai: 40960 au lieu de 72.

Le probleme doit venir donc de :
joueur->Pad_x = lvl[jeu->Level]->Pad_x;
Mais pourquoi

erf tout le monde dort

Parce que, en C, les arrays commencent avec 0, donc
joueur->Pad_x = lvl[jeu->Level]->Pad_x;
doit être
joueur->Pad_x = lvl[jeu->Level - 1]->Pad_x;

Arf.. je suis con j'avais pas vu...
c'est ce de programmer si tard...

Merci

Bon moi je vais me coucher.. la fatigue ca paye pas en prog

arf oué, le 1er élément d'un tableau est le 0ème en C

Je cherchais un truc plus complexe que ça moi , à vérifier la syntaxe, si tu avais bien les valeurs et pas les adresses, mais en fait non

Moi aussi

Es ce que qnn peu m'expliquer:
unsigned short** lookup_table = (unsigned short *[64]){
(unsigned short [1]){0},
(unsigned short [2]){0,256},
(unsigned short [3]){0,168,176},
(unsigned short [4]){0,128,128,128},
(unsigned short [5]){0,104,104,96,104},
(unsigned short [6]){0,88,80,88,88,80},
(unsigned short [7]){0,72,72,72,80,72,72},

parce que j'ai encore un peu de mal

Je crois qu'il faut faire

typedef unsigned short usarray[0];

puis

usarray *lookup = (usarray[64]){
{0},
{0,256},
{0,168,176},
...};

(en tout cas c censé marcher dans GTC )

Ca veins du tuto de la tict.

Ce que je ne comprend pas c'est la syntax
unsigned short** lookup_table = (unsigned short *[64]){ // pkoi 2 etoiles? pointeur sur pointeur?;§!
// pourquoi *[64].. un pointeur sur un tableau de short de dim 64, mais il y en a qui font que 1, 2... seront ils convertis en {16 0 a la suite }?
(unsigned short [1]){0},
(unsigned short [2]){0,256},
(unsigned short [3]){0,168,176},
(unsigned short [4]){0,128,128,128},
(unsigned short [5]){0,104,104,96,104},
(unsigned short [6]){0,88,80,88,88,80},
(unsigned short [7]){0,72,72,72,80,72,72},
...

>>// pkoi 2 etoiles? pointeur sur pointeur?;§!
First I'm sorry for the English, I will try to translate into French, but I can't program in
French, nor can I explain programming in French
D'abord, désolé d'écrire en anglais, j'essayerai de le traduire en français, mais je ne peux pas faire la programmation en français, et j'ai du mal à expliquer la programmation en français

There are two stars because it's a pointer to a pointer, yes. It's a pointer to the pointer to the start of the first array: 3d arrays can be declared with two *'s.

Il y a deux *'s parce que c'est un pointer sur un pointer, oui. C'est un pointer sur le pointer sur le début du premier tableau: 3d tableau peuvent être définis avec deux *'s.

>>// pourquoi *[64].. un pointeur sur un tableau de short de dim 64, mais il y en a qui >>font que 1, 2... seront ils convertis en {16 0 a la suite }?
He's casting it to a pointer to an array of 64 elements. There's more there, I'm sure, to make 64 elements in it. Arrays can be tought of as sort of like a pointer:
char* x = "This is a string";
char y[] = "This is a string";
The thing is, x is modifiable, useable in loops (x++, x--, etc), so that's how he's doing it. In the second example, y is the same as &(y[0]) and *y is the same as y[0], and *(y + 1) is the same as y[1]. It's an abstract concept that I have trouble explaining in English, much less French
Il le convertis à un pointer sur un tableau de 65 élémets. Je suis sûr qu'il y a 64 choses dans ce tableau. On peut penser des tableaus comme pointers:
char* x = "C'est une chaîne";
char y[] = "C'est une chaîne";
x peut être changé, comme x++, x--, etc. alors c'est comment il le fait. Dans le deuxième exemple, y est le même que &(y[0]) and *y est le même que y[0], et *(y + 1) est le même que y[1], et *(y + z) est le même que y[z]. C'est une idée abstacte (je ne pense pas que c'est le mot que je veux dire) que j'ai même du mal à expliquer en anglais

est ce que:
(unsigned short *[64])
implique que {0} sera convertit en {0,0,0,0,0,0,0,0,0,0,...} ?
Ou alors c'est juste pour que le compilo comprenne...

unsigned short *[64] signifie 64 fois unsigned short *, donc ça va être un array de 64 longs, avec les références initialisées vers les tableaux que tu as mis :

table:
dc.l tab1
dc.l tab2
... (64 fois)

tab1:
dc.w 1,2,3
tab2:
dc.w 4,5,6,7,8

Si tu veux faire un tableau avec des sous-tableaux de taille 64, sans pointeurs (je pense que c ce que tu veux faire vu ton dernier post) :

typedef struct {
char tab[64];
} char64;

char64 mytable[0]={
{1,2,3},
{4,5,6,7,8}};

sera converti en
mytable:
dc.w 1,2,3,0,0,0...
dc.w 4,5,6,7,8,0,0...

Voilà

Ok.. je comprend tout de suite mieux quand c'est transcrit en asm
Thx joelt49 & Pollux.