.gitignore

@@ -1,3 +1,2 @@
 /target
 .env
-config.json

Cargo.toml

@@ -1,14 +1,16 @@
 [package]
 name = "playerbot"
-version = "1.0.0"
+version = "0.6.1"
 edition = "2021"
 
 [dependencies]
-anyhow = "1.0.102"
+anyhow = "1.0.93"
-futures = "0.3.32"
+dotenvy = "0.15.7"
-poise = "0.6.2"
+log = "0.4.22"
-reqwest = {version = "0.13.3", features = ["json"]}
+poise = "0.6.1"
+pretty_env_logger = "0.5.0"
+reqwest = {version = "0.12.9", features = ["json"]}
 serde = {version = "1.0.215", features = ["derive", "serde_derive"]}
-serde_json = "1.0.149"
+serde_json = {version = "1.0.132", features = []}
 tokio = {version = "1.41.1", features = ["full"]}
 url = "2.5.3"

src/bot_runner.rs

@@ -1,135 +0,0 @@
-
-
-use crate::request::request;
-use crate::types::*;
-use poise::serenity_prelude as serenity;
-use poise::serenity_prelude::{ActivityData, ClientBuilder, GatewayIntents};
-use tokio::sync::Mutex;
-
-pub struct BotRunner {
-    client: poise::serenity_prelude::Client,
-}
-
-pub struct Data {
-    server: Box<dyn ServerInfo>,
-    cached_reply: Mutex<Option<ServerResponse>>,
-}
-
-impl BotRunner {
-    pub async fn new(server: Box<dyn ServerInfo>) -> Self {
-        let token = server.app_token();
-        let framework = poise::Framework::builder()
-            .options(poise::FrameworkOptions {
-                commands: vec![players(), join()],
-                event_handler: |ctx, event, framework, data| {
-                    Box::pin(event_handler(ctx, event, framework, data))
-                },
-                ..Default::default()
-            })
-            .setup(|ctx, _ready, framework| {
-                Box::pin(async move {
-                    poise::builtins::register_globally(ctx, &framework.options().commands).await?;
-                    Ok(Data {
-                        server,
-                        cached_reply: Mutex::new(None),
-                    })
-                })
-            })
-            .build();
-
-        let client = ClientBuilder::new(token, GatewayIntents::non_privileged())
-            .framework(framework)
-            .activity(ActivityData::custom("Waiting on first heartbeat"))
-            .await
-            .unwrap();
-        BotRunner { client }
-    }
-
-    pub async fn run(&mut self) -> Result<(), serenity::Error> {
-        self.client.start().await
-    }
-}
-
-pub async fn event_handler(
-    ctx: &serenity::Context,
-    event: &serenity::FullEvent,
-    _framework: poise::FrameworkContext<'_, Data, serenity::Error>,
-    data: &Data,
-) -> Result<(), serenity::Error> {
-    match event {
-        serenity::FullEvent::Ready {
-            data_about_bot: _bot_data,
-        } => loop {
-            println!("Checking status: {}", data.server.api_address());
-            let http_response = request(data.server.api_address()).await.unwrap();
-            let results = data.server.parse(http_response.text().await.unwrap());
-            match &results {
-                ServerResponse::Offline => {
-                    ctx.set_presence(
-                        Some(ActivityData::custom("Server offline!")),
-                        serenity::OnlineStatus::DoNotDisturb,
-                    );
-                }
-                ServerResponse::Online(online_info) => {
-                    ctx.set_presence(
-                        Some(ActivityData::custom(format!(
-                            "{}/{} online, v{}",
-                            online_info.players_online,
-                            online_info.player_limit,
-                            online_info.version
-                        ))),
-                        if online_info.players_online > 0 {
-                            serenity::OnlineStatus::Online
-                        } else {
-                            serenity::OnlineStatus::Idle
-                        },
-                    );
-                }
-            }
-            //println!("{:#?}", &results);
-            *data.cached_reply.lock().await = Some(results);
-            tokio::time::sleep(std::time::Duration::from_secs(30)).await;
-        },
-        _ => Ok(()),
-    }
-}
-
-#[poise::command(slash_command)]
-pub async fn players(
-    ctx: poise::Context<'_, Data, serenity::Error>,
-) -> Result<(), serenity::Error> {
-    if let Some(reply) = &*ctx.data().cached_reply.lock().await {
-        match reply {
-            ServerResponse::Offline => ctx.say("Server is offline!").await?,
-            ServerResponse::Online(on) => {
-                if let Some(list) = &on.players {
-                    ctx.say(format!(
-                        "{} out of {} players are online.\nPlayers online: {}",
-                        on.players_online,
-                        on.player_limit,
-                        list.join(", ")
-                    ))
-                    .await?
-                } else {
-                    ctx.say(format!(
-                        "{} out of {} players are online.",
-                        on.players_online, on.player_limit
-                    ))
-                    .await?
-                }
-            }
-        };
-    } else {
-        ctx.say("No status response yet. Please wait 30 seconds.")
-            .await?;
-    }
-    Ok(())
-}
-
-#[poise::command(slash_command)]
-pub async fn join(
-    ctx: poise::Context<'_, Data, serenity::Error>,
-) -> Result<(), serenity::Error> {
-    ctx.say(format!("To join, type `{}` in the server URL box or search bar.", ctx.data().server.addressable_name())).await?;
-    Ok(())
-}

