You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
88 lines
2.7 KiB
Rust
88 lines
2.7 KiB
Rust
|
|
|
|
mod commands;
|
|
mod data_loader;
|
|
mod utils;
|
|
|
|
use serenity::async_trait;
|
|
use serenity::model::channel::Message;
|
|
use serenity::model::gateway::Ready;
|
|
use serenity::prelude::*;
|
|
|
|
struct Handler;
|
|
|
|
#[async_trait]
|
|
impl EventHandler for Handler
|
|
{
|
|
// Set a handler for the `message` event - so that whenever a new message
|
|
// is received - the closure (or function) passed will be called.
|
|
//
|
|
// Event handlers are dispatched through a threadpool, and so multiple
|
|
// events can be dispatched simultaneously.
|
|
async fn message(&self, ctx: Context, msg: Message)
|
|
{
|
|
if msg.content == ".ping"
|
|
{
|
|
// Sending a message can fail, due to a network error, an
|
|
// authentication error, or lack of permissions to post in the
|
|
// channel, so log to stdout when some error happens, with a
|
|
// description of it.
|
|
if let Err(why) = msg.channel_id.say(&ctx.http, "Pong!").await
|
|
{
|
|
println!("Error sending message: {:?}", why);
|
|
}
|
|
}
|
|
|
|
if msg.content == ".randomizer"
|
|
{
|
|
let item = utils::get_random_item();
|
|
if let Err(why) = msg.channel_id.say(&ctx.http, format!("You found {}!", item)).await
|
|
{
|
|
println!("Error sending message: {:?}", why);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Set a handler to be called on the `ready` event. This is called when a
|
|
// shard is booted, and a READY payload is sent by Discord. This payload
|
|
// contains data like the current user's guild Ids, current user data,
|
|
// private channels, and more.
|
|
//
|
|
// In this case, just print what the current user's username is.
|
|
async fn ready(&self, _: Context, ready: Ready) {
|
|
println!("{} is connected!", ready.user.name);
|
|
}
|
|
}
|
|
|
|
|
|
#[tokio::main]
|
|
async fn main()
|
|
{
|
|
let token = match data_loader::load_token("secrets/test.txt")
|
|
{
|
|
Ok(t) => t,
|
|
Err(why) => panic!("Could not load app token: {}", why),
|
|
};
|
|
|
|
println!("Connecting...");
|
|
|
|
let intents = GatewayIntents::GUILD_MESSAGES
|
|
| GatewayIntents::DIRECT_MESSAGES
|
|
| GatewayIntents::MESSAGE_CONTENT;
|
|
|
|
// Create a new instance of the Client, logging in as a bot. This will
|
|
// automatically prepend your bot token with "Bot ", which is a requirement
|
|
// by Discord for bot users.
|
|
let mut client = Client::builder(&token, intents).event_handler(Handler).await.expect("Err creating client");
|
|
|
|
// Finally, start a single shard, and start listening to events.
|
|
//
|
|
// Shards will automatically attempt to reconnect, and will perform
|
|
// exponential backoff until it reconnects.
|
|
if let Err(why) = client.start().await
|
|
{
|
|
println!("Client error: {:?}", why);
|
|
}
|
|
|
|
}
|