Struct SmFile 

pub struct SmFile {
    pub metadata: Metadata,
    pub offset: f64,
    pub bpms: Vec<(f64, f64)>,
    pub stops: Vec<(f64, f64)>,
    pub charts: Vec<Chart>,
}

Fields

metadata: Metadata

offset: f64

bpms: Vec<(f64, f64)>

stops: Vec<(f64, f64)>

charts: Vec<Chart>

Implementations

impl SmFile

pub fn from_file(path: PathBuf) -> Result<SmFile, String>

Examples found in repository

examples/to_osu.rs (line 12)

fn main() {
    // Load MEGALOVANIA.sm file
    let sm_path = PathBuf::from("assets/MEGALOVANIA.sm");
    
    println!("Loading SM file: {:?}", sm_path);
    
    let sm_file = match SmFile::from_file(sm_path) {
        Ok(file) => file,
        Err(e) => {
            eprintln!("Error loading SM file: {}", e);
            std::process::exit(1);
        }
    };
    println!("Offset: {}", sm_file.offset);
    println!("Loaded {} chart(s)", sm_file.charts.len());
    
    // Convert each chart to .osu format
    for (chart_idx, chart) in sm_file.charts.iter().enumerate() {
        println!("\nConverting chart {}: {} ({})", 
            chart_idx + 1, 
            chart.difficulty.trim_end_matches(':'),
            chart.stepstype.trim_end_matches(':')
        );
        
        // Create OsuSettings (you can adjust these values)
        let settings = OsuSettings {
            hp: 5.0,  // HP Drain Rate
            od: 8.0,  // Overall Difficulty
        };
        
        // Convert to .osu format
        match create_basic_osu(&sm_file, chart, &settings) {
            Ok(osu_content) => {
                // Generate output filename
                let difficulty_name = chart.difficulty.trim_end_matches(':');
                let sanitized_name = difficulty_name
                    .chars()
                    .map(|c| if c.is_alphanumeric() || c == '-' || c == '_' { c } else { '_' })
                    .collect::<String>();
                
                let output_path = format!("output/MEGALOVANIA_{}.osu", sanitized_name);
                
                // Create output directory if it doesn't exist
                if let Some(parent) = PathBuf::from(&output_path).parent() {
                    fs::create_dir_all(parent).expect("Failed to create output directory");
                }
                
                // Write .osu file
                fs::write(&output_path, osu_content)
                    .expect("Failed to write .osu file");
                
                println!("  ✓ Saved to: {}", output_path);
            }
            Err(e) => {
                eprintln!("  ✗ Error converting chart: {}", e);
            }
        }
    }
    
    println!("\nConversion complete!");
}

examples/load_sm.rs (line 10)

fn main() {
    // Load a .sm file
    let path = PathBuf::from("assets/MEGALOVANIA.sm");
    
    println!("Loading file: {:?}", path);
    
    match SmFile::from_file(path) {
        Ok(sm_file) => {
            println!("\n=== METADATA ===");
            println!("Title: {}", sm_file.metadata.title);
            println!("Artist: {}", sm_file.metadata.artist);
            println!("Subtitle: {}", sm_file.metadata.subtitle);
            println!("Offset: {}", sm_file.offset);
            
            println!("\n=== BPMS ===");
            for (beat, bpm) in &sm_file.bpms {
                println!("  Beat {}: {} BPM", beat, bpm);
            }
            
            println!("\n=== STOPS ===");
            for (beat, duration) in &sm_file.stops {
                println!("  Beat {}: {} seconds", beat, duration);
            }
            
            println!("\n=== CHARTS ===");
            println!("Number of charts: {}", sm_file.charts.len());
            
            for (chart_idx, chart) in sm_file.charts.iter().enumerate() {
                println!("\n--- Chart {} ---", chart_idx + 1);
                println!("Stepstype: {}", chart.stepstype);
                println!("Difficulty: {}", chart.difficulty);
                println!("Meter: {}", chart.meter);
                println!("Number of measures: {}", chart.measures.len());
                
                // Print last measure to check total duration
                if let Some(last_measure) = chart.measures.last() {
                    if let Some(last_beat) = last_measure.beats.last() {
                        let total_duration_sec = last_beat.time / 1000.0;
                        println!("Last beat time: {:.2} ms ({:.2} seconds / {:.2} minutes)", 
                            last_beat.time, total_duration_sec, total_duration_sec / 60.0);
                    } else if !chart.measures.is_empty() {
                        // Empty measure - calculate from start_time
                        let total_duration_sec = last_measure.start_time / 1000.0;
                        println!("Last measure start time: {:.2} ms ({:.2} seconds / {:.2} minutes)", 
                            last_measure.start_time, total_duration_sec, total_duration_sec / 60.0);
                    }
                }
                
                // Print first few measures
                for (measure_idx, measure) in chart.measures.iter().take(3).enumerate() {
                    println!("\n  Measure {}:", measure_idx + 1);
                    println!("    Start time: {:.3} ms", measure.start_time);
                    println!("    Number of beats: {}", measure.beats.len());
                    
                    // Print first few beats
                    for (beat_idx, beat) in measure.beats.iter().take(3).enumerate() {
                        println!("      Beat {}: time={:.3} ms, notes={:?}", 
                            beat_idx + 1, beat.time, beat.notes);
                    }
                    if measure.beats.len() > 3 {
                        println!("      ... ({} more beats)", measure.beats.len() - 3);
                    }
                }
                if chart.measures.len() > 3 {
                    println!("\n  ... ({} more measures)", chart.measures.len() - 3);
                }
            }
        }
        Err(e) => {
            eprintln!("Error loading file: {}", e);
            std::process::exit(1);
        }
    }
}

pub fn from_string(content: &str) -> Result<SmFile, String>

impl SmFile

pub fn new() -> SmFile

Trait Implementations

impl Clone for SmFile

fn clone(&self) -> SmFile

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for SmFile

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.