1 files changed, 71 insertions, 0 deletions
diff --git a/src/main.rs b/src/main.rs
new file mode 100644
index 0000000..42855c3
--- /dev/null
+++ b/src/main.rs
@@ -0,0 +1,71 @@
+use rand::Rng;
+use std::env;
+
+use serenity::{
+    model::{channel::Message, gateway::Ready},
+    prelude::*,
+};
+
+struct Handler;
+
+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.
+    fn message(&self, ctx: Context, msg: Message) {
+        if msg.content[0..2] == *"!s" {
+            // 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.
+            println!("{}", &msg.content[3..]);
+            let arg: u32 = msg.content[3..].parse().unwrap();
+            let mut rng = rand::thread_rng();
+            let mut answer = String::from("```md\n");
+            let mut hits = 0;
+            for _ in 0..arg {
+                let rn = rng.gen_range(1, 7);
+                if rn >= 5 {
+                    hits += 1;
+                }
+                answer = format!("{}[{}] ", answer.clone(), rn);
+            }
+            let answer = format!("{}\nhits: {}\n```", answer, hits);
+            if let Err(why) = msg.channel_id.say(&ctx.http, answer) {
+                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.
+    fn ready(&self, _: Context, ready: Ready) {
+        println!("{} is connected!", ready.user.name);
+    }
+}
+
+fn main() {
+    // Configure the client with your Discord bot token in the environment.
+    //let token = env::var("DISCORD_TOKEN")
+    //    .expect("Expected a token in the environment");
+    let token = "Mjk0NTU0MDU4Nzg4NzAwMTYx.XmfrfA.l8MmCKYem6IBlYOjViUeT9tMSaE";
+
+    // 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::new(&token, Handler).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() {
+        println!("Client error: {:?}", why);
+    }
+}