src/config_parser.rs

@@ -1,37 +0,0 @@
-use crate::{handlers, types::ServerInfo};
-use serde::Deserialize;
-use std::{fs::File, path::Path};
-use url::Url;
-
-#[derive(Deserialize)]
-pub struct ConfigEntry {
-    handler_type: String,
-    address: Url,
-    token: String,
-}
-
-#[derive(Deserialize)]
-pub struct Config {
-    version: String,
-    entries: Vec<ConfigEntry>,
-}
-
-pub fn parse_configs(path: &Path) -> Result<Config, anyhow::Error> {
-    let file_handle = File::open(path)?;
-    Ok(serde_json::from_reader::<File, Config>(file_handle)?)
-}
-
-pub fn build_handlers(conf: Config) -> Vec<Box<dyn ServerInfo>> {
-    assert_eq!(conf.version, "0.1.0");
-    let mut results: Vec<Box<dyn ServerInfo>> = vec![];
-    for item in conf.entries {
-        match item.handler_type.as_str() {
-            "minecraft" => results.push(Box::new(handlers::minecraft::Server::new(
-                item.token,
-                item.address,
-            ))),
-            _ => {}
-        }
-    }
-    results
-}

src/funcs.rs

@@ -0,0 +1,30 @@
+use poise::serenity_prelude::{ActivityData, OnlineStatus};
+
+use crate::types::ServerResponse;
+
+pub fn set_presence(ctx: &poise::serenity_prelude::Context, status: ServerResponse) {
+    ctx.set_presence(
+        Some(ActivityData::custom(match status.online() {
+            true => {
+                format!(
+                    "{}/{} players online {}",
+                    status.players().unwrap(),
+                    status.max().unwrap(),
+                    if let Some(version) = status.version() {
+                        format!("v{}", version)
+                    } else {
+                        "".into()
+                    }
+                )
+            }
+            false => "Server offline!".to_string(),
+        })),
+        match status.online() {
+            true => match status.is_full() {
+                true => OnlineStatus::Idle,
+                false => OnlineStatus::Online,
+            },
+            false => OnlineStatus::DoNotDisturb,
+        },
+    );
+}

src/handlers/minecraft.rs

