sorceress/rustcord
sorceress
/
rustcord
1
0
Fork 1
Code Issues Pull Requests Projects Releases Wiki Activity

full rewrite

This commit is contained in:
EvilDeaaaadd 2019-09-23 00:34:03 +03:00
parent 4ac2f0f75e
commit 27a868085d
5 changed files with 1647 additions and 498 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
.gitignore vendored
View File

@ -1,3 +1,2 @@
/target
**/*.rs.bk

1546
Cargo.lock generated
View File

File diff suppressed because it is too large Load Diff

14
Cargo.toml
View File

@ -1,12 +1,14 @@
[package]
name = "rustcord"
version = "0.2.1"
name = "rustcordmkii"
version = "0.1.0"
authors = ["EvilDeaaaadd <EvilDeaaaadd@protonmail.com>"]
edition = "2018"
# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
[dependencies]
serenity = "0.5.5"
rand = "0.3.14"
#select = "0.4.2"
sys-info = "0.5.6"
serenity = "0.7.0"
rand = "0.7.2"
sys-info = "0.5.8"
urbandict = "0.2.0"
owoify = "0.1.4"

1
Procfile
View File

@ -1 +0,0 @@
worker: ./target/release/rustcord

453
src/main.rs
View File

@ -1,17 +1,17 @@
#[macro_use]
extern crate serenity;
extern crate rand;
extern crate sys_info;
extern crate urbandict;
extern crate owoify;
#![allow(clippy::unreadable_literal)]
use rand::Rng;
use serenity::client::Client;
use serenity::framework::standard::StandardFramework;
use serenity::model::gateway::Ready;
use serenity::prelude::*;
use std::{env, process};
use owoify::OwOifiable;
use rand::Rng;
use serenity::{
client::Client,
framework::standard::{
macros::{check, command, group},
Args, CheckResult, CommandOptions, CommandResult, DispatchError, Reason, StandardFramework,
},
model::{channel::Message, gateway::Ready, id::UserId, user::OnlineStatus},
prelude::*,
};
use std::{env, process};
struct Handler;
@ -23,115 +23,157 @@ impl EventHandler for Handler {
ready.user.name, shard[0], shard[1]
);
use serenity::model::gateway::Game;
use serenity::model::user::OnlineStatus;
let game = Game::playing("with lemons");
use serenity::model::gateway::Activity;
let activity = Activity::listening("dj0nt");
let status = OnlineStatus::Online;
ctx.set_presence(Some(game), status);
ctx.set_presence(Some(activity), status);
}
}
}
group!({
name: "general",
options: {},
commands: [init, ping, halt, list_srv, host, ship, headpat, uwu, gayculator, waffle, sausage, ad, help, compare_bot, what, owo, info]
});
fn main() {
// Login with a bot token from the environment
let mut client = Client::new(&env::var("DISCORD_TOKEN").expect("token"), Handler)
let mut client = Client::new(&env::var("DISCORD_TOKEN").expect("Invalid token"), Handler)
.expect("Error creating client");
client.with_framework(
StandardFramework::new()
.configure(|c| c.prefix("owo ").case_insensitivity(true))
.cmd("init", init)
.cmd("gayculator", gayculator)
.command("ad", |c| {
c.cmd(ad).check(|_, msg, _, _| {
msg.guild_id == Some(serenity::model::id::GuildId(255386835964919810))
.configure(|c| {
c.with_whitespace(true)
.owners(vec![UserId(254310746450690048)].into_iter().collect())
.prefixes(vec!["owo ", "OwO "])
.no_dm_prefix(true)
.case_insensitivity(true)
.by_space(false)
})
.on_dispatch_error(|ctx, msg, error| {
if let DispatchError::CheckFailed("Owner", Reason::Unknown) = error {
let _ = msg.channel_id.say(&ctx.http, "no");
} else if let DispatchError::Ratelimited(seconds) = error {
let _ = msg
.channel_id
.say(&ctx.http, &format!("Try again in {} seconds.", seconds));
}
})
.cmd("waffle", waffle)
.cmd("sausage", sausage)
.cmd("halt", halt)
.cmd("help", help)
.cmd("info", info)
.cmd("ping", ping)
.cmd("list_srv", list_srv)
.command("compare_bot", |c| {
c.cmd(compare_bot).known_as("compare bot")
})
.cmd("ship", ship)
.cmd("uwu", uwu)
.cmd("owo", owo)
.cmd("host", host)
.cmd("headpat", headpat)
.cmd("what's this", what),
.group(&GENERAL_GROUP),
);
// start listening for events by starting a single shard
if let Err(e) = client.start() {
println!("An error occurred while running the client: {:?}", e);
}
}
command!(init(_ctx, message) {
#[check]
#[name = "Owner"]
fn owner_check(_: &mut Context, msg: &Message, _: &mut Args, _: &CommandOptions) -> CheckResult {
if msg.author.id == 254310746450690048 {
CheckResult::Success
} else {
CheckResult::Failure(Reason::Unknown)
}
}
#[check]
#[name = "Server"]
fn server_check(_: &mut Context, msg: &Message, _: &mut Args, _: &CommandOptions) -> CheckResult {
(msg.guild_id == Some(serenity::model::id::GuildId(255386835964919810))).into()
}
#[command]
fn init(ctx: &mut Context, message: &Message) -> CommandResult {
let num = rand::thread_rng().gen_range(0, 2);
match num {
0 => {
let _ = message.channel_id.say("The Discordinator9000 is going sicko mode!");
let _ = message
.channel_id
.say(&ctx.http, "The Discordinator9000 is going sicko mode!");
}
1 => {
let _ = message.channel_id.say("The Discordinator9000 is ready to take over the world!");
let _ = message.channel_id.say(
&ctx.http,
"The Discordinator9000 is ready to take over the world!",
);
}
_ => {
let _ = message.channel_id.say("Oopsie woopsie! UwU");
let _ = message.channel_id.say(&ctx.http, "Oopsie woopsie! UwU");
}
}
});
command!(ping(_ctx, message) {
let _ = message.reply("Pong!");
});
Ok(())
}
command!(halt(ctx, message) {
if message.author.id == 254310746450690048 {
use serenity::model::user::OnlineStatus;
let status = OnlineStatus::Offline;
ctx.set_presence(None, status);
ctx.quit();
#[command]
fn ping(ctx: &mut Context, message: &Message) -> CommandResult {
let _ = message.reply(&ctx, "Pong!");
Ok(())
}
#[command]
#[checks(Owner)]
fn halt(ctx: &mut Context) -> CommandResult {
ctx.set_presence(None, OnlineStatus::Offline);
use std::{thread, time};
let one_s = time::Duration::new(2, 0);
thread::sleep(one_s);
process::exit(0);
} else {
let _ = message.channel_id.say("no");
}
});
command!(list_srv(_ctx, message) {
if message.author.id == 254310746450690048 {
use serenity::CACHE;
let cache = CACHE.read();
#[command]
#[checks(Owner)]
fn list_srv(ctx: &mut Context, message: &Message) -> CommandResult {
let mut list = String::new();
let cache = ctx.cache.read();
for (index, guild_lock) in cache.guilds.values().enumerate() {
let guild = guild_lock.read();
list.push_str(&format!("{}: {}\n", index, guild.name));
}
let _ = message.channel_id.say(list.replace("@everyone", "WARN: @ mention used as server name").to_string());
}
});
let _ = message.channel_id.say(
&ctx.http,
list.replace("@everyone", "@\u{200B}everyone").to_string(),
);
command!(host(_ctx, message) {
if message.author.id == 254310746450690048 {
let _ = message.channel_id.say(format!("Debug\nOS: {:?}\nHost: {:?}", sys_info::os_type().unwrap(), sys_info::hostname().unwrap()));
Ok(())
}
});
command!(ship(_ctx, message, args) {
#[command]
#[checks(Owner)]
fn host(ctx: &mut Context, message: &Message) -> CommandResult {
let _ = message.channel_id.say(
&ctx.http,
format!(
"Debug\nOS: {:?}\nHost: {:?}",
sys_info::os_type().unwrap(),
sys_info::hostname().unwrap()
),
);
Ok(())
}
#[command]
fn ship(ctx: &mut Context, message: &Message, mut args: Args) -> CommandResult {
use std::collections::hash_map::DefaultHasher;
use std::hash::{Hash, Hasher};
let first = calculate_hash(&args.single::<String>().unwrap());
let second = calculate_hash(&args.single::<String>().unwrap());
let first = calculate_hash(
&args
.single::<String>()
.unwrap_or_else(|_| "Null".to_string()),
);
let second = calculate_hash(
&args
.single::<String>()
.unwrap_or_else(|_| "Null".to_string()),
);
let mut slider = String::new();
let res = (first % second) / 100000000000000000;
@ -146,107 +188,137 @@ use std::hash::{Hash, Hasher};
slider.push('▬');
num += 1;
}
let _ = message.channel_id.send_message(|m| m
.embed(|e| e
.title(format!("{}%", res))
let _ = message.channel_id.send_message(&ctx.http, |m| {
m.embed(|e| {
e.title(format!("{}%", res))
.description(slider)
.color(0xff00ce)
));
})
});
fn calculate_hash<T: Hash>(t: &T) -> u64 {
let mut s = DefaultHasher::new();
t.hash(&mut s);
s.finish()
}
});
command!(headpat(_ctx, message, args) {
message.channel_id.send_message(|m|
m.embed(|e|
e.title(format!("Sending headpats to **{}**...", args.trim().to_string()))
Ok(())
}
#[command]
fn headpat(ctx: &mut Context, message: &Message, args: Args) -> CommandResult {
message
.channel_id
.send_message(&ctx.http, |m| {
m.embed(|e| {
e.title(format!("Sending headpats to **{}**...", args.rest().trim()))
.image("https://i.pinimg.com/originals/83/1a/90/831a903eab6d827dcfd298b9e3196e30.jpg")
.description("[Source](https://www.pinterest.com/pin/377809856242075277/)"))
).expect("Failed to send message!");
});
.description("[Source](https://www.pinterest.com/pin/377809856242075277/)")
})
})
.expect("Failed to send message!");
command!(owo(_ctx, message, args) {
let _ = message.channel_id.say(args.trim().to_string().owoify());
});
Ok(())
}
command!(uwu(_ctx, message) {
#[command]
fn uwu(ctx: &mut Context, message: &Message) -> CommandResult {
let num = rand::thread_rng().gen_range(0, 4);
match num {
0 => {
let _ = message.channel_id.send_message(|m| m
let _ = message.channel_id.send_message(&ctx.http, |m| m
.embed(|e| e
.image("https://i.redditmedia.com/qDD9W7NJqTAk31y061TuRW9R8qOcCuEmmCWyOsUEavE.png?fit=crop&crop=faces%2Centropy&arh=2&w=640&s=ebdd3f1970b4fe70ccd24a1958e7fc32")
)); }
1 => {
let _ = message.channel_id.send_message(|m| m
.embed(|e| e
.image("https://www.shitpostbot.com/img/sourceimages/smash-that-mfuckn-uwu-button-57b5aa1de9fe4.jpeg")
)); }
2 => {
let _ = message.channel_id.send_message(|m| m
.embed(|e| e
.image("https://www.shitpostbot.com/img/sourceimages/fallout-nv-owo-57e586ae15322.jpeg")
)); }
3 => {
let _ = message.channel_id.send_message(|m| m
.embed(|e| e
.image("https://i.redditmedia.com/-JaK9YW7mPz2S2xBJmXvW4fZ58uGMa4l6GIgYt3dqZg.jpg?fit=crop&crop=faces%2Centropy&arh=2&w=640&s=ebab29a577346b4d18ec914538b69bb4")
)); }
_ => {
let _ = message.channel_id.say("UwU");
}
}
});
command!(gayculator(_ctx, message, args) {
if message.author.id != 191948420141809665 {
let number_32: i32 = args.trim().parse().unwrap_or(1);
let mut result = if number_32 % 2 == 0 { "You are straight as heck!".to_string() } else { "You are hella gay!".to_string() };
let _ = message.channel_id.send_message(|m| m
.embed(|e| e
.title("Gayness level:")
.description(result)
.color(0xff00f9)
));
}
});
/* command!(notice(ctx, message, args) {
let query: String = args.trim().parse().expect("ERR");
let query = query.replace(" ", "+");
let link = String::from(format!("https://www.google.com/search?q={}&source=lnms&tbm=isch", query));
}); */
command!(waffle(_ctx, message) {
let _ = message.channel_id.say("h");
});
command!(sausage(_ctx, message) {
let _ = message.channel_id.send_message(|m| m
1 => {
let _ = message.channel_id.send_message(&ctx.http, |m| m
.embed(|e| e
.title("Dongle!")
.image("https://cdn.discordapp.com/attachments/379673147764506624/431546724637736971/image.png"))
);
.image("https://www.shitpostbot.com/img/sourceimages/smash-that-mfuckn-uwu-button-57b5aa1de9fe4.jpeg")
));
}
2 => {
let _ = message.channel_id.send_message(&ctx.http, |m| {
m.embed(|e| {
e
.image("https://www.shitpostbot.com/img/sourceimages/fallout-nv-owo-57e586ae15322.jpeg")
})
});
}
3 => {
let _ = message.channel_id.send_message(&ctx.http, |m| m
.embed(|e| e
.image("https://i.redditmedia.com/-JaK9YW7mPz2S2xBJmXvW4fZ58uGMa4l6GIgYt3dqZg.jpg?fit=crop&crop=faces%2Centropy&arh=2&w=640&s=ebab29a577346b4d18ec914538b69bb4")
));
}
_ => {
let _ = message.channel_id.say(&ctx.http, "UwU");
}
}
command!(ad(_ctx, message) {
let _ = message.channel_id.send_message(|m| m
Ok(())
}
#[command]
fn gayculator(ctx: &mut Context, message: &Message, mut args: Args) -> CommandResult {
//the amiter check
if message.author.id != 191948420141809665 {
let number_32: i32 = args.single::<i32>().unwrap_or(1);
let result = if number_32 % 2 == 0 {
"much straight".to_string()
} else {
"large gay".to_string()
};
let _ = message.channel_id.send_message(&ctx.http, |m| {
m.embed(|e| {
e.title("Gayness level:")
.description(result)
.color(0xff00f9)
})
});
}
Ok(())
}
#[command]
fn waffle(ctx: &mut Context, message: &Message) -> CommandResult {
let _ = message.channel_id.say(&ctx.http, "h");
Ok(())
}
#[command]
fn sausage(ctx: &mut Context, message: &Message) -> CommandResult {
let _ = message.channel_id.send_message(&ctx.http, |m| {
m.embed(|e| {
e
.title("Dongle!")
.image("https://cdn.discordapp.com/attachments/379673147764506624/431546724637736971/image.png")
})
});
Ok(())
}
#[command]
#[checks(Server)]
fn ad(ctx: &mut Context, message: &Message) -> CommandResult {
let _ = message.channel_id.send_message(&ctx.http, |m| m
.embed(|e| e
.title(":b:ottom text")
.description("hey @\u{200B}everyone , JOIN OUR SUPER KOOL SERVER ON 1.5.2 CRACKED SERVER MARRIAGE GAY DRUGS TOWN OF SALEM PLUGINS ECONOMY NO GRIEF PROTECTION BETTER THAN HYPIXAL SUPPORTS EMOJI FREE OP CSGO PVP SKYWARS SKYBLOCC BLOCKCHAIN AR VR TENSORFLOW IoT QUANTUM COMPUTER SERVERLESS DARK DATA JAVA ALSO ITS LIKE ROBLOX AAAAA JOIN AT superkool.[B].cc OwO (edited)(edited)(edited)(edited)(edited)(edited)(edited)")
***REMOVED***
.thumbnail("https://i.imgur.com/8MU0gqD.png")
.color(0x00f3ff))
);
});
command!(help(_ctx, message) {
let _ = message.channel_id.send_message(|m| m
.embed(|e| e
.title("Availble commands:")
Ok(())
}
#[command]
fn help(ctx: &mut Context, message: &Message) -> CommandResult {
let _ = message.channel_id.send_message(&ctx.http, |m| {
m.embed(|e| {
e.title("Availble commands:")
.description("All commands are case-insensitive")
.fields(vec![
("owo init", "Introduce me", false),
@ -255,24 +327,39 @@ command!(help(_ctx, message) {
("owo sausage", "sosig", false),
("owo help", "Help the fellow humanz!", false),
("owo info", "Show information about me!", false),
("owo compare_bot ``bot's name``", "Compare me to other robots!", false),
("owo what's this ``word``", "Find a definition of word", false),
("owo ship ``name 1`` ``name 2``", "*shipping intensifies*", false),
(
"owo compare_bot ``bot's name``",
"Compare me to other robots!",
false,
),
(
"owo what's this ``word``",
"Find a definition of word",
false,
),
(
"owo ship ``name 1`` ``name 2``",
"*shipping intensifies*",
false,
),
("owo headpat ``name``", "Headpat someone", false),
("owo owo ``text``", "owoify input text", false),
("Admin commands:", "\u{200B}", true),
("owo halt", "kill me", false),
("owo list_srv", "list my servers", false),
("owo host", "Display host info", false)
("owo host", "Display host info", false),
])
.color(0x000000)
));
})
});
command!(info(_ctx, message) {
use serenity::CACHE;
let num = CACHE.read().guilds.len();
let _ = message.channel_id.send_message(|m| m
Ok(())
}
#[command]
fn info(ctx: &mut Context, message: &Message) -> CommandResult {
let num = ctx.cache.read().guilds.len();
let _ = message.channel_id.send_message(&ctx.http, |m| m
.embed(|e| e
.title("Discordinator9000's info:")
.description("h")
@ -280,34 +367,58 @@ let num = CACHE.read().guilds.len();
.field("Server count:", num , false)
.field("Invite:", "[Invite link](https://discordapp.com/api/oauth2/authorize?client_id=470350233419907129&permissions=2048&scope=bot)", false )
.footer(|f| f
.text("Written in Rust using Serenity library"))
.text("Written in Rust using Serenity, OwOify and a few other libraries"))
.color(0xee657)
));
});
Ok(())
}
command!(compare_bot(_ctx, message, args) {
#[command]
#[aliases("compare")]
fn compare_bot(ctx: &mut Context, message: &Message, mut args: Args) -> CommandResult {
//the amiter check
if message.author.id != 191948420141809665 {
let text: String = args.trim().parse()
.expect("ERR!");
let text: String = args
.single::<String>()
.unwrap_or_else(|_| "Null".to_string());
if text.to_lowercase().contains("nib") {
let _ = message.channel_id.say("I am superior to NibBot");
let _ = message.channel_id.say(&ctx.http, "I am superior to NibBot");
} else if text.to_lowercase().contains("amit") {
let _ = message.channel_id.say("Amiter is big dumb");
let _ = message.channel_id.say(&ctx.http, "Amiter is big dumb");
} else if text.to_lowercase().contains("discordinator") {
let _ = message.channel_id.say("Option<(!, ())>");
let _ = message.channel_id.say(&ctx.http, "Option<(!, ())>");
} else {
let _ = message.channel_id.say(format!("Me and {} are friends!", text));
let _ = message
.channel_id
.say(&ctx.http, format!("Me and {} are friends!", text));
}
}
});
Ok(())
}
command!(what(_ctx, message, args){
let text: String = args.trim().parse().expect("ERR");
#[command]
#[aliases("what's this")]
fn what(ctx: &mut Context, message: &Message, args: Args) -> CommandResult {
let text: String = args.rest().to_string();
let defs = &urbandict::get_definitions(&text.to_string())?;
let def = &defs[0];
let _ = message.channel_id.send_message(|m| m
.embed(|e| e
.title(format!("Author: {}", def.author))
.field("Definition: ", def.definition.replace(|c| c == '[' || c == ']', ""), false)
));
let _ = message.channel_id.send_message(&ctx.http, |m| {
m.embed(|e| {
e.title(format!("Author: {}", def.author)).field(
"Definition: ",
def.definition.replace(|c| c == '[' || c == ']', ""),
false,
)
})
});
Ok(())
}
#[command]
fn owo(ctx: &mut Context, message: &Message, args: Args) -> CommandResult {
let input: String = args.rest().trim().to_string();
let _ = message.channel_id.say(&ctx.http, input.owoify());
Ok(())
}