public class AimAssist {
    private float baseAssistStrength = 0.7f;
    private float maxAngleAdjustment = 15.0f;
    private float aimSmoothing = 0.2f;
    private float targetLockThreshold = 0.8f;
    private float lockDuration = 1.5f;
    private float detectionRange = 100.0f;
    private float fovAngle = 60.0f;
    
    private boolean isTargetLocked = false;
    private float currentLockTimer = 0.0f;
    private float currentAssistStrength = baseAssistStrength;
    
    public void update(float deltaTime, float targetAngle, float currentAngle) {
        if (isTargetLocked) {
            currentLockTimer += deltaTime;
            if (currentLockTimer >= lockDuration) {
                isTargetLocked = false;
                currentLockTimer = 0.0f;
            }
        }
        
        float angleDifference = calculateAngleDifference(targetAngle, currentAngle);
        if (angleDifference <= fovAngle && angleDifference <= detectionRange) {
            adjustAim(targetAngle, currentAngle, angleDifference);
        } else {
            isTargetLocked = false;
        }
    }
    
    private float calculateAngleDifference(float target, float current) {
        return Math.abs(target - current);
    }
    
    private void adjustAim(float targetAngle, float currentAngle, float angleDiff) {
        if (angleDiff < targetLockThreshold) {
            isTargetLocked = true;
            currentLockTimer = 0.0f;
        }
        
        float adjustment = Math.min(maxAngleAdjustment, angleDiff * currentAssistStrength);
        float newAngle = currentAngle + (targetAngle > currentAngle ? adjustment : -adjustment);
        newAngle = smoothAim(currentAngle, newAngle);
        
        applyAimAdjustment(newAngle);
    }
    
    private float smoothAim(float current, float target) {
        return current + (target - current) * aimSmoothing;
    }
    
    private void applyAimAdjustment(float newAngle) {
        
    }
    
    public void setAssistStrength(float strength) {
        currentAssistStrength = Math.max(0.1f, Math.min(1.0f, strength));
    }
    
    public void setMaxAngleAdjustment(float angle) {
        maxAngleAdjustment = angle;
    }
    
    public boolean isTargetLocked() {
        return isTargetLocked;
    }
}

public class AimAssist {
    private float baseAssistStrength = 0.7f;
    private float maxAngleAdjustment = 15.0f;
    private float aimSmoothing = 0.2f;
    private float targetLockThreshold = 0.8f;
    private float lockDuration = 1.5f;
    private float detectionRange = 100.0f;
    private float fovAngle = 60.0f;
    
    private boolean isTargetLocked = false;
    private float currentLockTimer = 0.0f;
    private float currentAssistStrength = baseAssistStrength;
    
    public void update(float deltaTime, float targetAngle, float currentAngle) {
        if (isTargetLocked) {
            currentLockTimer += deltaTime;
            if (currentLockTimer >= lockDuration) {
                isTargetLocked = false;
                currentLockTimer = 0.0f;
            }
        }
        
        float angleDifference = calculateAngleDifference(targetAngle, currentAngle);
        if (angleDifference <= fovAngle && angleDifference <= detectionRange) {
            adjustAim(targetAngle, currentAngle, angleDifference);
        } else {
            isTargetLocked = false;
        }
    }
    
    private float calculateAngleDifference(float target, float current) {
        return Math.abs(target - current);
    }
    
    private void adjustAim(float targetAngle, float currentAngle, float angleDiff) {
        if (angleDiff < targetLockThreshold) {
            isTargetLocked = true;
            currentLockTimer = 0.0f;
        }
        
        float adjustment = Math.min(maxAngleAdjustment, angleDiff * currentAssistStrength);
        float newAngle = currentAngle + (targetAngle > currentAngle ? adjustment : -adjustment);
        newAngle = smoothAim(currentAngle, newAngle);
        
        applyAimAdjustment(newAngle);
    }
    
    private float smoothAim(float current, float target) {
        return current + (target - current) * aimSmoothing;
    }
    
    private void applyAimAdjustment(float newAngle) {
        
    }
    
    public void setAssistStrength(float strength) {
        currentAssistStrength = Math.max(0.1f, Math.min(1.0f, strength));
    }
    
    public void setMaxAngleAdjustment(float angle) {
        maxAngleAdjustment = angle;
    }
    
    public boolean isTargetLocked() {
        return isTargetLocked;
    }
}

public class AimAssist {
    private float baseAssistStrength = 0.7f;
    private float maxAngleAdjustment = 15.0f;
    private float aimSmoothing = 0.2f;
    private float targetLockThreshold = 0.8f;
    private float lockDuration = 1.5f;
    private float detectionRange = 100.0f;
    private float fovAngle = 60.0f;
    
    private boolean isTargetLocked = false;
    private float currentLockTimer = 0.0f;
    private float currentAssistStrength = baseAssistStrength;
    
    public void update(float deltaTime, float targetAngle, float currentAngle) {
        if (isTargetLocked) {
            currentLockTimer += deltaTime;
            if (currentLockTimer >= lockDuration) {
                isTargetLocked = false;
                currentLockTimer = 0.0f;
            }
        }
        
        float angleDifference = calculateAngleDifference(targetAngle, currentAngle);
        if (angleDifference <= fovAngle && angleDifference <= detectionRange) {
            adjustAim(targetAngle, currentAngle, angleDifference);
        } else {
            isTargetLocked = false;
        }
    }
    
    private float calculateAngleDifference(float target, float current) {
        return Math.abs(target - current);
    }
    
    private void adjustAim(float targetAngle, float currentAngle, float angleDiff) {
        if (angleDiff < targetLockThreshold) {
            isTargetLocked = true;
            currentLockTimer = 0.0f;
        }
        
        float adjustment = Math.min(maxAngleAdjustment, angleDiff * currentAssistStrength);
        float newAngle = currentAngle + (targetAngle > currentAngle ? adjustment : -adjustment);
        newAngle = smoothAim(currentAngle, newAngle);
        
        applyAimAdjustment(newAngle);
    }
    
    private float smoothAim(float current, float target) {
        return current + (target - current) * aimSmoothing;
    }
    
    private void applyAimAdjustment(float newAngle) {
        
    }
    
    public void setAssistStrength(float strength) {
        currentAssistStrength = Math.max(0.1f, Math.min(1.0f, strength));
    }
    
    public void setMaxAngleAdjustment(float angle) {
        maxAngleAdjustment = angle;
    }
    
    public boolean isTargetLocked() {
        return isTargetLocked;
    }
}

public class AimAssist {
    private float baseAssistStrength = 0.7f;
    private float maxAngleAdjustment = 15.0f;
    private float aimSmoothing = 0.2f;
    private float targetLockThreshold = 0.8f;
    private float lockDuration = 1.5f;
    private float detectionRange = 100.0f;
    private float fovAngle = 60.0f;
    
    private boolean isTargetLocked = false;
    private float currentLockTimer = 0.0f;
    private float currentAssistStrength = baseAssistStrength;
    
    public void update(float deltaTime, float targetAngle, float currentAngle) {
        if (isTargetLocked) {
            currentLockTimer += deltaTime;
            if (currentLockTimer >= lockDuration) {
                isTargetLocked = false;
                currentLockTimer = 0.0f;
            }
        }
        
        float angleDifference = calculateAngleDifference(targetAngle, currentAngle);
        if (angleDifference <= fovAngle && angleDifference <= detectionRange) {
            adjustAim(targetAngle, currentAngle, angleDifference);
        } else {
            isTargetLocked = false;
        }
    }
    
    private float calculateAngleDifference(float target, float current) {
        return Math.abs(target - current);
    }
    
    private void adjustAim(float targetAngle, float currentAngle, float angleDiff) {
        if (angleDiff < targetLockThreshold) {
            isTargetLocked = true;
            currentLockTimer = 0.0f;
        }
        
        float adjustment = Math.min(maxAngleAdjustment, angleDiff * currentAssistStrength);
        float newAngle = currentAngle + (targetAngle > currentAngle ? adjustment : -adjustment);
        newAngle = smoothAim(currentAngle, newAngle);
        
        applyAimAdjustment(newAngle);
    }
    
    private float smoothAim(float current, float target) {
        return current + (target - current) * aimSmoothing;
    }
    
    private void applyAimAdjustment(float newAngle) {
        
    }
    
    public void setAssistStrength(float strength) {
        currentAssistStrength = Math.max(0.1f, Math.min(1.0f, strength));
    }
    
    public void setMaxAngleAdjustment(float angle) {
        maxAngleAdjustment = angle;
    }
    
    public boolean isTargetLocked() {
        return isTargetLocked;
    }
}

public class AimAssist {
    private float baseAssistStrength = 0.7f;
    private float maxAngleAdjustment = 15.0f;
    private float aimSmoothing = 0.2f;
    private float targetLockThreshold = 0.8f;
    private float lockDuration = 1.5f;
    private float detectionRange = 100.0f;
    private float fovAngle = 60.0f;
    
    private boolean isTargetLocked = false;
    private float currentLockTimer = 0.0f;
    private float currentAssistStrength = baseAssistStrength;
    
    public void update(float deltaTime, float targetAngle, float currentAngle) {
        if (isTargetLocked) {
            currentLockTimer += deltaTime;
            if (currentLockTimer >= lockDuration) {
                isTargetLocked = false;
                currentLockTimer = 0.0f;
            }
        }
        
        float angleDifference = calculateAngleDifference(targetAngle, currentAngle);
        if (angleDifference <= fovAngle && angleDifference <= detectionRange) {
            adjustAim(targetAngle, currentAngle, angleDifference);
        } else {
            isTargetLocked = false;
        }
    }
    
    private float calculateAngleDifference(float target, float current) {
        return Math.abs(target - current);
    }
    
    private void adjustAim(float targetAngle, float currentAngle, float angleDiff) {
        if (angleDiff < targetLockThreshold) {
            isTargetLocked = true;
            currentLockTimer = 0.0f;
        }
        
        float adjustment = Math.min(maxAngleAdjustment, angleDiff * currentAssistStrength);
        float newAngle = currentAngle + (targetAngle > currentAngle ? adjustment : -adjustment);
        newAngle = smoothAim(currentAngle, newAngle);
        
        applyAimAdjustment(newAngle);
    }
    
    private float smoothAim(float current, float target) {
        return current + (target - current) * aimSmoothing;
    }
    
    private void applyAimAdjustment(float newAngle) {
        
    }
    
    public void setAssistStrength(float strength) {
        currentAssistStrength = Math.max(0.1f, Math.min(1.0f, strength));
    }
    
    public void setMaxAngleAdjustment(float angle) {
        maxAngleAdjustment = angle;
    }
    
    public boolean isTargetLocked() {
        return isTargetLocked;
    }
}

public class AimAssist {
    private float baseAssistStrength = 0.7f;
    private float maxAngleAdjustment = 15.0f;
    private float aimSmoothing = 0.2f;
    private float targetLockThreshold = 0.8f;
    private float lockDuration = 1.5f;
    private float detectionRange = 100.0f;
    private float fovAngle = 60.0f;
    
    private boolean isTargetLocked = false;
    private float currentLockTimer = 0.0f;
    private float currentAssistStrength = baseAssistStrength;
    
    public void update(float deltaTime, float targetAngle, float currentAngle) {
        if (isTargetLocked) {
            currentLockTimer += deltaTime;
            if (currentLockTimer >= lockDuration) {
                isTargetLocked = false;
                currentLockTimer = 0.0f;
            }
        }
        
        float angleDifference = calculateAngleDifference(targetAngle, currentAngle);
        if (angleDifference <= fovAngle && angleDifference <= detectionRange) {
            adjustAim(targetAngle, currentAngle, angleDifference);
        } else {
            isTargetLocked = false;
        }
    }
    
    private float calculateAngleDifference(float target, float current) {
        return Math.abs(target - current);
    }
    
    private void adjustAim(float targetAngle, float currentAngle, float angleDiff) {
        if (angleDiff < targetLockThreshold) {
            isTargetLocked = true;
            currentLockTimer = 0.0f;
        }
        
        float adjustment = Math.min(maxAngleAdjustment, angleDiff * currentAssistStrength);
        float newAngle = currentAngle + (targetAngle > currentAngle ? adjustment : -adjustment);
        newAngle = smoothAim(currentAngle, newAngle);
        
        applyAimAdjustment(newAngle);
    }
    
    private float smoothAim(float current, float target) {
        return current + (target - current) * aimSmoothing;
    }
    
    private void applyAimAdjustment(float newAngle) {
        
    }
    
    public void setAssistStrength(float strength) {
        currentAssistStrength = Math.max(0.1f, Math.min(1.0f, strength));
    }
    
    public void setMaxAngleAdjustment(float angle) {
        maxAngleAdjustment = angle;
    }
    
    public boolean isTargetLocked() {
        return isTargetLocked;
    }
}

public class AimAssist {
    private float baseAssistStrength = 0.7f;
    private float maxAngleAdjustment = 15.0f;
    private float aimSmoothing = 0.2f;
    private float targetLockThreshold = 0.8f;
    private float lockDuration = 1.5f;
    private float detectionRange = 100.0f;
    private float fovAngle = 60.0f;
    
    private boolean isTargetLocked = false;
    private float currentLockTimer = 0.0f;
    private float currentAssistStrength = baseAssistStrength;
    
    public void update(float deltaTime, float targetAngle, float currentAngle) {
        if (isTargetLocked) {
            currentLockTimer += deltaTime;
            if (currentLockTimer >= lockDuration) {
                isTargetLocked = false;
                currentLockTimer = 0.0f;
            }
        }
        
        float angleDifference = calculateAngleDifference(targetAngle, currentAngle);
        if (angleDifference <= fovAngle && angleDifference <= detectionRange) {
            adjustAim(targetAngle, currentAngle, angleDifference);
        } else {
            isTargetLocked = false;
        }
    }
    
    private float calculateAngleDifference(float target, float current) {
        return Math.abs(target - current);
    }
    
    private void adjustAim(float targetAngle, float currentAngle, float angleDiff) {
        if (angleDiff < targetLockThreshold) {
            isTargetLocked = true;
            currentLockTimer = 0.0f;
        }
        
        float adjustment = Math.min(maxAngleAdjustment, angleDiff * currentAssistStrength);
        float newAngle = currentAngle + (targetAngle > currentAngle ? adjustment : -adjustment);
        newAngle = smoothAim(currentAngle, newAngle);
        
        applyAimAdjustment(newAngle);
    }
    
    private float smoothAim(float current, float target) {
        return current + (target - current) * aimSmoothing;
    }
    
    private void applyAimAdjustment(float newAngle) {
        
    }
    
    public void setAssistStrength(float strength) {
        currentAssistStrength = Math.max(0.1f, Math.min(1.0f, strength));
    }
    
    public void setMaxAngleAdjustment(float angle) {
        maxAngleAdjustment = angle;
    }
    
    public boolean isTargetLocked() {
        return isTargetLocked;
    }
}

public class AimAssist {
    private float baseAssistStrength = 0.7f;
    private float maxAngleAdjustment = 15.0f;
    private float aimSmoothing = 0.2f;
    private float targetLockThreshold = 0.8f;
    private float lockDuration = 1.5f;
    private float detectionRange = 100.0f;
    private float fovAngle = 60.0f;
    
    private boolean isTargetLocked = false;
    private float currentLockTimer = 0.0f;
    private float currentAssistStrength = baseAssistStrength;
    
    public void update(float deltaTime, float targetAngle, float currentAngle) {
        if (isTargetLocked) {
            currentLockTimer += deltaTime;
            if (currentLockTimer >= lockDuration) {
                isTargetLocked = false;
                currentLockTimer = 0.0f;
            }
        }
        
        float angleDifference = calculateAngleDifference(targetAngle, currentAngle);
        if (angleDifference <= fovAngle && angleDifference <= detectionRange) {
            adjustAim(targetAngle, currentAngle, angleDifference);
        } else {
            isTargetLocked = false;
        }
    }
    
    private float calculateAngleDifference(float target, float current) {
        return Math.abs(target - current);
    }
    
    private void adjustAim(float targetAngle, float currentAngle, float angleDiff) {
        if (angleDiff < targetLockThreshold) {
            isTargetLocked = true;
            currentLockTimer = 0.0f;
        }
        
        float adjustment = Math.min(maxAngleAdjustment, angleDiff * currentAssistStrength);
        float newAngle = currentAngle + (targetAngle > currentAngle ? adjustment : -adjustment);
        newAngle = smoothAim(currentAngle, newAngle);
        
        applyAimAdjustment(newAngle);
    }
    
    private float smoothAim(float current, float target) {
        return current + (target - current) * aimSmoothing;
    }
    
    private void applyAimAdjustment(float newAngle) {
        
    }
    
    public void setAssistStrength(float strength) {
        currentAssistStrength = Math.max(0.1f, Math.min(1.0f, strength));
    }
    
    public void setMaxAngleAdjustment(float angle) {
        maxAngleAdjustment = angle;
    }
    
    public boolean isTargetLocked() {
        return isTargetLocked;
    }
}

public class AimAssist {
    private float baseAssistStrength = 0.7f;
    private float maxAngleAdjustment = 15.0f;
    private float aimSmoothing = 0.2f;
    private float targetLockThreshold = 0.8f;
    private float lockDuration = 1.5f;
    private float detectionRange = 100.0f;
    private float fovAngle = 60.0f;
    
    private boolean isTargetLocked = false;
    private float currentLockTimer = 0.0f;
    private float currentAssistStrength = baseAssistStrength;
    
    public void update(float deltaTime, float targetAngle, float currentAngle) {
        if (isTargetLocked) {
            currentLockTimer += deltaTime;
            if (currentLockTimer >= lockDuration) {
                isTargetLocked = false;
                currentLockTimer = 0.0f;
            }
        }
        
        float angleDifference = calculateAngleDifference(targetAngle, currentAngle);
        if (angleDifference <= fovAngle && angleDifference <= detectionRange) {
            adjustAim(targetAngle, currentAngle, angleDifference);
        } else {
            isTargetLocked = false;
        }
    }
    
    private float calculateAngleDifference(float target, float current) {
        return Math.abs(target - current);
    }
    
    private void adjustAim(float targetAngle, float currentAngle, float angleDiff) {
        if (angleDiff < targetLockThreshold) {
            isTargetLocked = true;
            currentLockTimer = 0.0f;
        }
        
        float adjustment = Math.min(maxAngleAdjustment, angleDiff * currentAssistStrength);
        float newAngle = currentAngle + (targetAngle > currentAngle ? adjustment : -adjustment);
        newAngle = smoothAim(currentAngle, newAngle);
        
        applyAimAdjustment(newAngle);
    }
    
    private float smoothAim(float current, float target) {
        return current + (target - current) * aimSmoothing;
    }
    
    private void applyAimAdjustment(float newAngle) {
        
    }
    
    public void setAssistStrength(float strength) {
        currentAssistStrength = Math.max(0.1f, Math.min(1.0f, strength));
    }
    
    public void setMaxAngleAdjustment(float angle) {
        maxAngleAdjustment = angle;
    }
    
    public boolean isTargetLocked() {
        return isTargetLocked;
    }
}

public class AimAssist {
    private float baseAssistStrength = 0.7f;
    private float maxAngleAdjustment = 15.0f;
    private float aimSmoothing = 0.2f;
    private float targetLockThreshold = 0.8f;
    private float lockDuration = 1.5f;
    private float detectionRange = 100.0f;
    private float fovAngle = 60.0f;
    
    private boolean isTargetLocked = false;
    private float currentLockTimer = 0.0f;
    private float currentAssistStrength = baseAssistStrength;
    
    public void update(float deltaTime, float targetAngle, float currentAngle) {
        if (isTargetLocked) {
            currentLockTimer += deltaTime;
            if (currentLockTimer >= lockDuration) {
                isTargetLocked = false;
                currentLockTimer = 0.0f;
            }
        }
        
        float angleDifference = calculateAngleDifference(targetAngle, currentAngle);
        if (angleDifference <= fovAngle && angleDifference <= detectionRange) {
            adjustAim(targetAngle, currentAngle, angleDifference);
        } else {
            isTargetLocked = false;
        }
    }
    
    private float calculateAngleDifference(float target, float current) {
        return Math.abs(target - current);
    }
    
    private void adjustAim(float targetAngle, float currentAngle, float angleDiff) {
        if (angleDiff < targetLockThreshold) {
            isTargetLocked = true;
            currentLockTimer = 0.0f;
        }
        
        float adjustment = Math.min(maxAngleAdjustment, angleDiff * currentAssistStrength);
        float newAngle = currentAngle + (targetAngle > currentAngle ? adjustment : -adjustment);
        newAngle = smoothAim(currentAngle, newAngle);
        
        applyAimAdjustment(newAngle);
    }
    
    private float smoothAim(float current, float target) {
        return current + (target - current) * aimSmoothing;
    }
    
    private void applyAimAdjustment(float newAngle) {
        
    }
    
    public void setAssistStrength(float strength) {
        currentAssistStrength = Math.max(0.1f, Math.min(1.0f, strength));
    }
    
    public void setMaxAngleAdjustment(float angle) {
        maxAngleAdjustment = angle;
    }
    
    public boolean isTargetLocked() {
        return isTargetLocked;
    }
}

public class AimAssist {
    private float baseAssistStrength = 0.7f;
    private float maxAngleAdjustment = 15.0f;
    private float aimSmoothing = 0.2f;
    private float targetLockThreshold = 0.8f;
    private float lockDuration = 1.5f;
    private float detectionRange = 100.0f;
    private float fovAngle = 60.0f;
    