@@ -1,104 +0,0 @@
-use serde::Deserialize;
-use serde_json;
-use url::Url;
-
-use crate::types::{ServerInfo, ServerOnlineResponse, ServerResponse};
-
-#[derive(Deserialize, Debug)]
-struct ApiResponse {
-    online: bool,
-    version: Option<String>,
-    players: Option<ApiResponsePlayers>,
-    motd: Option<Motd>,
-}
-
-#[derive(Deserialize, Debug, Clone)]
-struct ApiResponsePlayers {
-    online: u64,
-    max: u64,
-    list: Option<Vec<ApiResponsePlayerEntry>>,
-}
-
-#[derive(Deserialize, Debug, Clone)]
-struct ApiResponsePlayerEntry {
-    name: String,
-    #[allow(dead_code)]
-    uuid: String,
-}
-
-#[derive(Deserialize, Debug)]
-#[allow(dead_code)]
-struct Motd {
-    raw: Vec<String>,
-    clean: Vec<String>,
-    html: Vec<String>,
-}
-
-#[derive(Debug)]
-#[allow(dead_code)]
-pub struct OnlineResponse {
-    searchable_name: String,
-    reported_name: String,
-    clean_name: String,
-    players_online: u64,
-    player_limit: u64,
-    version: String,
-    players: Vec<String>,
-}
-
-pub struct Server {
-    #[allow(dead_code)]
-    token: String,
-    addr: Url,
-}
-
-impl ServerInfo for Server {
-    fn new(token: String, addr: Url) -> Self {
-        Server { token, addr }
-    }
-
-    fn addressable_name(&self) -> String {
-        self.addr.clone().into()
-    }
-
-    fn app_token(&self) -> String {
-        self.token.clone()
-    }
-
-    fn api_address(&self) -> Url {
-        let url_string = format!("https://api.mcsrvstat.us/3/{}", self.addr.host().unwrap());
-        Url::parse(&url_string).unwrap()
-    }
-
-    fn parse(&self, response: String) -> ServerResponse {
-        let parsed_data: ApiResponse = serde_json::from_str(&response).unwrap();
-        match parsed_data.online {
-            true => {
-                let players = parsed_data.players.unwrap();
-                let motd = parsed_data.motd.as_ref().unwrap();
-                self::ServerResponse::Online(ServerOnlineResponse {
-                    searchable_name: self.addr.host().unwrap().to_string(),
-                    readable_name: motd.clean.first().unwrap().into(),
-                    reported_name: motd.clean.first().unwrap().into(),
-                    clean_name: motd.clean.first().unwrap().into(),
-                    players_online: players.online,
-                    player_limit: players.max,
-                    version: parsed_data.version.unwrap(),
-                    players: Some(
-                        players
-                            .list
-                            .unwrap_or_default()
-                            .iter()
-                            .map(|e| e.name.clone())
-                            .collect(),
-                    ),
-                })
-            }
-            false => ServerResponse::Offline,
-        }
-    }
-
-    fn supports_playerlist(&self) -> bool {
-        true
-    }
-}

src/handlers/mod.rs

@@ -1,2 +0,0 @@
-pub mod minecraft;
-pub mod scpsl;

src/handlers/scpsl.rs

@@ -1 +0,0 @@
-

src/main.rs

@@ -1,22 +1,33 @@
-#![feature(impl_trait_in_bindings)]
+mod funcs;
-mod bot_runner;
+mod minecraft;
-mod config_parser;
+mod scpsl;
-mod handlers;
-mod request;
 mod types;
+use dotenvy::{self, dotenv};
+use minecraft::Minecraft;
+use tokio::join;
+use url::{self, Url};
 
