Blur Busters Forums

Code: Select all

[package]
name = "cs2_optimizer_architect"
version = "0.5.0"
edition = "2021"

[dependencies]
rand = "0.8"
windows-sys = { version = "0.48", features = [
    "Win32_Foundation",
    "Win32_System_Threading",
    "Win32_Media",
    "Win32_UI_Input_KeyboardAndMouse",
    "Win32_System_SystemInformation",
    "Win32_System_Performance" // Pour QueryPerformanceCounter
] }

Code: Select all

use std::thread;
use std::time::Duration;
use std::io::{self, Write};
use std::ffi::CString;

// --- IMPORTS ARCHITECTURE (INTRINSICS) ---
#[cfg(target_arch = "x86_64")]
use core::arch::x86_64::{
    _mm_mfence, _mm_pause, _rdtsc, // Instructions bas niveau
    _mm_set1_ps, _mm_sqrt_ps, _mm_add_ps, // SSE
};

// --- IMPORTS WINDOWS ---
use windows_sys::Win32::UI::Input::KeyboardAndMouse::*;
use windows_sys::Win32::System::Threading::*;
use windows_sys::Win32::System::Performance::{QueryPerformanceCounter, QueryPerformanceFrequency};
use windows_sys::Win32::Media::timeBeginPeriod;

#[link(name = "ntdll")]
extern "system" {
    fn NtSetTimerResolution(Desired: u32, Set: u8, Current: *mut u32) -> i32;
    fn NtDelayExecution(Alertable: u8, DelayInterval: *const i64) -> i32;
}

#[link(name = "avrt")]
extern "system" {
    fn AvSetMmThreadCharacteristicsA(TaskName: *const u8, TaskIndex: *mut u32) -> isize;
    fn AvRevertMmThreadCharacteristics(Handle: isize) -> bool;
}

// --- ÉNUMÉRATION DES MODES DE CHARGE ---
#[derive(Clone, Copy, PartialEq)]
enum LoadMode {
    SSE = 0,
    RND = 1,
    MEM = 2,
    MATH = 3,
    CACHE = 4,
}

impl LoadMode {
    fn from_u8(v: u8) -> Self {
        match v % 5 {
            0 => LoadMode::SSE,
            1 => LoadMode::RND,
            2 => LoadMode::MEM,
            3 => LoadMode::MATH,
            4 => LoadMode::CACHE,
            _ => LoadMode::SSE,
        }
    }
    fn as_str(&self) -> &str {
        match self {
            LoadMode::SSE => "SSE",
            LoadMode::RND => "RND",
            LoadMode::MEM => "MEM",
            LoadMode::MATH => "MTH",
            LoadMode::CACHE => "CCH",
        }
    }
}

// --- ÉTAT GLOBAL ---
static mut STATE_HZ: u32 = 5000;
static mut STATE_MMCSS: bool = false;
static mut STATE_MMCSS_HANDLE: isize = 0;
static mut STATE_SCRAMBLE: bool = false;
static mut STATE_CORE: usize = 1;
static mut STATE_FENCE: bool = true;
static mut STATE_PHANTOM: bool = true;
static mut STATE_LOAD_MODE: u8 = 0; // 0=SSE par défaut
static mut STATE_BURST: bool = false;

// --- MOTEUR DE TEMPS ULTRA-PRÉCIS (QPC/RDTSC) ---
fn get_time_us() -> u64 {
    unsafe {
        let mut freq = 0;
        let mut count = 0;
        QueryPerformanceFrequency(&mut freq);
        QueryPerformanceCounter(&mut count);
        // Conversion en microsecondes sans perte de précision flottante
        (count as u128 * 1_000_000 / freq as u128) as u64
    }
}

// --- MOTEUR DE CHARGE ARCHITECTURAL (CPU STRESS) ---
// Simule les instructions spécifiques trouvées dans l'outil
unsafe fn run_architectural_load(mode: LoadMode, iterations: u64) {
    match mode {
        LoadMode::SSE => {
            // Calculs vectoriels (Simule la charge graphique/physique)
            let mut a = _mm_set1_ps(123.456);
            let b = _mm_set1_ps(789.101);
            for _ in 0..iterations {
                a = _mm_sqrt_ps(_mm_add_ps(a, b));
            }
            // Empêche l'optimisation du compilateur (Black Box)
            std::ptr::write_volatile(&mut a as *mut _, a);
        },
        LoadMode::MATH => {
            // Calculs entiers lourds (ALU)
            let mut val: u64 = 123456789;
            for i in 0..iterations {
                val = val.wrapping_mul(3).wrapping_add(i);
                val = val.rotate_left(5);
            }
            std::ptr::write_volatile(&mut val as *mut _, val);
        },
        LoadMode::MEM => {
            // Copie mémoire rapide (L1 Cache Stress)
            // Buffer de 4KB (taille d'une page standard)
            const BUF_SIZE: usize = 1024; // 1024 * 4 bytes = 4KB
            let mut buffer = [0u32; BUF_SIZE];
            for i in 0..BUF_SIZE {
                // Écriture volatile pour forcer l'accès RAM/Cache
                std::ptr::write_volatile(&mut buffer[i], i as u32);
            }
        },
        LoadMode::CACHE => {
            // Cache Trashing (Sauts de 64 octets = 1 Cache Line)
            // Force le CPU à recharger les lignes de cache
            const SIZE: usize = 4096; 
            let mut arr = [0u8; SIZE];
            let mut idx = 0;
            for _ in 0..iterations {
                // Accès avec stride de 64 (Line Size sur x86)
                std::ptr::write_volatile(&mut arr[idx], 1);
                idx = (idx + 64) % SIZE;
            }
        },
        LoadMode::RND => {
            // Branch Prediction Stress (Sauts conditionnels aléatoires)
            let mut val = 0;
            for _ in 0..iterations {
                if rand::random() { val += 1; } else { val -= 1; }
            }
            std::ptr::write_volatile(&mut val as *mut _, val);
        }
    }
}

