rosu-pp 4.0.1

Difficulty and performance calculation for osu!
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114

use rosu_map::section::hit_objects::hit_samples::HitSoundType;

use crate::{
    Beatmap,
    mania::convert::{pattern::Pattern, pattern_type::PatternType},
    model::hit_object::HitObject,
    util::random::osu::Random,
};

use super::PatternGenerator;

pub struct EndTimeObjectPatternGenerator<'h> {
    pub end_time: f64,
    pub sample: HitSoundType,
    pub inner: PatternGenerator<'h>,
    convert_type: PatternType,
    prev_pattern: &'h Pattern,
}

impl<'h> EndTimeObjectPatternGenerator<'h> {
    pub fn new(
        random: &'h mut Random,
        hit_object: &'h HitObject,
        end_time: f64,
        sample: HitSoundType,
        total_columns: i32,
        prev_pattern: &'h Pattern,
        orig: &'h Beatmap,
    ) -> Self {
        let convert_type = if prev_pattern.column_with_objs() == total_columns {
            PatternType::default()
        } else {
            PatternType::FORCE_NOT_STACK
        };

        let inner = PatternGenerator::new(hit_object, total_columns, random, orig);

        Self {
            end_time,
            sample,
            inner,
            convert_type,
            prev_pattern,
        }
    }

    pub fn generate(&mut self) -> Pattern {
        let generate_hold = self.end_time - self.inner.hit_object.start_time >= 100.0;

        match self.inner.total_columns {
            8 if self.sample.has_flag(HitSoundType::FINISH)
                && self.end_time - self.inner.hit_object.start_time < 1000.0 =>
            {
                Pattern::new_end_time_note(self, 0, generate_hold)
            }
            8 => {
                let column = self.get_random_column(self.inner.random_start());

                Pattern::new_end_time_note(self, column, generate_hold)
            }
            _ => {
                let column = self.get_random_column(0);

                Pattern::new_end_time_note(self, column, generate_hold)
            }
        }
    }

    fn get_random_column(&mut self, lower: i32) -> u8 {
        let column = self.inner.get_random_column(Some(lower), None);

        if self.convert_type.contains(PatternType::FORCE_NOT_STACK) {
            self.find_available_column(column, Some(lower), &[self.prev_pattern])
        } else {
            self.find_available_column(column, Some(lower), &[])
        }
    }

    fn find_available_column(
        &mut self,
        mut initial_column: u8,
        lower: Option<i32>,
        patterns: &[&Pattern],
    ) -> u8 {
        let lower = lower.unwrap_or_else(|| self.inner.random_start());
        let upper = self.inner.total_columns;

        let is_valid = |column: i32| {
            let column = column as u8;

            patterns
                .iter()
                .all(|pattern| !pattern.column_has_obj(column))
        };

        // * Check for the initial column
        if is_valid(i32::from(initial_column)) {
            return initial_column;
        }

        // * Ensure that we have at least one free column, so that an endless loop is avoided
        let has_valid_column = (lower..upper).any(is_valid);
        assert!(has_valid_column);

        // * Iterate until a valid column is found. This is a random iteration in the default case.
        while {
            initial_column = self.inner.get_random_column(Some(lower), Some(upper));

            !is_valid(i32::from(initial_column))
        } {}

        initial_column
    }
}