changed the Line.raycast

Author: Emc2356

geometry.pyi

@@ -98,7 +98,7 @@ class Line(Sequence[float]):
     def collidecircle(self, circle: CircleValue) -> bool: ...
     @overload
     def collidecircle(self, x: float, y: float, r: float) -> bool: ...
-    def raycast(self, second: Sequence[LineValue]) -> Optional[Tuple[float, float]]: ...
+    def raycast(self, sequence: Sequence[LineValue]) -> Optional[Tuple[float, float]]: ...
 
 class Circle:
     x: float
@@ -116,9 +116,3 @@ class Circle:
     def __init__(self, single_arg: CircleValue) -> None: ...
     def __copy__(self) -> "Circle": ...
     copy = __copy__
-
-
-def raycast(
-        first: Sequence[LineValue],
-        second: Sequence[LineValue]
-) -> List[Optional[Tuple[float, float]]]: ...

setup.py

@@ -29,4 +29,3 @@ def build() -> None:
         sys.exit(subprocess.call(cmd))
 
     build()
-

src_c/collisions.c

@@ -62,10 +62,8 @@ pgIntersection_LineLine(pgLineBase *A, pgLineBase *B, double *X, double *Y)
     double u = -(u1 / den);
 
     if (t >= 0 && t <= 1 && u >= 0 && u <= 1) {
-        if (X)
-            *X = x1 + t * (x2 - x1);
-        if (Y)
-            *Y = y1 + t * (y2 - y1);
+        *X = x1 + t * (x2 - x1);
+        *Y = y1 + t * (y2 - y1);
         return 1;
     }
     return 0;

src_c/geometry.c

@@ -1,13 +1,10 @@
 #include "line.c"
 #include "circle.c"
 #include "collisions.c"
-#include "methods.c"
 
 #define PYGAMEAPI_GEOMETRY_NUMSLOTS 17
 
-static PyMethodDef _pg_module_methods[] = {
-    {"raycast", (PyCFunction)pg_geometry_raycast, METH_FASTCALL, NULL},
-    {NULL, NULL, 0, NULL}};
+static PyMethodDef _pg_module_methods[] = {{NULL, NULL, 0, NULL}};
 
 MODINIT_DEFINE(geometry)
 {
@@ -97,3 +94,10 @@ MODINIT_DEFINE(geometry)
     }
     return module;
 }
+
+
+
+
+
+
+

src_c/line.c

@@ -1,7 +1,6 @@
 #include "include/pygame.h"
 #include "include/geometry.h"
 #include "include/collisions.h"
-#include "include/methods.h"
 
 #include <limits.h>
 #include <math.h>
@@ -210,29 +209,55 @@ pg_line_copy(pgLineObject *self, PyObject *_null)
 }
 
 static PyObject *