// --- GESTION ENTRÉES ---
fn check_inputs() {
    unsafe {
        let kp = |vk| (GetAsyncKeyState(vk) & 1) != 0;
        
        // [5] LOAD MODE (La nouvelle touche clé)
        if kp(0x35) { STATE_LOAD_MODE = (STATE_LOAD_MODE + 1) % 5; }

        if kp(VK_F1 as i32) { STATE_HZ = if STATE_HZ == 5000 { 10000 } else { 5000 }; }
        if kp(VK_INSERT as i32) { STATE_PHANTOM = !STATE_PHANTOM; }
        if kp(VK_HOME as i32) { STATE_SCRAMBLE = !STATE_SCRAMBLE; }
        if kp(VK_END as i32) { STATE_FENCE = !STATE_FENCE; }
        if kp(VK_B as i32) { STATE_BURST = !STATE_BURST; }
        
        if kp(VK_M as i32) {
            if !STATE_MMCSS {
                let name = CString::new("Pro Audio").unwrap();
                let mut i = 0;
                let h = AvSetMmThreadCharacteristicsA(name.as_ptr() as *const u8, &mut i);
                if h != 0 { STATE_MMCSS_HANDLE = h; STATE_MMCSS = true; }
            } else {
                AvRevertMmThreadCharacteristics(STATE_MMCSS_HANDLE);
                STATE_MMCSS = false;
            }
        }
    }
}

// --- MAIN ENGINE ---
fn main() {
    unsafe {
        timeBeginPeriod(1);
        SetPriorityClass(GetCurrentProcess(), REALTIME_PRIORITY_CLASS); // Priorité Processus MAX
        SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_TIME_CRITICAL); // Priorité Thread MAX
    }

    println!("=====================================================");
    println!("   CS2 OPTIMIZER: V5 ARCHITECT EDITION (INTRINSICS)  ");
    println!("=====================================================");
    println!(" [5] LOAD MODE : Cycle SSE / RND / MEM / MATH / CACHE");
    println!(" [B] BURST     : CPU Turbo Lock (Micro-Choke)");
    println!(" [M] MMCSS     : Pro Audio Priority");
    println!("=====================================================");

    let mut last_scramble = get_time_us();
    let mut frame_count = 0u64;

    loop {
        unsafe {
            let start_cycle = _rdtsc(); // Cycle CPU exact au début de la boucle
            
            // 1. TIMER HARDWARE
            let mut cur: u32 = 0;
            NtSetTimerResolution(STATE_HZ, 1, &mut cur);

            // 2. SCRAMBLE (Affinité dynamique)
            let now_us = get_time_us();
            if STATE_SCRAMBLE && (now_us - last_scramble > 2_000_000) { // 2 sec
                let cores = [2, 4, 6, 8]; // Cœurs pairs (souvent les cœurs physiques P-Cores)
                let idx = (frame_count as usize) % cores.len();
                STATE_CORE = cores[idx];
                
                let mask = 1 << STATE_CORE;
                SetProcessAffinityMask(GetCurrentProcess(), mask);
                
                last_scramble = now_us;
            } else if !STATE_SCRAMBLE {
                SetProcessAffinityMask(GetCurrentProcess(), 1 << 1); // Lock Core 1
            }

            // 3. ARCHITECTURAL LOAD (Le cœur de V5)
            // On calcule combien de charge appliquer pour maintenir le CPU éveillé
            // sans voler de temps au jeu.
            if STATE_PHANTOM {
                let current_mode = LoadMode::from_u8(STATE_LOAD_MODE);
                
                // Intensité variable (LFO simulé par le compteur de frames)
                let intensity = if STATE_BURST { 2000 } else { 500 }; 
                
                // Exécute les instructions CPU spécifiques
                run_architectural_load(current_mode, intensity);
            }

            // 4. MEMORY FENCE
            if STATE_FENCE && (frame_count % 4 == 0) {
                 _mm_mfence();
            }

            // 5. SYNCHRONISATION PRÉCISE (Wait Loop)
            // On attend que 0.5ms ou 1ms soit écoulé depuis le début du cycle
            // Utilise _mm_pause() pour ne pas surchauffer pendant l'attente active
            let target_cycles = if STATE_HZ == 5000 { 2_000_000 } else { 4_000_000 }; // Approx cycles
            // (Note: La synchro cycle pure est difficile sans calibration, on utilise un mix)
            
            // Simule le délai de thread pour laisser respirer Windows
            // NtDelayExecution pour 1 microseconde (le minimum)
            let delay = -10i64; // 100ns units, négatif = relatif. -10 = 1us.
            NtDelayExecution(0, &delay);

            // 6. DASHBOARD V5
            if frame_count % 100 == 0 {
                let mode = LoadMode::from_u8(STATE_LOAD_MODE);
                print!("\r [V5] CORE:{:<2} | MODE:{:<4} | MMC:{} | BST:{} | FNC:{} | TMR:{:.1}ms ",
                    STATE_CORE,
                    mode.as_str(), // SSE, MEM, etc.
                    if STATE_MMCSS { "ON" } else { "--" },
                    if STATE_BURST { "ON" } else { "--" },
                    if STATE_FENCE { "ON" } else { "--" },
                    STATE_HZ as f32 / 10000.0
                );
                io::stdout().flush().unwrap();
            }
        }

        check_inputs();
        frame_count = frame_count.wrapping_add(1);
    }
}