Source.Python forums

trace_filter = TraceFilterSimple((player, ))
game_trace = GameTrace()

for i in range(1000):
    engine_trace.trace_ray(
                        Ray(start_pos, start_pos + direction * 8192.0),
                        ContentMasks.SHOT,
                        trace_filter,
                        game_trace
                    )

# ../get_players_in_sphere/get_players_in_sphere.py

# Source.Python
from engines.trace import (ContentMasks, engine_trace, GameTrace, Ray, 
    TraceFilterSimple)
from filters.players import PlayerIter
from mathlib import Vector


HEIGHT_OFFSET = Vector(0, 0, 32)


def get_players_in_sphere(position, radius, wall_check=True):
    _players = []

    # Go through all the Players.
    for player in PlayerIter():
        # Get the Player center.
        player_center = player.origin + HEIGHT_OFFSET
        # Calculate the distance between the center of the sphere and the 
        # center of the Player.
        distance = position.get_distance(player_center)
        
        # Is the Player within the radius?
        if distance <= radius:
            # Should we check for walls?
            if wall_check:
                # Create and fire a new trace ray from the center of the sphere
                # to the center of the Player.
                trace = GameTrace()
                engine_trace.trace_ray(
                    Ray(position, player_center), 
                    ContentMasks.ALL, 
                    TraceFilterSimple(), 
                    trace
                    )

                # Did we hit a wall?
                if trace.did_hit_world():
                    # Skip this Player.
                    continue

                debug_line(position, trace.end_position)

            _players.append(player)

    return _players


# Debug
import effects
from commands import CommandReturn
from commands.client import ClientCommand
from engines.precache import Model
from filters.recipients import RecipientFilter
from players.dictionary import PlayerDictionary


beam_model = Model('sprites/laserbeam.vmt')
player_instances = PlayerDictionary()


def debug_line(start, end, color=(255, 255, 255)):
    effects.beam(RecipientFilter(),
        start=start, 
        end=end, 
        parent=False, 
        life_time=5, 
        red=color[0], 
        green=color[1], 
        blue=color[2], 
        alpha=175, 
        speed=1, 
        model_index=beam_model.index, 
        start_width=0.4, 
        end_width=0.4)


# Usage: get_players_in_sphere <radius>
@ClientCommand('get_players_in_sphere')
def radius_command(command, index):
    player = player_instances[index]
    try:
        radius = float(command[1])
    except IndexError:
        return CommandReturn.BLOCK

    players = get_players_in_sphere(player.view_coordinates, radius, True)

    if players:
        for player in players:
            print(player.name)

    return CommandReturn.BLOCK

shoot_eye_angle - QAngle(80.0, 65.0, 0.0)
shoot_pos  - Vector(?, ?, ?)

Init loop:
for i in range(100) {
    shoot_eye_angle.x += 0.04

    forward = Vector()
    direction = shoot_eye_angle.get_angle_vectors(forward, None, None)
    
    engine_trace.trace_ray(
                        Ray(shoot_pos, shoot_pos + direction * 8192.0),
                        ContentMasks.SHOT,
                        trace_filter,
                        game_trace
                    )

    if 0 < game_trace.entity_index < 65 {
        accuracy_percent = 100 - i
        break
    }
}