Struct Key 

pub struct Key(pub u32);

Represents keys that can be pressed during osu!standard gameplay. Includes mouse buttons (M1, M2), keyboard keys (K1, K2), and smoke.

Tuple Fields

0: u32

Implementations

impl Key

pub const M1: Self

pub const M2: Self

pub const K1: Self

pub const K2: Self

pub const SMOKE: Self

pub fn value(&self) -> u32

Examples found in repository

examples/example_1.rs (line 81)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let osr_path = Path::new("assets/test.osr");

    // Check if the file exists
    if !osr_path.exists() {
        eprintln!("Error: File 'assets/test.osr' not found!");
        eprintln!("Please place a valid .osr file at 'assets/test.osr' to run this example.");
        return Ok(());
    }

    println!("Reading replay from: {}", osr_path.display());

    // Parse the replay file
    match Replay::from_path(osr_path) {
        Ok(replay) => {
            println!("\n=== Replay Information ===");
            println!("Username: {}", replay.username);
            println!("Game Mode: {:?}", replay.mode);
            println!("Game Version: {}", replay.game_version);
            println!("Beatmap Hash: {}", replay.beatmap_hash);
            println!("Score: {}", replay.score);
            println!("Max Combo: {}", replay.max_combo);
            println!("Perfect: {}", replay.perfect);
            println!("Mods: {:?} (value: {})", replay.mods, replay.mods.value());
            println!("Timestamp: {}", replay.timestamp);
            println!("Replay ID: {}", replay.replay_id);

            // Hit counts
            println!("\n=== Hit Counts ===");
            println!("300s: {}", replay.count_300);
            println!("100s: {}", replay.count_100);
            println!("50s: {}", replay.count_50);
            println!("Gekis: {}", replay.count_geki);
            println!("Katus: {}", replay.count_katu);
            println!("Misses: {}", replay.count_miss);

            // RNG seed
            if let Some(seed) = replay.rng_seed {
                println!("\n=== RNG Seed ===");
                println!("Seed: {}", seed);
            }

            // Life bar information
            if let Some(ref life_bar) = replay.life_bar_graph {
                println!("\n=== Life Bar ===");
                println!("Life bar states: {}", life_bar.len());
                if !life_bar.is_empty() {
                    println!(
                        "First state: time={}ms, life={}",
                        life_bar[0].time, life_bar[0].life
                    );
                    println!(
                        "Last state: time={}ms, life={}",
                        life_bar[life_bar.len() - 1].time,
                        life_bar[life_bar.len() - 1].life
                    );
                }
            } else {
                println!("\n=== Life Bar ===");
                println!("No life bar data available");
            }

            // Replay data information
            println!("\n=== Replay Data ===");
            println!("Total events: {}", replay.replay_data.len());

            if !replay.replay_data.is_empty() {
                println!("\nFirst 5 events:");
                for (i, event) in replay.replay_data.iter().take(5).enumerate() {
                    match event {
                        ReplayEvent::Osu(e) => {
                            println!(
                                "  {}: Osu - time_delta={}ms, x={}, y={}, keys={}",
                                i + 1,
                                e.time_delta,
                                e.x,
                                e.y,
                                e.keys.value()
                            );
                        }
                        ReplayEvent::Taiko(e) => {
                            println!(
                                "  {}: Taiko - time_delta={}ms, x={}, keys={}",
                                i + 1,
                                e.time_delta,
                                e.x,
                                e.keys.value()
                            );
                        }
                        ReplayEvent::Catch(e) => {
                            println!(
                                "  {}: Catch - time_delta={}ms, x={}, dashing={}",
                                i + 1,
                                e.time_delta,
                                e.x,
                                e.dashing
                            );
                        }
                        ReplayEvent::Mania(e) => {
                            println!(
                                "  {}: Mania - time_delta={}ms, keys={}",
                                i + 1,
                                e.time_delta,
                                e.keys.value()
                            );
                        }
                    }
                }

                if replay.replay_data.len() > 5 {
                    println!("  ... and {} more events", replay.replay_data.len() - 5);
                }
            }

            // Calculate total replay duration
            let total_time: i32 = replay
                .replay_data
                .iter()
                .map(|event| event.time_delta())
                .sum();

            if total_time > 0 {
                let minutes = total_time / 60000;
                let seconds = (total_time % 60000) / 1000;
                let milliseconds = total_time % 1000;
                println!(
                    "\nTotal replay duration: {}:{:02}.{:03}",
                    minutes, seconds, milliseconds
                );
            }

            // Try to write the replay back to verify our packer works
            println!("\n=== Testing Write Functionality ===");
            let output_path = "assets/test_output.osr";
            match replay.write_path(output_path) {
                Ok(()) => {
                    println!("Successfully wrote replay to: {}", output_path);

                    // Verify by reading it back
                    match Replay::from_path(output_path) {
                        Ok(replay_copy) => {
                            println!("Successfully verified written replay!");
                            println!("Original username: {}", replay.username);
                            println!("Copy username: {}", replay_copy.username);
                            println!("Scores match: {}", replay.score == replay_copy.score);
                        }
                        Err(e) => {
                            eprintln!("Error reading back written replay: {}", e);
                        }
                    }
                }
                Err(e) => {
                    eprintln!("Error writing replay: {}", e);
                }
            }

            // Test uncompressed packing
            println!("\n=== Testing Uncompressed Packing ===");
            let uncompressed_path = "assets/test_uncompressed.osr";
            match replay.pack_uncompressed() {
                Ok(uncompressed_data) => {
                    std::fs::write(uncompressed_path, &uncompressed_data)?;
                    println!(
                        "Successfully wrote uncompressed replay to: {}",
                        uncompressed_path
                    );

                    // Compare file sizes
                    let compressed_size = std::fs::metadata(output_path)?.len();
                    let uncompressed_size = std::fs::metadata(uncompressed_path)?.len();

                    println!("Compressed file size: {} bytes", compressed_size);
                    println!("Uncompressed file size: {} bytes", uncompressed_size);
                    println!(
                        "Size difference: {} bytes ({}%)",
                        uncompressed_size as i64 - compressed_size as i64,
                        ((uncompressed_size as f64 - compressed_size as f64)
                            / compressed_size as f64
                            * 100.0) as i32
                    );

                    // Verify uncompressed replay can be read back
                    match Replay::from_path(uncompressed_path) {
                        Ok(replay_uncompressed) => {
                            println!("Successfully verified uncompressed replay!");
                            println!(
                                "Scores match: {}",
                                replay.score == replay_uncompressed.score
                            );
                            println!(
                                "Event counts match: {}",
                                replay.replay_data.len() == replay_uncompressed.replay_data.len()
                            );
                        }
                        Err(e) => {
                            eprintln!("Error reading back uncompressed replay: {}", e);
                        }
                    }
                }
                Err(e) => {
                    eprintln!("Error packing uncompressed replay: {}", e);
                }
            }
        }
        Err(e) => {
            eprintln!("Error reading replay: {}", e);
            eprintln!("Make sure the file is a valid .osr replay file.");
        }
    }

    Ok(())
}

Trait Implementations

impl Clone for Key

fn clone(&self) -> Key

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for Key

impl Debug for Key

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Key

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for Key

impl From<u32> for Key

fn from(value: u32) -> Self

Converts to this type from the input type.

impl PartialEq for Key

fn eq(&self, other: &Key) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl Serialize for Key

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Key