@@ -10,6 +10,7 @@ Arcade [PyPi Release History](https://pypi.org/project/arcade/#history) page.
 - Fixed `SpatialHash` queries (`get_sprites_near_sprite`, `get_sprites_near_point`, `get_sprites_near_rect`, and the collision functions that use them) adding an empty bucket for every grid cell they looked at. Memory use grew as sprites moved around large maps. Queries and adding sprites to a spatial hash are also faster, since the hit box points are now scanned once instead of four times.
 - Fixed `are_polygons_intersecting` (and sprite collision checks) always returning `False` when a polygon had a repeated point, such as a closed polygon whose first point is repeated at the end.
 - Rotated hit boxes at right angles (90, 180, 270 degrees, etc.) now have exact point coordinates. Before, values like `sin(radians(180))` being about 1.2e-16 instead of 0 left tiny errors that could make exactly touching sprites count as colliding, or not, differently from unrotated ones.
+- Fixed sprite collision checks missing collisions when a sprite's hit box is bigger than its texture, such as a custom hit box used as a melee reach area. The quick distance check estimated each sprite's size from its texture; it now uses the actual hit box, cached until the scale changes. This also makes the check tighter for most sprites, so brute-force list checks are about 20-40% faster.
 
 ### New Features
 - Added `HitBox.get_adjusted_bounds()`, which returns the cached `(left, right, bottom, top)` bounds of the adjusted hit box points.
 
@@ -17,6 +17,11 @@
 # whether two edges are parallel.
 _AXIS_DECIMALS = 9
 
+# Hit box radii are padded by this relative and absolute amount, so rounding
+# in the adjusted points can never put a point outside the radius.
+_RADIUS_PADDING_RELATIVE = 1e-6
+_RADIUS_PADDING_ABSOLUTE = 1e-6
+
 # Cosine and sine for 0, 90, 180 and 270 degrees clockwise
 _RIGHT_ANGLE_ROTATIONS = ((1.0, 0.0), (0.0, -1.0), (-1.0, 0.0), (0.0, 1.0))
 
@@ -213,6 +218,9 @@ def __init__(
         self._axes: Axes = {}
         self._axes_key: tuple[Any, ...] | None = None
 
+        # Cached by _get_radius() until the scale changes
+        self._radius: float | None = None
+
     @property
     def points(self) -> Point2List:
         """
@@ -300,6 +308,36 @@ def get_adjusted_bounds(self) -> tuple[float, float, float, float]:
             self._adjusted_bounds_points = points
         return self._adjusted_bounds
 
+    def _get_radius(self) -> float:
+        """
+        Get the distance from the position to the farthest adjusted point.
+
+        Rotating or moving the hit box doesn't change this, so it's cached
+        until the scale changes. The result is padded very slightly so
+        rounding can't put an adjusted point outside it.
+        """
+        if type(self).get_adjusted_points not in (
+            HitBox.get_adjusted_points,
+            RotatableHitBox.get_adjusted_points,
+        ):
+            # A subclass may transform the points differently, so measure
+            # the adjusted points. Not cached, since they may change at any time.
+            position_x, position_y = self._position
+            radius = max(
+                (hypot(x - position_x, y - position_y) for x, y in self.get_adjusted_points()),
+                default=0.0,
+            )
+            return radius + radius * _RADIUS_PADDING_RELATIVE + _RADIUS_PADDING_ABSOLUTE
+
+        cached = self._radius
+        if cached is not None:
+            return cached
+        scale_x, scale_y = self._scale
+        radius = max((hypot(x * scale_x, y * scale_y) for x, y in self._points), default=0.0)
+        radius += radius * _RADIUS_PADDING_RELATIVE + _RADIUS_PADDING_ABSOLUTE
+        self._radius = radius
+        return radius
+
     def _get_axes(self) -> Axes:
         """
         Get the separating axes to test this hit box against another.
@@ -374,6 +412,7 @@ def scale(self) -> tuple[float, float]:
     @scale.setter
     def scale(self, scale: tuple[float, float]):
         self._scale = scale
+        self._radius = None
         self._adjusted_cache_dirty = True
 
     def create_rotatable(
 
@@ -92,20 +92,20 @@ def _check_for_collision(sprite1: BasicSprite, sprite2: BasicSprite) -> bool:
     """
 
     # NOTE: for speed because attribute look ups are slow.
-    # Width and height are negative when the sprite is flipped with a negative scale.
     sprite1_position = sprite1._position
-    sprite1_width = abs(sprite1._width)
-    sprite1_height = abs(sprite1._height)
     sprite2_position = sprite2._position
-    sprite2_width = abs(sprite2._width)
-    sprite2_height = abs(sprite2._height)
-
-    radius_sum = (sprite1_width if sprite1_width > sprite1_height else sprite1_height) + (
-        sprite2_width if sprite2_width > sprite2_height else sprite2_height
-    )
-
-    # Multiply by half of the theoretical max diagonal length for an estimation of distance
-    radius_sum *= 0.71  # 1.42 / 2
+    hit_box1 = sprite1._hit_box
+    hit_box2 = sprite2._hit_box
+
+    # Quick check with circles around each hit box. The radius is cached on
+    # the hit box until its scale changes.
+    radius1 = hit_box1._radius
+    if radius1 is None:
+        radius1 = hit_box1._get_radius()
+    radius2 = hit_box2._radius
+    if radius2 is None:
+        radius2 = hit_box2._get_radius()
+    radius_sum = radius1 + radius2
     radius_sum_sq = radius_sum * radius_sum
 
     diff_x = sprite1_position[0] - sprite2_position[0]
@@ -122,8 +122,6 @@ def _check_for_collision(sprite1: BasicSprite, sprite2: BasicSprite) -> bool:
     if distance > radius_sum_sq:
         return False
 
-    hit_box1 = sprite1.hit_box
-    hit_box2 = sprite2.hit_box
     points1 = hit_box1.get_adjusted_points()
     points2 = hit_box2.get_adjusted_points()
     if not points1 or not points2:
 
@@ -1,3 +1,6 @@
+import math
+import random
+
 import pytest
 from arcade import hitbox
 
@@ -174,3 +177,69 @@ def get_adjusted_points(self):
     # The skew turns the box's vertical edges into diagonals
     axes = SkewedHitBox(points)._get_axes()
     assert _axis_directions(axes) == {(0.707107, -0.707107)}
+
+
+def test_radius():
+    """The radius is the distance from the position to the farthest point"""
+    hb = hitbox.HitBox(points)  # (0, 0) to (10, 10), so (10, 10) is farthest
+    assert hb._get_radius() == pytest.approx(200**0.5, rel=1e-5)
+    # Never smaller than the true distance, so rounding can't cause misses
+    assert hb._get_radius() >= 200**0.5
+
+    # Cached, and not changed by moving
+    radius = hb._get_radius()
+    assert hb._radius == radius
+    hb.position = (100.0, -50.0)
+    assert hb._get_radius() == radius
+
+    # Recalculated when the scale changes, including negative scales
+    hb.scale = (2.0, -0.5)
+    assert hb._radius is None
+    assert hb._get_radius() == pytest.approx((20**2 + 5**2) ** 0.5, rel=1e-5)
+
+
+def test_radius_rotatable():
+    """Rotation doesn't change the radius"""
+    rot = hitbox.HitBox(octagon).create_rotatable()
+    radius = rot._get_radius()
+    assert radius == pytest.approx(20**0.5, rel=1e-5)
+    for angle in (30.0, 45.0, 90.0, 217.0):
+        rot.angle = angle
+        assert rot._get_radius() == radius
+        farthest = max(
+            ((x - rot.position[0]) ** 2 + (y - rot.position[1]) ** 2) ** 0.5
+            for x, y in rot.get_adjusted_points()
+        )
+        assert farthest <= radius
+
+
+def test_radius_empty():
+    assert hitbox.HitBox([])._get_radius() == pytest.approx(0.0, abs=1e-5)
+
+
+def test_radius_subclass_override():
+    """The radius comes from get_adjusted_points() if a subclass overrides it."""
+
+    class StretchedHitBox(hitbox.HitBox):
+        def get_adjusted_points(self):
+            px, py = self.position
+            return [(x * 3 + px, y + py) for x, y in self.points]
+
+    hb = StretchedHitBox(points, position=(5.0, 5.0))
+    assert hb._get_radius() == pytest.approx((30**2 + 10**2) ** 0.5, rel=1e-5)
+
+
+def test_radius_covers_rounding():
+    """Rounding in the adjusted points must never put a point outside the radius"""
+    rng = random.Random(0)
+    for _ in range(2000):
+        pts = [(rng.uniform(-60, 60), rng.uniform(-60, 60)) for _ in range(rng.randint(3, 8))]
+        rot = hitbox.HitBox(pts).create_rotatable(angle=rng.uniform(0, 360))
+        rot.scale = (rng.uniform(-3, 3), rng.uniform(-3, 3))
+        far = rng.choice([1.0, 1e3, 1e5, 1e7])
+        rot.position = (rng.uniform(-far, far), rng.uniform(-far, far))
+
+        radius = rot._get_radius()
+        px, py = rot.position
+        for x, y in rot.get_adjusted_points():
+            assert math.hypot(x - px, y - py) <= radius
@@ -199,6 +199,35 @@ def test_check_for_collision_negative_scale(window, scale_a, scale_b):
     assert arcade.check_for_collision(a, b) is False
 
 
+def test_check_for_collision_hit_box_bigger_than_texture(window):
+    """A custom hit box bigger than the texture must still collide."""
+    a = arcade.SpriteSolidColor(32, 32, color=arcade.csscolor.RED)
+    # Like a melee reach area around the sprite
+    a.hit_box = arcade.hitbox.HitBox([(-50, -50), (50, -50), (50, 50), (-50, 50)])
+    # Overlaps the hit box, but is too far away to touch the texture
+    b = arcade.SpriteSolidColor(32, 32, center_x=60, color=arcade.csscolor.RED)
+    assert arcade.check_for_collision(a, b) is True
+    assert arcade.check_for_collision(b, a) is True
+
+    sprite_list = arcade.SpriteList()
+    sprite_list.append(b)
+    assert arcade.check_for_collision_with_list(a, sprite_list, method=3) == [b]
+    sprite_list.enable_spatial_hashing()
+    assert arcade.check_for_collision_with_list(a, sprite_list, method=1) == [b]
+
+    # Still found when rotated, scaled, or flipped
+    a.angle = 45
+    b.position = 70, 0
+    assert arcade.check_for_collision(a, b) is True
+    a.scale = (-1.5, 1.5)
+    b.position = 90, 0
+    assert arcade.check_for_collision(a, b) is True
+
+    # And not when it really is out of reach
+    b.position = 200, 0
+    assert arcade.check_for_collision(a, b) is False
+
+
 def test_check_for_collision_with_list(window):
     # TODO: Check that the right collision function is called internally
     a = arcade.SpriteSolidColor(50, 50, color=arcade.csscolor.RED)
@@ -385,7 +414,11 @@ def test_check_for_collision_matches_reference():
 
     def random_sprite(shared_angle):
         sprite = arcade.Sprite(rng.choice(textures))
-        sprite.scale = (rng.choice([-1, 1]) * rng.choice([0.25, 0.5, 1, 1.5]),
+        # Sometimes use a custom hit box bigger than the texture
+        if rng.random() < 0.2:
+            points = [(x * 2.5, y * 2.5) for x, y in sprite.texture.hit_box_points]
+            sprite.hit_box = arcade.hitbox.HitBox(points)
+        sprite.scale =(rng.choice([-1, 1]) * rng.choice([0.25, 0.5, 1, 1.5]),
                         rng.choice([-1, 1]) * rng.choice([0.25, 0.5, 1, 1.5]))  # fmt: skip
         # Often share an angle, so both hit boxes have parallel edges
         if rng.random() < 0.5: