Android - déterminer des emplacements spécifiques (coordonnées X, Y) sur un bitmap sur différentes résolutions?

Question

Mon application que j'essaie de créer est un jeu de société. Il aura un bitmap comme le tableau et les pièces qui vont se déplacer à différents endroits sur le plateau. La conception générale de la planche est carrée, a un certain nombre de colonnes et de lignes et a une bordure pour les regards. Pensez à un échiquier ou à un tableau de scrabble. Avant d'utiliser des bitmaps, j'ai d'abord créé la carte et la carte en la dessinant manuellement - drawLine & drawRect. J'ai décidé combien de pixels en largeur la bordure serait basée sur la largeur de l'écran et la hauteur passée sur "onSizeChanged". L'écran restant I divisé par le nombre de colonnes ou de lignes dont j'avais besoin.

Pour l'amour des exemples, disons que les dimensions de l'écran sont 102 x 102.

j'ai choisi pour la frontière à 1 et définir le nombre de lignes & colonnes à 10. Cela laisserait 100 x 100 gauche (réduit de deux pour représenter la limite inférieure & supérieure, ainsi que la bordure gauche/droite). Ensuite, avec des colonnes et des lignes définies sur 10, cela laisserait 10 pixels à la fois pour la hauteur et la largeur.

Quelle que soit la taille de l'écran, je stocke exactement combien de pixels de largeur est la boarder et la hauteur & de chaque carré sur la carte. Je sais exactement quel emplacement sur l'écran pour déplacer les pièces sur la base d'une formule simple et je sais exactement quelle cellule un utilisateur a touché pour faire un mouvement.

Maintenant, comment cela fonctionne avec les bitmaps? Par exemple, si je crée 3 bitmaps d'arrière-plan différents, une fois pour chaque densité, ils ne seront pas redimensionnés pour s'adapter à la résolution de chaque écran, car d'après ce que j'ai lu, il n'y a pas que 3 résolutions d'écran. plus. Si je ou Android ajuste les bitmaps en fonction de la taille actuelle de l'écran, comment puis-je connaître la largeur de la bordure et les dimensions de chaque case pour savoir où déplacer une pièce ou calculer où se trouve un joueur touché. Jusqu'à présent, les exemples que j'ai examinés montrent simplement comment mettre à l'échelle le bitmap global et obtenir la largeur et la hauteur globales des bitmaps. Mais, je ne vois pas comment dire combien de pixels de large ou de haute chaque partie de la planche serait après qu'elle ait été mise à l'échelle. Lorsque je dessine moi-même chaque ligne et chaque rectangle en fonction des dimensions de l'écran de onSizeChanged, je connais toujours ces dimensions.

Si quelqu'un a un exemple de code ou une URL pour me diriger vers ce que je peux lire à ce sujet avec bitmaps, je l'apprécierais.

BTW, voici un exemple de code (très simplifié) sur la façon dont je connais les dimensions de mon plateau de jeu (bordure et carrés), peu importe la taille de l'écran. Maintenant, j'ai juste besoin de savoir comment faire cela avec le tableau comme une image bitmap qui est mise à l'échelle à n'importe quelle taille d'écran.

@Override 
    protected void onSizeChanged(int w, int h, int oldw, int oldh) { 
     intScreenWidth = w; 
     intScreenHeight = h; 

     // Set Border width - my real code changes this value based on the dimensions of w 
     // and h that are passed in. In other words bigger screens get a slightly larger 
     // border. 
     intOuterBorder = 1; 

     /** Reserve part of the board for the boardgame and part for player controls & score 
      My real code forces this to be square, but this is good enough to get the point 
      across. 
     **/ 
     floatBoardHeight = intScreenHeight/4 * 3; 

     // My real code actually causes floatCellWidth and floatCellHeight to 
     // be equal (Square). 
     floatCellWidth = (intScreenWidth - intOuterBorder * 2)/intNumColumns; 
     floatCellHeight = (floatBoardHeight - intOuterBorder * 2)/intNumRows; 

     super.onSizeChanged(w, h, oldw, oldh); 
    } 

---