    private boolean isTargetLocked = false;
    private float currentLockTimer = 0.0f;
    private float currentAssistStrength = baseAssistStrength;
    
    public void update(float deltaTime, float targetAngle, float currentAngle) {
        if (isTargetLocked) {
            currentLockTimer += deltaTime;
            if (currentLockTimer >= lockDuration) {
                isTargetLocked = false;
                currentLockTimer = 0.0f;
            }
        }
        
        float angleDifference = calculateAngleDifference(targetAngle, currentAngle);
        if (angleDifference <= fovAngle && angleDifference <= detectionRange) {
            adjustAim(targetAngle, currentAngle, angleDifference);
        } else {
            isTargetLocked = false;
        }
    }
    
    private float calculateAngleDifference(float target, float current) {
        return Math.abs(target - current);
    }
    
    private void adjustAim(float targetAngle, float currentAngle, float angleDiff) {
        if (angleDiff < targetLockThreshold) {
            isTargetLocked = true;
            currentLockTimer = 0.0f;
        }
        
        float adjustment = Math.min(maxAngleAdjustment, angleDiff * currentAssistStrength);
        float newAngle = currentAngle + (targetAngle > currentAngle ? adjustment : -adjustment);
        newAngle = smoothAim(currentAngle, newAngle);
        
        applyAimAdjustment(newAngle);
    }
    
    private float smoothAim(float current, float target) {
        return current + (target - current) * aimSmoothing;
    }
    
    private void applyAimAdjustment(float newAngle) {
        
    }
    
    public void setAssistStrength(float strength) {
        currentAssistStrength = Math.max(0.1f, Math.min(1.0f, strength));
    }
    
    public void setMaxAngleAdjustment(float angle) {
        maxAngleAdjustment = angle;
    }
    
    public boolean isTargetLocked() {
        return isTargetLocked;
    }
}

public class AimAssist {
    private float baseAssistStrength = 0.7f;
    private float maxAngleAdjustment = 15.0f;
    private float aimSmoothing = 0.2f;
    private float targetLockThreshold = 0.8f;
    private float lockDuration = 1.5f;
    private float detectionRange = 100.0f;
    private float fovAngle = 60.0f;
    
    private boolean isTargetLocked = false;
    private float currentLockTimer = 0.0f;
    private float currentAssistStrength = baseAssistStrength;
    
    public void update(float deltaTime, float targetAngle, float currentAngle) {
        if (isTargetLocked) {
            currentLockTimer += deltaTime;
            if (currentLockTimer >= lockDuration) {
                isTargetLocked = false;
                currentLockTimer = 0.0f;
            }
        }
        
        float angleDifference = calculateAngleDifference(targetAngle, currentAngle);
        if (angleDifference <= fovAngle && angleDifference <= detectionRange) {
            adjustAim(targetAngle, currentAngle, angleDifference);
        } else {
            isTargetLocked = false;
        }
    }
    
    private float calculateAngleDifference(float target, float current) {
        return Math.abs(target - current);
    }
    
    private void adjustAim(float targetAngle, float currentAngle, float angleDiff) {
        if (angleDiff < targetLockThreshold) {
            isTargetLocked = true;
            currentLockTimer = 0.0f;
        }
        
        float adjustment = Math.min(maxAngleAdjustment, angleDiff * currentAssistStrength);
        float newAngle = currentAngle + (targetAngle > currentAngle ? adjustment : -adjustment);
        newAngle = smoothAim(currentAngle, newAngle);
        
        applyAimAdjustment(newAngle);
    }
    
    private float smoothAim(float current, float target) {
        return current + (target - current) * aimSmoothing;
    }
    
    private void applyAimAdjustment(float newAngle) {
        
    }
    
    public void setAssistStrength(float strength) {
        currentAssistStrength = Math.max(0.1f, Math.min(1.0f, strength));
    }
    
    public void setMaxAngleAdjustment(float angle) {
        maxAngleAdjustment = angle;
    }
    
    public boolean isTargetLocked() {
        return isTargetLocked;
    }
}

public class AimAssist {
    private float baseAssistStrength = 0.7f;
    private float maxAngleAdjustment = 15.0f;
    private float aimSmoothing = 0.2f;
    private float targetLockThreshold = 0.8f;
    private float lockDuration = 1.5f;
    private float detectionRange = 100.0f;
    private float fovAngle = 60.0f;
    
    private boolean isTargetLocked = false;
    private float currentLockTimer = 0.0f;
    private float currentAssistStrength = baseAssistStrength;
    
    public void update(float deltaTime, float targetAngle, float currentAngle) {
        if (isTargetLocked) {
            currentLockTimer += deltaTime;
            if (currentLockTimer >= lockDuration) {
                isTargetLocked = false;
                currentLockTimer = 0.0f;
            }
        }
        
        float angleDifference = calculateAngleDifference(targetAngle, currentAngle);
        if (angleDifference <= fovAngle && angleDifference <= detectionRange) {
            adjustAim(targetAngle, currentAngle, angleDifference);
        } else {
            isTargetLocked = false;
        }
    }
    
    private float calculateAngleDifference(float target, float current) {
        return Math.abs(target - current);
    }
    
    private void adjustAim(float targetAngle, float currentAngle, float angleDiff) {
        if (angleDiff < targetLockThreshold) {
            isTargetLocked = true;
            currentLockTimer = 0.0f;
        }
        
        float adjustment = Math.min(maxAngleAdjustment, angleDiff * currentAssistStrength);
        float newAngle = currentAngle + (targetAngle > currentAngle ? adjustment : -adjustment);
        newAngle = smoothAim(currentAngle, newAngle);
        
        applyAimAdjustment(newAngle);
    }
    
    private float smoothAim(float current, float target) {
        return current + (target - current) * aimSmoothing;
    }
    
    private void applyAimAdjustment(float newAngle) {
        
    }
    
    public void setAssistStrength(float strength) {
        currentAssistStrength = Math.max(0.1f, Math.min(1.0f, strength));
    }
    
    public void setMaxAngleAdjustment(float angle) {
        maxAngleAdjustment = angle;
    }
    
    public boolean isTargetLocked() {
        return isTargetLocked;
    }
}

public class AimAssist {
    private float baseAssistStrength = 0.7f;
    private float maxAngleAdjustment = 15.0f;
    private float aimSmoothing = 0.2f;
    private float targetLockThreshold = 0.8f;
    private float lockDuration = 1.5f;
    private float detectionRange = 100.0f;
    private float fovAngle = 60.0f;
    
    private boolean isTargetLocked = false;
    private float currentLockTimer = 0.0f;
    private float currentAssistStrength = baseAssistStrength;
    
    public void update(float deltaTime, float targetAngle, float currentAngle) {
        if (isTargetLocked) {
            currentLockTimer += deltaTime;
            if (currentLockTimer >= lockDuration) {
                isTargetLocked = false;
                currentLockTimer = 0.0f;
            }
        }
        
        float angleDifference = calculateAngleDifference(targetAngle, currentAngle);
        if (angleDifference <= fovAngle && angleDifference <= detectionRange) {
            adjustAim(targetAngle, currentAngle, angleDifference);
        } else {
            isTargetLocked = false;
        }
    }
    
    private float calculateAngleDifference(float target, float current) {
        return Math.abs(target - current);
    }
    
    private void adjustAim(float targetAngle, float currentAngle, float angleDiff) {
        if (angleDiff < targetLockThreshold) {
            isTargetLocked = true;
            currentLockTimer = 0.0f;
        }
        
        float adjustment = Math.min(maxAngleAdjustment, angleDiff * currentAssistStrength);
        float newAngle = currentAngle + (targetAngle > currentAngle ? adjustment : -adjustment);
        newAngle = smoothAim(currentAngle, newAngle);
        
        applyAimAdjustment(newAngle);
    }
    
    private float smoothAim(float current, float target) {
        return current + (target - current) * aimSmoothing;
    }
    
    private void applyAimAdjustment(float newAngle) {
        
    }
    
    public void setAssistStrength(float strength) {
        currentAssistStrength = Math.max(0.1f, Math.min(1.0f, strength));
    }
    
    public void setMaxAngleAdjustment(float angle) {
        maxAngleAdjustment = angle;
    }
    
    public boolean isTargetLocked() {
        return isTargetLocked;
    }
}

public class AimAssist {
    private float baseAssistStrength = 0.7f;
    private float maxAngleAdjustment = 15.0f;
    private float aimSmoothing = 0.2f;
    private float targetLockThreshold = 0.8f;
    private float lockDuration = 1.5f;
    private float detectionRange = 100.0f;
    private float fovAngle = 60.0f;
    
    private boolean isTargetLocked = false;
    private float currentLockTimer = 0.0f;
    private float currentAssistStrength = baseAssistStrength;
    
    public void update(float deltaTime, float targetAngle, float currentAngle) {
        if (isTargetLocked) {
            currentLockTimer += deltaTime;
            if (currentLockTimer >= lockDuration) {
                isTargetLocked = false;
                currentLockTimer = 0.0f;
            }
        }
        
        float angleDifference = calculateAngleDifference(targetAngle, currentAngle);
        if (angleDifference <= fovAngle && angleDifference <= detectionRange) {
            adjustAim(targetAngle, currentAngle, angleDifference);
        } else {
            isTargetLocked = false;
        }
    }
    
    private float calculateAngleDifference(float target, float current) {
        return Math.abs(target - current);
    }
    
    private void adjustAim(float targetAngle, float currentAngle, float angleDiff) {
        if (angleDiff < targetLockThreshold) {
            isTargetLocked = true;
            currentLockTimer = 0.0f;
        }
        
        float adjustment = Math.min(maxAngleAdjustment, angleDiff * currentAssistStrength);
        float newAngle = currentAngle + (targetAngle > currentAngle ? adjustment : -adjustment);
        newAngle = smoothAim(currentAngle, newAngle);
        
        applyAimAdjustment(newAngle);
    }
    
    private float smoothAim(float current, float target) {
        return current + (target - current) * aimSmoothing;
    }
    
    private void applyAimAdjustment(float newAngle) {
        
    }
    
    public void setAssistStrength(float strength) {
        currentAssistStrength = Math.max(0.1f, Math.min(1.0f, strength));
    }
    
    public void setMaxAngleAdjustment(float angle) {
        maxAngleAdjustment = angle;
    }
    
    public boolean isTargetLocked() {
        return isTargetLocked;
    }
}

public class AimAssist {
    private float baseAssistStrength = 0.7f;
    private float maxAngleAdjustment = 15.0f;
    private float aimSmoothing = 0.2f;
    private float targetLockThreshold = 0.8f;
    private float lockDuration = 1.5f;
    private float detectionRange = 100.0f;
    private float fovAngle = 60.0f;
    
    private boolean isTargetLocked = false;
    private float currentLockTimer = 0.0f;
    private float currentAssistStrength = baseAssistStrength;
    
    public void update(float deltaTime, float targetAngle, float currentAngle) {
        if (isTargetLocked) {
            currentLockTimer += deltaTime;
            if (currentLockTimer >= lockDuration) {
                isTargetLocked = false;
                currentLockTimer = 0.0f;
            }
        }
        
        float angleDifference = calculateAngleDifference(targetAngle, currentAngle);
        if (angleDifference <= fovAngle && angleDifference <= detectionRange) {
            adjustAim(targetAngle, currentAngle, angleDifference);
        } else {
            isTargetLocked = false;
        }
    }
    
    private float calculateAngleDifference(float target, float current) {
        return Math.abs(target - current);
    }
    
    private void adjustAim(float targetAngle, float currentAngle, float angleDiff) {
        if (angleDiff < targetLockThreshold) {
            isTargetLocked = true;
            currentLockTimer = 0.0f;
        }
        
        float adjustment = Math.min(maxAngleAdjustment, angleDiff * currentAssistStrength);
        float newAngle = currentAngle + (targetAngle > currentAngle ? adjustment : -adjustment);
        newAngle = smoothAim(currentAngle, newAngle);
        
        applyAimAdjustment(newAngle);
    }
    
    private float smoothAim(float current, float target) {
        return current + (target - current) * aimSmoothing;
    }
    
    private void applyAimAdjustment(float newAngle) {
        
    }
    
    public void setAssistStrength(float strength) {
        currentAssistStrength = Math.max(0.1f, Math.min(1.0f, strength));
    }
    
    public void setMaxAngleAdjustment(float angle) {
        maxAngleAdjustment = angle;
    }
    
    public boolean isTargetLocked() {
        return isTargetLocked;
    }
}

public class AimAssist {
    private float baseAssistStrength = 0.7f;
    private float maxAngleAdjustment = 15.0f;
    private float aimSmoothing = 0.2f;
    private float targetLockThreshold = 0.8f;
    private float lockDuration = 1.5f;
    private float detectionRange = 100.0f;
    private float fovAngle = 60.0f;
    
    private boolean isTargetLocked = false;
    private float currentLockTimer = 0.0f;
    private float currentAssistStrength = baseAssistStrength;
    
    public void update(float deltaTime, float targetAngle, float currentAngle) {
        if (isTargetLocked) {
            currentLockTimer += deltaTime;
            if (currentLockTimer >= lockDuration) {
                isTargetLocked = false;
                currentLockTimer = 0.0f;
            }
        }
        
        float angleDifference = calculateAngleDifference(targetAngle, currentAngle);
        if (angleDifference <= fovAngle && angleDifference <= detectionRange) {
            adjustAim(targetAngle, currentAngle, angleDifference);
        } else {
            isTargetLocked = false;
        }
    }
    
    private float calculateAngleDifference(float target, float current) {
        return Math.abs(target - current);
    }
    
    private void adjustAim(float targetAngle, float currentAngle, float angleDiff) {
        if (angleDiff < targetLockThreshold) {
            isTargetLocked = true;
            currentLockTimer = 0.0f;
        }
        
        float adjustment = Math.min(maxAngleAdjustment, angleDiff * currentAssistStrength);
        float newAngle = currentAngle + (targetAngle > currentAngle ? adjustment : -adjustment);
        newAngle = smoothAim(currentAngle, newAngle);
        
        applyAimAdjustment(newAngle);
    }
    
    private float smoothAim(float current, float target) {
        return current + (target - current) * aimSmoothing;
    }
    
    private void applyAimAdjustment(float newAngle) {
        
    }
    
    public void setAssistStrength(float strength) {
        currentAssistStrength = Math.max(0.1f, Math.min(1.0f, strength));
    }
    
    public void setMaxAngleAdjustment(float angle) {
        maxAngleAdjustment = angle;
    }
    
    public boolean isTargetLocked() {
        return isTargetLocked;
    }
}

public class AimAssist {
    private float baseAssistStrength = 0.7f;
    private float maxAngleAdjustment = 15.0f;
    private float aimSmoothing = 0.2f;
    private float targetLockThreshold = 0.8f;
    private float lockDuration = 1.5f;
    private float detectionRange = 100.0f;
    private float fovAngle = 60.0f;
    
    private boolean isTargetLocked = false;
    private float currentLockTimer = 0.0f;
    private float currentAssistStrength = baseAssistStrength;
    
    public void update(float deltaTime, float targetAngle, float currentAngle) {
        if (isTargetLocked) {
            currentLockTimer += deltaTime;
            if (currentLockTimer >= lockDuration) {
                isTargetLocked = false;
                currentLockTimer = 0.0f;
            }
        }
        
        float angleDifference = calculateAngleDifference(targetAngle, currentAngle);
        if (angleDifference <= fovAngle && angleDifference <= detectionRange) {
            adjustAim(targetAngle, currentAngle, angleDifference);
        } else {
            isTargetLocked = false;
        }
    }
    
    private float calculateAngleDifference(float target, float current) {
        return Math.abs(target - current);
    }
    
    private void adjustAim(float targetAngle, float currentAngle, float angleDiff) {
        if (angleDiff < targetLockThreshold) {
            isTargetLocked = true;
            currentLockTimer = 0.0f;
        }
        
        float adjustment = Math.min(maxAngleAdjustment, angleDiff * currentAssistStrength);
        float newAngle = currentAngle + (targetAngle > currentAngle ? adjustment : -adjustment);
        newAngle = smoothAim(currentAngle, newAngle);
        
        applyAimAdjustment(newAngle);
    }
    
    private float smoothAim(float current, float target) {
        return current + (target - current) * aimSmoothing;
    }
    
    private void applyAimAdjustment(float newAngle) {
        
    }
    
    public void setAssistStrength(float strength) {
        currentAssistStrength = Math.max(0.1f, Math.min(1.0f, strength));
    }
    
    public void setMaxAngleAdjustment(float angle) {
        maxAngleAdjustment = angle;
    }
    
    public boolean isTargetLocked() {
        return isTargetLocked;
    }
}

public class AimAssist {
    private float baseAssistStrength = 0.7f;
    private float maxAngleAdjustment = 15.0f;
    private float aimSmoothing = 0.2f;
    private float targetLockThreshold = 0.8f;
    private float lockDuration = 1.5f;
    private float detectionRange = 100.0f;
    private float fovAngle = 60.0f;
    
    private boolean isTargetLocked = false;
    private float currentLockTimer = 0.0f;
    private float currentAssistStrength = baseAssistStrength;
    
    public void update(float deltaTime, float targetAngle, float currentAngle) {
        if (isTargetLocked) {
            currentLockTimer += deltaTime;
            if (currentLockTimer >= lockDuration) {
                isTargetLocked = false;
                currentLockTimer = 0.0f;
            }
        }
        
        float angleDifference = calculateAngleDifference(targetAngle, currentAngle);
        if (angleDifference <= fovAngle && angleDifference <= detectionRange) {
            adjustAim(targetAngle, currentAngle, angleDifference);
        } else {
            isTargetLocked = false;
        }
    }
    
    private float calculateAngleDifference(float target, float current) {
        return Math.abs(target - current);
    }
    
    private void adjustAim(float targetAngle, float currentAngle, float angleDiff) {
        if (angleDiff < targetLockThreshold) {
            isTargetLocked = true;
            currentLockTimer = 0.0f;
        }
        
        float adjustment = Math.min(maxAngleAdjustment, angleDiff * currentAssistStrength);
        float newAngle = currentAngle + (targetAngle > currentAngle ? adjustment : -adjustment);
        newAngle = smoothAim(currentAngle, newAngle);
        
        applyAimAdjustment(newAngle);
    }
    
    private float smoothAim(float current, float target) {
        return current + (target - current) * aimSmoothing;
    }
    
    private void applyAimAdjustment(float newAngle) {
        
    }
    
    public void setAssistStrength(float strength) {
        currentAssistStrength = Math.max(0.1f, Math.min(1.0f, strength));
    }
    
    public void setMaxAngleAdjustment(float angle) {
        maxAngleAdjustment = angle;
    }
    
    public boolean isTargetLocked() {
        return isTargetLocked;
    }
}

public class AimAssist {
    private float baseAssistStrength = 0.7f;
    private float maxAngleAdjustment = 15.0f;
    private float aimSmoothing = 0.2f;
    private float targetLockThreshold = 0.8f;
    private float lockDuration = 1.5f;
    private float detectionRange = 100.0f;
    private float fovAngle = 60.0f;
    
    private boolean isTargetLocked = false;
    private float currentLockTimer = 0.0f;
    private float currentAssistStrength = baseAssistStrength;
    
    public void update(float deltaTime, float targetAngle, float currentAngle) {
        if (isTargetLocked) {
            currentLockTimer += deltaTime;
            if (currentLockTimer >= lockDuration) {
                isTargetLocked = false;
                currentLockTimer = 0.0f;
            }
        }
        
        float angleDifference = calculateAngleDifference(targetAngle, currentAngle);
        if (angleDifference <= fovAngle && angleDifference <= detectionRange) {
            adjustAim(targetAngle, currentAngle, angleDifference);
        } else {
            isTargetLocked = false;
        }
    }
    
    private float calculateAngleDifference(float target, float current) {
        return Math.abs(target - current);
    }
    
    private void adjustAim(float targetAngle, float currentAngle, float angleDiff) {
        if (angleDiff < targetLockThreshold) {
            isTargetLocked = true;
            currentLockTimer = 0.0f;
        }
        
        float adjustment = Math.min(maxAngleAdjustment, angleDiff * currentAssistStrength);
        float newAngle = currentAngle + (targetAngle > currentAngle ? adjustment : -adjustment);
        newAngle = smoothAim(currentAngle, newAngle);
        
        applyAimAdjustment(newAngle);
    }
    
    private float smoothAim(float current, float target) {
        return current + (target - current) * aimSmoothing;
    }
    
    private void applyAimAdjustment(float newAngle) {
        
    }
    
    public void setAssistStrength(float strength) {
        currentAssistStrength = Math.max(0.1f, Math.min(1.0f, strength));
    }
    
    public void setMaxAngleAdjustment(float angle) {
        maxAngleAdjustment = angle;
    }
    
    public boolean isTargetLocked() {
        return isTargetLocked;
    }
}

public class AimAssist {
    private float baseAssistStrength = 0.7f;
    private float maxAngleAdjustment = 15.0f;
    private float aimSmoothing = 0.2f;
    private float targetLockThreshold = 0.8f;
    private float lockDuration = 1.5f;
    private float detectionRange = 100.0f;
    private float fovAngle = 60.0f;
    
    private boolean isTargetLocked = false;
    private float currentLockTimer = 0.0f;
    private float currentAssistStrength = baseAssistStrength;
    
