Reconociendo un clickbox hexagonal

Estoy trabajando en un juego que involucrará hexágonos de jadeo .

En este momento, tengo una imagen hexagonal que estoy usando (todos los lados tienen la misma longitud ... encaja en una imagen de 50 px por 50 px).

Soy algo nuevo en C # y realmente nuevo en XNA, pero ¿hay algún tipo de método fácil al que pueda llamar en lugar de hacer una declaración enrevesada basada en puntos y ángulos?

Un hexágono es un rectángulo con esquinas recortadas. La forma en que he visto esto, y he escuchado que la serie Civilization lo hace de esta manera con mapas ortogonales, es crear un mapa de bits con un espacio en blanco (ortogonal o hexagonal) y rojo, verde, azul y amarillo. esquina. (O los colores que quieras)

Hexagonal: o

Ortogonal:

Luego, solo determina en qué rectángulo está el cursor y prueba el color del píxel en esa ubicación. Si es blanco, están flotando sobre ese espacio. Cada otro color se asigna a un desplazamiento, y en su lugar se ciernen sobre ese hexágono. Esta manera es eficiente, requiere poca geometría y puede usarse para cualquier espacio de teselado arbitrario.

No hay un método XNA que haga una prueba de golpe hexagonal

Este artículo explica cómo escribir una función que realiza la prueba y le brinda la función:

Cómo verificar si un punto está dentro de un hexágono

Aquí hay un resumen de ese artículo:

Y la función que realiza la prueba es la siguiente:

1. Pruebe el cuadro delimitador alrededor del hexágono, temprano si no se cruza.
2. Transforme el punto en un cuadrante local como se muestra arriba.
3. Realice la siguiente isInsideprueba para el cuadrante 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;
}

Vea el artículo para más detalles.

Aquí hay algunas otras fuentes relacionadas útiles:

• Coordenadas en mapas de mosaicos basados ​​en hexágonos

• ¿Hay un punto dentro de un hexágono regular?

Aquí obtuve un método que puede usarse para detectar clics dentro de cualquier polígono:

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;
    }

Debe dar las esquinas de su hexágono en una matriz vector2 (poli) y la posición en la que se hizo clic (p) para el método.