-use crate::bot_runner::BotRunner;
+#[macro_use]
-use futures::{self, future::try_join_all};
+extern crate log;
-use std::path::Path;
 
 #[tokio::main]
 async fn main() {
-    let config = config_parser::parse_configs(Path::new("config.json")).unwrap();
+    dotenv().ok();
-    let handlers = config_parser::build_handlers(config);
+    pretty_env_logger::init();
-    let mut bots: Vec<bot_runner::BotRunner> = vec![];
+    let gamerzone = Minecraft::new(
-    for item in handlers {
+        Url::try_from("https://api.mcstatus.io/v2/status/java/bleat.shibedrill.site").unwrap(),
-        bots.push(BotRunner::new(item).await);
+        std::env::var("TOKEN_BOT_MC_BLEAT").unwrap(),
-    }
+        "DeersCord SMP".into(),
-    let futures: Vec<_> = bots.iter_mut().map(|b| b.run()).collect();
+    );
-    let _ = try_join_all(futures).await;
+    let mchprs = Minecraft::new(
+        Url::try_from("https://api.mcstatus.io/v2/status/java/mchprs.shibedrill.site").unwrap(),
+        std::env::var("TOKEN_BOT_MC_MCHPRS").unwrap(),
+        "Project MCRV".into(),
+    );
+    let dawn = Minecraft::new(
+        Url::try_from("https://api.mcstatus.io/v2/status/java/dawn.shibedrill.site").unwrap(),
+        std::env::var("TOKEN_BOT_MC_DAWN").unwrap(),
+        "Dawn Group".into(),
+    );
+    join!(mchprs.run(), gamerzone.run(), dawn.run());
 }

src/minecraft.rs

@@ -0,0 +1,131 @@
+use poise::serenity_prelude as serenity;
+use reqwest::{Client, Request};
+use serenity::*;
+use url::Url;
+
+use crate::{
+    funcs,
+    types::{self, ServerResponse},
+};
+
+#[derive(serde::Deserialize, Debug)]
+struct ServerSummary {
+    online: bool,
+    players: Option<Players>,
+    version: Version,
+}
+
+#[derive(serde::Deserialize, Debug)]
+struct Version {
+    name_raw: String,
+    name_clean: String,
+    name_html: String,
+    protocol: u32,
+}
+
+#[derive(serde::Deserialize, Debug)]
+struct Players {
+    online: i32,
+    max: i32,
+}
+
+pub struct Data {
+    controller: Minecraft,
+}
+
+#[derive(Clone)]
+pub struct Minecraft {
+    url: Url,
+    token: String,
+    name: String,
+}
+
+impl Minecraft {
+    pub fn new(url: Url, token: String, name: String) -> Self {
+        Self { url, token, name }
+    }
+
+    pub async fn get_status(&self) -> Result<ServerResponse, anyhow::Error> {
+        let http_client = Client::new();
+        trace!("Created HTTP client");
+        let request = Request::new(reqwest::Method::GET, self.url.clone());
+        trace!("Created HTTP request");
+        let response = http_client.execute(request).await?;
+        trace!("Ran request using client");
+        let data: ServerSummary = serde_json::from_str(&response.text().await?)?;
+
+        trace!("Response JSON for {}: {:#?}", self.name, data); // this
+
+        if let Some(players) = data.players {
+            Ok(ServerResponse::new(
+                data.online,
+                Some(players.online as u32),
+                Some(players.max as u32),
+                Some(data.version.name_raw),
+            ))
+        } else {
+            Ok(ServerResponse::new(data.online, None, None, None))
+        }
+    }
+    pub async fn run(&self) {
+        let controller = self.clone();
+        let framework = poise::Framework::builder()
+            .options(poise::FrameworkOptions {
+                event_handler: |ctx, event, framework, data| {
+                    Box::pin(event_handler(ctx, event, framework, data))
+                },
+                ..Default::default()
+            })
+            .setup(|ctx, _ready, framework| {
+                Box::pin(async move {
+                    poise::builtins::register_globally(ctx, &framework.options().commands).await?;
+                    Ok(Data { controller })
+                })
+            })
+            .build();
+        info!("Built framework successfully.");
+
+        let mut discord_client = ClientBuilder::new(
+            self.token.clone(),
+            serenity::GatewayIntents::non_privileged(),
+        )
+        .framework(framework)
+        .activity(ActivityData::custom("Waiting on initial status..."))
+        .await
+        .inspect_err(|e| error!("Failed to start client: {}", e))
+        .unwrap();
+        info!("Built client successfully.");
+
+        let _ = discord_client.start().await;
+    }
+}
+
+pub async fn event_handler(
+    ctx: &serenity::Context,
+    event: &serenity::FullEvent,
+    _framework: poise::FrameworkContext<'_, Data, Error>,
+    data: &Data,
+) -> Result<(), Error> {
+    match event {
+        serenity::FullEvent::Ready {
+            data_about_bot: _bot_data,
+        } => loop {
+            trace!("Running loop routine");
+            let status = data
+                .controller
+                .get_status()
+                .await
+                .inspect_err(|e| error!("{}: Failed to get status: {}", data.controller.name, e))
+                .unwrap();
+            info!(
+                "{}: Got status: {}",
+                data.controller.name,
+                status.to_string()
+            );
+
+            funcs::set_presence(ctx, status);
+            tokio::time::sleep(std::time::Duration::from_secs(30)).await;
+        },
+        _ => Ok(()),
+    }
+}