    public void update(float deltaTime, float targetAngle, float currentAngle) {
        if (isTargetLocked) {
            currentLockTimer += deltaTime;
            if (currentLockTimer >= lockDuration) {
                isTargetLocked = false;
                currentLockTimer = 0.0f;
            }
        }
        
        float angleDifference = calculateAngleDifference(targetAngle, currentAngle);
        if (angleDifference <= fovAngle && angleDifference <= detectionRange) {
            adjustAim(targetAngle, currentAngle, angleDifference);
        } else {
            isTargetLocked = false;
        }
    }
    
    private float calculateAngleDifference(float target, float current) {
        return Math.abs(target - current);
    }
    
    private void adjustAim(float targetAngle, float currentAngle, float angleDiff) {
        if (angleDiff < targetLockThreshold) {
            isTargetLocked = true;
            currentLockTimer = 0.0f;
        }
        
        float adjustment = Math.min(maxAngleAdjustment, angleDiff * currentAssistStrength);
        float newAngle = currentAngle + (targetAngle > currentAngle ? adjustment : -adjustment);
        newAngle = smoothAim(currentAngle, newAngle);
        
        applyAimAdjustment(newAngle);
    }
    
    private float smoothAim(float current, float target) {
        return current + (target - current) * aimSmoothing;
    }
    
    private void applyAimAdjustment(float newAngle) {
        
    }
    
    public void setAssistStrength(float strength) {
        currentAssistStrength = Math.max(0.1f, Math.min(1.0f, strength));
    }
    
    public void setMaxAngleAdjustment(float angle) {
        maxAngleAdjustment = angle;
    }
    
    public boolean isTargetLocked() {
        return isTargetLocked;
    }
}

public class AimAssist {
    private float baseAssistStrength = 0.7f;
    private float maxAngleAdjustment = 15.0f;
    private float aimSmoothing = 0.2f;
    private float targetLockThreshold = 0.8f;
    private float lockDuration = 1.5f;
    private float detectionRange = 100.0f;
    private float fovAngle = 60.0f;
    
    private boolean isTargetLocked = false;
    private float currentLockTimer = 0.0f;
    private float currentAssistStrength = baseAssistStrength;
    
    public void update(float deltaTime, float targetAngle, float currentAngle) {
        if (isTargetLocked) {
            currentLockTimer += deltaTime;
            if (currentLockTimer >= lockDuration) {
                isTargetLocked = false;
                currentLockTimer = 0.0f;
            }
        }
        
        float angleDifference = calculateAngleDifference(targetAngle, currentAngle);
        if (angleDifference <= fovAngle && angleDifference <= detectionRange) {
            adjustAim(targetAngle, currentAngle, angleDifference);
        } else {
            isTargetLocked = false;
        }
    }
    
    private float calculateAngleDifference(float target, float current) {
        return Math.abs(target - current);
    }
    
    private void adjustAim(float targetAngle, float currentAngle, float angleDiff) {
        if (angleDiff < targetLockThreshold) {
            isTargetLocked = true;
            currentLockTimer = 0.0f;
        }
        
        float adjustment = Math.min(maxAngleAdjustment, angleDiff * currentAssistStrength);
        float newAngle = currentAngle + (targetAngle > currentAngle ? adjustment : -adjustment);
        newAngle = smoothAim(currentAngle, newAngle);
        
        applyAimAdjustment(newAngle);
    }
    
    private float smoothAim(float current, float target) {
        return current + (target - current) * aimSmoothing;
    }
    
    private void applyAimAdjustment(float newAngle) {
        
    }
    
    public void setAssistStrength(float strength) {
        currentAssistStrength = Math.max(0.1f, Math.min(1.0f, strength));
    }
    
    public void setMaxAngleAdjustment(float angle) {
        maxAngleAdjustment = angle;
    }
    
    public boolean isTargetLocked() {
        return isTargetLocked;
    }
}

public class AimAssist {
    private float baseAssistStrength = 0.7f;
    private float maxAngleAdjustment = 15.0f;
    private float aimSmoothing = 0.2f;
    private float targetLockThreshold = 0.8f;
    private float lockDuration = 1.5f;
    private float detectionRange = 100.0f;
    private float fovAngle = 60.0f;
    
    private boolean isTargetLocked = false;
    private float currentLockTimer = 0.0f;
    private float currentAssistStrength = baseAssistStrength;
    
    public void update(float deltaTime, float targetAngle, float currentAngle) {
        if (isTargetLocked) {
            currentLockTimer += deltaTime;
            if (currentLockTimer >= lockDuration) {
                isTargetLocked = false;
                currentLockTimer = 0.0f;
            }
        }
        
        float angleDifference = calculateAngleDifference(targetAngle, currentAngle);
        if (angleDifference <= fovAngle && angleDifference <= detectionRange) {
            adjustAim(targetAngle, currentAngle, angleDifference);
        } else {
            isTargetLocked = false;
        }
    }
    
    private float calculateAngleDifference(float target, float current) {
        return Math.abs(target - current);
    }
    
    private void adjustAim(float targetAngle, float currentAngle, float angleDiff) {
        if (angleDiff < targetLockThreshold) {
            isTargetLocked = true;
            currentLockTimer = 0.0f;
        }
        
        float adjustment = Math.min(maxAngleAdjustment, angleDiff * currentAssistStrength);
        float newAngle = currentAngle + (targetAngle > currentAngle ? adjustment : -adjustment);
        newAngle = smoothAim(currentAngle, newAngle);
        
        applyAimAdjustment(newAngle);
    }
    
    private float smoothAim(float current, float target) {
        return current + (target - current) * aimSmoothing;
    }
    
    private void applyAimAdjustment(float newAngle) {
        
    }
    
    public void setAssistStrength(float strength) {
        currentAssistStrength = Math.max(0.1f, Math.min(1.0f, strength));
    }
    
    public void setMaxAngleAdjustment(float angle) {
        maxAngleAdjustment = angle;
    }
    
    public boolean isTargetLocked() {
        return isTargetLocked;
    }
}

public class AimAssist {
    private float baseAssistStrength = 0.7f;
    private float maxAngleAdjustment = 15.0f;
    private float aimSmoothing = 0.2f;
    private float targetLockThreshold = 0.8f;
    private float lockDuration = 1.5f;
    private float detectionRange = 100.0f;
    private float fovAngle = 60.0f;
    
    private boolean isTargetLocked = false;
    private float currentLockTimer = 0.0f;
    private float currentAssistStrength = baseAssistStrength;
    
    public void update(float deltaTime, float targetAngle, float currentAngle) {
        if (isTargetLocked) {
            currentLockTimer += deltaTime;
            if (currentLockTimer >= lockDuration) {
                isTargetLocked = false;
                currentLockTimer = 0.0f;
            }
        }
        
        float angleDifference = calculateAngleDifference(targetAngle, currentAngle);
        if (angleDifference <= fovAngle && angleDifference <= detectionRange) {
            adjustAim(targetAngle, currentAngle, angleDifference);
        } else {
            isTargetLocked = false;
        }
    }
    
    private float calculateAngleDifference(float target, float current) {
        return Math.abs(target - current);
    }
    
    private void adjustAim(float targetAngle, float currentAngle, float angleDiff) {
        if (angleDiff < targetLockThreshold) {
            isTargetLocked = true;
            currentLockTimer = 0.0f;
        }
        
        float adjustment = Math.min(maxAngleAdjustment, angleDiff * currentAssistStrength);
        float newAngle = currentAngle + (targetAngle > currentAngle ? adjustment : -adjustment);
        newAngle = smoothAim(currentAngle, newAngle);
        
        applyAimAdjustment(newAngle);
    }
    
    private float smoothAim(float current, float target) {
        return current + (target - current) * aimSmoothing;
    }
    
    private void applyAimAdjustment(float newAngle) {
        
    }
    
    public void setAssistStrength(float strength) {
        currentAssistStrength = Math.max(0.1f, Math.min(1.0f, strength));
    }
    
    public void setMaxAngleAdjustment(float angle) {
        maxAngleAdjustment = angle;
    }
    
    public boolean isTargetLocked() {
        return isTargetLocked;
    }
}

public class AimAssist {
    private float baseAssistStrength = 0.7f;
    private float maxAngleAdjustment = 15.0f;
    private float aimSmoothing = 0.2f;
    private float targetLockThreshold = 0.8f;
    private float lockDuration = 1.5f;
    private float detectionRange = 100.0f;
    private float fovAngle = 60.0f;
    
    private boolean isTargetLocked = false;
    private float currentLockTimer = 0.0f;
    private float currentAssistStrength = baseAssistStrength;
    
    public void update(float deltaTime, float targetAngle, float currentAngle) {
        if (isTargetLocked) {
            currentLockTimer += deltaTime;
            if (currentLockTimer >= lockDuration) {
                isTargetLocked = false;
                currentLockTimer = 0.0f;
            }
        }
        
        float angleDifference = calculateAngleDifference(targetAngle, currentAngle);
        if (angleDifference <= fovAngle && angleDifference <= detectionRange) {
            adjustAim(targetAngle, currentAngle, angleDifference);
        } else {
            isTargetLocked = false;
        }
    }
    
    private float calculateAngleDifference(float target, float current) {
        return Math.abs(target - current);
    }
    
    private void adjustAim(float targetAngle, float currentAngle, float angleDiff) {
        if (angleDiff < targetLockThreshold) {
            isTargetLocked = true;
            currentLockTimer = 0.0f;
        }
        
        float adjustment = Math.min(maxAngleAdjustment, angleDiff * currentAssistStrength);
        float newAngle = currentAngle + (targetAngle > currentAngle ? adjustment : -adjustment);
        newAngle = smoothAim(currentAngle, newAngle);
        
        applyAimAdjustment(newAngle);
    }
    
    private float smoothAim(float current, float target) {
        return current + (target - current) * aimSmoothing;
    }
    
    private void applyAimAdjustment(float newAngle) {
        
    }
    
    public void setAssistStrength(float strength) {
        currentAssistStrength = Math.max(0.1f, Math.min(1.0f, strength));
    }
    
    public void setMaxAngleAdjustment(float angle) {
        maxAngleAdjustment = angle;
    }
    
    public boolean isTargetLocked() {
        return isTargetLocked;
    }
}

public class AimAssist {
    private float baseAssistStrength = 0.7f;
    private float maxAngleAdjustment = 15.0f;
    private float aimSmoothing = 0.2f;
    private float targetLockThreshold = 0.8f;
    private float lockDuration = 1.5f;
    private float detectionRange = 100.0f;
    private float fovAngle = 60.0f;
    
    private boolean isTargetLocked = false;
    private float currentLockTimer = 0.0f;
    private float currentAssistStrength = baseAssistStrength;
    
    public void update(float deltaTime, float targetAngle, float currentAngle) {
        if (isTargetLocked) {
            currentLockTimer += deltaTime;
            if (currentLockTimer >= lockDuration) {
                isTargetLocked = false;
                currentLockTimer = 0.0f;
            }
        }
        
        float angleDifference = calculateAngleDifference(targetAngle, currentAngle);
        if (angleDifference <= fovAngle && angleDifference <= detectionRange) {
            adjustAim(targetAngle, currentAngle, angleDifference);
        } else {
            isTargetLocked = false;
        }
    }
    
    private float calculateAngleDifference(float target, float current) {
        return Math.abs(target - current);
    }
    
    private void adjustAim(float targetAngle, float currentAngle, float angleDiff) {
        if (angleDiff < targetLockThreshold) {
            isTargetLocked = true;
            currentLockTimer = 0.0f;
        }
        
        float adjustment = Math.min(maxAngleAdjustment, angleDiff * currentAssistStrength);
        float newAngle = currentAngle + (targetAngle > currentAngle ? adjustment : -adjustment);
        newAngle = smoothAim(currentAngle, newAngle);
        
        applyAimAdjustment(newAngle);
    }
    
    private float smoothAim(float current, float target) {
        return current + (target - current) * aimSmoothing;
    }
    
    private void applyAimAdjustment(float newAngle) {
        
    }
    
    public void setAssistStrength(float strength) {
        currentAssistStrength = Math.max(0.1f, Math.min(1.0f, strength));
    }
    
    public void setMaxAngleAdjustment(float angle) {
        maxAngleAdjustment = angle;
    }
    
    public boolean isTargetLocked() {
        return isTargetLocked;
    }
}

public class AimAssist {
    private float baseAssistStrength = 0.7f;
    private float maxAngleAdjustment = 15.0f;
    private float aimSmoothing = 0.2f;
    private float targetLockThreshold = 0.8f;
    private float lockDuration = 1.5f;
    private float detectionRange = 100.0f;
    private float fovAngle = 60.0f;
    
    private boolean isTargetLocked = false;
    private float currentLockTimer = 0.0f;
    private float currentAssistStrength = baseAssistStrength;
    
    public void update(float deltaTime, float targetAngle, float currentAngle) {
        if (isTargetLocked) {
            currentLockTimer += deltaTime;
            if (currentLockTimer >= lockDuration) {
                isTargetLocked = false;
                currentLockTimer = 0.0f;
            }
        }
        
        float angleDifference = calculateAngleDifference(targetAngle, currentAngle);
        if (angleDifference <= fovAngle && angleDifference <= detectionRange) {
            adjustAim(targetAngle, currentAngle, angleDifference);
        } else {
            isTargetLocked = false;
        }
    }
    
    private float calculateAngleDifference(float target, float current) {
        return Math.abs(target - current);
    }
    
    private void adjustAim(float targetAngle, float currentAngle, float angleDiff) {
        if (angleDiff < targetLockThreshold) {
            isTargetLocked = true;
            currentLockTimer = 0.0f;
        }
        
        float adjustment = Math.min(maxAngleAdjustment, angleDiff * currentAssistStrength);
        float newAngle = currentAngle + (targetAngle > currentAngle ? adjustment : -adjustment);
        newAngle = smoothAim(currentAngle, newAngle);
        
        applyAimAdjustment(newAngle);
    }
    
    private float smoothAim(float current, float target) {
        return current + (target - current) * aimSmoothing;
    }
    
    private void applyAimAdjustment(float newAngle) {
        
    }
    
    public void setAssistStrength(float strength) {
        currentAssistStrength = Math.max(0.1f, Math.min(1.0f, strength));
    }
    
    public void setMaxAngleAdjustment(float angle) {
        maxAngleAdjustment = angle;
    }
    
    public boolean isTargetLocked() {
        return isTargetLocked;
    }
}

public class AimAssist {
    private float baseAssistStrength = 0.7f;
    private float maxAngleAdjustment = 15.0f;
    private float aimSmoothing = 0.2f;
    private float targetLockThreshold = 0.8f;
    private float lockDuration = 1.5f;
    private float detectionRange = 100.0f;
    private float fovAngle = 60.0f;
    
    private boolean isTargetLocked = false;
    private float currentLockTimer = 0.0f;
    private float currentAssistStrength = baseAssistStrength;
    
    public void update(float deltaTime, float targetAngle, float currentAngle) {
        if (isTargetLocked) {
            currentLockTimer += deltaTime;
            if (currentLockTimer >= lockDuration) {
                isTargetLocked = false;
                currentLockTimer = 0.0f;
            }
        }
        
        float angleDifference = calculateAngleDifference(targetAngle, currentAngle);
        if (angleDifference <= fovAngle && angleDifference <= detectionRange) {
            adjustAim(targetAngle, currentAngle, angleDifference);
        } else {
            isTargetLocked = false;
        }
    }
    
    private float calculateAngleDifference(float target, float current) {
        return Math.abs(target - current);
    }
    
    private void adjustAim(float targetAngle, float currentAngle, float angleDiff) {
        if (angleDiff < targetLockThreshold) {
            isTargetLocked = true;
            currentLockTimer = 0.0f;
        }
        
        float adjustment = Math.min(maxAngleAdjustment, angleDiff * currentAssistStrength);
        float newAngle = currentAngle + (targetAngle > currentAngle ? adjustment : -adjustment);
        newAngle = smoothAim(currentAngle, newAngle);
        
        applyAimAdjustment(newAngle);
    }
    
    private float smoothAim(float current, float target) {
        return current + (target - current) * aimSmoothing;
    }
    
    private void applyAimAdjustment(float newAngle) {
        
    }
    
    public void setAssistStrength(float strength) {
        currentAssistStrength = Math.max(0.1f, Math.min(1.0f, strength));
    }
    
    public void setMaxAngleAdjustment(float angle) {
        maxAngleAdjustment = angle;
    }
    
    public boolean isTargetLocked() {
        return isTargetLocked;
    }
}

public class AimAssist {
    private float baseAssistStrength = 0.7f;
    private float maxAngleAdjustment = 15.0f;
    private float aimSmoothing = 0.2f;
    private float targetLockThreshold = 0.8f;
    private float lockDuration = 1.5f;
    private float detectionRange = 100.0f;
    private float fovAngle = 60.0f;
    
    private boolean isTargetLocked = false;
    private float currentLockTimer = 0.0f;
    private float currentAssistStrength = baseAssistStrength;
    
    public void update(float deltaTime, float targetAngle, float currentAngle) {
        if (isTargetLocked) {
            currentLockTimer += deltaTime;
            if (currentLockTimer >= lockDuration) {
                isTargetLocked = false;
                currentLockTimer = 0.0f;
            }
        }
        
        float angleDifference = calculateAngleDifference(targetAngle, currentAngle);
        if (angleDifference <= fovAngle && angleDifference <= detectionRange) {
            adjustAim(targetAngle, currentAngle, angleDifference);
        } else {
            isTargetLocked = false;
        }
    }
    
    private float calculateAngleDifference(float target, float current) {
        return Math.abs(target - current);
    }
    
    private void adjustAim(float targetAngle, float currentAngle, float angleDiff) {
        if (angleDiff < targetLockThreshold) {
            isTargetLocked = true;
            currentLockTimer = 0.0f;
        }
        
        float adjustment = Math.min(maxAngleAdjustment, angleDiff * currentAssistStrength);
        float newAngle = currentAngle + (targetAngle > currentAngle ? adjustment : -adjustment);
        newAngle = smoothAim(currentAngle, newAngle);
        
        applyAimAdjustment(newAngle);
    }
    
    private float smoothAim(float current, float target) {
        return current + (target - current) * aimSmoothing;
    }
    
    private void applyAimAdjustment(float newAngle) {
        
    }
    
    public void setAssistStrength(float strength) {
        currentAssistStrength = Math.max(0.1f, Math.min(1.0f, strength));
    }
    
    public void setMaxAngleAdjustment(float angle) {
        maxAngleAdjustment = angle;
    }
    
    public boolean isTargetLocked() {
        return isTargetLocked;
    }
}

public class AimAssist {
    private float baseAssistStrength = 0.7f;
    private float maxAngleAdjustment = 15.0f;
    private float aimSmoothing = 0.2f;
    private float targetLockThreshold = 0.8f;
    private float lockDuration = 1.5f;
    private float detectionRange = 100.0f;
    private float fovAngle = 60.0f;
    
    private boolean isTargetLocked = false;
    private float currentLockTimer = 0.0f;
    private float currentAssistStrength = baseAssistStrength;
    
    public void update(float deltaTime, float targetAngle, float currentAngle) {
        if (isTargetLocked) {
            currentLockTimer += deltaTime;
            if (currentLockTimer >= lockDuration) {
                isTargetLocked = false;
                currentLockTimer = 0.0f;
            }
        }
        
        float angleDifference = calculateAngleDifference(targetAngle, currentAngle);
        if (angleDifference <= fovAngle && angleDifference <= detectionRange) {
            adjustAim(targetAngle, currentAngle, angleDifference);
        } else {
            isTargetLocked = false;
        }
    }
    
    private float calculateAngleDifference(float target, float current) {
        return Math.abs(target - current);
    }
    
    private void adjustAim(float targetAngle, float currentAngle, float angleDiff) {
        if (angleDiff < targetLockThreshold) {
            isTargetLocked = true;
            currentLockTimer = 0.0f;
        }
        
        float adjustment = Math.min(maxAngleAdjustment, angleDiff * currentAssistStrength);
        float newAngle = currentAngle + (targetAngle > currentAngle ? adjustment : -adjustment);
        newAngle = smoothAim(currentAngle, newAngle);
        
        applyAimAdjustment(newAngle);
    }
    
    private float smoothAim(float current, float target) {
        return current + (target - current) * aimSmoothing;
    }
    
    private void applyAimAdjustment(float newAngle) {
        
    }
    
    public void setAssistStrength(float strength) {
        currentAssistStrength = Math.max(0.1f, Math.min(1.0f, strength));
    }
    
    public void setMaxAngleAdjustment(float angle) {
        maxAngleAdjustment = angle;
    }
    
    public boolean isTargetLocked() {
        return isTargetLocked;
    }
}

public class AimAssist {
    private float baseAssistStrength = 0.7f;
    private float maxAngleAdjustment = 15.0f;
    private float aimSmoothing = 0.2f;
    private float targetLockThreshold = 0.8f;
    private float lockDuration = 1.5f;
    private float detectionRange = 100.0f;
    private float fovAngle = 60.0f;
    
    private boolean isTargetLocked = false;
    private float currentLockTimer = 0.0f;
    private float currentAssistStrength = baseAssistStrength;
    
    public void update(float deltaTime, float targetAngle, float currentAngle) {
        if (isTargetLocked) {
            currentLockTimer += deltaTime;
            if (currentLockTimer >= lockDuration) {
                isTargetLocked = false;
                currentLockTimer = 0.0f;
            }
        }
        
        float angleDifference = calculateAngleDifference(targetAngle, currentAngle);
        if (angleDifference <= fovAngle && angleDifference <= detectionRange) {
            adjustAim(targetAngle, currentAngle, angleDifference);
        } else {
            isTargetLocked = false;
        }
    }
    
