[Palib || Libnds] Récupérer Un Uniqid

[alex331980]

Hello !

Pour commencer à bidouiller des fonctions de coop sur un projet de jeu perso, je cherche à récupérer un uniqid pour identifier une console. J'arrive à récupérer le nom du user, la date etc... mais rien concernant un hypothétique serial ou autre permettant d'identifier de manière sûre une console d'une autre.

Vous auriez un lien, ou une fonction qui m'aurait échappée ?

[Asthroth]

Peut etre en récupérant l'adresse MAC de la DS non? après comment on fait ca, aucune idée, désolé.

[alex331980]

:-/

[Asthroth]

et si tu tire, aléatoirement, 3 chiffres compris entre 0 et, disons, 1 000 000, et que tu les sauvegarde sur la cartouche.

Ce trinome de chiffres pourrait contitué un ID et meme si l'unicité du tirage n'est pas garantie à 100%, on en est pas loin non?

Le tirage n'est fait qu'un fois bien sur, à la première utilisation.

[alex331980]

Oui, mais j'aimerai quelque chose qui tienne dans le temps, car là en cas de mise à jour du jeu, ben on perd tout

Sauf si tu connais le moyen d'écrire un fichier sur un linker ? Car perso j'arrive qu'à écrire dans le .nds

J'ai jamais réussi à écrire dans un .SAV externe au jeu.

[Asthroth]

Moi j'ai trouvé cela et j'en ai fait une classe. J'ai fais des essais et ca fonctionne, après c'est encore en cours de développement, donc peut etre à débugger un peu

Le H

#ifndef DEF_SRam
#define DEF_SRam
#include "nds/arm9/console.h"

 
 #ifdef ARM9
 #define WAIT_CR REG_EXMEMCNT
 #else
 #define WAIT_CR REG_EXMEMSTAT
 #endif
 // #define WAIT_CR 	0x04000204
	
class SRam
{
    public:
	SRam();
	~SRam();
	
	void LireSauvegarde(char *, int); //méthode pour lire la sauvegarde de la SRam vers le membre sram_data
	bool EnregistreSauvegarde(char *, int); //Methode pour enregistrer les données vers la SRam
	void DonneCardID(char *); //renvoie le card ID
	 
    private:
	void InitAccessSRam(void); /* Enable the ARM9 to access the GBA cartridge memory area */
	int is_homebrew_cartridge(char * ) ; //Méthode qui va vérifier si la PASS est bien respecté
	void memcpySRam(char* , char * , int ); //Methode permettant d'ecrire dans une zone mémoire
	void memsetSRam(char* , char , int ); //Methode permettant d'initialiser une zone mémoire

	char card_id[5]; 
	char sram_data[101]; //contenu de la SRAM apres lecture de celle-ci
	//char copy_status[32];

};
 
#endif

Le CPP

#include "SRam.h"
#include <nds.h>
#include <stdio.h>

//constructeur 
SRam::SRam()
{
	//RAZ de la copy local des 100 premiers octets de la SRAM
	memsetSRam(sram_data, 0, sizeof(sram_data));
	memsetSRam(card_id, 0, sizeof(card_id));
	
	 // copie le contenu des 4 caractères de l'identifiant de la ROM dans une variable locale
	 //Ce doit être 'PASS' pour toutes les homebrew ROM's. cet ID est localisé à l'adresse 0x080000AC.
	memcpySRam(card_id, (char*)0x080000AC, 4);
}
//destructeur
SRam::~SRam(){}

// active le ARM9 pour accéder à la zone memoire de la cartouche
void SRam::InitAccessSRam(void) 
{	
  WAIT_CR &= ~0x80;
}

//méthode pour lire la sauvegarde de la SRam vers le membre sram_data
void SRam::LireSauvegarde(char *TxtRelue, int Taille)
{
      //copie le contenu de la SRAM vers une variable locale
      memcpySRam(sram_data, (char*)SRAM, Taille - 1);
	  strcpy(TxtRelue,sram_data);
} 

//Methode pour enregistrer les données vers la SRam
//renvoie 1 si c'est ok, sinon renvoie 0
bool SRam::EnregistreSauvegarde(char *TxtSauve, int Taille)
{
	/* Copy une chaine de texte dans la SRAM si la cartouche a un homebrew ROM. */
	if(is_homebrew_cartridge(card_id)) 
	{
		memcpySRam((char*)SRAM, TxtSauve, Taille);
		return 1;
	}
	else
		return 0;
		//memcpy(copy_status, error, sizeof(error));
}

//Méthode qui va vérifier si la PASS est bien respecté
int SRam::is_homebrew_cartridge(char * card_id) 
{
  return 
    card_id[0] == 'P' &&
    card_id[1] == 'A' &&
    card_id[2] == 'S' &&
    card_id[3] == 'S';
}