src/request.rs

@@ -1,9 +0,0 @@
-use reqwest::{header::HeaderValue, Response};
-use url::Url;
-
-pub async fn request(url: Url) -> Result<Response, reqwest::Error> {
-    let client = reqwest::Client::new();
-    let mut request = reqwest::Request::new(reqwest::Method::GET, url);
-    request.headers_mut().append("User-Agent", HeaderValue::from_str("Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Mobile Safari/537.36").unwrap());
-    client.execute(request).await
-}

src/scpsl.rs

@@ -0,0 +1,115 @@
+use crate::{funcs, types::ServerResponse};
+use poise::serenity_prelude as serenity;
+use reqwest::{Client, Request};
+use serenity::*;
+use url::Url;
+
+#[derive(serde::Deserialize, Debug)]
+#[allow(non_snake_case)]
+struct ServerSummary {
+    online: bool,
+    players: String,
+}
+
+pub struct Data {
+    controller: Scpsl,
+}
+
+#[derive(Clone)]
+pub struct Scpsl {
+    name: String,
+    url: Url,
+    token: String,
+}
+
+impl Scpsl {
+    pub fn new(url: Url, token: String, name: String) -> Self {
+        Self { url, token, name }
+    }
+    async fn get_status(&self) -> Result<ServerResponse, anyhow::Error> {
+        let http_client = Client::new();
+        trace!("Created HTTP client");
+        let request = Request::new(reqwest::Method::GET, self.url.clone());
+        trace!("Created HTTP request");
+        let response = http_client.execute(request).await?;
+        trace!("Ran request using client");
+        let data: ServerSummary = serde_json::from_str(&response.text().await?)?;
+
+        trace!("Response JSON for {}: {:#?}", self.name, data); // this is the only thing I added.
+
+        let playercount: Result<Vec<u32>, _> =
+            data.players.split('/').map(|x| x.parse::<u32>()).collect();
+
+        let playercount_unwrapped = playercount?;
+
+        Ok(ServerResponse::new(
+            data.online,
+            playercount_unwrapped.first().copied(),
+            playercount_unwrapped.get(1).copied(),
+            None,
+        ))
+    }
+
+    pub async fn run(&self) {
+        let controller = self.clone();
+        let framework = poise::Framework::builder()
+            .options(poise::FrameworkOptions {
+                initialize_owners: true,
+                event_handler: |ctx, event, framework, data| {
+                    Box::pin(event_handler(ctx, event, framework, data))
+                },
+                ..Default::default()
+            })
+            .setup(|ctx, _ready, framework| {
+                Box::pin(async move {
+                    poise::builtins::register_globally(ctx, &framework.options().commands).await?;
+                    Ok(Data { controller })
+                })
+            })
+            .build();
+        info!("Built framework successfully.");
+
+        let mut discord_client = ClientBuilder::new(
+            self.token.clone(),
+            serenity::GatewayIntents::non_privileged(),
+        )
+        .framework(framework)
+        .activity(ActivityData::custom("Waiting on initial status..."))
+        .await
+        .inspect_err(|e| error!("Failed to start client: {}", e))
+        .unwrap();
+        info!("Built client successfully.");
+
+        let _ = discord_client.start().await;
+    }
+}
+
+pub async fn event_handler(
+    ctx: &serenity::Context,
+    event: &serenity::FullEvent,
+    _framework: poise::FrameworkContext<'_, Data, Error>,
+    data: &Data,
+) -> Result<(), Error> {
+    match event {
+        serenity::FullEvent::Ready {
+            data_about_bot: _data,
+        } => loop {
+            trace!("Running loop routine");
+            let status = data
+                .controller
+                .get_status()
+                .await
+                .inspect_err(|e| error!("{}: Failed to get status: {}", data.controller.name, e))
+                .unwrap();
+            info!(
+                "{}: Got status: {}",
+                data.controller.name,
+                status.to_string()
+            );
+
+            funcs::set_presence(ctx, status);
+            tokio::time::sleep(std::time::Duration::from_secs(30)).await;
+        },
+        _ => Ok(()),
+    }
+}