    private float calculateAngleDifference(float target, float current) {
        return Math.abs(target - current);
    }
    
    private void adjustAim(float targetAngle, float currentAngle, float angleDiff) {
        if (angleDiff < targetLockThreshold) {
            isTargetLocked = true;
            currentLockTimer = 0.0f;
        }
        
        float adjustment = Math.min(maxAngleAdjustment, angleDiff * currentAssistStrength);
        float newAngle = currentAngle + (targetAngle > currentAngle ? adjustment : -adjustment);
        newAngle = smoothAim(currentAngle, newAngle);
        
        applyAimAdjustment(newAngle);
    }
    
    private float smoothAim(float current, float target) {
        return current + (target - current) * aimSmoothing;
    }
    
    private void applyAimAdjustment(float newAngle) {
        
    }
    
    public void setAssistStrength(float strength) {
        currentAssistStrength = Math.max(0.1f, Math.min(1.0f, strength));
    }
    
    public void setMaxAngleAdjustment(float angle) {
        maxAngleAdjustment = angle;
    }
    
    public boolean isTargetLocked() {
        return isTargetLocked;
    }
}

public class AimAssist {
    private float baseAssistStrength = 0.7f;
    private float maxAngleAdjustment = 15.0f;
    private float aimSmoothing = 0.2f;
    private float targetLockThreshold = 0.8f;
    private float lockDuration = 1.5f;
    private float detectionRange = 100.0f;
    private float fovAngle = 60.0f;
    
    private boolean isTargetLocked = false;
    private float currentLockTimer = 0.0f;
    private float currentAssistStrength = baseAssistStrength;
    
    public void update(float deltaTime, float targetAngle, float currentAngle) {
        if (isTargetLocked) {
            currentLockTimer += deltaTime;
            if (currentLockTimer >= lockDuration) {
                isTargetLocked = false;
                currentLockTimer = 0.0f;
            }
        }
        
        float angleDifference = calculateAngleDifference(targetAngle, currentAngle);
        if (angleDifference <= fovAngle && angleDifference <= detectionRange) {
            adjustAim(targetAngle, currentAngle, angleDifference);
        } else {
            isTargetLocked = false;
        }
    }
    
    private float calculateAngleDifference(float target, float current) {
        return Math.abs(target - current);
    }
    
    private void adjustAim(float targetAngle, float currentAngle, float angleDiff) {
        if (angleDiff < targetLockThreshold) {
            isTargetLocked = true;
            currentLockTimer = 0.0f;
        }
        
        float adjustment = Math.min(maxAngleAdjustment, angleDiff * currentAssistStrength);
        float newAngle = currentAngle + (targetAngle > currentAngle ? adjustment : -adjustment);
        newAngle = smoothAim(currentAngle, newAngle);
        
        applyAimAdjustment(newAngle);
    }
    
    private float smoothAim(float current, float target) {
        return current + (target - current) * aimSmoothing;
    }
    
    private void applyAimAdjustment(float newAngle) {
        
    }
    
    public void setAssistStrength(float strength) {
        currentAssistStrength = Math.max(0.1f, Math.min(1.0f, strength));
    }
    
    public void setMaxAngleAdjustment(float angle) {
        maxAngleAdjustment = angle;
    }
    
    public boolean isTargetLocked() {
        return isTargetLocked;
    }
}

public class AimAssist {
    private float baseAssistStrength = 0.7f;
    private float maxAngleAdjustment = 15.0f;
    private float aimSmoothing = 0.2f;
    private float targetLockThreshold = 0.8f;
    private float lockDuration = 1.5f;
    private float detectionRange = 100.0f;
    private float fovAngle = 60.0f;
    
    private boolean isTargetLocked = false;
    private float currentLockTimer = 0.0f;
    private float currentAssistStrength = baseAssistStrength;
    
    public void update(float deltaTime, float targetAngle, float currentAngle) {
        if (isTargetLocked) {
            currentLockTimer += deltaTime;
            if (currentLockTimer >= lockDuration) {
                isTargetLocked = false;
                currentLockTimer = 0.0f;
            }
        }
        
        float angleDifference = calculateAngleDifference(targetAngle, currentAngle);
        if (angleDifference <= fovAngle && angleDifference <= detectionRange) {
            adjustAim(targetAngle, currentAngle, angleDifference);
        } else {
            isTargetLocked = false;
        }
    }
    
    private float calculateAngleDifference(float target, float current) {
        return Math.abs(target - current);
    }
    
    private void adjustAim(float targetAngle, float currentAngle, float angleDiff) {
        if (angleDiff < targetLockThreshold) {
            isTargetLocked = true;
            currentLockTimer = 0.0f;
        }
        
        float adjustment = Math.min(maxAngleAdjustment, angleDiff * currentAssistStrength);
        float newAngle = currentAngle + (targetAngle > currentAngle ? adjustment : -adjustment);
        newAngle = smoothAim(currentAngle, newAngle);
        
        applyAimAdjustment(newAngle);
    }
    
    private float smoothAim(float current, float target) {
        return current + (target - current) * aimSmoothing;
    }
    
    private void applyAimAdjustment(float newAngle) {
        
    }
    
    public void setAssistStrength(float strength) {
        currentAssistStrength = Math.max(0.1f, Math.min(1.0f, strength));
    }
    
    public void setMaxAngleAdjustment(float angle) {
        maxAngleAdjustment = angle;
    }
    
    public boolean isTargetLocked() {
        return isTargetLocked;
    }
}

public class AimAssist {
    private float baseAssistStrength = 0.7f;
    private float maxAngleAdjustment = 15.0f;
    private float aimSmoothing = 0.2f;
    private float targetLockThreshold = 0.8f;
    private float lockDuration = 1.5f;
    private float detectionRange = 100.0f;
    private float fovAngle = 60.0f;
    
    private boolean isTargetLocked = false;
    private float currentLockTimer = 0.0f;
    private float currentAssistStrength = baseAssistStrength;
    
    public void update(float deltaTime, float targetAngle, float currentAngle) {
        if (isTargetLocked) {
            currentLockTimer += deltaTime;
            if (currentLockTimer >= lockDuration) {
                isTargetLocked = false;
                currentLockTimer = 0.0f;
            }
        }
        
        float angleDifference = calculateAngleDifference(targetAngle, currentAngle);
        if (angleDifference <= fovAngle && angleDifference <= detectionRange) {
            adjustAim(targetAngle, currentAngle, angleDifference);
        } else {
            isTargetLocked = false;
        }
    }
    
    private float calculateAngleDifference(float target, float current) {
        return Math.abs(target - current);
    }
    
    private void adjustAim(float targetAngle, float currentAngle, float angleDiff) {
        if (angleDiff < targetLockThreshold) {
            isTargetLocked = true;
            currentLockTimer = 0.0f;
        }
        
        float adjustment = Math.min(maxAngleAdjustment, angleDiff * currentAssistStrength);
        float newAngle = currentAngle + (targetAngle > currentAngle ? adjustment : -adjustment);
        newAngle = smoothAim(currentAngle, newAngle);
        
        applyAimAdjustment(newAngle);
    }
    
    private float smoothAim(float current, float target) {
        return current + (target - current) * aimSmoothing;
    }
    
    private void applyAimAdjustment(float newAngle) {
        
    }
    
    public void setAssistStrength(float strength) {
        currentAssistStrength = Math.max(0.1f, Math.min(1.0f, strength));
    }
    
    public void setMaxAngleAdjustment(float angle) {
        maxAngleAdjustment = angle;
    }
    
    public boolean isTargetLocked() {
        return isTargetLocked;
    }
}

public class AimAssist {
    private float baseAssistStrength = 0.7f;
    private float maxAngleAdjustment = 15.0f;
    private float aimSmoothing = 0.2f;
    private float targetLockThreshold = 0.8f;
    private float lockDuration = 1.5f;
    private float detectionRange = 100.0f;
    private float fovAngle = 60.0f;
    
    private boolean isTargetLocked = false;
    private float currentLockTimer = 0.0f;
    private float currentAssistStrength = baseAssistStrength;
    
    public void update(float deltaTime, float targetAngle, float currentAngle) {
        if (isTargetLocked) {
            currentLockTimer += deltaTime;
            if (currentLockTimer >= lockDuration) {
                isTargetLocked = false;
                currentLockTimer = 0.0f;
            }
        }
        
        float angleDifference = calculateAngleDifference(targetAngle, currentAngle);
        if (angleDifference <= fovAngle && angleDifference <= detectionRange) {
            adjustAim(targetAngle, currentAngle, angleDifference);
        } else {
            isTargetLocked = false;
        }
    }
    
    private float calculateAngleDifference(float target, float current) {
        return Math.abs(target - current);
    }
    
    private void adjustAim(float targetAngle, float currentAngle, float angleDiff) {
        if (angleDiff < targetLockThreshold) {
            isTargetLocked = true;
            currentLockTimer = 0.0f;
        }
        
        float adjustment = Math.min(maxAngleAdjustment, angleDiff * currentAssistStrength);
        float newAngle = currentAngle + (targetAngle > currentAngle ? adjustment : -adjustment);
        newAngle = smoothAim(currentAngle, newAngle);
        
        applyAimAdjustment(newAngle);
    }
    
    private float smoothAim(float current, float target) {
        return current + (target - current) * aimSmoothing;
    }
    
    private void applyAimAdjustment(float newAngle) {
        
    }
    
    public void setAssistStrength(float strength) {
        currentAssistStrength = Math.max(0.1f, Math.min(1.0f, strength));
    }
    
    public void setMaxAngleAdjustment(float angle) {
        maxAngleAdjustment = angle;
    }
    
    public boolean isTargetLocked() {
        return isTargetLocked;
    }
}

public class AimAssist {
    private float baseAssistStrength = 0.7f;
    private float maxAngleAdjustment = 15.0f;
    private float aimSmoothing = 0.2f;
    private float targetLockThreshold = 0.8f;
    private float lockDuration = 1.5f;
    private float detectionRange = 100.0f;
    private float fovAngle = 60.0f;
    
    private boolean isTargetLocked = false;
    private float currentLockTimer = 0.0f;
    private float currentAssistStrength = baseAssistStrength;
    
    public void update(float deltaTime, float targetAngle, float currentAngle) {
        if (isTargetLocked) {
            currentLockTimer += deltaTime;
            if (currentLockTimer >= lockDuration) {
                isTargetLocked = false;
                currentLockTimer = 0.0f;
            }
        }
        
        float angleDifference = calculateAngleDifference(targetAngle, currentAngle);
        if (angleDifference <= fovAngle && angleDifference <= detectionRange) {
            adjustAim(targetAngle, currentAngle, angleDifference);
        } else {
            isTargetLocked = false;
        }
    }
    
    private float calculateAngleDifference(float target, float current) {
        return Math.abs(target - current);
    }
    
    private void adjustAim(float targetAngle, float currentAngle, float angleDiff) {
        if (angleDiff < targetLockThreshold) {
            isTargetLocked = true;
            currentLockTimer = 0.0f;
        }
        
        float adjustment = Math.min(maxAngleAdjustment, angleDiff * currentAssistStrength);
        float newAngle = currentAngle + (targetAngle > currentAngle ? adjustment : -adjustment);
        newAngle = smoothAim(currentAngle, newAngle);
        
        applyAimAdjustment(newAngle);
    }
    
    private float smoothAim(float current, float target) {
        return current + (target - current) * aimSmoothing;
    }
    
    private void applyAimAdjustment(float newAngle) {
        
    }
    
    public void setAssistStrength(float strength) {
        currentAssistStrength = Math.max(0.1f, Math.min(1.0f, strength));
    }
    
    public void setMaxAngleAdjustment(float angle) {
        maxAngleAdjustment = angle;
    }
    
    public boolean isTargetLocked() {
        return isTargetLocked;
    }
}

public class AimAssist {
    private float baseAssistStrength = 0.7f;
    private float maxAngleAdjustment = 15.0f;
    private float aimSmoothing = 0.2f;
    private float targetLockThreshold = 0.8f;
    private float lockDuration = 1.5f;
    private float detectionRange = 100.0f;
    private float fovAngle = 60.0f;
    
    private boolean isTargetLocked = false;
    private float currentLockTimer = 0.0f;
    private float currentAssistStrength = baseAssistStrength;
    
    public void update(float deltaTime, float targetAngle, float currentAngle) {
        if (isTargetLocked) {
            currentLockTimer += deltaTime;
            if (currentLockTimer >= lockDuration) {
                isTargetLocked = false;
                currentLockTimer = 0.0f;
            }
        }
        
        float angleDifference = calculateAngleDifference(targetAngle, currentAngle);
        if (angleDifference <= fovAngle && angleDifference <= detectionRange) {
            adjustAim(targetAngle, currentAngle, angleDifference);
        } else {
            isTargetLocked = false;
        }
    }
    
    private float calculateAngleDifference(float target, float current) {
        return Math.abs(target - current);
    }
    
    private void adjustAim(float targetAngle, float currentAngle, float angleDiff) {
        if (angleDiff < targetLockThreshold) {
            isTargetLocked = true;
            currentLockTimer = 0.0f;
        }
        
        float adjustment = Math.min(maxAngleAdjustment, angleDiff * currentAssistStrength);
        float newAngle = currentAngle + (targetAngle > currentAngle ? adjustment : -adjustment);
        newAngle = smoothAim(currentAngle, newAngle);
        
        applyAimAdjustment(newAngle);
    }
    
    private float smoothAim(float current, float target) {
        return current + (target - current) * aimSmoothing;
    }
    
    private void applyAimAdjustment(float newAngle) {
        
    }
    
    public void setAssistStrength(float strength) {
        currentAssistStrength = Math.max(0.1f, Math.min(1.0f, strength));
    }
    
    public void setMaxAngleAdjustment(float angle) {
        maxAngleAdjustment = angle;
    }
    
    public boolean isTargetLocked() {
        return isTargetLocked;
    }
}

public class AimAssist {
    private float baseAssistStrength = 0.7f;
    private float maxAngleAdjustment = 15.0f;
    private float aimSmoothing = 0.2f;
    private float targetLockThreshold = 0.8f;
    private float lockDuration = 1.5f;
    private float detectionRange = 100.0f;
    private float fovAngle = 60.0f;
    
    private boolean isTargetLocked = false;
    private float currentLockTimer = 0.0f;
    private float currentAssistStrength = baseAssistStrength;
    
    public void update(float deltaTime, float targetAngle, float currentAngle) {
        if (isTargetLocked) {
            currentLockTimer += deltaTime;
            if (currentLockTimer >= lockDuration) {
                isTargetLocked = false;
                currentLockTimer = 0.0f;
            }
        }
        
        float angleDifference = calculateAngleDifference(targetAngle, currentAngle);
        if (angleDifference <= fovAngle && angleDifference <= detectionRange) {
            adjustAim(targetAngle, currentAngle, angleDifference);
        } else {
            isTargetLocked = false;
        }
    }
    
    private float calculateAngleDifference(float target, float current) {
        return Math.abs(target - current);
    }
    
    private void adjustAim(float targetAngle, float currentAngle, float angleDiff) {
        if (angleDiff < targetLockThreshold) {
            isTargetLocked = true;
            currentLockTimer = 0.0f;
        }
        
        float adjustment = Math.min(maxAngleAdjustment, angleDiff * currentAssistStrength);
        float newAngle = currentAngle + (targetAngle > currentAngle ? adjustment : -adjustment);
        newAngle = smoothAim(currentAngle, newAngle);
        
        applyAimAdjustment(newAngle);
    }
    
    private float smoothAim(float current, float target) {
        return current + (target - current) * aimSmoothing;
    }
    
    private void applyAimAdjustment(float newAngle) {
        
    }
    
    public void setAssistStrength(float strength) {
        currentAssistStrength = Math.max(0.1f, Math.min(1.0f, strength));
    }
    
    public void setMaxAngleAdjustment(float angle) {
        maxAngleAdjustment = angle;
    }
    
    public boolean isTargetLocked() {
        return isTargetLocked;
    }
}

public class AimAssist {
    private float baseAssistStrength = 0.7f;
    private float maxAngleAdjustment = 15.0f;
    private float aimSmoothing = 0.2f;
    private float targetLockThreshold = 0.8f;
    private float lockDuration = 1.5f;
    private float detectionRange = 100.0f;
    private float fovAngle = 60.0f;
    
    private boolean isTargetLocked = false;
    private float currentLockTimer = 0.0f;
    private float currentAssistStrength = baseAssistStrength;
    
    public void update(float deltaTime, float targetAngle, float currentAngle) {
        if (isTargetLocked) {
            currentLockTimer += deltaTime;
            if (currentLockTimer >= lockDuration) {
                isTargetLocked = false;
                currentLockTimer = 0.0f;
            }
        }
        
        float angleDifference = calculateAngleDifference(targetAngle, currentAngle);
        if (angleDifference <= fovAngle && angleDifference <= detectionRange) {
            adjustAim(targetAngle, currentAngle, angleDifference);
        } else {
            isTargetLocked = false;
        }
    }
    
    private float calculateAngleDifference(float target, float current) {
        return Math.abs(target - current);
    }
    
    private void adjustAim(float targetAngle, float currentAngle, float angleDiff) {
        if (angleDiff < targetLockThreshold) {
            isTargetLocked = true;
            currentLockTimer = 0.0f;
        }
        
        float adjustment = Math.min(maxAngleAdjustment, angleDiff * currentAssistStrength);
        float newAngle = currentAngle + (targetAngle > currentAngle ? adjustment : -adjustment);
        newAngle = smoothAim(currentAngle, newAngle);
        
        applyAimAdjustment(newAngle);
    }
    
    private float smoothAim(float current, float target) {
        return current + (target - current) * aimSmoothing;
    }
    
    private void applyAimAdjustment(float newAngle) {
        
    }
    
    public void setAssistStrength(float strength) {
        currentAssistStrength = Math.max(0.1f, Math.min(1.0f, strength));
    }
    
    public void setMaxAngleAdjustment(float angle) {
        maxAngleAdjustment = angle;
    }
    
    public boolean isTargetLocked() {
        return isTargetLocked;
    }
}

public class AimAssist {
    private float baseAssistStrength = 0.7f;
    private float maxAngleAdjustment = 15.0f;
    private float aimSmoothing = 0.2f;
    private float targetLockThreshold = 0.8f;
    private float lockDuration = 1.5f;
    private float detectionRange = 100.0f;
    private float fovAngle = 60.0f;
    
    private boolean isTargetLocked = false;
    private float currentLockTimer = 0.0f;
    private float currentAssistStrength = baseAssistStrength;
    
    public void update(float deltaTime, float targetAngle, float currentAngle) {
        if (isTargetLocked) {
            currentLockTimer += deltaTime;
            if (currentLockTimer >= lockDuration) {
                isTargetLocked = false;
                currentLockTimer = 0.0f;
            }
        }
        
        float angleDifference = calculateAngleDifference(targetAngle, currentAngle);
        if (angleDifference <= fovAngle && angleDifference <= detectionRange) {
            adjustAim(targetAngle, currentAngle, angleDifference);
        } else {
            isTargetLocked = false;
        }
    }
    
    private float calculateAngleDifference(float target, float current) {
        return Math.abs(target - current);
    }
    
    private void adjustAim(float targetAngle, float currentAngle, float angleDiff) {
        if (angleDiff < targetLockThreshold) {
            isTargetLocked = true;
            currentLockTimer = 0.0f;
        }
        
        float adjustment = Math.min(maxAngleAdjustment, angleDiff * currentAssistStrength);
        float newAngle = currentAngle + (targetAngle > currentAngle ? adjustment : -adjustment);
        newAngle = smoothAim(currentAngle, newAngle);
        
        applyAimAdjustment(newAngle);
    }
    
    private float smoothAim(float current, float target) {
        return current + (target - current) * aimSmoothing;
    }
    
    private void applyAimAdjustment(float newAngle) {
        
    }
    
    public void setAssistStrength(float strength) {
        currentAssistStrength = Math.max(0.1f, Math.min(1.0f, strength));
    }
    
    public void setMaxAngleAdjustment(float angle) {
        maxAngleAdjustment = angle;
    }
    
    public boolean isTargetLocked() {
        return isTargetLocked;
    }
}

public class AimAssist {
    private float baseAssistStrength = 0.7f;
    private float maxAngleAdjustment = 15.0f;
    private float aimSmoothing = 0.2f;
    private float targetLockThreshold = 0.8f;
    private float lockDuration = 1.5f;
    private float detectionRange = 100.0f;
    private float fovAngle = 60.0f;
    
    private boolean isTargetLocked = false;
    private float currentLockTimer = 0.0f;
    private float currentAssistStrength = baseAssistStrength;
    
    public void update(float deltaTime, float targetAngle, float currentAngle) {
        if (isTargetLocked) {
            currentLockTimer += deltaTime;
            if (currentLockTimer >= lockDuration) {
                isTargetLocked = false;
                currentLockTimer = 0.0f;
            }
        }
        
        float angleDifference = calculateAngleDifference(targetAngle, currentAngle);
        if (angleDifference <= fovAngle && angleDifference <= detectionRange) {
            adjustAim(targetAngle, currentAngle, angleDifference);
        } else {
            isTargetLocked = false;
        }
    }
    
