Reconnaître une boîte de clic hexagonale

Je travaille sur un jeu qui va impliquer des hexagones haletants .

À l'heure actuelle, j'ai une image hexagonale que j'utilise (tous les côtés sont de la même longueur ... elle s'inscrit dans une image de 50 pixels par 50 pixels).

Je suis un peu nouveau pour C # et vraiment nouveau pour XNA, mais y a-t-il une sorte de méthode facile que je peux appeler plutôt que de faire une instruction alambiquée si basée sur des points et des angles?

Un hexagone est un rectangle avec des coins coupés. La façon dont j'ai vu cela, et j'ai entendu dire que la série Civilization le faisait avec des cartes orthogonales, c'est de créer une bitmap avec un espace blanc (orthogonal ou hexagonal), et un rouge, vert, bleu et jaune coin. (Ou quelles que soient les couleurs que vous aimez.)

Hexagonal: ou

Orthogonal:

Ensuite, déterminez simplement le rectangle sur lequel se trouve le curseur et testez la couleur du pixel à cet endroit. S'il est blanc, ils survolent cet espace. Chaque autre couleur est mappée à un décalage et survole cet hexagone à la place. Cette méthode est efficace, prend peu de géométrie et peut être utilisée pour tout espace de pavage arbitraire.

Il n'y a pas de méthode XNA qui effectue un test de hit hexagonal.

Cet article explique comment écrire une fonction qui effectue le test et vous donne la fonction:

Comment vérifier si un point est à l'intérieur d'un hexagone

Voici un résumé de cet article:

Et la fonction qui fait le test se présente comme suit:

1. Testez la boîte englobante autour de l'hexagone, tôt si elle ne l'intersecte pas.
2. Transformez le point en un quadrant local comme indiqué ci-dessus.
3. Effectuez le isInsidetest suivant pour le quadrant local.

public function isInside(pos:Vec2Const):Boolean
{
    const q2x:Number = Math.abs(pos.x - _center.x);       
    const q2y:Number = Math.abs(pos.y - _center.y);
    if (q2x > _hori || q2y > _vert*2) 
        return false;
    return 2 * _vert * _hori - _vert * q2x - _hori * q2y >= 0;
}

Voir l'article pour plus de détails.

Voici quelques autres sources utiles utiles:

• Coordonnées dans les cartes de tuiles basées sur l'hexagone

• Un point à l'intérieur d'un hexagone régulier?

Ici, j'ai une méthode qui peut être utilisée pour détecter les clics à l'intérieur de n'importe quel polygone:

public bool PointInPolygon( Vector2 p, Vector2[] poly )
    {
        Vector2 p1, p2;
        bool inside = false;

        if( poly.Length < 3 )
        {
            return inside;
        }

        Vector2 oldPoint = new Vector2( poly[poly.Length - 1].X, poly[poly.Length - 1].Y );

        for( int i = 0; i < poly.Length; i++ )
        {
            Vector2 newPoint = new Vector2( poly[i].X, poly[i].Y );

            if( newPoint.X > oldPoint.X )
            {
                p1 = oldPoint;
                p2 = newPoint;
            }
            else
            {
                p1 = newPoint;
                p2 = oldPoint;
            }

            if( ( newPoint.X < p.X ) == ( p.X <= oldPoint.X )
                && ( (long)p.Y - (long)p1.Y ) * (long)( p2.X - p1.X )
                 < ( (long)p2.Y - (long)p1.Y ) * (long)( p.X - p1.X ) )
            {
                inside = !inside;
            }

            oldPoint = newPoint;
        }

        return inside;
    }

Vous devez donner les coins de votre hexagone dans un tableau vector2 (poly) et la position cliquée (p) à la méthode.