base

src/listener.rs

@@ -0,0 +1,22 @@
+use serenity::{all::{ActivityData, Context, EventHandler, OnlineStatus, Ready}, async_trait};
+use tracing::info;
+
+pub struct Handler;
+
+#[async_trait]
+impl EventHandler for Handler {
+    async fn ready(&self, context: Context, ready: Ready) {
+        info!("{} ({}) is connected!", ready.user.tag(), ready.user.id);
+
+        let http = &context.http;
+        let version = ready.version;
+        let gateway = http.get_bot_gateway().await.unwrap();
+        let total = gateway.session_start_limit.total;
+        let remaining = gateway.session_start_limit.remaining;
+        info!("Connected to the Discord API (version {version}) with {remaining}/{total} sessions remaining.");
+
+        let guilds_len = ready.guilds.len();
+        info!("Connected to {} guilds", guilds_len);
+        context.set_presence(Some(ActivityData::listening(format!("void"))), OnlineStatus::Idle);
+    }
+}

src/main.rs

@@ -1,3 +1,54 @@
-fn main() {
-    println!("Hello, world!");
-}
+mod listener;
+mod commands;
+
+use dotenvy::dotenv;
+use poise::{serenity_prelude as serenity, Framework, FrameworkOptions};
+use ::serenity::all::GatewayIntents;
+use std::env;
+
+type Error = anyhow::Error;
+use tracing_subscriber::{FmtSubscriber, EnvFilter};
+type Context<'a> = poise::Context<'a, Data, Error>;
+
+
+struct Data {}
+
+#[tokio::main()]
+async fn main() -> Result<(), Error> {
+    dotenv().ok();
+
+    let subscriber = FmtSubscriber::builder()
+        .with_env_filter(
+            EnvFilter::try_from_default_env()
+                .unwrap_or_else(|_| EnvFilter::new("info"))
+        )
+        .finish();
+
+    tracing::subscriber::set_global_default(subscriber)?;
+
+    let token = env::var("DISCORD_TOKEN")?;
+
+    let framework = Framework::builder()
+        .options(FrameworkOptions::<Data, Error> {
+            commands: vec![],
+            ..Default::default()
+        })
+        .setup(move |context, _ready, framework| {
+            Box::pin(async move {
+                poise::builtins::register_globally(context, &framework.options().commands).await?;
+                Ok(Data {})
+            })
+        })
+        .build();
+
+    let mut client = serenity::Client::builder(token, GatewayIntents::all())
+        .event_handler(listener::Handler)
+        .framework(framework)
+        .await?;
+
+    if let Err(why) = client.start_autosharded().await {
+        eprintln!("An error occurred while running the client: {why}");
+    }
+
+    Ok(())
+}