Je pense avoir trouvé la réponse. Je ne pourrais peut-être pas trouver la largeur/hauteur exacte et l'emplacement de chaque carré jouable au sein d'une image bitmap, mais en regardant l'exemple de Snake dans le SDK, je vois qu'il ne crée pas 1 bitmap pour l'ensemble du tableau et de l'échelle il est basé sur les dimensions de l'écran - à la place il crée un bitmap pour chaque tuile, puis redimensionne la tuile en fonction de la résolution de l'écran et du nombre de tuiles désirées sur l'écran - comme je le fais manuellement. Avec cette méthode, je devrais être capable de trouver les limites de pixels exactes pour tous les carrés jouables sur le plateau. Je dois juste briser le tableau en plusieurs bitmaps pour chaque carré. Je vais probablement devoir faire une approche similaire pour les bordures, ainsi je peux détecter leur largeur/hauteur aussi bien après la mise à l'échelle.

Maintenant, je vais le tester pour vérifier, mais je m'attends à ce qu'il fonctionne sur la base de ce que j'ai vu dans l'exemple de Snake SDK.

--Mike

---

J'ai testé un moyen de faire ce que je demandais et il semble fonctionner. Voici ce que j'ai fait:

J'ai créé un bitmap 320 x 320 pour une carte. Il était composé d'une bordure et de carrés (comme un échiquier). La bordure faisait 10 pixels de largeur tout autour du plateau. Les carrés étaient de 20 x 20 pixels.

J'ai détecté la largeur et la hauteur de l'écran via onSizeChanged. Sur un 480 x 800 pixels, je mettrais la nouvelle largeur de la carte à 480 x 480 et utiliser le code suivant à l'échelle la chose:

protected void onSizeChanged(int w, int h, int oldw, int oldh) {   
    floatBoardWidth = w; 
    floatBoardHeight = floatBoardWidth; 

    bitmapScaledBoard = Bitmap.createScaledBitmap(bitmapBoard, (int)floatBoardWidth, (int)floatBoardHeight, true);  

     super.onSizeChanged(w, h, oldw, oldh); 
} 

maintenant afin de détecter le nombre de pixels de large à la frontière a été mise à l'échelle et combien de pixels de la largeur & les carrés ont été mis à l'échelle, j'ai d'abord calculé combien l'image sur toute l'échelle a été mise à l'échelle. Je savais que le bitmap était de 320 x 320, depuis que je l'ai créé. J'ai utilisé la formule suivante pour calculer combien l'image a été mise à l'échelle:

floatBoardScale = floatScreenWidth/320; Dans le cas d'un écran de 480, floatBoardScale est égal à: 1.5. Ensuite, pour calculer ce que ma frontière dans l'image complète a été mise à l'échelle, j'ai fait:

floatBorderWidth = 10 * floatBoardScale;

10 était la largeur de la bordure d'origine dans mon bitmap 320 x 320. Dans mon code final, je ne coderai pas les valeurs, j'utiliserai des variables. Quoi qu'il en soit, dans le cas de cette formule, la nouvelle largeur de bordure calculée doit être: 15

Lorsque j'ai multiplié le même facteur d'échelle par les carrés de la carte (20 x 20 dans l'image originale), j'ai obtenu de nouvelles valeurs de 30 x 30. Lorsque j'ai utilisé ces valeurs dans mes formules pour calculer quel carré une personne a touché, cela a fonctionné. Je touchais tous les coins des carrés et au centre et calculais toujours le bon endroit. Ce qui est important, donc peu importe la résolution de l'écran, je sais où l'utilisateur voulait déplacer une pièce et visuellement, il apparaît au bon endroit. J'espère que cela aidera tous ceux qui pourraient avoir eu la même question. En outre, si quelqu'un a une meilleure méthode pour accomplir la même chose, veuillez l'afficher.

Answer 1

Un couple de choses. Tout d'abord, commencez à lire sur la façon de support multiple screens. Portez une attention particulière à l'apprentissage des trempettes et comment ils fonctionnent. Ensuite, regardez this video (au moins les 15-20 premières minutes).

Ce sujet n'est pas un gâteau à saisir. J'ai trouvé préférable de commencer à jouer dans mon code. Je suggère de créer une vue de surface et commencer à déconner avec quelques bitmaps, différents émulateurs (tailles et densités d'écran), et les différents types de dossiers drawable. Malheureusement, il ya beaucoup plus à ce sujet que Google ne veut l'admettre, et bien que ce soit définitivement faisable, il n'est pas simple de commencer à le faire pour certains types d'applications.Enfin, vous devriez envisager de résumer votre question pour être plus simple si vous n'êtes pas à la recherche d'une réponse abstraite (comme celle-ci).

Bonne chance!