    private float calculateAngleDifference(float target, float current) {
        return Math.abs(target - current);
    }
    
    private void adjustAim(float targetAngle, float currentAngle, float angleDiff) {
        if (angleDiff < targetLockThreshold) {
            isTargetLocked = true;
            currentLockTimer = 0.0f;
        }
        
        float adjustment = Math.min(maxAngleAdjustment, angleDiff * currentAssistStrength);
        float newAngle = currentAngle + (targetAngle > currentAngle ? adjustment : -adjustment);
        newAngle = smoothAim(currentAngle, newAngle);
        
        applyAimAdjustment(newAngle);
    }
    
    private float smoothAim(float current, float target) {
        return current + (target - current) * aimSmoothing;
    }
    
    private void applyAimAdjustment(float newAngle) {
        
    }
    
    public void setAssistStrength(float strength) {
        currentAssistStrength = Math.max(0.1f, Math.min(1.0f, strength));
    }
    
    public void setMaxAngleAdjustment(float angle) {
        maxAngleAdjustment = angle;
    }
    
    public boolean isTargetLocked() {
        return isTargetLocked;
    }
}

public class AimAssist {
    private float baseAssistStrength = 0.7f;
    private float maxAngleAdjustment = 15.0f;
    private float aimSmoothing = 0.2f;
    private float targetLockThreshold = 0.8f;
    private float lockDuration = 1.5f;
    private float detectionRange = 100.0f;
    private float fovAngle = 60.0f;
    
    private boolean isTargetLocked = false;
    private float currentLockTimer = 0.0f;
    private float currentAssistStrength = baseAssistStrength;
    
    public void update(float deltaTime, float targetAngle, float currentAngle) {
        if (isTargetLocked) {
            currentLockTimer += deltaTime;
            if (currentLockTimer >= lockDuration) {
                isTargetLocked = false;
                currentLockTimer = 0.0f;
            }
        }
        
        float angleDifference = calculateAngleDifference(targetAngle, currentAngle);
        if (angleDifference <= fovAngle && angleDifference <= detectionRange) {
            adjustAim(targetAngle, currentAngle, angleDifference);
        } else {
            isTargetLocked = false;
        }
    }
    
    private float calculateAngleDifference(float target, float current) {
        return Math.abs(target - current);
    }
    
    private void adjustAim(float targetAngle, float currentAngle, float angleDiff) {
        if (angleDiff < targetLockThreshold) {
            isTargetLocked = true;
            currentLockTimer = 0.0f;
        }
        
        float adjustment = Math.min(maxAngleAdjustment, angleDiff * currentAssistStrength);
        float newAngle = currentAngle + (targetAngle > currentAngle ? adjustment : -adjustment);
        newAngle = smoothAim(currentAngle, newAngle);
        
        applyAimAdjustment(newAngle);
    }
    
    private float smoothAim(float current, float target) {
        return current + (target - current) * aimSmoothing;
    }
    
    private void applyAimAdjustment(float newAngle) {
        
    }
    
    public void setAssistStrength(float strength) {
        currentAssistStrength = Math.max(0.1f, Math.min(1.0f, strength));
    }
    
    public void setMaxAngleAdjustment(float angle) {
        maxAngleAdjustment = angle;
    }
    
    public boolean isTargetLocked() {
        return isTargetLocked;
    }
}

public class AimAssist {
    private float baseAssistStrength = 0.7f;
    private float maxAngleAdjustment = 15.0f;
    private float aimSmoothing = 0.2f;
    private float targetLockThreshold = 0.8f;
    private float lockDuration = 1.5f;
    private float detectionRange = 100.0f;
    private float fovAngle = 60.0f;
    
    private boolean isTargetLocked = false;
    private float currentLockTimer = 0.0f;
    private float currentAssistStrength = baseAssistStrength;
    
    public void update(float deltaTime, float targetAngle, float currentAngle) {
        if (isTargetLocked) {
            currentLockTimer += deltaTime;
            if (currentLockTimer >= lockDuration) {
                isTargetLocked = false;
                currentLockTimer = 0.0f;
            }
        }
        
        float angleDifference = calculateAngleDifference(targetAngle, currentAngle);
        if (angleDifference <= fovAngle && angleDifference <= detectionRange) {
            adjustAim(targetAngle, currentAngle, angleDifference);
        } else {
            isTargetLocked = false;
        }
    }
    
    private float calculateAngleDifference(float target, float current) {
        return Math.abs(target - current);
    }
    
    private void adjustAim(float targetAngle, float currentAngle, float angleDiff) {
        if (angleDiff < targetLockThreshold) {
            isTargetLocked = true;
            currentLockTimer = 0.0f;
        }
        
        float adjustment = Math.min(maxAngleAdjustment, angleDiff * currentAssistStrength);
        float newAngle = currentAngle + (targetAngle > currentAngle ? adjustment : -adjustment);
        newAngle = smoothAim(currentAngle, newAngle);
        
        applyAimAdjustment(newAngle);
    }
    
    private float smoothAim(float current, float target) {
        return current + (target - current) * aimSmoothing;
    }
    
    private void applyAimAdjustment(float newAngle) {
        
    }
    
    public void setAssistStrength(float strength) {
        currentAssistStrength = Math.max(0.1f, Math.min(1.0f, strength));
    }
    
    public void setMaxAngleAdjustment(float angle) {
        maxAngleAdjustment = angle;
    }
    
    public boolean isTargetLocked() {
        return isTargetLocked;
    }
}

public class AimAssist {
    private float baseAssistStrength = 0.7f;
    private float maxAngleAdjustment = 15.0f;
    private float aimSmoothing = 0.2f;
    private float targetLockThreshold = 0.8f;
    private float lockDuration = 1.5f;
    private float detectionRange = 100.0f;
    private float fovAngle = 60.0f;
    
    private boolean isTargetLocked = false;
    private float currentLockTimer = 0.0f;
    private float currentAssistStrength = baseAssistStrength;
    
    public void update(float deltaTime, float targetAngle, float currentAngle) {
        if (isTargetLocked) {
            currentLockTimer += deltaTime;
            if (currentLockTimer >= lockDuration) {
                isTargetLocked = false;
                currentLockTimer = 0.0f;
            }
        }
        
        float angleDifference = calculateAngleDifference(targetAngle, currentAngle);
        if (angleDifference <= fovAngle && angleDifference <= detectionRange) {
            adjustAim(targetAngle, currentAngle, angleDifference);
        } else {
            isTargetLocked = false;
        }
    }
    
    private float calculateAngleDifference(float target, float current) {
        return Math.abs(target - current);
    }
    
    private void adjustAim(float targetAngle, float currentAngle, float angleDiff) {
        if (angleDiff < targetLockThreshold) {
            isTargetLocked = true;
            currentLockTimer = 0.0f;
        }
        
        float adjustment = Math.min(maxAngleAdjustment, angleDiff * currentAssistStrength);
        float newAngle = currentAngle + (targetAngle > currentAngle ? adjustment : -adjustment);
        newAngle = smoothAim(currentAngle, newAngle);
        
        applyAimAdjustment(newAngle);
    }
    
    private float smoothAim(float current, float target) {
        return current + (target - current) * aimSmoothing;
    }
    
    private void applyAimAdjustment(float newAngle) {
        
    }
    
    public void setAssistStrength(float strength) {
        currentAssistStrength = Math.max(0.1f, Math.min(1.0f, strength));
    }
    
    public void setMaxAngleAdjustment(float angle) {
        maxAngleAdjustment = angle;
    }
    
    public boolean isTargetLocked() {
        return isTargetLocked;
    }
}

public class AimAssist {
    private float baseAssistStrength = 0.7f;
    private float maxAngleAdjustment = 15.0f;
    private float aimSmoothing = 0.2f;
    private float targetLockThreshold = 0.8f;
    private float lockDuration = 1.5f;
    private float detectionRange = 100.0f;
    private float fovAngle = 60.0f;
    
    private boolean isTargetLocked = false;
    private float currentLockTimer = 0.0f;
    private float currentAssistStrength = baseAssistStrength;
    
    public void update(float deltaTime, float targetAngle, float currentAngle) {
        if (isTargetLocked) {
            currentLockTimer += deltaTime;
            if (currentLockTimer >= lockDuration) {
                isTargetLocked = false;
                currentLockTimer = 0.0f;
            }
        }
        
        float angleDifference = calculateAngleDifference(targetAngle, currentAngle);
        if (angleDifference <= fovAngle && angleDifference <= detectionRange) {
            adjustAim(targetAngle, currentAngle, angleDifference);
        } else {
            isTargetLocked = false;
        }
    }
    
    private float calculateAngleDifference(float target, float current) {
        return Math.abs(target - current);
    }
    
    private void adjustAim(float targetAngle, float currentAngle, float angleDiff) {
        if (angleDiff < targetLockThreshold) {
            isTargetLocked = true;
            currentLockTimer = 0.0f;
        }
        
        float adjustment = Math.min(maxAngleAdjustment, angleDiff * currentAssistStrength);
        float newAngle = currentAngle + (targetAngle > currentAngle ? adjustment : -adjustment);
        newAngle = smoothAim(currentAngle, newAngle);
        
        applyAimAdjustment(newAngle);
    }
    
    private float smoothAim(float current, float target) {
        return current + (target - current) * aimSmoothing;
    }
    
    private void applyAimAdjustment(float newAngle) {
        
    }
    
    public void setAssistStrength(float strength) {
        currentAssistStrength = Math.max(0.1f, Math.min(1.0f, strength));
    }
    
    public void setMaxAngleAdjustment(float angle) {
        maxAngleAdjustment = angle;
    }
    
    public boolean isTargetLocked() {
        return isTargetLocked;
    }
}

public class AimAssist {
    private float baseAssistStrength = 0.7f;
    private float maxAngleAdjustment = 15.0f;
    private float aimSmoothing = 0.2f;
    private float targetLockThreshold = 0.8f;
    private float lockDuration = 1.5f;
    private float detectionRange = 100.0f;
    private float fovAngle = 60.0f;
    
    private boolean isTargetLocked = false;
    private float currentLockTimer = 0.0f;
    private float currentAssistStrength = baseAssistStrength;
    
    public void update(float deltaTime, float targetAngle, float currentAngle) {
        if (isTargetLocked) {
            currentLockTimer += deltaTime;
            if (currentLockTimer >= lockDuration) {
                isTargetLocked = false;
                currentLockTimer = 0.0f;
            }
        }
        
        float angleDifference = calculateAngleDifference(targetAngle, currentAngle);
        if (angleDifference <= fovAngle && angleDifference <= detectionRange) {
            adjustAim(targetAngle, currentAngle, angleDifference);
        } else {
            isTargetLocked = false;
        }
    }
    
    private float calculateAngleDifference(float target, float current) {
        return Math.abs(target - current);
    }
    
    private void adjustAim(float targetAngle, float currentAngle, float angleDiff) {
        if (angleDiff < targetLockThreshold) {
            isTargetLocked = true;
            currentLockTimer = 0.0f;
        }
        
        float adjustment = Math.min(maxAngleAdjustment, angleDiff * currentAssistStrength);
        float newAngle = currentAngle + (targetAngle > currentAngle ? adjustment : -adjustment);
        newAngle = smoothAim(currentAngle, newAngle);
        
        applyAimAdjustment(newAngle);
    }
    
    private float smoothAim(float current, float target) {
        return current + (target - current) * aimSmoothing;
    }
    
    private void applyAimAdjustment(float newAngle) {
        
    }
    
    public void setAssistStrength(float strength) {
        currentAssistStrength = Math.max(0.1f, Math.min(1.0f, strength));
    }
    
    public void setMaxAngleAdjustment(float angle) {
        maxAngleAdjustment = angle;
    }
    
    public boolean isTargetLocked() {
        return isTargetLocked;
    }
}

public class AimAssist {
    private float baseAssistStrength = 0.7f;
    private float maxAngleAdjustment = 15.0f;
    private float aimSmoothing = 0.2f;
    private float targetLockThreshold = 0.8f;
    private float lockDuration = 1.5f;
    private float detectionRange = 100.0f;
    private float fovAngle = 60.0f;
    
    private boolean isTargetLocked = false;
    private float currentLockTimer = 0.0f;
    private float currentAssistStrength = baseAssistStrength;
    
    public void update(float deltaTime, float targetAngle, float currentAngle) {
        if (isTargetLocked) {
            currentLockTimer += deltaTime;
            if (currentLockTimer >= lockDuration) {
                isTargetLocked = false;
                currentLockTimer = 0.0f;
            }
        }
        
        float angleDifference = calculateAngleDifference(targetAngle, currentAngle);
        if (angleDifference <= fovAngle && angleDifference <= detectionRange) {
            adjustAim(targetAngle, currentAngle, angleDifference);
        } else {
            isTargetLocked = false;
        }
    }
    
    private float calculateAngleDifference(float target, float current) {
        return Math.abs(target - current);
    }
    
    private void adjustAim(float targetAngle, float currentAngle, float angleDiff) {
        if (angleDiff < targetLockThreshold) {
            isTargetLocked = true;
            currentLockTimer = 0.0f;
        }
        
        float adjustment = Math.min(maxAngleAdjustment, angleDiff * currentAssistStrength);
        float newAngle = currentAngle + (targetAngle > currentAngle ? adjustment : -adjustment);
        newAngle = smoothAim(currentAngle, newAngle);
        
        applyAimAdjustment(newAngle);
    }
    
    private float smoothAim(float current, float target) {
        return current + (target - current) * aimSmoothing;
    }
    
    private void applyAimAdjustment(float newAngle) {
        
    }
    
    public void setAssistStrength(float strength) {
        currentAssistStrength = Math.max(0.1f, Math.min(1.0f, strength));
    }
    
    public void setMaxAngleAdjustment(float angle) {
        maxAngleAdjustment = angle;
    }
    
    public boolean isTargetLocked() {
        return isTargetLocked;
    }
}

public class AimAssist {
    private float baseAssistStrength = 0.7f;
    private float maxAngleAdjustment = 15.0f;
    private float aimSmoothing = 0.2f;
    private float targetLockThreshold = 0.8f;
    private float lockDuration = 1.5f;
    private float detectionRange = 100.0f;
    private float fovAngle = 60.0f;
    
    private boolean isTargetLocked = false;
    private float currentLockTimer = 0.0f;
    private float currentAssistStrength = baseAssistStrength;
    
    public void update(float deltaTime, float targetAngle, float currentAngle) {
        if (isTargetLocked) {
            currentLockTimer += deltaTime;
            if (currentLockTimer >= lockDuration) {
                isTargetLocked = false;
                currentLockTimer = 0.0f;
            }
        }
        
        float angleDifference = calculateAngleDifference(targetAngle, currentAngle);
        if (angleDifference <= fovAngle && angleDifference <= detectionRange) {
            adjustAim(targetAngle, currentAngle, angleDifference);
        } else {
            isTargetLocked = false;
        }
    }
    
    private float calculateAngleDifference(float target, float current) {
        return Math.abs(target - current);
    }
    
    private void adjustAim(float targetAngle, float currentAngle, float angleDiff) {
        if (angleDiff < targetLockThreshold) {
            isTargetLocked = true;
            currentLockTimer = 0.0f;
        }
        
        float adjustment = Math.min(maxAngleAdjustment, angleDiff * currentAssistStrength);
        float newAngle = currentAngle + (targetAngle > currentAngle ? adjustment : -adjustment);
        newAngle = smoothAim(currentAngle, newAngle);
        
        applyAimAdjustment(newAngle);
    }
    
    private float smoothAim(float current, float target) {
        return current + (target - current) * aimSmoothing;
    }
    
    private void applyAimAdjustment(float newAngle) {
        
    }
    
    public void setAssistStrength(float strength) {
        currentAssistStrength = Math.max(0.1f, Math.min(1.0f, strength));
    }
    
    public void setMaxAngleAdjustment(float angle) {
        maxAngleAdjustment = angle;
    }
    
    public boolean isTargetLocked() {
        return isTargetLocked;
    }
}

public class AimAssist {
    private float baseAssistStrength = 0.7f;
    private float maxAngleAdjustment = 15.0f;
    private float aimSmoothing = 0.2f;
    private float targetLockThreshold = 0.8f;
    private float lockDuration = 1.5f;
    private float detectionRange = 100.0f;
    private float fovAngle = 60.0f;
    
    private boolean isTargetLocked = false;
    private float currentLockTimer = 0.0f;
    private float currentAssistStrength = baseAssistStrength;
    
    public void update(float deltaTime, float targetAngle, float currentAngle) {
        if (isTargetLocked) {
            currentLockTimer += deltaTime;
            if (currentLockTimer >= lockDuration) {
                isTargetLocked = false;
                currentLockTimer = 0.0f;
            }
        }
        
        float angleDifference = calculateAngleDifference(targetAngle, currentAngle);
        if (angleDifference <= fovAngle && angleDifference <= detectionRange) {
            adjustAim(targetAngle, currentAngle, angleDifference);
        } else {
            isTargetLocked = false;
        }
    }
    
    private float calculateAngleDifference(float target, float current) {
        return Math.abs(target - current);
    }
    
    private void adjustAim(float targetAngle, float currentAngle, float angleDiff) {
        if (angleDiff < targetLockThreshold) {
            isTargetLocked = true;
            currentLockTimer = 0.0f;
        }
        
        float adjustment = Math.min(maxAngleAdjustment, angleDiff * currentAssistStrength);
        float newAngle = currentAngle + (targetAngle > currentAngle ? adjustment : -adjustment);
        newAngle = smoothAim(currentAngle, newAngle);
        
        applyAimAdjustment(newAngle);
    }
    
    private float smoothAim(float current, float target) {
        return current + (target - current) * aimSmoothing;
    }
    
    private void applyAimAdjustment(float newAngle) {
        
    }
    
    public void setAssistStrength(float strength) {
        currentAssistStrength = Math.max(0.1f, Math.min(1.0f, strength));
    }
    
    public void setMaxAngleAdjustment(float angle) {
        maxAngleAdjustment = angle;
    }
    
    public boolean isTargetLocked() {
        return isTargetLocked;
    }
}

public class AimAssist {
    private float baseAssistStrength = 0.7f;
    private float maxAngleAdjustment = 15.0f;
    private float aimSmoothing = 0.2f;
    private float targetLockThreshold = 0.8f;
    private float lockDuration = 1.5f;
    private float detectionRange = 100.0f;
    private float fovAngle = 60.0f;
    
    private boolean isTargetLocked = false;
    private float currentLockTimer = 0.0f;
    private float currentAssistStrength = baseAssistStrength;
    
    public void update(float deltaTime, float targetAngle, float currentAngle) {
        if (isTargetLocked) {
            currentLockTimer += deltaTime;
            if (currentLockTimer >= lockDuration) {
                isTargetLocked = false;
                currentLockTimer = 0.0f;
            }
        }
        
        float angleDifference = calculateAngleDifference(targetAngle, currentAngle);
        if (angleDifference <= fovAngle && angleDifference <= detectionRange) {
            adjustAim(targetAngle, currentAngle, angleDifference);
        } else {
            isTargetLocked = false;
        }
    }
    
    private float calculateAngleDifference(float target, float current) {
        return Math.abs(target - current);
    }
    
    private void adjustAim(float targetAngle, float currentAngle, float angleDiff) {
        if (angleDiff < targetLockThreshold) {
            isTargetLocked = true;
            currentLockTimer = 0.0f;
        }
        
        float adjustment = Math.min(maxAngleAdjustment, angleDiff * currentAssistStrength);
        float newAngle = currentAngle + (targetAngle > currentAngle ? adjustment : -adjustment);
        newAngle = smoothAim(currentAngle, newAngle);
        
        applyAimAdjustment(newAngle);
    }
    
    private float smoothAim(float current, float target) {
        return current + (target - current) * aimSmoothing;
    }
    
    private void applyAimAdjustment(float newAngle) {
        
    }
    
    public void setAssistStrength(float strength) {
        currentAssistStrength = Math.max(0.1f, Math.min(1.0f, strength));
    }
    
    public void setMaxAngleAdjustment(float angle) {
        maxAngleAdjustment = angle;
    }
    
    public boolean isTargetLocked() {
        return isTargetLocked;
    }
}

public class AimAssist {
    private float baseAssistStrength = 0.7f;
    private float maxAngleAdjustment = 15.0f;
    private float aimSmoothing = 0.2f;
    private float targetLockThreshold = 0.8f;
    private float lockDuration = 1.5f;
    private float detectionRange = 100.0f;
    private float fovAngle = 60.0f;
    
    private boolean isTargetLocked = false;
    private float currentLockTimer = 0.0f;
    private float currentAssistStrength = baseAssistStrength;
    
    public void update(float deltaTime, float targetAngle, float currentAngle) {
        if (isTargetLocked) {
            currentLockTimer += deltaTime;
            if (currentLockTimer >= lockDuration) {
                isTargetLocked = false;
                currentLockTimer = 0.0f;
            }
        }
        
        float angleDifference = calculateAngleDifference(targetAngle, currentAngle);
        if (angleDifference <= fovAngle && angleDifference <= detectionRange) {
            adjustAim(targetAngle, currentAngle, angleDifference);
        } else {
            isTargetLocked = false;
        }
    }
    
    private float calculateAngleDifference(float target, float current) {
        return Math.abs(target - current);
    }
    
