[zeldalyoko]

Salut,

J'ai plus ou moins terminée un projet, que j'ai commencé y hum... deux jours environs (a deux heures par jour x). J'ai eut de multiple problème, j'ai du recommencé les lignes des centaines de fois, mais finalement, j'y suis arrivé ! Ce n'est pas terminée malheureusement et j'ai besoin d'avis et de conseil pour optimisé ce code. C'est un sudoku (comme d'hab  ) qui fonctionne mieux que l'anciens (sur pc). Je demande conseil car je ne suis pas sûr sur l'utilisation de s8 et s16. Je n'ai jamais su qu'elle type (ex : int, long, double etc... ) utilisé, je fais toujours au pif et si sa fonctionne tant mieux 

Bref... voici le code :

Code

 (c):
#include <PA9.h>  
#include "gfx/all_gfx.c"
#include "gfx/all_gfx.h"
#include "function.h"
 
//Debut de la fonction
void ingame(){	
 
	//On init tout ce qu'il faut 
	PA_InitText(1,0);
	PA_LoadSpritePal(0, 0, (void*)decors_Pal);
	PA_LoadSpritePal(0, 1, (void*)objet_Pal);
	PA_LoadSpritePal(0, 2, (void*)personnage_Pal);
 
 
 
	//Map Test (pour les tests
	s16 map[9][9] = {
	   {1,1,1,1,1,1,1,1,1},
		{1,0,1,0,0,0,1,2,1},
		{1,0,1,2,0,0,0,0,1},
		{1,0,1,2,1,0,0,0,1},
		{1,0,1,1,1,0,0,0,1},
		{1,0,1,2,1,0,0,0,1},
		{1,0,0,0,0,0,0,0,1},
		{1,2,1,0,0,0,0,0,1},
		{1,1,1,1,1,1,1,1,1}};
 
	//Idem 
	s16 objet[9][9] = {
	   {0,0,0,0,0,0,0,0,0},
		{0,0,0,0,0,0,0,0,0},
		{0,3,0,0,0,3,0,0,0},
		{0,0,0,0,0,0,0,0,0},
		{0,0,0,0,0,0,0,3,0},
		{0,0,0,0,0,0,0,0,0},
		{0,0,0,0,3,0,3,0,0},
		{0,0,0,0,0,0,0,0,0},
		{0,0,0,0,0,0,0,0,0}};
 
	//Les variables (Note : j'ai du me trompé avec le s8)
	s8 x, y, hx, hy, im, retour; hx = 1, hy = 1, im = 0, retour = 0;  
 
	//Le hero x)
	PA_CreateSprite(0, im, (void*)personnage_Sprite, OBJ_SIZE_16X16, 1, 2, hx, hy);
	im ++; 
 
	for(x = 0; x < 9; x ++){
		for(y = 0; y < 9; y ++){
			switch(objet[y][x]){			
				case 3:
					PA_CreateSprite(0, im, (void*)caisse_no_Sprite, OBJ_SIZE_16X16, 1, 1, x << 4, y << 4);
					im ++;
				break;
			}	
		}
	y = 0;
	}	
		for(x = 0; x < 9; x ++){
	   	for(y = 0; y < 9; y ++){
	      	switch(map[y][x]){
	         	case 1:
		   			PA_CreateSprite(0, im, (void*)murs_Sprite, OBJ_SIZE_16X16, 1, 0, x << 4, y << 4);
					break;
					case 0:
					   PA_CreateSprite(0, im, (void*)sols_Sprite, OBJ_SIZE_16X16, 1, 0, x << 4, y << 4);
					break;
					case 2:
					   PA_CreateSprite(0, im, (void*)emplacement_Sprite, OBJ_SIZE_16X16, 1, 1, x << 4, y << 4);
					break;
				}
				im ++;		
			}
			y = 0;
		}
 
	while (1)
	{
	   //Deplacement x)
		if(Pad.Newpress.Up){
		   verification(map, objet, &hx, &hy, 1, 0, -1, 0, -2, 0);}	
		else if(Pad.Newpress.Down){
		   verification(map, objet, &hx, &hy, 1, 1, +1, 0, +2, 0);}
		else if(Pad.Newpress.Right){
		   verification(map, objet, &hx, &hy, 2, 1, 0, +1, 0, +2);}
		else if(Pad.Newpress.Left){
		   verification(map, objet, &hx, &hy, 2, 0, 0, -1, 0, -2);}
 
		PA_OutputText(1,10,10,"%d",retour);
		PA_SetSpriteXY(0, 0, hx<<4, hy<<4);	
 
 
                      //Affichage des objets sur l'écran du haut pour les tests. (très utile ses lignes)
		im = 1;
		for(x = 0; x < 9; x ++){
	   	for(y = 0; y < 9; y ++){
				if(objet[y][x] == 3 || objet[y][x] == 4){
					   PA_SetSpriteXY(0, im, x << 4, y << 4);
				              im ++;
				}	
				PA_OutputText(1,x,y,"%d",objet[y][x]);
 
			}
			y = 0;
		}
 
		PA_OutputText(1,x,y,"x %d y %d",hx, hy);
 
		PA_WaitForVBL();
	}
 
}  
 
 
//Fonction de deplacement des objets/heros
void verification(s16 map[9][9], s16 objet[9][9], s8 *hx, s8 *hy, s8 direct, s8 ajout, s8 iy, s8 ix, s8 ey, s8 ex){
s8 hhx, hhy, deplac; deplac = 0; hhx = *hx; hhy = *hy;
 
	//On verifie les objets et map pour savoir si certain deplacement sont autorisés >__<
	if(map[hhy + ey][hhx + ex] == 2 && (objet[hhy + iy][hhx + ix] == 3 || objet[hhy + iy][hhx + ix] == 4)){objet[hhy + ey][hhx + ex] = 4; objet[hhy + iy][hhx + ix] = 0; deplac = 1;}
	else if(map[hhy + ey][hhx + ex] != 1 && (objet[hhy + iy][hhx + ix] == 3 || objet[hhy + iy][hhx + ix] == 4)){objet[hhy + ey][hhx + ex] = 3; objet[hhy + iy][hhx + ix] = 0; deplac = 1;}
	else if(map[hhy + iy][hhx + ix] != 1){deplac = 1;}
 
	//appelle de la fonction qui deplace le hero
	if(deplac == 1){deplacement_hero(map, objet, &hhx, &hhy, direct, ajout);}
*hx = hhx;
*hy = hhy;	
}
 
 
//Fonction de deplacement du hero simple (si, je n'ai pas cette fonction, je devrait copié, collé a chaque fois ce code >__<)
void deplacement_hero(s16 map[9][9], s16 objet[9][9], s8 *hx, s8 *hy, s8 direct, s8 ajout){
s8 hhx, hhy;
hhx = *hx;
hhy = *hy;
 
 
	   if(ajout == 1){
		   if(direct == 1){hhy ++;}
		   else if(direct == 2){hhx ++;}	
		}	
		else{
		   if(direct == 1){hhy --;}
			else if(direct == 2){hhx --;}
		}
 
*hx = hhx;
*hy = hhy;
}