//Methode permettant d'ecrire dans une zone mémoire
void SRam::memcpySRam(char* dest, char * src, int size) {
  while(size--) 
    *dest++ = *src++;
}

//Methode permettant d'initialiser une zone mémoire
void SRam::memsetSRam(char* dest, char fill, int size) {
  while(size--)
    *dest++ = fill;
}
	
void SRam::DonneCardID(char * cardID)
{
	strcpy(cardID, card_id);
}

Ca va te faire un .SAV que tu pourra relire par la suite et modifier.

Modifié 7 novembre 2013 par Asthroth

[alex331980]

Merci, je vais tester ça, en le modifiant au besoin, vu que le projet l'utilisant est en C

(Ben vi, j'ai tout appris en C, le c++ j'adhère pas )

[Asthroth]

Bonne chance en espérant que ca résolve ton problème

[alex331980]

Si ça marche en C, oui, ça le résout

[alex331980]

Re.

Fonctionne sur emulateur NO$GBA, mais pas sur R4 revolution. La chaine "PASS" n'est pas retournée (j'ai fait un print du retour de 0x080000AC, c'est une chaine vide).

[alex331980]

Double post, la fonction EDIT renvoie sur une page blanche sur ce PC -_-'

J'ai décidé de me replonger dedans, et en fait, j'arrive à écrire sur un fichier .SAV, en faisant ceci:

	if(EFS_Init(EFS_AND_FAT | EFS_DEFAULT_DEVICE, NULL )) {
        fatInitDefault();


....


....


                     FILE* test = fopen ("fat1:/DEFAULT.SAV", "wb");
                    Character xxx;
                    newCharacter(&xxx);
                    fwrite(&xxx, sizeof(Character), 1, test);
                    fclose( test );

Par contre, initialiser les 2 systèmes de fichiers (dont la FAT en double d'ailleurs...) ne risque pas de poser des soucis ?

Ensuite: j'écris ma structure Character xxx dans le fichier, c'est ok, MAIS... ben oui y a un mais sinon c'est pas marrant le linker me dit que la sauvegarde est endommagée.. normale, elle ne fait plus que 1 KB au lieu de 512 ...

Comment je peux compléter "proprement" le fichier ?

J'ai pensé à ajouter des "&hFF" au cul pour compléter, avec un fill de taille 512000-sizeof(Character) ??? Propre ? pas propre ? meilleure méthode de dispo ?

[Asthroth]

Bonjour, j'avoue ne pas avoir testé sur linker, donc il va falloir que je me penche sur la question effectivement.

Quand au fait de compléter afin d'obtenir la taille afin d'otenir la taille de 512 Ko, je ne vois pas bien comment faire autrement non?

La seule chose qui me chagrine dans l'utilisation de la FAT (et c'est pour cela que je n'ai pas du tout étudié cette méthode) est la suivante:

Quand on lance un .nds pour la première fois sur un linker, un .sav du meme nom que le linker est créé automatiquement, et donc avec la gestion de la SRam, on a pas a s'occuper du nom du fichier.
D'ailleur sur emulateur, un fichier est automatiquement créé avec le bon nom.
Avec la fat, on ne peut pas savoir quel nom donner au fichier et du coup, si on a plusieurs .nds sur le meme linker, comment savoir le nom a donner pour ne pas ecraser les donner d'un autre .nds
parceque dire que l'on regarde par exemple si un default01.sav existe deja on passe au default 02 et ainsi de suite jusqu'a trouver un nom libre, mais apres, le .nds, comment sait-il le nom de sa propre sauvegarde.
Bref, ca devient vite compliqué.

Je pense que la meilleure solution est de se servir de la SRam. Je vais chercher de mon coté comment resoudre ce soucis de la SRam sur un linker et je ferais un retour ici.

[Asthroth]

apres essai sur ma R4, la sauvegarde ne fonctionne pas, je vais voir si l'on peut se passer de ce test du CARD_ID ou voir pourquoi cet ID est vide sur le linker.

Edit:

voici l'explication de ce test: http://forum.gbadev.org/viewtopic.php?t=5924

De ce que jai compris (mon anglais est plutot moyen), c'est pour gérer un cas assez particulier, donc a voir si on peut s'en passer ou alors s'assurer que les données que l'on est en train de lire sont bien les notre par exemple en mettant et tout début de sauvegarde un petit "machin", une sorte d'ID a nous, et si la SRam n'est pas vide et ne commence pas par ce machin, mettre un message disant qu'il faut redemarrer sa console.

je ferais un essai et ferait un retour ici.

Modifié 8 novembre 2013 par Asthroth