Geometry Dash OmegaBot3/OBot V3 File Format Specification - From https://discord.gg/4vrxF335wh (their official Discord server)

replay.rs

use std::{fs::File, path::Path};

use dlhn::{Deserializer, Serializer};
use serde::{Deserialize, Serialize};
use thiserror::Error;

#[derive(Debug, Error)]
pub enum ReplayError {
    #[error("IO error: {0}")]
    Io(#[from] std::io::Error),
    #[error("Serialization error: {0}")]
    Serialize(#[from] dlhn::ser::Error),
    #[error("Deserialization error: {0}")]
    Deserialize(#[from] dlhn::de::Error),
}

pub type ReplayResult<T> = Result<T, ReplayError>;

#[derive(Serialize, Deserialize, Clone, Copy, PartialEq, Default, Debug)]
pub enum ClickType {
    #[default]
    None,

    Player1Down,
    Player1Up,
    Player2Down,
    Player2Up,

    FpsChange(f32),
}

#[derive(Serialize, Deserialize, Clone, Copy, Debug)]
pub struct Click {
    pub frame: u32,
    pub click_type: ClickType,
}

#[derive(Serialize, Deserialize)]
pub struct Replay {
    pub initial_fps: f32,
    current_fps: f32,
    pub clicks: Vec<Click>,
    current: usize,
}

impl Replay {
    pub fn new(fps: f32) -> Self {
        Self {
            initial_fps: fps,
            current_fps: fps,
            clicks: Vec::new(),
            current: 0,
        }
    }

    pub fn load(path: impl AsRef<Path>) -> ReplayResult<Self> {
        let mut file = File::open(path)?;
        let mut deserializer = Deserializer::new(&mut file);
        Self::deserialize(&mut deserializer)
            .map_err(|e| e.into())
            .map(|mut replay| {
                replay.current_fps = replay.initial_fps;
                replay.current = 0;
                replay
            })
    }

    pub fn save(&self, path: impl AsRef<Path>) -> ReplayResult<()> {
        let mut file = File::create(path)?;
        let mut serializer = Serializer::new(&mut file);
        self.serialize(&mut serializer).map_err(|e| e.into())
    }

    pub fn get_fps(&self) -> f32 {
        self.current_fps
    }

    pub fn add_click(&mut self, click: Click) {
        if let ClickType::FpsChange(fps) = click.click_type {
            self.current_fps = fps;
        }

        self.clicks.push(click);
        self.current = self.clicks.len();
    }

    pub fn on_reset(&mut self, frame: u32, recording: bool) {
        if recording {
            while self
                .clicks
                .last()
                .map(|click| click.frame >= frame)
                .unwrap_or(false)
            {
                self.clicks.pop();
            }

            self.current_fps = self.initial_fps;
            self.current = self.clicks.len();
            for click in self.clicks.iter().rev() {
                if let ClickType::FpsChange(fps) = click.click_type {
                    self.current_fps = fps;
                    break;
                }
            }
        } else {
            self.current = 0;
            self.current_fps = self.initial_fps;
            for (i, click) in self.clicks.iter().enumerate() {
                if click.frame >= frame {
                    self.current = i;
                    break;
                }

                if let ClickType::FpsChange(fps) = click.click_type {
                    self.current_fps = fps;
                }
            }
        }
    }

    pub fn for_all_current_clicks(&mut self, frame: u32, mut f: impl FnMut(ClickType)) {
        for click in self.clicks.iter().skip(self.current) {
            if click.frame > frame {
                break;
            }
            if let ClickType::FpsChange(fps) = click.click_type {
                self.current_fps = fps;
            }
            f(click.click_type);
            self.current += 1;
        }
    }
}

Reading technical discussions about game file formats always reminds me how complex modern games have become behind the scenes Even small mechanics like replay systems or click tracking require careful coding and data structure design I enjoy exploring these details because they show how developers build smooth gameplay experiences Most of the time I play directly on my phone using a simple app and sometimes I test different platforms like https://stakes-india.com/app/ to see how their mobile app works in practice