src/types.rs

@@ -1,40 +1,65 @@
-use url::Url;
+use std::fmt::format;
 
-#[derive(Debug)]
+pub struct ServerResponse {
-pub enum ServerResponse {
+    online: bool,
-    Offline,
+    players: Option<u32>,
-    Online(ServerOnlineResponse),
+    max: Option<u32>,
+    version: Option<String>,
 }
 
-#[derive(Debug)]
+impl ServerResponse {
-#[allow(dead_code)]
+    pub fn new(
-pub struct ServerOnlineResponse {
+        online: bool,
-    pub players_online: u64,
+        players: Option<u32>,
-    pub player_limit: u64,
+        max: Option<u32>,
-    pub version: String,
+        version: Option<String>,
-    pub searchable_name: String,
+    ) -> Self {
-    pub readable_name: String,
+        ServerResponse {
-    pub clean_name: String,
+            online,
-    pub reported_name: String,
+            players,
-    pub players: Option<Vec<String>>,
+            max,
+            version,
+        }
     }
 
-#[allow(dead_code)]
+    pub fn online(&self) -> bool {
-pub trait ServerInfo: Send + Sync {
+        self.online
-    fn new(token: String, addr: Url) -> Self
+    }
-    where
+
-        Self: Sized;
+    pub fn players(&self) -> Option<u32> {
-
+        self.players
-    /// An addressable, unique identifier, used for its API.
+    }
-    /// If it is a Minecraft server, this can be a fully qualified domain name or URL.
+
-    /// If this is an SCP secret laboratory server, it can be a server ID.
+    pub fn max(&self) -> Option<u32> {
-    fn addressable_name(&self) -> String;
+        self.max
-    /// The address wrapped in the API URL.
+    }
-    fn api_address(&self) -> Url;
+
-    fn parse(&self, response: String) -> ServerResponse;
+    pub fn is_full(&self) -> bool {
-
+        self.players >= self.max
-    /// The app token used to send status updates.
+    }
-    fn app_token(&self) -> String;
+
-
+    pub fn version(&self) -> &Option<String> {
-    fn supports_playerlist(&self) -> bool;
+        &self.version
+    }
+
+    pub fn to_string(&self) -> String {
+        format!(
+            "{} {} {}",
+            if let Some(players) = self.players {
+                if let Some(max) = self.max {
+                    format!("{}/{}", players, max)
+                } else {
+                    players.to_string()
+                }
+            } else {
+                "N/A".into()
+            },
+            self.online,
+            if let Some(version) = &self.version {
+                version.to_string()
+            } else {
+                "N/A".into()
+            }
+        )
+    }
 }