Add exact message length April fools channel

Author: Earthcomputer

src/discord_bot/april_fools_channel/exact_message_length.rs

@@ -0,0 +1,79 @@
+use crate::discord_bot::april_fools_channel::{AprilFoolsChannel, AprilFoolsMessageContext};
+use crate::discord_bot::guild_storage::GuildStorage;
+use async_trait::async_trait;
+use serde::{Deserialize, Serialize};
+use serenity::all::ChannelId;
+use serenity::builder::CreateMessage;
+
+pub(crate) struct ExactMessageLength;
+
+pub(crate) static CHANNEL: ExactMessageLength = ExactMessageLength;
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash, Deserialize, Serialize)]
+pub(crate) struct ExactMessageLengthData {
+    pub channel: ChannelId,
+    pub expected_length: Option<u16>,
+}
+
+#[async_trait]
+impl AprilFoolsChannel for ExactMessageLength {
+    async fn get_error(&self, context: &AprilFoolsMessageContext<'_>) -> Option<String> {
+        let mut storage = GuildStorage::get_mut(context.guild_id).await;
+        let Some(expected_length_data) = &mut storage.april_fools_channels.exact_message_length
+        else {
+            storage.discard();
+            return None;
+        };
+
+        let message_length = context.content.chars().count();
+        let mut just_had_67 = false;
+
+        if let Some(expected_length) = expected_length_data.expected_length {
+            if expected_length as usize != message_length {
+                storage.discard();
+                return Some(format!("Your message was the wrong length! Expected length {expected_length} but it was {message_length}."));
+            }
+
+            just_had_67 = expected_length == 67;
+        }
+
+        let new_length = reroll_message_length(just_had_67);
+        expected_length_data.expected_length = Some(new_length);
+        storage.save().await;
+        None
+    }
+
+    async fn on_success(&self, context: &AprilFoolsMessageContext<'_>) -> crate::Result<()> {
+        let storage = GuildStorage::get_mut(context.guild_id).await;
+        let Some(expected_length) = storage
+            .april_fools_channels
+            .exact_message_length
+            .as_ref()
+            .and_then(|exact_message_length| exact_message_length.expected_length)
+        else {
+            return Ok(());
+        };
+        context
+            .channel_id
+            .send_message(
+                &context.context,
+                CreateMessage::new()
+                    .content(format!("Now expecting message length of {expected_length}")),
+            )
+            .await?;
+        Ok(())
+    }
+}
+
+fn reroll_message_length(just_had_67: bool) -> u16 {
+    if !just_had_67 && rand::random::<bool>() {
+        67
+    } else {
+        let length = rand::random_range(5..=99);
+        if length >= 67 {
+            length + 1
+        } else {
+            length
+        }
+    }
+}

src/discord_bot/april_fools_channel/haiku.rs

@@ -1,6 +1,7 @@
-use crate::discord_bot::april_fools_channel::AprilFoolsChannel;
+use crate::discord_bot::april_fools_channel::{AprilFoolsChannel, AprilFoolsMessageContext};
 use arpabet::phoneme::Phoneme;
 use arpabet::{load_cmudict, Polyphone};
+use async_trait::async_trait;
 use std::collections::BTreeSet;
 use std::mem;
 
@@ -24,8 +25,10 @@ pub(crate) struct HaikuChannel;
 
 pub(crate) static CHANNEL: HaikuChannel = HaikuChannel;
 
+#[async_trait]
 impl AprilFoolsChannel for HaikuChannel {
-    fn get_error(&self, message: &str) -> Option<String> {
+    async fn get_error(&self, context: &AprilFoolsMessageContext<'_>) -> Option<String> {
+        let message = context.content;
         if !message.is_ascii() {
             return Some(INVALID_CHARACTER.to_owned());
         }

src/discord_bot/april_fools_channel/mod.rs

@@ -1,7 +1,10 @@
+use crate::discord_bot::april_fools_channel::exact_message_length::ExactMessageLengthData;
 use crate::discord_bot::guild_storage::GuildStorage;
+use async_trait::async_trait;
 use serde::{Deserialize, Serialize};
 use serenity::all::{ChannelId, Context, CreateMessage, GuildId, MessageFlags, MessageId, User};
 
+mod exact_message_length;
 mod haiku;
 mod simple_words;
 
@@ -22,6 +25,8 @@ pub(crate) struct AprilFoolsChannels {
     pub simple_words: Option<ChannelId>,
     #[serde(default)]
     pub haiku: Option<ChannelId>,
+    #[serde(default)]
+    pub exact_message_length: Option<ExactMessageLengthData>,
 }
 
 pub(crate) async fn get_april_fools_channel(
@@ -34,6 +39,12 @@ pub(crate) async fn get_april_fools_channel(
         Some(&simple_words::CHANNEL)
     } else if channels.haiku == Some(channel_id) {
         Some(&haiku::CHANNEL)
+    } else if channels
+        .exact_message_length
+        .as_ref()
+        .is_some_and(|exact_message_length| exact_message_length.channel == channel_id)
+    {
+        Some(&exact_message_length::CHANNEL)
     } else {
         None
     }
@@ -47,7 +58,7 @@ pub(crate) async fn on_message(
     let error_message = if context.has_attachments {
         Some(april_fools.has_attachment_message().to_owned())
     } else {
-        april_fools.get_error(context.content)
+        april_fools.get_error(&context).await
     };
     if let Some(mut error_message) = error_message {
         context
@@ -77,12 +88,15 @@ pub(crate) async fn on_message(
                     .await?;
             }
         }
+    } else {
+        april_fools.on_success(&context).await?;
     }
     Ok(())
 }
 
+#[async_trait]
 pub(crate) trait AprilFoolsChannel: Send + Sync {
-    fn get_error(&self, message: &str) -> Option<String>;
+    async fn get_error(&self, context: &AprilFoolsMessageContext<'_>) -> Option<String>;
 
     fn your_original_message_was(&self) -> Option<&'static str> {
         Some("Your original message was:")
@@ -91,4 +105,8 @@ pub(crate) trait AprilFoolsChannel: Send + Sync {
     fn has_attachment_message(&self) -> &'static str {
         "Message has attachment"
     }
+
+    async fn on_success(&self, _context: &AprilFoolsMessageContext<'_>) -> crate::Result<()> {
+        Ok(())
+    }
 }

src/discord_bot/april_fools_channel/simple_words.rs

@@ -1,4 +1,5 @@
-use crate::discord_bot::april_fools_channel::AprilFoolsChannel;
+use crate::discord_bot::april_fools_channel::{AprilFoolsChannel, AprilFoolsMessageContext};
+use async_trait::async_trait;
 use std::collections::HashSet;
 use std::sync::OnceLock;
 
@@ -17,8 +18,10 @@ pub(crate) struct SimpleWordsChannel;
 
 pub(crate) static CHANNEL: SimpleWordsChannel = SimpleWordsChannel;
 
+#[async_trait]
 impl AprilFoolsChannel for SimpleWordsChannel {
-    fn get_error(&self, message: &str) -> Option<String> {
+    async fn get_error(&self, context: &AprilFoolsMessageContext<'_>) -> Option<String> {
+        let message = context.content;
         let mut illegal_words = Vec::new();
         let mut current_word_start = None;
         let mut prev_char = None;