quaver_rs::difficulty_processor::processor

Struct DifficultyProcessor

pub struct DifficultyProcessor {
    pub map: Qua,
    pub overall_difficulty: f32,
    pub qss_pattern_flags: QssPatternFlags,
    pub strain_constants: StrainConstantsKeys,
    pub average_note_density: f32,
    pub strain_solver_data: Vec<StrainSolverData>,
    pub vibro_inaccuracy_confidence: f32,
    pub roll_inaccuracy_confidence: f32,
}

Expand description

Handles Difficulty Solving + Data

Fields§

§map: Qua

Current map for difficulty calculation

§overall_difficulty: f32

Overall Difficulty of a map

§qss_pattern_flags: QssPatternFlags

Used to display prominent patterns of a map in the client

§strain_constants: StrainConstantsKeys

Constants used for solving

§average_note_density: f32

Average note density of the map

§strain_solver_data: Vec<StrainSolverData>

Hit objects in the map used for solving difficulty

§vibro_inaccuracy_confidence: f32

Value of confidence that there’s vibro manipulation in the calculated map

§roll_inaccuracy_confidence: f32

Value of confidence that there’s roll manipulation in the calculated map

Implementations§

Source §

impl DifficultyProcessor

Source

pub fn new(map: Qua, _constants: StrainConstants, _mods: ModIdentifier) -> Self

Constructor

Examples found in repository ?

examples/basic_usage.rs (line 19)

3fn main() -> Result<(), Box<dyn std::error::Error>> {
4    println!("Parsing .qua file...");
5    
6    // Parse the .qua file
7    let qua = Qua::from_file("assets/171402.qua")?;
8    
9    println!("Map: {} - {}", qua.metadata.title, qua.metadata.artist);
10    println!("Creator: {}", qua.metadata.creator);
11    println!("Difficulty: {}", qua.metadata.difficulty_name);
12    println!("Mode: {:?}", qua.metadata.mode);
13    println!("Hit Objects: {}", qua.hit_objects.len());
14    println!("Timing Points: {}", qua.timing_points.len());
15    
16    // Calculate difficulty
17    println!("\nCalculating difficulty...");
18    let constants = StrainConstants::new(None);
19    let mut processor = DifficultyProcessor::new(qua, constants, ModIdentifier::NONE);
20    processor.calculate_difficulty(ModIdentifier::NONE);
21    
22    println!("Overall Difficulty: {:.2}", processor.overall_difficulty);
23    println!("Average Note Density: {:.2}", processor.average_note_density);
24    println!("Map Length: {:.2}", processor.map.length());
25    println!("Hit Objects Count: {}", processor.map.hit_objects.len());
26    println!("Timing Points Count: {}", processor.map.timing_points.len());
27    
28    Ok(())
29}

Source

pub fn calculate_difficulty(&mut self, mods: ModIdentifier)

Calculate difficulty of a map with given mods

Examples found in repository ?

examples/basic_usage.rs (line 20)

3fn main() -> Result<(), Box<dyn std::error::Error>> {
4    println!("Parsing .qua file...");
5    
6    // Parse the .qua file
7    let qua = Qua::from_file("assets/171402.qua")?;
8    
9    println!("Map: {} - {}", qua.metadata.title, qua.metadata.artist);
10    println!("Creator: {}", qua.metadata.creator);
11    println!("Difficulty: {}", qua.metadata.difficulty_name);
12    println!("Mode: {:?}", qua.metadata.mode);
13    println!("Hit Objects: {}", qua.hit_objects.len());
14    println!("Timing Points: {}", qua.timing_points.len());
15    
16    // Calculate difficulty
17    println!("\nCalculating difficulty...");
18    let constants = StrainConstants::new(None);
19    let mut processor = DifficultyProcessor::new(qua, constants, ModIdentifier::NONE);
20    processor.calculate_difficulty(ModIdentifier::NONE);
21    
22    println!("Overall Difficulty: {:.2}", processor.overall_difficulty);
23    println!("Average Note Density: {:.2}", processor.average_note_density);
24    println!("Map Length: {:.2}", processor.map.length());
25    println!("Hit Objects Count: {}", processor.map.hit_objects.len());
26    println!("Timing Points Count: {}", processor.map.timing_points.len());
27    
28    Ok(())
29}