    private void adjustAim(float targetAngle, float currentAngle, float angleDiff) {
        if (angleDiff < targetLockThreshold) {
            isTargetLocked = true;
            currentLockTimer = 0.0f;
        }
        
        float adjustment = Math.min(maxAngleAdjustment, angleDiff * currentAssistStrength);
        float newAngle = currentAngle + (targetAngle > currentAngle ? adjustment : -adjustment);
        newAngle = smoothAim(currentAngle, newAngle);
        
        applyAimAdjustment(newAngle);
    }
    
    private float smoothAim(float current, float target) {
        return current + (target - current) * aimSmoothing;
    }
    
    private void applyAimAdjustment(float newAngle) {
        
    }
    
    public void setAssistStrength(float strength) {
        currentAssistStrength = Math.max(0.1f, Math.min(1.0f, strength));
    }
    
    public void setMaxAngleAdjustment(float angle) {
        maxAngleAdjustment = angle;
    }
    
    public boolean isTargetLocked() {
        return isTargetLocked;
    }
}

public class AimAssist {
    private float baseAssistStrength = 0.7f;
    private float maxAngleAdjustment = 15.0f;
    private float aimSmoothing = 0.2f;
    private float targetLockThreshold = 0.8f;
    private float lockDuration = 1.5f;
    private float detectionRange = 100.0f;
    private float fovAngle = 60.0f;
    
    private boolean isTargetLocked = false;
    private float currentLockTimer = 0.0f;
    private float currentAssistStrength = baseAssistStrength;
    
    public void update(float deltaTime, float targetAngle, float currentAngle) {
        if (isTargetLocked) {
            currentLockTimer += deltaTime;
            if (currentLockTimer >= lockDuration) {
                isTargetLocked = false;
                currentLockTimer = 0.0f;
            }
        }
        
        float angleDifference = calculateAngleDifference(targetAngle, currentAngle);
        if (angleDifference <= fovAngle && angleDifference <= detectionRange) {
            adjustAim(targetAngle, currentAngle, angleDifference);
        } else {
            isTargetLocked = false;
        }
    }
    
    private float calculateAngleDifference(float target, float current) {
        return Math.abs(target - current);
    }
    
    private void adjustAim(float targetAngle, float currentAngle, float angleDiff) {
        if (angleDiff < targetLockThreshold) {
            isTargetLocked = true;
            currentLockTimer = 0.0f;
        }
        
        float adjustment = Math.min(maxAngleAdjustment, angleDiff * currentAssistStrength);
        float newAngle = currentAngle + (targetAngle > currentAngle ? adjustment : -adjustment);
        newAngle = smoothAim(currentAngle, newAngle);
        
        applyAimAdjustment(newAngle);
    }
    
    private float smoothAim(float current, float target) {
        return current + (target - current) * aimSmoothing;
    }
    
    private void applyAimAdjustment(float newAngle) {
        
    }
    
    public void setAssistStrength(float strength) {
        currentAssistStrength = Math.max(0.1f, Math.min(1.0f, strength));
    }
    
    public void setMaxAngleAdjustment(float angle) {
        maxAngleAdjustment = angle;
    }
    
    public boolean isTargetLocked() {
        return isTargetLocked;
    }
}

public class AimAssist {
    private float baseAssistStrength = 0.7f;
    private float maxAngleAdjustment = 15.0f;
    private float aimSmoothing = 0.2f;
    private float targetLockThreshold = 0.8f;
    private float lockDuration = 1.5f;
    private float detectionRange = 100.0f;
    private float fovAngle = 60.0f;
    
    private boolean isTargetLocked = false;
    private float currentLockTimer = 0.0f;
    private float currentAssistStrength = baseAssistStrength;
    
    public void update(float deltaTime, float targetAngle, float currentAngle) {
        if (isTargetLocked) {
            currentLockTimer += deltaTime;
            if (currentLockTimer >= lockDuration) {
                isTargetLocked = false;
                currentLockTimer = 0.0f;
            }
        }
        
        float angleDifference = calculateAngleDifference(targetAngle, currentAngle);
        if (angleDifference <= fovAngle && angleDifference <= detectionRange) {
            adjustAim(targetAngle, currentAngle, angleDifference);
        } else {
            isTargetLocked = false;
        }
    }
    
    private float calculateAngleDifference(float target, float current) {
        return Math.abs(target - current);
    }
    
    private void adjustAim(float targetAngle, float currentAngle, float angleDiff) {
        if (angleDiff < targetLockThreshold) {
            isTargetLocked = true;
            currentLockTimer = 0.0f;
        }
        
        float adjustment = Math.min(maxAngleAdjustment, angleDiff * currentAssistStrength);
        float newAngle = currentAngle + (targetAngle > currentAngle ? adjustment : -adjustment);
        newAngle = smoothAim(currentAngle, newAngle);
        
        applyAimAdjustment(newAngle);
    }
    
    private float smoothAim(float current, float target) {
        return current + (target - current) * aimSmoothing;
    }
    
    private void applyAimAdjustment(float newAngle) {
        
    }
    
    public void setAssistStrength(float strength) {
        currentAssistStrength = Math.max(0.1f, Math.min(1.0f, strength));
    }
    
    public void setMaxAngleAdjustment(float angle) {
        maxAngleAdjustment = angle;
    }
    
    public boolean isTargetLocked() {
        return isTargetLocked;
    }
}

public class AimAssist {
    private float baseAssistStrength = 0.7f;
    private float maxAngleAdjustment = 15.0f;
    private float aimSmoothing = 0.2f;
    private float targetLockThreshold = 0.8f;
    private float lockDuration = 1.5f;
    private float detectionRange = 100.0f;
    private float fovAngle = 60.0f;
    
    private boolean isTargetLocked = false;
    private float currentLockTimer = 0.0f;
    private float currentAssistStrength = baseAssistStrength;
    
    public void update(float deltaTime, float targetAngle, float currentAngle) {
        if (isTargetLocked) {
            currentLockTimer += deltaTime;
            if (currentLockTimer >= lockDuration) {
                isTargetLocked = false;
                currentLockTimer = 0.0f;
            }
        }
        
        float angleDifference = calculateAngleDifference(targetAngle, currentAngle);
        if (angleDifference <= fovAngle && angleDifference <= detectionRange) {
            adjustAim(targetAngle, currentAngle, angleDifference);
        } else {
            isTargetLocked = false;
        }
    }
    
    private float calculateAngleDifference(float target, float current) {
        return Math.abs(target - current);
    }
    
    private void adjustAim(float targetAngle, float currentAngle, float angleDiff) {
        if (angleDiff < targetLockThreshold) {
            isTargetLocked = true;
            currentLockTimer = 0.0f;
        }
        
        float adjustment = Math.min(maxAngleAdjustment, angleDiff * currentAssistStrength);
        float newAngle = currentAngle + (targetAngle > currentAngle ? adjustment : -adjustment);
        newAngle = smoothAim(currentAngle, newAngle);
        
        applyAimAdjustment(newAngle);
    }
    
    private float smoothAim(float current, float target) {
        return current + (target - current) * aimSmoothing;
    }
    
    private void applyAimAdjustment(float newAngle) {
        
    }
    
    public void setAssistStrength(float strength) {
        currentAssistStrength = Math.max(0.1f, Math.min(1.0f, strength));
    }
    
    public void setMaxAngleAdjustment(float angle) {
        maxAngleAdjustment = angle;
    }
    
    public boolean isTargetLocked() {
        return isTargetLocked;
    }
}

public class AimAssist {
    private float baseAssistStrength = 0.7f;
    private float maxAngleAdjustment = 15.0f;
    private float aimSmoothing = 0.2f;
    private float targetLockThreshold = 0.8f;
    private float lockDuration = 1.5f;
    private float detectionRange = 100.0f;
    private float fovAngle = 60.0f;
    
    private boolean isTargetLocked = false;
    private float currentLockTimer = 0.0f;
    private float currentAssistStrength = baseAssistStrength;
    
    public void update(float deltaTime, float targetAngle, float currentAngle) {
        if (isTargetLocked) {
            currentLockTimer += deltaTime;
            if (currentLockTimer >= lockDuration) {
                isTargetLocked = false;
                currentLockTimer = 0.0f;
            }
        }
        
        float angleDifference = calculateAngleDifference(targetAngle, currentAngle);
        if (angleDifference <= fovAngle && angleDifference <= detectionRange) {
            adjustAim(targetAngle, currentAngle, angleDifference);
        } else {
            isTargetLocked = false;
        }
    }
    
    private float calculateAngleDifference(float target, float current) {
        return Math.abs(target - current);
    }
    
    private void adjustAim(float targetAngle, float currentAngle, float angleDiff) {
        if (angleDiff < targetLockThreshold) {
            isTargetLocked = true;
            currentLockTimer = 0.0f;
        }
        
        float adjustment = Math.min(maxAngleAdjustment, angleDiff * currentAssistStrength);
        float newAngle = currentAngle + (targetAngle > currentAngle ? adjustment : -adjustment);
        newAngle = smoothAim(currentAngle, newAngle);
        
        applyAimAdjustment(newAngle);
    }
    
    private float smoothAim(float current, float target) {
        return current + (target - current) * aimSmoothing;
    }
    
    private void applyAimAdjustment(float newAngle) {
        
    }
    
    public void setAssistStrength(float strength) {
        currentAssistStrength = Math.max(0.1f, Math.min(1.0f, strength));
    }
    
    public void setMaxAngleAdjustment(float angle) {
        maxAngleAdjustment = angle;
    }
    
    public boolean isTargetLocked() {
        return isTargetLocked;
    }
}

public class AimAssist {
    private float baseAssistStrength = 0.7f;
    private float maxAngleAdjustment = 15.0f;
    private float aimSmoothing = 0.2f;
    private float targetLockThreshold = 0.8f;
    private float lockDuration = 1.5f;
    private float detectionRange = 100.0f;
    private float fovAngle = 60.0f;
    
    private boolean isTargetLocked = false;
    private float currentLockTimer = 0.0f;
    private float currentAssistStrength = baseAssistStrength;
    
    public void update(float deltaTime, float targetAngle, float currentAngle) {
        if (isTargetLocked) {
            currentLockTimer += deltaTime;
            if (currentLockTimer >= lockDuration) {
                isTargetLocked = false;
                currentLockTimer = 0.0f;
            }
        }
        
        float angleDifference = calculateAngleDifference(targetAngle, currentAngle);
        if (angleDifference <= fovAngle && angleDifference <= detectionRange) {
            adjustAim(targetAngle, currentAngle, angleDifference);
        } else {
            isTargetLocked = false;
        }
    }
    
    private float calculateAngleDifference(float target, float current) {
        return Math.abs(target - current);
    }
    
    private void adjustAim(float targetAngle, float currentAngle, float angleDiff) {
        if (angleDiff < targetLockThreshold) {
            isTargetLocked = true;
            currentLockTimer = 0.0f;
        }
        
        float adjustment = Math.min(maxAngleAdjustment, angleDiff * currentAssistStrength);
        float newAngle = currentAngle + (targetAngle > currentAngle ? adjustment : -adjustment);
        newAngle = smoothAim(currentAngle, newAngle);
        
        applyAimAdjustment(newAngle);
    }
    
    private float smoothAim(float current, float target) {
        return current + (target - current) * aimSmoothing;
    }
    
    private void applyAimAdjustment(float newAngle) {
        
    }
    
    public void setAssistStrength(float strength) {
        currentAssistStrength = Math.max(0.1f, Math.min(1.0f, strength));
    }
    
    public void setMaxAngleAdjustment(float angle) {
        maxAngleAdjustment = angle;
    }
    
    public boolean isTargetLocked() {
        return isTargetLocked;
    }
}

public class AimAssist {
    private float baseAssistStrength = 0.7f;
    private float maxAngleAdjustment = 15.0f;
    private float aimSmoothing = 0.2f;
    private float targetLockThreshold = 0.8f;
    private float lockDuration = 1.5f;
    private float detectionRange = 100.0f;
    private float fovAngle = 60.0f;
    
    private boolean isTargetLocked = false;
    private float currentLockTimer = 0.0f;
    private float currentAssistStrength = baseAssistStrength;
    
    public void update(float deltaTime, float targetAngle, float currentAngle) {
        if (isTargetLocked) {
            currentLockTimer += deltaTime;
            if (currentLockTimer >= lockDuration) {
                isTargetLocked = false;
                currentLockTimer = 0.0f;
            }
        }
        
        float angleDifference = calculateAngleDifference(targetAngle, currentAngle);
        if (angleDifference <= fovAngle && angleDifference <= detectionRange) {
            adjustAim(targetAngle, currentAngle, angleDifference);
        } else {
            isTargetLocked = false;
        }
    }
    
    private float calculateAngleDifference(float target, float current) {
        return Math.abs(target - current);
    }
    
    private void adjustAim(float targetAngle, float currentAngle, float angleDiff) {
        if (angleDiff < targetLockThreshold) {
            isTargetLocked = true;
            currentLockTimer = 0.0f;
        }
        
        float adjustment = Math.min(maxAngleAdjustment, angleDiff * currentAssistStrength);
        float newAngle = currentAngle + (targetAngle > currentAngle ? adjustment : -adjustment);
        newAngle = smoothAim(currentAngle, newAngle);
        
        applyAimAdjustment(newAngle);
    }
    
    private float smoothAim(float current, float target) {
        return current + (target - current) * aimSmoothing;
    }
    
    private void applyAimAdjustment(float newAngle) {
        
    }
    
    public void setAssistStrength(float strength) {
        currentAssistStrength = Math.max(0.1f, Math.min(1.0f, strength));
    }
    
    public void setMaxAngleAdjustment(float angle) {
        maxAngleAdjustment = angle;
    }
    
    public boolean isTargetLocked() {
        return isTargetLocked;
    }
}

public class AimAssist {
    private float baseAssistStrength = 0.7f;
    private float maxAngleAdjustment = 15.0f;
    private float aimSmoothing = 0.2f;
    private float targetLockThreshold = 0.8f;
    private float lockDuration = 1.5f;
    private float detectionRange = 100.0f;
    private float fovAngle = 60.0f;
    
    private boolean isTargetLocked = false;
    private float currentLockTimer = 0.0f;
    private float currentAssistStrength = baseAssistStrength;
    
    public void update(float deltaTime, float targetAngle, float currentAngle) {
        if (isTargetLocked) {
            currentLockTimer += deltaTime;
            if (currentLockTimer >= lockDuration) {
                isTargetLocked = false;
                currentLockTimer = 0.0f;
            }
        }
        
        float angleDifference = calculateAngleDifference(targetAngle, currentAngle);
        if (angleDifference <= fovAngle && angleDifference <= detectionRange) {
            adjustAim(targetAngle, currentAngle, angleDifference);
        } else {
            isTargetLocked = false;
        }
    }
    
    private float calculateAngleDifference(float target, float current) {
        return Math.abs(target - current);
    }
    
    private void adjustAim(float targetAngle, float currentAngle, float angleDiff) {
        if (angleDiff < targetLockThreshold) {
            isTargetLocked = true;
            currentLockTimer = 0.0f;
        }
        
        float adjustment = Math.min(maxAngleAdjustment, angleDiff * currentAssistStrength);
        float newAngle = currentAngle + (targetAngle > currentAngle ? adjustment : -adjustment);
        newAngle = smoothAim(currentAngle, newAngle);
        
        applyAimAdjustment(newAngle);
    }
    
    private float smoothAim(float current, float target) {
        return current + (target - current) * aimSmoothing;
    }
    
    private void applyAimAdjustment(float newAngle) {
        
    }
    
    public void setAssistStrength(float strength) {
        currentAssistStrength = Math.max(0.1f, Math.min(1.0f, strength));
    }
    
    public void setMaxAngleAdjustment(float angle) {
        maxAngleAdjustment = angle;
    }
    
    public boolean isTargetLocked() {
        return isTargetLocked;
    }
}

public class AimAssist {
    private float baseAssistStrength = 0.7f;
    private float maxAngleAdjustment = 15.0f;
    private float aimSmoothing = 0.2f;
    private float targetLockThreshold = 0.8f;
    private float lockDuration = 1.5f;
    private float detectionRange = 100.0f;
    private float fovAngle = 60.0f;
    
    private boolean isTargetLocked = false;
    private float currentLockTimer = 0.0f;
    private float currentAssistStrength = baseAssistStrength;
    
    public void update(float deltaTime, float targetAngle, float currentAngle) {
        if (isTargetLocked) {
            currentLockTimer += deltaTime;
            if (currentLockTimer >= lockDuration) {
                isTargetLocked = false;
                currentLockTimer = 0.0f;
            }
        }
        
        float angleDifference = calculateAngleDifference(targetAngle, currentAngle);
        if (angleDifference <= fovAngle && angleDifference <= detectionRange) {
            adjustAim(targetAngle, currentAngle, angleDifference);
        } else {
            isTargetLocked = false;
        }
    }
    
    private float calculateAngleDifference(float target, float current) {
        return Math.abs(target - current);
    }
    
    private void adjustAim(float targetAngle, float currentAngle, float angleDiff) {
        if (angleDiff < targetLockThreshold) {
            isTargetLocked = true;
            currentLockTimer = 0.0f;
        }
        
        float adjustment = Math.min(maxAngleAdjustment, angleDiff * currentAssistStrength);
        float newAngle = currentAngle + (targetAngle > currentAngle ? adjustment : -adjustment);
        newAngle = smoothAim(currentAngle, newAngle);
        
        applyAimAdjustment(newAngle);
    }
    
    private float smoothAim(float current, float target) {
        return current + (target - current) * aimSmoothing;
    }
    
    private void applyAimAdjustment(float newAngle) {
        
    }
    
    public void setAssistStrength(float strength) {
        currentAssistStrength = Math.max(0.1f, Math.min(1.0f, strength));
    }
    
    public void setMaxAngleAdjustment(float angle) {
        maxAngleAdjustment = angle;
    }
    
    public boolean isTargetLocked() {
        return isTargetLocked;
    }
}

public class AimAssist {
    private float baseAssistStrength = 0.7f;
    private float maxAngleAdjustment = 15.0f;
    private float aimSmoothing = 0.2f;
    private float targetLockThreshold = 0.8f;
    private float lockDuration = 1.5f;
    private float detectionRange = 100.0f;
    private float fovAngle = 60.0f;
    
    private boolean isTargetLocked = false;
    private float currentLockTimer = 0.0f;
    private float currentAssistStrength = baseAssistStrength;
    
    public void update(float deltaTime, float targetAngle, float currentAngle) {
        if (isTargetLocked) {
            currentLockTimer += deltaTime;
            if (currentLockTimer >= lockDuration) {
                isTargetLocked = false;
                currentLockTimer = 0.0f;
            }
        }
        
        float angleDifference = calculateAngleDifference(targetAngle, currentAngle);
        if (angleDifference <= fovAngle && angleDifference <= detectionRange) {
            adjustAim(targetAngle, currentAngle, angleDifference);
        } else {
            isTargetLocked = false;
        }
    }
    
    private float calculateAngleDifference(float target, float current) {
        return Math.abs(target - current);
    }
    
    private void adjustAim(float targetAngle, float currentAngle, float angleDiff) {
        if (angleDiff < targetLockThreshold) {
            isTargetLocked = true;
            currentLockTimer = 0.0f;
        }
        
        float adjustment = Math.min(maxAngleAdjustment, angleDiff * currentAssistStrength);
        float newAngle = currentAngle + (targetAngle > currentAngle ? adjustment : -adjustment);
        newAngle = smoothAim(currentAngle, newAngle);
        
        applyAimAdjustment(newAngle);
    }
    
    private float smoothAim(float current, float target) {
        return current + (target - current) * aimSmoothing;
    }
    
    private void applyAimAdjustment(float newAngle) {
        
    }
    
    public void setAssistStrength(float strength) {
        currentAssistStrength = Math.max(0.1f, Math.min(1.0f, strength));
    }
    
    public void setMaxAngleAdjustment(float angle) {
        maxAngleAdjustment = angle;
    }
    
    public boolean isTargetLocked() {
        return isTargetLocked;
    }
}

public class AimAssist {
    private float baseAssistStrength = 0.7f;
    private float maxAngleAdjustment = 15.0f;
    private float aimSmoothing = 0.2f;
    private float targetLockThreshold = 0.8f;
    private float lockDuration = 1.5f;
    private float detectionRange = 100.0f;
    private float fovAngle = 60.0f;
    
    private boolean isTargetLocked = false;
    private float currentLockTimer = 0.0f;
    private float currentAssistStrength = baseAssistStrength;
    
    public void update(float deltaTime, float targetAngle, float currentAngle) {
        if (isTargetLocked) {
            currentLockTimer += deltaTime;
            if (currentLockTimer >= lockDuration) {
                isTargetLocked = false;
                currentLockTimer = 0.0f;
            }
        }
        
        float angleDifference = calculateAngleDifference(targetAngle, currentAngle);
        if (angleDifference <= fovAngle && angleDifference <= detectionRange) {
            adjustAim(targetAngle, currentAngle, angleDifference);
        } else {
            isTargetLocked = false;
        }
    }
    
    private float calculateAngleDifference(float target, float current) {
        return Math.abs(target - current);
    }
    
    private void adjustAim(float targetAngle, float currentAngle, float angleDiff) {
        if (angleDiff < targetLockThreshold) {
            isTargetLocked = true;
            currentLockTimer = 0.0f;
        }
        
        float adjustment = Math.min(maxAngleAdjustment, angleDiff * currentAssistStrength);
        float newAngle = currentAngle + (targetAngle > currentAngle ? adjustment : -adjustment);
        newAngle = smoothAim(currentAngle, newAngle);
        
        applyAimAdjustment(newAngle);
    }
    
