Discussion :

[DamiB]

Bonjour à tous et à toutes(il y en a peu, mais ça existe )

Je suis me suis mis récemment au Java et à Android (j'étais sur C# avant), et j'ai pour but de réussir à coder proprement une application affichant une carte (perso) faite de tuiles(256x256).
En C# je faisais ça avec un Panel et des PictureBox (je sais, c'est pas bien), mais cette fois ci j'aimerai bien directement dessiner dans un Canva... (et si j'y arrive, je transpose le tout su la version C#, ça lui fera du bien)

J'ai stocké les tuiles dans le dossier drawable, et leur nom est de la forme suivante :

• x0y0z0, x0z1y0, ..., xNyNzU

Où N est un multiple de 256 (0 = 0, 1 = 256, ..., N = N*256) et U est le niveau de zoom (0, 1, etc...)
Pour ce qui est de la l'algo, j'imagine qui faudrait créer une collection de Bitmap, initialiser la capacité de la collection avec le nombre maximum de tuiles qui peut être affiché à l'écran :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
int nbTuilesX = (int)Math.floor((double)largeurEcran / 256) + 2;
int nbTuilesY = (int)Math.floor((double)hauteurEcran / 256) + 2;
int nbTuilesTotal = nbTuilesX * nbTuilesY ;

Cette collection serait une sorte de SparseArray avec deux clés (abscisse, ordonnée) et pourrait à la volée ajouter et enlever des éléments...
Lors du déplacement de la carte, il faudrait vérifier que la collection contienne les tuiles appropriées et soit les afficher, soit les charger :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
// On prend les coordonnées des coins haut-gauche et bas-droite de l'écran par rapport à l'origine de la carte
int coinHautGaucheX = origineEcranX;
int coinHautGaucheY = origineEcranY;
int coinBasDroiteX = origineEcranX + largeurEcran;
int coinBasDroiteY = origineEcranY + hauteurEcran;
 
/* On calcul les origines(en multiples de 256) de la tuile la plus en haut à gauche
et la tuile la plus en bas à droite qui doivent être affichées */
int originePremiereTuileX = (int)Math.floor((double)coinHautGaucheX / 256);
int originePremiereTuileY = (int)Math.floor((double)coinHautGaucheY / 256);	
int origineDerniereTuileX = (int)Math.floor((double)coinBasDroiteX / 256);
int origineDerniereTuileY = (int)Math.floor((double)coinBasDroiteY / 256);
 
// On trouve les origines de toutes les tuiles à afficher(en multiples de 256)
for(int x = originePremiereTuileX; x <= origineDerniereTuileX; x++) {
	for(int y = originePremiereTuileY; y <= origineDerniereTuileY; y++) {
		// Actions sur la tuile(x,y) dont la position est (x*256, y*256)
		if(/* Test si la tuile(x,y) existe dans la collection */
			// Afficher la tuile(x,y)
		else
			// Charger nouvelle tuile(x,y)
	}	
}

A partir d'ici je suis un peu perdu...
Si vous avez la moindre idée ou le moindre conseil, je suis preneur

J'aimerai vraiment aboutir à un code optimiser pour que la "glisse" soit la plus confortable possible(plus de fps et moins de ms quoi...) ^^

Des idées ?

[Viish]

J'ai regardé vite fait ton code et tes explications et voici ce que je te propose (si j'ai bien compris) :

Tu crées une HashTable qui contiendra tes tuiles, indexées par leur nom en xNyNzU. Comme ça tu te facilites la condition de ton if et tu te facilites sa récupération.
Ensuite pour la charger, ben tu crées ton nouveau Bitmap a partir de ton drawable et tu l'insères dans la HashTable.

En espérant que ça t'aide.

[Viish]

Oh je viens de me rendre compte, j'ai oublié de te dire que tu devrais mettre tes images dans le dossiers Assets plutôt que Drawable, ça te permettra de les loader plus facilement (et surtout à partir du nom du fichier).

[DamiB]

Je m'étais basé sur l'article suivant :Astuces #5 : Stop aux HashMaps! (très bon blog sur Android en passant). Mais bon, String étant un objet...

En tout cas, merci pour l'info, je vais retourner à mes tests

Ps : Merci pour l'astuce des Assets (je vais faire mes petites recherches là dessus aussi)

[Viish]

Ou alors tu peux essayer de développer 2 fonctions, une permettant d'associer a une de tes tuiles xNyNzU un unique entier pour utiliser ensuite un SparseArray, et l'autre pour faire le chemin inverse (si tu en as besoin).

[macRiaz]

Bonjour DamiB,

Bien que peu en mesure de t'aider, ton sujet m'intéresse ...

Pourquoi des tuiles ?
N'est-il pas possible d'avoir une image bitmap qui déborde (largement voire très largement) de l'écran et de n'afficher que la partie centrée sur une position qui nous intéresse ?
Il faut régler bien sûr le pb de la calibration ....