add: initial commit

src/lib/buzzer.rs

@@ -0,0 +1,124 @@
+use std::f32::consts::TAU;
+use std::io::Cursor;
+use std::sync::Arc;
+
+use serenity::all::{
+    ButtonStyle, ChannelId, CreateActionRow, CreateButton, GuildId, MessageId, UserId,
+};
+use serenity::prelude::TypeMapKey;
+use songbird::input::{Input, RawAdapter};
+use tokio::sync::Mutex;
+
+pub const BUZZER_CUSTOM_ID: &str = "buzzer:press";
+pub const RESET_CUSTOM_ID: &str = "buzzer:reset";
+pub const LOCK_CUSTOM_ID: &str = "buzzer:lock";
+pub const UNLOCK_CUSTOM_ID: &str = "buzzer:unlock";
+
+#[derive(Debug)]
+pub struct BuzzerSession {
+    pub guild_id: GuildId,
+    pub host_id: UserId,
+    pub voice_channel_id: ChannelId,
+    pub text_channel_id: ChannelId,
+    pub button_message_id: MessageId,
+
+    pub buzzed_user: Option<UserId>,
+    pub is_open: bool,
+}
+
+impl BuzzerSession {
+    pub fn new(
+        guild_id: GuildId,
+        host_id: UserId,
+        voice_channel_id: ChannelId,
+        text_channel_id: ChannelId,
+        button_message_id: MessageId,
+    ) -> Self {
+        Self {
+            guild_id,
+            host_id,
+            voice_channel_id,
+            text_channel_id,
+            button_message_id,
+            buzzed_user: None,
+            is_open: true,
+        }
+    }
+}
+
+pub fn is_session_component(custom_id: &str) -> bool {
+    matches!(
+        custom_id,
+        BUZZER_CUSTOM_ID | RESET_CUSTOM_ID | LOCK_CUSTOM_ID | UNLOCK_CUSTOM_ID
+    )
+}
+
+pub fn session_components(is_open: bool) -> Vec<CreateActionRow> {
+    control_components(is_open, false)
+}
+
+pub fn stopped_session_components() -> Vec<CreateActionRow> {
+    control_components(false, true)
+}
+
+fn control_components(is_open: bool, session_ended: bool) -> Vec<CreateActionRow> {
+    let buzzer = CreateButton::new(BUZZER_CUSTOM_ID)
+        .label("BUZZ!")
+        .style(ButtonStyle::Danger)
+        .disabled(!is_open || session_ended);
+    let reset = CreateButton::new(RESET_CUSTOM_ID)
+        .label("Reset")
+        .style(ButtonStyle::Secondary)
+        .disabled(session_ended);
+    let lock = CreateButton::new(LOCK_CUSTOM_ID)
+        .label("Lock")
+        .style(ButtonStyle::Secondary)
+        .disabled(!is_open || session_ended);
+    let unlock = CreateButton::new(UNLOCK_CUSTOM_ID)
+        .label("Unlock")
+        .style(ButtonStyle::Success)
+        .disabled(is_open || session_ended);
+
+    vec![CreateActionRow::Buttons(vec![buzzer, reset, lock, unlock])]
+}
+
+/// Produces a short, self-contained buzzer tone as stereo f32 PCM.
+pub fn buzzer_sound() -> Input {
+    const SAMPLE_RATE: u32 = 48_000;
+    const DURATION_SECONDS: f32 = 0.4;
+    const FREQUENCY_HZ: f32 = 180.0;
+
+    let sample_count = (SAMPLE_RATE as f32 * DURATION_SECONDS) as usize;
+    let mut pcm = Vec::with_capacity(sample_count * 2 * size_of::<f32>());
+
+    for sample_index in 0..sample_count {
+        let time = sample_index as f32 / SAMPLE_RATE as f32;
+        let progress = sample_index as f32 / sample_count as f32;
+        let attack = (time / 0.01).min(1.0);
+        let release = ((1.0 - progress) / 0.08).min(1.0);
+        let envelope = attack * release;
+
+        // Odd harmonics give the tone the rasp of a physical game-show buzzer.
+        let phase = TAU * FREQUENCY_HZ * time;
+        let value =
+            envelope * (phase.sin() + (3.0 * phase).sin() / 3.0 + (5.0 * phase).sin() / 5.0) * 0.32;
+
+        for _ in 0..2 {
+            pcm.extend_from_slice(&value.to_le_bytes());
+        }
+    }
+
+    RawAdapter::new(Cursor::new(pcm), SAMPLE_RATE, 2).into()
+}
+
+/// The application's single active buzzer session.
+///
+/// Keeping the optional session behind one shared mutex makes the check and
+/// creation performed by `/start` atomic, even when commands arrive together.
+pub type ActiveBuzzerSession = Arc<Mutex<Option<BuzzerSession>>>;
+
+pub struct BuzzerSessionKey;
+
+impl TypeMapKey for BuzzerSessionKey {
+    type Value = ActiveBuzzerSession;
+}