From 2f91a086f8b85f6fc4ad6f5e6b36a540689068fb Mon Sep 17 00:00:00 2001 From: Laggy Date: Fri, 29 Dec 2023 00:24:30 +0800 Subject: [PATCH] rename 'collideswith' to 'collide' --- benchmarks/GEOMETRY_circle_benchmark.py | 20 ++++++------- docs/circle.rst | 16 +++++----- docs/geometry.rst | 4 +-- docs/line.rst | 14 ++++----- examples/circle_collision_game.py | 2 +- geometry.pyi | 4 +-- src_c/circle.c | 2 +- src_c/line.c | 2 +- test/test_circle.py | 34 ++++++++++----------- test/test_line.py | 40 ++++++++++++------------- 10 files changed, 69 insertions(+), 69 deletions(-) diff --git a/benchmarks/GEOMETRY_circle_benchmark.py b/benchmarks/GEOMETRY_circle_benchmark.py index 3c331f1d..4af0ebdf 100644 --- a/benchmarks/GEOMETRY_circle_benchmark.py +++ b/benchmarks/GEOMETRY_circle_benchmark.py @@ -263,16 +263,16 @@ ] collideswith_tests = [ - ("C rect", "c1.collideswith(r1)"), - ("NC rect", "c1.collideswith(r2)"), - ("C circle", "c1.collideswith(c2)"), - ("NC circle", "c1.collideswith(c2)"), - ("C point int", "c1.collideswith(p1)"), - ("NC point int", "c1.collideswith(p2)"), - ("C point float", "c1.collideswith(p3)"), - ("NC point float", "c1.collideswith(p4)"), - ("C line", "c1.collideswith(l1)"), - ("NC line", "c1.collideswith(l2)"), + ("C rect", "c1.collide(r1)"), + ("NC rect", "c1.collide(r2)"), + ("C circle", "c1.collide(c2)"), + ("NC circle", "c1.collide(c2)"), + ("C point int", "c1.collide(p1)"), + ("NC point int", "c1.collide(p2)"), + ("C point float", "c1.collide(p3)"), + ("NC point float", "c1.collide(p4)"), + ("C line", "c1.collide(l1)"), + ("NC line", "c1.collide(l2)"), ] contains_tests = [ diff --git a/docs/circle.rst b/docs/circle.rst index d980971b..8612735f 100644 --- a/docs/circle.rst +++ b/docs/circle.rst @@ -266,17 +266,17 @@ Circle Methods .. ## Circle.collidepolygon ## - .. method:: collideswith + .. method:: collide | :sl:`test if a shape or point and the circle collide` - | :sg:`collideswith(Line) -> bool` - | :sg:`collideswith(Circle) -> bool` - | :sg:`collideswith(Rect) -> bool` - | :sg:`collideswith(Polygon) -> bool` - | :sg:`collideswith((x, y)) -> bool` + | :sg:`collide(Line) -> bool` + | :sg:`collide(Circle) -> bool` + | :sg:`collide(Rect) -> bool` + | :sg:`collide(Polygon) -> bool` + | :sg:`collide((x, y)) -> bool` | :sg:`contains(Vector2) -> bool` - The `collideswith` method tests whether a given shape or point collides (overlaps) + The `collide` method tests whether a given shape or point collides (overlaps) with a `Circle` object. The function takes in a single argument, which can be a `Line`, `Circle`, `Rect`, `Polygon`, tuple or list containing the x and y coordinates of a point, or a `Vector2` object. The function returns a boolean value of `True` @@ -296,7 +296,7 @@ Circle Methods Collisions with a `Polygon` object are evaluated the same way the :meth:`collidepolygon` method does by default, meaning with only_edges set to `False`. - .. ## Circle.collideswith ## + .. ## Circle.collide ## .. method:: contains diff --git a/docs/geometry.rst b/docs/geometry.rst index 528f7bcb..e00f65a2 100644 --- a/docs/geometry.rst +++ b/docs/geometry.rst @@ -56,7 +56,7 @@ performing transformations and checking for collisions with other objects. collidepolygon: Checks if the circle collides with the given polygon. - collideswith: Checks if the circle collides with the given object. + collide: Checks if the circle collides with the given object. contains: Checks if the circle fully contains the given object. @@ -128,7 +128,7 @@ other objects. collidepolygon: Checks if the line collides with the given polygon. - collideswith: Checks if the line collides with the given object. + collide: Checks if the line collides with the given object. as_circle: Returns a circle which fully encloses the line. diff --git a/docs/line.rst b/docs/line.rst index ac0f0270..e4f4113e 100644 --- a/docs/line.rst +++ b/docs/line.rst @@ -344,14 +344,14 @@ Line Methods .. ## Line.collidepolygon ## - .. method:: collideswith + .. method:: collide | :sl:`test if a shape or point and the line collide` - | :sg:`collideswith(Line) -> bool` - | :sg:`collideswith(Circle) -> bool` - | :sg:`collideswith(Rect) -> bool` - | :sg:`collideswith(Polygon) -> bool` - | :sg:`collideswith((x, y)) -> bool` + | :sg:`collide(Line) -> bool` + | :sg:`collide(Circle) -> bool` + | :sg:`collide(Rect) -> bool` + | :sg:`collide(Polygon) -> bool` + | :sg:`collide((x, y)) -> bool` | :sg:`contains(Vector2) -> bool` Returns `True` if any portion of the shape or point overlaps with the Line, @@ -369,7 +369,7 @@ Line Methods Collisions with a `Polygon` object are evaluated the same way the :meth:`collidepolygon` method does by default, meaning with only_edges set to `False`. - .. ## Line.collideswith ## + .. ## Line.collide ## .. method:: as_circle diff --git a/examples/circle_collision_game.py b/examples/circle_collision_game.py index f3a7fe71..68e6cf2d 100644 --- a/examples/circle_collision_game.py +++ b/examples/circle_collision_game.py @@ -104,7 +104,7 @@ def get_new_circle_surf( is_circle = isinstance(shape, Circle) is_rect = isinstance(shape, pygame.Rect) - if feed_active and mouse_circle.collideswith(shape): + if feed_active and mouse_circle.collide(shape): if is_circle: shape.r += 0.2 draw_circle(screen, coll_color, shape.center, shape.r, 3) diff --git a/geometry.pyi b/geometry.pyi index 02eca2d7..fef6d4b7 100644 --- a/geometry.pyi +++ b/geometry.pyi @@ -89,7 +89,7 @@ class Line(Sequence[float]): def update(self, a: Coordinate, b: Coordinate) -> None: ... @overload def update(self, single_arg: LineValue) -> None: ... - def collideswith(self, other: _CanBeCollided) -> bool: ... + def collide(self, other: _CanBeCollided) -> bool: ... @overload def collidepoint(self, x: float, y: float) -> bool: ... @overload @@ -175,7 +175,7 @@ class Circle: def colliderect(self, rect: Rect) -> bool: ... @overload def colliderect(self, x: int, y: int, w: int, h: int) -> bool: ... - def collideswith(self, other: _CanBeCollided) -> bool: ... + def collide(self, other: _CanBeCollided) -> bool: ... def __copy__(self) -> Circle: ... copy = __copy__ diff --git a/src_c/circle.c b/src_c/circle.c index c94a3085..0111cc01 100644 --- a/src_c/circle.c +++ b/src_c/circle.c @@ -504,7 +504,7 @@ static struct PyMethodDef pg_circle_methods[] = { {"collideline", (PyCFunction)pg_circle_collideline, METH_FASTCALL, NULL}, {"collidepoint", (PyCFunction)pg_circle_collidepoint, METH_FASTCALL, NULL}, {"colliderect", (PyCFunction)pg_circle_colliderect, METH_FASTCALL, NULL}, - {"collideswith", (PyCFunction)pg_circle_collideswith, METH_O, NULL}, + {"collide", (PyCFunction)pg_circle_collideswith, METH_O, NULL}, {"collidepolygon", (PyCFunction)pg_circle_collidepolygon, METH_FASTCALL, NULL}, {"as_rect", (PyCFunction)pg_circle_as_rect, METH_NOARGS, NULL}, diff --git a/src_c/line.c b/src_c/line.c index bdc6d0b5..3b169bdd 100644 --- a/src_c/line.c +++ b/src_c/line.c @@ -755,7 +755,7 @@ static struct PyMethodDef pg_line_methods[] = { {"collidepoint", (PyCFunction)pg_line_collidepoint, METH_FASTCALL, NULL}, {"collidecircle", (PyCFunction)pg_line_collidecircle, METH_FASTCALL, NULL}, {"colliderect", (PyCFunction)pg_line_colliderect, METH_FASTCALL, NULL}, - {"collideswith", (PyCFunction)pg_line_collideswith, METH_O, NULL}, + {"collide", (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}, diff --git a/test/test_circle.py b/test/test_circle.py index 4d011430..8c54fa56 100644 --- a/test/test_circle.py +++ b/test/test_circle.py @@ -648,7 +648,7 @@ def test_colliderect(self): # barely colliding single self.assertTrue(c.colliderect(0, 4.9999999999999, 4, 4), msgt) - def test_collideswith_argtype(self): + def test_collide_argtype(self): """tests if the function correctly handles incorrect types as parameters""" invalid_types = (None, [], "1", (1,), Vector3(1, 1, 1), 1) @@ -656,56 +656,56 @@ def test_collideswith_argtype(self): for value in invalid_types: with self.assertRaises(TypeError): - c.collideswith(value) + c.collide(value) - def test_collideswith_argnum(self): + def test_collide_argnum(self): c = Circle(10, 10, 4) args = [tuple(range(x)) for x in range(2, 4)] # no params with self.assertRaises(TypeError): - c.collideswith() + c.collide() # too many params for arg in args: with self.assertRaises(TypeError): - c.collideswith(*arg) + c.collide(*arg) - def test_collideswith(self): - """Ensures the collideswith function correctly registers collisions with circles, lines, rects and points""" + def test_collide(self): + """Ensures the collide function correctly registers collisions with circles, lines, rects and points""" c = Circle(0, 0, 5) # circle c2 = Circle(0, 10, 15) c3 = Circle(100, 100, 1) - self.assertTrue(c.collideswith(c2), E_T + "circles should collide here") - self.assertFalse(c.collideswith(c3), E_F + "circles should not collide here") + self.assertTrue(c.collide(c2), E_T + "circles should collide here") + self.assertFalse(c.collide(c3), E_F + "circles should not collide here") # line l = Line(0, 0, 10, 10) l2 = Line(50, 0, 50, 10) - self.assertTrue(c.collideswith(l), E_T + "line should collide here") - self.assertFalse(c.collideswith(l2), E_F + "line should not collide here") + self.assertTrue(c.collide(l), E_T + "line should collide here") + self.assertFalse(c.collide(l2), E_F + "line should not collide here") # rect r = Rect(0, 0, 10, 10) r2 = Rect(50, 0, 10, 10) - self.assertTrue(c.collideswith(r), E_T + "rect should collide here") - self.assertFalse(c.collideswith(r2), E_F + "rect should not collide here") + self.assertTrue(c.collide(r), E_T + "rect should collide here") + self.assertFalse(c.collide(r2), E_F + "rect should not collide here") # point p = (0, 0) p2 = (50, 0) - self.assertTrue(c.collideswith(p), E_T + "point should collide here") - self.assertFalse(c.collideswith(p2), E_F + "point should not collide here") + self.assertTrue(c.collide(p), E_T + "point should collide here") + self.assertFalse(c.collide(p2), E_F + "point should not collide here") # polygon c4 = Circle(0, 0, 15) po1 = Polygon([(-5, 0), (5, 0), (0, 5)]) po2 = Polygon([(100, 150), (200, 225), (150, 200)]) - self.assertTrue(c.collideswith(po1), E_T + "polygon should collide here") - self.assertFalse(c.collideswith(po2), E_F + "polygon should not collide here") + self.assertTrue(c.collide(po1), E_T + "polygon should collide here") + self.assertFalse(c.collide(po2), E_F + "polygon should not collide here") def test_as_rect_invalid_args(self): c = Circle(0, 0, 10) diff --git a/test/test_line.py b/test/test_line.py index 4a24562f..77ba38d7 100644 --- a/test/test_line.py +++ b/test/test_line.py @@ -505,7 +505,7 @@ def test_attrib_centery(self): with self.assertRaises(AttributeError): del line.centery - def test_collideswith_argtype(self): + def test_collide_argtype(self): """tests if the function correctly handles incorrect types as parameters""" invalid_types = (None, [], "1", (1,), Vector3(1, 1, 1), 1) @@ -513,49 +513,49 @@ def test_collideswith_argtype(self): for value in invalid_types: with self.assertRaises(TypeError): - l.collideswith(value) + l.collide(value) - def test_collideswith_argnum(self): + def test_collide_argnum(self): l = Line(10, 10, 4, 4) args = [tuple(range(x)) for x in range(2, 4)] # no params with self.assertRaises(TypeError): - l.collideswith() + l.collide() # too many params for arg in args: with self.assertRaises(TypeError): - l.collideswith(*arg) + l.collide(*arg) - def test_collideswith(self): - """Ensures the collideswith function correctly registers collisions with circles, lines, rects and points""" + def test_collide(self): + """Ensures the collide function correctly registers collisions with circles, lines, rects and points""" l = Line(10, 10, 200, 200) # line l2 = Line(400, 300, 10, 100) l3 = Line(400, 300, 10, 200) - self.assertTrue(l.collideswith(l2), E_T + "lines should collide here") - self.assertFalse(l.collideswith(l3), E_F + "lines should not collide here") + self.assertTrue(l.collide(l2), E_T + "lines should collide here") + self.assertFalse(l.collide(l3), E_F + "lines should not collide here") # circle c = Circle(10, 10, 10) c2 = Circle(50, 10, 10) - self.assertTrue(l.collideswith(c), E_T + "circle should collide here") - self.assertFalse(l.collideswith(c2), E_F + "circle should not collide here") + self.assertTrue(l.collide(c), E_T + "circle should collide here") + self.assertFalse(l.collide(c2), E_F + "circle should not collide here") # rect r = Rect(10, 10, 10, 10) r2 = Rect(50, 10, 10, 10) - self.assertTrue(l.collideswith(r), E_T + "rect should collide here") - self.assertFalse(l.collideswith(r2), E_F + "rect should not collide here") + self.assertTrue(l.collide(r), E_T + "rect should collide here") + self.assertFalse(l.collide(r2), E_F + "rect should not collide here") # point p = (11, 11) p2 = (60, 80) - self.assertTrue(c.collideswith(p), E_T + "point should collide here") - self.assertFalse(c.collideswith(p2), E_F + "point should not collide here") + self.assertTrue(c.collide(p), E_T + "point should collide here") + self.assertFalse(c.collide(p2), E_F + "point should not collide here") # polygon l4 = Line(0, 0, 10, 10) @@ -565,11 +565,11 @@ def test_collideswith(self): po4 = Polygon((5, 5), (5, 10), (0, 10), (2.5, 2.5)) po5 = Polygon((0, 0), (0, 10), (-5, 10), (-5, 0)) - self.assertTrue(l4.collideswith(po1)) - self.assertFalse(l4.collideswith(po2)) - self.assertTrue(l4.collideswith(po3)) - self.assertTrue(l4.collideswith(po4)) - self.assertTrue(l4.collideswith(po5)) + self.assertTrue(l4.collide(po1)) + self.assertFalse(l4.collide(po2)) + self.assertTrue(l4.collide(po3)) + self.assertTrue(l4.collide(po4)) + self.assertTrue(l4.collide(po5)) def test_meth_copy(self): line = Line(1, 2, 3, 4)