    private float smoothAim(float current, float target) {
        return current + (target - current) * aimSmoothing;
    }
    
    private void applyAimAdjustment(float newAngle) {
        
    }
    
    public void setAssistStrength(float strength) {
        currentAssistStrength = Math.max(0.1f, Math.min(1.0f, strength));
    }
    
    public void setMaxAngleAdjustment(float angle) {
        maxAngleAdjustment = angle;
    }
    
    public boolean isTargetLocked() {
        return isTargetLocked;
    }
}

public class AimAssist {
    private float baseAssistStrength = 0.7f;
    private float maxAngleAdjustment = 15.0f;
    private float aimSmoothing = 0.2f;
    private float targetLockThreshold = 0.8f;
    private float lockDuration = 1.5f;
    private float detectionRange = 100.0f;
    private float fovAngle = 60.0f;
    
    private boolean isTargetLocked = false;
    private float currentLockTimer = 0.0f;
    private float currentAssistStrength = baseAssistStrength;
    
    public void update(float deltaTime, float targetAngle, float currentAngle) {
        if (isTargetLocked) {
            currentLockTimer += deltaTime;
            if (currentLockTimer >= lockDuration) {
                isTargetLocked = false;
                currentLockTimer = 0.0f;
            }
        }
        
        float angleDifference = calculateAngleDifference(targetAngle, currentAngle);
        if (angleDifference <= fovAngle && angleDifference <= detectionRange) {
            adjustAim(targetAngle, currentAngle, angleDifference);
        } else {
            isTargetLocked = false;
        }
    }
    
    private float calculateAngleDifference(float target, float current) {
        return Math.abs(target - current);
    }
    
    private void adjustAim(float targetAngle, float currentAngle, float angleDiff) {
        if (angleDiff < targetLockThreshold) {
            isTargetLocked = true;
            currentLockTimer = 0.0f;
        }
        
        float adjustment = Math.min(maxAngleAdjustment, angleDiff * currentAssistStrength);
        float newAngle = currentAngle + (targetAngle > currentAngle ? adjustment : -adjustment);
        newAngle = smoothAim(currentAngle, newAngle);
        
        applyAimAdjustment(newAngle);
    }
    
    private float smoothAim(float current, float target) {
        return current + (target - current) * aimSmoothing;
    }
    
    private void applyAimAdjustment(float newAngle) {
        
    }
    
    public void setAssistStrength(float strength) {
        currentAssistStrength = Math.max(0.1f, Math.min(1.0f, strength));
    }
    
    public void setMaxAngleAdjustment(float angle) {
        maxAngleAdjustment = angle;
    }
    
    public boolean isTargetLocked() {
        return isTargetLocked;
    }
}

public class AimAssist {
    private float baseAssistStrength = 0.7f;
    private float maxAngleAdjustment = 15.0f;
    private float aimSmoothing = 0.2f;
    private float targetLockThreshold = 0.8f;
    private float lockDuration = 1.5f;
    private float detectionRange = 100.0f;
    private float fovAngle = 60.0f;
    
    private boolean isTargetLocked = false;
    private float currentLockTimer = 0.0f;
    private float currentAssistStrength = baseAssistStrength;
    
    public void update(float deltaTime, float targetAngle, float currentAngle) {
        if (isTargetLocked) {
            currentLockTimer += deltaTime;
            if (currentLockTimer >= lockDuration) {
                isTargetLocked = false;
                currentLockTimer = 0.0f;
            }
        }
        
        float angleDifference = calculateAngleDifference(targetAngle, currentAngle);
        if (angleDifference <= fovAngle && angleDifference <= detectionRange) {
            adjustAim(targetAngle, currentAngle, angleDifference);
        } else {
            isTargetLocked = false;
        }
    }
    
    private float calculateAngleDifference(float target, float current) {
        return Math.abs(target - current);
    }
    
    private void adjustAim(float targetAngle, float currentAngle, float angleDiff) {
        if (angleDiff < targetLockThreshold) {
            isTargetLocked = true;
            currentLockTimer = 0.0f;
        }
        
        float adjustment = Math.min(maxAngleAdjustment, angleDiff * currentAssistStrength);
        float newAngle = currentAngle + (targetAngle > currentAngle ? adjustment : -adjustment);
        newAngle = smoothAim(currentAngle, newAngle);
        
        applyAimAdjustment(newAngle);
    }
    
    private float smoothAim(float current, float target) {
        return current + (target - current) * aimSmoothing;
    }
    
    private void applyAimAdjustment(float newAngle) {
        
    }
    
    public void setAssistStrength(float strength) {
        currentAssistStrength = Math.max(0.1f, Math.min(1.0f, strength));
    }
    
    public void setMaxAngleAdjustment(float angle) {
        maxAngleAdjustment = angle;
    }
    
    public boolean isTargetLocked() {
        return isTargetLocked;
    }
}

public class AimAssist {
    private float baseAssistStrength = 0.7f;
    private float maxAngleAdjustment = 15.0f;
    private float aimSmoothing = 0.2f;
    private float targetLockThreshold = 0.8f;
    private float lockDuration = 1.5f;
    private float detectionRange = 100.0f;
    private float fovAngle = 60.0f;
    
    private boolean isTargetLocked = false;
    private float currentLockTimer = 0.0f;
    private float currentAssistStrength = baseAssistStrength;
    
    public void update(float deltaTime, float targetAngle, float currentAngle) {
        if (isTargetLocked) {
            currentLockTimer += deltaTime;
            if (currentLockTimer >= lockDuration) {
                isTargetLocked = false;
                currentLockTimer = 0.0f;
            }
        }
        
        float angleDifference = calculateAngleDifference(targetAngle, currentAngle);
        if (angleDifference <= fovAngle && angleDifference <= detectionRange) {
            adjustAim(targetAngle, currentAngle, angleDifference);
        } else {
            isTargetLocked = false;
        }
    }
    
    private float calculateAngleDifference(float target, float current) {
        return Math.abs(target - current);
    }
    
    private void adjustAim(float targetAngle, float currentAngle, float angleDiff) {
        if (angleDiff < targetLockThreshold) {
            isTargetLocked = true;
            currentLockTimer = 0.0f;
        }
        
        float adjustment = Math.min(maxAngleAdjustment, angleDiff * currentAssistStrength);
        float newAngle = currentAngle + (targetAngle > currentAngle ? adjustment : -adjustment);
        newAngle = smoothAim(currentAngle, newAngle);
        
        applyAimAdjustment(newAngle);
    }
    
    private float smoothAim(float current, float target) {
        return current + (target - current) * aimSmoothing;
    }
    
    private void applyAimAdjustment(float newAngle) {
        
    }
    
    public void setAssistStrength(float strength) {
        currentAssistStrength = Math.max(0.1f, Math.min(1.0f, strength));
    }
    
    public void setMaxAngleAdjustment(float angle) {
        maxAngleAdjustment = angle;
    }
    
    public boolean isTargetLocked() {
        return isTargetLocked;
    }
}

public class AimAssist {
    private float baseAssistStrength = 0.7f;
    private float maxAngleAdjustment = 15.0f;
    private float aimSmoothing = 0.2f;
    private float targetLockThreshold = 0.8f;
    private float lockDuration = 1.5f;
    private float detectionRange = 100.0f;
    private float fovAngle = 60.0f;
    
    private boolean isTargetLocked = false;
    private float currentLockTimer = 0.0f;
    private float currentAssistStrength = baseAssistStrength;
    
    public void update(float deltaTime, float targetAngle, float currentAngle) {
        if (isTargetLocked) {
            currentLockTimer += deltaTime;
            if (currentLockTimer >= lockDuration) {
                isTargetLocked = false;
                currentLockTimer = 0.0f;
            }
        }
        
        float angleDifference = calculateAngleDifference(targetAngle, currentAngle);
        if (angleDifference <= fovAngle && angleDifference <= detectionRange) {
            adjustAim(targetAngle, currentAngle, angleDifference);
        } else {
            isTargetLocked = false;
        }
    }
    
    private float calculateAngleDifference(float target, float current) {
        return Math.abs(target - current);
    }
    
    private void adjustAim(float targetAngle, float currentAngle, float angleDiff) {
        if (angleDiff < targetLockThreshold) {
            isTargetLocked = true;
            currentLockTimer = 0.0f;
        }
        
        float adjustment = Math.min(maxAngleAdjustment, angleDiff * currentAssistStrength);
        float newAngle = currentAngle + (targetAngle > currentAngle ? adjustment : -adjustment);
        newAngle = smoothAim(currentAngle, newAngle);
        
        applyAimAdjustment(newAngle);
    }
    
    private float smoothAim(float current, float target) {
        return current + (target - current) * aimSmoothing;
    }
    
    private void applyAimAdjustment(float newAngle) {
        
    }
    
    public void setAssistStrength(float strength) {
        currentAssistStrength = Math.max(0.1f, Math.min(1.0f, strength));
    }
    
    public void setMaxAngleAdjustment(float angle) {
        maxAngleAdjustment = angle;
    }
    
    public boolean isTargetLocked() {
        return isTargetLocked;
    }
}

public class AimAssist {
    private float baseAssistStrength = 0.7f;
    private float maxAngleAdjustment = 15.0f;
    private float aimSmoothing = 0.2f;
    private float targetLockThreshold = 0.8f;
    private float lockDuration = 1.5f;
    private float detectionRange = 100.0f;
    private float fovAngle = 60.0f;
    
    private boolean isTargetLocked = false;
    private float currentLockTimer = 0.0f;
    private float currentAssistStrength = baseAssistStrength;
    
    public void update(float deltaTime, float targetAngle, float currentAngle) {
        if (isTargetLocked) {
            currentLockTimer += deltaTime;
            if (currentLockTimer >= lockDuration) {
                isTargetLocked = false;
                currentLockTimer = 0.0f;
            }
        }
        
        float angleDifference = calculateAngleDifference(targetAngle, currentAngle);
        if (angleDifference <= fovAngle && angleDifference <= detectionRange) {
            adjustAim(targetAngle, currentAngle, angleDifference);
        } else {
            isTargetLocked = false;
        }
    }
    
    private float calculateAngleDifference(float target, float current) {
        return Math.abs(target - current);
    }
    
    private void adjustAim(float targetAngle, float currentAngle, float angleDiff) {
        if (angleDiff < targetLockThreshold) {
            isTargetLocked = true;
            currentLockTimer = 0.0f;
        }
        
        float adjustment = Math.min(maxAngleAdjustment, angleDiff * currentAssistStrength);
        float newAngle = currentAngle + (targetAngle > currentAngle ? adjustment : -adjustment);
        newAngle = smoothAim(currentAngle, newAngle);
        
        applyAimAdjustment(newAngle);
    }
    
    private float smoothAim(float current, float target) {
        return current + (target - current) * aimSmoothing;
    }
    
    private void applyAimAdjustment(float newAngle) {
        
    }
    
    public void setAssistStrength(float strength) {
        currentAssistStrength = Math.max(0.1f, Math.min(1.0f, strength));
    }
    
    public void setMaxAngleAdjustment(float angle) {
        maxAngleAdjustment = angle;
    }
    
    public boolean isTargetLocked() {
        return isTargetLocked;
    }
}

public class AimAssist {
    private float baseAssistStrength = 0.7f;
    private float maxAngleAdjustment = 15.0f;
    private float aimSmoothing = 0.2f;
    private float targetLockThreshold = 0.8f;
    private float lockDuration = 1.5f;
    private float detectionRange = 100.0f;
    private float fovAngle = 60.0f;
    
    private boolean isTargetLocked = false;
    private float currentLockTimer = 0.0f;
    private float currentAssistStrength = baseAssistStrength;
    
    public void update(float deltaTime, float targetAngle, float currentAngle) {
        if (isTargetLocked) {
            currentLockTimer += deltaTime;
            if (currentLockTimer >= lockDuration) {
                isTargetLocked = false;
                currentLockTimer = 0.0f;
            }
        }
        
        float angleDifference = calculateAngleDifference(targetAngle, currentAngle);
        if (angleDifference <= fovAngle && angleDifference <= detectionRange) {
            adjustAim(targetAngle, currentAngle, angleDifference);
        } else {
            isTargetLocked = false;
        }
    }
    
    private float calculateAngleDifference(float target, float current) {
        return Math.abs(target - current);
    }
    
    private void adjustAim(float targetAngle, float currentAngle, float angleDiff) {
        if (angleDiff < targetLockThreshold) {
            isTargetLocked = true;
            currentLockTimer = 0.0f;
        }
        
        float adjustment = Math.min(maxAngleAdjustment, angleDiff * currentAssistStrength);
        float newAngle = currentAngle + (targetAngle > currentAngle ? adjustment : -adjustment);
        newAngle = smoothAim(currentAngle, newAngle);
        
        applyAimAdjustment(newAngle);
    }
    
    private float smoothAim(float current, float target) {
        return current + (target - current) * aimSmoothing;
    }
    
    private void applyAimAdjustment(float newAngle) {
        
    }
    
    public void setAssistStrength(float strength) {
        currentAssistStrength = Math.max(0.1f, Math.min(1.0f, strength));
    }
    
    public void setMaxAngleAdjustment(float angle) {
        maxAngleAdjustment = angle;
    }
    
    public boolean isTargetLocked() {
        return isTargetLocked;
    }
}

public class AimAssist {
    private float baseAssistStrength = 0.7f;
    private float maxAngleAdjustment = 15.0f;
    private float aimSmoothing = 0.2f;
    private float targetLockThreshold = 0.8f;
    private float lockDuration = 1.5f;
    private float detectionRange = 100.0f;
    private float fovAngle = 60.0f;
    
    private boolean isTargetLocked = false;
    private float currentLockTimer = 0.0f;
    private float currentAssistStrength = baseAssistStrength;
    
    public void update(float deltaTime, float targetAngle, float currentAngle) {
        if (isTargetLocked) {
            currentLockTimer += deltaTime;
            if (currentLockTimer >= lockDuration) {
                isTargetLocked = false;
                currentLockTimer = 0.0f;
            }
        }
        
        float angleDifference = calculateAngleDifference(targetAngle, currentAngle);
        if (angleDifference <= fovAngle && angleDifference <= detectionRange) {
            adjustAim(targetAngle, currentAngle, angleDifference);
        } else {
            isTargetLocked = false;
        }
    }
    
    private float calculateAngleDifference(float target, float current) {
        return Math.abs(target - current);
    }
    
    private void adjustAim(float targetAngle, float currentAngle, float angleDiff) {
        if (angleDiff < targetLockThreshold) {
            isTargetLocked = true;
            currentLockTimer = 0.0f;
        }
        
        float adjustment = Math.min(maxAngleAdjustment, angleDiff * currentAssistStrength);
        float newAngle = currentAngle + (targetAngle > currentAngle ? adjustment : -adjustment);
        newAngle = smoothAim(currentAngle, newAngle);
        
        applyAimAdjustment(newAngle);
    }
    
    private float smoothAim(float current, float target) {
        return current + (target - current) * aimSmoothing;
    }
    
    private void applyAimAdjustment(float newAngle) {
        
    }
    
    public void setAssistStrength(float strength) {
        currentAssistStrength = Math.max(0.1f, Math.min(1.0f, strength));
    }
    
    public void setMaxAngleAdjustment(float angle) {
        maxAngleAdjustment = angle;
    }
    
    public boolean isTargetLocked() {
        return isTargetLocked;
    }
}

public class AimAssist {
    private float baseAssistStrength = 0.7f;
    private float maxAngleAdjustment = 15.0f;
    private float aimSmoothing = 0.2f;
    private float targetLockThreshold = 0.8f;
    private float lockDuration = 1.5f;
    private float detectionRange = 100.0f;
    private float fovAngle = 60.0f;
    
    private boolean isTargetLocked = false;
    private float currentLockTimer = 0.0f;
    private float currentAssistStrength = baseAssistStrength;
    
    public void update(float deltaTime, float targetAngle, float currentAngle) {
        if (isTargetLocked) {
            currentLockTimer += deltaTime;
            if (currentLockTimer >= lockDuration) {
                isTargetLocked = false;
                currentLockTimer = 0.0f;
            }
        }
        
        float angleDifference = calculateAngleDifference(targetAngle, currentAngle);
        if (angleDifference <= fovAngle && angleDifference <= detectionRange) {
            adjustAim(targetAngle, currentAngle, angleDifference);
        } else {
            isTargetLocked = false;
        }
    }
    
    private float calculateAngleDifference(float target, float current) {
        return Math.abs(target - current);
    }
    
    private void adjustAim(float targetAngle, float currentAngle, float angleDiff) {
        if (angleDiff < targetLockThreshold) {
            isTargetLocked = true;
            currentLockTimer = 0.0f;
        }
        
        float adjustment = Math.min(maxAngleAdjustment, angleDiff * currentAssistStrength);
        float newAngle = currentAngle + (targetAngle > currentAngle ? adjustment : -adjustment);
        newAngle = smoothAim(currentAngle, newAngle);
        
        applyAimAdjustment(newAngle);
    }
    
    private float smoothAim(float current, float target) {
        return current + (target - current) * aimSmoothing;
    }
    
    private void applyAimAdjustment(float newAngle) {
        
    }
    
    public void setAssistStrength(float strength) {
        currentAssistStrength = Math.max(0.1f, Math.min(1.0f, strength));
    }
    
    public void setMaxAngleAdjustment(float angle) {
        maxAngleAdjustment = angle;
    }
    
    public boolean isTargetLocked() {
        return isTargetLocked;
    }
}

public class AimAssist {
    private float baseAssistStrength = 0.7f;
    private float maxAngleAdjustment = 15.0f;
    private float aimSmoothing = 0.2f;
    private float targetLockThreshold = 0.8f;
    private float lockDuration = 1.5f;
    private float detectionRange = 100.0f;
    private float fovAngle = 60.0f;
    
    private boolean isTargetLocked = false;
    private float currentLockTimer = 0.0f;
    private float currentAssistStrength = baseAssistStrength;
    
    public void update(float deltaTime, float targetAngle, float currentAngle) {
        if (isTargetLocked) {
            currentLockTimer += deltaTime;
            if (currentLockTimer >= lockDuration) {
                isTargetLocked = false;
                currentLockTimer = 0.0f;
            }
        }
        
        float angleDifference = calculateAngleDifference(targetAngle, currentAngle);
        if (angleDifference <= fovAngle && angleDifference <= detectionRange) {
            adjustAim(targetAngle, currentAngle, angleDifference);
        } else {
            isTargetLocked = false;
        }
    }
    
    private float calculateAngleDifference(float target, float current) {
        return Math.abs(target - current);
    }
    
    private void adjustAim(float targetAngle, float currentAngle, float angleDiff) {
        if (angleDiff < targetLockThreshold) {
            isTargetLocked = true;
            currentLockTimer = 0.0f;
        }
        
        float adjustment = Math.min(maxAngleAdjustment, angleDiff * currentAssistStrength);
        float newAngle = currentAngle + (targetAngle > currentAngle ? adjustment : -adjustment);
        newAngle = smoothAim(currentAngle, newAngle);
        
        applyAimAdjustment(newAngle);
    }
    
    private float smoothAim(float current, float target) {
        return current + (target - current) * aimSmoothing;
    }
    
    private void applyAimAdjustment(float newAngle) {
        
    }
    
    public void setAssistStrength(float strength) {
        currentAssistStrength = Math.max(0.1f, Math.min(1.0f, strength));
    }
    
    public void setMaxAngleAdjustment(float angle) {
        maxAngleAdjustment = angle;
    }
    
    public boolean isTargetLocked() {
        return isTargetLocked;
    }
}

public class AimAssist {
    private float baseAssistStrength = 0.7f;
    private float maxAngleAdjustment = 15.0f;
    private float aimSmoothing = 0.2f;
    private float targetLockThreshold = 0.8f;
    private float lockDuration = 1.5f;
    private float detectionRange = 100.0f;
    private float fovAngle = 60.0f;
    
    private boolean isTargetLocked = false;
    private float currentLockTimer = 0.0f;
    private float currentAssistStrength = baseAssistStrength;
    
    public void update(float deltaTime, float targetAngle, float currentAngle) {
        if (isTargetLocked) {
            currentLockTimer += deltaTime;
            if (currentLockTimer >= lockDuration) {
                isTargetLocked = false;
                currentLockTimer = 0.0f;
            }
        }
        
        float angleDifference = calculateAngleDifference(targetAngle, currentAngle);
        if (angleDifference <= fovAngle && angleDifference <= detectionRange) {
            adjustAim(targetAngle, currentAngle, angleDifference);
        } else {
            isTargetLocked = false;
        }
    }
    
    private float calculateAngleDifference(float target, float current) {
        return Math.abs(target - current);
    }
    
    private void adjustAim(float targetAngle, float currentAngle, float angleDiff) {
        if (angleDiff < targetLockThreshold) {
            isTargetLocked = true;
            currentLockTimer = 0.0f;
        }
        
        float adjustment = Math.min(maxAngleAdjustment, angleDiff * currentAssistStrength);
        float newAngle = currentAngle + (targetAngle > currentAngle ? adjustment : -adjustment);
        newAngle = smoothAim(currentAngle, newAngle);
        
        applyAimAdjustment(newAngle);
    }
    
    private float smoothAim(float current, float target) {
        return current + (target - current) * aimSmoothing;
    }
    
    private void applyAimAdjustment(float newAngle) {
        
    }
    
