Discussion :

[Torshid]

Bonjour à tous,
J'essaye d'avoir comme rendu une carte 2D isométrique, voilà un premier résultat proche de l'isométrique, mais le problème ne se pose pas là.


J'aimerais savoir comment reconnaître un clique sur une case, quels sont les différents moyens? J'avais penser à faire des milliers de conditions (du style vérifier si la souris est à cette position, etc.) mais c'est du n'importe quoi.

Bon voilà, j'espère que j'ai pu me faire comprendre et qu'il y aura des personnes qui prendront la peine de répondre.

Merci à vous, à plus.

Edit: image mise à jour (et petit problème avec les axes), problème non résolu.

[macumba]

Je ne suis pas un spécialiste, mais je pense que si tu poses ton pb comme un repère orthonorme qui a subit une rotation de 45° ca te faciliterait le raisonnement.
Si tu commences par régler un repère orthonormé classique, tes cellules du bas aurait comme coordonnées 4,1 et 5,1, celle du haut 1,4. Il suffit après d'appliquer la rotation de 45° avec un sin/cos 45° sur tes coordonnées et tes conditions.

[Nollo]

Tu devrais jeter un coup d'oeil sur ça http://www.developpez.net/forums/d88...-isometriques/

[LittleWhite]

Bonjour,

J'ai étudié cette question cette année, est ma réponse est la suivante:

Faire un premier repérage comme si on était en 2D (non isométrique). Cela permet d'avoir une première approximation de la tuile sur laquelle nous sommes.
Maintenant, en fait, notre approximation, peut nous donner 5 tuiles ... (4 coins) celle du centre. Pour faire un répérage des coin, je divise le rectangle du premier repérage, en 4. Je repère quel rectangle contient mon curseur ( if x < width/2) ... et puis , finalement, on coupe le rectangle selectionner en deux ( if x < y ) ... cela nous indique dans quel moitié (coupage en diagonale) le curseur est. Selon le cas, il sera en dehors donc, sur la tuile à coté, donc on appliquera un décalage, sinon ... bah on avait la bonne tuile depuis le début (on ne change rien).

Voilà ... je peux comprendre que cela ne soit pas clair sans schémas ...

[Torshid]

Merci beaucoup pour vos réponses! Je vais les voir de plus prêt, je vous tiens au courant.
Edit: le code n'est pas très clair dans le lien que tu m'a donné Nollo (il y a des variables qui tombent du ciel, je comprends pas), néanmoins je crois que la méthode est la bonne. Je vais aussi tenter de faire la même chose que macumba et LittleWhite.

[Anything]

Si je ne me trompe pas les "formules magiques" du lien de Nollo viennent d'une formule de changement de repère simplifiée grace à certaines propritétés des vecteurs utilisés comme base du repère "carte".

En gros faut résoudre:

1) sx = mx * i.x + my * j.x
2) sy = mx * i.y + my * j.y

i, j sont les vecteurs du repère carte.
sx, sy les coordonnées écrans(s pour screen).
mx, my les coordonées carte (celles qu'on cherche à trouver/m pour map).

J'ai pas trop le temps la, mais j'essayerais de développer demain

[Nollo]

Merci beaucoup pour vos réponses! Je vais les voir de plus prêt, je vous tiens au courant.
Edit: le code n'est pas très clair dans le lien que tu m'a donné Nollo (il y a des variables qui tombent du ciel, je comprends pas), néanmoins je crois que la méthode est la bonne. Je vais aussi tenter de faire la même chose que macumba et LittleWhite.

Qu'est ce que tu ne comprends pas dans le lien ?

[Anything]

Voila la version longue. En fait quand on regarde une carte en vue iso, on voit qu'en fait c'est une bête repère carthésien de base i, j (voir image en pièce jointe). i et j sont en fait des vecteurs suivent les cotés des tiles. Et l'origine de ce répère est le magnifique point jaune sur mon dessin.





Donc a partir des coordonnées de la souris, ils suffit d'appliquer un changement de repère du repère écran vers le repère de la carte pour connaitre le coordonées du tile cliqué.

Donc de resoudre à peu près (*):

1) sx = mx * i.x + my * j.x
2) sy = mx * i.y + my * j.y


On va partir de 1)

sx = mx * i.x + my * j.x
<=> mx * i.x = sx - my * j.x
<=> mx = (sx - my * j.x)/i.x
<=> mx = ((sx/i.x) - (my * j.x/i.x))

On injecte ca dans 2):

sy = ((sx/i.x) - (my * j.x/i.x)) * i.y + my * j.y
<=> sy * i.x /i.x = (sx* i.y/i.x) - (my * j.x* i.y/i.x) + (my * j.y * i.x)/ i.x
<=> sy * i.x = (sx* i.y) - (my * j.x* i.y) + (my * j.y * i.x)
<=> (my * j.y * i.x) - (my * j.x* i.y) = sy * i.x - sx * i.y
<=> my * (j.y * i.x - j.x* i.y) = sy * i.x - sx * i.y
<=> my = (sy * i.x - sx * i.y) / (j.y * i.x - j.x* i.y)

Voila gagné on a récupérer my à partir de donnée connues(les coordonnées écran et nos vecteurs). Donc si j'avais le courage je réinjecterais le résultat de 2) dans 1) pour avoir mx lui aussi seulement en fonction de i, j et des coordonnées de départ. Mais ca devient un peu barbare Mais on est dans un cas très générique.

Je parlais d'une simplification due au caractéristiques des vecteurs dans mon premier message. En fait dans le cas de la vue isométrique on voit que:

i.x = -j.x
i.y = j.y

On reprends le résultats de 2)

2') my = (sy * i.x - sx * i.y) / (i.y * i.x + i.x* i.y)
<=> my = (sy * i.x - sx * i.y) / ( 2 * i.y * i.x)
<=> my = (sy * i.x)/ ( 2 * i.y * i.x) - (sx * i.y) / ( 2 * i.y * i.x)
<=> my = sy / (2 * i.y) - sx / (2 * i.x)

Ca commence a fichetrement à ressembler à:

position.Y = (float)Math.Ceiling((y / tilesand.Height) - (x / tilesand.Width));

Non hein?

En le tilesand.height vient du fait que notre i.y = (tilesand.height/2) et que i.x = (tilesand.Width/2) et voila on retombe sur nos pattes.

Voila pour l'explication longue, je vous laisse vous amuser pour trouver de la même manière mx.

*) en fait il un petit offset de décalage a appliquer sur les coordonées écrans vu que très probablement l'origine de la carte ne sera pas sur l'origine de l'écran.

[Torshid]

Merci beaucoup Anything, les autres aussi! J’espère que le sujet va en aider plus d'un.