base

Author: itzpr3d4t0r

geometry.pyi

@@ -109,6 +109,7 @@ class Line(Sequence[float]):
     def collidecircle(self, circle: CircleValue) -> bool: ...
     @overload
     def collidecircle(self, x: float, y: float, r: float) -> bool: ...
+    def collidepolygon(self, polygon: Polygon) -> bool: ...
     def as_rect(self) -> Rect: ...
     @overload
     def move(self, x: float, y: float) -> Line: ...
@@ -214,6 +215,7 @@ class Polygon:
     def collidepoint(self, x: float, y: float) -> bool: ...
     @overload
     def collidepoint(self, point: Coordinate) -> bool: ...
+    def collideline(self, line: LineValue) -> bool: ...
     def get_bounding_box(self) -> Rect: ...
     def is_convex() -> bool: ...
     def insert_vertex(self, index: int, vertex: Coordinate) -> None: ...

src_c/collisions.c

@@ -319,6 +319,70 @@ pgCollision_PolygonPoint(pgPolygonBase *poly, double x, double y)
     return collision;
 }
 
+static inline int
+pgCollision_PolygonPoints(pgPolygonBase *poly, double x1, double y1, double x2,
+                          double y2)
+{
+    int collision1 = 0, collision2 = 0;
+    Py_ssize_t i, j;
+
+    double *vertices = poly->vertices;
+
+    for (i = 0, j = poly->verts_num - 1; i < poly->verts_num; j = i++) {
+        double xi = vertices[i * 2];
+        double yi = vertices[i * 2 + 1];
+        double xj = vertices[j * 2];
+        double yj = vertices[j * 2 + 1];
+
+        double xj_xi = xj - xi;
+        double yj_yi = yj - yi;
+
+        if (((yi > y1) != (yj > y1)) &&
+            (x1 < xj_xi * (y1 - yi) / yj_yi + xi)) {
+            collision1 = !collision1;
+        }
+
+        if (((yi > y2) != (yj > y2)) &&
+            (x2 < xj_xi * (y2 - yi) / yj_yi + xi)) {
+            collision2 = !collision2;
+        }
+    }
+
+    return collision1 || collision2;
+}
+
+static inline int
+_pgCollision_line_edges(pgLineBase *line, pgPolygonBase *poly)
+{
+    Py_ssize_t i, j;
+    double *vertices = poly->vertices;
+
+    for (i = 0, j = poly->verts_num - 1; i < poly->verts_num; j = i++) {
+        if (pgCollision_LineLine(line, &(pgLineBase){vertices[j * 2],
+                                                     vertices[j * 2 + 1],
+                                                     vertices[i * 2],
+                                                     vertices[i * 2 + 1]})) {
+            return 1;
+        }
+    }
+
+    return 0;
+}
+
+static inline int
+pgCollision_PolygonLine(pgPolygonBase *poly, pgLineBase *line, int only_edges)
+{
+    int collision = 0;
+    collision = _pgCollision_line_edges(line, poly);
+
+    if (collision || only_edges) {
+        return collision;
+    }
+
+    return pgCollision_PolygonPoints(poly, line->x1, line->y1, line->x2,
+                                     line->y2);
+}
+
 static int
 pgRaycast_LineLine(pgLineBase *A, pgLineBase *B, double max_t, double *T)
 {

src_c/include/collisions.h

@@ -43,4 +43,7 @@ pgRaycast_LineCircle(pgLineBase *, pgCircleBase *, double, double *);
 static int
 pgCollision_PolygonPoint(pgPolygonBase *, double, double);
 
+static int
+pgCollision_PolygonLine(pgPolygonBase *, pgLineBase *, int);
+
 #endif /* ~_PG_COLLISIONS_H */

src_c/line.c

@@ -490,6 +490,33 @@ pg_line_flip_ip(pgLineObject *self, PyObject *_null)
     Py_RETURN_NONE;
 }
 
+static PyObject *
+pg_line_collidepolygon(pgLineObject *self, PyObject *const *args,
+                       Py_ssize_t nargs)
+{
+    pgPolygonBase poly;
+    int was_sequence, result = 0, only_edges = 0;
+
+    if (PyBool_Check(args[nargs - 1])) {
+        if (args[nargs - 1] == Py_True) {
+            only_edges = 1;
+        }
+        nargs--;
+    }
+
+    if (!pgPolygon_FromObjectFastcall(args, nargs, &poly, &was_sequence)) {
+        return RAISE(
+            PyExc_TypeError,
+            "collidepolygon requires a Polygon or PolygonLike object");
+    }
+
+    result = pgCollision_PolygonLine(&poly, &self->line, only_edges);
+
+    PG_FREEPOLY_COND(&poly, was_sequence);
+
+    return PyBool_FromLong(result);
+}
+
 static struct PyMethodDef pg_line_methods[] = {
     {"__copy__", (PyCFunction)pg_line_copy, METH_NOARGS, NULL},
     {"copy", (PyCFunction)pg_line_copy, METH_NOARGS, NULL},
@@ -501,6 +528,7 @@ static struct PyMethodDef pg_line_methods[] = {
     {"collidecircle", (PyCFunction)pg_line_collidecircle, METH_FASTCALL, NULL},
     {"colliderect", (PyCFunction)pg_line_colliderect, METH_FASTCALL, NULL},
     {"collideswith", (PyCFunction)pg_line_collideswith, METH_O, NULL},
+    {"collidepolygon", (PyCFunction)pg_line_collidepolygon, METH_FASTCALL, NULL},
     {"as_rect", (PyCFunction)pg_line_as_rect, METH_NOARGS, NULL},
     {"update", (PyCFunction)pg_line_update, METH_FASTCALL, NULL},
     {"move", (PyCFunction)pg_line_move, METH_FASTCALL, NULL},

src_c/polygon.c

@@ -1134,13 +1134,36 @@ pg_polygon_is_convex(pgPolygonObject *self, PyObject *_null)
     return PyBool_FromLong(_pg_polygon_is_convex_helper(&self->polygon));
 }
 
+static PyObject *
+pg_polygon_collideline(pgPolygonObject *self, PyObject *const *args,
+                       Py_ssize_t nargs)
+{
+    pgLineBase line;
+    int only_edges = 0;
+
+    if (PyBool_Check(args[nargs - 1])) {
+        if (args[nargs - 1] == Py_True) {
+            only_edges = 1;
+        }
+        nargs--;
+    }
+
+    if (!pgLine_FromObjectFastcall(args, nargs, &line)) {
+        return RAISE(PyExc_TypeError, "Invalid line parameter");
+    }
+
+    return PyBool_FromLong(
+        pgCollision_PolygonLine(&self->polygon, &line, only_edges));
+}
+
 static struct PyMethodDef pg_polygon_methods[] = {
     {"move", (PyCFunction)pg_polygon_move, METH_FASTCALL, NULL},
     {"move_ip", (PyCFunction)pg_polygon_move_ip, METH_FASTCALL, NULL},
     {"rotate", (PyCFunction)pg_polygon_rotate, METH_O, NULL},
     {"rotate_ip", (PyCFunction)pg_polygon_rotate_ip, METH_O, NULL},
     {"collidepoint", (PyCFunction)pg_polygon_collidepoint, METH_FASTCALL,
      NULL},
+    {"collideline", (PyCFunction)pg_polygon_collideline, METH_FASTCALL, NULL},
     {"get_bounding_box", (PyCFunction)pg_polygon_get_bounding_box, METH_NOARGS,
      NULL},
     {"is_convex", (PyCFunction)pg_polygon_is_convex, METH_NOARGS, NULL},