Issue with target drone code: Can pass through obstacles, and hides inside them.

[RKResident]

There is some issue with target drone code due to which it can pass through obstacles, and hides inside them. Is this intentional or not?

This is the corrected code

`

def _update_target_ai(self):
"""Adversarial AI: Gaussian Random Walk + LoS Breaking + Wall Sliding."""
tx, ty = self.target_pos
px, py = self.player_pos

    # 1. Base Gaussian Random Walk
    self.target_wander_angle += random.gauss(0, 0.15)
    desired_vx = math.cos(self.target_wander_angle) * MAX_TARGET_SPEED
    desired_vy = math.sin(self.target_wander_angle) * MAX_TARGET_SPEED

    # 2. Flee and Seek Cover
    dist_to_player = math.hypot(tx - px, ty - py)
    if dist_to_player < TARGET_VISION:
        best_cover_dist = float('inf')
        cover_x, cover_y = None, None

        for cx, cy, hw, hh in self.obstacles:
            r_eff = max(hw, hh)
            dist_to_obs = math.hypot(tx - cx, ty - cy)

            if dist_to_obs < COVER_SEARCH_RADIUS:
                vec_po_x = cx - px
                vec_po_y = cy - py
                po_mag = math.hypot(vec_po_x, vec_po_y)

                if po_mag > 0:
                    hide_x = cx + (vec_po_x / po_mag) * (r_eff + HIDE_SPOT_OFFSET)
                    hide_y = cy + (vec_po_y / po_mag) * (r_eff + HIDE_SPOT_OFFSET)

                    dist_to_hide = math.hypot(tx - hide_x, ty - hide_y)
                    if dist_to_hide < best_cover_dist:
                        best_cover_dist = dist_to_hide
                        cover_x, cover_y = hide_x, hide_y

        if cover_x is not None:
            seek_x = cover_x - tx
            seek_y = cover_y - ty
            seek_mag = math.hypot(seek_x, seek_y)
            if seek_mag > 0:
                desired_vx += (seek_x / seek_mag) * 3.5
                desired_vy += (seek_y / seek_mag) * 3.5
        else:
            escape_x = tx - px
            escape_y = ty - py
            mag = math.hypot(escape_x, escape_y)
            if mag > 0:
                desired_vx += (escape_x / mag) * 3.0
                desired_vy += (escape_y / mag) * 3.0

    # 3. Wall Avoidance
    if tx < WALL_AVOIDANCE_MARGIN:
        desired_vx += WALL_AVOIDANCE_FORCE
    if tx > WIDTH - WALL_AVOIDANCE_MARGIN:
        desired_vx -= WALL_AVOIDANCE_FORCE
    if ty < WALL_AVOIDANCE_MARGIN:
        desired_vy += WALL_AVOIDANCE_FORCE
    if ty > HEIGHT - WALL_AVOIDANCE_MARGIN:
        desired_vy -= WALL_AVOIDANCE_FORCE

    # 4. Normalise to MAX_TARGET_SPEED
    speed = math.hypot(desired_vx, desired_vy)
    if speed > 0:
        tvx = (desired_vx / speed) * MAX_TARGET_SPEED
        tvy = (desired_vy / speed) * MAX_TARGET_SPEED
    else:
        tvx, tvy = 0.0, 0.0

    # 5. CORRECTED WALL SLIDING
    #
    # Original bugs:
    #   a) `break` after first obstacle — corrected velocity could still
    #      enter a second obstacle unchecked.
    #   b) The tangential axis was forced to MAX_TARGET_SPEED regardless
    #      of its actual value — giving free speed boosts into other walls.
    #   c) next_x/next_y were never updated between iterations, so each
    #      obstacle tested the original pre-correction position.
    #
    # Fix: iterate ALL obstacles without break, recompute next_x/next_y
    # after each correction, and PRESERVE the existing tangential speed
    # instead of overwriting it.

    for cx, cy, hw, hh in self.obstacles:
        # Recompute candidate next position with current (possibly already
        # corrected) velocity — this is the key fix for bug (c).
        next_x = tx + tvx
        next_y = ty + tvy

        bx = hw + 13
        by = hh + 13

        if abs(next_x - cx) >= bx or abs(next_y - cy) >= by:
            continue   # not overlapping this obstacle

        overlap_x = bx - abs(next_x - cx)
        overlap_y = by - abs(next_y - cy)

        if overlap_x < overlap_y:
            # Nearest face is left or right — zero the x component only.
            # PRESERVE tvy rather than forcing it to MAX_TARGET_SPEED (bug b fix).
            tvx = 0.0
            # If tangential speed is also zero, nudge along y to escape.
            if tvy == 0.0:
                tvy = random.choice([-1.0, 1.0]) * MAX_TARGET_SPEED
        else:
            # Nearest face is top or bottom — zero the y component only.
            tvy = 0.0
            if tvx == 0.0:
                tvx = random.choice([-1.0, 1.0]) * MAX_TARGET_SPEED
        # No break — continue checking remaining obstacles with updated tvx/tvy

    # Re-normalise after slide corrections to keep speed consistent
    slide_speed = math.hypot(tvx, tvy)
    if slide_speed > MAX_TARGET_SPEED:
        tvx = (tvx / slide_speed) * MAX_TARGET_SPEED
        tvy = (tvy / slide_speed) * MAX_TARGET_SPEED

    if tvx != 0 or tvy != 0:
        self.target_wander_angle = math.atan2(tvy, tvx)

    # 6. Apply Final Movement
    self.target_vel = [tvx, tvy]
    self.target_pos[0] += tvx
    self.target_pos[1] += tvy

    # 7. Hard boundary clamp
    pad = TARGET_BOUNDARY_PAD
    self.target_pos[0] = max(pad, min(WIDTH  - pad, self.target_pos[0]))
    self.target_pos[1] = max(pad, min(HEIGHT - pad, self.target_pos[1]))`

[Soumya-prog-tech]

It is not intentional but doe to the constraint of avoiding the player, which is more important than avoiding the obstacles. You can work with your corrected version till then, I will fix this soon