Je demande car c'est la première fois que je code pour DS et que je vois Palib. D'ailleurs, j'ai entendu dire (sur les tutos x) que la mémoire vive de la NDS était limité a 4mo... est-ce que mon code peu passé sur une vrai DS ? (je n'ai pas de linker pour essayé) comment libéré de la mémoire ? j'ai entendu parler de free(); mais je crois que c'est plus pour les variables char* crée manuellement avec malloc, je me trompe ?

Si vous avez eut le courrage et le temps de lire, si vous avez trouvé la moindre erreur, merci de me le signalé.

Merci
@bientôt

EDIT : Je me demande si je n'ai pas meilleur t'en d'utilisé une structure (struct) pour les caisses a déplacé  que de devoir utilisé un tableau. (vous en pensez quoi ? )

[philoo]

En fait c'est assez simple :
 s8 : c'est un entier signe sur 8bit. le 1er bit (le MSB) est utilise pour le signe. Donc il te reste 7 bit pour le nombre. Tu peux donc l'utiliser de -128 a +127.
 u8 c'est sans le signe donc 8 bit pour le nombre : de 0 a 255.

 u16 : pareil que u8 mais avec 16 bits : de 0 a 65535
 s16 : pareil que s8 mais avec 16 bits : de -32768 a 32767

Maintenant les int, long...dependent generalement de la machine sur laquelle tu compiles.
en generale int est equivalent a s16. long est le double de int.

float et double sont utilises pour les nombre flottant (on va dire des reels).

J'espere ne pas avoir ecrit de betises 

[Mollusk]

Alors... Fais une recherche sur le forum pour savoir à quoi correspond u8/s8/etc, on en a parlé plusieurs fois

Concernant les 4Mo, ça reste assez large. De manière générale tu ne risques pas de les atteindre juste avec du code, à moins d'avoir des tableaux gigantesques (le calcul est vite fait : 9 * 9 * 2 (car 16bit) = 162 octets, tu es loin d'atteindre 4Mo comme ça  Le facteur limitant des 4Mo c'est plutôt pour les ressources à inclure dans le projet, en fait

Vite fait : u8 c'est limité aux valeurs de 0 à 255, donc pour ton sudoku ça devrait suffir

"y = 0;" dans ta boucle, après la boucle for, il sert à rien puisque la boucle for remet y à 0
Concernant les switch/case, tu pourrais les regrouper tous dans une seule boucle, ça évite de parcours 2 fois tout le tableau. Tu pourrais aussi faire un tableau qui référence en fonction de la valeur le sprite à afficher, comme ça tu évites le switch/case et tu fais
PA_CreateSprite(0, im++, monsprite[map[y][ x]], ...);

Ensuite on peut argumenter que ce que je viens de te dire ne sert à rien puisqu'optimiser l'init te feras rien gagner, c'est dans la boucle de jeu qu'il faut faire les optimisations


Et à part ça, je dois partir et ça m'a pas l'air trop gourmand ton code de toute façon

[Ludo6431]

Je pense que tu peux tout faire en u8, il ne devrait pas y avoir de pb.
Ensuite, par exemple pour cette fonction :

Code

 (c):
void deplacement_hero(/*u8 map[9][9], u8 objet[9][9],*/ u8 *hx, u8 *hy, u8 direct, u8 ajout){
	if(ajout==1) {
		if(direct==1) (*hy)++;
		else if(direct==2) (*hx)++;
	}
	else {
		if(direct==1) (*hy)--;
		else if(direct==2) (*hx)--;
	}
}

Pourquoi crées-tu d'autres variables ?
Et pourquoi passes-tu en argument des choses que tu n'utilises pas ?

edit :
Je t'ai modifié cette fonction aussi :

Code

 (c):
void verification(u8 map[9][9], u8 objet[9][9], u8 *hx, u8 *hy, u8 direct, u8 ajout, u8 iy, u8 ix, u8 ey, u8 ex){
	u8 deplac=0;
 
	if(map[(*hy) + ey][(*hx) + ex]==2 && (objet[(*hy) + iy][(*hx) + ix]==3 || objet[(*hy) + iy][(*hx) + ix]==4)) {
		objet[(*hy) + ey][(*hx) + ex]=4;
		objet[(*hy) + iy][(*hx) + ix]=0;
		deplac=1;
	}
	else if(map[(*hy) + ey][(*hx) + ex]!=1 && (objet[(*hy) + iy][(*hx) + ix]==3 || objet[(*hy) + iy][(*hx) + ix]==4)) {
		objet[(*hy) + ey][(*hx) + ex]=3;
		objet[(*hy) + iy][(*hx) + ix]=0;
		deplac=1;
	}
	else if(map[(*hy) + iy][(*hx) + ix] != 1) deplac=1;
 
	if(deplac==1) deplacement_hero(map, objet, hx, hy, direct, ajout);
}

[philoo]

Pout l'ajout des variables hhx et hhy c'est a cause des pointeurs qui ne semblent
pas fonctionner comme ils le devraient. J'ai eu le meme soucis.
Peut-etre il y a-t'il une autre methode.

[Ludo6431]

Euh t'es sûr ?
Pourquoi ils ne marcheraient pas ?

(Tu fesais bien ce code ?, exactement ? (les parenthèses sont importantes))

[philoo]

Ah OK. J'avais pas vu les parenthèses.
Bien joué l'artiste 
Ca va me servir pour la prochaine fois.
Merci.

[zeldalyoko]

Salut,

Merci Philoo et Mollusk pour l'explication des types de variables et des informations sur la mémoire vive de la DS

Pourquoi crées-tu d'autres variables ?
Et pourquoi passes-tu en argument des choses que tu n'utilises pas ?

J'ai fais quelque chose d'autre avec cette fonction, mais je n'ai pas pensé a supprimé les variables inutiles etc...   

Code

 (c):
(Tu fesais bien ce code ?, exactement ? (les parenthèses sont importantes))

Hum... J'ai fais des recherches durant 6 heures pour une con**** de parenthése   

En tout cas merci pour les infos
@bientôt.

[zeldalyoko]

Juste une question, je vais utilisé le code de Ludo, mais, un soucis est présent. Je n'ai aucune "collision" avec les murs en haut et les murs a gauche...

Code

 (c):
	if(Pad.Newpress.Up){
		   verification(map, objet, &hx, &hy, 1, 0, -1, 0, -2, 0);}	
		else if(Pad.Newpress.Down){
		   verification(map, objet, &hx, &hy, 1, 1, +1, 0, +2, 0);}
		else if(Pad.Newpress.Right){
		   verification(map, objet, &hx, &hy, 2, 1, 0, +1, 0, +2);}
		else if(Pad.Newpress.Left){
		   verification(map, objet, &hx, &hy, 2, 0, 0, -1, 0, -2);}

avec les "-1" et "-2"... avec ma version du code, tout fonctionnait, mais a présent o_O plus rien ne fonctionne. Je ne comprend pas, vous avez une idée ?

[philoo]

Si tu as utilise le code de Ludo alors tu as utilise des u8 a la place de s8.
Il te faut des nombres signes si tu veux utiliser de nombre negatifs.

Je suppose que ton erreur vient de la.

[Ludo6431]

Ah oui désolé j'avais pas vu que tu utilisais des nombres négatifs -_-'
Alors à ce compte-là, oui tu mets s8

[zeldalyoko]

Effectivement 
Merci pour les informations 

@bientôt