diff --git a/src/core/botmodules.rs b/src/core/botmodules.rs index 8e172f6..3e6aead 100644 --- a/src/core/botmodules.rs +++ b/src/core/botmodules.rs @@ -634,7 +634,7 @@ pub struct Routine { pub join_handle : Option>>> , start_time : Option> , pub complete_iterations : i64 , - remaining_iterations : Option , + pub remaining_iterations : Option , routine_attr : Vec , pub internal_signal : RoutineSignal , pub self_routine_ar : Option , diff --git a/src/custom/experimental/experiment003.rs b/src/custom/experimental/experiment003.rs index 343cece..5532dfe 100644 --- a/src/custom/experimental/experiment003.rs +++ b/src/custom/experimental/experiment003.rs @@ -16,6 +16,9 @@ const OF_CMD_CHANNEL:Channel = Channel(String::new()); use casual_logger::Log; use rand::Rng; +use rand::thread_rng; +use rand::rngs::StdRng; +use rand::seq::SliceRandom; use tokio::sync::RwLock; use std::borrow::Borrow; use std::sync::Arc; @@ -50,9 +53,222 @@ pub async fn init(mgr: Arc) { botc1.add_to_modmgr(Arc::clone(&mgr)).await; + // 1. Define the BotAction + let botc1 = BotCommand { + module: BotModule(String::from("experiments003")), + command: String::from("countdown"), // command call name + alias: vec![], // String of alternative names + exec_body: actions_util::asyncbox(countdown_chnl_v1), + help: String::from("Test Command tester"), + required_roles: vec![ + BotAdmin, + Mod(OF_CMD_CHANNEL), + ], + }; + + // 2. Add the BotAction to ModulesManager + botc1.add_to_modmgr(Arc::clone(&mgr)).await; + + + } +async fn countdown_chnl_v1(params : ExecBodyParams) { + + botlog::debug( + "[CHILDFN] countdown_chnl() triggered!", + Some("Experiments003 > countdown_chnl()".to_string()), + Some(¶ms.msg), + ); + + + /* + create a fun countdown BotCommand that allows an Elevated Chatter to + -a add channels to target a routine message + -start to start the routine with an input String, that sends a number + of messages to the targeted channels with a countdown, until it + reaches 0 when it sends a cute or funny message + + NOTE : At the moment, I don't have customizable persistence, so I would just use + counters from the Routine itself + */ + + /* + Because of some bot core features are not available, v1.0 of this could be : + [x] 1. Create a Routine & start a routine + [x] 2. Have the routine go through each joined channel randomly and countdown + [x] 3. At the end, say "0, I love you uwu~" in the last chosen channel + */ + + /* + Usage => 03.28 - skipping arguments as functinoality isn't enhanced + + -a => 03.28 - Not sure if this is possible at the moment? + + -start + + -stop => 03.28 - Not sure if this is possible at the moment? + + */ + + /* + [ ] Functional Use Case + + 1. -a adds targetted channels + + */ + + // [-] Unwraps arguments from message + + // let (arg1, arg2) = { + + // let mut argv = params.msg.message_text.split(' '); + + // argv.next(); // Skip the command name + + // let arg1 = argv.next(); + + // let arg2 = argv.next(); + + // (arg1, arg2) + // }; + + + + // [ ] 1. Create a Routine & start a routine + + // let parentmodule = params.get_parent_module().await; + let module = params.get_module().await; + let channel = params.get_channel().await; + let routine_attr = vec![ + RoutineAttr::RunOnce + ]; + // let exec_body = actions_util::asyncbox(rtestbody); + let exec_body = actions_util::asyncbox(innertester); // <-- 03.27 - when below is uncommented, this is throwing an issue + + async fn innertester(params : ExecBodyParams) { + + + + let logmsg_botact = match *params.curr_act.read().await { + BotAction::C(_) => "command", + BotAction::R(_) => "routine", + BotAction::L(_) => "listener", + } ; + + + botlog::trace( + format!("Params > Curr_act type : {:?}", logmsg_botact).as_str(), + Some("Experiments003 > countdown_chnl()".to_string()), + Some(¶ms.msg), + ); + Log::flush(); + + let bot = Arc::clone(¶ms.bot); + + let botlock = bot.read().await; + + if let BotAction::R(arr) = &*params.curr_act.read().await { + + let iterleft = arr.read().await.remaining_iterations.unwrap_or(0); + + // [ ] get joined channels + let joinedchannels = botlock.bot_channels.clone(); + + + fn pick_a_channel(chnlvec : Vec) -> Channel { + + // More Information : https://docs.rs/rand/0.7.2/rand/seq/trait.SliceRandom.html#tymethod.choose + + let mut rng = thread_rng(); + + // let joinedchannels = botlock.bot_channels.clone(); + (*chnlvec.choose(&mut rng).unwrap()).clone() + } + + let chosen_channel = pick_a_channel(joinedchannels); + + let outmsg = if iterleft == 1 { + format!("{} I love you uwu~",iterleft) + } else { format!("{}",iterleft) }; + + botlock.botmgrs.chat + .say( + // joinedchannels.choose(&mut rng).unwrap().0.clone(), + chosen_channel.0.clone(), + outmsg, + params.clone() + ).await; + + } + + + } + + + + // [ ] setup the routine + if let Ok(newr) = Routine::from( + "Routine Test".to_string(), + module, + channel.unwrap(), + routine_attr, + exec_body, + params.clone() + ).await { + let newr_ar = newr.clone(); + // [ ] start the routine + if let Ok(_) = Routine::start(newr_ar.clone()).await { + + + botlog::debug( + "Successfully started", + Some("experiment003 > countdown_chnl()".to_string()), + Some(¶ms.msg), + ); + + + Log::flush(); + + let bot = Arc::clone(¶ms.bot); + + let botlock = bot.read().await; + + // uses chat.say_in_reply_to() for the bot controls for messages + botlock + .botmgrs + .chat + .say_in_reply_to( + ¶ms.msg, + "Started Routine!".to_string(), + params.clone() + ).await; + + + + } + + + } + + + // botlock + // .botmgrs + // .chat + // .say_in_reply_to( + // ¶ms.msg, + // format!("{:?}",), + // params.clone() + // ).await; + + + +} + + + + async fn test3_body(params : ExecBodyParams) { // println!("testy triggered!"); // NOTE : This test function intends to print (e.g., to stdout) at fn call botlog::debug(