-pg_line_raycast(pgLineObject *self, PyObject *sequence)
+pg_line_raycast(pgLineObject *self, PyObject* const* args, Py_ssize_t nargs)
 {
-    PyObject *list = PyList_New(1);
+    PyObject **farr;
+    Py_ssize_t loop;
 
-    if (list == NULL) {
-        return NULL;
+    if (nargs != 1) {
+        return RAISE(PyExc_TypeError, "raycast() takes exactly 1 argument");
+    }
+    if (!PySequence_FAST_CHECK(args[0])) {
+        return RAISE(PyExc_TypeError,
+                     "raycast() first argument must be a sequence");
+    }
+
+    Py_ssize_t length = PySequence_Fast_GET_SIZE(args[0]);
+
+    if (length == 0) {
+        Py_RETURN_NONE;
     }
 
-    PyList_SET_ITEM(list, 0, (PyObject *)self);
+    farr = PySequence_Fast_ITEMS(args[0]);
+
+    pgLineBase other_line;
 
-    PyObject *args[2] = {
-        list,
-        sequence,
-    };
-    PyObject *delete_list =
-        pg_geometry_raycast(NULL, (PyObject *const *)args, 2);
-    PyObject *ret = PyList_GET_ITEM(delete_list, 0);
-    Py_INCREF(ret);
+    double record = DBL_MAX;
+    double closest_x = 0, closest_y = 0;
+    double x = 0, y = 0;
 
-    Py_DECREF(delete_list);
-    Py_DECREF(list);
+    for (loop = 0; loop < length; loop++) {
+        if (!pgLine_FromObject(farr[loop], &other_line)) {
+            return RAISE(
+                PyExc_TypeError,
+                "raycast() first argument must be a sequence of Line or "
+                "LineLike objects");
+        }
+
+        if (pgIntersection_LineLine(&(self->line), &other_line, &x, &y)) {
+            double xxyy = sqrt(x * x + y * y);
+            if (xxyy < record) {
+                record = xxyy;
+                closest_x = x;
+                closest_y = y;
+            }
+        }
+    }
 
-    return ret;
+    if (record == DBL_MAX) {
+        Py_RETURN_NONE;
+    }
+    return Py_BuildValue("(dd)", closest_x, closest_y);
 }
 
 static PyObject *
@@ -307,7 +332,7 @@ pg_line_update(pgLineObject *self, PyObject *const *args, Py_ssize_t nargs)
 static struct PyMethodDef pg_line_methods[] = {
     {"__copy__", (PyCFunction)pg_line_copy, METH_NOARGS, NULL},
     {"copy", (PyCFunction)pg_line_copy, METH_NOARGS, NULL},
-    {"raycast", (PyCFunction)pg_line_raycast, METH_O, NULL},
+    {"raycast", (PyCFunction)pg_line_raycast, METH_FASTCALL, NULL},
     {"collideline", (PyCFunction)pg_line_collideline, METH_FASTCALL, NULL},
     {"collidepoint", (PyCFunction)pg_line_collidepoint, METH_FASTCALL, NULL},
     {"collidecircle", (PyCFunction)pg_line_collidecircle, METH_FASTCALL, NULL},

src_c/methods.c

@@ -1,37 +1,43 @@
-from shapes import raycast
-from shapes.line import LineSegment
+import geometry
 
 import pygame
-import math
 import random
+import math
 
 screen = pygame.display.set_mode((800, 800))
 collisions = []
 
+
 def generate_random_lines(amt):
     def random_pos():
-        return (random.randrange(0, 800), random.randrange(0, 800))
+        return random.randrange(0, 800), random.randrange(0, 800)
 
     for x in range(amt):
-        line = LineSegment(random_pos(), random_pos())
+        line = geometry.Line(random_pos(), random_pos())
         collisions.append(line)
 
-generate_random_lines(55)
 
-while True:
-    for e in pygame.event.get():
-        if e.type == pygame.QUIT:
-            pygame.quit()
-    
+generate_random_lines(10)
+
+running = True
+
+while running:
     screen.fill((0, 0, 0))
 
     for x in range(90):
         origin_pos = pygame.mouse.get_pos()
         ray_endpoint = pygame.Vector2(math.sin(math.degrees(x)), math.cos(math.degrees(x))) * 125 + origin_pos
-        endpoint = raycast.raycast(origin_pos, ray_endpoint, collisions)
-        pygame.draw.line(screen, (255, 0, 0), origin_pos, endpoint, 1)
+        ray = geometry.Line(origin_pos, ray_endpoint)
+
+        point = ray.raycast(collisions) or ray_endpoint
+        pygame.draw.line(screen, (255, 0, 0), origin_pos, point, 1)
 
-    for c in collisions:
-        pygame.draw.line(screen, (0, 0, 255), c.point1, c.point2, 5)
+    for line in collisions:
+        pygame.draw.line(screen, (0, 0, 255), line.a, line.b, 5)
 
     pygame.display.flip()
+
+    for e in pygame.event.get():
+        if e.type == pygame.QUIT:
+            pygame.quit()
+            running = False