    public void setAssistStrength(float strength) {
        currentAssistStrength = Math.max(0.1f, Math.min(1.0f, strength));
    }
    
    public void setMaxAngleAdjustment(float angle) {
        maxAngleAdjustment = angle;
    }
    
    public boolean isTargetLocked() {
        return isTargetLocked;
    }
}

public class AimAssist {
    private float baseAssistStrength = 0.7f;
    private float maxAngleAdjustment = 15.0f;
    private float aimSmoothing = 0.2f;
    private float targetLockThreshold = 0.8f;
    private float lockDuration = 1.5f;
    private float detectionRange = 100.0f;
    private float fovAngle = 60.0f;
    
    private boolean isTargetLocked = false;
    private float currentLockTimer = 0.0f;
    private float currentAssistStrength = baseAssistStrength;
    
    public void update(float deltaTime, float targetAngle, float currentAngle) {
        if (isTargetLocked) {
            currentLockTimer += deltaTime;
            if (currentLockTimer >= lockDuration) {
                isTargetLocked = false;
                currentLockTimer = 0.0f;
            }
        }
        
        float angleDifference = calculateAngleDifference(targetAngle, currentAngle);
        if (angleDifference <= fovAngle && angleDifference <= detectionRange) {
            adjustAim(targetAngle, currentAngle, angleDifference);
        } else {
            isTargetLocked = false;
        }
    }
    
    private float calculateAngleDifference(float target, float current) {
        return Math.abs(target - current);
    }
    
    private void adjustAim(float targetAngle, float currentAngle, float angleDiff) {
        if (angleDiff < targetLockThreshold) {
            isTargetLocked = true;
            currentLockTimer = 0.0f;
        }
        
        float adjustment = Math.min(maxAngleAdjustment, angleDiff * currentAssistStrength);
        float newAngle = currentAngle + (targetAngle > currentAngle ? adjustment : -adjustment);
        newAngle = smoothAim(currentAngle, newAngle);
        
        applyAimAdjustment(newAngle);
    }
    
    private float smoothAim(float current, float target) {
        return current + (target - current) * aimSmoothing;
    }
    
    private void applyAimAdjustment(float newAngle) {
        
    }
    
    public void setAssistStrength(float strength) {
        currentAssistStrength = Math.max(0.1f, Math.min(1.0f, strength));
    }
    
    public void setMaxAngleAdjustment(float angle) {
        maxAngleAdjustment = angle;
    }
    
    public boolean isTargetLocked() {
        return isTargetLocked;
    }
}

public class AimAssist {
    private float baseAssistStrength = 0.7f;
    private float maxAngleAdjustment = 15.0f;
    private float aimSmoothing = 0.2f;
    private float targetLockThreshold = 0.8f;
    private float lockDuration = 1.5f;
    private float detectionRange = 100.0f;
    private float fovAngle = 60.0f;
    
    private boolean isTargetLocked = false;
    private float currentLockTimer = 0.0f;
    private float currentAssistStrength = baseAssistStrength;
    
    public void update(float deltaTime, float targetAngle, float currentAngle) {
        if (isTargetLocked) {
            currentLockTimer += deltaTime;
            if (currentLockTimer >= lockDuration) {
                isTargetLocked = false;
                currentLockTimer = 0.0f;
            }
        }
        
        float angleDifference = calculateAngleDifference(targetAngle, currentAngle);
        if (angleDifference <= fovAngle && angleDifference <= detectionRange) {
            adjustAim(targetAngle, currentAngle, angleDifference);
        } else {
            isTargetLocked = false;
        }
    }
    
    private float calculateAngleDifference(float target, float current) {
        return Math.abs(target - current);
    }
    
    private void adjustAim(float targetAngle, float currentAngle, float angleDiff) {
        if (angleDiff < targetLockThreshold) {
            isTargetLocked = true;
            currentLockTimer = 0.0f;
        }
        
        float adjustment = Math.min(maxAngleAdjustment, angleDiff * currentAssistStrength);
        float newAngle = currentAngle + (targetAngle > currentAngle ? adjustment : -adjustment);
        newAngle = smoothAim(currentAngle, newAngle);
        
        applyAimAdjustment(newAngle);
    }
    
    private float smoothAim(float current, float target) {
        return current + (target - current) * aimSmoothing;
    }
    
    private void applyAimAdjustment(float newAngle) {
        
    }
    
    public void setAssistStrength(float strength) {
        currentAssistStrength = Math.max(0.1f, Math.min(1.0f, strength));
    }
    
    public void setMaxAngleAdjustment(float angle) {
        maxAngleAdjustment = angle;
    }
    
    public boolean isTargetLocked() {
        return isTargetLocked;
    }
}

public class AimAssist {
    private float baseAssistStrength = 0.7f;
    private float maxAngleAdjustment = 15.0f;
    private float aimSmoothing = 0.2f;
    private float targetLockThreshold = 0.8f;
    private float lockDuration = 1.5f;
    private float detectionRange = 100.0f;
    private float fovAngle = 60.0f;
    
    private boolean isTargetLocked = false;
    private float currentLockTimer = 0.0f;
    private float currentAssistStrength = baseAssistStrength;
    
    public void update(float deltaTime, float targetAngle, float currentAngle) {
        if (isTargetLocked) {
            currentLockTimer += deltaTime;
            if (currentLockTimer >= lockDuration) {
                isTargetLocked = false;
                currentLockTimer = 0.0f;
            }
        }
        
        float angleDifference = calculateAngleDifference(targetAngle, currentAngle);
        if (angleDifference <= fovAngle && angleDifference <= detectionRange) {
            adjustAim(targetAngle, currentAngle, angleDifference);
        } else {
            isTargetLocked = false;
        }
    }
    
    private float calculateAngleDifference(float target, float current) {
        return Math.abs(target - current);
    }
    
    private void adjustAim(float targetAngle, float currentAngle, float angleDiff) {
        if (angleDiff < targetLockThreshold) {
            isTargetLocked = true;
            currentLockTimer = 0.0f;
        }
        
        float adjustment = Math.min(maxAngleAdjustment, angleDiff * currentAssistStrength);
        float newAngle = currentAngle + (targetAngle > currentAngle ? adjustment : -adjustment);
        newAngle = smoothAim(currentAngle, newAngle);
        
        applyAimAdjustment(newAngle);
    }
    
    private float smoothAim(float current, float target) {
        return current + (target - current) * aimSmoothing;
    }
    
    private void applyAimAdjustment(float newAngle) {
        
    }
    
    public void setAssistStrength(float strength) {
        currentAssistStrength = Math.max(0.1f, Math.min(1.0f, strength));
    }
    
    public void setMaxAngleAdjustment(float angle) {
        maxAngleAdjustment = angle;
    }
    
    public boolean isTargetLocked() {
        return isTargetLocked;
    }
}

public class AimAssist {
    private float baseAssistStrength = 0.7f;
    private float maxAngleAdjustment = 15.0f;
    private float aimSmoothing = 0.2f;
    private float targetLockThreshold = 0.8f;
    private float lockDuration = 1.5f;
    private float detectionRange = 100.0f;
    private float fovAngle = 60.0f;
    
    private boolean isTargetLocked = false;
    private float currentLockTimer = 0.0f;
    private float currentAssistStrength = baseAssistStrength;
    
    public void update(float deltaTime, float targetAngle, float currentAngle) {
        if (isTargetLocked) {
            currentLockTimer += deltaTime;
            if (currentLockTimer >= lockDuration) {
                isTargetLocked = false;
                currentLockTimer = 0.0f;
            }
        }
        
        float angleDifference = calculateAngleDifference(targetAngle, currentAngle);
        if (angleDifference <= fovAngle && angleDifference <= detectionRange) {
            adjustAim(targetAngle, currentAngle, angleDifference);
        } else {
            isTargetLocked = false;
        }
    }
    
    private float calculateAngleDifference(float target, float current) {
        return Math.abs(target - current);
    }
    
    private void adjustAim(float targetAngle, float currentAngle, float angleDiff) {
        if (angleDiff < targetLockThreshold) {
            isTargetLocked = true;
            currentLockTimer = 0.0f;
        }
        
        float adjustment = Math.min(maxAngleAdjustment, angleDiff * currentAssistStrength);
        float newAngle = currentAngle + (targetAngle > currentAngle ? adjustment : -adjustment);
        newAngle = smoothAim(currentAngle, newAngle);
        
        applyAimAdjustment(newAngle);
    }
    
    private float smoothAim(float current, float target) {
        return current + (target - current) * aimSmoothing;
    }
    
    private void applyAimAdjustment(float newAngle) {
        
    }
    
    public void setAssistStrength(float strength) {
        currentAssistStrength = Math.max(0.1f, Math.min(1.0f, strength));
    }
    
    public void setMaxAngleAdjustment(float angle) {
        maxAngleAdjustment = angle;
    }
    
    public boolean isTargetLocked() {
        return isTargetLocked;
    }
}

public class AimAssist {
    private float baseAssistStrength = 0.7f;
    private float maxAngleAdjustment = 15.0f;
    private float aimSmoothing = 0.2f;
    private float targetLockThreshold = 0.8f;
    private float lockDuration = 1.5f;
    private float detectionRange = 100.0f;
    private float fovAngle = 60.0f;
    
    private boolean isTargetLocked = false;
    private float currentLockTimer = 0.0f;
    private float currentAssistStrength = baseAssistStrength;
    
    public void update(float deltaTime, float targetAngle, float currentAngle) {
        if (isTargetLocked) {
            currentLockTimer += deltaTime;
            if (currentLockTimer >= lockDuration) {
                isTargetLocked = false;
                currentLockTimer = 0.0f;
            }
        }
        
        float angleDifference = calculateAngleDifference(targetAngle, currentAngle);
        if (angleDifference <= fovAngle && angleDifference <= detectionRange) {
            adjustAim(targetAngle, currentAngle, angleDifference);
        } else {
            isTargetLocked = false;
        }
    }
    
    private float calculateAngleDifference(float target, float current) {
        return Math.abs(target - current);
    }
    
    private void adjustAim(float targetAngle, float currentAngle, float angleDiff) {
        if (angleDiff < targetLockThreshold) {
            isTargetLocked = true;
            currentLockTimer = 0.0f;
        }
        
        float adjustment = Math.min(maxAngleAdjustment, angleDiff * currentAssistStrength);
        float newAngle = currentAngle + (targetAngle > currentAngle ? adjustment : -adjustment);
        newAngle = smoothAim(currentAngle, newAngle);
        
        applyAimAdjustment(newAngle);
    }
    
    private float smoothAim(float current, float target) {
        return current + (target - current) * aimSmoothing;
    }
    
    private void applyAimAdjustment(float newAngle) {
        
    }
    
    public void setAssistStrength(float strength) {
        currentAssistStrength = Math.max(0.1f, Math.min(1.0f, strength));
    }
    
    public void setMaxAngleAdjustment(float angle) {
        maxAngleAdjustment = angle;
    }
    
    public boolean isTargetLocked() {
        return isTargetLocked;
    }
}

public class AimAssist {
    private float baseAssistStrength = 0.7f;
    private float maxAngleAdjustment = 15.0f;
    private float aimSmoothing = 0.2f;
    private float targetLockThreshold = 0.8f;
    private float lockDuration = 1.5f;
    private float detectionRange = 100.0f;
    private float fovAngle = 60.0f;
    
    private boolean isTargetLocked = false;
    private float currentLockTimer = 0.0f;
    private float currentAssistStrength = baseAssistStrength;
    
    public void update(float deltaTime, float targetAngle, float currentAngle) {
        if (isTargetLocked) {
            currentLockTimer += deltaTime;
            if (currentLockTimer >= lockDuration) {
                isTargetLocked = false;
                currentLockTimer = 0.0f;
            }
        }
        
        float angleDifference = calculateAngleDifference(targetAngle, currentAngle);
        if (angleDifference <= fovAngle && angleDifference <= detectionRange) {
            adjustAim(targetAngle, currentAngle, angleDifference);
        } else {
            isTargetLocked = false;
        }
    }
    
    private float calculateAngleDifference(float target, float current) {
        return Math.abs(target - current);
    }
    
    private void adjustAim(float targetAngle, float currentAngle, float angleDiff) {
        if (angleDiff < targetLockThreshold) {
            isTargetLocked = true;
            currentLockTimer = 0.0f;
        }
        
        float adjustment = Math.min(maxAngleAdjustment, angleDiff * currentAssistStrength);
        float newAngle = currentAngle + (targetAngle > currentAngle ? adjustment : -adjustment);
        newAngle = smoothAim(currentAngle, newAngle);
        
        applyAimAdjustment(newAngle);
    }
    
    private float smoothAim(float current, float target) {
        return current + (target - current) * aimSmoothing;
    }
    
    private void applyAimAdjustment(float newAngle) {
        
    }
    
    public void setAssistStrength(float strength) {
        currentAssistStrength = Math.max(0.1f, Math.min(1.0f, strength));
    }
    
    public void setMaxAngleAdjustment(float angle) {
        maxAngleAdjustment = angle;
    }
    
    public boolean isTargetLocked() {
        return isTargetLocked;
    }
}

public class AimAssist {
    private float baseAssistStrength = 0.7f;
    private float maxAngleAdjustment = 15.0f;
    private float aimSmoothing = 0.2f;
    private float targetLockThreshold = 0.8f;
    private float lockDuration = 1.5f;
    private float detectionRange = 100.0f;
    private float fovAngle = 60.0f;
    
    private boolean isTargetLocked = false;
    private float currentLockTimer = 0.0f;
    private float currentAssistStrength = baseAssistStrength;
    
    public void update(float deltaTime, float targetAngle, float currentAngle) {
        if (isTargetLocked) {
            currentLockTimer += deltaTime;
            if (currentLockTimer >= lockDuration) {
                isTargetLocked = false;
                currentLockTimer = 0.0f;
            }
        }
        
        float angleDifference = calculateAngleDifference(targetAngle, currentAngle);
        if (angleDifference <= fovAngle && angleDifference <= detectionRange) {
            adjustAim(targetAngle, currentAngle, angleDifference);
        } else {
            isTargetLocked = false;
        }
    }
    
    private float calculateAngleDifference(float target, float current) {
        return Math.abs(target - current);
    }
    
    private void adjustAim(float targetAngle, float currentAngle, float angleDiff) {
        if (angleDiff < targetLockThreshold) {
            isTargetLocked = true;
            currentLockTimer = 0.0f;
        }
        
        float adjustment = Math.min(maxAngleAdjustment, angleDiff * currentAssistStrength);
        float newAngle = currentAngle + (targetAngle > currentAngle ? adjustment : -adjustment);
        newAngle = smoothAim(currentAngle, newAngle);
        
        applyAimAdjustment(newAngle);
    }
    
    private float smoothAim(float current, float target) {
        return current + (target - current) * aimSmoothing;
    }
    
    private void applyAimAdjustment(float newAngle) {
        
    }
    
    public void setAssistStrength(float strength) {
        currentAssistStrength = Math.max(0.1f, Math.min(1.0f, strength));
    }
    
    public void setMaxAngleAdjustment(float angle) {
        maxAngleAdjustment = angle;
    }
    
    public boolean isTargetLocked() {
        return isTargetLocked;
    }
}

public class AimAssist {
    private float baseAssistStrength = 0.7f;
    private float maxAngleAdjustment = 15.0f;
    private float aimSmoothing = 0.2f;
    private float targetLockThreshold = 0.8f;
    private float lockDuration = 1.5f;
    private float detectionRange = 100.0f;
    private float fovAngle = 60.0f;
    
    private boolean isTargetLocked = false;
    private float currentLockTimer = 0.0f;
    private float currentAssistStrength = baseAssistStrength;
    
    public void update(float deltaTime, float targetAngle, float currentAngle) {
        if (isTargetLocked) {
            currentLockTimer += deltaTime;
            if (currentLockTimer >= lockDuration) {
                isTargetLocked = false;
                currentLockTimer = 0.0f;
            }
        }
        
        float angleDifference = calculateAngleDifference(targetAngle, currentAngle);
        if (angleDifference <= fovAngle && angleDifference <= detectionRange) {
            adjustAim(targetAngle, currentAngle, angleDifference);
        } else {
            isTargetLocked = false;
        }
    }
    
    private float calculateAngleDifference(float target, float current) {
        return Math.abs(target - current);
    }
    
    private void adjustAim(float targetAngle, float currentAngle, float angleDiff) {
        if (angleDiff < targetLockThreshold) {
            isTargetLocked = true;
            currentLockTimer = 0.0f;
        }
        
        float adjustment = Math.min(maxAngleAdjustment, angleDiff * currentAssistStrength);
        float newAngle = currentAngle + (targetAngle > currentAngle ? adjustment : -adjustment);
        newAngle = smoothAim(currentAngle, newAngle);
        
        applyAimAdjustment(newAngle);
    }
    
    private float smoothAim(float current, float target) {
        return current + (target - current) * aimSmoothing;
    }
    
    private void applyAimAdjustment(float newAngle) {
        
    }
    
    public void setAssistStrength(float strength) {
        currentAssistStrength = Math.max(0.1f, Math.min(1.0f, strength));
    }
    
    public void setMaxAngleAdjustment(float angle) {
        maxAngleAdjustment = angle;
    }
    
    public boolean isTargetLocked() {
        return isTargetLocked;
    }
}

public class AimAssist {
    private float baseAssistStrength = 0.7f;
    private float maxAngleAdjustment = 15.0f;
    private float aimSmoothing = 0.2f;
    private float targetLockThreshold = 0.8f;
    private float lockDuration = 1.5f;
    private float detectionRange = 100.0f;
    private float fovAngle = 60.0f;
    
    private boolean isTargetLocked = false;
    private float currentLockTimer = 0.0f;
    private float currentAssistStrength = baseAssistStrength;
    
    public void update(float deltaTime, float targetAngle, float currentAngle) {
        if (isTargetLocked) {
            currentLockTimer += deltaTime;
            if (currentLockTimer >= lockDuration) {
                isTargetLocked = false;
                currentLockTimer = 0.0f;
            }
        }
        
        float angleDifference = calculateAngleDifference(targetAngle, currentAngle);
        if (angleDifference <= fovAngle && angleDifference <= detectionRange) {
            adjustAim(targetAngle, currentAngle, angleDifference);
        } else {
            isTargetLocked = false;
        }
    }
    
    private float calculateAngleDifference(float target, float current) {
        return Math.abs(target - current);
    }
    
    private void adjustAim(float targetAngle, float currentAngle, float angleDiff) {
        if (angleDiff < targetLockThreshold) {
            isTargetLocked = true;
            currentLockTimer = 0.0f;
        }
        
        float adjustment = Math.min(maxAngleAdjustment, angleDiff * currentAssistStrength);
        float newAngle = currentAngle + (targetAngle > currentAngle ? adjustment : -adjustment);
        newAngle = smoothAim(currentAngle, newAngle);
        
        applyAimAdjustment(newAngle);
    }
    
    private float smoothAim(float current, float target) {
        return current + (target - current) * aimSmoothing;
    }
    
    private void applyAimAdjustment(float newAngle) {
        
    }
    
    public void setAssistStrength(float strength) {
        currentAssistStrength = Math.max(0.1f, Math.min(1.0f, strength));
    }
    
    public void setMaxAngleAdjustment(float angle) {
        maxAngleAdjustment = angle;
    }
    
    public boolean isTargetLocked() {
        return isTargetLocked;
    }
}

public class AimAssist {
    private float baseAssistStrength = 0.7f;
    private float maxAngleAdjustment = 15.0f;
    private float aimSmoothing = 0.2f;
    private float targetLockThreshold = 0.8f;
    private float lockDuration = 1.5f;
    private float detectionRange = 100.0f;
    private float fovAngle = 60.0f;
    
    private boolean isTargetLocked = false;
    private float currentLockTimer = 0.0f;
    private float currentAssistStrength = baseAssistStrength;
    
    public void update(float deltaTime, float targetAngle, float currentAngle) {
        if (isTargetLocked) {
            currentLockTimer += deltaTime;
            if (currentLockTimer >= lockDuration) {
                isTargetLocked = false;
                currentLockTimer = 0.0f;
            }
        }
        
        float angleDifference = calculateAngleDifference(targetAngle, currentAngle);
        if (angleDifference <= fovAngle && angleDifference <= detectionRange) {
            adjustAim(targetAngle, currentAngle, angleDifference);
        } else {
            isTargetLocked = false;
        }
    }
    
    private float calculateAngleDifference(float target, float current) {
        return Math.abs(target - current);
    }
    
    private void adjustAim(float targetAngle, float currentAngle, float angleDiff) {
        if (angleDiff < targetLockThreshold) {
            isTargetLocked = true;
            currentLockTimer = 0.0f;
        }
        
        float adjustment = Math.min(maxAngleAdjustment, angleDiff * currentAssistStrength);
        float newAngle = currentAngle + (targetAngle > currentAngle ? adjustment : -adjustment);
        newAngle = smoothAim(currentAngle, newAngle);
        
        applyAimAdjustment(newAngle);
    }
    
    private float smoothAim(float current, float target) {
        return current + (target - current) * aimSmoothing;
    }
    
    private void applyAimAdjustment(float newAngle) {
        
    }
    
    public void setAssistStrength(float strength) {
        currentAssistStrength = Math.max(0.1f, Math.min(1.0f, strength));
    }
    
    public void setMaxAngleAdjustment(float angle) {
        maxAngleAdjustment = angle;
    }
    
    public boolean isTargetLocked() {
        return isTargetLocked;
    }
}
